Misc patches regarding corrupt rindex handling

index f0d0768..eca04a0 100644
@@ -12,7 +12,6 @@ struct osi_node {
 #define	OSI_BLACK	1
 	struct osi_node *osi_left;
 	struct osi_node *osi_right;
-	struct osi_node *osi_parent;
 };
 
 #define osi_parent(r)   ((struct osi_node *)((r)->osi_parent_color & ~3))

@@ -21,22 +20,25 @@ struct osi_node {
 #define osi_is_black(r) osi_color(r)
 #define osi_set_red(r)  do { (r)->osi_parent_color &= ~1; } while (0)
 #define osi_set_black(r)  do { (r)->osi_parent_color |= 1; } while (0)
+#define OSI_EMPTY_NODE(node) (osi_parent(node) == node)
 
 struct osi_root
 {
 	struct osi_node *osi_node;
 };
 
-static inline void osi_set_color(struct osi_node *rb, int color)
-{
-	rb->osi_parent_color = (rb->osi_parent_color & ~1) | color;
-}
+#define OSI_EMPTY_ROOT(root)  ((root)->osi_node == NULL)
 
 static inline void osi_set_parent(struct osi_node *rb, struct osi_node *p)
 {
         rb->osi_parent_color = (rb->osi_parent_color & 3) | (unsigned long)p;
 }
 
+static inline void osi_set_color(struct osi_node *rb, int color)
+{
+	rb->osi_parent_color = (rb->osi_parent_color & ~1) | color;
+}
+
 static inline void osi_link_node(struct osi_node *node,
 				 struct osi_node *parent,
 				 struct osi_node **osi_link)

@@ -245,33 +247,34 @@ static inline void osi_erase(struct osi_node *node, struct osi_root *root)
 		node = node->osi_right;
 		while ((left = node->osi_left) != NULL)
 			node = left;
+
+		if (osi_parent(old)) {
+			if (osi_parent(old)->osi_left == old)
+				osi_parent(old)->osi_left = node;
+			else
+				osi_parent(old)->osi_right = node;
+		} else
+			root->osi_node = node;
+
 		child = node->osi_right;
 		parent = osi_parent(node);
 		color = osi_color(node);
 
-		if (child)
-			osi_set_parent(child, parent);
 		if (parent == old) {
-			parent->osi_right = child;
 			parent = node;
-		} else
+		} else {
+			if (child)
+				osi_set_parent(child, parent);
 			parent->osi_left = child;
 
+			node->osi_right = old->osi_right;
+			osi_set_parent(old->osi_right, node);
+		}
+
 		node->osi_parent_color = old->osi_parent_color;
-		node->osi_right = old->osi_right;
 		node->osi_left = old->osi_left;
-
-		if (osi_parent(old)) {
-			if (osi_parent(old)->osi_left == old)
-				osi_parent(old)->osi_left = node;
-			else
-				osi_parent(old)->osi_right = node;
-		} else
-			root->osi_node = node;
-
 		osi_set_parent(old->osi_left, node);
-		if (old->osi_right)
-			osi_set_parent(old->osi_right, node);
+
 		goto color;
 	}
 

