Return to pass4.c CVS log

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

Annotation of 43BSD/etc/fsck/pass4.c, revision 1.1.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[] = "@(#)pass4.c    5.3 (Berkeley) 3/5/86";
                      9: #endif not lint
                     10: 
                     11: #include <sys/param.h>
                     12: #include <sys/inode.h>
                     13: #include <sys/fs.h>
                     14: #include "fsck.h"
                     15: 
                     16: int    pass4check();
                     17: 
                     18: pass4()
                     19: {
                     20:        register ino_t inumber;
                     21:        register struct zlncnt *zlnp;
                     22:        struct inodesc idesc;
                     23:        int n;
                     24: 
                     25:        bzero((char *)&idesc, sizeof(struct inodesc));
                     26:        idesc.id_type = ADDR;
                     27:        idesc.id_func = pass4check;
                     28:        for (inumber = ROOTINO; inumber <= lastino; inumber++) {
                     29:                idesc.id_number = inumber;
                     30:                switch (statemap[inumber]) {
                     31: 
                     32:                case FSTATE:
                     33:                case DFOUND:
                     34:                        n = lncntp[inumber];
                     35:                        if (n)
                     36:                                adjust(&idesc, (short)n);
                     37:                        else {
                     38:                                for (zlnp = zlnhead; zlnp; zlnp = zlnp->next)
                     39:                                        if (zlnp->zlncnt == inumber) {
                     40:                                                zlnp->zlncnt = zlnhead->zlncnt;
                     41:                                                zlnp = zlnhead;
                     42:                                                zlnhead = zlnhead->next;
                     43:                                                free(zlnp);
                     44:                                                clri(&idesc, "UNREF", 1);
                     45:                                                break;
                     46:                                        }
                     47:                        }
                     48:                        break;
                     49: 
                     50:                case DSTATE:
                     51:                        clri(&idesc, "UNREF", 1);
                     52:                        break;
                     53: 
                     54:                case DCLEAR:
                     55:                case FCLEAR:
                     56:                        clri(&idesc, "BAD/DUP", 1);
                     57:                        break;
                     58: 
                     59:                case USTATE:
                     60:                        break;
                     61: 
                     62:                default:
                     63:                        errexit("BAD STATE %d FOR INODE I=%d",
                     64:                            statemap[inumber], inumber);
                     65:                }
                     66:        }
                     67: }
                     68: 
                     69: pass4check(idesc)
                     70:        register struct inodesc *idesc;
                     71: {
                     72:        register struct dups *dlp;
                     73:        int nfrags, res = KEEPON;
                     74:        daddr_t blkno = idesc->id_blkno;
                     75: 
                     76:        for (nfrags = idesc->id_numfrags; nfrags > 0; blkno++, nfrags--) {
                     77:                if (outrange(blkno, 1)) {
                     78:                        res = SKIP;
                     79:                } else if (getbmap(blkno)) {
                     80:                        for (dlp = duplist; dlp; dlp = dlp->next) {
                     81:                                if (dlp->dup != blkno)
                     82:                                        continue;
                     83:                                dlp->dup = duplist->dup;
                     84:                                dlp = duplist;
                     85:                                duplist = duplist->next;
                     86:                                free(dlp);
                     87:                                break;
                     88:                        }
                     89:                        if (dlp == 0) {
                     90:                                clrbmap(blkno);
                     91:                                n_blks--;
                     92:                        }
                     93:                }
                     94:        }
                     95:        return (res);
                     96: }

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