- Update Xen patches to 4.0-final.
[opensuse:kernel.git] / fs / exportfs / expfs.c
1 /*
2  * Copyright (C) Neil Brown 2002
3  * Copyright (C) Christoph Hellwig 2007
4  *
5  * This file contains the code mapping from inodes to NFS file handles,
6  * and for mapping back from file handles to dentries.
7  *
8  * For details on why we do all the strange and hairy things in here
9  * take a look at Documentation/filesystems/nfs/Exporting.
10  */
11 #include <linux/exportfs.h>
12 #include <linux/fs.h>
13 #include <linux/file.h>
14 #include <linux/module.h>
15 #include <linux/mount.h>
16 #include <linux/namei.h>
17 #include <linux/sched.h>
18
19 #define dprintk(fmt, args...) do{}while(0)
20
21
22 static int get_name(const struct path *path, char *name, struct dentry *child);
23
24
25 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26                 char *name, struct dentry *child)
27 {
28         const struct export_operations *nop = dir->d_sb->s_export_op;
29         struct path path = {.mnt = mnt, .dentry = dir};
30
31         if (nop->get_name)
32                 return nop->get_name(dir, name, child);
33         else
34                 return get_name(&path, name, child);
35 }
36
37 /*
38  * Check if the dentry or any of it's aliases is acceptable.
39  */
40 static struct dentry *
41 find_acceptable_alias(struct dentry *result,
42                 int (*acceptable)(void *context, struct dentry *dentry),
43                 void *context)
44 {
45         struct dentry *dentry, *toput = NULL;
46         struct inode *inode;
47
48         if (acceptable(context, result))
49                 return result;
50
51         inode = result->d_inode;
52         spin_lock(&inode->i_lock);
53         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
54                 dget(dentry);
55                 spin_unlock(&inode->i_lock);
56                 if (toput)
57                         dput(toput);
58                 if (dentry != result && acceptable(context, dentry)) {
59                         dput(result);
60                         return dentry;
61                 }
62                 spin_lock(&inode->i_lock);
63                 toput = dentry;
64         }
65         spin_unlock(&inode->i_lock);
66
67         if (toput)
68                 dput(toput);
69         return NULL;
70 }
71
72 static bool dentry_connected(struct dentry *dentry)
73 {
74         dget(dentry);
75         while (dentry->d_flags & DCACHE_DISCONNECTED) {
76                 struct dentry *parent = dget_parent(dentry);
77
78                 dput(dentry);
79                 if (IS_ROOT(dentry)) {
80                         dput(parent);
81                         return false;
82                 }
83                 dentry = parent;
84         }
85         dput(dentry);
86         return true;
87 }
88
89 static void clear_disconnected(struct dentry *dentry)
90 {
91         dget(dentry);
92         while (dentry->d_flags & DCACHE_DISCONNECTED) {
93                 struct dentry *parent = dget_parent(dentry);
94
95                 WARN_ON_ONCE(IS_ROOT(dentry));
96
97                 spin_lock(&dentry->d_lock);
98                 dentry->d_flags &= ~DCACHE_DISCONNECTED;
99                 spin_unlock(&dentry->d_lock);
100
101                 dput(dentry);
102                 dentry = parent;
103         }
104         dput(dentry);
105 }
106
107 /*
108  * Reconnect a directory dentry with its parent.
109  *
110  * This can return a dentry, or NULL, or an error.
111  *
112  * In the first case the returned dentry is the parent of the given
113  * dentry, and may itself need to be reconnected to its parent.
114  *
115  * In the NULL case, a concurrent VFS operation has either renamed or
116  * removed this directory.  The concurrent operation has reconnected our
117  * dentry, so we no longer need to.
118  */
119 static struct dentry *reconnect_one(struct vfsmount *mnt,
120                 struct dentry *dentry, char *nbuf)
121 {
122         struct dentry *parent;
123         struct dentry *tmp;
124         int err;
125
126         parent = ERR_PTR(-EACCES);
127         mutex_lock(&dentry->d_inode->i_mutex);
128         if (mnt->mnt_sb->s_export_op->get_parent)
129                 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
130         mutex_unlock(&dentry->d_inode->i_mutex);
131
132         if (IS_ERR(parent)) {
133                 dprintk("%s: get_parent of %ld failed, err %d\n",
134                         __func__, dentry->d_inode->i_ino, PTR_ERR(parent));
135                 return parent;
136         }
137
138         dprintk("%s: find name of %lu in %lu\n", __func__,
139                 dentry->d_inode->i_ino, parent->d_inode->i_ino);
140         err = exportfs_get_name(mnt, parent, nbuf, dentry);
141         if (err == -ENOENT)
142                 goto out_reconnected;
143         if (err)
144                 goto out_err;
145         dprintk("%s: found name: %s\n", __func__, nbuf);
146         mutex_lock(&parent->d_inode->i_mutex);
147         tmp = lookup_one_len(nbuf, parent, strlen(nbuf));
148         mutex_unlock(&parent->d_inode->i_mutex);
149         if (IS_ERR(tmp)) {
150                 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
151                 goto out_err;
152         }
153         if (tmp != dentry) {
154                 dput(tmp);
155                 goto out_reconnected;
156         }
157         dput(tmp);
158         if (IS_ROOT(dentry)) {
159                 err = -ESTALE;
160                 goto out_err;
161         }
162         return parent;
163
164 out_err:
165         dput(parent);
166         return ERR_PTR(err);
167 out_reconnected:
168         dput(parent);
169         /*
170          * Someone must have renamed our entry into another parent, in
171          * which case it has been reconnected by the rename.
172          *
173          * Or someone removed it entirely, in which case filehandle
174          * lookup will succeed but the directory is now IS_DEAD and
175          * subsequent operations on it will fail.
176          *
177          * Alternatively, maybe there was no race at all, and the
178          * filesystem is just corrupt and gave us a parent that doesn't
179          * actually contain any entry pointing to this inode.  So,
180          * double check that this worked and return -ESTALE if not:
181          */
182         if (!dentry_connected(dentry))
183                 return ERR_PTR(-ESTALE);
184         return NULL;
185 }
186
187 /*
188  * Make sure target_dir is fully connected to the dentry tree.
189  *
190  * On successful return, DCACHE_DISCONNECTED will be cleared on
191  * target_dir, and target_dir->d_parent->...->d_parent will reach the
192  * root of the filesystem.
193  *
194  * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
195  * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
196  * set but already be connected.  In that case we'll verify the
197  * connection to root and then clear the flag.
198  *
199  * Note that target_dir could be removed by a concurrent operation.  In
200  * that case reconnect_path may still succeed with target_dir fully
201  * connected, but further operations using the filehandle will fail when
202  * necessary (due to S_DEAD being set on the directory).
203  */
204 static int
205 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
206 {
207         struct dentry *dentry, *parent;
208
209         dentry = dget(target_dir);
210
211         while (dentry->d_flags & DCACHE_DISCONNECTED) {
212                 BUG_ON(dentry == mnt->mnt_sb->s_root);
213
214                 if (IS_ROOT(dentry))
215                         parent = reconnect_one(mnt, dentry, nbuf);
216                 else
217                         parent = dget_parent(dentry);
218
219                 if (!parent)
220                         break;
221                 dput(dentry);
222                 if (IS_ERR(parent))
223                         return PTR_ERR(parent);
224                 dentry = parent;
225         }
226         dput(dentry);
227         clear_disconnected(target_dir);
228         return 0;
229 }
230
231 struct getdents_callback {
232         struct dir_context ctx;
233         char *name;             /* name that was found. It already points to a
234                                    buffer NAME_MAX+1 is size */
235         u64 ino;                /* the inum we are looking for */
236         int found;              /* inode matched? */
237         int sequence;           /* sequence counter */
238 };
239
240 /*
241  * A rather strange filldir function to capture
242  * the name matching the specified inode number.
243  */
244 static int filldir_one(struct dir_context *ctx, const char *name, int len,
245                         loff_t pos, u64 ino, unsigned int d_type)
246 {
247         struct getdents_callback *buf =
248                 container_of(ctx, struct getdents_callback, ctx);
249         int result = 0;
250
251         buf->sequence++;
252         if (buf->ino == ino && len <= NAME_MAX) {
253                 memcpy(buf->name, name, len);
254                 buf->name[len] = '\0';
255                 buf->found = 1;
256                 result = -1;
257         }
258         return result;
259 }
260
261 /**
262  * get_name - default export_operations->get_name function
263  * @path:   the directory in which to find a name
264  * @name:   a pointer to a %NAME_MAX+1 char buffer to store the name
265  * @child:  the dentry for the child directory.
266  *
267  * calls readdir on the parent until it finds an entry with
268  * the same inode number as the child, and returns that.
269  */
270 static int get_name(const struct path *path, char *name, struct dentry *child)
271 {
272         const struct cred *cred = current_cred();
273         struct inode *dir = path->dentry->d_inode;
274         int error;
275         struct file *file;
276         struct kstat stat;
277         struct path child_path = {
278                 .mnt = path->mnt,
279                 .dentry = child,
280         };
281         struct getdents_callback buffer = {
282                 .ctx.actor = filldir_one,
283                 .name = name,
284         };
285
286         error = -ENOTDIR;
287         if (!dir || !S_ISDIR(dir->i_mode))
288                 goto out;
289         error = -EINVAL;
290         if (!dir->i_fop)
291                 goto out;
292         /*
293          * inode->i_ino is unsigned long, kstat->ino is u64, so the
294          * former would be insufficient on 32-bit hosts when the
295          * filesystem supports 64-bit inode numbers.  So we need to
296          * actually call ->getattr, not just read i_ino:
297          */
298         error = vfs_getattr_nosec(&child_path, &stat);
299         if (error)
300                 return error;
301         buffer.ino = stat.ino;
302         /*
303          * Open the directory ...
304          */
305         file = dentry_open(path, O_RDONLY, cred);
306         error = PTR_ERR(file);
307         if (IS_ERR(file))
308                 goto out;
309
310         error = -EINVAL;
311         if (!file->f_op->iterate)
312                 goto out_close;
313
314         buffer.sequence = 0;
315         while (1) {
316                 int old_seq = buffer.sequence;
317
318                 error = iterate_dir(file, &buffer.ctx);
319                 if (buffer.found) {
320                         error = 0;
321                         break;
322                 }
323
324                 if (error < 0)
325                         break;
326
327                 error = -ENOENT;
328                 if (old_seq == buffer.sequence)
329                         break;
330         }
331
332 out_close:
333         fput(file);
334 out:
335         return error;
336 }
337
338 /**
339  * export_encode_fh - default export_operations->encode_fh function
340  * @inode:   the object to encode
341  * @fid:     where to store the file handle fragment
342  * @max_len: maximum length to store there
343  * @parent:  parent directory inode, if wanted
344  *
345  * This default encode_fh function assumes that the 32 inode number
346  * is suitable for locating an inode, and that the generation number
347  * can be used to check that it is still valid.  It places them in the
348  * filehandle fragment where export_decode_fh expects to find them.
349  */
350 static int export_encode_fh(struct inode *inode, struct fid *fid,
351                 int *max_len, struct inode *parent)
352 {
353         int len = *max_len;
354         int type = FILEID_INO32_GEN;
355
356         if (parent && (len < 4)) {
357                 *max_len = 4;
358                 return FILEID_INVALID;
359         } else if (len < 2) {
360                 *max_len = 2;
361                 return FILEID_INVALID;
362         }
363
364         len = 2;
365         fid->i32.ino = inode->i_ino;
366         fid->i32.gen = inode->i_generation;
367         if (parent) {
368                 fid->i32.parent_ino = parent->i_ino;
369                 fid->i32.parent_gen = parent->i_generation;
370                 len = 4;
371                 type = FILEID_INO32_GEN_PARENT;
372         }
373         *max_len = len;
374         return type;
375 }
376
377 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
378                              int *max_len, struct inode *parent)
379 {
380         const struct export_operations *nop = inode->i_sb->s_export_op;
381
382         if (nop && nop->encode_fh)
383                 return nop->encode_fh(inode, fid->raw, max_len, parent);
384
385         return export_encode_fh(inode, fid, max_len, parent);
386 }
387 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
388
389 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
390                 int connectable)
391 {
392         int error;
393         struct dentry *p = NULL;
394         struct inode *inode = dentry->d_inode, *parent = NULL;
395
396         if (connectable && !S_ISDIR(inode->i_mode)) {
397                 p = dget_parent(dentry);
398                 /*
399                  * note that while p might've ceased to be our parent already,
400                  * it's still pinned by and still positive.
401                  */
402                 parent = p->d_inode;
403         }
404
405         error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
406         dput(p);
407
408         return error;
409 }
410 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
411
412 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
413                 int fh_len, int fileid_type,
414                 int (*acceptable)(void *, struct dentry *), void *context)
415 {
416         const struct export_operations *nop = mnt->mnt_sb->s_export_op;
417         struct dentry *result, *alias;
418         char nbuf[NAME_MAX+1];
419         int err;
420
421         /*
422          * Try to get any dentry for the given file handle from the filesystem.
423          */
424         if (!nop || !nop->fh_to_dentry)
425                 return ERR_PTR(-ESTALE);
426         result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
427         if (!result)
428                 result = ERR_PTR(-ESTALE);
429         if (IS_ERR(result))
430                 return result;
431
432         if (d_is_dir(result)) {
433                 /*
434                  * This request is for a directory.
435                  *
436                  * On the positive side there is only one dentry for each
437                  * directory inode.  On the negative side this implies that we
438                  * to ensure our dentry is connected all the way up to the
439                  * filesystem root.
440                  */
441                 if (result->d_flags & DCACHE_DISCONNECTED) {
442                         err = reconnect_path(mnt, result, nbuf);
443                         if (err)
444                                 goto err_result;
445                 }
446
447                 if (!acceptable(context, result)) {
448                         err = -EACCES;
449                         goto err_result;
450                 }
451
452                 return result;
453         } else {
454                 /*
455                  * It's not a directory.  Life is a little more complicated.
456                  */
457                 struct dentry *target_dir, *nresult;
458
459                 /*
460                  * See if either the dentry we just got from the filesystem
461                  * or any alias for it is acceptable.  This is always true
462                  * if this filesystem is exported without the subtreecheck
463                  * option.  If the filesystem is exported with the subtree
464                  * check option there's a fair chance we need to look at
465                  * the parent directory in the file handle and make sure
466                  * it's connected to the filesystem root.
467                  */
468                 alias = find_acceptable_alias(result, acceptable, context);
469                 if (alias)
470                         return alias;
471
472                 /*
473                  * Try to extract a dentry for the parent directory from the
474                  * file handle.  If this fails we'll have to give up.
475                  */
476                 err = -ESTALE;
477                 if (!nop->fh_to_parent)
478                         goto err_result;
479
480                 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
481                                 fh_len, fileid_type);
482                 if (!target_dir)
483                         goto err_result;
484                 err = PTR_ERR(target_dir);
485                 if (IS_ERR(target_dir))
486                         goto err_result;
487
488                 /*
489                  * And as usual we need to make sure the parent directory is
490                  * connected to the filesystem root.  The VFS really doesn't
491                  * like disconnected directories..
492                  */
493                 err = reconnect_path(mnt, target_dir, nbuf);
494                 if (err) {
495                         dput(target_dir);
496                         goto err_result;
497                 }
498
499                 /*
500                  * Now that we've got both a well-connected parent and a
501                  * dentry for the inode we're after, make sure that our
502                  * inode is actually connected to the parent.
503                  */
504                 err = exportfs_get_name(mnt, target_dir, nbuf, result);
505                 if (!err) {
506                         mutex_lock(&target_dir->d_inode->i_mutex);
507                         nresult = lookup_one_len(nbuf, target_dir,
508                                                  strlen(nbuf));
509                         mutex_unlock(&target_dir->d_inode->i_mutex);
510                         if (!IS_ERR(nresult)) {
511                                 if (nresult->d_inode) {
512                                         dput(result);
513                                         result = nresult;
514                                 } else
515                                         dput(nresult);
516                         }
517                 }
518
519                 /*
520                  * At this point we are done with the parent, but it's pinned
521                  * by the child dentry anyway.
522                  */
523                 dput(target_dir);
524
525                 /*
526                  * And finally make sure the dentry is actually acceptable
527                  * to NFSD.
528                  */
529                 alias = find_acceptable_alias(result, acceptable, context);
530                 if (!alias) {
531                         err = -EACCES;
532                         goto err_result;
533                 }
534
535                 return alias;
536         }
537
538  err_result:
539         dput(result);
540         return ERR_PTR(err);
541 }
542 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
543
544 MODULE_LICENSE("GPL");