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 *);
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();
76 new->fsuid = GLOBAL_ROOT_UID;
77 new->fsgid = GLOBAL_ROOT_GID;
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(struct nfs4_client *clp, 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");
162 nfsd4_client_tracking_exit(clp->net);
167 nfsd4_create_clid_dir(struct nfs4_client *clp)
169 const struct cred *original_cred;
170 char dname[HEXDIR_LEN];
171 struct dentry *dir, *dentry;
172 struct nfs4_client_reclaim *crp;
174 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
176 if (test_and_set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
181 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
183 return legacy_recdir_name_error(clp, status);
185 status = nfs4_save_creds(&original_cred);
189 status = mnt_want_write_file(nn->rec_file);
193 dir = nn->rec_file->f_path.dentry;
194 /* lock the parent */
195 mutex_lock(&d_inode(dir)->i_mutex);
197 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1);
198 if (IS_ERR(dentry)) {
199 status = PTR_ERR(dentry);
202 if (d_really_is_positive(dentry))
204 * In the 4.1 case, where we're called from
205 * reclaim_complete(), records from the previous reboot
206 * may still be left, so this is OK.
208 * In the 4.0 case, we should never get here; but we may
209 * as well be forgiving and just succeed silently.
212 status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU);
216 mutex_unlock(&d_inode(dir)->i_mutex);
219 crp = nfs4_client_to_reclaim(dname, nn);
223 vfs_fsync(nn->rec_file, 0);
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);
230 mnt_drop_write_file(nn->rec_file);
232 nfs4_reset_creds(original_cred);
235 typedef int (recdir_func)(struct dentry *, struct dentry *, struct nfsd_net *);
238 char name[HEXDIR_LEN];
239 struct list_head list;
242 struct nfs4_dir_ctx {
243 struct dir_context ctx;
244 struct list_head names;
248 nfsd4_build_namelist(struct dir_context *__ctx, const char *name, int namlen,
249 loff_t offset, u64 ino, unsigned int d_type)
251 struct nfs4_dir_ctx *ctx =
252 container_of(__ctx, struct nfs4_dir_ctx, ctx);
253 struct name_list *entry;
255 if (namlen != HEXDIR_LEN - 1)
257 entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
260 memcpy(entry->name, name, HEXDIR_LEN - 1);
261 entry->name[HEXDIR_LEN - 1] = '\0';
262 list_add(&entry->list, &ctx->names);
267 nfsd4_list_rec_dir(recdir_func *f, struct nfsd_net *nn)
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)
275 struct name_list *entry, *tmp;
278 status = nfs4_save_creds(&original_cred);
282 status = vfs_llseek(nn->rec_file, 0, SEEK_SET);
284 nfs4_reset_creds(original_cred);
288 status = iterate_dir(nn->rec_file, &ctx.ctx);
289 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
291 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
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);
299 status = f(dir, dentry, nn);
302 list_del(&entry->list);
305 mutex_unlock(&d_inode(dir)->i_mutex);
306 nfs4_reset_creds(original_cred);
308 list_for_each_entry_safe(entry, tmp, &ctx.names, list) {
309 dprintk("NFSD: %s. Left entry %s\n", __func__, entry->name);
310 list_del(&entry->list);
317 nfsd4_unlink_clid_dir(char *name, int namlen, struct nfsd_net *nn)
319 struct dentry *dir, *dentry;
322 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
324 dir = nn->rec_file->f_path.dentry;
325 mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT);
326 dentry = lookup_one_len(name, dir, namlen);
327 if (IS_ERR(dentry)) {
328 status = PTR_ERR(dentry);
332 if (d_really_is_negative(dentry))
334 status = vfs_rmdir(d_inode(dir), dentry);
338 mutex_unlock(&d_inode(dir)->i_mutex);
343 nfsd4_remove_clid_dir(struct nfs4_client *clp)
345 const struct cred *original_cred;
346 struct nfs4_client_reclaim *crp;
347 char dname[HEXDIR_LEN];
349 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
351 if (!nn->rec_file || !test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
354 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
356 return legacy_recdir_name_error(clp, status);
358 status = mnt_want_write_file(nn->rec_file);
361 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
363 status = nfs4_save_creds(&original_cred);
367 status = nfsd4_unlink_clid_dir(dname, HEXDIR_LEN-1, nn);
368 nfs4_reset_creds(original_cred);
370 vfs_fsync(nn->rec_file, 0);
372 /* remove reclaim record */
373 crp = nfsd4_find_reclaim_client(dname, nn);
375 nfs4_remove_reclaim_record(crp, nn);
379 mnt_drop_write_file(nn->rec_file);
382 printk("NFSD: Failed to remove expired client state directory"
383 " %.*s\n", HEXDIR_LEN, dname);
387 purge_old(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
391 if (nfs4_has_reclaimed_state(child->d_name.name, nn))
394 status = vfs_rmdir(d_inode(parent), child);
396 printk("failed to remove client recovery directory %pd\n",
398 /* Keep trying, success or failure: */
403 nfsd4_recdir_purge_old(struct nfsd_net *nn)
407 nn->in_grace = false;
410 status = mnt_want_write_file(nn->rec_file);
413 status = nfsd4_list_rec_dir(purge_old, nn);
415 vfs_fsync(nn->rec_file, 0);
416 mnt_drop_write_file(nn->rec_file);
418 nfs4_release_reclaim(nn);
420 printk("nfsd4: failed to purge old clients from recovery"
421 " directory %pD\n", nn->rec_file);
425 load_recdir(struct dentry *parent, struct dentry *child, struct nfsd_net *nn)
427 if (child->d_name.len != HEXDIR_LEN - 1) {
428 printk("nfsd4: illegal name %pd in recovery directory\n",
430 /* Keep trying; maybe the others are OK: */
433 nfs4_client_to_reclaim(child->d_name.name, nn);
438 nfsd4_recdir_load(struct net *net) {
440 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
445 status = nfsd4_list_rec_dir(load_recdir, nn);
447 printk("nfsd4: failed loading clients from recovery"
448 " directory %pD\n", nn->rec_file);
453 * Hold reference to the recovery directory.
457 nfsd4_init_recdir(struct net *net)
459 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
460 const struct cred *original_cred;
463 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
464 user_recovery_dirname);
466 BUG_ON(nn->rec_file);
468 status = nfs4_save_creds(&original_cred);
470 printk("NFSD: Unable to change credentials to find recovery"
471 " directory: error %d\n",
476 nn->rec_file = filp_open(user_recovery_dirname, O_RDONLY | O_DIRECTORY, 0);
477 if (IS_ERR(nn->rec_file)) {
478 printk("NFSD: unable to find recovery directory %s\n",
479 user_recovery_dirname);
480 status = PTR_ERR(nn->rec_file);
484 nfs4_reset_creds(original_cred);
491 nfsd4_shutdown_recdir(struct net *net)
493 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
502 nfs4_legacy_state_init(struct net *net)
504 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
507 nn->reclaim_str_hashtbl = kmalloc(sizeof(struct list_head) *
508 CLIENT_HASH_SIZE, GFP_KERNEL);
509 if (!nn->reclaim_str_hashtbl)
512 for (i = 0; i < CLIENT_HASH_SIZE; i++)
513 INIT_LIST_HEAD(&nn->reclaim_str_hashtbl[i]);
514 nn->reclaim_str_hashtbl_size = 0;
520 nfs4_legacy_state_shutdown(struct net *net)
522 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
524 kfree(nn->reclaim_str_hashtbl);
528 nfsd4_load_reboot_recovery_data(struct net *net)
532 status = nfsd4_init_recdir(net);
536 status = nfsd4_recdir_load(net);
538 nfsd4_shutdown_recdir(net);
544 nfsd4_legacy_tracking_init(struct net *net)
548 /* XXX: The legacy code won't work in a container */
549 if (net != &init_net) {
550 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n");
554 status = nfs4_legacy_state_init(net);
558 status = nfsd4_load_reboot_recovery_data(net);
564 nfs4_legacy_state_shutdown(net);
569 nfsd4_legacy_tracking_exit(struct net *net)
571 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
573 nfs4_release_reclaim(nn);
574 nfsd4_shutdown_recdir(net);
575 nfs4_legacy_state_shutdown(net);
579 * Change the NFSv4 recovery directory to recdir.
582 nfs4_reset_recoverydir(char *recdir)
587 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
591 if (d_is_dir(path.dentry)) {
592 strcpy(user_recovery_dirname, recdir);
600 nfs4_recoverydir(void)
602 return user_recovery_dirname;
606 nfsd4_check_legacy_client(struct nfs4_client *clp)
609 char dname[HEXDIR_LEN];
610 struct nfs4_client_reclaim *crp;
611 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
613 /* did we already find that this client is stable? */
614 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
617 status = nfs4_make_rec_clidname(dname, &clp->cl_name);
619 legacy_recdir_name_error(clp, status);
623 /* look for it in the reclaim hashtable otherwise */
624 crp = nfsd4_find_reclaim_client(dname, nn);
626 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
634 static struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops = {
635 .init = nfsd4_legacy_tracking_init,
636 .exit = nfsd4_legacy_tracking_exit,
637 .create = nfsd4_create_clid_dir,
638 .remove = nfsd4_remove_clid_dir,
639 .check = nfsd4_check_legacy_client,
640 .grace_done = nfsd4_recdir_purge_old,
644 #define NFSD_PIPE_DIR "nfsd"
645 #define NFSD_CLD_PIPE "cld"
647 /* per-net-ns structure for holding cld upcall info */
649 struct rpc_pipe *cn_pipe;
651 struct list_head cn_list;
656 struct list_head cu_list;
657 struct cld_net *cu_net;
658 struct task_struct *cu_task;
659 struct cld_msg cu_msg;
663 __cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
666 struct rpc_pipe_msg msg;
668 memset(&msg, 0, sizeof(msg));
670 msg.len = sizeof(*cmsg);
673 * Set task state before we queue the upcall. That prevents
674 * wake_up_process in the downcall from racing with schedule.
676 set_current_state(TASK_UNINTERRUPTIBLE);
677 ret = rpc_queue_upcall(pipe, &msg);
679 set_current_state(TASK_RUNNING);
692 cld_pipe_upcall(struct rpc_pipe *pipe, struct cld_msg *cmsg)
697 * -EAGAIN occurs when pipe is closed and reopened while there are
701 ret = __cld_pipe_upcall(pipe, cmsg);
702 } while (ret == -EAGAIN);
708 cld_pipe_downcall(struct file *filp, const char __user *src, size_t mlen)
710 struct cld_upcall *tmp, *cup;
711 struct cld_msg __user *cmsg = (struct cld_msg __user *)src;
713 struct nfsd_net *nn = net_generic(file_inode(filp)->i_sb->s_fs_info,
715 struct cld_net *cn = nn->cld_net;
717 if (mlen != sizeof(*cmsg)) {
718 dprintk("%s: got %zu bytes, expected %zu\n", __func__, mlen,
723 /* copy just the xid so we can try to find that */
724 if (copy_from_user(&xid, &cmsg->cm_xid, sizeof(xid)) != 0) {
725 dprintk("%s: error when copying xid from userspace", __func__);
729 /* walk the list and find corresponding xid */
731 spin_lock(&cn->cn_lock);
732 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
733 if (get_unaligned(&tmp->cu_msg.cm_xid) == xid) {
735 list_del_init(&cup->cu_list);
739 spin_unlock(&cn->cn_lock);
741 /* couldn't find upcall? */
743 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__, xid);
747 if (copy_from_user(&cup->cu_msg, src, mlen) != 0)
750 wake_up_process(cup->cu_task);
755 cld_pipe_destroy_msg(struct rpc_pipe_msg *msg)
757 struct cld_msg *cmsg = msg->data;
758 struct cld_upcall *cup = container_of(cmsg, struct cld_upcall,
761 /* errno >= 0 means we got a downcall */
765 wake_up_process(cup->cu_task);
768 static const struct rpc_pipe_ops cld_upcall_ops = {
769 .upcall = rpc_pipe_generic_upcall,
770 .downcall = cld_pipe_downcall,
771 .destroy_msg = cld_pipe_destroy_msg,
774 static struct dentry *
775 nfsd4_cld_register_sb(struct super_block *sb, struct rpc_pipe *pipe)
777 struct dentry *dir, *dentry;
779 dir = rpc_d_lookup_sb(sb, NFSD_PIPE_DIR);
781 return ERR_PTR(-ENOENT);
782 dentry = rpc_mkpipe_dentry(dir, NFSD_CLD_PIPE, NULL, pipe);
788 nfsd4_cld_unregister_sb(struct rpc_pipe *pipe)
791 rpc_unlink(pipe->dentry);
794 static struct dentry *
795 nfsd4_cld_register_net(struct net *net, struct rpc_pipe *pipe)
797 struct super_block *sb;
798 struct dentry *dentry;
800 sb = rpc_get_sb_net(net);
803 dentry = nfsd4_cld_register_sb(sb, pipe);
809 nfsd4_cld_unregister_net(struct net *net, struct rpc_pipe *pipe)
811 struct super_block *sb;
813 sb = rpc_get_sb_net(net);
815 nfsd4_cld_unregister_sb(pipe);
820 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */
822 nfsd4_init_cld_pipe(struct net *net)
825 struct dentry *dentry;
826 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
832 cn = kzalloc(sizeof(*cn), GFP_KERNEL);
838 cn->cn_pipe = rpc_mkpipe_data(&cld_upcall_ops, RPC_PIPE_WAIT_FOR_OPEN);
839 if (IS_ERR(cn->cn_pipe)) {
840 ret = PTR_ERR(cn->cn_pipe);
843 spin_lock_init(&cn->cn_lock);
844 INIT_LIST_HEAD(&cn->cn_list);
846 dentry = nfsd4_cld_register_net(net, cn->cn_pipe);
847 if (IS_ERR(dentry)) {
848 ret = PTR_ERR(dentry);
849 goto err_destroy_data;
852 cn->cn_pipe->dentry = dentry;
857 rpc_destroy_pipe_data(cn->cn_pipe);
860 printk(KERN_ERR "NFSD: unable to create nfsdcld upcall pipe (%d)\n",
866 nfsd4_remove_cld_pipe(struct net *net)
868 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
869 struct cld_net *cn = nn->cld_net;
871 nfsd4_cld_unregister_net(net, cn->cn_pipe);
872 rpc_destroy_pipe_data(cn->cn_pipe);
877 static struct cld_upcall *
878 alloc_cld_upcall(struct cld_net *cn)
880 struct cld_upcall *new, *tmp;
882 new = kzalloc(sizeof(*new), GFP_KERNEL);
886 /* FIXME: hard cap on number in flight? */
888 spin_lock(&cn->cn_lock);
889 list_for_each_entry(tmp, &cn->cn_list, cu_list) {
890 if (tmp->cu_msg.cm_xid == cn->cn_xid) {
892 spin_unlock(&cn->cn_lock);
896 new->cu_task = current;
897 new->cu_msg.cm_vers = CLD_UPCALL_VERSION;
898 put_unaligned(cn->cn_xid++, &new->cu_msg.cm_xid);
900 list_add(&new->cu_list, &cn->cn_list);
901 spin_unlock(&cn->cn_lock);
903 dprintk("%s: allocated xid %u\n", __func__, new->cu_msg.cm_xid);
909 free_cld_upcall(struct cld_upcall *victim)
911 struct cld_net *cn = victim->cu_net;
913 spin_lock(&cn->cn_lock);
914 list_del(&victim->cu_list);
915 spin_unlock(&cn->cn_lock);
919 /* Ask daemon to create a new record */
921 nfsd4_cld_create(struct nfs4_client *clp)
924 struct cld_upcall *cup;
925 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
926 struct cld_net *cn = nn->cld_net;
928 /* Don't upcall if it's already stored */
929 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
932 cup = alloc_cld_upcall(cn);
938 cup->cu_msg.cm_cmd = Cld_Create;
939 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
940 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
943 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
945 ret = cup->cu_msg.cm_status;
946 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
949 free_cld_upcall(cup);
952 printk(KERN_ERR "NFSD: Unable to create client "
953 "record on stable storage: %d\n", ret);
956 /* Ask daemon to create a new record */
958 nfsd4_cld_remove(struct nfs4_client *clp)
961 struct cld_upcall *cup;
962 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
963 struct cld_net *cn = nn->cld_net;
965 /* Don't upcall if it's already removed */
966 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
969 cup = alloc_cld_upcall(cn);
975 cup->cu_msg.cm_cmd = Cld_Remove;
976 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
977 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
980 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
982 ret = cup->cu_msg.cm_status;
983 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
986 free_cld_upcall(cup);
989 printk(KERN_ERR "NFSD: Unable to remove client "
990 "record from stable storage: %d\n", ret);
993 /* Check for presence of a record, and update its timestamp */
995 nfsd4_cld_check(struct nfs4_client *clp)
998 struct cld_upcall *cup;
999 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1000 struct cld_net *cn = nn->cld_net;
1002 /* Don't upcall if one was already stored during this grace pd */
1003 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1006 cup = alloc_cld_upcall(cn);
1008 printk(KERN_ERR "NFSD: Unable to check client record on "
1009 "stable storage: %d\n", -ENOMEM);
1013 cup->cu_msg.cm_cmd = Cld_Check;
1014 cup->cu_msg.cm_u.cm_name.cn_len = clp->cl_name.len;
1015 memcpy(cup->cu_msg.cm_u.cm_name.cn_id, clp->cl_name.data,
1018 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1020 ret = cup->cu_msg.cm_status;
1021 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1024 free_cld_upcall(cup);
1029 nfsd4_cld_grace_done(struct nfsd_net *nn)
1032 struct cld_upcall *cup;
1033 struct cld_net *cn = nn->cld_net;
1035 cup = alloc_cld_upcall(cn);
1041 cup->cu_msg.cm_cmd = Cld_GraceDone;
1042 cup->cu_msg.cm_u.cm_gracetime = (int64_t)nn->boot_time;
1043 ret = cld_pipe_upcall(cn->cn_pipe, &cup->cu_msg);
1045 ret = cup->cu_msg.cm_status;
1047 free_cld_upcall(cup);
1050 printk(KERN_ERR "NFSD: Unable to end grace period: %d\n", ret);
1053 static struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops = {
1054 .init = nfsd4_init_cld_pipe,
1055 .exit = nfsd4_remove_cld_pipe,
1056 .create = nfsd4_cld_create,
1057 .remove = nfsd4_cld_remove,
1058 .check = nfsd4_cld_check,
1059 .grace_done = nfsd4_cld_grace_done,
1062 /* upcall via usermodehelper */
1063 static char cltrack_prog[PATH_MAX] = "/sbin/nfsdcltrack";
1064 module_param_string(cltrack_prog, cltrack_prog, sizeof(cltrack_prog),
1066 MODULE_PARM_DESC(cltrack_prog, "Path to the nfsdcltrack upcall program");
1068 static bool cltrack_legacy_disable;
1069 module_param(cltrack_legacy_disable, bool, S_IRUGO|S_IWUSR);
1070 MODULE_PARM_DESC(cltrack_legacy_disable,
1071 "Disable legacy recoverydir conversion. Default: false");
1073 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="
1074 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="
1075 #define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION="
1076 #define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START="
1079 nfsd4_cltrack_legacy_topdir(void)
1085 if (cltrack_legacy_disable)
1088 len = strlen(LEGACY_TOPDIR_ENV_PREFIX) +
1089 strlen(nfs4_recoverydir()) + 1;
1091 result = kmalloc(len, GFP_KERNEL);
1095 copied = snprintf(result, len, LEGACY_TOPDIR_ENV_PREFIX "%s",
1096 nfs4_recoverydir());
1097 if (copied >= len) {
1098 /* just return nothing if output was truncated */
1107 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj *name)
1113 if (cltrack_legacy_disable)
1116 /* +1 is for '/' between "topdir" and "recdir" */
1117 len = strlen(LEGACY_RECDIR_ENV_PREFIX) +
1118 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN;
1120 result = kmalloc(len, GFP_KERNEL);
1124 copied = snprintf(result, len, LEGACY_RECDIR_ENV_PREFIX "%s/",
1125 nfs4_recoverydir());
1126 if (copied > (len - HEXDIR_LEN)) {
1127 /* just return nothing if output will be truncated */
1132 copied = nfs4_make_rec_clidname(result + copied, name);
1142 nfsd4_cltrack_client_has_session(struct nfs4_client *clp)
1148 /* prefix + Y/N character + terminating NULL */
1149 len = strlen(HAS_SESSION_ENV_PREFIX) + 1 + 1;
1151 result = kmalloc(len, GFP_KERNEL);
1155 copied = snprintf(result, len, HAS_SESSION_ENV_PREFIX "%c",
1156 clp->cl_minorversion ? 'Y' : 'N');
1157 if (copied >= len) {
1158 /* just return nothing if output was truncated */
1167 nfsd4_cltrack_grace_start(time_t grace_start)
1173 /* prefix + max width of int64_t string + terminating NULL */
1174 len = strlen(GRACE_START_ENV_PREFIX) + 22 + 1;
1176 result = kmalloc(len, GFP_KERNEL);
1180 copied = snprintf(result, len, GRACE_START_ENV_PREFIX "%ld",
1182 if (copied >= len) {
1183 /* just return nothing if output was truncated */
1192 nfsd4_umh_cltrack_upcall(char *cmd, char *arg, char *env0, char *env1)
1198 if (unlikely(!cltrack_prog[0])) {
1199 dprintk("%s: cltrack_prog is disabled\n", __func__);
1203 dprintk("%s: cmd: %s\n", __func__, cmd);
1204 dprintk("%s: arg: %s\n", __func__, arg ? arg : "(null)");
1205 dprintk("%s: env0: %s\n", __func__, env0 ? env0 : "(null)");
1206 dprintk("%s: env1: %s\n", __func__, env1 ? env1 : "(null)");
1212 argv[0] = (char *)cltrack_prog;
1217 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
1219 * Disable the upcall mechanism if we're getting an ENOENT or EACCES
1220 * error. The admin can re-enable it on the fly by using sysfs
1221 * once the problem has been fixed.
1223 if (ret == -ENOENT || ret == -EACCES) {
1224 dprintk("NFSD: %s was not found or isn't executable (%d). "
1225 "Setting cltrack_prog to blank string!",
1227 cltrack_prog[0] = '\0';
1229 dprintk("%s: %s return value: %d\n", __func__, cltrack_prog, ret);
1235 bin_to_hex_dup(const unsigned char *src, int srclen)
1240 /* +1 for terminating NULL */
1241 buf = kmalloc((srclen * 2) + 1, GFP_KERNEL);
1246 for (i = 0; i < srclen; i++) {
1247 sprintf(hex, "%2.2x", *src++);
1254 nfsd4_umh_cltrack_init(struct net *net)
1257 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1258 char *grace_start = nfsd4_cltrack_grace_start(nn->boot_time);
1260 /* XXX: The usermode helper s not working in container yet. */
1261 if (net != &init_net) {
1262 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n");
1266 ret = nfsd4_umh_cltrack_upcall("init", NULL, grace_start, NULL);
1272 nfsd4_cltrack_upcall_lock(struct nfs4_client *clp)
1274 wait_on_bit_lock(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK,
1275 TASK_UNINTERRUPTIBLE);
1279 nfsd4_cltrack_upcall_unlock(struct nfs4_client *clp)
1281 smp_mb__before_atomic();
1282 clear_bit(NFSD4_CLIENT_UPCALL_LOCK, &clp->cl_flags);
1283 smp_mb__after_atomic();
1284 wake_up_bit(&clp->cl_flags, NFSD4_CLIENT_UPCALL_LOCK);
1288 nfsd4_umh_cltrack_create(struct nfs4_client *clp)
1290 char *hexid, *has_session, *grace_start;
1291 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1294 * With v4.0 clients, there's little difference in outcome between a
1295 * create and check operation, and we can end up calling into this
1296 * function multiple times per client (once for each openowner). So,
1297 * for v4.0 clients skip upcalling once the client has been recorded
1298 * on stable storage.
1300 * For v4.1+ clients, the outcome of the two operations is different,
1301 * so we must ensure that we upcall for the create operation. v4.1+
1302 * clients call this on RECLAIM_COMPLETE though, so we should only end
1303 * up doing a single create upcall per client.
1305 if (clp->cl_minorversion == 0 &&
1306 test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1309 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1311 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1315 has_session = nfsd4_cltrack_client_has_session(clp);
1316 grace_start = nfsd4_cltrack_grace_start(nn->boot_time);
1318 nfsd4_cltrack_upcall_lock(clp);
1319 if (!nfsd4_umh_cltrack_upcall("create", hexid, has_session, grace_start))
1320 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1321 nfsd4_cltrack_upcall_unlock(clp);
1329 nfsd4_umh_cltrack_remove(struct nfs4_client *clp)
1333 if (!test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1336 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1338 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1342 nfsd4_cltrack_upcall_lock(clp);
1343 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags) &&
1344 nfsd4_umh_cltrack_upcall("remove", hexid, NULL, NULL) == 0)
1345 clear_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1346 nfsd4_cltrack_upcall_unlock(clp);
1352 nfsd4_umh_cltrack_check(struct nfs4_client *clp)
1355 char *hexid, *has_session, *legacy;
1357 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags))
1360 hexid = bin_to_hex_dup(clp->cl_name.data, clp->cl_name.len);
1362 dprintk("%s: can't allocate memory for upcall!\n", __func__);
1366 has_session = nfsd4_cltrack_client_has_session(clp);
1367 legacy = nfsd4_cltrack_legacy_recdir(&clp->cl_name);
1369 nfsd4_cltrack_upcall_lock(clp);
1370 if (test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags)) {
1373 ret = nfsd4_umh_cltrack_upcall("check", hexid, has_session, legacy);
1375 set_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
1377 nfsd4_cltrack_upcall_unlock(clp);
1386 nfsd4_umh_cltrack_grace_done(struct nfsd_net *nn)
1389 char timestr[22]; /* FIXME: better way to determine max size? */
1391 sprintf(timestr, "%ld", nn->boot_time);
1392 legacy = nfsd4_cltrack_legacy_topdir();
1393 nfsd4_umh_cltrack_upcall("gracedone", timestr, legacy, NULL);
1397 static struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops = {
1398 .init = nfsd4_umh_cltrack_init,
1400 .create = nfsd4_umh_cltrack_create,
1401 .remove = nfsd4_umh_cltrack_remove,
1402 .check = nfsd4_umh_cltrack_check,
1403 .grace_done = nfsd4_umh_cltrack_grace_done,
1407 nfsd4_client_tracking_init(struct net *net)
1411 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1413 /* just run the init if it the method is already decided */
1414 if (nn->client_tracking_ops)
1418 * First, try a UMH upcall. It should succeed or fail quickly, so
1419 * there's little harm in trying that first.
1421 nn->client_tracking_ops = &nfsd4_umh_tracking_ops;
1422 status = nn->client_tracking_ops->init(net);
1427 * See if the recoverydir exists and is a directory. If it is,
1428 * then use the legacy ops.
1430 nn->client_tracking_ops = &nfsd4_legacy_tracking_ops;
1431 status = kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW, &path);
1433 status = d_is_dir(path.dentry);
1439 /* Finally, try to use nfsdcld */
1440 nn->client_tracking_ops = &nfsd4_cld_tracking_ops;
1441 printk(KERN_WARNING "NFSD: the nfsdcld client tracking upcall will be "
1442 "removed in 3.10. Please transition to using "
1445 status = nn->client_tracking_ops->init(net);
1447 printk(KERN_WARNING "NFSD: Unable to initialize client "
1448 "recovery tracking! (%d)\n", status);
1449 nn->client_tracking_ops = NULL;
1455 nfsd4_client_tracking_exit(struct net *net)
1457 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1459 if (nn->client_tracking_ops) {
1460 if (nn->client_tracking_ops->exit)
1461 nn->client_tracking_ops->exit(net);
1462 nn->client_tracking_ops = NULL;
1467 nfsd4_client_record_create(struct nfs4_client *clp)
1469 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1471 if (nn->client_tracking_ops)
1472 nn->client_tracking_ops->create(clp);
1476 nfsd4_client_record_remove(struct nfs4_client *clp)
1478 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1480 if (nn->client_tracking_ops)
1481 nn->client_tracking_ops->remove(clp);
1485 nfsd4_client_record_check(struct nfs4_client *clp)
1487 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1489 if (nn->client_tracking_ops)
1490 return nn->client_tracking_ops->check(clp);
1496 nfsd4_record_grace_done(struct nfsd_net *nn)
1498 if (nn->client_tracking_ops)
1499 nn->client_tracking_ops->grace_done(nn);
1503 rpc_pipefs_event(struct notifier_block *nb, unsigned long event, void *ptr)
1505 struct super_block *sb = ptr;
1506 struct net *net = sb->s_fs_info;
1507 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1508 struct cld_net *cn = nn->cld_net;
1509 struct dentry *dentry;
1512 if (!try_module_get(THIS_MODULE))
1516 module_put(THIS_MODULE);
1521 case RPC_PIPEFS_MOUNT:
1522 dentry = nfsd4_cld_register_sb(sb, cn->cn_pipe);
1523 if (IS_ERR(dentry)) {
1524 ret = PTR_ERR(dentry);
1527 cn->cn_pipe->dentry = dentry;
1529 case RPC_PIPEFS_UMOUNT:
1530 if (cn->cn_pipe->dentry)
1531 nfsd4_cld_unregister_sb(cn->cn_pipe);
1537 module_put(THIS_MODULE);
1541 static struct notifier_block nfsd4_cld_block = {
1542 .notifier_call = rpc_pipefs_event,
1546 register_cld_notifier(void)
1548 return rpc_pipefs_notifier_register(&nfsd4_cld_block);
1552 unregister_cld_notifier(void)
1554 rpc_pipefs_notifier_unregister(&nfsd4_cld_block);