Annotation of src/sys/arch/i386/i386/locore.S, Revision 1.24
1.24 ! yamt 1: /* $NetBSD: locore.S,v 1.23 2004/02/16 17:11:27 wiz Exp $ */
1.1 fvdl 2:
3: /*-
4: * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
5: * All rights reserved.
6: *
7: * This code is derived from software contributed to The NetBSD Foundation
8: * by Charles M. Hannum.
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the NetBSD
21: * Foundation, Inc. and its contributors.
22: * 4. Neither the name of The NetBSD Foundation nor the names of its
23: * contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: * POSSIBILITY OF SUCH DAMAGE.
37: */
38:
39: /*-
40: * Copyright (c) 1990 The Regents of the University of California.
41: * All rights reserved.
42: *
43: * This code is derived from software contributed to Berkeley by
44: * William Jolitz.
45: *
46: * Redistribution and use in source and binary forms, with or without
47: * modification, are permitted provided that the following conditions
48: * are met:
49: * 1. Redistributions of source code must retain the above copyright
50: * notice, this list of conditions and the following disclaimer.
51: * 2. Redistributions in binary form must reproduce the above copyright
52: * notice, this list of conditions and the following disclaimer in the
53: * documentation and/or other materials provided with the distribution.
1.12 agc 54: * 3. Neither the name of the University nor the names of its contributors
1.1 fvdl 55: * may be used to endorse or promote products derived from this software
56: * without specific prior written permission.
57: *
58: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
59: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
60: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
61: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
62: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
63: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
64: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
65: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
66: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
67: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68: * SUCH DAMAGE.
69: *
70: * @(#)locore.s 7.3 (Berkeley) 5/13/91
71: */
72:
1.18 christos 73: #include "opt_compat_netbsd.h"
74: #include "opt_compat_oldboot.h"
1.1 fvdl 75: #include "opt_cputype.h"
76: #include "opt_ddb.h"
77: #include "opt_ipkdb.h"
1.18 christos 78: #include "opt_lockdebug.h"
1.1 fvdl 79: #include "opt_multiprocessor.h"
80: #include "opt_realmem.h"
1.18 christos 81: #include "opt_user_ldt.h"
82: #include "opt_vm86.h"
1.1 fvdl 83:
84: #include "npx.h"
85: #include "assym.h"
86: #include "apm.h"
87: #include "lapic.h"
88: #include "ioapic.h"
1.8 fvdl 89: #include "ksyms.h"
1.1 fvdl 90:
91: #include <sys/errno.h>
92: #include <sys/syscall.h>
93:
94: #include <machine/cputypes.h>
95: #include <machine/param.h>
96: #include <machine/pte.h>
97: #include <machine/segments.h>
98: #include <machine/specialreg.h>
99: #include <machine/trap.h>
100: #include <machine/bootinfo.h>
101:
102: #if NLAPIC > 0
103: #include <machine/i82489reg.h>
104: #endif
105:
106: /* LINTSTUB: include <sys/types.h> */
107: /* LINTSTUB: include <machine/cpu.h> */
108: /* LINTSTUB: include <sys/systm.h> */
109:
110: #include <machine/asm.h>
111:
112: #if defined(MULTIPROCESSOR)
113:
1.5 thorpej 114: #define SET_CURLWP(lwp,cpu) \
1.1 fvdl 115: movl CPUVAR(SELF),cpu ; \
1.5 thorpej 116: movl lwp,CPUVAR(CURLWP) ; \
117: movl cpu,L_CPU(lwp)
1.1 fvdl 118:
119: #else
120:
1.5 thorpej 121: #define SET_CURLWP(lwp,tcpu) movl lwp,CPUVAR(CURLWP)
122: #define GET_CURLWP(reg) movl CPUVAR(CURLWP),reg
1.1 fvdl 123:
124: #endif
125:
126: #define GET_CURPCB(reg) movl CPUVAR(CURPCB),reg
127: #define SET_CURPCB(reg) movl reg,CPUVAR(CURPCB)
1.24 ! yamt 128:
1.1 fvdl 129: #define CLEAR_RESCHED(reg) movl reg,CPUVAR(RESCHED)
130:
131: /* XXX temporary kluge; these should not be here */
132: /* Get definitions for IOM_BEGIN, IOM_END, and IOM_SIZE */
133: #include <dev/isa/isareg.h>
134:
135:
136: /* Disallow old names for REALBASEMEM */
137: #ifdef BIOSBASEMEM
138: #error BIOSBASEMEM option deprecated; use REALBASEMEM only if memory size reported by latest boot block is incorrect
139: #endif
140:
141: /* Disallow old names for REALEXTMEM */
142: #ifdef EXTMEM_SIZE
143: #error EXTMEM_SIZE option deprecated; use REALEXTMEM only if memory size reported by latest boot block is incorrect
144: #endif
145: #ifdef BIOSEXTMEM
146: #error BIOSEXTMEM option deprecated; use REALEXTMEM only if memory size reported by latest boot block is incorrect
147: #endif
148:
149: #include <machine/frameasm.h>
150:
151:
152: #ifdef MULTIPROCESSOR
153: #include <machine/i82489reg.h>
154: #endif
155:
156: /*
157: * PTmap is recursive pagemap at top of virtual address space.
158: * Within PTmap, the page directory can be found (third indirection).
159: *
160: * XXX 4 == sizeof pde
161: */
162: .set _C_LABEL(PTmap),(PDSLOT_PTE << PDSHIFT)
1.7 thorpej 163: .set _C_LABEL(PTD),(_C_LABEL(PTmap) + PDSLOT_PTE * PAGE_SIZE)
1.1 fvdl 164: .set _C_LABEL(PTDpde),(_C_LABEL(PTD) + PDSLOT_PTE * 4)
165:
166: /*
167: * APTmap, APTD is the alternate recursive pagemap.
168: * It's used when modifying another process's page tables.
169: *
170: * XXX 4 == sizeof pde
171: */
172: .set _C_LABEL(APTmap),(PDSLOT_APTE << PDSHIFT)
1.7 thorpej 173: .set _C_LABEL(APTD),(_C_LABEL(APTmap) + PDSLOT_APTE * PAGE_SIZE)
1.1 fvdl 174: .set _C_LABEL(APTDpde),(_C_LABEL(PTD) + PDSLOT_APTE * 4)
175:
176:
177: /*
178: * Initialization
179: */
180: .data
181:
182: .globl _C_LABEL(cpu)
183: .globl _C_LABEL(esym),_C_LABEL(boothowto)
184: .globl _C_LABEL(bootinfo),_C_LABEL(atdevbase)
185: #ifdef COMPAT_OLDBOOT
186: .globl _C_LABEL(bootdev)
187: #endif
188: .globl _C_LABEL(proc0paddr),_C_LABEL(PTDpaddr)
189: .globl _C_LABEL(biosbasemem),_C_LABEL(biosextmem)
190: .globl _C_LABEL(gdt)
191: #ifdef I586_CPU
192: .globl _C_LABEL(idt)
193: #endif
194: .globl _C_LABEL(lapic_tpr)
195:
196: #if NLAPIC > 0
197: #ifdef __ELF__
1.7 thorpej 198: .align PAGE_SIZE
1.1 fvdl 199: #else
200: .align 12
201: #endif
202: .globl _C_LABEL(local_apic), _C_LABEL(lapic_id)
203: _C_LABEL(local_apic):
204: .space LAPIC_ID
205: _C_LABEL(lapic_id):
206: .long 0x00000000
207: .space LAPIC_TPRI-(LAPIC_ID+4)
208: _C_LABEL(lapic_tpr):
209: .space LAPIC_PPRI-LAPIC_TPRI
210: _C_LABEL(lapic_ppr):
211: .space LAPIC_ISR-LAPIC_PPRI
212: _C_LABEL(lapic_isr):
1.7 thorpej 213: .space PAGE_SIZE-LAPIC_ISR
1.1 fvdl 214: #else
215: _C_LABEL(lapic_tpr):
216: .long 0
217: #endif
218:
219:
220: _C_LABEL(cpu): .long 0 # are we 386, 386sx, or 486,
221: # or Pentium, or..
222: _C_LABEL(esym): .long 0 # ptr to end of syms
223: _C_LABEL(atdevbase): .long 0 # location of start of iomem in virtual
224: _C_LABEL(proc0paddr): .long 0
225: _C_LABEL(PTDpaddr): .long 0 # paddr of PTD, for libkvm
226: #ifndef REALBASEMEM
227: _C_LABEL(biosbasemem): .long 0 # base memory reported by BIOS
228: #else
229: _C_LABEL(biosbasemem): .long REALBASEMEM
230: #endif
231: #ifndef REALEXTMEM
232: _C_LABEL(biosextmem): .long 0 # extended memory reported by BIOS
233: #else
234: _C_LABEL(biosextmem): .long REALEXTMEM
235: #endif
236:
237: .space 512
238: tmpstk:
239:
240:
1.13 christos 241: #define _RELOC(x) ((x) - KERNBASE_LOCORE)
1.1 fvdl 242: #define RELOC(x) _RELOC(_C_LABEL(x))
243:
244: .text
245: .globl _C_LABEL(kernel_text)
246: .set _C_LABEL(kernel_text),KERNTEXTOFF
247:
248: .globl start
249: start: movw $0x1234,0x472 # warm boot
250:
251: /*
252: * Load parameters from stack
253: * (howto, [bootdev], bootinfo, esym, basemem, extmem).
254: */
255: movl 4(%esp),%eax
256: movl %eax,RELOC(boothowto)
257: #ifdef COMPAT_OLDBOOT
258: movl 8(%esp),%eax
259: movl %eax,RELOC(bootdev)
260: #endif
261: movl 12(%esp),%eax
262:
263: testl %eax, %eax
264: jz 1f
265: movl (%eax), %ebx /* number of entries */
266: movl $RELOC(bootinfo), %edi
267: movl %ebx, (%edi)
268: addl $4, %edi
269: 2:
270: testl %ebx, %ebx
271: jz 1f
272: addl $4, %eax
273: movl (%eax), %ecx /* address of entry */
274: pushl %eax
275: pushl (%ecx) /* len */
276: pushl %ecx
277: pushl %edi
278: addl (%ecx), %edi /* update dest pointer */
279: cmpl $_RELOC(_C_LABEL(bootinfo) + BOOTINFO_MAXSIZE), %edi
280: jg 2f
281: call _C_LABEL(memcpy)
282: addl $12, %esp
283: popl %eax
284: subl $1, %ebx
285: jmp 2b
286: 2: /* cleanup for overflow case */
287: addl $16, %esp
288: movl $RELOC(bootinfo), %edi
289: subl %ebx, (%edi) /* correct number of entries */
290: 1:
291:
292: movl 16(%esp),%eax
293: testl %eax,%eax
294: jz 1f
1.13 christos 295: addl $KERNBASE_LOCORE,%eax
1.1 fvdl 296: 1: movl %eax,RELOC(esym)
297:
298: movl RELOC(biosextmem),%eax
299: testl %eax,%eax
300: jnz 1f
301: movl 20(%esp),%eax
302: movl %eax,RELOC(biosextmem)
303: 1:
304: movl RELOC(biosbasemem),%eax
305: testl %eax,%eax
306: jnz 1f
307: movl 24(%esp),%eax
308: movl %eax,RELOC(biosbasemem)
309: 1:
310:
311: /* First, reset the PSL. */
312: pushl $PSL_MBO
313: popfl
314:
315: /* Clear segment registers; always null in proc0. */
316: xorl %eax,%eax
317: movw %ax,%fs
318: movw %ax,%gs
319: decl %eax
320: movl %eax,RELOC(cpu_info_primary)+CPU_INFO_LEVEL
321:
322: /* Find out our CPU type. */
323:
324: try386: /* Try to toggle alignment check flag; does not exist on 386. */
325: pushfl
326: popl %eax
327: movl %eax,%ecx
328: orl $PSL_AC,%eax
329: pushl %eax
330: popfl
331: pushfl
332: popl %eax
333: xorl %ecx,%eax
334: andl $PSL_AC,%eax
335: pushl %ecx
336: popfl
337:
338: testl %eax,%eax
339: jnz try486
340:
341: /*
342: * Try the test of a NexGen CPU -- ZF will not change on a DIV
343: * instruction on a NexGen, it will on an i386. Documented in
344: * Nx586 Processor Recognition Application Note, NexGen, Inc.
345: */
346: movl $0x5555,%eax
347: xorl %edx,%edx
348: movl $2,%ecx
349: divl %ecx
350: jnz is386
351:
352: isnx586:
353: /*
354: * Don't try cpuid, as Nx586s reportedly don't support the
355: * PSL_ID bit.
356: */
357: movl $CPU_NX586,RELOC(cpu)
358: jmp 2f
359:
360: is386:
361: movl $CPU_386,RELOC(cpu)
362: jmp 2f
363:
364: try486: /* Try to toggle identification flag; does not exist on early 486s. */
365: pushfl
366: popl %eax
367: movl %eax,%ecx
368: xorl $PSL_ID,%eax
369: pushl %eax
370: popfl
371: pushfl
372: popl %eax
373: xorl %ecx,%eax
374: andl $PSL_ID,%eax
375: pushl %ecx
376: popfl
377:
378: testl %eax,%eax
379: jnz try586
380: is486: movl $CPU_486,RELOC(cpu)
381: /*
382: * Check Cyrix CPU
383: * Cyrix CPUs do not change the undefined flags following
384: * execution of the divide instruction which divides 5 by 2.
385: *
386: * Note: CPUID is enabled on M2, so it passes another way.
387: */
388: pushfl
389: movl $0x5555, %eax
390: xorl %edx, %edx
391: movl $2, %ecx
392: clc
393: divl %ecx
394: jnc trycyrix486
395: popfl
396: jmp 2f
397: trycyrix486:
398: movl $CPU_6x86,RELOC(cpu) # set CPU type
399: /*
400: * Check for Cyrix 486 CPU by seeing if the flags change during a
401: * divide. This is documented in the Cx486SLC/e SMM Programmer's
402: * Guide.
403: */
404: xorl %edx,%edx
405: cmpl %edx,%edx # set flags to known state
406: pushfl
407: popl %ecx # store flags in ecx
408: movl $-1,%eax
409: movl $4,%ebx
410: divl %ebx # do a long division
411: pushfl
412: popl %eax
413: xorl %ecx,%eax # are the flags different?
414: testl $0x8d5,%eax # only check C|PF|AF|Z|N|V
415: jne 2f # yes; must be Cyrix 6x86 CPU
416: movl $CPU_486DLC,RELOC(cpu) # set CPU type
417:
418: #ifndef CYRIX_CACHE_WORKS
419: /* Disable caching of the ISA hole only. */
420: invd
421: movb $CCR0,%al # Configuration Register index (CCR0)
422: outb %al,$0x22
423: inb $0x23,%al
424: orb $(CCR0_NC1|CCR0_BARB),%al
425: movb %al,%ah
426: movb $CCR0,%al
427: outb %al,$0x22
428: movb %ah,%al
429: outb %al,$0x23
430: invd
431: #else /* CYRIX_CACHE_WORKS */
432: /* Set cache parameters */
433: invd # Start with guaranteed clean cache
434: movb $CCR0,%al # Configuration Register index (CCR0)
435: outb %al,$0x22
436: inb $0x23,%al
437: andb $~CCR0_NC0,%al
438: #ifndef CYRIX_CACHE_REALLY_WORKS
439: orb $(CCR0_NC1|CCR0_BARB),%al
440: #else
441: orb $CCR0_NC1,%al
442: #endif
443: movb %al,%ah
444: movb $CCR0,%al
445: outb %al,$0x22
446: movb %ah,%al
447: outb %al,$0x23
448: /* clear non-cacheable region 1 */
449: movb $(NCR1+2),%al
450: outb %al,$0x22
451: movb $NCR_SIZE_0K,%al
452: outb %al,$0x23
453: /* clear non-cacheable region 2 */
454: movb $(NCR2+2),%al
455: outb %al,$0x22
456: movb $NCR_SIZE_0K,%al
457: outb %al,$0x23
458: /* clear non-cacheable region 3 */
459: movb $(NCR3+2),%al
460: outb %al,$0x22
461: movb $NCR_SIZE_0K,%al
462: outb %al,$0x23
463: /* clear non-cacheable region 4 */
464: movb $(NCR4+2),%al
465: outb %al,$0x22
466: movb $NCR_SIZE_0K,%al
467: outb %al,$0x23
468: /* enable caching in CR0 */
469: movl %cr0,%eax
470: andl $~(CR0_CD|CR0_NW),%eax
471: movl %eax,%cr0
472: invd
473: #endif /* CYRIX_CACHE_WORKS */
474:
475: jmp 2f
476:
477: try586: /* Use the `cpuid' instruction. */
478: xorl %eax,%eax
479: cpuid
480: movl %eax,RELOC(cpu_info_primary)+CPU_INFO_LEVEL
481:
482: 2:
483: /*
484: * Finished with old stack; load new %esp now instead of later so we
485: * can trace this code without having to worry about the trace trap
486: * clobbering the memory test or the zeroing of the bss+bootstrap page
487: * tables.
488: *
489: * The boot program should check:
490: * text+data <= &stack_variable - more_space_for_stack
491: * text+data+bss+pad+space_for_page_tables <= end_of_memory
492: * Oops, the gdt is in the carcass of the boot program so clearing
493: * the rest of memory is still not possible.
494: */
495: movl $_RELOC(tmpstk),%esp # bootstrap stack end location
496:
497: /*
498: * Virtual address space of kernel:
499: *
500: * text | data | bss | [syms] | page dir | proc0 kstack
501: * 0 1 2 3
502: */
1.7 thorpej 503: #define PROC0PDIR ((0) * PAGE_SIZE)
504: #define PROC0STACK ((1) * PAGE_SIZE)
505: #define SYSMAP ((1+UPAGES) * PAGE_SIZE)
506: #define TABLESIZE ((1+UPAGES) * PAGE_SIZE) /* + nkpde * PAGE_SIZE */
1.1 fvdl 507:
508: /* Find end of kernel image. */
509: movl $RELOC(end),%edi
1.8 fvdl 510: #if (NKSYMS || defined(DDB) || defined(LKM)) && !defined(SYMTAB_SPACE)
1.1 fvdl 511: /* Save the symbols (if loaded). */
512: movl RELOC(esym),%eax
513: testl %eax,%eax
514: jz 1f
1.13 christos 515: subl $KERNBASE_LOCORE,%eax
1.1 fvdl 516: movl %eax,%edi
517: 1:
518: #endif
519:
520: /* Calculate where to start the bootstrap tables. */
521: movl %edi,%esi # edi = esym ? esym : end
522: addl $PGOFSET,%esi # page align up
523: andl $~PGOFSET,%esi
524:
525: /*
526: * Calculate the size of the kernel page table directory, and
527: * how many entries it will have.
528: */
529: movl RELOC(nkpde),%ecx # get nkpde
530: cmpl $NKPTP_MIN,%ecx # larger than min?
531: jge 1f
532: movl $NKPTP_MIN,%ecx # set at min
533: jmp 2f
534: 1: cmpl $NKPTP_MAX,%ecx # larger than max?
535: jle 2f
536: movl $NKPTP_MAX,%ecx
537: 2:
538:
539: /* Clear memory for bootstrap tables. */
540: shll $PGSHIFT,%ecx
541: addl $TABLESIZE,%ecx
542: addl %esi,%ecx # end of tables
543: subl %edi,%ecx # size of tables
544: shrl $2,%ecx
545: xorl %eax,%eax
546: cld
547: rep
548: stosl
549:
550: /*
551: * fillkpt
552: * eax = pte (page frame | control | status)
553: * ebx = page table address
554: * ecx = number of pages to map
555: */
556: #define fillkpt \
557: 1: movl %eax,(%ebx) ; \
1.7 thorpej 558: addl $PAGE_SIZE,%eax ; /* increment physical address */ \
1.1 fvdl 559: addl $4,%ebx ; /* next pte */ \
560: loop 1b ;
561:
562: /*
563: * Build initial page tables.
564: */
565: /* Calculate end of text segment, rounded to a page. */
566: leal (RELOC(etext)+PGOFSET),%edx
567: andl $~PGOFSET,%edx
568:
569: /* Skip over the first 1MB. */
570: movl $_RELOC(KERNTEXTOFF),%eax
571: movl %eax,%ecx
572: shrl $PGSHIFT,%ecx
573: leal (SYSMAP)(%esi,%ecx,4),%ebx
574:
575: /* Map the kernel text read-only. */
576: movl %edx,%ecx
577: subl %eax,%ecx
578: shrl $PGSHIFT,%ecx
579: orl $(PG_V|PG_KR),%eax
580: fillkpt
581:
582: /* Map the data, BSS, and bootstrap tables read-write. */
583: leal (PG_V|PG_KW)(%edx),%eax
584: movl RELOC(nkpde),%ecx
585: shll $PGSHIFT,%ecx
586: addl $TABLESIZE,%ecx
587: addl %esi,%ecx # end of tables
588: subl %edx,%ecx # subtract end of text
589: shrl $PGSHIFT,%ecx
590: fillkpt
591:
592: /* Map ISA I/O memory. */
593: movl $(IOM_BEGIN|PG_V|PG_KW/*|PG_N*/),%eax # having these bits set
594: movl $(IOM_SIZE>>PGSHIFT),%ecx # for this many pte s,
595: fillkpt
596:
597: /*
598: * Construct a page table directory.
599: */
600: /* Install PDEs for temporary double map of kernel. */
601: movl RELOC(nkpde),%ecx # for this many pde s,
602: leal (PROC0PDIR+0*4)(%esi),%ebx # which is where temp maps!
603: leal (SYSMAP+PG_V|PG_KW)(%esi),%eax # pte for KPT in proc 0,
604: fillkpt
605:
606: /* Map kernel PDEs. */
607: movl RELOC(nkpde),%ecx # for this many pde s,
608: leal (PROC0PDIR+PDSLOT_KERN*4)(%esi),%ebx # kernel pde offset
609: leal (SYSMAP+PG_V|PG_KW)(%esi),%eax # pte for KPT in proc 0,
610: fillkpt
611:
612: /* Install a PDE recursively mapping page directory as a page table! */
613: leal (PROC0PDIR+PG_V|PG_KW)(%esi),%eax # pte for ptd
614: movl %eax,(PROC0PDIR+PDSLOT_PTE*4)(%esi) # recursive PD slot
615:
616: /* Save phys. addr of PTD, for libkvm. */
617: movl %esi,RELOC(PTDpaddr)
618:
619: /* Load base of page directory and enable mapping. */
620: movl %esi,%eax # phys address of ptd in proc 0
621: movl %eax,%cr3 # load ptd addr into mmu
622: movl %cr0,%eax # get control word
623: # enable paging & NPX emulation
624: orl $(CR0_PE|CR0_PG|CR0_NE|CR0_TS|CR0_EM|CR0_MP),%eax
625: movl %eax,%cr0 # and let's page NOW!
626:
627: pushl $begin # jump to high mem
628: ret
629:
630: begin:
1.13 christos 631: /* Now running relocated at KERNBASE_LOCORE. Remove double mapping. */
1.1 fvdl 632: movl _C_LABEL(nkpde),%ecx # for this many pde s,
633: leal (PROC0PDIR+0*4)(%esi),%ebx # which is where temp maps!
1.13 christos 634: addl $(KERNBASE_LOCORE), %ebx # now use relocated address
1.1 fvdl 635: 1: movl $0,(%ebx)
636: addl $4,%ebx # next pde
637: loop 1b
638:
639: /* Relocate atdevbase. */
640: movl _C_LABEL(nkpde),%edx
641: shll $PGSHIFT,%edx
1.13 christos 642: addl $(TABLESIZE+KERNBASE_LOCORE),%edx
1.1 fvdl 643: addl %esi,%edx
644: movl %edx,_C_LABEL(atdevbase)
645:
646: /* Set up bootstrap stack. */
1.13 christos 647: leal (PROC0STACK+KERNBASE_LOCORE)(%esi),%eax
1.1 fvdl 648: movl %eax,_C_LABEL(proc0paddr)
649: leal (USPACE-FRAMESIZE)(%eax),%esp
650: movl %esi,PCB_CR3(%eax) # pcb->pcb_cr3
651: xorl %ebp,%ebp # mark end of frames
652:
653: subl $NGDT*8, %esp # space for temporary gdt
654: pushl %esp
655: call _C_LABEL(initgdt)
656: addl $4,%esp
657:
658: movl _C_LABEL(nkpde),%eax
659: shll $PGSHIFT,%eax
660: addl $TABLESIZE,%eax
661: addl %esi,%eax # skip past stack and page tables
662:
663: pushl %eax
664: call _C_LABEL(init386) # wire 386 chip for unix operation
665: addl $4+NGDT*8,%esp # pop temporary gdt
666:
667: #ifdef SAFARI_FIFO_HACK
668: movb $5,%al
669: movw $0x37b,%dx
670: outb %al,%dx
671: movw $0x37f,%dx
672: inb %dx,%al
673: movb %al,%cl
674:
675: orb $1,%cl
676:
677: movb $5,%al
678: movw $0x37b,%dx
679: outb %al,%dx
680: movw $0x37f,%dx
681: movb %cl,%al
682: outb %al,%dx
683: #endif /* SAFARI_FIFO_HACK */
684:
685: call _C_LABEL(main)
686:
687: /*
688: * void proc_trampoline(void);
689: * This is a trampoline function pushed onto the stack of a newly created
690: * process in order to do some additional setup. The trampoline is entered by
691: * cpu_switch()ing to the process, so we abuse the callee-saved registers used
692: * by cpu_switch() to store the information about the stub to call.
693: * NOTE: This function does not have a normal calling sequence!
694: */
695: /* LINTSTUB: Func: void proc_trampoline(void) */
696: NENTRY(proc_trampoline)
697: #ifdef MULTIPROCESSOR
698: call _C_LABEL(proc_trampoline_mp)
699: #endif
700: movl $IPL_NONE,CPUVAR(ILEVEL)
701: pushl %ebx
702: call *%esi
703: addl $4,%esp
1.24 ! yamt 704: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 705: INTRFASTEXIT
706: /* NOTREACHED */
707:
708: /*****************************************************************************/
1.16 christos 709: #ifdef COMPAT_16
1.1 fvdl 710: /*
711: * Signal trampoline; copied to top of user stack.
712: */
713: /* LINTSTUB: Var: char sigcode[1], esigcode[1]; */
714: NENTRY(sigcode)
715: /*
716: * Handler has returned here as if we called it. The sigcontext
717: * is on the stack after the 3 args "we" pushed.
718: */
719: leal 12(%esp),%eax # get pointer to sigcontext
720: movl %eax,4(%esp) # put it in the argument slot
721: # fake return address already there
1.19 christos 722: #if defined(SYS_compat_16___sigreturn14)
1.17 christos 723: movl $SYS_compat_16___sigreturn14,%eax
1.19 christos 724: #elif defined(SYS___sigreturn14)
725: movl $SYS___sigreturn14,%eax
726: #else
727: #error "no sigreturn14 syscall"
728: #endif
1.1 fvdl 729: int $0x80 # enter kernel with args on stack
730: movl $SYS_exit,%eax
731: int $0x80 # exit if sigreturn fails
732: .globl _C_LABEL(esigcode)
733: _C_LABEL(esigcode):
1.16 christos 734: #endif
1.1 fvdl 735:
736: /*****************************************************************************/
737:
738: /*
739: * The following primitives are used to fill and copy regions of memory.
740: */
741:
742: /*
743: * XXX No section 9 man page for fillw.
744: * fillw seems to be very sparsely used (only in pccons it seems.)
745: * One wonders if it couldn't be done without.
746: * -- Perry Metzger, May 7, 2001
747: */
748: /*
749: * void fillw(short pattern, void *addr, size_t len);
750: * Write len copies of pattern at addr.
751: */
752: /* LINTSTUB: Func: void fillw(short pattern, void *addr, size_t len) */
753: ENTRY(fillw)
754: pushl %edi
755: movl 8(%esp),%eax
756: movl 12(%esp),%edi
757: movw %ax,%cx
758: rorl $16,%eax
759: movw %cx,%ax
760: cld
761: movl 16(%esp),%ecx
762: shrl %ecx # do longwords
763: rep
764: stosl
765: movl 16(%esp),%ecx
766: andl $1,%ecx # do remainder
767: rep
768: stosw
769: popl %edi
770: ret
771:
772: /*
773: * int kcopy(const void *from, void *to, size_t len);
774: * Copy len bytes, abort on fault.
775: */
776: /* LINTSTUB: Func: int kcopy(const void *from, void *to, size_t len) */
777: ENTRY(kcopy)
778: pushl %esi
779: pushl %edi
780: GET_CURPCB(%eax) # load curpcb into eax and set on-fault
781: pushl PCB_ONFAULT(%eax)
1.24 ! yamt 782: movl $_C_LABEL(kcopy_fault), PCB_ONFAULT(%eax)
1.1 fvdl 783:
784: movl 16(%esp),%esi
785: movl 20(%esp),%edi
786: movl 24(%esp),%ecx
787: movl %edi,%eax
788: subl %esi,%eax
789: cmpl %ecx,%eax # overlapping?
790: jb 1f
791: cld # nope, copy forward
792: shrl $2,%ecx # copy by 32-bit words
793: rep
794: movsl
795: movl 24(%esp),%ecx
796: andl $3,%ecx # any bytes left?
797: rep
798: movsb
799:
800: GET_CURPCB(%edx) # XXX save curpcb?
801: popl PCB_ONFAULT(%edx)
802: popl %edi
803: popl %esi
804: xorl %eax,%eax
805: ret
806:
807: ALIGN_TEXT
808: 1: addl %ecx,%edi # copy backward
809: addl %ecx,%esi
810: std
811: andl $3,%ecx # any fractional bytes?
812: decl %edi
813: decl %esi
814: rep
815: movsb
816: movl 24(%esp),%ecx # copy remainder by 32-bit words
817: shrl $2,%ecx
818: subl $3,%esi
819: subl $3,%edi
820: rep
821: movsl
822: cld
823:
824: GET_CURPCB(%edx)
825: popl PCB_ONFAULT(%edx)
826: popl %edi
827: popl %esi
828: xorl %eax,%eax
829: ret
830:
831: /*****************************************************************************/
832:
833: /*
834: * The following primitives are used to copy data in and out of the user's
835: * address space.
836: */
837:
838: /*
839: * Default to the lowest-common-denominator. We will improve it
840: * later.
841: */
842: #if defined(I386_CPU)
843: #define DEFAULT_COPYOUT _C_LABEL(i386_copyout)
844: #define DEFAULT_COPYIN _C_LABEL(i386_copyin)
845: #elif defined(I486_CPU)
846: #define DEFAULT_COPYOUT _C_LABEL(i486_copyout)
847: #define DEFAULT_COPYIN _C_LABEL(i386_copyin)
848: #elif defined(I586_CPU)
849: #define DEFAULT_COPYOUT _C_LABEL(i486_copyout) /* XXX */
850: #define DEFAULT_COPYIN _C_LABEL(i386_copyin) /* XXX */
851: #elif defined(I686_CPU)
852: #define DEFAULT_COPYOUT _C_LABEL(i486_copyout) /* XXX */
853: #define DEFAULT_COPYIN _C_LABEL(i386_copyin) /* XXX */
854: #endif
855:
856: .data
857:
858: .globl _C_LABEL(copyout_func)
859: _C_LABEL(copyout_func):
860: .long DEFAULT_COPYOUT
861:
862: .globl _C_LABEL(copyin_func)
863: _C_LABEL(copyin_func):
864: .long DEFAULT_COPYIN
865:
866: .text
867:
868: /*
869: * int copyout(const void *from, void *to, size_t len);
870: * Copy len bytes into the user's address space.
871: * see copyout(9)
872: */
873: /* LINTSTUB: Func: int copyout(const void *kaddr, void *uaddr, size_t len) */
874: ENTRY(copyout)
1.24 ! yamt 875: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 876: jmp *_C_LABEL(copyout_func)
877:
878: #if defined(I386_CPU)
879: /* LINTSTUB: Func: int i386_copyout(const void *kaddr, void *uaddr, size_t len) */
880: ENTRY(i386_copyout)
881: pushl %esi
882: pushl %edi
883: pushl $0
884:
885: movl 16(%esp),%esi
886: movl 20(%esp),%edi
887: movl 24(%esp),%eax
888:
889: /*
890: * We check that the end of the destination buffer is not past the end
891: * of the user's address space. If it's not, then we only need to
892: * check that each page is writable. The 486 will do this for us; the
893: * 386 will not. (We assume that pages in user space that are not
894: * writable by the user are not writable by the kernel either.)
895: */
896: movl %edi,%edx
897: addl %eax,%edx
898: jc _C_LABEL(copy_efault)
899: cmpl $VM_MAXUSER_ADDRESS,%edx
900: ja _C_LABEL(copy_efault)
901:
902: testl %eax,%eax # anything to do?
903: jz 3f
904:
905: /*
906: * We have to check each PTE for (write) permission, since the CPU
907: * doesn't do it for us.
908: */
909:
910: /* Compute number of pages. */
911: movl %edi,%ecx
912: andl $PGOFSET,%ecx
913: addl %eax,%ecx
914: decl %ecx
915: shrl $PGSHIFT,%ecx
916:
917: /* Compute PTE offset for start address. */
918: shrl $PGSHIFT,%edi
919:
920: GET_CURPCB(%edx)
921: movl $2f,PCB_ONFAULT(%edx)
922:
923: 1: /* Check PTE for each page. */
924: testb $PG_RW,_C_LABEL(PTmap)(,%edi,4)
925: jz 2f
926:
927: 4: incl %edi
928: decl %ecx
929: jns 1b
930:
931: movl 20(%esp),%edi
932: movl 24(%esp),%eax
933: jmp 3f
934:
935: 2: /* Simulate a trap. */
936: pushl %ecx
937: movl %edi,%eax
938: shll $PGSHIFT,%eax
939: pushl %eax
940: call _C_LABEL(trapwrite) # trapwrite(addr)
941: addl $4,%esp # pop argument
942: popl %ecx
943: testl %eax,%eax # if not ok, return EFAULT
944: jz 4b
945: jmp _C_LABEL(copy_efault)
946:
947: 3: GET_CURPCB(%edx)
948: movl $_C_LABEL(copy_fault),PCB_ONFAULT(%edx)
949:
950: /* bcopy(%esi, %edi, %eax); */
951: cld
952: movl %eax,%ecx
953: shrl $2,%ecx
954: rep
955: movsl
956: movl %eax,%ecx
957: andl $3,%ecx
958: rep
959: movsb
960:
961: popl PCB_ONFAULT(%edx)
962: popl %edi
963: popl %esi
964: xorl %eax,%eax
965: ret
966: #endif /* I386_CPU */
967:
968: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
969: /* LINTSTUB: Func: int i486_copyout(const void *kaddr, void *uaddr, size_t len) */
970: ENTRY(i486_copyout)
971: pushl %esi
972: pushl %edi
973: pushl $0
974:
975: movl 16(%esp),%esi
976: movl 20(%esp),%edi
977: movl 24(%esp),%eax
978:
979: /*
980: * We check that the end of the destination buffer is not past the end
981: * of the user's address space.
982: */
983: movl %edi,%edx
984: addl %eax,%edx
985: jc _C_LABEL(copy_efault)
986: cmpl $VM_MAXUSER_ADDRESS,%edx
987: ja _C_LABEL(copy_efault)
988:
989: GET_CURPCB(%edx)
990: movl $_C_LABEL(copy_fault),PCB_ONFAULT(%edx)
991:
992: /* bcopy(%esi, %edi, %eax); */
993: cld
994: movl %eax,%ecx
995: shrl $2,%ecx
996: rep
997: movsl
998: movl %eax,%ecx
999: andl $3,%ecx
1000: rep
1001: movsb
1002:
1003: popl PCB_ONFAULT(%edx)
1004: popl %edi
1005: popl %esi
1006: xorl %eax,%eax
1007: ret
1008: #endif /* I486_CPU || I586_CPU || I686_CPU */
1009:
1010: /*
1011: * int copyin(const void *from, void *to, size_t len);
1012: * Copy len bytes from the user's address space.
1013: * see copyin(9)
1014: */
1015: /* LINTSTUB: Func: int copyin(const void *uaddr, void *kaddr, size_t len) */
1016: ENTRY(copyin)
1.24 ! yamt 1017: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1018: jmp *_C_LABEL(copyin_func)
1019:
1020: #if defined(I386_CPU) || defined(I486_CPU) || defined(I586_CPU) || \
1021: defined(I686_CPU)
1022: /* LINTSTUB: Func: int i386_copyin(const void *uaddr, void *kaddr, size_t len) */
1023: ENTRY(i386_copyin)
1024: pushl %esi
1025: pushl %edi
1026: GET_CURPCB(%eax)
1027: pushl $0
1028: movl $_C_LABEL(copy_fault),PCB_ONFAULT(%eax)
1029:
1030: movl 16(%esp),%esi
1031: movl 20(%esp),%edi
1032: movl 24(%esp),%eax
1033:
1034: /*
1035: * We check that the end of the destination buffer is not past the end
1036: * of the user's address space. If it's not, then we only need to
1037: * check that each page is readable, and the CPU will do that for us.
1038: */
1039: movl %esi,%edx
1040: addl %eax,%edx
1041: jc _C_LABEL(copy_efault)
1042: cmpl $VM_MAXUSER_ADDRESS,%edx
1043: ja _C_LABEL(copy_efault)
1044:
1045: /* bcopy(%esi, %edi, %eax); */
1046: cld
1047: movl %eax,%ecx
1048: shrl $2,%ecx
1049: rep
1050: movsl
1051: movl %eax,%ecx
1052: andl $3,%ecx
1053: rep
1054: movsb
1055:
1056: GET_CURPCB(%edx)
1057: popl PCB_ONFAULT(%edx)
1058: popl %edi
1059: popl %esi
1060: xorl %eax,%eax
1061: ret
1062: #endif /* I386_CPU || I486_CPU || I586_CPU || I686_CPU */
1063:
1064: /* LINTSTUB: Ignore */
1065: NENTRY(copy_efault)
1066: movl $EFAULT,%eax
1067:
1.24 ! yamt 1068: /*
! 1069: * kcopy_fault is used by kcopy and copy_fault is used by copyin/out.
! 1070: *
! 1071: * they're distinguished for lazy pmap switching. see trap().
! 1072: */
! 1073: /* LINTSTUB: Ignore */
! 1074: NENTRY(kcopy_fault)
! 1075: GET_CURPCB(%edx)
! 1076: popl PCB_ONFAULT(%edx)
! 1077: popl %edi
! 1078: popl %esi
! 1079: ret
! 1080:
1.1 fvdl 1081: /* LINTSTUB: Ignore */
1082: NENTRY(copy_fault)
1083: GET_CURPCB(%edx)
1084: popl PCB_ONFAULT(%edx)
1085: popl %edi
1086: popl %esi
1087: ret
1088:
1089: /*
1090: * int copyoutstr(const void *from, void *to, size_t maxlen, size_t *lencopied);
1091: * Copy a NUL-terminated string, at most maxlen characters long, into the
1092: * user's address space. Return the number of characters copied (including the
1093: * NUL) in *lencopied. If the string is too long, return ENAMETOOLONG; else
1094: * return 0 or EFAULT.
1095: * see copyoutstr(9)
1096: */
1097: /* LINTSTUB: Func: int copyoutstr(const void *kaddr, void *uaddr, size_t len, size_t *done) */
1098: ENTRY(copyoutstr)
1099: pushl %esi
1100: pushl %edi
1101:
1.24 ! yamt 1102: DO_DEFERRED_SWITCH(%eax)
! 1103:
1.1 fvdl 1104: movl 12(%esp),%esi # esi = from
1105: movl 16(%esp),%edi # edi = to
1106: movl 20(%esp),%edx # edx = maxlen
1107:
1108: #if defined(I386_CPU)
1109: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1110: cmpl $CPUCLASS_386,_C_LABEL(cpu_class)
1111: jne 5f
1112: #endif /* I486_CPU || I586_CPU || I686_CPU */
1113:
1114: /* Compute number of bytes in first page. */
1115: movl %edi,%eax
1116: andl $PGOFSET,%eax
1.7 thorpej 1117: movl $PAGE_SIZE,%ecx
1118: subl %eax,%ecx # ecx = PAGE_SIZE - (src % PAGE_SIZE)
1.1 fvdl 1119:
1120: GET_CURPCB(%eax)
1121: movl $6f,PCB_ONFAULT(%eax)
1122:
1123: 1: /*
1124: * Once per page, check that we are still within the bounds of user
1125: * space, and check for a write fault.
1126: */
1127: cmpl $VM_MAXUSER_ADDRESS,%edi
1128: jae _C_LABEL(copystr_efault)
1129:
1130: /* Compute PTE offset. */
1131: movl %edi,%eax
1132: shrl $PGSHIFT,%eax # calculate pte address
1133:
1134: testb $PG_RW,_C_LABEL(PTmap)(,%eax,4)
1135: jnz 2f
1136:
1137: 6: /* Simulate a trap. */
1138: pushl %edx
1139: pushl %edi
1140: call _C_LABEL(trapwrite) # trapwrite(addr)
1141: addl $4,%esp # clear argument from stack
1142: popl %edx
1143: testl %eax,%eax
1144: jnz _C_LABEL(copystr_efault)
1145:
1146: 2: /* Copy up to end of this page. */
1147: subl %ecx,%edx # predecrement total count
1148: jnc 3f
1149: addl %edx,%ecx # ecx += (edx - ecx) = edx
1150: xorl %edx,%edx
1151:
1152: 3: decl %ecx
1153: js 4f
1154: lodsb
1155: stosb
1156: testb %al,%al
1157: jnz 3b
1158:
1159: /* Success -- 0 byte reached. */
1160: addl %ecx,%edx # add back residual for this page
1161: xorl %eax,%eax
1162: jmp copystr_return
1163:
1164: 4: /* Go to next page, if any. */
1.7 thorpej 1165: movl $PAGE_SIZE,%ecx
1.1 fvdl 1166: testl %edx,%edx
1167: jnz 1b
1168:
1169: /* edx is zero -- return ENAMETOOLONG. */
1170: movl $ENAMETOOLONG,%eax
1171: jmp copystr_return
1172: #endif /* I386_CPU */
1173:
1174: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1175: 5: GET_CURPCB(%eax)
1176: movl $_C_LABEL(copystr_fault),PCB_ONFAULT(%eax)
1177: /*
1178: * Get min(%edx, VM_MAXUSER_ADDRESS-%edi).
1179: */
1180: movl $VM_MAXUSER_ADDRESS,%eax
1181: subl %edi,%eax
1182: cmpl %edx,%eax
1183: jae 1f
1184: movl %eax,%edx
1185: movl %eax,20(%esp)
1186:
1187: 1: incl %edx
1188: cld
1189:
1190: 1: decl %edx
1191: jz 2f
1192: lodsb
1193: stosb
1194: testb %al,%al
1195: jnz 1b
1196:
1197: /* Success -- 0 byte reached. */
1198: decl %edx
1199: xorl %eax,%eax
1200: jmp copystr_return
1201:
1202: 2: /* edx is zero -- return EFAULT or ENAMETOOLONG. */
1203: cmpl $VM_MAXUSER_ADDRESS,%edi
1204: jae _C_LABEL(copystr_efault)
1205: movl $ENAMETOOLONG,%eax
1206: jmp copystr_return
1207: #endif /* I486_CPU || I586_CPU || I686_CPU */
1208:
1209: /*
1210: * int copyinstr(const void *from, void *to, size_t maxlen, size_t *lencopied);
1211: * Copy a NUL-terminated string, at most maxlen characters long, from the
1212: * user's address space. Return the number of characters copied (including the
1213: * NUL) in *lencopied. If the string is too long, return ENAMETOOLONG; else
1214: * return 0 or EFAULT.
1215: * see copyinstr(9)
1216: */
1217: /* LINTSTUB: Func: int copyinstr(const void *uaddr, void *kaddr, size_t len, size_t *done) */
1218: ENTRY(copyinstr)
1219: pushl %esi
1220: pushl %edi
1.24 ! yamt 1221:
! 1222: DO_DEFERRED_SWITCH(%eax)
! 1223:
1.1 fvdl 1224: GET_CURPCB(%ecx)
1225: movl $_C_LABEL(copystr_fault),PCB_ONFAULT(%ecx)
1226:
1227: movl 12(%esp),%esi # %esi = from
1228: movl 16(%esp),%edi # %edi = to
1229: movl 20(%esp),%edx # %edx = maxlen
1230:
1231: /*
1232: * Get min(%edx, VM_MAXUSER_ADDRESS-%esi).
1233: */
1234: movl $VM_MAXUSER_ADDRESS,%eax
1235: subl %esi,%eax
1236: cmpl %edx,%eax
1237: jae 1f
1238: movl %eax,%edx
1239: movl %eax,20(%esp)
1240:
1241: 1: incl %edx
1242: cld
1243:
1244: 1: decl %edx
1245: jz 2f
1246: lodsb
1247: stosb
1248: testb %al,%al
1249: jnz 1b
1250:
1251: /* Success -- 0 byte reached. */
1252: decl %edx
1253: xorl %eax,%eax
1254: jmp copystr_return
1255:
1256: 2: /* edx is zero -- return EFAULT or ENAMETOOLONG. */
1257: cmpl $VM_MAXUSER_ADDRESS,%esi
1258: jae _C_LABEL(copystr_efault)
1259: movl $ENAMETOOLONG,%eax
1260: jmp copystr_return
1261:
1262: /* LINTSTUB: Ignore */
1263: NENTRY(copystr_efault)
1264: movl $EFAULT,%eax
1265:
1266: /* LINTSTUB: Ignore */
1267: NENTRY(copystr_fault)
1268: copystr_return:
1269: /* Set *lencopied and return %eax. */
1270: GET_CURPCB(%ecx)
1271: movl $0,PCB_ONFAULT(%ecx)
1272: movl 20(%esp),%ecx
1273: subl %edx,%ecx
1274: movl 24(%esp),%edx
1275: testl %edx,%edx
1276: jz 8f
1277: movl %ecx,(%edx)
1278:
1279: 8: popl %edi
1280: popl %esi
1281: ret
1282:
1283: /*
1284: * int copystr(const void *from, void *to, size_t maxlen, size_t *lencopied);
1285: * Copy a NUL-terminated string, at most maxlen characters long. Return the
1286: * number of characters copied (including the NUL) in *lencopied. If the
1287: * string is too long, return ENAMETOOLONG; else return 0.
1288: * see copystr(9)
1289: */
1290: /* LINTSTUB: Func: int copystr(const void *kfaddr, void *kdaddr, size_t len, size_t *done) */
1291: ENTRY(copystr)
1292: pushl %esi
1293: pushl %edi
1294:
1295: movl 12(%esp),%esi # esi = from
1296: movl 16(%esp),%edi # edi = to
1297: movl 20(%esp),%edx # edx = maxlen
1298: incl %edx
1299: cld
1300:
1301: 1: decl %edx
1302: jz 4f
1303: lodsb
1304: stosb
1305: testb %al,%al
1306: jnz 1b
1307:
1308: /* Success -- 0 byte reached. */
1309: decl %edx
1310: xorl %eax,%eax
1311: jmp 6f
1312:
1313: 4: /* edx is zero -- return ENAMETOOLONG. */
1314: movl $ENAMETOOLONG,%eax
1315:
1316: 6: /* Set *lencopied and return %eax. */
1317: movl 20(%esp),%ecx
1318: subl %edx,%ecx
1319: movl 24(%esp),%edx
1320: testl %edx,%edx
1321: jz 7f
1322: movl %ecx,(%edx)
1323:
1324: 7: popl %edi
1325: popl %esi
1326: ret
1327:
1328: /*
1329: * long fuword(const void *uaddr);
1330: * Fetch an int from the user's address space.
1331: * see fuword(9)
1332: */
1333: /* LINTSTUB: Func: long fuword(const void *base) */
1334: ENTRY(fuword)
1.24 ! yamt 1335: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1336: movl 4(%esp),%edx
1337: cmpl $VM_MAXUSER_ADDRESS-4,%edx
1338: ja _C_LABEL(fusuaddrfault)
1339: GET_CURPCB(%ecx)
1340: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1341: movl (%edx),%eax
1342: movl $0,PCB_ONFAULT(%ecx)
1343: ret
1344:
1345: /*
1346: * int fusword(const void *uaddr);
1347: * Fetch a short from the user's address space.
1348: * see fusword(9)
1349: */
1350: /* LINTSTUB: Func: int fusword(const void *base) */
1351: ENTRY(fusword)
1.24 ! yamt 1352: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1353: movl 4(%esp),%edx
1354: cmpl $VM_MAXUSER_ADDRESS-2,%edx
1355: ja _C_LABEL(fusuaddrfault)
1356: GET_CURPCB(%ecx)
1357: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1358: movzwl (%edx),%eax
1359: movl $0,PCB_ONFAULT(%ecx)
1360: ret
1361:
1362: /*
1363: * int fuswintr(const void *uaddr);
1364: * Fetch a short from the user's address space. Can be called during an
1365: * interrupt.
1366: * see fuswintr(9)
1367: */
1368: /* LINTSTUB: Func: int fuswintr(const void *base) */
1369: ENTRY(fuswintr)
1.24 ! yamt 1370: cmpl $TLBSTATE_VALID, CPUVAR(TLBSTATE)
! 1371: jnz _C_LABEL(fusuaddrfault)
1.1 fvdl 1372: movl 4(%esp),%edx
1373: cmpl $VM_MAXUSER_ADDRESS-2,%edx
1374: ja _C_LABEL(fusuaddrfault)
1.5 thorpej 1375: movl CPUVAR(CURLWP),%ecx
1376: movl L_ADDR(%ecx),%ecx
1.1 fvdl 1377: movl $_C_LABEL(fusubail),PCB_ONFAULT(%ecx)
1378: movzwl (%edx),%eax
1379: movl $0,PCB_ONFAULT(%ecx)
1380: ret
1381:
1382: /*
1383: * int fubyte(const void *uaddr);
1384: * Fetch a byte from the user's address space.
1385: * see fubyte(9)
1386: */
1387: /* LINTSTUB: Func: int fubyte(const void *base) */
1388: ENTRY(fubyte)
1.24 ! yamt 1389: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1390: movl 4(%esp),%edx
1391: cmpl $VM_MAXUSER_ADDRESS-1,%edx
1392: ja _C_LABEL(fusuaddrfault)
1393: GET_CURPCB(%ecx)
1394: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1395: movzbl (%edx),%eax
1396: movl $0,PCB_ONFAULT(%ecx)
1397: ret
1398:
1399: /*
1400: * Handle faults from [fs]u*(). Clean up and return -1.
1401: */
1402: /* LINTSTUB: Ignore */
1403: NENTRY(fusufault)
1404: movl $0,PCB_ONFAULT(%ecx)
1405: movl $-1,%eax
1406: ret
1407:
1408: /*
1409: * Handle faults from [fs]u*(). Clean up and return -1. This differs from
1410: * fusufault() in that trap() will recognize it and return immediately rather
1411: * than trying to page fault.
1412: */
1413: /* LINTSTUB: Ignore */
1414: NENTRY(fusubail)
1415: movl $0,PCB_ONFAULT(%ecx)
1416: movl $-1,%eax
1417: ret
1418:
1419: /*
1420: * Handle earlier faults from [fs]u*(), due to our of range addresses.
1421: */
1422: /* LINTSTUB: Ignore */
1423: NENTRY(fusuaddrfault)
1424: movl $-1,%eax
1425: ret
1426:
1427: /*
1428: * int suword(void *uaddr, long x);
1429: * Store an int in the user's address space.
1430: * see suword(9)
1431: */
1432: /* LINTSTUB: Func: int suword(void *base, long c) */
1433: ENTRY(suword)
1.24 ! yamt 1434: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1435: movl 4(%esp),%edx
1436: cmpl $VM_MAXUSER_ADDRESS-4,%edx
1437: ja _C_LABEL(fusuaddrfault)
1438:
1439: #if defined(I386_CPU)
1440: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1441: cmpl $CPUCLASS_386,_C_LABEL(cpu_class)
1442: jne 2f
1443: #endif /* I486_CPU || I586_CPU || I686_CPU */
1444:
1445: GET_CURPCB(%eax)
1446: movl $3f,PCB_ONFAULT(%eax)
1447:
1448: movl %edx,%eax
1449: shrl $PGSHIFT,%eax # calculate pte address
1450: testb $PG_RW,_C_LABEL(PTmap)(,%eax,4)
1451: jnz 1f
1452:
1453: 3: /* Simulate a trap. */
1454: pushl %edx
1455: pushl %edx
1456: call _C_LABEL(trapwrite) # trapwrite(addr)
1457: addl $4,%esp # clear parameter from the stack
1458: popl %edx
1459: GET_CURPCB(%ecx)
1460: testl %eax,%eax
1461: jnz _C_LABEL(fusufault)
1462:
1463: 1: /* XXX also need to check the following 3 bytes for validity! */
1464: #endif
1465:
1466: 2: GET_CURPCB(%ecx)
1467: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1468:
1469: movl 8(%esp),%eax
1470: movl %eax,(%edx)
1471: xorl %eax,%eax
1472: movl %eax,PCB_ONFAULT(%ecx)
1473: ret
1474:
1475: /*
1476: * int susword(void *uaddr, short x);
1477: * Store a short in the user's address space.
1478: * see susword(9)
1479: */
1480: /* LINTSTUB: Func: int susword(void *base, short c) */
1481: ENTRY(susword)
1.24 ! yamt 1482: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1483: movl 4(%esp),%edx
1484: cmpl $VM_MAXUSER_ADDRESS-2,%edx
1485: ja _C_LABEL(fusuaddrfault)
1486:
1487: #if defined(I386_CPU)
1488: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1489: cmpl $CPUCLASS_386,_C_LABEL(cpu_class)
1490: jne 2f
1491: #endif /* I486_CPU || I586_CPU || I686_CPU */
1492:
1493: GET_CURPCB(%eax)
1494: movl $3f,PCB_ONFAULT(%eax)
1495:
1496: movl %edx,%eax
1497: shrl $PGSHIFT,%eax # calculate pte address
1498: testb $PG_RW,_C_LABEL(PTmap)(,%eax,4)
1499: jnz 1f
1500:
1501: 3: /* Simulate a trap. */
1502: pushl %edx
1503: pushl %edx
1504: call _C_LABEL(trapwrite) # trapwrite(addr)
1505: addl $4,%esp # clear parameter from the stack
1506: popl %edx
1507: GET_CURPCB(%ecx)
1508: testl %eax,%eax
1509: jnz _C_LABEL(fusufault)
1510:
1511: 1: /* XXX also need to check the following byte for validity! */
1512: #endif
1513:
1514: 2: GET_CURPCB(%ecx)
1515: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1516:
1517: movl 8(%esp),%eax
1518: movw %ax,(%edx)
1519: xorl %eax,%eax
1520: movl %eax,PCB_ONFAULT(%ecx)
1521: ret
1522:
1523: /*
1524: * int suswintr(void *uaddr, short x);
1525: * Store a short in the user's address space. Can be called during an
1526: * interrupt.
1527: * see suswintr(9)
1528: */
1529: /* LINTSTUB: Func: int suswintr(void *base, short c) */
1530: ENTRY(suswintr)
1.24 ! yamt 1531: cmpl $TLBSTATE_VALID, CPUVAR(TLBSTATE)
! 1532: jnz _C_LABEL(fusuaddrfault)
1.1 fvdl 1533: movl 4(%esp),%edx
1534: cmpl $VM_MAXUSER_ADDRESS-2,%edx
1535: ja _C_LABEL(fusuaddrfault)
1.5 thorpej 1536: movl CPUVAR(CURLWP),%ecx
1537: movl L_ADDR(%ecx),%ecx
1.1 fvdl 1538: movl $_C_LABEL(fusubail),PCB_ONFAULT(%ecx)
1539:
1540: #if defined(I386_CPU)
1541: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1542: cmpl $CPUCLASS_386,_C_LABEL(cpu_class)
1543: jne 2f
1544: #endif /* I486_CPU || I586_CPU || I686_CPU */
1545:
1546: movl %edx,%eax
1547: shrl $PGSHIFT,%eax # calculate pte address
1548: testb $PG_RW,_C_LABEL(PTmap)(,%eax,4)
1549: jnz 1f
1550:
1551: /* Simulate a trap. */
1552: jmp _C_LABEL(fusubail)
1553:
1554: 1: /* XXX also need to check the following byte for validity! */
1555: #endif
1556:
1557: 2: movl 8(%esp),%eax
1558: movw %ax,(%edx)
1559: xorl %eax,%eax
1560: movl %eax,PCB_ONFAULT(%ecx)
1561: ret
1562:
1563: /*
1564: * int subyte(void *uaddr, char x);
1565: * Store a byte in the user's address space.
1566: * see subyte(9)
1567: */
1568: /* LINTSTUB: Func: int subyte(void *base, int c) */
1569: ENTRY(subyte)
1.24 ! yamt 1570: DO_DEFERRED_SWITCH(%eax)
1.1 fvdl 1571: movl 4(%esp),%edx
1572: cmpl $VM_MAXUSER_ADDRESS-1,%edx
1573: ja _C_LABEL(fusuaddrfault)
1574:
1575: #if defined(I386_CPU)
1576: #if defined(I486_CPU) || defined(I586_CPU) || defined(I686_CPU)
1577: cmpl $CPUCLASS_386,_C_LABEL(cpu_class)
1578: jne 2f
1579: #endif /* I486_CPU || I586_CPU || I686_CPU */
1580:
1581: GET_CURPCB(%eax)
1582: movl $3f,PCB_ONFAULT(%eax)
1583:
1584: movl %edx,%eax
1585: shrl $PGSHIFT,%eax # calculate pte address
1586: testb $PG_RW,_C_LABEL(PTmap)(,%eax,4)
1587: jnz 1f
1588:
1589: 3: /* Simulate a trap. */
1590: pushl %edx
1591: pushl %edx
1592: call _C_LABEL(trapwrite) # trapwrite(addr)
1593: addl $4,%esp # clear parameter from the stack
1594: popl %edx
1595: GET_CURPCB(%ecx)
1596: testl %eax,%eax
1597: jnz _C_LABEL(fusufault)
1598:
1599: 1:
1600: #endif
1601:
1602: 2: GET_CURPCB(%ecx)
1603: movl $_C_LABEL(fusufault),PCB_ONFAULT(%ecx)
1604:
1605: movb 8(%esp),%al
1606: movb %al,(%edx)
1607: xorl %eax,%eax
1608: movl %eax,PCB_ONFAULT(%ecx)
1609: ret
1610:
1611: /*****************************************************************************/
1612:
1613: /*
1614: * The following is i386-specific nonsense.
1615: */
1616:
1617: /*
1618: * void lgdt(struct region_descriptor *rdp);
1619: * Load a new GDT pointer (and do any necessary cleanup).
1620: * XXX It's somewhat questionable whether reloading all the segment registers
1621: * is necessary, since the actual descriptor data is not changed except by
1622: * process creation and exit, both of which clean up via task switches. OTOH,
1623: * this only happens at run time when the GDT is resized.
1624: */
1625: /* LINTSTUB: Func: void lgdt(struct region_descriptor *rdp) */
1626: NENTRY(lgdt)
1627: /* Reload the descriptor table. */
1628: movl 4(%esp),%eax
1629: lgdt (%eax)
1630: /* Flush the prefetch queue. */
1631: jmp 1f
1632: nop
1633: 1: /* Reload "stale" selectors. */
1634: movl $GSEL(GDATA_SEL, SEL_KPL),%eax
1635: movw %ax,%ds
1636: movw %ax,%es
1637: movw %ax,%gs
1638: movw %ax,%ss
1639: movl $GSEL(GCPU_SEL, SEL_KPL),%eax
1640: movw %ax,%fs
1641: /* Reload code selector by doing intersegment return. */
1642: popl %eax
1643: pushl $GSEL(GCODE_SEL, SEL_KPL)
1644: pushl %eax
1645: lret
1646:
1647: /*****************************************************************************/
1648:
1649: /*
1650: * These functions are primarily used by DDB.
1651: */
1652:
1653: /* LINTSTUB: Func: int setjmp (label_t *l) */
1654: ENTRY(setjmp)
1655: movl 4(%esp),%eax
1656: movl %ebx,(%eax) # save ebx
1657: movl %esp,4(%eax) # save esp
1658: movl %ebp,8(%eax) # save ebp
1659: movl %esi,12(%eax) # save esi
1660: movl %edi,16(%eax) # save edi
1661: movl (%esp),%edx # get rta
1662: movl %edx,20(%eax) # save eip
1663: xorl %eax,%eax # return (0);
1664: ret
1665:
1666: /* LINTSTUB: Func: void longjmp (label_t *l) */
1667: ENTRY(longjmp)
1668: movl 4(%esp),%eax
1669: movl (%eax),%ebx # restore ebx
1670: movl 4(%eax),%esp # restore esp
1671: movl 8(%eax),%ebp # restore ebp
1672: movl 12(%eax),%esi # restore esi
1673: movl 16(%eax),%edi # restore edi
1674: movl 20(%eax),%edx # get rta
1675: movl %edx,(%esp) # put in return frame
1676: xorl %eax,%eax # return (1);
1677: incl %eax
1678: ret
1679:
1680: /*****************************************************************************/
1681:
1682: .globl _C_LABEL(sched_whichqs),_C_LABEL(sched_qs)
1683: .globl _C_LABEL(uvmexp),_C_LABEL(panic)
1684:
1685: #ifdef DIAGNOSTIC
1686: NENTRY(switch_error)
1687: pushl $1f
1688: call _C_LABEL(panic)
1689: /* NOTREACHED */
1690: 1: .asciz "cpu_switch"
1691: #endif /* DIAGNOSTIC */
1692:
1693: /*
1.5 thorpej 1694: * void cpu_switch(struct lwp *)
1.1 fvdl 1695: * Find a runnable process and switch to it. Wait if necessary. If the new
1696: * process is the same as the old one, we short-circuit the context save and
1697: * restore.
1698: *
1699: * Note that the stack frame layout is known to "struct switchframe"
1700: * in <machine/frame.h> and to the code in cpu_fork() which initializes
1.5 thorpej 1701: * it for a new lwp.
1.1 fvdl 1702: */
1703: ENTRY(cpu_switch)
1704: pushl %ebx
1705: pushl %esi
1706: pushl %edi
1707:
1708: #ifdef DEBUG
1709: cmpl $IPL_SCHED,CPUVAR(ILEVEL)
1710: jae 1f
1.5 thorpej 1711: pushl $2f
1.1 fvdl 1712: call _C_LABEL(panic)
1713: /* NOTREACHED */
1.5 thorpej 1714: 2: .asciz "not splsched() in cpu_switch!"
1.1 fvdl 1715: 1:
1716: #endif /* DEBUG */
1717:
1.5 thorpej 1718: movl 16(%esp),%esi # current
1.1 fvdl 1719:
1720: /*
1.5 thorpej 1721: * Clear curlwp so that we don't accumulate system time while idle.
1722: * This also insures that schedcpu() will move the old lwp to
1.1 fvdl 1723: * the correct queue if it happens to get called from the spllower()
1724: * below and changes the priority. (See corresponding comment in
1725: * userret()).
1726: */
1.5 thorpej 1727: movl $0,CPUVAR(CURLWP)
1.1 fvdl 1728: /*
1.5 thorpej 1729: * First phase: find new lwp.
1.1 fvdl 1730: *
1731: * Registers:
1732: * %eax - queue head, scratch, then zero
1733: * %ebx - queue number
1734: * %ecx - cached value of whichqs
1.5 thorpej 1735: * %edx - next lwp in queue
1736: * %esi - old lwp
1737: * %edi - new lwp
1.1 fvdl 1738: */
1739:
1.5 thorpej 1740: /* Look for new lwp. */
1.1 fvdl 1741: cli # splhigh doesn't do a cli
1742: movl _C_LABEL(sched_whichqs),%ecx
1743: bsfl %ecx,%ebx # find a full q
1744: jnz switch_dequeue
1745:
1746: /*
1747: * idling: save old context.
1748: *
1749: * Registers:
1750: * %eax, %ecx - scratch
1.5 thorpej 1751: * %esi - old lwp, then old pcb
1.1 fvdl 1752: * %edi - idle pcb
1753: */
1754:
1755: pushl %esi
1.24 ! yamt 1756: call _C_LABEL(pmap_deactivate2) # pmap_deactivate(oldproc)
1.1 fvdl 1757: addl $4,%esp
1758:
1.5 thorpej 1759: movl L_ADDR(%esi),%esi
1.1 fvdl 1760:
1761: /* Save stack pointers. */
1762: movl %esp,PCB_ESP(%esi)
1763: movl %ebp,PCB_EBP(%esi)
1764:
1765: /* Find idle PCB for this CPU */
1766: #ifndef MULTIPROCESSOR
1.5 thorpej 1767: movl $_C_LABEL(lwp0),%ebx
1768: movl L_ADDR(%ebx),%edi
1769: movl L_MD_TSS_SEL(%ebx),%edx
1.1 fvdl 1770: #else
1771: movl CPUVAR(IDLE_PCB),%edi
1772: movl CPUVAR(IDLE_TSS_SEL),%edx
1773: #endif
1.5 thorpej 1774: movl $0,CPUVAR(CURLWP) /* In case we fault... */
1.1 fvdl 1775:
1776: /* Restore the idle context (avoid interrupts) */
1777: cli
1778:
1779: /* Restore stack pointers. */
1780: movl PCB_ESP(%edi),%esp
1781: movl PCB_EBP(%edi),%ebp
1782:
1783: /* Switch TSS. Reset "task busy" flag before loading. */
1784: #ifdef MULTIPROCESSOR
1785: movl CPUVAR(GDT),%eax
1786: #else
1787: movl _C_LABEL(gdt),%eax
1788: #endif
1789: andl $~0x0200,4-SEL_KPL(%eax,%edx,1)
1790: ltr %dx
1791:
1792: /* We're always in the kernel, so we don't need the LDT. */
1793:
1794: /* Restore cr0 (including FPU state). */
1795: movl PCB_CR0(%edi),%ecx
1796: movl %ecx,%cr0
1797:
1798: /* Record new pcb. */
1799: SET_CURPCB(%edi)
1800:
1801: xorl %esi,%esi
1802: sti
1803: idle_unlock:
1804: #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
1805: call _C_LABEL(sched_unlock_idle)
1806: #endif
1807: /* Interrupts are okay again. */
1.2 fvdl 1808: pushl $IPL_NONE # spl0()
1.1 fvdl 1809: call _C_LABEL(Xspllower) # process pending interrupts
1.2 fvdl 1810: addl $4,%esp
1.1 fvdl 1811: jmp idle_start
1812: idle_zero:
1813: sti
1814: call _C_LABEL(uvm_pageidlezero)
1815: cli
1816: cmpl $0,_C_LABEL(sched_whichqs)
1817: jnz idle_exit
1818: idle_loop:
1819: /* Try to zero some pages. */
1820: movl _C_LABEL(uvm)+UVM_PAGE_IDLE_ZERO,%ecx
1821: testl %ecx,%ecx
1822: jnz idle_zero
1823: sti
1824: hlt
1825: NENTRY(mpidle)
1826: idle_start:
1827: cli
1828: cmpl $0,_C_LABEL(sched_whichqs)
1829: jz idle_loop
1830: idle_exit:
1831: movl $IPL_HIGH,CPUVAR(ILEVEL) # splhigh
1.14 fvdl 1832: sti
1.1 fvdl 1833: #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
1834: call _C_LABEL(sched_lock_idle)
1835: #endif
1836: movl _C_LABEL(sched_whichqs),%ecx
1837: bsfl %ecx,%ebx
1838: jz idle_unlock
1839:
1840: switch_dequeue:
1841: /*
1842: * we're running at splhigh(), but it's otherwise okay to take
1843: * interrupts here.
1844: */
1845: sti
1846: leal _C_LABEL(sched_qs)(,%ebx,8),%eax # select q
1847:
1.5 thorpej 1848: movl L_FORW(%eax),%edi # unlink from front of process q
1.1 fvdl 1849: #ifdef DIAGNOSTIC
1850: cmpl %edi,%eax # linked to self (i.e. nothing queued)?
1851: je _C_LABEL(switch_error) # not possible
1852: #endif /* DIAGNOSTIC */
1.5 thorpej 1853: movl L_FORW(%edi),%edx
1854: movl %edx,L_FORW(%eax)
1855: movl %eax,L_BACK(%edx)
1.1 fvdl 1856:
1857: cmpl %edx,%eax # q empty?
1858: jne 3f
1859:
1860: btrl %ebx,%ecx # yes, clear to indicate empty
1861: movl %ecx,_C_LABEL(sched_whichqs) # update q status
1862:
1863: 3: /* We just did it. */
1864: xorl %eax,%eax
1865: CLEAR_RESCHED(%eax)
1866:
1.5 thorpej 1867: switch_resume:
1.1 fvdl 1868: #ifdef DIAGNOSTIC
1.5 thorpej 1869: cmpl %eax,L_WCHAN(%edi) # Waiting for something?
1.1 fvdl 1870: jne _C_LABEL(switch_error) # Yes; shouldn't be queued.
1.5 thorpej 1871: cmpb $LSRUN,L_STAT(%edi) # In run state?
1.1 fvdl 1872: jne _C_LABEL(switch_error) # No; shouldn't be queued.
1873: #endif /* DIAGNOSTIC */
1874:
1.5 thorpej 1875: /* Isolate lwp. XXX Is this necessary? */
1876: movl %eax,L_BACK(%edi)
1.1 fvdl 1877:
1.5 thorpej 1878: /* Record new lwp. */
1879: movb $LSONPROC,L_STAT(%edi) # l->l_stat = LSONPROC
1880: SET_CURLWP(%edi,%ecx)
1.1 fvdl 1881:
1.5 thorpej 1882: /* Skip context switch if same lwp. */
1.10 fvdl 1883: xorl %ebx,%ebx
1.1 fvdl 1884: cmpl %edi,%esi
1885: je switch_return
1886:
1.5 thorpej 1887: /* If old lwp exited, don't bother. */
1.1 fvdl 1888: testl %esi,%esi
1889: jz switch_exited
1890:
1891: /*
1892: * Second phase: save old context.
1893: *
1894: * Registers:
1895: * %eax, %ecx - scratch
1.5 thorpej 1896: * %esi - old lwp, then old pcb
1897: * %edi - new lwp
1.1 fvdl 1898: */
1899:
1900: pushl %esi
1.24 ! yamt 1901: call _C_LABEL(pmap_deactivate2) # pmap_deactivate(oldproc)
1.1 fvdl 1902: addl $4,%esp
1903:
1.5 thorpej 1904: movl L_ADDR(%esi),%esi
1.1 fvdl 1905:
1906: /* Save stack pointers. */
1907: movl %esp,PCB_ESP(%esi)
1908: movl %ebp,PCB_EBP(%esi)
1909:
1910: switch_exited:
1911: /*
1912: * Third phase: restore saved context.
1913: *
1914: * Registers:
1915: * %eax, %ebx, %ecx, %edx - scratch
1916: * %esi - new pcb
1.5 thorpej 1917: * %edi - new lwp
1.1 fvdl 1918: */
1919:
1920: /* No interrupts while loading new state. */
1921: cli
1.5 thorpej 1922: movl L_ADDR(%edi),%esi
1.1 fvdl 1923:
1924: /* Restore stack pointers. */
1925: movl PCB_ESP(%esi),%esp
1926: movl PCB_EBP(%esi),%ebp
1927:
1928: #if 0
1929: /* Don't bother with the rest if switching to a system process. */
1.5 thorpej 1930: testl $P_SYSTEM,L_FLAG(%edi); XXX NJWLWP lwp's don't have P_SYSTEM!
1.1 fvdl 1931: jnz switch_restored
1932: #endif
1933:
1934: #ifdef MULTIPROCESSOR
1935: movl CPUVAR(GDT),%eax
1936: #else
1937: /* Load TSS info. */
1938: movl _C_LABEL(gdt),%eax
1939: #endif
1.5 thorpej 1940: movl L_MD_TSS_SEL(%edi),%edx
1.1 fvdl 1941:
1942: /* Switch TSS. Reset "task busy" flag before loading. */
1943: andl $~0x0200,4(%eax,%edx, 1)
1944: ltr %dx
1945:
1946: pushl %edi
1947: call _C_LABEL(pmap_activate) # pmap_activate(p)
1948: addl $4,%esp
1949:
1950: #if 0
1951: switch_restored:
1952: #endif
1953: /* Restore cr0 (including FPU state). */
1954: movl PCB_CR0(%esi),%ecx
1955: #ifdef MULTIPROCESSOR
1956: /*
1.22 wiz 1957: * If our floating point registers are on a different CPU,
1.1 fvdl 1958: * clear CR0_TS so we'll trap rather than reuse bogus state.
1959: */
1960: movl PCB_FPCPU(%esi),%ebx
1961: cmpl CPUVAR(SELF),%ebx
1962: jz 1f
1963: orl $CR0_TS,%ecx
1964: 1:
1965: #endif
1966: movl %ecx,%cr0
1967:
1968: /* Record new pcb. */
1969: SET_CURPCB(%esi)
1970:
1971: /* Interrupts are okay again. */
1972: sti
1973:
1974: /*
1975: * Check for restartable atomic sequences (RAS)
1976: */
1.5 thorpej 1977: movl CPUVAR(CURLWP),%edi
1978: movl L_PROC(%edi),%esi
1.20 dsl 1979: cmpl $0,P_RASLIST(%esi)
1980: jne 2f
1.1 fvdl 1981: 1:
1.10 fvdl 1982: movl $1,%ebx
1.1 fvdl 1983:
1984: switch_return:
1985: #if defined(MULTIPROCESSOR) || defined(LOCKDEBUG)
1986: call _C_LABEL(sched_unlock_idle)
1987: #endif
1.2 fvdl 1988: pushl $IPL_NONE # spl0()
1.1 fvdl 1989: call _C_LABEL(Xspllower) # process pending interrupts
1.2 fvdl 1990: addl $4,%esp
1.1 fvdl 1991: movl $IPL_HIGH,CPUVAR(ILEVEL) # splhigh()
1.9 fvdl 1992:
1993: movl %ebx,%eax
1.1 fvdl 1994:
1995: popl %edi
1996: popl %esi
1997: popl %ebx
1998: ret
1.20 dsl 1999:
2000: 2: # check RAS list
2001: movl L_MD_REGS(%edi),%ebx
2002: movl TF_EIP(%ebx),%eax
2003: pushl %eax
2004: pushl %esi
2005: call _C_LABEL(ras_lookup)
2006: addl $8,%esp
2007: cmpl $-1,%eax
2008: je 1b
2009: movl %eax,TF_EIP(%ebx)
2010: jmp 1b
1.1 fvdl 2011:
2012: /*
1.5 thorpej 2013: * void cpu_switchto(struct lwp *current, struct lwp *next)
2014: * Switch to the specified next LWP.
2015: */
2016: ENTRY(cpu_switchto)
2017: pushl %ebx
2018: pushl %esi
2019: pushl %edi
2020:
2021: #ifdef DEBUG
2022: cmpl $IPL_SCHED,CPUVAR(ILEVEL)
2023: jae 1f
2024: pushl $2f
2025: call _C_LABEL(panic)
2026: /* NOTREACHED */
2027: 2: .asciz "not splsched() in cpu_switchto!"
2028: 1:
2029: #endif /* DEBUG */
2030:
2031: movl 16(%esp),%esi # current
2032: movl 20(%esp),%edi # next
2033:
2034: /*
2035: * Clear curlwp so that we don't accumulate system time while idle.
2036: * This also insures that schedcpu() will move the old process to
2037: * the correct queue if it happens to get called from the spllower()
2038: * below and changes the priority. (See corresponding comment in
2039: * usrret()).
2040: *
2041: * XXX Is this necessary? We know we won't go idle.
2042: */
2043: movl $0,CPUVAR(CURLWP)
2044:
2045: /*
2046: * We're running at splhigh(), but it's otherwise okay to take
2047: * interrupts here.
2048: */
2049: sti
2050:
2051: /* Jump into the middle of cpu_switch */
2052: xorl %eax,%eax
2053: jmp switch_resume
2054:
2055: /*
1.21 jdolecek 2056: * void cpu_exit(struct lwp *l)
1.22 wiz 2057: * Switch to the appropriate idle context (lwp0's if uniprocessor; the CPU's
1.1 fvdl 2058: * if multiprocessor) and deallocate the address space and kernel stack for p.
2059: * Then jump into cpu_switch(), as if we were in the idle proc all along.
2060: */
2061: #ifndef MULTIPROCESSOR
1.5 thorpej 2062: .globl _C_LABEL(lwp0)
1.1 fvdl 2063: #endif
2064: .globl _C_LABEL(uvmspace_free),_C_LABEL(kernel_map)
2065: .globl _C_LABEL(uvm_km_free),_C_LABEL(tss_free)
1.21 jdolecek 2066: /* LINTSTUB: Func: void cpu_exit(struct lwp *l) */
2067: ENTRY(cpu_exit)
1.1 fvdl 2068: movl 4(%esp),%edi # old process
2069: #ifndef MULTIPROCESSOR
1.5 thorpej 2070: movl $_C_LABEL(lwp0),%ebx
2071: movl L_ADDR(%ebx),%esi
2072: movl L_MD_TSS_SEL(%ebx),%edx
1.1 fvdl 2073: #else
2074: movl CPUVAR(IDLE_PCB),%esi
2075: movl CPUVAR(IDLE_TSS_SEL),%edx
2076: #endif
2077: /* In case we fault... */
1.5 thorpej 2078: movl $0,CPUVAR(CURLWP)
1.1 fvdl 2079:
2080: /* Restore the idle context. */
2081: cli
2082:
2083: /* Restore stack pointers. */
2084: movl PCB_ESP(%esi),%esp
2085: movl PCB_EBP(%esi),%ebp
2086:
2087: /* Load TSS info. */
2088: #ifdef MULTIPROCESSOR
2089: movl CPUVAR(GDT),%eax
2090: #else
2091: /* Load TSS info. */
2092: movl _C_LABEL(gdt),%eax
2093: #endif
2094:
2095: /* Switch TSS. */
2096: andl $~0x0200,4-SEL_KPL(%eax,%edx,1)
2097: ltr %dx
2098:
2099: /* We're always in the kernel, so we don't need the LDT. */
2100:
2101: /* Restore cr0 (including FPU state). */
2102: movl PCB_CR0(%esi),%ecx
2103: movl %ecx,%cr0
2104:
2105: /* Record new pcb. */
2106: SET_CURPCB(%esi)
2107:
2108: /* Interrupts are okay again. */
2109: sti
2110:
2111: /*
1.21 jdolecek 2112: * Schedule the dead LWP's stack to be freed.
1.1 fvdl 2113: */
1.21 jdolecek 2114: pushl %edi
2115: call _C_LABEL(lwp_exit2)
1.1 fvdl 2116: addl $4,%esp
2117:
2118: /* Jump into cpu_switch() with the right state. */
2119: xorl %esi,%esi
1.5 thorpej 2120: movl %esi,CPUVAR(CURLWP)
1.1 fvdl 2121: jmp idle_start
2122:
2123: /*
2124: * void savectx(struct pcb *pcb);
2125: * Update pcb, saving current processor state.
2126: */
2127: /* LINTSTUB: Func: void savectx(struct pcb *pcb) */
2128: ENTRY(savectx)
2129: movl 4(%esp),%edx # edx = p->p_addr
2130:
2131: /* Save stack pointers. */
2132: movl %esp,PCB_ESP(%edx)
2133: movl %ebp,PCB_EBP(%edx)
2134:
2135: ret
2136:
2137: /*
2138: * Old call gate entry for syscall
2139: */
2140: /* LINTSTUB: Var: char Xosyscall[1]; */
2141: IDTVEC(osyscall)
2142: /* Set eflags in trap frame. */
2143: pushfl
2144: popl 8(%esp)
2145: pushl $7 # size of instruction for restart
2146: jmp syscall1
2147:
2148: /*
2149: * Trap gate entry for syscall
2150: */
2151: /* LINTSTUB: Var: char Xsyscall[1]; */
2152: IDTVEC(syscall)
2153: pushl $2 # size of instruction for restart
2154: syscall1:
2155: pushl $T_ASTFLT # trap # for doing ASTs
2156: INTRENTRY
2157:
2158: #ifdef DIAGNOSTIC
1.24 ! yamt 2159: cmpl $0, CPUVAR(WANT_PMAPLOAD)
! 2160: jz 1f
! 2161: pushl $6f
! 2162: call _C_LABEL(printf)
! 2163: addl $4, %esp
! 2164: 1:
1.1 fvdl 2165: movl CPUVAR(ILEVEL),%ebx
2166: testl %ebx,%ebx
2167: jz 1f
2168: pushl $5f
2169: call _C_LABEL(printf)
2170: addl $4,%esp
2171: #ifdef DDB
2172: int $3
2173: #endif
2174: 1:
2175: #endif /* DIAGNOSTIC */
1.5 thorpej 2176: movl CPUVAR(CURLWP),%edx
2177: movl %esp,L_MD_REGS(%edx) # save pointer to frame
2178: movl L_PROC(%edx),%edx
1.15 fvdl 2179: pushl %esp
1.1 fvdl 2180: call *P_MD_SYSCALL(%edx) # get pointer to syscall() function
1.15 fvdl 2181: addl $4,%esp
1.24 ! yamt 2182: syscall_checkast:
! 2183: /* Check for ASTs on exit to user mode. */
1.1 fvdl 2184: cli
1.5 thorpej 2185: CHECK_ASTPENDING(%eax)
1.1 fvdl 2186: je 1f
2187: /* Always returning to user mode here. */
1.5 thorpej 2188: CLEAR_ASTPENDING(%eax)
1.1 fvdl 2189: sti
2190: /* Pushed T_ASTFLT into tf_trapno on entry. */
1.15 fvdl 2191: pushl %esp
1.1 fvdl 2192: call _C_LABEL(trap)
1.15 fvdl 2193: addl $4,%esp
1.24 ! yamt 2194: jmp syscall_checkast /* re-check ASTs */
! 2195: 1: CHECK_DEFERRED_SWITCH(%eax)
! 2196: jnz 9f
1.1 fvdl 2197: #ifndef DIAGNOSTIC
1.24 ! yamt 2198: INTRFASTEXIT
1.1 fvdl 2199: #else /* DIAGNOSTIC */
1.24 ! yamt 2200: cmpl $IPL_NONE,CPUVAR(ILEVEL)
1.1 fvdl 2201: jne 3f
2202: INTRFASTEXIT
2203: 3: sti
2204: pushl $4f
2205: call _C_LABEL(printf)
2206: addl $4,%esp
2207: #ifdef DDB
2208: int $3
2209: #endif /* DDB */
2210: movl $IPL_NONE,CPUVAR(ILEVEL)
2211: jmp 2b
2212: 4: .asciz "WARNING: SPL NOT LOWERED ON SYSCALL EXIT\n"
2213: 5: .asciz "WARNING: SPL NOT ZERO ON SYSCALL ENTRY\n"
1.24 ! yamt 2214: 6: .asciz "WARNING: WANT PMAPLOAD ON SYSCALL ENTRY\n"
1.1 fvdl 2215: #endif /* DIAGNOSTIC */
1.24 ! yamt 2216: 9: sti
! 2217: call _C_LABEL(pmap_load)
! 2218: jmp syscall_checkast /* re-check ASTs */
1.1 fvdl 2219:
2220: #if NNPX > 0
2221: /*
2222: * Special interrupt handlers. Someday intr0-intr15 will be used to count
2223: * interrupts. We'll still need a special exception 16 handler. The busy
2224: * latch stuff in probintr() can be moved to npxprobe().
2225: */
2226:
2227: /* LINTSTUB: Func: void probeintr(void) */
2228: NENTRY(probeintr)
2229: ss
2230: incl _C_LABEL(npx_intrs_while_probing)
2231: pushl %eax
2232: movb $0x20,%al # EOI (asm in strings loses cpp features)
2233: outb %al,$0xa0 # IO_ICU2
2234: outb %al,$0x20 # IO_ICU1
2235: movb $0,%al
2236: outb %al,$0xf0 # clear BUSY# latch
2237: popl %eax
2238: iret
2239:
2240: /* LINTSTUB: Func: void probetrap(void) */
2241: NENTRY(probetrap)
2242: ss
2243: incl _C_LABEL(npx_traps_while_probing)
2244: fnclex
2245: iret
2246:
2247: /* LINTSTUB: Func: int npx586bug1(int a, int b) */
2248: NENTRY(npx586bug1)
2249: fildl 4(%esp) # x
2250: fildl 8(%esp) # y
2251: fld %st(1)
2252: fdiv %st(1),%st # x/y
2253: fmulp %st,%st(1) # (x/y)*y
2254: fsubrp %st,%st(1) # x-(x/y)*y
2255: pushl $0
2256: fistpl (%esp)
2257: popl %eax
2258: ret
2259: #endif /* NNPX > 0 */
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to locore.S CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / arch / i386 / i386