2 * Copyright (C) 2011 Novell Inc.
3 * Copyright (C) 2016 Red Hat, Inc.
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.
11 #include <linux/mount.h>
12 #include <linux/slab.h>
13 #include <linux/cred.h>
14 #include <linux/xattr.h>
15 #include <linux/exportfs.h>
16 #include <linux/uuid.h>
17 #include <linux/namei.h>
18 #include <linux/ratelimit.h>
19 #include "overlayfs.h"
21 int ovl_want_write(struct dentry *dentry)
23 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
24 return mnt_want_write(ofs->upper_mnt);
27 void ovl_drop_write(struct dentry *dentry)
29 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
30 mnt_drop_write(ofs->upper_mnt);
33 struct dentry *ovl_workdir(struct dentry *dentry)
35 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
39 const struct cred *ovl_override_creds(struct super_block *sb)
41 struct ovl_fs *ofs = sb->s_fs_info;
43 return override_creds(ofs->creator_cred);
46 struct super_block *ovl_same_sb(struct super_block *sb)
48 struct ovl_fs *ofs = sb->s_fs_info;
53 bool ovl_can_decode_fh(struct super_block *sb)
55 return (sb->s_export_op && sb->s_export_op->fh_to_dentry &&
56 !uuid_is_null(&sb->s_uuid));
59 struct dentry *ovl_indexdir(struct super_block *sb)
61 struct ovl_fs *ofs = sb->s_fs_info;
66 struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
68 size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
69 struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
72 oe->numlower = numlower;
77 bool ovl_dentry_remote(struct dentry *dentry)
79 return dentry->d_flags &
80 (DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE |
84 bool ovl_dentry_weird(struct dentry *dentry)
86 return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
87 DCACHE_MANAGE_TRANSIT |
92 enum ovl_path_type ovl_path_type(struct dentry *dentry)
94 struct ovl_entry *oe = dentry->d_fsdata;
95 enum ovl_path_type type = 0;
97 if (ovl_dentry_upper(dentry)) {
98 type = __OVL_PATH_UPPER;
101 * Non-dir dentry can hold lower dentry of its copy up origin.
104 type |= __OVL_PATH_ORIGIN;
105 if (d_is_dir(dentry))
106 type |= __OVL_PATH_MERGE;
109 if (oe->numlower > 1)
110 type |= __OVL_PATH_MERGE;
115 void ovl_path_upper(struct dentry *dentry, struct path *path)
117 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
119 path->mnt = ofs->upper_mnt;
120 path->dentry = ovl_dentry_upper(dentry);
123 void ovl_path_lower(struct dentry *dentry, struct path *path)
125 struct ovl_entry *oe = dentry->d_fsdata;
128 path->mnt = oe->lowerstack[0].layer->mnt;
129 path->dentry = oe->lowerstack[0].dentry;
131 *path = (struct path) { };
135 enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
137 enum ovl_path_type type = ovl_path_type(dentry);
139 if (!OVL_TYPE_UPPER(type))
140 ovl_path_lower(dentry, path);
142 ovl_path_upper(dentry, path);
147 struct dentry *ovl_dentry_upper(struct dentry *dentry)
149 return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
152 struct dentry *ovl_dentry_lower(struct dentry *dentry)
154 struct ovl_entry *oe = dentry->d_fsdata;
156 return oe->numlower ? oe->lowerstack[0].dentry : NULL;
159 struct dentry *ovl_dentry_real(struct dentry *dentry)
161 return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
164 struct dentry *ovl_i_dentry_upper(struct inode *inode)
166 return ovl_upperdentry_dereference(OVL_I(inode));
169 struct inode *ovl_inode_upper(struct inode *inode)
171 struct dentry *upperdentry = ovl_i_dentry_upper(inode);
173 return upperdentry ? d_inode(upperdentry) : NULL;
176 struct inode *ovl_inode_lower(struct inode *inode)
178 return OVL_I(inode)->lower;
181 struct inode *ovl_inode_real(struct inode *inode)
183 return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
187 struct ovl_dir_cache *ovl_dir_cache(struct inode *inode)
189 return OVL_I(inode)->cache;
192 void ovl_set_dir_cache(struct inode *inode, struct ovl_dir_cache *cache)
194 OVL_I(inode)->cache = cache;
197 bool ovl_dentry_is_opaque(struct dentry *dentry)
199 struct ovl_entry *oe = dentry->d_fsdata;
203 bool ovl_dentry_is_whiteout(struct dentry *dentry)
205 return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
208 void ovl_dentry_set_opaque(struct dentry *dentry)
210 struct ovl_entry *oe = dentry->d_fsdata;
216 * For hard links it's possible for ovl_dentry_upper() to return positive, while
217 * there's no actual upper alias for the inode. Copy up code needs to know
218 * about the existence of the upper alias, so it can't use ovl_dentry_upper().
220 bool ovl_dentry_has_upper_alias(struct dentry *dentry)
222 struct ovl_entry *oe = dentry->d_fsdata;
224 return oe->has_upper;
227 void ovl_dentry_set_upper_alias(struct dentry *dentry)
229 struct ovl_entry *oe = dentry->d_fsdata;
231 oe->has_upper = true;
234 bool ovl_redirect_dir(struct super_block *sb)
236 struct ovl_fs *ofs = sb->s_fs_info;
238 return ofs->config.redirect_dir && !ofs->noxattr;
241 const char *ovl_dentry_get_redirect(struct dentry *dentry)
243 return OVL_I(d_inode(dentry))->redirect;
246 void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
248 struct ovl_inode *oi = OVL_I(d_inode(dentry));
251 oi->redirect = redirect;
254 void ovl_inode_init(struct inode *inode, struct dentry *upperdentry,
255 struct dentry *lowerdentry)
258 OVL_I(inode)->__upperdentry = upperdentry;
260 OVL_I(inode)->lower = d_inode(lowerdentry);
262 ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode);
265 void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
267 struct inode *upperinode = d_inode(upperdentry);
269 WARN_ON(OVL_I(inode)->__upperdentry);
272 * Make sure upperdentry is consistent before making it visible
275 OVL_I(inode)->__upperdentry = upperdentry;
276 if (!S_ISDIR(upperinode->i_mode) && inode_unhashed(inode)) {
277 inode->i_private = upperinode;
278 __insert_inode_hash(inode, (unsigned long) upperinode);
282 void ovl_dentry_version_inc(struct dentry *dentry, bool impurity)
284 struct inode *inode = d_inode(dentry);
286 WARN_ON(!inode_is_locked(inode));
288 * Version is used by readdir code to keep cache consistent. For merge
289 * dirs all changes need to be noted. For non-merge dirs, cache only
290 * contains impure (ones which have been copied up and have origins)
291 * entries, so only need to note changes to impure entries.
293 if (OVL_TYPE_MERGE(ovl_path_type(dentry)) || impurity)
294 OVL_I(inode)->version++;
297 u64 ovl_dentry_version_get(struct dentry *dentry)
299 struct inode *inode = d_inode(dentry);
301 WARN_ON(!inode_is_locked(inode));
302 return OVL_I(inode)->version;
305 bool ovl_is_whiteout(struct dentry *dentry)
307 struct inode *inode = dentry->d_inode;
309 return inode && IS_WHITEOUT(inode);
312 struct file *ovl_path_open(struct path *path, int flags)
314 return dentry_open(path, flags | O_NOATIME, current_cred());
317 int ovl_copy_up_start(struct dentry *dentry)
319 struct ovl_inode *oi = OVL_I(d_inode(dentry));
322 err = mutex_lock_interruptible(&oi->lock);
323 if (!err && ovl_dentry_has_upper_alias(dentry)) {
324 err = 1; /* Already copied up */
325 mutex_unlock(&oi->lock);
331 void ovl_copy_up_end(struct dentry *dentry)
333 mutex_unlock(&OVL_I(d_inode(dentry))->lock);
336 bool ovl_check_origin_xattr(struct dentry *dentry)
340 res = vfs_getxattr(dentry, OVL_XATTR_ORIGIN, NULL, 0);
342 /* Zero size value means "copied up but origin unknown" */
349 bool ovl_check_dir_xattr(struct dentry *dentry, const char *name)
354 if (!d_is_dir(dentry))
357 res = vfs_getxattr(dentry, name, &val, 1);
358 if (res == 1 && val == 'y')
364 int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry,
365 const char *name, const void *value, size_t size,
369 struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
374 err = ovl_do_setxattr(upperdentry, name, value, size, 0);
376 if (err == -EOPNOTSUPP) {
377 pr_warn("overlayfs: cannot set %s xattr on upper\n", name);
385 int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
389 if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
393 * Do not fail when upper doesn't support xattrs.
394 * Upper inodes won't have origin nor redirect xattr anyway.
396 err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE,
399 ovl_set_flag(OVL_IMPURE, d_inode(dentry));
404 void ovl_set_flag(unsigned long flag, struct inode *inode)
406 set_bit(flag, &OVL_I(inode)->flags);
409 void ovl_clear_flag(unsigned long flag, struct inode *inode)
411 clear_bit(flag, &OVL_I(inode)->flags);
414 bool ovl_test_flag(unsigned long flag, struct inode *inode)
416 return test_bit(flag, &OVL_I(inode)->flags);
420 * Caller must hold a reference to inode to prevent it from being freed while
421 * it is marked inuse.
423 bool ovl_inuse_trylock(struct dentry *dentry)
425 struct inode *inode = d_inode(dentry);
428 spin_lock(&inode->i_lock);
429 if (!(inode->i_state & I_OVL_INUSE)) {
430 inode->i_state |= I_OVL_INUSE;
433 spin_unlock(&inode->i_lock);
438 void ovl_inuse_unlock(struct dentry *dentry)
441 struct inode *inode = d_inode(dentry);
443 spin_lock(&inode->i_lock);
444 WARN_ON(!(inode->i_state & I_OVL_INUSE));
445 inode->i_state &= ~I_OVL_INUSE;
446 spin_unlock(&inode->i_lock);
450 /* Caller must hold OVL_I(inode)->lock */
451 static void ovl_cleanup_index(struct dentry *dentry)
453 struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;
454 struct dentry *lowerdentry = ovl_dentry_lower(dentry);
455 struct dentry *upperdentry = ovl_dentry_upper(dentry);
456 struct dentry *index = NULL;
461 err = ovl_get_index_name(lowerdentry, &name);
465 inode = d_inode(upperdentry);
466 if (inode->i_nlink != 1) {
467 pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
468 upperdentry, inode->i_ino, inode->i_nlink);
470 * We either have a bug with persistent union nlink or a lower
471 * hardlink was added while overlay is mounted. Adding a lower
472 * hardlink and then unlinking all overlay hardlinks would drop
473 * overlay nlink to zero before all upper inodes are unlinked.
474 * As a safety measure, when that situation is detected, set
475 * the overlay nlink to the index inode nlink minus one for the
476 * index entry itself.
478 set_nlink(d_inode(dentry), inode->i_nlink - 1);
479 ovl_set_nlink_upper(dentry);
483 inode_lock_nested(dir, I_MUTEX_PARENT);
484 /* TODO: whiteout instead of cleanup to block future open by handle */
485 index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len);
486 err = PTR_ERR(index);
488 err = ovl_cleanup(dir, index);
501 pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
506 * Operations that change overlay inode and upper inode nlink need to be
507 * synchronized with copy up for persistent nlink accounting.
509 int ovl_nlink_start(struct dentry *dentry, bool *locked)
511 struct ovl_inode *oi = OVL_I(d_inode(dentry));
512 const struct cred *old_cred;
515 if (!d_inode(dentry) || d_is_dir(dentry))
519 * With inodes index is enabled, we store the union overlay nlink
520 * in an xattr on the index inode. When whiting out lower hardlinks
521 * we need to decrement the overlay persistent nlink, but before the
522 * first copy up, we have no upper index inode to store the xattr.
524 * As a workaround, before whiteout/rename over of a lower hardlink,
525 * copy up to create the upper index. Creating the upper index will
526 * initialize the overlay nlink, so it could be dropped if unlink
527 * or rename succeeds.
529 * TODO: implement metadata only index copy up when called with
530 * ovl_copy_up_flags(dentry, O_PATH).
532 if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) &&
533 d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) {
534 err = ovl_copy_up(dentry);
539 err = mutex_lock_interruptible(&oi->lock);
543 if (!ovl_test_flag(OVL_INDEX, d_inode(dentry)))
546 old_cred = ovl_override_creds(dentry->d_sb);
548 * The overlay inode nlink should be incremented/decremented IFF the
549 * upper operation succeeds, along with nlink change of upper inode.
550 * Therefore, before link/unlink/rename, we store the union nlink
551 * value relative to the upper inode nlink in an upper inode xattr.
553 err = ovl_set_nlink_upper(dentry);
554 revert_creds(old_cred);
558 mutex_unlock(&oi->lock);
565 void ovl_nlink_end(struct dentry *dentry, bool locked)
568 if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) &&
569 d_inode(dentry)->i_nlink == 0) {
570 const struct cred *old_cred;
572 old_cred = ovl_override_creds(dentry->d_sb);
573 ovl_cleanup_index(dentry);
574 revert_creds(old_cred);
577 mutex_unlock(&OVL_I(d_inode(dentry))->lock);
581 int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
583 /* Workdir should not be the same as upperdir */
584 if (workdir == upperdir)
587 /* Workdir should not be subdir of upperdir and vice versa */
588 if (lock_rename(workdir, upperdir) != NULL)
594 unlock_rename(workdir, upperdir);
596 pr_err("overlayfs: failed to lock workdir+upperdir\n");