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 }; 63 64 /* Globals */ 65 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery"; 66 67 static int 68 nfs4_save_creds(const struct cred **original_creds) 69 { 70 struct cred *new; 71 72 new = prepare_creds(); 73 if (!new) 74 return -ENOMEM; 75 76 new->fsuid = GLOBAL_ROOT_UID; 77 new->fsgid = GLOBAL_ROOT_GID; 78 *original_creds = override_creds(new); 79 put_cred(new); 80 return 0; 81 } 82 83 static void 84 nfs4_reset_creds(const struct cred *original) 85 { 86 revert_creds(original); 87 } 88 89 static void 90 md5_to_hex(char *out, char *md5) 91 { 92 int i; 93 94 for (i=0; i<16; i++) { 95 unsigned char c = md5[i]; 96 97 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1); 98 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1); 99 } 100 *out = '\0'; 101 } 102 103 static int 104 nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname) 105 { 106 struct xdr_netobj cksum; 107 struct crypto_shash *tfm; 108 int status; 109 110 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n", 111 clname->len, clname->data); 112 tfm = crypto_alloc_shash("md5", 0, 0); 113 if (IS_ERR(tfm)) { 114 status = PTR_ERR(tfm); 115 goto out_no_tfm; 116 } 117 118 cksum.len = crypto_shash_digestsize(tfm); 119 cksum.data = kmalloc(cksum.len, GFP_KERNEL); 120 if (cksum.data == NULL) { 121 status = -ENOMEM; 122 goto out; 123 } 124 125 { 126 SHASH_DESC_ON_STACK(desc, tfm); 127 128 desc->tfm = tfm; 129 desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP; 130 131 status = crypto_shash_digest(desc, clname->data, clname->len, 132 cksum.data); 133 shash_desc_zero(desc); 134 } 135 136 if (status) 137 goto out; 138 139 md5_to_hex(dname, cksum.data); 140 141 status = 0; 142 out: 143 kfree(cksum.data); 144 crypto_free_shash(tfm); 145 out_no_tfm: 146 return status; 147 } 148 149 /* 150 * If we had an error generating the recdir name for the legacy tracker 151 * then warn the admin. If the error doesn't appear to be transient, 152 * then disable recovery tracking. 153 */ 154 static void 155 legacy_recdir_name_error(struct nfs4_client *clp, int error) 156 { 157 printk(KERN_ERR "NFSD: unable to generate recoverydir " 158 "name (%d).\n", error); 159 160 /* 161 * if the algorithm just doesn't exist, then disable the recovery 162 * tracker altogether. The crypto libs will generally return this if 163 * FIPS is enabled as well. 164 */ 165 if (error == -ENOENT) { 166 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. " 167 "Reboot recovery will not function correctly!\n"); 168 nfsd4_client_tracking_exit(clp->net); 169 } 170 } 171 172 static void 173 nfsd4_create_clid_dir(struct nfs4_client *clp) 174 { 175 const struct cred *original_cred; 176 char dname[HEXDIR_LEN]; 177 struct dentry *dir, *dentry; 178 struct nfs4_client_reclaim *crp; 179 int status; 180 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 181 182 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 183 return; 184 if (!nn->rec_file) 185 return; 186 187 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 188 if (status) 189 return legacy_recdir_name_error(clp, status); 190 191 status = nfs4_save_creds(&original_cred); 192 if (status < 0) 193 return; 194 195 status = mnt_want_write_file(nn->rec_file); 196 if (status) 197 goto out_creds; 198 199 dir = nn->rec_file->f_path.dentry; 200 /* lock the parent */ 201 inode_lock(d_inode(dir)); 202 203 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1); 204 if (IS_ERR(dentry)) { 205 status = PTR_ERR(dentry); 206 goto out_unlock; 207 } 208 if (d_really_is_positive(dentry)) 209 /* 210 * In the 4.1 case, where we're called from 211 * reclaim_complete(), records from the previous reboot 212 * may still be left, so this is OK. 213 * 214 * In the 4.0 case, we should never get here; but we may 215 * as well be forgiving and just succeed silently. 216 */ 217 goto out_put; 218 status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU); 219 out_put: 220 dput(dentry); 221 out_unlock: 222 inode_unlock(d_inode(dir)); 223 if (status == 0) { 224 if (nn->in_grace) { 225 crp = nfs4_client_to_reclaim(dname, nn); 226 if (crp) 227 crp->cr_clp = clp; 228 } 229 vfs_fsync(nn->rec_file, 0); 230 } else { 231 printk(KERN_ERR "NFSD: failed to write recovery record" 232 " (err %d); please check that %s exists" 233 " and is writeable", status, 234 user_recovery_dirname); 235 } 236 mnt_drop_write_file(nn->rec_file); 237 out_creds: 238 nfs4_reset_creds(original_cred); 239 } 240 241 typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *); 242 243 struct name_list { 244 char name[HEXDIR_LEN]; 245 struct list_head list; 246 }; 247 248 struct nfs4_dir_ctx { 249 struct dir_context ctx; 250 struct list_head names; 251 }; 252 253 static int 254 nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen, 255 loff_t offset, u64 ino, unsigned int d_type) 256 { 257 struct nfs4_dir_ctx *ctx = 258 container_of(__ctx, struct nfs4_dir_ctx, ctx); 259 struct name_list *entry; 260 261 if (namlen != HEXDIR_LEN - 1) 262 return 0; 263 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL); 264 if (entry == NULL) 265 return -ENOMEM; 266 memcpy(entry->name, name, HEXDIR_LEN - 1); 267 entry->name[HEXDIR_LEN - 1] = '\0'; 268 list_add(&entry->list, &ctx->names); 269 return 0; 270 } 271 272 static int 273 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn) 274 { 275 const struct cred *original_cred; 276 struct dentry *dir = nn->rec_file->f_path.dentry; 277 struct nfs4_dir_ctx ctx = { 278 .ctx.actor = nfsd4_build_namelist, 279 .names = LIST_HEAD_INIT(ctx.names) 280 }; 281 struct name_list *entry, *tmp; 282 int status; 283 284 status = nfs4_save_creds(&original_cred); 285 if (status < 0) 286 return status; 287 288 status = vfs_llseek(nn->rec_file, 0, SEEK_SET); 289 if (status < 0) { 290 nfs4_reset_creds(original_cred); 291 return status; 292 } 293 294 status = iterate_dir(nn->rec_file, &ctx.ctx); 295 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 296 297 list_for_each_entry_safe(entry, tmp, &ctx.names, list) { 298 if (!status) { 299 struct dentry *dentry; 300 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1); 301 if (IS_ERR(dentry)) { 302 status = PTR_ERR(dentry); 303 break; 304 } 305 status = f(dir, dentry, nn); 306 dput(dentry); 307 } 308 list_del(&entry->list); 309 kfree(entry); 310 } 311 inode_unlock(d_inode(dir)); 312 nfs4_reset_creds(original_cred); 313 314 list_for_each_entry_safe(entry, tmp, &ctx.names, list) { 315 dprintk("NFSD: %s. Left entry %s\n", __func__, entry->name); 316 list_del(&entry->list); 317 kfree(entry); 318 } 319 return status; 320 } 321 322 static int 323 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn) 324 { 325 struct dentry *dir, *dentry; 326 int status; 327 328 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name); 329 330 dir = nn->rec_file->f_path.dentry; 331 inode_lock_nested(d_inode(dir), I_MUTEX_PARENT); 332 dentry = lookup_one_len(name, dir, namlen); 333 if (IS_ERR(dentry)) { 334 status = PTR_ERR(dentry); 335 goto out_unlock; 336 } 337 status = -ENOENT; 338 if (d_really_is_negative(dentry)) 339 goto out; 340 status = vfs_rmdir(d_inode(dir), dentry); 341 out: 342 dput(dentry); 343 out_unlock: 344 inode_unlock(d_inode(dir)); 345 return status; 346 } 347 348 static void 349 nfsd4_remove_clid_dir(struct nfs4_client *clp) 350 { 351 const struct cred *original_cred; 352 struct nfs4_client_reclaim *crp; 353 char dname[HEXDIR_LEN]; 354 int status; 355 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 356 357 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 358 return; 359 360 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 361 if (status) 362 return legacy_recdir_name_error(clp, status); 363 364 status = mnt_want_write_file(nn->rec_file); 365 if (status) 366 goto out; 367 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 368 369 status = nfs4_save_creds(&original_cred); 370 if (status < 0) 371 goto out_drop_write; 372 373 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn); 374 nfs4_reset_creds(original_cred); 375 if (status == 0) { 376 vfs_fsync(nn->rec_file, 0); 377 if (nn->in_grace) { 378 /* remove reclaim record */ 379 crp = nfsd4_find_reclaim_client(dname, nn); 380 if (crp) 381 nfs4_remove_reclaim_record(crp, nn); 382 } 383 } 384 out_drop_write: 385 mnt_drop_write_file(nn->rec_file); 386 out: 387 if (status) 388 printk("NFSD: Failed to remove expired client state directory" 389 " %.*s\n", HEXDIR_LEN, dname); 390 } 391 392 static int 393 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) 394 { 395 int status; 396 397 if (nfs4_has_reclaimed_state(child->d_name.name, nn)) 398 return 0; 399 400 status = vfs_rmdir(d_inode(parent), child); 401 if (status) 402 printk("failed to remove client recovery directory %pd\n", 403 child); 404 /* Keep trying, success or failure: */ 405 return 0; 406 } 407 408 static void 409 nfsd4_recdir_purge_old(struct nfsd_net *nn) 410 { 411 int status; 412 413 nn->in_grace = false; 414 if (!nn->rec_file) 415 return; 416 status = mnt_want_write_file(nn->rec_file); 417 if (status) 418 goto out; 419 status = nfsd4_list_rec_dir(purge_old, nn); 420 if (status == 0) 421 vfs_fsync(nn->rec_file, 0); 422 mnt_drop_write_file(nn->rec_file); 423 out: 424 nfs4_release_reclaim(nn); 425 if (status) 426 printk("nfsd4: failed to purge old clients from recovery" 427 " directory %pD\n", nn->rec_file); 428 } 429 430 static int 431 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn) 432 { 433 if (child->d_name.len != HEXDIR_LEN - 1) { 434 printk("nfsd4: illegal name %pd in recovery directory\n", 435 child); 436 /* Keep trying; maybe the others are OK: */ 437 return 0; 438 } 439 nfs4_client_to_reclaim(child->d_name.name, nn); 440 return 0; 441 } 442 443 static int 444 nfsd4_recdir_load(struct net *net) { 445 int status; 446 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 447 448 if (!nn->rec_file) 449 return 0; 450 451 status = nfsd4_list_rec_dir(load_recdir, nn); 452 if (status) 453 printk("nfsd4: failed loading clients from recovery" 454 " directory %pD\n", nn->rec_file); 455 return status; 456 } 457 458 /* 459 * Hold reference to the recovery directory. 460 */ 461 462 static int 463 nfsd4_init_recdir(struct net *net) 464 { 465 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 466 const struct cred *original_cred; 467 int status; 468 469 printk("NFSD: Using %s as the NFSv4 state recovery directory\n", 470 user_recovery_dirname); 471 472 BUG_ON(nn->rec_file); 473 474 status = nfs4_save_creds(&original_cred); 475 if (status < 0) { 476 printk("NFSD: Unable to change credentials to find recovery" 477 " directory: error %d\n", 478 status); 479 return status; 480 } 481 482 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0); 483 if (IS_ERR(nn->rec_file)) { 484 printk("NFSD: unable to find recovery directory %s\n", 485 user_recovery_dirname); 486 status = PTR_ERR(nn->rec_file); 487 nn->rec_file = NULL; 488 } 489 490 nfs4_reset_creds(original_cred); 491 if (!status) 492 nn->in_grace = true; 493 return status; 494 } 495 496 static void 497 nfsd4_shutdown_recdir(struct net *net) 498 { 499 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 500 501 if (!nn->rec_file) 502 return; 503 fput(nn->rec_file); 504 nn->rec_file = NULL; 505 } 506 507 static int 508 nfs4_legacy_state_init(struct net *net) 509 { 510 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 511 int i; 512 513 nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE, 514 sizeof(struct list_head), 515 GFP_KERNEL); 516 if (!nn->reclaim_str_hashtbl) 517 return -ENOMEM; 518 519 for (i = 0; i < CLIENT_HASH_SIZE; i++) 520 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]); 521 nn->reclaim_str_hashtbl_size = 0; 522 523 return 0; 524 } 525 526 static void 527 nfs4_legacy_state_shutdown(struct net *net) 528 { 529 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 530 531 kfree(nn->reclaim_str_hashtbl); 532 } 533 534 static int 535 nfsd4_load_reboot_recovery_data(struct net *net) 536 { 537 int status; 538 539 status = nfsd4_init_recdir(net); 540 if (status) 541 return status; 542 543 status = nfsd4_recdir_load(net); 544 if (status) 545 nfsd4_shutdown_recdir(net); 546 547 return status; 548 } 549 550 static int 551 nfsd4_legacy_tracking_init(struct net *net) 552 { 553 int status; 554 555 /* XXX: The legacy code won't work in a container */ 556 if (net != &init_net) { 557 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n"); 558 return -EINVAL; 559 } 560 561 status = nfs4_legacy_state_init(net); 562 if (status) 563 return status; 564 565 status = nfsd4_load_reboot_recovery_data(net); 566 if (status) 567 goto err; 568 return 0; 569 570 err: 571 nfs4_legacy_state_shutdown(net); 572 return status; 573 } 574 575 static void 576 nfsd4_legacy_tracking_exit(struct net *net) 577 { 578 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 579 580 nfs4_release_reclaim(nn); 581 nfsd4_shutdown_recdir(net); 582 nfs4_legacy_state_shutdown(net); 583 } 584 585 /* 586 * Change the NFSv4 recovery directory to recdir. 587 */ 588 int 589 nfs4_reset_recoverydir(char *recdir) 590 { 591 int status; 592 struct path path; 593 594 status = kern_path(recdir, LOOKUP_FOLLOW, &path); 595 if (status) 596 return status; 597 status = -ENOTDIR; 598 if (d_is_dir(path.dentry)) { 599 strcpy(user_recovery_dirname, recdir); 600 status = 0; 601 } 602 path_put(&path); 603 return status; 604 } 605 606 char * 607 nfs4_recoverydir(void) 608 { 609 return user_recovery_dirname; 610 } 611 612 static int 613 nfsd4_check_legacy_client(struct nfs4_client *clp) 614 { 615 int status; 616 char dname[HEXDIR_LEN]; 617 struct nfs4_client_reclaim *crp; 618 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 619 620 /* did we already find that this client is stable? */ 621 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 622 return 0; 623 624 status = nfs4_make_rec_clidname(dname, &clp->cl_name); 625 if (status) { 626 legacy_recdir_name_error(clp, status); 627 return status; 628 } 629 630 /* look for it in the reclaim hashtable otherwise */ 631 crp = nfsd4_find_reclaim_client(dname, nn); 632 if (crp) { 633 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 634 crp->cr_clp = clp; 635 return 0; 636 } 637 638 return -ENOENT; 639 } 640 641 static const struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = { 642 .init = nfsd4_legacy_tracking_init, 643 .exit = nfsd4_legacy_tracking_exit, 644 .create = nfsd4_create_clid_dir, 645 .remove = nfsd4_remove_clid_dir, 646 .check = nfsd4_check_legacy_client, 647 .grace_done = nfsd4_recdir_purge_old, 648 }; 649 650 /* Globals */ 651 #define NFSD_PIPE_DIR "nfsd" 652 #define NFSD_CLD_PIPE "cld" 653 654 /* per-net-ns structure for holding cld upcall info */ 655 struct cld_net { 656 struct rpc_pipe *cn_pipe; 657 spinlock_t cn_lock; 658 struct list_head cn_list; 659 unsigned int cn_xid; 660 }; 661 662 struct cld_upcall { 663 struct list_head cu_list; 664 struct cld_net *cu_net; 665 struct completion cu_done; 666 struct cld_msg cu_msg; 667 }; 668 669 static int 670 __cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg) 671 { 672 int ret; 673 struct rpc_pipe_msg msg; 674 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, cu_msg); 675 676 memset(&msg, 0, sizeof(msg)); 677 msg.data = cmsg; 678 msg.len = sizeof(*cmsg); 679 680 ret = rpc_queue_upcall(pipe, &msg); 681 if (ret < 0) { 682 goto out; 683 } 684 685 wait_for_completion(&cup->cu_done); 686 687 if (msg.errno < 0) 688 ret = msg.errno; 689 out: 690 return ret; 691 } 692 693 static int 694 cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg) 695 { 696 int ret; 697 698 /* 699 * -EAGAIN occurs when pipe is closed and reopened while there are 700 * upcalls queued. 701 */ 702 do { 703 ret = __cld_pipe_upcall(pipe, cmsg); 704 } while (ret == -EAGAIN); 705 706 return ret; 707 } 708 709 static ssize_t 710 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen) 711 { 712 struct cld_upcall *tmp, *cup; 713 struct cld_msg __user *cmsg = (struct cld_msg __user *)src; 714 uint32_t xid; 715 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info, 716 nfsd_net_id); 717 struct cld_net *cn = nn->cld_net; 718 719 if (mlen != sizeof(*cmsg)) { 720 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen, 721 sizeof(*cmsg)); 722 return -EINVAL; 723 } 724 725 /* copy just the xid so we can try to find that */ 726 if (copy_from_user(&xid, &cmsg->cm_xid, sizeof(xid)) != 0) { 727 dprintk("%s: error when copying xid from userspace", __func__); 728 return -EFAULT; 729 } 730 731 /* walk the list and find corresponding xid */ 732 cup = NULL; 733 spin_lock(&cn->cn_lock); 734 list_for_each_entry(tmp, &cn->cn_list, cu_list) { 735 if (get_unaligned(&tmp->cu_msg.cm_xid) == xid) { 736 cup = tmp; 737 list_del_init(&cup->cu_list); 738 break; 739 } 740 } 741 spin_unlock(&cn->cn_lock); 742 743 /* couldn't find upcall? */ 744 if (!cup) { 745 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid); 746 return -EINVAL; 747 } 748 749 if (copy_from_user(&cup->cu_msg, src, mlen) != 0) 750 return -EFAULT; 751 752 complete(&cup->cu_done); 753 return mlen; 754 } 755 756 static void 757 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg) 758 { 759 struct cld_msg *cmsg = msg->data; 760 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall, 761 cu_msg); 762 763 /* errno >= 0 means we got a downcall */ 764 if (msg->errno >= 0) 765 return; 766 767 complete(&cup->cu_done); 768 } 769 770 static const struct rpc_pipe_ops cld_upcall_ops = { 771 .upcall = rpc_pipe_generic_upcall, 772 .downcall = cld_pipe_downcall, 773 .destroy_msg = cld_pipe_destroy_msg, 774 }; 775 776 static struct dentry * 777 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe) 778 { 779 struct dentry *dir, *dentry; 780 781 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR); 782 if (dir == NULL) 783 return ERR_PTR(-ENOENT); 784 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe); 785 dput(dir); 786 return dentry; 787 } 788 789 static void 790 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe) 791 { 792 if (pipe->dentry) 793 rpc_unlink(pipe->dentry); 794 } 795 796 static struct dentry * 797 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe) 798 { 799 struct super_block *sb; 800 struct dentry *dentry; 801 802 sb = rpc_get_sb_net(net); 803 if (!sb) 804 return NULL; 805 dentry = nfsd4_cld_register_sb(sb, pipe); 806 rpc_put_sb_net(net); 807 return dentry; 808 } 809 810 static void 811 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe) 812 { 813 struct super_block *sb; 814 815 sb = rpc_get_sb_net(net); 816 if (sb) { 817 nfsd4_cld_unregister_sb(pipe); 818 rpc_put_sb_net(net); 819 } 820 } 821 822 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */ 823 static int 824 nfsd4_init_cld_pipe(struct net *net) 825 { 826 int ret; 827 struct dentry *dentry; 828 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 829 struct cld_net *cn; 830 831 if (nn->cld_net) 832 return 0; 833 834 cn = kzalloc(sizeof(*cn), GFP_KERNEL); 835 if (!cn) { 836 ret = -ENOMEM; 837 goto err; 838 } 839 840 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN); 841 if (IS_ERR(cn->cn_pipe)) { 842 ret = PTR_ERR(cn->cn_pipe); 843 goto err; 844 } 845 spin_lock_init(&cn->cn_lock); 846 INIT_LIST_HEAD(&cn->cn_list); 847 848 dentry = nfsd4_cld_register_net(net, cn->cn_pipe); 849 if (IS_ERR(dentry)) { 850 ret = PTR_ERR(dentry); 851 goto err_destroy_data; 852 } 853 854 cn->cn_pipe->dentry = dentry; 855 nn->cld_net = cn; 856 return 0; 857 858 err_destroy_data: 859 rpc_destroy_pipe_data(cn->cn_pipe); 860 err: 861 kfree(cn); 862 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n", 863 ret); 864 return ret; 865 } 866 867 static void 868 nfsd4_remove_cld_pipe(struct net *net) 869 { 870 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 871 struct cld_net *cn = nn->cld_net; 872 873 nfsd4_cld_unregister_net(net, cn->cn_pipe); 874 rpc_destroy_pipe_data(cn->cn_pipe); 875 kfree(nn->cld_net); 876 nn->cld_net = NULL; 877 } 878 879 static struct cld_upcall * 880 alloc_cld_upcall(struct cld_net *cn) 881 { 882 struct cld_upcall *new, *tmp; 883 884 new = kzalloc(sizeof(*new), GFP_KERNEL); 885 if (!new) 886 return new; 887 888 /* FIXME: hard cap on number in flight? */ 889 restart_search: 890 spin_lock(&cn->cn_lock); 891 list_for_each_entry(tmp, &cn->cn_list, cu_list) { 892 if (tmp->cu_msg.cm_xid == cn->cn_xid) { 893 cn->cn_xid++; 894 spin_unlock(&cn->cn_lock); 895 goto restart_search; 896 } 897 } 898 init_completion(&new->cu_done); 899 new->cu_msg.cm_vers = CLD_UPCALL_VERSION; 900 put_unaligned(cn->cn_xid++, &new->cu_msg.cm_xid); 901 new->cu_net = cn; 902 list_add(&new->cu_list, &cn->cn_list); 903 spin_unlock(&cn->cn_lock); 904 905 dprintk("%s: allocated xid %u\n", __func__, new->cu_msg.cm_xid); 906 907 return new; 908 } 909 910 static void 911 free_cld_upcall(struct cld_upcall *victim) 912 { 913 struct cld_net *cn = victim->cu_net; 914 915 spin_lock(&cn->cn_lock); 916 list_del(&victim->cu_list); 917 spin_unlock(&cn->cn_lock); 918 kfree(victim); 919 } 920 921 /* Ask daemon to create a new record */ 922 static void 923 nfsd4_cld_create(struct nfs4_client *clp) 924 { 925 int ret; 926 struct cld_upcall *cup; 927 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 928 struct cld_net *cn = nn->cld_net; 929 930 /* Don't upcall if it's already stored */ 931 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 932 return; 933 934 cup = alloc_cld_upcall(cn); 935 if (!cup) { 936 ret = -ENOMEM; 937 goto out_err; 938 } 939 940 cup->cu_msg.cm_cmd = Cld_Create; 941 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 942 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 943 clp->cl_name.len); 944 945 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg); 946 if (!ret) { 947 ret = cup->cu_msg.cm_status; 948 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 949 } 950 951 free_cld_upcall(cup); 952 out_err: 953 if (ret) 954 printk(KERN_ERR "NFSD: Unable to create client " 955 "record on stable storage: %d\n", ret); 956 } 957 958 /* Ask daemon to create a new record */ 959 static void 960 nfsd4_cld_remove(struct nfs4_client *clp) 961 { 962 int ret; 963 struct cld_upcall *cup; 964 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 965 struct cld_net *cn = nn->cld_net; 966 967 /* Don't upcall if it's already removed */ 968 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 969 return; 970 971 cup = alloc_cld_upcall(cn); 972 if (!cup) { 973 ret = -ENOMEM; 974 goto out_err; 975 } 976 977 cup->cu_msg.cm_cmd = Cld_Remove; 978 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 979 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 980 clp->cl_name.len); 981 982 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg); 983 if (!ret) { 984 ret = cup->cu_msg.cm_status; 985 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 986 } 987 988 free_cld_upcall(cup); 989 out_err: 990 if (ret) 991 printk(KERN_ERR "NFSD: Unable to remove client " 992 "record from stable storage: %d\n", ret); 993 } 994 995 /* Check for presence of a record, and update its timestamp */ 996 static int 997 nfsd4_cld_check(struct nfs4_client *clp) 998 { 999 int ret; 1000 struct cld_upcall *cup; 1001 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1002 struct cld_net *cn = nn->cld_net; 1003 1004 /* Don't upcall if one was already stored during this grace pd */ 1005 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1006 return 0; 1007 1008 cup = alloc_cld_upcall(cn); 1009 if (!cup) { 1010 printk(KERN_ERR "NFSD: Unable to check client record on " 1011 "stable storage: %d\n", -ENOMEM); 1012 return -ENOMEM; 1013 } 1014 1015 cup->cu_msg.cm_cmd = Cld_Check; 1016 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len; 1017 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data, 1018 clp->cl_name.len); 1019 1020 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg); 1021 if (!ret) { 1022 ret = cup->cu_msg.cm_status; 1023 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1024 } 1025 1026 free_cld_upcall(cup); 1027 return ret; 1028 } 1029 1030 static void 1031 nfsd4_cld_grace_done(struct nfsd_net *nn) 1032 { 1033 int ret; 1034 struct cld_upcall *cup; 1035 struct cld_net *cn = nn->cld_net; 1036 1037 cup = alloc_cld_upcall(cn); 1038 if (!cup) { 1039 ret = -ENOMEM; 1040 goto out_err; 1041 } 1042 1043 cup->cu_msg.cm_cmd = Cld_GraceDone; 1044 cup->cu_msg.cm_u.cm_gracetime = (int64_t)nn->boot_time; 1045 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg); 1046 if (!ret) 1047 ret = cup->cu_msg.cm_status; 1048 1049 free_cld_upcall(cup); 1050 out_err: 1051 if (ret) 1052 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret); 1053 } 1054 1055 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = { 1056 .init = nfsd4_init_cld_pipe, 1057 .exit = nfsd4_remove_cld_pipe, 1058 .create = nfsd4_cld_create, 1059 .remove = nfsd4_cld_remove, 1060 .check = nfsd4_cld_check, 1061 .grace_done = nfsd4_cld_grace_done, 1062 }; 1063 1064 /* upcall via usermodehelper */ 1065 static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack"; 1066 module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog), 1067 S_IRUGO|S_IWUSR); 1068 MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program"); 1069 1070 static bool cltrack_legacy_disable; 1071 module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR); 1072 MODULE_PARM_DESC(cltrack_legacy_disable, 1073 "Disable legacy recoverydir conversion. Default: false"); 1074 1075 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR=" 1076 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR=" 1077 #define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION=" 1078 #define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START=" 1079 1080 static char * 1081 nfsd4_cltrack_legacy_topdir(void) 1082 { 1083 int copied; 1084 size_t len; 1085 char *result; 1086 1087 if (cltrack_legacy_disable) 1088 return NULL; 1089 1090 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) + 1091 strlen(nfs4_recoverydir()) + 1; 1092 1093 result = kmalloc(len, GFP_KERNEL); 1094 if (!result) 1095 return result; 1096 1097 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s", 1098 nfs4_recoverydir()); 1099 if (copied >= len) { 1100 /* just return nothing if output was truncated */ 1101 kfree(result); 1102 return NULL; 1103 } 1104 1105 return result; 1106 } 1107 1108 static char * 1109 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name) 1110 { 1111 int copied; 1112 size_t len; 1113 char *result; 1114 1115 if (cltrack_legacy_disable) 1116 return NULL; 1117 1118 /* +1 is for '/' between "topdir" and "recdir" */ 1119 len = strlen(LEGACY_RECDIR_ENV_PREFIX) + 1120 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN; 1121 1122 result = kmalloc(len, GFP_KERNEL); 1123 if (!result) 1124 return result; 1125 1126 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/", 1127 nfs4_recoverydir()); 1128 if (copied > (len - HEXDIR_LEN)) { 1129 /* just return nothing if output will be truncated */ 1130 kfree(result); 1131 return NULL; 1132 } 1133 1134 copied = nfs4_make_rec_clidname(result + copied, name); 1135 if (copied) { 1136 kfree(result); 1137 return NULL; 1138 } 1139 1140 return result; 1141 } 1142 1143 static char * 1144 nfsd4_cltrack_client_has_session(struct nfs4_client *clp) 1145 { 1146 int copied; 1147 size_t len; 1148 char *result; 1149 1150 /* prefix + Y/N character + terminating NULL */ 1151 len = strlen(HAS_SESSION_ENV_PREFIX) + 1 + 1; 1152 1153 result = kmalloc(len, GFP_KERNEL); 1154 if (!result) 1155 return result; 1156 1157 copied = snprintf(result, len, HAS_SESSION_ENV_PREFIX "%c", 1158 clp->cl_minorversion ? 'Y' : 'N'); 1159 if (copied >= len) { 1160 /* just return nothing if output was truncated */ 1161 kfree(result); 1162 return NULL; 1163 } 1164 1165 return result; 1166 } 1167 1168 static char * 1169 nfsd4_cltrack_grace_start(time_t grace_start) 1170 { 1171 int copied; 1172 size_t len; 1173 char *result; 1174 1175 /* prefix + max width of int64_t string + terminating NULL */ 1176 len = strlen(GRACE_START_ENV_PREFIX) + 22 + 1; 1177 1178 result = kmalloc(len, GFP_KERNEL); 1179 if (!result) 1180 return result; 1181 1182 copied = snprintf(result, len, GRACE_START_ENV_PREFIX "%ld", 1183 grace_start); 1184 if (copied >= len) { 1185 /* just return nothing if output was truncated */ 1186 kfree(result); 1187 return NULL; 1188 } 1189 1190 return result; 1191 } 1192 1193 static int 1194 nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1) 1195 { 1196 char *envp[3]; 1197 char *argv[4]; 1198 int ret; 1199 1200 if (unlikely(!cltrack_prog[0])) { 1201 dprintk("%s: cltrack_prog is disabled\n", __func__); 1202 return -EACCES; 1203 } 1204 1205 dprintk("%s: cmd: %s\n", __func__, cmd); 1206 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)"); 1207 dprintk("%s: env0: %s\n", __func__, env0 ? env0 : "(null)"); 1208 dprintk("%s: env1: %s\n", __func__, env1 ? env1 : "(null)"); 1209 1210 envp[0] = env0; 1211 envp[1] = env1; 1212 envp[2] = NULL; 1213 1214 argv[0] = (char *)cltrack_prog; 1215 argv[1] = cmd; 1216 argv[2] = arg; 1217 argv[3] = NULL; 1218 1219 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC); 1220 /* 1221 * Disable the upcall mechanism if we're getting an ENOENT or EACCES 1222 * error. The admin can re-enable it on the fly by using sysfs 1223 * once the problem has been fixed. 1224 */ 1225 if (ret == -ENOENT || ret == -EACCES) { 1226 dprintk("NFSD: %s was not found or isn't executable (%d). " 1227 "Setting cltrack_prog to blank string!", 1228 cltrack_prog, ret); 1229 cltrack_prog[0] = '\0'; 1230 } 1231 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret); 1232 1233 return ret; 1234 } 1235 1236 static char * 1237 bin_to_hex_dup(const unsigned char *src, int srclen) 1238 { 1239 int i; 1240 char *buf, *hex; 1241 1242 /* +1 for terminating NULL */ 1243 buf = kmalloc((srclen * 2) + 1, GFP_KERNEL); 1244 if (!buf) 1245 return buf; 1246 1247 hex = buf; 1248 for (i = 0; i < srclen; i++) { 1249 sprintf(hex, "%2.2x", *src++); 1250 hex += 2; 1251 } 1252 return buf; 1253 } 1254 1255 static int 1256 nfsd4_umh_cltrack_init(struct net *net) 1257 { 1258 int ret; 1259 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1260 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time); 1261 1262 /* XXX: The usermode helper s not working in container yet. */ 1263 if (net != &init_net) { 1264 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n"); 1265 kfree(grace_start); 1266 return -EINVAL; 1267 } 1268 1269 ret = nfsd4_umh_cltrack_upcall("init", NULL, grace_start, NULL); 1270 kfree(grace_start); 1271 return ret; 1272 } 1273 1274 static void 1275 nfsd4_cltrack_upcall_lock(struct nfs4_client *clp) 1276 { 1277 wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK, 1278 TASK_UNINTERRUPTIBLE); 1279 } 1280 1281 static void 1282 nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp) 1283 { 1284 smp_mb__before_atomic(); 1285 clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags); 1286 smp_mb__after_atomic(); 1287 wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK); 1288 } 1289 1290 static void 1291 nfsd4_umh_cltrack_create(struct nfs4_client *clp) 1292 { 1293 char *hexid, *has_session, *grace_start; 1294 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1295 1296 /* 1297 * With v4.0 clients, there's little difference in outcome between a 1298 * create and check operation, and we can end up calling into this 1299 * function multiple times per client (once for each openowner). So, 1300 * for v4.0 clients skip upcalling once the client has been recorded 1301 * on stable storage. 1302 * 1303 * For v4.1+ clients, the outcome of the two operations is different, 1304 * so we must ensure that we upcall for the create operation. v4.1+ 1305 * clients call this on RECLAIM_COMPLETE though, so we should only end 1306 * up doing a single create upcall per client. 1307 */ 1308 if (clp->cl_minorversion == 0 && 1309 test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1310 return; 1311 1312 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1313 if (!hexid) { 1314 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1315 return; 1316 } 1317 1318 has_session = nfsd4_cltrack_client_has_session(clp); 1319 grace_start = nfsd4_cltrack_grace_start(nn->boot_time); 1320 1321 nfsd4_cltrack_upcall_lock(clp); 1322 if (!nfsd4_umh_cltrack_upcall("create", hexid, has_session, grace_start)) 1323 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1324 nfsd4_cltrack_upcall_unlock(clp); 1325 1326 kfree(has_session); 1327 kfree(grace_start); 1328 kfree(hexid); 1329 } 1330 1331 static void 1332 nfsd4_umh_cltrack_remove(struct nfs4_client *clp) 1333 { 1334 char *hexid; 1335 1336 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1337 return; 1338 1339 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1340 if (!hexid) { 1341 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1342 return; 1343 } 1344 1345 nfsd4_cltrack_upcall_lock(clp); 1346 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) && 1347 nfsd4_umh_cltrack_upcall("remove", hexid, NULL, NULL) == 0) 1348 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1349 nfsd4_cltrack_upcall_unlock(clp); 1350 1351 kfree(hexid); 1352 } 1353 1354 static int 1355 nfsd4_umh_cltrack_check(struct nfs4_client *clp) 1356 { 1357 int ret; 1358 char *hexid, *has_session, *legacy; 1359 1360 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) 1361 return 0; 1362 1363 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len); 1364 if (!hexid) { 1365 dprintk("%s: can't allocate memory for upcall!\n", __func__); 1366 return -ENOMEM; 1367 } 1368 1369 has_session = nfsd4_cltrack_client_has_session(clp); 1370 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name); 1371 1372 nfsd4_cltrack_upcall_lock(clp); 1373 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) { 1374 ret = 0; 1375 } else { 1376 ret = nfsd4_umh_cltrack_upcall("check", hexid, has_session, legacy); 1377 if (ret == 0) 1378 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags); 1379 } 1380 nfsd4_cltrack_upcall_unlock(clp); 1381 kfree(has_session); 1382 kfree(legacy); 1383 kfree(hexid); 1384 1385 return ret; 1386 } 1387 1388 static void 1389 nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn) 1390 { 1391 char *legacy; 1392 char timestr[22]; /* FIXME: better way to determine max size? */ 1393 1394 sprintf(timestr, "%ld", nn->boot_time); 1395 legacy = nfsd4_cltrack_legacy_topdir(); 1396 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy, NULL); 1397 kfree(legacy); 1398 } 1399 1400 static const struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = { 1401 .init = nfsd4_umh_cltrack_init, 1402 .exit = NULL, 1403 .create = nfsd4_umh_cltrack_create, 1404 .remove = nfsd4_umh_cltrack_remove, 1405 .check = nfsd4_umh_cltrack_check, 1406 .grace_done = nfsd4_umh_cltrack_grace_done, 1407 }; 1408 1409 int 1410 nfsd4_client_tracking_init(struct net *net) 1411 { 1412 int status; 1413 struct path path; 1414 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1415 1416 /* just run the init if it the method is already decided */ 1417 if (nn->client_tracking_ops) 1418 goto do_init; 1419 1420 /* 1421 * First, try a UMH upcall. It should succeed or fail quickly, so 1422 * there's little harm in trying that first. 1423 */ 1424 nn->client_tracking_ops = &nfsd4_umh_tracking_ops; 1425 status = nn->client_tracking_ops->init(net); 1426 if (!status) 1427 return status; 1428 1429 /* 1430 * See if the recoverydir exists and is a directory. If it is, 1431 * then use the legacy ops. 1432 */ 1433 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops; 1434 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path); 1435 if (!status) { 1436 status = d_is_dir(path.dentry); 1437 path_put(&path); 1438 if (status) 1439 goto do_init; 1440 } 1441 1442 /* Finally, try to use nfsdcld */ 1443 nn->client_tracking_ops = &nfsd4_cld_tracking_ops; 1444 printk(KERN_WARNING "NFSD: the nfsdcld client tracking upcall will be " 1445 "removed in 3.10. Please transition to using " 1446 "nfsdcltrack.\n"); 1447 do_init: 1448 status = nn->client_tracking_ops->init(net); 1449 if (status) { 1450 printk(KERN_WARNING "NFSD: Unable to initialize client " 1451 "recovery tracking! (%d)\n", status); 1452 nn->client_tracking_ops = NULL; 1453 } 1454 return status; 1455 } 1456 1457 void 1458 nfsd4_client_tracking_exit(struct net *net) 1459 { 1460 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1461 1462 if (nn->client_tracking_ops) { 1463 if (nn->client_tracking_ops->exit) 1464 nn->client_tracking_ops->exit(net); 1465 nn->client_tracking_ops = NULL; 1466 } 1467 } 1468 1469 void 1470 nfsd4_client_record_create(struct nfs4_client *clp) 1471 { 1472 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1473 1474 if (nn->client_tracking_ops) 1475 nn->client_tracking_ops->create(clp); 1476 } 1477 1478 void 1479 nfsd4_client_record_remove(struct nfs4_client *clp) 1480 { 1481 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1482 1483 if (nn->client_tracking_ops) 1484 nn->client_tracking_ops->remove(clp); 1485 } 1486 1487 int 1488 nfsd4_client_record_check(struct nfs4_client *clp) 1489 { 1490 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id); 1491 1492 if (nn->client_tracking_ops) 1493 return nn->client_tracking_ops->check(clp); 1494 1495 return -EOPNOTSUPP; 1496 } 1497 1498 void 1499 nfsd4_record_grace_done(struct nfsd_net *nn) 1500 { 1501 if (nn->client_tracking_ops) 1502 nn->client_tracking_ops->grace_done(nn); 1503 } 1504 1505 static int 1506 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr) 1507 { 1508 struct super_block *sb = ptr; 1509 struct net *net = sb->s_fs_info; 1510 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 1511 struct cld_net *cn = nn->cld_net; 1512 struct dentry *dentry; 1513 int ret = 0; 1514 1515 if (!try_module_get(THIS_MODULE)) 1516 return 0; 1517 1518 if (!cn) { 1519 module_put(THIS_MODULE); 1520 return 0; 1521 } 1522 1523 switch (event) { 1524 case RPC_PIPEFS_MOUNT: 1525 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe); 1526 if (IS_ERR(dentry)) { 1527 ret = PTR_ERR(dentry); 1528 break; 1529 } 1530 cn->cn_pipe->dentry = dentry; 1531 break; 1532 case RPC_PIPEFS_UMOUNT: 1533 if (cn->cn_pipe->dentry) 1534 nfsd4_cld_unregister_sb(cn->cn_pipe); 1535 break; 1536 default: 1537 ret = -ENOTSUPP; 1538 break; 1539 } 1540 module_put(THIS_MODULE); 1541 return ret; 1542 } 1543 1544 static struct notifier_block nfsd4_cld_block = { 1545 .notifier_call = rpc_pipefs_event, 1546 }; 1547 1548 int 1549 register_cld_notifier(void) 1550 { 1551 return rpc_pipefs_notifier_register(&nfsd4_cld_block); 1552 } 1553 1554 void 1555 unregister_cld_notifier(void) 1556 { 1557 rpc_pipefs_notifier_unregister(&nfsd4_cld_block); 1558 } 1559