inode.c 16.3 KB
Newer Older
M
Miklos Szeredi 已提交
1 2 3 4 5 6 7 8 9 10 11
/*
 *
 * 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/fs.h>
#include <linux/slab.h>
12
#include <linux/cred.h>
M
Miklos Szeredi 已提交
13
#include <linux/xattr.h>
14
#include <linux/posix_acl.h>
15
#include <linux/ratelimit.h>
M
Miklos Szeredi 已提交
16 17 18 19 20 21
#include "overlayfs.h"

int ovl_setattr(struct dentry *dentry, struct iattr *attr)
{
	int err;
	struct dentry *upperdentry;
22
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
23

24 25 26 27 28 29 30 31 32
	/*
	 * Check for permissions before trying to copy-up.  This is redundant
	 * since it will be rechecked later by ->setattr() on upper dentry.  But
	 * without this, copy-up can be triggered by just about anybody.
	 *
	 * We don't initialize inode->size, which just means that
	 * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not
	 * check for a swapfile (which this won't be anyway).
	 */
33
	err = setattr_prepare(dentry, attr);
34 35 36
	if (err)
		return err;

M
Miklos Szeredi 已提交
37 38 39 40
	err = ovl_want_write(dentry);
	if (err)
		goto out;

41 42 43 44
	err = ovl_copy_up(dentry);
	if (!err) {
		upperdentry = ovl_dentry_upper(dentry);

M
Miklos Szeredi 已提交
45 46 47
		if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
			attr->ia_valid &= ~ATTR_MODE;

A
Al Viro 已提交
48
		inode_lock(upperdentry->d_inode);
49
		old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
50
		err = notify_change(upperdentry, attr, NULL);
51
		revert_creds(old_cred);
52 53
		if (!err)
			ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
A
Al Viro 已提交
54
		inode_unlock(upperdentry->d_inode);
M
Miklos Szeredi 已提交
55 56 57 58 59 60
	}
	ovl_drop_write(dentry);
out:
	return err;
}

61 62
int ovl_getattr(const struct path *path, struct kstat *stat,
		u32 request_mask, unsigned int flags)
M
Miklos Szeredi 已提交
63
{
64
	struct dentry *dentry = path->dentry;
65
	enum ovl_path_type type;
M
Miklos Szeredi 已提交
66
	struct path realpath;
67
	const struct cred *old_cred;
68
	bool is_dir = S_ISDIR(dentry->d_inode->i_mode);
69
	int err;
M
Miklos Szeredi 已提交
70

71
	type = ovl_path_real(dentry, &realpath);
72
	old_cred = ovl_override_creds(dentry->d_sb);
73
	err = vfs_getattr(&realpath, stat, request_mask, flags);
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
	if (err)
		goto out;

	/*
	 * When all layers are on the same fs, all real inode number are
	 * unique, so we use the overlay st_dev, which is friendly to du -x.
	 *
	 * We also use st_ino of the copy up origin, if we know it.
	 * This guaranties constant st_dev/st_ino across copy up.
	 *
	 * If filesystem supports NFS export ops, this also guaranties
	 * persistent st_ino across mount cycle.
	 */
	if (ovl_same_sb(dentry->d_sb)) {
		if (OVL_TYPE_ORIGIN(type)) {
			struct kstat lowerstat;
90
			u32 lowermask = STATX_INO | (!is_dir ? STATX_NLINK : 0);
91 92 93

			ovl_path_lower(dentry, &realpath);
			err = vfs_getattr(&realpath, &lowerstat,
94
					  lowermask, flags);
95 96 97 98 99
			if (err)
				goto out;

			WARN_ON_ONCE(stat->dev != lowerstat.dev);
			/*
100
			 * Lower hardlinks may be broken on copy up to different
101 102
			 * upper files, so we cannot use the lower origin st_ino
			 * for those different files, even for the same fs case.
103 104 105
			 * With inodes index enabled, it is safe to use st_ino
			 * of an indexed hardlinked origin. The index validates
			 * that the upper hardlink is not broken.
106
			 */
107 108
			if (is_dir || lowerstat.nlink == 1 ||
			    ovl_test_flag(OVL_INDEX, d_inode(dentry)))
109 110 111
				stat->ino = lowerstat.ino;
		}
		stat->dev = dentry->d_sb->s_dev;
112 113 114 115 116 117 118 119 120 121 122 123
	} else if (is_dir) {
		/*
		 * If not all layers are on the same fs the pair {real st_ino;
		 * overlay st_dev} is not unique, so use the non persistent
		 * overlay st_ino.
		 *
		 * Always use the overlay st_dev for directories, so 'find
		 * -xdev' will scan the entire overlay mount and won't cross the
		 * overlay mount boundaries.
		 */
		stat->dev = dentry->d_sb->s_dev;
		stat->ino = dentry->d_inode->i_ino;
124
	}
125 126 127 128 129 130 131 132 133

	/*
	 * It's probably not worth it to count subdirs to get the
	 * correct link count.  nlink=1 seems to pacify 'find' and
	 * other utilities.
	 */
	if (is_dir && OVL_TYPE_MERGE(type))
		stat->nlink = 1;

134 135 136 137 138 139 140 141 142
	/*
	 * Return the overlay inode nlinks for indexed upper inodes.
	 * Overlay inode nlink counts the union of the upper hardlinks
	 * and non-covered lower hardlinks. It does not include the upper
	 * index hardlink.
	 */
	if (!is_dir && ovl_test_flag(OVL_INDEX, d_inode(dentry)))
		stat->nlink = dentry->d_inode->i_nlink;

143
out:
144
	revert_creds(old_cred);
145

146
	return err;
M
Miklos Szeredi 已提交
147 148 149 150
}

