[PATCH 4/5] metadump: walk single fsb objects a block at a time

[Dave Chinner <david@fromorbit.com>]

From: Dave Chinner <dchinner@redhat.com>

To be able to support arbitrary discontiguous extents in multi-block
objects, we need to be able to process a single object at a time
presented as a single flat buffer. Right now we pass an arbitrary
extent and have the individal object processing functions break it
up and keep track of inter-call state.

This greatly complicates the processing of directory objects, such
that certain formats are simply not handled at all. Instead, for
single block objects loop over the extent a block at a time, feeding
a whole object to the processing function and hence making the
extent walking generic instead of per object.

At thsi point multi-block directory objects still need to use the
existing code, so duplicate the old single block object code into it
so we can fix it up properly. This means directory block processing
can't be fully cleaned up yet.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
---
 db/metadump.c | 180 ++++++++++++++++++++++++++++++++++------------------------
 1 file changed, 107 insertions(+), 73 deletions(-)

diff --git a/db/metadump.c b/db/metadump.c
index 9fc08ed..e973c5e 100644
--- a/db/metadump.c
+++ b/db/metadump.c
@@ -1257,12 +1257,11 @@ obfuscate_dir_data_blocks(
 }
 
 static void
-obfuscate_symlink_blocks(
-	char			*block,
-	xfs_dfilblks_t		count)
+obfuscate_symlink_block(
+	char			*block)
 {
-	count <<= mp->m_sb.sb_blocklog;
-	obfuscate_path_components(block, count);
+	/* XXX: need to handle CRC headers */
+	obfuscate_path_components(block, mp->m_sb.sb_blocksize);
 }
 
 #define MAX_REMOTE_VALS		4095
@@ -1283,80 +1282,79 @@ add_remote_vals(
 		blockidx++;
 		length -= XFS_LBSIZE(mp);
 	}
+
+	if (attr_data.remote_val_count >= MAX_REMOTE_VALS) {
+		print_warning(
+"Overflowed attr obfuscation array. No longer obfuscating remote attrs.");
+	}
 }
 
 static void
