Return to dumkfs.c CVS log

Up to [XINU] / xinu / sys / LSI

Annotation of xinu/sys/LSI/dumkfs.c, revision 1.1.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.