dir.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 *
   4 * Copyright (C) 2011 Novell Inc.
   5 */
   6
   7#include <linux/fs.h>
   8#include <linux/namei.h>
   9#include <linux/xattr.h>
  10#include <linux/security.h>
  11#include <linux/cred.h>
  12#include <linux/module.h>
  13#include <linux/posix_acl.h>
  14#include <linux/posix_acl_xattr.h>
  15#include <linux/atomic.h>
  16#include <linux/ratelimit.h>
  17#include <linux/backing-file.h>
  18#include "overlayfs.h"
  19
  20static unsigned short ovl_redirect_max = 256;
  21module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
  22MODULE_PARM_DESC(redirect_max,
  23		 "Maximum length of absolute redirect xattr value");
  24
  25static int ovl_set_redirect(struct dentry *dentry, bool samedir);
  26
  27static int ovl_cleanup_locked(struct ovl_fs *ofs, struct inode *wdir,
  28			      struct dentry *wdentry)
  29{
  30	int err;
  31
  32	dget(wdentry);
  33	if (d_is_dir(wdentry))
  34		err = ovl_do_rmdir(ofs, wdir, wdentry);
  35	else
  36		err = ovl_do_unlink(ofs, wdir, wdentry);
  37	dput(wdentry);
  38
  39	if (err) {
  40		pr_err("cleanup of '%pd2' failed (%i)\n",
  41		       wdentry, err);
  42	}
  43
  44	return err;
  45}
  46
  47int ovl_cleanup(struct ovl_fs *ofs, struct dentry *workdir,
  48		struct dentry *wdentry)
  49{
  50	wdentry = start_removing_dentry(workdir, wdentry);
  51	if (IS_ERR(wdentry))
  52		return PTR_ERR(wdentry);
  53
  54	ovl_cleanup_locked(ofs, workdir->d_inode, wdentry);
  55	end_removing(wdentry);
  56
  57	return 0;
  58}
  59
  60void ovl_tempname(char name[OVL_TEMPNAME_SIZE])
  61{
  62	static atomic_t temp_id = ATOMIC_INIT(0);
  63
  64	/* counter is allowed to wrap, since temp dentries are ephemeral */
  65	snprintf(name, OVL_TEMPNAME_SIZE, "#%x", atomic_inc_return(&temp_id));
  66}
  67
  68static struct dentry *ovl_start_creating_temp(struct ovl_fs *ofs,
  69					      struct dentry *workdir)
  70{
  71	char name[OVL_TEMPNAME_SIZE];
  72
  73	ovl_tempname(name);
  74	return start_creating(ovl_upper_mnt_idmap(ofs), workdir,
  75			      &QSTR(name));
  76}
  77
  78static struct dentry *ovl_whiteout(struct ovl_fs *ofs)
  79{
  80	int err;
  81	struct dentry *whiteout, *link;
  82	struct dentry *workdir = ofs->workdir;
  83	struct inode *wdir = workdir->d_inode;
  84
  85	guard(mutex)(&ofs->whiteout_lock);
  86
  87	if (!ofs->whiteout) {
  88		whiteout = ovl_start_creating_temp(ofs, workdir);
  89		if (IS_ERR(whiteout))
  90			return whiteout;
  91		err = ovl_do_whiteout(ofs, wdir, whiteout);
  92		if (!err)
  93			ofs->whiteout = dget(whiteout);
  94		end_creating(whiteout);
  95		if (err)
  96			return ERR_PTR(err);
  97	}
  98
  99	if (!ofs->no_shared_whiteout) {
 100		link = ovl_start_creating_temp(ofs, workdir);
 101		if (IS_ERR(link))
 102			return link;
 103		err = ovl_do_link(ofs, ofs->whiteout, wdir, link);
 104		if (!err)
 105			whiteout = dget(link);
 106		end_creating(link);
 107		if (!err)
 108			return whiteout;
 109
 110		if (err != -EMLINK) {
 111			pr_warn("Failed to link whiteout - disabling whiteout inode sharing(nlink=%u, err=%u)\n",
 112				ofs->whiteout->d_inode->i_nlink,
 113				err);
 114			ofs->no_shared_whiteout = true;
 115		}
 116	}
 117	whiteout = ofs->whiteout;
 118	ofs->whiteout = NULL;
 119	return whiteout;
 120}
 121
 122int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct dentry *dir,
 123			     struct dentry *dentry)
 124{
 125	struct dentry *whiteout;
 126	struct renamedata rd = {};
 127	int err;
 128	int flags = 0;
 129
 130	whiteout = ovl_whiteout(ofs);
 131	err = PTR_ERR(whiteout);
 132	if (IS_ERR(whiteout))
 133		return err;
 134
 135	if (d_is_dir(dentry))
 136		flags = RENAME_EXCHANGE;
 137
 138	rd.mnt_idmap = ovl_upper_mnt_idmap(ofs);
 139	rd.old_parent = ofs->workdir;
 140	rd.new_parent = dir;
 141	rd.flags = flags;
 142	err = start_renaming_two_dentries(&rd, whiteout, dentry);
 143	if (!err) {
 144		err = ovl_do_rename_rd(&rd);
 145		end_renaming(&rd);
 146	}
 147	if (err)
 148		goto kill_whiteout;
 149	if (flags)
 150		ovl_cleanup(ofs, ofs->workdir, dentry);
 151
 152out:
 153	dput(whiteout);
 154	return err;
 155
 156kill_whiteout:
 157	ovl_cleanup(ofs, ofs->workdir, whiteout);
 158	goto out;
 159}
 160
 161struct dentry *ovl_create_real(struct ovl_fs *ofs, struct dentry *parent,
 162			       struct dentry *newdentry, struct ovl_cattr *attr)
 163{
 164	struct inode *dir = parent->d_inode;
 165	int err;
 166
 167	if (IS_ERR(newdentry))
 168		return newdentry;
 169
 170	err = -ESTALE;
 171	if (newdentry->d_inode)
 172		goto out;
 173
 174	if (attr->hardlink) {
 175		err = ovl_do_link(ofs, attr->hardlink, dir, newdentry);
 176	} else {
 177		switch (attr->mode & S_IFMT) {
 178		case S_IFREG:
 179			err = ovl_do_create(ofs, dir, newdentry, attr->mode);
 180			break;
 181
 182		case S_IFDIR:
 183			/* mkdir is special... */
 184			newdentry =  ovl_do_mkdir(ofs, dir, newdentry, attr->mode);
 185			err = PTR_ERR_OR_ZERO(newdentry);
 186			/* expect to inherit casefolding from workdir/upperdir */
 187			if (!err && ofs->casefold != ovl_dentry_casefolded(newdentry)) {
 188				pr_warn_ratelimited("wrong inherited casefold (%pd2)\n",
 189						    newdentry);
 190				end_creating(newdentry);
 191				err = -EINVAL;
 192			}
 193			break;
 194
 195		case S_IFCHR:
 196		case S_IFBLK:
 197		case S_IFIFO:
 198		case S_IFSOCK:
 199			err = ovl_do_mknod(ofs, dir, newdentry, attr->mode,
 200					   attr->rdev);
 201			break;
 202
 203		case S_IFLNK:
 204			err = ovl_do_symlink(ofs, dir, newdentry, attr->link);
 205			break;
 206
 207		default:
 208			err = -EPERM;
 209		}
 210	}
 211	if (err)
 212		goto out;
 213
 214	if (WARN_ON(!newdentry->d_inode)) {
 215		/*
 216		 * Not quite sure if non-instantiated dentry is legal or not.
 217		 * VFS doesn't seem to care so check and warn here.
 218		 */
 219		err = -EIO;
 220	} else if (d_unhashed(newdentry)) {
 221		struct dentry *d;
 222		/*
 223		 * Some filesystems (i.e. casefolded) may return an unhashed
 224		 * negative dentry from the ovl_lookup_upper() call before
 225		 * ovl_create_real().
 226		 * In that case, lookup again after making the newdentry
 227		 * positive, so ovl_create_upper() always returns a hashed
 228		 * positive dentry.
 229		 */
 230		d = ovl_lookup_upper(ofs, newdentry->d_name.name, parent,
 231				     newdentry->d_name.len);
 232		dput(newdentry);
 233		if (IS_ERR_OR_NULL(d))
 234			err = d ? PTR_ERR(d) : -ENOENT;
 235		else
 236			return d;
 237	}
 238out:
 239	if (err) {
 240		end_creating(newdentry);
 241		return ERR_PTR(err);
 242	}
 243	return newdentry;
 244}
 245
 246struct dentry *ovl_create_temp(struct ovl_fs *ofs, struct dentry *workdir,
 247			       struct ovl_cattr *attr)
 248{
 249	struct dentry *ret;
 250	ret = ovl_start_creating_temp(ofs, workdir);
 251	if (IS_ERR(ret))
 252		return ret;
 253	ret = ovl_create_real(ofs, workdir, ret, attr);
 254	return end_creating_keep(ret);
 255}
 256
 257static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
 258			       int xerr)
 259{
 260	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 261	int err;
 262
 263	err = ovl_check_setxattr(ofs, upper, OVL_XATTR_OPAQUE, "y", 1, xerr);
 264	if (!err)
 265		ovl_dentry_set_opaque(dentry);
 266
 267	return err;
 268}
 269
 270static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
 271{
 272	/*
 273	 * Fail with -EIO when trying to create opaque dir and upper doesn't
 274	 * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
 275	 * return a specific error for noxattr case.
 276	 */
 277	return ovl_set_opaque_xerr(dentry, upperdentry, -EIO);
 278}
 279
 280/*
 281 * Common operations required to be done after creation of file on upper.
 282 * If @hardlink is false, then @inode is a pre-allocated inode, we may or
 283 * may not use to instantiate the new dentry.
 284 */
 285static int ovl_instantiate(struct dentry *dentry, struct inode *inode,
 286			   struct dentry *newdentry, bool hardlink, struct file *tmpfile)
 287{
 288	struct ovl_inode_params oip = {
 289		.upperdentry = newdentry,
 290		.newinode = inode,
 291	};
 292
 293	ovl_dentry_set_upper_alias(dentry);
 294	ovl_dentry_init_reval(dentry, newdentry, NULL);
 295
 296	if (!hardlink) {
 297		/*
 298		 * ovl_obtain_alias() can be called after ovl_create_real()
 299		 * and before we get here, so we may get an inode from cache
 300		 * with the same real upperdentry that is not the inode we
 301		 * pre-allocated.  In this case we will use the cached inode
 302		 * to instantiate the new dentry.
 303		 *
 304		 * XXX: if we ever use ovl_obtain_alias() to decode directory
 305		 * file handles, need to use ovl_get_inode_locked() and
 306		 * d_instantiate_new() here to prevent from creating two
 307		 * hashed directory inode aliases.  We then need to return
 308		 * the obtained alias to ovl_mkdir().
 309		 */
 310		inode = ovl_get_inode(dentry->d_sb, &oip);
 311		if (IS_ERR(inode))
 312			return PTR_ERR(inode);
 313		if (inode == oip.newinode)
 314			ovl_set_flag(OVL_UPPERDATA, inode);
 315	} else {
 316		WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
 317		dput(newdentry);
 318		inc_nlink(inode);
 319	}
 320
 321	if (tmpfile)
 322		d_mark_tmpfile(tmpfile, inode);
 323
 324	d_instantiate(dentry, inode);
 325	if (inode != oip.newinode) {
 326		pr_warn_ratelimited("newly created inode found in cache (%pd2)\n",
 327				    dentry);
 328	}
 329
 330	/* Force lookup of new upper hardlink to find its lower */
 331	if (hardlink)
 332		d_drop(dentry);
 333
 334	return 0;
 335}
 336
 337static bool ovl_type_merge(struct dentry *dentry)
 338{
 339	return OVL_TYPE_MERGE(ovl_path_type(dentry));
 340}
 341
 342static bool ovl_type_origin(struct dentry *dentry)
 343{
 344	return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
 345}
 346
 347static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
 348			    struct ovl_cattr *attr)
 349{
 350	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 351	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 352	struct dentry *newdentry;
 353	int err;
 354
 355	newdentry = ovl_start_creating_upper(ofs, upperdir,
 356					     &QSTR_LEN(dentry->d_name.name,
 357						       dentry->d_name.len));
 358	if (IS_ERR(newdentry))
 359		return PTR_ERR(newdentry);
 360	newdentry = ovl_create_real(ofs, upperdir, newdentry, attr);
 361	if (IS_ERR(newdentry))
 362		return PTR_ERR(newdentry);
 363
 364	end_creating_keep(newdentry);
 365
 366	if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry) &&
 367	    !ovl_allow_offline_changes(ofs)) {
 368		/* Setting opaque here is just an optimization, allow to fail */
 369		ovl_set_opaque(dentry, newdentry);
 370	}
 371
 372	ovl_dir_modified(dentry->d_parent, false);
 373	err = ovl_instantiate(dentry, inode, newdentry, !!attr->hardlink, NULL);
 374	if (err)
 375		goto out_cleanup;
 376	return 0;
 377
 378out_cleanup:
 379	ovl_cleanup(ofs, upperdir, newdentry);
 380	dput(newdentry);
 381	return err;
 382}
 383
 384static struct dentry *ovl_clear_empty(struct dentry *dentry,
 385				      struct list_head *list)
 386{
 387	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 388	struct dentry *workdir = ovl_workdir(dentry);
 389	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 390	struct renamedata rd = {};
 391	struct path upperpath;
 392	struct dentry *upper;
 393	struct dentry *opaquedir;
 394	struct kstat stat;
 395	int err;
 396
 397	if (WARN_ON(!workdir))
 398		return ERR_PTR(-EROFS);
 399
 400	ovl_path_upper(dentry, &upperpath);
 401	err = vfs_getattr(&upperpath, &stat,
 402			  STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
 403	if (err)
 404		goto out;
 405
 406	err = -ESTALE;
 407	if (!S_ISDIR(stat.mode))
 408		goto out;
 409	upper = upperpath.dentry;
 410
 411	opaquedir = ovl_create_temp(ofs, workdir, OVL_CATTR(stat.mode));
 412	err = PTR_ERR(opaquedir);
 413	if (IS_ERR(opaquedir))
 414		goto out;
 415
 416	rd.mnt_idmap = ovl_upper_mnt_idmap(ofs);
 417	rd.old_parent = workdir;
 418	rd.new_parent = upperdir;
 419	rd.flags = RENAME_EXCHANGE;
 420	err = start_renaming_two_dentries(&rd, opaquedir, upper);
 421	if (err)
 422		goto out_cleanup_unlocked;
 423
 424	err = ovl_copy_xattr(dentry->d_sb, &upperpath, opaquedir);
 425	if (err)
 426		goto out_cleanup;
 427
 428	err = ovl_set_opaque(dentry, opaquedir);
 429	if (err)
 430		goto out_cleanup;
 431
 432	inode_lock(opaquedir->d_inode);
 433	err = ovl_set_attr(ofs, opaquedir, &stat);
 434	inode_unlock(opaquedir->d_inode);
 435	if (err)
 436		goto out_cleanup;
 437
 438	err = ovl_do_rename_rd(&rd);
 439	end_renaming(&rd);
 440	if (err)
 441		goto out_cleanup_unlocked;
 442
 443	ovl_cleanup_whiteouts(ofs, upper, list);
 444	ovl_cleanup(ofs, workdir, upper);
 445
 446	/* dentry's upper doesn't match now, get rid of it */
 447	d_drop(dentry);
 448
 449	return opaquedir;
 450
 451out_cleanup:
 452	end_renaming(&rd);
 453out_cleanup_unlocked:
 454	ovl_cleanup(ofs, workdir, opaquedir);
 455	dput(opaquedir);
 456out:
 457	return ERR_PTR(err);
 458}
 459
 460static int ovl_set_upper_acl(struct ovl_fs *ofs, struct dentry *upperdentry,
 461			     const char *acl_name, struct posix_acl *acl)
 462{
 463	if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
 464		return 0;
 465
 466	return ovl_do_set_acl(ofs, upperdentry, acl_name, acl);
 467}
 468
 469static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
 470				    struct ovl_cattr *cattr)
 471{
 472	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 473	struct dentry *workdir = ovl_workdir(dentry);
 474	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 475	struct renamedata rd = {};
 476	struct dentry *upper;
 477	struct dentry *newdentry;
 478	int err;
 479	struct posix_acl *acl, *default_acl;
 480	bool hardlink = !!cattr->hardlink;
 481
 482	if (WARN_ON(!workdir))
 483		return -EROFS;
 484
 485	if (!hardlink) {
 486		err = posix_acl_create(dentry->d_parent->d_inode,
 487				       &cattr->mode, &default_acl, &acl);
 488		if (err)
 489			return err;
 490	}
 491
 492	upper = ovl_lookup_upper_unlocked(ofs, dentry->d_name.name, upperdir,
 493					  dentry->d_name.len);
 494	err = PTR_ERR(upper);
 495	if (IS_ERR(upper))
 496		goto out;
 497
 498	err = -ESTALE;
 499	if (d_is_negative(upper) || !ovl_upper_is_whiteout(ofs, upper))
 500		goto out_dput;
 501
 502	newdentry = ovl_create_temp(ofs, workdir, cattr);
 503	err = PTR_ERR(newdentry);
 504	if (IS_ERR(newdentry))
 505		goto out_dput;
 506
 507	rd.mnt_idmap = ovl_upper_mnt_idmap(ofs);
 508	rd.old_parent = workdir;
 509	rd.new_parent = upperdir;
 510	rd.flags = 0;
 511	err = start_renaming_two_dentries(&rd, newdentry, upper);
 512	if (err)
 513		goto out_cleanup_unlocked;
 514
 515	/*
 516	 * mode could have been mutilated due to umask (e.g. sgid directory)
 517	 */
 518	if (!hardlink &&
 519	    !S_ISLNK(cattr->mode) &&
 520	    newdentry->d_inode->i_mode != cattr->mode) {
 521		struct iattr attr = {
 522			.ia_valid = ATTR_MODE,
 523			.ia_mode = cattr->mode,
 524		};
 525		inode_lock(newdentry->d_inode);
 526		err = ovl_do_notify_change(ofs, newdentry, &attr);
 527		inode_unlock(newdentry->d_inode);
 528		if (err)
 529			goto out_cleanup;
 530	}
 531	if (!hardlink) {
 532		err = ovl_set_upper_acl(ofs, newdentry,
 533					XATTR_NAME_POSIX_ACL_ACCESS, acl);
 534		if (err)
 535			goto out_cleanup;
 536
 537		err = ovl_set_upper_acl(ofs, newdentry,
 538					XATTR_NAME_POSIX_ACL_DEFAULT, default_acl);
 539		if (err)
 540			goto out_cleanup;
 541	}
 542
 543	if (!hardlink && S_ISDIR(cattr->mode)) {
 544		err = ovl_set_opaque(dentry, newdentry);
 545		if (err)
 546			goto out_cleanup;
 547
 548		rd.flags = RENAME_EXCHANGE;
 549		err = ovl_do_rename_rd(&rd);
 550		end_renaming(&rd);
 551		if (err)
 552			goto out_cleanup_unlocked;
 553
 554		ovl_cleanup(ofs, workdir, upper);
 555	} else {
 556		err = ovl_do_rename_rd(&rd);
 557		end_renaming(&rd);
 558		if (err)
 559			goto out_cleanup_unlocked;
 560	}
 561	ovl_dir_modified(dentry->d_parent, false);
 562	err = ovl_instantiate(dentry, inode, newdentry, hardlink, NULL);
 563	if (err) {
 564		ovl_cleanup(ofs, upperdir, newdentry);
 565		dput(newdentry);
 566	}
 567out_dput:
 568	dput(upper);
 569out:
 570	if (!hardlink) {
 571		posix_acl_release(acl);
 572		posix_acl_release(default_acl);
 573	}
 574	return err;
 575
 576out_cleanup:
 577	end_renaming(&rd);
 578out_cleanup_unlocked:
 579	ovl_cleanup(ofs, workdir, newdentry);
 580	dput(newdentry);
 581	goto out_dput;
 582}
 583
 584static const struct cred *ovl_override_creator_creds(const struct cred *original_creds,
 585						     struct dentry *dentry, struct inode *inode, umode_t mode)
 586{
 587	int err;
 588
 589	if (WARN_ON_ONCE(current->cred != ovl_creds(dentry->d_sb)))
 590		return ERR_PTR(-EINVAL);
 591
 592	CLASS(prepare_creds, override_cred)();
 593	if (!override_cred)
 594		return ERR_PTR(-ENOMEM);
 595
 596	override_cred->fsuid = inode->i_uid;
 597	override_cred->fsgid = inode->i_gid;
 598
 599	err = security_dentry_create_files_as(dentry, mode, &dentry->d_name,
 600					      original_creds, override_cred);
 601	if (err)
 602		return ERR_PTR(err);
 603
 604	return override_creds(no_free_ptr(override_cred));
 605}
 606
 607static void ovl_revert_creator_creds(const struct cred *old_cred)
 608{
 609	const struct cred *override_cred;
 610
 611	override_cred = revert_creds(old_cred);
 612	put_cred(override_cred);
 613}
 614
 615DEFINE_CLASS(ovl_override_creator_creds,
 616	     const struct cred *,
 617	     if (!IS_ERR_OR_NULL(_T)) ovl_revert_creator_creds(_T),
 618	     ovl_override_creator_creds(original_creds, dentry, inode, mode),
 619	     const struct cred *original_creds,
 620	     struct dentry *dentry,
 621	     struct inode *inode,
 622	     umode_t mode)
 623
 624static int ovl_create_handle_whiteouts(struct dentry *dentry,
 625				       struct inode *inode,
 626				       struct ovl_cattr *attr)
 627{
 628	if (!ovl_dentry_is_whiteout(dentry))
 629		return ovl_create_upper(dentry, inode, attr);
 630
 631	return ovl_create_over_whiteout(dentry, inode, attr);
 632}
 633
 634static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
 635			      struct ovl_cattr *attr, bool origin)
 636{
 637	int err;
 638	struct dentry *parent = dentry->d_parent;
 639
 640	scoped_class(override_creds_ovl, original_creds, dentry->d_sb) {
 641		/*
 642		 * When linking a file with copy up origin into a new parent, mark the
 643		 * new parent dir "impure".
 644		 */
 645		if (origin) {
 646			err = ovl_set_impure(parent, ovl_dentry_upper(parent));
 647			if (err)
 648				return err;
 649		}
 650
 651		/*
 652		 * In the creation cases(create, mkdir, mknod, symlink),
 653		 * ovl should transfer current's fs{u,g}id to underlying
 654		 * fs. Because underlying fs want to initialize its new
 655		 * inode owner using current's fs{u,g}id. And in this
 656		 * case, the @inode is a new inode that is initialized
 657		 * in inode_init_owner() to current's fs{u,g}id. So use
 658		 * the inode's i_{u,g}id to override the cred's fs{u,g}id.
 659		 *
 660		 * But in the other hardlink case, ovl_link() does not
 661		 * create a new inode, so just use the ovl mounter's
 662		 * fs{u,g}id.
 663		 */
 664
 665		if (attr->hardlink)
 666			return ovl_create_handle_whiteouts(dentry, inode, attr);
 667
 668		scoped_class(ovl_override_creator_creds, cred, original_creds, dentry, inode, attr->mode) {
 669			if (IS_ERR(cred))
 670				return PTR_ERR(cred);
 671			return ovl_create_handle_whiteouts(dentry, inode, attr);
 672		}
 673	}
 674	return err;
 675}
 676
 677static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
 678			     const char *link)
 679{
 680	int err;
 681	struct inode *inode;
 682	struct ovl_cattr attr = {
 683		.rdev = rdev,
 684		.link = link,
 685	};
 686
 687	err = ovl_copy_up(dentry->d_parent);
 688	if (err)
 689		return err;
 690
 691	err = ovl_want_write(dentry);
 692	if (err)
 693		goto out;
 694
 695	/* Preallocate inode to be used by ovl_get_inode() */
 696	err = -ENOMEM;
 697	inode = ovl_new_inode(dentry->d_sb, mode, rdev);
 698	if (!inode)
 699		goto out_drop_write;
 700
 701	spin_lock(&inode->i_lock);
 702	inode_state_set(inode, I_CREATING);
 703	spin_unlock(&inode->i_lock);
 704
 705	inode_init_owner(&nop_mnt_idmap, inode, dentry->d_parent->d_inode, mode);
 706	attr.mode = inode->i_mode;
 707
 708	err = ovl_create_or_link(dentry, inode, &attr, false);
 709	/* Did we end up using the preallocated inode? */
 710	if (inode != d_inode(dentry))
 711		iput(inode);
 712
 713out_drop_write:
 714	ovl_drop_write(dentry);
 715out:
 716	return err;
 717}
 718
 719static int ovl_create(struct mnt_idmap *idmap, struct inode *dir,
 720		      struct dentry *dentry, umode_t mode, bool excl)
 721{
 722	return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
 723}
 724
 725static struct dentry *ovl_mkdir(struct mnt_idmap *idmap, struct inode *dir,
 726				struct dentry *dentry, umode_t mode)
 727{
 728	return ERR_PTR(ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL));
 729}
 730
 731static int ovl_mknod(struct mnt_idmap *idmap, struct inode *dir,
 732		     struct dentry *dentry, umode_t mode, dev_t rdev)
 733{
 734	/* Don't allow creation of "whiteout" on overlay */
 735	if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
 736		return -EPERM;
 737
 738	return ovl_create_object(dentry, mode, rdev, NULL);
 739}
 740
 741static int ovl_symlink(struct mnt_idmap *idmap, struct inode *dir,
 742		       struct dentry *dentry, const char *link)
 743{
 744	return ovl_create_object(dentry, S_IFLNK, 0, link);
 745}
 746
 747static int ovl_set_link_redirect(struct dentry *dentry)
 748{
 749	with_ovl_creds(dentry->d_sb)
 750		return ovl_set_redirect(dentry, false);
 751}
 752
 753static int ovl_link(struct dentry *old, struct inode *newdir,
 754		    struct dentry *new)
 755{
 756	int err;
 757	struct inode *inode;
 758
 759	err = ovl_copy_up(old);
 760	if (err)
 761		goto out;
 762
 763	err = ovl_copy_up(new->d_parent);
 764	if (err)
 765		goto out;
 766
 767	err = ovl_nlink_start(old);
 768	if (err)
 769		goto out;
 770
 771	if (ovl_is_metacopy_dentry(old)) {
 772		err = ovl_set_link_redirect(old);
 773		if (err)
 774			goto out_nlink_end;
 775	}
 776
 777	inode = d_inode(old);
 778	ihold(inode);
 779
 780	err = ovl_create_or_link(new, inode,
 781			&(struct ovl_cattr) {.hardlink = ovl_dentry_upper(old)},
 782			ovl_type_origin(old));
 783	if (err)
 784		iput(inode);
 785
 786out_nlink_end:
 787	ovl_nlink_end(old);
 788out:
 789	return err;
 790}
 791
 792static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
 793{
 794	return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
 795}
 796
 797static int ovl_remove_and_whiteout(struct dentry *dentry,
 798				   struct list_head *list)
 799{
 800	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 801	struct dentry *workdir = ovl_workdir(dentry);
 802	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 803	struct dentry *upper;
 804	struct dentry *opaquedir = NULL;
 805	int err;
 806
 807	if (WARN_ON(!workdir))
 808		return -EROFS;
 809
 810	if (!list_empty(list)) {
 811		opaquedir = ovl_clear_empty(dentry, list);
 812		err = PTR_ERR(opaquedir);
 813		if (IS_ERR(opaquedir))
 814			goto out;
 815	}
 816
 817	upper = ovl_lookup_upper_unlocked(ofs, dentry->d_name.name, upperdir,
 818					  dentry->d_name.len);
 819	err = PTR_ERR(upper);
 820	if (IS_ERR(upper))
 821		goto out_dput;
 822
 823	err = -ESTALE;
 824	if ((opaquedir && upper != opaquedir) ||
 825	    (!opaquedir && ovl_dentry_upper(dentry) &&
 826	     !ovl_matches_upper(dentry, upper))) {
 827		goto out_dput_upper;
 828	}
 829
 830	err = ovl_cleanup_and_whiteout(ofs, upperdir, upper);
 831	if (!err)
 832		ovl_dir_modified(dentry->d_parent, true);
 833
 834	d_drop(dentry);
 835out_dput_upper:
 836	dput(upper);
 837out_dput:
 838	dput(opaquedir);
 839out:
 840	return err;
 841}
 842
 843static int ovl_remove_upper(struct dentry *dentry, bool is_dir,
 844			    struct list_head *list)
 845{
 846	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
 847	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
 848	struct inode *dir = upperdir->d_inode;
 849	struct dentry *upper;
 850	struct dentry *opaquedir = NULL;
 851	int err;
 852
 853	if (!list_empty(list)) {
 854		opaquedir = ovl_clear_empty(dentry, list);
 855		err = PTR_ERR(opaquedir);
 856		if (IS_ERR(opaquedir))
 857			goto out;
 858	}
 859
 860	upper = ovl_start_removing_upper(ofs, upperdir,
 861					 &QSTR_LEN(dentry->d_name.name,
 862						   dentry->d_name.len));
 863	err = PTR_ERR(upper);
 864	if (IS_ERR(upper))
 865		goto out_dput;
 866
 867	err = -ESTALE;
 868	if ((opaquedir && upper != opaquedir) ||
 869	    (!opaquedir && !ovl_matches_upper(dentry, upper)))
 870		goto out_unlock;
 871
 872	if (is_dir)
 873		err = ovl_do_rmdir(ofs, dir, upper);
 874	else
 875		err = ovl_do_unlink(ofs, dir, upper);
 876	ovl_dir_modified(dentry->d_parent, ovl_type_origin(dentry));
 877
 878	/*
 879	 * Keeping this dentry hashed would mean having to release
 880	 * upperpath/lowerpath, which could only be done if we are the
 881	 * sole user of this dentry.  Too tricky...  Just unhash for
 882	 * now.
 883	 */
 884	if (!err)
 885		d_drop(dentry);
 886out_unlock:
 887	end_removing(upper);
 888out_dput:
 889	dput(opaquedir);
 890out:
 891	return err;
 892}
 893
 894static bool ovl_pure_upper(struct dentry *dentry)
 895{
 896	return !ovl_dentry_lower(dentry) &&
 897	       !ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
 898}
 899
 900static void ovl_drop_nlink(struct dentry *dentry)
 901{
 902	struct inode *inode = d_inode(dentry);
 903	struct dentry *alias;
 904
 905	/* Try to find another, hashed alias */
 906	spin_lock(&inode->i_lock);
 907	hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
 908		if (alias != dentry && !d_unhashed(alias))
 909			break;
 910	}
 911	spin_unlock(&inode->i_lock);
 912
 913	/*
 914	 * Changes to underlying layers may cause i_nlink to lose sync with
 915	 * reality.  In this case prevent the link count from going to zero
 916	 * prematurely.
 917	 */
 918	if (inode->i_nlink > !!alias)
 919		drop_nlink(inode);
 920}
 921
 922static int ovl_do_remove(struct dentry *dentry, bool is_dir)
 923{
 924	int err;
 925	bool lower_positive = ovl_lower_positive(dentry);
 926	LIST_HEAD(list);
 927
 928	/* No need to clean pure upper removed by vfs_rmdir() */
 929	if (is_dir && (lower_positive || !ovl_pure_upper(dentry))) {
 930		err = ovl_check_empty_dir(dentry, &list);
 931		if (err)
 932			goto out;
 933	}
 934
 935	err = ovl_copy_up(dentry->d_parent);
 936	if (err)
 937		goto out;
 938
 939	err = ovl_nlink_start(dentry);
 940	if (err)
 941		goto out;
 942
 943	with_ovl_creds(dentry->d_sb) {
 944		if (!lower_positive)
 945			err = ovl_remove_upper(dentry, is_dir, &list);
 946		else
 947			err = ovl_remove_and_whiteout(dentry, &list);
 948	}
 949	if (!err) {
 950		if (is_dir)
 951			clear_nlink(dentry->d_inode);
 952		else
 953			ovl_drop_nlink(dentry);
 954	}
 955	ovl_nlink_end(dentry);
 956
 957	/*
 958	 * Copy ctime
 959	 *
 960	 * Note: we fail to update ctime if there was no copy-up, only a
 961	 * whiteout
 962	 */
 963	if (ovl_dentry_upper(dentry))
 964		ovl_copyattr(d_inode(dentry));
 965
 966out:
 967	ovl_cache_free(&list);
 968	return err;
 969}
 970
 971static int ovl_unlink(struct inode *dir, struct dentry *dentry)
 972{
 973	return ovl_do_remove(dentry, false);
 974}
 975
 976static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
 977{
 978	return ovl_do_remove(dentry, true);
 979}
 980
 981static bool ovl_type_merge_or_lower(struct dentry *dentry)
 982{
 983	enum ovl_path_type type = ovl_path_type(dentry);
 984
 985	return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
 986}
 987
 988static bool ovl_can_move(struct dentry *dentry)
 989{
 990	return ovl_redirect_dir(OVL_FS(dentry->d_sb)) ||
 991		!d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
 992}
 993
 994static char *ovl_get_redirect(struct dentry *dentry, bool abs_redirect)
 995{
 996	char *buf, *ret;
 997	struct dentry *d, *tmp;
 998	int buflen = ovl_redirect_max + 1;
 999
1000	if (!abs_redirect) {
1001		ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
1002			       GFP_KERNEL);
1003		goto out;
1004	}
1005
1006	buf = ret = kmalloc(buflen, GFP_KERNEL);
1007	if (!buf)
1008		goto out;
1009
1010	buflen--;
1011	buf[buflen] = '\0';
1012	for (d = dget(dentry); !IS_ROOT(d);) {
1013		const char *name;
1014		int thislen;
1015
1016		spin_lock(&d->d_lock);
1017		name = ovl_dentry_get_redirect(d);
1018		if (name) {
1019			thislen = strlen(name);
1020		} else {
1021			name = d->d_name.name;
1022			thislen = d->d_name.len;
1023		}
1024
1025		/* If path is too long, fall back to userspace move */
1026		if (thislen + (name[0] != '/') > buflen) {
1027			ret = ERR_PTR(-EXDEV);
1028			spin_unlock(&d->d_lock);
1029			goto out_put;
1030		}
1031
1032		buflen -= thislen;
1033		memcpy(&buf[buflen], name, thislen);
1034		spin_unlock(&d->d_lock);
1035		tmp = dget_parent(d);
1036
1037		dput(d);
1038		d = tmp;
1039
1040		/* Absolute redirect: finished */
1041		if (buf[buflen] == '/')
1042			break;
1043		buflen--;
1044		buf[buflen] = '/';
1045	}
1046	ret = kstrdup(&buf[buflen], GFP_KERNEL);
1047out_put:
1048	dput(d);
1049	kfree(buf);
1050out:
1051	return ret ? ret : ERR_PTR(-ENOMEM);
1052}
1053
1054static bool ovl_need_absolute_redirect(struct dentry *dentry, bool samedir)
1055{
1056	struct dentry *lowerdentry;
1057
1058	if (!samedir)
1059		return true;
1060
1061	if (d_is_dir(dentry))
1062		return false;
1063
1064	/*
1065	 * For non-dir hardlinked files, we need absolute redirects
1066	 * in general as two upper hardlinks could be in different
1067	 * dirs. We could put a relative redirect now and convert
1068	 * it to absolute redirect later. But when nlink > 1 and
1069	 * indexing is on, that means relative redirect needs to be
1070	 * converted to absolute during copy up of another lower
1071	 * hardllink as well.
1072	 *
1073	 * So without optimizing too much, just check if lower is
1074	 * a hard link or not. If lower is hard link, put absolute
1075	 * redirect.
1076	 */
1077	lowerdentry = ovl_dentry_lower(dentry);
1078	return (d_inode(lowerdentry)->i_nlink > 1);
1079}
1080
1081static int ovl_set_redirect(struct dentry *dentry, bool samedir)
1082{
1083	int err;
1084	struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
1085	const char *redirect = ovl_dentry_get_redirect(dentry);
1086	bool absolute_redirect = ovl_need_absolute_redirect(dentry, samedir);
1087
1088	if (redirect && (!absolute_redirect || redirect[0] == '/'))
1089		return 0;
1090
1091	redirect = ovl_get_redirect(dentry, absolute_redirect);
1092	if (IS_ERR(redirect))
1093		return PTR_ERR(redirect);
1094
1095	err = ovl_check_setxattr(ofs, ovl_dentry_upper(dentry),
1096				 OVL_XATTR_REDIRECT,
1097				 redirect, strlen(redirect), -EXDEV);
1098	if (!err) {
1099		spin_lock(&dentry->d_lock);
1100		ovl_dentry_set_redirect(dentry, redirect);
1101		spin_unlock(&dentry->d_lock);
1102	} else {
1103		kfree(redirect);
1104		pr_warn_ratelimited("failed to set redirect (%i)\n",
1105				    err);
1106		/* Fall back to userspace copy-up */
1107		err = -EXDEV;
1108	}
1109	return err;
1110}
1111
1112struct ovl_renamedata {
1113	struct renamedata;
1114	struct dentry *opaquedir;
1115	bool cleanup_whiteout;
1116	bool update_nlink;
1117	bool overwrite;
1118};
1119
1120static int ovl_rename_start(struct ovl_renamedata *ovlrd, struct list_head *list)
1121{
1122	struct dentry *old = ovlrd->old_dentry;
1123	struct dentry *new = ovlrd->new_dentry;
1124	bool is_dir = d_is_dir(old);
1125	bool new_is_dir = d_is_dir(new);
1126	int err;
1127
1128	if (ovlrd->flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
1129		return -EINVAL;
1130
1131	ovlrd->flags &= ~RENAME_NOREPLACE;
1132
1133	/* Don't copy up directory trees */
1134	err = -EXDEV;
1135	if (!ovl_can_move(old))
1136		return err;
1137	if (!ovlrd->overwrite && !ovl_can_move(new))
1138		return err;
1139
1140	if (ovlrd->overwrite && new_is_dir && !ovl_pure_upper(new)) {
1141		err = ovl_check_empty_dir(new, list);
1142		if (err)
1143			return err;
1144	}
1145
1146	if (ovlrd->overwrite) {
1147		if (ovl_lower_positive(old)) {
1148			if (!ovl_dentry_is_whiteout(new)) {
1149				/* Whiteout source */
1150				ovlrd->flags |= RENAME_WHITEOUT;
1151			} else {
1152				/* Switch whiteouts */
1153				ovlrd->flags |= RENAME_EXCHANGE;
1154			}
1155		} else if (is_dir && ovl_dentry_is_whiteout(new)) {
1156			ovlrd->flags |= RENAME_EXCHANGE;
1157			ovlrd->cleanup_whiteout = true;
1158		}
1159	}
1160
1161	err = ovl_copy_up(old);
1162	if (err)
1163		return err;
1164
1165	err = ovl_copy_up(new->d_parent);
1166	if (err)
1167		return err;
1168
1169	if (!ovlrd->overwrite) {
1170		err = ovl_copy_up(new);
1171		if (err)
1172			return err;
1173	} else if (d_inode(new)) {
1174		err = ovl_nlink_start(new);
1175		if (err)
1176			return err;
1177
1178		ovlrd->update_nlink = true;
1179	}
1180
1181	if (!ovlrd->update_nlink) {
1182		/* ovl_nlink_start() took ovl_want_write() */
1183		err = ovl_want_write(old);
1184		if (err)
1185			return err;
1186	}
1187
1188	return 0;
1189}
1190
1191static int ovl_rename_upper(struct ovl_renamedata *ovlrd, struct list_head *list)
1192{
1193	struct dentry *old = ovlrd->old_dentry;
1194	struct dentry *new = ovlrd->new_dentry;
1195	struct ovl_fs *ofs = OVL_FS(old->d_sb);
1196	struct dentry *old_upperdir = ovl_dentry_upper(old->d_parent);
1197	struct dentry *new_upperdir = ovl_dentry_upper(new->d_parent);
1198	bool is_dir = d_is_dir(old);
1199	bool new_is_dir = d_is_dir(new);
1200	bool samedir = old->d_parent == new->d_parent;
1201	struct renamedata rd = {};
1202	struct dentry *de;
1203	struct dentry *whiteout = NULL;
1204	bool old_opaque, new_opaque;
1205	int err;
1206
1207	if (!list_empty(list)) {
1208		de = ovl_clear_empty(new, list);
1209		if (IS_ERR(de))
1210			return PTR_ERR(de);
1211		ovlrd->opaquedir = de;
1212	}
1213
1214	if (!samedir) {
1215		/*
1216		 * When moving a merge dir or non-dir with copy up origin into
1217		 * a new parent, we are marking the new parent dir "impure".
1218		 * When ovl_iterate() iterates an "impure" upper dir, it will
1219		 * lookup the origin inodes of the entries to fill d_ino.
1220		 */
1221		if (ovl_type_origin(old)) {
1222			err = ovl_set_impure(new->d_parent, new_upperdir);
1223			if (err)
1224				return err;
1225		}
1226		if (!ovlrd->overwrite && ovl_type_origin(new)) {
1227			err = ovl_set_impure(old->d_parent, old_upperdir);
1228			if (err)
1229				return err;
1230		}
1231	}
1232
1233	rd.mnt_idmap = ovl_upper_mnt_idmap(ofs);
1234	rd.old_parent = old_upperdir;
1235	rd.new_parent = new_upperdir;
1236	rd.flags = ovlrd->flags;
1237
1238	err = start_renaming(&rd, 0,
1239			     &QSTR_LEN(old->d_name.name, old->d_name.len),
1240			     &QSTR_LEN(new->d_name.name, new->d_name.len));
1241	if (err)
1242		return err;
1243
1244	err = -ESTALE;
1245	if (!ovl_matches_upper(old, rd.old_dentry))
1246		goto out_unlock;
1247
1248	old_opaque = ovl_dentry_is_opaque(old);
1249	new_opaque = ovl_dentry_is_opaque(new);
1250
1251	err = -ESTALE;
1252	if (d_inode(new) && ovl_dentry_upper(new)) {
1253		if (ovlrd->opaquedir) {
1254			if (rd.new_dentry != ovlrd->opaquedir)
1255				goto out_unlock;
1256		} else {
1257			if (!ovl_matches_upper(new, rd.new_dentry))
1258				goto out_unlock;
1259		}
1260	} else {
1261		if (!d_is_negative(rd.new_dentry)) {
1262			if (!new_opaque || !ovl_upper_is_whiteout(ofs, rd.new_dentry))
1263				goto out_unlock;
1264		} else {
1265			if (ovlrd->flags & RENAME_EXCHANGE)
1266				goto out_unlock;
1267		}
1268	}
1269
1270	if (rd.old_dentry->d_inode == rd.new_dentry->d_inode)
1271		goto out_unlock;
1272
1273	err = 0;
1274	if (ovl_type_merge_or_lower(old))
1275		err = ovl_set_redirect(old, samedir);
1276	else if (is_dir && !old_opaque && ovl_type_merge(new->d_parent))
1277		err = ovl_set_opaque_xerr(old, rd.old_dentry, -EXDEV);
1278	if (err)
1279		goto out_unlock;
1280
1281	if (!ovlrd->overwrite && ovl_type_merge_or_lower(new))
1282		err = ovl_set_redirect(new, samedir);
1283	else if (!ovlrd->overwrite && new_is_dir && !new_opaque &&
1284		 ovl_type_merge(old->d_parent))
1285		err = ovl_set_opaque_xerr(new, rd.new_dentry, -EXDEV);
1286	if (err)
1287		goto out_unlock;
1288
1289	err = ovl_do_rename_rd(&rd);
1290
1291	if (!err && ovlrd->cleanup_whiteout)
1292		whiteout = dget(rd.new_dentry);
1293
1294out_unlock:
1295	end_renaming(&rd);
1296
1297	if (err)
1298		return err;
1299
1300	if (whiteout) {
1301		ovl_cleanup(ofs, old_upperdir, whiteout);
1302		dput(whiteout);
1303	}
1304
1305	if (ovlrd->overwrite && d_inode(new)) {
1306		if (new_is_dir)
1307			clear_nlink(d_inode(new));
1308		else
1309			ovl_drop_nlink(new);
1310	}
1311
1312	ovl_dir_modified(old->d_parent, ovl_type_origin(old) ||
1313			 (!ovlrd->overwrite && ovl_type_origin(new)));
1314	ovl_dir_modified(new->d_parent, ovl_type_origin(old) ||
1315			 (d_inode(new) && ovl_type_origin(new)));
1316
1317	/* copy ctime: */
1318	ovl_copyattr(d_inode(old));
1319	if (d_inode(new) && ovl_dentry_upper(new))
1320		ovl_copyattr(d_inode(new));
1321
1322	return err;
1323}
1324
1325static void ovl_rename_end(struct ovl_renamedata *ovlrd)
1326{
1327	if (ovlrd->update_nlink)
1328		ovl_nlink_end(ovlrd->new_dentry);
1329	else
1330		ovl_drop_write(ovlrd->old_dentry);
1331}
1332
1333static int ovl_rename(struct mnt_idmap *idmap, struct inode *olddir,
1334		      struct dentry *old, struct inode *newdir,
1335		      struct dentry *new, unsigned int flags)
1336{
1337	struct ovl_renamedata ovlrd = {
1338		.old_parent		= old->d_parent,
1339		.old_dentry		= old,
1340		.new_parent		= new->d_parent,
1341		.new_dentry		= new,
1342		.flags			= flags,
1343		.overwrite		= !(flags & RENAME_EXCHANGE),
1344	};
1345	LIST_HEAD(list);
1346	int err;
1347
1348	err = ovl_rename_start(&ovlrd, &list);
1349	if (!err) {
1350		with_ovl_creds(old->d_sb)
1351			err = ovl_rename_upper(&ovlrd, &list);
1352		ovl_rename_end(&ovlrd);
1353	}
1354
1355	dput(ovlrd.opaquedir);
1356	ovl_cache_free(&list);
1357	return err;
1358}
1359
1360static int ovl_create_tmpfile(struct file *file, struct dentry *dentry,
1361			      struct inode *inode, umode_t mode)
1362{
1363	struct path realparentpath;
1364	struct file *realfile;
1365	struct ovl_file *of;
1366	struct dentry *newdentry;
1367	/* It's okay to set O_NOATIME, since the owner will be current fsuid */
1368	int flags = file->f_flags | OVL_OPEN_FLAGS;
1369	int err;
1370
1371	scoped_class(override_creds_ovl, original_creds, dentry->d_sb) {
1372		scoped_class(ovl_override_creator_creds, cred, original_creds, dentry, inode, mode) {
1373			if (IS_ERR(cred))
1374				return PTR_ERR(cred);
1375
1376			ovl_path_upper(dentry->d_parent, &realparentpath);
1377			realfile = backing_tmpfile_open(&file->f_path, flags, &realparentpath,
1378							mode, current_cred());
1379			err = PTR_ERR_OR_ZERO(realfile);
1380			pr_debug("tmpfile/open(%pd2, 0%o) = %i\n", realparentpath.dentry, mode, err);
1381			if (err)
1382				return err;
1383
1384			of = ovl_file_alloc(realfile);
1385			if (!of) {
1386				fput(realfile);
1387				return -ENOMEM;
1388			}
1389
1390			/* ovl_instantiate() consumes the newdentry reference on success */
1391			newdentry = dget(realfile->f_path.dentry);
1392			err = ovl_instantiate(dentry, inode, newdentry, false, file);
1393			if (!err) {
1394				file->private_data = of;
1395			} else {
1396				dput(newdentry);
1397				ovl_file_free(of);
1398			}
1399		}
1400	}
1401	return err;
1402}
1403
1404static int ovl_dummy_open(struct inode *inode, struct file *file)
1405{
1406	return 0;
1407}
1408
1409static int ovl_tmpfile(struct mnt_idmap *idmap, struct inode *dir,
1410		       struct file *file, umode_t mode)
1411{
1412	int err;
1413	struct dentry *dentry = file->f_path.dentry;
1414	struct inode *inode;
1415
1416	if (!OVL_FS(dentry->d_sb)->tmpfile)
1417		return -EOPNOTSUPP;
1418
1419	err = ovl_copy_up(dentry->d_parent);
1420	if (err)
1421		return err;
1422
1423	err = ovl_want_write(dentry);
1424	if (err)
1425		return err;
1426
1427	err = -ENOMEM;
1428	inode = ovl_new_inode(dentry->d_sb, mode, 0);
1429	if (!inode)
1430		goto drop_write;
1431
1432	inode_init_owner(&nop_mnt_idmap, inode, dir, mode);
1433	err = ovl_create_tmpfile(file, dentry, inode, inode->i_mode);
1434	if (err)
1435		goto put_inode;
1436
1437	/*
1438	 * Check if the preallocated inode was actually used.  Having something
1439	 * else assigned to the dentry shouldn't happen as that would indicate
1440	 * that the backing tmpfile "leaked" out of overlayfs.
1441	 */
1442	err = -EIO;
1443	if (WARN_ON(inode != d_inode(dentry)))
1444		goto put_realfile;
1445
1446	/* inode reference was transferred to dentry */
1447	inode = NULL;
1448	err = finish_open(file, dentry, ovl_dummy_open);
1449put_realfile:
1450	/* Without FMODE_OPENED ->release() won't be called on @file */
1451	if (!(file->f_mode & FMODE_OPENED))
1452		ovl_file_free(file->private_data);
1453put_inode:
1454	iput(inode);
1455drop_write:
1456	ovl_drop_write(dentry);
1457	return err;
1458}
1459
1460const struct inode_operations ovl_dir_inode_operations = {
1461	.lookup		= ovl_lookup,
1462	.mkdir		= ovl_mkdir,
1463	.symlink	= ovl_symlink,
1464	.unlink		= ovl_unlink,
1465	.rmdir		= ovl_rmdir,
1466	.rename		= ovl_rename,
1467	.link		= ovl_link,
1468	.setattr	= ovl_setattr,
1469	.create		= ovl_create,
1470	.mknod		= ovl_mknod,
1471	.permission	= ovl_permission,
1472	.getattr	= ovl_getattr,
1473	.listxattr	= ovl_listxattr,
1474	.get_inode_acl	= ovl_get_inode_acl,
1475	.get_acl	= ovl_get_acl,
1476	.set_acl	= ovl_set_acl,
1477	.update_time	= ovl_update_time,
1478	.fileattr_get	= ovl_fileattr_get,
1479	.fileattr_set	= ovl_fileattr_set,
1480	.tmpfile	= ovl_tmpfile,
1481};