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