]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/fs/lockd/svcproc.c | |
4 | * | |
5 | * Lockd server procedures. We don't implement the NLM_*_RES | |
6 | * procedures because we don't use the async procedures. | |
7 | * | |
8 | * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de> | |
9 | */ | |
10 | ||
1da177e4 LT |
11 | #include <linux/types.h> |
12 | #include <linux/time.h> | |
1da177e4 LT |
13 | #include <linux/lockd/lockd.h> |
14 | #include <linux/lockd/share.h> | |
5ccb0066 | 15 | #include <linux/sunrpc/svc_xprt.h> |
1da177e4 LT |
16 | |
17 | #define NLMDBG_FACILITY NLMDBG_CLIENT | |
18 | ||
1da177e4 | 19 | #ifdef CONFIG_LOCKD_V4 |
52921e02 AV |
20 | static __be32 |
21 | cast_to_nlm(__be32 status, u32 vers) | |
1da177e4 LT |
22 | { |
23 | /* Note: status is assumed to be in network byte order !!! */ | |
24 | if (vers != 4){ | |
25 | switch (status) { | |
26 | case nlm_granted: | |
27 | case nlm_lck_denied: | |
28 | case nlm_lck_denied_nolocks: | |
29 | case nlm_lck_blocked: | |
30 | case nlm_lck_denied_grace_period: | |
5ea0d750 | 31 | case nlm_drop_reply: |
1da177e4 LT |
32 | break; |
33 | case nlm4_deadlock: | |
34 | status = nlm_lck_denied; | |
35 | break; | |
36 | default: | |
37 | status = nlm_lck_denied_nolocks; | |
38 | } | |
39 | } | |
40 | ||
41 | return (status); | |
42 | } | |
43 | #define cast_status(status) (cast_to_nlm(status, rqstp->rq_vers)) | |
44 | #else | |
45 | #define cast_status(status) (status) | |
46 | #endif | |
47 | ||
48 | /* | |
49 | * Obtain client and file from arguments | |
50 | */ | |
52921e02 | 51 | static __be32 |
1da177e4 LT |
52 | nlmsvc_retrieve_args(struct svc_rqst *rqstp, struct nlm_args *argp, |
53 | struct nlm_host **hostp, struct nlm_file **filp) | |
54 | { | |
55 | struct nlm_host *host = NULL; | |
56 | struct nlm_file *file = NULL; | |
57 | struct nlm_lock *lock = &argp->lock; | |
52921e02 | 58 | __be32 error = 0; |
1da177e4 LT |
59 | |
60 | /* nfsd callbacks must have been installed for this procedure */ | |
61 | if (!nlmsvc_ops) | |
62 | return nlm_lck_denied_nolocks; | |
63 | ||
64 | /* Obtain host handle */ | |
db4e4c9a | 65 | if (!(host = nlmsvc_lookup_host(rqstp, lock->caller, lock->len)) |
977faf39 | 66 | || (argp->monitor && nsm_monitor(host) < 0)) |
1da177e4 LT |
67 | goto no_locks; |
68 | *hostp = host; | |
69 | ||
70 | /* Obtain file pointer. Not used by FREE_ALL call. */ | |
71 | if (filp != NULL) { | |
cd0b16c1 TM |
72 | error = cast_status(nlm_lookup_file(rqstp, &file, &lock->fh)); |
73 | if (error != 0) | |
1da177e4 LT |
74 | goto no_locks; |
75 | *filp = file; | |
76 | ||
77 | /* Set up the missing parts of the file_lock structure */ | |
78 | lock->fl.fl_file = file->f_file; | |
646d73e9 | 79 | lock->fl.fl_pid = current->tgid; |
1da177e4 | 80 | lock->fl.fl_lmops = &nlmsvc_lock_operations; |
89e0edfb BC |
81 | nlmsvc_locks_init_private(&lock->fl, host, (pid_t)lock->svid); |
82 | if (!lock->fl.fl_owner) { | |
83 | /* lockowner allocation has failed */ | |
84 | nlmsvc_release_host(host); | |
85 | return nlm_lck_denied_nolocks; | |
86 | } | |
1da177e4 LT |
87 | } |
88 | ||
89 | return 0; | |
90 | ||
91 | no_locks: | |
67216b94 | 92 | nlmsvc_release_host(host); |
d343fce1 N |
93 | if (error) |
94 | return error; | |
1da177e4 LT |
95 | return nlm_lck_denied_nolocks; |
96 | } | |
97 | ||
98 | /* | |
99 | * NULL: Test for presence of service | |
100 | */ | |
7111c66e | 101 | static __be32 |
a6beb732 | 102 | nlmsvc_proc_null(struct svc_rqst *rqstp) |
1da177e4 LT |
103 | { |
104 | dprintk("lockd: NULL called\n"); | |
105 | return rpc_success; | |
106 | } | |
107 | ||
108 | /* | |
109 | * TEST: Check for conflicting lock | |
110 | */ | |
7111c66e | 111 | static __be32 |
a6beb732 | 112 | __nlmsvc_proc_test(struct svc_rqst *rqstp, struct nlm_res *resp) |
1da177e4 | 113 | { |
a6beb732 | 114 | struct nlm_args *argp = rqstp->rq_argp; |
1da177e4 LT |
115 | struct nlm_host *host; |
116 | struct nlm_file *file; | |
317602f3 | 117 | __be32 rc = rpc_success; |
1da177e4 LT |
118 | |
119 | dprintk("lockd: TEST called\n"); | |
120 | resp->cookie = argp->cookie; | |
121 | ||
1da177e4 LT |
122 | /* Obtain client and file */ |
123 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 124 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
125 | |
126 | /* Now check for conflicting locks */ | |
8f920d5e | 127 | resp->status = cast_status(nlmsvc_testlock(rqstp, file, host, &argp->lock, &resp->lock, &resp->cookie)); |
5ea0d750 | 128 | if (resp->status == nlm_drop_reply) |
b7e6b869 OD |
129 | rc = rpc_drop_reply; |
130 | else | |
131 | dprintk("lockd: TEST status %d vers %d\n", | |
132 | ntohl(resp->status), rqstp->rq_vers); | |
1da177e4 | 133 | |
89e0edfb | 134 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 135 | nlmsvc_release_host(host); |
1da177e4 | 136 | nlm_release_file(file); |
b7e6b869 | 137 | return rc; |
1da177e4 LT |
138 | } |
139 | ||
7111c66e | 140 | static __be32 |
a6beb732 | 141 | nlmsvc_proc_test(struct svc_rqst *rqstp) |
1da177e4 | 142 | { |
a6beb732 CH |
143 | return __nlmsvc_proc_test(rqstp, rqstp->rq_resp); |
144 | } | |
145 | ||
146 | static __be32 | |
147 | __nlmsvc_proc_lock(struct svc_rqst *rqstp, struct nlm_res *resp) | |
148 | { | |
149 | struct nlm_args *argp = rqstp->rq_argp; | |
1da177e4 LT |
150 | struct nlm_host *host; |
151 | struct nlm_file *file; | |
317602f3 | 152 | __be32 rc = rpc_success; |
1da177e4 LT |
153 | |
154 | dprintk("lockd: LOCK called\n"); | |
155 | ||
156 | resp->cookie = argp->cookie; | |
157 | ||
1da177e4 LT |
158 | /* Obtain client and file */ |
159 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 160 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
161 | |
162 | #if 0 | |
163 | /* If supplied state doesn't match current state, we assume it's | |
164 | * an old request that time-warped somehow. Any error return would | |
165 | * do in this case because it's irrelevant anyway. | |
166 | * | |
167 | * NB: We don't retrieve the remote host's state yet. | |
168 | */ | |
169 | if (host->h_nsmstate && host->h_nsmstate != argp->state) { | |
170 | resp->status = nlm_lck_denied_nolocks; | |
171 | } else | |
172 | #endif | |
173 | ||
174 | /* Now try to lock the file */ | |
6cde4de8 | 175 | resp->status = cast_status(nlmsvc_lock(rqstp, file, host, &argp->lock, |
b2b50289 BF |
176 | argp->block, &argp->cookie, |
177 | argp->reclaim)); | |
1a8322b2 | 178 | if (resp->status == nlm_drop_reply) |
b7e6b869 OD |
179 | rc = rpc_drop_reply; |
180 | else | |
181 | dprintk("lockd: LOCK status %d\n", ntohl(resp->status)); | |
1da177e4 | 182 | |
89e0edfb | 183 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 184 | nlmsvc_release_host(host); |
1da177e4 | 185 | nlm_release_file(file); |
b7e6b869 | 186 | return rc; |
1da177e4 LT |
187 | } |
188 | ||
7111c66e | 189 | static __be32 |
a6beb732 CH |
190 | nlmsvc_proc_lock(struct svc_rqst *rqstp) |
191 | { | |
192 | return __nlmsvc_proc_lock(rqstp, rqstp->rq_resp); | |
193 | } | |
194 | ||
195 | static __be32 | |
196 | __nlmsvc_proc_cancel(struct svc_rqst *rqstp, struct nlm_res *resp) | |
1da177e4 | 197 | { |
a6beb732 | 198 | struct nlm_args *argp = rqstp->rq_argp; |
1da177e4 LT |
199 | struct nlm_host *host; |
200 | struct nlm_file *file; | |
5ccb0066 | 201 | struct net *net = SVC_NET(rqstp); |
1da177e4 LT |
202 | |
203 | dprintk("lockd: CANCEL called\n"); | |
204 | ||
205 | resp->cookie = argp->cookie; | |
206 | ||
207 | /* Don't accept requests during grace period */ | |
5ccb0066 | 208 | if (locks_in_grace(net)) { |
1da177e4 LT |
209 | resp->status = nlm_lck_denied_grace_period; |
210 | return rpc_success; | |
211 | } | |
212 | ||
213 | /* Obtain client and file */ | |
214 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 215 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
216 | |
217 | /* Try to cancel request. */ | |
5ccb0066 | 218 | resp->status = cast_status(nlmsvc_cancel_blocked(net, file, &argp->lock)); |
1da177e4 LT |
219 | |
220 | dprintk("lockd: CANCEL status %d\n", ntohl(resp->status)); | |
89e0edfb | 221 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 222 | nlmsvc_release_host(host); |
1da177e4 LT |
223 | nlm_release_file(file); |
224 | return rpc_success; | |
225 | } | |
226 | ||
a6beb732 CH |
227 | static __be32 |
228 | nlmsvc_proc_cancel(struct svc_rqst *rqstp) | |
229 | { | |
230 | return __nlmsvc_proc_cancel(rqstp, rqstp->rq_resp); | |
231 | } | |
232 | ||
1da177e4 LT |
233 | /* |
234 | * UNLOCK: release a lock | |
235 | */ | |
7111c66e | 236 | static __be32 |
a6beb732 | 237 | __nlmsvc_proc_unlock(struct svc_rqst *rqstp, struct nlm_res *resp) |
1da177e4 | 238 | { |
a6beb732 | 239 | struct nlm_args *argp = rqstp->rq_argp; |
1da177e4 LT |
240 | struct nlm_host *host; |
241 | struct nlm_file *file; | |
5ccb0066 | 242 | struct net *net = SVC_NET(rqstp); |
1da177e4 LT |
243 | |
244 | dprintk("lockd: UNLOCK called\n"); | |
245 | ||
246 | resp->cookie = argp->cookie; | |
247 | ||
248 | /* Don't accept new lock requests during grace period */ | |
5ccb0066 | 249 | if (locks_in_grace(net)) { |
1da177e4 LT |
250 | resp->status = nlm_lck_denied_grace_period; |
251 | return rpc_success; | |
252 | } | |
253 | ||
254 | /* Obtain client and file */ | |
255 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 256 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
257 | |
258 | /* Now try to remove the lock */ | |
5ccb0066 | 259 | resp->status = cast_status(nlmsvc_unlock(net, file, &argp->lock)); |
1da177e4 LT |
260 | |
261 | dprintk("lockd: UNLOCK status %d\n", ntohl(resp->status)); | |
89e0edfb | 262 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 263 | nlmsvc_release_host(host); |
1da177e4 LT |
264 | nlm_release_file(file); |
265 | return rpc_success; | |
266 | } | |
267 | ||
a6beb732 CH |
268 | static __be32 |
269 | nlmsvc_proc_unlock(struct svc_rqst *rqstp) | |
270 | { | |
271 | return __nlmsvc_proc_unlock(rqstp, rqstp->rq_resp); | |
272 | } | |
273 | ||
1da177e4 LT |
274 | /* |
275 | * GRANTED: A server calls us to tell that a process' lock request | |
276 | * was granted | |
277 | */ | |
7111c66e | 278 | static __be32 |
a6beb732 | 279 | __nlmsvc_proc_granted(struct svc_rqst *rqstp, struct nlm_res *resp) |
1da177e4 | 280 | { |
a6beb732 CH |
281 | struct nlm_args *argp = rqstp->rq_argp; |
282 | ||
1da177e4 LT |
283 | resp->cookie = argp->cookie; |
284 | ||
285 | dprintk("lockd: GRANTED called\n"); | |
dcff09f1 | 286 | resp->status = nlmclnt_grant(svc_addr(rqstp), &argp->lock); |
1da177e4 LT |
287 | dprintk("lockd: GRANTED status %d\n", ntohl(resp->status)); |
288 | return rpc_success; | |
289 | } | |
290 | ||
a6beb732 CH |
291 | static __be32 |
292 | nlmsvc_proc_granted(struct svc_rqst *rqstp) | |
293 | { | |
294 | return __nlmsvc_proc_granted(rqstp, rqstp->rq_resp); | |
295 | } | |
296 | ||
d4716624 TM |
297 | /* |
298 | * This is the generic lockd callback for async RPC calls | |
299 | */ | |
300 | static void nlmsvc_callback_exit(struct rpc_task *task, void *data) | |
301 | { | |
c041b5ff | 302 | dprintk("lockd: %5u callback returned %d\n", task->tk_pid, |
d4716624 TM |
303 | -task->tk_status); |
304 | } | |
305 | ||
7db836d4 CL |
306 | void nlmsvc_release_call(struct nlm_rqst *call) |
307 | { | |
fbca30c5 | 308 | if (!refcount_dec_and_test(&call->a_count)) |
7db836d4 | 309 | return; |
67216b94 | 310 | nlmsvc_release_host(call->a_host); |
7db836d4 CL |
311 | kfree(call); |
312 | } | |
313 | ||
d4716624 TM |
314 | static void nlmsvc_callback_release(void *data) |
315 | { | |
7db836d4 | 316 | nlmsvc_release_call(data); |
d4716624 TM |
317 | } |
318 | ||
319 | static const struct rpc_call_ops nlmsvc_callback_ops = { | |
320 | .rpc_call_done = nlmsvc_callback_exit, | |
321 | .rpc_release = nlmsvc_callback_release, | |
322 | }; | |
323 | ||
1da177e4 LT |
324 | /* |
325 | * `Async' versions of the above service routines. They aren't really, | |
326 | * because we send the callback before the reply proper. I hope this | |
327 | * doesn't break any clients. | |
328 | */ | |
a6beb732 CH |
329 | static __be32 nlmsvc_callback(struct svc_rqst *rqstp, u32 proc, |
330 | __be32 (*func)(struct svc_rqst *, struct nlm_res *)) | |
1da177e4 | 331 | { |
a6beb732 | 332 | struct nlm_args *argp = rqstp->rq_argp; |
d4716624 TM |
333 | struct nlm_host *host; |
334 | struct nlm_rqst *call; | |
7111c66e | 335 | __be32 stat; |
1da177e4 | 336 | |
db4e4c9a OK |
337 | host = nlmsvc_lookup_host(rqstp, |
338 | argp->lock.caller, | |
339 | argp->lock.len); | |
d4716624 TM |
340 | if (host == NULL) |
341 | return rpc_system_err; | |
342 | ||
343 | call = nlm_alloc_call(host); | |
446945ab | 344 | nlmsvc_release_host(host); |
d4716624 TM |
345 | if (call == NULL) |
346 | return rpc_system_err; | |
347 | ||
a6beb732 | 348 | stat = func(rqstp, &call->a_res); |
d4716624 | 349 | if (stat != 0) { |
7db836d4 | 350 | nlmsvc_release_call(call); |
d4716624 TM |
351 | return stat; |
352 | } | |
1da177e4 | 353 | |
d4716624 TM |
354 | call->a_flags = RPC_TASK_ASYNC; |
355 | if (nlm_async_reply(call, proc, &nlmsvc_callback_ops) < 0) | |
356 | return rpc_system_err; | |
357 | return rpc_success; | |
1da177e4 LT |
358 | } |
359 | ||
a6beb732 | 360 | static __be32 nlmsvc_proc_test_msg(struct svc_rqst *rqstp) |
1da177e4 | 361 | { |
d4716624 | 362 | dprintk("lockd: TEST_MSG called\n"); |
a6beb732 | 363 | return nlmsvc_callback(rqstp, NLMPROC_TEST_RES, __nlmsvc_proc_test); |
d4716624 | 364 | } |
1da177e4 | 365 | |
a6beb732 | 366 | static __be32 nlmsvc_proc_lock_msg(struct svc_rqst *rqstp) |
d4716624 | 367 | { |
1da177e4 | 368 | dprintk("lockd: LOCK_MSG called\n"); |
a6beb732 | 369 | return nlmsvc_callback(rqstp, NLMPROC_LOCK_RES, __nlmsvc_proc_lock); |
1da177e4 LT |
370 | } |
371 | ||
a6beb732 | 372 | static __be32 nlmsvc_proc_cancel_msg(struct svc_rqst *rqstp) |
1da177e4 | 373 | { |
1da177e4 | 374 | dprintk("lockd: CANCEL_MSG called\n"); |
a6beb732 | 375 | return nlmsvc_callback(rqstp, NLMPROC_CANCEL_RES, __nlmsvc_proc_cancel); |
1da177e4 LT |
376 | } |
377 | ||
7111c66e | 378 | static __be32 |
a6beb732 | 379 | nlmsvc_proc_unlock_msg(struct svc_rqst *rqstp) |
1da177e4 | 380 | { |
1da177e4 | 381 | dprintk("lockd: UNLOCK_MSG called\n"); |
a6beb732 | 382 | return nlmsvc_callback(rqstp, NLMPROC_UNLOCK_RES, __nlmsvc_proc_unlock); |
1da177e4 LT |
383 | } |
384 | ||
7111c66e | 385 | static __be32 |
a6beb732 | 386 | nlmsvc_proc_granted_msg(struct svc_rqst *rqstp) |
1da177e4 | 387 | { |
1da177e4 | 388 | dprintk("lockd: GRANTED_MSG called\n"); |
a6beb732 | 389 | return nlmsvc_callback(rqstp, NLMPROC_GRANTED_RES, __nlmsvc_proc_granted); |
1da177e4 LT |
390 | } |
391 | ||
392 | /* | |
393 | * SHARE: create a DOS share or alter existing share. | |
394 | */ | |
7111c66e | 395 | static __be32 |
a6beb732 | 396 | nlmsvc_proc_share(struct svc_rqst *rqstp) |
1da177e4 | 397 | { |
a6beb732 CH |
398 | struct nlm_args *argp = rqstp->rq_argp; |
399 | struct nlm_res *resp = rqstp->rq_resp; | |
1da177e4 LT |
400 | struct nlm_host *host; |
401 | struct nlm_file *file; | |
402 | ||
403 | dprintk("lockd: SHARE called\n"); | |
404 | ||
405 | resp->cookie = argp->cookie; | |
406 | ||
407 | /* Don't accept new lock requests during grace period */ | |
5ccb0066 | 408 | if (locks_in_grace(SVC_NET(rqstp)) && !argp->reclaim) { |
1da177e4 LT |
409 | resp->status = nlm_lck_denied_grace_period; |
410 | return rpc_success; | |
411 | } | |
412 | ||
413 | /* Obtain client and file */ | |
414 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 415 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
416 | |
417 | /* Now try to create the share */ | |
418 | resp->status = cast_status(nlmsvc_share_file(host, file, argp)); | |
419 | ||
420 | dprintk("lockd: SHARE status %d\n", ntohl(resp->status)); | |
89e0edfb | 421 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 422 | nlmsvc_release_host(host); |
1da177e4 LT |
423 | nlm_release_file(file); |
424 | return rpc_success; | |
425 | } | |
426 | ||
427 | /* | |
428 | * UNSHARE: Release a DOS share. | |
429 | */ | |
7111c66e | 430 | static __be32 |
a6beb732 | 431 | nlmsvc_proc_unshare(struct svc_rqst *rqstp) |
1da177e4 | 432 | { |
a6beb732 CH |
433 | struct nlm_args *argp = rqstp->rq_argp; |
434 | struct nlm_res *resp = rqstp->rq_resp; | |
1da177e4 LT |
435 | struct nlm_host *host; |
436 | struct nlm_file *file; | |
437 | ||
438 | dprintk("lockd: UNSHARE called\n"); | |
439 | ||
440 | resp->cookie = argp->cookie; | |
441 | ||
442 | /* Don't accept requests during grace period */ | |
5ccb0066 | 443 | if (locks_in_grace(SVC_NET(rqstp))) { |
1da177e4 LT |
444 | resp->status = nlm_lck_denied_grace_period; |
445 | return rpc_success; | |
446 | } | |
447 | ||
448 | /* Obtain client and file */ | |
449 | if ((resp->status = nlmsvc_retrieve_args(rqstp, argp, &host, &file))) | |
d343fce1 | 450 | return resp->status == nlm_drop_reply ? rpc_drop_reply :rpc_success; |
1da177e4 LT |
451 | |
452 | /* Now try to unshare the file */ | |
453 | resp->status = cast_status(nlmsvc_unshare_file(host, file, argp)); | |
454 | ||
455 | dprintk("lockd: UNSHARE status %d\n", ntohl(resp->status)); | |
89e0edfb | 456 | nlmsvc_release_lockowner(&argp->lock); |
67216b94 | 457 | nlmsvc_release_host(host); |
1da177e4 LT |
458 | nlm_release_file(file); |
459 | return rpc_success; | |
460 | } | |
461 | ||
462 | /* | |
463 | * NM_LOCK: Create an unmonitored lock | |
464 | */ | |
7111c66e | 465 | static __be32 |
a6beb732 | 466 | nlmsvc_proc_nm_lock(struct svc_rqst *rqstp) |
1da177e4 | 467 | { |
a6beb732 CH |
468 | struct nlm_args *argp = rqstp->rq_argp; |
469 | ||
1da177e4 LT |
470 | dprintk("lockd: NM_LOCK called\n"); |
471 | ||
472 | argp->monitor = 0; /* just clean the monitor flag */ | |
a6beb732 | 473 | return nlmsvc_proc_lock(rqstp); |
1da177e4 LT |
474 | } |
475 | ||
476 | /* | |
477 | * FREE_ALL: Release all locks and shares held by client | |
478 | */ | |
7111c66e | 479 | static __be32 |
a6beb732 | 480 | nlmsvc_proc_free_all(struct svc_rqst *rqstp) |
1da177e4 | 481 | { |
a6beb732 | 482 | struct nlm_args *argp = rqstp->rq_argp; |
1da177e4 LT |
483 | struct nlm_host *host; |
484 | ||
485 | /* Obtain client */ | |
486 | if (nlmsvc_retrieve_args(rqstp, argp, &host, NULL)) | |
487 | return rpc_success; | |
488 | ||
489 | nlmsvc_free_host_resources(host); | |
67216b94 | 490 | nlmsvc_release_host(host); |
1da177e4 LT |
491 | return rpc_success; |
492 | } | |
493 | ||
494 | /* | |
495 | * SM_NOTIFY: private callback from statd (not part of official NLM proto) | |
496 | */ | |
7111c66e | 497 | static __be32 |
a6beb732 | 498 | nlmsvc_proc_sm_notify(struct svc_rqst *rqstp) |
1da177e4 | 499 | { |
a6beb732 CH |
500 | struct nlm_reboot *argp = rqstp->rq_argp; |
501 | ||
1da177e4 | 502 | dprintk("lockd: SM_NOTIFY called\n"); |
b85e4676 CL |
503 | |
504 | if (!nlm_privileged_requester(rqstp)) { | |
ad06e4bd CL |
505 | char buf[RPC_MAX_ADDRBUFLEN]; |
506 | printk(KERN_WARNING "lockd: rejected NSM callback from %s\n", | |
507 | svc_print_addr(rqstp, buf, sizeof(buf))); | |
1da177e4 LT |
508 | return rpc_system_err; |
509 | } | |
510 | ||
0ad95472 | 511 | nlm_host_rebooted(SVC_NET(rqstp), argp); |
1da177e4 LT |
512 | return rpc_success; |
513 | } | |
514 | ||
515 | /* | |
516 | * client sent a GRANTED_RES, let's remove the associated block | |
517 | */ | |
7111c66e | 518 | static __be32 |
a6beb732 | 519 | nlmsvc_proc_granted_res(struct svc_rqst *rqstp) |
1da177e4 | 520 | { |
a6beb732 CH |
521 | struct nlm_res *argp = rqstp->rq_argp; |
522 | ||
1da177e4 LT |
523 | if (!nlmsvc_ops) |
524 | return rpc_success; | |
525 | ||
526 | dprintk("lockd: GRANTED_RES called\n"); | |
527 | ||
39be4502 | 528 | nlmsvc_grant_reply(&argp->cookie, argp->status); |
1da177e4 LT |
529 | return rpc_success; |
530 | } | |
531 | ||
49d99608 CL |
532 | static __be32 |
533 | nlmsvc_proc_unused(struct svc_rqst *rqstp) | |
534 | { | |
535 | return rpc_proc_unavail; | |
536 | } | |
537 | ||
1da177e4 LT |
538 | /* |
539 | * NLM Server procedures. | |
540 | */ | |
541 | ||
1da177e4 LT |
542 | struct nlm_void { int dummy; }; |
543 | ||
1da177e4 LT |
544 | #define Ck (1+XDR_QUADLEN(NLM_MAXCOOKIELEN)) /* cookie */ |
545 | #define St 1 /* status */ | |
546 | #define No (1+1024/4) /* Net Obj */ | |
547 | #define Rg 2 /* range - offset + size */ | |
548 | ||
49d99608 CL |
549 | const struct svc_procedure nlmsvc_procedures[24] = { |
550 | [NLMPROC_NULL] = { | |
551 | .pc_func = nlmsvc_proc_null, | |
552 | .pc_decode = nlmsvc_decode_void, | |
553 | .pc_encode = nlmsvc_encode_void, | |
554 | .pc_argsize = sizeof(struct nlm_void), | |
555 | .pc_ressize = sizeof(struct nlm_void), | |
556 | .pc_xdrressize = St, | |
557 | }, | |
558 | [NLMPROC_TEST] = { | |
559 | .pc_func = nlmsvc_proc_test, | |
560 | .pc_decode = nlmsvc_decode_testargs, | |
561 | .pc_encode = nlmsvc_encode_testres, | |
562 | .pc_argsize = sizeof(struct nlm_args), | |
563 | .pc_ressize = sizeof(struct nlm_res), | |
564 | .pc_xdrressize = Ck+St+2+No+Rg, | |
565 | }, | |
566 | [NLMPROC_LOCK] = { | |
567 | .pc_func = nlmsvc_proc_lock, | |
568 | .pc_decode = nlmsvc_decode_lockargs, | |
569 | .pc_encode = nlmsvc_encode_res, | |
570 | .pc_argsize = sizeof(struct nlm_args), | |
571 | .pc_ressize = sizeof(struct nlm_res), | |
572 | .pc_xdrressize = Ck+St, | |
573 | }, | |
574 | [NLMPROC_CANCEL] = { | |
575 | .pc_func = nlmsvc_proc_cancel, | |
576 | .pc_decode = nlmsvc_decode_cancargs, | |
577 | .pc_encode = nlmsvc_encode_res, | |
578 | .pc_argsize = sizeof(struct nlm_args), | |
579 | .pc_ressize = sizeof(struct nlm_res), | |
580 | .pc_xdrressize = Ck+St, | |
581 | }, | |
582 | [NLMPROC_UNLOCK] = { | |
583 | .pc_func = nlmsvc_proc_unlock, | |
584 | .pc_decode = nlmsvc_decode_unlockargs, | |
585 | .pc_encode = nlmsvc_encode_res, | |
586 | .pc_argsize = sizeof(struct nlm_args), | |
587 | .pc_ressize = sizeof(struct nlm_res), | |
588 | .pc_xdrressize = Ck+St, | |
589 | }, | |
590 | [NLMPROC_GRANTED] = { | |
591 | .pc_func = nlmsvc_proc_granted, | |
592 | .pc_decode = nlmsvc_decode_testargs, | |
593 | .pc_encode = nlmsvc_encode_res, | |
594 | .pc_argsize = sizeof(struct nlm_args), | |
595 | .pc_ressize = sizeof(struct nlm_res), | |
596 | .pc_xdrressize = Ck+St, | |
597 | }, | |
598 | [NLMPROC_TEST_MSG] = { | |
599 | .pc_func = nlmsvc_proc_test_msg, | |
600 | .pc_decode = nlmsvc_decode_testargs, | |
601 | .pc_encode = nlmsvc_encode_void, | |
602 | .pc_argsize = sizeof(struct nlm_args), | |
603 | .pc_ressize = sizeof(struct nlm_void), | |
604 | .pc_xdrressize = St, | |
605 | }, | |
606 | [NLMPROC_LOCK_MSG] = { | |
607 | .pc_func = nlmsvc_proc_lock_msg, | |
608 | .pc_decode = nlmsvc_decode_lockargs, | |
609 | .pc_encode = nlmsvc_encode_void, | |
610 | .pc_argsize = sizeof(struct nlm_args), | |
611 | .pc_ressize = sizeof(struct nlm_void), | |
612 | .pc_xdrressize = St, | |
613 | }, | |
614 | [NLMPROC_CANCEL_MSG] = { | |
615 | .pc_func = nlmsvc_proc_cancel_msg, | |
616 | .pc_decode = nlmsvc_decode_cancargs, | |
617 | .pc_encode = nlmsvc_encode_void, | |
618 | .pc_argsize = sizeof(struct nlm_args), | |
619 | .pc_ressize = sizeof(struct nlm_void), | |
620 | .pc_xdrressize = St, | |
621 | }, | |
622 | [NLMPROC_UNLOCK_MSG] = { | |
623 | .pc_func = nlmsvc_proc_unlock_msg, | |
624 | .pc_decode = nlmsvc_decode_unlockargs, | |
625 | .pc_encode = nlmsvc_encode_void, | |
626 | .pc_argsize = sizeof(struct nlm_args), | |
627 | .pc_ressize = sizeof(struct nlm_void), | |
628 | .pc_xdrressize = St, | |
629 | }, | |
630 | [NLMPROC_GRANTED_MSG] = { | |
631 | .pc_func = nlmsvc_proc_granted_msg, | |
632 | .pc_decode = nlmsvc_decode_testargs, | |
633 | .pc_encode = nlmsvc_encode_void, | |
634 | .pc_argsize = sizeof(struct nlm_args), | |
635 | .pc_ressize = sizeof(struct nlm_void), | |
636 | .pc_xdrressize = St, | |
637 | }, | |
638 | [NLMPROC_TEST_RES] = { | |
639 | .pc_func = nlmsvc_proc_null, | |
640 | .pc_decode = nlmsvc_decode_void, | |
641 | .pc_encode = nlmsvc_encode_void, | |
642 | .pc_argsize = sizeof(struct nlm_res), | |
643 | .pc_ressize = sizeof(struct nlm_void), | |
644 | .pc_xdrressize = St, | |
645 | }, | |
646 | [NLMPROC_LOCK_RES] = { | |
647 | .pc_func = nlmsvc_proc_null, | |
648 | .pc_decode = nlmsvc_decode_void, | |
649 | .pc_encode = nlmsvc_encode_void, | |
650 | .pc_argsize = sizeof(struct nlm_res), | |
651 | .pc_ressize = sizeof(struct nlm_void), | |
652 | .pc_xdrressize = St, | |
653 | }, | |
654 | [NLMPROC_CANCEL_RES] = { | |
655 | .pc_func = nlmsvc_proc_null, | |
656 | .pc_decode = nlmsvc_decode_void, | |
657 | .pc_encode = nlmsvc_encode_void, | |
658 | .pc_argsize = sizeof(struct nlm_res), | |
659 | .pc_ressize = sizeof(struct nlm_void), | |
660 | .pc_xdrressize = St, | |
661 | }, | |
662 | [NLMPROC_UNLOCK_RES] = { | |
663 | .pc_func = nlmsvc_proc_null, | |
664 | .pc_decode = nlmsvc_decode_void, | |
665 | .pc_encode = nlmsvc_encode_void, | |
666 | .pc_argsize = sizeof(struct nlm_res), | |
667 | .pc_ressize = sizeof(struct nlm_void), | |
668 | .pc_xdrressize = St, | |
669 | }, | |
670 | [NLMPROC_GRANTED_RES] = { | |
671 | .pc_func = nlmsvc_proc_granted_res, | |
672 | .pc_decode = nlmsvc_decode_res, | |
673 | .pc_encode = nlmsvc_encode_void, | |
674 | .pc_argsize = sizeof(struct nlm_res), | |
675 | .pc_ressize = sizeof(struct nlm_void), | |
676 | .pc_xdrressize = St, | |
677 | }, | |
678 | [NLMPROC_NSM_NOTIFY] = { | |
679 | .pc_func = nlmsvc_proc_sm_notify, | |
680 | .pc_decode = nlmsvc_decode_reboot, | |
681 | .pc_encode = nlmsvc_encode_void, | |
682 | .pc_argsize = sizeof(struct nlm_reboot), | |
683 | .pc_ressize = sizeof(struct nlm_void), | |
684 | .pc_xdrressize = St, | |
685 | }, | |
686 | [17] = { | |
687 | .pc_func = nlmsvc_proc_unused, | |
688 | .pc_decode = nlmsvc_decode_void, | |
689 | .pc_encode = nlmsvc_encode_void, | |
690 | .pc_argsize = sizeof(struct nlm_void), | |
691 | .pc_ressize = sizeof(struct nlm_void), | |
692 | .pc_xdrressize = St, | |
693 | }, | |
694 | [18] = { | |
695 | .pc_func = nlmsvc_proc_unused, | |
696 | .pc_decode = nlmsvc_decode_void, | |
697 | .pc_encode = nlmsvc_encode_void, | |
698 | .pc_argsize = sizeof(struct nlm_void), | |
699 | .pc_ressize = sizeof(struct nlm_void), | |
700 | .pc_xdrressize = St, | |
701 | }, | |
702 | [19] = { | |
703 | .pc_func = nlmsvc_proc_unused, | |
704 | .pc_decode = nlmsvc_decode_void, | |
705 | .pc_encode = nlmsvc_encode_void, | |
706 | .pc_argsize = sizeof(struct nlm_void), | |
707 | .pc_ressize = sizeof(struct nlm_void), | |
708 | .pc_xdrressize = St, | |
709 | }, | |
710 | [NLMPROC_SHARE] = { | |
711 | .pc_func = nlmsvc_proc_share, | |
712 | .pc_decode = nlmsvc_decode_shareargs, | |
713 | .pc_encode = nlmsvc_encode_shareres, | |
714 | .pc_argsize = sizeof(struct nlm_args), | |
715 | .pc_ressize = sizeof(struct nlm_res), | |
716 | .pc_xdrressize = Ck+St+1, | |
717 | }, | |
718 | [NLMPROC_UNSHARE] = { | |
719 | .pc_func = nlmsvc_proc_unshare, | |
720 | .pc_decode = nlmsvc_decode_shareargs, | |
721 | .pc_encode = nlmsvc_encode_shareres, | |
722 | .pc_argsize = sizeof(struct nlm_args), | |
723 | .pc_ressize = sizeof(struct nlm_res), | |
724 | .pc_xdrressize = Ck+St+1, | |
725 | }, | |
726 | [NLMPROC_NM_LOCK] = { | |
727 | .pc_func = nlmsvc_proc_nm_lock, | |
728 | .pc_decode = nlmsvc_decode_lockargs, | |
729 | .pc_encode = nlmsvc_encode_res, | |
730 | .pc_argsize = sizeof(struct nlm_args), | |
731 | .pc_ressize = sizeof(struct nlm_res), | |
732 | .pc_xdrressize = Ck+St, | |
733 | }, | |
734 | [NLMPROC_FREE_ALL] = { | |
735 | .pc_func = nlmsvc_proc_free_all, | |
736 | .pc_decode = nlmsvc_decode_notify, | |
737 | .pc_encode = nlmsvc_encode_void, | |
738 | .pc_argsize = sizeof(struct nlm_args), | |
739 | .pc_ressize = sizeof(struct nlm_void), | |
740 | .pc_xdrressize = 0, | |
741 | }, | |
1da177e4 | 742 | }; |