xfs: convert kmem_zalloc() to kzalloc()

There's no reason to keep the kmem_zalloc() around anymore, it's
just a thin wrapper around kmalloc(), so lets get rid of it.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: "Darrick J. Wong" <djwong@kernel.org>
Signed-off-by: Chandan Babu R <chandanbabu@kernel.org>

diff --git a/fs/xfs/kmem.h b/fs/xfs/kmem.h
index b987dc2c685170ad1ce08768553c7a8cee02d7a6..bce31182c9e8d8da7564fa6dd4f44424b9e05aea 100644 (file)
--- a/fs/xfs/kmem.h
+++ b/fs/xfs/kmem.h
@@ -62,13 +62,6 @@ static inline void  kmem_free(const void *ptr)
        kvfree(ptr);
 }
 
-
-static inline void *
-kmem_zalloc(size_t size, xfs_km_flags_t flags)
-{
-       return kmem_alloc(size, flags | KM_ZERO);
-}
-
 /*
  * Zone interfaces
  */

diff --git a/fs/xfs/libxfs/xfs_ag.c b/fs/xfs/libxfs/xfs_ag.c
index 39d9525270b74fecee2ff9e0db741c25bc77db6a..96a6bfd58931674ba3b0745020c87cdf1a175d8d 100644 (file)
--- a/fs/xfs/libxfs/xfs_ag.c
+++ b/fs/xfs/libxfs/xfs_ag.c
@@ -381,7 +381,7 @@ xfs_initialize_perag(
                        continue;
                }
 
