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