int ovl_permission(struct inode *inode, int mask)
{
151 152
	struct inode *upperinode = ovl_inode_upper(inode);
	struct inode *realinode = upperinode ?: ovl_inode_lower(inode);
153
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
154 155 156 157 158
	int err;

	/* Careful in RCU walk mode */
	if (!realinode) {
		WARN_ON(!(mask & MAY_NOT_BLOCK));
159
		return -ECHILD;
M
Miklos Szeredi 已提交
160 161
	}

162 163 164 165 166 167 168 169 170
	/*
	 * Check overlay inode with the creds of task and underlying inode
	 * with creds of mounter
	 */
	err = generic_permission(inode, mask);
	if (err)
		return err;

	old_cred = ovl_override_creds(inode->i_sb);
171 172
	if (!upperinode &&
	    !special_file(realinode->i_mode) && mask & MAY_WRITE) {
173
		mask &= ~(MAY_WRITE | MAY_APPEND);
174 175 176
		/* Make sure mounter can read file for copy up later */
		mask |= MAY_READ;
	}
177
	err = inode_permission(realinode, mask);
178 179 180
	revert_creds(old_cred);

	return err;
M
Miklos Szeredi 已提交
181 182
}

183
static const char *ovl_get_link(struct dentry *dentry,
184 185
				struct inode *inode,
				struct delayed_call *done)
M
Miklos Szeredi 已提交
186
{
187 188
	const struct cred *old_cred;
	const char *p;
M
Miklos Szeredi 已提交
189

190 191 192
	if (!dentry)
		return ERR_PTR(-ECHILD);

193
	old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
194
	p = vfs_get_link(ovl_dentry_real(dentry), done);
195 196
	revert_creds(old_cred);
	return p;
M
Miklos Szeredi 已提交
197 198
}

M
Miklos Szeredi 已提交
199
bool ovl_is_private_xattr(const char *name)
M
Miklos Szeredi 已提交
200
{
A
Andreas Gruenbacher 已提交
201 202
	return strncmp(name, OVL_XATTR_PREFIX,
		       sizeof(OVL_XATTR_PREFIX) - 1) == 0;
M
Miklos Szeredi 已提交
203 204
}

205 206
int ovl_xattr_set(struct dentry *dentry, const char *name, const void *value,
		  size_t size, int flags)
