NFS: Convert GFP_NOFS to GFP_KERNEL

Assume that sections that should not re-enter the filesystem are already
protected with memalloc_nofs_save/restore call, so relax those GFP_NOFS
instances which might be used by other contexts.

Signed-off-by: Trond Myklebust <trond.myklebust@hammerspace.com>

diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 34209abe16c552508aefe82acb1c623cef538987..8cf29c6cd9f949912e9de4a6d650d18b82982415 100644 (file)
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1583,7 +1583,7 @@ struct nfs_fattr *nfs_alloc_fattr(void)
 {
        struct nfs_fattr *fattr;
 
-       fattr = kmalloc(sizeof(*fattr), GFP_NOFS);
+       fattr = kmalloc(sizeof(*fattr), GFP_KERNEL);
        if (fattr != NULL) {
                nfs_fattr_init(fattr);
                fattr->label = NULL;
@@ -1599,7 +1599,7 @@ struct nfs_fattr *nfs_alloc_fattr_with_label(struct nfs_server *server)
        if (!fattr)
                return NULL;
 
-       fattr->label = nfs4_label_alloc(server, GFP_NOFS);
+       fattr->label = nfs4_label_alloc(server, GFP_KERNEL);
        if (IS_ERR(fattr->label)) {
                kfree(fattr);
                return NULL;
@@ -1613,7 +1613,7 @@ struct nfs_fh *nfs_alloc_fhandle(void)
 {
        struct nfs_fh *fh;
 
-       fh = kmalloc(sizeof(struct nfs_fh), GFP_NOFS);
+       fh = kmalloc(sizeof(struct nfs_fh), GFP_KERNEL);
        if (fh != NULL)
                fh->size = 0;
        return fh;

diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 0e0db6c276196108581b08cd9949c05160106f47..b3793b82a5e74e6ca218211fdf7df4b8673ba69e 100644 (file)
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -5904,7 +5904,7 @@ static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t bu
                buflen = server->rsize;
 
        npages = DIV_ROUND_UP(buflen, PAGE_SIZE) + 1;
-       pages = kmalloc_array(npages, sizeof(struct page *), GFP_NOFS);
+       pages = kmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
        if (!pages)
                return -ENOMEM;
 
@@ -6609,7 +6609,7 @@ static int _nfs4_proc_delegreturn(struct inode *inode, const struct cred *cred,
        };
        int status = 0;
 
-       data = kzalloc(sizeof(*data), GFP_NOFS);
+       data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (data == NULL)
                return -ENOMEM;
 
@@ -6797,7 +6797,7 @@ static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
        struct nfs4_state *state = lsp->ls_state;
        struct inode *inode = state->inode;
 
-       p = kzalloc(sizeof(*p), GFP_NOFS);
+       p = kzalloc(sizeof(*p), GFP_KERNEL);
        if (p == NULL)
                return NULL;
        p->arg.fh = NFS_FH(inode);
@@ -7202,8 +7202,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
                task_setup_data.flags |= RPC_TASK_MOVEABLE;
 
        data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
-                       fl->fl_u.nfs4_fl.owner,
-                       recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
+                                  fl->fl_u.nfs4_fl.owner, GFP_KERNEL);
        if (data == NULL)
                return -ENOMEM;
        if (IS_SETLKW(cmd))
@@ -7626,7 +7625,7 @@ nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
        if (server->nfs_client->cl_mvops->minor_version != 0)
                return;
 
-       data = kmalloc(sizeof(*data), GFP_NOFS);
+       data = kmalloc(sizeof(*data), GFP_KERNEL);
        if (!data)
                return;
        data->lsp = lsp;
@@ -9291,7 +9290,7 @@ static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
                goto out_err;
 
        ret = ERR_PTR(-ENOMEM);
-       calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
+       calldata = kzalloc(sizeof(*calldata), GFP_KERNEL);
        if (calldata == NULL)
                goto out_put_clp;
        nfs4_init_sequence(&calldata->args, &calldata->res, 0, is_privileged);
@@ -10222,7 +10221,7 @@ static int nfs41_free_stateid(struct nfs_server *server,
                &task_setup.rpc_client, &msg);
 
        dprintk("NFS call  free_stateid %p\n", stateid);
-       data = kmalloc(sizeof(*data), GFP_NOFS);
+       data = kmalloc(sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
        data->server = server;

diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 87cb864a1ba2c942fdbe9479c09ae4e32cce1a9b..58054dfdf2b03b156362118ef93a7d68e13140b9 100644 (file)
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -821,7 +821,7 @@ static void __nfs4_close(struct nfs4_state *state,
 
 void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
 {
-       __nfs4_close(state, fmode, GFP_NOFS, 0);
+       __nfs4_close(state, fmode, GFP_KERNEL, 0);
 }
 
 void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)

diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index 7c9090a28e5c3d07247ff189349757706e88f784..f089e11fd0014a7e99a2f3773daad950eb8a2011 100644 (file)
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -1233,7 +1233,7 @@ pnfs_send_layoutreturn(struct pnfs_layout_hdr *lo,
        int status = 0;
 
        *pcred = NULL;
-       lrp = kzalloc(sizeof(*lrp), GFP_NOFS);
+       lrp = kzalloc(sizeof(*lrp), GFP_KERNEL);
        if (unlikely(lrp == NULL)) {
                status = -ENOMEM;
                spin_lock(&ino->i_lock);
@@ -3250,7 +3250,7 @@ struct nfs4_threshold *pnfs_mdsthreshold_alloc(void)
 {
        struct nfs4_threshold *thp;
 
-       thp = kzalloc(sizeof(*thp), GFP_NOFS);
+       thp = kzalloc(sizeof(*thp), GFP_KERNEL);
        if (!thp) {
                dprintk("%s mdsthreshold allocation failed\n", __func__);
                return NULL;