]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/overlayfs/super.c
Merge branch 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / fs / overlayfs / super.c
1 /*
2 *
3 * Copyright (C) 2011 Novell Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 */
9
10 #include <linux/fs.h>
11 #include <linux/namei.h>
12 #include <linux/pagemap.h>
13 #include <linux/xattr.h>
14 #include <linux/security.h>
15 #include <linux/mount.h>
16 #include <linux/slab.h>
17 #include <linux/parser.h>
18 #include <linux/module.h>
19 #include <linux/pagemap.h>
20 #include <linux/sched.h>
21 #include <linux/statfs.h>
22 #include <linux/seq_file.h>
23 #include "overlayfs.h"
24
25 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
26 MODULE_DESCRIPTION("Overlay filesystem");
27 MODULE_LICENSE("GPL");
28
29 struct ovl_config {
30 char *lowerdir;
31 char *upperdir;
32 char *workdir;
33 bool default_permissions;
34 };
35
36 /* private information held for overlayfs's superblock */
37 struct ovl_fs {
38 struct vfsmount *upper_mnt;
39 unsigned numlower;
40 struct vfsmount **lower_mnt;
41 struct dentry *workdir;
42 long lower_namelen;
43 /* pathnames of lower and upper dirs, for show_options */
44 struct ovl_config config;
45 };
46
47 struct ovl_dir_cache;
48
49 /* private information held for every overlayfs dentry */
50 struct ovl_entry {
51 struct dentry *__upperdentry;
52 struct ovl_dir_cache *cache;
53 union {
54 struct {
55 u64 version;
56 bool opaque;
57 };
58 struct rcu_head rcu;
59 };
60 unsigned numlower;
61 struct path lowerstack[];
62 };
63
64 #define OVL_MAX_STACK 500
65
66 static struct dentry *__ovl_dentry_lower(struct ovl_entry *oe)
67 {
68 return oe->numlower ? oe->lowerstack[0].dentry : NULL;
69 }
70
71 enum ovl_path_type ovl_path_type(struct dentry *dentry)
72 {
73 struct ovl_entry *oe = dentry->d_fsdata;
74 enum ovl_path_type type = 0;
75
76 if (oe->__upperdentry) {
77 type = __OVL_PATH_UPPER;
78
79 /*
80 * Non-dir dentry can hold lower dentry from previous
81 * location. Its purity depends only on opaque flag.
82 */
83 if (oe->numlower && S_ISDIR(dentry->d_inode->i_mode))
84 type |= __OVL_PATH_MERGE;
85 else if (!oe->opaque)
86 type |= __OVL_PATH_PURE;
87 } else {
88 if (oe->numlower > 1)
89 type |= __OVL_PATH_MERGE;
90 }
91 return type;
92 }
93
94 static struct dentry *ovl_upperdentry_dereference(struct ovl_entry *oe)
95 {
96 return lockless_dereference(oe->__upperdentry);
97 }
98
99 void ovl_path_upper(struct dentry *dentry, struct path *path)
100 {
101 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
102 struct ovl_entry *oe = dentry->d_fsdata;
103
104 path->mnt = ofs->upper_mnt;
105 path->dentry = ovl_upperdentry_dereference(oe);
106 }
107
108 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
109 {
110 enum ovl_path_type type = ovl_path_type(dentry);
111
112 if (!OVL_TYPE_UPPER(type))
113 ovl_path_lower(dentry, path);
114 else
115 ovl_path_upper(dentry, path);
116
117 return type;
118 }
119
120 struct dentry *ovl_dentry_upper(struct dentry *dentry)
121 {
122 struct ovl_entry *oe = dentry->d_fsdata;
123
124 return ovl_upperdentry_dereference(oe);
125 }
126
127 struct dentry *ovl_dentry_lower(struct dentry *dentry)
128 {
129 struct ovl_entry *oe = dentry->d_fsdata;
130
131 return __ovl_dentry_lower(oe);
132 }
133
134 struct dentry *ovl_dentry_real(struct dentry *dentry)
135 {
136 struct ovl_entry *oe = dentry->d_fsdata;
137 struct dentry *realdentry;
138
139 realdentry = ovl_upperdentry_dereference(oe);
140 if (!realdentry)
141 realdentry = __ovl_dentry_lower(oe);
142
143 return realdentry;
144 }
145
146 struct dentry *ovl_entry_real(struct ovl_entry *oe, bool *is_upper)
147 {
148 struct dentry *realdentry;
149
150 realdentry = ovl_upperdentry_dereference(oe);
151 if (realdentry) {
152 *is_upper = true;
153 } else {
154 realdentry = __ovl_dentry_lower(oe);
155 *is_upper = false;
156 }
157 return realdentry;
158 }
159
160 struct vfsmount *ovl_entry_mnt_real(struct ovl_entry *oe, struct inode *inode,
161 bool is_upper)
162 {
163 if (is_upper) {
164 struct ovl_fs *ofs = inode->i_sb->s_fs_info;
165
166 return ofs->upper_mnt;
167 } else {
168 return oe->numlower ? oe->lowerstack[0].mnt : NULL;
169 }
170 }
171
172 struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
173 {
174 struct ovl_entry *oe = dentry->d_fsdata;
175
176 return oe->cache;
177 }
178
179 bool ovl_is_default_permissions(struct inode *inode)
180 {
181 struct ovl_fs *ofs = inode->i_sb->s_fs_info;
182
183 return ofs->config.default_permissions;
184 }
185
186 void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
187 {
188 struct ovl_entry *oe = dentry->d_fsdata;
189
190 oe->cache = cache;
191 }
192
193 void ovl_path_lower(struct dentry *dentry, struct path *path)
194 {
195 struct ovl_entry *oe = dentry->d_fsdata;
196
197 *path = oe->numlower ? oe->lowerstack[0] : (struct path) { NULL, NULL };
198 }
199
200 int ovl_want_write(struct dentry *dentry)
201 {
202 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
203 return mnt_want_write(ofs->upper_mnt);
204 }
205
206 void ovl_drop_write(struct dentry *dentry)
207 {
208 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
209 mnt_drop_write(ofs->upper_mnt);
210 }
211
212 struct dentry *ovl_workdir(struct dentry *dentry)
213 {
214 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
215 return ofs->workdir;
216 }
217
218 bool ovl_dentry_is_opaque(struct dentry *dentry)
219 {
220 struct ovl_entry *oe = dentry->d_fsdata;
221 return oe->opaque;
222 }
223
224 void ovl_dentry_set_opaque(struct dentry *dentry, bool opaque)
225 {
226 struct ovl_entry *oe = dentry->d_fsdata;
227 oe->opaque = opaque;
228 }
229
230 void ovl_dentry_update(struct dentry *dentry, struct dentry *upperdentry)
231 {
232 struct ovl_entry *oe = dentry->d_fsdata;
233
234 WARN_ON(!inode_is_locked(upperdentry->d_parent->d_inode));
235 WARN_ON(oe->__upperdentry);
236 BUG_ON(!upperdentry->d_inode);
237 /*
238 * Make sure upperdentry is consistent before making it visible to
239 * ovl_upperdentry_dereference().
240 */
241 smp_wmb();
242 oe->__upperdentry = upperdentry;
243 }
244
245 void ovl_dentry_version_inc(struct dentry *dentry)
246 {
247 struct ovl_entry *oe = dentry->d_fsdata;
248
249 WARN_ON(!inode_is_locked(dentry->d_inode));
250 oe->version++;
251 }
252
253 u64 ovl_dentry_version_get(struct dentry *dentry)
254 {
255 struct ovl_entry *oe = dentry->d_fsdata;
256
257 WARN_ON(!inode_is_locked(dentry->d_inode));
258 return oe->version;
259 }
260
261 bool ovl_is_whiteout(struct dentry *dentry)
262 {
263 struct inode *inode = dentry->d_inode;
264
265 return inode && IS_WHITEOUT(inode);
266 }
267
268 static bool ovl_is_opaquedir(struct dentry *dentry)
269 {
270 int res;
271 char val;
272 struct inode *inode = dentry->d_inode;
273
274 if (!S_ISDIR(inode->i_mode) || !inode->i_op->getxattr)
275 return false;
276
277 res = inode->i_op->getxattr(dentry, OVL_XATTR_OPAQUE, &val, 1);
278 if (res == 1 && val == 'y')
279 return true;
280
281 return false;
282 }
283
284 static void ovl_dentry_release(struct dentry *dentry)
285 {
286 struct ovl_entry *oe = dentry->d_fsdata;
287
288 if (oe) {
289 unsigned int i;
290
291 dput(oe->__upperdentry);
292 for (i = 0; i < oe->numlower; i++)
293 dput(oe->lowerstack[i].dentry);
294 kfree_rcu(oe, rcu);
295 }
296 }
297
298 static struct dentry *ovl_d_real(struct dentry *dentry, struct inode *inode)
299 {
300 struct dentry *real;
301
302 if (d_is_dir(dentry)) {
303 if (!inode || inode == d_inode(dentry))
304 return dentry;
305 goto bug;
306 }
307
308 real = ovl_dentry_upper(dentry);
309 if (real && (!inode || inode == d_inode(real)))
310 return real;
311
312 real = ovl_dentry_lower(dentry);
313 if (!real)
314 goto bug;
315
316 if (!inode || inode == d_inode(real))
317 return real;
318
319 /* Handle recursion */
320 if (real->d_flags & DCACHE_OP_REAL)
321 return real->d_op->d_real(real, inode);
322
323 bug:
324 WARN(1, "ovl_d_real(%pd4, %s:%lu\n): real dentry not found\n", dentry,
325 inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0);
326 return dentry;
327 }
328
329 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags)
330 {
331 struct ovl_entry *oe = dentry->d_fsdata;
332 unsigned int i;
333 int ret = 1;
334
335 for (i = 0; i < oe->numlower; i++) {
336 struct dentry *d = oe->lowerstack[i].dentry;
337
338 if (d->d_flags & DCACHE_OP_REVALIDATE) {
339 ret = d->d_op->d_revalidate(d, flags);
340 if (ret < 0)
341 return ret;
342 if (!ret) {
343 if (!(flags & LOOKUP_RCU))
344 d_invalidate(d);
345 return -ESTALE;
346 }
347 }
348 }
349 return 1;
350 }
351
352 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags)
353 {
354 struct ovl_entry *oe = dentry->d_fsdata;
355 unsigned int i;
356 int ret = 1;
357
358 for (i = 0; i < oe->numlower; i++) {
359 struct dentry *d = oe->lowerstack[i].dentry;
360
361 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) {
362 ret = d->d_op->d_weak_revalidate(d, flags);
363 if (ret <= 0)
364 break;
365 }
366 }
367 return ret;
368 }
369
370 static const struct dentry_operations ovl_dentry_operations = {
371 .d_release = ovl_dentry_release,
372 .d_select_inode = ovl_d_select_inode,
373 .d_real = ovl_d_real,
374 };
375
376 static const struct dentry_operations ovl_reval_dentry_operations = {
377 .d_release = ovl_dentry_release,
378 .d_select_inode = ovl_d_select_inode,
379 .d_real = ovl_d_real,
380 .d_revalidate = ovl_dentry_revalidate,
381 .d_weak_revalidate = ovl_dentry_weak_revalidate,
382 };
383
384 static struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
385 {
386 size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
387 struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
388
389 if (oe)
390 oe->numlower = numlower;
391
392 return oe;
393 }
394
395 static bool ovl_dentry_remote(struct dentry *dentry)
396 {
397 return dentry->d_flags &
398 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
399 }
400
401 static bool ovl_dentry_weird(struct dentry *dentry)
402 {
403 return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
404 DCACHE_MANAGE_TRANSIT |
405 DCACHE_OP_HASH |
406 DCACHE_OP_COMPARE);
407 }
408
409 static inline struct dentry *ovl_lookup_real(struct dentry *dir,
410 struct qstr *name)
411 {
412 struct dentry *dentry;
413
414 inode_lock(dir->d_inode);
415 dentry = lookup_one_len(name->name, dir, name->len);
416 inode_unlock(dir->d_inode);
417
418 if (IS_ERR(dentry)) {
419 if (PTR_ERR(dentry) == -ENOENT)
420 dentry = NULL;
421 } else if (!dentry->d_inode) {
422 dput(dentry);
423 dentry = NULL;
424 } else if (ovl_dentry_weird(dentry)) {
425 dput(dentry);
426 /* Don't support traversing automounts and other weirdness */
427 dentry = ERR_PTR(-EREMOTE);
428 }
429 return dentry;
430 }
431
432 /*
433 * Returns next layer in stack starting from top.
434 * Returns -1 if this is the last layer.
435 */
436 int ovl_path_next(int idx, struct dentry *dentry, struct path *path)
437 {
438 struct ovl_entry *oe = dentry->d_fsdata;
439
440 BUG_ON(idx < 0);
441 if (idx == 0) {
442 ovl_path_upper(dentry, path);
443 if (path->dentry)
444 return oe->numlower ? 1 : -1;
445 idx++;
446 }
447 BUG_ON(idx > oe->numlower);
448 *path = oe->lowerstack[idx - 1];
449
450 return (idx < oe->numlower) ? idx + 1 : -1;
451 }
452
453 struct dentry *ovl_lookup(struct inode *dir, struct dentry *dentry,
454 unsigned int flags)
455 {
456 struct ovl_entry *oe;
457 struct ovl_entry *poe = dentry->d_parent->d_fsdata;
458 struct path *stack = NULL;
459 struct dentry *upperdir, *upperdentry = NULL;
460 unsigned int ctr = 0;
461 struct inode *inode = NULL;
462 bool upperopaque = false;
463 struct dentry *this, *prev = NULL;
464 unsigned int i;
465 int err;
466
467 upperdir = ovl_upperdentry_dereference(poe);
468 if (upperdir) {
469 this = ovl_lookup_real(upperdir, &dentry->d_name);
470 err = PTR_ERR(this);
471 if (IS_ERR(this))
472 goto out;
473
474 if (this) {
475 if (unlikely(ovl_dentry_remote(this))) {
476 dput(this);
477 err = -EREMOTE;
478 goto out;
479 }
480 if (ovl_is_whiteout(this)) {
481 dput(this);
482 this = NULL;
483 upperopaque = true;
484 } else if (poe->numlower && ovl_is_opaquedir(this)) {
485 upperopaque = true;
486 }
487 }
488 upperdentry = prev = this;
489 }
490
491 if (!upperopaque && poe->numlower) {
492 err = -ENOMEM;
493 stack = kcalloc(poe->numlower, sizeof(struct path), GFP_KERNEL);
494 if (!stack)
495 goto out_put_upper;
496 }
497
498 for (i = 0; !upperopaque && i < poe->numlower; i++) {
499 bool opaque = false;
500 struct path lowerpath = poe->lowerstack[i];
501
502 this = ovl_lookup_real(lowerpath.dentry, &dentry->d_name);
503 err = PTR_ERR(this);
504 if (IS_ERR(this)) {
505 /*
506 * If it's positive, then treat ENAMETOOLONG as ENOENT.
507 */
508 if (err == -ENAMETOOLONG && (upperdentry || ctr))
509 continue;
510 goto out_put;
511 }
512 if (!this)
513 continue;
514 if (ovl_is_whiteout(this)) {
515 dput(this);
516 break;
517 }
518 /*
519 * Only makes sense to check opaque dir if this is not the
520 * lowermost layer.
521 */
522 if (i < poe->numlower - 1 && ovl_is_opaquedir(this))
523 opaque = true;
524
525 if (prev && (!S_ISDIR(prev->d_inode->i_mode) ||
526 !S_ISDIR(this->d_inode->i_mode))) {
527 /*
528 * FIXME: check for upper-opaqueness maybe better done
529 * in remove code.
530 */
531 if (prev == upperdentry)
532 upperopaque = true;
533 dput(this);
534 break;
535 }
536 /*
537 * If this is a non-directory then stop here.
538 */
539 if (!S_ISDIR(this->d_inode->i_mode))
540 opaque = true;
541
542 stack[ctr].dentry = this;
543 stack[ctr].mnt = lowerpath.mnt;
544 ctr++;
545 prev = this;
546 if (opaque)
547 break;
548 }
549
550 oe = ovl_alloc_entry(ctr);
551 err = -ENOMEM;
552 if (!oe)
553 goto out_put;
554
555 if (upperdentry || ctr) {
556 struct dentry *realdentry;
557
558 realdentry = upperdentry ? upperdentry : stack[0].dentry;
559
560 err = -ENOMEM;
561 inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode,
562 oe);
563 if (!inode)
564 goto out_free_oe;
565 ovl_copyattr(realdentry->d_inode, inode);
566 }
567
568 oe->opaque = upperopaque;
569 oe->__upperdentry = upperdentry;
570 memcpy(oe->lowerstack, stack, sizeof(struct path) * ctr);
571 kfree(stack);
572 dentry->d_fsdata = oe;
573 d_add(dentry, inode);
574
575 return NULL;
576
577 out_free_oe:
578 kfree(oe);
579 out_put:
580 for (i = 0; i < ctr; i++)
581 dput(stack[i].dentry);
582 kfree(stack);
583 out_put_upper:
584 dput(upperdentry);
585 out:
586 return ERR_PTR(err);
587 }
588
589 struct file *ovl_path_open(struct path *path, int flags)
590 {
591 return dentry_open(path, flags, current_cred());
592 }
593
594 static void ovl_put_super(struct super_block *sb)
595 {
596 struct ovl_fs *ufs = sb->s_fs_info;
597 unsigned i;
598
599 dput(ufs->workdir);
600 mntput(ufs->upper_mnt);
601 for (i = 0; i < ufs->numlower; i++)
602 mntput(ufs->lower_mnt[i]);
603 kfree(ufs->lower_mnt);
604
605 kfree(ufs->config.lowerdir);
606 kfree(ufs->config.upperdir);
607 kfree(ufs->config.workdir);
608 kfree(ufs);
609 }
610
611 /**
612 * ovl_statfs
613 * @sb: The overlayfs super block
614 * @buf: The struct kstatfs to fill in with stats
615 *
616 * Get the filesystem statistics. As writes always target the upper layer
617 * filesystem pass the statfs to the upper filesystem (if it exists)
618 */
619 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
620 {
621 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
622 struct dentry *root_dentry = dentry->d_sb->s_root;
623 struct path path;
624 int err;
625
626 ovl_path_real(root_dentry, &path);
627
628 err = vfs_statfs(&path, buf);
629 if (!err) {
630 buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen);
631 buf->f_type = OVERLAYFS_SUPER_MAGIC;
632 }
633
634 return err;
635 }
636
637 /**
638 * ovl_show_options
639 *
640 * Prints the mount options for a given superblock.
641 * Returns zero; does not fail.
642 */
643 static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
644 {
645 struct super_block *sb = dentry->d_sb;
646 struct ovl_fs *ufs = sb->s_fs_info;
647
648 seq_show_option(m, "lowerdir", ufs->config.lowerdir);
649 if (ufs->config.upperdir) {
650 seq_show_option(m, "upperdir", ufs->config.upperdir);
651 seq_show_option(m, "workdir", ufs->config.workdir);
652 }
653 if (ufs->config.default_permissions)
654 seq_puts(m, ",default_permissions");
655 return 0;
656 }
657
658 static int ovl_remount(struct super_block *sb, int *flags, char *data)
659 {
660 struct ovl_fs *ufs = sb->s_fs_info;
661
662 if (!(*flags & MS_RDONLY) && (!ufs->upper_mnt || !ufs->workdir))
663 return -EROFS;
664
665 return 0;
666 }
667
668 static const struct super_operations ovl_super_operations = {
669 .put_super = ovl_put_super,
670 .statfs = ovl_statfs,
671 .show_options = ovl_show_options,
672 .remount_fs = ovl_remount,
673 };
674
675 enum {
676 OPT_LOWERDIR,
677 OPT_UPPERDIR,
678 OPT_WORKDIR,
679 OPT_DEFAULT_PERMISSIONS,
680 OPT_ERR,
681 };
682
683 static const match_table_t ovl_tokens = {
684 {OPT_LOWERDIR, "lowerdir=%s"},
685 {OPT_UPPERDIR, "upperdir=%s"},
686 {OPT_WORKDIR, "workdir=%s"},
687 {OPT_DEFAULT_PERMISSIONS, "default_permissions"},
688 {OPT_ERR, NULL}
689 };
690
691 static char *ovl_next_opt(char **s)
692 {
693 char *sbegin = *s;
694 char *p;
695
696 if (sbegin == NULL)
697 return NULL;
698
699 for (p = sbegin; *p; p++) {
700 if (*p == '\\') {
701 p++;
702 if (!*p)
703 break;
704 } else if (*p == ',') {
705 *p = '\0';
706 *s = p + 1;
707 return sbegin;
708 }
709 }
710 *s = NULL;
711 return sbegin;
712 }
713
714 static int ovl_parse_opt(char *opt, struct ovl_config *config)
715 {
716 char *p;
717
718 while ((p = ovl_next_opt(&opt)) != NULL) {
719 int token;
720 substring_t args[MAX_OPT_ARGS];
721
722 if (!*p)
723 continue;
724
725 token = match_token(p, ovl_tokens, args);
726 switch (token) {
727 case OPT_UPPERDIR:
728 kfree(config->upperdir);
729 config->upperdir = match_strdup(&args[0]);
730 if (!config->upperdir)
731 return -ENOMEM;
732 break;
733
734 case OPT_LOWERDIR:
735 kfree(config->lowerdir);
736 config->lowerdir = match_strdup(&args[0]);
737 if (!config->lowerdir)
738 return -ENOMEM;
739 break;
740
741 case OPT_WORKDIR:
742 kfree(config->workdir);
743 config->workdir = match_strdup(&args[0]);
744 if (!config->workdir)
745 return -ENOMEM;
746 break;
747
748 case OPT_DEFAULT_PERMISSIONS:
749 config->default_permissions = true;
750 break;
751
752 default:
753 pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p);
754 return -EINVAL;
755 }
756 }
757
758 /* Workdir is useless in non-upper mount */
759 if (!config->upperdir && config->workdir) {
760 pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n",
761 config->workdir);
762 kfree(config->workdir);
763 config->workdir = NULL;
764 }
765
766 return 0;
767 }
768
769 #define OVL_WORKDIR_NAME "work"
770
771 static struct dentry *ovl_workdir_create(struct vfsmount *mnt,
772 struct dentry *dentry)
773 {
774 struct inode *dir = dentry->d_inode;
775 struct dentry *work;
776 int err;
777 bool retried = false;
778
779 err = mnt_want_write(mnt);
780 if (err)
781 return ERR_PTR(err);
782
783 inode_lock_nested(dir, I_MUTEX_PARENT);
784 retry:
785 work = lookup_one_len(OVL_WORKDIR_NAME, dentry,
786 strlen(OVL_WORKDIR_NAME));
787
788 if (!IS_ERR(work)) {
789 struct kstat stat = {
790 .mode = S_IFDIR | 0,
791 };
792
793 if (work->d_inode) {
794 err = -EEXIST;
795 if (retried)
796 goto out_dput;
797
798 retried = true;
799 ovl_cleanup(dir, work);
800 dput(work);
801 goto retry;
802 }
803
804 err = ovl_create_real(dir, work, &stat, NULL, NULL, true);
805 if (err)
806 goto out_dput;
807 }
808 out_unlock:
809 inode_unlock(dir);
810 mnt_drop_write(mnt);
811
812 return work;
813
814 out_dput:
815 dput(work);
816 work = ERR_PTR(err);
817 goto out_unlock;
818 }
819
820 static void ovl_unescape(char *s)
821 {
822 char *d = s;
823
824 for (;; s++, d++) {
825 if (*s == '\\')
826 s++;
827 *d = *s;
828 if (!*s)
829 break;
830 }
831 }
832
833 static int ovl_mount_dir_noesc(const char *name, struct path *path)
834 {
835 int err = -EINVAL;
836
837 if (!*name) {
838 pr_err("overlayfs: empty lowerdir\n");
839 goto out;
840 }
841 err = kern_path(name, LOOKUP_FOLLOW, path);
842 if (err) {
843 pr_err("overlayfs: failed to resolve '%s': %i\n", name, err);
844 goto out;
845 }
846 err = -EINVAL;
847 if (ovl_dentry_weird(path->dentry)) {
848 pr_err("overlayfs: filesystem on '%s' not supported\n", name);
849 goto out_put;
850 }
851 if (!S_ISDIR(path->dentry->d_inode->i_mode)) {
852 pr_err("overlayfs: '%s' not a directory\n", name);
853 goto out_put;
854 }
855 return 0;
856
857 out_put:
858 path_put(path);
859 out:
860 return err;
861 }
862
863 static int ovl_mount_dir(const char *name, struct path *path)
864 {
865 int err = -ENOMEM;
866 char *tmp = kstrdup(name, GFP_KERNEL);
867
868 if (tmp) {
869 ovl_unescape(tmp);
870 err = ovl_mount_dir_noesc(tmp, path);
871
872 if (!err)
873 if (ovl_dentry_remote(path->dentry)) {
874 pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n",
875 tmp);
876 path_put(path);
877 err = -EINVAL;
878 }
879 kfree(tmp);
880 }
881 return err;
882 }
883
884 static int ovl_lower_dir(const char *name, struct path *path, long *namelen,
885 int *stack_depth, bool *remote)
886 {
887 int err;
888 struct kstatfs statfs;
889
890 err = ovl_mount_dir_noesc(name, path);
891 if (err)
892 goto out;
893
894 err = vfs_statfs(path, &statfs);
895 if (err) {
896 pr_err("overlayfs: statfs failed on '%s'\n", name);
897 goto out_put;
898 }
899 *namelen = max(*namelen, statfs.f_namelen);
900 *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth);
901
902 if (ovl_dentry_remote(path->dentry))
903 *remote = true;
904
905 return 0;
906
907 out_put:
908 path_put(path);
909 out:
910 return err;
911 }
912
913 /* Workdir should not be subdir of upperdir and vice versa */
914 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
915 {
916 bool ok = false;
917
918 if (workdir != upperdir) {
919 ok = (lock_rename(workdir, upperdir) == NULL);
920 unlock_rename(workdir, upperdir);
921 }
922 return ok;
923 }
924
925 static unsigned int ovl_split_lowerdirs(char *str)
926 {
927 unsigned int ctr = 1;
928 char *s, *d;
929
930 for (s = d = str;; s++, d++) {
931 if (*s == '\\') {
932 s++;
933 } else if (*s == ':') {
934 *d = '\0';
935 ctr++;
936 continue;
937 }
938 *d = *s;
939 if (!*s)
940 break;
941 }
942 return ctr;
943 }
944
945 static int ovl_fill_super(struct super_block *sb, void *data, int silent)
946 {
947 struct path upperpath = { NULL, NULL };
948 struct path workpath = { NULL, NULL };
949 struct dentry *root_dentry;
950 struct ovl_entry *oe;
951 struct ovl_fs *ufs;
952 struct path *stack = NULL;
953 char *lowertmp;
954 char *lower;
955 unsigned int numlower;
956 unsigned int stacklen = 0;
957 unsigned int i;
958 bool remote = false;
959 int err;
960
961 err = -ENOMEM;
962 ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
963 if (!ufs)
964 goto out;
965
966 err = ovl_parse_opt((char *) data, &ufs->config);
967 if (err)
968 goto out_free_config;
969
970 err = -EINVAL;
971 if (!ufs->config.lowerdir) {
972 if (!silent)
973 pr_err("overlayfs: missing 'lowerdir'\n");
974 goto out_free_config;
975 }
976
977 sb->s_stack_depth = 0;
978 sb->s_maxbytes = MAX_LFS_FILESIZE;
979 if (ufs->config.upperdir) {
980 if (!ufs->config.workdir) {
981 pr_err("overlayfs: missing 'workdir'\n");
982 goto out_free_config;
983 }
984
985 err = ovl_mount_dir(ufs->config.upperdir, &upperpath);
986 if (err)
987 goto out_free_config;
988
989 /* Upper fs should not be r/o */
990 if (upperpath.mnt->mnt_sb->s_flags & MS_RDONLY) {
991 pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n");
992 err = -EINVAL;
993 goto out_put_upperpath;
994 }
995
996 err = ovl_mount_dir(ufs->config.workdir, &workpath);
997 if (err)
998 goto out_put_upperpath;
999
1000 err = -EINVAL;
1001 if (upperpath.mnt != workpath.mnt) {
1002 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
1003 goto out_put_workpath;
1004 }
1005 if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) {
1006 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
1007 goto out_put_workpath;
1008 }
1009 sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth;
1010 }
1011 err = -ENOMEM;
1012 lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL);
1013 if (!lowertmp)
1014 goto out_put_workpath;
1015
1016 err = -EINVAL;
1017 stacklen = ovl_split_lowerdirs(lowertmp);
1018 if (stacklen > OVL_MAX_STACK) {
1019 pr_err("overlayfs: too many lower directries, limit is %d\n",
1020 OVL_MAX_STACK);
1021 goto out_free_lowertmp;
1022 } else if (!ufs->config.upperdir && stacklen == 1) {
1023 pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n");
1024 goto out_free_lowertmp;
1025 }
1026
1027 stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL);
1028 if (!stack)
1029 goto out_free_lowertmp;
1030
1031 lower = lowertmp;
1032 for (numlower = 0; numlower < stacklen; numlower++) {
1033 err = ovl_lower_dir(lower, &stack[numlower],
1034 &ufs->lower_namelen, &sb->s_stack_depth,
1035 &remote);
1036 if (err)
1037 goto out_put_lowerpath;
1038
1039 lower = strchr(lower, '\0') + 1;
1040 }
1041
1042 err = -EINVAL;
1043 sb->s_stack_depth++;
1044 if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
1045 pr_err("overlayfs: maximum fs stacking depth exceeded\n");
1046 goto out_put_lowerpath;
1047 }
1048
1049 if (ufs->config.upperdir) {
1050 ufs->upper_mnt = clone_private_mount(&upperpath);
1051 err = PTR_ERR(ufs->upper_mnt);
1052 if (IS_ERR(ufs->upper_mnt)) {
1053 pr_err("overlayfs: failed to clone upperpath\n");
1054 goto out_put_lowerpath;
1055 }
1056
1057 ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry);
1058 err = PTR_ERR(ufs->workdir);
1059 if (IS_ERR(ufs->workdir)) {
1060 pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n",
1061 ufs->config.workdir, OVL_WORKDIR_NAME, -err);
1062 sb->s_flags |= MS_RDONLY;
1063 ufs->workdir = NULL;
1064 }
1065
1066 /*
1067 * Upper should support d_type, else whiteouts are visible.
1068 * Given workdir and upper are on same fs, we can do
1069 * iterate_dir() on workdir.
1070 */
1071 err = ovl_check_d_type_supported(&workpath);
1072 if (err < 0)
1073 goto out_put_workdir;
1074
1075 if (!err) {
1076 pr_err("overlayfs: upper fs needs to support d_type.\n");
1077 err = -EINVAL;
1078 goto out_put_workdir;
1079 }
1080 }
1081
1082 err = -ENOMEM;
1083 ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL);
1084 if (ufs->lower_mnt == NULL)
1085 goto out_put_workdir;
1086 for (i = 0; i < numlower; i++) {
1087 struct vfsmount *mnt = clone_private_mount(&stack[i]);
1088
1089 err = PTR_ERR(mnt);
1090 if (IS_ERR(mnt)) {
1091 pr_err("overlayfs: failed to clone lowerpath\n");
1092 goto out_put_lower_mnt;
1093 }
1094 /*
1095 * Make lower_mnt R/O. That way fchmod/fchown on lower file
1096 * will fail instead of modifying lower fs.
1097 */
1098 mnt->mnt_flags |= MNT_READONLY;
1099
1100 ufs->lower_mnt[ufs->numlower] = mnt;
1101 ufs->numlower++;
1102 }
1103
1104 /* If the upper fs is nonexistent, we mark overlayfs r/o too */
1105 if (!ufs->upper_mnt)
1106 sb->s_flags |= MS_RDONLY;
1107
1108 if (remote)
1109 sb->s_d_op = &ovl_reval_dentry_operations;
1110 else
1111 sb->s_d_op = &ovl_dentry_operations;
1112
1113 err = -ENOMEM;
1114 oe = ovl_alloc_entry(numlower);
1115 if (!oe)
1116 goto out_put_lower_mnt;
1117
1118 root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, oe));
1119 if (!root_dentry)
1120 goto out_free_oe;
1121
1122 mntput(upperpath.mnt);
1123 for (i = 0; i < numlower; i++)
1124 mntput(stack[i].mnt);
1125 path_put(&workpath);
1126 kfree(lowertmp);
1127
1128 oe->__upperdentry = upperpath.dentry;
1129 for (i = 0; i < numlower; i++) {
1130 oe->lowerstack[i].dentry = stack[i].dentry;
1131 oe->lowerstack[i].mnt = ufs->lower_mnt[i];
1132 }
1133 kfree(stack);
1134
1135 root_dentry->d_fsdata = oe;
1136
1137 ovl_copyattr(ovl_dentry_real(root_dentry)->d_inode,
1138 root_dentry->d_inode);
1139
1140 sb->s_magic = OVERLAYFS_SUPER_MAGIC;
1141 sb->s_op = &ovl_super_operations;
1142 sb->s_root = root_dentry;
1143 sb->s_fs_info = ufs;
1144
1145 return 0;
1146
1147 out_free_oe:
1148 kfree(oe);
1149 out_put_lower_mnt:
1150 for (i = 0; i < ufs->numlower; i++)
1151 mntput(ufs->lower_mnt[i]);
1152 kfree(ufs->lower_mnt);
1153 out_put_workdir:
1154 dput(ufs->workdir);
1155 mntput(ufs->upper_mnt);
1156 out_put_lowerpath:
1157 for (i = 0; i < numlower; i++)
1158 path_put(&stack[i]);
1159 kfree(stack);
1160 out_free_lowertmp:
1161 kfree(lowertmp);
1162 out_put_workpath:
1163 path_put(&workpath);
1164 out_put_upperpath:
1165 path_put(&upperpath);
1166 out_free_config:
1167 kfree(ufs->config.lowerdir);
1168 kfree(ufs->config.upperdir);
1169 kfree(ufs->config.workdir);
1170 kfree(ufs);
1171 out:
1172 return err;
1173 }
1174
1175 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
1176 const char *dev_name, void *raw_data)
1177 {
1178 return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
1179 }
1180
1181 static struct file_system_type ovl_fs_type = {
1182 .owner = THIS_MODULE,
1183 .name = "overlay",
1184 .mount = ovl_mount,
1185 .kill_sb = kill_anon_super,
1186 };
1187 MODULE_ALIAS_FS("overlay");
1188
1189 static int __init ovl_init(void)
1190 {
1191 return register_filesystem(&ovl_fs_type);
1192 }
1193
1194 static void __exit ovl_exit(void)
1195 {
1196 unregister_filesystem(&ovl_fs_type);
1197 }
1198
1199 module_init(ovl_init);
1200 module_exit(ovl_exit);