![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to DOCS 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 / old_tboot|
Return to DOCS CVS log | Up to [MW Coherent from dump] / coherent / d / conf / old_tboot |
1.1 root 1: Documentation for libtboot.a.
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30: Startup.s: .globl myds_
31: Startup.s: .globl seconddat
32: Startup.s: .globl nbuf_
33: Startup.s: .globl traks
34: Startup.s: .globl traks_
35: Startup.s: .globl sects
36: Startup.s: .globl sects_
37: Startup.s: .globl heads
38: Startup.s: .globl heads_
39: Startup.s: .globl drive
40: Startup.s: .globl drive_
41: Startup.s: .globl first
42: Startup.s: .globl first_
43: BASE10 cbootlib.c 83
44: BASE16 cbootlib.c 113
45: BITS_PER_INT16 cbootlib.c 251
46: BLOCK tboot.h 25
47: BS cbootlib.c 26
48: BUFSIZE tboot.h 55
49: COFF_SYS_BASE tboot.h 63
50: DEF_SYS_BASE tboot.h 64
51: DEL cbootlib.c 27
52: DIGITS_PER_INT16 cbootlib.c 252
53: DIGITS_PER_INT8 cbootlib.c 253
54: DISK tboot.h 56
55: DISKINT tboot.h 32
56: DISK_PARAMS tboot.h 33
57: FALSE tboot.h 20
58: FIRST tboot.h 59
59: FOURK tboot.h 23
60: FOURKBOUNDRY tboot.h 24
61: FULLSEG tboot.h 60
62: GIFTBOX gift.c 48
63: GREATEST tboot.h 74
64: HARD_DRIVE tboot.h 34
65: HIGH tboot.h 76
66: IBSHIFT tboot.h 52
67: INODES_PER_BLOCK tboot.h 38
68: INOMASK tboot.h 54
69: INOORG tboot.h 51
70: IOSHIFT tboot.h 53
71: KEYBD tboot.h 57
72: LESSER tboot.h 75
73: LINESIZE tboot.h 26
74: LOW tboot.h 77
75: MAIN tboot.c 23
76: MAXINT16 ptypes.h 16
77: MAXINT32 ptypes.h 20
78: MAXINT8 ptypes.h 12
79: MAXSEG cbootlib.c 177
80: MAXUINT16 ptypes.h 18
81: MAXUINT32 ptypes.h 22
82: MAXUINT8 ptypes.h 14
83: MAX_SEGS tboot.h 27
84: MIDNIGHT cbootlib.c 377
85: Mcoff coff.c main()
86: Mobjects objects.c main()
87: NAK cbootlib.c 28
88: NBUF bio.c 16
89: NHD tboot.h 42
90: NORMAL_MAGIC tboot.h 28
91: NSPT tboot.h 46
92: NTRK tboot.h 47
93: NULL tboot.h 22
94: PPMASK tboot.h 61
95: PPSIZE cbootlib.c 178
96: PROMPT monitor.c 15
97: PTYPES_H ptypes.h 6
98: READ1 tboot.h 58
99: RESIZE typed.h 40
100: RETYPE typed.h 42
101: ROOTINO tboot.h 50
102: SEVENONES indirect.c 139
103: SIXBITS tboot.h 36
104: SYS_START tboot.h 65
105: THE_DEV tboot.h 67
106: THE_XDEV tboot.h 68
107: TIMER_OFF cbootlib.c 375
108: TIMER_SEG cbootlib.c 374
109: TRUE tboot.h 19
110: TYPED_H typed.h 17
111: TYPED_SPACE fifo_k.c TYPED_SPACE(global_space, 128, T_FIFO_SIC); Static In-Core Fifo.
112: TYPED_SPACE gift.c TYPED_SPACE(local_gift, GIFTBOX, T_FIFO_SIC); Static In-Core Fifo.
113: TYPED_SPACE tboot.c TYPED_SPACE(boot_gift, 8192, T_FIFO_SIC); Static In-Core FIFO.
114: TYPED_SPACE typed.h 32
115: T_BIOS typed.h 63
116: T_BIOS_DISK typed.h 64
117: T_BIOS_ROOTDEV typed.h 65
118: T_FIFO typed.h 56
119: T_FIFO_DIC typed.h 58
120: T_FIFO_DP typed.h 60
121: T_FIFO_SIC typed.h 57
122: T_FIFO_SP typed.h 59
123: T_STR typed.h 68
124: T_STR_ARGF typed.h 71
125: T_STR_ARGV typed.h 69
126: T_STR_STR typed.h 70
127: T_UNKNOWN typed.h 53
128: WAIT_DELAY tboot.h 71
129: WS tboot.h 21
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153: _bread_ bootlib.m
154: _ffcopy_ bootlib.m
155: _xbread_ bootlib.m
156: arg_exist arg_exist.c
157: * Determine whether or not a given argument exists on the command line
158: * passed into the kernel.
159: *
160: * Takes a pointer to a NUL terminated string that is the name of
161: * the desired argument.
162: int arg_exist(arg)
163: basetoi cbootlib.c uint16 basetoi(char *s, base)
164: uint16 basetoi(); Convert an arbitrary base string to an integer.
165: * basetoi(char *s, int base)
166: * Convert a string base "base" to an integer.
167: * Good through base 36.
168: * Loosely based on K&R's atoi().
169: bclaim bio.c bclaim(block)
170: BUF *bclaim(); Claim a disk buffer.
171: bpick bio.c bpick()
172: BUF *bpick(); Pick a buffer to trash.
173: bread diskio.c bread(blockno)
174: /* Aligning bread.
175: * Reads 1 block into an arbitrary buffer. The assembly language
176: * routine bread() needs a buffer aligned on a 4K boundary.
177: */
178:
179: BUF *
180: bread(blockno)
181: daddr_t blo
182: brelease bio.c brelease(bp)
183: void brelease(); Free a disk buffer.
184: bufinit bio.c bufinit()
185: void bufinit(); Initialize disk buffers.
186: close sys.c int close(int fd)
187: int close(); /* Close a file descriptor. */
188: coff2load coff.c coff2load(ip, table, data_seg)
189: int
190: coff2load(ip, table, data_seg)
191: struct inode *ip; /* input: File to read. */
192: struct load_segment table[]; /* output: How to read it. */
193: uint16 *data_seg; /* output: Where to point es. */
194: * Convert COFF to load table.
195: * Used to generate loading instructions for use by tboot main().
196: * Returns true on successful translation.
197: coffnlist coff.c
198: Search COFF file for symbols.
199: int
200: coffnlist(fn, nlp, names, count)
201: char *fn; /* file name */
202: SYMENT *nlp; /* names to look up */
203: char *names; /* long names */
204: int count; /* size of passed table */
205:
206: dir builtin.c dir()
207: Create a listing of file names in /.
208: void dir()
209: dpb builtin.c dpb()
210: Display the BIOS parameters loaded up by the startup code.
211: void dpb()
212: dump_bios_disk gift.c dump_bios_disk(a_disk)
213: /* Dump a T_BIOS_DISK typed_space. */
214: void
215: dump_bios_disk(a_disk)
216: BIOS_DISK *a_disk;
217: dump_fifo gift.c dump_fifo(fifo)
218: /* Dump the contents of a fifo. */
219: void
220: dump_fifo(fifo)
221: typed_space *fifo;
222: dump_gift gift.c dump_gift()
223: /* Dump the contents of boot_gift. */
224: void
225: dump_gift()
226: dump_rootdev gift.c dump_rootdev(a_rootdev)
227: /* Dump a T_BIOS_ROOTDEV typed_space. */
228: void
229: dump_rootdev(a_rootdev)
230: BIOS_ROOTDEV *a_rootdev;
231: fdisk fdisk.c fdisk( fp )
232: * void
233: * fdisk( fp ) -- Fixed Disk Configuration
234: * dev_t dev;
235: * struct fdisk_s *fp;
236: * Input: fp = pointer to memory-resident partition info (to update)
237: *
238: * Action: Read first block from the device.
239: * If valid signature present on block,
240: * copy partition information to memory
241: *
242: * Return: 1 = partition information successfully updated
243: * 0 = failure (could not read block, or bad signature)
244:
245: ffcopy cbootlib.c ffcopy(to_offset, to_seg, from_offset, from_seg, length)
246: * Wrapper for far-far copy. Changes the segment so that the requested
247: * length does not wrap past the end of the segment.
248: *
249: * For Intel 8086 Real Mode.
250: void
251: ffcopy(to_offset, to_seg, from_offset, from_seg, length)
252: uint16 to_offset;
253: uint16 to_seg;
254: uint16 from_offset;
255: uint16 from_seg;
256: uint16 length;
257: fifo_close fifo_k.c fifo_close(ffp)
258: int fifo_close(); Finish with using a typed space as a fifo.
259: fifo_len fifo_b.c fifo_len(ffp)
260: long fifo_len(); /* Find out how long a fifo is. */
261: fifo_open fifo_k.c fifo_open(fifo_space, mode)
262: FIFO *fifo_open(); Open a typed space as a fifo.
263: fifo_read fifo_k.c fifo_read(ffp)
264: typed_space *fifo_read(); Read a typed space from a fifo.
265: fifo_rewind fifo_k.c fifo_rewind(ffp)
266: int fifo_rewind(); Go back to the start of the fifo.
267: fifo_write fifo_b.c fifo_write(ffp, space)
268: typed_space *fifo_write(); Write a typed space into an open fifo.
269: fifo_write_untyped fifo_b.c fifo_write_untyped(ffp, datum, size, type)
270: typed_space *fifo_write_untyped(); Write data into an open fifo.
271: getchar bootlib.m
272: gate_lock bio.c gate_lock(g)
273: int gate_lock(); Attempt to lock a GATE.
274: gate_locked bio.c gate_locked(g)
275: int gate_locked(); Check to see if a GATE is locked.
276: gate_unlock bio.c gate_unlock(g)
277: void gate_unlock(); Unlock a GATE.
278: get_num_of_drives builtin.c int get_num_of_drives()
279: /* Ask the BIOS how many drives are attached. */
280: int get_num_of_drives()
281: gets cbootlib.c gets(s)
282: char *gets(); Get a string from the keyboard.
283: gift_argf gift.c gift_argf(ffp, cmd_line)
284: /* Write an argument fifo into ffp from the command line cmd_line.
285: * Returns 0 if it runs out of space, 1 on success, and 2 if something else
286: * goes wrong.
287: */
288: int
289: gift_argf(ffp, cmd_line)
290: FIFO *ffp;
291: char *cmd_line;
292: gift_drive_params gift.c gift_drive_params(ffp)
293: /* Load the BIOS parameters loaded up by the startup code. */
294: int
295: gift_drive_params(ffp)
296: FIFO *ffp;
297: gift_rootdev gift.c gift_rootdev(ffp)
298: /* Write a structure describing the boot partition into a fifo.
299: * Returns 1 on success, 0 if it runs out of space, or 2 if it
300: * can't read the boot block.
301: */
302: int
303: gift_rootdev(ffp)
304: FIFO *ffp;
305: gotofar bootlib.m
306: gotoker bootlib.m
307: hdinit bootlib.m
308: ifread diskio.c ifread(ip, toseg, tooffset, offset, lenarg)
309: * Inode to Far READ: Load an arbitrary length from a file into a far address.
310: void
311: ifread(ip, toseg, tooffset, offset, lenarg)
312: struct inode *ip; /* Read from this file, */
313: uint16 toseg; /* into this far buffer, */
314: uint16 tooffset;
315: fsize_t offset; /* from here in the file, */
316: fsize_t lenarg; /* for this many bytes. */
317: ind_index indirect.c ind_index(ind_level, vblockno)
318: * uint16 ind_index(uint16 ind_level, daddr_t vblockno);
319: * Calculate the index needed for virtual block vblockno into
320: * a table of the given indirection level.
321: ind_lookup indirect.c ind_lookup(ind_level, ind_table, vblockno)
322: * Look up the next level of block in table ind_table, for virtual
323: * block number vblockno.
324: * Note that this table is in DISK CANNONICAL format. If the local
325: * notion of daddr_t is a different size from DISK CANONICAL daddr_t
326: daddr_t
327: ind_lookup(ind_level, ind_table, vblockno)
328: uint16 ind_level;
329: daddr_t *ind_table;
330: daddr_t vblockno;
331: indirect indirect.c indirect(ind_level, ind_table_ptr, vblockno)
332: * Recursively follow an indirection for a given virtual block number
333: * vblockno.
334: * ind_level must be the level of indirection still un-resolved.
335: * ind_table is the physical block number of the next indirection.
336: * daddr_t
337: * indirect(uint16 ind_level, daddr_t ind_table_ptr, daddr_t vblockno)
338: intcall intcall.m
339: int intcall(reg *srcreg, reg *destreg, int intnum);
340: Provide C interface to bios interrupts.
341: interpret builtin.c interpret(command)
342: * If possible, execute "command".
343: * Return "true" if the command exists, "false" otherwise.
344: int
345: interpret(command)
346: char *command;
347: intmon bootlib.m
348: iopen diskio.c iopen(meminode, inode_number)
349: * Inode OPEN: Load the inode for a file into memory.
350: * iopen(struct inode *ip,
351: * ino_t inode_number)
352: int
353: iopen(meminode, inode_number)
354: struct inode *meminode;
355: ino_t inode_number;
356: iread diskio.c iread(ip, buffer, offset, lenarg)
357: * Inode READ: Load a local buffer from a file.
358: void
359: iread(ip, buffer, offset, lenarg)
360: struct inode *ip; /* Read from this file, */
361: char *buffer; /* into this buffer, */
362: fsize_t offset; /* from here in the file, */
363: uint16 lenarg; /* for this many bytes. */
364: iskey bootlib.m
365: itoa cbootlib.c itoa(n, s)
366: void itoa(); Convert an integer to a decimal string.
367: itobase cbootlib.c itobase(n, s, base)
368: void itobase(); Convert an integer to an arbitrary base string.
369: l_out_nlist l.out.c l_out_nlist(fn, nlp)
370: * Get entries from l.out name list.
371: void
372: l_out_nlist(fn, nlp)
373: char *fn;
374: struct nlist *nlp;
375: lout2load l.out.c lout2load(ip, table, data_seg)
376: /* Convert l.out to load table.
377: * Used to generate loading instructions for use by tboot main().
378: * Returns true on successful translation.
379: */
380:
381: int
382: lout2load(ip, table, data_seg)
383: struct inode *ip; /* input: File to read. */
384: struct load_segment table[]; /* output: How to read it. */
385: uint16 *data_seg; /* output: Where to point es. */
386: lpad cbootlib.c lpad(s, c, n)
387: char *lpad(); Pad a string on the left.
388: lseek sys.c lseek(fd, where, how)
389: /* Set a read/write position.
390: * Changes the seek position for file descriptor fd.
391: * where and how describe the new seek position. where gives the
392: * number of bytes that you wish to move the seek position; it is
393: * measured from the beginning of the file if how is zero, from the
394: * current seek position if how is one, or from the end of the file
395: * if how is two. A successful call to lseek returns the new seek
396: * position; a failure returns (int32) -1.
397: */
398: long
399: lseek(fd, where, how)
400: int fd;
401: long where;
402: int how;
403: monitor monitor.c void monitor()
404: Mini-monitor for testing boot code.
405: namei diskio.c namei(filename)
406: * Convert a filename to an inode number. Returns inode number 0 on
407: * failure.
408: ino_t
409: namei(filename)
410: char *filename;
411: object2load objects.c object2load(magic, ip, table, data_seg)
412: /* Extract information from an object file that describes how to
413: * load an executable.
414: * The magic number of the file is in "magic".
415: * The object file's inode is in "ip".
416: *
417: * The information needed is extracted into "table".
418: * The value for the data segment is put in "data_seg".
419: *
420: * Returns TRUE if the needed information could be extracted, FALSE ow.
421: */
422:
423: int
424: object2load(magic, ip, table, data_seg)
425: uint16 magic;
426: struct inode *ip;
427: struct load_segment table[];
428: uint16 *data_seg;
429: object_nlist objects.c object_nlist(magic, filename, symbol)
430: /* Look up symbol(s) in an object file.
431: * searches the name list (symbol table) of the load module
432: * "filename" for each symbol in the array pointed to by "nlp".
433: *
434: * nlp points to an array of nlist structures, terminated by a
435: * structure with a null string as its n_name member.
436: *
437: * If "filename" is not a load module or has had its symbol table
438: * stripped, all returned n_type and n_value entries will be zero.
439:
440: uint16
441: object_nlist(magic, filename, symbol)
442: uint16 magic;
443: char *filename;
444: char *symbol;
445: object_sys_base objects.c object_sys_base(magic)
446: /* Determine the value for sys_base based on the type of the load file. */
447: uint16
448: object_sys_base(magic)
449: int magic;
450: open sys.c open(file, type)
451: /* Open a file.
452: * Takes a file name, file; and a way of opening it, type as follows:
453: * 0 Read only
454: * 1 Write
455: * 2 Read and write
456: * Only read is implimented.
457: *
458: * Returns a file descriptor, or -1 if the open failed.
459: */
460: int
461: open(file, type)
462: char *file;
463: int type;
464: print8 cbootlib.c print8(uint8 my_int)
465: void print8(); Print an 8 bit integer, base 16.
466: print16 cbootlib.c print16(uint16 my_int)
467: void print16(); Print a 16 bit integer, base 16.
468: print32 cbootlib.c print32(uint32 my_int)
469: void print32(); Print a 32 bit integer, base 16.
470: putchar bootlib.m
471: puts cbootlib.c puts(s)
472: void puts(); Put a string on the screen.
473: * puts() -- put a NUL terminated string.
474: * Takes one argument--a pointer to a NUL terminated character string.
475: * Does no error checking. Calls the assembly language routine putc().
476: read sys.c read(fd, buffer, n)
477: * Read from a file.
478: * Takes a file descriptor, a buffer, and a length to read.
479: *
480: * Returns the number of characters read, or -1 if an error occurs.
481: int
482: read(fd, buffer, n)
483: int fd;
484: char *buffer;
485: int n;
486: reverse cbootlib.c reverse(s)
487: void reverse(); Reverse a string in place.
488: sanity_check bio.c sanity_check(message)
489: * Sanity checker.
490: * Prints contents of "message" if something is amiss and dumps you
491: * into the monitor.
492: *
493: * Add tests and messages as needed.
494:
495: void
496: sanity_check(message)
497: char *message;
498: seg_align cbootlib.c seg_align(offset, segment)
499: void seg_align(); Align a far address.
500: seginc cbootlib.c seginc(offset, segment, increment)
501: /* seginc(uint16 *offset,
502: * uint16 *segment,
503: * uint16 increment)
504: * Add an offset to a segment. We may adjust the segment base
505: * to make everything fit.
506: */
507: vmap indirect.c vmap(ip, vblockno)
508: /* Convert the given virtual block to a physical block for the given inode.
509: * ip points to the in-core inode for a file.
510: * vblockno is a block number relative to the start of that file.
511: */
512: daddr_t
513: vmap(ip, vblockno)
514: struct inode *ip;
515: daddr_t vblockno;
516: wait_for_keystroke cbootlib.c wait_for_keystroke(delay, key)
517: int wait_for_keystrok(); Wait a time delay for a keystroke.
518: wrap_coffnlist coff.c wrap_coffnlist(fn, symbol)
519: * Look up the value of a single data symbol in a coff file,
520: * relative to the start of the data segment.
521: *
522: * We use the symbol "sdata" to find the start of the data segment--
523: * this works for 386 COHERENT kernels but will not work in general.
524: * It should really fetch the address of the start of the data segment
525: * from the data section header.
526: uint32
527: wrap_coffnlist(fn, symbol)
528: char *fn; /* file name */
529: char *symbol; /* symbol to look up */
530: xbread diskio.c xbread(blockno)
531: * Aligning xbread.
532: * Disk addresses are relative to the start of the disk, rather than
533: * the start of the partition.
534: * Reads 1 block into an arbitrary buffer. The assembly language
535: * routine xbread() needs a buffer aligned on a 4K boundary.
536: BUF *
537: xbread(blockno)
538: daddr_t blockno; /* Block number. */
539: * To pass a new data structure into the kernel:
540: *
541: * 1. Define your new data structure in typed.h. You will probably want
542: * to define some supporting routines for your data structure. These
543: * should go in a file by themselves. Be sure to add the file to the
544: * tboot Makefile.
545: *
546: * 2. Write a routine that takes at least an ffp, which will generate your
547: * data structure and write it into the ffp. The routine should return 0
548: * if it ran out of space in the FIFO. Other return values are permissible,
549: * but ignored. Add arguments to prepare_gift() as needed. It is called
550: * only from the end of main() in tboot.c
551: *
552: * 3. Add a call to your routine to prepare_gift() in the section marked
553: * FILL THE BOX. This is an if statement with || seperated calls. The
554: * most important data structures should be called first, because later
555: * calls will be skipped if the FIFO fills.
556: *
557: * 4. In the kernel (probably in a driver) you will want to add a loop to
558: * look through the gift for your data structure:
559: *
560: * FIFO *ffp;
561: * typed_space *tp;
562: *
563: * ffp = fifo_open(&boot_gift, 0); -- Open gift for reading.
564: *
565: * if (F_NULL == ffp) {
566: * indicate_error("Could not open boot_gift.");
567: * } else {
568: * while (T_NULL != (tp = fifo_read(ffp))) { -- While not EOFIFO.
569: * if (T_MYTYPE == tp->ts_type) { -- Is this my type?
570: * my_handler(tp->ts_data); -- Process the data.
571: * }
572: * }
573: * }
574: *
575: * Be sure to include fifo_k.c and typed.h into your kernel.
576:
577:
578: gift_drive_params
579:
580: gift_argf
581: * To read gift_argf from bootgift, use the procedure outlined above in
582: * point 4 to find the entry marked T_STR_ARGF. You must then explicitly
583: * recast it with RETYPE(tp->ts_data, T_FIFO_SIC). Then you can open it
584: * as a FIFO, with code modeled on point 4 above. This scheme seemed
585: * the simplest for uniquely identifying the argument FIFO.
586: * Each element of the FIFO is a T_STR_STR, so ts_data for these is
587: * just a NUL terminated string.
588:
589: gift_rootdev
590: /* typed.h -- Data structures for an implimentation of internally
591: * typed data structures.
592: *
593: * This file has 5 major sections:
594: * TYPED_SPACE DECLARATIONS -- Declarations for typed_space in general.
595: * DATA TYPES -- Values for typed_space.ts_type.
596: * Make at least one entry here when you add new data types.
597: * STRUCTURE DECLARATIONS -- Declarations for specific typed spaces.
598: * Declare structures that describe the typed_space.ts_data element.
599: * FUNCTION DECLARATIONS -- Function names for specific typed spaces.
600: * Declare all the functions need to manipulate your data type.
601: * USEFUL SYMBOLS -- Symbols needed by specific typed spaces.
602: * Anything else you need to define should go here.
603: */
604:
605: /*
606: * DATA TYPES: (values for ts_type in a typed_space)
607: * All data types start with "T_".
608: * Similar data types share a common prefix which is defined like this:
609: * #define T_COMMON (space_type)0xhh00
610: * Specific types are then assigned sequentially from that:
611: * #define T_COMMON_SPECIFIC T_COMMON+n
612: */
613: /*
614: * STRUCTURE DECLARATIONS.
615: * These define the typed_space.ts_data elements that go with the above
616: * data types. They should be typedef'd to a name derivable from the
617: * type name by removing the leading "T_" (see above.)
618: *
619: * E.g. For the type T_COMMON create this typedef:
620: * typedef common {
621: * ...
622: * } COMMON;
623: *
624: * If the specific types need their own structs do them like this:
625: * typedef common_specific {
626: * ...
627: * } COMMON_SPECIFIC;
628: *
629: */
630:
631: /* USEFUL SYMBOLS.
632: * If appropriate, be sure to define a form of NULL for your new data
633: * type. E.g. for the type COMMON
634: * #define COMMON_NULL ((COMMON *) 0)
635: *
636: * If you need any other symbols define them here.
637: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.