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

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

Diff for /src/sbin/fsck_lfs/setup.c between version 1.38.2.2 and 1.39

version 1.38.2.2, 2014/05/22 11:37:28 version 1.39, 2013/01/22 09:39:12
Line 71 
Line 71 
 #include <sys/disk.h>  #include <sys/disk.h>
 #include <sys/file.h>  #include <sys/file.h>
   
   #include <ufs/ufs/inode.h>
   #include <ufs/ufs/ufsmount.h>
 #define vnode uvnode  #define vnode uvnode
 #include <ufs/lfs/lfs.h>  #include <ufs/lfs/lfs.h>
 #include <ufs/lfs/lfs_inode.h>  
 #undef vnode  #undef vnode
   
 #include <ctype.h>  #include <ctype.h>
Line 97 
Line 98 
 extern u_int32_t cksum(void *, size_t);  extern u_int32_t cksum(void *, size_t);
 static uint64_t calcmaxfilesize(int);  static uint64_t calcmaxfilesize(int);
   
 ulfs_daddr_t *din_table;  ufs_daddr_t *din_table;
 SEGUSE *seg_table;  SEGUSE *seg_table;
   
 #ifdef DKTYPENAMES  #ifdef DKTYPENAMES
Line 123  calcmaxfilesize(int bshift)
Line 124  calcmaxfilesize(int bshift)
         uint64_t maxblock;          uint64_t maxblock;
   
         nptr = (1 << bshift) / sizeof(uint32_t);          nptr = (1 << bshift) / sizeof(uint32_t);
         maxblock = ULFS_NDADDR + nptr + nptr * nptr + nptr * nptr * nptr;          maxblock = UFS_NDADDR + nptr + nptr * nptr + nptr * nptr * nptr;
   
         return maxblock << bshift;          return maxblock << bshift;
 }  }
