[mirror_ubuntu-artful-kernel.git] / fs / overlayfs / util.c

/*
 * Copyright (C) 2011 Novell Inc.
 * Copyright (C) 2016 Red Hat, Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/slab.h>
#include <linux/cred.h>
#include <linux/xattr.h>
#include <linux/exportfs.h>
#include <linux/uuid.h>
#include <linux/namei.h>
#include <linux/ratelimit.h>
#include "overlayfs.h"
#include "ovl_entry.h"

int ovl_want_write(struct dentry *dentry)
{
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	return mnt_want_write(ofs->upper_mnt);
}

void ovl_drop_write(struct dentry *dentry)
{
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	mnt_drop_write(ofs->upper_mnt);
}

struct dentry *ovl_workdir(struct dentry *dentry)
{
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	return ofs->workdir;
}

const struct cred *ovl_override_creds(struct super_block *sb)
{
	struct ovl_fs *ofs = sb->s_fs_info;

	return override_creds(ofs->creator_cred);
}

struct super_block *ovl_same_sb(struct super_block *sb)
{
	struct ovl_fs *ofs = sb->s_fs_info;

	return ofs->same_sb;
}

bool ovl_can_decode_fh(struct super_block *sb)
{
	return (sb->s_export_op && sb->s_export_op->fh_to_dentry &&
		!uuid_is_null(&sb->s_uuid));
}

struct dentry *ovl_indexdir(struct super_block *sb)
{
	struct ovl_fs *ofs = sb->s_fs_info;

	return ofs->indexdir;
}

struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
{
	size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
	struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);

	if (oe)
		oe->numlower = numlower;

	return oe;
}

bool ovl_dentry_remote(struct dentry *dentry)
{
	return dentry->d_flags &
		(DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE |
		 DCACHE_OP_REAL);
}

bool ovl_dentry_weird(struct dentry *dentry)
{
	return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT |
				  DCACHE_MANAGE_TRANSIT |
				  DCACHE_OP_HASH |
				  DCACHE_OP_COMPARE);
}

enum ovl_path_type ovl_path_type(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	enum ovl_path_type type = 0;

	if (ovl_dentry_upper(dentry)) {
		type = __OVL_PATH_UPPER;

		/*
		 * Non-dir dentry can hold lower dentry of its copy up origin.
		 */
		if (oe->numlower) {
			type |= __OVL_PATH_ORIGIN;
			if (d_is_dir(dentry))
				type |= __OVL_PATH_MERGE;
		}
	} else {
		if (oe->numlower > 1)
			type |= __OVL_PATH_MERGE;
	}
	return type;
}

void ovl_path_upper(struct dentry *dentry, struct path *path)
{
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;

	path->mnt = ofs->upper_mnt;
	path->dentry = ovl_dentry_upper(dentry);
}

void ovl_path_lower(struct dentry *dentry, struct path *path)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	*path = oe->numlower ? oe->lowerstack[0] : (struct path) { };
}

enum ovl_path_type ovl_path_real(struct dentry *dentry, struct path *path)
{
	enum ovl_path_type type = ovl_path_type(dentry);

	if (!OVL_TYPE_UPPER(type))
		ovl_path_lower(dentry, path);
	else
		ovl_path_upper(dentry, path);

	return type;
}

struct dentry *ovl_dentry_upper(struct dentry *dentry)
{
	return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
}

struct dentry *ovl_dentry_lower(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	return oe->numlower ? oe->lowerstack[0].dentry : NULL;
}

struct dentry *ovl_dentry_real(struct dentry *dentry)
{
	return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
}

struct dentry *ovl_i_dentry_upper(struct inode *inode)
{
	return ovl_upperdentry_dereference(OVL_I(inode));
}

struct inode *ovl_inode_upper(struct inode *inode)
{
	struct dentry *upperdentry = ovl_i_dentry_upper(inode);

	return upperdentry ? d_inode(upperdentry) : NULL;
}

struct inode *ovl_inode_lower(struct inode *inode)
{
	return OVL_I(inode)->lower;
}

struct inode *ovl_inode_real(struct inode *inode)
{
	return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
}


struct ovl_dir_cache *ovl_dir_cache(struct dentry *dentry)
{
	return OVL_I(d_inode(dentry))->cache;
}

void ovl_set_dir_cache(struct dentry *dentry, struct ovl_dir_cache *cache)
{
	OVL_I(d_inode(dentry))->cache = cache;
}

bool ovl_dentry_is_opaque(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	return oe->opaque;
}

bool ovl_dentry_is_whiteout(struct dentry *dentry)
{
	return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
}

