Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
expfs.c
Go to the documentation of this file.
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  struct hlist_node *p;
48 
49  if (acceptable(context, result))
50  return result;
51 
52  inode = result->d_inode;
53  spin_lock(&inode->i_lock);
54  hlist_for_each_entry(dentry, p, &inode->i_dentry, d_alias) {
55  dget(dentry);
56  spin_unlock(&inode->i_lock);
57  if (toput)
58  dput(toput);
59  if (dentry != result && acceptable(context, dentry)) {
60  dput(result);
61  return dentry;
62  }
63  spin_lock(&inode->i_lock);
64  toput = dentry;
65  }
66  spin_unlock(&inode->i_lock);
67 
68  if (toput)
69  dput(toput);
70  return NULL;
71 }
72 
73 /*
74  * Find root of a disconnected subtree and return a reference to it.
75  */
76 static struct dentry *
77 find_disconnected_root(struct dentry *dentry)
78 {
79  dget(dentry);
80  while (!IS_ROOT(dentry)) {
81  struct dentry *parent = dget_parent(dentry);
82 
83  if (!(parent->d_flags & DCACHE_DISCONNECTED)) {
84  dput(parent);
85  break;
86  }
87 
88  dput(dentry);
89  dentry = parent;
90  }
91  return dentry;
92 }
93 
94 /*
95  * Make sure target_dir is fully connected to the dentry tree.
96  *
97  * It may already be, as the flag isn't always updated when connection happens.
98  */
99 static int
100 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
101 {
102  int noprogress = 0;
103  int err = -ESTALE;
104 
105  /*
106  * It is possible that a confused file system might not let us complete
107  * the path to the root. For example, if get_parent returns a directory
108  * in which we cannot find a name for the child. While this implies a
109  * very sick filesystem we don't want it to cause knfsd to spin. Hence
110  * the noprogress counter. If we go through the loop 10 times (2 is
111  * probably enough) without getting anywhere, we just give up
112  */
113  while (target_dir->d_flags & DCACHE_DISCONNECTED && noprogress++ < 10) {
114  struct dentry *pd = find_disconnected_root(target_dir);
115 
116  if (!IS_ROOT(pd)) {
117  /* must have found a connected parent - great */
118  spin_lock(&pd->d_lock);
120  spin_unlock(&pd->d_lock);
121  noprogress = 0;
122  } else if (pd == mnt->mnt_sb->s_root) {
123  printk(KERN_ERR "export: Eeek filesystem root is not connected, impossible\n");
124  spin_lock(&pd->d_lock);
126  spin_unlock(&pd->d_lock);
127  noprogress = 0;
128  } else {
129  /*
130  * We have hit the top of a disconnected path, try to
131  * find parent and connect.
132  *
133  * Racing with some other process renaming a directory
134  * isn't much of a problem here. If someone renames
135  * the directory, it will end up properly connected,
136  * which is what we want
137  *
138  * Getting the parent can't be supported generically,
139  * the locking is too icky.
140  *
141  * Instead we just return EACCES. If server reboots
142  * or inodes get flushed, you lose
143  */
144  struct dentry *ppd = ERR_PTR(-EACCES);
145  struct dentry *npd;
146 
147  mutex_lock(&pd->d_inode->i_mutex);
148  if (mnt->mnt_sb->s_export_op->get_parent)
149  ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
150  mutex_unlock(&pd->d_inode->i_mutex);
151 
152  if (IS_ERR(ppd)) {
153  err = PTR_ERR(ppd);
154  dprintk("%s: get_parent of %ld failed, err %d\n",
155  __func__, pd->d_inode->i_ino, err);
156  dput(pd);
157  break;
158  }
159 
160  dprintk("%s: find name of %lu in %lu\n", __func__,
161  pd->d_inode->i_ino, ppd->d_inode->i_ino);
162  err = exportfs_get_name(mnt, ppd, nbuf, pd);
163  if (err) {
164  dput(ppd);
165  dput(pd);
166  if (err == -ENOENT)
167  /* some race between get_parent and
168  * get_name? just try again
169  */
170  continue;
171  break;
172  }
173  dprintk("%s: found name: %s\n", __func__, nbuf);
174  mutex_lock(&ppd->d_inode->i_mutex);
175  npd = lookup_one_len(nbuf, ppd, strlen(nbuf));
176  mutex_unlock(&ppd->d_inode->i_mutex);
177  if (IS_ERR(npd)) {
178  err = PTR_ERR(npd);
179  dprintk("%s: lookup failed: %d\n",
180  __func__, err);
181  dput(ppd);
182  dput(pd);
183  break;
184  }
185  /* we didn't really want npd, we really wanted
186  * a side-effect of the lookup.
187  * hopefully, npd == pd, though it isn't really
188  * a problem if it isn't
189  */
190  if (npd == pd)
191  noprogress = 0;
192  else
193  printk("%s: npd != pd\n", __func__);
194  dput(npd);
195  dput(ppd);
196  if (IS_ROOT(pd)) {
197  /* something went wrong, we have to give up */
198  dput(pd);
199  break;
200  }
201  }
202  dput(pd);
203  }
204 
205  if (target_dir->d_flags & DCACHE_DISCONNECTED) {
206  /* something went wrong - oh-well */
207  if (!err)
208  err = -ESTALE;
209  return err;
210  }
211 
212  return 0;
213 }
214 
215 struct getdents_callback {
216  char *name; /* name that was found. It already points to a
217  buffer NAME_MAX+1 is size */
218  unsigned long ino; /* the inum we are looking for */
219  int found; /* inode matched? */
220  int sequence; /* sequence counter */
221 };
222 
223 /*
224  * A rather strange filldir function to capture
225  * the name matching the specified inode number.
226  */
227 static int filldir_one(void * __buf, const char * name, int len,
228  loff_t pos, u64 ino, unsigned int d_type)
229 {
230  struct getdents_callback *buf = __buf;
231  int result = 0;
232 
233  buf->sequence++;
234  if (buf->ino == ino) {
235  memcpy(buf->name, name, len);
236  buf->name[len] = '\0';
237  buf->found = 1;
238  result = -1;
239  }
240  return result;
241 }
242 
252 static int get_name(const struct path *path, char *name, struct dentry *child)
253 {
254  const struct cred *cred = current_cred();
255  struct inode *dir = path->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(path, 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 
317 static int export_encode_fh(struct inode *inode, struct fid *fid,
318  int *max_len, struct inode *parent)
319 {
320  int len = *max_len;
321  int type = FILEID_INO32_GEN;
322 
323  if (parent && (len < 4)) {
324  *max_len = 4;
325  return 255;
326  } else if (len < 2) {
327  *max_len = 2;
328  return 255;
329  }
330 
331  len = 2;
332  fid->i32.ino = inode->i_ino;
333  fid->i32.gen = inode->i_generation;
334  if (parent) {
335  fid->i32.parent_ino = parent->i_ino;
336  fid->i32.parent_gen = parent->i_generation;
337  len = 4;
339  }
340  *max_len = len;
341  return type;
342 }
343 
344 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
345  int connectable)
346 {
347  const struct export_operations *nop = dentry->d_sb->s_export_op;
348  int error;
349  struct dentry *p = NULL;
350  struct inode *inode = dentry->d_inode, *parent = NULL;
351 
352  if (connectable && !S_ISDIR(inode->i_mode)) {
353  p = dget_parent(dentry);
354  /*
355  * note that while p might've ceased to be our parent already,
356  * it's still pinned by and still positive.
357  */
358  parent = p->d_inode;
359  }
360  if (nop->encode_fh)
361  error = nop->encode_fh(inode, fid->raw, max_len, parent);
362  else
363  error = export_encode_fh(inode, fid, max_len, parent);
364  dput(p);
365 
366  return error;
367 }
369 
370 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
371  int fh_len, int fileid_type,
372  int (*acceptable)(void *, struct dentry *), void *context)
373 {
374  const struct export_operations *nop = mnt->mnt_sb->s_export_op;
375  struct dentry *result, *alias;
376  char nbuf[NAME_MAX+1];
377  int err;
378 
379  /*
380  * Try to get any dentry for the given file handle from the filesystem.
381  */
382  if (!nop || !nop->fh_to_dentry)
383  return ERR_PTR(-ESTALE);
384  result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
385  if (!result)
386  result = ERR_PTR(-ESTALE);
387  if (IS_ERR(result))
388  return result;
389 
390  if (S_ISDIR(result->d_inode->i_mode)) {
391  /*
392  * This request is for a directory.
393  *
394  * On the positive side there is only one dentry for each
395  * directory inode. On the negative side this implies that we
396  * to ensure our dentry is connected all the way up to the
397  * filesystem root.
398  */
399  if (result->d_flags & DCACHE_DISCONNECTED) {
400  err = reconnect_path(mnt, result, nbuf);
401  if (err)
402  goto err_result;
403  }
404 
405  if (!acceptable(context, result)) {
406  err = -EACCES;
407  goto err_result;
408  }
409 
410  return result;
411  } else {
412  /*
413  * It's not a directory. Life is a little more complicated.
414  */
415  struct dentry *target_dir, *nresult;
416 
417  /*
418  * See if either the dentry we just got from the filesystem
419  * or any alias for it is acceptable. This is always true
420  * if this filesystem is exported without the subtreecheck
421  * option. If the filesystem is exported with the subtree
422  * check option there's a fair chance we need to look at
423  * the parent directory in the file handle and make sure
424  * it's connected to the filesystem root.
425  */
426  alias = find_acceptable_alias(result, acceptable, context);
427  if (alias)
428  return alias;
429 
430  /*
431  * Try to extract a dentry for the parent directory from the
432  * file handle. If this fails we'll have to give up.
433  */
434  err = -ESTALE;
435  if (!nop->fh_to_parent)
436  goto err_result;
437 
438  target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
439  fh_len, fileid_type);
440  if (!target_dir)
441  goto err_result;
442  err = PTR_ERR(target_dir);
443  if (IS_ERR(target_dir))
444  goto err_result;
445 
446  /*
447  * And as usual we need to make sure the parent directory is
448  * connected to the filesystem root. The VFS really doesn't
449  * like disconnected directories..
450  */
451  err = reconnect_path(mnt, target_dir, nbuf);
452  if (err) {
453  dput(target_dir);
454  goto err_result;
455  }
456 
457  /*
458  * Now that we've got both a well-connected parent and a
459  * dentry for the inode we're after, make sure that our
460  * inode is actually connected to the parent.
461  */
462  err = exportfs_get_name(mnt, target_dir, nbuf, result);
463  if (!err) {
464  mutex_lock(&target_dir->d_inode->i_mutex);
465  nresult = lookup_one_len(nbuf, target_dir,
466  strlen(nbuf));
467  mutex_unlock(&target_dir->d_inode->i_mutex);
468  if (!IS_ERR(nresult)) {
469  if (nresult->d_inode) {
470  dput(result);
471  result = nresult;
472  } else
473  dput(nresult);
474  }
475  }
476 
477  /*
478  * At this point we are done with the parent, but it's pinned
479  * by the child dentry anyway.
480  */
481  dput(target_dir);
482 
483  /*
484  * And finally make sure the dentry is actually acceptable
485  * to NFSD.
486  */
487  alias = find_acceptable_alias(result, acceptable, context);
488  if (!alias) {
489  err = -EACCES;
490  goto err_result;
491  }
492 
493  return alias;
494  }
495 
496  err_result:
497  dput(result);
498  return ERR_PTR(err);
499 }
501 
502 MODULE_LICENSE("GPL");