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

/*
 *
 * Copyright (C) 2011 Novell 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/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/file.h>
#include <linux/splice.h>
#include <linux/xattr.h>
#include <linux/security.h>
#include <linux/uaccess.h>
#include <linux/sched/signal.h>
#include <linux/cred.h>
#include <linux/namei.h>
#include <linux/fdtable.h>
#include <linux/ratelimit.h>
#include <linux/exportfs.h>
#include "overlayfs.h"
#include "ovl_entry.h"

#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)

static bool __read_mostly ovl_check_copy_up;
module_param_named(check_copy_up, ovl_check_copy_up, bool,
		   S_IWUSR | S_IRUGO);
MODULE_PARM_DESC(ovl_check_copy_up,
		 "Warn on copy-up when causing process also has a R/O fd open");

static int ovl_check_fd(const void *data, struct file *f, unsigned int fd)
{
	const struct dentry *dentry = data;

	if (file_inode(f) == d_inode(dentry))
		pr_warn_ratelimited("overlayfs: Warning: Copying up %pD, but open R/O on fd %u which will cease to be coherent [pid=%d %s]\n",
				    f, fd, current->pid, current->comm);
	return 0;
}

/*
 * Check the fds open by this process and warn if something like the following
 * scenario is about to occur:
 *
 *	fd1 = open("foo", O_RDONLY);
 *	fd2 = open("foo", O_RDWR);
 */
static void ovl_do_check_copy_up(struct dentry *dentry)
{
	if (ovl_check_copy_up)
		iterate_fd(current->files, 0, ovl_check_fd, dentry);
}

int ovl_copy_xattr(struct dentry *old, struct dentry *new)
{
	ssize_t list_size, size, value_size = 0;
	char *buf, *name, *value = NULL;
	int uninitialized_var(error);
	size_t slen;

	if (!(old->d_inode->i_opflags & IOP_XATTR) ||
	    !(new->d_inode->i_opflags & IOP_XATTR))
		return 0;

	list_size = vfs_listxattr(old, NULL, 0);
	if (list_size <= 0) {
		if (list_size == -EOPNOTSUPP)
			return 0;
		return list_size;
	}

	buf = kzalloc(list_size, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	list_size = vfs_listxattr(old, buf, list_size);
	if (list_size <= 0) {
		error = list_size;
		goto out;
	}

	for (name = buf; list_size; name += slen) {
		slen = strnlen(name, list_size) + 1;

		/* underlying fs providing us with an broken xattr list? */
		if (WARN_ON(slen > list_size)) {
			error = -EIO;
			break;
		}
		list_size -= slen;

		if (ovl_is_private_xattr(name))
			continue;
retry:
		size = vfs_getxattr(old, name, value, value_size);
		if (size == -ERANGE)
			size = vfs_getxattr(old, name, NULL, 0);

		if (size < 0) {
			error = size;
			break;
		}

		if (size > value_size) {
			void *new;

			new = krealloc(value, size, GFP_KERNEL);
			if (!new) {
				error = -ENOMEM;
				break;
			}
			value = new;
			value_size = size;
			goto retry;
		}

		error = security_inode_copy_up_xattr(name);
		if (error < 0 && error != -EOPNOTSUPP)
			break;
		if (error == 1) {
			error = 0;
			continue; /* Discard */
		}
		error = vfs_setxattr(new, name, value, size, 0);
		if (error)
			break;
	}
	kfree(value);
out:
	kfree(buf);
	return error;
}

static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
{
	struct file *old_file;
	struct file *new_file;
	loff_t old_pos = 0;
	loff_t new_pos = 0;
	int error = 0;

	if (len == 0)
		return 0;

	old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY);
	if (IS_ERR(old_file))
		return PTR_ERR(old_file);

	new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY);
	if (IS_ERR(new_file)) {
		error = PTR_ERR(new_file);
		goto out_fput;
	}

	/* Try to use clone_file_range to clone up within the same fs */
	error = vfs_clone_file_range(old_file, 0, new_file, 0, len);
	if (!error)
		goto out;
	/* Couldn't clone, so now we try to copy the data */
	error = 0;

	/* FIXME: copy up sparse files efficiently */
	while (len) {
		size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
		long bytes;

		if (len < this_len)
			this_len = len;

		if (signal_pending_state(TASK_KILLABLE, current)) {
			error = -EINTR;
			break;
		}

		bytes = do_splice_direct(old_file, &old_pos,
					 new_file, &new_pos,
					 this_len, SPLICE_F_MOVE);
		if (bytes <= 0) {
			error = bytes;
			break;
		}
		WARN_ON(old_pos != new_pos);

		len -= bytes;
	}
out:
	if (!error)
		error = vfs_fsync(new_file, 0);
	fput(new_file);
out_fput:
	fput(old_file);
	return error;
}

static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
{
	struct iattr attr = {
		.ia_valid =
		     ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
		.ia_atime = stat->atime,
		.ia_mtime = stat->mtime,
	};

	return notify_change(upperdentry, &attr, NULL);
}

int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)
{
	int err = 0;

	if (!S_ISLNK(stat->mode)) {
		struct iattr attr = {
			.ia_valid = ATTR_MODE,
			.ia_mode = stat->mode,
		};
		err = notify_change(upperdentry, &attr, NULL);
	}
	if (!err) {
		struct iattr attr = {
			.ia_valid = ATTR_UID | ATTR_GID,
			.ia_uid = stat->uid,
			.ia_gid = stat->gid,
		};
		err = notify_change(upperdentry, &attr, NULL);
	}
	if (!err)
		ovl_set_timestamps(upperdentry, stat);

	return err;
}

struct ovl_fh *ovl_encode_fh(struct dentry *lower, bool is_upper)
{
	struct ovl_fh *fh;
	int fh_type, fh_len, dwords;
	void *buf;
	int buflen = MAX_HANDLE_SZ;
	uuid_t *uuid = &lower->d_sb->s_uuid;

