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