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/mount.h> 15 #include <linux/slab.h> 16 #include <linux/parser.h> 17 #include <linux/module.h> 18 #include <linux/sched.h> 19 #include <linux/statfs.h> 20 #include <linux/seq_file.h> 21 #include "overlayfs.h" 22 23 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); 24 MODULE_DESCRIPTION("Overlay filesystem"); 25 MODULE_LICENSE("GPL"); 26 27 #define OVERLAYFS_SUPER_MAGIC 0x794c7630 28 29 struct ovl_config { 30 char *lowerdir; 31 char *upperdir; 32 char *workdir; 33 }; 34 35 /* private information held for overlayfs's superblock */ 36 struct ovl_fs { 37 struct vfsmount *upper_mnt; 38 struct vfsmount *lower_mnt; 39 struct dentry *workdir; 40 long lower_namelen; 41 /* pathnames of lower and upper dirs, for show_options */ 42 struct ovl_config config; 43 }; 44 45 struct ovl_dir_cache; 46 47 /* private information held for every overlayfs dentry */ 48 struct ovl_entry { 49 struct dentry *__upperdentry; 50 struct dentry *lowerdentry; 51 struct ovl_dir_cache *cache; 52 union { 53 struct { 54 u64 version; 55 bool opaque; 56 }; 57 struct rcu_head rcu; 58 }; 59 }; 60 61 const char *ovl_opaque_xattr = "trusted.overlay.opaque"; 62 63 64 enum ovl_path_type ovl_path_type(struct dentry *dentry) 65 { 66 struct ovl_entry *oe = dentry->d_fsdata; 67 68 if (oe->__upperdentry) { 69 if (oe->lowerdentry) { 70 if (S_ISDIR(dentry->d_inode->i_mode)) 71 return OVL_PATH_MERGE; 72 else 73 return OVL_PATH_UPPER; 74 } else { 75 if (oe->opaque) 76 return OVL_PATH_UPPER; 77 else 78 return OVL_PATH_PURE_UPPER; 79 } 80 } else { 81 return OVL_PATH_LOWER; 82 } 83 } 84 85 static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe) 86 { 87 return lockless_dereference(oe->__upperdentry); 88 } 89 90 void ovl_path_upper(struct dentry *dentry, struct path *path) 91 { 92 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 93 struct ovl_entry *oe = dentry->d_fsdata; 94 95 path->mnt = ofs->upper_mnt; 96 path->dentry = ovl_upperdentry_dereference(oe); 97 } 98 99 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path) 100 { 101 102 enum ovl_path_type type = ovl_path_type(dentry); 103 104 if (type == OVL_PATH_LOWER) 105 ovl_path_lower(dentry, path); 106 else 107 ovl_path_upper(dentry, path); 108 109 return type; 110 } 111 112 struct dentry *ovl_dentry_upper(struct dentry *dentry) 113 { 114 struct ovl_entry *oe = dentry->d_fsdata; 115 116 return ovl_upperdentry_dereference(oe); 117 } 118 119 struct dentry *ovl_dentry_lower(struct dentry *dentry) 120 { 121 struct ovl_entry *oe = dentry->d_fsdata; 122 123 return oe->lowerdentry; 124 } 125 126 struct dentry *ovl_dentry_real(struct dentry *dentry) 127 { 128 struct ovl_entry *oe = dentry->d_fsdata; 129 struct dentry *realdentry; 130 131 realdentry = ovl_upperdentry_dereference(oe); 132 if (!realdentry) 133 realdentry = oe->lowerdentry; 134 135 return realdentry; 136 } 137 138 struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper) 139 { 140 struct dentry *realdentry; 141 142 realdentry = ovl_upperdentry_dereference(oe); 143 if (realdentry) { 144 *is_upper = true; 145 } else { 146 realdentry = oe->lowerdentry; 147 *is_upper = false; 148 } 149 return realdentry; 150 } 151 152 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry) 153 { 154 struct ovl_entry *oe = dentry->d_fsdata; 155 156 return oe->cache; 157 } 158 159 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache) 160 { 161 struct ovl_entry *oe = dentry->d_fsdata; 162 163 oe->cache = cache; 164 } 165 166 void ovl_path_lower(struct dentry *dentry, struct path *path) 167 { 168 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 169 struct ovl_entry *oe = dentry->d_fsdata; 170 171 path->mnt = ofs->lower_mnt; 172 path->dentry = oe->lowerdentry; 173 } 174 175 int ovl_want_write(struct dentry *dentry) 176 { 177 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 178 return mnt_want_write(ofs->upper_mnt); 179 } 180 181 void ovl_drop_write(struct dentry *dentry) 182 { 183 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 184 mnt_drop_write(ofs->upper_mnt); 185 } 186 187 struct dentry *ovl_workdir(struct dentry *dentry) 188 { 189 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 190 return ofs->workdir; 191 } 192 193 bool ovl_dentry_is_opaque(struct dentry *dentry) 194 { 195 struct ovl_entry *oe = dentry->d_fsdata; 196 return oe->opaque; 197 } 198 199 void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque) 200 { 201 struct ovl_entry *oe = dentry->d_fsdata; 202 oe->opaque = opaque; 203 } 204 205 void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry) 206 { 207 struct ovl_entry *oe = dentry->d_fsdata; 208 209 WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); 210 WARN_ON(oe->__upperdentry); 211 BUG_ON(!upperdentry->d_inode); 212 /* 213 * Make sure upperdentry is consistent before making it visible to 214 * ovl_upperdentry_dereference(). 215 */ 216 smp_wmb(); 217 oe->__upperdentry = upperdentry; 218 } 219 220 void ovl_dentry_version_inc(struct dentry *dentry) 221 { 222 struct ovl_entry *oe = dentry->d_fsdata; 223 224 WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 225 oe->version++; 226 } 227 228 u64 ovl_dentry_version_get(struct dentry *dentry) 229 { 230 struct ovl_entry *oe = dentry->d_fsdata; 231 232 WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); 233 return oe->version; 234 } 235 236 bool ovl_is_whiteout(struct dentry *dentry) 237 { 238 struct inode *inode = dentry->d_inode; 239 240 return inode && IS_WHITEOUT(inode); 241 } 242 243 static bool ovl_is_opaquedir(struct dentry *dentry) 244 { 245 int res; 246 char val; 247 struct inode *inode = dentry->d_inode; 248 249 if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr) 250 return false; 251 252 res = inode->i_op->getxattr(dentry, ovl_opaque_xattr, &val, 1); 253 if (res == 1 && val == 'y') 254 return true; 255 256 return false; 257 } 258 259 static void ovl_dentry_release(struct dentry *dentry) 260 { 261 struct ovl_entry *oe = dentry->d_fsdata; 262 263 if (oe) { 264 dput(oe->__upperdentry); 265 dput(oe->lowerdentry); 266 kfree_rcu(oe, rcu); 267 } 268 } 269 270 static const struct dentry_operations ovl_dentry_operations = { 271 .d_release = ovl_dentry_release, 272 }; 273 274 static struct ovl_entry *ovl_alloc_entry(void) 275 { 276 return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); 277 } 278 279 static inline struct dentry *ovl_lookup_real(struct dentry *dir, 280 struct qstr *name) 281 { 282 struct dentry *dentry; 283 284 mutex_lock(&dir->d_inode->i_mutex); 285 dentry = lookup_one_len(name->name, dir, name->len); 286 mutex_unlock(&dir->d_inode->i_mutex); 287 288 if (IS_ERR(dentry)) { 289 if (PTR_ERR(dentry) == -ENOENT) 290 dentry = NULL; 291 } else if (!dentry->d_inode) { 292 dput(dentry); 293 dentry = NULL; 294 } 295 return dentry; 296 } 297 298 struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry, 299 unsigned int flags) 300 { 301 struct ovl_entry *oe; 302 struct dentry *upperdir; 303 struct dentry *lowerdir; 304 struct dentry *upperdentry = NULL; 305 struct dentry *lowerdentry = NULL; 306 struct inode *inode = NULL; 307 int err; 308 309 err = -ENOMEM; 310 oe = ovl_alloc_entry(); 311 if (!oe) 312 goto out; 313 314 upperdir = ovl_dentry_upper(dentry->d_parent); 315 lowerdir = ovl_dentry_lower(dentry->d_parent); 316 317 if (upperdir) { 318 upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); 319 err = PTR_ERR(upperdentry); 320 if (IS_ERR(upperdentry)) 321 goto out_put_dir; 322 323 if (lowerdir && upperdentry) { 324 if (ovl_is_whiteout(upperdentry)) { 325 dput(upperdentry); 326 upperdentry = NULL; 327 oe->opaque = true; 328 } else if (ovl_is_opaquedir(upperdentry)) { 329 oe->opaque = true; 330 } 331 } 332 } 333 if (lowerdir && !oe->opaque) { 334 lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); 335 err = PTR_ERR(lowerdentry); 336 if (IS_ERR(lowerdentry)) 337 goto out_dput_upper; 338 } 339 340 if (lowerdentry && upperdentry && 341 (!S_ISDIR(upperdentry->d_inode->i_mode) || 342 !S_ISDIR(lowerdentry->d_inode->i_mode))) { 343 dput(lowerdentry); 344 lowerdentry = NULL; 345 oe->opaque = true; 346 } 347 348 if (lowerdentry || upperdentry) { 349 struct dentry *realdentry; 350 351 realdentry = upperdentry ? upperdentry : lowerdentry; 352 err = -ENOMEM; 353 inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, 354 oe); 355 if (!inode) 356 goto out_dput; 357 ovl_copyattr(realdentry->d_inode, inode); 358 } 359 360 oe->__upperdentry = upperdentry; 361 oe->lowerdentry = lowerdentry; 362 363 dentry->d_fsdata = oe; 364 d_add(dentry, inode); 365 366 return NULL; 367 368 out_dput: 369 dput(lowerdentry); 370 out_dput_upper: 371 dput(upperdentry); 372 out_put_dir: 373 kfree(oe); 374 out: 375 return ERR_PTR(err); 376 } 377 378 struct file *ovl_path_open(struct path *path, int flags) 379 { 380 return dentry_open(path, flags, current_cred()); 381 } 382 383 static void ovl_put_super(struct super_block *sb) 384 { 385 struct ovl_fs *ufs = sb->s_fs_info; 386 387 dput(ufs->workdir); 388 mntput(ufs->upper_mnt); 389 mntput(ufs->lower_mnt); 390 391 kfree(ufs->config.lowerdir); 392 kfree(ufs->config.upperdir); 393 kfree(ufs->config.workdir); 394 kfree(ufs); 395 } 396 397 /** 398 * ovl_statfs 399 * @sb: The overlayfs super block 400 * @buf: The struct kstatfs to fill in with stats 401 * 402 * Get the filesystem statistics. As writes always target the upper layer 403 * filesystem pass the statfs to the same filesystem. 404 */ 405 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf) 406 { 407 struct ovl_fs *ofs = dentry->d_sb->s_fs_info; 408 struct dentry *root_dentry = dentry->d_sb->s_root; 409 struct path path; 410 int err; 411 412 ovl_path_upper(root_dentry, &path); 413 414 err = vfs_statfs(&path, buf); 415 if (!err) { 416 buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen); 417 buf->f_type = OVERLAYFS_SUPER_MAGIC; 418 } 419 420 return err; 421 } 422 423 /** 424 * ovl_show_options 425 * 426 * Prints the mount options for a given superblock. 427 * Returns zero; does not fail. 428 */ 429 static int ovl_show_options(struct seq_file *m, struct dentry *dentry) 430 { 431 struct super_block *sb = dentry->d_sb; 432 struct ovl_fs *ufs = sb->s_fs_info; 433 434 seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); 435 seq_printf(m, ",upperdir=%s", ufs->config.upperdir); 436 seq_printf(m, ",workdir=%s", ufs->config.workdir); 437 return 0; 438 } 439 440 static const struct super_operations ovl_super_operations = { 441 .put_super = ovl_put_super, 442 .statfs = ovl_statfs, 443 .show_options = ovl_show_options, 444 }; 445 446 enum { 447 OPT_LOWERDIR, 448 OPT_UPPERDIR, 449 OPT_WORKDIR, 450 OPT_ERR, 451 }; 452 453 static const match_table_t ovl_tokens = { 454 {OPT_LOWERDIR, "lowerdir=%s"}, 455 {OPT_UPPERDIR, "upperdir=%s"}, 456 {OPT_WORKDIR, "workdir=%s"}, 457 {OPT_ERR, NULL} 458 }; 459 460 static char *ovl_next_opt(char **s) 461 { 462 char *sbegin = *s; 463 char *p; 464 465 if (sbegin == NULL) 466 return NULL; 467 468 for (p = sbegin; *p; p++) { 469 if (*p == '\\') { 470 p++; 471 if (!*p) 472 break; 473 } else if (*p == ',') { 474 *p = '\0'; 475 *s = p + 1; 476 return sbegin; 477 } 478 } 479 *s = NULL; 480 return sbegin; 481 } 482 483 static int ovl_parse_opt(char *opt, struct ovl_config *config) 484 { 485 char *p; 486 487 while ((p = ovl_next_opt(&opt)) != NULL) { 488 int token; 489 substring_t args[MAX_OPT_ARGS]; 490 491 if (!*p) 492 continue; 493 494 token = match_token(p, ovl_tokens, args); 495 switch (token) { 496 case OPT_UPPERDIR: 497 kfree(config->upperdir); 498 config->upperdir = match_strdup(&args[0]); 499 if (!config->upperdir) 500 return -ENOMEM; 501 break; 502 503 case OPT_LOWERDIR: 504 kfree(config->lowerdir); 505 config->lowerdir = match_strdup(&args[0]); 506 if (!config->lowerdir) 507 return -ENOMEM; 508 break; 509 510 case OPT_WORKDIR: 511 kfree(config->workdir); 512 config->workdir = match_strdup(&args[0]); 513 if (!config->workdir) 514 return -ENOMEM; 515 break; 516 517 default: 518 return -EINVAL; 519 } 520 } 521 return 0; 522 } 523 524 #define OVL_WORKDIR_NAME "work" 525 526 static struct dentry *ovl_workdir_create(struct vfsmount *mnt, 527 struct dentry *dentry) 528 { 529 struct inode *dir = dentry->d_inode; 530 struct dentry *work; 531 int err; 532 bool retried = false; 533 534 err = mnt_want_write(mnt); 535 if (err) 536 return ERR_PTR(err); 537 538 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 539 retry: 540 work = lookup_one_len(OVL_WORKDIR_NAME, dentry, 541 strlen(OVL_WORKDIR_NAME)); 542 543 if (!IS_ERR(work)) { 544 struct kstat stat = { 545 .mode = S_IFDIR | 0, 546 }; 547 548 if (work->d_inode) { 549 err = -EEXIST; 550 if (retried) 551 goto out_dput; 552 553 retried = true; 554 ovl_cleanup(dir, work); 555 dput(work); 556 goto retry; 557 } 558 559 err = ovl_create_real(dir, work, &stat, NULL, NULL, true); 560 if (err) 561 goto out_dput; 562 } 563 out_unlock: 564 mutex_unlock(&dir->i_mutex); 565 mnt_drop_write(mnt); 566 567 return work; 568 569 out_dput: 570 dput(work); 571 work = ERR_PTR(err); 572 goto out_unlock; 573 } 574 575 static void ovl_unescape(char *s) 576 { 577 char *d = s; 578 579 for (;; s++, d++) { 580 if (*s == '\\') 581 s++; 582 *d = *s; 583 if (!*s) 584 break; 585 } 586 } 587 588 static int ovl_mount_dir(const char *name, struct path *path) 589 { 590 int err; 591 char *tmp = kstrdup(name, GFP_KERNEL); 592 593 if (!tmp) 594 return -ENOMEM; 595 596 ovl_unescape(tmp); 597 err = kern_path(tmp, LOOKUP_FOLLOW, path); 598 if (err) { 599 pr_err("overlayfs: failed to resolve '%s': %i\n", tmp, err); 600 err = -EINVAL; 601 } 602 kfree(tmp); 603 return err; 604 } 605 606 static bool ovl_is_allowed_fs_type(struct dentry *root) 607 { 608 const struct dentry_operations *dop = root->d_op; 609 610 /* 611 * We don't support: 612 * - automount filesystems 613 * - filesystems with revalidate (FIXME for lower layer) 614 * - filesystems with case insensitive names 615 */ 616 if (dop && 617 (dop->d_manage || dop->d_automount || 618 dop->d_revalidate || dop->d_weak_revalidate || 619 dop->d_compare || dop->d_hash)) { 620 return false; 621 } 622 return true; 623 } 624 625 /* Workdir should not be subdir of upperdir and vice versa */ 626 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir) 627 { 628 bool ok = false; 629 630 if (workdir != upperdir) { 631 ok = (lock_rename(workdir, upperdir) == NULL); 632 unlock_rename(workdir, upperdir); 633 } 634 return ok; 635 } 636 637 static int ovl_fill_super(struct super_block *sb, void *data, int silent) 638 { 639 struct path lowerpath; 640 struct path upperpath; 641 struct path workpath; 642 struct inode *root_inode; 643 struct dentry *root_dentry; 644 struct ovl_entry *oe; 645 struct ovl_fs *ufs; 646 struct kstatfs statfs; 647 int err; 648 649 err = -ENOMEM; 650 ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); 651 if (!ufs) 652 goto out; 653 654 err = ovl_parse_opt((char *) data, &ufs->config); 655 if (err) 656 goto out_free_config; 657 658 /* FIXME: workdir is not needed for a R/O mount */ 659 err = -EINVAL; 660 if (!ufs->config.upperdir || !ufs->config.lowerdir || 661 !ufs->config.workdir) { 662 pr_err("overlayfs: missing upperdir or lowerdir or workdir\n"); 663 goto out_free_config; 664 } 665 666 err = -ENOMEM; 667 oe = ovl_alloc_entry(); 668 if (oe == NULL) 669 goto out_free_config; 670 671 err = ovl_mount_dir(ufs->config.upperdir, &upperpath); 672 if (err) 673 goto out_free_oe; 674 675 err = ovl_mount_dir(ufs->config.lowerdir, &lowerpath); 676 if (err) 677 goto out_put_upperpath; 678 679 err = ovl_mount_dir(ufs->config.workdir, &workpath); 680 if (err) 681 goto out_put_lowerpath; 682 683 err = -EINVAL; 684 if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) || 685 !S_ISDIR(lowerpath.dentry->d_inode->i_mode) || 686 !S_ISDIR(workpath.dentry->d_inode->i_mode)) { 687 pr_err("overlayfs: upperdir or lowerdir or workdir not a directory\n"); 688 goto out_put_workpath; 689 } 690 691 if (upperpath.mnt != workpath.mnt) { 692 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); 693 goto out_put_workpath; 694 } 695 if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { 696 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); 697 goto out_put_workpath; 698 } 699 700 if (!ovl_is_allowed_fs_type(upperpath.dentry)) { 701 pr_err("overlayfs: filesystem of upperdir is not supported\n"); 702 goto out_put_workpath; 703 } 704 705 if (!ovl_is_allowed_fs_type(lowerpath.dentry)) { 706 pr_err("overlayfs: filesystem of lowerdir is not supported\n"); 707 goto out_put_workpath; 708 } 709 710 err = vfs_statfs(&lowerpath, &statfs); 711 if (err) { 712 pr_err("overlayfs: statfs failed on lowerpath\n"); 713 goto out_put_workpath; 714 } 715 ufs->lower_namelen = statfs.f_namelen; 716 717 sb->s_stack_depth = max(upperpath.mnt->mnt_sb->s_stack_depth, 718 lowerpath.mnt->mnt_sb->s_stack_depth) + 1; 719 720 err = -EINVAL; 721 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) { 722 pr_err("overlayfs: maximum fs stacking depth exceeded\n"); 723 goto out_put_workpath; 724 } 725 726 ufs->upper_mnt = clone_private_mount(&upperpath); 727 err = PTR_ERR(ufs->upper_mnt); 728 if (IS_ERR(ufs->upper_mnt)) { 729 pr_err("overlayfs: failed to clone upperpath\n"); 730 goto out_put_workpath; 731 } 732 733 ufs->lower_mnt = clone_private_mount(&lowerpath); 734 err = PTR_ERR(ufs->lower_mnt); 735 if (IS_ERR(ufs->lower_mnt)) { 736 pr_err("overlayfs: failed to clone lowerpath\n"); 737 goto out_put_upper_mnt; 738 } 739 740 ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry); 741 err = PTR_ERR(ufs->workdir); 742 if (IS_ERR(ufs->workdir)) { 743 pr_err("overlayfs: failed to create directory %s/%s\n", 744 ufs->config.workdir, OVL_WORKDIR_NAME); 745 goto out_put_lower_mnt; 746 } 747 748 /* 749 * Make lower_mnt R/O. That way fchmod/fchown on lower file 750 * will fail instead of modifying lower fs. 751 */ 752 ufs->lower_mnt->mnt_flags |= MNT_READONLY; 753 754 /* If the upper fs is r/o, we mark overlayfs r/o too */ 755 if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) 756 sb->s_flags |= MS_RDONLY; 757 758 sb->s_d_op = &ovl_dentry_operations; 759 760 err = -ENOMEM; 761 root_inode = ovl_new_inode(sb, S_IFDIR, oe); 762 if (!root_inode) 763 goto out_put_workdir; 764 765 root_dentry = d_make_root(root_inode); 766 if (!root_dentry) 767 goto out_put_workdir; 768 769 mntput(upperpath.mnt); 770 mntput(lowerpath.mnt); 771 path_put(&workpath); 772 773 oe->__upperdentry = upperpath.dentry; 774 oe->lowerdentry = lowerpath.dentry; 775 776 root_dentry->d_fsdata = oe; 777 778 sb->s_magic = OVERLAYFS_SUPER_MAGIC; 779 sb->s_op = &ovl_super_operations; 780 sb->s_root = root_dentry; 781 sb->s_fs_info = ufs; 782 783 return 0; 784 785 out_put_workdir: 786 dput(ufs->workdir); 787 out_put_lower_mnt: 788 mntput(ufs->lower_mnt); 789 out_put_upper_mnt: 790 mntput(ufs->upper_mnt); 791 out_put_workpath: 792 path_put(&workpath); 793 out_put_lowerpath: 794 path_put(&lowerpath); 795 out_put_upperpath: 796 path_put(&upperpath); 797 out_free_oe: 798 kfree(oe); 799 out_free_config: 800 kfree(ufs->config.lowerdir); 801 kfree(ufs->config.upperdir); 802 kfree(ufs->config.workdir); 803 kfree(ufs); 804 out: 805 return err; 806 } 807 808 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags, 809 const char *dev_name, void *raw_data) 810 { 811 return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); 812 } 813 814 static struct file_system_type ovl_fs_type = { 815 .owner = THIS_MODULE, 816 .name = "overlay", 817 .mount = ovl_mount, 818 .kill_sb = kill_anon_super, 819 }; 820 MODULE_ALIAS_FS("overlay"); 821 822 static int __init ovl_init(void) 823 { 824 return register_filesystem(&ovl_fs_type); 825 } 826 827 static void __exit ovl_exit(void) 828 { 829 unregister_filesystem(&ovl_fs_type); 830 } 831 832 module_init(ovl_init); 833 module_exit(ovl_exit); 834