Merge branch 'nfsclone' (51e0164e) · Commits · 戴 / test

fs/nfs/client.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -764,6 +764,7 @@ static void nfs_server_set_fsinfo(struct nfs_server *server,

		server->time_delta = fsinfo->time_delta;

		server->clone_blksize = fsinfo->clone_blksize;
		/* We're airborne Set socket buffersize */
		rpc_setbufsize(server->client, server->wsize + 100, server->rsize + 100);
		}

fs/nfs/nfs42.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -17,5 +17,6 @@ int nfs42_proc_deallocate(struct file *, loff_t, loff_t);
		loff_t nfs42_proc_llseek(struct file *, loff_t, int);
		int nfs42_proc_layoutstats_generic(struct nfs_server *,
		struct nfs42_layoutstat_data *);
		int nfs42_proc_clone(struct file , struct file , loff_t, loff_t, loff_t);

		#endif /* __LINUX_FS_NFS_NFS4_2_H */

fs/nfs/nfs42proc.c

+71 −0

Original line number	Diff line number	Diff line
		@@ -271,3 +271,74 @@ int nfs42_proc_layoutstats_generic(struct nfs_server *server,
		return PTR_ERR(task);
		return 0;
		}

		static int _nfs42_proc_clone(struct rpc_message msg, struct file src_f,
		struct file *dst_f, 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);
		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,
		.dst_bitmask = server->cache_consistency_bitmask,
		};
		struct nfs42_clone_res res = {
		.server = server,
		};
		int status;

		msg->rpc_argp = &args;
		msg->rpc_resp = &res;

		status = nfs42_set_rw_stateid(&args.src_stateid, src_f, FMODE_READ);
		if (status)
		return status;

		status = nfs42_set_rw_stateid(&args.dst_stateid, dst_f, FMODE_WRITE);
		if (status)
		return status;

		res.dst_fattr = nfs_alloc_fattr();
		if (!res.dst_fattr)
		return -ENOMEM;

		status = nfs4_call_sync(server->client, server, msg,
		&args.seq_args, &res.seq_res, 0);
		if (status == 0)
		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 nfs4_exception exception = { };
		int err;

		if (!nfs_server_capable(inode, NFS_CAP_CLONE))
		return -EOPNOTSUPP;

		do {
		err = _nfs42_proc_clone(&msg, src_f, dst_f, src_offset,
		dst_offset, count);
		if (err == -ENOTSUPP \|\| err == -EOPNOTSUPP) {
		NFS_SERVER(inode)->caps &= ~NFS_CAP_CLONE;
		return -EOPNOTSUPP;
		}
		err = nfs4_handle_exception(server, err, &exception);
		} while (exception.retry);

		return err;

		}

fs/nfs/nfs42xdr.c

+96 −1

