super.c 23.1 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 <uapi/linux/magic.h>
M
Miklos Szeredi 已提交
11 12 13 14 15 16
#include <linux/fs.h>
#include <linux/namei.h>
#include <linux/xattr.h>
#include <linux/mount.h>
#include <linux/parser.h>
#include <linux/module.h>
A
Andy Whitcroft 已提交
17
#include <linux/statfs.h>
E
Erez Zadok 已提交
18
#include <linux/seq_file.h>
M
Miklos Szeredi 已提交
19
#include <linux/posix_acl_xattr.h>
M
Miklos Szeredi 已提交
20
#include "overlayfs.h"
M
Miklos Szeredi 已提交
21
#include "ovl_entry.h"
M
Miklos Szeredi 已提交
22 23 24 25 26 27 28 29

MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>");
MODULE_DESCRIPTION("Overlay filesystem");
MODULE_LICENSE("GPL");


struct ovl_dir_cache;

30 31
#define OVL_MAX_STACK 500

32 33 34 35
static bool ovl_redirect_dir_def = IS_ENABLED(CONFIG_OVERLAY_FS_REDIRECT_DIR);
module_param_named(redirect_dir, ovl_redirect_dir_def, bool, 0644);
MODULE_PARM_DESC(ovl_redirect_dir_def,
		 "Default to on or off for the redirect_dir feature");
M
Miklos Szeredi 已提交
36 37 38 39 40 41

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

	if (oe) {
42 43
		unsigned int i;

M
Miklos Szeredi 已提交
44
		dput(oe->__upperdentry);
M
Miklos Szeredi 已提交
45
		kfree(oe->redirect);
46 47
		for (i = 0; i < oe->numlower; i++)
			dput(oe->lowerstack[i].dentry);
M
Miklos Szeredi 已提交
48 49 50 51
		kfree_rcu(oe, rcu);
	}
}

52 53 54
static struct dentry *ovl_d_real(struct dentry *dentry,
				 const struct inode *inode,
				 unsigned int open_flags)
M
Miklos Szeredi 已提交
55 56 57
{
	struct dentry *real;

58
	if (!d_is_reg(dentry)) {
M
Miklos Szeredi 已提交
59 60 61 62 63
		if (!inode || inode == d_inode(dentry))
			return dentry;
		goto bug;
	}

64 65 66 67 68 69 70 71 72 73
	if (d_is_negative(dentry))
		return dentry;

	if (open_flags) {
		int err = ovl_open_maybe_copy_up(dentry, open_flags);

		if (err)
			return ERR_PTR(err);
	}

M
Miklos Szeredi 已提交
74 75 76 77 78 79 80 81
	real = ovl_dentry_upper(dentry);
	if (real && (!inode || inode == d_inode(real)))
		return real;

	real = ovl_dentry_lower(dentry);
	if (!real)
		goto bug;

M
Miklos Szeredi 已提交
82 83 84
	/* Handle recursion */
	real = d_real(real, inode, open_flags);

M
Miklos Szeredi 已提交
85 86 87
	if (!inode || inode == d_inode(real))
		return real;
bug:
M
Miklos Szeredi 已提交
88
	WARN(1, "ovl_d_real(%pd4, %s:%lu): real dentry not found\n", dentry,
M
Miklos Szeredi 已提交
89 90 91 92
	     inode ? inode->i_sb->s_id : "NULL", inode ? inode->i_ino : 0);
	return dentry;
}

93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
static int ovl_dentry_revalidate(struct dentry *dentry, unsigned int flags)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	unsigned int i;
	int ret = 1;

	for (i = 0; i < oe->numlower; i++) {
		struct dentry *d = oe->lowerstack[i].dentry;

		if (d->d_flags & DCACHE_OP_REVALIDATE) {
			ret = d->d_op->d_revalidate(d, flags);
			if (ret < 0)
				return ret;
			if (!ret) {
				if (!(flags & LOOKUP_RCU))
					d_invalidate(d);
				return -ESTALE;
			}
		}
	}
	return 1;
}

static int ovl_dentry_weak_revalidate(struct dentry *dentry, unsigned int flags)
{
	struct ovl_entry *oe = dentry->d_fsdata;
	unsigned int i;
	int ret = 1;

	for (i = 0; i < oe->numlower; i++) {
		struct dentry *d = oe->lowerstack[i].dentry;

		if (d->d_flags & DCACHE_OP_WEAK_REVALIDATE) {
			ret = d->d_op->d_weak_revalidate(d, flags);
			if (ret <= 0)
				break;
		}
	}
	return ret;
}

M
Miklos Szeredi 已提交
134 135
static const struct dentry_operations ovl_dentry_operations = {
	.d_release = ovl_dentry_release,
M
Miklos Szeredi 已提交
136
	.d_real = ovl_d_real,
M
Miklos Szeredi 已提交
137 138
};

139 140
static const struct dentry_operations ovl_reval_dentry_operations = {
	.d_release = ovl_dentry_release,
M
Miklos Szeredi 已提交
141
	.d_real = ovl_d_real,
142 143 144 145
	.d_revalidate = ovl_dentry_revalidate,
	.d_weak_revalidate = ovl_dentry_weak_revalidate,
};

