xfs: don't use a xfs_log_iovec for ri_buf in log recovery

Source kernel commit: ded74fddcaf685a9440c5612f7831d0c4c1473ca

ri_buf just holds a pointer/len pair and is not a log iovec used for
writing to the log.  Switch to use a kvec instead.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Carlos Maiolino <cmaiolino@redhat.com>
Signed-off-by: Carlos Maiolino <cem@kernel.org>
Signed-off-by: Andrey Albershteyn <aalbersh@kernel.org>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>

diff --git a/include/platform_defs.h b/include/platform_defs.h
index 7b4a1a625586dbc055b42c30b7ab60e4025c1e42..da966490b0f5c6f26e55fb090f70fa2e2b39dac4 100644 (file)
--- a/include/platform_defs.h
+++ b/include/platform_defs.h
@@ -302,4 +302,9 @@ static inline bool __must_check __must_check_overflow(bool overflow)
 # define __nonstring
 #endif
 
+struct kvec {
+       void *iov_base;
+       size_t iov_len;
+};
+
 #endif /* __XFS_PLATFORM_DEFS_H__ */

diff --git a/libxfs/xfs_log_recover.h b/libxfs/xfs_log_recover.h
index 66c7916fb5cd5ef269ef82bb6e8ace0c1510f649..95de23095030699fd40cf13edfdb3112cca1dedc 100644 (file)
--- a/libxfs/xfs_log_recover.h
+++ b/libxfs/xfs_log_recover.h
@@ -104,7 +104,7 @@ struct xlog_recover_item {
        struct list_head        ri_list;
        int                     ri_cnt; /* count of regions found */
        int                     ri_total;       /* total regions */
-       struct xfs_log_iovec    *ri_buf;        /* ptr to regions buffer */
+       struct kvec             *ri_buf;        /* ptr to regions buffer */
        const struct xlog_recover_item_ops *ri_ops;
 };
 
@@ -117,7 +117,7 @@ struct xlog_recover {
        struct list_head        r_itemq;        /* q for items */
 };
 
-#define ITEM_TYPE(i)   (*(unsigned short *)(i)->ri_buf[0].i_addr)
+#define ITEM_TYPE(i)   (*(unsigned short *)(i)->ri_buf[0].iov_base)
 
 #define        XLOG_RECOVER_CRCPASS    0
 #define        XLOG_RECOVER_PASS1      1

diff --git a/libxlog/xfs_log_recover.c b/libxlog/xfs_log_recover.c
index 275593a3ac9148938a7916d343f169f17e2476c8..7ef43956e945532a8986c4f88f5582c05d027c1d 100644 (file)
--- a/libxlog/xfs_log_recover.c
+++ b/libxlog/xfs_log_recover.c
@@ -1034,13 +1034,13 @@ xlog_recover_add_to_cont_trans(
        item = list_entry(trans->r_itemq.prev, struct xlog_recover_item,
                          ri_list);
 
-       old_ptr = item->ri_buf[item->ri_cnt-1].i_addr;
-       old_len = item->ri_buf[item->ri_cnt-1].i_len;
+       old_ptr = item->ri_buf[item->ri_cnt-1].iov_base;
+       old_len = item->ri_buf[item->ri_cnt-1].iov_len;
 
        ptr = krealloc(old_ptr, len+old_len, 0);
        memcpy(&ptr[old_len], dp, len); /* d, s, l */
-       item->ri_buf[item->ri_cnt-1].i_len += len;
-       item->ri_buf[item->ri_cnt-1].i_addr = ptr;
+       item->ri_buf[item->ri_cnt-1].iov_len += len;
+       item->ri_buf[item->ri_cnt-1].iov_base = ptr;
        trace_xfs_log_recover_item_add_cont(log, trans, item, 0);
        return 0;
 }
@@ -1117,8 +1117,8 @@ xlog_recover_add_to_trans(
        }
        ASSERT(item->ri_total > item->ri_cnt);
        /* Description region is ri_buf[0] */
