ich777/linux_media
1
0
Fork 0
mirror of https://github.com/tbsdtv/linux_media.git synced 2025-07-23 12:43:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'nfs-for-5.12-2' of git://git.linux-nfs.org/projects/anna/linux-nfs

Browse Source 
Pull NFS client bugfixes from Anna Schumaker:
 "These are mostly fixes for issues discovered at the recent NFS
  bakeathon:

   - Fix PNFS_FLEXFILE_LAYOUT kconfig so it is possible to build
     into the kernel

   - Correct size calculationn for create reply length

   - Set memalloc_nofs_save() for sync tasks to prevent deadlocks

   - Don't revalidate directory permissions on lookup failure

   - Don't clear inode cache when lookup fails

   - Change functions to use nfs_set_cache_invalid() for proper
     delegation handling

   - Fix return value of _nfs4_get_security_label()

   - Return an error when attempting to remove system.nfs4_acl"

* tag 'nfs-for-5.12-2' of git://git.linux-nfs.org/projects/anna/linux-nfs:
  nfs: we don't support removing system.nfs4_acl
  NFSv4.2: fix return value of _nfs4_get_security_label()
  NFS: Fix open coded versions of nfs_set_cache_invalid() in NFSv4
  NFS: Fix open coded versions of nfs_set_cache_invalid()
  NFS: Clean up function nfs_mark_dir_for_revalidate()
  NFS: Don't gratuitously clear the inode cache when lookup failed
  NFS: Don't revalidate the directory permissions on a lookup failure
  SUNRPC: Set memalloc_nofs_save() for sync tasks
  NFS: Correct size calculation for create reply length
  nfs: fix PNFS_FLEXFILE_LAYOUT Kconfig default
This commit is contained in:
Linus Torvalds
2021-03-12 14:19:35 -08:00
parent b6b8aa27a3 4f8be1f53b
commit f296bfd5cd
10 changed files with 76 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
fs/nfs/Kconfig
View File

@@ -127,7 +127,7 @@ config PNFS_BLOCK
config PNFS_FLEXFILE_LAYOUT config PNFS_FLEXFILE_LAYOUT
tristate tristate
depends on NFS_V4_1 && NFS_V3 depends on NFS_V4_1 && NFS_V3
default m default NFS_V4
config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN config NFS_V4_1_IMPLEMENTATION_ID_DOMAIN
string "NFSv4.1 Implementation ID Domain" string "NFSv4.1 Implementation ID Domain"

58
fs/nfs/dir.c
View File

