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