M
Miklos Szeredi 已提交
146 147 148
static void ovl_put_super(struct super_block *sb)
{
	struct ovl_fs *ufs = sb->s_fs_info;
149
	unsigned i;
M
Miklos Szeredi 已提交
150 151 152

	dput(ufs->workdir);
	mntput(ufs->upper_mnt);
153 154
	for (i = 0; i < ufs->numlower; i++)
		mntput(ufs->lower_mnt[i]);
155
	kfree(ufs->lower_mnt);
M
Miklos Szeredi 已提交
156

E
Erez Zadok 已提交
157 158 159
	kfree(ufs->config.lowerdir);
	kfree(ufs->config.upperdir);
	kfree(ufs->config.workdir);
160
	put_cred(ufs->creator_cred);
M
Miklos Szeredi 已提交
161 162 163
	kfree(ufs);
}

164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
static int ovl_sync_fs(struct super_block *sb, int wait)
{
	struct ovl_fs *ufs = sb->s_fs_info;
	struct super_block *upper_sb;
	int ret;

	if (!ufs->upper_mnt)
		return 0;
	upper_sb = ufs->upper_mnt->mnt_sb;
	if (!upper_sb->s_op->sync_fs)
		return 0;

	/* real inodes have already been synced by sync_filesystem(ovl_sb) */
	down_read(&upper_sb->s_umount);
	ret = upper_sb->s_op->sync_fs(upper_sb, wait);
	up_read(&upper_sb->s_umount);
	return ret;
}

A
Andy Whitcroft 已提交
183 184 185 186 187 188
/**
 * ovl_statfs
 * @sb: The overlayfs super block
 * @buf: The struct kstatfs to fill in with stats
 *
 * Get the filesystem statistics.  As writes always target the upper layer
189
 * filesystem pass the statfs to the upper filesystem (if it exists)
A
Andy Whitcroft 已提交
190 191 192 193 194 195 196 197
 */
static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf)
{
	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;
	struct dentry *root_dentry = dentry->d_sb->s_root;
	struct path path;
	int err;

198
	ovl_path_real(root_dentry, &path);
A
Andy Whitcroft 已提交
199 200 201

	err = vfs_statfs(&path, buf);
	if (!err) {
M
Miklos Szeredi 已提交
202
		buf->f_namelen = ofs->namelen;
A
Andy Whitcroft 已提交
203 204 205 206 207 208
		buf->f_type = OVERLAYFS_SUPER_MAGIC;
	}

	return err;
}

E
Erez Zadok 已提交
209 210 211 212 213 214 215 216 217 218 219
/**
 * ovl_show_options
 *
 * Prints the mount options for a given superblock.
 * Returns zero; does not fail.
 */
static int ovl_show_options(struct seq_file *m, struct dentry *dentry)
{
	struct super_block *sb = dentry->d_sb;
	struct ovl_fs *ufs = sb->s_fs_info;

220
	seq_show_option(m, "lowerdir", ufs->config.lowerdir);
M
Miklos Szeredi 已提交
221
	if (ufs->config.upperdir) {
222 223
		seq_show_option(m, "upperdir", ufs->config.upperdir);
		seq_show_option(m, "workdir", ufs->config.workdir);
M
Miklos Szeredi 已提交
224
	}
M
Miklos Szeredi 已提交
225 226
	if (ufs->config.default_permissions)
		seq_puts(m, ",default_permissions");
227 228 229
	if (ufs->config.redirect_dir != ovl_redirect_dir_def)
		seq_printf(m, ",redirect_dir=%s",
			   ufs->config.redirect_dir ? "on" : "off");
E
Erez Zadok 已提交
230 231 232
	return 0;
}

233 234 235 236
static int ovl_remount(struct super_block *sb, int *flags, char *data)
{
	struct ovl_fs *ufs = sb->s_fs_info;

237
	if (!(*flags & MS_RDONLY) && (!ufs->upper_mnt || !ufs->workdir))
238 239 240 241 242
		return -EROFS;

	return 0;
}

M
Miklos Szeredi 已提交
243 244
static const struct super_operations ovl_super_operations = {
	.put_super	= ovl_put_super,
245
	.sync_fs	= ovl_sync_fs,
A
Andy Whitcroft 已提交
246
	.statfs		= ovl_statfs,
E
Erez Zadok 已提交
247
	.show_options	= ovl_show_options,
248
	.remount_fs	= ovl_remount,
M
Miklos Szeredi 已提交
249
	.drop_inode	= generic_delete_inode,
M
Miklos Szeredi 已提交
250 251 252 253 254 255
};

enum {
	OPT_LOWERDIR,
	OPT_UPPERDIR,
	OPT_WORKDIR,
M
Miklos Szeredi 已提交
256
	OPT_DEFAULT_PERMISSIONS,
M
Miklos Szeredi 已提交
257 258
	OPT_REDIRECT_DIR_ON,
	OPT_REDIRECT_DIR_OFF,
M
Miklos Szeredi 已提交
259 260 261 262 263 264 265
	OPT_ERR,
};

