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