a848c29e34
On the node of an NFS client, some files saved in the mountpoint of the
NFS server were copied to another location of the same NFS server.
Accidentally, the nfs42_complete_copies() got a NULL-pointer dereference
crash with the following syslog:
[232064.838881] NFSv4: state recovery failed for open file nfs/pvc-12b5200d-cd0f-46a3-b9f0-af8f4fe0ef64.qcow2, error = -116
[232064.839360] NFSv4: state recovery failed for open file nfs/pvc-12b5200d-cd0f-46a3-b9f0-af8f4fe0ef64.qcow2, error = -116
[232066.588183] Unable to handle kernel NULL pointer dereference at virtual address 0000000000000058
[232066.588586] Mem abort info:
[232066.588701] ESR = 0x0000000096000007
[232066.588862] EC = 0x25: DABT (current EL), IL = 32 bits
[232066.589084] SET = 0, FnV = 0
[232066.589216] EA = 0, S1PTW = 0
[232066.589340] FSC = 0x07: level 3 translation fault
[232066.589559] Data abort info:
[232066.589683] ISV = 0, ISS = 0x00000007
[232066.589842] CM = 0, WnR = 0
[232066.589967] user pgtable: 64k pages, 48-bit VAs, pgdp=00002000956ff400
[232066.590231] [0000000000000058] pgd=08001100ae100003, p4d=08001100ae100003, pud=08001100ae100003, pmd=08001100b3c00003, pte=0000000000000000
[232066.590757] Internal error: Oops: 96000007 [#1] SMP
[232066.590958] Modules linked in: rpcsec_gss_krb5 auth_rpcgss nfsv4 dns_resolver nfs lockd grace fscache netfs ocfs2_dlmfs ocfs2_stack_o2cb ocfs2_dlm vhost_net vhost vhost_iotlb tap tun ipt_rpfilter xt_multiport ip_set_hash_ip ip_set_hash_net xfrm_interface xfrm6_tunnel tunnel4 tunnel6 esp4 ah4 wireguard libcurve25519_generic veth xt_addrtype xt_set nf_conntrack_netlink ip_set_hash_ipportnet ip_set_hash_ipportip ip_set_bitmap_port ip_set_hash_ipport dummy ip_set ip_vs_sh ip_vs_wrr ip_vs_rr ip_vs iptable_filter sch_ingress nfnetlink_cttimeout vport_gre ip_gre ip_tunnel gre vport_geneve geneve vport_vxlan vxlan ip6_udp_tunnel udp_tunnel openvswitch nf_conncount dm_round_robin dm_service_time dm_multipath xt_nat xt_MASQUERADE nft_chain_nat nf_nat xt_mark xt_conntrack xt_comment nft_compat nft_counter nf_tables nfnetlink ocfs2 ocfs2_nodemanager ocfs2_stackglue iscsi_tcp libiscsi_tcp libiscsi scsi_transport_iscsi ipmi_ssif nbd overlay 8021q garp mrp bonding tls rfkill sunrpc ext4 mbcache jbd2
[232066.591052] vfat fat cas_cache cas_disk ses enclosure scsi_transport_sas sg acpi_ipmi ipmi_si ipmi_devintf ipmi_msghandler ip_tables vfio_pci vfio_pci_core vfio_virqfd vfio_iommu_type1 vfio dm_mirror dm_region_hash dm_log dm_mod nf_conntrack nf_defrag_ipv6 nf_defrag_ipv4 br_netfilter bridge stp llc fuse xfs libcrc32c ast drm_vram_helper qla2xxx drm_kms_helper syscopyarea crct10dif_ce sysfillrect ghash_ce sysimgblt sha2_ce fb_sys_fops cec sha256_arm64 sha1_ce drm_ttm_helper ttm nvme_fc igb sbsa_gwdt nvme_fabrics drm nvme_core i2c_algo_bit i40e scsi_transport_fc megaraid_sas aes_neon_bs
[232066.596953] CPU: 6 PID: 4124696 Comm: 10.253.166.125- Kdump: loaded Not tainted 5.15.131-9.cl9_ocfs2.aarch64 #1
[232066.597356] Hardware name: Great Wall .\x93\x8e...RF6260 V5/GWMSSE2GL1T, BIOS T656FBE_V3.0.18 2024-01-06
[232066.597721] pstate: 20400009 (nzCv daif +PAN -UAO -TCO -DIT -SSBS BTYPE=--)
[232066.598034] pc : nfs4_reclaim_open_state+0x220/0x800 [nfsv4]
[232066.598327] lr : nfs4_reclaim_open_state+0x12c/0x800 [nfsv4]
[232066.598595] sp : ffff8000f568fc70
[232066.598731] x29: ffff8000f568fc70 x28: 0000000000001000 x27: ffff21003db33000
[232066.599030] x26: ffff800005521ae0 x25: ffff0100f98fa3f0 x24: 0000000000000001
[232066.599319] x23: ffff800009920008 x22: ffff21003db33040 x21: ffff21003db33050
[232066.599628] x20: ffff410172fe9e40 x19: ffff410172fe9e00 x18: 0000000000000000
[232066.599914] x17: 0000000000000000 x16: 0000000000000004 x15: 0000000000000000
[232066.600195] x14: 0000000000000000 x13: ffff800008e685a8 x12: 00000000eac0c6e6
[232066.600498] x11: 0000000000000000 x10: 0000000000000008 x9 : ffff8000054e5828
[232066.600784] x8 : 00000000ffffffbf x7 : 0000000000000001 x6 : 000000000a9eb14a
[232066.601062] x5 : 0000000000000000 x4 : ffff70ff8a14a800 x3 : 0000000000000058
[232066.601348] x2 : 0000000000000001 x1 : 54dce46366daa6c6 x0 : 0000000000000000
[232066.601636] Call trace:
[232066.601749] nfs4_reclaim_open_state+0x220/0x800 [nfsv4]
[232066.601998] nfs4_do_reclaim+0x1b8/0x28c [nfsv4]
[232066.602218] nfs4_state_manager+0x928/0x10f0 [nfsv4]
[232066.602455] nfs4_run_state_manager+0x78/0x1b0 [nfsv4]
[232066.602690] kthread+0x110/0x114
[232066.602830] ret_from_fork+0x10/0x20
[232066.602985] Code: 1400000d f9403f20 f9402e61 91016003 (f9402c00)
[232066.603284] SMP: stopping secondary CPUs
[232066.606936] Starting crashdump kernel...
[232066.607146] Bye!
Analysing the vmcore, we know that nfs4_copy_state listed by destination
nfs_server->ss_copies was added by the field copies in handle_async_copy(),
and we found a waiting copy process with the stack as:
PID: 3511963 TASK: ffff710028b47e00 CPU: 0 COMMAND: "cp"
#0 [ffff8001116ef740] __switch_to at ffff8000081b92f4
#1 [ffff8001116ef760] __schedule at ffff800008dd0650
#2 [ffff8001116ef7c0] schedule at ffff800008dd0a00
#3 [ffff8001116ef7e0] schedule_timeout at ffff800008dd6aa0
#4 [ffff8001116ef860] __wait_for_common at ffff800008dd166c
#5 [ffff8001116ef8e0] wait_for_completion_interruptible at ffff800008dd1898
#6 [ffff8001116ef8f0] handle_async_copy at ffff8000055142f4 [nfsv4]
#7 [ffff8001116ef970] _nfs42_proc_copy at ffff8000055147c8 [nfsv4]
#8 [ffff8001116efa80] nfs42_proc_copy at ffff800005514cf0 [nfsv4]
#9 [ffff8001116efc50] __nfs4_copy_file_range.constprop.0 at ffff8000054ed694 [nfsv4]
The NULL-pointer dereference was due to nfs42_complete_copies() listed
the nfs_server->ss_copies by the field ss_copies of nfs4_copy_state.
So the nfs4_copy_state address ffff0100f98fa3f0 was offset by 0x10 and
the data accessed through this pointer was also incorrect. Generally,
the ordered list nfs4_state_owner->so_states indicate open(O_RDWR) or
open(O_WRITE) states are reclaimed firstly by nfs4_reclaim_open_state().
When destination state reclaim is failed with NFS_STATE_RECOVERY_FAILED
and copies are not deleted in nfs_server->ss_copies, the source state
may be passed to the nfs42_complete_copies() process earlier, resulting
in this crash scene finally. To solve this issue, we add a list_head
nfs_server->ss_src_copies for a server-to-server copy specially.
Fixes: 0e65a32c8a
("NFS: handle source server reboot")
Signed-off-by: Yanjun Zhang <zhangyanjun@cestc.cn>
Reviewed-by: Trond Myklebust <trond.myklebust@hammerspace.com>
Signed-off-by: Anna Schumaker <anna.schumaker@oracle.com>
1462 lines
37 KiB
C
1462 lines
37 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
|
|
*/
|
|
#include <linux/fs.h>
|
|
#include <linux/sunrpc/addr.h>
|
|
#include <linux/sunrpc/sched.h>
|
|
#include <linux/nfs.h>
|
|
#include <linux/nfs3.h>
|
|
#include <linux/nfs4.h>
|
|
#include <linux/nfs_xdr.h>
|
|
#include <linux/nfs_fs.h>
|
|
#include "nfs4_fs.h"
|
|
#include "nfs42.h"
|
|
#include "iostat.h"
|
|
#include "pnfs.h"
|
|
#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);
|
|
|
|
static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
|
|
{
|
|
struct nfs_client *clp = (NFS_SERVER(file_inode(filep)))->nfs_client;
|
|
unsigned short port = 2049;
|
|
|
|
rcu_read_lock();
|
|
naddr->netid_len = scnprintf(naddr->netid,
|
|
sizeof(naddr->netid), "%s",
|
|
rpc_peeraddr2str(clp->cl_rpcclient,
|
|
RPC_DISPLAY_NETID));
|
|
naddr->addr_len = scnprintf(naddr->addr,
|
|
sizeof(naddr->addr),
|
|
"%s.%u.%u",
|
|
rpc_peeraddr2str(clp->cl_rpcclient,
|
|
RPC_DISPLAY_ADDR),
|
|
port >> 8, port & 255);
|
|
rcu_read_unlock();
|
|
}
|
|
|
|
static int _nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
|
|
struct nfs_lock_context *lock, loff_t offset, loff_t len)
|
|
{
|
|
struct inode *inode = file_inode(filep);
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
u32 bitmask[NFS_BITMASK_SZ];
|
|
struct nfs42_falloc_args args = {
|
|
.falloc_fh = NFS_FH(inode),
|
|
.falloc_offset = offset,
|
|
.falloc_length = len,
|
|
.falloc_bitmask = bitmask,
|
|
};
|
|
struct nfs42_falloc_res res = {
|
|
.falloc_server = server,
|
|
};
|
|
int status;
|
|
|
|
msg->rpc_argp = &args;
|
|
msg->rpc_resp = &res;
|
|
|
|
status = nfs4_set_rw_stateid(&args.falloc_stateid, lock->open_context,
|
|
lock, FMODE_WRITE);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
|
|
nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask, inode,
|
|
NFS_INO_INVALID_BLOCKS);
|
|
|
|
res.falloc_fattr = nfs_alloc_fattr();
|
|
if (!res.falloc_fattr)
|
|
return -ENOMEM;
|
|
|
|
status = nfs4_call_sync(server->client, server, msg,
|
|
&args.seq_args, &res.seq_res, 0);
|
|
if (status == 0) {
|
|
if (nfs_should_remove_suid(inode)) {
|
|
spin_lock(&inode->i_lock);
|
|
nfs_set_cache_invalid(inode,
|
|
NFS_INO_REVAL_FORCED | NFS_INO_INVALID_MODE);
|
|
spin_unlock(&inode->i_lock);
|
|
}
|
|
status = nfs_post_op_update_inode_force_wcc(inode,
|
|
res.falloc_fattr);
|
|
}
|
|
if (msg->rpc_proc == &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE])
|
|
trace_nfs4_fallocate(inode, &args, status);
|
|
else
|
|
trace_nfs4_deallocate(inode, &args, status);
|
|
kfree(res.falloc_fattr);
|
|
return status;
|
|
}
|
|
|
|
static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
|
|
loff_t offset, loff_t len)
|
|
{
|
|
struct inode *inode = file_inode(filep);
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
struct nfs4_exception exception = { };
|
|
struct nfs_lock_context *lock;
|
|
int err;
|
|
|
|
lock = nfs_get_lock_context(nfs_file_open_context(filep));
|
|
if (IS_ERR(lock))
|
|
return PTR_ERR(lock);
|
|
|
|
exception.inode = inode;
|
|
exception.state = lock->open_context->state;
|
|
|
|
err = nfs_sync_inode(inode);
|
|
if (err)
|
|
goto out;
|
|
|
|
do {
|
|
err = _nfs42_proc_fallocate(msg, filep, lock, offset, len);
|
|
if (err == -ENOTSUPP) {
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
err = nfs4_handle_exception(server, err, &exception);
|
|
} while (exception.retry);
|
|
out:
|
|
nfs_put_lock_context(lock);
|
|
return err;
|
|
}
|
|
|
|
int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
|
|
{
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
|
|
};
|
|
struct inode *inode = file_inode(filep);
|
|
int err;
|
|
|
|
if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
|
|
return -EOPNOTSUPP;
|
|
|
|
inode_lock(inode);
|
|
|
|
err = nfs42_proc_fallocate(&msg, filep, offset, len);
|
|
if (err == -EOPNOTSUPP)
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
|
|
|
|
inode_unlock(inode);
|
|
return err;
|
|
}
|
|
|
|
int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
|
|
{
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
|
|
};
|
|
struct inode *inode = file_inode(filep);
|
|
int err;
|
|
|
|
if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
|
|
return -EOPNOTSUPP;
|
|
|
|
inode_lock(inode);
|
|
|
|
err = nfs42_proc_fallocate(&msg, filep, offset, len);
|
|
if (err == 0)
|
|
truncate_pagecache_range(inode, offset, (offset + len) -1);
|
|
if (err == -EOPNOTSUPP)
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
|
|
|
|
inode_unlock(inode);
|
|
return err;
|
|
}
|
|
|
|
static int handle_async_copy(struct nfs42_copy_res *res,
|
|
struct nfs_server *dst_server,
|
|
struct nfs_server *src_server,
|
|
struct file *src,
|
|
struct file *dst,
|
|
nfs4_stateid *src_stateid,
|
|
bool *restart)
|
|
{
|
|
struct nfs4_copy_state *copy, *tmp_copy = NULL, *iter;
|
|
int status = NFS4_OK;
|
|
struct nfs_open_context *dst_ctx = nfs_file_open_context(dst);
|
|
struct nfs_open_context *src_ctx = nfs_file_open_context(src);
|
|
|
|
copy = kzalloc(sizeof(struct nfs4_copy_state), GFP_KERNEL);
|
|
if (!copy)
|
|
return -ENOMEM;
|
|
|
|
spin_lock(&dst_server->nfs_client->cl_lock);
|
|
list_for_each_entry(iter,
|
|
&dst_server->nfs_client->pending_cb_stateids,
|
|
copies) {
|
|
if (memcmp(&res->write_res.stateid, &iter->stateid,
|
|
NFS4_STATEID_SIZE))
|
|
continue;
|
|
tmp_copy = iter;
|
|
list_del(&iter->copies);
|
|
break;
|
|
}
|
|
if (tmp_copy) {
|
|
spin_unlock(&dst_server->nfs_client->cl_lock);
|
|
kfree(copy);
|
|
copy = tmp_copy;
|
|
goto out;
|
|
}
|
|
|
|
memcpy(©->stateid, &res->write_res.stateid, NFS4_STATEID_SIZE);
|
|
init_completion(©->completion);
|
|
copy->parent_dst_state = dst_ctx->state;
|
|
copy->parent_src_state = src_ctx->state;
|
|
|
|
list_add_tail(©->copies, &dst_server->ss_copies);
|
|
spin_unlock(&dst_server->nfs_client->cl_lock);
|
|
|
|
if (dst_server != src_server) {
|
|
spin_lock(&src_server->nfs_client->cl_lock);
|
|
list_add_tail(©->src_copies, &src_server->ss_src_copies);
|
|
spin_unlock(&src_server->nfs_client->cl_lock);
|
|
}
|
|
|
|
status = wait_for_completion_interruptible(©->completion);
|
|
spin_lock(&dst_server->nfs_client->cl_lock);
|
|
list_del_init(©->copies);
|
|
spin_unlock(&dst_server->nfs_client->cl_lock);
|
|
if (dst_server != src_server) {
|
|
spin_lock(&src_server->nfs_client->cl_lock);
|
|
list_del_init(©->src_copies);
|
|
spin_unlock(&src_server->nfs_client->cl_lock);
|
|
}
|
|
if (status == -ERESTARTSYS) {
|
|
goto out_cancel;
|
|
} else if (copy->flags || copy->error == NFS4ERR_PARTNER_NO_AUTH) {
|
|
status = -EAGAIN;
|
|
*restart = true;
|
|
goto out_cancel;
|
|
}
|
|
out:
|
|
res->write_res.count = copy->count;
|
|
memcpy(&res->write_res.verifier, ©->verf, sizeof(copy->verf));
|
|
status = -copy->error;
|
|
|
|
out_free:
|
|
kfree(copy);
|
|
return status;
|
|
out_cancel:
|
|
nfs42_do_offload_cancel_async(dst, ©->stateid);
|
|
if (!nfs42_files_from_same_server(src, dst))
|
|
nfs42_do_offload_cancel_async(src, src_stateid);
|
|
goto out_free;
|
|
}
|
|
|
|
static int process_copy_commit(struct file *dst, loff_t pos_dst,
|
|
struct nfs42_copy_res *res)
|
|
{
|
|
struct nfs_commitres cres;
|
|
int status = -ENOMEM;
|
|
|
|
cres.verf = kzalloc(sizeof(struct nfs_writeverf), GFP_KERNEL);
|
|
if (!cres.verf)
|
|
goto out;
|
|
|
|
status = nfs4_proc_commit(dst, pos_dst, res->write_res.count, &cres);
|
|
if (status)
|
|
goto out_free;
|
|
if (nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
|
|
&cres.verf->verifier)) {
|
|
dprintk("commit verf differs from copy verf\n");
|
|
status = -EAGAIN;
|
|
}
|
|
out_free:
|
|
kfree(cres.verf);
|
|
out:
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* nfs42_copy_dest_done - perform inode cache updates after clone/copy offload
|
|
* @inode: pointer to destination inode
|
|
* @pos: destination offset
|
|
* @len: copy length
|
|
*
|
|
* Punch a hole in the inode page cache, so that the NFS client will
|
|
* know to retrieve new data.
|
|
* Update the file size if necessary, and then mark the inode as having
|
|
* invalid cached values for change attribute, ctime, mtime and space used.
|
|
*/
|
|
static void nfs42_copy_dest_done(struct inode *inode, loff_t pos, loff_t len)
|
|
{
|
|
loff_t newsize = pos + len;
|
|
loff_t end = newsize - 1;
|
|
|
|
WARN_ON_ONCE(invalidate_inode_pages2_range(inode->i_mapping,
|
|
pos >> PAGE_SHIFT, end >> PAGE_SHIFT));
|
|
|
|
spin_lock(&inode->i_lock);
|
|
if (newsize > i_size_read(inode))
|
|
i_size_write(inode, newsize);
|
|
nfs_set_cache_invalid(inode, NFS_INO_INVALID_CHANGE |
|
|
NFS_INO_INVALID_CTIME |
|
|
NFS_INO_INVALID_MTIME |
|
|
NFS_INO_INVALID_BLOCKS);
|
|
spin_unlock(&inode->i_lock);
|
|
}
|
|
|
|
static ssize_t _nfs42_proc_copy(struct file *src,
|
|
struct nfs_lock_context *src_lock,
|
|
struct file *dst,
|
|
struct nfs_lock_context *dst_lock,
|
|
struct nfs42_copy_args *args,
|
|
struct nfs42_copy_res *res,
|
|
struct nl4_server *nss,
|
|
nfs4_stateid *cnr_stateid,
|
|
bool *restart)
|
|
{
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY],
|
|
.rpc_argp = args,
|
|
.rpc_resp = res,
|
|
};
|
|
struct inode *dst_inode = file_inode(dst);
|
|
struct inode *src_inode = file_inode(src);
|
|
struct nfs_server *dst_server = NFS_SERVER(dst_inode);
|
|
struct nfs_server *src_server = NFS_SERVER(src_inode);
|
|
loff_t pos_src = args->src_pos;
|
|
loff_t pos_dst = args->dst_pos;
|
|
size_t count = args->count;
|
|
ssize_t status;
|
|
|
|
if (nss) {
|
|
args->cp_src = nss;
|
|
nfs4_stateid_copy(&args->src_stateid, cnr_stateid);
|
|
} else {
|
|
status = nfs4_set_rw_stateid(&args->src_stateid,
|
|
src_lock->open_context, src_lock, FMODE_READ);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
}
|
|
status = nfs_filemap_write_and_wait_range(src->f_mapping,
|
|
pos_src, pos_src + (loff_t)count - 1);
|
|
if (status)
|
|
return status;
|
|
|
|
status = nfs4_set_rw_stateid(&args->dst_stateid, dst_lock->open_context,
|
|
dst_lock, FMODE_WRITE);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
|
|
status = nfs_sync_inode(dst_inode);
|
|
if (status)
|
|
return status;
|
|
|
|
res->commit_res.verf = NULL;
|
|
if (args->sync) {
|
|
res->commit_res.verf =
|
|
kzalloc(sizeof(struct nfs_writeverf), GFP_KERNEL);
|
|
if (!res->commit_res.verf)
|
|
return -ENOMEM;
|
|
}
|
|
set_bit(NFS_CLNT_SRC_SSC_COPY_STATE,
|
|
&src_lock->open_context->state->flags);
|
|
set_bit(NFS_CLNT_DST_SSC_COPY_STATE,
|
|
&dst_lock->open_context->state->flags);
|
|
|
|
status = nfs4_call_sync(dst_server->client, dst_server, &msg,
|
|
&args->seq_args, &res->seq_res, 0);
|
|
trace_nfs4_copy(src_inode, dst_inode, args, res, nss, status);
|
|
if (status == -ENOTSUPP)
|
|
dst_server->caps &= ~NFS_CAP_COPY;
|
|
if (status)
|
|
goto out;
|
|
|
|
if (args->sync &&
|
|
nfs_write_verifier_cmp(&res->write_res.verifier.verifier,
|
|
&res->commit_res.verf->verifier)) {
|
|
status = -EAGAIN;
|
|
goto out;
|
|
}
|
|
|
|
if (!res->synchronous) {
|
|
status = handle_async_copy(res, dst_server, src_server, src,
|
|
dst, &args->src_stateid, restart);
|
|
if (status)
|
|
goto out;
|
|
}
|
|
|
|
if ((!res->synchronous || !args->sync) &&
|
|
res->write_res.verifier.committed != NFS_FILE_SYNC) {
|
|
status = process_copy_commit(dst, pos_dst, res);
|
|
if (status)
|
|
goto out;
|
|
}
|
|
|
|
nfs42_copy_dest_done(dst_inode, pos_dst, res->write_res.count);
|
|
nfs_invalidate_atime(src_inode);
|
|
status = res->write_res.count;
|
|
out:
|
|
if (args->sync)
|
|
kfree(res->commit_res.verf);
|
|
return status;
|
|
}
|
|
|
|
ssize_t nfs42_proc_copy(struct file *src, loff_t pos_src,
|
|
struct file *dst, loff_t pos_dst, size_t count,
|
|
struct nl4_server *nss,
|
|
nfs4_stateid *cnr_stateid, bool sync)
|
|
{
|
|
struct nfs_server *server = NFS_SERVER(file_inode(dst));
|
|
struct nfs_lock_context *src_lock;
|
|
struct nfs_lock_context *dst_lock;
|
|
struct nfs42_copy_args args = {
|
|
.src_fh = NFS_FH(file_inode(src)),
|
|
.src_pos = pos_src,
|
|
.dst_fh = NFS_FH(file_inode(dst)),
|
|
.dst_pos = pos_dst,
|
|
.count = count,
|
|
.sync = sync,
|
|
};
|
|
struct nfs42_copy_res res;
|
|
struct nfs4_exception src_exception = {
|
|
.inode = file_inode(src),
|
|
.stateid = &args.src_stateid,
|
|
};
|
|
struct nfs4_exception dst_exception = {
|
|
.inode = file_inode(dst),
|
|
.stateid = &args.dst_stateid,
|
|
};
|
|
ssize_t err, err2;
|
|
bool restart = false;
|
|
|
|
src_lock = nfs_get_lock_context(nfs_file_open_context(src));
|
|
if (IS_ERR(src_lock))
|
|
return PTR_ERR(src_lock);
|
|
|
|
src_exception.state = src_lock->open_context->state;
|
|
|
|
dst_lock = nfs_get_lock_context(nfs_file_open_context(dst));
|
|
if (IS_ERR(dst_lock)) {
|
|
err = PTR_ERR(dst_lock);
|
|
goto out_put_src_lock;
|
|
}
|
|
|
|
dst_exception.state = dst_lock->open_context->state;
|
|
|
|
do {
|
|
inode_lock(file_inode(dst));
|
|
err = _nfs42_proc_copy(src, src_lock,
|
|
dst, dst_lock,
|
|
&args, &res,
|
|
nss, cnr_stateid, &restart);
|
|
inode_unlock(file_inode(dst));
|
|
|
|
if (err >= 0)
|
|
break;
|
|
if ((err == -ENOTSUPP ||
|
|
err == -NFS4ERR_OFFLOAD_DENIED) &&
|
|
nfs42_files_from_same_server(src, dst)) {
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
} else if (err == -EAGAIN) {
|
|
if (!restart) {
|
|
dst_exception.retry = 1;
|
|
continue;
|
|
}
|
|
break;
|
|
} else if (err == -NFS4ERR_OFFLOAD_NO_REQS &&
|
|
args.sync != res.synchronous) {
|
|
args.sync = res.synchronous;
|
|
dst_exception.retry = 1;
|
|
continue;
|
|
} else if ((err == -ESTALE ||
|
|
err == -NFS4ERR_OFFLOAD_DENIED ||
|
|
err == -ENOTSUPP) &&
|
|
!nfs42_files_from_same_server(src, dst)) {
|
|
nfs42_do_offload_cancel_async(src, &args.src_stateid);
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
err2 = nfs4_handle_exception(server, err, &src_exception);
|
|
err = nfs4_handle_exception(server, err, &dst_exception);
|
|
if (!err)
|
|
err = err2;
|
|
} while (src_exception.retry || dst_exception.retry);
|
|
|
|
nfs_put_lock_context(dst_lock);
|
|
out_put_src_lock:
|
|
nfs_put_lock_context(src_lock);
|
|
return err;
|
|
}
|
|
|
|
struct nfs42_offloadcancel_data {
|
|
struct nfs_server *seq_server;
|
|
struct nfs42_offload_status_args args;
|
|
struct nfs42_offload_status_res res;
|
|
};
|
|
|
|
static void nfs42_offload_cancel_prepare(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_offloadcancel_data *data = calldata;
|
|
|
|
nfs4_setup_sequence(data->seq_server->nfs_client,
|
|
&data->args.osa_seq_args,
|
|
&data->res.osr_seq_res, task);
|
|
}
|
|
|
|
static void nfs42_offload_cancel_done(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_offloadcancel_data *data = calldata;
|
|
|
|
trace_nfs4_offload_cancel(&data->args, task->tk_status);
|
|
nfs41_sequence_done(task, &data->res.osr_seq_res);
|
|
if (task->tk_status &&
|
|
nfs4_async_handle_error(task, data->seq_server, NULL,
|
|
NULL) == -EAGAIN)
|
|
rpc_restart_call_prepare(task);
|
|
}
|
|
|
|
static void nfs42_free_offloadcancel_data(void *data)
|
|
{
|
|
kfree(data);
|
|
}
|
|
|
|
static const struct rpc_call_ops nfs42_offload_cancel_ops = {
|
|
.rpc_call_prepare = nfs42_offload_cancel_prepare,
|
|
.rpc_call_done = nfs42_offload_cancel_done,
|
|
.rpc_release = nfs42_free_offloadcancel_data,
|
|
};
|
|
|
|
static int nfs42_do_offload_cancel_async(struct file *dst,
|
|
nfs4_stateid *stateid)
|
|
{
|
|
struct nfs_server *dst_server = NFS_SERVER(file_inode(dst));
|
|
struct nfs42_offloadcancel_data *data = NULL;
|
|
struct nfs_open_context *ctx = nfs_file_open_context(dst);
|
|
struct rpc_task *task;
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_CANCEL],
|
|
.rpc_cred = ctx->cred,
|
|
};
|
|
struct rpc_task_setup task_setup_data = {
|
|
.rpc_client = dst_server->client,
|
|
.rpc_message = &msg,
|
|
.callback_ops = &nfs42_offload_cancel_ops,
|
|
.workqueue = nfsiod_workqueue,
|
|
.flags = RPC_TASK_ASYNC,
|
|
};
|
|
int status;
|
|
|
|
if (!(dst_server->caps & NFS_CAP_OFFLOAD_CANCEL))
|
|
return -EOPNOTSUPP;
|
|
|
|
data = kzalloc(sizeof(struct nfs42_offloadcancel_data), GFP_KERNEL);
|
|
if (data == NULL)
|
|
return -ENOMEM;
|
|
|
|
data->seq_server = dst_server;
|
|
data->args.osa_src_fh = NFS_FH(file_inode(dst));
|
|
memcpy(&data->args.osa_stateid, stateid,
|
|
sizeof(data->args.osa_stateid));
|
|
msg.rpc_argp = &data->args;
|
|
msg.rpc_resp = &data->res;
|
|
task_setup_data.callback_data = data;
|
|
nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
|
|
1, 0);
|
|
task = rpc_run_task(&task_setup_data);
|
|
if (IS_ERR(task))
|
|
return PTR_ERR(task);
|
|
status = rpc_wait_for_completion_task(task);
|
|
if (status == -ENOTSUPP)
|
|
dst_server->caps &= ~NFS_CAP_OFFLOAD_CANCEL;
|
|
rpc_put_task(task);
|
|
return status;
|
|
}
|
|
|
|
static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
|
|
struct nfs42_copy_notify_args *args,
|
|
struct nfs42_copy_notify_res *res)
|
|
{
|
|
struct nfs_server *src_server = NFS_SERVER(file_inode(src));
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COPY_NOTIFY],
|
|
.rpc_argp = args,
|
|
.rpc_resp = res,
|
|
};
|
|
int status;
|
|
struct nfs_open_context *ctx;
|
|
struct nfs_lock_context *l_ctx;
|
|
|
|
ctx = get_nfs_open_context(nfs_file_open_context(src));
|
|
l_ctx = nfs_get_lock_context(ctx);
|
|
if (IS_ERR(l_ctx)) {
|
|
status = PTR_ERR(l_ctx);
|
|
goto out;
|
|
}
|
|
|
|
status = nfs4_set_rw_stateid(&args->cna_src_stateid, ctx, l_ctx,
|
|
FMODE_READ);
|
|
nfs_put_lock_context(l_ctx);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
goto out;
|
|
}
|
|
|
|
status = nfs4_call_sync(src_server->client, src_server, &msg,
|
|
&args->cna_seq_args, &res->cnr_seq_res, 0);
|
|
trace_nfs4_copy_notify(file_inode(src), args, res, status);
|
|
if (status == -ENOTSUPP)
|
|
src_server->caps &= ~NFS_CAP_COPY_NOTIFY;
|
|
|
|
out:
|
|
put_nfs_open_context(nfs_file_open_context(src));
|
|
return status;
|
|
}
|
|
|
|
int nfs42_proc_copy_notify(struct file *src, struct file *dst,
|
|
struct nfs42_copy_notify_res *res)
|
|
{
|
|
struct nfs_server *src_server = NFS_SERVER(file_inode(src));
|
|
struct nfs42_copy_notify_args *args;
|
|
struct nfs4_exception exception = {
|
|
.inode = file_inode(src),
|
|
};
|
|
int status;
|
|
|
|
if (!(src_server->caps & NFS_CAP_COPY_NOTIFY))
|
|
return -EOPNOTSUPP;
|
|
|
|
args = kzalloc(sizeof(struct nfs42_copy_notify_args), GFP_KERNEL);
|
|
if (args == NULL)
|
|
return -ENOMEM;
|
|
|
|
args->cna_src_fh = NFS_FH(file_inode(src)),
|
|
args->cna_dst.nl4_type = NL4_NETADDR;
|
|
nfs42_set_netaddr(dst, &args->cna_dst.u.nl4_addr);
|
|
exception.stateid = &args->cna_src_stateid;
|
|
|
|
do {
|
|
status = _nfs42_proc_copy_notify(src, dst, args, res);
|
|
if (status == -ENOTSUPP) {
|
|
status = -EOPNOTSUPP;
|
|
goto out;
|
|
}
|
|
status = nfs4_handle_exception(src_server, status, &exception);
|
|
} while (exception.retry);
|
|
|
|
out:
|
|
kfree(args);
|
|
return status;
|
|
}
|
|
|
|
static loff_t _nfs42_proc_llseek(struct file *filep,
|
|
struct nfs_lock_context *lock, loff_t offset, int whence)
|
|
{
|
|
struct inode *inode = file_inode(filep);
|
|
struct nfs42_seek_args args = {
|
|
.sa_fh = NFS_FH(inode),
|
|
.sa_offset = offset,
|
|
.sa_what = (whence == SEEK_HOLE) ?
|
|
NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
|
|
};
|
|
struct nfs42_seek_res res;
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
|
|
.rpc_argp = &args,
|
|
.rpc_resp = &res,
|
|
};
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
int status;
|
|
|
|
if (!nfs_server_capable(inode, NFS_CAP_SEEK))
|
|
return -ENOTSUPP;
|
|
|
|
status = nfs4_set_rw_stateid(&args.sa_stateid, lock->open_context,
|
|
lock, FMODE_READ);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
|
|
status = nfs_filemap_write_and_wait_range(inode->i_mapping,
|
|
offset, LLONG_MAX);
|
|
if (status)
|
|
return status;
|
|
|
|
status = nfs4_call_sync(server->client, server, &msg,
|
|
&args.seq_args, &res.seq_res, 0);
|
|
trace_nfs4_llseek(inode, &args, &res, status);
|
|
if (status == -ENOTSUPP)
|
|
server->caps &= ~NFS_CAP_SEEK;
|
|
if (status)
|
|
return status;
|
|
|
|
if (whence == SEEK_DATA && res.sr_eof)
|
|
return -NFS4ERR_NXIO;
|
|
else
|
|
return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
|
|
}
|
|
|
|
loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
|
|
{
|
|
struct nfs_server *server = NFS_SERVER(file_inode(filep));
|
|
struct nfs4_exception exception = { };
|
|
struct nfs_lock_context *lock;
|
|
loff_t err;
|
|
|
|
lock = nfs_get_lock_context(nfs_file_open_context(filep));
|
|
if (IS_ERR(lock))
|
|
return PTR_ERR(lock);
|
|
|
|
exception.inode = file_inode(filep);
|
|
exception.state = lock->open_context->state;
|
|
|
|
do {
|
|
err = _nfs42_proc_llseek(filep, lock, offset, whence);
|
|
if (err >= 0)
|
|
break;
|
|
if (err == -ENOTSUPP) {
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
err = nfs4_handle_exception(server, err, &exception);
|
|
} while (exception.retry);
|
|
|
|
nfs_put_lock_context(lock);
|
|
return err;
|
|
}
|
|
|
|
|
|
static void
|
|
nfs42_layoutstat_prepare(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_layoutstat_data *data = calldata;
|
|
struct inode *inode = data->inode;
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
struct pnfs_layout_hdr *lo;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
lo = NFS_I(inode)->layout;
|
|
if (!pnfs_layout_is_valid(lo)) {
|
|
spin_unlock(&inode->i_lock);
|
|
rpc_exit(task, 0);
|
|
return;
|
|
}
|
|
nfs4_stateid_copy(&data->args.stateid, &lo->plh_stateid);
|
|
spin_unlock(&inode->i_lock);
|
|
nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
|
|
&data->res.seq_res, task);
|
|
}
|
|
|
|
static void
|
|
nfs42_layoutstat_done(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_layoutstat_data *data = calldata;
|
|
struct inode *inode = data->inode;
|
|
struct pnfs_layout_hdr *lo;
|
|
|
|
if (!nfs4_sequence_done(task, &data->res.seq_res))
|
|
return;
|
|
|
|
switch (task->tk_status) {
|
|
case 0:
|
|
return;
|
|
case -NFS4ERR_BADHANDLE:
|
|
case -ESTALE:
|
|
pnfs_destroy_layout(NFS_I(inode));
|
|
break;
|
|
case -NFS4ERR_EXPIRED:
|
|
case -NFS4ERR_ADMIN_REVOKED:
|
|
case -NFS4ERR_DELEG_REVOKED:
|
|
case -NFS4ERR_STALE_STATEID:
|
|
case -NFS4ERR_BAD_STATEID:
|
|
spin_lock(&inode->i_lock);
|
|
lo = NFS_I(inode)->layout;
|
|
if (pnfs_layout_is_valid(lo) &&
|
|
nfs4_stateid_match(&data->args.stateid,
|
|
&lo->plh_stateid)) {
|
|
LIST_HEAD(head);
|
|
|
|
/*
|
|
* Mark the bad layout state as invalid, then retry
|
|
* with the current stateid.
|
|
*/
|
|
pnfs_mark_layout_stateid_invalid(lo, &head);
|
|
spin_unlock(&inode->i_lock);
|
|
pnfs_free_lseg_list(&head);
|
|
nfs_commit_inode(inode, 0);
|
|
} else
|
|
spin_unlock(&inode->i_lock);
|
|
break;
|
|
case -NFS4ERR_OLD_STATEID:
|
|
spin_lock(&inode->i_lock);
|
|
lo = NFS_I(inode)->layout;
|
|
if (pnfs_layout_is_valid(lo) &&
|
|
nfs4_stateid_match_other(&data->args.stateid,
|
|
&lo->plh_stateid)) {
|
|
/* Do we need to delay before resending? */
|
|
if (!nfs4_stateid_is_newer(&lo->plh_stateid,
|
|
&data->args.stateid))
|
|
rpc_delay(task, HZ);
|
|
rpc_restart_call_prepare(task);
|
|
}
|
|
spin_unlock(&inode->i_lock);
|
|
break;
|
|
case -ENOTSUPP:
|
|
case -EOPNOTSUPP:
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTSTATS;
|
|
}
|
|
|
|
trace_nfs4_layoutstats(inode, &data->args.stateid, task->tk_status);
|
|
}
|
|
|
|
static void
|
|
nfs42_layoutstat_release(void *calldata)
|
|
{
|
|
struct nfs42_layoutstat_data *data = calldata;
|
|
struct nfs42_layoutstat_devinfo *devinfo = data->args.devinfo;
|
|
int i;
|
|
|
|
for (i = 0; i < data->args.num_dev; i++) {
|
|
if (devinfo[i].ld_private.ops && devinfo[i].ld_private.ops->free)
|
|
devinfo[i].ld_private.ops->free(&devinfo[i].ld_private);
|
|
}
|
|
|
|
pnfs_put_layout_hdr(NFS_I(data->args.inode)->layout);
|
|
smp_mb__before_atomic();
|
|
clear_bit(NFS_INO_LAYOUTSTATS, &NFS_I(data->args.inode)->flags);
|
|
smp_mb__after_atomic();
|
|
nfs_iput_and_deactive(data->inode);
|
|
kfree(data->args.devinfo);
|
|
kfree(data);
|
|
}
|
|
|
|
static const struct rpc_call_ops nfs42_layoutstat_ops = {
|
|
.rpc_call_prepare = nfs42_layoutstat_prepare,
|
|
.rpc_call_done = nfs42_layoutstat_done,
|
|
.rpc_release = nfs42_layoutstat_release,
|
|
};
|
|
|
|
int nfs42_proc_layoutstats_generic(struct nfs_server *server,
|
|
struct nfs42_layoutstat_data *data)
|
|
{
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTSTATS],
|
|
.rpc_argp = &data->args,
|
|
.rpc_resp = &data->res,
|
|
};
|
|
struct rpc_task_setup task_setup = {
|
|
.rpc_client = server->client,
|
|
.rpc_message = &msg,
|
|
.callback_ops = &nfs42_layoutstat_ops,
|
|
.callback_data = data,
|
|
.flags = RPC_TASK_ASYNC,
|
|
};
|
|
struct rpc_task *task;
|
|
|
|
data->inode = nfs_igrab_and_active(data->args.inode);
|
|
if (!data->inode) {
|
|
nfs42_layoutstat_release(data);
|
|
return -EAGAIN;
|
|
}
|
|
nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
|
|
task = rpc_run_task(&task_setup);
|
|
if (IS_ERR(task))
|
|
return PTR_ERR(task);
|
|
rpc_put_task(task);
|
|
return 0;
|
|
}
|
|
|
|
static struct nfs42_layouterror_data *
|
|
nfs42_alloc_layouterror_data(struct pnfs_layout_segment *lseg, gfp_t gfp_flags)
|
|
{
|
|
struct nfs42_layouterror_data *data;
|
|
struct inode *inode = lseg->pls_layout->plh_inode;
|
|
|
|
data = kzalloc(sizeof(*data), gfp_flags);
|
|
if (data) {
|
|
data->args.inode = data->inode = nfs_igrab_and_active(inode);
|
|
if (data->inode) {
|
|
data->lseg = pnfs_get_lseg(lseg);
|
|
if (data->lseg)
|
|
return data;
|
|
nfs_iput_and_deactive(data->inode);
|
|
}
|
|
kfree(data);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
nfs42_free_layouterror_data(struct nfs42_layouterror_data *data)
|
|
{
|
|
pnfs_put_lseg(data->lseg);
|
|
nfs_iput_and_deactive(data->inode);
|
|
kfree(data);
|
|
}
|
|
|
|
static void
|
|
nfs42_layouterror_prepare(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_layouterror_data *data = calldata;
|
|
struct inode *inode = data->inode;
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
|
|
unsigned i;
|
|
|
|
spin_lock(&inode->i_lock);
|
|
if (!pnfs_layout_is_valid(lo)) {
|
|
spin_unlock(&inode->i_lock);
|
|
rpc_exit(task, 0);
|
|
return;
|
|
}
|
|
for (i = 0; i < data->args.num_errors; i++)
|
|
nfs4_stateid_copy(&data->args.errors[i].stateid,
|
|
&lo->plh_stateid);
|
|
spin_unlock(&inode->i_lock);
|
|
nfs4_setup_sequence(server->nfs_client, &data->args.seq_args,
|
|
&data->res.seq_res, task);
|
|
}
|
|
|
|
static void
|
|
nfs42_layouterror_done(struct rpc_task *task, void *calldata)
|
|
{
|
|
struct nfs42_layouterror_data *data = calldata;
|
|
struct inode *inode = data->inode;
|
|
struct pnfs_layout_hdr *lo = data->lseg->pls_layout;
|
|
|
|
if (!nfs4_sequence_done(task, &data->res.seq_res))
|
|
return;
|
|
|
|
switch (task->tk_status) {
|
|
case 0:
|
|
return;
|
|
case -NFS4ERR_BADHANDLE:
|
|
case -ESTALE:
|
|
pnfs_destroy_layout(NFS_I(inode));
|
|
break;
|
|
case -NFS4ERR_EXPIRED:
|
|
case -NFS4ERR_ADMIN_REVOKED:
|
|
case -NFS4ERR_DELEG_REVOKED:
|
|
case -NFS4ERR_STALE_STATEID:
|
|
case -NFS4ERR_BAD_STATEID:
|
|
spin_lock(&inode->i_lock);
|
|
if (pnfs_layout_is_valid(lo) &&
|
|
nfs4_stateid_match(&data->args.errors[0].stateid,
|
|
&lo->plh_stateid)) {
|
|
LIST_HEAD(head);
|
|
|
|
/*
|
|
* Mark the bad layout state as invalid, then retry
|
|
* with the current stateid.
|
|
*/
|
|
pnfs_mark_layout_stateid_invalid(lo, &head);
|
|
spin_unlock(&inode->i_lock);
|
|
pnfs_free_lseg_list(&head);
|
|
nfs_commit_inode(inode, 0);
|
|
} else
|
|
spin_unlock(&inode->i_lock);
|
|
break;
|
|
case -NFS4ERR_OLD_STATEID:
|
|
spin_lock(&inode->i_lock);
|
|
if (pnfs_layout_is_valid(lo) &&
|
|
nfs4_stateid_match_other(&data->args.errors[0].stateid,
|
|
&lo->plh_stateid)) {
|
|
/* Do we need to delay before resending? */
|
|
if (!nfs4_stateid_is_newer(&lo->plh_stateid,
|
|
&data->args.errors[0].stateid))
|
|
rpc_delay(task, HZ);
|
|
rpc_restart_call_prepare(task);
|
|
}
|
|
spin_unlock(&inode->i_lock);
|
|
break;
|
|
case -ENOTSUPP:
|
|
case -EOPNOTSUPP:
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_LAYOUTERROR;
|
|
}
|
|
|
|
trace_nfs4_layouterror(inode, &data->args.errors[0].stateid,
|
|
task->tk_status);
|
|
}
|
|
|
|
static void
|
|
nfs42_layouterror_release(void *calldata)
|
|
{
|
|
struct nfs42_layouterror_data *data = calldata;
|
|
|
|
nfs42_free_layouterror_data(data);
|
|
}
|
|
|
|
static const struct rpc_call_ops nfs42_layouterror_ops = {
|
|
.rpc_call_prepare = nfs42_layouterror_prepare,
|
|
.rpc_call_done = nfs42_layouterror_done,
|
|
.rpc_release = nfs42_layouterror_release,
|
|
};
|
|
|
|
int nfs42_proc_layouterror(struct pnfs_layout_segment *lseg,
|
|
const struct nfs42_layout_error *errors, size_t n)
|
|
{
|
|
struct inode *inode = lseg->pls_layout->plh_inode;
|
|
struct nfs42_layouterror_data *data;
|
|
struct rpc_task *task;
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTERROR],
|
|
};
|
|
struct rpc_task_setup task_setup = {
|
|
.rpc_message = &msg,
|
|
.callback_ops = &nfs42_layouterror_ops,
|
|
.flags = RPC_TASK_ASYNC,
|
|
};
|
|
unsigned int i;
|
|
|
|
if (!nfs_server_capable(inode, NFS_CAP_LAYOUTERROR))
|
|
return -EOPNOTSUPP;
|
|
if (n > NFS42_LAYOUTERROR_MAX)
|
|
return -EINVAL;
|
|
data = nfs42_alloc_layouterror_data(lseg, nfs_io_gfp_mask());
|
|
if (!data)
|
|
return -ENOMEM;
|
|
for (i = 0; i < n; i++) {
|
|
data->args.errors[i] = errors[i];
|
|
data->args.num_errors++;
|
|
data->res.num_errors++;
|
|
}
|
|
msg.rpc_argp = &data->args;
|
|
msg.rpc_resp = &data->res;
|
|
task_setup.callback_data = data;
|
|
task_setup.rpc_client = NFS_SERVER(inode)->client;
|
|
nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
|
|
task = rpc_run_task(&task_setup);
|
|
if (IS_ERR(task))
|
|
return PTR_ERR(task);
|
|
rpc_put_task(task);
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(nfs42_proc_layouterror);
|
|
|
|
static int _nfs42_proc_clone(struct rpc_message *msg, struct file *src_f,
|
|
struct file *dst_f, struct nfs_lock_context *src_lock,
|
|
struct nfs_lock_context *dst_lock, loff_t src_offset,
|
|
loff_t dst_offset, loff_t count)
|
|
{
|
|
struct inode *src_inode = file_inode(src_f);
|
|
struct inode *dst_inode = file_inode(dst_f);
|
|
struct nfs_server *server = NFS_SERVER(dst_inode);
|
|
__u32 dst_bitmask[NFS_BITMASK_SZ];
|
|
struct nfs42_clone_args args = {
|
|
.src_fh = NFS_FH(src_inode),
|
|
.dst_fh = NFS_FH(dst_inode),
|
|
.src_offset = src_offset,
|
|
.dst_offset = dst_offset,
|
|
.count = count,
|
|
.dst_bitmask = dst_bitmask,
|
|
};
|
|
struct nfs42_clone_res res = {
|
|
.server = server,
|
|
};
|
|
int status;
|
|
|
|
msg->rpc_argp = &args;
|
|
msg->rpc_resp = &res;
|
|
|
|
status = nfs4_set_rw_stateid(&args.src_stateid, src_lock->open_context,
|
|
src_lock, FMODE_READ);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
status = nfs4_set_rw_stateid(&args.dst_stateid, dst_lock->open_context,
|
|
dst_lock, FMODE_WRITE);
|
|
if (status) {
|
|
if (status == -EAGAIN)
|
|
status = -NFS4ERR_BAD_STATEID;
|
|
return status;
|
|
}
|
|
|
|
res.dst_fattr = nfs_alloc_fattr();
|
|
if (!res.dst_fattr)
|
|
return -ENOMEM;
|
|
|
|
nfs4_bitmask_set(dst_bitmask, server->cache_consistency_bitmask,
|
|
dst_inode, NFS_INO_INVALID_BLOCKS);
|
|
|
|
status = nfs4_call_sync(server->client, server, msg,
|
|
&args.seq_args, &res.seq_res, 0);
|
|
trace_nfs4_clone(src_inode, dst_inode, &args, status);
|
|
if (status == 0) {
|
|
/* a zero-length count means clone to EOF in src */
|
|
if (count == 0 && res.dst_fattr->valid & NFS_ATTR_FATTR_SIZE)
|
|
count = nfs_size_to_loff_t(res.dst_fattr->size) - dst_offset;
|
|
nfs42_copy_dest_done(dst_inode, dst_offset, count);
|
|
status = nfs_post_op_update_inode(dst_inode, res.dst_fattr);
|
|
}
|
|
|
|
kfree(res.dst_fattr);
|
|
return status;
|
|
}
|
|
|
|
int nfs42_proc_clone(struct file *src_f, struct file *dst_f,
|
|
loff_t src_offset, loff_t dst_offset, loff_t count)
|
|
{
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLONE],
|
|
};
|
|
struct inode *inode = file_inode(src_f);
|
|
struct nfs_server *server = NFS_SERVER(file_inode(src_f));
|
|
struct nfs_lock_context *src_lock;
|
|
struct nfs_lock_context *dst_lock;
|
|
struct nfs4_exception src_exception = { };
|
|
struct nfs4_exception dst_exception = { };
|
|
int err, err2;
|
|
|
|
if (!nfs_server_capable(inode, NFS_CAP_CLONE))
|
|
return -EOPNOTSUPP;
|
|
|
|
src_lock = nfs_get_lock_context(nfs_file_open_context(src_f));
|
|
if (IS_ERR(src_lock))
|
|
return PTR_ERR(src_lock);
|
|
|
|
src_exception.inode = file_inode(src_f);
|
|
src_exception.state = src_lock->open_context->state;
|
|
|
|
dst_lock = nfs_get_lock_context(nfs_file_open_context(dst_f));
|
|
if (IS_ERR(dst_lock)) {
|
|
err = PTR_ERR(dst_lock);
|
|
goto out_put_src_lock;
|
|
}
|
|
|
|
dst_exception.inode = file_inode(dst_f);
|
|
dst_exception.state = dst_lock->open_context->state;
|
|
|
|
do {
|
|
err = _nfs42_proc_clone(&msg, src_f, dst_f, src_lock, dst_lock,
|
|
src_offset, dst_offset, count);
|
|
if (err == -ENOTSUPP || err == -EOPNOTSUPP) {
|
|
NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
|
|
err = -EOPNOTSUPP;
|
|
break;
|
|
}
|
|
|
|
err2 = nfs4_handle_exception(server, err, &src_exception);
|
|
err = nfs4_handle_exception(server, err, &dst_exception);
|
|
if (!err)
|
|
err = err2;
|
|
} while (src_exception.retry || dst_exception.retry);
|
|
|
|
nfs_put_lock_context(dst_lock);
|
|
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);
|
|
trace_nfs4_removexattr(inode, name, ret);
|
|
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);
|
|
__u32 bitmask[NFS_BITMASK_SZ];
|
|
struct page *pages[NFS4XATTR_MAXPAGES];
|
|
struct nfs42_setxattrargs arg = {
|
|
.fh = NFS_FH(inode),
|
|
.bitmask = bitmask,
|
|
.xattr_pages = pages,
|
|
.xattr_len = buflen,
|
|
.xattr_name = name,
|
|
.xattr_flags = flags,
|
|
};
|
|
struct nfs42_setxattrres res = {
|
|
.server = server,
|
|
};
|
|
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;
|
|
|
|
res.fattr = nfs_alloc_fattr();
|
|
if (!res.fattr)
|
|
return -ENOMEM;
|
|
|
|
if (buflen > 0) {
|
|
np = nfs4_buf_to_pages_noslab(buf, buflen, arg.xattr_pages);
|
|
if (np < 0) {
|
|
ret = np;
|
|
goto out;
|
|
}
|
|
} else
|
|
np = 0;
|
|
|
|
nfs4_bitmask_set(bitmask, server->cache_consistency_bitmask,
|
|
inode, NFS_INO_INVALID_CHANGE);
|
|
|
|
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
|
&res.seq_res, 1);
|
|
trace_nfs4_setxattr(inode, name, ret);
|
|
|
|
for (; np > 0; np--)
|
|
put_page(pages[np - 1]);
|
|
|
|
if (!ret) {
|
|
nfs4_update_changeattr(inode, &res.cinfo, timestamp, 0);
|
|
ret = nfs_post_op_update_inode(inode, res.fattr);
|
|
}
|
|
|
|
out:
|
|
kfree(res.fattr);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,
|
|
void *buf, size_t buflen, struct page **pages,
|
|
size_t plen)
|
|
{
|
|
struct nfs_server *server = NFS_SERVER(inode);
|
|
struct nfs42_getxattrargs arg = {
|
|
.fh = NFS_FH(inode),
|
|
.xattr_name = name,
|
|
};
|
|
struct nfs42_getxattrres res;
|
|
struct rpc_message msg = {
|
|
.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETXATTR],
|
|
.rpc_argp = &arg,
|
|
.rpc_resp = &res,
|
|
};
|
|
ssize_t ret;
|
|
|
|
arg.xattr_len = plen;
|
|
arg.xattr_pages = pages;
|
|
|
|
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
|
&res.seq_res, 0);
|
|
trace_nfs4_getxattr(inode, name, ret);
|
|
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);
|
|
}
|
|
|
|
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, i;
|
|
|
|
|
|
ret = -ENOMEM;
|
|
res.scratch = alloc_page(GFP_KERNEL);
|
|
if (!res.scratch)
|
|
goto out;
|
|
|
|
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)
|
|
goto out_free_scratch;
|
|
for (i = 0; i < np; i++) {
|
|
pages[i] = alloc_page(GFP_KERNEL);
|
|
if (!pages[i])
|
|
goto out_free_pages;
|
|
}
|
|
|
|
arg.xattr_pages = pages;
|
|
arg.count = xdrlen;
|
|
|
|
ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args,
|
|
&res.seq_res, 0);
|
|
trace_nfs4_listxattr(inode, ret);
|
|
|
|
if (ret >= 0) {
|
|
ret = res.copied;
|
|
*cookiep = res.cookie;
|
|
*eofp = res.eof;
|
|
}
|
|
|
|
out_free_pages:
|
|
while (--np >= 0) {
|
|
if (pages[np])
|
|
__free_page(pages[np]);
|
|
}
|
|
kfree(pages);
|
|
out_free_scratch:
|
|
__free_page(res.scratch);
|
|
out:
|
|
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, np, i;
|
|
struct page **pages;
|
|
|
|
np = nfs_page_array_len(0, buflen ?: XATTR_SIZE_MAX);
|
|
pages = kmalloc_array(np, sizeof(*pages), GFP_KERNEL);
|
|
if (!pages)
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < np; i++) {
|
|
pages[i] = alloc_page(GFP_KERNEL);
|
|
if (!pages[i]) {
|
|
err = -ENOMEM;
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The GETXATTR op has no length field in the call, and the
|
|
* xattr data is at the end of the reply.
|
|
*
|
|
* There is no downside in using the page-aligned length. It will
|
|
* allow receiving and caching xattrs that are too large for the
|
|
* caller but still fit in the page-rounded value.
|
|
*/
|
|
do {
|
|
err = _nfs42_proc_getxattr(inode, name, buf, buflen,
|
|
pages, np * PAGE_SIZE);
|
|
if (err >= 0)
|
|
break;
|
|
err = nfs4_handle_exception(NFS_SERVER(inode), err,
|
|
&exception);
|
|
} while (exception.retry);
|
|
|
|
out:
|
|
while (--i >= 0)
|
|
__free_page(pages[i]);
|
|
kfree(pages);
|
|
|
|
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;
|
|
}
|