xref: /openbmc/linux/fs/lockd/svc4proc.c (revision 7dd65feb)
1 /*
2  * linux/fs/lockd/svc4proc.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/slab.h>
13 #include <linux/smp_lock.h>
14 #include <linux/lockd/lockd.h>
15 #include <linux/lockd/share.h>
16 
17 #define NLMDBG_FACILITY		NLMDBG_CLIENT
18 
19 /*
20  * Obtain client and file from arguments
21  */
22 static __be32
23 nlm4svc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp,
24 			struct nlm_host **hostp, struct nlm_file **filp)
25 {
26 	struct nlm_host		*host = NULL;
27 	struct nlm_file		*file = NULL;
28 	struct nlm_lock		*lock = &argp->lock;
29 	__be32			error = 0;
30 
31 	/* nfsd callbacks must have been installed for this procedure */
32 	if (!nlmsvc_ops)
33 		return nlm_lck_denied_nolocks;
34 
35 	/* Obtain host handle */
36 	if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len))
37 	 || (argp->monitor && nsm_monitor(host) < 0))
38 		goto no_locks;
39 	*hostp = host;
40 
41 	/* Obtain file pointer. Not used by FREE_ALL call. */
42 	if (filp != NULL) {
43 		if ((error = nlm_lookup_file(rqstp, &file, &lock->fh)) != 0)
44 			goto no_locks;
45 		*filp = file;
46 
47 		/* Set up the missing parts of the file_lock structure */
48 		lock->fl.fl_file  = file->f_file;
49 		lock->fl.fl_owner = (fl_owner_t) host;
50 		lock->fl.fl_lmops = &nlmsvc_lock_operations;
51 	}
52 
53 	return 0;
54 
55 no_locks:
56 	nlm_release_host(host);
57  	if (error)
58 		return error;
59 	return nlm_lck_denied_nolocks;
60 }
61 
62 /*
63  * NULL: Test for presence of service
64  */
65 static __be32
66 nlm4svc_proc_null(struct svc_rqst *rqstp, void *argp, void *resp)
67 {
68 	dprintk("lockd: NULL          called\n");
69 	return rpc_success;
70 }
71 
72 /*
73  * TEST: Check for conflicting lock
74  */
75 static __be32
76 nlm4svc_proc_test(struct svc_rqst *rqstp, struct nlm_args *argp,
77 				         struct nlm_res  *resp)
78 {
79 	struct nlm_host	*host;
80 	struct nlm_file	*file;
81 	__be32 rc = rpc_success;
82 
83 	dprintk("lockd: TEST4        called\n");
84 	resp->cookie = argp->cookie;
85 
86 	/* Obtain client and file */
87 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
88 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
89 
90 	/* Now check for conflicting locks */
91 	resp->status = nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie);
92 	if (resp->status == nlm_drop_reply)
93 		rc = rpc_drop_reply;
94 	else
95 		dprintk("lockd: TEST4        status %d\n", ntohl(resp->status));
96 
97 	nlm_release_host(host);
98 	nlm_release_file(file);
99 	return rc;
100 }
101 
102 static __be32
103 nlm4svc_proc_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
104 				         struct nlm_res  *resp)
105 {
106 	struct nlm_host	*host;
107 	struct nlm_file	*file;
108 	__be32 rc = rpc_success;
109 
110 	dprintk("lockd: LOCK          called\n");
111 
112 	resp->cookie = argp->cookie;
113 
114 	/* Obtain client and file */
115 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
116 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
117 
118 #if 0
119 	/* If supplied state doesn't match current state, we assume it's
120 	 * an old request that time-warped somehow. Any error return would
121 	 * do in this case because it's irrelevant anyway.
122 	 *
123 	 * NB: We don't retrieve the remote host's state yet.
124 	 */
125 	if (host->h_nsmstate && host->h_nsmstate != argp->state) {
126 		resp->status = nlm_lck_denied_nolocks;
127 	} else
128 #endif
129 
130 	/* Now try to lock the file */
131 	resp->status = nlmsvc_lock(rqstp, file, host, &argp->lock,
132 					argp->block, &argp->cookie,
133 					argp->reclaim);
134 	if (resp->status == nlm_drop_reply)
135 		rc = rpc_drop_reply;
136 	else
137 		dprintk("lockd: LOCK         status %d\n", ntohl(resp->status));
138 
139 	nlm_release_host(host);
140 	nlm_release_file(file);
141 	return rc;
142 }
143 
144 static __be32
145 nlm4svc_proc_cancel(struct svc_rqst *rqstp, struct nlm_args *argp,
146 				           struct nlm_res  *resp)
147 {
148 	struct nlm_host	*host;
149 	struct nlm_file	*file;
150 
151 	dprintk("lockd: CANCEL        called\n");
152 
153 	resp->cookie = argp->cookie;
154 
155 	/* Don't accept requests during grace period */
156 	if (locks_in_grace()) {
157 		resp->status = nlm_lck_denied_grace_period;
158 		return rpc_success;
159 	}
160 
161 	/* Obtain client and file */
162 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
163 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
164 
165 	/* Try to cancel request. */
166 	resp->status = nlmsvc_cancel_blocked(file, &argp->lock);
167 
168 	dprintk("lockd: CANCEL        status %d\n", ntohl(resp->status));
169 	nlm_release_host(host);
170 	nlm_release_file(file);
171 	return rpc_success;
172 }
173 
174 /*
175  * UNLOCK: release a lock
176  */
177 static __be32
178 nlm4svc_proc_unlock(struct svc_rqst *rqstp, struct nlm_args *argp,
179 				           struct nlm_res  *resp)
180 {
181 	struct nlm_host	*host;
182 	struct nlm_file	*file;
183 
184 	dprintk("lockd: UNLOCK        called\n");
185 
186 	resp->cookie = argp->cookie;
187 
188 	/* Don't accept new lock requests during grace period */
189 	if (locks_in_grace()) {
190 		resp->status = nlm_lck_denied_grace_period;
191 		return rpc_success;
192 	}
193 
194 	/* Obtain client and file */
195 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
196 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
197 
198 	/* Now try to remove the lock */
199 	resp->status = nlmsvc_unlock(file, &argp->lock);
200 
201 	dprintk("lockd: UNLOCK        status %d\n", ntohl(resp->status));
202 	nlm_release_host(host);
203 	nlm_release_file(file);
204 	return rpc_success;
205 }
206 
207 /*
208  * GRANTED: A server calls us to tell that a process' lock request
209  * was granted
210  */
211 static __be32
212 nlm4svc_proc_granted(struct svc_rqst *rqstp, struct nlm_args *argp,
213 				            struct nlm_res  *resp)
214 {
215 	resp->cookie = argp->cookie;
216 
217 	dprintk("lockd: GRANTED       called\n");
218 	resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock);
219 	dprintk("lockd: GRANTED       status %d\n", ntohl(resp->status));
220 	return rpc_success;
221 }
222 
223 /*
224  * This is the generic lockd callback for async RPC calls
225  */
226 static void nlm4svc_callback_exit(struct rpc_task *task, void *data)
227 {
228 	dprintk("lockd: %5u callback returned %d\n", task->tk_pid,
229 			-task->tk_status);
230 }
231 
232 static void nlm4svc_callback_release(void *data)
233 {
234 	lock_kernel();
235 	nlm_release_call(data);
236 	unlock_kernel();
237 }
238 
239 static const struct rpc_call_ops nlm4svc_callback_ops = {
240 	.rpc_call_done = nlm4svc_callback_exit,
241 	.rpc_release = nlm4svc_callback_release,
242 };
243 
244 /*
245  * `Async' versions of the above service routines. They aren't really,
246  * because we send the callback before the reply proper. I hope this
247  * doesn't break any clients.
248  */
249 static __be32 nlm4svc_callback(struct svc_rqst *rqstp, u32 proc, struct nlm_args *argp,
250 		__be32 (*func)(struct svc_rqst *, struct nlm_args *, struct nlm_res  *))
251 {
252 	struct nlm_host	*host;
253 	struct nlm_rqst	*call;
254 	__be32 stat;
255 
256 	host = nlmsvc_lookup_host(rqstp,
257 				  argp->lock.caller,
258 				  argp->lock.len);
259 	if (host == NULL)
260 		return rpc_system_err;
261 
262 	call = nlm_alloc_call(host);
263 	if (call == NULL)
264 		return rpc_system_err;
265 
266 	stat = func(rqstp, argp, &call->a_res);
267 	if (stat != 0) {
268 		nlm_release_call(call);
269 		return stat;
270 	}
271 
272 	call->a_flags = RPC_TASK_ASYNC;
273 	if (nlm_async_reply(call, proc, &nlm4svc_callback_ops) < 0)
274 		return rpc_system_err;
275 	return rpc_success;
276 }
277 
278 static __be32 nlm4svc_proc_test_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
279 					     void	     *resp)
280 {
281 	dprintk("lockd: TEST_MSG      called\n");
282 	return nlm4svc_callback(rqstp, NLMPROC_TEST_RES, argp, nlm4svc_proc_test);
283 }
284 
285 static __be32 nlm4svc_proc_lock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
286 					     void	     *resp)
287 {
288 	dprintk("lockd: LOCK_MSG      called\n");
289 	return nlm4svc_callback(rqstp, NLMPROC_LOCK_RES, argp, nlm4svc_proc_lock);
290 }
291 
292 static __be32 nlm4svc_proc_cancel_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
293 					       void	       *resp)
294 {
295 	dprintk("lockd: CANCEL_MSG    called\n");
296 	return nlm4svc_callback(rqstp, NLMPROC_CANCEL_RES, argp, nlm4svc_proc_cancel);
297 }
298 
299 static __be32 nlm4svc_proc_unlock_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
300                                                void            *resp)
301 {
302 	dprintk("lockd: UNLOCK_MSG    called\n");
303 	return nlm4svc_callback(rqstp, NLMPROC_UNLOCK_RES, argp, nlm4svc_proc_unlock);
304 }
305 
306 static __be32 nlm4svc_proc_granted_msg(struct svc_rqst *rqstp, struct nlm_args *argp,
307                                                 void            *resp)
308 {
309 	dprintk("lockd: GRANTED_MSG   called\n");
310 	return nlm4svc_callback(rqstp, NLMPROC_GRANTED_RES, argp, nlm4svc_proc_granted);
311 }
312 
313 /*
314  * SHARE: create a DOS share or alter existing share.
315  */
316 static __be32
317 nlm4svc_proc_share(struct svc_rqst *rqstp, struct nlm_args *argp,
318 				          struct nlm_res  *resp)
319 {
320 	struct nlm_host	*host;
321 	struct nlm_file	*file;
322 
323 	dprintk("lockd: SHARE         called\n");
324 
325 	resp->cookie = argp->cookie;
326 
327 	/* Don't accept new lock requests during grace period */
328 	if (locks_in_grace() && !argp->reclaim) {
329 		resp->status = nlm_lck_denied_grace_period;
330 		return rpc_success;
331 	}
332 
333 	/* Obtain client and file */
334 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
335 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
336 
337 	/* Now try to create the share */
338 	resp->status = nlmsvc_share_file(host, file, argp);
339 
340 	dprintk("lockd: SHARE         status %d\n", ntohl(resp->status));
341 	nlm_release_host(host);
342 	nlm_release_file(file);
343 	return rpc_success;
344 }
345 
346 /*
347  * UNSHARE: Release a DOS share.
348  */
349 static __be32
350 nlm4svc_proc_unshare(struct svc_rqst *rqstp, struct nlm_args *argp,
351 				            struct nlm_res  *resp)
352 {
353 	struct nlm_host	*host;
354 	struct nlm_file	*file;
355 
356 	dprintk("lockd: UNSHARE       called\n");
357 
358 	resp->cookie = argp->cookie;
359 
360 	/* Don't accept requests during grace period */
361 	if (locks_in_grace()) {
362 		resp->status = nlm_lck_denied_grace_period;
363 		return rpc_success;
364 	}
365 
366 	/* Obtain client and file */
367 	if ((resp->status = nlm4svc_retrieve_args(rqstp, argp, &host, &file)))
368 		return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success;
369 
370 	/* Now try to lock the file */
371 	resp->status = nlmsvc_unshare_file(host, file, argp);
372 
373 	dprintk("lockd: UNSHARE       status %d\n", ntohl(resp->status));
374 	nlm_release_host(host);
375 	nlm_release_file(file);
376 	return rpc_success;
377 }
378 
379 /*
380  * NM_LOCK: Create an unmonitored lock
381  */
382 static __be32
383 nlm4svc_proc_nm_lock(struct svc_rqst *rqstp, struct nlm_args *argp,
384 				            struct nlm_res  *resp)
385 {
386 	dprintk("lockd: NM_LOCK       called\n");
387 
388 	argp->monitor = 0;		/* just clean the monitor flag */
389 	return nlm4svc_proc_lock(rqstp, argp, resp);
390 }
391 
392 /*
393  * FREE_ALL: Release all locks and shares held by client
394  */
395 static __be32
396 nlm4svc_proc_free_all(struct svc_rqst *rqstp, struct nlm_args *argp,
397 					     void            *resp)
398 {
399 	struct nlm_host	*host;
400 
401 	/* Obtain client */
402 	if (nlm4svc_retrieve_args(rqstp, argp, &host, NULL))
403 		return rpc_success;
404 
405 	nlmsvc_free_host_resources(host);
406 	nlm_release_host(host);
407 	return rpc_success;
408 }
409 
410 /*
411  * SM_NOTIFY: private callback from statd (not part of official NLM proto)
412  */
413 static __be32
414 nlm4svc_proc_sm_notify(struct svc_rqst *rqstp, struct nlm_reboot *argp,
415 					      void	        *resp)
416 {
417 	dprintk("lockd: SM_NOTIFY     called\n");
418 
419 	if (!nlm_privileged_requester(rqstp)) {
420 		char buf[RPC_MAX_ADDRBUFLEN];
421 		printk(KERN_WARNING "lockd: rejected NSM callback from %s\n",
422 				svc_print_addr(rqstp, buf, sizeof(buf)));
423 		return rpc_system_err;
424 	}
425 
426 	nlm_host_rebooted(argp);
427 	return rpc_success;
428 }
429 
430 /*
431  * client sent a GRANTED_RES, let's remove the associated block
432  */
433 static __be32
434 nlm4svc_proc_granted_res(struct svc_rqst *rqstp, struct nlm_res  *argp,
435                                                 void            *resp)
436 {
437         if (!nlmsvc_ops)
438                 return rpc_success;
439 
440         dprintk("lockd: GRANTED_RES   called\n");
441 
442         nlmsvc_grant_reply(&argp->cookie, argp->status);
443         return rpc_success;
444 }
445 
446 
447 /*
448  * NLM Server procedures.
449  */
450 
451 #define nlm4svc_encode_norep	nlm4svc_encode_void
452 #define nlm4svc_decode_norep	nlm4svc_decode_void
453 #define nlm4svc_decode_testres	nlm4svc_decode_void
454 #define nlm4svc_decode_lockres	nlm4svc_decode_void
455 #define nlm4svc_decode_unlockres	nlm4svc_decode_void
456 #define nlm4svc_decode_cancelres	nlm4svc_decode_void
457 #define nlm4svc_decode_grantedres	nlm4svc_decode_void
458 
459 #define nlm4svc_proc_none	nlm4svc_proc_null
460 #define nlm4svc_proc_test_res	nlm4svc_proc_null
461 #define nlm4svc_proc_lock_res	nlm4svc_proc_null
462 #define nlm4svc_proc_cancel_res	nlm4svc_proc_null
463 #define nlm4svc_proc_unlock_res	nlm4svc_proc_null
464 
465 struct nlm_void			{ int dummy; };
466 
467 #define PROC(name, xargt, xrest, argt, rest, respsize)	\
468  { .pc_func	= (svc_procfunc) nlm4svc_proc_##name,	\
469    .pc_decode	= (kxdrproc_t) nlm4svc_decode_##xargt,	\
470    .pc_encode	= (kxdrproc_t) nlm4svc_encode_##xrest,	\
471    .pc_release	= NULL,					\
472    .pc_argsize	= sizeof(struct nlm_##argt),		\
473    .pc_ressize	= sizeof(struct nlm_##rest),		\
474    .pc_xdrressize = respsize,				\
475  }
476 #define	Ck	(1+XDR_QUADLEN(NLM_MAXCOOKIELEN))	/* cookie */
477 #define	No	(1+1024/4)				/* netobj */
478 #define	St	1					/* status */
479 #define	Rg	4					/* range (offset + length) */
480 struct svc_procedure		nlmsvc_procedures4[] = {
481   PROC(null,		void,		void,		void,	void, 1),
482   PROC(test,		testargs,	testres,	args,	res, Ck+St+2+No+Rg),
483   PROC(lock,		lockargs,	res,		args,	res, Ck+St),
484   PROC(cancel,		cancargs,	res,		args,	res, Ck+St),
485   PROC(unlock,		unlockargs,	res,		args,	res, Ck+St),
486   PROC(granted,		testargs,	res,		args,	res, Ck+St),
487   PROC(test_msg,	testargs,	norep,		args,	void, 1),
488   PROC(lock_msg,	lockargs,	norep,		args,	void, 1),
489   PROC(cancel_msg,	cancargs,	norep,		args,	void, 1),
490   PROC(unlock_msg,	unlockargs,	norep,		args,	void, 1),
491   PROC(granted_msg,	testargs,	norep,		args,	void, 1),
492   PROC(test_res,	testres,	norep,		res,	void, 1),
493   PROC(lock_res,	lockres,	norep,		res,	void, 1),
494   PROC(cancel_res,	cancelres,	norep,		res,	void, 1),
495   PROC(unlock_res,	unlockres,	norep,		res,	void, 1),
496   PROC(granted_res,	res,		norep,		res,	void, 1),
497   /* statd callback */
498   PROC(sm_notify,	reboot,		void,		reboot,	void, 1),
499   PROC(none,		void,		void,		void,	void, 0),
500   PROC(none,		void,		void,		void,	void, 0),
501   PROC(none,		void,		void,		void,	void, 0),
502   PROC(share,		shareargs,	shareres,	args,	res, Ck+St+1),
503   PROC(unshare,		shareargs,	shareres,	args,	res, Ck+St+1),
504   PROC(nm_lock,		lockargs,	res,		args,	res, Ck+St),
505   PROC(free_all,	notify,		void,		args,	void, 1),
506 
507 };
508