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                 err = PTR_ERR(index);
 510                 if (err == -ENOENT) {
 511                         index = NULL;
 512                         goto out;
 513                 }
 514                 pr_warn_ratelimited("overlayfs: failed inode index lookup (ino=%lu, key=%*s, err=%i);\n"
 515                                     "overlayfs: mount with '-o index=off' to disable inodes index.\n",
 516                                     d_inode(origin)->i_ino, name.len, name.name,
 517                                     err);
 518                 goto out;
 519         }
 520
 521         inode = d_inode(index);
 522         if (d_is_negative(index)) {
 523                 goto out_dput;
 524         } else if (upper && d_inode(upper) != inode) {
 525                 goto out_dput;
 526         } else if (ovl_dentry_weird(index) || ovl_is_whiteout(index) ||
 527                    ((inode->i_mode ^ d_inode(origin)->i_mode) & S_IFMT)) {
 528                 /*
 529                  * Index should always be of the same file type as origin
 530                  * except for the case of a whiteout index. A whiteout
 531                  * index should only exist if all lower aliases have been
 532                  * unlinked, which means that finding a lower origin on lookup
 533                  * whose index is a whiteout should be treated as an error.
 534                  */
 535                 pr_warn_ratelimited("overlayfs: bad index found (index=%pd2, ftype=%x, origin ftype=%x).\n",
 536                                     index, d_inode(index)->i_mode & S_IFMT,
 537                                     d_inode(origin)->i_mode & S_IFMT);
 538                 goto fail;
 539         }
 540
 541 out:
 542         kfree(name.name);
 543         return index;
 544
 545 out_dput:
 546         dput(index);
 547         index = NULL;
 548         goto out;
 549
 550 fail:
 551         dput(index);
 552         index = ERR_PTR(-EIO);
 553         goto out;
 554 }
 555
 556 /*
 557  * Returns next layer in stack starting from top.
 558  * Returns -1 if this is the last layer.
 559  */
 560 int ovl_path_next(int idx, struct dentry *dentry, struct path *path)
 561 {
 562         struct ovl_entry *oe = dentry->d_fsdata;
 563
 564         BUG_ON(idx < 0);
 565         if (idx == 0) {
 566                 ovl_path_upper(dentry, path);
 567                 if (path->dentry)
 568                         return oe->numlower ? 1 : -1;
 569                 idx++;
 570         }
 571         BUG_ON(idx > oe->numlower);
 572         *path = oe->lowerstack[idx - 1];
 573
 574         return (idx < oe->numlower) ? idx + 1 : -1;
 575 }
 576
 577 struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
 578                           unsigned int flags)
 579 {
 580         struct ovl_entry *oe;
 581         const struct cred *old_cred;
 582         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
 583         struct ovl_entry *poe = dentry->d_parent->d_fsdata;
 584         struct ovl_entry *roe = dentry->d_sb->s_root->d_fsdata;
 585         struct path *stack = NULL;
 586         struct dentry *upperdir, *upperdentry = NULL;
 587         struct dentry *index = NULL;
 588         unsigned int ctr = 0;
 589         struct inode *inode = NULL;
 590         bool upperopaque = false;
 591         char *upperredirect = NULL;
 592         struct dentry *this;
 593         unsigned int i;
 594         int err;
 595         struct ovl_lookup_data d = {
 596                 .name = dentry->d_name,
 597                 .is_dir = false,
 598                 .opaque = false,
 599                 .stop = false,
 600                 .last = !poe->numlower,
 601                 .redirect = NULL,
 602         };
 603
 604         if (dentry->d_name.len > ofs->namelen)
 605                 return ERR_PTR(-ENAMETOOLONG);
 606
 607         old_cred = ovl_override_creds(dentry->d_sb);
 608         upperdir = ovl_dentry_upper(dentry->d_parent);
 609         if (upperdir) {
 610                 err = ovl_lookup_layer(upperdir, &d, &upperdentry);
 611                 if (err)
 612                         goto out;
 613
 614                 if (upperdentry && unlikely(ovl_dentry_remote(upperdentry))) {
 615                         dput(upperdentry);
 616                         err = -EREMOTE;
 617                         goto out;
 618                 }
 619                 if (upperdentry && !d.is_dir) {
 620                         BUG_ON(!d.stop || d.redirect);
 621                         /*
 622                          * Lookup copy up origin by decoding origin file handle.
 623                          * We may get a disconnected dentry, which is fine,
 624                          * because we only need to hold the origin inode in
 625                          * cache and use its inode number.  We may even get a
 626                          * connected dentry, that is not under any of the lower
 627                          * layers root.  That is also fine for using it's inode
 628                          * number - it's the same as if we held a reference
 629                          * to a dentry in lower layer that was moved under us.
 630                          */
 631                         err = ovl_check_origin(upperdentry, roe->lowerstack,
 632                                                roe->numlower, &stack, &ctr);
 633                         if (err)
 634                                 goto out;
 635                 }
 636
 637                 if (d.redirect) {
 638                         upperredirect = kstrdup(d.redirect, GFP_KERNEL);
 639                         if (!upperredirect)
 640                                 goto out_put_upper;
 641                         if (d.redirect[0] == '/')
 642                                 poe = roe;
 643                 }
 644                 upperopaque = d.opaque;
 645         }
 646
 647         if (!d.stop && poe->numlower) {
 648                 err = -ENOMEM;
 649                 stack = kcalloc(ofs->numlower, sizeof(struct path),
 650                                 GFP_TEMPORARY);
 651                 if (!stack)
 652                         goto out_put_upper;
 653         }
 654
 655         for (i = 0; !d.stop && i < poe->numlower; i++) {
 656                 struct path lowerpath = poe->lowerstack[i];
 657
 658                 d.last = i == poe->numlower - 1;
 659                 err = ovl_lookup_layer(lowerpath.dentry, &d, &this);
 660                 if (err)
 661                         goto out_put;
 662
 663                 if (!this)
 664                         continue;
 665
 666                 stack[ctr].dentry = this;
 667                 stack[ctr].mnt = lowerpath.mnt;
 668                 ctr++;
 669
 670                 if (d.stop)
 671                         break;
 672
 673                 if (d.redirect && d.redirect[0] == '/' && poe != roe) {
 674                         poe = roe;
 675
 676                         /* Find the current layer on the root dentry */
 677                         for (i = 0; i < poe->numlower; i++)
 678                                 if (poe->lowerstack[i].mnt == lowerpath.mnt)
 679                                         break;
 680                         if (WARN_ON(i == poe->numlower))
 681                                 break;
 682                 }
 683         }
 684
 685         /* Lookup index by lower inode and verify it matches upper inode */
 686         if (ctr && !d.is_dir && ovl_indexdir(dentry->d_sb)) {
 687                 struct dentry *origin = stack[0].dentry;
 688
 689                 index = ovl_lookup_index(dentry, upperdentry, origin);
 690                 if (IS_ERR(index)) {
 691                         err = PTR_ERR(index);
 692                         index = NULL;
 693                         goto out_put;
 694                 }
 695         }
 696
 697         oe = ovl_alloc_entry(ctr);
 698         err = -ENOMEM;
 699         if (!oe)
 700                 goto out_put;
 701
 702         oe->opaque = upperopaque;
 703         memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
 704         dentry->d_fsdata = oe;
 705
 706         if (upperdentry)
 707                 ovl_dentry_set_upper_alias(dentry);
 708         else if (index)
 709                 upperdentry = dget(index);
 710
 711         if (upperdentry || ctr) {
 712                 inode = ovl_get_inode(dentry, upperdentry, index);
 713                 err = PTR_ERR(inode);
 714                 if (IS_ERR(inode))
 715                         goto out_free_oe;
 716
 717                 OVL_I(inode)->redirect = upperredirect;
 718                 if (index)
 719                         ovl_set_flag(OVL_INDEX, inode);
 720         }
 721
 722         revert_creds(old_cred);
 723         dput(index);
 724         kfree(stack);
 725         kfree(d.redirect);
 726         d_add(dentry, inode);
 727
 728         return NULL;
 729
 730 out_free_oe:
 731         dentry->d_fsdata = NULL;
 732         kfree(oe);
 733 out_put:
 734         dput(index);
 735         for (i = 0; i < ctr; i++)
 736                 dput(stack[i].dentry);
 737         kfree(stack);
 738 out_put_upper:
 739         dput(upperdentry);
 740         kfree(upperredirect);
 741 out:
 742         kfree(d.redirect);
 743         revert_creds(old_cred);
 744         return ERR_PTR(err);
 745 }
 746
 747 bool ovl_lower_positive(struct dentry *dentry)
 748 {
 749         struct ovl_entry *oe = dentry->d_fsdata;
 750         struct ovl_entry *poe = dentry->d_parent->d_fsdata;
 751         const struct qstr *name = &dentry->d_name;
 752         unsigned int i;
 753         bool positive = false;
 754         bool done = false;
 755
 756         /*
 757          * If dentry is negative, then lower is positive iff this is a
 758          * whiteout.
 759          */
 760         if (!dentry->d_inode)
 761                 return oe->opaque;
 762
 763         /* Negative upper -> positive lower */
 764         if (!ovl_dentry_upper(dentry))
 765                 return true;
 766
 767         /* Positive upper -> have to look up lower to see whether it exists */
 768         for (i = 0; !done && !positive && i < poe->numlower; i++) {
 769                 struct dentry *this;
 770                 struct dentry *lowerdir = poe->lowerstack[i].dentry;
 771
 772                 this = lookup_one_len_unlocked(name->name, lowerdir,
 773                                                name->len);
 774                 if (IS_ERR(this)) {
 775                         switch (PTR_ERR(this)) {
 776                         case -ENOENT:
 777                         case -ENAMETOOLONG:
 778                                 break;
 779
 780                         default:
 781                                 /*
 782                                  * Assume something is there, we just couldn't
 783                                  * access it.
 784                                  */
 785                                 positive = true;
 786                                 break;
 787                         }
 788                 } else {
 789                         if (this->d_inode) {
 790                                 positive = !ovl_is_whiteout(this);
 791                                 done = true;
 792                         }
 793                         dput(this);
 794                 }
 795         }
 796
 797         return positive;
 798 }