linux-stable-mirror/fs/lockd/svcproc.c

// SPDX-License-Identifier: GPL-2.0
/*
 * linux/fs/lockd/svcproc.c
 *
 * Lockd server procedures. We don't implement the NLM_*_RES 
 * procedures because we don't use the async procedures.
 *
 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
 */

#include <linux/types.h>
#include <linux/time.h>
#include <linux/sunrpc/svc_xprt.h>

#include "lockd.h"

/*
 * xdr.h defines SM_PRIV_SIZE as a macro. nlm3xdr_gen.h defines
 * it as an enum constant. Undefine the macro before including
 * the generated header.
 */
#undef SM_PRIV_SIZE

#include "share.h"
#include "nlm3xdr_gen.h"

/*
 * Size of an NFSv2 file handle, in bytes, which is 32.
 * Defined locally to avoid including uapi/linux/nfs2.h.
 */
#define NLM3_FHSIZE		32

/*
 * Wrapper structures combine xdrgen types with legacy lockd_lock.
 * The xdrgen field must be first so the structure can be cast
 * to its XDR type for the RPC dispatch layer.
 */
struct nlm_testargs_wrapper {
	struct nlm_testargs		xdrgen;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_testargs_wrapper, xdrgen) == 0);

struct nlm_testres_wrapper {
	struct nlm_testres		xdrgen;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_testres_wrapper, xdrgen) == 0);

struct nlm_lockargs_wrapper {
	struct nlm_lockargs		xdrgen;
	struct lockd_cookie		cookie;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_lockargs_wrapper, xdrgen) == 0);

struct nlm_res_wrapper {
	struct nlm_res			xdrgen;
	struct lockd_cookie		cookie;
};

static_assert(offsetof(struct nlm_res_wrapper, xdrgen) == 0);

struct nlm_cancargs_wrapper {
	struct nlm_cancargs		xdrgen;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_cancargs_wrapper, xdrgen) == 0);

struct nlm_unlockargs_wrapper {
	struct nlm_unlockargs		xdrgen;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_unlockargs_wrapper, xdrgen) == 0);

struct nlm_notifyargs_wrapper {
	struct nlm_notifyargs		xdrgen;
	struct lockd_reboot		reboot;
};

static_assert(offsetof(struct nlm_notifyargs_wrapper, xdrgen) == 0);

struct nlm_shareargs_wrapper {
	struct nlm_shareargs		xdrgen;
	struct lockd_lock		lock;
};

static_assert(offsetof(struct nlm_shareargs_wrapper, xdrgen) == 0);

struct nlm_shareres_wrapper {
	struct nlm_shareres		xdrgen;
};

static_assert(offsetof(struct nlm_shareres_wrapper, xdrgen) == 0);

struct nlm_notify_wrapper {
	struct nlm_notify		xdrgen;
};

static_assert(offsetof(struct nlm_notify_wrapper, xdrgen) == 0);

static __be32
nlm_netobj_to_cookie(struct lockd_cookie *cookie, netobj *object)
{
	if (object->len > NLM_MAXCOOKIELEN)
		return nlm_lck_denied_nolocks;
	cookie->len = object->len;
	memcpy(cookie->data, object->data, object->len);
	return nlm_granted;
}

static __be32
nlm_lock_to_lockd_lock(struct lockd_lock *lock, struct nlm_lock *alock)
{
	if (alock->fh.len != NLM3_FHSIZE)
		return nlm_lck_denied;
	lock->fh.size = alock->fh.len;
	memcpy(lock->fh.data, alock->fh.data, alock->fh.len);
	lock->oh.len = alock->oh.len;
	lock->oh.data = alock->oh.data;
	lock->svid = alock->uppid;
	lockd_set_file_lock_range3(&lock->fl, alock->l_offset, alock->l_len);
	return nlm_granted;
}

static struct nlm_host *
nlm3svc_lookup_host(struct svc_rqst *rqstp, string caller, bool monitored)
{
	struct nlm_host *host;

	if (!nlmsvc_ops)
		return NULL;
	host = nlmsvc_lookup_host(rqstp, caller.data, caller.len);
	if (!host)
		return NULL;
	if (monitored && nsm_monitor(host) < 0) {
		nlmsvc_release_host(host);
		return NULL;
	}
	return host;
}

static __be32
nlm3svc_lookup_file(struct svc_rqst *rqstp, struct nlm_host *host,
		    struct lockd_lock *lock, struct nlm_file **filp,
		    struct nlm_lock *xdr_lock, unsigned char type)
{
	bool is_test = (rqstp->rq_proc == NLMPROC_TEST ||
			rqstp->rq_proc == NLMPROC_TEST_MSG);
	struct file_lock *fl = &lock->fl;
	struct nlm_file *file = NULL;
	__be32 error;
	int mode;

	if (xdr_lock->fh.len != NLM3_FHSIZE)
		return nlm_lck_denied_nolocks;
	lock->fh.size = xdr_lock->fh.len;
	memcpy(lock->fh.data, xdr_lock->fh.data, xdr_lock->fh.len);

