NFS client updates for Linux 5.9
Highlights include: Stable fixes: - pNFS: Don't return layout segments that are being used for I/O - pNFS: Don't move layout segments off the active list when being used for I/O Features: - NFS: Add support for user xattrs through the NFSv4.2 protocol - NFS: Allow applications to speed up readdir+statx() using AT_STATX_DONT_SYNC - NFSv4.0 allow nconnect for v4.0 Bugfixes and cleanups: - nfs: ensure correct writeback errors are returned on close() - nfs: nfs_file_write() should check for writeback errors - nfs: Fix getxattr kernel panic and memory overflow - NFS: Fix the pNFS/flexfiles mirrored read failover code - SUNRPC: dont update timeout value on connection reset - freezer: Add unsafe versions of freezable_schedule_timeout_interruptible for NFS - sunrpc: destroy rpc_inode_cachep after unregister_filesystem -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEESQctxSBg8JpV8KqEZwvnipYKAPIFAl83CYEACgkQZwvnipYK APLx4g/9EQNTG5VkUToElRHs4b3vFxbmh9Odnk/JwPHxY5GQ8/AyGqwWHBgMZc7/ 2AV/C83pk7pJsDNsKbVAaFCT1cwjmItHM63vKJYGBYbE8LhkZ/1sYkdtPBYwHoVl 7CWfpVY/4NjYw5GJfrVA5Y0m7lrQInRtIMzfaENw2tpw+/cKUpadxgEJltzFNvpa Ploinr1ZRBl1tvfeHNRP5ZMPk2AfgGWtQKQ/b2UWUk5tXALoQm2Eu+/oku39uqhy hW5tCbU2BzR91gg5JwF9n7VowkCHXfe7lMzDBTVfwZOELOmoyys/1wKv550FWcWi yymljWiPGZOnXGT1vfKptPESQjdtElMfanvEZ0BzS+yNR0HZGnIupaxGlYlG9ZGU 2sXHQPp3mk2Q+L1IgbTSCnSju0YlZo32JQpYCZiROjIXnPWPQ50YNhr8GL18M1FW hTeShg2avWH+59GB6moEBmsuvui7Dy1jkimblToLEoGJ4kbvEl72FYSqTCkAXXbB rVUzhmJFgfk/EOS4d+QKJoBqNzw3aw79wyT7PLkoCYBqPZBHQexlmI+ktMbgUEdw c/fM7l5/Vcb9weIHKzul2Jbk5q6bFME/xPnIkr3v/oKIFlLFwQ04BX6R/42AMJHw V5Q9Wp81Vy6RXQMn8P0ZMeY0WQC/rhpijOEVMUC+Ni+spz44AdM= =k4pE -----END PGP SIGNATURE----- Merge tag 'nfs-for-5.9-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs Pull NFS client updates from Trond Myklebust: "Stable fixes: - pNFS: Don't return layout segments that are being used for I/O - pNFS: Don't move layout segments off the active list when being used for I/O Features: - NFS: Add support for user xattrs through the NFSv4.2 protocol - NFS: Allow applications to speed up readdir+statx() using AT_STATX_DONT_SYNC - NFSv4.0 allow nconnect for v4.0 Bugfixes and cleanups: - nfs: ensure correct writeback errors are returned on close() - nfs: nfs_file_write() should check for writeback errors - nfs: Fix getxattr kernel panic and memory overflow - NFS: Fix the pNFS/flexfiles mirrored read failover code - SUNRPC: dont update timeout value on connection reset - freezer: Add unsafe versions of freezable_schedule_timeout_interruptible for NFS - sunrpc: destroy rpc_inode_cachep after unregister_filesystem" * tag 'nfs-for-5.9-1' of git://git.linux-nfs.org/projects/trondmy/linux-nfs: (32 commits) NFS: Fix flexfiles read failover fs: nfs: delete repeated words in comments rpc_pipefs: convert comma to semicolon nfs: Fix getxattr kernel panic and memory overflow NFS: Don't return layout segments that are in use NFS: Don't move layouts to plh_return_segs list while in use NFS: Add layout segment info to pnfs read/write/commit tracepoints NFS: Add tracepoints for layouterror and layoutstats. NFS: Report the stateid + status in trace_nfs4_layoutreturn_on_close() SUNRPC dont update timeout value on connection reset nfs: nfs_file_write() should check for writeback errors nfs: ensure correct writeback errors are returned on close() NFSv4.2: xattr cache: get rid of cache discard work queue NFS: remove redundant initialization of variable result NFSv4.0 allow nconnect for v4.0 freezer: Add unsafe versions of freezable_schedule_timeout_interruptible for NFS sunrpc: destroy rpc_inode_cachep after unregister_filesystem NFSv4.2: add client side xattr caching. NFSv4.2: hook in the user extended attribute handlers NFSv4.2: add the extended attribute proc functions. ...zero-sugar-mainline-defconfig
commit
37711e5e23
|
@ -30,7 +30,7 @@ nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o
|
|||
nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o
|
||||
nfsv4-$(CONFIG_SYSCTL) += nfs4sysctl.o
|
||||
nfsv4-$(CONFIG_NFS_V4_1) += pnfs.o pnfs_dev.o pnfs_nfs.o
|
||||
nfsv4-$(CONFIG_NFS_V4_2) += nfs42proc.o
|
||||
nfsv4-$(CONFIG_NFS_V4_2) += nfs42proc.o nfs42xattr.o
|
||||
|
||||
obj-$(CONFIG_PNFS_FILE_LAYOUT) += filelayout/
|
||||
obj-$(CONFIG_PNFS_BLOCK) += blocklayout/
|
||||
|
|
|
@ -79,7 +79,7 @@ bl_resolve_deviceid(struct nfs_server *server, struct pnfs_block_volume *b,
|
|||
goto out_free_data;
|
||||
|
||||
bl_msg = msg->data;
|
||||
bl_msg->type = BL_DEVICE_MOUNT,
|
||||
bl_msg->type = BL_DEVICE_MOUNT;
|
||||
bl_msg->totallen = b->simple.len;
|
||||
nfs4_encode_simple(msg->data + sizeof(*bl_msg), b);
|
||||
|
||||
|
|
|
@ -50,6 +50,7 @@
|
|||
#include "nfs.h"
|
||||
#include "netns.h"
|
||||
#include "sysfs.h"
|
||||
#include "nfs42.h"
|
||||
|
||||
#define NFSDBG_FACILITY NFSDBG_CLIENT
|
||||
|
||||
|
@ -749,7 +750,7 @@ error:
|
|||
static void nfs_server_set_fsinfo(struct nfs_server *server,
|
||||
struct nfs_fsinfo *fsinfo)
|
||||
{
|
||||
unsigned long max_rpc_payload;
|
||||
unsigned long max_rpc_payload, raw_max_rpc_payload;
|
||||
|
||||
/* Work out a lot of parameters */
|
||||
if (server->rsize == 0)
|
||||
|
@ -762,7 +763,9 @@ static void nfs_server_set_fsinfo(struct nfs_server *server,
|
|||
if (fsinfo->wtmax >= 512 && server->wsize > fsinfo->wtmax)
|
||||
server->wsize = nfs_block_size(fsinfo->wtmax, NULL);
|
||||
|
||||
max_rpc_payload = nfs_block_size(rpc_max_payload(server->client), NULL);
|
||||
raw_max_rpc_payload = rpc_max_payload(server->client);
|
||||
max_rpc_payload = nfs_block_size(raw_max_rpc_payload, NULL);
|
||||
|
||||
if (server->rsize > max_rpc_payload)
|
||||
server->rsize = max_rpc_payload;
|
||||
if (server->rsize > NFS_MAX_FILE_IO_SIZE)
|
||||
|
@ -795,6 +798,21 @@ static void nfs_server_set_fsinfo(struct nfs_server *server,
|
|||
server->clone_blksize = fsinfo->clone_blksize;
|
||||
/* We're airborne Set socket buffersize */
|
||||
rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
/*
|
||||
* Defaults until limited by the session parameters.
|
||||
*/
|
||||
server->gxasize = min_t(unsigned int, raw_max_rpc_payload,
|
||||
XATTR_SIZE_MAX);
|
||||
server->sxasize = min_t(unsigned int, raw_max_rpc_payload,
|
||||
XATTR_SIZE_MAX);
|
||||
server->lxasize = min_t(unsigned int, raw_max_rpc_payload,
|
||||
nfs42_listxattr_xdrsize(XATTR_LIST_MAX));
|
||||
|
||||
if (fsinfo->xattr_support)
|
||||
server->caps |= NFS_CAP_XATTR;
|
||||
#endif
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
24
fs/nfs/dir.c
24
fs/nfs/dir.c
|
@ -2460,7 +2460,7 @@ static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, co
|
|||
return NULL;
|
||||
}
|
||||
|
||||
static int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res, bool may_block)
|
||||
static int nfs_access_get_cached_locked(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res, bool may_block)
|
||||
{
|
||||
struct nfs_inode *nfsi = NFS_I(inode);
|
||||
struct nfs_access_entry *cache;
|
||||
|
@ -2533,6 +2533,20 @@ out:
|
|||
return err;
|
||||
}
|
||||
|
||||
int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct
|
||||
nfs_access_entry *res, bool may_block)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = nfs_access_get_cached_rcu(inode, cred, res);
|
||||
if (status != 0)
|
||||
status = nfs_access_get_cached_locked(inode, cred, res,
|
||||
may_block);
|
||||
|
||||
return status;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nfs_access_get_cached);
|
||||
|
||||
static void nfs_access_add_rbtree(struct inode *inode, struct nfs_access_entry *set)
|
||||
{
|
||||
struct nfs_inode *nfsi = NFS_I(inode);
|
||||
|
@ -2647,9 +2661,7 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)
|
|||
|
||||
trace_nfs_access_enter(inode);
|
||||
|
||||
status = nfs_access_get_cached_rcu(inode, cred, &cache);
|
||||
if (status != 0)
|
||||
status = nfs_access_get_cached(inode, cred, &cache, may_block);
|
||||
status = nfs_access_get_cached(inode, cred, &cache, may_block);
|
||||
if (status == 0)
|
||||
goto out_cached;
|
||||
|
||||
|
@ -2661,6 +2673,10 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)
|
|||
* Determine which access bits we want to ask for...
|
||||
*/
|
||||
cache.mask = NFS_ACCESS_READ | NFS_ACCESS_MODIFY | NFS_ACCESS_EXTEND;
|
||||
if (nfs_server_capable(inode, NFS_CAP_XATTR)) {
|
||||
cache.mask |= NFS_ACCESS_XAREAD | NFS_ACCESS_XAWRITE |
|
||||
NFS_ACCESS_XALIST;
|
||||
}
|
||||
if (S_ISDIR(inode->i_mode))
|
||||
cache.mask |= NFS_ACCESS_DELETE | NFS_ACCESS_LOOKUP;
|
||||
else
|
||||
|
|
|
@ -896,7 +896,7 @@ static ssize_t nfs_direct_write_schedule_iovec(struct nfs_direct_req *dreq,
|
|||
*/
|
||||
ssize_t nfs_file_direct_write(struct kiocb *iocb, struct iov_iter *iter)
|
||||
{
|
||||
ssize_t result = -EINVAL, requested;
|
||||
ssize_t result, requested;
|
||||
size_t count;
|
||||
struct file *file = iocb->ki_filp;
|
||||
struct address_space *mapping = file->f_mapping;
|
||||
|
|
|
@ -140,6 +140,7 @@ static int
|
|||
nfs_file_flush(struct file *file, fl_owner_t id)
|
||||
{
|
||||
struct inode *inode = file_inode(file);
|
||||
errseq_t since;
|
||||
|
||||
dprintk("NFS: flush(%pD2)\n", file);
|
||||
|
||||
|
@ -148,7 +149,9 @@ nfs_file_flush(struct file *file, fl_owner_t id)
|
|||
return 0;
|
||||
|
||||
/* Flush writes to the server and return any errors */
|
||||
return nfs_wb_all(inode);
|
||||
since = filemap_sample_wb_err(file->f_mapping);
|
||||
nfs_wb_all(inode);
|
||||
return filemap_check_wb_err(file->f_mapping, since);
|
||||
}
|
||||
|
||||
ssize_t
|
||||
|
@ -587,12 +590,14 @@ static const struct vm_operations_struct nfs_file_vm_ops = {
|
|||
.page_mkwrite = nfs_vm_page_mkwrite,
|
||||
};
|
||||
|
||||
static int nfs_need_check_write(struct file *filp, struct inode *inode)
|
||||
static int nfs_need_check_write(struct file *filp, struct inode *inode,
|
||||
int error)
|
||||
{
|
||||
struct nfs_open_context *ctx;
|
||||
|
||||
ctx = nfs_file_open_context(filp);
|
||||
if (nfs_ctx_key_to_expire(ctx, inode))
|
||||
if (nfs_error_is_fatal_on_server(error) ||
|
||||
nfs_ctx_key_to_expire(ctx, inode))
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
@ -603,6 +608,8 @@ ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
|
|||
struct inode *inode = file_inode(file);
|
||||
unsigned long written = 0;
|
||||
ssize_t result;
|
||||
errseq_t since;
|
||||
int error;
|
||||
|
||||
result = nfs_key_timeout_notify(file, inode);
|
||||
if (result)
|
||||
|
@ -627,6 +634,7 @@ ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
|
|||
if (iocb->ki_pos > i_size_read(inode))
|
||||
nfs_revalidate_mapping(inode, file->f_mapping);
|
||||
|
||||
since = filemap_sample_wb_err(file->f_mapping);
|
||||
nfs_start_io_write(inode);
|
||||
result = generic_write_checks(iocb, from);
|
||||
if (result > 0) {
|
||||
|
@ -645,7 +653,8 @@ ssize_t nfs_file_write(struct kiocb *iocb, struct iov_iter *from)
|
|||
goto out;
|
||||
|
||||
/* Return error values */
|
||||
if (nfs_need_check_write(file, inode)) {
|
||||
error = filemap_check_wb_err(file->f_mapping, since);
|
||||
if (nfs_need_check_write(file, inode, error)) {
|
||||
int err = nfs_wb_all(inode);
|
||||
if (err < 0)
|
||||
result = err;
|
||||
|
|
|
@ -790,6 +790,19 @@ ff_layout_choose_best_ds_for_read(struct pnfs_layout_segment *lseg,
|
|||
return ff_layout_choose_any_ds_for_read(lseg, start_idx, best_idx);
|
||||
}
|
||||
|
||||
static struct nfs4_pnfs_ds *
|
||||
ff_layout_get_ds_for_read(struct nfs_pageio_descriptor *pgio, int *best_idx)
|
||||
{
|
||||
struct pnfs_layout_segment *lseg = pgio->pg_lseg;
|
||||
struct nfs4_pnfs_ds *ds;
|
||||
|
||||
ds = ff_layout_choose_best_ds_for_read(lseg, pgio->pg_mirror_idx,
|
||||
best_idx);
|
||||
if (ds || !pgio->pg_mirror_idx)
|
||||
return ds;
|
||||
return ff_layout_choose_best_ds_for_read(lseg, 0, best_idx);
|
||||
}
|
||||
|
||||
static void
|
||||
ff_layout_pg_get_read(struct nfs_pageio_descriptor *pgio,
|
||||
struct nfs_page *req,
|
||||
|
@ -840,12 +853,11 @@ retry:
|
|||
goto out_nolseg;
|
||||
}
|
||||
|
||||
ds = ff_layout_choose_best_ds_for_read(pgio->pg_lseg, 0, &ds_idx);
|
||||
ds = ff_layout_get_ds_for_read(pgio, &ds_idx);
|
||||
if (!ds) {
|
||||
if (!ff_layout_no_fallback_to_mds(pgio->pg_lseg))
|
||||
goto out_mds;
|
||||
pnfs_put_lseg(pgio->pg_lseg);
|
||||
pgio->pg_lseg = NULL;
|
||||
pnfs_generic_pg_cleanup(pgio);
|
||||
/* Sleep for 1 second before retrying */
|
||||
ssleep(1);
|
||||
goto retry;
|
||||
|
@ -871,8 +883,6 @@ out_mds:
|
|||
0, NFS4_MAX_UINT64, IOMODE_READ,
|
||||
NFS_I(pgio->pg_inode)->layout,
|
||||
pgio->pg_lseg);
|
||||
pnfs_put_lseg(pgio->pg_lseg);
|
||||
pgio->pg_lseg = NULL;
|
||||
pgio->pg_maxretrans = 0;
|
||||
nfs_pageio_reset_read_mds(pgio);
|
||||
}
|
||||
|
@ -916,8 +926,7 @@ retry:
|
|||
if (!ds) {
|
||||
if (!ff_layout_no_fallback_to_mds(pgio->pg_lseg))
|
||||
goto out_mds;
|
||||
pnfs_put_lseg(pgio->pg_lseg);
|
||||
pgio->pg_lseg = NULL;
|
||||
pnfs_generic_pg_cleanup(pgio);
|
||||
/* Sleep for 1 second before retrying */
|
||||
ssleep(1);
|
||||
goto retry;
|
||||
|
@ -939,8 +948,6 @@ out_mds:
|
|||
0, NFS4_MAX_UINT64, IOMODE_RW,
|
||||
NFS_I(pgio->pg_inode)->layout,
|
||||
pgio->pg_lseg);
|
||||
pnfs_put_lseg(pgio->pg_lseg);
|
||||
pgio->pg_lseg = NULL;
|
||||
pgio->pg_maxretrans = 0;
|
||||
nfs_pageio_reset_write_mds(pgio);
|
||||
pgio->pg_error = -EAGAIN;
|
||||
|
@ -953,8 +960,8 @@ ff_layout_pg_get_mirror_count_write(struct nfs_pageio_descriptor *pgio,
|
|||
if (!pgio->pg_lseg) {
|
||||
pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
|
||||
nfs_req_openctx(req),
|
||||
0,
|
||||
NFS4_MAX_UINT64,
|
||||
req_offset(req),
|
||||
req->wb_bytes,
|
||||
IOMODE_RW,
|
||||
false,
|
||||
GFP_NOFS);
|
||||
|
@ -1028,11 +1035,24 @@ static void ff_layout_reset_write(struct nfs_pgio_header *hdr, bool retry_pnfs)
|
|||
}
|
||||
}
|
||||
|
||||
static void ff_layout_resend_pnfs_read(struct nfs_pgio_header *hdr)
|
||||
{
|
||||
u32 idx = hdr->pgio_mirror_idx + 1;
|
||||
int new_idx = 0;
|
||||
|
||||
if (ff_layout_choose_any_ds_for_read(hdr->lseg, idx + 1, &new_idx))
|
||||
ff_layout_send_layouterror(hdr->lseg);
|
||||
else
|
||||
pnfs_error_mark_layout_for_return(hdr->inode, hdr->lseg);
|
||||
pnfs_read_resend_pnfs(hdr, new_idx);
|
||||
}
|
||||
|
||||
static void ff_layout_reset_read(struct nfs_pgio_header *hdr)
|
||||
{
|
||||
struct rpc_task *task = &hdr->task;
|
||||
|
||||
pnfs_layoutcommit_inode(hdr->inode, false);
|
||||
pnfs_error_mark_layout_for_return(hdr->inode, hdr->lseg);
|
||||
|
||||
if (!test_and_set_bit(NFS_IOHDR_REDO, &hdr->flags)) {
|
||||
dprintk("%s Reset task %5u for i/o through MDS "
|
||||
|
@ -1234,6 +1254,12 @@ static void ff_layout_io_track_ds_error(struct pnfs_layout_segment *lseg,
|
|||
break;
|
||||
case NFS4ERR_NXIO:
|
||||
ff_layout_mark_ds_unreachable(lseg, idx);
|
||||
/*
|
||||
* Don't return the layout if this is a read and we still
|
||||
* have layouts to try
|
||||
*/
|
||||
if (opnum == OP_READ)
|
||||
break;
|
||||
/* Fallthrough */
|
||||
default:
|
||||
pnfs_error_mark_layout_for_return(lseg->pls_layout->plh_inode,
|
||||
|
@ -1247,7 +1273,6 @@ static void ff_layout_io_track_ds_error(struct pnfs_layout_segment *lseg,
|
|||
static int ff_layout_read_done_cb(struct rpc_task *task,
|
||||
struct nfs_pgio_header *hdr)
|
||||
{
|
||||
int new_idx = hdr->pgio_mirror_idx;
|
||||
int err;
|
||||
|
||||
if (task->tk_status < 0) {
|
||||
|
@ -1267,10 +1292,6 @@ static int ff_layout_read_done_cb(struct rpc_task *task,
|
|||
clear_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags);
|
||||
switch (err) {
|
||||
case -NFS4ERR_RESET_TO_PNFS:
|
||||
if (ff_layout_choose_best_ds_for_read(hdr->lseg,
|
||||
hdr->pgio_mirror_idx + 1,
|
||||
&new_idx))
|
||||
goto out_layouterror;
|
||||
set_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags);
|
||||
return task->tk_status;
|
||||
case -NFS4ERR_RESET_TO_MDS:
|
||||
|
@ -1281,10 +1302,6 @@ static int ff_layout_read_done_cb(struct rpc_task *task,
|
|||
}
|
||||
|
||||
return 0;
|
||||
out_layouterror:
|
||||
ff_layout_read_record_layoutstats_done(task, hdr);
|
||||
ff_layout_send_layouterror(hdr->lseg);
|
||||
hdr->pgio_mirror_idx = new_idx;
|
||||
out_eagain:
|
||||
rpc_restart_call_prepare(task);
|
||||
return -EAGAIN;
|
||||
|
@ -1411,10 +1428,9 @@ static void ff_layout_read_release(void *data)
|
|||
struct nfs_pgio_header *hdr = data;
|
||||
|
||||
ff_layout_read_record_layoutstats_done(&hdr->task, hdr);
|
||||
if (test_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags)) {
|
||||
ff_layout_send_layouterror(hdr->lseg);
|
||||
pnfs_read_resend_pnfs(hdr);
|
||||
} else if (test_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags))
|
||||
if (test_bit(NFS_IOHDR_RESEND_PNFS, &hdr->flags))
|
||||
ff_layout_resend_pnfs_read(hdr);
|
||||
else if (test_bit(NFS_IOHDR_RESEND_MDS, &hdr->flags))
|
||||
ff_layout_reset_read(hdr);
|
||||
pnfs_generic_rw_release(data);
|
||||
}
|
||||
|
|
|
@ -982,7 +982,7 @@ static int nfs23_parse_monolithic(struct fs_context *fc,
|
|||
/*
|
||||
* The legacy version 6 binary mount data from userspace has a
|
||||
* field used only to transport selinux information into the
|
||||
* the kernel. To continue to support that functionality we
|
||||
* kernel. To continue to support that functionality we
|
||||
* have a touch of selinux knowledge here in the NFS code. The
|
||||
* userspace code converted context=blah to just blah so we are
|
||||
* converting back to the full string selinux understands.
|
||||
|
|
|
@ -193,6 +193,7 @@ bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)
|
|||
|
||||
return nfs_check_cache_invalid_not_delegated(inode, flags);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nfs_check_cache_invalid);
|
||||
|
||||
static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
|
||||
{
|
||||
|
@ -204,7 +205,8 @@ static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags)
|
|||
flags &= ~NFS_INO_INVALID_OTHER;
|
||||
flags &= ~(NFS_INO_INVALID_CHANGE
|
||||
| NFS_INO_INVALID_SIZE
|
||||
| NFS_INO_REVAL_PAGECACHE);
|
||||
| NFS_INO_REVAL_PAGECACHE
|
||||
| NFS_INO_INVALID_XATTR);
|
||||
}
|
||||
|
||||
if (inode->i_mapping->nrpages == 0)
|
||||
|
@ -233,11 +235,13 @@ static void nfs_zap_caches_locked(struct inode *inode)
|
|||
| NFS_INO_INVALID_DATA
|
||||
| NFS_INO_INVALID_ACCESS
|
||||
| NFS_INO_INVALID_ACL
|
||||
| NFS_INO_INVALID_XATTR
|
||||
| NFS_INO_REVAL_PAGECACHE);
|
||||
} else
|
||||
nfs_set_cache_invalid(inode, NFS_INO_INVALID_ATTR
|
||||
| NFS_INO_INVALID_ACCESS
|
||||
| NFS_INO_INVALID_ACL
|
||||
| NFS_INO_INVALID_XATTR
|
||||
| NFS_INO_REVAL_PAGECACHE);
|
||||
nfs_zap_label_cache_locked(nfsi);
|
||||
}
|
||||
|
@ -542,6 +546,8 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st
|
|||
inode->i_gid = fattr->gid;
|
||||
else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP))
|
||||
nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER);
|
||||
if (nfs_server_capable(inode, NFS_CAP_XATTR))
|
||||
nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
|
||||
if (fattr->valid & NFS_ATTR_FATTR_BLOCKS_USED)
|
||||
inode->i_blocks = fattr->du.nfs2.blocks;
|
||||
if (fattr->valid & NFS_ATTR_FATTR_SPACE_USED) {
|
||||
|
@ -794,8 +800,10 @@ int nfs_getattr(const struct path *path, struct kstat *stat,
|
|||
|
||||
trace_nfs_getattr_enter(inode);
|
||||
|
||||
if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync)
|
||||
if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) {
|
||||
nfs_readdirplus_parent_cache_hit(path->dentry);
|
||||
goto out_no_update;
|
||||
}
|
||||
|
||||
/* Flush out writes to the server in order to update c/mtime. */
|
||||
if ((request_mask & (STATX_CTIME|STATX_MTIME)) &&
|
||||
|
@ -1375,6 +1383,8 @@ static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)
|
|||
inode_set_iversion_raw(inode, fattr->change_attr);
|
||||
if (S_ISDIR(inode->i_mode))
|
||||
nfs_set_cache_invalid(inode, NFS_INO_INVALID_DATA);
|
||||
else if (nfs_server_capable(inode, NFS_CAP_XATTR))
|
||||
nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);
|
||||
}
|
||||
/* If we have atomic WCC data, we may update some attributes */
|
||||
ts = inode->i_ctime;
|
||||
|
@ -1892,7 +1902,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
|
|||
if (!(have_writers || have_delegation)) {
|
||||
invalid |= NFS_INO_INVALID_DATA
|
||||
| NFS_INO_INVALID_ACCESS
|
||||
| NFS_INO_INVALID_ACL;
|
||||
| NFS_INO_INVALID_ACL
|
||||
| NFS_INO_INVALID_XATTR;
|
||||
/* Force revalidate of all attributes */
|
||||
save_cache_validity |= NFS_INO_INVALID_CTIME
|
||||
| NFS_INO_INVALID_MTIME
|
||||
|
@ -2095,6 +2106,9 @@ struct inode *nfs_alloc_inode(struct super_block *sb)
|
|||
#if IS_ENABLED(CONFIG_NFS_V4)
|
||||
nfsi->nfs4_acl = NULL;
|
||||
#endif /* CONFIG_NFS_V4 */
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
nfsi->xattr_cache = NULL;
|
||||
#endif
|
||||
return &nfsi->vfs_inode;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(nfs_alloc_inode);
|
||||
|
|
|
@ -6,6 +6,8 @@
|
|||
#ifndef __LINUX_FS_NFS_NFS4_2_H
|
||||
#define __LINUX_FS_NFS_NFS4_2_H
|
||||
|
||||
#include <linux/xattr.h>
|
||||
|
||||
/*
|
||||
* FIXME: four LAYOUTSTATS calls per compound at most! Do we need to support
|
||||
* more? Need to consider not to pre-alloc too much for a compound.
|
||||
|
@ -36,5 +38,27 @@ static inline bool nfs42_files_from_same_server(struct file *in,
|
|||
return nfs4_check_serverowner_major_id(c_in->cl_serverowner,
|
||||
c_out->cl_serverowner);
|
||||
}
|
||||
|
||||
ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
|
||||
void *buf, size_t buflen);
|
||||
int nfs42_proc_setxattr(struct inode *inode, const char *name,
|
||||
const void *buf, size_t buflen, int flags);
|
||||
ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
|
||||
size_t buflen, u64 *cookiep, bool *eofp);
|
||||
int nfs42_proc_removexattr(struct inode *inode, const char *name);
|
||||
|
||||
/*
|
||||
* Maximum XDR buffer size needed for a listxattr buffer of buflen size.
|
||||
*
|
||||
* The upper boundary is a buffer with all 1-byte sized attribute names.
|
||||
* They would be 7 bytes long in the eventual buffer ("user.x\0"), and
|
||||
* 8 bytes long XDR-encoded.
|
||||
*
|
||||
* Include the trailing eof word as well.
|
||||
*/
|
||||
static inline u32 nfs42_listxattr_xdrsize(u32 buflen)
|
||||
{
|
||||
return ((buflen / (XATTR_USER_PREFIX_LEN + 2)) * 8) + 4;
|
||||
}
|
||||
#endif /* CONFIG_NFS_V4_2 */
|
||||
#endif /* __LINUX_FS_NFS_NFS4_2_H */
|
||||
|
|
|
@ -17,6 +17,7 @@
|
|||
#include "nfs4session.h"
|
||||
#include "internal.h"
|
||||
#include "delegation.h"
|
||||
#include "nfs4trace.h"
|
||||
|
||||
#define NFSDBG_FACILITY NFSDBG_PROC
|
||||
static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
|
||||
|
@ -714,7 +715,7 @@ nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
|
|||
|
||||
switch (task->tk_status) {
|
||||
case 0:
|
||||
break;
|
||||
return;
|
||||
case -NFS4ERR_BADHANDLE:
|
||||
case -ESTALE:
|
||||
pnfs_destroy_layout(NFS_I(inode));
|
||||
|
@ -760,6 +761,8 @@ nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
|
|||
case -EOPNOTSUPP:
|
||||
NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
|
||||
}
|
||||
|
||||
trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -882,7 +885,7 @@ nfs42_layouterror_done(struct rpc_task *task, void *calldata)
|
|||
|
||||
switch (task->tk_status) {
|
||||
case 0:
|
||||
break;
|
||||
return;
|
||||
case -NFS4ERR_BADHANDLE:
|
||||
case -ESTALE:
|
||||
pnfs_destroy_layout(NFS_I(inode));
|
||||
|
@ -926,6 +929,9 @@ nfs42_layouterror_done(struct rpc_task *task, void *calldata)
|
|||
case -EOPNOTSUPP:
|
||||
NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
|
||||
}
|
||||
|
||||
trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
|
||||
task->tk_status);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -1088,3 +1094,251 @@ out_put_src_lock:
|
|||
nfs_put_lock_context(src_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
#define NFS4XATTR_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
|
||||
|
||||
static int _nfs42_proc_removexattr(struct inode *inode, const char *name)
|
||||
{
|
||||
struct nfs_server *server = NFS_SERVER(inode);
|
||||
struct nfs42_removexattrargs args = {
|
||||
.fh = NFS_FH(inode),
|
||||
.xattr_name = name,
|
||||
};
|
||||
struct nfs42_removexattrres res;
|
||||
struct rpc_message msg = {
|
||||
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVEXATTR],
|
||||
.rpc_argp = &args,
|
||||
.rpc_resp = &res,
|
||||
};
|
||||
int ret;
|
||||
unsigned long timestamp = jiffies;
|
||||
|
||||
ret = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
|
||||
&res.seq_res, 1);
|
||||
if (!ret)
|
||||
nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int _nfs42_proc_setxattr(struct inode *inode, const char *name,
|
||||
const void *buf, size_t buflen, int flags)
|
||||
{
|
||||
struct nfs_server *server = NFS_SERVER(inode);
|
||||
struct page *pages[NFS4XATTR_MAXPAGES];
|
||||
struct nfs42_setxattrargs arg = {
|
||||
.fh = NFS_FH(inode),
|
||||
.xattr_pages = pages,
|
||||
.xattr_len = buflen,
|
||||
.xattr_name = name,
|
||||
.xattr_flags = flags,
|
||||
};
|
||||
struct nfs42_setxattrres res;
|
||||
struct rpc_message msg = {
|
||||
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETXATTR],
|
||||
.rpc_argp = &arg,
|
||||
.rpc_resp = &res,
|
||||
};
|
||||
int ret, np;
|
||||
unsigned long timestamp = jiffies;
|
||||
|
||||
if (buflen > server->sxasize)
|
||||
return -ERANGE;
|
||||
|
||||
if (buflen > 0) {
|
||||
np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
|
||||
if (np < 0)
|
||||
return np;
|
||||
} else
|
||||
np = 0;
|
||||
|
||||
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
||||
&res.seq_res, 1);
|
||||
|
||||
for (; np > 0; np--)
|
||||
put_page(pages[np - 1]);
|
||||
|
||||
if (!ret)
|
||||
nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
|
||||
void *buf, size_t buflen)
|
||||
{
|
||||
struct nfs_server *server = NFS_SERVER(inode);
|
||||
struct page *pages[NFS4XATTR_MAXPAGES] = {};
|
||||
struct nfs42_getxattrargs arg = {
|
||||
.fh = NFS_FH(inode),
|
||||
.xattr_pages = pages,
|
||||
.xattr_len = buflen,
|
||||
.xattr_name = name,
|
||||
};
|
||||
struct nfs42_getxattrres res;
|
||||
struct rpc_message msg = {
|
||||
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
|
||||
.rpc_argp = &arg,
|
||||
.rpc_resp = &res,
|
||||
};
|
||||
int ret, np;
|
||||
|
||||
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
||||
&res.seq_res, 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
/*
|
||||
* Normally, the caching is done one layer up, but for successful
|
||||
* RPCS, always cache the result here, even if the caller was
|
||||
* just querying the length, or if the reply was too big for
|
||||
* the caller. This avoids a second RPC in the case of the
|
||||
* common query-alloc-retrieve cycle for xattrs.
|
||||
*
|
||||
* Note that xattr_len is always capped to XATTR_SIZE_MAX.
|
||||
*/
|
||||
|
||||
nfs4_xattr_cache_add(inode, name, NULL, pages, res.xattr_len);
|
||||
|
||||
if (buflen) {
|
||||
if (res.xattr_len > buflen)
|
||||
return -ERANGE;
|
||||
_copy_from_pages(buf, pages, 0, res.xattr_len);
|
||||
}
|
||||
|
||||
np = DIV_ROUND_UP(res.xattr_len, PAGE_SIZE);
|
||||
while (--np >= 0)
|
||||
__free_page(pages[np]);
|
||||
|
||||
return res.xattr_len;
|
||||
}
|
||||
|
||||
static ssize_t _nfs42_proc_listxattrs(struct inode *inode, void *buf,
|
||||
size_t buflen, u64 *cookiep, bool *eofp)
|
||||
{
|
||||
struct nfs_server *server = NFS_SERVER(inode);
|
||||
struct page **pages;
|
||||
struct nfs42_listxattrsargs arg = {
|
||||
.fh = NFS_FH(inode),
|
||||
.cookie = *cookiep,
|
||||
};
|
||||
struct nfs42_listxattrsres res = {
|
||||
.eof = false,
|
||||
.xattr_buf = buf,
|
||||
.xattr_len = buflen,
|
||||
};
|
||||
struct rpc_message msg = {
|
||||
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LISTXATTRS],
|
||||
.rpc_argp = &arg,
|
||||
.rpc_resp = &res,
|
||||
};
|
||||
u32 xdrlen;
|
||||
int ret, np;
|
||||
|
||||
|
||||
res.scratch = alloc_page(GFP_KERNEL);
|
||||
if (!res.scratch)
|
||||
return -ENOMEM;
|
||||
|
||||
xdrlen = nfs42_listxattr_xdrsize(buflen);
|
||||
if (xdrlen > server->lxasize)
|
||||
xdrlen = server->lxasize;
|
||||
np = xdrlen / PAGE_SIZE + 1;
|
||||
|
||||
pages = kcalloc(np, sizeof(struct page *), GFP_KERNEL);
|
||||
if (pages == NULL) {
|
||||
__free_page(res.scratch);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
arg.xattr_pages = pages;
|
||||
arg.count = xdrlen;
|
||||
|
||||
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
||||
&res.seq_res, 0);
|
||||
|
||||
if (ret >= 0) {
|
||||
ret = res.copied;
|
||||
*cookiep = res.cookie;
|
||||
*eofp = res.eof;
|
||||
}
|
||||
|
||||
while (--np >= 0) {
|
||||
if (pages[np])
|
||||
__free_page(pages[np]);
|
||||
}
|
||||
|
||||
__free_page(res.scratch);
|
||||
kfree(pages);
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
|
||||
ssize_t nfs42_proc_getxattr(struct inode *inode, const char *name,
|
||||
void *buf, size_t buflen)
|
||||
{
|
||||
struct nfs4_exception exception = { };
|
||||
ssize_t err;
|
||||
|
||||
do {
|
||||
err = _nfs42_proc_getxattr(inode, name, buf, buflen);
|
||||
if (err >= 0)
|
||||
break;
|
||||
err = nfs4_handle_exception(NFS_SERVER(inode), err,
|
||||
&exception);
|
||||
} while (exception.retry);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int nfs42_proc_setxattr(struct inode *inode, const char *name,
|
||||
const void *buf, size_t buflen, int flags)
|
||||
{
|
||||
struct nfs4_exception exception = { };
|
||||
int err;
|
||||
|
||||
do {
|
||||
err = _nfs42_proc_setxattr(inode, name, buf, buflen, flags);
|
||||
if (!err)
|
||||
break;
|
||||
err = nfs4_handle_exception(NFS_SERVER(inode), err,
|
||||
&exception);
|
||||
} while (exception.retry);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
ssize_t nfs42_proc_listxattrs(struct inode *inode, void *buf,
|
||||
size_t buflen, u64 *cookiep, bool *eofp)
|
||||
{
|
||||
struct nfs4_exception exception = { };
|
||||
ssize_t err;
|
||||
|
||||
do {
|
||||
err = _nfs42_proc_listxattrs(inode, buf, buflen,
|
||||
cookiep, eofp);
|
||||
if (err >= 0)
|
||||
break;
|
||||
err = nfs4_handle_exception(NFS_SERVER(inode), err,
|
||||
&exception);
|
||||
} while (exception.retry);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
int nfs42_proc_removexattr(struct inode *inode, const char *name)
|
||||
{
|
||||
struct nfs4_exception exception = { };
|
||||
int err;
|
||||
|
||||
do {
|
||||
err = _nfs42_proc_removexattr(inode, name);
|
||||
if (!err)
|
||||
break;
|
||||
err = nfs4_handle_exception(NFS_SERVER(inode), err,
|
||||
&exception);
|
||||
} while (exception.retry);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -169,6 +169,78 @@
|
|||
decode_clone_maxsz + \
|
||||
decode_getattr_maxsz)
|
||||
|
||||
/* Not limited by NFS itself, limited by the generic xattr code */
|
||||
#define nfs4_xattr_name_maxsz XDR_QUADLEN(XATTR_NAME_MAX)
|
||||
|
||||
#define encode_getxattr_maxsz (op_encode_hdr_maxsz + 1 + \
|
||||
nfs4_xattr_name_maxsz)
|
||||
#define decode_getxattr_maxsz (op_decode_hdr_maxsz + 1 + 1)
|
||||
#define encode_setxattr_maxsz (op_encode_hdr_maxsz + \
|
||||
1 + nfs4_xattr_name_maxsz + 1)
|
||||
#define decode_setxattr_maxsz (op_decode_hdr_maxsz + decode_change_info_maxsz)
|
||||
#define encode_listxattrs_maxsz (op_encode_hdr_maxsz + 2 + 1)
|
||||
#define decode_listxattrs_maxsz (op_decode_hdr_maxsz + 2 + 1 + 1)
|
||||
#define encode_removexattr_maxsz (op_encode_hdr_maxsz + 1 + \
|
||||
nfs4_xattr_name_maxsz)
|
||||
#define decode_removexattr_maxsz (op_decode_hdr_maxsz + \
|
||||
decode_change_info_maxsz)
|
||||
|
||||
#define NFS4_enc_getxattr_sz (compound_encode_hdr_maxsz + \
|
||||
encode_sequence_maxsz + \
|
||||
encode_putfh_maxsz + \
|
||||
encode_getxattr_maxsz)
|
||||
#define NFS4_dec_getxattr_sz (compound_decode_hdr_maxsz + \
|
||||
decode_sequence_maxsz + \
|
||||
decode_putfh_maxsz + \
|
||||
decode_getxattr_maxsz)
|
||||
#define NFS4_enc_setxattr_sz (compound_encode_hdr_maxsz + \
|
||||
encode_sequence_maxsz + \
|
||||
encode_putfh_maxsz + \
|
||||
encode_setxattr_maxsz)
|
||||
#define NFS4_dec_setxattr_sz (compound_decode_hdr_maxsz + \
|
||||
decode_sequence_maxsz + \
|
||||
decode_putfh_maxsz + \
|
||||
decode_setxattr_maxsz)
|
||||
#define NFS4_enc_listxattrs_sz (compound_encode_hdr_maxsz + \
|
||||
encode_sequence_maxsz + \
|
||||
encode_putfh_maxsz + \
|
||||
encode_listxattrs_maxsz)
|
||||
#define NFS4_dec_listxattrs_sz (compound_decode_hdr_maxsz + \
|
||||
decode_sequence_maxsz + \
|
||||
decode_putfh_maxsz + \
|
||||
decode_listxattrs_maxsz)
|
||||
#define NFS4_enc_removexattr_sz (compound_encode_hdr_maxsz + \
|
||||
encode_sequence_maxsz + \
|
||||
encode_putfh_maxsz + \
|
||||
encode_removexattr_maxsz)
|
||||
#define NFS4_dec_removexattr_sz (compound_decode_hdr_maxsz + \
|
||||
decode_sequence_maxsz + \
|
||||
decode_putfh_maxsz + \
|
||||
decode_removexattr_maxsz)
|
||||
|
||||
/*
|
||||
* These values specify the maximum amount of data that is not
|
||||
* associated with the extended attribute name or extended
|
||||
* attribute list in the SETXATTR, GETXATTR and LISTXATTR
|
||||
* respectively.
|
||||
*/
|
||||
const u32 nfs42_maxsetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
|
||||
compound_encode_hdr_maxsz +
|
||||
encode_sequence_maxsz +
|
||||
encode_putfh_maxsz + 1 +
|
||||
nfs4_xattr_name_maxsz)
|
||||
* XDR_UNIT);
|
||||
|
||||
const u32 nfs42_maxgetxattr_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
|
||||
compound_decode_hdr_maxsz +
|
||||
decode_sequence_maxsz +
|
||||
decode_putfh_maxsz + 1) * XDR_UNIT);
|
||||
|
||||
const u32 nfs42_maxlistxattrs_overhead = ((RPC_MAX_HEADER_WITH_AUTH +
|
||||
compound_decode_hdr_maxsz +
|
||||
decode_sequence_maxsz +
|
||||
decode_putfh_maxsz + 3) * XDR_UNIT);
|
||||
|
||||
static void encode_fallocate(struct xdr_stream *xdr,
|
||||
const struct nfs42_falloc_args *args)
|
||||
{
|
||||
|
@ -333,6 +405,210 @@ static void encode_layouterror(struct xdr_stream *xdr,
|
|||
encode_device_error(xdr, &args->errors[0]);
|
||||
}
|
||||
|
||||
static void encode_setxattr(struct xdr_stream *xdr,
|
||||
const struct nfs42_setxattrargs *arg,
|
||||
struct compound_hdr *hdr)
|
||||
{
|
||||
__be32 *p;
|
||||
|
||||
BUILD_BUG_ON(XATTR_CREATE != SETXATTR4_CREATE);
|
||||
BUILD_BUG_ON(XATTR_REPLACE != SETXATTR4_REPLACE);
|
||||
|
||||
encode_op_hdr(xdr, OP_SETXATTR, decode_setxattr_maxsz, hdr);
|
||||
p = reserve_space(xdr, 4);
|
||||
*p = cpu_to_be32(arg->xattr_flags);
|
||||
encode_string(xdr, strlen(arg->xattr_name), arg->xattr_name);
|
||||
p = reserve_space(xdr, 4);
|
||||
*p = cpu_to_be32(arg->xattr_len);
|
||||
if (arg->xattr_len)
|
||||
xdr_write_pages(xdr, arg->xattr_pages, 0, arg->xattr_len);
|
||||
}
|
||||
|
||||
static int decode_setxattr(struct xdr_stream *xdr,
|
||||
struct nfs4_change_info *cinfo)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = decode_op_hdr(xdr, OP_SETXATTR);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_change_info(xdr, cinfo);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
|
||||
|
||||
static void encode_getxattr(struct xdr_stream *xdr, const char *name,
|
||||
struct compound_hdr *hdr)
|
||||
{
|
||||
encode_op_hdr(xdr, OP_GETXATTR, decode_getxattr_maxsz, hdr);
|
||||
encode_string(xdr, strlen(name), name);
|
||||
}
|
||||
|
||||
static int decode_getxattr(struct xdr_stream *xdr,
|
||||
struct nfs42_getxattrres *res,
|
||||
struct rpc_rqst *req)
|
||||
{
|
||||
int status;
|
||||
__be32 *p;
|
||||
u32 len, rdlen;
|
||||
|
||||
status = decode_op_hdr(xdr, OP_GETXATTR);
|
||||
if (status)
|
||||
return status;
|
||||
|
||||
p = xdr_inline_decode(xdr, 4);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
len = be32_to_cpup(p);
|
||||
if (len > req->rq_rcv_buf.page_len)
|
||||
return -ERANGE;
|
||||
|
||||
res->xattr_len = len;
|
||||
|
||||
if (len > 0) {
|
||||
rdlen = xdr_read_pages(xdr, len);
|
||||
if (rdlen < len)
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void encode_removexattr(struct xdr_stream *xdr, const char *name,
|
||||
struct compound_hdr *hdr)
|
||||
{
|
||||
encode_op_hdr(xdr, OP_REMOVEXATTR, decode_removexattr_maxsz, hdr);
|
||||
encode_string(xdr, strlen(name), name);
|
||||
}
|
||||
|
||||
|
||||
static int decode_removexattr(struct xdr_stream *xdr,
|
||||
struct nfs4_change_info *cinfo)
|
||||
{
|
||||
int status;
|
||||
|
||||
status = decode_op_hdr(xdr, OP_REMOVEXATTR);
|
||||
if (status)
|
||||
goto out;
|
||||
|
||||
status = decode_change_info(xdr, cinfo);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
|
||||
static void encode_listxattrs(struct xdr_stream *xdr,
|
||||
const struct nfs42_listxattrsargs *arg,
|
||||
struct compound_hdr *hdr)
|
||||
{
|
||||
__be32 *p;
|
||||
|
||||
encode_op_hdr(xdr, OP_LISTXATTRS, decode_listxattrs_maxsz + 1, hdr);
|
||||
|
||||
p = reserve_space(xdr, 12);
|
||||
if (unlikely(!p))
|
||||
return;
|
||||
|
||||
p = xdr_encode_hyper(p, arg->cookie);
|
||||
/*
|
||||
* RFC 8276 says to specify the full max length of the LISTXATTRS
|
||||
* XDR reply. Count is set to the XDR length of the names array
|
||||
* plus the EOF marker. So, add the cookie and the names count.
|
||||
*/
|
||||
*p = cpu_to_be32(arg->count + 8 + 4);
|
||||
}
|
||||
|
||||
static int decode_listxattrs(struct xdr_stream *xdr,
|
||||
struct nfs42_listxattrsres *res)
|
||||
{
|
||||
int status;
|
||||
__be32 *p;
|
||||
u32 count, len, ulen;
|
||||
size_t left, copied;
|
||||
char *buf;
|
||||
|
||||
status = decode_op_hdr(xdr, OP_LISTXATTRS);
|
||||
if (status) {
|
||||
/*
|
||||
* Special case: for LISTXATTRS, NFS4ERR_TOOSMALL
|
||||
* should be translated to ERANGE.
|
||||
*/
|
||||
if (status == -ETOOSMALL)
|
||||
status = -ERANGE;
|
||||
goto out;
|
||||
}
|
||||
|
||||
p = xdr_inline_decode(xdr, 8);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
xdr_decode_hyper(p, &res->cookie);
|
||||
|
||||
p = xdr_inline_decode(xdr, 4);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
left = res->xattr_len;
|
||||
buf = res->xattr_buf;
|
||||
|
||||
count = be32_to_cpup(p);
|
||||
copied = 0;
|
||||
|
||||
/*
|
||||
* We have asked for enough room to encode the maximum number
|
||||
* of possible attribute names, so everything should fit.
|
||||
*
|
||||
* But, don't rely on that assumption. Just decode entries
|
||||
* until they don't fit anymore, just in case the server did
|
||||
* something odd.
|
||||
*/
|
||||
while (count--) {
|
||||
p = xdr_inline_decode(xdr, 4);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
len = be32_to_cpup(p);
|
||||
if (len > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) {
|
||||
status = -ERANGE;
|
||||
goto out;
|
||||
}
|
||||
|
||||
p = xdr_inline_decode(xdr, len);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
ulen = len + XATTR_USER_PREFIX_LEN + 1;
|
||||
if (buf) {
|
||||
if (ulen > left) {
|
||||
status = -ERANGE;
|
||||
goto out;
|
||||
}
|
||||
|
||||
memcpy(buf, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
|
||||
memcpy(buf + XATTR_USER_PREFIX_LEN, p, len);
|
||||
|
||||
buf[ulen - 1] = 0;
|
||||
buf += ulen;
|
||||
left -= ulen;
|
||||
}
|
||||
copied += ulen;
|
||||
}
|
||||
|
||||
p = xdr_inline_decode(xdr, 4);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
|
||||
res->eof = be32_to_cpup(p);
|
||||
res->copied = copied;
|
||||
|
||||
out:
|
||||
if (status == -ERANGE && res->xattr_len == XATTR_LIST_MAX)
|
||||
status = -E2BIG;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*
|
||||
* Encode ALLOCATE request
|
||||
*/
|
||||
|
@ -988,4 +1264,166 @@ out:
|
|||
return status;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
static void nfs4_xdr_enc_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
|
||||
const void *data)
|
||||
{
|
||||
const struct nfs42_setxattrargs *args = data;
|
||||
struct compound_hdr hdr = {
|
||||
.minorversion = nfs4_xdr_minorversion(&args->seq_args),
|
||||
};
|
||||
|
||||
encode_compound_hdr(xdr, req, &hdr);
|
||||
encode_sequence(xdr, &args->seq_args, &hdr);
|
||||
encode_putfh(xdr, args->fh, &hdr);
|
||||
encode_setxattr(xdr, args, &hdr);
|
||||
encode_nops(&hdr);
|
||||
}
|
||||
|
||||
static int nfs4_xdr_dec_setxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
|
||||
void *data)
|
||||
{
|
||||
struct nfs42_setxattrres *res = data;
|
||||
struct compound_hdr hdr;
|
||||
int status;
|
||||
|
||||
status = decode_compound_hdr(xdr, &hdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_sequence(xdr, &res->seq_res, req);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_putfh(xdr);
|
||||
if (status)
|
||||
goto out;
|
||||
|
||||
status = decode_setxattr(xdr, &res->cinfo);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
|
||||
static void nfs4_xdr_enc_getxattr(struct rpc_rqst *req, struct xdr_stream *xdr,
|
||||
const void *data)
|
||||
{
|
||||
const struct nfs42_getxattrargs *args = data;
|
||||
struct compound_hdr hdr = {
|
||||
.minorversion = nfs4_xdr_minorversion(&args->seq_args),
|
||||
};
|
||||
size_t plen;
|
||||
|
||||
encode_compound_hdr(xdr, req, &hdr);
|
||||
encode_sequence(xdr, &args->seq_args, &hdr);
|
||||
encode_putfh(xdr, args->fh, &hdr);
|
||||
encode_getxattr(xdr, args->xattr_name, &hdr);
|
||||
|
||||
plen = args->xattr_len ? args->xattr_len : XATTR_SIZE_MAX;
|
||||
|
||||
rpc_prepare_reply_pages(req, args->xattr_pages, 0, plen,
|
||||
hdr.replen);
|
||||
req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
|
||||
|
||||
encode_nops(&hdr);
|
||||
}
|
||||
|
||||
static int nfs4_xdr_dec_getxattr(struct rpc_rqst *rqstp,
|
||||
struct xdr_stream *xdr, void *data)
|
||||
{
|
||||
struct nfs42_getxattrres *res = data;
|
||||
struct compound_hdr hdr;
|
||||
int status;
|
||||
|
||||
status = decode_compound_hdr(xdr, &hdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_sequence(xdr, &res->seq_res, rqstp);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_putfh(xdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_getxattr(xdr, res, rqstp);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
|
||||
static void nfs4_xdr_enc_listxattrs(struct rpc_rqst *req,
|
||||
struct xdr_stream *xdr, const void *data)
|
||||
{
|
||||
const struct nfs42_listxattrsargs *args = data;
|
||||
struct compound_hdr hdr = {
|
||||
.minorversion = nfs4_xdr_minorversion(&args->seq_args),
|
||||
};
|
||||
|
||||
encode_compound_hdr(xdr, req, &hdr);
|
||||
encode_sequence(xdr, &args->seq_args, &hdr);
|
||||
encode_putfh(xdr, args->fh, &hdr);
|
||||
encode_listxattrs(xdr, args, &hdr);
|
||||
|
||||
rpc_prepare_reply_pages(req, args->xattr_pages, 0, args->count,
|
||||
hdr.replen);
|
||||
req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
|
||||
|
||||
encode_nops(&hdr);
|
||||
}
|
||||
|
||||
static int nfs4_xdr_dec_listxattrs(struct rpc_rqst *rqstp,
|
||||
struct xdr_stream *xdr, void *data)
|
||||
{
|
||||
struct nfs42_listxattrsres *res = data;
|
||||
struct compound_hdr hdr;
|
||||
int status;
|
||||
|
||||
xdr_set_scratch_buffer(xdr, page_address(res->scratch), PAGE_SIZE);
|
||||
|
||||
status = decode_compound_hdr(xdr, &hdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_sequence(xdr, &res->seq_res, rqstp);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_putfh(xdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_listxattrs(xdr, res);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
|
||||
static void nfs4_xdr_enc_removexattr(struct rpc_rqst *req,
|
||||
struct xdr_stream *xdr, const void *data)
|
||||
{
|
||||
const struct nfs42_removexattrargs *args = data;
|
||||
struct compound_hdr hdr = {
|
||||
.minorversion = nfs4_xdr_minorversion(&args->seq_args),
|
||||
};
|
||||
|
||||
encode_compound_hdr(xdr, req, &hdr);
|
||||
encode_sequence(xdr, &args->seq_args, &hdr);
|
||||
encode_putfh(xdr, args->fh, &hdr);
|
||||
encode_removexattr(xdr, args->xattr_name, &hdr);
|
||||
encode_nops(&hdr);
|
||||
}
|
||||
|
||||
static int nfs4_xdr_dec_removexattr(struct rpc_rqst *req,
|
||||
struct xdr_stream *xdr, void *data)
|
||||
{
|
||||
struct nfs42_removexattrres *res = data;
|
||||
struct compound_hdr hdr;
|
||||
int status;
|
||||
|
||||
status = decode_compound_hdr(xdr, &hdr);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_sequence(xdr, &res->seq_res, req);
|
||||
if (status)
|
||||
goto out;
|
||||
status = decode_putfh(xdr);
|
||||
if (status)
|
||||
goto out;
|
||||
|
||||
status = decode_removexattr(xdr, &res->cinfo);
|
||||
out:
|
||||
return status;
|
||||
}
|
||||
#endif
|
||||
#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
|
||||
|
|
|
@ -324,6 +324,13 @@ extern int update_open_stateid(struct nfs4_state *state,
|
|||
|
||||
extern int nfs4_proc_get_lease_time(struct nfs_client *clp,
|
||||
struct nfs_fsinfo *fsinfo);
|
||||
extern void nfs4_update_changeattr(struct inode *dir,
|
||||
struct nfs4_change_info *cinfo,
|
||||
unsigned long timestamp,
|
||||
unsigned long cache_validity);
|
||||
extern int nfs4_buf_to_pages_noslab(const void *buf, size_t buflen,
|
||||
struct page **pages);
|
||||
|
||||
#if defined(CONFIG_NFS_V4_1)
|
||||
extern int nfs41_sequence_done(struct rpc_task *, struct nfs4_sequence_res *);
|
||||
extern int nfs4_proc_create_session(struct nfs_client *, const struct cred *);
|
||||
|
@ -557,6 +564,12 @@ static inline void nfs4_unregister_sysctl(void)
|
|||
/* nfs4xdr.c */
|
||||
extern const struct rpc_procinfo nfs4_procedures[];
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
extern const u32 nfs42_maxsetxattr_overhead;
|
||||
extern const u32 nfs42_maxgetxattr_overhead;
|
||||
extern const u32 nfs42_maxlistxattrs_overhead;
|
||||
#endif
|
||||
|
||||
struct nfs4_mount_data;
|
||||
|
||||
/* callback_xdr.c */
|
||||
|
@ -613,12 +626,34 @@ static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state *
|
|||
nfs4_stateid_match_other(&state->open_stateid, stateid);
|
||||
}
|
||||
|
||||
/* nfs42xattr.c */
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
extern int __init nfs4_xattr_cache_init(void);
|
||||
extern void nfs4_xattr_cache_exit(void);
|
||||
extern void nfs4_xattr_cache_add(struct inode *inode, const char *name,
|
||||
const char *buf, struct page **pages,
|
||||
ssize_t buflen);
|
||||
extern void nfs4_xattr_cache_remove(struct inode *inode, const char *name);
|
||||
extern ssize_t nfs4_xattr_cache_get(struct inode *inode, const char *name,
|
||||
char *buf, ssize_t buflen);
|
||||
extern void nfs4_xattr_cache_set_list(struct inode *inode, const char *buf,
|
||||
ssize_t buflen);
|
||||
extern ssize_t nfs4_xattr_cache_list(struct inode *inode, char *buf,
|
||||
ssize_t buflen);
|
||||
extern void nfs4_xattr_cache_zap(struct inode *inode);
|
||||
#else
|
||||
static inline void nfs4_xattr_cache_zap(struct inode *inode)
|
||||
{
|
||||
}
|
||||
#endif /* CONFIG_NFS_V4_2 */
|
||||
|
||||
#else /* CONFIG_NFS_V4 */
|
||||
|
||||
#define nfs4_close_state(a, b) do { } while (0)
|
||||
#define nfs4_close_sync(a, b) do { } while (0)
|
||||
#define nfs4_state_protect(a, b, c, d) do { } while (0)
|
||||
#define nfs4_state_protect_write(a, b, c, d) do { } while (0)
|
||||
|
||||
|
||||
#endif /* CONFIG_NFS_V4 */
|
||||
#endif /* __LINUX_FS_NFS_NFS4_FS.H */
|
||||
|
|
|
@ -880,7 +880,7 @@ static int nfs4_set_client(struct nfs_server *server,
|
|||
|
||||
if (minorversion == 0)
|
||||
__set_bit(NFS_CS_REUSEPORT, &cl_init.init_flags);
|
||||
else if (proto == XPRT_TRANSPORT_TCP)
|
||||
if (proto == XPRT_TRANSPORT_TCP)
|
||||
cl_init.nconnect = nconnect;
|
||||
|
||||
if (server->flags & NFS_MOUNT_NORESVPORT)
|
||||
|
@ -992,6 +992,36 @@ static void nfs4_session_limit_rwsize(struct nfs_server *server)
|
|||
#endif /* CONFIG_NFS_V4_1 */
|
||||
}
|
||||
|
||||
/*
|
||||
* Limit xattr sizes using the channel attributes.
|
||||
*/
|
||||
static void nfs4_session_limit_xasize(struct nfs_server *server)
|
||||
{
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
struct nfs4_session *sess;
|
||||
u32 server_gxa_sz;
|
||||
u32 server_sxa_sz;
|
||||
u32 server_lxa_sz;
|
||||
|
||||
if (!nfs4_has_session(server->nfs_client))
|
||||
return;
|
||||
|
||||
sess = server->nfs_client->cl_session;
|
||||
|
||||
server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead;
|
||||
server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead;
|
||||
server_lxa_sz = sess->fc_attrs.max_resp_sz -
|
||||
nfs42_maxlistxattrs_overhead;
|
||||
|
||||
if (server->gxasize > server_gxa_sz)
|
||||
server->gxasize = server_gxa_sz;
|
||||
if (server->sxasize > server_sxa_sz)
|
||||
server->sxasize = server_sxa_sz;
|
||||
if (server->lxasize > server_lxa_sz)
|
||||
server->lxasize = server_lxa_sz;
|
||||
#endif
|
||||
}
|
||||
|
||||
static int nfs4_server_common_setup(struct nfs_server *server,
|
||||
struct nfs_fh *mntfh, bool auth_probe)
|
||||
{
|
||||
|
@ -1039,6 +1069,7 @@ static int nfs4_server_common_setup(struct nfs_server *server,
|
|||
goto out;
|
||||
|
||||
nfs4_session_limit_rwsize(server);
|
||||
nfs4_session_limit_xasize(server);
|
||||
|
||||
if (server->namelen == 0 || server->namelen > NFS4_MAXNAMLEN)
|
||||
server->namelen = NFS4_MAXNAMLEN;
|
||||
|
|
|
@ -110,6 +110,7 @@ static int
|
|||
nfs4_file_flush(struct file *file, fl_owner_t id)
|
||||
{
|
||||
struct inode *inode = file_inode(file);
|
||||
errseq_t since;
|
||||
|
||||
dprintk("NFS: flush(%pD2)\n", file);
|
||||
|
||||
|
@ -125,7 +126,9 @@ nfs4_file_flush(struct file *file, fl_owner_t id)
|
|||
return filemap_fdatawrite(file->f_mapping);
|
||||
|
||||
/* Flush writes to the server and return any errors */
|
||||
return nfs_wb_all(inode);
|
||||
since = filemap_sample_wb_err(file->f_mapping);
|
||||
nfs_wb_all(inode);
|
||||
return filemap_check_wb_err(file->f_mapping, since);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
|
|
|
@ -66,6 +66,7 @@
|
|||
#include "nfs4idmap.h"
|
||||
#include "nfs4session.h"
|
||||
#include "fscache.h"
|
||||
#include "nfs42.h"
|
||||
|
||||
#include "nfs4trace.h"
|
||||
|
||||
|
@ -256,6 +257,7 @@ const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
|
|||
| FATTR4_WORD1_FS_LAYOUT_TYPES,
|
||||
FATTR4_WORD2_LAYOUT_BLKSIZE
|
||||
| FATTR4_WORD2_CLONE_BLKSIZE
|
||||
| FATTR4_WORD2_XATTR_SUPPORT
|
||||
};
|
||||
|
||||
const u32 nfs4_fs_locations_bitmap[3] = {
|
||||
|
@ -1173,37 +1175,49 @@ nfs4_dec_nlink_locked(struct inode *inode)
|
|||
}
|
||||
|
||||
static void
|
||||
update_changeattr_locked(struct inode *dir, struct nfs4_change_info *cinfo,
|
||||
nfs4_update_changeattr_locked(struct inode *inode,
|
||||
struct nfs4_change_info *cinfo,
|
||||
unsigned long timestamp, unsigned long cache_validity)
|
||||
{
|
||||
struct nfs_inode *nfsi = NFS_I(dir);
|
||||
struct nfs_inode *nfsi = NFS_I(inode);
|
||||
|
||||
nfsi->cache_validity |= NFS_INO_INVALID_CTIME
|
||||
| NFS_INO_INVALID_MTIME
|
||||
| NFS_INO_INVALID_DATA
|
||||
| cache_validity;
|
||||
if (cinfo->atomic && cinfo->before == inode_peek_iversion_raw(dir)) {
|
||||
|
||||
if (cinfo->atomic && cinfo->before == inode_peek_iversion_raw(inode)) {
|
||||
nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
|
||||
nfsi->attrtimeo_timestamp = jiffies;
|
||||
} else {
|
||||
nfs_force_lookup_revalidate(dir);
|
||||
if (cinfo->before != inode_peek_iversion_raw(dir))
|
||||
if (S_ISDIR(inode->i_mode)) {
|
||||
nfsi->cache_validity |= NFS_INO_INVALID_DATA;
|
||||
nfs_force_lookup_revalidate(inode);
|
||||
} else {
|
||||
if (!NFS_PROTO(inode)->have_delegation(inode,
|
||||
FMODE_READ))
|
||||
nfsi->cache_validity |= NFS_INO_REVAL_PAGECACHE;
|
||||
}
|
||||
|
||||
if (cinfo->before != inode_peek_iversion_raw(inode))
|
||||
nfsi->cache_validity |= NFS_INO_INVALID_ACCESS |
|
||||
NFS_INO_INVALID_ACL;
|
||||
NFS_INO_INVALID_ACL |
|
||||
NFS_INO_INVALID_XATTR;
|
||||
}
|
||||
inode_set_iversion_raw(dir, cinfo->after);
|
||||
inode_set_iversion_raw(inode, cinfo->after);
|
||||
nfsi->read_cache_jiffies = timestamp;
|
||||
nfsi->attr_gencount = nfs_inc_attr_generation_counter();
|
||||
nfsi->cache_validity &= ~NFS_INO_INVALID_CHANGE;
|
||||
nfs_fscache_invalidate(dir);
|
||||
|
||||
if (nfsi->cache_validity & NFS_INO_INVALID_DATA)
|
||||
nfs_fscache_invalidate(inode);
|
||||
}
|
||||
|
||||
static void
|
||||
update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo,
|
||||
void
|
||||
nfs4_update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo,
|
||||
unsigned long timestamp, unsigned long cache_validity)
|
||||
{
|
||||
spin_lock(&dir->i_lock);
|
||||
update_changeattr_locked(dir, cinfo, timestamp, cache_validity);
|
||||
nfs4_update_changeattr_locked(dir, cinfo, timestamp, cache_validity);
|
||||
spin_unlock(&dir->i_lock);
|
||||
}
|
||||
|
||||
|
@ -1356,6 +1370,12 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
|
|||
NFS4_ACCESS_MODIFY |
|
||||
NFS4_ACCESS_EXTEND |
|
||||
NFS4_ACCESS_EXECUTE;
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
if (server->caps & NFS_CAP_XATTR)
|
||||
p->o_arg.access |= NFS4_ACCESS_XAREAD |
|
||||
NFS4_ACCESS_XAWRITE |
|
||||
NFS4_ACCESS_XALIST;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
p->o_arg.clientid = server->nfs_client->cl_clientid;
|
||||
|
@ -2653,8 +2673,9 @@ static int _nfs4_proc_open(struct nfs4_opendata *data,
|
|||
data->file_created = true;
|
||||
if (data->file_created ||
|
||||
inode_peek_iversion_raw(dir) != o_res->cinfo.after)
|
||||
update_changeattr(dir, &o_res->cinfo,
|
||||
o_res->f_attr->time_start, 0);
|
||||
nfs4_update_changeattr(dir, &o_res->cinfo,
|
||||
o_res->f_attr->time_start,
|
||||
NFS_INO_INVALID_DATA);
|
||||
}
|
||||
if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
|
||||
server->caps &= ~NFS_CAP_POSIX_LOCK;
|
||||
|
@ -3756,7 +3777,7 @@ static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
|
|||
|
||||
#define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
|
||||
#define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
|
||||
#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL)
|
||||
#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_XATTR_SUPPORT - 1UL)
|
||||
|
||||
static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
|
||||
{
|
||||
|
@ -4540,7 +4561,8 @@ _nfs4_proc_remove(struct inode *dir, const struct qstr *name, u32 ftype)
|
|||
status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
|
||||
if (status == 0) {
|
||||
spin_lock(&dir->i_lock);
|
||||
update_changeattr_locked(dir, &res.cinfo, timestamp, 0);
|
||||
nfs4_update_changeattr_locked(dir, &res.cinfo, timestamp,
|
||||
NFS_INO_INVALID_DATA);
|
||||
/* Removing a directory decrements nlink in the parent */
|
||||
if (ftype == NF4DIR && dir->i_nlink > 2)
|
||||
nfs4_dec_nlink_locked(dir);
|
||||
|
@ -4624,8 +4646,9 @@ static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
|
|||
&data->timeout) == -EAGAIN)
|
||||
return 0;
|
||||
if (task->tk_status == 0)
|
||||
update_changeattr(dir, &res->cinfo,
|
||||
res->dir_attr->time_start, 0);
|
||||
nfs4_update_changeattr(dir, &res->cinfo,
|
||||
res->dir_attr->time_start,
|
||||
NFS_INO_INVALID_DATA);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -4669,16 +4692,18 @@ static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
|
|||
if (task->tk_status == 0) {
|
||||
if (new_dir != old_dir) {
|
||||
/* Note: If we moved a directory, nlink will change */
|
||||
update_changeattr(old_dir, &res->old_cinfo,
|
||||
nfs4_update_changeattr(old_dir, &res->old_cinfo,
|
||||
res->old_fattr->time_start,
|
||||
NFS_INO_INVALID_OTHER);
|
||||
update_changeattr(new_dir, &res->new_cinfo,
|
||||
NFS_INO_INVALID_OTHER |
|
||||
NFS_INO_INVALID_DATA);
|
||||
nfs4_update_changeattr(new_dir, &res->new_cinfo,
|
||||
res->new_fattr->time_start,
|
||||
NFS_INO_INVALID_OTHER);
|
||||
NFS_INO_INVALID_OTHER |
|
||||
NFS_INO_INVALID_DATA);
|
||||
} else
|
||||
update_changeattr(old_dir, &res->old_cinfo,
|
||||
nfs4_update_changeattr(old_dir, &res->old_cinfo,
|
||||
res->old_fattr->time_start,
|
||||
0);
|
||||
NFS_INO_INVALID_DATA);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
@ -4719,7 +4744,8 @@ static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct
|
|||
|
||||
status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
|
||||
if (!status) {
|
||||
update_changeattr(dir, &res.cinfo, res.fattr->time_start, 0);
|
||||
nfs4_update_changeattr(dir, &res.cinfo, res.fattr->time_start,
|
||||
NFS_INO_INVALID_DATA);
|
||||
status = nfs_post_op_update_inode(inode, res.fattr);
|
||||
if (!status)
|
||||
nfs_setsecurity(inode, res.fattr, res.label);
|
||||
|
@ -4797,8 +4823,9 @@ static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_
|
|||
&data->arg.seq_args, &data->res.seq_res, 1);
|
||||
if (status == 0) {
|
||||
spin_lock(&dir->i_lock);
|
||||
update_changeattr_locked(dir, &data->res.dir_cinfo,
|
||||
data->res.fattr->time_start, 0);
|
||||
nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo,
|
||||
data->res.fattr->time_start,
|
||||
NFS_INO_INVALID_DATA);
|
||||
/* Creating a directory bumps nlink in the parent */
|
||||
if (data->arg.ftype == NF4DIR)
|
||||
nfs4_inc_nlink_locked(dir);
|
||||
|
@ -5531,7 +5558,7 @@ static inline int nfs4_server_supports_acls(struct nfs_server *server)
|
|||
*/
|
||||
#define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
|
||||
|
||||
static int buf_to_pages_noslab(const void *buf, size_t buflen,
|
||||
int nfs4_buf_to_pages_noslab(const void *buf, size_t buflen,
|
||||
struct page **pages)
|
||||
{
|
||||
struct page *newpage, **spages;
|
||||
|
@ -5773,7 +5800,7 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t bufl
|
|||
return -EOPNOTSUPP;
|
||||
if (npages > ARRAY_SIZE(pages))
|
||||
return -ERANGE;
|
||||
i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
|
||||
i = nfs4_buf_to_pages_noslab(buf, buflen, arg.acl_pages);
|
||||
if (i < 0)
|
||||
return i;
|
||||
nfs4_inode_make_writeable(inode);
|
||||
|
@ -5845,8 +5872,6 @@ static int _nfs4_get_security_label(struct inode *inode, void *buf,
|
|||
return ret;
|
||||
if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
|
||||
return -ENOENT;
|
||||
if (buflen < label.len)
|
||||
return -ERANGE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -7430,6 +7455,133 @@ nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
|
|||
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
static int nfs4_xattr_set_nfs4_user(const struct xattr_handler *handler,
|
||||
struct dentry *unused, struct inode *inode,
|
||||
const char *key, const void *buf,
|
||||
size_t buflen, int flags)
|
||||
{
|
||||
struct nfs_access_entry cache;
|
||||
int ret;
|
||||
|
||||
if (!nfs_server_capable(inode, NFS_CAP_XATTR))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
/*
|
||||
* There is no mapping from the MAY_* flags to the NFS_ACCESS_XA*
|
||||
* flags right now. Handling of xattr operations use the normal
|
||||
* file read/write permissions.
|
||||
*
|
||||
* Just in case the server has other ideas (which RFC 8276 allows),
|
||||
* do a cached access check for the XA* flags to possibly avoid
|
||||
* doing an RPC and getting EACCES back.
|
||||
*/
|
||||
if (!nfs_access_get_cached(inode, current_cred(), &cache, true)) {
|
||||
if (!(cache.mask & NFS_ACCESS_XAWRITE))
|
||||
return -EACCES;
|
||||
}
|
||||
|
||||
if (buf == NULL) {
|
||||
ret = nfs42_proc_removexattr(inode, key);
|
||||
if (!ret)
|
||||
nfs4_xattr_cache_remove(inode, key);
|
||||
} else {
|
||||
ret = nfs42_proc_setxattr(inode, key, buf, buflen, flags);
|
||||
if (!ret)
|
||||
nfs4_xattr_cache_add(inode, key, buf, NULL, buflen);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int nfs4_xattr_get_nfs4_user(const struct xattr_handler *handler,
|
||||
struct dentry *unused, struct inode *inode,
|
||||
const char *key, void *buf, size_t buflen)
|
||||
{
|
||||
struct nfs_access_entry cache;
|
||||
ssize_t ret;
|
||||
|
||||
if (!nfs_server_capable(inode, NFS_CAP_XATTR))
|
||||
return -EOPNOTSUPP;
|
||||
|
||||
if (!nfs_access_get_cached(inode, current_cred(), &cache, true)) {
|
||||
if (!(cache.mask & NFS_ACCESS_XAREAD))
|
||||
return -EACCES;
|
||||
}
|
||||
|
||||
ret = nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = nfs4_xattr_cache_get(inode, key, buf, buflen);
|
||||
if (ret >= 0 || (ret < 0 && ret != -ENOENT))
|
||||
return ret;
|
||||
|
||||
ret = nfs42_proc_getxattr(inode, key, buf, buflen);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t
|
||||
nfs4_listxattr_nfs4_user(struct inode *inode, char *list, size_t list_len)
|
||||
{
|
||||
u64 cookie;
|
||||
bool eof;
|
||||
ssize_t ret, size;
|
||||
char *buf;
|
||||
size_t buflen;
|
||||
struct nfs_access_entry cache;
|
||||
|
||||
if (!nfs_server_capable(inode, NFS_CAP_XATTR))
|
||||
return 0;
|
||||
|
||||
if (!nfs_access_get_cached(inode, current_cred(), &cache, true)) {
|
||||
if (!(cache.mask & NFS_ACCESS_XALIST))
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = nfs_revalidate_inode(NFS_SERVER(inode), inode);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = nfs4_xattr_cache_list(inode, list, list_len);
|
||||
if (ret >= 0 || (ret < 0 && ret != -ENOENT))
|
||||
return ret;
|
||||
|
||||
cookie = 0;
|
||||
eof = false;
|
||||
buflen = list_len ? list_len : XATTR_LIST_MAX;
|
||||
buf = list_len ? list : NULL;
|
||||
size = 0;
|
||||
|
||||
while (!eof) {
|
||||
ret = nfs42_proc_listxattrs(inode, buf, buflen,
|
||||
&cookie, &eof);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
if (list_len) {
|
||||
buf += ret;
|
||||
buflen -= ret;
|
||||
}
|
||||
size += ret;
|
||||
}
|
||||
|
||||
if (list_len)
|
||||
nfs4_xattr_cache_set_list(inode, list, size);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static ssize_t
|
||||
nfs4_listxattr_nfs4_user(struct inode *inode, char *list, size_t list_len)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_NFS_V4_2 */
|
||||
|
||||
/*
|
||||
* nfs_fhget will use either the mounted_on_fileid or the fileid
|
||||
*/
|
||||
|
@ -10035,7 +10187,7 @@ const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
|
|||
|
||||
static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
|
||||
{
|
||||
ssize_t error, error2;
|
||||
ssize_t error, error2, error3;
|
||||
|
||||
error = generic_listxattr(dentry, list, size);
|
||||
if (error < 0)
|
||||
|
@ -10048,7 +10200,17 @@ static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
|
|||
error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
|
||||
if (error2 < 0)
|
||||
return error2;
|
||||
return error + error2;
|
||||
|
||||
if (list) {
|
||||
list += error2;
|
||||
size -= error2;
|
||||
}
|
||||
|
||||
error3 = nfs4_listxattr_nfs4_user(d_inode(dentry), list, size);
|
||||
if (error3 < 0)
|
||||
return error3;
|
||||
|
||||
return error + error2 + error3;
|
||||
}
|
||||
|
||||
static const struct inode_operations nfs4_dir_inode_operations = {
|
||||
|
@ -10136,10 +10298,21 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
|
|||
.set = nfs4_xattr_set_nfs4_acl,
|
||||
};
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
static const struct xattr_handler nfs4_xattr_nfs4_user_handler = {
|
||||
.prefix = XATTR_USER_PREFIX,
|
||||
.get = nfs4_xattr_get_nfs4_user,
|
||||
.set = nfs4_xattr_set_nfs4_user,
|
||||
};
|
||||
#endif
|
||||
|
||||
const struct xattr_handler *nfs4_xattr_handlers[] = {
|
||||
&nfs4_xattr_nfs4_acl_handler,
|
||||
#ifdef CONFIG_NFS_V4_SECURITY_LABEL
|
||||
&nfs4_xattr_nfs4_label_handler,
|
||||
#endif
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
&nfs4_xattr_nfs4_user_handler,
|
||||
#endif
|
||||
NULL
|
||||
};
|
||||
|
|
|
@ -69,6 +69,7 @@ static void nfs4_evict_inode(struct inode *inode)
|
|||
pnfs_destroy_layout(NFS_I(inode));
|
||||
/* First call standard NFS clear_inode() code */
|
||||
nfs_clear_inode(inode);
|
||||
nfs4_xattr_cache_zap(inode);
|
||||
}
|
||||
|
||||
struct nfs_referral_count {
|
||||
|
@ -268,6 +269,12 @@ static int __init init_nfs_v4(void)
|
|||
if (err)
|
||||
goto out1;
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
err = nfs4_xattr_cache_init();
|
||||
if (err)
|
||||
goto out2;
|
||||
#endif
|
||||
|
||||
err = nfs4_register_sysctl();
|
||||
if (err)
|
||||
goto out2;
|
||||
|
@ -288,6 +295,9 @@ static void __exit exit_nfs_v4(void)
|
|||
nfs4_pnfs_v3_ds_connect_unload();
|
||||
|
||||
unregister_nfs_version(&nfs_v4);
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
nfs4_xattr_cache_exit();
|
||||
#endif
|
||||
nfs4_unregister_sysctl();
|
||||
nfs_idmap_quit();
|
||||
nfs_dns_resolver_destroy();
|
||||
|
|
|
@ -1727,6 +1727,13 @@ DEFINE_NFS4_IDMAP_EVENT(nfs4_map_group_to_gid);
|
|||
DEFINE_NFS4_IDMAP_EVENT(nfs4_map_uid_to_name);
|
||||
DEFINE_NFS4_IDMAP_EVENT(nfs4_map_gid_to_group);
|
||||
|
||||
#ifdef CONFIG_NFS_V4_1
|
||||
#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) \
|
||||
(lseg ? nfs_stateid_hash(&lseg->pls_layout->plh_stateid) : 0)
|
||||
#else
|
||||
#define NFS4_LSEG_LAYOUT_STATEID_HASH(lseg) (0)
|
||||
#endif
|
||||
|
||||
DECLARE_EVENT_CLASS(nfs4_read_event,
|
||||
TP_PROTO(
|
||||
const struct nfs_pgio_header *hdr,
|
||||
|
@ -1745,6 +1752,8 @@ DECLARE_EVENT_CLASS(nfs4_read_event,
|
|||
__field(unsigned long, error)
|
||||
__field(int, stateid_seq)
|
||||
__field(u32, stateid_hash)
|
||||
__field(int, layoutstateid_seq)
|
||||
__field(u32, layoutstateid_hash)
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
|
@ -1754,6 +1763,7 @@ DECLARE_EVENT_CLASS(nfs4_read_event,
|
|||
hdr->args.fh : &nfsi->fh;
|
||||
const struct nfs4_state *state =
|
||||
hdr->args.context->state;
|
||||
const struct pnfs_layout_segment *lseg = hdr->lseg;
|
||||
|
||||
__entry->dev = inode->i_sb->s_dev;
|
||||
__entry->fileid = nfsi->fileid;
|
||||
|
@ -1766,11 +1776,15 @@ DECLARE_EVENT_CLASS(nfs4_read_event,
|
|||
be32_to_cpu(state->stateid.seqid);
|
||||
__entry->stateid_hash =
|
||||
nfs_stateid_hash(&state->stateid);
|
||||
__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
|
||||
__entry->layoutstateid_hash =
|
||||
NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
|
||||
),
|
||||
|
||||
TP_printk(
|
||||
"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
|
||||
"offset=%lld count=%u res=%u stateid=%d:0x%08x",
|
||||
"offset=%lld count=%u res=%u stateid=%d:0x%08x "
|
||||
"layoutstateid=%d:0x%08x",
|
||||
-__entry->error,
|
||||
show_nfsv4_errors(__entry->error),
|
||||
MAJOR(__entry->dev), MINOR(__entry->dev),
|
||||
|
@ -1778,7 +1792,8 @@ DECLARE_EVENT_CLASS(nfs4_read_event,
|
|||
__entry->fhandle,
|
||||
(long long)__entry->offset,
|
||||
__entry->arg_count, __entry->res_count,
|
||||
__entry->stateid_seq, __entry->stateid_hash
|
||||
__entry->stateid_seq, __entry->stateid_hash,
|
||||
__entry->layoutstateid_seq, __entry->layoutstateid_hash
|
||||
)
|
||||
);
|
||||
#define DEFINE_NFS4_READ_EVENT(name) \
|
||||
|
@ -1811,6 +1826,8 @@ DECLARE_EVENT_CLASS(nfs4_write_event,
|
|||
__field(unsigned long, error)
|
||||
__field(int, stateid_seq)
|
||||
__field(u32, stateid_hash)
|
||||
__field(int, layoutstateid_seq)
|
||||
__field(u32, layoutstateid_hash)
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
|
@ -1820,6 +1837,7 @@ DECLARE_EVENT_CLASS(nfs4_write_event,
|
|||
hdr->args.fh : &nfsi->fh;
|
||||
const struct nfs4_state *state =
|
||||
hdr->args.context->state;
|
||||
const struct pnfs_layout_segment *lseg = hdr->lseg;
|
||||
|
||||
__entry->dev = inode->i_sb->s_dev;
|
||||
__entry->fileid = nfsi->fileid;
|
||||
|
@ -1832,11 +1850,15 @@ DECLARE_EVENT_CLASS(nfs4_write_event,
|
|||
be32_to_cpu(state->stateid.seqid);
|
||||
__entry->stateid_hash =
|
||||
nfs_stateid_hash(&state->stateid);
|
||||
__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
|
||||
__entry->layoutstateid_hash =
|
||||
NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
|
||||
),
|
||||
|
||||
TP_printk(
|
||||
"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
|
||||
"offset=%lld count=%u res=%u stateid=%d:0x%08x",
|
||||
"offset=%lld count=%u res=%u stateid=%d:0x%08x "
|
||||
"layoutstateid=%d:0x%08x",
|
||||
-__entry->error,
|
||||
show_nfsv4_errors(__entry->error),
|
||||
MAJOR(__entry->dev), MINOR(__entry->dev),
|
||||
|
@ -1844,7 +1866,8 @@ DECLARE_EVENT_CLASS(nfs4_write_event,
|
|||
__entry->fhandle,
|
||||
(long long)__entry->offset,
|
||||
__entry->arg_count, __entry->res_count,
|
||||
__entry->stateid_seq, __entry->stateid_hash
|
||||
__entry->stateid_seq, __entry->stateid_hash,
|
||||
__entry->layoutstateid_seq, __entry->layoutstateid_hash
|
||||
)
|
||||
);
|
||||
|
||||
|
@ -1875,6 +1898,8 @@ DECLARE_EVENT_CLASS(nfs4_commit_event,
|
|||
__field(unsigned long, error)
|
||||
__field(loff_t, offset)
|
||||
__field(u32, count)
|
||||
__field(int, layoutstateid_seq)
|
||||
__field(u32, layoutstateid_hash)
|
||||
),
|
||||
|
||||
TP_fast_assign(
|
||||
|
@ -1882,6 +1907,7 @@ DECLARE_EVENT_CLASS(nfs4_commit_event,
|
|||
const struct nfs_inode *nfsi = NFS_I(inode);
|
||||
const struct nfs_fh *fh = data->args.fh ?
|
||||
data->args.fh : &nfsi->fh;
|
||||
const struct pnfs_layout_segment *lseg = data->lseg;
|
||||
|
||||
__entry->dev = inode->i_sb->s_dev;
|
||||
__entry->fileid = nfsi->fileid;
|
||||
|
@ -1889,18 +1915,22 @@ DECLARE_EVENT_CLASS(nfs4_commit_event,
|
|||
__entry->offset = data->args.offset;
|
||||
__entry->count = data->args.count;
|
||||
__entry->error = error < 0 ? -error : 0;
|
||||
__entry->layoutstateid_seq = lseg ? lseg->pls_seq : 0;
|
||||
__entry->layoutstateid_hash =
|
||||
NFS4_LSEG_LAYOUT_STATEID_HASH(lseg);
|
||||
),
|
||||
|
||||
TP_printk(
|
||||
"error=%ld (%s) fileid=%02x:%02x:%llu fhandle=0x%08x "
|
||||
"offset=%lld count=%u",
|
||||
"offset=%lld count=%u layoutstateid=%d:0x%08x",
|
||||
-__entry->error,
|
||||
show_nfsv4_errors(__entry->error),
|
||||
MAJOR(__entry->dev), MINOR(__entry->dev),
|
||||
(unsigned long long)__entry->fileid,
|
||||
__entry->fhandle,
|
||||
(long long)__entry->offset,
|
||||
__entry->count
|
||||
__entry->count,
|
||||
__entry->layoutstateid_seq, __entry->layoutstateid_hash
|
||||
)
|
||||
);
|
||||
#define DEFINE_NFS4_COMMIT_EVENT(name) \
|
||||
|
@ -1993,7 +2023,9 @@ TRACE_EVENT(nfs4_layoutget,
|
|||
|
||||
DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutcommit);
|
||||
DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn);
|
||||
DEFINE_NFS4_INODE_EVENT(nfs4_layoutreturn_on_close);
|
||||
DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutreturn_on_close);
|
||||
DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layouterror);
|
||||
DEFINE_NFS4_INODE_STATEID_EVENT(nfs4_layoutstats);
|
||||
|
||||
TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_UNKNOWN);
|
||||
TRACE_DEFINE_ENUM(PNFS_UPDATE_LAYOUT_NO_PNFS);
|
||||
|
|
|
@ -4166,7 +4166,11 @@ static int decode_attr_security_label(struct xdr_stream *xdr, uint32_t *bitmap,
|
|||
return -EIO;
|
||||
if (len < NFS4_MAXLABELLEN) {
|
||||
if (label) {
|
||||
memcpy(label->label, p, len);
|
||||
if (label->len) {
|
||||
if (label->len < len)
|
||||
return -ERANGE;
|
||||
memcpy(label->label, p, len);
|
||||
}
|
||||
label->len = len;
|
||||
label->pi = pi;
|
||||
label->lfs = lfs;
|
||||
|
@ -4201,6 +4205,26 @@ static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, str
|
|||
return status;
|
||||
}
|
||||
|
||||
static int decode_attr_xattrsupport(struct xdr_stream *xdr, uint32_t *bitmap,
|
||||
uint32_t *res)
|
||||
{
|
||||
__be32 *p;
|
||||
|
||||
*res = 0;
|
||||
if (unlikely(bitmap[2] & (FATTR4_WORD2_XATTR_SUPPORT - 1U)))
|
||||
return -EIO;
|
||||
if (likely(bitmap[2] & FATTR4_WORD2_XATTR_SUPPORT)) {
|
||||
p = xdr_inline_decode(xdr, 4);
|
||||
if (unlikely(!p))
|
||||
return -EIO;
|
||||
*res = be32_to_cpup(p);
|
||||
bitmap[2] &= ~FATTR4_WORD2_XATTR_SUPPORT;
|
||||
}
|
||||
dprintk("%s: XATTR support=%s\n", __func__,
|
||||
*res == 0 ? "false" : "true");
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int verify_attr_len(struct xdr_stream *xdr, unsigned int savep, uint32_t attrlen)
|
||||
{
|
||||
unsigned int attrwords = XDR_QUADLEN(attrlen);
|
||||
|
@ -4855,6 +4879,11 @@ static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
|
|||
if (status)
|
||||
goto xdr_error;
|
||||
|
||||
status = decode_attr_xattrsupport(xdr, bitmap,
|
||||
&fsinfo->xattr_support);
|
||||
if (status)
|
||||
goto xdr_error;
|
||||
|
||||
status = verify_attr_len(xdr, savep, attrlen);
|
||||
xdr_error:
|
||||
dprintk("%s: xdr returned %d!\n", __func__, -status);
|
||||
|
@ -5227,7 +5256,7 @@ static int decode_readlink(struct xdr_stream *xdr, struct rpc_rqst *req)
|
|||
* The XDR encode routine has set things up so that
|
||||
* the link text will be copied directly into the
|
||||
* buffer. We just have to do overflow-checking,
|
||||
* and and null-terminate the text (the VFS expects
|
||||
* and null-terminate the text (the VFS expects
|
||||
* null-termination).
|
||||
*/
|
||||
xdr_terminate_string(rcvbuf, len);
|
||||
|
@ -7456,6 +7485,8 @@ static struct {
|
|||
{ NFS4ERR_SYMLINK, -ELOOP },
|
||||
{ NFS4ERR_OP_ILLEGAL, -EOPNOTSUPP },
|
||||
{ NFS4ERR_DEADLOCK, -EDEADLK },
|
||||
{ NFS4ERR_NOXATTR, -ENODATA },
|
||||
{ NFS4ERR_XATTR2BIG, -E2BIG },
|
||||
{ -1, -EIO }
|
||||
};
|
||||
|
||||
|
@ -7584,6 +7615,10 @@ const struct rpc_procinfo nfs4_procedures[] = {
|
|||
PROC42(COPY_NOTIFY, enc_copy_notify, dec_copy_notify),
|
||||
PROC(LOOKUPP, enc_lookupp, dec_lookupp),
|
||||
PROC42(LAYOUTERROR, enc_layouterror, dec_layouterror),
|
||||
PROC42(GETXATTR, enc_getxattr, dec_getxattr),
|
||||
PROC42(SETXATTR, enc_setxattr, dec_setxattr),
|
||||
PROC42(LISTXATTRS, enc_listxattrs, dec_listxattrs),
|
||||
PROC42(REMOVEXATTR, enc_removexattr, dec_removexattr),
|
||||
};
|
||||
|
||||
static unsigned int nfs_version4_counts[ARRAY_SIZE(nfs4_procedures)];
|
||||
|
|
|
@ -59,7 +59,8 @@ TRACE_DEFINE_ENUM(NFS_INO_INVALID_OTHER);
|
|||
{ NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \
|
||||
{ NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \
|
||||
{ NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \
|
||||
{ NFS_INO_INVALID_OTHER, "INVALID_OTHER" })
|
||||
{ NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \
|
||||
{ NFS_INO_INVALID_XATTR, "INVALID_XATTR" })
|
||||
|
||||
TRACE_DEFINE_ENUM(NFS_INO_ADVISE_RDPLUS);
|
||||
TRACE_DEFINE_ENUM(NFS_INO_STALE);
|
||||
|
|
|
@ -1226,31 +1226,27 @@ out:
|
|||
return status;
|
||||
}
|
||||
|
||||
static bool
|
||||
pnfs_layout_segments_returnable(struct pnfs_layout_hdr *lo,
|
||||
enum pnfs_iomode iomode,
|
||||
u32 seq)
|
||||
{
|
||||
struct pnfs_layout_range recall_range = {
|
||||
.length = NFS4_MAX_UINT64,
|
||||
.iomode = iomode,
|
||||
};
|
||||
return pnfs_mark_matching_lsegs_return(lo, &lo->plh_return_segs,
|
||||
&recall_range, seq) != -EBUSY;
|
||||
}
|
||||
|
||||
/* Return true if layoutreturn is needed */
|
||||
static bool
|
||||
pnfs_layout_need_return(struct pnfs_layout_hdr *lo)
|
||||
{
|
||||
struct pnfs_layout_segment *s;
|
||||
enum pnfs_iomode iomode;
|
||||
u32 seq;
|
||||
|
||||
if (!test_bit(NFS_LAYOUT_RETURN_REQUESTED, &lo->plh_flags))
|
||||
return false;
|
||||
|
||||
seq = lo->plh_return_seq;
|
||||
iomode = lo->plh_return_iomode;
|
||||
|
||||
/* Defer layoutreturn until all recalled lsegs are done */
|
||||
list_for_each_entry(s, &lo->plh_segs, pls_list) {
|
||||
if (seq && pnfs_seqid_is_newer(s->pls_seq, seq))
|
||||
continue;
|
||||
if (iomode != IOMODE_ANY && s->pls_range.iomode != iomode)
|
||||
continue;
|
||||
if (test_bit(NFS_LSEG_LAYOUTRETURN, &s->pls_flags))
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
return pnfs_layout_segments_returnable(lo, lo->plh_return_iomode,
|
||||
lo->plh_return_seq);
|
||||
}
|
||||
|
||||
static void pnfs_layoutreturn_before_put_layout_hdr(struct pnfs_layout_hdr *lo)
|
||||
|
@ -1549,12 +1545,12 @@ void pnfs_roc_release(struct nfs4_layoutreturn_args *args,
|
|||
default:
|
||||
arg_stateid = &args->stateid;
|
||||
}
|
||||
trace_nfs4_layoutreturn_on_close(args->inode, &args->stateid, ret);
|
||||
pnfs_layoutreturn_free_lsegs(lo, arg_stateid, &args->range,
|
||||
res_stateid);
|
||||
if (ld_private && ld_private->ops && ld_private->ops->free)
|
||||
ld_private->ops->free(ld_private);
|
||||
pnfs_put_layout_hdr(lo);
|
||||
trace_nfs4_layoutreturn_on_close(args->inode, 0);
|
||||
}
|
||||
|
||||
bool pnfs_wait_on_layoutreturn(struct inode *ino, struct rpc_task *task)
|
||||
|
@ -2392,16 +2388,6 @@ out_forget:
|
|||
return ERR_PTR(-EAGAIN);
|
||||
}
|
||||
|
||||
static int
|
||||
mark_lseg_invalid_or_return(struct pnfs_layout_segment *lseg,
|
||||
struct list_head *tmp_list)
|
||||
{
|
||||
if (!mark_lseg_invalid(lseg, tmp_list))
|
||||
return 0;
|
||||
pnfs_cache_lseg_for_layoutreturn(lseg->pls_layout, lseg);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* pnfs_mark_matching_lsegs_return - Free or return matching layout segments
|
||||
* @lo: pointer to layout header
|
||||
|
@ -2438,7 +2424,7 @@ pnfs_mark_matching_lsegs_return(struct pnfs_layout_hdr *lo,
|
|||
lseg, lseg->pls_range.iomode,
|
||||
lseg->pls_range.offset,
|
||||
lseg->pls_range.length);
|
||||
if (mark_lseg_invalid_or_return(lseg, tmp_list))
|
||||
if (mark_lseg_invalid(lseg, tmp_list))
|
||||
continue;
|
||||
remaining++;
|
||||
set_bit(NFS_LSEG_LAYOUTRETURN, &lseg->pls_flags);
|
||||
|
@ -2953,7 +2939,8 @@ pnfs_try_to_read_data(struct nfs_pgio_header *hdr,
|
|||
}
|
||||
|
||||
/* Resend all requests through pnfs. */
|
||||
void pnfs_read_resend_pnfs(struct nfs_pgio_header *hdr)
|
||||
void pnfs_read_resend_pnfs(struct nfs_pgio_header *hdr,
|
||||
unsigned int mirror_idx)
|
||||
{
|
||||
struct nfs_pageio_descriptor pgio;
|
||||
|
||||
|
@ -2964,6 +2951,7 @@ void pnfs_read_resend_pnfs(struct nfs_pgio_header *hdr)
|
|||
|
||||
nfs_pageio_init_read(&pgio, hdr->inode, false,
|
||||
hdr->completion_ops);
|
||||
pgio.pg_mirror_idx = mirror_idx;
|
||||
hdr->task.tk_status = nfs_pageio_resend(&pgio, hdr);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -311,7 +311,7 @@ int _pnfs_return_layout(struct inode *);
|
|||
int pnfs_commit_and_return_layout(struct inode *);
|
||||
void pnfs_ld_write_done(struct nfs_pgio_header *);
|
||||
void pnfs_ld_read_done(struct nfs_pgio_header *);
|
||||
void pnfs_read_resend_pnfs(struct nfs_pgio_header *);
|
||||
void pnfs_read_resend_pnfs(struct nfs_pgio_header *, unsigned int mirror_idx);
|
||||
struct pnfs_layout_segment *pnfs_update_layout(struct inode *ino,
|
||||
struct nfs_open_context *ctx,
|
||||
loff_t pos,
|
||||
|
|
|
@ -553,6 +553,11 @@ enum {
|
|||
NFSPROC4_CLNT_LAYOUTERROR,
|
||||
|
||||
NFSPROC4_CLNT_COPY_NOTIFY,
|
||||
|
||||
NFSPROC4_CLNT_GETXATTR,
|
||||
NFSPROC4_CLNT_SETXATTR,
|
||||
NFSPROC4_CLNT_LISTXATTRS,
|
||||
NFSPROC4_CLNT_REMOVEXATTR,
|
||||
};
|
||||
|
||||
/* nfs41 types */
|
||||
|
|
|
@ -102,6 +102,8 @@ struct nfs_delegation;
|
|||
|
||||
struct posix_acl;
|
||||
|
||||
struct nfs4_xattr_cache;
|
||||
|
||||
/*
|
||||
* nfs fs inode data in memory
|
||||
*/
|
||||
|
@ -188,6 +190,10 @@ struct nfs_inode {
|
|||
struct fscache_cookie *fscache;
|
||||
#endif
|
||||
struct inode vfs_inode;
|
||||
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
struct nfs4_xattr_cache *xattr_cache;
|
||||
#endif
|
||||
};
|
||||
|
||||
struct nfs4_copy_state {
|
||||
|
@ -212,6 +218,9 @@ struct nfs4_copy_state {
|
|||
#define NFS_ACCESS_EXTEND 0x0008
|
||||
#define NFS_ACCESS_DELETE 0x0010
|
||||
#define NFS_ACCESS_EXECUTE 0x0020
|
||||
#define NFS_ACCESS_XAREAD 0x0040
|
||||
#define NFS_ACCESS_XAWRITE 0x0080
|
||||
#define NFS_ACCESS_XALIST 0x0100
|
||||
|
||||
/*
|
||||
* Cache validity bit flags
|
||||
|
@ -231,6 +240,7 @@ struct nfs4_copy_state {
|
|||
#define NFS_INO_DATA_INVAL_DEFER \
|
||||
BIT(13) /* Deferred cache invalidation */
|
||||
#define NFS_INO_INVALID_BLOCKS BIT(14) /* cached blocks are invalid */
|
||||
#define NFS_INO_INVALID_XATTR BIT(15) /* xattrs are invalid */
|
||||
|
||||
#define NFS_INO_INVALID_ATTR (NFS_INO_INVALID_CHANGE \
|
||||
| NFS_INO_INVALID_CTIME \
|
||||
|
@ -490,6 +500,8 @@ extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh,
|
|||
struct nfs_fattr *fattr, struct nfs4_label *label);
|
||||
extern int nfs_may_open(struct inode *inode, const struct cred *cred, int openflags);
|
||||
extern void nfs_access_zap_cache(struct inode *inode);
|
||||
extern int nfs_access_get_cached(struct inode *inode, const struct cred *cred, struct nfs_access_entry *res,
|
||||
bool may_block);
|
||||
|
||||
/*
|
||||
* linux/fs/nfs/symlink.c
|
||||
|
|
|
@ -163,6 +163,11 @@ struct nfs_server {
|
|||
unsigned int dtsize; /* readdir size */
|
||||
unsigned short port; /* "port=" setting */
|
||||
unsigned int bsize; /* server block size */
|
||||
#ifdef CONFIG_NFS_V4_2
|
||||
unsigned int gxasize; /* getxattr size */
|
||||
unsigned int sxasize; /* setxattr size */
|
||||
unsigned int lxasize; /* listxattr size */
|
||||
#endif
|
||||
unsigned int acregmin; /* attr cache timeouts */
|
||||
unsigned int acregmax;
|
||||
unsigned int acdirmin;
|
||||
|
@ -281,5 +286,6 @@ struct nfs_server {
|
|||
#define NFS_CAP_OFFLOAD_CANCEL (1U << 25)
|
||||
#define NFS_CAP_LAYOUTERROR (1U << 26)
|
||||
#define NFS_CAP_COPY_NOTIFY (1U << 27)
|
||||
#define NFS_CAP_XATTR (1U << 28)
|
||||
|
||||
#endif
|
||||
|
|
|
@ -150,6 +150,7 @@ struct nfs_fsinfo {
|
|||
__u32 layouttype[NFS_MAX_LAYOUT_TYPES]; /* supported pnfs layout driver */
|
||||
__u32 blksize; /* preferred pnfs io block size */
|
||||
__u32 clone_blksize; /* granularity of a CLONE operation */
|
||||
__u32 xattr_support; /* User xattrs supported */
|
||||
};
|
||||
|
||||
struct nfs_fsstat {
|
||||
|
@ -1497,7 +1498,64 @@ struct nfs42_seek_res {
|
|||
u32 sr_eof;
|
||||
u64 sr_offset;
|
||||
};
|
||||
#endif
|
||||
|
||||
struct nfs42_setxattrargs {
|
||||
struct nfs4_sequence_args seq_args;
|
||||
struct nfs_fh *fh;
|
||||
const char *xattr_name;
|
||||
u32 xattr_flags;
|
||||
size_t xattr_len;
|
||||
struct page **xattr_pages;
|
||||
};
|
||||
|
||||
struct nfs42_setxattrres {
|
||||
struct nfs4_sequence_res seq_res;
|
||||
struct nfs4_change_info cinfo;
|
||||
};
|
||||
|
||||
struct nfs42_getxattrargs {
|
||||
struct nfs4_sequence_args seq_args;
|
||||
struct nfs_fh *fh;
|
||||
const char *xattr_name;
|
||||
size_t xattr_len;
|
||||
struct page **xattr_pages;
|
||||
};
|
||||
|
||||
struct nfs42_getxattrres {
|
||||
struct nfs4_sequence_res seq_res;
|
||||
size_t xattr_len;
|
||||
};
|
||||
|
||||
struct nfs42_listxattrsargs {
|
||||
struct nfs4_sequence_args seq_args;
|
||||
struct nfs_fh *fh;
|
||||
u32 count;
|
||||
u64 cookie;
|
||||
struct page **xattr_pages;
|
||||
};
|
||||
|
||||
struct nfs42_listxattrsres {
|
||||
struct nfs4_sequence_res seq_res;
|
||||
struct page *scratch;
|
||||
void *xattr_buf;
|
||||
size_t xattr_len;
|
||||
u64 cookie;
|
||||
bool eof;
|
||||
size_t copied;
|
||||
};
|
||||
|
||||
struct nfs42_removexattrargs {
|
||||
struct nfs4_sequence_args seq_args;
|
||||
struct nfs_fh *fh;
|
||||
const char *xattr_name;
|
||||
};
|
||||
|
||||
struct nfs42_removexattrres {
|
||||
struct nfs4_sequence_res seq_res;
|
||||
struct nfs4_change_info cinfo;
|
||||
};
|
||||
|
||||
#endif /* CONFIG_NFS_V4_2 */
|
||||
|
||||
struct nfs_page;
|
||||
|
||||
|
|
|
@ -101,6 +101,7 @@ struct rpc_rqst {
|
|||
* used in the softirq.
|
||||
*/
|
||||
unsigned long rq_majortimeo; /* major timeout alarm */
|
||||
unsigned long rq_minortimeo; /* minor timeout alarm */
|
||||
unsigned long rq_timeout; /* Current timeout value */
|
||||
ktime_t rq_rtt; /* round-trip time */
|
||||
unsigned int rq_retries; /* # of retries */
|
||||
|
|
|
@ -56,6 +56,7 @@
|
|||
#define NFSDBG_PNFS 0x1000
|
||||
#define NFSDBG_PNFS_LD 0x2000
|
||||
#define NFSDBG_STATE 0x4000
|
||||
#define NFSDBG_XATTRCACHE 0x8000
|
||||
#define NFSDBG_ALL 0xFFFF
|
||||
|
||||
|
||||
|
|
|
@ -1510,6 +1510,6 @@ err_notifier:
|
|||
void unregister_rpc_pipefs(void)
|
||||
{
|
||||
rpc_clients_notifier_unregister();
|
||||
kmem_cache_destroy(rpc_inode_cachep);
|
||||
unregister_filesystem(&rpc_pipe_fs_type);
|
||||
kmem_cache_destroy(rpc_inode_cachep);
|
||||
}
|
||||
|
|
|
@ -607,6 +607,11 @@ static void xprt_reset_majortimeo(struct rpc_rqst *req)
|
|||
req->rq_majortimeo += xprt_calc_majortimeo(req);
|
||||
}
|
||||
|
||||
static void xprt_reset_minortimeo(struct rpc_rqst *req)
|
||||
{
|
||||
req->rq_minortimeo += req->rq_timeout;
|
||||
}
|
||||
|
||||
static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req)
|
||||
{
|
||||
unsigned long time_init;
|
||||
|
@ -618,6 +623,7 @@ static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req)
|
|||
time_init = xprt_abs_ktime_to_jiffies(task->tk_start);
|
||||
req->rq_timeout = task->tk_client->cl_timeout->to_initval;
|
||||
req->rq_majortimeo = time_init + xprt_calc_majortimeo(req);
|
||||
req->rq_minortimeo = time_init + req->rq_timeout;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -631,6 +637,8 @@ int xprt_adjust_timeout(struct rpc_rqst *req)
|
|||
const struct rpc_timeout *to = req->rq_task->tk_client->cl_timeout;
|
||||
int status = 0;
|
||||
|
||||
if (time_before(jiffies, req->rq_minortimeo))
|
||||
return status;
|
||||
if (time_before(jiffies, req->rq_majortimeo)) {
|
||||
if (to->to_exponential)
|
||||
req->rq_timeout <<= 1;
|
||||
|
@ -649,6 +657,7 @@ int xprt_adjust_timeout(struct rpc_rqst *req)
|
|||
spin_unlock(&xprt->transport_lock);
|
||||
status = -ETIMEDOUT;
|
||||
}
|
||||
xprt_reset_minortimeo(req);
|
||||
|
||||
if (req->rq_timeout == 0) {
|
||||
printk(KERN_WARNING "xprt_adjust_timeout: rq_timeout = 0!\n");
|
||||
|
|
Loading…
Reference in New Issue