static const match_table_t ovl_tokens = {
	{OPT_LOWERDIR,			"lowerdir=%s"},
	{OPT_UPPERDIR,			"upperdir=%s"},
	{OPT_WORKDIR,			"workdir=%s"},
M
Miklos Szeredi 已提交
266
	{OPT_DEFAULT_PERMISSIONS,	"default_permissions"},
M
Miklos Szeredi 已提交
267 268
	{OPT_REDIRECT_DIR_ON,		"redirect_dir=on"},
	{OPT_REDIRECT_DIR_OFF,		"redirect_dir=off"},
M
Miklos Szeredi 已提交
269 270 271
	{OPT_ERR,			NULL}
};

M
Miklos Szeredi 已提交
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
static char *ovl_next_opt(char **s)
{
	char *sbegin = *s;
	char *p;

	if (sbegin == NULL)
		return NULL;

	for (p = sbegin; *p; p++) {
		if (*p == '\\') {
			p++;
			if (!*p)
				break;
		} else if (*p == ',') {
			*p = '\0';
			*s = p + 1;
			return sbegin;
		}
	}
	*s = NULL;
	return sbegin;
}

M
Miklos Szeredi 已提交
295 296 297 298
static int ovl_parse_opt(char *opt, struct ovl_config *config)
{
	char *p;

M
Miklos Szeredi 已提交
299
	while ((p = ovl_next_opt(&opt)) != NULL) {
M
Miklos Szeredi 已提交
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
		int token;
		substring_t args[MAX_OPT_ARGS];

		if (!*p)
			continue;

		token = match_token(p, ovl_tokens, args);
		switch (token) {
		case OPT_UPPERDIR:
			kfree(config->upperdir);
			config->upperdir = match_strdup(&args[0]);
			if (!config->upperdir)
				return -ENOMEM;
			break;

		case OPT_LOWERDIR:
			kfree(config->lowerdir);
			config->lowerdir = match_strdup(&args[0]);
			if (!config->lowerdir)
				return -ENOMEM;
			break;

		case OPT_WORKDIR:
			kfree(config->workdir);
			config->workdir = match_strdup(&args[0]);
			if (!config->workdir)
				return -ENOMEM;
			break;

M
Miklos Szeredi 已提交
329 330 331 332
		case OPT_DEFAULT_PERMISSIONS:
			config->default_permissions = true;
			break;

M
Miklos Szeredi 已提交
333 334 335 336 337 338 339 340
		case OPT_REDIRECT_DIR_ON:
			config->redirect_dir = true;
			break;

		case OPT_REDIRECT_DIR_OFF:
			config->redirect_dir = false;
			break;

M
Miklos Szeredi 已提交
341
		default:
342
			pr_err("overlayfs: unrecognized mount option \"%s\" or missing value\n", p);
M
Miklos Szeredi 已提交
343 344 345
			return -EINVAL;
		}
	}
H
hujianyang 已提交
346 347 348 349 350 351 352 353 354

	/* Workdir is useless in non-upper mount */
	if (!config->upperdir && config->workdir) {
		pr_info("overlayfs: option \"workdir=%s\" is useless in a non-upper mount, ignore\n",
			config->workdir);
		kfree(config->workdir);
		config->workdir = NULL;
	}

M
Miklos Szeredi 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
	return 0;
}

#define OVL_WORKDIR_NAME "work"

static struct dentry *ovl_workdir_create(struct vfsmount *mnt,
					 struct dentry *dentry)
{
	struct inode *dir = dentry->d_inode;
	struct dentry *work;
	int err;
	bool retried = false;

	err = mnt_want_write(mnt);
	if (err)
		return ERR_PTR(err);

A
Al Viro 已提交
372
	inode_lock_nested(dir, I_MUTEX_PARENT);
M
Miklos Szeredi 已提交
373 374 375 376 377
retry:
	work = lookup_one_len(OVL_WORKDIR_NAME, dentry,
			      strlen(OVL_WORKDIR_NAME));

	if (!IS_ERR(work)) {
378 379
		struct iattr attr = {
			.ia_valid = ATTR_MODE,
A
Al Viro 已提交
380
			.ia_mode = S_IFDIR | 0,
381
		};
M
Miklos Szeredi 已提交
382 383 384 385 386 387 388

		if (work->d_inode) {
			err = -EEXIST;
			if (retried)
				goto out_dput;

			retried = true;
M
Miklos Szeredi 已提交
389
			ovl_workdir_cleanup(dir, mnt, work, 0);
M
Miklos Szeredi 已提交
390 391 392 393
			dput(work);
			goto retry;
		}

A
Al Viro 已提交
394 395 396
		err = ovl_create_real(dir, work,
				      &(struct cattr){.mode = S_IFDIR | 0},
				      NULL, true);
M
Miklos Szeredi 已提交
397 398
		if (err)
			goto out_dput;
399

400 401 402 403 404 405 406 407 408 409 410 411 412
		/*
		 * Try to remove POSIX ACL xattrs from workdir.  We are good if:
		 *
		 * a) success (there was a POSIX ACL xattr and was removed)
		 * b) -ENODATA (there was no POSIX ACL xattr)
		 * c) -EOPNOTSUPP (POSIX ACL xattrs are not supported)
		 *
		 * There are various other error values that could effectively
		 * mean that the xattr doesn't exist (e.g. -ERANGE is returned
		 * if the xattr name is too long), but the set of filesystems
		 * allowed as upper are limited to "normal" ones, where checking
		 * for the above two errors is sufficient.
		 */
413
		err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_DEFAULT);
M
Miklos Szeredi 已提交
414
		if (err && err != -ENODATA && err != -EOPNOTSUPP)
415 416 417
			goto out_dput;

