Return to clri.c CVS log

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

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

1.1     ! root        1: static char sccsid[] = "@(#)clri.c 2.2 4/11/82";
        !             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: 
        !            34: main(argc, argv)
        !            35:        int argc;
        !            36:        char *argv[];
        !            37: {
        !            38:        register i, f;
        !            39:        unsigned n;
        !            40:        int j, k;
        !            41:        long off;
        !            42: 
        !            43:        if (argc < 3) {
        !            44:                printf("usage: clri filsys inumber ...\n");
        !            45:                exit(4);
        !            46:        }
        !            47:        f = open(argv[1], 2);
        !            48:        if (f < 0) {
        !            49:                printf("cannot open %s\n", argv[1]);
        !            50:                exit(4);
        !            51:        }
        !            52:        lseek(f, SBLOCK * DEV_BSIZE, 0);
        !            53:        if (read(f, &sblock, SBSIZE) != SBSIZE) {
        !            54:                printf("cannot read %s\n", argv[1]);
        !            55:                exit(4);
        !            56:        }
        !            57:        if (sblock.fs_magic != FS_MAGIC) {
        !            58:                printf("bad super block magic number\n");
        !            59:                exit(4);
        !            60:        }
        !            61:        for (i = 2; i < argc; i++) {
        !            62:                if (!isnumber(argv[i])) {
        !            63:                        printf("%s: is not a number\n", argv[i]);
        !            64:                        status = 1;
        !            65:                        continue;
        !            66:                }
        !            67:                n = atoi(argv[i]);
        !            68:                if (n == 0) {
        !            69:                        printf("%s: is zero\n", argv[i]);
        !            70:                        status = 1;
        !            71:                        continue;
        !            72:                }
        !            73:                off = fsbtodb(&sblock, itod(&sblock, n)) * DEV_BSIZE;
        !            74:                lseek(f, off, 0);
        !            75:                if (read(f, (char *)buf, sblock.fs_bsize) != sblock.fs_bsize) {
        !            76:                        printf("%s: read error\n", argv[i]);
        !            77:                        status = 1;
        !            78:                }
        !            79:        }
        !            80:        if (status)
        !            81:                exit(status);
        !            82:        for (i = 2; i < argc; i++) {
        !            83:                n = atoi(argv[i]);
        !            84:                printf("clearing %u\n", n);
        !            85:                off = fsbtodb(&sblock, itod(&sblock, n)) * DEV_BSIZE;
        !            86:                lseek(f, off, 0);
        !            87:                read(f, (char *)buf, sblock.fs_bsize);
        !            88:                j = itoo(&sblock, n);
        !            89:                for (k = 0; k < ISIZE; k++)
        !            90:                        buf[j].junk[k] = 0;
        !            91:                lseek(f, off, 0);
        !            92:                write(f, (char *)buf, sblock.fs_bsize);
        !            93:        }
        !            94:        exit(status);
        !            95: }
        !            96: 
        !            97: isnumber(s)
        !            98:        char *s;
        !            99: {
        !           100:        register c;
        !           101: 
        !           102:        while(c = *s++)
        !           103:                if (c < '0' || c > '9')
        !           104:                        return(0);
        !           105:        return(1);
        !           106: }

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