inode.c 9.9 KB
Newer Older
M
Miklos Szeredi 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *
 * Copyright (C) 2011 Novell Inc.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */

#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/xattr.h>
13
#include <linux/posix_acl.h>
M
Miklos Szeredi 已提交
14 15
#include "overlayfs.h"

16
static int ovl_copy_up_truncate(struct dentry *dentry)
M
Miklos Szeredi 已提交
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
{
	int err;
	struct dentry *parent;
	struct kstat stat;
	struct path lowerpath;

	parent = dget_parent(dentry);
	err = ovl_copy_up(parent);
	if (err)
		goto out_dput_parent;

	ovl_path_lower(dentry, &lowerpath);
	err = vfs_getattr(&lowerpath, &stat);
	if (err)
		goto out_dput_parent;

33 34
	stat.size = 0;
	err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat);
M
Miklos Szeredi 已提交
35 36 37 38 39 40 41 42 43 44

out_dput_parent:
	dput(parent);
	return err;
}

int ovl_setattr(struct dentry *dentry, struct iattr *attr)
{
	int err;
	struct dentry *upperdentry;
45
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
46

47 48 49 50 51 52 53 54 55 56 57 58 59
	/*
	 * Check for permissions before trying to copy-up.  This is redundant
	 * since it will be rechecked later by ->setattr() on upper dentry.  But
	 * without this, copy-up can be triggered by just about anybody.
	 *
	 * We don't initialize inode->size, which just means that
	 * inode_newsize_ok() will always check against MAX_LFS_FILESIZE and not
	 * check for a swapfile (which this won't be anyway).
	 */
	err = inode_change_ok(dentry->d_inode, attr);
	if (err)
		return err;

M
Miklos Szeredi 已提交
60 61 62 63
	err = ovl_want_write(dentry);
	if (err)
		goto out;

64 65 66 67 68 69 70 71
	if (attr->ia_valid & ATTR_SIZE) {
		struct inode *realinode = d_inode(ovl_dentry_real(dentry));

		err = -ETXTBSY;
		if (atomic_read(&realinode->i_writecount) < 0)
			goto out_drop_write;
	}

72 73
	err = ovl_copy_up(dentry);
	if (!err) {
74 75
		struct inode *winode = NULL;

76 77
		upperdentry = ovl_dentry_upper(dentry);

78 79 80 81 82 83 84
		if (attr->ia_valid & ATTR_SIZE) {
			winode = d_inode(upperdentry);
			err = get_write_access(winode);
			if (err)
				goto out_drop_write;
		}

M
Miklos Szeredi 已提交
85 86 87
		if (attr->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
			attr->ia_valid &= ~ATTR_MODE;

A
Al Viro 已提交
88
		inode_lock(upperdentry->d_inode);
89
		old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
90
		err = notify_change(upperdentry, attr, NULL);
91
		revert_creds(old_cred);
92 93
		if (!err)
			ovl_copyattr(upperdentry->d_inode, dentry->d_inode);
A
Al Viro 已提交
94
		inode_unlock(upperdentry->d_inode);
95 96 97

		if (winode)
			put_write_access(winode);
M
Miklos Szeredi 已提交
98
	}
99
out_drop_write:
M
Miklos Szeredi 已提交
100 101 102 103 104 105 106 107 108
	ovl_drop_write(dentry);
out:
	return err;
}

static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,
			 struct kstat *stat)
{
	struct path realpath;
109 110
	const struct cred *old_cred;
	int err;
M
Miklos Szeredi 已提交
111 112

	ovl_path_real(dentry, &realpath);
113 114 115 116
	old_cred = ovl_override_creds(dentry->d_sb);
	err = vfs_getattr(&realpath, stat);
	revert_creds(old_cred);
	return err;
M
Miklos Szeredi 已提交
117 118 119 120 121
}

