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(struct vfsmount *mnt, struct dentry *dentry, char *name,
23 struct dentry *child);
24
25
exportfs_get_name(struct vfsmount * mnt,struct dentry * dir,char * name,struct dentry * child)26 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
27 char *name, struct dentry *child)
28 {
29 const struct export_operations *nop = dir->d_sb->s_export_op;
30
31 if (nop->get_name)
32 return nop->get_name(dir, name, child);
33 else
34 return get_name(mnt, dir, name, child);
35 }
36
37 /*
38 * Check if the dentry or any of it's aliases is acceptable.
39 */
40 static struct dentry *
find_acceptable_alias(struct dentry * result,int (* acceptable)(void * context,struct dentry * dentry),void * context)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 list_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
72 /*
73 * Find root of a disconnected subtree and return a reference to it.
74 */
75 static struct dentry *
find_disconnected_root(struct dentry * dentry)76 find_disconnected_root(struct dentry *dentry)
77 {
78 dget(dentry);
79 while (!IS_ROOT(dentry)) {
80 struct dentry *parent = dget_parent(dentry);
81
82 if (!(parent->d_flags & DCACHE_DISCONNECTED)) {
83 dput(parent);
84 break;
85 }
86
87 dput(dentry);
88 dentry = parent;
89 }
90 return dentry;
91 }
92
93 /*
94 * Make sure target_dir is fully connected to the dentry tree.
95 *
96 * It may already be, as the flag isn't always updated when connection happens.
97 */
98 static int
reconnect_path(struct vfsmount * mnt,struct dentry * target_dir,char * nbuf)99 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
100 {
101 int noprogress = 0;
102 int err = -ESTALE;
103
104 /*
105 * It is possible that a confused file system might not let us complete
106 * the path to the root. For example, if get_parent returns a directory
107 * in which we cannot find a name for the child. While this implies a
108 * very sick filesystem we don't want it to cause knfsd to spin. Hence
109 * the noprogress counter. If we go through the loop 10 times (2 is
110 * probably enough) without getting anywhere, we just give up
111 */
112 while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
113 struct dentry *pd = find_disconnected_root(target_dir);
114
115 if (!IS_ROOT(pd)) {
116 /* must have found a connected parent - great */
117 spin_lock(&pd->d_lock);
118 pd->d_flags &= ~DCACHE_DISCONNECTED;
119 spin_unlock(&pd->d_lock);
120 noprogress = 0;
121 } else if (pd == mnt->mnt_sb->s_root) {
122 printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
123 spin_lock(&pd->d_lock);
124 pd->d_flags &= ~DCACHE_DISCONNECTED;
125 spin_unlock(&pd->d_lock);
126 noprogress = 0;
127 } else {
128 /*
129 * We have hit the top of a disconnected path, try to
130 * find parent and connect.
131 *
132 * Racing with some other process renaming a directory
133 * isn't much of a problem here. If someone renames
134 * the directory, it will end up properly connected,
135 * which is what we want
136 *
137 * Getting the parent can't be supported generically,
138 * the locking is too icky.
139 *
140 * Instead we just return EACCES. If server reboots
141 * or inodes get flushed, you lose
142 */
143 struct dentry *ppd = ERR_PTR(-EACCES);
144 struct dentry *npd;
145
146 mutex_lock(&pd->d_inode->i_mutex);
147 if (mnt->mnt_sb->s_export_op->get_parent)
148 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
149 mutex_unlock(&pd->d_inode->i_mutex);
150
151 if (IS_ERR(ppd)) {
152 err = PTR_ERR(ppd);
153 dprintk("%s: get_parent of %ld failed, err %d\n",
154 __func__, pd->d_inode->i_ino, err);
155 dput(pd);
156 break;
157 }
158
159 dprintk("%s: find name of %lu in %lu\n", __func__,
160 pd->d_inode->i_ino, ppd->d_inode->i_ino);
161 err = exportfs_get_name(mnt, ppd, nbuf, pd);
162 if (err) {
163 dput(ppd);
164 dput(pd);
165 if (err == -ENOENT)
166 /* some race between get_parent and
167 * get_name? just try again
168 */
169 continue;
170 break;
171 }
172 dprintk("%s: found name: %s\n", __func__, nbuf);
173 mutex_lock(&ppd->d_inode->i_mutex);
174 npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
175 mutex_unlock(&ppd->d_inode->i_mutex);
176 if (IS_ERR(npd)) {
177 err = PTR_ERR(npd);
178 dprintk("%s: lookup failed: %d\n",
179 __func__, err);
180 dput(ppd);
181 dput(pd);
182 break;
183 }
184 /* we didn't really want npd, we really wanted
185 * a side-effect of the lookup.
186 * hopefully, npd == pd, though it isn't really
187 * a problem if it isn't
188 */
189 if (npd == pd)
190 noprogress = 0;
191 else
192 printk("%s: npd != pd\n", __func__);
193 dput(npd);
194 dput(ppd);
195 if (IS_ROOT(pd)) {
196 /* something went wrong, we have to give up */
197 dput(pd);
198 break;
199 }
200 }
201 dput(pd);
202 }
203
204 if (target_dir->d_flags & DCACHE_DISCONNECTED) {
205 /* something went wrong - oh-well */
206 if (!err)
207 err = -ESTALE;
208 return err;
209 }
210
211 return 0;
212 }
213
214 struct getdents_callback {
215 char *name; /* name that was found. It already points to a
216 buffer NAME_MAX+1 is size */
217 unsigned long ino; /* the inum we are looking for */
218 int found; /* inode matched? */
219 int sequence; /* sequence counter */
220 };
221
222 /*
223 * A rather strange filldir function to capture
224 * the name matching the specified inode number.
225 */
filldir_one(void * __buf,const char * name,int len,loff_t pos,u64 ino,unsigned int d_type)226 static int filldir_one(void * __buf, const char * name, int len,
227 loff_t pos, u64 ino, unsigned int d_type)
228 {
229 struct getdents_callback *buf = __buf;
230 int result = 0;
231
232 buf->sequence++;
233 if (buf->ino == ino) {
234 memcpy(buf->name, name, len);
235 buf->name[len] = '\0';
236 buf->found = 1;
237 result = -1;
238 }
239 return result;
240 }
241
242 /**
243 * get_name - default export_operations->get_name function
244 * @dentry: the directory in which to find a name
245 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
246 * @child: the dentry for the child directory.
247 *
248 * calls readdir on the parent until it finds an entry with
249 * the same inode number as the child, and returns that.
250 */
get_name(struct vfsmount * mnt,struct dentry * dentry,char * name,struct dentry * child)251 static int get_name(struct vfsmount *mnt, struct dentry *dentry,
252 char *name, struct dentry *child)
253 {
254 const struct cred *cred = current_cred();
255 struct inode *dir = dentry->d_inode;
256 int error;
257 struct file *file;
258 struct getdents_callback buffer;
259
260 error = -ENOTDIR;
261 if (!dir || !S_ISDIR(dir->i_mode))
262 goto out;
263 error = -EINVAL;
264 if (!dir->i_fop)
265 goto out;
266 /*
267 * Open the directory ...
268 */
269 file = dentry_open(dget(dentry), mntget(mnt), O_RDONLY, cred);
270 error = PTR_ERR(file);
271 if (IS_ERR(file))
272 goto out;
273
274 error = -EINVAL;
275 if (!file->f_op->readdir)
276 goto out_close;
277
278 buffer.name = name;
279 buffer.ino = child->d_inode->i_ino;
280 buffer.found = 0;
281 buffer.sequence = 0;
282 while (1) {
283 int old_seq = buffer.sequence;
284
285 error = vfs_readdir(file, filldir_one, &buffer);
286 if (buffer.found) {
287 error = 0;
288 break;
289 }
290
291 if (error < 0)
292 break;
293
294 error = -ENOENT;
295 if (old_seq == buffer.sequence)
296 break;
297 }
298
299 out_close:
300 fput(file);
301 out:
302 return error;
303 }
304
305 /**
306 * export_encode_fh - default export_operations->encode_fh function
307 * @dentry: the dentry to encode
308 * @fh: where to store the file handle fragment
309 * @max_len: maximum length to store there
310 * @connectable: whether to store parent information
311 *
312 * This default encode_fh function assumes that the 32 inode number
313 * is suitable for locating an inode, and that the generation number
314 * can be used to check that it is still valid. It places them in the
315 * filehandle fragment where export_decode_fh expects to find them.
316 */
export_encode_fh(struct dentry * dentry,struct fid * fid,int * max_len,int connectable)317 static int export_encode_fh(struct dentry *dentry, struct fid *fid,
318 int *max_len, int connectable)
319 {
320 struct inode * inode = dentry->d_inode;
321 int len = *max_len;
322 int type = FILEID_INO32_GEN;
323
324 if (connectable && (len < 4)) {
325 *max_len = 4;
326 return 255;
327 } else if (len < 2) {
328 *max_len = 2;
329 return 255;
330 }
331
332 len = 2;
333 fid->i32.ino = inode->i_ino;
334 fid->i32.gen = inode->i_generation;
335 if (connectable && !S_ISDIR(inode->i_mode)) {
336 struct inode *parent;
337
338 spin_lock(&dentry->d_lock);
339 parent = dentry->d_parent->d_inode;
340 fid->i32.parent_ino = parent->i_ino;
341 fid->i32.parent_gen = parent->i_generation;
342 spin_unlock(&dentry->d_lock);
343 len = 4;
344 type = FILEID_INO32_GEN_PARENT;
345 }
346 *max_len = len;
347 return type;
348 }
349
exportfs_encode_fh(struct dentry * dentry,struct fid * fid,int * max_len,int connectable)350 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
351 int connectable)
352 {
353 const struct export_operations *nop = dentry->d_sb->s_export_op;
354 int error;
355
356 if (nop->encode_fh)
357 error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
358 else
359 error = export_encode_fh(dentry, fid, max_len, connectable);
360
361 return error;
362 }
363 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
364
exportfs_decode_fh(struct vfsmount * mnt,struct fid * fid,int fh_len,int fileid_type,int (* acceptable)(void *,struct dentry *),void * context)365 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
366 int fh_len, int fileid_type,
367 int (*acceptable)(void *, struct dentry *), void *context)
368 {
369 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
370 struct dentry *result, *alias;
371 char nbuf[NAME_MAX+1];
372 int err;
373
374 /*
375 * Try to get any dentry for the given file handle from the filesystem.
376 */
377 if (!nop || !nop->fh_to_dentry)
378 return ERR_PTR(-ESTALE);
379 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
380 if (!result)
381 result = ERR_PTR(-ESTALE);
382 if (IS_ERR(result))
383 return result;
384
385 if (S_ISDIR(result->d_inode->i_mode)) {
386 /*
387 * This request is for a directory.
388 *
389 * On the positive side there is only one dentry for each
390 * directory inode. On the negative side this implies that we
391 * to ensure our dentry is connected all the way up to the
392 * filesystem root.
393 */
394 if (result->d_flags & DCACHE_DISCONNECTED) {
395 err = reconnect_path(mnt, result, nbuf);
396 if (err)
397 goto err_result;
398 }
399
400 if (!acceptable(context, result)) {
401 err = -EACCES;
402 goto err_result;
403 }
404
405 return result;
406 } else {
407 /*
408 * It's not a directory. Life is a little more complicated.
409 */
410 struct dentry *target_dir, *nresult;
411
412 /*
413 * See if either the dentry we just got from the filesystem
414 * or any alias for it is acceptable. This is always true
415 * if this filesystem is exported without the subtreecheck
416 * option. If the filesystem is exported with the subtree
417 * check option there's a fair chance we need to look at
418 * the parent directory in the file handle and make sure
419 * it's connected to the filesystem root.
420 */
421 alias = find_acceptable_alias(result, acceptable, context);
422 if (alias)
423 return alias;
424
425 /*
426 * Try to extract a dentry for the parent directory from the
427 * file handle. If this fails we'll have to give up.
428 */
429 err = -ESTALE;
430 if (!nop->fh_to_parent)
431 goto err_result;
432
433 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
434 fh_len, fileid_type);
435 if (!target_dir)
436 goto err_result;
437 err = PTR_ERR(target_dir);
438 if (IS_ERR(target_dir))
439 goto err_result;
440
441 /*
442 * And as usual we need to make sure the parent directory is
443 * connected to the filesystem root. The VFS really doesn't
444 * like disconnected directories..
445 */
446 err = reconnect_path(mnt, target_dir, nbuf);
447 if (err) {
448 dput(target_dir);
449 goto err_result;
450 }
451
452 /*
453 * Now that we've got both a well-connected parent and a
454 * dentry for the inode we're after, make sure that our
455 * inode is actually connected to the parent.
456 */
457 err = exportfs_get_name(mnt, target_dir, nbuf, result);
458 if (!err) {
459 mutex_lock(&target_dir->d_inode->i_mutex);
460 nresult = lookup_one_len(nbuf, target_dir,
461 strlen(nbuf));
462 mutex_unlock(&target_dir->d_inode->i_mutex);
463 if (!IS_ERR(nresult)) {
464 if (nresult->d_inode) {
465 dput(result);
466 result = nresult;
467 } else
468 dput(nresult);
469 }
470 }
471
472 /*
473 * At this point we are done with the parent, but it's pinned
474 * by the child dentry anyway.
475 */
476 dput(target_dir);
477
478 /*
479 * And finally make sure the dentry is actually acceptable
480 * to NFSD.
481 */
482 alias = find_acceptable_alias(result, acceptable, context);
483 if (!alias) {
484 err = -EACCES;
485 goto err_result;
486 }
487
488 return alias;
489 }
490
491 err_result:
492 dput(result);
493 return ERR_PTR(err);
494 }
495 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
496
497 MODULE_LICENSE("GPL");
498