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