1 /* 2 * Copyright (c) 2004 The Regents of the University of Michigan. 3 * Copyright (c) 2012 Jeff Layton <jlayton@redhat.com> 4 * All rights reserved. 5 * 6 * Andy Adamson <andros@citi.umich.edu> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. Neither the name of the University nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED 22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 24 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 28 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 * 33 */ 34 35 #include <crypto/hash.h> 36 #include <linux/file.h> 37 #include <linux/slab.h> 38 #include <linux/namei.h> 39 #include <linux/sched.h> 40 #include <linux/fs.h> 41 #include <linux/module.h> 42 #include <net/net_namespace.h> 43 #include <linux/sunrpc/rpc_pipe_fs.h> 44 #include <linux/sunrpc/clnt.h> 45 #include <linux/nfsd/cld.h> 46 47 #include "nfsd.h" 48 #include "state.h" 49 #include "vfs.h" 50 #include "netns.h" 51 52 #define NFSDDBG_FACILITY NFSDDBG_PROC 53 54 /* Declarations */ 55 struct nfsd4_client_tracking_ops { 56 int (*init)(struct net *); 57 void (*exit)(struct net *); 58 void (*create)(struct nfs4_client *); 59 void (*remove)(struct nfs4_client *); 60 int (*check)(struct nfs4_client *); 61 void (*grace_done)(struct nfsd_net *); 62 uint8_t version; 63 size_t msglen; 64 }; 65 66 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops; 67 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2; 68 69 /* Globals */ 70 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery"; 71 72 static int 73 nfs4_save_creds(const struct cred **original_creds) 74 { 75 struct cred *new; 76 77 new = prepare_creds(); 78 if (!new) 79 return -ENOMEM; 80 81 new->fsuid = GLOBAL_ROOT_UID; 82 new->fsgid = GLOBAL_ROOT_GID; 83 *original_creds = override_creds(new); 84 put_cred(new); 85 return 0; 86 } 87 88 static void 89 nfs4_reset_creds(const struct cred *original) 90 { 91 revert_creds(original); 92 } 93 94 static void 95 md5_to_hex(char *out, char *md5) 96 { 97 int i; 98 99 for (i=0; i<16; i++) { 100 unsigned char c = md5[i]; 101 102 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1); 103 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1); 104 } 105 *out = '\0'; 106 } 107 108 static int 109 nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname) 110 { 111 struct xdr_netobj cksum; 112 struct crypto_shash *tfm; 113 int status; 114 115 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n", 116 clname->len, clname->data); 117 tfm = crypto_alloc_shash("md5", 0, 0); 118 if (IS_ERR(tfm)) { 119 status = PTR_ERR(tfm); 120 goto out_no_tfm; 121 } 122 123 cksum.len = crypto_shash_digestsize(tfm); 124 cksum.data = kmalloc(cksum.len, GFP_KERNEL); 125 if (cksum.data == NULL) { 126 status = -ENOMEM; 127 goto out; 128 } 129 130 status = crypto_shash_tfm_digest(tfm, clname->data, clname->len, 131 cksum.data); 132 if (status) 133 goto out; 134 135 md5_to_hex(dname, cksum.data); 136 137 status = 0; 138 out: 139 kfree(cksum.data); 140 crypto_free_shash(tfm); 141 out_no_tfm: 142 return status; 143 } 144 145 /* 146 * If we had an error generating the recdir name for the legacy tracker 147 * then warn the admin. If the error doesn't appear to be transient, 148 * then disable recovery tracking. 149 */ 150 static void 151 legacy_recdir_name_error(struct nfs4_client *clp, int error) 152 { 153 printk(KERN_ERR "NFSD: unable to generate recoverydir " 154 "name (%d).\n", error); 155 156 /* 157 * if the algorithm just doesn't exist, then disable the recovery 158 * tracker altogether. The crypto libs will generally return this if 159 * FIPS is enabled as well. 160 */ 161 if (error == -ENOENT) { 162 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. " 163 "Reboot recovery will not function correctly!\n"); 164 nfsd4_client_tracking_exit(clp->net); 165 } 166 } 167 168 static void 169 __nfsd4_create_reclaim_record_grace(struct nfs4_client *clp, 170 const char *dname, int len, struct nfsd_net *nn) 171 { 172 struct xdr_netobj name; 173 struct xdr_netobj princhash = { .len = 0, .data = NULL }; 174 struct nfs4_client_reclaim *crp; 175 176 name.data = kmemdup(dname, len, GFP_KERNEL); 177 if (!name.data) { 178 dprintk("%s: failed to allocate memory for name.data!\n", 179 __func__); 180 return; 181 } 182 name.len = len; 183 crp = nfs4_client_to_reclaim(name, princhash, nn); 184 if (!crp) { 185 kfree(name.data); 186 return; 187 } 188 crp->cr_clp = clp; 189 } 190 191 static void 192 nfsd4_create_clid_dir(struct nfs4_client *clp) 193 { 194 const struct cred *original_cred; 195 char dname[HEXDIR_LEN]; 196 struct dentry *dir, *dentry; 197 int status; 198 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 199 200 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 201 return; 202 if (!nn->rec_file) 203 return; 204 205 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 206 if (status) 207 return legacy_recdir_name_error(clp, status); 208 209 status = nfs4_save_creds(&original_cred); 210 if (status < 0) 211 return; 212 213 status = mnt_want_write_file(nn->rec_file); 214 if (status) 215 goto out_creds; 216 217 dir = nn->rec_file->f_path.dentry; 218 /* lock the parent */ 219 inode_lock(d_inode(dir)); 220 221 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1); 222 if (IS_ERR(dentry)) { 223 status = PTR_ERR(dentry); 224 goto out_unlock; 225 } 226 if (d_really_is_positive(dentry)) 227 /* 228 * In the 4.1 case, where we're called from 229 * reclaim_complete(), records from the previous reboot 230 * may still be left, so this is OK. 231 * 232 * In the 4.0 case, we should never get here; but we may 233 * as well be forgiving and just succeed silently. 234 */ 235 goto out_put; 236 status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU); 237 out_put: 238 dput(dentry); 239 out_unlock: 240 inode_unlock(d_inode(dir)); 241 if (status == 0) { 242 if (nn->in_grace) 243 __nfsd4_create_reclaim_record_grace(clp, dname, 244 HEXDIR_LEN, nn); 245 vfs_fsync(nn->rec_file, 0); 246 } else { 247 printk(KERN_ERR "NFSD: failed to write recovery record" 248 " (err %d); please check that %s exists" 249 " and is writeable", status, 250 user_recovery_dirname); 251 } 252 mnt_drop_write_file(nn->rec_file); 253 out_creds: 254 nfs4_reset_creds(original_cred); 255 } 256 257 typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *); 258 259 struct name_list { 260 char name[HEXDIR_LEN]; 261 struct list_head list; 262 }; 263 264 struct nfs4_dir_ctx { 265 struct dir_context ctx; 266 struct list_head names; 267 }; 268 269 static int 270 nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen, 271 loff_t offset, u64 ino, unsigned int d_type) 272 { 273 struct nfs4_dir_ctx *ctx = 274 container_of(__ctx, struct nfs4_dir_ctx, ctx); 275 struct name_list *entry; 276 277 if (namlen != HEXDIR_LEN - 1) 278 return 0; 279 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL); 280 if (entry == NULL) 281 return -ENOMEM; 282 memcpy(entry->name, name, HEXDIR_LEN - 1); 283 entry->name[HEXDIR_LEN - 1] = '\0'; 284 list_add(&entry->list, &ctx->names); 285 return 0; 286 } 287 288 static int 289 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn) 290 { 291 const struct cred *original_cred; 292 struct dentry *dir = nn->rec_file->f_path.dentry; 293 struct nfs4_dir_ctx ctx = { 294 .ctx.actor = nfsd4_build_namelist, 295 .names = LIST_HEAD_INIT(ctx.names) 296 }; 297 struct name_list *entry, *tmp; 298 int status; 299 300 status = nfs4_save_creds(&original_cred); 301 if (status < 0) 302 return status; 303 304 status = vfs_llseek(nn->rec_file, 0, SEEK_SET); 305 if (status < 0) { 306 nfs4_reset_creds(original_cred); 307 return status; 308 } 309 310 status = iterate_dir(nn->rec_file, &ctx.ctx); 311 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 312 313 list_for_each_entry_safe(entry, tmp, &ctx.names, list) { 314 if (!status) { 315 struct dentry *dentry; 316 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1); 317 if (IS_ERR(dentry)) { 318 status = PTR_ERR(dentry); 319 break; 320 } 321 status = f(dir, dentry, nn); 322 dput(dentry); 323 } 324 list_del(&entry->list); 325 kfree(entry); 326 } 327 inode_unlock(d_inode(dir)); 328 nfs4_reset_creds(original_cred); 329 330 list_for_each_entry_safe(entry, tmp, &ctx.names, list) { 331 dprintk("NFSD: %s. Left entry %s\n", __func__, entry->name); 332 list_del(&entry->list); 333 kfree(entry); 334 } 335 return status; 336 } 337 338 static int 339 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn) 340 { 341 struct dentry *dir, *dentry; 342 int status; 343 344 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name); 345 346 dir = nn->rec_file->f_path.dentry; 347 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 348 dentry = lookup_one_len(name, dir, namlen); 349 if (IS_ERR(dentry)) { 350 status = PTR_ERR(dentry); 351 goto out_unlock; 352 } 353 status = -ENOENT; 354 if (d_really_is_negative(dentry)) 355 goto out; 356 status = vfs_rmdir(d_inode(dir), dentry); 357 out: 358 dput(dentry); 359 out_unlock: 360 inode_unlock(d_inode(dir)); 361 return status; 362 } 363 364 static void 365 __nfsd4_remove_reclaim_record_grace(const char *dname, int len, 366 struct nfsd_net *nn) 367 { 368 struct xdr_netobj name; 369 struct nfs4_client_reclaim *crp; 370 371 name.data = kmemdup(dname, len, GFP_KERNEL); 372 if (!name.data) { 373 dprintk("%s: failed to allocate memory for name.data!\n", 374 __func__); 375 return; 376 } 377 name.len = len; 378 crp = nfsd4_find_reclaim_client(name, nn); 379 kfree(name.data); 380 if (crp) 381 nfs4_remove_reclaim_record(crp, nn); 382 } 383 384 static void 385 nfsd4_remove_clid_dir(struct nfs4_client *clp) 386 { 387 const struct cred *original_cred; 388 char dname[HEXDIR_LEN]; 389 int status; 390 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 391 392 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 393 return; 394 395 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 396 if (status) 397 return legacy_recdir_name_error(clp, status); 398 399 status = mnt_want_write_file(nn->rec_file); 400 if (status) 401 goto out; 402 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 403 404 status = nfs4_save_creds(&original_cred); 405 if (status < 0) 406 goto out_drop_write; 407 408 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn); 409 nfs4_reset_creds(original_cred); 410 if (status == 0) { 411 vfs_fsync(nn->rec_file, 0); 412 if (nn->in_grace) 413 __nfsd4_remove_reclaim_record_grace(dname, 414 HEXDIR_LEN, nn); 415 } 416 out_drop_write: 417 mnt_drop_write_file(nn->rec_file); 418 out: 419 if (status) 420 printk("NFSD: Failed to remove expired client state directory" 421 " %.*s\n", HEXDIR_LEN, dname); 422 } 423 424 static int 425 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) 426 { 427 int status; 428 struct xdr_netobj name; 429 430 if (child->d_name.len != HEXDIR_LEN - 1) { 431 printk("%s: illegal name %pd in recovery directory\n", 432 __func__, child); 433 /* Keep trying; maybe the others are OK: */ 434 return 0; 435 } 436 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL); 437 if (!name.data) { 438 dprintk("%s: failed to allocate memory for name.data!\n", 439 __func__); 440 goto out; 441 } 442 name.len = HEXDIR_LEN; 443 if (nfs4_has_reclaimed_state(name, nn)) 444 goto out_free; 445 446 status = vfs_rmdir(d_inode(parent), child); 447 if (status) 448 printk("failed to remove client recovery directory %pd\n", 449 child); 450 out_free: 451 kfree(name.data); 452 out: 453 /* Keep trying, success or failure: */ 454 return 0; 455 } 456 457 static void 458 nfsd4_recdir_purge_old(struct nfsd_net *nn) 459 { 460 int status; 461 462 nn->in_grace = false; 463 if (!nn->rec_file) 464 return; 465 status = mnt_want_write_file(nn->rec_file); 466 if (status) 467 goto out; 468 status = nfsd4_list_rec_dir(purge_old, nn); 469 if (status == 0) 470 vfs_fsync(nn->rec_file, 0); 471 mnt_drop_write_file(nn->rec_file); 472 out: 473 nfs4_release_reclaim(nn); 474 if (status) 475 printk("nfsd4: failed to purge old clients from recovery" 476 " directory %pD\n", nn->rec_file); 477 } 478 479 static int 480 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) 481 { 482 struct xdr_netobj name; 483 struct xdr_netobj princhash = { .len = 0, .data = NULL }; 484 485 if (child->d_name.len != HEXDIR_LEN - 1) { 486 printk("%s: illegal name %pd in recovery directory\n", 487 __func__, child); 488 /* Keep trying; maybe the others are OK: */ 489 return 0; 490 } 491 name.data = kmemdup_nul(child->d_name.name, child->d_name.len, GFP_KERNEL); 492 if (!name.data) { 493 dprintk("%s: failed to allocate memory for name.data!\n", 494 __func__); 495 goto out; 496 } 497 name.len = HEXDIR_LEN; 498 if (!nfs4_client_to_reclaim(name, princhash, nn)) 499 kfree(name.data); 500 out: 501 return 0; 502 } 503 504 static int 505 nfsd4_recdir_load(struct net *net) { 506 int status; 507 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 508 509 if (!nn->rec_file) 510 return 0; 511 512 status = nfsd4_list_rec_dir(load_recdir, nn); 513 if (status) 514 printk("nfsd4: failed loading clients from recovery" 515 " directory %pD\n", nn->rec_file); 516 return status; 517 } 518 519 /* 520 * Hold reference to the recovery directory. 521 */ 522 523 static int 524 nfsd4_init_recdir(struct net *net) 525 { 526 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 527 const struct cred *original_cred; 528 int status; 529 530 printk("NFSD: Using %s as the NFSv4 state recovery directory\n", 531 user_recovery_dirname); 532 533 BUG_ON(nn->rec_file); 534 535 status = nfs4_save_creds(&original_cred); 536 if (status < 0) { 537 printk("NFSD: Unable to change credentials to find recovery" 538 " directory: error %d\n", 539 status); 540 return status; 541 } 542 543 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0); 544 if (IS_ERR(nn->rec_file)) { 545 printk("NFSD: unable to find recovery directory %s\n", 546 user_recovery_dirname); 547 status = PTR_ERR(nn->rec_file); 548 nn->rec_file = NULL; 549 } 550 551 nfs4_reset_creds(original_cred); 552 if (!status) 553 nn->in_grace = true; 554 return status; 555 } 556 557 static void 558 nfsd4_shutdown_recdir(struct net *net) 559 { 560 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 561 562 if (!nn->rec_file) 563 return; 564 fput(nn->rec_file); 565 nn->rec_file = NULL; 566 } 567 568 static int 569 nfs4_legacy_state_init(struct net *net) 570 { 571 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 572 int i; 573 574 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, 575 sizeof(struct list_head), 576 GFP_KERNEL); 577 if (!nn->reclaim_str_hashtbl) 578 return -ENOMEM; 579 580 for (i = 0; i < CLIENT_HASH_SIZE; i++) 581 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]); 582 nn->reclaim_str_hashtbl_size = 0; 583 584 return 0; 585 } 586 587 static void 588 nfs4_legacy_state_shutdown(struct net *net) 589 { 590 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 591 592 kfree(nn->reclaim_str_hashtbl); 593 } 594 595 static int 596 nfsd4_load_reboot_recovery_data(struct net *net) 597 { 598 int status; 599 600 status = nfsd4_init_recdir(net); 601 if (status) 602 return status; 603 604 status = nfsd4_recdir_load(net); 605 if (status) 606 nfsd4_shutdown_recdir(net); 607 608 return status; 609 } 610 611 static int 612 nfsd4_legacy_tracking_init(struct net *net) 613 { 614 int status; 615 616 /* XXX: The legacy code won't work in a container */ 617 if (net != &init_net) { 618 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n"); 619 return -EINVAL; 620 } 621 622 status = nfs4_legacy_state_init(net); 623 if (status) 624 return status; 625 626 status = nfsd4_load_reboot_recovery_data(net); 627 if (status) 628 goto err; 629 printk("NFSD: Using legacy client tracking operations.\n"); 630 return 0; 631 632 err: 633 nfs4_legacy_state_shutdown(net); 634 return status; 635 } 636 637 static void 638 nfsd4_legacy_tracking_exit(struct net *net) 639 { 640 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 641 642 nfs4_release_reclaim(nn); 643 nfsd4_shutdown_recdir(net); 644 nfs4_legacy_state_shutdown(net); 645 } 646 647 /* 648 * Change the NFSv4 recovery directory to recdir. 649 */ 650 int 651 nfs4_reset_recoverydir(char *recdir) 652 { 653 int status; 654 struct path path; 655 656 status = kern_path(recdir, LOOKUP_FOLLOW, &path); 657 if (status) 658 return status; 659 status = -ENOTDIR; 660 if (d_is_dir(path.dentry)) { 661 strcpy(user_recovery_dirname, recdir); 662 status = 0; 663 } 664 path_put(&path); 665 return status; 666 } 667 668 char * 669 nfs4_recoverydir(void) 670 { 671 return user_recovery_dirname; 672 } 673 674 static int 675 nfsd4_check_legacy_client(struct nfs4_client *clp) 676 { 677 int status; 678 char dname[HEXDIR_LEN]; 679 struct nfs4_client_reclaim *crp; 680 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 681 struct xdr_netobj name; 682 683 /* did we already find that this client is stable? */ 684 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 685 return 0; 686 687 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 688 if (status) { 689 legacy_recdir_name_error(clp, status); 690 return status; 691 } 692 693 /* look for it in the reclaim hashtable otherwise */ 694 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL); 695 if (!name.data) { 696 dprintk("%s: failed to allocate memory for name.data!\n", 697 __func__); 698 goto out_enoent; 699 } 700 name.len = HEXDIR_LEN; 701 crp = nfsd4_find_reclaim_client(name, nn); 702 kfree(name.data); 703 if (crp) { 704 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 705 crp->cr_clp = clp; 706 return 0; 707 } 708 709 out_enoent: 710 return -ENOENT; 711 } 712 713 static const struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = { 714 .init = nfsd4_legacy_tracking_init, 715 .exit = nfsd4_legacy_tracking_exit, 716 .create = nfsd4_create_clid_dir, 717 .remove = nfsd4_remove_clid_dir, 718 .check = nfsd4_check_legacy_client, 719 .grace_done = nfsd4_recdir_purge_old, 720 .version = 1, 721 .msglen = 0, 722 }; 723 724 /* Globals */ 725 #define NFSD_PIPE_DIR "nfsd" 726 #define NFSD_CLD_PIPE "cld" 727 728 /* per-net-ns structure for holding cld upcall info */ 729 struct cld_net { 730 struct rpc_pipe *cn_pipe; 731 spinlock_t cn_lock; 732 struct list_head cn_list; 733 unsigned int cn_xid; 734 bool cn_has_legacy; 735 struct crypto_shash *cn_tfm; 736 }; 737 738 struct cld_upcall { 739 struct list_head cu_list; 740 struct cld_net *cu_net; 741 struct completion cu_done; 742 union { 743 struct cld_msg_hdr cu_hdr; 744 struct cld_msg cu_msg; 745 struct cld_msg_v2 cu_msg_v2; 746 } cu_u; 747 }; 748 749 static int 750 __cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg) 751 { 752 int ret; 753 struct rpc_pipe_msg msg; 754 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, cu_u); 755 struct nfsd_net *nn = net_generic(pipe->dentry->d_sb->s_fs_info, 756 nfsd_net_id); 757 758 memset(&msg, 0, sizeof(msg)); 759 msg.data = cmsg; 760 msg.len = nn->client_tracking_ops->msglen; 761 762 ret = rpc_queue_upcall(pipe, &msg); 763 if (ret < 0) { 764 goto out; 765 } 766 767 wait_for_completion(&cup->cu_done); 768 769 if (msg.errno < 0) 770 ret = msg.errno; 771 out: 772 return ret; 773 } 774 775 static int 776 cld_pipe_upcall(struct rpc_pipe *pipe, void *cmsg) 777 { 778 int ret; 779 780 /* 781 * -EAGAIN occurs when pipe is closed and reopened while there are 782 * upcalls queued. 783 */ 784 do { 785 ret = __cld_pipe_upcall(pipe, cmsg); 786 } while (ret == -EAGAIN); 787 788 return ret; 789 } 790 791 static ssize_t 792 __cld_pipe_inprogress_downcall(const struct cld_msg_v2 __user *cmsg, 793 struct nfsd_net *nn) 794 { 795 uint8_t cmd, princhashlen; 796 struct xdr_netobj name, princhash = { .len = 0, .data = NULL }; 797 uint16_t namelen; 798 struct cld_net *cn = nn->cld_net; 799 800 if (get_user(cmd, &cmsg->cm_cmd)) { 801 dprintk("%s: error when copying cmd from userspace", __func__); 802 return -EFAULT; 803 } 804 if (cmd == Cld_GraceStart) { 805 if (nn->client_tracking_ops->version >= 2) { 806 const struct cld_clntinfo __user *ci; 807 808 ci = &cmsg->cm_u.cm_clntinfo; 809 if (get_user(namelen, &ci->cc_name.cn_len)) 810 return -EFAULT; 811 name.data = memdup_user(&ci->cc_name.cn_id, namelen); 812 if (IS_ERR_OR_NULL(name.data)) 813 return -EFAULT; 814 name.len = namelen; 815 get_user(princhashlen, &ci->cc_princhash.cp_len); 816 if (princhashlen > 0) { 817 princhash.data = memdup_user( 818 &ci->cc_princhash.cp_data, 819 princhashlen); 820 if (IS_ERR_OR_NULL(princhash.data)) 821 return -EFAULT; 822 princhash.len = princhashlen; 823 } else 824 princhash.len = 0; 825 } else { 826 const struct cld_name __user *cnm; 827 828 cnm = &cmsg->cm_u.cm_name; 829 if (get_user(namelen, &cnm->cn_len)) 830 return -EFAULT; 831 name.data = memdup_user(&cnm->cn_id, namelen); 832 if (IS_ERR_OR_NULL(name.data)) 833 return -EFAULT; 834 name.len = namelen; 835 } 836 if (name.len > 5 && memcmp(name.data, "hash:", 5) == 0) { 837 name.len = name.len - 5; 838 memmove(name.data, name.data + 5, name.len); 839 cn->cn_has_legacy = true; 840 } 841 if (!nfs4_client_to_reclaim(name, princhash, nn)) { 842 kfree(name.data); 843 kfree(princhash.data); 844 return -EFAULT; 845 } 846 return nn->client_tracking_ops->msglen; 847 } 848 return -EFAULT; 849 } 850 851 static ssize_t 852 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) 853 { 854 struct cld_upcall *tmp, *cup; 855 struct cld_msg_hdr __user *hdr = (struct cld_msg_hdr __user *)src; 856 struct cld_msg_v2 __user *cmsg = (struct cld_msg_v2 __user *)src; 857 uint32_t xid; 858 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info, 859 nfsd_net_id); 860 struct cld_net *cn = nn->cld_net; 861 int16_t status; 862 863 if (mlen != nn->client_tracking_ops->msglen) { 864 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen, 865 nn->client_tracking_ops->msglen); 866 return -EINVAL; 867 } 868 869 /* copy just the xid so we can try to find that */ 870 if (copy_from_user(&xid, &hdr->cm_xid, sizeof(xid)) != 0) { 871 dprintk("%s: error when copying xid from userspace", __func__); 872 return -EFAULT; 873 } 874 875 /* 876 * copy the status so we know whether to remove the upcall from the 877 * list (for -EINPROGRESS, we just want to make sure the xid is 878 * valid, not remove the upcall from the list) 879 */ 880 if (get_user(status, &hdr->cm_status)) { 881 dprintk("%s: error when copying status from userspace", __func__); 882 return -EFAULT; 883 } 884 885 /* walk the list and find corresponding xid */ 886 cup = NULL; 887 spin_lock(&cn->cn_lock); 888 list_for_each_entry(tmp, &cn->cn_list, cu_list) { 889 if (get_unaligned(&tmp->cu_u.cu_hdr.cm_xid) == xid) { 890 cup = tmp; 891 if (status != -EINPROGRESS) 892 list_del_init(&cup->cu_list); 893 break; 894 } 895 } 896 spin_unlock(&cn->cn_lock); 897 898 /* couldn't find upcall? */ 899 if (!cup) { 900 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid); 901 return -EINVAL; 902 } 903 904 if (status == -EINPROGRESS) 905 return __cld_pipe_inprogress_downcall(cmsg, nn); 906 907 if (copy_from_user(&cup->cu_u.cu_msg_v2, src, mlen) != 0) 908 return -EFAULT; 909 910 complete(&cup->cu_done); 911 return mlen; 912 } 913 914 static void 915 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg) 916 { 917 struct cld_msg *cmsg = msg->data; 918 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, 919 cu_u.cu_msg); 920 921 /* errno >= 0 means we got a downcall */ 922 if (msg->errno >= 0) 923 return; 924 925 complete(&cup->cu_done); 926 } 927 928 static const struct rpc_pipe_ops cld_upcall_ops = { 929 .upcall = rpc_pipe_generic_upcall, 930 .downcall = cld_pipe_downcall, 931 .destroy_msg = cld_pipe_destroy_msg, 932 }; 933 934 static struct dentry * 935 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe) 936 { 937 struct dentry *dir, *dentry; 938 939 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR); 940 if (dir == NULL) 941 return ERR_PTR(-ENOENT); 942 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe); 943 dput(dir); 944 return dentry; 945 } 946 947 static void 948 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe) 949 { 950 if (pipe->dentry) 951 rpc_unlink(pipe->dentry); 952 } 953 954 static struct dentry * 955 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe) 956 { 957 struct super_block *sb; 958 struct dentry *dentry; 959 960 sb = rpc_get_sb_net(net); 961 if (!sb) 962 return NULL; 963 dentry = nfsd4_cld_register_sb(sb, pipe); 964 rpc_put_sb_net(net); 965 return dentry; 966 } 967 968 static void 969 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe) 970 { 971 struct super_block *sb; 972 973 sb = rpc_get_sb_net(net); 974 if (sb) { 975 nfsd4_cld_unregister_sb(pipe); 976 rpc_put_sb_net(net); 977 } 978 } 979 980 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */ 981 static int 982 __nfsd4_init_cld_pipe(struct net *net) 983 { 984 int ret; 985 struct dentry *dentry; 986 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 987 struct cld_net *cn; 988 989 if (nn->cld_net) 990 return 0; 991 992 cn = kzalloc(sizeof(*cn), GFP_KERNEL); 993 if (!cn) { 994 ret = -ENOMEM; 995 goto err; 996 } 997 998 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN); 999 if (IS_ERR(cn->cn_pipe)) { 1000 ret = PTR_ERR(cn->cn_pipe); 1001 goto err; 1002 } 1003 spin_lock_init(&cn->cn_lock); 1004 INIT_LIST_HEAD(&cn->cn_list); 1005 1006 dentry = nfsd4_cld_register_net(net, cn->cn_pipe); 1007 if (IS_ERR(dentry)) { 1008 ret = PTR_ERR(dentry); 1009 goto err_destroy_data; 1010 } 1011 1012 cn->cn_pipe->dentry = dentry; 1013 cn->cn_has_legacy = false; 1014 nn->cld_net = cn; 1015 return 0; 1016 1017 err_destroy_data: 1018 rpc_destroy_pipe_data(cn->cn_pipe); 1019 err: 1020 kfree(cn); 1021 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n", 1022 ret); 1023 return ret; 1024 } 1025 1026 static int 1027 nfsd4_init_cld_pipe(struct net *net) 1028 { 1029 int status; 1030 1031 status = __nfsd4_init_cld_pipe(net); 1032 if (!status) 1033 printk("NFSD: Using old nfsdcld client tracking operations.\n"); 1034 return status; 1035 } 1036 1037 static void 1038 nfsd4_remove_cld_pipe(struct net *net) 1039 { 1040 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1041 struct cld_net *cn = nn->cld_net; 1042 1043 nfsd4_cld_unregister_net(net, cn->cn_pipe); 1044 rpc_destroy_pipe_data(cn->cn_pipe); 1045 if (cn->cn_tfm) 1046 crypto_free_shash(cn->cn_tfm); 1047 kfree(nn->cld_net); 1048 nn->cld_net = NULL; 1049 } 1050 1051 static struct cld_upcall * 1052 alloc_cld_upcall(struct nfsd_net *nn) 1053 { 1054 struct cld_upcall *new, *tmp; 1055 struct cld_net *cn = nn->cld_net; 1056 1057 new = kzalloc(sizeof(*new), GFP_KERNEL); 1058 if (!new) 1059 return new; 1060 1061 /* FIXME: hard cap on number in flight? */ 1062 restart_search: 1063 spin_lock(&cn->cn_lock); 1064 list_for_each_entry(tmp, &cn->cn_list, cu_list) { 1065 if (tmp->cu_u.cu_msg.cm_xid == cn->cn_xid) { 1066 cn->cn_xid++; 1067 spin_unlock(&cn->cn_lock); 1068 goto restart_search; 1069 } 1070 } 1071 init_completion(&new->cu_done); 1072 new->cu_u.cu_msg.cm_vers = nn->client_tracking_ops->version; 1073 put_unaligned(cn->cn_xid++, &new->cu_u.cu_msg.cm_xid); 1074 new->cu_net = cn; 1075 list_add(&new->cu_list, &cn->cn_list); 1076 spin_unlock(&cn->cn_lock); 1077 1078 dprintk("%s: allocated xid %u\n", __func__, new->cu_u.cu_msg.cm_xid); 1079 1080 return new; 1081 } 1082 1083 static void 1084 free_cld_upcall(struct cld_upcall *victim) 1085 { 1086 struct cld_net *cn = victim->cu_net; 1087 1088 spin_lock(&cn->cn_lock); 1089 list_del(&victim->cu_list); 1090 spin_unlock(&cn->cn_lock); 1091 kfree(victim); 1092 } 1093 1094 /* Ask daemon to create a new record */ 1095 static void 1096 nfsd4_cld_create(struct nfs4_client *clp) 1097 { 1098 int ret; 1099 struct cld_upcall *cup; 1100 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1101 struct cld_net *cn = nn->cld_net; 1102 1103 /* Don't upcall if it's already stored */ 1104 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1105 return; 1106 1107 cup = alloc_cld_upcall(nn); 1108 if (!cup) { 1109 ret = -ENOMEM; 1110 goto out_err; 1111 } 1112 1113 cup->cu_u.cu_msg.cm_cmd = Cld_Create; 1114 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 1115 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 1116 clp->cl_name.len); 1117 1118 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1119 if (!ret) { 1120 ret = cup->cu_u.cu_msg.cm_status; 1121 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1122 } 1123 1124 free_cld_upcall(cup); 1125 out_err: 1126 if (ret) 1127 printk(KERN_ERR "NFSD: Unable to create client " 1128 "record on stable storage: %d\n", ret); 1129 } 1130 1131 /* Ask daemon to create a new record */ 1132 static void 1133 nfsd4_cld_create_v2(struct nfs4_client *clp) 1134 { 1135 int ret; 1136 struct cld_upcall *cup; 1137 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1138 struct cld_net *cn = nn->cld_net; 1139 struct cld_msg_v2 *cmsg; 1140 struct crypto_shash *tfm = cn->cn_tfm; 1141 struct xdr_netobj cksum; 1142 char *principal = NULL; 1143 1144 /* Don't upcall if it's already stored */ 1145 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1146 return; 1147 1148 cup = alloc_cld_upcall(nn); 1149 if (!cup) { 1150 ret = -ENOMEM; 1151 goto out_err; 1152 } 1153 1154 cmsg = &cup->cu_u.cu_msg_v2; 1155 cmsg->cm_cmd = Cld_Create; 1156 cmsg->cm_u.cm_clntinfo.cc_name.cn_len = clp->cl_name.len; 1157 memcpy(cmsg->cm_u.cm_clntinfo.cc_name.cn_id, clp->cl_name.data, 1158 clp->cl_name.len); 1159 if (clp->cl_cred.cr_raw_principal) 1160 principal = clp->cl_cred.cr_raw_principal; 1161 else if (clp->cl_cred.cr_principal) 1162 principal = clp->cl_cred.cr_principal; 1163 if (principal) { 1164 cksum.len = crypto_shash_digestsize(tfm); 1165 cksum.data = kmalloc(cksum.len, GFP_KERNEL); 1166 if (cksum.data == NULL) { 1167 ret = -ENOMEM; 1168 goto out; 1169 } 1170 ret = crypto_shash_tfm_digest(tfm, principal, strlen(principal), 1171 cksum.data); 1172 if (ret) { 1173 kfree(cksum.data); 1174 goto out; 1175 } 1176 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = cksum.len; 1177 memcpy(cmsg->cm_u.cm_clntinfo.cc_princhash.cp_data, 1178 cksum.data, cksum.len); 1179 kfree(cksum.data); 1180 } else 1181 cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = 0; 1182 1183 ret = cld_pipe_upcall(cn->cn_pipe, cmsg); 1184 if (!ret) { 1185 ret = cmsg->cm_status; 1186 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1187 } 1188 1189 out: 1190 free_cld_upcall(cup); 1191 out_err: 1192 if (ret) 1193 pr_err("NFSD: Unable to create client record on stable storage: %d\n", 1194 ret); 1195 } 1196 1197 /* Ask daemon to create a new record */ 1198 static void 1199 nfsd4_cld_remove(struct nfs4_client *clp) 1200 { 1201 int ret; 1202 struct cld_upcall *cup; 1203 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1204 struct cld_net *cn = nn->cld_net; 1205 1206 /* Don't upcall if it's already removed */ 1207 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1208 return; 1209 1210 cup = alloc_cld_upcall(nn); 1211 if (!cup) { 1212 ret = -ENOMEM; 1213 goto out_err; 1214 } 1215 1216 cup->cu_u.cu_msg.cm_cmd = Cld_Remove; 1217 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 1218 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 1219 clp->cl_name.len); 1220 1221 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1222 if (!ret) { 1223 ret = cup->cu_u.cu_msg.cm_status; 1224 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1225 } 1226 1227 free_cld_upcall(cup); 1228 out_err: 1229 if (ret) 1230 printk(KERN_ERR "NFSD: Unable to remove client " 1231 "record from stable storage: %d\n", ret); 1232 } 1233 1234 /* 1235 * For older nfsdcld's that do not allow us to "slurp" the clients 1236 * from the tracking database during startup. 1237 * 1238 * Check for presence of a record, and update its timestamp 1239 */ 1240 static int 1241 nfsd4_cld_check_v0(struct nfs4_client *clp) 1242 { 1243 int ret; 1244 struct cld_upcall *cup; 1245 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1246 struct cld_net *cn = nn->cld_net; 1247 1248 /* Don't upcall if one was already stored during this grace pd */ 1249 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1250 return 0; 1251 1252 cup = alloc_cld_upcall(nn); 1253 if (!cup) { 1254 printk(KERN_ERR "NFSD: Unable to check client record on " 1255 "stable storage: %d\n", -ENOMEM); 1256 return -ENOMEM; 1257 } 1258 1259 cup->cu_u.cu_msg.cm_cmd = Cld_Check; 1260 cup->cu_u.cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 1261 memcpy(cup->cu_u.cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 1262 clp->cl_name.len); 1263 1264 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1265 if (!ret) { 1266 ret = cup->cu_u.cu_msg.cm_status; 1267 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1268 } 1269 1270 free_cld_upcall(cup); 1271 return ret; 1272 } 1273 1274 /* 1275 * For newer nfsdcld's that allow us to "slurp" the clients 1276 * from the tracking database during startup. 1277 * 1278 * Check for presence of a record in the reclaim_str_hashtbl 1279 */ 1280 static int 1281 nfsd4_cld_check(struct nfs4_client *clp) 1282 { 1283 struct nfs4_client_reclaim *crp; 1284 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1285 struct cld_net *cn = nn->cld_net; 1286 int status; 1287 char dname[HEXDIR_LEN]; 1288 struct xdr_netobj name; 1289 1290 /* did we already find that this client is stable? */ 1291 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1292 return 0; 1293 1294 /* look for it in the reclaim hashtable otherwise */ 1295 crp = nfsd4_find_reclaim_client(clp->cl_name, nn); 1296 if (crp) 1297 goto found; 1298 1299 if (cn->cn_has_legacy) { 1300 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 1301 if (status) 1302 return -ENOENT; 1303 1304 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL); 1305 if (!name.data) { 1306 dprintk("%s: failed to allocate memory for name.data!\n", 1307 __func__); 1308 return -ENOENT; 1309 } 1310 name.len = HEXDIR_LEN; 1311 crp = nfsd4_find_reclaim_client(name, nn); 1312 kfree(name.data); 1313 if (crp) 1314 goto found; 1315 1316 } 1317 return -ENOENT; 1318 found: 1319 crp->cr_clp = clp; 1320 return 0; 1321 } 1322 1323 static int 1324 nfsd4_cld_check_v2(struct nfs4_client *clp) 1325 { 1326 struct nfs4_client_reclaim *crp; 1327 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1328 struct cld_net *cn = nn->cld_net; 1329 int status; 1330 char dname[HEXDIR_LEN]; 1331 struct xdr_netobj name; 1332 struct crypto_shash *tfm = cn->cn_tfm; 1333 struct xdr_netobj cksum; 1334 char *principal = NULL; 1335 1336 /* did we already find that this client is stable? */ 1337 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1338 return 0; 1339 1340 /* look for it in the reclaim hashtable otherwise */ 1341 crp = nfsd4_find_reclaim_client(clp->cl_name, nn); 1342 if (crp) 1343 goto found; 1344 1345 if (cn->cn_has_legacy) { 1346 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 1347 if (status) 1348 return -ENOENT; 1349 1350 name.data = kmemdup(dname, HEXDIR_LEN, GFP_KERNEL); 1351 if (!name.data) { 1352 dprintk("%s: failed to allocate memory for name.data\n", 1353 __func__); 1354 return -ENOENT; 1355 } 1356 name.len = HEXDIR_LEN; 1357 crp = nfsd4_find_reclaim_client(name, nn); 1358 kfree(name.data); 1359 if (crp) 1360 goto found; 1361 1362 } 1363 return -ENOENT; 1364 found: 1365 if (crp->cr_princhash.len) { 1366 if (clp->cl_cred.cr_raw_principal) 1367 principal = clp->cl_cred.cr_raw_principal; 1368 else if (clp->cl_cred.cr_principal) 1369 principal = clp->cl_cred.cr_principal; 1370 if (principal == NULL) 1371 return -ENOENT; 1372 cksum.len = crypto_shash_digestsize(tfm); 1373 cksum.data = kmalloc(cksum.len, GFP_KERNEL); 1374 if (cksum.data == NULL) 1375 return -ENOENT; 1376 status = crypto_shash_tfm_digest(tfm, principal, 1377 strlen(principal), cksum.data); 1378 if (status) { 1379 kfree(cksum.data); 1380 return -ENOENT; 1381 } 1382 if (memcmp(crp->cr_princhash.data, cksum.data, 1383 crp->cr_princhash.len)) { 1384 kfree(cksum.data); 1385 return -ENOENT; 1386 } 1387 kfree(cksum.data); 1388 } 1389 crp->cr_clp = clp; 1390 return 0; 1391 } 1392 1393 static int 1394 nfsd4_cld_grace_start(struct nfsd_net *nn) 1395 { 1396 int ret; 1397 struct cld_upcall *cup; 1398 struct cld_net *cn = nn->cld_net; 1399 1400 cup = alloc_cld_upcall(nn); 1401 if (!cup) { 1402 ret = -ENOMEM; 1403 goto out_err; 1404 } 1405 1406 cup->cu_u.cu_msg.cm_cmd = Cld_GraceStart; 1407 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1408 if (!ret) 1409 ret = cup->cu_u.cu_msg.cm_status; 1410 1411 free_cld_upcall(cup); 1412 out_err: 1413 if (ret) 1414 dprintk("%s: Unable to get clients from userspace: %d\n", 1415 __func__, ret); 1416 return ret; 1417 } 1418 1419 /* For older nfsdcld's that need cm_gracetime */ 1420 static void 1421 nfsd4_cld_grace_done_v0(struct nfsd_net *nn) 1422 { 1423 int ret; 1424 struct cld_upcall *cup; 1425 struct cld_net *cn = nn->cld_net; 1426 1427 cup = alloc_cld_upcall(nn); 1428 if (!cup) { 1429 ret = -ENOMEM; 1430 goto out_err; 1431 } 1432 1433 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone; 1434 cup->cu_u.cu_msg.cm_u.cm_gracetime = nn->boot_time; 1435 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1436 if (!ret) 1437 ret = cup->cu_u.cu_msg.cm_status; 1438 1439 free_cld_upcall(cup); 1440 out_err: 1441 if (ret) 1442 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret); 1443 } 1444 1445 /* 1446 * For newer nfsdcld's that do not need cm_gracetime. We also need to call 1447 * nfs4_release_reclaim() to clear out the reclaim_str_hashtbl. 1448 */ 1449 static void 1450 nfsd4_cld_grace_done(struct nfsd_net *nn) 1451 { 1452 int ret; 1453 struct cld_upcall *cup; 1454 struct cld_net *cn = nn->cld_net; 1455 1456 cup = alloc_cld_upcall(nn); 1457 if (!cup) { 1458 ret = -ENOMEM; 1459 goto out_err; 1460 } 1461 1462 cup->cu_u.cu_msg.cm_cmd = Cld_GraceDone; 1463 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1464 if (!ret) 1465 ret = cup->cu_u.cu_msg.cm_status; 1466 1467 free_cld_upcall(cup); 1468 out_err: 1469 nfs4_release_reclaim(nn); 1470 if (ret) 1471 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret); 1472 } 1473 1474 static int 1475 nfs4_cld_state_init(struct net *net) 1476 { 1477 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1478 int i; 1479 1480 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, 1481 sizeof(struct list_head), 1482 GFP_KERNEL); 1483 if (!nn->reclaim_str_hashtbl) 1484 return -ENOMEM; 1485 1486 for (i = 0; i < CLIENT_HASH_SIZE; i++) 1487 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]); 1488 nn->reclaim_str_hashtbl_size = 0; 1489 nn->track_reclaim_completes = true; 1490 atomic_set(&nn->nr_reclaim_complete, 0); 1491 1492 return 0; 1493 } 1494 1495 static void 1496 nfs4_cld_state_shutdown(struct net *net) 1497 { 1498 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1499 1500 nn->track_reclaim_completes = false; 1501 kfree(nn->reclaim_str_hashtbl); 1502 } 1503 1504 static bool 1505 cld_running(struct nfsd_net *nn) 1506 { 1507 struct cld_net *cn = nn->cld_net; 1508 struct rpc_pipe *pipe = cn->cn_pipe; 1509 1510 return pipe->nreaders || pipe->nwriters; 1511 } 1512 1513 static int 1514 nfsd4_cld_get_version(struct nfsd_net *nn) 1515 { 1516 int ret = 0; 1517 struct cld_upcall *cup; 1518 struct cld_net *cn = nn->cld_net; 1519 uint8_t version; 1520 1521 cup = alloc_cld_upcall(nn); 1522 if (!cup) { 1523 ret = -ENOMEM; 1524 goto out_err; 1525 } 1526 cup->cu_u.cu_msg.cm_cmd = Cld_GetVersion; 1527 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_u.cu_msg); 1528 if (!ret) { 1529 ret = cup->cu_u.cu_msg.cm_status; 1530 if (ret) 1531 goto out_free; 1532 version = cup->cu_u.cu_msg.cm_u.cm_version; 1533 dprintk("%s: userspace returned version %u\n", 1534 __func__, version); 1535 if (version < 1) 1536 version = 1; 1537 else if (version > CLD_UPCALL_VERSION) 1538 version = CLD_UPCALL_VERSION; 1539 1540 switch (version) { 1541 case 1: 1542 nn->client_tracking_ops = &nfsd4_cld_tracking_ops; 1543 break; 1544 case 2: 1545 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v2; 1546 break; 1547 default: 1548 break; 1549 } 1550 } 1551 out_free: 1552 free_cld_upcall(cup); 1553 out_err: 1554 if (ret) 1555 dprintk("%s: Unable to get version from userspace: %d\n", 1556 __func__, ret); 1557 return ret; 1558 } 1559 1560 static int 1561 nfsd4_cld_tracking_init(struct net *net) 1562 { 1563 int status; 1564 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1565 bool running; 1566 int retries = 10; 1567 struct crypto_shash *tfm; 1568 1569 status = nfs4_cld_state_init(net); 1570 if (status) 1571 return status; 1572 1573 status = __nfsd4_init_cld_pipe(net); 1574 if (status) 1575 goto err_shutdown; 1576 1577 /* 1578 * rpc pipe upcalls take 30 seconds to time out, so we don't want to 1579 * queue an upcall unless we know that nfsdcld is running (because we 1580 * want this to fail fast so that nfsd4_client_tracking_init() can try 1581 * the next client tracking method). nfsdcld should already be running 1582 * before nfsd is started, so the wait here is for nfsdcld to open the 1583 * pipefs file we just created. 1584 */ 1585 while (!(running = cld_running(nn)) && retries--) 1586 msleep(100); 1587 1588 if (!running) { 1589 status = -ETIMEDOUT; 1590 goto err_remove; 1591 } 1592 tfm = crypto_alloc_shash("sha256", 0, 0); 1593 if (IS_ERR(tfm)) { 1594 status = PTR_ERR(tfm); 1595 goto err_remove; 1596 } 1597 nn->cld_net->cn_tfm = tfm; 1598 1599 status = nfsd4_cld_get_version(nn); 1600 if (status == -EOPNOTSUPP) 1601 pr_warn("NFSD: nfsdcld GetVersion upcall failed. Please upgrade nfsdcld.\n"); 1602 1603 status = nfsd4_cld_grace_start(nn); 1604 if (status) { 1605 if (status == -EOPNOTSUPP) 1606 pr_warn("NFSD: nfsdcld GraceStart upcall failed. Please upgrade nfsdcld.\n"); 1607 nfs4_release_reclaim(nn); 1608 goto err_remove; 1609 } else 1610 printk("NFSD: Using nfsdcld client tracking operations.\n"); 1611 return 0; 1612 1613 err_remove: 1614 nfsd4_remove_cld_pipe(net); 1615 err_shutdown: 1616 nfs4_cld_state_shutdown(net); 1617 return status; 1618 } 1619 1620 static void 1621 nfsd4_cld_tracking_exit(struct net *net) 1622 { 1623 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1624 1625 nfs4_release_reclaim(nn); 1626 nfsd4_remove_cld_pipe(net); 1627 nfs4_cld_state_shutdown(net); 1628 } 1629 1630 /* For older nfsdcld's */ 1631 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v0 = { 1632 .init = nfsd4_init_cld_pipe, 1633 .exit = nfsd4_remove_cld_pipe, 1634 .create = nfsd4_cld_create, 1635 .remove = nfsd4_cld_remove, 1636 .check = nfsd4_cld_check_v0, 1637 .grace_done = nfsd4_cld_grace_done_v0, 1638 .version = 1, 1639 .msglen = sizeof(struct cld_msg), 1640 }; 1641 1642 /* For newer nfsdcld's */ 1643 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = { 1644 .init = nfsd4_cld_tracking_init, 1645 .exit = nfsd4_cld_tracking_exit, 1646 .create = nfsd4_cld_create, 1647 .remove = nfsd4_cld_remove, 1648 .check = nfsd4_cld_check, 1649 .grace_done = nfsd4_cld_grace_done, 1650 .version = 1, 1651 .msglen = sizeof(struct cld_msg), 1652 }; 1653 1654 /* v2 create/check ops include the principal, if available */ 1655 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops_v2 = { 1656 .init = nfsd4_cld_tracking_init, 1657 .exit = nfsd4_cld_tracking_exit, 1658 .create = nfsd4_cld_create_v2, 1659 .remove = nfsd4_cld_remove, 1660 .check = nfsd4_cld_check_v2, 1661 .grace_done = nfsd4_cld_grace_done, 1662 .version = 2, 1663 .msglen = sizeof(struct cld_msg_v2), 1664 }; 1665 1666 /* upcall via usermodehelper */ 1667 static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack"; 1668 module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog), 1669 S_IRUGO|S_IWUSR); 1670 MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program"); 1671 1672 static bool cltrack_legacy_disable; 1673 module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR); 1674 MODULE_PARM_DESC(cltrack_legacy_disable, 1675 "Disable legacy recoverydir conversion. Default: false"); 1676 1677 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR=" 1678 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR=" 1679 #define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION=" 1680 #define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START=" 1681 1682 static char * 1683 nfsd4_cltrack_legacy_topdir(void) 1684 { 1685 int copied; 1686 size_t len; 1687 char *result; 1688 1689 if (cltrack_legacy_disable) 1690 return NULL; 1691 1692 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) + 1693 strlen(nfs4_recoverydir()) + 1; 1694 1695 result = kmalloc(len, GFP_KERNEL); 1696 if (!result) 1697 return result; 1698 1699 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s", 1700 nfs4_recoverydir()); 1701 if (copied >= len) { 1702 /* just return nothing if output was truncated */ 1703 kfree(result); 1704 return NULL; 1705 } 1706 1707 return result; 1708 } 1709 1710 static char * 1711 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name) 1712 { 1713 int copied; 1714 size_t len; 1715 char *result; 1716 1717 if (cltrack_legacy_disable) 1718 return NULL; 1719 1720 /* +1 is for '/' between "topdir" and "recdir" */ 1721 len = strlen(LEGACY_RECDIR_ENV_PREFIX) + 1722 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN; 1723 1724 result = kmalloc(len, GFP_KERNEL); 1725 if (!result) 1726 return result; 1727 1728 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/", 1729 nfs4_recoverydir()); 1730 if (copied > (len - HEXDIR_LEN)) { 1731 /* just return nothing if output will be truncated */ 1732 kfree(result); 1733 return NULL; 1734 } 1735 1736 copied = nfs4_make_rec_clidname(result + copied, name); 1737 if (copied) { 1738 kfree(result); 1739 return NULL; 1740 } 1741 1742 return result; 1743 } 1744 1745 static char * 1746 nfsd4_cltrack_client_has_session(struct nfs4_client *clp) 1747 { 1748 int copied; 1749 size_t len; 1750 char *result; 1751 1752 /* prefix + Y/N character + terminating NULL */ 1753 len = strlen(HAS_SESSION_ENV_PREFIX) + 1 + 1; 1754 1755 result = kmalloc(len, GFP_KERNEL); 1756 if (!result) 1757 return result; 1758 1759 copied = snprintf(result, len, HAS_SESSION_ENV_PREFIX "%c", 1760 clp->cl_minorversion ? 'Y' : 'N'); 1761 if (copied >= len) { 1762 /* just return nothing if output was truncated */ 1763 kfree(result); 1764 return NULL; 1765 } 1766 1767 return result; 1768 } 1769 1770 static char * 1771 nfsd4_cltrack_grace_start(time64_t grace_start) 1772 { 1773 int copied; 1774 size_t len; 1775 char *result; 1776 1777 /* prefix + max width of int64_t string + terminating NULL */ 1778 len = strlen(GRACE_START_ENV_PREFIX) + 22 + 1; 1779 1780 result = kmalloc(len, GFP_KERNEL); 1781 if (!result) 1782 return result; 1783 1784 copied = snprintf(result, len, GRACE_START_ENV_PREFIX "%lld", 1785 grace_start); 1786 if (copied >= len) { 1787 /* just return nothing if output was truncated */ 1788 kfree(result); 1789 return NULL; 1790 } 1791 1792 return result; 1793 } 1794 1795 static int 1796 nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1) 1797 { 1798 char *envp[3]; 1799 char *argv[4]; 1800 int ret; 1801 1802 if (unlikely(!cltrack_prog[0])) { 1803 dprintk("%s: cltrack_prog is disabled\n", __func__); 1804 return -EACCES; 1805 } 1806 1807 dprintk("%s: cmd: %s\n", __func__, cmd); 1808 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)"); 1809 dprintk("%s: env0: %s\n", __func__, env0 ? env0 : "(null)"); 1810 dprintk("%s: env1: %s\n", __func__, env1 ? env1 : "(null)"); 1811 1812 envp[0] = env0; 1813 envp[1] = env1; 1814 envp[2] = NULL; 1815 1816 argv[0] = (char *)cltrack_prog; 1817 argv[1] = cmd; 1818 argv[2] = arg; 1819 argv[3] = NULL; 1820 1821 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 1822 /* 1823 * Disable the upcall mechanism if we're getting an ENOENT or EACCES 1824 * error. The admin can re-enable it on the fly by using sysfs 1825 * once the problem has been fixed. 1826 */ 1827 if (ret == -ENOENT || ret == -EACCES) { 1828 dprintk("NFSD: %s was not found or isn't executable (%d). " 1829 "Setting cltrack_prog to blank string!", 1830 cltrack_prog, ret); 1831 cltrack_prog[0] = '\0'; 1832 } 1833 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret); 1834 1835 return ret; 1836 } 1837 1838 static char * 1839 bin_to_hex_dup(const unsigned char *src, int srclen) 1840 { 1841 char *buf; 1842 1843 /* +1 for terminating NULL */ 1844 buf = kzalloc((srclen * 2) + 1, GFP_KERNEL); 1845 if (!buf) 1846 return buf; 1847 1848 bin2hex(buf, src, srclen); 1849 return buf; 1850 } 1851 1852 static int 1853 nfsd4_umh_cltrack_init(struct net *net) 1854 { 1855 int ret; 1856 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1857 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time); 1858 1859 /* XXX: The usermode helper s not working in container yet. */ 1860 if (net != &init_net) { 1861 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n"); 1862 kfree(grace_start); 1863 return -EINVAL; 1864 } 1865 1866 ret = nfsd4_umh_cltrack_upcall("init", NULL, grace_start, NULL); 1867 kfree(grace_start); 1868 if (!ret) 1869 printk("NFSD: Using UMH upcall client tracking operations.\n"); 1870 return ret; 1871 } 1872 1873 static void 1874 nfsd4_cltrack_upcall_lock(struct nfs4_client *clp) 1875 { 1876 wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK, 1877 TASK_UNINTERRUPTIBLE); 1878 } 1879 1880 static void 1881 nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp) 1882 { 1883 smp_mb__before_atomic(); 1884 clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags); 1885 smp_mb__after_atomic(); 1886 wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK); 1887 } 1888 1889 static void 1890 nfsd4_umh_cltrack_create(struct nfs4_client *clp) 1891 { 1892 char *hexid, *has_session, *grace_start; 1893 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1894 1895 /* 1896 * With v4.0 clients, there's little difference in outcome between a 1897 * create and check operation, and we can end up calling into this 1898 * function multiple times per client (once for each openowner). So, 1899 * for v4.0 clients skip upcalling once the client has been recorded 1900 * on stable storage. 1901 * 1902 * For v4.1+ clients, the outcome of the two operations is different, 1903 * so we must ensure that we upcall for the create operation. v4.1+ 1904 * clients call this on RECLAIM_COMPLETE though, so we should only end 1905 * up doing a single create upcall per client. 1906 */ 1907 if (clp->cl_minorversion == 0 && 1908 test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1909 return; 1910 1911 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1912 if (!hexid) { 1913 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1914 return; 1915 } 1916 1917 has_session = nfsd4_cltrack_client_has_session(clp); 1918 grace_start = nfsd4_cltrack_grace_start(nn->boot_time); 1919 1920 nfsd4_cltrack_upcall_lock(clp); 1921 if (!nfsd4_umh_cltrack_upcall("create", hexid, has_session, grace_start)) 1922 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1923 nfsd4_cltrack_upcall_unlock(clp); 1924 1925 kfree(has_session); 1926 kfree(grace_start); 1927 kfree(hexid); 1928 } 1929 1930 static void 1931 nfsd4_umh_cltrack_remove(struct nfs4_client *clp) 1932 { 1933 char *hexid; 1934 1935 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1936 return; 1937 1938 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1939 if (!hexid) { 1940 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1941 return; 1942 } 1943 1944 nfsd4_cltrack_upcall_lock(clp); 1945 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) && 1946 nfsd4_umh_cltrack_upcall("remove", hexid, NULL, NULL) == 0) 1947 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1948 nfsd4_cltrack_upcall_unlock(clp); 1949 1950 kfree(hexid); 1951 } 1952 1953 static int 1954 nfsd4_umh_cltrack_check(struct nfs4_client *clp) 1955 { 1956 int ret; 1957 char *hexid, *has_session, *legacy; 1958 1959 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1960 return 0; 1961 1962 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1963 if (!hexid) { 1964 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1965 return -ENOMEM; 1966 } 1967 1968 has_session = nfsd4_cltrack_client_has_session(clp); 1969 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name); 1970 1971 nfsd4_cltrack_upcall_lock(clp); 1972 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) { 1973 ret = 0; 1974 } else { 1975 ret = nfsd4_umh_cltrack_upcall("check", hexid, has_session, legacy); 1976 if (ret == 0) 1977 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1978 } 1979 nfsd4_cltrack_upcall_unlock(clp); 1980 kfree(has_session); 1981 kfree(legacy); 1982 kfree(hexid); 1983 1984 return ret; 1985 } 1986 1987 static void 1988 nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn) 1989 { 1990 char *legacy; 1991 char timestr[22]; /* FIXME: better way to determine max size? */ 1992 1993 sprintf(timestr, "%lld", nn->boot_time); 1994 legacy = nfsd4_cltrack_legacy_topdir(); 1995 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy, NULL); 1996 kfree(legacy); 1997 } 1998 1999 static const struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = { 2000 .init = nfsd4_umh_cltrack_init, 2001 .exit = NULL, 2002 .create = nfsd4_umh_cltrack_create, 2003 .remove = nfsd4_umh_cltrack_remove, 2004 .check = nfsd4_umh_cltrack_check, 2005 .grace_done = nfsd4_umh_cltrack_grace_done, 2006 .version = 1, 2007 .msglen = 0, 2008 }; 2009 2010 int 2011 nfsd4_client_tracking_init(struct net *net) 2012 { 2013 int status; 2014 struct path path; 2015 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2016 2017 /* just run the init if it the method is already decided */ 2018 if (nn->client_tracking_ops) 2019 goto do_init; 2020 2021 /* First, try to use nfsdcld */ 2022 nn->client_tracking_ops = &nfsd4_cld_tracking_ops; 2023 status = nn->client_tracking_ops->init(net); 2024 if (!status) 2025 return status; 2026 if (status != -ETIMEDOUT) { 2027 nn->client_tracking_ops = &nfsd4_cld_tracking_ops_v0; 2028 status = nn->client_tracking_ops->init(net); 2029 if (!status) 2030 return status; 2031 } 2032 2033 /* 2034 * Next, try the UMH upcall. 2035 */ 2036 nn->client_tracking_ops = &nfsd4_umh_tracking_ops; 2037 status = nn->client_tracking_ops->init(net); 2038 if (!status) 2039 return status; 2040 2041 /* 2042 * Finally, See if the recoverydir exists and is a directory. 2043 * If it is, then use the legacy ops. 2044 */ 2045 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops; 2046 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path); 2047 if (!status) { 2048 status = d_is_dir(path.dentry); 2049 path_put(&path); 2050 if (!status) { 2051 status = -EINVAL; 2052 goto out; 2053 } 2054 } 2055 2056 do_init: 2057 status = nn->client_tracking_ops->init(net); 2058 out: 2059 if (status) { 2060 printk(KERN_WARNING "NFSD: Unable to initialize client " 2061 "recovery tracking! (%d)\n", status); 2062 nn->client_tracking_ops = NULL; 2063 } 2064 return status; 2065 } 2066 2067 void 2068 nfsd4_client_tracking_exit(struct net *net) 2069 { 2070 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2071 2072 if (nn->client_tracking_ops) { 2073 if (nn->client_tracking_ops->exit) 2074 nn->client_tracking_ops->exit(net); 2075 nn->client_tracking_ops = NULL; 2076 } 2077 } 2078 2079 void 2080 nfsd4_client_record_create(struct nfs4_client *clp) 2081 { 2082 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 2083 2084 if (nn->client_tracking_ops) 2085 nn->client_tracking_ops->create(clp); 2086 } 2087 2088 void 2089 nfsd4_client_record_remove(struct nfs4_client *clp) 2090 { 2091 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 2092 2093 if (nn->client_tracking_ops) 2094 nn->client_tracking_ops->remove(clp); 2095 } 2096 2097 int 2098 nfsd4_client_record_check(struct nfs4_client *clp) 2099 { 2100 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 2101 2102 if (nn->client_tracking_ops) 2103 return nn->client_tracking_ops->check(clp); 2104 2105 return -EOPNOTSUPP; 2106 } 2107 2108 void 2109 nfsd4_record_grace_done(struct nfsd_net *nn) 2110 { 2111 if (nn->client_tracking_ops) 2112 nn->client_tracking_ops->grace_done(nn); 2113 } 2114 2115 static int 2116 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr) 2117 { 2118 struct super_block *sb = ptr; 2119 struct net *net = sb->s_fs_info; 2120 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 2121 struct cld_net *cn = nn->cld_net; 2122 struct dentry *dentry; 2123 int ret = 0; 2124 2125 if (!try_module_get(THIS_MODULE)) 2126 return 0; 2127 2128 if (!cn) { 2129 module_put(THIS_MODULE); 2130 return 0; 2131 } 2132 2133 switch (event) { 2134 case RPC_PIPEFS_MOUNT: 2135 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe); 2136 if (IS_ERR(dentry)) { 2137 ret = PTR_ERR(dentry); 2138 break; 2139 } 2140 cn->cn_pipe->dentry = dentry; 2141 break; 2142 case RPC_PIPEFS_UMOUNT: 2143 if (cn->cn_pipe->dentry) 2144 nfsd4_cld_unregister_sb(cn->cn_pipe); 2145 break; 2146 default: 2147 ret = -ENOTSUPP; 2148 break; 2149 } 2150 module_put(THIS_MODULE); 2151 return ret; 2152 } 2153 2154 static struct notifier_block nfsd4_cld_block = { 2155 .notifier_call = rpc_pipefs_event, 2156 }; 2157 2158 int 2159 register_cld_notifier(void) 2160 { 2161 return rpc_pipefs_notifier_register(&nfsd4_cld_block); 2162 } 2163 2164 void 2165 unregister_cld_notifier(void) 2166 { 2167 rpc_pipefs_notifier_unregister(&nfsd4_cld_block); 2168 } 2169