1: #ifdef LOCORE 2: #define P_LINK 0 3: #define P_RLINK 4 4: #define P_XLINK 108 5: #define P_ADDR 16 6: #define P_PRI 21 7: #define P_STAT 23 8: #define P_WCHAN 96 9: #define P_TSIZE 68 10: #define P_DSIZE 72 11: #define P_SSIZE 76 12: #define P_P0BR 104 13: #define P_SZPT 66 14: #define P_TEXTP 100 15: #define P_FLAG 44 16: #define SSLEEP 1 17: #define SRUN 3 18: #define UBA_BRRVR 48 19: #define UH_UBA 0 20: #define UH_VEC 8 21: #define UH_SIZE 64 22: #define RP_FLAG 12 23: #define X_CADDR 64 24: #define V_SWTCH 0 25: #define V_TRAP 4 26: #define V_SYSCALL 8 27: #define V_INTR 12 28: #define V_SOFT 16 29: #define V_PDMA 20 30: #define V_FAULTS 92 31: #define V_PGREC 52 32: #define V_FASTPGREC 112 33: #define UPAGES 10 34: #define CLSIZE 2 35: #define SYSPTSIZE 3584 36: #define USRPTSIZE 4096 37: #define MSGBUFPTECNT 8 38: #define NMBCLUSTERS 256 39: #define U_PROCP 128 40: #define U_RU 1640 41: #define RU_MINFLT 32 42: #else 43: asm(".set U_ARG,156"); 44: asm(".set U_QSAVE,192"); 45: #endif 46: /* 47: * Copyright (c) 1982, 1986 Regents of the University of California. 48: * All rights reserved. The Berkeley software License Agreement 49: * specifies the terms and conditions for redistribution. 50: * 51: * @(#)rpb.s 7.1 (Berkeley) 6/5/86 52: */ 53: 54: /* 55: * This has to get loaded first (physical 0) as 780 memory restart rom 56: * only looks for rpb on a 64K page boundary (doc isn't wrong, 57: * it never says what size "page boundary" rpb has to be on). 58: */ 59: .globl _rpb 60: _rpb: 61: .space 508 62: erpb: 63: .space 4 64: /* 65: * Copyright (c) 1982, 1986 Regents of the University of California. 66: * All rights reserved. The Berkeley software License Agreement 67: * specifies the terms and conditions for redistribution. 68: * 69: * @(#)scb.s 7.1 (Berkeley) 6/5/86 70: */ 71: 72: #include "uba.h" 73: 74: /* 75: * System control block 76: */ 77: .set INTSTK,1 # handle this interrupt on the interrupt stack 78: .set HALT,3 # halt if this interrupt occurs 79: 80: _scb: .globl _scb 81: 82: #define STRAY .long _Xstray+INTSTK 83: #define STRAY8 STRAY;STRAY;STRAY;STRAY;STRAY;STRAY;STRAY;STRAY 84: #define STRAY15 STRAY;STRAY;STRAY;STRAY;STRAY;STRAY;STRAY;STRAY8 85: #define KS(a) .long _X/**/a 86: #define IS(a) .long _X/**/a+INTSTK 87: #define STOP(a) .long _X/**/a+HALT 88: 89: /* 000 */ STRAY; IS(machcheck); IS(kspnotval); STOP(powfail); 90: /* 010 */ KS(privinflt); KS(xfcflt); KS(resopflt); KS(resadflt); 91: /* 020 */ KS(protflt); KS(transflt); KS(tracep); KS(bptflt); 92: /* 030 */ KS(compatflt); KS(arithtrap); STRAY; STRAY; 93: /* 040 */ KS(syscall); KS(chme); KS(chms); KS(chmu); 94: /* 050 */ STRAY; IS(cmrd); STRAY; STRAY; 95: /* 060 */ IS(wtime); STRAY; STRAY; STRAY; 96: /* 070 */ STRAY; STRAY; STRAY; STRAY; 97: /* 080 */ STRAY; STRAY; KS(astflt); STRAY; 98: /* 090 */ STRAY; STRAY; STRAY; STRAY; 99: /* 0a0 */ IS(softclock); STRAY; STRAY; STRAY; 100: /* 0b0 */ IS(netintr); STRAY; STRAY; STRAY; 101: /* 0c0 */ IS(hardclock); STRAY; KS(emulate); KS(emulateFPD); 102: /* 0d0 */ STRAY; STRAY; STRAY; STRAY; 103: /* 0e0 */ STRAY; STRAY; STRAY; STRAY; 104: /* 0f0 */ IS(consdin); IS(consdout); IS(cnrint); IS(cnxint); 105: /* 100 */ IS(nexzvec); STRAY15; /* ipl 0x14, nexus 0-15 */ 106: /* 140 */ IS(nexzvec); STRAY15; /* ipl 0x15, nexus 0-15 */ 107: /* 180 */ IS(nexzvec); STRAY15; /* ipl 0x16, nexus 0-15 */ 108: /* 1c0 */ IS(nexzvec); STRAY15; /* ipl 0x17, nexus 0-15 */ 109: 110: .globl _UNIvec 111: _UNIvec: .space 512 # 750 unibus intr vector 112: # 1st UBA jump table on 780's 113: #if NUBA > 1 114: .globl _UNI1vec 115: _UNI1vec: .space 512 # 750 second unibus intr vector 116: # 2nd UBA jump table on 780's 117: #endif 118: #define I_CLOCK 0 119: #define I_CNR 4 120: #define I_CNX 8 121: #define I_TUR 12 122: #define I_TUX 16 123: #define I_MBA0 20 124: #define I_MBA1 24 125: #define I_MBA2 28 126: #define I_MBA3 32 127: #define I_UBA0 36 128: #define I_UBA1 40 129: #define I_UBA2 44 130: #define I_UBA3 48 131: /* 132: * Copyright (c) 1980, 1986 Regents of the University of California. 133: * All rights reserved. The Berkeley software License Agreement 134: * specifies the terms and conditions for redistribution. 135: * 136: * @(#)locore.s 7.1 (Berkeley) 6/5/86 137: */ 138: 139: #include "psl.h" 140: #include "pte.h" 141: 142: #include "errno.h" 143: #include "cmap.h" 144: 145: #include "mtpr.h" 146: #include "trap.h" 147: #include "cpu.h" 148: #include "nexus.h" 149: #include "cons.h" 150: #include "clock.h" 151: #include "ioa.h" 152: #include "ka630.h" 153: #include "../vaxuba/ubareg.h" 154: 155: #include "dz.h" 156: #include "uu.h" 157: #include "ps.h" 158: #include "mba.h" 159: #include "uba.h" 160: 161: .set HIGH,0x1f # mask for total disable 162: .set MCKVEC,4 # offset into scb of machine check vector 163: .set NBPG,512 164: .set PGSHIFT,9 165: 166: .set NISP,3 # number of interrupt stack pages 167: 168: /* 169: * User structure is UPAGES at top of user space. 170: */ 171: .globl _u 172: .set _u,0x80000000 - UPAGES*NBPG 173: 174: .globl _intstack 175: _intstack: 176: .space NISP*NBPG 177: eintstack: 178: 179: /* 180: * Do a dump. 181: * Called by auto-restart. 182: * May be called manually. 183: */ 184: .align 2 185: .globl _doadump 186: _doadump: 187: nop; nop # .word 0x0101 188: #define _rpbmap _Sysmap # rpb, scb, UNI*vec, istack*4 189: bicl2 $PG_PROT,_rpbmap 190: bisl2 $PG_KW,_rpbmap 191: mtpr $0,$TBIA 192: tstl _rpb+RP_FLAG # dump only once! 193: bneq 1f 194: incl _rpb+RP_FLAG 195: movl sp,erpb 196: movab erpb,sp 197: mfpr $PCBB,-(sp) 198: mfpr $MAPEN,-(sp) 199: mfpr $IPL,-(sp) 200: mtpr $0,$MAPEN 201: mtpr $HIGH,$IPL 202: pushr $0x3fff 203: calls $0,_dumpsys 204: 1: 205: pushl $TXDB_BOOT 206: calls $1,_tocons 207: halt 208: 209: /* 210: * Interrupt vector routines 211: */ 212: .globl _waittime 213: 214: #define SCBVEC(name) .align 2; .globl _X/**/name; _X/**/name 215: #define PANIC(msg) clrl _waittime; pushab 1f; \ 216: calls $1,_panic; 1: .asciz msg 217: #define PRINTF(n,msg) pushab 1f; calls $n+1,_printf; MSG(msg) 218: #define MSG(msg) .data; 1: .asciz msg; .text 219: #define PUSHR pushr $0x3f 220: #define POPR popr $0x3f 221: 222: .data 223: nofault: .long 0 # where to go on predicted machcheck 224: .text 225: SCBVEC(machcheck): 226: tstl nofault 227: bneq 1f 228: PUSHR; pushab 6*4(sp); calls $1,_machinecheck; POPR; 229: addl2 (sp)+,sp; rei 230: .align 2 231: 1: 232: casel _cpu,$1,$VAX_MAX 233: 0: 234: .word 8f-0b # 1 is 780 235: .word 5f-0b # 2 is 750 236: .word 5f-0b # 3 is 730 237: .word 7f-0b # 4 is 8600 238: .word 1f-0b # ??? 239: .word 1f-0b # ??? 240: .word 1f-0b # ??? 241: .word 1f-0b # 8 is 630 242: 5: 243: #if defined(VAX750) || defined(VAX730) 244: mtpr $0xf,$MCESR 245: #endif 246: brb 1f 247: 7: 248: #if VAX8600 249: mtpr $0,$EHSR 250: #endif 251: brb 1f 252: 8: 253: #if VAX780 254: mtpr $0,$SBIFS 255: #endif 256: 1: 257: addl2 (sp)+,sp # discard mchchk trash 258: movl nofault,(sp) 259: rei 260: SCBVEC(kspnotval): 261: PUSHR; PANIC("KSP not valid"); 262: SCBVEC(powfail): 263: halt 264: SCBVEC(chme): SCBVEC(chms): SCBVEC(chmu): 265: PUSHR; PANIC("CHM? in kernel"); 266: SCBVEC(stray): 267: PUSHR; PRINTF(0, "stray scb interrupt\n"); POPR; 268: rei 269: SCBVEC(nexzvec): 270: PUSHR; mfpr $IPL,-(sp); PRINTF(1, "nexus stray intr ipl%x\n"); POPR; rei 271: SCBVEC(cmrd): 272: PUSHR; calls $0,_memerr; POPR; rei 273: SCBVEC(wtime): 274: PUSHR; pushl 6*4(sp); PRINTF(1,"write timeout %x\n"); POPR; 275: PANIC("wtimo"); 276: 277: #if NMBA > 0 278: SCBVEC(mba3int): 279: PUSHR; incl _intrcnt+I_MBA3; pushl $3; brb 1f 280: SCBVEC(mba2int): 281: PUSHR; incl _intrcnt+I_MBA2; pushl $2; brb 1f 282: SCBVEC(mba1int): 283: PUSHR; incl _intrcnt+I_MBA1; pushl $1; brb 1f 284: SCBVEC(mba0int): 285: PUSHR; incl _intrcnt+I_MBA0; pushl $0 286: 1: calls $1,_mbintr 287: POPR 288: incl _cnt+V_INTR 289: rei 290: #endif 291: 292: #if defined(VAX780) || defined(VAX8600) 293: /* 294: * Registers for the uba handling code 295: */ 296: #define rUBANUM r0 297: #define rUBAHD r1 298: #define rUVEC r3 299: #define rUBA r4 300: /* r2,r5 are scratch */ 301: 302: #define I_UBA I_UBA0 /* base of UBA interrupt counters */ 303: 304: #if NUBA > 4 305: SCBVEC(ua7int): 306: PUSHR; movl $7,rUBANUM; moval _uba_hd+(7*UH_SIZE),rUBAHD; brb 1f 307: SCBVEC(ua6int): 308: PUSHR; movl $6,rUBANUM; moval _uba_hd+(6*UH_SIZE),rUBAHD; brb 1f 309: SCBVEC(ua5int): 310: PUSHR; movl $5,rUBANUM; moval _uba_hd+(5*UH_SIZE),rUBAHD; brb 1f 311: SCBVEC(ua4int): 312: PUSHR; movl $4,rUBANUM; moval _uba_hd+(4*UH_SIZE),rUBAHD; brb 1f 313: #endif 314: SCBVEC(ua3int): 315: PUSHR; movl $3,rUBANUM; moval _uba_hd+(3*UH_SIZE),rUBAHD; brb 1f 316: SCBVEC(ua2int): 317: PUSHR; movl $2,rUBANUM; moval _uba_hd+(2*UH_SIZE),rUBAHD; brb 1f 318: SCBVEC(ua1int): 319: PUSHR; movl $1,rUBANUM; moval _uba_hd+(1*UH_SIZE),rUBAHD; brb 1f 320: SCBVEC(ua0int): 321: PUSHR; movl $0,rUBANUM; moval _uba_hd+(0*UH_SIZE),rUBAHD; 322: 1: 323: mfpr $IPL,r2 /* r2 = mfpr(IPL); */ 324: movl UH_UBA(rUBAHD),rUBA /* uba = uhp->uh_uba; */ 325: movl UBA_BRRVR-0x14*4(rUBA)[r2],rUVEC 326: /* uvec = uba->uba_brrvr[r2-0x14] */ 327: ubanorm: 328: bleq ubaerror 329: addl2 UH_VEC(rUBAHD),rUVEC /* uvec += uh->uh_vec */ 330: bicl3 $3,(rUVEC),r1 331: jmp 2(r1) /* 2 skips ``pushr $0x3f'' */ 332: ubaerror: 333: PUSHR; calls $0,_ubaerror; POPR /* ubaerror r/w's r0-r5 */ 334: tstl rUVEC; jneq ubanorm /* rUVEC contains result */ 335: incl _intrcnt+I_UBA[rUBANUM] 336: incl _cnt+V_INTR 337: POPR 338: rei 339: #endif 340: SCBVEC(cnrint): 341: PUSHR; calls $0,_cnrint; POPR 342: incl _cnt+V_INTR 343: incl _intrcnt+I_CNR 344: rei 345: SCBVEC(cnxint): 346: PUSHR; calls $0,_cnxint; POPR 347: incl _cnt+V_INTR 348: incl _intrcnt+I_CNX 349: rei 350: SCBVEC(hardclock): 351: PUSHR 352: mtpr $ICCS_RUN|ICCS_IE|ICCS_INT|ICCS_ERR,$ICCS 353: #if NPS > 0 354: pushl 4+6*4(sp); pushl 4+6*4(sp); 355: calls $2,_psextsync 356: #endif 357: pushl 4+6*4(sp); pushl 4+6*4(sp); 358: calls $2,_hardclock # hardclock(pc,psl) 359: POPR; 360: incl _cnt+V_INTR 361: incl _intrcnt+I_CLOCK 362: rei 363: SCBVEC(softclock): 364: PUSHR 365: pushl 4+6*4(sp); pushl 4+6*4(sp); 366: calls $2,_softclock # softclock(pc,psl) 367: POPR; 368: incl _cnt+V_SOFT 369: rei 370: 371: #include "../net/netisr.h" 372: .globl _netisr 373: SCBVEC(netintr): 374: PUSHR 375: #include "imp.h" 376: #if NIMP > 0 377: bbcc $NETISR_IMP,_netisr,1f; calls $0,_impintr; 1: 378: #endif 379: #ifdef INET 380: bbcc $NETISR_IP,_netisr,1f; calls $0,_ipintr; 1: 381: #endif 382: #ifdef NS 383: bbcc $NETISR_NS,_netisr,1f; calls $0,_nsintr; 1: 384: #endif 385: bbcc $NETISR_RAW,_netisr,1f; calls $0,_rawintr; 1: 386: POPR 387: incl _cnt+V_SOFT 388: rei 389: 390: #if defined(VAX750) || defined(VAX730) || defined(VAX8600) 391: SCBVEC(consdin): 392: PUSHR; 393: incl _intrcnt+I_TUR 394: casel _cpu,$VAX_750,$VAX_8600 395: 0: 396: .word 5f-0b # 2 is VAX_750 397: .word 3f-0b # 3 is VAX_730 398: .word 6f-0b # 4 is VAX_8600 399: halt 400: 5: 401: #if defined(VAX750) && !defined(MRSP) 402: jsb tudma 403: #endif 404: 3: 405: #if defined(VAX750) || defined(VAX730) 406: calls $0,_turintr 407: brb 2f 408: #else 409: halt 410: #endif 411: 6: 412: #if VAX8600 413: calls $0, _crlintr 414: #else 415: halt 416: #endif 417: 2: 418: POPR; 419: incl _cnt+V_INTR; 420: rei 421: #else 422: SCBVEC(consdin): 423: halt 424: #endif 425: 426: #if defined(VAX750) || defined(VAX730) 427: SCBVEC(consdout): 428: PUSHR; calls $0,_tuxintr; POPR 429: incl _cnt+V_INTR 430: incl _intrcnt+I_TUX 431: rei 432: #else 433: SCBVEC(consdout): 434: halt 435: #endif 436: 437: #if NDZ > 0 438: /* 439: * DZ pseudo dma routine: 440: * r0 - controller number 441: */ 442: .align 1 443: .globl dzdma 444: dzdma: 445: mull2 $8*20,r0 446: movab _dzpdma(r0),r3 # pdma structure base 447: # for this controller 448: dzploop: 449: movl r3,r0 450: movl (r0)+,r1 # device register address 451: movzbl 1(r1),r2 # get line number 452: bitb $0x80,r2 # TRDY on? 453: beql dzprei # no 454: bicb2 $0xf8,r2 # clear garbage bits 455: mull2 $20,r2 456: addl2 r2,r0 # point at line's pdma structure 457: movl (r0)+,r2 # p_mem 458: cmpl r2,(r0)+ # p_mem < p_end ? 459: bgequ dzpcall # no, go call dzxint 460: movb (r2)+,6(r1) # dztbuf = *p_mem++ 461: movl r2,-8(r0) 462: brb dzploop # check for another line 463: dzprei: 464: POPR 465: incl _cnt+V_PDMA 466: rei 467: 468: dzpcall: 469: pushl r3 470: pushl (r0)+ # push tty address 471: calls $1,*(r0) # call interrupt rtn 472: movl (sp)+,r3 473: brb dzploop # check for another line 474: #endif 475: 476: #if NUU > 0 && defined(UUDMA) 477: /* 478: * Pseudo DMA routine for tu58 (on DL11) 479: * r0 - controller number 480: */ 481: .align 1 482: .globl uudma 483: uudma: 484: movl _uudinfo[r0],r2 485: movl 16(r2),r2 # r2 = uuaddr 486: mull3 $48,r0,r3 487: movab _uu_softc(r3),r5 # r5 = uuc 488: 489: cvtwl 2(r2),r1 # c = uuaddr->rdb 490: bbc $15,r1,1f # if (c & UUDB_ERROR) 491: movl $13,16(r5) # uuc->tu_state = TUC_RCVERR; 492: rsb # let uurintr handle it 493: 1: 494: tstl 4(r5) # if (uuc->tu_rcnt) { 495: beql 1f 496: movb r1,*0(r5) # *uuc->tu_rbptr++ = r1 497: incl (r5) 498: decl 4(r5) # if (--uuc->tu_rcnt) 499: beql 2f # done 500: tstl (sp)+ 501: POPR # registers saved in ubglue.s 502: rei # } 503: 2: 504: cmpl 16(r5),$8 # if (uuc->tu_state != TUS_GETH) 505: beql 2f # let uurintr handle it 506: 1: 507: rsb 508: 2: 509: mull2 $14,r0 # sizeof(uudata[ctlr]) = 14 510: movab _uudata(r0),r4 # data = &uudata[ctlr]; 511: cmpb $1,(r4) # if (data->pk_flag != TUF_DATA) 512: bneq 1b 513: #ifdef notdef 514: /* this is for command packets */ 515: beql 1f # r0 = uuc->tu_rbptr 516: movl (r5),r0 517: brb 2f 518: 1: # else 519: #endif 520: movl 24(r5),r0 # r0 = uuc->tu_addr 521: 2: 522: movzbl 1(r4),r3 # counter to r3 (data->pk_count) 523: movzwl (r4),r1 # first word of checksum (=header) 524: mfpr $IPL,-(sp) # s = spl5(); 525: mtpr $0x15,$IPL # to keep disk interrupts out 526: clrw (r2) # disable receiver interrupts 527: 3: bbc $7,(r2),3b # while ((uuaddr->rcs & UUCS_READY)==0); 528: cvtwb 2(r2),(r0)+ # *buffer = uuaddr->rdb & 0xff 529: sobgtr r3,1f # continue with next byte ... 530: addw2 2(r2),r1 # unless this was the last (odd count) 531: brb 2f 532: 533: 1: bbc $7,(r2),1b # while ((uuaddr->rcs & UUCS_READY)==0); 534: cvtwb 2(r2),(r0)+ # *buffer = uuaddr->rdb & 0xff 535: addw2 -2(r0),r1 # add to checksum.. 536: 2: 537: adwc $0,r1 # get the carry 538: sobgtr r3,3b # loop while r3 > 0 539: /* 540: * We're ready to get the checksum 541: */ 542: 1: bbc $7,(r2),1b # while ((uuaddr->rcs & UUCS_READY)==0); 543: cvtwb 2(r2),12(r4) # get first (lower) byte 544: 1: bbc $7,(r2),1b 545: cvtwb 2(r2),13(r4) # ..and second 546: cmpw 12(r4),r1 # is checksum ok? 547: beql 1f 548: movl $14,16(r5) # uuc->tu_state = TUS_CHKERR 549: brb 2f # exit 550: 1: 551: movl $11,16(r5) # uuc->tu_state = TUS_GET (ok) 552: 2: 553: movw $0x40,(r2) # enable receiver interrupts 554: mtpr (sp)+,$IPL # splx(s); 555: rsb # continue processing in uurintr 556: #endif 557: 558: #if defined(VAX750) && !defined(MRSP) 559: /* 560: * Pseudo DMA routine for VAX-11/750 console tu58 561: * (without MRSP) 562: */ 563: .align 1 564: .globl tudma 565: tudma: 566: movab _tu,r5 # r5 = tu 567: tstl 4(r5) # if (tu.tu_rcnt) { 568: beql 3f 569: mfpr $CSRD,r1 # get data from tu58 570: movb r1,*0(r5) # *tu.tu_rbptr++ = r1 571: incl (r5) 572: decl 4(r5) # if (--tu.tu_rcnt) 573: beql 1f # done 574: tstl (sp)+ 575: POPR # registers saved in ubglue.s 576: rei # data handled, done 577: 1: # } 578: cmpl 16(r5),$8 # if (tu.tu_state != TUS_GETH) 579: beql 2f # let turintr handle it 580: 3: 581: rsb 582: 2: 583: movab _tudata,r4 # r4 = tudata 584: cmpb $1,(r4) # if (tudata.pk_flag != TUF_DATA) 585: bneq 3b # let turintr handle it 586: 1: # else 587: movl 24(r5),r1 # get buffer pointer to r1 588: movzbl 1(r4),r3 # counter to r3 589: movzwl (r4),r0 # first word of checksum (=header) 590: mtpr $0,$CSRS # disable receiver interrupts 591: 3: 592: bsbw 5f # wait for next byte 593: mfpr $CSRD,r5 594: movb r5,(r1)+ # *buffer = rdb 595: sobgtr r3,1f # continue with next byte ... 596: mfpr $CSRD,r2 # unless this was the last (odd count) 597: brb 2f 598: 599: 1: bsbw 5f # wait for next byte 600: mfpr $CSRD,r5 601: movb r5,(r1)+ # *buffer = rdb 602: movzwl -2(r1),r2 # get the last word back from memory 603: 2: 604: addw2 r2,r0 # add to checksum.. 605: adwc $0,r0 # get the carry 606: sobgtr r3,3b # loop while r3 > 0 607: /* 608: * We're ready to get the checksum. 609: */ 610: bsbw 5f 611: movab _tudata,r4 612: mfpr $CSRD,r5 613: movb r5,12(r4) # get first (lower) byte 614: bsbw 5f 615: mfpr $CSRD,r5 616: movb r5,13(r4) # ..and second 617: movab _tu,r5 618: cmpw 12(r4),r0 # is checksum ok? 619: beql 1f 620: movl $14,16(r5) # tu.tu_state = TUS_CHKERR 621: brb 2f # exit 622: 1: 623: movl $11,16(r5) # tu.tu_state = TUS_GET 624: 2: 625: mtpr $0x40,$CSRS # enable receiver interrupts 626: rsb # continue processing in turintr 627: /* 628: * Loop until a new byte is ready from 629: * the tu58, make sure we don't loop forever 630: */ 631: 5: 632: movl $5000,r5 # loop max 5000 times 633: 1: 634: mfpr $CSRS,r2 635: bbs $7,r2,1f 636: sobgtr r5,1b 637: movab _tu,r5 638: movl $13,16(r5) # return TUS_RCVERR 639: tstl (sp)+ # and let turintr handle it 640: 1: 641: rsb 642: #endif 643: 644: /* 645: * Stray UNIBUS interrupt catch routines 646: */ 647: .data 648: .align 2 649: #define PJ PUSHR;jsb _Xustray 650: .globl _catcher 651: _catcher: 652: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 653: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 654: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 655: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 656: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 657: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 658: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 659: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ 660: 661: .globl _cold 662: _cold: .long 1 663: .data 664: 665: .text 666: SCBVEC(ustray): 667: blbc _cold,1f 668: mfpr $IPL,r11 669: subl3 $_catcher+8,(sp)+,r10 670: ashl $-1,r10,r10 671: POPR 672: rei 673: 1: 674: subl3 $_catcher+8,(sp)+,r0 675: ashl $-1,r0,-(sp) 676: mfpr $IPL,-(sp) 677: PRINTF(2, "uba?: stray intr ipl %x vec %o\n") 678: POPR 679: rei 680: 681: #ifdef VAX630 682: /* 683: * Emulation OpCode jump table: 684: * ONLY GOES FROM 0xf8 (-8) TO 0x3B (59) 685: */ 686: #define EMUTABLE 0x43 687: #define NOEMULATE .long noemulate 688: #define EMULATE(a) .long _EM/**/a 689: .globl _emJUMPtable 690: _emJUMPtable: 691: /* f8 */ EMULATE(ashp); EMULATE(cvtlp); NOEMULATE; NOEMULATE 692: /* fc */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 693: /* 00 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 694: /* 04 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 695: /* 08 */ EMULATE(cvtps); EMULATE(cvtsp); NOEMULATE; EMULATE(crc) 696: /* 0c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 697: /* 10 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 698: /* 14 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 699: /* 18 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 700: /* 1c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 701: /* 20 */ EMULATE(addp4); EMULATE(addp6); EMULATE(subp4); EMULATE(subp6) 702: /* 24 */ EMULATE(cvtpt); EMULATE(mulp); EMULATE(cvttp); EMULATE(divp) 703: /* 28 */ NOEMULATE; EMULATE(cmpc3); EMULATE(scanc); EMULATE(spanc) 704: /* 2c */ NOEMULATE; EMULATE(cmpc5); EMULATE(movtc); EMULATE(movtuc) 705: /* 30 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE 706: /* 34 */ EMULATE(movp); EMULATE(cmpp3); EMULATE(cvtpl); EMULATE(cmpp4) 707: /* 38 */ EMULATE(editpc); EMULATE(matchc); EMULATE(locc); EMULATE(skpc) 708: #endif 709: 710: /* 711: * Trap and fault vector routines 712: */ 713: #define TRAP(a) pushl $T_/**/a; jbr alltraps 714: 715: /* 716: * Ast delivery (profiling and/or reschedule) 717: */ 718: SCBVEC(astflt): 719: pushl $0; TRAP(ASTFLT) 720: SCBVEC(privinflt): 721: pushl $0; TRAP(PRIVINFLT) 722: SCBVEC(xfcflt): 723: pushl $0; TRAP(XFCFLT) 724: SCBVEC(resopflt): 725: pushl $0; TRAP(RESOPFLT) 726: SCBVEC(resadflt): 727: pushl $0; TRAP(RESADFLT) 728: SCBVEC(bptflt): 729: pushl $0; TRAP(BPTFLT) 730: SCBVEC(compatflt): 731: TRAP(COMPATFLT); 732: SCBVEC(tracep): 733: pushl $0; TRAP(TRCTRAP) 734: SCBVEC(arithtrap): 735: TRAP(ARITHTRAP) 736: SCBVEC(protflt): 737: blbs (sp)+,segflt 738: TRAP(PROTFLT) 739: segflt: 740: TRAP(SEGFLT) 741: 742: /* 743: * The following is called with the stack set up as follows: 744: * 745: * (sp): Opcode 746: * 4(sp): Instruction PC 747: * 8(sp): Operand 1 748: * 12(sp): Operand 2 749: * 16(sp): Operand 3 750: * 20(sp): Operand 4 751: * 24(sp): Operand 5 752: * 28(sp): Operand 6 753: * 32(sp): Operand 7 (unused) 754: * 36(sp): Operand 8 (unused) 755: * 40(sp): Return PC 756: * 44(sp): Return PSL 757: * 48(sp): TOS before instruction 758: * 759: * Each individual routine is called with the stack set up as follows: 760: * 761: * (sp): Return address of trap handler 762: * 4(sp): Opcode (will get return PSL) 763: * 8(sp): Instruction PC 764: * 12(sp): Operand 1 765: * 16(sp): Operand 2 766: * 20(sp): Operand 3 767: * 24(sp): Operand 4 768: * 28(sp): Operand 5 769: * 32(sp): Operand 6 770: * 36(sp): saved register 11 771: * 40(sp): saved register 10 772: * 44(sp): Return PC 773: * 48(sp): Return PSL 774: * 52(sp): TOS before instruction 775: */ 776: 777: SCBVEC(emulate): 778: #ifdef VAX630 779: movl r11,32(sp) # save register r11 in unused operand 780: movl r10,36(sp) # save register r10 in unused operand 781: cvtbl (sp),r10 # get opcode 782: addl2 $8,r10 # shift negative opcodes 783: subl3 r10,$EMUTABLE,r11 # forget it if opcode is out of range 784: bcs noemulate 785: movl _emJUMPtable[r10],r10 # call appropriate emulation routine 786: jsb (r10) # routines put return values into regs 0-5 787: movl 32(sp),r11 # restore register r11 788: movl 36(sp),r10 # restore register r10 789: insv (sp),$0,$4,44(sp) # and condition codes in Opcode spot 790: addl2 $40,sp # adjust stack for return 791: rei 792: noemulate: 793: addl2 $48,sp # adjust stack for 794: #endif VAX630 795: .word 0xffff # "reserved instruction fault" 796: SCBVEC(emulateFPD): 797: .word 0xffff # "reserved instruction fault" 798: SCBVEC(transflt): 799: bitl $2,(sp)+ 800: bnequ tableflt 801: jsb Fastreclaim # try and avoid pagein 802: TRAP(PAGEFLT) 803: tableflt: 804: TRAP(TABLEFLT) 805: 806: alltraps: 807: mfpr $USP,-(sp); calls $0,_trap; mtpr (sp)+,$USP 808: incl _cnt+V_TRAP 809: addl2 $8,sp # pop type, code 810: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) 811: rei 812: 813: SCBVEC(syscall): 814: pushl $T_SYSCALL 815: mfpr $USP,-(sp); calls $0,_syscall; mtpr (sp)+,$USP 816: incl _cnt+V_SYSCALL 817: addl2 $8,sp # pop type, code 818: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) 819: rei 820: 821: /* 822: * System page table 823: * Mbmap and Usrptmap are enlarged by CLSIZE entries 824: * as they are managed by resource maps starting with index 1 or CLSIZE. 825: */ 826: #define vaddr(x) ((((x)-_Sysmap)/4)*NBPG+0x80000000) 827: #define SYSMAP(mname, vname, npte) \ 828: _/**/mname: .globl _/**/mname; \ 829: .space (npte)*4; \ 830: .globl _/**/vname; \ 831: .set _/**/vname,vaddr(_/**/mname) 832: 833: .data 834: .align 2 835: SYSMAP(Sysmap ,Sysbase ,SYSPTSIZE ) 836: SYSMAP(Forkmap ,forkutl ,UPAGES ) 837: SYSMAP(Xswapmap ,xswaputl ,UPAGES ) 838: SYSMAP(Xswap2map,xswap2utl ,UPAGES ) 839: SYSMAP(Swapmap ,swaputl ,UPAGES ) 840: SYSMAP(Pushmap ,pushutl ,UPAGES ) 841: SYSMAP(Vfmap ,vfutl ,UPAGES ) 842: SYSMAP(CMAP1 ,CADDR1 ,1 ) 843: SYSMAP(CMAP2 ,CADDR2 ,1 ) 844: SYSMAP(mmap ,vmmap ,1 ) 845: SYSMAP(alignmap ,alignutl ,1 ) /* XXX */ 846: SYSMAP(msgbufmap,msgbuf ,MSGBUFPTECNT ) 847: SYSMAP(Mbmap ,mbutl ,NMBCLUSTERS*CLSIZE+CLSIZE ) 848: SYSMAP(camap ,cabase ,16*CLSIZE ) 849: #ifdef GPROF 850: SYSMAP(profmap ,profbase ,600*CLSIZE ) 851: #endif 852: SYSMAP(ecamap ,calimit ,0 ) 853: 854: SYSMAP(UMBAbeg ,umbabeg ,0 ) 855: SYSMAP(Nexmap ,nexus ,16*MAXNNEXUS ) 856: SYSMAP(UMEMmap ,umem ,UBAPAGES*NUBA ) 857: SYSMAP(Ioamap ,ioa ,MAXNIOA*IOAMAPSIZ/NBPG ) 858: SYSMAP(UMBAend ,umbaend ,0 ) 859: #if VAX630 860: SYSMAP(Clockmap ,cldevice ,1 ) 861: SYSMAP(Ka630map ,ka630cpu ,1 ) 862: #endif 863: 864: SYSMAP(Usrptmap ,usrpt ,USRPTSIZE+CLSIZE ) 865: 866: eSysmap: 867: .globl _Syssize 868: .set _Syssize,(eSysmap-_Sysmap)/4 869: .text 870: 871: /* 872: * Initialization 873: * 874: * ipl 0x1f; mapen 0; scbb, pcbb, sbr, slr, isp, ksp not set 875: */ 876: .data 877: .globl _cpu 878: _cpu: .long 0 879: .text 880: .globl start 881: start: 882: .word 0 883: mtpr $0,$ICCS 884: /* set system control block base and system page table params */ 885: mtpr $_scb-0x80000000,$SCBB 886: mtpr $_Sysmap-0x80000000,$SBR 887: mtpr $_Syssize,$SLR 888: /* double map the kernel into the virtual user addresses of phys mem */ 889: mtpr $_Sysmap,$P0BR 890: mtpr $_Syssize,$P0LR 891: /* set ISP and get cpu type */ 892: movl $_intstack+NISP*NBPG,sp 893: mfpr $SID,r0 894: movab _cpu,r1 895: extzv $24,$8,r0,(r1) 896: /* init RPB */ 897: movab _rpb,r0 898: movl r0,(r0)+ # rp_selfref 899: movab _doadump,r1 900: movl r1,(r0)+ # rp_dumprout 901: movl $0x1f,r2 902: clrl r3 903: 1: addl2 (r1)+,r3; sobgtr r2,1b 904: movl r3,(r0)+ # rp_chksum 905: /* count up memory */ 906: clrl r7 907: 1: pushl $4; pushl r7; calls $2,_badaddr; tstl r0; bneq 9f 908: acbl $MAXMEM*1024-1,$64*1024,r7,1b 909: 9: 910: #ifdef VAX630 911: /* leave an area for uVAX II console scratch pad at the top */ 912: cmpb _cpu,$VAX_630 913: bneq 1f 914: subl2 $4096,r7 915: 1: 916: #endif 917: /* clear memory from kernel bss and pages for proc 0 u. and page table */ 918: movab _edata,r6 919: movab _end,r5 920: bbcc $31,r5,0f; 0: 921: addl2 $(UPAGES*NBPG)+NBPG+NBPG,r5 922: 1: clrq (r6); acbl r5,$8,r6,1b 923: /* trap() and syscall() save r0-r11 in the entry mask (per ../h/reg.h) */ 924: /* panic() is convenient place to save all for debugging */ 925: bisw2 $0x0fff,_trap 926: bisw2 $0x0fff,_syscall 927: bisw2 $0x0fff,_panic 928: calls $0,_fixctlrmask 929: /* initialize system page table: uba vectors and int stack writeable */ 930: clrl r2 931: movab eintstack,r1; bbcc $31,r1,0f; 0: ashl $-PGSHIFT,r1,r1 932: 1: bisl3 $PG_V|PG_KW,r2,_Sysmap[r2]; aoblss r1,r2,1b 933: /* make rpb, scb read-only as red zone for interrupt stack */ 934: bicl2 $PG_PROT,_rpbmap 935: bisl2 $PG_KR,_rpbmap 936: /* make kernel text space read-only */ 937: movab _etext+NBPG-1,r1; bbcc $31,r1,0f; 0: ashl $-PGSHIFT,r1,r1 938: 1: bisl3 $PG_V|PG_URKR,r2,_Sysmap[r2]; aoblss r1,r2,1b 939: /* make kernel data, bss, read-write */ 940: movab _end+NBPG-1,r1; bbcc $31,r1,0f; 0:; ashl $-PGSHIFT,r1,r1 941: 1: bisl3 $PG_V|PG_KW,r2,_Sysmap[r2]; aoblss r1,r2,1b 942: /* now go to mapped mode */ 943: mtpr $0,$TBIA; mtpr $1,$MAPEN; jmp *$0f; 0: 944: /* init mem sizes */ 945: ashl $-PGSHIFT,r7,_maxmem 946: movl _maxmem,_physmem 947: movl _maxmem,_freemem 948: /* setup context for proc[0] == Scheduler */ 949: movab _end+NBPG-1,r6 950: bicl2 $NBPG-1,r6 # make page boundary 951: /* setup page table for proc[0] */ 952: bbcc $31,r6,0f; 0: 953: ashl $-PGSHIFT,r6,r3 # r3 = btoc(r6) 954: bisl3 $PG_V|PG_KW,r3,_Usrptmap # init first upt entry 955: incl r3 956: movab _usrpt,r0 957: mtpr r0,$TBIS 958: /* init p0br, p0lr */ 959: mtpr r0,$P0BR 960: mtpr $0,$P0LR 961: /* init p1br, p1lr */ 962: movab NBPG(r0),r0 963: movl $0x200000-UPAGES,r1 964: mtpr r1,$P1LR 965: mnegl r1,r1 966: moval -4*UPAGES(r0)[r1],r2 967: mtpr r2,$P1BR 968: /* setup mapping for UPAGES of _u */ 969: movl $UPAGES,r2; movab _u+NBPG*UPAGES,r1; addl2 $UPAGES,r3; jbr 2f 970: 1: decl r3 971: moval -NBPG(r1),r1; 972: bisl3 $PG_V|PG_URKW,r3,-(r0) 973: mtpr r1,$TBIS 974: 2: sobgeq r2,1b 975: /* initialize (slightly) the pcb */ 976: movab UPAGES*NBPG(r1),PCB_KSP(r1) 977: mnegl $1,PCB_ESP(r1) 978: mnegl $1,PCB_SSP(r1) 979: movl r1,PCB_USP(r1) 980: mfpr $P0BR,PCB_P0BR(r1) 981: mfpr $P0LR,PCB_P0LR(r1) 982: movb $4,PCB_P0LR+3(r1) # disable ast 983: mfpr $P1BR,PCB_P1BR(r1) 984: mfpr $P1LR,PCB_P1LR(r1) 985: movl $CLSIZE,PCB_SZPT(r1) # init u.u_pcb.pcb_szpt 986: movl r10,PCB_R10(r1) 987: movl r11,PCB_R11(r1) 988: movab 1f,PCB_PC(r1) # initial pc 989: clrl PCB_PSL(r1) # mode(k,k), ipl=0 990: ashl $PGSHIFT,r3,r3 991: mtpr r3,$PCBB # first pcbb 992: /* set regs, p0br, p0lr, p1br, p1lr, astlvl, ksp and change to kernel mode */ 993: ldpctx 994: rei 995: /* put signal trampoline code in u. area */ 996: 1: movab _u,r0 997: movc3 $19,sigcode,PCB_SIGC(r0) 998: /* save boot device in global _bootdev */ 999: movl r10,_bootdev 1000: /* save reboot flags in global _boothowto */ 1001: movl r11,_boothowto 1002: /* calculate firstaddr, and call main() */ 1003: movab _end+NBPG-1,r0; bbcc $31,r0,0f; 0:; ashl $-PGSHIFT,r0,-(sp) 1004: addl2 $UPAGES+1,(sp); calls $1,_main 1005: /* proc[1] == /etc/init now running here; run icode */ 1006: pushl $PSL_CURMOD|PSL_PRVMOD; pushl $0; rei 1007: 1008: /* signal trampoline code: it is known that this code takes exactly 19 bytes */ 1009: /* in ../vax/pcb.h and in the movc3 above */ 1010: sigcode: 1011: calls $4,8(pc) # params pushed by sendsig 1012: movl sp,ap # calls frame built by sendsig 1013: chmk $103 # cleanup mask and onsigstack 1014: halt # sigreturn() does not return! 1015: .word 0x3f # registers 0-5 1016: callg (ap),*16(ap) # call the signal handler 1017: ret # return to code above 1018: 1019: .set exec,11 1020: .set exit,1 1021: .globl _icode 1022: .globl _initflags 1023: .globl _szicode 1024: /* 1025: * Icode is copied out to process 1 to exec /etc/init. 1026: * If the exec fails, process 1 exits. 1027: */ 1028: _icode: 1029: pushab b`argv-l0(pc) 1030: l0: pushab b`init-l1(pc) 1031: l1: pushl $2 1032: movl sp,ap 1033: chmk $exec 1034: chmk $exit 1035: 1036: init: .asciz "/etc/init" 1037: .align 2 1038: _initflags: 1039: .long 0 1040: argv: .long init+5-_icode 1041: .long _initflags-_icode 1042: .long 0 1043: _szicode: 1044: .long _szicode-_icode 1045: 1046: /* 1047: * Primitives 1048: */ 1049: 1050: #ifdef GPROF 1051: #define ENTRY(name, regs) \ 1052: .globl _/**/name; .align 1; _/**/name: .word regs; jsb mcount 1053: #define JSBENTRY(name, regs) \ 1054: .globl _/**/name; _/**/name: \ 1055: movl fp,-(sp); movab -12(sp),fp; pushr $(regs); jsb mcount; \ 1056: popr $(regs); movl (sp)+,fp 1057: #else 1058: #define ENTRY(name, regs) \ 1059: .globl _/**/name; .align 1; _/**/name: .word regs 1060: #define JSBENTRY(name, regs) \ 1061: .globl _/**/name; _/**/name: 1062: #endif GPROF 1063: #define R0 0x01 1064: #define R1 0x02 1065: #define R2 0x04 1066: #define R3 0x08 1067: #define R4 0x10 1068: #define R5 0x20 1069: #define R6 0x40 1070: 1071: /* 1072: * badaddr(addr, len) 1073: * see if access addr with a len type instruction causes a machine check 1074: * len is length of access (1=byte, 2=short, 4=long) 1075: */ 1076: .globl _badaddr 1077: _badaddr: 1078: .word 0 1079: movl $1,r0 1080: mfpr $IPL,r1 1081: mtpr $HIGH,$IPL 1082: movl 4(ap),r3 1083: movl 8(ap),r4 1084: movab 2f,nofault # jump to 2f on machcheck 1085: bbc $0,r4,1f; tstb (r3) 1086: 1: bbc $1,r4,1f; tstw (r3) 1087: 1: bbc $2,r4,1f; tstl (r3) 1088: 1: clrl r0 # made it w/o machine checks 1089: 2: clrl nofault 1090: mtpr r1,$IPL 1091: ret 1092: 1093: /* 1094: * update profiling information for the user 1095: * addupc(pc, &u.u_prof, ticks) 1096: */ 1097: ENTRY(addupc, 0) 1098: movl 8(ap),r2 # &u.u_prof 1099: subl3 8(r2),4(ap),r0 # corrected pc 1100: blss 9f 1101: extzv $1,$31,r0,r0 # logical right shift 1102: extzv $1,$31,12(r2),r1 # ditto for scale 1103: emul r1,r0,$0,r0 1104: ashq $-14,r0,r0 1105: tstl r1 1106: bneq 9f 1107: bicl2 $1,r0 1108: cmpl r0,4(r2) # length 1109: bgequ 9f 1110: addl2 (r2),r0 # base 1111: probew $3,$2,(r0) 1112: beql 8f 1113: addw2 12(ap),(r0) 1114: 9: 1115: ret 1116: 8: 1117: clrl 12(r2) 1118: ret 1119: 1120: /* 1121: * Copy a null terminated string from the user address space into 1122: * the kernel address space. 1123: * 1124: * copyinstr(fromaddr, toaddr, maxlength, &lencopied) 1125: */ 1126: ENTRY(copyinstr, R6) 1127: movl 12(ap),r6 # r6 = max length 1128: jlss 8f 1129: movl 4(ap),r1 # r1 = user address 1130: bicl3 $~(NBPG*CLSIZE-1),r1,r2 # r2 = bytes on first page 1131: subl3 r2,$NBPG*CLSIZE,r2 1132: movl 8(ap),r3 # r3 = kernel address 1133: 1: 1134: cmpl r6,r2 # r2 = min(bytes on page, length left); 1135: jgeq 2f 1136: movl r6,r2 1137: 2: 1138: prober $3,r2,(r1) # bytes accessible? 1139: jeql 8f 1140: subl2 r2,r6 # update bytes left count 1141: #ifdef NOSUBSINST 1142: # fake the locc instr. for processors that don't have it 1143: movl r2,r0 1144: 6: 1145: tstb (r1)+ 1146: jeql 5f 1147: sobgtr r0,6b 1148: jbr 7f 1149: 5: 1150: decl r1 1151: jbr 3f 1152: 7: 1153: #else 1154: locc $0,r2,(r1) # null byte found? 1155: jneq 3f 1156: #endif 1157: subl2 r2,r1 # back up pointer updated by `locc' 1158: movc3 r2,(r1),(r3) # copy in next piece 1159: movl $(NBPG*CLSIZE),r2 # check next page 1160: tstl r6 # run out of space? 1161: jneq 1b 1162: movl $ENOENT,r0 # set error code and return 1163: jbr 9f 1164: 3: 1165: tstl 16(ap) # return length? 1166: beql 4f 1167: subl3 r6,12(ap),r6 # actual len = maxlen - unused pages 1168: subl2 r0,r6 # - unused on this page 1169: addl3 $1,r6,*16(ap) # + the null byte 1170: 4: 1171: subl2 r0,r2 # r2 = number of bytes to move 1172: subl2 r2,r1 # back up pointer updated by `locc' 1173: incl r2 # copy null byte as well 1174: movc3 r2,(r1),(r3) # copy in last piece 1175: clrl r0 # redundant 1176: ret 1177: 8: 1178: movl $EFAULT,r0 1179: 9: 1180: tstl 16(ap) 1181: beql 1f 1182: subl3 r6,12(ap),*16(ap) 1183: 1: 1184: ret 1185: 1186: /* 1187: * Copy a null terminated string from the kernel 1188: * address space to the user address space. 1189: * 1190: * copyoutstr(fromaddr, toaddr, maxlength, &lencopied) 1191: */ 1192: ENTRY(copyoutstr, R6) 1193: movl 12(ap),r6 # r6 = max length 1194: jlss 8b 1195: movl 4(ap),r1 # r1 = kernel address 1196: movl 8(ap),r3 # r3 = user address 1197: bicl3 $~(NBPG*CLSIZE-1),r3,r2 # r2 = bytes on first page 1198: subl3 r2,$NBPG*CLSIZE,r2 1199: 1: 1200: cmpl r6,r2 # r2 = min(bytes on page, length left); 1201: jgeq 2f 1202: movl r6,r2 1203: 2: 1204: probew $3,r2,(r3) # bytes accessible? 1205: jeql 8b 1206: subl2 r2,r6 # update bytes left count 1207: #ifdef NOSUBSINST 1208: # fake the locc instr. for processors that don't have it 1209: movl r2,r0 1210: 6: 1211: tstb (r1)+ 1212: jeql 5f 1213: sobgtr r0,6b 1214: jbr 7f 1215: 5: 1216: decl r1 1217: jbr 3b 1218: 7: 1219: #else 1220: locc $0,r2,(r1) # null byte found? 1221: jneq 3b 1222: #endif 1223: subl2 r2,r1 # back up pointer updated by `locc' 1224: movc3 r2,(r1),(r3) # copy in next piece 1225: movl $(NBPG*CLSIZE),r2 # check next page 1226: tstl r6 # run out of space? 1227: jneq 1b 1228: movl $ENOENT,r0 # set error code and return 1229: jbr 9b 1230: 1231: /* 1232: * Copy a null terminated string from one point to another in 1233: * the kernel address space. 1234: * 1235: * copystr(fromaddr, toaddr, maxlength, &lencopied) 1236: */ 1237: ENTRY(copystr, R6) 1238: movl 12(ap),r6 # r6 = max length 1239: jlss 8b 1240: movl 4(ap),r1 # r1 = src address 1241: movl 8(ap),r3 # r3 = dest address 1242: 1: 1243: movzwl $65535,r2 # r2 = bytes in first chunk 1244: cmpl r6,r2 # r2 = min(bytes in chunk, length left); 1245: jgeq 2f 1246: movl r6,r2 1247: 2: 1248: subl2 r2,r6 # update bytes left count 1249: #ifdef NOSUBSINST 1250: # fake the locc instr. for processors that don't have it 1251: movl r2,r0 1252: 6: 1253: tstb (r1)+ 1254: jeql 5f 1255: sobgtr r0,6b 1256: jbr 7f 1257: 5: 1258: decl r1 1259: jbr 3b 1260: 7: 1261: #else 1262: locc $0,r2,(r1) # null byte found? 1263: jneq 3b 1264: #endif 1265: subl2 r2,r1 # back up pointer updated by `locc' 1266: movc3 r2,(r1),(r3) # copy in next piece 1267: tstl r6 # run out of space? 1268: jneq 1b 1269: movl $ENOENT,r0 # set error code and return 1270: jbr 9b 1271: 1272: /* 1273: * Copy specified amount of data from user space into the kernel 1274: * Copyin(from, to, len) 1275: * r1 == from (user source address) 1276: * r3 == to (kernel destination address) 1277: * r5 == length 1278: */ 1279: .align 1 1280: JSBENTRY(Copyin, R1|R3|R5) 1281: cmpl r5,$(NBPG*CLSIZE) # probing one page or less ? 1282: bgtru 1f # no 1283: prober $3,r5,(r1) # bytes accessible ? 1284: beql ersb # no 1285: movc3 r5,(r1),(r3) 1286: /* clrl r0 # redundant */ 1287: rsb 1288: 1: 1289: blss ersb # negative length? 1290: pushl r6 # r6 = length 1291: movl r5,r6 1292: bicl3 $~(NBPG*CLSIZE-1),r1,r0 # r0 = bytes on first page 1293: subl3 r0,$(NBPG*CLSIZE),r0 1294: addl2 $(NBPG*CLSIZE),r0 # plus one additional full page 1295: jbr 2f 1296: 1297: ciloop: 1298: movc3 r0,(r1),(r3) 1299: movl $(2*NBPG*CLSIZE),r0 # next amount to move 1300: 2: 1301: cmpl r0,r6 1302: bleq 3f 1303: movl r6,r0 1304: 3: 1305: prober $3,r0,(r1) # bytes accessible ? 1306: beql ersb1 # no 1307: subl2 r0,r6 # last move? 1308: bneq ciloop # no 1309: 1310: movc3 r0,(r1),(r3) 1311: /* clrl r0 # redundant */ 1312: movl (sp)+,r6 # restore r6 1313: rsb 1314: 1315: ersb1: 1316: movl (sp)+,r6 # restore r6 1317: ersb: 1318: movl $EFAULT,r0 1319: rsb 1320: 1321: /* 1322: * Copy specified amount of data from kernel to the user space 1323: * Copyout(from, to, len) 1324: * r1 == from (kernel source address) 1325: * r3 == to (user destination address) 1326: * r5 == length 1327: */ 1328: .align 1 1329: JSBENTRY(Copyout, R1|R3|R5) 1330: cmpl r5,$(NBPG*CLSIZE) # moving one page or less ? 1331: bgtru 1f # no 1332: probew $3,r5,(r3) # bytes writeable? 1333: beql ersb # no 1334: movc3 r5,(r1),(r3) 1335: /* clrl r0 # redundant */ 1336: rsb 1337: 1: 1338: blss ersb # negative length? 1339: pushl r6 # r6 = length 1340: movl r5,r6 1341: bicl3 $~(NBPG*CLSIZE-1),r3,r0 # r0 = bytes on first page 1342: subl3 r0,$(NBPG*CLSIZE),r0 1343: addl2 $(NBPG*CLSIZE),r0 # plus one additional full page 1344: jbr 2f 1345: 1346: coloop: 1347: movc3 r0,(r1),(r3) 1348: movl $(2*NBPG*CLSIZE),r0 # next amount to move 1349: 2: 1350: cmpl r0,r6 1351: bleq 3f 1352: movl r6,r0 1353: 3: 1354: probew $3,r0,(r3) # bytes writeable? 1355: beql ersb1 # no 1356: subl2 r0,r6 # last move? 1357: bneq coloop # no 1358: 1359: movc3 r0,(r1),(r3) 1360: /* clrl r0 # redundant */ 1361: movl (sp)+,r6 # restore r6 1362: rsb 1363: 1364: /* 1365: * non-local goto's 1366: */ 1367: #ifdef notdef /* this is now expanded completely inline */ 1368: .align 1 1369: JSBENTRY(Setjmp, R0) 1370: movl fp,(r0)+ # current stack frame 1371: movl (sp),(r0) # resuming pc 1372: clrl r0 1373: rsb 1374: #endif 1375: 1376: #define PCLOC 16 /* location of pc in calls frame */ 1377: #define APLOC 8 /* location of ap,fp in calls frame */ 1378: .align 1 1379: JSBENTRY(Longjmp, R0) 1380: movl (r0)+,newfp # must save parameters in memory as all 1381: movl (r0),newpc # registers may be clobbered. 1382: 1: 1383: cmpl fp,newfp # are we there yet? 1384: bgequ 2f # yes 1385: moval 1b,PCLOC(fp) # redirect return pc to us! 1386: ret # pop next frame 1387: 2: 1388: beql 3f # did we miss our frame? 1389: pushab 4f # yep ?!? 1390: calls $1,_panic 1391: 3: 1392: movl newpc,r0 # all done, just return to the `setjmp' 1393: jmp (r0) # ``rsb'' 1394: 1395: .data 1396: newpc: .space 4 1397: newfp: .space 4 1398: 4: .asciz "longjmp" 1399: .text 1400: /* 1401: * setjmp that saves all registers as the call frame may not 1402: * be available to recover them in the usual mannor by longjmp. 1403: * Called before swapping out the u. area, restored by resume() 1404: * below. 1405: */ 1406: ENTRY(savectx, 0) 1407: movl 4(ap),r0 1408: movq r6,(r0)+ 1409: movq r8,(r0)+ 1410: movq r10,(r0)+ 1411: movq APLOC(fp),(r0)+ # save ap, fp 1412: addl3 $8,ap,(r0)+ # save sp 1413: movl PCLOC(fp),(r0) # save pc 1414: clrl r0 1415: ret 1416: 1417: .globl _whichqs 1418: .globl _qs 1419: .globl _cnt 1420: 1421: .globl _noproc 1422: .comm _noproc,4 1423: .globl _runrun 1424: .comm _runrun,4 1425: 1426: /* 1427: * The following primitives use the fancy VAX instructions 1428: * much like VMS does. _whichqs tells which of the 32 queues _qs 1429: * have processes in them. Setrq puts processes into queues, Remrq 1430: * removes them from queues. The running process is on no queue, 1431: * other processes are on a queue related to p->p_pri, divided by 4 1432: * actually to shrink the 0-127 range of priorities into the 32 available 1433: * queues. 1434: */ 1435: 1436: /* 1437: * Setrq(p), using fancy VAX instructions. 1438: * 1439: * Call should be made at splclock(), and p->p_stat should be SRUN 1440: */ 1441: .align 1 1442: JSBENTRY(Setrq, R0) 1443: tstl P_RLINK(r0) ## firewall: p->p_rlink must be 0 1444: beql set1 ## 1445: pushab set3 ## 1446: calls $1,_panic ## 1447: set1: 1448: movzbl P_PRI(r0),r1 # put on queue which is p->p_pri / 4 1449: ashl $-2,r1,r1 1450: movaq _qs[r1],r2 1451: insque (r0),*4(r2) # at end of queue 1452: bbss r1,_whichqs,set2 # mark queue non-empty 1453: set2: 1454: rsb 1455: 1456: set3: .asciz "setrq" 1457: 1458: /* 1459: * Remrq(p), using fancy VAX instructions 1460: * 1461: * Call should be made at splclock(). 1462: */ 1463: .align 1 1464: JSBENTRY(Remrq, R0) 1465: movzbl P_PRI(r0),r1 1466: ashl $-2,r1,r1 1467: bbsc r1,_whichqs,rem1 1468: pushab rem3 # it wasn't recorded to be on its q 1469: calls $1,_panic 1470: rem1: 1471: remque (r0),r2 1472: beql rem2 1473: bbss r1,_whichqs,rem2 1474: rem2: 1475: clrl P_RLINK(r0) ## for firewall checking 1476: rsb 1477: 1478: rem3: .asciz "remrq" 1479: 1480: /* 1481: * Masterpaddr is the p->p_addr of the running process on the master 1482: * processor. When a multiprocessor system, the slave processors will have 1483: * an array of slavepaddr's. 1484: */ 1485: .globl _masterpaddr 1486: .data 1487: _masterpaddr: 1488: .long 0 1489: 1490: .set ASTLVL_NONE,4 1491: .text 1492: sw0: .asciz "swtch" 1493: 1494: /* 1495: * When no processes are on the runq, Swtch branches to idle 1496: * to wait for something to come ready. 1497: */ 1498: .globl Idle 1499: Idle: idle: 1500: mtpr $0,$IPL # must allow interrupts here 1501: tstl _whichqs # look for non-empty queue 1502: bneq sw1 1503: brb idle 1504: 1505: badsw: pushab sw0 1506: calls $1,_panic 1507: /*NOTREACHED*/ 1508: 1509: /* 1510: * Swtch(), using fancy VAX instructions 1511: */ 1512: .align 1 1513: JSBENTRY(Swtch, 0) 1514: movl $1,_noproc 1515: incl _cnt+V_SWTCH 1516: sw1: ffs $0,$32,_whichqs,r0 # look for non-empty queue 1517: beql idle # if none, idle 1518: mtpr $0x18,$IPL # lock out all so _whichqs==_qs 1519: bbcc r0,_whichqs,sw1 # proc moved via lbolt interrupt 1520: movaq _qs[r0],r1 1521: remque *(r1),r2 # r2 = p = highest pri process 1522: bvs badsw # make sure something was there 1523: sw2: beql sw3 1524: insv $1,r0,$1,_whichqs # still more procs in this queue 1525: sw3: 1526: clrl _noproc 1527: clrl _runrun 1528: tstl P_WCHAN(r2) ## firewalls 1529: bneq badsw ## 1530: cmpb P_STAT(r2),$SRUN ## 1531: bneq badsw ## 1532: clrl P_RLINK(r2) ## 1533: movl *P_ADDR(r2),r0 1534: #ifdef notdef 1535: cmpl r0,_masterpaddr # resume of current proc is easy 1536: beql res0 1537: #endif 1538: movl r0,_masterpaddr 1539: ashl $PGSHIFT,r0,r0 # r0 = pcbb(p) 1540: /* fall into... */ 1541: 1542: /* 1543: * Resume(pf) 1544: */ 1545: JSBENTRY(Resume, R0) 1546: mtpr $HIGH,$IPL # no interrupts, please 1547: movl _CMAP2,_u+PCB_CMAP2 # yech 1548: svpctx 1549: mtpr r0,$PCBB 1550: ldpctx 1551: movl _u+PCB_CMAP2,_CMAP2 # yech 1552: mtpr $_CADDR2,$TBIS 1553: res0: 1554: tstl _u+PCB_SSWAP 1555: bneq res1 1556: rei 1557: res1: 1558: movl _u+PCB_SSWAP,r0 # longjmp to saved context 1559: clrl _u+PCB_SSWAP 1560: movq (r0)+,r6 1561: movq (r0)+,r8 1562: movq (r0)+,r10 1563: movq (r0)+,r12 1564: movl (r0)+,r1 1565: cmpl r1,sp # must be a pop 1566: bgequ 1f 1567: pushab 2f 1568: calls $1,_panic 1569: /* NOTREACHED */ 1570: 1: 1571: movl r1,sp 1572: movl (r0),(sp) # address to return to 1573: movl $PSL_PRVMOD,4(sp) # ``cheating'' (jfr) 1574: rei 1575: 1576: 2: .asciz "ldctx" 1577: 1578: /* 1579: * {fu,su},{byte,word}, all massaged by asm.sed to jsb's 1580: */ 1581: .align 1 1582: JSBENTRY(Fuword, R0) 1583: prober $3,$4,(r0) 1584: beql fserr 1585: movl (r0),r0 1586: rsb 1587: fserr: 1588: mnegl $1,r0 1589: rsb 1590: 1591: .align 1 1592: JSBENTRY(Fubyte, R0) 1593: prober $3,$1,(r0) 1594: beql fserr 1595: movzbl (r0),r0 1596: rsb 1597: 1598: .align 1 1599: JSBENTRY(Suword, R0|R1) 1600: probew $3,$4,(r0) 1601: beql fserr 1602: movl r1,(r0) 1603: clrl r0 1604: rsb 1605: 1606: .align 1 1607: JSBENTRY(Subyte, R0|R1) 1608: probew $3,$1,(r0) 1609: beql fserr 1610: movb r1,(r0) 1611: clrl r0 1612: rsb 1613: 1614: /* 1615: * Copy 1 relocation unit (NBPG bytes) 1616: * from user virtual address to physical address 1617: */ 1618: ENTRY(copyseg, 0) 1619: bisl3 $PG_V|PG_KW,8(ap),_CMAP2 1620: mtpr $_CADDR2,$TBIS # invalidate entry for copy 1621: movc3 $NBPG,*4(ap),_CADDR2 1622: ret 1623: 1624: /* 1625: * zero out physical memory 1626: * specified in relocation units (NBPG bytes) 1627: */ 1628: ENTRY(clearseg, 0) 1629: bisl3 $PG_V|PG_KW,4(ap),_CMAP1 1630: mtpr $_CADDR1,$TBIS 1631: movc5 $0,(sp),$0,$NBPG,_CADDR1 1632: ret 1633: 1634: /* 1635: * Check address. 1636: * Given virtual address, byte count, and rw flag 1637: * returns 0 on no access. 1638: */ 1639: ENTRY(useracc, 0) 1640: movl 4(ap),r0 # get va 1641: movl 8(ap),r1 # count 1642: tstl 12(ap) # test for read access ? 1643: bneq userar # yes 1644: cmpl $NBPG,r1 # can we do it in one probe ? 1645: bgeq uaw2 # yes 1646: uaw1: 1647: probew $3,$NBPG,(r0) 1648: beql uaerr # no access 1649: addl2 $NBPG,r0 1650: acbl $NBPG+1,$-NBPG,r1,uaw1 1651: uaw2: 1652: probew $3,r1,(r0) 1653: beql uaerr 1654: movl $1,r0 1655: ret 1656: 1657: userar: 1658: cmpl $NBPG,r1 1659: bgeq uar2 1660: uar1: 1661: prober $3,$NBPG,(r0) 1662: beql uaerr 1663: addl2 $NBPG,r0 1664: acbl $NBPG+1,$-NBPG,r1,uar1 1665: uar2: 1666: prober $3,r1,(r0) 1667: beql uaerr 1668: movl $1,r0 1669: ret 1670: uaerr: 1671: clrl r0 1672: ret 1673: 1674: /* 1675: * kernacc - check for kernel access privileges 1676: * 1677: * We can't use the probe instruction directly because 1678: * it ors together current and previous mode. 1679: */ 1680: ENTRY(kernacc, 0) 1681: movl 4(ap),r0 # virtual address 1682: bbcc $31,r0,kacc1 1683: bbs $30,r0,kacerr 1684: mfpr $SBR,r2 # address and length of page table (system) 1685: bbss $31,r2,0f; 0: 1686: mfpr $SLR,r3 1687: brb kacc2 1688: kacc1: 1689: bbsc $30,r0,kacc3 1690: mfpr $P0BR,r2 # user P0 1691: mfpr $P0LR,r3 1692: brb kacc2 1693: kacc3: 1694: mfpr $P1BR,r2 # user P1 (stack) 1695: mfpr $P1LR,r3 1696: kacc2: 1697: addl3 8(ap),r0,r1 # ending virtual address 1698: addl2 $NBPG-1,r1 1699: ashl $-PGSHIFT,r0,r0 1700: ashl $-PGSHIFT,r1,r1 1701: bbs $31,4(ap),kacc6 1702: bbc $30,4(ap),kacc6 1703: cmpl r0,r3 # user stack 1704: blss kacerr # address too low 1705: brb kacc4 1706: kacc6: 1707: cmpl r1,r3 # compare last page to P0LR or SLR 1708: bgtr kacerr # address too high 1709: kacc4: 1710: movl (r2)[r0],r3 1711: bbc $31,4(ap),kacc4a 1712: bbc $31,r3,kacerr # valid bit is off 1713: kacc4a: 1714: cmpzv $27,$4,r3,$1 # check protection code 1715: bleq kacerr # no access allowed 1716: tstb 12(ap) 1717: bneq kacc5 # only check read access 1718: cmpzv $27,$2,r3,$3 # check low 2 bits of prot code 1719: beql kacerr # no write access 1720: kacc5: 1721: aoblss r1,r0,kacc4 # next page 1722: movl $1,r0 # no errors 1723: ret 1724: kacerr: 1725: clrl r0 # error 1726: ret 1727: /* 1728: * Extracted and unrolled most common case of pagein (hopefully): 1729: * resident and not on free list (reclaim of page is purely 1730: * for the purpose of simulating a reference bit) 1731: * 1732: * Built in constants: 1733: * CLSIZE of 2, any bit fields in pte's 1734: */ 1735: .text 1736: .globl Fastreclaim 1737: Fastreclaim: 1738: PUSHR 1739: #ifdef GPROF 1740: movl fp,-(sp) 1741: movab 12(sp),fp 1742: jsb mcount 1743: movl (sp)+,fp 1744: #endif GPROF 1745: extzv $9,$23,28(sp),r3 # virtual address 1746: bicl2 $1,r3 # v = clbase(btop(virtaddr)); 1747: movl _u+U_PROCP,r5 # p = u.u_procp 1748: # from vtopte(p, v) ... 1749: movl $1,r2 # type = CTEXT; 1750: cmpl r3,P_TSIZE(r5) 1751: jlssu 1f # if (isatsv(p, v)) { 1752: addl3 P_TSIZE(r5),P_DSIZE(r5),r0 1753: cmpl r3,r0 1754: jgequ 2f 1755: clrl r2 # type = !CTEXT; 1756: 1: 1757: ashl $2,r3,r4 1758: addl2 P_P0BR(r5),r4 # tptopte(p, vtotp(p, v)); 1759: jbr 3f 1760: 2: 1761: cvtwl P_SZPT(r5),r4 # } else (isassv(p, v)) { 1762: ashl $7,r4,r4 1763: subl2 $0x400000,r4 1764: addl2 r3,r4 1765: ashl $2,r4,r4 1766: addl2 P_P0BR(r5),r4 # sptopte(p, vtosp(p, v)); 1767: clrl r2 # type = !CTEXT; 1768: 3: # } 1769: bitb $0x82,3(r4) 1770: beql 2f # if (pte->pg_v || pte->pg_fod) 1771: POPR; rsb # let pagein handle it 1772: 2: 1773: bicl3 $0xffe00000,(r4),r0 1774: jneq 2f # if (pte->pg_pfnum == 0) 1775: POPR; rsb # let pagein handle it 1776: 2: 1777: subl2 _firstfree,r0 1778: ashl $-1,r0,r0 1779: incl r0 # pgtocm(pte->pg_pfnum) 1780: mull2 $SZ_CMAP,r0 1781: addl2 _cmap,r0 # &cmap[pgtocm(pte->pg_pfnum)] 1782: tstl r2 1783: jeql 2f # if (type == CTEXT && 1784: jbc $C_INTRANS,(r0),2f # c_intrans) 1785: POPR; rsb # let pagein handle it 1786: 2: 1787: jbc $C_FREE,(r0),2f # if (c_free) 1788: POPR; rsb # let pagein handle it 1789: 2: 1790: bisb2 $0x80,3(r4) # pte->pg_v = 1; 1791: jbc $26,4(r4),2f # if (anycl(pte, pg_m) 1792: bisb2 $0x04,3(r4) # pte->pg_m = 1; 1793: 2: 1794: bicw3 $0x7f,2(r4),r0 1795: bicw3 $0xff80,6(r4),r1 1796: bisw3 r0,r1,6(r4) # distcl(pte); 1797: ashl $PGSHIFT,r3,r0 1798: mtpr r0,$TBIS 1799: addl2 $NBPG,r0 1800: mtpr r0,$TBIS # tbiscl(v); 1801: tstl r2 1802: jeql 2f # if (type == CTEXT) 1803: movl P_TEXTP(r5),r0 1804: movl X_CADDR(r0),r5 # for (p = p->p_textp->x_caddr; p; ) { 1805: jeql 2f 1806: ashl $2,r3,r3 1807: 3: 1808: addl3 P_P0BR(r5),r3,r0 # tpte = tptopte(p, tp); 1809: bisb2 $1,P_FLAG+3(r5) # p->p_flag |= SPTECHG; 1810: movl (r4),(r0)+ # for (i = 0; i < CLSIZE; i++) 1811: movl 4(r4),(r0) # tpte[i] = pte[i]; 1812: movl P_XLINK(r5),r5 # p = p->p_xlink; 1813: jneq 3b # } 1814: 2: # collect a few statistics... 1815: incl _u+U_RU+RU_MINFLT # u.u_ru.ru_minflt++; 1816: moval _cnt,r0 1817: incl V_FAULTS(r0) # cnt.v_faults++; 1818: incl V_PGREC(r0) # cnt.v_pgrec++; 1819: incl V_FASTPGREC(r0) # cnt.v_fastpgrec++; 1820: incl V_TRAP(r0) # cnt.v_trap++; 1821: POPR 1822: addl2 $8,sp # pop pc, code 1823: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) 1824: rei 1825: .globl _Xrkintr0 1826: .align 2 1827: _Xrkintr0: 1828: pushr $0x3f 1829: incl _fltintrcnt+(4*0) 1830: pushl $0 1831: calls $1,_rkintr 1832: popr $0x3f 1833: incl _cnt+V_INTR 1834: rei 1835: 1836: .globl _Xtmintr0 1837: .align 2 1838: _Xtmintr0: 1839: pushr $0x3f 1840: incl _fltintrcnt+(4*1) 1841: pushl $0 1842: calls $1,_tmintr 1843: popr $0x3f 1844: incl _cnt+V_INTR 1845: rei 1846: 1847: .globl _Xutintr0 1848: .align 2 1849: _Xutintr0: 1850: pushr $0x3f 1851: incl _fltintrcnt+(4*2) 1852: pushl $0 1853: calls $1,_utintr 1854: popr $0x3f 1855: incl _cnt+V_INTR 1856: rei 1857: 1858: .globl _Xtmscpintr0 1859: .align 2 1860: _Xtmscpintr0: 1861: pushr $0x3f 1862: incl _fltintrcnt+(4*3) 1863: pushl $0 1864: calls $1,_tmscpintr 1865: popr $0x3f 1866: incl _cnt+V_INTR 1867: rei 1868: 1869: .globl _Xupintr0 1870: .align 2 1871: _Xupintr0: 1872: pushr $0x3f 1873: incl _fltintrcnt+(4*4) 1874: pushl $0 1875: calls $1,_upintr 1876: popr $0x3f 1877: incl _cnt+V_INTR 1878: rei 1879: 1880: .globl _Xudintr0 1881: .align 2 1882: _Xudintr0: 1883: pushr $0x3f 1884: incl _fltintrcnt+(4*5) 1885: pushl $0 1886: calls $1,_udintr 1887: popr $0x3f 1888: incl _cnt+V_INTR 1889: rei 1890: 1891: .globl _Xidcintr0 1892: .align 2 1893: _Xidcintr0: 1894: pushr $0x3f 1895: incl _fltintrcnt+(4*6) 1896: pushl $0 1897: calls $1,_idcintr 1898: popr $0x3f 1899: incl _cnt+V_INTR 1900: rei 1901: 1902: .globl _Xrlintr0 1903: .align 2 1904: _Xrlintr0: 1905: pushr $0x3f 1906: incl _fltintrcnt+(4*7) 1907: pushl $0 1908: calls $1,_rlintr 1909: popr $0x3f 1910: incl _cnt+V_INTR 1911: rei 1912: 1913: .globl _Xdhrint0 1914: .align 2 1915: _Xdhrint0: 1916: pushr $0x3f 1917: incl _fltintrcnt+(4*8) 1918: pushl $0 1919: calls $1,_dhrint 1920: popr $0x3f 1921: incl _cnt+V_INTR 1922: rei 1923: 1924: .globl _Xdhxint0 1925: .align 2 1926: _Xdhxint0: 1927: pushr $0x3f 1928: incl _fltintrcnt+(4*9) 1929: pushl $0 1930: calls $1,_dhxint 1931: popr $0x3f 1932: incl _cnt+V_INTR 1933: rei 1934: 1935: .globl _Xdmintr0 1936: .align 2 1937: _Xdmintr0: 1938: pushr $0x3f 1939: incl _fltintrcnt+(4*10) 1940: pushl $0 1941: calls $1,_dmintr 1942: popr $0x3f 1943: incl _cnt+V_INTR 1944: rei 1945: 1946: .globl _Xdhrint1 1947: .align 2 1948: _Xdhrint1: 1949: pushr $0x3f 1950: incl _fltintrcnt+(4*11) 1951: pushl $1 1952: calls $1,_dhrint 1953: popr $0x3f 1954: incl _cnt+V_INTR 1955: rei 1956: 1957: .globl _Xdhxint1 1958: .align 2 1959: _Xdhxint1: 1960: pushr $0x3f 1961: incl _fltintrcnt+(4*12) 1962: pushl $1 1963: calls $1,_dhxint 1964: popr $0x3f 1965: incl _cnt+V_INTR 1966: rei 1967: 1968: .globl _Xdzrint0 1969: .align 2 1970: _Xdzrint0: 1971: pushr $0x3f 1972: incl _fltintrcnt+(4*13) 1973: pushl $0 1974: calls $1,_dzrint 1975: popr $0x3f 1976: incl _cnt+V_INTR 1977: rei 1978: 1979: .globl _Xdzxint0 1980: .align 2 1981: _Xdzxint0: 1982: pushr $0x3f 1983: incl _fltintrcnt+(4*14) 1984: movl $0,r0 1985: jmp dzdma 1986: 1987: .globl _Xdzrint1 1988: .align 2 1989: _Xdzrint1: 1990: pushr $0x3f 1991: incl _fltintrcnt+(4*15) 1992: pushl $1 1993: calls $1,_dzrint 1994: popr $0x3f 1995: incl _cnt+V_INTR 1996: rei 1997: 1998: .globl _Xdzxint1 1999: .align 2 2000: _Xdzxint1: 2001: pushr $0x3f 2002: incl _fltintrcnt+(4*16) 2003: movl $1,r0 2004: jmp dzdma 2005: 2006: .globl _Xdzrint2 2007: .align 2 2008: _Xdzrint2: 2009: pushr $0x3f 2010: incl _fltintrcnt+(4*17) 2011: pushl $2 2012: calls $1,_dzrint 2013: popr $0x3f 2014: incl _cnt+V_INTR 2015: rei 2016: 2017: .globl _Xdzxint2 2018: .align 2 2019: _Xdzxint2: 2020: pushr $0x3f 2021: incl _fltintrcnt+(4*18) 2022: movl $2,r0 2023: jmp dzdma 2024: 2025: .globl _Xdzrint3 2026: .align 2 2027: _Xdzrint3: 2028: pushr $0x3f 2029: incl _fltintrcnt+(4*19) 2030: pushl $3 2031: calls $1,_dzrint 2032: popr $0x3f 2033: incl _cnt+V_INTR 2034: rei 2035: 2036: .globl _Xdzxint3 2037: .align 2 2038: _Xdzxint3: 2039: pushr $0x3f 2040: incl _fltintrcnt+(4*20) 2041: movl $3,r0 2042: jmp dzdma 2043: 2044: .globl _Xdzrint4 2045: .align 2 2046: _Xdzrint4: 2047: pushr $0x3f 2048: incl _fltintrcnt+(4*21) 2049: pushl $4 2050: calls $1,_dzrint 2051: popr $0x3f 2052: incl _cnt+V_INTR 2053: rei 2054: 2055: .globl _Xdzxint4 2056: .align 2 2057: _Xdzxint4: 2058: pushr $0x3f 2059: incl _fltintrcnt+(4*22) 2060: movl $4,r0 2061: jmp dzdma 2062: 2063: .globl _Xdzrint5 2064: .align 2 2065: _Xdzrint5: 2066: pushr $0x3f 2067: incl _fltintrcnt+(4*23) 2068: pushl $5 2069: calls $1,_dzrint 2070: popr $0x3f 2071: incl _cnt+V_INTR 2072: rei 2073: 2074: .globl _Xdzxint5 2075: .align 2 2076: _Xdzxint5: 2077: pushr $0x3f 2078: incl _fltintrcnt+(4*24) 2079: movl $5,r0 2080: jmp dzdma 2081: 2082: .globl _Xdzrint6 2083: .align 2 2084: _Xdzrint6: 2085: pushr $0x3f 2086: incl _fltintrcnt+(4*25) 2087: pushl $6 2088: calls $1,_dzrint 2089: popr $0x3f 2090: incl _cnt+V_INTR 2091: rei 2092: 2093: .globl _Xdzxint6 2094: .align 2 2095: _Xdzxint6: 2096: pushr $0x3f 2097: incl _fltintrcnt+(4*26) 2098: movl $6,r0 2099: jmp dzdma 2100: 2101: .globl _Xdzrint7 2102: .align 2 2103: _Xdzrint7: 2104: pushr $0x3f 2105: incl _fltintrcnt+(4*27) 2106: pushl $7 2107: calls $1,_dzrint 2108: popr $0x3f 2109: incl _cnt+V_INTR 2110: rei 2111: 2112: .globl _Xdzxint7 2113: .align 2 2114: _Xdzxint7: 2115: pushr $0x3f 2116: incl _fltintrcnt+(4*28) 2117: movl $7,r0 2118: jmp dzdma 2119: 2120: .globl _Xtsintr0 2121: .align 2 2122: _Xtsintr0: 2123: pushr $0x3f 2124: incl _fltintrcnt+(4*29) 2125: pushl $0 2126: calls $1,_tsintr 2127: popr $0x3f 2128: incl _cnt+V_INTR 2129: rei 2130: 2131: .globl _Xdmfsrint0 2132: .align 2 2133: _Xdmfsrint0: 2134: pushr $0x3f 2135: incl _fltintrcnt+(4*30) 2136: pushl $0 2137: calls $1,_dmfsrint 2138: popr $0x3f 2139: incl _cnt+V_INTR 2140: rei 2141: 2142: .globl _Xdmfsxint0 2143: .align 2 2144: _Xdmfsxint0: 2145: pushr $0x3f 2146: incl _fltintrcnt+(4*31) 2147: pushl $0 2148: calls $1,_dmfsxint 2149: popr $0x3f 2150: incl _cnt+V_INTR 2151: rei 2152: 2153: .globl _Xdmfdaint0 2154: .align 2 2155: _Xdmfdaint0: 2156: pushr $0x3f 2157: incl _fltintrcnt+(4*32) 2158: pushl $0 2159: calls $1,_dmfdaint 2160: popr $0x3f 2161: incl _cnt+V_INTR 2162: rei 2163: 2164: .globl _Xdmfdbint0 2165: .align 2 2166: _Xdmfdbint0: 2167: pushr $0x3f 2168: incl _fltintrcnt+(4*33) 2169: pushl $0 2170: calls $1,_dmfdbint 2171: popr $0x3f 2172: incl _cnt+V_INTR 2173: rei 2174: 2175: .globl _Xdmfrint0 2176: .align 2 2177: _Xdmfrint0: 2178: pushr $0x3f 2179: incl _fltintrcnt+(4*34) 2180: pushl $0 2181: calls $1,_dmfrint 2182: popr $0x3f 2183: incl _cnt+V_INTR 2184: rei 2185: 2186: .globl _Xdmfxint0 2187: .align 2 2188: _Xdmfxint0: 2189: pushr $0x3f 2190: incl _fltintrcnt+(4*35) 2191: pushl $0 2192: calls $1,_dmfxint 2193: popr $0x3f 2194: incl _cnt+V_INTR 2195: rei 2196: 2197: .globl _Xdmflint0 2198: .align 2 2199: _Xdmflint0: 2200: pushr $0x3f 2201: incl _fltintrcnt+(4*36) 2202: pushl $0 2203: calls $1,_dmflint 2204: popr $0x3f 2205: incl _cnt+V_INTR 2206: rei 2207: 2208: .globl _Xdmzrinta0 2209: .align 2 2210: _Xdmzrinta0: 2211: pushr $0x3f 2212: incl _fltintrcnt+(4*37) 2213: pushl $0 2214: calls $1,_dmzrinta 2215: popr $0x3f 2216: incl _cnt+V_INTR 2217: rei 2218: 2219: .globl _Xdmzxinta0 2220: .align 2 2221: _Xdmzxinta0: 2222: pushr $0x3f 2223: incl _fltintrcnt+(4*38) 2224: pushl $0 2225: calls $1,_dmzxinta 2226: popr $0x3f 2227: incl _cnt+V_INTR 2228: rei 2229: 2230: .globl _Xdmzrintb0 2231: .align 2 2232: _Xdmzrintb0: 2233: pushr $0x3f 2234: incl _fltintrcnt+(4*39) 2235: pushl $0 2236: calls $1,_dmzrintb 2237: popr $0x3f 2238: incl _cnt+V_INTR 2239: rei 2240: 2241: .globl _Xdmzxintb0 2242: .align 2 2243: _Xdmzxintb0: 2244: pushr $0x3f 2245: incl _fltintrcnt+(4*40) 2246: pushl $0 2247: calls $1,_dmzxintb 2248: popr $0x3f 2249: incl _cnt+V_INTR 2250: rei 2251: 2252: .globl _Xdmzrintc0 2253: .align 2 2254: _Xdmzrintc0: 2255: pushr $0x3f 2256: incl _fltintrcnt+(4*41) 2257: pushl $0 2258: calls $1,_dmzrintc 2259: popr $0x3f 2260: incl _cnt+V_INTR 2261: rei 2262: 2263: .globl _Xdmzxintc0 2264: .align 2 2265: _Xdmzxintc0: 2266: pushr $0x3f 2267: incl _fltintrcnt+(4*42) 2268: pushl $0 2269: calls $1,_dmzxintc 2270: popr $0x3f 2271: incl _cnt+V_INTR 2272: rei 2273: 2274: .globl _Xdhurint0 2275: .align 2 2276: _Xdhurint0: 2277: pushr $0x3f 2278: incl _fltintrcnt+(4*43) 2279: pushl $0 2280: calls $1,_dhurint 2281: popr $0x3f 2282: incl _cnt+V_INTR 2283: rei 2284: 2285: .globl _Xdhuxint0 2286: .align 2 2287: _Xdhuxint0: 2288: pushr $0x3f 2289: incl _fltintrcnt+(4*44) 2290: pushl $0 2291: calls $1,_dhuxint 2292: popr $0x3f 2293: incl _cnt+V_INTR 2294: rei 2295: 2296: .globl _Xlpintr0 2297: .align 2 2298: _Xlpintr0: 2299: pushr $0x3f 2300: incl _fltintrcnt+(4*45) 2301: pushl $0 2302: calls $1,_lpintr 2303: popr $0x3f 2304: incl _cnt+V_INTR 2305: rei 2306: 2307: .globl _Xenxint0 2308: .align 2 2309: _Xenxint0: 2310: pushr $0x3f 2311: incl _fltintrcnt+(4*46) 2312: pushl $0 2313: calls $1,_enxint 2314: popr $0x3f 2315: incl _cnt+V_INTR 2316: rei 2317: 2318: .globl _Xenrint0 2319: .align 2 2320: _Xenrint0: 2321: pushr $0x3f 2322: incl _fltintrcnt+(4*47) 2323: pushl $0 2324: calls $1,_enrint 2325: popr $0x3f 2326: incl _cnt+V_INTR 2327: rei 2328: 2329: .globl _Xencollide0 2330: .align 2 2331: _Xencollide0: 2332: pushr $0x3f 2333: incl _fltintrcnt+(4*48) 2334: pushl $0 2335: calls $1,_encollide 2336: popr $0x3f 2337: incl _cnt+V_INTR 2338: rei 2339: 2340: .globl _Xecrint0 2341: .align 2 2342: _Xecrint0: 2343: pushr $0x3f 2344: incl _fltintrcnt+(4*49) 2345: pushl $0 2346: calls $1,_ecrint 2347: popr $0x3f 2348: incl _cnt+V_INTR 2349: rei 2350: 2351: .globl _Xeccollide0 2352: .align 2 2353: _Xeccollide0: 2354: pushr $0x3f 2355: incl _fltintrcnt+(4*50) 2356: pushl $0 2357: calls $1,_eccollide 2358: popr $0x3f 2359: incl _cnt+V_INTR 2360: rei 2361: 2362: .globl _Xecxint0 2363: .align 2 2364: _Xecxint0: 2365: pushr $0x3f 2366: incl _fltintrcnt+(4*51) 2367: pushl $0 2368: calls $1,_ecxint 2369: popr $0x3f 2370: incl _cnt+V_INTR 2371: rei 2372: 2373: .globl _Xdeintr0 2374: .align 2 2375: _Xdeintr0: 2376: pushr $0x3f 2377: incl _fltintrcnt+(4*52) 2378: pushl $0 2379: calls $1,_deintr 2380: popr $0x3f 2381: incl _cnt+V_INTR 2382: rei 2383: 2384: .globl _Xilrint0 2385: .align 2 2386: _Xilrint0: 2387: pushr $0x3f 2388: incl _fltintrcnt+(4*53) 2389: pushl $0 2390: calls $1,_ilrint 2391: popr $0x3f 2392: incl _cnt+V_INTR 2393: rei 2394: 2395: .globl _Xilcint0 2396: .align 2 2397: _Xilcint0: 2398: pushr $0x3f 2399: incl _fltintrcnt+(4*54) 2400: pushl $0 2401: calls $1,_ilcint 2402: popr $0x3f 2403: incl _cnt+V_INTR 2404: rei 2405: 2406: .globl _Xexcdint0 2407: .align 2 2408: _Xexcdint0: 2409: pushr $0x3f 2410: incl _fltintrcnt+(4*55) 2411: pushl $0 2412: calls $1,_excdint 2413: popr $0x3f 2414: incl _cnt+V_INTR 2415: rei 2416: 2417: 2418: .globl _intrnames 2419: 2420: .globl _eintrnames 2421: .data 2422: _intrnames: 2423: .asciz "clock" 2424: .asciz "cnr" 2425: .asciz "cnx" 2426: .asciz "tur" 2427: .asciz "tux" 2428: .asciz "mba0" 2429: .asciz "mba1" 2430: .asciz "mba2" 2431: .asciz "mba3" 2432: .asciz "uba0" 2433: .asciz "uba1" 2434: .asciz "uba2" 2435: .asciz "uba3" 2436: .asciz "rk0" 2437: .asciz "tm0" 2438: .asciz "ut0" 2439: .asciz "tmscp0" 2440: .asciz "up0" 2441: .asciz "ud0" 2442: .asciz "idc0" 2443: .asciz "rl0" 2444: .asciz "dhr0" 2445: .asciz "dhx0" 2446: .asciz "dm0" 2447: .asciz "dhr1" 2448: .asciz "dhx1" 2449: .asciz "dzr0" 2450: .asciz "dzx0" 2451: .asciz "dzr1" 2452: .asciz "dzx1" 2453: .asciz "dzr2" 2454: .asciz "dzx2" 2455: .asciz "dzr3" 2456: .asciz "dzx3" 2457: .asciz "dzr4" 2458: .asciz "dzx4" 2459: .asciz "dzr5" 2460: .asciz "dzx5" 2461: .asciz "dzr6" 2462: .asciz "dzx6" 2463: .asciz "dzr7" 2464: .asciz "dzx7" 2465: .asciz "ts0" 2466: .asciz "dmfsr0" 2467: .asciz "dmfsx0" 2468: .asciz "dmfda0" 2469: .asciz "dmfdb0" 2470: .asciz "dmfr0" 2471: .asciz "dmfx0" 2472: .asciz "dmfl0" 2473: .asciz "dmzra0" 2474: .asciz "dmzxa0" 2475: .asciz "dmzrb0" 2476: .asciz "dmzxb0" 2477: .asciz "dmzrc0" 2478: .asciz "dmzxc0" 2479: .asciz "dhur0" 2480: .asciz "dhux0" 2481: .asciz "lp0" 2482: .asciz "enx0" 2483: .asciz "enr0" 2484: .asciz "encollide0" 2485: .asciz "ecr0" 2486: .asciz "eccollide0" 2487: .asciz "ecx0" 2488: .asciz "de0" 2489: .asciz "ilr0" 2490: .asciz "ilc0" 2491: .asciz "excd0" 2492: _eintrnames: 2493: 2494: .globl _intrcnt 2495: 2496: .globl _eintrcnt 2497: .align 2 2498: _intrcnt: 2499: .space 4 * 13 2500: _fltintrcnt: 2501: .space 4 * 56 2502: _eintrcnt: 2503: 2504: .text
Defined functions
V_FASTPGREC
defined in line 1788; never used
incl
defined in line 428; used 136 times
- in line 194, 279-288(5), 335-336(2), 342-348(4), 360-361(2), 368, 387, 393, 419, 429-430(2), 465, 808, 816, 955, 1173, 1515, 1779, 1815-1820(5), 1829-1833(2), 1840-1844(2), 1851-1855(2), 1862-1866(2), 1873-1877(2), 1884-1888(2), 1895-1899(2), 1906-1910(2), 1917-1921(2), 1928-1932(2), 1939-1943(2), 1950-1954(2), 1961-1965(2), 1972-1976(2), 1983, 1991-1995(2), 2002, 2010-2014(2), 2021, 2029-2033(2), 2040, 2048-2052(2), 2059, 2067-2071(2), 2078, 2086-2090(2), 2097, 2105-2109(2), 2116, 2124-2128(2), 2135-2139(2), 2146-2150(2), 2157-2161(2), 2168-2172(2), 2179-2183(2), 2190-2194(2), 2201-2205(2), 2212-2216(2), 2223-2227(2), 2234-2238(2), 2245-2249(2), 2256-2260(2), 2267-2271(2), 2278-2282(2), 2289-2293(2), 2300-2304(2), 2311-2315(2), 2322-2326(2), 2333-2337(2), 2344-2348(2), 2355-2359(2), 2366-2370(2), 2377-2381(2), 2388-2392(2), 2399-2403(2), 2410-2414(2)
movl
defined in line 1685; used 121 times
- in line 195, 258, 306-325(10), 449, 461, 484-485(2), 491, 516-520(2), 548-551(2), 587, 620-623(2), 632, 638, 779-788(5), 892, 898-904(4), 946-947(2), 963, 969, 979, 985-987(3), 999-1001(2), 1012, 1032, 1055-1056(2), 1079-1083(3), 1098, 1127-1136(4), 1143, 1159-1162(2), 1178, 1193-1196(3), 1202, 1209, 1225-1228(2), 1238-1251(5), 1269, 1291, 1299-1303(2), 1318, 1340, 1348-1352(2), 1370-1371(2), 1381, 1392, 1407, 1413, 1514, 1533-1538(2), 1547-1551(2), 1558, 1571-1573(3), 1585, 1602, 1640-1641(2), 1654, 1668, 1681, 1722, 1740, 1747-1749(2), 1803-1804(2), 1810-1812(3), 1984, 2003, 2022, 2041, 2060, 2079, 2098, 2117
mtpr
defined in line 815; used 153 times
- in line 191, 200-201(2), 244-254(3), 352, 525, 590, 625, 810, 818, 883-890(6), 943(2), 957-967(5), 973, 991, 1081, 1090, 1500, 1518, 1546-1552(3), 1620, 1630, 1798-1800(2), 1823
- in /usr/src/sys/h/vmmac.h line 88-93(4)
- in /usr/src/sys/net/netisr.h line 18
- in /usr/src/sys/stand/autoconf.c line 98
- in /usr/src/sys/stand/prf.c line 154-159(3)
- in /usr/src/sys/sys/kern_exec.c line 473
- in /usr/src/sys/sys/kern_mman.c line 308
- in /usr/src/sys/sys/vm_pt.c line 223, 232-235(4), 248, 264, 465, 483, 494
- in /usr/src/sys/vax/autoconf.c line 114, 845
- in /usr/src/sys/vax/clock.c line 37-41(3), 153
- in /usr/src/sys/vax/cons.c line 45-46(2), 171-173(2), 206-211(3)
- in /usr/src/sys/vax/crl.c line 149-152(2), 189-195(3), 201, 207, 220
- in /usr/src/sys/vax/flp.c line 154-156(2), 173-175(2), 181, 187, 198, 204
- in /usr/src/sys/vax/ka630.c line 40
- in /usr/src/sys/vax/machdep.c line 87, 221, 732, 787, 826, 833, 841, 1065, 1085-1086(2), 1097-1098(2), 1122, 1211-1221(3), 1239
- in /usr/src/sys/vax/mem.c line 73
- in /usr/src/sys/vax/mem.h line 71-72(3), 97-99(2), 107-109(2), 117-119(2)
- in /usr/src/sys/vax/pcb.h line 61-66(2)
- in /usr/src/sys/vax/tu.c line 123, 138-139(2), 180, 198, 208, 287, 305, 347, 419, 447, 498, 517, 529, 541, 553, 597, 682-683(2)
- in /usr/src/sys/vax/vm_machdep.c line 35, 47, 99-103(2), 153, 168-171(2), 182-185(2), 206-207(2)
- in /usr/src/sys/vax/vmparam.h line 160
- in /usr/src/sys/vaxif/if_uba.c line 212-214(2)
- in /usr/src/sys/vaxuba/uba.c line 389
pushl
defined in line 428; used 77 times
- in line 205, 274-285(5), 354-357(4), 365(2), 469, 713, 719-733(7), 814, 907(2), 1006(2), 1031, 1290, 1339, 1830, 1841, 1852, 1863, 1874, 1885, 1896, 1907, 1918, 1929, 1940, 1951, 1962, 1973, 1992, 2011, 2030, 2049, 2068, 2087, 2106, 2125, 2136, 2147, 2158, 2169, 2180, 2191, 2202, 2213, 2224, 2235, 2246, 2257, 2268, 2279, 2290, 2301, 2312, 2323, 2334, 2345, 2356, 2367, 2378, 2389, 2400, 2411
Defined variables
Defined macros
V_FASTPGREC
defined in line 32; never used
V_INTR
defined in line 27; used 55 times
- in line 288, 336, 342-347(2), 360, 419, 429, 1833, 1844, 1855, 1866, 1877, 1888, 1899, 1910, 1921, 1932, 1943, 1954, 1965, 1976, 1995, 2014, 2033, 2052, 2071, 2090, 2109, 2128, 2139, 2150, 2161, 2172, 2183, 2194, 2205, 2216, 2227, 2238, 2249, 2260, 2271, 2282, 2293, 2304, 2315, 2326, 2337, 2348, 2359, 2370, 2381, 2392, 2403, 2414
|
Last modified: 1986-06-07
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 3340 |
|