		err = vfs_removexattr(work, XATTR_NAME_POSIX_ACL_ACCESS);
M
Miklos Szeredi 已提交
418
		if (err && err != -ENODATA && err != -EOPNOTSUPP)
419 420 421 422 423 424 425 426
			goto out_dput;

		/* Clear any inherited mode bits */
		inode_lock(work->d_inode);
		err = notify_change(work, &attr, NULL);
		inode_unlock(work->d_inode);
		if (err)
			goto out_dput;
M
Miklos Szeredi 已提交
427 428
	}
out_unlock:
A
Al Viro 已提交
429
	inode_unlock(dir);
M
Miklos Szeredi 已提交
430 431 432 433 434 435 436 437 438 439
	mnt_drop_write(mnt);

	return work;

out_dput:
	dput(work);
	work = ERR_PTR(err);
	goto out_unlock;
}

M
Miklos Szeredi 已提交
440 441 442 443 444 445 446 447 448 449 450 451 452
static void ovl_unescape(char *s)
{
	char *d = s;

	for (;; s++, d++) {
		if (*s == '\\')
			s++;
		*d = *s;
		if (!*s)
			break;
	}
}

M
Miklos Szeredi 已提交
453 454
static int ovl_mount_dir_noesc(const char *name, struct path *path)
{
455
	int err = -EINVAL;
M
Miklos Szeredi 已提交
456

457 458 459 460
	if (!*name) {
		pr_err("overlayfs: empty lowerdir\n");
		goto out;
	}
M
Miklos Szeredi 已提交
461 462 463 464 465 466
	err = kern_path(name, LOOKUP_FOLLOW, path);
	if (err) {
		pr_err("overlayfs: failed to resolve '%s': %i\n", name, err);
		goto out;
	}
	err = -EINVAL;
467
	if (ovl_dentry_weird(path->dentry)) {
M
Miklos Szeredi 已提交
468 469 470
		pr_err("overlayfs: filesystem on '%s' not supported\n", name);
		goto out_put;
	}
M
Miklos Szeredi 已提交
471
	if (!d_is_dir(path->dentry)) {
M
Miklos Szeredi 已提交
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
		pr_err("overlayfs: '%s' not a directory\n", name);
		goto out_put;
	}
	return 0;

out_put:
	path_put(path);
out:
	return err;
}

static int ovl_mount_dir(const char *name, struct path *path)
{
	int err = -ENOMEM;
	char *tmp = kstrdup(name, GFP_KERNEL);

	if (tmp) {
		ovl_unescape(tmp);
		err = ovl_mount_dir_noesc(tmp, path);
491 492 493 494 495 496 497 498

		if (!err)
			if (ovl_dentry_remote(path->dentry)) {
				pr_err("overlayfs: filesystem on '%s' not supported as upperdir\n",
				       tmp);
				path_put(path);
				err = -EINVAL;
			}
M
Miklos Szeredi 已提交
499 500 501 502 503
		kfree(tmp);
	}
	return err;
}

M
Miklos Szeredi 已提交
504 505
static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs,
			     const char *name)
M
Miklos Szeredi 已提交
506 507
{
	struct kstatfs statfs;
M
Miklos Szeredi 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521
	int err = vfs_statfs(path, &statfs);

	if (err)
		pr_err("overlayfs: statfs failed on '%s'\n", name);
	else
		ofs->namelen = max(ofs->namelen, statfs.f_namelen);

	return err;
}

static int ovl_lower_dir(const char *name, struct path *path,
			 struct ovl_fs *ofs, int *stack_depth, bool *remote)
{
	int err;
M
Miklos Szeredi 已提交
522

523
	err = ovl_mount_dir_noesc(name, path);
M
Miklos Szeredi 已提交
524 525 526
	if (err)
		goto out;

M
Miklos Szeredi 已提交
527 528
	err = ovl_check_namelen(path, ofs, name);
	if (err)
M
Miklos Szeredi 已提交
529
		goto out_put;
M
Miklos Szeredi 已提交
530

M
Miklos Szeredi 已提交
531 532
	*stack_depth = max(*stack_depth, path->mnt->mnt_sb->s_stack_depth);

533 534 535
	if (ovl_dentry_remote(path->dentry))
		*remote = true;

M
Miklos Szeredi 已提交
536 537 538 539 540 541 542 543
	return 0;

out_put:
	path_put(path);
out:
	return err;
}