M
Miklos Szeredi 已提交
207 208
{
	int err;
209 210
	struct path realpath;
	enum ovl_path_type type = ovl_path_real(dentry, &realpath);
211
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
212 213 214 215 216

	err = ovl_want_write(dentry);
	if (err)
		goto out;

217 218 219 220 221 222
	if (!value && !OVL_TYPE_UPPER(type)) {
		err = vfs_getxattr(realpath.dentry, name, NULL, 0);
		if (err < 0)
			goto out_drop_write;
	}

M
Miklos Szeredi 已提交
223 224 225 226
	err = ovl_copy_up(dentry);
	if (err)
		goto out_drop_write;

227 228 229
	if (!OVL_TYPE_UPPER(type))
		ovl_path_upper(dentry, &realpath);

230
	old_cred = ovl_override_creds(dentry->d_sb);
231 232 233 234 235 236
	if (value)
		err = vfs_setxattr(realpath.dentry, name, value, size, flags);
	else {
		WARN_ON(flags != XATTR_REPLACE);
		err = vfs_removexattr(realpath.dentry, name);
	}
237
	revert_creds(old_cred);
M
Miklos Szeredi 已提交
238 239 240 241 242 243 244

out_drop_write:
	ovl_drop_write(dentry);
out:
	return err;
}

245 246
int ovl_xattr_get(struct dentry *dentry, const char *name,
		  void *value, size_t size)
M
Miklos Szeredi 已提交
247
{
M
Miklos Szeredi 已提交
248
	struct dentry *realdentry = ovl_dentry_real(dentry);
249 250
	ssize_t res;
	const struct cred *old_cred;
251

252 253 254 255
	old_cred = ovl_override_creds(dentry->d_sb);
	res = vfs_getxattr(realdentry, name, value, size);
	revert_creds(old_cred);
	return res;
M
Miklos Szeredi 已提交
256 257
}

258 259 260 261 262 263 264 265 266 267
static bool ovl_can_list(const char *s)
{
	/* List all non-trusted xatts */
	if (strncmp(s, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) != 0)
		return true;

	/* Never list trusted.overlay, list other trusted for superuser only */
	return !ovl_is_private_xattr(s) && capable(CAP_SYS_ADMIN);
}

M
Miklos Szeredi 已提交
268 269
ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
{
M
Miklos Szeredi 已提交
270
	struct dentry *realdentry = ovl_dentry_real(dentry);
M
Miklos Szeredi 已提交
271
	ssize_t res;
M
Miklos Szeredi 已提交
272 273
	size_t len;
	char *s;
274
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
275

276
	old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
277
	res = vfs_listxattr(realdentry, list, size);
278
	revert_creds(old_cred);
M
Miklos Szeredi 已提交
279 280 281 282
	if (res <= 0 || size == 0)
		return res;

	/* filter out private xattrs */
M
Miklos Szeredi 已提交
283 284
	for (s = list, len = res; len;) {
		size_t slen = strnlen(s, len) + 1;
M
Miklos Szeredi 已提交
285

M
Miklos Szeredi 已提交
286 287 288
		/* underlying fs providing us with an broken xattr list? */
		if (WARN_ON(slen > len))
			return -EIO;
M
Miklos Szeredi 已提交
289

M
Miklos Szeredi 已提交
290
		len -= slen;
291
		if (!ovl_can_list(s)) {
M
Miklos Szeredi 已提交
292
			res -= slen;
M
Miklos Szeredi 已提交
293
			memmove(s, s + slen, len);
M
Miklos Szeredi 已提交
294
		} else {
M
Miklos Szeredi 已提交
295
			s += slen;
M
Miklos Szeredi 已提交
296 297 298 299 300 301
		}
	}

	return res;
}

302 303
struct posix_acl *ovl_get_acl(struct inode *inode, int type)
{
304
	struct inode *realinode = ovl_inode_real(inode);
305 306
	const struct cred *old_cred;
	struct posix_acl *acl;
307

308
	if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode))
309 310
		return NULL;

311
	old_cred = ovl_override_creds(inode->i_sb);
312
	acl = get_acl(realinode, type);
313 314 315
	revert_creds(old_cred);

	return acl;
316 317
}

318
static bool ovl_open_need_copy_up(struct dentry *dentry, int flags)
M
Miklos Szeredi 已提交
319
{
320 321
	if (ovl_dentry_upper(dentry) &&
	    ovl_dentry_has_upper_alias(dentry))
M
Miklos Szeredi 已提交
322 323
		return false;

324
	if (special_file(d_inode(dentry)->i_mode))
M
Miklos Szeredi 已提交
325 326 327 328 329 330 331 332
		return false;

	if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
		return false;

	return true;
}