	buf = kmalloc(buflen, GFP_TEMPORARY);
	if (!buf)
		return ERR_PTR(-ENOMEM);

	/*
	 * We encode a non-connectable file handle for non-dir, because we
	 * only need to find the lower inode number and we don't want to pay
	 * the price or reconnecting the dentry.
	 */
	dwords = buflen >> 2;
	fh_type = exportfs_encode_fh(lower, buf, &dwords, 0);
	buflen = (dwords << 2);

	fh = ERR_PTR(-EIO);
	if (WARN_ON(fh_type < 0) ||
	    WARN_ON(buflen > MAX_HANDLE_SZ) ||
	    WARN_ON(fh_type == FILEID_INVALID))
		goto out;

	BUILD_BUG_ON(MAX_HANDLE_SZ + offsetof(struct ovl_fh, fid) > 255);
	fh_len = offsetof(struct ovl_fh, fid) + buflen;
	fh = kmalloc(fh_len, GFP_KERNEL);
	if (!fh) {
		fh = ERR_PTR(-ENOMEM);
		goto out;
	}

	fh->version = OVL_FH_VERSION;
	fh->magic = OVL_FH_MAGIC;
	fh->type = fh_type;
	fh->flags = OVL_FH_FLAG_CPU_ENDIAN;
	/*
	 * When we will want to decode an overlay dentry from this handle
	 * and all layers are on the same fs, if we get a disconncted real
	 * dentry when we decode fid, the only way to tell if we should assign
	 * it to upperdentry or to lowerstack is by checking this flag.
	 */
	if (is_upper)
		fh->flags |= OVL_FH_FLAG_PATH_UPPER;
	fh->len = fh_len;
	fh->uuid = *uuid;
	memcpy(fh->fid, buf, buflen);

out:
	kfree(buf);
	return fh;
}

static int ovl_set_origin(struct dentry *dentry, struct dentry *lower,
			  struct dentry *upper)
{
	const struct ovl_fh *fh = NULL;
	int err;

	/*
	 * When lower layer doesn't support export operations store a 'null' fh,
	 * so we can use the overlay.origin xattr to distignuish between a copy
	 * up and a pure upper inode.
	 */
	if (ovl_can_decode_fh(lower->d_sb)) {
		fh = ovl_encode_fh(lower, false);
		if (IS_ERR(fh))
			return PTR_ERR(fh);
	}

	/*
	 * Do not fail when upper doesn't support xattrs.
	 */
	err = ovl_check_setxattr(dentry, upper, OVL_XATTR_ORIGIN, fh,
				 fh ? fh->len : 0, 0);
	kfree(fh);

	return err;
}

struct ovl_copy_up_ctx {
	struct dentry *parent;
	struct dentry *dentry;
	struct path lowerpath;
	struct kstat stat;
	struct kstat pstat;
	const char *link;
	struct dentry *destdir;
	struct qstr destname;
	struct dentry *workdir;
	bool tmpfile;
	bool origin;
};

static int ovl_link_up(struct ovl_copy_up_ctx *c)
{
	int err;
	struct dentry *upper;
	struct dentry *upperdir = ovl_dentry_upper(c->parent);
	struct inode *udir = d_inode(upperdir);

	/* Mark parent "impure" because it may now contain non-pure upper */
	err = ovl_set_impure(c->parent, upperdir);
	if (err)
		return err;

	err = ovl_set_nlink_lower(c->dentry);
	if (err)
		return err;

	inode_lock_nested(udir, I_MUTEX_PARENT);
	upper = lookup_one_len(c->dentry->d_name.name, upperdir,
			       c->dentry->d_name.len);
	err = PTR_ERR(upper);
	if (!IS_ERR(upper)) {
		err = ovl_do_link(ovl_dentry_upper(c->dentry), udir, upper,
				  true);
		dput(upper);

		if (!err) {
			/* Restore timestamps on parent (best effort) */
			ovl_set_timestamps(upperdir, &c->pstat);
			ovl_dentry_set_upper_alias(c->dentry);
		}
	}
	inode_unlock(udir);
	ovl_set_nlink_upper(c->dentry);

	return err;
}

static int ovl_install_temp(struct ovl_copy_up_ctx *c, struct dentry *temp,
			    struct dentry **newdentry)
{
	int err;
	struct dentry *upper;
	struct inode *udir = d_inode(c->destdir);

	upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);
	if (IS_ERR(upper))
		return PTR_ERR(upper);

	if (c->tmpfile)
		err = ovl_do_link(temp, udir, upper, true);
	else
		err = ovl_do_rename(d_inode(c->workdir), temp, udir, upper, 0);

	if (!err)
		*newdentry = dget(c->tmpfile ? upper : temp);
	dput(upper);

	return err;
}

static int ovl_get_tmpfile(struct ovl_copy_up_ctx *c, struct dentry **tempp)
{
	int err;
	struct dentry *temp;
	const struct cred *old_creds = NULL;
	struct cred *new_creds = NULL;
	struct cattr cattr = {
		/* Can't properly set mode on creation because of the umask */
		.mode = c->stat.mode & S_IFMT,
		.rdev = c->stat.rdev,
		.link = c->link
	};

	err = security_inode_copy_up(c->dentry, &new_creds);
	if (err < 0)
		goto out;

	if (new_creds)
		old_creds = override_creds(new_creds);

	if (c->tmpfile) {
		temp = ovl_do_tmpfile(c->workdir, c->stat.mode);
		if (IS_ERR(temp))
			goto temp_err;
	} else {
		temp = ovl_lookup_temp(c->workdir);
		if (IS_ERR(temp))
			goto temp_err;

		err = ovl_create_real(d_inode(c->workdir), temp, &cattr,
				      NULL, true);
		if (err) {
			dput(temp);
			goto out;
		}
	}
	err = 0;
	*tempp = temp;
out:
	if (new_creds) {
		revert_creds(old_creds);
		put_cred(new_creds);
	}

	return err;

temp_err:
	err = PTR_ERR(temp);
	goto out;
}

