![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to locore.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoe|
Return to locore.s CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoe |
1.1 root 1: /*
2: * Copyright (c) 1988 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)locore.s 7.14 (Berkeley) 5/10/90
7: */
8:
9: #include "../tahoe/mtpr.h"
10: #include "../tahoe/trap.h"
11: #include "../tahoe/psl.h"
12: #include "../tahoe/pte.h"
13: #include "../tahoe/cp.h"
14: #include "../tahoe/mem.h"
15: #include "../tahoe/SYS.h"
16:
17: #include "../tahoemath/fp.h"
18:
19: #include "errno.h"
20: #include "syscall.h"
21: #include "cmap.h"
22:
23: .set HIGH,0x1f # mask for total disable
24: .set NISP,3 # number of interrupt stack pages
25: .set SYSTEM,0xC0000000 # virtual address of system start
26: .set PPAGES,0x100000 # possible pages in P0,P1, etc.
27:
28: /* ACBL for non-negative '_add' */
29: #define ACBL(_limit,_add,_index,_displ) \
30: addl2 _add,_index; \
31: cmpl _index,_limit; \
32: bleq _displ
33:
34: /* _ACBL for negative '_add' */
35: #define _ACBL(_limit,_add,_index,_displ) \
36: addl2 _add,_index; \
37: cmpl _index,_limit; \
38: bgeq _displ
39:
40: #define MOVC3(_srcaddr,_dstaddr,_len) \
41: movl _srcaddr,r0; \
42: movl _dstaddr,r1; \
43: movl _len,r2; \
44: movblk
45:
46: /* keep address of psl if coming from user mode */
47: #define CHECK_SFE(_delta) \
48: bitl $PSL_CURMOD,_delta(sp); \
49: jeql 1f; \
50: moval _delta(sp),_user_psl; \
51: 1:
52:
53: /*
54: * User structure is UPAGES at top of user space.
55: */
56: .globl _u
57: .set _u,SYSTEM - UPAGES*NBPG
58:
59: /*
60: * Restart stack. Used on power recovery or panic.
61: * Takes a core-dump and then halts.
62: */
63: .globl _rsstk
64: .globl pwfl_stk
65: _rsstk:
66: .space 1024-8
67: pwfl_stk:
68: .space 4
69: dumpflag:
70: .space 4
71:
72: .globl _intstack
73: _intstack:
74: .space NISP*NBPG
75: eintstack:
76:
77: /*
78: * Power failure storage block and
79: * macros for saving and restoring.
80: */
81: #define POWERFAIL(id,longs) \
82: .globl pwfl_/**/id \
83: pwfl_/**/id: .space longs*4
84: .data
85: POWERFAIL(r0, 14) # r0-r13
86: POWERFAIL(sp, 1) # r14
87: POWERFAIL(SCBB, 1) # system control block base
88: POWERFAIL(SBR, 1) # system pte base
89: POWERFAIL(SLR, 1) # system pte length
90: POWERFAIL(P0BR, 1) # p0 pte base
91: POWERFAIL(P0LR, 1) # p0 pte length
92: POWERFAIL(P1BR, 1) # p1 pte base
93: POWERFAIL(P1LR, 1) # p1 pte length
94: POWERFAIL(P2BR, 1) # p2 pte base
95: POWERFAIL(P2LR, 1) # p2 pte length
96: POWERFAIL(IPL, 1) # interrupt priority level
97: POWERFAIL(DCK, 1) # data cache key
98: POWERFAIL(CCK, 1) # code cache key
99: POWERFAIL(PCBB, 1) # process control block base
100: POWERFAIL(ISP, 1) # interrupt stack pointer
101: POWERFAIL(KSP, 1) # kernel mode stack pointer
102: POWERFAIL(USP, 1) # user mode stack pointer
103: POWERFAIL(MME, 1) # memory management enable
104: POWERFAIL(PSL, 1) # processor status longword
105:
106: /*
107: * Save current state in power fail storage block.
108: */
109: #define SAVEpwfl() \
110: movpsl pwfl_PSL # Keeps all flags, etc. \
111: storer $0x3fff,pwfl_r0 # Saves r0-r13 \
112: moval 0(sp),pwfl_sp # Saves sp (=r14) \
113: mfpr $SBR,pwfl_SBR # Save all re_loadable registers \
114: mfpr $SLR,pwfl_SLR \
115: mfpr $P0BR,pwfl_P0BR \
116: mfpr $P0LR,pwfl_P0LR \
117: mfpr $P1BR,pwfl_P1BR \
118: mfpr $P1LR,pwfl_P1LR \
119: mfpr $P2BR,pwfl_P2BR \
120: mfpr $P2LR,pwfl_P2LR \
121: mfpr $IPL,pwfl_IPL \
122: mfpr $MME,pwfl_MME \
123: mfpr $DCK,pwfl_DCK \
124: mfpr $CCK,pwfl_CCK \
125: mfpr $PCBB,pwfl_PCBB \
126: mfpr $ISP,pwfl_ISP \
127: mfpr $SCBB,pwfl_SCBB \
128: mfpr $KSP,pwfl_KSP \
129: mfpr $USP,pwfl_USP
130:
131: /*
132: * Restore state saved in power fail block and
133: * jmp to location specified after (possibly)
134: * enabling memory management.
135: */
136: #define RESTOREpwfl(loc) \
137: loadr $0x3fff,pwfl_r0 # Restore r0-r13 \
138: movl pwfl_sp,sp # Restore sp (=r14) \
139: mtpr pwfl_SCBB,$SCBB \
140: mtpr pwfl_SBR,$SBR # Restore all re_loadable registers \
141: mtpr pwfl_SLR,$SLR \
142: mtpr pwfl_P0BR,$P0BR \
143: mtpr pwfl_P0LR,$P0LR \
144: mtpr pwfl_P1BR,$P1BR \
145: mtpr pwfl_P1LR,$P1LR \
146: mtpr pwfl_P2BR,$P2BR \
147: mtpr pwfl_P2LR,$P2LR \
148: mtpr pwfl_IPL,$IPL \
149: mtpr pwfl_DCK,$DCK \
150: mtpr pwfl_CCK,$CCK \
151: mtpr pwfl_PCBB,$PCBB \
152: mtpr pwfl_ISP,$ISP \
153: mtpr pwfl_KSP,$KSP \
154: mtpr pwfl_USP,$USP \
155: \
156: bicpsw $0xff # Restore PSW. \
157: bispsw pwfl_PSL+2 # Set original bits back (just in case..) \
158: # now go to mapped mode \
159: # Have to change PC to system addresses \
160: mtpr $1,$PACC # Thoroughly clean up caches. \
161: mtpr $1,$PADC \
162: mtpr $1,$TBIA \
163: mtpr pwfl_MME,$MME # Restore MME. Last thing to be done. \
164: jmp loc
165:
166: /*
167: * Do a dump.
168: * Called by auto-restart.
169: * May be called manually.
170: */
171: .align 2
172: .text
173: .globl _Xdoadump
174: .globl _doadump
175: _Xdoadump: # CP comes here after power fail
176: RESTOREpwfl(*0f) # restore state
177: _doadump:
178: .word 0
179: 0: mtpr $HIGH,$IPL
180: #define _rsstkmap _Sysmap+12 # powerfail storage, scb, rsstk, int stack
181: tstl dumpflag # dump only once!
182: bneq 1f
183: andl2 $~PG_PROT,_rsstkmap
184: orl2 $PG_KW,_rsstkmap # Make dump stack r/w
185: mtpr $0,$TBIA
186: movl $1,dumpflag
187: movab dumpflag,sp
188: callf $4,_dumpsys
189: 1:
190: halt
191:
192: /*
193: * Interrupt vector routines
194: */
195: .globl _waittime
196: #define SCBVEC(name) \
197: .align 2; \
198: .globl _X/**/name; \
199: _X/**/name
200: #define PANIC(msg) \
201: clrl _waittime; pushab 1f; callf $8,_panic; 1: .asciz msg
202: #define PRINTF(n,msg) \
203: pushab 1f; callf $(n+2)*4,_printf; MSG(msg)
204: #define MSG(msg) .data; 1: .asciz msg; .text
205: /*
206: * r0-r5 are saved across all faults and interrupts.
207: * Routines below and those hidden in vbglue.s (device
208: * interrupts) invoke the PUSHR/POPR macros to execute
209: * this. Also, certain stack frame offset calculations
210: * use this, using the REGSPC definition (and FPSPC defined below).
211: */
212: #define REGSPC 6*4
213: #define PUSHR movab -REGSPC(sp),sp; storer $0x3f,(sp)
214: #define POPR loadr $0x3f,(sp); movab REGSPC(sp),sp
215:
216: /*
217: * Floating point state is saved across faults and
218: * interrupts. The state occupies 4 longwords on
219: * the stack:
220: * precision indicator (single = 0/double = 1)
221: * double representation of accumulator
222: * save accumulator status flag (pcb_savacc)
223: */
224: #define FPSPC (4*4)
225:
226: #define SAVE_FPSTAT(_delta) \
227: bitl $PSL_DBL,_delta(sp); \
228: beql 1f; \
229: pushl $1; \
230: pushd; \
231: jmp 2f; \
232: 1: pushl $0; \
233: pushl $0; \
234: stf -(sp); \
235: 2: tstl _u+PCB_SAVACC; \
236: bneq 3f; \
237: moval 0(sp),_u+PCB_SAVACC; \
238: orl2 $2,8(sp);\
239: 3: pushl $0;
240:
241: #define REST_FPSTAT \
242: tstl (sp)+; \
243: bitl $2,8(sp);\
244: beql 1f;\
245: movl $0,_u+PCB_SAVACC; \
246: 1: bitl $1,8(sp); \
247: beql 2f; \
248: ldd (sp); \
249: jmp 3f; \
250: 2: ldf (sp); \
251: 3: moval 12(sp),sp;
252:
253: #define REST_ACC \
254: tstl _u+PCB_SAVACC; \
255: beql 2f; \
256: movl _u+PCB_SAVACC,r1; \
257: andl3 $(EXPMASK|SIGNBIT),(r1),-(sp); \
258: cmpl $0x80000000,(sp)+; \
259: bneq 3f; \
260: clrl (r1); \
261: 3: bitl $1,8(r1); \
262: beql 1f; \
263: ldd (r1); \
264: jmp 2f; \
265: 1: ldf (r1); \
266: 2: ;
267:
268: .data
269: nofault: .space 4 # bus error non-local goto label
270:
271: .text
272: SCBVEC(buserr):
273: CHECK_SFE(12)
274: SAVE_FPSTAT(12)
275: incl _intrcnt+I_BUSERR # keep stats...
276: pushl r0 # must save
277: andl3 24(sp),$ERRCD,r0 # grab pushed MER value
278: cmpl r0,$APE # address parity error?
279: jneq 1f
280: halt
281: 1: cmpl r0,$VBE # versabus error?
282: jneq 2f
283: halt
284: 2:
285: movl (sp)+,r0 # restore r0 and...
286: bitl $PSL_CURMOD,4*4+3*4(sp) # check if happened in user mode?
287: jeql 3f # yes, then shift stack up for trap...
288: movl 12(sp),16(sp) # sorry, no space for which-buss...
289: movl 8(sp),12(sp)
290: movl 4(sp),8(sp)
291: movl 0(sp),4(sp)
292: movl $T_BUSERR,0(sp) # push trap type code and...
293: jbr alltraps # ...merge with all other traps
294: 3: # kernel mode, check to see if...
295: tstl nofault # ...doing peek/poke?
296: jeql 4f # nofault set? if so, jump to it...
297: movl nofault,4*4+2*4(sp) # ...setup for non-local goto
298: clrl nofault
299: jbr 5f
300: 4:
301: PUSHR
302: pushab 4*4+REGSPC(sp) # address of bus error parameters
303: callf $8,_buserror
304: POPR
305: 5:
306: REST_FPSTAT
307: movab 8(sp),sp # remove bus error parameters
308: rei
309:
310: SCBVEC(powfail): # We should be on interrupt stack now.
311: SAVEpwfl() # save machine state
312: moval _Xdoadump-SYSTEM,_scb+SCB_DOADUMP
313: halt
314:
315: SCBVEC(stray):
316: incl _cnt+V_INTR # add to statistics
317: rei
318:
319: #include "../net/netisr.h"
320: .globl _netisr
321: SCBVEC(netintr):
322: CHECK_SFE(4)
323: SAVE_FPSTAT(4); PUSHR
324: #include "imp.h"
325: #if NIMP > 0
326: bbc $NETISR_IMP,_netisr,1f;
327: andl2 $~(1<<NETISR_IMP),_netisr
328: callf $4,_impintr;
329: 1:
330: #endif
331: #ifdef INET
332: bbc $NETISR_IP,_netisr,1f
333: andl2 $~(1<<NETISR_IP),_netisr
334: callf $4,_ipintr
335: 1:
336: #endif
337: #ifdef NS
338: bbc $NETISR_NS,_netisr,1f
339: andl2 $~(1<<NETISR_NS),_netisr
340: callf $4,_nsintr
341: 1:
342: #endif
343: #ifdef ISO
344: bbc $NETISR_ISO,_netisr,1f
345: andl2 $~(1<<NETISR_ISO),_netisr
346: callf $4,_clnlintr
347: 1:
348: #endif
349: incl _cnt+V_SOFT
350: POPR; REST_FPSTAT
351: rei
352:
353: SCBVEC(cnrint):
354: CHECK_SFE(4)
355: SAVE_FPSTAT(4); PUSHR;
356: pushl $CPCONS; callf $8,_cnrint;
357: incl _intrcnt+I_CNR
358: incl _cnt+V_INTR
359: POPR; REST_FPSTAT;
360: rei
361: SCBVEC(cnxint):
362: CHECK_SFE(4)
363: SAVE_FPSTAT(4); PUSHR;
364: pushl $CPCONS; callf $8,_cnxint;
365: incl _intrcnt+I_CNX
366: incl _cnt+V_INTR
367: POPR; REST_FPSTAT;
368: rei
369: SCBVEC(rmtrint):
370: CHECK_SFE(4)
371: SAVE_FPSTAT(4); PUSHR;
372: pushl $CPREMOT; callf $8,_cnrint;
373: incl _intrcnt+I_RMTR
374: incl _cnt+V_INTR
375: POPR; REST_FPSTAT;
376: rei
377: SCBVEC(rmtxint):
378: CHECK_SFE(4)
379: SAVE_FPSTAT(4); PUSHR;
380: pushl $CPREMOT; callf $8,_cnxint;
381: incl _intrcnt+I_RMTX
382: incl _cnt+V_INTR
383: POPR; REST_FPSTAT;
384: rei
385:
386: #define PUSHPCPSL pushl 4+FPSPC+REGSPC(sp); pushl 4+FPSPC+REGSPC(sp);
387:
388: SCBVEC(hardclock):
389: tstl _clk_enable
390: bneq 1f
391: rei
392: 1:
393: CHECK_SFE(4)
394: SAVE_FPSTAT(4); PUSHR
395: PUSHPCPSL # push pc and psl
396: callf $12,_hardclock # hardclock(pc,psl)
397: incl _intrcnt+I_CLOCK
398: incl _cnt+V_INTR ## temp so not to break vmstat -= HZ
399: POPR; REST_FPSTAT
400: rei
401: SCBVEC(softclock):
402: CHECK_SFE(4)
403: SAVE_FPSTAT(4); PUSHR;
404: PUSHPCPSL # push pc and psl
405: callf $12,_softclock # softclock(pc,psl)
406: incl _cnt+V_SOFT
407: POPR; REST_FPSTAT
408: rei
409:
410: /*
411: * Stray VERSAbus interrupt catch routines
412: */
413: .data
414: #define PJ .align 2; callf $4,_Xvstray
415: .globl _catcher
416: _catcher:
417: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
418: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
419: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
420: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
421: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
422: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
423: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
424: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
425: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
426: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
427: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
428: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ
429:
430: .align 2
431: .globl _cold
432: _cold: .long 0x3
433:
434: .text
435: SCBVEC(vstray):
436: .word 0
437: bbc $0,_cold,2f # system running?
438: bbc $1,_cold,1f # doing autoconfig?
439: jbr 3f # random interrupt, ignore
440: 1:
441: mfpr $IPL,r12 # ...setup br and cvec
442: subl3 $_catcher+7,-8(fp),r11; shar $3,r11,r11
443: addl2 $SCB_DEVBASE,r11
444: jbr 3f
445: 2:
446: PUSHR
447: subl3 $_catcher+7,-8(fp),r0; shar $3,r0,r0
448: addl3 $SCB_DEVBASE,r0,-(sp);
449: mfpr $IPL,-(sp)
450: PRINTF(2, "stray intr ipl %x vec %x\n")
451: POPR
452: 3: moval 0f,-8(fp); ret # pop callf frame...
453: 0: rei # ...and return
454:
455: /*
456: * Trap and fault vector routines
457: */
458: #define TRAP(a) pushl $T_/**/a; jbr alltraps
459:
460: /*
461: * Ast delivery (profiling and/or reschedule)
462: */
463:
464: SCBVEC(kspnotval):
465: CHECK_SFE(4)
466: pushl $0;
467: SAVE_FPSTAT(8)
468: TRAP(KSPNOTVAL)
469: SCBVEC(privinflt):
470: CHECK_SFE(4)
471: pushl $0;
472: SAVE_FPSTAT(8)
473: TRAP(PRIVINFLT)
474: SCBVEC(resopflt):
475: CHECK_SFE(4)
476: pushl $0;
477: SAVE_FPSTAT(8)
478: TRAP(RESOPFLT)
479: SCBVEC(resadflt):
480: CHECK_SFE(4)
481: pushl $0;
482: SAVE_FPSTAT(8)
483: TRAP(RESADFLT)
484: SCBVEC(bptflt):
485: CHECK_SFE(4)
486: pushl $0;
487: SAVE_FPSTAT(8)
488: TRAP(BPTFLT)
489: SCBVEC(kdbintr):
490: CHECK_SFE(4);
491: pushl $0;
492: SAVE_FPSTAT(8);
493: TRAP(KDBTRAP);
494: SCBVEC(tracep):
495: CHECK_SFE(4)
496: pushl $0;
497: SAVE_FPSTAT(8)
498: TRAP(TRCTRAP)
499: SCBVEC(alignflt):
500: #ifdef ALIGN
501: bitl $PSL_CURMOD,4(sp)
502: jeql align_excp # Can't emulate for kernel mode !
503: jbr non_aligned # Only emulated for user mode.
504: align_excp:
505: #else
506: CHECK_SFE(4)
507: #endif
508: pushl $0;
509: SAVE_FPSTAT(8)
510: TRAP(ALIGNFLT)
511: SCBVEC(arithtrap):
512: CHECK_SFE(8)
513: SAVE_FPSTAT(8)
514: TRAP(ARITHTRAP)
515:
516: SCBVEC(protflt):
517: CHECK_SFE(12)
518: bitl $1,(sp)+
519: jneq segflt
520: SAVE_FPSTAT(8)
521: TRAP(PROTFLT)
522: segflt:
523: SAVE_FPSTAT(8)
524: TRAP(SEGFLT)
525:
526: SCBVEC(fpm): # Floating Point Emulation
527: #ifdef FPE
528: CHECK_SFE(16)
529: SAVE_FPSTAT(16)
530: incl _cnt+V_FPE # count emulation traps
531: callf $4,_fpemulate
532: REST_FPSTAT
533: #endif
534: moval 8(sp),sp # Pop operand
535: tstl (sp) # Stack= PSL, PC, return_code
536: jneq _Xarithtrap # If not OK, emulate F.P. exception
537: movab 4(sp),sp # Else remove return_code and
538: rei
539:
540: SCBVEC(sfexcep):
541: CHECK_SFE(4)
542: pushl $0
543: SAVE_FPSTAT(8)
544: TRAP(ASTFLT)
545:
546: SCBVEC(transflt):
547: CHECK_SFE(12)
548: bitl $2,(sp)+
549: bneq tableflt
550: pageflt:
551: SAVE_FPSTAT(8)
552: TRAP(PAGEFLT)
553: tableflt:
554: SAVE_FPSTAT(8)
555: TRAP(TABLEFLT)
556:
557: #define REST_STACK movab 4(sp), sp; REST_FPSTAT; movab 4(sp), sp
558:
559: alltraps:
560: mfpr $USP,-(sp);
561: callf $4,_trap;
562: mtpr (sp)+,$USP
563: incl _cnt+V_TRAP
564: REST_STACK # pop type, code, and fp stuff
565: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT)
566: rei
567:
568: SCBVEC(syscall):
569: CHECK_SFE(8)
570: SAVE_FPSTAT(8)
571: pushl $T_SYSCALL
572: mfpr $USP,-(sp);
573: callf $4,_syscall;
574: mtpr (sp)+,$USP
575: incl _cnt+V_SYSCALL
576: REST_STACK # pop type, code, and fp stuff
577: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT)
578: rei
579:
580: /*
581: * System page table.
582: *
583: * Mbmap and Usrptmap are enlarged by CLSIZE entries
584: * as they are managed by resource maps starting with index 1 or CLSIZE.
585: */
586: #define vaddr(x) ((((x)-_Sysmap)/4)*NBPG+SYSTEM)
587: #define SYSMAP(mname, vname, npte) \
588: _/**/mname: .globl _/**/mname; \
589: .space (npte)*4; \
590: .globl _/**/vname; \
591: .set _/**/vname,vaddr(_/**/mname)
592: #define ADDMAP(npte) .space (npte)*4
593:
594: .data
595: .align 2
596: SYSMAP(Sysmap ,Sysbase ,SYSPTSIZE )
597: SYSMAP(Forkmap ,forkutl ,UPAGES )
598: SYSMAP(Xswapmap ,xswaputl ,UPAGES )
599: SYSMAP(Xswap2map,xswap2utl ,UPAGES )
600: SYSMAP(Swapmap ,swaputl ,UPAGES )
601: SYSMAP(Pushmap ,pushutl ,UPAGES )
602: SYSMAP(Vfmap ,vfutl ,UPAGES )
603: SYSMAP(CMAP1 ,CADDR1 ,1 )
604: SYSMAP(CMAP2 ,CADDR2 ,1 )
605: SYSMAP(mmap ,vmmap ,1 )
606: SYSMAP(alignmap ,alignutl ,1 ) /* XXX */
607: SYSMAP(msgbufmap,msgbuf ,MSGBUFPTECNT )
608: SYSMAP(Mbmap ,mbutl ,NMBCLUSTERS*MCLBYTES/NBPG+CLSIZE )
609: #ifdef MFS
610: #include "../ufs/mfsiom.h"
611: /*
612: * Used by the mfs_doio() routine for physical I/O
613: */
614: SYSMAP(Mfsiomap ,mfsiobuf ,MFS_MAPREG )
615: #endif /* MFS */
616: #ifdef NFS
617: #include "../nfs/nfsiom.h"
618: /*
619: * Used by the nfs_doio() routine for physical I/O
620: */
621: SYSMAP(Nfsiomap ,nfsiobuf ,NFS_MAPREG )
622: #endif /* NFS */
623: /*
624: * This is the map used by the kernel memory allocator.
625: * It is expanded as necessary by the special features
626: * that use it.
627: */
628: SYSMAP(kmempt ,kmembase ,NKMEMCLUSTERS*CLSIZE )
629: #ifdef SYSVSHM
630: ADDMAP( SHMMAXPGS )
631: #endif
632: #ifdef GPROF
633: ADDMAP( 600*CLSIZE )
634: #endif
635: /*
636: * Enlarge kmempt as needed for bounce buffers allocated
637: * by tahoe controllers.
638: */
639: #include "hd.h"
640: #if NHD > 0
641: ADDMAP( NHDC*(MAXPHYS/NBPG+CLSIZE) )
642: #endif
643: #include "dk.h"
644: #if NDK > 0
645: ADDMAP( NVD*(MAXPHYS/NBPG+CLSIZE) )
646: #endif
647: #include "yc.h"
648: #if NYC > 0
649: ADDMAP( NCY*(MAXPHYS/NBPG+CLSIZE) )
650: #endif
651: #include "mp.h"
652: ADDMAP( NMP*14 )
653: SYSMAP(ekmempt ,kmemlimit ,0 )
654:
655: SYSMAP(VMEMbeg ,vmembeg ,0 )
656: SYSMAP(VMEMmap ,vmem ,VBIOSIZE )
657: SYSMAP(VMEMmap1 ,vmem1 ,0 )
658: #include "ace.h"
659: #if NACE > 0
660: ADDMAP( NACE*32 )
661: #endif
662: #if NHD > 0
663: ADDMAP( NHDC )
664: #endif
665: #include "vx.h"
666: #if NVX > 0
667: ADDMAP( NVX * 16384/NBPG )
668: #endif
669: SYSMAP(VMEMend ,vmemend ,0 )
670:
671: SYSMAP(VBmap ,vbbase ,CLSIZE )
672: #if NHD > 0
673: ADDMAP( NHDC*(MAXPHYS/NBPG+CLSIZE) )
674: #endif
675: #if NDK > 0
676: ADDMAP( NVD*(MAXPHYS/NBPG+CLSIZE) )
677: #endif
678: #if NYC > 0
679: ADDMAP( NCY*(MAXPHYS/NBPG+CLSIZE) )
680: #endif
681: ADDMAP( NMP*14 )
682: SYSMAP(eVBmap ,vbend ,0 )
683:
684: SYSMAP(Usrptmap ,usrpt ,USRPTSIZE+CLSIZE )
685: eSysmap:
686: .globl _Syssize
687: .set _Syssize,(eSysmap-_Sysmap)/4
688:
689: .text
690: /*
691: * Initialization
692: *
693: * IPL 0x1f; MME 0; scbb, pcbb, sbr, slr, isp, ksp not set
694: */
695: .align 2
696: .globl start
697: start:
698: .word 0
699: /* set system control block base and system page table params */
700: mtpr $_scb-SYSTEM,$SCBB
701: mtpr $_Sysmap-SYSTEM,$SBR
702: mtpr $_Syssize,$SLR
703: /* double map the kernel into the virtual user addresses of phys mem */
704: mtpr $_Sysmap,$P0BR
705: mtpr $_Syssize,$P0LR
706: mtpr $_Sysmap,$P1BR # against Murphy
707: mtpr $_Syssize,$P1LR
708: /* set ISP */
709: movl $_intstack-SYSTEM+NISP*NBPG,sp # still physical
710: mtpr $_intstack+NISP*NBPG,$ISP
711: /* count up memory; _physmem contains limit */
712: clrl r7
713: shll $PGSHIFT,_physmem,r8
714: decl r8
715: 1: pushl $1; pushl r7; callf $12,_badaddr; tstl r0; bneq 9f
716: ACBL(r8,$64*1024,r7,1b)
717: 9:
718: /* clear memory from kernel bss and pages for proc 0 u. and page table */
719: movab _edata,r6; andl2 $~SYSTEM,r6
720: movab _end,r5; andl2 $~SYSTEM,r5
721: #ifdef KADB
722: subl2 $4,r5
723: 1: clrl (r6); ACBL(r5,$4,r6,1b) # clear just bss
724: addl2 $4,r5
725: bbc $6,r11,0f # check RB_KDB
726: andl3 $~SYSTEM,r9,r5 # skip symbol & string tables
727: andl3 $~SYSTEM,r9,r6
728: #endif
729: 0: orl3 $SYSTEM,r5,r9 # convert to virtual address
730: addl2 $NBPG-1,r9 # roundup to next page
731: addl2 $(UPAGES*NBPG)+NBPG+NBPG,r5
732: 1: clrl (r6); ACBL(r5,$4,r6,1b)
733: /* trap(), syscall(), and fpemulate() save r0-r12 in the entry mask */
734: orw2 $0x01fff,_trap
735: orw2 $0x01fff,_syscall
736: #ifdef FPE
737: orw2 $0x01fff,_fpemulate
738: #endif
739: orw2 $0x01ffc,_panic # for debugging (no r0|r1)
740: callf $4,_fixctlrmask # setup for autoconfig
741: /* initialize system page table: scb and int stack writeable */
742: clrl r2
743: movab eintstack,r1
744: andl2 $~SYSTEM,r1
745: shrl $PGSHIFT,r1,r1 # r1-page number of eintstack
746: /* make 1st page processor storage read/only, 2nd read/write */
747: orl3 $PG_V|PG_KR,r2,_Sysmap[r2]; incl r2;
748: orl3 $PG_V|PG_KW,r2,_Sysmap[r2]; incl r2;
749: /* other parts of the system are read/write for kernel */
750: 1: orl3 $PG_V|PG_KW,r2,_Sysmap[r2]; # data:kernel write+phys=virtual
751: aoblss r1,r2,1b
752: /* make rsstk read-only as red zone for interrupt stack */
753: andl2 $~PG_PROT,_rsstkmap
754: orl2 $PG_V|PG_KR,_rsstkmap
755: /* make kernel text space read-only */
756: movab _etext+NBPG-1,r1
757: andl2 $~SYSTEM,r1
758: shrl $PGSHIFT,r1,r1
759: 1: orl3 $PG_V|PG_KR,r2,_Sysmap[r2]
760: aoblss r1,r2,1b
761: /* make kernel data, bss, read-write */
762: andl3 $~SYSTEM,r9,r1
763: shrl $PGSHIFT,r1,r1
764: 1: orl3 $PG_V|PG_KW,r2,_Sysmap[r2]
765: aoblss r1,r2,1b
766: /* go to mapped mode, have to change both pc and sp to system addresses */
767: mtpr $1,$TBIA
768: mtpr $1,$PADC # needed by HW parity&ECC logic
769: mtpr $1,$PACC # just in case
770: mtpr $1,$MME
771: movab SYSTEM(sp),sp
772: jmp *$0f
773: 0:
774: /* disable any interrupts */
775: movl $0,_intenable
776: /* init mem sizes */
777: shrl $PGSHIFT,r7,_physmem
778: /* setup context for proc[0] == scheduler */
779: andl3 $~SYSTEM,r9,r6 # convert to physical
780: andl2 $~(NBPG-1),r6 # make page boundary
781: /* setup page table for proc[0] */
782: shrl $PGSHIFT,r6,r3 # r3 = btoc(r6)
783: orl3 $PG_V|PG_KW,r3,_Usrptmap # init first upt entry
784: incl r3 # r3 - next page
785: movab _usrpt,r0 # r0 - first user page
786: mtpr r0,$TBIS
787: /* init p0br, p0lr */
788: mtpr r0,$P0BR # no p0 for proc[0]
789: mtpr $0,$P0LR
790: mtpr r0,$P1BR # no p1 either
791: mtpr $0,$P1LR
792: /* init p2br, p2lr */
793: movab NBPG(r0),r0
794: movl $PPAGES-UPAGES,r1
795: mtpr r1,$P2LR
796: moval -4*PPAGES(r0),r2
797: mtpr r2,$P2BR
798: /* setup mapping for UPAGES of _u */
799: clrl r2
800: movl $SYSTEM,r1
801: addl2 $UPAGES,r3
802: jbr 2f
803: 1: decl r3
804: moval -NBPG(r1),r1 # r1 = virtual add of next (downward) _u page
805: subl2 $4,r0 # r0 = pte address
806: orl3 $PG_V|PG_URKW,r3,(r0)
807: mtpr r1,$TBIS
808: 2: aobleq $UPAGES,r2,1b
809: /* initialize (slightly) the pcb */
810: movab UPAGES*NBPG(r1),PCB_KSP(r1) # KSP starts at end of _u
811: movl r1,PCB_USP(r1) # USP starts just below _u
812: mfpr $P0BR,PCB_P0BR(r1)
813: mfpr $P0LR,PCB_P0LR(r1)
814: mfpr $P1BR,PCB_P1BR(r1)
815: mfpr $P1LR,PCB_P1LR(r1)
816: mfpr $P2BR,PCB_P2BR(r1)
817: mfpr $P2LR,PCB_P2LR(r1)
818: movl $CLSIZE,PCB_SZPT(r1) # init u.u_pcb.pcb_szpt
819: movl r9,PCB_R9(r1) # r9 obtained from boot
820: movl r10,PCB_R10(r1) # r10 obtained from boot
821: movl r11,PCB_R11(r1) # r11 obtained from CP on boot
822: movab 1f,PCB_PC(r1) # initial pc
823: clrl PCB_PSL(r1) # kernel mode, ipl=0
824: shll $PGSHIFT,r3,r3
825: mtpr r3,$PCBB # first pcbb (physical)
826: /* go to kernel mode */
827: ldpctx
828: rei # Actually next instruction:
829: /* put signal trampoline code in u. area */
830: 1: movab sigcode,r0
831: movab _u+PCB_SIGC,r1
832: movl $19,r2
833: movblk
834: /* save boot device in global _bootdev */
835: movl r10,_bootdev
836: /* save reboot flags in global _boothowto */
837: movl r11,_boothowto
838: #ifdef KADB
839: /* save end of symbol & string table in global _bootesym */
840: subl3 $NBPG-1,r9,_bootesym
841: #endif
842: /* calculate firstaddr, and call main() */
843: andl3 $~SYSTEM,r9,r0
844: shrl $PGSHIFT,r0,-(sp)
845: addl2 $UPAGES+1,(sp) # first physical unused page
846: callf $8,_main
847: /* proc[1] == /etc/init now running here in kernel mode; run icode */
848: pushl $PSL_CURMOD # User mode PSL
849: pushl $0 # PC = 0 (virtual now)
850: rei
851:
852: /*
853: * Mask for saving/restoring registers on entry to
854: * a user signal handler. Space for the registers
855: * is reserved in sendsig, so beware if you want
856: * to change the mask.
857: */
858: #define SIGREGS (R0|R1|R2|R3|R4|R5)
859: .align 2
860: .globl sigcode
861: sigcode:
862: storer $SIGREGS,16(sp) # save volatile registers
863: calls $4*3+4,*12(sp) # params pushed by sendsig for handler
864: loadr $SIGREGS,4(sp) # restore volatile registers
865: movab 24(sp),fp # use parameter list set up in sendsig
866: kcall $SYS_sigreturn # cleanup mask and onsigstack
867: halt # sigreturn does not return!
868:
869: .globl _icode
870: .globl _initflags
871: .globl _szicode
872: /*
873: * Icode is copied out to process 1 to exec /etc/init.
874: * If the exec fails, process 1 exits.
875: */
876: .align 2
877: _icode:
878: /* try /sbin/init */
879: pushab b`argv1-l0(pc)
880: l0: pushab b`init1-l1(pc)
881: l1: pushl $2
882: movab (sp),fp
883: kcall $SYS_execv
884: /* try /etc/init */
885: pushab b`argv2-l2(pc)
886: l2: pushab b`init2-l3(pc)
887: l3: pushl $2
888: movab (sp),fp
889: kcall $SYS_execv
890: /* give up */
891: pushl r0
892: pushl $1
893: movab (sp),fp
894: kcall $SYS_exit
895:
896: init1: .asciz "/sbin/init"
897: init2: .asciz "/etc/init"
898: .align 2
899: _initflags:
900: .long 0
901: argv1: .long init1+6-_icode
902: .long _initflags-_icode
903: .long 0
904: argv2: .long init2+5-_icode
905: .long _initflags-_icode
906: .long 0
907: _szicode:
908: .long _szicode-_icode
909:
910: /*
911: * Primitives
912: */
913:
914: /*
915: * badaddr(addr, len)
916: * see if access addr with a len type instruction causes a machine check
917: * len is length of access (1=byte, 2=short, 4=long)
918: * r0 = 0 means good(exists); r0 =1 means does not exist.
919: */
920: ENTRY(badaddr, R3|R4)
921: mfpr $IPL,r1
922: mtpr $HIGH,$IPL
923: movl _scb+SCB_BUSERR,r2
924: movl 4(fp),r3
925: movl 8(fp),r4
926: movab 9f,_scb+SCB_BUSERR
927: bbc $0,r4,1f; tstb (r3)
928: 1: bbc $1,r4,1f; tstw (r3)
929: 1: bbc $2,r4,1f; tstl (r3)
930: 1: clrl r0
931: 2: movl r2,_scb+SCB_BUSERR
932: mtpr r1,$IPL
933: ret
934:
935: /*
936: * wbadaddr(addr, len, value)
937: * see if write of value to addr with a len type instruction causes
938: * a machine check
939: * len is length of access (1=byte, 2=short, 4=long)
940: * r0 = 0 means good(exists); r0 =1 means does not exist.
941: */
942: ENTRY(wbadaddr, R3|R4)
943: mfpr $IPL,r1
944: mtpr $HIGH,$IPL
945: movl _scb+SCB_BUSERR,r2
946: movl 4(fp),r3
947: movl 8(fp),r4
948: movab 9f,_scb+SCB_BUSERR
949: bbc $0,r4,1f; movb 15(fp), (r3)
950: 1: bbc $1,r4,1f; movw 14(fp), (r3)
951: 1: bbc $2,r4,1f; movl 12(fp), (r3)
952: 1: movl $30000,r0 # delay for error interrupt
953: 1: decl r0
954: jneq 1b
955: 2: movl r2,_scb+SCB_BUSERR # made it w/o machine checks; r0 is 0
956: mtpr r1,$IPL
957: ret
958:
959: .align 2
960: 9: # catch buss error (if it comes)
961: andl3 4(sp),$ERRCD,r0
962: cmpl r0,$APE
963: jneq 1f
964: halt # address parity error
965: 1: cmpl r0,$VBE
966: jneq 1f
967: halt # Versabus error
968: 1:
969: movl $1,r0 # Anything else = bad address
970: movab 8(sp),sp # discard buss error trash
971: movab 2b,(sp) # new program counter on stack.
972: rei
973:
974: /*
975: * badcyaddr(addr)
976: * see if access tape master controller addr causes a bus error
977: * r0 = 0: no error; r0 = 1: timeout error.
978: */
979: ENTRY(badcyaddr, 0)
980: mfpr $IPL,r1
981: mtpr $HIGH,$IPL
982: clrl r2
983: movab 2f,nofault
984: movob $-1, *4(fp)
985: 1: aobleq $1000, r2, 1b
986: clrl nofault # made it w/o bus error
987: clrl r0
988: jbr 3f
989: 2: movl $1,r0
990: 3: mtpr r1,$IPL
991: ret
992:
993: /*
994: * peek(addr)
995: * fetch word and catch any bus error
996: */
997: ENTRY(peek, 0)
998: mfpr $IPL,r1
999: mtpr $0x18,$IPL # not reentrant
1000: movl 4(fp),r2
1001: movab 1f,nofault
1002: movw (r2),r0
1003: clrl nofault
1004: andl2 $0xffff,r0
1005: jbr 2f
1006: 1: movl $-1,r0 # bus error
1007: 2: mtpr r1,$IPL
1008: ret
1009:
1010: /*
1011: * poke(addr, val)
1012: * write word and catch any bus error
1013: */
1014: ENTRY(poke, R3)
1015: mfpr $IPL,r1
1016: mtpr $0x18,$IPL # not reentrant
1017: movl 4(fp),r2
1018: movl 8(fp),r3
1019: clrl r0
1020: movab 1f,nofault
1021: movw r3,(r2)
1022: clrl nofault
1023: jbr 2f
1024: 1: movl $-1,r0 # bus error
1025: 2: mtpr r1,$IPL
1026: ret
1027:
1028: /*
1029: * Copy a potentially overlapping block of memory.
1030: *
1031: * ovbcopy(src, dst, count)
1032: * caddr_t src, dst; unsigned count;
1033: */
1034: ENTRY(ovbcopy, R3|R4)
1035: movl 4(fp),r0
1036: movl 8(fp),r1
1037: movl 12(fp),r2
1038: cmpl r0,r1
1039: bgtru 1f # normal forward case
1040: beql 2f # equal, nothing to do
1041: addl2 r2,r0 # may be overlapping
1042: cmpl r0,r1
1043: bgtru 3f
1044: subl2 r2,r0 # normal forward case
1045: 1:
1046: movblk
1047: 2:
1048: ret
1049: 3:
1050: addl2 r2,r1 # overlapping, must do backwards
1051: subl3 r0,r1,r3
1052: movl r2,r4
1053: jbr 5f
1054: 4:
1055: subl2 r3,r0
1056: subl2 r3,r1
1057: movl r3,r2
1058: movblk
1059: subl2 r3,r0
1060: subl2 r3,r1
1061: subl2 r3,r4
1062: 5:
1063: cmpl r4,r3
1064: jgtr 4b
1065: movl r4,r2
1066: subl2 r2,r0
1067: subl2 r2,r1
1068: movblk
1069: ret
1070:
1071: /*
1072: * Copy a null terminated string from the user address space into
1073: * the kernel address space.
1074: *
1075: * copyinstr(fromaddr, toaddr, maxlength, &lencopied)
1076: */
1077: ENTRY(copyinstr, 0)
1078: movl 12(fp),r5 # r5 = max length
1079: jlss 5f
1080: movl 8(fp),r4 # r4 = kernel address
1081: movl 4(fp),r0 # r0 = user address
1082: andl3 $(NBPG*CLSIZE-1),r0,r2 # r2 = bytes on first page
1083: subl3 r2,$(NBPG*CLSIZE),r2
1084: 1:
1085: cmpl r5,r2 # r2 = min(bytes on page, length left);
1086: jgeq 2f
1087: movl r5,r2
1088: 2:
1089: prober $1,(r0),r2 # bytes accessible?
1090: jeql 5f
1091: subl2 r2,r5 # update bytes left count
1092: movl r2,r3 # r3 = saved count
1093: movl r0,r1
1094: cmps3 # check for null
1095: tstl r2
1096: jneq 3f
1097: subl2 r3,r0 # back up r0
1098: movl r4,r1
1099: movl r3,r2
1100: movblk # copy in next piece
1101: movl r1,r4
1102: movl $(NBPG*CLSIZE),r2 # check next page
1103: tstl r5 # run out of space?
1104: jneq 1b
1105: movl $ENOENT,r0 # set error code and return
1106: jbr 6f
1107: 3:
1108: tstl 16(fp) # return length?
1109: beql 4f
1110: subl3 r5,12(fp),r5 # actual len = maxlen - unused pages
1111: subl2 r2,r5 # - unused on this page
1112: addl3 $1,r5,*16(fp) # + the null byte
1113: 4:
1114: movl r4,r1
1115: subl3 r2,r3,r2 # calc char cnt
1116: subl2 r2,r0 # back up r0
1117: incl r2 # add on null byte
1118: movblk # copy last piece
1119: clrl r0
1120: ret
1121: 5:
1122: movl $EFAULT,r0
1123: 6:
1124: tstl 16(fp)
1125: beql 7f
1126: subl3 r5,12(fp),*16(fp)
1127: 7:
1128: ret
1129:
1130: /*
1131: * Copy a null terminated string from the kernel
1132: * address space to the user address space.
1133: *
1134: * copyoutstr(fromaddr, toaddr, maxlength, &lencopied)
1135: */
1136: ENTRY(copyoutstr, 0)
1137: movl 12(fp),r5 # r5 = max length
1138: jlss 5f
1139: movl 4(fp),r0 # r0 = kernel address
1140: movl 8(fp),r4 # r4 = user address
1141: andl3 $(NBPG*CLSIZE-1),r4,r2 # r2 = bytes on first page
1142: subl3 r2,$(NBPG*CLSIZE),r2
1143: 1:
1144: cmpl r5,r2 # r2 = min(bytes on page, length left);
1145: jgeq 2f
1146: movl r5,r2
1147: 2:
1148: probew $1,(r4),r2 # bytes accessible?
1149: jeql 5f
1150: subl2 r2,r5 # update bytes left count
1151: movl r2,r3 # r3 = saved count
1152: movl r0,r1
1153: /*
1154: * This is a workaround for a microcode bug that causes
1155: * a trap type 9 when cmps3/movs3 touches the last byte
1156: * on a valid page immediately followed by an invalid page.
1157: */
1158: #ifdef good_cmps3
1159: cmps3 # check for null
1160: tstl r2
1161: jneq 3b
1162: #else
1163: decl r2
1164: beql 9f # cannot handle case of r2 == 0!
1165: cmps3 # check for null up to last byte
1166: 9:
1167: incl r2
1168: cmpl $1,r2 # get to last byte on page?
1169: bneq 3b
1170: tstb (r0) # last byte on page null?
1171: beql 3b
1172: incl r0 # not null, so bump pointer
1173: #endif not good_cmps3
1174: subl2 r3,r0 # back up r0
1175: movl r4,r1
1176: movl r3,r2
1177: movblk # copy out next piece
1178: movl r1,r4
1179: movl $(NBPG*CLSIZE),r2 # check next page
1180: tstl r5 # run out of space?
1181: jneq 1b
1182: movl $ENOENT,r0 # set error code and return
1183: jbr 6b
1184: 5:
1185: clrl *$0 # this should never execute, if it does
1186: movl $EFAULT,r0 # save me a core dump (mkm - 9/87)
1187: 6:
1188: tstl 16(fp)
1189: beql 7f
1190: subl3 r5,12(fp),*16(fp)
1191: 7:
1192: ret
1193:
1194:
1195: /*
1196: * Copy a null terminated string from one point to another in
1197: * the kernel address space.
1198: *
1199: * copystr(fromaddr, toaddr, maxlength, &lencopied)
1200: */
1201: ENTRY(copystr, 0)
1202: movl 12(fp),r3 # r3 = max length
1203: jlss 5b
1204: movl 4(fp),r0 # r0 = src address
1205: movl 8(fp),r4 # r4 = dest address
1206: clrl r5 # r5 = bytes left
1207: movl r3,r2 # r2 = max bytes to copy
1208: movl r0,r1
1209: cmps3 # check for null
1210: tstl r2
1211: jneq 3b
1212: subl2 r3,r0 # back up r0
1213: movl r4,r1
1214: movl r3,r2
1215: movblk # copy next piece
1216: movl $ENOENT,r0 # set error code and return
1217: jbr 6b
1218:
1219: /*
1220: * Copy a block of data from the user address space into
1221: * the kernel address space.
1222: *
1223: * copyin(fromaddr, toaddr, count)
1224: */
1225: ENTRY(copyin, 0)
1226: movl 12(fp),r0 # copy length
1227: blss 9f
1228: movl 4(fp),r1 # copy user address
1229: cmpl $(CLSIZE*NBPG),r0 # probing one page or less ?
1230: bgeq 2f # yes
1231: 1:
1232: prober $1,(r1),$(CLSIZE*NBPG) # bytes accessible ?
1233: beql 9f # no
1234: addl2 $(CLSIZE*NBPG),r1 # incr user address ptr
1235: _ACBL($(CLSIZE*NBPG+1),$(-CLSIZE*NBPG),r0,1b) # reduce count and loop
1236: 2:
1237: prober $1,(r1),r0 # bytes accessible ?
1238: beql 9f # no
1239: MOVC3(4(fp),8(fp),12(fp))
1240: clrl r0
1241: ret
1242: 9:
1243: movl $EFAULT,r0
1244: ret
1245:
1246: /*
1247: * Copy a block of data from the kernel
1248: * address space to the user address space.
1249: *
1250: * copyout(fromaddr, toaddr, count)
1251: */
1252: ENTRY(copyout, 0)
1253: movl 12(fp),r0 # get count
1254: blss 9b
1255: movl 8(fp),r1 # get user address
1256: cmpl $(CLSIZE*NBPG),r0 # can do in one probew?
1257: bgeq 2f # yes
1258: 1:
1259: probew $1,(r1),$(CLSIZE*NBPG) # bytes accessible?
1260: beql 9b # no
1261: addl2 $(CLSIZE*NBPG),r1 # increment user address
1262: _ACBL($(CLSIZE*NBPG+1),$(-CLSIZE*NBPG),r0,1b) # reduce count and loop
1263: 2:
1264: probew $1,(r1),r0 # bytes accessible?
1265: beql 9b # no
1266: MOVC3(4(fp),8(fp),12(fp))
1267: clrl r0
1268: ret
1269:
1270: /*
1271: * savectx is like setjmp but saves all registers.
1272: * Called before swapping out the u. area, restored by resume()
1273: * below.
1274: */
1275: ENTRY(savectx, 0)
1276: movl 4(fp),r2
1277: storer $0x1ff8,(r2); addl2 $40,r2 # r3-r12
1278: movl (fp),(r2); addl2 $4,r2 # fp
1279: movab 8(fp),(r2); addl2 $4,r2 # sp
1280: movl -8(fp),(r2) # pc
1281: clrl r0
1282: ret
1283:
1284: #ifdef KADB
1285: /*
1286: * C library -- reset, setexit -- XXX
1287: *
1288: * reset(x)
1289: * will generate a "return" from
1290: * the last call to
1291: * setexit()
1292: * by restoring r2 - r12, fp
1293: * and doing a return.
1294: * The returned value is x; on the original
1295: * call the returned value is 0.
1296: */
1297: ENTRY(setexit, 0)
1298: movab setsav,r0
1299: storer $0x1ffc, (r0)
1300: movl (fp),44(r0) # fp
1301: moval 4(fp),48(r0) # sp
1302: movl -8(fp),52(r0) # pc
1303: clrl r0
1304: ret
1305:
1306: ENTRY(reset, 0)
1307: movl 4(fp),r0 # returned value
1308: movab setsav,r1
1309: loadr $0x1ffc,(r1)
1310: movl 44(r1),fp
1311: movl 48(r1),sp
1312: jmp *52(r1)
1313:
1314: .data
1315: .align 2
1316: setsav: .space 14*4
1317: .text
1318: #endif
1319:
1320: .globl _whichqs
1321: .globl _qs
1322: .globl _cnt
1323:
1324: .globl _noproc
1325: .comm _noproc,4
1326: .globl _runrun
1327: .comm _runrun,4
1328: /*
1329: * The following primitives use the fancy TAHOE instructions.
1330: * _whichqs tells which of the 32 queues _qs
1331: * have processes in them. setrq puts processes into queues, remrq
1332: * removes them from queues. The running process is on no queue,
1333: * other processes are on a queue related to p->p_pri, divided by 4
1334: * actually to shrink the 0-127 range of priorities into the 32 available
1335: * queues.
1336: */
1337:
1338: /*
1339: * setrq(p), using fancy TAHOE instructions.
1340: *
1341: * Call should be made at spl8(), and p->p_stat should be SRUN
1342: */
1343: ENTRY(setrq, 0)
1344: movl 4(fp),r0
1345: tstl P_RLINK(r0) ## firewall: p->p_rlink must be 0
1346: beql set1 ##
1347: pushab set3 ##
1348: callf $8,_panic ##
1349: set1:
1350: movzbl P_PRI(r0),r1 # put on queue which is p->p_pri / 4
1351: shar $2,r1,r1
1352: shal $1,r1,r2
1353: moval _qs[r2],r2
1354: insque (r0),*4(r2) # at end of queue
1355: shal r1,$1,r1
1356: orl2 r1,_whichqs # mark queue non-empty
1357: ret
1358:
1359: set3: .asciz "setrq"
1360:
1361: /*
1362: * remrq(p), using fancy TAHOE instructions
1363: *
1364: * Call should be made at spl8().
1365: */
1366: ENTRY(remrq, 0)
1367: movl 4(fp),r0
1368: movzbl P_PRI(r0),r1
1369: shar $2,r1,r1
1370: bbs r1,_whichqs,rem1
1371: pushab rem3 # it wasn't recorded to be on its q
1372: callf $8,_panic
1373: rem1:
1374: remque (r0)
1375: bneq rem2 # q not empty yet
1376: shal r1,$1,r1
1377: mcoml r1,r1
1378: andl2 r1,_whichqs # mark queue empty
1379: rem2:
1380: clrl P_RLINK(r0) ## for firewall checking
1381: ret
1382:
1383: rem3: .asciz "remrq"
1384:
1385: /*
1386: * Masterpaddr is the p->p_addr of the running process on the master
1387: * processor. When a multiprocessor system, the slave processors will have
1388: * an array of slavepaddr's.
1389: */
1390: .globl _masterpaddr
1391: .data
1392: .align 2
1393: _masterpaddr: .long 0
1394:
1395: .text
1396: sw0: .asciz "swtch"
1397:
1398: /*
1399: * When no processes are on the runq, swtch branches to idle
1400: * to wait for something to come ready.
1401: */
1402: .globl Idle
1403: Idle: idle:
1404: movl $1,_noproc
1405: mtpr $0,$IPL # must allow interrupts here
1406: 1:
1407: tstl _whichqs # look for non-empty queue
1408: bneq sw1
1409: brb 1b
1410:
1411: badsw: pushab sw0
1412: callf $8,_panic
1413: /* NOTREACHED */
1414:
1415: .align 2
1416: /*
1417: * swtch(), using fancy tahoe instructions
1418: */
1419: ENTRY(swtch, 0)
1420: movl (fp),fp # prepare for rei
1421: movl (sp),4(sp) # saved pc
1422: tstl (sp)+
1423: movpsl 4(sp)
1424: incl _cnt+V_SWTCH
1425: sw1: ffs _whichqs,r0 # look for non-empty queue
1426: blss idle # if none, idle
1427: mtpr $0x18,$IPL # lock out all so _whichqs==_qs
1428: bbc r0,_whichqs,sw1 # proc moved via interrupt
1429: shal $1,r0,r1
1430: moval _qs[r1],r1
1431: movl (r1),r2 # r2 = p = highest pri process
1432: remque *(r1)
1433: bvs badsw # make sure something was there
1434: bneq sw2
1435: shal r0,$1,r1
1436: mcoml r1,r1
1437: andl2 r1,_whichqs # no more procs in this queue
1438: sw2:
1439: clrl _noproc
1440: clrl _runrun
1441: #ifdef notdef
1442: tstl P_WCHAN(r2) ## firewalls
1443: bneq badsw ##
1444: cmpb P_STAT(r2),$SRUN ##
1445: bneq badsw ##
1446: #endif
1447: clrl P_RLINK(r2) ##
1448: movl *P_ADDR(r2),r0
1449: #ifdef notdef
1450: cmpl r0,_masterpaddr # resume of current proc is easy
1451: beql res0
1452: #endif
1453: movl r0,_masterpaddr
1454: shal $PGSHIFT,r0,r0 # r0 = pcbb(p)
1455: brb swresume
1456:
1457: /*
1458: * resume(pf)
1459: */
1460: ENTRY(resume, 0)
1461: shal $PGSHIFT,4(fp),r0 # r0 = pcbb(pf)
1462: movl (fp),fp # prepare for rei
1463: movl (sp)+,4(sp) # saved pc
1464: tstl (sp)+
1465: movpsl 4(sp)
1466: swresume:
1467: mtpr $0x18,$IPL # no interrupts, please
1468: movl _CMAP2,_u+PCB_CMAP2 # yech
1469: REST_ACC # restore original accumulator
1470: svpctx
1471: mtpr r0,$PCBB
1472: ldpctx
1473: movl _u+PCB_CMAP2,_CMAP2 # yech
1474: mtpr $_CADDR2,$TBIS
1475: res0:
1476: movl _u+U_PROCP,r2 # r2 = u.u_procp
1477: tstl P_CKEY(r2) # does proc have code key?
1478: bneq 1f
1479: callf $4,_getcodekey # no, give him one
1480: movl _u+U_PROCP,r2 # r2 = u.u_procp
1481: movl r0,P_CKEY(r2)
1482: 1:
1483: tstl P_DKEY(r2) # does proc have data key?
1484: bneq 1f
1485: callf $4,_getdatakey # no, give him one
1486: movl _u+U_PROCP,r2 # r2 = u.u_procp
1487: movl r0,P_DKEY(r2)
1488: 1:
1489: mtpr P_CKEY(r2),$CCK # set code cache key
1490: mtpr P_DKEY(r2),$DCK # set data cache key
1491: tstl _u+PCB_SSWAP
1492: bneq res1
1493: rei
1494: res1: # restore alternate saved context
1495: movl _u+PCB_SSWAP,r2
1496: clrl _u+PCB_SSWAP
1497: loadr $0x3ff8,(r2); addl2 $44,r2 # restore r3-r13 (r13=fp)
1498: movl (r2),r1; addl2 $4,r2 # fetch previous sp ...
1499: movab (sp),r0 # ... and current sp and
1500: cmpl r1,r0 # check for credibility,
1501: bgequ 1f # if further up stack ...
1502: pushab 2f; callf $8,_panic # ... panic
1503: /*NOTREACHED*/
1504: 1: # sp ok, complete return
1505: movl r1,sp # restore sp
1506: pushl $PSL_PRVMOD # kernel mode, ipl 0
1507: pushl (r2) # return address
1508: rei
1509: 2: .asciz "ldctx"
1510:
1511: /*
1512: * {fu,su},{byte,word}
1513: */
1514: ENTRY(fuword, 0)
1515: movl 4(fp), r1
1516: prober $1,(r1),$4 # check access
1517: beql fserr # page unreadable
1518: bitl $1,r1 # check byte alignment
1519: bneq 2f # odd, do byte-word-byte
1520: bitl $2,r1 # check word alignment
1521: bneq 1f # odd, do in 2 words
1522: movl (r1),r0 # move longword
1523: ret
1524: 1:
1525: movw (r1),r0 # move two words
1526: shal $16,r0,r0
1527: movzwl 2(r1),r1 # orw2 sign extends
1528: orl2 r1,r0
1529: ret
1530: 2:
1531: movb (r1),r0 # move byte-word-byte
1532: shal $24,r0,r0
1533: movzwl 1(r1),r2 # orw2 sign extends
1534: shal $8,r2,r2
1535: movzbl 3(r1),r1 # orb2 sign extends
1536: orl2 r2,r1
1537: orl2 r1,r0
1538: ret
1539: fserr:
1540: mnegl $1,r0
1541: ret
1542:
1543: ENTRY(fubyte, 0)
1544: prober $1,*4(fp),$1
1545: beql fserr
1546: movzbl *4(fp),r0
1547: ret
1548:
1549: ENTRY(suword, 0)
1550: movl 4(fp), r0
1551: probew $1,(r0),$4 # check access
1552: beql fserr # page unwritable
1553: bitl $1,r0 # check byte alignment
1554: bneq 1f # odd byte boundary
1555: bitl $2,r0 # check word alignment
1556: beql 2f # longword aligned
1557: movw 8(fp),(r0) # move two words
1558: movw 10(fp),2(r0)
1559: jbr 3f
1560: 1:
1561: movb 8(fp),(r0)
1562: movb 9(fp),1(r0)
1563: movb 10(fp),2(r0)
1564: movb 11(fp),3(r0)
1565: jbr 3f
1566: 2:
1567: movl 8(fp),(r0)
1568: 3:
1569: clrl r0
1570: ret
1571:
1572: ENTRY(subyte, 0)
1573: probew $1,*4(fp),$1
1574: beql fserr
1575: movb 11(fp),*4(fp)
1576: clrl r0
1577: ret
1578:
1579: /*
1580: * Copy 1 relocation unit (NBPG bytes)
1581: * from user virtual address to physical address
1582: */
1583: ENTRY(copyseg, 0)
1584: orl3 $PG_V|PG_KW,8(fp),_CMAP2
1585: mtpr $_CADDR2,$TBIS # invalidate entry for copy
1586: MOVC3(4(fp),$_CADDR2,$NBPG)
1587: ret
1588:
1589: /*
1590: * Clear a page of memory. The page frame is specified.
1591: *
1592: * clearseg(pf);
1593: */
1594: ENTRY(clearseg, 0)
1595: orl3 $PG_V|PG_KW,4(fp),_CMAP1 # Maps to virtual addr CADDR1
1596: mtpr $_CADDR1,$TBIS
1597: movl $255,r0 # r0 = limit
1598: clrl r1 # r1 = index of cleared long
1599: 1:
1600: clrl _CADDR1[r1]
1601: aobleq r0,r1,1b
1602: ret
1603:
1604: /*
1605: * Check user mode read/write access.
1606: *
1607: * useracc(addr, count, mode)
1608: * caddr_t addr; int count, mode;
1609: * mode = 0 write access
1610: * mode = 1 read access
1611: */
1612: ENTRY(useracc, 0)
1613: movl $1,r2 # r2 = 'user mode' for probew/probew
1614: probes:
1615: movl 4(fp),r0 # get va
1616: movl 8(fp),r1 # count
1617: tstl 12(fp) # test for read access ?
1618: bneq userar # yes
1619: cmpl $(CLSIZE*NBPG),r1 # can we do it in one probe ?
1620: bgeq uaw2 # yes
1621: uaw1:
1622: probew r2,(r0),$(CLSIZE*NBPG)
1623: beql uaerr # no access
1624: addl2 $(CLSIZE*NBPG),r0
1625: _ACBL($(CLSIZE*NBPG+1),$(-CLSIZE*NBPG),r1,uaw1)
1626: uaw2:
1627: probew r2,(r0),r1
1628: beql uaerr
1629: movl $1,r0
1630: ret
1631: userar:
1632: cmpl $(CLSIZE*NBPG),r1
1633: bgeq uar2
1634: uar1:
1635: prober r2,(r0),$(CLSIZE*NBPG)
1636: beql uaerr
1637: addl2 $(CLSIZE*NBPG),r0
1638: _ACBL($(CLSIZE*NBPG+1),$(-CLSIZE*NBPG),r1,uar1)
1639: uar2:
1640: prober r2,(r0),r1
1641: beql uaerr
1642: movl $1,r0
1643: ret
1644: uaerr:
1645: clrl r0
1646: ret
1647:
1648: /*
1649: * Check kernel mode read/write access.
1650: *
1651: * kernacc(addr, count, mode)
1652: * caddr_t addr; int count, mode;
1653: * mode = 0 write access
1654: * mode = 1 read access
1655: */
1656: ENTRY(kernacc, 0)
1657: clrl r2 # r2 = 0 means kernel mode probe.
1658: jbr probes # Dijkstra would get gastric distress here.
1659:
1660: /*
1661: * addupc - increment some histogram counter
1662: * in the profiling buffer
1663: *
1664: * addupc(pc, prof, delta)
1665: * long pc; short delta; struct uprof *prof;
1666: *
1667: * struct uprof { # profile arguments
1668: * short *r_base; # buffer base
1669: * unsigned pr_size; # buffer size
1670: * unsigned pr_off; # pc offset
1671: * unsigned pr_scale; # pc scaling
1672: * }
1673: */
1674: ENTRY(addupc, 0)
1675: movl 8(fp),r2 # r2 points to structure
1676: subl3 8(r2),4(fp),r0 # r0 = PC - lowpc
1677: jlss 9f # PC < lowpc , out of range !
1678: shrl $1,r0,r0 # the unit is words
1679: shrl $1,12(r2),r1 # ditto for scale
1680: emul r1,r0,$0,r0
1681: shrq $14,r0,r0
1682: tstl r0 # too big
1683: jneq 9f
1684: cmpl r1,4(r2) # Check buffer overflow
1685: jgequ 9f
1686: probew $1,*0(r2)[r1],$2 # counter accessible?
1687: jeql 9f
1688: shrl $1,r1,r1 # make r1 word index
1689: addw2 14(fp),*0(r2)[r1]
1690: 9: ret
1691:
1692: /*
1693: * scanc(size, cp, table, mask)
1694: */
1695: ENTRY(scanc, R3|R4)
1696: movl 8(fp),r0 # r0 = cp
1697: addl3 4(fp),r0,r2 # end = &cp[size]
1698: movl 12(fp),r1 # r1 = table
1699: movb 19(fp),r4 # r4 = mask
1700: decl r0 # --cp
1701: jbr 0f # just like Fortran...
1702: 1: # do {
1703: movzbl (r0),r3
1704: bitb r4,(r1)[r3] # if (table[*cp] & mask)
1705: jneq 2f # break;
1706: 0: aoblss r2,r0,1b # } while (++cp < end);
1707: 2:
1708: subl3 r0,r2,r0; ret # return (end - cp);
1709:
1710: /*
1711: * skpc(mask, size, cp)
1712: */
1713: ENTRY(skpc, 0)
1714: movl 12(fp),r0 # r0 = cp
1715: addl3 8(fp),r0,r1 # r1 = end = &cp[size];
1716: movb 7(fp),r2 # r2 = mask
1717: decl r0 # --cp;
1718: jbr 0f
1719: 1: # do
1720: cmpb (r0),r2 # if (*cp != mask)
1721: jneq 2f # break;
1722: 0: aoblss r1,r0,1b # while (++cp < end);
1723: 2:
1724: subl3 r0,r1,r0; ret # return (end - cp);
1725:
1726: /*
1727: * locc(mask, size, cp)
1728: */
1729: ENTRY(locc, 0)
1730: movl 12(fp),r0 # r0 = cp
1731: addl3 8(fp),r0,r1 # r1 = end = &cp[size]
1732: movb 7(fp),r2 # r2 = mask
1733: decl r0 # --cp;
1734: jbr 0f
1735: 1: # do
1736: cmpb (r0),r2 # if (*cp == mask)
1737: jeql 2f # break;
1738: 0: aoblss r1,r0,1b # while (++cp < end);
1739: 2:
1740: subl3 r0,r1,r0; ret # return (end - cp);
1741:
1742: #ifdef ALIGN
1743: #include "../tahoealign/align.h"
1744:
1745: .globl _alignment
1746: /*
1747: * There's an intimate relationship between this piece of code
1748: * and the alignment emulation code (especially the layout
1749: * of local variables in alignment.c! Don't change unless
1750: * you update both this, alignment.h and alignment.c !!
1751: */
1752: non_aligned:
1753: orb2 $EMULATEALIGN,_u+U_EOSYS
1754: incl _cnt+V_TRAP
1755: incl _cnt+V_ALIGN # count emulated alignment traps
1756: moval 4(sp),_user_psl
1757: SAVE_FPSTAT(4) # Also zeroes out ret_exception !
1758: pushl $0 # ret_addr
1759: pushl $0 # ret_code
1760: mfpr $USP,-(sp) # user sp
1761: callf $4,_alignment # call w/o parms so regs may be modified
1762: /*
1763: * We return here after a successful emulation or an exception.
1764: * The registers have been restored and we must not alter them
1765: * before returning to the user.
1766: */
1767: 2: mtpr (sp)+,$USP # restore user sp
1768: tstl 8(sp) # Any exception ?
1769: bneq got_excp # Yes, reflect it back to user.
1770: moval 8(sp),sp # pop 2 zeroes pushed above
1771: REST_FPSTAT
1772: xorb2 $EMULATEALIGN,_u+U_EOSYS
1773:
1774: bitl $PSL_T,4(sp) # check for trace bit set
1775: beql 9f
1776: CHECK_SFE(4)
1777: pushl $0
1778: SAVE_FPSTAT(8)
1779: TRAP(TRCTRAP)
1780: 9: rei
1781:
1782: got_excp: # decode exception
1783: casel 8(sp),$ILL_ADDRMOD,$ALIGNMENT
1784: .align 1
1785: L1:
1786: .word ill_addrmod-L1
1787: .word ill_access-L1
1788: .word ill_oprnd-L1
1789: .word arithmetic-L1
1790: .word alignment-L1
1791: brw alignment # default - shouldn't come here at all !
1792:
1793: ill_addrmod: # No other parameters. Set up stack as
1794: moval 8(sp),sp # the HW would do it in a real case.
1795: REST_FPSTAT
1796: jbr _Xresadflt
1797: ill_oprnd:
1798: moval 8(sp),sp
1799: REST_FPSTAT
1800: jbr _Xresopflt
1801: alignment:
1802: moval 8(sp),sp
1803: REST_FPSTAT
1804: jbr align_excp # NB: going to _Xalignflt would cause loop
1805: ill_access:
1806: /*
1807: * Must restore accumulator w/o modifying sp and w/o using
1808: * registers. Solution: copy things needed by REST_FPSTAT.
1809: */
1810: pushl 20(sp) # The flags longword
1811: pushl 20(sp) # acc_low
1812: pushl 20(sp) # acc_high
1813: pushl 20(sp) # ret_exception ignored by REST_FPSTAT
1814: REST_FPSTAT # Back where we were with the sp !
1815: movl (sp),16(sp) # code for illegal access
1816: movl 4(sp),20(sp) # original virtual address
1817: moval 16(sp),sp # Just like the HW would set it up
1818: jbr _Xprotflt
1819: arithmetic: # same trickery as above
1820: pushl 20(sp) # The flags longword
1821: pushl 20(sp) # acc_low
1822: pushl 20(sp) # acc_high
1823: pushl 20(sp) # ret_exception ignored by REST_FPSTAT
1824: REST_FPSTAT # Back where we were with the sp !
1825: movl (sp),20(sp) # code for arithmetic exception
1826: moval 20(sp),sp # Just like the HW would set it up
1827: jbr _Xarithtrap
1828: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.