open.c 27.3 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9
/*
 *  linux/fs/open.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/string.h>
#include <linux/mm.h>
#include <linux/file.h>
Al Viro's avatar
Al Viro committed
10
#include <linux/fdtable.h>
Linus Torvalds's avatar
Linus Torvalds committed
11
#include <linux/quotaops.h>
Robert Love's avatar
Robert Love committed
12
#include <linux/fsnotify.h>
Linus Torvalds's avatar
Linus Torvalds committed
13 14 15 16 17
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/namei.h>
#include <linux/backing-dev.h>
18
#include <linux/capability.h>
19
#include <linux/securebits.h>
Linus Torvalds's avatar
Linus Torvalds committed
20 21 22
#include <linux/security.h>
#include <linux/mount.h>
#include <linux/vfs.h>
23
#include <linux/fcntl.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25
#include <asm/uaccess.h>
#include <linux/fs.h>
26
#include <linux/personality.h>
Linus Torvalds's avatar
Linus Torvalds committed
27 28
#include <linux/pagemap.h>
#include <linux/syscalls.h>
29
#include <linux/rcupdate.h>
30
#include <linux/audit.h>
31
#include <linux/falloc.h>
32
#include <linux/fs_struct.h>
33
#include <linux/ima.h>
Linus Torvalds's avatar
Linus Torvalds committed
34

35 36
#include "internal.h"

37
int vfs_statfs(struct dentry *dentry, struct kstatfs *buf)
Linus Torvalds's avatar
Linus Torvalds committed
38 39 40
{
	int retval = -ENODEV;

41
	if (dentry) {
Linus Torvalds's avatar
Linus Torvalds committed
42
		retval = -ENOSYS;
43
		if (dentry->d_sb->s_op->statfs) {
Linus Torvalds's avatar
Linus Torvalds committed
44
			memset(buf, 0, sizeof(*buf));
45
			retval = security_sb_statfs(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
46 47
			if (retval)
				return retval;
48
			retval = dentry->d_sb->s_op->statfs(dentry, buf);
Linus Torvalds's avatar
Linus Torvalds committed
49 50 51 52 53 54 55 56 57
			if (retval == 0 && buf->f_frsize == 0)
				buf->f_frsize = buf->f_bsize;
		}
	}
	return retval;
}

EXPORT_SYMBOL(vfs_statfs);

58
static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf)
Linus Torvalds's avatar
Linus Torvalds committed
59 60 61 62
{
	struct kstatfs st;
	int retval;

63
	retval = vfs_statfs(dentry, &st);
Linus Torvalds's avatar
Linus Torvalds committed
64 65 66 67 68 69 70
	if (retval)
		return retval;

	if (sizeof(*buf) == sizeof(st))
		memcpy(buf, &st, sizeof(st));
	else {
		if (sizeof buf->f_blocks == 4) {
Jon Tollefson's avatar
Jon Tollefson committed
71 72
			if ((st.f_blocks | st.f_bfree | st.f_bavail |
			     st.f_bsize | st.f_frsize) &
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
			    0xffffffff00000000ULL)
				return -EOVERFLOW;
			/*
			 * f_files and f_ffree may be -1; it's okay to stuff
			 * that into 32 bits
			 */
			if (st.f_files != -1 &&
			    (st.f_files & 0xffffffff00000000ULL))
				return -EOVERFLOW;
			if (st.f_ffree != -1 &&
			    (st.f_ffree & 0xffffffff00000000ULL))
				return -EOVERFLOW;
		}

		buf->f_type = st.f_type;
		buf->f_bsize = st.f_bsize;
		buf->f_blocks = st.f_blocks;
		buf->f_bfree = st.f_bfree;
		buf->f_bavail = st.f_bavail;
		buf->f_files = st.f_files;
		buf->f_ffree = st.f_ffree;
		buf->f_fsid = st.f_fsid;
		buf->f_namelen = st.f_namelen;
		buf->f_frsize = st.f_frsize;
		memset(buf->f_spare, 0, sizeof(buf->f_spare));
	}
	return 0;
}

102
static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf)
Linus Torvalds's avatar
Linus Torvalds committed
103 104 105 106
{
	struct kstatfs st;
	int retval;

107
	retval = vfs_statfs(dentry, &st);
Linus Torvalds's avatar
Linus Torvalds committed
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	if (retval)
		return retval;

	if (sizeof(*buf) == sizeof(st))
		memcpy(buf, &st, sizeof(st));
	else {
		buf->f_type = st.f_type;
		buf->f_bsize = st.f_bsize;
		buf->f_blocks = st.f_blocks;
		buf->f_bfree = st.f_bfree;
		buf->f_bavail = st.f_bavail;
		buf->f_files = st.f_files;
		buf->f_ffree = st.f_ffree;
		buf->f_fsid = st.f_fsid;
		buf->f_namelen = st.f_namelen;
		buf->f_frsize = st.f_frsize;
		memset(buf->f_spare, 0, sizeof(buf->f_spare));
	}
	return 0;
}

