2 * linux/fs/lockd/xdr4.c
4 * XDR support for lockd and the lock client.
6 * Copyright (C) 1995, 1996 Olaf Kirch <okir@monad.swb.de>
7 * Copyright (C) 1999, Trond Myklebust <trond.myklebust@fys.uio.no>
10 #include <linux/types.h>
11 #include <linux/sched.h>
12 #include <linux/utsname.h>
13 #include <linux/nfs.h>
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>
21 #define NLMDBG_FACILITY NLMDBG_XDR
24 s64_to_loff_t(__s64 offset)
26 return (loff_t)offset;
31 loff_t_to_s64(loff_t offset)
34 if (offset > NLM4_OFFSET_MAX)
35 res = NLM4_OFFSET_MAX;
36 else if (offset < -NLM4_OFFSET_MAX)
37 res = -NLM4_OFFSET_MAX;
44 * XDR functions for basic NLM types
47 nlm4_decode_cookie(__be32 *p, struct nlm_cookie *c)
56 memset(c->data, 0, 4); /* hockeypux brain damage */
58 else if(len<=NLM_MAXCOOKIELEN)
61 memcpy(c->data, p, len);
66 dprintk("lockd: bad cookie size %d (only cookies under "
67 "%d bytes are supported.)\n",
68 len, NLM_MAXCOOKIELEN);
75 nlm4_encode_cookie(__be32 *p, struct nlm_cookie *c)
78 memcpy(p, c->data, c->len);
79 p+=XDR_QUADLEN(c->len);
84 nlm4_decode_fh(__be32 *p, struct nfs_fh *f)
86 memset(f->data, 0, sizeof(f->data));
87 f->size = ntohl(*p++);
88 if (f->size > NFS_MAXFHSIZE) {
89 dprintk("lockd: bad fhandle size %d (should be <=%d)\n",
90 f->size, NFS_MAXFHSIZE);
93 memcpy(f->data, p, f->size);
94 return p + XDR_QUADLEN(f->size);
98 nlm4_encode_fh(__be32 *p, struct nfs_fh *f)
100 *p++ = htonl(f->size);
101 if (f->size) p[XDR_QUADLEN(f->size)-1] = 0; /* don't leak anything */
102 memcpy(p, f->data, f->size);
103 return p + XDR_QUADLEN(f->size);
107 * Encode and decode owner handle
110 nlm4_decode_oh(__be32 *p, struct xdr_netobj *oh)
112 return xdr_decode_netobj(p, oh);
116 nlm4_encode_oh(__be32 *p, struct xdr_netobj *oh)
118 return xdr_encode_netobj(p, oh);
122 nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
124 struct file_lock *fl = &lock->fl;
128 if (!(p = xdr_decode_string_inplace(p, &lock->caller,
129 &lock->len, NLM_MAXSTRLEN))
130 || !(p = nlm4_decode_fh(p, &lock->fh))
131 || !(p = nlm4_decode_oh(p, &lock->oh)))
133 lock->svid = ntohl(*p++);
136 fl->fl_owner = current->files;
137 fl->fl_pid = (pid_t)lock->svid;
138 fl->fl_flags = FL_POSIX;
139 fl->fl_type = F_RDLCK; /* as good as anything else */
140 p = xdr_decode_hyper(p, &start);
141 p = xdr_decode_hyper(p, &len);
142 end = start + len - 1;
144 fl->fl_start = s64_to_loff_t(start);
146 if (len == 0 || end < 0)
147 fl->fl_end = OFFSET_MAX;
149 fl->fl_end = s64_to_loff_t(end);
154 * Encode a lock as part of an NLM call
157 nlm4_encode_lock(__be32 *p, struct nlm_lock *lock)
159 struct file_lock *fl = &lock->fl;
162 if (!(p = xdr_encode_string(p, lock->caller))
163 || !(p = nlm4_encode_fh(p, &lock->fh))
164 || !(p = nlm4_encode_oh(p, &lock->oh)))
167 if (fl->fl_start > NLM4_OFFSET_MAX
168 || (fl->fl_end > NLM4_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
171 *p++ = htonl(lock->svid);
173 start = loff_t_to_s64(fl->fl_start);
174 if (fl->fl_end == OFFSET_MAX)
177 len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
179 p = xdr_encode_hyper(p, start);
180 p = xdr_encode_hyper(p, len);
186 * Encode result of a TEST/TEST_MSG call
189 nlm4_encode_testres(__be32 *p, struct nlm_res *resp)
193 dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
194 if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
198 if (resp->status == nlm_lck_denied) {
199 struct file_lock *fl = &resp->lock.fl;
201 *p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
202 *p++ = htonl(resp->lock.svid);
204 /* Encode owner handle. */
205 if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
208 start = loff_t_to_s64(fl->fl_start);
209 if (fl->fl_end == OFFSET_MAX)
212 len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
214 p = xdr_encode_hyper(p, start);
215 p = xdr_encode_hyper(p, len);
216 dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n",
217 resp->status, (int)resp->lock.svid, fl->fl_type,
218 (long long)fl->fl_start, (long long)fl->fl_end);
221 dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
227 * First, the server side XDR functions
230 nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
234 if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
237 exclusive = ntohl(*p++);
238 if (!(p = nlm4_decode_lock(p, &argp->lock)))
241 argp->lock.fl.fl_type = F_WRLCK;
243 return xdr_argsize_check(rqstp, p);
247 nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
249 if (!(p = nlm4_encode_testres(p, resp)))
251 return xdr_ressize_check(rqstp, p);
255 nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
259 if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
261 argp->block = ntohl(*p++);
262 exclusive = ntohl(*p++);
263 if (!(p = nlm4_decode_lock(p, &argp->lock)))
266 argp->lock.fl.fl_type = F_WRLCK;
267 argp->reclaim = ntohl(*p++);
268 argp->state = ntohl(*p++);
269 argp->monitor = 1; /* monitor client by default */
271 return xdr_argsize_check(rqstp, p);
275 nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
279 if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
281 argp->block = ntohl(*p++);
282 exclusive = ntohl(*p++);
283 if (!(p = nlm4_decode_lock(p, &argp->lock)))
286 argp->lock.fl.fl_type = F_WRLCK;
287 return xdr_argsize_check(rqstp, p);
291 nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
293 if (!(p = nlm4_decode_cookie(p, &argp->cookie))
294 || !(p = nlm4_decode_lock(p, &argp->lock)))
296 argp->lock.fl.fl_type = F_UNLCK;
297 return xdr_argsize_check(rqstp, p);
301 nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
303 struct nlm_lock *lock = &argp->lock;
305 memset(lock, 0, sizeof(*lock));
306 locks_init_lock(&lock->fl);
307 lock->svid = ~(u32) 0;
308 lock->fl.fl_pid = (pid_t)lock->svid;
310 if (!(p = nlm4_decode_cookie(p, &argp->cookie))
311 || !(p = xdr_decode_string_inplace(p, &lock->caller,
312 &lock->len, NLM_MAXSTRLEN))
313 || !(p = nlm4_decode_fh(p, &lock->fh))
314 || !(p = nlm4_decode_oh(p, &lock->oh)))
316 argp->fsm_mode = ntohl(*p++);
317 argp->fsm_access = ntohl(*p++);
318 return xdr_argsize_check(rqstp, p);
322 nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
324 if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
327 *p++ = xdr_zero; /* sequence argument */
328 return xdr_ressize_check(rqstp, p);
332 nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
334 if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
337 return xdr_ressize_check(rqstp, p);
341 nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
343 struct nlm_lock *lock = &argp->lock;
345 if (!(p = xdr_decode_string_inplace(p, &lock->caller,
346 &lock->len, NLM_MAXSTRLEN)))
348 argp->state = ntohl(*p++);
349 return xdr_argsize_check(rqstp, p);
353 nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp)
355 if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
357 argp->state = ntohl(*p++);
358 memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
359 p += XDR_QUADLEN(SM_PRIV_SIZE);
360 return xdr_argsize_check(rqstp, p);
364 nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
366 if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
369 return xdr_argsize_check(rqstp, p);
373 nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
375 return xdr_argsize_check(rqstp, p);
379 nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
381 return xdr_ressize_check(rqstp, p);
385 * Now, the client side XDR functions
387 #ifdef NLMCLNT_SUPPORT_SHARES
389 nlm4clt_decode_void(struct rpc_rqst *req, __be32 *p, void *ptr)
396 nlm4clt_encode_testargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
398 struct nlm_lock *lock = &argp->lock;
400 if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
402 *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
403 if (!(p = nlm4_encode_lock(p, lock)))
405 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
410 nlm4clt_decode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
412 if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
415 if (resp->status == nlm_lck_denied) {
416 struct file_lock *fl = &resp->lock.fl;
421 memset(&resp->lock, 0, sizeof(resp->lock));
424 resp->lock.svid = ntohl(*p++);
425 fl->fl_pid = (pid_t)resp->lock.svid;
426 if (!(p = nlm4_decode_oh(p, &resp->lock.oh)))
429 fl->fl_flags = FL_POSIX;
430 fl->fl_type = excl? F_WRLCK : F_RDLCK;
431 p = xdr_decode_hyper(p, &start);
432 p = xdr_decode_hyper(p, &len);
433 end = start + len - 1;
435 fl->fl_start = s64_to_loff_t(start);
436 if (len == 0 || end < 0)
437 fl->fl_end = OFFSET_MAX;
439 fl->fl_end = s64_to_loff_t(end);
446 nlm4clt_encode_lockargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
448 struct nlm_lock *lock = &argp->lock;
450 if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
452 *p++ = argp->block? xdr_one : xdr_zero;
453 *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
454 if (!(p = nlm4_encode_lock(p, lock)))
456 *p++ = argp->reclaim? xdr_one : xdr_zero;
457 *p++ = htonl(argp->state);
458 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
463 nlm4clt_encode_cancargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
465 struct nlm_lock *lock = &argp->lock;
467 if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
469 *p++ = argp->block? xdr_one : xdr_zero;
470 *p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
471 if (!(p = nlm4_encode_lock(p, lock)))
473 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
478 nlm4clt_encode_unlockargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
480 struct nlm_lock *lock = &argp->lock;
482 if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
484 if (!(p = nlm4_encode_lock(p, lock)))
486 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
491 nlm4clt_encode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
493 if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
496 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
501 nlm4clt_encode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
503 if (!(p = nlm4_encode_testres(p, resp)))
505 req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
510 nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
512 if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
518 #if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
519 # error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
522 #if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)
523 # error "NLM host name cannot be larger than NLM's maximum string length!"
527 * Buffer requirements for NLM
529 #define NLM4_void_sz 0
530 #define NLM4_cookie_sz 1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
531 #define NLM4_caller_sz 1+XDR_QUADLEN(NLMCLNT_OHSIZE)
532 #define NLM4_owner_sz 1+XDR_QUADLEN(NLMCLNT_OHSIZE)
533 #define NLM4_fhandle_sz 1+XDR_QUADLEN(NFS3_FHSIZE)
534 #define NLM4_lock_sz 5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz
535 #define NLM4_holder_sz 6+NLM4_owner_sz
537 #define NLM4_testargs_sz NLM4_cookie_sz+1+NLM4_lock_sz
538 #define NLM4_lockargs_sz NLM4_cookie_sz+4+NLM4_lock_sz
539 #define NLM4_cancargs_sz NLM4_cookie_sz+2+NLM4_lock_sz
540 #define NLM4_unlockargs_sz NLM4_cookie_sz+NLM4_lock_sz
542 #define NLM4_testres_sz NLM4_cookie_sz+1+NLM4_holder_sz
543 #define NLM4_res_sz NLM4_cookie_sz+1
544 #define NLM4_norep_sz 0
547 * For NLM, a void procedure really returns nothing
549 #define nlm4clt_decode_norep NULL
551 #define PROC(proc, argtype, restype) \
552 [NLMPROC_##proc] = { \
553 .p_proc = NLMPROC_##proc, \
554 .p_encode = (kxdrproc_t) nlm4clt_encode_##argtype, \
555 .p_decode = (kxdrproc_t) nlm4clt_decode_##restype, \
556 .p_arglen = NLM4_##argtype##_sz, \
557 .p_replen = NLM4_##restype##_sz, \
558 .p_statidx = NLMPROC_##proc, \
562 static struct rpc_procinfo nlm4_procedures[] = {
563 PROC(TEST, testargs, testres),
564 PROC(LOCK, lockargs, res),
565 PROC(CANCEL, cancargs, res),
566 PROC(UNLOCK, unlockargs, res),
567 PROC(GRANTED, testargs, res),
568 PROC(TEST_MSG, testargs, norep),
569 PROC(LOCK_MSG, lockargs, norep),
570 PROC(CANCEL_MSG, cancargs, norep),
571 PROC(UNLOCK_MSG, unlockargs, norep),
572 PROC(GRANTED_MSG, testargs, norep),
573 PROC(TEST_RES, testres, norep),
574 PROC(LOCK_RES, res, norep),
575 PROC(CANCEL_RES, res, norep),
576 PROC(UNLOCK_RES, res, norep),
577 PROC(GRANTED_RES, res, norep),
578 #ifdef NLMCLNT_SUPPORT_SHARES
579 PROC(SHARE, shareargs, shareres),
580 PROC(UNSHARE, shareargs, shareres),
581 PROC(NM_LOCK, lockargs, res),
582 PROC(FREE_ALL, notify, void),
586 struct rpc_version nlm_version4 = {
589 .procs = nlm4_procedures,