Try to squash metadump data leaks

The processing for data zeroing was never added to process_multi_fsb_objects. It is now the same thing that process_single_fsb_objects does.

---
 db/metadump.c | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

db/metadump.c +9 -6

index cc2ae9af..ff96860d 100644
@@ -1862,6 +1862,7 @@ process_multi_fsb_objects(
 	typnm_t		btype,
 	xfs_fileoff_t	last)
 {
+	char		*dp;
 	int		ret = 0;
 
 	switch (btype) {

@@ -1902,14 +1903,16 @@ process_multi_fsb_objects(
 
 			}
 
-			if ((!obfuscate && !zero_stale_data) ||
-			     o >= mp->m_dir_geo->leafblk) {
-				ret = write_buf(iocur_top);
-				goto out_pop;
+			dp = iocur_top->data;
+			if (o >= mp->m_dir_geo->freeblk) {
+				process_dir_free_block(dp);
+			} else if (o >= mp->m_dir_geo->leafblk) {
+				process_dir_leaf_block(dp);
+			} else {
+				process_dir_data_block(
+					dp, o, last == mp->m_dir_geo->fsbcount);
 			}
 
-			process_dir_data_block(iocur_top->data, o,
-					       last == mp->m_dir_geo->fsbcount);
 			iocur_top->need_crc = 1;
 			ret = write_buf(iocur_top);
 out_pop:

Quoted 2 lines · Stefan Ring

The processing for data zeroing was never added to process_multi_fsb_objects. It is now the same thing that process_single_fsb_objects does.

First, thanks for doing this, seems about right.

But I could use more changelog words here. ;)

AFAICT, the intent was for process_multi_fsb_objects to call process_dir_data_block() in order to handle the zeroing for multi-fsb objects, so at least some of the cases /were/ handled, right?

Your patch seems to be splitting that 3 ways, so we go to process_dir_free_block or process_dir_leaf_block or process_dir_data_block, the first two are new cases that are now handled? (I do see that this is the same as the process_single_fsb_objects code.)

Given the old case:

                        if ((!obfuscate && !zero_stale_data) ||
                             o >= mp->m_dir_geo->leafblk) {
                                ret = write_buf(iocur_top);

it looks like we were just directly writing the leaf blocks and never obfuscating them, is that correct? I guess I need to go make some test filesystems... do you know from your testing if this is true?

Quoted 23 lines · Eric Sandeen

Quoted 2 lines · Stefan Ring

The processing for data zeroing was never added to process_multi_fsb_objects. It is now the same thing that process_single_fsb_objects does.

First, thanks for doing this, seems about right.

But I could use more changelog words here. ;)

AFAICT, the intent was for process_multi_fsb_objects to call process_dir_data_block() in order to handle the zeroing for multi-fsb objects, so at least some of the cases /were/ handled, right?

Your patch seems to be splitting that 3 ways, so we go to process_dir_free_block or process_dir_leaf_block or process_dir_data_block, the first two are new cases that are now handled? (I do see that this is the same as the process_single_fsb_objects code.)

Given the old case:

                        if ((!obfuscate && !zero_stale_data) ||
                             o >= mp->m_dir_geo->leafblk) {
                                ret = write_buf(iocur_top);

Quoted 3 lines

it looks like we were just directly writing the leaf blocks and never obfuscating them, is that correct? I guess I need to go make some test filesystems... do you know from your testing if this is true?

Whoops, I forgot what directory leaf blocks were, sorry - there is nothing to obfuscate in them. (but there may be data to zero in them...)

I have empirically found and tried to fix some places where stale data was not properly zeroed out.

In the order of the code changes:

- The "freeindex" blocks in inode directories, from last entry to end of block.
- XFS_DIR{2,3}_LEAFN_MAGIC, from last entry to end of block.
- In btree format inodes before as well as after the btree pointers.
- In dev inodes, everything after the header.

---
 db/metadump.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 98 insertions(+), 8 deletions(-)

db/metadump.c +0 -0

index ff96860d..c8213d41 100644

db/metadump.c +63 -7

+	char				*block)
+{
+	struct xfs_dir2_free		*free;
+	struct xfs_dir3_icfree_hdr	freehdr;
+
+	if (!zero_stale_data)
+		return;
+
+	free = (struct xfs_dir2_free *)block;
+	M_DIROPS(mp)->free_hdr_from_disk(&freehdr, free);
+
+	switch (freehdr.magic) {
+	case XFS_DIR2_FREE_MAGIC:
+	case XFS_DIR3_FREE_MAGIC: {
+		__be16			*bests;
+		char			*high;
+		int			used;
+
+		/* Zero out space from end of bests[] to end of block */
+		bests = M_DIROPS(mp)->free_bests_p(free);
+		high = (char *)&bests[freehdr.nvalid];
+		used = high - (char*)free;
+		memset(high, 0, mp->m_dir_geo->blksize - used);
+		iocur_top->need_crc = 1;
+		break;
+	}
+	default:
+		if (show_warnings)
+			print_warning("invalid magic in dir inode %llu "
+				      "free block",
+				      (unsigned long long)cur_ino);
+		break;
+	}
+}
+
 static void
 process_dir_leaf_block(
 	char				*block)
 {
 	struct xfs_dir2_leaf		*leaf;
-	struct xfs_dir3_icleaf_hdr 	leafhdr;
+	struct xfs_dir3_icleaf_hdr	leafhdr;
 
 	if (!zero_stale_data)
 		return;

@@ -1435,20 +1472,39 @@ process_dir_leaf_block(
 	leaf = (struct xfs_dir2_leaf *)block;
 	M_DIROPS(mp)->leaf_hdr_from_disk(&leafhdr, leaf);
 
-	/* Zero out space from end of ents[] to bests */
-	if (leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
-	    leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
+	switch (leafhdr.magic) {
+	case XFS_DIR2_LEAF1_MAGIC:
+	case XFS_DIR3_LEAF1_MAGIC: {
 		struct xfs_dir2_leaf_tail	*ltp;
 		__be16				*lbp;
 		struct xfs_dir2_leaf_entry	*ents;
 		char				*free; /* end of ents */
 
+		/* Zero out space from end of ents[] to bests */
 		ents = M_DIROPS(mp)->leaf_ents_p(leaf);
 		free = (char *)&ents[leafhdr.count];
 		ltp = xfs_dir2_leaf_tail_p(mp->m_dir_geo, leaf);
 		lbp = xfs_dir2_leaf_bests_p(ltp);
 		memset(free, 0, (char *)lbp - free);
 		iocur_top->need_crc = 1;
+		break;
+	}
+	case XFS_DIR2_LEAFN_MAGIC:
+	case XFS_DIR3_LEAFN_MAGIC: {
+		struct xfs_dir2_leaf_entry	*ents;
+		char				*free;
+		int				used;
+
+		/* Zero out space from end of ents[] to end of block */
+		ents = M_DIROPS(mp)->leaf_ents_p(leaf);
+		free = (char *)&ents[leafhdr.count];
+		used = free - (char*)leaf;
+		memset(free, 0, mp->m_dir_geo->blksize - used);
+		iocur_top->need_crc = 1;
+		break;
+	}
+	default:
+		break;
 	}
 }
 

@@ -1499,7 +1555,7 @@ process_dir_data_block(
 		if (show_warnings)
 			print_warning(
 		"invalid magic in dir inode %llu block %ld",
-					(long long)cur_ino, (long)offset);
+					(unsigned long long)cur_ino, (long)offset);
 		return;
 	}
 

@@ -1813,8 +1869,7 @@ process_single_fsb_objects(
 		switch (btype) {
 		case TYP_DIR2:
 			if (o >= mp->m_dir_geo->freeblk) {
-				/* TODO, zap any stale data */
-				break;
+				process_dir_free_block(dp);
 			} else if (o >= mp->m_dir_geo->leafblk) {
 				process_dir_leaf_block(dp);
 			} else {

@@ -2118,6 +2173,21 @@ process_btinode(
 	}
 
 	pp = XFS_BMDR_PTR_ADDR(dib, 1, maxrecs);
+
+	if (zero_stale_data) {
+		char	*top;

db/metadump.c +3 -0

+	}
+
 	for (i = 0; i < nrecs; i++) {
 		xfs_agnumber_t	ag;
 		xfs_agblock_t	bno;

@@ -2201,6 +2271,24 @@ process_inode_data(
 	return 1;
 }
 
+static int

db/metadump.c +7 -1

+		return 1;
+	}
+}
+
 /*
  * when we process the inode, we may change the data in the data and/or
  * attribute fork if they are in short form and we are obfuscating names.

@@ -2253,7 +2341,9 @@ process_inode(
 		case S_IFREG:
 			success = process_inode_data(dip, TYP_DATA);
 			break;
-		default: ;
+		default:
+			success = process_dev_inode(dip);
+			break;
 	}
 	nametable_clear();
 

Signature · 1 line

2.14.4

Quoted 21 lines · Stefan Ring

I have empirically found and tried to fix some places where stale data was not properly zeroed out.

In the order of the code changes:

- The "freeindex" blocks in inode directories, from last entry to end of block.
- XFS_DIR{2,3}_LEAFN_MAGIC, from last entry to end of block.
- In btree format inodes before as well as after the btree pointers.
- In dev inodes, everything after the header.

---
 db/metadump.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 98 insertions(+), 8 deletions(-)

db/metadump.c +0 -0

index ff96860d..c8213d41 100644
@@ -1421,12 +1421,49 @@ process_sf_attr(
              memset(asfep, 0, XFS_DFORK_ASIZE(dip, mp) - ino_attr_size);
 }
 

db/metadump.c process_sf_attr( · line 1425

Quoted 2 lines

db/metadump.c +2 -0

+static void
+process_dir_free_block(

I think patch 1 references this function in patch 2?

I should find some time this weekend for another round of polishing these patches.

Quoted 29 lines · Stefan Ring

I have empirically found and tried to fix some places where stale data was not properly zeroed out.

In the order of the code changes:

- The "freeindex" blocks in inode directories, from last entry to end of block.
- XFS_DIR{2,3}_LEAFN_MAGIC, from last entry to end of block.
- In btree format inodes before as well as after the btree pointers.
- In dev inodes, everything after the header.

---
 db/metadump.c | 106 +++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 98 insertions(+), 8 deletions(-)

db/metadump.c +8 -0

index ff96860d..c8213d41 100644
@@ -2118,6 +2173,21 @@ process_btinode(
      }
 
      pp = XFS_BMDR_PTR_ADDR(dib, 1, maxrecs);
+
+     if (zero_stale_data) {
+             char    *top;
+             int     used;
+
+             /* Space before btree pointers */
+             top = (char*)XFS_BMDR_PTR_ADDR(dib, 1, nrecs);
+             memset(top, 0, (char*)pp - top);

db/metadump.c process_btinode( · line 2188

Quoted 5 lines

db/metadump.c +5 -0

+
+             /* Space after btree pointers */
+             top = (char*)&pp[nrecs];
+             used = top - (char*)dip;
+             memset(top, 0, mp->m_sb.sb_inodesize - used);

Er... this zaps everything past the end of the bmbt pointers, which means that this can zero the attr fork root.

This is the same as v2, but with the correct e-mail address this time. Sorry!

Stefan Ring (2):
xfs_metadump: Extend zapping to multi fsb dir blocks
xfs_metadump: Zap more stale data

 db/metadump.c | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 107 insertions(+), 14 deletions(-)

Quoted 8 lines · Stefan Ring

This is the same as v2, but with the correct e-mail address this time. Sorry!

Stefan Ring (2):
xfs_metadump: Extend zapping to multi fsb dir blocks
xfs_metadump: Zap more stale data

 db/metadump.c | 121 +++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 107 insertions(+), 14 deletions(-)

Still reading through the patches (this stuff makes my brain hurt)

but I think it'd be nice to structure this in a more incremental way, perhaps:

1) fix dir leaf block processing to handle LEAFN
2) add existing leaf block processing to multi-fsb dirs
3) add the dir2 free processing function, and add it to both single & multi-fsb dirs
4) add the process_btinode fixes
5) add the device inode processing

1,2,3 are dependent, 4 and 5 should be independent, they can each be reviewed for their sole purpose. One change, one patch. :)

