xfs_db: update field printing for dir crc format changes.

Note that this also requires changing the type parsing to only
allow dir3 data block parsing on CRC enabled filesystems. This is
slighly more complex than it needs to be  because of the way the
type table is walked and the assumption that all the entries are in
type number order.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

diff --git a/db/dir2.c b/db/dir2.c
index 594d9d2f9c18b40067eb0baccc5bdbae14d7cf2c..85240b098a3bbfc5febc75d0ad4a22e7ae32939d 100644 (file)
--- a/db/dir2.c
+++ b/db/dir2.c
@@ -260,24 +260,34 @@ dir2_block_hdr_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_data_hdr *block;
+       struct xfs_dir2_data_hdr *block = obj;
 
        ASSERT(startoff == 0);
-       block = obj;
        return be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC;
 }
 
+static int
+dir3_block_hdr_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir2_data_hdr *block = obj;
+
+       ASSERT(startoff == 0);
+       return be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC;
+}
+
 static int
 dir2_block_leaf_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_data_hdr *block;
+       struct xfs_dir2_data_hdr *block = obj;
        struct xfs_dir2_block_tail *btp;
 
        ASSERT(startoff == 0);
-       block = obj;
-       if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC)
+       if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC &&
+           be32_to_cpu(block->magic) != XFS_DIR3_BLOCK_MAGIC)
                return 0;
        btp = xfs_dir2_block_tail_p(mp, block);
        return be32_to_cpu(btp->count);
@@ -289,13 +299,13 @@ dir2_block_leaf_offset(
        int                     startoff,
        int                     idx)
 {
-       struct xfs_dir2_data_hdr *block;
+       struct xfs_dir2_data_hdr *block = obj;
        struct xfs_dir2_block_tail *btp;
        struct xfs_dir2_leaf_entry *lep;
 
        ASSERT(startoff == 0);
-       block = obj;
-       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC ||
+              be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC);
        btp = xfs_dir2_block_tail_p(mp, block);
        lep = xfs_dir2_block_leaf_p(btp) + idx;
        return bitize((int)((char *)lep - (char *)block));
@@ -306,14 +316,23 @@ dir2_block_tail_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_data_hdr *block;
+       struct xfs_dir2_data_hdr *block = obj;
 
        ASSERT(startoff == 0);
-       block = obj;
        return be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_block_tail_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir2_data_hdr *block = obj;
+
+       ASSERT(startoff == 0);
+       return be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC;
+}
+
 static int
 dir2_block_tail_offset(
        void                    *obj,
@@ -322,7 +341,8 @@ dir2_block_tail_offset(
 {
        struct xfs_dir2_data_hdr *block = obj;
 
-       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC ||
+              be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC);
        return __dir2_block_tail_offset(block, startoff, idx);
 }
 
@@ -335,7 +355,8 @@ dir2_block_u_count(
        struct xfs_dir2_block_tail *btp;
 
        ASSERT(startoff == 0);
-       if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC)
+       if (be32_to_cpu(block->magic) != XFS_DIR2_BLOCK_MAGIC &&
+           be32_to_cpu(block->magic) != XFS_DIR3_BLOCK_MAGIC)
                return 0;
 
        btp = xfs_dir2_block_tail_p(mp, block);
@@ -354,7 +375,8 @@ dir2_block_u_offset(
        char                    *ptr;
 
        ASSERT(startoff == 0);
-       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC);
+       ASSERT(be32_to_cpu(block->magic) == XFS_DIR2_BLOCK_MAGIC ||
+              be32_to_cpu(block->magic) == XFS_DIR3_BLOCK_MAGIC);
        btp = xfs_dir2_block_tail_p(mp, block);
        ptr = __dir2_data_entry_offset((char *)xfs_dir3_data_unused_p(block),
                                       (char *)xfs_dir2_block_leaf_p(btp), idx);
@@ -479,7 +501,6 @@ dir2_data_union_tag_count(
        return end <= (char *)obj + mp->m_dirblksize;
 }
 
-/*ARGSUSED*/
 static int
 dir2_data_union_tag_offset(
        void                    *obj,
@@ -500,20 +521,28 @@ dir2_data_union_tag_offset(
                            (char *)dep));
 }
 
