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