xref: /openbmc/linux/fs/lockd/svcproc.c (revision a2cce7a9)
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, void *argp, void *resp)
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_args *argp,
106 				         struct nlm_res  *resp)
107 {
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_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
134 				         struct nlm_res  *resp)
135 {
136 	struct nlm_host	*host;
137 	struct nlm_file	*file;
138 	__be32 rc = rpc_success;
139 
140 	dprintk("lockd: LOCK          called\n");
141 
142 	resp->cookie = argp->cookie;
143 
144 	/* Obtain client and file */
145 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
146 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
147 
148 #if 0
149 	/* If supplied state doesn't match current state, we assume it's
150 	 * an old request that time-warped somehow. Any error return would
151 	 * do in this case because it's irrelevant anyway.
152 	 *
153 	 * NB: We don't retrieve the remote host's state yet.
154 	 */
155 	if (host->h_nsmstate && host->h_nsmstate != argp->state) {
156 		resp->status = nlm_lck_denied_nolocks;
157 	} else
158 #endif
159 
160 	/* Now try to lock the file */
161 	resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock,
162 					       argp->block, &argp->cookie,
163 					       argp->reclaim));
164 	if (resp->status == nlm_drop_reply)
165 		rc = rpc_drop_reply;
166 	else
167 		dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
168 
169 	nlmsvc_release_host(host);
170 	nlm_release_file(file);
171 	return rc;
172 }
173 
174 static __be32
175 nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
176 				           struct nlm_res  *resp)
177 {
178 	struct nlm_host	*host;
179 	struct nlm_file	*file;
180 	struct net *net = SVC_NET(rqstp);
181 
182 	dprintk("lockd: CANCEL        called\n");
183 
184 	resp->cookie = argp->cookie;
185 
186 	/* Don't accept requests during grace period */
187 	if (locks_in_grace(net)) {
188 		resp->status = nlm_lck_denied_grace_period;
189 		return rpc_success;
190 	}
191 
192 	/* Obtain client and file */
193 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
194 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
195 
196 	/* Try to cancel request. */
197 	resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock));
198 
199 	dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
200 	nlmsvc_release_host(host);
201 	nlm_release_file(file);
202 	return rpc_success;
203 }
204 
205 /*
206  * UNLOCK: release a lock
207  */
208 static __be32
209 nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
210 				           struct nlm_res  *resp)
211 {
212 	struct nlm_host	*host;
213 	struct nlm_file	*file;
214 	struct net *net = SVC_NET(rqstp);
215 
216 	dprintk("lockd: UNLOCK        called\n");
217 
218 	resp->cookie = argp->cookie;
219 
220 	/* Don't accept new lock requests during grace period */
221 	if (locks_in_grace(net)) {
222 		resp->status = nlm_lck_denied_grace_period;
223 		return rpc_success;
224 	}
225 
226 	/* Obtain client and file */
227 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
228 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
229 
230 	/* Now try to remove the lock */
231 	resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock));
232 
233 	dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
234 	nlmsvc_release_host(host);
235 	nlm_release_file(file);
236 	return rpc_success;
237 }
238 
239 /*
240  * GRANTED: A server calls us to tell that a process' lock request
241  * was granted
242  */
243 static __be32
244 nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
245 				            struct nlm_res  *resp)
246 {
247 	resp->cookie = argp->cookie;
248 
249 	dprintk("lockd: GRANTED       called\n");
250 	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
251 	dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
252 	return rpc_success;
253 }
254 
255 /*
256  * This is the generic lockd callback for async RPC calls
257  */
258 static void nlmsvc_callback_exit(struct rpc_task *task, void *data)
259 {
260 	dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
261 			-task->tk_status);
262 }
263 
264 void nlmsvc_release_call(struct nlm_rqst *call)
265 {
266 	if (!atomic_dec_and_test(&call->a_count))
267 		return;
268 	nlmsvc_release_host(call->a_host);
269 	kfree(call);
270 }
271 
272 static void nlmsvc_callback_release(void *data)
273 {
274 	nlmsvc_release_call(data);
275 }
276 
277 static const struct rpc_call_ops nlmsvc_callback_ops = {
278 	.rpc_call_done = nlmsvc_callback_exit,
279 	.rpc_release = nlmsvc_callback_release,
280 };
281 
282 /*
283  * `Async' versions of the above service routines. They aren't really,
284  * because we send the callback before the reply proper. I hope this
285  * doesn't break any clients.
286  */
287 static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
288 		__be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res  *))
289 {
290 	struct nlm_host	*host;
291 	struct nlm_rqst	*call;
292 	__be32 stat;
293 
294 	host = nlmsvc_lookup_host(rqstp,
295 				  argp->lock.caller,
296 				  argp->lock.len);
297 	if (host == NULL)
298 		return rpc_system_err;
299 
300 	call = nlm_alloc_call(host);
301 	nlmsvc_release_host(host);
302 	if (call == NULL)
303 		return rpc_system_err;
304 
305 	stat = func(rqstp, argp, &call->a_res);
306 	if (stat != 0) {
307 		nlmsvc_release_call(call);
308 		return stat;
309 	}
310 
311 	call->a_flags = RPC_TASK_ASYNC;
312 	if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0)
313 		return rpc_system_err;
314 	return rpc_success;
315 }
316 
317 static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
318 					     void	     *resp)
319 {
320 	dprintk("lockd: TEST_MSG      called\n");
321 	return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, argp, nlmsvc_proc_test);
322 }
323 
324 static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
325 					     void	     *resp)
326 {
327 	dprintk("lockd: LOCK_MSG      called\n");
328 	return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlmsvc_proc_lock);
329 }
330 
331 static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
332 					       void	       *resp)
333 {
334 	dprintk("lockd: CANCEL_MSG    called\n");
335 	return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlmsvc_proc_cancel);
336 }
337 
338 static __be32
339 nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
340                                                void            *resp)
341 {
342 	dprintk("lockd: UNLOCK_MSG    called\n");
343 	return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlmsvc_proc_unlock);
344 }
345 
346 static __be32
347 nlmsvc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
348                                                 void            *resp)
349 {
350 	dprintk("lockd: GRANTED_MSG   called\n");
351 	return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlmsvc_proc_granted);
352 }
353 
354 /*
355  * SHARE: create a DOS share or alter existing share.
356  */
357 static __be32
358 nlmsvc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
359 				          struct nlm_res  *resp)
360 {
361 	struct nlm_host	*host;
362 	struct nlm_file	*file;
363 
364 	dprintk("lockd: SHARE         called\n");
365 
366 	resp->cookie = argp->cookie;
367 
368 	/* Don't accept new lock requests during grace period */
369 	if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) {
370 		resp->status = nlm_lck_denied_grace_period;
371 		return rpc_success;
372 	}
373 
374 	/* Obtain client and file */
375 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
376 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
377 
378 	/* Now try to create the share */
379 	resp->status = cast_status(nlmsvc_share_file(host, file, argp));
380 
381 	dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
382 	nlmsvc_release_host(host);
383 	nlm_release_file(file);
384 	return rpc_success;
385 }
386 
387 /*
388  * UNSHARE: Release a DOS share.
389  */
390 static __be32
391 nlmsvc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
392 				            struct nlm_res  *resp)
393 {
394 	struct nlm_host	*host;
395 	struct nlm_file	*file;
396 
397 	dprintk("lockd: UNSHARE       called\n");
398 
399 	resp->cookie = argp->cookie;
400 
401 	/* Don't accept requests during grace period */
402 	if (locks_in_grace(SVC_NET(rqstp))) {
403 		resp->status = nlm_lck_denied_grace_period;
404 		return rpc_success;
405 	}
406 
407 	/* Obtain client and file */
408 	if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file)))
409 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
410 
411 	/* Now try to unshare the file */
412 	resp->status = cast_status(nlmsvc_unshare_file(host, file, argp));
413 
414 	dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
415 	nlmsvc_release_host(host);
416 	nlm_release_file(file);
417 	return rpc_success;
418 }
419 
420 /*
421  * NM_LOCK: Create an unmonitored lock
422  */
423 static __be32
424 nlmsvc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
425 				            struct nlm_res  *resp)
426 {
427 	dprintk("lockd: NM_LOCK       called\n");
428 
429 	argp->monitor = 0;		/* just clean the monitor flag */
430 	return nlmsvc_proc_lock(rqstp, argp, resp);
431 }
432 
433 /*
434  * FREE_ALL: Release all locks and shares held by client
435  */
436 static __be32
437 nlmsvc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
438 					     void            *resp)
439 {
440 	struct nlm_host	*host;
441 
442 	/* Obtain client */
443 	if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL))
444 		return rpc_success;
445 
446 	nlmsvc_free_host_resources(host);
447 	nlmsvc_release_host(host);
448 	return rpc_success;
449 }
450 
451 /*
452  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
453  */
454 static __be32
455 nlmsvc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
456 					      void	        *resp)
457 {
458 	dprintk("lockd: SM_NOTIFY     called\n");
459 
460 	if (!nlm_privileged_requester(rqstp)) {
461 		char buf[RPC_MAX_ADDRBUFLEN];
462 		printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
463 				svc_print_addr(rqstp, buf, sizeof(buf)));
464 		return rpc_system_err;
465 	}
466 
467 	nlm_host_rebooted(argp);
468 	return rpc_success;
469 }
470 
471 /*
472  * client sent a GRANTED_RES, let's remove the associated block
473  */
474 static __be32
475 nlmsvc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
476                                                 void            *resp)
477 {
478 	if (!nlmsvc_ops)
479 		return rpc_success;
480 
481 	dprintk("lockd: GRANTED_RES   called\n");
482 
483 	nlmsvc_grant_reply(&argp->cookie, argp->status);
484 	return rpc_success;
485 }
486 
487 /*
488  * NLM Server procedures.
489  */
490 
491 #define nlmsvc_encode_norep	nlmsvc_encode_void
492 #define nlmsvc_decode_norep	nlmsvc_decode_void
493 #define nlmsvc_decode_testres	nlmsvc_decode_void
494 #define nlmsvc_decode_lockres	nlmsvc_decode_void
495 #define nlmsvc_decode_unlockres	nlmsvc_decode_void
496 #define nlmsvc_decode_cancelres	nlmsvc_decode_void
497 #define nlmsvc_decode_grantedres	nlmsvc_decode_void
498 
499 #define nlmsvc_proc_none	nlmsvc_proc_null
500 #define nlmsvc_proc_test_res	nlmsvc_proc_null
501 #define nlmsvc_proc_lock_res	nlmsvc_proc_null
502 #define nlmsvc_proc_cancel_res	nlmsvc_proc_null
503 #define nlmsvc_proc_unlock_res	nlmsvc_proc_null
504 
505 struct nlm_void			{ int dummy; };
506 
507 #define PROC(name, xargt, xrest, argt, rest, respsize)	\
508  { .pc_func	= (svc_procfunc) nlmsvc_proc_##name,	\
509    .pc_decode	= (kxdrproc_t) nlmsvc_decode_##xargt,	\
510    .pc_encode	= (kxdrproc_t) nlmsvc_encode_##xrest,	\
511    .pc_release	= NULL,					\
512    .pc_argsize	= sizeof(struct nlm_##argt),		\
513    .pc_ressize	= sizeof(struct nlm_##rest),		\
514    .pc_xdrressize = respsize,				\
515  }
516 
517 #define	Ck	(1+XDR_QUADLEN(NLM_MAXCOOKIELEN))	/* cookie */
518 #define	St	1				/* status */
519 #define	No	(1+1024/4)			/* Net Obj */
520 #define	Rg	2				/* range - offset + size */
521 
522 struct svc_procedure		nlmsvc_procedures[] = {
523   PROC(null,		void,		void,		void,	void, 1),
524   PROC(test,		testargs,	testres,	args,	res, Ck+St+2+No+Rg),
525   PROC(lock,		lockargs,	res,		args,	res, Ck+St),
526   PROC(cancel,		cancargs,	res,		args,	res, Ck+St),
527   PROC(unlock,		unlockargs,	res,		args,	res, Ck+St),
528   PROC(granted,		testargs,	res,		args,	res, Ck+St),
529   PROC(test_msg,	testargs,	norep,		args,	void, 1),
530   PROC(lock_msg,	lockargs,	norep,		args,	void, 1),
531   PROC(cancel_msg,	cancargs,	norep,		args,	void, 1),
532   PROC(unlock_msg,	unlockargs,	norep,		args,	void, 1),
533   PROC(granted_msg,	testargs,	norep,		args,	void, 1),
534   PROC(test_res,	testres,	norep,		res,	void, 1),
535   PROC(lock_res,	lockres,	norep,		res,	void, 1),
536   PROC(cancel_res,	cancelres,	norep,		res,	void, 1),
537   PROC(unlock_res,	unlockres,	norep,		res,	void, 1),
538   PROC(granted_res,	res,		norep,		res,	void, 1),
539   /* statd callback */
540   PROC(sm_notify,	reboot,		void,		reboot,	void, 1),
541   PROC(none,		void,		void,		void,	void, 1),
542   PROC(none,		void,		void,		void,	void, 1),
543   PROC(none,		void,		void,		void,	void, 1),
544   PROC(share,		shareargs,	shareres,	args,	res, Ck+St+1),
545   PROC(unshare,		shareargs,	shareres,	args,	res, Ck+St+1),
546   PROC(nm_lock,		lockargs,	res,		args,	res, Ck+St),
547   PROC(free_all,	notify,		void,		args,	void, 0),
548 
549 };
550