# 2.11BSD#431 - /usr/src/sbin/fsck/pass5.c

##### Functions

    freechk           X
    ifreechk          X
    makefree          X
    pass5             X
    pass5check        X

       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: #if !defined(lint) && defined(DOSCCS)
       8: static char sccsid[] = "@(#)pass5.c	5.2 (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: pass5()
      17: {
      18: struct  inodesc idesc;
      19:     daddr_t blkno;
      20:     int n;
      21:     BUFAREA *bp1, *bp2;
      22:     extern int debug;
      23:
      24:     bzero(&idesc, sizeof (idesc));
      25:     idesc.id_type = ADDR;
      26:
      27:     if(sflag)
      28:         fixfree = 1;
      29:     else {
      30:         ifreechk();
      31:         if(freemap)
      32:             bcopy(blockmap, freemap, (int)bmapsz);
      33:         else {
      34:             for(blkno = 0; blkno < fmapblk-bmapblk; blkno++) {
      35:                 bp1 = getblk((BUFAREA *)NULL,blkno+bmapblk);
      36:                 bp2 = getblk((BUFAREA *)NULL,blkno+fmapblk);
      37:                 bcopy(bp1->b_un.b_buf,bp2->b_un.b_buf,DEV_BSIZE);
      38:                 dirty(bp2);
      39:             }
      40:         }
      41:         badblk = dupblk = 0;
      42:         freeblk.df_nfree = sblock.fs_nfree;
      43:         for(n = 0; n < NICFREE; n++)
      44:             freeblk.df_free[n] = sblock.fs_free[n];
      45:         freechk();
      46:         if(badblk)
      47:             pfatal("%d BAD BLKS IN FREE LIST\n",badblk);
      48:         if(dupblk)
      49:             pwarn("%d DUP BLKS IN FREE LIST\n",dupblk);
      50:         if (debug)
      51:             printf("n_files %ld n_blks %ld n_free %ld fmax %ld fmin %ld ninode: %u\n",
      52:                 n_files, n_blks, n_free, fmax, fmin,sblock.fs_ninode);
      53:         if(fixfree == 0) {
      54:             if ((n_blks+n_free) != (fmax-fmin) &&
      55:                     dofix(&idesc, "BLK(S) MISSING"))
      56:                 fixfree = 1;
      57:             else if (n_free != sblock.fs_tfree &&
      58:                dofix(&idesc,"FREE BLK COUNT WRONG IN SUPERBLOCK")) {
      59:                     sblock.fs_tfree = n_free;
      60:                     sbdirty();
      61:                 }
      62:         }
      63:         if(fixfree && !dofix(&idesc, "BAD FREE LIST"))
      64:                 fixfree = 0;
      65:     }
      66:
      67:     if(fixfree) {
      68:         if (preen == 0)
      69:             printf("** Phase 6 - Salvage Free List\n");
      70:         makefree();
      71:         n_free = sblock.fs_tfree;
      72:         sblock.fs_ronly = 0;
      73:         sblock.fs_fmod = 0;
      74:         sbdirty();
      75:     }
      76: }
      77:
      78: ifreechk() {
      79:     register int i;
      80:     ino_t   inum;
      81:
      82:     for (i=0; i<sblock.fs_ninode; i++) {
      83:         inum = sblock.fs_inode[i];
      84:         switch (getstate(inum)) {
      85:
      86:         case USTATE:
      87:             continue;
      88:         default:
      89:             pwarn("ALLOCATED INODE(S) IN IFREE LIST");
      90:             if (preen)
      91:                 printf(" (FIXED)\n");
      92:             if (preen || reply("FIX") == 1) {
      93:                 sblock.fs_ninode = i-1;
      94:                 sbdirty();
      95:             }
      96:             return;
      97:         }
      98:     }
      99: }
     100:
     101: freechk()
     102: {
     103:     register daddr_t *ap;
     104:
     105:     if(freeblk.df_nfree == 0)
     106:         return;
     107:     do {
     108:         if(freeblk.df_nfree <= 0 || freeblk.df_nfree > NICFREE) {
     109:             pfatal("BAD FREEBLK COUNT");
     110:             printf("\n");
     111:             fixfree = 1;
     112:             return;
     113:         }
     114:         ap = &freeblk.df_free[freeblk.df_nfree];
     115:         while(--ap > &freeblk.df_free[0]) {
     116:             if(pass5check(*ap) == STOP)
     117:                 return;
     118:         }
     119:         if(*ap == (daddr_t)0 || pass5check(*ap) != KEEPON)
     120:             return;
     121:     } while(getblk(&fileblk,*ap) != NULL);
     122: }
     123:
     124:
     125: makefree()
     126: {
     127:     register i, cyl, step;
     128:     int j;
     129:     char flg[MAXCYL];
     130:     short addr[MAXCYL];
     131:     daddr_t blk, baseblk;
     132:
     133:     sblock.fs_nfree = 0;
     134:     sblock.fs_flock = 0;
     135:     sblock.fs_fmod = 0;
     136:     sblock.fs_tfree = 0;
     137:     sblock.fs_ninode = 0;
     138:     sblock.fs_ilock = 0;
     139:     sblock.fs_ronly = 0;
     140:     if(cylsize == 0 || stepsize == 0) {
     141:         step = sblock.fs_step;
     142:         cyl = sblock.fs_cyl;
     143:     }
     144:     else {
     145:         step = stepsize;
     146:         cyl = cylsize;
     147:     }
     148:     if(step > cyl || step <= 0 || cyl <= 0 || cyl > MAXCYL) {
     149:         printf("Default free list spacing assumed\n");
     150:         step = STEPSIZE;
     151:         cyl = CYLSIZE;
     152:     }
     153:     sblock.fs_step = step;
     154:     sblock.fs_cyl = cyl;
     155:     bzero(flg,sizeof(flg));
     156:     i = 0;
     157:     for(j = 0; j < cyl; j++) {
     158:         while(flg[i])
     159:             i = (i + 1) % cyl;
     160:         addr[j] = i + 1;
     161:         flg[i]++;
     162:         i = (i + step) % cyl;
     163:     }
     164:     baseblk = (daddr_t)roundup(fmax,cyl);
     165:     bzero((char *)&freeblk,DEV_BSIZE);
     166:     freeblk.df_nfree++;
     167:     for( ; baseblk > 0; baseblk -= cyl)
     168:         for(i = 0; i < cyl; i++) {
     169:             blk = baseblk - addr[i];
     170:             if(!outrange(blk) && !getbmap(blk)) {
     171:                 sblock.fs_tfree++;
     172:                 if(freeblk.df_nfree >= NICFREE) {
     173:                     fbdirty();
     174:                     fileblk.b_bno = blk;
     175:                     flush(&dfile,&fileblk);
     176:                     bzero((char *)&freeblk,DEV_BSIZE);
     177:                 }
     178:                 freeblk.df_free[freeblk.df_nfree] = blk;
     179:                 freeblk.df_nfree++;
     180:             }
     181:         }
     182:     sblock.fs_nfree = freeblk.df_nfree;
     183:     for(i = 0; i < NICFREE; i++)
     184:         sblock.fs_free[i] = freeblk.df_free[i];
     185:     sbdirty();
     186: }
     187:
     188: pass5check(blk)
     189: daddr_t blk;
     190: {
     191:     if(outrange(blk)) {
     192:         fixfree = 1;
     193:         if (preen)
     194:             pfatal("BAD BLOCKS IN FREE LIST.");
     195:         if(++badblk >= MAXBAD) {
     196:             printf("EXCESSIVE BAD BLKS IN FREE LIST.");
     197:             if(reply("CONTINUE") == 0)
     198:                 errexit("");
     199:             return(STOP);
     200:         }
     201:         return(SKIP);
     202:     }
     203:     if(getfmap(blk)) {
     204:         fixfree = 1;
     205:         if(++dupblk >= DUPTBLSIZE) {
     206:             printf("EXCESSIVE DUP BLKS IN FREE LIST.");
     207:             if(reply("CONTINUE") == 0)
     208:                 errexit("");
     209:             return(STOP);
     210:         }
     211:     }
     212:     else {
     213:         n_free++;
     214:         setfmap(blk);
     215:     }
     216:     return(KEEPON);
     217: }

#### Defined functions

freechk defined in line 101; used 1 times

- in line 45

ifreechk defined in line 78; used 1 times

- in line 30

makefree defined in line 125; used 1 times

- in line 70

pass5 defined in line 16; used 1 times

- in /usr/src/sbin/fsck/main.c line 227

pass5check defined in line 188; used 2 times

- in line 116-119(2)

#### Defined variables

sccsid defined in line 8; never used

Last modified: 1990-08-02 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 853 |