Return to clri.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / etc

Annotation of 43BSDTahoe/etc/clri.c, revision 1.1

1.1     ! root        1: static char sccsid[] = "@(#)clri.c 2.3 2/23/87";
        !             2: 
        !             3: /* static char *sccsid = "@(#)clri.c   4.1 (Berkeley) 10/1/80"; */
        !             4: 
        !             5: /*
        !             6:  * clri filsys inumber ...
        !             7:  */
        !             8: 
        !             9: #ifndef SIMFS
        !            10: #include <sys/param.h>
        !            11: #include <sys/inode.h>
        !            12: #include <sys/fs.h>
        !            13: #else
        !            14: #include "../h/param.h"
        !            15: #include "../h/inode.h"
        !            16: #include "../h/fs.h"
        !            17: #endif
        !            18: 
        !            19: #define ISIZE  (sizeof(struct dinode))
        !            20: #define        NI      (MAXBSIZE/ISIZE)
        !            21: struct ino {
        !            22:        char    junk[ISIZE];
        !            23: };
        !            24: struct ino     buf[NI];
        !            25: 
        !            26: union {
        !            27:        char            dummy[SBSIZE];
        !            28:        struct fs       sblk;
        !            29: } sb_un;
        !            30: #define sblock sb_un.sblk
        !            31: 
        !            32: int    status;
        !            33: long   dev_bsize = 1;
        !            34: 
        !            35: main(argc, argv)
        !            36:        int argc;
        !            37:        char *argv[];
        !            38: {
        !            39:        register i, f;
        !            40:        unsigned n;
        !            41:        int j, k;
        !            42:        long off;
        !            43: 
        !            44:        if (argc < 3) {
        !            45:                printf("usage: clri filsys inumber ...\n");
        !            46:                exit(4);
        !            47:        }
        !            48:        f = open(argv[1], 2);
        !            49:        if (f < 0) {
        !            50:                printf("cannot open %s\n", argv[1]);
        !            51:                exit(4);
        !            52:        }
        !            53:        lseek(f, SBOFF, 0);
        !            54:        if (read(f, &sblock, SBSIZE) != SBSIZE) {
        !            55:                printf("cannot read %s\n", argv[1]);
        !            56:                exit(4);
        !            57:        }
        !            58:        if (sblock.fs_magic != FS_MAGIC) {
        !            59:                printf("bad super block magic number\n");
        !            60:                exit(4);
        !            61:        }
        !            62:        dev_bsize = sblock.fs_fsize / fsbtodb(&sblock, 1);
        !            63:        for (i = 2; i < argc; i++) {
        !            64:                if (!isnumber(argv[i])) {
        !            65:                        printf("%s: is not a number\n", argv[i]);
        !            66:                        status = 1;
        !            67:                        continue;
        !            68:                }
        !            69:                n = atoi(argv[i]);
        !            70:                if (n == 0) {
        !            71:                        printf("%s: is zero\n", argv[i]);
        !            72:                        status = 1;
        !            73:                        continue;
        !            74:                }
        !            75:                off = fsbtodb(&sblock, itod(&sblock, n)) * dev_bsize;
        !            76:                lseek(f, off, 0);
        !            77:                if (read(f, (char *)buf, sblock.fs_bsize) != sblock.fs_bsize) {
        !            78:                        printf("%s: read error\n", argv[i]);
        !            79:                        status = 1;
        !            80:                }
        !            81:        }
        !            82:        if (status)
        !            83:                exit(status);
        !            84:        for (i = 2; i < argc; i++) {
        !            85:                n = atoi(argv[i]);
        !            86:                printf("clearing %u\n", n);
        !            87:                off = fsbtodb(&sblock, itod(&sblock, n)) * dev_bsize;
        !            88:                lseek(f, off, 0);
        !            89:                read(f, (char *)buf, sblock.fs_bsize);
        !            90:                j = itoo(&sblock, n);
        !            91:                for (k = 0; k < ISIZE; k++)
        !            92:                        buf[j].junk[k] = 0;
        !            93:                lseek(f, off, 0);
        !            94:                write(f, (char *)buf, sblock.fs_bsize);
        !            95:        }
        !            96:        exit(status);
        !            97: }
        !            98: 
        !            99: isnumber(s)
        !           100:        char *s;
        !           101: {
        !           102:        register c;
        !           103: 
        !           104:        while(c = *s++)
        !           105:                if (c < '0' || c > '9')
        !           106:                        return(0);
        !           107:        return(1);
        !           108: }

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