/* * linux/fs/lockd/clntproc.c * * RPC procedures for the client side NLM implementation * * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> */#include <linux/module.h>#include <linux/types.h>#include <linux/errno.h>#include <linux/fs.h>#include <linux/nfs_fs.h>#include <linux/utsname.h>#include <linux/freezer.h>#include <linux/sunrpc/clnt.h>#include <linux/sunrpc/svc.h>#include <linux/lockd/lockd.h>#define NLMDBG_FACILITY		NLMDBG_CLIENT#define NLMCLNT_GRACE_WAIT	(5*HZ)#define NLMCLNT_POLL_TIMEOUT	(30*HZ)#define NLMCLNT_MAX_RETRIES	3static int	nlmclnt_test(struct nlm_rqst *, struct file_lock *);static int	nlmclnt_lock(struct nlm_rqst *, struct file_lock *);static int	nlmclnt_unlock(struct nlm_rqst *, struct file_lock *);static int	nlm_stat_to_errno(__be32 stat);static void	nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host);static int	nlmclnt_cancel(struct nlm_host *, int , struct file_lock *);static const struct rpc_call_ops nlmclnt_unlock_ops;static const struct rpc_call_ops nlmclnt_cancel_ops;/* * Cookie counter for NLM requests */static atomic_t	nlm_cookie = ATOMIC_INIT(0x1234);void nlmclnt_next_cookie(struct nlm_cookie *c){	u32	cookie = atomic_inc_return(&nlm_cookie);	memcpy(c->data, &cookie, 4);	c->len=4;}static struct nlm_lockowner *nlm_get_lockowner(struct nlm_lockowner *lockowner){	atomic_inc(&lockowner->count);	return lockowner;}static void nlm_put_lockowner(struct nlm_lockowner *lockowner){	if (!atomic_dec_and_lock(&lockowner->count, &lockowner->host->h_lock))		return;	list_del(&lockowner->list);	spin_unlock(&lockowner->host->h_lock);	nlm_release_host(lockowner->host);	kfree(lockowner);}static inline int nlm_pidbusy(struct nlm_host *host, uint32_t pid){	struct nlm_lockowner *lockowner;	list_for_each_entry(lockowner, &host->h_lockowners, list) {		if (lockowner->pid == pid)			return -EBUSY;	}	return 0;}static inline uint32_t __nlm_alloc_pid(struct nlm_host *host){	uint32_t res;	do {		res = host->h_pidcount++;	} while (nlm_pidbusy(host, res) < 0);	return res;}static struct nlm_lockowner *__nlm_find_lockowner(struct nlm_host *host, fl_owner_t owner){	struct nlm_lockowner *lockowner;	list_for_each_entry(lockowner, &host->h_lockowners, list) {		if (lockowner->owner != owner)			continue;		return nlm_get_lockowner(lockowner);	}	return NULL;}static struct nlm_lockowner *nlm_find_lockowner(struct nlm_host *host, fl_owner_t owner){	struct nlm_lockowner *res, *new = NULL;	spin_lock(&host->h_lock);	res = __nlm_find_lockowner(host, owner);	if (res == NULL) {		spin_unlock(&host->h_lock);		new = kmalloc(sizeof(*new), GFP_KERNEL);		spin_lock(&host->h_lock);		res = __nlm_find_lockowner(host, owner);		if (res == NULL && new != NULL) {			res = new;			atomic_set(&new->count, 1);			new->owner = owner;			new->pid = __nlm_alloc_pid(host);			new->host = nlm_get_host(host);			list_add(&new->list, &host->h_lockowners);			new = NULL;		}	}	spin_unlock(&host->h_lock);	kfree(new);	return res;}/* * Initialize arguments for TEST/LOCK/UNLOCK/CANCEL calls */static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl){	struct nlm_args	*argp = &req->a_args;	struct nlm_lock	*lock = &argp->lock;	nlmclnt_next_cookie(&argp->cookie);	argp->state   = nsm_local_state;	memcpy(&lock->fh, NFS_FH(fl->fl_file->f_path.dentry->d_inode), sizeof(struct nfs_fh));	lock->caller  = utsname()->nodename;	lock->oh.data = req->a_owner;	lock->oh.len  = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",				(unsigned int)fl->fl_u.nfs_fl.owner->pid,				utsname()->nodename);	lock->svid = fl->fl_u.nfs_fl.owner->pid;	lock->fl.fl_start = fl->fl_start;	lock->fl.fl_end = fl->fl_end;	lock->fl.fl_type = fl->fl_type;}static void nlmclnt_release_lockargs(struct nlm_rqst *req){	BUG_ON(req->a_args.lock.fl.fl_ops != NULL);}/** * nlmclnt_proc - Perform a single client-side lock request * @host: address of a valid nlm_host context representing the NLM server * @cmd: fcntl-style file lock operation to perform * @fl: address of arguments for the lock operation * */int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl){	struct nlm_rqst		*call;	int			status;	nlm_get_host(host);	call = nlm_alloc_call(host);	if (call == NULL)		return -ENOMEM;	nlmclnt_locks_init_private(fl, host);	/* Set up the argument struct */	nlmclnt_setlockargs(call, fl);	if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {		if (fl->fl_type != F_UNLCK) {			call->a_args.block = IS_SETLKW(cmd) ? 1 : 0;			status = nlmclnt_lock(call, fl);		} else			status = nlmclnt_unlock(call, fl);	} else if (IS_GETLK(cmd))		status = nlmclnt_test(call, fl);	else		status = -EINVAL;	fl->fl_ops->fl_release_private(fl);	fl->fl_ops = NULL;	dprintk("lockd: clnt proc returns %d\n", status);	return status;}EXPORT_SYMBOL_GPL(nlmclnt_proc);/* * Allocate an NLM RPC call struct * * Note: the caller must hold a reference to host. In case of failure, * this reference will be released. */struct nlm_rqst *nlm_alloc_call(struct nlm_host *host){	struct nlm_rqst	*call;	for(;;) {		call = kzalloc(sizeof(*call), GFP_KERNEL);		if (call != NULL) {			atomic_set(&call->a_count, 1);			locks_init_lock(&call->a_args.lock.fl);			locks_init_lock(&call->a_res.lock.fl);			call->a_host = host;			return call;		}		if (signalled())			break;		printk("nlm_alloc_call: failed, waiting for memory\n");		schedule_timeout_interruptible(5*HZ);	}	nlm_release_host(host);	return NULL;}void nlm_release_call(struct nlm_rqst *call){	if (!atomic_dec_and_test(&call->a_count))		return;	nlm_release_host(call->a_host);	nlmclnt_release_lockargs(call);	kfree(call);}static void nlmclnt_rpc_release(void *data){	lock_kernel();	nlm_release_call(data);	unlock_kernel();}static int nlm_wait_on_grace(wait_queue_head_t *queue){	DEFINE_WAIT(wait);	int status = -EINTR;	prepare_to_wait(queue, &wait, TASK_INTERRUPTIBLE);	if (!signalled ()) {		schedule_timeout(NLMCLNT_GRACE_WAIT);		try_to_freeze();		if (!signalled ())			status = 0;	}	finish_wait(queue, &wait);	return status;}/* * Generic NLM call */static intnlmclnt_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc){	struct nlm_host	*host = req->a_host;	struct rpc_clnt	*clnt;	struct nlm_args	*argp = &req->a_args;	struct nlm_res	*resp = &req->a_res;	struct rpc_message msg = {		.rpc_argp	= argp,		.rpc_resp	= resp,		.rpc_cred	= cred,	};	int		status;	dprintk("lockd: call procedure %d on %s\n",			(int)proc, host->h_name);	do {		if (host->h_reclaiming && !argp->reclaim)			goto in_grace_period;		/* If we have no RPC client yet, create one. */		if ((clnt = nlm_bind_host(host)) == NULL)			return -ENOLCK;		msg.rpc_proc = &clnt->cl_procinfo[proc];		/* Perform the RPC call. If an error occurs, try again */		if ((status = rpc_call_sync(clnt, &msg, 0)) < 0) {			dprintk("lockd: rpc_call returned error %d\n", -status);			switch (status) {			case -EPROTONOSUPPORT:				status = -EINVAL;				break;			case -ECONNREFUSED:			case -ETIMEDOUT:			case -ENOTCONN:				nlm_rebind_host(host);				status = -EAGAIN;				break;			case -ERESTARTSYS:				return signalled () ? -EINTR : status;			default:				break;			}			break;		} else		if (resp->status == nlm_lck_denied_grace_period) {			dprintk("lockd: server in grace period\n");			if (argp->reclaim) {				printk(KERN_WARNING				     "lockd: spurious grace period reject?!\n");				return -ENOLCK;			}		} else {			if (!argp->reclaim) {				/* We appear to be out of the grace period */				wake_up_all(&host->h_gracewait);			}			dprintk("lockd: server returns status %d\n", resp->status);			return 0;	/* Okay, call complete */		}in_grace_period:		/*		 * The server has rebooted and appears to be in the grace		 * period during which locks are only allowed to be		 * reclaimed.		 * We can only back off and try again later.		 */		status = nlm_wait_on_grace(&host->h_gracewait);	} while (status == 0);	return status;}/* * Generic NLM call, async version. */static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops){	struct nlm_host	*host = req->a_host;	struct rpc_clnt	*clnt;	struct rpc_task_setup task_setup_data = {		.rpc_message = msg,		.callback_ops = tk_ops,		.callback_data = req,		.flags = RPC_TASK_ASYNC,	};	dprintk("lockd: call procedure %d on %s (async)\n",			(int)proc, host->h_name);	/* If we have no RPC client yet, create one. */	clnt = nlm_bind_host(host);	if (clnt == NULL)		goto out_err;	msg->rpc_proc = &clnt->cl_procinfo[proc];	task_setup_data.rpc_client = clnt;        /* bootstrap and kick off the async RPC call */	return rpc_run_task(&task_setup_data);out_err:	tk_ops->rpc_release(req);	return ERR_PTR(-ENOLCK);}static int nlm_do_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops){	struct rpc_task *task;	task = __nlm_async_call(req, proc, msg, tk_ops);	if (IS_ERR(task))		return PTR_ERR(task);	rpc_put_task(task);	return 0;}/* * NLM asynchronous call. */int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops){	struct rpc_message msg = {		.rpc_argp	= &req->a_args,		.rpc_resp	= &req->a_res,	};	return nlm_do_async_call(req, proc, &msg, tk_ops);}int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops){	struct rpc_message msg = {		.rpc_argp	= &req->a_res,	};	return nlm_do_async_call(req, proc, &msg, tk_ops);}/* * NLM client asynchronous call. * * Note that although the calls are asynchronous, and are therefore *      guaranteed to complete, we still always attempt to wait for *      completion in order to be able to correctly track the lock *      state. */static int nlmclnt_async_call(struct rpc_cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops){	struct rpc_message msg = {		.rpc_argp	= &req->a_args,		.rpc_resp	= &req->a_res,		.rpc_cred	= cred,	};	struct rpc_task *task;	int err;	task = __nlm_async_call(req, proc, &msg, tk_ops);	if (IS_ERR(task))		return PTR_ERR(task);	err = rpc_wait_for_completion_task(task);	rpc_put_task(task);	return err;}/* * TEST for the presence of a conflicting lock */static intnlmclnt_test(struct nlm_rqst *req, struct file_lock *fl){	int	status;	status = nlmclnt_call(nfs_file_cred(fl->fl_file), req, NLMPROC_TEST);	if (status < 0)		goto out;