include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / fs / nfsd / nfs4recover.c
1 /*
2 *  Copyright (c) 2004 The Regents of the University of Michigan.
3 *  All rights reserved.
4 *
5 *  Andy Adamson <andros@citi.umich.edu>
6 *
7 *  Redistribution and use in source and binary forms, with or without
8 *  modification, are permitted provided that the following conditions
9 *  are met:
10 *
11 *  1. Redistributions of source code must retain the above copyright
12 *     notice, this list of conditions and the following disclaimer.
13 *  2. Redistributions in binary form must reproduce the above copyright
14 *     notice, this list of conditions and the following disclaimer in the
15 *     documentation and/or other materials provided with the distribution.
16 *  3. Neither the name of the University nor the names of its
17 *     contributors may be used to endorse or promote products derived
18 *     from this software without specific prior written permission.
19 *
20 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
21 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
22 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
23 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
27 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
28 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
29 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 *
32 */
33
34 #include <linux/file.h>
35 #include <linux/slab.h>
36 #include <linux/namei.h>
37 #include <linux/crypto.h>
38 #include <linux/sched.h>
39
40 #include "nfsd.h"
41 #include "state.h"
42 #include "vfs.h"
43
44 #define NFSDDBG_FACILITY                NFSDDBG_PROC
45
46 /* Globals */
47 static struct path rec_dir;
48 static int rec_dir_init = 0;
49
50 static int
51 nfs4_save_creds(const struct cred **original_creds)
52 {
53         struct cred *new;
54
55         new = prepare_creds();
56         if (!new)
57                 return -ENOMEM;
58
59         new->fsuid = 0;
60         new->fsgid = 0;
61         *original_creds = override_creds(new);
62         put_cred(new);
63         return 0;
64 }
65
66 static void
67 nfs4_reset_creds(const struct cred *original)
68 {
69         revert_creds(original);
70 }
71
72 static void
73 md5_to_hex(char *out, char *md5)
74 {
75         int i;
76
77         for (i=0; i<16; i++) {
78                 unsigned char c = md5[i];
79
80                 *out++ = '0' + ((c&0xf0)>>4) + (c>=0xa0)*('a'-'9'-1);
81                 *out++ = '0' + (c&0x0f) + ((c&0x0f)>=0x0a)*('a'-'9'-1);
82         }
83         *out = '\0';
84 }
85
86 __be32
87 nfs4_make_rec_clidname(char *dname, struct xdr_netobj *clname)
88 {
89         struct xdr_netobj cksum;
90         struct hash_desc desc;
91         struct scatterlist sg;
92         __be32 status = nfserr_resource;
93
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);
98         if (IS_ERR(desc.tfm))
99                 goto out_no_tfm;
100         cksum.len = crypto_hash_digestsize(desc.tfm);
101         cksum.data = kmalloc(cksum.len, GFP_KERNEL);
102         if (cksum.data == NULL)
103                 goto out;
104
105         sg_init_one(&sg, clname->data, clname->len);
106
107         if (crypto_hash_digest(&desc, &sg, sg.length, cksum.data))
108                 goto out;
109
110         md5_to_hex(dname, cksum.data);
111
112         status = nfs_ok;
113 out:
114         kfree(cksum.data);
115         crypto_free_hash(desc.tfm);
116 out_no_tfm:
117         return status;
118 }
119
120 static void
121 nfsd4_sync_rec_dir(void)
122 {
123         vfs_fsync(NULL, rec_dir.dentry, 0);
124 }
125
126 int
127 nfsd4_create_clid_dir(struct nfs4_client *clp)
128 {
129         const struct cred *original_cred;
130         char *dname = clp->cl_recdir;
131         struct dentry *dentry;
132         int status;
133
134         dprintk("NFSD: nfsd4_create_clid_dir for \"%s\"\n", dname);
135
136         if (!rec_dir_init || clp->cl_firststate)
137                 return 0;
138
139         status = nfs4_save_creds(&original_cred);
140         if (status < 0)
141                 return status;
142
143         /* lock the parent */
144         mutex_lock(&rec_dir.dentry->d_inode->i_mutex);
145
146         dentry = lookup_one_len(dname, rec_dir.dentry, HEXDIR_LEN-1);
147         if (IS_ERR(dentry)) {
148                 status = PTR_ERR(dentry);
149                 goto out_unlock;
150         }
151         status = -EEXIST;
152         if (dentry->d_inode) {
153                 dprintk("NFSD: nfsd4_create_clid_dir: DIRECTORY EXISTS\n");
154                 goto out_put;
155         }
156         status = mnt_want_write(rec_dir.mnt);
157         if (status)
158                 goto out_put;
159         status = vfs_mkdir(rec_dir.dentry->d_inode, dentry, S_IRWXU);
160         mnt_drop_write(rec_dir.mnt);
161 out_put:
162         dput(dentry);
163 out_unlock:
164         mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
165         if (status == 0) {
166                 clp->cl_firststate = 1;
167                 nfsd4_sync_rec_dir();
168         }
169         nfs4_reset_creds(original_cred);
170         dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status);
171         return status;
172 }
173
174 typedef int (recdir_func)(struct dentry *, struct dentry *);
175
176 struct name_list {
177         char name[HEXDIR_LEN];
178         struct list_head list;
179 };
180
181 static int
182 nfsd4_build_namelist(void *arg, const char *name, int namlen,
183                 loff_t offset, u64 ino, unsigned int d_type)
184 {
185         struct list_head *names = arg;
186         struct name_list *entry;
187
188         if (namlen != HEXDIR_LEN - 1)
189                 return 0;
190         entry = kmalloc(sizeof(struct name_list), GFP_KERNEL);
191         if (entry == NULL)
192                 return -ENOMEM;
193         memcpy(entry->name, name, HEXDIR_LEN - 1);
194         entry->name[HEXDIR_LEN - 1] = '\0';
195         list_add(&entry->list, names);
196         return 0;
197 }
198
199 static int
200 nfsd4_list_rec_dir(struct dentry *dir, recdir_func *f)
201 {
202         const struct cred *original_cred;
203         struct file *filp;
204         LIST_HEAD(names);
205         struct name_list *entry;
206         struct dentry *dentry;
207         int status;
208
209         if (!rec_dir_init)
210                 return 0;
211
212         status = nfs4_save_creds(&original_cred);
213         if (status < 0)
214                 return status;
215
216         filp = dentry_open(dget(dir), mntget(rec_dir.mnt), O_RDONLY,
217                            current_cred());
218         status = PTR_ERR(filp);
219         if (IS_ERR(filp))
220                 goto out;
221         status = vfs_readdir(filp, nfsd4_build_namelist, &names);
222         fput(filp);
223         mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
224         while (!list_empty(&names)) {
225                 entry = list_entry(names.next, struct name_list, list);
226
227                 dentry = lookup_one_len(entry->name, dir, HEXDIR_LEN-1);
228                 if (IS_ERR(dentry)) {
229                         status = PTR_ERR(dentry);
230                         break;
231                 }
232                 status = f(dir, dentry);
233                 dput(dentry);
234                 if (status)
235                         break;
236                 list_del(&entry->list);
237                 kfree(entry);
238         }
239         mutex_unlock(&dir->d_inode->i_mutex);
240 out:
241         while (!list_empty(&names)) {
242                 entry = list_entry(names.next, struct name_list, list);
243                 list_del(&entry->list);
244                 kfree(entry);
245         }
246         nfs4_reset_creds(original_cred);
247         return status;
248 }
249
250 static int
251 nfsd4_unlink_clid_dir(char *name, int namlen)
252 {
253         struct dentry *dentry;
254         int status;
255
256         dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name);
257
258         mutex_lock_nested(&rec_dir.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
259         dentry = lookup_one_len(name, rec_dir.dentry, namlen);
260         if (IS_ERR(dentry)) {
261                 status = PTR_ERR(dentry);
262                 goto out_unlock;
263         }
264         status = -ENOENT;
265         if (!dentry->d_inode)
266                 goto out;
267         status = vfs_rmdir(rec_dir.dentry->d_inode, dentry);
268 out:
269         dput(dentry);
270 out_unlock:
271         mutex_unlock(&rec_dir.dentry->d_inode->i_mutex);
272         return status;
273 }
274
275 void
276 nfsd4_remove_clid_dir(struct nfs4_client *clp)
277 {
278         const struct cred *original_cred;
279         int status;
280
281         if (!rec_dir_init || !clp->cl_firststate)
282                 return;
283
284         status = mnt_want_write(rec_dir.mnt);
285         if (status)
286                 goto out;
287         clp->cl_firststate = 0;
288
289         status = nfs4_save_creds(&original_cred);
290         if (status < 0)
291                 goto out;
292
293         status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
294         nfs4_reset_creds(original_cred);
295         if (status == 0)
296                 nfsd4_sync_rec_dir();
297         mnt_drop_write(rec_dir.mnt);
298 out:
299         if (status)
300                 printk("NFSD: Failed to remove expired client state directory"
301                                 " %.*s\n", HEXDIR_LEN, clp->cl_recdir);
302         return;
303 }
304
305 static int
306 purge_old(struct dentry *parent, struct dentry *child)
307 {
308         int status;
309
310         /* note: we currently use this path only for minorversion 0 */
311         if (nfs4_has_reclaimed_state(child->d_name.name, false))
312                 return 0;
313
314         status = vfs_rmdir(parent->d_inode, child);
315         if (status)
316                 printk("failed to remove client recovery directory %s\n",
317                                 child->d_name.name);
318         /* Keep trying, success or failure: */
319         return 0;
320 }
321
322 void
323 nfsd4_recdir_purge_old(void) {
324         int status;
325
326         if (!rec_dir_init)
327                 return;
328         status = mnt_want_write(rec_dir.mnt);
329         if (status)
330                 goto out;
331         status = nfsd4_list_rec_dir(rec_dir.dentry, purge_old);
332         if (status == 0)
333                 nfsd4_sync_rec_dir();
334         mnt_drop_write(rec_dir.mnt);
335 out:
336         if (status)
337                 printk("nfsd4: failed to purge old clients from recovery"
338                         " directory %s\n", rec_dir.dentry->d_name.name);
339 }
340
341 static int
342 load_recdir(struct dentry *parent, struct dentry *child)
343 {
344         if (child->d_name.len != HEXDIR_LEN - 1) {
345                 printk("nfsd4: illegal name %s in recovery directory\n",
346                                 child->d_name.name);
347                 /* Keep trying; maybe the others are OK: */
348                 return 0;
349         }
350         nfs4_client_to_reclaim(child->d_name.name);
351         return 0;
352 }
353
354 int
355 nfsd4_recdir_load(void) {
356         int status;
357
358         status = nfsd4_list_rec_dir(rec_dir.dentry, load_recdir);
359         if (status)
360                 printk("nfsd4: failed loading clients from recovery"
361                         " directory %s\n", rec_dir.dentry->d_name.name);
362         return status;
363 }
364
365 /*
366  * Hold reference to the recovery directory.
367  */
368
369 void
370 nfsd4_init_recdir(char *rec_dirname)
371 {
372         const struct cred *original_cred;
373         int status;
374
375         printk("NFSD: Using %s as the NFSv4 state recovery directory\n",
376                         rec_dirname);
377
378         BUG_ON(rec_dir_init);
379
380         status = nfs4_save_creds(&original_cred);
381         if (status < 0) {
382                 printk("NFSD: Unable to change credentials to find recovery"
383                        " directory: error %d\n",
384                        status);
385                 return;
386         }
387
388         status = kern_path(rec_dirname, LOOKUP_FOLLOW | LOOKUP_DIRECTORY,
389                         &rec_dir);
390         if (status)
391                 printk("NFSD: unable to find recovery directory %s\n",
392                                 rec_dirname);
393
394         if (!status)
395                 rec_dir_init = 1;
396         nfs4_reset_creds(original_cred);
397 }
398
399 void
400 nfsd4_shutdown_recdir(void)
401 {
402         if (!rec_dir_init)
403                 return;
404         rec_dir_init = 0;
405         path_put(&rec_dir);
406 }