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