	lock->oh.len = xdr_lock->oh.len;
	lock->oh.data = xdr_lock->oh.data;

	lock->svid = xdr_lock->uppid;
	lock->lock_start = xdr_lock->l_offset;
	lock->lock_len = xdr_lock->l_len;

	locks_init_lock(fl);
	fl->c.flc_type = type;
	lockd_set_file_lock_range3(fl, lock->lock_start, lock->lock_len);

	mode = lock_to_openmode(fl);
	if (is_test)
		mode = O_RDWR;

	error = nlm_lookup_file(rqstp, &file, lock, mode);
	switch (error) {
	case nlm_granted:
		break;
	case nlm__int__stale_fh:
	case nlm__int__failed:
		return nlm_lck_denied_nolocks;
	default:
		return error;
	}
	*filp = file;

	fl->c.flc_flags = FL_POSIX;
	if (is_test)
		fl->c.flc_file = nlmsvc_file_file(file);
	else
		fl->c.flc_file = file->f_file[mode];
	fl->c.flc_pid = current->tgid;
	fl->fl_lmops = &nlmsvc_lock_operations;
	nlmsvc_locks_init_private(fl, host, (pid_t)lock->svid);
	if (!fl->c.flc_owner)
		return nlm_lck_denied_nolocks;

	return nlm_granted;
}

static inline __be32 cast_status(__be32 status)
{
	switch (status) {
	case nlm_granted:
	case nlm_lck_denied:
	case nlm_lck_denied_nolocks:
	case nlm_lck_blocked:
	case nlm_lck_denied_grace_period:
	case nlm__int__drop_reply:
		break;
	case nlm__int__deadlock:
		status = nlm_lck_denied;
		break;
	default:
		pr_warn_once("lockd: unhandled internal status %u\n",
			     be32_to_cpu(status));
		status = nlm_lck_denied_nolocks;
		break;
	}
	return status;
}

/**
 * nlmsvc_proc_null - NULL: Test for presence of service
 * @rqstp: RPC transaction context
 *
 * Return:
 *   %rpc_success:		RPC executed successfully
 *
 * RPC synopsis:
 *   void NLM_NULL(void) = 0;
 */
static __be32 nlmsvc_proc_null(struct svc_rqst *rqstp)
{
	return rpc_success;
}

/**
 * nlmsvc_proc_test - TEST: Check for conflicting lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_testres NLM_TEST(nlm_testargs) = 1;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The server would be able to grant the
 *				requested lock.
 *   %LCK_DENIED:		The requested lock conflicted with existing
 *				lock reservations for the file.
 *   %LCK_DENIED_NOLOCKS:	The server could not allocate the resources
 *				needed to process the request.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 */
static __be32 nlmsvc_proc_test(struct svc_rqst *rqstp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct nlm_testres_wrapper *resp = rqstp->rq_resp;
	struct nlm_file *file = NULL;
	struct nlm_host	*host;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.test_stat.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->xdrgen.test_stat.stat =
		nlm3svc_lookup_file(rqstp, host, &argp->lock, &file,
				    &argp->xdrgen.alock, type);
	if (resp->xdrgen.test_stat.stat)
		goto out;

	resp->xdrgen.test_stat.stat =
		cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock,
					    &resp->lock));
	nlmsvc_release_lockowner(&argp->lock);

	if (resp->xdrgen.test_stat.stat == nlm_lck_denied) {
		struct lockd_lock *conf = &resp->lock;
		struct nlm_holder *holder = &resp->xdrgen.test_stat.u.holder;

		holder->exclusive = (conf->fl.c.flc_type != F_RDLCK);
		holder->uppid = conf->svid;
		holder->oh.len = conf->oh.len;
		holder->oh.data = conf->oh.data;
		holder->l_offset = min_t(loff_t, conf->fl.fl_start,
					 NLM_OFFSET_MAX);
		if (conf->fl.fl_end == OFFSET_MAX)
			holder->l_len = 0;
		else
			holder->l_len = min_t(loff_t,
					      conf->fl.fl_end -
					      conf->fl.fl_start + 1,
					      NLM_OFFSET_MAX);
	}

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.test_stat.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

