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