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