![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to refs 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 / tboot|
Return to refs CVS log | Up to [MW Coherent from dump] / coherent / d / conf / tboot |
1.1 root 1: / Startup.s -- initilization code for any tertiary boot program.
2: /
3: / La Monte H. Yarroll <[email protected]>, September 1991
4: /
5: / RBOOTS is set exactly 128K below the top of 640K.
6: / One day, RBOOTS should be dynamicly determined based on the size of
7: / available memory.
8: RBOOTS = 0x8000 / New segement for boot program.
9: JMPF = 0xEA / jump far, direct
10: SEGSIZ = 0xffff / Size of a whole segment.
11: NSTK = 0x2000 / # of bytes of stack.
12: BLOCK = 0x200 / # of bytes in a disk block
13: DIRSIZE = 14 / Size of a file name.
14: SIZEOFSDAT = 23 / sizeof(seconddat)
15: SECONDDAT = 0x01E7 / Offset of useful data in secondary boot.
16: CR = 0x0d / Carriage return
17: LF = 0x0a / Line Feed
18: NUL = 0x00 / NUL (for terminating strings)
19: / Interrupts.
20: MON = 0x00 / Invoke BIOS monitor.
21: KEYBD = 0x16 / Keyboard software interrupt.
22: REBOOT = 0x19 / Reboot through BIOS.
23:
24:
25: NTRK = 40 / Number of tracks on a floppy.
26: NSPT = 9 / Number of sectors per track on a floppy.
27: NHD = 1 / Number of heads per drive on a floppy.
28: .bssd
29: stack: .blkb NSTK / Local Stack
30: .shri
31: .blkb 0x100 / Symbol "begin" must be at offset 0x100 from
32: begin: / the beginning of the code segment--secondary
33: / boot jumps here.
34: / Upon entry ds points at the secondary boot data segment,
35: / si points at the data we want,
36: / and es points at our data segment.
37: mov di, $seconddat
38: mov cx, $SIZEOFSDAT
39: cld
40: rep
41: movsb / Copy disk configuration information to our own segment.
42: / Create a nice, safe stack.
43: mov bp, $stack+NSTK
44: mov ax, es
45: mov ss, ax
46: mov sp, bp
47:
48: push es / Save location of data segment from secondary boot.
49: / Move the tertiary boot to high memory.
50: call moveme
51:
52: add sp, $2 / Throw away old data segment.
53: / Set up the new stack.
54: mov bp, $stack+NSTK
55: mov ax, es
56: mov ss, ax
57: mov sp, bp
58: .byte JMPF / Jump to the relocated code.
59: .word entry
60: .word RBOOTS
61: entry: call main_
62: / Aargh! main() returned! Wait for a keystroke and then reboot.
63: push $keymsg
64: call puts_
65: 0: movb ah, $1 / while (!iskey()) {};
66: int KEYBD / /* Read the key. */
67: movb ah, $1 / } while (iskey())
68: int KEYBD / /* Scan the keyboard for another key. */
69: jne 1b /
70: int REBOOT / Reboot through the BIOS.
71: .shrd
72: keymsg:
73: .byte CR
74: .byte LF
75: .ascii "Press any key to reboot."
76: .byte CR
77: .byte LF
78: .byte NUL
79: ////////
80: /
81: / Move tertiary boot to high memory.
82: / Take one parameter--a word on the stack pointing to the current
83: / data segment.
84: /
85: / As a side effect, this sets ds to the new data segment in high memory.
86: /
87: ////////
88: .shri
89: moveme:
90: mov bp, sp / For parameter lookups.
91: / Move the code segment.
92: push cs
93: pop ds
94: xor si, si / Point ds:si at loaded code segment.
95: mov ax, $RBOOTS
96: mov es, ax
97: xor di, di / Point es:di at where we want to be.
98: mov cx, $SEGSIZ / Move a maximal segment.
99: cld
100: rep
101: movsb
102: / Calculate location of new data segment.
103: mov ax, 2(bp)
104: push cs / Fetch the code segment.
105: pop bx
106: sub ax, bx / Calculate offset to data segment.
107: add ax, $RBOOTS / Calculate the new data segment.
108:
109: / Move the data segment.
110: mov ds, 2(bp)
111: xor si, si / Point ds:si at loaded data segment
112: mov es, ax
113: xor di, di / Point es:di at where we want to be.
114: mov cx, $SEGSIZ / Move a maximal segment.
115: cld
116: rep
117: movsb
118: / Set the new data segment appropriately.
119: push es
120: pop ds
121: mov myds_, ds
122: ret / routine moveme
123: / Shared data segment (initialized)
124: .shrd
125: .globl myds_
126: myds_: .word 0 / Place to communicate ds to C programs.
127: / Variables nbuf, traks, sects, and heads MUST appear in this order.
128: .globl seconddat
129: seconddat: / Data extracted from secondary boot data segment.
130: .globl nbuf_
131: nbuf_:
132: nbuf: .blkb DIRSIZE
133: / Defaults for all the following parameters match a floppy disk.
134: .globl traks
135: .globl traks_
136: traks_:
137: traks: .word NTRK / Number of cylinders on drive we're booting off of.
138: .globl sects
139: .globl sects_
140: sects_:
141: sects: .byte NSPT / Number of sectors per track for our drive.
142: .globl heads
143: .globl heads_
144: heads_:
145: heads: .byte NHD / Number of heads on drive we're booting off of.
146: .globl drive
147: .globl drive_
148: drive_:
149: drive: .byte 0 / Drive our partition resides upon.
150: .globl first
151: .globl first_
152: first_:
153: first: .word 0 / First block of our partition (?)
154: .word 0
155: /*
156: * Determine whether or not a given argument exists on the command line
157: * passed into the kernel.
158: *
159: * Takes a pointer to a NUL terminated string that is the name of
160: * the desired argument.
161: */
162: extern typed_space boot_gift;
163: int
164: arg_exist(arg)
165: {
166: } /* arg_exist() */
167: /*
168: * Looks for the string "astring" in the fifo "afifo".
169: * Returns TRUE if it find the string.
170: */
171: int
172: fifo_find_str(afifo, astring)
173: typed_space *afifo;
174: char *astring;
175: {
176: } /* fifo_find_str() */
177: /*
178: * bio.c -- buffer handling code.
179: *
180: * This code REALLY assumes single-threaded execution. All locks are
181: * advisory only and may be revoked without notice.
182: *
183: * See also bread() in diskio.c.
184: */
185: static BUF bufl[NBUF]; /* Buffer structures. */
186: static char blockp[NBUF * BLOCK]; /* The blocks themselves. */
187: static int buf_inited = (1==2); /* Has bufinit been called? */
188: /*
189: * Initialise buffer headers.
190: */
191: void
192: bufinit()
193: {
194: } /* bufinit() */
195: /*
196: * Claim a buffer for a block.
197: * Finds the buffer if it has already been accessed, otherwise,
198: * picks another buffer.
199: */
200: BUF *
201: bclaim(block)
202: daddr_t block;
203: {
204: } /* bclaim() */
205: /*
206: * Pick the next buffer for allocation.
207: * Uses a round-robin scheme of buffer allocation, skipping over
208: * locked buffers. If all buffers are locked, they are forcibly
209: * unlocked and the first one is picked.
210: */
211: BUF *
212: bpick()
213: {
214: } /* bpick() */
215: /*
216: * Release a buffer for a block.
217: */
218: void
219: brelease(bp)
220: BUF *bp;
221: {
222: } /* brelease() */
223: /*
224: * Attempt to lock the gate 'g'.
225: * Return TRUE on success, FALSE if it was already locked.
226: */
227: int
228: gate_lock(g)
229: GATE g;
230: {
231: } /* gate_lock() */
232: /*
233: * Check to see if the gate 'g' is locked.
234: */
235: int
236: gate_locked(g)
237: GATE g;
238: {
239: } /* gate_locked() */
240: /*
241: * Unlock the gate 'g'.
242: */
243: void
244: gate_unlock(g)
245: GATE g;
246: {
247: } /* gate_unlock() */
248: /*
249: * Sanity checker.
250: * Prints contents of "message" if something is amiss and dumps you
251: * into the monitor.
252: *
253: * Add tests and messages as needed.
254: */
255: void
256: sanity_check(message)
257: char *message;
258: {
259: } /* sanity_check() */
260: ////////
261: /
262: / I/O library for use with boot programs. Uses the BIOS.
263: /
264: / La Monte H. Yarroll <[email protected]>, September 1991
265: /
266: ////////
267: ////////
268: /
269: / Magic constants.
270: /
271: ////////
272: RETF = 0xCB / Far return
273: VIDEO = 0x10 / video swi
274: DISK = 0x13 / disk io swi
275: KEYBD = 0x16 / keyboard swi
276: MON = 0x00 / Monitor swi
277: READ1 = 0x0201 / read 1 sector
278:
279: BUFSIZE = 0x200 / Size of a physical disk block.
280:
281: NTRK = 40 / Number of tracks on a floppy.
282: NSPT = 9 / Number of sectors per track on a floppy.
283: NHD = 1 / Number of heads per drive on a floppy.
284: FIRST = 8 / Relative start of partition.
285: .shri / Shared code segment, initialized.
286: ////////
287: /
288: / Read a block from disk, relative to the start of the boot partition,
289: / using the code in the IBM firmware.
290: /
291: / It takes two parameters:
292: / daddr_t blockno; /* 32 bit block number. */
293: / char *buff; /* Must point to a 512 byte buffer. */
294: /
295: / The buffer must not cross a 4K boundry. Disk input should generally
296: / be done through the C routine bread(), which calls _bread() with an
297: / aligned buffer.
298: /
299: ////////
300: .globl _bread_
301: _bread_:
302: push es / Save registers
303: push si
304: push di
305: push bp
306: push dx
307: push ds
308: pop es / Set es:bp to address of the buffer.
309: mov bp, sp
310: mov ax, 12(bp) / Get low word of block number.
311: mov dx, 14(bp) / Get high word of block number.
312: mov bx, 16(bp) / Get a buffer to put it in.
313: mov bp, bx
314: mov di, bp / Blast the buffer contents.
315: mov cx, $BUFSIZE / For block 0, this fills the buffer
316: rep / with zeros.
317: stosb
318: / Block #0 is the sparse block--it means a block of all zeros.
319: test ax, ax / if block 0, return zeroed buffer
320: jnz 3f
321: test dx, dx
322: jnz 3f
323: movb al, $1 / Say that we read 1 block.
324: jmp 2f
325: / Translate block number into cylinder, head, and sector.
326: 3: add ax, first / add first block
327: adc dx, first+2 / add rest
328: mov bx, ax / save block number
329: movb al, heads / get number of heads
330: movb cl, sects / get number of sectors
331: mulb cl / calculate sectors per cylinder
332: xchg bx,ax / swap block/sectors
333: div bx / calculate track
334: xchg dx, ax / put track in DX
335: divb cl / calculate head/sector
336: movb cl, ah / set sector
337: inc cx / sectors start at 1 [incb cl]
338:
339: cmp dx, traks / check for second side
340: jb 0f
341: sub dx, traks / fold track
342: inc ax / next head [incb al]
343: 0: rorb dh, $1 / rotate track(low) into
344: rorb dh, $1 / msbits of DX
345: orb cl, dh / set track(high)
346: movb ch, dl / set track(low)
347: movb dh, al / set head
348: movb dl, drive / set drive
349: mov bx, bp / set offset [bbuf]
350: mov ax, $READ1 / Read, 1 sector.
351: int DISK / Disk I/O.
352: jnc 2f / Jump if no error.
353: mov ax, $READ1 / try again
354: int DISK
355: jc berror
356: 2:
357: / al contains the number of blocks read (should be 1).
358: pop dx / restore registers.
359: pop bp
360: pop di
361: pop si
362: pop es
363: ret / return.
364: berror: / error handling for _bread.
365: xorb al, al / ah contains an error code.
366: jmp 2b
367: ////////
368: /
369: / Write the character in "al" out to
370: / the display, using routines in the ROM.
371: / Like most calls to the ROM, this routine spends
372: / most of its time saving and restoring the
373: / registers.
374: /
375: ////////
376: .globl putchar_
377: putchar_: push si / Save registers.
378: push di
379: push bp
380: mov bp, sp
381: mov ax, 8(bp) / Fetch the single argument.
382: mov bx, $0x0007 / Page 0, white on black
383: movb ah, $0x0E / Write TTY.
384: int VIDEO / Call video I/O in ROM.
385: pop bp / Restore registers.
386: pop di
387: pop si
388: ret
389: ////////
390: /
391: / Fetch character from keyboard, using
392: / routines in the ROM.
393: /
394: ////////
395: .globl getchar_
396: getchar_:
397: push si / Save registers.
398: push di
399: push bp
400: movb ah, $0x00 / Read keystroke.
401: int KEYBD
402: movb ah, $0x00
403: pop bp / Restore registers.
404: pop di
405: pop si
406: ret
407: ////////
408: /
409: / Check for a pending keystroke using
410: / routines in the ROM.
411: /
412: ////////
413: .globl iskey_
414: iskey_:
415: push si / Save registers.
416: push di
417: push bp
418: movb ah, $0x01 / Check for keystroke.
419: int KEYBD
420: jne 0f
421: xor ax, ax / Set false.
422: jmp 1f
423: 0: xor ax, ax
424: inc ax / Set true.
425: 1: pop bp / Restore registers.
426: pop di
427: pop si
428: ret
429: ////////
430: /
431: / Goto a far address
432: / Takes two integer arguments: an offset, and a segment, in that order.
433: /
434: ////////
435: .globl gotofar_
436: gotofar_:
437: add sp, $2
438: .byte RETF
439: ////////
440: /
441: / Goto a kernel.
442: / Takes three integer arguments: an offset, a segment, and a new data segment
443: / in that order.
444: /
445: ////////
446: .globl gotoker_
447: gotoker_:
448: mov bp, sp
449: mov es, 6(bp) / Point es at the new data segment.
450: mov si, $seconddat / Point ds:si at useful data.
451: add sp, $2
452: .byte RETF
453: ////////
454: /
455: / Initilize hard disk parameters
456: /
457: ////////
458: .globl hdinit_
459: hdinit_:
460: push si / Save registers.
461: push di
462: push bp
463: mov si, bp / set si to partition table
464: movb dl, (si) / get drive number
465: movb ah, $8 / get drive parameters
466: int DISK
467: jc 1f / abort on error (just return)
468: movb al, ch / fetch cyl(lo)
469: movb ah, cl / move cyl(hi), sects
470: rolb ah, $1 / shift cylinder high to
471: rolb ah, $1 / the least sig bits
472: andb ah, $3 / mask out cylinder bits
473: mov di, $traks / point to drive
474: stosw / set number of tracks
475: movb al, $0x3F / sector mask
476: andb al, cl / mask sector
477: stosb / set sector
478: movb al, dh / get max head
479: inc ax / change to # of heads (incb al)
480: stosb / set number of heads
481: movsb / set drive
482: add si, $FIRST-1 / point to first block
483: movsw / fetch first block
484: movsw
485: 1: pop bp / Restore registers.
486: pop di
487: pop si
488: ret
489: ////////
490: /
491: / Invoke the native monitor.
492: / Useful for debugging.
493: /
494: ////////
495: .globl intmon_
496: intmon_:
497: int MON
498: ret
499: ////////
500: /
501: / void _ffcopy(from_fp, to_fp, count)
502: / faddr_t from_fp, to_fp;
503: / int count;
504: /
505: / Copy count bytes from from_fp to to_fp.
506: /
507: / Here is the stack after initial "push bp":
508: /
509: / 12(bp) count
510: / 10(bp) FP_SEL(to_fp)
511: / 8(bp) FP_OFF(to_fp)
512: / 6(bp) FP_SEL(from_fp)
513: / 4(bp) FP_OFF(from_fp)
514: / 2(bp) return IP
515: / 0(bp) old bp
516: /
517: ////////
518: .globl _ffcopy_
519: _ffcopy_:
520: push bp
521: mov bp, sp
522: push es
523: push di
524: push ds
525: push si
526: lds si, 4(bp) / from_fp to DS:SI
527: les di, 8(bp) / to_fp to ES:DI
528: mov cx, 12(bp) / rep count to CX
529: rep
530: movsb
531: pop si
532: pop ds
533: pop di
534: pop es
535: pop bp
536: ret / return from _ffcopy()
537: ////////
538: /
539: / Read a block from disk, relative to start of disk,
540: / using the code in the IBM firmware.
541: /
542: / It takes two parameters:
543: / daddr_t blockno; /* 32 bit block number. */
544: / char *buff; /* Must point to a 512 byte buffer. */
545: /
546: / The buffer must not cross a 4K boundry. Disk input should generally
547: / be done through the C routine xbread(), which calls _xbread() with an
548: / aligned buffer.
549: /
550: ////////
551: .globl _xbread_
552: _xbread_:
553: push es / Save registers
554: push si
555: push di
556: push bp
557: push dx
558: push ds
559: pop es / Set es:bp to address of the buffer.
560: mov bp, sp
561: mov ax, 12(bp) / Get low word of block number.
562: mov dx, 14(bp) / Get high word of block number.
563: mov bx, 16(bp) / Get a buffer to put it in.
564: mov bp, bx
565: / Translate block number into cylinder, head, and sector.
566: 3:
567: mov bx, ax / save block number
568: movb al, heads / get number of heads
569: movb cl, sects / get number of sectors
570: mulb cl / calculate sectors per cylinder
571: xchg bx,ax / swap block/sectors
572: div bx / calculate track
573: xchg dx, ax / put track in DX
574: divb cl / calculate head/sector
575: movb cl, ah / set sector
576: inc cx / sectors start at 1 [incb cl]
577:
578: cmp dx, traks / check for second side
579: jb 0f
580: sub dx, traks / fold track
581: inc ax / next head [incb al]
582: 0: rorb dh, $1 / rotate track(low) into
583: rorb dh, $1 / msbits of DX
584: orb cl, dh / set track(high)
585: movb ch, dl / set track(low)
586: movb dh, al / set head
587: movb dl, drive / set drive
588: mov bx, bp / set offset [bbuf]
589: mov ax, $READ1 / Read, 1 sector.
590: int DISK / Disk I/O.
591: jnc 2f / Jump if no error.
592: mov ax, $READ1 / try again
593: int DISK
594: jc berror
595: 2:
596: / al contains the number of blocks read (should be 1).
597: pop dx / restore registers.
598: pop bp
599: pop di
600: pop si
601: pop es
602: ret / return.
603: /* builtin.c -- builtin routines for tboot.
604: *
605: * Add new ones by adding a check for them in interpret().
606: *
607: * La Monte H. Yarroll <[email protected]>, September 1991
608: */
609: extern int slow_flag; /* Slow down pacifier. */
610: extern int feet_flag; /* Enable pacifier footprints. */
611: /* If possible, execute "command".
612: * Return "true" if the command exists, "false" otherwise.
613: */
614: int
615: interpret(command)
616: char *command;
617: {
618: } /* interpret() */
619: /* Display the BIOS parameters loaded up by the startup code. */
620: void
621: dpb()
622: {
623: } /* dpb() */
624: /* Ask the BIOS how many drives are attached. */
625: int get_num_of_drives()
626: {
627: } /* get_num_of_drives() */
628: /* Create a listing of file names in /. */
629: void
630: dir()
631: {
632: } /* dir() */
633: /* cbootlib.c -- C routines for use by boot programs.
634: *
635: * La Monte H. Yarroll <[email protected]>, September 1991
636: */
637: /* puts() -- put a NUL terminated string.
638: * Takes one argument--a pointer to a NUL terminated character string.
639: * Does no error checking. Calls the assembly language routine putc().
640: */
641: void
642: puts(s)
643: register char *s;
644: {
645: } /* puts() */
646: /* gets() -- Read string from keyboard.
647: * Takes one argument--a pointer to a buffer big enough for the
648: * expected response.
649: * It stops reading as soon as it detects a carriage return. The CR
650: * is replaced with a NUL.
651: */
652: char *
653: gets(s)
654: char *s;
655: {
656: } /* gets() */
657: /* Reverse string s in place.
658: * Straight from K&R.
659: */
660: void
661: reverse(s)
662: char s[];
663: {
664: } /* reverse() */
665: /* Convert n to decimal characters in s.
666: * Straight from K&R (with minor sylistic changes.)
667: */
668: void
669: itoa(n, s)
670: char s[];
671: int n;
672: {
673: } /* itoa() */
674: /* Convert n to digits in s, base base.
675: * Works for any base from 2 to 36.
676: * Modified itoa() from K&R.
677: */
678: void
679: itobase(n, s, base)
680: uint16 n;
681: char s[];
682: int base;
683: {
684: } /* itobase() */
685: /* basetoi(char *s, int base)
686: * Convert a string base "base" to an integer.
687: * Good through base 36.
688: * Loosely based on K&R's atoi().
689: */
690: uint16
691: basetoi(s, base)
692: char *s;
693: int base;
694: {
695: } /* basetoi() */
696: /* seginc(uint16 *offset,
697: * uint16 *segment,
698: * uint16 increment)
699: * Add an offset to a segment. We may adjust the segment base
700: * to make everything fit.
701: */
702: * segments are PP aligned.
703: */
704:
705: void
706: seginc(offset, segment, increment)
707: uint16 *offset;
708: uint16 *segment;
709: uint16 increment;
710: {
711: } /* seginc() */
712: /* Pad a string s on the left with character c, to length n.
713: * The old contents of s are replaced by the padded version.
714: */
715: char *
716: lpad(s, c, n)
717: char *s;
718: char c;
719: int n;
720: {
721: } /* lpad() */
722: /*
723: * Print a 32 bit integer in hexadecimal.
724: */
725: void
726: print32(my_int)
727: uint32 my_int;
728: {
729: }
730: /*
731: * Print a 16 bit integer in hexadecimal.
732: */
733: void
734: print16(my_int)
735: uint16 my_int;
736: {
737: }
738: /*
739: * Print an 8 bit integer in hexadecimal.
740: */
741: void
742: print8(my_int)
743: uint8 my_int;
744: {
745: }
746: /*
747: * Wrapper for far-far copy. Changes the segment so that the requested
748: * length does not wrap past the end of the segment.
749: *
750: * For Intel 8086 Real Mode.
751: */
752: void
753: ffcopy(to_offset, to_seg, from_offset, from_seg, length)
754: uint16 to_offset;
755: uint16 to_seg;
756: uint16 from_offset;
757: uint16 from_seg;
758: uint16 length;
759: {
760: } /* ffcopy() */
761: /*
762: * Align a far address so that its offset is within a paragraph of
763: * the start of the segment.
764: *
765: * Note that we ignore overflow in the segment, since this is exactly
766: * what happens when you offset past the end of the highest segment.
767: *
768: * WARNING: This routine is destructive to its arguments.
769: *
770: * For Intel 8086 Real Mode.
771: */
772: void
773: seg_align(offset, segment)
774: uint16 *offset;
775: uint16 *segment;
776: {
777: } /* seg_align() */
778: /*
779: * wait_for_keystroke() -- wait for a specific keystroke.
780: */
781: /* Location of BIOS-run timer. */
782: /*
783: * Waits delay ticks for the requested keystroke. Returns TRUE if
784: * keystroke came, FALSE if delay runs out.
785: * If key == -1, accept ANY keystroke.
786: */
787: int
788: wait_for_keystroke(delay, key)
789: int delay;
790: int key;
791: {
792: } /* wait_for_keystrok() */
793: /* coff.c -- rutines for manipulating coff executable files. */
794: /* Convert COFF to load table.
795: * Used to generate loading instructions for use by tboot main().
796: * Returns true on successful translation.
797: */
798: int
799: coff2load(ip, table, data_seg)
800: struct inode *ip; /* input: File to read. */
801: struct load_segment table[]; /* output: How to read it. */
802: uint16 *data_seg; /* output: Where to point es. */
803: {
804: }
805: /*
806: * Symbol name.
807: */
808: static char *
809: symName(sym, str_tab, work)
810: SYMENT *sym;
811: char *str_tab, *work;
812: {
813: }
814: /*
815: * Look up the value of a single data symbol in a coff file,
816: * relative to the start of the data segment.
817: *
818: * We use the symbol "sdata" to find the start of the data segment--
819: * this works for 386 COHERENT kernels but will not work in general.
820: * It should really fetch the address of the start of the data segment
821: * from the data section header.
822: */
823: uint32
824: wrap_coffnlist(fn, symbol)
825: char *fn; /* file name */
826: char *symbol; /* symbol to look up */
827: {
828: } /* wrap_coffnlist() */
829: int
830: coffnlist(fn, nlp, names, count)
831: char *fn; /* file name */
832: SYMENT *nlp; /* names to look up */
833: char *names; /* long names */
834: int count; /* size of passed table */
835: {
836: }
837: main()
838: {
839: }
840: /* diskio.c -- C routines for disk i/o in tertiary boot programs.
841: *
842: * La Monte H. Yarroll <[email protected]>, September 1991
843: */
844: /* Aligning bread.
845: * Reads 1 block into an arbitrary buffer. The assembly language
846: * routine bread() needs a buffer aligned on a 4K boundary.
847: */
848: char bufspace[FOURK+BLOCK];
849: char *lbuf = NULL; /* Buffer for bread. */
850: BUF *
851: bread(blockno)
852: daddr_t blockno; /* Block number. */
853: {
854: } /* bread() */
855: /*
856: * Inode OPEN: Load the inode for a file into memory.
857: * iopen(struct inode *ip,
858: * ino_t inode_number)
859: *
860: */
861: int
862: iopen(meminode, inode_number)
863: struct inode *meminode;
864: ino_t inode_number;
865: {
866: } /* iopen() */
867: /* Convert a filename to an inode number. Returns inode number 0 on
868: * failure.
869: */
870: ino_t
871: namei(filename)
872: char *filename;
873: {
874: } /* namei() */
875: /*
876: * Inode READ: Load a local buffer from a file.
877: * iread(struct inode *ip,
878: * char *buffer,
879: * fsize_t offset,
880: * uint16 lenarg);
881: */
882: void
883: iread(ip, buffer, offset, lenarg)
884: struct inode *ip; /* Read from this file, */
885: char *buffer; /* into this buffer, */
886: fsize_t offset; /* from here in the file, */
887: uint16 lenarg; /* for this many bytes. */
888: {
889: } /* iread() */
890: /*
891: * Inode to Far READ: Load an arbitrary length from a file into a far address.
892: * ifread(struct inode *ip,
893: * uint16 toseg,
894: * uint16 tooffset,
895: * fsize_t offset,
896: * fsize_t length);
897: */
898: void
899: ifread(ip, toseg, tooffset, offset, lenarg)
900: struct inode *ip; /* Read from this file, */
901: uint16 toseg; /* into this far buffer, */
902: uint16 tooffset;
903: fsize_t offset; /* from here in the file, */
904: fsize_t lenarg; /* for this many bytes. */
905: {
906: } /* ifread() */
907: /* Aligning xbread.
908: * Disk addresses are relative to the start of the disk, rather than
909: * the start of the partition.
910: * Reads 1 block into an arbitrary buffer. The assembly language
911: * routine xbread() needs a buffer aligned on a 4K boundary.
912: */
913: BUF *
914: xbread(blockno)
915: daddr_t blockno; /* Block number. */
916: {
917: } /* xbread() */
918: /*
919: *
920: * fdisk( fp ) -- Fixed Disk Configuration
921: * dev_t dev;
922: * struct fdisk_s *fp;
923: *
924: * Input: fp = pointer to memory-resident partition info (to update)
925: *
926: * Action: Read first block from the device.
927: * If valid signature present on block,
928: * copy partition information to memory
929: *
930: * Return: 1 = partition information successfully updated
931: * 0 = failure (could not read block, or bad signature)
932: */
933: int
934: fdisk( fp )
935: register FDISK_S *fp;
936: {
937: }
938: /*
939: * fifo_b.c -- Extra routines for handling typed fifos.
940: * Both fifo_b.c (boot fifo) and fifo_k.c (kernel fifo) are needed by the
941: * boot code.
942: */
943: /* How long is an open fifo? */
944: long
945: fifo_len(ffp)
946: FIFO *ffp;
947: {
948: } /* fifo_len() */
949: /* Write a typed space into a FIFO. */
950: typed_space *
951: fifo_write(ffp, space)
952: FIFO *ffp;
953: typed_space *space;
954: {
955: } /* fifo_write() */
956: /* Write a chunk of data into an open fifo as a typed space.
957: * Takes a FIFO to be written to, ffp; a pointer to the data, datum; a
958: * size for the datum, size; and a type for the new space, type.
959: *
960: * Returns a pointer to the newly written space. Returns NULL if the
961: * new space could not be written.
962: *
963: * Note that while sizes throughout this package refer to TOTAL sizes
964: * including headers, the size argument here is ONLY for the datum.
965: *
966: * Only FIFOs of type T_FIFO_SIC are implimented.
967: */
968: typed_space *
969: fifo_write_untyped(ffp, datum, size, type)
970: FIFO *ffp;
971: char *datum;
972: long size;
973: space_type type;
974: {
975: } /* fifo_write_untyped() */
976: /*
977: * fifo_k.c -- Routines for reading interally typed fifos.
978: * These are all that need to be included in the kernel.
979: */
980: /* The input channel from tboot to the kernel. */
981: TYPED_SPACE(boot_gift, 512, T_FIFO_SIC);
982: /* Read a typed space from a fifo.
983: * Return a pointer to the next typed space in the fifo ffp. Returns
984: * NULL on end of fifo.
985: *
986: * This read assumes that ffp->f_space has type T_FIFO_SIC.
987: */
988: typed_space *
989: fifo_read(ffp)
990: register FIFO *ffp;
991: {
992: } /* fifo_read() */
993: /* Go back to the start of the fifo.
994: * Takes a FIFO. For reading, go back to the first space; for writing
995: * truncate the FIFO to empty.
996: * Returns 1 on success, 0 otherwise.
997: */
998: int
999: fifo_rewind(ffp)
1000: FIFO *ffp;
1001: {
1002: } /* fifo_rewind() */
1003: /* Finish with using a typed space as a fifo.
1004: * Free up FIFO structure associated with a typed space.
1005: * Returns 0 if ffp was not open, 1 otherwise.
1006: */
1007: int
1008: fifo_close(ffp)
1009: FIFO *ffp;
1010: {
1011: } /* fifo_close() */
1012: /* Open a typed space as a fifo.
1013: *
1014: * Takes a typed_space that is already allocated, and a mode. The type of
1015: * the typed space must be a FIFO. Only T_FIFO_SIC has been implimented
1016: * (static, in-core fifo).
1017: *
1018: * The mode indicates whether to open for reading or writing.
1019: * mode == 0 means read only.
1020: * mode == 1 means write only.
1021: * Other values are illegal.
1022: *
1023: * Returns a pointer to an initialized FIFO structure. FIFO structures are
1024: * allocated from a pre-allocated array. Returns F_NULL if it can't open
1025: * the fifo.
1026: */
1027: FIFO *
1028: fifo_open(fifo_space, mode)
1029: typed_space *fifo_space;
1030: int mode;
1031: {
1032: } /* fifo_open() */
1033: /* This is the typed space we will use for our FIFO operations. */
1034: TYPED_SPACE(global_space, 128, T_FIFO_SIC); /* Static In-Core Fifo. */
1035: int
1036: main()
1037: {
1038: } /* main() */
1039: /* gift.c -- Prepare a gift of information for the program currently loaded.
1040: *
1041: * To pass a new data structure into the kernel:
1042: *
1043: * 1. Define your new data structure in typed.h. You will probably want
1044: * to define some supporting routines for your data structure. These
1045: * should go in a file by themselves. Be sure to add the file to the
1046: * tboot Makefile.
1047: *
1048: * 2. Write a routine that takes at least an ffp, which will generate your
1049: * data structure and write it into the ffp. The routine should return 0
1050: * if it ran out of space in the FIFO. Other return values are permissible,
1051: * but ignored. Add arguments to prepare_gift() as needed. It is called
1052: * only from the end of main() in tboot.c
1053: *
1054: * 3. Add a call to your routine to prepare_gift() in the section marked
1055: * FILL THE BOX. This is an if statement with || seperated calls. The
1056: * most important data structures should be called first, because later
1057: * calls will be skipped if the FIFO fills.
1058: *
1059: * 4. In the kernel (probably in a driver) you will want to add a loop to
1060: * look through the gift for your data structure:
1061: *
1062: * FIFO *ffp;
1063: * typed_space *tp;
1064: *
1065: * ffp = fifo_open(&boot_gift, 0); -- Open gift for reading.
1066: *
1067: * if (F_NULL == ffp) {
1068: * indicate_error("Could not open boot_gift.");
1069: * } else {
1070: * while (T_NULL != (tp = fifo_read(ffp))) { -- While not EOFIFO.
1071: * if (T_MYTYPE == tp->ts_type) { -- Is this my type?
1072: * my_handler(tp->ts_data); -- Process the data.
1073: * }
1074: * }
1075: * }
1076: *
1077: * Be sure to include fifo.c and typed.h into your kernel.
1078: *
1079: */
1080: /* We have to build the gift in the local segment and then copy it in
1081: * place. In a better world, the gift could be built in place.
1082: */
1083: TYPED_SPACE(local_gift, GIFTBOX, T_FIFO_SIC); /* Static In-Core Fifo. */
1084: /* Prepare a gift of information for the program currently loaded.
1085: *
1086: * The gift is a Static In-Core FIFO whose objects are typed spaces.
1087: *
1088: * cmd_line is the command line needby by gift_argf().
1089: *
1090: * It should be placed in memory at data_seg:offset.
1091: */
1092: void
1093: prepare_gift(data_seg, offset, cmd_line)
1094: uint16 data_seg;
1095: uint16 offset;
1096: char *cmd_line;
1097: {
1098: } /* prepare_gift() */
1099: /* Load the BIOS parameters loaded up by the startup code. */
1100: int
1101: gift_drive_params(ffp)
1102: FIFO *ffp;
1103: {
1104: } /* gift_drive_params() */
1105: /* We'd really rather have a dynamic in-core fifo, but they are not
1106: * yet implimented. We'll have to settle for a fixed length argument list.
1107: */
1108: TYPED_SPACE(argf, BLOCK, T_FIFO_SIC);
1109: /*
1110: * To read this item from bootgift, use the procedure outlined above in
1111: * point 4 to find the entry marked T_STR_ARGF. You must then explicitly
1112: * recast it with RETYPE(tp->ts_data, T_FIFO_SIC). Then you can open it
1113: * as a FIFO, with code modeled on point 4 above. This scheme seemed
1114: * the simplest for uniquely identifying the argument FIFO.
1115: * Each element of the FIFO is a T_STR_STR, so ts_data for these is
1116: * just a NUL terminated string. You can a
1117: */
1118: /* Write an argument fifo into ffp from the command line cmd_line.
1119: * Returns 0 if it runs out of space, 1 on success, and 2 if something else
1120: * goes wrong.
1121: */
1122: int
1123: gift_argf(ffp, cmd_line)
1124: FIFO *ffp;
1125: char *cmd_line;
1126: {
1127: } /* gift_argf() */
1128: /* Write a structure describing the boot partition into a fifo.
1129: * Returns 1 on success, 0 if it runs out of space, or 2 if it
1130: * can't read the boot block.
1131: */
1132: int
1133: gift_rootdev(ffp)
1134: FIFO *ffp;
1135: {
1136: } /* gift_rootdev() */
1137: /* Dump the contents of boot_gift. */
1138: void
1139: dump_gift()
1140: {
1141: }
1142: /* Dump the contents of a fifo. */
1143: void
1144: dump_fifo(fifo)
1145: typed_space *fifo;
1146: {
1147: } /* dump_gift() */
1148: /* Dump a T_BIOS_DISK typed_space. */
1149: void
1150: dump_bios_disk(a_disk)
1151: BIOS_DISK *a_disk;
1152: {
1153: } /* dump_bios_disk() */
1154: /* Dump a T_BIOS_ROOTDEV typed_space. */
1155: void
1156: dump_rootdev(a_rootdev)
1157: BIOS_ROOTDEV *a_rootdev;
1158: {
1159: } /* dump_rootdev() */
1160: /*
1161: * Handle the indirections in Unix-style file system.
1162: *
1163: * Uses a recursive scheme to follow up indirections.
1164: *
1165: * Needs optimization. A good place to start would be caching of
1166: * lookup tables.
1167: *
1168: * La Monte H. Yarroll <[email protected]>, September 1991
1169: */
1170: extern BUF *bread();
1171: daddr_t vmap();
1172: daddr_t indirect();
1173: daddr_t ind_lookup();
1174: uint16 ind_index();
1175: /* Convert the given virtual block to a physical block for the given inode.
1176: * ip points to the in-core inode for a file.
1177: * vblockno is a block number relative to the start of that file.
1178: */
1179: daddr_t
1180: vmap(ip, vblockno)
1181: struct inode *ip;
1182: daddr_t vblockno;
1183: {
1184: } /* vmap() */
1185: /* indirect(uint16 ind_level, daddr_t ind_table_ptr, daddr_t vblockno)
1186: * Recursively follow an indirection for a given virtual block number
1187: * vblockno.
1188: * ind_level must be the level of indirection still un-resolved.
1189: * ind_table is the physical block number of the next indirection.
1190: */
1191: daddr_t
1192: indirect(ind_level, ind_table_ptr, vblockno)
1193: uint16 ind_level;
1194: daddr_t ind_table_ptr;
1195: daddr_t vblockno;
1196: {
1197: } /* indirect() */
1198: /* ind_lookup(uint16 ind_level, daddr_t *ind_table, daddr_t vblockno)
1199: * Look up the next level of block in table ind_table, for virtual
1200: * block number vblockno.
1201: * Note that this table is in DISK CANNONICAL format. If the local
1202: * notion of daddr_t is a different size from DISK CANONICAL daddr_t
1203: */
1204: daddr_t
1205: ind_lookup(ind_level, ind_table, vblockno)
1206: uint16 ind_level;
1207: daddr_t *ind_table;
1208: daddr_t vblockno;
1209: {
1210: }
1211: /* uint16 ind_index(uint16 ind_level, daddr_t vblockno);
1212: * Calculate the index needed for virtual block vblockno into
1213: * a table of the given indirection level.
1214: */
1215: * NBN = 128 entries = 7 bit address.
1216: */
1217: uint16
1218: ind_index(ind_level, vblockno)
1219: uint16 ind_level;
1220: daddr_t vblockno;
1221: {}
1222: //////////
1223: / From MSDOS MWC86 system call interface.
1224: / Interrupt simulation.
1225: / Modified for use with tertiary boot code for COHERENT.
1226: /
1227: / Modified September 1991 by La Monte H. Yarroll <[email protected]>
1228: /
1229: / DANGER!! THIS IS SELF MODIFYING CODE. IT WILL ONLY WORK IN A STRICTLY
1230: / SINGLE THREADED ENVIRONMENT.
1231: //////////
1232: //////////
1233: / void
1234: / intcall(src, dest, intnum)
1235: / struct reg *src; /* All regs are loaded except flags */
1236: / struct reg *dest; /* All regs are stored here */
1237: / int intnum; /* Int number */
1238: //////////
1239: src = 6+RASIZE
1240: dest = src+PTRSIZE
1241: intnum = dest+PTRSIZE
1242: .globl intcall_
1243: intcall_:
1244: push si / Save register variables.
1245: push di
1246: push bp
1247: mov bp, sp
1248: movb al, intnum(bp) / Get intnum in AL
1249: movb cs:myint+1, al / Modify the code
1250: Lds si, src(bp) / Load DS:SI with src pointer.
1251: mov ax, (si) / Set AX
1252: mov bx, 2(si) / and BX
1253: mov cx, 4(si) / and CX
1254: mov dx, 6(si) / and DX
1255: mov di, 10(si) / and DI,
1256: push 12(si) / save src DS,
1257: mov es, 14(si) / set ES
1258: mov si, 8(si) / and SI
1259: pop ds / and DS.
1260: / Actually do the interrupt.
1261: myint: int 0 / This instruction gets modified.
1262: / The interrupt handler preserves SS:SP.
1263: / The iret to the handler pops the handler address and flags pushed above,
1264: / the iret from the handler pops the retint address and flags.
1265: retint:
1266: mov bp, sp / Restore BP.
1267: pushf / Save result flags
1268: push es / and ES
1269: push ds / and DS
1270: push si / and SI.
1271: mov si, ss
1272: mov ds, si / Restore DS
1273: mov es, si / and ES.
1274: Lds si, dest(bp) / Get dest in DS:SI.
1275: mov (si), ax / Load dest with returned AX
1276: mov 2(si), bx / and BX
1277: mov 4(si), cx / and CX
1278: mov 6(si), dx / and DX
1279: pop 8(si) / and SI
1280: mov 10(si), di / and DI
1281: pop 12(si) / and DS
1282: pop 14(si) / and ES
1283: pop 16(si) / and flags.
1284: pop bp
1285: pop di
1286: pop si
1287: Gret
1288: / end of intcall.m
1289: /* l.out.c -- routines for manipulating l.out executable files. */
1290: /* Convert l.out to load table.
1291: * Used to generate loading instructions for use by tboot main().
1292: * Returns true on successful translation.
1293: */
1294: int
1295: lout2load(ip, table, data_seg)
1296: struct inode *ip; /* input: File to read. */
1297: struct load_segment table[]; /* output: How to read it. */
1298: uint16 *data_seg; /* output: Where to point es. */
1299: {
1300: }
1301: /*
1302: * Get entries from l.out name list.
1303: */
1304: void
1305: l_out_nlist(fn, nlp)
1306: char *fn;
1307: struct nlist *nlp;
1308: {
1309: }
1310: /* Mini-monitor for testing boot code.
1311: *
1312: * La Monte H. Yarroll <[email protected]>, September 1991
1313: */
1314: void
1315: monitor()
1316: {
1317: }
1318: /* objects.c -- routines for handling different object formats.
1319: * Currently, only COFF and COHERENT l.out are supported.
1320: */
1321: /* Extract information from an object file that describes how to
1322: * load an executable.
1323: * The magic number of the file is in "magic".
1324: * The object file's inode is in "ip".
1325: *
1326: * The information needed is extracted into "table".
1327: * The value for the data segment is put in "data_seg".
1328: *
1329: * Returns TRUE if the needed information could be extracted, FALSE ow.
1330: */
1331: int
1332: object2load(magic, ip, table, data_seg)
1333: uint16 magic;
1334: struct inode *ip;
1335: struct load_segment table[];
1336: uint16 *data_seg;
1337: {
1338: } /* object2load() */
1339: /* Look up symbol(s) in an object file.
1340: * searches the name list (symbol table) of the load module
1341: * "filename" for each symbol in the array pointed to by "nlp".
1342: *
1343: * nlp points to an array of nlist structures, terminated by a
1344: * structure with a null string as its n_name member.
1345: *
1346: * If "filename" is not a load module or has had its symbol table
1347: * stripped, all returned n_type and n_value entries will be zero.
1348: *
1349: */
1350: uint16
1351: object_nlist(magic, filename, symbol)
1352: uint16 magic;
1353: char *filename;
1354: char *symbol;
1355: {
1356: } /* object_nlist() */
1357: /* Determine the value for sys_base based on the type of the load file. */
1358: uint16
1359: object_sys_base(magic)
1360: int magic;
1361: {
1362: } /* object_sys_base() */
1363: main()
1364: {
1365: } /* main () */
1366: /*
1367: * pacifier.c - state machine for putting something interesting on the screen.
1368: */
1369: int slow_flag = FALSE; /* Slow down pacifier. */
1370: int feet_flag = FALSE; /* Print footprints? */
1371: void pac_init(); /* Initialise the state machine. */
1372: void pac_cleanup(); /* Clean up after the state machine. */
1373: void pacifier(); /* Run the next step of the state machine. */
1374: void subliminal(); /* Print a subliminal message. */
1375: static int pac_inited = FALSE; /* Has pac_init() been called? */
1376: static int pac_dirty = FALSE; /* Has pacifier() been called? */
1377: static int state;
1378: static int substate;
1379: static int count;
1380: void
1381: pacifier()
1382: {
1383: } /* pacifier() */
1384: /*
1385: * Print a subliminal message on the console.
1386: * It does this by printing the message, backspacing over it,
1387: * spacing over it, and the backspacing again.
1388: */
1389: void
1390: subliminal(msg)
1391: char *msg;
1392: {
1393: } /* subliminal() */
1394: /*
1395: * Initialize the pacifier state machine.
1396: */
1397: void
1398: pac_init()
1399: {
1400: } /* pac_init() */
1401: /*
1402: * Clean up the screen after the pacifier.
1403: */
1404: void
1405: pac_cleanup()
1406: {
1407: } /* pac_cleanup() */
1408: /* sys.c -- Simulate kernel calls for file i/o.
1409: */
1410: int errno;
1411: /* Table of file descriptors. */
1412: static FD u_filep[NUFILE];
1413: static struct inode ip_table[NUFILE];
1414: static inited = (1==2);
1415: /* Open a file.
1416: * Takes a file name, file; and a way of opening it, type as follows:
1417: * 0 Read only
1418: * 1 Write
1419: * 2 Read and write
1420: * Only read is implimented.
1421: *
1422: * Returns a file descriptor, or -1 if the open failed.
1423: */
1424: int
1425: open(file, type)
1426: char *file;
1427: int type;
1428: {
1429: } /* open() */
1430: /* Read from a file.
1431: * Takes a file descriptor, a buffer, and a length to read.
1432: *
1433: * Returns the number of characters read, or -1 if an error occurs.
1434: */
1435: int
1436: read(fd, buffer, n)
1437: int fd;
1438: char *buffer;
1439: int n;
1440: {
1441: } /* read() */
1442: /* Close a file.
1443: * Takes a file descriptor.
1444: */
1445: int
1446: close(fd)
1447: int fd;
1448: {
1449: } /* close() */
1450: /* Set a read/write position.
1451: * Changes the seek position for file descriptor fd.
1452: * where and how describe the new seek position. where gives the
1453: * number of bytes that you wish to move the seek position; it is
1454: * measured from the beginning of the file if how is zero, from the
1455: * current seek position if how is one, or from the end of the file
1456: * if how is two. A successful call to lseek returns the new seek
1457: * position; a failure returns (int32) -1.
1458: */
1459: long
1460: lseek(fd, where, how)
1461: int fd;
1462: long where;
1463: int how;
1464: {
1465: } /* lseek() */
1466: /* tboot.c -- tertiary boot
1467: * This is invoked by the secondary boot to do all the things we can't
1468: * do in just 512 bytes.
1469: *
1470: * Includes an interpreter for builtin commands. Just type "info" or "dir"
1471: * to get disk information, or a directory listing of "/".
1472: *
1473: * Can load an image up to 1 gigabyte in length. Segments can be as
1474: * big as the whole file.
1475: *
1476: * La Monte H. Yarroll <[email protected]>, September 1991
1477: */
1478: /* Potentially communicated information from an earlier tboot. */
1479: TYPED_SPACE(boot_gift, 8192, T_FIFO_SIC); /* Static In-Core FIFO. */
1480: main()
1481: {
1482: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.