~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/exportfs/expfs.c

Version: ~ [ linux-5.15-rc7 ] ~ [ linux-5.14.14 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.75 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.155 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.213 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.252 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.287 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.289 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 #include <linux/cred.h>
 19 
 20 #define dprintk(fmt, args...) do{}while(0)
 21 
 22 
 23 static int get_name(const struct path *path, char *name, 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         struct path path = {.mnt = mnt, .dentry = dir};
 31 
 32         if (nop->get_name)
 33                 return nop->get_name(dir, name, child);
 34         else
 35                 return get_name(&path, name, child);
 36 }
 37 
 38 /*
 39  * Check if the dentry or any of it's aliases is acceptable.
 40  */
 41 static struct dentry *
 42 find_acceptable_alias(struct dentry *result,
 43                 int (*acceptable)(void *context, struct dentry *dentry),
 44                 void *context)
 45 {
 46         struct dentry *dentry, *toput = NULL;
 47         struct inode *inode;
 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, &inode->i_dentry, d_u.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 static bool dentry_connected(struct dentry *dentry)
 74 {
 75         dget(dentry);
 76         while (dentry->d_flags & DCACHE_DISCONNECTED) {
 77                 struct dentry *parent = dget_parent(dentry);
 78 
 79                 dput(dentry);
 80                 if (IS_ROOT(dentry)) {
 81                         dput(parent);
 82                         return false;
 83                 }
 84                 dentry = parent;
 85         }
 86         dput(dentry);
 87         return true;
 88 }
 89 
 90 static void clear_disconnected(struct dentry *dentry)
 91 {
 92         dget(dentry);
 93         while (dentry->d_flags & DCACHE_DISCONNECTED) {
 94                 struct dentry *parent = dget_parent(dentry);
 95 
 96                 WARN_ON_ONCE(IS_ROOT(dentry));
 97 
 98                 spin_lock(&dentry->d_lock);
 99                 dentry->d_flags &= ~DCACHE_DISCONNECTED;
100                 spin_unlock(&dentry->d_lock);
101 
102                 dput(dentry);
103                 dentry = parent;
104         }
105         dput(dentry);
106 }
107 
108 /*
109  * Reconnect a directory dentry with its parent.
110  *
111  * This can return a dentry, or NULL, or an error.
112  *
113  * In the first case the returned dentry is the parent of the given
114  * dentry, and may itself need to be reconnected to its parent.
115  *
116  * In the NULL case, a concurrent VFS operation has either renamed or
117  * removed this directory.  The concurrent operation has reconnected our
118  * dentry, so we no longer need to.
119  */
120 static struct dentry *reconnect_one(struct vfsmount *mnt,
121                 struct dentry *dentry, char *nbuf)
122 {
123         struct dentry *parent;
124         struct dentry *tmp;
125         int err;
126 
127         parent = ERR_PTR(-EACCES);
128         inode_lock(dentry->d_inode);
129         if (mnt->mnt_sb->s_export_op->get_parent)
130                 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
131         inode_unlock(dentry->d_inode);
132 
133         if (IS_ERR(parent)) {
134                 dprintk("%s: get_parent of %ld failed, err %d\n",
135                         __func__, dentry->d_inode->i_ino, PTR_ERR(parent));
136                 return parent;
137         }
138 
139         dprintk("%s: find name of %lu in %lu\n", __func__,
140                 dentry->d_inode->i_ino, parent->d_inode->i_ino);
141         err = exportfs_get_name(mnt, parent, nbuf, dentry);
142         if (err == -ENOENT)
143                 goto out_reconnected;
144         if (err)
145                 goto out_err;
146         dprintk("%s: found name: %s\n", __func__, nbuf);
147         tmp = lookup_one_len_unlocked(nbuf, parent, strlen(nbuf));
148         if (IS_ERR(tmp)) {
149                 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
150                 goto out_err;
151         }
152         if (tmp != dentry) {
153                 /*
154                  * Somebody has renamed it since exportfs_get_name();
155                  * great, since it could've only been renamed if it
156                  * got looked up and thus connected, and it would
157                  * remain connected afterwards.  We are done.
158                  */
159                 dput(tmp);
160                 goto out_reconnected;
161         }
162         dput(tmp);
163         if (IS_ROOT(dentry)) {
164                 err = -ESTALE;
165                 goto out_err;
166         }
167         return parent;
168 
169 out_err:
170         dput(parent);
171         return ERR_PTR(err);
172 out_reconnected:
173         dput(parent);
174         /*
175          * Someone must have renamed our entry into another parent, in
176          * which case it has been reconnected by the rename.
177          *
178          * Or someone removed it entirely, in which case filehandle
179          * lookup will succeed but the directory is now IS_DEAD and
180          * subsequent operations on it will fail.
181          *
182          * Alternatively, maybe there was no race at all, and the
183          * filesystem is just corrupt and gave us a parent that doesn't
184          * actually contain any entry pointing to this inode.  So,
185          * double check that this worked and return -ESTALE if not:
186          */
187         if (!dentry_connected(dentry))
188                 return ERR_PTR(-ESTALE);
189         return NULL;
190 }
191 
192 /*
193  * Make sure target_dir is fully connected to the dentry tree.
194  *
195  * On successful return, DCACHE_DISCONNECTED will be cleared on
196  * target_dir, and target_dir->d_parent->...->d_parent will reach the
197  * root of the filesystem.
198  *
199  * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
200  * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
201  * set but already be connected.  In that case we'll verify the
202  * connection to root and then clear the flag.
203  *
204  * Note that target_dir could be removed by a concurrent operation.  In
205  * that case reconnect_path may still succeed with target_dir fully
206  * connected, but further operations using the filehandle will fail when
207  * necessary (due to S_DEAD being set on the directory).
208  */
209 static int
210 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
211 {
212         struct dentry *dentry, *parent;
213 
214         dentry = dget(target_dir);
215 
216         while (dentry->d_flags & DCACHE_DISCONNECTED) {
217                 BUG_ON(dentry == mnt->mnt_sb->s_root);
218 
219                 if (IS_ROOT(dentry))
220                         parent = reconnect_one(mnt, dentry, nbuf);
221                 else
222                         parent = dget_parent(dentry);
223 
224                 if (!parent)
225                         break;
226                 dput(dentry);
227                 if (IS_ERR(parent))
228                         return PTR_ERR(parent);
229                 dentry = parent;
230         }
231         dput(dentry);
232         clear_disconnected(target_dir);
233         return 0;
234 }
235 
236 struct getdents_callback {
237         struct dir_context ctx;
238         char *name;             /* name that was found. It already points to a
239                                    buffer NAME_MAX+1 is size */
240         u64 ino;                /* the inum we are looking for */
241         int found;              /* inode matched? */
242         int sequence;           /* sequence counter */
243 };
244 
245 /*
246  * A rather strange filldir function to capture
247  * the name matching the specified inode number.
248  */
249 static int filldir_one(struct dir_context *ctx, const char *name, int len,
250                         loff_t pos, u64 ino, unsigned int d_type)
251 {
252         struct getdents_callback *buf =
253                 container_of(ctx, struct getdents_callback, ctx);
254         int result = 0;
255 
256         buf->sequence++;
257         if (buf->ino == ino && len <= NAME_MAX) {
258                 memcpy(buf->name, name, len);
259                 buf->name[len] = '\0';
260                 buf->found = 1;
261                 result = -1;
262         }
263         return result;
264 }
265 
266 /**
267  * get_name - default export_operations->get_name function
268  * @path:   the directory in which to find a name
269  * @name:   a pointer to a %NAME_MAX+1 char buffer to store the name
270  * @child:  the dentry for the child directory.
271  *
272  * calls readdir on the parent until it finds an entry with
273  * the same inode number as the child, and returns that.
274  */
275 static int get_name(const struct path *path, char *name, struct dentry *child)
276 {
277         const struct cred *cred = current_cred();
278         struct inode *dir = path->dentry->d_inode;
279         int error;
280         struct file *file;
281         struct kstat stat;
282         struct path child_path = {
283                 .mnt = path->mnt,
284                 .dentry = child,
285         };
286         struct getdents_callback buffer = {
287                 .ctx.actor = filldir_one,
288                 .name = name,
289         };
290 
291         error = -ENOTDIR;
292         if (!dir || !S_ISDIR(dir->i_mode))
293                 goto out;
294         error = -EINVAL;
295         if (!dir->i_fop)
296                 goto out;
297         /*
298          * inode->i_ino is unsigned long, kstat->ino is u64, so the
299          * former would be insufficient on 32-bit hosts when the
300          * filesystem supports 64-bit inode numbers.  So we need to
301          * actually call ->getattr, not just read i_ino:
302          */
303         error = vfs_getattr_nosec(&child_path, &stat,
304                                   STATX_INO, AT_STATX_SYNC_AS_STAT);
305         if (error)
306                 return error;
307         buffer.ino = stat.ino;
308         /*
309          * Open the directory ...
310          */
311         file = dentry_open(path, O_RDONLY, cred);
312         error = PTR_ERR(file);
313         if (IS_ERR(file))
314                 goto out;
315 
316         error = -EINVAL;
317         if (!file->f_op->iterate && !file->f_op->iterate_shared)
318                 goto out_close;
319 
320         buffer.sequence = 0;
321         while (1) {
322                 int old_seq = buffer.sequence;
323 
324                 error = iterate_dir(file, &buffer.ctx);
325                 if (buffer.found) {
326                         error = 0;
327                         break;
328                 }
329 
330                 if (error < 0)
331                         break;
332 
333                 error = -ENOENT;
334                 if (old_seq == buffer.sequence)
335                         break;
336         }
337 
338 out_close:
339         fput(file);
340 out:
341         return error;
342 }
343 
344 /**
345  * export_encode_fh - default export_operations->encode_fh function
346  * @inode:   the object to encode
347  * @fid:     where to store the file handle fragment
348  * @max_len: maximum length to store there
349  * @parent:  parent directory inode, if wanted
350  *
351  * This default encode_fh function assumes that the 32 inode number
352  * is suitable for locating an inode, and that the generation number
353  * can be used to check that it is still valid.  It places them in the
354  * filehandle fragment where export_decode_fh expects to find them.
355  */
356 static int export_encode_fh(struct inode *inode, struct fid *fid,
357                 int *max_len, struct inode *parent)
358 {
359         int len = *max_len;
360         int type = FILEID_INO32_GEN;
361 
362         if (parent && (len < 4)) {
363                 *max_len = 4;
364                 return FILEID_INVALID;
365         } else if (len < 2) {
366                 *max_len = 2;
367                 return FILEID_INVALID;
368         }
369 
370         len = 2;
371         fid->i32.ino = inode->i_ino;
372         fid->i32.gen = inode->i_generation;
373         if (parent) {
374                 fid->i32.parent_ino = parent->i_ino;
375                 fid->i32.parent_gen = parent->i_generation;
376                 len = 4;
377                 type = FILEID_INO32_GEN_PARENT;
378         }
379         *max_len = len;
380         return type;
381 }
382 
383 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
384                              int *max_len, struct inode *parent)
385 {
386         const struct export_operations *nop = inode->i_sb->s_export_op;
387 
388         if (nop && nop->encode_fh)
389                 return nop->encode_fh(inode, fid->raw, max_len, parent);
390 
391         return export_encode_fh(inode, fid, max_len, parent);
392 }
393 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
394 
395 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
396                 int connectable)
397 {
398         int error;
399         struct dentry *p = NULL;
400         struct inode *inode = dentry->d_inode, *parent = NULL;
401 
402         if (connectable && !S_ISDIR(inode->i_mode)) {
403                 p = dget_parent(dentry);
404                 /*
405                  * note that while p might've ceased to be our parent already,
406                  * it's still pinned by and still positive.
407                  */
408                 parent = p->d_inode;
409         }
410 
411         error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
412         dput(p);
413 
414         return error;
415 }
416 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
417 
418 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
419                 int fh_len, int fileid_type,
420                 int (*acceptable)(void *, struct dentry *), void *context)
421 {
422         const struct export_operations *nop = mnt->mnt_sb->s_export_op;
423         struct dentry *result, *alias;
424         char nbuf[NAME_MAX+1];
425         int err;
426 
427         /*
428          * Try to get any dentry for the given file handle from the filesystem.
429          */
430         if (!nop || !nop->fh_to_dentry)
431                 return ERR_PTR(-ESTALE);
432         result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
433         if (PTR_ERR(result) == -ENOMEM)
434                 return ERR_CAST(result);
435         if (IS_ERR_OR_NULL(result))
436                 return ERR_PTR(-ESTALE);
437 
438         if (d_is_dir(result)) {
439                 /*
440                  * This request is for a directory.
441                  *
442                  * On the positive side there is only one dentry for each
443                  * directory inode.  On the negative side this implies that we
444                  * to ensure our dentry is connected all the way up to the
445                  * filesystem root.
446                  */
447                 if (result->d_flags & DCACHE_DISCONNECTED) {
448                         err = reconnect_path(mnt, result, nbuf);
449                         if (err)
450                                 goto err_result;
451                 }
452 
453                 if (!acceptable(context, result)) {
454                         err = -EACCES;
455                         goto err_result;
456                 }
457 
458                 return result;
459         } else {
460                 /*
461                  * It's not a directory.  Life is a little more complicated.
462                  */
463                 struct dentry *target_dir, *nresult;
464 
465                 /*
466                  * See if either the dentry we just got from the filesystem
467                  * or any alias for it is acceptable.  This is always true
468                  * if this filesystem is exported without the subtreecheck
469                  * option.  If the filesystem is exported with the subtree
470                  * check option there's a fair chance we need to look at
471                  * the parent directory in the file handle and make sure
472                  * it's connected to the filesystem root.
473                  */
474                 alias = find_acceptable_alias(result, acceptable, context);
475                 if (alias)
476                         return alias;
477 
478                 /*
479                  * Try to extract a dentry for the parent directory from the
480                  * file handle.  If this fails we'll have to give up.
481                  */
482                 err = -ESTALE;
483                 if (!nop->fh_to_parent)
484                         goto err_result;
485 
486                 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
487                                 fh_len, fileid_type);
488                 if (!target_dir)
489                         goto err_result;
490                 err = PTR_ERR(target_dir);
491                 if (IS_ERR(target_dir))
492                         goto err_result;
493 
494                 /*
495                  * And as usual we need to make sure the parent directory is
496                  * connected to the filesystem root.  The VFS really doesn't
497                  * like disconnected directories..
498                  */
499                 err = reconnect_path(mnt, target_dir, nbuf);
500                 if (err) {
501                         dput(target_dir);
502                         goto err_result;
503                 }
504 
505                 /*
506                  * Now that we've got both a well-connected parent and a
507                  * dentry for the inode we're after, make sure that our
508                  * inode is actually connected to the parent.
509                  */
510                 err = exportfs_get_name(mnt, target_dir, nbuf, result);
511                 if (!err) {
512                         inode_lock(target_dir->d_inode);
513                         nresult = lookup_one_len(nbuf, target_dir,
514                                                  strlen(nbuf));
515                         inode_unlock(target_dir->d_inode);
516                         if (!IS_ERR(nresult)) {
517                                 if (nresult->d_inode) {
518                                         dput(result);
519                                         result = nresult;
520                                 } else
521                                         dput(nresult);
522                         }
523                 }
524 
525                 /*
526                  * At this point we are done with the parent, but it's pinned
527                  * by the child dentry anyway.
528                  */
529                 dput(target_dir);
530 
531                 /*
532                  * And finally make sure the dentry is actually acceptable
533                  * to NFSD.
534                  */
535                 alias = find_acceptable_alias(result, acceptable, context);
536                 if (!alias) {
537                         err = -EACCES;
538                         goto err_result;
539                 }
540 
541                 return alias;
542         }
543 
544  err_result:
545         dput(result);
546         if (err != -ENOMEM)
547                 err = -ESTALE;
548         return ERR_PTR(err);
549 }
550 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
551 
552 MODULE_LICENSE("GPL");
553 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp