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 <crypto/hash.h>
36 #include <linux/file.h>
37 #include <linux/slab.h>
38 #include <linux/namei.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 crypto_shash
*tfm
;
110 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
111 clname
->len
, clname
->data
);
112 tfm
= crypto_alloc_shash("md5", 0, 0);
114 status
= PTR_ERR(tfm
);
118 cksum
.len
= crypto_shash_digestsize(tfm
);
119 cksum
.data
= kmalloc(cksum
.len
, GFP_KERNEL
);
120 if (cksum
.data
== NULL
) {
126 SHASH_DESC_ON_STACK(desc
, tfm
);
130 status
= crypto_shash_digest(desc
, clname
->data
, clname
->len
,
132 shash_desc_zero(desc
);
138 md5_to_hex(dname
, cksum
.data
);
143 crypto_free_shash(tfm
);
149 * If we had an error generating the recdir name for the legacy tracker
150 * then warn the admin. If the error doesn't appear to be transient,
151 * then disable recovery tracking.
154 legacy_recdir_name_error(struct nfs4_client
*clp
, int error
)
156 printk(KERN_ERR
"NFSD: unable to generate recoverydir "
157 "name (%d).\n", error
);
160 * if the algorithm just doesn't exist, then disable the recovery
161 * tracker altogether. The crypto libs will generally return this if
162 * FIPS is enabled as well.
164 if (error
== -ENOENT
) {
165 printk(KERN_ERR
"NFSD: disabling legacy clientid tracking. "
166 "Reboot recovery will not function correctly!\n");
167 nfsd4_client_tracking_exit(clp
->net
);
172 nfsd4_create_clid_dir(struct nfs4_client
*clp
)
174 const struct cred
*original_cred
;
175 char dname
[HEXDIR_LEN
];
176 struct dentry
*dir
, *dentry
;
177 struct nfs4_client_reclaim
*crp
;
179 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
181 if (test_and_set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
186 status
= nfs4_make_rec_clidname(dname
, &clp
->cl_name
);
188 return legacy_recdir_name_error(clp
, status
);
190 status
= nfs4_save_creds(&original_cred
);
194 status
= mnt_want_write_file(nn
->rec_file
);
198 dir
= nn
->rec_file
->f_path
.dentry
;
199 /* lock the parent */
200 inode_lock(d_inode(dir
));
202 dentry
= lookup_one_len(dname
, dir
, HEXDIR_LEN
-1);
203 if (IS_ERR(dentry
)) {
204 status
= PTR_ERR(dentry
);
207 if (d_really_is_positive(dentry
))
209 * In the 4.1 case, where we're called from
210 * reclaim_complete(), records from the previous reboot
211 * may still be left, so this is OK.
213 * In the 4.0 case, we should never get here; but we may
214 * as well be forgiving and just succeed silently.
217 status
= vfs_mkdir(d_inode(dir
), dentry
, S_IRWXU
);
221 inode_unlock(d_inode(dir
));
224 crp
= nfs4_client_to_reclaim(dname
, nn
);
228 vfs_fsync(nn
->rec_file
, 0);
230 printk(KERN_ERR
"NFSD: failed to write recovery record"
231 " (err %d); please check that %s exists"
232 " and is writeable", status
,
233 user_recovery_dirname
);
235 mnt_drop_write_file(nn
->rec_file
);
237 nfs4_reset_creds(original_cred
);
240 typedef int (recdir_func
)(struct dentry
*, struct dentry
*, struct nfsd_net
*);
243 char name
[HEXDIR_LEN
];
244 struct list_head list
;
247 struct nfs4_dir_ctx
{
248 struct dir_context ctx
;
249 struct list_head names
;
253 nfsd4_build_namelist(struct dir_context
*__ctx
, const char *name
, int namlen
,
254 loff_t offset
, u64 ino
, unsigned int d_type
)
256 struct nfs4_dir_ctx
*ctx
=
257 container_of(__ctx
, struct nfs4_dir_ctx
, ctx
);
258 struct name_list
*entry
;
260 if (namlen
!= HEXDIR_LEN
- 1)
262 entry
= kmalloc(sizeof(struct name_list
), GFP_KERNEL
);
265 memcpy(entry
->name
, name
, HEXDIR_LEN
- 1);
266 entry
->name
[HEXDIR_LEN
- 1] = '\0';
267 list_add(&entry
->list
, &ctx
->names
);
272 nfsd4_list_rec_dir(recdir_func
*f
, struct nfsd_net
*nn
)
274 const struct cred
*original_cred
;
275 struct dentry
*dir
= nn
->rec_file
->f_path
.dentry
;
276 struct nfs4_dir_ctx ctx
= {
277 .ctx
.actor
= nfsd4_build_namelist
,
278 .names
= LIST_HEAD_INIT(ctx
.names
)
280 struct name_list
*entry
, *tmp
;
283 status
= nfs4_save_creds(&original_cred
);
287 status
= vfs_llseek(nn
->rec_file
, 0, SEEK_SET
);
289 nfs4_reset_creds(original_cred
);
293 status
= iterate_dir(nn
->rec_file
, &ctx
.ctx
);
294 inode_lock_nested(d_inode(dir
), I_MUTEX_PARENT
);
296 list_for_each_entry_safe(entry
, tmp
, &ctx
.names
, list
) {
298 struct dentry
*dentry
;
299 dentry
= lookup_one_len(entry
->name
, dir
, HEXDIR_LEN
-1);
300 if (IS_ERR(dentry
)) {
301 status
= PTR_ERR(dentry
);
304 status
= f(dir
, dentry
, nn
);
307 list_del(&entry
->list
);
310 inode_unlock(d_inode(dir
));
311 nfs4_reset_creds(original_cred
);
313 list_for_each_entry_safe(entry
, tmp
, &ctx
.names
, list
) {
314 dprintk("NFSD: %s. Left entry %s\n", __func__
, entry
->name
);
315 list_del(&entry
->list
);
322 nfsd4_unlink_clid_dir(char *name
, int namlen
, struct nfsd_net
*nn
)
324 struct dentry
*dir
, *dentry
;
327 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen
, name
);
329 dir
= nn
->rec_file
->f_path
.dentry
;
330 inode_lock_nested(d_inode(dir
), I_MUTEX_PARENT
);
331 dentry
= lookup_one_len(name
, dir
, namlen
);
332 if (IS_ERR(dentry
)) {
333 status
= PTR_ERR(dentry
);
337 if (d_really_is_negative(dentry
))
339 status
= vfs_rmdir(d_inode(dir
), dentry
);
343 inode_unlock(d_inode(dir
));
348 nfsd4_remove_clid_dir(struct nfs4_client
*clp
)
350 const struct cred
*original_cred
;
351 struct nfs4_client_reclaim
*crp
;
352 char dname
[HEXDIR_LEN
];
354 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
356 if (!nn
->rec_file
|| !test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
359 status
= nfs4_make_rec_clidname(dname
, &clp
->cl_name
);
361 return legacy_recdir_name_error(clp
, status
);
363 status
= mnt_want_write_file(nn
->rec_file
);
366 clear_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
368 status
= nfs4_save_creds(&original_cred
);
372 status
= nfsd4_unlink_clid_dir(dname
, HEXDIR_LEN
-1, nn
);
373 nfs4_reset_creds(original_cred
);
375 vfs_fsync(nn
->rec_file
, 0);
377 /* remove reclaim record */
378 crp
= nfsd4_find_reclaim_client(dname
, nn
);
380 nfs4_remove_reclaim_record(crp
, nn
);
384 mnt_drop_write_file(nn
->rec_file
);
387 printk("NFSD: Failed to remove expired client state directory"
388 " %.*s\n", HEXDIR_LEN
, dname
);
392 purge_old(struct dentry
*parent
, struct dentry
*child
, struct nfsd_net
*nn
)
396 if (nfs4_has_reclaimed_state(child
->d_name
.name
, nn
))
399 status
= vfs_rmdir(d_inode(parent
), child
);
401 printk("failed to remove client recovery directory %pd\n",
403 /* Keep trying, success or failure: */
408 nfsd4_recdir_purge_old(struct nfsd_net
*nn
)
412 nn
->in_grace
= false;
415 status
= mnt_want_write_file(nn
->rec_file
);
418 status
= nfsd4_list_rec_dir(purge_old
, nn
);
420 vfs_fsync(nn
->rec_file
, 0);
421 mnt_drop_write_file(nn
->rec_file
);
423 nfs4_release_reclaim(nn
);
425 printk("nfsd4: failed to purge old clients from recovery"
426 " directory %pD\n", nn
->rec_file
);
430 load_recdir(struct dentry
*parent
, struct dentry
*child
, struct nfsd_net
*nn
)
432 if (child
->d_name
.len
!= HEXDIR_LEN
- 1) {
433 printk("nfsd4: illegal name %pd in recovery directory\n",
435 /* Keep trying; maybe the others are OK: */
438 nfs4_client_to_reclaim(child
->d_name
.name
, nn
);
443 nfsd4_recdir_load(struct net
*net
) {
445 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
450 status
= nfsd4_list_rec_dir(load_recdir
, nn
);
452 printk("nfsd4: failed loading clients from recovery"
453 " directory %pD\n", nn
->rec_file
);
458 * Hold reference to the recovery directory.
462 nfsd4_init_recdir(struct net
*net
)
464 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
465 const struct cred
*original_cred
;
468 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
469 user_recovery_dirname
);
471 BUG_ON(nn
->rec_file
);
473 status
= nfs4_save_creds(&original_cred
);
475 printk("NFSD: Unable to change credentials to find recovery"
476 " directory: error %d\n",
481 nn
->rec_file
= filp_open(user_recovery_dirname
, O_RDONLY
| O_DIRECTORY
, 0);
482 if (IS_ERR(nn
->rec_file
)) {
483 printk("NFSD: unable to find recovery directory %s\n",
484 user_recovery_dirname
);
485 status
= PTR_ERR(nn
->rec_file
);
489 nfs4_reset_creds(original_cred
);
496 nfsd4_shutdown_recdir(struct net
*net
)
498 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
507 nfs4_legacy_state_init(struct net
*net
)
509 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
512 nn
->reclaim_str_hashtbl
= kmalloc_array(CLIENT_HASH_SIZE
,
513 sizeof(struct list_head
),
515 if (!nn
->reclaim_str_hashtbl
)
518 for (i
= 0; i
< CLIENT_HASH_SIZE
; i
++)
519 INIT_LIST_HEAD(&nn
->reclaim_str_hashtbl
[i
]);
520 nn
->reclaim_str_hashtbl_size
= 0;
526 nfs4_legacy_state_shutdown(struct net
*net
)
528 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
530 kfree(nn
->reclaim_str_hashtbl
);
534 nfsd4_load_reboot_recovery_data(struct net
*net
)
538 status
= nfsd4_init_recdir(net
);
542 status
= nfsd4_recdir_load(net
);
544 nfsd4_shutdown_recdir(net
);
550 nfsd4_legacy_tracking_init(struct net
*net
)
554 /* XXX: The legacy code won't work in a container */
555 if (net
!= &init_net
) {
556 pr_warn("NFSD: attempt to initialize legacy client tracking in a container ignored.\n");
560 status
= nfs4_legacy_state_init(net
);
564 status
= nfsd4_load_reboot_recovery_data(net
);
570 nfs4_legacy_state_shutdown(net
);
575 nfsd4_legacy_tracking_exit(struct net
*net
)
577 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
579 nfs4_release_reclaim(nn
);
580 nfsd4_shutdown_recdir(net
);
581 nfs4_legacy_state_shutdown(net
);
585 * Change the NFSv4 recovery directory to recdir.
588 nfs4_reset_recoverydir(char *recdir
)
593 status
= kern_path(recdir
, LOOKUP_FOLLOW
, &path
);
597 if (d_is_dir(path
.dentry
)) {
598 strcpy(user_recovery_dirname
, recdir
);
606 nfs4_recoverydir(void)
608 return user_recovery_dirname
;
612 nfsd4_check_legacy_client(struct nfs4_client
*clp
)
615 char dname
[HEXDIR_LEN
];
616 struct nfs4_client_reclaim
*crp
;
617 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
619 /* did we already find that this client is stable? */
620 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
623 status
= nfs4_make_rec_clidname(dname
, &clp
->cl_name
);
625 legacy_recdir_name_error(clp
, status
);
629 /* look for it in the reclaim hashtable otherwise */
630 crp
= nfsd4_find_reclaim_client(dname
, nn
);
632 set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
640 static const struct nfsd4_client_tracking_ops nfsd4_legacy_tracking_ops
= {
641 .init
= nfsd4_legacy_tracking_init
,
642 .exit
= nfsd4_legacy_tracking_exit
,
643 .create
= nfsd4_create_clid_dir
,
644 .remove
= nfsd4_remove_clid_dir
,
645 .check
= nfsd4_check_legacy_client
,
646 .grace_done
= nfsd4_recdir_purge_old
,
650 #define NFSD_PIPE_DIR "nfsd"
651 #define NFSD_CLD_PIPE "cld"
653 /* per-net-ns structure for holding cld upcall info */
655 struct rpc_pipe
*cn_pipe
;
657 struct list_head cn_list
;
662 struct list_head cu_list
;
663 struct cld_net
*cu_net
;
664 struct completion cu_done
;
665 struct cld_msg cu_msg
;
669 __cld_pipe_upcall(struct rpc_pipe
*pipe
, struct cld_msg
*cmsg
)
672 struct rpc_pipe_msg msg
;
673 struct cld_upcall
*cup
= container_of(cmsg
, struct cld_upcall
, cu_msg
);
675 memset(&msg
, 0, sizeof(msg
));
677 msg
.len
= sizeof(*cmsg
);
679 ret
= rpc_queue_upcall(pipe
, &msg
);
684 wait_for_completion(&cup
->cu_done
);
693 cld_pipe_upcall(struct rpc_pipe
*pipe
, struct cld_msg
*cmsg
)
698 * -EAGAIN occurs when pipe is closed and reopened while there are
702 ret
= __cld_pipe_upcall(pipe
, cmsg
);
703 } while (ret
== -EAGAIN
);
709 cld_pipe_downcall(struct file
*filp
, const char __user
*src
, size_t mlen
)
711 struct cld_upcall
*tmp
, *cup
;
712 struct cld_msg __user
*cmsg
= (struct cld_msg __user
*)src
;
714 struct nfsd_net
*nn
= net_generic(file_inode(filp
)->i_sb
->s_fs_info
,
716 struct cld_net
*cn
= nn
->cld_net
;
718 if (mlen
!= sizeof(*cmsg
)) {
719 dprintk("%s: got %zu bytes, expected %zu\n", __func__
, mlen
,
724 /* copy just the xid so we can try to find that */
725 if (copy_from_user(&xid
, &cmsg
->cm_xid
, sizeof(xid
)) != 0) {
726 dprintk("%s: error when copying xid from userspace", __func__
);
730 /* walk the list and find corresponding xid */
732 spin_lock(&cn
->cn_lock
);
733 list_for_each_entry(tmp
, &cn
->cn_list
, cu_list
) {
734 if (get_unaligned(&tmp
->cu_msg
.cm_xid
) == xid
) {
736 list_del_init(&cup
->cu_list
);
740 spin_unlock(&cn
->cn_lock
);
742 /* couldn't find upcall? */
744 dprintk("%s: couldn't find upcall -- xid=%u\n", __func__
, xid
);
748 if (copy_from_user(&cup
->cu_msg
, src
, mlen
) != 0)
751 complete(&cup
->cu_done
);
756 cld_pipe_destroy_msg(struct rpc_pipe_msg
*msg
)
758 struct cld_msg
*cmsg
= msg
->data
;
759 struct cld_upcall
*cup
= container_of(cmsg
, struct cld_upcall
,
762 /* errno >= 0 means we got a downcall */
766 complete(&cup
->cu_done
);
769 static const struct rpc_pipe_ops cld_upcall_ops
= {
770 .upcall
= rpc_pipe_generic_upcall
,
771 .downcall
= cld_pipe_downcall
,
772 .destroy_msg
= cld_pipe_destroy_msg
,
775 static struct dentry
*
776 nfsd4_cld_register_sb(struct super_block
*sb
, struct rpc_pipe
*pipe
)
778 struct dentry
*dir
, *dentry
;
780 dir
= rpc_d_lookup_sb(sb
, NFSD_PIPE_DIR
);
782 return ERR_PTR(-ENOENT
);
783 dentry
= rpc_mkpipe_dentry(dir
, NFSD_CLD_PIPE
, NULL
, pipe
);
789 nfsd4_cld_unregister_sb(struct rpc_pipe
*pipe
)
792 rpc_unlink(pipe
->dentry
);
795 static struct dentry
*
796 nfsd4_cld_register_net(struct net
*net
, struct rpc_pipe
*pipe
)
798 struct super_block
*sb
;
799 struct dentry
*dentry
;
801 sb
= rpc_get_sb_net(net
);
804 dentry
= nfsd4_cld_register_sb(sb
, pipe
);
810 nfsd4_cld_unregister_net(struct net
*net
, struct rpc_pipe
*pipe
)
812 struct super_block
*sb
;
814 sb
= rpc_get_sb_net(net
);
816 nfsd4_cld_unregister_sb(pipe
);
821 /* Initialize rpc_pipefs pipe for communication with client tracking daemon */
823 nfsd4_init_cld_pipe(struct net
*net
)
826 struct dentry
*dentry
;
827 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
833 cn
= kzalloc(sizeof(*cn
), GFP_KERNEL
);
839 cn
->cn_pipe
= rpc_mkpipe_data(&cld_upcall_ops
, RPC_PIPE_WAIT_FOR_OPEN
);
840 if (IS_ERR(cn
->cn_pipe
)) {
841 ret
= PTR_ERR(cn
->cn_pipe
);
844 spin_lock_init(&cn
->cn_lock
);
845 INIT_LIST_HEAD(&cn
->cn_list
);
847 dentry
= nfsd4_cld_register_net(net
, cn
->cn_pipe
);
848 if (IS_ERR(dentry
)) {
849 ret
= PTR_ERR(dentry
);
850 goto err_destroy_data
;
853 cn
->cn_pipe
->dentry
= dentry
;
858 rpc_destroy_pipe_data(cn
->cn_pipe
);
861 printk(KERN_ERR
"NFSD: unable to create nfsdcld upcall pipe (%d)\n",
867 nfsd4_remove_cld_pipe(struct net
*net
)
869 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
870 struct cld_net
*cn
= nn
->cld_net
;
872 nfsd4_cld_unregister_net(net
, cn
->cn_pipe
);
873 rpc_destroy_pipe_data(cn
->cn_pipe
);
878 static struct cld_upcall
*
879 alloc_cld_upcall(struct cld_net
*cn
)
881 struct cld_upcall
*new, *tmp
;
883 new = kzalloc(sizeof(*new), GFP_KERNEL
);
887 /* FIXME: hard cap on number in flight? */
889 spin_lock(&cn
->cn_lock
);
890 list_for_each_entry(tmp
, &cn
->cn_list
, cu_list
) {
891 if (tmp
->cu_msg
.cm_xid
== cn
->cn_xid
) {
893 spin_unlock(&cn
->cn_lock
);
897 init_completion(&new->cu_done
);
898 new->cu_msg
.cm_vers
= CLD_UPCALL_VERSION
;
899 put_unaligned(cn
->cn_xid
++, &new->cu_msg
.cm_xid
);
901 list_add(&new->cu_list
, &cn
->cn_list
);
902 spin_unlock(&cn
->cn_lock
);
904 dprintk("%s: allocated xid %u\n", __func__
, new->cu_msg
.cm_xid
);
910 free_cld_upcall(struct cld_upcall
*victim
)
912 struct cld_net
*cn
= victim
->cu_net
;
914 spin_lock(&cn
->cn_lock
);
915 list_del(&victim
->cu_list
);
916 spin_unlock(&cn
->cn_lock
);
920 /* Ask daemon to create a new record */
922 nfsd4_cld_create(struct nfs4_client
*clp
)
925 struct cld_upcall
*cup
;
926 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
927 struct cld_net
*cn
= nn
->cld_net
;
929 /* Don't upcall if it's already stored */
930 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
933 cup
= alloc_cld_upcall(cn
);
939 cup
->cu_msg
.cm_cmd
= Cld_Create
;
940 cup
->cu_msg
.cm_u
.cm_name
.cn_len
= clp
->cl_name
.len
;
941 memcpy(cup
->cu_msg
.cm_u
.cm_name
.cn_id
, clp
->cl_name
.data
,
944 ret
= cld_pipe_upcall(cn
->cn_pipe
, &cup
->cu_msg
);
946 ret
= cup
->cu_msg
.cm_status
;
947 set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
950 free_cld_upcall(cup
);
953 printk(KERN_ERR
"NFSD: Unable to create client "
954 "record on stable storage: %d\n", ret
);
957 /* Ask daemon to create a new record */
959 nfsd4_cld_remove(struct nfs4_client
*clp
)
962 struct cld_upcall
*cup
;
963 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
964 struct cld_net
*cn
= nn
->cld_net
;
966 /* Don't upcall if it's already removed */
967 if (!test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
970 cup
= alloc_cld_upcall(cn
);
976 cup
->cu_msg
.cm_cmd
= Cld_Remove
;
977 cup
->cu_msg
.cm_u
.cm_name
.cn_len
= clp
->cl_name
.len
;
978 memcpy(cup
->cu_msg
.cm_u
.cm_name
.cn_id
, clp
->cl_name
.data
,
981 ret
= cld_pipe_upcall(cn
->cn_pipe
, &cup
->cu_msg
);
983 ret
= cup
->cu_msg
.cm_status
;
984 clear_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
987 free_cld_upcall(cup
);
990 printk(KERN_ERR
"NFSD: Unable to remove client "
991 "record from stable storage: %d\n", ret
);
994 /* Check for presence of a record, and update its timestamp */
996 nfsd4_cld_check(struct nfs4_client
*clp
)
999 struct cld_upcall
*cup
;
1000 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
1001 struct cld_net
*cn
= nn
->cld_net
;
1003 /* Don't upcall if one was already stored during this grace pd */
1004 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
1007 cup
= alloc_cld_upcall(cn
);
1009 printk(KERN_ERR
"NFSD: Unable to check client record on "
1010 "stable storage: %d\n", -ENOMEM
);
1014 cup
->cu_msg
.cm_cmd
= Cld_Check
;
1015 cup
->cu_msg
.cm_u
.cm_name
.cn_len
= clp
->cl_name
.len
;
1016 memcpy(cup
->cu_msg
.cm_u
.cm_name
.cn_id
, clp
->cl_name
.data
,
1019 ret
= cld_pipe_upcall(cn
->cn_pipe
, &cup
->cu_msg
);
1021 ret
= cup
->cu_msg
.cm_status
;
1022 set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
1025 free_cld_upcall(cup
);
1030 nfsd4_cld_grace_done(struct nfsd_net
*nn
)
1033 struct cld_upcall
*cup
;
1034 struct cld_net
*cn
= nn
->cld_net
;
1036 cup
= alloc_cld_upcall(cn
);
1042 cup
->cu_msg
.cm_cmd
= Cld_GraceDone
;
1043 cup
->cu_msg
.cm_u
.cm_gracetime
= (int64_t)nn
->boot_time
;
1044 ret
= cld_pipe_upcall(cn
->cn_pipe
, &cup
->cu_msg
);
1046 ret
= cup
->cu_msg
.cm_status
;
1048 free_cld_upcall(cup
);
1051 printk(KERN_ERR
"NFSD: Unable to end grace period: %d\n", ret
);
1054 static const struct nfsd4_client_tracking_ops nfsd4_cld_tracking_ops
= {
1055 .init
= nfsd4_init_cld_pipe
,
1056 .exit
= nfsd4_remove_cld_pipe
,
1057 .create
= nfsd4_cld_create
,
1058 .remove
= nfsd4_cld_remove
,
1059 .check
= nfsd4_cld_check
,
1060 .grace_done
= nfsd4_cld_grace_done
,
1063 /* upcall via usermodehelper */
1064 static char cltrack_prog
[PATH_MAX
] = "/sbin/nfsdcltrack";
1065 module_param_string(cltrack_prog
, cltrack_prog
, sizeof(cltrack_prog
),
1067 MODULE_PARM_DESC(cltrack_prog
, "Path to the nfsdcltrack upcall program");
1069 static bool cltrack_legacy_disable
;
1070 module_param(cltrack_legacy_disable
, bool, S_IRUGO
|S_IWUSR
);
1071 MODULE_PARM_DESC(cltrack_legacy_disable
,
1072 "Disable legacy recoverydir conversion. Default: false");
1074 #define LEGACY_TOPDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_TOPDIR="
1075 #define LEGACY_RECDIR_ENV_PREFIX "NFSDCLTRACK_LEGACY_RECDIR="
1076 #define HAS_SESSION_ENV_PREFIX "NFSDCLTRACK_CLIENT_HAS_SESSION="
1077 #define GRACE_START_ENV_PREFIX "NFSDCLTRACK_GRACE_START="
1080 nfsd4_cltrack_legacy_topdir(void)
1086 if (cltrack_legacy_disable
)
1089 len
= strlen(LEGACY_TOPDIR_ENV_PREFIX
) +
1090 strlen(nfs4_recoverydir()) + 1;
1092 result
= kmalloc(len
, GFP_KERNEL
);
1096 copied
= snprintf(result
, len
, LEGACY_TOPDIR_ENV_PREFIX
"%s",
1097 nfs4_recoverydir());
1098 if (copied
>= len
) {
1099 /* just return nothing if output was truncated */
1108 nfsd4_cltrack_legacy_recdir(const struct xdr_netobj
*name
)
1114 if (cltrack_legacy_disable
)
1117 /* +1 is for '/' between "topdir" and "recdir" */
1118 len
= strlen(LEGACY_RECDIR_ENV_PREFIX
) +
1119 strlen(nfs4_recoverydir()) + 1 + HEXDIR_LEN
;
1121 result
= kmalloc(len
, GFP_KERNEL
);
1125 copied
= snprintf(result
, len
, LEGACY_RECDIR_ENV_PREFIX
"%s/",
1126 nfs4_recoverydir());
1127 if (copied
> (len
- HEXDIR_LEN
)) {
1128 /* just return nothing if output will be truncated */
1133 copied
= nfs4_make_rec_clidname(result
+ copied
, name
);
1143 nfsd4_cltrack_client_has_session(struct nfs4_client
*clp
)
1149 /* prefix + Y/N character + terminating NULL */
1150 len
= strlen(HAS_SESSION_ENV_PREFIX
) + 1 + 1;
1152 result
= kmalloc(len
, GFP_KERNEL
);
1156 copied
= snprintf(result
, len
, HAS_SESSION_ENV_PREFIX
"%c",
1157 clp
->cl_minorversion
? 'Y' : 'N');
1158 if (copied
>= len
) {
1159 /* just return nothing if output was truncated */
1168 nfsd4_cltrack_grace_start(time_t grace_start
)
1174 /* prefix + max width of int64_t string + terminating NULL */
1175 len
= strlen(GRACE_START_ENV_PREFIX
) + 22 + 1;
1177 result
= kmalloc(len
, GFP_KERNEL
);
1181 copied
= snprintf(result
, len
, GRACE_START_ENV_PREFIX
"%ld",
1183 if (copied
>= len
) {
1184 /* just return nothing if output was truncated */
1193 nfsd4_umh_cltrack_upcall(char *cmd
, char *arg
, char *env0
, char *env1
)
1199 if (unlikely(!cltrack_prog
[0])) {
1200 dprintk("%s: cltrack_prog is disabled\n", __func__
);
1204 dprintk("%s: cmd: %s\n", __func__
, cmd
);
1205 dprintk("%s: arg: %s\n", __func__
, arg
? arg
: "(null)");
1206 dprintk("%s: env0: %s\n", __func__
, env0
? env0
: "(null)");
1207 dprintk("%s: env1: %s\n", __func__
, env1
? env1
: "(null)");
1213 argv
[0] = (char *)cltrack_prog
;
1218 ret
= call_usermodehelper(argv
[0], argv
, envp
, UMH_WAIT_PROC
);
1220 * Disable the upcall mechanism if we're getting an ENOENT or EACCES
1221 * error. The admin can re-enable it on the fly by using sysfs
1222 * once the problem has been fixed.
1224 if (ret
== -ENOENT
|| ret
== -EACCES
) {
1225 dprintk("NFSD: %s was not found or isn't executable (%d). "
1226 "Setting cltrack_prog to blank string!",
1228 cltrack_prog
[0] = '\0';
1230 dprintk("%s: %s return value: %d\n", __func__
, cltrack_prog
, ret
);
1236 bin_to_hex_dup(const unsigned char *src
, int srclen
)
1241 /* +1 for terminating NULL */
1242 buf
= kmalloc((srclen
* 2) + 1, GFP_KERNEL
);
1247 for (i
= 0; i
< srclen
; i
++) {
1248 sprintf(hex
, "%2.2x", *src
++);
1255 nfsd4_umh_cltrack_init(struct net
*net
)
1258 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
1259 char *grace_start
= nfsd4_cltrack_grace_start(nn
->boot_time
);
1261 /* XXX: The usermode helper s not working in container yet. */
1262 if (net
!= &init_net
) {
1263 pr_warn("NFSD: attempt to initialize umh client tracking in a container ignored.\n");
1268 ret
= nfsd4_umh_cltrack_upcall("init", NULL
, grace_start
, NULL
);
1274 nfsd4_cltrack_upcall_lock(struct nfs4_client
*clp
)
1276 wait_on_bit_lock(&clp
->cl_flags
, NFSD4_CLIENT_UPCALL_LOCK
,
1277 TASK_UNINTERRUPTIBLE
);
1281 nfsd4_cltrack_upcall_unlock(struct nfs4_client
*clp
)
1283 smp_mb__before_atomic();
1284 clear_bit(NFSD4_CLIENT_UPCALL_LOCK
, &clp
->cl_flags
);
1285 smp_mb__after_atomic();
1286 wake_up_bit(&clp
->cl_flags
, NFSD4_CLIENT_UPCALL_LOCK
);
1290 nfsd4_umh_cltrack_create(struct nfs4_client
*clp
)
1292 char *hexid
, *has_session
, *grace_start
;
1293 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
1296 * With v4.0 clients, there's little difference in outcome between a
1297 * create and check operation, and we can end up calling into this
1298 * function multiple times per client (once for each openowner). So,
1299 * for v4.0 clients skip upcalling once the client has been recorded
1300 * on stable storage.
1302 * For v4.1+ clients, the outcome of the two operations is different,
1303 * so we must ensure that we upcall for the create operation. v4.1+
1304 * clients call this on RECLAIM_COMPLETE though, so we should only end
1305 * up doing a single create upcall per client.
1307 if (clp
->cl_minorversion
== 0 &&
1308 test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
1311 hexid
= bin_to_hex_dup(clp
->cl_name
.data
, clp
->cl_name
.len
);
1313 dprintk("%s: can't allocate memory for upcall!\n", __func__
);
1317 has_session
= nfsd4_cltrack_client_has_session(clp
);
1318 grace_start
= nfsd4_cltrack_grace_start(nn
->boot_time
);
1320 nfsd4_cltrack_upcall_lock(clp
);
1321 if (!nfsd4_umh_cltrack_upcall("create", hexid
, has_session
, grace_start
))
1322 set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
1323 nfsd4_cltrack_upcall_unlock(clp
);
1331 nfsd4_umh_cltrack_remove(struct nfs4_client
*clp
)
1335 if (!test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
1338 hexid
= bin_to_hex_dup(clp
->cl_name
.data
, clp
->cl_name
.len
);
1340 dprintk("%s: can't allocate memory for upcall!\n", __func__
);
1344 nfsd4_cltrack_upcall_lock(clp
);
1345 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
) &&
1346 nfsd4_umh_cltrack_upcall("remove", hexid
, NULL
, NULL
) == 0)
1347 clear_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
1348 nfsd4_cltrack_upcall_unlock(clp
);
1354 nfsd4_umh_cltrack_check(struct nfs4_client
*clp
)
1357 char *hexid
, *has_session
, *legacy
;
1359 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
))
1362 hexid
= bin_to_hex_dup(clp
->cl_name
.data
, clp
->cl_name
.len
);
1364 dprintk("%s: can't allocate memory for upcall!\n", __func__
);
1368 has_session
= nfsd4_cltrack_client_has_session(clp
);
1369 legacy
= nfsd4_cltrack_legacy_recdir(&clp
->cl_name
);
1371 nfsd4_cltrack_upcall_lock(clp
);
1372 if (test_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
)) {
1375 ret
= nfsd4_umh_cltrack_upcall("check", hexid
, has_session
, legacy
);
1377 set_bit(NFSD4_CLIENT_STABLE
, &clp
->cl_flags
);
1379 nfsd4_cltrack_upcall_unlock(clp
);
1388 nfsd4_umh_cltrack_grace_done(struct nfsd_net
*nn
)
1391 char timestr
[22]; /* FIXME: better way to determine max size? */
1393 sprintf(timestr
, "%ld", nn
->boot_time
);
1394 legacy
= nfsd4_cltrack_legacy_topdir();
1395 nfsd4_umh_cltrack_upcall("gracedone", timestr
, legacy
, NULL
);
1399 static const struct nfsd4_client_tracking_ops nfsd4_umh_tracking_ops
= {
1400 .init
= nfsd4_umh_cltrack_init
,
1402 .create
= nfsd4_umh_cltrack_create
,
1403 .remove
= nfsd4_umh_cltrack_remove
,
1404 .check
= nfsd4_umh_cltrack_check
,
1405 .grace_done
= nfsd4_umh_cltrack_grace_done
,
1409 nfsd4_client_tracking_init(struct net
*net
)
1413 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
1415 /* just run the init if it the method is already decided */
1416 if (nn
->client_tracking_ops
)
1420 * First, try a UMH upcall. It should succeed or fail quickly, so
1421 * there's little harm in trying that first.
1423 nn
->client_tracking_ops
= &nfsd4_umh_tracking_ops
;
1424 status
= nn
->client_tracking_ops
->init(net
);
1429 * See if the recoverydir exists and is a directory. If it is,
1430 * then use the legacy ops.
1432 nn
->client_tracking_ops
= &nfsd4_legacy_tracking_ops
;
1433 status
= kern_path(nfs4_recoverydir(), LOOKUP_FOLLOW
, &path
);
1435 status
= d_is_dir(path
.dentry
);
1441 /* Finally, try to use nfsdcld */
1442 nn
->client_tracking_ops
= &nfsd4_cld_tracking_ops
;
1443 printk(KERN_WARNING
"NFSD: the nfsdcld client tracking upcall will be "
1444 "removed in 3.10. Please transition to using "
1447 status
= nn
->client_tracking_ops
->init(net
);
1449 printk(KERN_WARNING
"NFSD: Unable to initialize client "
1450 "recovery tracking! (%d)\n", status
);
1451 nn
->client_tracking_ops
= NULL
;
1457 nfsd4_client_tracking_exit(struct net
*net
)
1459 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
1461 if (nn
->client_tracking_ops
) {
1462 if (nn
->client_tracking_ops
->exit
)
1463 nn
->client_tracking_ops
->exit(net
);
1464 nn
->client_tracking_ops
= NULL
;
1469 nfsd4_client_record_create(struct nfs4_client
*clp
)
1471 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
1473 if (nn
->client_tracking_ops
)
1474 nn
->client_tracking_ops
->create(clp
);
1478 nfsd4_client_record_remove(struct nfs4_client
*clp
)
1480 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
1482 if (nn
->client_tracking_ops
)
1483 nn
->client_tracking_ops
->remove(clp
);
1487 nfsd4_client_record_check(struct nfs4_client
*clp
)
1489 struct nfsd_net
*nn
= net_generic(clp
->net
, nfsd_net_id
);
1491 if (nn
->client_tracking_ops
)
1492 return nn
->client_tracking_ops
->check(clp
);
1498 nfsd4_record_grace_done(struct nfsd_net
*nn
)
1500 if (nn
->client_tracking_ops
)
1501 nn
->client_tracking_ops
->grace_done(nn
);
1505 rpc_pipefs_event(struct notifier_block
*nb
, unsigned long event
, void *ptr
)
1507 struct super_block
*sb
= ptr
;
1508 struct net
*net
= sb
->s_fs_info
;
1509 struct nfsd_net
*nn
= net_generic(net
, nfsd_net_id
);
1510 struct cld_net
*cn
= nn
->cld_net
;
1511 struct dentry
*dentry
;
1514 if (!try_module_get(THIS_MODULE
))
1518 module_put(THIS_MODULE
);
1523 case RPC_PIPEFS_MOUNT
:
1524 dentry
= nfsd4_cld_register_sb(sb
, cn
->cn_pipe
);
1525 if (IS_ERR(dentry
)) {
1526 ret
= PTR_ERR(dentry
);
1529 cn
->cn_pipe
->dentry
= dentry
;
1531 case RPC_PIPEFS_UMOUNT
:
1532 if (cn
->cn_pipe
->dentry
)
1533 nfsd4_cld_unregister_sb(cn
->cn_pipe
);
1539 module_put(THIS_MODULE
);
1543 static struct notifier_block nfsd4_cld_block
= {
1544 .notifier_call
= rpc_pipefs_event
,
1548 register_cld_notifier(void)
1550 return rpc_pipefs_notifier_register(&nfsd4_cld_block
);
1554 unregister_cld_notifier(void)
1556 rpc_pipefs_notifier_unregister(&nfsd4_cld_block
);