blob: a235f0016889b557e06d6273f0f3dca7d873a608 [file] [log] [blame]
Christoph Hellwige38f9812007-10-21 16:42:19 -07001/*
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
J. Bruce Fieldsdc7a0812009-10-27 14:41:35 -04009 * take a look at Documentation/filesystems/nfs/Exporting.
Christoph Hellwige38f9812007-10-21 16:42:19 -070010 */
Christoph Hellwiga5694252007-07-17 04:04:28 -070011#include <linux/exportfs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include <linux/fs.h>
13#include <linux/file.h>
14#include <linux/module.h>
Christoph Hellwigd37065c2007-07-17 04:04:30 -070015#include <linux/mount.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/namei.h>
David Howells745ca242008-11-14 10:39:22 +110017#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#define dprintk(fmt, args...) do{}while(0)
20
Christoph Hellwig10f11c32007-07-17 04:04:31 -070021
Al Viro765927b2012-06-26 21:58:53 +040022static int get_name(const struct path *path, char *name, struct dentry *child);
Christoph Hellwig10f11c32007-07-17 04:04:31 -070023
24
Christoph Hellwige38f9812007-10-21 16:42:19 -070025static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
26 char *name, struct dentry *child)
Christoph Hellwig10f11c32007-07-17 04:04:31 -070027{
Christoph Hellwig39655162007-10-21 16:42:17 -070028 const struct export_operations *nop = dir->d_sb->s_export_op;
Al Viro765927b2012-06-26 21:58:53 +040029 struct path path = {.mnt = mnt, .dentry = dir};
Christoph Hellwig10f11c32007-07-17 04:04:31 -070030
31 if (nop->get_name)
32 return nop->get_name(dir, name, child);
33 else
Al Viro765927b2012-06-26 21:58:53 +040034 return get_name(&path, name, child);
Christoph Hellwig10f11c32007-07-17 04:04:31 -070035}
36
Christoph Hellwigfb66a192007-07-17 04:04:32 -070037/*
38 * Check if the dentry or any of it's aliases is acceptable.
39 */
Christoph Hellwige2f99012006-01-18 17:43:52 -080040static 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;
Nick Piggin873feea2011-01-07 17:50:06 +110046 struct inode *inode;
Christoph Hellwige2f99012006-01-18 17:43:52 -080047
Christoph Hellwigfb66a192007-07-17 04:04:32 -070048 if (acceptable(context, result))
49 return result;
50
Nick Piggin873feea2011-01-07 17:50:06 +110051 inode = result->d_inode;
52 spin_lock(&inode->i_lock);
Sasha Levinb67bfe02013-02-27 17:06:00 -080053 hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
Nick Piggindc0474b2011-01-07 17:49:43 +110054 dget(dentry);
Nick Piggin873feea2011-01-07 17:50:06 +110055 spin_unlock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080056 if (toput)
57 dput(toput);
58 if (dentry != result && acceptable(context, dentry)) {
59 dput(result);
60 return dentry;
61 }
Nick Piggin873feea2011-01-07 17:50:06 +110062 spin_lock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080063 toput = dentry;
64 }
Nick Piggin873feea2011-01-07 17:50:06 +110065 spin_unlock(&inode->i_lock);
Christoph Hellwige2f99012006-01-18 17:43:52 -080066
67 if (toput)
68 dput(toput);
69 return NULL;
70}
71
Christoph Hellwigdd90b502007-07-17 04:04:32 -070072/*
73 * Find root of a disconnected subtree and return a reference to it.
74 */
75static struct dentry *
76find_disconnected_root(struct dentry *dentry)
77{
78 dget(dentry);
Christoph Hellwig0461ee22010-10-13 11:56:37 -040079 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
Christoph Hellwigdd90b502007-07-17 04:04:32 -070087 dput(dentry);
88 dentry = parent;
Christoph Hellwigdd90b502007-07-17 04:04:32 -070089 }
Christoph Hellwigdd90b502007-07-17 04:04:32 -070090 return dentry;
91}
92
Christoph Hellwig019ab802007-07-17 04:04:33 -070093/*
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 */
98static int
Al Virof3f8e172008-08-11 12:39:47 -040099reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
Christoph Hellwig019ab802007-07-17 04:04:33 -0700100{
Christoph Hellwig019ab802007-07-17 04:04:33 -0700101 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;
Christoph Hellwige38f9812007-10-21 16:42:19 -0700121 } else if (pd == mnt->mnt_sb->s_root) {
Christoph Hellwig019ab802007-07-17 04:04:33 -0700122 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);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700147 if (mnt->mnt_sb->s_export_op->get_parent)
148 ppd = mnt->mnt_sb->s_export_op->get_parent(pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700149 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",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700154 __func__, pd->d_inode->i_ino, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700155 dput(pd);
156 break;
157 }
158
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700159 dprintk("%s: find name of %lu in %lu\n", __func__,
Christoph Hellwig019ab802007-07-17 04:04:33 -0700160 pd->d_inode->i_ino, ppd->d_inode->i_ino);
Christoph Hellwige38f9812007-10-21 16:42:19 -0700161 err = exportfs_get_name(mnt, ppd, nbuf, pd);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700162 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 }
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700172 dprintk("%s: found name: %s\n", __func__, nbuf);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700173 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",
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700179 __func__, err);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700180 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
Harvey Harrison8e24eea2008-04-30 00:55:09 -0700192 printk("%s: npd != pd\n", __func__);
Christoph Hellwig019ab802007-07-17 04:04:33 -0700193 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214struct getdents_callback {
Al Viro5c0ba4e2013-05-15 13:52:59 -0400215 struct dir_context ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 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 */
227static int filldir_one(void * __buf, const char * name, int len,
David Howellsafefdbb2006-10-03 01:13:46 -0700228 loff_t pos, u64 ino, unsigned int d_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229{
230 struct getdents_callback *buf = __buf;
231 int result = 0;
232
233 buf->sequence++;
Al Virodfc59e2c2013-09-06 16:55:36 -0400234 if (buf->ino == ino && len <= NAME_MAX) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 memcpy(buf->name, name, len);
236 buf->name[len] = '\0';
237 buf->found = 1;
238 result = -1;
239 }
240 return result;
241}
242
243/**
244 * get_name - default export_operations->get_name function
245 * @dentry: the directory in which to find a name
246 * @name: a pointer to a %NAME_MAX+1 char buffer to store the name
247 * @child: the dentry for the child directory.
248 *
249 * calls readdir on the parent until it finds an entry with
250 * the same inode number as the child, and returns that.
251 */
Al Viro765927b2012-06-26 21:58:53 +0400252static int get_name(const struct path *path, char *name, struct dentry *child)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253{
David Howells745ca242008-11-14 10:39:22 +1100254 const struct cred *cred = current_cred();
Al Viro765927b2012-06-26 21:58:53 +0400255 struct inode *dir = path->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 int error;
257 struct file *file;
Al Viroac6614b2013-05-22 22:22:04 -0400258 struct getdents_callback buffer = {
259 .ctx.actor = filldir_one,
260 .name = name,
261 .ino = child->d_inode->i_ino
262 };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264 error = -ENOTDIR;
265 if (!dir || !S_ISDIR(dir->i_mode))
266 goto out;
267 error = -EINVAL;
268 if (!dir->i_fop)
269 goto out;
270 /*
271 * Open the directory ...
272 */
Al Viro765927b2012-06-26 21:58:53 +0400273 file = dentry_open(path, O_RDONLY, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 error = PTR_ERR(file);
275 if (IS_ERR(file))
276 goto out;
277
278 error = -EINVAL;
Al Viro2233f312013-05-22 21:44:23 -0400279 if (!file->f_op->iterate)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 goto out_close;
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 buffer.sequence = 0;
283 while (1) {
284 int old_seq = buffer.sequence;
285
Al Viro5c0ba4e2013-05-15 13:52:59 -0400286 error = iterate_dir(file, &buffer.ctx);
Al Viro53c9c5c2008-08-24 07:29:52 -0400287 if (buffer.found) {
288 error = 0;
289 break;
290 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291
292 if (error < 0)
293 break;
294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 error = -ENOENT;
296 if (old_seq == buffer.sequence)
297 break;
298 }
299
300out_close:
301 fput(file);
302out:
303 return error;
304}
305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306/**
307 * export_encode_fh - default export_operations->encode_fh function
Al Virob0b03822012-04-02 14:34:06 -0400308 * @inode: the object to encode
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 * @fh: where to store the file handle fragment
310 * @max_len: maximum length to store there
Al Virob0b03822012-04-02 14:34:06 -0400311 * @parent: parent directory inode, if wanted
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 *
313 * This default encode_fh function assumes that the 32 inode number
314 * is suitable for locating an inode, and that the generation number
315 * can be used to check that it is still valid. It places them in the
316 * filehandle fragment where export_decode_fh expects to find them.
317 */
Al Virob0b03822012-04-02 14:34:06 -0400318static int export_encode_fh(struct inode *inode, struct fid *fid,
319 int *max_len, struct inode *parent)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 int len = *max_len;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700322 int type = FILEID_INO32_GEN;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530323
Al Virob0b03822012-04-02 14:34:06 -0400324 if (parent && (len < 4)) {
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530325 *max_len = 4;
Namjae Jeon216b6cb2012-08-29 10:10:10 -0400326 return FILEID_INVALID;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530327 } else if (len < 2) {
328 *max_len = 2;
Namjae Jeon216b6cb2012-08-29 10:10:10 -0400329 return FILEID_INVALID;
Aneesh Kumar K.V5fe0c232011-01-29 18:43:25 +0530330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331
332 len = 2;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700333 fid->i32.ino = inode->i_ino;
334 fid->i32.gen = inode->i_generation;
Al Virob0b03822012-04-02 14:34:06 -0400335 if (parent) {
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700336 fid->i32.parent_ino = parent->i_ino;
337 fid->i32.parent_gen = parent->i_generation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 len = 4;
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700339 type = FILEID_INO32_GEN_PARENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 }
341 *max_len = len;
342 return type;
343}
344
Cyrill Gorcunov711c7bf2012-12-17 16:05:08 -0800345int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
346 int *max_len, struct inode *parent)
347{
348 const struct export_operations *nop = inode->i_sb->s_export_op;
349
350 if (nop && nop->encode_fh)
351 return nop->encode_fh(inode, fid->raw, max_len, parent);
352
353 return export_encode_fh(inode, fid, max_len, parent);
354}
355EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
356
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700357int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700358 int connectable)
359{
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700360 int error;
Al Virob0b03822012-04-02 14:34:06 -0400361 struct dentry *p = NULL;
362 struct inode *inode = dentry->d_inode, *parent = NULL;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700363
Al Virob0b03822012-04-02 14:34:06 -0400364 if (connectable && !S_ISDIR(inode->i_mode)) {
365 p = dget_parent(dentry);
366 /*
367 * note that while p might've ceased to be our parent already,
368 * it's still pinned by and still positive.
369 */
370 parent = p->d_inode;
371 }
Cyrill Gorcunov711c7bf2012-12-17 16:05:08 -0800372
373 error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
Al Virob0b03822012-04-02 14:34:06 -0400374 dput(p);
Christoph Hellwig10f11c32007-07-17 04:04:31 -0700375
376 return error;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700377}
378EXPORT_SYMBOL_GPL(exportfs_encode_fh);
379
Christoph Hellwig6e91ea22007-10-21 16:42:03 -0700380struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
381 int fh_len, int fileid_type,
382 int (*acceptable)(void *, struct dentry *), void *context)
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700383{
Christoph Hellwig39655162007-10-21 16:42:17 -0700384 const struct export_operations *nop = mnt->mnt_sb->s_export_op;
Christoph Hellwig25961102007-10-21 16:42:05 -0700385 struct dentry *result, *alias;
Al Virof3f8e172008-08-11 12:39:47 -0400386 char nbuf[NAME_MAX+1];
Christoph Hellwig25961102007-10-21 16:42:05 -0700387 int err;
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700388
Christoph Hellwig25961102007-10-21 16:42:05 -0700389 /*
Christoph Hellwig25961102007-10-21 16:42:05 -0700390 * Try to get any dentry for the given file handle from the filesystem.
391 */
Aneesh Kumar K.Vbecfd1f2011-01-29 18:43:26 +0530392 if (!nop || !nop->fh_to_dentry)
393 return ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700394 result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500395 if (!result)
396 result = ERR_PTR(-ESTALE);
Christoph Hellwig25961102007-10-21 16:42:05 -0700397 if (IS_ERR(result))
398 return result;
399
400 if (S_ISDIR(result->d_inode->i_mode)) {
401 /*
402 * This request is for a directory.
403 *
404 * On the positive side there is only one dentry for each
405 * directory inode. On the negative side this implies that we
406 * to ensure our dentry is connected all the way up to the
407 * filesystem root.
408 */
409 if (result->d_flags & DCACHE_DISCONNECTED) {
Al Virof3f8e172008-08-11 12:39:47 -0400410 err = reconnect_path(mnt, result, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700411 if (err)
412 goto err_result;
413 }
414
415 if (!acceptable(context, result)) {
416 err = -EACCES;
417 goto err_result;
418 }
419
420 return result;
421 } else {
422 /*
423 * It's not a directory. Life is a little more complicated.
424 */
425 struct dentry *target_dir, *nresult;
Christoph Hellwig25961102007-10-21 16:42:05 -0700426
427 /*
428 * See if either the dentry we just got from the filesystem
429 * or any alias for it is acceptable. This is always true
430 * if this filesystem is exported without the subtreecheck
431 * option. If the filesystem is exported with the subtree
432 * check option there's a fair chance we need to look at
433 * the parent directory in the file handle and make sure
434 * it's connected to the filesystem root.
435 */
436 alias = find_acceptable_alias(result, acceptable, context);
437 if (alias)
438 return alias;
439
440 /*
441 * Try to extract a dentry for the parent directory from the
442 * file handle. If this fails we'll have to give up.
443 */
444 err = -ESTALE;
445 if (!nop->fh_to_parent)
446 goto err_result;
447
448 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
449 fh_len, fileid_type);
J. Bruce Fieldsa4f4d6d2008-12-08 18:24:18 -0500450 if (!target_dir)
451 goto err_result;
Christoph Hellwig25961102007-10-21 16:42:05 -0700452 err = PTR_ERR(target_dir);
453 if (IS_ERR(target_dir))
454 goto err_result;
455
456 /*
457 * And as usual we need to make sure the parent directory is
458 * connected to the filesystem root. The VFS really doesn't
459 * like disconnected directories..
460 */
Al Virof3f8e172008-08-11 12:39:47 -0400461 err = reconnect_path(mnt, target_dir, nbuf);
Christoph Hellwig25961102007-10-21 16:42:05 -0700462 if (err) {
463 dput(target_dir);
464 goto err_result;
465 }
466
467 /*
468 * Now that we've got both a well-connected parent and a
469 * dentry for the inode we're after, make sure that our
470 * inode is actually connected to the parent.
471 */
Christoph Hellwige38f9812007-10-21 16:42:19 -0700472 err = exportfs_get_name(mnt, target_dir, nbuf, result);
Christoph Hellwig25961102007-10-21 16:42:05 -0700473 if (!err) {
474 mutex_lock(&target_dir->d_inode->i_mutex);
475 nresult = lookup_one_len(nbuf, target_dir,
476 strlen(nbuf));
477 mutex_unlock(&target_dir->d_inode->i_mutex);
478 if (!IS_ERR(nresult)) {
479 if (nresult->d_inode) {
480 dput(result);
481 result = nresult;
482 } else
483 dput(nresult);
484 }
485 }
486
487 /*
488 * At this point we are done with the parent, but it's pinned
489 * by the child dentry anyway.
490 */
491 dput(target_dir);
492
493 /*
494 * And finally make sure the dentry is actually acceptable
495 * to NFSD.
496 */
497 alias = find_acceptable_alias(result, acceptable, context);
498 if (!alias) {
499 err = -EACCES;
500 goto err_result;
501 }
502
503 return alias;
504 }
505
506 err_result:
507 dput(result);
508 return ERR_PTR(err);
Christoph Hellwigd37065c2007-07-17 04:04:30 -0700509}
510EXPORT_SYMBOL_GPL(exportfs_decode_fh);
511
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512MODULE_LICENSE("GPL");