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
20	static unsigned short ovl_redirect_max = 256;
21	module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
22	MODULE_PARM_DESC(redirect_max,
23	"Maximum length of absolute redirect xattr value");
24
25	static int ovl_set_redirect(struct dentry *dentry, bool samedir);
26
27	static int ovl_cleanup_locked(struct ovl_fs *ofs, struct inode *wdir,
28	struct dentry *wdentry)
29	{
30	int err;
31
32	dget(dentry: wdentry);
33	if (d_is_dir(dentry: wdentry))
34	err = ovl_do_rmdir(ofs, dir: wdir, dentry: wdentry);
35	else
36	err = ovl_do_unlink(ofs, dir: wdir, dentry: 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
47	int ovl_cleanup(struct ovl_fs *ofs, struct dentry *workdir,
48	struct dentry *wdentry)
49	{
50	wdentry = start_removing_dentry(parent: workdir, child: wdentry);
51	if (IS_ERR(ptr: wdentry))
52	return PTR_ERR(ptr: wdentry);
53
54	ovl_cleanup_locked(ofs, wdir: workdir->d_inode, wdentry);
55	end_removing(child: wdentry);
56
57	return 0;
58	}
59
60	void 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(buf: name, OVL_TEMPNAME_SIZE, fmt: "#%x", atomic_inc_return(v: &temp_id));
66	}
67
68	static 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(idmap: ovl_upper_mnt_idmap(ofs), parent: workdir,
75	name: &QSTR(name));
76	}
77
78	static 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)(T: &ofs->whiteout_lock);
86
87	if (!ofs->whiteout) {
88	whiteout = ovl_start_creating_temp(ofs, workdir);
89	if (IS_ERR(ptr: whiteout))
90	return whiteout;
91	err = ovl_do_whiteout(ofs, dir: wdir, dentry: whiteout);
92	if (!err)
93	ofs->whiteout = dget(dentry: whiteout);
94	end_creating(child: whiteout);
95	if (err)
96	return ERR_PTR(error: err);
97	}
98
99	if (!ofs->no_shared_whiteout) {
100	link = ovl_start_creating_temp(ofs, workdir);
101	if (IS_ERR(ptr: link))
102	return link;
103	err = ovl_do_link(ofs, old_dentry: ofs->whiteout, dir: wdir, new_dentry: link);
104	if (!err)
105	whiteout = dget(dentry: link);
106	end_creating(child: 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
122	int 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(ptr: whiteout);
132	if (IS_ERR(ptr: 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: &rd, old_dentry: whiteout, new_dentry: dentry);
143	if (!err) {
144	err = ovl_do_rename_rd(rd: &rd);
145	end_renaming(rd: &rd);
146	}
147	if (err)
148	goto kill_whiteout;
149	if (flags)
150	ovl_cleanup(ofs, workdir: ofs->workdir, wdentry: dentry);
151
152	out:
153	dput(whiteout);
154	return err;
155
156	kill_whiteout:
157	ovl_cleanup(ofs, workdir: ofs->workdir, wdentry: whiteout);
158	goto out;
159	}
160
161	struct 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(ptr: 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, old_dentry: attr->hardlink, dir, new_dentry: newdentry);
176	} else {
177	switch (attr->mode & S_IFMT) {
178	case S_IFREG:
179	err = ovl_do_create(ofs, dir, dentry: newdentry, mode: attr->mode);
180	break;
181
182	case S_IFDIR:
183	/* mkdir is special... */
184	newdentry = ovl_do_mkdir(ofs, dir, dentry: newdentry, mode: attr->mode);
185	err = PTR_ERR_OR_ZERO(ptr: newdentry);
186	/* expect to inherit casefolding from workdir/upperdir */
187	if (!err && ofs->casefold != ovl_dentry_casefolded(dentry: newdentry)) {
188	pr_warn_ratelimited("wrong inherited casefold (%pd2)\n",
189	newdentry);
190	end_creating(child: 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, dentry: newdentry, mode: attr->mode,
200	dev: attr->rdev);
201	break;
202
203	case S_IFLNK:
204	err = ovl_do_symlink(ofs, dir, dentry: newdentry, oldname: 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(dentry: 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, name: newdentry->d_name.name, base: parent,
231	len: newdentry->d_name.len);
232	dput(newdentry);
233	if (IS_ERR_OR_NULL(ptr: d))
234	err = d ? PTR_ERR(ptr: d) : -ENOENT;
235	else
236	return d;
237	}
238	out:
239	if (err) {
240	end_creating(child: newdentry);
241	return ERR_PTR(error: err);
242	}
243	return newdentry;
244	}
245
246	struct 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(ptr: ret))
252	return ret;
253	ret = ovl_create_real(ofs, parent: workdir, newdentry: ret, attr);
254	return end_creating_keep(child: ret);
255	}
256
257	static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
258	int xerr)
259	{
260	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
261	int err;
262
263	err = ovl_check_setxattr(ofs, upperdentry: upper, ox: OVL_XATTR_OPAQUE, value: "y", size: 1, xerr);
264	if (!err)
265	ovl_dentry_set_opaque(dentry);
266
267	return err;
268	}
269
270	static 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, upper: upperdentry, xerr: -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	*/
285	static 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, upperdentry: 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(sb: dentry->d_sb, oip: &oip);
311	if (IS_ERR(ptr: inode))
312	return PTR_ERR(ptr: inode);
313	if (inode == oip.newinode)
314	ovl_set_flag(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
337	static bool ovl_type_merge(struct dentry *dentry)
338	{
339	return OVL_TYPE_MERGE(ovl_path_type(dentry));
340	}
341
342	static bool ovl_type_origin(struct dentry *dentry)
343	{
344	return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
345	}
346
347	static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
348	struct ovl_cattr *attr)
349	{
350	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
351	struct dentry *upperdir = ovl_dentry_upper(dentry: dentry->d_parent);
352	struct dentry *newdentry;
353	int err;
354
355	newdentry = ovl_start_creating_upper(ofs, parent: upperdir,
356	name: &QSTR_LEN(dentry->d_name.name,
357	dentry->d_name.len));
358	if (IS_ERR(ptr: newdentry))
359	return PTR_ERR(ptr: newdentry);
360	newdentry = ovl_create_real(ofs, parent: upperdir, newdentry, attr);
361	if (IS_ERR(ptr: newdentry))
362	return PTR_ERR(ptr: newdentry);
363
364	end_creating_keep(child: newdentry);
365
366	if (ovl_type_merge(dentry: dentry->d_parent) && d_is_dir(dentry: newdentry) &&
367	!ovl_allow_offline_changes(ofs)) {
368	/* Setting opaque here is just an optimization, allow to fail */
369	ovl_set_opaque(dentry, upperdentry: newdentry);
370	}
371
372	ovl_dir_modified(dentry: dentry->d_parent, impurity: false);
373	err = ovl_instantiate(dentry, inode, newdentry, hardlink: !!attr->hardlink, NULL);
374	if (err)
375	goto out_cleanup;
376	return 0;
377
378	out_cleanup:
379	ovl_cleanup(ofs, workdir: upperdir, wdentry: newdentry);
380	dput(newdentry);
381	return err;
382	}
383
384	static struct dentry *ovl_clear_empty(struct dentry *dentry,
385	struct list_head *list)
386	{
387	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
388	struct dentry *workdir = ovl_workdir(dentry);
389	struct dentry *upperdir = ovl_dentry_upper(dentry: 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(error: -EROFS);
399
400	ovl_path_upper(dentry, path: &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(ptr: opaquedir);
413	if (IS_ERR(ptr: 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: &rd, old_dentry: opaquedir, new_dentry: upper);
421	if (err)
422	goto out_cleanup_unlocked;
423
424	err = ovl_copy_xattr(sb: dentry->d_sb, path: &upperpath, new: opaquedir);
425	if (err)
426	goto out_cleanup;
427
428	err = ovl_set_opaque(dentry, upperdentry: opaquedir);
429	if (err)
430	goto out_cleanup;
431
432	inode_lock(inode: opaquedir->d_inode);
433	err = ovl_set_attr(ofs, upper: opaquedir, stat: &stat);
434	inode_unlock(inode: opaquedir->d_inode);
435	if (err)
436	goto out_cleanup;
437
438	err = ovl_do_rename_rd(rd: &rd);
439	end_renaming(rd: &rd);
440	if (err)
441	goto out_cleanup_unlocked;
442
443	ovl_cleanup_whiteouts(ofs, upper, list);
444	ovl_cleanup(ofs, workdir, wdentry: upper);
445
446	/* dentry's upper doesn't match now, get rid of it */
447	d_drop(dentry);
448
449	return opaquedir;
450
451	out_cleanup:
452	end_renaming(rd: &rd);
453	out_cleanup_unlocked:
454	ovl_cleanup(ofs, workdir, wdentry: opaquedir);
455	dput(opaquedir);
456	out:
457	return ERR_PTR(error: err);
458	}
459
460	static 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, dentry: upperdentry, acl_name, acl);
467	}
468
469	static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
470	struct ovl_cattr *cattr)
471	{
472	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
473	struct dentry *workdir = ovl_workdir(dentry);
474	struct dentry *upperdir = ovl_dentry_upper(dentry: 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, name: dentry->d_name.name, base: upperdir,
493	len: dentry->d_name.len);
494	err = PTR_ERR(ptr: upper);
495	if (IS_ERR(ptr: upper))
496	goto out;
497
498	err = -ESTALE;
499	if (d_is_negative(dentry: upper) || !ovl_upper_is_whiteout(ofs, upperdentry: upper))
500	goto out_dput;
501
502	newdentry = ovl_create_temp(ofs, workdir, attr: cattr);
503	err = PTR_ERR(ptr: newdentry);
504	if (IS_ERR(ptr: 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: &rd, old_dentry: newdentry, new_dentry: 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(inode: newdentry->d_inode);
526	err = ovl_do_notify_change(ofs, upperdentry: newdentry, attr: &attr);
527	inode_unlock(inode: newdentry->d_inode);
528	if (err)
529	goto out_cleanup;
530	}
531	if (!hardlink) {
532	err = ovl_set_upper_acl(ofs, upperdentry: newdentry,
533	XATTR_NAME_POSIX_ACL_ACCESS, acl);
534	if (err)
535	goto out_cleanup;
536
537	err = ovl_set_upper_acl(ofs, upperdentry: newdentry,
538	XATTR_NAME_POSIX_ACL_DEFAULT, acl: default_acl);
539	if (err)
540	goto out_cleanup;
541	}
542
543	if (!hardlink && S_ISDIR(cattr->mode)) {
544	err = ovl_set_opaque(dentry, upperdentry: newdentry);
545	if (err)
546	goto out_cleanup;
547
548	rd.flags = RENAME_EXCHANGE;
549	err = ovl_do_rename_rd(rd: &rd);
550	end_renaming(rd: &rd);
551	if (err)
552	goto out_cleanup_unlocked;
553
554	ovl_cleanup(ofs, workdir, wdentry: upper);
555	} else {
556	err = ovl_do_rename_rd(rd: &rd);
557	end_renaming(rd: &rd);
558	if (err)
559	goto out_cleanup_unlocked;
560	}
561	ovl_dir_modified(dentry: dentry->d_parent, impurity: false);
562	err = ovl_instantiate(dentry, inode, newdentry, hardlink, NULL);
563	if (err) {
564	ovl_cleanup(ofs, workdir: upperdir, wdentry: newdentry);
565	dput(newdentry);
566	}
567	out_dput:
568	dput(upper);
569	out:
570	if (!hardlink) {
571	posix_acl_release(acl);
572	posix_acl_release(acl: default_acl);
573	}
574	return err;
575
576	out_cleanup:
577	end_renaming(rd: &rd);
578	out_cleanup_unlocked:
579	ovl_cleanup(ofs, workdir, wdentry: newdentry);
580	dput(newdentry);
581	goto out_dput;
582	}
583
584	static 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(error: -EINVAL);
591
592	CLASS(prepare_creds, override_cred)();
593	if (!override_cred)
594	return ERR_PTR(error: -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, name: &dentry->d_name,
600	old: original_creds, new: override_cred);
601	if (err)
602	return ERR_PTR(error: err);
603
604	return override_creds(no_free_ptr(override_cred));
605	}
606
607	static void ovl_revert_creator_creds(const struct cred *old_cred)
608	{
609	const struct cred *override_cred;
610
611	override_cred = revert_creds(revert_cred: old_cred);
612	put_cred(cred: override_cred);
613	}
614
615	DEFINE_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
624	static 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, cattr: attr);
632	}
633
634	static 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(dentry: parent, upperdentry: ovl_dentry_upper(dentry: 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(ptr: cred))
670	return PTR_ERR(ptr: cred);
671	return ovl_create_handle_whiteouts(dentry, inode, attr);
672	}
673	}
674	return err;
675	}
676
677	static 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: 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(sb: dentry->d_sb, mode, rdev);
698	if (!inode)
699	goto out_drop_write;
700
701	spin_lock(lock: &inode->i_lock);
702	inode_state_set(inode, flags: I_CREATING);
703	spin_unlock(lock: &inode->i_lock);
704
705	inode_init_owner(idmap: &nop_mnt_idmap, inode, dir: dentry->d_parent->d_inode, mode);
706	attr.mode = inode->i_mode;
707
708	err = ovl_create_or_link(dentry, inode, attr: &attr, origin: false);
709	/* Did we end up using the preallocated inode? */
710	if (inode != d_inode(dentry))
711	iput(inode);
712
713	out_drop_write:
714	ovl_drop_write(dentry);
715	out:
716	return err;
717	}
718
719	static 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: (mode & 07777) | S_IFREG, rdev: 0, NULL);
723	}
724
725	static struct dentry *ovl_mkdir(struct mnt_idmap *idmap, struct inode *dir,
726	struct dentry *dentry, umode_t mode)
727	{
728	return ERR_PTR(error: ovl_create_object(dentry, mode: (mode & 07777) | S_IFDIR, rdev: 0, NULL));
729	}
730
731	static 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
741	static 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, rdev: 0, link);
745	}
746
747	static int ovl_set_link_redirect(struct dentry *dentry)
748	{
749	with_ovl_creds(dentry->d_sb)
750	return ovl_set_redirect(dentry, samedir: false);
751	}
752
753	static 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(dentry: old);
760	if (err)
761	goto out;
762
763	err = ovl_copy_up(dentry: new->d_parent);
764	if (err)
765	goto out;
766
767	err = ovl_nlink_start(dentry: old);
768	if (err)
769	goto out;
770
771	if (ovl_is_metacopy_dentry(dentry: old)) {
772	err = ovl_set_link_redirect(dentry: old);
773	if (err)
774	goto out_nlink_end;
775	}
776
777	inode = d_inode(dentry: old);
778	ihold(inode);
779
780	err = ovl_create_or_link(dentry: new, inode,
781	attr: &(struct ovl_cattr) {.hardlink = ovl_dentry_upper(dentry: old)},
782	origin: ovl_type_origin(dentry: old));
783	if (err)
784	iput(inode);
785
786	out_nlink_end:
787	ovl_nlink_end(dentry: old);
788	out:
789	return err;
790	}
791
792	static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
793	{
794	return d_inode(dentry: ovl_dentry_upper(dentry)) == d_inode(dentry: upper);
795	}
796
797	static int ovl_remove_and_whiteout(struct dentry *dentry,
798	struct list_head *list)
799	{
800	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
801	struct dentry *workdir = ovl_workdir(dentry);
802	struct dentry *upperdir = ovl_dentry_upper(dentry: 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(head: list)) {
811	opaquedir = ovl_clear_empty(dentry, list);
812	err = PTR_ERR(ptr: opaquedir);
813	if (IS_ERR(ptr: opaquedir))
814	goto out;
815	}
816
817	upper = ovl_lookup_upper_unlocked(ofs, name: dentry->d_name.name, base: upperdir,
818	len: dentry->d_name.len);
819	err = PTR_ERR(ptr: upper);
820	if (IS_ERR(ptr: 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, dir: upperdir, dentry: upper);
831	if (!err)
832	ovl_dir_modified(dentry: dentry->d_parent, impurity: true);
833
834	d_drop(dentry);
835	out_dput_upper:
836	dput(upper);
837	out_dput:
838	dput(opaquedir);
839	out:
840	return err;
841	}
842
843	static int ovl_remove_upper(struct dentry *dentry, bool is_dir,
844	struct list_head *list)
845	{
846	struct ovl_fs *ofs = OVL_FS(sb: dentry->d_sb);
847	struct dentry *upperdir = ovl_dentry_upper(dentry: 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(head: list)) {
854	opaquedir = ovl_clear_empty(dentry, list);
855	err = PTR_ERR(ptr: opaquedir);
856	if (IS_ERR(ptr: opaquedir))
857	goto out;
858	}
859
860	upper = ovl_start_removing_upper(ofs, parent: upperdir,
861	name: &QSTR_LEN(dentry->d_name.name,
862	dentry->d_name.len));
863	err = PTR_ERR(ptr: upper);
864	if (IS_ERR(ptr: 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, dentry: upper);
874	else
875	err = ovl_do_unlink(ofs, dir, dentry: upper);
876	ovl_dir_modified(dentry: dentry->d_parent, impurity: 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);
886	out_unlock:
887	end_removing(child: upper);
888	out_dput:
889	dput(opaquedir);
890	out:
891	return err;
892	}
893
894	static bool ovl_pure_upper(struct dentry *dentry)
895	{
896	return !ovl_dentry_lower(dentry) &&
897	!ovl_test_flag(flag: OVL_WHITEOUTS, inode: d_inode(dentry));
898	}
899
900	static 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(lock: &inode->i_lock);
907	hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
908	if (alias != dentry && !d_unhashed(dentry: alias))
909	break;
910	}
911	spin_unlock(lock: &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
922	static 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: &list);
931	if (err)
932	goto out;
933	}
934
935	err = ovl_copy_up(dentry: 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: &list);
946	else
947	err = ovl_remove_and_whiteout(dentry, list: &list);
948	}
949	if (!err) {
950	if (is_dir)
951	clear_nlink(inode: 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(to: d_inode(dentry));
965
966	out:
967	ovl_cache_free(list: &list);
968	return err;
969	}
970
971	static int ovl_unlink(struct inode *dir, struct dentry *dentry)
972	{
973	return ovl_do_remove(dentry, is_dir: false);
974	}
975
976	static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
977	{
978	return ovl_do_remove(dentry, is_dir: true);
979	}
980
981	static 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
988	static bool ovl_can_move(struct dentry *dentry)
989	{
990	return ovl_redirect_dir(ofs: OVL_FS(sb: dentry->d_sb)) ||
991	!d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
992	}
993
994	static 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(s: dentry->d_name.name, len: 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(lock: &d->d_lock);
1017	name = ovl_dentry_get_redirect(dentry: 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(error: -EXDEV);
1028	spin_unlock(lock: &d->d_lock);
1029	goto out_put;
1030	}
1031
1032	buflen -= thislen;
1033	memcpy(&buf[buflen], name, thislen);
1034	spin_unlock(lock: &d->d_lock);
1035	tmp = dget_parent(dentry: 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(s: &buf[buflen], GFP_KERNEL);
1047	out_put:
1048	dput(d);
1049	kfree(objp: buf);
1050	out:
1051	return ret ? ret : ERR_PTR(error: -ENOMEM);
1052	}
1053
1054	static 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(dentry: lowerdentry)->i_nlink > 1);
1079	}
1080
1081	static int ovl_set_redirect(struct dentry *dentry, bool samedir)
1082	{
1083	int err;
1084	struct ovl_fs *ofs = OVL_FS(sb: 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, abs_redirect: absolute_redirect);
1092	if (IS_ERR(ptr: redirect))
1093	return PTR_ERR(ptr: redirect);
1094
1095	err = ovl_check_setxattr(ofs, upperdentry: ovl_dentry_upper(dentry),
1096	ox: OVL_XATTR_REDIRECT,
1097	value: redirect, strlen(redirect), xerr: -EXDEV);
1098	if (!err) {
1099	spin_lock(lock: &dentry->d_lock);
1100	ovl_dentry_set_redirect(dentry, redirect);
1101	spin_unlock(lock: &dentry->d_lock);
1102	} else {
1103	kfree(objp: 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
1112	struct ovl_renamedata {
1113	struct renamedata;
1114	struct dentry *opaquedir;
1115	bool cleanup_whiteout;
1116	bool update_nlink;
1117	bool overwrite;
1118	};
1119
1120	static 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(dentry: old);
1125	bool new_is_dir = d_is_dir(dentry: 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(dentry: old))
1136	return err;
1137	if (!ovlrd->overwrite && !ovl_can_move(dentry: new))
1138	return err;
1139
1140	if (ovlrd->overwrite && new_is_dir && !ovl_pure_upper(dentry: new)) {
1141	err = ovl_check_empty_dir(dentry: new, list);
1142	if (err)
1143	return err;
1144	}
1145
1146	if (ovlrd->overwrite) {
1147	if (ovl_lower_positive(dentry: old)) {
1148	if (!ovl_dentry_is_whiteout(dentry: 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(dentry: new)) {
1156	ovlrd->flags |= RENAME_EXCHANGE;
1157	ovlrd->cleanup_whiteout = true;
1158	}
1159	}
1160
1161	err = ovl_copy_up(dentry: old);
1162	if (err)
1163	return err;
1164
1165	err = ovl_copy_up(dentry: new->d_parent);
1166	if (err)
1167	return err;
1168
1169	if (!ovlrd->overwrite) {
1170	err = ovl_copy_up(dentry: new);
1171	if (err)
1172	return err;
1173	} else if (d_inode(dentry: new)) {
1174	err = ovl_nlink_start(dentry: 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(dentry: old);
1184	if (err)
1185	return err;
1186	}
1187
1188	return 0;
1189	}
1190
1191	static 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(sb: old->d_sb);
1196	struct dentry *old_upperdir = ovl_dentry_upper(dentry: old->d_parent);
1197	struct dentry *new_upperdir = ovl_dentry_upper(dentry: new->d_parent);
1198	bool is_dir = d_is_dir(dentry: old);
1199	bool new_is_dir = d_is_dir(dentry: 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(head: list)) {
1208	de = ovl_clear_empty(dentry: new, list);
1209	if (IS_ERR(ptr: de))
1210	return PTR_ERR(ptr: 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(dentry: old)) {
1222	err = ovl_set_impure(dentry: new->d_parent, upperdentry: new_upperdir);
1223	if (err)
1224	return err;
1225	}
1226	if (!ovlrd->overwrite && ovl_type_origin(dentry: new)) {
1227	err = ovl_set_impure(dentry: old->d_parent, upperdentry: 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: &rd, lookup_flags: 0,
1239	old_last: &QSTR_LEN(old->d_name.name, old->d_name.len),
1240	new_last: &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(dentry: old, upper: rd.old_dentry))
1246	goto out_unlock;
1247
1248	old_opaque = ovl_dentry_is_opaque(dentry: old);
1249	new_opaque = ovl_dentry_is_opaque(dentry: new);
1250
1251	err = -ESTALE;
1252	if (d_inode(dentry: new) && ovl_dentry_upper(dentry: new)) {
1253	if (ovlrd->opaquedir) {
1254	if (rd.new_dentry != ovlrd->opaquedir)
1255	goto out_unlock;
1256	} else {
1257	if (!ovl_matches_upper(dentry: new, upper: rd.new_dentry))
1258	goto out_unlock;
1259	}
1260	} else {
1261	if (!d_is_negative(dentry: rd.new_dentry)) {
1262	if (!new_opaque || !ovl_upper_is_whiteout(ofs, upperdentry: 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(dentry: old))
1275	err = ovl_set_redirect(dentry: old, samedir);
1276	else if (is_dir && !old_opaque && ovl_type_merge(dentry: new->d_parent))
1277	err = ovl_set_opaque_xerr(dentry: old, upper: rd.old_dentry, xerr: -EXDEV);
1278	if (err)
1279	goto out_unlock;
1280
1281	if (!ovlrd->overwrite && ovl_type_merge_or_lower(dentry: new))
1282	err = ovl_set_redirect(dentry: new, samedir);
1283	else if (!ovlrd->overwrite && new_is_dir && !new_opaque &&
1284	ovl_type_merge(dentry: old->d_parent))
1285	err = ovl_set_opaque_xerr(dentry: new, upper: rd.new_dentry, xerr: -EXDEV);
1286	if (err)
1287	goto out_unlock;
1288
1289	err = ovl_do_rename_rd(rd: &rd);
1290
1291	if (!err && ovlrd->cleanup_whiteout)
1292	whiteout = dget(dentry: rd.new_dentry);
1293
1294	out_unlock:
1295	end_renaming(rd: &rd);
1296
1297	if (err)
1298	return err;
1299
1300	if (whiteout) {
1301	ovl_cleanup(ofs, workdir: old_upperdir, wdentry: whiteout);
1302	dput(whiteout);
1303	}
1304
1305	if (ovlrd->overwrite && d_inode(dentry: new)) {
1306	if (new_is_dir)
1307	clear_nlink(inode: d_inode(dentry: new));
1308	else
1309	ovl_drop_nlink(dentry: new);
1310	}
1311
1312	ovl_dir_modified(dentry: old->d_parent, impurity: ovl_type_origin(dentry: old) ||
1313	(!ovlrd->overwrite && ovl_type_origin(dentry: new)));
1314	ovl_dir_modified(dentry: new->d_parent, impurity: ovl_type_origin(dentry: old) ||
1315	(d_inode(dentry: new) && ovl_type_origin(dentry: new)));
1316
1317	/* copy ctime: */
1318	ovl_copyattr(to: d_inode(dentry: old));
1319	if (d_inode(dentry: new) && ovl_dentry_upper(dentry: new))
1320	ovl_copyattr(to: d_inode(dentry: new));
1321
1322	return err;
1323	}
1324
1325	static void ovl_rename_end(struct ovl_renamedata *ovlrd)
1326	{
1327	if (ovlrd->update_nlink)
1328	ovl_nlink_end(dentry: ovlrd->new_dentry);
1329	else
1330	ovl_drop_write(dentry: ovlrd->old_dentry);
1331	}
1332
1333	static 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: &ovlrd, list: &list);
1349	if (!err) {
1350	with_ovl_creds(old->d_sb)
1351	err = ovl_rename_upper(ovlrd: &ovlrd, list: &list);
1352	ovl_rename_end(ovlrd: &ovlrd);
1353	}
1354
1355	dput(ovlrd.opaquedir);
1356	ovl_cache_free(list: &list);
1357	return err;
1358	}
1359
1360	static 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(ptr: cred))
1374	return PTR_ERR(ptr: cred);
1375
1376	ovl_path_upper(dentry: dentry->d_parent, path: &realparentpath);
1377	realfile = backing_tmpfile_open(user_path: &file->f_path, flags, real_parentpath: &realparentpath,
1378	mode, current_cred());
1379	err = PTR_ERR_OR_ZERO(ptr: 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(dentry: realfile->f_path.dentry);
1392	err = ovl_instantiate(dentry, inode, newdentry, hardlink: false, tmpfile: 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
1404	static int ovl_dummy_open(struct inode *inode, struct file *file)
1405	{
1406	return 0;
1407	}
1408
1409	static 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(sb: dentry->d_sb)->tmpfile)
1417	return -EOPNOTSUPP;
1418
1419	err = ovl_copy_up(dentry: 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(sb: dentry->d_sb, mode, rdev: 0);
1429	if (!inode)
1430	goto drop_write;
1431
1432	inode_init_owner(idmap: &nop_mnt_idmap, inode, dir, mode);
1433	err = ovl_create_tmpfile(file, dentry, inode, mode: 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, open: ovl_dummy_open);
1449	put_realfile:
1450	/* Without FMODE_OPENED ->release() won't be called on @file */
1451	if (!(file->f_mode & FMODE_OPENED))
1452	ovl_file_free(of: file->private_data);
1453	put_inode:
1454	iput(inode);
1455	drop_write:
1456	ovl_drop_write(dentry);
1457	return err;
1458	}
1459
1460	const 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	};
1482