Return to is_fs.c CVS log

Up to [MW Coherent from dump] / coherent / a / usr / src / misc

Annotation of coherent/a/usr/src/misc/is_fs.c, revision 1.1.1.1

1.1       root        1: #include <sys/stat.h>
                      2: #include <canon.h>
                      3: #include <sys/filsys.h>
                      4: 
                      5: /*
                      6:  * Check if a special file is a well-formed filesystem.
                      7:  * This routine is derived from code in "mount.c".
                      8:  * Return values:
                      9:  *     -1      Not a device, cannot open, read or seek failed
                     10:  *     0       No filesystem
                     11:  *     1       Legal filesystem
                     12:  */
                     13: int
                     14: is_fs(special) char *special;
                     15: {
                     16:        static struct filsys f;
                     17:        struct stat sbuf;
                     18:        register int fd;
                     19:        register struct filsys *fp;
                     20:        register daddr_t *dp;
                     21:        register ino_t *ip, maxinode;
                     22: 
                     23:        if (stat(special, &sbuf) < 0)
                     24:                return -1;                      /* cannot stat device */
                     25:        else if ((sbuf.st_mode&S_IFMT) != S_IFBLK
                     26:              && (sbuf.st_mode&S_IFMT) != S_IFCHR)
                     27:                return -1;                      /* not a special file */
                     28:        else if ((fd = open(special, 2)) < 0)
                     29:                return -1;                      /* cannot open */
                     30:        else if (lseek(fd, (long)SUPERI*BSIZE, 0) == -1L
                     31:              || read(fd, &f, sizeof(f)) != sizeof(f)) {
                     32:                close(fd);
                     33:                return -1;                      /* seek or read failed */
                     34:        } else
                     35:                close(fd);                      /* so far so good */
                     36: 
                     37:        /* Canonical stuff. */
                     38:        fp = &f;
                     39:        canshort(fp->s_isize);
                     40:        candaddr(fp->s_fsize);
                     41:        canshort(fp->s_nfree);
                     42:        for (dp = &fp->s_free[0]; dp < &fp->s_free[NICFREE]; dp += 1)
                     43:                candaddr(*dp);
                     44:        canshort(fp->s_ninode);
                     45:        for (ip = &fp->s_inode[0]; ip < &fp->s_inode[NICINOD]; ip += 1)
                     46:                canino(*ip);
                     47:        candaddr(fp->s_tfree);
                     48:        canino(fp->s_tinode);
                     49: 
                     50:        /* Test for rationality. */
                     51:        maxinode = (fp->s_isize - INODEI) * INOPB + 1;
                     52:        if (fp->s_isize >= fp->s_fsize)
                     53:                return 0;
                     54:        if ((fp->s_tfree < fp->s_nfree)
                     55:        ||  (fp->s_tfree >= fp->s_fsize - fp->s_isize + 1))
                     56:                return 0;
                     57:        if ((fp->s_tinode < fp->s_ninode) || (fp->s_tinode >= maxinode-1 ))
                     58:                return 0;
                     59:        for (dp = &fp->s_free[0]; dp < &fp->s_free[fp->s_nfree]; dp += 1)
                     60:                if ((*dp < fp->s_isize) || (*dp >= fp->s_fsize))
                     61:                        return 0;
                     62:        for (ip = &fp->s_inode[0]; ip < &fp->s_inode[fp->s_ninode]; ip += 1)
                     63:                if ((*ip < 1) || (*ip > maxinode))
                     64:                        return 0;
                     65:        return 1;
                     66: }

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