333
int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags)
M
Miklos Szeredi 已提交
334
{
335
	int err = 0;
M
Miklos Szeredi 已提交
336

337
	if (ovl_open_need_copy_up(dentry, file_flags)) {
M
Miklos Szeredi 已提交
338
		err = ovl_want_write(dentry);
339
		if (!err) {
340
			err = ovl_copy_up_flags(dentry, file_flags);
341 342
			ovl_drop_write(dentry);
		}
M
Miklos Szeredi 已提交
343 344
	}

345
	return err;
M
Miklos Szeredi 已提交
346 347
}

M
Miklos Szeredi 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
int ovl_update_time(struct inode *inode, struct timespec *ts, int flags)
{
	struct dentry *alias;
	struct path upperpath;

	if (!(flags & S_ATIME))
		return 0;

	alias = d_find_any_alias(inode);
	if (!alias)
		return 0;

	ovl_path_upper(alias, &upperpath);
	if (upperpath.dentry) {
		touch_atime(&upperpath);
		inode->i_atime = d_inode(upperpath.dentry)->i_atime;
	}

	dput(alias);

	return 0;
}

M
Miklos Szeredi 已提交
371 372 373 374 375
static const struct inode_operations ovl_file_inode_operations = {
	.setattr	= ovl_setattr,
	.permission	= ovl_permission,
	.getattr	= ovl_getattr,
	.listxattr	= ovl_listxattr,
376
	.get_acl	= ovl_get_acl,
M
Miklos Szeredi 已提交
377
	.update_time	= ovl_update_time,
M
Miklos Szeredi 已提交
378 379 380 381
};

static const struct inode_operations ovl_symlink_inode_operations = {
	.setattr	= ovl_setattr,
382
	.get_link	= ovl_get_link,
M
Miklos Szeredi 已提交
383 384
	.getattr	= ovl_getattr,
	.listxattr	= ovl_listxattr,
M
Miklos Szeredi 已提交
385
	.update_time	= ovl_update_time,
M
Miklos Szeredi 已提交
386 387
};

388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
/*
 * It is possible to stack overlayfs instance on top of another
 * overlayfs instance as lower layer. We need to annonate the
 * stackable i_mutex locks according to stack level of the super
 * block instance. An overlayfs instance can never be in stack
 * depth 0 (there is always a real fs below it).  An overlayfs
 * inode lock will use the lockdep annotaion ovl_i_mutex_key[depth].
 *
 * For example, here is a snip from /proc/lockdep_chains after
 * dir_iterate of nested overlayfs:
 *
 * [...] &ovl_i_mutex_dir_key[depth]   (stack_depth=2)
 * [...] &ovl_i_mutex_dir_key[depth]#2 (stack_depth=1)
 * [...] &type->i_mutex_dir_key        (stack_depth=0)
 */
#define OVL_MAX_NESTING FILESYSTEM_MAX_STACK_DEPTH

static inline void ovl_lockdep_annotate_inode_mutex_key(struct inode *inode)
{
#ifdef CONFIG_LOCKDEP
	static struct lock_class_key ovl_i_mutex_key[OVL_MAX_NESTING];
	static struct lock_class_key ovl_i_mutex_dir_key[OVL_MAX_NESTING];

	int depth = inode->i_sb->s_stack_depth - 1;

	if (WARN_ON_ONCE(depth < 0 || depth >= OVL_MAX_NESTING))
		depth = 0;

	if (S_ISDIR(inode->i_mode))
		lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_dir_key[depth]);
	else
		lockdep_set_class(&inode->i_rwsem, &ovl_i_mutex_key[depth]);
#endif
}