Original line number	Diff line number	Diff line
		@@ -34,6 +34,12 @@
		1 /* opaque devaddr4 length */ + \
		XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
		#define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
		#define encode_clone_maxsz (encode_stateid_maxsz + \
		encode_stateid_maxsz + \
		2 /* src offset */ + \
		2 /* dst offset */ + \
		2 /* count */)
		#define decode_clone_maxsz (op_decode_hdr_maxsz)

		#define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
		encode_putfh_maxsz + \
		@@ -65,7 +71,20 @@
		decode_sequence_maxsz + \
		decode_putfh_maxsz + \
		PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)

		#define NFS4_enc_clone_sz (compound_encode_hdr_maxsz + \
		encode_sequence_maxsz + \
		encode_putfh_maxsz + \
		encode_savefh_maxsz + \
		encode_putfh_maxsz + \
		encode_clone_maxsz + \
		encode_getattr_maxsz)
		#define NFS4_dec_clone_sz (compound_decode_hdr_maxsz + \
		decode_sequence_maxsz + \
		decode_putfh_maxsz + \
		decode_savefh_maxsz + \
		decode_putfh_maxsz + \
		decode_clone_maxsz + \
		decode_getattr_maxsz)

		static void encode_fallocate(struct xdr_stream *xdr,
		struct nfs42_falloc_args *args)
		@@ -128,6 +147,21 @@ static void encode_layoutstats(struct xdr_stream *xdr,
		encode_uint32(xdr, 0);
		}

		static void encode_clone(struct xdr_stream *xdr,
		struct nfs42_clone_args *args,
		struct compound_hdr *hdr)
		{
		__be32 *p;

		encode_op_hdr(xdr, OP_CLONE, decode_clone_maxsz, hdr);
		encode_nfs4_stateid(xdr, &args->src_stateid);
		encode_nfs4_stateid(xdr, &args->dst_stateid);
		p = reserve_space(xdr, 3*8);
		p = xdr_encode_hyper(p, args->src_offset);
		p = xdr_encode_hyper(p, args->dst_offset);
		xdr_encode_hyper(p, args->count);
		}

		/*
		* Encode ALLOCATE request
		*/
		@@ -206,6 +240,27 @@ static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
		encode_nops(&hdr);
		}

		/*
		* Encode CLONE request
		*/
		static void nfs4_xdr_enc_clone(struct rpc_rqst *req,
		struct xdr_stream *xdr,
		struct nfs42_clone_args *args)
		{
		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->src_fh, &hdr);
		encode_savefh(xdr, &hdr);
		encode_putfh(xdr, args->dst_fh, &hdr);
		encode_clone(xdr, args, &hdr);
		encode_getfattr(xdr, args->dst_bitmask, &hdr);
		encode_nops(&hdr);
		}

		static int decode_allocate(struct xdr_stream xdr, struct nfs42_falloc_res res)
		{
		return decode_op_hdr(xdr, OP_ALLOCATE);
		@@ -243,6 +298,11 @@ static int decode_layoutstats(struct xdr_stream *xdr)
		return decode_op_hdr(xdr, OP_LAYOUTSTATS);
		}

		static int decode_clone(struct xdr_stream *xdr)
		{
		return decode_op_hdr(xdr, OP_CLONE);
		}

		/*
		* Decode ALLOCATE request
		*/
		@@ -351,4 +411,39 @@ out:
		return status;
		}

		/*
		* Decode CLONE request
		*/
		static int nfs4_xdr_dec_clone(struct rpc_rqst *rqstp,
		struct xdr_stream *xdr,
		struct nfs42_clone_res *res)
		{
		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_savefh(xdr);
		if (status)
		goto out;
		status = decode_putfh(xdr);
		if (status)
		goto out;
		status = decode_clone(xdr);
		if (status)
		goto out;
		status = decode_getfattr(xdr, res->dst_fattr, res->server);

		out:
		res->rpc_status = status;
		return status;
		}

		#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */

fs/nfs/nfs4file.c