static int ovl_copy_up_inode(struct ovl_copy_up_ctx *c, struct dentry *temp)
{
	int err;

	if (S_ISREG(c->stat.mode)) {
		struct path upperpath;

		ovl_path_upper(c->dentry, &upperpath);
		BUG_ON(upperpath.dentry != NULL);
		upperpath.dentry = temp;

		err = ovl_copy_up_data(&c->lowerpath, &upperpath, c->stat.size);
		if (err)
			return err;
	}

	err = ovl_copy_xattr(c->lowerpath.dentry, temp);
	if (err)
		return err;

	inode_lock(temp->d_inode);
	err = ovl_set_attr(temp, &c->stat);
	inode_unlock(temp->d_inode);
	if (err)
		return err;

	/*
	 * Store identifier of lower inode in upper inode xattr to
	 * allow lookup of the copy up origin inode.
	 *
	 * Don't set origin when we are breaking the association with a lower
	 * hard link.
	 */
	if (c->origin) {
		err = ovl_set_origin(c->dentry, c->lowerpath.dentry, temp);
		if (err)
			return err;
	}

	return 0;
}

static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c)
{
	struct inode *udir = c->destdir->d_inode;
	struct dentry *newdentry = NULL;
	struct dentry *temp = NULL;
	int err;

	err = ovl_get_tmpfile(c, &temp);
	if (err)
		goto out;

	err = ovl_copy_up_inode(c, temp);
	if (err)
		goto out_cleanup;

	if (c->tmpfile) {
		inode_lock_nested(udir, I_MUTEX_PARENT);
		err = ovl_install_temp(c, temp, &newdentry);
		inode_unlock(udir);
	} else {
		err = ovl_install_temp(c, temp, &newdentry);
	}
	if (err)
		goto out_cleanup;

	ovl_inode_update(d_inode(c->dentry), newdentry);
out:
	dput(temp);
	return err;

out_cleanup:
	if (!c->tmpfile)
		ovl_cleanup(d_inode(c->workdir), temp);
	goto out;
}

/*
 * Copy up a single dentry
 *
 * All renames start with copy up of source if necessary.  The actual
 * rename will only proceed once the copy up was successful.  Copy up uses
 * upper parent i_mutex for exclusion.  Since rename can change d_parent it
 * is possible that the copy up will lock the old parent.  At that point
 * the file will have already been copied up anyway.
 */
static int ovl_do_copy_up(struct ovl_copy_up_ctx *c)
{
	int err;
	struct ovl_fs *ofs = c->dentry->d_sb->s_fs_info;
	bool indexed = false;

	if (ovl_indexdir(c->dentry->d_sb) && !S_ISDIR(c->stat.mode) &&
	    c->stat.nlink > 1)
		indexed = true;

	if (S_ISDIR(c->stat.mode) || c->stat.nlink == 1 || indexed)
		c->origin = true;

	if (indexed) {
		c->destdir = ovl_indexdir(c->dentry->d_sb);
		err = ovl_get_index_name(c->lowerpath.dentry, &c->destname);
		if (err)
			return err;
	} else {
		/*
		 * Mark parent "impure" because it may now contain non-pure
		 * upper
		 */
		err = ovl_set_impure(c->parent, c->destdir);
		if (err)
			return err;
	}

	/* Should we copyup with O_TMPFILE or with workdir? */
	if (S_ISREG(c->stat.mode) && ofs->tmpfile) {
		c->tmpfile = true;
		err = ovl_copy_up_locked(c);
	} else {
		err = -EIO;
		if (lock_rename(c->workdir, c->destdir) != NULL) {
			pr_err("overlayfs: failed to lock workdir+upperdir\n");
		} else {
			err = ovl_copy_up_locked(c);
			unlock_rename(c->workdir, c->destdir);
		}
	}

	if (indexed) {
		if (!err)
			ovl_set_flag(OVL_INDEX, d_inode(c->dentry));
		kfree(c->destname.name);
	} else if (!err) {
		struct inode *udir = d_inode(c->destdir);

		/* Restore timestamps on parent (best effort) */
		inode_lock(udir);
		ovl_set_timestamps(c->destdir, &c->pstat);
		inode_unlock(udir);

		ovl_dentry_set_upper_alias(c->dentry);
	}

	return err;
}

static int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
			   int flags)
{
	int err;
	DEFINE_DELAYED_CALL(done);
	struct path parentpath;
	struct ovl_copy_up_ctx ctx = {
		.parent = parent,
		.dentry = dentry,
		.workdir = ovl_workdir(dentry),
	};

	if (WARN_ON(!ctx.workdir))
		return -EROFS;

	ovl_path_lower(dentry, &ctx.lowerpath);
	err = vfs_getattr(&ctx.lowerpath, &ctx.stat,
			  STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
	if (err)
		return err;

	ovl_path_upper(parent, &parentpath);
	ctx.destdir = parentpath.dentry;
	ctx.destname = dentry->d_name;

	err = vfs_getattr(&parentpath, &ctx.pstat,
			  STATX_ATIME | STATX_MTIME, AT_STATX_SYNC_AS_STAT);
	if (err)
		return err;

	/* maybe truncate regular file. this has no effect on dirs */
	if (flags & O_TRUNC)
		ctx.stat.size = 0;

	if (S_ISLNK(ctx.stat.mode)) {
		ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done);
		if (IS_ERR(ctx.link))
			return PTR_ERR(ctx.link);
	}
	ovl_do_check_copy_up(ctx.lowerpath.dentry);

	err = ovl_copy_up_start(dentry);
	/* err < 0: interrupted, err > 0: raced with another copy-up */
	if (unlikely(err)) {
		if (err > 0)
			err = 0;
	} else {
		if (!ovl_dentry_upper(dentry))
			err = ovl_do_copy_up(&ctx);
		if (!err && !ovl_dentry_has_upper_alias(dentry))
			err = ovl_link_up(&ctx);
		ovl_copy_up_end(dentry);
	}
	do_delayed_call(&done);

	return err;
}