M
Miklos Szeredi 已提交
544 545 546 547 548 549 550 551 552 553 554 555
/* Workdir should not be subdir of upperdir and vice versa */
static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir)
{
	bool ok = false;

	if (workdir != upperdir) {
		ok = (lock_rename(workdir, upperdir) == NULL);
		unlock_rename(workdir, upperdir);
	}
	return ok;
}

556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
static unsigned int ovl_split_lowerdirs(char *str)
{
	unsigned int ctr = 1;
	char *s, *d;

	for (s = d = str;; s++, d++) {
		if (*s == '\\') {
			s++;
		} else if (*s == ':') {
			*d = '\0';
			ctr++;
			continue;
		}
		*d = *s;
		if (!*s)
			break;
	}
	return ctr;
}

576 577 578 579 580 581 582 583
static int __maybe_unused
ovl_posix_acl_xattr_get(const struct xattr_handler *handler,
			struct dentry *dentry, struct inode *inode,
			const char *name, void *buffer, size_t size)
{
	return ovl_xattr_get(dentry, handler->name, buffer, size);
}

584 585 586 587 588
static int __maybe_unused
ovl_posix_acl_xattr_set(const struct xattr_handler *handler,
			struct dentry *dentry, struct inode *inode,
			const char *name, const void *value,
			size_t size, int flags)
M
Miklos Szeredi 已提交
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615
{
	struct dentry *workdir = ovl_workdir(dentry);
	struct inode *realinode = ovl_inode_real(inode, NULL);
	struct posix_acl *acl = NULL;
	int err;

	/* Check that everything is OK before copy-up */
	if (value) {
		acl = posix_acl_from_xattr(&init_user_ns, value, size);
		if (IS_ERR(acl))
			return PTR_ERR(acl);
	}
	err = -EOPNOTSUPP;
	if (!IS_POSIXACL(d_inode(workdir)))
		goto out_acl_release;
	if (!realinode->i_op->set_acl)
		goto out_acl_release;
	if (handler->flags == ACL_TYPE_DEFAULT && !S_ISDIR(inode->i_mode)) {
		err = acl ? -EACCES : 0;
		goto out_acl_release;
	}
	err = -EPERM;
	if (!inode_owner_or_capable(inode))
		goto out_acl_release;

	posix_acl_release(acl);

616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
	/*
	 * Check if sgid bit needs to be cleared (actual setacl operation will
	 * be done with mounter's capabilities and so that won't do it for us).
	 */
	if (unlikely(inode->i_mode & S_ISGID) &&
	    handler->flags == ACL_TYPE_ACCESS &&
	    !in_group_p(inode->i_gid) &&
	    !capable_wrt_inode_uidgid(inode, CAP_FSETID)) {
		struct iattr iattr = { .ia_valid = ATTR_KILL_SGID };

		err = ovl_setattr(dentry, &iattr);
		if (err)
			return err;
	}

631 632 633 634 635
	err = ovl_xattr_set(dentry, handler->name, value, size, flags);
	if (!err)
		ovl_copyattr(ovl_inode_real(inode, NULL), inode);

	return err;
M
Miklos Szeredi 已提交
636 637 638 639 640 641

out_acl_release:
	posix_acl_release(acl);
	return err;
}

642 643 644 645
static int ovl_own_xattr_get(const struct xattr_handler *handler,
			     struct dentry *dentry, struct inode *inode,
			     const char *name, void *buffer, size_t size)
{
A
Amir Goldstein 已提交
646
	return -EOPNOTSUPP;
647 648
}

M
Miklos Szeredi 已提交
649 650 651 652 653
static int ovl_own_xattr_set(const struct xattr_handler *handler,
			     struct dentry *dentry, struct inode *inode,
			     const char *name, const void *value,
			     size_t size, int flags)
{
A
Amir Goldstein 已提交
654
	return -EOPNOTSUPP;
M
Miklos Szeredi 已提交
655 656
}

657 658 659 660 661 662 663
static int ovl_other_xattr_get(const struct xattr_handler *handler,
			       struct dentry *dentry, struct inode *inode,
			       const char *name, void *buffer, size_t size)
{
	return ovl_xattr_get(dentry, name, buffer, size);
}

664 665 666 667 668 669 670 671
static int ovl_other_xattr_set(const struct xattr_handler *handler,
			       struct dentry *dentry, struct inode *inode,
			       const char *name, const void *value,
			       size_t size, int flags)
{
	return ovl_xattr_set(dentry, name, value, size, flags);
}

672 673
static const struct xattr_handler __maybe_unused
ovl_posix_acl_access_xattr_handler = {
M
Miklos Szeredi 已提交
674 675
	.name = XATTR_NAME_POSIX_ACL_ACCESS,
	.flags = ACL_TYPE_ACCESS,
676
	.get = ovl_posix_acl_xattr_get,
M
Miklos Szeredi 已提交
677 678 679
	.set = ovl_posix_acl_xattr_set,
};