+136 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,7 @@
		* Copyright (C) 1992 Rick Sladkey
		*/
		#include <linux/fs.h>
		#include <linux/file.h>
		#include <linux/falloc.h>
		#include <linux/nfs_fs.h>
		#include "delegation.h"
		@@ -192,8 +193,138 @@ static long nfs42_fallocate(struct file *filep, int mode, loff_t offset, loff_t
		return nfs42_proc_deallocate(filep, offset, len);
		return nfs42_proc_allocate(filep, offset, len);
		}

		static noinline long
		nfs42_ioctl_clone(struct file *dst_file, unsigned long srcfd,
		u64 src_off, u64 dst_off, u64 count)
		{
		struct inode *dst_inode = file_inode(dst_file);
		struct nfs_server *server = NFS_SERVER(dst_inode);
		struct fd src_file;
		struct inode *src_inode;
		unsigned int bs = server->clone_blksize;
		int ret;

		/* dst file must be opened for writing */
		if (!(dst_file->f_mode & FMODE_WRITE))
		return -EINVAL;

		ret = mnt_want_write_file(dst_file);
		if (ret)
		return ret;

		src_file = fdget(srcfd);
		if (!src_file.file) {
		ret = -EBADF;
		goto out_drop_write;
		}

		src_inode = file_inode(src_file.file);

		/* src and dst must be different files */
		ret = -EINVAL;
		if (src_inode == dst_inode)
		goto out_fput;

		/* src file must be opened for reading */
		if (!(src_file.file->f_mode & FMODE_READ))
		goto out_fput;

		/* src and dst must be regular files */
		ret = -EISDIR;
		if (!S_ISREG(src_inode->i_mode) \|\| !S_ISREG(dst_inode->i_mode))
		goto out_fput;

		ret = -EXDEV;
		if (src_file.file->f_path.mnt != dst_file->f_path.mnt \|\|
		src_inode->i_sb != dst_inode->i_sb)
		goto out_fput;

		/* check alignment w.r.t. clone_blksize */
		ret = -EINVAL;
		if (bs) {
		if (!IS_ALIGNED(src_off, bs) \|\| !IS_ALIGNED(dst_off, bs))
		goto out_fput;
		if (!IS_ALIGNED(count, bs) && i_size_read(src_inode) != (src_off + count))
		goto out_fput;
		}

		/* XXX: do we lock at all? what if server needs CB_RECALL_LAYOUT? */
		if (dst_inode < src_inode) {
		mutex_lock_nested(&dst_inode->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_CHILD);
		} else {
		mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_PARENT);
		mutex_lock_nested(&dst_inode->i_mutex, I_MUTEX_CHILD);
		}

		/* flush all pending writes on both src and dst so that server
		* has the latest data */
		ret = nfs_sync_inode(src_inode);
		if (ret)
		goto out_unlock;
		ret = nfs_sync_inode(dst_inode);
		if (ret)
		goto out_unlock;

		ret = nfs42_proc_clone(src_file.file, dst_file, src_off, dst_off, count);

		/* truncate inode page cache of the dst range so that future reads can fetch
		* new data from server */
		if (!ret)
		truncate_inode_pages_range(&dst_inode->i_data, dst_off, dst_off + count - 1);

		out_unlock:
		if (dst_inode < src_inode) {
		mutex_unlock(&src_inode->i_mutex);
		mutex_unlock(&dst_inode->i_mutex);
		} else {
		mutex_unlock(&dst_inode->i_mutex);
		mutex_unlock(&src_inode->i_mutex);
		}
		out_fput:
		fdput(src_file);
		out_drop_write:
		mnt_drop_write_file(dst_file);
		return ret;
		}

		static long nfs42_ioctl_clone_range(struct file dst_file, void __user argp)
		{
		struct nfs_ioctl_clone_range_args args;

		if (copy_from_user(&args, argp, sizeof(args)))
		return -EFAULT;

		return nfs42_ioctl_clone(dst_file, args.src_fd, args.src_off, args.dst_off, args.count);
		}
		#else
		static long nfs42_ioctl_clone(struct file *dst_file, unsigned long srcfd,
		u64 src_off, u64 dst_off, u64 count)
		{
		return -ENOTTY;
		}

		static long nfs42_ioctl_clone_range(struct file dst_file, void __user argp)
		{
		return -ENOTTY;
		}
		#endif /* CONFIG_NFS_V4_2 */

		long nfs4_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
		{
		void __user argp = (void __user )arg;

		switch (cmd) {
		case NFS_IOC_CLONE:
		return nfs42_ioctl_clone(file, arg, 0, 0, 0);
		case NFS_IOC_CLONE_RANGE:
		return nfs42_ioctl_clone_range(file, argp);
		}

		return -ENOTTY;
		}

		const struct file_operations nfs4_file_operations = {
		#ifdef CONFIG_NFS_V4_2
		.llseek = nfs4_file_llseek,
		@@ -216,4 +347,9 @@ const struct file_operations nfs4_file_operations = {
		#endif /* CONFIG_NFS_V4_2 */
		.check_flags = nfs_check_flags,
		.setlease = simple_nosetlease,
		#ifdef CONFIG_COMPAT
		.unlocked_ioctl = nfs4_ioctl,
		#else
		.compat_ioctl = nfs4_ioctl,
		#endif /* CONFIG_COMPAT */
		};

Admin message