int ovl_copy_up_flags(struct dentry *dentry, int flags)
{
	int err = 0;
	const struct cred *old_cred = ovl_override_creds(dentry->d_sb);

	while (!err) {
		struct dentry *next;
		struct dentry *parent;

		/*
		 * Check if copy-up has happened as well as for upper alias (in
		 * case of hard links) is there.
		 *
		 * Both checks are lockless:
		 *  - false negatives: will recheck under oi->lock
		 *  - false positives:
		 *    + ovl_dentry_upper() uses memory barriers to ensure the
		 *      upper dentry is up-to-date
		 *    + ovl_dentry_has_upper_alias() relies on locking of
		 *      upper parent i_rwsem to prevent reordering copy-up
		 *      with rename.
		 */
		if (ovl_dentry_upper(dentry) &&
		    ovl_dentry_has_upper_alias(dentry))
			break;

		next = dget(dentry);
		/* find the topmost dentry not yet copied up */
		for (;;) {
			parent = dget_parent(next);

			if (ovl_dentry_upper(parent))
				break;

			dput(next);
			next = parent;
		}

		err = ovl_copy_up_one(parent, next, flags);

		dput(parent);
		dput(next);
	}
	revert_creds(old_cred);

	return err;
}

int ovl_copy_up(struct dentry *dentry)
{
	return ovl_copy_up_flags(dentry, 0);
}
Commit	Line	Data
e9be9d5e MS	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
fb5bb2c3	10	#include <linux/module.h>
e9be9d5e MS	11	#include <linux/fs.h>
	12	#include <linux/slab.h>
	13	#include <linux/file.h>
	14	#include <linux/splice.h>
	15	#include <linux/xattr.h>
	16	#include <linux/security.h>
	17	#include <linux/uaccess.h>
174cd4b1	18	#include <linux/sched/signal.h>
5b825c3a	19	#include <linux/cred.h>
e9be9d5e	20	#include <linux/namei.h>
fb5bb2c3 DH	21	#include <linux/fdtable.h>
fb5bb2c3 DH	22	#include <linux/ratelimit.h>
3a1e819b	23	#include <linux/exportfs.h>
e9be9d5e	24	#include "overlayfs.h"
d8514d8e	25	#include "ovl_entry.h"
e9be9d5e MS	26
	27	#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
	28
fb5bb2c3 DH	29	static bool __read_mostly ovl_check_copy_up;
	30	module_param_named(check_copy_up, ovl_check_copy_up, bool,
	31	S_IWUSR \| S_IRUGO);
	32	MODULE_PARM_DESC(ovl_check_copy_up,
	33	"Warn on copy-up when causing process also has a R/O fd open");
	34
	35	static int ovl_check_fd(const void data, struct file f, unsigned int fd)
	36	{
	37	const struct dentry *dentry = data;
	38
45063097	39	if (file_inode(f) == d_inode(dentry))
fb5bb2c3 DH	40	pr_warn_ratelimited("overlayfs: Warning: Copying up %pD, but open R/O on fd %u which will cease to be coherent [pid=%d %s]\n",
	41	f, fd, current->pid, current->comm);
	42	return 0;
	43	}
	44
	45	/*
	46	* Check the fds open by this process and warn if something like the following
	47	* scenario is about to occur:
	48	*
	49	* fd1 = open("foo", O_RDONLY);
	50	* fd2 = open("foo", O_RDWR);
	51	*/
	52	static void ovl_do_check_copy_up(struct dentry *dentry)
	53	{
	54	if (ovl_check_copy_up)
	55	iterate_fd(current->files, 0, ovl_check_fd, dentry);
	56	}
	57
