fs/overlayfs/dir.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  * Copyright (C) 2011 Novell Inc.
   5  */
   6
   7 #include <linux/fs.h>
   8 #include <linux/namei.h>
   9 #include <linux/xattr.h>
  10 #include <linux/security.h>
  11 #include <linux/cred.h>
  12 #include <linux/module.h>
  13 #include <linux/posix_acl.h>
  14 #include <linux/posix_acl_xattr.h>
  15 #include <linux/atomic.h>
  16 #include <linux/ratelimit.h>
  17 #include "overlayfs.h"
  18
  19 static unsigned short ovl_redirect_max = 256;
  20 module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
  21 MODULE_PARM_DESC(redirect_max,
  22                  "Maximum length of absolute redirect xattr value");
  23
  24 static int ovl_set_redirect(struct dentry *dentry, bool samedir);
  25
  26 int ovl_cleanup(struct inode *wdir, struct dentry *wdentry)
  27 {
  28         int err;
  29
  30         dget(wdentry);
  31         if (d_is_dir(wdentry))
  32                 err = ovl_do_rmdir(wdir, wdentry);
  33         else
  34                 err = ovl_do_unlink(wdir, wdentry);
  35         dput(wdentry);
  36
  37         if (err) {
  38                 pr_err("overlayfs: cleanup of '%pd2' failed (%i)\n",
  39                        wdentry, err);
  40         }
  41
  42         return err;
  43 }
  44
  45 static struct dentry *ovl_lookup_temp(struct dentry *workdir)
  46 {
  47         struct dentry *temp;
  48         char name[20];
  49         static atomic_t temp_id = ATOMIC_INIT(0);
  50
  51         /* counter is allowed to wrap, since temp dentries are ephemeral */
  52         snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));
  53
  54         temp = lookup_one_len(name, workdir, strlen(name));
  55         if (!IS_ERR(temp) && temp->d_inode) {
  56                 pr_err("overlayfs: workdir/%s already exists\n", name);
  57                 dput(temp);
  58                 temp = ERR_PTR(-EIO);
  59         }
  60
  61         return temp;
  62 }
  63
  64 /* caller holds i_mutex on workdir */
  65 static struct dentry *ovl_whiteout(struct dentry *workdir)
  66 {
  67         int err;
  68         struct dentry *whiteout;
  69         struct inode *wdir = workdir->d_inode;
  70
  71         whiteout = ovl_lookup_temp(workdir);
  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 /* Caller must hold i_mutex on both workdir and dir */
  85 int ovl_cleanup_and_whiteout(struct dentry *workdir, struct inode *dir,
  86                              struct dentry *dentry)
  87 {
  88         struct inode *wdir = workdir->d_inode;
  89         struct dentry *whiteout;
  90         int err;
  91         int flags = 0;
  92
  93         whiteout = ovl_whiteout(workdir);
  94         err = PTR_ERR(whiteout);
  95         if (IS_ERR(whiteout))
  96                 return err;
  97
  98         if (d_is_dir(dentry))
  99                 flags = RENAME_EXCHANGE;
 100
 101         err = ovl_do_rename(wdir, whiteout, dir, dentry, flags);
 102         if (err)
 103                 goto kill_whiteout;
 104         if (flags)
 105                 ovl_cleanup(wdir, dentry);
 106
 107 out:
 108         dput(whiteout);
 109         return err;
 110
 111 kill_whiteout:
 112         ovl_cleanup(wdir, whiteout);
 113         goto out;
 114 }
 115
 116 int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, umode_t mode)
 117 {
 118         int err;
 119         struct dentry *d, *dentry = *newdentry;
 120
 121         err = ovl_do_mkdir(dir, dentry, mode);
 122         if (err)
 123                 return err;
 124
 125         if (likely(!d_unhashed(dentry)))
 126                 return 0;
 127
 128         /*
 129          * vfs_mkdir() may succeed and leave the dentry passed
 130          * to it unhashed and negative. If that happens, try to
 131          * lookup a new hashed and positive dentry.
 132          */
 133         d = lookup_one_len(dentry->d_name.name, dentry->d_parent,
 134                            dentry->d_name.len);
 135         if (IS_ERR(d)) {
 136                 pr_warn("overlayfs: failed lookup after mkdir (%pd2, err=%i).\n",
 137                         dentry, err);
 138                 return PTR_ERR(d);
 139         }
 140         dput(dentry);
 141         *newdentry = d;
 142
 143         return 0;
 144 }
 145
 146 struct dentry *ovl_create_real(struct inode *dir, struct dentry *newdentry,
 147                                struct ovl_cattr *attr)
 148 {
 149         int err;
 150
 151         if (IS_ERR(newdentry))
 152                 return newdentry;
 153
 154         err = -ESTALE;
 155         if (newdentry->d_inode)
 156                 goto out;
 157
 158         if (attr->hardlink) {
 159                 err = ovl_do_link(attr->hardlink, dir, newdentry);
 160         } else {
 161                 switch (attr->mode & S_IFMT) {
 162                 case S_IFREG:
 163                         err = ovl_do_create(dir, newdentry, attr->mode);
 164                         break;
 165
 166                 case S_IFDIR:
 167                         /* mkdir is special... */
 168                         err =  ovl_mkdir_real(dir, &newdentry, attr->mode);
 169                         break;
 170
 171                 case S_IFCHR:
 172                 case S_IFBLK:
 173                 case S_IFIFO:
 174                 case S_IFSOCK:
 175                         err = ovl_do_mknod(dir, newdentry, attr->mode,
 176                                            attr->rdev);
 177                         break;
 178
 179                 case S_IFLNK:
 180                         err = ovl_do_symlink(dir, newdentry, attr->link);
 181                         break;
 182
 183                 default:
 184                         err = -EPERM;
 185                 }
 186         }
 187         if (!err && WARN_ON(!newdentry->d_inode)) {
 188                 /*
 189                  * Not quite sure if non-instantiated dentry is legal or not.
 190                  * VFS doesn't seem to care so check and warn here.
 191                  */
 192                 err = -EIO;
 193         }
 194 out:
 195         if (err) {
 196                 dput(newdentry);
 197                 return ERR_PTR(err);
 198         }
 199         return newdentry;
 200 }
 201
 202 struct dentry *ovl_create_temp(struct dentry *workdir, struct ovl_cattr *attr)
 203 {
 204         return ovl_create_real(d_inode(workdir), ovl_lookup_temp(workdir),
 205                                attr);
 206 }
 207
 208 static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
 209                                int xerr)
 210 {
 211         int err;
 212
 213         err = ovl_check_setxattr(dentry, upper, OVL_XATTR_OPAQUE, "y", 1, xerr);
 214         if (!err)
 215                 ovl_dentry_set_opaque(dentry);
 216
 217         return err;
 218 }
 219
 220 static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
 221 {
 222         /*
 223          * Fail with -EIO when trying to create opaque dir and upper doesn't
 224          * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
 225          * return a specific error for noxattr case.
 226          */
 227         return ovl_set_opaque_xerr(dentry, upperdentry, -EIO);
 228 }
 229
 230 /*
 231  * Common operations required to be done after creation of file on upper.
 232  * If @hardlink is false, then @inode is a pre-allocated inode, we may or
 233  * may not use to instantiate the new dentry.
 234  */
 235 static int ovl_instantiate(struct dentry *dentry, struct inode *inode,
 236                            struct dentry *newdentry, bool hardlink)
 237 {
 238         struct ovl_inode_params oip = {
 239                 .upperdentry = newdentry,
 240                 .newinode = inode,
 241         };
 242
 243         ovl_dir_modified(dentry->d_parent, false);
 244         ovl_dentry_set_upper_alias(dentry);
 245         if (!hardlink) {
 246                 /*
 247                  * ovl_obtain_alias() can be called after ovl_create_real()
 248                  * and before we get here, so we may get an inode from cache
 249                  * with the same real upperdentry that is not the inode we
 250                  * pre-allocated.  In this case we will use the cached inode
 251                  * to instantiate the new dentry.
 252                  *
 253                  * XXX: if we ever use ovl_obtain_alias() to decode directory
 254                  * file handles, need to use ovl_get_inode_locked() and
 255                  * d_instantiate_new() here to prevent from creating two
 256                  * hashed directory inode aliases.
 257                  */
 258                 inode = ovl_get_inode(dentry->d_sb, &oip);
 259                 if (IS_ERR(inode))
 260                         return PTR_ERR(inode);
 261         } else {
 262                 WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
 263                 dput(newdentry);
 264                 inc_nlink(inode);
 265         }
 266
 267         d_instantiate(dentry, inode);
 268         if (inode != oip.newinode) {
 269                 pr_warn_ratelimited("overlayfs: newly created inode found in cache (%pd2)\n",
 270                                     dentry);
 271         }
 272
 273         /* Force lookup of new upper hardlink to find its lower */
 274         if (hardlink)
 275                 d_drop(dentry);
 276
 277         return 0;
 278 }
 279
 280 static bool ovl_type_merge(struct dentry *dentry)
 281 {
 282         return OVL_TYPE_MERGE(ovl_path_type(dentry));
 283 }
 284
 285 static bool ovl_type_origin(struct dentry *dentry)
 286 {
 287         return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
 288 }
 289
 290 static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
 291                             struct ovl_cattr *attr)
 292 {
 293         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 294         struct inode *udir = upperdir->d_inode;
 295         struct dentry *newdentry;
 296         int err;
 297
 298         if (!attr->hardlink && !IS_POSIXACL(udir))
 299                 attr->mode &= ~current_umask();
 300
 301         inode_lock_nested(udir, I_MUTEX_PARENT);
 302         newdentry = ovl_create_real(udir,
 303                                     lookup_one_len(dentry->d_name.name,
 304                                                    upperdir,
 305                                                    dentry->d_name.len),
 306                                     attr);
 307         err = PTR_ERR(newdentry);
 308         if (IS_ERR(newdentry))
 309                 goto out_unlock;
 310
 311         if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry)) {
 312                 /* Setting opaque here is just an optimization, allow to fail */
 313                 ovl_set_opaque(dentry, newdentry);
 314         }
 315
 316         err = ovl_instantiate(dentry, inode, newdentry, !!attr->hardlink);
 317         if (err)
 318                 goto out_cleanup;
 319 out_unlock:
 320         inode_unlock(udir);
 321         return err;
 322
 323 out_cleanup:
 324         ovl_cleanup(udir, newdentry);
 325         dput(newdentry);
 326         goto out_unlock;
 327 }
 328
 329 static struct dentry *ovl_clear_empty(struct dentry *dentry,
 330                                       struct list_head *list)
 331 {
 332         struct dentry *workdir = ovl_workdir(dentry);
 333         struct inode *wdir = workdir->d_inode;
 334         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 335         struct inode *udir = upperdir->d_inode;
 336         struct path upperpath;
 337         struct dentry *upper;
 338         struct dentry *opaquedir;
 339         struct kstat stat;
 340         int err;
 341
 342         if (WARN_ON(!workdir))
 343                 return ERR_PTR(-EROFS);
 344
 345         err = ovl_lock_rename_workdir(workdir, upperdir);
 346         if (err)
 347                 goto out;
 348
 349         ovl_path_upper(dentry, &upperpath);
 350         err = vfs_getattr(&upperpath, &stat,
 351                           STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
 352         if (err)
 353                 goto out_unlock;
 354
 355         err = -ESTALE;
 356         if (!S_ISDIR(stat.mode))
 357                 goto out_unlock;
 358         upper = upperpath.dentry;
 359         if (upper->d_parent->d_inode != udir)
 360                 goto out_unlock;
 361
 362         opaquedir = ovl_create_temp(workdir, OVL_CATTR(stat.mode));
 363         err = PTR_ERR(opaquedir);
 364         if (IS_ERR(opaquedir))
 365                 goto out_unlock;
 366
 367         err = ovl_copy_xattr(upper, opaquedir);
 368         if (err)
 369                 goto out_cleanup;
 370
 371         err = ovl_set_opaque(dentry, opaquedir);
 372         if (err)
 373                 goto out_cleanup;
 374
 375         inode_lock(opaquedir->d_inode);
 376         err = ovl_set_attr(opaquedir, &stat);
 377         inode_unlock(opaquedir->d_inode);
 378         if (err)
 379                 goto out_cleanup;
 380
 381         err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);
 382         if (err)
 383                 goto out_cleanup;
 384
 385         ovl_cleanup_whiteouts(upper, list);
 386         ovl_cleanup(wdir, upper);
 387         unlock_rename(workdir, upperdir);
 388
 389         /* dentry's upper doesn't match now, get rid of it */
 390         d_drop(dentry);
 391
 392         return opaquedir;
 393
 394 out_cleanup:
 395         ovl_cleanup(wdir, opaquedir);
 396         dput(opaquedir);
 397 out_unlock:
 398         unlock_rename(workdir, upperdir);
 399 out:
 400         return ERR_PTR(err);
 401 }
 402
 403 static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name,
 404                              const struct posix_acl *acl)
 405 {
 406         void *buffer;
 407         size_t size;
 408         int err;
 409
 410         if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
 411                 return 0;
 412
 413         size = posix_acl_xattr_size(acl->a_count);
 414         buffer = kmalloc(size, GFP_KERNEL);
 415         if (!buffer)
 416                 return -ENOMEM;
 417
 418         err = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
 419         if (err < 0)
 420                 goto out_free;
 421
 422         err = vfs_setxattr(upperdentry, name, buffer, size, XATTR_CREATE);
 423 out_free:
 424         kfree(buffer);
 425         return err;
 426 }
 427
 428 static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
 429                                     struct ovl_cattr *cattr)
 430 {
 431         struct dentry *workdir = ovl_workdir(dentry);
 432         struct inode *wdir = workdir->d_inode;
 433         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 434         struct inode *udir = upperdir->d_inode;
 435         struct dentry *upper;
 436         struct dentry *newdentry;
 437         int err;
 438         struct posix_acl *acl, *default_acl;
 439         bool hardlink = !!cattr->hardlink;
 440
 441         if (WARN_ON(!workdir))
 442                 return -EROFS;
 443
 444         if (!hardlink) {
 445                 err = posix_acl_create(dentry->d_parent->d_inode,
 446                                        &cattr->mode, &default_acl, &acl);
 447                 if (err)
 448                         return err;
 449         }
 450
 451         err = ovl_lock_rename_workdir(workdir, upperdir);
 452         if (err)
 453                 goto out;
 454
 455         upper = lookup_one_len(dentry->d_name.name, upperdir,
 456                                dentry->d_name.len);
 457         err = PTR_ERR(upper);
 458         if (IS_ERR(upper))
 459                 goto out_unlock;
 460
 461         err = -ESTALE;
 462         if (d_is_negative(upper) || !IS_WHITEOUT(d_inode(upper)))
 463                 goto out_dput;
 464
 465         newdentry = ovl_create_temp(workdir, cattr);
 466         err = PTR_ERR(newdentry);
 467         if (IS_ERR(newdentry))
 468                 goto out_dput;
 469
 470         /*
 471          * mode could have been mutilated due to umask (e.g. sgid directory)
 472          */
 473         if (!hardlink &&
 474             !S_ISLNK(cattr->mode) &&
 475             newdentry->d_inode->i_mode != cattr->mode) {
 476                 struct iattr attr = {
 477                         .ia_valid = ATTR_MODE,
 478                         .ia_mode = cattr->mode,
 479                 };
 480                 inode_lock(newdentry->d_inode);
 481                 err = notify_change(newdentry, &attr, NULL);
 482                 inode_unlock(newdentry->d_inode);
 483                 if (err)
 484                         goto out_cleanup;
 485         }
 486         if (!hardlink) {
 487                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,
 488                                         acl);
 489                 if (err)
 490                         goto out_cleanup;
 491
 492                 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,
 493                                         default_acl);
 494                 if (err)
 495                         goto out_cleanup;
 496         }
 497
 498         if (!hardlink && S_ISDIR(cattr->mode)) {
 499                 err = ovl_set_opaque(dentry, newdentry);
 500                 if (err)
 501                         goto out_cleanup;
 502
 503                 err = ovl_do_rename(wdir, newdentry, udir, upper,
 504                                     RENAME_EXCHANGE);
 505                 if (err)
 506                         goto out_cleanup;
 507
 508                 ovl_cleanup(wdir, upper);
 509         } else {
 510                 err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
 511                 if (err)
 512                         goto out_cleanup;
 513         }
 514         err = ovl_instantiate(dentry, inode, newdentry, hardlink);
 515         if (err) {
 516                 ovl_cleanup(udir, newdentry);
 517                 dput(newdentry);
 518         }
 519 out_dput:
 520         dput(upper);
 521 out_unlock:
 522         unlock_rename(workdir, upperdir);
 523 out:
 524         if (!hardlink) {
 525                 posix_acl_release(acl);
 526                 posix_acl_release(default_acl);
 527         }
 528         return err;
 529
 530 out_cleanup:
 531         ovl_cleanup(wdir, newdentry);
 532         dput(newdentry);
 533         goto out_dput;
 534 }
 535
 536 static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
 537                               struct ovl_cattr *attr, bool origin)
 538 {
 539         int err;
 540         const struct cred *old_cred;
 541         struct cred *override_cred;
 542         struct dentry *parent = dentry->d_parent;
 543
 544         err = ovl_copy_up(parent);
 545         if (err)
 546                 return err;
 547
 548         old_cred = ovl_override_creds(dentry->d_sb);
 549
 550         /*
 551          * When linking a file with copy up origin into a new parent, mark the
 552          * new parent dir "impure".
 553          */
 554         if (origin) {
 555                 err = ovl_set_impure(parent, ovl_dentry_upper(parent));
 556                 if (err)
 557                         goto out_revert_creds;
 558         }
 559
 560         if (!attr->hardlink) {
 561                 err = -ENOMEM;
 562                 override_cred = prepare_creds();
 563                 if (!override_cred)
 564                         goto out_revert_creds;
 565                 /*
 566                  * In the creation cases(create, mkdir, mknod, symlink),
 567                  * ovl should transfer current's fs{u,g}id to underlying
 568                  * fs. Because underlying fs want to initialize its new
 569                  * inode owner using current's fs{u,g}id. And in this
 570                  * case, the @inode is a new inode that is initialized
 571                  * in inode_init_owner() to current's fs{u,g}id. So use
 572                  * the inode's i_{u,g}id to override the cred's fs{u,g}id.
 573                  *
 574                  * But in the other hardlink case, ovl_link() does not
 575                  * create a new inode, so just use the ovl mounter's
 576                  * fs{u,g}id.
 577                  */
 578                 override_cred->fsuid = inode->i_uid;
 579                 override_cred->fsgid = inode->i_gid;
 580                 err = security_dentry_create_files_as(dentry,
 581                                 attr->mode, &dentry->d_name, old_cred,
 582                                 override_cred);
 583                 if (err) {
 584                         put_cred(override_cred);
 585                         goto out_revert_creds;
 586                 }
 587                 put_cred(override_creds(override_cred));
 588                 put_cred(override_cred);
 589         }
 590
 591         if (!ovl_dentry_is_whiteout(dentry))
 592                 err = ovl_create_upper(dentry, inode, attr);
 593         else
 594                 err = ovl_create_over_whiteout(dentry, inode, attr);
 595
 596 out_revert_creds:
 597         revert_creds(old_cred);
 598         return err;
 599 }
 600
 601 static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
 602                              const char *link)
 603 {
 604         int err;
 605         struct inode *inode;
 606         struct ovl_cattr attr = {
 607                 .rdev = rdev,
 608                 .link = link,
 609         };
 610
 611         err = ovl_want_write(dentry);
 612         if (err)
 613                 goto out;
 614
 615         /* Preallocate inode to be used by ovl_get_inode() */
 616         err = -ENOMEM;
 617         inode = ovl_new_inode(dentry->d_sb, mode, rdev);
 618         if (!inode)
 619                 goto out_drop_write;
 620
 621         spin_lock(&inode->i_lock);
 622         inode->i_state |= I_CREATING;
 623         spin_unlock(&inode->i_lock);
 624
 625         inode_init_owner(inode, dentry->d_parent->d_inode, mode);
 626         attr.mode = inode->i_mode;
 627
 628         err = ovl_create_or_link(dentry, inode, &attr, false);
 629         /* Did we end up using the preallocated inode? */
 630         if (inode != d_inode(dentry))
 631                 iput(inode);
 632
 633 out_drop_write:
 634         ovl_drop_write(dentry);
 635 out:
 636         return err;
 637 }
 638
 639 static int ovl_create(struct inode *dir, struct dentry *dentry, umode_t mode,
 640                       bool excl)
 641 {
 642         return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
 643 }
 644
 645 static int ovl_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 646 {
 647         return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
 648 }
 649
 650 static int ovl_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,
 651                      dev_t rdev)
 652 {
 653         /* Don't allow creation of "whiteout" on overlay */
 654         if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
 655                 return -EPERM;
 656
 657         return ovl_create_object(dentry, mode, rdev, NULL);
 658 }
 659
 660 static int ovl_symlink(struct inode *dir, struct dentry *dentry,
 661                        const char *link)
 662 {
 663         return ovl_create_object(dentry, S_IFLNK, 0, link);
 664 }
 665
 666 static int ovl_set_link_redirect(struct dentry *dentry)
 667 {
 668         const struct cred *old_cred;
 669         int err;
 670
 671         old_cred = ovl_override_creds(dentry->d_sb);
 672         err = ovl_set_redirect(dentry, false);
 673         revert_creds(old_cred);
 674
 675         return err;
 676 }
 677
 678 static int ovl_link(struct dentry *old, struct inode *newdir,
 679                     struct dentry *new)
 680 {
 681         int err;
 682         struct inode *inode;
 683
 684         err = ovl_want_write(old);
 685         if (err)
 686                 goto out;
 687
 688         err = ovl_copy_up(old);
 689         if (err)
 690                 goto out_drop_write;
 691
 692         err = ovl_copy_up(new->d_parent);
 693         if (err)
 694                 goto out_drop_write;
 695
 696         if (ovl_is_metacopy_dentry(old)) {
 697                 err = ovl_set_link_redirect(old);
 698                 if (err)
 699                         goto out_drop_write;
 700         }
 701
 702         err = ovl_nlink_start(old);
 703         if (err)
 704                 goto out_drop_write;
 705
 706         inode = d_inode(old);
 707         ihold(inode);
 708
 709         err = ovl_create_or_link(new, inode,
 710                         &(struct ovl_cattr) {.hardlink = ovl_dentry_upper(old)},
 711                         ovl_type_origin(old));
 712         if (err)
 713                 iput(inode);
 714
 715         ovl_nlink_end(old);
 716 out_drop_write:
 717         ovl_drop_write(old);
 718 out:
 719         return err;
 720 }
 721
 722 static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
 723 {
 724         return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
 725 }
 726
 727 static int ovl_remove_and_whiteout(struct dentry *dentry,
 728                                    struct list_head *list)
 729 {
 730         struct dentry *workdir = ovl_workdir(dentry);
 731         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 732         struct dentry *upper;
 733         struct dentry *opaquedir = NULL;
 734         int err;
 735
 736         if (WARN_ON(!workdir))
 737                 return -EROFS;
 738
 739         if (!list_empty(list)) {
 740                 opaquedir = ovl_clear_empty(dentry, list);
 741                 err = PTR_ERR(opaquedir);
 742                 if (IS_ERR(opaquedir))
 743                         goto out;
 744         }
 745
 746         err = ovl_lock_rename_workdir(workdir, upperdir);
 747         if (err)
 748                 goto out_dput;
 749
 750         upper = lookup_one_len(dentry->d_name.name, upperdir,
 751                                dentry->d_name.len);
 752         err = PTR_ERR(upper);
 753         if (IS_ERR(upper))
 754                 goto out_unlock;
 755
 756         err = -ESTALE;
 757         if ((opaquedir && upper != opaquedir) ||
 758             (!opaquedir && ovl_dentry_upper(dentry) &&
 759              !ovl_matches_upper(dentry, upper))) {
 760                 goto out_dput_upper;
 761         }
 762
 763         err = ovl_cleanup_and_whiteout(workdir, d_inode(upperdir), upper);
 764         if (err)
 765                 goto out_d_drop;
 766
 767         ovl_dir_modified(dentry->d_parent, true);
 768 out_d_drop:
 769         d_drop(dentry);
 770 out_dput_upper:
 771         dput(upper);
 772 out_unlock:
 773         unlock_rename(workdir, upperdir);
 774 out_dput:
 775         dput(opaquedir);
 776 out:
 777         return err;
 778 }
 779
 780 static int ovl_remove_upper(struct dentry *dentry, bool is_dir,
 781                             struct list_head *list)
 782 {
 783         struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 784         struct inode *dir = upperdir->d_inode;
 785         struct dentry *upper;
 786         struct dentry *opaquedir = NULL;
 787         int err;
 788
 789         if (!list_empty(list)) {
 790                 opaquedir = ovl_clear_empty(dentry, list);
 791                 err = PTR_ERR(opaquedir);
 792                 if (IS_ERR(opaquedir))
 793                         goto out;
 794         }
 795
 796         inode_lock_nested(dir, I_MUTEX_PARENT);
 797         upper = lookup_one_len(dentry->d_name.name, upperdir,
 798                                dentry->d_name.len);
 799         err = PTR_ERR(upper);
 800         if (IS_ERR(upper))
 801                 goto out_unlock;
 802
 803         err = -ESTALE;
 804         if ((opaquedir && upper != opaquedir) ||
 805             (!opaquedir && !ovl_matches_upper(dentry, upper)))
 806                 goto out_dput_upper;
 807
 808         if (is_dir)
 809                 err = vfs_rmdir(dir, upper);
 810         else
 811                 err = vfs_unlink(dir, upper, NULL);
 812         ovl_dir_modified(dentry->d_parent, ovl_type_origin(dentry));
 813
 814         /*
 815          * Keeping this dentry hashed would mean having to release
 816          * upperpath/lowerpath, which could only be done if we are the
 817          * sole user of this dentry.  Too tricky...  Just unhash for
 818          * now.
 819          */
 820         if (!err)
 821                 d_drop(dentry);
 822 out_dput_upper:
 823         dput(upper);
 824 out_unlock:
 825         inode_unlock(dir);
 826         dput(opaquedir);
 827 out:
 828         return err;
 829 }
 830
 831 static bool ovl_pure_upper(struct dentry *dentry)
 832 {
 833         return !ovl_dentry_lower(dentry) &&
 834                !ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
 835 }
 836
 837 static int ovl_do_remove(struct dentry *dentry, bool is_dir)
 838 {
 839         int err;
 840         const struct cred *old_cred;
 841         struct dentry *upperdentry;
 842         bool lower_positive = ovl_lower_positive(dentry);
 843         LIST_HEAD(list);
 844
 845         /* No need to clean pure upper removed by vfs_rmdir() */
 846         if (is_dir && (lower_positive || !ovl_pure_upper(dentry))) {
 847                 err = ovl_check_empty_dir(dentry, &list);
 848                 if (err)
 849                         goto out;
 850         }
 851
 852         err = ovl_want_write(dentry);
 853         if (err)
 854                 goto out;
 855
 856         err = ovl_copy_up(dentry->d_parent);
 857         if (err)
 858                 goto out_drop_write;
 859
 860         err = ovl_nlink_start(dentry);
 861         if (err)
 862                 goto out_drop_write;
 863
 864         old_cred = ovl_override_creds(dentry->d_sb);
 865         if (!lower_positive)
 866                 err = ovl_remove_upper(dentry, is_dir, &list);
 867         else
 868                 err = ovl_remove_and_whiteout(dentry, &list);
 869         revert_creds(old_cred);
 870         if (!err) {
 871                 if (is_dir)
 872                         clear_nlink(dentry->d_inode);
 873                 else
 874                         drop_nlink(dentry->d_inode);
 875         }
 876         ovl_nlink_end(dentry);
 877
 878         /*
 879          * Copy ctime
 880          *
 881          * Note: we fail to update ctime if there was no copy-up, only a
 882          * whiteout
 883          */
 884         upperdentry = ovl_dentry_upper(dentry);
 885         if (upperdentry)
 886                 ovl_copyattr(d_inode(upperdentry), d_inode(dentry));
 887
 888 out_drop_write:
 889         ovl_drop_write(dentry);
 890 out:
 891         ovl_cache_free(&list);
 892         return err;
 893 }
 894
 895 static int ovl_unlink(struct inode *dir, struct dentry *dentry)
 896 {
 897         return ovl_do_remove(dentry, false);
 898 }
 899
 900 static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
 901 {
 902         return ovl_do_remove(dentry, true);
 903 }
 904
 905 static bool ovl_type_merge_or_lower(struct dentry *dentry)
 906 {
 907         enum ovl_path_type type = ovl_path_type(dentry);
 908
 909         return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
 910 }
 911
 912 static bool ovl_can_move(struct dentry *dentry)
 913 {
 914         return ovl_redirect_dir(dentry->d_sb) ||
 915                 !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
 916 }
 917
 918 static char *ovl_get_redirect(struct dentry *dentry, bool abs_redirect)
 919 {
 920         char *buf, *ret;
 921         struct dentry *d, *tmp;
 922         int buflen = ovl_redirect_max + 1;
 923
 924         if (!abs_redirect) {
 925                 ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
 926                                GFP_KERNEL);
 927                 goto out;
 928         }
 929
 930         buf = ret = kmalloc(buflen, GFP_KERNEL);
 931         if (!buf)
 932                 goto out;
 933
 934         buflen--;
 935         buf[buflen] = '\0';
 936         for (d = dget(dentry); !IS_ROOT(d);) {
 937                 const char *name;
 938                 int thislen;
 939
 940                 spin_lock(&d->d_lock);
 941                 name = ovl_dentry_get_redirect(d);
 942                 if (name) {
 943                         thislen = strlen(name);
 944                 } else {
 945                         name = d->d_name.name;
 946                         thislen = d->d_name.len;
 947                 }
 948
 949                 /* If path is too long, fall back to userspace move */
 950                 if (thislen + (name[0] != '/') > buflen) {
 951                         ret = ERR_PTR(-EXDEV);
 952                         spin_unlock(&d->d_lock);
 953                         goto out_put;
 954                 }
 955
 956                 buflen -= thislen;
 957                 memcpy(&buf[buflen], name, thislen);
 958                 spin_unlock(&d->d_lock);
 959                 tmp = dget_parent(d);
 960
 961                 dput(d);
 962                 d = tmp;
 963
 964                 /* Absolute redirect: finished */
 965                 if (buf[buflen] == '/')
 966                         break;
 967                 buflen--;
 968                 buf[buflen] = '/';
 969         }
 970         ret = kstrdup(&buf[buflen], GFP_KERNEL);
 971 out_put:
 972         dput(d);
 973         kfree(buf);
 974 out:
 975         return ret ? ret : ERR_PTR(-ENOMEM);
 976 }
 977
 978 static bool ovl_need_absolute_redirect(struct dentry *dentry, bool samedir)
 979 {
 980         struct dentry *lowerdentry;
 981
 982         if (!samedir)
 983                 return true;
 984
 985         if (d_is_dir(dentry))
 986                 return false;
 987
 988         /*
 989          * For non-dir hardlinked files, we need absolute redirects
 990          * in general as two upper hardlinks could be in different
 991          * dirs. We could put a relative redirect now and convert
 992          * it to absolute redirect later. But when nlink > 1 and
 993          * indexing is on, that means relative redirect needs to be
 994          * converted to absolute during copy up of another lower
 995          * hardllink as well.
 996          *
 997          * So without optimizing too much, just check if lower is
 998          * a hard link or not. If lower is hard link, put absolute
 999          * redirect.
1000          */
1001         lowerdentry = ovl_dentry_lower(dentry);
1002         return (d_inode(lowerdentry)->i_nlink > 1);
1003 }
1004
1005 static int ovl_set_redirect(struct dentry *dentry, bool samedir)
1006 {
1007         int err;
1008         const char *redirect = ovl_dentry_get_redirect(dentry);
1009         bool absolute_redirect = ovl_need_absolute_redirect(dentry, samedir);
1010
1011         if (redirect && (!absolute_redirect || redirect[0] == '/'))
1012                 return 0;
1013
1014         redirect = ovl_get_redirect(dentry, absolute_redirect);
1015         if (IS_ERR(redirect))
1016                 return PTR_ERR(redirect);
1017
1018         err = ovl_check_setxattr(dentry, ovl_dentry_upper(dentry),
1019                                  OVL_XATTR_REDIRECT,
1020                                  redirect, strlen(redirect), -EXDEV);
1021         if (!err) {
1022                 spin_lock(&dentry->d_lock);
1023                 ovl_dentry_set_redirect(dentry, redirect);
1024                 spin_unlock(&dentry->d_lock);
1025         } else {
1026                 kfree(redirect);
1027                 pr_warn_ratelimited("overlayfs: failed to set redirect (%i)\n",
1028                                     err);
1029                 /* Fall back to userspace copy-up */
1030                 err = -EXDEV;
1031         }
1032         return err;
1033 }
1034
1035 static int ovl_rename(struct inode *olddir, struct dentry *old,
1036                       struct inode *newdir, struct dentry *new,
1037                       unsigned int flags)
1038 {
1039         int err;
1040         struct dentry *old_upperdir;
1041         struct dentry *new_upperdir;
1042         struct dentry *olddentry;
1043         struct dentry *newdentry;
1044         struct dentry *trap;
1045         bool old_opaque;
1046         bool new_opaque;
1047         bool cleanup_whiteout = false;
1048         bool update_nlink = false;
1049         bool overwrite = !(flags & RENAME_EXCHANGE);
1050         bool is_dir = d_is_dir(old);
1051         bool new_is_dir = d_is_dir(new);
1052         bool samedir = olddir == newdir;
1053         struct dentry *opaquedir = NULL;
1054         const struct cred *old_cred = NULL;
1055         LIST_HEAD(list);
1056
1057         err = -EINVAL;
1058         if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
1059                 goto out;
1060
1061         flags &= ~RENAME_NOREPLACE;
1062
1063         /* Don't copy up directory trees */
1064         err = -EXDEV;
1065         if (!ovl_can_move(old))
1066                 goto out;
1067         if (!overwrite && !ovl_can_move(new))
1068                 goto out;
1069
1070         if (overwrite && new_is_dir && !ovl_pure_upper(new)) {
1071                 err = ovl_check_empty_dir(new, &list);
1072                 if (err)
1073                         goto out;
1074         }
1075
1076         if (overwrite) {
1077                 if (ovl_lower_positive(old)) {
1078                         if (!ovl_dentry_is_whiteout(new)) {
1079                                 /* Whiteout source */
1080                                 flags |= RENAME_WHITEOUT;
1081                         } else {
1082                                 /* Switch whiteouts */
1083                                 flags |= RENAME_EXCHANGE;
1084                         }
1085                 } else if (is_dir && ovl_dentry_is_whiteout(new)) {
1086                         flags |= RENAME_EXCHANGE;
1087                         cleanup_whiteout = true;
1088                 }
1089         }
1090
1091         err = ovl_want_write(old);
1092         if (err)
1093                 goto out;
1094
1095         err = ovl_copy_up(old);
1096         if (err)
1097                 goto out_drop_write;
1098
1099         err = ovl_copy_up(new->d_parent);
1100         if (err)
1101                 goto out_drop_write;
1102         if (!overwrite) {
1103                 err = ovl_copy_up(new);
1104                 if (err)
1105                         goto out_drop_write;
1106         } else if (d_inode(new)) {
1107                 err = ovl_nlink_start(new);
1108                 if (err)
1109                         goto out_drop_write;
1110
1111                 update_nlink = true;
1112         }
1113
1114         old_cred = ovl_override_creds(old->d_sb);
1115
1116         if (!list_empty(&list)) {
1117                 opaquedir = ovl_clear_empty(new, &list);
1118                 err = PTR_ERR(opaquedir);
1119                 if (IS_ERR(opaquedir)) {
1120                         opaquedir = NULL;
1121                         goto out_revert_creds;
1122                 }
1123         }
1124
1125         old_upperdir = ovl_dentry_upper(old->d_parent);
1126         new_upperdir = ovl_dentry_upper(new->d_parent);
1127
1128         if (!samedir) {
1129                 /*
1130                  * When moving a merge dir or non-dir with copy up origin into
1131                  * a new parent, we are marking the new parent dir "impure".
1132                  * When ovl_iterate() iterates an "impure" upper dir, it will
1133                  * lookup the origin inodes of the entries to fill d_ino.
1134                  */
1135                 if (ovl_type_origin(old)) {
1136                         err = ovl_set_impure(new->d_parent, new_upperdir);
1137                         if (err)
1138                                 goto out_revert_creds;
1139                 }
1140                 if (!overwrite && ovl_type_origin(new)) {
1141                         err = ovl_set_impure(old->d_parent, old_upperdir);
1142                         if (err)
1143                                 goto out_revert_creds;
1144                 }
1145         }
1146
1147         trap = lock_rename(new_upperdir, old_upperdir);
1148
1149         olddentry = lookup_one_len(old->d_name.name, old_upperdir,
1150                                    old->d_name.len);
1151         err = PTR_ERR(olddentry);
1152         if (IS_ERR(olddentry))
1153                 goto out_unlock;
1154
1155         err = -ESTALE;
1156         if (!ovl_matches_upper(old, olddentry))
1157                 goto out_dput_old;
1158
1159         newdentry = lookup_one_len(new->d_name.name, new_upperdir,
1160                                    new->d_name.len);
1161         err = PTR_ERR(newdentry);
1162         if (IS_ERR(newdentry))
1163                 goto out_dput_old;
1164
1165         old_opaque = ovl_dentry_is_opaque(old);
1166         new_opaque = ovl_dentry_is_opaque(new);
1167
1168         err = -ESTALE;
1169         if (d_inode(new) && ovl_dentry_upper(new)) {
1170                 if (opaquedir) {
1171                         if (newdentry != opaquedir)
1172                                 goto out_dput;
1173                 } else {
1174                         if (!ovl_matches_upper(new, newdentry))
1175                                 goto out_dput;
1176                 }
1177         } else {
1178                 if (!d_is_negative(newdentry)) {
1179                         if (!new_opaque || !ovl_is_whiteout(newdentry))
1180                                 goto out_dput;
1181                 } else {
1182                         if (flags & RENAME_EXCHANGE)
1183                                 goto out_dput;
1184                 }
1185         }
1186
1187         if (olddentry == trap)
1188                 goto out_dput;
1189         if (newdentry == trap)
1190                 goto out_dput;
1191
1192         if (olddentry->d_inode == newdentry->d_inode)
1193                 goto out_dput;
1194
1195         err = 0;
1196         if (ovl_type_merge_or_lower(old))
1197                 err = ovl_set_redirect(old, samedir);
1198         else if (is_dir && !old_opaque && ovl_type_merge(new->d_parent))
1199                 err = ovl_set_opaque_xerr(old, olddentry, -EXDEV);
1200         if (err)
1201                 goto out_dput;
1202
1203         if (!overwrite && ovl_type_merge_or_lower(new))
1204                 err = ovl_set_redirect(new, samedir);
1205         else if (!overwrite && new_is_dir && !new_opaque &&
1206                  ovl_type_merge(old->d_parent))
1207                 err = ovl_set_opaque_xerr(new, newdentry, -EXDEV);
1208         if (err)
1209                 goto out_dput;
1210
1211         err = ovl_do_rename(old_upperdir->d_inode, olddentry,
1212                             new_upperdir->d_inode, newdentry, flags);
1213         if (err)
1214                 goto out_dput;
1215
1216         if (cleanup_whiteout)
1217                 ovl_cleanup(old_upperdir->d_inode, newdentry);
1218
1219         if (overwrite && d_inode(new)) {
1220                 if (new_is_dir)
1221                         clear_nlink(d_inode(new));
1222                 else
1223                         drop_nlink(d_inode(new));
1224         }
1225
1226         ovl_dir_modified(old->d_parent, ovl_type_origin(old) ||
1227                          (!overwrite && ovl_type_origin(new)));
1228         ovl_dir_modified(new->d_parent, ovl_type_origin(old) ||
1229                          (d_inode(new) && ovl_type_origin(new)));
1230
1231         /* copy ctime: */
1232         ovl_copyattr(d_inode(olddentry), d_inode(old));
1233         if (d_inode(new) && ovl_dentry_upper(new))
1234                 ovl_copyattr(d_inode(newdentry), d_inode(new));
1235
1236 out_dput:
1237         dput(newdentry);
1238 out_dput_old:
1239         dput(olddentry);
1240 out_unlock:
1241         unlock_rename(new_upperdir, old_upperdir);
1242 out_revert_creds:
1243         revert_creds(old_cred);
1244         if (update_nlink)
1245                 ovl_nlink_end(new);
1246 out_drop_write:
1247         ovl_drop_write(old);
1248 out:
1249         dput(opaquedir);
1250         ovl_cache_free(&list);
1251         return err;
1252 }
1253
1254 const struct inode_operations ovl_dir_inode_operations = {
1255         .lookup         = ovl_lookup,
1256         .mkdir          = ovl_mkdir,
1257         .symlink        = ovl_symlink,
1258         .unlink         = ovl_unlink,
1259         .rmdir          = ovl_rmdir,
1260         .rename         = ovl_rename,
1261         .link           = ovl_link,
1262         .setattr        = ovl_setattr,
1263         .create         = ovl_create,
1264         .mknod          = ovl_mknod,
1265         .permission     = ovl_permission,
1266         .getattr        = ovl_getattr,
1267         .listxattr      = ovl_listxattr,
1268         .get_acl        = ovl_get_acl,
1269         .update_time    = ovl_update_time,
1270 };