xfs_logprint: dump new attr log item fields

Dump the new extended attribute log item fields.  This was split out
from the previous patch to make libxfs resyncing easier.  This code
needs more cleaning, which we'll do in the next few patches before
moving on to the parent pointer code.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>

diff --git a/logprint/log_redo.c b/logprint/log_redo.c
index ca6dadd7551a5bc6cf685a4aaad51c6480f6c165..1d55164a90ffe4b669092b2f472b69fa5800fae6 100644 (file)
--- a/logprint/log_redo.c
+++ b/logprint/log_redo.c
@@ -674,6 +674,12 @@ xfs_attri_copy_log_format(
        return 1;
 }
 
+static inline unsigned int
+xfs_attr_log_item_op(const struct xfs_attri_log_format *attrp)
+{
+       return attrp->alfi_op_flags & XFS_ATTRI_OP_FLAGS_TYPE_MASK;
+}
+
 int
 xlog_print_trans_attri(
        char                            **ptr,
@@ -683,6 +689,10 @@ xlog_print_trans_attri(
        struct xfs_attri_log_format     *src_f = NULL;
        xlog_op_header_t                *head = NULL;
        uint                            dst_len;
+       unsigned int                    name_len = 0;
+       unsigned int                    new_name_len = 0;
+       unsigned int                    value_len = 0;
+       unsigned int                    new_value_len = 0;
        int                             error = 0;
 
        dst_len = sizeof(struct xfs_attri_log_format);
@@ -705,27 +715,71 @@ xlog_print_trans_attri(
        memmove((char*)src_f, *ptr, src_len);
        *ptr += src_len;
 
-       printf(_("ATTRI:  #regs: %d     name_len: %d, value_len: %d  id: 0x%llx\n"),
-               src_f->alfi_size, src_f->alfi_name_len, src_f->alfi_value_len,
-                               (unsigned long long)src_f->alfi_id);
+       if (xfs_attr_log_item_op(src_f) == XFS_ATTRI_OP_FLAGS_PPTR_REPLACE) {
+               name_len      = src_f->alfi_old_name_len;
+               new_name_len  = src_f->alfi_new_name_len;
+               value_len     = src_f->alfi_value_len;
+               new_value_len = src_f->alfi_value_len;
+       } else {
+               name_len      = src_f->alfi_name_len;
+               value_len     = src_f->alfi_value_len;
+       }
+
+       printf(_("ATTRI:  #regs: %d     f: 0x%x, ino: 0x%llx, igen: 0x%x, attr_filter: 0x%x, name_len: %u, new_name_len: %u, value_len: %u, new_value_len: %u  id: 0x%llx\n"),
+                       src_f->alfi_size,
+                       src_f->alfi_op_flags,
+                       (unsigned long long)src_f->alfi_ino,
+                       (unsigned int)src_f->alfi_igen,
+                       src_f->alfi_attr_filter,
+                       name_len,
+                       new_name_len,
+                       value_len,
+                       new_value_len,
+                       (unsigned long long)src_f->alfi_id);
+
+       if (name_len > 0) {
+               printf(_("\n"));
+               (*i)++;
+               head = (xlog_op_header_t *)*ptr;
+               xlog_print_op_header(head, *i, ptr);
+               error = xlog_print_trans_attri_name(ptr,
+                               be32_to_cpu(head->oh_len), "name");
+               if (error)
+                       goto error;
+       }
+
+       if (new_name_len > 0) {
+               printf(_("\n"));
+               (*i)++;
+               head = (xlog_op_header_t *)*ptr;
+               xlog_print_op_header(head, *i, ptr);
+               error = xlog_print_trans_attri_name(ptr,
+                               be32_to_cpu(head->oh_len), "newname");
+               if (error)
+                       goto error;
+       }
 
-       if (src_f->alfi_name_len > 0) {
+       if (value_len > 0) {
                printf(_("\n"));
                (*i)++;
                head = (xlog_op_header_t *)*ptr;
                xlog_print_op_header(head, *i, ptr);
-               error = xlog_print_trans_attri_name(ptr, be32_to_cpu(head->oh_len));
+               error = xlog_print_trans_attri_value(ptr,
+                               be32_to_cpu(head->oh_len), value_len, "value");
                if (error)
                        goto error;
        }
 
-       if (src_f->alfi_value_len > 0) {
+       if (new_value_len > 0) {
                printf(_("\n"));
                (*i)++;
                head = (xlog_op_header_t *)*ptr;
                xlog_print_op_header(head, *i, ptr);
-               error = xlog_print_trans_attri_value(ptr, be32_to_cpu(head->oh_len),
-                               src_f->alfi_value_len);
+               error = xlog_print_trans_attri_value(ptr,
+                               be32_to_cpu(head->oh_len), new_value_len,
+                               "newvalue");
+               if (error)
+                       goto error;
        }
 error:
        free(src_f);
@@ -736,31 +790,33 @@ error:
 int
 xlog_print_trans_attri_name(
        char                            **ptr,
-       uint                            src_len)
+       uint                            src_len,
+       const char                      *tag)
 {
-       printf(_("ATTRI:  name len:%u\n"), src_len);
+       printf(_("ATTRI:  %s len:%u\n"), tag, src_len);
        print_or_dump(*ptr, src_len);
 
        *ptr += src_len;
 
        return 0;
-}      /* xlog_print_trans_attri */
+}
 
 int
 xlog_print_trans_attri_value(
        char                            **ptr,
        uint                            src_len,
-       int                             value_len)
+       int                             value_len,
+       const char                      *tag)
 {
        int len = min(value_len, src_len);
 
-       printf(_("ATTRI:  value len:%u\n"), value_len);
+       printf(_("ATTRI:  %s len:%u\n"), tag, value_len);
        print_or_dump(*ptr, len);
 
        *ptr += src_len;
 
        return 0;
-}      /* xlog_print_trans_attri_value */
+}
 
 void
 xlog_recover_print_attri(
@@ -768,7 +824,10 @@ xlog_recover_print_attri(
 {
        struct xfs_attri_log_format     *f, *src_f = NULL;
        uint                            src_len, dst_len;
-
+       unsigned int                    name_len = 0;
+       unsigned int                    new_name_len = 0;
+       unsigned int                    value_len = 0;
+       unsigned int                    new_value_len = 0;
        int                             region = 0;
 
        src_f = (struct xfs_attri_log_format *)item->ri_buf[0].i_addr;
@@ -788,24 +847,55 @@ xlog_recover_print_attri(
        if (xfs_attri_copy_log_format((char*)src_f, src_len, f))
                goto out;
 
-       printf(_("ATTRI:  #regs: %d     name_len: %d, value_len: %d  id: 0x%llx\n"),
-               f->alfi_size, f->alfi_name_len, f->alfi_value_len, (unsigned long long)f->alfi_id);
+       if (xfs_attr_log_item_op(f) == XFS_ATTRI_OP_FLAGS_PPTR_REPLACE) {
+               name_len      = f->alfi_old_name_len;
+               new_name_len  = f->alfi_new_name_len;
+               value_len     = f->alfi_value_len;
+               new_value_len = f->alfi_value_len;
+       } else {
+               name_len      = f->alfi_name_len;
+               value_len     = f->alfi_value_len;
+       }
+
+       printf(_("ATTRI:  #regs: %d     f: 0x%x, ino: 0x%llx, igen: 0x%x, attr_filter: 0x%x, name_len: %u, new_name_len: %u, value_len: %d, new_value_len: %u  id: 0x%llx\n"),
+                       f->alfi_size,
+                       f->alfi_op_flags,
+                       (unsigned long long)f->alfi_ino,
+                       (unsigned int)f->alfi_igen,
+                       f->alfi_attr_filter,
+                       name_len,
+                       new_name_len,
+                       value_len,
+                       new_value_len,
+                       (unsigned long long)f->alfi_id);
+
+       if (name_len > 0) {
+               region++;
+               printf(_("ATTRI:  name len:%u\n"), name_len);
+               print_or_dump((char *)item->ri_buf[region].i_addr,
+                              name_len);
+       }
 
-       if (f->alfi_name_len > 0) {
+       if (new_name_len > 0) {
                region++;
-               printf(_("ATTRI:  name len:%u\n"), f->alfi_name_len);
+               printf(_("ATTRI:  newname len:%u\n"), new_name_len);
                print_or_dump((char *)item->ri_buf[region].i_addr,
-                              f->alfi_name_len);
+                              new_name_len);
        }
 
-       if (f->alfi_value_len > 0) {
-               int len = f->alfi_value_len;
+       if (value_len > 0) {
+               int     len = min(MAX_ATTR_VAL_PRINT, value_len);
+
+               region++;
+               printf(_("ATTRI:  value len:%u\n"), value_len);
+               print_or_dump((char *)item->ri_buf[region].i_addr, len);
+       }
 
-               if (len > MAX_ATTR_VAL_PRINT)
-                       len = MAX_ATTR_VAL_PRINT;
+       if (new_value_len > 0) {
+               int     len = min(MAX_ATTR_VAL_PRINT, new_value_len);
 
                region++;
-               printf(_("ATTRI:  value len:%u\n"), f->alfi_value_len);
+               printf(_("ATTRI:  newvalue len:%u\n"), new_value_len);
                print_or_dump((char *)item->ri_buf[region].i_addr, len);
        }
 

diff --git a/logprint/logprint.h b/logprint/logprint.h
index 8867b110ecaf3096a71f45bca2b4d9846923acac..9715cdb9e27bb2d149e47dbf2577523a0960899b 100644 (file)
--- a/logprint/logprint.h
+++ b/logprint/logprint.h
@@ -59,8 +59,10 @@ extern void xlog_recover_print_bud(struct xlog_recover_item *item);
 #define MAX_ATTR_VAL_PRINT     128
 
 extern int xlog_print_trans_attri(char **ptr, uint src_len, int *i);
-extern int xlog_print_trans_attri_name(char **ptr, uint src_len);
-extern int xlog_print_trans_attri_value(char **ptr, uint src_len, int value_len);
+extern int xlog_print_trans_attri_name(char **ptr, uint src_len,
+               const char *tag);
+extern int xlog_print_trans_attri_value(char **ptr, uint src_len, int value_len,
+               const char *tag);
 extern void xlog_recover_print_attri(struct xlog_recover_item *item);
 extern int xlog_print_trans_attrd(char **ptr, uint len);
 extern void xlog_recover_print_attrd(struct xlog_recover_item *item);