Return to pass5.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sbin / fsck

Annotation of 43BSDReno/sbin/fsck/pass5.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980, 1986 The Regents of the University of California.
        !             3:  * All rights reserved.
        !             4:  *
        !             5:  * Redistribution and use in source and binary forms are permitted provided
        !             6:  * that: (1) source distributions retain this entire copyright notice and
        !             7:  * comment, and (2) distributions including binaries display the following
        !             8:  * acknowledgement:  ``This product includes software developed by the
        !             9:  * University of California, Berkeley and its contributors'' in the
        !            10:  * documentation or other materials provided with the distribution and in
        !            11:  * all advertising materials mentioning features or use of this software.
        !            12:  * Neither the name of the University nor the names of its contributors may
        !            13:  * be used to endorse or promote products derived from this software without
        !            14:  * specific prior written permission.
        !            15:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
        !            16:  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
        !            17:  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        !            18:  */
        !            19: 
        !            20: #ifndef lint
        !            21: static char sccsid[] = "@(#)pass5.c    5.13 (Berkeley) 7/20/90";
        !            22: #endif /* not lint */
        !            23: 
        !            24: #include <sys/param.h>
        !            25: #include <ufs/dinode.h>
        !            26: #include <ufs/fs.h>
        !            27: #include <string.h>
        !            28: #include "fsck.h"
        !            29: 
        !            30: pass5()
        !            31: {
        !            32:        int c, blk, frags, basesize, sumsize, mapsize, savednrpos;
        !            33:        register struct fs *fs = &sblock;
        !            34:        register struct cg *cg = &cgrp;
        !            35:        daddr_t dbase, dmax;
        !            36:        register daddr_t d;
        !            37:        register long i, j;
        !            38:        struct csum *cs;
        !            39:        time_t now;
        !            40:        struct csum cstotal;
        !            41:        struct inodesc idesc[3];
        !            42:        char buf[MAXBSIZE];
        !            43:        register struct cg *newcg = (struct cg *)buf;
        !            44:        struct ocg *ocg = (struct ocg *)buf;
        !            45: 
        !            46:        bzero((char *)newcg, (size_t)fs->fs_cgsize);
        !            47:        newcg->cg_niblk = fs->fs_ipg;
        !            48:        switch ((int)fs->fs_postblformat) {
        !            49: 
        !            50:        case FS_42POSTBLFMT:
        !            51:                basesize = (char *)(&ocg->cg_btot[0]) - (char *)(&ocg->cg_link);
        !            52:                sumsize = &ocg->cg_iused[0] - (char *)(&ocg->cg_btot[0]);
        !            53:                mapsize = &ocg->cg_free[howmany(fs->fs_fpg, NBBY)] -
        !            54:                        (u_char *)&ocg->cg_iused[0];
        !            55:                ocg->cg_magic = CG_MAGIC;
        !            56:                savednrpos = fs->fs_nrpos;
        !            57:                fs->fs_nrpos = 8;
        !            58:                break;
        !            59: 
        !            60:        case FS_DYNAMICPOSTBLFMT:
        !            61:                newcg->cg_btotoff =
        !            62:                        &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
        !            63:                newcg->cg_boff =
        !            64:                        newcg->cg_btotoff + fs->fs_cpg * sizeof(long);
        !            65:                newcg->cg_iusedoff = newcg->cg_boff + 
        !            66:                        fs->fs_cpg * fs->fs_nrpos * sizeof(short);
        !            67:                newcg->cg_freeoff =
        !            68:                        newcg->cg_iusedoff + howmany(fs->fs_ipg, NBBY);
        !            69:                newcg->cg_nextfreeoff = newcg->cg_freeoff +
        !            70:                        howmany(fs->fs_cpg * fs->fs_spc / NSPF(fs),
        !            71:                                NBBY);
        !            72:                newcg->cg_magic = CG_MAGIC;
        !            73:                basesize = &newcg->cg_space[0] - (u_char *)(&newcg->cg_link);
        !            74:                sumsize = newcg->cg_iusedoff - newcg->cg_btotoff;
        !            75:                mapsize = newcg->cg_nextfreeoff - newcg->cg_iusedoff;
        !            76:                break;
        !            77: 
        !            78:        default:
        !            79:                errexit("UNKNOWN ROTATIONAL TABLE FORMAT %d\n",
        !            80:                        fs->fs_postblformat);
        !            81:        }
        !            82:        bzero((char *)&idesc[0], sizeof idesc);
        !            83:        for (i = 0; i < 3; i++)
        !            84:                idesc[i].id_type = ADDR;
        !            85:        bzero((char *)&cstotal, sizeof(struct csum));
        !            86:        (void)time(&now);
        !            87:        j = blknum(fs, fs->fs_size + fs->fs_frag - 1);
        !            88:        for (i = fs->fs_size; i < j; i++)
        !            89:                setbmap(i);
        !            90:        for (c = 0; c < fs->fs_ncg; c++) {
        !            91:                getblk(&cgblk, cgtod(fs, c), fs->fs_cgsize);
        !            92:                if (!cg_chkmagic(cg))
        !            93:                        pfatal("CG %d: BAD MAGIC NUMBER\n", c);
        !            94:                dbase = cgbase(fs, c);
        !            95:                dmax = dbase + fs->fs_fpg;
        !            96:                if (dmax > fs->fs_size)
        !            97:                        dmax = fs->fs_size;
        !            98:                if (now > cg->cg_time)
        !            99:                        newcg->cg_time = cg->cg_time;
        !           100:                else
        !           101:                        newcg->cg_time = now;
        !           102:                newcg->cg_cgx = c;
        !           103:                if (c == fs->fs_ncg - 1)
        !           104:                        newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
        !           105:                else
        !           106:                        newcg->cg_ncyl = fs->fs_cpg;
        !           107:                newcg->cg_ndblk = dmax - dbase;
        !           108:                newcg->cg_cs.cs_ndir = 0;
        !           109:                newcg->cg_cs.cs_nffree = 0;
        !           110:                newcg->cg_cs.cs_nbfree = 0;
        !           111:                newcg->cg_cs.cs_nifree = fs->fs_ipg;
        !           112:                if (cg->cg_rotor < newcg->cg_ndblk)
        !           113:                        newcg->cg_rotor = cg->cg_rotor;
        !           114:                else
        !           115:                        newcg->cg_rotor = 0;
        !           116:                if (cg->cg_frotor < newcg->cg_ndblk)
        !           117:                        newcg->cg_frotor = cg->cg_frotor;
        !           118:                else
        !           119:                        newcg->cg_frotor = 0;
        !           120:                if (cg->cg_irotor < newcg->cg_niblk)
        !           121:                        newcg->cg_irotor = cg->cg_irotor;
        !           122:                else
        !           123:                        newcg->cg_irotor = 0;
        !           124:                bzero((char *)&newcg->cg_frsum[0], sizeof newcg->cg_frsum);
        !           125:                bzero((char *)&cg_blktot(newcg)[0],
        !           126:                      (size_t)(sumsize + mapsize));
        !           127:                if (fs->fs_postblformat == FS_42POSTBLFMT)
        !           128:                        ocg->cg_magic = CG_MAGIC;
        !           129:                j = fs->fs_ipg * c;
        !           130:                for (i = 0; i < fs->fs_ipg; j++, i++) {
        !           131:                        switch (statemap[j]) {
        !           132: 
        !           133:                        case USTATE:
        !           134:                                break;
        !           135: 
        !           136:                        case DSTATE:
        !           137:                        case DCLEAR:
        !           138:                        case DFOUND:
        !           139:                                newcg->cg_cs.cs_ndir++;
        !           140:                                /* fall through */
        !           141: 
        !           142:                        case FSTATE:
        !           143:                        case FCLEAR:
        !           144:                                newcg->cg_cs.cs_nifree--;
        !           145:                                setbit(cg_inosused(newcg), i);
        !           146:                                break;
        !           147: 
        !           148:                        default:
        !           149:                                if (j < ROOTINO)
        !           150:                                        break;
        !           151:                                errexit("BAD STATE %d FOR INODE I=%d",
        !           152:                                    statemap[j], j);
        !           153:                        }
        !           154:                }
        !           155:                if (c == 0)
        !           156:                        for (i = 0; i < ROOTINO; i++) {
        !           157:                                setbit(cg_inosused(newcg), i);
        !           158:                                newcg->cg_cs.cs_nifree--;
        !           159:                        }
        !           160:                for (i = 0, d = dbase;
        !           161:                     d < dmax;
        !           162:                     d += fs->fs_frag, i += fs->fs_frag) {
        !           163:                        frags = 0;
        !           164:                        for (j = 0; j < fs->fs_frag; j++) {
        !           165:                                if (testbmap(d + j))
        !           166:                                        continue;
        !           167:                                setbit(cg_blksfree(newcg), i + j);
        !           168:                                frags++;
        !           169:                        }
        !           170:                        if (frags == fs->fs_frag) {
        !           171:                                newcg->cg_cs.cs_nbfree++;
        !           172:                                j = cbtocylno(fs, i);
        !           173:                                cg_blktot(newcg)[j]++;
        !           174:                                cg_blks(fs, newcg, j)[cbtorpos(fs, i)]++;
        !           175:                        } else if (frags > 0) {
        !           176:                                newcg->cg_cs.cs_nffree += frags;
        !           177:                                blk = blkmap(fs, cg_blksfree(newcg), i);
        !           178:                                fragacct(fs, blk, newcg->cg_frsum, 1);
        !           179:                        }
        !           180:                }
        !           181:                cstotal.cs_nffree += newcg->cg_cs.cs_nffree;
        !           182:                cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree;
        !           183:                cstotal.cs_nifree += newcg->cg_cs.cs_nifree;
        !           184:                cstotal.cs_ndir += newcg->cg_cs.cs_ndir;
        !           185:                cs = &fs->fs_cs(fs, c);
        !           186:                if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 &&
        !           187:                    dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
        !           188:                        bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs);
        !           189:                        sbdirty();
        !           190:                }
        !           191:                if (cvtflag) {
        !           192:                        bcopy((char *)newcg, (char *)cg, (size_t)fs->fs_cgsize);
        !           193:                        cgdirty();
        !           194:                        continue;
        !           195:                }
        !           196:                if (bcmp(cg_inosused(newcg),
        !           197:                         cg_inosused(cg), mapsize) != 0 &&
        !           198:                    dofix(&idesc[1], "BLK(S) MISSING IN BIT MAPS")) {
        !           199:                        bcopy(cg_inosused(newcg), cg_inosused(cg),
        !           200:                              (size_t)mapsize);
        !           201:                        cgdirty();
        !           202:                }
        !           203:                if ((bcmp((char *)newcg, (char *)cg, basesize) != 0 ||
        !           204:                     bcmp((char *)&cg_blktot(newcg)[0],
        !           205:                          (char *)&cg_blktot(cg)[0], sumsize) != 0) &&
        !           206:                    dofix(&idesc[2], "SUMMARY INFORMATION BAD")) {
        !           207:                        bcopy((char *)newcg, (char *)cg, (size_t)basesize);
        !           208:                        bcopy((char *)&cg_blktot(newcg)[0],
        !           209:                              (char *)&cg_blktot(cg)[0], (size_t)sumsize);
        !           210:                        cgdirty();
        !           211:                }
        !           212:        }
        !           213:        if (fs->fs_postblformat == FS_42POSTBLFMT)
        !           214:                fs->fs_nrpos = savednrpos;
        !           215:        if (bcmp((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs) != 0
        !           216:            && dofix(&idesc[0], "FREE BLK COUNT(S) WRONG IN SUPERBLK")) {
        !           217:                bcopy((char *)&cstotal, (char *)&fs->fs_cstotal, sizeof *cs);
        !           218:                fs->fs_ronly = 0;
        !           219:                fs->fs_fmod = 0;
        !           220:                sbdirty();
        !           221:        }
        !           222: }

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