repair/phase2.c

   1 /*
   2  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18
  19 #include "xfs/libxfs.h"
  20 #include "xfs/libxlog.h"
  21 #include "avl.h"
  22 #include "globals.h"
  23 #include "agheader.h"
  24 #include "protos.h"
  25 #include "err_protos.h"
  26 #include "incore.h"
  27 #include "progress.h"
  28 #include "scan.h"
  29
  30 void    set_mp(xfs_mount_t *mpp);
  31
  32 /* workaround craziness in the xlog routines */
  33 int xlog_recover_do_trans(struct xlog *log, xlog_recover_t *t, int p)
  34 {
  35         return 0;
  36 }
  37
  38 static void
  39 zero_log(xfs_mount_t *mp)
  40 {
  41         int error;
  42         struct xlog     log;
  43         xfs_daddr_t head_blk, tail_blk;
  44
  45         memset(&log, 0, sizeof(log));
  46         x.logBBsize = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);
  47         x.logBBstart = XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart);
  48         x.lbsize = BBSIZE;
  49         if (xfs_sb_version_hassector(&mp->m_sb))
  50                 x.lbsize <<= (mp->m_sb.sb_logsectlog - BBSHIFT);
  51
  52         log.l_dev = mp->m_logdev_targp;
  53         log.l_logBBsize = x.logBBsize;
  54         log.l_logBBstart = x.logBBstart;
  55         log.l_sectBBsize  = BTOBB(x.lbsize);
  56         log.l_mp = mp;
  57         if (xfs_sb_version_hassector(&mp->m_sb)) {
  58                 log.l_sectbb_log = mp->m_sb.sb_logsectlog - BBSHIFT;
  59                 ASSERT(log.l_sectbb_log <= mp->m_sectbb_log);
  60                 /* for larger sector sizes, must have v2 or external log */
  61                 ASSERT(log.l_sectbb_log == 0 ||
  62                         log.l_logBBstart == 0 ||
  63                         xfs_sb_version_haslogv2(&mp->m_sb));
  64                 ASSERT(mp->m_sb.sb_logsectlog >= BBSHIFT);
  65         }
  66         log.l_sectbb_mask = (1 << log.l_sectbb_log) - 1;
  67
  68         if ((error = xlog_find_tail(&log, &head_blk, &tail_blk))) {
  69                 do_warn(_("zero_log: cannot find log head/tail "
  70                           "(xlog_find_tail=%d), zeroing it anyway\n"),
  71                         error);
  72         } else {
  73                 if (verbose) {
  74                         do_warn(
  75         _("zero_log: head block %" PRId64 " tail block %" PRId64 "\n"),
  76                                 head_blk, tail_blk);
  77                 }
  78                 if (head_blk != tail_blk) {
  79                         if (zap_log) {
  80                                 do_warn(_(
  81 "ALERT: The filesystem has valuable metadata changes in a log which is being\n"
  82 "destroyed because the -L option was used.\n"));
  83                         } else {
  84                                 do_warn(_(
  85 "ERROR: The filesystem has valuable metadata changes in a log which needs to\n"
  86 "be replayed.  Mount the filesystem to replay the log, and unmount it before\n"
  87 "re-running xfs_repair.  If you are unable to mount the filesystem, then use\n"
  88 "the -L option to destroy the log and attempt a repair.\n"
  89 "Note that destroying the log may cause corruption -- please attempt a mount\n"
  90 "of the filesystem before doing this.\n"));
  91                                 exit(2);
  92                         }
  93                 }
  94         }
  95
  96         libxfs_log_clear(log.l_dev,
  97                 XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart),
  98                 (xfs_extlen_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks),
  99                 &mp->m_sb.sb_uuid,
 100                 xfs_sb_version_haslogv2(&mp->m_sb) ? 2 : 1,
 101                 mp->m_sb.sb_logsunit, XLOG_FMT);
 102 }
 103
 104 /*
 105  * ok, at this point, the fs is mounted but the root inode may be
 106  * trashed and the ag headers haven't been checked.  So we have
 107  * a valid xfs_mount_t and superblock but that's about it.  That
 108  * means we can use macros that use mount/sb fields in calculations
 109  * but I/O or btree routines that depend on space maps or inode maps
 110  * being correct are verboten.
 111  */
 112
 113 void
 114 phase2(
 115         struct xfs_mount        *mp,
 116         int                     scan_threads)
 117 {
 118         int                     j;
 119         ino_tree_node_t         *ino_rec;
 120
 121         /* now we can start using the buffer cache routines */
 122         set_mp(mp);
 123
 124         /* Check whether this fs has internal or external log */
 125         if (mp->m_sb.sb_logstart == 0) {
 126                 if (!x.logname)
 127                         do_error(_("This filesystem has an external log.  "
 128                                    "Specify log device with the -l option.\n"));
 129
 130                 do_log(_("Phase 2 - using external log on %s\n"), x.logname);
 131         } else
 132                 do_log(_("Phase 2 - using internal log\n"));
 133
 134         /* Zero log if applicable */
 135         if (!no_modify)  {
 136                 do_log(_("        - zero log...\n"));
 137                 zero_log(mp);
 138         }
 139
 140         do_log(_("        - scan filesystem freespace and inode maps...\n"));
 141
 142         bad_ino_btree = 0;
 143
 144         set_progress_msg(PROG_FMT_SCAN_AG, (__uint64_t) glob_agcount);
 145
 146         scan_ags(mp, scan_threads);
 147
 148         print_final_rpt();
 149
 150         /*
 151          * make sure we know about the root inode chunk
 152          */
 153         if ((ino_rec = find_inode_rec(mp, 0, mp->m_sb.sb_rootino)) == NULL)  {
 154                 ASSERT(mp->m_sb.sb_rbmino == mp->m_sb.sb_rootino + 1 &&
 155                         mp->m_sb.sb_rsumino == mp->m_sb.sb_rootino + 2);
 156                 do_warn(_("root inode chunk not found\n"));
 157
 158                 /*
 159                  * mark the first 3 used, the rest are free
 160                  */
 161                 ino_rec = set_inode_used_alloc(mp, 0,
 162                                 (xfs_agino_t) mp->m_sb.sb_rootino);
 163                 set_inode_used(ino_rec, 1);
 164                 set_inode_used(ino_rec, 2);
 165
 166                 for (j = 3; j < XFS_INODES_PER_CHUNK; j++)
 167                         set_inode_free(ino_rec, j);
 168
 169                 /*
 170                  * also mark blocks
 171                  */
 172                 set_bmap_ext(0, XFS_INO_TO_AGBNO(mp, mp->m_sb.sb_rootino),
 173                              mp->m_ialloc_blks, XR_E_INO);
 174         } else  {
 175                 do_log(_("        - found root inode chunk\n"));
 176
 177                 /*
 178                  * blocks are marked, just make sure they're in use
 179                  */
 180                 if (is_inode_free(ino_rec, 0))  {
 181                         do_warn(_("root inode marked free, "));
 182                         set_inode_used(ino_rec, 0);
 183                         if (!no_modify)
 184                                 do_warn(_("correcting\n"));
 185                         else
 186                                 do_warn(_("would correct\n"));
 187                 }
 188
 189                 if (is_inode_free(ino_rec, 1))  {
 190                         do_warn(_("realtime bitmap inode marked free, "));
 191                         set_inode_used(ino_rec, 1);
 192                         if (!no_modify)
 193                                 do_warn(_("correcting\n"));
 194                         else
 195                                 do_warn(_("would correct\n"));
 196                 }
 197
 198                 if (is_inode_free(ino_rec, 2))  {
 199                         do_warn(_("realtime summary inode marked free, "));
 200                         set_inode_used(ino_rec, 2);
 201                         if (!no_modify)
 202                                 do_warn(_("correcting\n"));
 203                         else
 204                                 do_warn(_("would correct\n"));
 205                 }
 206         }
 207 }