680 681
static const struct xattr_handler __maybe_unused
ovl_posix_acl_default_xattr_handler = {
M
Miklos Szeredi 已提交
682 683
	.name = XATTR_NAME_POSIX_ACL_DEFAULT,
	.flags = ACL_TYPE_DEFAULT,
684
	.get = ovl_posix_acl_xattr_get,
M
Miklos Szeredi 已提交
685 686 687 688 689
	.set = ovl_posix_acl_xattr_set,
};

static const struct xattr_handler ovl_own_xattr_handler = {
	.prefix	= OVL_XATTR_PREFIX,
690
	.get = ovl_own_xattr_get,
M
Miklos Szeredi 已提交
691 692 693 694 695
	.set = ovl_own_xattr_set,
};

static const struct xattr_handler ovl_other_xattr_handler = {
	.prefix	= "", /* catch all */
696
	.get = ovl_other_xattr_get,
M
Miklos Szeredi 已提交
697 698 699 700
	.set = ovl_other_xattr_set,
};

static const struct xattr_handler *ovl_xattr_handlers[] = {
701
#ifdef CONFIG_FS_POSIX_ACL
M
Miklos Szeredi 已提交
702 703
	&ovl_posix_acl_access_xattr_handler,
	&ovl_posix_acl_default_xattr_handler,
704
#endif
M
Miklos Szeredi 已提交
705 706 707 708 709
	&ovl_own_xattr_handler,
	&ovl_other_xattr_handler,
	NULL
};

M
Miklos Szeredi 已提交
710 711
static int ovl_fill_super(struct super_block *sb, void *data, int silent)
{
M
Miklos Szeredi 已提交
712 713
	struct path upperpath = { NULL, NULL };
	struct path workpath = { NULL, NULL };
M
Miklos Szeredi 已提交
714
	struct dentry *root_dentry;
715
	struct inode *realinode;
M
Miklos Szeredi 已提交
716 717
	struct ovl_entry *oe;
	struct ovl_fs *ufs;
718 719 720 721 722
	struct path *stack = NULL;
	char *lowertmp;
	char *lower;
	unsigned int numlower;
	unsigned int stacklen = 0;
723
	unsigned int i;
724
	bool remote = false;
725
	struct cred *cred;
M
Miklos Szeredi 已提交
726 727
	int err;

E
Erez Zadok 已提交
728 729 730
	err = -ENOMEM;
	ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL);
	if (!ufs)
M
Miklos Szeredi 已提交
731 732
		goto out;

733
	init_waitqueue_head(&ufs->copyup_wq);
734
	ufs->config.redirect_dir = ovl_redirect_dir_def;
E
Erez Zadok 已提交
735 736 737 738
	err = ovl_parse_opt((char *) data, &ufs->config);
	if (err)
		goto out_free_config;

M
Miklos Szeredi 已提交
739
	err = -EINVAL;
M
Miklos Szeredi 已提交
740
	if (!ufs->config.lowerdir) {
741 742
		if (!silent)
			pr_err("overlayfs: missing 'lowerdir'\n");
M
Miklos Szeredi 已提交
743 744 745
		goto out_free_config;
	}

M
Miklos Szeredi 已提交
746
	sb->s_stack_depth = 0;
747
	sb->s_maxbytes = MAX_LFS_FILESIZE;
M
Miklos Szeredi 已提交
748 749 750 751 752
	if (ufs->config.upperdir) {
		if (!ufs->config.workdir) {
			pr_err("overlayfs: missing 'workdir'\n");
			goto out_free_config;
		}
M
Miklos Szeredi 已提交
753

M
Miklos Szeredi 已提交
754 755 756
		err = ovl_mount_dir(ufs->config.upperdir, &upperpath);
		if (err)
			goto out_free_config;
M
Miklos Szeredi 已提交
757

H
hujianyang 已提交
758 759 760 761 762 763 764
		/* Upper fs should not be r/o */
		if (upperpath.mnt->mnt_sb->s_flags & MS_RDONLY) {
			pr_err("overlayfs: upper fs is r/o, try multi-lower layers mount\n");
			err = -EINVAL;
			goto out_put_upperpath;
		}

M
Miklos Szeredi 已提交
765 766 767 768
		err = ovl_check_namelen(&upperpath, ufs, ufs->config.upperdir);
		if (err)
			goto out_put_upperpath;

M
Miklos Szeredi 已提交
769 770 771 772
		err = ovl_mount_dir(ufs->config.workdir, &workpath);
		if (err)
			goto out_put_upperpath;

773
		err = -EINVAL;
M
Miklos Szeredi 已提交
774 775 776 777 778 779 780 781 782
		if (upperpath.mnt != workpath.mnt) {
			pr_err("overlayfs: workdir and upperdir must reside under the same mount\n");
			goto out_put_workpath;
		}
		if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) {
			pr_err("overlayfs: workdir and upperdir must be separate subtrees\n");
			goto out_put_workpath;
		}
		sb->s_stack_depth = upperpath.mnt->mnt_sb->s_stack_depth;