-               pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL);
+               pag = kzalloc(sizeof(*pag), GFP_KERNEL | __GFP_RETRY_MAYFAIL);
                if (!pag) {
                        error = -ENOMEM;
                        goto out_unwind_new_pags;

diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 6374bf1072420707709d8b6504b87355f3dc6587..ab4223bf51eee2c9de4e15dda6bc9ba40bdbb0c4 100644 (file)
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -2250,7 +2250,8 @@ xfs_attr3_leaf_unbalance(
                struct xfs_attr_leafblock *tmp_leaf;
                struct xfs_attr3_icleaf_hdr tmphdr;
 
-               tmp_leaf = kmem_zalloc(state->args->geo->blksize, 0);
+               tmp_leaf = kzalloc(state->args->geo->blksize,
+                               GFP_KERNEL | __GFP_NOFAIL);
 
                /*
                 * Copy the header into the temp leaf so that all the stuff

diff --git a/fs/xfs/libxfs/xfs_btree_staging.c b/fs/xfs/libxfs/xfs_btree_staging.c
index e276eba87cb19c8ac48b713fba391e5f75f8e30b..eff29425fd762bb8c61b6567b8377843b079e3dc 100644 (file)
--- a/fs/xfs/libxfs/xfs_btree_staging.c
+++ b/fs/xfs/libxfs/xfs_btree_staging.c
@@ -406,7 +406,7 @@ xfs_btree_bload_prep_block(
 
                /* Allocate a new incore btree root block. */
                new_size = bbl->iroot_size(cur, level, nr_this_block, priv);
-               ifp->if_broot = kmem_zalloc(new_size, 0);
+               ifp->if_broot = kzalloc(new_size, GFP_KERNEL);
                ifp->if_broot_bytes = (int)new_size;
 
                /* Initialize it and send it out. */

diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 5457188bb4deb29c8a607e19f82f1fdf5b116b71..73aae65439060dd75bc676c30a353f5794843d8a 100644 (file)
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -2518,7 +2518,7 @@ xfs_dabuf_map(
        int                     error = 0, nirecs, i;
 
        if (nfsb > 1)
-               irecs = kmem_zalloc(sizeof(irec) * nfsb, KM_NOFS);
+               irecs = kzalloc(sizeof(irec) * nfsb, GFP_NOFS | __GFP_NOFAIL);
 
        nirecs = nfsb;
        error = xfs_bmapi_read(dp, bno, nfsb, irecs, &nirecs,
@@ -2531,7 +2531,8 @@ xfs_dabuf_map(
         * larger one that needs to be free by the caller.
         */
        if (nirecs > 1) {
-               map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map), KM_NOFS);
+               map = kzalloc(nirecs * sizeof(struct xfs_buf_map),
+                               GFP_NOFS | __GFP_NOFAIL);
                if (!map) {
                        error = -ENOMEM;
                        goto out_free_irecs;

diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
index 66a17910d021942d5cbd943a933096705f09ea56..07d318b1f807a6c7e36a9f883bdf2d85a2b9628c 100644 (file)
--- a/fs/xfs/libxfs/xfs_defer.c
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -979,7 +979,7 @@ xfs_defer_ops_capture(
                return ERR_PTR(error);
 
        /* Create an object to capture the defer ops. */
-       dfc = kmem_zalloc(sizeof(*dfc), KM_NOFS);
+       dfc = kzalloc(sizeof(*dfc), GFP_NOFS | __GFP_NOFAIL);
        INIT_LIST_HEAD(&dfc->dfc_list);
        INIT_LIST_HEAD(&dfc->dfc_dfops);
 

diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index a76673281514501560e286d8bb5ac19cbc7e5707..54915a302e96e4afa992745d5448992c7b7d8136 100644 (file)
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -104,10 +104,10 @@ xfs_da_mount(
        ASSERT(mp->m_sb.sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
        ASSERT(xfs_dir2_dirblock_bytes(&mp->m_sb) <= XFS_MAX_BLOCKSIZE);
 
-       mp->m_dir_geo = kmem_zalloc(sizeof(struct xfs_da_geometry),
-                                   KM_MAYFAIL);
-       mp->m_attr_geo = kmem_zalloc(sizeof(struct xfs_da_geometry),
-                                    KM_MAYFAIL);
+       mp->m_dir_geo = kzalloc(sizeof(struct xfs_da_geometry),
+                               GFP_KERNEL | __GFP_RETRY_MAYFAIL);
+       mp->m_attr_geo = kzalloc(sizeof(struct xfs_da_geometry),
+                               GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!mp->m_dir_geo || !mp->m_attr_geo) {
                kmem_free(mp->m_dir_geo);
                kmem_free(mp->m_attr_geo);
@@ -236,7 +236,7 @@ xfs_dir_init(
        if (error)
                return error;
 
-       args = kmem_zalloc(sizeof(*args), KM_NOFS);
+       args = kzalloc(sizeof(*args), GFP_NOFS | __GFP_NOFAIL);
        if (!args)
                return -ENOMEM;
 
@@ -273,7 +273,7 @@ xfs_dir_createname(
                XFS_STATS_INC(dp->i_mount, xs_dir_create);
        }
 
-       args = kmem_zalloc(sizeof(*args), KM_NOFS);
+       args = kzalloc(sizeof(*args), GFP_NOFS | __GFP_NOFAIL);
        if (!args)
                return -ENOMEM;
 
@@ -372,7 +372,7 @@ xfs_dir_lookup(
         * lockdep Doing this avoids having to add a bunch of lockdep class
         * annotations into the reclaim path for the ilock.
         */
-       args = kmem_zalloc(sizeof(*args), KM_NOFS);
+       args = kzalloc(sizeof(*args), GFP_NOFS | __GFP_NOFAIL);
        args->geo = dp->i_mount->m_dir_geo;
        args->name = name->name;
        args->namelen = name->len;
@@ -441,7 +441,7 @@ xfs_dir_removename(
        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
        XFS_STATS_INC(dp->i_mount, xs_dir_remove);
 
-       args = kmem_zalloc(sizeof(*args), KM_NOFS);
+       args = kzalloc(sizeof(*args), GFP_NOFS | __GFP_NOFAIL);
        if (!args)
                return -ENOMEM;
 
@@ -502,7 +502,7 @@ xfs_dir_replace(
        if (rval)
                return rval;
 
-       args = kmem_zalloc(sizeof(*args), KM_NOFS);
+       args = kzalloc(sizeof(*args), GFP_NOFS | __GFP_NOFAIL);
        if (!args)
                return -ENOMEM;
 

diff --git a/fs/xfs/libxfs/xfs_iext_tree.c b/fs/xfs/libxfs/xfs_iext_tree.c
index f4e6b200cdf8c118bf5ad401592eb23406a4cf5f..4522f3c7a23f311f3961c760fd5c035e36f3acf0 100644 (file)
--- a/fs/xfs/libxfs/xfs_iext_tree.c
+++ b/fs/xfs/libxfs/xfs_iext_tree.c
@@ -398,7 +398,8 @@ static void
 xfs_iext_grow(
        struct xfs_ifork        *ifp)
 {
-       struct xfs_iext_node    *node = kmem_zalloc(NODE_SIZE, KM_NOFS);
+       struct xfs_iext_node    *node = kzalloc(NODE_SIZE,
+                                               GFP_NOFS | __GFP_NOFAIL);
        int                     i;
 
        if (ifp->if_height == 1) {
@@ -454,7 +455,8 @@ xfs_iext_split_node(
        int                     *nr_entries)
 {
        struct xfs_iext_node    *node = *nodep;
-       struct xfs_iext_node    *new = kmem_zalloc(NODE_SIZE, KM_NOFS);
+       struct xfs_iext_node    *new = kzalloc(NODE_SIZE,
+                                               GFP_NOFS | __GFP_NOFAIL);
        const int               nr_move = KEYS_PER_NODE / 2;
        int                     nr_keep = nr_move + (KEYS_PER_NODE & 1);
        int                     i = 0;
@@ -542,7 +544,8 @@ xfs_iext_split_leaf(
        int                     *nr_entries)
 {
        struct xfs_iext_leaf    *leaf = cur->leaf;
-       struct xfs_iext_leaf    *new = kmem_zalloc(NODE_SIZE, KM_NOFS);
+       struct xfs_iext_leaf    *new = kzalloc(NODE_SIZE,
+                                               GFP_NOFS | __GFP_NOFAIL);
        const int               nr_move = RECS_PER_LEAF / 2;
        int                     nr_keep = nr_move + (RECS_PER_LEAF & 1);
        int                     i;
@@ -583,7 +586,8 @@ xfs_iext_alloc_root(
 {
        ASSERT(ifp->if_bytes == 0);
 
-       ifp->if_data = kmem_zalloc(sizeof(struct xfs_iext_rec), KM_NOFS);
+       ifp->if_data = kzalloc(sizeof(struct xfs_iext_rec),
+                                       GFP_NOFS | __GFP_NOFAIL);
        ifp->if_height = 1;
 
        /* now that we have a node step into it */

diff --git a/fs/xfs/xfs_attr_item.c b/fs/xfs/xfs_attr_item.c
index 9e02111bd89010ab572c4e6d41ca71465d98f142..2e454a0d6f19c50aa4e853556446eb58ba3556c0 100644 (file)
--- a/fs/xfs/xfs_attr_item.c
+++ b/fs/xfs/xfs_attr_item.c
@@ -512,8 +512,8 @@ xfs_attri_recover_work(
        if (error)
                return ERR_PTR(error);
 
-       attr = kmem_zalloc(sizeof(struct xfs_attr_intent) +
-                          sizeof(struct xfs_da_args), KM_NOFS);
+       attr = kzalloc(sizeof(struct xfs_attr_intent) +
+                       sizeof(struct xfs_da_args), GFP_NOFS | __GFP_NOFAIL);
        args = (struct xfs_da_args *)(attr + 1);
 
        attr->xattri_da_args = args;

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 8e5bd50d29feb34b50a5a85dca9110648a6bf69e..5672665150eab40c2a14f6480c56550b2eeb6872 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -189,8 +189,8 @@ xfs_buf_get_maps(
                return 0;
        }
 
-       bp->b_maps = kmem_zalloc(map_count * sizeof(struct xfs_buf_map),
-                               KM_NOFS);
+       bp->b_maps = kzalloc(map_count * sizeof(struct xfs_buf_map),
+                               GFP_NOFS | __GFP_NOFAIL);
        if (!bp->b_maps)
                return -ENOMEM;
        return 0;
@@ -2002,7 +2002,7 @@ xfs_alloc_buftarg(
 #if defined(CONFIG_FS_DAX) && defined(CONFIG_MEMORY_FAILURE)
        ops = &xfs_dax_holder_operations;
 #endif
-       btp = kmem_zalloc(sizeof(*btp), KM_NOFS);
+       btp = kzalloc(sizeof(*btp), GFP_NOFS | __GFP_NOFAIL);
 
        btp->bt_mount = mp;
        btp->bt_bdev_handle = bdev_handle;

diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 023d4e0385dd08da8928f2492bf2b7fd09851c37..ec93d34188c8340c3d4f00709897804071656a85 100644 (file)
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -805,8 +805,8 @@ xfs_buf_item_get_format(
                return;
        }
 
-       bip->bli_formats = kmem_zalloc(count * sizeof(struct xfs_buf_log_format),
-                               0);
+       bip->bli_formats = kzalloc(count * sizeof(struct xfs_buf_log_format),
+                               GFP_KERNEL | __GFP_NOFAIL);
 }
 
 STATIC void

diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index b2cbbba3e15a55b67bade9c1d5429649d5b4d6c1..456520d60cd08beb605e7157e3c75a85a4292239 100644 (file)
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -240,8 +240,8 @@ xfs_errortag_init(
 {
        int ret;
 
-       mp->m_errortag = kmem_zalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
-                       KM_MAYFAIL);
+       mp->m_errortag = kzalloc(sizeof(unsigned int) * XFS_ERRTAG_MAX,
+                               GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!mp->m_errortag)
                return -ENOMEM;
 

diff --git a/fs/xfs/xfs_extent_busy.c b/fs/xfs/xfs_extent_busy.c
index 2ccde32c9a9e97c7ad920acf0d8ff9ac0896b9b4..b90c3dd43e03d0820e81b237251d0f2827b6a3e8 100644 (file)
--- a/fs/xfs/xfs_extent_busy.c
+++ b/fs/xfs/xfs_extent_busy.c
@@ -32,7 +32,8 @@ xfs_extent_busy_insert_list(
        struct rb_node          **rbp;
        struct rb_node          *parent = NULL;
 
-       new = kmem_zalloc(sizeof(struct xfs_extent_busy), 0);
+       new = kzalloc(sizeof(struct xfs_extent_busy),
+                       GFP_KERNEL | __GFP_NOFAIL);
        new->agno = pag->pag_agno;
        new->bno = bno;
        new->length = len;

diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 14462614fcc8da1f029ac03395db317b47f44261..14211174267a4939ead66a713b49358537f13943 100644 (file)
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -197,8 +197,8 @@ xfs_bulkstat_one(
 
        ASSERT(breq->icount == 1);
 
-       bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
-                       KM_MAYFAIL);
+       bc.buf = kzalloc(sizeof(struct xfs_bulkstat),
+                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!bc.buf)
                return -ENOMEM;
 
@@ -289,8 +289,8 @@ xfs_bulkstat(
        if (xfs_bulkstat_already_done(breq->mp, breq->startino))
                return 0;
 
-       bc.buf = kmem_zalloc(sizeof(struct xfs_bulkstat),
-                       KM_MAYFAIL);
+       bc.buf = kzalloc(sizeof(struct xfs_bulkstat),
+                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!bc.buf)
                return -ENOMEM;
 

diff --git a/fs/xfs/xfs_iwalk.c b/fs/xfs/xfs_iwalk.c
index b3275e8d47b6057f8a2a776e6bddd3ec2f8a5600..8dbb7c054b28975e2884bba073f451bb5fad3926 100644 (file)
--- a/fs/xfs/xfs_iwalk.c
+++ b/fs/xfs/xfs_iwalk.c
@@ -663,7 +663,8 @@ xfs_iwalk_threaded(
                if (xfs_pwork_ctl_want_abort(&pctl))
                        break;
 
-               iwag = kmem_zalloc(sizeof(struct xfs_iwalk_ag), 0);
+               iwag = kzalloc(sizeof(struct xfs_iwalk_ag),
+                               GFP_KERNEL | __GFP_NOFAIL);
                iwag->mp = mp;
 
                /*

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index a1650fc81382f953c515a0a302243cd7361ad03f..d38cfaadc7263abb611526245ef0a93fb84062b6 100644 (file)
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1528,7 +1528,7 @@ xlog_alloc_log(
        int                     error = -ENOMEM;
        uint                    log2_size = 0;
 
-       log = kmem_zalloc(sizeof(struct xlog), KM_MAYFAIL);
+       log = kzalloc(sizeof(struct xlog), GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!log) {
                xfs_warn(mp, "Log allocation failed: No memory!");
                goto out;
@@ -1605,7 +1605,8 @@ xlog_alloc_log(
                size_t bvec_size = howmany(log->l_iclog_size, PAGE_SIZE) *
                                sizeof(struct bio_vec);
 
-               iclog = kmem_zalloc(sizeof(*iclog) + bvec_size, KM_MAYFAIL);
+               iclog = kzalloc(sizeof(*iclog) + bvec_size,
+                               GFP_KERNEL | __GFP_RETRY_MAYFAIL);
                if (!iclog)
                        goto out_free_iclog;
 

diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index 67a99d94701e5b08da7849ddc29a361a71e12f12..3c705f22b0ab6946558878012c1a6a026863fbf9 100644 (file)
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -100,7 +100,7 @@ xlog_cil_ctx_alloc(void)
 {
        struct xfs_cil_ctx      *ctx;
 
-       ctx = kmem_zalloc(sizeof(*ctx), KM_NOFS);
+       ctx = kzalloc(sizeof(*ctx), GFP_NOFS | __GFP_NOFAIL);
        INIT_LIST_HEAD(&ctx->committing);
        INIT_LIST_HEAD(&ctx->busy_extents.extent_list);
        INIT_LIST_HEAD(&ctx->log_items);
@@ -1747,7 +1747,7 @@ xlog_cil_init(
        struct xlog_cil_pcp     *cilpcp;
        int                     cpu;
 
-       cil = kmem_zalloc(sizeof(*cil), KM_MAYFAIL);
+       cil = kzalloc(sizeof(*cil), GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!cil)
                return -ENOMEM;
        /*

diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 1251c81e55f9820b77b287b28dd24f9a826451b9..4a27ecdbb5463c1e5b53d373c15f5ec4067fe316 100644 (file)
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -2057,7 +2057,8 @@ xlog_recover_add_item(
 {
        struct xlog_recover_item *item;
 
-       item = kmem_zalloc(sizeof(struct xlog_recover_item), 0);
+       item = kzalloc(sizeof(struct xlog_recover_item),
+                       GFP_KERNEL | __GFP_NOFAIL);
        INIT_LIST_HEAD(&item->ri_list);
        list_add_tail(&item->ri_list, head);
 }
@@ -2187,9 +2188,8 @@ xlog_recover_add_to_trans(
                }
 
                item->ri_total = in_f->ilf_size;
-               item->ri_buf =
-                       kmem_zalloc(item->ri_total * sizeof(xfs_log_iovec_t),
-                                   0);
+               item->ri_buf = kzalloc(item->ri_total * sizeof(xfs_log_iovec_t),
+                               GFP_KERNEL | __GFP_NOFAIL);
        }
 
        if (item->ri_total <= item->ri_cnt) {
@@ -2332,7 +2332,7 @@ xlog_recover_ophdr_to_trans(
         * This is a new transaction so allocate a new recovery container to
         * hold the recovery ops that will follow.
         */
-       trans = kmem_zalloc(sizeof(struct xlog_recover), 0);
+       trans = kzalloc(sizeof(struct xlog_recover), GFP_KERNEL | __GFP_NOFAIL);
        trans->r_log_tid = tid;
        trans->r_lsn = be64_to_cpu(rhead->h_lsn);
        INIT_LIST_HEAD(&trans->r_itemq);

diff --git a/fs/xfs/xfs_mru_cache.c b/fs/xfs/xfs_mru_cache.c
index f85e3b07ab4408897ddbcbad3935e06a8b8f1b78..feae3115617ba0fff4620bba0e32adcbfcb030e3 100644 (file)
--- a/fs/xfs/xfs_mru_cache.c
+++ b/fs/xfs/xfs_mru_cache.c
@@ -333,13 +333,14 @@ xfs_mru_cache_create(
        if (!(grp_time = msecs_to_jiffies(lifetime_ms) / grp_count))
                return -EINVAL;
 
-       if (!(mru = kmem_zalloc(sizeof(*mru), 0)))
+       mru = kzalloc(sizeof(*mru), GFP_KERNEL | __GFP_NOFAIL);
+       if (!mru)
                return -ENOMEM;
 
        /* An extra list is needed to avoid reaping up to a grp_time early. */
        mru->grp_count = grp_count + 1;
-       mru->lists = kmem_zalloc(mru->grp_count * sizeof(*mru->lists), 0);
-
+       mru->lists = kzalloc(mru->grp_count * sizeof(*mru->lists),
+                               GFP_KERNEL | __GFP_NOFAIL);
        if (!mru->lists) {
                err = -ENOMEM;
                goto exit;

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 67d0a8564ff3e4897671e98adb3a377440353169..9c2528418b180a52707a9d5209a03303d8a211df 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -628,7 +628,8 @@ xfs_qm_init_quotainfo(
 
        ASSERT(XFS_IS_QUOTA_ON(mp));
 
-       qinf = mp->m_quotainfo = kmem_zalloc(sizeof(struct xfs_quotainfo), 0);
+       qinf = mp->m_quotainfo = kzalloc(sizeof(struct xfs_quotainfo),
+                                       GFP_KERNEL | __GFP_NOFAIL);
 
        error = list_lru_init(&qinf->qi_lru);
        if (error)

diff --git a/fs/xfs/xfs_refcount_item.c b/fs/xfs/xfs_refcount_item.c
index 20ad8086da60be72e79411d71b8015c68bb4dd39..78d0cda60abf35042db41f9eb6ac0d7742c52bcf 100644 (file)
--- a/fs/xfs/xfs_refcount_item.c
+++ b/fs/xfs/xfs_refcount_item.c
@@ -143,8 +143,8 @@ xfs_cui_init(
 
        ASSERT(nextents > 0);
        if (nextents > XFS_CUI_MAX_FAST_EXTENTS)
-               cuip = kmem_zalloc(xfs_cui_log_item_sizeof(nextents),
-                               0);
+               cuip = kzalloc(xfs_cui_log_item_sizeof(nextents),
+                               GFP_KERNEL | __GFP_NOFAIL);
        else
                cuip = kmem_cache_zalloc(xfs_cui_cache,
                                         GFP_KERNEL | __GFP_NOFAIL);

diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c
index 79ad0087aecaf52ea9853c788a72e71c90ab5a45..31a921fc34b23bf008529dbee6879218bb82a8af 100644 (file)
--- a/fs/xfs/xfs_rmap_item.c
+++ b/fs/xfs/xfs_rmap_item.c
@@ -142,7 +142,8 @@ xfs_rui_init(
 
        ASSERT(nextents > 0);
        if (nextents > XFS_RUI_MAX_FAST_EXTENTS)
-               ruip = kmem_zalloc(xfs_rui_log_item_sizeof(nextents), 0);
+               ruip = kzalloc(xfs_rui_log_item_sizeof(nextents),
+                               GFP_KERNEL | __GFP_NOFAIL);
        else
                ruip = kmem_cache_zalloc(xfs_rui_cache,
                                         GFP_KERNEL | __GFP_NOFAIL);

diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 1098452e7f953442ce79c97380e1218ebe613990..5f206cdb40ffd190ec7febf77e62c37cf2a2e032 100644 (file)
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -901,7 +901,8 @@ xfs_trans_ail_init(
 {
        struct xfs_ail  *ailp;
 
-       ailp = kmem_zalloc(sizeof(struct xfs_ail), KM_MAYFAIL);
+       ailp = kzalloc(sizeof(struct xfs_ail),
+                       GFP_KERNEL | __GFP_RETRY_MAYFAIL);
        if (!ailp)
                return -ENOMEM;