129
SYSCALL_DEFINE2(statfs, const char __user *, pathname, struct statfs __user *, buf)
Linus Torvalds's avatar
Linus Torvalds committed
130
{
131
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
132 133
	int error;

134
	error = user_path(pathname, &path);
Linus Torvalds's avatar
Linus Torvalds committed
135 136
	if (!error) {
		struct statfs tmp;
137
		error = vfs_statfs_native(path.dentry, &tmp);
Linus Torvalds's avatar
Linus Torvalds committed
138 139
		if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
			error = -EFAULT;
140
		path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
141 142 143 144
	}
	return error;
}

145
SYSCALL_DEFINE3(statfs64, const char __user *, pathname, size_t, sz, struct statfs64 __user *, buf)
Linus Torvalds's avatar
Linus Torvalds committed
146
{
147
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
148 149 150 151
	long error;

	if (sz != sizeof(*buf))
		return -EINVAL;
152
	error = user_path(pathname, &path);
Linus Torvalds's avatar
Linus Torvalds committed
153 154
	if (!error) {
		struct statfs64 tmp;
155
		error = vfs_statfs64(path.dentry, &tmp);
Linus Torvalds's avatar
Linus Torvalds committed
156 157
		if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
			error = -EFAULT;
158
		path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161 162
	}
	return error;
}

163
SYSCALL_DEFINE2(fstatfs, unsigned int, fd, struct statfs __user *, buf)
Linus Torvalds's avatar
Linus Torvalds committed
164 165 166 167 168 169 170 171 172
{
	struct file * file;
	struct statfs tmp;
	int error;

	error = -EBADF;
	file = fget(fd);
	if (!file)
		goto out;
173
	error = vfs_statfs_native(file->f_path.dentry, &tmp);
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176 177 178 179 180
	if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
		error = -EFAULT;
	fput(file);
out:
	return error;
}

181
SYSCALL_DEFINE3(fstatfs64, unsigned int, fd, size_t, sz, struct statfs64 __user *, buf)
Linus Torvalds's avatar
Linus Torvalds committed
182 183 184 185 186 187 188 189 190 191 192 193
{
	struct file * file;
	struct statfs64 tmp;
	int error;

	if (sz != sizeof(*buf))
		return -EINVAL;

	error = -EBADF;
	file = fget(fd);
	if (!file)
		goto out;
194
	error = vfs_statfs64(file->f_path.dentry, &tmp);
Linus Torvalds's avatar
Linus Torvalds committed
195 196 197 198 199 200 201
	if (!error && copy_to_user(buf, &tmp, sizeof(tmp)))
		error = -EFAULT;
	fput(file);
out:
	return error;
}

202 203
int do_truncate(struct dentry *dentry, loff_t length, unsigned int time_attrs,
	struct file *filp)
Linus Torvalds's avatar
Linus Torvalds committed
204
{
205
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
206 207 208 209 210 211 212
	struct iattr newattrs;

	/* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
	if (length < 0)
		return -EINVAL;

	newattrs.ia_size = length;
213
	newattrs.ia_valid = ATTR_SIZE | time_attrs;
214 215 216 217
	if (filp) {
		newattrs.ia_file = filp;
		newattrs.ia_valid |= ATTR_FILE;
	}
Linus Torvalds's avatar
Linus Torvalds committed
218

219
	/* Remove suid/sgid on truncate too */
220 221 222
	ret = should_remove_suid(dentry);
	if (ret)
		newattrs.ia_valid |= ret | ATTR_FORCE;
223

224
	mutex_lock(&dentry->d_inode->i_mutex);
225
	ret = notify_change(dentry, &newattrs);
226
	mutex_unlock(&dentry->d_inode->i_mutex);
227
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
228 229
}