e9be9d5e MS	58	int ovl_copy_xattr(struct dentry old, struct dentry new)
e9be9d5e MS	59	{
e4ad29fa VC	60	ssize_t list_size, size, value_size = 0;
	61	char buf, name, *value = NULL;
	62	int uninitialized_var(error);
8b326c61	63	size_t slen;
e9be9d5e	64
5d6c3191 AG	65	if (!(old->d_inode->i_opflags & IOP_XATTR) \|\|
5d6c3191 AG	66	!(new->d_inode->i_opflags & IOP_XATTR))
e9be9d5e MS	67	return 0;
	68
	69	list_size = vfs_listxattr(old, NULL, 0);
	70	if (list_size <= 0) {
	71	if (list_size == -EOPNOTSUPP)
	72	return 0;
	73	return list_size;
	74	}
	75
	76	buf = kzalloc(list_size, GFP_KERNEL);
	77	if (!buf)
	78	return -ENOMEM;
	79
e9be9d5e MS	80	list_size = vfs_listxattr(old, buf, list_size);
	81	if (list_size <= 0) {
	82	error = list_size;
e4ad29fa	83	goto out;
e9be9d5e MS	84	}
e9be9d5e MS	85
8b326c61 MS	86	for (name = buf; list_size; name += slen) {
	87	slen = strnlen(name, list_size) + 1;
	88
	89	/* underlying fs providing us with an broken xattr list? */
	90	if (WARN_ON(slen > list_size)) {
	91	error = -EIO;
	92	break;
	93	}
	94	list_size -= slen;
	95
0956254a MS	96	if (ovl_is_private_xattr(name))
0956254a MS	97	continue;
e4ad29fa VC	98	retry:
	99	size = vfs_getxattr(old, name, value, value_size);
	100	if (size == -ERANGE)
	101	size = vfs_getxattr(old, name, NULL, 0);
	102
97daf8b9	103	if (size < 0) {
e9be9d5e	104	error = size;
e4ad29fa	105	break;
e9be9d5e	106	}
e4ad29fa VC	107
	108	if (size > value_size) {
	109	void *new;
	110
	111	new = krealloc(value, size, GFP_KERNEL);
	112	if (!new) {
	113	error = -ENOMEM;
	114	break;
	115	}
	116	value = new;
	117	value_size = size;
	118	goto retry;
	119	}
	120
121ab822 VG	121	error = security_inode_copy_up_xattr(name);
	122	if (error < 0 && error != -EOPNOTSUPP)
	123	break;
	124	if (error == 1) {
	125	error = 0;
	126	continue; /* Discard */
	127	}
e9be9d5e MS	128	error = vfs_setxattr(new, name, value, size, 0);
e9be9d5e MS	129	if (error)
e4ad29fa	130	break;
e9be9d5e	131	}
e9be9d5e MS	132	kfree(value);
	133	out:
	134	kfree(buf);
	135	return error;
	136	}
	137
	138	static int ovl_copy_up_data(struct path old, struct path new, loff_t len)
	139	{
	140	struct file *old_file;
	141	struct file *new_file;
	142	loff_t old_pos = 0;
	143	loff_t new_pos = 0;
	144	int error = 0;
	145
	146	if (len == 0)
	147	return 0;
	148
0480334f	149	old_file = ovl_path_open(old, O_LARGEFILE \| O_RDONLY);
e9be9d5e MS	150	if (IS_ERR(old_file))
	151	return PTR_ERR(old_file);
	152
0480334f	153	new_file = ovl_path_open(new, O_LARGEFILE \| O_WRONLY);
e9be9d5e MS	154	if (IS_ERR(new_file)) {
	155	error = PTR_ERR(new_file);
	156	goto out_fput;
	157	}
	158
2ea98466 AG	159	/* Try to use clone_file_range to clone up within the same fs */
	160	error = vfs_clone_file_range(old_file, 0, new_file, 0, len);
	161	if (!error)
	162	goto out;
	163	/* Couldn't clone, so now we try to copy the data */
	164	error = 0;
	165
e9be9d5e MS	166	/* FIXME: copy up sparse files efficiently */
	167	while (len) {
	168	size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
	169	long bytes;
	170
	171	if (len < this_len)
	172	this_len = len;
	173
	174	if (signal_pending_state(TASK_KILLABLE, current)) {
	175	error = -EINTR;
	176	break;
	177	}
	178
	179	bytes = do_splice_direct(old_file, &old_pos,
	180	new_file, &new_pos,
	181	this_len, SPLICE_F_MOVE);
	182	if (bytes <= 0) {
	183	error = bytes;
	184	break;
	185	}
	186	WARN_ON(old_pos != new_pos);
	187
	188	len -= bytes;
	189	}
2ea98466	190	out:
641089c1 MS	191	if (!error)
641089c1 MS	192	error = vfs_fsync(new_file, 0);
e9be9d5e MS	193	fput(new_file);
	194	out_fput:
	195	fput(old_file);
	196	return error;
	197	}
	198
e9be9d5e MS	199	static int ovl_set_timestamps(struct dentry upperdentry, struct kstat stat)
	200	{
	201	struct iattr attr = {
	202	.ia_valid =
	203	ATTR_ATIME \| ATTR_MTIME \| ATTR_ATIME_SET \| ATTR_MTIME_SET,
	204	.ia_atime = stat->atime,
	205	.ia_mtime = stat->mtime,
	206	};
	207
	208	return notify_change(upperdentry, &attr, NULL);
	209	}
	210
	211	int ovl_set_attr(struct dentry upperdentry, struct kstat stat)
	212	{
	213	int err = 0;
	214
	215	if (!S_ISLNK(stat->mode)) {
	216	struct iattr attr = {
	217	.ia_valid = ATTR_MODE,
	218	.ia_mode = stat->mode,
	219	};
	220	err = notify_change(upperdentry, &attr, NULL);
	221	}
	222	if (!err) {
	223	struct iattr attr = {
	224	.ia_valid = ATTR_UID \| ATTR_GID,
	225	.ia_uid = stat->uid,
	226	.ia_gid = stat->gid,
	227	};
	228	err = notify_change(upperdentry, &attr, NULL);
	229	}
	230	if (!err)
	231	ovl_set_timestamps(upperdentry, stat);
	232
	233	return err;
e9be9d5e MS	234	}
e9be9d5e MS	235
54fb347e	236	struct ovl_fh ovl_encode_fh(struct dentry lower, bool is_upper)
3a1e819b AG	237	{
	238	struct ovl_fh *fh;
	239	int fh_type, fh_len, dwords;
	240	void *buf;
	241	int buflen = MAX_HANDLE_SZ;
02bcd157	242	uuid_t *uuid = &lower->d_sb->s_uuid;
3a1e819b AG	243
	244	buf = kmalloc(buflen, GFP_TEMPORARY);
	245	if (!buf)
	246	return ERR_PTR(-ENOMEM);
	247
	248	/*
	249	* We encode a non-connectable file handle for non-dir, because we
	250	* only need to find the lower inode number and we don't want to pay
	251	* the price or reconnecting the dentry.
	252	*/
	253	dwords = buflen >> 2;
	254	fh_type = exportfs_encode_fh(lower, buf, &dwords, 0);
	255	buflen = (dwords << 2);
	256
	257	fh = ERR_PTR(-EIO);
	258	if (WARN_ON(fh_type < 0) \|\|
	259	WARN_ON(buflen > MAX_HANDLE_SZ) \|\|
	260	WARN_ON(fh_type == FILEID_INVALID))
	261	goto out;
	262
	263	BUILD_BUG_ON(MAX_HANDLE_SZ + offsetof(struct ovl_fh, fid) > 255);
	264	fh_len = offsetof(struct ovl_fh, fid) + buflen;
	265	fh = kmalloc(fh_len, GFP_KERNEL);
	266	if (!fh) {
	267	fh = ERR_PTR(-ENOMEM);
	268	goto out;
	269	}
	270
	271	fh->version = OVL_FH_VERSION;
	272	fh->magic = OVL_FH_MAGIC;
	273	fh->type = fh_type;
	274	fh->flags = OVL_FH_FLAG_CPU_ENDIAN;
54fb347e AG	275	/*
	276	* When we will want to decode an overlay dentry from this handle
	277	* and all layers are on the same fs, if we get a disconncted real
	278	* dentry when we decode fid, the only way to tell if we should assign
	279	* it to upperdentry or to lowerstack is by checking this flag.
	280	*/
	281	if (is_upper)
	282	fh->flags \|= OVL_FH_FLAG_PATH_UPPER;
3a1e819b AG	283	fh->len = fh_len;
	284	fh->uuid = *uuid;
	285	memcpy(fh->fid, buf, buflen);
	286
	287	out:
	288	kfree(buf);
	289	return fh;
	290	}
	291
	292	static int ovl_set_origin(struct dentry dentry, struct dentry lower,
	293	struct dentry *upper)
	294	{
3a1e819b AG	295	const struct ovl_fh *fh = NULL;
	296	int err;
	297
	298	/*
	299	* When lower layer doesn't support export operations store a 'null' fh,
	300	* so we can use the overlay.origin xattr to distignuish between a copy
	301	* up and a pure upper inode.
	302	*/
02bcd157	303	if (ovl_can_decode_fh(lower->d_sb)) {
54fb347e	304	fh = ovl_encode_fh(lower, false);
3a1e819b AG	305	if (IS_ERR(fh))
	306	return PTR_ERR(fh);
	307	}
	308
6266d465 MS	309	/*
	310	* Do not fail when upper doesn't support xattrs.
	311	*/
	312	err = ovl_check_setxattr(dentry, upper, OVL_XATTR_ORIGIN, fh,
	313	fh ? fh->len : 0, 0);
3a1e819b AG	314	kfree(fh);
	315
	316	return err;
	317	}
	318