-obfuscate_attr_blocks(
+obfuscate_attr_block(
 	char			*block,
-	xfs_dfiloff_t		offset,
-	xfs_dfilblks_t		count)
+	xfs_dfiloff_t		offset)
 {
 	xfs_attr_leafblock_t	*leaf;
-	int			c;
 	int			i;
 	int			nentries;
 	xfs_attr_leaf_entry_t 	*entry;
 	xfs_attr_leaf_name_local_t *local;
 	xfs_attr_leaf_name_remote_t *remote;
 
-	for (c = 0; c < count; c++, offset++, block += XFS_LBSIZE(mp)) {
+	leaf = (xfs_attr_leafblock_t *)block;
 
-		leaf = (xfs_attr_leafblock_t *)block;
-
-		if (be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR_LEAF_MAGIC) {
-			for (i = 0; i < attr_data.remote_val_count; i++) {
-				if (attr_data.remote_vals[i] == offset)
-					memset(block, 0, XFS_LBSIZE(mp));
-			}
-			continue;
+	if (be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR_LEAF_MAGIC) {
+		for (i = 0; i < attr_data.remote_val_count; i++) {
+			/* XXX: need to handle CRC headers */
+			if (attr_data.remote_vals[i] == offset)
+				memset(block, 0, XFS_LBSIZE(mp));
 		}
+		return;
+	}
+
+	nentries = be16_to_cpu(leaf->hdr.count);
+	if (nentries * sizeof(xfs_attr_leaf_entry_t) +
+			sizeof(xfs_attr_leaf_hdr_t) > XFS_LBSIZE(mp)) {
+		if (show_warnings)
+			print_warning("invalid attr count in inode %llu",
+					(long long)cur_ino);
+		return;
+	}
 
-		nentries = be16_to_cpu(leaf->hdr.count);
-		if (nentries * sizeof(xfs_attr_leaf_entry_t) +
-				sizeof(xfs_attr_leaf_hdr_t) > XFS_LBSIZE(mp)) {
+	for (i = 0, entry = &leaf->entries[0]; i < nentries; i++, entry++) {
+		if (be16_to_cpu(entry->nameidx) > XFS_LBSIZE(mp)) {
 			if (show_warnings)
-				print_warning("invalid attr count in inode %llu",
+				print_warning(
+				"invalid attr nameidx in inode %llu",
 						(long long)cur_ino);
-			continue;
+			break;
 		}
-
-		for (i = 0, entry = &leaf->entries[0]; i < nentries;
-				i++, entry++) {
-			if (be16_to_cpu(entry->nameidx) > XFS_LBSIZE(mp)) {
+		if (entry->flags & XFS_ATTR_LOCAL) {
+			local = xfs_attr3_leaf_name_local(leaf, i);
+			if (local->namelen == 0) {
 				if (show_warnings)
-					print_warning("invalid attr nameidx "
-							"in inode %llu",
-							(long long)cur_ino);
+					print_warning(
+				"zero length for attr name in inode %llu",
+						(long long)cur_ino);
 				break;
 			}
-			if (entry->flags & XFS_ATTR_LOCAL) {
-				local = xfs_attr3_leaf_name_local(leaf, i);
-				if (local->namelen == 0) {
-					if (show_warnings)
-						print_warning("zero length for "
-							"attr name in inode %llu",
-							(long long)cur_ino);
-					break;
-				}
-				generate_obfuscated_name(0, local->namelen,
-					&local->nameval[0]);
-				memset(&local->nameval[local->namelen], 0,
-					be16_to_cpu(local->valuelen));
-			} else {
-				remote = xfs_attr3_leaf_name_remote(leaf, i);
-				if (remote->namelen == 0 ||
-						remote->valueblk == 0) {
-					if (show_warnings)
-						print_warning("invalid attr "
-							"entry in inode %llu",
-							(long long)cur_ino);
-					break;
-				}
-				generate_obfuscated_name(0, remote->namelen,
-					&remote->name[0]);
-				add_remote_vals(be32_to_cpu(remote->valueblk),
-					be32_to_cpu(remote->valuelen));
+			generate_obfuscated_name(0, local->namelen,
+				&local->nameval[0]);
+			memset(&local->nameval[local->namelen], 0,
+				be16_to_cpu(local->valuelen));
+		} else {
+			remote = xfs_attr3_leaf_name_remote(leaf, i);
+			if (remote->namelen == 0 || remote->valueblk == 0) {
+				if (show_warnings)
+					print_warning(
+				"invalid attr entry in inode %llu",
+						(long long)cur_ino);
+				break;
 			}
+			generate_obfuscated_name(0, remote->namelen,
+						 &remote->name[0]);
+			add_remote_vals(be32_to_cpu(remote->valueblk),
+					be32_to_cpu(remote->valuelen));
 		}
 	}
 }
@@ -1369,7 +1367,9 @@ process_single_fsb_objects(
 	typnm_t		btype,
 	xfs_dfiloff_t	last)
 {
+	char		*dp;
 	int		ret = 0;
+	int		i;
 
 	push_cur();
 	set_cur(&typtab[btype], XFS_FSB_TO_DADDR(mp, s), c * blkbb,
@@ -1392,22 +1392,27 @@ process_single_fsb_objects(
 		goto out_pop;
 	}
 
-	switch (btype) {
-	case TYP_DIR2:
-		if (o >= mp->m_dirleafblk)
-			break;
+	dp = iocur_top->data;
+	for (i = 0; i < c; i++) {
+		switch (btype) {
+		case TYP_DIR2:
+			if (o >= mp->m_dirleafblk)
+				break;
 
-		obfuscate_dir_data_blocks(iocur_top->data, o, c,
-					 last == mp->m_dirblkfsbs);
-		break;
-	case TYP_SYMLINK:
-		obfuscate_symlink_blocks(iocur_top->data, c);
-		break;
-	case TYP_ATTR:
-		obfuscate_attr_blocks(iocur_top->data, o, c);
-		break;
-	default:
-		break;
+			obfuscate_dir_data_blocks(dp, o, 1,
+						  last == mp->m_dirblkfsbs);
+			break;
+		case TYP_SYMLINK:
+			obfuscate_symlink_block(dp);
+			break;
+		case TYP_ATTR:
+			obfuscate_attr_block(dp, o);
+			break;
+		default:
+			break;
+		}
+		o++;
+		dp += mp->m_sb.sb_blocksize;
 	}
 	ret = write_buf(iocur_top);
 
@@ -1424,12 +1429,41 @@ process_multi_fsb_objects(
 	typnm_t		btype,
 	xfs_dfiloff_t	last)
 {
+	int		ret = 0;
+
 	if (btype != TYP_DIR2) {
 		print_warning("bad type for multi-fsb object %d", btype);
 		return -EINVAL;
 	}
 
-	return process_single_fsb_objects(o, s, c, btype, last);
+	push_cur();
+	set_cur(&typtab[btype], XFS_FSB_TO_DADDR(mp, s), c * blkbb,
+			DB_RING_IGN, NULL);
+
+	if (!iocur_top->data) {
+		xfs_agnumber_t	agno = XFS_FSB_TO_AGNO(mp, s);
+		xfs_agblock_t	agbno = XFS_FSB_TO_AGBNO(mp, s);
+
+		print_warning("cannot read %s block %u/%u (%llu)",
+				typtab[btype].name, agno, agbno, s);
+		if (stop_on_read_error)
+			ret = -EIO;
+		goto out_pop;
+
+	}
+
+	if (dont_obfuscate || o >= mp->m_dirleafblk) {
+		ret = write_buf(iocur_top);
+		goto out_pop;
+	}
+
+	obfuscate_dir_data_blocks(iocur_top->data, o, c,
+				 last == mp->m_dirblkfsbs);
+	ret = write_buf(iocur_top);
+
+out_pop:
+	pop_cur();
+	return ret;
 }
 
 /* inode copy routines */
-- 
1.8.4.rc3

_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs