Annotation of sys/arch/amd64/amd64/machdep.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: machdep.c,v 1.60 2007/08/02 16:40:27 deraadt Exp $ */
2: /* $NetBSD: machdep.c,v 1.3 2003/05/07 22:58:18 fvdl Exp $ */
3:
4: /*-
5: * Copyright (c) 1996, 1997, 1998, 2000 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
10: * Simulation Facility, NASA Ames Research Center.
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 NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: /*-
42: * Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
43: * All rights reserved.
44: *
45: * This code is derived from software contributed to Berkeley by
46: * William Jolitz.
47: *
48: * Redistribution and use in source and binary forms, with or without
49: * modification, are permitted provided that the following conditions
50: * are met:
51: * 1. Redistributions of source code must retain the above copyright
52: * notice, this list of conditions and the following disclaimer.
53: * 2. Redistributions in binary form must reproduce the above copyright
54: * notice, this list of conditions and the following disclaimer in the
55: * documentation and/or other materials provided with the distribution.
56: * 3. Neither the name of the University nor the names of its contributors
57: * may be used to endorse or promote products derived from this software
58: * without specific prior written permission.
59: *
60: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
61: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
62: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
63: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
64: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
65: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
66: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
67: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
68: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
69: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
70: * SUCH DAMAGE.
71: *
72: * @(#)machdep.c 7.4 (Berkeley) 6/3/91
73: */
74:
75: #include <sys/param.h>
76: #include <sys/systm.h>
77: #include <sys/signal.h>
78: #include <sys/signalvar.h>
79: #include <sys/kernel.h>
80: #include <sys/proc.h>
81: #include <sys/user.h>
82: #include <sys/exec.h>
83: #include <sys/buf.h>
84: #include <sys/reboot.h>
85: #include <sys/conf.h>
86: #include <sys/file.h>
87: #include <sys/malloc.h>
88: #include <sys/mbuf.h>
89: #include <sys/msgbuf.h>
90: #include <sys/mount.h>
91: #include <sys/vnode.h>
92: #include <sys/extent.h>
93: #include <sys/core.h>
94: #include <sys/kcore.h>
95: #include <sys/syscallargs.h>
96:
97: #ifdef SYSVMSG
98: #include <sys/msg.h>
99: #endif
100:
101: #ifdef KGDB
102: #include <sys/kgdb.h>
103: #endif
104:
105: #include <dev/cons.h>
106: #include <stand/boot/bootarg.h>
107:
108: #include <uvm/uvm_extern.h>
109: #include <uvm/uvm_page.h>
110:
111: #include <sys/sysctl.h>
112:
113: #include <machine/cpu.h>
114: #include <machine/cpufunc.h>
115: #include <machine/gdt.h>
116: #include <machine/pio.h>
117: #include <machine/psl.h>
118: #include <machine/reg.h>
119: #include <machine/specialreg.h>
120: #include <machine/fpu.h>
121: #include <machine/mtrr.h>
122: #include <machine/biosvar.h>
123: #include <machine/mpbiosvar.h>
124: #include <machine/reg.h>
125: #include <machine/kcore.h>
126:
127: #include <dev/isa/isareg.h>
128: #include <machine/isa_machdep.h>
129: #include <dev/ic/i8042reg.h>
130: #include <amd64/isa/nvram.h>
131:
132: #ifdef DDB
133: #include <machine/db_machdep.h>
134: #include <ddb/db_extern.h>
135: #endif
136:
137: #include "isa.h"
138: #include "isadma.h"
139: #include "ksyms.h"
140:
141: #include "acpi.h"
142: #if NACPI > 0
143: #include <dev/acpi/acpivar.h>
144: #endif
145:
146:
147: /* the following is used externally (sysctl_hw) */
148: char machine[] = MACHINE;
149:
150: /* the following is used externally for concurrent handlers */
151: int setperf_prio = 0;
152:
153: #ifdef CPURESET_DELAY
154: int cpureset_delay = CPURESET_DELAY;
155: #else
156: int cpureset_delay = 2000; /* default to 2s */
157: #endif
158:
159: int physmem;
160: u_int64_t dumpmem_low;
161: u_int64_t dumpmem_high;
162: extern int boothowto;
163: int cpu_class;
164:
165: char *ssym = NULL;
166: vaddr_t kern_end;
167:
168: vaddr_t msgbuf_vaddr;
169: paddr_t msgbuf_paddr;
170:
171: vaddr_t idt_vaddr;
172: paddr_t idt_paddr;
173:
174: vaddr_t lo32_vaddr;
175: paddr_t lo32_paddr;
176:
177: int kbd_reset;
178:
179: struct vm_map *exec_map = NULL;
180: struct vm_map *phys_map = NULL;
181:
182: #ifndef BUFCACHEPERCENT
183: #define BUFCACHEPERCENT 10
184: #endif
185:
186: #ifdef BUFPAGES
187: int bufpages = BUFPAGES;
188: #else
189: int bufpages = 0;
190: #endif
191: int bufcachepercent = BUFCACHEPERCENT;
192:
193: #ifdef DEBUG
194: int sigdebug = 0;
195: pid_t sigpid = 0;
196: #define SDB_FOLLOW 0x01
197: #endif
198:
199: extern paddr_t avail_start, avail_end;
200:
201: void (*delay_func)(int) = i8254_delay;
202: void (*initclock_func)(void) = i8254_initclocks;
203:
204: struct mtrr_funcs *mtrr_funcs;
205:
206: /*
207: * Format of boot information passed to us by 32-bit /boot
208: */
209: typedef struct _boot_args32 {
210: int ba_type;
211: int ba_size;
212: int ba_nextX; /* a ptr in 32-bit world, but not here */
213: char ba_arg[1];
214: } bootarg32_t;
215:
216: #define BOOTARGC_MAX NBPG /* one page */
217:
218: #ifdef NFSCLIENT
219: bios_bootmac_t *bios_bootmac;
220: #endif
221:
222: /* locore copies the arguments from /boot to here for us */
223: char bootinfo[BOOTARGC_MAX];
224: int bootinfo_size = BOOTARGC_MAX;
225:
226: void getbootinfo(char *, int);
227:
228: /* Data passed to us by /boot, filled in by getbootinfo() */
229: #if NAPM > 0 || defined(DEBUG)
230: bios_apminfo_t *apm;
231: #endif
232: #if NPCI > 0
233: bios_pciinfo_t *bios_pciinfo;
234: #endif
235: bios_diskinfo_t *bios_diskinfo;
236: bios_memmap_t *bios_memmap;
237: u_int32_t bios_cksumlen;
238:
239: /*
240: * Size of memory segments, before any memory is stolen.
241: */
242: phys_ram_seg_t mem_clusters[VM_PHYSSEG_MAX];
243: int mem_cluster_cnt;
244:
245: vaddr_t allocsys(vaddr_t);
246: void setup_buffers(void);
247: int cpu_dump(void);
248: int cpu_dumpsize(void);
249: u_long cpu_dump_mempagecnt(void);
250: void dumpsys(void);
251: void init_x86_64(paddr_t);
252:
253: #ifdef KGDB
254: #ifndef KGDB_DEVNAME
255: #define KGDB_DEVNAME "com"
256: #endif /* KGDB_DEVNAME */
257: char kgdb_devname[] = KGDB_DEVNAME;
258: #if NCOM > 0
259: #ifndef KGDBADDR
260: #define KGDBADDR 0x3f8
261: #endif /* KGDBADDR */
262: int comkgdbaddr = KGDBADDR;
263: #ifndef KGDBRATE
264: #define KGDBRATE TTYDEF_SPEED
265: #endif /* KGDBRATE */
266: int comkgdbrate = KGDBRATE;
267: #ifndef KGDBMODE
268: #define KGDBMODE ((TTYDEF_CFLAG & ~(CSIZE | CSTOPB | PARENB)) | CS8)
269: #endif /* KGDBMODE */
270: int comkgdbmode = KGDBMODE;
271: #endif /* NCOM */
272: void kgdb_port_init(void);
273: #endif /* KGDB */
274:
275: #ifdef APERTURE
276: #ifdef INSECURE
277: int allowaperture = 1;
278: #else
279: int allowaperture = 0;
280: #endif
281: #endif
282:
283: /*
284: * Machine-dependent startup code
285: */
286: void
287: cpu_startup(void)
288: {
289: vaddr_t v;
290: vsize_t sz;
291: vaddr_t minaddr, maxaddr;
292:
293: msgbuf_vaddr = PMAP_DIRECT_MAP(msgbuf_paddr);
294: initmsgbuf((caddr_t)msgbuf_vaddr, round_page(MSGBUFSIZE));
295:
296: printf("%s", version);
297:
298: printf("real mem = %u (%uMB)\n", ctob(physmem),
299: ctob(physmem)/1024/1024);
300:
301: if (physmem >= btoc(1ULL << 32)) {
302: extern int amdgart_enable;
303:
304: amdgart_enable = 1;
305: }
306:
307: /*
308: * Find out how much space we need, allocate it,
309: * and then give everything true virtual addresses.
310: */
311: sz = allocsys(0);
312: if ((v = uvm_km_zalloc(kernel_map, round_page(sz))) == 0)
313: panic("startup: no room for tables");
314: if (allocsys(v) - v != sz)
315: panic("startup: table size inconsistency");
316:
317: setup_buffers();
318:
319: /*
320: * Allocate a submap for exec arguments. This map effectively
321: * limits the number of processes exec'ing at any time.
322: */
323: minaddr = vm_map_min(kernel_map);
324: exec_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
325: 16*NCARGS, VM_MAP_PAGEABLE, FALSE, NULL);
326:
327: /*
328: * Allocate a submap for physio
329: */
330: minaddr = vm_map_min(kernel_map);
331: phys_map = uvm_km_suballoc(kernel_map, &minaddr, &maxaddr,
332: VM_PHYS_SIZE, 0, FALSE, NULL);
333:
334: printf("avail mem = %lu (%luMB)\n", ptoa(uvmexp.free),
335: ptoa(uvmexp.free)/1024/1024);
336:
337: bufinit();
338:
339: if (boothowto & RB_CONFIG) {
340: #ifdef BOOT_CONFIG
341: user_config();
342: #else
343: printf("kernel does not support - c; continuing..\n");
344: #endif
345: }
346:
347: /* Safe for i/o port / memory space allocation to use malloc now. */
348: x86_bus_space_mallocok();
349: }
350:
351: /*
352: * Allocate space for system data structures. We are given
353: * a starting virtual address and we return a final virtual
354: * address; along the way we set each data structure pointer.
355: *
356: * We call allocsys() with 0 to find out how much space we want,
357: * allocate that much and fill it with zeroes, and then call
358: * allocsys() again with the correct base virtual address.
359: */
360: vaddr_t
361: allocsys(vaddr_t v)
362: {
363:
364: #define valloc(name, type, num) \
365: v = (vaddr_t)(((name) = (type *)v) + (num))
366:
367: #ifdef SYSVMSG
368: valloc(msgpool, char, msginfo.msgmax);
369: valloc(msgmaps, struct msgmap, msginfo.msgseg);
370: valloc(msghdrs, struct msg, msginfo.msgtql);
371: valloc(msqids, struct msqid_ds, msginfo.msgmni);
372: #endif
373:
374: return v;
375: }
376:
377: void
378: setup_buffers()
379: {
380: /*
381: * Determine how many buffers to allocate.
382: * We allocate bufcachepercent% of memory for buffer space.
383: */
384: if (bufpages == 0)
385: bufpages = physmem * bufcachepercent / 100;
386:
387: /* Restrict to at most 25% filled kvm */
388: if (bufpages >
389: (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE / 4)
390: bufpages = (VM_MAX_KERNEL_ADDRESS-VM_MIN_KERNEL_ADDRESS) /
391: PAGE_SIZE / 4;
392: }
393:
394: /*
395: * Set up proc0's TSS and LDT.
396: */
397: void
398: x86_64_proc0_tss_ldt_init(void)
399: {
400: struct pcb *pcb;
401: int x;
402:
403: gdt_init();
404:
405: cpu_info_primary.ci_curpcb = pcb = &proc0.p_addr->u_pcb;
406:
407: pcb->pcb_flags = 0;
408: pcb->pcb_tss.tss_iobase =
409: (u_int16_t)((caddr_t)pcb->pcb_iomap - (caddr_t)&pcb->pcb_tss);
410: for (x = 0; x < sizeof(pcb->pcb_iomap) / 4; x++)
411: pcb->pcb_iomap[x] = 0xffffffff;
412:
413: pcb->pcb_ldt_sel = pmap_kernel()->pm_ldt_sel =
414: GSYSSEL(GLDT_SEL, SEL_KPL);
415: pcb->pcb_cr0 = rcr0();
416: pcb->pcb_tss.tss_rsp0 = (u_int64_t)proc0.p_addr + USPACE - 16;
417: pcb->pcb_tss.tss_ist[0] = (u_int64_t)proc0.p_addr + PAGE_SIZE;
418: proc0.p_md.md_regs = (struct trapframe *)pcb->pcb_tss.tss_rsp0 - 1;
419: proc0.p_md.md_tss_sel = tss_alloc(pcb);
420:
421: ltr(proc0.p_md.md_tss_sel);
422: lldt(pcb->pcb_ldt_sel);
423: }
424:
425: /*
426: * Set up TSS and LDT for a new PCB.
427: */
428:
429: #ifdef MULTIPROCESSOR
430: void
431: x86_64_init_pcb_tss_ldt(struct cpu_info *ci)
432: {
433: int x;
434: struct pcb *pcb = ci->ci_idle_pcb;
435:
436: pcb->pcb_tss.tss_iobase =
437: (u_int16_t)((caddr_t)pcb->pcb_iomap - (caddr_t)&pcb->pcb_tss);
438: for (x = 0; x < sizeof(pcb->pcb_iomap) / 4; x++)
439: pcb->pcb_iomap[x] = 0xffffffff;
440:
441: /* XXXfvdl pmap_kernel not needed */
442: pcb->pcb_ldt_sel = pmap_kernel()->pm_ldt_sel =
443: GSYSSEL(GLDT_SEL, SEL_KPL);
444: pcb->pcb_cr0 = rcr0();
445:
446: ci->ci_idle_tss_sel = tss_alloc(pcb);
447: }
448: #endif /* MULTIPROCESSOR */
449:
450: bios_diskinfo_t *
451: bios_getdiskinfo(dev_t dev)
452: {
453: bios_diskinfo_t *pdi;
454:
455: if (bios_diskinfo == NULL)
456: return NULL;
457:
458: for (pdi = bios_diskinfo; pdi->bios_number != -1; pdi++) {
459: if ((dev & B_MAGICMASK) == B_DEVMAGIC) { /* search by bootdev */
460: if (pdi->bsd_dev == dev)
461: break;
462: } else {
463: if (pdi->bios_number == dev)
464: break;
465: }
466: }
467:
468: if (pdi->bios_number == -1)
469: return NULL;
470: else
471: return pdi;
472: }
473:
474: int
475: bios_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
476: size_t newlen, struct proc *p)
477: {
478: bios_diskinfo_t *pdi;
479: extern dev_t bootdev;
480: int biosdev;
481:
482: /* all sysctl names at this level except diskinfo are terminal */
483: if (namelen != 1 && name[0] != BIOS_DISKINFO)
484: return (ENOTDIR); /* overloaded */
485:
486: if (!(bootapiver & BAPIV_VECTOR))
487: return EOPNOTSUPP;
488:
489: switch (name[0]) {
490: case BIOS_DEV:
491: if ((pdi = bios_getdiskinfo(bootdev)) == NULL)
492: return ENXIO;
493: biosdev = pdi->bios_number;
494: return sysctl_rdint(oldp, oldlenp, newp, biosdev);
495: case BIOS_DISKINFO:
496: if (namelen != 2)
497: return ENOTDIR;
498: if ((pdi = bios_getdiskinfo(name[1])) == NULL)
499: return ENXIO;
500: return sysctl_rdstruct(oldp, oldlenp, newp, pdi, sizeof(*pdi));
501: case BIOS_CKSUMLEN:
502: return sysctl_rdint(oldp, oldlenp, newp, bios_cksumlen);
503: default:
504: return EOPNOTSUPP;
505: }
506: /* NOTREACHED */
507: }
508:
509: /*
510: * machine dependent system variables.
511: */
512: int
513: cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
514: size_t newlen, struct proc *p)
515: {
516: dev_t consdev;
517: dev_t dev;
518:
519: switch (name[0]) {
520: case CPU_CONSDEV:
521: if (namelen != 1)
522: return (ENOTDIR); /* overloaded */
523: if (cn_tab != NULL)
524: consdev = cn_tab->cn_dev;
525: else
526: consdev = NODEV;
527: return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
528: sizeof consdev));
529: case CPU_CHR2BLK:
530: if (namelen != 2)
531: return (ENOTDIR); /* overloaded */
532: dev = chrtoblk((dev_t)name[1]);
533: return sysctl_rdstruct(oldp, oldlenp, newp, &dev, sizeof(dev));
534: case CPU_BIOS:
535: return bios_sysctl(name + 1, namelen - 1, oldp, oldlenp,
536: newp, newlen, p);
537: case CPU_CPUVENDOR:
538: return (sysctl_rdstring(oldp, oldlenp, newp, cpu_vendor));
539: case CPU_CPUFEATURE:
540: return (sysctl_rdint(oldp, oldlenp, newp, cpu_feature));
541: case CPU_KBDRESET:
542: if (securelevel > 0)
543: return (sysctl_rdint(oldp, oldlenp, newp,
544: kbd_reset));
545: else
546: return (sysctl_int(oldp, oldlenp, newp, newlen,
547: &kbd_reset));
548: case CPU_ALLOWAPERTURE:
549: if (namelen != 1)
550: return (ENOTDIR); /* overloaded */
551: #ifdef APERTURE
552: if (securelevel > 0)
553: return (sysctl_int_lower(oldp, oldlenp, newp, newlen,
554: &allowaperture));
555: else
556: return (sysctl_int(oldp, oldlenp, newp, newlen,
557: &allowaperture));
558: #else
559: return (sysctl_rdint(oldp, oldlenp, newp, 0));
560: #endif
561: default:
562: return (EOPNOTSUPP);
563: }
564: /* NOTREACHED */
565: }
566:
567: /*
568: * Send an interrupt to process.
569: *
570: * Stack is set up to allow sigcode stored
571: * in u. to call routine, followed by kcall
572: * to sigreturn routine below. After sigreturn
573: * resets the signal mask, the stack, and the
574: * frame pointer, it returns to the user
575: * specified pc, psl.
576: */
577: void
578: sendsig(sig_t catcher, int sig, int mask, u_long code, int type,
579: union sigval val)
580: {
581: struct proc *p = curproc;
582: struct trapframe *tf = p->p_md.md_regs;
583: struct sigacts * psp = p->p_sigacts;
584: struct sigcontext ksc;
585: siginfo_t ksi;
586: register_t sp, scp, sip;
587: u_long sss;
588:
589: #ifdef DEBUG
590: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
591: printf("sendsig: %s[%d] sig %d catcher %p\n",
592: p->p_comm, p->p_pid, sig, catcher);
593: #endif
594:
595: bcopy(tf, &ksc, sizeof(*tf));
596: ksc.sc_onstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
597: ksc.sc_mask = mask;
598: ksc.sc_fpstate = NULL;
599:
600: /* Allocate space for the signal handler context. */
601: if ((psp->ps_flags & SAS_ALTSTACK) && !ksc.sc_onstack &&
602: (psp->ps_sigonstack & sigmask(sig))) {
603: sp = (register_t)psp->ps_sigstk.ss_sp + psp->ps_sigstk.ss_size;
604: psp->ps_sigstk.ss_flags |= SS_ONSTACK;
605: } else
606: sp = tf->tf_rsp - 128;
607:
608: sp &= ~15ULL; /* just in case */
609: sss = (sizeof(ksc) + 15) & ~15;
610:
611: if (p->p_md.md_flags & MDP_USEDFPU) {
612: fpusave_proc(p, 1);
613: sp -= sizeof(struct fxsave64);
614: ksc.sc_fpstate = (struct fxsave64 *)sp;
615: if (copyout(&p->p_addr->u_pcb.pcb_savefpu.fp_fxsave,
616: (void *)sp, sizeof(struct fxsave64)))
617: sigexit(p, SIGILL);
618: }
619:
620: sip = 0;
621: if (psp->ps_siginfo & sigmask(sig)) {
622: sip = sp - ((sizeof(ksi) + 15) & ~15);
623: sss += (sizeof(ksi) + 15) & ~15;
624:
625: initsiginfo(&ksi, sig, code, type, val);
626: if (copyout(&ksi, (void *)sip, sizeof(ksi)))
627: sigexit(p, SIGILL);
628: }
629: scp = sp - sss;
630:
631: if (copyout(&ksc, (void *)scp, sizeof(ksc)))
632: sigexit(p, SIGILL);
633:
634: /*
635: * Build context to run handler in.
636: */
637: tf->tf_ds = LSEL(LUDATA_SEL, SEL_UPL);
638: tf->tf_es = LSEL(LUDATA_SEL, SEL_UPL);
639: tf->tf_fs = LSEL(LUDATA_SEL, SEL_UPL);
640: tf->tf_gs = LSEL(LUDATA_SEL, SEL_UPL);
641:
642: tf->tf_rax = (u_int64_t)catcher;
643: tf->tf_rdi = sig;
644: tf->tf_rsi = sip;
645: tf->tf_rdx = scp;
646:
647: tf->tf_rip = (u_int64_t)p->p_sigcode;
648: tf->tf_cs = LSEL(LUCODE_SEL, SEL_UPL);
649: tf->tf_rflags &= ~(PSL_T|PSL_VM|PSL_AC);
650: tf->tf_rsp = scp;
651: tf->tf_ss = LSEL(LUDATA_SEL, SEL_UPL);
652:
653: #ifdef DEBUG
654: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
655: printf("sendsig(%d): pc 0x%x, catcher 0x%x\n", p->p_pid,
656: tf->tf_rip, tf->tf_rax);
657: #endif
658: }
659:
660: /*
661: * System call to cleanup state after a signal
662: * has been taken. Reset signal mask and
663: * stack state from context left by sendsig (above).
664: * Return to previous pc and psl as specified by
665: * context left by sendsig. Check carefully to
666: * make sure that the user has not modified the
667: * psl to gain improper privileges or to cause
668: * a machine fault.
669: */
670: int
671: sys_sigreturn(struct proc *p, void *v, register_t *retval)
672: {
673: struct sys_sigreturn_args /* {
674: syscallarg(struct sigcontext *) sigcntxp;
675: } */ *uap = v;
676: struct sigcontext *scp, ksc;
677: struct trapframe *tf = p->p_md.md_regs;
678: int error;
679:
680: scp = SCARG(uap, sigcntxp);
681: #ifdef DEBUG
682: if ((sigdebug & SDB_FOLLOW) && (!sigpid || p->p_pid == sigpid))
683: printf("sigreturn: pid %d, scp %p\n", p->p_pid, scp);
684: #endif
685: if ((error = copyin((caddr_t)scp, &ksc, sizeof ksc)))
686: return (error);
687:
688: if (((ksc.sc_rflags ^ tf->tf_rflags) & PSL_USERSTATIC) != 0 ||
689: !USERMODE(ksc.sc_cs, ksc.sc_eflags))
690: return (EINVAL);
691:
692: if (p->p_md.md_flags & MDP_USEDFPU)
693: fpusave_proc(p, 0);
694:
695: if (ksc.sc_fpstate && (error = copyin(ksc.sc_fpstate,
696: &p->p_addr->u_pcb.pcb_savefpu.fp_fxsave, sizeof (struct fxsave64))))
697: return (error);
698:
699: ksc.sc_trapno = tf->tf_trapno;
700: ksc.sc_err = tf->tf_err;
701: bcopy(&ksc, tf, sizeof(*tf));
702:
703: /* Restore signal stack. */
704: if (ksc.sc_onstack)
705: p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
706: else
707: p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
708: p->p_sigmask = ksc.sc_mask & ~sigcantmask;
709:
710: return (EJUSTRETURN);
711: }
712:
713: /*
714: * Notify the current process (p) that it has a signal pending,
715: * process as soon as possible.
716: */
717: void
718: signotify(struct proc *p)
719: {
720: aston(p);
721: #ifdef MULTIPROCESSOR
722: if (p->p_cpu != curcpu() && p->p_cpu != NULL)
723: x86_send_ipi(p->p_cpu, X86_IPI_NOP);
724: #endif
725: }
726:
727: int waittime = -1;
728: struct pcb dumppcb;
729:
730: void
731: boot(int howto)
732: {
733:
734: if (cold) {
735: /*
736: * If the system is cold, just halt, unless the user
737: * explicitly asked for reboot.
738: */
739: if ((howto & RB_USERREQ) == 0)
740: howto |= RB_HALT;
741: goto haltsys;
742: }
743:
744: boothowto = howto;
745: if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
746: waittime = 0;
747:
748: if (curproc == NULL)
749: curproc = &proc0; /* XXX */
750: vfs_shutdown();
751: /*
752: * If we've been adjusting the clock, the todr
753: * will be out of synch; adjust it now.
754: */
755: if ((howto & RB_TIMEBAD) == 0) {
756: resettodr();
757: } else {
758: printf("WARNING: not updating battery clock\n");
759: }
760: }
761:
762: /* Disable interrupts. */
763: splhigh();
764:
765: /* Do a dump if requested. */
766: if (howto & RB_DUMP)
767: dumpsys();
768:
769: haltsys:
770: doshutdownhooks();
771:
772: #ifdef MULTIPROCESSOR
773: x86_broadcast_ipi(X86_IPI_HALT);
774: #endif
775:
776: if (howto & RB_HALT) {
777: #if NACPI > 0 && !defined(SMALL_KERNEL)
778: extern int acpi_s5, acpi_enabled;
779:
780: if (acpi_enabled) {
781: delay(500000);
782: if (howto & RB_POWERDOWN || acpi_s5)
783: acpi_powerdown();
784: }
785: #endif
786: printf("\n");
787: printf("The operating system has halted.\n");
788: printf("Please press any key to reboot.\n\n");
789: cnpollc(1); /* for proper keyboard command handling */
790: cngetc();
791: cnpollc(0);
792: }
793:
794: printf("rebooting...\n");
795: if (cpureset_delay > 0)
796: delay(cpureset_delay * 1000);
797: cpu_reset();
798: for(;;) ;
799: /*NOTREACHED*/
800: }
801:
802: /*
803: * XXXfvdl share dumpcode.
804: */
805:
806: /*
807: * These variables are needed by /sbin/savecore
808: */
809: u_int32_t dumpmag = 0x8fca0101; /* magic number */
810: int dumpsize = 0; /* pages */
811: long dumplo = 0; /* blocks */
812:
813: /*
814: * cpu_dump: dump the machine-dependent kernel core dump headers.
815: */
816: int
817: cpu_dump(void)
818: {
819: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
820: char buf[dbtob(1)];
821: kcore_seg_t *segp;
822: cpu_kcore_hdr_t *cpuhdrp;
823: phys_ram_seg_t *memsegp;
824: int i;
825:
826: dump = bdevsw[major(dumpdev)].d_dump;
827:
828: memset(buf, 0, sizeof buf);
829: segp = (kcore_seg_t *)buf;
830: cpuhdrp = (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp))];
831: memsegp = (phys_ram_seg_t *)&buf[ALIGN(sizeof(*segp)) +
832: ALIGN(sizeof(*cpuhdrp))];
833:
834: /*
835: * Generate a segment header.
836: */
837: CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
838: segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));
839:
840: /*
841: * Add the machine-dependent header info.
842: */
843: cpuhdrp->ptdpaddr = PTDpaddr;
844: cpuhdrp->nmemsegs = mem_cluster_cnt;
845:
846: /*
847: * Fill in the memory segment descriptors.
848: */
849: for (i = 0; i < mem_cluster_cnt; i++) {
850: memsegp[i].start = mem_clusters[i].start;
851: memsegp[i].size = mem_clusters[i].size & ~PAGE_MASK;
852: }
853:
854: return (dump(dumpdev, dumplo, (caddr_t)buf, dbtob(1)));
855: }
856:
857: /*
858: * This is called by main to set dumplo and dumpsize.
859: * Dumps always skip the first PAGE_SIZE of disk space
860: * in case there might be a disk label stored there.
861: * If there is extra space, put dump at the end to
862: * reduce the chance that swapping trashes it.
863: */
864: void
865: dumpconf(void)
866: {
867: int nblks, dumpblks; /* size of dump area */
868:
869: if (dumpdev == NODEV ||
870: (nblks = (bdevsw[major(dumpdev)].d_psize)(dumpdev)) == 0)
871: return;
872: if (nblks <= ctod(1))
873: return;
874:
875: dumpblks = cpu_dumpsize();
876: if (dumpblks < 0)
877: return;
878: dumpblks += ctod(cpu_dump_mempagecnt());
879:
880: /* If dump won't fit (incl. room for possible label), punt. */
881: if (dumpblks > (nblks - ctod(1)))
882: return;
883:
884: /* Put dump at end of partition */
885: dumplo = nblks - dumpblks;
886:
887: /* dumpsize is in page units, and doesn't include headers. */
888: dumpsize = cpu_dump_mempagecnt();
889: }
890:
891: /*
892: * Doadump comes here after turning off memory management and
893: * getting on the dump stack, either when called above, or by
894: * the auto-restart code.
895: */
896: #define BYTES_PER_DUMP PAGE_SIZE /* must be a multiple of pagesize XXX small */
897: static vaddr_t dumpspace;
898:
899: vaddr_t
900: reserve_dumppages(vaddr_t p)
901: {
902:
903: dumpspace = p;
904: return (p + BYTES_PER_DUMP);
905: }
906:
907: void
908: dumpsys(void)
909: {
910: u_long totalbytesleft, bytes, i, n, memseg;
911: u_long maddr;
912: daddr64_t blkno;
913: int (*dump)(dev_t, daddr64_t, caddr_t, size_t);
914: int error;
915:
916: /* Save registers. */
917: savectx(&dumppcb);
918:
919: if (dumpdev == NODEV)
920: return;
921:
922: /*
923: * For dumps during autoconfiguration,
924: * if dump device has already configured...
925: */
926: if (dumpsize == 0)
927: dumpconf();
928: if (dumplo <= 0 || dumpsize == 0) {
929: printf("\ndump to dev %u,%u not possible\n", major(dumpdev),
930: minor(dumpdev));
931: return;
932: }
933: printf("\ndumping to dev %u,%u offset %ld\n", major(dumpdev),
934: minor(dumpdev), dumplo);
935:
936: error = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
937: printf("dump ");
938: if (error == -1) {
939: printf("area unavailable\n");
940: return;
941: }
942:
943: if ((error = cpu_dump()) != 0)
944: goto err;
945:
946: totalbytesleft = ptoa(cpu_dump_mempagecnt());
947: blkno = dumplo + cpu_dumpsize();
948: dump = bdevsw[major(dumpdev)].d_dump;
949: error = 0;
950:
951: for (memseg = 0; memseg < mem_cluster_cnt; memseg++) {
952: maddr = mem_clusters[memseg].start;
953: bytes = mem_clusters[memseg].size;
954:
955: for (i = 0; i < bytes; i += n, totalbytesleft -= n) {
956: /* Print out how many MBs we have left to go. */
957: if ((totalbytesleft % (1024*1024)) == 0)
958: printf("%ld ", totalbytesleft / (1024 * 1024));
959:
960: /* Limit size for next transfer. */
961: n = bytes - i;
962: if (n > BYTES_PER_DUMP)
963: n = BYTES_PER_DUMP;
964:
965: (void) pmap_map(dumpspace, maddr, maddr + n,
966: VM_PROT_READ);
967:
968: error = (*dump)(dumpdev, blkno, (caddr_t)dumpspace, n);
969: if (error)
970: goto err;
971: maddr += n;
972: blkno += btodb(n); /* XXX? */
973:
974: #if 0 /* XXX this doesn't work. grr. */
975: /* operator aborting dump? */
976: if (sget() != NULL) {
977: error = EINTR;
978: break;
979: }
980: #endif
981: }
982: }
983:
984: err:
985: switch (error) {
986:
987: case ENXIO:
988: printf("device bad\n");
989: break;
990:
991: case EFAULT:
992: printf("device not ready\n");
993: break;
994:
995: case EINVAL:
996: printf("area improper\n");
997: break;
998:
999: case EIO:
1000: printf("i/o error\n");
1001: break;
1002:
1003: case EINTR:
1004: printf("aborted from console\n");
1005: break;
1006:
1007: case 0:
1008: printf("succeeded\n");
1009: break;
1010:
1011: default:
1012: printf("error %d\n", error);
1013: break;
1014: }
1015: printf("\n\n");
1016: delay(5000000); /* 5 seconds */
1017: }
1018:
1019: /*
1020: * Clear registers on exec
1021: */
1022: void
1023: setregs(struct proc *p, struct exec_package *pack, u_long stack,
1024: register_t *retval)
1025: {
1026: struct pcb *pcb = &p->p_addr->u_pcb;
1027: struct trapframe *tf;
1028:
1029: /* If we were using the FPU, forget about it. */
1030: if (p->p_addr->u_pcb.pcb_fpcpu != NULL)
1031: fpusave_proc(p, 0);
1032:
1033: #ifdef USER_LDT
1034: pmap_ldt_cleanup(p);
1035: #endif
1036:
1037: p->p_md.md_flags &= ~MDP_USEDFPU;
1038: pcb->pcb_flags = 0;
1039: pcb->pcb_savefpu.fp_fxsave.fx_fcw = __INITIAL_NPXCW__;
1040: pcb->pcb_savefpu.fp_fxsave.fx_mxcsr = __INITIAL_MXCSR__;
1041: pcb->pcb_savefpu.fp_fxsave.fx_mxcsr_mask = __INITIAL_MXCSR_MASK__;
1042:
1043: tf = p->p_md.md_regs;
1044: tf->tf_ds = LSEL(LUDATA_SEL, SEL_UPL);
1045: tf->tf_es = LSEL(LUDATA_SEL, SEL_UPL);
1046: tf->tf_fs = LSEL(LUDATA_SEL, SEL_UPL);
1047: tf->tf_gs = LSEL(LUDATA_SEL, SEL_UPL);
1048: tf->tf_rdi = 0;
1049: tf->tf_rsi = 0;
1050: tf->tf_rbp = 0;
1051: tf->tf_rbx = 0;
1052: tf->tf_rdx = 0;
1053: tf->tf_rcx = 0;
1054: tf->tf_rax = 0;
1055: tf->tf_rip = pack->ep_entry;
1056: tf->tf_cs = LSEL(LUCODE_SEL, SEL_UPL);
1057: tf->tf_rflags = PSL_USERSET;
1058: tf->tf_rsp = stack;
1059: tf->tf_ss = LSEL(LUDATA_SEL, SEL_UPL);
1060:
1061: retval[1] = 0;
1062: }
1063:
1064: /*
1065: * Initialize segments and descriptor tables
1066: */
1067:
1068: struct gate_descriptor *idt;
1069: char idt_allocmap[NIDT];
1070: struct simplelock idt_lock;
1071: char *ldtstore;
1072: char *gdtstore;
1073: extern struct user *proc0paddr;
1074:
1075: void
1076: setgate(struct gate_descriptor *gd, void *func, int ist, int type, int dpl,
1077: int sel)
1078: {
1079: gd->gd_looffset = (u_int64_t)func & 0xffff;
1080: gd->gd_selector = sel;
1081: gd->gd_ist = ist;
1082: gd->gd_type = type;
1083: gd->gd_dpl = dpl;
1084: gd->gd_p = 1;
1085: gd->gd_hioffset = (u_int64_t)func >> 16;
1086: gd->gd_zero = 0;
1087: gd->gd_xx1 = 0;
1088: gd->gd_xx2 = 0;
1089: gd->gd_xx3 = 0;
1090: }
1091:
1092: void
1093: unsetgate(struct gate_descriptor *gd)
1094: {
1095: memset(gd, 0, sizeof (*gd));
1096: }
1097:
1098: void
1099: setregion(struct region_descriptor *rd, void *base, u_int16_t limit)
1100: {
1101: rd->rd_limit = limit;
1102: rd->rd_base = (u_int64_t)base;
1103: }
1104:
1105: /*
1106: * Note that the base and limit fields are ignored in long mode.
1107: */
1108: void
1109: set_mem_segment(struct mem_segment_descriptor *sd, void *base, size_t limit,
1110: int type, int dpl, int gran, int def32, int is64)
1111: {
1112: sd->sd_lolimit = (unsigned)limit;
1113: sd->sd_lobase = (unsigned long)base;
1114: sd->sd_type = type;
1115: sd->sd_dpl = dpl;
1116: sd->sd_p = 1;
1117: sd->sd_hilimit = (unsigned)limit >> 16;
1118: sd->sd_avl = 0;
1119: sd->sd_long = is64;
1120: sd->sd_def32 = def32;
1121: sd->sd_gran = gran;
1122: sd->sd_hibase = (unsigned long)base >> 24;
1123: }
1124:
1125: void
1126: set_sys_segment(struct sys_segment_descriptor *sd, void *base, size_t limit,
1127: int type, int dpl, int gran)
1128: {
1129: memset(sd, 0, sizeof *sd);
1130: sd->sd_lolimit = (unsigned)limit;
1131: sd->sd_lobase = (u_int64_t)base;
1132: sd->sd_type = type;
1133: sd->sd_dpl = dpl;
1134: sd->sd_p = 1;
1135: sd->sd_hilimit = (unsigned)limit >> 16;
1136: sd->sd_gran = gran;
1137: sd->sd_hibase = (u_int64_t)base >> 24;
1138: }
1139:
1140: void cpu_init_idt(void)
1141: {
1142: struct region_descriptor region;
1143:
1144: setregion(®ion, idt, NIDT * sizeof(idt[0]) - 1);
1145: lidt(®ion);
1146: }
1147:
1148:
1149: #define IDTVEC(name) __CONCAT(X, name)
1150: typedef void (vector)(void);
1151: extern vector IDTVEC(syscall);
1152: extern vector IDTVEC(syscall32);
1153: extern vector IDTVEC(osyscall);
1154: extern vector IDTVEC(oosyscall);
1155: extern vector *IDTVEC(exceptions)[];
1156:
1157: #define KBTOB(x) ((size_t)(x) * 1024UL)
1158:
1159: void
1160: init_x86_64(paddr_t first_avail)
1161: {
1162: extern void consinit(void);
1163: extern struct extent *iomem_ex;
1164: struct region_descriptor region;
1165: struct mem_segment_descriptor *ldt_segp;
1166: int x, first16q, ist;
1167: u_int64_t seg_start, seg_end;
1168: u_int64_t seg_start1, seg_end1;
1169:
1170: cpu_init_msrs(&cpu_info_primary);
1171:
1172: proc0.p_addr = proc0paddr;
1173: cpu_info_primary.ci_curpcb = &proc0.p_addr->u_pcb;
1174:
1175: x86_bus_space_init();
1176:
1177: consinit(); /* XXX SHOULD NOT BE DONE HERE */
1178:
1179: /*
1180: * Initailize PAGE_SIZE-dependent variables.
1181: */
1182: uvm_setpagesize();
1183:
1184: #if 0
1185: uvmexp.ncolors = 2;
1186: #endif
1187:
1188: /*
1189: * Boot arguments are in a single page specified by /boot.
1190: *
1191: * We require the "new" vector form, as well as memory ranges
1192: * to be given in bytes rather than KB.
1193: *
1194: * locore copies the data into bootinfo[] for us.
1195: */
1196: if ((bootapiver & (BAPIV_VECTOR | BAPIV_BMEMMAP)) ==
1197: (BAPIV_VECTOR | BAPIV_BMEMMAP)) {
1198: if (bootinfo_size >= sizeof(bootinfo))
1199: panic("boot args too big");
1200:
1201: getbootinfo(bootinfo, bootinfo_size);
1202: } else
1203: panic("invalid /boot");
1204:
1205: avail_start = PAGE_SIZE; /* BIOS leaves data in low memory */
1206: /* and VM system doesn't work with phys 0 */
1207: #ifdef MULTIPROCESSOR
1208: if (avail_start < MP_TRAMPOLINE + PAGE_SIZE)
1209: avail_start = MP_TRAMPOLINE + PAGE_SIZE;
1210: #endif
1211:
1212: /*
1213: * Call pmap initialization to make new kernel address space.
1214: * We must do this before loading pages into the VM system.
1215: */
1216: pmap_bootstrap(VM_MIN_KERNEL_ADDRESS,
1217: IOM_END + trunc_page(KBTOB(biosextmem)));
1218:
1219: if (avail_start != PAGE_SIZE)
1220: pmap_prealloc_lowmem_ptps();
1221:
1222: if (mem_cluster_cnt == 0) {
1223: /*
1224: * Allocate the physical addresses used by RAM from the iomem
1225: * extent map. This is done before the addresses are
1226: * page rounded just to make sure we get them all.
1227: */
1228: if (extent_alloc_region(iomem_ex, 0, KBTOB(biosbasemem),
1229: EX_NOWAIT)) {
1230: /* XXX What should we do? */
1231: printf("WARNING: CAN'T ALLOCATE BASE MEMORY FROM "
1232: "IOMEM EXTENT MAP!\n");
1233: }
1234: mem_clusters[0].start = 0;
1235: mem_clusters[0].size = trunc_page(KBTOB(biosbasemem));
1236: physmem += atop(mem_clusters[0].size);
1237: if (extent_alloc_region(iomem_ex, IOM_END, KBTOB(biosextmem),
1238: EX_NOWAIT)) {
1239: /* XXX What should we do? */
1240: printf("WARNING: CAN'T ALLOCATE EXTENDED MEMORY FROM "
1241: "IOMEM EXTENT MAP!\n");
1242: }
1243: #if 0
1244: #if NISADMA > 0
1245: /*
1246: * Some motherboards/BIOSes remap the 384K of RAM that would
1247: * normally be covered by the ISA hole to the end of memory
1248: * so that it can be used. However, on a 16M system, this
1249: * would cause bounce buffers to be allocated and used.
1250: * This is not desirable behaviour, as more than 384K of
1251: * bounce buffers might be allocated. As a work-around,
1252: * we round memory down to the nearest 1M boundary if
1253: * we're using any isadma devices and the remapped memory
1254: * is what puts us over 16M.
1255: */
1256: if (biosextmem > (15*1024) && biosextmem < (16*1024)) {
1257: char pbuf[9];
1258:
1259: format_bytes(pbuf, sizeof(pbuf),
1260: biosextmem - (15*1024));
1261: printf("Warning: ignoring %s of remapped memory\n",
1262: pbuf);
1263: biosextmem = (15*1024);
1264: }
1265: #endif
1266: #endif
1267: mem_clusters[1].start = IOM_END;
1268: mem_clusters[1].size = trunc_page(KBTOB(biosextmem));
1269: physmem += atop(mem_clusters[1].size);
1270:
1271: mem_cluster_cnt = 2;
1272:
1273: avail_end = IOM_END + trunc_page(KBTOB(biosextmem));
1274: }
1275:
1276: /*
1277: * If we have 16M of RAM or less, just put it all on
1278: * the default free list. Otherwise, put the first
1279: * 16M of RAM on a lower priority free list (so that
1280: * all of the ISA DMA'able memory won't be eaten up
1281: * first-off).
1282: */
1283: if (avail_end <= (16 * 1024 * 1024))
1284: first16q = VM_FREELIST_DEFAULT;
1285: else
1286: first16q = VM_FREELIST_FIRST16;
1287:
1288: /* Make sure the end of the space used by the kernel is rounded. */
1289: first_avail = round_page(first_avail);
1290: kern_end = KERNBASE + first_avail;
1291:
1292: /*
1293: * Now, load the memory clusters (which have already been
1294: * rounded and truncated) into the VM system.
1295: *
1296: * NOTE: WE ASSUME THAT MEMORY STARTS AT 0 AND THAT THE KERNEL
1297: * IS LOADED AT IOM_END (1M).
1298: */
1299: for (x = 0; x < mem_cluster_cnt; x++) {
1300: seg_start = mem_clusters[x].start;
1301: seg_end = mem_clusters[x].start + mem_clusters[x].size;
1302: seg_start1 = 0;
1303: seg_end1 = 0;
1304:
1305: if (seg_start > 0xffffffffULL) {
1306: printf("skipping %lld bytes of memory above 4GB\n",
1307: seg_end - seg_start);
1308: continue;
1309: }
1310: if (seg_end > 0x100000000ULL) {
1311: printf("skipping %lld bytes of memory above 4GB\n",
1312: seg_end - 0x100000000ULL);
1313: seg_end = 0x100000000ULL;
1314: }
1315:
1316: /*
1317: * Skip memory before our available starting point.
1318: */
1319: if (seg_end <= avail_start)
1320: continue;
1321:
1322: if (avail_start >= seg_start && avail_start < seg_end) {
1323: if (seg_start != 0)
1324: panic("init_x86_64: memory doesn't start at 0");
1325: seg_start = avail_start;
1326: if (seg_start == seg_end)
1327: continue;
1328: }
1329:
1330: /*
1331: * If this segment contains the kernel, split it
1332: * in two, around the kernel.
1333: */
1334: if (seg_start <= IOM_END && first_avail <= seg_end) {
1335: seg_start1 = first_avail;
1336: seg_end1 = seg_end;
1337: seg_end = IOM_END;
1338: }
1339:
1340: /* First hunk */
1341: if (seg_start != seg_end) {
1342: if (seg_start <= (16 * 1024 * 1024) &&
1343: first16q != VM_FREELIST_DEFAULT) {
1344: u_int64_t tmp;
1345:
1346: if (seg_end > (16 * 1024 * 1024))
1347: tmp = (16 * 1024 * 1024);
1348: else
1349: tmp = seg_end;
1350: #if DEBUG_MEMLOAD
1351: printf("loading 0x%qx-0x%qx (0x%lx-0x%lx)\n",
1352: (unsigned long long)seg_start,
1353: (unsigned long long)tmp,
1354: atop(seg_start), atop(tmp));
1355: #endif
1356: uvm_page_physload(atop(seg_start),
1357: atop(tmp), atop(seg_start),
1358: atop(tmp), first16q);
1359: seg_start = tmp;
1360: }
1361:
1362: if (seg_start != seg_end) {
1363: #if DEBUG_MEMLOAD
1364: printf("loading 0x%qx-0x%qx (0x%lx-0x%lx)\n",
1365: (unsigned long long)seg_start,
1366: (unsigned long long)seg_end,
1367: atop(seg_start), atop(seg_end));
1368: #endif
1369: uvm_page_physload(atop(seg_start),
1370: atop(seg_end), atop(seg_start),
1371: atop(seg_end), VM_FREELIST_DEFAULT);
1372: }
1373: }
1374:
1375: /* Second hunk */
1376: if (seg_start1 != seg_end1) {
1377: if (seg_start1 <= (16 * 1024 * 1024) &&
1378: first16q != VM_FREELIST_DEFAULT) {
1379: u_int64_t tmp;
1380:
1381: if (seg_end1 > (16 * 1024 * 1024))
1382: tmp = (16 * 1024 * 1024);
1383: else
1384: tmp = seg_end1;
1385: #if DEBUG_MEMLOAD
1386: printf("loading 0x%qx-0x%qx (0x%lx-0x%lx)\n",
1387: (unsigned long long)seg_start1,
1388: (unsigned long long)tmp,
1389: atop(seg_start1), atop(tmp));
1390: #endif
1391: uvm_page_physload(atop(seg_start1),
1392: atop(tmp), atop(seg_start1),
1393: atop(tmp), first16q);
1394: seg_start1 = tmp;
1395: }
1396:
1397: if (seg_start1 != seg_end1) {
1398: #if DEBUG_MEMLOAD
1399: printf("loading 0x%qx-0x%qx (0x%lx-0x%lx)\n",
1400: (unsigned long long)seg_start1,
1401: (unsigned long long)seg_end1,
1402: atop(seg_start1), atop(seg_end1));
1403: #endif
1404: uvm_page_physload(atop(seg_start1),
1405: atop(seg_end1), atop(seg_start1),
1406: atop(seg_end1), VM_FREELIST_DEFAULT);
1407: }
1408: }
1409: }
1410:
1411: /*
1412: * Steal memory for the message buffer (at end of core).
1413: */
1414: {
1415: struct vm_physseg *vps = NULL;
1416: psize_t sz = round_page(MSGBUFSIZE);
1417: psize_t reqsz = sz;
1418:
1419: for (x = 0; x < vm_nphysseg; x++) {
1420: vps = &vm_physmem[x];
1421: if (ptoa(vps->avail_end) == avail_end)
1422: break;
1423: }
1424: if (x == vm_nphysseg)
1425: panic("init_x86_64: can't find end of memory");
1426:
1427: /* Shrink so it'll fit in the last segment. */
1428: if ((vps->avail_end - vps->avail_start) < atop(sz))
1429: sz = ptoa(vps->avail_end - vps->avail_start);
1430:
1431: vps->avail_end -= atop(sz);
1432: vps->end -= atop(sz);
1433: msgbuf_paddr = ptoa(vps->avail_end);
1434:
1435: /* Remove the last segment if it now has no pages. */
1436: if (vps->start == vps->end) {
1437: for (vm_nphysseg--; x < vm_nphysseg; x++)
1438: vm_physmem[x] = vm_physmem[x + 1];
1439: }
1440:
1441: /* Now find where the new avail_end is. */
1442: for (avail_end = 0, x = 0; x < vm_nphysseg; x++)
1443: if (vm_physmem[x].avail_end > avail_end)
1444: avail_end = vm_physmem[x].avail_end;
1445: avail_end = ptoa(avail_end);
1446:
1447: /* Warn if the message buffer had to be shrunk. */
1448: if (sz != reqsz)
1449: printf("WARNING: %ld bytes not available for msgbuf "
1450: "in last cluster (%ld used)\n", reqsz, sz);
1451: }
1452:
1453: /*
1454: * XXXfvdl todo: acpi wakeup code.
1455: */
1456:
1457: pmap_growkernel(VM_MIN_KERNEL_ADDRESS + 32 * 1024 * 1024);
1458:
1459: pmap_kenter_pa(idt_vaddr, idt_paddr, VM_PROT_READ|VM_PROT_WRITE);
1460: pmap_kenter_pa(idt_vaddr + PAGE_SIZE, idt_paddr + PAGE_SIZE,
1461: VM_PROT_READ|VM_PROT_WRITE);
1462:
1463: pmap_kenter_pa(lo32_vaddr, lo32_paddr, VM_PROT_READ|VM_PROT_WRITE);
1464:
1465: idt = (struct gate_descriptor *)idt_vaddr;
1466: gdtstore = (char *)(idt + NIDT);
1467: ldtstore = gdtstore + DYNSEL_START;
1468:
1469: /* make gdt gates and memory segments */
1470: set_mem_segment(GDT_ADDR_MEM(gdtstore, GCODE_SEL), 0, 0xfffff, SDT_MEMERA,
1471: SEL_KPL, 1, 0, 1);
1472:
1473: set_mem_segment(GDT_ADDR_MEM(gdtstore, GDATA_SEL), 0, 0xfffff, SDT_MEMRWA,
1474: SEL_KPL, 1, 0, 1);
1475:
1476: set_sys_segment(GDT_ADDR_SYS(gdtstore, GLDT_SEL), ldtstore, LDT_SIZE - 1,
1477: SDT_SYSLDT, SEL_KPL, 0);
1478:
1479: set_mem_segment(GDT_ADDR_MEM(gdtstore, GUCODE_SEL), 0,
1480: atop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMERA, SEL_UPL, 1, 0, 1);
1481:
1482: set_mem_segment(GDT_ADDR_MEM(gdtstore, GUDATA_SEL), 0,
1483: atop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMRWA, SEL_UPL, 1, 0, 1);
1484:
1485: /* make ldt gates and memory segments */
1486: setgate((struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
1487: &IDTVEC(oosyscall), 0, SDT_SYS386CGT, SEL_UPL,
1488: GSEL(GCODE_SEL, SEL_KPL));
1489:
1490: *(struct mem_segment_descriptor *)(ldtstore + LUCODE_SEL) =
1491: *GDT_ADDR_MEM(gdtstore, GUCODE_SEL);
1492: *(struct mem_segment_descriptor *)(ldtstore + LUDATA_SEL) =
1493: *GDT_ADDR_MEM(gdtstore, GUDATA_SEL);
1494:
1495: /*
1496: * 32 bit GDT entries.
1497: */
1498:
1499: set_mem_segment(GDT_ADDR_MEM(gdtstore, GUCODE32_SEL), 0,
1500: atop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMERA, SEL_UPL, 1, 1, 0);
1501:
1502: set_mem_segment(GDT_ADDR_MEM(gdtstore, GUDATA32_SEL), 0,
1503: atop(VM_MAXUSER_ADDRESS) - 1, SDT_MEMRWA, SEL_UPL, 1, 1, 0);
1504:
1505: /*
1506: * 32 bit LDT entries.
1507: */
1508: ldt_segp = (struct mem_segment_descriptor *)(ldtstore + LUCODE32_SEL);
1509: set_mem_segment(ldt_segp, 0, atop(VM_MAXUSER_ADDRESS32) - 1,
1510: SDT_MEMERA, SEL_UPL, 1, 1, 0);
1511: ldt_segp = (struct mem_segment_descriptor *)(ldtstore + LUDATA32_SEL);
1512: set_mem_segment(ldt_segp, 0, atop(VM_MAXUSER_ADDRESS32) - 1,
1513: SDT_MEMRWA, SEL_UPL, 1, 1, 0);
1514:
1515: /*
1516: * Other entries.
1517: */
1518: memcpy((struct gate_descriptor *)(ldtstore + LSOL26CALLS_SEL),
1519: (struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
1520: sizeof (struct gate_descriptor));
1521: memcpy((struct gate_descriptor *)(ldtstore + LBSDICALLS_SEL),
1522: (struct gate_descriptor *)(ldtstore + LSYS5CALLS_SEL),
1523: sizeof (struct gate_descriptor));
1524:
1525: /* exceptions */
1526: for (x = 0; x < 32; x++) {
1527: ist = (x == 8) ? 1 : 0;
1528: setgate(&idt[x], IDTVEC(exceptions)[x], ist, SDT_SYS386IGT,
1529: (x == 3 || x == 4) ? SEL_UPL : SEL_KPL,
1530: GSEL(GCODE_SEL, SEL_KPL));
1531: idt_allocmap[x] = 1;
1532: }
1533:
1534: /* new-style interrupt gate for syscalls */
1535: setgate(&idt[128], &IDTVEC(osyscall), 0, SDT_SYS386IGT, SEL_UPL,
1536: GSEL(GCODE_SEL, SEL_KPL));
1537: idt_allocmap[128] = 1;
1538:
1539: setregion(®ion, gdtstore, DYNSEL_START - 1);
1540: lgdt(®ion);
1541:
1542: cpu_init_idt();
1543:
1544: #ifdef DDB
1545: db_machine_init();
1546: ddb_init();
1547: if (boothowto & RB_KDB)
1548: Debugger();
1549: #endif
1550: #ifdef KGDB
1551: kgdb_port_init();
1552: if (boothowto & RB_KDB) {
1553: kgdb_debug_init = 1;
1554: kgdb_connect(1);
1555: }
1556: #endif
1557:
1558: intr_default_setup();
1559:
1560: softintr_init();
1561: splraise(IPL_IPI);
1562: enable_intr();
1563:
1564: /* Make sure maxproc is sane */
1565: if (maxproc > cpu_maxproc())
1566: maxproc = cpu_maxproc();
1567: }
1568:
1569: #ifdef KGDB
1570: void
1571: kgdb_port_init(void)
1572: {
1573: #if NCOM > 0
1574: if (!strcmp(kgdb_devname, "com")) {
1575: bus_space_tag_t tag = X86_BUS_SPACE_IO;
1576: com_kgdb_attach(tag, comkgdbaddr, comkgdbrate, COM_FREQ,
1577: comkgdbmode);
1578: }
1579: #endif
1580: }
1581: #endif /* KGDB */
1582:
1583: void
1584: cpu_reset(void)
1585: {
1586:
1587: disable_intr();
1588:
1589: /*
1590: * The keyboard controller has 4 random output pins, one of which is
1591: * connected to the RESET pin on the CPU in many PCs. We tell the
1592: * keyboard controller to pulse this line a couple of times.
1593: */
1594: outb(IO_KBD + KBCMDP, KBC_PULSE0);
1595: delay(100000);
1596: outb(IO_KBD + KBCMDP, KBC_PULSE0);
1597: delay(100000);
1598:
1599: /*
1600: * Try to cause a triple fault and watchdog reset by making the IDT
1601: * invalid and causing a fault.
1602: */
1603: memset((caddr_t)idt, 0, NIDT * sizeof(idt[0]));
1604: __asm __volatile("divl %0,%1" : : "q" (0), "a" (0));
1605:
1606: #if 0
1607: /*
1608: * Try to cause a triple fault and watchdog reset by unmapping the
1609: * entire address space and doing a TLB flush.
1610: */
1611: memset((caddr_t)PTD, 0, PAGE_SIZE);
1612: tlbflush();
1613: #endif
1614:
1615: for (;;);
1616: }
1617:
1618: /*
1619: * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
1620: */
1621: int
1622: cpu_dumpsize(void)
1623: {
1624: int size;
1625:
1626: size = ALIGN(sizeof(kcore_seg_t)) +
1627: ALIGN(mem_cluster_cnt * sizeof(phys_ram_seg_t));
1628: if (roundup(size, dbtob(1)) != dbtob(1))
1629: return (-1);
1630:
1631: return (1);
1632: }
1633:
1634: /*
1635: * cpu_dump_mempagecnt: calculate the size of RAM (in pages) to be dumped.
1636: */
1637: u_long
1638: cpu_dump_mempagecnt(void)
1639: {
1640: u_long i, n;
1641:
1642: n = 0;
1643: for (i = 0; i < mem_cluster_cnt; i++)
1644: n += atop(mem_clusters[i].size);
1645: return (n);
1646: }
1647:
1648: void
1649: cpu_initclocks(void)
1650: {
1651: (*initclock_func)();
1652:
1653: if (initclock_func == i8254_initclocks)
1654: i8254_inittimecounter();
1655: else
1656: i8254_inittimecounter_simple();
1657: }
1658:
1659: void
1660: need_resched(struct cpu_info *ci)
1661: {
1662: ci->ci_want_resched = 1;
1663: if ((ci)->ci_curproc != NULL)
1664: aston((ci)->ci_curproc);
1665: }
1666:
1667: /*
1668: * Allocate an IDT vector slot within the given range.
1669: * XXX needs locking to avoid MP allocation races.
1670: * XXXfvdl share idt code
1671: */
1672:
1673: int
1674: idt_vec_alloc(int low, int high)
1675: {
1676: int vec;
1677:
1678: simple_lock(&idt_lock);
1679: for (vec = low; vec <= high; vec++) {
1680: if (idt_allocmap[vec] == 0) {
1681: idt_allocmap[vec] = 1;
1682: simple_unlock(&idt_lock);
1683: return vec;
1684: }
1685: }
1686: simple_unlock(&idt_lock);
1687: return 0;
1688: }
1689:
1690: void
1691: idt_vec_set(int vec, void (*function)(void))
1692: {
1693: /*
1694: * Vector should be allocated, so no locking needed.
1695: */
1696: KASSERT(idt_allocmap[vec] == 1);
1697: setgate(&idt[vec], function, 0, SDT_SYS386IGT, SEL_KPL,
1698: GSEL(GCODE_SEL, SEL_KPL));
1699: }
1700:
1701: void
1702: idt_vec_free(int vec)
1703: {
1704: simple_lock(&idt_lock);
1705: unsetgate(&idt[vec]);
1706: idt_allocmap[vec] = 0;
1707: simple_unlock(&idt_lock);
1708: }
1709:
1710: /*
1711: * Number of processes is limited by number of available GDT slots.
1712: */
1713: int
1714: cpu_maxproc(void)
1715: {
1716: #ifdef USER_LDT
1717: return ((MAXGDTSIZ - DYNSEL_START) / 32);
1718: #else
1719: return (MAXGDTSIZ - DYNSEL_START) / 16;
1720: #endif
1721: }
1722:
1723: #ifdef DIAGNOSTIC
1724: void
1725: splassert_check(int wantipl, const char *func)
1726: {
1727: int cpl = curcpu()->ci_ilevel;
1728:
1729: if (cpl < wantipl) {
1730: splassert_fail(wantipl, cpl, func);
1731: }
1732: }
1733: #endif
1734:
1735: void
1736: getbootinfo(char *bootinfo, int bootinfo_size)
1737: {
1738: bootarg32_t *q;
1739:
1740: #undef BOOTINFO_DEBUG
1741: #ifdef BOOTINFO_DEBUG
1742: printf("bootargv:");
1743: #endif
1744:
1745: for (q = (bootarg32_t *)bootinfo;
1746: (q->ba_type != BOOTARG_END) &&
1747: ((((char *)q) - bootinfo) < bootinfo_size);
1748: q = (bootarg32_t *)(((char *)q) + q->ba_size)) {
1749:
1750: switch (q->ba_type) {
1751: case BOOTARG_MEMMAP:
1752: bios_memmap = (bios_memmap_t *)q->ba_arg;
1753: #ifdef BOOTINFO_DEBUG
1754: printf(" memmap %p", bios_memmap);
1755: #endif
1756: break;
1757: case BOOTARG_DISKINFO:
1758: bios_diskinfo = (bios_diskinfo_t *)q->ba_arg;
1759: #ifdef BOOTINFO_DEBUG
1760: printf(" diskinfo %p", bios_diskinfo);
1761: #endif
1762: break;
1763: #if 0
1764: #if NAPM > 0 || defined(DEBUG)
1765: case BOOTARG_APMINFO:
1766: #ifdef BOOTINFO_DEBUG
1767: printf(" apminfo %p", q->ba_arg);
1768: #endif
1769: apm = (bios_apminfo_t *)q->ba_arg;
1770: break;
1771: #endif
1772: #endif
1773: case BOOTARG_CKSUMLEN:
1774: bios_cksumlen = *(u_int32_t *)q->ba_arg;
1775: #ifdef BOOTINFO_DEBUG
1776: printf(" cksumlen %d", bios_cksumlen);
1777: #endif
1778: break;
1779: #if 0
1780: #if NPCI > 0
1781: case BOOTARG_PCIINFO:
1782: bios_pciinfo = (bios_pciinfo_t *)q->ba_arg;
1783: #ifdef BOOTINFO_DEBUG
1784: printf(" pciinfo %p", bios_pciinfo);
1785: #endif
1786: break;
1787: #endif
1788: #endif
1789: case BOOTARG_CONSDEV:
1790: if (q->ba_size >= sizeof(bios_consdev_t))
1791: {
1792: bios_consdev_t *cdp =
1793: (bios_consdev_t*)q->ba_arg;
1794: #include "com.h"
1795: #if NCOM > 0
1796: extern int comdefaultrate; /* ic/com.c */
1797: comdefaultrate = cdp->conspeed;
1798: #endif
1799: #ifdef BOOTINFO_DEBUG
1800: printf(" console 0x%x:%d",
1801: cdp->consdev, cdp->conspeed);
1802: #endif
1803: cnset(cdp->consdev);
1804: }
1805: break;
1806: #ifdef NFSCLIENT
1807: case BOOTARG_BOOTMAC:
1808: bios_bootmac = (bios_bootmac_t *)q->ba_arg;
1809: break;
1810: #endif
1811:
1812: default:
1813: #ifdef BOOTINFO_DEBUG
1814: printf(" unsupported arg (%d) %p", q->ba_type,
1815: q->ba_arg);
1816: #endif
1817: break;
1818: }
1819: }
1820: #ifdef BOOTINFO_DEBUG
1821: printf("\n");
1822: #endif
1823: }
1824:
1825: int
1826: check_context(const struct reg *regs, struct trapframe *tf)
1827: {
1828: uint16_t sel;
1829:
1830: if (((regs->r_rflags ^ tf->tf_rflags) & PSL_USERSTATIC) != 0)
1831: return EINVAL;
1832:
1833: sel = regs->r_es & 0xffff;
1834: if (sel != 0 && !VALID_USER_DSEL(sel))
1835: return EINVAL;
1836:
1837: sel = regs->r_fs & 0xffff;
1838: if (sel != 0 && !VALID_USER_DSEL(sel))
1839: return EINVAL;
1840:
1841: sel = regs->r_gs & 0xffff;
1842: if (sel != 0 && !VALID_USER_DSEL(sel))
1843: return EINVAL;
1844:
1845: sel = regs->r_ds & 0xffff;
1846: if (!VALID_USER_DSEL(sel))
1847: return EINVAL;
1848:
1849: sel = regs->r_ss & 0xffff;
1850: if (!VALID_USER_DSEL(sel))
1851: return EINVAL;
1852:
1853: sel = regs->r_cs & 0xffff;
1854: if (!VALID_USER_CSEL(sel))
1855: return EINVAL;
1856:
1857: if (regs->r_rip >= VM_MAXUSER_ADDRESS)
1858: return EINVAL;
1859:
1860: return 0;
1861: }
CVSweb
![[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 / amd64 / amd64