![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to locore.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vax|
Return to locore.s CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vax |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980, 1986 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: * ! 6: * @(#)locore.s 7.1 (Berkeley) 6/5/86 ! 7: */ ! 8: ! 9: #include "psl.h" ! 10: #include "pte.h" ! 11: ! 12: #include "errno.h" ! 13: #include "cmap.h" ! 14: ! 15: #include "mtpr.h" ! 16: #include "trap.h" ! 17: #include "cpu.h" ! 18: #include "nexus.h" ! 19: #include "cons.h" ! 20: #include "clock.h" ! 21: #include "ioa.h" ! 22: #include "ka630.h" ! 23: #include "../vaxuba/ubareg.h" ! 24: ! 25: #include "dz.h" ! 26: #include "uu.h" ! 27: #include "ps.h" ! 28: #include "mba.h" ! 29: #include "uba.h" ! 30: ! 31: .set HIGH,0x1f # mask for total disable ! 32: .set MCKVEC,4 # offset into scb of machine check vector ! 33: .set NBPG,512 ! 34: .set PGSHIFT,9 ! 35: ! 36: .set NISP,3 # number of interrupt stack pages ! 37: ! 38: /* ! 39: * User structure is UPAGES at top of user space. ! 40: */ ! 41: .globl _u ! 42: .set _u,0x80000000 - UPAGES*NBPG ! 43: ! 44: .globl _intstack ! 45: _intstack: ! 46: .space NISP*NBPG ! 47: eintstack: ! 48: ! 49: /* ! 50: * Do a dump. ! 51: * Called by auto-restart. ! 52: * May be called manually. ! 53: */ ! 54: .align 2 ! 55: .globl _doadump ! 56: _doadump: ! 57: nop; nop # .word 0x0101 ! 58: #define _rpbmap _Sysmap # rpb, scb, UNI*vec, istack*4 ! 59: bicl2 $PG_PROT,_rpbmap ! 60: bisl2 $PG_KW,_rpbmap ! 61: mtpr $0,$TBIA ! 62: tstl _rpb+RP_FLAG # dump only once! ! 63: bneq 1f ! 64: incl _rpb+RP_FLAG ! 65: movl sp,erpb ! 66: movab erpb,sp ! 67: mfpr $PCBB,-(sp) ! 68: mfpr $MAPEN,-(sp) ! 69: mfpr $IPL,-(sp) ! 70: mtpr $0,$MAPEN ! 71: mtpr $HIGH,$IPL ! 72: pushr $0x3fff ! 73: calls $0,_dumpsys ! 74: 1: ! 75: pushl $TXDB_BOOT ! 76: calls $1,_tocons ! 77: halt ! 78: ! 79: /* ! 80: * Interrupt vector routines ! 81: */ ! 82: .globl _waittime ! 83: ! 84: #define SCBVEC(name) .align 2; .globl _X/**/name; _X/**/name ! 85: #define PANIC(msg) clrl _waittime; pushab 1f; \ ! 86: calls $1,_panic; 1: .asciz msg ! 87: #define PRINTF(n,msg) pushab 1f; calls $n+1,_printf; MSG(msg) ! 88: #define MSG(msg) .data; 1: .asciz msg; .text ! 89: #define PUSHR pushr $0x3f ! 90: #define POPR popr $0x3f ! 91: ! 92: .data ! 93: nofault: .long 0 # where to go on predicted machcheck ! 94: .text ! 95: SCBVEC(machcheck): ! 96: tstl nofault ! 97: bneq 1f ! 98: PUSHR; pushab 6*4(sp); calls $1,_machinecheck; POPR; ! 99: addl2 (sp)+,sp; rei ! 100: .align 2 ! 101: 1: ! 102: casel _cpu,$1,$VAX_MAX ! 103: 0: ! 104: .word 8f-0b # 1 is 780 ! 105: .word 5f-0b # 2 is 750 ! 106: .word 5f-0b # 3 is 730 ! 107: .word 7f-0b # 4 is 8600 ! 108: .word 1f-0b # ??? ! 109: .word 1f-0b # ??? ! 110: .word 1f-0b # ??? ! 111: .word 1f-0b # 8 is 630 ! 112: 5: ! 113: #if defined(VAX750) || defined(VAX730) ! 114: mtpr $0xf,$MCESR ! 115: #endif ! 116: brb 1f ! 117: 7: ! 118: #if VAX8600 ! 119: mtpr $0,$EHSR ! 120: #endif ! 121: brb 1f ! 122: 8: ! 123: #if VAX780 ! 124: mtpr $0,$SBIFS ! 125: #endif ! 126: 1: ! 127: addl2 (sp)+,sp # discard mchchk trash ! 128: movl nofault,(sp) ! 129: rei ! 130: SCBVEC(kspnotval): ! 131: PUSHR; PANIC("KSP not valid"); ! 132: SCBVEC(powfail): ! 133: halt ! 134: SCBVEC(chme): SCBVEC(chms): SCBVEC(chmu): ! 135: PUSHR; PANIC("CHM? in kernel"); ! 136: SCBVEC(stray): ! 137: PUSHR; PRINTF(0, "stray scb interrupt\n"); POPR; ! 138: rei ! 139: SCBVEC(nexzvec): ! 140: PUSHR; mfpr $IPL,-(sp); PRINTF(1, "nexus stray intr ipl%x\n"); POPR; rei ! 141: SCBVEC(cmrd): ! 142: PUSHR; calls $0,_memerr; POPR; rei ! 143: SCBVEC(wtime): ! 144: PUSHR; pushl 6*4(sp); PRINTF(1,"write timeout %x\n"); POPR; ! 145: PANIC("wtimo"); ! 146: ! 147: #if NMBA > 0 ! 148: SCBVEC(mba3int): ! 149: PUSHR; incl _intrcnt+I_MBA3; pushl $3; brb 1f ! 150: SCBVEC(mba2int): ! 151: PUSHR; incl _intrcnt+I_MBA2; pushl $2; brb 1f ! 152: SCBVEC(mba1int): ! 153: PUSHR; incl _intrcnt+I_MBA1; pushl $1; brb 1f ! 154: SCBVEC(mba0int): ! 155: PUSHR; incl _intrcnt+I_MBA0; pushl $0 ! 156: 1: calls $1,_mbintr ! 157: POPR ! 158: incl _cnt+V_INTR ! 159: rei ! 160: #endif ! 161: ! 162: #if defined(VAX780) || defined(VAX8600) ! 163: /* ! 164: * Registers for the uba handling code ! 165: */ ! 166: #define rUBANUM r0 ! 167: #define rUBAHD r1 ! 168: #define rUVEC r3 ! 169: #define rUBA r4 ! 170: /* r2,r5 are scratch */ ! 171: ! 172: #define I_UBA I_UBA0 /* base of UBA interrupt counters */ ! 173: ! 174: #if NUBA > 4 ! 175: SCBVEC(ua7int): ! 176: PUSHR; movl $7,rUBANUM; moval _uba_hd+(7*UH_SIZE),rUBAHD; brb 1f ! 177: SCBVEC(ua6int): ! 178: PUSHR; movl $6,rUBANUM; moval _uba_hd+(6*UH_SIZE),rUBAHD; brb 1f ! 179: SCBVEC(ua5int): ! 180: PUSHR; movl $5,rUBANUM; moval _uba_hd+(5*UH_SIZE),rUBAHD; brb 1f ! 181: SCBVEC(ua4int): ! 182: PUSHR; movl $4,rUBANUM; moval _uba_hd+(4*UH_SIZE),rUBAHD; brb 1f ! 183: #endif ! 184: SCBVEC(ua3int): ! 185: PUSHR; movl $3,rUBANUM; moval _uba_hd+(3*UH_SIZE),rUBAHD; brb 1f ! 186: SCBVEC(ua2int): ! 187: PUSHR; movl $2,rUBANUM; moval _uba_hd+(2*UH_SIZE),rUBAHD; brb 1f ! 188: SCBVEC(ua1int): ! 189: PUSHR; movl $1,rUBANUM; moval _uba_hd+(1*UH_SIZE),rUBAHD; brb 1f ! 190: SCBVEC(ua0int): ! 191: PUSHR; movl $0,rUBANUM; moval _uba_hd+(0*UH_SIZE),rUBAHD; ! 192: 1: ! 193: mfpr $IPL,r2 /* r2 = mfpr(IPL); */ ! 194: movl UH_UBA(rUBAHD),rUBA /* uba = uhp->uh_uba; */ ! 195: movl UBA_BRRVR-0x14*4(rUBA)[r2],rUVEC ! 196: /* uvec = uba->uba_brrvr[r2-0x14] */ ! 197: ubanorm: ! 198: bleq ubaerror ! 199: addl2 UH_VEC(rUBAHD),rUVEC /* uvec += uh->uh_vec */ ! 200: bicl3 $3,(rUVEC),r1 ! 201: jmp 2(r1) /* 2 skips ``pushr $0x3f'' */ ! 202: ubaerror: ! 203: PUSHR; calls $0,_ubaerror; POPR /* ubaerror r/w's r0-r5 */ ! 204: tstl rUVEC; jneq ubanorm /* rUVEC contains result */ ! 205: incl _intrcnt+I_UBA[rUBANUM] ! 206: incl _cnt+V_INTR ! 207: POPR ! 208: rei ! 209: #endif ! 210: SCBVEC(cnrint): ! 211: PUSHR; calls $0,_cnrint; POPR ! 212: incl _cnt+V_INTR ! 213: incl _intrcnt+I_CNR ! 214: rei ! 215: SCBVEC(cnxint): ! 216: PUSHR; calls $0,_cnxint; POPR ! 217: incl _cnt+V_INTR ! 218: incl _intrcnt+I_CNX ! 219: rei ! 220: SCBVEC(hardclock): ! 221: PUSHR ! 222: mtpr $ICCS_RUN|ICCS_IE|ICCS_INT|ICCS_ERR,$ICCS ! 223: #if NPS > 0 ! 224: pushl 4+6*4(sp); pushl 4+6*4(sp); ! 225: calls $2,_psextsync ! 226: #endif ! 227: pushl 4+6*4(sp); pushl 4+6*4(sp); ! 228: calls $2,_hardclock # hardclock(pc,psl) ! 229: POPR; ! 230: incl _cnt+V_INTR ! 231: incl _intrcnt+I_CLOCK ! 232: rei ! 233: SCBVEC(softclock): ! 234: PUSHR ! 235: pushl 4+6*4(sp); pushl 4+6*4(sp); ! 236: calls $2,_softclock # softclock(pc,psl) ! 237: POPR; ! 238: incl _cnt+V_SOFT ! 239: rei ! 240: ! 241: #include "../net/netisr.h" ! 242: .globl _netisr ! 243: SCBVEC(netintr): ! 244: PUSHR ! 245: #include "imp.h" ! 246: #if NIMP > 0 ! 247: bbcc $NETISR_IMP,_netisr,1f; calls $0,_impintr; 1: ! 248: #endif ! 249: #ifdef INET ! 250: bbcc $NETISR_IP,_netisr,1f; calls $0,_ipintr; 1: ! 251: #endif ! 252: #ifdef NS ! 253: bbcc $NETISR_NS,_netisr,1f; calls $0,_nsintr; 1: ! 254: #endif ! 255: bbcc $NETISR_RAW,_netisr,1f; calls $0,_rawintr; 1: ! 256: POPR ! 257: incl _cnt+V_SOFT ! 258: rei ! 259: ! 260: #if defined(VAX750) || defined(VAX730) || defined(VAX8600) ! 261: SCBVEC(consdin): ! 262: PUSHR; ! 263: incl _intrcnt+I_TUR ! 264: casel _cpu,$VAX_750,$VAX_8600 ! 265: 0: ! 266: .word 5f-0b # 2 is VAX_750 ! 267: .word 3f-0b # 3 is VAX_730 ! 268: .word 6f-0b # 4 is VAX_8600 ! 269: halt ! 270: 5: ! 271: #if defined(VAX750) && !defined(MRSP) ! 272: jsb tudma ! 273: #endif ! 274: 3: ! 275: #if defined(VAX750) || defined(VAX730) ! 276: calls $0,_turintr ! 277: brb 2f ! 278: #else ! 279: halt ! 280: #endif ! 281: 6: ! 282: #if VAX8600 ! 283: calls $0, _crlintr ! 284: #else ! 285: halt ! 286: #endif ! 287: 2: ! 288: POPR; ! 289: incl _cnt+V_INTR; ! 290: rei ! 291: #else ! 292: SCBVEC(consdin): ! 293: halt ! 294: #endif ! 295: ! 296: #if defined(VAX750) || defined(VAX730) ! 297: SCBVEC(consdout): ! 298: PUSHR; calls $0,_tuxintr; POPR ! 299: incl _cnt+V_INTR ! 300: incl _intrcnt+I_TUX ! 301: rei ! 302: #else ! 303: SCBVEC(consdout): ! 304: halt ! 305: #endif ! 306: ! 307: #if NDZ > 0 ! 308: /* ! 309: * DZ pseudo dma routine: ! 310: * r0 - controller number ! 311: */ ! 312: .align 1 ! 313: .globl dzdma ! 314: dzdma: ! 315: mull2 $8*20,r0 ! 316: movab _dzpdma(r0),r3 # pdma structure base ! 317: # for this controller ! 318: dzploop: ! 319: movl r3,r0 ! 320: movl (r0)+,r1 # device register address ! 321: movzbl 1(r1),r2 # get line number ! 322: bitb $0x80,r2 # TRDY on? ! 323: beql dzprei # no ! 324: bicb2 $0xf8,r2 # clear garbage bits ! 325: mull2 $20,r2 ! 326: addl2 r2,r0 # point at line's pdma structure ! 327: movl (r0)+,r2 # p_mem ! 328: cmpl r2,(r0)+ # p_mem < p_end ? ! 329: bgequ dzpcall # no, go call dzxint ! 330: movb (r2)+,6(r1) # dztbuf = *p_mem++ ! 331: movl r2,-8(r0) ! 332: brb dzploop # check for another line ! 333: dzprei: ! 334: POPR ! 335: incl _cnt+V_PDMA ! 336: rei ! 337: ! 338: dzpcall: ! 339: pushl r3 ! 340: pushl (r0)+ # push tty address ! 341: calls $1,*(r0) # call interrupt rtn ! 342: movl (sp)+,r3 ! 343: brb dzploop # check for another line ! 344: #endif ! 345: ! 346: #if NUU > 0 && defined(UUDMA) ! 347: /* ! 348: * Pseudo DMA routine for tu58 (on DL11) ! 349: * r0 - controller number ! 350: */ ! 351: .align 1 ! 352: .globl uudma ! 353: uudma: ! 354: movl _uudinfo[r0],r2 ! 355: movl 16(r2),r2 # r2 = uuaddr ! 356: mull3 $48,r0,r3 ! 357: movab _uu_softc(r3),r5 # r5 = uuc ! 358: ! 359: cvtwl 2(r2),r1 # c = uuaddr->rdb ! 360: bbc $15,r1,1f # if (c & UUDB_ERROR) ! 361: movl $13,16(r5) # uuc->tu_state = TUC_RCVERR; ! 362: rsb # let uurintr handle it ! 363: 1: ! 364: tstl 4(r5) # if (uuc->tu_rcnt) { ! 365: beql 1f ! 366: movb r1,*0(r5) # *uuc->tu_rbptr++ = r1 ! 367: incl (r5) ! 368: decl 4(r5) # if (--uuc->tu_rcnt) ! 369: beql 2f # done ! 370: tstl (sp)+ ! 371: POPR # registers saved in ubglue.s ! 372: rei # } ! 373: 2: ! 374: cmpl 16(r5),$8 # if (uuc->tu_state != TUS_GETH) ! 375: beql 2f # let uurintr handle it ! 376: 1: ! 377: rsb ! 378: 2: ! 379: mull2 $14,r0 # sizeof(uudata[ctlr]) = 14 ! 380: movab _uudata(r0),r4 # data = &uudata[ctlr]; ! 381: cmpb $1,(r4) # if (data->pk_flag != TUF_DATA) ! 382: bneq 1b ! 383: #ifdef notdef ! 384: /* this is for command packets */ ! 385: beql 1f # r0 = uuc->tu_rbptr ! 386: movl (r5),r0 ! 387: brb 2f ! 388: 1: # else ! 389: #endif ! 390: movl 24(r5),r0 # r0 = uuc->tu_addr ! 391: 2: ! 392: movzbl 1(r4),r3 # counter to r3 (data->pk_count) ! 393: movzwl (r4),r1 # first word of checksum (=header) ! 394: mfpr $IPL,-(sp) # s = spl5(); ! 395: mtpr $0x15,$IPL # to keep disk interrupts out ! 396: clrw (r2) # disable receiver interrupts ! 397: 3: bbc $7,(r2),3b # while ((uuaddr->rcs & UUCS_READY)==0); ! 398: cvtwb 2(r2),(r0)+ # *buffer = uuaddr->rdb & 0xff ! 399: sobgtr r3,1f # continue with next byte ... ! 400: addw2 2(r2),r1 # unless this was the last (odd count) ! 401: brb 2f ! 402: ! 403: 1: bbc $7,(r2),1b # while ((uuaddr->rcs & UUCS_READY)==0); ! 404: cvtwb 2(r2),(r0)+ # *buffer = uuaddr->rdb & 0xff ! 405: addw2 -2(r0),r1 # add to checksum.. ! 406: 2: ! 407: adwc $0,r1 # get the carry ! 408: sobgtr r3,3b # loop while r3 > 0 ! 409: /* ! 410: * We're ready to get the checksum ! 411: */ ! 412: 1: bbc $7,(r2),1b # while ((uuaddr->rcs & UUCS_READY)==0); ! 413: cvtwb 2(r2),12(r4) # get first (lower) byte ! 414: 1: bbc $7,(r2),1b ! 415: cvtwb 2(r2),13(r4) # ..and second ! 416: cmpw 12(r4),r1 # is checksum ok? ! 417: beql 1f ! 418: movl $14,16(r5) # uuc->tu_state = TUS_CHKERR ! 419: brb 2f # exit ! 420: 1: ! 421: movl $11,16(r5) # uuc->tu_state = TUS_GET (ok) ! 422: 2: ! 423: movw $0x40,(r2) # enable receiver interrupts ! 424: mtpr (sp)+,$IPL # splx(s); ! 425: rsb # continue processing in uurintr ! 426: #endif ! 427: ! 428: #if defined(VAX750) && !defined(MRSP) ! 429: /* ! 430: * Pseudo DMA routine for VAX-11/750 console tu58 ! 431: * (without MRSP) ! 432: */ ! 433: .align 1 ! 434: .globl tudma ! 435: tudma: ! 436: movab _tu,r5 # r5 = tu ! 437: tstl 4(r5) # if (tu.tu_rcnt) { ! 438: beql 3f ! 439: mfpr $CSRD,r1 # get data from tu58 ! 440: movb r1,*0(r5) # *tu.tu_rbptr++ = r1 ! 441: incl (r5) ! 442: decl 4(r5) # if (--tu.tu_rcnt) ! 443: beql 1f # done ! 444: tstl (sp)+ ! 445: POPR # registers saved in ubglue.s ! 446: rei # data handled, done ! 447: 1: # } ! 448: cmpl 16(r5),$8 # if (tu.tu_state != TUS_GETH) ! 449: beql 2f # let turintr handle it ! 450: 3: ! 451: rsb ! 452: 2: ! 453: movab _tudata,r4 # r4 = tudata ! 454: cmpb $1,(r4) # if (tudata.pk_flag != TUF_DATA) ! 455: bneq 3b # let turintr handle it ! 456: 1: # else ! 457: movl 24(r5),r1 # get buffer pointer to r1 ! 458: movzbl 1(r4),r3 # counter to r3 ! 459: movzwl (r4),r0 # first word of checksum (=header) ! 460: mtpr $0,$CSRS # disable receiver interrupts ! 461: 3: ! 462: bsbw 5f # wait for next byte ! 463: mfpr $CSRD,r5 ! 464: movb r5,(r1)+ # *buffer = rdb ! 465: sobgtr r3,1f # continue with next byte ... ! 466: mfpr $CSRD,r2 # unless this was the last (odd count) ! 467: brb 2f ! 468: ! 469: 1: bsbw 5f # wait for next byte ! 470: mfpr $CSRD,r5 ! 471: movb r5,(r1)+ # *buffer = rdb ! 472: movzwl -2(r1),r2 # get the last word back from memory ! 473: 2: ! 474: addw2 r2,r0 # add to checksum.. ! 475: adwc $0,r0 # get the carry ! 476: sobgtr r3,3b # loop while r3 > 0 ! 477: /* ! 478: * We're ready to get the checksum. ! 479: */ ! 480: bsbw 5f ! 481: movab _tudata,r4 ! 482: mfpr $CSRD,r5 ! 483: movb r5,12(r4) # get first (lower) byte ! 484: bsbw 5f ! 485: mfpr $CSRD,r5 ! 486: movb r5,13(r4) # ..and second ! 487: movab _tu,r5 ! 488: cmpw 12(r4),r0 # is checksum ok? ! 489: beql 1f ! 490: movl $14,16(r5) # tu.tu_state = TUS_CHKERR ! 491: brb 2f # exit ! 492: 1: ! 493: movl $11,16(r5) # tu.tu_state = TUS_GET ! 494: 2: ! 495: mtpr $0x40,$CSRS # enable receiver interrupts ! 496: rsb # continue processing in turintr ! 497: /* ! 498: * Loop until a new byte is ready from ! 499: * the tu58, make sure we don't loop forever ! 500: */ ! 501: 5: ! 502: movl $5000,r5 # loop max 5000 times ! 503: 1: ! 504: mfpr $CSRS,r2 ! 505: bbs $7,r2,1f ! 506: sobgtr r5,1b ! 507: movab _tu,r5 ! 508: movl $13,16(r5) # return TUS_RCVERR ! 509: tstl (sp)+ # and let turintr handle it ! 510: 1: ! 511: rsb ! 512: #endif ! 513: ! 514: /* ! 515: * Stray UNIBUS interrupt catch routines ! 516: */ ! 517: .data ! 518: .align 2 ! 519: #define PJ PUSHR;jsb _Xustray ! 520: .globl _catcher ! 521: _catcher: ! 522: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 523: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 524: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 525: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 526: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 527: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 528: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 529: PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ;PJ ! 530: ! 531: .globl _cold ! 532: _cold: .long 1 ! 533: .data ! 534: ! 535: .text ! 536: SCBVEC(ustray): ! 537: blbc _cold,1f ! 538: mfpr $IPL,r11 ! 539: subl3 $_catcher+8,(sp)+,r10 ! 540: ashl $-1,r10,r10 ! 541: POPR ! 542: rei ! 543: 1: ! 544: subl3 $_catcher+8,(sp)+,r0 ! 545: ashl $-1,r0,-(sp) ! 546: mfpr $IPL,-(sp) ! 547: PRINTF(2, "uba?: stray intr ipl %x vec %o\n") ! 548: POPR ! 549: rei ! 550: ! 551: #ifdef VAX630 ! 552: /* ! 553: * Emulation OpCode jump table: ! 554: * ONLY GOES FROM 0xf8 (-8) TO 0x3B (59) ! 555: */ ! 556: #define EMUTABLE 0x43 ! 557: #define NOEMULATE .long noemulate ! 558: #define EMULATE(a) .long _EM/**/a ! 559: .globl _emJUMPtable ! 560: _emJUMPtable: ! 561: /* f8 */ EMULATE(ashp); EMULATE(cvtlp); NOEMULATE; NOEMULATE ! 562: /* fc */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 563: /* 00 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 564: /* 04 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 565: /* 08 */ EMULATE(cvtps); EMULATE(cvtsp); NOEMULATE; EMULATE(crc) ! 566: /* 0c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 567: /* 10 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 568: /* 14 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 569: /* 18 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 570: /* 1c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 571: /* 20 */ EMULATE(addp4); EMULATE(addp6); EMULATE(subp4); EMULATE(subp6) ! 572: /* 24 */ EMULATE(cvtpt); EMULATE(mulp); EMULATE(cvttp); EMULATE(divp) ! 573: /* 28 */ NOEMULATE; EMULATE(cmpc3); EMULATE(scanc); EMULATE(spanc) ! 574: /* 2c */ NOEMULATE; EMULATE(cmpc5); EMULATE(movtc); EMULATE(movtuc) ! 575: /* 30 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 576: /* 34 */ EMULATE(movp); EMULATE(cmpp3); EMULATE(cvtpl); EMULATE(cmpp4) ! 577: /* 38 */ EMULATE(editpc); EMULATE(matchc); EMULATE(locc); EMULATE(skpc) ! 578: #endif ! 579: ! 580: /* ! 581: * Trap and fault vector routines ! 582: */ ! 583: #define TRAP(a) pushl $T_/**/a; jbr alltraps ! 584: ! 585: /* ! 586: * Ast delivery (profiling and/or reschedule) ! 587: */ ! 588: SCBVEC(astflt): ! 589: pushl $0; TRAP(ASTFLT) ! 590: SCBVEC(privinflt): ! 591: pushl $0; TRAP(PRIVINFLT) ! 592: SCBVEC(xfcflt): ! 593: pushl $0; TRAP(XFCFLT) ! 594: SCBVEC(resopflt): ! 595: pushl $0; TRAP(RESOPFLT) ! 596: SCBVEC(resadflt): ! 597: pushl $0; TRAP(RESADFLT) ! 598: SCBVEC(bptflt): ! 599: pushl $0; TRAP(BPTFLT) ! 600: SCBVEC(compatflt): ! 601: TRAP(COMPATFLT); ! 602: SCBVEC(tracep): ! 603: pushl $0; TRAP(TRCTRAP) ! 604: SCBVEC(arithtrap): ! 605: TRAP(ARITHTRAP) ! 606: SCBVEC(protflt): ! 607: blbs (sp)+,segflt ! 608: TRAP(PROTFLT) ! 609: segflt: ! 610: TRAP(SEGFLT) ! 611: ! 612: /* ! 613: * The following is called with the stack set up as follows: ! 614: * ! 615: * (sp): Opcode ! 616: * 4(sp): Instruction PC ! 617: * 8(sp): Operand 1 ! 618: * 12(sp): Operand 2 ! 619: * 16(sp): Operand 3 ! 620: * 20(sp): Operand 4 ! 621: * 24(sp): Operand 5 ! 622: * 28(sp): Operand 6 ! 623: * 32(sp): Operand 7 (unused) ! 624: * 36(sp): Operand 8 (unused) ! 625: * 40(sp): Return PC ! 626: * 44(sp): Return PSL ! 627: * 48(sp): TOS before instruction ! 628: * ! 629: * Each individual routine is called with the stack set up as follows: ! 630: * ! 631: * (sp): Return address of trap handler ! 632: * 4(sp): Opcode (will get return PSL) ! 633: * 8(sp): Instruction PC ! 634: * 12(sp): Operand 1 ! 635: * 16(sp): Operand 2 ! 636: * 20(sp): Operand 3 ! 637: * 24(sp): Operand 4 ! 638: * 28(sp): Operand 5 ! 639: * 32(sp): Operand 6 ! 640: * 36(sp): saved register 11 ! 641: * 40(sp): saved register 10 ! 642: * 44(sp): Return PC ! 643: * 48(sp): Return PSL ! 644: * 52(sp): TOS before instruction ! 645: */ ! 646: ! 647: SCBVEC(emulate): ! 648: #ifdef VAX630 ! 649: movl r11,32(sp) # save register r11 in unused operand ! 650: movl r10,36(sp) # save register r10 in unused operand ! 651: cvtbl (sp),r10 # get opcode ! 652: addl2 $8,r10 # shift negative opcodes ! 653: subl3 r10,$EMUTABLE,r11 # forget it if opcode is out of range ! 654: bcs noemulate ! 655: movl _emJUMPtable[r10],r10 # call appropriate emulation routine ! 656: jsb (r10) # routines put return values into regs 0-5 ! 657: movl 32(sp),r11 # restore register r11 ! 658: movl 36(sp),r10 # restore register r10 ! 659: insv (sp),$0,$4,44(sp) # and condition codes in Opcode spot ! 660: addl2 $40,sp # adjust stack for return ! 661: rei ! 662: noemulate: ! 663: addl2 $48,sp # adjust stack for ! 664: #endif VAX630 ! 665: .word 0xffff # "reserved instruction fault" ! 666: SCBVEC(emulateFPD): ! 667: .word 0xffff # "reserved instruction fault" ! 668: SCBVEC(transflt): ! 669: bitl $2,(sp)+ ! 670: bnequ tableflt ! 671: jsb Fastreclaim # try and avoid pagein ! 672: TRAP(PAGEFLT) ! 673: tableflt: ! 674: TRAP(TABLEFLT) ! 675: ! 676: alltraps: ! 677: mfpr $USP,-(sp); calls $0,_trap; mtpr (sp)+,$USP ! 678: incl _cnt+V_TRAP ! 679: addl2 $8,sp # pop type, code ! 680: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) ! 681: rei ! 682: ! 683: SCBVEC(syscall): ! 684: pushl $T_SYSCALL ! 685: mfpr $USP,-(sp); calls $0,_syscall; mtpr (sp)+,$USP ! 686: incl _cnt+V_SYSCALL ! 687: addl2 $8,sp # pop type, code ! 688: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) ! 689: rei ! 690: ! 691: /* ! 692: * System page table ! 693: * Mbmap and Usrptmap are enlarged by CLSIZE entries ! 694: * as they are managed by resource maps starting with index 1 or CLSIZE. ! 695: */ ! 696: #define vaddr(x) ((((x)-_Sysmap)/4)*NBPG+0x80000000) ! 697: #define SYSMAP(mname, vname, npte) \ ! 698: _/**/mname: .globl _/**/mname; \ ! 699: .space (npte)*4; \ ! 700: .globl _/**/vname; \ ! 701: .set _/**/vname,vaddr(_/**/mname) ! 702: ! 703: .data ! 704: .align 2 ! 705: SYSMAP(Sysmap ,Sysbase ,SYSPTSIZE ) ! 706: SYSMAP(Forkmap ,forkutl ,UPAGES ) ! 707: SYSMAP(Xswapmap ,xswaputl ,UPAGES ) ! 708: SYSMAP(Xswap2map,xswap2utl ,UPAGES ) ! 709: SYSMAP(Swapmap ,swaputl ,UPAGES ) ! 710: SYSMAP(Pushmap ,pushutl ,UPAGES ) ! 711: SYSMAP(Vfmap ,vfutl ,UPAGES ) ! 712: SYSMAP(CMAP1 ,CADDR1 ,1 ) ! 713: SYSMAP(CMAP2 ,CADDR2 ,1 ) ! 714: SYSMAP(mmap ,vmmap ,1 ) ! 715: SYSMAP(alignmap ,alignutl ,1 ) /* XXX */ ! 716: SYSMAP(msgbufmap,msgbuf ,MSGBUFPTECNT ) ! 717: SYSMAP(Mbmap ,mbutl ,NMBCLUSTERS*CLSIZE+CLSIZE ) ! 718: SYSMAP(camap ,cabase ,16*CLSIZE ) ! 719: #ifdef GPROF ! 720: SYSMAP(profmap ,profbase ,600*CLSIZE ) ! 721: #endif ! 722: SYSMAP(ecamap ,calimit ,0 ) ! 723: ! 724: SYSMAP(UMBAbeg ,umbabeg ,0 ) ! 725: SYSMAP(Nexmap ,nexus ,16*MAXNNEXUS ) ! 726: SYSMAP(UMEMmap ,umem ,UBAPAGES*NUBA ) ! 727: SYSMAP(Ioamap ,ioa ,MAXNIOA*IOAMAPSIZ/NBPG ) ! 728: SYSMAP(UMBAend ,umbaend ,0 ) ! 729: #if VAX630 ! 730: SYSMAP(Clockmap ,cldevice ,1 ) ! 731: SYSMAP(Ka630map ,ka630cpu ,1 ) ! 732: #endif ! 733: ! 734: SYSMAP(Usrptmap ,usrpt ,USRPTSIZE+CLSIZE ) ! 735: ! 736: eSysmap: ! 737: .globl _Syssize ! 738: .set _Syssize,(eSysmap-_Sysmap)/4 ! 739: .text ! 740: ! 741: /* ! 742: * Initialization ! 743: * ! 744: * ipl 0x1f; mapen 0; scbb, pcbb, sbr, slr, isp, ksp not set ! 745: */ ! 746: .data ! 747: .globl _cpu ! 748: _cpu: .long 0 ! 749: .text ! 750: .globl start ! 751: start: ! 752: .word 0 ! 753: mtpr $0,$ICCS ! 754: /* set system control block base and system page table params */ ! 755: mtpr $_scb-0x80000000,$SCBB ! 756: mtpr $_Sysmap-0x80000000,$SBR ! 757: mtpr $_Syssize,$SLR ! 758: /* double map the kernel into the virtual user addresses of phys mem */ ! 759: mtpr $_Sysmap,$P0BR ! 760: mtpr $_Syssize,$P0LR ! 761: /* set ISP and get cpu type */ ! 762: movl $_intstack+NISP*NBPG,sp ! 763: mfpr $SID,r0 ! 764: movab _cpu,r1 ! 765: extzv $24,$8,r0,(r1) ! 766: /* init RPB */ ! 767: movab _rpb,r0 ! 768: movl r0,(r0)+ # rp_selfref ! 769: movab _doadump,r1 ! 770: movl r1,(r0)+ # rp_dumprout ! 771: movl $0x1f,r2 ! 772: clrl r3 ! 773: 1: addl2 (r1)+,r3; sobgtr r2,1b ! 774: movl r3,(r0)+ # rp_chksum ! 775: /* count up memory */ ! 776: clrl r7 ! 777: 1: pushl $4; pushl r7; calls $2,_badaddr; tstl r0; bneq 9f ! 778: acbl $MAXMEM*1024-1,$64*1024,r7,1b ! 779: 9: ! 780: #ifdef VAX630 ! 781: /* leave an area for uVAX II console scratch pad at the top */ ! 782: cmpb _cpu,$VAX_630 ! 783: bneq 1f ! 784: subl2 $4096,r7 ! 785: 1: ! 786: #endif ! 787: /* clear memory from kernel bss and pages for proc 0 u. and page table */ ! 788: movab _edata,r6 ! 789: movab _end,r5 ! 790: bbcc $31,r5,0f; 0: ! 791: addl2 $(UPAGES*NBPG)+NBPG+NBPG,r5 ! 792: 1: clrq (r6); acbl r5,$8,r6,1b ! 793: /* trap() and syscall() save r0-r11 in the entry mask (per ../h/reg.h) */ ! 794: /* panic() is convenient place to save all for debugging */ ! 795: bisw2 $0x0fff,_trap ! 796: bisw2 $0x0fff,_syscall ! 797: bisw2 $0x0fff,_panic ! 798: calls $0,_fixctlrmask ! 799: /* initialize system page table: uba vectors and int stack writeable */ ! 800: clrl r2 ! 801: movab eintstack,r1; bbcc $31,r1,0f; 0: ashl $-PGSHIFT,r1,r1 ! 802: 1: bisl3 $PG_V|PG_KW,r2,_Sysmap[r2]; aoblss r1,r2,1b ! 803: /* make rpb, scb read-only as red zone for interrupt stack */ ! 804: bicl2 $PG_PROT,_rpbmap ! 805: bisl2 $PG_KR,_rpbmap ! 806: /* make kernel text space read-only */ ! 807: movab _etext+NBPG-1,r1; bbcc $31,r1,0f; 0: ashl $-PGSHIFT,r1,r1 ! 808: 1: bisl3 $PG_V|PG_URKR,r2,_Sysmap[r2]; aoblss r1,r2,1b ! 809: /* make kernel data, bss, read-write */ ! 810: movab _end+NBPG-1,r1; bbcc $31,r1,0f; 0:; ashl $-PGSHIFT,r1,r1 ! 811: 1: bisl3 $PG_V|PG_KW,r2,_Sysmap[r2]; aoblss r1,r2,1b ! 812: /* now go to mapped mode */ ! 813: mtpr $0,$TBIA; mtpr $1,$MAPEN; jmp *$0f; 0: ! 814: /* init mem sizes */ ! 815: ashl $-PGSHIFT,r7,_maxmem ! 816: movl _maxmem,_physmem ! 817: movl _maxmem,_freemem ! 818: /* setup context for proc[0] == Scheduler */ ! 819: movab _end+NBPG-1,r6 ! 820: bicl2 $NBPG-1,r6 # make page boundary ! 821: /* setup page table for proc[0] */ ! 822: bbcc $31,r6,0f; 0: ! 823: ashl $-PGSHIFT,r6,r3 # r3 = btoc(r6) ! 824: bisl3 $PG_V|PG_KW,r3,_Usrptmap # init first upt entry ! 825: incl r3 ! 826: movab _usrpt,r0 ! 827: mtpr r0,$TBIS ! 828: /* init p0br, p0lr */ ! 829: mtpr r0,$P0BR ! 830: mtpr $0,$P0LR ! 831: /* init p1br, p1lr */ ! 832: movab NBPG(r0),r0 ! 833: movl $0x200000-UPAGES,r1 ! 834: mtpr r1,$P1LR ! 835: mnegl r1,r1 ! 836: moval -4*UPAGES(r0)[r1],r2 ! 837: mtpr r2,$P1BR ! 838: /* setup mapping for UPAGES of _u */ ! 839: movl $UPAGES,r2; movab _u+NBPG*UPAGES,r1; addl2 $UPAGES,r3; jbr 2f ! 840: 1: decl r3 ! 841: moval -NBPG(r1),r1; ! 842: bisl3 $PG_V|PG_URKW,r3,-(r0) ! 843: mtpr r1,$TBIS ! 844: 2: sobgeq r2,1b ! 845: /* initialize (slightly) the pcb */ ! 846: movab UPAGES*NBPG(r1),PCB_KSP(r1) ! 847: mnegl $1,PCB_ESP(r1) ! 848: mnegl $1,PCB_SSP(r1) ! 849: movl r1,PCB_USP(r1) ! 850: mfpr $P0BR,PCB_P0BR(r1) ! 851: mfpr $P0LR,PCB_P0LR(r1) ! 852: movb $4,PCB_P0LR+3(r1) # disable ast ! 853: mfpr $P1BR,PCB_P1BR(r1) ! 854: mfpr $P1LR,PCB_P1LR(r1) ! 855: movl $CLSIZE,PCB_SZPT(r1) # init u.u_pcb.pcb_szpt ! 856: movl r10,PCB_R10(r1) ! 857: movl r11,PCB_R11(r1) ! 858: movab 1f,PCB_PC(r1) # initial pc ! 859: clrl PCB_PSL(r1) # mode(k,k), ipl=0 ! 860: ashl $PGSHIFT,r3,r3 ! 861: mtpr r3,$PCBB # first pcbb ! 862: /* set regs, p0br, p0lr, p1br, p1lr, astlvl, ksp and change to kernel mode */ ! 863: ldpctx ! 864: rei ! 865: /* put signal trampoline code in u. area */ ! 866: 1: movab _u,r0 ! 867: movc3 $19,sigcode,PCB_SIGC(r0) ! 868: /* save boot device in global _bootdev */ ! 869: movl r10,_bootdev ! 870: /* save reboot flags in global _boothowto */ ! 871: movl r11,_boothowto ! 872: /* calculate firstaddr, and call main() */ ! 873: movab _end+NBPG-1,r0; bbcc $31,r0,0f; 0:; ashl $-PGSHIFT,r0,-(sp) ! 874: addl2 $UPAGES+1,(sp); calls $1,_main ! 875: /* proc[1] == /etc/init now running here; run icode */ ! 876: pushl $PSL_CURMOD|PSL_PRVMOD; pushl $0; rei ! 877: ! 878: /* signal trampoline code: it is known that this code takes exactly 19 bytes */ ! 879: /* in ../vax/pcb.h and in the movc3 above */ ! 880: sigcode: ! 881: calls $4,8(pc) # params pushed by sendsig ! 882: movl sp,ap # calls frame built by sendsig ! 883: chmk $103 # cleanup mask and onsigstack ! 884: halt # sigreturn() does not return! ! 885: .word 0x3f # registers 0-5 ! 886: callg (ap),*16(ap) # call the signal handler ! 887: ret # return to code above ! 888: ! 889: .set exec,11 ! 890: .set exit,1 ! 891: .globl _icode ! 892: .globl _initflags ! 893: .globl _szicode ! 894: /* ! 895: * Icode is copied out to process 1 to exec /etc/init. ! 896: * If the exec fails, process 1 exits. ! 897: */ ! 898: _icode: ! 899: pushab b`argv-l0(pc) ! 900: l0: pushab b`init-l1(pc) ! 901: l1: pushl $2 ! 902: movl sp,ap ! 903: chmk $exec ! 904: chmk $exit ! 905: ! 906: init: .asciz "/etc/init" ! 907: .align 2 ! 908: _initflags: ! 909: .long 0 ! 910: argv: .long init+5-_icode ! 911: .long _initflags-_icode ! 912: .long 0 ! 913: _szicode: ! 914: .long _szicode-_icode ! 915: ! 916: /* ! 917: * Primitives ! 918: */ ! 919: ! 920: #ifdef GPROF ! 921: #define ENTRY(name, regs) \ ! 922: .globl _/**/name; .align 1; _/**/name: .word regs; jsb mcount ! 923: #define JSBENTRY(name, regs) \ ! 924: .globl _/**/name; _/**/name: \ ! 925: movl fp,-(sp); movab -12(sp),fp; pushr $(regs); jsb mcount; \ ! 926: popr $(regs); movl (sp)+,fp ! 927: #else ! 928: #define ENTRY(name, regs) \ ! 929: .globl _/**/name; .align 1; _/**/name: .word regs ! 930: #define JSBENTRY(name, regs) \ ! 931: .globl _/**/name; _/**/name: ! 932: #endif GPROF ! 933: #define R0 0x01 ! 934: #define R1 0x02 ! 935: #define R2 0x04 ! 936: #define R3 0x08 ! 937: #define R4 0x10 ! 938: #define R5 0x20 ! 939: #define R6 0x40 ! 940: ! 941: /* ! 942: * badaddr(addr, len) ! 943: * see if access addr with a len type instruction causes a machine check ! 944: * len is length of access (1=byte, 2=short, 4=long) ! 945: */ ! 946: .globl _badaddr ! 947: _badaddr: ! 948: .word 0 ! 949: movl $1,r0 ! 950: mfpr $IPL,r1 ! 951: mtpr $HIGH,$IPL ! 952: movl 4(ap),r3 ! 953: movl 8(ap),r4 ! 954: movab 2f,nofault # jump to 2f on machcheck ! 955: bbc $0,r4,1f; tstb (r3) ! 956: 1: bbc $1,r4,1f; tstw (r3) ! 957: 1: bbc $2,r4,1f; tstl (r3) ! 958: 1: clrl r0 # made it w/o machine checks ! 959: 2: clrl nofault ! 960: mtpr r1,$IPL ! 961: ret ! 962: ! 963: /* ! 964: * update profiling information for the user ! 965: * addupc(pc, &u.u_prof, ticks) ! 966: */ ! 967: ENTRY(addupc, 0) ! 968: movl 8(ap),r2 # &u.u_prof ! 969: subl3 8(r2),4(ap),r0 # corrected pc ! 970: blss 9f ! 971: extzv $1,$31,r0,r0 # logical right shift ! 972: extzv $1,$31,12(r2),r1 # ditto for scale ! 973: emul r1,r0,$0,r0 ! 974: ashq $-14,r0,r0 ! 975: tstl r1 ! 976: bneq 9f ! 977: bicl2 $1,r0 ! 978: cmpl r0,4(r2) # length ! 979: bgequ 9f ! 980: addl2 (r2),r0 # base ! 981: probew $3,$2,(r0) ! 982: beql 8f ! 983: addw2 12(ap),(r0) ! 984: 9: ! 985: ret ! 986: 8: ! 987: clrl 12(r2) ! 988: ret ! 989: ! 990: /* ! 991: * Copy a null terminated string from the user address space into ! 992: * the kernel address space. ! 993: * ! 994: * copyinstr(fromaddr, toaddr, maxlength, &lencopied) ! 995: */ ! 996: ENTRY(copyinstr, R6) ! 997: movl 12(ap),r6 # r6 = max length ! 998: jlss 8f ! 999: movl 4(ap),r1 # r1 = user address ! 1000: bicl3 $~(NBPG*CLSIZE-1),r1,r2 # r2 = bytes on first page ! 1001: subl3 r2,$NBPG*CLSIZE,r2 ! 1002: movl 8(ap),r3 # r3 = kernel address ! 1003: 1: ! 1004: cmpl r6,r2 # r2 = min(bytes on page, length left); ! 1005: jgeq 2f ! 1006: movl r6,r2 ! 1007: 2: ! 1008: prober $3,r2,(r1) # bytes accessible? ! 1009: jeql 8f ! 1010: subl2 r2,r6 # update bytes left count ! 1011: #ifdef NOSUBSINST ! 1012: # fake the locc instr. for processors that don't have it ! 1013: movl r2,r0 ! 1014: 6: ! 1015: tstb (r1)+ ! 1016: jeql 5f ! 1017: sobgtr r0,6b ! 1018: jbr 7f ! 1019: 5: ! 1020: decl r1 ! 1021: jbr 3f ! 1022: 7: ! 1023: #else ! 1024: locc $0,r2,(r1) # null byte found? ! 1025: jneq 3f ! 1026: #endif ! 1027: subl2 r2,r1 # back up pointer updated by `locc' ! 1028: movc3 r2,(r1),(r3) # copy in next piece ! 1029: movl $(NBPG*CLSIZE),r2 # check next page ! 1030: tstl r6 # run out of space? ! 1031: jneq 1b ! 1032: movl $ENOENT,r0 # set error code and return ! 1033: jbr 9f ! 1034: 3: ! 1035: tstl 16(ap) # return length? ! 1036: beql 4f ! 1037: subl3 r6,12(ap),r6 # actual len = maxlen - unused pages ! 1038: subl2 r0,r6 # - unused on this page ! 1039: addl3 $1,r6,*16(ap) # + the null byte ! 1040: 4: ! 1041: subl2 r0,r2 # r2 = number of bytes to move ! 1042: subl2 r2,r1 # back up pointer updated by `locc' ! 1043: incl r2 # copy null byte as well ! 1044: movc3 r2,(r1),(r3) # copy in last piece ! 1045: clrl r0 # redundant ! 1046: ret ! 1047: 8: ! 1048: movl $EFAULT,r0 ! 1049: 9: ! 1050: tstl 16(ap) ! 1051: beql 1f ! 1052: subl3 r6,12(ap),*16(ap) ! 1053: 1: ! 1054: ret ! 1055: ! 1056: /* ! 1057: * Copy a null terminated string from the kernel ! 1058: * address space to the user address space. ! 1059: * ! 1060: * copyoutstr(fromaddr, toaddr, maxlength, &lencopied) ! 1061: */ ! 1062: ENTRY(copyoutstr, R6) ! 1063: movl 12(ap),r6 # r6 = max length ! 1064: jlss 8b ! 1065: movl 4(ap),r1 # r1 = kernel address ! 1066: movl 8(ap),r3 # r3 = user address ! 1067: bicl3 $~(NBPG*CLSIZE-1),r3,r2 # r2 = bytes on first page ! 1068: subl3 r2,$NBPG*CLSIZE,r2 ! 1069: 1: ! 1070: cmpl r6,r2 # r2 = min(bytes on page, length left); ! 1071: jgeq 2f ! 1072: movl r6,r2 ! 1073: 2: ! 1074: probew $3,r2,(r3) # bytes accessible? ! 1075: jeql 8b ! 1076: subl2 r2,r6 # update bytes left count ! 1077: #ifdef NOSUBSINST ! 1078: # fake the locc instr. for processors that don't have it ! 1079: movl r2,r0 ! 1080: 6: ! 1081: tstb (r1)+ ! 1082: jeql 5f ! 1083: sobgtr r0,6b ! 1084: jbr 7f ! 1085: 5: ! 1086: decl r1 ! 1087: jbr 3b ! 1088: 7: ! 1089: #else ! 1090: locc $0,r2,(r1) # null byte found? ! 1091: jneq 3b ! 1092: #endif ! 1093: subl2 r2,r1 # back up pointer updated by `locc' ! 1094: movc3 r2,(r1),(r3) # copy in next piece ! 1095: movl $(NBPG*CLSIZE),r2 # check next page ! 1096: tstl r6 # run out of space? ! 1097: jneq 1b ! 1098: movl $ENOENT,r0 # set error code and return ! 1099: jbr 9b ! 1100: ! 1101: /* ! 1102: * Copy a null terminated string from one point to another in ! 1103: * the kernel address space. ! 1104: * ! 1105: * copystr(fromaddr, toaddr, maxlength, &lencopied) ! 1106: */ ! 1107: ENTRY(copystr, R6) ! 1108: movl 12(ap),r6 # r6 = max length ! 1109: jlss 8b ! 1110: movl 4(ap),r1 # r1 = src address ! 1111: movl 8(ap),r3 # r3 = dest address ! 1112: 1: ! 1113: movzwl $65535,r2 # r2 = bytes in first chunk ! 1114: cmpl r6,r2 # r2 = min(bytes in chunk, length left); ! 1115: jgeq 2f ! 1116: movl r6,r2 ! 1117: 2: ! 1118: subl2 r2,r6 # update bytes left count ! 1119: #ifdef NOSUBSINST ! 1120: # fake the locc instr. for processors that don't have it ! 1121: movl r2,r0 ! 1122: 6: ! 1123: tstb (r1)+ ! 1124: jeql 5f ! 1125: sobgtr r0,6b ! 1126: jbr 7f ! 1127: 5: ! 1128: decl r1 ! 1129: jbr 3b ! 1130: 7: ! 1131: #else ! 1132: locc $0,r2,(r1) # null byte found? ! 1133: jneq 3b ! 1134: #endif ! 1135: subl2 r2,r1 # back up pointer updated by `locc' ! 1136: movc3 r2,(r1),(r3) # copy in next piece ! 1137: tstl r6 # run out of space? ! 1138: jneq 1b ! 1139: movl $ENOENT,r0 # set error code and return ! 1140: jbr 9b ! 1141: ! 1142: /* ! 1143: * Copy specified amount of data from user space into the kernel ! 1144: * Copyin(from, to, len) ! 1145: * r1 == from (user source address) ! 1146: * r3 == to (kernel destination address) ! 1147: * r5 == length ! 1148: */ ! 1149: .align 1 ! 1150: JSBENTRY(Copyin, R1|R3|R5) ! 1151: cmpl r5,$(NBPG*CLSIZE) # probing one page or less ? ! 1152: bgtru 1f # no ! 1153: prober $3,r5,(r1) # bytes accessible ? ! 1154: beql ersb # no ! 1155: movc3 r5,(r1),(r3) ! 1156: /* clrl r0 # redundant */ ! 1157: rsb ! 1158: 1: ! 1159: blss ersb # negative length? ! 1160: pushl r6 # r6 = length ! 1161: movl r5,r6 ! 1162: bicl3 $~(NBPG*CLSIZE-1),r1,r0 # r0 = bytes on first page ! 1163: subl3 r0,$(NBPG*CLSIZE),r0 ! 1164: addl2 $(NBPG*CLSIZE),r0 # plus one additional full page ! 1165: jbr 2f ! 1166: ! 1167: ciloop: ! 1168: movc3 r0,(r1),(r3) ! 1169: movl $(2*NBPG*CLSIZE),r0 # next amount to move ! 1170: 2: ! 1171: cmpl r0,r6 ! 1172: bleq 3f ! 1173: movl r6,r0 ! 1174: 3: ! 1175: prober $3,r0,(r1) # bytes accessible ? ! 1176: beql ersb1 # no ! 1177: subl2 r0,r6 # last move? ! 1178: bneq ciloop # no ! 1179: ! 1180: movc3 r0,(r1),(r3) ! 1181: /* clrl r0 # redundant */ ! 1182: movl (sp)+,r6 # restore r6 ! 1183: rsb ! 1184: ! 1185: ersb1: ! 1186: movl (sp)+,r6 # restore r6 ! 1187: ersb: ! 1188: movl $EFAULT,r0 ! 1189: rsb ! 1190: ! 1191: /* ! 1192: * Copy specified amount of data from kernel to the user space ! 1193: * Copyout(from, to, len) ! 1194: * r1 == from (kernel source address) ! 1195: * r3 == to (user destination address) ! 1196: * r5 == length ! 1197: */ ! 1198: .align 1 ! 1199: JSBENTRY(Copyout, R1|R3|R5) ! 1200: cmpl r5,$(NBPG*CLSIZE) # moving one page or less ? ! 1201: bgtru 1f # no ! 1202: probew $3,r5,(r3) # bytes writeable? ! 1203: beql ersb # no ! 1204: movc3 r5,(r1),(r3) ! 1205: /* clrl r0 # redundant */ ! 1206: rsb ! 1207: 1: ! 1208: blss ersb # negative length? ! 1209: pushl r6 # r6 = length ! 1210: movl r5,r6 ! 1211: bicl3 $~(NBPG*CLSIZE-1),r3,r0 # r0 = bytes on first page ! 1212: subl3 r0,$(NBPG*CLSIZE),r0 ! 1213: addl2 $(NBPG*CLSIZE),r0 # plus one additional full page ! 1214: jbr 2f ! 1215: ! 1216: coloop: ! 1217: movc3 r0,(r1),(r3) ! 1218: movl $(2*NBPG*CLSIZE),r0 # next amount to move ! 1219: 2: ! 1220: cmpl r0,r6 ! 1221: bleq 3f ! 1222: movl r6,r0 ! 1223: 3: ! 1224: probew $3,r0,(r3) # bytes writeable? ! 1225: beql ersb1 # no ! 1226: subl2 r0,r6 # last move? ! 1227: bneq coloop # no ! 1228: ! 1229: movc3 r0,(r1),(r3) ! 1230: /* clrl r0 # redundant */ ! 1231: movl (sp)+,r6 # restore r6 ! 1232: rsb ! 1233: ! 1234: /* ! 1235: * non-local goto's ! 1236: */ ! 1237: #ifdef notdef /* this is now expanded completely inline */ ! 1238: .align 1 ! 1239: JSBENTRY(Setjmp, R0) ! 1240: movl fp,(r0)+ # current stack frame ! 1241: movl (sp),(r0) # resuming pc ! 1242: clrl r0 ! 1243: rsb ! 1244: #endif ! 1245: ! 1246: #define PCLOC 16 /* location of pc in calls frame */ ! 1247: #define APLOC 8 /* location of ap,fp in calls frame */ ! 1248: .align 1 ! 1249: JSBENTRY(Longjmp, R0) ! 1250: movl (r0)+,newfp # must save parameters in memory as all ! 1251: movl (r0),newpc # registers may be clobbered. ! 1252: 1: ! 1253: cmpl fp,newfp # are we there yet? ! 1254: bgequ 2f # yes ! 1255: moval 1b,PCLOC(fp) # redirect return pc to us! ! 1256: ret # pop next frame ! 1257: 2: ! 1258: beql 3f # did we miss our frame? ! 1259: pushab 4f # yep ?!? ! 1260: calls $1,_panic ! 1261: 3: ! 1262: movl newpc,r0 # all done, just return to the `setjmp' ! 1263: jmp (r0) # ``rsb'' ! 1264: ! 1265: .data ! 1266: newpc: .space 4 ! 1267: newfp: .space 4 ! 1268: 4: .asciz "longjmp" ! 1269: .text ! 1270: /* ! 1271: * setjmp that saves all registers as the call frame may not ! 1272: * be available to recover them in the usual mannor by longjmp. ! 1273: * Called before swapping out the u. area, restored by resume() ! 1274: * below. ! 1275: */ ! 1276: ENTRY(savectx, 0) ! 1277: movl 4(ap),r0 ! 1278: movq r6,(r0)+ ! 1279: movq r8,(r0)+ ! 1280: movq r10,(r0)+ ! 1281: movq APLOC(fp),(r0)+ # save ap, fp ! 1282: addl3 $8,ap,(r0)+ # save sp ! 1283: movl PCLOC(fp),(r0) # save pc ! 1284: clrl r0 ! 1285: ret ! 1286: ! 1287: .globl _whichqs ! 1288: .globl _qs ! 1289: .globl _cnt ! 1290: ! 1291: .globl _noproc ! 1292: .comm _noproc,4 ! 1293: .globl _runrun ! 1294: .comm _runrun,4 ! 1295: ! 1296: /* ! 1297: * The following primitives use the fancy VAX instructions ! 1298: * much like VMS does. _whichqs tells which of the 32 queues _qs ! 1299: * have processes in them. Setrq puts processes into queues, Remrq ! 1300: * removes them from queues. The running process is on no queue, ! 1301: * other processes are on a queue related to p->p_pri, divided by 4 ! 1302: * actually to shrink the 0-127 range of priorities into the 32 available ! 1303: * queues. ! 1304: */ ! 1305: ! 1306: /* ! 1307: * Setrq(p), using fancy VAX instructions. ! 1308: * ! 1309: * Call should be made at splclock(), and p->p_stat should be SRUN ! 1310: */ ! 1311: .align 1 ! 1312: JSBENTRY(Setrq, R0) ! 1313: tstl P_RLINK(r0) ## firewall: p->p_rlink must be 0 ! 1314: beql set1 ## ! 1315: pushab set3 ## ! 1316: calls $1,_panic ## ! 1317: set1: ! 1318: movzbl P_PRI(r0),r1 # put on queue which is p->p_pri / 4 ! 1319: ashl $-2,r1,r1 ! 1320: movaq _qs[r1],r2 ! 1321: insque (r0),*4(r2) # at end of queue ! 1322: bbss r1,_whichqs,set2 # mark queue non-empty ! 1323: set2: ! 1324: rsb ! 1325: ! 1326: set3: .asciz "setrq" ! 1327: ! 1328: /* ! 1329: * Remrq(p), using fancy VAX instructions ! 1330: * ! 1331: * Call should be made at splclock(). ! 1332: */ ! 1333: .align 1 ! 1334: JSBENTRY(Remrq, R0) ! 1335: movzbl P_PRI(r0),r1 ! 1336: ashl $-2,r1,r1 ! 1337: bbsc r1,_whichqs,rem1 ! 1338: pushab rem3 # it wasn't recorded to be on its q ! 1339: calls $1,_panic ! 1340: rem1: ! 1341: remque (r0),r2 ! 1342: beql rem2 ! 1343: bbss r1,_whichqs,rem2 ! 1344: rem2: ! 1345: clrl P_RLINK(r0) ## for firewall checking ! 1346: rsb ! 1347: ! 1348: rem3: .asciz "remrq" ! 1349: ! 1350: /* ! 1351: * Masterpaddr is the p->p_addr of the running process on the master ! 1352: * processor. When a multiprocessor system, the slave processors will have ! 1353: * an array of slavepaddr's. ! 1354: */ ! 1355: .globl _masterpaddr ! 1356: .data ! 1357: _masterpaddr: ! 1358: .long 0 ! 1359: ! 1360: .set ASTLVL_NONE,4 ! 1361: .text ! 1362: sw0: .asciz "swtch" ! 1363: ! 1364: /* ! 1365: * When no processes are on the runq, Swtch branches to idle ! 1366: * to wait for something to come ready. ! 1367: */ ! 1368: .globl Idle ! 1369: Idle: idle: ! 1370: mtpr $0,$IPL # must allow interrupts here ! 1371: tstl _whichqs # look for non-empty queue ! 1372: bneq sw1 ! 1373: brb idle ! 1374: ! 1375: badsw: pushab sw0 ! 1376: calls $1,_panic ! 1377: /*NOTREACHED*/ ! 1378: ! 1379: /* ! 1380: * Swtch(), using fancy VAX instructions ! 1381: */ ! 1382: .align 1 ! 1383: JSBENTRY(Swtch, 0) ! 1384: movl $1,_noproc ! 1385: incl _cnt+V_SWTCH ! 1386: sw1: ffs $0,$32,_whichqs,r0 # look for non-empty queue ! 1387: beql idle # if none, idle ! 1388: mtpr $0x18,$IPL # lock out all so _whichqs==_qs ! 1389: bbcc r0,_whichqs,sw1 # proc moved via lbolt interrupt ! 1390: movaq _qs[r0],r1 ! 1391: remque *(r1),r2 # r2 = p = highest pri process ! 1392: bvs badsw # make sure something was there ! 1393: sw2: beql sw3 ! 1394: insv $1,r0,$1,_whichqs # still more procs in this queue ! 1395: sw3: ! 1396: clrl _noproc ! 1397: clrl _runrun ! 1398: tstl P_WCHAN(r2) ## firewalls ! 1399: bneq badsw ## ! 1400: cmpb P_STAT(r2),$SRUN ## ! 1401: bneq badsw ## ! 1402: clrl P_RLINK(r2) ## ! 1403: movl *P_ADDR(r2),r0 ! 1404: #ifdef notdef ! 1405: cmpl r0,_masterpaddr # resume of current proc is easy ! 1406: beql res0 ! 1407: #endif ! 1408: movl r0,_masterpaddr ! 1409: ashl $PGSHIFT,r0,r0 # r0 = pcbb(p) ! 1410: /* fall into... */ ! 1411: ! 1412: /* ! 1413: * Resume(pf) ! 1414: */ ! 1415: JSBENTRY(Resume, R0) ! 1416: mtpr $HIGH,$IPL # no interrupts, please ! 1417: movl _CMAP2,_u+PCB_CMAP2 # yech ! 1418: svpctx ! 1419: mtpr r0,$PCBB ! 1420: ldpctx ! 1421: movl _u+PCB_CMAP2,_CMAP2 # yech ! 1422: mtpr $_CADDR2,$TBIS ! 1423: res0: ! 1424: tstl _u+PCB_SSWAP ! 1425: bneq res1 ! 1426: rei ! 1427: res1: ! 1428: movl _u+PCB_SSWAP,r0 # longjmp to saved context ! 1429: clrl _u+PCB_SSWAP ! 1430: movq (r0)+,r6 ! 1431: movq (r0)+,r8 ! 1432: movq (r0)+,r10 ! 1433: movq (r0)+,r12 ! 1434: movl (r0)+,r1 ! 1435: cmpl r1,sp # must be a pop ! 1436: bgequ 1f ! 1437: pushab 2f ! 1438: calls $1,_panic ! 1439: /* NOTREACHED */ ! 1440: 1: ! 1441: movl r1,sp ! 1442: movl (r0),(sp) # address to return to ! 1443: movl $PSL_PRVMOD,4(sp) # ``cheating'' (jfr) ! 1444: rei ! 1445: ! 1446: 2: .asciz "ldctx" ! 1447: ! 1448: /* ! 1449: * {fu,su},{byte,word}, all massaged by asm.sed to jsb's ! 1450: */ ! 1451: .align 1 ! 1452: JSBENTRY(Fuword, R0) ! 1453: prober $3,$4,(r0) ! 1454: beql fserr ! 1455: movl (r0),r0 ! 1456: rsb ! 1457: fserr: ! 1458: mnegl $1,r0 ! 1459: rsb ! 1460: ! 1461: .align 1 ! 1462: JSBENTRY(Fubyte, R0) ! 1463: prober $3,$1,(r0) ! 1464: beql fserr ! 1465: movzbl (r0),r0 ! 1466: rsb ! 1467: ! 1468: .align 1 ! 1469: JSBENTRY(Suword, R0|R1) ! 1470: probew $3,$4,(r0) ! 1471: beql fserr ! 1472: movl r1,(r0) ! 1473: clrl r0 ! 1474: rsb ! 1475: ! 1476: .align 1 ! 1477: JSBENTRY(Subyte, R0|R1) ! 1478: probew $3,$1,(r0) ! 1479: beql fserr ! 1480: movb r1,(r0) ! 1481: clrl r0 ! 1482: rsb ! 1483: ! 1484: /* ! 1485: * Copy 1 relocation unit (NBPG bytes) ! 1486: * from user virtual address to physical address ! 1487: */ ! 1488: ENTRY(copyseg, 0) ! 1489: bisl3 $PG_V|PG_KW,8(ap),_CMAP2 ! 1490: mtpr $_CADDR2,$TBIS # invalidate entry for copy ! 1491: movc3 $NBPG,*4(ap),_CADDR2 ! 1492: ret ! 1493: ! 1494: /* ! 1495: * zero out physical memory ! 1496: * specified in relocation units (NBPG bytes) ! 1497: */ ! 1498: ENTRY(clearseg, 0) ! 1499: bisl3 $PG_V|PG_KW,4(ap),_CMAP1 ! 1500: mtpr $_CADDR1,$TBIS ! 1501: movc5 $0,(sp),$0,$NBPG,_CADDR1 ! 1502: ret ! 1503: ! 1504: /* ! 1505: * Check address. ! 1506: * Given virtual address, byte count, and rw flag ! 1507: * returns 0 on no access. ! 1508: */ ! 1509: ENTRY(useracc, 0) ! 1510: movl 4(ap),r0 # get va ! 1511: movl 8(ap),r1 # count ! 1512: tstl 12(ap) # test for read access ? ! 1513: bneq userar # yes ! 1514: cmpl $NBPG,r1 # can we do it in one probe ? ! 1515: bgeq uaw2 # yes ! 1516: uaw1: ! 1517: probew $3,$NBPG,(r0) ! 1518: beql uaerr # no access ! 1519: addl2 $NBPG,r0 ! 1520: acbl $NBPG+1,$-NBPG,r1,uaw1 ! 1521: uaw2: ! 1522: probew $3,r1,(r0) ! 1523: beql uaerr ! 1524: movl $1,r0 ! 1525: ret ! 1526: ! 1527: userar: ! 1528: cmpl $NBPG,r1 ! 1529: bgeq uar2 ! 1530: uar1: ! 1531: prober $3,$NBPG,(r0) ! 1532: beql uaerr ! 1533: addl2 $NBPG,r0 ! 1534: acbl $NBPG+1,$-NBPG,r1,uar1 ! 1535: uar2: ! 1536: prober $3,r1,(r0) ! 1537: beql uaerr ! 1538: movl $1,r0 ! 1539: ret ! 1540: uaerr: ! 1541: clrl r0 ! 1542: ret ! 1543: ! 1544: /* ! 1545: * kernacc - check for kernel access privileges ! 1546: * ! 1547: * We can't use the probe instruction directly because ! 1548: * it ors together current and previous mode. ! 1549: */ ! 1550: ENTRY(kernacc, 0) ! 1551: movl 4(ap),r0 # virtual address ! 1552: bbcc $31,r0,kacc1 ! 1553: bbs $30,r0,kacerr ! 1554: mfpr $SBR,r2 # address and length of page table (system) ! 1555: bbss $31,r2,0f; 0: ! 1556: mfpr $SLR,r3 ! 1557: brb kacc2 ! 1558: kacc1: ! 1559: bbsc $30,r0,kacc3 ! 1560: mfpr $P0BR,r2 # user P0 ! 1561: mfpr $P0LR,r3 ! 1562: brb kacc2 ! 1563: kacc3: ! 1564: mfpr $P1BR,r2 # user P1 (stack) ! 1565: mfpr $P1LR,r3 ! 1566: kacc2: ! 1567: addl3 8(ap),r0,r1 # ending virtual address ! 1568: addl2 $NBPG-1,r1 ! 1569: ashl $-PGSHIFT,r0,r0 ! 1570: ashl $-PGSHIFT,r1,r1 ! 1571: bbs $31,4(ap),kacc6 ! 1572: bbc $30,4(ap),kacc6 ! 1573: cmpl r0,r3 # user stack ! 1574: blss kacerr # address too low ! 1575: brb kacc4 ! 1576: kacc6: ! 1577: cmpl r1,r3 # compare last page to P0LR or SLR ! 1578: bgtr kacerr # address too high ! 1579: kacc4: ! 1580: movl (r2)[r0],r3 ! 1581: bbc $31,4(ap),kacc4a ! 1582: bbc $31,r3,kacerr # valid bit is off ! 1583: kacc4a: ! 1584: cmpzv $27,$4,r3,$1 # check protection code ! 1585: bleq kacerr # no access allowed ! 1586: tstb 12(ap) ! 1587: bneq kacc5 # only check read access ! 1588: cmpzv $27,$2,r3,$3 # check low 2 bits of prot code ! 1589: beql kacerr # no write access ! 1590: kacc5: ! 1591: aoblss r1,r0,kacc4 # next page ! 1592: movl $1,r0 # no errors ! 1593: ret ! 1594: kacerr: ! 1595: clrl r0 # error ! 1596: ret ! 1597: /* ! 1598: * Extracted and unrolled most common case of pagein (hopefully): ! 1599: * resident and not on free list (reclaim of page is purely ! 1600: * for the purpose of simulating a reference bit) ! 1601: * ! 1602: * Built in constants: ! 1603: * CLSIZE of 2, any bit fields in pte's ! 1604: */ ! 1605: .text ! 1606: .globl Fastreclaim ! 1607: Fastreclaim: ! 1608: PUSHR ! 1609: #ifdef GPROF ! 1610: movl fp,-(sp) ! 1611: movab 12(sp),fp ! 1612: jsb mcount ! 1613: movl (sp)+,fp ! 1614: #endif GPROF ! 1615: extzv $9,$23,28(sp),r3 # virtual address ! 1616: bicl2 $1,r3 # v = clbase(btop(virtaddr)); ! 1617: movl _u+U_PROCP,r5 # p = u.u_procp ! 1618: # from vtopte(p, v) ... ! 1619: movl $1,r2 # type = CTEXT; ! 1620: cmpl r3,P_TSIZE(r5) ! 1621: jlssu 1f # if (isatsv(p, v)) { ! 1622: addl3 P_TSIZE(r5),P_DSIZE(r5),r0 ! 1623: cmpl r3,r0 ! 1624: jgequ 2f ! 1625: clrl r2 # type = !CTEXT; ! 1626: 1: ! 1627: ashl $2,r3,r4 ! 1628: addl2 P_P0BR(r5),r4 # tptopte(p, vtotp(p, v)); ! 1629: jbr 3f ! 1630: 2: ! 1631: cvtwl P_SZPT(r5),r4 # } else (isassv(p, v)) { ! 1632: ashl $7,r4,r4 ! 1633: subl2 $0x400000,r4 ! 1634: addl2 r3,r4 ! 1635: ashl $2,r4,r4 ! 1636: addl2 P_P0BR(r5),r4 # sptopte(p, vtosp(p, v)); ! 1637: clrl r2 # type = !CTEXT; ! 1638: 3: # } ! 1639: bitb $0x82,3(r4) ! 1640: beql 2f # if (pte->pg_v || pte->pg_fod) ! 1641: POPR; rsb # let pagein handle it ! 1642: 2: ! 1643: bicl3 $0xffe00000,(r4),r0 ! 1644: jneq 2f # if (pte->pg_pfnum == 0) ! 1645: POPR; rsb # let pagein handle it ! 1646: 2: ! 1647: subl2 _firstfree,r0 ! 1648: ashl $-1,r0,r0 ! 1649: incl r0 # pgtocm(pte->pg_pfnum) ! 1650: mull2 $SZ_CMAP,r0 ! 1651: addl2 _cmap,r0 # &cmap[pgtocm(pte->pg_pfnum)] ! 1652: tstl r2 ! 1653: jeql 2f # if (type == CTEXT && ! 1654: jbc $C_INTRANS,(r0),2f # c_intrans) ! 1655: POPR; rsb # let pagein handle it ! 1656: 2: ! 1657: jbc $C_FREE,(r0),2f # if (c_free) ! 1658: POPR; rsb # let pagein handle it ! 1659: 2: ! 1660: bisb2 $0x80,3(r4) # pte->pg_v = 1; ! 1661: jbc $26,4(r4),2f # if (anycl(pte, pg_m) ! 1662: bisb2 $0x04,3(r4) # pte->pg_m = 1; ! 1663: 2: ! 1664: bicw3 $0x7f,2(r4),r0 ! 1665: bicw3 $0xff80,6(r4),r1 ! 1666: bisw3 r0,r1,6(r4) # distcl(pte); ! 1667: ashl $PGSHIFT,r3,r0 ! 1668: mtpr r0,$TBIS ! 1669: addl2 $NBPG,r0 ! 1670: mtpr r0,$TBIS # tbiscl(v); ! 1671: tstl r2 ! 1672: jeql 2f # if (type == CTEXT) ! 1673: movl P_TEXTP(r5),r0 ! 1674: movl X_CADDR(r0),r5 # for (p = p->p_textp->x_caddr; p; ) { ! 1675: jeql 2f ! 1676: ashl $2,r3,r3 ! 1677: 3: ! 1678: addl3 P_P0BR(r5),r3,r0 # tpte = tptopte(p, tp); ! 1679: bisb2 $1,P_FLAG+3(r5) # p->p_flag |= SPTECHG; ! 1680: movl (r4),(r0)+ # for (i = 0; i < CLSIZE; i++) ! 1681: movl 4(r4),(r0) # tpte[i] = pte[i]; ! 1682: movl P_XLINK(r5),r5 # p = p->p_xlink; ! 1683: jneq 3b # } ! 1684: 2: # collect a few statistics... ! 1685: incl _u+U_RU+RU_MINFLT # u.u_ru.ru_minflt++; ! 1686: moval _cnt,r0 ! 1687: incl V_FAULTS(r0) # cnt.v_faults++; ! 1688: incl V_PGREC(r0) # cnt.v_pgrec++; ! 1689: incl V_FASTPGREC(r0) # cnt.v_fastpgrec++; ! 1690: incl V_TRAP(r0) # cnt.v_trap++; ! 1691: POPR ! 1692: addl2 $8,sp # pop pc, code ! 1693: mtpr $HIGH,$IPL ## dont go to a higher IPL (GROT) ! 1694: rei
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.