Return to refs CVS log

Up to [MW Coherent from dump] / coherent / d / conf / old_tboot

coherent

arg_exist(arg)
fifo_find_str(afifo, astring)
	typed_space *afifo;
	char *astring;
bufinit()
bclaim(block)
	daddr_t block;
bpick()
brelease(bp)
	BUF *bp;
gate_lock(g)
	GATE g;
gate_locked(g)
	GATE g;
gate_unlock(g)
	GATE g;
sanity_check(message)
	char *message;
interpret(command)
	char *command;
dpb()
int get_num_of_drives()
dir()
puts(s)
	register char *s;
gets(s)
	char *s;
reverse(s)
	char s[];
itoa(n, s)
	char s[];
	int n;
itobase(n, s, base)
	uint16 n;
	char s[];
	int base;
basetoi(s, base)
	char *s;
	int base;
seginc(offset, segment, increment)
	uint16 *offset;
	uint16 *segment;
	 	uint16 increment;
lpad(s, c, n)
	char *s;
	char c;
	int n;
print32(my_int)
	uint32 my_int;
print16(my_int)
	uint16 my_int;
print8(my_int)
	uint8 my_int;
ffcopy(to_offset, to_seg, from_offset, from_seg, length)
	uint16 to_offset;
	uint16 to_seg;
	uint16 from_offset;
	uint16 from_seg;
	uint16 length;
seg_align(offset, segment)
	uint16 *offset;
	uint16 *segment;
wait_for_keystroke(delay, key)
	int delay;
	int key;
coff2load(ip, table, data_seg)
	struct inode *ip;		/* input: File to read.		*/
	struct load_segment table[];	/* output: How to read it.	*/
	uint16 *data_seg;	/* output: Where to point es.	*/
symName(sym, str_tab, work)
	SYMENT *sym;
	char *str_tab, *work;
wrap_coffnlist(fn, symbol)
	char *fn;	/* file name */
	char *symbol;	/* symbol to look up */
coffnlist(fn, nlp, names, count)
	char *fn;	/* file name */
	SYMENT *nlp;	/* names to look up */
	char *names;	/* long names */
	int count;	/* size of passed table */
main()
bread(blockno)
	daddr_t blockno;	/* Block number.  */
iopen(meminode, inode_number)
	struct inode *meminode;
	ino_t inode_number;
namei(filename)
	char *filename;
iread(ip, buffer, offset, lenarg)
	struct inode *ip;	/* Read from this file,		*/
	char *buffer;		/* into this buffer,		*/
	fsize_t offset;		/* from here in the file,	*/
	uint16 lenarg;	/* for this many bytes.		*/
ifread(ip, toseg, tooffset, offset, lenarg)
	struct inode *ip;	/* Read from this file,		*/
	uint16 toseg;	/* into this far buffer,	*/
	uint16 tooffset;
	fsize_t offset;		/* from here in the file,	*/
	fsize_t lenarg;		/* for this many bytes.		*/
xbread(blockno)
	daddr_t blockno;	/* Block number.  */
fdisk( fp )
	register FDISK_S *fp;
fifo_len(ffp)
	FIFO *ffp;
fifo_write(ffp, space)
	FIFO *ffp;
	typed_space *space;
fifo_write_untyped(ffp, datum, size, type)
	FIFO *ffp;
	char *datum;
	long size;
	space_type type;
fifo_read(ffp)
	register FIFO *ffp;
fifo_rewind(ffp)
	FIFO *ffp;
fifo_close(ffp)
	FIFO *ffp;
fifo_open(fifo_space, mode)
	typed_space *fifo_space;
	int mode;
TYPED_SPACE(global_space, 128, T_FIFO_SIC);	/* Static In-Core Fifo.  */
	
	int
	main()
TYPED_SPACE(local_gift, GIFTBOX, T_FIFO_SIC); /* Static In-Core Fifo.  */
	
	
	/* Prepare a gift of information for the program currently loaded.
	 *
	 * The gift is a Static In-Core FIFO whose objects are typed spaces.
	 *
	 * cmd_line is the command line needby by gift_argf().
	 *
	 * It should be placed in memory at data_seg:offset.
	 */
	void
	prepare_gift(data_seg, offset, cmd_line)
	uint16 data_seg;
	uint16 offset;
	char *cmd_line;
gift_drive_params(ffp)
	FIFO *ffp;
gift_argf(ffp, cmd_line)
	FIFO *ffp;
	char *cmd_line;
gift_rootdev(ffp)
	FIFO *ffp;
dump_gift()
dump_fifo(fifo)
	typed_space *fifo;
dump_bios_disk(a_disk)
	BIOS_DISK *a_disk;
dump_rootdev(a_rootdev)
	BIOS_ROOTDEV *a_rootdev;
vmap(ip, vblockno)
	struct inode *ip;
	daddr_t vblockno;
indirect(ind_level, ind_table_ptr, vblockno)
	uint16 ind_level;
	daddr_t ind_table_ptr;
	daddr_t vblockno;
ind_lookup(ind_level, ind_table, vblockno)
	uint16 ind_level;
	daddr_t *ind_table;
	daddr_t vblockno;
ind_index(ind_level, vblockno)
	uint16 ind_level;
	daddr_t vblockno;
lout2load(ip, table, data_seg)
	struct inode *ip;		/* input: File to read.		*/
	struct load_segment table[];	/* output: How to read it.	*/
	uint16 *data_seg;	/* output: Where to point es.	*/
l_out_nlist(fn, nlp)
	char *fn;
	struct nlist *nlp;
monitor()
object2load(magic, ip, table, data_seg)
	uint16 magic;
	struct inode *ip;
	struct load_segment table[];
	uint16 *data_seg;
object_nlist(magic, filename, symbol)
	uint16 magic;
	char *filename;
	char *symbol;
object_sys_base(magic)
	int magic;
main()
open(file, type)
	char *file;
	int type;
read(fd, buffer, n)
	int fd;
	char *buffer;
	int n;
close(fd)
	int fd;
lseek(fd, where, how)
	int fd;
	long where;
	int how;
TYPED_SPACE(boot_gift, 8192, T_FIFO_SIC);	/* Static In-Core FIFO.  */
	
	main()
FIFO *fifo_open();		/* Open a typed space as a fifo.	*/
	typed_space *fifo_read();	/* Read a typed space from a fifo.	*/
	typed_space *fifo_write();	/* Write a typed space into an open fifo.  */
	typed_space *fifo_write_untyped();  /* Write data into an open fifo.  */
	int fifo_rewind();		/* Go back to the start of the fifo.	*/
	int fifo_close();		/* Finish with using a typed space as a fifo.  */
	long fifo_len();		/* Find out how long a fifo is.  */
	
	/* USEFUL SYMBOLS.
	 * If appropriate, be sure to define a form of NULL for your new data
	 * type.  E.g. for the type COMMON
	 * #define COMMON_NULL ((COMMON *) 0)
	 *
	 * If you need any other symbols define them here.
	 */
	
	#define T_NULL	((typed_space *) 0)	/* The empty typed_space.  */
	
	/* Useful symbols for FIFOS.  */
	#define F_NULL	((FIFO *) 0)	/* The void FIFO.  */
	#define NFIFOS	20		/* Maximum of 20 fifos at a time... */
	
	/* Values for FIFO.f_flags.  */
	#define F_READ	0x0001
	#define F_WRITE	0x0002
	
	#endif /* ifdef TYPED_H */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.