![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to boot.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / conf|
Return to boot.s CVS log | Up to [MW Coherent from dump] / coherent / d / conf |
1.1 ! root 1: / $Header: /z/vlad/boot/src/RCS/boot.s,v 1.4 91/08/27 14:19:59 vlad Exp Locker: vlad $ ! 2: / (lgl- ! 3: / The information contained herein is a trade secret of Mark Williams ! 4: / Company, and is confidential information. It is provided under a ! 5: / license agreement, and may be copied or disclosed only under the ! 6: / terms of that agreement. Any reproduction or disclosure of this ! 7: / material without the express written authorization of Mark Williams ! 8: / Company or persuant to the license agreement is unlawful. ! 9: / ! 10: / COHERENT Version 2.3.37 ! 11: / Copyright (c) 1982, 1983, 1984. ! 12: / An unpublished work by Mark Williams Company, Chicago. ! 13: / All rights reserved. ! 14: / -lgl) ! 15: ! 16: //////// ! 17: / ! 18: / Bootstrap block for the IBM ! 19: / PC. This code, which lives in sector 1, ! 20: / track 0 of the floppy (or sector 1 of a hard disk partition) ! 21: / gets read into location 0x7C00 by the ROM. ! 22: / The code relocates itself to location 0x2060:0x0000 ! 23: / (128K above the fixed memory used by the ROM). The system image is read ! 24: / in beginning at paragraph 0x0060. ! 25: / ! 26: / $Log: boot.s,v $ ! 27: /RCS-> Revision 1.4 91/08/27 14:19:59 vlad ! 28: /RCS-> Fixed boot that allow to boot from arbitrary place of the disk, by ! 29: /RCS-> using four byte block numbers. Original (oldest and Ciarian) used ! 30: /RCS-> only two byte block numbers -- only the first 32 Meg were accessable. ! 31: /RCS-> ! 32: / Revision 1.1 88/03/24 16:44:09 src ! 33: / Initial revision ! 34: / ! 35: / 87/10/04 Allan Cornish /usr/src/sys/i8086/boot/boot.s ! 36: / Number of heads now defined by NHD macro. Should be 1 for f*d*, 2 for f*a*. ! 37: / ! 38: / 85/10/04 Allan Cornish /usr/src/sys/i8086/boot/boot.s ! 39: / Bootstrap extended to increase max file size from 64 Kbytes to 128 Kbytes. ! 40: / The private code segment is now loaded, where previously it had to be empty. ! 41: / File name editing enhanced to help cursor stay in the 14 char entry field, ! 42: / and to provide a destructive backspace. ! 43: / ! 44: / 85/01/04 Allan Cornish ! 45: / Added backspace editing of file name. ! 46: / ! 47: //////// ! 48: ! 49: #ifndef NHD ! 50: #define NHD 1 / # of heads per drive [1 for f9d0]. ! 51: #endif ! 52: ! 53: #ifndef NSPT ! 54: #define NSPT 9 / # of sectors per track on floppy. ! 55: #define NTRK 40 / # of tracks on floppy. ! 56: #endif ! 57: ! 58: NSTK = 256 / # of bytes of stack. ! 59: BS = 0x08 / BS character. ! 60: CR = 0x0D / CR character. ! 61: LF = 0x0A / LF character. ! 62: SP = 0x20 / Backspace character. ! 63: BOOTLC = 0x7C00 / Boot location (ROM). ! 64: BOOTS = 0 / boot segment (ROM). ! 65: RBOOTS = 0x2060 / Relocated boot segment. ! 66: BSHIFT = 9 / Shift, bytes to blocks. ! 67: ROOTINO = 2 / Root inode # ! 68: INOORG = 2 / First inode block. ! 69: IBSHIFT = 3 / Shift, inode to blocks ! 70: IOSHIFT = 6 / Shift, inode to bytes ! 71: INOMASK = 0x0007 / Mask, inode to offset ! 72: DIRSIZE = 14 / Directory size. ! 73: DIRSIZ2 = 7 / Directory size / 2. ! 74: BUFSIZE = 512 / Block size. ! 75: HDRSIZE = 44 / L.out header size. ! 76: HDRSIZ2 = 22 / L.out header size / 2. ! 77: BUFMSK2 = 0x00FF / Block [word] mask, for reads. ! 78: DISK = 0x13 / Disk Interrupt ! 79: KEYBD = 0x16 / Keyboard Interrupt ! 80: READ1 = 0x0201 / read one sector ! 81: DADDR = 4 / number of bytes in a disk block number ! 82: ND = 10 / # of direct blocks. ! 83: NIND = 128 / # of blocks in indirect block. ! 84: NINDX2 = 256 / NIND * 2 (number of words in indirect) ! 85: ISIZE = 8 / Offset of "di_size". ! 86: IADDR = 12 / Offset of "di_addr". ! 87: JMPF = 0xEA / Jump far, direct. ! 88: LMAGIC = 0 / Offset of "l_magic" ! 89: LFLAG = 2 / Offset of "l_flag" ! 90: LSHRI = 10 / Offset of "l_ssize[SHRI]" ! 91: LPRVI = 14 / Offset of "l_ssize[PRVI]" ! 92: LSHRD = 22 / Offset of "l_ssize[SHRD]" ! 93: LPRVD = 26 / Offset of "l_ssize[PRVD]" ! 94: LBSSD = 30 / Offset of "l_ssize[BSSD]" ! 95: LFMAG = 0x0107 / Magic number. ! 96: LFSEP = 0x02 / Sep I/D flag bit. ! 97: SYSBASE = 0x0060 / System load base paragraph. ! 98: FIRST = 8 / relative start of partition ! 99: ! 100: //////// ! 101: / Overall structure of boot.s (the secondary boot): ! 102: / ! 103: / boot: relocate secondary to high memory (0x2060:0x0000) ! 104: / if needed, get hard disk parameters from bios ! 105: / jump far to high memory (RBOOTS:entry) ! 106: / entry: open directory "/" ! 107: / search: while filename not found ! 108: / walk through "/" looking for filename (in nbuf) ! 109: / if not found, ask for another name (call input:), and loop to search ! 110: / found: open file that we just found ! 111: / read the l.out header (verify magic number, get partition sizes) ! 112: / load the shared and private code segments as one (call load:) ! 113: / load the initialized data segment (call load:) ! 114: / jump far to the newly loaded program ! 115: / ! 116: //////// ! 117: ! 118: //////// ! 119: / ! 120: / Bootstrap mainline. Relocate the ! 121: / boot to high memory, so it won't be written ! 122: / over by the system. Read in a file name. Look up ! 123: / the file name by following out the directory ! 124: / structure. Read in the image and jump to it. ! 125: / ! 126: //////// ! 127: ! 128: boot: xor di, di ! 129: mov ds, di ! 130: mov si, $BOOTLC / Make DS:SI point at the code ! 131: / "mov es, 1f(si)" really means "mov es, $RBOOTS". Clever Intel... :-( ! 132: mov es, 1f(si) / Make ES:DI point at where it goes ! 133: mov cx, $512 / cx = # of bytes to move ! 134: cld ! 135: rep / Move the bootstrap ! 136: movsb / to high memory. ! 137: ! 138: / Check to see if we were invoked by mboot. (That means we're booting ! 139: / off a hard disk and need to load disk parameters. ! 140: ! 141: / mboot sets bx = sp ! 142: cmp bx, sp / trick to tell ! 143: jne 0f / whether or not xt ! 144: ! 145: / Assertion: at this point we know we're boot off a hard disk. ! 146: mov si, bp / set si to partition table ! 147: ! 148: movb dl, (si) / get drive number ! 149: movb ah, $8 / get drive parameters ! 150: int DISK ! 151: jc 0f / abort on error ! 152: ! 153: movb al, ch / fetch cyl(lo) ! 154: movb ah, cl / move cyl(hi), sects ! 155: rolb ah, $1 / shift cylinder high to ! 156: rolb ah, $1 / the least sig bits ! 157: andb ah, $3 / mask out cylinder bits ! 158: ! 159: mov di, $traks / point to drive ! 160: stosw / set number of tracks ! 161: ! 162: movb al, $0x3F / sector mask ! 163: andb al,cl / mask sector ! 164: stosb / set sector ! 165: ! 166: movb al, dh / get max head ! 167: inc ax / change to # of heads [incb al] ! 168: stosb / set number of heads ! 169: ! 170: movsb / set drive ! 171: add si, $FIRST-1 / point to first block ! 172: movsw ! 173: movsw / fetch first block ! 174: ! 175: / Set registers. ! 176: ! 177: 0: mov bp, $stack+NSTK / stack pointer value ! 178: mov ax, es ! 179: mov ds, ax ! 180: mov ss, ax ! 181: mov sp, bp ! 182: ! 183: call login / print signon message ! 184: ! 185: / Jump to (relocated) boot. ! 186: ! 187: .byte JMPF ! 188: .word entry ! 189: 1: .word RBOOTS ! 190: ! 191: //////// ! 192: / ! 193: / This is the equivalent of "open()", ! 194: / but takes an inode instead of a pathname. ! 195: / ! 196: / Read the inode specified by "ax" ! 197: / into the external variable "iaddr". ! 198: / ! 199: / Makes a list of block numbers in "iaddr" ! 200: / consisting of the 10 direct block numbers, the 128 ! 201: / block numbers pointed to the singly indirect block, ! 202: / and the first 128 block numbers pointed to by the ! 203: / first doubly indirect block. ! 204: / ! 205: / Note that "iread" can only access the first 256 ! 206: / block numbers in this list, so the last 10 are ! 207: / ignored. ! 208: / ! 209: / Note that block numbers are actually 32 bits on disk-- ! 210: / this routine only uses the lower 16 bits. ! 211: / In fact, iaddr is loaded with 16 bit numbers, not 32 bit. ! 212: / ! 213: / No checking is done to make sure that ! 214: / the inumber is in range on the filesystem. ! 215: / Sets dx and cx to 0. ! 216: / Mungs si, di, ax. ! 217: / ! 218: //////// ! 219: ! 220: igrab: dec ax / Make origin 0 and ! 221: push ax / remember for later use. ! 222: ! 223: / We assume that the inode table appears in the first 32 meg of disk. ! 224: / Look up the inode in the inode table. ! 225: movb cl, $IBSHIFT / Convert to ! 226: shr ax, cl / inode block number, ! 227: inc ax / then to physical block number, ! 228: inc ax ! 229: sub bx, bx / Assume inode within first 32 meg. ! 230: call bread / and read in the data. ! 231: ! 232: pop ax / Get i-number back. ! 233: and ax, $INOMASK / Get inode within block ! 234: movb cl, $IOSHIFT / and convert to ! 235: shl ax, cl / a byte offset in the block. ! 236: add si, ax / si = inode pointer. ! 237: ! 238: / Assertion: si now points at the start of the desired ! 239: / inode structure (see <sys/inode.h>). ! 240: ! 241: / Copy out the direct block numbers to iaddr. ! 242: add si, $IADDR / Point at address field. ! 243: mov di, $iaddr / Copy out area. ! 244: ! 245: / The block numbers in the inode on disk are stored as ! 246: / 3 bytes: msb, lsw. lsw is lsb, msb. We want to store them ! 247: / in memory as msw, lsw, just like the inodes in the indirect ! 248: / blocks on disk. So we need to cast msb as msw. ! 249: movb cl, $ND / cx = # of direct blocks ! 250: sub ax, ax / cast byte in al to word in ax ! 251: 0: lodsb / al = msb for direct byte ! 252: stosw / store msb cast as a word ! 253: movsw / store lsw. ! 254: loop 0b ! 255: ! 256: lodsb / Get the msb for the indirect block. ! 257: xchg bx, ax / (implicit cast of msb to msw) ! 258: lodsw / Get the lsw for the indirect block. ! 259: call bread / Read (first) indirect block. ! 260: ! 261: / Copy out the singly indirect block numbers to iaddr. ! 262: / These are stored on disk as 4 byte numbers: msw, lsw ! 263: / where each word is lsb, msb. This is how we store them ! 264: / in memory. ! 265: mov cx, $NINDX2 ! 266: rep ! 267: movsw ! 268: ! 269: / Finish by reading the first block of the file into bbuf. ! 270: sub dx, dx / Set dh to first block number in iaddr. ! 271: / jmp iread / Done return through iread. ! 272: ! 273: //////// ! 274: / ! 275: / This routine reads the virtual ! 276: / block iaddr[dh] (the dh'th block number ! 277: / in iaddr) into the buffer "bbuf". ! 278: / It uses the mapping data that ! 279: / has been provided by a previous call to igrab ! 280: / On return "si" points at "bbuf". ! 281: / Holes in files (sparse blocks) are correctly done. ! 282: / mungs ax, bx, si. ! 283: / clears cx. ! 284: / ! 285: /////// ! 286: ! 287: iread: ! 288: sub bx, bx / Convert from words to blocks. ! 289: movb bl, dh / ! 290: ! 291: / Block numbers are 4 bytes long, stored msw, lsw. ! 292: shl bx, $2 / Compute index into iaddr table. ! 293: push iaddr(bx) / fetch msw ! 294: inc bx ! 295: inc bx ! 296: mov ax, iaddr(bx) / fetch lsw ! 297: pop bx / put msw where it belongs ! 298: / jmp bread / Yes, return through "bread". ! 299: ! 300: //////// ! 301: / ! 302: / Read a block from the floppy disk, ! 303: / drive A:, using the code in the IBM firmware. ! 304: / The physical block # is in ax and bx. ! 305: / Register bx is the MSW, and ax is the LSW. ! 306: / ! 307: / This code is restricted to reading from the first 32meg of ! 308: / disk because the block number is only 16 bits long. ! 309: //////// ! 310: ! 311: bread: push es / Save registers ! 312: push di ! 313: push dx ! 314: ! 315: push ds ! 316: pop es / set ES to the address of the buffer ! 317: ! 318: mov di, bp / Blast the buffer contents. ! 319: mov cx, $BUFSIZE / For block 0, this fills the buffer ! 320: rep / with zeros. ! 321: stosb ! 322: ! 323: / Block #0 is the sparse block--it means a block of all zeros. ! 324: test ax, ax / if block 0, return zeroed buffer ! 325: jz 2f ! 326: ! 327: / Translate block number into cylinder, head, and sector. ! 328: push bx ! 329: pop dx ! 330: / xor dx, dx / extend block number ! 331: add ax, first / add first block ! 332: adc dx, first+2 / add rest ! 333: ! 334: mov bx, ax / save block number ! 335: movb al, heads / get number of heads ! 336: movb cl, sects / get number of sectors ! 337: mulb cl / calculate sectors per cylinder ! 338: xchg bx,ax / swap block/sectors ! 339: div bx / calculate track ! 340: xchg dx, ax / put track in DX ! 341: divb cl / calculate head/sector ! 342: ! 343: movb cl, ah / set sector ! 344: inc cx / sectors start at 1 [incb cl] ! 345: ! 346: cmp dx, traks / check for second side ! 347: jb 0f ! 348: sub dx, traks / fold track ! 349: inc ax / next head [incb al] ! 350: ! 351: 0: rorb dh, $1 / rotate track(low) into ! 352: rorb dh, $1 / msbits of DX ! 353: orb cl, dh / set track(high) ! 354: movb ch, dl / set track(low) ! 355: movb dh, al / set head ! 356: movb dl, drive / set drive ! 357: mov bx, bp / set offset [bbuf] ! 358: ! 359: mov ax, $READ1 / Read, 1 sector. ! 360: int DISK / Disk I/O. ! 361: jnc 2f / Jump if no error. ! 362: mov ax, $READ1 / try again ! 363: int DISK ! 364: jc error ! 365: ! 366: 2: mov si, bp / set SI to point to buffer for return ! 367: sub cx, cx / clear CX here to save space ! 368: ! 369: pop dx / restore registers. ! 370: pop di ! 371: pop es ! 372: ret / return. ! 373: ! 374: //////// ! 375: / ! 376: / Print signon message ! 377: / ! 378: //////// ! 379: ! 380: login: mov si, $msg00 / point si to message ! 381: ! 382: print: lodsb / al=byte ! 383: cmpb al, $LF / check for end of message ! 384: call putc / Type it and ! 385: jne print / go back for more. ! 386: ret ! 387: ! 388: / Prompt with a "?" and read the file name ! 389: / into "nbuf". No character editing facilites ! 390: / are provided. ! 391: ! 392: error: mov sp, bp / Reset stack ! 393: call login / print boot message ! 394: ! 395: input: mov di, $nbuf / di=name buffer pointer ! 396: mov cx, $DIRSIZE / cx=size of ! 397: movb al, $'? / set prompt ! 398: 0: call putc ! 399: ! 400: 1: movb ah, $0 / Get ASCII opcode. ! 401: int KEYBD / Read keyboard ROM call. ! 402: ! 403: 2: cmpb al, $CR / CR ? ! 404: je 3f / Yup, do next thing ! 405: ! 406: jcxz 1b / skip over too big name ! 407: stosb / put it into the buffer, ! 408: dec cx / adjust char count ! 409: jmp 0b / and continue. ! 410: ! 411: 3: mov si, $crlf / Echo LF followed by CR. ! 412: call print ! 413: ! 414: movb al, $0 / zero out ! 415: rep ! 416: stosb / rest of name ! 417: ! 418: //////// ! 419: / This is where we jump after boot has been relocated. ! 420: / ! 421: / Open "/"; we're going to search for "autoboot". ! 422: //////// ! 423: entry: mov ax, $ROOTINO / ax = current inode ! 424: call igrab / Read in inode and set dx ! 425: ! 426: //////// ! 427: / Search directory for filename in nbuf. ! 428: / Assume directory size = 64 Kbytes. ! 429: / This assumption works because block numbers ! 430: / from the inode beyond end of file are zero. ! 431: //////// ! 432: ! 433: search: orb dl, dl / On block boundry ? ! 434: jnz 0f / Nope. ! 435: call iread / Read block, set si. ! 436: ! 437: 0: movb cl, $DIRSIZE / cx = count left ! 438: mov di, $nbuf / Point at name buffer and ! 439: lodsw / ax = inumber, this entry. ! 440: or ax, ax / Empty directory slot ? ! 441: je 1f / Yes, skip. ! 442: repe / compare the ! 443: cmpsb / two file names. ! 444: je found / If eq, go and get inode. ! 445: ! 446: 1: add si, cx / Advance by count remaining. ! 447: add dx, $DIRSIZ2+1 / Bump [word] seek pointer ! 448: jg search / Scan up to 64 Kbytes of directory. ! 449: ! 450: jmp input / File not found. ! 451: ! 452: //////// ! 453: / ! 454: / Found the file so read it in. ! 455: / ax = inode number of file ! 456: / ! 457: //////// ! 458: ! 459: found: call igrab / read in inode and first block ! 460: cmp LMAGIC(si),$LFMAG / Check the magic number. ! 461: jne error / not Ok. ! 462: ! 463: / push LBSSD(si) / Push the uninitialized data size. ! 464: ! 465: / Get the total size of shared and private data segments. ! 466: / They are contigious on disk. see <l.out.h> ! 467: mov ax, LSHRD(si) / Push the sum ! 468: add ax, LPRVD(si) / of the shared and private ! 469: push ax / [initialized] data sizes. ! 470: / If this is not a sep I/D executable, then we ! 471: / don't want to load the non-existent data segment. ! 472: andb LFLAG(si), $LFSEP / check image flags. ! 473: pushf / Push result of test. ! 474: mov ax, LSHRI(si) / Get the sum of the ! 475: add ax, LPRVI(si) / shared and private code sizes. ! 476: ! 477: / Find the start of the first segment on disk. ! 478: mov dx, $HDRSIZ2 / Seek after header and ! 479: add si, $HDRSIZE / set buffer pointer appropriately. ! 480: mov es, 1f / Set ES:DI to point to the load ! 481: sub di, di / base of the new system. ! 482: ! 483: / Load the code segment. ! 484: call load / Load code. ! 485: ! 486: / Skip loading the data segment for non-sep I/D executables. ! 487: popf / Pop sep I/D flag test ! 488: jz 0f / Not sep. ! 489: ! 490: / Assertion: at this point we are dealing with a sep I/D ! 491: / l.out executable. ! 492: ! 493: / Calculate load point for data segment. ! 494: add di, $15 / Round up the system code ! 495: movb cl, $4 / size to 16 byte ! 496: shr di, cl / paragraphs. ! 497: mov ax, es / fetch program base ! 498: add ax, di / Compute the data base and ! 499: mov es, ax / set up ES:DI to point ! 500: sub di, di / at it. ! 501: ! 502: 0: pop ax / Pop off initialized data size and ! 503: / Load the initialized data segment. ! 504: call load / load the image. ! 505: ! 506: / pop cx / Pop off uninitialized data size and ! 507: / rep / clear it. ! 508: / stosb ! 509: ! 510: / Run the program that we just loaded. ! 511: .byte JMPF / Jump to offset ! 512: .word 0x0100 / 0x0100 (after base) in system ! 513: 1: .word SYSBASE / code segment. ! 514: ! 515: //////// ! 516: / ! 517: / Load a segment from an l.out file into memory. ! 518: / The "dx" register holds the ! 519: / seek pointer into the file. The "si" holds ! 520: / a pointer into the "bbuf". The "es:di" pair ! 521: / holds the target address. The "ax" holds ! 522: / the number of bytes to load. On return the ! 523: / "ax" must equal 0 (the caller assumes this ! 524: / and uses "al" to clear the BSS). ! 525: / ! 526: / Note that since the number of bytes to load is ! 527: / stored in a 16 bit register, a segment may be no ! 528: / longer than 64K. For small model this is just fine. ! 529: //////// ! 530: ! 531: load: or ax, ax / Any left ? ! 532: jz return / Jump if all loaded. ! 533: ! 534: mov cx, $bbuf+BUFSIZE / Compute the number of bytes ! 535: sub cx, si / remaining in the block. ! 536: jnz 0f / Jump if some. ! 537: ! 538: push ax / Save count registers, then ! 539: call iread / read the next block ! 540: pop ax / of the file. ! 541: mov cx, $BUFSIZE / We now have a full block. ! 542: ! 543: 0: cmp cx, ax / More than we need ? ! 544: jbe 1f / Nope. ! 545: mov cx, ax / Only take what we need. ! 546: ! 547: 1: sub ax, cx / Fix up the count ! 548: shr cx, $1 / ! 549: add dx, cx / Fix up the seek [word] address, then ! 550: rep / copy the words from the block ! 551: movsw / buffer to the load point and ! 552: jmp load / loop until done. ! 553: ! 554: //////// ! 555: / ! 556: / Write the character in "al" out to ! 557: / the display, using routines in the ROM. ! 558: / Like most calls to the ROM, this routine spends ! 559: / most of its time saving and restoring the ! 560: / registers. ! 561: / ! 562: / Note: The ZF in the PSW word must be preserved. ! 563: / ! 564: //////// ! 565: ! 566: putc: push si / Save registers. ! 567: push di ! 568: push bp ! 569: ! 570: mov bx, $0x0007 / Page 0, white on black ! 571: movb ah, $0x0E / Write TTY. ! 572: int 0x10 / Call video I/O in ROM. ! 573: ! 574: pop bp / Restore registers. ! 575: pop di ! 576: pop si ! 577: return: ret / Return ! 578: ! 579: //////// ! 580: / ! 581: / Data. There is some pure data in ! 582: / the "prvd" segment. This data is moved to the ! 583: / new memory when the boot is relocated. All buffers ! 584: / are in the BSS, and are not actually moved, or even ! 585: / saved in the boot block. ! 586: / ! 587: //////// ! 588: ! 589: .prvd ! 590: nbuf: .ascii "autoboot" / Name buffer. ! 591: .blkb DIRSIZE-8 / rest of buffer (8=sizeof("autoboot")) ! 592: ! 593: / Defaults for all the following parameters match a floppy disk. ! 594: ! 595: traks: .word NTRK / Number of cylinders on drive we're booting off of. ! 596: sects: .byte NSPT / Number of sectors per track for our drive. ! 597: heads: .byte NHD / Number of heads on drive we're booting off of. ! 598: ! 599: drive: .byte 0 / Drive our partition resides upon. ! 600: first: .word 0 / First block of our partition (?) ! 601: .word 0 ! 602: ! 603: msg00: .ascii "NATboot" ! 604: crlf: .byte CR, LF ! 605: ! 606: / This magic pair of bytes must be the last two bytes of ! 607: / the sector (address 0x1FE), otherwise mboot will refuse ! 608: / to execute it. ! 609: / If needed, uncomment the .blkb and adjust the number appropriately. ! 610: .blkb 0x1c / Padding need to make magic byte line up ! 611: .byte 0x55,0xAA ! 612: ! 613: .bssd ! 614: stack: .blkb NSTK / Local Stack and name buffer ! 615: bbuf: .blkb BUFSIZE / Block buffer [must follow stack]. ! 616: iaddr: .blkw ND+ND+NIND+NIND / Inode map words.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.