423
static void ovl_fill_inode(struct inode *inode, umode_t mode, dev_t rdev)
M
Miklos Szeredi 已提交
424 425 426
{
	inode->i_ino = get_next_ino();
	inode->i_mode = mode;
M
Miklos Szeredi 已提交
427
	inode->i_flags |= S_NOCMTIME;
428 429 430
#ifdef CONFIG_FS_POSIX_ACL
	inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
#endif
M
Miklos Szeredi 已提交
431

432 433
	ovl_lockdep_annotate_inode_mutex_key(inode);

434 435 436 437 438
	switch (mode & S_IFMT) {
	case S_IFREG:
		inode->i_op = &ovl_file_inode_operations;
		break;

M
Miklos Szeredi 已提交
439 440 441 442 443 444 445 446 447
	case S_IFDIR:
		inode->i_op = &ovl_dir_inode_operations;
		inode->i_fop = &ovl_dir_operations;
		break;

	case S_IFLNK:
		inode->i_op = &ovl_symlink_inode_operations;
		break;

M
Miklos Szeredi 已提交
448
	default:
M
Miklos Szeredi 已提交
449
		inode->i_op = &ovl_file_inode_operations;
450
		init_special_inode(inode, mode, rdev);
M
Miklos Szeredi 已提交
451
		break;
M
Miklos Szeredi 已提交
452 453
	}
}
M
Miklos Szeredi 已提交
454

455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
/*
 * With inodes index enabled, an overlay inode nlink counts the union of upper
 * hardlinks and non-covered lower hardlinks. During the lifetime of a non-pure
 * upper inode, the following nlink modifying operations can happen:
 *
 * 1. Lower hardlink copy up
 * 2. Upper hardlink created, unlinked or renamed over
 * 3. Lower hardlink whiteout or renamed over
 *
 * For the first, copy up case, the union nlink does not change, whether the
 * operation succeeds or fails, but the upper inode nlink may change.
 * Therefore, before copy up, we store the union nlink value relative to the
 * lower inode nlink in the index inode xattr trusted.overlay.nlink.
 *
 * For the second, upper hardlink case, the union nlink should be incremented
 * or decremented IFF the operation succeeds, aligned with nlink change of the
 * upper inode. Therefore, before link/unlink/rename, we store the union nlink
 * value relative to the upper inode nlink in the index inode.
 *
 * For the last, lower cover up case, we simplify things by preceding the
 * whiteout or cover up with copy up. This makes sure that there is an index
 * upper inode where the nlink xattr can be stored before the copied up upper
 * entry is unlink.
 */
#define OVL_NLINK_ADD_UPPER	(1 << 0)

/*
 * On-disk format for indexed nlink:
 *
 * nlink relative to the upper inode - "U[+-]NUM"
 * nlink relative to the lower inode - "L[+-]NUM"
 */

static int ovl_set_nlink_common(struct dentry *dentry,
				struct dentry *realdentry, const char *format)
{
	struct inode *inode = d_inode(dentry);
	struct inode *realinode = d_inode(realdentry);
	char buf[13];
	int len;

	len = snprintf(buf, sizeof(buf), format,
		       (int) (inode->i_nlink - realinode->i_nlink));

	return ovl_do_setxattr(ovl_dentry_upper(dentry),
			       OVL_XATTR_NLINK, buf, len, 0);
}

int ovl_set_nlink_upper(struct dentry *dentry)
{
	return ovl_set_nlink_common(dentry, ovl_dentry_upper(dentry), "U%+i");
}

int ovl_set_nlink_lower(struct dentry *dentry)
{
	return ovl_set_nlink_common(dentry, ovl_dentry_lower(dentry), "L%+i");
}

static unsigned int ovl_get_nlink(struct dentry *lowerdentry,
				  struct dentry *upperdentry,
				  unsigned int fallback)
{
	int nlink_diff;
	int nlink;
	char buf[13];
	int err;

	if (!lowerdentry || !upperdentry || d_inode(lowerdentry)->i_nlink == 1)
		return fallback;

	err = vfs_getxattr(upperdentry, OVL_XATTR_NLINK, &buf, sizeof(buf) - 1);
	if (err < 0)
		goto fail;

	buf[err] = '\0';
	if ((buf[0] != 'L' && buf[0] != 'U') ||
	    (buf[1] != '+' && buf[1] != '-'))
		goto fail;

	err = kstrtoint(buf + 1, 10, &nlink_diff);
	if (err < 0)
		goto fail;

	nlink = d_inode(buf[0] == 'L' ? lowerdentry : upperdentry)->i_nlink;
	nlink += nlink_diff;

	if (nlink <= 0)
		goto fail;

	return nlink;

fail:
	pr_warn_ratelimited("overlayfs: failed to get index nlink (%pd2, err=%i)\n",
			    upperdentry, err);
	return fallback;
}