-       item->ri_buf[item->ri_cnt].i_addr = ptr;
-       item->ri_buf[item->ri_cnt].i_len  = len;
+       item->ri_buf[item->ri_cnt].iov_base = ptr;
+       item->ri_buf[item->ri_cnt].iov_len  = len;
        item->ri_cnt++;
        trace_xfs_log_recover_item_add(log, trans, item, 0);
        return 0;
@@ -1140,7 +1140,7 @@ xlog_recover_free_trans(
                /* Free the regions in the item. */
                list_del(&item->ri_list);
                for (i = 0; i < item->ri_cnt; i++)
-                       kfree(item->ri_buf[i].i_addr);
+                       kfree(item->ri_buf[i].iov_base);
                /* Free the item itself */
                kfree(item->ri_buf);
                kfree(item);

diff --git a/logprint/log_print_all.c b/logprint/log_print_all.c
index 1498ef97247d3dcf040426f28dcb0e36ab82086e..39946f32d493bfab301f66c02149286e05f6d1b8 100644 (file)
--- a/logprint/log_print_all.c
+++ b/logprint/log_print_all.c
@@ -78,7 +78,7 @@ xlog_recover_print_buffer(
        xfs_daddr_t             blkno;
        struct xfs_disk_dquot   *ddq;
 
-       f = (xfs_buf_log_format_t *)item->ri_buf[0].i_addr;
+       f = (xfs_buf_log_format_t *)item->ri_buf[0].iov_base;
        printf("        ");
        ASSERT(f->blf_type == XFS_LI_BUF);
        printf(_("BUF:  #regs:%d   start blkno:0x%llx   len:%d   bmap size:%d   flags:0x%x\n"),
@@ -87,8 +87,8 @@ xlog_recover_print_buffer(
        num = f->blf_size-1;
        i = 1;
        while (num-- > 0) {
-               p = item->ri_buf[i].i_addr;
-               len = item->ri_buf[i].i_len;
+               p = item->ri_buf[i].iov_base;
+               len = item->ri_buf[i].iov_len;
                i++;
                if (blkno == 0) { /* super block */
                        struct xfs_dsb  *dsb = (struct xfs_dsb *)p;
@@ -185,7 +185,7 @@ xlog_recover_print_quotaoff(
 {
        xfs_qoff_logformat_t    *qoff_f;
 
-       qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].i_addr;
+       qoff_f = (xfs_qoff_logformat_t *)item->ri_buf[0].iov_base;
 
        ASSERT(qoff_f);
        printf(_("\tQUOTAOFF: #regs:%d   type:"), qoff_f->qf_size);
@@ -205,10 +205,10 @@ xlog_recover_print_dquot(
        xfs_dq_logformat_t      *f;
        struct xfs_disk_dquot   *d;
 
-       f = (xfs_dq_logformat_t *)item->ri_buf[0].i_addr;
+       f = (xfs_dq_logformat_t *)item->ri_buf[0].iov_base;
        ASSERT(f);
        ASSERT(f->qlf_len == 1);
-       d = (struct xfs_disk_dquot *)item->ri_buf[1].i_addr;
+       d = (struct xfs_disk_dquot *)item->ri_buf[1].iov_base;
        printf(_("\tDQUOT: #regs:%d  blkno:%lld  boffset:%u id: %d\n"),
               f->qlf_size, (long long)f->qlf_blkno, f->qlf_boffset, f->qlf_id);
        if (!print_quota)
@@ -288,21 +288,22 @@ xlog_recover_print_inode(
        int                     hasdata;
        int                     hasattr;
 
-       ASSERT(item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format_32) ||
-              item->ri_buf[0].i_len == sizeof(struct xfs_inode_log_format));
-       f = xfs_inode_item_format_convert(item->ri_buf[0].i_addr, item->ri_buf[0].i_len, &f_buf);
+       ASSERT(item->ri_buf[0].iov_len == sizeof(struct xfs_inode_log_format_32) ||
+               item->ri_buf[0].iov_len == sizeof(struct xfs_inode_log_format));
+       f = xfs_inode_item_format_convert(item->ri_buf[0].iov_base,
+                                         item->ri_buf[0].iov_len, &f_buf);
 
        printf(_("      INODE: #regs:%d   ino:0x%llx  flags:0x%x   dsize:%d\n"),
-              f->ilf_size, (unsigned long long)f->ilf_ino, f->ilf_fields,
-              f->ilf_dsize);
+               f->ilf_size, (unsigned long long)f->ilf_ino, f->ilf_fields,
+               f->ilf_dsize);
 
        /* core inode comes 2nd */
        /* ASSERT len vs xfs_log_dinode_size() for V3 or V2 inodes */
-       ASSERT(item->ri_buf[1].i_len ==
+       ASSERT(item->ri_buf[1].iov_len ==
                        offsetof(struct xfs_log_dinode, di_next_unlinked) ||
-              item->ri_buf[1].i_len == sizeof(struct xfs_log_dinode));
+              item->ri_buf[1].iov_len == sizeof(struct xfs_log_dinode));
        xlog_recover_print_inode_core((struct xfs_log_dinode *)
-                                     item->ri_buf[1].i_addr);
+                                     item->ri_buf[1].iov_base);
 
        hasdata = (f->ilf_fields & XFS_ILOG_DFORK) != 0;
        hasattr = (f->ilf_fields & XFS_ILOG_AFORK) != 0;
@@ -312,22 +313,22 @@ xlog_recover_print_inode(
                ASSERT(f->ilf_size == 3 + hasattr);
                printf(_("              DATA FORK EXTENTS inode data:\n"));
                if (print_inode && print_data)
-                       xlog_recover_print_data(item->ri_buf[2].i_addr,
-                                               item->ri_buf[2].i_len);
+                       xlog_recover_print_data(item->ri_buf[2].iov_base,
+                                               item->ri_buf[2].iov_len);
                break;
        case XFS_ILOG_DBROOT:
                ASSERT(f->ilf_size == 3 + hasattr);
                printf(_("              DATA FORK BTREE inode data:\n"));
                if (print_inode && print_data)
-                       xlog_recover_print_data(item->ri_buf[2].i_addr,
-                                               item->ri_buf[2].i_len);
+                       xlog_recover_print_data(item->ri_buf[2].iov_base,
+                                               item->ri_buf[2].iov_len);
                break;
        case XFS_ILOG_DDATA:
                ASSERT(f->ilf_size == 3 + hasattr);
                printf(_("              DATA FORK LOCAL inode data:\n"));
                if (print_inode && print_data)
-                       xlog_recover_print_data(item->ri_buf[2].i_addr,
-                                               item->ri_buf[2].i_len);
+                       xlog_recover_print_data(item->ri_buf[2].iov_base,
+                                               item->ri_buf[2].iov_len);
                break;
        case XFS_ILOG_DEV:
                ASSERT(f->ilf_size == 2 + hasattr);
@@ -353,24 +354,24 @@ xlog_recover_print_inode(
                        printf(_("              ATTR FORK EXTENTS inode data:\n"));
                        if (print_inode && print_data)
                                xlog_recover_print_data(
-                                       item->ri_buf[attr_index].i_addr,
-                                       item->ri_buf[attr_index].i_len);
+                                       item->ri_buf[attr_index].iov_base,
+                                       item->ri_buf[attr_index].iov_len);
                        break;
                case XFS_ILOG_ABROOT:
                        ASSERT(f->ilf_size == 3 + hasdata);
                        printf(_("              ATTR FORK BTREE inode data:\n"));
                        if (print_inode && print_data)
                                xlog_recover_print_data(
-                                       item->ri_buf[attr_index].i_addr,
-                                       item->ri_buf[attr_index].i_len);
+                                       item->ri_buf[attr_index].iov_base,
+                                       item->ri_buf[attr_index].iov_len);
                        break;
                case XFS_ILOG_ADATA:
                        ASSERT(f->ilf_size == 3 + hasdata);
                        printf(_("              ATTR FORK LOCAL inode data:\n"));
                        if (print_inode && print_data)
                                xlog_recover_print_data(
-                                       item->ri_buf[attr_index].i_addr,
-                                       item->ri_buf[attr_index].i_len);
+                                       item->ri_buf[attr_index].iov_base,
+                                       item->ri_buf[attr_index].iov_len);
                        break;
                default:
                        xlog_panic("%s: illegal inode log flag", __FUNCTION__);
@@ -385,7 +386,7 @@ xlog_recover_print_icreate(
 {
        struct xfs_icreate_log  *icl;
 
-       icl = (struct xfs_icreate_log *)item->ri_buf[0].i_addr;
+       icl = (struct xfs_icreate_log *)item->ri_buf[0].iov_base;
 
        printf(_("      ICR:  #ag: %d  agbno: 0x%x  len: %d\n"
                 "            cnt: %d  isize: %d    gen: 0x%x\n"),
@@ -549,8 +550,8 @@ xlog_recover_print_item(
 */
        printf(_(": cnt:%d total:%d "), item->ri_cnt, item->ri_total);
        for (i=0; i<item->ri_cnt; i++) {
-               printf(_("a:0x%lx len:%d "),
-                      (long)item->ri_buf[i].i_addr, item->ri_buf[i].i_len);
+               printf(_("a:0x%lx len:%zu "),
+                      (long)item->ri_buf[i].iov_base, item->ri_buf[i].iov_len);
        }
        printf("\n");
        xlog_recover_print_logitem(item);

diff --git a/logprint/log_redo.c b/logprint/log_redo.c
index 89d7448342b33d7b52666eb3a5993ccc288a90eb..f5bac21d35c8808092a5eafd304fd13091948644 100644 (file)
--- a/logprint/log_redo.c
+++ b/logprint/log_redo.c
@@ -143,8 +143,8 @@ xlog_recover_print_efi(
        int                     i;
        uint                    src_len, dst_len;
 
-       src_f = (xfs_efi_log_format_t *)item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[0].i_len;
+       src_f = (xfs_efi_log_format_t *)item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[0].iov_len;
        /*
         * An xfs_efi_log_format structure contains a variable length array
         * as the last field.
@@ -229,7 +229,7 @@ xlog_recover_print_efd(
        const char              *item_name = "EFD?";
        xfs_efd_log_format_t    *f;
 
-       f = (xfs_efd_log_format_t *)item->ri_buf[0].i_addr;
+       f = (xfs_efd_log_format_t *)item->ri_buf[0].iov_base;
 
        switch (f->efd_type) {
        case XFS_LI_EFD:        item_name = "EFD"; break;
@@ -355,8 +355,8 @@ xlog_recover_print_rui(
        char                            *src_f;
        uint                            src_len;
 
-       src_f = item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[0].i_len;
+       src_f = item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[0].iov_len;
 
        xlog_print_trans_rui(&src_f, src_len, 0);
 }
@@ -406,7 +406,7 @@ xlog_recover_print_rud(
 {
        char                            *f;
 
-       f = item->ri_buf[0].i_addr;
+       f = item->ri_buf[0].iov_base;
        xlog_print_trans_rud(&f, sizeof(struct xfs_rud_log_format));
 }
 
@@ -516,8 +516,8 @@ xlog_recover_print_cui(
        char                            *src_f;
        uint                            src_len;
 
-       src_f = item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[0].i_len;
+       src_f = item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[0].iov_len;
 
        xlog_print_trans_cui(&src_f, src_len, 0);
 }
@@ -563,7 +563,7 @@ xlog_recover_print_cud(
 {
        char                            *f;
 
-       f = item->ri_buf[0].i_addr;
+       f = item->ri_buf[0].iov_base;
        xlog_print_trans_cud(&f, sizeof(struct xfs_cud_log_format));
 }
 
@@ -667,8 +667,8 @@ xlog_recover_print_bui(
        char                            *src_f;
        uint                            src_len;
 
-       src_f = item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[0].i_len;
+       src_f = item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[0].iov_len;
 
        xlog_print_trans_bui(&src_f, src_len, 0);
 }
@@ -707,7 +707,7 @@ xlog_recover_print_bud(
 {
        char                            *f;
 
-       f = item->ri_buf[0].i_addr;
+       f = item->ri_buf[0].iov_base;
        xlog_print_trans_bud(&f, sizeof(struct xfs_bud_log_format));
 }
 
@@ -954,8 +954,8 @@ xlog_recover_print_attri(
        unsigned int                    new_value_len = 0;
        int                             region = 0;
 
-       src_f = (struct xfs_attri_log_format *)item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[region].i_len;
+       src_f = (struct xfs_attri_log_format *)item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[region].iov_len;
 
        /*
         * An xfs_attri_log_format structure contains a attribute name and
@@ -996,17 +996,17 @@ xlog_recover_print_attri(
        if (name_len > 0) {
                region++;
                printf(_("ATTRI:  name len:%u\n"), name_len);
-               print_or_dump((char *)item->ri_buf[region].i_addr,
+               print_or_dump((char *)item->ri_buf[region].iov_base,
                               name_len);
-               name_ptr = item->ri_buf[region].i_addr;
+               name_ptr = item->ri_buf[region].iov_base;
        }
 
        if (new_name_len > 0) {
                region++;
                printf(_("ATTRI:  newname len:%u\n"), new_name_len);
-               print_or_dump((char *)item->ri_buf[region].i_addr,
+               print_or_dump((char *)item->ri_buf[region].iov_base,
                               new_name_len);
-               new_name_ptr = item->ri_buf[region].i_addr;
+               new_name_ptr = item->ri_buf[region].iov_base;
        }
 
        if (value_len > 0) {
@@ -1014,8 +1014,8 @@ xlog_recover_print_attri(
 
                region++;
                printf(_("ATTRI:  value len:%u\n"), value_len);
-               print_or_dump((char *)item->ri_buf[region].i_addr, len);
-               value_ptr = item->ri_buf[region].i_addr;
+               print_or_dump((char *)item->ri_buf[region].iov_base, len);
+               value_ptr = item->ri_buf[region].iov_base;
        }
 
        if (new_value_len > 0) {
@@ -1023,8 +1023,8 @@ xlog_recover_print_attri(
 
                region++;
                printf(_("ATTRI:  newvalue len:%u\n"), new_value_len);
-               print_or_dump((char *)item->ri_buf[region].i_addr, len);
-               new_value_ptr = item->ri_buf[region].i_addr;
+               print_or_dump((char *)item->ri_buf[region].iov_base, len);
+               new_value_ptr = item->ri_buf[region].iov_base;
        }
 
        if (src_f->alfi_attr_filter & XFS_ATTR_PARENT)
@@ -1065,7 +1065,7 @@ xlog_recover_print_attrd(
 {
        struct xfs_attrd_log_format     *f;
 
-       f = (struct xfs_attrd_log_format *)item->ri_buf[0].i_addr;
+       f = (struct xfs_attrd_log_format *)item->ri_buf[0].iov_base;
 
        printf(_("      ATTRD:  #regs: %d       id: 0x%llx\n"),
                f->alfd_size,
@@ -1156,8 +1156,8 @@ xlog_recover_print_xmi(
        char                            *src_f;
        uint                            src_len;
 
-       src_f = item->ri_buf[0].i_addr;
-       src_len = item->ri_buf[0].i_len;
+       src_f = item->ri_buf[0].iov_base;
+       src_len = item->ri_buf[0].iov_len;
 
        xlog_print_trans_xmi(&src_f, src_len, 0);
 }
@@ -1196,6 +1196,6 @@ xlog_recover_print_xmd(
 {
        char                            *f;
 
-       f = item->ri_buf[0].i_addr;
+       f = item->ri_buf[0].iov_base;
        xlog_print_trans_xmd(&f, sizeof(struct xfs_xmd_log_format));
 }