2 * Copyright (c) 2004 The Regents of the University of Michigan.
3 * Copyright (c) 2012 Jeff Layton <jlayton@redhat.com>
6 * Andy Adamson <andros@citi.umich.edu>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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.
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>
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>
52 #define NFSDDBG_FACILITY NFSDDBG_PROC
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 *, time_t);
65 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
68 nfs4_save_creds(const struct cred **original_creds)
72 new = prepare_creds();
78 *original_creds = override_creds(new);
84 nfs4_reset_creds(const struct cred *original)
86 revert_creds(original);
90 md5_to_hex(char *out, char *md5)
94 for (i=0; i<16; i++) {
95 unsigned char c = md5[i];
97 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
98 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
104 nfs4_make_rec_clidname(char *dname, const struct xdr_netobj *clname)
106 struct xdr_netobj cksum;
107 struct hash_desc desc;
108 struct scatterlist sg;
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);
120 cksum.len = crypto_hash_digestsize(desc.tfm);
121 cksum.data = kmalloc(cksum.len, GFP_KERNEL);
122 if (cksum.data == NULL) {
127 sg_init_one(&sg, clname->data, clname->len);
129 status = crypto_hash_digest(&desc, &sg, sg.length, cksum.data);
133 md5_to_hex(dname, cksum.data);
138 crypto_free_hash(desc.tfm);
144 * If we had an error generating the recdir name for the legacy tracker
145 * then warn the admin. If the error doesn't appear to be transient,
146 * then disable recovery tracking.
149 legacy_recdir_name_error(int error)
151 printk(KERN_ERR "NFSD: unable to generate recoverydir "
152 "name (%d).\n", error);
155 * if the algorithm just doesn't exist, then disable the recovery
156 * tracker altogether. The crypto libs will generally return this if
157 * FIPS is enabled as well.
159 if (error == -ENOENT) {
160 printk(KERN_ERR "NFSD: disabling legacy clientid tracking. "
161 "Reboot recovery will not function correctly!\n");
163 /* the argument is ignored by the legacy exit function */
164 nfsd4_client_tracking_exit(NULL);
169 nfsd4_create_clid_dir(struct nfs4_client *clp)
171 const struct cred *original_cred;
172 char dname[HEXDIR_LEN];
173 struct dentry *dir, *dentry;
174 struct nfs4_client_reclaim *crp;
176 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
178 dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname);
180 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
185 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
187 return legacy_recdir_name_error(status);
189 status = nfs4_save_creds(&original_cred);
193 status = mnt_want_write_file(nn->rec_file);
197 dir = nn->rec_file->f_path.dentry;
198 /* lock the parent */
199 mutex_lock(&dir->d_inode->i_mutex);
201 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
202 if (IS_ERR(dentry)) {
203 status = PTR_ERR(dentry);
208 * In the 4.1 case, where we're called from
209 * reclaim_complete(), records from the previous reboot
210 * may still be left, so this is OK.
212 * In the 4.0 case, we should never get here; but we may
213 * as well be forgiving and just succeed silently.
216 status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU);
220 mutex_unlock(&dir->d_inode->i_mutex);
223 crp = nfs4_client_to_reclaim(dname, nn);
227 vfs_fsync(nn->rec_file, 0);
229 printk(KERN_ERR "NFSD: failed to write recovery record"
230 " (err %d); please check that %s exists"
231 " and is writeable", status,
232 user_recovery_dirname);
234 mnt_drop_write_file(nn->rec_file);
235 nfs4_reset_creds(original_cred);
238 typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *);
241 char name[HEXDIR_LEN];
242 struct list_head list;
246 nfsd4_build_namelist(void *arg, const char *name, int namlen,
247 loff_t offset, u64 ino, unsigned int d_type)
249 struct list_head *names = arg;
250 struct name_list *entry;
252 if (namlen != HEXDIR_LEN - 1)
254 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
257 memcpy(entry->name, name, HEXDIR_LEN - 1);
258 entry->name[HEXDIR_LEN - 1] = '\0';
259 list_add(&entry->list, names);
264 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
266 const struct cred *original_cred;
267 struct dentry *dir = nn->rec_file->f_path.dentry;
271 status = nfs4_save_creds(&original_cred);
275 status = vfs_llseek(nn->rec_file, 0, SEEK_SET);
277 nfs4_reset_creds(original_cred);
281 status = vfs_readdir(nn->rec_file, nfsd4_build_namelist, &names);
282 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
283 while (!list_empty(&names)) {
284 struct name_list *entry;
285 entry = list_entry(names.next, struct name_list, list);
287 struct dentry *dentry;
288 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
289 if (IS_ERR(dentry)) {
290 status = PTR_ERR(dentry);
293 status = f(dir, dentry, nn);
296 list_del(&entry->list);
299 mutex_unlock(&dir->d_inode->i_mutex);
300 nfs4_reset_creds(original_cred);
305 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
307 struct dentry *dir, *dentry;
310 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
312 dir = nn->rec_file->f_path.dentry;
313 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
314 dentry = lookup_one_len(name, dir, namlen);
315 if (IS_ERR(dentry)) {
316 status = PTR_ERR(dentry);
320 if (!dentry->d_inode)
322 status = vfs_rmdir(dir->d_inode, dentry);
326 mutex_unlock(&dir->d_inode->i_mutex);
331 nfsd4_remove_clid_dir(struct nfs4_client *clp)
333 const struct cred *original_cred;
334 struct nfs4_client_reclaim *crp;
335 char dname[HEXDIR_LEN];
337 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
339 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
342 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
344 return legacy_recdir_name_error(status);
346 status = mnt_want_write_file(nn->rec_file);
349 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
351 status = nfs4_save_creds(&original_cred);
355 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn);
356 nfs4_reset_creds(original_cred);
358 vfs_fsync(nn->rec_file, 0);
360 /* remove reclaim record */
361 crp = nfsd4_find_reclaim_client(dname, nn);
363 nfs4_remove_reclaim_record(crp, nn);
367 mnt_drop_write_file(nn->rec_file);
370 printk("NFSD: Failed to remove expired client state directory"
371 " %.*s\n", HEXDIR_LEN, dname);
375 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
379 if (nfs4_has_reclaimed_state(child->d_name.name, nn))
382 status = vfs_rmdir(parent->d_inode, child);
384 printk("failed to remove client recovery directory %s\n",
386 /* Keep trying, success or failure: */
391 nfsd4_recdir_purge_old(struct nfsd_net *nn, time_t boot_time)
395 nn->in_grace = false;
398 status = mnt_want_write_file(nn->rec_file);
401 status = nfsd4_list_rec_dir(purge_old, nn);
403 vfs_fsync(nn->rec_file, 0);
404 mnt_drop_write_file(nn->rec_file);
406 nfs4_release_reclaim(nn);
408 printk("nfsd4: failed to purge old clients from recovery"
409 " directory %s\n", nn->rec_file->f_path.dentry->d_name.name);
413 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
415 if (child->d_name.len != HEXDIR_LEN - 1) {
416 printk("nfsd4: illegal name %s in recovery directory\n",
418 /* Keep trying; maybe the others are OK: */
421 nfs4_client_to_reclaim(child->d_name.name, nn);
426 nfsd4_recdir_load(struct net *net) {
428 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
433 status = nfsd4_list_rec_dir(load_recdir, nn);
435 printk("nfsd4: failed loading clients from recovery"
436 " directory %s\n", nn->rec_file->f_path.dentry->d_name.name);
441 * Hold reference to the recovery directory.
445 nfsd4_init_recdir(struct net *net)
447 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
448 const struct cred *original_cred;
451 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
452 user_recovery_dirname);
454 BUG_ON(nn->rec_file);
456 status = nfs4_save_creds(&original_cred);
458 printk("NFSD: Unable to change credentials to find recovery"
459 " directory: error %d\n",
464 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);
465 if (IS_ERR(nn->rec_file)) {
466 printk("NFSD: unable to find recovery directory %s\n",
467 user_recovery_dirname);
468 status = PTR_ERR(nn->rec_file);
472 nfs4_reset_creds(original_cred);
480 nfs4_legacy_state_init(struct net *net)
482 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
485 nn->reclaim_str_hashtbl = kmalloc(sizeof(struct list_head) *
486 CLIENT_HASH_SIZE, GFP_KERNEL);
487 if (!nn->reclaim_str_hashtbl)
490 for (i = 0; i < CLIENT_HASH_SIZE; i++)
491 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);
492 nn->reclaim_str_hashtbl_size = 0;
498 nfs4_legacy_state_shutdown(struct net *net)
500 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
502 kfree(nn->reclaim_str_hashtbl);
506 nfsd4_load_reboot_recovery_data(struct net *net)
510 status = nfsd4_init_recdir(net);
512 status = nfsd4_recdir_load(net);
514 printk(KERN_ERR "NFSD: Failure reading reboot recovery data\n");
519 nfsd4_legacy_tracking_init(struct net *net)
523 /* XXX: The legacy code won't work in a container */
524 if (net != &init_net) {
525 WARN(1, KERN_ERR "NFSD: attempt to initialize legacy client "
526 "tracking in a container!\n");
530 status = nfs4_legacy_state_init(net);
534 status = nfsd4_load_reboot_recovery_data(net);
540 nfs4_legacy_state_shutdown(net);
545 nfsd4_shutdown_recdir(struct nfsd_net *nn)
554 nfsd4_legacy_tracking_exit(struct net *net)
556 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
558 nfs4_release_reclaim(nn);
559 nfsd4_shutdown_recdir(nn);
560 nfs4_legacy_state_shutdown(net);
564 * Change the NFSv4 recovery directory to recdir.
567 nfs4_reset_recoverydir(char *recdir)
572 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
576 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
577 strcpy(user_recovery_dirname, recdir);
585 nfs4_recoverydir(void)
587 return user_recovery_dirname;
591 nfsd4_check_legacy_client(struct nfs4_client *clp)
594 char dname[HEXDIR_LEN];
595 struct nfs4_client_reclaim *crp;
596 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
598 /* did we already find that this client is stable? */
599 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
602 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
604 legacy_recdir_name_error(status);
608 /* look for it in the reclaim hashtable otherwise */
609 crp = nfsd4_find_reclaim_client(dname, nn);
611 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
619 static struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {
620 .init = nfsd4_legacy_tracking_init,
621 .exit = nfsd4_legacy_tracking_exit,
622 .create = nfsd4_create_clid_dir,
623 .remove = nfsd4_remove_clid_dir,
624 .check = nfsd4_check_legacy_client,
625 .grace_done = nfsd4_recdir_purge_old,
629 #define NFSD_PIPE_DIR "nfsd"
630 #define NFSD_CLD_PIPE "cld"
632 /* per-net-ns structure for holding cld upcall info */
634 struct rpc_pipe *cn_pipe;
636 struct list_head cn_list;
641 struct list_head cu_list;
642 struct cld_net *cu_net;
643 struct task_struct *cu_task;
644 struct cld_msg cu_msg;
648 __cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
651 struct rpc_pipe_msg msg;
653 memset(&msg, 0, sizeof(msg));
655 msg.len = sizeof(*cmsg);
658 * Set task state before we queue the upcall. That prevents
659 * wake_up_process in the downcall from racing with schedule.
661 set_current_state(TASK_UNINTERRUPTIBLE);
662 ret = rpc_queue_upcall(pipe, &msg);
664 set_current_state(TASK_RUNNING);
669 set_current_state(TASK_RUNNING);
678 cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
683 * -EAGAIN occurs when pipe is closed and reopened while there are
687 ret = __cld_pipe_upcall(pipe, cmsg);
688 } while (ret == -EAGAIN);
694 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
696 struct cld_upcall *tmp, *cup;
697 struct cld_msg __user *cmsg = (struct cld_msg __user *)src;
699 struct nfsd_net *nn = net_generic(filp->f_dentry->d_sb->s_fs_info,
701 struct cld_net *cn = nn->cld_net;
703 if (mlen != sizeof(*cmsg)) {
704 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen,
709 /* copy just the xid so we can try to find that */
710 if (copy_from_user(&xid, &cmsg->cm_xid, sizeof(xid)) != 0) {
711 dprintk("%s: error when copying xid from userspace", __func__);
715 /* walk the list and find corresponding xid */
717 spin_lock(&cn->cn_lock);
718 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
719 if (get_unaligned(&tmp->cu_msg.cm_xid) == xid) {
721 list_del_init(&cup->cu_list);
725 spin_unlock(&cn->cn_lock);
727 /* couldn't find upcall? */
729 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);
733 if (copy_from_user(&cup->cu_msg, src, mlen) != 0)
736 wake_up_process(cup->cu_task);
741 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)
743 struct cld_msg *cmsg = msg->data;
744 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,
747 /* errno >= 0 means we got a downcall */
751 wake_up_process(cup->cu_task);
754 static const struct rpc_pipe_ops cld_upcall_ops = {
755 .upcall = rpc_pipe_generic_upcall,
756 .downcall = cld_pipe_downcall,
757 .destroy_msg = cld_pipe_destroy_msg,
760 static struct dentry *
761 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)
763 struct dentry *dir, *dentry;
765 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);
767 return ERR_PTR(-ENOENT);
768 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);
774 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)
777 rpc_unlink(pipe->dentry);
780 static struct dentry *
781 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)
783 struct super_block *sb;
784 struct dentry *dentry;
786 sb = rpc_get_sb_net(net);
789 dentry = nfsd4_cld_register_sb(sb, pipe);
795 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)
797 struct super_block *sb;
799 sb = rpc_get_sb_net(net);
801 nfsd4_cld_unregister_sb(pipe);
806 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */
808 nfsd4_init_cld_pipe(struct net *net)
811 struct dentry *dentry;
812 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
818 cn = kzalloc(sizeof(*cn), GFP_KERNEL);
824 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
825 if (IS_ERR(cn->cn_pipe)) {
826 ret = PTR_ERR(cn->cn_pipe);
829 spin_lock_init(&cn->cn_lock);
830 INIT_LIST_HEAD(&cn->cn_list);
832 dentry = nfsd4_cld_register_net(net, cn->cn_pipe);
833 if (IS_ERR(dentry)) {
834 ret = PTR_ERR(dentry);
835 goto err_destroy_data;
838 cn->cn_pipe->dentry = dentry;
843 rpc_destroy_pipe_data(cn->cn_pipe);
846 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",
852 nfsd4_remove_cld_pipe(struct net *net)
854 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
855 struct cld_net *cn = nn->cld_net;
857 nfsd4_cld_unregister_net(net, cn->cn_pipe);
858 rpc_destroy_pipe_data(cn->cn_pipe);
863 static struct cld_upcall *
864 alloc_cld_upcall(struct cld_net *cn)
866 struct cld_upcall *new, *tmp;
868 new = kzalloc(sizeof(*new), GFP_KERNEL);
872 /* FIXME: hard cap on number in flight? */
874 spin_lock(&cn->cn_lock);
875 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
876 if (tmp->cu_msg.cm_xid == cn->cn_xid) {
878 spin_unlock(&cn->cn_lock);
882 new->cu_task = current;
883 new->cu_msg.cm_vers = CLD_UPCALL_VERSION;
884 put_unaligned(cn->cn_xid++, &new->cu_msg.cm_xid);
886 list_add(&new->cu_list, &cn->cn_list);
887 spin_unlock(&cn->cn_lock);
889 dprintk("%s: allocated xid %u\n", __func__, new->cu_msg.cm_xid);
895 free_cld_upcall(struct cld_upcall *victim)
897 struct cld_net *cn = victim->cu_net;
899 spin_lock(&cn->cn_lock);
900 list_del(&victim->cu_list);
901 spin_unlock(&cn->cn_lock);
905 /* Ask daemon to create a new record */
907 nfsd4_cld_create(struct nfs4_client *clp)
910 struct cld_upcall *cup;
911 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
912 struct cld_net *cn = nn->cld_net;
914 /* Don't upcall if it's already stored */
915 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
918 cup = alloc_cld_upcall(cn);
924 cup->cu_msg.cm_cmd = Cld_Create;
925 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
926 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
929 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
931 ret = cup->cu_msg.cm_status;
932 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
935 free_cld_upcall(cup);
938 printk(KERN_ERR "NFSD: Unable to create client "
939 "record on stable storage: %d\n", ret);
942 /* Ask daemon to create a new record */
944 nfsd4_cld_remove(struct nfs4_client *clp)
947 struct cld_upcall *cup;
948 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
949 struct cld_net *cn = nn->cld_net;
951 /* Don't upcall if it's already removed */
952 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
955 cup = alloc_cld_upcall(cn);
961 cup->cu_msg.cm_cmd = Cld_Remove;
962 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
963 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
966 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
968 ret = cup->cu_msg.cm_status;
969 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
972 free_cld_upcall(cup);
975 printk(KERN_ERR "NFSD: Unable to remove client "
976 "record from stable storage: %d\n", ret);
979 /* Check for presence of a record, and update its timestamp */
981 nfsd4_cld_check(struct nfs4_client *clp)
984 struct cld_upcall *cup;
985 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
986 struct cld_net *cn = nn->cld_net;
988 /* Don't upcall if one was already stored during this grace pd */
989 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
992 cup = alloc_cld_upcall(cn);
994 printk(KERN_ERR "NFSD: Unable to check client record on "
995 "stable storage: %d\n", -ENOMEM);
999 cup->cu_msg.cm_cmd = Cld_Check;
1000 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1001 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1004 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1006 ret = cup->cu_msg.cm_status;
1007 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1010 free_cld_upcall(cup);
1015 nfsd4_cld_grace_done(struct nfsd_net *nn, time_t boot_time)
1018 struct cld_upcall *cup;
1019 struct cld_net *cn = nn->cld_net;
1021 cup = alloc_cld_upcall(cn);
1027 cup->cu_msg.cm_cmd = Cld_GraceDone;
1028 cup->cu_msg.cm_u.cm_gracetime = (int64_t)boot_time;
1029 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1031 ret = cup->cu_msg.cm_status;
1033 free_cld_upcall(cup);
1036 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
1039 static struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {
1040 .init = nfsd4_init_cld_pipe,
1041 .exit = nfsd4_remove_cld_pipe,
1042 .create = nfsd4_cld_create,
1043 .remove = nfsd4_cld_remove,
1044 .check = nfsd4_cld_check,
1045 .grace_done = nfsd4_cld_grace_done,
1048 /* upcall via usermodehelper */
1049 static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";
1050 module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog),
1052 MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program");
1054 static bool cltrack_legacy_disable;
1055 module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR);
1056 MODULE_PARM_DESC(cltrack_legacy_disable,
1057 "Disable legacy recoverydir conversion. Default: false");
1059 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="
1060 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="
1063 nfsd4_cltrack_legacy_topdir(void)
1069 if (cltrack_legacy_disable)
1072 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) +
1073 strlen(nfs4_recoverydir()) + 1;
1075 result = kmalloc(len, GFP_KERNEL);
1079 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s",
1080 nfs4_recoverydir());
1081 if (copied >= len) {
1082 /* just return nothing if output was truncated */
1091 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name)
1097 if (cltrack_legacy_disable)
1100 /* +1 is for '/' between "topdir" and "recdir" */
1101 len = strlen(LEGACY_RECDIR_ENV_PREFIX) +
1102 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN;
1104 result = kmalloc(len, GFP_KERNEL);
1108 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/",
1109 nfs4_recoverydir());
1110 if (copied > (len - HEXDIR_LEN)) {
1111 /* just return nothing if output will be truncated */
1116 copied = nfs4_make_rec_clidname(result + copied, name);
1126 nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *legacy)
1132 if (unlikely(!cltrack_prog[0])) {
1133 dprintk("%s: cltrack_prog is disabled\n", __func__);
1137 dprintk("%s: cmd: %s\n", __func__, cmd);
1138 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)");
1139 dprintk("%s: legacy: %s\n", __func__, legacy ? legacy : "(null)");
1144 argv[0] = (char *)cltrack_prog;
1149 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1151 * Disable the upcall mechanism if we're getting an ENOENT or EACCES
1152 * error. The admin can re-enable it on the fly by using sysfs
1153 * once the problem has been fixed.
1155 if (ret == -ENOENT || ret == -EACCES) {
1156 dprintk("NFSD: %s was not found or isn't executable (%d). "
1157 "Setting cltrack_prog to blank string!",
1159 cltrack_prog[0] = '\0';
1161 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret);
1167 bin_to_hex_dup(const unsigned char *src, int srclen)
1172 /* +1 for terminating NULL */
1173 buf = kmalloc((srclen * 2) + 1, GFP_KERNEL);
1178 for (i = 0; i < srclen; i++) {
1179 sprintf(hex, "%2.2x", *src++);
1186 nfsd4_umh_cltrack_init(struct net __attribute__((unused)) *net)
1188 return nfsd4_umh_cltrack_upcall("init", NULL, NULL);
1192 nfsd4_umh_cltrack_create(struct nfs4_client *clp)
1196 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1198 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1201 nfsd4_umh_cltrack_upcall("create", hexid, NULL);
1206 nfsd4_umh_cltrack_remove(struct nfs4_client *clp)
1210 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1212 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1215 nfsd4_umh_cltrack_upcall("remove", hexid, NULL);
1220 nfsd4_umh_cltrack_check(struct nfs4_client *clp)
1223 char *hexid, *legacy;
1225 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1227 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1230 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name);
1231 ret = nfsd4_umh_cltrack_upcall("check", hexid, legacy);
1238 nfsd4_umh_cltrack_grace_done(struct nfsd_net __attribute__((unused)) *nn,
1242 char timestr[22]; /* FIXME: better way to determine max size? */
1244 sprintf(timestr, "%ld", boot_time);
1245 legacy = nfsd4_cltrack_legacy_topdir();
1246 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy);
1250 static struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = {
1251 .init = nfsd4_umh_cltrack_init,
1253 .create = nfsd4_umh_cltrack_create,
1254 .remove = nfsd4_umh_cltrack_remove,
1255 .check = nfsd4_umh_cltrack_check,
1256 .grace_done = nfsd4_umh_cltrack_grace_done,
1260 nfsd4_client_tracking_init(struct net *net)
1264 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1266 /* just run the init if it the method is already decided */
1267 if (nn->client_tracking_ops)
1271 * First, try a UMH upcall. It should succeed or fail quickly, so
1272 * there's little harm in trying that first.
1274 nn->client_tracking_ops = &nfsd4_umh_tracking_ops;
1275 status = nn->client_tracking_ops->init(net);
1280 * See if the recoverydir exists and is a directory. If it is,
1281 * then use the legacy ops.
1283 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops;
1284 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);
1286 status = S_ISDIR(path.dentry->d_inode->i_mode);
1292 /* Finally, try to use nfsdcld */
1293 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;
1294 printk(KERN_WARNING "NFSD: the nfsdcld client tracking upcall will be "
1295 "removed in 3.10. Please transition to using "
1298 status = nn->client_tracking_ops->init(net);
1300 printk(KERN_WARNING "NFSD: Unable to initialize client "
1301 "recovery tracking! (%d)\n", status);
1302 nn->client_tracking_ops = NULL;
1308 nfsd4_client_tracking_exit(struct net *net)
1310 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1312 if (nn->client_tracking_ops) {
1313 if (nn->client_tracking_ops->exit)
1314 nn->client_tracking_ops->exit(net);
1315 nn->client_tracking_ops = NULL;
1320 nfsd4_client_record_create(struct nfs4_client *clp)
1322 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1324 if (nn->client_tracking_ops)
1325 nn->client_tracking_ops->create(clp);
1329 nfsd4_client_record_remove(struct nfs4_client *clp)
1331 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1333 if (nn->client_tracking_ops)
1334 nn->client_tracking_ops->remove(clp);
1338 nfsd4_client_record_check(struct nfs4_client *clp)
1340 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1342 if (nn->client_tracking_ops)
1343 return nn->client_tracking_ops->check(clp);
1349 nfsd4_record_grace_done(struct nfsd_net *nn, time_t boot_time)
1351 if (nn->client_tracking_ops)
1352 nn->client_tracking_ops->grace_done(nn, boot_time);
1356 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)
1358 struct super_block *sb = ptr;
1359 struct net *net = sb->s_fs_info;
1360 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1361 struct cld_net *cn = nn->cld_net;
1362 struct dentry *dentry;
1365 if (!try_module_get(THIS_MODULE))
1369 module_put(THIS_MODULE);
1374 case RPC_PIPEFS_MOUNT:
1375 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);
1376 if (IS_ERR(dentry)) {
1377 ret = PTR_ERR(dentry);
1380 cn->cn_pipe->dentry = dentry;
1382 case RPC_PIPEFS_UMOUNT:
1383 if (cn->cn_pipe->dentry)
1384 nfsd4_cld_unregister_sb(cn->cn_pipe);
1390 module_put(THIS_MODULE);
1394 static struct notifier_block nfsd4_cld_block = {
1395 .notifier_call = rpc_pipefs_event,
1399 register_cld_notifier(void)
1401 return rpc_pipefs_notifier_register(&nfsd4_cld_block);
1405 unregister_cld_notifier(void)
1407 rpc_pipefs_notifier_unregister(&nfsd4_cld_block);