void ovl_dentry_set_opaque(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	oe->opaque = true;
}

/*
 * For hard links it's possible for ovl_dentry_upper() to return positive, while
 * there's no actual upper alias for the inode.  Copy up code needs to know
 * about the existence of the upper alias, so it can't use ovl_dentry_upper().
 */
bool ovl_dentry_has_upper_alias(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	return oe->has_upper;
}

void ovl_dentry_set_upper_alias(struct dentry *dentry)
{
	struct ovl_entry *oe = dentry->d_fsdata;

	oe->has_upper = true;
}

bool ovl_redirect_dir(struct super_block *sb)
{
	struct ovl_fs *ofs = sb->s_fs_info;

	return ofs->config.redirect_dir && !ofs->noxattr;
}

const char *ovl_dentry_get_redirect(struct dentry *dentry)
{
	return OVL_I(d_inode(dentry))->redirect;
}

void ovl_dentry_set_redirect(struct dentry *dentry, const char *redirect)
{
	struct ovl_inode *oi = OVL_I(d_inode(dentry));

	kfree(oi->redirect);
	oi->redirect = redirect;
}

void ovl_inode_init(struct inode *inode, struct dentry *upperdentry,
		    struct dentry *lowerdentry)
{
	if (upperdentry)
		OVL_I(inode)->__upperdentry = upperdentry;
	if (lowerdentry)
		OVL_I(inode)->lower = d_inode(lowerdentry);

	ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode);
}

void ovl_inode_update(struct inode *inode, struct dentry *upperdentry)
{
	struct inode *upperinode = d_inode(upperdentry);

	WARN_ON(OVL_I(inode)->__upperdentry);

	/*
	 * Make sure upperdentry is consistent before making it visible
	 */
	smp_wmb();
	OVL_I(inode)->__upperdentry = upperdentry;
	if (!S_ISDIR(upperinode->i_mode) && inode_unhashed(inode)) {
		inode->i_private = upperinode;
		__insert_inode_hash(inode, (unsigned long) upperinode);
	}
}

void ovl_dentry_version_inc(struct dentry *dentry)
{
	struct inode *inode = d_inode(dentry);

	WARN_ON(!inode_is_locked(inode));
	OVL_I(inode)->version++;
}

u64 ovl_dentry_version_get(struct dentry *dentry)
{
	struct inode *inode = d_inode(dentry);

	WARN_ON(!inode_is_locked(inode));
	return OVL_I(inode)->version;
}

bool ovl_is_whiteout(struct dentry *dentry)
{
	struct inode *inode = dentry->d_inode;

	return inode && IS_WHITEOUT(inode);
}

struct file *ovl_path_open(struct path *path, int flags)
{
	return dentry_open(path, flags | O_NOATIME, current_cred());
}

int ovl_copy_up_start(struct dentry *dentry)
{
	struct ovl_inode *oi = OVL_I(d_inode(dentry));
	int err;

	err = mutex_lock_interruptible(&oi->lock);
	if (!err && ovl_dentry_has_upper_alias(dentry)) {
		err = 1; /* Already copied up */
		mutex_unlock(&oi->lock);
	}

	return err;
}

void ovl_copy_up_end(struct dentry *dentry)
{
	mutex_unlock(&OVL_I(d_inode(dentry))->lock);
}

bool ovl_check_dir_xattr(struct dentry *dentry, const char *name)
{
	int res;
	char val;

	if (!d_is_dir(dentry))
		return false;

	res = vfs_getxattr(dentry, name, &val, 1);
	if (res == 1 && val == 'y')
		return true;

	return false;
}

int ovl_check_setxattr(struct dentry *dentry, struct dentry *upperdentry,
		       const char *name, const void *value, size_t size,
		       int xerr)
{
	int err;
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;

	if (ofs->noxattr)
		return xerr;

	err = ovl_do_setxattr(upperdentry, name, value, size, 0);

	if (err == -EOPNOTSUPP) {
		pr_warn("overlayfs: cannot set %s xattr on upper\n", name);
		ofs->noxattr = true;
		return xerr;
	}

	return err;
}

int ovl_set_impure(struct dentry *dentry, struct dentry *upperdentry)
{
	int err;

	if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
		return 0;

	/*
	 * Do not fail when upper doesn't support xattrs.
	 * Upper inodes won't have origin nor redirect xattr anyway.
	 */
	err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE,
				 "y", 1, 0);
	if (!err)
		ovl_set_flag(OVL_IMPURE, d_inode(dentry));

	return err;
}

void ovl_set_flag(unsigned long flag, struct inode *inode)
{
	set_bit(flag, &OVL_I(inode)->flags);
}