230
static long do_sys_truncate(const char __user *pathname, loff_t length)
Linus Torvalds's avatar
Linus Torvalds committed
231
{
232 233
	struct path path;
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236 237 238 239
	int error;

	error = -EINVAL;
	if (length < 0)	/* sorry, but loff_t says... */
		goto out;

240
	error = user_path(pathname, &path);
Linus Torvalds's avatar
Linus Torvalds committed
241 242
	if (error)
		goto out;
243
	inode = path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
244 245 246 247 248 249 250 251 252 253

	/* For directories it's -EISDIR, for other non-regulars - -EINVAL */
	error = -EISDIR;
	if (S_ISDIR(inode->i_mode))
		goto dput_and_out;

	error = -EINVAL;
	if (!S_ISREG(inode->i_mode))
		goto dput_and_out;

254
	error = mnt_want_write(path.mnt);
Linus Torvalds's avatar
Linus Torvalds committed
255 256 257
	if (error)
		goto dput_and_out;

258
	error = inode_permission(inode, MAY_WRITE);
259 260
	if (error)
		goto mnt_drop_write_and_out;
Linus Torvalds's avatar
Linus Torvalds committed
261 262

	error = -EPERM;
263
	if (IS_APPEND(inode))
264
		goto mnt_drop_write_and_out;
Linus Torvalds's avatar
Linus Torvalds committed
265

266
	error = get_write_access(inode);
Linus Torvalds's avatar
Linus Torvalds committed
267
	if (error)
268
		goto mnt_drop_write_and_out;
Linus Torvalds's avatar
Linus Torvalds committed
269

270 271 272 273 274
	/*
	 * Make sure that there are no leases.  get_write_access() protects
	 * against the truncate racing with a lease-granting setlease().
	 */
	error = break_lease(inode, FMODE_WRITE);
Linus Torvalds's avatar
Linus Torvalds committed
275
	if (error)
276
		goto put_write_and_out;
Linus Torvalds's avatar
Linus Torvalds committed
277 278

	error = locks_verify_truncate(inode, NULL, length);
279 280
	if (!error)
		error = security_path_truncate(&path, length, 0);
Linus Torvalds's avatar
Linus Torvalds committed
281
	if (!error) {
282
		vfs_dq_init(inode);
283
		error = do_truncate(path.dentry, length, 0, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
284 285
	}

286 287
put_write_and_out:
	put_write_access(inode);
288
mnt_drop_write_and_out:
289
	mnt_drop_write(path.mnt);
Linus Torvalds's avatar
Linus Torvalds committed
290
dput_and_out:
291
	path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295
out:
	return error;
}

296
SYSCALL_DEFINE2(truncate, const char __user *, path, long, length)
Linus Torvalds's avatar
Linus Torvalds committed
297
{
298
	return do_sys_truncate(path, length);
Linus Torvalds's avatar
Linus Torvalds committed
299 300
}

301
static long do_sys_ftruncate(unsigned int fd, loff_t length, int small)
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
{
	struct inode * inode;
	struct dentry *dentry;
	struct file * file;
	int error;

	error = -EINVAL;
	if (length < 0)
		goto out;
	error = -EBADF;
	file = fget(fd);
	if (!file)
		goto out;

	/* explicitly opened as large or we are on 64-bit box */
	if (file->f_flags & O_LARGEFILE)
		small = 0;

320
	dentry = file->f_path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
	inode = dentry->d_inode;
	error = -EINVAL;
	if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
		goto out_putf;

	error = -EINVAL;
	/* Cannot ftruncate over 2^31 bytes without large file support */
	if (small && length > MAX_NON_LFS)
		goto out_putf;

	error = -EPERM;
	if (IS_APPEND(inode))
		goto out_putf;

	error = locks_verify_truncate(inode, file, length);
336 337 338
	if (!error)
		error = security_path_truncate(&file->f_path, length,
					       ATTR_MTIME|ATTR_CTIME);
Linus Torvalds's avatar
Linus Torvalds committed
339
	if (!error)
340
		error = do_truncate(dentry, length, ATTR_MTIME|ATTR_CTIME, file);
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344 345 346
out_putf:
	fput(file);
out:
	return error;
}

347
SYSCALL_DEFINE2(ftruncate, unsigned int, fd, unsigned long, length)
Linus Torvalds's avatar
Linus Torvalds committed
348
{
349
	long ret = do_sys_ftruncate(fd, length, 1);
350
	/* avoid REGPARM breakage on x86: */
351
	asmlinkage_protect(2, ret, fd, length);
352
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
353 354 355 356
}

/* LFS versions of truncate are only needed on 32 bit machines */
#if BITS_PER_LONG == 32
357
SYSCALL_DEFINE(truncate64)(const char __user * path, loff_t length)
Linus Torvalds's avatar
Linus Torvalds committed
358 359 360
{
	return do_sys_truncate(path, length);
}
361 362 363 364 365 366 367
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
asmlinkage long SyS_truncate64(long path, loff_t length)
{
	return SYSC_truncate64((const char __user *) path, length);
}
SYSCALL_ALIAS(sys_truncate64, SyS_truncate64);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
368

369
SYSCALL_DEFINE(ftruncate64)(unsigned int fd, loff_t length)
Linus Torvalds's avatar
Linus Torvalds committed
370
{
371
	long ret = do_sys_ftruncate(fd, length, 0);
372
	/* avoid REGPARM breakage on x86: */
373
	asmlinkage_protect(2, ret, fd, length);
374
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
375
}
376 377 378 379 380 381
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
asmlinkage long SyS_ftruncate64(long fd, loff_t length)
{
	return SYSC_ftruncate64((unsigned int) fd, length);
}
SYSCALL_ALIAS(sys_ftruncate64, SyS_ftruncate64);
Linus Torvalds's avatar
Linus Torvalds committed
382
#endif
383
#endif /* BITS_PER_LONG == 32 */
Linus Torvalds's avatar
Linus Torvalds committed
384

385 386

int do_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
387
{
388 389
	struct inode *inode = file->f_path.dentry->d_inode;
	long ret;
390 391

	if (offset < 0 || len <= 0)
392
		return -EINVAL;
393 394 395

	/* Return error if mode is not supported */
	if (mode && !(mode & FALLOC_FL_KEEP_SIZE))
396
		return -EOPNOTSUPP;
397 398

	if (!(file->f_mode & FMODE_WRITE))
399
		return -EBADF;
400 401 402 403 404 405
	/*
	 * Revalidate the write permissions, in case security policy has
	 * changed since the files were opened.
	 */
	ret = security_file_permission(file, MAY_WRITE);
	if (ret)
406
		return ret;
407 408

	if (S_ISFIFO(inode->i_mode))
409
		return -ESPIPE;
410 411 412 413 414 415

	/*
	 * Let individual file system decide if it supports preallocation
	 * for directories or not.
	 */
	if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
416
		return -ENODEV;
417 418 419

	/* Check for wrap through zero too */
	if (((offset + len) > inode->i_sb->s_maxbytes) || ((offset + len) < 0))
420
		return -EFBIG;
421

422 423
	if (!inode->i_op->fallocate)
		return -EOPNOTSUPP;
424

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
	return inode->i_op->fallocate(inode, mode, offset, len);
}

SYSCALL_DEFINE(fallocate)(int fd, int mode, loff_t offset, loff_t len)
{
	struct file *file;
	int error = -EBADF;

	file = fget(fd);
	if (file) {
		error = do_fallocate(file, mode, offset, len);
		fput(file);
	}

	return error;
440
}
441

442 443 444 445 446 447 448
#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
asmlinkage long SyS_fallocate(long fd, long mode, loff_t offset, loff_t len)
{
	return SYSC_fallocate((int)fd, (int)mode, offset, len);
}
SYSCALL_ALIAS(sys_fallocate, SyS_fallocate);
#endif
449

Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453 454
/*
 * access() needs to use the real uid/gid, not the effective uid/gid.
 * We do this by temporarily clearing all FS-related capabilities and
 * switching the fsuid/fsgid around to the real ones.
 */
455
SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode)
Linus Torvalds's avatar
Linus Torvalds committed
456
{
457 458
	const struct cred *old_cred;
	struct cred *override_cred;
459
	struct path path;
460
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
461 462 463 464 465
	int res;

	if (mode & ~S_IRWXO)	/* where's F_OK, X_OK, W_OK, R_OK? */
		return -EINVAL;

466 467 468
	override_cred = prepare_creds();
	if (!override_cred)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
469

470 471
	override_cred->fsuid = override_cred->uid;
	override_cred->fsgid = override_cred->gid;
Linus Torvalds's avatar
Linus Torvalds committed
472

473
	if (!issecure(SECURE_NO_SETUID_FIXUP)) {
David Howells's avatar
David Howells committed
474
		/* Clear the capabilities if we switch to a non-root user */
475 476
		if (override_cred->uid)
			cap_clear(override_cred->cap_effective);
477
		else
478 479
			override_cred->cap_effective =
				override_cred->cap_permitted;
480
	}
Linus Torvalds's avatar
Linus Torvalds committed
481

482 483
	old_cred = override_creds(override_cred);

484
	res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
485 486 487
	if (res)
		goto out;

488
	inode = path.dentry->d_inode;
489 490

	if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {
491 492 493 494 495
		/*
		 * MAY_EXEC on regular files is denied if the fs is mounted
		 * with the "noexec" flag.
		 */
		res = -EACCES;
496
		if (path.mnt->mnt_flags & MNT_NOEXEC)
497 498 499
			goto out_path_release;
	}

500
	res = inode_permission(inode, mode | MAY_ACCESS);
501
	/* SuS v2 requires we report a read only fs too */
502
	if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))