-/*ARGSUSED*/
 static int
 dir2_data_hdr_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_data_hdr *data;
+       struct xfs_dir2_data_hdr *data = obj;
 
        ASSERT(startoff == 0);
-       data = obj;
        return be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_data_hdr_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir2_data_hdr *data = obj;
+
+       ASSERT(startoff == 0);
+       return be32_to_cpu(data->magic) == XFS_DIR3_DATA_MAGIC;
+}
+
 static int
 dir2_data_u_count(
        void                    *obj,
@@ -522,7 +551,8 @@ dir2_data_u_count(
        struct xfs_dir2_data_hdr *data = obj;
 
        ASSERT(startoff == 0);
-       if (be32_to_cpu(data->magic) != XFS_DIR2_DATA_MAGIC)
+       if (be32_to_cpu(data->magic) != XFS_DIR2_DATA_MAGIC &&
+           be32_to_cpu(data->magic) != XFS_DIR3_DATA_MAGIC)
                return 0;
 
        return __dir2_data_entries_count((char *)xfs_dir3_data_unused_p(data),
@@ -539,7 +569,8 @@ dir2_data_u_offset(
        char                    *ptr;
 
        ASSERT(startoff == 0);
-       ASSERT(be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC);
+       ASSERT(be32_to_cpu(data->magic) == XFS_DIR2_DATA_MAGIC ||
+              be32_to_cpu(data->magic) == XFS_DIR3_DATA_MAGIC);
        ptr = __dir2_data_entry_offset((char *)xfs_dir3_data_unused_p(data),
                                       (char *)data + mp->m_dirblksize, idx);
        return bitize((int)(ptr - (char *)data));
@@ -565,160 +596,236 @@ dir2_data_union_size(
        }
 }
 
-/*ARGSUSED*/
+/*
+ * Free block functions
+ */
 static int
 dir2_free_bests_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_free    *free;
+       struct xfs_dir2_free    *free = obj;
 
        ASSERT(startoff == 0);
-       free = obj;
        if (be32_to_cpu(free->hdr.magic) != XFS_DIR2_FREE_MAGIC)
                return 0;
        return be32_to_cpu(free->hdr.nvalid);
 }
 
-/*ARGSUSED*/
+static int
+dir3_free_bests_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir3_free    *free = obj;
+
+       ASSERT(startoff == 0);
+       if (be32_to_cpu(free->hdr.hdr.magic) != XFS_DIR3_FREE_MAGIC)
+               return 0;
+       return be32_to_cpu(free->hdr.nvalid);
+}
+
 static int
 dir2_free_hdr_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_free    *free;
+       struct xfs_dir2_free    *free = obj;
 
        ASSERT(startoff == 0);
-       free = obj;
        return be32_to_cpu(free->hdr.magic) == XFS_DIR2_FREE_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_free_hdr_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir3_free    *free = obj;
+
+       ASSERT(startoff == 0);
+       return be32_to_cpu(free->hdr.hdr.magic) == XFS_DIR3_FREE_MAGIC;
+}
+
+/*
+ * Leaf block functions
+ */
 static int
 dir2_leaf_bests_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
        struct xfs_dir2_leaf_tail *ltp;
 
        ASSERT(startoff == 0);
-       leaf = obj;
-       if (be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR2_LEAF1_MAGIC)
+       if (be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR2_LEAF1_MAGIC &&
+           be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR3_LEAF1_MAGIC)
                return 0;
        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
        return be32_to_cpu(ltp->bestcount);
 }
 
-/*ARGSUSED*/
 static int
 dir2_leaf_bests_offset(
        void                    *obj,
        int                     startoff,
        int                     idx)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
        struct xfs_dir2_leaf_tail *ltp;
        __be16                  *lbp;
 
        ASSERT(startoff == 0);
-       leaf = obj;
-       ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
+       ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC ||
+              be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR3_LEAF1_MAGIC);
        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
        lbp = xfs_dir2_leaf_bests_p(ltp) + idx;
        return bitize((int)((char *)lbp - (char *)leaf));
 }
 
-/*ARGSUSED*/
 static int
 dir2_leaf_ents_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
 
        ASSERT(startoff == 0);
-       leaf = obj;
        if (be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR2_LEAF1_MAGIC &&
            be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR2_LEAFN_MAGIC)
                return 0;
        return be16_to_cpu(leaf->hdr.count);
 }
 