int ovl_permission(struct inode *inode, int mask)
{
	bool is_upper;
122
	struct inode *realinode = ovl_inode_real(inode, &is_upper);
123
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
124 125 126 127 128
	int err;

	/* Careful in RCU walk mode */
	if (!realinode) {
		WARN_ON(!(mask & MAY_NOT_BLOCK));
129
		return -ECHILD;
M
Miklos Szeredi 已提交
130 131
	}

132 133 134 135 136 137 138 139 140
	/*
	 * Check overlay inode with the creds of task and underlying inode
	 * with creds of mounter
	 */
	err = generic_permission(inode, mask);
	if (err)
		return err;

	old_cred = ovl_override_creds(inode->i_sb);
141
	if (!is_upper && !special_file(realinode->i_mode) && mask & MAY_WRITE) {
142
		mask &= ~(MAY_WRITE | MAY_APPEND);
143 144 145
		/* Make sure mounter can read file for copy up later */
		mask |= MAY_READ;
	}
146
	err = inode_permission(realinode, mask);
147 148 149
	revert_creds(old_cred);

	return err;
M
Miklos Szeredi 已提交
150 151
}

152
static const char *ovl_get_link(struct dentry *dentry,
153 154
				struct inode *inode,
				struct delayed_call *done)
M
Miklos Szeredi 已提交
155 156 157
{
	struct dentry *realdentry;
	struct inode *realinode;
158 159
	const struct cred *old_cred;
	const char *p;
M
Miklos Szeredi 已提交
160

161 162 163
	if (!dentry)
		return ERR_PTR(-ECHILD);

M
Miklos Szeredi 已提交
164 165 166
	realdentry = ovl_dentry_real(dentry);
	realinode = realdentry->d_inode;

167
	if (WARN_ON(!realinode->i_op->get_link))
M
Miklos Szeredi 已提交
168 169
		return ERR_PTR(-EPERM);

170 171 172 173
	old_cred = ovl_override_creds(dentry->d_sb);
	p = realinode->i_op->get_link(realdentry, realinode, done);
	revert_creds(old_cred);
	return p;
M
Miklos Szeredi 已提交
174 175 176 177 178 179
}

static int ovl_readlink(struct dentry *dentry, char __user *buf, int bufsiz)
{
	struct path realpath;
	struct inode *realinode;
180 181
	const struct cred *old_cred;
	int err;
M
Miklos Szeredi 已提交
182 183 184 185 186 187 188

	ovl_path_real(dentry, &realpath);
	realinode = realpath.dentry->d_inode;

	if (!realinode->i_op->readlink)
		return -EINVAL;

189 190 191 192
	old_cred = ovl_override_creds(dentry->d_sb);
	err = realinode->i_op->readlink(realpath.dentry, buf, bufsiz);
	revert_creds(old_cred);
	return err;
M
Miklos Szeredi 已提交
193 194
}

M
Miklos Szeredi 已提交
195
bool ovl_is_private_xattr(const char *name)
M
Miklos Szeredi 已提交
196
{
A
Andreas Gruenbacher 已提交
197 198
	return strncmp(name, OVL_XATTR_PREFIX,
		       sizeof(OVL_XATTR_PREFIX) - 1) == 0;
M
Miklos Szeredi 已提交
199 200
}

201 202
int ovl_xattr_set(struct dentry *dentry, const char *name, const void *value,
		  size_t size, int flags)
M
Miklos Szeredi 已提交
203 204
{
	int err;
205 206
	struct path realpath;
	enum ovl_path_type type = ovl_path_real(dentry, &realpath);
207
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
208 209 210 211 212

	err = ovl_want_write(dentry);
	if (err)
		goto out;

213 214 215 216 217 218
	if (!value && !OVL_TYPE_UPPER(type)) {
		err = vfs_getxattr(realpath.dentry, name, NULL, 0);
		if (err < 0)
			goto out_drop_write;
	}

M
Miklos Szeredi 已提交
219 220 221 222
	err = ovl_copy_up(dentry);
	if (err)
		goto out_drop_write;

223 224 225
	if (!OVL_TYPE_UPPER(type))
		ovl_path_upper(dentry, &realpath);

226
	old_cred = ovl_override_creds(dentry->d_sb);
227 228 229 230 231 232
	if (value)
		err = vfs_setxattr(realpath.dentry, name, value, size, flags);
	else {
		WARN_ON(flags != XATTR_REPLACE);
		err = vfs_removexattr(realpath.dentry, name);
	}
233
	revert_creds(old_cred);
M
Miklos Szeredi 已提交
234 235 236 237 238 239 240

out_drop_write:
	ovl_drop_write(dentry);
out:
	return err;
}

