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