-/*ARGSUSED*/
+static int
+dir3_leaf_ents_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir3_leaf    *leaf = obj;
+
+       ASSERT(startoff == 0);
+       if (be16_to_cpu(leaf->hdr.info.hdr.magic) != XFS_DIR3_LEAF1_MAGIC &&
+           be16_to_cpu(leaf->hdr.info.hdr.magic) != XFS_DIR3_LEAFN_MAGIC)
+               return 0;
+       return be16_to_cpu(leaf->hdr.count);
+}
+
 static int
 dir2_leaf_hdr_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
 
        ASSERT(startoff == 0);
-       leaf = obj;
        return be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC ||
               be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAFN_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_leaf_hdr_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir3_leaf    *leaf = obj;
+
+       ASSERT(startoff == 0);
+       return be16_to_cpu(leaf->hdr.info.hdr.magic) == XFS_DIR3_LEAF1_MAGIC ||
+              be16_to_cpu(leaf->hdr.info.hdr.magic) == XFS_DIR3_LEAFN_MAGIC;
+}
+
 static int
 dir2_leaf_tail_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
 
        ASSERT(startoff == 0);
-       leaf = obj;
        return be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_leaf_tail_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_dir3_leaf    *leaf = obj;
+
+       ASSERT(startoff == 0);
+       return be16_to_cpu(leaf->hdr.info.hdr.magic) == XFS_DIR3_LEAF1_MAGIC;
+}
+
 static int
 dir2_leaf_tail_offset(
        void                    *obj,
        int                     startoff,
        int                     idx)
 {
-       struct xfs_dir2_leaf    *leaf;
+       struct xfs_dir2_leaf    *leaf = obj;
        struct xfs_dir2_leaf_tail *ltp;
 
        ASSERT(startoff == 0);
        ASSERT(idx == 0);
-       leaf = obj;
-       ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
+       ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC ||
+              be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR3_LEAF1_MAGIC);
        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
        return bitize((int)((char *)ltp - (char *)leaf));
 }
 
-/*ARGSUSED*/
+/*
+ * Node format functions
+ */
 static int
 dir2_node_btree_count(
        void                    *obj,
        int                     startoff)
 {
-       xfs_da_intnode_t        *node;
+       xfs_da_intnode_t        *node = obj;
 
        ASSERT(startoff == 0);
-       node = obj;
        if (be16_to_cpu(node->hdr.info.magic) != XFS_DA_NODE_MAGIC)
                return 0;
        return be16_to_cpu(node->hdr.__count);
 }
 
-/*ARGSUSED*/
+static int
+dir3_node_btree_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_da3_intnode  *node = obj;
+
+       ASSERT(startoff == 0);
+       if (be16_to_cpu(node->hdr.info.hdr.magic) != XFS_DA3_NODE_MAGIC)
+               return 0;
+       return be16_to_cpu(node->hdr.__count);
+}
+
 static int
 dir2_node_hdr_count(
        void                    *obj,
        int                     startoff)
 {
-       struct xfs_da_intnode   *node;
+       struct xfs_da_intnode   *node = obj;
 
        ASSERT(startoff == 0);
-       node = obj;
        return be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC;
 }
 
