copy_up.c 9.4 KB
Newer Older
M
Miklos Szeredi 已提交
1 2 3 4 5 6 7 8 9
/*
 *
 * 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.
 */

10
#include <linux/module.h>
M
Miklos Szeredi 已提交
11 12 13 14 15 16 17 18 19
#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.h>
#include <linux/namei.h>
20 21
#include <linux/fdtable.h>
#include <linux/ratelimit.h>
M
Miklos Szeredi 已提交
22 23 24 25
#include "overlayfs.h"

#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)

26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
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 (f->f_inode == 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);
}

M
Miklos Szeredi 已提交
55 56
int ovl_copy_xattr(struct dentry *old, struct dentry *new)
{
57 58 59
	ssize_t list_size, size, value_size = 0;
	char *buf, *name, *value = NULL;
	int uninitialized_var(error);
60
	size_t slen;
M
Miklos Szeredi 已提交
61

62 63
	if (!(old->d_inode->i_opflags & IOP_XATTR) ||
	    !(new->d_inode->i_opflags & IOP_XATTR))
M
Miklos Szeredi 已提交
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
		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;
80
		goto out;
M
Miklos Szeredi 已提交
81 82
	}

83 84 85 86 87 88 89 90 91 92
	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;

M
Miklos Szeredi 已提交
93 94
		if (ovl_is_private_xattr(name))
			continue;
95 96 97 98 99
retry:
		size = vfs_getxattr(old, name, value, value_size);
		if (size == -ERANGE)
			size = vfs_getxattr(old, name, NULL, 0);

M
Miklos Szeredi 已提交
100
		if (size < 0) {
M
Miklos Szeredi 已提交
101
			error = size;
102
			break;
M
Miklos Szeredi 已提交
103
		}
104 105 106 107 108 109 110 111 112 113 114 115 116 117

		if (size > value_size) {
			void *new;

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

118 119 120 121 122 123 124
		error = security_inode_copy_up_xattr(name);
		if (error < 0 && error != -EOPNOTSUPP)
			break;
		if (error == 1) {
			error = 0;
			continue; /* Discard */
		}
M
Miklos Szeredi 已提交
125 126
		error = vfs_setxattr(new, name, value, size, 0);
		if (error)
127
			break;
M
Miklos Szeredi 已提交
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145
	}
	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;

146
	old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY);
M
Miklos Szeredi 已提交
147 148 149
	if (IS_ERR(old_file))
		return PTR_ERR(old_file);

150
	new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY);
M
Miklos Szeredi 已提交
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
	if (IS_ERR(new_file)) {
		error = PTR_ERR(new_file);
		goto out_fput;
	}

	/* 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;
	}

M
Miklos Szeredi 已提交
181 182
	if (!error)
		error = vfs_fsync(new_file, 0);
M
Miklos Szeredi 已提交
183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
	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;
}

static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir,
			      struct dentry *dentry, struct path *lowerpath,
228
			      struct kstat *stat, const char *link)
M
Miklos Szeredi 已提交
229 230 231 232 233 234 235
{
	struct inode *wdir = workdir->d_inode;
	struct inode *udir = upperdir->d_inode;
	struct dentry *newdentry = NULL;
	struct dentry *upper = NULL;
	umode_t mode = stat->mode;
	int err;
236 237
	const struct cred *old_creds = NULL;
	struct cred *new_creds = NULL;
M
Miklos Szeredi 已提交
238 239 240 241 242 243 244 245 246 247 248 249

	newdentry = ovl_lookup_temp(workdir, dentry);
	err = PTR_ERR(newdentry);
	if (IS_ERR(newdentry))
		goto out;

	upper = lookup_one_len(dentry->d_name.name, upperdir,
			       dentry->d_name.len);
	err = PTR_ERR(upper);
	if (IS_ERR(upper))
		goto out1;

250 251 252 253 254 255 256
	err = security_inode_copy_up(dentry, &new_creds);
	if (err < 0)
		goto out2;

	if (new_creds)
		old_creds = override_creds(new_creds);

M
Miklos Szeredi 已提交
257 258 259 260
	/* Can't properly set mode on creation because of the umask */
	stat->mode &= S_IFMT;
	err = ovl_create_real(wdir, newdentry, stat, link, NULL, true);
	stat->mode = mode;
261 262 263 264 265 266

	if (new_creds) {
		revert_creds(old_creds);
		put_cred(new_creds);
	}

M
Miklos Szeredi 已提交
267 268 269 270 271
	if (err)
		goto out2;

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

M
Miklos Szeredi 已提交
273 274 275 276 277 278 279 280 281 282 283 284 285
		ovl_path_upper(dentry, &upperpath);
		BUG_ON(upperpath.dentry != NULL);
		upperpath.dentry = newdentry;

		err = ovl_copy_up_data(lowerpath, &upperpath, stat->size);
		if (err)
			goto out_cleanup;
	}

	err = ovl_copy_xattr(lowerpath->dentry, newdentry);
	if (err)
		goto out_cleanup;

A
Al Viro 已提交
286
	inode_lock(newdentry->d_inode);
