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