Return to fs.h CVS log

Up to [Research Unix] / researchv10no / cmd / chuck

Annotation of researchv10no/cmd/chuck/fs.h, revision 1.1

1.1     ! root        1: #include "sys/param.h"
        !             2: #include "sys/filsys.h"
        !             3: #include "sys/ino.h"
        !             4: #include "sys/inode.h"
        !             5: #include "sys/dir.h"
        !             6: struct filsys sblk;
        !             7: long   ninode, /* first illegal inode number */
        !             8:        fblk,   /* first legal data block number */
        !             9:        lblk,   /* first illegal data block number */
        !            10:        pblk,   /* first illegal physical block number */
        !            11:        inopb;  /* dinodes per block */
        !            12: typedef struct {       /* one per file system block */
        !            13:        char type;
        !            14:        long ino;
        !            15:        int bnum;
        !            16: } bm;
        !            17: enum bm_type {Unk, Sblock, Inode, Free, Data, Ind, Ind2, Ind3,
        !            18:                First, Other, Bits, Ioerr, Boot, Bad};
        !            19: bm *bmap;
        !            20: typedef struct {       /* one per inode */
        !            21:        unsigned char type, seen;
        !            22:        unsigned short nrefs;   /* how many dirs am i found in? */
        !            23:        long last;      /* last legal block number */
        !            24:        long dotdot;    /* .. for dirs */
        !            25:        long parent;    /* a directory i'm found in */
        !            26:        int ptr;        /* where dir entries start in dmap, after qsort */
        !            27: } im;
        !            28: enum im_type {Unalloc, Dir, Lnk, Chr, Blk, Reg, Weird};
        !            29: im *imap;
        !            30: typedef struct {
        !            31:        long dino, ino; /* directory summary */
        !            32: } dm;
        !            33: dm *dmap;
        !            34: int dmaplen;   /* in case we have to realloc */
        !            35: int dmapptr;
        !            36: char flags[128];
        !            37: char *file;    /* the name of the file system */
        !            38: int fd;                /* fd for reading it */
        !            39: int    bsize;  /* block size in file system */
        !            40: int    exitcode;
        !            41: char *freeb;   /* bit map blocks for large file systems */
        !            42: int    tfree, tinode;  /* for the super block */
        !            43: char *itype(), *btype(),*prname(), *prino();
        !            44: char mbuf[4096], xbuf[];       /* to format output messages */
        !            45: char *buf;     /* where the inode blocks get read (first 2 are extra bufs) */
        !            46: int buflen;    /* how much is allocated */
        !            47: enum e_type {Elinksize = 1, Ebadaddr, Efirst, Ebadread, Efirstio, Edirio,
        !            48:                Enotdot, Edotino, Enotdotdot, Ebadino, Ebadname, Enullable,
        !            49:                Elinkcnt, Emulti, Ebadparent, Einvalid, Esuperfree,
        !            50:                Esuperino, Efreelist, Edup, Eshort, Ehole, Etriple, Eshortdir,
        !            51:                Eattach, Efakeroot, };
        !            52: typedef struct {
        !            53:        enum e_type type;
        !            54:        long a, b;
        !            55:        char done;
        !            56: } er;
        !            57: er *erlist;
        !            58: int erptr, erlen;
        !            59: int errcnts[32];       /* at least all the e_types! */
        !            60: int blkcnts[32];
        !            61: int *iarg, *barg;      /* argument I and B */
        !            62: int ilen, iptr, blen, bptr;

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