[deliverable/linux.git] / fs / nfs / nfs42proc.c

/*
 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
 */
#include <linux/fs.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"

static int nfs42_set_rw_stateid(nfs4_stateid *dst, struct file *file,
				fmode_t fmode)
{
	struct nfs_open_context *open;
	struct nfs_lock_context *lock;
	int ret;

	open = get_nfs_open_context(nfs_file_open_context(file));
	lock = nfs_get_lock_context(open);
	if (IS_ERR(lock)) {
		put_nfs_open_context(open);
		return PTR_ERR(lock);
	}

	ret = nfs4_set_rw_stateid(dst, open, lock, fmode);

	nfs_put_lock_context(lock);
	put_nfs_open_context(open);
	return ret;
}

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 nfs42_falloc_args args = {
		.falloc_fh	= NFS_FH(inode),
		.falloc_offset	= offset,
		.falloc_length	= len,
	};
	struct nfs42_falloc_res res;
	struct nfs_server *server = NFS_SERVER(inode);
	int status;

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

	status = nfs42_set_rw_stateid(&args.falloc_stateid, filep, FMODE_WRITE);
	if (status)
		return status;

	return nfs4_call_sync(server->client, server, msg,
			      &args.seq_args, &res.seq_res, 0);
}

static int nfs42_proc_fallocate(struct rpc_message *msg, struct file *filep,
				loff_t offset, loff_t len)
{
	struct nfs_server *server = NFS_SERVER(file_inode(filep));
	struct nfs4_exception exception = { };
	int err;

	do {
		err = _nfs42_proc_fallocate(msg, filep, offset, len);
		if (err == -ENOTSUPP)
			return -EOPNOTSUPP;
		err = nfs4_handle_exception(server, err, &exception);
	} while (exception.retry);

	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;

	err = nfs42_proc_fallocate(&msg, filep, offset, len);
	if (err == -EOPNOTSUPP)
		NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
	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;

	err = nfs42_proc_fallocate(&msg, filep, offset, len);
	if (err == -EOPNOTSUPP)
		NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
	return err;
}

loff_t nfs42_proc_llseek(struct file *filep, 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 = nfs42_set_rw_stateid(&args.sa_stateid, filep, FMODE_READ);
	if (status)
		return status;

	nfs_wb_all(inode);
	status = nfs4_call_sync(server->client, server, &msg,
				&args.seq_args, &res.seq_res, 0);
	if (status == -ENOTSUPP)
		server->caps &= ~NFS_CAP_SEEK;
	if (status)
		return status;

	return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
}
Commit	Line	Data
1c6dcbe5 AS	1	/*
	2	* Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
	3	*/
	4	#include <linux/fs.h>
	5	#include <linux/sunrpc/sched.h>
	6	#include <linux/nfs.h>
	7	#include <linux/nfs3.h>
	8	#include <linux/nfs4.h>
	9	#include <linux/nfs_xdr.h>
	10	#include <linux/nfs_fs.h>
	11	#include "nfs4_fs.h"
	12	#include "nfs42.h"
	13
	14	static int nfs42_set_rw_stateid(nfs4_stateid dst, struct file file,
	15	fmode_t fmode)
	16	{
	17	struct nfs_open_context *open;
	18	struct nfs_lock_context *lock;
	19	int ret;
	20
	21	open = get_nfs_open_context(nfs_file_open_context(file));
	22	lock = nfs_get_lock_context(open);
	23	if (IS_ERR(lock)) {
	24	put_nfs_open_context(open);
	25	return PTR_ERR(lock);
	26	}
	27
	28	ret = nfs4_set_rw_stateid(dst, open, lock, fmode);
	29
	30	nfs_put_lock_context(lock);
	31	put_nfs_open_context(open);
	32	return ret;
	33	}
	34
