LCOV - code coverage report
Current view: top level - fs/exportfs - expfs.c (source / functions) Hit Total Coverage
Test: Real Lines: 18 163 11.0 %
Date: 2020-10-17 15:46:43 Functions: 0 11 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14