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