f4439de1 AG	319	struct ovl_copy_up_ctx {
	320	struct dentry *parent;
	321	struct dentry *dentry;
	322	struct path lowerpath;
	323	struct kstat stat;
	324	struct kstat pstat;
	325	const char *link;
	326	struct dentry *destdir;
	327	struct qstr destname;
	328	struct dentry *workdir;
	329	bool tmpfile;
	330	bool origin;
	331	};
	332
	333	static int ovl_link_up(struct ovl_copy_up_ctx *c)
59be0971 AG	334	{
	335	int err;
	336	struct dentry *upper;
f4439de1	337	struct dentry *upperdir = ovl_dentry_upper(c->parent);
59be0971 AG	338	struct inode *udir = d_inode(upperdir);
59be0971 AG	339
f4439de1 AG	340	/* Mark parent "impure" because it may now contain non-pure upper */
	341	err = ovl_set_impure(c->parent, upperdir);
	342	if (err)
	343	return err;
	344
	345	err = ovl_set_nlink_lower(c->dentry);
5f8415d6 AG	346	if (err)
	347	return err;
	348
59be0971	349	inode_lock_nested(udir, I_MUTEX_PARENT);
f4439de1 AG	350	upper = lookup_one_len(c->dentry->d_name.name, upperdir,
f4439de1 AG	351	c->dentry->d_name.len);
59be0971 AG	352	err = PTR_ERR(upper);
59be0971 AG	353	if (!IS_ERR(upper)) {
f4439de1 AG	354	err = ovl_do_link(ovl_dentry_upper(c->dentry), udir, upper,
f4439de1 AG	355	true);
59be0971 AG	356	dput(upper);
59be0971 AG	357
f4439de1 AG	358	if (!err) {
	359	/* Restore timestamps on parent (best effort) */
	360	ovl_set_timestamps(upperdir, &c->pstat);
	361	ovl_dentry_set_upper_alias(c->dentry);
	362	}
59be0971 AG	363	}
59be0971 AG	364	inode_unlock(udir);
f4439de1	365	ovl_set_nlink_upper(c->dentry);
59be0971 AG	366
	367	return err;
	368	}
	369
23f0ab13 MS	370	static int ovl_install_temp(struct ovl_copy_up_ctx c, struct dentry temp,
23f0ab13 MS	371	struct dentry **newdentry)
15932c41 AG	372	{
	373	int err;
	374	struct dentry *upper;
59be0971	375	struct inode *udir = d_inode(c->destdir);
15932c41	376
59be0971	377	upper = lookup_one_len(c->destname.name, c->destdir, c->destname.len);
15932c41 AG	378	if (IS_ERR(upper))
	379	return PTR_ERR(upper);
	380
23f0ab13	381	if (c->tmpfile)
15932c41 AG	382	err = ovl_do_link(temp, udir, upper, true);
15932c41 AG	383	else
23f0ab13	384	err = ovl_do_rename(d_inode(c->workdir), temp, udir, upper, 0);
15932c41	385
59be0971	386	if (!err)
23f0ab13	387	*newdentry = dget(c->tmpfile ? upper : temp);
15932c41 AG	388	dput(upper);
	389
	390	return err;
	391	}
	392