241 242
int ovl_xattr_get(struct dentry *dentry, const char *name,
		  void *value, size_t size)
M
Miklos Szeredi 已提交
243
{
M
Miklos Szeredi 已提交
244
	struct dentry *realdentry = ovl_dentry_real(dentry);
245 246
	ssize_t res;
	const struct cred *old_cred;
247

248 249 250 251
	old_cred = ovl_override_creds(dentry->d_sb);
	res = vfs_getxattr(realdentry, name, value, size);
	revert_creds(old_cred);
	return res;
M
Miklos Szeredi 已提交
252 253 254 255
}

ssize_t ovl_listxattr(struct dentry *dentry, char *list, size_t size)
{
M
Miklos Szeredi 已提交
256
	struct dentry *realdentry = ovl_dentry_real(dentry);
M
Miklos Szeredi 已提交
257 258
	ssize_t res;
	int off;
259
	const struct cred *old_cred;
M
Miklos Szeredi 已提交
260

261
	old_cred = ovl_override_creds(dentry->d_sb);
M
Miklos Szeredi 已提交
262
	res = vfs_listxattr(realdentry, list, size);
263
	revert_creds(old_cred);
M
Miklos Szeredi 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
	if (res <= 0 || size == 0)
		return res;

	/* filter out private xattrs */
	for (off = 0; off < res;) {
		char *s = list + off;
		size_t slen = strlen(s) + 1;

		BUG_ON(off + slen > res);

		if (ovl_is_private_xattr(s)) {
			res -= slen;
			memmove(s, s + slen, res - off);
		} else {
			off += slen;
		}
	}

	return res;
}

285 286
struct posix_acl *ovl_get_acl(struct inode *inode, int type)
{
287
	struct inode *realinode = ovl_inode_real(inode, NULL);
288 289
	const struct cred *old_cred;
	struct posix_acl *acl;
290

291
	if (!IS_ENABLED(CONFIG_FS_POSIX_ACL) || !IS_POSIXACL(realinode))
292 293 294 295 296
		return NULL;

	if (!realinode->i_op->get_acl)
		return NULL;

297
	old_cred = ovl_override_creds(inode->i_sb);
298
	acl = get_acl(realinode, type);
299 300 301
	revert_creds(old_cred);

	return acl;
302 303
}

M
Miklos Szeredi 已提交
304 305 306
static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type,
				  struct dentry *realdentry)
{
M
Miklos Szeredi 已提交
307
	if (OVL_TYPE_UPPER(type))
M
Miklos Szeredi 已提交
308 309 310 311 312 313 314 315 316 317 318
		return false;

	if (special_file(realdentry->d_inode->i_mode))
		return false;

	if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC))
		return false;

	return true;
}

319
int ovl_open_maybe_copy_up(struct dentry *dentry, unsigned int file_flags)
M
Miklos Szeredi 已提交
320
{
321
	int err = 0;
M
Miklos Szeredi 已提交
322 323 324 325
	struct path realpath;
	enum ovl_path_type type;

	type = ovl_path_real(dentry, &realpath);
326
	if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) {
M
Miklos Szeredi 已提交
327
		err = ovl_want_write(dentry);
328 329 330 331 332 333 334
		if (!err) {
			if (file_flags & O_TRUNC)
				err = ovl_copy_up_truncate(dentry);
			else
				err = ovl_copy_up(dentry);
			ovl_drop_write(dentry);
		}
M
Miklos Szeredi 已提交
335 336
	}

337
	return err;
M
Miklos Szeredi 已提交
338 339
}

M
Miklos Szeredi 已提交
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
int ovl_update_time(struct inode *inode, struct timespec *ts, int flags)
{
	struct dentry *alias;
	struct path upperpath;

	if (!(flags & S_ATIME))
		return 0;

	alias = d_find_any_alias(inode);
	if (!alias)
		return 0;

	ovl_path_upper(alias, &upperpath);
	if (upperpath.dentry) {
		touch_atime(&upperpath);
		inode->i_atime = d_inode(upperpath.dentry)->i_atime;
	}

	dput(alias);

	return 0;
}

