Return to mkfs.c CVS log

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

Annotation of researchv10no/cmd/chuck/mkfs.c, revision 1.1

1.1     ! root        1: #include "fs.h"
        !             2: 
        !             3: /* always bit-mapped.  only question is how many blocks of inodes */
        !             4: mknew()
        !             5: {      int n;
        !             6:        if(pblk < 4)
        !             7:                fatal("%d blocks is too few\n", pblk);
        !             8:        fd = open(file, 2);
        !             9:        inopb = bsize/sizeof(struct dinode);
        !            10:        fblk = (pblk-2)/(1+inopb);
        !            11:        ninode = (fblk-2)*inopb;
        !            12:        if(ninode > 65536) {    /* temporary, I hope FIX */
        !            13:                fblk = 65536/inopb + 2;
        !            14:        }
        !            15:        else if(ninode <= 0)
        !            16:                fblk = 3;
        !            17:        ninode = (fblk-2)*inopb;
        !            18:        if(fblk + BITMAP*8*sizeof(long) < pblk)
        !            19:                lblk = pblk - (pblk + 8*bsize - 1)/(8*bsize);
        !            20:        else
        !            21:                lblk = pblk;
        !            22:        pmesg("%d blocks, %d inodes, fblk %d, lblk %d (%d data blocks)\n",
        !            23:                pblk, ninode, fblk, lblk, lblk-fblk);
        !            24:        /* we could give the sucker a chance to adjust this */
        !            25:        if(qry("is this ok? (yq)\n") != 'y')
        !            26:                fatal("too bad, quitting\n");
        !            27:        n = pblk - lblk + fblk; /* inodes plus bit maps */
        !            28:        buf = (char *) malloc(bsize * n);
        !            29:        memset(buf, 0, bsize * n);
        !            30:        newsuper();
        !            31:        sblk.U.B.S_valid = 1;
        !            32:        newroot();
        !            33:        newbits();
        !            34:        writeem();
        !            35:        exit(0);
        !            36: }
        !            37: 
        !            38: newsuper()
        !            39: {      int i;
        !            40:        long *p;
        !            41:        sblk.s_isize = fblk;
        !            42:        sblk.s_fsize = pblk;
        !            43:        sblk.s_tinode = ninode - 1;
        !            44:        for(i = 0; i < NICINOD; i++) {
        !            45:                if(i+3 >= ninode)       /* maybe >? */
        !            46:                        break;
        !            47:                sblk.s_inode[i] = i+3;
        !            48:        }
        !            49:        sblk.s_ninode = i;
        !            50:        sblk.s_time = time(0);
        !            51:        sblk.s_tfree = lblk-fblk-1;
        !            52:        if(pblk > lblk)
        !            53:                return;
        !            54:        p = sblk.U.B.S_bfree;
        !            55:        for(i = 0; i < (lblk-fblk)/(8*sizeof(long)); i++)
        !            56:                p[i] = ~0;
        !            57:        /* and the (possible) last bunch */
        !            58:        for(i = i*8*sizeof(long) + fblk; i < lblk; i++)
        !            59:                setfree(p, i-fblk);
        !            60:        /* fblk is used by the root */
        !            61:        *p &= ~1;
        !            62: }
        !            63: 
        !            64: setfree(p, n)
        !            65: long *p;
        !            66: {      int j, k;
        !            67:        j = n/(8*sizeof(int));
        !            68:        k = n%(8*sizeof(int));
        !            69:        p[j] |= (1 << k);
        !            70: }
        !            71: 
        !            72: /* the root goes in inode 2, and in block fblk */
        !            73: newroot()
        !            74: {      struct dinode *p = (struct dinode *) (buf + 2*bsize);
        !            75:        struct direct *d = (struct direct *) (buf + bsize);
        !            76:        p++;    /* root is inode 2 */
        !            77:        p->di_mode = IFDIR | (~umask(0) & 0777);        /* sets umask */
        !            78:        p->di_nlink = 2;
        !            79:        p->di_uid = getuid();
        !            80:        p->di_gid = getgid();
        !            81:        p->di_size = 32;        /* temporary, I hope FIX */
        !            82:        p->di_atime = p->di_mtime = p->di_ctime = time(0);
        !            83:        ltol3(p->di_addr, &fblk, 1);
        !            84:        d->d_ino = 2;
        !            85:        strcpy(d->d_name, ".");
        !            86:        d++;
        !            87:        d->d_ino = 2;
        !            88:        strcpy(d->d_name, "..");
        !            89: }
        !            90: 
        !            91: newbits()
        !            92: {      int i;
        !            93:        long *p;
        !            94:        if(pblk <= lblk)
        !            95:                return;
        !            96:        p = (long *)(buf + fblk*bsize);
        !            97:        for(i = fblk+1; i % (8*sizeof(int)); i++)
        !            98:                setfree(p, i);
        !            99:        for(; i+8*sizeof(int) < lblk; i += 8*sizeof(int))
        !           100:                p[i/(8*sizeof(int))] = ~0;
        !           101:        for(; i < lblk; i++)
        !           102:                setfree(p, i);
        !           103: /*     sblk.U.N.S_flag = 1;    /* bit map blocks */
        !           104: /*     sblk.U.N.S_bsize = 4096*8;*/
        !           105: }
        !           106: writeem()
        !           107: {
        !           108:        fd = open(file, 2);
        !           109:        if(fd < 0)
        !           110:                fatal("can't write\n");
        !           111:        if(bwrite(pblk-1, buf, 1))
        !           112:                fatal("can't write last block (%d)\n", pblk-1);
        !           113:        if(pblk > lblk)
        !           114:                if(bwrite(lblk, buf+fblk*bsize, pblk-lblk))
        !           115:                        fatal("couldn't write bit maps\n");
        !           116:        if(bwrite(fblk, buf+bsize, 1))
        !           117:                fatal("couldn't write root dir\n");
        !           118:        if(bwrite(2, buf+2*bsize, fblk-2))
        !           119:                fatal("couldn't write inodes\n");
        !           120:        if(bwrite(1, (char *)&sblk, 1))
        !           121:                fatal("couldn't write superblock\n");
        !           122: }

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