2 * linux/fs/lockd/svcproc.c
4 * Lockd server procedures. We don't implement the NLM_*_RES
5 * procedures because we don't use the async procedures.
7 * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
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>
16 #define NLMDBG_FACILITY NLMDBG_CLIENT
18 #ifdef CONFIG_LOCKD_V4
20 cast_to_nlm(__be32 status
, u32 vers
)
22 /* Note: status is assumed to be in network byte order !!! */
27 case nlm_lck_denied_nolocks
:
29 case nlm_lck_denied_grace_period
:
33 status
= nlm_lck_denied
;
36 status
= nlm_lck_denied_nolocks
;
42 #define cast_status(status) (cast_to_nlm(status, rqstp->rq_vers))
44 #define cast_status(status) (status)
48 * Obtain client and file from arguments
51 nlmsvc_retrieve_args(struct svc_rqst
*rqstp
, struct nlm_args
*argp
,
52 struct nlm_host
**hostp
, struct nlm_file
**filp
)
54 struct nlm_host
*host
= NULL
;
55 struct nlm_file
*file
= NULL
;
56 struct nlm_lock
*lock
= &argp
->lock
;
59 /* nfsd callbacks must have been installed for this procedure */
61 return nlm_lck_denied_nolocks
;
63 /* Obtain host handle */
64 if (!(host
= nlmsvc_lookup_host(rqstp
, lock
->caller
, lock
->len
))
65 || (argp
->monitor
&& nsm_monitor(host
) < 0))
69 /* Obtain file pointer. Not used by FREE_ALL call. */
71 error
= cast_status(nlm_lookup_file(rqstp
, &file
, &lock
->fh
));
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
;
85 nlmsvc_release_host(host
);
88 return nlm_lck_denied_nolocks
;
92 * NULL: Test for presence of service
95 nlmsvc_proc_null(struct svc_rqst
*rqstp
)
97 dprintk("lockd: NULL called\n");
102 * TEST: Check for conflicting lock
105 __nlmsvc_proc_test(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
107 struct nlm_args
*argp
= rqstp
->rq_argp
;
108 struct nlm_host
*host
;
109 struct nlm_file
*file
;
110 __be32 rc
= rpc_success
;
112 dprintk("lockd: TEST called\n");
113 resp
->cookie
= argp
->cookie
;
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
;
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
)
124 dprintk("lockd: TEST status %d vers %d\n",
125 ntohl(resp
->status
), rqstp
->rq_vers
);
127 nlmsvc_release_host(host
);
128 nlm_release_file(file
);
133 nlmsvc_proc_test(struct svc_rqst
*rqstp
)
135 return __nlmsvc_proc_test(rqstp
, rqstp
->rq_resp
);
139 __nlmsvc_proc_lock(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
141 struct nlm_args
*argp
= rqstp
->rq_argp
;
142 struct nlm_host
*host
;
143 struct nlm_file
*file
;
144 __be32 rc
= rpc_success
;
146 dprintk("lockd: LOCK called\n");
148 resp
->cookie
= argp
->cookie
;
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
;
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.
159 * NB: We don't retrieve the remote host's state yet.
161 if (host
->h_nsmstate
&& host
->h_nsmstate
!= argp
->state
) {
162 resp
->status
= nlm_lck_denied_nolocks
;
166 /* Now try to lock the file */
167 resp
->status
= cast_status(nlmsvc_lock(rqstp
, file
, host
, &argp
->lock
,
168 argp
->block
, &argp
->cookie
,
170 if (resp
->status
== nlm_drop_reply
)
173 dprintk("lockd: LOCK status %d\n", ntohl(resp
->status
));
175 nlmsvc_release_host(host
);
176 nlm_release_file(file
);
181 nlmsvc_proc_lock(struct svc_rqst
*rqstp
)
183 return __nlmsvc_proc_lock(rqstp
, rqstp
->rq_resp
);
187 __nlmsvc_proc_cancel(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
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
);
194 dprintk("lockd: CANCEL called\n");
196 resp
->cookie
= argp
->cookie
;
198 /* Don't accept requests during grace period */
199 if (locks_in_grace(net
)) {
200 resp
->status
= nlm_lck_denied_grace_period
;
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
;
208 /* Try to cancel request. */
209 resp
->status
= cast_status(nlmsvc_cancel_blocked(net
, file
, &argp
->lock
));
211 dprintk("lockd: CANCEL status %d\n", ntohl(resp
->status
));
212 nlmsvc_release_host(host
);
213 nlm_release_file(file
);
218 nlmsvc_proc_cancel(struct svc_rqst
*rqstp
)
220 return __nlmsvc_proc_cancel(rqstp
, rqstp
->rq_resp
);
224 * UNLOCK: release a lock
227 __nlmsvc_proc_unlock(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
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
);
234 dprintk("lockd: UNLOCK called\n");
236 resp
->cookie
= argp
->cookie
;
238 /* Don't accept new lock requests during grace period */
239 if (locks_in_grace(net
)) {
240 resp
->status
= nlm_lck_denied_grace_period
;
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
;
248 /* Now try to remove the lock */
249 resp
->status
= cast_status(nlmsvc_unlock(net
, file
, &argp
->lock
));
251 dprintk("lockd: UNLOCK status %d\n", ntohl(resp
->status
));
252 nlmsvc_release_host(host
);
253 nlm_release_file(file
);
258 nlmsvc_proc_unlock(struct svc_rqst
*rqstp
)
260 return __nlmsvc_proc_unlock(rqstp
, rqstp
->rq_resp
);
264 * GRANTED: A server calls us to tell that a process' lock request
268 __nlmsvc_proc_granted(struct svc_rqst
*rqstp
, struct nlm_res
*resp
)
270 struct nlm_args
*argp
= rqstp
->rq_argp
;
272 resp
->cookie
= argp
->cookie
;
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
));
281 nlmsvc_proc_granted(struct svc_rqst
*rqstp
)
283 return __nlmsvc_proc_granted(rqstp
, rqstp
->rq_resp
);
287 * This is the generic lockd callback for async RPC calls
289 static void nlmsvc_callback_exit(struct rpc_task
*task
, void *data
)
291 dprintk("lockd: %5u callback returned %d\n", task
->tk_pid
,
295 void nlmsvc_release_call(struct nlm_rqst
*call
)
297 if (!atomic_dec_and_test(&call
->a_count
))
299 nlmsvc_release_host(call
->a_host
);
303 static void nlmsvc_callback_release(void *data
)
305 nlmsvc_release_call(data
);
308 static const struct rpc_call_ops nlmsvc_callback_ops
= {
309 .rpc_call_done
= nlmsvc_callback_exit
,
310 .rpc_release
= nlmsvc_callback_release
,
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.
318 static __be32
nlmsvc_callback(struct svc_rqst
*rqstp
, u32 proc
,
319 __be32 (*func
)(struct svc_rqst
*, struct nlm_res
*))
321 struct nlm_args
*argp
= rqstp
->rq_argp
;
322 struct nlm_host
*host
;
323 struct nlm_rqst
*call
;
326 host
= nlmsvc_lookup_host(rqstp
,
330 return rpc_system_err
;
332 call
= nlm_alloc_call(host
);
333 nlmsvc_release_host(host
);
335 return rpc_system_err
;
337 stat
= func(rqstp
, &call
->a_res
);
339 nlmsvc_release_call(call
);
343 call
->a_flags
= RPC_TASK_ASYNC
;
344 if (nlm_async_reply(call
, proc
, &nlmsvc_callback_ops
) < 0)
345 return rpc_system_err
;
349 static __be32
nlmsvc_proc_test_msg(struct svc_rqst
*rqstp
)
351 dprintk("lockd: TEST_MSG called\n");
352 return nlmsvc_callback(rqstp
, NLMPROC_TEST_RES
, __nlmsvc_proc_test
);
355 static __be32
nlmsvc_proc_lock_msg(struct svc_rqst
*rqstp
)
357 dprintk("lockd: LOCK_MSG called\n");
358 return nlmsvc_callback(rqstp
, NLMPROC_LOCK_RES
, __nlmsvc_proc_lock
);
361 static __be32
nlmsvc_proc_cancel_msg(struct svc_rqst
*rqstp
)
363 dprintk("lockd: CANCEL_MSG called\n");
364 return nlmsvc_callback(rqstp
, NLMPROC_CANCEL_RES
, __nlmsvc_proc_cancel
);
368 nlmsvc_proc_unlock_msg(struct svc_rqst
*rqstp
)
370 dprintk("lockd: UNLOCK_MSG called\n");
371 return nlmsvc_callback(rqstp
, NLMPROC_UNLOCK_RES
, __nlmsvc_proc_unlock
);
375 nlmsvc_proc_granted_msg(struct svc_rqst
*rqstp
)
377 dprintk("lockd: GRANTED_MSG called\n");
378 return nlmsvc_callback(rqstp
, NLMPROC_GRANTED_RES
, __nlmsvc_proc_granted
);
382 * SHARE: create a DOS share or alter existing share.
385 nlmsvc_proc_share(struct svc_rqst
*rqstp
)
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
;
392 dprintk("lockd: SHARE called\n");
394 resp
->cookie
= argp
->cookie
;
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
;
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
;
406 /* Now try to create the share */
407 resp
->status
= cast_status(nlmsvc_share_file(host
, file
, argp
));
409 dprintk("lockd: SHARE status %d\n", ntohl(resp
->status
));
410 nlmsvc_release_host(host
);
411 nlm_release_file(file
);
416 * UNSHARE: Release a DOS share.
419 nlmsvc_proc_unshare(struct svc_rqst
*rqstp
)
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
;
426 dprintk("lockd: UNSHARE called\n");
428 resp
->cookie
= argp
->cookie
;
430 /* Don't accept requests during grace period */
431 if (locks_in_grace(SVC_NET(rqstp
))) {
432 resp
->status
= nlm_lck_denied_grace_period
;
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
;
440 /* Now try to unshare the file */
441 resp
->status
= cast_status(nlmsvc_unshare_file(host
, file
, argp
));
443 dprintk("lockd: UNSHARE status %d\n", ntohl(resp
->status
));
444 nlmsvc_release_host(host
);
445 nlm_release_file(file
);
450 * NM_LOCK: Create an unmonitored lock
453 nlmsvc_proc_nm_lock(struct svc_rqst
*rqstp
)
455 struct nlm_args
*argp
= rqstp
->rq_argp
;
457 dprintk("lockd: NM_LOCK called\n");
459 argp
->monitor
= 0; /* just clean the monitor flag */
460 return nlmsvc_proc_lock(rqstp
);
464 * FREE_ALL: Release all locks and shares held by client
467 nlmsvc_proc_free_all(struct svc_rqst
*rqstp
)
469 struct nlm_args
*argp
= rqstp
->rq_argp
;
470 struct nlm_host
*host
;
473 if (nlmsvc_retrieve_args(rqstp
, argp
, &host
, NULL
))
476 nlmsvc_free_host_resources(host
);
477 nlmsvc_release_host(host
);
482 * SM_NOTIFY: private callback from statd (not part of official NLM proto)
485 nlmsvc_proc_sm_notify(struct svc_rqst
*rqstp
)
487 struct nlm_reboot
*argp
= rqstp
->rq_argp
;
489 dprintk("lockd: SM_NOTIFY called\n");
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
;
498 nlm_host_rebooted(SVC_NET(rqstp
), argp
);
503 * client sent a GRANTED_RES, let's remove the associated block
506 nlmsvc_proc_granted_res(struct svc_rqst
*rqstp
)
508 struct nlm_res
*argp
= rqstp
->rq_argp
;
513 dprintk("lockd: GRANTED_RES called\n");
515 nlmsvc_grant_reply(&argp
->cookie
, argp
->status
);
520 * NLM Server procedures.
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
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
537 struct nlm_void
{ int dummy
; };
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, \
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 */
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),
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),