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 /* Force lookup of new upper hardlink to find its lower */ 156 if (hardlink) 157 d_drop(dentry); 158 } 159 160 static bool ovl_type_merge(struct dentry *dentry) 161 { 162 return OVL_TYPE_MERGE(ovl_path_type(dentry)); 163 } 164 165 static int ovl_create_upper(struct dentry *dentry, struct inode *inode, 166 struct cattr *attr, struct dentry *hardlink) 167 { 168 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent); 169 struct inode *udir = upperdir->d_inode; 170 struct dentry *newdentry; 171 int err; 172 173 if (!hardlink && !IS_POSIXACL(udir)) 174 attr->mode &= ~current_umask(); 175 176 inode_lock_nested(udir, I_MUTEX_PARENT); 177 newdentry = lookup_one_len(dentry->d_name.name, upperdir, 178 dentry->d_name.len); 179 err = PTR_ERR(newdentry); 180 if (IS_ERR(newdentry)) 181 goto out_unlock; 182 err = ovl_create_real(udir, newdentry, attr, hardlink, false); 183 if (err) 184 goto out_dput; 185 186 if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry)) { 187 /* Setting opaque here is just an optimization, allow to fail */ 188 ovl_set_opaque(dentry, newdentry); 189 } 190 191 ovl_instantiate(dentry, inode, newdentry, !!hardlink); 192 newdentry = NULL; 193 out_dput: 194 dput(newdentry); 195 out_unlock: 196 inode_unlock(udir); 197 return err; 198 } 199 200 static int ovl_lock_rename_workdir(struct dentry *workdir, 201 struct dentry *upperdir) 202 { 203 /* Workdir should not be the same as upperdir */ 204 if (workdir == upperdir) 205 goto err; 206 207 /* Workdir should not be subdir of upperdir and vice versa */ 208 if (lock_rename(workdir, upperdir) != NULL) 209 goto err_unlock; 210 211 return 0; 212 213 err_unlock: 214 unlock_rename(workdir, upperdir); 215 err: 216 pr_err("overlayfs: failed to lock workdir+upperdir\n"); 217 return -EIO; 218 } 219 220 static struct dentry *ovl_clear_empty(struct dentry *dentry, 221 struct list_head *list) 222 { 223 struct dentry *workdir = ovl_workdir(dentry); 224 struct inode *wdir = workdir->d_inode; 225 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent); 226 struct inode *udir = upperdir->d_inode; 227 struct path upperpath; 228 struct dentry *upper; 229 struct dentry *opaquedir; 230 struct kstat stat; 231 int err; 232 233 if (WARN_ON(!workdir)) 234 return ERR_PTR(-EROFS); 235 236 err = ovl_lock_rename_workdir(workdir, upperdir); 237 if (err) 238 goto out; 239 240 ovl_path_upper(dentry, &upperpath); 241 err = vfs_getattr(&upperpath, &stat, 242 STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT); 243 if (err) 244 goto out_unlock; 245 246 err = -ESTALE; 247 if (!S_ISDIR(stat.mode)) 248 goto out_unlock; 249 upper = upperpath.dentry; 250 if (upper->d_parent->d_inode != udir) 251 goto out_unlock; 252 253 opaquedir = ovl_lookup_temp(workdir, dentry); 254 err = PTR_ERR(opaquedir); 255 if (IS_ERR(opaquedir)) 256 goto out_unlock; 257 258 err = ovl_create_real(wdir, opaquedir, 259 &(struct cattr){.mode = stat.mode}, NULL, true); 260 if (err) 261 goto out_dput; 262 263 err = ovl_copy_xattr(upper, opaquedir); 264 if (err) 265 goto out_cleanup; 266 267 err = ovl_set_opaque(dentry, opaquedir); 268 if (err) 269 goto out_cleanup; 270 271 inode_lock(opaquedir->d_inode); 272 err = ovl_set_attr(opaquedir, &stat); 273 inode_unlock(opaquedir->d_inode); 274 if (err) 275 goto out_cleanup; 276 277 err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE); 278 if (err) 279 goto out_cleanup; 280 281 ovl_cleanup_whiteouts(upper, list); 282 ovl_cleanup(wdir, upper); 283 unlock_rename(workdir, upperdir); 284 285 /* dentry's upper doesn't match now, get rid of it */ 286 d_drop(dentry); 287 288 return opaquedir; 289 290 out_cleanup: 291 ovl_cleanup(wdir, opaquedir); 292 out_dput: 293 dput(opaquedir); 294 out_unlock: 295 unlock_rename(workdir, upperdir); 296 out: 297 return ERR_PTR(err); 298 } 299 300 static struct dentry *ovl_check_empty_and_clear(struct dentry *dentry) 301 { 302 int err; 303 struct dentry *ret = NULL; 304 enum ovl_path_type type = ovl_path_type(dentry); 305 LIST_HEAD(list); 306 307 err = ovl_check_empty_dir(dentry, &list); 308 if (err) { 309 ret = ERR_PTR(err); 310 goto out_free; 311 } 312 313 /* 314 * When removing an empty opaque directory, then it makes no sense to 315 * replace it with an exact replica of itself. 316 * 317 * If no upperdentry then skip clearing whiteouts. 318 * 319 * Can race with copy-up, since we don't hold the upperdir mutex. 320 * Doesn't matter, since copy-up can't create a non-empty directory 321 * from an empty one. 322 */ 323 if (OVL_TYPE_UPPER(type) && OVL_TYPE_MERGE(type)) 324 ret = ovl_clear_empty(dentry, &list); 325 326 out_free: 327 ovl_cache_free(&list); 328 329 return ret; 330 } 331 332 static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name, 333 const struct posix_acl *acl) 334 { 335 void *buffer; 336 size_t size; 337 int err; 338 339 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl) 340 return 0; 341 342 size = posix_acl_to_xattr(NULL, acl, NULL, 0); 343 buffer = kmalloc(size, GFP_KERNEL); 344 if (!buffer) 345 return -ENOMEM; 346 347 size = posix_acl_to_xattr(&init_user_ns, acl, buffer, size); 348 err = size; 349 if (err < 0) 350 goto out_free; 351 352 err = vfs_setxattr(upperdentry, name, buffer, size, XATTR_CREATE); 353 out_free: 354 kfree(buffer); 355 return err; 356 } 357 358 static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode, 359 struct cattr *cattr, 360 struct dentry *hardlink) 361 { 362 struct dentry *workdir = ovl_workdir(dentry); 363 struct inode *wdir = workdir->d_inode; 364 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent); 365 struct inode *udir = upperdir->d_inode; 366 struct dentry *upper; 367 struct dentry *newdentry; 368 int err; 369 struct posix_acl *acl, *default_acl; 370 371 if (WARN_ON(!workdir)) 372 return -EROFS; 373 374 if (!hardlink) { 375 err = posix_acl_create(dentry->d_parent->d_inode, 376 &cattr->mode, &default_acl, &acl); 377 if (err) 378 return err; 379 } 380 381 err = ovl_lock_rename_workdir(workdir, upperdir); 382 if (err) 383 goto out; 384 385 newdentry = ovl_lookup_temp(workdir, dentry); 386 err = PTR_ERR(newdentry); 387 if (IS_ERR(newdentry)) 388 goto out_unlock; 389 390 upper = lookup_one_len(dentry->d_name.name, upperdir, 391 dentry->d_name.len); 392 err = PTR_ERR(upper); 393 if (IS_ERR(upper)) 394 goto out_dput; 395 396 err = ovl_create_real(wdir, newdentry, cattr, hardlink, true); 397 if (err) 398 goto out_dput2; 399 400 /* 401 * mode could have been mutilated due to umask (e.g. sgid directory) 402 */ 403 if (!hardlink && 404 !S_ISLNK(cattr->mode) && 405 newdentry->d_inode->i_mode != cattr->mode) { 406 struct iattr attr = { 407 .ia_valid = ATTR_MODE, 408 .ia_mode = cattr->mode, 409 }; 410 inode_lock(newdentry->d_inode); 411 err = notify_change(newdentry, &attr, NULL); 412 inode_unlock(newdentry->d_inode); 413 if (err) 414 goto out_cleanup; 415 } 416 if (!hardlink) { 417 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS, 418 acl); 419 if (err) 420 goto out_cleanup; 421 422 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT, 423 default_acl); 424 if (err) 425 goto out_cleanup; 426 } 427 428 if (!hardlink && S_ISDIR(cattr->mode)) { 429 err = ovl_set_opaque(dentry, newdentry); 430 if (err) 431 goto out_cleanup; 432 433 err = ovl_do_rename(wdir, newdentry, udir, upper, 434 RENAME_EXCHANGE); 435 if (err) 436 goto out_cleanup; 437 438 ovl_cleanup(wdir, upper); 439 } else { 440 err = ovl_do_rename(wdir, newdentry, udir, upper, 0); 441 if (err) 442 goto out_cleanup; 443 } 444 ovl_instantiate(dentry, inode, newdentry, !!hardlink); 445 newdentry = NULL; 446 out_dput2: 447 dput(upper); 448 out_dput: 449 dput(newdentry); 450 out_unlock: 451 unlock_rename(workdir, upperdir); 452 out: 453 if (!hardlink) { 454 posix_acl_release(acl); 455 posix_acl_release(default_acl); 456 } 457 return err; 458 459 out_cleanup: 460 ovl_cleanup(wdir, newdentry); 461 goto out_dput2; 462 } 463 464 static int ovl_create_or_link(struct dentry *dentry, struct inode *inode, 465 struct cattr *attr, struct dentry *hardlink) 466 { 467 int err; 468 const struct cred *old_cred; 469 struct cred *override_cred; 470 471 err = ovl_copy_up(dentry->d_parent); 472 if (err) 473 return err; 474 475 old_cred = ovl_override_creds(dentry->d_sb); 476 err = -ENOMEM; 477 override_cred = prepare_creds(); 478 if (override_cred) { 479 override_cred->fsuid = inode->i_uid; 480 override_cred->fsgid = inode->i_gid; 481 if (!hardlink) { 482 err = security_dentry_create_files_as(dentry, 483 attr->mode, &dentry->d_name, old_cred, 484 override_cred); 485 if (err) { 486 put_cred(override_cred); 487 goto out_revert_creds; 488 } 489 } 490 put_cred(override_creds(override_cred)); 491 put_cred(override_cred); 492 493 if (!ovl_dentry_is_whiteout(dentry)) 494 err = ovl_create_upper(dentry, inode, attr, 495 hardlink); 496 else 497 err = ovl_create_over_whiteout(dentry, inode, attr, 498 hardlink); 499 } 500 out_revert_creds: 501 revert_creds(old_cred); 502 if (!err) { 503 struct inode *realinode = d_inode(ovl_dentry_upper(dentry)); 504 505 WARN_ON(inode->i_mode != realinode->i_mode); 506 WARN_ON(!uid_eq(inode->i_uid, realinode->i_uid)); 507 WARN_ON(!gid_eq(inode->i_gid, realinode->i_gid)); 508 } 509 return err; 510 } 511 512 static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev, 513 const char *link) 514 { 515 int err; 516 struct inode *inode; 517 struct cattr attr = { 518 .rdev = rdev, 519 .link = link, 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, rdev); 528 if (!inode) 529 goto out_drop_write; 530 531 inode_init_owner(inode, dentry->d_parent->d_inode, mode); 532 attr.mode = inode->i_mode; 533 534 err = ovl_create_or_link(dentry, inode, &attr, 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, 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 struct dentry *opaquedir = NULL; 675 int err; 676 677 /* Redirect dir can be !ovl_lower_positive && OVL_TYPE_MERGE */ 678 if (is_dir && ovl_dentry_get_redirect(dentry)) { 679 opaquedir = ovl_check_empty_and_clear(dentry); 680 err = PTR_ERR(opaquedir); 681 if (IS_ERR(opaquedir)) 682 goto out; 683 } 684 685 inode_lock_nested(dir, I_MUTEX_PARENT); 686 upper = lookup_one_len(dentry->d_name.name, upperdir, 687 dentry->d_name.len); 688 err = PTR_ERR(upper); 689 if (IS_ERR(upper)) 690 goto out_unlock; 691 692 err = -ESTALE; 693 if ((opaquedir && upper != opaquedir) || 694 (!opaquedir && upper != ovl_dentry_upper(dentry))) 695 goto out_dput_upper; 696 697 if (is_dir) 698 err = vfs_rmdir(dir, upper); 699 else 700 err = vfs_unlink(dir, upper, NULL); 701 ovl_dentry_version_inc(dentry->d_parent); 702 703 /* 704 * Keeping this dentry hashed would mean having to release 705 * upperpath/lowerpath, which could only be done if we are the 706 * sole user of this dentry. Too tricky... Just unhash for 707 * now. 708 */ 709 if (!err) 710 d_drop(dentry); 711 out_dput_upper: 712 dput(upper); 713 out_unlock: 714 inode_unlock(dir); 715 dput(opaquedir); 716 out: 717 return err; 718 } 719 720 static int ovl_do_remove(struct dentry *dentry, bool is_dir) 721 { 722 enum ovl_path_type type; 723 int err; 724 const struct cred *old_cred; 725 726 err = ovl_want_write(dentry); 727 if (err) 728 goto out; 729 730 err = ovl_copy_up(dentry->d_parent); 731 if (err) 732 goto out_drop_write; 733 734 type = ovl_path_type(dentry); 735 736 old_cred = ovl_override_creds(dentry->d_sb); 737 if (!ovl_lower_positive(dentry)) 738 err = ovl_remove_upper(dentry, is_dir); 739 else 740 err = ovl_remove_and_whiteout(dentry, is_dir); 741 revert_creds(old_cred); 742 if (!err) { 743 if (is_dir) 744 clear_nlink(dentry->d_inode); 745 else 746 drop_nlink(dentry->d_inode); 747 } 748 out_drop_write: 749 ovl_drop_write(dentry); 750 out: 751 return err; 752 } 753 754 static int ovl_unlink(struct inode *dir, struct dentry *dentry) 755 { 756 return ovl_do_remove(dentry, false); 757 } 758 759 static int ovl_rmdir(struct inode *dir, struct dentry *dentry) 760 { 761 return ovl_do_remove(dentry, true); 762 } 763 764 static bool ovl_type_merge_or_lower(struct dentry *dentry) 765 { 766 enum ovl_path_type type = ovl_path_type(dentry); 767 768 return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type); 769 } 770 771 static bool ovl_can_move(struct dentry *dentry) 772 { 773 return ovl_redirect_dir(dentry->d_sb) || 774 !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry); 775 } 776 777 static char *ovl_get_redirect(struct dentry *dentry, bool samedir) 778 { 779 char *buf, *ret; 780 struct dentry *d, *tmp; 781 int buflen = ovl_redirect_max + 1; 782 783 if (samedir) { 784 ret = kstrndup(dentry->d_name.name, dentry->d_name.len, 785 GFP_KERNEL); 786 goto out; 787 } 788 789 buf = ret = kmalloc(buflen, GFP_TEMPORARY); 790 if (!buf) 791 goto out; 792 793 buflen--; 794 buf[buflen] = '\0'; 795 for (d = dget(dentry); !IS_ROOT(d);) { 796 const char *name; 797 int thislen; 798 799 spin_lock(&d->d_lock); 800 name = ovl_dentry_get_redirect(d); 801 if (name) { 802 thislen = strlen(name); 803 } else { 804 name = d->d_name.name; 805 thislen = d->d_name.len; 806 } 807 808 /* If path is too long, fall back to userspace move */ 809 if (thislen + (name[0] != '/') > buflen) { 810 ret = ERR_PTR(-EXDEV); 811 spin_unlock(&d->d_lock); 812 goto out_put; 813 } 814 815 buflen -= thislen; 816 memcpy(&buf[buflen], name, thislen); 817 tmp = dget_dlock(d->d_parent); 818 spin_unlock(&d->d_lock); 819 820 dput(d); 821 d = tmp; 822 823 /* Absolute redirect: finished */ 824 if (buf[buflen] == '/') 825 break; 826 buflen--; 827 buf[buflen] = '/'; 828 } 829 ret = kstrdup(&buf[buflen], GFP_KERNEL); 830 out_put: 831 dput(d); 832 kfree(buf); 833 out: 834 return ret ? ret : ERR_PTR(-ENOMEM); 835 } 836 837 static int ovl_set_redirect(struct dentry *dentry, bool samedir) 838 { 839 int err; 840 const char *redirect = ovl_dentry_get_redirect(dentry); 841 842 if (redirect && (samedir || redirect[0] == '/')) 843 return 0; 844 845 redirect = ovl_get_redirect(dentry, samedir); 846 if (IS_ERR(redirect)) 847 return PTR_ERR(redirect); 848 849 err = ovl_do_setxattr(ovl_dentry_upper(dentry), OVL_XATTR_REDIRECT, 850 redirect, strlen(redirect), 0); 851 if (!err) { 852 spin_lock(&dentry->d_lock); 853 ovl_dentry_set_redirect(dentry, redirect); 854 spin_unlock(&dentry->d_lock); 855 } else { 856 kfree(redirect); 857 if (err == -EOPNOTSUPP) 858 ovl_clear_redirect_dir(dentry->d_sb); 859 else 860 pr_warn_ratelimited("overlay: failed to set redirect (%i)\n", err); 861 /* Fall back to userspace copy-up */ 862 err = -EXDEV; 863 } 864 return err; 865 } 866 867 static int ovl_rename(struct inode *olddir, struct dentry *old, 868 struct inode *newdir, struct dentry *new, 869 unsigned int flags) 870 { 871 int err; 872 struct dentry *old_upperdir; 873 struct dentry *new_upperdir; 874 struct dentry *olddentry; 875 struct dentry *newdentry; 876 struct dentry *trap; 877 bool old_opaque; 878 bool new_opaque; 879 bool cleanup_whiteout = false; 880 bool overwrite = !(flags & RENAME_EXCHANGE); 881 bool is_dir = d_is_dir(old); 882 bool new_is_dir = d_is_dir(new); 883 bool samedir = olddir == newdir; 884 struct dentry *opaquedir = NULL; 885 const struct cred *old_cred = NULL; 886 887 err = -EINVAL; 888 if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE)) 889 goto out; 890 891 flags &= ~RENAME_NOREPLACE; 892 893 /* Don't copy up directory trees */ 894 err = -EXDEV; 895 if (!ovl_can_move(old)) 896 goto out; 897 if (!overwrite && !ovl_can_move(new)) 898 goto out; 899 900 err = ovl_want_write(old); 901 if (err) 902 goto out; 903 904 err = ovl_copy_up(old); 905 if (err) 906 goto out_drop_write; 907 908 err = ovl_copy_up(new->d_parent); 909 if (err) 910 goto out_drop_write; 911 if (!overwrite) { 912 err = ovl_copy_up(new); 913 if (err) 914 goto out_drop_write; 915 } 916 917 old_cred = ovl_override_creds(old->d_sb); 918 919 if (overwrite && new_is_dir && ovl_type_merge_or_lower(new)) { 920 opaquedir = ovl_check_empty_and_clear(new); 921 err = PTR_ERR(opaquedir); 922 if (IS_ERR(opaquedir)) { 923 opaquedir = NULL; 924 goto out_revert_creds; 925 } 926 } 927 928 if (overwrite) { 929 if (ovl_lower_positive(old)) { 930 if (!ovl_dentry_is_whiteout(new)) { 931 /* Whiteout source */ 932 flags |= RENAME_WHITEOUT; 933 } else { 934 /* Switch whiteouts */ 935 flags |= RENAME_EXCHANGE; 936 } 937 } else if (is_dir && ovl_dentry_is_whiteout(new)) { 938 flags |= RENAME_EXCHANGE; 939 cleanup_whiteout = true; 940 } 941 } 942 943 old_upperdir = ovl_dentry_upper(old->d_parent); 944 new_upperdir = ovl_dentry_upper(new->d_parent); 945 946 trap = lock_rename(new_upperdir, old_upperdir); 947 948 olddentry = lookup_one_len(old->d_name.name, old_upperdir, 949 old->d_name.len); 950 err = PTR_ERR(olddentry); 951 if (IS_ERR(olddentry)) 952 goto out_unlock; 953 954 err = -ESTALE; 955 if (olddentry != ovl_dentry_upper(old)) 956 goto out_dput_old; 957 958 newdentry = lookup_one_len(new->d_name.name, new_upperdir, 959 new->d_name.len); 960 err = PTR_ERR(newdentry); 961 if (IS_ERR(newdentry)) 962 goto out_dput_old; 963 964 old_opaque = ovl_dentry_is_opaque(old); 965 new_opaque = ovl_dentry_is_opaque(new); 966 967 err = -ESTALE; 968 if (ovl_dentry_upper(new)) { 969 if (opaquedir) { 970 if (newdentry != opaquedir) 971 goto out_dput; 972 } else { 973 if (newdentry != ovl_dentry_upper(new)) 974 goto out_dput; 975 } 976 } else { 977 if (!d_is_negative(newdentry) && 978 (!new_opaque || !ovl_is_whiteout(newdentry))) 979 goto out_dput; 980 } 981 982 if (olddentry == trap) 983 goto out_dput; 984 if (newdentry == trap) 985 goto out_dput; 986 987 if (WARN_ON(olddentry->d_inode == newdentry->d_inode)) 988 goto out_dput; 989 990 err = 0; 991 if (is_dir) { 992 if (ovl_type_merge_or_lower(old)) 993 err = ovl_set_redirect(old, samedir); 994 else if (!old_opaque && ovl_type_merge(new->d_parent)) 995 err = ovl_set_opaque(old, olddentry); 996 if (err) 997 goto out_dput; 998 } 999 if (!overwrite && new_is_dir) { 1000 if (ovl_type_merge_or_lower(new)) 1001 err = ovl_set_redirect(new, samedir); 1002 else if (!new_opaque && ovl_type_merge(old->d_parent)) 1003 err = ovl_set_opaque(new, newdentry); 1004 if (err) 1005 goto out_dput; 1006 } 1007 1008 err = ovl_do_rename(old_upperdir->d_inode, olddentry, 1009 new_upperdir->d_inode, newdentry, flags); 1010 if (err) 1011 goto out_dput; 1012 1013 if (cleanup_whiteout) 1014 ovl_cleanup(old_upperdir->d_inode, newdentry); 1015 1016 ovl_dentry_version_inc(old->d_parent); 1017 ovl_dentry_version_inc(new->d_parent); 1018 1019 out_dput: 1020 dput(newdentry); 1021 out_dput_old: 1022 dput(olddentry); 1023 out_unlock: 1024 unlock_rename(new_upperdir, old_upperdir); 1025 out_revert_creds: 1026 revert_creds(old_cred); 1027 out_drop_write: 1028 ovl_drop_write(old); 1029 out: 1030 dput(opaquedir); 1031 return err; 1032 } 1033 1034 const struct inode_operations ovl_dir_inode_operations = { 1035 .lookup = ovl_lookup, 1036 .mkdir = ovl_mkdir, 1037 .symlink = ovl_symlink, 1038 .unlink = ovl_unlink, 1039 .rmdir = ovl_rmdir, 1040 .rename = ovl_rename, 1041 .link = ovl_link, 1042 .setattr = ovl_setattr, 1043 .create = ovl_create, 1044 .mknod = ovl_mknod, 1045 .permission = ovl_permission, 1046 .getattr = ovl_getattr, 1047 .listxattr = ovl_listxattr, 1048 .get_acl = ovl_get_acl, 1049 .update_time = ovl_update_time, 1050 }; 1051