fs/overlayfs/namei.c

   1 /*
   2  * Copyright (C) 2011 Novell Inc.
   3  * Copyright (C) 2016 Red Hat, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  */
   9
  10 #include <linux/fs.h>
  11 #include <linux/cred.h>
  12 #include <linux/namei.h>
  13 #include <linux/xattr.h>
  14 #include <linux/ratelimit.h>
  15 #include <linux/mount.h>
  16 #include <linux/exportfs.h>
  17 #include "overlayfs.h"
  18 #include "ovl_entry.h"
  19
  20 struct ovl_lookup_data {
  21         struct qstr name;
  22         bool is_dir;
  23         bool opaque;
  24         bool stop;
  25         bool last;
  26         char *redirect;
  27 };
  28
  29 static int ovl_check_redirect(struct dentry *dentry, struct ovl_lookup_data *d,
  30                               size_t prelen, const char *post)
  31 {
  32         int res;
  33         char *s, *next, *buf = NULL;
  34
  35         res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, NULL, 0);
  36         if (res < 0) {
  37                 if (res == -ENODATA || res == -EOPNOTSUPP)
  38                         return 0;
  39                 goto fail;
  40         }
  41         buf = kzalloc(prelen + res + strlen(post) + 1, GFP_TEMPORARY);
  42         if (!buf)
  43                 return -ENOMEM;
  44
  45         if (res == 0)
  46                 goto invalid;
  47
  48         res = vfs_getxattr(dentry, OVL_XATTR_REDIRECT, buf, res);
  49         if (res < 0)
  50                 goto fail;
  51         if (res == 0)
  52                 goto invalid;
  53         if (buf[0] == '/') {
  54                 for (s = buf; *s++ == '/'; s = next) {
  55                         next = strchrnul(s, '/');
  56                         if (s == next)
  57                                 goto invalid;
  58                 }
  59         } else {
  60                 if (strchr(buf, '/') != NULL)
  61                         goto invalid;
  62
  63                 memmove(buf + prelen, buf, res);
  64                 memcpy(buf, d->name.name, prelen);
  65         }
  66
  67         strcat(buf, post);
  68         kfree(d->redirect);
  69         d->redirect = buf;
  70         d->name.name = d->redirect;
  71         d->name.len = strlen(d->redirect);
  72
  73         return 0;
  74
  75 err_free:
  76         kfree(buf);
  77         return 0;
  78 fail:
  79         pr_warn_ratelimited("overlayfs: failed to get redirect (%i)\n", res);
  80         goto err_free;
  81 invalid:
  82         pr_warn_ratelimited("overlayfs: invalid redirect (%s)\n", buf);
  83         goto err_free;
  84 }
  85
  86 static int ovl_acceptable(void *ctx, struct dentry *dentry)
  87 {
  88         return 1;
  89 }
  90
  91 static struct ovl_fh *ovl_get_origin_fh(struct dentry *dentry)
  92 {
  93         int res;
  94         struct ovl_fh *fh = NULL;
  95
  96         res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0);
  97         if (res < 0) {
  98                 if (res == -ENODATA || res == -EOPNOTSUPP)
  99                         return NULL;
 100                 goto fail;
 101         }
 102         /* Zero size value means "copied up but origin unknown" */
 103         if (res == 0)
 104                 return NULL;
 105
 106         fh = kzalloc(res, GFP_TEMPORARY);
 107         if (!fh)
 108                 return ERR_PTR(-ENOMEM);
 109
 110         res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, fh, res);
 111         if (res < 0)
 112                 goto fail;
 113
 114         if (res < sizeof(struct ovl_fh) || res < fh->len)
 115                 goto invalid;
 116
 117         if (fh->magic != OVL_FH_MAGIC)
 118                 goto invalid;
 119
 120         /* Treat larger version and unknown flags as "origin unknown" */
 121         if (fh->version > OVL_FH_VERSION || fh->flags & ~OVL_FH_FLAG_ALL)
 122                 goto out;
 123
 124         /* Treat endianness mismatch as "origin unknown" */
 125         if (!(fh->flags & OVL_FH_FLAG_ANY_ENDIAN) &&
 126             (fh->flags & OVL_FH_FLAG_BIG_ENDIAN) != OVL_FH_FLAG_CPU_ENDIAN)
 127                 goto out;
 128
 129         return fh;
 130
 131 out:
 132         kfree(fh);
 133         return NULL;
 134
 135 fail:
 136         pr_warn_ratelimited("overlayfs: failed to get origin (%i)\n", res);
 137         goto out;
 138 invalid:
 139         pr_warn_ratelimited("overlayfs: invalid origin (%*phN)\n", res, fh);
 140         goto out;
 141 }
 142
 143 static struct dentry *ovl_get_origin(struct dentry *dentry,
 144                                      struct vfsmount *mnt)
 145 {
 146         struct dentry *origin = NULL;
 147         struct ovl_fh *fh = ovl_get_origin_fh(dentry);
 148         int bytes;
 149
 150         if (IS_ERR_OR_NULL(fh))
 151                 return (struct dentry *)fh;
 152
 153         /*
 154          * Make sure that the stored uuid matches the uuid of the lower
 155          * layer where file handle will be decoded.
 156          */
 157         if (!uuid_equal(&fh->uuid, &mnt->mnt_sb->s_uuid))
 158                 goto out;
 159
 160         bytes = (fh->len - offsetof(struct ovl_fh, fid));
 161         origin = exportfs_decode_fh(mnt, (struct fid *)fh->fid,
 162                                     bytes >> 2, (int)fh->type,
 163                                     ovl_acceptable, NULL);
 164         if (IS_ERR(origin)) {
 165                 /* Treat stale file handle as "origin unknown" */
 166                 if (origin == ERR_PTR(-ESTALE))
 167                         origin = NULL;
 168                 goto out;
 169         }
 170
 171         if (ovl_dentry_weird(origin) ||
 172             ((d_inode(origin)->i_mode ^ d_inode(dentry)->i_mode) & S_IFMT))
 173                 goto invalid;
 174
 175 out:
 176         kfree(fh);
 177         return origin;
 178
 179 invalid:
 180         pr_warn_ratelimited("overlayfs: invalid origin (%pd2)\n", origin);
 181         dput(origin);
 182         origin = NULL;
 183         goto out;
 184 }
 185
 186 static bool ovl_is_opaquedir(struct dentry *dentry)
 187 {
 188         return ovl_check_dir_xattr(dentry, OVL_XATTR_OPAQUE);
 189 }
 190
 191 static int ovl_lookup_single(struct dentry *base, struct ovl_lookup_data *d,
 192                              const char *name, unsigned int namelen,
 193                              size_t prelen, const char *post,
 194                              struct dentry **ret)
 195 {
 196         struct dentry *this;
 197         int err;
 198
 199         this = lookup_one_len_unlocked(name, base, namelen);
 200         if (IS_ERR(this)) {
 201                 err = PTR_ERR(this);
 202                 this = NULL;
 203                 if (err == -ENOENT || err == -ENAMETOOLONG)
 204                         goto out;
 205                 goto out_err;
 206         }
 207         if (!this->d_inode)
 208                 goto put_and_out;
 209
 210         if (ovl_dentry_weird(this)) {
 211                 /* Don't support traversing automounts and other weirdness */
 212                 err = -EREMOTE;
 213                 goto out_err;
 214         }
 215         if (ovl_is_whiteout(this)) {
 216                 d->stop = d->opaque = true;
 217                 goto put_and_out;
 218         }
 219         if (!d_can_lookup(this)) {
 220                 d->stop = true;
 221                 if (d->is_dir)
 222                         goto put_and_out;
 223                 goto out;
 224         }
 225         d->is_dir = true;
 226         if (!d->last && ovl_is_opaquedir(this)) {
 227                 d->stop = d->opaque = true;
 228                 goto out;
 229         }
 230         err = ovl_check_redirect(this, d, prelen, post);
 231         if (err)
 232                 goto out_err;
 233 out:
 234         *ret = this;
 235         return 0;
 236
 237 put_and_out:
 238         dput(this);
 239         this = NULL;
 240         goto out;
 241
 242 out_err:
 243         dput(this);
 244         return err;
 245 }
 246
 247 static int ovl_lookup_layer(struct dentry *base, struct ovl_lookup_data *d,
 248                             struct dentry **ret)
 249 {
 250         /* Counting down from the end, since the prefix can change */
 251         size_t rem = d->name.len - 1;
 252         struct dentry *dentry = NULL;
 253         int err;
 254
 255         if (d->name.name[0] != '/')
 256                 return ovl_lookup_single(base, d, d->name.name, d->name.len,
 257                                          0, "", ret);
 258
 259         while (!IS_ERR_OR_NULL(base) && d_can_lookup(base)) {
 260                 const char *s = d->name.name + d->name.len - rem;
 261                 const char *next = strchrnul(s, '/');
 262                 size_t thislen = next - s;
 263                 bool end = !next[0];
 264
 265                 /* Verify we did not go off the rails */
 266                 if (WARN_ON(s[-1] != '/'))
 267                         return -EIO;
 268
 269                 err = ovl_lookup_single(base, d, s, thislen,
 270                                         d->name.len - rem, next, &base);
 271                 dput(dentry);
 272                 if (err)
 273                         return err;
 274                 dentry = base;
 275                 if (end)
 276                         break;
 277
 278                 rem -= thislen + 1;
 279
 280                 if (WARN_ON(rem >= d->name.len))
 281                         return -EIO;
 282         }
 283         *ret = dentry;
 284         return 0;
 285 }
 286
 287
 288 static int ovl_check_origin(struct dentry *upperdentry,
 289                             struct path *lowerstack, unsigned int numlower,
 290                             struct path **stackp, unsigned int *ctrp)
 291 {
 292         struct vfsmount *mnt;
 293         struct dentry *origin = NULL;
 294         int i;
 295
 296
 297         for (i = 0; i < numlower; i++) {
 298                 mnt = lowerstack[i].mnt;
 299                 origin = ovl_get_origin(upperdentry, mnt);
 300                 if (IS_ERR(origin))
 301                         return PTR_ERR(origin);
 302
 303                 if (origin)
 304                         break;
 305         }
 306
 307         if (!origin)
 308                 return 0;
 309
 310         BUG_ON(*ctrp);
 311         if (!*stackp)
 312                 *stackp = kmalloc(sizeof(struct path), GFP_TEMPORARY);
 313         if (!*stackp) {
 314                 dput(origin);
 315                 return -ENOMEM;
 316         }
 317         **stackp = (struct path) { .dentry = origin, .mnt = mnt };
 318         *ctrp = 1;
 319
 320         return 0;
 321 }
 322
 323 /*
 324  * Verify that @fh matches the origin file handle stored in OVL_XATTR_ORIGIN.
 325  * Return 0 on match, -ESTALE on mismatch, < 0 on error.
 326  */
 327 static int ovl_verify_origin_fh(struct dentry *dentry, const struct ovl_fh *fh)
 328 {
 329         struct ovl_fh *ofh = ovl_get_origin_fh(dentry);
 330         int err = 0;
 331
 332         if (!ofh)
 333                 return -ENODATA;
 334
 335         if (IS_ERR(ofh))
 336                 return PTR_ERR(ofh);
 337
 338         if (fh->len != ofh->len || memcmp(fh, ofh, fh->len))
 339                 err = -ESTALE;
 340
 341         kfree(ofh);
 342         return err;
 343 }
 344
 345 /*
 346  * Verify that an inode matches the origin file handle stored in upper inode.
 347  *
 348  * If @set is true and there is no stored file handle, encode and store origin
 349  * file handle in OVL_XATTR_ORIGIN.
 350  *
 351  * Return 0 on match, -ESTALE on mismatch, < 0 on error.
 352  */
 353 int ovl_verify_origin(struct dentry *dentry, struct vfsmount *mnt,
 354                       struct dentry *origin, bool is_upper, bool set)
 355 {
 356         struct inode *inode;
 357         struct ovl_fh *fh;
 358         int err;
 359
 360         fh = ovl_encode_fh(origin, is_upper);
 361         err = PTR_ERR(fh);
 362         if (IS_ERR(fh))
 363                 goto fail;
 364
 365         err = ovl_verify_origin_fh(dentry, fh);
 366         if (set && err == -ENODATA)
 367                 err = ovl_do_setxattr(dentry, OVL_XATTR_ORIGIN, fh, fh->len, 0);
 368         if (err)
 369                 goto fail;
 370
 371 out:
 372         kfree(fh);
 373         return err;
 374
 375 fail:
 376         inode = d_inode(origin);
 377         pr_warn_ratelimited("overlayfs: failed to verify origin (%pd2, ino=%lu, err=%i)\n",
 378                             origin, inode ? inode->i_ino : 0, err);
 379         goto out;
 380 }
 381
 382 /*
 383  * Verify that an index entry name matches the origin file handle stored in
 384  * OVL_XATTR_ORIGIN and that origin file handle can be decoded to lower path.
 385  * Return 0 on match, -ESTALE on mismatch or stale origin, < 0 on error.
 386  */
 387 int ovl_verify_index(struct dentry *index, struct path *lowerstack,
 388                      unsigned int numlower)
 389 {
 390         struct ovl_fh *fh = NULL;
 391         size_t len;
 392         struct path origin = { };
 393         struct path *stack = &origin;
 394         unsigned int ctr = 0;
 395         int err;
 396
 397         if (!d_inode(index))
 398                 return 0;
 399
 400         /*
 401          * Directory index entries are going to be used for looking up
 402          * redirected upper dirs by lower dir fh when decoding an overlay
 403          * file handle of a merge dir. Whiteout index entries are going to be
 404          * used as an indication that an exported overlay file handle should
 405          * be treated as stale (i.e. after unlink of the overlay inode).
 406          * We don't know the verification rules for directory and whiteout
 407          * index entries, because they have not been implemented yet, so return
 408          * EROFS if those entries are found to avoid corrupting an index that
 409          * was created by a newer kernel.
 410          */
 411         err = -EROFS;
 412         if (d_is_dir(index) || ovl_is_whiteout(index))
 413                 goto fail;
 414
 415         err = -EINVAL;
 416         if (index->d_name.len < sizeof(struct ovl_fh)*2)
 417                 goto fail;
 418
 419         err = -ENOMEM;
 420         len = index->d_name.len / 2;
 421         fh = kzalloc(len, GFP_TEMPORARY);
 422         if (!fh)
 423                 goto fail;
 424
 425         err = -EINVAL;
 426         if (hex2bin((u8 *)fh, index->d_name.name, len) || len != fh->len)
 427                 goto fail;
 428
 429         err = ovl_verify_origin_fh(index, fh);
 430         if (err)
 431                 goto fail;
 432
 433         err = ovl_check_origin(index, lowerstack, numlower, &stack, &ctr);
 434         if (!err && !ctr)
 435                 err = -ESTALE;
 436         if (err)
 437                 goto fail;
 438
 439         /* Check if index is orphan and don't warn before cleaning it */
 440         if (d_inode(index)->i_nlink == 1 &&
 441             ovl_get_nlink(index, origin.dentry, 0) == 0)
 442                 err = -ENOENT;
 443
 444         dput(origin.dentry);
 445 out:
 446         kfree(fh);
 447         return err;
 448
 449 fail:
 450         pr_warn_ratelimited("overlayfs: failed to verify index (%pd2, ftype=%x, err=%i)\n",
 451                             index, d_inode(index)->i_mode & S_IFMT, err);
 452         goto out;
 453 }
 454
 455 /*
 456  * Lookup in indexdir for the index entry of a lower real inode or a copy up
 457  * origin inode. The index entry name is the hex representation of the lower
 458  * inode file handle.
 459  *
 460  * If the index dentry in negative, then either no lower aliases have been
 461  * copied up yet, or aliases have been copied up in older kernels and are
 462  * not indexed.
 463  *
 464  * If the index dentry for a copy up origin inode is positive, but points
 465  * to an inode different than the upper inode, then either the upper inode
 466  * has been copied up and not indexed or it was indexed, but since then
 467  * index dir was cleared. Either way, that index cannot be used to indentify
 468  * the overlay inode.
 469  */
 470 int ovl_get_index_name(struct dentry *origin, struct qstr *name)
 471 {
 472         int err;
 473         struct ovl_fh *fh;
 474         char *n, *s;
 475
 476         fh = ovl_encode_fh(origin, false);
 477         if (IS_ERR(fh))
 478                 return PTR_ERR(fh);
 479
 480         err = -ENOMEM;
 481         n = kzalloc(fh->len * 2, GFP_TEMPORARY);
 482         if (n) {
 483                 s  = bin2hex(n, fh, fh->len);
 484                 *name = (struct qstr) QSTR_INIT(n, s - n);
 485                 err = 0;
 486         }
 487         kfree(fh);
 488
 489         return err;
 490
 491 }
 492
 493 static struct dentry *ovl_lookup_index(struct dentry *dentry,
 494                                        struct dentry *upper,
 495                                        struct dentry *origin)
 496 {
 497         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 498         struct dentry *index;
 499         struct inode *inode;
 500         struct qstr name;
 501         int err;
 502
 503         err = ovl_get_index_name(origin, &name);
 504         if (err)
 505                 return ERR_PTR(err);
 506
 507         index = lookup_one_len_unlocked(name.name, ofs->indexdir, name.len);
 508         if (IS_ERR(index)) {
 509                 pr_warn_ratelimited("overlayfs: failed inode index lookup (ino=%lu, key=%*s, err=%i);\n"
 510                                     "overlayfs: mount with '-o index=off' to disable inodes index.\n",
 511                                     d_inode(origin)->i_ino, name.len, name.name,
 512                                     err);
 513                 goto out;
 514         }
 515
 516         if (d_is_negative(index)) {
 517                 if (upper && d_inode(origin)->i_nlink > 1) {
 518                         pr_warn_ratelimited("overlayfs: hard link with origin but no index (ino=%lu).\n",
 519                                             d_inode(origin)->i_ino);
 520                         goto fail;
 521                 }
 522
 523                 dput(index);
 524                 index = NULL;
 525         } else if (upper && d_inode(index) != d_inode(upper)) {
 526                 inode = d_inode(index);
 527                 pr_warn_ratelimited("overlayfs: wrong index found (index ino: %lu, upper ino: %lu).\n",
 528                                     d_inode(index)->i_ino,
 529                                     d_inode(upper)->i_ino);
 530                 goto fail;
 531         }
 532
 533 out:
 534         kfree(name.name);
 535         return index;
 536
 537 fail:
 538         dput(index);
 539         index = ERR_PTR(-EIO);
 540         goto out;
 541 }
 542
 543 /*
 544  * Returns next layer in stack starting from top.
 545  * Returns -1 if this is the last layer.
 546  */
 547 int ovl_path_next(int idx, struct dentry *dentry, struct path *path)
 548 {
 549         struct ovl_entry *oe = dentry->d_fsdata;
 550
 551         BUG_ON(idx < 0);
 552         if (idx == 0) {
 553                 ovl_path_upper(dentry, path);
 554                 if (path->dentry)
 555                         return oe->numlower ? 1 : -1;
 556                 idx++;
 557         }
 558         BUG_ON(idx > oe->numlower);
 559         *path = oe->lowerstack[idx - 1];
 560
 561         return (idx < oe->numlower) ? idx + 1 : -1;
 562 }
 563
 564 struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
 565                           unsigned int flags)
 566 {
 567         struct ovl_entry *oe;
 568         const struct cred *old_cred;
 569         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 570         struct ovl_entry *poe = dentry->d_parent->d_fsdata;
 571         struct ovl_entry *roe = dentry->d_sb->s_root->d_fsdata;
 572         struct path *stack = NULL;
 573         struct dentry *upperdir, *upperdentry = NULL;
 574         struct dentry *index = NULL;
 575         unsigned int ctr = 0;
 576         struct inode *inode = NULL;
 577         bool upperopaque = false;
 578         char *upperredirect = NULL;
 579         struct dentry *this;
 580         unsigned int i;
 581         int err;
 582         struct ovl_lookup_data d = {
 583                 .name = dentry->d_name,
 584                 .is_dir = false,
 585                 .opaque = false,
 586                 .stop = false,
 587                 .last = !poe->numlower,
 588                 .redirect = NULL,
 589         };
 590
 591         if (dentry->d_name.len > ofs->namelen)
 592                 return ERR_PTR(-ENAMETOOLONG);
 593
 594         old_cred = ovl_override_creds(dentry->d_sb);
 595         upperdir = ovl_dentry_upper(dentry->d_parent);
 596         if (upperdir) {
 597                 err = ovl_lookup_layer(upperdir, &d, &upperdentry);
 598                 if (err)
 599                         goto out;
 600
 601                 if (upperdentry && unlikely(ovl_dentry_remote(upperdentry))) {
 602                         dput(upperdentry);
 603                         err = -EREMOTE;
 604                         goto out;
 605                 }
 606                 if (upperdentry && !d.is_dir) {
 607                         BUG_ON(!d.stop || d.redirect);
 608                         /*
 609                          * Lookup copy up origin by decoding origin file handle.
 610                          * We may get a disconnected dentry, which is fine,
 611                          * because we only need to hold the origin inode in
 612                          * cache and use its inode number.  We may even get a
 613                          * connected dentry, that is not under any of the lower
 614                          * layers root.  That is also fine for using it's inode
 615                          * number - it's the same as if we held a reference
 616                          * to a dentry in lower layer that was moved under us.
 617                          */
 618                         err = ovl_check_origin(upperdentry, roe->lowerstack,
 619                                                roe->numlower, &stack, &ctr);
 620                         if (err)
 621                                 goto out;
 622                 }
 623
 624                 if (d.redirect) {
 625                         upperredirect = kstrdup(d.redirect, GFP_KERNEL);
 626                         if (!upperredirect)
 627                                 goto out_put_upper;
 628                         if (d.redirect[0] == '/')
 629                                 poe = roe;
 630                 }
 631                 upperopaque = d.opaque;
 632         }
 633
 634         if (!d.stop && poe->numlower) {
 635                 err = -ENOMEM;
 636                 stack = kcalloc(ofs->numlower, sizeof(struct path),
 637                                 GFP_TEMPORARY);
 638                 if (!stack)
 639                         goto out_put_upper;
 640         }
 641
 642         for (i = 0; !d.stop && i < poe->numlower; i++) {
 643                 struct path lowerpath = poe->lowerstack[i];
 644
 645                 d.last = i == poe->numlower - 1;
 646                 err = ovl_lookup_layer(lowerpath.dentry, &d, &this);
 647                 if (err)
 648                         goto out_put;
 649
 650                 if (!this)
 651                         continue;
 652
 653                 stack[ctr].dentry = this;
 654                 stack[ctr].mnt = lowerpath.mnt;
 655                 ctr++;
 656
 657                 if (d.stop)
 658                         break;
 659
 660                 if (d.redirect && d.redirect[0] == '/' && poe != roe) {
 661                         poe = roe;
 662
 663                         /* Find the current layer on the root dentry */
 664                         for (i = 0; i < poe->numlower; i++)
 665                                 if (poe->lowerstack[i].mnt == lowerpath.mnt)
 666                                         break;
 667                         if (WARN_ON(i == poe->numlower))
 668                                 break;
 669                 }
 670         }
 671
 672         /* Lookup index by lower inode and verify it matches upper inode */
 673         if (ctr && !d.is_dir && ovl_indexdir(dentry->d_sb)) {
 674                 struct dentry *origin = stack[0].dentry;
 675
 676                 index = ovl_lookup_index(dentry, upperdentry, origin);
 677                 if (IS_ERR(index)) {
 678                         err = PTR_ERR(index);
 679                         index = NULL;
 680                         goto out_put;
 681                 }
 682         }
 683
 684         oe = ovl_alloc_entry(ctr);
 685         err = -ENOMEM;
 686         if (!oe)
 687                 goto out_put;
 688
 689         oe->opaque = upperopaque;
 690         memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
 691         dentry->d_fsdata = oe;
 692
 693         if (upperdentry)
 694                 ovl_dentry_set_upper_alias(dentry);
 695         else if (index)
 696                 upperdentry = dget(index);
 697
 698         if (upperdentry || ctr) {
 699                 inode = ovl_get_inode(dentry, upperdentry);
 700                 err = PTR_ERR(inode);
 701                 if (IS_ERR(inode))
 702                         goto out_free_oe;
 703
 704                 OVL_I(inode)->redirect = upperredirect;
 705                 if (index)
 706                         ovl_set_flag(OVL_INDEX, inode);
 707         }
 708
 709         revert_creds(old_cred);
 710         dput(index);
 711         kfree(stack);
 712         kfree(d.redirect);
 713         d_add(dentry, inode);
 714
 715         return NULL;
 716
 717 out_free_oe:
 718         dentry->d_fsdata = NULL;
 719         kfree(oe);
 720 out_put:
 721         dput(index);
 722         for (i = 0; i < ctr; i++)
 723                 dput(stack[i].dentry);
 724         kfree(stack);
 725 out_put_upper:
 726         dput(upperdentry);
 727         kfree(upperredirect);
 728 out:
 729         kfree(d.redirect);
 730         revert_creds(old_cred);
 731         return ERR_PTR(err);
 732 }
 733
 734 bool ovl_lower_positive(struct dentry *dentry)
 735 {
 736         struct ovl_entry *oe = dentry->d_fsdata;
 737         struct ovl_entry *poe = dentry->d_parent->d_fsdata;
 738         const struct qstr *name = &dentry->d_name;
 739         unsigned int i;
 740         bool positive = false;
 741         bool done = false;
 742
 743         /*
 744          * If dentry is negative, then lower is positive iff this is a
 745          * whiteout.
 746          */
 747         if (!dentry->d_inode)
 748                 return oe->opaque;
 749
 750         /* Negative upper -> positive lower */
 751         if (!ovl_dentry_upper(dentry))
 752                 return true;
 753
 754         /* Positive upper -> have to look up lower to see whether it exists */
 755         for (i = 0; !done && !positive && i < poe->numlower; i++) {
 756                 struct dentry *this;
 757                 struct dentry *lowerdir = poe->lowerstack[i].dentry;
 758
 759                 this = lookup_one_len_unlocked(name->name, lowerdir,
 760                                                name->len);
 761                 if (IS_ERR(this)) {
 762                         switch (PTR_ERR(this)) {
 763                         case -ENOENT:
 764                         case -ENAMETOOLONG:
 765                                 break;
 766
 767                         default:
 768                                 /*
 769                                  * Assume something is there, we just couldn't
 770                                  * access it.
 771                                  */
 772                                 positive = true;
 773                                 break;
 774                         }
 775                 } else {
 776                         if (this->d_inode) {
 777                                 positive = !ovl_is_whiteout(this);
 778                                 done = true;
 779                         }
 780                         dput(this);
 781                 }
 782         }
 783
 784         return positive;
 785 }