Return to refs CVS log

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

Annotation of coherent/d/conf/old_tboot/refs, revision 1.1

1.1     ! root        1: arg_exist(arg)
        !             2: fifo_find_str(afifo, astring)
        !             3:        typed_space *afifo;
        !             4:        char *astring;
        !             5: bufinit()
        !             6: bclaim(block)
        !             7:        daddr_t block;
        !             8: bpick()
        !             9: brelease(bp)
        !            10:        BUF *bp;
        !            11: gate_lock(g)
        !            12:        GATE g;
        !            13: gate_locked(g)
        !            14:        GATE g;
        !            15: gate_unlock(g)
        !            16:        GATE g;
        !            17: sanity_check(message)
        !            18:        char *message;
        !            19: interpret(command)
        !            20:        char *command;
        !            21: dpb()
        !            22: int get_num_of_drives()
        !            23: dir()
        !            24: puts(s)
        !            25:        register char *s;
        !            26: gets(s)
        !            27:        char *s;
        !            28: reverse(s)
        !            29:        char s[];
        !            30: itoa(n, s)
        !            31:        char s[];
        !            32:        int n;
        !            33: itobase(n, s, base)
        !            34:        uint16 n;
        !            35:        char s[];
        !            36:        int base;
        !            37: basetoi(s, base)
        !            38:        char *s;
        !            39:        int base;
        !            40: seginc(offset, segment, increment)
        !            41:        uint16 *offset;
        !            42:        uint16 *segment;
        !            43:                uint16 increment;
        !            44: lpad(s, c, n)
        !            45:        char *s;
        !            46:        char c;
        !            47:        int n;
        !            48: print32(my_int)
        !            49:        uint32 my_int;
        !            50: print16(my_int)
        !            51:        uint16 my_int;
        !            52: print8(my_int)
        !            53:        uint8 my_int;
        !            54: ffcopy(to_offset, to_seg, from_offset, from_seg, length)
        !            55:        uint16 to_offset;
        !            56:        uint16 to_seg;
        !            57:        uint16 from_offset;
        !            58:        uint16 from_seg;
        !            59:        uint16 length;
        !            60: seg_align(offset, segment)
        !            61:        uint16 *offset;
        !            62:        uint16 *segment;
        !            63: wait_for_keystroke(delay, key)
        !            64:        int delay;
        !            65:        int key;
        !            66: coff2load(ip, table, data_seg)
        !            67:        struct inode *ip;               /* input: File to read.         */
        !            68:        struct load_segment table[];    /* output: How to read it.      */
        !            69:        uint16 *data_seg;       /* output: Where to point es.   */
        !            70: symName(sym, str_tab, work)
        !            71:        SYMENT *sym;
        !            72:        char *str_tab, *work;
        !            73: wrap_coffnlist(fn, symbol)
        !            74:        char *fn;       /* file name */
        !            75:        char *symbol;   /* symbol to look up */
        !            76: coffnlist(fn, nlp, names, count)
        !            77:        char *fn;       /* file name */
        !            78:        SYMENT *nlp;    /* names to look up */
        !            79:        char *names;    /* long names */
        !            80:        int count;      /* size of passed table */
        !            81: main()
        !            82: bread(blockno)
        !            83:        daddr_t blockno;        /* Block number.  */
        !            84: iopen(meminode, inode_number)
        !            85:        struct inode *meminode;
        !            86:        ino_t inode_number;
        !            87: namei(filename)
        !            88:        char *filename;
        !            89: iread(ip, buffer, offset, lenarg)
        !            90:        struct inode *ip;       /* Read from this file,         */
        !            91:        char *buffer;           /* into this buffer,            */
        !            92:        fsize_t offset;         /* from here in the file,       */
        !            93:        uint16 lenarg;  /* for this many bytes.         */
        !            94: ifread(ip, toseg, tooffset, offset, lenarg)
        !            95:        struct inode *ip;       /* Read from this file,         */
        !            96:        uint16 toseg;   /* into this far buffer,        */
        !            97:        uint16 tooffset;
        !            98:        fsize_t offset;         /* from here in the file,       */
        !            99:        fsize_t lenarg;         /* for this many bytes.         */
        !           100: xbread(blockno)
        !           101:        daddr_t blockno;        /* Block number.  */
        !           102: fdisk( fp )
        !           103:        register FDISK_S *fp;
        !           104: fifo_len(ffp)
        !           105:        FIFO *ffp;
        !           106: fifo_write(ffp, space)
        !           107:        FIFO *ffp;
        !           108:        typed_space *space;
        !           109: fifo_write_untyped(ffp, datum, size, type)
        !           110:        FIFO *ffp;
        !           111:        char *datum;
        !           112:        long size;
        !           113:        space_type type;
        !           114: fifo_read(ffp)
        !           115:        register FIFO *ffp;
        !           116: fifo_rewind(ffp)
        !           117:        FIFO *ffp;
        !           118: fifo_close(ffp)
        !           119:        FIFO *ffp;
        !           120: fifo_open(fifo_space, mode)
        !           121:        typed_space *fifo_space;
        !           122:        int mode;
        !           123: TYPED_SPACE(global_space, 128, T_FIFO_SIC);    /* Static In-Core Fifo.  */
        !           124:        
        !           125:        int
        !           126:        main()
        !           127: TYPED_SPACE(local_gift, GIFTBOX, T_FIFO_SIC); /* Static In-Core Fifo.  */
        !           128:        
        !           129:        
        !           130:        /* Prepare a gift of information for the program currently loaded.
        !           131:         *
        !           132:         * The gift is a Static In-Core FIFO whose objects are typed spaces.
        !           133:         *
        !           134:         * cmd_line is the command line needby by gift_argf().
        !           135:         *
        !           136:         * It should be placed in memory at data_seg:offset.
        !           137:         */
        !           138:        void
        !           139:        prepare_gift(data_seg, offset, cmd_line)
        !           140:        uint16 data_seg;
        !           141:        uint16 offset;
        !           142:        char *cmd_line;
        !           143: gift_drive_params(ffp)
        !           144:        FIFO *ffp;
        !           145: gift_argf(ffp, cmd_line)
        !           146:        FIFO *ffp;
        !           147:        char *cmd_line;
        !           148: gift_rootdev(ffp)
        !           149:        FIFO *ffp;
        !           150: dump_gift()
        !           151: dump_fifo(fifo)
        !           152:        typed_space *fifo;
        !           153: dump_bios_disk(a_disk)
        !           154:        BIOS_DISK *a_disk;
        !           155: dump_rootdev(a_rootdev)
        !           156:        BIOS_ROOTDEV *a_rootdev;
        !           157: vmap(ip, vblockno)
        !           158:        struct inode *ip;
        !           159:        daddr_t vblockno;
        !           160: indirect(ind_level, ind_table_ptr, vblockno)
        !           161:        uint16 ind_level;
        !           162:        daddr_t ind_table_ptr;
        !           163:        daddr_t vblockno;
        !           164: ind_lookup(ind_level, ind_table, vblockno)
        !           165:        uint16 ind_level;
        !           166:        daddr_t *ind_table;
        !           167:        daddr_t vblockno;
        !           168: ind_index(ind_level, vblockno)
        !           169:        uint16 ind_level;
        !           170:        daddr_t vblockno;
        !           171: lout2load(ip, table, data_seg)
        !           172:        struct inode *ip;               /* input: File to read.         */
        !           173:        struct load_segment table[];    /* output: How to read it.      */
        !           174:        uint16 *data_seg;       /* output: Where to point es.   */
        !           175: l_out_nlist(fn, nlp)
        !           176:        char *fn;
        !           177:        struct nlist *nlp;
        !           178: monitor()
        !           179: object2load(magic, ip, table, data_seg)
        !           180:        uint16 magic;
        !           181:        struct inode *ip;
        !           182:        struct load_segment table[];
        !           183:        uint16 *data_seg;
        !           184: object_nlist(magic, filename, symbol)
        !           185:        uint16 magic;
        !           186:        char *filename;
        !           187:        char *symbol;
        !           188: object_sys_base(magic)
        !           189:        int magic;
        !           190: main()
        !           191: open(file, type)
        !           192:        char *file;
        !           193:        int type;
        !           194: read(fd, buffer, n)
        !           195:        int fd;
        !           196:        char *buffer;
        !           197:        int n;
        !           198: close(fd)
        !           199:        int fd;
        !           200: lseek(fd, where, how)
        !           201:        int fd;
        !           202:        long where;
        !           203:        int how;
        !           204: TYPED_SPACE(boot_gift, 8192, T_FIFO_SIC);      /* Static In-Core FIFO.  */
        !           205:        
        !           206:        main()
        !           207: FIFO *fifo_open();             /* Open a typed space as a fifo.        */
        !           208:        typed_space *fifo_read();       /* Read a typed space from a fifo.      */
        !           209:        typed_space *fifo_write();      /* Write a typed space into an open fifo.  */
        !           210:        typed_space *fifo_write_untyped();  /* Write data into an open fifo.  */
        !           211:        int fifo_rewind();              /* Go back to the start of the fifo.    */
        !           212:        int fifo_close();               /* Finish with using a typed space as a fifo.  */
        !           213:        long fifo_len();                /* Find out how long a fifo is.  */
        !           214:        
        !           215:        /* USEFUL SYMBOLS.
        !           216:         * If appropriate, be sure to define a form of NULL for your new data
        !           217:         * type.  E.g. for the type COMMON
        !           218:         * #define COMMON_NULL ((COMMON *) 0)
        !           219:         *
        !           220:         * If you need any other symbols define them here.
        !           221:         */
        !           222:        
        !           223:        #define T_NULL  ((typed_space *) 0)     /* The empty typed_space.  */
        !           224:        
        !           225:        /* Useful symbols for FIFOS.  */
        !           226:        #define F_NULL  ((FIFO *) 0)    /* The void FIFO.  */
        !           227:        #define NFIFOS  20              /* Maximum of 20 fifos at a time... */
        !           228:        
        !           229:        /* Values for FIFO.f_flags.  */
        !           230:        #define F_READ  0x0001
        !           231:        #define F_WRITE 0x0002
        !           232:        
        !           233:        #endif /* ifdef TYPED_H */

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