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>
Reviewed-by: Christoph Hellwig <hch@lst.de>

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 25c043485cbb8a9635f5e97f3de658fabf7404e7..8a997fe1150e873a5437c5fd2c2fda6b1e9a30c2 100644 (file)
--- a/logprint/logprint.h
+++ b/logprint/logprint.h
@@ -59,8 +59,9 @@ 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);
+int xlog_print_trans_attri_name(char **ptr, uint src_len, const char *tag);
+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);