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