23f0ab13	393	static int ovl_get_tmpfile(struct ovl_copy_up_ctx c, struct dentry *tempp)
e9be9d5e	394	{
e9be9d5e	395	int err;
7d90b853	396	struct dentry *temp;
d8ad8b49 VG	397	const struct cred *old_creds = NULL;
d8ad8b49 VG	398	struct cred *new_creds = NULL;
32a3d848 AV	399	struct cattr cattr = {
32a3d848 AV	400	/* Can't properly set mode on creation because of the umask */
23f0ab13 MS	401	.mode = c->stat.mode & S_IFMT,
	402	.rdev = c->stat.rdev,
	403	.link = c->link
32a3d848	404	};
e9be9d5e	405
23f0ab13	406	err = security_inode_copy_up(c->dentry, &new_creds);
d8ad8b49	407	if (err < 0)
e85f82ff	408	goto out;
d8ad8b49 VG	409
	410	if (new_creds)
	411	old_creds = override_creds(new_creds);
	412
23f0ab13 MS	413	if (c->tmpfile) {
23f0ab13 MS	414	temp = ovl_do_tmpfile(c->workdir, c->stat.mode);
7d90b853 MS	415	if (IS_ERR(temp))
	416	goto temp_err;
	417	} else {
23f0ab13	418	temp = ovl_lookup_temp(c->workdir);
7d90b853 MS	419	if (IS_ERR(temp))
	420	goto temp_err;
	421
23f0ab13	422	err = ovl_create_real(d_inode(c->workdir), temp, &cattr,
7d90b853 MS	423	NULL, true);
	424	if (err) {
	425	dput(temp);
	426	goto out;
	427	}
8137ae26	428	}
7d90b853 MS	429	err = 0;
	430	*tempp = temp;
	431	out:
d8ad8b49 VG	432	if (new_creds) {
	433	revert_creds(old_creds);
	434	put_cred(new_creds);
	435	}
	436
7d90b853 MS	437	return err;
	438
	439	temp_err:
	440	err = PTR_ERR(temp);
	441	goto out;
	442	}
	443
23f0ab13	444	static int ovl_copy_up_inode(struct ovl_copy_up_ctx c, struct dentry temp)
7d90b853	445	{
7d90b853 MS	446	int err;
7d90b853 MS	447
23f0ab13	448	if (S_ISREG(c->stat.mode)) {
e9be9d5e	449	struct path upperpath;
f134f244	450
23f0ab13	451	ovl_path_upper(c->dentry, &upperpath);
e9be9d5e	452	BUG_ON(upperpath.dentry != NULL);
42f269b9	453	upperpath.dentry = temp;
e9be9d5e	454
23f0ab13	455	err = ovl_copy_up_data(&c->lowerpath, &upperpath, c->stat.size);
e9be9d5e	456	if (err)
02209d10	457	return err;
e9be9d5e MS	458	}
e9be9d5e MS	459
23f0ab13	460	err = ovl_copy_xattr(c->lowerpath.dentry, temp);
e9be9d5e	461	if (err)
02209d10	462	return err;
e9be9d5e	463
42f269b9	464	inode_lock(temp->d_inode);
23f0ab13	465	err = ovl_set_attr(temp, &c->stat);
42f269b9	466	inode_unlock(temp->d_inode);
e9be9d5e	467	if (err)
02209d10	468	return err;
e9be9d5e	469
3a1e819b AG	470	/*
	471	* Store identifier of lower inode in upper inode xattr to
	472	* allow lookup of the copy up origin inode.
fbaf94ee MS	473	*
	474	* Don't set origin when we are breaking the association with a lower
	475	* hard link.
3a1e819b	476	*/
59be0971	477	if (c->origin) {
23f0ab13	478	err = ovl_set_origin(c->dentry, c->lowerpath.dentry, temp);
fbaf94ee	479	if (err)
02209d10	480	return err;
fbaf94ee	481	}
3a1e819b	482
02209d10 AG	483	return 0;
	484	}
	485