f4ac1674 AS	35	static int _nfs42_proc_fallocate(struct rpc_message msg, struct file filep,
	36	loff_t offset, loff_t len)
	37	{
	38	struct inode *inode = file_inode(filep);
	39	struct nfs42_falloc_args args = {
	40	.falloc_fh = NFS_FH(inode),
	41	.falloc_offset = offset,
	42	.falloc_length = len,
	43	};
	44	struct nfs42_falloc_res res;
	45	struct nfs_server *server = NFS_SERVER(inode);
	46	int status;
	47
	48	msg->rpc_argp = &args;
	49	msg->rpc_resp = &res;
	50
	51	status = nfs42_set_rw_stateid(&args.falloc_stateid, filep, FMODE_WRITE);
	52	if (status)
	53	return status;
	54
	55	return nfs4_call_sync(server->client, server, msg,
	56	&args.seq_args, &res.seq_res, 0);
	57	}
	58
	59	static int nfs42_proc_fallocate(struct rpc_message msg, struct file filep,
	60	loff_t offset, loff_t len)
	61	{
	62	struct nfs_server *server = NFS_SERVER(file_inode(filep));
	63	struct nfs4_exception exception = { };
	64	int err;
	65
	66	do {
	67	err = _nfs42_proc_fallocate(msg, filep, offset, len);
	68	if (err == -ENOTSUPP)
	69	return -EOPNOTSUPP;
	70	err = nfs4_handle_exception(server, err, &exception);
	71	} while (exception.retry);
	72
	73	return err;
	74	}
	75
	76	int nfs42_proc_allocate(struct file *filep, loff_t offset, loff_t len)
	77	{
	78	struct rpc_message msg = {
	79	.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ALLOCATE],
	80	};
	81	struct inode *inode = file_inode(filep);
	82	int err;
	83
	84	if (!nfs_server_capable(inode, NFS_CAP_ALLOCATE))
	85	return -EOPNOTSUPP;
	86
	87	err = nfs42_proc_fallocate(&msg, filep, offset, len);
	88	if (err == -EOPNOTSUPP)
	89	NFS_SERVER(inode)->caps &= ~NFS_CAP_ALLOCATE;
	90	return err;
	91	}
	92
624bd5b7 AS	93	int nfs42_proc_deallocate(struct file *filep, loff_t offset, loff_t len)
	94	{
	95	struct rpc_message msg = {
	96	.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DEALLOCATE],
	97	};
	98	struct inode *inode = file_inode(filep);
	99	int err;
	100
	101	if (!nfs_server_capable(inode, NFS_CAP_DEALLOCATE))
	102	return -EOPNOTSUPP;
	103
	104	err = nfs42_proc_fallocate(&msg, filep, offset, len);
	105	if (err == -EOPNOTSUPP)
	106	NFS_SERVER(inode)->caps &= ~NFS_CAP_DEALLOCATE;
	107	return err;
	108	}
	109
1c6dcbe5 AS	110	loff_t nfs42_proc_llseek(struct file *filep, loff_t offset, int whence)
	111	{
	112	struct inode *inode = file_inode(filep);
	113	struct nfs42_seek_args args = {
	114	.sa_fh = NFS_FH(inode),
	115	.sa_offset = offset,
	116	.sa_what = (whence == SEEK_HOLE) ?
	117	NFS4_CONTENT_HOLE : NFS4_CONTENT_DATA,
	118	};
	119	struct nfs42_seek_res res;
	120	struct rpc_message msg = {
	121	.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEEK],
	122	.rpc_argp = &args,
	123	.rpc_resp = &res,
	124	};
	125	struct nfs_server *server = NFS_SERVER(inode);
	126	int status;
	127
878ffa9f	128	if (!nfs_server_capable(inode, NFS_CAP_SEEK))
1c6dcbe5 AS	129	return -ENOTSUPP;
	130
	131	status = nfs42_set_rw_stateid(&args.sa_stateid, filep, FMODE_READ);
	132	if (status)
	133	return status;
	134
	135	nfs_wb_all(inode);
	136	status = nfs4_call_sync(server->client, server, &msg,
	137	&args.seq_args, &res.seq_res, 0);
	138	if (status == -ENOTSUPP)
	139	server->caps &= ~NFS_CAP_SEEK;
	140	if (status)
	141	return status;
	142
	143	return vfs_setpos(filep, res.sr_offset, inode->i_sb->s_maxbytes);
	144	}