blob: 6be0d276fd0522ca0a4fcf8f0c4fa05384d8118c [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
10#include <linux/fs.h>
11#include <linux/slab.h>
12#include <linux/xattr.h>
13#include "overlayfs.h"
14
Al Viro0f7ff2d2015-12-06 12:31:07 -050015static int ovl_copy_up_truncate(struct dentry *dentry)
Miklos Szeredie9be9d52014-10-24 00:14:38 +020016{
17 int err;
18 struct dentry *parent;
19 struct kstat stat;
20 struct path lowerpath;
21
22 parent = dget_parent(dentry);
23 err = ovl_copy_up(parent);
24 if (err)
25 goto out_dput_parent;
26
27 ovl_path_lower(dentry, &lowerpath);
28 err = vfs_getattr(&lowerpath, &stat);
29 if (err)
30 goto out_dput_parent;
31
Al Viro0f7ff2d2015-12-06 12:31:07 -050032 stat.size = 0;
33 err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020034
35out_dput_parent:
36 dput(parent);
37 return err;
38}
39
40int ovl_setattr(struct dentry *dentry, struct iattr *attr)
41{
42 int err;
43 struct dentry *upperdentry;
Vivek Goyal1175b6b2016-07-01 16:34:28 -040044 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +020045
Miklos Szeredicf9a6782015-12-11 16:30:49 +010046 /*
47 * Check for permissions before trying to copy-up. This is redundant
48 * since it will be rechecked later by ->setattr() on upper dentry. But
49 * without this, copy-up can be triggered by just about anybody.
50 *
51 * We don't initialize inode->size, which just means that
52 * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not
53 * check for a swapfile (which this won't be anyway).
54 */
55 err = inode_change_ok(dentry->d_inode, attr);
56 if (err)
57 return err;
58
Miklos Szeredie9be9d52014-10-24 00:14:38 +020059 err = ovl_want_write(dentry);
60 if (err)
61 goto out;
62
Miklos Szeredi03bea602016-06-29 16:03:55 +020063 if (attr->ia_valid & ATTR_SIZE) {
64 struct inode *realinode = d_inode(ovl_dentry_real(dentry));
65
66 err = -ETXTBSY;
67 if (atomic_read(&realinode->i_writecount) < 0)
68 goto out_drop_write;
69 }
70
Miklos Szerediacff81e2015-12-04 19:18:48 +010071 err = ovl_copy_up(dentry);
72 if (!err) {
Miklos Szeredi03bea602016-06-29 16:03:55 +020073 struct inode *winode = NULL;
74
Miklos Szerediacff81e2015-12-04 19:18:48 +010075 upperdentry = ovl_dentry_upper(dentry);
76
Miklos Szeredi03bea602016-06-29 16:03:55 +020077 if (attr->ia_valid & ATTR_SIZE) {
78 winode = d_inode(upperdentry);
79 err = get_write_access(winode);
80 if (err)
81 goto out_drop_write;
82 }
83
Miklos Szeredib99c2d92016-07-04 16:49:48 +020084 if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
85 attr->ia_valid &= ~ATTR_MODE;
86
Al Viro59551022016-01-22 15:40:57 -050087 inode_lock(upperdentry->d_inode);
Vivek Goyal1175b6b2016-07-01 16:34:28 -040088 old_cred = ovl_override_creds(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020089 err = notify_change(upperdentry, attr, NULL);
Vivek Goyal1175b6b2016-07-01 16:34:28 -040090 revert_creds(old_cred);
Konstantin Khlebnikovb81de062016-01-31 16:21:29 +030091 if (!err)
92 ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
Al Viro59551022016-01-22 15:40:57 -050093 inode_unlock(upperdentry->d_inode);
Miklos Szeredi03bea602016-06-29 16:03:55 +020094
95 if (winode)
96 put_write_access(winode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +020097 }
Miklos Szeredi03bea602016-06-29 16:03:55 +020098out_drop_write:
Miklos Szeredie9be9d52014-10-24 00:14:38 +020099 ovl_drop_write(dentry);
100out:
101 return err;
102}
103
104static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
105 struct kstat *stat)
106{
107 struct path realpath;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400108 const struct cred *old_cred;
109 int err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200110
111 ovl_path_real(dentry, &realpath);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400112 old_cred = ovl_override_creds(dentry->d_sb);
113 err = vfs_getattr(&realpath, stat);
114 revert_creds(old_cred);
115 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200116}
117
118int ovl_permission(struct inode *inode, int mask)
119{
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200120 bool is_upper;
Miklos Szeredi39b681f2016-07-29 12:05:24 +0200121 struct inode *realinode = ovl_inode_real(inode, &is_upper);
Vivek Goyalc0ca3d72016-07-01 16:34:27 -0400122 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200123 int err;
124
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200125 /* Careful in RCU walk mode */
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200126 if (!realinode) {
127 WARN_ON(!(mask & MAY_NOT_BLOCK));
Miklos Szeredia999d7e2016-07-29 12:05:23 +0200128 return -ECHILD;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200129 }
130
Vivek Goyalc0ca3d72016-07-01 16:34:27 -0400131 /*
132 * Check overlay inode with the creds of task and underlying inode
133 * with creds of mounter
134 */
135 err = generic_permission(inode, mask);
136 if (err)
137 return err;
138
139 old_cred = ovl_override_creds(inode->i_sb);
Vivek Goyal754f8cb2016-07-01 16:34:29 -0400140 if (!is_upper)
141 mask &= ~(MAY_WRITE | MAY_APPEND);
Miklos Szeredi9c630eb2016-07-29 12:05:23 +0200142 err = inode_permission(realinode, mask);
Vivek Goyalc0ca3d72016-07-01 16:34:27 -0400143 revert_creds(old_cred);
144
145 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200146}
147
Al Viro6b255392015-11-17 10:20:54 -0500148static const char *ovl_get_link(struct dentry *dentry,
Al Virofceef392015-12-29 15:58:39 -0500149 struct inode *inode,
150 struct delayed_call *done)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200151{
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200152 struct dentry *realdentry;
153 struct inode *realinode;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400154 const struct cred *old_cred;
155 const char *p;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200156
Al Viro6b255392015-11-17 10:20:54 -0500157 if (!dentry)
158 return ERR_PTR(-ECHILD);
159
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200160 realdentry = ovl_dentry_real(dentry);
161 realinode = realdentry->d_inode;
162
Al Viro6b255392015-11-17 10:20:54 -0500163 if (WARN_ON(!realinode->i_op->get_link))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200164 return ERR_PTR(-EPERM);
165
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400166 old_cred = ovl_override_creds(dentry->d_sb);
167 p = realinode->i_op->get_link(realdentry, realinode, done);
168 revert_creds(old_cred);
169 return p;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200170}
171
172static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
173{
174 struct path realpath;
175 struct inode *realinode;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400176 const struct cred *old_cred;
177 int err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200178
179 ovl_path_real(dentry, &realpath);
180 realinode = realpath.dentry->d_inode;
181
182 if (!realinode->i_op->readlink)
183 return -EINVAL;
184
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400185 old_cred = ovl_override_creds(dentry->d_sb);
186 err = realinode->i_op->readlink(realpath.dentry, buf, bufsiz);
187 revert_creds(old_cred);
188 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200189}
190
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200191static bool ovl_is_private_xattr(const char *name)
192{
hujianyangcead89b2014-11-24 18:25:21 +0800193 return strncmp(name, OVL_XATTR_PRE_NAME, OVL_XATTR_PRE_LEN) == 0;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200194}
195
Al Viro3767e252016-05-27 11:06:05 -0400196int ovl_setxattr(struct dentry *dentry, struct inode *inode,
197 const char *name, const void *value,
198 size_t size, int flags)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200199{
200 int err;
201 struct dentry *upperdentry;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400202 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200203
204 err = ovl_want_write(dentry);
205 if (err)
206 goto out;
207
208 err = -EPERM;
209 if (ovl_is_private_xattr(name))
210 goto out_drop_write;
211
212 err = ovl_copy_up(dentry);
213 if (err)
214 goto out_drop_write;
215
216 upperdentry = ovl_dentry_upper(dentry);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400217 old_cred = ovl_override_creds(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200218 err = vfs_setxattr(upperdentry, name, value, size, flags);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400219 revert_creds(old_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200220
221out_drop_write:
222 ovl_drop_write(dentry);
223out:
224 return err;
225}
226
Al Viroce23e642016-04-11 00:48:00 -0400227ssize_t ovl_getxattr(struct dentry *dentry, struct inode *inode,
228 const char *name, void *value, size_t size)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200229{
Miklos Szeredib5817552016-06-06 16:21:37 +0200230 struct dentry *realdentry = ovl_dentry_real(dentry);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400231 ssize_t res;
232 const struct cred *old_cred;
Miklos Szeredi52148462014-11-20 16:40:00 +0100233
Miklos Szeredib5817552016-06-06 16:21:37 +0200234 if (ovl_is_private_xattr(name))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200235 return -ENODATA;
236
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400237 old_cred = ovl_override_creds(dentry->d_sb);
238 res = vfs_getxattr(realdentry, name, value, size);
239 revert_creds(old_cred);
240 return res;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200241}
242
243ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
244{
Miklos Szeredib5817552016-06-06 16:21:37 +0200245 struct dentry *realdentry = ovl_dentry_real(dentry);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200246 ssize_t res;
247 int off;
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400248 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200249
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400250 old_cred = ovl_override_creds(dentry->d_sb);
Miklos Szeredib5817552016-06-06 16:21:37 +0200251 res = vfs_listxattr(realdentry, list, size);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400252 revert_creds(old_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200253 if (res <= 0 || size == 0)
254 return res;
255
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200256 /* filter out private xattrs */
257 for (off = 0; off < res;) {
258 char *s = list + off;
259 size_t slen = strlen(s) + 1;
260
261 BUG_ON(off + slen > res);
262
263 if (ovl_is_private_xattr(s)) {
264 res -= slen;
265 memmove(s, s + slen, res - off);
266 } else {
267 off += slen;
268 }
269 }
270
271 return res;
272}
273
274int ovl_removexattr(struct dentry *dentry, const char *name)
275{
276 int err;
277 struct path realpath;
Miklos Szeredi52148462014-11-20 16:40:00 +0100278 enum ovl_path_type type = ovl_path_real(dentry, &realpath);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400279 const struct cred *old_cred;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200280
281 err = ovl_want_write(dentry);
282 if (err)
283 goto out;
284
Miklos Szeredi52148462014-11-20 16:40:00 +0100285 err = -ENODATA;
Miklos Szeredib5817552016-06-06 16:21:37 +0200286 if (ovl_is_private_xattr(name))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200287 goto out_drop_write;
288
Miklos Szeredi1afaba12014-12-13 00:59:42 +0100289 if (!OVL_TYPE_UPPER(type)) {
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200290 err = vfs_getxattr(realpath.dentry, name, NULL, 0);
291 if (err < 0)
292 goto out_drop_write;
293
294 err = ovl_copy_up(dentry);
295 if (err)
296 goto out_drop_write;
297
298 ovl_path_upper(dentry, &realpath);
299 }
300
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400301 old_cred = ovl_override_creds(dentry->d_sb);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200302 err = vfs_removexattr(realpath.dentry, name);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400303 revert_creds(old_cred);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200304out_drop_write:
305 ovl_drop_write(dentry);
306out:
307 return err;
308}
309
Vivek Goyal39a25b22016-07-01 16:34:26 -0400310struct posix_acl *ovl_get_acl(struct inode *inode, int type)
311{
Miklos Szeredi39b681f2016-07-29 12:05:24 +0200312 struct inode *realinode = ovl_inode_real(inode, NULL);
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400313 const struct cred *old_cred;
314 struct posix_acl *acl;
Vivek Goyal39a25b22016-07-01 16:34:26 -0400315
Vivek Goyal39a25b22016-07-01 16:34:26 -0400316 if (!IS_POSIXACL(realinode))
317 return NULL;
318
319 if (!realinode->i_op->get_acl)
320 return NULL;
321
Vivek Goyal1175b6b2016-07-01 16:34:28 -0400322 old_cred = ovl_override_creds(inode->i_sb);
323 acl = realinode->i_op->get_acl(realinode, type);
324 revert_creds(old_cred);
325
326 return acl;
Vivek Goyal39a25b22016-07-01 16:34:26 -0400327}
328
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200329static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
330 struct dentry *realdentry)
331{
Miklos Szeredi1afaba12014-12-13 00:59:42 +0100332 if (OVL_TYPE_UPPER(type))
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200333 return false;
334
335 if (special_file(realdentry->d_inode->i_mode))
336 return false;
337
338 if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
339 return false;
340
341 return true;
342}
343
Miklos Szeredi2d902672016-06-30 08:53:27 +0200344int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200345{
Miklos Szeredi2d902672016-06-30 08:53:27 +0200346 int err = 0;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200347 struct path realpath;
348 enum ovl_path_type type;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200349
350 type = ovl_path_real(dentry, &realpath);
David Howells4bacc9c2015-06-18 14:32:31 +0100351 if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) {
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200352 err = ovl_want_write(dentry);
Miklos Szeredi2d902672016-06-30 08:53:27 +0200353 if (!err) {
354 if (file_flags & O_TRUNC)
355 err = ovl_copy_up_truncate(dentry);
356 else
357 err = ovl_copy_up(dentry);
358 ovl_drop_write(dentry);
359 }
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200360 }
361
Miklos Szeredi2d902672016-06-30 08:53:27 +0200362 return err;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200363}
364
Miklos Szeredid719e8f2016-07-29 12:05:23 +0200365int ovl_update_time(struct inode *inode, struct timespec *ts, int flags)
366{
367 struct dentry *alias;
368 struct path upperpath;
369
370 if (!(flags & S_ATIME))
371 return 0;
372
373 alias = d_find_any_alias(inode);
374 if (!alias)
375 return 0;
376
377 ovl_path_upper(alias, &upperpath);
378 if (upperpath.dentry) {
379 touch_atime(&upperpath);
380 inode->i_atime = d_inode(upperpath.dentry)->i_atime;
381 }
382
383 dput(alias);
384
385 return 0;
386}
387
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200388static const struct inode_operations ovl_file_inode_operations = {
389 .setattr = ovl_setattr,
390 .permission = ovl_permission,
391 .getattr = ovl_getattr,
392 .setxattr = ovl_setxattr,
393 .getxattr = ovl_getxattr,
394 .listxattr = ovl_listxattr,
395 .removexattr = ovl_removexattr,
Vivek Goyal39a25b22016-07-01 16:34:26 -0400396 .get_acl = ovl_get_acl,
Miklos Szeredid719e8f2016-07-29 12:05:23 +0200397 .update_time = ovl_update_time,
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200398};
399
400static const struct inode_operations ovl_symlink_inode_operations = {
401 .setattr = ovl_setattr,
Al Viro6b255392015-11-17 10:20:54 -0500402 .get_link = ovl_get_link,
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200403 .readlink = ovl_readlink,
404 .getattr = ovl_getattr,
405 .setxattr = ovl_setxattr,
406 .getxattr = ovl_getxattr,
407 .listxattr = ovl_listxattr,
408 .removexattr = ovl_removexattr,
Miklos Szeredid719e8f2016-07-29 12:05:23 +0200409 .update_time = ovl_update_time,
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200410};
411
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200412static void ovl_fill_inode(struct inode *inode, umode_t mode)
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200413{
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200414 inode->i_ino = get_next_ino();
415 inode->i_mode = mode;
Miklos Szeredid719e8f2016-07-29 12:05:23 +0200416 inode->i_flags |= S_NOCMTIME;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200417
Vivek Goyal07a2daa2016-07-01 16:34:25 -0400418 mode &= S_IFMT;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200419 switch (mode) {
420 case S_IFDIR:
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200421 inode->i_op = &ovl_dir_inode_operations;
422 inode->i_fop = &ovl_dir_operations;
423 break;
424
425 case S_IFLNK:
426 inode->i_op = &ovl_symlink_inode_operations;
427 break;
428
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200429 default:
430 WARN(1, "illegal file type: %i\n", mode);
431 /* Fall through */
432
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200433 case S_IFREG:
434 case S_IFSOCK:
435 case S_IFBLK:
436 case S_IFCHR:
437 case S_IFIFO:
438 inode->i_op = &ovl_file_inode_operations;
439 break;
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200440 }
441}
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200442
Miklos Szeredi51f7e522016-07-29 12:05:24 +0200443struct inode *ovl_new_inode(struct super_block *sb, umode_t mode)
444{
445 struct inode *inode;
446
447 inode = new_inode(sb);
448 if (inode)
449 ovl_fill_inode(inode, mode);
450
451 return inode;
452}
453
454static int ovl_inode_test(struct inode *inode, void *data)
455{
456 return ovl_inode_real(inode, NULL) == data;
457}
458
459static int ovl_inode_set(struct inode *inode, void *data)
460{
461 inode->i_private = (void *) (((unsigned long) data) | OVL_ISUPPER_MASK);
462 return 0;
463}
464
465struct inode *ovl_get_inode(struct super_block *sb, struct inode *realinode)
466
467{
468 struct inode *inode;
469
470 inode = iget5_locked(sb, (unsigned long) realinode,
471 ovl_inode_test, ovl_inode_set, realinode);
472 if (inode && inode->i_state & I_NEW) {
473 ovl_fill_inode(inode, realinode->i_mode);
474 set_nlink(inode, realinode->i_nlink);
475 unlock_new_inode(inode);
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200476 }
477
478 return inode;
Miklos Szeredie9be9d52014-10-24 00:14:38 +0200479}