2 * linux/fs/nfsd/nfs4recover.c
4 * Copyright (c) 2004 The Regents of the University of Michigan.
7 * Andy Adamson <andros@citi.umich.edu>
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 * 3. Neither the name of the University nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
23 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
24 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
29 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 #include <linux/err.h>
37 #include <linux/sunrpc/svc.h>
38 #include <linux/nfsd/nfsd.h>
39 #include <linux/nfs4.h>
40 #include <linux/nfsd/state.h>
41 #include <linux/nfsd/xdr4.h>
42 #include <linux/param.h>
43 #include <linux/file.h>
44 #include <linux/namei.h>
45 #include <asm/uaccess.h>
46 #include <linux/scatterlist.h>
47 #include <linux/crypto.h>
48 #include <linux/sched.h>
49 #include <linux/mount.h>
51 #define NFSDDBG_FACILITY NFSDDBG_PROC
54 static struct path rec_dir
;
55 static int rec_dir_init
= 0;
58 nfs4_save_creds(const struct cred
**original_creds
)
62 new = prepare_creds();
68 *original_creds
= override_creds(new);
74 nfs4_reset_creds(const struct cred
*original
)
76 revert_creds(original
);
80 md5_to_hex(char *out
, char *md5
)
84 for (i
=0; i
<16; i
++) {
85 unsigned char c
= md5
[i
];
87 *out
++ = '0' + ((c
&0xf0)>>4) + (c
>=0xa0)*('a'-'9'-1);
88 *out
++ = '0' + (c
&0x0f) + ((c
&0x0f)>=0x0a)*('a'-'9'-1);
94 nfs4_make_rec_clidname(char *dname
, struct xdr_netobj
*clname
)
96 struct xdr_netobj cksum
;
97 struct hash_desc desc
;
98 struct scatterlist sg
;
99 __be32 status
= nfserr_resource
;
101 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
102 clname
->len
, clname
->data
);
103 desc
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
104 desc
.tfm
= crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC
);
105 if (IS_ERR(desc
.tfm
))
107 cksum
.len
= crypto_hash_digestsize(desc
.tfm
);
108 cksum
.data
= kmalloc(cksum
.len
, GFP_KERNEL
);
109 if (cksum
.data
== NULL
)
112 sg_init_one(&sg
, clname
->data
, clname
->len
);
114 if (crypto_hash_digest(&desc
, &sg
, sg
.length
, cksum
.data
))
117 md5_to_hex(dname
, cksum
.data
);
122 crypto_free_hash(desc
.tfm
);
128 nfsd4_sync_rec_dir(void)
130 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
131 nfsd_sync_dir(rec_dir
.dentry
);
132 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
136 nfsd4_create_clid_dir(struct nfs4_client
*clp
)
138 const struct cred
*original_cred
;
139 char *dname
= clp
->cl_recdir
;
140 struct dentry
*dentry
;
143 dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname
);
145 if (!rec_dir_init
|| clp
->cl_firststate
)
148 status
= nfs4_save_creds(&original_cred
);
152 /* lock the parent */
153 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
155 dentry
= lookup_one_len(dname
, rec_dir
.dentry
, HEXDIR_LEN
-1);
156 if (IS_ERR(dentry
)) {
157 status
= PTR_ERR(dentry
);
161 if (dentry
->d_inode
) {
162 dprintk("NFSD: nfsd4_create_clid_dir: DIRECTORY EXISTS\n");
165 status
= mnt_want_write(rec_dir
.mnt
);
168 status
= vfs_mkdir(rec_dir
.dentry
->d_inode
, dentry
, S_IRWXU
);
169 mnt_drop_write(rec_dir
.mnt
);
173 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
175 clp
->cl_firststate
= 1;
176 nfsd4_sync_rec_dir();
178 nfs4_reset_creds(original_cred
);
179 dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status
);
183 typedef int (recdir_func
)(struct dentry
*, struct dentry
*);
186 struct dentry
*dentry
;
187 struct list_head list
;
190 struct dentry_list_arg
{
191 struct list_head dentries
;
192 struct dentry
*parent
;
196 nfsd4_build_dentrylist(void *arg
, const char *name
, int namlen
,
197 loff_t offset
, u64 ino
, unsigned int d_type
)
199 struct dentry_list_arg
*dla
= arg
;
200 struct list_head
*dentries
= &dla
->dentries
;
201 struct dentry
*parent
= dla
->parent
;
202 struct dentry
*dentry
;
203 struct dentry_list
*child
;
205 if (name
&& isdotent(name
, namlen
))
207 dentry
= lookup_one_len(name
, parent
, namlen
);
209 return PTR_ERR(dentry
);
210 child
= kmalloc(sizeof(*child
), GFP_KERNEL
);
213 child
->dentry
= dentry
;
214 list_add(&child
->list
, dentries
);
219 nfsd4_list_rec_dir(struct dentry
*dir
, recdir_func
*f
)
221 const struct cred
*original_cred
;
223 struct dentry_list_arg dla
= {
226 struct list_head
*dentries
= &dla
.dentries
;
227 struct dentry_list
*child
;
233 status
= nfs4_save_creds(&original_cred
);
237 filp
= dentry_open(dget(dir
), mntget(rec_dir
.mnt
), O_RDONLY
,
239 status
= PTR_ERR(filp
);
242 INIT_LIST_HEAD(dentries
);
243 status
= vfs_readdir(filp
, nfsd4_build_dentrylist
, &dla
);
245 while (!list_empty(dentries
)) {
246 child
= list_entry(dentries
->next
, struct dentry_list
, list
);
247 status
= f(dir
, child
->dentry
);
250 list_del(&child
->list
);
255 while (!list_empty(dentries
)) {
256 child
= list_entry(dentries
->next
, struct dentry_list
, list
);
257 list_del(&child
->list
);
261 nfs4_reset_creds(original_cred
);
266 nfsd4_remove_clid_file(struct dentry
*dir
, struct dentry
*dentry
)
270 if (!S_ISREG(dir
->d_inode
->i_mode
)) {
271 printk("nfsd4: non-file found in client recovery directory\n");
274 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_PARENT
);
275 status
= vfs_unlink(dir
->d_inode
, dentry
);
276 mutex_unlock(&dir
->d_inode
->i_mutex
);
281 nfsd4_clear_clid_dir(struct dentry
*dir
, struct dentry
*dentry
)
285 /* For now this directory should already be empty, but we empty it of
286 * any regular files anyway, just in case the directory was created by
287 * a kernel from the future.... */
288 nfsd4_list_rec_dir(dentry
, nfsd4_remove_clid_file
);
289 mutex_lock_nested(&dir
->d_inode
->i_mutex
, I_MUTEX_PARENT
);
290 status
= vfs_rmdir(dir
->d_inode
, dentry
);
291 mutex_unlock(&dir
->d_inode
->i_mutex
);
296 nfsd4_unlink_clid_dir(char *name
, int namlen
)
298 struct dentry
*dentry
;
301 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen
, name
);
303 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
304 dentry
= lookup_one_len(name
, rec_dir
.dentry
, namlen
);
305 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
306 if (IS_ERR(dentry
)) {
307 status
= PTR_ERR(dentry
);
311 if (!dentry
->d_inode
)
314 status
= nfsd4_clear_clid_dir(rec_dir
.dentry
, dentry
);
321 nfsd4_remove_clid_dir(struct nfs4_client
*clp
)
323 const struct cred
*original_cred
;
326 if (!rec_dir_init
|| !clp
->cl_firststate
)
329 status
= mnt_want_write(rec_dir
.mnt
);
332 clp
->cl_firststate
= 0;
334 status
= nfs4_save_creds(&original_cred
);
338 status
= nfsd4_unlink_clid_dir(clp
->cl_recdir
, HEXDIR_LEN
-1);
339 nfs4_reset_creds(original_cred
);
341 nfsd4_sync_rec_dir();
342 mnt_drop_write(rec_dir
.mnt
);
345 printk("NFSD: Failed to remove expired client state directory"
346 " %.*s\n", HEXDIR_LEN
, clp
->cl_recdir
);
351 purge_old(struct dentry
*parent
, struct dentry
*child
)
355 if (nfs4_has_reclaimed_state(child
->d_name
.name
))
358 status
= nfsd4_clear_clid_dir(parent
, child
);
360 printk("failed to remove client recovery directory %s\n",
362 /* Keep trying, success or failure: */
367 nfsd4_recdir_purge_old(void) {
372 status
= mnt_want_write(rec_dir
.mnt
);
375 status
= nfsd4_list_rec_dir(rec_dir
.dentry
, purge_old
);
377 nfsd4_sync_rec_dir();
378 mnt_drop_write(rec_dir
.mnt
);
381 printk("nfsd4: failed to purge old clients from recovery"
382 " directory %s\n", rec_dir
.dentry
->d_name
.name
);
386 load_recdir(struct dentry
*parent
, struct dentry
*child
)
388 if (child
->d_name
.len
!= HEXDIR_LEN
- 1) {
389 printk("nfsd4: illegal name %s in recovery directory\n",
391 /* Keep trying; maybe the others are OK: */
394 nfs4_client_to_reclaim(child
->d_name
.name
);
399 nfsd4_recdir_load(void) {
402 status
= nfsd4_list_rec_dir(rec_dir
.dentry
, load_recdir
);
404 printk("nfsd4: failed loading clients from recovery"
405 " directory %s\n", rec_dir
.dentry
->d_name
.name
);
410 * Hold reference to the recovery directory.
414 nfsd4_init_recdir(char *rec_dirname
)
416 const struct cred
*original_cred
;
419 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
422 BUG_ON(rec_dir_init
);
424 status
= nfs4_save_creds(&original_cred
);
426 printk("NFSD: Unable to change credentials to find recovery"
427 " directory: error %d\n",
432 status
= kern_path(rec_dirname
, LOOKUP_FOLLOW
| LOOKUP_DIRECTORY
,
435 printk("NFSD: unable to find recovery directory %s\n",
440 nfs4_reset_creds(original_cred
);
444 nfsd4_shutdown_recdir(void)