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