machdep.c revision 1.73 1 1.73 cgd /* $NetBSD: machdep.c,v 1.73 1997/04/07 06:09:06 cgd Exp $ */
2 1.1 cgd
3 1.1 cgd /*
4 1.16 cgd * Copyright (c) 1994, 1995, 1996 Carnegie-Mellon University.
5 1.1 cgd * All rights reserved.
6 1.1 cgd *
7 1.1 cgd * Author: Chris G. Demetriou
8 1.1 cgd *
9 1.1 cgd * Permission to use, copy, modify and distribute this software and
10 1.1 cgd * its documentation is hereby granted, provided that both the copyright
11 1.1 cgd * notice and this permission notice appear in all copies of the
12 1.1 cgd * software, derivative works or modified versions, and any portions
13 1.1 cgd * thereof, and that both notices appear in supporting documentation.
14 1.1 cgd *
15 1.1 cgd * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
16 1.1 cgd * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
17 1.1 cgd * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
18 1.1 cgd *
19 1.1 cgd * Carnegie Mellon requests users of this software to return to
20 1.1 cgd *
21 1.1 cgd * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU
22 1.1 cgd * School of Computer Science
23 1.1 cgd * Carnegie Mellon University
24 1.1 cgd * Pittsburgh PA 15213-3890
25 1.1 cgd *
26 1.1 cgd * any improvements or extensions that they make and grant Carnegie the
27 1.1 cgd * rights to redistribute these changes.
28 1.1 cgd */
29 1.1 cgd
30 1.1 cgd #include <sys/param.h>
31 1.1 cgd #include <sys/systm.h>
32 1.1 cgd #include <sys/signalvar.h>
33 1.1 cgd #include <sys/kernel.h>
34 1.1 cgd #include <sys/map.h>
35 1.1 cgd #include <sys/proc.h>
36 1.1 cgd #include <sys/buf.h>
37 1.1 cgd #include <sys/reboot.h>
38 1.28 cgd #include <sys/device.h>
39 1.1 cgd #include <sys/file.h>
40 1.1 cgd #ifdef REAL_CLISTS
41 1.1 cgd #include <sys/clist.h>
42 1.1 cgd #endif
43 1.1 cgd #include <sys/callout.h>
44 1.1 cgd #include <sys/malloc.h>
45 1.1 cgd #include <sys/mbuf.h>
46 1.1 cgd #include <sys/msgbuf.h>
47 1.1 cgd #include <sys/ioctl.h>
48 1.1 cgd #include <sys/tty.h>
49 1.1 cgd #include <sys/user.h>
50 1.1 cgd #include <sys/exec.h>
51 1.1 cgd #include <sys/exec_ecoff.h>
52 1.1 cgd #include <sys/sysctl.h>
53 1.43 cgd #include <sys/core.h>
54 1.43 cgd #include <sys/kcore.h>
55 1.43 cgd #include <machine/kcore.h>
56 1.1 cgd #ifdef SYSVMSG
57 1.1 cgd #include <sys/msg.h>
58 1.1 cgd #endif
59 1.1 cgd #ifdef SYSVSEM
60 1.1 cgd #include <sys/sem.h>
61 1.1 cgd #endif
62 1.1 cgd #ifdef SYSVSHM
63 1.1 cgd #include <sys/shm.h>
64 1.1 cgd #endif
65 1.1 cgd
66 1.1 cgd #include <sys/mount.h>
67 1.1 cgd #include <sys/syscallargs.h>
68 1.1 cgd
69 1.1 cgd #include <vm/vm_kern.h>
70 1.1 cgd
71 1.1 cgd #include <dev/cons.h>
72 1.1 cgd
73 1.1 cgd #include <machine/cpu.h>
74 1.1 cgd #include <machine/reg.h>
75 1.1 cgd #include <machine/rpb.h>
76 1.1 cgd #include <machine/prom.h>
77 1.73 cgd #include <machine/conf.h>
78 1.8 cgd
79 1.49 cgd #include <net/netisr.h>
80 1.33 cgd #include <net/if.h>
81 1.49 cgd
82 1.49 cgd #ifdef INET
83 1.33 cgd #include <netinet/in.h>
84 1.72 cgd #include <netinet/ip_var.h>
85 1.72 cgd #include "arp.h"
86 1.72 cgd #if NARP > 0
87 1.67 is #include <netinet/if_inarp.h>
88 1.72 cgd #endif
89 1.49 cgd #endif
90 1.49 cgd #ifdef NS
91 1.49 cgd #include <netns/ns_var.h>
92 1.49 cgd #endif
93 1.49 cgd #ifdef ISO
94 1.49 cgd #include <netiso/iso.h>
95 1.49 cgd #include <netiso/clnp.h>
96 1.49 cgd #endif
97 1.55 cgd #ifdef CCITT
98 1.55 cgd #include <netccitt/x25.h>
99 1.55 cgd #include <netccitt/pk.h>
100 1.55 cgd #include <netccitt/pk_extern.h>
101 1.55 cgd #endif
102 1.55 cgd #ifdef NATM
103 1.55 cgd #include <netnatm/natm.h>
104 1.55 cgd #endif
105 1.70 christos #ifdef NETATALK
106 1.70 christos #include <netatalk/at_extern.h>
107 1.70 christos #endif
108 1.49 cgd #include "ppp.h"
109 1.49 cgd #if NPPP > 0
110 1.49 cgd #include <net/ppp_defs.h>
111 1.49 cgd #include <net/if_ppp.h>
112 1.49 cgd #endif
113 1.1 cgd
114 1.17 cgd #include "le_ioasic.h" /* for le_iomem creation */
115 1.1 cgd
116 1.1 cgd vm_map_t buffer_map;
117 1.1 cgd
118 1.1 cgd /*
119 1.1 cgd * Declare these as initialized data so we can patch them.
120 1.1 cgd */
121 1.1 cgd int nswbuf = 0;
122 1.1 cgd #ifdef NBUF
123 1.1 cgd int nbuf = NBUF;
124 1.1 cgd #else
125 1.1 cgd int nbuf = 0;
126 1.1 cgd #endif
127 1.1 cgd #ifdef BUFPAGES
128 1.1 cgd int bufpages = BUFPAGES;
129 1.1 cgd #else
130 1.1 cgd int bufpages = 0;
131 1.1 cgd #endif
132 1.1 cgd int msgbufmapped = 0; /* set when safe to use msgbuf */
133 1.1 cgd int maxmem; /* max memory per process */
134 1.7 cgd
135 1.7 cgd int totalphysmem; /* total amount of physical memory in system */
136 1.7 cgd int physmem; /* physical memory used by NetBSD + some rsvd */
137 1.7 cgd int firstusablepage; /* first usable memory page */
138 1.7 cgd int lastusablepage; /* last usable memory page */
139 1.1 cgd int resvmem; /* amount of memory reserved for PROM */
140 1.7 cgd int unusedmem; /* amount of memory for OS that we don't use */
141 1.7 cgd int unknownmem; /* amount of memory with an unknown use */
142 1.1 cgd
143 1.1 cgd int cputype; /* system type, from the RPB */
144 1.1 cgd
145 1.1 cgd /*
146 1.1 cgd * XXX We need an address to which we can assign things so that they
147 1.1 cgd * won't be optimized away because we didn't use the value.
148 1.1 cgd */
149 1.1 cgd u_int32_t no_optimize;
150 1.1 cgd
151 1.1 cgd /* the following is used externally (sysctl_hw) */
152 1.1 cgd char machine[] = "alpha";
153 1.29 cgd char cpu_model[128];
154 1.54 cgd const struct cpusw *cpu_fn_switch; /* function switch */
155 1.1 cgd
156 1.1 cgd struct user *proc0paddr;
157 1.1 cgd
158 1.1 cgd /* Number of machine cycles per microsecond */
159 1.1 cgd u_int64_t cycles_per_usec;
160 1.1 cgd
161 1.1 cgd /* some memory areas for device DMA. "ick." */
162 1.1 cgd caddr_t le_iomem; /* XXX iomem for LANCE DMA */
163 1.1 cgd
164 1.7 cgd /* number of cpus in the box. really! */
165 1.7 cgd int ncpus;
166 1.7 cgd
167 1.25 cgd char boot_flags[64];
168 1.61 cgd char booted_kernel[64];
169 1.8 cgd
170 1.30 cgd /* for cpu_sysctl() */
171 1.36 cgd int alpha_unaligned_print = 1; /* warn about unaligned accesses */
172 1.36 cgd int alpha_unaligned_fix = 1; /* fix up unaligned accesses */
173 1.36 cgd int alpha_unaligned_sigbus = 0; /* don't SIGBUS on fixed-up accesses */
174 1.30 cgd
175 1.55 cgd int cpu_dump __P((void));
176 1.55 cgd int cpu_dumpsize __P((void));
177 1.55 cgd void dumpsys __P((void));
178 1.55 cgd void identifycpu __P((void));
179 1.55 cgd void netintr __P((void));
180 1.55 cgd void printregs __P((struct reg *));
181 1.33 cgd
182 1.55 cgd void
183 1.25 cgd alpha_init(pfn, ptb)
184 1.1 cgd u_long pfn; /* first free PFN number */
185 1.1 cgd u_long ptb; /* PFN of current level 1 page table */
186 1.1 cgd {
187 1.2 cgd extern char _end[];
188 1.1 cgd caddr_t start, v;
189 1.1 cgd struct mddt *mddtp;
190 1.7 cgd int i, mddtweird;
191 1.1 cgd char *p;
192 1.1 cgd
193 1.1 cgd /*
194 1.1 cgd * Turn off interrupts and floating point.
195 1.1 cgd * Make sure the instruction and data streams are consistent.
196 1.1 cgd */
197 1.1 cgd (void)splhigh();
198 1.32 cgd alpha_pal_wrfen(0);
199 1.37 cgd ALPHA_TBIA();
200 1.32 cgd alpha_pal_imb();
201 1.1 cgd
202 1.1 cgd /*
203 1.1 cgd * get address of the restart block, while we the bootstrap
204 1.1 cgd * mapping is still around.
205 1.1 cgd */
206 1.32 cgd hwrpb = (struct rpb *)ALPHA_PHYS_TO_K0SEG(
207 1.32 cgd (vm_offset_t)(*(struct rpb **)HWRPB_ADDR));
208 1.1 cgd
209 1.1 cgd /*
210 1.1 cgd * Remember how many cycles there are per microsecond,
211 1.7 cgd * so that we can use delay(). Round up, for safety.
212 1.1 cgd */
213 1.7 cgd cycles_per_usec = (hwrpb->rpb_cc_freq + 999999) / 1000000;
214 1.1 cgd
215 1.1 cgd /*
216 1.1 cgd * Init the PROM interface, so we can use printf
217 1.1 cgd * until PROM mappings go away in consinit.
218 1.1 cgd */
219 1.1 cgd init_prom_interface();
220 1.1 cgd
221 1.1 cgd /*
222 1.1 cgd * Point interrupt/exception vectors to our own.
223 1.1 cgd */
224 1.36 cgd alpha_pal_wrent(XentInt, ALPHA_KENTRY_INT);
225 1.36 cgd alpha_pal_wrent(XentArith, ALPHA_KENTRY_ARITH);
226 1.36 cgd alpha_pal_wrent(XentMM, ALPHA_KENTRY_MM);
227 1.36 cgd alpha_pal_wrent(XentIF, ALPHA_KENTRY_IF);
228 1.36 cgd alpha_pal_wrent(XentUna, ALPHA_KENTRY_UNA);
229 1.36 cgd alpha_pal_wrent(XentSys, ALPHA_KENTRY_SYS);
230 1.36 cgd
231 1.36 cgd /*
232 1.36 cgd * Disable System and Processor Correctable Error reporting.
233 1.36 cgd * Clear pending machine checks and error reports, etc.
234 1.36 cgd */
235 1.40 cgd alpha_pal_wrmces(alpha_pal_rdmces() | ALPHA_MCES_DSC | ALPHA_MCES_DPC);
236 1.1 cgd
237 1.1 cgd /*
238 1.1 cgd * Find out how much memory is available, by looking at
239 1.7 cgd * the memory cluster descriptors. This also tries to do
240 1.7 cgd * its best to detect things things that have never been seen
241 1.7 cgd * before...
242 1.7 cgd *
243 1.1 cgd * XXX Assumes that the first "system" cluster is the
244 1.7 cgd * only one we can use. Is the second (etc.) system cluster
245 1.7 cgd * (if one happens to exist) guaranteed to be contiguous? or...?
246 1.1 cgd */
247 1.1 cgd mddtp = (struct mddt *)(((caddr_t)hwrpb) + hwrpb->rpb_memdat_off);
248 1.7 cgd
249 1.7 cgd /*
250 1.7 cgd * BEGIN MDDT WEIRDNESS CHECKING
251 1.7 cgd */
252 1.7 cgd mddtweird = 0;
253 1.7 cgd
254 1.7 cgd #define cnt mddtp->mddt_cluster_cnt
255 1.7 cgd #define usage(n) mddtp->mddt_clusters[(n)].mddt_usage
256 1.7 cgd if (cnt != 2 && cnt != 3) {
257 1.46 christos printf("WARNING: weird number (%ld) of mem clusters\n", cnt);
258 1.7 cgd mddtweird = 1;
259 1.7 cgd } else if (usage(0) != MDDT_PALCODE ||
260 1.7 cgd usage(1) != MDDT_SYSTEM ||
261 1.7 cgd (cnt == 3 && usage(2) != MDDT_PALCODE)) {
262 1.7 cgd mddtweird = 1;
263 1.46 christos printf("WARNING: %ld mem clusters, but weird config\n", cnt);
264 1.7 cgd }
265 1.7 cgd
266 1.7 cgd for (i = 0; i < cnt; i++) {
267 1.7 cgd if ((usage(i) & MDDT_mbz) != 0) {
268 1.46 christos printf("WARNING: mem cluster %d has weird usage %lx\n",
269 1.7 cgd i, usage(i));
270 1.7 cgd mddtweird = 1;
271 1.7 cgd }
272 1.7 cgd if (mddtp->mddt_clusters[i].mddt_pg_cnt == 0) {
273 1.46 christos printf("WARNING: mem cluster %d has pg cnt == 0\n", i);
274 1.7 cgd mddtweird = 1;
275 1.7 cgd }
276 1.7 cgd /* XXX other things to check? */
277 1.7 cgd }
278 1.7 cgd #undef cnt
279 1.7 cgd #undef usage
280 1.7 cgd
281 1.7 cgd if (mddtweird) {
282 1.46 christos printf("\n");
283 1.46 christos printf("complete memory cluster information:\n");
284 1.2 cgd for (i = 0; i < mddtp->mddt_cluster_cnt; i++) {
285 1.46 christos printf("mddt %d:\n", i);
286 1.46 christos printf("\tpfn %lx\n",
287 1.2 cgd mddtp->mddt_clusters[i].mddt_pfn);
288 1.46 christos printf("\tcnt %lx\n",
289 1.2 cgd mddtp->mddt_clusters[i].mddt_pg_cnt);
290 1.46 christos printf("\ttest %lx\n",
291 1.2 cgd mddtp->mddt_clusters[i].mddt_pg_test);
292 1.46 christos printf("\tbva %lx\n",
293 1.2 cgd mddtp->mddt_clusters[i].mddt_v_bitaddr);
294 1.46 christos printf("\tbpa %lx\n",
295 1.2 cgd mddtp->mddt_clusters[i].mddt_p_bitaddr);
296 1.46 christos printf("\tbcksum %lx\n",
297 1.2 cgd mddtp->mddt_clusters[i].mddt_bit_cksum);
298 1.46 christos printf("\tusage %lx\n",
299 1.2 cgd mddtp->mddt_clusters[i].mddt_usage);
300 1.2 cgd }
301 1.46 christos printf("\n");
302 1.2 cgd }
303 1.7 cgd /*
304 1.7 cgd * END MDDT WEIRDNESS CHECKING
305 1.7 cgd */
306 1.2 cgd
307 1.1 cgd for (i = 0; i < mddtp->mddt_cluster_cnt; i++) {
308 1.7 cgd totalphysmem += mddtp->mddt_clusters[i].mddt_pg_cnt;
309 1.7 cgd #define usage(n) mddtp->mddt_clusters[(n)].mddt_usage
310 1.7 cgd #define pgcnt(n) mddtp->mddt_clusters[(n)].mddt_pg_cnt
311 1.7 cgd if ((usage(i) & MDDT_mbz) != 0)
312 1.7 cgd unknownmem += pgcnt(i);
313 1.7 cgd else if ((usage(i) & ~MDDT_mbz) == MDDT_PALCODE)
314 1.7 cgd resvmem += pgcnt(i);
315 1.7 cgd else if ((usage(i) & ~MDDT_mbz) == MDDT_SYSTEM) {
316 1.7 cgd /*
317 1.7 cgd * assumes that the system cluster listed is
318 1.7 cgd * one we're in...
319 1.7 cgd */
320 1.7 cgd if (physmem != resvmem) {
321 1.7 cgd physmem += pgcnt(i);
322 1.7 cgd firstusablepage =
323 1.7 cgd mddtp->mddt_clusters[i].mddt_pfn;
324 1.7 cgd lastusablepage = firstusablepage + pgcnt(i) - 1;
325 1.7 cgd } else
326 1.7 cgd unusedmem += pgcnt(i);
327 1.7 cgd }
328 1.7 cgd #undef usage
329 1.7 cgd #undef pgcnt
330 1.1 cgd }
331 1.7 cgd if (totalphysmem == 0)
332 1.1 cgd panic("can't happen: system seems to have no memory!");
333 1.1 cgd maxmem = physmem;
334 1.1 cgd
335 1.7 cgd #if 0
336 1.46 christos printf("totalphysmem = %d\n", totalphysmem);
337 1.46 christos printf("physmem = %d\n", physmem);
338 1.46 christos printf("firstusablepage = %d\n", firstusablepage);
339 1.46 christos printf("lastusablepage = %d\n", lastusablepage);
340 1.46 christos printf("resvmem = %d\n", resvmem);
341 1.46 christos printf("unusedmem = %d\n", unusedmem);
342 1.46 christos printf("unknownmem = %d\n", unknownmem);
343 1.7 cgd #endif
344 1.7 cgd
345 1.1 cgd /*
346 1.1 cgd * find out this CPU's page size
347 1.1 cgd */
348 1.1 cgd PAGE_SIZE = hwrpb->rpb_page_size;
349 1.12 cgd if (PAGE_SIZE != 8192)
350 1.12 cgd panic("page size %d != 8192?!", PAGE_SIZE);
351 1.1 cgd
352 1.2 cgd v = (caddr_t)alpha_round_page(_end);
353 1.1 cgd /*
354 1.1 cgd * Init mapping for u page(s) for proc 0
355 1.1 cgd */
356 1.1 cgd start = v;
357 1.1 cgd curproc->p_addr = proc0paddr = (struct user *)v;
358 1.1 cgd v += UPAGES * NBPG;
359 1.1 cgd
360 1.1 cgd /*
361 1.1 cgd * Find out what hardware we're on, and remember its type name.
362 1.1 cgd */
363 1.1 cgd cputype = hwrpb->rpb_type;
364 1.54 cgd if (cputype < 0 || cputype > ncpusw) {
365 1.54 cgd unknown_cputype:
366 1.54 cgd printf("\n");
367 1.54 cgd printf("Unknown system type %d.\n", cputype);
368 1.54 cgd printf("\n");
369 1.54 cgd panic("unknown system type");
370 1.54 cgd }
371 1.54 cgd cpu_fn_switch = &cpusw[cputype];
372 1.54 cgd if (cpu_fn_switch->family == NULL)
373 1.54 cgd goto unknown_cputype;
374 1.54 cgd if (cpu_fn_switch->option == NULL) {
375 1.54 cgd printf("\n");
376 1.54 cgd printf("NetBSD does not currently support system type %d\n",
377 1.54 cgd cputype);
378 1.54 cgd printf("(%s family).\n", cpu_fn_switch->family);
379 1.54 cgd printf("\n");
380 1.54 cgd panic("unsupported system type");
381 1.54 cgd }
382 1.54 cgd if (!cpu_fn_switch->present) {
383 1.54 cgd printf("\n");
384 1.54 cgd printf("Support for system type %d (%s family) is\n", cputype,
385 1.54 cgd cpu_fn_switch->family);
386 1.57 cgd printf("not present in this kernel. Build a kernel with \"options %s\"\n",
387 1.54 cgd cpu_fn_switch->option);
388 1.57 cgd printf("to include support for this system type.\n");
389 1.54 cgd printf("\n");
390 1.54 cgd panic("support for system not present");
391 1.54 cgd }
392 1.54 cgd
393 1.54 cgd if ((*cpu_fn_switch->model_name)() != NULL)
394 1.54 cgd strncpy(cpu_model, (*cpu_fn_switch->model_name)(),
395 1.54 cgd sizeof cpu_model - 1);
396 1.54 cgd else {
397 1.54 cgd strncpy(cpu_model, cpu_fn_switch->family, sizeof cpu_model - 1);
398 1.54 cgd strcat(cpu_model, " family"); /* XXX */
399 1.54 cgd }
400 1.29 cgd cpu_model[sizeof cpu_model - 1] = '\0';
401 1.66 cgd
402 1.66 cgd /* XXX SANITY CHECKING. SHOULD GO AWAY */
403 1.66 cgd /* XXX We should always be running on the the primary. */
404 1.66 cgd assert(hwrpb->rpb_primary_cpu_id == alpha_pal_whami()); /*XXX*/
405 1.66 cgd /* XXX On single-CPU boxes, the primary should always be CPU 0. */
406 1.66 cgd if (cputype != ST_DEC_21000) /*XXX*/
407 1.66 cgd assert(hwrpb->rpb_primary_cpu_id == 0); /*XXX*/
408 1.1 cgd
409 1.17 cgd #if NLE_IOASIC > 0
410 1.1 cgd /*
411 1.1 cgd * Grab 128K at the top of physical memory for the lance chip
412 1.1 cgd * on machines where it does dma through the I/O ASIC.
413 1.1 cgd * It must be physically contiguous and aligned on a 128K boundary.
414 1.17 cgd *
415 1.17 cgd * Note that since this is conditional on the presence of
416 1.17 cgd * IOASIC-attached 'le' units in the kernel config, the
417 1.17 cgd * message buffer may move on these systems. This shouldn't
418 1.17 cgd * be a problem, because once people have a kernel config that
419 1.17 cgd * they use, they're going to stick with it.
420 1.1 cgd */
421 1.1 cgd if (cputype == ST_DEC_3000_500 ||
422 1.1 cgd cputype == ST_DEC_3000_300) { /* XXX possibly others? */
423 1.7 cgd lastusablepage -= btoc(128 * 1024);
424 1.32 cgd le_iomem =
425 1.32 cgd (caddr_t)ALPHA_PHYS_TO_K0SEG(ctob(lastusablepage + 1));
426 1.1 cgd }
427 1.17 cgd #endif /* NLE_IOASIC */
428 1.1 cgd
429 1.1 cgd /*
430 1.1 cgd * Initialize error message buffer (at end of core).
431 1.1 cgd */
432 1.7 cgd lastusablepage -= btoc(sizeof (struct msgbuf));
433 1.32 cgd msgbufp =
434 1.32 cgd (struct msgbuf *)ALPHA_PHYS_TO_K0SEG(ctob(lastusablepage + 1));
435 1.1 cgd msgbufmapped = 1;
436 1.1 cgd
437 1.1 cgd /*
438 1.1 cgd * Allocate space for system data structures.
439 1.1 cgd * The first available kernel virtual address is in "v".
440 1.1 cgd * As pages of kernel virtual memory are allocated, "v" is incremented.
441 1.1 cgd *
442 1.1 cgd * These data structures are allocated here instead of cpu_startup()
443 1.1 cgd * because physical memory is directly addressable. We don't have
444 1.1 cgd * to map these into virtual address space.
445 1.1 cgd */
446 1.1 cgd #define valloc(name, type, num) \
447 1.12 cgd (name) = (type *)v; v = (caddr_t)ALIGN((name)+(num))
448 1.1 cgd #define valloclim(name, type, num, lim) \
449 1.12 cgd (name) = (type *)v; v = (caddr_t)ALIGN((lim) = ((name)+(num)))
450 1.1 cgd #ifdef REAL_CLISTS
451 1.1 cgd valloc(cfree, struct cblock, nclist);
452 1.1 cgd #endif
453 1.1 cgd valloc(callout, struct callout, ncallout);
454 1.1 cgd valloc(swapmap, struct map, nswapmap = maxproc * 2);
455 1.1 cgd #ifdef SYSVSHM
456 1.1 cgd valloc(shmsegs, struct shmid_ds, shminfo.shmmni);
457 1.1 cgd #endif
458 1.1 cgd #ifdef SYSVSEM
459 1.1 cgd valloc(sema, struct semid_ds, seminfo.semmni);
460 1.1 cgd valloc(sem, struct sem, seminfo.semmns);
461 1.1 cgd /* This is pretty disgusting! */
462 1.1 cgd valloc(semu, int, (seminfo.semmnu * seminfo.semusz) / sizeof(int));
463 1.1 cgd #endif
464 1.1 cgd #ifdef SYSVMSG
465 1.1 cgd valloc(msgpool, char, msginfo.msgmax);
466 1.1 cgd valloc(msgmaps, struct msgmap, msginfo.msgseg);
467 1.1 cgd valloc(msghdrs, struct msg, msginfo.msgtql);
468 1.1 cgd valloc(msqids, struct msqid_ds, msginfo.msgmni);
469 1.1 cgd #endif
470 1.1 cgd
471 1.1 cgd /*
472 1.1 cgd * Determine how many buffers to allocate.
473 1.31 cgd * We allocate 10% of memory for buffer space. Insure a
474 1.1 cgd * minimum of 16 buffers. We allocate 1/2 as many swap buffer
475 1.1 cgd * headers as file i/o buffers.
476 1.1 cgd */
477 1.1 cgd if (bufpages == 0)
478 1.31 cgd bufpages = (physmem * 10) / (CLSIZE * 100);
479 1.1 cgd if (nbuf == 0) {
480 1.1 cgd nbuf = bufpages;
481 1.1 cgd if (nbuf < 16)
482 1.1 cgd nbuf = 16;
483 1.1 cgd }
484 1.1 cgd if (nswbuf == 0) {
485 1.1 cgd nswbuf = (nbuf / 2) &~ 1; /* force even */
486 1.1 cgd if (nswbuf > 256)
487 1.1 cgd nswbuf = 256; /* sanity */
488 1.1 cgd }
489 1.1 cgd valloc(swbuf, struct buf, nswbuf);
490 1.1 cgd valloc(buf, struct buf, nbuf);
491 1.1 cgd
492 1.1 cgd /*
493 1.1 cgd * Clear allocated memory.
494 1.1 cgd */
495 1.1 cgd bzero(start, v - start);
496 1.1 cgd
497 1.1 cgd /*
498 1.1 cgd * Initialize the virtual memory system, and set the
499 1.1 cgd * page table base register in proc 0's PCB.
500 1.1 cgd */
501 1.40 cgd #ifndef NEW_PMAP
502 1.32 cgd pmap_bootstrap((vm_offset_t)v, ALPHA_PHYS_TO_K0SEG(ptb << PGSHIFT));
503 1.40 cgd #else
504 1.40 cgd pmap_bootstrap((vm_offset_t)v, ALPHA_PHYS_TO_K0SEG(ptb << PGSHIFT),
505 1.40 cgd hwrpb->rpb_max_asn);
506 1.40 cgd #endif
507 1.1 cgd
508 1.1 cgd /*
509 1.3 cgd * Initialize the rest of proc 0's PCB, and cache its physical
510 1.3 cgd * address.
511 1.3 cgd */
512 1.3 cgd proc0.p_md.md_pcbpaddr =
513 1.32 cgd (struct pcb *)ALPHA_K0SEG_TO_PHYS((vm_offset_t)&proc0paddr->u_pcb);
514 1.3 cgd
515 1.3 cgd /*
516 1.3 cgd * Set the kernel sp, reserving space for an (empty) trapframe,
517 1.3 cgd * and make proc0's trapframe pointer point to it for sanity.
518 1.3 cgd */
519 1.33 cgd proc0paddr->u_pcb.pcb_hw.apcb_ksp =
520 1.3 cgd (u_int64_t)proc0paddr + USPACE - sizeof(struct trapframe);
521 1.33 cgd proc0.p_md.md_tf = (struct trapframe *)proc0paddr->u_pcb.pcb_hw.apcb_ksp;
522 1.38 cgd
523 1.40 cgd #ifdef NEW_PMAP
524 1.40 cgd pmap_activate(kernel_pmap, &proc0paddr->u_pcb.pcb_hw, 0);
525 1.38 cgd #endif
526 1.1 cgd
527 1.1 cgd /*
528 1.25 cgd * Look at arguments passed to us and compute boothowto.
529 1.61 cgd * Also, get kernel name so it can be used in user-land.
530 1.8 cgd */
531 1.25 cgd prom_getenv(PROM_E_BOOTED_OSFLAGS, boot_flags, sizeof(boot_flags));
532 1.25 cgd #if 0
533 1.46 christos printf("boot flags = \"%s\"\n", boot_flags);
534 1.25 cgd #endif
535 1.61 cgd prom_getenv(PROM_E_BOOTED_FILE, booted_kernel,
536 1.61 cgd sizeof(booted_kernel));
537 1.61 cgd #if 0
538 1.61 cgd printf("booted kernel = \"%s\"\n", booted_kernel);
539 1.61 cgd #endif
540 1.1 cgd
541 1.8 cgd boothowto = RB_SINGLE;
542 1.1 cgd #ifdef KADB
543 1.1 cgd boothowto |= RB_KDB;
544 1.1 cgd #endif
545 1.8 cgd for (p = boot_flags; p && *p != '\0'; p++) {
546 1.26 cgd /*
547 1.26 cgd * Note that we'd really like to differentiate case here,
548 1.26 cgd * but the Alpha AXP Architecture Reference Manual
549 1.26 cgd * says that we shouldn't.
550 1.26 cgd */
551 1.8 cgd switch (*p) {
552 1.26 cgd case 'a': /* autoboot */
553 1.26 cgd case 'A':
554 1.26 cgd boothowto &= ~RB_SINGLE;
555 1.21 cgd break;
556 1.21 cgd
557 1.43 cgd #ifdef DEBUG
558 1.43 cgd case 'c': /* crash dump immediately after autoconfig */
559 1.43 cgd case 'C':
560 1.43 cgd boothowto |= RB_DUMP;
561 1.43 cgd break;
562 1.43 cgd #endif
563 1.43 cgd
564 1.36 cgd case 'h': /* always halt, never reboot */
565 1.36 cgd case 'H':
566 1.36 cgd boothowto |= RB_HALT;
567 1.8 cgd break;
568 1.8 cgd
569 1.21 cgd #if 0
570 1.8 cgd case 'm': /* mini root present in memory */
571 1.26 cgd case 'M':
572 1.8 cgd boothowto |= RB_MINIROOT;
573 1.8 cgd break;
574 1.21 cgd #endif
575 1.36 cgd
576 1.36 cgd case 'n': /* askname */
577 1.36 cgd case 'N':
578 1.36 cgd boothowto |= RB_ASKNAME;
579 1.65 cgd break;
580 1.65 cgd
581 1.65 cgd case 's': /* single-user (default, supported for sanity) */
582 1.65 cgd case 'S':
583 1.65 cgd boothowto |= RB_SINGLE;
584 1.65 cgd break;
585 1.65 cgd
586 1.65 cgd default:
587 1.65 cgd printf("Unrecognized boot flag '%c'.\n", *p);
588 1.36 cgd break;
589 1.1 cgd }
590 1.1 cgd }
591 1.1 cgd
592 1.7 cgd /*
593 1.7 cgd * Figure out the number of cpus in the box, from RPB fields.
594 1.7 cgd * Really. We mean it.
595 1.7 cgd */
596 1.7 cgd for (i = 0; i < hwrpb->rpb_pcs_cnt; i++) {
597 1.7 cgd struct pcs *pcsp;
598 1.7 cgd
599 1.7 cgd pcsp = (struct pcs *)((char *)hwrpb + hwrpb->rpb_pcs_off +
600 1.7 cgd (i * hwrpb->rpb_pcs_size));
601 1.7 cgd if ((pcsp->pcs_flags & PCS_PP) != 0)
602 1.7 cgd ncpus++;
603 1.7 cgd }
604 1.1 cgd }
605 1.1 cgd
606 1.18 cgd void
607 1.1 cgd consinit()
608 1.1 cgd {
609 1.1 cgd
610 1.54 cgd (*cpu_fn_switch->cons_init)();
611 1.1 cgd pmap_unmap_prom();
612 1.1 cgd }
613 1.1 cgd
614 1.18 cgd void
615 1.1 cgd cpu_startup()
616 1.1 cgd {
617 1.1 cgd register unsigned i;
618 1.1 cgd int base, residual;
619 1.1 cgd vm_offset_t minaddr, maxaddr;
620 1.1 cgd vm_size_t size;
621 1.40 cgd #if defined(DEBUG)
622 1.1 cgd extern int pmapdebug;
623 1.1 cgd int opmapdebug = pmapdebug;
624 1.1 cgd
625 1.1 cgd pmapdebug = 0;
626 1.1 cgd #endif
627 1.1 cgd
628 1.1 cgd /*
629 1.1 cgd * Good {morning,afternoon,evening,night}.
630 1.1 cgd */
631 1.46 christos printf(version);
632 1.1 cgd identifycpu();
633 1.46 christos printf("real mem = %d (%d reserved for PROM, %d used by NetBSD)\n",
634 1.7 cgd ctob(totalphysmem), ctob(resvmem), ctob(physmem));
635 1.7 cgd if (unusedmem)
636 1.46 christos printf("WARNING: unused memory = %d bytes\n", ctob(unusedmem));
637 1.7 cgd if (unknownmem)
638 1.46 christos printf("WARNING: %d bytes of memory with unknown purpose\n",
639 1.7 cgd ctob(unknownmem));
640 1.1 cgd
641 1.1 cgd /*
642 1.1 cgd * Allocate virtual address space for file I/O buffers.
643 1.1 cgd * Note they are different than the array of headers, 'buf',
644 1.1 cgd * and usually occupy more virtual memory than physical.
645 1.1 cgd */
646 1.1 cgd size = MAXBSIZE * nbuf;
647 1.1 cgd buffer_map = kmem_suballoc(kernel_map, (vm_offset_t *)&buffers,
648 1.1 cgd &maxaddr, size, TRUE);
649 1.1 cgd minaddr = (vm_offset_t)buffers;
650 1.1 cgd if (vm_map_find(buffer_map, vm_object_allocate(size), (vm_offset_t)0,
651 1.1 cgd &minaddr, size, FALSE) != KERN_SUCCESS)
652 1.1 cgd panic("startup: cannot allocate buffers");
653 1.1 cgd base = bufpages / nbuf;
654 1.1 cgd residual = bufpages % nbuf;
655 1.1 cgd for (i = 0; i < nbuf; i++) {
656 1.1 cgd vm_size_t curbufsize;
657 1.1 cgd vm_offset_t curbuf;
658 1.1 cgd
659 1.1 cgd /*
660 1.1 cgd * First <residual> buffers get (base+1) physical pages
661 1.1 cgd * allocated for them. The rest get (base) physical pages.
662 1.1 cgd *
663 1.1 cgd * The rest of each buffer occupies virtual space,
664 1.1 cgd * but has no physical memory allocated for it.
665 1.1 cgd */
666 1.1 cgd curbuf = (vm_offset_t)buffers + i * MAXBSIZE;
667 1.1 cgd curbufsize = CLBYTES * (i < residual ? base+1 : base);
668 1.1 cgd vm_map_pageable(buffer_map, curbuf, curbuf+curbufsize, FALSE);
669 1.1 cgd vm_map_simplify(buffer_map, curbuf);
670 1.1 cgd }
671 1.1 cgd /*
672 1.1 cgd * Allocate a submap for exec arguments. This map effectively
673 1.1 cgd * limits the number of processes exec'ing at any time.
674 1.1 cgd */
675 1.1 cgd exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
676 1.1 cgd 16 * NCARGS, TRUE);
677 1.1 cgd
678 1.1 cgd /*
679 1.1 cgd * Allocate a submap for physio
680 1.1 cgd */
681 1.1 cgd phys_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
682 1.1 cgd VM_PHYS_SIZE, TRUE);
683 1.1 cgd
684 1.1 cgd /*
685 1.69 thorpej * Finally, allocate mbuf cluster submap.
686 1.1 cgd */
687 1.1 cgd mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl, &maxaddr,
688 1.1 cgd VM_MBUF_SIZE, FALSE);
689 1.1 cgd /*
690 1.1 cgd * Initialize callouts
691 1.1 cgd */
692 1.1 cgd callfree = callout;
693 1.1 cgd for (i = 1; i < ncallout; i++)
694 1.1 cgd callout[i-1].c_next = &callout[i];
695 1.1 cgd callout[i-1].c_next = NULL;
696 1.1 cgd
697 1.40 cgd #if defined(DEBUG)
698 1.1 cgd pmapdebug = opmapdebug;
699 1.1 cgd #endif
700 1.46 christos printf("avail mem = %ld\n", (long)ptoa(cnt.v_free_count));
701 1.46 christos printf("using %ld buffers containing %ld bytes of memory\n",
702 1.1 cgd (long)nbuf, (long)(bufpages * CLBYTES));
703 1.1 cgd
704 1.1 cgd /*
705 1.1 cgd * Set up buffers, so they can be used to read disk labels.
706 1.1 cgd */
707 1.1 cgd bufinit();
708 1.1 cgd
709 1.1 cgd /*
710 1.1 cgd * Configure the system.
711 1.1 cgd */
712 1.1 cgd configure();
713 1.48 cgd
714 1.48 cgd /*
715 1.48 cgd * Note that bootstrapping is finished, and set the HWRPB up
716 1.48 cgd * to do restarts.
717 1.48 cgd */
718 1.55 cgd hwrpb_restart_setup();
719 1.1 cgd }
720 1.1 cgd
721 1.33 cgd void
722 1.1 cgd identifycpu()
723 1.1 cgd {
724 1.1 cgd
725 1.7 cgd /*
726 1.7 cgd * print out CPU identification information.
727 1.7 cgd */
728 1.46 christos printf("%s, %ldMHz\n", cpu_model,
729 1.7 cgd hwrpb->rpb_cc_freq / 1000000); /* XXX true for 21164? */
730 1.46 christos printf("%ld byte page size, %d processor%s.\n",
731 1.7 cgd hwrpb->rpb_page_size, ncpus, ncpus == 1 ? "" : "s");
732 1.7 cgd #if 0
733 1.7 cgd /* this isn't defined for any systems that we run on? */
734 1.46 christos printf("serial number 0x%lx 0x%lx\n",
735 1.1 cgd ((long *)hwrpb->rpb_ssn)[0], ((long *)hwrpb->rpb_ssn)[1]);
736 1.7 cgd
737 1.7 cgd /* and these aren't particularly useful! */
738 1.46 christos printf("variation: 0x%lx, revision 0x%lx\n",
739 1.1 cgd hwrpb->rpb_variation, *(long *)hwrpb->rpb_revision);
740 1.7 cgd #endif
741 1.1 cgd }
742 1.1 cgd
743 1.1 cgd int waittime = -1;
744 1.7 cgd struct pcb dumppcb;
745 1.1 cgd
746 1.18 cgd void
747 1.68 gwr cpu_reboot(howto, bootstr)
748 1.1 cgd int howto;
749 1.39 mrg char *bootstr;
750 1.1 cgd {
751 1.1 cgd extern int cold;
752 1.1 cgd
753 1.1 cgd /* If system is cold, just halt. */
754 1.1 cgd if (cold) {
755 1.1 cgd howto |= RB_HALT;
756 1.1 cgd goto haltsys;
757 1.1 cgd }
758 1.1 cgd
759 1.36 cgd /* If "always halt" was specified as a boot flag, obey. */
760 1.36 cgd if ((boothowto & RB_HALT) != 0)
761 1.36 cgd howto |= RB_HALT;
762 1.36 cgd
763 1.7 cgd boothowto = howto;
764 1.7 cgd if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
765 1.1 cgd waittime = 0;
766 1.7 cgd vfs_shutdown();
767 1.1 cgd /*
768 1.1 cgd * If we've been adjusting the clock, the todr
769 1.1 cgd * will be out of synch; adjust it now.
770 1.1 cgd */
771 1.1 cgd resettodr();
772 1.1 cgd }
773 1.1 cgd
774 1.1 cgd /* Disable interrupts. */
775 1.1 cgd splhigh();
776 1.1 cgd
777 1.7 cgd /* If rebooting and a dump is requested do it. */
778 1.42 cgd #if 0
779 1.42 cgd if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
780 1.42 cgd #else
781 1.42 cgd if (howto & RB_DUMP)
782 1.42 cgd #endif
783 1.1 cgd dumpsys();
784 1.6 cgd
785 1.12 cgd haltsys:
786 1.12 cgd
787 1.6 cgd /* run any shutdown hooks */
788 1.6 cgd doshutdownhooks();
789 1.1 cgd
790 1.7 cgd #ifdef BOOTKEY
791 1.46 christos printf("hit any key to %s...\n", howto & RB_HALT ? "halt" : "reboot");
792 1.7 cgd cngetc();
793 1.46 christos printf("\n");
794 1.7 cgd #endif
795 1.7 cgd
796 1.1 cgd /* Finally, halt/reboot the system. */
797 1.46 christos printf("%s\n\n", howto & RB_HALT ? "halted." : "rebooting...");
798 1.1 cgd prom_halt(howto & RB_HALT);
799 1.1 cgd /*NOTREACHED*/
800 1.1 cgd }
801 1.1 cgd
802 1.7 cgd /*
803 1.7 cgd * These variables are needed by /sbin/savecore
804 1.7 cgd */
805 1.7 cgd u_long dumpmag = 0x8fca0101; /* magic number */
806 1.7 cgd int dumpsize = 0; /* pages */
807 1.7 cgd long dumplo = 0; /* blocks */
808 1.7 cgd
809 1.7 cgd /*
810 1.43 cgd * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
811 1.43 cgd */
812 1.43 cgd int
813 1.43 cgd cpu_dumpsize()
814 1.43 cgd {
815 1.43 cgd int size;
816 1.43 cgd
817 1.43 cgd size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t));
818 1.43 cgd if (roundup(size, dbtob(1)) != dbtob(1))
819 1.43 cgd return -1;
820 1.43 cgd
821 1.43 cgd return (1);
822 1.43 cgd }
823 1.43 cgd
824 1.43 cgd /*
825 1.43 cgd * cpu_dump: dump machine-dependent kernel core dump headers.
826 1.43 cgd */
827 1.43 cgd int
828 1.43 cgd cpu_dump()
829 1.43 cgd {
830 1.43 cgd int (*dump) __P((dev_t, daddr_t, caddr_t, size_t));
831 1.43 cgd long buf[dbtob(1) / sizeof (long)];
832 1.43 cgd kcore_seg_t *segp;
833 1.43 cgd cpu_kcore_hdr_t *cpuhdrp;
834 1.43 cgd
835 1.43 cgd dump = bdevsw[major(dumpdev)].d_dump;
836 1.43 cgd
837 1.43 cgd segp = (kcore_seg_t *)buf;
838 1.43 cgd cpuhdrp =
839 1.43 cgd (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp)) / sizeof (long)];
840 1.43 cgd
841 1.43 cgd /*
842 1.43 cgd * Generate a segment header.
843 1.43 cgd */
844 1.43 cgd CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
845 1.43 cgd segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));
846 1.43 cgd
847 1.43 cgd /*
848 1.43 cgd * Add the machine-dependent header info
849 1.43 cgd */
850 1.44 cgd cpuhdrp->lev1map_pa = ALPHA_K0SEG_TO_PHYS((vm_offset_t)Lev1map);
851 1.43 cgd cpuhdrp->page_size = PAGE_SIZE;
852 1.43 cgd cpuhdrp->core_seg.start = ctob(firstusablepage);
853 1.43 cgd cpuhdrp->core_seg.size = ctob(physmem);
854 1.43 cgd
855 1.43 cgd return (dump(dumpdev, dumplo, (caddr_t)buf, dbtob(1)));
856 1.43 cgd }
857 1.43 cgd
858 1.43 cgd /*
859 1.68 gwr * This is called by main to set dumplo and dumpsize.
860 1.7 cgd * Dumps always skip the first CLBYTES of disk space
861 1.7 cgd * in case there might be a disk label stored there.
862 1.7 cgd * If there is extra space, put dump at the end to
863 1.7 cgd * reduce the chance that swapping trashes it.
864 1.7 cgd */
865 1.7 cgd void
866 1.68 gwr cpu_dumpconf()
867 1.7 cgd {
868 1.43 cgd int nblks, dumpblks; /* size of dump area */
869 1.7 cgd int maj;
870 1.7 cgd
871 1.7 cgd if (dumpdev == NODEV)
872 1.43 cgd goto bad;
873 1.7 cgd maj = major(dumpdev);
874 1.7 cgd if (maj < 0 || maj >= nblkdev)
875 1.7 cgd panic("dumpconf: bad dumpdev=0x%x", dumpdev);
876 1.7 cgd if (bdevsw[maj].d_psize == NULL)
877 1.43 cgd goto bad;
878 1.7 cgd nblks = (*bdevsw[maj].d_psize)(dumpdev);
879 1.7 cgd if (nblks <= ctod(1))
880 1.43 cgd goto bad;
881 1.43 cgd
882 1.43 cgd dumpblks = cpu_dumpsize();
883 1.43 cgd if (dumpblks < 0)
884 1.43 cgd goto bad;
885 1.43 cgd dumpblks += ctod(physmem);
886 1.43 cgd
887 1.43 cgd /* If dump won't fit (incl. room for possible label), punt. */
888 1.43 cgd if (dumpblks > (nblks - ctod(1)))
889 1.43 cgd goto bad;
890 1.43 cgd
891 1.43 cgd /* Put dump at end of partition */
892 1.43 cgd dumplo = nblks - dumpblks;
893 1.7 cgd
894 1.43 cgd /* dumpsize is in page units, and doesn't include headers. */
895 1.7 cgd dumpsize = physmem;
896 1.43 cgd return;
897 1.7 cgd
898 1.43 cgd bad:
899 1.43 cgd dumpsize = 0;
900 1.43 cgd return;
901 1.7 cgd }
902 1.7 cgd
903 1.7 cgd /*
904 1.42 cgd * Dump the kernel's image to the swap partition.
905 1.7 cgd */
906 1.42 cgd #define BYTES_PER_DUMP NBPG
907 1.42 cgd
908 1.7 cgd void
909 1.7 cgd dumpsys()
910 1.7 cgd {
911 1.42 cgd unsigned bytes, i, n;
912 1.42 cgd int maddr, psize;
913 1.42 cgd daddr_t blkno;
914 1.42 cgd int (*dump) __P((dev_t, daddr_t, caddr_t, size_t));
915 1.42 cgd int error;
916 1.42 cgd
917 1.42 cgd /* Save registers. */
918 1.42 cgd savectx(&dumppcb);
919 1.7 cgd
920 1.42 cgd msgbufmapped = 0; /* don't record dump msgs in msgbuf */
921 1.7 cgd if (dumpdev == NODEV)
922 1.7 cgd return;
923 1.42 cgd
924 1.42 cgd /*
925 1.42 cgd * For dumps during autoconfiguration,
926 1.42 cgd * if dump device has already configured...
927 1.42 cgd */
928 1.42 cgd if (dumpsize == 0)
929 1.68 gwr cpu_dumpconf();
930 1.47 cgd if (dumplo <= 0) {
931 1.46 christos printf("\ndump to dev %x not possible\n", dumpdev);
932 1.42 cgd return;
933 1.43 cgd }
934 1.46 christos printf("\ndumping to dev %x, offset %ld\n", dumpdev, dumplo);
935 1.7 cgd
936 1.42 cgd psize = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
937 1.46 christos printf("dump ");
938 1.42 cgd if (psize == -1) {
939 1.46 christos printf("area unavailable\n");
940 1.42 cgd return;
941 1.42 cgd }
942 1.42 cgd
943 1.42 cgd /* XXX should purge all outstanding keystrokes. */
944 1.42 cgd
945 1.43 cgd if ((error = cpu_dump()) != 0)
946 1.43 cgd goto err;
947 1.43 cgd
948 1.43 cgd bytes = ctob(physmem);
949 1.42 cgd maddr = ctob(firstusablepage);
950 1.43 cgd blkno = dumplo + cpu_dumpsize();
951 1.42 cgd dump = bdevsw[major(dumpdev)].d_dump;
952 1.42 cgd error = 0;
953 1.42 cgd for (i = 0; i < bytes; i += n) {
954 1.42 cgd
955 1.42 cgd /* Print out how many MBs we to go. */
956 1.42 cgd n = bytes - i;
957 1.42 cgd if (n && (n % (1024*1024)) == 0)
958 1.46 christos printf("%d ", n / (1024 * 1024));
959 1.42 cgd
960 1.42 cgd /* Limit size for next transfer. */
961 1.42 cgd if (n > BYTES_PER_DUMP)
962 1.42 cgd n = BYTES_PER_DUMP;
963 1.42 cgd
964 1.42 cgd error = (*dump)(dumpdev, blkno,
965 1.42 cgd (caddr_t)ALPHA_PHYS_TO_K0SEG(maddr), n);
966 1.42 cgd if (error)
967 1.42 cgd break;
968 1.42 cgd maddr += n;
969 1.42 cgd blkno += btodb(n); /* XXX? */
970 1.42 cgd
971 1.42 cgd /* XXX should look for keystrokes, to cancel. */
972 1.42 cgd }
973 1.42 cgd
974 1.43 cgd err:
975 1.42 cgd switch (error) {
976 1.7 cgd
977 1.7 cgd case ENXIO:
978 1.46 christos printf("device bad\n");
979 1.7 cgd break;
980 1.7 cgd
981 1.7 cgd case EFAULT:
982 1.46 christos printf("device not ready\n");
983 1.7 cgd break;
984 1.7 cgd
985 1.7 cgd case EINVAL:
986 1.46 christos printf("area improper\n");
987 1.7 cgd break;
988 1.7 cgd
989 1.7 cgd case EIO:
990 1.46 christos printf("i/o error\n");
991 1.7 cgd break;
992 1.7 cgd
993 1.7 cgd case EINTR:
994 1.46 christos printf("aborted from console\n");
995 1.7 cgd break;
996 1.7 cgd
997 1.42 cgd case 0:
998 1.46 christos printf("succeeded\n");
999 1.42 cgd break;
1000 1.42 cgd
1001 1.7 cgd default:
1002 1.46 christos printf("error %d\n", error);
1003 1.7 cgd break;
1004 1.7 cgd }
1005 1.46 christos printf("\n\n");
1006 1.7 cgd delay(1000);
1007 1.7 cgd }
1008 1.7 cgd
1009 1.1 cgd void
1010 1.1 cgd frametoreg(framep, regp)
1011 1.1 cgd struct trapframe *framep;
1012 1.1 cgd struct reg *regp;
1013 1.1 cgd {
1014 1.1 cgd
1015 1.1 cgd regp->r_regs[R_V0] = framep->tf_regs[FRAME_V0];
1016 1.1 cgd regp->r_regs[R_T0] = framep->tf_regs[FRAME_T0];
1017 1.1 cgd regp->r_regs[R_T1] = framep->tf_regs[FRAME_T1];
1018 1.1 cgd regp->r_regs[R_T2] = framep->tf_regs[FRAME_T2];
1019 1.1 cgd regp->r_regs[R_T3] = framep->tf_regs[FRAME_T3];
1020 1.1 cgd regp->r_regs[R_T4] = framep->tf_regs[FRAME_T4];
1021 1.1 cgd regp->r_regs[R_T5] = framep->tf_regs[FRAME_T5];
1022 1.1 cgd regp->r_regs[R_T6] = framep->tf_regs[FRAME_T6];
1023 1.1 cgd regp->r_regs[R_T7] = framep->tf_regs[FRAME_T7];
1024 1.1 cgd regp->r_regs[R_S0] = framep->tf_regs[FRAME_S0];
1025 1.1 cgd regp->r_regs[R_S1] = framep->tf_regs[FRAME_S1];
1026 1.1 cgd regp->r_regs[R_S2] = framep->tf_regs[FRAME_S2];
1027 1.1 cgd regp->r_regs[R_S3] = framep->tf_regs[FRAME_S3];
1028 1.1 cgd regp->r_regs[R_S4] = framep->tf_regs[FRAME_S4];
1029 1.1 cgd regp->r_regs[R_S5] = framep->tf_regs[FRAME_S5];
1030 1.1 cgd regp->r_regs[R_S6] = framep->tf_regs[FRAME_S6];
1031 1.34 cgd regp->r_regs[R_A0] = framep->tf_regs[FRAME_A0];
1032 1.34 cgd regp->r_regs[R_A1] = framep->tf_regs[FRAME_A1];
1033 1.34 cgd regp->r_regs[R_A2] = framep->tf_regs[FRAME_A2];
1034 1.1 cgd regp->r_regs[R_A3] = framep->tf_regs[FRAME_A3];
1035 1.1 cgd regp->r_regs[R_A4] = framep->tf_regs[FRAME_A4];
1036 1.1 cgd regp->r_regs[R_A5] = framep->tf_regs[FRAME_A5];
1037 1.1 cgd regp->r_regs[R_T8] = framep->tf_regs[FRAME_T8];
1038 1.1 cgd regp->r_regs[R_T9] = framep->tf_regs[FRAME_T9];
1039 1.1 cgd regp->r_regs[R_T10] = framep->tf_regs[FRAME_T10];
1040 1.1 cgd regp->r_regs[R_T11] = framep->tf_regs[FRAME_T11];
1041 1.1 cgd regp->r_regs[R_RA] = framep->tf_regs[FRAME_RA];
1042 1.1 cgd regp->r_regs[R_T12] = framep->tf_regs[FRAME_T12];
1043 1.1 cgd regp->r_regs[R_AT] = framep->tf_regs[FRAME_AT];
1044 1.34 cgd regp->r_regs[R_GP] = framep->tf_regs[FRAME_GP];
1045 1.35 cgd /* regp->r_regs[R_SP] = framep->tf_regs[FRAME_SP]; XXX */
1046 1.1 cgd regp->r_regs[R_ZERO] = 0;
1047 1.1 cgd }
1048 1.1 cgd
1049 1.1 cgd void
1050 1.1 cgd regtoframe(regp, framep)
1051 1.1 cgd struct reg *regp;
1052 1.1 cgd struct trapframe *framep;
1053 1.1 cgd {
1054 1.1 cgd
1055 1.1 cgd framep->tf_regs[FRAME_V0] = regp->r_regs[R_V0];
1056 1.1 cgd framep->tf_regs[FRAME_T0] = regp->r_regs[R_T0];
1057 1.1 cgd framep->tf_regs[FRAME_T1] = regp->r_regs[R_T1];
1058 1.1 cgd framep->tf_regs[FRAME_T2] = regp->r_regs[R_T2];
1059 1.1 cgd framep->tf_regs[FRAME_T3] = regp->r_regs[R_T3];
1060 1.1 cgd framep->tf_regs[FRAME_T4] = regp->r_regs[R_T4];
1061 1.1 cgd framep->tf_regs[FRAME_T5] = regp->r_regs[R_T5];
1062 1.1 cgd framep->tf_regs[FRAME_T6] = regp->r_regs[R_T6];
1063 1.1 cgd framep->tf_regs[FRAME_T7] = regp->r_regs[R_T7];
1064 1.1 cgd framep->tf_regs[FRAME_S0] = regp->r_regs[R_S0];
1065 1.1 cgd framep->tf_regs[FRAME_S1] = regp->r_regs[R_S1];
1066 1.1 cgd framep->tf_regs[FRAME_S2] = regp->r_regs[R_S2];
1067 1.1 cgd framep->tf_regs[FRAME_S3] = regp->r_regs[R_S3];
1068 1.1 cgd framep->tf_regs[FRAME_S4] = regp->r_regs[R_S4];
1069 1.1 cgd framep->tf_regs[FRAME_S5] = regp->r_regs[R_S5];
1070 1.1 cgd framep->tf_regs[FRAME_S6] = regp->r_regs[R_S6];
1071 1.34 cgd framep->tf_regs[FRAME_A0] = regp->r_regs[R_A0];
1072 1.34 cgd framep->tf_regs[FRAME_A1] = regp->r_regs[R_A1];
1073 1.34 cgd framep->tf_regs[FRAME_A2] = regp->r_regs[R_A2];
1074 1.1 cgd framep->tf_regs[FRAME_A3] = regp->r_regs[R_A3];
1075 1.1 cgd framep->tf_regs[FRAME_A4] = regp->r_regs[R_A4];
1076 1.1 cgd framep->tf_regs[FRAME_A5] = regp->r_regs[R_A5];
1077 1.1 cgd framep->tf_regs[FRAME_T8] = regp->r_regs[R_T8];
1078 1.1 cgd framep->tf_regs[FRAME_T9] = regp->r_regs[R_T9];
1079 1.1 cgd framep->tf_regs[FRAME_T10] = regp->r_regs[R_T10];
1080 1.1 cgd framep->tf_regs[FRAME_T11] = regp->r_regs[R_T11];
1081 1.1 cgd framep->tf_regs[FRAME_RA] = regp->r_regs[R_RA];
1082 1.1 cgd framep->tf_regs[FRAME_T12] = regp->r_regs[R_T12];
1083 1.1 cgd framep->tf_regs[FRAME_AT] = regp->r_regs[R_AT];
1084 1.34 cgd framep->tf_regs[FRAME_GP] = regp->r_regs[R_GP];
1085 1.35 cgd /* framep->tf_regs[FRAME_SP] = regp->r_regs[R_SP]; XXX */
1086 1.1 cgd /* ??? = regp->r_regs[R_ZERO]; */
1087 1.1 cgd }
1088 1.1 cgd
1089 1.1 cgd void
1090 1.1 cgd printregs(regp)
1091 1.1 cgd struct reg *regp;
1092 1.1 cgd {
1093 1.1 cgd int i;
1094 1.1 cgd
1095 1.1 cgd for (i = 0; i < 32; i++)
1096 1.46 christos printf("R%d:\t0x%016lx%s", i, regp->r_regs[i],
1097 1.1 cgd i & 1 ? "\n" : "\t");
1098 1.1 cgd }
1099 1.1 cgd
1100 1.1 cgd void
1101 1.1 cgd regdump(framep)
1102 1.1 cgd struct trapframe *framep;
1103 1.1 cgd {
1104 1.1 cgd struct reg reg;
1105 1.1 cgd
1106 1.1 cgd frametoreg(framep, ®);
1107 1.35 cgd reg.r_regs[R_SP] = alpha_pal_rdusp();
1108 1.35 cgd
1109 1.46 christos printf("REGISTERS:\n");
1110 1.1 cgd printregs(®);
1111 1.1 cgd }
1112 1.1 cgd
1113 1.1 cgd #ifdef DEBUG
1114 1.1 cgd int sigdebug = 0;
1115 1.1 cgd int sigpid = 0;
1116 1.1 cgd #define SDB_FOLLOW 0x01
1117 1.1 cgd #define SDB_KSTACK 0x02
1118 1.1 cgd #endif
1119 1.1 cgd
1120 1.1 cgd /*
1121 1.1 cgd * Send an interrupt to process.
1122 1.1 cgd */
1123 1.1 cgd void
1124 1.1 cgd sendsig(catcher, sig, mask, code)
1125 1.1 cgd sig_t catcher;
1126 1.1 cgd int sig, mask;
1127 1.1 cgd u_long code;
1128 1.1 cgd {
1129 1.1 cgd struct proc *p = curproc;
1130 1.1 cgd struct sigcontext *scp, ksc;
1131 1.1 cgd struct trapframe *frame;
1132 1.1 cgd struct sigacts *psp = p->p_sigacts;
1133 1.1 cgd int oonstack, fsize, rndfsize;
1134 1.1 cgd extern char sigcode[], esigcode[];
1135 1.1 cgd extern struct proc *fpcurproc;
1136 1.1 cgd
1137 1.1 cgd frame = p->p_md.md_tf;
1138 1.9 mycroft oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
1139 1.1 cgd fsize = sizeof ksc;
1140 1.1 cgd rndfsize = ((fsize + 15) / 16) * 16;
1141 1.1 cgd /*
1142 1.1 cgd * Allocate and validate space for the signal handler
1143 1.1 cgd * context. Note that if the stack is in P0 space, the
1144 1.1 cgd * call to grow() is a nop, and the useracc() check
1145 1.1 cgd * will fail if the process has not already allocated
1146 1.1 cgd * the space with a `brk'.
1147 1.1 cgd */
1148 1.1 cgd if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack &&
1149 1.1 cgd (psp->ps_sigonstack & sigmask(sig))) {
1150 1.14 jtc scp = (struct sigcontext *)(psp->ps_sigstk.ss_sp +
1151 1.1 cgd psp->ps_sigstk.ss_size - rndfsize);
1152 1.9 mycroft psp->ps_sigstk.ss_flags |= SS_ONSTACK;
1153 1.1 cgd } else
1154 1.35 cgd scp = (struct sigcontext *)(alpha_pal_rdusp() - rndfsize);
1155 1.1 cgd if ((u_long)scp <= USRSTACK - ctob(p->p_vmspace->vm_ssize))
1156 1.1 cgd (void)grow(p, (u_long)scp);
1157 1.1 cgd #ifdef DEBUG
1158 1.1 cgd if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
1159 1.46 christos printf("sendsig(%d): sig %d ssp %p usp %p\n", p->p_pid,
1160 1.1 cgd sig, &oonstack, scp);
1161 1.1 cgd #endif
1162 1.1 cgd if (useracc((caddr_t)scp, fsize, B_WRITE) == 0) {
1163 1.1 cgd #ifdef DEBUG
1164 1.1 cgd if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
1165 1.46 christos printf("sendsig(%d): useracc failed on sig %d\n",
1166 1.1 cgd p->p_pid, sig);
1167 1.1 cgd #endif
1168 1.1 cgd /*
1169 1.1 cgd * Process has trashed its stack; give it an illegal
1170 1.1 cgd * instruction to halt it in its tracks.
1171 1.1 cgd */
1172 1.1 cgd SIGACTION(p, SIGILL) = SIG_DFL;
1173 1.1 cgd sig = sigmask(SIGILL);
1174 1.1 cgd p->p_sigignore &= ~sig;
1175 1.1 cgd p->p_sigcatch &= ~sig;
1176 1.1 cgd p->p_sigmask &= ~sig;
1177 1.1 cgd psignal(p, SIGILL);
1178 1.1 cgd return;
1179 1.1 cgd }
1180 1.1 cgd
1181 1.1 cgd /*
1182 1.1 cgd * Build the signal context to be used by sigreturn.
1183 1.1 cgd */
1184 1.1 cgd ksc.sc_onstack = oonstack;
1185 1.1 cgd ksc.sc_mask = mask;
1186 1.34 cgd ksc.sc_pc = frame->tf_regs[FRAME_PC];
1187 1.34 cgd ksc.sc_ps = frame->tf_regs[FRAME_PS];
1188 1.1 cgd
1189 1.1 cgd /* copy the registers. */
1190 1.1 cgd frametoreg(frame, (struct reg *)ksc.sc_regs);
1191 1.1 cgd ksc.sc_regs[R_ZERO] = 0xACEDBADE; /* magic number */
1192 1.35 cgd ksc.sc_regs[R_SP] = alpha_pal_rdusp();
1193 1.1 cgd
1194 1.1 cgd /* save the floating-point state, if necessary, then copy it. */
1195 1.1 cgd if (p == fpcurproc) {
1196 1.32 cgd alpha_pal_wrfen(1);
1197 1.1 cgd savefpstate(&p->p_addr->u_pcb.pcb_fp);
1198 1.32 cgd alpha_pal_wrfen(0);
1199 1.1 cgd fpcurproc = NULL;
1200 1.1 cgd }
1201 1.1 cgd ksc.sc_ownedfp = p->p_md.md_flags & MDP_FPUSED;
1202 1.1 cgd bcopy(&p->p_addr->u_pcb.pcb_fp, (struct fpreg *)ksc.sc_fpregs,
1203 1.1 cgd sizeof(struct fpreg));
1204 1.1 cgd ksc.sc_fp_control = 0; /* XXX ? */
1205 1.1 cgd bzero(ksc.sc_reserved, sizeof ksc.sc_reserved); /* XXX */
1206 1.1 cgd bzero(ksc.sc_xxx, sizeof ksc.sc_xxx); /* XXX */
1207 1.1 cgd
1208 1.1 cgd
1209 1.1 cgd #ifdef COMPAT_OSF1
1210 1.1 cgd /*
1211 1.1 cgd * XXX Create an OSF/1-style sigcontext and associated goo.
1212 1.1 cgd */
1213 1.1 cgd #endif
1214 1.1 cgd
1215 1.1 cgd /*
1216 1.1 cgd * copy the frame out to userland.
1217 1.1 cgd */
1218 1.1 cgd (void) copyout((caddr_t)&ksc, (caddr_t)scp, fsize);
1219 1.1 cgd #ifdef DEBUG
1220 1.1 cgd if (sigdebug & SDB_FOLLOW)
1221 1.46 christos printf("sendsig(%d): sig %d scp %p code %lx\n", p->p_pid, sig,
1222 1.1 cgd scp, code);
1223 1.1 cgd #endif
1224 1.1 cgd
1225 1.1 cgd /*
1226 1.1 cgd * Set up the registers to return to sigcode.
1227 1.1 cgd */
1228 1.34 cgd frame->tf_regs[FRAME_PC] =
1229 1.34 cgd (u_int64_t)PS_STRINGS - (esigcode - sigcode);
1230 1.34 cgd frame->tf_regs[FRAME_A0] = sig;
1231 1.34 cgd frame->tf_regs[FRAME_A1] = code;
1232 1.34 cgd frame->tf_regs[FRAME_A2] = (u_int64_t)scp;
1233 1.1 cgd frame->tf_regs[FRAME_T12] = (u_int64_t)catcher; /* t12 is pv */
1234 1.35 cgd alpha_pal_wrusp((unsigned long)scp);
1235 1.1 cgd
1236 1.1 cgd #ifdef DEBUG
1237 1.1 cgd if (sigdebug & SDB_FOLLOW)
1238 1.46 christos printf("sendsig(%d): pc %lx, catcher %lx\n", p->p_pid,
1239 1.34 cgd frame->tf_regs[FRAME_PC], frame->tf_regs[FRAME_A3]);
1240 1.1 cgd if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
1241 1.46 christos printf("sendsig(%d): sig %d returns\n",
1242 1.1 cgd p->p_pid, sig);
1243 1.1 cgd #endif
1244 1.1 cgd }
1245 1.1 cgd
1246 1.1 cgd /*
1247 1.1 cgd * System call to cleanup state after a signal
1248 1.1 cgd * has been taken. Reset signal mask and
1249 1.1 cgd * stack state from context left by sendsig (above).
1250 1.1 cgd * Return to previous pc and psl as specified by
1251 1.1 cgd * context left by sendsig. Check carefully to
1252 1.1 cgd * make sure that the user has not modified the
1253 1.1 cgd * psl to gain improper priviledges or to cause
1254 1.1 cgd * a machine fault.
1255 1.1 cgd */
1256 1.1 cgd /* ARGSUSED */
1257 1.11 mycroft int
1258 1.11 mycroft sys_sigreturn(p, v, retval)
1259 1.1 cgd struct proc *p;
1260 1.10 thorpej void *v;
1261 1.10 thorpej register_t *retval;
1262 1.10 thorpej {
1263 1.11 mycroft struct sys_sigreturn_args /* {
1264 1.1 cgd syscallarg(struct sigcontext *) sigcntxp;
1265 1.10 thorpej } */ *uap = v;
1266 1.1 cgd struct sigcontext *scp, ksc;
1267 1.1 cgd extern struct proc *fpcurproc;
1268 1.1 cgd
1269 1.1 cgd scp = SCARG(uap, sigcntxp);
1270 1.1 cgd #ifdef DEBUG
1271 1.1 cgd if (sigdebug & SDB_FOLLOW)
1272 1.46 christos printf("sigreturn: pid %d, scp %p\n", p->p_pid, scp);
1273 1.1 cgd #endif
1274 1.1 cgd
1275 1.1 cgd if (ALIGN(scp) != (u_int64_t)scp)
1276 1.1 cgd return (EINVAL);
1277 1.1 cgd
1278 1.1 cgd /*
1279 1.1 cgd * Test and fetch the context structure.
1280 1.1 cgd * We grab it all at once for speed.
1281 1.1 cgd */
1282 1.1 cgd if (useracc((caddr_t)scp, sizeof (*scp), B_WRITE) == 0 ||
1283 1.1 cgd copyin((caddr_t)scp, (caddr_t)&ksc, sizeof ksc))
1284 1.1 cgd return (EINVAL);
1285 1.1 cgd
1286 1.1 cgd if (ksc.sc_regs[R_ZERO] != 0xACEDBADE) /* magic number */
1287 1.1 cgd return (EINVAL);
1288 1.1 cgd /*
1289 1.1 cgd * Restore the user-supplied information
1290 1.1 cgd */
1291 1.1 cgd if (ksc.sc_onstack)
1292 1.9 mycroft p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
1293 1.1 cgd else
1294 1.9 mycroft p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
1295 1.1 cgd p->p_sigmask = ksc.sc_mask &~ sigcantmask;
1296 1.1 cgd
1297 1.34 cgd p->p_md.md_tf->tf_regs[FRAME_PC] = ksc.sc_pc;
1298 1.34 cgd p->p_md.md_tf->tf_regs[FRAME_PS] =
1299 1.32 cgd (ksc.sc_ps | ALPHA_PSL_USERSET) & ~ALPHA_PSL_USERCLR;
1300 1.1 cgd
1301 1.1 cgd regtoframe((struct reg *)ksc.sc_regs, p->p_md.md_tf);
1302 1.35 cgd alpha_pal_wrusp(ksc.sc_regs[R_SP]);
1303 1.1 cgd
1304 1.1 cgd /* XXX ksc.sc_ownedfp ? */
1305 1.1 cgd if (p == fpcurproc)
1306 1.1 cgd fpcurproc = NULL;
1307 1.1 cgd bcopy((struct fpreg *)ksc.sc_fpregs, &p->p_addr->u_pcb.pcb_fp,
1308 1.1 cgd sizeof(struct fpreg));
1309 1.1 cgd /* XXX ksc.sc_fp_control ? */
1310 1.1 cgd
1311 1.1 cgd #ifdef DEBUG
1312 1.1 cgd if (sigdebug & SDB_FOLLOW)
1313 1.46 christos printf("sigreturn(%d): returns\n", p->p_pid);
1314 1.1 cgd #endif
1315 1.1 cgd return (EJUSTRETURN);
1316 1.1 cgd }
1317 1.1 cgd
1318 1.1 cgd /*
1319 1.1 cgd * machine dependent system variables.
1320 1.1 cgd */
1321 1.33 cgd int
1322 1.1 cgd cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
1323 1.1 cgd int *name;
1324 1.1 cgd u_int namelen;
1325 1.1 cgd void *oldp;
1326 1.1 cgd size_t *oldlenp;
1327 1.1 cgd void *newp;
1328 1.1 cgd size_t newlen;
1329 1.1 cgd struct proc *p;
1330 1.1 cgd {
1331 1.1 cgd dev_t consdev;
1332 1.1 cgd
1333 1.1 cgd /* all sysctl names at this level are terminal */
1334 1.1 cgd if (namelen != 1)
1335 1.1 cgd return (ENOTDIR); /* overloaded */
1336 1.1 cgd
1337 1.1 cgd switch (name[0]) {
1338 1.1 cgd case CPU_CONSDEV:
1339 1.1 cgd if (cn_tab != NULL)
1340 1.1 cgd consdev = cn_tab->cn_dev;
1341 1.1 cgd else
1342 1.1 cgd consdev = NODEV;
1343 1.1 cgd return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
1344 1.1 cgd sizeof consdev));
1345 1.30 cgd
1346 1.30 cgd case CPU_ROOT_DEVICE:
1347 1.64 thorpej return (sysctl_rdstring(oldp, oldlenp, newp,
1348 1.64 thorpej root_device->dv_xname));
1349 1.36 cgd
1350 1.36 cgd case CPU_UNALIGNED_PRINT:
1351 1.36 cgd return (sysctl_int(oldp, oldlenp, newp, newlen,
1352 1.36 cgd &alpha_unaligned_print));
1353 1.36 cgd
1354 1.36 cgd case CPU_UNALIGNED_FIX:
1355 1.36 cgd return (sysctl_int(oldp, oldlenp, newp, newlen,
1356 1.36 cgd &alpha_unaligned_fix));
1357 1.36 cgd
1358 1.36 cgd case CPU_UNALIGNED_SIGBUS:
1359 1.36 cgd return (sysctl_int(oldp, oldlenp, newp, newlen,
1360 1.36 cgd &alpha_unaligned_sigbus));
1361 1.61 cgd
1362 1.61 cgd case CPU_BOOTED_KERNEL:
1363 1.61 cgd return (sysctl_rdstring(oldp, oldlenp, newp, booted_kernel));
1364 1.30 cgd
1365 1.1 cgd default:
1366 1.1 cgd return (EOPNOTSUPP);
1367 1.1 cgd }
1368 1.1 cgd /* NOTREACHED */
1369 1.1 cgd }
1370 1.1 cgd
1371 1.1 cgd /*
1372 1.1 cgd * Set registers on exec.
1373 1.1 cgd */
1374 1.1 cgd void
1375 1.5 christos setregs(p, pack, stack, retval)
1376 1.1 cgd register struct proc *p;
1377 1.5 christos struct exec_package *pack;
1378 1.1 cgd u_long stack;
1379 1.1 cgd register_t *retval;
1380 1.1 cgd {
1381 1.1 cgd struct trapframe *tfp = p->p_md.md_tf;
1382 1.56 cgd extern struct proc *fpcurproc;
1383 1.56 cgd #ifdef DEBUG
1384 1.1 cgd int i;
1385 1.56 cgd #endif
1386 1.43 cgd
1387 1.43 cgd #ifdef DEBUG
1388 1.43 cgd /*
1389 1.43 cgd * Crash and dump, if the user requested it.
1390 1.43 cgd */
1391 1.43 cgd if (boothowto & RB_DUMP)
1392 1.43 cgd panic("crash requested by boot flags");
1393 1.43 cgd #endif
1394 1.1 cgd
1395 1.1 cgd #ifdef DEBUG
1396 1.34 cgd for (i = 0; i < FRAME_SIZE; i++)
1397 1.1 cgd tfp->tf_regs[i] = 0xbabefacedeadbeef;
1398 1.1 cgd #else
1399 1.34 cgd bzero(tfp->tf_regs, FRAME_SIZE * sizeof tfp->tf_regs[0]);
1400 1.1 cgd #endif
1401 1.1 cgd bzero(&p->p_addr->u_pcb.pcb_fp, sizeof p->p_addr->u_pcb.pcb_fp);
1402 1.7 cgd #define FP_RN 2 /* XXX */
1403 1.7 cgd p->p_addr->u_pcb.pcb_fp.fpr_cr = (long)FP_RN << 58;
1404 1.35 cgd alpha_pal_wrusp(stack);
1405 1.34 cgd tfp->tf_regs[FRAME_PS] = ALPHA_PSL_USERSET;
1406 1.34 cgd tfp->tf_regs[FRAME_PC] = pack->ep_entry & ~3;
1407 1.41 cgd
1408 1.62 cgd tfp->tf_regs[FRAME_A0] = stack; /* a0 = sp */
1409 1.62 cgd tfp->tf_regs[FRAME_A1] = 0; /* a1 = rtld cleanup */
1410 1.62 cgd tfp->tf_regs[FRAME_A2] = 0; /* a2 = rtld object */
1411 1.63 cgd tfp->tf_regs[FRAME_A3] = (u_int64_t)PS_STRINGS; /* a3 = ps_strings */
1412 1.41 cgd tfp->tf_regs[FRAME_T12] = tfp->tf_regs[FRAME_PC]; /* a.k.a. PV */
1413 1.1 cgd
1414 1.33 cgd p->p_md.md_flags &= ~MDP_FPUSED;
1415 1.1 cgd if (fpcurproc == p)
1416 1.1 cgd fpcurproc = NULL;
1417 1.1 cgd
1418 1.1 cgd retval[0] = retval[1] = 0;
1419 1.1 cgd }
1420 1.1 cgd
1421 1.1 cgd void
1422 1.1 cgd netintr()
1423 1.1 cgd {
1424 1.49 cgd int n, s;
1425 1.49 cgd
1426 1.49 cgd s = splhigh();
1427 1.49 cgd n = netisr;
1428 1.49 cgd netisr = 0;
1429 1.49 cgd splx(s);
1430 1.49 cgd
1431 1.49 cgd #define DONETISR(bit, fn) \
1432 1.49 cgd do { \
1433 1.49 cgd if (n & (1 << (bit))) \
1434 1.49 cgd fn; \
1435 1.49 cgd } while (0)
1436 1.49 cgd
1437 1.1 cgd #ifdef INET
1438 1.72 cgd #if NARP > 0
1439 1.49 cgd DONETISR(NETISR_ARP, arpintr());
1440 1.72 cgd #endif
1441 1.49 cgd DONETISR(NETISR_IP, ipintr());
1442 1.70 christos #endif
1443 1.70 christos #ifdef NETATALK
1444 1.70 christos DONETISR(NETISR_ATALK, atintr());
1445 1.1 cgd #endif
1446 1.1 cgd #ifdef NS
1447 1.49 cgd DONETISR(NETISR_NS, nsintr());
1448 1.1 cgd #endif
1449 1.1 cgd #ifdef ISO
1450 1.49 cgd DONETISR(NETISR_ISO, clnlintr());
1451 1.1 cgd #endif
1452 1.1 cgd #ifdef CCITT
1453 1.49 cgd DONETISR(NETISR_CCITT, ccittintr());
1454 1.49 cgd #endif
1455 1.49 cgd #ifdef NATM
1456 1.49 cgd DONETISR(NETISR_NATM, natmintr());
1457 1.1 cgd #endif
1458 1.49 cgd #if NPPP > 1
1459 1.49 cgd DONETISR(NETISR_PPP, pppintr());
1460 1.8 cgd #endif
1461 1.49 cgd
1462 1.49 cgd #undef DONETISR
1463 1.1 cgd }
1464 1.1 cgd
1465 1.1 cgd void
1466 1.1 cgd do_sir()
1467 1.1 cgd {
1468 1.58 cgd u_int64_t n;
1469 1.1 cgd
1470 1.59 cgd do {
1471 1.60 cgd (void)splhigh();
1472 1.58 cgd n = ssir;
1473 1.58 cgd ssir = 0;
1474 1.60 cgd splsoft(); /* don't recurse through spl0() */
1475 1.59 cgd
1476 1.59 cgd #define DO_SIR(bit, fn) \
1477 1.59 cgd do { \
1478 1.60 cgd if (n & (bit)) { \
1479 1.59 cgd cnt.v_soft++; \
1480 1.59 cgd fn; \
1481 1.59 cgd } \
1482 1.59 cgd } while (0)
1483 1.59 cgd
1484 1.60 cgd DO_SIR(SIR_NET, netintr());
1485 1.60 cgd DO_SIR(SIR_CLOCK, softclock());
1486 1.60 cgd
1487 1.60 cgd #undef DO_SIR
1488 1.59 cgd } while (ssir != 0);
1489 1.1 cgd }
1490 1.1 cgd
1491 1.1 cgd int
1492 1.1 cgd spl0()
1493 1.1 cgd {
1494 1.1 cgd
1495 1.59 cgd if (ssir)
1496 1.59 cgd do_sir(); /* it lowers the IPL itself */
1497 1.1 cgd
1498 1.32 cgd return (alpha_pal_swpipl(ALPHA_PSL_IPL_0));
1499 1.1 cgd }
1500 1.1 cgd
1501 1.1 cgd /*
1502 1.1 cgd * The following primitives manipulate the run queues. _whichqs tells which
1503 1.1 cgd * of the 32 queues _qs have processes in them. Setrunqueue puts processes
1504 1.52 cgd * into queues, Remrunqueue removes them from queues. The running process is
1505 1.52 cgd * on no queue, other processes are on a queue related to p->p_priority,
1506 1.52 cgd * divided by 4 actually to shrink the 0-127 range of priorities into the 32
1507 1.52 cgd * available queues.
1508 1.1 cgd */
1509 1.1 cgd /*
1510 1.1 cgd * setrunqueue(p)
1511 1.1 cgd * proc *p;
1512 1.1 cgd *
1513 1.1 cgd * Call should be made at splclock(), and p->p_stat should be SRUN.
1514 1.1 cgd */
1515 1.1 cgd
1516 1.1 cgd void
1517 1.1 cgd setrunqueue(p)
1518 1.1 cgd struct proc *p;
1519 1.1 cgd {
1520 1.1 cgd int bit;
1521 1.1 cgd
1522 1.1 cgd /* firewall: p->p_back must be NULL */
1523 1.1 cgd if (p->p_back != NULL)
1524 1.1 cgd panic("setrunqueue");
1525 1.1 cgd
1526 1.1 cgd bit = p->p_priority >> 2;
1527 1.1 cgd whichqs |= (1 << bit);
1528 1.1 cgd p->p_forw = (struct proc *)&qs[bit];
1529 1.1 cgd p->p_back = qs[bit].ph_rlink;
1530 1.1 cgd p->p_back->p_forw = p;
1531 1.1 cgd qs[bit].ph_rlink = p;
1532 1.1 cgd }
1533 1.1 cgd
1534 1.1 cgd /*
1535 1.52 cgd * remrunqueue(p)
1536 1.1 cgd *
1537 1.1 cgd * Call should be made at splclock().
1538 1.1 cgd */
1539 1.1 cgd void
1540 1.52 cgd remrunqueue(p)
1541 1.1 cgd struct proc *p;
1542 1.1 cgd {
1543 1.1 cgd int bit;
1544 1.1 cgd
1545 1.1 cgd bit = p->p_priority >> 2;
1546 1.1 cgd if ((whichqs & (1 << bit)) == 0)
1547 1.52 cgd panic("remrunqueue");
1548 1.1 cgd
1549 1.1 cgd p->p_back->p_forw = p->p_forw;
1550 1.1 cgd p->p_forw->p_back = p->p_back;
1551 1.1 cgd p->p_back = NULL; /* for firewall checking. */
1552 1.1 cgd
1553 1.1 cgd if ((struct proc *)&qs[bit] == qs[bit].ph_link)
1554 1.1 cgd whichqs &= ~(1 << bit);
1555 1.1 cgd }
1556 1.1 cgd
1557 1.1 cgd /*
1558 1.1 cgd * Return the best possible estimate of the time in the timeval
1559 1.1 cgd * to which tvp points. Unfortunately, we can't read the hardware registers.
1560 1.1 cgd * We guarantee that the time will be greater than the value obtained by a
1561 1.1 cgd * previous call.
1562 1.1 cgd */
1563 1.1 cgd void
1564 1.1 cgd microtime(tvp)
1565 1.1 cgd register struct timeval *tvp;
1566 1.1 cgd {
1567 1.1 cgd int s = splclock();
1568 1.1 cgd static struct timeval lasttime;
1569 1.1 cgd
1570 1.1 cgd *tvp = time;
1571 1.1 cgd #ifdef notdef
1572 1.1 cgd tvp->tv_usec += clkread();
1573 1.1 cgd while (tvp->tv_usec > 1000000) {
1574 1.1 cgd tvp->tv_sec++;
1575 1.1 cgd tvp->tv_usec -= 1000000;
1576 1.1 cgd }
1577 1.1 cgd #endif
1578 1.1 cgd if (tvp->tv_sec == lasttime.tv_sec &&
1579 1.1 cgd tvp->tv_usec <= lasttime.tv_usec &&
1580 1.1 cgd (tvp->tv_usec = lasttime.tv_usec + 1) > 1000000) {
1581 1.1 cgd tvp->tv_sec++;
1582 1.1 cgd tvp->tv_usec -= 1000000;
1583 1.1 cgd }
1584 1.1 cgd lasttime = *tvp;
1585 1.1 cgd splx(s);
1586 1.15 cgd }
1587 1.15 cgd
1588 1.15 cgd /*
1589 1.15 cgd * Wait "n" microseconds.
1590 1.15 cgd */
1591 1.32 cgd void
1592 1.15 cgd delay(n)
1593 1.32 cgd unsigned long n;
1594 1.15 cgd {
1595 1.15 cgd long N = cycles_per_usec * (n);
1596 1.15 cgd
1597 1.15 cgd while (N > 0) /* XXX */
1598 1.15 cgd N -= 3; /* XXX */
1599 1.1 cgd }
1600 1.1 cgd
1601 1.8 cgd #if defined(COMPAT_OSF1) || 1 /* XXX */
1602 1.55 cgd void cpu_exec_ecoff_setregs __P((struct proc *, struct exec_package *,
1603 1.55 cgd u_long, register_t *));
1604 1.55 cgd
1605 1.1 cgd void
1606 1.19 cgd cpu_exec_ecoff_setregs(p, epp, stack, retval)
1607 1.1 cgd struct proc *p;
1608 1.19 cgd struct exec_package *epp;
1609 1.5 christos u_long stack;
1610 1.5 christos register_t *retval;
1611 1.1 cgd {
1612 1.19 cgd struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
1613 1.1 cgd
1614 1.19 cgd setregs(p, epp, stack, retval);
1615 1.34 cgd p->p_md.md_tf->tf_regs[FRAME_GP] = execp->a.gp_value;
1616 1.1 cgd }
1617 1.1 cgd
1618 1.1 cgd /*
1619 1.1 cgd * cpu_exec_ecoff_hook():
1620 1.1 cgd * cpu-dependent ECOFF format hook for execve().
1621 1.1 cgd *
1622 1.1 cgd * Do any machine-dependent diddling of the exec package when doing ECOFF.
1623 1.1 cgd *
1624 1.1 cgd */
1625 1.1 cgd int
1626 1.19 cgd cpu_exec_ecoff_hook(p, epp)
1627 1.1 cgd struct proc *p;
1628 1.1 cgd struct exec_package *epp;
1629 1.1 cgd {
1630 1.19 cgd struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
1631 1.5 christos extern struct emul emul_netbsd;
1632 1.5 christos #ifdef COMPAT_OSF1
1633 1.5 christos extern struct emul emul_osf1;
1634 1.5 christos #endif
1635 1.1 cgd
1636 1.19 cgd switch (execp->f.f_magic) {
1637 1.5 christos #ifdef COMPAT_OSF1
1638 1.1 cgd case ECOFF_MAGIC_ALPHA:
1639 1.5 christos epp->ep_emul = &emul_osf1;
1640 1.1 cgd break;
1641 1.5 christos #endif
1642 1.1 cgd
1643 1.1 cgd case ECOFF_MAGIC_NETBSD_ALPHA:
1644 1.5 christos epp->ep_emul = &emul_netbsd;
1645 1.1 cgd break;
1646 1.1 cgd
1647 1.1 cgd default:
1648 1.12 cgd return ENOEXEC;
1649 1.1 cgd }
1650 1.1 cgd return 0;
1651 1.1 cgd }
1652 1.1 cgd #endif
1653 1.50 cgd
1654 1.50 cgd /* XXX XXX BEGIN XXX XXX */
1655 1.50 cgd vm_offset_t alpha_XXX_dmamap_or; /* XXX */
1656 1.50 cgd /* XXX */
1657 1.50 cgd vm_offset_t /* XXX */
1658 1.50 cgd alpha_XXX_dmamap(v) /* XXX */
1659 1.51 cgd vm_offset_t v; /* XXX */
1660 1.50 cgd { /* XXX */
1661 1.50 cgd /* XXX */
1662 1.51 cgd return (vtophys(v) | alpha_XXX_dmamap_or); /* XXX */
1663 1.50 cgd } /* XXX */
1664 1.50 cgd /* XXX XXX END XXX XXX */
1665