1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * linux/fs/lockd/svcproc.c
4  *
5  * Lockd server procedures. We don't implement the NLM_*_RES
6  * procedures because we don't use the async procedures.
7  *
8  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
9  */
10 
11 #include <linux/types.h>
12 #include <linux/time.h>
13 #include <linux/lockd/lockd.h>
14 #include <linux/lockd/share.h>
15 #include <linux/sunrpc/svc_xprt.h>
16 
17 #define NLMDBG_FACILITY		NLMDBG_CLIENT
18 
19 #ifdef CONFIG_LOCKD_V4
20 static __be32
cast_to_nlm(__be32 status,u32 vers)21 cast_to_nlm(__be32 status, u32 vers)
22 {
23 	/* Note: status is assumed to be in network byte order !!! */
24 	if (vers != 4){
25 		switch (status) {
26 		case nlm_granted:
27 		case nlm_lck_denied:
28 		case nlm_lck_denied_nolocks:
29 		case nlm_lck_blocked:
30 		case nlm_lck_denied_grace_period:
31 		case nlm_drop_reply:
32 			break;
33 		case nlm4_deadlock:
34 			status = nlm_lck_denied;
35 			break;
36 		default:
37 			status = nlm_lck_denied_nolocks;
38 		}
39 	}
40 
41 	return (status);
42 }
43 #define	cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
44 #else
45 #define cast_status(status) (status)
46 #endif
47 
48 /*
49  * Obtain client and file from arguments
50  */
51 static __be32
nlmsvc_retrieve_args(struct svc_rqst * rqstp,struct nlm_args * argp,struct nlm_host ** hostp,struct nlm_file ** filp)52 nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
53 			struct nlm_host **hostp, struct nlm_file **filp)
54 {
55 	struct nlm_host		*host = NULL;
56 	struct nlm_file		*file = NULL;
57 	struct nlm_lock		*lock = &argp->lock;
58 	__be32			error = 0;
59 
60 	/* nfsd callbacks must have been installed for this procedure */
61 	if (!nlmsvc_ops)
62 		return nlm_lck_denied_nolocks;
63 
64 	/* Obtain host handle */
65 	if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
66 	 || (argp->monitor && nsm_monitor(host) < 0))
67 		goto no_locks;
68 	*hostp = host;
69 
70 	/* Obtain file pointer. Not used by FREE_ALL call. */
71 	if (filp != NULL) {
72 		error = cast_status(nlm_lookup_file(rqstp, &file, &lock->fh));
73 		if (error != 0)
74 			goto no_locks;
75 		*filp = file;
76 
77 		/* Set up the missing parts of the file_lock structure */
78 		lock->fl.fl_file  = file->f_file;
79 		lock->fl.fl_owner = (fl_owner_t) host;
80 		lock->fl.fl_lmops = &nlmsvc_lock_operations;
81 	}
82 
83 	return 0;
84 
85 no_locks:
86 	nlmsvc_release_host(host);
87 	if (error)
88 		return error;
89 	return nlm_lck_denied_nolocks;
90 }
91 
92 /*
93  * NULL: Test for presence of service
94  */
95 static __be32
nlmsvc_proc_null(struct svc_rqst * rqstp)96 nlmsvc_proc_null(struct svc_rqst *rqstp)
97 {
98 	dprintk("lockd: NULL          called\n");
99 	return rpc_success;
100 }
101 
102 /*
103  * TEST: Check for conflicting lock
104  */
105 static __be32
__nlmsvc_proc_test(struct svc_rqst * rqstp,struct nlm_res * resp)106 __nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp)
107 {
108 	struct nlm_args *argp = rqstp->rq_argp;
109 	struct nlm_host	*host;
110 	struct nlm_file	*file;
111 	__be32 rc = rpc_success;
112 
113 	dprintk("lockd: TEST          called\n");
114 	resp->cookie = argp->cookie;
115 
116 	/* Obtain client and file */
117 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
118 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
119 
120 	/* Now check for conflicting locks */
121 	resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie));
122 	if (resp->status == nlm_drop_reply)
123 		rc = rpc_drop_reply;
124 	else
125 		dprintk("lockd: TEST          status %d vers %d\n",
126 			ntohl(resp->status), rqstp->rq_vers);
127 
128 	nlmsvc_release_host(host);
129 	nlm_release_file(file);
130 	return rc;
131 }
132 
133 static __be32
nlmsvc_proc_test(struct svc_rqst * rqstp)134 nlmsvc_proc_test(struct svc_rqst *rqstp)
135 {
136 	return __nlmsvc_proc_test(rqstp, rqstp->rq_resp);
137 }
138 
139 static __be32
__nlmsvc_proc_lock(struct svc_rqst * rqstp,struct nlm_res * resp)140 __nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp)
141 {
142 	struct nlm_args *argp = rqstp->rq_argp;
143 	struct nlm_host	*host;
144 	struct nlm_file	*file;
145 	__be32 rc = rpc_success;
146 
147 	dprintk("lockd: LOCK          called\n");
148 
149 	resp->cookie = argp->cookie;
150 
151 	/* Obtain client and file */
152 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
153 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
154 
155 #if 0
156 	/* If supplied state doesn't match current state, we assume it's
157 	 * an old request that time-warped somehow. Any error return would
158 	 * do in this case because it's irrelevant anyway.
159 	 *
160 	 * NB: We don't retrieve the remote host's state yet.
161 	 */
162 	if (host->h_nsmstate && host->h_nsmstate != argp->state) {
163 		resp->status = nlm_lck_denied_nolocks;
164 	} else
165 #endif
166 
167 	/* Now try to lock the file */
168 	resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
169 					       argp->block, &argp->cookie,
170 					       argp->reclaim));
171 	if (resp->status == nlm_drop_reply)
172 		rc = rpc_drop_reply;
173 	else
174 		dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
175 
176 	nlmsvc_release_host(host);
177 	nlm_release_file(file);
178 	return rc;
179 }
180 
181 static __be32
nlmsvc_proc_lock(struct svc_rqst * rqstp)182 nlmsvc_proc_lock(struct svc_rqst *rqstp)
183 {
184 	return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp);
185 }
186 
187 static __be32
__nlmsvc_proc_cancel(struct svc_rqst * rqstp,struct nlm_res * resp)188 __nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp)
189 {
190 	struct nlm_args *argp = rqstp->rq_argp;
191 	struct nlm_host	*host;
192 	struct nlm_file	*file;
193 	struct net *net = SVC_NET(rqstp);
194 
195 	dprintk("lockd: CANCEL        called\n");
196 
197 	resp->cookie = argp->cookie;
198 
199 	/* Don't accept requests during grace period */
200 	if (locks_in_grace(net)) {
201 		resp->status = nlm_lck_denied_grace_period;
202 		return rpc_success;
203 	}
204 
205 	/* Obtain client and file */
206 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
207 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
208 
209 	/* Try to cancel request. */
210 	resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock));
211 
212 	dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
213 	nlmsvc_release_host(host);
214 	nlm_release_file(file);
215 	return rpc_success;
216 }
217 
218 static __be32
nlmsvc_proc_cancel(struct svc_rqst * rqstp)219 nlmsvc_proc_cancel(struct svc_rqst *rqstp)
220 {
221 	return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp);
222 }
223 
224 /*
225  * UNLOCK: release a lock
226  */
227 static __be32
__nlmsvc_proc_unlock(struct svc_rqst * rqstp,struct nlm_res * resp)228 __nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp)
229 {
230 	struct nlm_args *argp = rqstp->rq_argp;
231 	struct nlm_host	*host;
232 	struct nlm_file	*file;
233 	struct net *net = SVC_NET(rqstp);
234 
235 	dprintk("lockd: UNLOCK        called\n");
236 
237 	resp->cookie = argp->cookie;
238 
239 	/* Don't accept new lock requests during grace period */
240 	if (locks_in_grace(net)) {
241 		resp->status = nlm_lck_denied_grace_period;
242 		return rpc_success;
243 	}
244 
245 	/* Obtain client and file */
246 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
247 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
248 
249 	/* Now try to remove the lock */
250 	resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock));
251 
252 	dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
253 	nlmsvc_release_host(host);
254 	nlm_release_file(file);
255 	return rpc_success;
256 }
257 
258 static __be32
nlmsvc_proc_unlock(struct svc_rqst * rqstp)259 nlmsvc_proc_unlock(struct svc_rqst *rqstp)
260 {
261 	return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp);
262 }
263 
264 /*
265  * GRANTED: A server calls us to tell that a process' lock request
266  * was granted
267  */
268 static __be32
__nlmsvc_proc_granted(struct svc_rqst * rqstp,struct nlm_res * resp)269 __nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp)
270 {
271 	struct nlm_args *argp = rqstp->rq_argp;
272 
273 	resp->cookie = argp->cookie;
274 
275 	dprintk("lockd: GRANTED       called\n");
276 	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
277 	dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
278 	return rpc_success;
279 }
280 
281 static __be32
nlmsvc_proc_granted(struct svc_rqst * rqstp)282 nlmsvc_proc_granted(struct svc_rqst *rqstp)
283 {
284 	return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp);
285 }
286 
287 /*
288  * This is the generic lockd callback for async RPC calls
289  */
nlmsvc_callback_exit(struct rpc_task * task,void * data)290 static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
291 {
292 	dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
293 			-task->tk_status);
294 }
295 
nlmsvc_release_call(struct nlm_rqst * call)296 void nlmsvc_release_call(struct nlm_rqst *call)
297 {
298 	if (!refcount_dec_and_test(&call->a_count))
299 		return;
300 	nlmsvc_release_host(call->a_host);
301 	kfree(call);
302 }
303 
nlmsvc_callback_release(void * data)304 static void nlmsvc_callback_release(void *data)
305 {
306 	nlmsvc_release_call(data);
307 }
308 
309 static const struct rpc_call_ops nlmsvc_callback_ops = {
310 	.rpc_call_done = nlmsvc_callback_exit,
311 	.rpc_release = nlmsvc_callback_release,
312 };
313 
314 /*
315  * `Async' versions of the above service routines. They aren't really,
316  * because we send the callback before the reply proper. I hope this
317  * doesn't break any clients.
318  */
nlmsvc_callback(struct svc_rqst * rqstp,u32 proc,__be32 (* func)(struct svc_rqst *,struct nlm_res *))319 static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc,
320 		__be32 (*func)(struct svc_rqst *, struct nlm_res *))
321 {
322 	struct nlm_args *argp = rqstp->rq_argp;
323 	struct nlm_host	*host;
324 	struct nlm_rqst	*call;
325 	__be32 stat;
326 
327 	host = nlmsvc_lookup_host(rqstp,
328 				  argp->lock.caller,
329 				  argp->lock.len);
330 	if (host == NULL)
331 		return rpc_system_err;
332 
333 	call = nlm_alloc_call(host);
334 	nlmsvc_release_host(host);
335 	if (call == NULL)
336 		return rpc_system_err;
337 
338 	stat = func(rqstp, &call->a_res);
339 	if (stat != 0) {
340 		nlmsvc_release_call(call);
341 		return stat;
342 	}
343 
344 	call->a_flags = RPC_TASK_ASYNC;
345 	if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
346 		return rpc_system_err;
347 	return rpc_success;
348 }
349 
nlmsvc_proc_test_msg(struct svc_rqst * rqstp)350 static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp)
351 {
352 	dprintk("lockd: TEST_MSG      called\n");
353 	return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test);
354 }
355 
nlmsvc_proc_lock_msg(struct svc_rqst * rqstp)356 static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp)
357 {
358 	dprintk("lockd: LOCK_MSG      called\n");
359 	return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock);
360 }
361 
nlmsvc_proc_cancel_msg(struct svc_rqst * rqstp)362 static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp)
363 {
364 	dprintk("lockd: CANCEL_MSG    called\n");
365 	return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel);
366 }
367 
368 static __be32
nlmsvc_proc_unlock_msg(struct svc_rqst * rqstp)369 nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp)
370 {
371 	dprintk("lockd: UNLOCK_MSG    called\n");
372 	return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock);
373 }
374 
375 static __be32
nlmsvc_proc_granted_msg(struct svc_rqst * rqstp)376 nlmsvc_proc_granted_msg(struct svc_rqst *rqstp)
377 {
378 	dprintk("lockd: GRANTED_MSG   called\n");
379 	return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted);
380 }
381 
382 /*
383  * SHARE: create a DOS share or alter existing share.
384  */
385 static __be32
nlmsvc_proc_share(struct svc_rqst * rqstp)386 nlmsvc_proc_share(struct svc_rqst *rqstp)
387 {
388 	struct nlm_args *argp = rqstp->rq_argp;
389 	struct nlm_res *resp = rqstp->rq_resp;
390 	struct nlm_host	*host;
391 	struct nlm_file	*file;
392 
393 	dprintk("lockd: SHARE         called\n");
394 
395 	resp->cookie = argp->cookie;
396 
397 	/* Don't accept new lock requests during grace period */
398 	if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
399 		resp->status = nlm_lck_denied_grace_period;
400 		return rpc_success;
401 	}
402 
403 	/* Obtain client and file */
404 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
405 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
406 
407 	/* Now try to create the share */
408 	resp->status = cast_status(nlmsvc_share_file(host, file, argp));
409 
410 	dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
411 	nlmsvc_release_host(host);
412 	nlm_release_file(file);
413 	return rpc_success;
414 }
415 
416 /*
417  * UNSHARE: Release a DOS share.
418  */
419 static __be32
nlmsvc_proc_unshare(struct svc_rqst * rqstp)420 nlmsvc_proc_unshare(struct svc_rqst *rqstp)
421 {
422 	struct nlm_args *argp = rqstp->rq_argp;
423 	struct nlm_res *resp = rqstp->rq_resp;
424 	struct nlm_host	*host;
425 	struct nlm_file	*file;
426 
427 	dprintk("lockd: UNSHARE       called\n");
428 
429 	resp->cookie = argp->cookie;
430 
431 	/* Don't accept requests during grace period */
432 	if (locks_in_grace(SVC_NET(rqstp))) {
433 		resp->status = nlm_lck_denied_grace_period;
434 		return rpc_success;
435 	}
436 
437 	/* Obtain client and file */
438 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
439 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
440 
441 	/* Now try to unshare the file */
442 	resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));
443 
444 	dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
445 	nlmsvc_release_host(host);
446 	nlm_release_file(file);
447 	return rpc_success;
448 }
449 
450 /*
451  * NM_LOCK: Create an unmonitored lock
452  */
453 static __be32
nlmsvc_proc_nm_lock(struct svc_rqst * rqstp)454 nlmsvc_proc_nm_lock(struct svc_rqst *rqstp)
455 {
456 	struct nlm_args *argp = rqstp->rq_argp;
457 
458 	dprintk("lockd: NM_LOCK       called\n");
459 
460 	argp->monitor = 0;		/* just clean the monitor flag */
461 	return nlmsvc_proc_lock(rqstp);
462 }
463 
464 /*
465  * FREE_ALL: Release all locks and shares held by client
466  */
467 static __be32
nlmsvc_proc_free_all(struct svc_rqst * rqstp)468 nlmsvc_proc_free_all(struct svc_rqst *rqstp)
469 {
470 	struct nlm_args *argp = rqstp->rq_argp;
471 	struct nlm_host	*host;
472 
473 	/* Obtain client */
474 	if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
475 		return rpc_success;
476 
477 	nlmsvc_free_host_resources(host);
478 	nlmsvc_release_host(host);
479 	return rpc_success;
480 }
481 
482 /*
483  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
484  */
485 static __be32
nlmsvc_proc_sm_notify(struct svc_rqst * rqstp)486 nlmsvc_proc_sm_notify(struct svc_rqst *rqstp)
487 {
488 	struct nlm_reboot *argp = rqstp->rq_argp;
489 
490 	dprintk("lockd: SM_NOTIFY     called\n");
491 
492 	if (!nlm_privileged_requester(rqstp)) {
493 		char buf[RPC_MAX_ADDRBUFLEN];
494 		printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
495 				svc_print_addr(rqstp, buf, sizeof(buf)));
496 		return rpc_system_err;
497 	}
498 
499 	nlm_host_rebooted(SVC_NET(rqstp), argp);
500 	return rpc_success;
501 }
502 
503 /*
504  * client sent a GRANTED_RES, let's remove the associated block
505  */
506 static __be32
nlmsvc_proc_granted_res(struct svc_rqst * rqstp)507 nlmsvc_proc_granted_res(struct svc_rqst *rqstp)
508 {
509 	struct nlm_res *argp = rqstp->rq_argp;
510 
511 	if (!nlmsvc_ops)
512 		return rpc_success;
513 
514 	dprintk("lockd: GRANTED_RES   called\n");
515 
516 	nlmsvc_grant_reply(&argp->cookie, argp->status);
517 	return rpc_success;
518 }
519 
520 /*
521  * NLM Server procedures.
522  */
523 
524 #define nlmsvc_encode_norep	nlmsvc_encode_void
525 #define nlmsvc_decode_norep	nlmsvc_decode_void
526 #define nlmsvc_decode_testres	nlmsvc_decode_void
527 #define nlmsvc_decode_lockres	nlmsvc_decode_void
528 #define nlmsvc_decode_unlockres	nlmsvc_decode_void
529 #define nlmsvc_decode_cancelres	nlmsvc_decode_void
530 #define nlmsvc_decode_grantedres	nlmsvc_decode_void
531 
532 #define nlmsvc_proc_none	nlmsvc_proc_null
533 #define nlmsvc_proc_test_res	nlmsvc_proc_null
534 #define nlmsvc_proc_lock_res	nlmsvc_proc_null
535 #define nlmsvc_proc_cancel_res	nlmsvc_proc_null
536 #define nlmsvc_proc_unlock_res	nlmsvc_proc_null
537 
538 struct nlm_void			{ int dummy; };
539 
540 #define PROC(name, xargt, xrest, argt, rest, respsize)	\
541  { .pc_func	= nlmsvc_proc_##name,			\
542    .pc_decode	= nlmsvc_decode_##xargt,		\
543    .pc_encode	= nlmsvc_encode_##xrest,		\
544    .pc_release	= NULL,					\
545    .pc_argsize	= sizeof(struct nlm_##argt),		\
546    .pc_ressize	= sizeof(struct nlm_##rest),		\
547    .pc_xdrressize = respsize,				\
548  }
549 
550 #define	Ck	(1+XDR_QUADLEN(NLM_MAXCOOKIELEN))	/* cookie */
551 #define	St	1				/* status */
552 #define	No	(1+1024/4)			/* Net Obj */
553 #define	Rg	2				/* range - offset + size */
554 
555 const struct svc_procedure nlmsvc_procedures[] = {
556   PROC(null,		void,		void,		void,	void, 1),
557   PROC(test,		testargs,	testres,	args,	res, Ck+St+2+No+Rg),
558   PROC(lock,		lockargs,	res,		args,	res, Ck+St),
559   PROC(cancel,		cancargs,	res,		args,	res, Ck+St),
560   PROC(unlock,		unlockargs,	res,		args,	res, Ck+St),
561   PROC(granted,		testargs,	res,		args,	res, Ck+St),
562   PROC(test_msg,	testargs,	norep,		args,	void, 1),
563   PROC(lock_msg,	lockargs,	norep,		args,	void, 1),
564   PROC(cancel_msg,	cancargs,	norep,		args,	void, 1),
565   PROC(unlock_msg,	unlockargs,	norep,		args,	void, 1),
566   PROC(granted_msg,	testargs,	norep,		args,	void, 1),
567   PROC(test_res,	testres,	norep,		res,	void, 1),
568   PROC(lock_res,	lockres,	norep,		res,	void, 1),
569   PROC(cancel_res,	cancelres,	norep,		res,	void, 1),
570   PROC(unlock_res,	unlockres,	norep,		res,	void, 1),
571   PROC(granted_res,	res,		norep,		res,	void, 1),
572   /* statd callback */
573   PROC(sm_notify,	reboot,		void,		reboot,	void, 1),
574   PROC(none,		void,		void,		void,	void, 1),
575   PROC(none,		void,		void,		void,	void, 1),
576   PROC(none,		void,		void,		void,	void, 1),
577   PROC(share,		shareargs,	shareres,	args,	res, Ck+St+1),
578   PROC(unshare,		shareargs,	shareres,	args,	res, Ck+St+1),
579   PROC(nm_lock,		lockargs,	res,		args,	res, Ck+St),
580   PROC(free_all,	notify,		void,		args,	void, 0),
581 
582 };
583