503
		goto out_path_release;
504 505 506 507 508 509 510 511 512 513
	/*
	 * This is a rare case where using __mnt_is_readonly()
	 * is OK without a mnt_want/drop_write() pair.  Since
	 * no actual write to the fs is performed here, we do
	 * not need to telegraph to that to anyone.
	 *
	 * By doing this, we accept that this access is
	 * inherently racy and know that the fs may change
	 * state before we even see this result.
	 */
514
	if (__mnt_is_readonly(path.mnt))
515
		res = -EROFS;
Linus Torvalds's avatar
Linus Torvalds committed
516

517
out_path_release:
518
	path_put(&path);
519
out:
520 521
	revert_creds(old_cred);
	put_cred(override_cred);
Linus Torvalds's avatar
Linus Torvalds committed
522 523 524
	return res;
}

525
SYSCALL_DEFINE2(access, const char __user *, filename, int, mode)
526 527 528 529
{
	return sys_faccessat(AT_FDCWD, filename, mode);
}

530
SYSCALL_DEFINE1(chdir, const char __user *, filename)
Linus Torvalds's avatar
Linus Torvalds committed
531
{
532
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
533 534
	int error;

535
	error = user_path_dir(filename, &path);
Linus Torvalds's avatar
Linus Torvalds committed
536 537 538
	if (error)
		goto out;

539
	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds's avatar
Linus Torvalds committed
540 541 542
	if (error)
		goto dput_and_out;

543
	set_fs_pwd(current->fs, &path);
Linus Torvalds's avatar
Linus Torvalds committed
544 545

dput_and_out:
546
	path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
547 548 549 550
out:
	return error;
}

