Merge git://git.linux-nfs.org/pub/linux/nfs-2.6 (53846a21) · Commits · 戴 / test

fs/Kconfig

+1 −0

Original line number	Diff line number	Diff line
		@@ -1555,6 +1555,7 @@ config RPCSEC_GSS_SPKM3
		select CRYPTO
		select CRYPTO_MD5
		select CRYPTO_DES
		select CRYPTO_CAST5
		help
		Provides for secure RPC calls by means of a gss-api
		mechanism based on the SPKM3 public-key mechanism.

fs/lockd/clntlock.c

+37 −75

Original line number	Diff line number	Diff line
		@@ -44,32 +44,25 @@ static LIST_HEAD(nlm_blocked);
		/*
		* Queue up a lock for blocking so that the GRANTED request can see it
		*/
		int nlmclnt_prepare_block(struct nlm_rqst req, struct nlm_host host, struct file_lock *fl)
		struct nlm_wait nlmclnt_prepare_block(struct nlm_host host, struct file_lock *fl)
		{
		struct nlm_wait *block;

		BUG_ON(req->a_block != NULL);
		block = kmalloc(sizeof(*block), GFP_KERNEL);
		if (block == NULL)
		return -ENOMEM;
		if (block != NULL) {
		block->b_host = host;
		block->b_lock = fl;
		init_waitqueue_head(&block->b_wait);
		block->b_status = NLM_LCK_BLOCKED;

		list_add(&block->b_list, &nlm_blocked);
		req->a_block = block;

		return 0;
		}
		return block;
		}

		void nlmclnt_finish_block(struct nlm_rqst *req)
		void nlmclnt_finish_block(struct nlm_wait *block)
		{
		struct nlm_wait *block = req->a_block;

		if (block == NULL)
		return;
		req->a_block = NULL;
		list_del(&block->b_list);
		kfree(block);
		}
		@@ -77,15 +70,14 @@ void nlmclnt_finish_block(struct nlm_rqst *req)
		/*
		* Block on a lock
		*/
		long nlmclnt_block(struct nlm_rqst *req, long timeout)
		int nlmclnt_block(struct nlm_wait block, struct nlm_rqst req, long timeout)
		{
		struct nlm_wait *block = req->a_block;
		long ret;

		/* A borken server might ask us to block even if we didn't
		* request it. Just say no!
		*/
		if (!req->a_args.block)
		if (block == NULL)
		return -EAGAIN;

		/* Go to sleep waiting for GRANT callback. Some servers seem
		@@ -99,13 +91,10 @@ long nlmclnt_block(struct nlm_rqst *req, long timeout)
		ret = wait_event_interruptible_timeout(block->b_wait,
		block->b_status != NLM_LCK_BLOCKED,
		timeout);

		if (block->b_status != NLM_LCK_BLOCKED) {
		if (ret < 0)
		return -ERESTARTSYS;
		req->a_res.status = block->b_status;
		block->b_status = NLM_LCK_BLOCKED;
		}

		return ret;
		return 0;
		}

		/*
		@@ -125,7 +114,15 @@ u32 nlmclnt_grant(const struct sockaddr_in addr, const struct nlm_lock lock)
		list_for_each_entry(block, &nlm_blocked, b_list) {
		struct file_lock *fl_blocked = block->b_lock;

		if (!nlm_compare_locks(fl_blocked, fl))
		if (fl_blocked->fl_start != fl->fl_start)
		continue;
		if (fl_blocked->fl_end != fl->fl_end)
		continue;
		/*
		* Careful! The NLM server will return the 32-bit "pid" that
		* we put on the wire: in this case the lockowner "pid".
		*/
		if (fl_blocked->fl_u.nfs_fl.owner->pid != lock->svid)
		continue;
		if (!nlm_cmp_addr(&block->b_host->h_addr, addr))
		continue;
		@@ -146,34 +143,6 @@ u32 nlmclnt_grant(const struct sockaddr_in addr, const struct nlm_lock lock)
		* server crash.
		*/

		/*
		* Mark the locks for reclaiming.
		* FIXME: In 2.5 we don't want to iterate through any global file_lock_list.
		* Maintain NLM lock reclaiming lists in the nlm_host instead.
		*/
		static
		void nlmclnt_mark_reclaim(struct nlm_host *host)
		{
		struct file_lock *fl;
		struct inode *inode;
		struct list_head *tmp;

		list_for_each(tmp, &file_lock_list) {
		fl = list_entry(tmp, struct file_lock, fl_link);

		inode = fl->fl_file->f_dentry->d_inode;
		if (inode->i_sb->s_magic != NFS_SUPER_MAGIC)
		continue;
		if (fl->fl_u.nfs_fl.owner == NULL)
		continue;
		if (fl->fl_u.nfs_fl.owner->host != host)
		continue;
		if (!(fl->fl_u.nfs_fl.flags & NFS_LCK_GRANTED))
		continue;
		fl->fl_u.nfs_fl.flags \|= NFS_LCK_RECLAIM;
		}
		}

		/*
		* Someone has sent us an SM_NOTIFY. Ensure we bind to the new port number,
		* that we mark locks for reclaiming, and that we bump the pseudo NSM state.
		@@ -186,7 +155,12 @@ void nlmclnt_prepare_reclaim(struct nlm_host *host, u32 newstate)
		host->h_state++;
		host->h_nextrebind = 0;
		nlm_rebind_host(host);
		nlmclnt_mark_reclaim(host);

		/*
		* Mark the locks for reclaiming.
		*/
		list_splice_init(&host->h_granted, &host->h_reclaim);

		dprintk("NLM: reclaiming locks for host %s", host->h_name);
		}

		@@ -215,9 +189,7 @@ reclaimer(void *ptr)
		{
		struct nlm_host host = (struct nlm_host ) ptr;
		struct nlm_wait *block;
		struct list_head *tmp;
		struct file_lock *fl;
		struct inode *inode;
		struct file_lock fl, next;

		daemonize("%s-reclaim", host->h_name);
		allow_signal(SIGKILL);
		@@ -229,23 +201,13 @@ reclaimer(void *ptr)

		/* First, reclaim all locks that have been marked. */
		restart:
		list_for_each(tmp, &file_lock_list) {
		fl = list_entry(tmp, struct file_lock, fl_link);

		inode = fl->fl_file->f_dentry->d_inode;
		if (inode->i_sb->s_magic != NFS_SUPER_MAGIC)
		continue;
		if (fl->fl_u.nfs_fl.owner == NULL)
		continue;
		if (fl->fl_u.nfs_fl.owner->host != host)
		continue;
		if (!(fl->fl_u.nfs_fl.flags & NFS_LCK_RECLAIM))
		continue;
		list_for_each_entry_safe(fl, next, &host->h_reclaim, fl_u.nfs_fl.list) {
		list_del_init(&fl->fl_u.nfs_fl.list);

		fl->fl_u.nfs_fl.flags &= ~NFS_LCK_RECLAIM;
		nlmclnt_reclaim(host, fl);
		if (signalled())
		break;
		continue;
		if (nlmclnt_reclaim(host, fl) == 0)
		list_add_tail(&fl->fl_u.nfs_fl.list, &host->h_granted);
		goto restart;
		}

fs/lockd/clntproc.c

+119 −198

Original line number	Diff line number	Diff line
		@@ -132,59 +132,18 @@ static void nlmclnt_setlockargs(struct nlm_rqst req, struct file_lock fl)
		memcpy(&lock->fh, NFS_FH(fl->fl_file->f_dentry->d_inode), sizeof(struct nfs_fh));
		lock->caller = system_utsname.nodename;
		lock->oh.data = req->a_owner;
		lock->oh.len = sprintf(req->a_owner, "%d@%s",
		current->pid, system_utsname.nodename);
		locks_copy_lock(&lock->fl, fl);
		lock->oh.len = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",
		(unsigned int)fl->fl_u.nfs_fl.owner->pid,
		system_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)
		{
		struct file_lock *fl = &req->a_args.lock.fl;

		if (fl->fl_ops && fl->fl_ops->fl_release_private)
		fl->fl_ops->fl_release_private(fl);
		}

		/*
		* Initialize arguments for GRANTED call. The nlm_rqst structure
		* has been cleared already.
		*/
		int
		nlmclnt_setgrantargs(struct nlm_rqst call, struct nlm_lock lock)
		{
		locks_copy_lock(&call->a_args.lock.fl, &lock->fl);
		memcpy(&call->a_args.lock.fh, &lock->fh, sizeof(call->a_args.lock.fh));
		call->a_args.lock.caller = system_utsname.nodename;
		call->a_args.lock.oh.len = lock->oh.len;

		/* set default data area */
		call->a_args.lock.oh.data = call->a_owner;

		if (lock->oh.len > NLMCLNT_OHSIZE) {
		void *data = kmalloc(lock->oh.len, GFP_KERNEL);
		if (!data) {
		nlmclnt_freegrantargs(call);
		return 0;
		}
		call->a_args.lock.oh.data = (u8 *) data;
		}

		memcpy(call->a_args.lock.oh.data, lock->oh.data, lock->oh.len);
		return 1;
		}

		void
		nlmclnt_freegrantargs(struct nlm_rqst *call)
		{
		struct file_lock *fl = &call->a_args.lock.fl;
		/*
		* Check whether we allocated memory for the owner.
		*/
		if (call->a_args.lock.oh.data != (u8 *) call->a_owner) {
		kfree(call->a_args.lock.oh.data);
		}
		if (fl->fl_ops && fl->fl_ops->fl_release_private)
		fl->fl_ops->fl_release_private(fl);
		BUG_ON(req->a_args.lock.fl.fl_ops != NULL);
		}

		/*
		@@ -193,9 +152,8 @@ nlmclnt_freegrantargs(struct nlm_rqst *call)
		int
		nlmclnt_proc(struct inode inode, int cmd, struct file_lock fl)
		{
		struct nfs_server *nfssrv = NFS_SERVER(inode);
		struct nlm_host *host;
		struct nlm_rqst reqst, *call = &reqst;
		struct nlm_rqst *call;
		sigset_t oldset;
		unsigned long flags;
		int status, proto, vers;
		@@ -209,23 +167,17 @@ nlmclnt_proc(struct inode inode, int cmd, struct file_lock fl)
		/* Retrieve transport protocol from NFS client */
		proto = NFS_CLIENT(inode)->cl_xprt->prot;

		if (!(host = nlmclnt_lookup_host(NFS_ADDR(inode), proto, vers)))
		host = nlmclnt_lookup_host(NFS_ADDR(inode), proto, vers);
		if (host == NULL)
		return -ENOLCK;

		/* Create RPC client handle if not there, and copy soft
		* and intr flags from NFS client. */
		if (host->h_rpcclnt == NULL) {
		struct rpc_clnt *clnt;
		call = nlm_alloc_call(host);
		if (call == NULL)
		return -ENOMEM;

		/* Bind an rpc client to this host handle (does not
		* perform a portmapper lookup) */
		if (!(clnt = nlm_bind_host(host))) {
		status = -ENOLCK;
		goto done;
		}
		clnt->cl_softrtry = nfssrv->client->cl_softrtry;
		clnt->cl_intr = nfssrv->client->cl_intr;
		}
		nlmclnt_locks_init_private(fl, host);
		/* Set up the argument struct */
		nlmclnt_setlockargs(call, fl);

		/* Keep the old signal mask */
		spin_lock_irqsave(&current->sighand->siglock, flags);
		@@ -238,26 +190,10 @@ nlmclnt_proc(struct inode inode, int cmd, struct file_lock fl)
		&& (current->flags & PF_EXITING)) {
		sigfillset(&current->blocked); /* Mask all signals */
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);

		call = nlmclnt_alloc_call();
		if (!call) {
		status = -ENOMEM;
		goto out_restore;
		}
		call->a_flags = RPC_TASK_ASYNC;
		} else {
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
		memset(call, 0, sizeof(*call));
		locks_init_lock(&call->a_args.lock.fl);
		locks_init_lock(&call->a_res.lock.fl);
		}
		call->a_host = host;

		nlmclnt_locks_init_private(fl, host);

		/* Set up the argument struct */
		nlmclnt_setlockargs(call, fl);
		spin_unlock_irqrestore(&current->sighand->siglock, flags);

		if (IS_SETLK(cmd) \|\| IS_SETLKW(cmd)) {
		if (fl->fl_type != F_UNLCK) {
		@@ -270,41 +206,58 @@ nlmclnt_proc(struct inode inode, int cmd, struct file_lock fl)
		else
		status = -EINVAL;

		out_restore:
		fl->fl_ops->fl_release_private(fl);
		fl->fl_ops = NULL;

		spin_lock_irqsave(&current->sighand->siglock, flags);
		current->blocked = oldset;
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);

		done:
		dprintk("lockd: clnt proc returns %d\n", status);
		nlm_release_host(host);
		return status;
		}
		EXPORT_SYMBOL(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 *
		nlmclnt_alloc_call(void)
		struct nlm_rqst nlm_alloc_call(struct nlm_host host)
		{
		struct nlm_rqst *call;

		while (!signalled()) {
		call = (struct nlm_rqst *) kmalloc(sizeof(struct nlm_rqst), GFP_KERNEL);
		if (call) {
		memset(call, 0, sizeof(*call));
		for(;;) {
		call = kzalloc(sizeof(*call), GFP_KERNEL);
		if (call != NULL) {
		locks_init_lock(&call->a_args.lock.fl);
		locks_init_lock(&call->a_res.lock.fl);
		call->a_host = host;
		return call;
		}
		printk("nlmclnt_alloc_call: failed, waiting for memory\n");
		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)
		{
		nlm_release_host(call->a_host);
		nlmclnt_release_lockargs(call);
		kfree(call);
		}

		static void nlmclnt_rpc_release(void *data)
		{
		return nlm_release_call(data);
		}

		static int nlm_wait_on_grace(wait_queue_head_t *queue)
		{
		DEFINE_WAIT(wait);
		@@ -401,57 +354,45 @@ in_grace_period:
		/*
		* Generic NLM call, async version.
		*/
		int nlmsvc_async_call(struct nlm_rqst req, u32 proc, const struct rpc_call_ops tk_ops)
		static int __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_message msg = {
		.rpc_argp = &req->a_args,
		.rpc_resp = &req->a_res,
		};
		int status;
		int status = -ENOLCK;

		dprintk("lockd: call procedure %d on %s (async)\n",
		(int)proc, host->h_name);

		/* 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];
		clnt = nlm_bind_host(host);
		if (clnt == NULL)
		goto out_err;
		msg->rpc_proc = &clnt->cl_procinfo[proc];

		/* bootstrap and kick off the async RPC call */
		status = rpc_call_async(clnt, &msg, RPC_TASK_ASYNC, tk_ops, req);

		status = rpc_call_async(clnt, msg, RPC_TASK_ASYNC, tk_ops, req);
		if (status == 0)
		return 0;
		out_err:
		nlm_release_call(req);
		return status;
		}

		static int nlmclnt_async_call(struct nlm_rqst req, u32 proc, const struct rpc_call_ops tk_ops)
		int nlm_async_call(struct nlm_rqst req, u32 proc, const struct rpc_call_ops tk_ops)
		{
		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_argp = &req->a_args,
		.rpc_resp = &req->a_res,
		};
		int status;

		dprintk("lockd: call procedure %d on %s (async)\n",
		(int)proc, host->h_name);

		/* 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];
		return __nlm_async_call(req, proc, &msg, tk_ops);
		}

		/* Increment host refcount */
		nlm_get_host(host);
		/* bootstrap and kick off the async RPC call */
		status = rpc_call_async(clnt, &msg, RPC_TASK_ASYNC, tk_ops, req);
		if (status < 0)
		nlm_release_host(host);
		return status;
		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_async_call(req, proc, &msg, tk_ops);
		}

		/*
		@@ -463,36 +404,41 @@ nlmclnt_test(struct nlm_rqst req, struct file_lock fl)
		int status;

		status = nlmclnt_call(req, NLMPROC_TEST);
		nlmclnt_release_lockargs(req);
		if (status < 0)
		return status;
		goto out;

		status = req->a_res.status;
		if (status == NLM_LCK_GRANTED) {
		switch (req->a_res.status) {
		case NLM_LCK_GRANTED:
		fl->fl_type = F_UNLCK;
		} if (status == NLM_LCK_DENIED) {
		break;
		case NLM_LCK_DENIED:
		/*
		* Report the conflicting lock back to the application.
		*/
		locks_copy_lock(fl, &req->a_res.lock.fl);
		fl->fl_start = req->a_res.lock.fl.fl_start;
		fl->fl_end = req->a_res.lock.fl.fl_start;
		fl->fl_type = req->a_res.lock.fl.fl_type;
		fl->fl_pid = 0;
		} else {
		return nlm_stat_to_errno(req->a_res.status);
		break;
		default:
		status = nlm_stat_to_errno(req->a_res.status);
		}

		return 0;
		out:
		nlm_release_call(req);
		return status;
		}

		static void nlmclnt_locks_copy_lock(struct file_lock new, struct file_lock fl)
		{
		memcpy(&new->fl_u.nfs_fl, &fl->fl_u.nfs_fl, sizeof(new->fl_u.nfs_fl));
		nlm_get_lockowner(new->fl_u.nfs_fl.owner);
		new->fl_u.nfs_fl.state = fl->fl_u.nfs_fl.state;
		new->fl_u.nfs_fl.owner = nlm_get_lockowner(fl->fl_u.nfs_fl.owner);
		list_add_tail(&new->fl_u.nfs_fl.list, &fl->fl_u.nfs_fl.owner->host->h_granted);
		}

		static void nlmclnt_locks_release_private(struct file_lock *fl)
		{
		list_del(&fl->fl_u.nfs_fl.list);
		nlm_put_lockowner(fl->fl_u.nfs_fl.owner);
		fl->fl_ops = NULL;
		}

		static struct file_lock_operations nlmclnt_lock_ops = {
		@@ -504,8 +450,8 @@ static void nlmclnt_locks_init_private(struct file_lock fl, struct nlm_host ho
		{
		BUG_ON(fl->fl_ops != NULL);
		fl->fl_u.nfs_fl.state = 0;
		fl->fl_u.nfs_fl.flags = 0;
		fl->fl_u.nfs_fl.owner = nlm_find_lockowner(host, fl->fl_owner);
		INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list);
		fl->fl_ops = &nlmclnt_lock_ops;
		}

		@@ -552,57 +498,52 @@ nlmclnt_lock(struct nlm_rqst req, struct file_lock fl)
		{
		struct nlm_host *host = req->a_host;
		struct nlm_res *resp = &req->a_res;
		long timeout;
		int status;
		struct nlm_wait *block = NULL;
		int status = -ENOLCK;

		if (!host->h_monitored && nsm_monitor(host) < 0) {
		printk(KERN_NOTICE "lockd: failed to monitor %s\n",
		host->h_name);
		status = -ENOLCK;
		goto out;
		}

		if (req->a_args.block) {
		status = nlmclnt_prepare_block(req, host, fl);
		if (status < 0)
		goto out;
		}
		block = nlmclnt_prepare_block(host, fl);
		for(;;) {
		status = nlmclnt_call(req, NLMPROC_LOCK);
		if (status < 0)
		goto out_unblock;
		if (resp->status != NLM_LCK_BLOCKED)
		if (!req->a_args.block)
		break;
		/* Wait on an NLM blocking lock */
		timeout = nlmclnt_block(req, NLMCLNT_POLL_TIMEOUT);
		/* Did a reclaimer thread notify us of a server reboot? */
		if (resp->status == NLM_LCK_DENIED_GRACE_PERIOD)
		continue;
		if (resp->status != NLM_LCK_BLOCKED)
		break;
		if (timeout >= 0)
		continue;
		/* We were interrupted. Send a CANCEL request to the server
		/* Wait on an NLM blocking lock */
		status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);
		/* if we were interrupted. Send a CANCEL request to the server
		* and exit
		*/
		status = (int)timeout;
		if (status < 0)
		goto out_unblock;
		if (resp->status != NLM_LCK_BLOCKED)
		break;
		}

		if (resp->status == NLM_LCK_GRANTED) {
		fl->fl_u.nfs_fl.state = host->h_state;
		fl->fl_u.nfs_fl.flags \|= NFS_LCK_GRANTED;
		fl->fl_flags \|= FL_SLEEP;
		/* Ensure the resulting lock will get added to granted list */
		do_vfs_lock(fl);
		}
		status = nlm_stat_to_errno(resp->status);
		out_unblock:
		nlmclnt_finish_block(req);
		nlmclnt_finish_block(block);
		/* Cancel the blocked request if it is still pending */
		if (resp->status == NLM_LCK_BLOCKED)
		nlmclnt_cancel(host, req->a_args.block, fl);
		out:
		nlmclnt_release_lockargs(req);
		nlm_release_call(req);
		return status;
		}

		@@ -658,10 +599,6 @@ nlmclnt_unlock(struct nlm_rqst req, struct file_lock fl)
		struct nlm_res *resp = &req->a_res;
		int status;

		/* Clean the GRANTED flag now so the lock doesn't get
		* reclaimed while we're stuck in the unlock call. */
		fl->fl_u.nfs_fl.flags &= ~NFS_LCK_GRANTED;

		/*
		* Note: the server is supposed to either grant us the unlock
		* request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either
		@@ -669,32 +606,24 @@ nlmclnt_unlock(struct nlm_rqst req, struct file_lock fl)
		*/
		do_vfs_lock(fl);

		if (req->a_flags & RPC_TASK_ASYNC) {
		status = nlmclnt_async_call(req, NLMPROC_UNLOCK,
		&nlmclnt_unlock_ops);
		/* Hrmf... Do the unlock early since locks_remove_posix()
		* really expects us to free the lock synchronously */
		if (status < 0) {
		nlmclnt_release_lockargs(req);
		kfree(req);
		}
		return status;
		}
		if (req->a_flags & RPC_TASK_ASYNC)
		return nlm_async_call(req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops);

		status = nlmclnt_call(req, NLMPROC_UNLOCK);
		nlmclnt_release_lockargs(req);
		if (status < 0)
		return status;
		goto out;

		status = 0;
		if (resp->status == NLM_LCK_GRANTED)
		return 0;
		goto out;

		if (resp->status != NLM_LCK_DENIED_NOLOCKS)
		printk("lockd: unexpected unlock status: %d\n", resp->status);

		/* What to do now? I'm out of my depth... */

		return -ENOLCK;
		status = -ENOLCK;
		out:
		nlm_release_call(req);
		return status;
		}

		static void nlmclnt_unlock_callback(struct rpc_task task, void data)
		@@ -716,9 +645,6 @@ static void nlmclnt_unlock_callback(struct rpc_task task, void data)
		if (status != NLM_LCK_GRANTED)
		printk(KERN_WARNING "lockd: unexpected unlock status: %d\n", status);
		die:
		nlm_release_host(req->a_host);
		nlmclnt_release_lockargs(req);
		kfree(req);
		return;
		retry_rebind:
		nlm_rebind_host(req->a_host);
		@@ -728,6 +654,7 @@ die:

		static const struct rpc_call_ops nlmclnt_unlock_ops = {
		.rpc_call_done = nlmclnt_unlock_callback,
		.rpc_release = nlmclnt_rpc_release,
		};

		/*
		@@ -749,20 +676,15 @@ static int nlmclnt_cancel(struct nlm_host host, int block, struct file_lock fl
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);

		req = nlmclnt_alloc_call();
		req = nlm_alloc_call(nlm_get_host(host));
		if (!req)
		return -ENOMEM;
		req->a_host = host;
		req->a_flags = RPC_TASK_ASYNC;

		nlmclnt_setlockargs(req, fl);
		req->a_args.block = block;

		status = nlmclnt_async_call(req, NLMPROC_CANCEL, &nlmclnt_cancel_ops);
		if (status < 0) {
		nlmclnt_release_lockargs(req);
		kfree(req);
		}
		status = nlm_async_call(req, NLMPROC_CANCEL, &nlmclnt_cancel_ops);

		spin_lock_irqsave(&current->sighand->siglock, flags);
		current->blocked = oldset;
		@@ -791,6 +713,7 @@ static void nlmclnt_cancel_callback(struct rpc_task task, void data)
		switch (req->a_res.status) {
		case NLM_LCK_GRANTED:
		case NLM_LCK_DENIED_GRACE_PERIOD:
		case NLM_LCK_DENIED:
		/* Everything's good */
		break;
		case NLM_LCK_DENIED_NOLOCKS:
		@@ -802,9 +725,6 @@ static void nlmclnt_cancel_callback(struct rpc_task task, void data)
		}

		die:
		nlm_release_host(req->a_host);
		nlmclnt_release_lockargs(req);
		kfree(req);
		return;

		retry_cancel:
		@@ -818,6 +738,7 @@ retry_cancel:

		static const struct rpc_call_ops nlmclnt_cancel_ops = {
		.rpc_call_done = nlmclnt_cancel_callback,
		.rpc_release = nlmclnt_rpc_release,
		};

		/*

fs/lockd/host.c

+9 −3

Original line number	Diff line number	Diff line
		@@ -123,6 +123,8 @@ nlm_lookup_host(int server, struct sockaddr_in *sin,
		nlm_hosts[hash] = host;
		INIT_LIST_HEAD(&host->h_lockowners);
		spin_lock_init(&host->h_lock);
		INIT_LIST_HEAD(&host->h_granted);
		INIT_LIST_HEAD(&host->h_reclaim);

		if (++nrhosts > NLM_HOST_MAX)
		next_gc = 0;
		@@ -191,11 +193,12 @@ nlm_bind_host(struct nlm_host *host)
		xprt->resvport = 1; /* NLM requires a reserved port */

		/* Existing NLM servers accept AUTH_UNIX only */
		clnt = rpc_create_client(xprt, host->h_name, &nlm_program,
		clnt = rpc_new_client(xprt, host->h_name, &nlm_program,
		host->h_version, RPC_AUTH_UNIX);
		if (IS_ERR(clnt))
		goto forgetit;
		clnt->cl_autobind = 1; /* turn on pmap queries */
		clnt->cl_softrtry = 1; /* All queries are soft */

		host->h_rpcclnt = clnt;
		}
		@@ -242,8 +245,12 @@ void nlm_release_host(struct nlm_host *host)
		{
		if (host != NULL) {
		dprintk("lockd: release host %s\n", host->h_name);
		atomic_dec(&host->h_count);
		BUG_ON(atomic_read(&host->h_count) < 0);
		if (atomic_dec_and_test(&host->h_count)) {
		BUG_ON(!list_empty(&host->h_lockowners));
		BUG_ON(!list_empty(&host->h_granted));
		BUG_ON(!list_empty(&host->h_reclaim));
		}
		}
		}

		@@ -331,7 +338,6 @@ nlm_gc_hosts(void)
		rpc_destroy_client(host->h_rpcclnt);
		}
		}
		BUG_ON(!list_empty(&host->h_lockowners));
		kfree(host);
		nrhosts--;
		}