M
Miklos Szeredi 已提交
363 364 365 366
static const struct inode_operations ovl_file_inode_operations = {
	.setattr	= ovl_setattr,
	.permission	= ovl_permission,
	.getattr	= ovl_getattr,
M
Miklos Szeredi 已提交
367
	.setxattr	= generic_setxattr,
368
	.getxattr	= generic_getxattr,
M
Miklos Szeredi 已提交
369
	.listxattr	= ovl_listxattr,
370
	.removexattr	= generic_removexattr,
371
	.get_acl	= ovl_get_acl,
M
Miklos Szeredi 已提交
372
	.update_time	= ovl_update_time,
M
Miklos Szeredi 已提交
373 374 375 376
};

static const struct inode_operations ovl_symlink_inode_operations = {
	.setattr	= ovl_setattr,
377
	.get_link	= ovl_get_link,
M
Miklos Szeredi 已提交
378 379
	.readlink	= ovl_readlink,
	.getattr	= ovl_getattr,
M
Miklos Szeredi 已提交
380
	.setxattr	= generic_setxattr,
381
	.getxattr	= generic_getxattr,
M
Miklos Szeredi 已提交
382
	.listxattr	= ovl_listxattr,
383
	.removexattr	= generic_removexattr,
M
Miklos Szeredi 已提交
384
	.update_time	= ovl_update_time,
M
Miklos Szeredi 已提交
385 386
};

M
Miklos Szeredi 已提交
387
static void ovl_fill_inode(struct inode *inode, umode_t mode)
M
Miklos Szeredi 已提交
388 389 390
{
	inode->i_ino = get_next_ino();
	inode->i_mode = mode;
M
Miklos Szeredi 已提交
391
	inode->i_flags |= S_NOCMTIME;
392 393 394
#ifdef CONFIG_FS_POSIX_ACL
	inode->i_acl = inode->i_default_acl = ACL_DONT_CACHE;
#endif
M
Miklos Szeredi 已提交
395

396
	mode &= S_IFMT;
M
Miklos Szeredi 已提交
397 398 399 400 401 402 403 404 405 406
	switch (mode) {
	case S_IFDIR:
		inode->i_op = &ovl_dir_inode_operations;
		inode->i_fop = &ovl_dir_operations;
		break;

	case S_IFLNK:
		inode->i_op = &ovl_symlink_inode_operations;
		break;

M
Miklos Szeredi 已提交
407 408 409 410
	default:
		WARN(1, "illegal file type: %i\n", mode);
		/* Fall through */

M
Miklos Szeredi 已提交
411 412 413 414 415 416 417
	case S_IFREG:
	case S_IFSOCK:
	case S_IFBLK:
	case S_IFCHR:
	case S_IFIFO:
		inode->i_op = &ovl_file_inode_operations;
		break;
M
Miklos Szeredi 已提交
418 419
	}
}
M
Miklos Szeredi 已提交
420

M
Miklos Szeredi 已提交
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453
struct inode *ovl_new_inode(struct super_block *sb, umode_t mode)
{
	struct inode *inode;

	inode = new_inode(sb);
	if (inode)
		ovl_fill_inode(inode, mode);

	return inode;
}

static int ovl_inode_test(struct inode *inode, void *data)
{
	return ovl_inode_real(inode, NULL) == data;
}

static int ovl_inode_set(struct inode *inode, void *data)
{
	inode->i_private = (void *) (((unsigned long) data) | OVL_ISUPPER_MASK);
	return 0;
}

struct inode *ovl_get_inode(struct super_block *sb, struct inode *realinode)

{
	struct inode *inode;

	inode = iget5_locked(sb, (unsigned long) realinode,
			     ovl_inode_test, ovl_inode_set, realinode);
	if (inode && inode->i_state & I_NEW) {
		ovl_fill_inode(inode, realinode->i_mode);
		set_nlink(inode, realinode->i_nlink);
		unlock_new_inode(inode);
M
Miklos Szeredi 已提交
454 455 456 457
	}

	return inode;
}