551
SYSCALL_DEFINE1(fchdir, unsigned int, fd)
Linus Torvalds's avatar
Linus Torvalds committed
552 553 554 555 556 557 558 559 560 561
{
	struct file *file;
	struct inode *inode;
	int error;

	error = -EBADF;
	file = fget(fd);
	if (!file)
		goto out;

562
	inode = file->f_path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
563 564 565 566 567

	error = -ENOTDIR;
	if (!S_ISDIR(inode->i_mode))
		goto out_putf;

568
	error = inode_permission(inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds's avatar
Linus Torvalds committed
569
	if (!error)
570
		set_fs_pwd(current->fs, &file->f_path);
Linus Torvalds's avatar
Linus Torvalds committed
571 572 573 574 575 576
out_putf:
	fput(file);
out:
	return error;
}

577
SYSCALL_DEFINE1(chroot, const char __user *, filename)
Linus Torvalds's avatar
Linus Torvalds committed
578
{
579
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
580 581
	int error;

582
	error = user_path_dir(filename, &path);
Linus Torvalds's avatar
Linus Torvalds committed
583 584 585
	if (error)
		goto out;

586
	error = inode_permission(path.dentry->d_inode, MAY_EXEC | MAY_ACCESS);
Linus Torvalds's avatar
Linus Torvalds committed
587 588 589 590 591 592
	if (error)
		goto dput_and_out;

	error = -EPERM;
	if (!capable(CAP_SYS_CHROOT))
		goto dput_and_out;
593 594 595
	error = security_path_chroot(&path);
	if (error)
		goto dput_and_out;
Linus Torvalds's avatar
Linus Torvalds committed
596

597
	set_fs_root(current->fs, &path);
Linus Torvalds's avatar
Linus Torvalds committed
598 599
	error = 0;
dput_and_out:
600
	path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
601 602 603 604
out:
	return error;
}

605
SYSCALL_DEFINE2(fchmod, unsigned int, fd, mode_t, mode)
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611 612 613 614 615 616
{
	struct inode * inode;
	struct dentry * dentry;
	struct file * file;
	int err = -EBADF;
	struct iattr newattrs;

	file = fget(fd);
	if (!file)
		goto out;

617
	dentry = file->f_path.dentry;
Linus Torvalds's avatar
Linus Torvalds committed
618 619
	inode = dentry->d_inode;

620
	audit_inode(NULL, dentry);
621

622
	err = mnt_want_write_file(file);
623
	if (err)
Linus Torvalds's avatar
Linus Torvalds committed
624
		goto out_putf;
625
	mutex_lock(&inode->i_mutex);
626 627
	err = security_path_chmod(dentry, file->f_vfsmnt, mode);
	if (err)
628
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
629 630 631 632 633
	if (mode == (mode_t) -1)
		mode = inode->i_mode;
	newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
	newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
	err = notify_change(dentry, &newattrs);
634
out_unlock:
635
	mutex_unlock(&inode->i_mutex);
636
	mnt_drop_write(file->f_path.mnt);
Linus Torvalds's avatar
Linus Torvalds committed
637 638 639 640 641 642
out_putf:
	fput(file);
out:
	return err;
}

643
SYSCALL_DEFINE3(fchmodat, int, dfd, const char __user *, filename, mode_t, mode)
Linus Torvalds's avatar
Linus Torvalds committed
644
{
645 646
	struct path path;
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
647 648 649
	int error;
	struct iattr newattrs;

650
	error = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);
Linus Torvalds's avatar
Linus Torvalds committed
651 652
	if (error)
		goto out;
653
	inode = path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
654

655
	error = mnt_want_write(path.mnt);
656
	if (error)
Linus Torvalds's avatar
Linus Torvalds committed
657
		goto dput_and_out;
658
	mutex_lock(&inode->i_mutex);
659 660
	error = security_path_chmod(path.dentry, path.mnt, mode);
	if (error)
661
		goto out_unlock;
Linus Torvalds's avatar
Linus Torvalds committed
662 663 664 665
	if (mode == (mode_t) -1)
		mode = inode->i_mode;
	newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
	newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
666
	error = notify_change(path.dentry, &newattrs);
667
out_unlock:
668
	mutex_unlock(&inode->i_mutex);
669
	mnt_drop_write(path.mnt);
Linus Torvalds's avatar
Linus Torvalds committed
670
dput_and_out:
671
	path_put(&path);
Linus Torvalds's avatar
Linus Torvalds committed
672 673 674 675
out:
	return error;
}

