Return to utilities.c CVS log

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

Annotation of 43BSD/etc/fsck/utilities.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)utilities.c        5.2 (Berkeley) 9/10/85";
        !             9: #endif not lint
        !            10: 
        !            11: #include <stdio.h>
        !            12: #include <ctype.h>
        !            13: #include <sys/param.h>
        !            14: #include <sys/inode.h>
        !            15: #include <sys/fs.h>
        !            16: #include <sys/dir.h>
        !            17: #include "fsck.h"
        !            18: 
        !            19: long   lseek();
        !            20: 
        !            21: ftypeok(dp)
        !            22:        DINODE *dp;
        !            23: {
        !            24:        switch (dp->di_mode & IFMT) {
        !            25: 
        !            26:        case IFDIR:
        !            27:        case IFREG:
        !            28:        case IFBLK:
        !            29:        case IFCHR:
        !            30:        case IFLNK:
        !            31:        case IFSOCK:
        !            32:                return (1);
        !            33: 
        !            34:        default:
        !            35:                if (debug)
        !            36:                        printf("bad file type 0%o\n", dp->di_mode);
        !            37:                return (0);
        !            38:        }
        !            39: }
        !            40: 
        !            41: reply(s)
        !            42:        char *s;
        !            43: {
        !            44:        char line[80];
        !            45: 
        !            46:        if (preen)
        !            47:                pfatal("INTERNAL ERROR: GOT TO reply()");
        !            48:        printf("\n%s? ", s);
        !            49:        if (nflag || dfile.wfdes < 0) {
        !            50:                printf(" no\n\n");
        !            51:                return (0);
        !            52:        }
        !            53:        if (yflag) {
        !            54:                printf(" yes\n\n");
        !            55:                return (1);
        !            56:        }
        !            57:        if (getline(stdin, line, sizeof(line)) == EOF)
        !            58:                errexit("\n");
        !            59:        printf("\n");
        !            60:        if (line[0] == 'y' || line[0] == 'Y')
        !            61:                return (1);
        !            62:        else
        !            63:                return (0);
        !            64: }
        !            65: 
        !            66: getline(fp, loc, maxlen)
        !            67:        FILE *fp;
        !            68:        char *loc;
        !            69: {
        !            70:        register n;
        !            71:        register char *p, *lastloc;
        !            72: 
        !            73:        p = loc;
        !            74:        lastloc = &p[maxlen-1];
        !            75:        while ((n = getc(fp)) != '\n') {
        !            76:                if (n == EOF)
        !            77:                        return (EOF);
        !            78:                if (!isspace(n) && p < lastloc)
        !            79:                        *p++ = n;
        !            80:        }
        !            81:        *p = 0;
        !            82:        return (p - loc);
        !            83: }
        !            84: 
        !            85: BUFAREA *
        !            86: getblk(bp, blk, size)
        !            87:        register BUFAREA *bp;
        !            88:        daddr_t blk;
        !            89:        long size;
        !            90: {
        !            91:        register struct filecntl *fcp;
        !            92:        daddr_t dblk;
        !            93: 
        !            94:        fcp = &dfile;
        !            95:        dblk = fsbtodb(&sblock, blk);
        !            96:        if (bp->b_bno == dblk)
        !            97:                return (bp);
        !            98:        flush(fcp, bp);
        !            99:        bp->b_errs = bread(fcp, bp->b_un.b_buf, dblk, size);
        !           100:        bp->b_bno = dblk;
        !           101:        bp->b_size = size;
        !           102:        return (bp);
        !           103: }
        !           104: 
        !           105: flush(fcp, bp)
        !           106:        struct filecntl *fcp;
        !           107:        register BUFAREA *bp;
        !           108: {
        !           109:        register int i, j;
        !           110: 
        !           111:        if (!bp->b_dirty)
        !           112:                return;
        !           113:        if (bp->b_errs != 0)
        !           114:                pfatal("WRITING ZERO'ED BLOCK %d TO DISK\n", bp->b_bno);
        !           115:        bp->b_dirty = 0;
        !           116:        bp->b_errs = 0;
        !           117:        bwrite(fcp, bp->b_un.b_buf, bp->b_bno, (long)bp->b_size);
        !           118:        if (bp != &sblk)
        !           119:                return;
        !           120:        for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) {
        !           121:                bwrite(&dfile, (char *)sblock.fs_csp[j],
        !           122:                    fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag),
        !           123:                    sblock.fs_cssize - i < sblock.fs_bsize ?
        !           124:                    sblock.fs_cssize - i : sblock.fs_bsize);
        !           125:        }
        !           126: }
        !           127: 
        !           128: rwerr(s, blk)
        !           129:        char *s;
        !           130:        daddr_t blk;
        !           131: {
        !           132: 
        !           133:        if (preen == 0)
        !           134:                printf("\n");
        !           135:        pfatal("CANNOT %s: BLK %ld", s, blk);
        !           136:        if (reply("CONTINUE") == 0)
        !           137:                errexit("Program terminated\n");
        !           138: }
        !           139: 
        !           140: ckfini()
        !           141: {
        !           142: 
        !           143:        flush(&dfile, &fileblk);
        !           144:        flush(&dfile, &sblk);
        !           145:        if (sblk.b_bno != SBLOCK) {
        !           146:                sblk.b_bno = SBLOCK;
        !           147:                sbdirty();
        !           148:                flush(&dfile, &sblk);
        !           149:        }
        !           150:        flush(&dfile, &inoblk);
        !           151:        flush(&dfile, &cgblk);
        !           152:        (void)close(dfile.rfdes);
        !           153:        (void)close(dfile.wfdes);
        !           154: }
        !           155: 
        !           156: bread(fcp, buf, blk, size)
        !           157:        register struct filecntl *fcp;
        !           158:        char *buf;
        !           159:        daddr_t blk;
        !           160:        long size;
        !           161: {
        !           162:        char *cp;
        !           163:        int i, errs;
        !           164: 
        !           165:        if (lseek(fcp->rfdes, (long)dbtob(blk), 0) < 0)
        !           166:                rwerr("SEEK", blk);
        !           167:        else if (read(fcp->rfdes, buf, (int)size) == size)
        !           168:                return (0);
        !           169:        rwerr("READ", blk);
        !           170:        if (lseek(fcp->rfdes, (long)dbtob(blk), 0) < 0)
        !           171:                rwerr("SEEK", blk);
        !           172:        errs = 0;
        !           173:        pfatal("THE FOLLOWING SECTORS COULD NOT BE READ:");
        !           174:        for (cp = buf, i = 0; i < size; i += DEV_BSIZE, cp += DEV_BSIZE) {
        !           175:                if (read(fcp->rfdes, cp, DEV_BSIZE) < 0) {
        !           176:                        printf(" %d,", blk + i / DEV_BSIZE);
        !           177:                        bzero(cp, DEV_BSIZE);
        !           178:                        errs++;
        !           179:                }
        !           180:        }
        !           181:        printf("\n");
        !           182:        return (errs);
        !           183: }
        !           184: 
        !           185: bwrite(fcp, buf, blk, size)
        !           186:        register struct filecntl *fcp;
        !           187:        char *buf;
        !           188:        daddr_t blk;
        !           189:        long size;
        !           190: {
        !           191:        int i;
        !           192:        char *cp;
        !           193: 
        !           194:        if (fcp->wfdes < 0)
        !           195:                return;
        !           196:        if (lseek(fcp->wfdes, (long)dbtob(blk), 0) < 0)
        !           197:                rwerr("SEEK", blk);
        !           198:        else if (write(fcp->wfdes, buf, (int)size) == size) {
        !           199:                fcp->mod = 1;
        !           200:                return;
        !           201:        }
        !           202:        rwerr("WRITE", blk);
        !           203:        if (lseek(fcp->wfdes, (long)dbtob(blk), 0) < 0)
        !           204:                rwerr("SEEK", blk);
        !           205:        pfatal("THE FOLLOWING SECTORS COULD NOT BE WRITTEN:");
        !           206:        for (cp = buf, i = 0; i < size; i += DEV_BSIZE, cp += DEV_BSIZE)
        !           207:                if (write(fcp->wfdes, cp, DEV_BSIZE) < 0)
        !           208:                        printf(" %d,", blk + i / DEV_BSIZE);
        !           209:        printf("\n");
        !           210:        return;
        !           211: }
        !           212: 
        !           213: /*
        !           214:  * allocate a data block with the specified number of fragments
        !           215:  */
        !           216: allocblk(frags)
        !           217:        int frags;
        !           218: {
        !           219:        register int i, j, k;
        !           220: 
        !           221:        if (frags <= 0 || frags > sblock.fs_frag)
        !           222:                return (0);
        !           223:        for (i = 0; i < fmax - sblock.fs_frag; i += sblock.fs_frag) {
        !           224:                for (j = 0; j <= sblock.fs_frag - frags; j++) {
        !           225:                        if (getbmap(i + j))
        !           226:                                continue;
        !           227:                        for (k = 1; k < frags; k++)
        !           228:                                if (getbmap(i + j + k))
        !           229:                                        break;
        !           230:                        if (k < frags) {
        !           231:                                j += k;
        !           232:                                continue;
        !           233:                        }
        !           234:                        for (k = 0; k < frags; k++)
        !           235:                                setbmap(i + j + k);
        !           236:                        n_blks += frags;
        !           237:                        return (i + j);
        !           238:                }
        !           239:        }
        !           240:        return (0);
        !           241: }
        !           242: 
        !           243: /*
        !           244:  * Free a previously allocated block
        !           245:  */
        !           246: freeblk(blkno, frags)
        !           247:        daddr_t blkno;
        !           248:        int frags;
        !           249: {
        !           250:        struct inodesc idesc;
        !           251: 
        !           252:        idesc.id_blkno = blkno;
        !           253:        idesc.id_numfrags = frags;
        !           254:        pass4check(&idesc);
        !           255: }
        !           256: 
        !           257: /*
        !           258:  * Find a pathname
        !           259:  */
        !           260: getpathname(namebuf, curdir, ino)
        !           261:        char *namebuf;
        !           262:        ino_t curdir, ino;
        !           263: {
        !           264:        int len;
        !           265:        register char *cp;
        !           266:        struct inodesc idesc;
        !           267:        extern int findname();
        !           268: 
        !           269:        if (statemap[ino] != DSTATE && statemap[ino] != DFOUND) {
        !           270:                strcpy(namebuf, "?");
        !           271:                return;
        !           272:        }
        !           273:        bzero(&idesc, sizeof(struct inodesc));
        !           274:        idesc.id_type = DATA;
        !           275:        cp = &namebuf[BUFSIZ - 1];
        !           276:        *cp-- = '\0';
        !           277:        if (curdir != ino) {
        !           278:                idesc.id_parent = curdir;
        !           279:                goto namelookup;
        !           280:        }
        !           281:        while (ino != ROOTINO) {
        !           282:                idesc.id_number = ino;
        !           283:                idesc.id_func = findino;
        !           284:                idesc.id_name = "..";
        !           285:                if ((ckinode(ginode(ino), &idesc) & STOP) == 0)
        !           286:                        break;
        !           287:        namelookup:
        !           288:                idesc.id_number = idesc.id_parent;
        !           289:                idesc.id_parent = ino;
        !           290:                idesc.id_func = findname;
        !           291:                idesc.id_name = namebuf;
        !           292:                if ((ckinode(ginode(idesc.id_number), &idesc) & STOP) == 0)
        !           293:                        break;
        !           294:                len = strlen(namebuf);
        !           295:                cp -= len;
        !           296:                if (cp < &namebuf[MAXNAMLEN])
        !           297:                        break;
        !           298:                bcopy(namebuf, cp, len);
        !           299:                *--cp = '/';
        !           300:                ino = idesc.id_number;
        !           301:        }
        !           302:        if (ino != ROOTINO) {
        !           303:                strcpy(namebuf, "?");
        !           304:                return;
        !           305:        }
        !           306:        bcopy(cp, namebuf, &namebuf[BUFSIZ] - cp);
        !           307: }
        !           308: 
        !           309: catch()
        !           310: {
        !           311: 
        !           312:        ckfini();
        !           313:        exit(12);
        !           314: }
        !           315: 
        !           316: /*
        !           317:  * When preening, allow a single quit to signal
        !           318:  * a special exit after filesystem checks complete
        !           319:  * so that reboot sequence may be interrupted.
        !           320:  */
        !           321: catchquit()
        !           322: {
        !           323:        extern returntosingle;
        !           324: 
        !           325:        printf("returning to single-user after filesystem check\n");
        !           326:        returntosingle = 1;
        !           327:        (void)signal(SIGQUIT, SIG_DFL);
        !           328: }
        !           329: 
        !           330: /*
        !           331:  * Ignore a single quit signal; wait and flush just in case.
        !           332:  * Used by child processes in preen.
        !           333:  */
        !           334: voidquit()
        !           335: {
        !           336: 
        !           337:        sleep(1);
        !           338:        (void)signal(SIGQUIT, SIG_IGN);
        !           339:        (void)signal(SIGQUIT, SIG_DFL);
        !           340: }
        !           341: 
        !           342: /*
        !           343:  * determine whether an inode should be fixed.
        !           344:  */
        !           345: dofix(idesc, msg)
        !           346:        register struct inodesc *idesc;
        !           347:        char *msg;
        !           348: {
        !           349: 
        !           350:        switch (idesc->id_fix) {
        !           351: 
        !           352:        case DONTKNOW:
        !           353:                if (idesc->id_type == DATA)
        !           354:                        direrr(idesc->id_number, msg);
        !           355:                else
        !           356:                        pwarn(msg);
        !           357:                if (preen) {
        !           358:                        printf(" (SALVAGED)\n");
        !           359:                        idesc->id_fix = FIX;
        !           360:                        return (ALTERED);
        !           361:                }
        !           362:                if (reply("SALVAGE") == 0) {
        !           363:                        idesc->id_fix = NOFIX;
        !           364:                        return (0);
        !           365:                }
        !           366:                idesc->id_fix = FIX;
        !           367:                return (ALTERED);
        !           368: 
        !           369:        case FIX:
        !           370:                return (ALTERED);
        !           371: 
        !           372:        case NOFIX:
        !           373:                return (0);
        !           374: 
        !           375:        default:
        !           376:                errexit("UNKNOWN INODESC FIX MODE %d\n", idesc->id_fix);
        !           377:        }
        !           378:        /* NOTREACHED */
        !           379: }
        !           380: 
        !           381: /* VARARGS1 */
        !           382: errexit(s1, s2, s3, s4)
        !           383:        char *s1;
        !           384: {
        !           385:        printf(s1, s2, s3, s4);
        !           386:        exit(8);
        !           387: }
        !           388: 
        !           389: /*
        !           390:  * An inconsistency occured which shouldn't during normal operations.
        !           391:  * Die if preening, otherwise just printf.
        !           392:  */
        !           393: /* VARARGS1 */
        !           394: pfatal(s, a1, a2, a3)
        !           395:        char *s;
        !           396: {
        !           397: 
        !           398:        if (preen) {
        !           399:                printf("%s: ", devname);
        !           400:                printf(s, a1, a2, a3);
        !           401:                printf("\n");
        !           402:                printf("%s: UNEXPECTED INCONSISTENCY; RUN fsck MANUALLY.\n",
        !           403:                        devname);
        !           404:                exit(8);
        !           405:        }
        !           406:        printf(s, a1, a2, a3);
        !           407: }
        !           408: 
        !           409: /*
        !           410:  * Pwarn is like printf when not preening,
        !           411:  * or a warning (preceded by filename) when preening.
        !           412:  */
        !           413: /* VARARGS1 */
        !           414: pwarn(s, a1, a2, a3, a4, a5, a6)
        !           415:        char *s;
        !           416: {
        !           417: 
        !           418:        if (preen)
        !           419:                printf("%s: ", devname);
        !           420:        printf(s, a1, a2, a3, a4, a5, a6);
        !           421: }
        !           422: 
        !           423: #ifndef lint
        !           424: /*
        !           425:  * Stub for routines from kernel.
        !           426:  */
        !           427: panic(s)
        !           428:        char *s;
        !           429: {
        !           430: 
        !           431:        pfatal("INTERNAL INCONSISTENCY:");
        !           432:        errexit(s);
        !           433: }
        !           434: #endif

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