bool ovl_test_flag(unsigned long flag, struct inode *inode)
{
	return test_bit(flag, &OVL_I(inode)->flags);
}

/**
 * Caller must hold a reference to inode to prevent it from being freed while
 * it is marked inuse.
 */
bool ovl_inuse_trylock(struct dentry *dentry)
{
	struct inode *inode = d_inode(dentry);
	bool locked = false;

	spin_lock(&inode->i_lock);
	if (!(inode->i_state & I_OVL_INUSE)) {
		inode->i_state |= I_OVL_INUSE;
		locked = true;
	}
	spin_unlock(&inode->i_lock);

	return locked;
}

void ovl_inuse_unlock(struct dentry *dentry)
{
	if (dentry) {
		struct inode *inode = d_inode(dentry);

		spin_lock(&inode->i_lock);
		WARN_ON(!(inode->i_state & I_OVL_INUSE));
		inode->i_state &= ~I_OVL_INUSE;
		spin_unlock(&inode->i_lock);
	}
}

/* Caller must hold OVL_I(inode)->lock */
static void ovl_cleanup_index(struct dentry *dentry)
{
	struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;
	struct dentry *lowerdentry = ovl_dentry_lower(dentry);
	struct dentry *upperdentry = ovl_dentry_upper(dentry);
	struct dentry *index = NULL;
	struct inode *inode;
	struct qstr name;
	int err;

	err = ovl_get_index_name(lowerdentry, &name);
	if (err)
		goto fail;

	inode = d_inode(upperdentry);
	if (inode->i_nlink != 1) {
		pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
				    upperdentry, inode->i_ino, inode->i_nlink);
		/*
		 * We either have a bug with persistent union nlink or a lower
		 * hardlink was added while overlay is mounted. Adding a lower
		 * hardlink and then unlinking all overlay hardlinks would drop
		 * overlay nlink to zero before all upper inodes are unlinked.
		 * As a safety measure, when that situation is detected, set
		 * the overlay nlink to the index inode nlink minus one for the
		 * index entry itself.
		 */
		set_nlink(d_inode(dentry), inode->i_nlink - 1);
		ovl_set_nlink_upper(dentry);
		goto out;
	}

	inode_lock_nested(dir, I_MUTEX_PARENT);
	/* TODO: whiteout instead of cleanup to block future open by handle */
	index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len);
	err = PTR_ERR(index);
	if (!IS_ERR(index))
		err = ovl_cleanup(dir, index);
	else
		index = NULL;

	inode_unlock(dir);
	if (err)
		goto fail;

out:
	dput(index);
	return;

fail:
	pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
	goto out;
}

/*
 * Operations that change overlay inode and upper inode nlink need to be
 * synchronized with copy up for persistent nlink accounting.
 */
int ovl_nlink_start(struct dentry *dentry, bool *locked)
{
	struct ovl_inode *oi = OVL_I(d_inode(dentry));
	const struct cred *old_cred;
	int err;

	if (!d_inode(dentry) || d_is_dir(dentry))
		return 0;

	/*
	 * With inodes index is enabled, we store the union overlay nlink
	 * in an xattr on the index inode. When whiting out lower hardlinks
	 * we need to decrement the overlay persistent nlink, but before the
	 * first copy up, we have no upper index inode to store the xattr.
	 *
	 * As a workaround, before whiteout/rename over of a lower hardlink,
	 * copy up to create the upper index. Creating the upper index will
	 * initialize the overlay nlink, so it could be dropped if unlink
	 * or rename succeeds.
	 *
	 * TODO: implement metadata only index copy up when called with
	 *       ovl_copy_up_flags(dentry, O_PATH).
	 */
	if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) &&
	    d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) {
		err = ovl_copy_up(dentry);
		if (err)
			return err;
	}

	err = mutex_lock_interruptible(&oi->lock);
	if (err)
		return err;

	if (!ovl_test_flag(OVL_INDEX, d_inode(dentry)))
		goto out;

	old_cred = ovl_override_creds(dentry->d_sb);
	/*
	 * The overlay inode nlink should be incremented/decremented IFF the
	 * upper operation succeeds, along with nlink change of upper inode.
	 * Therefore, before link/unlink/rename, we store the union nlink
	 * value relative to the upper inode nlink in an upper inode xattr.
	 */
	err = ovl_set_nlink_upper(dentry);
	revert_creds(old_cred);

out:
	if (err)
		mutex_unlock(&oi->lock);
	else
		*locked = true;

	return err;
}

