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