Return to is_fs.c CVS log

Up to [MW Coherent from dump] / coherent / d / etc / fsck

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

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