static __be32
nlmsvc_do_lock(struct svc_rqst *rqstp, bool monitored)
{
	struct nlm_lockargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct nlm_res_wrapper *resp = rqstp->rq_resp;
	struct nlm_file	*file = NULL;
	struct nlm_host	*host = NULL;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat.stat = nlm_netobj_to_cookie(&argp->cookie,
						      &argp->xdrgen.cookie);
	if (resp->xdrgen.stat.stat)
		goto out;

	resp->xdrgen.stat.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name,
				   monitored);
	if (!host)
		goto out;

	resp->xdrgen.stat.stat = nlm3svc_lookup_file(rqstp, host, &argp->lock,
						     &file, &argp->xdrgen.alock,
						     type);
	if (resp->xdrgen.stat.stat)
		goto out;

	resp->xdrgen.stat.stat = cast_status(nlmsvc_lock(rqstp, file, host,
							 &argp->lock,
							 argp->xdrgen.block,
							 &argp->cookie,
							 argp->xdrgen.reclaim));

	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.stat.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_lock - LOCK: Establish a monitored lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_res NLM_LOCK(nlm_lockargs) = 2;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The requested lock was granted.
 *   %LCK_DENIED:		The requested lock conflicted with existing
 *				lock reservations for the file.
 *   %LCK_DENIED_NOLOCKS:	The server could not allocate the resources
 *				needed to process the request.
 *   %LCK_BLOCKED:		The blocking request cannot be granted
 *				immediately. The server will send an
 *				NLM_GRANTED callback to the client when
 *				the lock can be granted.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 */
static __be32
nlmsvc_proc_lock(struct svc_rqst *rqstp)
{
	return nlmsvc_do_lock(rqstp, true);
}

/**
 * nlmsvc_proc_cancel - CANCEL: Cancel an outstanding blocked lock request
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_res NLM_CANCEL(nlm_cancargs) = 3;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The requested lock was canceled.
 *   %LCK_DENIED:		There was no lock to cancel.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 *
 * The Linux NLM server implementation also returns:
 *   %LCK_DENIED_NOLOCKS:	A needed resource could not be allocated.
 */
static __be32
nlmsvc_proc_cancel(struct svc_rqst *rqstp)
{
	struct nlm_cancargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct nlm_res_wrapper *resp = rqstp->rq_resp;
	struct net *net = SVC_NET(rqstp);
	struct nlm_host	*host = NULL;
	struct nlm_file	*file = NULL;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat.stat = nlm_lck_denied_grace_period;
	if (locks_in_grace(net))
		goto out;

	resp->xdrgen.stat.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->xdrgen.stat.stat = nlm3svc_lookup_file(rqstp, host, &argp->lock,
						     &file, &argp->xdrgen.alock,
						     type);
	if (resp->xdrgen.stat.stat)
		goto out;

	resp->xdrgen.stat.stat = nlmsvc_cancel_blocked(net, file, &argp->lock);
	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.stat.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_unlock - UNLOCK: Remove a lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_res NLM_UNLOCK(nlm_unlockargs) = 4;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The requested lock was released.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 *
 * The Linux NLM server implementation also returns:
 *   %LCK_DENIED_NOLOCKS:	A needed resource could not be allocated.
 */
static __be32
nlmsvc_proc_unlock(struct svc_rqst *rqstp)
{
	struct nlm_unlockargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_res_wrapper *resp = rqstp->rq_resp;
	struct net *net = SVC_NET(rqstp);
	struct nlm_host	*host = NULL;
	struct nlm_file	*file = NULL;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat.stat = nlm_lck_denied_grace_period;
	if (locks_in_grace(net))
		goto out;

	resp->xdrgen.stat.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->xdrgen.stat.stat = nlm3svc_lookup_file(rqstp, host, &argp->lock,
						     &file, &argp->xdrgen.alock,
						     F_UNLCK);
	if (resp->xdrgen.stat.stat)
		goto out;

	resp->xdrgen.stat.stat = nlmsvc_unlock(net, file, &argp->lock);
	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.stat.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_granted - GRANTED: Blocked lock has been granted
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *
 * RPC synopsis:
 *   nlm_res NLM_GRANTED(nlm_testargs) = 5;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The granted lock was accepted.
 *   %LCK_DENIED:		The procedure failed, possibly due to
 *				internal resource constraints.
 *   %LCK_DENIED_GRACE_PERIOD:	The client host recently restarted and
 *				its NLM is re-establishing existing locks,
 *				so it is not yet ready to accept callbacks.
 */
static __be32
nlmsvc_proc_granted(struct svc_rqst *rqstp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_res_wrapper *resp = rqstp->rq_resp;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat.stat = nlm_lock_to_lockd_lock(&argp->lock,
							&argp->xdrgen.alock);
	if (resp->xdrgen.stat.stat)
		goto out;

	resp->xdrgen.stat.stat = nlmclnt_grant(svc_addr(rqstp), &argp->lock);

out:
	return rpc_success;
}

/*
 * This is the generic lockd callback for async RPC calls
 */
static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
{
}

void nlmsvc_release_call(struct nlm_rqst *call)
{
	if (!refcount_dec_and_test(&call->a_count))
		return;
	nlmsvc_release_host(call->a_host);
	kfree(call);
}

static void nlmsvc_callback_release(void *data)
{
	nlmsvc_release_call(data);
}

static const struct rpc_call_ops nlmsvc_callback_ops = {
	.rpc_call_done = nlmsvc_callback_exit,
	.rpc_release = nlmsvc_callback_release,
};

/*
 * `Async' versions of the above service routines. They aren't really,
 * because we send the callback before the reply proper. I hope this
 * doesn't break any clients.
 */
static __be32
nlmsvc_callback(struct svc_rqst *rqstp, struct nlm_host *host, u32 proc,
		__be32 (*func)(struct svc_rqst *, struct lockd_res *))
{
	struct nlm_rqst	*call;
	__be32 stat;

	call = nlm_alloc_call(host);
	nlmsvc_release_host(host);
	if (call == NULL)
		return rpc_system_err;

	stat = func(rqstp, &call->a_res);
	if (stat != 0) {
		nlmsvc_release_call(call);
		return stat;
	}

	call->a_flags = RPC_TASK_ASYNC;
	if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
		return rpc_system_err;
	return rpc_success;
}

static __be32
__nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct lockd_res *resp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct nlm_lockowner *owner;
	struct nlm_file	*file = NULL;
	struct nlm_host	*host = NULL;

	resp->status = nlm_lck_denied_nolocks;
	if (nlm_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
		goto out;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->status = nlm3svc_lookup_file(rqstp, host, &argp->lock,
					   &file, &argp->xdrgen.alock, type);
	if (resp->status)
		goto out;

	owner = argp->lock.fl.c.flc_owner;
	resp->status = cast_status(nlmsvc_testlock(rqstp, file, host,
						   &argp->lock, &resp->lock));
	nlmsvc_put_lockowner(owner);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->status == nlm__int__drop_reply ? rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_test_msg - TEST_MSG: Check for conflicting lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *   %rpc_garbage_args:	The request arguments are malformed.
 *   %rpc_system_err:		RPC execution failed.
 *
 * RPC synopsis:
 *   void NLMPROC_TEST_MSG(nlm_testargs) = 6;
 *
 * The response to this request is delivered via the TEST_RES procedure.
 */
static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_host *host;

	if (argp->xdrgen.cookie.len > NLM_MAXCOOKIELEN)
		return rpc_garbage_args;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		return rpc_system_err;

	return nlmsvc_callback(rqstp, host, NLMPROC_TEST_RES,
			       __nlmsvc_proc_test_msg);
}

static __be32
__nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct lockd_res *resp)
{
	struct nlm_lockargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct nlm_file	*file = NULL;
	struct nlm_host	*host = NULL;

	resp->status = nlm_lck_denied_nolocks;
	if (nlm_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
		goto out;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, true);
	if (!host)
		goto out;

	resp->status = nlm3svc_lookup_file(rqstp, host, &argp->lock,
					   &file, &argp->xdrgen.alock, type);
	if (resp->status)
		goto out;

	resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
					       argp->xdrgen.block, &resp->cookie,
					       argp->xdrgen.reclaim));
	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->status == nlm__int__drop_reply ? rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_lock_msg - LOCK_MSG: Establish a monitored lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *   %rpc_garbage_args:	The request arguments are malformed.
 *   %rpc_system_err:		RPC execution failed.
 *
 * RPC synopsis:
 *   void NLMPROC_LOCK_MSG(nlm_lockargs) = 7;
 *
 * The response to this request is delivered via the LOCK_RES procedure.
 */