M
Miklos Szeredi 已提交
287
	err = ovl_set_attr(newdentry, stat);
A
Al Viro 已提交
288
	inode_unlock(newdentry->d_inode);
M
Miklos Szeredi 已提交
289 290 291 292 293 294 295 296
	if (err)
		goto out_cleanup;

	err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
	if (err)
		goto out_cleanup;

	ovl_dentry_update(dentry, newdentry);
297
	ovl_inode_update(d_inode(dentry), d_inode(newdentry));
M
Miklos Szeredi 已提交
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
	newdentry = NULL;

	/*
	 * Non-directores become opaque when copied up.
	 */
	if (!S_ISDIR(stat->mode))
		ovl_dentry_set_opaque(dentry, true);
out2:
	dput(upper);
out1:
	dput(newdentry);
out:
	return err;

out_cleanup:
	ovl_cleanup(wdir, newdentry);
D
David Howells 已提交
314
	goto out2;
M
Miklos Szeredi 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332
}

/*
 * Copy up a single dentry
 *
 * Directory renames only allowed on "pure upper" (already created on
 * upper filesystem, never copied up).  Directories which are on lower or
 * are merged may not be renamed.  For these -EXDEV is returned and
 * userspace has to deal with it.  This means, when copying up a
 * directory we can rely on it and ancestors being stable.
 *
 * Non-directory 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.
 */
int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
333
		    struct path *lowerpath, struct kstat *stat)
M
Miklos Szeredi 已提交
334
{
M
Miklos Szeredi 已提交
335
	DEFINE_DELAYED_CALL(done);
M
Miklos Szeredi 已提交
336 337 338 339
	struct dentry *workdir = ovl_workdir(dentry);
	int err;
	struct kstat pstat;
	struct path parentpath;
M
Miklos Szeredi 已提交
340
	struct dentry *lowerdentry = lowerpath->dentry;
M
Miklos Szeredi 已提交
341 342
	struct dentry *upperdir;
	struct dentry *upperdentry;
M
Miklos Szeredi 已提交
343
	const char *link = NULL;
M
Miklos Szeredi 已提交
344

345 346 347
	if (WARN_ON(!workdir))
		return -EROFS;

M
Miklos Szeredi 已提交
348
	ovl_do_check_copy_up(lowerdentry);
349

M
Miklos Szeredi 已提交
350 351 352 353 354 355 356 357
	ovl_path_upper(parent, &parentpath);
	upperdir = parentpath.dentry;

	err = vfs_getattr(&parentpath, &pstat);
	if (err)
		return err;

	if (S_ISLNK(stat->mode)) {
M
Miklos Szeredi 已提交
358
		link = vfs_get_link(lowerdentry, &done);
M
Miklos Szeredi 已提交
359 360 361 362 363 364 365 366 367 368 369
		if (IS_ERR(link))
			return PTR_ERR(link);
	}

	err = -EIO;
	if (lock_rename(workdir, upperdir) != NULL) {
		pr_err("overlayfs: failed to lock workdir+upperdir\n");
		goto out_unlock;
	}
	upperdentry = ovl_dentry_upper(dentry);
	if (upperdentry) {
370
		/* Raced with another copy-up?  Nothing to do, then... */
M
Miklos Szeredi 已提交
371
		err = 0;
372
		goto out_unlock;
M
Miklos Szeredi 已提交
373 374 375
	}

	err = ovl_copy_up_locked(workdir, upperdir, dentry, lowerpath,
376
				 stat, link);
M
Miklos Szeredi 已提交
377 378 379 380 381 382
	if (!err) {
		/* Restore timestamps on parent (best effort) */
		ovl_set_timestamps(upperdir, &pstat);
	}
out_unlock:
	unlock_rename(workdir, upperdir);
M
Miklos Szeredi 已提交
383
	do_delayed_call(&done);
M
Miklos Szeredi 已提交
384 385 386 387 388 389

	return err;
}

int ovl_copy_up(struct dentry *dentry)
{
390 391
	int err = 0;
	const struct cred *old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
392 393 394 395 396 397 398 399

	while (!err) {
		struct dentry *next;
		struct dentry *parent;
		struct path lowerpath;
		struct kstat stat;
		enum ovl_path_type type = ovl_path_type(dentry);

M
Miklos Szeredi 已提交
400
		if (OVL_TYPE_UPPER(type))
M
Miklos Szeredi 已提交
401 402 403 404 405 406 407 408
			break;

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

			type = ovl_path_type(parent);
M
Miklos Szeredi 已提交
409
			if (OVL_TYPE_UPPER(type))
M
Miklos Szeredi 已提交
410 411 412 413 414 415 416 417 418
				break;

			dput(next);
			next = parent;
		}

		ovl_path_lower(next, &lowerpath);
		err = vfs_getattr(&lowerpath, &stat);
		if (!err)
419
			err = ovl_copy_up_one(parent, next, &lowerpath, &stat);
M
Miklos Szeredi 已提交
420 421 422 423

		dput(parent);
		dput(next);
	}
424
	revert_creds(old_cred);
M
Miklos Szeredi 已提交
425 426 427

	return err;
}