-/*ARGSUSED*/
+static int
+dir3_node_hdr_count(
+       void                    *obj,
+       int                     startoff)
+{
+       struct xfs_da3_intnode  *node = obj;
+
+       ASSERT(startoff == 0);
+       return be16_to_cpu(node->hdr.info.hdr.magic) == XFS_DA3_NODE_MAGIC;
+}
+
 int
 dir2_size(
        void    *obj,
@@ -727,3 +834,105 @@ dir2_size(
 {
        return bitize(mp->m_dirblksize);
 }
+
+/*
+ * CRC enabled structure definitions
+ */
+const field_t  dir3_hfld[] = {
+       { "", FLDT_DIR3, OI(0), C1, 0, TYP_NONE },
+       { NULL }
+};
+
+#define        B3OFF(f)        bitize(offsetof(struct xfs_dir3_data_hdr, f))
+#define        D3OFF(f)        bitize(offsetof(struct xfs_dir3_data_hdr, f))
+#define        F3OFF(f)        bitize(offsetof(struct xfs_dir3_free, f))
+#define        L3OFF(f)        bitize(offsetof(struct xfs_dir3_leaf, f))
+#define        N3OFF(f)        bitize(offsetof(struct xfs_da3_intnode, f))
+const field_t  dir3_flds[] = {
+       { "bhdr", FLDT_DIR3_DATA_HDR, OI(B3OFF(hdr)), dir3_block_hdr_count,
+         FLD_COUNT, TYP_NONE },
+       { "bu", FLDT_DIR2_DATA_UNION, dir2_block_u_offset, dir2_block_u_count,
+         FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "bleaf", FLDT_DIR2_LEAF_ENTRY, dir2_block_leaf_offset,
+         dir2_block_leaf_count, FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "btail", FLDT_DIR2_BLOCK_TAIL, dir2_block_tail_offset,
+         dir3_block_tail_count, FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "dhdr", FLDT_DIR3_DATA_HDR, OI(D3OFF(hdr)), dir3_data_hdr_count,
+         FLD_COUNT, TYP_NONE },
+       { "du", FLDT_DIR2_DATA_UNION, dir2_data_u_offset, dir2_data_u_count,
+         FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "lhdr", FLDT_DIR3_LEAF_HDR, OI(L3OFF(hdr)), dir3_leaf_hdr_count,
+         FLD_COUNT, TYP_NONE },
+       { "lbests", FLDT_DIR2_DATA_OFF, dir2_leaf_bests_offset,
+         dir2_leaf_bests_count, FLD_ARRAY|FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "lents", FLDT_DIR2_LEAF_ENTRY, OI(L3OFF(__ents)), dir3_leaf_ents_count,
+         FLD_ARRAY|FLD_COUNT, TYP_NONE },
+       { "ltail", FLDT_DIR2_LEAF_TAIL, dir2_leaf_tail_offset,
+         dir3_leaf_tail_count, FLD_OFFSET|FLD_COUNT, TYP_NONE },
+       { "nhdr", FLDT_DA3_NODE_HDR, OI(N3OFF(hdr)), dir3_node_hdr_count,
+         FLD_COUNT, TYP_NONE },
+       { "nbtree", FLDT_DA_NODE_ENTRY, OI(N3OFF(__btree)), dir3_node_btree_count,
+         FLD_ARRAY|FLD_COUNT, TYP_NONE },
+       { "fhdr", FLDT_DIR3_FREE_HDR, OI(F3OFF(hdr)), dir3_free_hdr_count,
+         FLD_COUNT, TYP_NONE },
+       { "fbests", FLDT_DIR2_DATA_OFFNZ, OI(F3OFF(bests)),
+         dir3_free_bests_count, FLD_ARRAY|FLD_COUNT, TYP_NONE },
+       { NULL }
+};
+
+#define        DBH3OFF(f)      bitize(offsetof(struct xfs_dir3_blk_hdr, f))
+const field_t  dir3_blkhdr_flds[] = {
+       { "magic", FLDT_UINT32X, OI(DBH3OFF(magic)), C1, 0, TYP_NONE },
+       { "crc", FLDT_UINT32X, OI(DBH3OFF(crc)), C1, 0, TYP_NONE },
+       { "bno", FLDT_DFSBNO, OI(DBH3OFF(blkno)), C1, 0, TYP_BMAPBTD },
+       { "lsn", FLDT_UINT64X, OI(DBH3OFF(lsn)), C1, 0, TYP_NONE },
+       { "uuid", FLDT_UUID, OI(DBH3OFF(uuid)), C1, 0, TYP_NONE },
+       { "owner", FLDT_INO, OI(DBH3OFF(owner)), C1, 0, TYP_NONE },
+       { NULL }
+};
+
+#define        DH3OFF(f)       bitize(offsetof(struct xfs_dir3_data_hdr, f))
+const field_t  dir3_data_hdr_flds[] = {
+       { "hdr", FLDT_DIR3_BLKHDR, OI(DH3OFF(hdr)), C1, 0, TYP_NONE },
+       { "bestfree", FLDT_DIR2_DATA_FREE, OI(DH3OFF(best_free)),
+         CI(XFS_DIR2_DATA_FD_COUNT), FLD_ARRAY, TYP_NONE },
+       { NULL }
+};
+
+#define        LH3OFF(f)       bitize(offsetof(struct xfs_dir3_leaf_hdr, f))
+const field_t  dir3_leaf_hdr_flds[] = {
+       { "info", FLDT_DA3_BLKINFO, OI(LH3OFF(info)), C1, 0, TYP_NONE },
+       { "count", FLDT_UINT16D, OI(LH3OFF(count)), C1, 0, TYP_NONE },
+       { "stale", FLDT_UINT16D, OI(LH3OFF(stale)), C1, 0, TYP_NONE },
+       { NULL }
+};
+
+#define        FH3OFF(f)       bitize(offsetof(struct xfs_dir3_free_hdr, f))
+const field_t  dir3_free_hdr_flds[] = {
+       { "hdr", FLDT_DIR3_BLKHDR, OI(FH3OFF(hdr)), C1, 0, TYP_NONE },
+       { "firstdb", FLDT_INT32D, OI(FH3OFF(firstdb)), C1, 0, TYP_NONE },
+       { "nvalid", FLDT_INT32D, OI(FH3OFF(nvalid)), C1, 0, TYP_NONE },
+       { "nused", FLDT_INT32D, OI(FH3OFF(nused)), C1, 0, TYP_NONE },
+       { NULL }
+};
+
+
+#define        DB3OFF(f)       bitize(offsetof(struct xfs_da3_blkinfo, f))
+const field_t  da3_blkinfo_flds[] = {
+       { "hdr", FLDT_DA_BLKINFO, OI(DB3OFF(hdr)), C1, 0, TYP_NONE },
+       { "crc", FLDT_UINT32X, OI(DB3OFF(crc)), C1, 0, TYP_NONE },
+       { "bno", FLDT_DFSBNO, OI(DB3OFF(blkno)), C1, 0, TYP_BMAPBTD },
+       { "lsn", FLDT_UINT64X, OI(DB3OFF(lsn)), C1, 0, TYP_NONE },
+       { "uuid", FLDT_UUID, OI(DB3OFF(uuid)), C1, 0, TYP_NONE },
+       { "owner", FLDT_INO, OI(DB3OFF(owner)), C1, 0, TYP_NONE },
+       { NULL }
+};
+
+#define        H3OFF(f)        bitize(offsetof(struct xfs_da3_node_hdr, f))
+const field_t  da3_node_hdr_flds[] = {
+       { "info", FLDT_DA3_BLKINFO, OI(H3OFF(info)), C1, 0, TYP_NONE },
+       { "count", FLDT_UINT16D, OI(H3OFF(__count)), C1, 0, TYP_NONE },
+       { "level", FLDT_UINT16D, OI(H3OFF(__level)), C1, 0, TYP_NONE },
+       { "pad", FLDT_UINT32D, OI(H3OFF(__pad32)), C1, 0, TYP_NONE },
+       { NULL }
+};

diff --git a/db/dir2.h b/db/dir2.h
index 05ab354a6f3981c7728391f5cdc26d49ab93dd31..d9dc27bba6929841289bc3f60234c7b430d6dec5 100644 (file)
--- a/db/dir2.h
+++ b/db/dir2.h
@@ -16,21 +16,42 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
-extern const field_t   dir2_flds[];
-extern const field_t   dir2_hfld[];
+/*
+ * common types across directory formats
+ */
 extern const field_t   dir2_block_tail_flds[];
 extern const field_t   dir2_data_free_flds[];
-extern const field_t   dir2_data_hdr_flds[];
 extern const field_t   dir2_data_union_flds[];
-extern const field_t   dir2_free_hdr_flds[];
+extern const field_t   dir2_leaf_tail_flds[];
 extern const field_t   dir2_leaf_entry_flds[];
+
+extern const field_t   da_node_entry_flds[];
+
+/*
+ * dirv2 specific types
+ */
+extern const field_t   dir2_flds[];
+extern const field_t   dir2_hfld[];
+extern const field_t   dir2_data_hdr_flds[];
+extern const field_t   dir2_free_hdr_flds[];
 extern const field_t   dir2_leaf_hdr_flds[];
-extern const field_t   dir2_leaf_tail_flds[];
 
 extern const field_t   da_blkinfo_flds[];
-extern const field_t   da_node_entry_flds[];
 extern const field_t   da_node_hdr_flds[];
 
+/*
+ * dirv3 specific types
+ */
+extern const field_t   dir3_flds[];
+extern const field_t   dir3_hfld[];
+extern const field_t   dir3_blkhdr_flds[];
+extern const field_t   dir3_data_hdr_flds[];
+extern const field_t   dir3_free_hdr_flds[];
+extern const field_t   dir3_leaf_hdr_flds[];
+
+extern const field_t   da3_blkinfo_flds[];
+extern const field_t   da3_node_hdr_flds[];
+
 static inline xfs_dir2_inou_t *xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep)
 {
        return (xfs_dir2_inou_t *)&(sfep)->name[(sfep)->namelen];

diff --git a/db/field.c b/db/field.c
index 510ad848ac3eed1cb686e84bd1432660d4c150eb..cb153185e51719a7090930d64ce578bdcf5ca4a2 100644 (file)
--- a/db/field.c
+++ b/db/field.c
@@ -166,6 +166,8 @@ const ftattr_t      ftattrtab[] = {
          FTARG_SIZE|FTARG_OKEMPTY, NULL, inode_u_flds },
        { FLDT_DINODE_V3, "dinode_v3", NULL, (char *)inode_v3_flds,
          SI(bitsz(xfs_dinode_t)), 0, NULL, inode_v3_flds },
+
+/* dir v2 fields */
        { FLDT_DIR2, "dir2", NULL, (char *)dir2_flds, dir2_size, FTARG_SIZE,
          NULL, dir2_flds },
        { FLDT_DIR2_BLOCK_TAIL, "dir2_block_tail", NULL,
@@ -207,6 +209,20 @@ const ftattr_t     ftattrtab[] = {
          SI(bitsz(xfs_dir2_sf_off_t)), 0, NULL, NULL },
        { FLDT_DIR2SF, "dir2sf", NULL, (char *)dir2sf_flds, dir2sf_size,
          FTARG_SIZE, NULL, dir2sf_flds },
+
+/* dir v3 fields */
+       { FLDT_DIR3, "dir3", NULL, (char *)dir3_flds, dir2_size, FTARG_SIZE,
+         NULL, dir3_flds },
+       { FLDT_DIR3_BLKHDR, "dir3_blk_hdr", NULL, (char *)dir3_blkhdr_flds,
+         SI(bitsz(struct xfs_dir3_blk_hdr)), 0, NULL, dir3_blkhdr_flds },
+       { FLDT_DIR3_DATA_HDR, "dir3_data_hdr", NULL, (char *)dir3_data_hdr_flds,
+         SI(bitsz(struct xfs_dir3_data_hdr)), 0, NULL, dir3_data_hdr_flds },
+       { FLDT_DIR3_FREE_HDR, "dir3_free_hdr", NULL, (char *)dir3_free_hdr_flds,
+         SI(bitsz(struct xfs_dir3_free_hdr)), 0, NULL, dir3_free_hdr_flds },
+       { FLDT_DIR3_LEAF_HDR, "dir3_leaf_hdr", NULL, (char *)dir3_leaf_hdr_flds,
+         SI(bitsz(struct xfs_dir3_leaf_hdr)), 0, NULL, dir3_leaf_hdr_flds },
+
+/* dir v2/3 node fields */
        { FLDT_DA_BLKINFO, "dir_blkinfo", NULL, (char *)da_blkinfo_flds,
          SI(bitsz(struct xfs_da_blkinfo)), 0, NULL, da_blkinfo_flds },
        { FLDT_DA_NODE_ENTRY, "dir_node_entry", fp_sarray,
@@ -214,6 +230,11 @@ const ftattr_t     ftattrtab[] = {
          NULL, da_node_entry_flds },
        { FLDT_DA_NODE_HDR, "dir_node_hdr", NULL, (char *)da_node_hdr_flds,
          SI(bitsz(struct xfs_da_node_hdr)), 0, NULL, da_node_hdr_flds },
+       { FLDT_DA3_BLKINFO, "dir_blkinfo", NULL, (char *)da3_blkinfo_flds,
+         SI(bitsz(struct xfs_da3_blkinfo)), 0, NULL, da3_blkinfo_flds },
+       { FLDT_DA3_NODE_HDR, "dir_node_hdr", NULL, (char *)da3_node_hdr_flds,
+         SI(bitsz(struct xfs_da3_node_hdr)), 0, NULL, da3_node_hdr_flds },
+
        { FLDT_DIRBLOCK, "dirblock", fp_num, "%u", SI(bitsz(__uint32_t)), 0,
          fa_dirblock, NULL },
        { FLDT_DISK_DQUOT, "disk_dquot", NULL, (char *)disk_dquot_flds,

diff --git a/db/field.h b/db/field.h
index 9b332f5d33b6c706383c0bb3de252bd5744ed35d..56715716865f25dbcbdcccad52c3f8eb293733ea 100644 (file)
--- a/db/field.h
+++ b/db/field.h
@@ -81,6 +81,8 @@ typedef enum fldt     {
        FLDT_DINODE_FMT,
        FLDT_DINODE_U,
        FLDT_DINODE_V3,
+
+       /* dir v2 fields */
        FLDT_DIR2,
        FLDT_DIR2_BLOCK_TAIL,
        FLDT_DIR2_DATA_FREE,
@@ -99,9 +101,21 @@ typedef enum fldt   {
        FLDT_DIR2_SF_HDR,
        FLDT_DIR2_SF_OFF,
        FLDT_DIR2SF,
+
+       /* dir v3 fields */
+       FLDT_DIR3,
+       FLDT_DIR3_BLKHDR,
+       FLDT_DIR3_DATA_HDR,
+       FLDT_DIR3_FREE_HDR,
+       FLDT_DIR3_LEAF_HDR,
+
+       /* dir v2/3 node fields */
        FLDT_DA_BLKINFO,
        FLDT_DA_NODE_ENTRY,
        FLDT_DA_NODE_HDR,
+       FLDT_DA3_BLKINFO,
+       FLDT_DA3_NODE_HDR,
+
        FLDT_DIRBLOCK,
        FLDT_DISK_DQUOT,
        FLDT_DQBLK,

diff --git a/db/type.c b/db/type.c
index 97f3548f24863bc156547a2edd442a873b0a8e89..7738db5e2a5d7920583ef76805ea4135838293c5 100644 (file)
--- a/db/type.c
+++ b/db/type.c
@@ -82,7 +82,7 @@ static const typ_t    __typtab_crc[] = {
        { TYP_BNOBT, "bnobt", handle_struct, bnobt_crc_hfld },
        { TYP_CNTBT, "cntbt", handle_struct, cntbt_crc_hfld },
        { TYP_DATA, "data", handle_block, NULL },
-       { TYP_DIR2, "dir2", handle_struct, dir2_hfld },
+       { TYP_DIR2, "dir3", handle_struct, dir3_hfld },
        { TYP_DQBLK, "dqblk", handle_struct, dqblk_hfld },
        { TYP_INOBT, "inobt", handle_struct, inobt_crc_hfld },
        { TYP_INODATA, "inodata", NULL, NULL },
@@ -110,9 +110,9 @@ findtyp(
 {
        const typ_t     *tt;
 
-       for (tt = typtab; tt->name != NULL; tt++) {
+       for (tt = typtab; tt->typnm != TYP_NONE; tt++) {
                ASSERT(tt->typnm == (typnm_t)(tt - typtab));
-               if (strcmp(tt->name, name) == 0)
+               if (tt->name && strcmp(tt->name, name) == 0)
                        return tt;
        }
        return NULL;
@@ -133,12 +133,14 @@ type_f(
                        dbprintf(_("current type is \"%s\"\n"), cur_typ->name);
 
                dbprintf(_("\n supported types are:\n "));
-               for (tt = typtab, count = 0; tt->name != NULL; tt++) {
+               for (tt = typtab, count = 0; tt->typnm != TYP_NONE; tt++) {
+                       if (tt->name == NULL)
+                               continue;
                        if ((tt+1)->name != NULL) {
                                dbprintf("%s, ", tt->name);
                                if ((++count % 8) == 0)
                                        dbprintf("\n ");
-                       } else {
+                       } else if ((tt+1)->typnm == TYP_NONE) {
                                dbprintf("%s\n", tt->name);
                        }
                }