void ovl_nlink_end(struct dentry *dentry, bool locked)
{
	if (locked) {
		if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) &&
		    d_inode(dentry)->i_nlink == 0) {
			const struct cred *old_cred;

			old_cred = ovl_override_creds(dentry->d_sb);
			ovl_cleanup_index(dentry);
			revert_creds(old_cred);
		}

		mutex_unlock(&OVL_I(d_inode(dentry))->lock);
	}
}

int ovl_lock_rename_workdir(struct dentry *workdir, struct dentry *upperdir)
{
	/* Workdir should not be the same as upperdir */
	if (workdir == upperdir)
		goto err;

	/* Workdir should not be subdir of upperdir and vice versa */
	if (lock_rename(workdir, upperdir) != NULL)
		goto err_unlock;

	return 0;

err_unlock:
	unlock_rename(workdir, upperdir);
err:
	pr_err("overlayfs: failed to lock workdir+upperdir\n");
	return -EIO;
}
Commit	Line	Data
bbb1e54d MS	1	/*
	2	* Copyright (C) 2011 Novell Inc.
	3	* Copyright (C) 2016 Red Hat, 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/mount.h>
	12	#include <linux/slab.h>
5b825c3a	13	#include <linux/cred.h>
bbb1e54d	14	#include <linux/xattr.h>
02bcd157 AG	15	#include <linux/exportfs.h>
02bcd157 AG	16	#include <linux/uuid.h>
caf70cb2 AG	17	#include <linux/namei.h>
caf70cb2 AG	18	#include <linux/ratelimit.h>
bbb1e54d MS	19	#include "overlayfs.h"
	20	#include "ovl_entry.h"
	21
	22	int ovl_want_write(struct dentry *dentry)
	23	{
	24	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	25	return mnt_want_write(ofs->upper_mnt);
	26	}
	27
	28	void ovl_drop_write(struct dentry *dentry)
	29	{
	30	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	31	mnt_drop_write(ofs->upper_mnt);
	32	}
	33
	34	struct dentry ovl_workdir(struct dentry dentry)
	35	{
	36	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	37	return ofs->workdir;
	38	}
	39
	40	const struct cred ovl_override_creds(struct super_block sb)
	41	{
	42	struct ovl_fs *ofs = sb->s_fs_info;
	43
	44	return override_creds(ofs->creator_cred);
	45	}
	46
7bcd74b9 AG	47	struct super_block ovl_same_sb(struct super_block sb)
	48	{
	49	struct ovl_fs *ofs = sb->s_fs_info;
	50
	51	return ofs->same_sb;
	52	}
	53
02bcd157 AG	54	bool ovl_can_decode_fh(struct super_block *sb)
	55	{
	56	return (sb->s_export_op && sb->s_export_op->fh_to_dentry &&
	57	!uuid_is_null(&sb->s_uuid));
	58	}
	59
	60	struct dentry ovl_indexdir(struct super_block sb)
	61	{
	62	struct ovl_fs *ofs = sb->s_fs_info;
	63
	64	return ofs->indexdir;
	65	}
	66
bbb1e54d MS	67	struct ovl_entry *ovl_alloc_entry(unsigned int numlower)
	68	{
	69	size_t size = offsetof(struct ovl_entry, lowerstack[numlower]);
	70	struct ovl_entry *oe = kzalloc(size, GFP_KERNEL);
	71
	72	if (oe)
	73	oe->numlower = numlower;
	74
	75	return oe;
	76	}
	77
	78	bool ovl_dentry_remote(struct dentry *dentry)
	79	{
	80	return dentry->d_flags &
	81	(DCACHE_OP_REVALIDATE \| DCACHE_OP_WEAK_REVALIDATE \|
	82	DCACHE_OP_REAL);
	83	}
	84
	85	bool ovl_dentry_weird(struct dentry *dentry)
	86	{
	87	return dentry->d_flags & (DCACHE_NEED_AUTOMOUNT \|
	88	DCACHE_MANAGE_TRANSIT \|
	89	DCACHE_OP_HASH \|
	90	DCACHE_OP_COMPARE);
	91	}
	92
	93	enum ovl_path_type ovl_path_type(struct dentry *dentry)
	94	{
	95	struct ovl_entry *oe = dentry->d_fsdata;
	96	enum ovl_path_type type = 0;
	97
09d8b586	98	if (ovl_dentry_upper(dentry)) {
bbb1e54d MS	99	type = __OVL_PATH_UPPER;
	100
	101	/*
59548503	102	* Non-dir dentry can hold lower dentry of its copy up origin.
bbb1e54d	103	*/
59548503 AG	104	if (oe->numlower) {
	105	type \|= __OVL_PATH_ORIGIN;
	106	if (d_is_dir(dentry))
	107	type \|= __OVL_PATH_MERGE;
	108	}
