]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - fs/nfsd/nfs4recover.c
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 <asm/scatterlist.h>
47 #include <linux/crypto.h>
50 #define NFSDDBG_FACILITY NFSDDBG_PROC
53 static struct nameidata rec_dir
;
54 static int rec_dir_init
= 0;
57 nfs4_save_user(uid_t
*saveuid
, gid_t
*savegid
)
59 *saveuid
= current
->fsuid
;
60 *savegid
= current
->fsgid
;
66 nfs4_reset_user(uid_t saveuid
, gid_t savegid
)
68 current
->fsuid
= saveuid
;
69 current
->fsgid
= savegid
;
73 md5_to_hex(char *out
, char *md5
)
77 for (i
=0; i
<16; i
++) {
78 unsigned char c
= md5
[i
];
80 *out
++ = '0' + ((c
&0xf0)>>4) + (c
>=0xa0)*('a'-'9'-1);
81 *out
++ = '0' + (c
&0x0f) + ((c
&0x0f)>=0x0a)*('a'-'9'-1);
87 nfs4_make_rec_clidname(char *dname
, struct xdr_netobj
*clname
)
89 struct xdr_netobj cksum
;
90 struct hash_desc desc
;
91 struct scatterlist sg
[1];
92 __be32 status
= nfserr_resource
;
94 dprintk("NFSD: nfs4_make_rec_clidname for %.*s\n",
95 clname
->len
, clname
->data
);
96 desc
.flags
= CRYPTO_TFM_REQ_MAY_SLEEP
;
97 desc
.tfm
= crypto_alloc_hash("md5", 0, CRYPTO_ALG_ASYNC
);
100 cksum
.len
= crypto_hash_digestsize(desc
.tfm
);
101 cksum
.data
= kmalloc(cksum
.len
, GFP_KERNEL
);
102 if (cksum
.data
== NULL
)
105 sg
[0].page
= virt_to_page(clname
->data
);
106 sg
[0].offset
= offset_in_page(clname
->data
);
107 sg
[0].length
= clname
->len
;
109 if (crypto_hash_digest(&desc
, sg
, sg
->length
, cksum
.data
))
112 md5_to_hex(dname
, cksum
.data
);
117 crypto_free_hash(desc
.tfm
);
123 nfsd4_sync_rec_dir(void)
125 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
126 nfsd_sync_dir(rec_dir
.dentry
);
127 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
131 nfsd4_create_clid_dir(struct nfs4_client
*clp
)
133 char *dname
= clp
->cl_recdir
;
134 struct dentry
*dentry
;
139 dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname
);
141 if (!rec_dir_init
|| clp
->cl_firststate
)
144 nfs4_save_user(&uid
, &gid
);
146 /* lock the parent */
147 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
149 dentry
= lookup_one_len(dname
, rec_dir
.dentry
, HEXDIR_LEN
-1);
150 if (IS_ERR(dentry
)) {
151 status
= PTR_ERR(dentry
);
155 if (dentry
->d_inode
) {
156 dprintk("NFSD: nfsd4_create_clid_dir: DIRECTORY EXISTS\n");
159 status
= vfs_mkdir(rec_dir
.dentry
->d_inode
, dentry
, S_IRWXU
);
163 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
165 clp
->cl_firststate
= 1;
166 nfsd4_sync_rec_dir();
168 nfs4_reset_user(uid
, gid
);
169 dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status
);
173 typedef int (recdir_func
)(struct dentry
*, struct dentry
*);
176 struct dentry
*dentry
;
177 struct list_head list
;
180 struct dentry_list_arg
{
181 struct list_head dentries
;
182 struct dentry
*parent
;
186 nfsd4_build_dentrylist(void *arg
, const char *name
, int namlen
,
187 loff_t offset
, u64 ino
, unsigned int d_type
)
189 struct dentry_list_arg
*dla
= arg
;
190 struct list_head
*dentries
= &dla
->dentries
;
191 struct dentry
*parent
= dla
->parent
;
192 struct dentry
*dentry
;
193 struct dentry_list
*child
;
195 if (name
&& isdotent(name
, namlen
))
197 dentry
= lookup_one_len(name
, parent
, namlen
);
199 return PTR_ERR(dentry
);
200 child
= kmalloc(sizeof(*child
), GFP_KERNEL
);
203 child
->dentry
= dentry
;
204 list_add(&child
->list
, dentries
);
209 nfsd4_list_rec_dir(struct dentry
*dir
, recdir_func
*f
)
212 struct dentry_list_arg dla
= {
215 struct list_head
*dentries
= &dla
.dentries
;
216 struct dentry_list
*child
;
224 nfs4_save_user(&uid
, &gid
);
226 filp
= dentry_open(dget(dir
), mntget(rec_dir
.mnt
), O_RDONLY
);
227 status
= PTR_ERR(filp
);
230 INIT_LIST_HEAD(dentries
);
231 status
= vfs_readdir(filp
, nfsd4_build_dentrylist
, &dla
);
233 while (!list_empty(dentries
)) {
234 child
= list_entry(dentries
->next
, struct dentry_list
, list
);
235 status
= f(dir
, child
->dentry
);
238 list_del(&child
->list
);
243 while (!list_empty(dentries
)) {
244 child
= list_entry(dentries
->next
, struct dentry_list
, list
);
245 list_del(&child
->list
);
249 nfs4_reset_user(uid
, gid
);
254 nfsd4_remove_clid_file(struct dentry
*dir
, struct dentry
*dentry
)
258 if (!S_ISREG(dir
->d_inode
->i_mode
)) {
259 printk("nfsd4: non-file found in client recovery directory\n");
262 mutex_lock(&dir
->d_inode
->i_mutex
);
263 status
= vfs_unlink(dir
->d_inode
, dentry
);
264 mutex_unlock(&dir
->d_inode
->i_mutex
);
269 nfsd4_clear_clid_dir(struct dentry
*dir
, struct dentry
*dentry
)
273 /* For now this directory should already be empty, but we empty it of
274 * any regular files anyway, just in case the directory was created by
275 * a kernel from the future.... */
276 nfsd4_list_rec_dir(dentry
, nfsd4_remove_clid_file
);
277 mutex_lock(&dir
->d_inode
->i_mutex
);
278 status
= vfs_rmdir(dir
->d_inode
, dentry
);
279 mutex_unlock(&dir
->d_inode
->i_mutex
);
284 nfsd4_unlink_clid_dir(char *name
, int namlen
)
286 struct dentry
*dentry
;
289 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen
, name
);
291 mutex_lock(&rec_dir
.dentry
->d_inode
->i_mutex
);
292 dentry
= lookup_one_len(name
, rec_dir
.dentry
, namlen
);
293 mutex_unlock(&rec_dir
.dentry
->d_inode
->i_mutex
);
294 if (IS_ERR(dentry
)) {
295 status
= PTR_ERR(dentry
);
299 if (!dentry
->d_inode
)
302 status
= nfsd4_clear_clid_dir(rec_dir
.dentry
, dentry
);
309 nfsd4_remove_clid_dir(struct nfs4_client
*clp
)
315 if (!rec_dir_init
|| !clp
->cl_firststate
)
318 clp
->cl_firststate
= 0;
319 nfs4_save_user(&uid
, &gid
);
320 status
= nfsd4_unlink_clid_dir(clp
->cl_recdir
, HEXDIR_LEN
-1);
321 nfs4_reset_user(uid
, gid
);
323 nfsd4_sync_rec_dir();
325 printk("NFSD: Failed to remove expired client state directory"
326 " %.*s\n", HEXDIR_LEN
, clp
->cl_recdir
);
331 purge_old(struct dentry
*parent
, struct dentry
*child
)
335 if (nfs4_has_reclaimed_state(child
->d_name
.name
))
338 status
= nfsd4_clear_clid_dir(parent
, child
);
340 printk("failed to remove client recovery directory %s\n",
342 /* Keep trying, success or failure: */
347 nfsd4_recdir_purge_old(void) {
352 status
= nfsd4_list_rec_dir(rec_dir
.dentry
, purge_old
);
354 nfsd4_sync_rec_dir();
356 printk("nfsd4: failed to purge old clients from recovery"
357 " directory %s\n", rec_dir
.dentry
->d_name
.name
);
362 load_recdir(struct dentry
*parent
, struct dentry
*child
)
364 if (child
->d_name
.len
!= HEXDIR_LEN
- 1) {
365 printk("nfsd4: illegal name %s in recovery directory\n",
367 /* Keep trying; maybe the others are OK: */
370 nfs4_client_to_reclaim(child
->d_name
.name
);
375 nfsd4_recdir_load(void) {
378 status
= nfsd4_list_rec_dir(rec_dir
.dentry
, load_recdir
);
380 printk("nfsd4: failed loading clients from recovery"
381 " directory %s\n", rec_dir
.dentry
->d_name
.name
);
386 * Hold reference to the recovery directory.
390 nfsd4_init_recdir(char *rec_dirname
)
396 printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
399 BUG_ON(rec_dir_init
);
401 nfs4_save_user(&uid
, &gid
);
403 status
= path_lookup(rec_dirname
, LOOKUP_FOLLOW
| LOOKUP_DIRECTORY
,
406 printk("NFSD: unable to find recovery directory %s\n",
411 nfs4_reset_user(uid
, gid
);
415 nfsd4_shutdown_recdir(void)
420 path_release(&rec_dir
);