blob: 54e5d6681786780812c9a5adddc27dd782b40bbb [file] [log] [blame]
Miklos Szeredie9be9d52014-10-24 00:14:38 +02001/*
2 *
3 * Copyright (C) 2011 Novell Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 */
9
David Howellsfb5bb2c32015-07-07 15:04:44 +010010#include <linux/module.h>
Miklos Szeredie9be9d52014-10-24 00:14:38 +020011#include <linux/fs.h>
12#include <linux/slab.h>
13#include <linux/file.h>
14#include <linux/splice.h>
15#include <linux/xattr.h>
16#include <linux/security.h>
17#include <linux/uaccess.h>
18#include <linux/sched.h>
19#include <linux/namei.h>
David Howellsfb5bb2c32015-07-07 15:04:44 +010020#include <linux/fdtable.h>
21#include <linux/ratelimit.h>
Miklos Szeredie9be9d52014-10-24 00:14:38 +020022#include "overlayfs.h"
23
24#define OVL_COPY_UP_CHUNK_SIZE (1 << 20)
25
David Howellsfb5bb2c32015-07-07 15:04:44 +010026static bool __read_mostly ovl_check_copy_up;
27module_param_named(check_copy_up, ovl_check_copy_up, bool,
28 S_IWUSR | S_IRUGO);
29MODULE_PARM_DESC(ovl_check_copy_up,
30 "Warn on copy-up when causing process also has a R/O fd open");
31
32static int ovl_check_fd(const void *data, struct file *f, unsigned int fd)
33{
34 const struct dentry *dentry = data;
35
36 if (f->f_inode == d_inode(dentry))
37 pr_warn_ratelimited("overlayfs: Warning: Copying up %pD, but open R/O on fd %u which will cease to be coherent [pid=%d %s]\n",
38 f, fd, current->pid, current->comm);
39 return 0;
40}
41
42/*
43 * Check the fds open by this process and warn if something like the following
44 * scenario is about to occur:
45 *
46 * fd1 = open("foo", O_RDONLY);
47 * fd2 = open("foo", O_RDWR);
48 */
49static void ovl_do_check_copy_up(struct dentry *dentry)
50{
51 if (ovl_check_copy_up)
52 iterate_fd(current->files, 0, ovl_check_fd, dentry);
53}
54
Miklos Szeredie9be9d52014-10-24 00:14:38 +020055int ovl_copy_xattr(struct dentry *old, struct dentry *new)
56{
Vito Caputoe4ad29f2015-10-24 07:19:46 -050057 ssize_t list_size, size, value_size = 0;
58 char *buf, *name, *value = NULL;
59 int uninitialized_var(error);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020060
61 if (!old->d_inode->i_op->getxattr ||
62 !new->d_inode->i_op->getxattr)
63 return 0;
64
65 list_size = vfs_listxattr(old, NULL, 0);
66 if (list_size <= 0) {
67 if (list_size == -EOPNOTSUPP)
68 return 0;
69 return list_size;
70 }
71
72 buf = kzalloc(list_size, GFP_KERNEL);
73 if (!buf)
74 return -ENOMEM;
75
Miklos Szeredie9be9d52014-10-24 00:14:38 +020076 list_size = vfs_listxattr(old, buf, list_size);
77 if (list_size <= 0) {
78 error = list_size;
Vito Caputoe4ad29f2015-10-24 07:19:46 -050079 goto out;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020080 }
81
82 for (name = buf; name < (buf + list_size); name += strlen(name) + 1) {
Vito Caputoe4ad29f2015-10-24 07:19:46 -050083retry:
84 size = vfs_getxattr(old, name, value, value_size);
85 if (size == -ERANGE)
86 size = vfs_getxattr(old, name, NULL, 0);
87
Miklos Szeredi97daf8b2015-11-10 17:08:41 +010088 if (size < 0) {
Miklos Szeredie9be9d52014-10-24 00:14:38 +020089 error = size;
Vito Caputoe4ad29f2015-10-24 07:19:46 -050090 break;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020091 }
Vito Caputoe4ad29f2015-10-24 07:19:46 -050092
93 if (size > value_size) {
94 void *new;
95
96 new = krealloc(value, size, GFP_KERNEL);
97 if (!new) {
98 error = -ENOMEM;
99 break;
100 }
101 value = new;
102 value_size = size;
103 goto retry;
104 }
105
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200106 error = vfs_setxattr(new, name, value, size, 0);
107 if (error)
Vito Caputoe4ad29f2015-10-24 07:19:46 -0500108 break;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200109 }
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200110 kfree(value);
111out:
112 kfree(buf);
113 return error;
114}
115
116static int ovl_copy_up_data(struct path *old, struct path *new, loff_t len)
117{
118 struct file *old_file;
119 struct file *new_file;
120 loff_t old_pos = 0;
121 loff_t new_pos = 0;
122 int error = 0;
123
124 if (len == 0)
125 return 0;
126
David Howells04803342015-09-18 11:45:12 +0100127 old_file = ovl_path_open(old, O_LARGEFILE | O_RDONLY);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200128 if (IS_ERR(old_file))
129 return PTR_ERR(old_file);
130
David Howells04803342015-09-18 11:45:12 +0100131 new_file = ovl_path_open(new, O_LARGEFILE | O_WRONLY);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200132 if (IS_ERR(new_file)) {
133 error = PTR_ERR(new_file);
134 goto out_fput;
135 }
136
137 /* FIXME: copy up sparse files efficiently */
138 while (len) {
139 size_t this_len = OVL_COPY_UP_CHUNK_SIZE;
140 long bytes;
141
142 if (len < this_len)
143 this_len = len;
144
145 if (signal_pending_state(TASK_KILLABLE, current)) {
146 error = -EINTR;
147 break;
148 }
149
150 bytes = do_splice_direct(old_file, &old_pos,
151 new_file, &new_pos,
152 this_len, SPLICE_F_MOVE);
153 if (bytes <= 0) {
154 error = bytes;
155 break;
156 }
157 WARN_ON(old_pos != new_pos);
158
159 len -= bytes;
160 }
161
162 fput(new_file);
163out_fput:
164 fput(old_file);
165 return error;
166}
167
168static char *ovl_read_symlink(struct dentry *realdentry)
169{
170 int res;
171 char *buf;
172 struct inode *inode = realdentry->d_inode;
173 mm_segment_t old_fs;
174
175 res = -EINVAL;
176 if (!inode->i_op->readlink)
177 goto err;
178
179 res = -ENOMEM;
180 buf = (char *) __get_free_page(GFP_KERNEL);
181 if (!buf)
182 goto err;
183
184 old_fs = get_fs();
185 set_fs(get_ds());
186 /* The cast to a user pointer is valid due to the set_fs() */
187 res = inode->i_op->readlink(realdentry,
188 (char __user *)buf, PAGE_SIZE - 1);
189 set_fs(old_fs);
190 if (res < 0) {
191 free_page((unsigned long) buf);
192 goto err;
193 }
194 buf[res] = '\0';
195
196 return buf;
197
198err:
199 return ERR_PTR(res);
200}
201
202static int ovl_set_timestamps(struct dentry *upperdentry, struct kstat *stat)
203{
204 struct iattr attr = {
205 .ia_valid =
206 ATTR_ATIME | ATTR_MTIME | ATTR_ATIME_SET | ATTR_MTIME_SET,
207 .ia_atime = stat->atime,
208 .ia_mtime = stat->mtime,
209 };
210
211 return notify_change(upperdentry, &attr, NULL);
212}
213
214int ovl_set_attr(struct dentry *upperdentry, struct kstat *stat)
215{
216 int err = 0;
217
218 if (!S_ISLNK(stat->mode)) {
219 struct iattr attr = {
220 .ia_valid = ATTR_MODE,
221 .ia_mode = stat->mode,
222 };
223 err = notify_change(upperdentry, &attr, NULL);
224 }
225 if (!err) {
226 struct iattr attr = {
227 .ia_valid = ATTR_UID | ATTR_GID,
228 .ia_uid = stat->uid,
229 .ia_gid = stat->gid,
230 };
231 err = notify_change(upperdentry, &attr, NULL);
232 }
233 if (!err)
234 ovl_set_timestamps(upperdentry, stat);
235
236 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200237}
238
239static int ovl_copy_up_locked(struct dentry *workdir, struct dentry *upperdir,
240 struct dentry *dentry, struct path *lowerpath,
Al Viro0f7ff2d2015-12-06 12:31:07 -0500241 struct kstat *stat, const char *link)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200242{
243 struct inode *wdir = workdir->d_inode;
244 struct inode *udir = upperdir->d_inode;
245 struct dentry *newdentry = NULL;
246 struct dentry *upper = NULL;
247 umode_t mode = stat->mode;
248 int err;
249
250 newdentry = ovl_lookup_temp(workdir, dentry);
251 err = PTR_ERR(newdentry);
252 if (IS_ERR(newdentry))
253 goto out;
254
255 upper = lookup_one_len(dentry->d_name.name, upperdir,
256 dentry->d_name.len);
257 err = PTR_ERR(upper);
258 if (IS_ERR(upper))
259 goto out1;
260
261 /* Can't properly set mode on creation because of the umask */
262 stat->mode &= S_IFMT;
263 err = ovl_create_real(wdir, newdentry, stat, link, NULL, true);
264 stat->mode = mode;
265 if (err)
266 goto out2;
267
268 if (S_ISREG(stat->mode)) {
269 struct path upperpath;
Sohom Bhattacharjeef134f242016-03-15 20:57:59 +0530270
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200271 ovl_path_upper(dentry, &upperpath);
272 BUG_ON(upperpath.dentry != NULL);
273 upperpath.dentry = newdentry;
274
275 err = ovl_copy_up_data(lowerpath, &upperpath, stat->size);
276 if (err)
277 goto out_cleanup;
278 }
279
280 err = ovl_copy_xattr(lowerpath->dentry, newdentry);
281 if (err)
282 goto out_cleanup;
283
Al Viro59551022016-01-22 15:40:57 -0500284 inode_lock(newdentry->d_inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200285 err = ovl_set_attr(newdentry, stat);
Al Viro59551022016-01-22 15:40:57 -0500286 inode_unlock(newdentry->d_inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200287 if (err)
288 goto out_cleanup;
289
290 err = ovl_do_rename(wdir, newdentry, udir, upper, 0);
291 if (err)
292 goto out_cleanup;
293
294 ovl_dentry_update(dentry, newdentry);
Miklos Szeredi39b681f2016-07-29 12:05:24 +0200295 ovl_inode_update(d_inode(dentry), d_inode(newdentry));
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200296 newdentry = NULL;
297
298 /*
299 * Non-directores become opaque when copied up.
300 */
301 if (!S_ISDIR(stat->mode))
302 ovl_dentry_set_opaque(dentry, true);
303out2:
304 dput(upper);
305out1:
306 dput(newdentry);
307out:
308 return err;
309
310out_cleanup:
311 ovl_cleanup(wdir, newdentry);
David Howellsab79efa2015-09-18 11:45:22 +0100312 goto out2;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200313}
314
315/*
316 * Copy up a single dentry
317 *
318 * Directory renames only allowed on "pure upper" (already created on
319 * upper filesystem, never copied up). Directories which are on lower or
320 * are merged may not be renamed. For these -EXDEV is returned and
321 * userspace has to deal with it. This means, when copying up a
322 * directory we can rely on it and ancestors being stable.
323 *
324 * Non-directory renames start with copy up of source if necessary. The
325 * actual rename will only proceed once the copy up was successful. Copy
326 * up uses upper parent i_mutex for exclusion. Since rename can change
327 * d_parent it is possible that the copy up will lock the old parent. At
328 * that point the file will have already been copied up anyway.
329 */
330int ovl_copy_up_one(struct dentry *parent, struct dentry *dentry,
Al Viro0f7ff2d2015-12-06 12:31:07 -0500331 struct path *lowerpath, struct kstat *stat)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200332{
333 struct dentry *workdir = ovl_workdir(dentry);
334 int err;
335 struct kstat pstat;
336 struct path parentpath;
337 struct dentry *upperdir;
338 struct dentry *upperdentry;
339 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200340 char *link = NULL;
341
Miklos Szeredicc6f67b2015-05-19 14:30:12 +0200342 if (WARN_ON(!workdir))
343 return -EROFS;
344
David Howellsfb5bb2c32015-07-07 15:04:44 +0100345 ovl_do_check_copy_up(lowerpath->dentry);
346
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200347 ovl_path_upper(parent, &parentpath);
348 upperdir = parentpath.dentry;
349
350 err = vfs_getattr(&parentpath, &pstat);
351 if (err)
352 return err;
353
354 if (S_ISLNK(stat->mode)) {
355 link = ovl_read_symlink(lowerpath->dentry);
356 if (IS_ERR(link))
357 return PTR_ERR(link);
358 }
359
Antonio Murdaca3fe6e522016-04-07 15:48:25 +0200360 old_cred = ovl_override_creds(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200361
362 err = -EIO;
363 if (lock_rename(workdir, upperdir) != NULL) {
364 pr_err("overlayfs: failed to lock workdir+upperdir\n");
365 goto out_unlock;
366 }
367 upperdentry = ovl_dentry_upper(dentry);
368 if (upperdentry) {
Al Viro0f7ff2d2015-12-06 12:31:07 -0500369 /* Raced with another copy-up? Nothing to do, then... */
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200370 err = 0;
Al Viro0f7ff2d2015-12-06 12:31:07 -0500371 goto out_unlock;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200372 }
373
374 err = ovl_copy_up_locked(workdir, upperdir, dentry, lowerpath,
Al Viro0f7ff2d2015-12-06 12:31:07 -0500375 stat, link);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200376 if (!err) {
377 /* Restore timestamps on parent (best effort) */
378 ovl_set_timestamps(upperdir, &pstat);
379 }
380out_unlock:
381 unlock_rename(workdir, upperdir);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200382 revert_creds(old_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200383
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200384 if (link)
385 free_page((unsigned long) link);
386
387 return err;
388}
389
390int ovl_copy_up(struct dentry *dentry)
391{
392 int err;
393
394 err = 0;
395 while (!err) {
396 struct dentry *next;
397 struct dentry *parent;
398 struct path lowerpath;
399 struct kstat stat;
400 enum ovl_path_type type = ovl_path_type(dentry);
401
Miklos Szeredi1afaba12014-12-13 00:59:42 +0100402 if (OVL_TYPE_UPPER(type))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200403 break;
404
405 next = dget(dentry);
406 /* find the topmost dentry not yet copied up */
407 for (;;) {
408 parent = dget_parent(next);
409
410 type = ovl_path_type(parent);
Miklos Szeredi1afaba12014-12-13 00:59:42 +0100411 if (OVL_TYPE_UPPER(type))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200412 break;
413
414 dput(next);
415 next = parent;
416 }
417
418 ovl_path_lower(next, &lowerpath);
419 err = vfs_getattr(&lowerpath, &stat);
420 if (!err)
Al Viro0f7ff2d2015-12-06 12:31:07 -0500421 err = ovl_copy_up_one(parent, next, &lowerpath, &stat);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200422
423 dput(parent);
424 dput(next);
425 }
426
427 return err;
428}