Merge git://git.linux-nfs.org/pub/linux/nfs-2.6
[linux-2.6.git] / fs / lockd / xdr.c
1 /*
2  * linux/fs/lockd/xdr.c
3  *
4  * XDR support for lockd and the lock client.
5  *
6  * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7  */
8
9 #include <linux/config.h>
10 #include <linux/types.h>
11 #include <linux/sched.h>
12 #include <linux/utsname.h>
13 #include <linux/nfs.h>
14
15 #include <linux/sunrpc/xdr.h>
16 #include <linux/sunrpc/clnt.h>
17 #include <linux/sunrpc/svc.h>
18 #include <linux/sunrpc/stats.h>
19 #include <linux/lockd/lockd.h>
20 #include <linux/lockd/sm_inter.h>
21
22 #define NLMDBG_FACILITY         NLMDBG_XDR
23
24
25 static inline loff_t
26 s32_to_loff_t(__s32 offset)
27 {
28         return (loff_t)offset;
29 }
30
31 static inline __s32
32 loff_t_to_s32(loff_t offset)
33 {
34         __s32 res;
35         if (offset >= NLM_OFFSET_MAX)
36                 res = NLM_OFFSET_MAX;
37         else if (offset <= -NLM_OFFSET_MAX)
38                 res = -NLM_OFFSET_MAX;
39         else
40                 res = offset;
41         return res;
42 }
43
44 /*
45  * XDR functions for basic NLM types
46  */
47 static u32 *nlm_decode_cookie(u32 *p, struct nlm_cookie *c)
48 {
49         unsigned int    len;
50
51         len = ntohl(*p++);
52         
53         if(len==0)
54         {
55                 c->len=4;
56                 memset(c->data, 0, 4);  /* hockeypux brain damage */
57         }
58         else if(len<=NLM_MAXCOOKIELEN)
59         {
60                 c->len=len;
61                 memcpy(c->data, p, len);
62                 p+=XDR_QUADLEN(len);
63         }
64         else 
65         {
66                 printk(KERN_NOTICE
67                         "lockd: bad cookie size %d (only cookies under %d bytes are supported.)\n", len, NLM_MAXCOOKIELEN);
68                 return NULL;
69         }
70         return p;
71 }
72
73 static inline u32 *
74 nlm_encode_cookie(u32 *p, struct nlm_cookie *c)
75 {
76         *p++ = htonl(c->len);
77         memcpy(p, c->data, c->len);
78         p+=XDR_QUADLEN(c->len);
79         return p;
80 }
81
82 static u32 *
83 nlm_decode_fh(u32 *p, struct nfs_fh *f)
84 {
85         unsigned int    len;
86
87         if ((len = ntohl(*p++)) != NFS2_FHSIZE) {
88                 printk(KERN_NOTICE
89                         "lockd: bad fhandle size %d (should be %d)\n",
90                         len, NFS2_FHSIZE);
91                 return NULL;
92         }
93         f->size = NFS2_FHSIZE;
94         memset(f->data, 0, sizeof(f->data));
95         memcpy(f->data, p, NFS2_FHSIZE);
96         return p + XDR_QUADLEN(NFS2_FHSIZE);
97 }
98
99 static inline u32 *
100 nlm_encode_fh(u32 *p, struct nfs_fh *f)
101 {
102         *p++ = htonl(NFS2_FHSIZE);
103         memcpy(p, f->data, NFS2_FHSIZE);
104         return p + XDR_QUADLEN(NFS2_FHSIZE);
105 }
106
107 /*
108  * Encode and decode owner handle
109  */
110 static inline u32 *
111 nlm_decode_oh(u32 *p, struct xdr_netobj *oh)
112 {
113         return xdr_decode_netobj(p, oh);
114 }
115
116 static inline u32 *
117 nlm_encode_oh(u32 *p, struct xdr_netobj *oh)
118 {
119         return xdr_encode_netobj(p, oh);
120 }
121
122 static u32 *
123 nlm_decode_lock(u32 *p, struct nlm_lock *lock)
124 {
125         struct file_lock        *fl = &lock->fl;
126         s32                     start, len, end;
127
128         if (!(p = xdr_decode_string_inplace(p, &lock->caller,
129                                             &lock->len,
130                                             NLM_MAXSTRLEN))
131          || !(p = nlm_decode_fh(p, &lock->fh))
132          || !(p = nlm_decode_oh(p, &lock->oh)))
133                 return NULL;
134         lock->svid  = ntohl(*p++);
135
136         locks_init_lock(fl);
137         fl->fl_owner = current->files;
138         fl->fl_pid   = (pid_t)lock->svid;
139         fl->fl_flags = FL_POSIX;
140         fl->fl_type  = F_RDLCK;         /* as good as anything else */
141         start = ntohl(*p++);
142         len = ntohl(*p++);
143         end = start + len - 1;
144
145         fl->fl_start = s32_to_loff_t(start);
146
147         if (len == 0 || end < 0)
148                 fl->fl_end = OFFSET_MAX;
149         else
150                 fl->fl_end = s32_to_loff_t(end);
151         return p;
152 }
153
154 /*
155  * Encode a lock as part of an NLM call
156  */
157 static u32 *
158 nlm_encode_lock(u32 *p, struct nlm_lock *lock)
159 {
160         struct file_lock        *fl = &lock->fl;
161         __s32                   start, len;
162
163         if (!(p = xdr_encode_string(p, lock->caller))
164          || !(p = nlm_encode_fh(p, &lock->fh))
165          || !(p = nlm_encode_oh(p, &lock->oh)))
166                 return NULL;
167
168         if (fl->fl_start > NLM_OFFSET_MAX
169          || (fl->fl_end > NLM_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
170                 return NULL;
171
172         start = loff_t_to_s32(fl->fl_start);
173         if (fl->fl_end == OFFSET_MAX)
174                 len = 0;
175         else
176                 len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
177
178         *p++ = htonl(lock->svid);
179         *p++ = htonl(start);
180         *p++ = htonl(len);
181
182         return p;
183 }
184
185 /*
186  * Encode result of a TEST/TEST_MSG call
187  */
188 static u32 *
189 nlm_encode_testres(u32 *p, struct nlm_res *resp)
190 {
191         s32             start, len;
192
193         if (!(p = nlm_encode_cookie(p, &resp->cookie)))
194                 return NULL;
195         *p++ = resp->status;
196
197         if (resp->status == nlm_lck_denied) {
198                 struct file_lock        *fl = &resp->lock.fl;
199
200                 *p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
201                 *p++ = htonl(resp->lock.svid);
202
203                 /* Encode owner handle. */
204                 if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
205                         return NULL;
206
207                 start = loff_t_to_s32(fl->fl_start);
208                 if (fl->fl_end == OFFSET_MAX)
209                         len = 0;
210                 else
211                         len = loff_t_to_s32(fl->fl_end - fl->fl_start + 1);
212
213                 *p++ = htonl(start);
214                 *p++ = htonl(len);
215         }
216
217         return p;
218 }
219
220
221 /*
222  * First, the server side XDR functions
223  */
224 int
225 nlmsvc_decode_testargs(struct svc_rqst *rqstp, u32 *p, nlm_args *argp)
226 {
227         u32     exclusive;
228
229         if (!(p = nlm_decode_cookie(p, &argp->cookie)))
230                 return 0;
231
232         exclusive = ntohl(*p++);
233         if (!(p = nlm_decode_lock(p, &argp->lock)))
234                 return 0;
235         if (exclusive)
236                 argp->lock.fl.fl_type = F_WRLCK;
237
238         return xdr_argsize_check(rqstp, p);
239 }
240
241 int
242 nlmsvc_encode_testres(struct svc_rqst *rqstp, u32 *p, struct nlm_res *resp)
243 {
244         if (!(p = nlm_encode_testres(p, resp)))
245                 return 0;
246         return xdr_ressize_check(rqstp, p);
247 }
248
249 int
250 nlmsvc_decode_lockargs(struct svc_rqst *rqstp, u32 *p, nlm_args *argp)
251 {
252         u32     exclusive;
253
254         if (!(p = nlm_decode_cookie(p, &argp->cookie)))
255                 return 0;
256         argp->block  = ntohl(*p++);
257         exclusive    = ntohl(*p++);
258         if (!(p = nlm_decode_lock(p, &argp->lock)))
259                 return 0;
260         if (exclusive)
261                 argp->lock.fl.fl_type = F_WRLCK;
262         argp->reclaim = ntohl(*p++);
263         argp->state   = ntohl(*p++);
264         argp->monitor = 1;              /* monitor client by default */
265
266         return xdr_argsize_check(rqstp, p);
267 }
268
269 int
270 nlmsvc_decode_cancargs(struct svc_rqst *rqstp, u32 *p, nlm_args *argp)
271 {
272         u32     exclusive;
273
274         if (!(p = nlm_decode_cookie(p, &argp->cookie)))
275                 return 0;
276         argp->block = ntohl(*p++);
277         exclusive = ntohl(*p++);
278         if (!(p = nlm_decode_lock(p, &argp->lock)))
279                 return 0;
280         if (exclusive)
281                 argp->lock.fl.fl_type = F_WRLCK;
282         return xdr_argsize_check(rqstp, p);
283 }
284
285 int
286 nlmsvc_decode_unlockargs(struct svc_rqst *rqstp, u32 *p, nlm_args *argp)
287 {
288         if (!(p = nlm_decode_cookie(p, &argp->cookie))
289          || !(p = nlm_decode_lock(p, &argp->lock)))
290                 return 0;
291         argp->lock.fl.fl_type = F_UNLCK;
292         return xdr_argsize_check(rqstp, p);
293 }
294
295 int
296 nlmsvc_decode_shareargs(struct svc_rqst *rqstp, u32 *p, nlm_args *argp)
297 {
298         struct nlm_lock *lock = &argp->lock;
299
300         memset(lock, 0, sizeof(*lock));
301         locks_init_lock(&lock->fl);
302         lock->svid = ~(u32) 0;
303         lock->fl.fl_pid = (pid_t)lock->svid;
304
305         if (!(p = nlm_decode_cookie(p, &argp->cookie))
306          || !(p = xdr_decode_string_inplace(p, &lock->caller,
307                                             &lock->len, NLM_MAXSTRLEN))
308          || !(p = nlm_decode_fh(p, &lock->fh))
309          || !(p = nlm_decode_oh(p, &lock->oh)))
310                 return 0;
311         argp->fsm_mode = ntohl(*p++);
312         argp->fsm_access = ntohl(*p++);
313         return xdr_argsize_check(rqstp, p);
314 }
315
316 int
317 nlmsvc_encode_shareres(struct svc_rqst *rqstp, u32 *p, struct nlm_res *resp)
318 {
319         if (!(p = nlm_encode_cookie(p, &resp->cookie)))
320                 return 0;
321         *p++ = resp->status;
322         *p++ = xdr_zero;                /* sequence argument */
323         return xdr_ressize_check(rqstp, p);
324 }
325
326 int
327 nlmsvc_encode_res(struct svc_rqst *rqstp, u32 *p, struct nlm_res *resp)
328 {
329         if (!(p = nlm_encode_cookie(p, &resp->cookie)))
330                 return 0;
331         *p++ = resp->status;
332         return xdr_ressize_check(rqstp, p);
333 }
334
335 int
336 nlmsvc_decode_notify(struct svc_rqst *rqstp, u32 *p, struct nlm_args *argp)
337 {
338         struct nlm_lock *lock = &argp->lock;
339
340         if (!(p = xdr_decode_string_inplace(p, &lock->caller,
341                                             &lock->len, NLM_MAXSTRLEN)))
342                 return 0;
343         argp->state = ntohl(*p++);
344         return xdr_argsize_check(rqstp, p);
345 }
346
347 int
348 nlmsvc_decode_reboot(struct svc_rqst *rqstp, u32 *p, struct nlm_reboot *argp)
349 {
350         if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
351                 return 0;
352         argp->state = ntohl(*p++);
353         /* Preserve the address in network byte order */
354         argp->addr = *p++;
355         argp->vers = *p++;
356         argp->proto = *p++;
357         return xdr_argsize_check(rqstp, p);
358 }
359
360 int
361 nlmsvc_decode_res(struct svc_rqst *rqstp, u32 *p, struct nlm_res *resp)
362 {
363         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
364                 return 0;
365         resp->status = ntohl(*p++);
366         return xdr_argsize_check(rqstp, p);
367 }
368
369 int
370 nlmsvc_decode_void(struct svc_rqst *rqstp, u32 *p, void *dummy)
371 {
372         return xdr_argsize_check(rqstp, p);
373 }
374
375 int
376 nlmsvc_encode_void(struct svc_rqst *rqstp, u32 *p, void *dummy)
377 {
378         return xdr_ressize_check(rqstp, p);
379 }
380
381 /*
382  * Now, the client side XDR functions
383  */
384 #ifdef NLMCLNT_SUPPORT_SHARES
385 static int
386 nlmclt_decode_void(struct rpc_rqst *req, u32 *p, void *ptr)
387 {
388         return 0;
389 }
390 #endif
391
392 static int
393 nlmclt_encode_testargs(struct rpc_rqst *req, u32 *p, nlm_args *argp)
394 {
395         struct nlm_lock *lock = &argp->lock;
396
397         if (!(p = nlm_encode_cookie(p, &argp->cookie)))
398                 return -EIO;
399         *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
400         if (!(p = nlm_encode_lock(p, lock)))
401                 return -EIO;
402         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
403         return 0;
404 }
405
406 static int
407 nlmclt_decode_testres(struct rpc_rqst *req, u32 *p, struct nlm_res *resp)
408 {
409         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
410                 return -EIO;
411         resp->status = ntohl(*p++);
412         if (resp->status == NLM_LCK_DENIED) {
413                 struct file_lock        *fl = &resp->lock.fl;
414                 u32                     excl;
415                 s32                     start, len, end;
416
417                 memset(&resp->lock, 0, sizeof(resp->lock));
418                 locks_init_lock(fl);
419                 excl = ntohl(*p++);
420                 resp->lock.svid = ntohl(*p++);
421                 fl->fl_pid = (pid_t)resp->lock.svid;
422                 if (!(p = nlm_decode_oh(p, &resp->lock.oh)))
423                         return -EIO;
424
425                 fl->fl_flags = FL_POSIX;
426                 fl->fl_type  = excl? F_WRLCK : F_RDLCK;
427                 start = ntohl(*p++);
428                 len = ntohl(*p++);
429                 end = start + len - 1;
430
431                 fl->fl_start = s32_to_loff_t(start);
432                 if (len == 0 || end < 0)
433                         fl->fl_end = OFFSET_MAX;
434                 else
435                         fl->fl_end = s32_to_loff_t(end);
436         }
437         return 0;
438 }
439
440
441 static int
442 nlmclt_encode_lockargs(struct rpc_rqst *req, u32 *p, nlm_args *argp)
443 {
444         struct nlm_lock *lock = &argp->lock;
445
446         if (!(p = nlm_encode_cookie(p, &argp->cookie)))
447                 return -EIO;
448         *p++ = argp->block? xdr_one : xdr_zero;
449         *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
450         if (!(p = nlm_encode_lock(p, lock)))
451                 return -EIO;
452         *p++ = argp->reclaim? xdr_one : xdr_zero;
453         *p++ = htonl(argp->state);
454         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
455         return 0;
456 }
457
458 static int
459 nlmclt_encode_cancargs(struct rpc_rqst *req, u32 *p, nlm_args *argp)
460 {
461         struct nlm_lock *lock = &argp->lock;
462
463         if (!(p = nlm_encode_cookie(p, &argp->cookie)))
464                 return -EIO;
465         *p++ = argp->block? xdr_one : xdr_zero;
466         *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
467         if (!(p = nlm_encode_lock(p, lock)))
468                 return -EIO;
469         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
470         return 0;
471 }
472
473 static int
474 nlmclt_encode_unlockargs(struct rpc_rqst *req, u32 *p, nlm_args *argp)
475 {
476         struct nlm_lock *lock = &argp->lock;
477
478         if (!(p = nlm_encode_cookie(p, &argp->cookie)))
479                 return -EIO;
480         if (!(p = nlm_encode_lock(p, lock)))
481                 return -EIO;
482         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
483         return 0;
484 }
485
486 static int
487 nlmclt_encode_res(struct rpc_rqst *req, u32 *p, struct nlm_res *resp)
488 {
489         if (!(p = nlm_encode_cookie(p, &resp->cookie)))
490                 return -EIO;
491         *p++ = resp->status;
492         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
493         return 0;
494 }
495
496 static int
497 nlmclt_encode_testres(struct rpc_rqst *req, u32 *p, struct nlm_res *resp)
498 {
499         if (!(p = nlm_encode_testres(p, resp)))
500                 return -EIO;
501         req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
502         return 0;
503 }
504
505 static int
506 nlmclt_decode_res(struct rpc_rqst *req, u32 *p, struct nlm_res *resp)
507 {
508         if (!(p = nlm_decode_cookie(p, &resp->cookie)))
509                 return -EIO;
510         resp->status = ntohl(*p++);
511         return 0;
512 }
513
514 /*
515  * Buffer requirements for NLM
516  */
517 #define NLM_void_sz             0
518 #define NLM_cookie_sz           1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
519 #define NLM_caller_sz           1+XDR_QUADLEN(sizeof(system_utsname.nodename))
520 #define NLM_netobj_sz           1+XDR_QUADLEN(XDR_MAX_NETOBJ)
521 /* #define NLM_owner_sz         1+XDR_QUADLEN(NLM_MAXOWNER) */
522 #define NLM_fhandle_sz          1+XDR_QUADLEN(NFS2_FHSIZE)
523 #define NLM_lock_sz             3+NLM_caller_sz+NLM_netobj_sz+NLM_fhandle_sz
524 #define NLM_holder_sz           4+NLM_netobj_sz
525
526 #define NLM_testargs_sz         NLM_cookie_sz+1+NLM_lock_sz
527 #define NLM_lockargs_sz         NLM_cookie_sz+4+NLM_lock_sz
528 #define NLM_cancargs_sz         NLM_cookie_sz+2+NLM_lock_sz
529 #define NLM_unlockargs_sz       NLM_cookie_sz+NLM_lock_sz
530
531 #define NLM_testres_sz          NLM_cookie_sz+1+NLM_holder_sz
532 #define NLM_res_sz              NLM_cookie_sz+1
533 #define NLM_norep_sz            0
534
535 #ifndef MAX
536 # define MAX(a, b)              (((a) > (b))? (a) : (b))
537 #endif
538
539 /*
540  * For NLM, a void procedure really returns nothing
541  */
542 #define nlmclt_decode_norep     NULL
543
544 #define PROC(proc, argtype, restype)    \
545 [NLMPROC_##proc] = {                                                    \
546         .p_proc      = NLMPROC_##proc,                                  \
547         .p_encode    = (kxdrproc_t) nlmclt_encode_##argtype,            \
548         .p_decode    = (kxdrproc_t) nlmclt_decode_##restype,            \
549         .p_bufsiz    = MAX(NLM_##argtype##_sz, NLM_##restype##_sz) << 2,        \
550         .p_statidx   = NLMPROC_##proc,                                  \
551         .p_name      = #proc,                                           \
552         }
553
554 static struct rpc_procinfo      nlm_procedures[] = {
555     PROC(TEST,          testargs,       testres),
556     PROC(LOCK,          lockargs,       res),
557     PROC(CANCEL,        cancargs,       res),
558     PROC(UNLOCK,        unlockargs,     res),
559     PROC(GRANTED,       testargs,       res),
560     PROC(TEST_MSG,      testargs,       norep),
561     PROC(LOCK_MSG,      lockargs,       norep),
562     PROC(CANCEL_MSG,    cancargs,       norep),
563     PROC(UNLOCK_MSG,    unlockargs,     norep),
564     PROC(GRANTED_MSG,   testargs,       norep),
565     PROC(TEST_RES,      testres,        norep),
566     PROC(LOCK_RES,      res,            norep),
567     PROC(CANCEL_RES,    res,            norep),
568     PROC(UNLOCK_RES,    res,            norep),
569     PROC(GRANTED_RES,   res,            norep),
570 #ifdef NLMCLNT_SUPPORT_SHARES
571     PROC(SHARE,         shareargs,      shareres),
572     PROC(UNSHARE,       shareargs,      shareres),
573     PROC(NM_LOCK,       lockargs,       res),
574     PROC(FREE_ALL,      notify,         void),
575 #endif
576 };
577
578 static struct rpc_version       nlm_version1 = {
579                 .number         = 1,
580                 .nrprocs        = 16,
581                 .procs          = nlm_procedures,
582 };
583
584 static struct rpc_version       nlm_version3 = {
585                 .number         = 3,
586                 .nrprocs        = 24,
587                 .procs          = nlm_procedures,
588 };
589
590 #ifdef  CONFIG_LOCKD_V4
591 extern struct rpc_version nlm_version4;
592 #endif
593
594 static struct rpc_version *     nlm_versions[] = {
595         [1] = &nlm_version1,
596         [3] = &nlm_version3,
597 #ifdef  CONFIG_LOCKD_V4
598         [4] = &nlm_version4,
599 #endif
600 };
601
602 static struct rpc_stat          nlm_stats;
603
604 struct rpc_program              nlm_program = {
605                 .name           = "lockd",
606                 .number         = NLM_PROGRAM,
607                 .nrvers         = ARRAY_SIZE(nlm_versions),
608                 .version        = nlm_versions,
609                 .stats          = &nlm_stats,
610 };
611
612 #ifdef RPC_DEBUG
613 const char *nlmdbg_cookie2a(const struct nlm_cookie *cookie)
614 {
615         /*
616          * We can get away with a static buffer because we're only
617          * called with BKL held.
618          */
619         static char buf[2*NLM_MAXCOOKIELEN+1];
620         int i;
621         int len = sizeof(buf);
622         char *p = buf;
623
624         len--;  /* allow for trailing \0 */
625         if (len < 3)
626                 return "???";
627         for (i = 0 ; i < cookie->len ; i++) {
628                 if (len < 2) {
629                         strcpy(p-3, "...");
630                         break;
631                 }
632                 sprintf(p, "%02x", cookie->data[i]);
633                 p += 2;
634                 len -= 2;
635         }
636         *p = '\0';
637
638         return buf;
639 }
640 #endif