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