machdep.c revision 1.66 
1/*	$NetBSD: machdep.c,v 1.66 2001/05/28 20:56:54 chs Exp $	*/
2
3/*
4 * Copyright (c) 1988 University of Utah.
5 * Copyright (c) 1982, 1986, 1990, 1993
6 *	The Regents of the University of California.  All rights reserved.
7 *
8 * This code is derived from software contributed to Berkeley by
9 * the Systems Programming Group of the University of Utah Computer
10 * Science Department.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 *    notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 *    notice, this list of conditions and the following disclaimer in the
19 *    documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 *    must display the following acknowledgement:
22 *	This product includes software developed by the University of
23 *	California, Berkeley and its contributors.
24 * 4. Neither the name of the University nor the names of its contributors
25 *    may be used to endorse or promote products derived from this software
26 *    without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38 * SUCH DAMAGE.
39 *
40 *	from: Utah Hdr: machdep.c 1.74 92/12/20
41 *	from: @(#)machdep.c	8.10 (Berkeley) 4/20/94
42 */
43
44#include "opt_ddb.h"
45
46#include <sys/param.h>
47#include <sys/systm.h>
48#include <sys/kernel.h>
49#include <sys/map.h>
50#include <sys/proc.h>
51#include <sys/buf.h>
52#include <sys/reboot.h>
53#include <sys/conf.h>
54#include <sys/file.h>
55#include <sys/clist.h>
56#include <sys/device.h>
57#include <sys/malloc.h>
58#include <sys/mbuf.h>
59#include <sys/msgbuf.h>
60#include <sys/ioctl.h>
61#include <sys/tty.h>
62#include <sys/mount.h>
63#include <sys/user.h>
64#include <sys/exec.h>
65#include <sys/core.h>
66#include <sys/kcore.h>
67#include <sys/vnode.h>
68#include <sys/syscallargs.h>
69#ifdef	KGDB
70#include <sys/kgdb.h>
71#endif
72
73#include <uvm/uvm_extern.h>
74
75#include <sys/sysctl.h>
76
77#include <dev/cons.h>
78
79#include <machine/cpu.h>
80#include <machine/dvma.h>
81#include <machine/idprom.h>
82#include <machine/kcore.h>
83#include <machine/reg.h>
84#include <machine/psl.h>
85#include <machine/pte.h>
86
87#if defined(DDB)
88#include <machine/db_machdep.h>
89#include <ddb/db_sym.h>
90#include <ddb/db_extern.h>
91#endif
92
93#include <sun3/sun3/machdep.h>
94
95/* Defined in locore.s */
96extern char kernel_text[];
97/* Defined by the linker */
98extern char etext[];
99
100/* Our exported CPU info; we can have only one. */
101struct cpu_info cpu_info_store;
102
103vm_map_t exec_map = NULL;
104vm_map_t mb_map = NULL;
105vm_map_t phys_map = NULL;
106
107int	physmem;
108int	fputype;
109caddr_t	msgbufaddr;
110
111/* Virtual page frame for /dev/mem (see mem.c) */
112vm_offset_t vmmap;
113
114/*
115 * safepri is a safe priority for sleep to set for a spin-wait
116 * during autoconfiguration or after a panic.
117 */
118int	safepri = PSL_LOWIPL;
119
120u_char cpu_machine_id = 0;
121char *cpu_string = NULL;
122int cpu_has_vme = 0;
123int has_iocache = 0;
124
125vaddr_t dumppage;
126
127static void identifycpu __P((void));
128static void initcpu __P((void));
129
130/*
131 * Console initialization: called early on from main,
132 * before vm init or cpu_startup.  This system is able
133 * to use the console for output immediately (via PROM)
134 * but can not use it for input until after this point.
135 */
136void
137consinit()
138{
139
140	/*
141	 * Switch from the PROM console (output only)
142	 * to our own console driver.
143	 */
144	cninit();
145
146#ifdef DDB
147	{
148		extern int nsym;
149		extern char *ssym, *esym;
150
151		ddb_init(nsym, ssym, esym);
152	}
153#endif DDB
154
155	/*
156	 * Now that the console can do input as well as
157	 * output, consider stopping for a debugger.
158	 */
159	if (boothowto & RB_KDB) {
160#ifdef KGDB
161		/* XXX - Ask on console for kgdb_dev? */
162		/* Note: this will just return if kgdb_dev==NODEV */
163		kgdb_connect(1);
164#else	/* KGDB */
165		/* Either DDB or no debugger (just PROM). */
166		Debugger();
167#endif	/* KGDB */
168	}
169}
170
171/*
172 * cpu_startup: allocate memory for variable-sized tables,
173 * initialize cpu, and do autoconfiguration.
174 *
175 * This is called early in init_main.c:main(), after the
176 * kernel memory allocator is ready for use, but before
177 * the creation of processes 1,2, and mountroot, etc.
178 */
179void
180cpu_startup()
181{
182	caddr_t v;
183	int sz, i;
184	vm_size_t size;
185	int base, residual;
186	vm_offset_t minaddr, maxaddr;
187	char pbuf[9];
188
189	/*
190	 * Initialize message buffer (for kernel printf).
191	 * This is put in physical page zero so it will
192	 * always be in the same place after a reboot.
193	 * Its mapping was prepared in pmap_bootstrap().
194	 * Also, offset some to avoid PROM scribbles.
195	 */
196	v = (caddr_t) KERNBASE;
197	msgbufaddr = (caddr_t)(v + MSGBUFOFF);
198	initmsgbuf(msgbufaddr, MSGBUFSIZE);
199
200	/*
201	 * Good {morning,afternoon,evening,night}.
202	 */
203	printf(version);
204	identifycpu();
205	initfpu();	/* also prints FPU type */
206
207	format_bytes(pbuf, sizeof(pbuf), ctob(physmem));
208	printf("total memory = %s\n", pbuf);
209
210	/*
211	 * Get scratch page for dumpsys().
212	 */
213	if ((dumppage = uvm_km_alloc(kernel_map, NBPG)) == 0)
214		panic("startup: alloc dumppage");
215
216	/*
217	 * Find out how much space we need, allocate it,
218	 * and then give everything true virtual addresses.
219	 */
220	sz = (int)allocsys(NULL, NULL);
221	if ((v = (caddr_t)uvm_km_alloc(kernel_map, round_page(sz))) == 0)
222		panic("startup: no room for tables");
223	if (allocsys(v, NULL) - v != sz)
224		panic("startup: table size inconsistency");
225
226	/*
227	 * Now allocate buffers proper.  They are different than the above
228	 * in that they usually occupy more virtual memory than physical.
229	 */
230	size = MAXBSIZE * nbuf;
231	if (uvm_map(kernel_map, (vm_offset_t *) &buffers, round_page(size),
232		    NULL, UVM_UNKNOWN_OFFSET, 0,
233		    UVM_MAPFLAG(UVM_PROT_NONE, UVM_PROT_NONE, UVM_INH_NONE,
234				UVM_ADV_NORMAL, 0)) != 0)
235		panic("startup: cannot allocate VM for buffers");
236	minaddr = (vm_offset_t)buffers;
237	if ((bufpages / nbuf) >= btoc(MAXBSIZE)) {
238		/* don't want to alloc more physical mem than needed */
239		bufpages = btoc(MAXBSIZE) * nbuf;
240	}
241	base = bufpages / nbuf;
242	residual = bufpages % nbuf;
243	for (i = 0; i < nbuf; i++) {
244		vm_size_t curbufsize;
245		vm_offset_t curbuf;
246		struct vm_page *pg;
247
248		/*
249		 * Each buffer has MAXBSIZE bytes of VM space allocated.  Of
250		 * that MAXBSIZE space, we allocate and map (base+1) pages
251		 * for the first "residual" buffers, and then we allocate
252		 * "base" pages for the rest.
253		 */
254		curbuf = (vm_offset_t) buffers + (i * MAXBSIZE);
255		curbufsize = NBPG * ((i < residual) ? (base+1) : base);
256
257		while (curbufsize) {
258			pg = uvm_pagealloc(NULL, 0, NULL, 0);
259			if (pg == NULL)
260				panic("cpu_startup: not enough memory for "
261				    "buffer cache");
262			pmap_kenter_pa(curbuf, VM_PAGE_TO_PHYS(pg),
263				       VM_PROT_READ|VM_PROT_WRITE);
264			curbuf += PAGE_SIZE;
265			curbufsize -= PAGE_SIZE;
266		}
267	}
268	pmap_update();
269
270	/*
271	 * Allocate a submap for exec arguments.  This map effectively
272	 * limits the number of processes exec'ing at any time.
273	 */
274	exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
275				   16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
276
277	/*
278	 * We don't use a submap for physio, and use a separate map
279	 * for DVMA allocations.  Our vmapbuf just maps pages into
280	 * the kernel map (any kernel mapping is OK) and then the
281	 * device drivers clone the kernel mappings into DVMA space.
282	 */
283
284	/*
285	 * Finally, allocate mbuf cluster submap.
286	 */
287	mb_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
288				 nmbclusters * mclbytes, VM_MAP_INTRSAFE,
289				 FALSE, NULL);
290
291	format_bytes(pbuf, sizeof(pbuf), ptoa(uvmexp.free));
292	printf("avail memory = %s\n", pbuf);
293	format_bytes(pbuf, sizeof(pbuf), bufpages * NBPG);
294	printf("using %d buffers containing %s of memory\n", nbuf, pbuf);
295
296	/*
297	 * Tell the VM system that writing to kernel text isn't allowed.
298	 * If we don't, we might end up COW'ing the text segment!
299	 */
300	if (uvm_map_protect(kernel_map, (vm_offset_t) kernel_text,
301	    m68k_trunc_page((vm_offset_t) etext),
302	    UVM_PROT_READ|UVM_PROT_EXEC, TRUE) != 0)
303		panic("can't protect kernel text");
304
305	/*
306	 * Allocate a virtual page (for use by /dev/mem)
307	 * This page is handed to pmap_enter() therefore
308	 * it has to be in the normal kernel VA range.
309	 */
310	vmmap = uvm_km_valloc_wait(kernel_map, NBPG);
311
312	/*
313	 * Create the DVMA maps.
314	 */
315	dvma_init();
316
317	/*
318	 * Set up CPU-specific registers, cache, etc.
319	 */
320	initcpu();
321
322	/*
323	 * Set up buffers, so they can be used to read disk labels.
324	 */
325	bufinit();
326}
327
328/*
329 * Set registers on exec.
330 */
331void
332setregs(p, pack, stack)
333	struct proc *p;
334	struct exec_package *pack;
335	u_long stack;
336{
337	struct trapframe *tf = (struct trapframe *)p->p_md.md_regs;
338
339	tf->tf_sr = PSL_USERSET;
340	tf->tf_pc = pack->ep_entry & ~1;
341	tf->tf_regs[D0] = 0;
342	tf->tf_regs[D1] = 0;
343	tf->tf_regs[D2] = 0;
344	tf->tf_regs[D3] = 0;
345	tf->tf_regs[D4] = 0;
346	tf->tf_regs[D5] = 0;
347	tf->tf_regs[D6] = 0;
348	tf->tf_regs[D7] = 0;
349	tf->tf_regs[A0] = 0;
350	tf->tf_regs[A1] = 0;
351	tf->tf_regs[A2] = (int)PS_STRINGS;
352	tf->tf_regs[A3] = 0;
353	tf->tf_regs[A4] = 0;
354	tf->tf_regs[A5] = 0;
355	tf->tf_regs[A6] = 0;
356	tf->tf_regs[SP] = stack;
357
358	/* restore a null state frame */
359	p->p_addr->u_pcb.pcb_fpregs.fpf_null = 0;
360	if (fputype)
361		m68881_restore(&p->p_addr->u_pcb.pcb_fpregs);
362
363	p->p_md.md_flags = 0;
364}
365
366/*
367 * Info for CTL_HW
368 */
369char	machine[16] = MACHINE;		/* from <machine/param.h> */
370char	kernel_arch[16] = "sun3x";	/* XXX needs a sysctl node */
371char	cpu_model[120];
372
373/*
374 * XXX - Should empirically estimate the divisor...
375 * Note that the value of delay_divisor is roughly
376 * 2048 / cpuclock	(where cpuclock is in MHz).
377 */
378int delay_divisor = 62;		/* assume the fastest (33 MHz) */
379
380void
381identifycpu()
382{
383	u_char machtype;
384
385	machtype = identity_prom.idp_machtype;
386	if ((machtype & IDM_ARCH_MASK) != IDM_ARCH_SUN3X) {
387		printf("Bad IDPROM arch!\n");
388		sunmon_abort();
389	}
390
391	cpu_machine_id = machtype;
392	switch (cpu_machine_id) {
393
394	case SUN3X_MACH_80:
395		cpu_string = "80";  	/* Hydra */
396		delay_divisor = 102;	/* 20 MHz */
397		cpu_has_vme = FALSE;
398		break;
399
400	case SUN3X_MACH_470:
401		cpu_string = "470"; 	/* Pegasus */
402		delay_divisor = 62; 	/* 33 MHz */
403		cpu_has_vme = TRUE;
404		break;
405
406	default:
407		printf("unknown sun3x model\n");
408		sunmon_abort();
409	}
410
411	/* Other stuff? (VAC, mc6888x version, etc.) */
412	/* Note: miniroot cares about the kernel_arch part. */
413	sprintf(cpu_model, "%s %s", kernel_arch, cpu_string);
414
415	printf("Model: %s\n", cpu_model);
416}
417
418/*
419 * machine dependent system variables.
420 */
421int
422cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
423	int *name;
424	u_int namelen;
425	void *oldp;
426	size_t *oldlenp;
427	void *newp;
428	size_t newlen;
429	struct proc *p;
430{
431	int error;
432	dev_t consdev;
433
434	/* all sysctl names at this level are terminal */
435	if (namelen != 1)
436		return (ENOTDIR);		/* overloaded */
437
438	switch (name[0]) {
439	case CPU_CONSDEV:
440		if (cn_tab != NULL)
441			consdev = cn_tab->cn_dev;
442		else
443			consdev = NODEV;
444		error = sysctl_rdstruct(oldp, oldlenp, newp,
445		    &consdev, sizeof consdev);
446		break;
447
448#if 0	/* XXX - Not yet... */
449	case CPU_ROOT_DEVICE:
450		error = sysctl_rdstring(oldp, oldlenp, newp, root_device);
451		break;
452
453	case CPU_BOOTED_KERNEL:
454		error = sysctl_rdstring(oldp, oldlenp, newp, booted_kernel);
455		break;
456#endif
457
458	default:
459		error = EOPNOTSUPP;
460	}
461	return (error);
462}
463
464/* See: sig_machdep.c */
465
466/*
467 * Do a sync in preparation for a reboot.
468 * XXX - This could probably be common code.
469 * XXX - And now, most of it is in vfs_shutdown()
470 * XXX - Put waittime checks in there too?
471 */
472int waittime = -1;	/* XXX - Who else looks at this? -gwr */
473static void
474reboot_sync __P((void))
475{
476
477	/* Check waittime here to localize its use to this function. */
478	if (waittime >= 0)
479		return;
480	waittime = 0;
481	vfs_shutdown();
482}
483
484/*
485 * Common part of the BSD and SunOS reboot system calls.
486 */
487__dead void
488cpu_reboot(howto, user_boot_string)
489	int howto;
490	char *user_boot_string;
491{
492	/* Note: this string MUST be static! */
493	static char bootstr[128];
494	char *p;
495
496	/* If system is cold, just halt. (early panic?) */
497	if (cold)
498		goto haltsys;
499
500	/* Un-blank the screen if appropriate. */
501	cnpollc(1);
502
503	if ((howto & RB_NOSYNC) == 0) {
504		reboot_sync();
505		/*
506		 * If we've been adjusting the clock, the todr
507		 * will be out of synch; adjust it now.
508		 *
509		 * XXX - However, if the kernel has been sitting in ddb,
510		 * the time will be way off, so don't set the HW clock!
511		 * XXX - Should do sanity check against HW clock. -gwr
512		 */
513		/* resettodr(); */
514	}
515
516	/* Disable interrupts. */
517	splhigh();
518
519	/* Write out a crash dump if asked. */
520	if (howto & RB_DUMP)
521		dumpsys();
522
523	/* run any shutdown hooks */
524	doshutdownhooks();
525
526	if (howto & RB_HALT) {
527	haltsys:
528		printf("halted.\n");
529		sunmon_halt();
530	}
531
532	/*
533	 * Automatic reboot.
534	 */
535	if (user_boot_string)
536		strncpy(bootstr, user_boot_string, sizeof(bootstr));
537	else {
538		/*
539		 * Build our own boot string with an empty
540		 * boot device/file and (maybe) some flags.
541		 * The PROM will supply the device/file name.
542		 */
543		p = bootstr;
544		*p = '\0';
545		if (howto & (RB_KDB|RB_ASKNAME|RB_SINGLE)) {
546			/* Append the boot flags. */
547			*p++ = ' ';
548			*p++ = '-';
549			if (howto & RB_KDB)
550				*p++ = 'd';
551			if (howto & RB_ASKNAME)
552				*p++ = 'a';
553			if (howto & RB_SINGLE)
554				*p++ = 's';
555			*p = '\0';
556		}
557	}
558	printf("rebooting...\n");
559	sunmon_reboot(bootstr);
560	for (;;) ;
561	/*NOTREACHED*/
562}
563
564/*
565 * These variables are needed by /sbin/savecore
566 */
567u_long	dumpmag = 0x8fca0101;	/* magic number */
568int 	dumpsize = 0;		/* pages */
569long	dumplo = 0; 		/* blocks */
570
571/*
572 * This is called by main to set dumplo, dumpsize.
573 * Dumps always skip the first NBPG of disk space
574 * in case there might be a disk label stored there.
575 * If there is extra space, put dump at the end to
576 * reduce the chance that swapping trashes it.
577 */
578void
579cpu_dumpconf()
580{
581	int nblks;	/* size of dump area */
582	int maj;
583	int (*getsize)__P((dev_t));
584
585	/* Validate space in page zero for the kcore header. */
586	if (MSGBUFOFF < (sizeof(kcore_seg_t) + sizeof(cpu_kcore_hdr_t))) {
587		printf("%d %d\n",
588MSGBUFOFF, (sizeof(kcore_seg_t) + sizeof(cpu_kcore_hdr_t)));
589		panic("cpu_dumpconf: MSGBUFOFF too small");
590	}
591
592	if (dumpdev == NODEV)
593		return;
594
595	maj = major(dumpdev);
596	if (maj < 0 || maj >= nblkdev)
597		panic("dumpconf: bad dumpdev=0x%x", dumpdev);
598	getsize = bdevsw[maj].d_psize;
599	if (getsize == NULL)
600		return;
601	nblks = (*getsize)(dumpdev);
602	if (nblks <= ctod(1))
603		return;
604
605	/* Position dump image near end of space, page aligned. */
606	dumpsize = physmem; 	/* pages */
607	dumplo = nblks - ctod(dumpsize);
608	dumplo &= ~(ctod(1)-1);
609
610	/* If it does not fit, truncate it by moving dumplo. */
611	/* Note: Must force signed comparison. */
612	if (dumplo < ((long)ctod(1))) {
613		dumplo = ctod(1);
614		dumpsize = dtoc(nblks - dumplo);
615	}
616}
617
618/* Note: gdb looks for "dumppcb" in a kernel crash dump. */
619struct pcb dumppcb;
620
621/*
622 * Write a crash dump.  The format while in swap is:
623 *   kcore_seg_t cpu_hdr;
624 *   cpu_kcore_hdr_t cpu_data;
625 *   padding (NBPG-sizeof(kcore_seg_t))
626 *   pagemap (2*NBPG)
627 *   physical memory...
628 */
629void
630dumpsys()
631{
632	struct bdevsw *dsw;
633	kcore_seg_t *kseg_p;
634	cpu_kcore_hdr_t *chdr_p;
635	struct sun3x_kcore_hdr *sh;
636	phys_ram_seg_t *crs_p;
637	char *vaddr;
638	vm_offset_t paddr;
639	int psize, todo, seg, segsz;
640	daddr_t blkno;
641	int error = 0;
642
643	if (dumpdev == NODEV)
644		return;
645
646	/*
647	 * For dumps during autoconfiguration,
648	 * if dump device has already configured...
649	 */
650	if (dumpsize == 0)
651		cpu_dumpconf();
652	if (dumplo <= 0) {
653		printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
654		    minor(dumpdev));
655		return;
656	}
657	savectx(&dumppcb);
658
659	dsw = &bdevsw[major(dumpdev)];
660	psize = (*(dsw->d_psize))(dumpdev);
661	if (psize == -1) {
662		printf("dump area unavailable\n");
663		return;
664	}
665
666	printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
667	    minor(dumpdev), dumplo);
668
669	/*
670	 * We put the dump header is in physical page zero,
671	 * so there is no extra work here to write it out.
672	 * All we do is initialize the header.
673	 */
674
675	/* Set pointers to all three parts. */
676	kseg_p = (kcore_seg_t *)dumppage;
677	chdr_p = (cpu_kcore_hdr_t *)(kseg_p + 1);
678	sh = &chdr_p->un._sun3x;
679
680	/* Fill in kcore_seg_t part. */
681	CORE_SETMAGIC(*kseg_p, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
682	kseg_p->c_size = sizeof(*chdr_p);
683
684	/* Fill in cpu_kcore_hdr_t part. */
685	strncpy(chdr_p->name, kernel_arch, sizeof(chdr_p->name));
686	chdr_p->page_size = NBPG;
687	chdr_p->kernbase = KERNBASE;
688
689	/* Fill in the sun3x_kcore_hdr part. */
690	pmap_kcore_hdr(sh);
691
692	/*
693	 * Now dump physical memory.  Note that physical memory
694	 * might NOT be congiguous, so do it by segments.
695	 */
696
697	blkno = dumplo;
698	todo = dumpsize;	/* pages */
699	vaddr = (char *)vmmap;	/* Borrow /dev/mem VA */
700
701	for (seg = 0; seg < SUN3X_NPHYS_RAM_SEGS; seg++) {
702		crs_p = &sh->ram_segs[seg];
703		paddr = crs_p->start;
704		segsz = crs_p->size;
705		/*
706		 * Our header lives in the first little bit of
707		 * physical memory (not written separately), so
708		 * we have to adjust the first ram segment size
709		 * and start address to reflect the stolen RAM.
710		 * (Nothing interesing in that RAM anyway 8^).
711		 */
712		if (seg == 0) {
713			int adj = sizeof(*kseg_p) + sizeof(*chdr_p);
714			crs_p->start += adj;
715			crs_p->size  -= adj;
716		}
717
718		while (todo && (segsz > 0)) {
719
720			/* Print pages left after every 16. */
721			if ((todo & 0xf) == 0)
722				printf("\r%4d", todo);
723
724			/* Make a temporary mapping for the page. */
725			pmap_enter(pmap_kernel(), vmmap, paddr | PMAP_NC,
726					   VM_PROT_READ, 0);
727			pmap_update();
728			error = (*dsw->d_dump)(dumpdev, blkno, vaddr, NBPG);
729			pmap_remove(pmap_kernel(), vmmap, vmmap + NBPG);
730			pmap_update();
731			if (error)
732				goto fail;
733			paddr += NBPG;
734			segsz -= NBPG;
735			blkno += btodb(NBPG);
736			todo--;
737		}
738	}
739	printf("\rdump succeeded\n");
740	return;
741fail:
742	printf(" dump error=%d\n", error);
743}
744
745static void
746initcpu()
747{
748	/* XXX: Enable RAM parity/ECC checking? */
749	/* XXX: parityenable(); */
750
751#ifdef	HAVECACHE
752	cache_enable();
753#endif
754}
755
756/* straptrap() in trap.c */
757
758/* from hp300: badaddr() */
759/* peek_byte(), peek_word() moved to bus_subr.c */
760
761/* XXX: parityenable() ? */
762/* regdump() moved to regdump.c */
763
764/*
765 * cpu_exec_aout_makecmds():
766 *	cpu-dependent a.out format hook for execve().
767 *
768 * Determine if the given exec package refers to something which we
769 * understand and, if so, set up the vmcmds for it.
770 */
771int
772cpu_exec_aout_makecmds(p, epp)
773	struct proc *p;
774	struct exec_package *epp;
775{
776	return ENOEXEC;
777}
778