Quoted 1 line

Hm, I think another case we're missing is interior nodes on multi-fsb objects,

i.e. everything under /* Zero unused part of interior nodes */ seems to be missing for the process_multi_fsb_objects case as well. Urk, what a mess.

Quoted 3 lines · Eric Sandeen

Quoted 1 line

Hm, I think another case we're missing is interior nodes on multi-fsb objects,

i.e. everything under /* Zero unused part of interior nodes */ seems to be missing for the process_multi_fsb_objects case as well. Urk, what a mess.

It is a classic game of whack-a-mole ;). I do understand that it is this way for historical reasons, but if it would be redone today, it should obviously use zeroed buffers for writing out and copy just the bits that are known to be needed.

Quoted 9 lines · Stefan Ring

Quoted 3 lines · Eric Sandeen

Quoted 1 line

Hm, I think another case we're missing is interior nodes on multi-fsb objects,

i.e. everything under /* Zero unused part of interior nodes */ seems to be missing for the process_multi_fsb_objects case as well. Urk, what a mess.

It is a classic game of whack-a-mole ;). I do understand that it is this way for historical reasons, but if it would be redone today, it should obviously use zeroed buffers for writing out and copy just the bits that are known to be needed.

Yeah, I was thinking about that last night. I'm not sure it'd be a whole lot easier, though - for every single type of metadata block we either need to zap the holes or copy the bits, but every boundary is the same and would need to be computed and handled regardless.
I'm not sure it'd be a win.