xref: /linux/fs/lockd/clntproc.c (revision 79790b6818e96c58fe2bffee1b418c16e64e7b80)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * linux/fs/lockd/clntproc.c
4  *
5  * RPC procedures for the client side NLM implementation
6  *
7  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/slab.h>
12 #include <linux/types.h>
13 #include <linux/errno.h>
14 #include <linux/fs.h>
15 #include <linux/filelock.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/utsname.h>
18 #include <linux/freezer.h>
19 #include <linux/sunrpc/clnt.h>
20 #include <linux/sunrpc/svc.h>
21 #include <linux/lockd/lockd.h>
22 
23 #include "trace.h"
24 
25 #define NLMDBG_FACILITY		NLMDBG_CLIENT
26 #define NLMCLNT_GRACE_WAIT	(5*HZ)
27 #define NLMCLNT_POLL_TIMEOUT	(30*HZ)
28 #define NLMCLNT_MAX_RETRIES	3
29 
30 static int	nlmclnt_test(struct nlm_rqst *, struct file_lock *);
31 static int	nlmclnt_lock(struct nlm_rqst *, struct file_lock *);
32 static int	nlmclnt_unlock(struct nlm_rqst *, struct file_lock *);
33 static int	nlm_stat_to_errno(__be32 stat);
34 static void	nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host);
35 static int	nlmclnt_cancel(struct nlm_host *, int , struct file_lock *);
36 
37 static const struct rpc_call_ops nlmclnt_unlock_ops;
38 static const struct rpc_call_ops nlmclnt_cancel_ops;
39 
40 /*
41  * Cookie counter for NLM requests
42  */
43 static atomic_t	nlm_cookie = ATOMIC_INIT(0x1234);
44 
nlmclnt_next_cookie(struct nlm_cookie * c)45 void nlmclnt_next_cookie(struct nlm_cookie *c)
46 {
47 	u32	cookie = atomic_inc_return(&nlm_cookie);
48 
49 	memcpy(c->data, &cookie, 4);
50 	c->len=4;
51 }
52 
53 static struct nlm_lockowner *
nlmclnt_get_lockowner(struct nlm_lockowner * lockowner)54 nlmclnt_get_lockowner(struct nlm_lockowner *lockowner)
55 {
56 	refcount_inc(&lockowner->count);
57 	return lockowner;
58 }
59 
nlmclnt_put_lockowner(struct nlm_lockowner * lockowner)60 static void nlmclnt_put_lockowner(struct nlm_lockowner *lockowner)
61 {
62 	if (!refcount_dec_and_lock(&lockowner->count, &lockowner->host->h_lock))
63 		return;
64 	list_del(&lockowner->list);
65 	spin_unlock(&lockowner->host->h_lock);
66 	nlmclnt_release_host(lockowner->host);
67 	kfree(lockowner);
68 }
69 
nlm_pidbusy(struct nlm_host * host,uint32_t pid)70 static inline int nlm_pidbusy(struct nlm_host *host, uint32_t pid)
71 {
72 	struct nlm_lockowner *lockowner;
73 	list_for_each_entry(lockowner, &host->h_lockowners, list) {
74 		if (lockowner->pid == pid)
75 			return -EBUSY;
76 	}
77 	return 0;
78 }
79 
__nlm_alloc_pid(struct nlm_host * host)80 static inline uint32_t __nlm_alloc_pid(struct nlm_host *host)
81 {
82 	uint32_t res;
83 	do {
84 		res = host->h_pidcount++;
85 	} while (nlm_pidbusy(host, res) < 0);
86 	return res;
87 }
88 
__nlmclnt_find_lockowner(struct nlm_host * host,fl_owner_t owner)89 static struct nlm_lockowner *__nlmclnt_find_lockowner(struct nlm_host *host, fl_owner_t owner)
90 {
91 	struct nlm_lockowner *lockowner;
92 	list_for_each_entry(lockowner, &host->h_lockowners, list) {
93 		if (lockowner->owner != owner)
94 			continue;
95 		return nlmclnt_get_lockowner(lockowner);
96 	}
97 	return NULL;
98 }
99 
nlmclnt_find_lockowner(struct nlm_host * host,fl_owner_t owner)100 static struct nlm_lockowner *nlmclnt_find_lockowner(struct nlm_host *host, fl_owner_t owner)
101 {
102 	struct nlm_lockowner *res, *new = NULL;
103 
104 	spin_lock(&host->h_lock);
105 	res = __nlmclnt_find_lockowner(host, owner);
106 	if (res == NULL) {
107 		spin_unlock(&host->h_lock);
108 		new = kmalloc(sizeof(*new), GFP_KERNEL);
109 		spin_lock(&host->h_lock);
110 		res = __nlmclnt_find_lockowner(host, owner);
111 		if (res == NULL && new != NULL) {
112 			res = new;
113 			refcount_set(&new->count, 1);
114 			new->owner = owner;
115 			new->pid = __nlm_alloc_pid(host);
116 			new->host = nlm_get_host(host);
117 			list_add(&new->list, &host->h_lockowners);
118 			new = NULL;
119 		}
120 	}
121 	spin_unlock(&host->h_lock);
122 	kfree(new);
123 	return res;
124 }
125 
126 /*
127  * Initialize arguments for TEST/LOCK/UNLOCK/CANCEL calls
128  */
nlmclnt_setlockargs(struct nlm_rqst * req,struct file_lock * fl)129 static void nlmclnt_setlockargs(struct nlm_rqst *req, struct file_lock *fl)
130 {
131 	struct nlm_args	*argp = &req->a_args;
132 	struct nlm_lock	*lock = &argp->lock;
133 	char *nodename = req->a_host->h_rpcclnt->cl_nodename;
134 
135 	nlmclnt_next_cookie(&argp->cookie);
136 	memcpy(&lock->fh, NFS_FH(file_inode(fl->c.flc_file)),
137 	       sizeof(struct nfs_fh));
138 	lock->caller  = nodename;
139 	lock->oh.data = req->a_owner;
140 	lock->oh.len  = snprintf(req->a_owner, sizeof(req->a_owner), "%u@%s",
141 				(unsigned int)fl->fl_u.nfs_fl.owner->pid,
142 				nodename);
143 	lock->svid = fl->fl_u.nfs_fl.owner->pid;
144 	lock->fl.fl_start = fl->fl_start;
145 	lock->fl.fl_end = fl->fl_end;
146 	lock->fl.c.flc_type = fl->c.flc_type;
147 }
148 
nlmclnt_release_lockargs(struct nlm_rqst * req)149 static void nlmclnt_release_lockargs(struct nlm_rqst *req)
150 {
151 	WARN_ON_ONCE(req->a_args.lock.fl.fl_ops != NULL);
152 }
153 
154 /**
155  * nlmclnt_proc - Perform a single client-side lock request
156  * @host: address of a valid nlm_host context representing the NLM server
157  * @cmd: fcntl-style file lock operation to perform
158  * @fl: address of arguments for the lock operation
159  * @data: address of data to be sent to callback operations
160  *
161  */
nlmclnt_proc(struct nlm_host * host,int cmd,struct file_lock * fl,void * data)162 int nlmclnt_proc(struct nlm_host *host, int cmd, struct file_lock *fl, void *data)
163 {
164 	struct nlm_rqst		*call;
165 	int			status;
166 	const struct nlmclnt_operations *nlmclnt_ops = host->h_nlmclnt_ops;
167 
168 	call = nlm_alloc_call(host);
169 	if (call == NULL)
170 		return -ENOMEM;
171 
172 	if (nlmclnt_ops && nlmclnt_ops->nlmclnt_alloc_call)
173 		nlmclnt_ops->nlmclnt_alloc_call(data);
174 
175 	nlmclnt_locks_init_private(fl, host);
176 	if (!fl->fl_u.nfs_fl.owner) {
177 		/* lockowner allocation has failed */
178 		nlmclnt_release_call(call);
179 		return -ENOMEM;
180 	}
181 	/* Set up the argument struct */
182 	nlmclnt_setlockargs(call, fl);
183 	call->a_callback_data = data;
184 
185 	if (IS_SETLK(cmd) || IS_SETLKW(cmd)) {
186 		if (fl->c.flc_type != F_UNLCK) {
187 			call->a_args.block = IS_SETLKW(cmd) ? 1 : 0;
188 			status = nlmclnt_lock(call, fl);
189 		} else
190 			status = nlmclnt_unlock(call, fl);
191 	} else if (IS_GETLK(cmd))
192 		status = nlmclnt_test(call, fl);
193 	else
194 		status = -EINVAL;
195 	fl->fl_ops->fl_release_private(fl);
196 	fl->fl_ops = NULL;
197 
198 	dprintk("lockd: clnt proc returns %d\n", status);
199 	return status;
200 }
201 EXPORT_SYMBOL_GPL(nlmclnt_proc);
202 
203 /*
204  * Allocate an NLM RPC call struct
205  */
nlm_alloc_call(struct nlm_host * host)206 struct nlm_rqst *nlm_alloc_call(struct nlm_host *host)
207 {
208 	struct nlm_rqst	*call;
209 
210 	for(;;) {
211 		call = kzalloc(sizeof(*call), GFP_KERNEL);
212 		if (call != NULL) {
213 			refcount_set(&call->a_count, 1);
214 			locks_init_lock(&call->a_args.lock.fl);
215 			locks_init_lock(&call->a_res.lock.fl);
216 			call->a_host = nlm_get_host(host);
217 			return call;
218 		}
219 		if (signalled())
220 			break;
221 		printk("nlm_alloc_call: failed, waiting for memory\n");
222 		schedule_timeout_interruptible(5*HZ);
223 	}
224 	return NULL;
225 }
226 
nlmclnt_release_call(struct nlm_rqst * call)227 void nlmclnt_release_call(struct nlm_rqst *call)
228 {
229 	const struct nlmclnt_operations *nlmclnt_ops = call->a_host->h_nlmclnt_ops;
230 
231 	if (!refcount_dec_and_test(&call->a_count))
232 		return;
233 	if (nlmclnt_ops && nlmclnt_ops->nlmclnt_release_call)
234 		nlmclnt_ops->nlmclnt_release_call(call->a_callback_data);
235 	nlmclnt_release_host(call->a_host);
236 	nlmclnt_release_lockargs(call);
237 	kfree(call);
238 }
239 
nlmclnt_rpc_release(void * data)240 static void nlmclnt_rpc_release(void *data)
241 {
242 	nlmclnt_release_call(data);
243 }
244 
nlm_wait_on_grace(wait_queue_head_t * queue)245 static int nlm_wait_on_grace(wait_queue_head_t *queue)
246 {
247 	DEFINE_WAIT(wait);
248 	int status = -EINTR;
249 
250 	prepare_to_wait(queue, &wait, TASK_INTERRUPTIBLE);
251 	if (!signalled ()) {
252 		schedule_timeout(NLMCLNT_GRACE_WAIT);
253 		try_to_freeze();
254 		if (!signalled ())
255 			status = 0;
256 	}
257 	finish_wait(queue, &wait);
258 	return status;
259 }
260 
261 /*
262  * Generic NLM call
263  */
264 static int
nlmclnt_call(const struct cred * cred,struct nlm_rqst * req,u32 proc)265 nlmclnt_call(const struct cred *cred, struct nlm_rqst *req, u32 proc)
266 {
267 	struct nlm_host	*host = req->a_host;
268 	struct rpc_clnt	*clnt;
269 	struct nlm_args	*argp = &req->a_args;
270 	struct nlm_res	*resp = &req->a_res;
271 	struct rpc_message msg = {
272 		.rpc_argp	= argp,
273 		.rpc_resp	= resp,
274 		.rpc_cred	= cred,
275 	};
276 	int		status;
277 
278 	dprintk("lockd: call procedure %d on %s\n",
279 			(int)proc, host->h_name);
280 
281 	do {
282 		if (host->h_reclaiming && !argp->reclaim)
283 			goto in_grace_period;
284 
285 		/* If we have no RPC client yet, create one. */
286 		if ((clnt = nlm_bind_host(host)) == NULL)
287 			return -ENOLCK;
288 		msg.rpc_proc = &clnt->cl_procinfo[proc];
289 
290 		/* Perform the RPC call. If an error occurs, try again */
291 		if ((status = rpc_call_sync(clnt, &msg, 0)) < 0) {
292 			dprintk("lockd: rpc_call returned error %d\n", -status);
293 			switch (status) {
294 			case -EPROTONOSUPPORT:
295 				status = -EINVAL;
296 				break;
297 			case -ECONNREFUSED:
298 			case -ETIMEDOUT:
299 			case -ENOTCONN:
300 				nlm_rebind_host(host);
301 				status = -EAGAIN;
302 				break;
303 			case -ERESTARTSYS:
304 				return signalled () ? -EINTR : status;
305 			default:
306 				break;
307 			}
308 			break;
309 		} else
310 		if (resp->status == nlm_lck_denied_grace_period) {
311 			dprintk("lockd: server in grace period\n");
312 			if (argp->reclaim) {
313 				printk(KERN_WARNING
314 				     "lockd: spurious grace period reject?!\n");
315 				return -ENOLCK;
316 			}
317 		} else {
318 			if (!argp->reclaim) {
319 				/* We appear to be out of the grace period */
320 				wake_up_all(&host->h_gracewait);
321 			}
322 			dprintk("lockd: server returns status %d\n",
323 				ntohl(resp->status));
324 			return 0;	/* Okay, call complete */
325 		}
326 
327 in_grace_period:
328 		/*
329 		 * The server has rebooted and appears to be in the grace
330 		 * period during which locks are only allowed to be
331 		 * reclaimed.
332 		 * We can only back off and try again later.
333 		 */
334 		status = nlm_wait_on_grace(&host->h_gracewait);
335 	} while (status == 0);
336 
337 	return status;
338 }
339 
340 /*
341  * Generic NLM call, async version.
342  */
__nlm_async_call(struct nlm_rqst * req,u32 proc,struct rpc_message * msg,const struct rpc_call_ops * tk_ops)343 static struct rpc_task *__nlm_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops)
344 {
345 	struct nlm_host	*host = req->a_host;
346 	struct rpc_clnt	*clnt;
347 	struct rpc_task_setup task_setup_data = {
348 		.rpc_message = msg,
349 		.callback_ops = tk_ops,
350 		.callback_data = req,
351 		.flags = RPC_TASK_ASYNC,
352 	};
353 
354 	dprintk("lockd: call procedure %d on %s (async)\n",
355 			(int)proc, host->h_name);
356 
357 	/* If we have no RPC client yet, create one. */
358 	clnt = nlm_bind_host(host);
359 	if (clnt == NULL)
360 		goto out_err;
361 	msg->rpc_proc = &clnt->cl_procinfo[proc];
362 	task_setup_data.rpc_client = clnt;
363 
364         /* bootstrap and kick off the async RPC call */
365 	return rpc_run_task(&task_setup_data);
366 out_err:
367 	tk_ops->rpc_release(req);
368 	return ERR_PTR(-ENOLCK);
369 }
370 
nlm_do_async_call(struct nlm_rqst * req,u32 proc,struct rpc_message * msg,const struct rpc_call_ops * tk_ops)371 static int nlm_do_async_call(struct nlm_rqst *req, u32 proc, struct rpc_message *msg, const struct rpc_call_ops *tk_ops)
372 {
373 	struct rpc_task *task;
374 
375 	task = __nlm_async_call(req, proc, msg, tk_ops);
376 	if (IS_ERR(task))
377 		return PTR_ERR(task);
378 	rpc_put_task(task);
379 	return 0;
380 }
381 
382 /*
383  * NLM asynchronous call.
384  */
nlm_async_call(struct nlm_rqst * req,u32 proc,const struct rpc_call_ops * tk_ops)385 int nlm_async_call(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
386 {
387 	struct rpc_message msg = {
388 		.rpc_argp	= &req->a_args,
389 		.rpc_resp	= &req->a_res,
390 	};
391 	return nlm_do_async_call(req, proc, &msg, tk_ops);
392 }
393 
nlm_async_reply(struct nlm_rqst * req,u32 proc,const struct rpc_call_ops * tk_ops)394 int nlm_async_reply(struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
395 {
396 	struct rpc_message msg = {
397 		.rpc_argp	= &req->a_res,
398 	};
399 	return nlm_do_async_call(req, proc, &msg, tk_ops);
400 }
401 
402 /*
403  * NLM client asynchronous call.
404  *
405  * Note that although the calls are asynchronous, and are therefore
406  *      guaranteed to complete, we still always attempt to wait for
407  *      completion in order to be able to correctly track the lock
408  *      state.
409  */
nlmclnt_async_call(const struct cred * cred,struct nlm_rqst * req,u32 proc,const struct rpc_call_ops * tk_ops)410 static int nlmclnt_async_call(const struct cred *cred, struct nlm_rqst *req, u32 proc, const struct rpc_call_ops *tk_ops)
411 {
412 	struct rpc_message msg = {
413 		.rpc_argp	= &req->a_args,
414 		.rpc_resp	= &req->a_res,
415 		.rpc_cred	= cred,
416 	};
417 	struct rpc_task *task;
418 	int err;
419 
420 	task = __nlm_async_call(req, proc, &msg, tk_ops);
421 	if (IS_ERR(task))
422 		return PTR_ERR(task);
423 	err = rpc_wait_for_completion_task(task);
424 	rpc_put_task(task);
425 	return err;
426 }
427 
428 /*
429  * TEST for the presence of a conflicting lock
430  */
431 static int
nlmclnt_test(struct nlm_rqst * req,struct file_lock * fl)432 nlmclnt_test(struct nlm_rqst *req, struct file_lock *fl)
433 {
434 	int	status;
435 
436 	status = nlmclnt_call(nfs_file_cred(fl->c.flc_file), req,
437 			      NLMPROC_TEST);
438 	if (status < 0)
439 		goto out;
440 
441 	switch (req->a_res.status) {
442 		case nlm_granted:
443 			fl->c.flc_type = F_UNLCK;
444 			break;
445 		case nlm_lck_denied:
446 			/*
447 			 * Report the conflicting lock back to the application.
448 			 */
449 			fl->fl_start = req->a_res.lock.fl.fl_start;
450 			fl->fl_end = req->a_res.lock.fl.fl_end;
451 			fl->c.flc_type = req->a_res.lock.fl.c.flc_type;
452 			fl->c.flc_pid = -req->a_res.lock.fl.c.flc_pid;
453 			break;
454 		default:
455 			status = nlm_stat_to_errno(req->a_res.status);
456 	}
457 out:
458 	trace_nlmclnt_test(&req->a_args.lock,
459 			   (const struct sockaddr *)&req->a_host->h_addr,
460 			   req->a_host->h_addrlen, req->a_res.status);
461 	nlmclnt_release_call(req);
462 	return status;
463 }
464 
nlmclnt_locks_copy_lock(struct file_lock * new,struct file_lock * fl)465 static void nlmclnt_locks_copy_lock(struct file_lock *new, struct file_lock *fl)
466 {
467 	spin_lock(&fl->fl_u.nfs_fl.owner->host->h_lock);
468 	new->fl_u.nfs_fl.state = fl->fl_u.nfs_fl.state;
469 	new->fl_u.nfs_fl.owner = nlmclnt_get_lockowner(fl->fl_u.nfs_fl.owner);
470 	list_add_tail(&new->fl_u.nfs_fl.list, &fl->fl_u.nfs_fl.owner->host->h_granted);
471 	spin_unlock(&fl->fl_u.nfs_fl.owner->host->h_lock);
472 }
473 
nlmclnt_locks_release_private(struct file_lock * fl)474 static void nlmclnt_locks_release_private(struct file_lock *fl)
475 {
476 	spin_lock(&fl->fl_u.nfs_fl.owner->host->h_lock);
477 	list_del(&fl->fl_u.nfs_fl.list);
478 	spin_unlock(&fl->fl_u.nfs_fl.owner->host->h_lock);
479 	nlmclnt_put_lockowner(fl->fl_u.nfs_fl.owner);
480 }
481 
482 static const struct file_lock_operations nlmclnt_lock_ops = {
483 	.fl_copy_lock = nlmclnt_locks_copy_lock,
484 	.fl_release_private = nlmclnt_locks_release_private,
485 };
486 
nlmclnt_locks_init_private(struct file_lock * fl,struct nlm_host * host)487 static void nlmclnt_locks_init_private(struct file_lock *fl, struct nlm_host *host)
488 {
489 	fl->fl_u.nfs_fl.state = 0;
490 	fl->fl_u.nfs_fl.owner = nlmclnt_find_lockowner(host,
491 						       fl->c.flc_owner);
492 	INIT_LIST_HEAD(&fl->fl_u.nfs_fl.list);
493 	fl->fl_ops = &nlmclnt_lock_ops;
494 }
495 
do_vfs_lock(struct file_lock * fl)496 static int do_vfs_lock(struct file_lock *fl)
497 {
498 	return locks_lock_file_wait(fl->c.flc_file, fl);
499 }
500 
501 /*
502  * LOCK: Try to create a lock
503  *
504  *			Programmer Harassment Alert
505  *
506  * When given a blocking lock request in a sync RPC call, the HPUX lockd
507  * will faithfully return LCK_BLOCKED but never cares to notify us when
508  * the lock could be granted. This way, our local process could hang
509  * around forever waiting for the callback.
510  *
511  *  Solution A:	Implement busy-waiting
512  *  Solution B: Use the async version of the call (NLM_LOCK_{MSG,RES})
513  *
514  * For now I am implementing solution A, because I hate the idea of
515  * re-implementing lockd for a third time in two months. The async
516  * calls shouldn't be too hard to do, however.
517  *
518  * This is one of the lovely things about standards in the NFS area:
519  * they're so soft and squishy you can't really blame HP for doing this.
520  */
521 static int
nlmclnt_lock(struct nlm_rqst * req,struct file_lock * fl)522 nlmclnt_lock(struct nlm_rqst *req, struct file_lock *fl)
523 {
524 	const struct cred *cred = nfs_file_cred(fl->c.flc_file);
525 	struct nlm_host	*host = req->a_host;
526 	struct nlm_res	*resp = &req->a_res;
527 	struct nlm_wait block;
528 	unsigned char flags = fl->c.flc_flags;
529 	unsigned char type;
530 	__be32 b_status;
531 	int status = -ENOLCK;
532 
533 	if (nsm_monitor(host) < 0)
534 		goto out;
535 	req->a_args.state = nsm_local_state;
536 
537 	fl->c.flc_flags |= FL_ACCESS;
538 	status = do_vfs_lock(fl);
539 	fl->c.flc_flags = flags;
540 	if (status < 0)
541 		goto out;
542 
543 	nlmclnt_prepare_block(&block, host, fl);
544 again:
545 	/*
546 	 * Initialise resp->status to a valid non-zero value,
547 	 * since 0 == nlm_lck_granted
548 	 */
549 	resp->status = nlm_lck_blocked;
550 
551 	/*
552 	 * A GRANTED callback can come at any time -- even before the reply
553 	 * to the LOCK request arrives, so we queue the wait before
554 	 * requesting the lock.
555 	 */
556 	nlmclnt_queue_block(&block);
557 	for (;;) {
558 		/* Reboot protection */
559 		fl->fl_u.nfs_fl.state = host->h_state;
560 		status = nlmclnt_call(cred, req, NLMPROC_LOCK);
561 		if (status < 0)
562 			break;
563 		/* Did a reclaimer thread notify us of a server reboot? */
564 		if (resp->status == nlm_lck_denied_grace_period)
565 			continue;
566 		if (resp->status != nlm_lck_blocked)
567 			break;
568 		/* Wait on an NLM blocking lock */
569 		status = nlmclnt_wait(&block, req, NLMCLNT_POLL_TIMEOUT);
570 		if (status < 0)
571 			break;
572 		if (block.b_status != nlm_lck_blocked)
573 			break;
574 	}
575 	b_status = nlmclnt_dequeue_block(&block);
576 	if (resp->status == nlm_lck_blocked)
577 		resp->status = b_status;
578 
579 	/* if we were interrupted while blocking, then cancel the lock request
580 	 * and exit
581 	 */
582 	if (resp->status == nlm_lck_blocked) {
583 		if (!req->a_args.block)
584 			goto out_unlock;
585 		if (nlmclnt_cancel(host, req->a_args.block, fl) == 0)
586 			goto out;
587 	}
588 
589 	if (resp->status == nlm_granted) {
590 		down_read(&host->h_rwsem);
591 		/* Check whether or not the server has rebooted */
592 		if (fl->fl_u.nfs_fl.state != host->h_state) {
593 			up_read(&host->h_rwsem);
594 			goto again;
595 		}
596 		/* Ensure the resulting lock will get added to granted list */
597 		fl->c.flc_flags |= FL_SLEEP;
598 		if (do_vfs_lock(fl) < 0)
599 			printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
600 		up_read(&host->h_rwsem);
601 		fl->c.flc_flags = flags;
602 		status = 0;
603 	}
604 	if (status < 0)
605 		goto out_unlock;
606 	/*
607 	 * EAGAIN doesn't make sense for sleeping locks, and in some
608 	 * cases NLM_LCK_DENIED is returned for a permanent error.  So
609 	 * turn it into an ENOLCK.
610 	 */
611 	if (resp->status == nlm_lck_denied && (flags & FL_SLEEP))
612 		status = -ENOLCK;
613 	else
614 		status = nlm_stat_to_errno(resp->status);
615 out:
616 	trace_nlmclnt_lock(&req->a_args.lock,
617 			   (const struct sockaddr *)&req->a_host->h_addr,
618 			   req->a_host->h_addrlen, req->a_res.status);
619 	nlmclnt_release_call(req);
620 	return status;
621 out_unlock:
622 	/* Fatal error: ensure that we remove the lock altogether */
623 	trace_nlmclnt_lock(&req->a_args.lock,
624 			   (const struct sockaddr *)&req->a_host->h_addr,
625 			   req->a_host->h_addrlen, req->a_res.status);
626 	dprintk("lockd: lock attempt ended in fatal error.\n"
627 		"       Attempting to unlock.\n");
628 	type = fl->c.flc_type;
629 	fl->c.flc_type = F_UNLCK;
630 	down_read(&host->h_rwsem);
631 	do_vfs_lock(fl);
632 	up_read(&host->h_rwsem);
633 	fl->c.flc_type = type;
634 	fl->c.flc_flags = flags;
635 	nlmclnt_async_call(cred, req, NLMPROC_UNLOCK, &nlmclnt_unlock_ops);
636 	return status;
637 }
638 
639 /*
640  * RECLAIM: Try to reclaim a lock
641  */
642 int
nlmclnt_reclaim(struct nlm_host * host,struct file_lock * fl,struct nlm_rqst * req)643 nlmclnt_reclaim(struct nlm_host *host, struct file_lock *fl,
644 		struct nlm_rqst *req)
645 {
646 	int		status;
647 
648 	memset(req, 0, sizeof(*req));
649 	locks_init_lock(&req->a_args.lock.fl);
650 	locks_init_lock(&req->a_res.lock.fl);
651 	req->a_host  = host;
652 
653 	/* Set up the argument struct */
654 	nlmclnt_setlockargs(req, fl);
655 	req->a_args.reclaim = 1;
656 
657 	status = nlmclnt_call(nfs_file_cred(fl->c.flc_file), req,
658 			      NLMPROC_LOCK);
659 	if (status >= 0 && req->a_res.status == nlm_granted)
660 		return 0;
661 
662 	printk(KERN_WARNING "lockd: failed to reclaim lock for pid %d "
663 				"(errno %d, status %d)\n",
664 				fl->c.flc_pid,
665 				status, ntohl(req->a_res.status));
666 
667 	/*
668 	 * FIXME: This is a serious failure. We can
669 	 *
670 	 *  a.	Ignore the problem
671 	 *  b.	Send the owning process some signal (Linux doesn't have
672 	 *	SIGLOST, though...)
673 	 *  c.	Retry the operation
674 	 *
675 	 * Until someone comes up with a simple implementation
676 	 * for b or c, I'll choose option a.
677 	 */
678 
679 	return -ENOLCK;
680 }
681 
682 /*
683  * UNLOCK: remove an existing lock
684  */
685 static int
nlmclnt_unlock(struct nlm_rqst * req,struct file_lock * fl)686 nlmclnt_unlock(struct nlm_rqst *req, struct file_lock *fl)
687 {
688 	struct nlm_host	*host = req->a_host;
689 	struct nlm_res	*resp = &req->a_res;
690 	int status;
691 	unsigned char flags = fl->c.flc_flags;
692 
693 	/*
694 	 * Note: the server is supposed to either grant us the unlock
695 	 * request, or to deny it with NLM_LCK_DENIED_GRACE_PERIOD. In either
696 	 * case, we want to unlock.
697 	 */
698 	fl->c.flc_flags |= FL_EXISTS;
699 	down_read(&host->h_rwsem);
700 	status = do_vfs_lock(fl);
701 	up_read(&host->h_rwsem);
702 	fl->c.flc_flags = flags;
703 	if (status == -ENOENT) {
704 		status = 0;
705 		goto out;
706 	}
707 
708 	refcount_inc(&req->a_count);
709 	status = nlmclnt_async_call(nfs_file_cred(fl->c.flc_file), req,
710 				    NLMPROC_UNLOCK, &nlmclnt_unlock_ops);
711 	if (status < 0)
712 		goto out;
713 
714 	if (resp->status == nlm_granted)
715 		goto out;
716 
717 	if (resp->status != nlm_lck_denied_nolocks)
718 		printk("lockd: unexpected unlock status: %d\n",
719 			ntohl(resp->status));
720 	/* What to do now? I'm out of my depth... */
721 	status = -ENOLCK;
722 out:
723 	trace_nlmclnt_unlock(&req->a_args.lock,
724 			     (const struct sockaddr *)&req->a_host->h_addr,
725 			     req->a_host->h_addrlen, req->a_res.status);
726 	nlmclnt_release_call(req);
727 	return status;
728 }
729 
nlmclnt_unlock_prepare(struct rpc_task * task,void * data)730 static void nlmclnt_unlock_prepare(struct rpc_task *task, void *data)
731 {
732 	struct nlm_rqst	*req = data;
733 	const struct nlmclnt_operations *nlmclnt_ops = req->a_host->h_nlmclnt_ops;
734 	bool defer_call = false;
735 
736 	if (nlmclnt_ops && nlmclnt_ops->nlmclnt_unlock_prepare)
737 		defer_call = nlmclnt_ops->nlmclnt_unlock_prepare(task, req->a_callback_data);
738 
739 	if (!defer_call)
740 		rpc_call_start(task);
741 }
742 
nlmclnt_unlock_callback(struct rpc_task * task,void * data)743 static void nlmclnt_unlock_callback(struct rpc_task *task, void *data)
744 {
745 	struct nlm_rqst	*req = data;
746 	u32 status = ntohl(req->a_res.status);
747 
748 	if (RPC_SIGNALLED(task))
749 		goto die;
750 
751 	if (task->tk_status < 0) {
752 		dprintk("lockd: unlock failed (err = %d)\n", -task->tk_status);
753 		switch (task->tk_status) {
754 		case -EACCES:
755 		case -EIO:
756 			goto die;
757 		default:
758 			goto retry_rebind;
759 		}
760 	}
761 	if (status == NLM_LCK_DENIED_GRACE_PERIOD) {
762 		rpc_delay(task, NLMCLNT_GRACE_WAIT);
763 		goto retry_unlock;
764 	}
765 	if (status != NLM_LCK_GRANTED)
766 		printk(KERN_WARNING "lockd: unexpected unlock status: %d\n", status);
767 die:
768 	return;
769  retry_rebind:
770 	nlm_rebind_host(req->a_host);
771  retry_unlock:
772 	rpc_restart_call(task);
773 }
774 
775 static const struct rpc_call_ops nlmclnt_unlock_ops = {
776 	.rpc_call_prepare = nlmclnt_unlock_prepare,
777 	.rpc_call_done = nlmclnt_unlock_callback,
778 	.rpc_release = nlmclnt_rpc_release,
779 };
780 
781 /*
782  * Cancel a blocked lock request.
783  * We always use an async RPC call for this in order not to hang a
784  * process that has been Ctrl-C'ed.
785  */
nlmclnt_cancel(struct nlm_host * host,int block,struct file_lock * fl)786 static int nlmclnt_cancel(struct nlm_host *host, int block, struct file_lock *fl)
787 {
788 	struct nlm_rqst	*req;
789 	int status;
790 
791 	dprintk("lockd: blocking lock attempt was interrupted by a signal.\n"
792 		"       Attempting to cancel lock.\n");
793 
794 	req = nlm_alloc_call(host);
795 	if (!req)
796 		return -ENOMEM;
797 	req->a_flags = RPC_TASK_ASYNC;
798 
799 	nlmclnt_setlockargs(req, fl);
800 	req->a_args.block = block;
801 
802 	refcount_inc(&req->a_count);
803 	status = nlmclnt_async_call(nfs_file_cred(fl->c.flc_file), req,
804 				    NLMPROC_CANCEL, &nlmclnt_cancel_ops);
805 	if (status == 0 && req->a_res.status == nlm_lck_denied)
806 		status = -ENOLCK;
807 	nlmclnt_release_call(req);
808 	return status;
809 }
810 
nlmclnt_cancel_callback(struct rpc_task * task,void * data)811 static void nlmclnt_cancel_callback(struct rpc_task *task, void *data)
812 {
813 	struct nlm_rqst	*req = data;
814 	u32 status = ntohl(req->a_res.status);
815 
816 	if (RPC_SIGNALLED(task))
817 		goto die;
818 
819 	if (task->tk_status < 0) {
820 		dprintk("lockd: CANCEL call error %d, retrying.\n",
821 					task->tk_status);
822 		goto retry_cancel;
823 	}
824 
825 	switch (status) {
826 	case NLM_LCK_GRANTED:
827 	case NLM_LCK_DENIED_GRACE_PERIOD:
828 	case NLM_LCK_DENIED:
829 		/* Everything's good */
830 		break;
831 	case NLM_LCK_DENIED_NOLOCKS:
832 		dprintk("lockd: CANCEL failed (server has no locks)\n");
833 		goto retry_cancel;
834 	default:
835 		printk(KERN_NOTICE "lockd: weird return %d for CANCEL call\n",
836 			status);
837 	}
838 
839 die:
840 	return;
841 
842 retry_cancel:
843 	/* Don't ever retry more than 3 times */
844 	if (req->a_retries++ >= NLMCLNT_MAX_RETRIES)
845 		goto die;
846 	nlm_rebind_host(req->a_host);
847 	rpc_restart_call(task);
848 	rpc_delay(task, 30 * HZ);
849 }
850 
851 static const struct rpc_call_ops nlmclnt_cancel_ops = {
852 	.rpc_call_done = nlmclnt_cancel_callback,
853 	.rpc_release = nlmclnt_rpc_release,
854 };
855 
856 /*
857  * Convert an NLM status code to a generic kernel errno
858  */
859 static int
nlm_stat_to_errno(__be32 status)860 nlm_stat_to_errno(__be32 status)
861 {
862 	switch(ntohl(status)) {
863 	case NLM_LCK_GRANTED:
864 		return 0;
865 	case NLM_LCK_DENIED:
866 		return -EAGAIN;
867 	case NLM_LCK_DENIED_NOLOCKS:
868 	case NLM_LCK_DENIED_GRACE_PERIOD:
869 		return -ENOLCK;
870 	case NLM_LCK_BLOCKED:
871 		printk(KERN_NOTICE "lockd: unexpected status NLM_BLOCKED\n");
872 		return -ENOLCK;
873 #ifdef CONFIG_LOCKD_V4
874 	case NLM_DEADLCK:
875 		return -EDEADLK;
876 	case NLM_ROFS:
877 		return -EROFS;
878 	case NLM_STALE_FH:
879 		return -ESTALE;
880 	case NLM_FBIG:
881 		return -EOVERFLOW;
882 	case NLM_FAILED:
883 		return -ENOLCK;
884 #endif
885 	}
886 	printk(KERN_NOTICE "lockd: unexpected server status %d\n",
887 		 ntohl(status));
888 	return -ENOLCK;
889 }
890