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