1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/lockd/svcproc.c
5 * Lockd server procedures. We don't implement the NLM_*_RES
6 * procedures because we don't use the async procedures.
8 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
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>
17 #define NLMDBG_FACILITY NLMDBG_CLIENT
19 #ifdef CONFIG_LOCKD_V4
21 cast_to_nlm(__be32 status
, u32 vers
)
23 /* Note: status is assumed to be in network byte order !!! */
28 case nlm_lck_denied_nolocks
:
30 case nlm_lck_denied_grace_period
:
34 status
= nlm_lck_denied
;
37 status
= nlm_lck_denied_nolocks
;
43 #define cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
45 #define cast_status(status) (status)
49 * Obtain client and file from arguments
52 nlmsvc_retrieve_args(struct svc_rqst
*rqstp
, struct nlm_args
*argp
,
53 struct nlm_host
**hostp
, struct nlm_file
**filp
)
55 struct nlm_host
*host
= NULL
;
56 struct nlm_file
*file
= NULL
;
57 struct nlm_lock
*lock
= &argp
->lock
;
60 /* nfsd callbacks must have been installed for this procedure */
62 return nlm_lck_denied_nolocks
;
64 /* Obtain host handle */
65 if (!(host
= nlmsvc_lookup_host(rqstp
, lock
->caller
, lock
->len
))
66 || (argp
->monitor
&& nsm_monitor(host
) < 0))
70 /* Obtain file pointer. Not used by FREE_ALL call. */
72 error
= cast_status(nlm_lookup_file(rqstp
, &file
, &lock
->fh
));
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
;
86 nlmsvc_release_host(host
);
89 return nlm_lck_denied_nolocks
;
93 * NULL: Test for presence of service
96 nlmsvc_proc_null(struct svc_rqst
*rqstp
)
98 dprintk("lockd: NULL called\n");
103 * TEST: Check for conflicting lock
106 __nlmsvc_proc_test(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
108 struct nlm_args
*argp
= rqstp
->rq_argp
;
109 struct nlm_host
*host
;
110 struct nlm_file
*file
;
111 __be32 rc
= rpc_success
;
113 dprintk("lockd: TEST called\n");
114 resp
->cookie
= argp
->cookie
;
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
;
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
)
125 dprintk("lockd: TEST status %d vers %d\n",
126 ntohl(resp
->status
), rqstp
->rq_vers
);
128 nlmsvc_release_host(host
);
129 nlm_release_file(file
);
134 nlmsvc_proc_test(struct svc_rqst
*rqstp
)
136 return __nlmsvc_proc_test(rqstp
, rqstp
->rq_resp
);
140 __nlmsvc_proc_lock(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
142 struct nlm_args
*argp
= rqstp
->rq_argp
;
143 struct nlm_host
*host
;
144 struct nlm_file
*file
;
145 __be32 rc
= rpc_success
;
147 dprintk("lockd: LOCK called\n");
149 resp
->cookie
= argp
->cookie
;
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
;
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.
160 * NB: We don't retrieve the remote host's state yet.
162 if (host
->h_nsmstate
&& host
->h_nsmstate
!= argp
->state
) {
163 resp
->status
= nlm_lck_denied_nolocks
;
167 /* Now try to lock the file */
168 resp
->status
= cast_status(nlmsvc_lock(rqstp
, file
, host
, &argp
->lock
,
169 argp
->block
, &argp
->cookie
,
171 if (resp
->status
== nlm_drop_reply
)
174 dprintk("lockd: LOCK status %d\n", ntohl(resp
->status
));
176 nlmsvc_release_host(host
);
177 nlm_release_file(file
);
182 nlmsvc_proc_lock(struct svc_rqst
*rqstp
)
184 return __nlmsvc_proc_lock(rqstp
, rqstp
->rq_resp
);
188 __nlmsvc_proc_cancel(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
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
);
195 dprintk("lockd: CANCEL called\n");
197 resp
->cookie
= argp
->cookie
;
199 /* Don't accept requests during grace period */
200 if (locks_in_grace(net
)) {
201 resp
->status
= nlm_lck_denied_grace_period
;
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
;
209 /* Try to cancel request. */
210 resp
->status
= cast_status(nlmsvc_cancel_blocked(net
, file
, &argp
->lock
));
212 dprintk("lockd: CANCEL status %d\n", ntohl(resp
->status
));
213 nlmsvc_release_host(host
);
214 nlm_release_file(file
);
219 nlmsvc_proc_cancel(struct svc_rqst
*rqstp
)
221 return __nlmsvc_proc_cancel(rqstp
, rqstp
->rq_resp
);
225 * UNLOCK: release a lock
228 __nlmsvc_proc_unlock(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
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
);
235 dprintk("lockd: UNLOCK called\n");
237 resp
->cookie
= argp
->cookie
;
239 /* Don't accept new lock requests during grace period */
240 if (locks_in_grace(net
)) {
241 resp
->status
= nlm_lck_denied_grace_period
;
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
;
249 /* Now try to remove the lock */
250 resp
->status
= cast_status(nlmsvc_unlock(net
, file
, &argp
->lock
));
252 dprintk("lockd: UNLOCK status %d\n", ntohl(resp
->status
));
253 nlmsvc_release_host(host
);
254 nlm_release_file(file
);
259 nlmsvc_proc_unlock(struct svc_rqst
*rqstp
)
261 return __nlmsvc_proc_unlock(rqstp
, rqstp
->rq_resp
);
265 * GRANTED: A server calls us to tell that a process' lock request
269 __nlmsvc_proc_granted(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
271 struct nlm_args
*argp
= rqstp
->rq_argp
;
273 resp
->cookie
= argp
->cookie
;
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
));
282 nlmsvc_proc_granted(struct svc_rqst
*rqstp
)
284 return __nlmsvc_proc_granted(rqstp
, rqstp
->rq_resp
);
288 * This is the generic lockd callback for async RPC calls
290 static void nlmsvc_callback_exit(struct rpc_task
*task
, void *data
)
292 dprintk("lockd: %5u callback returned %d\n", task
->tk_pid
,
296 void nlmsvc_release_call(struct nlm_rqst
*call
)
298 if (!refcount_dec_and_test(&call
->a_count
))
300 nlmsvc_release_host(call
->a_host
);
304 static void nlmsvc_callback_release(void *data
)
306 nlmsvc_release_call(data
);
309 static const struct rpc_call_ops nlmsvc_callback_ops
= {
310 .rpc_call_done
= nlmsvc_callback_exit
,
311 .rpc_release
= nlmsvc_callback_release
,
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.
319 static __be32
nlmsvc_callback(struct svc_rqst
*rqstp
, u32 proc
,
320 __be32 (*func
)(struct svc_rqst
*, struct nlm_res
*))
322 struct nlm_args
*argp
= rqstp
->rq_argp
;
323 struct nlm_host
*host
;
324 struct nlm_rqst
*call
;
327 host
= nlmsvc_lookup_host(rqstp
,
331 return rpc_system_err
;
333 call
= nlm_alloc_call(host
);
334 nlmsvc_release_host(host
);
336 return rpc_system_err
;
338 stat
= func(rqstp
, &call
->a_res
);
340 nlmsvc_release_call(call
);
344 call
->a_flags
= RPC_TASK_ASYNC
;
345 if (nlm_async_reply(call
, proc
, &nlmsvc_callback_ops
) < 0)
346 return rpc_system_err
;
350 static __be32
nlmsvc_proc_test_msg(struct svc_rqst
*rqstp
)
352 dprintk("lockd: TEST_MSG called\n");
353 return nlmsvc_callback(rqstp
, NLMPROC_TEST_RES
, __nlmsvc_proc_test
);
356 static __be32
nlmsvc_proc_lock_msg(struct svc_rqst
*rqstp
)
358 dprintk("lockd: LOCK_MSG called\n");
359 return nlmsvc_callback(rqstp
, NLMPROC_LOCK_RES
, __nlmsvc_proc_lock
);
362 static __be32
nlmsvc_proc_cancel_msg(struct svc_rqst
*rqstp
)
364 dprintk("lockd: CANCEL_MSG called\n");
365 return nlmsvc_callback(rqstp
, NLMPROC_CANCEL_RES
, __nlmsvc_proc_cancel
);
369 nlmsvc_proc_unlock_msg(struct svc_rqst
*rqstp
)
371 dprintk("lockd: UNLOCK_MSG called\n");
372 return nlmsvc_callback(rqstp
, NLMPROC_UNLOCK_RES
, __nlmsvc_proc_unlock
);
376 nlmsvc_proc_granted_msg(struct svc_rqst
*rqstp
)
378 dprintk("lockd: GRANTED_MSG called\n");
379 return nlmsvc_callback(rqstp
, NLMPROC_GRANTED_RES
, __nlmsvc_proc_granted
);
383 * SHARE: create a DOS share or alter existing share.
386 nlmsvc_proc_share(struct svc_rqst
*rqstp
)
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
;
393 dprintk("lockd: SHARE called\n");
395 resp
->cookie
= argp
->cookie
;
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
;
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
;
407 /* Now try to create the share */
408 resp
->status
= cast_status(nlmsvc_share_file(host
, file
, argp
));
410 dprintk("lockd: SHARE status %d\n", ntohl(resp
->status
));
411 nlmsvc_release_host(host
);
412 nlm_release_file(file
);
417 * UNSHARE: Release a DOS share.
420 nlmsvc_proc_unshare(struct svc_rqst
*rqstp
)
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
;
427 dprintk("lockd: UNSHARE called\n");
429 resp
->cookie
= argp
->cookie
;
431 /* Don't accept requests during grace period */
432 if (locks_in_grace(SVC_NET(rqstp
))) {
433 resp
->status
= nlm_lck_denied_grace_period
;
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
;
441 /* Now try to unshare the file */
442 resp
->status
= cast_status(nlmsvc_unshare_file(host
, file
, argp
));
444 dprintk("lockd: UNSHARE status %d\n", ntohl(resp
->status
));
445 nlmsvc_release_host(host
);
446 nlm_release_file(file
);
451 * NM_LOCK: Create an unmonitored lock
454 nlmsvc_proc_nm_lock(struct svc_rqst
*rqstp
)
456 struct nlm_args
*argp
= rqstp
->rq_argp
;
458 dprintk("lockd: NM_LOCK called\n");
460 argp
->monitor
= 0; /* just clean the monitor flag */
461 return nlmsvc_proc_lock(rqstp
);
465 * FREE_ALL: Release all locks and shares held by client
468 nlmsvc_proc_free_all(struct svc_rqst
*rqstp
)
470 struct nlm_args
*argp
= rqstp
->rq_argp
;
471 struct nlm_host
*host
;
474 if (nlmsvc_retrieve_args(rqstp
, argp
, &host
, NULL
))
477 nlmsvc_free_host_resources(host
);
478 nlmsvc_release_host(host
);
483 * SM_NOTIFY: private callback from statd (not part of official NLM proto)
486 nlmsvc_proc_sm_notify(struct svc_rqst
*rqstp
)
488 struct nlm_reboot
*argp
= rqstp
->rq_argp
;
490 dprintk("lockd: SM_NOTIFY called\n");
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
;
499 nlm_host_rebooted(SVC_NET(rqstp
), argp
);
504 * client sent a GRANTED_RES, let's remove the associated block
507 nlmsvc_proc_granted_res(struct svc_rqst
*rqstp
)
509 struct nlm_res
*argp
= rqstp
->rq_argp
;
514 dprintk("lockd: GRANTED_RES called\n");
516 nlmsvc_grant_reply(&argp
->cookie
, argp
->status
);
521 * NLM Server procedures.
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
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
538 struct nlm_void
{ int dummy
; };
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, \
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 */
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),
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),