[BACK]Return to setup.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sbin / fsck_ext2fs

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sbin/fsck_ext2fs/setup.c between version 1.5 and 1.6

version 1.5, 1997/09/16 08:37:04 version 1.6, 1997/10/09 13:19:40
Line 63  __RCSID("$NetBSD$");
Line 63  __RCSID("$NetBSD$");
 #include "extern.h"  #include "extern.h"
 #include "fsutil.h"  #include "fsutil.h"
   
 struct bufarea asblk;  
 #define altsblock (*asblk.b_un.b_fs)  
 #define POWEROF2(num)   (((num) & ((num) - 1)) == 0)  #define POWEROF2(num)   (((num) & ((num) - 1)) == 0)
   
 void badsb __P((int, char *));  void badsb __P((int, char *));
Line 115  setup(dev)
Line 113  setup(dev)
         lfdir = 0;          lfdir = 0;
         initbarea(&sblk);          initbarea(&sblk);
         initbarea(&asblk);          initbarea(&asblk);
         sblk.b_un.b_buf = malloc(sizeof(struct m_ext2fs));          sblk.b_un.b_buf = malloc(SBSIZE);
         asblk.b_un.b_buf = malloc(sizeof(struct m_ext2fs));          asblk.b_un.b_buf = malloc(SBSIZE);
         if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)          if (sblk.b_un.b_buf == NULL || asblk.b_un.b_buf == NULL)
                 errexit("cannot allocate space for superblock\n");                  errexit("cannot allocate space for superblock\n");
         if ((lp = getdisklabel((char *)NULL, fsreadfd)) != NULL)          if ((lp = getdisklabel((char *)NULL, fsreadfd)) != NULL)
Line 179  setup(dev)
Line 177  setup(dev)
                 if (reply("SET TO DEFAULT") == 1) {                  if (reply("SET TO DEFAULT") == 1) {
                         sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * 0.1;                          sblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_bcount * 0.1;
                         sbdirty();                          sbdirty();
                           dirty(&asblk);
                 }                  }
         }          }
         if (sblock.e2fs.e2fs_bpg != sblock.e2fs.e2fs_fpg) {          if (sblock.e2fs.e2fs_bpg != sblock.e2fs.e2fs_fpg) {
Line 187  setup(dev)
Line 186  setup(dev)
                 return 0;                  return 0;
         }          }
         if (asblk.b_dirty && !bflag) {          if (asblk.b_dirty && !bflag) {
                 memcpy(&altsblock, &sblock, (size_t)SBSIZE);                  copyback_sb(&asblk);
                 flush(fswritefd, &asblk);                  flush(fswritefd, &asblk);
         }          }
         /*          /*
Line 230  setup(dev)
Line 229  setup(dev)
                 goto badsblabel;                  goto badsblabel;
         }          }
         for (numdirs = 0, cg = 0; cg < sblock.e2fs_ncg; cg++) {          for (numdirs = 0, cg = 0; cg < sblock.e2fs_ncg; cg++) {
                 numdirs += sblock.e2fs_gd[cg].ext2bgd_ndirs;                  numdirs += fs2h16(sblock.e2fs_gd[cg].ext2bgd_ndirs);
         }          }
         inplast = 0;          inplast = 0;
         listmax = numdirs + 10;          listmax = numdirs + 10;
Line 252  badsblabel:
Line 251  badsblabel:
 }  }
   
 /*  /*
  * Read in the super block and its summary info.   * Read in the super block and its summary info, convert to host byte order.
  */   */
 static int  static int
 readsb(listerr)  readsb(listerr)