@@ -81,8 +81,9 @@ static struct nfs_open_dir_context *alloc_nfs_open_dir_context(struct inode *dir
spin_lock(&dir->i_lock); spin_lock(&dir->i_lock);
if (list_empty(&nfsi->open_files) && if (list_empty(&nfsi->open_files) &&
(nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER)) (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
nfsi->cache_validity |= NFS_INO_INVALID_DATA | nfs_set_cache_invalid(dir,
NFS_INO_REVAL_FORCED; NFS_INO_INVALID_DATA |
NFS_INO_REVAL_FORCED);
list_add(&ctx->list, &nfsi->open_files); list_add(&ctx->list, &nfsi->open_files);
spin_unlock(&dir->i_lock); spin_unlock(&dir->i_lock);
return ctx; return ctx;
@@ -1401,6 +1402,13 @@ out_force:
goto out; goto out;
} }
static void nfs_mark_dir_for_revalidate(struct inode *inode)
{
spin_lock(&inode->i_lock);
nfs_set_cache_invalid(inode, NFS_INO_REVAL_PAGECACHE);
spin_unlock(&inode->i_lock);
}
/* /*
* We judge how long we want to trust negative * We judge how long we want to trust negative
* dentries by looking at the parent inode mtime. * dentries by looking at the parent inode mtime.
@@ -1435,19 +1443,14 @@ nfs_lookup_revalidate_done(struct inode *dir, struct dentry *dentry,
__func__, dentry); __func__, dentry);
return 1; return 1;
case 0: case 0:
nfs_mark_for_revalidate(dir); /*
if (inode && S_ISDIR(inode->i_mode)) { * We can't d_drop the root of a disconnected tree:
/* Purge readdir caches. */ * its d_hash is on the s_anon list and d_drop() would hide
nfs_zap_caches(inode); * it from shrink_dcache_for_unmount(), leading to busy
/* * inodes on unmount and further oopses.
* We can't d_drop the root of a disconnected tree: */
* its d_hash is on the s_anon list and d_drop() would hide if (inode && IS_ROOT(dentry))
* it from shrink_dcache_for_unmount(), leading to busy return 1;
* inodes on unmount and further oopses.
*/
if (IS_ROOT(dentry))
return 1;
}
dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n", dfprintk(LOOKUPCACHE, "NFS: %s(%pd2) is invalid\n",
__func__, dentry); __func__, dentry);
return 0; return 0;
@@ -1525,6 +1528,13 @@ out:
nfs_free_fattr(fattr); nfs_free_fattr(fattr);
nfs_free_fhandle(fhandle); nfs_free_fhandle(fhandle);
nfs4_label_free(label); nfs4_label_free(label);
/*
* If the lookup failed despite the dentry change attribute being
* a match, then we should revalidate the directory cache.
*/
if (!ret && nfs_verify_change_attribute(dir, dentry->d_time))
nfs_mark_dir_for_revalidate(dir);
return nfs_lookup_revalidate_done(dir, dentry, inode, ret); return nfs_lookup_revalidate_done(dir, dentry, inode, ret);
} }
@@ -1567,7 +1577,7 @@ nfs_do_lookup_revalidate(struct inode *dir, struct dentry *dentry,
error = nfs_lookup_verify_inode(inode, flags); error = nfs_lookup_verify_inode(inode, flags);
if (error) { if (error) {
if (error == -ESTALE) if (error == -ESTALE)
nfs_zap_caches(dir); nfs_mark_dir_for_revalidate(dir);
goto out_bad; goto out_bad;
} }
nfs_advise_use_readdirplus(dir); nfs_advise_use_readdirplus(dir);
@@ -1691,10 +1701,9 @@ static void nfs_drop_nlink(struct inode *inode)
if (inode->i_nlink > 0) if (inode->i_nlink > 0)
drop_nlink(inode); drop_nlink(inode);
NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter(); NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE nfs_set_cache_invalid(
| NFS_INO_INVALID_CTIME inode, NFS_INO_INVALID_CHANGE | NFS_INO_INVALID_CTIME |
| NFS_INO_INVALID_OTHER NFS_INO_INVALID_OTHER | NFS_INO_REVAL_FORCED);
| NFS_INO_REVAL_FORCED;
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
} }
@@ -1706,7 +1715,7 @@ static void nfs_dentry_iput(struct dentry *dentry, struct inode *inode)
{ {
if (S_ISDIR(inode->i_mode)) if (S_ISDIR(inode->i_mode))
/* drop any readdir cache as it could easily be old */ /* drop any readdir cache as it could easily be old */
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_DATA; nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { if (dentry->d_flags & DCACHE_NFSFS_RENAMED) {
nfs_complete_unlink(dentry, inode); nfs_complete_unlink(dentry, inode);
@@ -2064,7 +2073,6 @@ out:
dput(parent); dput(parent);
return d; return d;
out_error: out_error:
nfs_mark_for_revalidate(dir);
d = ERR_PTR(error); d = ERR_PTR(error);
goto out; goto out;
} }
@@ -2473,9 +2481,9 @@ int nfs_rename(struct user_namespace *mnt_userns, struct inode *old_dir,
if (error == 0) { if (error == 0) {
spin_lock(&old_inode->i_lock); spin_lock(&old_inode->i_lock);
NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter(); NFS_I(old_inode)->attr_gencount = nfs_inc_attr_generation_counter();
NFS_I(old_inode)->cache_validity |= NFS_INO_INVALID_CHANGE nfs_set_cache_invalid(old_inode, NFS_INO_INVALID_CHANGE |
| NFS_INO_INVALID_CTIME NFS_INO_INVALID_CTIME |
| NFS_INO_REVAL_FORCED; NFS_INO_REVAL_FORCED);
spin_unlock(&old_inode->i_lock); spin_unlock(&old_inode->i_lock);
} }
out: out:

7
fs/nfs/inode.c
View File

@@ -207,7 +207,7 @@ static bool nfs_has_xattr_cache(const struct nfs_inode *nfsi)
} }
#endif #endif
static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags) void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
{ {
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ); bool have_delegation = NFS_PROTO(inode)->have_delegation(inode, FMODE_READ);
@@ -229,6 +229,7 @@ static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
if (flags & NFS_INO_INVALID_DATA) if (flags & NFS_INO_INVALID_DATA)
nfs_fscache_invalidate(inode); nfs_fscache_invalidate(inode);
} }
EXPORT_SYMBOL_GPL(nfs_set_cache_invalid);
/* /*
* Invalidate the local caches * Invalidate the local caches
@@ -1067,8 +1068,8 @@ void nfs_inode_attach_open_context(struct nfs_open_context *ctx)
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
if (list_empty(&nfsi->open_files) && if (list_empty(&nfsi->open_files) &&
(nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER)) (nfsi->cache_validity & NFS_INO_DATA_INVAL_DEFER))
nfsi->cache_validity |= NFS_INO_INVALID_DATA | nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA |
NFS_INO_REVAL_FORCED; NFS_INO_REVAL_FORCED);
list_add_tail_rcu(&ctx->list, &nfsi->open_files); list_add_tail_rcu(&ctx->list, &nfsi->open_files);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
} }

3
fs/nfs/internal.h
View File

@@ -411,7 +411,8 @@ extern int nfs_write_inode(struct inode *, struct writeback_control *);
extern int nfs_drop_inode(struct inode *); extern int nfs_drop_inode(struct inode *);
extern void nfs_clear_inode(struct inode *); extern void nfs_clear_inode(struct inode *);
extern void nfs_evict_inode(struct inode *); extern void nfs_evict_inode(struct inode *);
void nfs_zap_acl_cache(struct inode *inode); extern void nfs_zap_acl_cache(struct inode *inode);
extern void nfs_set_cache_invalid(struct inode *inode, unsigned long flags);
extern bool nfs_check_cache_invalid(struct inode *, unsigned long); extern bool nfs_check_cache_invalid(struct inode *, unsigned long);
extern int nfs_wait_bit_killable(struct wait_bit_key *key, int mode); extern int nfs_wait_bit_killable(struct wait_bit_key *key, int mode);
extern int nfs_wait_atomic_killable(atomic_t *p, unsigned int mode); extern int nfs_wait_atomic_killable(atomic_t *p, unsigned int mode);

3
fs/nfs/nfs3xdr.c
View File

@@ -36,6 +36,7 @@
#define NFS3_pagepad_sz (1) /* Page padding */ #define NFS3_pagepad_sz (1) /* Page padding */
#define NFS3_fhandle_sz (1+16) #define NFS3_fhandle_sz (1+16)
#define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */ #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
#define NFS3_post_op_fh_sz (1+NFS3_fh_sz)
#define NFS3_sattr_sz (15) #define NFS3_sattr_sz (15)
#define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2)) #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
#define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2)) #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
@@ -73,7 +74,7 @@
#define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz) #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
#define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz) #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
#define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4) #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
#define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) #define NFS3_createres_sz (1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
#define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz)) #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
#define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz) #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
#define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz) #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)