fs/lockd/mon.c

+10 −1

Original line number	Diff line number	Diff line
		@@ -35,6 +35,10 @@ nsm_mon_unmon(struct nlm_host host, u32 proc, struct nsm_res res)
		struct rpc_clnt *clnt;
		int status;
		struct nsm_args args;
		struct rpc_message msg = {
		.rpc_argp = &args,
		.rpc_resp = res,
		};

		clnt = nsm_create();
		if (IS_ERR(clnt)) {
		@@ -49,7 +53,8 @@ nsm_mon_unmon(struct nlm_host host, u32 proc, struct nsm_res res)
		args.proc = NLMPROC_NSM_NOTIFY;
		memset(res, 0, sizeof(*res));

		status = rpc_call(clnt, proc, &args, res, 0);
		msg.rpc_proc = &clnt->cl_procinfo[proc];
		status = rpc_call_sync(clnt, &msg, 0);
		if (status < 0)
		printk(KERN_DEBUG "nsm_mon_unmon: rpc failed, status=%d\n",
		status);
		@@ -214,12 +219,16 @@ static struct rpc_procinfo nsm_procedures[] = {
		.p_encode = (kxdrproc_t) xdr_encode_mon,
		.p_decode = (kxdrproc_t) xdr_decode_stat_res,
		.p_bufsiz = MAX(SM_mon_sz, SM_monres_sz) << 2,
		.p_statidx = SM_MON,
		.p_name = "MONITOR",
		},
		[SM_UNMON] = {
		.p_proc = SM_UNMON,
		.p_encode = (kxdrproc_t) xdr_encode_unmon,
		.p_decode = (kxdrproc_t) xdr_decode_stat,
		.p_bufsiz = MAX(SM_mon_id_sz, SM_unmonres_sz) << 2,
		.p_statidx = SM_UNMON,
		.p_name = "UNMONITOR",
		},
		};

Admin message