static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
{
	struct nlm_lockargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_host *host;

	if (argp->xdrgen.cookie.len > NLM_MAXCOOKIELEN)
		return rpc_garbage_args;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		return rpc_system_err;

	return nlmsvc_callback(rqstp, host, NLMPROC_LOCK_RES,
			       __nlmsvc_proc_lock_msg);
}

static __be32
__nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct lockd_res *resp)
{
	struct nlm_cancargs_wrapper *argp = rqstp->rq_argp;
	unsigned char type = argp->xdrgen.exclusive ? F_WRLCK : F_RDLCK;
	struct net *net = SVC_NET(rqstp);
	struct nlm_file	*file = NULL;
	struct nlm_host	*host = NULL;

	resp->status = nlm_lck_denied_nolocks;
	if (nlm_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
		goto out;

	resp->status = nlm_lck_denied_grace_period;
	if (locks_in_grace(net))
		goto out;

	resp->status = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->status = nlm3svc_lookup_file(rqstp, host, &argp->lock,
					   &file, &argp->xdrgen.alock, type);
	if (resp->status)
		goto out;

	resp->status = nlmsvc_cancel_blocked(net, file, &argp->lock);
	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->status == nlm__int__drop_reply ? rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_cancel_msg - CANCEL_MSG: Cancel an outstanding lock request
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *   %rpc_garbage_args:	The request arguments are malformed.
 *   %rpc_system_err:		RPC execution failed.
 *
 * RPC synopsis:
 *   void NLMPROC_CANCEL_MSG(nlm_cancargs) = 8;
 *
 * The response to this request is delivered via the CANCEL_RES procedure.
 */
static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
{
	struct nlm_cancargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_host *host;

	if (argp->xdrgen.cookie.len > NLM_MAXCOOKIELEN)
		return rpc_garbage_args;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		return rpc_system_err;

	return nlmsvc_callback(rqstp, host, NLMPROC_CANCEL_RES,
			       __nlmsvc_proc_cancel_msg);
}

static __be32
__nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct lockd_res *resp)
{
	struct nlm_unlockargs_wrapper *argp = rqstp->rq_argp;
	struct net *net = SVC_NET(rqstp);
	struct nlm_file	*file = NULL;
	struct nlm_host	*host = NULL;

	resp->status = nlm_lck_denied_nolocks;
	if (nlm_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
		goto out;

	resp->status = nlm_lck_denied_grace_period;
	if (locks_in_grace(net))
		goto out;

	resp->status = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		goto out;

	resp->status = nlm3svc_lookup_file(rqstp, host, &argp->lock,
					   &file, &argp->xdrgen.alock, F_UNLCK);
	if (resp->status)
		goto out;

	resp->status = nlmsvc_unlock(net, file, &argp->lock);
	nlmsvc_release_lockowner(&argp->lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->status == nlm__int__drop_reply ? rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_unlock_msg - UNLOCK_MSG: Remove an existing lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *   %rpc_garbage_args:	The request arguments are malformed.
 *   %rpc_system_err:		RPC execution failed.
 *
 * RPC synopsis:
 *   void NLMPROC_UNLOCK_MSG(nlm_unlockargs) = 9;
 *
 * The response to this request is delivered via the UNLOCK_RES procedure.
 */
static __be32 nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
{
	struct nlm_unlockargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_host *host;

	if (argp->xdrgen.cookie.len > NLM_MAXCOOKIELEN)
		return rpc_garbage_args;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.alock.caller_name, false);
	if (!host)
		return rpc_system_err;

	return nlmsvc_callback(rqstp, host, NLMPROC_UNLOCK_RES,
			       __nlmsvc_proc_unlock_msg);
}

static __be32
__nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct lockd_res *resp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;

	resp->status = nlm_lck_denied;
	if (nlm_netobj_to_cookie(&resp->cookie, &argp->xdrgen.cookie))
		goto out;

	if (nlm_lock_to_lockd_lock(&argp->lock, &argp->xdrgen.alock))
		goto out;

	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);

out:
	return rpc_success;
}

/**
 * nlmsvc_proc_granted_msg - GRANTED_MSG: Blocked lock has been granted
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_garbage_args:	The request arguments are malformed.
 *   %rpc_system_err:		RPC execution failed.
 *
 * RPC synopsis:
 *   void NLMPROC_GRANTED_MSG(nlm_testargs) = 10;
 *
 * The response to this request is delivered via the GRANTED_RES procedure.
 */
static __be32 nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
{
	struct nlm_testargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_host *host;

	if (argp->xdrgen.cookie.len > NLM_MAXCOOKIELEN)
		return rpc_garbage_args;

	host = nlmsvc_lookup_host(rqstp, argp->xdrgen.alock.caller_name.data,
				  argp->xdrgen.alock.caller_name.len);
	if (!host)
		return rpc_system_err;

	return nlmsvc_callback(rqstp, host, NLMPROC_GRANTED_RES,
			       __nlmsvc_proc_granted_msg);
}

/**
 * nlmsvc_proc_granted_res - GRANTED_RES: Lock Granted result
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *
 * RPC synopsis:
 *   void NLMPROC_GRANTED_RES(nlm_res) = 15;
 */
static __be32 nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
{
	struct nlm_res_wrapper *argp = rqstp->rq_argp;

	if (!nlmsvc_ops)
		return rpc_success;

	if (nlm_netobj_to_cookie(&argp->cookie, &argp->xdrgen.cookie))
		return rpc_success;
	nlmsvc_grant_reply(&argp->cookie, argp->xdrgen.stat.stat);

	return rpc_success;
}

/**
 * nlmsvc_proc_sm_notify - SM_NOTIFY: Peer has rebooted
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_system_err:		RPC execution failed.
 *
 * The SM_NOTIFY procedure is a private callback from Linux statd and is
 * not part of the official NLM protocol.
 *
 * RPC synopsis:
 *   void NLM_SM_NOTIFY(nlm_notifyargs) = 16;
 */
static __be32 nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
{
	struct nlm_notifyargs_wrapper *argp = rqstp->rq_argp;
	struct lockd_reboot *reboot = &argp->reboot;

	if (!nlm_privileged_requester(rqstp)) {
		char buf[RPC_MAX_ADDRBUFLEN];

		pr_warn("lockd: rejected NSM callback from %s\n",
			svc_print_addr(rqstp, buf, sizeof(buf)));
		return rpc_system_err;
	}

	reboot->len = argp->xdrgen.notify.name.len;
	reboot->mon = (char *)argp->xdrgen.notify.name.data;
	reboot->state = argp->xdrgen.notify.state;
	memcpy(&reboot->priv.data, argp->xdrgen.private,
	       sizeof(reboot->priv.data));

	nlm_host_rebooted(SVC_NET(rqstp), reboot);

	return rpc_success;
}

/**
 * nlmsvc_proc_unused - stub for unused procedures
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_proc_unavail:	Program can't support procedure.
 */
static __be32 nlmsvc_proc_unused(struct svc_rqst *rqstp)
{
	return rpc_proc_unavail;
}

/**
 * nlmsvc_proc_share - SHARE: Open a file using DOS file-sharing modes
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_shareres NLM_SHARE(nlm_shareargs) = 20;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The requested share lock was granted.
 *   %LCK_DENIED:		The requested lock conflicted with existing
 *				lock reservations for the file.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 *
 * The Linux NLM server implementation also returns:
 *   %LCK_DENIED_NOLOCKS:	A needed resource could not be allocated.
 */
static __be32 nlmsvc_proc_share(struct svc_rqst *rqstp)
{
	struct nlm_shareargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_shareres_wrapper *resp = rqstp->rq_resp;
	struct lockd_lock *lock = &argp->lock;
	struct nlm_host	*host = NULL;
	struct nlm_file	*file = NULL;
	struct nlm_lock xdr_lock = {
		.fh		= argp->xdrgen.share.fh,
		.oh		= argp->xdrgen.share.oh,
		.uppid		= LOCKD_SHARE_SVID,
	};

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat = nlm_lck_denied_grace_period;
	if (locks_in_grace(SVC_NET(rqstp)) && !argp->xdrgen.reclaim)
		goto out;

	resp->xdrgen.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.share.caller_name, false);
	if (!host)
		goto out;

	resp->xdrgen.stat = nlm3svc_lookup_file(rqstp, host, lock, &file,
						&xdr_lock, F_RDLCK);
	if (resp->xdrgen.stat)
		goto out;

	resp->xdrgen.stat = nlmsvc_share_file(host, file, &lock->oh,
					      argp->xdrgen.share.access,
					      argp->xdrgen.share.mode);

	nlmsvc_release_lockowner(lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_unshare - UNSHARE: Release a share reservation
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_shareres NLM_UNSHARE(nlm_shareargs) = 21;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The share reservation was released.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 *
 * The Linux NLM server implementation also returns:
 *   %LCK_DENIED_NOLOCKS:	A needed resource could not be allocated.
 */
static __be32 nlmsvc_proc_unshare(struct svc_rqst *rqstp)
{
	struct nlm_shareargs_wrapper *argp = rqstp->rq_argp;
	struct nlm_shareres_wrapper *resp = rqstp->rq_resp;
	struct lockd_lock *lock = &argp->lock;
	struct nlm_lock xdr_lock = {
		.fh		= argp->xdrgen.share.fh,
		.oh		= argp->xdrgen.share.oh,
		.uppid		= LOCKD_SHARE_SVID,
	};
	struct nlm_host	*host = NULL;
	struct nlm_file	*file = NULL;

	resp->xdrgen.cookie = argp->xdrgen.cookie;

	resp->xdrgen.stat = nlm_lck_denied_grace_period;
	if (locks_in_grace(SVC_NET(rqstp)))
		goto out;

	resp->xdrgen.stat = nlm_lck_denied_nolocks;
	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.share.caller_name, false);
	if (!host)
		goto out;

	resp->xdrgen.stat = nlm3svc_lookup_file(rqstp, host, lock, &file,
						&xdr_lock, F_RDLCK);
	if (resp->xdrgen.stat)
		goto out;

	resp->xdrgen.stat = nlmsvc_unshare_file(host, file, &lock->oh);

	nlmsvc_release_lockowner(lock);

out:
	if (file)
		nlm_release_file(file);
	nlmsvc_release_host(host);
	return resp->xdrgen.stat == nlm__int__drop_reply ?
		rpc_drop_reply : rpc_success;
}

/**
 * nlmsvc_proc_nm_lock - NM_LOCK: Establish a non-monitored lock
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *   %rpc_drop_reply:		Do not send an RPC reply.
 *
 * RPC synopsis:
 *   nlm_res NLM_NM_LOCK(nlm_lockargs) = 22;
 *
 * Permissible procedure status codes:
 *   %LCK_GRANTED:		The requested lock was granted.
 *   %LCK_DENIED:		The requested lock conflicted with existing
 *				lock reservations for the file.
 *   %LCK_DENIED_NOLOCKS:	The server could not allocate the resources
 *				needed to process the request.
 *   %LCK_BLOCKED:		The blocking request cannot be granted
 *				immediately. The server will send an
 *				NLM_GRANTED callback to the client when
 *				the lock can be granted.
 *   %LCK_DENIED_GRACE_PERIOD:	The server has recently restarted and is
 *				re-establishing existing locks, and is not
 *				yet ready to accept normal service requests.
 */
static __be32 nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
{
	return nlmsvc_do_lock(rqstp, false);
}

/**
 * nlmsvc_proc_free_all - FREE_ALL: Discard client's lock and share state
 * @rqstp: RPC transaction context
 *
 * Returns:
 *   %rpc_success:		RPC executed successfully.
 *
 * RPC synopsis:
 *   void NLMPROC_FREE_ALL(nlm_notify) = 23;
 */
static __be32 nlmsvc_proc_free_all(struct svc_rqst *rqstp)
{
	struct nlm_notify_wrapper *argp = rqstp->rq_argp;
	struct nlm_host	*host;

	host = nlm3svc_lookup_host(rqstp, argp->xdrgen.name, false);
	if (!host)
		goto out;

	nlmsvc_free_host_resources(host);

	nlmsvc_release_host(host);

out:
	return rpc_success;
}

/*
 * NLMv3 Server procedures.
 */

static const struct svc_procedure nlmsvc_procedures[24] = {
	[NLM_NULL] = {
		.pc_func	= nlmsvc_proc_null,
		.pc_decode	= nlm_svc_decode_void,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= XDR_void,
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "NULL",
	},
	[NLM_TEST] = {
		.pc_func	= nlmsvc_proc_test,
		.pc_decode	= nlm_svc_decode_nlm_testargs,
		.pc_encode	= nlm_svc_encode_nlm_testres,
		.pc_argsize	= sizeof(struct nlm_testargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_testres_wrapper),
		.pc_xdrressize	= NLM3_nlm_testres_sz,
		.pc_name	= "TEST",
	},
	[NLM_LOCK] = {
		.pc_func	= nlmsvc_proc_lock,
		.pc_decode	= nlm_svc_decode_nlm_lockargs,
		.pc_encode	= nlm_svc_encode_nlm_res,
		.pc_argsize	= sizeof(struct nlm_lockargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_res_wrapper),
		.pc_xdrressize	= NLM3_nlm_res_sz,
		.pc_name	= "LOCK",
	},
	[NLM_CANCEL] = {
		.pc_func	= nlmsvc_proc_cancel,
		.pc_decode	= nlm_svc_decode_nlm_cancargs,
		.pc_encode	= nlm_svc_encode_nlm_res,
		.pc_argsize	= sizeof(struct nlm_cancargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_res_wrapper),
		.pc_xdrressize	= NLM3_nlm_res_sz,
		.pc_name	= "CANCEL",
	},
	[NLM_UNLOCK] = {
		.pc_func	= nlmsvc_proc_unlock,
		.pc_decode	= nlm_svc_decode_nlm_unlockargs,
		.pc_encode	= nlm_svc_encode_nlm_res,
		.pc_argsize	= sizeof(struct nlm_unlockargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_res_wrapper),
		.pc_xdrressize	= NLM3_nlm_res_sz,
		.pc_name	= "UNLOCK",
	},
	[NLM_GRANTED] = {
		.pc_func	= nlmsvc_proc_granted,
		.pc_decode	= nlm_svc_decode_nlm_testargs,
		.pc_encode	= nlm_svc_encode_nlm_res,
		.pc_argsize	= sizeof(struct nlm_testargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_res_wrapper),
		.pc_xdrressize	= NLM3_nlm_res_sz,
		.pc_name	= "GRANTED",
	},
	[NLM_TEST_MSG] = {
		.pc_func	= nlmsvc_proc_test_msg,
		.pc_decode	= nlm_svc_decode_nlm_testargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_testargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "TEST_MSG",
	},
	[NLM_LOCK_MSG] = {
		.pc_func	= nlmsvc_proc_lock_msg,
		.pc_decode	= nlm_svc_decode_nlm_lockargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_lockargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "LOCK_MSG",
	},
	[NLM_CANCEL_MSG] = {
		.pc_func	= nlmsvc_proc_cancel_msg,
		.pc_decode	= nlm_svc_decode_nlm_cancargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_cancargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "CANCEL_MSG",
	},
	[NLM_UNLOCK_MSG] = {
		.pc_func	= nlmsvc_proc_unlock_msg,
		.pc_decode	= nlm_svc_decode_nlm_unlockargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_unlockargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "UNLOCK_MSG",
	},
	[NLM_GRANTED_MSG] = {
		.pc_func	= nlmsvc_proc_granted_msg,
		.pc_decode	= nlm_svc_decode_nlm_testargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_testargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "GRANTED_MSG",
	},
	[NLM_TEST_RES] = {
		.pc_func	= nlmsvc_proc_null,
		.pc_decode	= nlm_svc_decode_nlm_testres,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_testres),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "TEST_RES",
	},
	[NLM_LOCK_RES] = {
		.pc_func	= nlmsvc_proc_null,
		.pc_decode	= nlm_svc_decode_nlm_res,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_res),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "LOCK_RES",
	},
	[NLM_CANCEL_RES] = {
		.pc_func	= nlmsvc_proc_null,
		.pc_decode	= nlm_svc_decode_nlm_res,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_res),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "CANCEL_RES",
	},
	[NLM_UNLOCK_RES] = {
		.pc_func	= nlmsvc_proc_null,
		.pc_decode	= nlm_svc_decode_nlm_res,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_res),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "UNLOCK_RES",
	},
	[NLM_GRANTED_RES] = {
		.pc_func	= nlmsvc_proc_granted_res,
		.pc_decode	= nlm_svc_decode_nlm_res,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_res_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "GRANTED_RES",
	},
	[NLM_SM_NOTIFY] = {
		.pc_func	= nlmsvc_proc_sm_notify,
		.pc_decode	= nlm_svc_decode_nlm_notifyargs,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_notifyargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "SM_NOTIFY",
	},
	[17] = {
		.pc_func	= nlmsvc_proc_unused,
		.pc_decode	= nlm_svc_decode_void,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= 0,
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "UNUSED",
	},
	[18] = {
		.pc_func	= nlmsvc_proc_unused,
		.pc_decode	= nlm_svc_decode_void,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= 0,
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "UNUSED",
	},
	[19] = {
		.pc_func	= nlmsvc_proc_unused,
		.pc_decode	= nlm_svc_decode_void,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= 0,
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "UNUSED",
	},
	[NLM_SHARE] = {
		.pc_func	= nlmsvc_proc_share,
		.pc_decode	= nlm_svc_decode_nlm_shareargs,
		.pc_encode	= nlm_svc_encode_nlm_shareres,
		.pc_argsize	= sizeof(struct nlm_shareargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_shareres_wrapper),
		.pc_xdrressize	= NLM3_nlm_shareres_sz,
		.pc_name	= "SHARE",
	},
	[NLM_UNSHARE] = {
		.pc_func	= nlmsvc_proc_unshare,
		.pc_decode	= nlm_svc_decode_nlm_shareargs,
		.pc_encode	= nlm_svc_encode_nlm_shareres,
		.pc_argsize	= sizeof(struct nlm_shareargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_shareres_wrapper),
		.pc_xdrressize	= NLM3_nlm_shareres_sz,
		.pc_name	= "UNSHARE",
	},
	[NLM_NM_LOCK] = {
		.pc_func	= nlmsvc_proc_nm_lock,
		.pc_decode	= nlm_svc_decode_nlm_lockargs,
		.pc_encode	= nlm_svc_encode_nlm_res,
		.pc_argsize	= sizeof(struct nlm_lockargs_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= sizeof(struct nlm_res_wrapper),
		.pc_xdrressize	= NLM3_nlm_res_sz,
		.pc_name	= "NM_LOCK",
	},
	[NLM_FREE_ALL] = {
		.pc_func	= nlmsvc_proc_free_all,
		.pc_decode	= nlm_svc_decode_nlm_notify,
		.pc_encode	= nlm_svc_encode_void,
		.pc_argsize	= sizeof(struct nlm_notify_wrapper),
		.pc_argzero	= 0,
		.pc_ressize	= 0,
		.pc_xdrressize	= XDR_void,
		.pc_name	= "FREE_ALL",
	},
};

