fs/overlayfs/dir.c

   1 /*
   2  *
   3  * Copyright (C) 2011 Novell 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/namei.h>
  12 #include <linux/xattr.h>
  13 #include <linux/security.h>
  14 #include <linux/cred.h>
  15 #include <linux/module.h>
  16 #include <linux/posix_acl.h>
  17 #include <linux/posix_acl_xattr.h>
  18 #include <linux/atomic.h>
  19 #include <linux/ratelimit.h>
  20 #include "overlayfs.h"
  21
  22 static unsigned short ovl_redirect_max = 256;
  23 module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
  24 MODULE_PARM_DESC(ovl_redirect_max,
  25                  "Maximum length of absolute redirect xattr value");
  26
  27 void ovl_cleanup(struct inode *wdir, struct dentry *wdentry)
  28 {
  29         int err;
  30
  31         dget(wdentry);
  32         if (d_is_dir(wdentry))
  33                 err = ovl_do_rmdir(wdir, wdentry);
  34         else
  35                 err = ovl_do_unlink(wdir, wdentry);
  36         dput(wdentry);
  37
  38         if (err) {
  39                 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
  40                        wdentry, err);
  41         }
  42 }
  43
  44 struct dentry *ovl_lookup_temp(struct dentry *workdir, struct dentry *dentry)
  45 {
  46         struct dentry *temp;
  47         char name[20];
  48         static atomic_t temp_id = ATOMIC_INIT(0);
  49
  50         /* counter is allowed to wrap, since temp dentries are ephemeral */
  51         snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));
  52
  53         temp = lookup_one_len(name, workdir, strlen(name));
  54         if (!IS_ERR(temp) && temp->d_inode) {
  55                 pr_err("overlayfs: workdir/%s already exists\n", name);
  56                 dput(temp);
  57                 temp = ERR_PTR(-EIO);
  58         }
  59
  60         return temp;
  61 }
  62
  63 /* caller holds i_mutex on workdir */
  64 static struct dentry *ovl_whiteout(struct dentry *workdir,
  65                                    struct dentry *dentry)
  66 {
  67         int err;
  68         struct dentry *whiteout;
  69         struct inode *wdir = workdir->d_inode;
  70
  71         whiteout = ovl_lookup_temp(workdir, dentry);
  72         if (IS_ERR(whiteout))
  73                 return whiteout;
  74
  75         err = ovl_do_whiteout(wdir, whiteout);
  76         if (err) {
  77                 dput(whiteout);
  78                 whiteout = ERR_PTR(err);
  79         }
  80
  81         return whiteout;
  82 }
  83
  84 int ovl_create_real(struct inode *dir, struct dentry *newdentry,
  85                     struct cattr *attr, struct dentry *hardlink, bool debug)
  86 {
  87         int err;
  88
  89         if (newdentry->d_inode)
  90                 return -ESTALE;
  91
  92         if (hardlink) {
  93                 err = ovl_do_link(hardlink, dir, newdentry, debug);
  94         } else {
  95                 switch (attr->mode & S_IFMT) {
  96                 case S_IFREG:
  97                         err = ovl_do_create(dir, newdentry, attr->mode, debug);
  98                         break;
  99
 100                 case S_IFDIR:
 101                         err = ovl_do_mkdir(dir, newdentry, attr->mode, debug);
 102                         break;
 103
 104                 case S_IFCHR:
 105                 case S_IFBLK:
 106                 case S_IFIFO:
 107                 case S_IFSOCK:
 108                         err = ovl_do_mknod(dir, newdentry,
 109                                            attr->mode, attr->rdev, debug);
 110                         break;
 111
 112                 case S_IFLNK:
 113                         err = ovl_do_symlink(dir, newdentry, attr->link, debug);
 114                         break;
 115
 116                 default:
 117                         err = -EPERM;
 118                 }
 119         }
 120         if (!err && WARN_ON(!newdentry->d_inode)) {
 121                 /*
 122                  * Not quite sure if non-instantiated dentry is legal or not.
 123                  * VFS doesn't seem to care so check and warn here.
 124                  */
 125                 err = -ENOENT;
 126         }
 127         return err;
 128 }
 129
 130 static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
 131 {
 132         int err;
 133
 134         err = ovl_do_setxattr(upperdentry, OVL_XATTR_OPAQUE, "y", 1, 0);
 135         if (!err)
 136                 ovl_dentry_set_opaque(dentry);
 137
 138         return err;
 139 }
 140
 141 static int ovl_dir_getattr(const struct path *path, struct kstat *stat,
 142                            u32 request_mask, unsigned int flags)
 143 {
 144         struct dentry *dentry = path->dentry;
 145         int err;
 146         enum ovl_path_type type;
 147         struct path realpath;
 148         const struct cred *old_cred;
 149
 150         type = ovl_path_real(dentry, &realpath);
 151         old_cred = ovl_override_creds(dentry->d_sb);
 152         err = vfs_getattr(&realpath, stat, request_mask, flags);
 153         revert_creds(old_cred);
 154         if (err)
 155                 return err;
 156
 157         stat->dev = dentry->d_sb->s_dev;
 158         stat->ino = dentry->d_inode->i_ino;
 159
 160         /*
 161          * It's probably not worth it to count subdirs to get the
 162          * correct link count.  nlink=1 seems to pacify 'find' and
 163          * other utilities.
 164          */
 165         if (OVL_TYPE_MERGE(type))
 166                 stat->nlink = 1;
 167
 168         return 0;
 169 }
 170
 171 /* Common operations required to be done after creation of file on upper */
 172 static void ovl_instantiate(struct dentry *dentry, struct inode *inode,
 173                             struct dentry *newdentry, bool hardlink)
 174 {
 175         ovl_dentry_version_inc(dentry->d_parent);
 176         ovl_dentry_update(dentry, newdentry);
 177         if (!hardlink) {
 178                 ovl_inode_update(inode, d_inode(newdentry));
 179                 ovl_copyattr(newdentry->d_inode, inode);
 180         } else {
 181                 WARN_ON(ovl_inode_real(inode, NULL) != d_inode(newdentry));
 182                 inc_nlink(inode);
 183         }
 184         d_instantiate(dentry, inode);
 185 }
 186
 187 static bool ovl_type_merge(struct dentry *dentry)
 188 {
 189         return OVL_TYPE_MERGE(ovl_path_type(dentry));
 190 }
 191
 192 static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
 193                             struct cattr *attr, struct dentry *hardlink)
 194 {
 195         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 196         struct inode *udir = upperdir->d_inode;
 197         struct dentry *newdentry;
 198         int err;
 199
 200         if (!hardlink && !IS_POSIXACL(udir))
 201                 attr->mode &= ~current_umask();
 202
 203         inode_lock_nested(udir, I_MUTEX_PARENT);
 204         newdentry = lookup_one_len(dentry->d_name.name, upperdir,
 205                                    dentry->d_name.len);
 206         err = PTR_ERR(newdentry);
 207         if (IS_ERR(newdentry))
 208                 goto out_unlock;
 209         err = ovl_create_real(udir, newdentry, attr, hardlink, false);
 210         if (err)
 211                 goto out_dput;
 212
 213         if (ovl_type_merge(dentry->d_parent)) {
 214                 /* Setting opaque here is just an optimization, allow to fail */
 215                 ovl_set_opaque(dentry, newdentry);
 216         }
 217
 218         ovl_instantiate(dentry, inode, newdentry, !!hardlink);
 219         newdentry = NULL;
 220 out_dput:
 221         dput(newdentry);
 222 out_unlock:
 223         inode_unlock(udir);
 224         return err;
 225 }
 226
 227 static int ovl_lock_rename_workdir(struct dentry *workdir,
 228                                    struct dentry *upperdir)
 229 {
 230         /* Workdir should not be the same as upperdir */
 231         if (workdir == upperdir)
 232                 goto err;
 233
 234         /* Workdir should not be subdir of upperdir and vice versa */
 235         if (lock_rename(workdir, upperdir) != NULL)
 236                 goto err_unlock;
 237
 238         return 0;
 239
 240 err_unlock:
 241         unlock_rename(workdir, upperdir);
 242 err:
 243         pr_err("overlayfs: failed to lock workdir+upperdir\n");
 244         return -EIO;
 245 }
 246
 247 static struct dentry *ovl_clear_empty(struct dentry *dentry,
 248                                       struct list_head *list)
 249 {
 250         struct dentry *workdir = ovl_workdir(dentry);
 251         struct inode *wdir = workdir->d_inode;
 252         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 253         struct inode *udir = upperdir->d_inode;
 254         struct path upperpath;
 255         struct dentry *upper;
 256         struct dentry *opaquedir;
 257         struct kstat stat;
 258         int err;
 259
 260         if (WARN_ON(!workdir))
 261                 return ERR_PTR(-EROFS);
 262
 263         err = ovl_lock_rename_workdir(workdir, upperdir);
 264         if (err)
 265                 goto out;
 266
 267         ovl_path_upper(dentry, &upperpath);
 268         err = vfs_getattr(&upperpath, &stat,
 269                           STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
 270         if (err)
 271                 goto out_unlock;
 272
 273         err = -ESTALE;
 274         if (!S_ISDIR(stat.mode))
 275                 goto out_unlock;
 276         upper = upperpath.dentry;
 277         if (upper->d_parent->d_inode != udir)
 278                 goto out_unlock;
 279
 280         opaquedir = ovl_lookup_temp(workdir, dentry);
 281         err = PTR_ERR(opaquedir);
 282         if (IS_ERR(opaquedir))
 283                 goto out_unlock;
 284
 285         err = ovl_create_real(wdir, opaquedir,
 286                               &(struct cattr){.mode = stat.mode}, NULL, true);
 287         if (err)
 288                 goto out_dput;
 289
 290         err = ovl_copy_xattr(upper, opaquedir);
 291         if (err)
 292                 goto out_cleanup;
 293
 294         err = ovl_set_opaque(dentry, opaquedir);
 295         if (err)
 296                 goto out_cleanup;
 297
 298         inode_lock(opaquedir->d_inode);
 299         err = ovl_set_attr(opaquedir, &stat);
 300         inode_unlock(opaquedir->d_inode);
 301         if (err)
 302                 goto out_cleanup;
 303
 304         err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);
 305         if (err)
 306                 goto out_cleanup;
 307
 308         ovl_cleanup_whiteouts(upper, list);
 309         ovl_cleanup(wdir, upper);
 310         unlock_rename(workdir, upperdir);
 311
 312         /* dentry's upper doesn't match now, get rid of it */
 313         d_drop(dentry);
 314
 315         return opaquedir;
 316
 317 out_cleanup:
 318         ovl_cleanup(wdir, opaquedir);
 319 out_dput:
 320         dput(opaquedir);
 321 out_unlock:
 322         unlock_rename(workdir, upperdir);
 323 out:
 324         return ERR_PTR(err);
 325 }
 326
 327 static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry)
 328 {
 329         int err;
 330         struct dentry *ret = NULL;
 331         enum ovl_path_type type = ovl_path_type(dentry);
 332         LIST_HEAD(list);
 333
 334         err = ovl_check_empty_dir(dentry, &list);
 335         if (err) {
 336                 ret = ERR_PTR(err);
 337                 goto out_free;
 338         }
 339
 340         /*
 341          * When removing an empty opaque directory, then it makes no sense to
 342          * replace it with an exact replica of itself.
 343          *
 344          * If no upperdentry then skip clearing whiteouts.
 345          *
 346          * Can race with copy-up, since we don't hold the upperdir mutex.
 347          * Doesn't matter, since copy-up can't create a non-empty directory
 348          * from an empty one.
 349          */
 350         if (OVL_TYPE_UPPER(type) && OVL_TYPE_MERGE(type))
 351                 ret = ovl_clear_empty(dentry, &list);
 352
 353 out_free:
 354         ovl_cache_free(&list);
 355
 356         return ret;
 357 }
 358
 359 static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name,
 360                              const struct posix_acl *acl)
 361 {
 362         void *buffer;
 363         size_t size;
 364         int err;
 365
 366         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
 367                 return 0;
 368
 369         size = posix_acl_to_xattr(NULL, acl, NULL, 0);
 370         buffer = kmalloc(size, GFP_KERNEL);
 371         if (!buffer)
 372                 return -ENOMEM;
 373
 374         size = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
 375         err = size;
 376         if (err < 0)
 377                 goto out_free;
 378
 379         err = vfs_setxattr(upperdentry, name, buffer, size, XATTR_CREATE);
 380 out_free:
 381         kfree(buffer);
 382         return err;
 383 }
 384
 385 static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
 386                                     struct cattr *cattr,
 387                                     struct dentry *hardlink)
 388 {
 389         struct dentry *workdir = ovl_workdir(dentry);
 390         struct inode *wdir = workdir->d_inode;
 391         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 392         struct inode *udir = upperdir->d_inode;
 393         struct dentry *upper;
 394         struct dentry *newdentry;
 395         int err;
 396         struct posix_acl *acl, *default_acl;
 397
 398         if (WARN_ON(!workdir))
 399                 return -EROFS;
 400
 401         if (!hardlink) {
 402                 err = posix_acl_create(dentry->d_parent->d_inode,
 403                                        &cattr->mode, &default_acl, &acl);
 404                 if (err)
 405                         return err;
 406         }
 407
 408         err = ovl_lock_rename_workdir(workdir, upperdir);
 409         if (err)
 410                 goto out;
 411
 412         newdentry = ovl_lookup_temp(workdir, dentry);
 413         err = PTR_ERR(newdentry);
 414         if (IS_ERR(newdentry))
 415                 goto out_unlock;
 416
 417         upper = lookup_one_len(dentry->d_name.name, upperdir,
 418                                dentry->d_name.len);
 419         err = PTR_ERR(upper);
 420         if (IS_ERR(upper))
 421                 goto out_dput;
 422
 423         err = ovl_create_real(wdir, newdentry, cattr, hardlink, true);
 424         if (err)
 425                 goto out_dput2;
 426
 427         /*
 428          * mode could have been mutilated due to umask (e.g. sgid directory)
 429          */
 430         if (!hardlink &&
 431             !S_ISLNK(cattr->mode) &&
 432             newdentry->d_inode->i_mode != cattr->mode) {
 433                 struct iattr attr = {
 434                         .ia_valid = ATTR_MODE,
 435                         .ia_mode = cattr->mode,
 436                 };
 437                 inode_lock(newdentry->d_inode);
 438                 err = notify_change(newdentry, &attr, NULL);
 439                 inode_unlock(newdentry->d_inode);
 440                 if (err)
 441                         goto out_cleanup;
 442         }
 443         if (!hardlink) {
 444                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,
 445                                         acl);
 446                 if (err)
 447                         goto out_cleanup;
 448
 449                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,
 450                                         default_acl);
 451                 if (err)
 452                         goto out_cleanup;
 453         }
 454
 455         if (!hardlink && S_ISDIR(cattr->mode)) {
 456                 err = ovl_set_opaque(dentry, newdentry);
 457                 if (err)
 458                         goto out_cleanup;
 459
 460                 err = ovl_do_rename(wdir, newdentry, udir, upper,
 461                                     RENAME_EXCHANGE);
 462                 if (err)
 463                         goto out_cleanup;
 464
 465                 ovl_cleanup(wdir, upper);
 466         } else {
 467                 err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
 468                 if (err)
 469                         goto out_cleanup;
 470         }
 471         ovl_instantiate(dentry, inode, newdentry, !!hardlink);
 472         newdentry = NULL;
 473 out_dput2:
 474         dput(upper);
 475 out_dput:
 476         dput(newdentry);
 477 out_unlock:
 478         unlock_rename(workdir, upperdir);
 479 out:
 480         if (!hardlink) {
 481                 posix_acl_release(acl);
 482                 posix_acl_release(default_acl);
 483         }
 484         return err;
 485
 486 out_cleanup:
 487         ovl_cleanup(wdir, newdentry);
 488         goto out_dput2;
 489 }
 490
 491 static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
 492                               struct cattr *attr, struct dentry *hardlink)
 493 {
 494         int err;
 495         const struct cred *old_cred;
 496         struct cred *override_cred;
 497
 498         err = ovl_copy_up(dentry->d_parent);
 499         if (err)
 500                 return err;
 501
 502         old_cred = ovl_override_creds(dentry->d_sb);
 503         err = -ENOMEM;
 504         override_cred = prepare_creds();
 505         if (override_cred) {
 506                 override_cred->fsuid = inode->i_uid;
 507                 override_cred->fsgid = inode->i_gid;
 508                 if (!hardlink) {
 509                         err = security_dentry_create_files_as(dentry,
 510                                         attr->mode, &dentry->d_name, old_cred,
 511                                         override_cred);
 512                         if (err) {
 513                                 put_cred(override_cred);
 514                                 goto out_revert_creds;
 515                         }
 516                 }
 517                 put_cred(override_creds(override_cred));
 518                 put_cred(override_cred);
 519
 520                 if (!ovl_dentry_is_whiteout(dentry))
 521                         err = ovl_create_upper(dentry, inode, attr,
 522                                                 hardlink);
 523                 else
 524                         err = ovl_create_over_whiteout(dentry, inode, attr,
 525                                                         hardlink);
 526         }
 527 out_revert_creds:
 528         revert_creds(old_cred);
 529         if (!err) {
 530                 struct inode *realinode = d_inode(ovl_dentry_upper(dentry));
 531
 532                 WARN_ON(inode->i_mode != realinode->i_mode);
 533                 WARN_ON(!uid_eq(inode->i_uid, realinode->i_uid));
 534                 WARN_ON(!gid_eq(inode->i_gid, realinode->i_gid));
 535         }
 536         return err;
 537 }
 538
 539 static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
 540                              const char *link)
 541 {
 542         int err;
 543         struct inode *inode;
 544         struct cattr attr = {
 545                 .rdev = rdev,
 546                 .link = link,
 547         };
 548
 549         err = ovl_want_write(dentry);
 550         if (err)
 551                 goto out;
 552
 553         err = -ENOMEM;
 554         inode = ovl_new_inode(dentry->d_sb, mode, rdev);
 555         if (!inode)
 556                 goto out_drop_write;
 557
 558         inode_init_owner(inode, dentry->d_parent->d_inode, mode);
 559         attr.mode = inode->i_mode;
 560
 561         err = ovl_create_or_link(dentry, inode, &attr, NULL);
 562         if (err)
 563                 iput(inode);
 564
 565 out_drop_write:
 566         ovl_drop_write(dentry);
 567 out:
 568         return err;
 569 }
 570
 571 static int ovl_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 572                       bool excl)
 573 {
 574         return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
 575 }
 576
 577 static int ovl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 578 {
 579         return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
 580 }
 581
 582 static int ovl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 583                      dev_t rdev)
 584 {
 585         /* Don't allow creation of "whiteout" on overlay */
 586         if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
 587                 return -EPERM;
 588
 589         return ovl_create_object(dentry, mode, rdev, NULL);
 590 }
 591
 592 static int ovl_symlink(struct inode *dir, struct dentry *dentry,
 593                        const char *link)
 594 {
 595         return ovl_create_object(dentry, S_IFLNK, 0, link);
 596 }
 597
 598 static int ovl_link(struct dentry *old, struct inode *newdir,
 599                     struct dentry *new)
 600 {
 601         int err;
 602         struct inode *inode;
 603
 604         err = ovl_want_write(old);
 605         if (err)
 606                 goto out;
 607
 608         err = ovl_copy_up(old);
 609         if (err)
 610                 goto out_drop_write;
 611
 612         inode = d_inode(old);
 613         ihold(inode);
 614
 615         err = ovl_create_or_link(new, inode, NULL, ovl_dentry_upper(old));
 616         if (err)
 617                 iput(inode);
 618
 619 out_drop_write:
 620         ovl_drop_write(old);
 621 out:
 622         return err;
 623 }
 624
 625 static int ovl_remove_and_whiteout(struct dentry *dentry, bool is_dir)
 626 {
 627         struct dentry *workdir = ovl_workdir(dentry);
 628         struct inode *wdir = workdir->d_inode;
 629         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 630         struct inode *udir = upperdir->d_inode;
 631         struct dentry *whiteout;
 632         struct dentry *upper;
 633         struct dentry *opaquedir = NULL;
 634         int err;
 635         int flags = 0;
 636
 637         if (WARN_ON(!workdir))
 638                 return -EROFS;
 639
 640         if (is_dir) {
 641                 opaquedir = ovl_check_empty_and_clear(dentry);
 642                 err = PTR_ERR(opaquedir);
 643                 if (IS_ERR(opaquedir))
 644                         goto out;
 645         }
 646
 647         err = ovl_lock_rename_workdir(workdir, upperdir);
 648         if (err)
 649                 goto out_dput;
 650
 651         upper = lookup_one_len(dentry->d_name.name, upperdir,
 652                                dentry->d_name.len);
 653         err = PTR_ERR(upper);
 654         if (IS_ERR(upper))
 655                 goto out_unlock;
 656
 657         err = -ESTALE;
 658         if ((opaquedir && upper != opaquedir) ||
 659             (!opaquedir && ovl_dentry_upper(dentry) &&
 660              upper != ovl_dentry_upper(dentry))) {
 661                 goto out_dput_upper;
 662         }
 663
 664         whiteout = ovl_whiteout(workdir, dentry);
 665         err = PTR_ERR(whiteout);
 666         if (IS_ERR(whiteout))
 667                 goto out_dput_upper;
 668
 669         if (d_is_dir(upper))
 670                 flags = RENAME_EXCHANGE;
 671
 672         err = ovl_do_rename(wdir, whiteout, udir, upper, flags);
 673         if (err)
 674                 goto kill_whiteout;
 675         if (flags)
 676                 ovl_cleanup(wdir, upper);
 677
 678         ovl_dentry_version_inc(dentry->d_parent);
 679 out_d_drop:
 680         d_drop(dentry);
 681         dput(whiteout);
 682 out_dput_upper:
 683         dput(upper);
 684 out_unlock:
 685         unlock_rename(workdir, upperdir);
 686 out_dput:
 687         dput(opaquedir);
 688 out:
 689         return err;
 690
 691 kill_whiteout:
 692         ovl_cleanup(wdir, whiteout);
 693         goto out_d_drop;
 694 }
 695
 696 static int ovl_remove_upper(struct dentry *dentry, bool is_dir)
 697 {
 698         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 699         struct inode *dir = upperdir->d_inode;
 700         struct dentry *upper;
 701         struct dentry *opaquedir = NULL;
 702         int err;
 703
 704         /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */
 705         if (is_dir && ovl_dentry_get_redirect(dentry)) {
 706                 opaquedir = ovl_check_empty_and_clear(dentry);
 707                 err = PTR_ERR(opaquedir);
 708                 if (IS_ERR(opaquedir))
 709                         goto out;
 710         }
 711
 712         inode_lock_nested(dir, I_MUTEX_PARENT);
 713         upper = lookup_one_len(dentry->d_name.name, upperdir,
 714                                dentry->d_name.len);
 715         err = PTR_ERR(upper);
 716         if (IS_ERR(upper))
 717                 goto out_unlock;
 718
 719         err = -ESTALE;
 720         if ((opaquedir && upper != opaquedir) ||
 721             (!opaquedir && upper != ovl_dentry_upper(dentry)))
 722                 goto out_dput_upper;
 723
 724         if (is_dir)
 725                 err = vfs_rmdir(dir, upper);
 726         else
 727                 err = vfs_unlink(dir, upper, NULL);
 728         ovl_dentry_version_inc(dentry->d_parent);
 729
 730         /*
 731          * Keeping this dentry hashed would mean having to release
 732          * upperpath/lowerpath, which could only be done if we are the
 733          * sole user of this dentry.  Too tricky...  Just unhash for
 734          * now.
 735          */
 736         if (!err)
 737                 d_drop(dentry);
 738 out_dput_upper:
 739         dput(upper);
 740 out_unlock:
 741         inode_unlock(dir);
 742         dput(opaquedir);
 743 out:
 744         return err;
 745 }
 746
 747 static int ovl_do_remove(struct dentry *dentry, bool is_dir)
 748 {
 749         enum ovl_path_type type;
 750         int err;
 751         const struct cred *old_cred;
 752
 753         err = ovl_want_write(dentry);
 754         if (err)
 755                 goto out;
 756
 757         err = ovl_copy_up(dentry->d_parent);
 758         if (err)
 759                 goto out_drop_write;
 760
 761         type = ovl_path_type(dentry);
 762
 763         old_cred = ovl_override_creds(dentry->d_sb);
 764         if (!ovl_lower_positive(dentry))
 765                 err = ovl_remove_upper(dentry, is_dir);
 766         else
 767                 err = ovl_remove_and_whiteout(dentry, is_dir);
 768         revert_creds(old_cred);
 769         if (!err) {
 770                 if (is_dir)
 771                         clear_nlink(dentry->d_inode);
 772                 else
 773                         drop_nlink(dentry->d_inode);
 774         }
 775 out_drop_write:
 776         ovl_drop_write(dentry);
 777 out:
 778         return err;
 779 }
 780
 781 static int ovl_unlink(struct inode *dir, struct dentry *dentry)
 782 {
 783         return ovl_do_remove(dentry, false);
 784 }
 785
 786 static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
 787 {
 788         return ovl_do_remove(dentry, true);
 789 }
 790
 791 static bool ovl_type_merge_or_lower(struct dentry *dentry)
 792 {
 793         enum ovl_path_type type = ovl_path_type(dentry);
 794
 795         return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
 796 }
 797
 798 static bool ovl_can_move(struct dentry *dentry)
 799 {
 800         return ovl_redirect_dir(dentry->d_sb) ||
 801                 !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
 802 }
 803
 804 static char *ovl_get_redirect(struct dentry *dentry, bool samedir)
 805 {
 806         char *buf, *ret;
 807         struct dentry *d, *tmp;
 808         int buflen = ovl_redirect_max + 1;
 809
 810         if (samedir) {
 811                 ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
 812                                GFP_KERNEL);
 813                 goto out;
 814         }
 815
 816         buf = ret = kmalloc(buflen, GFP_TEMPORARY);
 817         if (!buf)
 818                 goto out;
 819
 820         buflen--;
 821         buf[buflen] = '\0';
 822         for (d = dget(dentry); !IS_ROOT(d);) {
 823                 const char *name;
 824                 int thislen;
 825
 826                 spin_lock(&d->d_lock);
 827                 name = ovl_dentry_get_redirect(d);
 828                 if (name) {
 829                         thislen = strlen(name);
 830                 } else {
 831                         name = d->d_name.name;
 832                         thislen = d->d_name.len;
 833                 }
 834
 835                 /* If path is too long, fall back to userspace move */
 836                 if (thislen + (name[0] != '/') > buflen) {
 837                         ret = ERR_PTR(-EXDEV);
 838                         spin_unlock(&d->d_lock);
 839                         goto out_put;
 840                 }
 841
 842                 buflen -= thislen;
 843                 memcpy(&buf[buflen], name, thislen);
 844                 tmp = dget_dlock(d->d_parent);
 845                 spin_unlock(&d->d_lock);
 846
 847                 dput(d);
 848                 d = tmp;
 849
 850                 /* Absolute redirect: finished */
 851                 if (buf[buflen] == '/')
 852                         break;
 853                 buflen--;
 854                 buf[buflen] = '/';
 855         }
 856         ret = kstrdup(&buf[buflen], GFP_KERNEL);
 857 out_put:
 858         dput(d);
 859         kfree(buf);
 860 out:
 861         return ret ? ret : ERR_PTR(-ENOMEM);
 862 }
 863
 864 static int ovl_set_redirect(struct dentry *dentry, bool samedir)
 865 {
 866         int err;
 867         const char *redirect = ovl_dentry_get_redirect(dentry);
 868
 869         if (redirect && (samedir || redirect[0] == '/'))
 870                 return 0;
 871
 872         redirect = ovl_get_redirect(dentry, samedir);
 873         if (IS_ERR(redirect))
 874                 return PTR_ERR(redirect);
 875
 876         err = ovl_do_setxattr(ovl_dentry_upper(dentry), OVL_XATTR_REDIRECT,
 877                               redirect, strlen(redirect), 0);
 878         if (!err) {
 879                 spin_lock(&dentry->d_lock);
 880                 ovl_dentry_set_redirect(dentry, redirect);
 881                 spin_unlock(&dentry->d_lock);
 882         } else {
 883                 kfree(redirect);
 884                 if (err == -EOPNOTSUPP)
 885                         ovl_clear_redirect_dir(dentry->d_sb);
 886                 else
 887                         pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err);
 888                 /* Fall back to userspace copy-up */
 889                 err = -EXDEV;
 890         }
 891         return err;
 892 }
 893
 894 static int ovl_rename(struct inode *olddir, struct dentry *old,
 895                       struct inode *newdir, struct dentry *new,
 896                       unsigned int flags)
 897 {
 898         int err;
 899         struct dentry *old_upperdir;
 900         struct dentry *new_upperdir;
 901         struct dentry *olddentry;
 902         struct dentry *newdentry;
 903         struct dentry *trap;
 904         bool old_opaque;
 905         bool new_opaque;
 906         bool cleanup_whiteout = false;
 907         bool overwrite = !(flags & RENAME_EXCHANGE);
 908         bool is_dir = d_is_dir(old);
 909         bool new_is_dir = d_is_dir(new);
 910         bool samedir = olddir == newdir;
 911         struct dentry *opaquedir = NULL;
 912         const struct cred *old_cred = NULL;
 913
 914         err = -EINVAL;
 915         if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
 916                 goto out;
 917
 918         flags &= ~RENAME_NOREPLACE;
 919
 920         /* Don't copy up directory trees */
 921         err = -EXDEV;
 922         if (!ovl_can_move(old))
 923                 goto out;
 924         if (!overwrite && !ovl_can_move(new))
 925                 goto out;
 926
 927         err = ovl_want_write(old);
 928         if (err)
 929                 goto out;
 930
 931         err = ovl_copy_up(old);
 932         if (err)
 933                 goto out_drop_write;
 934
 935         err = ovl_copy_up(new->d_parent);
 936         if (err)
 937                 goto out_drop_write;
 938         if (!overwrite) {
 939                 err = ovl_copy_up(new);
 940                 if (err)
 941                         goto out_drop_write;
 942         }
 943
 944         old_cred = ovl_override_creds(old->d_sb);
 945
 946         if (overwrite && new_is_dir && ovl_type_merge_or_lower(new)) {
 947                 opaquedir = ovl_check_empty_and_clear(new);
 948                 err = PTR_ERR(opaquedir);
 949                 if (IS_ERR(opaquedir)) {
 950                         opaquedir = NULL;
 951                         goto out_revert_creds;
 952                 }
 953         }
 954
 955         if (overwrite) {
 956                 if (ovl_lower_positive(old)) {
 957                         if (!ovl_dentry_is_whiteout(new)) {
 958                                 /* Whiteout source */
 959                                 flags |= RENAME_WHITEOUT;
 960                         } else {
 961                                 /* Switch whiteouts */
 962                                 flags |= RENAME_EXCHANGE;
 963                         }
 964                 } else if (is_dir && ovl_dentry_is_whiteout(new)) {
 965                         flags |= RENAME_EXCHANGE;
 966                         cleanup_whiteout = true;
 967                 }
 968         }
 969
 970         old_upperdir = ovl_dentry_upper(old->d_parent);
 971         new_upperdir = ovl_dentry_upper(new->d_parent);
 972
 973         trap = lock_rename(new_upperdir, old_upperdir);
 974
 975         olddentry = lookup_one_len(old->d_name.name, old_upperdir,
 976                                    old->d_name.len);
 977         err = PTR_ERR(olddentry);
 978         if (IS_ERR(olddentry))
 979                 goto out_unlock;
 980
 981         err = -ESTALE;
 982         if (olddentry != ovl_dentry_upper(old))
 983                 goto out_dput_old;
 984
 985         newdentry = lookup_one_len(new->d_name.name, new_upperdir,
 986                                    new->d_name.len);
 987         err = PTR_ERR(newdentry);
 988         if (IS_ERR(newdentry))
 989                 goto out_dput_old;
 990
 991         old_opaque = ovl_dentry_is_opaque(old);
 992         new_opaque = ovl_dentry_is_opaque(new);
 993
 994         err = -ESTALE;
 995         if (ovl_dentry_upper(new)) {
 996                 if (opaquedir) {
 997                         if (newdentry != opaquedir)
 998                                 goto out_dput;
 999                 } else {
1000                         if (newdentry != ovl_dentry_upper(new))
1001                                 goto out_dput;
1002                 }
1003         } else {
1004                 if (!d_is_negative(newdentry) &&
1005                     (!new_opaque || !ovl_is_whiteout(newdentry)))
1006                         goto out_dput;
1007         }
1008
1009         if (olddentry == trap)
1010                 goto out_dput;
1011         if (newdentry == trap)
1012                 goto out_dput;
1013
1014         if (WARN_ON(olddentry->d_inode == newdentry->d_inode))
1015                 goto out_dput;
1016
1017         err = 0;
1018         if (is_dir) {
1019                 if (ovl_type_merge_or_lower(old))
1020                         err = ovl_set_redirect(old, samedir);
1021                 else if (!old_opaque && ovl_type_merge(new->d_parent))
1022                         err = ovl_set_opaque(old, olddentry);
1023                 if (err)
1024                         goto out_dput;
1025         }
1026         if (!overwrite && new_is_dir) {
1027                 if (ovl_type_merge_or_lower(new))
1028                         err = ovl_set_redirect(new, samedir);
1029                 else if (!new_opaque && ovl_type_merge(old->d_parent))
1030                         err = ovl_set_opaque(new, newdentry);
1031                 if (err)
1032                         goto out_dput;
1033         }
1034
1035         err = ovl_do_rename(old_upperdir->d_inode, olddentry,
1036                             new_upperdir->d_inode, newdentry, flags);
1037         if (err)
1038                 goto out_dput;
1039
1040         if (cleanup_whiteout)
1041                 ovl_cleanup(old_upperdir->d_inode, newdentry);
1042
1043         ovl_dentry_version_inc(old->d_parent);
1044         ovl_dentry_version_inc(new->d_parent);
1045
1046 out_dput:
1047         dput(newdentry);
1048 out_dput_old:
1049         dput(olddentry);
1050 out_unlock:
1051         unlock_rename(new_upperdir, old_upperdir);
1052 out_revert_creds:
1053         revert_creds(old_cred);
1054 out_drop_write:
1055         ovl_drop_write(old);
1056 out:
1057         dput(opaquedir);
1058         return err;
1059 }
1060
1061 const struct inode_operations ovl_dir_inode_operations = {
1062         .lookup         = ovl_lookup,
1063         .mkdir          = ovl_mkdir,
1064         .symlink        = ovl_symlink,
1065         .unlink         = ovl_unlink,
1066         .rmdir          = ovl_rmdir,
1067         .rename         = ovl_rename,
1068         .link           = ovl_link,
1069         .setattr        = ovl_setattr,
1070         .create         = ovl_create,
1071         .mknod          = ovl_mknod,
1072         .permission     = ovl_permission,
1073         .getattr        = ovl_dir_getattr,
1074         .listxattr      = ovl_listxattr,
1075         .get_acl        = ovl_get_acl,
1076         .update_time    = ovl_update_time,
1077 };