A
Andy Whitcroft 已提交
783
	}
784 785 786
	err = -ENOMEM;
	lowertmp = kstrdup(ufs->config.lowerdir, GFP_KERNEL);
	if (!lowertmp)
M
Miklos Szeredi 已提交
787
		goto out_put_workpath;
788

789 790
	err = -EINVAL;
	stacklen = ovl_split_lowerdirs(lowertmp);
791
	if (stacklen > OVL_MAX_STACK) {
792
		pr_err("overlayfs: too many lower directories, limit is %d\n",
793
		       OVL_MAX_STACK);
794
		goto out_free_lowertmp;
795 796 797 798
	} else if (!ufs->config.upperdir && stacklen == 1) {
		pr_err("overlayfs: at least 2 lowerdir are needed while upperdir nonexistent\n");
		goto out_free_lowertmp;
	}
799

800
	err = -ENOMEM;
801 802 803 804
	stack = kcalloc(stacklen, sizeof(struct path), GFP_KERNEL);
	if (!stack)
		goto out_free_lowertmp;

805
	err = -EINVAL;
806 807
	lower = lowertmp;
	for (numlower = 0; numlower < stacklen; numlower++) {
M
Miklos Szeredi 已提交
808 809
		err = ovl_lower_dir(lower, &stack[numlower], ufs,
				    &sb->s_stack_depth, &remote);
810 811 812 813 814 815
		if (err)
			goto out_put_lowerpath;

		lower = strchr(lower, '\0') + 1;
	}

816
	err = -EINVAL;
M
Miklos Szeredi 已提交
817
	sb->s_stack_depth++;
818 819
	if (sb->s_stack_depth > FILESYSTEM_MAX_STACK_DEPTH) {
		pr_err("overlayfs: maximum fs stacking depth exceeded\n");
820
		goto out_put_lowerpath;
821 822
	}

M
Miklos Szeredi 已提交
823 824 825 826 827 828 829
	if (ufs->config.upperdir) {
		ufs->upper_mnt = clone_private_mount(&upperpath);
		err = PTR_ERR(ufs->upper_mnt);
		if (IS_ERR(ufs->upper_mnt)) {
			pr_err("overlayfs: failed to clone upperpath\n");
			goto out_put_lowerpath;
		}
M
Miklos Szeredi 已提交
830 831 832 833
		/* Don't inherit atime flags */
		ufs->upper_mnt->mnt_flags &= ~(MNT_NOATIME | MNT_NODIRATIME | MNT_RELATIME);

		sb->s_time_gran = ufs->upper_mnt->mnt_sb->s_time_gran;
834

M
Miklos Szeredi 已提交
835 836 837
		ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry);
		err = PTR_ERR(ufs->workdir);
		if (IS_ERR(ufs->workdir)) {
838 839 840 841
			pr_warn("overlayfs: failed to create directory %s/%s (errno: %i); mounting read-only\n",
				ufs->config.workdir, OVL_WORKDIR_NAME, -err);
			sb->s_flags |= MS_RDONLY;
			ufs->workdir = NULL;
M
Miklos Szeredi 已提交
842
		}
843 844 845 846

		/*
		 * Upper should support d_type, else whiteouts are visible.
		 * Given workdir and upper are on same fs, we can do
847 848
		 * iterate_dir() on workdir. This check requires successful
		 * creation of workdir in previous step.
849
		 */
850
		if (ufs->workdir) {
851 852
			struct dentry *temp;

853 854 855
			err = ovl_check_d_type_supported(&workpath);
			if (err < 0)
				goto out_put_workdir;
856

857 858 859 860 861 862 863
			/*
			 * We allowed this configuration and don't want to
			 * break users over kernel upgrade. So warn instead
			 * of erroring out.
			 */
			if (!err)
				pr_warn("overlayfs: upper fs needs to support d_type.\n");
864 865 866 867 868 869 870 871

			/* Check if upper/work fs supports O_TMPFILE */
			temp = ovl_do_tmpfile(ufs->workdir, S_IFREG | 0);
			ufs->tmpfile = !IS_ERR(temp);
			if (ufs->tmpfile)
				dput(temp);
			else
				pr_warn("overlayfs: upper fs does not support tmpfile.\n");
872
		}
M
Miklos Szeredi 已提交
873 874
	}

875
	err = -ENOMEM;
876
	ufs->lower_mnt = kcalloc(numlower, sizeof(struct vfsmount *), GFP_KERNEL);
877
	if (ufs->lower_mnt == NULL)
878
		goto out_put_workdir;
879 880
	for (i = 0; i < numlower; i++) {
		struct vfsmount *mnt = clone_private_mount(&stack[i]);
881

882
		err = PTR_ERR(mnt);
883 884 885 886 887 888 889 890
		if (IS_ERR(mnt)) {
			pr_err("overlayfs: failed to clone lowerpath\n");
			goto out_put_lower_mnt;
		}
		/*
		 * Make lower_mnt R/O.  That way fchmod/fchown on lower file
		 * will fail instead of modifying lower fs.
		 */
M
Miklos Szeredi 已提交
891
		mnt->mnt_flags |= MNT_READONLY | MNT_NOATIME;
892

893 894 895
		ufs->lower_mnt[ufs->numlower] = mnt;
		ufs->numlower++;
	}
