Return to df.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/df.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <sys/param.h>
                      3: #include <sys/filsys.h>
                      4: #include <sys/fblk.h>
                      5: 
                      6: daddr_t        blkno   = 1;
                      7: char   *dargv[] = {
                      8:        0,
                      9:        "/dev/rp0a",
                     10:        "/dev/rp2a",
                     11:        "/dev/rp2h",
                     12:        0
                     13: };
                     14: 
                     15: 
                     16: struct filsys sblock;
                     17: 
                     18: int    fi;
                     19: daddr_t        alloc();
                     20: 
                     21: main(argc, argv)
                     22: char **argv;
                     23: {
                     24:        int i;
                     25: 
                     26:        if(argc <= 1) {
                     27:                for(argc = 1; dargv[argc]; argc++);
                     28:                argv = dargv;
                     29:        }
                     30: 
                     31:        for(i=1; i<argc; i++) {
                     32:                dfree(argv[i]);
                     33:        }
                     34: }
                     35: 
                     36: dfree(file)
                     37: char *file;
                     38: {
                     39:        daddr_t i;
                     40: 
                     41:        fi = open(file, 0);
                     42:        if(fi < 0) {
                     43:                fprintf(stderr,"cannot open %s\n", file);
                     44:                return;
                     45:        }
                     46:        sync();
                     47:        bread(1L, (char *)&sblock, sizeof(sblock));
                     48:        i = 0;
                     49:        while(alloc())
                     50:                i++;
                     51:        printf("%s %D\n", file, i);
                     52:        close(fi);
                     53: }
                     54: 
                     55: daddr_t
                     56: alloc()
                     57: {
                     58:        int i;
                     59:        daddr_t b;
                     60:        struct fblk buf;
                     61: 
                     62:        i = --sblock.s_nfree;
                     63:        if(i<0 || i>=NICFREE) {
                     64:                printf("bad free count, b=%D\n", blkno);
                     65:                return(0);
                     66:        }
                     67:        b = sblock.s_free[i];
                     68:        if(b == 0)
                     69:                return(0);
                     70:        if(b<sblock.s_isize || b>=sblock.s_fsize) {
                     71:                printf("bad free block (%D)\n", b);
                     72:                return(0);
                     73:        }
                     74:        if(sblock.s_nfree <= 0) {
                     75:                bread(b, (char *)&buf, sizeof(buf));
                     76:                blkno = b;
                     77:                sblock.s_nfree = buf.df_nfree;
                     78:                for(i=0; i<NICFREE; i++)
                     79:                        sblock.s_free[i] = buf.df_free[i];
                     80:        }
                     81:        return(b);
                     82: }
                     83: 
                     84: bread(bno, buf, cnt)
                     85: daddr_t bno;
                     86: char *buf;
                     87: {
                     88:        int n;
                     89:        extern errno;
                     90: 
                     91:        lseek(fi, bno<<BSHIFT, 0);
                     92:        if((n=read(fi, buf, cnt)) != cnt) {
                     93:                printf("read error %D\n", bno);
                     94:                printf("count = %d; errno = %d\n", n, errno);
                     95:                exit(0);
                     96:        }
                     97: }

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