12
fs/nfs/nfs42proc.c
View File

@@ -357,13 +357,15 @@ static ssize_t _nfs42_proc_copy(struct file *src,
truncate_pagecache_range(dst_inode, pos_dst, truncate_pagecache_range(dst_inode, pos_dst,
pos_dst + res->write_res.count); pos_dst + res->write_res.count);
spin_lock(&dst_inode->i_lock); spin_lock(&dst_inode->i_lock);
NFS_I(dst_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE | nfs_set_cache_invalid(
NFS_INO_REVAL_FORCED | NFS_INO_INVALID_SIZE | dst_inode, NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_FORCED |
NFS_INO_INVALID_ATTR | NFS_INO_INVALID_DATA); NFS_INO_INVALID_SIZE | NFS_INO_INVALID_ATTR |
NFS_INO_INVALID_DATA);
spin_unlock(&dst_inode->i_lock); spin_unlock(&dst_inode->i_lock);
spin_lock(&src_inode->i_lock); spin_lock(&src_inode->i_lock);
NFS_I(src_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE | nfs_set_cache_invalid(src_inode, NFS_INO_REVAL_PAGECACHE |
NFS_INO_REVAL_FORCED | NFS_INO_INVALID_ATIME); NFS_INO_REVAL_FORCED |
NFS_INO_INVALID_ATIME);
spin_unlock(&src_inode->i_lock); spin_unlock(&src_inode->i_lock);
status = res->write_res.count; status = res->write_res.count;
out: out:

33
fs/nfs/nfs4proc.c
View File

@@ -1169,14 +1169,14 @@ int nfs4_call_sync(struct rpc_clnt *clnt,
static void static void
nfs4_inc_nlink_locked(struct inode *inode) nfs4_inc_nlink_locked(struct inode *inode)
{ {
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER; nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
inc_nlink(inode); inc_nlink(inode);
} }
static void static void
nfs4_dec_nlink_locked(struct inode *inode) nfs4_dec_nlink_locked(struct inode *inode)
{ {
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER; nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
drop_nlink(inode); drop_nlink(inode);
} }
@@ -1187,35 +1187,31 @@ nfs4_update_changeattr_locked(struct inode *inode,
{ {
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
nfsi->cache_validity |= NFS_INO_INVALID_CTIME cache_validity |= NFS_INO_INVALID_CTIME | NFS_INO_INVALID_MTIME;
| NFS_INO_INVALID_MTIME
| cache_validity;
if (cinfo->atomic && cinfo->before == inode_peek_iversion_raw(inode)) { if (cinfo->atomic && cinfo->before == inode_peek_iversion_raw(inode)) {
nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE; nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
nfsi->attrtimeo_timestamp = jiffies; nfsi->attrtimeo_timestamp = jiffies;
} else { } else {
if (S_ISDIR(inode->i_mode)) { if (S_ISDIR(inode->i_mode)) {
nfsi->cache_validity |= NFS_INO_INVALID_DATA; cache_validity |= NFS_INO_INVALID_DATA;
nfs_force_lookup_revalidate(inode); nfs_force_lookup_revalidate(inode);
} else { } else {
if (!NFS_PROTO(inode)->have_delegation(inode, if (!NFS_PROTO(inode)->have_delegation(inode,
FMODE_READ)) FMODE_READ))
nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE; cache_validity |= NFS_INO_REVAL_PAGECACHE;
} }
if (cinfo->before != inode_peek_iversion_raw(inode)) if (cinfo->before != inode_peek_iversion_raw(inode))
nfsi->cache_validity |= NFS_INO_INVALID_ACCESS | cache_validity |= NFS_INO_INVALID_ACCESS |
NFS_INO_INVALID_ACL | NFS_INO_INVALID_ACL |
NFS_INO_INVALID_XATTR; NFS_INO_INVALID_XATTR;
} }
inode_set_iversion_raw(inode, cinfo->after); inode_set_iversion_raw(inode, cinfo->after);
nfsi->read_cache_jiffies = timestamp; nfsi->read_cache_jiffies = timestamp;
nfsi->attr_gencount = nfs_inc_attr_generation_counter(); nfsi->attr_gencount = nfs_inc_attr_generation_counter();
nfs_set_cache_invalid(inode, cache_validity);
nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE; nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE;
if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
nfs_fscache_invalidate(inode);
} }
void void
@@ -5893,6 +5889,9 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE); unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
int ret, i; int ret, i;
/* You can't remove system.nfs4_acl: */
if (buflen == 0)
return -EINVAL;
if (!nfs4_server_supports_acls(server)) if (!nfs4_server_supports_acls(server))
return -EOPNOTSUPP; return -EOPNOTSUPP;
if (npages > ARRAY_SIZE(pages)) if (npages > ARRAY_SIZE(pages))
@@ -5915,9 +5914,9 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
* so mark the attribute cache invalid. * so mark the attribute cache invalid.
*/ */
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
| NFS_INO_INVALID_CTIME NFS_INO_INVALID_CTIME |
| NFS_INO_REVAL_FORCED; NFS_INO_REVAL_FORCED);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
nfs_access_zap_cache(inode); nfs_access_zap_cache(inode);
nfs_zap_acl_cache(inode); nfs_zap_acl_cache(inode);
@@ -5969,7 +5968,7 @@ static int _nfs4_get_security_label(struct inode *inode, void *buf,
return ret; return ret;
if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL)) if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
return -ENOENT; return -ENOENT;
return 0; return label.len;
} }
static int nfs4_get_security_label(struct inode *inode, void *buf, static int nfs4_get_security_label(struct inode *inode, void *buf,

6
fs/nfs/unlink.c
View File

@@ -500,9 +500,9 @@ nfs_sillyrename(struct inode *dir, struct dentry *dentry)
nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter(); NFS_I(inode)->attr_gencount = nfs_inc_attr_generation_counter();
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_CHANGE nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
| NFS_INO_INVALID_CTIME NFS_INO_INVALID_CTIME |
| NFS_INO_REVAL_FORCED; NFS_INO_REVAL_FORCED);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
d_move(dentry, sdentry); d_move(dentry, sdentry);
break; break;

8
fs/nfs/write.c
View File

@@ -303,9 +303,9 @@ static void nfs_set_pageerror(struct address_space *mapping)
nfs_zap_mapping(mapping->host, mapping); nfs_zap_mapping(mapping->host, mapping);
/* Force file size revalidation */ /* Force file size revalidation */
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
NFS_I(inode)->cache_validity |= NFS_INO_REVAL_FORCED | nfs_set_cache_invalid(inode, NFS_INO_REVAL_FORCED |
NFS_INO_REVAL_PAGECACHE | NFS_INO_REVAL_PAGECACHE |
NFS_INO_INVALID_SIZE; NFS_INO_INVALID_SIZE);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
} }
@@ -1604,7 +1604,7 @@ static int nfs_writeback_done(struct rpc_task *task,
/* Deal with the suid/sgid bit corner case */ /* Deal with the suid/sgid bit corner case */
if (nfs_should_remove_suid(inode)) { if (nfs_should_remove_suid(inode)) {
spin_lock(&inode->i_lock); spin_lock(&inode->i_lock);
NFS_I(inode)->cache_validity |= NFS_INO_INVALID_OTHER; nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
spin_unlock(&inode->i_lock); spin_unlock(&inode->i_lock);
} }
return 0; return 0;

5
net/sunrpc/sched.c
View File

@@ -963,8 +963,11 @@ void rpc_execute(struct rpc_task *task)
rpc_set_active(task); rpc_set_active(task);
rpc_make_runnable(rpciod_workqueue, task); rpc_make_runnable(rpciod_workqueue, task);
if (!is_async) if (!is_async) {
unsigned int pflags = memalloc_nofs_save();
__rpc_execute(task); __rpc_execute(task);
memalloc_nofs_restore(pflags);
}
} }
static void rpc_async_schedule(struct work_struct *work) static void rpc_async_schedule(struct work_struct *work)