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 */ 55struct 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 */ 65static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery"; 66 67static int 68nfs4_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 83static void 84nfs4_reset_creds(const struct cred *original) 85{ 86 revert_creds(original); 87} 88 89static void 90md5_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 103static int 104nfs4_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; 136out: 137 kfree(cksum.data); 138 crypto_free_hash(desc.tfm); 139out_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 */ 148static void 149legacy_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 166static void 167nfsd4_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); 213out_put: 214 dput(dentry); 215out_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); 231out_creds: 232 nfs4_reset_creds(original_cred); 233} 234 235typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *); 236 237struct name_list { 238 char name[HEXDIR_LEN]; 239 struct list_head list; 240}; 241 242struct nfs4_dir_ctx { 243 struct dir_context ctx; 244 struct list_head names; 245}; 246 247static int 248nfsd4_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 266static int 267nfsd4_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 310static int 311nfsd4_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); 329out: 330 dput(dentry); 331out_unlock: 332 mutex_unlock(&d_inode(dir)->i_mutex); 333 return status; 334} 335 336static void 337nfsd4_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 } 372out_drop_write: 373 mnt_drop_write_file(nn->rec_file); 374out: 375 if (status) 376 printk("NFSD: Failed to remove expired client state directory" 377 " %.*s\n", HEXDIR_LEN, dname); 378} 379 380static int 381purge_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 396static void 397nfsd4_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); 411out: 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 418static int 419load_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 431static int 432nfsd4_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 450static int 451nfsd4_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 484static void 485nfsd4_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 495static int 496nfs4_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 513static void 514nfs4_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 521static int 522nfsd4_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 537static int 538nfsd4_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 558err: 559 nfs4_legacy_state_shutdown(net); 560 return status; 561} 562 563static void 564nfsd4_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 */ 576int 577nfs4_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 594char * 595nfs4_recoverydir(void) 596{ 597 return user_recovery_dirname; 598} 599 600static int 601nfsd4_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 629static 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 */ 643struct 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 650struct 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 657static 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; 682out: 683 return ret; 684} 685 686static int 687cld_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 702static ssize_t 703cld_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 749static void 750cld_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 763static 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 769static struct dentry * 770nfsd4_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 782static void 783nfsd4_cld_unregister_sb(struct rpc_pipe *pipe) 784{ 785 if (pipe->dentry) 786 rpc_unlink(pipe->dentry); 787} 788 789static struct dentry * 790nfsd4_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 803static void 804nfsd4_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 */ 816static int 817nfsd4_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 851err_destroy_data: 852 rpc_destroy_pipe_data(cn->cn_pipe); 853err: 854 kfree(cn); 855 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n", 856 ret); 857 return ret; 858} 859 860static void 861nfsd4_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 872static struct cld_upcall * 873alloc_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? */ 882restart_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 903static void 904free_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 */ 915static void 916nfsd4_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); 945out_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 */ 952static void 953nfsd4_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); 982out_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 */ 989static int 990nfsd4_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 1023static void 1024nfsd4_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); 1043out_err: 1044 if (ret) 1045 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret); 1046} 1047 1048static 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 */ 1058static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack"; 1059module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog), 1060 S_IRUGO|S_IWUSR); 1061MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program"); 1062 1063static bool cltrack_legacy_disable; 1064module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR); 1065MODULE_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 1073static char * 1074nfsd4_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 1101static char * 1102nfsd4_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 1136static char * 1137nfsd4_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 1161static char * 1162nfsd4_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 1186static int 1187nfsd4_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 1229static char * 1230bin_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 1248static int 1249nfsd4_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 1267static void 1268nfsd4_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 1274static void 1275nfsd4_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 1283static void 1284nfsd4_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 1324static void 1325nfsd4_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 1347static int 1348nfsd4_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 1381static void 1382nfsd4_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 1393static 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 1402int 1403nfsd4_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"); 1440do_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 1450void 1451nfsd4_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 1462void 1463nfsd4_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 1471void 1472nfsd4_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 1480int 1481nfsd4_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 1491void 1492nfsd4_record_grace_done(struct nfsd_net *nn) 1493{ 1494 if (nn->client_tracking_ops) 1495 nn->client_tracking_ops->grace_done(nn); 1496} 1497 1498static int 1499rpc_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 1537static struct notifier_block nfsd4_cld_block = { 1538 .notifier_call = rpc_pipefs_event, 1539}; 1540 1541int 1542register_cld_notifier(void) 1543{ 1544 return rpc_pipefs_notifier_register(&nfsd4_cld_block); 1545} 1546 1547void 1548unregister_cld_notifier(void) 1549{ 1550 rpc_pipefs_notifier_unregister(&nfsd4_cld_block); 1551} 1552