bbb1e54d MS	109	} else {
	110	if (oe->numlower > 1)
	111	type \|= __OVL_PATH_MERGE;
	112	}
	113	return type;
	114	}
	115
	116	void ovl_path_upper(struct dentry dentry, struct path path)
	117	{
	118	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
bbb1e54d MS	119
bbb1e54d MS	120	path->mnt = ofs->upper_mnt;
09d8b586	121	path->dentry = ovl_dentry_upper(dentry);
bbb1e54d MS	122	}
	123
	124	void ovl_path_lower(struct dentry dentry, struct path path)
	125	{
	126	struct ovl_entry *oe = dentry->d_fsdata;
	127
33006cdf	128	*path = oe->numlower ? oe->lowerstack[0] : (struct path) { };
bbb1e54d MS	129	}
	130
	131	enum ovl_path_type ovl_path_real(struct dentry dentry, struct path path)
	132	{
	133	enum ovl_path_type type = ovl_path_type(dentry);
	134
	135	if (!OVL_TYPE_UPPER(type))
	136	ovl_path_lower(dentry, path);
	137	else
	138	ovl_path_upper(dentry, path);
	139
	140	return type;
	141	}
	142
	143	struct dentry ovl_dentry_upper(struct dentry dentry)
	144	{
09d8b586	145	return ovl_upperdentry_dereference(OVL_I(d_inode(dentry)));
bbb1e54d MS	146	}
	147
	148	struct dentry ovl_dentry_lower(struct dentry dentry)
	149	{
	150	struct ovl_entry *oe = dentry->d_fsdata;
	151
09d8b586	152	return oe->numlower ? oe->lowerstack[0].dentry : NULL;
bbb1e54d MS	153	}
	154
	155	struct dentry ovl_dentry_real(struct dentry dentry)
	156	{
09d8b586	157	return ovl_dentry_upper(dentry) ?: ovl_dentry_lower(dentry);
bbb1e54d MS	158	}
bbb1e54d MS	159
1d88f183 MS	160	struct dentry ovl_i_dentry_upper(struct inode inode)
	161	{
	162	return ovl_upperdentry_dereference(OVL_I(inode));
	163	}
	164
09d8b586	165	struct inode ovl_inode_upper(struct inode inode)
25b7713a	166	{
1d88f183	167	struct dentry *upperdentry = ovl_i_dentry_upper(inode);
25b7713a	168
09d8b586 MS	169	return upperdentry ? d_inode(upperdentry) : NULL;
09d8b586 MS	170	}
25b7713a	171
09d8b586 MS	172	struct inode ovl_inode_lower(struct inode inode)
	173	{
	174	return OVL_I(inode)->lower;
	175	}