23f0ab13	486	static int ovl_copy_up_locked(struct ovl_copy_up_ctx *c)
02209d10	487	{
59be0971	488	struct inode *udir = c->destdir->d_inode;
02209d10 AG	489	struct dentry *newdentry = NULL;
	490	struct dentry *temp = NULL;
	491	int err;
	492
23f0ab13	493	err = ovl_get_tmpfile(c, &temp);
02209d10 AG	494	if (err)
	495	goto out;
	496
23f0ab13	497	err = ovl_copy_up_inode(c, temp);
02209d10 AG	498	if (err)
	499	goto out_cleanup;
	500
23f0ab13	501	if (c->tmpfile) {
15932c41	502	inode_lock_nested(udir, I_MUTEX_PARENT);
23f0ab13	503	err = ovl_install_temp(c, temp, &newdentry);
15932c41 AG	504	inode_unlock(udir);
15932c41 AG	505	} else {
23f0ab13	506	err = ovl_install_temp(c, temp, &newdentry);
e85f82ff	507	}
e9be9d5e MS	508	if (err)
	509	goto out_cleanup;
	510
23f0ab13	511	ovl_inode_update(d_inode(c->dentry), newdentry);
e85f82ff	512	out:
42f269b9	513	dput(temp);
e9be9d5e MS	514	return err;
	515
	516	out_cleanup:
23f0ab13 MS	517	if (!c->tmpfile)
23f0ab13 MS	518	ovl_cleanup(d_inode(c->workdir), temp);
e85f82ff	519	goto out;
e9be9d5e MS	520	}
	521
	522	/*
	523	* Copy up a single dentry
	524	*
a6c60655 MS	525	* All renames start with copy up of source if necessary. The actual
	526	* rename will only proceed once the copy up was successful. Copy up uses
	527	* upper parent i_mutex for exclusion. Since rename can change d_parent it
	528	* is possible that the copy up will lock the old parent. At that point
	529	* the file will have already been copied up anyway.
e9be9d5e	530	*/
a6fb235a	531	static int ovl_do_copy_up(struct ovl_copy_up_ctx *c)
e9be9d5e	532	{
e9be9d5e	533	int err;
23f0ab13	534	struct ovl_fs *ofs = c->dentry->d_sb->s_fs_info;
59be0971	535	bool indexed = false;
e9be9d5e	536
59be0971 AG	537	if (ovl_indexdir(c->dentry->d_sb) && !S_ISDIR(c->stat.mode) &&
	538	c->stat.nlink > 1)
	539	indexed = true;
	540
	541	if (S_ISDIR(c->stat.mode) \|\| c->stat.nlink == 1 \|\| indexed)
	542	c->origin = true;
	543
	544	if (indexed) {
	545	c->destdir = ovl_indexdir(c->dentry->d_sb);
	546	err = ovl_get_index_name(c->lowerpath.dentry, &c->destname);
	547	if (err)
	548	return err;
	549	} else {
	550	/*
	551	* Mark parent "impure" because it may now contain non-pure
	552	* upper
	553	*/
	554	err = ovl_set_impure(c->parent, c->destdir);
	555	if (err)
	556	return err;
	557	}
e9be9d5e	558
01ad3eb8	559	/* Should we copyup with O_TMPFILE or with workdir? */
23f0ab13	560	if (S_ISREG(c->stat.mode) && ofs->tmpfile) {
23f0ab13	561	c->tmpfile = true;
59be0971 AG	562	err = ovl_copy_up_locked(c);
	563	} else {
	564	err = -EIO;
	565	if (lock_rename(c->workdir, c->destdir) != NULL) {
	566	pr_err("overlayfs: failed to lock workdir+upperdir\n");
	567	} else {
	568	err = ovl_copy_up_locked(c);
	569	unlock_rename(c->workdir, c->destdir);
	570	}
01ad3eb8 AG	571	}
01ad3eb8 AG	572
59be0971 AG	573	if (indexed) {
	574	if (!err)
	575	ovl_set_flag(OVL_INDEX, d_inode(c->dentry));
	576	kfree(c->destname.name);
	577	} else if (!err) {
	578	struct inode *udir = d_inode(c->destdir);
	579
	580	/* Restore timestamps on parent (best effort) */
	581	inode_lock(udir);
	582	ovl_set_timestamps(c->destdir, &c->pstat);
	583	inode_unlock(udir);
	584
	585	ovl_dentry_set_upper_alias(c->dentry);
e9be9d5e MS	586	}
e9be9d5e MS	587
a6fb235a MS	588	return err;
	589	}
	590
	591	static int ovl_copy_up_one(struct dentry parent, struct dentry dentry,
	592	int flags)
	593	{
	594	int err;
	595	DEFINE_DELAYED_CALL(done);
	596	struct path parentpath;
	597	struct ovl_copy_up_ctx ctx = {
	598	.parent = parent,
	599	.dentry = dentry,
	600	.workdir = ovl_workdir(dentry),
	601	};
	602
	603	if (WARN_ON(!ctx.workdir))
	604	return -EROFS;
	605
	606	ovl_path_lower(dentry, &ctx.lowerpath);
	607	err = vfs_getattr(&ctx.lowerpath, &ctx.stat,
	608	STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
	609	if (err)
	610	return err;
	611
	612	ovl_path_upper(parent, &parentpath);
59be0971 AG	613	ctx.destdir = parentpath.dentry;
59be0971 AG	614	ctx.destname = dentry->d_name;
a6fb235a MS	615
	616	err = vfs_getattr(&parentpath, &ctx.pstat,
	617	STATX_ATIME \| STATX_MTIME, AT_STATX_SYNC_AS_STAT);
	618	if (err)
	619	return err;
	620
	621	/* maybe truncate regular file. this has no effect on dirs */
	622	if (flags & O_TRUNC)
	623	ctx.stat.size = 0;
	624
	625	if (S_ISLNK(ctx.stat.mode)) {
	626	ctx.link = vfs_get_link(ctx.lowerpath.dentry, &done);
	627	if (IS_ERR(ctx.link))
	628	return PTR_ERR(ctx.link);
	629	}
	630	ovl_do_check_copy_up(ctx.lowerpath.dentry);
	631
fd210b7d MS	632	err = ovl_copy_up_start(dentry);
	633	/* err < 0: interrupted, err > 0: raced with another copy-up */
	634	if (unlikely(err)) {
	635	if (err > 0)
	636	err = 0;
	637	} else {
59be0971 AG	638	if (!ovl_dentry_upper(dentry))
	639	err = ovl_do_copy_up(&ctx);
	640	if (!err && !ovl_dentry_has_upper_alias(dentry))
f4439de1	641	err = ovl_link_up(&ctx);
fd210b7d MS	642	ovl_copy_up_end(dentry);
fd210b7d MS	643	}
7764235b	644	do_delayed_call(&done);
e9be9d5e MS	645
	646	return err;
	647	}
	648
9aba6521	649	int ovl_copy_up_flags(struct dentry *dentry, int flags)
e9be9d5e	650	{
8eac98b8 VG	651	int err = 0;
8eac98b8 VG	652	const struct cred *old_cred = ovl_override_creds(dentry->d_sb);
e9be9d5e	653
e9be9d5e MS	654	while (!err) {
	655	struct dentry *next;
	656	struct dentry *parent;
e9be9d5e	657
59be0971 AG	658	/*
	659	* Check if copy-up has happened as well as for upper alias (in
	660	* case of hard links) is there.
	661	*
	662	* Both checks are lockless:
	663	* - false negatives: will recheck under oi->lock
	664	* - false positives:
	665	* + ovl_dentry_upper() uses memory barriers to ensure the
	666	* upper dentry is up-to-date
	667	* + ovl_dentry_has_upper_alias() relies on locking of
	668	* upper parent i_rwsem to prevent reordering copy-up
	669	* with rename.
	670	*/
	671	if (ovl_dentry_upper(dentry) &&
	672	ovl_dentry_has_upper_alias(dentry))
e9be9d5e MS	673	break;
	674
	675	next = dget(dentry);
	676	/* find the topmost dentry not yet copied up */
	677	for (;;) {
	678	parent = dget_parent(next);
	679
59be0971	680	if (ovl_dentry_upper(parent))
e9be9d5e MS	681	break;
	682
	683	dput(next);
	684	next = parent;
	685	}
	686
a6fb235a	687	err = ovl_copy_up_one(parent, next, flags);
e9be9d5e MS	688
	689	dput(parent);
	690	dput(next);
	691	}
8eac98b8	692	revert_creds(old_cred);
e9be9d5e MS	693
	694	return err;
	695	}
9aba6521 AG	696
	697	int ovl_copy_up(struct dentry *dentry)
	698	{
	699	return ovl_copy_up_flags(dentry, 0);
	700	}