![[BACK]](/icons/back.gif){kind=icon}
Return to machdep.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hppa64 / hppa64|
Return to machdep.c CVS log | Up to [local] / sys / arch / hppa64 / hppa64 |
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.7 2007/06/06 17:15:12 deraadt Exp $ */
2:
3: /*
4: * Copyright (c) 2005 Michael Shalayeff
5: * All rights reserved.
6: *
7: * Permission to use, copy, modify, and distribute this software for any
8: * purpose with or without fee is hereby granted, provided that the above
9: * copyright notice and this permission notice appear in all copies.
10: *
11: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
16: * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
17: * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18: */
19:
20: #include <sys/param.h>
21: #include <sys/systm.h>
22: #include <sys/signalvar.h>
23: #include <sys/kernel.h>
24: #include <sys/proc.h>
25: #include <sys/buf.h>
26: #include <sys/reboot.h>
27: #include <sys/device.h>
28: #include <sys/conf.h>
29: #include <sys/file.h>
30: #include <sys/timeout.h>
31: #include <sys/malloc.h>
32: #include <sys/mbuf.h>
33: #include <sys/msgbuf.h>
34: #include <sys/ioctl.h>
35: #include <sys/tty.h>
36: #include <sys/user.h>
37: #include <sys/exec.h>
38: #include <sys/sysctl.h>
39: #include <sys/core.h>
40: #include <sys/kcore.h>
41: #include <sys/extent.h>
42: #ifdef SYSVMSG
43: #include <sys/msg.h>
44: #endif
45:
46: #include <sys/mount.h>
47: #include <sys/syscallargs.h>
48:
49: #include <uvm/uvm.h>
50: #include <uvm/uvm_page.h>
51:
52: #include <dev/cons.h>
53: #include <dev/clock_subr.h>
54:
55: #include <machine/pdc.h>
56: #include <machine/iomod.h>
57: #include <machine/psl.h>
58: #include <machine/reg.h>
59: #include <machine/autoconf.h>
60: #include <machine/kcore.h>
61:
62: #ifdef COMPAT_HPUX
63: #include <compat/hpux/hpux.h>
64: #endif
65:
66: #ifdef DDB
67: #include <machine/db_machdep.h>
68: #include <ddb/db_access.h>
69: #include <ddb/db_sym.h>
70: #include <ddb/db_extern.h>
71: #endif
72:
73: #include <hppa/dev/cpudevs.h>
74:
75: /*
76: * Patchable buffer cache parameters
77: */
78: #ifndef BUFCACHEPERCENT
79: #define BUFCACHEPERCENT 10
80: #endif /* BUFCACHEPERCENT */
81:
82: #ifdef BUFPAGES
83: int bufpages = BUFPAGES;
84: #else
85: int bufpages = 0;
86: #endif
87: int bufcachepercent = BUFCACHEPERCENT;
88:
89: /*
90: * Different kinds of flags used throughout the kernel.
91: */
92: int cold = 1; /* unset when engine is up to go */
93: extern int msgbufmapped; /* set when safe to use msgbuf */
94:
95: /*
96: * cache configuration, for most machines is the same
97: * numbers, so it makes sense to do defines w/ numbers depending
98: * on configured cpu types in the kernel
99: */
100: int icache_stride, icache_line_mask;
101: int dcache_stride, dcache_line_mask;
102:
103: /*
104: * things to not kill
105: */
106: volatile u_int8_t *machine_ledaddr;
107: int machine_ledword, machine_leds;
108: struct cpu_info cpu0_info;
109:
110: /*
111: * CPU params (should be the same for all cpus in the system)
112: */
113: struct pdc_cache pdc_cache PDC_ALIGNMENT;
114: struct pdc_model pdc_model PDC_ALIGNMENT;
115:
116: /* w/ a little deviation should be the same for all installed cpus */
117: u_int cpu_ticksnum, cpu_ticksdenom;
118:
119: /* exported info */
120: char machine[] = MACHINE;
121: char cpu_model[128];
122: int cpu_hvers;
123: enum hppa_cpu_type cpu_type;
124: const char *cpu_typename;
125: u_int fpu_version;
126: #ifdef COMPAT_HPUX
127: int cpu_model_hpux; /* contains HPUX_SYSCONF_CPU* kind of value */
128: #endif
129:
130: dev_t bootdev;
131: int physmem, resvmem, resvphysmem, esym;
132: paddr_t avail_end;
133:
134: /*
135: * Things for MI glue to stick on.
136: */
137: struct user *proc0paddr;
138: long mem_ex_storage[EXTENT_FIXED_STORAGE_SIZE(32) / sizeof(long)];
139: struct extent *hppa_ex;
140:
141: struct vm_map *exec_map = NULL;
142: struct vm_map *phys_map = NULL;
143: /* Virtual page frame for /dev/mem (see mem.c) */
144: vaddr_t vmmap;
145:
146: void delay_init(void);
147: static __inline void fall(int, int, int, int, int);
148: void dumpsys(void);
149: void hpmc_dump(void);
150: void cpuid(void);
151:
152: /*
153: * wide used hardware params
154: */
155: struct pdc_hwtlb pdc_hwtlb PDC_ALIGNMENT;
156: struct pdc_coproc pdc_coproc PDC_ALIGNMENT;
157: struct pdc_coherence pdc_coherence PDC_ALIGNMENT;
158: struct pdc_spidb pdc_spidbits PDC_ALIGNMENT;
159: struct pdc_model pdc_model PDC_ALIGNMENT;
160:
161: #ifdef DEBUG
162: int sigdebug = 0;
163: pid_t sigpid = 0;
164: #define SDB_FOLLOW 0x01
165: #endif
166:
167: int
168: hppa_cpuspeed(int *mhz)
169: {
170: *mhz = PAGE0->mem_10msec / 10000;
171:
172: return (0);
173: }
174:
175: void
176: hppa_init(start)
177: paddr_t start;
178: {
179: extern int kernel_text;
180: int error;
181:
182: mtctl((long)&cpu0_info, 24);
183:
184: pdc_init(); /* init PDC iface, so we can call em easy */
185:
186: delay_init(); /* calculate cpu clock ratio */
187:
188: cpuid();
189:
190: /* cache parameters */
191: if ((error = pdc_call((iodcio_t)pdc, 0, PDC_CACHE, PDC_CACHE_DFLT,
192: &pdc_cache)) < 0) {
193: #ifdef DEBUG
194: printf("WARNING: PDC_CACHE error %d\n", error);
195: #endif
196: }
197:
198: dcache_line_mask = pdc_cache.dc_conf.cc_line * 16 - 1;
199: dcache_stride = pdc_cache.dc_stride;
200: icache_line_mask = pdc_cache.ic_conf.cc_line * 16 - 1;
201: icache_stride = pdc_cache.ic_stride;
202:
203: /* cache coherence params (pbably available for 8k only) */
204: error = pdc_call((iodcio_t)pdc, 0, PDC_CACHE, PDC_CACHE_SETCS,
205: &pdc_coherence, 1, 1, 1, 1);
206: #ifdef DEBUG
207: printf ("PDC_CACHE_SETCS: %d, %d, %d, %d (%d)\n",
208: pdc_coherence.ia_cst, pdc_coherence.da_cst,
209: pdc_coherence.ita_cst, pdc_coherence.dta_cst, error);
210: #endif
211: error = pdc_call((iodcio_t)pdc, 0, PDC_CACHE, PDC_CACHE_GETSPIDB,
212: &pdc_spidbits, 0, 0, 0, 0);
213: printf("SPID bits: 0x%x, error = %d\n", pdc_spidbits.spidbits, error);
214:
215: #if 0
216: TODO hpmc/toc/pfr
217: /* setup hpmc handler */
218: {
219: extern u_int hpmc_v[]; /* from locore.s */
220: register u_int *p = hpmc_v;
221:
222: if (pdc_call((iodcio_t)pdc, 0, PDC_INSTR, PDC_INSTR_DFLT, p))
223: *p = 0x08000240;
224:
225: p[6] = (u_int)&hpmc_dump;
226: p[7] = 32;
227: p[5] = -(p[0] + p[1] + p[2] + p[3] + p[4] + p[6] + p[7]);
228: }
229:
230: {
231: extern u_int hppa_toc[], hppa_toc_end[];
232: register u_int cksum, *p;
233:
234: for (cksum = 0, p = hppa_toc; p < hppa_toc_end; p++)
235: cksum += *p;
236:
237: *p = cksum;
238: PAGE0->ivec_toc = (u_int)&hppa_toc[0];
239: PAGE0->ivec_toclen = (hppa_toc_end - hppa_toc + 1) * 4;
240: }
241:
242: {
243: extern u_int hppa_pfr[], hppa_pfr_end[];
244: register u_int cksum, *p;
245:
246: for (cksum = 0, p = hppa_pfr; p < hppa_pfr_end; p++)
247: cksum += *p;
248:
249: *p = cksum;
250: PAGE0->ivec_mempf = (u_int)&hppa_pfr[0];
251: PAGE0->ivec_mempflen = (hppa_pfr_end - hppa_pfr + 1) * 4;
252: }
253: #endif
254: avail_end = trunc_page(PAGE0->imm_max_mem);
255: if (avail_end > 0x4000000)
256: avail_end = 0x4000000;
257: physmem = btoc(avail_end);
258: resvmem = btoc(((vaddr_t)&kernel_text));
259:
260: /* we hope this won't fail */
261: hppa_ex = extent_create("mem", 0, HPPA_PHYSMAP, M_DEVBUF,
262: (caddr_t)mem_ex_storage, sizeof(mem_ex_storage),
263: EX_NOCOALESCE|EX_NOWAIT);
264: if (extent_alloc_region(hppa_ex, 0, (vaddr_t)PAGE0->imm_max_mem,
265: EX_NOWAIT))
266: panic("cannot reserve main memory");
267:
268: #ifdef SYSVMSG
269: {
270: vaddr_t v;
271:
272: v = round_page(start);
273: #define valloc(name, type, num) (name) = (type *)v; v = (vaddr_t)((name)+(num))
274: valloc(msgpool, char, msginfo.msgmax);
275: valloc(msgmaps, struct msgmap, msginfo.msgseg);
276: valloc(msghdrs, struct msg, msginfo.msgtql);
277: valloc(msqids, struct msqid_ds, msginfo.msgmni);
278: #undef valloc
279: v = round_page(v);
280: bzero ((void *)start, (v - start));
281: start = v;
282: }
283: #endif
284: /* sets resvphysmem */
285: pmap_bootstrap(start);
286:
287: /* space has been reserved in pmap_bootstrap() */
288: msgbufp = (struct msgbuf *)((vaddr_t)ptoa(physmem) -
289: round_page(MSGBUFSIZE));
290: initmsgbuf((caddr_t)msgbufp, round_page(MSGBUFSIZE));
291: msgbufmapped = 1;
292:
293: /* they say PDC_COPROC might turn fault light on */
294: pdc_call((iodcio_t)pdc, 0, PDC_CHASSIS, PDC_CHASSIS_DISP,
295: PDC_OSTAT(PDC_OSTAT_RUN) | 0xCEC0);
296:
297: cpu_cpuspeed = &hppa_cpuspeed;
298:
299: #ifdef DDB
300: ddb_init();
301: if (boothowto & RB_KDB)
302: Debugger();
303: #endif
304: ptlball();
305: ficacheall();
306: fdcacheall();
307: printf("out\n");
308: }
309:
310: void
311: cpuid()
312: {
313: extern u_int fpu_enable;
314: struct pdc_cpuid pdc_cpuid PDC_ALIGNMENT;
315: int error;
316:
317: /* identify system type */
318: if ((error = pdc_call((iodcio_t)pdc, 0, PDC_MODEL, PDC_MODEL_INFO,
319: &pdc_model)) < 0) {
320: #ifdef DEBUG
321: printf("WARNING: PDC_MODEL error %d\n", error);
322: #endif
323: pdc_model.hvers = 0;
324: }
325:
326: bzero(&pdc_cpuid, sizeof(pdc_cpuid));
327: if (pdc_call((iodcio_t)pdc, 0, PDC_MODEL, PDC_MODEL_CPUID,
328: &pdc_cpuid, 0, 0, 0, 0) >= 0) {
329:
330: /* patch for old 8200 */
331: if (pdc_cpuid.version == HPPA_CPU_PCXU &&
332: pdc_cpuid.revision > 0x0d)
333: pdc_cpuid.version = HPPA_CPU_PCXUP;
334:
335: cpu_type = pdc_cpuid.version;
336: }
337:
338: /* locate coprocessors and SFUs */
339: bzero(&pdc_coproc, sizeof(pdc_coproc));
340: if ((error = pdc_call((iodcio_t)pdc, 0, PDC_COPROC, PDC_COPROC_DFLT,
341: &pdc_coproc, 0, 0, 0, 0)) < 0)
342: printf("WARNING: PDC_COPROC error %d\n", error);
343: else {
344: printf("pdc_coproc: 0x%x, 0x%x; model %x rev %x\n",
345: pdc_coproc.ccr_enable, pdc_coproc.ccr_present,
346: pdc_coproc.fpu_model, pdc_coproc.fpu_revision);
347: fpu_enable = pdc_coproc.ccr_enable & 0xc0;
348:
349: /* a kludge to detect PCXW */
350: if (pdc_coproc.fpu_model == HPPA_FPU_PCXW)
351: cpu_type = HPPA_CPU_PCXW;
352: }
353:
354: if (!cpu_type)
355: printf("WARNING: UNKNOWN CPU TYPE; GOOD LUCK\n");
356: cpu_typename = hppa_mod_info(HPPA_TYPE_CPU, cpu_type);
357:
358: if (pdc_model.arch_rev != 8)
359: panic("CANNOT RUN 64BIT KERNEL on 32BIT CPU");
360:
361: {
362: const char *p;
363: char buf[32];
364:
365: cpu_hvers = pdc_model.hvers >> 4;
366: if (!cpu_hvers) {
367: p = "(UNKNOWN)";
368: } else {
369: p = hppa_mod_info(HPPA_TYPE_BOARD, cpu_hvers);
370: if (!p) {
371: snprintf(buf, sizeof buf, "(UNKNOWN 0x%x)",
372: cpu_hvers);
373: p = buf;
374: }
375: }
376:
377: snprintf(cpu_model, sizeof cpu_model,
378: "HP 9000/%s PA-RISC 2.0", p);
379: }
380: #ifdef DEBUG
381: printf("%s\n", cpu_model);
382: #endif
383: }
384:
385: void
386: cpu_startup(void)
387: {
388: vaddr_t minaddr, maxaddr;
389:
390: /*
391: * psychodelic kingdom come
392: * ... run, run, run
393: * psychodelic kings and queens
394: * join me in this one love dream
395: */
396: printf("%s%s\n", version, cpu_model);
397: printf("real mem = %u (%u reserved for PROM, %u used by OpenBSD)\n",
398: ctob(physmem), ctob(resvmem), ctob(resvphysmem - resvmem));
399:
400: /*
401: * Determine how many buffers to allocate.
402: * We allocate bufcachepercent% of memory for buffer space.
403: */
404: if (bufpages == 0)
405: bufpages = physmem * bufcachepercent / 100;
406:
407: /* Restrict to at most 25% filled kvm */
408: if (bufpages >
409: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
410: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
411: PAGE_SIZE / 4;
412:
413: printf("here3\n");
414: /*
415: * Allocate a submap for exec arguments. This map effectively
416: * limits the number of processes exec'ing at any time.
417: */
418: minaddr = vm_map_min(kernel_map);
419: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
420: 16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
421:
422: printf("here4\n");
423: /*
424: * Allocate a submap for physio
425: */
426: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
427: VM_PHYS_SIZE, 0, FALSE, NULL);
428:
429: printf("here5\n");
430: printf("avail mem = %lu\n", ptoa(uvmexp.free));
431:
432: /*
433: * Set up buffers, so they can be used to read disk labels.
434: */
435: bufinit();
436: vmmap = uvm_km_valloc_wait(kernel_map, NBPG);
437:
438: printf("here6\n");
439: /*
440: * Configure the system.
441: */
442: if (boothowto & RB_CONFIG) {
443: #ifdef BOOT_CONFIG
444: user_config();
445: #else
446: printf("kernel does not support -c; continuing..\n");
447: #endif
448: }
449: printf("here7\n");
450: }
451:
452: /*
453: * initialize the system time from the time of day clock
454: */
455: void
456: inittodr(t)
457: time_t t;
458: {
459: struct pdc_tod tod PDC_ALIGNMENT;
460: int error, tbad = 0;
461:
462: if (t < 12*SECYR) {
463: printf ("WARNING: preposterous time in file system");
464: t = 6*SECYR + 186*SECDAY + SECDAY/2;
465: tbad = 1;
466: }
467:
468: if ((error = pdc_call((iodcio_t)pdc,
469: 1, PDC_TOD, PDC_TOD_READ, &tod, 0, 0, 0, 0, 0)))
470: printf("clock: failed to fetch (%d)\n", error);
471:
472: time.tv_sec = tod.sec;
473: time.tv_usec = tod.usec;
474:
475: if (!tbad) {
476: u_long dt;
477:
478: dt = (time.tv_sec < t)? t - time.tv_sec : time.tv_sec - t;
479:
480: if (dt < 2 * SECDAY)
481: return;
482: printf("WARNING: clock %s %ld days",
483: time.tv_sec < t? "lost" : "gained", dt / SECDAY);
484: }
485:
486: printf (" -- CHECK AND RESET THE DATE!\n");
487: }
488:
489: /*
490: * reset the time of day clock to the value in time
491: */
492: void
493: resettodr()
494: {
495: int error;
496:
497: if ((error = pdc_call((iodcio_t)pdc, 1, PDC_TOD, PDC_TOD_WRITE,
498: time.tv_sec, time.tv_usec)))
499: printf("clock: failed to save (%d)\n", error);
500: }
501:
502: /*
503: * compute cpu clock ratio such as:
504: * cpu_ticksnum / cpu_ticksdenom = t + delta
505: * delta -> 0
506: */
507: void
508: delay_init(void)
509: {
510: u_long num, denom, delta, mdelta;
511:
512: mdelta = ULONG_MAX;
513: for (denom = 1; denom < 1000; denom++) {
514: num = (PAGE0->mem_10msec * denom) / 10000;
515: delta = num * 10000 / denom - PAGE0->mem_10msec;
516: if (!delta) {
517: cpu_ticksdenom = denom;
518: cpu_ticksnum = num;
519: break;
520: } else if (delta < mdelta) {
521: cpu_ticksdenom = denom;
522: cpu_ticksnum = num;
523: mdelta = delta;
524: }
525: }
526: printf("nom=%lu denom=%lu\n", cpu_ticksnum, cpu_ticksdenom);
527: }
528:
529: void
530: delay(us)
531: u_int us;
532: {
533: u_long start, end, n;
534:
535: start = mfctl(CR_ITMR);
536: while (us) {
537: n = min(1000, us);
538: end = start + n * cpu_ticksnum / cpu_ticksdenom;
539:
540: /* N.B. Interval Timer may wrap around */
541: if (end < start)
542: do
543: start = mfctl(CR_ITMR);
544: while (start > end);
545:
546: do
547: start = mfctl(CR_ITMR);
548: while (start < end);
549:
550: us -= n;
551: }
552: }
553:
554: static __inline void
555: fall(c_base, c_count, c_loop, c_stride, data)
556: int c_base, c_count, c_loop, c_stride, data;
557: {
558: int loop;
559:
560: for (; c_count--; c_base += c_stride)
561: for (loop = c_loop; loop--; )
562: if (data)
563: __asm __volatile("fdce 0(%%sr0,%0)"
564: :: "r" (c_base));
565: else
566: __asm __volatile("fice 0(%%sr0,%0)"
567: :: "r" (c_base));
568: }
569:
570: void
571: ficacheall(void)
572: {
573: /*
574: * Flush the instruction, then data cache.
575: */
576: fall(pdc_cache.ic_base, pdc_cache.ic_count, pdc_cache.ic_loop,
577: pdc_cache.ic_stride, 0);
578: sync_caches();
579: }
580:
581: void
582: fdcacheall(void)
583: {
584: fall(pdc_cache.dc_base, pdc_cache.dc_count, pdc_cache.dc_loop,
585: pdc_cache.dc_stride, 1);
586: sync_caches();
587: }
588:
589: void
590: ptlball(void)
591: {
592: register pa_space_t sp;
593: register int i, j, k;
594:
595: /* instruction TLB */
596: sp = pdc_cache.it_sp_base;
597: for (i = 0; i < pdc_cache.it_sp_count; i++) {
598: register vaddr_t off = pdc_cache.it_off_base;
599: for (j = 0; j < pdc_cache.it_off_count; j++) {
600: for (k = 0; k < pdc_cache.it_loop; k++)
601: pitlb(sp, off);
602: off += pdc_cache.it_off_stride;
603: }
604: sp += pdc_cache.it_sp_stride;
605: }
606:
607: /* data TLB */
608: sp = pdc_cache.dt_sp_base;
609: for (i = 0; i < pdc_cache.dt_sp_count; i++) {
610: register vaddr_t off = pdc_cache.dt_off_base;
611: for (j = 0; j < pdc_cache.dt_off_count; j++) {
612: for (k = 0; k < pdc_cache.dt_loop; k++)
613: pdtlb(sp, off);
614: off += pdc_cache.dt_off_stride;
615: }
616: sp += pdc_cache.dt_sp_stride;
617: }
618: }
619:
620: void
621: boot(howto)
622: int howto;
623: {
624: /* If system is cold, just halt. */
625: if (cold) {
626: /* (Unless the user explicitly asked for reboot.) */
627: if ((howto & RB_USERREQ) == 0)
628: howto |= RB_HALT;
629: } else {
630:
631: boothowto = howto | (boothowto & RB_HALT);
632:
633: if (!(howto & RB_NOSYNC)) {
634: vfs_shutdown();
635: /*
636: * If we've been adjusting the clock, the todr
637: * will be out of synch; adjust it now unless
638: * the system was sitting in ddb.
639: */
640: if ((howto & RB_TIMEBAD) == 0)
641: resettodr();
642: else
643: printf("WARNING: not updating battery clock\n");
644: }
645:
646: /* XXX probably save howto into stable storage */
647:
648: splhigh();
649:
650: if (howto & RB_DUMP)
651: dumpsys();
652:
653: doshutdownhooks();
654: }
655:
656: /* in case we came on powerfail interrupt */
657: if (cold_hook)
658: (*cold_hook)(HPPA_COLD_COLD);
659:
660: if (howto & RB_HALT) {
661: if (howto & RB_POWERDOWN && cold_hook) {
662: printf("Powering off...");
663: DELAY(2000000);
664: (*cold_hook)(HPPA_COLD_OFF);
665: DELAY(1000000);
666: }
667:
668: printf("System halted!\n");
669: DELAY(2000000);
670: __asm __volatile("stwas %0, 0(%1)"
671: :: "r" (CMD_STOP), "r" (HPPA_LBCAST + iomod_command));
672: } else {
673: printf("rebooting...");
674: DELAY(2000000);
675: __asm __volatile(".export hppa_reset, entry\n\t"
676: ".label hppa_reset");
677: __asm __volatile("stwas %0, 0(%1)"
678: :: "r" (CMD_RESET), "r" (HPPA_LBCAST + iomod_command));
679: }
680:
681: for(;;); /* loop while bus reset is comming up */
682: /* NOTREACHED */
683: }
684:
685: u_long dumpmag = 0x8fca0101; /* magic number */
686: int dumpsize = 0; /* pages */
687: long dumplo = 0; /* blocks */
688:
689: /*
690: * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
691: */
692: int
693: cpu_dumpsize(void)
694: {
695: int size;
696:
697: size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t));
698: if (roundup(size, dbtob(1)) != dbtob(1))
699: return -1;
700:
701: return 1;
702: }
703:
704: /*
705: * Called from HPMC handler in locore
706: */
707: void
708: hpmc_dump(void)
709: {
710: printf("HPMC\n");
711:
712: cold = 0;
713: boot(RB_NOSYNC);
714: }
715:
716: int
717: cpu_dump(void)
718: {
719: long buf[dbtob(1) / sizeof (long)];
720: kcore_seg_t *segp;
721: cpu_kcore_hdr_t *cpuhdrp;
722:
723: segp = (kcore_seg_t *)buf;
724: cpuhdrp = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp)) / sizeof (long)];
725:
726: /*
727: * Generate a segment header.
728: */
729: CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
730: segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));
731:
732: /*
733: * Add the machine-dependent header info
734: */
735: /* nothing for now */
736:
737: return (bdevsw[major(dumpdev)].d_dump)
738: (dumpdev, dumplo, (caddr_t)buf, dbtob(1));
739: }
740:
741: /*
742: * Dump the kernel's image to the swap partition.
743: */
744: #define BYTES_PER_DUMP NBPG
745:
746: void
747: dumpsys(void)
748: {
749: int psize, bytes, i, n;
750: caddr_t maddr;
751: daddr64_t blkno;
752: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
753: int error;
754:
755: /* Save registers
756: savectx(&dumppcb); */
757:
758: if (dumpsize == 0)
759: dumpconf();
760: if (dumplo <= 0) {
761: printf("\ndump to dev %x not possible\n", dumpdev);
762: return;
763: }
764: printf("\ndumping to dev %x, offset %ld\n", dumpdev, dumplo);
765:
766: psize = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
767: printf("dump ");
768: if (psize == -1) {
769: printf("area unavailable\n");
770: return;
771: }
772:
773: if (!(error = cpu_dump())) {
774:
775: bytes = ctob(physmem);
776: maddr = NULL;
777: blkno = dumplo + cpu_dumpsize();
778: dump = bdevsw[major(dumpdev)].d_dump;
779: for (i = 0; i < bytes; i += n) {
780:
781: /* Print out how many MBs we are to go. */
782: n = bytes - i;
783: if (n && (n % (1024*1024)) == 0)
784: printf("%d ", n / (1024 * 1024));
785:
786: /* Limit size for next transfer. */
787: if (n > BYTES_PER_DUMP)
788: n = BYTES_PER_DUMP;
789:
790: if ((error = (*dump)(dumpdev, blkno, maddr, n)))
791: break;
792: maddr += n;
793: blkno += btodb(n);
794: }
795: }
796:
797: switch (error) {
798: case ENXIO: printf("device bad\n"); break;
799: case EFAULT: printf("device not ready\n"); break;
800: case EINVAL: printf("area improper\n"); break;
801: case EIO: printf("i/o error\n"); break;
802: case EINTR: printf("aborted from console\n"); break;
803: case 0: printf("succeeded\n"); break;
804: default: printf("error %d\n", error); break;
805: }
806: }
807:
808: /* bcopy(), error on fault */
809: int
810: kcopy(from, to, size)
811: const void *from;
812: void *to;
813: size_t size;
814: {
815: return spcopy(HPPA_SID_KERNEL, from, HPPA_SID_KERNEL, to, size);
816: }
817:
818: int
819: copystr(src, dst, size, lenp)
820: const void *src;
821: void *dst;
822: size_t size;
823: size_t *lenp;
824: {
825: return spstrcpy(HPPA_SID_KERNEL, src, HPPA_SID_KERNEL, dst, size, lenp);
826: }
827:
828: int
829: copyinstr(src, dst, size, lenp)
830: const void *src;
831: void *dst;
832: size_t size;
833: size_t *lenp;
834: {
835: return spstrcpy(curproc->p_addr->u_pcb.pcb_space, src,
836: HPPA_SID_KERNEL, dst, size, lenp);
837: }
838:
839:
840: int
841: copyoutstr(src, dst, size, lenp)
842: const void *src;
843: void *dst;
844: size_t size;
845: size_t *lenp;
846: {
847: return spstrcpy(HPPA_SID_KERNEL, src,
848: curproc->p_addr->u_pcb.pcb_space, dst, size, lenp);
849: }
850:
851:
852: int
853: copyin(src, dst, size)
854: const void *src;
855: void *dst;
856: size_t size;
857: {
858: return spcopy(curproc->p_addr->u_pcb.pcb_space, src,
859: HPPA_SID_KERNEL, dst, size);
860: }
861:
862: int
863: copyout(src, dst, size)
864: const void *src;
865: void *dst;
866: size_t size;
867: {
868: return spcopy(HPPA_SID_KERNEL, src,
869: curproc->p_addr->u_pcb.pcb_space, dst, size);
870: }
871:
872: /*
873: * Set registers on exec.
874: */
875: void
876: setregs(p, pack, stack, retval)
877: struct proc *p;
878: struct exec_package *pack;
879: u_long stack;
880: register_t *retval;
881: {
882: extern paddr_t fpu_curpcb; /* from locore.S */
883: struct trapframe *tf = p->p_md.md_regs;
884: struct pcb *pcb = &p->p_addr->u_pcb;
885: register_t zero;
886:
887: tf->tf_flags = TFF_SYS|TFF_LAST;
888: tf->tf_iioq[1] = 4 +
889: (tf->tf_iioq[0] = pack->ep_entry | HPPA_PC_PRIV_USER);
890: tf->tf_rp = 0;
891: tf->tf_args[0] = (u_long)PS_STRINGS;
892: tf->tf_args[1] = tf->tf_args[2] = 0; /* XXX dynload stuff */
893:
894: /* setup terminal stack frame */
895: stack = (stack + 0x1f) & ~0x1f;
896: tf->tf_r3 = stack;
897: tf->tf_sp = stack += HPPA_FRAME_SIZE;
898: tf->tf_ret1 = stack - 16; /* ap */
899: zero = 0;
900: copyout(&zero, (caddr_t)(stack - HPPA_FRAME_SIZE), sizeof(register_t));
901: copyout(&zero, (caddr_t)(stack + HPPA_FRAME_RP), sizeof(register_t));
902:
903: /* reset any of the pending FPU exceptions */
904: if (tf->tf_cr30 == fpu_curpcb) {
905: fpu_exit();
906: fpu_curpcb = 0;
907: }
908: pcb->pcb_fpregs[0] = ((u_int64_t)HPPA_FPU_INIT) << 32;
909: pcb->pcb_fpregs[1] = 0;
910: pcb->pcb_fpregs[2] = 0;
911: pcb->pcb_fpregs[3] = 0;
912: fdcache(HPPA_SID_KERNEL, (vaddr_t)pcb->pcb_fpregs, 8 * 4);
913:
914: retval[1] = 0;
915: }
916:
917: /*
918: * Send an interrupt to process.
919: */
920: void
921: sendsig(catcher, sig, mask, code, type, val)
922: sig_t catcher;
923: int sig, mask;
924: u_long code;
925: int type;
926: union sigval val;
927: {
928: extern paddr_t fpu_curpcb; /* from locore.S */
929: extern u_int fpu_enable;
930: struct proc *p = curproc;
931: struct trapframe *tf = p->p_md.md_regs;
932: struct sigacts *psp = p->p_sigacts;
933: struct sigcontext ksc;
934: siginfo_t ksi;
935: register_t scp, sip, zero;
936: int sss;
937:
938: /* TODO sendsig */
939:
940: #ifdef DEBUG
941: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
942: printf("sendsig: %s[%d] sig %d catcher %p\n",
943: p->p_comm, p->p_pid, sig, catcher);
944: #endif
945:
946: /* flush the FPU ctx first */
947: if (tf->tf_cr30 == fpu_curpcb) {
948: mtctl(fpu_enable, CR_CCR);
949: fpu_save(fpu_curpcb);
950: /* fpu_curpcb = 0; only needed if fpregs are preset */
951: mtctl(0, CR_CCR);
952: }
953:
954: ksc.sc_onstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
955:
956: /*
957: * Allocate space for the signal handler context.
958: */
959: if ((psp->ps_flags & SAS_ALTSTACK) && !ksc.sc_onstack &&
960: (psp->ps_sigonstack & sigmask(sig))) {
961: scp = (register_t)psp->ps_sigstk.ss_sp;
962: psp->ps_sigstk.ss_flags |= SS_ONSTACK;
963: } else
964: scp = (tf->tf_sp + 63) & ~63;
965:
966: sss = (sizeof(ksc) + 63) & ~63;
967: sip = 0;
968: if (psp->ps_siginfo & sigmask(sig)) {
969: sip = scp + sizeof(ksc);
970: sss += (sizeof(ksi) + 63) & ~63;
971: }
972:
973: #ifdef DEBUG
974: if ((tf->tf_iioq[0] & ~PAGE_MASK) == SYSCALLGATE)
975: printf("sendsig: interrupted syscall at 0x%x:0x%x, flags %b\n",
976: tf->tf_iioq[0], tf->tf_iioq[1], tf->tf_ipsw, PSL_BITS);
977: #endif
978:
979: ksc.sc_mask = mask;
980: ksc.sc_fp = scp + sss;
981: ksc.sc_ps = tf->tf_ipsw;
982: ksc.sc_pcoqh = tf->tf_iioq[0];
983: ksc.sc_pcoqt = tf->tf_iioq[1];
984: bcopy(tf, &ksc.sc_regs[0], 32*8);
985: ksc.sc_regs[0] = tf->tf_sar;
986: bcopy(p->p_addr->u_pcb.pcb_fpregs, ksc.sc_fpregs,
987: sizeof(ksc.sc_fpregs));
988:
989: sss += HPPA_FRAME_SIZE;
990: tf->tf_args[0] = sig;
991: tf->tf_args[1] = sip;
992: tf->tf_args[2] = tf->tf_r4 = scp;
993: tf->tf_args[3] = (register_t)catcher;
994: tf->tf_sp = scp + sss;
995: tf->tf_ipsw &= ~(PSL_N|PSL_B);
996: tf->tf_iioq[0] = HPPA_PC_PRIV_USER | p->p_sigcode;
997: tf->tf_iioq[1] = tf->tf_iioq[0] + 4;
998: /* disable tracing in the trapframe */
999:
1000: #ifdef DEBUG
1001: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
1002: printf("sendsig(%d): sig %d scp %p fp %p sp 0x%x\n",
1003: p->p_pid, sig, scp, ksc.sc_fp, (register_t)scp + sss);
1004: #endif
1005:
1006: if (copyout(&ksc, (void *)scp, sizeof(ksc)))
1007: sigexit(p, SIGILL);
1008:
1009: if (sip) {
1010: initsiginfo(&ksi, sig, code, type, val);
1011: if (copyout(&ksi, (void *)sip, sizeof(ksi)))
1012: sigexit(p, SIGILL);
1013: }
1014:
1015: zero = 0;
1016: if (copyout(&zero, (caddr_t)scp + sss - HPPA_FRAME_SIZE,
1017: sizeof(register_t)))
1018: sigexit(p, SIGILL);
1019:
1020: #ifdef DEBUG
1021: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
1022: printf("sendsig(%d): pc 0x%x, catcher 0x%x\n", p->p_pid,
1023: tf->tf_iioq[0], tf->tf_args[3]);
1024: #endif
1025: }
1026:
1027: int
1028: sys_sigreturn(p, v, retval)
1029: struct proc *p;
1030: void *v;
1031: register_t *retval;
1032: {
1033: extern paddr_t fpu_curpcb; /* from locore.S */
1034: struct sys_sigreturn_args /* {
1035: syscallarg(struct sigcontext *) sigcntxp;
1036: } */ *uap = v;
1037: struct sigcontext *scp, ksc;
1038: struct trapframe *tf = p->p_md.md_regs;
1039: int error;
1040:
1041: /* TODO sigreturn */
1042:
1043: scp = SCARG(uap, sigcntxp);
1044: #ifdef DEBUG
1045: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
1046: printf("sigreturn: pid %d, scp %p\n", p->p_pid, scp);
1047: #endif
1048:
1049: /* flush the FPU ctx first */
1050: if (tf->tf_cr30 == fpu_curpcb) {
1051: fpu_exit();
1052: fpu_curpcb = 0;
1053: }
1054:
1055: if ((error = copyin((caddr_t)scp, (caddr_t)&ksc, sizeof ksc)))
1056: return (error);
1057:
1058: #define PSL_MBS (PSL_C|PSL_Q|PSL_P|PSL_D|PSL_I)
1059: #define PSL_MBZ (PSL_Y|PSL_Z|PSL_S|PSL_X|PSL_M|PSL_R)
1060: if ((ksc.sc_ps & (PSL_MBS|PSL_MBZ)) != PSL_MBS)
1061: return (EINVAL);
1062:
1063: if (ksc.sc_onstack)
1064: p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
1065: else
1066: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
1067: p->p_sigmask = ksc.sc_mask &~ sigcantmask;
1068:
1069: tf->tf_sar = ksc.sc_regs[0];
1070: ksc.sc_regs[0] = tf->tf_flags;
1071: bcopy(&ksc.sc_regs[0], tf, 32*8);
1072: bcopy(ksc.sc_fpregs, p->p_addr->u_pcb.pcb_fpregs,
1073: sizeof(ksc.sc_fpregs));
1074: fdcache(HPPA_SID_KERNEL, (vaddr_t)p->p_addr->u_pcb.pcb_fpregs,
1075: sizeof(ksc.sc_fpregs));
1076:
1077: tf->tf_iioq[0] = ksc.sc_pcoqh;
1078: tf->tf_iioq[1] = ksc.sc_pcoqt;
1079: tf->tf_ipsw = ksc.sc_ps;
1080:
1081: #ifdef DEBUG
1082: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
1083: printf("sigreturn(%d): returns\n", p->p_pid);
1084: #endif
1085: return (EJUSTRETURN);
1086: }
1087:
1088: /*
1089: * machine dependent system variables.
1090: */
1091: int
1092: cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
1093: int *name;
1094: u_int namelen;
1095: void *oldp;
1096: size_t *oldlenp;
1097: void *newp;
1098: size_t newlen;
1099: struct proc *p;
1100: {
1101: dev_t consdev;
1102:
1103: /* all sysctl names at this level are terminal */
1104: if (namelen != 1)
1105: return (ENOTDIR); /* overloaded */
1106: switch (name[0]) {
1107: case CPU_CONSDEV:
1108: if (cn_tab != NULL)
1109: consdev = cn_tab->cn_dev;
1110: else
1111: consdev = NODEV;
1112: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
1113: sizeof consdev));
1114: default:
1115: return (EOPNOTSUPP);
1116: }
1117: /* NOTREACHED */
1118: }
1119:
1120:
1121: /*
1122: * consinit:
1123: * initialize the system console.
1124: */
1125: void
1126: consinit(void)
1127: {
1128: static int initted;
1129:
1130: if (!initted) {
1131: initted++;
1132: cninit();
1133: }
1134: }
1135:
1136: #ifdef DIAGNOSTIC
1137: void
1138: splassert_check(int wantipl, const char *func)
1139: {
1140: extern int cpl; /* from locoore.s */
1141:
1142: if (cpl < wantipl) {
1143: splassert_fail(wantipl, cpl, func);
1144: }
1145: }
1146: #endif