From: "Darrick J. Wong" <djwong@kernel.org>
To: Carlos Maiolino <cem@kernel.org>
Cc: Chandan Babu R <chandan.babu@oracle.com>, linux-xfs@vger.kernel.org
Subject: Re: [PATCH V2 04/23] metadump: Define and use struct metadump
Date: Thu, 20 Jul 2023 10:22:34 -0700 [thread overview]
Message-ID: <20230720172234.GJ11352@frogsfrogsfrogs> (raw)
In-Reply-To: <20230720131339.ca63q66syb6xu77n@andromeda>
On Thu, Jul 20, 2023 at 03:13:39PM +0200, Carlos Maiolino wrote:
> On Wed, Jul 12, 2023 at 11:12:00AM -0700, Darrick J. Wong wrote:
> > On Tue, Jun 06, 2023 at 02:57:47PM +0530, Chandan Babu R wrote:
> > > This commit collects all state tracking variables in a new "struct metadump"
> > > structure. This is done to collect all the global variables in one place
> > > rather than having them spread across the file. A new structure member of type
> > > "struct metadump_ops *" will be added by a future commit to support the two
> > > versions of metadump.
> > >
> > > Signed-off-by: Chandan Babu R <chandan.babu@oracle.com>
> >
> > FWIW I still don't see much point in wrapping the global variables in a
> > global struct, but I don't feel like holding up the patchset:
> >
> > Reviewed-by: Darrick J. Wong <djwong@kernel.org>
> >
> > (...but ultimately it's up to Carlos to decide to accept or reject
> > this.)
>
> I don't mind either way (variables or struct), but, having everything within a
> global struct just seem easier to my eyes tbh, as, at least for me, it's easier
> to identify some variable has a global scope just by seeing it within the
> 'global struct'.
>
> Unless you have any big objection to leave it as a struct (as I can see you
> don't), this seems totally fine to me.
Sounds good to me then. Let our RVBs stand together! :)
--D
>
> Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
>
>
> >
> > --D
> >
> > > ---
> > > db/metadump.c | 459 +++++++++++++++++++++++++++-----------------------
> > > 1 file changed, 244 insertions(+), 215 deletions(-)
> > >
> > > diff --git a/db/metadump.c b/db/metadump.c
> > > index 8b33fbfb..e5479b56 100644
> > > --- a/db/metadump.c
> > > +++ b/db/metadump.c
> > > @@ -40,25 +40,27 @@ static const cmdinfo_t metadump_cmd =
> > > N_("[-a] [-e] [-g] [-m max_extent] [-w] [-o] filename"),
> > > N_("dump metadata to a file"), metadump_help };
> > >
> > > -static FILE *outf; /* metadump file */
> > > -
> > > -static xfs_metablock_t *metablock; /* header + index + buffers */
> > > -static __be64 *block_index;
> > > -static char *block_buffer;
> > > -
> > > -static int num_indices;
> > > -static int cur_index;
> > > -
> > > -static xfs_ino_t cur_ino;
> > > -
> > > -static bool show_progress = false;
> > > -static bool stop_on_read_error = false;
> > > -static int max_extent_size = DEFAULT_MAX_EXT_SIZE;
> > > -static bool obfuscate = true;
> > > -static bool zero_stale_data = true;
> > > -static bool show_warnings = false;
> > > -static bool progress_since_warning = false;
> > > -static bool stdout_metadump;
> > > +static struct metadump {
> > > + int version;
> > > + bool show_progress;
> > > + bool stop_on_read_error;
> > > + int max_extent_size;
> > > + bool show_warnings;
> > > + bool obfuscate;
> > > + bool zero_stale_data;
> > > + bool progress_since_warning;
> > > + bool dirty_log;
> > > + bool stdout_metadump;
> > > + xfs_ino_t cur_ino;
> > > + /* Metadump file */
> > > + FILE *outf;
> > > + /* header + index + buffers */
> > > + struct xfs_metablock *metablock;
> > > + __be64 *block_index;
> > > + char *block_buffer;
> > > + int num_indices;
> > > + int cur_index;
> > > +} metadump;
> > >
> > > void
> > > metadump_init(void)
> > > @@ -98,9 +100,9 @@ print_warning(const char *fmt, ...)
> > > va_end(ap);
> > > buf[sizeof(buf)-1] = '\0';
> > >
> > > - fprintf(stderr, "%s%s: %s\n", progress_since_warning ? "\n" : "",
> > > - progname, buf);
> > > - progress_since_warning = false;
> > > + fprintf(stderr, "%s%s: %s\n",
> > > + metadump.progress_since_warning ? "\n" : "", progname, buf);
> > > + metadump.progress_since_warning = false;
> > > }
> > >
> > > static void
> > > @@ -118,10 +120,10 @@ print_progress(const char *fmt, ...)
> > > va_end(ap);
> > > buf[sizeof(buf)-1] = '\0';
> > >
> > > - f = stdout_metadump ? stderr : stdout;
> > > + f = metadump.stdout_metadump ? stderr : stdout;
> > > fprintf(f, "\r%-59s", buf);
> > > fflush(f);
> > > - progress_since_warning = true;
> > > + metadump.progress_since_warning = true;
> > > }
> > >
> > > /*
> > > @@ -136,17 +138,19 @@ print_progress(const char *fmt, ...)
> > > static int
> > > write_index(void)
> > > {
> > > + struct xfs_metablock *metablock = metadump.metablock;
> > > /*
> > > * write index block and following data blocks (streaming)
> > > */
> > > - metablock->mb_count = cpu_to_be16(cur_index);
> > > - if (fwrite(metablock, (cur_index + 1) << BBSHIFT, 1, outf) != 1) {
> > > + metablock->mb_count = cpu_to_be16(metadump.cur_index);
> > > + if (fwrite(metablock, (metadump.cur_index + 1) << BBSHIFT, 1,
> > > + metadump.outf) != 1) {
> > > print_warning("error writing to target file");
> > > return -1;
> > > }
> > >
> > > - memset(block_index, 0, num_indices * sizeof(__be64));
> > > - cur_index = 0;
> > > + memset(metadump.block_index, 0, metadump.num_indices * sizeof(__be64));
> > > + metadump.cur_index = 0;
> > > return 0;
> > > }
> > >
> > > @@ -163,9 +167,10 @@ write_buf_segment(
> > > int ret;
> > >
> > > for (i = 0; i < len; i++, off++, data += BBSIZE) {
> > > - block_index[cur_index] = cpu_to_be64(off);
> > > - memcpy(&block_buffer[cur_index << BBSHIFT], data, BBSIZE);
> > > - if (++cur_index == num_indices) {
> > > + metadump.block_index[metadump.cur_index] = cpu_to_be64(off);
> > > + memcpy(&metadump.block_buffer[metadump.cur_index << BBSHIFT],
> > > + data, BBSIZE);
> > > + if (++metadump.cur_index == metadump.num_indices) {
> > > ret = write_index();
> > > if (ret)
> > > return -EIO;
> > > @@ -388,11 +393,11 @@ scan_btree(
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read %s block %u/%u", typtab[btype].name,
> > > agno, agbno);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto pop_out;
> > > }
> > >
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > zero_btree_block(iocur_top->data, btype);
> > > iocur_top->need_crc = 1;
> > > }
> > > @@ -446,7 +451,7 @@ scanfunc_freesp(
> > >
> > > numrecs = be16_to_cpu(block->bb_numrecs);
> > > if (numrecs > mp->m_alloc_mxr[1]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in %s block %u/%u",
> > > numrecs, typtab[btype].name, agno, agbno);
> > > return 1;
> > > @@ -455,7 +460,7 @@ scanfunc_freesp(
> > > pp = XFS_ALLOC_PTR_ADDR(mp, block, 1, mp->m_alloc_mxr[1]);
> > > for (i = 0; i < numrecs; i++) {
> > > if (!valid_bno(agno, be32_to_cpu(pp[i]))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > "in %s block %u/%u",
> > > agno, be32_to_cpu(pp[i]),
> > > @@ -482,13 +487,13 @@ copy_free_bno_btree(
> > >
> > > /* validate root and levels before processing the tree */
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in bnobt "
> > > "root in agf %u", root, agno);
> > > return 1;
> > > }
> > > if (levels > mp->m_alloc_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in bnobt root "
> > > "in agf %u", levels, agno);
> > > return 1;
> > > @@ -510,13 +515,13 @@ copy_free_cnt_btree(
> > >
> > > /* validate root and levels before processing the tree */
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in cntbt "
> > > "root in agf %u", root, agno);
> > > return 1;
> > > }
> > > if (levels > mp->m_alloc_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in cntbt root "
> > > "in agf %u", levels, agno);
> > > return 1;
> > > @@ -543,7 +548,7 @@ scanfunc_rmapbt(
> > >
> > > numrecs = be16_to_cpu(block->bb_numrecs);
> > > if (numrecs > mp->m_rmap_mxr[1]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in %s block %u/%u",
> > > numrecs, typtab[btype].name, agno, agbno);
> > > return 1;
> > > @@ -552,7 +557,7 @@ scanfunc_rmapbt(
> > > pp = XFS_RMAP_PTR_ADDR(block, 1, mp->m_rmap_mxr[1]);
> > > for (i = 0; i < numrecs; i++) {
> > > if (!valid_bno(agno, be32_to_cpu(pp[i]))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > "in %s block %u/%u",
> > > agno, be32_to_cpu(pp[i]),
> > > @@ -582,13 +587,13 @@ copy_rmap_btree(
> > >
> > > /* validate root and levels before processing the tree */
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in rmapbt "
> > > "root in agf %u", root, agno);
> > > return 1;
> > > }
> > > if (levels > mp->m_rmap_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in rmapbt root "
> > > "in agf %u", levels, agno);
> > > return 1;
> > > @@ -615,7 +620,7 @@ scanfunc_refcntbt(
> > >
> > > numrecs = be16_to_cpu(block->bb_numrecs);
> > > if (numrecs > mp->m_refc_mxr[1]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in %s block %u/%u",
> > > numrecs, typtab[btype].name, agno, agbno);
> > > return 1;
> > > @@ -624,7 +629,7 @@ scanfunc_refcntbt(
> > > pp = XFS_REFCOUNT_PTR_ADDR(block, 1, mp->m_refc_mxr[1]);
> > > for (i = 0; i < numrecs; i++) {
> > > if (!valid_bno(agno, be32_to_cpu(pp[i]))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > "in %s block %u/%u",
> > > agno, be32_to_cpu(pp[i]),
> > > @@ -654,13 +659,13 @@ copy_refcount_btree(
> > >
> > > /* validate root and levels before processing the tree */
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in refcntbt "
> > > "root in agf %u", root, agno);
> > > return 1;
> > > }
> > > if (levels > mp->m_refc_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in refcntbt root "
> > > "in agf %u", levels, agno);
> > > return 1;
> > > @@ -785,7 +790,8 @@ in_lost_found(
> > > /* Record the "lost+found" inode if we haven't done so already */
> > >
> > > ASSERT(ino != 0);
> > > - if (!orphanage_ino && is_orphanage_dir(mp, cur_ino, namelen, name))
> > > + if (!orphanage_ino && is_orphanage_dir(mp, metadump.cur_ino, namelen,
> > > + name))
> > > orphanage_ino = ino;
> > >
> > > /* We don't obfuscate the "lost+found" directory itself */
> > > @@ -795,7 +801,7 @@ in_lost_found(
> > >
> > > /* Most files aren't in "lost+found" at all */
> > >
> > > - if (cur_ino != orphanage_ino)
> > > + if (metadump.cur_ino != orphanage_ino)
> > > return 0;
> > >
> > > /*
> > > @@ -1219,7 +1225,7 @@ generate_obfuscated_name(
> > > print_warning("duplicate name for inode %llu "
> > > "in dir inode %llu\n",
> > > (unsigned long long) ino,
> > > - (unsigned long long) cur_ino);
> > > + (unsigned long long) metadump.cur_ino);
> > > return;
> > > }
> > >
> > > @@ -1229,7 +1235,7 @@ generate_obfuscated_name(
> > > print_warning("unable to record name for inode %llu "
> > > "in dir inode %llu\n",
> > > (unsigned long long) ino,
> > > - (unsigned long long) cur_ino);
> > > + (unsigned long long) metadump.cur_ino);
> > > }
> > >
> > > static void
> > > @@ -1245,9 +1251,9 @@ process_sf_dir(
> > > ino_dir_size = be64_to_cpu(dip->di_size);
> > > if (ino_dir_size > XFS_DFORK_DSIZE(dip, mp)) {
> > > ino_dir_size = XFS_DFORK_DSIZE(dip, mp);
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid size in dir inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > }
> > >
> > > sfep = xfs_dir2_sf_firstentry(sfp);
> > > @@ -1261,9 +1267,9 @@ process_sf_dir(
> > > int namelen = sfep->namelen;
> > >
> > > if (namelen == 0) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("zero length entry in dir inode "
> > > - "%llu", (long long)cur_ino);
> > > + "%llu", (long long)metadump.cur_ino);
> > > if (i != sfp->count - 1)
> > > break;
> > > namelen = ino_dir_size - ((char *)&sfep->name[0] -
> > > @@ -1271,16 +1277,17 @@ process_sf_dir(
> > > } else if ((char *)sfep - (char *)sfp +
> > > libxfs_dir2_sf_entsize(mp, sfp, sfep->namelen) >
> > > ino_dir_size) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("entry length in dir inode %llu "
> > > - "overflows space", (long long)cur_ino);
> > > + "overflows space",
> > > + (long long)metadump.cur_ino);
> > > if (i != sfp->count - 1)
> > > break;
> > > namelen = ino_dir_size - ((char *)&sfep->name[0] -
> > > (char *)sfp);
> > > }
> > >
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > generate_obfuscated_name(
> > > libxfs_dir2_sf_get_ino(mp, sfp, sfep),
> > > namelen, &sfep->name[0]);
> > > @@ -1290,7 +1297,8 @@ process_sf_dir(
> > > }
> > >
> > > /* zero stale data in rest of space in data fork, if any */
> > > - if (zero_stale_data && (ino_dir_size < XFS_DFORK_DSIZE(dip, mp)))
> > > + if (metadump.zero_stale_data &&
> > > + (ino_dir_size < XFS_DFORK_DSIZE(dip, mp)))
> > > memset(sfep, 0, XFS_DFORK_DSIZE(dip, mp) - ino_dir_size);
> > > }
> > >
> > > @@ -1346,18 +1354,18 @@ process_sf_symlink(
> > >
> > > len = be64_to_cpu(dip->di_size);
> > > if (len > XFS_DFORK_DSIZE(dip, mp)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid size (%d) in symlink inode %llu",
> > > - len, (long long)cur_ino);
> > > + len, (long long)metadump.cur_ino);
> > > len = XFS_DFORK_DSIZE(dip, mp);
> > > }
> > >
> > > buf = (char *)XFS_DFORK_DPTR(dip);
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > obfuscate_path_components(buf, len);
> > >
> > > /* zero stale data in rest of space in data fork, if any */
> > > - if (zero_stale_data && len < XFS_DFORK_DSIZE(dip, mp))
> > > + if (metadump.zero_stale_data && len < XFS_DFORK_DSIZE(dip, mp))
> > > memset(&buf[len], 0, XFS_DFORK_DSIZE(dip, mp) - len);
> > > }
> > >
> > > @@ -1382,9 +1390,9 @@ process_sf_attr(
> > > ino_attr_size = be16_to_cpu(asfp->hdr.totsize);
> > > if (ino_attr_size > XFS_DFORK_ASIZE(dip, mp)) {
> > > ino_attr_size = XFS_DFORK_ASIZE(dip, mp);
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid attr size in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > }
> > >
> > > asfep = &asfp->list[0];
> > > @@ -1394,19 +1402,20 @@ process_sf_attr(
> > > int namelen = asfep->namelen;
> > >
> > > if (namelen == 0) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("zero length attr entry in inode "
> > > - "%llu", (long long)cur_ino);
> > > + "%llu", (long long)metadump.cur_ino);
> > > break;
> > > } else if ((char *)asfep - (char *)asfp +
> > > xfs_attr_sf_entsize(asfep) > ino_attr_size) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("attr entry length in inode %llu "
> > > - "overflows space", (long long)cur_ino);
> > > + "overflows space",
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > >
> > > - if (obfuscate) {
> > > + if (metadump.obfuscate) {
> > > generate_obfuscated_name(0, asfep->namelen,
> > > &asfep->nameval[0]);
> > > memset(&asfep->nameval[asfep->namelen], 'v',
> > > @@ -1418,7 +1427,8 @@ process_sf_attr(
> > > }
> > >
> > > /* zero stale data in rest of space in attr fork, if any */
> > > - if (zero_stale_data && (ino_attr_size < XFS_DFORK_ASIZE(dip, mp)))
> > > + if (metadump.zero_stale_data &&
> > > + (ino_attr_size < XFS_DFORK_ASIZE(dip, mp)))
> > > memset(asfep, 0, XFS_DFORK_ASIZE(dip, mp) - ino_attr_size);
> > > }
> > >
> > > @@ -1429,7 +1439,7 @@ process_dir_free_block(
> > > struct xfs_dir2_free *free;
> > > struct xfs_dir3_icfree_hdr freehdr;
> > >
> > > - if (!zero_stale_data)
> > > + if (!metadump.zero_stale_data)
> > > return;
> > >
> > > free = (struct xfs_dir2_free *)block;
> > > @@ -1451,10 +1461,10 @@ process_dir_free_block(
> > > break;
> > > }
> > > default:
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid magic in dir inode %llu "
> > > "free block",
> > > - (unsigned long long)cur_ino);
> > > + (unsigned long long)metadump.cur_ino);
> > > break;
> > > }
> > > }
> > > @@ -1466,7 +1476,7 @@ process_dir_leaf_block(
> > > struct xfs_dir2_leaf *leaf;
> > > struct xfs_dir3_icleaf_hdr leafhdr;
> > >
> > > - if (!zero_stale_data)
> > > + if (!metadump.zero_stale_data)
> > > return;
> > >
> > > /* Yes, this works for dir2 & dir3. Difference is padding. */
> > > @@ -1549,10 +1559,10 @@ process_dir_data_block(
> > > }
> > >
> > > if (be32_to_cpu(datahdr->magic) != wantmagic) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "invalid magic in dir inode %llu block %ld",
> > > - (unsigned long long)cur_ino, (long)offset);
> > > + (unsigned long long)metadump.cur_ino, (long)offset);
> > > return;
> > > }
> > >
> > > @@ -1572,10 +1582,10 @@ process_dir_data_block(
> > > if (dir_offset + free_length > end_of_data ||
> > > !free_length ||
> > > (free_length & (XFS_DIR2_DATA_ALIGN - 1))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "invalid length for dir free space in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > return;
> > > }
> > > if (be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) !=
> > > @@ -1588,7 +1598,7 @@ process_dir_data_block(
> > > * actually at a variable offset, so zeroing &dup->tag
> > > * is zeroing the free space in between
> > > */
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > int zlen = free_length -
> > > sizeof(xfs_dir2_data_unused_t);
> > >
> > > @@ -1606,23 +1616,23 @@ process_dir_data_block(
> > >
> > > if (dir_offset + length > end_of_data ||
> > > ptr + length > endptr) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "invalid length for dir entry name in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > return;
> > > }
> > > if (be16_to_cpu(*libxfs_dir2_data_entry_tag_p(mp, dep)) !=
> > > dir_offset)
> > > return;
> > >
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > generate_obfuscated_name(be64_to_cpu(dep->inumber),
> > > dep->namelen, &dep->name[0]);
> > > dir_offset += length;
> > > ptr += length;
> > > /* Zero the unused space after name, up to the tag */
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > /* 1 byte for ftype; don't bother with conditional */
> > > int zlen =
> > > (char *)libxfs_dir2_data_entry_tag_p(mp, dep) -
> > > @@ -1658,7 +1668,7 @@ process_symlink_block(
> > >
> > > print_warning("cannot read %s block %u/%u (%llu)",
> > > typtab[btype].name, agno, agbno, s);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto out_pop;
> > > }
> > > link = iocur_top->data;
> > > @@ -1666,10 +1676,10 @@ process_symlink_block(
> > > if (xfs_has_crc((mp)))
> > > link += sizeof(struct xfs_dsymlink_hdr);
> > >
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > obfuscate_path_components(link, XFS_SYMLINK_BUF_SPACE(mp,
> > > mp->m_sb.sb_blocksize));
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > size_t linklen, zlen;
> > >
> > > linklen = strlen(link);
> > > @@ -1736,7 +1746,8 @@ process_attr_block(
> > > if ((be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR_LEAF_MAGIC) &&
> > > (be16_to_cpu(leaf->hdr.info.magic) != XFS_ATTR3_LEAF_MAGIC)) {
> > > for (i = 0; i < attr_data.remote_val_count; i++) {
> > > - if (obfuscate && attr_data.remote_vals[i] == offset)
> > > + if (metadump.obfuscate &&
> > > + attr_data.remote_vals[i] == offset)
> > > /* Macros to handle both attr and attr3 */
> > > memset(block +
> > > (bs - XFS_ATTR3_RMT_BUF_SPACE(mp, bs)),
> > > @@ -1753,9 +1764,9 @@ process_attr_block(
> > > nentries * sizeof(xfs_attr_leaf_entry_t) +
> > > xfs_attr3_leaf_hdr_size(leaf) >
> > > XFS_ATTR3_RMT_BUF_SPACE(mp, bs)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid attr count in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > return;
> > > }
> > >
> > > @@ -1770,22 +1781,22 @@ process_attr_block(
> > > first_name = xfs_attr3_leaf_name(leaf, i);
> > >
> > > if (be16_to_cpu(entry->nameidx) > mp->m_sb.sb_blocksize) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "invalid attr nameidx in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > > if (entry->flags & XFS_ATTR_LOCAL) {
> > > local = xfs_attr3_leaf_name_local(leaf, i);
> > > if (local->namelen == 0) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "zero length for attr name in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > > - if (obfuscate) {
> > > + if (metadump.obfuscate) {
> > > generate_obfuscated_name(0, local->namelen,
> > > &local->nameval[0]);
> > > memset(&local->nameval[local->namelen], 'v',
> > > @@ -1797,18 +1808,18 @@ process_attr_block(
> > > zlen = xfs_attr_leaf_entsize_local(nlen, vlen) -
> > > (sizeof(xfs_attr_leaf_name_local_t) - 1 +
> > > nlen + vlen);
> > > - if (zero_stale_data)
> > > + if (metadump.zero_stale_data)
> > > memset(&local->nameval[nlen + vlen], 0, zlen);
> > > } else {
> > > remote = xfs_attr3_leaf_name_remote(leaf, i);
> > > if (remote->namelen == 0 || remote->valueblk == 0) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning(
> > > "invalid attr entry in inode %llu",
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > > - if (obfuscate) {
> > > + if (metadump.obfuscate) {
> > > generate_obfuscated_name(0, remote->namelen,
> > > &remote->name[0]);
> > > add_remote_vals(be32_to_cpu(remote->valueblk),
> > > @@ -1819,13 +1830,13 @@ process_attr_block(
> > > zlen = xfs_attr_leaf_entsize_remote(nlen) -
> > > (sizeof(xfs_attr_leaf_name_remote_t) - 1 +
> > > nlen);
> > > - if (zero_stale_data)
> > > + if (metadump.zero_stale_data)
> > > memset(&remote->name[nlen], 0, zlen);
> > > }
> > > }
> > >
> > > /* Zero from end of entries array to the first name/val */
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > struct xfs_attr_leaf_entry *entries;
> > >
> > > entries = xfs_attr3_leaf_entryp(leaf);
> > > @@ -1858,16 +1869,16 @@ process_single_fsb_objects(
> > >
> > > print_warning("cannot read %s block %u/%u (%llu)",
> > > typtab[btype].name, agno, agbno, s);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto out_pop;
> > >
> > > }
> > >
> > > - if (!obfuscate && !zero_stale_data)
> > > + if (!metadump.obfuscate && !metadump.zero_stale_data)
> > > goto write;
> > >
> > > /* Zero unused part of interior nodes */
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > xfs_da_intnode_t *node = iocur_top->data;
> > > int magic = be16_to_cpu(node->hdr.info.magic);
> > >
> > > @@ -1978,12 +1989,12 @@ process_multi_fsb_dir(
> > >
> > > print_warning("cannot read %s block %u/%u (%llu)",
> > > typtab[btype].name, agno, agbno, s);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto out_pop;
> > >
> > > }
> > >
> > > - if (!obfuscate && !zero_stale_data)
> > > + if (!metadump.obfuscate && !metadump.zero_stale_data)
> > > goto write;
> > >
> > > dp = iocur_top->data;
> > > @@ -2075,25 +2086,27 @@ process_bmbt_reclist(
> > > * one is found, stop processing remaining extents
> > > */
> > > if (i > 0 && op + cp > o) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("bmap extent %d in %s ino %llu "
> > > "starts at %llu, previous extent "
> > > "ended at %llu", i,
> > > - typtab[btype].name, (long long)cur_ino,
> > > + typtab[btype].name,
> > > + (long long)metadump.cur_ino,
> > > o, op + cp - 1);
> > > break;
> > > }
> > >
> > > - if (c > max_extent_size) {
> > > + if (c > metadump.max_extent_size) {
> > > /*
> > > * since we are only processing non-data extents,
> > > * large numbers of blocks in a metadata extent is
> > > * extremely rare and more than likely to be corrupt.
> > > */
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("suspicious count %u in bmap "
> > > "extent %d in %s ino %llu", c, i,
> > > - typtab[btype].name, (long long)cur_ino);
> > > + typtab[btype].name,
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > >
> > > @@ -2104,19 +2117,21 @@ process_bmbt_reclist(
> > > agbno = XFS_FSB_TO_AGBNO(mp, s);
> > >
> > > if (!valid_bno(agno, agbno)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number %u/%u "
> > > "(%llu) in bmap extent %d in %s ino "
> > > "%llu", agno, agbno, s, i,
> > > - typtab[btype].name, (long long)cur_ino);
> > > + typtab[btype].name,
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > >
> > > if (!valid_bno(agno, agbno + c - 1)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("bmap extent %i in %s inode %llu "
> > > "overflows AG (end is %u/%u)", i,
> > > - typtab[btype].name, (long long)cur_ino,
> > > + typtab[btype].name,
> > > + (long long)metadump.cur_ino,
> > > agno, agbno + c - 1);
> > > break;
> > > }
> > > @@ -2152,7 +2167,7 @@ scanfunc_bmap(
> > >
> > > if (level == 0) {
> > > if (nrecs > mp->m_bmap_dmxr[0]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in %s "
> > > "block %u/%u", nrecs,
> > > typtab[btype].name, agno, agbno);
> > > @@ -2163,7 +2178,7 @@ scanfunc_bmap(
> > > }
> > >
> > > if (nrecs > mp->m_bmap_dmxr[1]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in %s block %u/%u",
> > > nrecs, typtab[btype].name, agno, agbno);
> > > return 1;
> > > @@ -2178,7 +2193,7 @@ scanfunc_bmap(
> > >
> > > if (bno == 0 || bno > mp->m_sb.sb_agblocks ||
> > > ag > mp->m_sb.sb_agcount) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > "in %s block %u/%u", ag, bno,
> > > typtab[btype].name, agno, agbno);
> > > @@ -2213,10 +2228,10 @@ process_btinode(
> > > nrecs = be16_to_cpu(dib->bb_numrecs);
> > >
> > > if (level > XFS_BM_MAXLEVELS(mp, whichfork)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in inode %lld %s "
> > > - "root", level, (long long)cur_ino,
> > > - typtab[btype].name);
> > > + "root", level, (long long)metadump.cur_ino,
> > > + typtab[btype].name);
> > > return 1;
> > > }
> > >
> > > @@ -2227,16 +2242,16 @@ process_btinode(
> > >
> > > maxrecs = libxfs_bmdr_maxrecs(XFS_DFORK_SIZE(dip, mp, whichfork), 0);
> > > if (nrecs > maxrecs) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs (%u) in inode %lld %s "
> > > - "root", nrecs, (long long)cur_ino,
> > > - typtab[btype].name);
> > > + "root", nrecs, (long long)metadump.cur_ino,
> > > + typtab[btype].name);
> > > return 1;
> > > }
> > >
> > > pp = XFS_BMDR_PTR_ADDR(dib, 1, maxrecs);
> > >
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > char *top;
> > >
> > > /* Unused btree key space */
> > > @@ -2257,11 +2272,11 @@ process_btinode(
> > >
> > > if (bno == 0 || bno > mp->m_sb.sb_agblocks ||
> > > ag > mp->m_sb.sb_agcount) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > - "in inode %llu %s root", ag,
> > > - bno, (long long)cur_ino,
> > > - typtab[btype].name);
> > > + "in inode %llu %s root", ag, bno,
> > > + (long long)metadump.cur_ino,
> > > + typtab[btype].name);
> > > continue;
> > > }
> > >
> > > @@ -2288,14 +2303,16 @@ process_exinode(
> > > whichfork);
> > > used = nex * sizeof(xfs_bmbt_rec_t);
> > > if (nex > max_nex || used > XFS_DFORK_SIZE(dip, mp, whichfork)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("bad number of extents %llu in inode %lld",
> > > - (unsigned long long)nex, (long long)cur_ino);
> > > + (unsigned long long)nex,
> > > + (long long)metadump.cur_ino);
> > > return 1;
> > > }
> > >
> > > /* Zero unused data fork past used extents */
> > > - if (zero_stale_data && (used < XFS_DFORK_SIZE(dip, mp, whichfork)))
> > > + if (metadump.zero_stale_data &&
> > > + (used < XFS_DFORK_SIZE(dip, mp, whichfork)))
> > > memset(XFS_DFORK_PTR(dip, whichfork) + used, 0,
> > > XFS_DFORK_SIZE(dip, mp, whichfork) - used);
> > >
> > > @@ -2311,7 +2328,7 @@ process_inode_data(
> > > {
> > > switch (dip->di_format) {
> > > case XFS_DINODE_FMT_LOCAL:
> > > - if (!(obfuscate || zero_stale_data))
> > > + if (!(metadump.obfuscate || metadump.zero_stale_data))
> > > break;
> > >
> > > /*
> > > @@ -2323,7 +2340,7 @@ process_inode_data(
> > > print_warning(
> > > "Invalid data fork size (%d) in inode %llu, preserving contents!",
> > > XFS_DFORK_DSIZE(dip, mp),
> > > - (long long)cur_ino);
> > > + (long long)metadump.cur_ino);
> > > break;
> > > }
> > >
> > > @@ -2355,9 +2372,9 @@ process_dev_inode(
> > > struct xfs_dinode *dip)
> > > {
> > > if (xfs_dfork_data_extents(dip)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("inode %llu has unexpected extents",
> > > - (unsigned long long)cur_ino);
> > > + (unsigned long long)metadump.cur_ino);
> > > return;
> > > }
> > >
> > > @@ -2369,11 +2386,11 @@ process_dev_inode(
> > > if (XFS_DFORK_DSIZE(dip, mp) > XFS_LITINO(mp)) {
> > > print_warning(
> > > "Invalid data fork size (%d) in inode %llu, preserving contents!",
> > > - XFS_DFORK_DSIZE(dip, mp), (long long)cur_ino);
> > > + XFS_DFORK_DSIZE(dip, mp), (long long)metadump.cur_ino);
> > > return;
> > > }
> > >
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > unsigned int size = sizeof(xfs_dev_t);
> > >
> > > memset(XFS_DFORK_DPTR(dip) + size, 0,
> > > @@ -2399,17 +2416,17 @@ process_inode(
> > > bool crc_was_ok = false; /* no recalc by default */
> > > bool need_new_crc = false;
> > >
> > > - cur_ino = XFS_AGINO_TO_INO(mp, agno, agino);
> > > + metadump.cur_ino = XFS_AGINO_TO_INO(mp, agno, agino);
> > >
> > > /* we only care about crc recalculation if we will modify the inode. */
> > > - if (obfuscate || zero_stale_data) {
> > > + if (metadump.obfuscate || metadump.zero_stale_data) {
> > > crc_was_ok = libxfs_verify_cksum((char *)dip,
> > > mp->m_sb.sb_inodesize,
> > > offsetof(struct xfs_dinode, di_crc));
> > > }
> > >
> > > if (free_inode) {
> > > - if (zero_stale_data) {
> > > + if (metadump.zero_stale_data) {
> > > /* Zero all of the inode literal area */
> > > memset(XFS_DFORK_DPTR(dip), 0, XFS_LITINO(mp));
> > > }
> > > @@ -2451,7 +2468,8 @@ process_inode(
> > > switch (dip->di_aformat) {
> > > case XFS_DINODE_FMT_LOCAL:
> > > need_new_crc = true;
> > > - if (obfuscate || zero_stale_data)
> > > + if (metadump.obfuscate ||
> > > + metadump.zero_stale_data)
> > > process_sf_attr(dip);
> > > break;
> > >
> > > @@ -2468,7 +2486,7 @@ process_inode(
> > >
> > > done:
> > > /* Heavy handed but low cost; just do it as a catch-all. */
> > > - if (zero_stale_data)
> > > + if (metadump.zero_stale_data)
> > > need_new_crc = true;
> > >
> > > if (crc_was_ok && need_new_crc)
> > > @@ -2528,7 +2546,7 @@ copy_inode_chunk(
> > > if (agino == 0 || agino == NULLAGINO || !valid_bno(agno, agbno) ||
> > > !valid_bno(agno, XFS_AGINO_TO_AGBNO(mp,
> > > agino + XFS_INODES_PER_CHUNK - 1))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("bad inode number %llu (%u/%u)",
> > > XFS_AGINO_TO_INO(mp, agno, agino), agno, agino);
> > > return 1;
> > > @@ -2544,7 +2562,7 @@ copy_inode_chunk(
> > > (xfs_has_align(mp) &&
> > > mp->m_sb.sb_inoalignmt != 0 &&
> > > agbno % mp->m_sb.sb_inoalignmt != 0)) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("badly aligned inode (start = %llu)",
> > > XFS_AGINO_TO_INO(mp, agno, agino));
> > > return 1;
> > > @@ -2561,7 +2579,7 @@ copy_inode_chunk(
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read inode block %u/%u",
> > > agno, agbno);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto pop_out;
> > > }
> > >
> > > @@ -2587,7 +2605,7 @@ next_bp:
> > > ioff += inodes_per_buf;
> > > }
> > >
> > > - if (show_progress)
> > > + if (metadump.show_progress)
> > > print_progress("Copied %u of %u inodes (%u of %u AGs)",
> > > inodes_copied, mp->m_sb.sb_icount, agno,
> > > mp->m_sb.sb_agcount);
> > > @@ -2617,7 +2635,7 @@ scanfunc_ino(
> > >
> > > if (level == 0) {
> > > if (numrecs > igeo->inobt_mxr[0]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs %d in %s "
> > > "block %u/%u", numrecs,
> > > typtab[btype].name, agno, agbno);
> > > @@ -2640,7 +2658,7 @@ scanfunc_ino(
> > > }
> > >
> > > if (numrecs > igeo->inobt_mxr[1]) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid numrecs %d in %s block %u/%u",
> > > numrecs, typtab[btype].name, agno, agbno);
> > > numrecs = igeo->inobt_mxr[1];
> > > @@ -2649,7 +2667,7 @@ scanfunc_ino(
> > > pp = XFS_INOBT_PTR_ADDR(mp, block, 1, igeo->inobt_mxr[1]);
> > > for (i = 0; i < numrecs; i++) {
> > > if (!valid_bno(agno, be32_to_cpu(pp[i]))) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u/%u) "
> > > "in %s block %u/%u",
> > > agno, be32_to_cpu(pp[i]),
> > > @@ -2677,13 +2695,13 @@ copy_inodes(
> > >
> > > /* validate root and levels before processing the tree */
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in inobt "
> > > "root in agi %u", root, agno);
> > > return 1;
> > > }
> > > if (levels > M_IGEO(mp)->inobt_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in inobt root "
> > > "in agi %u", levels, agno);
> > > return 1;
> > > @@ -2697,7 +2715,7 @@ copy_inodes(
> > > levels = be32_to_cpu(agi->agi_free_level);
> > >
> > > if (root == 0 || root > mp->m_sb.sb_agblocks) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid block number (%u) in "
> > > "finobt root in agi %u", root,
> > > agno);
> > > @@ -2705,7 +2723,7 @@ copy_inodes(
> > > }
> > >
> > > if (levels > M_IGEO(mp)->inobt_maxlevels) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid level (%u) in finobt "
> > > "root in agi %u", levels, agno);
> > > return 1;
> > > @@ -2736,11 +2754,11 @@ scan_ag(
> > > XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
> > > if (!iocur_top->data) {
> > > print_warning("cannot read superblock for ag %u", agno);
> > > - if (stop_on_read_error)
> > > + if (metadump.stop_on_read_error)
> > > goto pop_out;
> > > } else {
> > > /* Replace any filesystem label with "L's" */
> > > - if (obfuscate) {
> > > + if (metadump.obfuscate) {
> > > struct xfs_sb *sb = iocur_top->data;
> > > memset(sb->sb_fname, 'L',
> > > min(strlen(sb->sb_fname), sizeof(sb->sb_fname)));
> > > @@ -2758,7 +2776,7 @@ scan_ag(
> > > agf = iocur_top->data;
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read agf block for ag %u", agno);
> > > - if (stop_on_read_error)
> > > + if (metadump.stop_on_read_error)
> > > goto pop_out;
> > > } else {
> > > if (write_buf(iocur_top))
> > > @@ -2773,7 +2791,7 @@ scan_ag(
> > > agi = iocur_top->data;
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read agi block for ag %u", agno);
> > > - if (stop_on_read_error)
> > > + if (metadump.stop_on_read_error)
> > > goto pop_out;
> > > } else {
> > > if (write_buf(iocur_top))
> > > @@ -2787,10 +2805,10 @@ scan_ag(
> > > XFS_FSS_TO_BB(mp, 1), DB_RING_IGN, NULL);
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read agfl block for ag %u", agno);
> > > - if (stop_on_read_error)
> > > + if (metadump.stop_on_read_error)
> > > goto pop_out;
> > > } else {
> > > - if (agf && zero_stale_data) {
> > > + if (agf && metadump.zero_stale_data) {
> > > /* Zero out unused bits of agfl */
> > > int i;
> > > __be32 *agfl_bno;
> > > @@ -2813,7 +2831,7 @@ scan_ag(
> > >
> > > /* copy AG free space btrees */
> > > if (agf) {
> > > - if (show_progress)
> > > + if (metadump.show_progress)
> > > print_progress("Copying free space trees of AG %u",
> > > agno);
> > > if (!copy_free_bno_btree(agno, agf))
> > > @@ -2859,7 +2877,7 @@ copy_ino(
> > >
> > > if (agno >= mp->m_sb.sb_agcount || agbno >= mp->m_sb.sb_agblocks ||
> > > offset >= mp->m_sb.sb_inopblock) {
> > > - if (show_warnings)
> > > + if (metadump.show_warnings)
> > > print_warning("invalid %s inode number (%lld)",
> > > typtab[itype].name, (long long)ino);
> > > return 1;
> > > @@ -2871,12 +2889,12 @@ copy_ino(
> > > if (iocur_top->data == NULL) {
> > > print_warning("cannot read %s inode %lld",
> > > typtab[itype].name, (long long)ino);
> > > - rval = !stop_on_read_error;
> > > + rval = !metadump.stop_on_read_error;
> > > goto pop_out;
> > > }
> > > off_cur(offset << mp->m_sb.sb_inodelog, mp->m_sb.sb_inodesize);
> > >
> > > - cur_ino = ino;
> > > + metadump.cur_ino = ino;
> > > rval = process_inode_data(iocur_top->data, itype);
> > > pop_out:
> > > pop_cur();
> > > @@ -2912,7 +2930,7 @@ copy_log(void)
> > > int logversion;
> > > int cycle = XLOG_INIT_CYCLE;
> > >
> > > - if (show_progress)
> > > + if (metadump.show_progress)
> > > print_progress("Copying log");
> > >
> > > push_cur();
> > > @@ -2921,11 +2939,11 @@ copy_log(void)
> > > if (iocur_top->data == NULL) {
> > > pop_cur();
> > > print_warning("cannot read log");
> > > - return !stop_on_read_error;
> > > + return !metadump.stop_on_read_error;
> > > }
> > >
> > > /* If not obfuscating or zeroing, just copy the log as it is */
> > > - if (!obfuscate && !zero_stale_data)
> > > + if (!metadump.obfuscate && !metadump.zero_stale_data)
> > > goto done;
> > >
> > > dirty = xlog_is_dirty(mp, &log, &x, 0);
> > > @@ -2933,7 +2951,7 @@ copy_log(void)
> > > switch (dirty) {
> > > case 0:
> > > /* clear out a clean log */
> > > - if (show_progress)
> > > + if (metadump.show_progress)
> > > print_progress("Zeroing clean log");
> > >
> > > logstart = XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart);
> > > @@ -2948,7 +2966,7 @@ copy_log(void)
> > > break;
> > > case 1:
> > > /* keep the dirty log */
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > print_warning(
> > > _("Warning: log recovery of an obfuscated metadata image can leak "
> > > "unobfuscated metadata and/or cause image corruption. If possible, "
> > > @@ -2956,7 +2974,7 @@ _("Warning: log recovery of an obfuscated metadata image can leak "
> > > break;
> > > case -1:
> > > /* log detection error */
> > > - if (obfuscate)
> > > + if (metadump.obfuscate)
> > > print_warning(
> > > _("Could not discern log; image will contain unobfuscated metadata in log."));
> > > break;
> > > @@ -2979,9 +2997,15 @@ metadump_f(
> > > char *p;
> > >
> > > exitcode = 1;
> > > - show_progress = false;
> > > - show_warnings = false;
> > > - stop_on_read_error = false;
> > > +
> > > + metadump.version = 1;
> > > + metadump.show_progress = false;
> > > + metadump.stop_on_read_error = false;
> > > + metadump.max_extent_size = DEFAULT_MAX_EXT_SIZE;
> > > + metadump.show_warnings = false;
> > > + metadump.obfuscate = true;
> > > + metadump.zero_stale_data = true;
> > > + metadump.dirty_log = false;
> > >
> > > if (mp->m_sb.sb_magicnum != XFS_SB_MAGIC) {
> > > print_warning("bad superblock magic number %x, giving up",
> > > @@ -3002,27 +3026,29 @@ metadump_f(
> > > while ((c = getopt(argc, argv, "aegm:ow")) != EOF) {
> > > switch (c) {
> > > case 'a':
> > > - zero_stale_data = false;
> > > + metadump.zero_stale_data = false;
> > > break;
> > > case 'e':
> > > - stop_on_read_error = true;
> > > + metadump.stop_on_read_error = true;
> > > break;
> > > case 'g':
> > > - show_progress = true;
> > > + metadump.show_progress = true;
> > > break;
> > > case 'm':
> > > - max_extent_size = (int)strtol(optarg, &p, 0);
> > > - if (*p != '\0' || max_extent_size <= 0) {
> > > + metadump.max_extent_size =
> > > + (int)strtol(optarg, &p, 0);
> > > + if (*p != '\0' ||
> > > + metadump.max_extent_size <= 0) {
> > > print_warning("bad max extent size %s",
> > > optarg);
> > > return 0;
> > > }
> > > break;
> > > case 'o':
> > > - obfuscate = false;
> > > + metadump.obfuscate = false;
> > > break;
> > > case 'w':
> > > - show_warnings = true;
> > > + metadump.show_warnings = true;
> > > break;
> > > default:
> > > print_warning("bad option for metadump command");
> > > @@ -3035,21 +3061,6 @@ metadump_f(
> > > return 0;
> > > }
> > >
> > > - metablock = (xfs_metablock_t *)calloc(BBSIZE + 1, BBSIZE);
> > > - if (metablock == NULL) {
> > > - print_warning("memory allocation failure");
> > > - return 0;
> > > - }
> > > - metablock->mb_blocklog = BBSHIFT;
> > > - metablock->mb_magic = cpu_to_be32(XFS_MD_MAGIC);
> > > -
> > > - /* Set flags about state of metadump */
> > > - metablock->mb_info = XFS_METADUMP_INFO_FLAGS;
> > > - if (obfuscate)
> > > - metablock->mb_info |= XFS_METADUMP_OBFUSCATED;
> > > - if (!zero_stale_data)
> > > - metablock->mb_info |= XFS_METADUMP_FULLBLOCKS;
> > > -
> > > /* If we'll copy the log, see if the log is dirty */
> > > if (mp->m_sb.sb_logstart) {
> > > push_cur();
> > > @@ -3060,34 +3071,52 @@ metadump_f(
> > > struct xlog log;
> > >
> > > if (xlog_is_dirty(mp, &log, &x, 0))
> > > - metablock->mb_info |= XFS_METADUMP_DIRTYLOG;
> > > + metadump.dirty_log = true;
> > > }
> > > pop_cur();
> > > }
> > >
> > > - block_index = (__be64 *)((char *)metablock + sizeof(xfs_metablock_t));
> > > - block_buffer = (char *)metablock + BBSIZE;
> > > - num_indices = (BBSIZE - sizeof(xfs_metablock_t)) / sizeof(__be64);
> > > + metadump.metablock = (xfs_metablock_t *)calloc(BBSIZE + 1, BBSIZE);
> > > + if (metadump.metablock == NULL) {
> > > + print_warning("memory allocation failure");
> > > + return -1;
> > > + }
> > > + metadump.metablock->mb_blocklog = BBSHIFT;
> > > + metadump.metablock->mb_magic = cpu_to_be32(XFS_MD_MAGIC);
> > > +
> > > + /* Set flags about state of metadump */
> > > + metadump.metablock->mb_info = XFS_METADUMP_INFO_FLAGS;
> > > + if (metadump.obfuscate)
> > > + metadump.metablock->mb_info |= XFS_METADUMP_OBFUSCATED;
> > > + if (!metadump.zero_stale_data)
> > > + metadump.metablock->mb_info |= XFS_METADUMP_FULLBLOCKS;
> > > + if (metadump.dirty_log)
> > > + metadump.metablock->mb_info |= XFS_METADUMP_DIRTYLOG;
> > > +
> > > + metadump.block_index = (__be64 *)((char *)metadump.metablock +
> > > + sizeof(xfs_metablock_t));
> > > + metadump.block_buffer = (char *)metadump.metablock + BBSIZE;
> > > + metadump.num_indices = (BBSIZE - sizeof(xfs_metablock_t)) /
> > > + sizeof(__be64);
> > >
> > > /*
> > > * A metadump block can hold at most num_indices of BBSIZE sectors;
> > > * do not try to dump a filesystem with a sector size which does not
> > > * fit within num_indices (i.e. within a single metablock).
> > > */
> > > - if (mp->m_sb.sb_sectsize > num_indices * BBSIZE) {
> > > + if (mp->m_sb.sb_sectsize > metadump.num_indices * BBSIZE) {
> > > print_warning("Cannot dump filesystem with sector size %u",
> > > mp->m_sb.sb_sectsize);
> > > - free(metablock);
> > > + free(metadump.metablock);
> > > return 0;
> > > }
> > >
> > > - cur_index = 0;
> > > start_iocur_sp = iocur_sp;
> > >
> > > if (strcmp(argv[optind], "-") == 0) {
> > > if (isatty(fileno(stdout))) {
> > > print_warning("cannot write to a terminal");
> > > - free(metablock);
> > > + free(metadump.metablock);
> > > return 0;
> > > }
> > > /*
> > > @@ -3111,17 +3140,17 @@ metadump_f(
> > > close(outfd);
> > > goto out;
> > > }
> > > - outf = fdopen(outfd, "a");
> > > - if (outf == NULL) {
> > > + metadump.outf = fdopen(outfd, "a");
> > > + if (metadump.outf == NULL) {
> > > fprintf(stderr, "cannot create dump stream\n");
> > > dup2(outfd, STDOUT_FILENO);
> > > close(outfd);
> > > goto out;
> > > }
> > > - stdout_metadump = true;
> > > + metadump.stdout_metadump = true;
> > > } else {
> > > - outf = fopen(argv[optind], "wb");
> > > - if (outf == NULL) {
> > > + metadump.outf = fopen(argv[optind], "wb");
> > > + if (metadump.outf == NULL) {
> > > print_warning("cannot create dump file");
> > > goto out;
> > > }
> > > @@ -3148,24 +3177,24 @@ metadump_f(
> > > if (!exitcode)
> > > exitcode = write_index() < 0;
> > >
> > > - if (progress_since_warning)
> > > - fputc('\n', stdout_metadump ? stderr : stdout);
> > > + if (metadump.progress_since_warning)
> > > + fputc('\n', metadump.stdout_metadump ? stderr : stdout);
> > >
> > > - if (stdout_metadump) {
> > > - fflush(outf);
> > > + if (metadump.stdout_metadump) {
> > > + fflush(metadump.outf);
> > > fflush(stdout);
> > > ret = dup2(outfd, STDOUT_FILENO);
> > > if (ret < 0)
> > > perror("un-redirecting stdout");
> > > - stdout_metadump = false;
> > > + metadump.stdout_metadump = false;
> > > }
> > > - fclose(outf);
> > > + fclose(metadump.outf);
> > >
> > > /* cleanup iocur stack */
> > > while (iocur_sp > start_iocur_sp)
> > > pop_cur();
> > > out:
> > > - free(metablock);
> > > + free(metadump.metablock);
> > >
> > > return 0;
> > > }
> > > --
> > > 2.39.1
> > >
next prev parent reply other threads:[~2023-07-20 17:22 UTC|newest]
Thread overview: 54+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <2ExBvYxYPnyiGvOJzODNvNXx_bfn5RWAck_7UcV7OvxkF6fgAy6UZtI6d2-FdmxoIeBLPPX0vwW9uaJxBa5Rmg==@protonmail.internalid>
2023-06-06 9:27 ` [PATCH V2 00/23] Metadump v2 Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 01/23] metadump: Use boolean values true/false instead of 1/0 Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 02/23] mdrestore: Fix logic used to check if target device is large enough Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 03/23] metadump: Declare boolean variables with bool type Chandan Babu R
2023-06-06 15:17 ` Darrick J. Wong
2023-06-06 9:27 ` [PATCH V2 04/23] metadump: Define and use struct metadump Chandan Babu R
2023-07-12 18:12 ` Darrick J. Wong
2023-07-20 13:13 ` Carlos Maiolino
2023-07-20 17:22 ` Darrick J. Wong [this message]
2023-06-06 9:27 ` [PATCH V2 05/23] metadump: Add initialization and release functions Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 06/23] metadump: Postpone invocation of init_metadump() Chandan Babu R
2023-07-12 17:00 ` Darrick J. Wong
2023-06-06 9:27 ` [PATCH V2 07/23] metadump: Introduce struct metadump_ops Chandan Babu R
2023-07-12 17:06 ` Darrick J. Wong
2023-06-06 9:27 ` [PATCH V2 08/23] metadump: Introduce metadump v1 operations Chandan Babu R
2023-07-12 17:10 ` Darrick J. Wong
2023-07-13 4:36 ` Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 09/23] metadump: Rename XFS_MD_MAGIC to XFS_MD_MAGIC_V1 Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 10/23] metadump: Define metadump v2 ondisk format structures and macros Chandan Babu R
2023-07-12 17:18 ` Darrick J. Wong
2023-07-13 4:37 ` Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 11/23] metadump: Define metadump ops for v2 format Chandan Babu R
2023-07-12 17:22 ` Darrick J. Wong
2023-07-13 4:45 ` Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 12/23] xfs_db: Add support to read from external log device Chandan Babu R
2023-07-12 17:35 ` Darrick J. Wong
2023-07-13 5:24 ` Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 13/23] metadump: Add support for passing version option Chandan Babu R
2023-06-06 9:27 ` [PATCH V2 14/23] mdrestore: Declare boolean variables with bool type Chandan Babu R
2023-07-12 17:35 ` Darrick J. Wong
2023-06-06 9:27 ` [PATCH V2 15/23] mdrestore: Define and use struct mdrestore Chandan Babu R
2023-07-12 18:12 ` Darrick J. Wong
2023-06-06 9:27 ` [PATCH V2 16/23] mdrestore: Detect metadump v1 magic before reading the header Chandan Babu R
2023-07-12 17:38 ` Darrick J. Wong
2023-06-06 9:28 ` [PATCH V2 17/23] mdrestore: Add open_device(), read_header() and show_info() functions Chandan Babu R
2023-07-12 17:46 ` Darrick J. Wong
2023-07-13 5:27 ` Chandan Babu R
2023-06-06 9:28 ` [PATCH V2 18/23] mdrestore: Introduce struct mdrestore_ops Chandan Babu R
2023-06-06 9:28 ` [PATCH V2 19/23] mdrestore: Replace metadump header pointer argument with generic pointer type Chandan Babu R
2023-07-12 17:55 ` Darrick J. Wong
2023-07-13 6:08 ` Chandan Babu R
2023-06-06 9:28 ` [PATCH V2 20/23] mdrestore: Introduce mdrestore v1 operations Chandan Babu R
2023-07-12 17:57 ` Darrick J. Wong
2023-06-06 9:28 ` [PATCH V2 21/23] mdrestore: Extract target device size verification into a function Chandan Babu R
2023-06-06 9:28 ` [PATCH V2 22/23] mdrestore: Define mdrestore ops for v2 format Chandan Babu R
2023-07-12 18:10 ` Darrick J. Wong
2023-07-13 6:27 ` Chandan Babu R
2023-07-13 14:22 ` Darrick J. Wong
2023-06-06 9:28 ` [PATCH V2 23/23] mdrestore: Add support for passing log device as an argument Chandan Babu R
2023-07-12 18:10 ` Darrick J. Wong
[not found] ` <181e7cbefa39e2dc59f2564c25966ac0d05aa6530483b7eb5d649de9a3d1cf7f@mu.id>
2023-07-13 6:48 ` Chandan Babu R
2023-06-06 12:10 ` [PATCH V2 00/23] Metadump v2 Carlos Maiolino
2023-06-06 12:38 ` Chandan Babu R
2023-06-06 16:04 ` Carlos Maiolino
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230720172234.GJ11352@frogsfrogsfrogs \
--to=djwong@kernel.org \
--cc=cem@kernel.org \
--cc=chandan.babu@oracle.com \
--cc=linux-xfs@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.