552
struct inode *ovl_new_inode(struct super_block *sb, umode_t mode, dev_t rdev)
M
Miklos Szeredi 已提交
553 554 555 556 557
{
	struct inode *inode;

	inode = new_inode(sb);
	if (inode)
558
		ovl_fill_inode(inode, mode, rdev);
M
Miklos Szeredi 已提交
559 560 561 562 563 564

	return inode;
}

static int ovl_inode_test(struct inode *inode, void *data)
{
565
	return inode->i_private == data;
M
Miklos Szeredi 已提交
566 567 568 569
}

static int ovl_inode_set(struct inode *inode, void *data)
{
570
	inode->i_private = data;
M
Miklos Szeredi 已提交
571 572 573
	return 0;
}

574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
static bool ovl_verify_inode(struct inode *inode, struct dentry *lowerdentry,
			     struct dentry *upperdentry)
{
	struct inode *lowerinode = lowerdentry ? d_inode(lowerdentry) : NULL;

	/* Lower (origin) inode must match, even if NULL */
	if (ovl_inode_lower(inode) != lowerinode)
		return false;

	/*
	 * Allow non-NULL __upperdentry in inode even if upperdentry is NULL.
	 * This happens when finding a lower alias for a copied up hard link.
	 */
	if (upperdentry && ovl_inode_upper(inode) != d_inode(upperdentry))
		return false;

	return true;
}

593
struct inode *ovl_get_inode(struct dentry *dentry, struct dentry *upperdentry)
M
Miklos Szeredi 已提交
594
{
595 596
	struct dentry *lowerdentry = ovl_dentry_lower(dentry);
	struct inode *realinode = upperdentry ? d_inode(upperdentry) : NULL;
M
Miklos Szeredi 已提交
597 598
	struct inode *inode;

599 600 601
	if (!realinode)
		realinode = d_inode(lowerdentry);

602 603 604
	if (!S_ISDIR(realinode->i_mode) &&
	    (upperdentry || (lowerdentry && ovl_indexdir(dentry->d_sb)))) {
		struct inode *key = d_inode(lowerdentry ?: upperdentry);
605
		unsigned int nlink;
606 607 608

		inode = iget5_locked(dentry->d_sb, (unsigned long) key,
				     ovl_inode_test, ovl_inode_set, key);
609
		if (!inode)
610
			goto out_nomem;
611
		if (!(inode->i_state & I_NEW)) {
612 613 614 615 616 617 618 619 620 621
			/*
			 * Verify that the underlying files stored in the inode
			 * match those in the dentry.
			 */
			if (!ovl_verify_inode(inode, lowerdentry, upperdentry)) {
				iput(inode);
				inode = ERR_PTR(-ESTALE);
				goto out;
			}

622 623 624
			dput(upperdentry);
			goto out;
		}
M
Miklos Szeredi 已提交
625

626 627 628
		nlink = ovl_get_nlink(lowerdentry, upperdentry,
				      realinode->i_nlink);
		set_nlink(inode, nlink);
M
Miklos Szeredi 已提交
629 630 631
	} else {
		inode = new_inode(dentry->d_sb);
		if (!inode)
632
			goto out_nomem;
M
Miklos Szeredi 已提交
633
	}
M
Miklos Szeredi 已提交
634
	ovl_fill_inode(inode, realinode->i_mode, realinode->i_rdev);
635
	ovl_inode_init(inode, upperdentry, lowerdentry);
M
Miklos Szeredi 已提交
636 637 638 639

	if (upperdentry && ovl_is_impuredir(upperdentry))
		ovl_set_flag(OVL_IMPURE, inode);

M
Miklos Szeredi 已提交
640 641 642
	if (inode->i_state & I_NEW)
		unlock_new_inode(inode);
out:
M
Miklos Szeredi 已提交
643
	return inode;
644 645 646 647

out_nomem:
	inode = ERR_PTR(-ENOMEM);
	goto out;
M
Miklos Szeredi 已提交
648
}