date and time created 84/03/31 21:03:42 by mckusick

[unix-history] / usr / src / sbin / fsck / inode.c

#ifndef lint
static char version[] = "@(#)inode.c    3.1 (Berkeley) %G%";
#endif

#include <sys/param.h>
#include <sys/inode.h>
#include <sys/fs.h>
#include <sys/dir.h>
#include "fsck.h"

ckinode(dp, idesc)
       DINODE *dp;
       register struct inodesc *idesc;
{
       register daddr_t *ap;
       int ret, n, ndb, offset;
       DINODE dino;

       if (SPECIAL)
               return (KEEPON);
       dino = *dp;
       idesc->id_fix = DONTKNOW;
       idesc->id_entryno = 0;
       ndb = howmany(dino.di_size, sblock.fs_bsize);
       for (ap = &dino.di_db[0]; ap < &dino.di_db[NDADDR]; ap++) {
               if (--ndb == 0 && (offset = blkoff(&sblock, dino.di_size)) != 0)
                       idesc->id_numfrags =
                               numfrags(&sblock, fragroundup(&sblock, offset));
               else
                       idesc->id_numfrags = sblock.fs_frag;
               if (*ap == 0)
                       continue;
               idesc->id_blkno = *ap;
               if (idesc->id_type == ADDR)
                       ret = (*idesc->id_func)(idesc);
               else
                       ret = dirscan(idesc);
               if (ret & STOP)
                       return (ret);
       }
       idesc->id_numfrags = sblock.fs_frag;
       for (ap = &dino.di_ib[0], n = 1; n <= 2; ap++, n++) {
               if (*ap) {
                       idesc->id_blkno = *ap;
                       ret = iblock(idesc, n,
                               dino.di_size - sblock.fs_bsize * NDADDR);
                       if (ret & STOP)
                               return (ret);
               }
       }
       return (KEEPON);
}

iblock(idesc, ilevel, isize)
       struct inodesc *idesc;
       register ilevel;
       long isize;
{
       register daddr_t *ap;
       register daddr_t *aplim;
       int i, n, (*func)(), nif;
       BUFAREA ib;

       if (idesc->id_type == ADDR) {
               func = idesc->id_func;
               if (((n = (*func)(idesc)) & KEEPON) == 0)
                       return (n);
       } else
               func = dirscan;
       if (outrange(idesc->id_blkno, idesc->id_numfrags)) /* protect thyself */
               return (SKIP);
       initbarea(&ib);
       if (getblk(&ib, idesc->id_blkno, sblock.fs_bsize) == NULL)
               return (SKIP);
       ilevel--;
       if (ilevel == 0) {
               nif = lblkno(&sblock, isize) + 1;
       } else /* ilevel == 1 */ {
               nif = isize / (sblock.fs_bsize * NINDIR(&sblock)) + 1;
       }
       if (nif > NINDIR(&sblock))
               nif = NINDIR(&sblock);
       aplim = &ib.b_un.b_indir[nif];
       for (ap = ib.b_un.b_indir, i = 1; ap < aplim; ap++, i++)
               if (*ap) {
                       idesc->id_blkno = *ap;
                       if (ilevel > 0)
                               n = iblock(idesc, ilevel,
                                   isize - i*NINDIR(&sblock)*sblock.fs_bsize);
                       else
                               n = (*func)(idesc);
                       if (n & STOP)
                               return (n);
               }
       return (KEEPON);
}

outrange(blk, cnt)
       daddr_t blk;
       int cnt;
{
       register int c;

       if ((unsigned)(blk+cnt) > fmax)
               return (1);
       c = dtog(&sblock, blk);
       if (blk < cgdmin(&sblock, c)) {
               if ((blk+cnt) > cgsblock(&sblock, c)) {
                       if (debug) {
                               printf("blk %d < cgdmin %d;",
                                   blk, cgdmin(&sblock, c));
                               printf(" blk+cnt %d > cgsbase %d\n",
                                   blk+cnt, cgsblock(&sblock, c));
                       }
                       return (1);
               }
       } else {
               if ((blk+cnt) > cgbase(&sblock, c+1)) {
                       if (debug)  {
                               printf("blk %d >= cgdmin %d;",
                                   blk, cgdmin(&sblock, c));
                               printf(" blk+cnt %d > sblock.fs_fpg %d\n",
                                   blk+cnt, sblock.fs_fpg);
                       }
                       return (1);
               }
       }
       return (0);
}

DINODE *
ginode(inumber)
       ino_t inumber;
{
       daddr_t iblk;
       static ino_t startinum = 0;     /* blk num of first in raw area */


       if (inumber < ROOTINO || inumber > imax) {
               if (debug && inumber > imax)
                       printf("inumber out of range (%d)\n", inumber);
               return (NULL);
       }
       if (startinum == 0 ||
           inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
               iblk = itod(&sblock, inumber);
               if (getblk(&inoblk, iblk, sblock.fs_bsize) == NULL) {
                       return (NULL);
               }
               startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
       }
       return (&inoblk.b_un.b_dinode[inumber % INOPB(&sblock)]);
}

clri(idesc, s, flg)
       register struct inodesc *idesc;
       char *s;
       int flg;
{
       register DINODE *dp;

       if ((dp = ginode(idesc->id_number)) == NULL)
               return;
       if (flg == 1) {
               pwarn("%s %s", s, DIRCT?"DIR":"FILE");
               pinode(idesc->id_number);
       }
       if (preen || reply("CLEAR") == 1) {
               if (preen)
                       printf(" (CLEARED)\n");
               n_files--;
               (void)ckinode(dp, idesc);
               zapino(dp);
               statemap[idesc->id_number] = USTATE;
               inodirty();
               inosumbad++;
       }
}

findino(idesc)
       struct inodesc *idesc;
{
       register DIRECT *dirp = idesc->id_dirp;

       if (dirp->d_ino == 0)
               return (KEEPON);
       if (!strcmp(dirp->d_name, srchname)) {
               if (dirp->d_ino >= ROOTINO && dirp->d_ino <= imax)
                       idesc->id_parent = dirp->d_ino;
               return (STOP);
       }
       return (KEEPON);
}

pinode(ino)
       ino_t ino;
{
       register DINODE *dp;
       register char *p;
       char uidbuf[BUFSIZ];
       char *ctime();

       printf(" I=%u ", ino);
       if ((dp = ginode(ino)) == NULL)
               return;
       printf(" OWNER=");
       if (getpw((int)dp->di_uid, uidbuf) == 0) {
               for (p = uidbuf; *p != ':'; p++);
               *p = 0;
               printf("%s ", uidbuf);
       }
       else {
               printf("%d ", dp->di_uid);
       }
       printf("MODE=%o\n", dp->di_mode);
       if (preen)
               printf("%s: ", devname);
       printf("SIZE=%ld ", dp->di_size);
       p = ctime(&dp->di_mtime);
       printf("MTIME=%12.12s %4.4s ", p+4, p+20);
}

blkerr(ino, s, blk)
       ino_t ino;
       char *s;
       daddr_t blk;
{

       pfatal("%ld %s I=%u", blk, s, ino);
       printf("\n");
       statemap[ino] = CLEAR;
}