fs/overlayfs/export.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Overlayfs NFS export support.
   4  *
   5  * Amir Goldstein <amir73il@gmail.com>
   6  *
   7  * Copyright (C) 2017-2018 CTERA Networks. All Rights Reserved.
   8  */
   9
  10 #include <linux/fs.h>
  11 #include <linux/cred.h>
  12 #include <linux/mount.h>
  13 #include <linux/namei.h>
  14 #include <linux/xattr.h>
  15 #include <linux/exportfs.h>
  16 #include <linux/ratelimit.h>
  17 #include "overlayfs.h"
  18
  19 static int ovl_encode_maybe_copy_up(struct dentry *dentry)
  20 {
  21         int err;
  22
  23         if (ovl_dentry_upper(dentry))
  24                 return 0;
  25
  26         err = ovl_copy_up(dentry);
  27         if (err) {
  28                 pr_warn_ratelimited("failed to copy up on encode (%pd2, err=%i)\n",
  29                                     dentry, err);
  30         }
  31
  32         return err;
  33 }
  34
  35 /*
  36  * Before encoding a non-upper directory file handle from real layer N, we need
  37  * to check if it will be possible to reconnect an overlay dentry from the real
  38  * lower decoded dentry. This is done by following the overlay ancestry up to a
  39  * "layer N connected" ancestor and verifying that all parents along the way are
  40  * "layer N connectable". If an ancestor that is NOT "layer N connectable" is
  41  * found, we need to copy up an ancestor, which is "layer N connectable", thus
  42  * making that ancestor "layer N connected". For example:
  43  *
  44  * layer 1: /a
  45  * layer 2: /a/b/c
  46  *
  47  * The overlay dentry /a is NOT "layer 2 connectable", because if dir /a is
  48  * copied up and renamed, upper dir /a will be indexed by lower dir /a from
  49  * layer 1. The dir /a from layer 2 will never be indexed, so the algorithm (*)
  50  * in ovl_lookup_real_ancestor() will not be able to lookup a connected overlay
  51  * dentry from the connected lower dentry /a/b/c.
  52  *
  53  * To avoid this problem on decode time, we need to copy up an ancestor of
  54  * /a/b/c, which is "layer 2 connectable", on encode time. That ancestor is
  55  * /a/b. After copy up (and index) of /a/b, it will become "layer 2 connected"
  56  * and when the time comes to decode the file handle from lower dentry /a/b/c,
  57  * ovl_lookup_real_ancestor() will find the indexed ancestor /a/b and decoding
  58  * a connected overlay dentry will be accomplished.
  59  *
  60  * (*) the algorithm in ovl_lookup_real_ancestor() can be improved to lookup an
  61  * entry /a in the lower layers above layer N and find the indexed dir /a from
  62  * layer 1. If that improvement is made, then the check for "layer N connected"
  63  * will need to verify there are no redirects in lower layers above N. In the
  64  * example above, /a will be "layer 2 connectable". However, if layer 2 dir /a
  65  * is a target of a layer 1 redirect, then /a will NOT be "layer 2 connectable":
  66  *
  67  * layer 1: /A (redirect = /a)
  68  * layer 2: /a/b/c
  69  */
  70
  71 /* Return the lowest layer for encoding a connectable file handle */
  72 static int ovl_connectable_layer(struct dentry *dentry)
  73 {
  74         struct ovl_entry *oe = OVL_E(dentry);
  75
  76         /* We can get overlay root from root of any layer */
  77         if (dentry == dentry->d_sb->s_root)
  78                 return ovl_numlower(oe);
  79
  80         /*
  81          * If it's an unindexed merge dir, then it's not connectable with any
  82          * lower layer
  83          */
  84         if (ovl_dentry_upper(dentry) &&
  85             !ovl_test_flag(OVL_INDEX, d_inode(dentry)))
  86                 return 0;
  87
  88         /* We can get upper/overlay path from indexed/lower dentry */
  89         return ovl_lowerstack(oe)->layer->idx;
  90 }
  91
  92 /*
  93  * @dentry is "connected" if all ancestors up to root or a "connected" ancestor
  94  * have the same uppermost lower layer as the origin's layer. We may need to
  95  * copy up a "connectable" ancestor to make it "connected". A "connected" dentry
  96  * cannot become non "connected", so cache positive result in dentry flags.
  97  *
  98  * Return the connected origin layer or < 0 on error.
  99  */
 100 static int ovl_connect_layer(struct dentry *dentry)
 101 {
 102         struct dentry *next, *parent = NULL;
 103         struct ovl_entry *oe = OVL_E(dentry);
 104         int origin_layer;
 105         int err = 0;
 106
 107         if (WARN_ON(dentry == dentry->d_sb->s_root) ||
 108             WARN_ON(!ovl_dentry_lower(dentry)))
 109                 return -EIO;
 110
 111         origin_layer = ovl_lowerstack(oe)->layer->idx;
 112         if (ovl_dentry_test_flag(OVL_E_CONNECTED, dentry))
 113                 return origin_layer;
 114
 115         /* Find the topmost origin layer connectable ancestor of @dentry */
 116         next = dget(dentry);
 117         for (;;) {
 118                 parent = dget_parent(next);
 119                 if (WARN_ON(parent == next)) {
 120                         err = -EIO;
 121                         break;
 122                 }
 123
 124                 /*
 125                  * If @parent is not origin layer connectable, then copy up
 126                  * @next which is origin layer connectable and we are done.
 127                  */
 128                 if (ovl_connectable_layer(parent) < origin_layer) {
 129                         err = ovl_encode_maybe_copy_up(next);
 130                         break;
 131                 }
 132
 133                 /* If @parent is connected or indexed we are done */
 134                 if (ovl_dentry_test_flag(OVL_E_CONNECTED, parent) ||
 135                     ovl_test_flag(OVL_INDEX, d_inode(parent)))
 136                         break;
 137
 138                 dput(next);
 139                 next = parent;
 140         }
 141
 142         dput(parent);
 143         dput(next);
 144
 145         if (!err)
 146                 ovl_dentry_set_flag(OVL_E_CONNECTED, dentry);
 147
 148         return err ?: origin_layer;
 149 }
 150
 151 /*
 152  * We only need to encode origin if there is a chance that the same object was
 153  * encoded pre copy up and then we need to stay consistent with the same
 154  * encoding also after copy up. If non-pure upper is not indexed, then it was
 155  * copied up before NFS export was enabled. In that case we don't need to worry
 156  * about staying consistent with pre copy up encoding and we encode an upper
 157  * file handle. Overlay root dentry is a private case of non-indexed upper.
 158  *
 159  * The following table summarizes the different file handle encodings used for
 160  * different overlay object types:
 161  *
 162  *  Object type         | Encoding
 163  * --------------------------------
 164  *  Pure upper          | U
 165  *  Non-indexed upper   | U
 166  *  Indexed upper       | L (*)
 167  *  Non-upper           | L (*)
 168  *
 169  * U = upper file handle
 170  * L = lower file handle
 171  *
 172  * (*) Decoding a connected overlay dir from real lower dentry is not always
 173  * possible when there are redirects in lower layers and non-indexed merge dirs.
 174  * To mitigate those case, we may copy up the lower dir ancestor before encode
 175  * of a decodable file handle for non-upper dir.
 176  *
 177  * Return 0 for upper file handle, > 0 for lower file handle or < 0 on error.
 178  */
 179 static int ovl_check_encode_origin(struct inode *inode)
 180 {
 181         struct ovl_fs *ofs = OVL_FS(inode->i_sb);
 182         bool decodable = ofs->config.nfs_export;
 183         struct dentry *dentry;
 184         int err;
 185
 186         /* No upper layer? */
 187         if (!ovl_upper_mnt(ofs))
 188                 return 1;
 189
 190         /* Lower file handle for non-upper non-decodable */
 191         if (!ovl_inode_upper(inode) && !decodable)
 192                 return 1;
 193
 194         /* Upper file handle for pure upper */
 195         if (!ovl_inode_lower(inode))
 196                 return 0;
 197
 198         /*
 199          * Root is never indexed, so if there's an upper layer, encode upper for
 200          * root.
 201          */
 202         if (inode == d_inode(inode->i_sb->s_root))
 203                 return 0;
 204
 205         /*
 206          * Upper decodable file handle for non-indexed upper.
 207          */
 208         if (ovl_inode_upper(inode) && decodable &&
 209             !ovl_test_flag(OVL_INDEX, inode))
 210                 return 0;
 211
 212         /*
 213          * Decoding a merge dir, whose origin's ancestor is under a redirected
 214          * lower dir or under a non-indexed upper is not always possible.
 215          * ovl_connect_layer() will try to make origin's layer "connected" by
 216          * copying up a "connectable" ancestor.
 217          */
 218         if (!decodable || !S_ISDIR(inode->i_mode))
 219                 return 1;
 220
 221         dentry = d_find_any_alias(inode);
 222         if (!dentry)
 223                 return -ENOENT;
 224
 225         err = ovl_connect_layer(dentry);
 226         dput(dentry);
 227         if (err < 0)
 228                 return err;
 229
 230         /* Lower file handle for indexed and non-upper dir/non-dir */
 231         return 1;
 232 }
 233
 234 static int ovl_dentry_to_fid(struct ovl_fs *ofs, struct inode *inode,
 235                              u32 *fid, int buflen)
 236 {
 237         struct ovl_fh *fh = NULL;
 238         int err, enc_lower;
 239         int len;
 240
 241         /*
 242          * Check if we should encode a lower or upper file handle and maybe
 243          * copy up an ancestor to make lower file handle connectable.
 244          */
 245         err = enc_lower = ovl_check_encode_origin(inode);
 246         if (enc_lower < 0)
 247                 goto fail;
 248
 249         /* Encode an upper or lower file handle */
 250         fh = ovl_encode_real_fh(ofs, enc_lower ? ovl_inode_lower(inode) :
 251                                 ovl_inode_upper(inode), !enc_lower);
 252         if (IS_ERR(fh))
 253                 return PTR_ERR(fh);
 254
 255         len = OVL_FH_LEN(fh);
 256         if (len <= buflen)
 257                 memcpy(fid, fh, len);
 258         err = len;
 259
 260 out:
 261         kfree(fh);
 262         return err;
 263
 264 fail:
 265         pr_warn_ratelimited("failed to encode file handle (ino=%lu, err=%i)\n",
 266                             inode->i_ino, err);
 267         goto out;
 268 }
 269
 270 static int ovl_encode_fh(struct inode *inode, u32 *fid, int *max_len,
 271                          struct inode *parent)
 272 {
 273         struct ovl_fs *ofs = OVL_FS(inode->i_sb);
 274         int bytes, buflen = *max_len << 2;
 275
 276         /* TODO: encode connectable file handles */
 277         if (parent)
 278                 return FILEID_INVALID;
 279
 280         bytes = ovl_dentry_to_fid(ofs, inode, fid, buflen);
 281         if (bytes <= 0)
 282                 return FILEID_INVALID;
 283
 284         *max_len = bytes >> 2;
 285         if (bytes > buflen)
 286                 return FILEID_INVALID;
 287
 288         return OVL_FILEID_V1;
 289 }
 290
 291 /*
 292  * Find or instantiate an overlay dentry from real dentries and index.
 293  */
 294 static struct dentry *ovl_obtain_alias(struct super_block *sb,
 295                                        struct dentry *upper_alias,
 296                                        struct ovl_path *lowerpath,
 297                                        struct dentry *index)
 298 {
 299         struct dentry *lower = lowerpath ? lowerpath->dentry : NULL;
 300         struct dentry *upper = upper_alias ?: index;
 301         struct inode *inode = NULL;
 302         struct ovl_entry *oe;
 303         struct ovl_inode_params oip = {
 304                 .index = index,
 305         };
 306
 307         /* We get overlay directory dentries with ovl_lookup_real() */
 308         if (d_is_dir(upper ?: lower))
 309                 return ERR_PTR(-EIO);
 310
 311         oe = ovl_alloc_entry(!!lower);
 312         if (!oe)
 313                 return ERR_PTR(-ENOMEM);
 314
 315         oip.upperdentry = dget(upper);
 316         if (lower) {
 317                 ovl_lowerstack(oe)->dentry = dget(lower);
 318                 ovl_lowerstack(oe)->layer = lowerpath->layer;
 319         }
 320         oip.oe = oe;
 321         inode = ovl_get_inode(sb, &oip);
 322         if (IS_ERR(inode)) {
 323                 ovl_free_entry(oe);
 324                 dput(upper);
 325                 return ERR_CAST(inode);
 326         }
 327
 328         if (upper)
 329                 ovl_set_flag(OVL_UPPERDATA, inode);
 330
 331         return d_obtain_alias(inode);
 332 }
 333
 334 /* Get the upper or lower dentry in stack whose on layer @idx */
 335 static struct dentry *ovl_dentry_real_at(struct dentry *dentry, int idx)
 336 {
 337         struct ovl_entry *oe = OVL_E(dentry);
 338         struct ovl_path *lowerstack = ovl_lowerstack(oe);
 339         int i;
 340
 341         if (!idx)
 342                 return ovl_dentry_upper(dentry);
 343
 344         for (i = 0; i < ovl_numlower(oe); i++) {
 345                 if (lowerstack[i].layer->idx == idx)
 346                         return lowerstack[i].dentry;
 347         }
 348
 349         return NULL;
 350 }
 351
 352 /*
 353  * Lookup a child overlay dentry to get a connected overlay dentry whose real
 354  * dentry is @real. If @real is on upper layer, we lookup a child overlay
 355  * dentry with the same name as the real dentry. Otherwise, we need to consult
 356  * index for lookup.
 357  */
 358 static struct dentry *ovl_lookup_real_one(struct dentry *connected,
 359                                           struct dentry *real,
 360                                           const struct ovl_layer *layer)
 361 {
 362         struct inode *dir = d_inode(connected);
 363         struct dentry *this, *parent = NULL;
 364         struct name_snapshot name;
 365         int err;
 366
 367         /*
 368          * Lookup child overlay dentry by real name. The dir mutex protects us
 369          * from racing with overlay rename. If the overlay dentry that is above
 370          * real has already been moved to a parent that is not under the
 371          * connected overlay dir, we return -ECHILD and restart the lookup of
 372          * connected real path from the top.
 373          */
 374         inode_lock_nested(dir, I_MUTEX_PARENT);
 375         err = -ECHILD;
 376         parent = dget_parent(real);
 377         if (ovl_dentry_real_at(connected, layer->idx) != parent)
 378                 goto fail;
 379
 380         /*
 381          * We also need to take a snapshot of real dentry name to protect us
 382          * from racing with underlying layer rename. In this case, we don't
 383          * care about returning ESTALE, only from dereferencing a free name
 384          * pointer because we hold no lock on the real dentry.
 385          */
 386         take_dentry_name_snapshot(&name, real);
 387         /*
 388          * No idmap handling here: it's an internal lookup.
 389          */
 390         this = lookup_noperm(&name.name, connected);
 391         release_dentry_name_snapshot(&name);
 392         err = PTR_ERR(this);
 393         if (IS_ERR(this)) {
 394                 goto fail;
 395         } else if (!this || !this->d_inode) {
 396                 dput(this);
 397                 err = -ENOENT;
 398                 goto fail;
 399         } else if (ovl_dentry_real_at(this, layer->idx) != real) {
 400                 dput(this);
 401                 err = -ESTALE;
 402                 goto fail;
 403         }
 404
 405 out:
 406         dput(parent);
 407         inode_unlock(dir);
 408         return this;
 409
 410 fail:
 411         pr_warn_ratelimited("failed to lookup one by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
 412                             real, layer->idx, connected, err);
 413         this = ERR_PTR(err);
 414         goto out;
 415 }
 416
 417 static struct dentry *ovl_lookup_real(struct super_block *sb,
 418                                       struct dentry *real,
 419                                       const struct ovl_layer *layer);
 420
 421 /*
 422  * Lookup an indexed or hashed overlay dentry by real inode.
 423  */
 424 static struct dentry *ovl_lookup_real_inode(struct super_block *sb,
 425                                             struct dentry *real,
 426                                             const struct ovl_layer *layer)
 427 {
 428         struct ovl_fs *ofs = OVL_FS(sb);
 429         struct dentry *index = NULL;
 430         struct dentry *this = NULL;
 431         struct inode *inode;
 432
 433         /*
 434          * Decoding upper dir from index is expensive, so first try to lookup
 435          * overlay dentry in inode/dcache.
 436          */
 437         inode = ovl_lookup_inode(sb, real, !layer->idx);
 438         if (IS_ERR(inode))
 439                 return ERR_CAST(inode);
 440         if (inode) {
 441                 this = d_find_any_alias(inode);
 442                 iput(inode);
 443         }
 444
 445         /*
 446          * For decoded lower dir file handle, lookup index by origin to check
 447          * if lower dir was copied up and and/or removed.
 448          */
 449         if (!this && layer->idx && ovl_indexdir(sb) && !WARN_ON(!d_is_dir(real))) {
 450                 index = ovl_lookup_index(ofs, NULL, real, false);
 451                 if (IS_ERR(index))
 452                         return index;
 453         }
 454
 455         /* Get connected upper overlay dir from index */
 456         if (index) {
 457                 struct dentry *upper = ovl_index_upper(ofs, index, true);
 458
 459                 dput(index);
 460                 if (IS_ERR_OR_NULL(upper))
 461                         return upper;
 462
 463                 /*
 464                  * ovl_lookup_real() in lower layer may call recursively once to
 465                  * ovl_lookup_real() in upper layer. The first level call walks
 466                  * back lower parents to the topmost indexed parent. The second
 467                  * recursive call walks back from indexed upper to the topmost
 468                  * connected/hashed upper parent (or up to root).
 469                  */
 470                 this = ovl_lookup_real(sb, upper, &ofs->layers[0]);
 471                 dput(upper);
 472         }
 473
 474         if (IS_ERR_OR_NULL(this))
 475                 return this;
 476
 477         if (ovl_dentry_real_at(this, layer->idx) != real) {
 478                 dput(this);
 479                 this = ERR_PTR(-EIO);
 480         }
 481
 482         return this;
 483 }
 484
 485 /*
 486  * Lookup an indexed or hashed overlay dentry, whose real dentry is an
 487  * ancestor of @real.
 488  */
 489 static struct dentry *ovl_lookup_real_ancestor(struct super_block *sb,
 490                                                struct dentry *real,
 491                                                const struct ovl_layer *layer)
 492 {
 493         struct dentry *next, *parent = NULL;
 494         struct dentry *ancestor = ERR_PTR(-EIO);
 495
 496         if (real == layer->mnt->mnt_root)
 497                 return dget(sb->s_root);
 498
 499         /* Find the topmost indexed or hashed ancestor */
 500         next = dget(real);
 501         for (;;) {
 502                 parent = dget_parent(next);
 503
 504                 /*
 505                  * Lookup a matching overlay dentry in inode/dentry
 506                  * cache or in index by real inode.
 507                  */
 508                 ancestor = ovl_lookup_real_inode(sb, next, layer);
 509                 if (ancestor)
 510                         break;
 511
 512                 if (parent == layer->mnt->mnt_root) {
 513                         ancestor = dget(sb->s_root);
 514                         break;
 515                 }
 516
 517                 /*
 518                  * If @real has been moved out of the layer root directory,
 519                  * we will eventully hit the real fs root. This cannot happen
 520                  * by legit overlay rename, so we return error in that case.
 521                  */
 522                 if (parent == next) {
 523                         ancestor = ERR_PTR(-EXDEV);
 524                         break;
 525                 }
 526
 527                 dput(next);
 528                 next = parent;
 529         }
 530
 531         dput(parent);
 532         dput(next);
 533
 534         return ancestor;
 535 }
 536
 537 /*
 538  * Lookup a connected overlay dentry whose real dentry is @real.
 539  * If @real is on upper layer, we lookup a child overlay dentry with the same
 540  * path the real dentry. Otherwise, we need to consult index for lookup.
 541  */
 542 static struct dentry *ovl_lookup_real(struct super_block *sb,
 543                                       struct dentry *real,
 544                                       const struct ovl_layer *layer)
 545 {
 546         struct dentry *connected;
 547         int err = 0;
 548
 549         connected = ovl_lookup_real_ancestor(sb, real, layer);
 550         if (IS_ERR(connected))
 551                 return connected;
 552
 553         while (!err) {
 554                 struct dentry *next, *this;
 555                 struct dentry *parent = NULL;
 556                 struct dentry *real_connected = ovl_dentry_real_at(connected,
 557                                                                    layer->idx);
 558
 559                 if (real_connected == real)
 560                         break;
 561
 562                 /* Find the topmost dentry not yet connected */
 563                 next = dget(real);
 564                 for (;;) {
 565                         parent = dget_parent(next);
 566
 567                         if (parent == real_connected)
 568                                 break;
 569
 570                         /*
 571                          * If real has been moved out of 'real_connected',
 572                          * we will not find 'real_connected' and hit the layer
 573                          * root. In that case, we need to restart connecting.
 574                          * This game can go on forever in the worst case. We
 575                          * may want to consider taking s_vfs_rename_mutex if
 576                          * this happens more than once.
 577                          */
 578                         if (parent == layer->mnt->mnt_root) {
 579                                 dput(connected);
 580                                 connected = dget(sb->s_root);
 581                                 break;
 582                         }
 583
 584                         /*
 585                          * If real file has been moved out of the layer root
 586                          * directory, we will eventully hit the real fs root.
 587                          * This cannot happen by legit overlay rename, so we
 588                          * return error in that case.
 589                          */
 590                         if (parent == next) {
 591                                 err = -EXDEV;
 592                                 break;
 593                         }
 594
 595                         dput(next);
 596                         next = parent;
 597                 }
 598
 599                 if (!err) {
 600                         this = ovl_lookup_real_one(connected, next, layer);
 601                         if (IS_ERR(this))
 602                                 err = PTR_ERR(this);
 603
 604                         /*
 605                          * Lookup of child in overlay can fail when racing with
 606                          * overlay rename of child away from 'connected' parent.
 607                          * In this case, we need to restart the lookup from the
 608                          * top, because we cannot trust that 'real_connected' is
 609                          * still an ancestor of 'real'. There is a good chance
 610                          * that the renamed overlay ancestor is now in cache, so
 611                          * ovl_lookup_real_ancestor() will find it and we can
 612                          * continue to connect exactly from where lookup failed.
 613                          */
 614                         if (err == -ECHILD) {
 615                                 this = ovl_lookup_real_ancestor(sb, real,
 616                                                                 layer);
 617                                 err = PTR_ERR_OR_ZERO(this);
 618                         }
 619                         if (!err) {
 620                                 dput(connected);
 621                                 connected = this;
 622                         }
 623                 }
 624
 625                 dput(parent);
 626                 dput(next);
 627         }
 628
 629         if (err)
 630                 goto fail;
 631
 632         return connected;
 633
 634 fail:
 635         pr_warn_ratelimited("failed to lookup by real (%pd2, layer=%d, connected=%pd2, err=%i)\n",
 636                             real, layer->idx, connected, err);
 637         dput(connected);
 638         return ERR_PTR(err);
 639 }
 640
 641 /*
 642  * Get an overlay dentry from upper/lower real dentries and index.
 643  */
 644 static struct dentry *ovl_get_dentry(struct super_block *sb,
 645                                      struct dentry *upper,
 646                                      struct ovl_path *lowerpath,
 647                                      struct dentry *index)
 648 {
 649         struct ovl_fs *ofs = OVL_FS(sb);
 650         const struct ovl_layer *layer = upper ? &ofs->layers[0] : lowerpath->layer;
 651         struct dentry *real = upper ?: (index ?: lowerpath->dentry);
 652
 653         /*
 654          * Obtain a disconnected overlay dentry from a non-dir real dentry
 655          * and index.
 656          */
 657         if (!d_is_dir(real))
 658                 return ovl_obtain_alias(sb, upper, lowerpath, index);
 659
 660         /* Removed empty directory? */
 661         if ((real->d_flags & DCACHE_DISCONNECTED) || d_unhashed(real))
 662                 return ERR_PTR(-ENOENT);
 663
 664         /*
 665          * If real dentry is connected and hashed, get a connected overlay
 666          * dentry whose real dentry is @real.
 667          */
 668         return ovl_lookup_real(sb, real, layer);
 669 }
 670
 671 static struct dentry *ovl_upper_fh_to_d(struct super_block *sb,
 672                                         struct ovl_fh *fh)
 673 {
 674         struct ovl_fs *ofs = OVL_FS(sb);
 675         struct dentry *dentry;
 676         struct dentry *upper;
 677
 678         if (!ovl_upper_mnt(ofs))
 679                 return ERR_PTR(-EACCES);
 680
 681         upper = ovl_decode_real_fh(ofs, fh, ovl_upper_mnt(ofs), true);
 682         if (IS_ERR_OR_NULL(upper))
 683                 return upper;
 684
 685         dentry = ovl_get_dentry(sb, upper, NULL, NULL);
 686         dput(upper);
 687
 688         return dentry;
 689 }
 690
 691 static struct dentry *ovl_lower_fh_to_d(struct super_block *sb,
 692                                         struct ovl_fh *fh)
 693 {
 694         struct ovl_fs *ofs = OVL_FS(sb);
 695         struct ovl_path origin = { };
 696         struct ovl_path *stack = &origin;
 697         struct dentry *dentry = NULL;
 698         struct dentry *index = NULL;
 699         struct inode *inode;
 700         int err;
 701
 702         /* First lookup overlay inode in inode cache by origin fh */
 703         err = ovl_check_origin_fh(ofs, fh, false, NULL, &stack);
 704         if (err)
 705                 return ERR_PTR(err);
 706
 707         if (!d_is_dir(origin.dentry) ||
 708             !(origin.dentry->d_flags & DCACHE_DISCONNECTED)) {
 709                 inode = ovl_lookup_inode(sb, origin.dentry, false);
 710                 err = PTR_ERR(inode);
 711                 if (IS_ERR(inode))
 712                         goto out_err;
 713                 if (inode) {
 714                         dentry = d_find_any_alias(inode);
 715                         iput(inode);
 716                         if (dentry)
 717                                 goto out;
 718                 }
 719         }
 720
 721         /* Then lookup indexed upper/whiteout by origin fh */
 722         if (ovl_indexdir(sb)) {
 723                 index = ovl_get_index_fh(ofs, fh);
 724                 err = PTR_ERR(index);
 725                 if (IS_ERR(index)) {
 726                         index = NULL;
 727                         goto out_err;
 728                 }
 729         }
 730
 731         /* Then try to get a connected upper dir by index */
 732         if (index && d_is_dir(index)) {
 733                 struct dentry *upper = ovl_index_upper(ofs, index, true);
 734
 735                 err = PTR_ERR(upper);
 736                 if (IS_ERR_OR_NULL(upper))
 737                         goto out_err;
 738
 739                 dentry = ovl_get_dentry(sb, upper, NULL, NULL);
 740                 dput(upper);
 741                 goto out;
 742         }
 743
 744         /* Find origin.dentry again with ovl_acceptable() layer check */
 745         if (d_is_dir(origin.dentry)) {
 746                 dput(origin.dentry);
 747                 origin.dentry = NULL;
 748                 err = ovl_check_origin_fh(ofs, fh, true, NULL, &stack);
 749                 if (err)
 750                         goto out_err;
 751         }
 752         if (index) {
 753                 err = ovl_verify_origin(ofs, index, origin.dentry, false);
 754                 if (err)
 755                         goto out_err;
 756         }
 757
 758         /* Get a connected non-upper dir or disconnected non-dir */
 759         dentry = ovl_get_dentry(sb, NULL, &origin, index);
 760
 761 out:
 762         dput(origin.dentry);
 763         dput(index);
 764         return dentry;
 765
 766 out_err:
 767         dentry = ERR_PTR(err);
 768         goto out;
 769 }
 770
 771 static struct ovl_fh *ovl_fid_to_fh(struct fid *fid, int buflen, int fh_type)
 772 {
 773         struct ovl_fh *fh;
 774
 775         /* If on-wire inner fid is aligned - nothing to do */
 776         if (fh_type == OVL_FILEID_V1)
 777                 return (struct ovl_fh *)fid;
 778
 779         if (fh_type != OVL_FILEID_V0)
 780                 return ERR_PTR(-EINVAL);
 781
 782         if (buflen <= OVL_FH_WIRE_OFFSET)
 783                 return ERR_PTR(-EINVAL);
 784
 785         fh = kzalloc(buflen, GFP_KERNEL);
 786         if (!fh)
 787                 return ERR_PTR(-ENOMEM);
 788
 789         /* Copy unaligned inner fh into aligned buffer */
 790         memcpy(fh->buf, fid, buflen - OVL_FH_WIRE_OFFSET);
 791         return fh;
 792 }
 793
 794 static struct dentry *ovl_fh_to_dentry(struct super_block *sb, struct fid *fid,
 795                                        int fh_len, int fh_type)
 796 {
 797         struct dentry *dentry = NULL;
 798         struct ovl_fh *fh = NULL;
 799         int len = fh_len << 2;
 800         unsigned int flags = 0;
 801         int err;
 802
 803         fh = ovl_fid_to_fh(fid, len, fh_type);
 804         err = PTR_ERR(fh);
 805         if (IS_ERR(fh))
 806                 goto out_err;
 807
 808         err = ovl_check_fh_len(fh, len);
 809         if (err)
 810                 goto out_err;
 811
 812         flags = fh->fb.flags;
 813         dentry = (flags & OVL_FH_FLAG_PATH_UPPER) ?
 814                  ovl_upper_fh_to_d(sb, fh) :
 815                  ovl_lower_fh_to_d(sb, fh);
 816         err = PTR_ERR(dentry);
 817         if (IS_ERR(dentry) && err != -ESTALE)
 818                 goto out_err;
 819
 820 out:
 821         /* We may have needed to re-align OVL_FILEID_V0 */
 822         if (!IS_ERR_OR_NULL(fh) && fh != (void *)fid)
 823                 kfree(fh);
 824
 825         return dentry;
 826
 827 out_err:
 828         pr_warn_ratelimited("failed to decode file handle (len=%d, type=%d, flags=%x, err=%i)\n",
 829                             fh_len, fh_type, flags, err);
 830         dentry = ERR_PTR(err);
 831         goto out;
 832 }
 833
 834 static struct dentry *ovl_fh_to_parent(struct super_block *sb, struct fid *fid,
 835                                        int fh_len, int fh_type)
 836 {
 837         pr_warn_ratelimited("connectable file handles not supported; use 'no_subtree_check' exportfs option.\n");
 838         return ERR_PTR(-EACCES);
 839 }
 840
 841 static int ovl_get_name(struct dentry *parent, char *name,
 842                         struct dentry *child)
 843 {
 844         /*
 845          * ovl_fh_to_dentry() returns connected dir overlay dentries and
 846          * ovl_fh_to_parent() is not implemented, so we should not get here.
 847          */
 848         WARN_ON_ONCE(1);
 849         return -EIO;
 850 }
 851
 852 static struct dentry *ovl_get_parent(struct dentry *dentry)
 853 {
 854         /*
 855          * ovl_fh_to_dentry() returns connected dir overlay dentries, so we
 856          * should not get here.
 857          */
 858         WARN_ON_ONCE(1);
 859         return ERR_PTR(-EIO);
 860 }
 861
 862 const struct export_operations ovl_export_operations = {
 863         .encode_fh      = ovl_encode_fh,
 864         .fh_to_dentry   = ovl_fh_to_dentry,
 865         .fh_to_parent   = ovl_fh_to_parent,
 866         .get_name       = ovl_get_name,
 867         .get_parent     = ovl_get_parent,
 868 };
 869
 870 /* encode_fh() encodes non-decodable file handles with nfs_export=off */
 871 const struct export_operations ovl_export_fid_operations = {
 872         .encode_fh      = ovl_encode_fh,
 873 };