@@ -326,6 +329,9 @@ static inline struct osi_node *osi_next(struct osi_node *node)
 {
 	struct osi_node *parent;
 
+	if (OSI_EMPTY_NODE(node))
+		return NULL;
+
 	/* If we have a right-hand child, go down and then left as far
 	   as we can. */
 	if (node->osi_right) {

@@ -351,6 +357,9 @@ static inline struct osi_node *osi_prev(struct osi_node *node)
 {
 	struct osi_node *parent;
 
+	if (OSI_EMPTY_NODE(node))
+		return NULL;
+
 	/* If we have a left-hand child, go down and then right as far
 	   as we can. */
 	if (node->osi_left) {

index c20aa1f..c5671f0 100644
@@ -71,8 +71,10 @@ int gfs2_compute_bitstructs(const uint32_t bsize, struct rgrp_tree *rgd)
 
 	return 0;
 errbits:
-	if (ownbits)
+	if (ownbits) {
 		free(rgd->bits);
+		rgd->bits = NULL;
+	}
 	return -1;
 }
 

@@ -197,8 +199,10 @@ void gfs2_rgrp_relse(struct rgrp_tree *rgd)
 {
 	int x, length = rgd->ri.ri_length;
 
+	if (rgd->bits == NULL)
+		return;
 	for (x = 0; x < length; x++) {
-		if (rgd->bits[x].bi_bh) {
+		if (rgd->bits[x].bi_bh && rgd->bits[x].bi_bh->b_data) {
 			brelse(rgd->bits[x].bi_bh);
 			rgd->bits[x].bi_bh = NULL;
 		}

@@ -241,6 +245,8 @@ void gfs2_rgrp_free(struct osi_root *rgrp_tree)
 	struct osi_node *n;
 	struct gfs2_sbd *sdp = NULL;
 
+	if (OSI_EMPTY_ROOT(rgrp_tree))
+		return;
 	while ((n = osi_first(rgrp_tree))) {
 		rgd = (struct rgrp_tree *)n;
 

index 73354ff..9b26cf4 100644
@@ -169,7 +169,7 @@ int rindex_read(struct gfs2_sbd *sdp, int fd, int *count1, int *sane)
 		if (gfs2_check_range(sdp, ri.ri_addr) != 0) {
 			*sane = 0;
 			if (prev_rgd == NULL)
-				return -1;
+				continue;
 			ri.ri_addr = prev_rgd->ri.ri_addr + prev_rgd->length;
 		}
 		rgd = rgrp_insert(&sdp->rgtree, ri.ri_addr);

@@ -206,6 +206,8 @@ int rindex_read(struct gfs2_sbd *sdp, int fd, int *count1, int *sane)
 	}
 	if (prev_rgd)
 		prev_rgd->length = rgrp_size(prev_rgd);
+	if (*count1 == 0)
+		return -1;
 	return 0;
 }
 

index 5adf7c5..606bb5a 100644
@@ -1018,7 +1018,8 @@ static void read_superblock(int fd)
 static int read_rindex(void)
 {
 	struct gfs2_rindex *ri;
-	int count, sane;
+	uint64_t count;
+	int sane;
 
 	sbd.fssize = sbd.device.length;
 	if (sbd.md.riinode) /* If we found the rindex */

index 5d9afd8..9c63ec4 100644
@@ -101,7 +101,7 @@ static int openfs(const char *path, struct gfs2_sbd *sdp)
 	int fd;
 	int ret;
 	int sane;
-	int count;
+	uint64_t count;
 
 	fd = open(path, O_RDWR);
 	if (fd < 0) {

index 12d57c7..7c87884 100644
@@ -701,7 +701,8 @@ extern int build_quota_change(struct gfs2_inode *per_node, unsigned int j);
 /* super.c */
 extern int check_sb(struct gfs2_sb *sb);
 extern int read_sb(struct gfs2_sbd *sdp);
-extern int rindex_read(struct gfs2_sbd *sdp, int fd, int *count1, int *sane);
+extern int rindex_read(struct gfs2_sbd *sdp, int fd, uint64_t *count1,
+		       int *sane);
 extern int ri_update(struct gfs2_sbd *sdp, int fd, int *rgcount, int *sane);
 extern int write_sb(struct gfs2_sbd *sdp);
 

index 9b26cf4..81834b3 100644
@@ -137,7 +137,7 @@ int read_sb(struct gfs2_sbd *sdp)
  *
  * Returns: 0 on success, -1 on failure
  */
-int rindex_read(struct gfs2_sbd *sdp, int fd, int *count1, int *sane)
+int rindex_read(struct gfs2_sbd *sdp, int fd, uint64_t *count1, int *sane)
 {
 	unsigned int rg;
 	int error;

@@ -250,7 +250,7 @@ static int __ri_update(struct gfs2_sbd *sdp, int fd, int *rgcount, int *sane,
 {
 	struct rgrp_tree *rgd;
 	struct gfs2_rindex *ri;
-	int count1 = 0, count2 = 0;
+	uint64_t count1 = 0, count2 = 0;
 	uint64_t errblock = 0;
 	uint64_t rmax = 0;
 	struct osi_node *n, *next = NULL;

index 606bb5a..1fea017 100644
@@ -1025,8 +1025,10 @@ static int read_rindex(void)
 	if (sbd.md.riinode) /* If we found the rindex */
 		rindex_read(&sbd, 0, &count, &sane);
 
-	ri = &((struct rgrp_tree *)osi_last(&sbd.rgtree))->ri;
-	sbd.fssize = ri->ri_data0 + ri->ri_data;
+	if (!OSI_EMPTY_ROOT(&sbd.rgtree)) {
+		ri = &((struct rgrp_tree *)osi_last(&sbd.rgtree))->ri;
+		sbd.fssize = ri->ri_data0 + ri->ri_data;
+	}
 	return 0;
 }
 

index ce11fb4..17b2a3a 100644
@@ -812,3 +812,141 @@ int ji_update(struct gfs2_sbd *sdp)
 	}
 	return 0;
 }
+
+static void bad_journalname(const char *filename, int len)
+{
+	if (len >= 64)
+		len = 63;
+	log_debug(_("Journal index entry '%.*s' has an invalid filename.\n"),
+	          len, filename);
+}
+
+/**
+ * check_jindex_dent - check the jindex directory entries
+ *
+ * This function makes sure the directory entries of the jindex are valid.
+ * If they're not '.' or '..' they better have the form journalXXX.
+ */
+static int check_jindex_dent(struct gfs2_inode *ip, struct gfs2_dirent *dent,
+			     struct gfs2_dirent *prev_de,
+			     struct gfs2_buffer_head *bh, char *filename,
+			     uint32_t *count, int *lindex, void *priv)
+{
+	struct gfs2_dirent dentry, *de;
+	int i;
+
+	memset(&dentry, 0, sizeof(struct gfs2_dirent));
+	gfs2_dirent_in(&dentry, (char *)dent);
+	de = &dentry;
+
+	if (de->de_name_len == 1 && filename[0] == '.')
+		goto dirent_good;
+	if (de->de_name_len == 2 && filename[0] == '.' && filename[1] == '.')
+		goto dirent_good;
+
+	if ((de->de_name_len >= 11) || /* "journal9999" */
+	    (de->de_name_len <= 7) ||
+	    (strncmp(filename, "journal", 7))) {
+		bad_journalname(filename, de->de_name_len);
+		return -1;
+	}
+	for (i = 7; i < de->de_name_len; i++) {
+		if (filename[i] < '0' || filename[i] > '9') {
+			bad_journalname(filename, de->de_name_len);
+			return -2;
+		}
+	}
+
+dirent_good:
+	/* Return the number of leaf entries so metawalk doesn't flag this
+	   leaf as having none. */
+	*count = be16_to_cpu(((struct gfs2_leaf *)bh->b_data)->lf_entries);
+	return 0;
+}
+
+struct metawalk_fxns jindex_check_fxns = {
+	.private = NULL,
+	.check_dentry = check_jindex_dent,
+};
+
+/**
+ * init_jindex - read in the rindex file
+ */
+int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild)
+{
+	/*******************************************************************
+	 ******************  Fill in journal information  ******************
+	 *******************************************************************/
+
+	log_debug(_("Validating the journal index.\n"));
+	/* rgrepair requires the journals be read in in order to distinguish
+	   "real" rgrps from rgrps that are just copies left in journals. */
+	if (sdp->gfs1)
+		sdp->md.jiinode = lgfs2_inode_read(sdp, sbd1->sb_jindex_di.no_addr);
+	else
+		gfs2_lookupi(sdp->master_dir, "jindex", 6, &sdp->md.jiinode);
+
+	if (!sdp->md.jiinode) {
+		int err;
+
+		if (!allow_ji_rebuild) {
+			log_crit(_("Error: jindex and rindex files are both "
+				   "corrupt.\n"));
+			return -1;
+		}
+		if (!query( _("The gfs2 system jindex inode is missing. "
+			      "Okay to rebuild it? (y/n) "))) {
+			log_crit(_("Error: cannot proceed without a valid "
+				   "jindex file.\n"));
+			return -1;
+		}
+
+		err = build_jindex(sdp);
+		if (err) {
+			log_crit(_("Error %d rebuilding jindex\n"), err);
+			return err;
+		}
+		gfs2_lookupi(sdp->master_dir, "jindex", 6, &sdp->md.jiinode);
+	}
+
+	/* check for irrelevant entries in jindex. Can't use check_dir because
+	   that creates and destroys the inode, which we don't want. */
+	if (!sdp->gfs1) {
+		int error;
+
+		log_debug(_("Checking the integrity of the journal index.\n"));
+		if (sdp->md.jiinode->i_di.di_flags & GFS2_DIF_EXHASH)
+			error = check_leaf_blks(sdp->md.jiinode,
+						&jindex_check_fxns);
+		else
+			error = check_linear_dir(sdp->md.jiinode,
+						 sdp->md.jiinode->i_bh,
+						 &jindex_check_fxns);
+		if (error) {
+			log_err(_("The system journal index is damaged.\n"));
+			if (!query( _("Okay to rebuild it? (y/n) "))) {
+				log_crit(_("Error: cannot proceed without a "
+					   "valid jindex file.\n"));
+				return -1;
+			}
+			inode_put(&sdp->md.jiinode);
+			gfs2_dirent_del(sdp->master_dir, "jindex", 6);
+			log_err(_("Corrupt journal index was removed.\n"));
+			error = build_jindex(sdp);
+			if (error) {
+				log_err(_("Error rebuilding journal "
+					  "index: Cannot continue.\n"));
+				return error;
+			}
+			gfs2_lookupi(sdp->master_dir, "jindex", 6,
+				     &sdp->md.jiinode);
+		}
+	}
+
+	/* read in the ji data */
+	if (ji_update(sdp)){
+		log_err( _("Unable to read jindex inode.\n"));
+		return -1;
+	}
+	return 0;
+}

index 1a7aae3..d687627 100644
@@ -8,5 +8,6 @@ extern int replay_journals(struct gfs2_sbd *sdp, int preen, int force_check,
 extern int preen_is_safe(struct gfs2_sbd *sdp, int preen, int force_check);
 
 extern int ji_update(struct gfs2_sbd *sdp);
+extern int init_jindex(struct gfs2_sbd *sdp, int allow_ji_rebuild);
 #endif /* __FS_RECOVERY_H__ */
 

158 lines not on this page · raw message

index 12e474b..9ef97b8 100644
@@ -14,6 +14,7 @@
 #include "libgfs2.h"
 #include "osi_list.h"
 #include "fsck.h"
+#include "fs_recovery.h"
 
 int rindex_modified = FALSE;
 struct special_blocks false_rgrps;

@@ -41,6 +42,10 @@ struct special_blocks false_rgrps;
  * case, we don't want to mistake these blocks that look just a real RG
  * for a real RG block.  These are "fake" RGs that need to be ignored for
  * the purposes of finding where things are.
+ *
+ * NOTE: This function assumes that the jindex and journals have been read in,
+ *       which isn't often the case. Normally the rindex needs to be read in
+ *       first. If the rindex is damaged, that's not an option.
  */
 static void find_journaled_rgs(struct gfs2_sbd *sdp)
 {

@@ -62,8 +67,7 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
 				break;
 			bh = bread(sdp, dblock);
 			if (!gfs2_check_meta(bh, GFS2_METATYPE_RG)) {
-				log_debug( _("False rgrp found at block 0x%llx\n"),
-					  (unsigned long long)dblock);
+				/* False rgrp found at block dblock */
 				gfs2_special_set(&false_rgrps, dblock);
 			}
 			brelse(bh);

@@ -443,6 +447,21 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 	struct rgrp_tree *calc_rgd, *prev_rgd;
 	int number_of_rgs, rgi;
 	int rg_was_fnd = FALSE, corrupt_rgs = 0;
+	int error = -1, j;
+
+	/*
+	 * In order to continue, we need to initialize the jindex. We need
+	 * the journals in order to correctly eliminate false positives during
+	 * rgrp repair. IOW, we need to properly ignore rgrps that appear in
+	 * the journals, and we can only do that if we have the journals.
+	 * To make matters worse, journals may span several (small) rgrps,
+	 * so we can't go by the rgrps.
+	 */
+	if (init_jindex(sdp, 0) != 0) {
+		log_crit(_("Error: Can't read jindex required for rindex "
+			   "repairs.\n"));
+		return -1;
+	}
 
 	sdp->rgcalc.osi_node = NULL;
 	initial_first_rg_dist = first_rg_dist = sdp->sb_addr + 1;

@@ -466,7 +485,7 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 		calc_rgd = rgrp_insert(&sdp->rgcalc, blk);
 		if (!calc_rgd) {
 			log_crit( _("Can't allocate memory for rgrp repair.\n"));
-			return -1;
+			goto out;
 		}
 		calc_rgd->ri.ri_length = 1;
 		if (!rg_was_fnd) { /* if not an RG */

@@ -483,7 +502,7 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 				log_crit( _("Error: too many missing or "
 					    "damaged rgrps using this method. "
 					    "Time to try another method.\n"));
-				return -1;
+				goto out;
 			}
 		}
 		/* ------------------------------------------------ */

@@ -519,10 +538,10 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 		}
 		number_of_rgs++;
 		if (rg_was_fnd)
-			log_info( _("  rgrp %d at block 0x%llx intact"),
+			log_info( _("  rgrp %d at block 0x%llx intact\n"),
 				  number_of_rgs, (unsigned long long)blk);
 		else
-			log_warn( _("* rgrp %d at block 0x%llx *** DAMAGED ***"),
+			log_warn( _("* rgrp %d at block 0x%llx *** DAMAGED ***\n"),
 				  number_of_rgs, (unsigned long long)blk);
 		prev_rgd = calc_rgd;
 		/*

@@ -587,7 +606,12 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 			  calc_rgd->ri.ri_bitbytes);
         }
 	*num_rgs = number_of_rgs;
-	return 0;
+	error = 0;
+out:
+	for (j = 0; j < sdp->md.journals; j++)
+		inode_put(&sdp->md.journal[j]);
+	free(sdp->md.journal);
+	return error;
 }
 
 #define DIV_RU(x, y) (((x) + (y) - 1) / (y))

index c5671f0..766bdfc 100644
@@ -250,17 +250,19 @@ void gfs2_rgrp_free(struct osi_root *rgrp_tree)
 	while ((n = osi_first(rgrp_tree))) {
 		rgd = (struct rgrp_tree *)n;
 
-		if (rgd->bits && rgd->bits[0].bi_bh) { /* if a buffer exists */
-			rgs_since_sync++;
-			if (rgs_since_sync >= RG_SYNC_TOLERANCE) {
-				if (!sdp)
-					sdp = rgd->bits[0].bi_bh->sdp;
-				fsync(sdp->device_fd);
-				rgs_since_sync = 0;
+		if (rgd->bits) {
+			if (rgd->bits[0].bi_bh) { /* if a buffer exists */
+				rgs_since_sync++;
+				if (rgs_since_sync >= RG_SYNC_TOLERANCE) {
+					if (!sdp)
+						sdp = rgd->bits[0].bi_bh->sdp;
+					fsync(sdp->device_fd);
+					rgs_since_sync = 0;
+				}
+				gfs2_rgrp_relse(rgd); /* free them all. */
 			}
-			gfs2_rgrp_relse(rgd); /* free them all. */
+			free(rgd->bits);
 		}
-		free(rgd->bits);
 		osi_erase(&rgd->node, rgrp_tree);
 		free(rgd);
 	}

index 9ef97b8..f0759c1 100644
@@ -55,12 +55,16 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
 	uint32_t extlen;
 	struct gfs2_inode *ip;
 	struct gfs2_buffer_head *bh;
+	int false_count;
 
 	osi_list_init(&false_rgrps.list);
 	for (j = 0; j < sdp->md.journals; j++) {
-		log_debug( _("Checking for rgrps in journal%d.\n"), j);
 		ip = sdp->md.journal[j];
+		log_debug(_("Checking for rgrps in journal%d which starts "
+			    "at block 0x%llx.\n"), j,
+			  (unsigned long long)ip->i_di.di_num.no_addr);
 		jblocks = ip->i_di.di_size / sdp->sd_sb.sb_bsize;
+		false_count = 0;
 		for (b = 0; b < jblocks; b++) {
 			block_map(ip, b, &new, &dblock, &extlen, 0);
 			if (!dblock)

@@ -68,10 +72,12 @@ static void find_journaled_rgs(struct gfs2_sbd *sdp)
 			bh = bread(sdp, dblock);
 			if (!gfs2_check_meta(bh, GFS2_METATYPE_RG)) {
 				/* False rgrp found@block dblock */
+				false_count++;
 				gfs2_special_set(&false_rgrps, dblock);
 			}
 			brelse(bh);
 		}
+		log_debug("\n%d false positives identified.\n", false_count);
 	}
 }
 

index f0759c1..5bf82db 100644
@@ -171,8 +171,7 @@ static uint64_t find_shortest_rgdist(struct gfs2_sbd *sdp,
 			log_warn( _("rgrp 2 is damaged: getting dist from index: "));
 			*first_rg_dist = tmpndx.ri_addr - (sdp->sb_addr + 1);
 			log_warn("0x%llx\n", (unsigned long long)*first_rg_dist);
-		}
-		else {
+		} else {
 			log_warn( _("rgrp index 2 is damaged: extrapolating dist: "));
 			*first_rg_dist = sdp->device.length -
 				(sdp->rgrps - 1) *

@@ -500,8 +499,8 @@ static int gfs2_rindex_rebuild(struct gfs2_sbd *sdp, int *num_rgs,
 			/* ------------------------------------------------- */
 			corrupt_rgs++;
 			if (corrupt_rgs < 5)
-				log_debug( _("Missing or damaged rgrp at block "
-					  "%llu (0x%llx)\n"),
+				log_debug(_("Missing or damaged rgrp@block "
+					    "%llu (0x%llx)\n"),
 					  (unsigned long long)blk,
 					  (unsigned long long)blk);
 			else {

@@ -664,7 +663,8 @@ static uint64_t how_many_rgrps(struct gfs2_sbd *sdp, struct device *dev, int rgs
 		sdp->rgsize += GFS2_DEFAULT_RGSIZE; /* bigger rgs */
 	}
 
-	log_debug("  rg sz = %"PRIu32"\n  nrgrp = %"PRIu64"\n", sdp->rgsize, nrgrp);
+	log_debug("  rg sz = %"PRIu32"\n  nrgrp = %"PRIu64"\n", sdp->rgsize,
+		  nrgrp);
 
 	return nrgrp;
 }

@@ -728,10 +728,10 @@ static void compute_rgrp_layout(struct gfs2_sbd *sdp, struct osi_root *rgtree, i
 				(nrgrp - 1) * (dev->length / nrgrp);
 		}
 		rl->start = rgaddr;
-		printf("%d: start: %" PRIu64 " (0x%"
+		/* printf("%d: start: %" PRIu64 " (0x%"
 			 PRIx64 "), length = %"PRIu64" (0x%"
 			 PRIx64 ")\n", rgrp + 1, rl->start, rl->start,
-			 rl->length, rl->length);
+			 rl->length, rl->length);*/
 		rlast = rl;
 	}
 

@@ -909,8 +909,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 			gfs2_rgrp_free(&sdp->rgcalc);
 			return -1;
 		}
-	}
-	else if (trust_lvl == distrust) { /* If we can't trust RG index */
+	} else if (trust_lvl == distrust) { /* If we can't trust RG index */
 		/* Free previous incarnations in memory, if any. */
 		gfs2_rgrp_free(&sdp->rgtree);
 

@@ -921,8 +920,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 			return -1;
 		}
 		sdp->rgrps = calc_rg_count;
-	}
-	else if (trust_lvl == indignation) { /* If we can't trust anything */
+	} else if (trust_lvl == indignation) { /* If we can't trust anything */
 		/* Free previous incarnations in memory, if any. */
 		gfs2_rgrp_free(&sdp->rgtree);
 

index 5bf82db..6e56f91 100644
@@ -880,7 +880,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 {
 	struct osi_node *n, *next = NULL, *e, *enext;
 	int error, discrepancies, percent;
-	int calc_rg_count = 0, rgcount_from_index, rg;
+	int calc_rg_count = 0, rg;
 	struct gfs2_rindex buf;
 
 	if (trust_lvl == blind_faith)

@@ -919,7 +919,6 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 			gfs2_rgrp_free(&sdp->rgcalc);
 			return -1;
 		}
-		sdp->rgrps = calc_rg_count;
 	} else if (trust_lvl == indignation) { /* If we can't trust anything */
 		/* Free previous incarnations in memory, if any. */
 		gfs2_rgrp_free(&sdp->rgtree);

@@ -930,11 +929,10 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 			gfs2_rgrp_free(&sdp->rgcalc);
 			return -1;
 		}
-		sdp->rgrps = calc_rg_count;
 	}
 	/* Read in the rindex */
 	sdp->rgtree.osi_node = NULL; /* Just to be safe */
-	rindex_read(sdp, 0, &rgcount_from_index, sane);
+	rindex_read(sdp, 0, &sdp->rgrps, sane);
 	if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) {
 		log_warn( _("WARNING: rindex file is corrupt.\n"));
 		gfs2_rgrp_free(&sdp->rgcalc);

index 6e56f91..1fefc34 100644
@@ -934,10 +934,18 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 	sdp->rgtree.osi_node = NULL; /* Just to be safe */
 	rindex_read(sdp, 0, &sdp->rgrps, sane);
 	if (sdp->md.riinode->i_di.di_size % sizeof(struct gfs2_rindex)) {
-		log_warn( _("WARNING: rindex file is corrupt.\n"));
-		gfs2_rgrp_free(&sdp->rgcalc);
-		gfs2_rgrp_free(&sdp->rgtree);
-		return -1;
+		log_warn( _("WARNING: rindex file has an invalid size.\n"));
+		if (!query( _("Truncate the rindex size? (y/n)"))) {
+			log_err(_("The rindex was not repaired.\n"));
+			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(&sdp->rgtree);
+			return -1;
+		}
+		sdp->md.riinode->i_di.di_size /= sizeof(struct gfs2_rindex);
+		sdp->md.riinode->i_di.di_size *= sizeof(struct gfs2_rindex);
+		bmodified(sdp->md.riinode->i_bh);
+		log_err(_("Changing rindex size to %lld.\n"),
+			(unsigned long long)sdp->md.riinode->i_di.di_size);
 	}
 	log_warn( _("L%d: number of rgs expected     = %lld.\n"), trust_lvl + 1,
 		 (unsigned long long)sdp->rgrps);

index 1fefc34..e80a7af 100644
@@ -950,13 +950,34 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 	log_warn( _("L%d: number of rgs expected     = %lld.\n"), trust_lvl + 1,
 		 (unsigned long long)sdp->rgrps);
 	if (calc_rg_count != sdp->rgrps) {
+		int most_that_fit;
+
 		log_warn( _("L%d: They don't match; either (1) the fs was "
 			    "extended, (2) an odd\n"), trust_lvl + 1);
 		log_warn( _("L%d: rgrp size was used, or (3) we have a corrupt "
 			    "rg index.\n"), trust_lvl + 1);
-		gfs2_rgrp_free(&sdp->rgcalc);
-		gfs2_rgrp_free(&sdp->rgtree);
-		return -1;
+		/* If the trust level is open_minded, we would have calculated
+		   the rindex based on the device size. If it's not the same
+		   number, don't trust it. Complain about the discrepancy,
+		   then try again with a little more distrust. */
+		if ((trust_lvl < distrust) ||
+		    !query( _("Attempt to use what rgrps we can? (y/n)"))) {
+			gfs2_rgrp_free(&sdp->rgcalc);
+			gfs2_rgrp_free(&sdp->rgtree);
+			log_err(_("The rindex was not repaired.\n"));
+			return -1;
+		}
+		/* We cannot grow rindex at this point. Since pass1 has not
+		   yet run, we can't allocate blocks. Therefore we must use
+		   whatever will fix in the space given. */
+		most_that_fit = sdp->md.riinode->i_di.di_size /
+			sizeof(struct gfs2_rindex);
+		log_debug(_("The most we can fit is %d rgrps\n"),
+			  most_that_fit);
+		if (most_that_fit < calc_rg_count)
+			calc_rg_count = most_that_fit;
+		log_err(_("Attempting to fix rindex with %d rgrps.\n"),
+			calc_rg_count);
 	}
 	/* ------------------------------------------------------------- */
 	/* Now compare the rindex to what we think it should be.         */

@@ -967,7 +988,7 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 	/* ------------------------------------------------------------- */
 	discrepancies = 0;
 	for (rg = 0, n = osi_first(&sdp->rgtree), e = osi_first(&sdp->rgcalc);
-	     n && e && !fsck_abort; rg++) {
+	     n && e && !fsck_abort && rg < calc_rg_count; rg++) {
 		struct rgrp_tree *expected, *actual;
 
 		next = osi_next(n);

@@ -1016,13 +1037,15 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 			return -1;
 		}
 	}
+	log_debug("Calculated %d rgrps: Total: %d Match: %d Mismatch: %d\n",
+		  calc_rg_count, rg, rg - discrepancies, discrepancies);
 	/* ------------------------------------------------------------- */
 	/* Now compare the rindex to what we think it should be.         */
 	/* Our rindex should be pretty predictable unless we've grown    */
 	/* so look for index problems first before looking@the rgs.   */
 	/* ------------------------------------------------------------- */
 	for (rg = 0, n = osi_first(&sdp->rgtree), e = osi_first(&sdp->rgcalc);
-	     e && !fsck_abort; rg++) {
+	     e && !fsck_abort && rg < calc_rg_count; rg++) {
 		struct rgrp_tree *expected, *actual;
 
 		if (n)

@@ -1091,8 +1114,8 @@ int rg_repair(struct gfs2_sbd *sdp, int trust_lvl, int *rg_count, int *sane)
 	/* Now we can somewhat trust the rindex and the RG addresses,    */
 	/* so let's read them in, check them and optionally fix them.    */
 	/* ------------------------------------------------------------- */
-	for (rg = 0, n = osi_first(&sdp->rgtree); n && !fsck_abort;
-	     n = next, rg++) {
+	for (rg = 0, n = osi_first(&sdp->rgtree); n && !fsck_abort &&
+		     rg < calc_rg_count; n = next, rg++) {
 		struct rgrp_tree *rgd;
 		uint64_t prev_err = 0, errblock;
 		int i;

index 09ad660..84d39cd 100644
@@ -640,7 +640,7 @@ static int fetch_rgrps(struct gfs2_sbd *sdp)
 			log_notice(_("(level %d passed)\n"), trust_lvl + 1);
 			break;
 		} else {
-			if (ret < 0)
+			if (ret == -1)
 				log_err( _("(level %d failed: %s)\n"),
 					 trust_lvl + 1, fail_desc[trust_lvl]);
 			else

310 lines not on this page · raw message