Return to dumkfs.c CVS log

Up to [XINU] / xinu / sys / LSI

Annotation of xinu/sys/LSI/dumkfs.c, revision 1.1

1.1     ! root        1: /* dumkfs.c - dumkfs, dumkdl, dumkil */
        !             2: 
        !             3: #include <conf.h>
        !             4: #include <kernel.h>
        !             5: #include <disk.h>
        !             6: #include <lfile.h>
        !             7: #include <dir.h>
        !             8: 
        !             9: /*------------------------------------------------------------------------
        !            10:  *  dumkfs  --  make a fresh file system on a disk
        !            11:  *------------------------------------------------------------------------
        !            12:  */
        !            13: dumkfs(diskdev, niblks, nblocks, diskid, verbose)
        !            14: int    diskdev;
        !            15: int    niblks;
        !            16: unsigned nblocks;
        !            17: int    diskid;
        !            18: Bool   verbose;
        !            19: {
        !            20:        DBADDR  firstdb, lastdb;
        !            21:        struct  dir     *dirptr;
        !            22: 
        !            23:        if (verbose)
        !            24:                kprintf("Clearing directory block...\n");
        !            25:        dirptr = dsdirec(diskdev);
        !            26:        firstdb = (DBADDR) (ibtodb(niblks-1) + 1);
        !            27:        lastdb = (DBADDR) (nblocks - 1);
        !            28:        dirptr->d_iblks = niblks;
        !            29:        dirptr->d_fblst = firstdb;
        !            30:        dirptr->d_filst = (IBADDR) niblks-1;
        !            31:        dirptr->d_id = diskid;
        !            32:        dirptr->d_nfiles = 0;
        !            33:        write(diskdev, dskbcpy(dirptr), DIRBLK);
        !            34:        dumkil(diskdev, niblks, verbose);
        !            35:        dumkdl(diskdev, firstdb, lastdb, verbose);      
        !            36:        if (verbose)
        !            37:                kprintf("Done initializing disk...\n");
        !            38:        return(OK);
        !            39: }
        !            40: 
        !            41: 
        !            42: /*------------------------------------------------------------------------
        !            43:  *  dumkdl  --  link all data blocks into free list to init. file system
        !            44:  *------------------------------------------------------------------------
        !            45:  */
        !            46: dumkdl(diskdev, firstfb, lastfb, verbose)
        !            47: int    diskdev;
        !            48: DBADDR firstfb, lastfb;
        !            49: Bool   verbose;
        !            50: {
        !            51:        struct  freeblk *buff;
        !            52:        DBADDR  dba;
        !            53:        char    *bptr;
        !            54:        int     i;
        !            55: 
        !            56:        if (verbose)
        !            57:                kprintf("Linking %u free blocks from %u through %u...\n",
        !            58:                        lastfb - firstfb + (DBADDR)1, firstfb, lastfb);
        !            59:        bptr = buff = (struct freeblk *) getbuf(dskdbp);
        !            60:        for (i=0 ; i<DBUFSIZ ; i++)
        !            61:                *bptr++ = '\000';
        !            62:        for (dba=firstfb ; dba < lastfb ; dba++) {
        !            63:                buff->fbnext = (DBADDR) (dba+1);
        !            64:                write(diskdev, dskbcpy(buff), dba);
        !            65:                if (verbose && (dba%500 == 0))
        !            66:                        kprintf("%5u\r",dba);
        !            67:        }
        !            68:        buff->fbnext = (DBADDR) DIRBLK;
        !            69:        write(diskdev, buff, dba);
        !            70:        if (verbose)
        !            71:                kprintf("\nDone linking data blocks...\n");
        !            72:        return(OK);
        !            73: }
        !            74: 
        !            75: 
        !            76: 
        !            77: /*------------------------------------------------------------------------
        !            78:  *  dumkil  --  link ALL i-blocks onto a free list
        !            79:  *------------------------------------------------------------------------
        !            80:  */
        !            81: dumkil(diskdev, niblks, verbose)
        !            82: int    diskdev;
        !            83: int    niblks;
        !            84: Bool   verbose;
        !            85: {
        !            86:        struct  iblk    iblock;
        !            87:        IBADDR  ibnum;
        !            88:        int     i;
        !            89: 
        !            90:        if (verbose)
        !            91:                kprintf("Linking %d i-blocks together...\n", niblks);
        !            92:        ibclear(&iblock, 0L);
        !            93:        for (ibnum=niblks-1 ; ibnum>0 ; ibnum--) {
        !            94:                iblock.ib_next = ibnum-1;
        !            95:                ibput(diskdev, ibnum, &iblock);
        !            96:        }
        !            97:        iblock.ib_next = IBNULL;
        !            98:        ibput(diskdev, 0, &iblock);
        !            99:        if (verbose)
        !           100:                kprintf("Done linking i-blocks...\n");
        !           101:        return(OK);
        !           102: }

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