fs/overlayfs/dir.c

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