/*
 * Storage requirements for XDR arguments and results
 */
union nlmsvc_xdrstore {
	struct nlm_testargs_wrapper	testargs;
	struct nlm_lockargs_wrapper	lockargs;
	struct nlm_cancargs_wrapper	cancargs;
	struct nlm_unlockargs_wrapper	unlockargs;
	struct nlm_notifyargs_wrapper	notifyargs;
	struct nlm_shareargs_wrapper	shareargs;
	struct nlm_notify_wrapper	notify;
	struct nlm_testres_wrapper	testres;
	struct nlm_res_wrapper		res;
	struct nlm_shareres_wrapper	shareres;
};

/*
 * NLMv1 defines only procedures 1 - 15. Linux lockd also implements
 * procedures 0 (NULL) and 16 (SM_NOTIFY).
 */
static DEFINE_PER_CPU_ALIGNED(unsigned long, nlm1svc_call_counters[17]);

const struct svc_version nlmsvc_version1 = {
	.vs_vers	= 1,
	.vs_nproc	= 17,
	.vs_proc	= nlmsvc_procedures,
	.vs_count	= nlm1svc_call_counters,
	.vs_dispatch	= nlmsvc_dispatch,
	.vs_xdrsize	= sizeof(union nlmsvc_xdrstore),
};

static DEFINE_PER_CPU_ALIGNED(unsigned long,
			      nlm3svc_call_counters[ARRAY_SIZE(nlmsvc_procedures)]);

const struct svc_version nlmsvc_version3 = {
	.vs_vers	= 3,
	.vs_nproc	= ARRAY_SIZE(nlmsvc_procedures),
	.vs_proc	= nlmsvc_procedures,
	.vs_count	= nlm3svc_call_counters,
	.vs_dispatch	= nlmsvc_dispatch,
	.vs_xdrsize	= sizeof(union nlmsvc_xdrstore),
};