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(alg_name: "md5", type: 0, mask: 0);
118	if (IS_ERR(ptr: tfm)) {
119	status = PTR_ERR(ptr: tfm);
120	goto out_no_tfm;
121	}
122
123	cksum.len = crypto_shash_digestsize(tfm);
124	cksum.data = kmalloc(size: cksum.len, GFP_KERNEL);
125	if (cksum.data == NULL) {
126	status = -ENOMEM;
127	goto out;
128	}
129
130	status = crypto_shash_tfm_digest(tfm, data: clname->data, len: clname->len,
131	out: cksum.data);
132	if (status)
133	goto out;
134
135	md5_to_hex(out: dname, md5: cksum.data);
136
137	status = 0;
138	out:
139	kfree(objp: 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(net: 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(p: dname, size: 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(objp: 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(net: clp->net, id: nfsd_net_id);
199
200	if (test_and_set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags))
201	return;
202	if (!nn->rec_file)
203	return;
204
205	status = nfs4_make_rec_clidname(dname, clname: &clp->cl_name);
206	if (status)
207	return legacy_recdir_name_error(clp, error: status);
208
209	status = nfs4_save_creds(original_creds: &original_cred);
210	if (status < 0)
211	return;
212
213	status = mnt_want_write_file(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(inode: d_inode(dentry: dir));
220
221	dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
222	if (IS_ERR(ptr: dentry)) {
223	status = PTR_ERR(ptr: 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(dentry: dir), dentry, S_IRWXU);
237	out_put:
238	dput(dentry);
239	out_unlock:
240	inode_unlock(inode: d_inode(dentry: 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(file: nn->rec_file, datasync: 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(file: nn->rec_file);
253	out_creds:
254	nfs4_reset_creds(original: 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(size: 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(new: &entry->list, head: &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_creds: &original_cred);
301	if (status < 0)
302	return status;
303
304	status = vfs_llseek(file: nn->rec_file, offset: 0, SEEK_SET);
305	if (status < 0) {
306	nfs4_reset_creds(original: original_cred);
307	return status;
308	}
309
310	status = iterate_dir(nn->rec_file, &ctx.ctx);
311	inode_lock_nested(inode: d_inode(dentry: dir), subclass: 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(ptr: dentry)) {
318	status = PTR_ERR(ptr: dentry);
319	break;
320	}
321	status = f(dir, dentry, nn);
322	dput(dentry);
323	}
324	list_del(entry: &entry->list);
325	kfree(objp: entry);
326	}
327	inode_unlock(inode: d_inode(dentry: dir));
328	nfs4_reset_creds(original: 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: &entry->list);
333	kfree(objp: 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(inode: d_inode(dentry: dir), subclass: I_MUTEX_PARENT);
348	dentry = lookup_one_len(name, dir, namlen);
349	if (IS_ERR(ptr: dentry)) {
350	status = PTR_ERR(ptr: 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(dentry: dir), dentry);
357	out:
358	dput(dentry);
359	out_unlock:
360	inode_unlock(inode: d_inode(dentry: 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(p: dname, size: 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(objp: 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(net: clp->net, id: 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, clname: &clp->cl_name);
396	if (status)
397	return legacy_recdir_name_error(clp, error: status);
398
399	status = mnt_want_write_file(file: nn->rec_file);
400	if (status)
401	goto out;
402	clear_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
403
404	status = nfs4_save_creds(original_creds: &original_cred);
405	if (status < 0)
406	goto out_drop_write;
407
408	status = nfsd4_unlink_clid_dir(name: dname, HEXDIR_LEN-1, nn);
409	nfs4_reset_creds(original: original_cred);
410	if (status == 0) {
411	vfs_fsync(file: nn->rec_file, datasync: 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(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(s: child->d_name.name, len: 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(dentry: parent), child);
447	if (status)
448	printk("failed to remove client recovery directory %pd\n",
449	child);
450	out_free:
451	kfree(objp: 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(file: nn->rec_file);
466	if (status)
467	goto out;
468	status = nfsd4_list_rec_dir(f: purge_old, nn);
469	if (status == 0)
470	vfs_fsync(file: nn->rec_file, datasync: 0);
471	mnt_drop_write_file(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(s: child->d_name.name, len: 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(objp: 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, id: nfsd_net_id);
508
509	if (!nn->rec_file)
510	return 0;
511
512	status = nfsd4_list_rec_dir(f: 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, id: 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_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(ptr: nn->rec_file)) {
545	printk("NFSD: unable to find recovery directory %s\n",
546	user_recovery_dirname);
547	status = PTR_ERR(ptr: nn->rec_file);
548	nn->rec_file = NULL;
549	}
550
551	nfs4_reset_creds(original: 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, id: 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, id: nfsd_net_id);
572	int i;
573
574	nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
575	size: 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(list: &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, id: nfsd_net_id);
591
592	kfree(objp: 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, id: 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(dentry: path.dentry)) {
661	strcpy(p: user_recovery_dirname, q: 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(net: clp->net, id: 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, clname: &clp->cl_name);
688	if (status) {
689	legacy_recdir_name_error(clp, error: status);
690	return status;
691	}
692
693	/* look for it in the reclaim hashtable otherwise */
694	name.data = kmemdup(p: 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(objp: name.data);
703	if (crp) {
704	set_bit(NFSD4_CLIENT_STABLE, addr: &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(ptr: name.data))
811	return PTR_ERR(ptr: 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(ptr: princhash.data)) {
819	kfree(objp: name.data);
820	return PTR_ERR(ptr: 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(ptr: name.data))
833	return PTR_ERR(ptr: name.data);
834	name.len = namelen;
835	}
836	if (name.len > 5 && memcmp(p: name.data, q: "hash:", size: 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(objp: name.data);
843	kfree(objp: 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(net: file_inode(f: filp)->i_sb->s_fs_info,
859	id: 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(to: &xid, from: &hdr->cm_xid, n: 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(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(entry: &cup->cu_list);
893	break;
894	}
895	}
896	spin_unlock(lock: &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(to: &cup->cu_u.cu_msg_v2, from: src, n: 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(error: -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, id: nfsd_net_id);
987	struct cld_net *cn;
988
989	if (nn->cld_net)
990	return 0;
991
992	cn = kzalloc(size: sizeof(*cn), GFP_KERNEL);
993	if (!cn) {
994	ret = -ENOMEM;
995	goto err;
996	}
997
998	cn->cn_pipe = rpc_mkpipe_data(ops: &cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
999	if (IS_ERR(ptr: cn->cn_pipe)) {
1000	ret = PTR_ERR(ptr: cn->cn_pipe);
1001	goto err;
1002	}
1003	spin_lock_init(&cn->cn_lock);
1004	INIT_LIST_HEAD(list: &cn->cn_list);
1005
1006	dentry = nfsd4_cld_register_net(net, pipe: cn->cn_pipe);
1007	if (IS_ERR(ptr: dentry)) {
1008	ret = PTR_ERR(ptr: 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(pipe: cn->cn_pipe);
1019	err:
1020	kfree(objp: 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, id: nfsd_net_id);
1041	struct cld_net *cn = nn->cld_net;
1042
1043	nfsd4_cld_unregister_net(net, pipe: cn->cn_pipe);
1044	rpc_destroy_pipe_data(pipe: cn->cn_pipe);
1045	if (cn->cn_tfm)
1046	crypto_free_shash(tfm: cn->cn_tfm);
1047	kfree(objp: 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(size: 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(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(lock: &cn->cn_lock);
1068	goto restart_search;
1069	}
1070	}
1071	init_completion(x: &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: &new->cu_list, head: &cn->cn_list);
1076	spin_unlock(lock: &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(lock: &cn->cn_lock);
1089	list_del(entry: &victim->cu_list);
1090	spin_unlock(lock: &cn->cn_lock);
1091	kfree(objp: 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(net: clp->net, id: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1119	if (!ret) {
1120	ret = cup->cu_u.cu_msg.cm_status;
1121	set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1122	}
1123
1124	free_cld_upcall(victim: 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(net: clp->net, id: 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(size: cksum.len, GFP_KERNEL);
1166	if (cksum.data == NULL) {
1167	ret = -ENOMEM;
1168	goto out;
1169	}
1170	ret = crypto_shash_tfm_digest(tfm, data: principal, strlen(principal),
1171	out: cksum.data);
1172	if (ret) {
1173	kfree(objp: 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(objp: cksum.data);
1180	} else
1181	cmsg->cm_u.cm_clntinfo.cc_princhash.cp_len = 0;
1182
1183	ret = cld_pipe_upcall(pipe: cn->cn_pipe, cmsg, nn);
1184	if (!ret) {
1185	ret = cmsg->cm_status;
1186	set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1187	}
1188
1189	out:
1190	free_cld_upcall(victim: 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(net: clp->net, id: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1222	if (!ret) {
1223	ret = cup->cu_u.cu_msg.cm_status;
1224	clear_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1225	}
1226
1227	free_cld_upcall(victim: 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(net: clp->net, id: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1265	if (!ret) {
1266	ret = cup->cu_u.cu_msg.cm_status;
1267	set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1268	}
1269
1270	free_cld_upcall(victim: 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(net: clp->net, id: 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(name: clp->cl_name, nn);
1296	if (crp)
1297	goto found;
1298
1299	if (cn->cn_has_legacy) {
1300	status = nfs4_make_rec_clidname(dname, clname: &clp->cl_name);
1301	if (status)
1302	return -ENOENT;
1303
1304	name.data = kmemdup(p: 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(objp: 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(net: clp->net, id: 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(name: clp->cl_name, nn);
1342	if (crp)
1343	goto found;
1344
1345	if (cn->cn_has_legacy) {
1346	status = nfs4_make_rec_clidname(dname, clname: &clp->cl_name);
1347	if (status)
1348	return -ENOENT;
1349
1350	name.data = kmemdup(p: 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(objp: 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(size: cksum.len, GFP_KERNEL);
1374	if (cksum.data == NULL)
1375	return -ENOENT;
1376	status = crypto_shash_tfm_digest(tfm, data: principal,
1377	strlen(principal), out: cksum.data);
1378	if (status) {
1379	kfree(objp: cksum.data);
1380	return -ENOENT;
1381	}
1382	if (memcmp(p: crp->cr_princhash.data, q: cksum.data,
1383	size: crp->cr_princhash.len)) {
1384	kfree(objp: cksum.data);
1385	return -ENOENT;
1386	}
1387	kfree(objp: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1408	if (!ret)
1409	ret = cup->cu_u.cu_msg.cm_status;
1410
1411	free_cld_upcall(victim: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1436	if (!ret)
1437	ret = cup->cu_u.cu_msg.cm_status;
1438
1439	free_cld_upcall(victim: 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(pipe: cn->cn_pipe, cmsg: &cup->cu_u.cu_msg, nn);
1464	if (!ret)
1465	ret = cup->cu_u.cu_msg.cm_status;
1466
1467	free_cld_upcall(victim: 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, id: nfsd_net_id);
1478	int i;
1479
1480	nn->reclaim_str_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
1481	size: 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(list: &nn->reclaim_str_hashtbl[i]);
1488	nn->reclaim_str_hashtbl_size = 0;
1489	nn->track_reclaim_completes = true;
1490	atomic_set(v: &nn->nr_reclaim_complete, i: 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, id: nfsd_net_id);
1499
1500	nn->track_reclaim_completes = false;
1501	kfree(objp: 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(pipe: cn->cn_pipe, cmsg: &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(victim: 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, id: 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(msecs: 100);
1587
1588	if (!running) {
1589	status = -ETIMEDOUT;
1590	goto err_remove;
1591	}
1592	tfm = crypto_alloc_shash(alg_name: "sha256", type: 0, mask: 0);
1593	if (IS_ERR(ptr: tfm)) {
1594	status = PTR_ERR(ptr: 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, id: 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(size: len, GFP_KERNEL);
1696	if (!result)
1697	return result;
1698
1699	copied = snprintf(buf: result, size: len, LEGACY_TOPDIR_ENV_PREFIX "%s",
1700	nfs4_recoverydir());
1701	if (copied >= len) {
1702	/* just return nothing if output was truncated */
1703	kfree(objp: 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(size: len, GFP_KERNEL);
1725	if (!result)
1726	return result;
1727
1728	copied = snprintf(buf: result, size: 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(objp: result);
1733	return NULL;
1734	}
1735
1736	copied = nfs4_make_rec_clidname(dname: result + copied, clname: name);
1737	if (copied) {
1738	kfree(objp: 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(size: len, GFP_KERNEL);
1756	if (!result)
1757	return result;
1758
1759	copied = snprintf(buf: result, size: 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(objp: 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(size: len, GFP_KERNEL);
1781	if (!result)
1782	return result;
1783
1784	copied = snprintf(buf: result, size: len, GRACE_START_ENV_PREFIX "%lld",
1785	grace_start);
1786	if (copied >= len) {
1787	/* just return nothing if output was truncated */
1788	kfree(objp: 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(path: 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(size: (srclen * 2) + 1, GFP_KERNEL);
1845	if (!buf)
1846	return buf;
1847
1848	bin2hex(dst: buf, src, count: 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, id: nfsd_net_id);
1857	char *grace_start = nfsd4_cltrack_grace_start(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(objp: grace_start);
1863	return -EINVAL;
1864	}
1865
1866	ret = nfsd4_umh_cltrack_upcall(cmd: "init", NULL, env0: grace_start, NULL);
1867	kfree(objp: 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(word: &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, addr: &clp->cl_flags);
1885	smp_mb__after_atomic();
1886	wake_up_bit(word: &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(net: clp->net, id: 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(src: clp->cl_name.data, srclen: 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(grace_start: nn->boot_time);
1919
1920	nfsd4_cltrack_upcall_lock(clp);
1921	if (!nfsd4_umh_cltrack_upcall(cmd: "create", arg: hexid, env0: has_session, env1: grace_start))
1922	set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1923	nfsd4_cltrack_upcall_unlock(clp);
1924
1925	kfree(objp: has_session);
1926	kfree(objp: grace_start);
1927	kfree(objp: 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(src: clp->cl_name.data, srclen: 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(cmd: "remove", arg: hexid, NULL, NULL) == 0)
1947	clear_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1948	nfsd4_cltrack_upcall_unlock(clp);
1949
1950	kfree(objp: 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(src: clp->cl_name.data, srclen: 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(name: &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(cmd: "check", arg: hexid, env0: has_session, env1: legacy);
1976	if (ret == 0)
1977	set_bit(NFSD4_CLIENT_STABLE, addr: &clp->cl_flags);
1978	}
1979	nfsd4_cltrack_upcall_unlock(clp);
1980	kfree(objp: has_session);
1981	kfree(objp: legacy);
1982	kfree(objp: 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(buf: timestr, fmt: "%lld", nn->boot_time);
1994	legacy = nfsd4_cltrack_legacy_topdir();
1995	nfsd4_umh_cltrack_upcall(cmd: "gracedone", arg: timestr, env0: legacy, NULL);
1996	kfree(objp: 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, id: 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(dentry: 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, id: 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(net: clp->net, id: 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(net: clp->net, id: 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(net: clp->net, id: 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, id: 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, pipe: cn->cn_pipe);
2136	if (IS_ERR(ptr: dentry)) {
2137	ret = PTR_ERR(ptr: 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(pipe: 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