blob: f18490813170af41375c24360ba6e136a841b30a [file] [log] [blame]
Thomas Gleixnerd2912cb2019-06-04 10:11:33 +02001// SPDX-License-Identifier: GPL-2.0-only
Miklos Szeredie9be9d52014-10-24 00:14:38 +02002/*
3 *
4 * Copyright (C) 2011 Novell Inc.
Miklos Szeredie9be9d52014-10-24 00:14:38 +02005 */
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>
Miklos Szeredi3ea22a72016-12-16 11:02:57 +010012#include <linux/module.h>
Miklos Szeredi38b25692016-09-01 11:11:59 +020013#include <linux/posix_acl.h>
14#include <linux/posix_acl_xattr.h>
Richard Weinberger6a45b362016-09-16 11:45:24 +020015#include <linux/atomic.h>
Miklos Szeredia6c60652016-12-16 11:02:56 +010016#include <linux/ratelimit.h>
Miklos Szeredie9be9d52014-10-24 00:14:38 +020017#include "overlayfs.h"
18
Miklos Szeredi3ea22a72016-12-16 11:02:57 +010019static unsigned short ovl_redirect_max = 256;
20module_param_named(redirect_max, ovl_redirect_max, ushort, 0644);
Nicolas Schier253e7482019-06-17 09:39:00 +020021MODULE_PARM_DESC(redirect_max,
Miklos Szeredi3ea22a72016-12-16 11:02:57 +010022 "Maximum length of absolute redirect xattr value");
23
Vivek Goyal4120fe62018-05-11 11:49:32 -040024static int ovl_set_redirect(struct dentry *dentry, bool samedir);
25
Amir Goldstein415543d2017-06-21 15:28:42 +030026int ovl_cleanup(struct inode *wdir, struct dentry *wdentry)
Miklos Szeredie9be9d52014-10-24 00:14:38 +020027{
28 int err;
29
30 dget(wdentry);
David Howellse36cb0b2015-01-29 12:02:35 +000031 if (d_is_dir(wdentry))
Miklos Szeredie9be9d52014-10-24 00:14:38 +020032 err = ovl_do_rmdir(wdir, wdentry);
33 else
34 err = ovl_do_unlink(wdir, wdentry);
35 dput(wdentry);
36
37 if (err) {
lijiazi1bd0a3a2019-12-16 19:12:32 +080038 pr_err("cleanup of '%pd2' failed (%i)\n",
Miklos Szeredie9be9d52014-10-24 00:14:38 +020039 wdentry, err);
40 }
Amir Goldstein415543d2017-06-21 15:28:42 +030041
42 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020043}
44
Amir Goldsteincad218a2020-02-20 09:00:19 +020045struct dentry *ovl_lookup_temp(struct dentry *workdir)
Miklos Szeredie9be9d52014-10-24 00:14:38 +020046{
47 struct dentry *temp;
48 char name[20];
Richard Weinberger6a45b362016-09-16 11:45:24 +020049 static atomic_t temp_id = ATOMIC_INIT(0);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020050
Richard Weinberger6a45b362016-09-16 11:45:24 +020051 /* counter is allowed to wrap, since temp dentries are ephemeral */
52 snprintf(name, sizeof(name), "#%x", atomic_inc_return(&temp_id));
Miklos Szeredie9be9d52014-10-24 00:14:38 +020053
54 temp = lookup_one_len(name, workdir, strlen(name));
55 if (!IS_ERR(temp) && temp->d_inode) {
lijiazi1bd0a3a2019-12-16 19:12:32 +080056 pr_err("workdir/%s already exists\n", name);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020057 dput(temp);
58 temp = ERR_PTR(-EIO);
59 }
60
61 return temp;
62}
63
64/* caller holds i_mutex on workdir */
Chengguang Xuc21c8392020-04-24 10:55:17 +080065static struct dentry *ovl_whiteout(struct ovl_fs *ofs)
Miklos Szeredie9be9d52014-10-24 00:14:38 +020066{
67 int err;
68 struct dentry *whiteout;
Chengguang Xuc21c8392020-04-24 10:55:17 +080069 struct dentry *workdir = ofs->workdir;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020070 struct inode *wdir = workdir->d_inode;
71
Chengguang Xuc21c8392020-04-24 10:55:17 +080072 if (!ofs->whiteout) {
73 whiteout = ovl_lookup_temp(workdir);
74 if (IS_ERR(whiteout))
75 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020076
Chengguang Xuc21c8392020-04-24 10:55:17 +080077 err = ovl_do_whiteout(wdir, whiteout);
78 if (err) {
79 dput(whiteout);
80 whiteout = ERR_PTR(err);
81 goto out;
82 }
83 ofs->whiteout = whiteout;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020084 }
85
Chengguang Xuc21c8392020-04-24 10:55:17 +080086 if (ofs->share_whiteout) {
87 whiteout = ovl_lookup_temp(workdir);
88 if (IS_ERR(whiteout))
89 goto out;
90
91 err = ovl_do_link(ofs->whiteout, wdir, whiteout);
92 if (!err)
93 goto out;
94
95 if (err != -EMLINK) {
96 pr_warn("Failed to link whiteout - disabling whiteout inode sharing(nlink=%u, err=%i)\n",
97 ofs->whiteout->d_inode->i_nlink, err);
98 ofs->share_whiteout = false;
99 }
100 dput(whiteout);
101 }
102 whiteout = ofs->whiteout;
103 ofs->whiteout = NULL;
104out:
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200105 return whiteout;
106}
107
Amir Goldsteine7dd0e72017-10-24 17:38:33 +0300108/* Caller must hold i_mutex on both workdir and dir */
Chengguang Xuc21c8392020-04-24 10:55:17 +0800109int ovl_cleanup_and_whiteout(struct ovl_fs *ofs, struct inode *dir,
Amir Goldsteine7dd0e72017-10-24 17:38:33 +0300110 struct dentry *dentry)
111{
Chengguang Xuc21c8392020-04-24 10:55:17 +0800112 struct inode *wdir = ofs->workdir->d_inode;
Amir Goldsteine7dd0e72017-10-24 17:38:33 +0300113 struct dentry *whiteout;
114 int err;
115 int flags = 0;
116
Chengguang Xuc21c8392020-04-24 10:55:17 +0800117 whiteout = ovl_whiteout(ofs);
Amir Goldsteine7dd0e72017-10-24 17:38:33 +0300118 err = PTR_ERR(whiteout);
119 if (IS_ERR(whiteout))
120 return err;
121
122 if (d_is_dir(dentry))
123 flags = RENAME_EXCHANGE;
124
125 err = ovl_do_rename(wdir, whiteout, dir, dentry, flags);
126 if (err)
127 goto kill_whiteout;
128 if (flags)
129 ovl_cleanup(wdir, dentry);
130
131out:
132 dput(whiteout);
133 return err;
134
135kill_whiteout:
136 ovl_cleanup(wdir, whiteout);
137 goto out;
138}
139
Miklos Szeredi1f5573c2021-11-04 10:55:34 +0100140int ovl_mkdir_real(struct inode *dir, struct dentry **newdentry, umode_t mode)
Al Virof73cc772018-05-16 18:19:53 +0300141{
142 int err;
143 struct dentry *d, *dentry = *newdentry;
144
145 err = ovl_do_mkdir(dir, dentry, mode);
146 if (err)
147 return err;
148
149 if (likely(!d_unhashed(dentry)))
150 return 0;
151
152 /*
153 * vfs_mkdir() may succeed and leave the dentry passed
154 * to it unhashed and negative. If that happens, try to
155 * lookup a new hashed and positive dentry.
156 */
157 d = lookup_one_len(dentry->d_name.name, dentry->d_parent,
158 dentry->d_name.len);
159 if (IS_ERR(d)) {
lijiazi1bd0a3a2019-12-16 19:12:32 +0800160 pr_warn("failed lookup after mkdir (%pd2, err=%i).\n",
Al Virof73cc772018-05-16 18:19:53 +0300161 dentry, err);
162 return PTR_ERR(d);
163 }
164 dput(dentry);
165 *newdentry = d;
166
167 return 0;
168}
169
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300170struct dentry *ovl_create_real(struct inode *dir, struct dentry *newdentry,
171 struct ovl_cattr *attr)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200172{
173 int err;
174
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300175 if (IS_ERR(newdentry))
176 return newdentry;
177
178 err = -ESTALE;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200179 if (newdentry->d_inode)
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300180 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200181
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300182 if (attr->hardlink) {
183 err = ovl_do_link(attr->hardlink, dir, newdentry);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200184 } else {
Al Viro32a3d842016-12-04 17:33:17 +0000185 switch (attr->mode & S_IFMT) {
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200186 case S_IFREG:
Amir Goldstein6cf00762018-05-16 17:04:00 +0300187 err = ovl_do_create(dir, newdentry, attr->mode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200188 break;
189
190 case S_IFDIR:
Al Virof73cc772018-05-16 18:19:53 +0300191 /* mkdir is special... */
192 err = ovl_mkdir_real(dir, &newdentry, attr->mode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200193 break;
194
195 case S_IFCHR:
196 case S_IFBLK:
197 case S_IFIFO:
198 case S_IFSOCK:
Amir Goldstein6cf00762018-05-16 17:04:00 +0300199 err = ovl_do_mknod(dir, newdentry, attr->mode,
200 attr->rdev);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200201 break;
202
203 case S_IFLNK:
Amir Goldstein6cf00762018-05-16 17:04:00 +0300204 err = ovl_do_symlink(dir, newdentry, attr->link);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200205 break;
206
207 default:
208 err = -EPERM;
209 }
210 }
211 if (!err && WARN_ON(!newdentry->d_inode)) {
212 /*
213 * Not quite sure if non-instantiated dentry is legal or not.
214 * VFS doesn't seem to care so check and warn here.
215 */
Miklos Szeredidd8ac6992018-05-31 11:06:11 +0200216 err = -EIO;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200217 }
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300218out:
219 if (err) {
220 dput(newdentry);
221 return ERR_PTR(err);
222 }
223 return newdentry;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200224}
225
Amir Goldstein137ec522018-05-16 17:51:25 +0300226struct dentry *ovl_create_temp(struct dentry *workdir, struct ovl_cattr *attr)
227{
228 return ovl_create_real(d_inode(workdir), ovl_lookup_temp(workdir),
229 attr);
230}
231
Amir Goldstein21a22872017-05-17 00:12:41 +0300232static int ovl_set_opaque_xerr(struct dentry *dentry, struct dentry *upper,
233 int xerr)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200234{
Amir Goldsteina0c236b2021-06-19 12:26:17 +0300235 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
Miklos Szeredi5cf5b472016-12-16 11:02:57 +0100236 int err;
237
Amir Goldsteina0c236b2021-06-19 12:26:17 +0300238 err = ovl_check_setxattr(ofs, upper, OVL_XATTR_OPAQUE, "y", 1, xerr);
Miklos Szeredi5cf5b472016-12-16 11:02:57 +0100239 if (!err)
240 ovl_dentry_set_opaque(dentry);
241
242 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200243}
244
Amir Goldstein21a22872017-05-17 00:12:41 +0300245static int ovl_set_opaque(struct dentry *dentry, struct dentry *upperdentry)
246{
247 /*
248 * Fail with -EIO when trying to create opaque dir and upper doesn't
249 * support xattrs. ovl_rename() calls ovl_set_opaque_xerr(-EXDEV) to
250 * return a specific error for noxattr case.
251 */
252 return ovl_set_opaque_xerr(dentry, upperdentry, -EIO);
253}
254
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300255/*
256 * Common operations required to be done after creation of file on upper.
257 * If @hardlink is false, then @inode is a pre-allocated inode, we may or
258 * may not use to instantiate the new dentry.
259 */
260static int ovl_instantiate(struct dentry *dentry, struct inode *inode,
261 struct dentry *newdentry, bool hardlink)
Vivek Goyal72e48482016-06-16 10:09:14 -0400262{
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300263 struct ovl_inode_params oip = {
264 .upperdentry = newdentry,
265 .newinode = inode,
266 };
267
Miklos Szeredid9854c82018-07-18 15:44:40 +0200268 ovl_dir_modified(dentry->d_parent, false);
Miklos Szeredi55acc662017-07-04 22:03:18 +0200269 ovl_dentry_set_upper_alias(dentry);
Miklos Szeredif4288842020-03-17 15:04:22 +0100270 ovl_dentry_update_reval(dentry, newdentry,
271 DCACHE_OP_REVALIDATE | DCACHE_OP_WEAK_REVALIDATE);
272
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200273 if (!hardlink) {
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300274 /*
275 * ovl_obtain_alias() can be called after ovl_create_real()
276 * and before we get here, so we may get an inode from cache
277 * with the same real upperdentry that is not the inode we
278 * pre-allocated. In this case we will use the cached inode
279 * to instantiate the new dentry.
280 *
281 * XXX: if we ever use ovl_obtain_alias() to decode directory
282 * file handles, need to use ovl_get_inode_locked() and
283 * d_instantiate_new() here to prevent from creating two
284 * hashed directory inode aliases.
285 */
286 inode = ovl_get_inode(dentry->d_sb, &oip);
Amir Goldsteinacf30622019-03-28 17:38:29 +0200287 if (IS_ERR(inode))
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300288 return PTR_ERR(inode);
Vivek Goyal28166ab2020-06-01 11:56:52 -0400289 if (inode == oip.newinode)
290 ovl_set_flag(OVL_UPPERDATA, inode);
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200291 } else {
Miklos Szeredi09d8b582017-07-04 22:03:16 +0200292 WARN_ON(ovl_inode_real(inode) != d_inode(newdentry));
293 dput(newdentry);
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200294 inc_nlink(inode);
295 }
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300296
Vivek Goyal72e48482016-06-16 10:09:14 -0400297 d_instantiate(dentry, inode);
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300298 if (inode != oip.newinode) {
lijiazi1bd0a3a2019-12-16 19:12:32 +0800299 pr_warn_ratelimited("newly created inode found in cache (%pd2)\n",
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300300 dentry);
301 }
302
Amir Goldstein5b6c9052017-04-24 19:54:13 +0300303 /* Force lookup of new upper hardlink to find its lower */
304 if (hardlink)
305 d_drop(dentry);
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300306
307 return 0;
Vivek Goyal72e48482016-06-16 10:09:14 -0400308}
309
Amir Goldstein97c684c2016-11-21 18:57:34 +0200310static bool ovl_type_merge(struct dentry *dentry)
311{
312 return OVL_TYPE_MERGE(ovl_path_type(dentry));
313}
314
Amir Goldsteinee1d6d372017-05-11 16:42:26 +0300315static bool ovl_type_origin(struct dentry *dentry)
316{
317 return OVL_TYPE_ORIGIN(ovl_path_type(dentry));
318}
319
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200320static int ovl_create_upper(struct dentry *dentry, struct inode *inode,
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300321 struct ovl_cattr *attr)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200322{
Vyacheslav Yurkov1fc31aa2021-05-27 19:45:47 +0200323 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200324 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
325 struct inode *udir = upperdir->d_inode;
326 struct dentry *newdentry;
327 int err;
328
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300329 if (!attr->hardlink && !IS_POSIXACL(udir))
Al Viro32a3d842016-12-04 17:33:17 +0000330 attr->mode &= ~current_umask();
Miklos Szeredi38b25692016-09-01 11:11:59 +0200331
Al Viro59551022016-01-22 15:40:57 -0500332 inode_lock_nested(udir, I_MUTEX_PARENT);
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300333 newdentry = ovl_create_real(udir,
334 lookup_one_len(dentry->d_name.name,
335 upperdir,
336 dentry->d_name.len),
337 attr);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200338 err = PTR_ERR(newdentry);
339 if (IS_ERR(newdentry))
340 goto out_unlock;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200341
Vyacheslav Yurkov1fc31aa2021-05-27 19:45:47 +0200342 if (ovl_type_merge(dentry->d_parent) && d_is_dir(newdentry) &&
343 !ovl_allow_offline_changes(ofs)) {
Amir Goldstein97c684c2016-11-21 18:57:34 +0200344 /* Setting opaque here is just an optimization, allow to fail */
345 ovl_set_opaque(dentry, newdentry);
346 }
347
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300348 err = ovl_instantiate(dentry, inode, newdentry, !!attr->hardlink);
349 if (err)
350 goto out_cleanup;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200351out_unlock:
Al Viro59551022016-01-22 15:40:57 -0500352 inode_unlock(udir);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200353 return err;
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300354
355out_cleanup:
356 ovl_cleanup(udir, newdentry);
357 dput(newdentry);
358 goto out_unlock;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200359}
360
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200361static struct dentry *ovl_clear_empty(struct dentry *dentry,
362 struct list_head *list)
363{
364 struct dentry *workdir = ovl_workdir(dentry);
365 struct inode *wdir = workdir->d_inode;
366 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
367 struct inode *udir = upperdir->d_inode;
368 struct path upperpath;
369 struct dentry *upper;
370 struct dentry *opaquedir;
371 struct kstat stat;
372 int err;
373
Miklos Szeredicc6f67b2015-05-19 14:30:12 +0200374 if (WARN_ON(!workdir))
375 return ERR_PTR(-EROFS);
376
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200377 err = ovl_lock_rename_workdir(workdir, upperdir);
378 if (err)
379 goto out;
380
381 ovl_path_upper(dentry, &upperpath);
David Howellsa528d352017-01-31 16:46:22 +0000382 err = vfs_getattr(&upperpath, &stat,
383 STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200384 if (err)
385 goto out_unlock;
386
387 err = -ESTALE;
388 if (!S_ISDIR(stat.mode))
389 goto out_unlock;
390 upper = upperpath.dentry;
391 if (upper->d_parent->d_inode != udir)
392 goto out_unlock;
393
Amir Goldstein137ec522018-05-16 17:51:25 +0300394 opaquedir = ovl_create_temp(workdir, OVL_CATTR(stat.mode));
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200395 err = PTR_ERR(opaquedir);
396 if (IS_ERR(opaquedir))
397 goto out_unlock;
398
Miklos Szeredi610afc02020-09-02 10:58:49 +0200399 err = ovl_copy_xattr(dentry->d_sb, upper, opaquedir);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200400 if (err)
401 goto out_cleanup;
402
Miklos Szeredi5cf5b472016-12-16 11:02:57 +0100403 err = ovl_set_opaque(dentry, opaquedir);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200404 if (err)
405 goto out_cleanup;
406
Al Viro59551022016-01-22 15:40:57 -0500407 inode_lock(opaquedir->d_inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200408 err = ovl_set_attr(opaquedir, &stat);
Al Viro59551022016-01-22 15:40:57 -0500409 inode_unlock(opaquedir->d_inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200410 if (err)
411 goto out_cleanup;
412
413 err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);
414 if (err)
415 goto out_cleanup;
416
417 ovl_cleanup_whiteouts(upper, list);
418 ovl_cleanup(wdir, upper);
419 unlock_rename(workdir, upperdir);
420
421 /* dentry's upper doesn't match now, get rid of it */
422 d_drop(dentry);
423
424 return opaquedir;
425
426out_cleanup:
427 ovl_cleanup(wdir, opaquedir);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200428 dput(opaquedir);
429out_unlock:
430 unlock_rename(workdir, upperdir);
431out:
432 return ERR_PTR(err);
433}
434
Miklos Szeredi38b25692016-09-01 11:11:59 +0200435static int ovl_set_upper_acl(struct dentry *upperdentry, const char *name,
436 const struct posix_acl *acl)
437{
438 void *buffer;
439 size_t size;
440 int err;
441
442 if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !acl)
443 return 0;
444
Chengguang Xu14fa0852018-06-22 09:49:36 +0800445 size = posix_acl_xattr_size(acl->a_count);
Miklos Szeredi38b25692016-09-01 11:11:59 +0200446 buffer = kmalloc(size, GFP_KERNEL);
447 if (!buffer)
448 return -ENOMEM;
449
Chengguang Xu14fa0852018-06-22 09:49:36 +0800450 err = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
Miklos Szeredi38b25692016-09-01 11:11:59 +0200451 if (err < 0)
452 goto out_free;
453
Tycho Andersenc7c7a1a12021-01-21 14:19:28 +0100454 err = vfs_setxattr(&init_user_ns, upperdentry, name, buffer, size, XATTR_CREATE);
Miklos Szeredi38b25692016-09-01 11:11:59 +0200455out_free:
456 kfree(buffer);
457 return err;
458}
459
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200460static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300461 struct ovl_cattr *cattr)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200462{
463 struct dentry *workdir = ovl_workdir(dentry);
464 struct inode *wdir = workdir->d_inode;
465 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
466 struct inode *udir = upperdir->d_inode;
467 struct dentry *upper;
468 struct dentry *newdentry;
469 int err;
Miklos Szeredi38b25692016-09-01 11:11:59 +0200470 struct posix_acl *acl, *default_acl;
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300471 bool hardlink = !!cattr->hardlink;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200472
Miklos Szeredicc6f67b2015-05-19 14:30:12 +0200473 if (WARN_ON(!workdir))
474 return -EROFS;
475
Miklos Szeredi38b25692016-09-01 11:11:59 +0200476 if (!hardlink) {
477 err = posix_acl_create(dentry->d_parent->d_inode,
Al Viro32a3d842016-12-04 17:33:17 +0000478 &cattr->mode, &default_acl, &acl);
Miklos Szeredi38b25692016-09-01 11:11:59 +0200479 if (err)
480 return err;
481 }
482
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200483 err = ovl_lock_rename_workdir(workdir, upperdir);
484 if (err)
485 goto out;
486
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200487 upper = lookup_one_len(dentry->d_name.name, upperdir,
488 dentry->d_name.len);
489 err = PTR_ERR(upper);
490 if (IS_ERR(upper))
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300491 goto out_unlock;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200492
Miklos Szeredi5e127582018-10-31 12:15:23 +0100493 err = -ESTALE;
494 if (d_is_negative(upper) || !IS_WHITEOUT(d_inode(upper)))
495 goto out_dput;
496
Amir Goldstein137ec522018-05-16 17:51:25 +0300497 newdentry = ovl_create_temp(workdir, cattr);
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300498 err = PTR_ERR(newdentry);
499 if (IS_ERR(newdentry))
500 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200501
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200502 /*
503 * mode could have been mutilated due to umask (e.g. sgid directory)
504 */
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200505 if (!hardlink &&
Al Viro32a3d842016-12-04 17:33:17 +0000506 !S_ISLNK(cattr->mode) &&
507 newdentry->d_inode->i_mode != cattr->mode) {
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200508 struct iattr attr = {
509 .ia_valid = ATTR_MODE,
Al Viro32a3d842016-12-04 17:33:17 +0000510 .ia_mode = cattr->mode,
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200511 };
512 inode_lock(newdentry->d_inode);
Christian Brauner2f221d62021-01-21 14:19:26 +0100513 err = notify_change(&init_user_ns, newdentry, &attr, NULL);
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200514 inode_unlock(newdentry->d_inode);
515 if (err)
516 goto out_cleanup;
517 }
Miklos Szeredi38b25692016-09-01 11:11:59 +0200518 if (!hardlink) {
519 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,
520 acl);
521 if (err)
522 goto out_cleanup;
523
524 err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,
525 default_acl);
526 if (err)
527 goto out_cleanup;
528 }
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200529
Al Viro32a3d842016-12-04 17:33:17 +0000530 if (!hardlink && S_ISDIR(cattr->mode)) {
Miklos Szeredi5cf5b472016-12-16 11:02:57 +0100531 err = ovl_set_opaque(dentry, newdentry);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200532 if (err)
533 goto out_cleanup;
534
535 err = ovl_do_rename(wdir, newdentry, udir, upper,
536 RENAME_EXCHANGE);
537 if (err)
538 goto out_cleanup;
539
540 ovl_cleanup(wdir, upper);
541 } else {
542 err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
543 if (err)
544 goto out_cleanup;
545 }
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300546 err = ovl_instantiate(dentry, inode, newdentry, hardlink);
chenying52d5a0c2021-08-16 18:02:56 +0800547 if (err) {
548 ovl_cleanup(udir, newdentry);
549 dput(newdentry);
550 }
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200551out_dput:
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300552 dput(upper);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200553out_unlock:
554 unlock_rename(workdir, upperdir);
555out:
Miklos Szeredi38b25692016-09-01 11:11:59 +0200556 if (!hardlink) {
557 posix_acl_release(acl);
558 posix_acl_release(default_acl);
559 }
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200560 return err;
561
562out_cleanup:
563 ovl_cleanup(wdir, newdentry);
Miklos Szeredi95a1c812018-05-16 17:51:25 +0300564 dput(newdentry);
565 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200566}
567
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200568static int ovl_create_or_link(struct dentry *dentry, struct inode *inode,
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300569 struct ovl_cattr *attr, bool origin)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200570{
571 int err;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400572 const struct cred *old_cred;
573 struct cred *override_cred;
Amir Goldsteinea3dad12017-07-11 15:58:34 +0300574 struct dentry *parent = dentry->d_parent;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200575
Amir Goldsteinea3dad12017-07-11 15:58:34 +0300576 err = ovl_copy_up(parent);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200577 if (err)
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200578 return err;
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200579
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400580 old_cred = ovl_override_creds(dentry->d_sb);
Amir Goldsteinea3dad12017-07-11 15:58:34 +0300581
582 /*
583 * When linking a file with copy up origin into a new parent, mark the
584 * new parent dir "impure".
585 */
586 if (origin) {
587 err = ovl_set_impure(parent, ovl_dentry_upper(parent));
588 if (err)
589 goto out_revert_creds;
590 }
591
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400592 err = -ENOMEM;
593 override_cred = prepare_creds();
594 if (override_cred) {
Miklos Szeredibb0d2b82016-07-29 12:05:23 +0200595 override_cred->fsuid = inode->i_uid;
596 override_cred->fsgid = inode->i_gid;
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300597 if (!attr->hardlink) {
Vivek Goyal26026252016-07-13 10:44:52 -0400598 err = security_dentry_create_files_as(dentry,
Al Viro32a3d842016-12-04 17:33:17 +0000599 attr->mode, &dentry->d_name, old_cred,
Vivek Goyal26026252016-07-13 10:44:52 -0400600 override_cred);
601 if (err) {
602 put_cred(override_cred);
603 goto out_revert_creds;
604 }
605 }
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400606 put_cred(override_creds(override_cred));
607 put_cred(override_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200608
Miklos Szeredic412ce42016-12-16 11:02:55 +0100609 if (!ovl_dentry_is_whiteout(dentry))
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300610 err = ovl_create_upper(dentry, inode, attr);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400611 else
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300612 err = ovl_create_over_whiteout(dentry, inode, attr);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200613 }
Vivek Goyal26026252016-07-13 10:44:52 -0400614out_revert_creds:
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400615 revert_creds(old_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200616 return err;
617}
618
619static int ovl_create_object(struct dentry *dentry, int mode, dev_t rdev,
620 const char *link)
621{
622 int err;
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200623 struct inode *inode;
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300624 struct ovl_cattr attr = {
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200625 .rdev = rdev,
Al Viro32a3d842016-12-04 17:33:17 +0000626 .link = link,
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200627 };
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200628
629 err = ovl_want_write(dentry);
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200630 if (err)
631 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200632
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300633 /* Preallocate inode to be used by ovl_get_inode() */
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200634 err = -ENOMEM;
Miklos Szeredica4c8a32016-12-16 11:02:55 +0100635 inode = ovl_new_inode(dentry->d_sb, mode, rdev);
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200636 if (!inode)
637 goto out_drop_write;
638
Miklos Szeredi6faf05c2018-08-22 10:55:22 +0200639 spin_lock(&inode->i_lock);
640 inode->i_state |= I_CREATING;
641 spin_unlock(&inode->i_lock);
642
Christian Brauner21cb47b2021-01-21 14:19:25 +0100643 inode_init_owner(&init_user_ns, inode, dentry->d_parent->d_inode, mode);
Al Viro32a3d842016-12-04 17:33:17 +0000644 attr.mode = inode->i_mode;
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200645
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300646 err = ovl_create_or_link(dentry, inode, &attr, false);
Amir Goldstein01b39dc2018-05-11 11:15:15 +0300647 /* Did we end up using the preallocated inode? */
648 if (inode != d_inode(dentry))
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200649 iput(inode);
650
651out_drop_write:
652 ovl_drop_write(dentry);
653out:
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200654 return err;
655}
656
Christian Brauner549c7292021-01-21 14:19:43 +0100657static int ovl_create(struct user_namespace *mnt_userns, struct inode *dir,
658 struct dentry *dentry, umode_t mode, bool excl)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200659{
660 return ovl_create_object(dentry, (mode & 07777) | S_IFREG, 0, NULL);
661}
662
Christian Brauner549c7292021-01-21 14:19:43 +0100663static int ovl_mkdir(struct user_namespace *mnt_userns, struct inode *dir,
664 struct dentry *dentry, umode_t mode)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200665{
666 return ovl_create_object(dentry, (mode & 07777) | S_IFDIR, 0, NULL);
667}
668
Christian Brauner549c7292021-01-21 14:19:43 +0100669static int ovl_mknod(struct user_namespace *mnt_userns, struct inode *dir,
670 struct dentry *dentry, umode_t mode, dev_t rdev)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200671{
672 /* Don't allow creation of "whiteout" on overlay */
673 if (S_ISCHR(mode) && rdev == WHITEOUT_DEV)
674 return -EPERM;
675
676 return ovl_create_object(dentry, mode, rdev, NULL);
677}
678
Christian Brauner549c7292021-01-21 14:19:43 +0100679static int ovl_symlink(struct user_namespace *mnt_userns, struct inode *dir,
680 struct dentry *dentry, const char *link)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200681{
682 return ovl_create_object(dentry, S_IFLNK, 0, link);
683}
684
Amir Goldstein91ff20f2018-11-14 16:01:34 +0200685static int ovl_set_link_redirect(struct dentry *dentry)
686{
687 const struct cred *old_cred;
688 int err;
689
690 old_cred = ovl_override_creds(dentry->d_sb);
691 err = ovl_set_redirect(dentry, false);
692 revert_creds(old_cred);
693
694 return err;
695}
696
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200697static int ovl_link(struct dentry *old, struct inode *newdir,
698 struct dentry *new)
699{
700 int err;
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200701 struct inode *inode;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200702
703 err = ovl_want_write(old);
704 if (err)
705 goto out;
706
707 err = ovl_copy_up(old);
708 if (err)
709 goto out_drop_write;
710
Amir Goldstein6cd07872018-10-18 09:45:49 +0300711 err = ovl_copy_up(new->d_parent);
712 if (err)
713 goto out_drop_write;
714
Vivek Goyal4120fe62018-05-11 11:49:32 -0400715 if (ovl_is_metacopy_dentry(old)) {
Amir Goldstein91ff20f2018-11-14 16:01:34 +0200716 err = ovl_set_link_redirect(old);
Vivek Goyal4120fe62018-05-11 11:49:32 -0400717 if (err)
718 goto out_drop_write;
719 }
720
Amir Goldstein0e329922018-10-18 18:37:13 +0300721 err = ovl_nlink_start(old);
Amir Goldstein5f8415d2017-06-20 15:35:14 +0300722 if (err)
723 goto out_drop_write;
724
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200725 inode = d_inode(old);
726 ihold(inode);
727
Amir Goldstein471ec5d2018-05-16 17:35:02 +0300728 err = ovl_create_or_link(new, inode,
729 &(struct ovl_cattr) {.hardlink = ovl_dentry_upper(old)},
730 ovl_type_origin(old));
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200731 if (err)
732 iput(inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200733
Amir Goldstein0e329922018-10-18 18:37:13 +0300734 ovl_nlink_end(old);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200735out_drop_write:
736 ovl_drop_write(old);
737out:
738 return err;
739}
740
Miklos Szeredi9020df32017-07-04 22:03:16 +0200741static bool ovl_matches_upper(struct dentry *dentry, struct dentry *upper)
742{
743 return d_inode(ovl_dentry_upper(dentry)) == d_inode(upper);
744}
745
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200746static int ovl_remove_and_whiteout(struct dentry *dentry,
747 struct list_head *list)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200748{
Chengguang Xuc21c8392020-04-24 10:55:17 +0800749 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200750 struct dentry *workdir = ovl_workdir(dentry);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200751 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200752 struct dentry *upper;
753 struct dentry *opaquedir = NULL;
754 int err;
755
Miklos Szeredicc6f67b2015-05-19 14:30:12 +0200756 if (WARN_ON(!workdir))
757 return -EROFS;
758
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200759 if (!list_empty(list)) {
760 opaquedir = ovl_clear_empty(dentry, list);
Miklos Szeredi30c17eb2016-07-29 12:05:25 +0200761 err = PTR_ERR(opaquedir);
762 if (IS_ERR(opaquedir))
763 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200764 }
765
766 err = ovl_lock_rename_workdir(workdir, upperdir);
767 if (err)
768 goto out_dput;
769
Maxim Patlasovcfc9fde2016-07-21 18:24:26 -0700770 upper = lookup_one_len(dentry->d_name.name, upperdir,
771 dentry->d_name.len);
772 err = PTR_ERR(upper);
773 if (IS_ERR(upper))
774 goto out_unlock;
775
776 err = -ESTALE;
777 if ((opaquedir && upper != opaquedir) ||
778 (!opaquedir && ovl_dentry_upper(dentry) &&
Miklos Szeredi9020df32017-07-04 22:03:16 +0200779 !ovl_matches_upper(dentry, upper))) {
Maxim Patlasovcfc9fde2016-07-21 18:24:26 -0700780 goto out_dput_upper;
781 }
782
Chengguang Xuc21c8392020-04-24 10:55:17 +0800783 err = ovl_cleanup_and_whiteout(ofs, d_inode(upperdir), upper);
Maxim Patlasovcfc9fde2016-07-21 18:24:26 -0700784 if (err)
Amir Goldsteine7dd0e72017-10-24 17:38:33 +0300785 goto out_d_drop;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200786
Miklos Szeredid9854c82018-07-18 15:44:40 +0200787 ovl_dir_modified(dentry->d_parent, true);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200788out_d_drop:
789 d_drop(dentry);
Maxim Patlasovcfc9fde2016-07-21 18:24:26 -0700790out_dput_upper:
791 dput(upper);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200792out_unlock:
793 unlock_rename(workdir, upperdir);
794out_dput:
795 dput(opaquedir);
796out:
797 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200798}
799
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200800static int ovl_remove_upper(struct dentry *dentry, bool is_dir,
801 struct list_head *list)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200802{
803 struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);
804 struct inode *dir = upperdir->d_inode;
Miklos Szeredi11f37102016-03-21 17:31:44 +0100805 struct dentry *upper;
Amir Goldsteind1595112016-10-26 12:34:06 +0300806 struct dentry *opaquedir = NULL;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200807 int err;
808
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200809 if (!list_empty(list)) {
810 opaquedir = ovl_clear_empty(dentry, list);
Amir Goldsteind1595112016-10-26 12:34:06 +0300811 err = PTR_ERR(opaquedir);
812 if (IS_ERR(opaquedir))
813 goto out;
814 }
815
Al Viro59551022016-01-22 15:40:57 -0500816 inode_lock_nested(dir, I_MUTEX_PARENT);
Miklos Szeredi11f37102016-03-21 17:31:44 +0100817 upper = lookup_one_len(dentry->d_name.name, upperdir,
818 dentry->d_name.len);
819 err = PTR_ERR(upper);
820 if (IS_ERR(upper))
821 goto out_unlock;
822
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200823 err = -ESTALE;
Amir Goldsteind1595112016-10-26 12:34:06 +0300824 if ((opaquedir && upper != opaquedir) ||
Miklos Szeredi9020df32017-07-04 22:03:16 +0200825 (!opaquedir && !ovl_matches_upper(dentry, upper)))
Amir Goldsteind1595112016-10-26 12:34:06 +0300826 goto out_dput_upper;
827
828 if (is_dir)
Christian Brauner6521f892021-01-21 14:19:33 +0100829 err = vfs_rmdir(&init_user_ns, dir, upper);
Amir Goldsteind1595112016-10-26 12:34:06 +0300830 else
Christian Brauner6521f892021-01-21 14:19:33 +0100831 err = vfs_unlink(&init_user_ns, dir, upper, NULL);
Miklos Szeredid9854c82018-07-18 15:44:40 +0200832 ovl_dir_modified(dentry->d_parent, ovl_type_origin(dentry));
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200833
834 /*
835 * Keeping this dentry hashed would mean having to release
836 * upperpath/lowerpath, which could only be done if we are the
837 * sole user of this dentry. Too tricky... Just unhash for
838 * now.
839 */
Rui Wangce9113b2016-01-08 23:09:59 +0800840 if (!err)
841 d_drop(dentry);
Amir Goldsteind1595112016-10-26 12:34:06 +0300842out_dput_upper:
843 dput(upper);
Miklos Szeredi11f37102016-03-21 17:31:44 +0100844out_unlock:
Al Viro59551022016-01-22 15:40:57 -0500845 inode_unlock(dir);
Amir Goldsteind1595112016-10-26 12:34:06 +0300846 dput(opaquedir);
847out:
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200848 return err;
849}
850
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200851static bool ovl_pure_upper(struct dentry *dentry)
852{
853 return !ovl_dentry_lower(dentry) &&
854 !ovl_test_flag(OVL_WHITEOUTS, d_inode(dentry));
855}
856
Miklos Szeredi83552ea2020-03-27 16:51:02 +0100857static void ovl_drop_nlink(struct dentry *dentry)
858{
859 struct inode *inode = d_inode(dentry);
860 struct dentry *alias;
861
862 /* Try to find another, hashed alias */
863 spin_lock(&inode->i_lock);
864 hlist_for_each_entry(alias, &inode->i_dentry, d_u.d_alias) {
865 if (alias != dentry && !d_unhashed(alias))
866 break;
867 }
868 spin_unlock(&inode->i_lock);
869
870 /*
871 * Changes to underlying layers may cause i_nlink to lose sync with
872 * reality. In this case prevent the link count from going to zero
873 * prematurely.
874 */
875 if (inode->i_nlink > !!alias)
876 drop_nlink(inode);
877}
878
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200879static int ovl_do_remove(struct dentry *dentry, bool is_dir)
880{
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200881 int err;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400882 const struct cred *old_cred;
Miklos Szeredid9854c82018-07-18 15:44:40 +0200883 struct dentry *upperdentry;
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200884 bool lower_positive = ovl_lower_positive(dentry);
885 LIST_HEAD(list);
886
887 /* No need to clean pure upper removed by vfs_rmdir() */
888 if (is_dir && (lower_positive || !ovl_pure_upper(dentry))) {
889 err = ovl_check_empty_dir(dentry, &list);
890 if (err)
891 goto out;
892 }
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400893
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200894 err = ovl_want_write(dentry);
895 if (err)
896 goto out;
897
898 err = ovl_copy_up(dentry->d_parent);
899 if (err)
900 goto out_drop_write;
901
Amir Goldstein0e329922018-10-18 18:37:13 +0300902 err = ovl_nlink_start(dentry);
Amir Goldstein5f8415d2017-06-20 15:35:14 +0300903 if (err)
904 goto out_drop_write;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400905
906 old_cred = ovl_override_creds(dentry->d_sb);
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200907 if (!lower_positive)
908 err = ovl_remove_upper(dentry, is_dir, &list);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400909 else
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200910 err = ovl_remove_and_whiteout(dentry, &list);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400911 revert_creds(old_cred);
Miklos Szeredidbc816d2016-07-29 12:05:24 +0200912 if (!err) {
913 if (is_dir)
914 clear_nlink(dentry->d_inode);
915 else
Miklos Szeredi83552ea2020-03-27 16:51:02 +0100916 ovl_drop_nlink(dentry);
Miklos Szeredidbc816d2016-07-29 12:05:24 +0200917 }
Amir Goldstein0e329922018-10-18 18:37:13 +0300918 ovl_nlink_end(dentry);
Miklos Szeredid9854c82018-07-18 15:44:40 +0200919
920 /*
921 * Copy ctime
922 *
923 * Note: we fail to update ctime if there was no copy-up, only a
924 * whiteout
925 */
926 upperdentry = ovl_dentry_upper(dentry);
927 if (upperdentry)
928 ovl_copyattr(d_inode(upperdentry), d_inode(dentry));
929
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200930out_drop_write:
931 ovl_drop_write(dentry);
932out:
Amir Goldstein6d0a8a92017-11-10 13:18:07 +0200933 ovl_cache_free(&list);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200934 return err;
935}
936
937static int ovl_unlink(struct inode *dir, struct dentry *dentry)
938{
939 return ovl_do_remove(dentry, false);
940}
941
942static int ovl_rmdir(struct inode *dir, struct dentry *dentry)
943{
944 return ovl_do_remove(dentry, true);
945}
946
Miklos Szeredi370e55a2016-12-16 11:02:55 +0100947static bool ovl_type_merge_or_lower(struct dentry *dentry)
948{
949 enum ovl_path_type type = ovl_path_type(dentry);
950
951 return OVL_TYPE_MERGE(type) || !OVL_TYPE_UPPER(type);
952}
953
Miklos Szeredia6c60652016-12-16 11:02:56 +0100954static bool ovl_can_move(struct dentry *dentry)
955{
956 return ovl_redirect_dir(dentry->d_sb) ||
957 !d_is_dir(dentry) || !ovl_type_merge_or_lower(dentry);
958}
959
Vivek Goyal7bb08382018-05-11 11:49:32 -0400960static char *ovl_get_redirect(struct dentry *dentry, bool abs_redirect)
Miklos Szeredia6c60652016-12-16 11:02:56 +0100961{
962 char *buf, *ret;
963 struct dentry *d, *tmp;
Miklos Szeredi3ea22a72016-12-16 11:02:57 +0100964 int buflen = ovl_redirect_max + 1;
Miklos Szeredia6c60652016-12-16 11:02:56 +0100965
Vivek Goyal7bb08382018-05-11 11:49:32 -0400966 if (!abs_redirect) {
Miklos Szeredia6c60652016-12-16 11:02:56 +0100967 ret = kstrndup(dentry->d_name.name, dentry->d_name.len,
968 GFP_KERNEL);
969 goto out;
970 }
971
Michal Hocko0ee931c2017-09-13 16:28:29 -0700972 buf = ret = kmalloc(buflen, GFP_KERNEL);
Miklos Szeredia6c60652016-12-16 11:02:56 +0100973 if (!buf)
974 goto out;
975
976 buflen--;
977 buf[buflen] = '\0';
978 for (d = dget(dentry); !IS_ROOT(d);) {
979 const char *name;
980 int thislen;
981
982 spin_lock(&d->d_lock);
983 name = ovl_dentry_get_redirect(d);
984 if (name) {
985 thislen = strlen(name);
986 } else {
987 name = d->d_name.name;
988 thislen = d->d_name.len;
989 }
990
991 /* If path is too long, fall back to userspace move */
992 if (thislen + (name[0] != '/') > buflen) {
993 ret = ERR_PTR(-EXDEV);
994 spin_unlock(&d->d_lock);
995 goto out_put;
996 }
997
998 buflen -= thislen;
999 memcpy(&buf[buflen], name, thislen);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001000 spin_unlock(&d->d_lock);
Liangyane04527f2020-12-22 11:06:26 +08001001 tmp = dget_parent(d);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001002
1003 dput(d);
1004 d = tmp;
1005
1006 /* Absolute redirect: finished */
1007 if (buf[buflen] == '/')
1008 break;
1009 buflen--;
1010 buf[buflen] = '/';
1011 }
1012 ret = kstrdup(&buf[buflen], GFP_KERNEL);
1013out_put:
1014 dput(d);
1015 kfree(buf);
1016out:
1017 return ret ? ret : ERR_PTR(-ENOMEM);
1018}
1019
Vivek Goyal7bb08382018-05-11 11:49:32 -04001020static bool ovl_need_absolute_redirect(struct dentry *dentry, bool samedir)
1021{
1022 struct dentry *lowerdentry;
1023
1024 if (!samedir)
1025 return true;
1026
1027 if (d_is_dir(dentry))
1028 return false;
1029
1030 /*
1031 * For non-dir hardlinked files, we need absolute redirects
1032 * in general as two upper hardlinks could be in different
1033 * dirs. We could put a relative redirect now and convert
1034 * it to absolute redirect later. But when nlink > 1 and
1035 * indexing is on, that means relative redirect needs to be
1036 * converted to absolute during copy up of another lower
1037 * hardllink as well.
1038 *
1039 * So without optimizing too much, just check if lower is
1040 * a hard link or not. If lower is hard link, put absolute
1041 * redirect.
1042 */
1043 lowerdentry = ovl_dentry_lower(dentry);
1044 return (d_inode(lowerdentry)->i_nlink > 1);
1045}
1046
Miklos Szeredia6c60652016-12-16 11:02:56 +01001047static int ovl_set_redirect(struct dentry *dentry, bool samedir)
1048{
1049 int err;
Amir Goldsteina0c236b2021-06-19 12:26:17 +03001050 struct ovl_fs *ofs = OVL_FS(dentry->d_sb);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001051 const char *redirect = ovl_dentry_get_redirect(dentry);
Vivek Goyal7bb08382018-05-11 11:49:32 -04001052 bool absolute_redirect = ovl_need_absolute_redirect(dentry, samedir);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001053
Vivek Goyal7bb08382018-05-11 11:49:32 -04001054 if (redirect && (!absolute_redirect || redirect[0] == '/'))
Miklos Szeredia6c60652016-12-16 11:02:56 +01001055 return 0;
1056
Vivek Goyal7bb08382018-05-11 11:49:32 -04001057 redirect = ovl_get_redirect(dentry, absolute_redirect);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001058 if (IS_ERR(redirect))
1059 return PTR_ERR(redirect);
1060
Amir Goldsteina0c236b2021-06-19 12:26:17 +03001061 err = ovl_check_setxattr(ofs, ovl_dentry_upper(dentry),
Amir Goldstein21a22872017-05-17 00:12:41 +03001062 OVL_XATTR_REDIRECT,
1063 redirect, strlen(redirect), -EXDEV);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001064 if (!err) {
1065 spin_lock(&dentry->d_lock);
1066 ovl_dentry_set_redirect(dentry, redirect);
1067 spin_unlock(&dentry->d_lock);
1068 } else {
1069 kfree(redirect);
lijiazi1bd0a3a2019-12-16 19:12:32 +08001070 pr_warn_ratelimited("failed to set redirect (%i)\n",
Amir Goldsteinda2e6b72017-11-22 20:27:34 +02001071 err);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001072 /* Fall back to userspace copy-up */
1073 err = -EXDEV;
1074 }
1075 return err;
1076}
1077
Christian Brauner549c7292021-01-21 14:19:43 +01001078static int ovl_rename(struct user_namespace *mnt_userns, struct inode *olddir,
1079 struct dentry *old, struct inode *newdir,
1080 struct dentry *new, unsigned int flags)
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001081{
1082 int err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001083 struct dentry *old_upperdir;
1084 struct dentry *new_upperdir;
1085 struct dentry *olddentry;
1086 struct dentry *newdentry;
1087 struct dentry *trap;
1088 bool old_opaque;
1089 bool new_opaque;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001090 bool cleanup_whiteout = false;
Amir Goldstein0e329922018-10-18 18:37:13 +03001091 bool update_nlink = false;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001092 bool overwrite = !(flags & RENAME_EXCHANGE);
David Howellse36cb0b2015-01-29 12:02:35 +00001093 bool is_dir = d_is_dir(old);
Miklos Szeredi370e55a2016-12-16 11:02:55 +01001094 bool new_is_dir = d_is_dir(new);
Miklos Szeredia6c60652016-12-16 11:02:56 +01001095 bool samedir = olddir == newdir;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001096 struct dentry *opaquedir = NULL;
1097 const struct cred *old_cred = NULL;
Amir Goldstein6d0a8a92017-11-10 13:18:07 +02001098 LIST_HEAD(list);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001099
1100 err = -EINVAL;
1101 if (flags & ~(RENAME_EXCHANGE | RENAME_NOREPLACE))
1102 goto out;
1103
1104 flags &= ~RENAME_NOREPLACE;
1105
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001106 /* Don't copy up directory trees */
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001107 err = -EXDEV;
Miklos Szeredia6c60652016-12-16 11:02:56 +01001108 if (!ovl_can_move(old))
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001109 goto out;
Miklos Szeredia6c60652016-12-16 11:02:56 +01001110 if (!overwrite && !ovl_can_move(new))
Miklos Szeredi370e55a2016-12-16 11:02:55 +01001111 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001112
Amir Goldstein6d0a8a92017-11-10 13:18:07 +02001113 if (overwrite && new_is_dir && !ovl_pure_upper(new)) {
1114 err = ovl_check_empty_dir(new, &list);
1115 if (err)
1116 goto out;
1117 }
1118
1119 if (overwrite) {
1120 if (ovl_lower_positive(old)) {
1121 if (!ovl_dentry_is_whiteout(new)) {
1122 /* Whiteout source */
1123 flags |= RENAME_WHITEOUT;
1124 } else {
1125 /* Switch whiteouts */
1126 flags |= RENAME_EXCHANGE;
1127 }
1128 } else if (is_dir && ovl_dentry_is_whiteout(new)) {
1129 flags |= RENAME_EXCHANGE;
1130 cleanup_whiteout = true;
1131 }
1132 }
1133
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001134 err = ovl_want_write(old);
1135 if (err)
1136 goto out;
1137
1138 err = ovl_copy_up(old);
1139 if (err)
1140 goto out_drop_write;
1141
1142 err = ovl_copy_up(new->d_parent);
1143 if (err)
1144 goto out_drop_write;
1145 if (!overwrite) {
1146 err = ovl_copy_up(new);
1147 if (err)
1148 goto out_drop_write;
Amir Goldstein0e329922018-10-18 18:37:13 +03001149 } else if (d_inode(new)) {
1150 err = ovl_nlink_start(new);
Amir Goldstein5f8415d2017-06-20 15:35:14 +03001151 if (err)
1152 goto out_drop_write;
Amir Goldstein0e329922018-10-18 18:37:13 +03001153
1154 update_nlink = true;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001155 }
1156
Vivek Goyal1175b6b2016-07-01 16:34:28 -04001157 old_cred = ovl_override_creds(old->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001158
Amir Goldstein6d0a8a92017-11-10 13:18:07 +02001159 if (!list_empty(&list)) {
1160 opaquedir = ovl_clear_empty(new, &list);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001161 err = PTR_ERR(opaquedir);
1162 if (IS_ERR(opaquedir)) {
1163 opaquedir = NULL;
1164 goto out_revert_creds;
1165 }
1166 }
1167
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001168 old_upperdir = ovl_dentry_upper(old->d_parent);
1169 new_upperdir = ovl_dentry_upper(new->d_parent);
1170
Amir Goldsteinee1d6d372017-05-11 16:42:26 +03001171 if (!samedir) {
1172 /*
1173 * When moving a merge dir or non-dir with copy up origin into
Amir Goldsteinf3a15682017-05-24 15:29:33 +03001174 * a new parent, we are marking the new parent dir "impure".
1175 * When ovl_iterate() iterates an "impure" upper dir, it will
1176 * lookup the origin inodes of the entries to fill d_ino.
Amir Goldsteinee1d6d372017-05-11 16:42:26 +03001177 */
Amir Goldsteinf3a15682017-05-24 15:29:33 +03001178 if (ovl_type_origin(old)) {
Amir Goldsteinee1d6d372017-05-11 16:42:26 +03001179 err = ovl_set_impure(new->d_parent, new_upperdir);
1180 if (err)
1181 goto out_revert_creds;
1182 }
Amir Goldsteinf3a15682017-05-24 15:29:33 +03001183 if (!overwrite && ovl_type_origin(new)) {
Amir Goldsteinee1d6d372017-05-11 16:42:26 +03001184 err = ovl_set_impure(old->d_parent, old_upperdir);
1185 if (err)
1186 goto out_revert_creds;
1187 }
1188 }
1189
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001190 trap = lock_rename(new_upperdir, old_upperdir);
1191
Miklos Szeredi11f37102016-03-21 17:31:44 +01001192 olddentry = lookup_one_len(old->d_name.name, old_upperdir,
1193 old->d_name.len);
1194 err = PTR_ERR(olddentry);
1195 if (IS_ERR(olddentry))
1196 goto out_unlock;
1197
1198 err = -ESTALE;
Miklos Szeredi9020df32017-07-04 22:03:16 +02001199 if (!ovl_matches_upper(old, olddentry))
Miklos Szeredi11f37102016-03-21 17:31:44 +01001200 goto out_dput_old;
1201
1202 newdentry = lookup_one_len(new->d_name.name, new_upperdir,
1203 new->d_name.len);
1204 err = PTR_ERR(newdentry);
1205 if (IS_ERR(newdentry))
1206 goto out_dput_old;
1207
Miklos Szeredi3ee23ff2016-12-16 11:02:55 +01001208 old_opaque = ovl_dentry_is_opaque(old);
1209 new_opaque = ovl_dentry_is_opaque(new);
1210
Miklos Szeredi11f37102016-03-21 17:31:44 +01001211 err = -ESTALE;
Miklos Szeredi09d8b582017-07-04 22:03:16 +02001212 if (d_inode(new) && ovl_dentry_upper(new)) {
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001213 if (opaquedir) {
Miklos Szeredi11f37102016-03-21 17:31:44 +01001214 if (newdentry != opaquedir)
1215 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001216 } else {
Miklos Szeredi9020df32017-07-04 22:03:16 +02001217 if (!ovl_matches_upper(new, newdentry))
Miklos Szeredi11f37102016-03-21 17:31:44 +01001218 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001219 }
1220 } else {
Zheng Lianga295aef2021-09-24 09:16:27 +08001221 if (!d_is_negative(newdentry)) {
1222 if (!new_opaque || !ovl_is_whiteout(newdentry))
1223 goto out_dput;
1224 } else {
1225 if (flags & RENAME_EXCHANGE)
1226 goto out_dput;
1227 }
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001228 }
1229
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001230 if (olddentry == trap)
1231 goto out_dput;
1232 if (newdentry == trap)
1233 goto out_dput;
1234
Amir Goldstein6889ee52019-12-06 08:33:36 +02001235 if (olddentry->d_inode == newdentry->d_inode)
Miklos Szeredi804032f2016-12-16 11:02:55 +01001236 goto out_dput;
1237
Miklos Szeredi5cf5b472016-12-16 11:02:57 +01001238 err = 0;
Vivek Goyal7bb08382018-05-11 11:49:32 -04001239 if (ovl_type_merge_or_lower(old))
1240 err = ovl_set_redirect(old, samedir);
1241 else if (is_dir && !old_opaque && ovl_type_merge(new->d_parent))
1242 err = ovl_set_opaque_xerr(old, olddentry, -EXDEV);
1243 if (err)
1244 goto out_dput;
1245
1246 if (!overwrite && ovl_type_merge_or_lower(new))
1247 err = ovl_set_redirect(new, samedir);
1248 else if (!overwrite && new_is_dir && !new_opaque &&
1249 ovl_type_merge(old->d_parent))
1250 err = ovl_set_opaque_xerr(new, newdentry, -EXDEV);
1251 if (err)
1252 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001253
Miklos Szeredi3ee23ff2016-12-16 11:02:55 +01001254 err = ovl_do_rename(old_upperdir->d_inode, olddentry,
1255 new_upperdir->d_inode, newdentry, flags);
1256 if (err)
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001257 goto out_dput;
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001258
1259 if (cleanup_whiteout)
1260 ovl_cleanup(old_upperdir->d_inode, newdentry);
1261
Amir Goldsteinf681eb12017-06-05 22:44:49 +03001262 if (overwrite && d_inode(new)) {
1263 if (new_is_dir)
1264 clear_nlink(d_inode(new));
1265 else
Miklos Szeredi83552ea2020-03-27 16:51:02 +01001266 ovl_drop_nlink(new);
Amir Goldsteinf681eb12017-06-05 22:44:49 +03001267 }
1268
Miklos Szeredid9854c82018-07-18 15:44:40 +02001269 ovl_dir_modified(old->d_parent, ovl_type_origin(old) ||
1270 (!overwrite && ovl_type_origin(new)));
1271 ovl_dir_modified(new->d_parent, ovl_type_origin(old) ||
1272 (d_inode(new) && ovl_type_origin(new)));
1273
1274 /* copy ctime: */
1275 ovl_copyattr(d_inode(olddentry), d_inode(old));
1276 if (d_inode(new) && ovl_dentry_upper(new))
1277 ovl_copyattr(d_inode(newdentry), d_inode(new));
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001278
1279out_dput:
1280 dput(newdentry);
Miklos Szeredi11f37102016-03-21 17:31:44 +01001281out_dput_old:
1282 dput(olddentry);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001283out_unlock:
1284 unlock_rename(new_upperdir, old_upperdir);
1285out_revert_creds:
Vivek Goyal1175b6b2016-07-01 16:34:28 -04001286 revert_creds(old_cred);
Amir Goldstein0e329922018-10-18 18:37:13 +03001287 if (update_nlink)
1288 ovl_nlink_end(new);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001289out_drop_write:
1290 ovl_drop_write(old);
1291out:
1292 dput(opaquedir);
Amir Goldstein6d0a8a92017-11-10 13:18:07 +02001293 ovl_cache_free(&list);
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001294 return err;
1295}
1296
1297const struct inode_operations ovl_dir_inode_operations = {
1298 .lookup = ovl_lookup,
1299 .mkdir = ovl_mkdir,
1300 .symlink = ovl_symlink,
1301 .unlink = ovl_unlink,
1302 .rmdir = ovl_rmdir,
Miklos Szeredi6c02cb52016-12-16 11:02:55 +01001303 .rename = ovl_rename,
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001304 .link = ovl_link,
1305 .setattr = ovl_setattr,
1306 .create = ovl_create,
1307 .mknod = ovl_mknod,
1308 .permission = ovl_permission,
Miklos Szeredi5b712092017-05-05 11:38:58 +02001309 .getattr = ovl_getattr,
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001310 .listxattr = ovl_listxattr,
Vivek Goyal39a25b22016-07-01 16:34:26 -04001311 .get_acl = ovl_get_acl,
Miklos Szeredid719e8f2016-07-29 12:05:23 +02001312 .update_time = ovl_update_time,
Miklos Szeredi66dbfab2021-04-07 14:36:43 +02001313 .fileattr_get = ovl_fileattr_get,
1314 .fileattr_set = ovl_fileattr_set,
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001315};