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