fs/nfsd/nfs4recover.c

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