Line 238  setup(const char *dev)
Line 239  setup(const char *dev)
                 if (debug)                  if (debug)
                         pwarn("adjusting offset, serial for -i 0x%lx\n",                          pwarn("adjusting offset, serial for -i 0x%lx\n",
                                 (unsigned long)idaddr);                                  (unsigned long)idaddr);
                 tdaddr = lfs_sntod(fs, lfs_dtosn(fs, idaddr));                  tdaddr = sntod(fs, dtosn(fs, idaddr));
                 if (lfs_sntod(fs, lfs_dtosn(fs, tdaddr)) == tdaddr) {                  if (sntod(fs, dtosn(fs, tdaddr)) == tdaddr) {
                         if (tdaddr == fs->lfs_start)                          if (tdaddr == fs->lfs_start)
                                 tdaddr += lfs_btofsb(fs, LFS_LABELPAD);                                  tdaddr += btofsb(fs, LFS_LABELPAD);
                         for (i = 0; i < LFS_MAXNUMSB; i++) {                          for (i = 0; i < LFS_MAXNUMSB; i++) {
                                 if (fs->lfs_sboffs[i] == tdaddr)                                  if (fs->lfs_sboffs[i] == tdaddr)
                                         tdaddr += lfs_btofsb(fs, LFS_SBPAD);                                          tdaddr += btofsb(fs, LFS_SBPAD);
                                 if (fs->lfs_sboffs[i] > tdaddr)                                  if (fs->lfs_sboffs[i] > tdaddr)
                                         break;                                          break;
                         }                          }
Line 254  setup(const char *dev)
Line 255  setup(const char *dev)
                         pwarn("begin with offset/serial 0x%x/%d\n",                          pwarn("begin with offset/serial 0x%x/%d\n",
                                 (int)fs->lfs_offset, (int)fs->lfs_serial);                                  (int)fs->lfs_offset, (int)fs->lfs_serial);
                 while (tdaddr < idaddr) {                  while (tdaddr < idaddr) {
                         bread(fs->lfs_devvp, LFS_FSBTODB(fs, tdaddr),                          bread(fs->lfs_devvp, fsbtodb(fs, tdaddr),
                               fs->lfs_sumsize,                                fs->lfs_sumsize,
                               NULL, 0, &bp);                                NULL, 0, &bp);
                         sp = (SEGSUM *)bp->b_data;                          sp = (SEGSUM *)bp->b_data;
Line 268  setup(const char *dev)
Line 269  setup(const char *dev)
                                 break;                                  break;
                         }                          }
                         fp = (FINFO *)(sp + 1);                          fp = (FINFO *)(sp + 1);
                         bc = howmany(sp->ss_ninos, LFS_INOPB(fs)) <<                          bc = howmany(sp->ss_ninos, INOPB(fs)) <<
                                 (fs->lfs_version > 1 ? fs->lfs_ffshift :                                  (fs->lfs_version > 1 ? fs->lfs_ffshift :
                                                        fs->lfs_bshift);                                                         fs->lfs_bshift);
                         for (i = 0; i < sp->ss_nfinfo; i++) {                          for (i = 0; i < sp->ss_nfinfo; i++) {
Line 277  setup(const char *dev)
Line 278  setup(const char *dev)
                                 fp = (FINFO *)(fp->fi_blocks + fp->fi_nblocks);                                  fp = (FINFO *)(fp->fi_blocks + fp->fi_nblocks);
                         }                          }
   
                         tdaddr += lfs_btofsb(fs, bc) + 1;                          tdaddr += btofsb(fs, bc) + 1;
                         fs->lfs_offset = tdaddr;                          fs->lfs_offset = tdaddr;
                         fs->lfs_serial = sp->ss_serial + 1;                          fs->lfs_serial = sp->ss_serial + 1;
                         brelse(bp, 0);                          brelse(bp, 0);
Line 287  setup(const char *dev)
Line 288  setup(const char *dev)
                  * Set curseg, nextseg appropriately -- inlined from                   * Set curseg, nextseg appropriately -- inlined from
                  * lfs_newseg()                   * lfs_newseg()
                  */                   */
                 curseg = lfs_dtosn(fs, fs->lfs_offset);                  curseg = dtosn(fs, fs->lfs_offset);
                 fs->lfs_curseg = lfs_sntod(fs, curseg);                  fs->lfs_curseg = sntod(fs, curseg);
                 for (sn = curseg + fs->lfs_interleave;;) {                  for (sn = curseg + fs->lfs_interleave;;) {
                         sn = (sn + 1) % fs->lfs_nseg;                          sn = (sn + 1) % fs->lfs_nseg;
                         if (sn == curseg)                          if (sn == curseg)
Line 304  setup(const char *dev)
Line 305  setup(const char *dev)
                 /* Skip superblock if necessary */                  /* Skip superblock if necessary */
                 for (i = 0; i < LFS_MAXNUMSB; i++)                  for (i = 0; i < LFS_MAXNUMSB; i++)
                         if (fs->lfs_offset == fs->lfs_sboffs[i])                          if (fs->lfs_offset == fs->lfs_sboffs[i])
                                 fs->lfs_offset += lfs_btofsb(fs, LFS_SBPAD);                                  fs->lfs_offset += btofsb(fs, LFS_SBPAD);
   
                 ++fs->lfs_nactive;                  ++fs->lfs_nactive;
                 fs->lfs_nextseg = lfs_sntod(fs, sn);                  fs->lfs_nextseg = sntod(fs, sn);
                 if (debug) {                  if (debug) {
                         pwarn("offset = 0x%" PRIx32 ", serial = %" PRId64 "\n",                          pwarn("offset = 0x%" PRIx32 ", serial = %" PRId64 "\n",
                                 fs->lfs_offset, fs->lfs_serial);                                  fs->lfs_offset, fs->lfs_serial);
Line 387  setup(const char *dev)
Line 388  setup(const char *dev)
                         sbdirty();                          sbdirty();
                 }                  }
         }          }
         if (fs->lfs_maxsymlinklen != ULFS1_MAXSYMLINKLEN) {          if (fs->lfs_maxsymlinklen != UFS1_MAXSYMLINKLEN) {
                 pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK",                  pwarn("INCORRECT MAXSYMLINKLEN=%d IN SUPERBLOCK",
                     fs->lfs_maxsymlinklen);                      fs->lfs_maxsymlinklen);
                 fs->lfs_maxsymlinklen = ULFS1_MAXSYMLINKLEN;                  fs->lfs_maxsymlinklen = UFS1_MAXSYMLINKLEN;
                 if (preen)                  if (preen)
                         printf(" (FIXED)\n");                          printf(" (FIXED)\n");
                 if (preen || reply("FIX") == 1) {                  if (preen || reply("FIX") == 1) {
Line 432  setup(const char *dev)
Line 433  setup(const char *dev)
   
         /* Initialize Ifile entry */          /* Initialize Ifile entry */
         din_table[fs->lfs_ifile] = fs->lfs_idaddr;          din_table[fs->lfs_ifile] = fs->lfs_idaddr;
         seg_table[lfs_dtosn(fs, fs->lfs_idaddr)].su_nbytes += LFS_DINODE1_SIZE;          seg_table[dtosn(fs, fs->lfs_idaddr)].su_nbytes += DINODE1_SIZE;
   
 #ifndef VERBOSE_BLOCKMAP  #ifndef VERBOSE_BLOCKMAP
         bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));          bmapsize = roundup(howmany(maxfsblock, NBBY), sizeof(int16_t));

Legend:
Removed from v.1.38.2.2  
changed lines
  Added in v.1.39

CVSweb <webmaster@jp.NetBSD.org>