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