676
SYSCALL_DEFINE2(chmod, const char __user *, filename, mode_t, mode)
677 678 679 680
{
	return sys_fchmodat(AT_FDCWD, filename, mode);
}

681
static int chown_common(struct path *path, uid_t user, gid_t group)
Linus Torvalds's avatar
Linus Torvalds committed
682
{
683
	struct inode *inode = path->dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
684 685 686 687 688 689 690 691 692 693 694 695 696
	int error;
	struct iattr newattrs;

	newattrs.ia_valid =  ATTR_CTIME;
	if (user != (uid_t) -1) {
		newattrs.ia_valid |= ATTR_UID;
		newattrs.ia_uid = user;
	}
	if (group != (gid_t) -1) {
		newattrs.ia_valid |= ATTR_GID;
		newattrs.ia_gid = group;
	}
	if (!S_ISDIR(inode->i_mode))
697 698
		newattrs.ia_valid |=
			ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
699
	mutex_lock(&inode->i_mutex);
700 701 702
	error = security_path_chown(path, user, group);
	if (!error)
		error = notify_change(path->dentry, &newattrs);
703
	mutex_unlock(&inode->i_mutex);
704

Linus Torvalds's avatar
Linus Torvalds committed
705 706 707
	return error;
}

708
SYSCALL_DEFINE3(chown, const char __user *, filename, uid_t, user, gid_t, group)
Linus Torvalds's avatar
Linus Torvalds committed
709
{
710
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
711 712
	int error;

713
	error = user_path(filename, &path);
714 715
	if (error)
		goto out;
716
	error = mnt_want_write(path.mnt);
717 718
	if (error)
		goto out_release;
719
	error = chown_common(&path, user, group);
720
	mnt_drop_write(path.mnt);
721
out_release:
722
	path_put(&path);
723
out:
Linus Torvalds's avatar
Linus Torvalds committed
724 725 726
	return error;
}

727 728
SYSCALL_DEFINE5(fchownat, int, dfd, const char __user *, filename, uid_t, user,
		gid_t, group, int, flag)
729
{
730
	struct path path;
731 732 733 734 735 736 737
	int error = -EINVAL;
	int follow;

	if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0)
		goto out;

	follow = (flag & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW;
738
	error = user_path_at(dfd, filename, follow, &path);
739 740
	if (error)
		goto out;
741
	error = mnt_want_write(path.mnt);
742 743
	if (error)
		goto out_release;
744
	error = chown_common(&path, user, group);
745
	mnt_drop_write(path.mnt);
746
out_release:
747
	path_put(&path);
748 749 750 751
out:
	return error;
}

752
SYSCALL_DEFINE3(lchown, const char __user *, filename, uid_t, user, gid_t, group)
Linus Torvalds's avatar
Linus Torvalds committed
753
{
754
	struct path path;
Linus Torvalds's avatar
Linus Torvalds committed
755 756
	int error;

757
	error = user_lpath(filename, &path);
758 759
	if (error)
		goto out;
760
	error = mnt_want_write(path.mnt);
761 762
	if (error)
		goto out_release;
763
	error = chown_common(&path, user, group);
764
	mnt_drop_write(path.mnt);
765
out_release:
766
	path_put(&path);
767
out:
Linus Torvalds's avatar
Linus Torvalds committed
768 769 770
	return error;
}

