Merge tag 'rproc-v4.16' of git://github.com/andersson/remoteproc
[sfrench/cifs-2.6.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 <uapi/linux/magic.h>
11 #include <linux/fs.h>
12 #include <linux/namei.h>
13 #include <linux/xattr.h>
14 #include <linux/mount.h>
15 #include <linux/parser.h>
16 #include <linux/module.h>
17 #include <linux/statfs.h>
18 #include <linux/seq_file.h>
19 #include <linux/posix_acl_xattr.h>
20 #include "overlayfs.h"
21
22 MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
23 MODULE_DESCRIPTION("Overlay filesystem");
24 MODULE_LICENSE("GPL");
25
26
27 struct ovl_dir_cache;
28
29 #define OVL_MAX_STACK 500
30
31 static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR);
32 module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644);
33 MODULE_PARM_DESC(ovl_redirect_dir_def,
34                  "Default to on or off for the redirect_dir feature");
35
36 static bool ovl_redirect_always_follow =
37         IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_ALWAYS_FOLLOW);
38 module_param_named(redirect_always_follow, ovl_redirect_always_follow,
39                    bool, 0644);
40 MODULE_PARM_DESC(ovl_redirect_always_follow,
41                  "Follow redirects even if redirect_dir feature is turned off");
42
43 static bool ovl_index_def = IS_ENABLED(CONFIG_OVERLAY_FS_INDEX);
44 module_param_named(index, ovl_index_def, bool, 0644);
45 MODULE_PARM_DESC(ovl_index_def,
46                  "Default to on or off for the inodes index feature");
47
48 static void ovl_entry_stack_free(struct ovl_entry *oe)
49 {
50         unsigned int i;
51
52         for (i = 0; i < oe->numlower; i++)
53                 dput(oe->lowerstack[i].dentry);
54 }
55
56 static void ovl_dentry_release(struct dentry *dentry)
57 {
58         struct ovl_entry *oe = dentry->d_fsdata;
59
60         if (oe) {
61                 ovl_entry_stack_free(oe);
62                 kfree_rcu(oe, rcu);
63         }
64 }
65
66 static int ovl_check_append_only(struct inode *inode, int flag)
67 {
68         /*
69          * This test was moot in vfs may_open() because overlay inode does
70          * not have the S_APPEND flag, so re-check on real upper inode
71          */
72         if (IS_APPEND(inode)) {
73                 if  ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND))
74                         return -EPERM;
75                 if (flag & O_TRUNC)
76                         return -EPERM;
77         }
78
79         return 0;
80 }
81
82 static struct dentry *ovl_d_real(struct dentry *dentry,
83                                  const struct inode *inode,
84                                  unsigned int open_flags, unsigned int flags)
85 {
86         struct dentry *real;
87         int err;
88
89         if (flags & D_REAL_UPPER)
90                 return ovl_dentry_upper(dentry);
91
92         if (!d_is_reg(dentry)) {
93                 if (!inode || inode == d_inode(dentry))
94                         return dentry;
95                 goto bug;
96         }
97
98         if (open_flags) {
99                 err = ovl_open_maybe_copy_up(dentry, open_flags);
100                 if (err)
101                         return ERR_PTR(err);
102         }
103
104         real = ovl_dentry_upper(dentry);
105         if (real && (!inode || inode == d_inode(real))) {
106                 if (!inode) {
107                         err = ovl_check_append_only(d_inode(real), open_flags);
108                         if (err)
109                                 return ERR_PTR(err);
110                 }
111                 return real;
112         }
113
114         real = ovl_dentry_lower(dentry);
115         if (!real)
116                 goto bug;
117
118         /* Handle recursion */
119         real = d_real(real, inode, open_flags, 0);
120
121         if (!inode || inode == d_inode(real))
122                 return real;
123 bug:
124         WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry,
125              inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0);
126         return dentry;
127 }
128
129 static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags)
130 {
131         struct ovl_entry *oe = dentry->d_fsdata;
132         unsigned int i;
133         int ret = 1;
134
135         for (i = 0; i < oe->numlower; i++) {
136                 struct dentry *d = oe->lowerstack[i].dentry;
137
138                 if (d->d_flags & DCACHE_OP_REVALIDATE) {
139                         ret = d->d_op->d_revalidate(d, flags);
140                         if (ret < 0)
141                                 return ret;
142                         if (!ret) {
143                                 if (!(flags & LOOKUP_RCU))
144                                         d_invalidate(d);
145                                 return -ESTALE;
146                         }
147                 }
148         }
149         return 1;
150 }
151
152 static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags)
153 {
154         struct ovl_entry *oe = dentry->d_fsdata;
155         unsigned int i;
156         int ret = 1;
157
158         for (i = 0; i < oe->numlower; i++) {
159                 struct dentry *d = oe->lowerstack[i].dentry;
160
161                 if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) {
162                         ret = d->d_op->d_weak_revalidate(d, flags);
163                         if (ret <= 0)
164                                 break;
165                 }
166         }
167         return ret;
168 }
169
170 static const struct dentry_operations ovl_dentry_operations = {
171         .d_release = ovl_dentry_release,
172         .d_real = ovl_d_real,
173 };
174
175 static const struct dentry_operations ovl_reval_dentry_operations = {
176         .d_release = ovl_dentry_release,
177         .d_real = ovl_d_real,
178         .d_revalidate = ovl_dentry_revalidate,
179         .d_weak_revalidate = ovl_dentry_weak_revalidate,
180 };
181
182 static struct kmem_cache *ovl_inode_cachep;
183
184 static struct inode *ovl_alloc_inode(struct super_block *sb)
185 {
186         struct ovl_inode *oi = kmem_cache_alloc(ovl_inode_cachep, GFP_KERNEL);
187
188         if (!oi)
189                 return NULL;
190
191         oi->cache = NULL;
192         oi->redirect = NULL;
193         oi->version = 0;
194         oi->flags = 0;
195         oi->__upperdentry = NULL;
196         oi->lower = NULL;
197         mutex_init(&oi->lock);
198
199         return &oi->vfs_inode;
200 }
201
202 static void ovl_i_callback(struct rcu_head *head)
203 {
204         struct inode *inode = container_of(head, struct inode, i_rcu);
205
206         kmem_cache_free(ovl_inode_cachep, OVL_I(inode));
207 }
208
209 static void ovl_destroy_inode(struct inode *inode)
210 {
211         struct ovl_inode *oi = OVL_I(inode);
212
213         dput(oi->__upperdentry);
214         kfree(oi->redirect);
215         ovl_dir_cache_free(inode);
216         mutex_destroy(&oi->lock);
217
218         call_rcu(&inode->i_rcu, ovl_i_callback);
219 }
220
221 static void ovl_free_fs(struct ovl_fs *ofs)
222 {
223         unsigned i;
224
225         dput(ofs->indexdir);
226         dput(ofs->workdir);
227         if (ofs->workdir_locked)
228                 ovl_inuse_unlock(ofs->workbasedir);
229         dput(ofs->workbasedir);
230         if (ofs->upperdir_locked)
231                 ovl_inuse_unlock(ofs->upper_mnt->mnt_root);
232         mntput(ofs->upper_mnt);
233         for (i = 0; i < ofs->numlower; i++) {
234                 mntput(ofs->lower_layers[i].mnt);
235                 free_anon_bdev(ofs->lower_layers[i].pseudo_dev);
236         }
237         kfree(ofs->lower_layers);
238
239         kfree(ofs->config.lowerdir);
240         kfree(ofs->config.upperdir);
241         kfree(ofs->config.workdir);
242         kfree(ofs->config.redirect_mode);
243         if (ofs->creator_cred)
244                 put_cred(ofs->creator_cred);
245         kfree(ofs);
246 }
247
248 static void ovl_put_super(struct super_block *sb)
249 {
250         struct ovl_fs *ofs = sb->s_fs_info;
251
252         ovl_free_fs(ofs);
253 }
254
255 /* Sync real dirty inodes in upper filesystem (if it exists) */
256 static int ovl_sync_fs(struct super_block *sb, int wait)
257 {
258         struct ovl_fs *ofs = sb->s_fs_info;
259         struct super_block *upper_sb;
260         int ret;
261
262         if (!ofs->upper_mnt)
263                 return 0;
264
265         /*
266          * If this is a sync(2) call or an emergency sync, all the super blocks
267          * will be iterated, including upper_sb, so no need to do anything.
268          *
269          * If this is a syncfs(2) call, then we do need to call
270          * sync_filesystem() on upper_sb, but enough if we do it when being
271          * called with wait == 1.
272          */
273         if (!wait)
274                 return 0;
275
276         upper_sb = ofs->upper_mnt->mnt_sb;
277
278         down_read(&upper_sb->s_umount);
279         ret = sync_filesystem(upper_sb);
280         up_read(&upper_sb->s_umount);
281
282         return ret;
283 }
284
285 /**
286  * ovl_statfs
287  * @sb: The overlayfs super block
288  * @buf: The struct kstatfs to fill in with stats
289  *
290  * Get the filesystem statistics.  As writes always target the upper layer
291  * filesystem pass the statfs to the upper filesystem (if it exists)
292  */
293 static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
294 {
295         struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
296         struct dentry *root_dentry = dentry->d_sb->s_root;
297         struct path path;
298         int err;
299
300         ovl_path_real(root_dentry, &path);
301
302         err = vfs_statfs(&path, buf);
303         if (!err) {
304                 buf->f_namelen = ofs->namelen;
305                 buf->f_type = OVERLAYFS_SUPER_MAGIC;
306         }
307
308         return err;
309 }
310
311 /* Will this overlay be forced to mount/remount ro? */
312 static bool ovl_force_readonly(struct ovl_fs *ofs)
313 {
314         return (!ofs->upper_mnt || !ofs->workdir);
315 }
316
317 static const char *ovl_redirect_mode_def(void)
318 {
319         return ovl_redirect_dir_def ? "on" : "off";
320 }
321
322 /**
323  * ovl_show_options
324  *
325  * Prints the mount options for a given superblock.
326  * Returns zero; does not fail.
327  */
328 static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
329 {
330         struct super_block *sb = dentry->d_sb;
331         struct ovl_fs *ofs = sb->s_fs_info;
332
333         seq_show_option(m, "lowerdir", ofs->config.lowerdir);
334         if (ofs->config.upperdir) {
335                 seq_show_option(m, "upperdir", ofs->config.upperdir);
336                 seq_show_option(m, "workdir", ofs->config.workdir);
337         }
338         if (ofs->config.default_permissions)
339                 seq_puts(m, ",default_permissions");
340         if (strcmp(ofs->config.redirect_mode, ovl_redirect_mode_def()) != 0)
341                 seq_printf(m, ",redirect_dir=%s", ofs->config.redirect_mode);
342         if (ofs->config.index != ovl_index_def)
343                 seq_printf(m, ",index=%s", ofs->config.index ? "on" : "off");
344         return 0;
345 }
346
347 static int ovl_remount(struct super_block *sb, int *flags, char *data)
348 {
349         struct ovl_fs *ofs = sb->s_fs_info;
350
351         if (!(*flags & SB_RDONLY) && ovl_force_readonly(ofs))
352                 return -EROFS;
353
354         return 0;
355 }
356
357 static const struct super_operations ovl_super_operations = {
358         .alloc_inode    = ovl_alloc_inode,
359         .destroy_inode  = ovl_destroy_inode,
360         .drop_inode     = generic_delete_inode,
361         .put_super      = ovl_put_super,
362         .sync_fs        = ovl_sync_fs,
363         .statfs         = ovl_statfs,
364         .show_options   = ovl_show_options,
365         .remount_fs     = ovl_remount,
366 };
367
368 enum {
369         OPT_LOWERDIR,
370         OPT_UPPERDIR,
371         OPT_WORKDIR,
372         OPT_DEFAULT_PERMISSIONS,
373         OPT_REDIRECT_DIR,
374         OPT_INDEX_ON,
375         OPT_INDEX_OFF,
376         OPT_ERR,
377 };
378
379 static const match_table_t ovl_tokens = {
380         {OPT_LOWERDIR,                  "lowerdir=%s"},
381         {OPT_UPPERDIR,                  "upperdir=%s"},
382         {OPT_WORKDIR,                   "workdir=%s"},
383         {OPT_DEFAULT_PERMISSIONS,       "default_permissions"},
384         {OPT_REDIRECT_DIR,              "redirect_dir=%s"},
385         {OPT_INDEX_ON,                  "index=on"},
386         {OPT_INDEX_OFF,                 "index=off"},
387         {OPT_ERR,                       NULL}
388 };
389
390 static char *ovl_next_opt(char **s)
391 {
392         char *sbegin = *s;
393         char *p;
394
395         if (sbegin == NULL)
396                 return NULL;
397
398         for (p = sbegin; *p; p++) {
399                 if (*p == '\\') {
400                         p++;
401                         if (!*p)
402                                 break;
403                 } else if (*p == ',') {
404                         *p = '\0';
405                         *s = p + 1;
406                         return sbegin;
407                 }
408         }
409         *s = NULL;
410         return sbegin;
411 }
412
413 static int ovl_parse_redirect_mode(struct ovl_config *config, const char *mode)
414 {
415         if (strcmp(mode, "on") == 0) {
416                 config->redirect_dir = true;
417                 /*
418                  * Does not make sense to have redirect creation without
419                  * redirect following.
420                  */
421                 config->redirect_follow = true;
422         } else if (strcmp(mode, "follow") == 0) {
423                 config->redirect_follow = true;
424         } else if (strcmp(mode, "off") == 0) {
425                 if (ovl_redirect_always_follow)
426                         config->redirect_follow = true;
427         } else if (strcmp(mode, "nofollow") != 0) {
428                 pr_err("overlayfs: bad mount option \"redirect_dir=%s\"\n",
429                        mode);
430                 return -EINVAL;
431         }
432
433         return 0;
434 }
435
436 static int ovl_parse_opt(char *opt, struct ovl_config *config)
437 {
438         char *p;
439
440         config->redirect_mode = kstrdup(ovl_redirect_mode_def(), GFP_KERNEL);
441         if (!config->redirect_mode)
442                 return -ENOMEM;
443
444         while ((p = ovl_next_opt(&opt)) != NULL) {
445                 int token;
446                 substring_t args[MAX_OPT_ARGS];
447
448                 if (!*p)
449                         continue;
450
451                 token = match_token(p, ovl_tokens, args);
452                 switch (token) {
453                 case OPT_UPPERDIR:
454                         kfree(config->upperdir);
455                         config->upperdir = match_strdup(&args[0]);
456                         if (!config->upperdir)
457                                 return -ENOMEM;
458                         break;
459
460                 case OPT_LOWERDIR:
461                         kfree(config->lowerdir);
462                         config->lowerdir = match_strdup(&args[0]);
463                         if (!config->lowerdir)
464                                 return -ENOMEM;
465                         break;
466
467                 case OPT_WORKDIR:
468                         kfree(config->workdir);
469                         config->workdir = match_strdup(&args[0]);
470                         if (!config->workdir)
471                                 return -ENOMEM;
472                         break;
473
474                 case OPT_DEFAULT_PERMISSIONS:
475                         config->default_permissions = true;
476                         break;
477
478                 case OPT_REDIRECT_DIR:
479                         kfree(config->redirect_mode);
480                         config->redirect_mode = match_strdup(&args[0]);
481                         if (!config->redirect_mode)
482                                 return -ENOMEM;
483                         break;
484
485                 case OPT_INDEX_ON:
486                         config->index = true;
487                         break;
488
489                 case OPT_INDEX_OFF:
490                         config->index = false;
491                         break;
492
493                 default:
494                         pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p);
495                         return -EINVAL;
496                 }
497         }
498
499         /* Workdir is useless in non-upper mount */
500         if (!config->upperdir && config->workdir) {
501                 pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n",
502                         config->workdir);
503                 kfree(config->workdir);
504                 config->workdir = NULL;
505         }
506
507         return ovl_parse_redirect_mode(config, config->redirect_mode);
508 }
509
510 #define OVL_WORKDIR_NAME "work"
511 #define OVL_INDEXDIR_NAME "index"
512
513 static struct dentry *ovl_workdir_create(struct ovl_fs *ofs,
514                                          const char *name, bool persist)
515 {
516         struct inode *dir =  ofs->workbasedir->d_inode;
517         struct vfsmount *mnt = ofs->upper_mnt;
518         struct dentry *work;
519         int err;
520         bool retried = false;
521         bool locked = false;
522
523         err = mnt_want_write(mnt);
524         if (err)
525                 goto out_err;
526
527         inode_lock_nested(dir, I_MUTEX_PARENT);
528         locked = true;
529
530 retry:
531         work = lookup_one_len(name, ofs->workbasedir, strlen(name));
532
533         if (!IS_ERR(work)) {
534                 struct iattr attr = {
535                         .ia_valid = ATTR_MODE,
536                         .ia_mode = S_IFDIR | 0,
537                 };
538
539                 if (work->d_inode) {
540                         err = -EEXIST;
541                         if (retried)
542                                 goto out_dput;
543
544                         if (persist)
545                                 goto out_unlock;
546
547                         retried = true;
548                         ovl_workdir_cleanup(dir, mnt, work, 0);
549                         dput(work);
550                         goto retry;
551                 }
552
553                 err = ovl_create_real(dir, work,
554                                       &(struct cattr){.mode = S_IFDIR | 0},
555                                       NULL, true);
556                 if (err)
557                         goto out_dput;
558
559                 /*
560                  * Try to remove POSIX ACL xattrs from workdir.  We are good if:
561                  *
562                  * a) success (there was a POSIX ACL xattr and was removed)
563                  * b) -ENODATA (there was no POSIX ACL xattr)
564                  * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported)
565                  *
566                  * There are various other error values that could effectively
567                  * mean that the xattr doesn't exist (e.g. -ERANGE is returned
568                  * if the xattr name is too long), but the set of filesystems
569                  * allowed as upper are limited to "normal" ones, where checking
570                  * for the above two errors is sufficient.
571                  */
572                 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT);
573                 if (err && err != -ENODATA && err != -EOPNOTSUPP)
574                         goto out_dput;
575
576                 err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS);
577                 if (err && err != -ENODATA && err != -EOPNOTSUPP)
578                         goto out_dput;
579
580                 /* Clear any inherited mode bits */
581                 inode_lock(work->d_inode);
582                 err = notify_change(work, &attr, NULL);
583                 inode_unlock(work->d_inode);
584                 if (err)
585                         goto out_dput;
586         } else {
587                 err = PTR_ERR(work);
588                 goto out_err;
589         }
590 out_unlock:
591         mnt_drop_write(mnt);
592         if (locked)
593                 inode_unlock(dir);
594
595         return work;
596
597 out_dput:
598         dput(work);
599 out_err:
600         pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n",
601                 ofs->config.workdir, name, -err);
602         work = NULL;
603         goto out_unlock;
604 }
605
606 static void ovl_unescape(char *s)
607 {
608         char *d = s;
609
610         for (;; s++, d++) {
611                 if (*s == '\\')
612                         s++;
613                 *d = *s;
614                 if (!*s)
615                         break;
616         }
617 }
618
619 static int ovl_mount_dir_noesc(const char *name, struct path *path)
620 {
621         int err = -EINVAL;
622
623         if (!*name) {
624                 pr_err("overlayfs: empty lowerdir\n");
625                 goto out;
626         }
627         err = kern_path(name, LOOKUP_FOLLOW, path);
628         if (err) {
629                 pr_err("overlayfs: failed to resolve '%s': %i\n", name, err);
630                 goto out;
631         }
632         err = -EINVAL;
633         if (ovl_dentry_weird(path->dentry)) {
634                 pr_err("overlayfs: filesystem on '%s' not supported\n", name);
635                 goto out_put;
636         }
637         if (!d_is_dir(path->dentry)) {
638                 pr_err("overlayfs: '%s' not a directory\n", name);
639                 goto out_put;
640         }
641         return 0;
642
643 out_put:
644         path_put_init(path);
645 out:
646         return err;
647 }
648
649 static int ovl_mount_dir(const char *name, struct path *path)
650 {
651         int err = -ENOMEM;
652         char *tmp = kstrdup(name, GFP_KERNEL);
653
654         if (tmp) {
655                 ovl_unescape(tmp);
656                 err = ovl_mount_dir_noesc(tmp, path);
657
658                 if (!err)
659                         if (ovl_dentry_remote(path->dentry)) {
660                                 pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n",
661                                        tmp);
662                                 path_put_init(path);
663                                 err = -EINVAL;
664                         }
665                 kfree(tmp);
666         }
667         return err;
668 }
669
670 static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs,
671                              const char *name)
672 {
673         struct kstatfs statfs;
674         int err = vfs_statfs(path, &statfs);
675
676         if (err)
677                 pr_err("overlayfs: statfs failed on '%s'\n", name);
678         else
679                 ofs->namelen = max(ofs->namelen, statfs.f_namelen);
680
681         return err;
682 }
683
684 static int ovl_lower_dir(const char *name, struct path *path,
685                          struct ovl_fs *ofs, int *stack_depth, bool *remote)
686 {
687         int err;
688
689         err = ovl_mount_dir_noesc(name, path);
690         if (err)
691                 goto out;
692
693         err = ovl_check_namelen(path, ofs, name);
694         if (err)
695                 goto out_put;
696
697         *stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth);
698
699         if (ovl_dentry_remote(path->dentry))
700                 *remote = true;
701
702         /*
703          * The inodes index feature needs to encode and decode file
704          * handles, so it requires that all layers support them.
705          */
706         if (ofs->config.index && !ovl_can_decode_fh(path->dentry->d_sb)) {
707                 ofs->config.index = false;
708                 pr_warn("overlayfs: fs on '%s' does not support file handles, falling back to index=off.\n", name);
709         }
710
711         return 0;
712
713 out_put:
714         path_put_init(path);
715 out:
716         return err;
717 }
718
719 /* Workdir should not be subdir of upperdir and vice versa */
720 static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
721 {
722         bool ok = false;
723
724         if (workdir != upperdir) {
725                 ok = (lock_rename(workdir, upperdir) == NULL);
726                 unlock_rename(workdir, upperdir);
727         }
728         return ok;
729 }
730
731 static unsigned int ovl_split_lowerdirs(char *str)
732 {
733         unsigned int ctr = 1;
734         char *s, *d;
735
736         for (s = d = str;; s++, d++) {
737                 if (*s == '\\') {
738                         s++;
739                 } else if (*s == ':') {
740                         *d = '\0';
741                         ctr++;
742                         continue;
743                 }
744                 *d = *s;
745                 if (!*s)
746                         break;
747         }
748         return ctr;
749 }
750
751 static int __maybe_unused
752 ovl_posix_acl_xattr_get(const struct xattr_handler *handler,
753                         struct dentry *dentry, struct inode *inode,
754                         const char *name, void *buffer, size_t size)
755 {
756         return ovl_xattr_get(dentry, inode, handler->name, buffer, size);
757 }
758
759 static int __maybe_unused
760 ovl_posix_acl_xattr_set(const struct xattr_handler *handler,
761                         struct dentry *dentry, struct inode *inode,
762                         const char *name, const void *value,
763                         size_t size, int flags)
764 {
765         struct dentry *workdir = ovl_workdir(dentry);
766         struct inode *realinode = ovl_inode_real(inode);
767         struct posix_acl *acl = NULL;
768         int err;
769
770         /* Check that everything is OK before copy-up */
771         if (value) {
772                 acl = posix_acl_from_xattr(&init_user_ns, value, size);
773                 if (IS_ERR(acl))
774                         return PTR_ERR(acl);
775         }
776         err = -EOPNOTSUPP;
777         if (!IS_POSIXACL(d_inode(workdir)))
778                 goto out_acl_release;
779         if (!realinode->i_op->set_acl)
780                 goto out_acl_release;
781         if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) {
782                 err = acl ? -EACCES : 0;
783                 goto out_acl_release;
784         }
785         err = -EPERM;
786         if (!inode_owner_or_capable(inode))
787                 goto out_acl_release;
788
789         posix_acl_release(acl);
790
791         /*
792          * Check if sgid bit needs to be cleared (actual setacl operation will
793          * be done with mounter's capabilities and so that won't do it for us).
794          */
795         if (unlikely(inode->i_mode & S_ISGID) &&
796             handler->flags == ACL_TYPE_ACCESS &&
797             !in_group_p(inode->i_gid) &&
798             !capable_wrt_inode_uidgid(inode, CAP_FSETID)) {
799                 struct iattr iattr = { .ia_valid = ATTR_KILL_SGID };
800
801                 err = ovl_setattr(dentry, &iattr);
802                 if (err)
803                         return err;
804         }
805
806         err = ovl_xattr_set(dentry, inode, handler->name, value, size, flags);
807         if (!err)
808                 ovl_copyattr(ovl_inode_real(inode), inode);
809
810         return err;
811
812 out_acl_release:
813         posix_acl_release(acl);
814         return err;
815 }
816
817 static int ovl_own_xattr_get(const struct xattr_handler *handler,
818                              struct dentry *dentry, struct inode *inode,
819                              const char *name, void *buffer, size_t size)
820 {
821         return -EOPNOTSUPP;
822 }
823
824 static int ovl_own_xattr_set(const struct xattr_handler *handler,
825                              struct dentry *dentry, struct inode *inode,
826                              const char *name, const void *value,
827                              size_t size, int flags)
828 {
829         return -EOPNOTSUPP;
830 }
831
832 static int ovl_other_xattr_get(const struct xattr_handler *handler,
833                                struct dentry *dentry, struct inode *inode,
834                                const char *name, void *buffer, size_t size)
835 {
836         return ovl_xattr_get(dentry, inode, name, buffer, size);
837 }
838
839 static int ovl_other_xattr_set(const struct xattr_handler *handler,
840                                struct dentry *dentry, struct inode *inode,
841                                const char *name, const void *value,
842                                size_t size, int flags)
843 {
844         return ovl_xattr_set(dentry, inode, name, value, size, flags);
845 }
846
847 static const struct xattr_handler __maybe_unused
848 ovl_posix_acl_access_xattr_handler = {
849         .name = XATTR_NAME_POSIX_ACL_ACCESS,
850         .flags = ACL_TYPE_ACCESS,
851         .get = ovl_posix_acl_xattr_get,
852         .set = ovl_posix_acl_xattr_set,
853 };
854
855 static const struct xattr_handler __maybe_unused
856 ovl_posix_acl_default_xattr_handler = {
857         .name = XATTR_NAME_POSIX_ACL_DEFAULT,
858         .flags = ACL_TYPE_DEFAULT,
859         .get = ovl_posix_acl_xattr_get,
860         .set = ovl_posix_acl_xattr_set,
861 };
862
863 static const struct xattr_handler ovl_own_xattr_handler = {
864         .prefix = OVL_XATTR_PREFIX,
865         .get = ovl_own_xattr_get,
866         .set = ovl_own_xattr_set,
867 };
868
869 static const struct xattr_handler ovl_other_xattr_handler = {
870         .prefix = "", /* catch all */
871         .get = ovl_other_xattr_get,
872         .set = ovl_other_xattr_set,
873 };
874
875 static const struct xattr_handler *ovl_xattr_handlers[] = {
876 #ifdef CONFIG_FS_POSIX_ACL
877         &ovl_posix_acl_access_xattr_handler,
878         &ovl_posix_acl_default_xattr_handler,
879 #endif
880         &ovl_own_xattr_handler,
881         &ovl_other_xattr_handler,
882         NULL
883 };
884
885 static int ovl_get_upper(struct ovl_fs *ofs, struct path *upperpath)
886 {
887         struct vfsmount *upper_mnt;
888         int err;
889
890         err = ovl_mount_dir(ofs->config.upperdir, upperpath);
891         if (err)
892                 goto out;
893
894         /* Upper fs should not be r/o */
895         if (sb_rdonly(upperpath->mnt->mnt_sb)) {
896                 pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n");
897                 err = -EINVAL;
898                 goto out;
899         }
900
901         err = ovl_check_namelen(upperpath, ofs, ofs->config.upperdir);
902         if (err)
903                 goto out;
904
905         err = -EBUSY;
906         if (ovl_inuse_trylock(upperpath->dentry)) {
907                 ofs->upperdir_locked = true;
908         } else if (ofs->config.index) {
909                 pr_err("overlayfs: upperdir is in-use by another mount, mount with '-o index=off' to override exclusive upperdir protection.\n");
910                 goto out;
911         } else {
912                 pr_warn("overlayfs: upperdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
913         }
914
915         upper_mnt = clone_private_mount(upperpath);
916         err = PTR_ERR(upper_mnt);
917         if (IS_ERR(upper_mnt)) {
918                 pr_err("overlayfs: failed to clone upperpath\n");
919                 goto out;
920         }
921
922         /* Don't inherit atime flags */
923         upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);
924         ofs->upper_mnt = upper_mnt;
925         err = 0;
926 out:
927         return err;
928 }
929
930 static int ovl_make_workdir(struct ovl_fs *ofs, struct path *workpath)
931 {
932         struct dentry *temp;
933         int err;
934
935         ofs->workdir = ovl_workdir_create(ofs, OVL_WORKDIR_NAME, false);
936         if (!ofs->workdir)
937                 return 0;
938
939         /*
940          * Upper should support d_type, else whiteouts are visible.  Given
941          * workdir and upper are on same fs, we can do iterate_dir() on
942          * workdir. This check requires successful creation of workdir in
943          * previous step.
944          */
945         err = ovl_check_d_type_supported(workpath);
946         if (err < 0)
947                 return err;
948
949         /*
950          * We allowed this configuration and don't want to break users over
951          * kernel upgrade. So warn instead of erroring out.
952          */
953         if (!err)
954                 pr_warn("overlayfs: upper fs needs to support d_type.\n");
955
956         /* Check if upper/work fs supports O_TMPFILE */
957         temp = ovl_do_tmpfile(ofs->workdir, S_IFREG | 0);
958         ofs->tmpfile = !IS_ERR(temp);
959         if (ofs->tmpfile)
960                 dput(temp);
961         else
962                 pr_warn("overlayfs: upper fs does not support tmpfile.\n");
963
964         /*
965          * Check if upper/work fs supports trusted.overlay.* xattr
966          */
967         err = ovl_do_setxattr(ofs->workdir, OVL_XATTR_OPAQUE, "0", 1, 0);
968         if (err) {
969                 ofs->noxattr = true;
970                 pr_warn("overlayfs: upper fs does not support xattr.\n");
971         } else {
972                 vfs_removexattr(ofs->workdir, OVL_XATTR_OPAQUE);
973         }
974
975         /* Check if upper/work fs supports file handles */
976         if (ofs->config.index &&
977             !ovl_can_decode_fh(ofs->workdir->d_sb)) {
978                 ofs->config.index = false;
979                 pr_warn("overlayfs: upper fs does not support file handles, falling back to index=off.\n");
980         }
981
982         return 0;
983 }
984
985 static int ovl_get_workdir(struct ovl_fs *ofs, struct path *upperpath)
986 {
987         int err;
988         struct path workpath = { };
989
990         err = ovl_mount_dir(ofs->config.workdir, &workpath);
991         if (err)
992                 goto out;
993
994         err = -EINVAL;
995         if (upperpath->mnt != workpath.mnt) {
996                 pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
997                 goto out;
998         }
999         if (!ovl_workdir_ok(workpath.dentry, upperpath->dentry)) {
1000                 pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
1001                 goto out;
1002         }
1003
1004         err = -EBUSY;
1005         if (ovl_inuse_trylock(workpath.dentry)) {
1006                 ofs->workdir_locked = true;
1007         } else if (ofs->config.index) {
1008                 pr_err("overlayfs: workdir is in-use by another mount, mount with '-o index=off' to override exclusive workdir protection.\n");
1009                 goto out;
1010         } else {
1011                 pr_warn("overlayfs: workdir is in-use by another mount, accessing files from both mounts will result in undefined behavior.\n");
1012         }
1013
1014         ofs->workbasedir = dget(workpath.dentry);
1015         err = ovl_make_workdir(ofs, &workpath);
1016         if (err)
1017                 goto out;
1018
1019         err = 0;
1020 out:
1021         path_put(&workpath);
1022
1023         return err;
1024 }
1025
1026 static int ovl_get_indexdir(struct ovl_fs *ofs, struct ovl_entry *oe,
1027                             struct path *upperpath)
1028 {
1029         int err;
1030
1031         /* Verify lower root is upper root origin */
1032         err = ovl_verify_origin(upperpath->dentry, oe->lowerstack[0].dentry,
1033                                 false, true);
1034         if (err) {
1035                 pr_err("overlayfs: failed to verify upper root origin\n");
1036                 goto out;
1037         }
1038
1039         ofs->indexdir = ovl_workdir_create(ofs, OVL_INDEXDIR_NAME, true);
1040         if (ofs->indexdir) {
1041                 /* Verify upper root is index dir origin */
1042                 err = ovl_verify_origin(ofs->indexdir, upperpath->dentry,
1043                                         true, true);
1044                 if (err)
1045                         pr_err("overlayfs: failed to verify index dir origin\n");
1046
1047                 /* Cleanup bad/stale/orphan index entries */
1048                 if (!err)
1049                         err = ovl_indexdir_cleanup(ofs->indexdir,
1050                                                    ofs->upper_mnt,
1051                                                    oe->lowerstack,
1052                                                    oe->numlower);
1053         }
1054         if (err || !ofs->indexdir)
1055                 pr_warn("overlayfs: try deleting index dir or mounting with '-o index=off' to disable inodes index.\n");
1056
1057 out:
1058         return err;
1059 }
1060
1061 static int ovl_get_lower_layers(struct ovl_fs *ofs, struct path *stack,
1062                                 unsigned int numlower)
1063 {
1064         int err;
1065         unsigned int i;
1066
1067         err = -ENOMEM;
1068         ofs->lower_layers = kcalloc(numlower, sizeof(struct ovl_layer),
1069                                     GFP_KERNEL);
1070         if (ofs->lower_layers == NULL)
1071                 goto out;
1072         for (i = 0; i < numlower; i++) {
1073                 struct vfsmount *mnt;
1074                 dev_t dev;
1075
1076                 err = get_anon_bdev(&dev);
1077                 if (err) {
1078                         pr_err("overlayfs: failed to get anonymous bdev for lowerpath\n");
1079                         goto out;
1080                 }
1081
1082                 mnt = clone_private_mount(&stack[i]);
1083                 err = PTR_ERR(mnt);
1084                 if (IS_ERR(mnt)) {
1085                         pr_err("overlayfs: failed to clone lowerpath\n");
1086                         free_anon_bdev(dev);
1087                         goto out;
1088                 }
1089                 /*
1090                  * Make lower layers R/O.  That way fchmod/fchown on lower file
1091                  * will fail instead of modifying lower fs.
1092                  */
1093                 mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
1094
1095                 ofs->lower_layers[ofs->numlower].mnt = mnt;
1096                 ofs->lower_layers[ofs->numlower].pseudo_dev = dev;
1097                 ofs->numlower++;
1098
1099                 /* Check if all lower layers are on same sb */
1100                 if (i == 0)
1101                         ofs->same_sb = mnt->mnt_sb;
1102                 else if (ofs->same_sb != mnt->mnt_sb)
1103                         ofs->same_sb = NULL;
1104         }
1105         err = 0;
1106 out:
1107         return err;
1108 }
1109
1110 static struct ovl_entry *ovl_get_lowerstack(struct super_block *sb,
1111                                             struct ovl_fs *ofs)
1112 {
1113         int err;
1114         char *lowertmp, *lower;
1115         struct path *stack = NULL;
1116         unsigned int stacklen, numlower = 0, i;
1117         bool remote = false;
1118         struct ovl_entry *oe;
1119
1120         err = -ENOMEM;
1121         lowertmp = kstrdup(ofs->config.lowerdir, GFP_KERNEL);
1122         if (!lowertmp)
1123                 goto out_err;
1124
1125         err = -EINVAL;
1126         stacklen = ovl_split_lowerdirs(lowertmp);
1127         if (stacklen > OVL_MAX_STACK) {
1128                 pr_err("overlayfs: too many lower directories, limit is %d\n",
1129                        OVL_MAX_STACK);
1130                 goto out_err;
1131         } else if (!ofs->config.upperdir && stacklen == 1) {
1132                 pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n");
1133                 goto out_err;
1134         }
1135
1136         err = -ENOMEM;
1137         stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL);
1138         if (!stack)
1139                 goto out_err;
1140
1141         err = -EINVAL;
1142         lower = lowertmp;
1143         for (numlower = 0; numlower < stacklen; numlower++) {
1144                 err = ovl_lower_dir(lower, &stack[numlower], ofs,
1145                                     &sb->s_stack_depth, &remote);
1146                 if (err)
1147                         goto out_err;
1148
1149                 lower = strchr(lower, '\0') + 1;
1150         }
1151
1152         err = -EINVAL;
1153         sb->s_stack_depth++;
1154         if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
1155                 pr_err("overlayfs: maximum fs stacking depth exceeded\n");
1156                 goto out_err;
1157         }
1158
1159         err = ovl_get_lower_layers(ofs, stack, numlower);
1160         if (err)
1161                 goto out_err;
1162
1163         err = -ENOMEM;
1164         oe = ovl_alloc_entry(numlower);
1165         if (!oe)
1166                 goto out_err;
1167
1168         for (i = 0; i < numlower; i++) {
1169                 oe->lowerstack[i].dentry = dget(stack[i].dentry);
1170                 oe->lowerstack[i].layer = &ofs->lower_layers[i];
1171         }
1172
1173         if (remote)
1174                 sb->s_d_op = &ovl_reval_dentry_operations;
1175         else
1176                 sb->s_d_op = &ovl_dentry_operations;
1177
1178 out:
1179         for (i = 0; i < numlower; i++)
1180                 path_put(&stack[i]);
1181         kfree(stack);
1182         kfree(lowertmp);
1183
1184         return oe;
1185
1186 out_err:
1187         oe = ERR_PTR(err);
1188         goto out;
1189 }
1190
1191 static int ovl_fill_super(struct super_block *sb, void *data, int silent)
1192 {
1193         struct path upperpath = { };
1194         struct dentry *root_dentry;
1195         struct ovl_entry *oe;
1196         struct ovl_fs *ofs;
1197         struct cred *cred;
1198         int err;
1199
1200         err = -ENOMEM;
1201         ofs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
1202         if (!ofs)
1203                 goto out;
1204
1205         ofs->creator_cred = cred = prepare_creds();
1206         if (!cred)
1207                 goto out_err;
1208
1209         ofs->config.index = ovl_index_def;
1210         err = ovl_parse_opt((char *) data, &ofs->config);
1211         if (err)
1212                 goto out_err;
1213
1214         err = -EINVAL;
1215         if (!ofs->config.lowerdir) {
1216                 if (!silent)
1217                         pr_err("overlayfs: missing 'lowerdir'\n");
1218                 goto out_err;
1219         }
1220
1221         sb->s_stack_depth = 0;
1222         sb->s_maxbytes = MAX_LFS_FILESIZE;
1223         if (ofs->config.upperdir) {
1224                 if (!ofs->config.workdir) {
1225                         pr_err("overlayfs: missing 'workdir'\n");
1226                         goto out_err;
1227                 }
1228
1229                 err = ovl_get_upper(ofs, &upperpath);
1230                 if (err)
1231                         goto out_err;
1232
1233                 err = ovl_get_workdir(ofs, &upperpath);
1234                 if (err)
1235                         goto out_err;
1236
1237                 if (!ofs->workdir)
1238                         sb->s_flags |= SB_RDONLY;
1239
1240                 sb->s_stack_depth = ofs->upper_mnt->mnt_sb->s_stack_depth;
1241                 sb->s_time_gran = ofs->upper_mnt->mnt_sb->s_time_gran;
1242
1243         }
1244         oe = ovl_get_lowerstack(sb, ofs);
1245         err = PTR_ERR(oe);
1246         if (IS_ERR(oe))
1247                 goto out_err;
1248
1249         /* If the upper fs is nonexistent, we mark overlayfs r/o too */
1250         if (!ofs->upper_mnt)
1251                 sb->s_flags |= SB_RDONLY;
1252         else if (ofs->upper_mnt->mnt_sb != ofs->same_sb)
1253                 ofs->same_sb = NULL;
1254
1255         if (!(ovl_force_readonly(ofs)) && ofs->config.index) {
1256                 err = ovl_get_indexdir(ofs, oe, &upperpath);
1257                 if (err)
1258                         goto out_free_oe;
1259
1260                 if (!ofs->indexdir)
1261                         sb->s_flags |= SB_RDONLY;
1262         }
1263
1264         /* Show index=off/on in /proc/mounts for any of the reasons above */
1265         if (!ofs->indexdir)
1266                 ofs->config.index = false;
1267
1268         /* Never override disk quota limits or use reserved space */
1269         cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);
1270
1271         sb->s_magic = OVERLAYFS_SUPER_MAGIC;
1272         sb->s_op = &ovl_super_operations;
1273         sb->s_xattr = ovl_xattr_handlers;
1274         sb->s_fs_info = ofs;
1275         sb->s_flags |= SB_POSIXACL | SB_NOREMOTELOCK;
1276
1277         err = -ENOMEM;
1278         root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
1279         if (!root_dentry)
1280                 goto out_free_oe;
1281
1282         mntput(upperpath.mnt);
1283         if (upperpath.dentry) {
1284                 oe->has_upper = true;
1285                 if (ovl_is_impuredir(upperpath.dentry))
1286                         ovl_set_flag(OVL_IMPURE, d_inode(root_dentry));
1287         }
1288
1289         root_dentry->d_fsdata = oe;
1290
1291         /* Root is always merge -> can have whiteouts */
1292         ovl_set_flag(OVL_WHITEOUTS, d_inode(root_dentry));
1293         ovl_inode_init(d_inode(root_dentry), upperpath.dentry,
1294                        ovl_dentry_lower(root_dentry));
1295
1296         sb->s_root = root_dentry;
1297
1298         return 0;
1299
1300 out_free_oe:
1301         ovl_entry_stack_free(oe);
1302         kfree(oe);
1303 out_err:
1304         path_put(&upperpath);
1305         ovl_free_fs(ofs);
1306 out:
1307         return err;
1308 }
1309
1310 static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
1311                                 const char *dev_name, void *raw_data)
1312 {
1313         return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
1314 }
1315
1316 static struct file_system_type ovl_fs_type = {
1317         .owner          = THIS_MODULE,
1318         .name           = "overlay",
1319         .mount          = ovl_mount,
1320         .kill_sb        = kill_anon_super,
1321 };
1322 MODULE_ALIAS_FS("overlay");
1323
1324 static void ovl_inode_init_once(void *foo)
1325 {
1326         struct ovl_inode *oi = foo;
1327
1328         inode_init_once(&oi->vfs_inode);
1329 }
1330
1331 static int __init ovl_init(void)
1332 {
1333         int err;
1334
1335         ovl_inode_cachep = kmem_cache_create("ovl_inode",
1336                                              sizeof(struct ovl_inode), 0,
1337                                              (SLAB_RECLAIM_ACCOUNT|
1338                                               SLAB_MEM_SPREAD|SLAB_ACCOUNT),
1339                                              ovl_inode_init_once);
1340         if (ovl_inode_cachep == NULL)
1341                 return -ENOMEM;
1342
1343         err = register_filesystem(&ovl_fs_type);
1344         if (err)
1345                 kmem_cache_destroy(ovl_inode_cachep);
1346
1347         return err;
1348 }
1349
1350 static void __exit ovl_exit(void)
1351 {
1352         unregister_filesystem(&ovl_fs_type);
1353
1354         /*
1355          * Make sure all delayed rcu free inodes are flushed before we
1356          * destroy cache.
1357          */
1358         rcu_barrier();
1359         kmem_cache_destroy(ovl_inode_cachep);
1360
1361 }
1362
1363 module_init(ovl_init);
1364 module_exit(ovl_exit);