M
Miklos Szeredi 已提交
896

H
hujianyang 已提交
897 898
	/* If the upper fs is nonexistent, we mark overlayfs r/o too */
	if (!ufs->upper_mnt)
M
Miklos Szeredi 已提交
899 900
		sb->s_flags |= MS_RDONLY;

901 902 903 904
	if (remote)
		sb->s_d_op = &ovl_reval_dentry_operations;
	else
		sb->s_d_op = &ovl_dentry_operations;
M
Miklos Szeredi 已提交
905

906 907
	ufs->creator_cred = cred = prepare_creds();
	if (!cred)
908 909
		goto out_put_lower_mnt;

910 911 912
	/* Never override disk quota limits or use reserved space */
	cap_lower(cred->cap_effective, CAP_SYS_RESOURCE);

M
Miklos Szeredi 已提交
913
	err = -ENOMEM;
914
	oe = ovl_alloc_entry(numlower);
915
	if (!oe)
916
		goto out_put_cred;
M
Miklos Szeredi 已提交
917

918 919 920 921 922 923
	sb->s_magic = OVERLAYFS_SUPER_MAGIC;
	sb->s_op = &ovl_super_operations;
	sb->s_xattr = ovl_xattr_handlers;
	sb->s_fs_info = ufs;
	sb->s_flags |= MS_POSIXACL | MS_NOREMOTELOCK;

924
	root_dentry = d_make_root(ovl_new_inode(sb, S_IFDIR, 0));
M
Miklos Szeredi 已提交
925
	if (!root_dentry)
926
		goto out_free_oe;
M
Miklos Szeredi 已提交
927 928

	mntput(upperpath.mnt);
929 930
	for (i = 0; i < numlower; i++)
		mntput(stack[i].mnt);
M
Miklos Szeredi 已提交
931
	path_put(&workpath);
932
	kfree(lowertmp);
M
Miklos Szeredi 已提交
933 934

	oe->__upperdentry = upperpath.dentry;
935 936 937 938
	for (i = 0; i < numlower; i++) {
		oe->lowerstack[i].dentry = stack[i].dentry;
		oe->lowerstack[i].mnt = ufs->lower_mnt[i];
	}
939
	kfree(stack);
M
Miklos Szeredi 已提交
940 941 942

	root_dentry->d_fsdata = oe;

943 944 945
	realinode = d_inode(ovl_dentry_real(root_dentry));
	ovl_inode_init(d_inode(root_dentry), realinode, !!upperpath.dentry);
	ovl_copyattr(realinode, d_inode(root_dentry));
M
Miklos Szeredi 已提交
946

M
Miklos Szeredi 已提交
947 948 949 950
	sb->s_root = root_dentry;

	return 0;

951 952
out_free_oe:
	kfree(oe);
953 954
out_put_cred:
	put_cred(ufs->creator_cred);
M
Miklos Szeredi 已提交
955
out_put_lower_mnt:
956 957 958
	for (i = 0; i < ufs->numlower; i++)
		mntput(ufs->lower_mnt[i]);
	kfree(ufs->lower_mnt);
959 960
out_put_workdir:
	dput(ufs->workdir);
M
Miklos Szeredi 已提交
961 962
	mntput(ufs->upper_mnt);
out_put_lowerpath:
963 964 965 966 967
	for (i = 0; i < numlower; i++)
		path_put(&stack[i]);
	kfree(stack);
out_free_lowertmp:
	kfree(lowertmp);
968 969
out_put_workpath:
	path_put(&workpath);
M
Miklos Szeredi 已提交
970 971 972
out_put_upperpath:
	path_put(&upperpath);
out_free_config:
E
Erez Zadok 已提交
973 974 975 976
	kfree(ufs->config.lowerdir);
	kfree(ufs->config.upperdir);
	kfree(ufs->config.workdir);
	kfree(ufs);
M
Miklos Szeredi 已提交
977 978 979 980 981 982 983 984 985 986 987 988
out:
	return err;
}

static struct dentry *ovl_mount(struct file_system_type *fs_type, int flags,
				const char *dev_name, void *raw_data)
{
	return mount_nodev(fs_type, flags, raw_data, ovl_fill_super);
}

static struct file_system_type ovl_fs_type = {
	.owner		= THIS_MODULE,
989
	.name		= "overlay",
M
Miklos Szeredi 已提交
990 991 992
	.mount		= ovl_mount,
	.kill_sb	= kill_anon_super,
};
993
MODULE_ALIAS_FS("overlay");
M
Miklos Szeredi 已提交
994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006

static int __init ovl_init(void)
{
	return register_filesystem(&ovl_fs_type);
}

static void __exit ovl_exit(void)
{
	unregister_filesystem(&ovl_fs_type);
}

module_init(ovl_init);
module_exit(ovl_exit);