Return to clri.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / check

Annotation of coherent/d/bin/check/clri.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Clear inodes.
                      3:  */
                      4: #include <sys/filsys.h>
                      5: #include <sys/ino.h>
                      6: #include <canon.h>
                      7: #include <stdio.h>
                      8: 
                      9: 
                     10: union {
                     11:        struct filsys   filsys_;
                     12:        struct dinode   dinode_[INOPB];
                     13: } buff;
                     14: #define        fs      buff.filsys_
                     15: #define        di      buff.dinode_
                     16: 
                     17: unsigned       isize;
                     18: 
                     19: 
                     20: main(argc, argv)
                     21: register char **argv;
                     22: {
                     23:        register fd;
                     24: 
                     25:        if (argc < 3)
                     26:                fatal("usage: clri dev ino ...");
                     27:        fd = open(*++argv, 2);
                     28:        if (fd < 0)
                     29:                fatal("can't open %s", *argv);
                     30:        lseek(fd, (long)SUPERI*BSIZE, 0);
                     31:        if (read(fd, (char *)&fs, sizeof fs) != sizeof fs)
                     32:                fatal("superblock read error");
                     33:        isize = fs.s_isize;
                     34:        canint(isize);
                     35: 
                     36:        while (*++argv)
                     37:                clri(fd, atoi(*argv));
                     38: 
                     39:        return (0);
                     40: }
                     41: 
                     42: 
                     43: clri(fd, ino)
                     44: register fd;
                     45: ino_t  ino;
                     46: {
                     47:        register bn;
                     48: 
                     49:        bn = iblockn(ino);
                     50:        if (bn >= isize)
                     51:                fatal("inode %u out of range", ino);
                     52:        lseek(fd, (long)bn*BSIZE, 0);
                     53:        if (read(fd, (char *)di, sizeof di) != sizeof di)
                     54:                fatal("read error on inode %u", ino);
                     55:        clear(&di[iblocko(ino)]);
                     56:        lseek(fd, (long)bn*BSIZE, 0);
                     57:        if (write(fd, (char *)di, sizeof di) != sizeof di)
                     58:                fatal("write error on inode %u", ino);
                     59: }
                     60: 
                     61: 
                     62: clear(dp)
                     63: struct dinode *dp;
                     64: {
                     65:        register char *p;
                     66:        register i;
                     67: 
                     68:        p = dp;
                     69:        i = sizeof *dp;
                     70:        do {
                     71:                *p++ = 0;
                     72:        } while (--i);
                     73: }
                     74: 
                     75: 
                     76: fatal(arg0)
                     77: char *arg0;
                     78: {
                     79: 
                     80:        fprintf(stderr, "clri: %r\n", &arg0);
                     81:        exit(1);
                     82: }

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