771
SYSCALL_DEFINE3(fchown, unsigned int, fd, uid_t, user, gid_t, group)
Linus Torvalds's avatar
Linus Torvalds committed
772 773 774
{
	struct file * file;
	int error = -EBADF;
775
	struct dentry * dentry;
Linus Torvalds's avatar
Linus Torvalds committed
776 777

	file = fget(fd);
778 779 780
	if (!file)
		goto out;

781
	error = mnt_want_write_file(file);
782 783
	if (error)
		goto out_fput;
784
	dentry = file->f_path.dentry;
785
	audit_inode(NULL, dentry);
786
	error = chown_common(&file->f_path, user, group);
787 788
	mnt_drop_write(file->f_path.mnt);
out_fput:
789 790
	fput(file);
out:
Linus Torvalds's avatar
Linus Torvalds committed
791 792 793
	return error;
}

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822
/*
 * You have to be very careful that these write
 * counts get cleaned up in error cases and
 * upon __fput().  This should probably never
 * be called outside of __dentry_open().
 */
static inline int __get_file_write_access(struct inode *inode,
					  struct vfsmount *mnt)
{
	int error;
	error = get_write_access(inode);
	if (error)
		return error;
	/*
	 * Do not take mount writer counts on
	 * special files since no writes to
	 * the mount itself will occur.
	 */
	if (!special_file(inode->i_mode)) {
		/*
		 * Balanced in __fput()
		 */
		error = mnt_want_write(mnt);
		if (error)
			put_write_access(inode);
	}
	return error;
}

823
static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,
824
					struct file *f,
825 826
					int (*open)(struct inode *, struct file *),
					const struct cred *cred)
Linus Torvalds's avatar
Linus Torvalds committed
827 828 829 830
{
	struct inode *inode;
	int error;

Al Viro's avatar
Al Viro committed
831
	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |
832
				FMODE_PREAD | FMODE_PWRITE;
Linus Torvalds's avatar
Linus Torvalds committed
833 834
	inode = dentry->d_inode;
	if (f->f_mode & FMODE_WRITE) {
835
		error = __get_file_write_access(inode, mnt);
Linus Torvalds's avatar
Linus Torvalds committed
836 837
		if (error)
			goto cleanup_file;
838 839
		if (!special_file(inode->i_mode))
			file_take_write(f);
Linus Torvalds's avatar
Linus Torvalds committed
840 841 842
	}

	f->f_mapping = inode->i_mapping;
843 844
	f->f_path.dentry = dentry;
	f->f_path.mnt = mnt;
Linus Torvalds's avatar
Linus Torvalds committed
845 846 847 848
	f->f_pos = 0;
	f->f_op = fops_get(inode->i_fop);
	file_move(f, &inode->i_sb->s_files);

849
	error = security_dentry_open(f, cred);
850 851 852
	if (error)
		goto cleanup_all;

853 854 855 856
	if (!open && f->f_op)
		open = f->f_op->open;
	if (open) {
		error = open(inode, f);
Linus Torvalds's avatar
Linus Torvalds committed
857 858 859
		if (error)
			goto cleanup_all;
	}
860
	ima_counts_get(f);
861

Linus Torvalds's avatar
Linus Torvalds committed
862 863 864 865 866 867
	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);

	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);

	/* NB: we're sure to have correct a_ops only after f_op->open */
	if (f->f_flags & O_DIRECT) {
868 869
		if (!f->f_mapping->a_ops ||
		    ((!f->f_mapping->a_ops->direct_IO) &&
870
		    (!f->f_mapping->a_ops->get_xip_mem))) {
Linus Torvalds's avatar
Linus Torvalds committed
871 872 873 874 875 876 877 878 879
			fput(f);
			f = ERR_PTR(-EINVAL);
		}
	}

	return f;

cleanup_all:
	fops_put(f->f_op);
880
	if (f->f_mode & FMODE_WRITE) {
Linus Torvalds's avatar
Linus Torvalds committed
881
		put_write_access(inode);
882 883 884 885 886 887 888 889
		if (!special_file(inode->i_mode)) {
			/*
			 * We don't consider this a real
			 * mnt_want/drop_write() pair
			 * because it all happenend right
			 * here, so just reset the state.
			 */
			file_reset_write(f);
890
			mnt_drop_write(mnt);
891
		}
892
	}
Linus Torvalds's avatar
Linus Torvalds committed
893
	file_kill(f);
894 895
	f->f_path.dentry = NULL;
	f->f_path.mnt = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
896 897 898 899 900 901 902
cleanup_file:
	put_filp(f);
	dput(dentry);
	mntput(mnt);
	return ERR_PTR(error);
}

