xref: /openbmc/linux/fs/exportfs/expfs.c (revision 4800cd83)
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 
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 *
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 *
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
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  */
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  */
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  */
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 (len < 2 || (connectable && len < 4))
325 		return 255;
326 
327 	len = 2;
328 	fid->i32.ino = inode->i_ino;
329 	fid->i32.gen = inode->i_generation;
330 	if (connectable && !S_ISDIR(inode->i_mode)) {
331 		struct inode *parent;
332 
333 		spin_lock(&dentry->d_lock);
334 		parent = dentry->d_parent->d_inode;
335 		fid->i32.parent_ino = parent->i_ino;
336 		fid->i32.parent_gen = parent->i_generation;
337 		spin_unlock(&dentry->d_lock);
338 		len = 4;
339 		type = FILEID_INO32_GEN_PARENT;
340 	}
341 	*max_len = len;
342 	return type;
343 }
344 
345 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
346 		int connectable)
347 {
348 	const struct export_operations *nop = dentry->d_sb->s_export_op;
349 	int error;
350 
351 	if (nop->encode_fh)
352 		error = nop->encode_fh(dentry, fid->raw, max_len, connectable);
353 	else
354 		error = export_encode_fh(dentry, fid, max_len, connectable);
355 
356 	return error;
357 }
358 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
359 
360 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
361 		int fh_len, int fileid_type,
362 		int (*acceptable)(void *, struct dentry *), void *context)
363 {
364 	const struct export_operations *nop = mnt->mnt_sb->s_export_op;
365 	struct dentry *result, *alias;
366 	char nbuf[NAME_MAX+1];
367 	int err;
368 
369 	/*
370 	 * Try to get any dentry for the given file handle from the filesystem.
371 	 */
372 	result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
373 	if (!result)
374 		result = ERR_PTR(-ESTALE);
375 	if (IS_ERR(result))
376 		return result;
377 
378 	if (S_ISDIR(result->d_inode->i_mode)) {
379 		/*
380 		 * This request is for a directory.
381 		 *
382 		 * On the positive side there is only one dentry for each
383 		 * directory inode.  On the negative side this implies that we
384 		 * to ensure our dentry is connected all the way up to the
385 		 * filesystem root.
386 		 */
387 		if (result->d_flags & DCACHE_DISCONNECTED) {
388 			err = reconnect_path(mnt, result, nbuf);
389 			if (err)
390 				goto err_result;
391 		}
392 
393 		if (!acceptable(context, result)) {
394 			err = -EACCES;
395 			goto err_result;
396 		}
397 
398 		return result;
399 	} else {
400 		/*
401 		 * It's not a directory.  Life is a little more complicated.
402 		 */
403 		struct dentry *target_dir, *nresult;
404 
405 		/*
406 		 * See if either the dentry we just got from the filesystem
407 		 * or any alias for it is acceptable.  This is always true
408 		 * if this filesystem is exported without the subtreecheck
409 		 * option.  If the filesystem is exported with the subtree
410 		 * check option there's a fair chance we need to look at
411 		 * the parent directory in the file handle and make sure
412 		 * it's connected to the filesystem root.
413 		 */
414 		alias = find_acceptable_alias(result, acceptable, context);
415 		if (alias)
416 			return alias;
417 
418 		/*
419 		 * Try to extract a dentry for the parent directory from the
420 		 * file handle.  If this fails we'll have to give up.
421 		 */
422 		err = -ESTALE;
423 		if (!nop->fh_to_parent)
424 			goto err_result;
425 
426 		target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
427 				fh_len, fileid_type);
428 		if (!target_dir)
429 			goto err_result;
430 		err = PTR_ERR(target_dir);
431 		if (IS_ERR(target_dir))
432 			goto err_result;
433 
434 		/*
435 		 * And as usual we need to make sure the parent directory is
436 		 * connected to the filesystem root.  The VFS really doesn't
437 		 * like disconnected directories..
438 		 */
439 		err = reconnect_path(mnt, target_dir, nbuf);
440 		if (err) {
441 			dput(target_dir);
442 			goto err_result;
443 		}
444 
445 		/*
446 		 * Now that we've got both a well-connected parent and a
447 		 * dentry for the inode we're after, make sure that our
448 		 * inode is actually connected to the parent.
449 		 */
450 		err = exportfs_get_name(mnt, target_dir, nbuf, result);
451 		if (!err) {
452 			mutex_lock(&target_dir->d_inode->i_mutex);
453 			nresult = lookup_one_len(nbuf, target_dir,
454 						 strlen(nbuf));
455 			mutex_unlock(&target_dir->d_inode->i_mutex);
456 			if (!IS_ERR(nresult)) {
457 				if (nresult->d_inode) {
458 					dput(result);
459 					result = nresult;
460 				} else
461 					dput(nresult);
462 			}
463 		}
464 
465 		/*
466 		 * At this point we are done with the parent, but it's pinned
467 		 * by the child dentry anyway.
468 		 */
469 		dput(target_dir);
470 
471 		/*
472 		 * And finally make sure the dentry is actually acceptable
473 		 * to NFSD.
474 		 */
475 		alias = find_acceptable_alias(result, acceptable, context);
476 		if (!alias) {
477 			err = -EACCES;
478 			goto err_result;
479 		}
480 
481 		return alias;
482 	}
483 
484  err_result:
485 	dput(result);
486 	return ERR_PTR(err);
487 }
488 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
489 
490 MODULE_LICENSE("GPL");
491