Line 260  readsb(listerr)
Line 259  readsb(listerr)
 {  {
         daddr_t super = bflag ? bflag : SBOFF / dev_bsize;          daddr_t super = bflag ? bflag : SBOFF / dev_bsize;
   
         if (bread(fsreadfd, (char *)&sblock.e2fs, super, (long)SBSIZE) != 0)          if (bread(fsreadfd, (char *)sblk.b_un.b_fs, super, (long)SBSIZE) != 0)
                 return (0);                  return (0);
         sblk.b_bno = super;          sblk.b_bno = super;
         sblk.b_size = SBSIZE;          sblk.b_size = SBSIZE;
   
           /* Copy the superblock in memory */
           sblock.e2fs.e2fs_icount = fs2h32(sblk.b_un.b_fs->e2fs_icount);
           sblock.e2fs.e2fs_bcount = fs2h32(sblk.b_un.b_fs->e2fs_bcount);
           sblock.e2fs.e2fs_rbcount = fs2h32(sblk.b_un.b_fs->e2fs_rbcount);
           sblock.e2fs.e2fs_fbcount = fs2h32(sblk.b_un.b_fs->e2fs_fbcount);
           sblock.e2fs.e2fs_ficount = fs2h32(sblk.b_un.b_fs->e2fs_ficount);
           sblock.e2fs.e2fs_first_dblock = fs2h32(sblk.b_un.b_fs->e2fs_first_dblock);
           sblock.e2fs.e2fs_log_bsize = fs2h32(sblk.b_un.b_fs->e2fs_log_bsize);
           sblock.e2fs.e2fs_fsize = fs2h32(sblk.b_un.b_fs->e2fs_fsize);
           sblock.e2fs.e2fs_bpg = fs2h32(sblk.b_un.b_fs->e2fs_bpg);
           sblock.e2fs.e2fs_fpg = fs2h32(sblk.b_un.b_fs->e2fs_fpg);
           sblock.e2fs.e2fs_ipg = fs2h32(sblk.b_un.b_fs->e2fs_ipg);
           sblock.e2fs.e2fs_mtime = fs2h32(sblk.b_un.b_fs->e2fs_mtime);
           sblock.e2fs.e2fs_wtime = fs2h32(sblk.b_un.b_fs->e2fs_wtime);
           sblock.e2fs.e2fs_lastfsck = fs2h32(sblk.b_un.b_fs->e2fs_lastfsck);
           sblock.e2fs.e2fs_fsckintv = fs2h32(sblk.b_un.b_fs->e2fs_fsckintv);
           sblock.e2fs.e2fs_creator = fs2h32(sblk.b_un.b_fs->e2fs_creator);
           sblock.e2fs.e2fs_rev = fs2h32(sblk.b_un.b_fs->e2fs_rev);
           sblock.e2fs.e2fs_mnt_count = fs2h16(sblk.b_un.b_fs->e2fs_mnt_count);
           sblock.e2fs.e2fs_max_mnt_count = fs2h16(sblk.b_un.b_fs->e2fs_max_mnt_count);
           sblock.e2fs.e2fs_magic = fs2h16(sblk.b_un.b_fs->e2fs_magic);
           sblock.e2fs.e2fs_state = fs2h16(sblk.b_un.b_fs->e2fs_state);
           sblock.e2fs.e2fs_beh = fs2h16(sblk.b_un.b_fs->e2fs_beh);
           sblock.e2fs.e2fs_ruid = fs2h16(sblk.b_un.b_fs->e2fs_ruid);
           sblock.e2fs.e2fs_rgid = fs2h16(sblk.b_un.b_fs->e2fs_rgid);
   
         /*          /*
          * run a few consistency checks of the super block           * run a few consistency checks of the super block
          */           */
Line 306  readsb(listerr)
Line 332  readsb(listerr)
         super *= dev_bsize;          super *= dev_bsize;
         dev_bsize = sblock.e2fs_bsize / fsbtodb(&sblock, 1);          dev_bsize = sblock.e2fs_bsize / fsbtodb(&sblock, 1);
         sblk.b_bno = super / dev_bsize;          sblk.b_bno = super / dev_bsize;
   
           getblk(&asblk, 1 * sblock.e2fs.e2fs_bpg + sblock.e2fs.e2fs_first_dblock,
                   (long)SBSIZE);
           if (asblk.b_errs)
                   return (0);
         if (bflag) {          if (bflag) {
                 havesb = 1;                  havesb = 1;
                 return (1);                  return (1);
Line 316  readsb(listerr)
Line 347  readsb(listerr)
          * of whole super block against an alternate super block.           * of whole super block against an alternate super block.
          * When an alternate super-block is specified this check is skipped.           * When an alternate super-block is specified this check is skipped.
          */           */
         getblk(&asblk, 1 * sblock.e2fs.e2fs_bpg + sblock.e2fs.e2fs_first_dblock,          asblk.b_un.b_fs->e2fs_rbcount = sblk.b_un.b_fs->e2fs_rbcount;
                 (long)SBSIZE);          asblk.b_un.b_fs->e2fs_fbcount = sblk.b_un.b_fs->e2fs_fbcount;
         if (asblk.b_errs)          asblk.b_un.b_fs->e2fs_ficount = sblk.b_un.b_fs->e2fs_ficount;
                 return (0);          asblk.b_un.b_fs->e2fs_mtime = sblk.b_un.b_fs->e2fs_mtime;
         altsblock.e2fs.e2fs_rbcount = sblock.e2fs.e2fs_rbcount;          asblk.b_un.b_fs->e2fs_wtime = sblk.b_un.b_fs->e2fs_wtime;
         altsblock.e2fs.e2fs_fbcount = sblock.e2fs.e2fs_fbcount;          asblk.b_un.b_fs->e2fs_mnt_count = sblk.b_un.b_fs->e2fs_mnt_count;
         altsblock.e2fs.e2fs_ficount = sblock.e2fs.e2fs_ficount;          asblk.b_un.b_fs->e2fs_max_mnt_count = sblk.b_un.b_fs->e2fs_max_mnt_count;
         altsblock.e2fs.e2fs_mtime = sblock.e2fs.e2fs_mtime;          asblk.b_un.b_fs->e2fs_state = sblk.b_un.b_fs->e2fs_state;
         altsblock.e2fs.e2fs_wtime = sblock.e2fs.e2fs_wtime;          asblk.b_un.b_fs->e2fs_beh = sblk.b_un.b_fs->e2fs_beh;
         altsblock.e2fs.e2fs_mnt_count = sblock.e2fs.e2fs_mnt_count;          asblk.b_un.b_fs->e2fs_lastfsck = sblk.b_un.b_fs->e2fs_lastfsck;
         altsblock.e2fs.e2fs_max_mnt_count = sblock.e2fs.e2fs_max_mnt_count;          asblk.b_un.b_fs->e2fs_fsckintv = sblk.b_un.b_fs->e2fs_fsckintv;
         altsblock.e2fs.e2fs_state = sblock.e2fs.e2fs_state;          asblk.b_un.b_fs->e2fs_ruid = sblk.b_un.b_fs->e2fs_ruid;
         altsblock.e2fs.e2fs_beh = sblock.e2fs.e2fs_beh;          asblk.b_un.b_fs->e2fs_rgid = sblk.b_un.b_fs->e2fs_rgid;
         altsblock.e2fs.e2fs_lastfsck = sblock.e2fs.e2fs_lastfsck;          if (memcmp(sblk.b_un.b_fs, asblk.b_un.b_fs, SBSIZE)) {
         altsblock.e2fs.e2fs_fsckintv = sblock.e2fs.e2fs_fsckintv;  
         altsblock.e2fs.e2fs_ruid = sblock.e2fs.e2fs_ruid;  
         altsblock.e2fs.e2fs_rgid = sblock.e2fs.e2fs_rgid;  
         if (memcmp(&(sblock.e2fs), &(altsblock.e2fs), (int)SBSIZE)) {  
                 if (debug) {                  if (debug) {
                         long *nlp, *olp, *endlp;                          u_int32_t *nlp, *olp, *endlp;
   
                         printf("superblock mismatches\n");                          printf("superblock mismatches\n");
                         nlp = (long *)&altsblock;                          nlp = (u_int32_t *)asblk.b_un.b_fs;
                         olp = (long *)&sblock;                          olp = (u_int32_t *)sblk.b_un.b_fs;
                         endlp = olp + (SBSIZE / sizeof *olp);                          endlp = olp + (SBSIZE / sizeof *olp);
                         for ( ; olp < endlp; olp++, nlp++) {                          for ( ; olp < endlp; olp++, nlp++) {
                                 if (*olp == *nlp)                                  if (*olp == *nlp)
                                         continue;                                          continue;
                                 printf("offset %ld, original %ld, alternate %ld\n",                                  printf("offset %ld, original %ld, alternate %ld\n",
                                         (long)(olp - (long *)&sblock), *olp, *nlp);                                          (long)(olp - (u_int32_t *)sblk.b_un.b_fs),
                                           (long)fs2h32(*olp),
                                           (long)fs2h32(*nlp));
                         }                          }
                 }                  }
                 badsb(listerr,                  badsb(listerr,
Line 357  readsb(listerr)
Line 386  readsb(listerr)
 }  }
   
 void  void
   copyback_sb(bp)
           struct bufarea *bp;
   {
           /* Copy the in-memory superblock back to buffer */
           bp->b_un.b_fs->e2fs_icount = fs2h32(sblock.e2fs.e2fs_icount);
           bp->b_un.b_fs->e2fs_bcount = fs2h32(sblock.e2fs.e2fs_bcount);
           bp->b_un.b_fs->e2fs_rbcount = fs2h32(sblock.e2fs.e2fs_rbcount);
           bp->b_un.b_fs->e2fs_fbcount = fs2h32(sblock.e2fs.e2fs_fbcount);
           bp->b_un.b_fs->e2fs_ficount = fs2h32(sblock.e2fs.e2fs_ficount);
           bp->b_un.b_fs->e2fs_first_dblock =
                                                                   fs2h32(sblock.e2fs.e2fs_first_dblock);
           bp->b_un.b_fs->e2fs_log_bsize = fs2h32(sblock.e2fs.e2fs_log_bsize);
           bp->b_un.b_fs->e2fs_fsize = fs2h32(sblock.e2fs.e2fs_fsize);
           bp->b_un.b_fs->e2fs_bpg = fs2h32(sblock.e2fs.e2fs_bpg);
           bp->b_un.b_fs->e2fs_fpg = fs2h32(sblock.e2fs.e2fs_fpg);
           bp->b_un.b_fs->e2fs_ipg = fs2h32(sblock.e2fs.e2fs_ipg);
           bp->b_un.b_fs->e2fs_mtime = fs2h32(sblock.e2fs.e2fs_mtime);
           bp->b_un.b_fs->e2fs_wtime = fs2h32(sblock.e2fs.e2fs_wtime);
           bp->b_un.b_fs->e2fs_lastfsck = fs2h32(sblock.e2fs.e2fs_lastfsck);
           bp->b_un.b_fs->e2fs_fsckintv = fs2h32(sblock.e2fs.e2fs_fsckintv);
           bp->b_un.b_fs->e2fs_creator = fs2h32(sblock.e2fs.e2fs_creator);
           bp->b_un.b_fs->e2fs_rev = fs2h32(sblock.e2fs.e2fs_rev);
           bp->b_un.b_fs->e2fs_mnt_count = fs2h16(sblock.e2fs.e2fs_mnt_count);
           bp->b_un.b_fs->e2fs_max_mnt_count =
                                                                   fs2h16(sblock.e2fs.e2fs_max_mnt_count);
           bp->b_un.b_fs->e2fs_magic = fs2h16(sblock.e2fs.e2fs_magic);
           bp->b_un.b_fs->e2fs_state = fs2h16(sblock.e2fs.e2fs_state);
           bp->b_un.b_fs->e2fs_beh = fs2h16(sblock.e2fs.e2fs_beh);
           bp->b_un.b_fs->e2fs_ruid = fs2h16(sblock.e2fs.e2fs_ruid);
           bp->b_un.b_fs->e2fs_rgid = fs2h16(sblock.e2fs.e2fs_rgid);
   }
   
   void
 badsb(listerr, s)  badsb(listerr, s)
         int listerr;          int listerr;
         char *s;          char *s;
Line 396  calcsb(dev, devfd, fs)
Line 458  calcsb(dev, devfd, fs)
                 pp = &lp->d_partitions[0];                  pp = &lp->d_partitions[0];
         else          else
                 pp = &lp->d_partitions[*cp - 'a'];                  pp = &lp->d_partitions[*cp - 'a'];
         if (pp->p_fstype != FS_BSDFFS) {          if (pp->p_fstype != FS_EX2FS) {
                 pfatal("%s: NOT LABELED AS A BSD FILE SYSTEM (%s)\n",                  pfatal("%s: NOT LABELED AS A EXT2 FILE SYSTEM (%s)\n",
                         dev, pp->p_fstype < FSMAXTYPES ?                          dev, pp->p_fstype < FSMAXTYPES ?
                         fstypenames[pp->p_fstype] : "unknown");                          fstypenames[pp->p_fstype] : "unknown");
                 return (0);                  return (0);
         }          }
         memset(fs, 0, sizeof(struct m_ext2fs));          memset(fs, 0, sizeof(struct m_ext2fs));
         fs->e2fs_bsize = 1024; /* XXX to look for altenate SP */          fs->e2fs_bsize = pp->p_fsize;
         fs->e2fs.e2fs_log_bsize = 0;          fs->e2fs.e2fs_log_bsize = pp->p_fsize / 1024;
         fs->e2fs.e2fs_bcount = (pp->p_size * DEV_BSIZE) / fs->e2fs_bsize;          fs->e2fs.e2fs_bcount = (pp->p_size * DEV_BSIZE) / fs->e2fs_bsize;
         fs->e2fs.e2fs_first_dblock = 1;          fs->e2fs.e2fs_first_dblock = (fs->e2fs.e2fs_log_bsize == 0) ? 1 : 0;
         fs->e2fs.e2fs_bpg = fs->e2fs_bsize * NBBY;          fs->e2fs.e2fs_bpg = fs->e2fs_bsize * NBBY;
         fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;          fs->e2fs_bshift = LOG_MINBSIZE + fs->e2fs.e2fs_log_bsize;
         fs->e2fs_qbmask = fs->e2fs_bsize - 1;          fs->e2fs_qbmask = fs->e2fs_bsize - 1;
Line 418  calcsb(dev, devfd, fs)
Line 480  calcsb(dev, devfd, fs)
         fs->e2fs_ngdb = howmany(fs->e2fs_ncg,          fs->e2fs_ngdb = howmany(fs->e2fs_ncg,
                 fs->e2fs_bsize / sizeof(struct ext2_gd));                  fs->e2fs_bsize / sizeof(struct ext2_gd));
   
   
   
         return (1);          return (1);
 }  }
   
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.6
CVSweb <webmaster@jp.NetBSD.org>