25b7713a	176
09d8b586 MS	177	struct inode ovl_inode_real(struct inode inode)
	178	{
	179	return ovl_inode_upper(inode) ?: ovl_inode_lower(inode);
25b7713a MS	180	}
25b7713a MS	181
09d8b586	182
bbb1e54d MS	183	struct ovl_dir_cache ovl_dir_cache(struct dentry dentry)
bbb1e54d MS	184	{
04a01ac7	185	return OVL_I(d_inode(dentry))->cache;
bbb1e54d MS	186	}
	187
	188	void ovl_set_dir_cache(struct dentry dentry, struct ovl_dir_cache cache)
	189	{
04a01ac7	190	OVL_I(d_inode(dentry))->cache = cache;
bbb1e54d MS	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	bool ovl_dentry_is_whiteout(struct dentry *dentry)
	200	{
	201	return !dentry->d_inode && ovl_dentry_is_opaque(dentry);
	202	}
	203
5cf5b477	204	void ovl_dentry_set_opaque(struct dentry *dentry)
bbb1e54d MS	205	{
bbb1e54d MS	206	struct ovl_entry *oe = dentry->d_fsdata;
5cf5b477 MS	207
5cf5b477 MS	208	oe->opaque = true;
bbb1e54d MS	209	}
bbb1e54d MS	210
55acc661 MS	211	/*
	212	* For hard links it's possible for ovl_dentry_upper() to return positive, while
	213	* there's no actual upper alias for the inode. Copy up code needs to know
	214	* about the existence of the upper alias, so it can't use ovl_dentry_upper().
	215	*/
	216	bool ovl_dentry_has_upper_alias(struct dentry *dentry)
	217	{
	218	struct ovl_entry *oe = dentry->d_fsdata;
	219
	220	return oe->has_upper;
	221	}
	222
	223	void ovl_dentry_set_upper_alias(struct dentry *dentry)
	224	{
	225	struct ovl_entry *oe = dentry->d_fsdata;
	226
	227	oe->has_upper = true;
	228	}
	229
a6c60655 MS	230	bool ovl_redirect_dir(struct super_block *sb)
	231	{
	232	struct ovl_fs *ofs = sb->s_fs_info;
	233
21a22878	234	return ofs->config.redirect_dir && !ofs->noxattr;
a6c60655 MS	235	}
	236
	237	const char ovl_dentry_get_redirect(struct dentry dentry)
	238	{
cf31c463	239	return OVL_I(d_inode(dentry))->redirect;
a6c60655 MS	240	}
	241
	242	void ovl_dentry_set_redirect(struct dentry dentry, const char redirect)
	243	{
cf31c463	244	struct ovl_inode *oi = OVL_I(d_inode(dentry));
a6c60655	245
cf31c463 MS	246	kfree(oi->redirect);
cf31c463 MS	247	oi->redirect = redirect;
a6c60655 MS	248	}
a6c60655 MS	249
09d8b586 MS	250	void ovl_inode_init(struct inode inode, struct dentry upperdentry,
09d8b586 MS	251	struct dentry *lowerdentry)
bbb1e54d	252	{
09d8b586 MS	253	if (upperdentry)
	254	OVL_I(inode)->__upperdentry = upperdentry;
	255	if (lowerdentry)
	256	OVL_I(inode)->lower = d_inode(lowerdentry);
bbb1e54d	257
09d8b586	258	ovl_copyattr(d_inode(upperdentry ?: lowerdentry), inode);
bbb1e54d MS	259	}
bbb1e54d MS	260
09d8b586	261	void ovl_inode_update(struct inode inode, struct dentry upperdentry)
bbb1e54d	262	{
09d8b586	263	struct inode *upperinode = d_inode(upperdentry);
e6d2ebdd	264
09d8b586 MS	265	WARN_ON(OVL_I(inode)->__upperdentry);
09d8b586 MS	266
25b7713a	267	/*
09d8b586	268	* Make sure upperdentry is consistent before making it visible
25b7713a MS	269	*/
25b7713a MS	270	smp_wmb();
09d8b586	271	OVL_I(inode)->__upperdentry = upperdentry;
b9ac5c27	272	if (!S_ISDIR(upperinode->i_mode) && inode_unhashed(inode)) {
25b7713a	273	inode->i_private = upperinode;
bbb1e54d	274	__insert_inode_hash(inode, (unsigned long) upperinode);
25b7713a	275	}
bbb1e54d MS	276	}
	277
	278	void ovl_dentry_version_inc(struct dentry *dentry)
	279	{
04a01ac7	280	struct inode *inode = d_inode(dentry);
bbb1e54d	281
04a01ac7 MS	282	WARN_ON(!inode_is_locked(inode));
04a01ac7 MS	283	OVL_I(inode)->version++;
bbb1e54d MS	284	}
	285
	286	u64 ovl_dentry_version_get(struct dentry *dentry)
	287	{
04a01ac7	288	struct inode *inode = d_inode(dentry);
bbb1e54d	289
04a01ac7 MS	290	WARN_ON(!inode_is_locked(inode));
04a01ac7 MS	291	return OVL_I(inode)->version;
bbb1e54d MS	292	}
	293
	294	bool ovl_is_whiteout(struct dentry *dentry)
	295	{
	296	struct inode *inode = dentry->d_inode;
	297
	298	return inode && IS_WHITEOUT(inode);
	299	}
	300
	301	struct file ovl_path_open(struct path path, int flags)
	302	{
	303	return dentry_open(path, flags \| O_NOATIME, current_cred());
	304	}
39d3d60a AG	305
	306	int ovl_copy_up_start(struct dentry *dentry)
	307	{
a015dafc	308	struct ovl_inode *oi = OVL_I(d_inode(dentry));
39d3d60a AG	309	int err;
39d3d60a AG	310
a015dafc	311	err = mutex_lock_interruptible(&oi->lock);
59be0971	312	if (!err && ovl_dentry_has_upper_alias(dentry)) {
a015dafc AG	313	err = 1; /* Already copied up */
a015dafc AG	314	mutex_unlock(&oi->lock);
39d3d60a	315	}
39d3d60a AG	316
	317	return err;
	318	}
	319
	320	void ovl_copy_up_end(struct dentry *dentry)
	321	{
a015dafc	322	mutex_unlock(&OVL_I(d_inode(dentry))->lock);
39d3d60a	323	}
82b749b2	324
f3a15685 AG	325	bool ovl_check_dir_xattr(struct dentry dentry, const char name)
	326	{
	327	int res;
	328	char val;
	329
	330	if (!d_is_dir(dentry))
	331	return false;
	332
	333	res = vfs_getxattr(dentry, name, &val, 1);
	334	if (res == 1 && val == 'y')
	335	return true;
	336
	337	return false;
	338	}
	339
82b749b2 AG	340	int ovl_check_setxattr(struct dentry dentry, struct dentry upperdentry,
	341	const char name, const void value, size_t size,
	342	int xerr)
	343	{
	344	int err;
	345	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	346
	347	if (ofs->noxattr)
	348	return xerr;
	349
	350	err = ovl_do_setxattr(upperdentry, name, value, size, 0);
	351
	352	if (err == -EOPNOTSUPP) {
	353	pr_warn("overlayfs: cannot set %s xattr on upper\n", name);
	354	ofs->noxattr = true;
	355	return xerr;
	356	}
	357
	358	return err;
	359	}
f3a15685 AG	360
	361	int ovl_set_impure(struct dentry dentry, struct dentry upperdentry)
	362	{
	363	int err;
f3a15685	364
13c72075	365	if (ovl_test_flag(OVL_IMPURE, d_inode(dentry)))
f3a15685 AG	366	return 0;
	367
	368	/*
	369	* Do not fail when upper doesn't support xattrs.
	370	* Upper inodes won't have origin nor redirect xattr anyway.
	371	*/
	372	err = ovl_check_setxattr(dentry, upperdentry, OVL_XATTR_IMPURE,
	373	"y", 1, 0);
	374	if (!err)
13c72075	375	ovl_set_flag(OVL_IMPURE, d_inode(dentry));
f3a15685 AG	376
	377	return err;
	378	}
13c72075 MS	379
	380	void ovl_set_flag(unsigned long flag, struct inode *inode)
	381	{
	382	set_bit(flag, &OVL_I(inode)->flags);
	383	}
	384
	385	bool ovl_test_flag(unsigned long flag, struct inode *inode)
	386	{
	387	return test_bit(flag, &OVL_I(inode)->flags);
	388	}
ad0af710 AG	389
	390	/**
	391	* Caller must hold a reference to inode to prevent it from being freed while
	392	* it is marked inuse.
	393	*/
	394	bool ovl_inuse_trylock(struct dentry *dentry)
	395	{
	396	struct inode *inode = d_inode(dentry);
	397	bool locked = false;
	398
	399	spin_lock(&inode->i_lock);
	400	if (!(inode->i_state & I_OVL_INUSE)) {
	401	inode->i_state \|= I_OVL_INUSE;
	402	locked = true;
	403	}
	404	spin_unlock(&inode->i_lock);
	405
	406	return locked;
	407	}
	408
	409	void ovl_inuse_unlock(struct dentry *dentry)
	410	{
	411	if (dentry) {
	412	struct inode *inode = d_inode(dentry);
	413
	414	spin_lock(&inode->i_lock);
	415	WARN_ON(!(inode->i_state & I_OVL_INUSE));
	416	inode->i_state &= ~I_OVL_INUSE;
	417	spin_unlock(&inode->i_lock);
	418	}
	419	}
5f8415d6	420
1e7581da	421	/* Caller must hold OVL_I(inode)->lock */
caf70cb2 AG	422	static void ovl_cleanup_index(struct dentry *dentry)
	423	{
	424	struct inode *dir = ovl_indexdir(dentry->d_sb)->d_inode;
	425	struct dentry *lowerdentry = ovl_dentry_lower(dentry);
	426	struct dentry *upperdentry = ovl_dentry_upper(dentry);
	427	struct dentry *index = NULL;
	428	struct inode *inode;
	429	struct qstr name;
	430	int err;
	431
	432	err = ovl_get_index_name(lowerdentry, &name);
	433	if (err)
	434	goto fail;
	435
	436	inode = d_inode(upperdentry);
	437	if (inode->i_nlink != 1) {
	438	pr_warn_ratelimited("overlayfs: cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
	439	upperdentry, inode->i_ino, inode->i_nlink);
	440	/*
	441	* We either have a bug with persistent union nlink or a lower
	442	* hardlink was added while overlay is mounted. Adding a lower
	443	* hardlink and then unlinking all overlay hardlinks would drop
	444	* overlay nlink to zero before all upper inodes are unlinked.
	445	* As a safety measure, when that situation is detected, set
	446	* the overlay nlink to the index inode nlink minus one for the
	447	* index entry itself.
	448	*/
	449	set_nlink(d_inode(dentry), inode->i_nlink - 1);
	450	ovl_set_nlink_upper(dentry);
	451	goto out;
	452	}
	453
	454	inode_lock_nested(dir, I_MUTEX_PARENT);
	455	/* TODO: whiteout instead of cleanup to block future open by handle */
	456	index = lookup_one_len(name.name, ovl_indexdir(dentry->d_sb), name.len);
	457	err = PTR_ERR(index);
	458	if (!IS_ERR(index))
	459	err = ovl_cleanup(dir, index);
1e7581da AG	460	else
	461	index = NULL;
	462
caf70cb2 AG	463	inode_unlock(dir);
	464	if (err)
	465	goto fail;
	466
	467	out:
	468	dput(index);
	469	return;
	470
	471	fail:
	472	pr_err("overlayfs: cleanup index of '%pd2' failed (%i)\n", dentry, err);
	473	goto out;
	474	}
	475
5f8415d6 AG	476	/*
	477	* Operations that change overlay inode and upper inode nlink need to be
	478	* synchronized with copy up for persistent nlink accounting.
	479	*/
	480	int ovl_nlink_start(struct dentry dentry, bool locked)
	481	{
	482	struct ovl_inode *oi = OVL_I(d_inode(dentry));
	483	const struct cred *old_cred;
	484	int err;
	485
	486	if (!d_inode(dentry) \|\| d_is_dir(dentry))
	487	return 0;
	488
	489	/*
	490	* With inodes index is enabled, we store the union overlay nlink
	491	* in an xattr on the index inode. When whiting out lower hardlinks
	492	* we need to decrement the overlay persistent nlink, but before the
	493	* first copy up, we have no upper index inode to store the xattr.
	494	*
	495	* As a workaround, before whiteout/rename over of a lower hardlink,
	496	* copy up to create the upper index. Creating the upper index will
	497	* initialize the overlay nlink, so it could be dropped if unlink
	498	* or rename succeeds.
	499	*
	500	* TODO: implement metadata only index copy up when called with
	501	* ovl_copy_up_flags(dentry, O_PATH).
	502	*/
	503	if (ovl_indexdir(dentry->d_sb) && !ovl_dentry_has_upper_alias(dentry) &&
	504	d_inode(ovl_dentry_lower(dentry))->i_nlink > 1) {
	505	err = ovl_copy_up(dentry);
	506	if (err)
	507	return err;
	508	}
	509
	510	err = mutex_lock_interruptible(&oi->lock);
	511	if (err)
	512	return err;
	513
	514	if (!ovl_test_flag(OVL_INDEX, d_inode(dentry)))
	515	goto out;
	516
	517	old_cred = ovl_override_creds(dentry->d_sb);
	518	/*
	519	* The overlay inode nlink should be incremented/decremented IFF the
	520	* upper operation succeeds, along with nlink change of upper inode.
	521	* Therefore, before link/unlink/rename, we store the union nlink
	522	* value relative to the upper inode nlink in an upper inode xattr.
	523	*/
	524	err = ovl_set_nlink_upper(dentry);
	525	revert_creds(old_cred);
	526
	527	out:
	528	if (err)
	529	mutex_unlock(&oi->lock);
	530	else
	531	*locked = true;
	532
	533	return err;
	534	}
	535
	536	void ovl_nlink_end(struct dentry *dentry, bool locked)
	537	{
caf70cb2 AG	538	if (locked) {
	539	if (ovl_test_flag(OVL_INDEX, d_inode(dentry)) &&
	540	d_inode(dentry)->i_nlink == 0) {
	541	const struct cred *old_cred;
	542
	543	old_cred = ovl_override_creds(dentry->d_sb);
	544	ovl_cleanup_index(dentry);
	545	revert_creds(old_cred);
	546	}
	547
5f8415d6	548	mutex_unlock(&OVL_I(d_inode(dentry))->lock);
caf70cb2	549	}
5f8415d6	550	}
e62595ed AG	551
	552	int ovl_lock_rename_workdir(struct dentry workdir, struct dentry upperdir)
	553	{
	554	/* Workdir should not be the same as upperdir */
	555	if (workdir == upperdir)
	556	goto err;
	557
	558	/* Workdir should not be subdir of upperdir and vice versa */
	559	if (lock_rename(workdir, upperdir) != NULL)
	560	goto err_unlock;
	561
	562	return 0;
	563
	564	err_unlock:
	565	unlock_rename(workdir, upperdir);
	566	err:
	567	pr_err("overlayfs: failed to lock workdir+upperdir\n");
	568	return -EIO;
	569	}