903 904 905 906 907 908 909 910 911 912
/**
 * lookup_instantiate_filp - instantiates the open intent filp
 * @nd: pointer to nameidata
 * @dentry: pointer to dentry
 * @open: open callback
 *
 * Helper for filesystems that want to use lookup open intents and pass back
 * a fully instantiated struct file to the caller.
 * This function is meant to be called from within a filesystem's
 * lookup method.
913 914 915 916
 * Beware of calling it for non-regular files! Those ->open methods might block
 * (e.g. in fifo_open), leaving you with parent locked (and in case of fifo,
 * leading to a deadlock, as nobody can open that fifo anymore, because
 * another process to open fifo will block on locked parent when doing lookup).
917 918 919 920 921 922 923 924
 * Note that in case of error, nd->intent.open.file is destroyed, but the
 * path information remains valid.
 * If the open callback is set to NULL, then the standard f_op->open()
 * filesystem callback is substituted.
 */
struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
		int (*open)(struct inode *, struct file *))
{
925 926
	const struct cred *cred = current_cred();

927 928 929 930
	if (IS_ERR(nd->intent.open.file))
		goto out;
	if (IS_ERR(dentry))
		goto out_err;
931
	nd->intent.open.file = __dentry_open(dget(dentry), mntget(nd->path.mnt),
932
					     nd->intent.open.file,
933
					     open, cred);
934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
out:
	return nd->intent.open.file;
out_err:
	release_open_intent(nd);
	nd->intent.open.file = (struct file *)dentry;
	goto out;
}
EXPORT_SYMBOL_GPL(lookup_instantiate_filp);

/**
 * nameidata_to_filp - convert a nameidata to an open filp.
 * @nd: pointer to nameidata
 * @flags: open flags
 *
 * Note that this function destroys the original nameidata
 */
950
struct file *nameidata_to_filp(struct nameidata *nd)
951
{
952
	const struct cred *cred = current_cred();
953 954 955 956 957
	struct file *filp;

	/* Pick up the filp from the open intent */
	filp = nd->intent.open.file;
	/* Has the filesystem initialised the file for us? */
958
	if (filp->f_path.dentry == NULL)
959
		filp = __dentry_open(nd->path.dentry, nd->path.mnt, filp,
960
				     NULL, cred);
961
	else
Jan Blunck's avatar
Jan Blunck committed
962
		path_put(&nd->path);
963 964 965
	return filp;
}

966 967 968 969
/*
 * dentry_open() will have done dput(dentry) and mntput(mnt) if it returns an
 * error.
 */
970 971
struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags,
			 const struct cred *cred)
972 973 974 975
{
	int error;
	struct file *f;

976 977
	validate_creds(cred);

978 979 980 981 982 983 984 985 986 987 988 989
	/*
	 * We must always pass in a valid mount pointer.   Historically
	 * callers got away with not passing it, but we must enforce this at
	 * the earliest possible point now to avoid strange problems deep in the
	 * filesystem stack.
	 */
	if (!mnt) {
		printk(KERN_WARNING "%s called with NULL vfsmount\n", __func__);
		dump_stack();
		return ERR_PTR(-EINVAL);
	}

990 991
	error = -ENFILE;
	f = get_empty_filp();
992 993 994
	if (f == NULL) {
		dput(dentry);
		mntput(mnt);
995
		return ERR_PTR(error);
996
	}
997

998 999
	f->f_flags = flags;
	return __dentry_open(dentry, mnt, f, NULL, cred);
1000
}
Linus Torvalds's avatar
Linus Torvalds committed
1001 1002
EXPORT_SYMBOL(dentry_open);

1003
static void __put_unused_fd(struct files_struct *files, unsigned int fd)
Linus Torvalds's avatar
Linus Torvalds committed
1004
{
1005 1006
	struct fdtable *fdt = files_fdtable(files);
	__FD_CLR(fd, fdt->open_fds);
1007 1008
	if (fd < files->next_fd)
		files->next_fd = fd;
Linus Torvalds's avatar
Linus Torvalds committed
1009 1010
}

1011
void put_unused_fd(unsigned int fd)
Linus Torvalds's avatar
Linus Torvalds committed
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021
{
	struct files_struct *files = current->files;
	spin_lock(&files->file_lock);
	__put_unused_fd(files, fd);
	spin_unlock(&files->file_lock);
}

EXPORT_SYMBOL(put_unused_fd);

/*
1022
 * Install a file pointer in the fd array.
Linus Torvalds's avatar
Linus Torvalds committed
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
 *
 * The VFS is full of places where we drop the files lock between
 * setting the open_fds bitmap and installing the file in the file
 * array.  At any such point, we are vulnerable to a dup2() race
 * installing a file in the array before us.  We need to detect this and
 * fput() the struct file we are about to overwrite in this case.
 *
 * It should never happen - if we allow dup2() do it, _really_ bad things
 * will follow.
 */

1034
void fd_install(unsigned int fd, struct file *file)