Loading...
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
22static int get_name(const struct path *path, char *name, struct dentry *child);
23
24
25static 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 */
40static struct dentry *
41find_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
72static 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
89static 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 */
119static 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 inode_lock(dentry->d_inode);
128 if (mnt->mnt_sb->s_export_op->get_parent)
129 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
130 inode_unlock(dentry->d_inode);
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 inode_lock(parent->d_inode);
147 tmp = lookup_one_len(nbuf, parent, strlen(nbuf));
148 inode_unlock(parent->d_inode);
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
164out_err:
165 dput(parent);
166 return ERR_PTR(err);
167out_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 */
204static int
205reconnect_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
231struct 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 */
244static 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 */
270static 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
332out_close:
333 fput(file);
334out:
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 */
350static 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
377int 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}
387EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
388
389int 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}
410EXPORT_SYMBOL_GPL(exportfs_encode_fh);
411
412struct 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 inode_lock(target_dir->d_inode);
507 nresult = lookup_one_len(nbuf, target_dir,
508 strlen(nbuf));
509 inode_unlock(target_dir->d_inode);
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}
542EXPORT_SYMBOL_GPL(exportfs_decode_fh);
543
544MODULE_LICENSE("GPL");
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
22static int get_name(const struct path *path, char *name, struct dentry *child);
23
24
25static 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 */
40static struct dentry *
41find_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_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
72static 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
89static 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 */
119static 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
164out_err:
165 dput(parent);
166 return ERR_PTR(err);
167out_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 */
204static int
205reconnect_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
231struct 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 */
244static int filldir_one(void * __buf, const char * name, int len,
245 loff_t pos, u64 ino, unsigned int d_type)
246{
247 struct getdents_callback *buf = __buf;
248 int result = 0;
249
250 buf->sequence++;
251 if (buf->ino == ino && len <= NAME_MAX) {
252 memcpy(buf->name, name, len);
253 buf->name[len] = '\0';
254 buf->found = 1;
255 result = -1;
256 }
257 return result;
258}
259
260/**
261 * get_name - default export_operations->get_name function
262 * @dentry: the directory in which to find a name
263 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
264 * @child: the dentry for the child directory.
265 *
266 * calls readdir on the parent until it finds an entry with
267 * the same inode number as the child, and returns that.
268 */
269static int get_name(const struct path *path, char *name, struct dentry *child)
270{
271 const struct cred *cred = current_cred();
272 struct inode *dir = path->dentry->d_inode;
273 int error;
274 struct file *file;
275 struct kstat stat;
276 struct path child_path = {
277 .mnt = path->mnt,
278 .dentry = child,
279 };
280 struct getdents_callback buffer = {
281 .ctx.actor = filldir_one,
282 .name = name,
283 };
284
285 error = -ENOTDIR;
286 if (!dir || !S_ISDIR(dir->i_mode))
287 goto out;
288 error = -EINVAL;
289 if (!dir->i_fop)
290 goto out;
291 /*
292 * inode->i_ino is unsigned long, kstat->ino is u64, so the
293 * former would be insufficient on 32-bit hosts when the
294 * filesystem supports 64-bit inode numbers. So we need to
295 * actually call ->getattr, not just read i_ino:
296 */
297 error = vfs_getattr_nosec(&child_path, &stat);
298 if (error)
299 return error;
300 buffer.ino = stat.ino;
301 /*
302 * Open the directory ...
303 */
304 file = dentry_open(path, O_RDONLY, cred);
305 error = PTR_ERR(file);
306 if (IS_ERR(file))
307 goto out;
308
309 error = -EINVAL;
310 if (!file->f_op->iterate)
311 goto out_close;
312
313 buffer.sequence = 0;
314 while (1) {
315 int old_seq = buffer.sequence;
316
317 error = iterate_dir(file, &buffer.ctx);
318 if (buffer.found) {
319 error = 0;
320 break;
321 }
322
323 if (error < 0)
324 break;
325
326 error = -ENOENT;
327 if (old_seq == buffer.sequence)
328 break;
329 }
330
331out_close:
332 fput(file);
333out:
334 return error;
335}
336
337/**
338 * export_encode_fh - default export_operations->encode_fh function
339 * @inode: the object to encode
340 * @fh: where to store the file handle fragment
341 * @max_len: maximum length to store there
342 * @parent: parent directory inode, if wanted
343 *
344 * This default encode_fh function assumes that the 32 inode number
345 * is suitable for locating an inode, and that the generation number
346 * can be used to check that it is still valid. It places them in the
347 * filehandle fragment where export_decode_fh expects to find them.
348 */
349static int export_encode_fh(struct inode *inode, struct fid *fid,
350 int *max_len, struct inode *parent)
351{
352 int len = *max_len;
353 int type = FILEID_INO32_GEN;
354
355 if (parent && (len < 4)) {
356 *max_len = 4;
357 return FILEID_INVALID;
358 } else if (len < 2) {
359 *max_len = 2;
360 return FILEID_INVALID;
361 }
362
363 len = 2;
364 fid->i32.ino = inode->i_ino;
365 fid->i32.gen = inode->i_generation;
366 if (parent) {
367 fid->i32.parent_ino = parent->i_ino;
368 fid->i32.parent_gen = parent->i_generation;
369 len = 4;
370 type = FILEID_INO32_GEN_PARENT;
371 }
372 *max_len = len;
373 return type;
374}
375
376int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
377 int *max_len, struct inode *parent)
378{
379 const struct export_operations *nop = inode->i_sb->s_export_op;
380
381 if (nop && nop->encode_fh)
382 return nop->encode_fh(inode, fid->raw, max_len, parent);
383
384 return export_encode_fh(inode, fid, max_len, parent);
385}
386EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
387
388int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
389 int connectable)
390{
391 int error;
392 struct dentry *p = NULL;
393 struct inode *inode = dentry->d_inode, *parent = NULL;
394
395 if (connectable && !S_ISDIR(inode->i_mode)) {
396 p = dget_parent(dentry);
397 /*
398 * note that while p might've ceased to be our parent already,
399 * it's still pinned by and still positive.
400 */
401 parent = p->d_inode;
402 }
403
404 error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
405 dput(p);
406
407 return error;
408}
409EXPORT_SYMBOL_GPL(exportfs_encode_fh);
410
411struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
412 int fh_len, int fileid_type,
413 int (*acceptable)(void *, struct dentry *), void *context)
414{
415 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
416 struct dentry *result, *alias;
417 char nbuf[NAME_MAX+1];
418 int err;
419
420 /*
421 * Try to get any dentry for the given file handle from the filesystem.
422 */
423 if (!nop || !nop->fh_to_dentry)
424 return ERR_PTR(-ESTALE);
425 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
426 if (!result)
427 result = ERR_PTR(-ESTALE);
428 if (IS_ERR(result))
429 return result;
430
431 if (S_ISDIR(result->d_inode->i_mode)) {
432 /*
433 * This request is for a directory.
434 *
435 * On the positive side there is only one dentry for each
436 * directory inode. On the negative side this implies that we
437 * to ensure our dentry is connected all the way up to the
438 * filesystem root.
439 */
440 if (result->d_flags & DCACHE_DISCONNECTED) {
441 err = reconnect_path(mnt, result, nbuf);
442 if (err)
443 goto err_result;
444 }
445
446 if (!acceptable(context, result)) {
447 err = -EACCES;
448 goto err_result;
449 }
450
451 return result;
452 } else {
453 /*
454 * It's not a directory. Life is a little more complicated.
455 */
456 struct dentry *target_dir, *nresult;
457
458 /*
459 * See if either the dentry we just got from the filesystem
460 * or any alias for it is acceptable. This is always true
461 * if this filesystem is exported without the subtreecheck
462 * option. If the filesystem is exported with the subtree
463 * check option there's a fair chance we need to look at
464 * the parent directory in the file handle and make sure
465 * it's connected to the filesystem root.
466 */
467 alias = find_acceptable_alias(result, acceptable, context);
468 if (alias)
469 return alias;
470
471 /*
472 * Try to extract a dentry for the parent directory from the
473 * file handle. If this fails we'll have to give up.
474 */
475 err = -ESTALE;
476 if (!nop->fh_to_parent)
477 goto err_result;
478
479 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
480 fh_len, fileid_type);
481 if (!target_dir)
482 goto err_result;
483 err = PTR_ERR(target_dir);
484 if (IS_ERR(target_dir))
485 goto err_result;
486
487 /*
488 * And as usual we need to make sure the parent directory is
489 * connected to the filesystem root. The VFS really doesn't
490 * like disconnected directories..
491 */
492 err = reconnect_path(mnt, target_dir, nbuf);
493 if (err) {
494 dput(target_dir);
495 goto err_result;
496 }
497
498 /*
499 * Now that we've got both a well-connected parent and a
500 * dentry for the inode we're after, make sure that our
501 * inode is actually connected to the parent.
502 */
503 err = exportfs_get_name(mnt, target_dir, nbuf, result);
504 if (!err) {
505 mutex_lock(&target_dir->d_inode->i_mutex);
506 nresult = lookup_one_len(nbuf, target_dir,
507 strlen(nbuf));
508 mutex_unlock(&target_dir->d_inode->i_mutex);
509 if (!IS_ERR(nresult)) {
510 if (nresult->d_inode) {
511 dput(result);
512 result = nresult;
513 } else
514 dput(nresult);
515 }
516 }
517
518 /*
519 * At this point we are done with the parent, but it's pinned
520 * by the child dentry anyway.
521 */
522 dput(target_dir);
523
524 /*
525 * And finally make sure the dentry is actually acceptable
526 * to NFSD.
527 */
528 alias = find_acceptable_alias(result, acceptable, context);
529 if (!alias) {
530 err = -EACCES;
531 goto err_result;
532 }
533
534 return alias;
535 }
536
537 err_result:
538 dput(result);
539 return ERR_PTR(err);
540}
541EXPORT_SYMBOL_GPL(exportfs_decode_fh);
542
543MODULE_LICENSE("GPL");