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