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

#include <linux/syscalls.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/file.h>
Al Viro's avatar
Al Viro committed
12
#include <linux/fdtable.h>
13
#include <linux/capability.h>
Linus Torvalds's avatar
Linus Torvalds committed
14 15 16
#include <linux/dnotify.h>
#include <linux/slab.h>
#include <linux/module.h>
17
#include <linux/pipe_fs_i.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19
#include <linux/security.h>
#include <linux/ptrace.h>
20
#include <linux/signal.h>
21
#include <linux/rcupdate.h>
22
#include <linux/pid_namespace.h>
23
#include <linux/user_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26 27 28

#include <asm/poll.h>
#include <asm/siginfo.h>
#include <asm/uaccess.h>

29
void set_close_on_exec(unsigned int fd, int flag)
Linus Torvalds's avatar
Linus Torvalds committed
30 31
{
	struct files_struct *files = current->files;
32
	struct fdtable *fdt;
Linus Torvalds's avatar
Linus Torvalds committed
33
	spin_lock(&files->file_lock);
34
	fdt = files_fdtable(files);
Linus Torvalds's avatar
Linus Torvalds committed
35
	if (flag)
36
		__set_close_on_exec(fd, fdt);
Linus Torvalds's avatar
Linus Torvalds committed
37
	else
38
		__clear_close_on_exec(fd, fdt);
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41
	spin_unlock(&files->file_lock);
}

42
static bool get_close_on_exec(unsigned int fd)
Linus Torvalds's avatar
Linus Torvalds committed
43 44
{
	struct files_struct *files = current->files;
45
	struct fdtable *fdt;
46
	bool res;
47
	rcu_read_lock();
48
	fdt = files_fdtable(files);
49
	res = close_on_exec(fd, fdt);
50
	rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
51 52 53
	return res;
}

54
SYSCALL_DEFINE3(dup3, unsigned int, oldfd, unsigned int, newfd, int, flags)
Linus Torvalds's avatar
Linus Torvalds committed
55 56 57 58
{
	int err = -EBADF;
	struct file * file, *tofree;
	struct files_struct * files = current->files;
59
	struct fdtable *fdt;
Linus Torvalds's avatar
Linus Torvalds committed
60

Ulrich Drepper's avatar
Ulrich Drepper committed
61 62 63
	if ((flags & ~O_CLOEXEC) != 0)
		return -EINVAL;

64 65
	if (unlikely(oldfd == newfd))
		return -EINVAL;
66 67 68

	if (newfd >= rlimit(RLIMIT_NOFILE))
		return -EMFILE;
69

Linus Torvalds's avatar
Linus Torvalds committed
70 71
	spin_lock(&files->file_lock);
	err = expand_files(files, newfd);
Al Viro's avatar
Al Viro committed
72 73 74
	file = fcheck(oldfd);
	if (unlikely(!file))
		goto Ebadf;
Al Viro's avatar
Al Viro committed
75 76
	if (unlikely(err < 0)) {
		if (err == -EMFILE)
Al Viro's avatar
Al Viro committed
77 78
			goto Ebadf;
		goto out_unlock;
Al Viro's avatar
Al Viro committed
79
	}
Al Viro's avatar
Al Viro committed
80 81 82 83 84 85 86 87 88 89 90 91 92 93
	/*
	 * We need to detect attempts to do dup2() over allocated but still
	 * not finished descriptor.  NB: OpenBSD avoids that at the price of
	 * extra work in their equivalent of fget() - they insert struct
	 * file immediately after grabbing descriptor, mark it larval if
	 * more work (e.g. actual opening) is needed and make sure that
	 * fget() treats larval files as absent.  Potentially interesting,
	 * but while extra work in fget() is trivial, locking implications
	 * and amount of surgery on open()-related paths in VFS are not.
	 * FreeBSD fails with -EBADF in the same situation, NetBSD "solution"
	 * deadlocks in rather amusing ways, AFAICS.  All of that is out of
	 * scope of POSIX or SUS, since neither considers shared descriptor
	 * tables and this condition does not arise without those.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
94
	err = -EBUSY;
95 96
	fdt = files_fdtable(files);
	tofree = fdt->fd[newfd];
97
	if (!tofree && fd_is_open(newfd, fdt))
Al Viro's avatar
Al Viro committed
98 99
		goto out_unlock;
	get_file(file);
100
	rcu_assign_pointer(fdt->fd[newfd], file);
101
	__set_open_fd(newfd, fdt);
Ulrich Drepper's avatar
Ulrich Drepper committed
102
	if (flags & O_CLOEXEC)
103
		__set_close_on_exec(newfd, fdt);
Ulrich Drepper's avatar
Ulrich Drepper committed
104
	else
105
		__clear_close_on_exec(newfd, fdt);
Linus Torvalds's avatar
Linus Torvalds committed
106 107 108 109 110
	spin_unlock(&files->file_lock);

	if (tofree)
		filp_close(tofree, files);

Al Viro's avatar
Al Viro committed
111 112 113 114 115
	return newfd;

Ebadf:
	err = -EBADF;
out_unlock:
Linus Torvalds's avatar
Linus Torvalds committed
116
	spin_unlock(&files->file_lock);
Al Viro's avatar
Al Viro committed
117
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
118
}
Ulrich Drepper's avatar
Ulrich Drepper committed
119

120
SYSCALL_DEFINE2(dup2, unsigned int, oldfd, unsigned int, newfd)
Ulrich Drepper's avatar
Ulrich Drepper committed
121
{
122 123
	if (unlikely(newfd == oldfd)) { /* corner case */
		struct files_struct *files = current->files;
124 125
		int retval = oldfd;

126 127
		rcu_read_lock();
		if (!fcheck_files(files, oldfd))
128
			retval = -EBADF;
129
		rcu_read_unlock();
130
		return retval;
131
	}
Ulrich Drepper's avatar
Ulrich Drepper committed
132 133
	return sys_dup3(oldfd, newfd, 0);
}
Linus Torvalds's avatar
Linus Torvalds committed
134

135
SYSCALL_DEFINE1(dup, unsigned int, fildes)
Linus Torvalds's avatar
Linus Torvalds committed
136 137
{
	int ret = -EBADF;
138
	struct file *file = fget_raw(fildes);
139 140 141 142 143 144 145 146

	if (file) {
		ret = get_unused_fd();
		if (ret >= 0)
			fd_install(ret, file);
		else
			fput(file);
	}
Linus Torvalds's avatar
Linus Torvalds committed
147 148 149
	return ret;
}

150
#define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
Linus Torvalds's avatar
Linus Torvalds committed
151 152 153

static int setfl(int fd, struct file * filp, unsigned long arg)
{
154
	struct inode * inode = filp->f_path.dentry->d_inode;
Linus Torvalds's avatar
Linus Torvalds committed
155 156
	int error = 0;

157 158 159 160 161
	/*
	 * O_APPEND cannot be cleared if the file is marked as append-only
	 * and the file is open for write.
	 */
	if (((arg ^ filp->f_flags) & O_APPEND) && IS_APPEND(inode))
Linus Torvalds's avatar
Linus Torvalds committed
162 163 164 165
		return -EPERM;

	/* O_NOATIME can only be set by the owner or superuser */
	if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
166
		if (!inode_owner_or_capable(inode))
Linus Torvalds's avatar
Linus Torvalds committed
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
			return -EPERM;

	/* required for strict SunOS emulation */
	if (O_NONBLOCK != O_NDELAY)
	       if (arg & O_NDELAY)
		   arg |= O_NONBLOCK;

	if (arg & O_DIRECT) {
		if (!filp->f_mapping || !filp->f_mapping->a_ops ||
			!filp->f_mapping->a_ops->direct_IO)
				return -EINVAL;
	}

	if (filp->f_op && filp->f_op->check_flags)
		error = filp->f_op->check_flags(arg);
	if (error)
		return error;

185
	/*
186
	 * ->fasync() is responsible for setting the FASYNC bit.
187
	 */
188 189 190 191 192
	if (((arg ^ filp->f_flags) & FASYNC) && filp->f_op &&
			filp->f_op->fasync) {
		error = filp->f_op->fasync(fd, filp, (arg & FASYNC) != 0);
		if (error < 0)
			goto out;
193 194
		if (error > 0)
			error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
195
	}
196
	spin_lock(&filp->f_lock);
Linus Torvalds's avatar
Linus Torvalds committed
197
	filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
198
	spin_unlock(&filp->f_lock);
199

Linus Torvalds's avatar
Linus Torvalds committed
200 201 202 203
 out:
	return error;
}

204
static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
205
                     int force)
Linus Torvalds's avatar
Linus Torvalds committed
206
{
207
	write_lock_irq(&filp->f_owner.lock);
Linus Torvalds's avatar
Linus Torvalds committed
208
	if (force || !filp->f_owner.pid) {
209 210 211
		put_pid(filp->f_owner.pid);
		filp->f_owner.pid = get_pid(pid);
		filp->f_owner.pid_type = type;
212 213 214 215 216 217

		if (pid) {
			const struct cred *cred = current_cred();
			filp->f_owner.uid = cred->uid;
			filp->f_owner.euid = cred->euid;
		}
Linus Torvalds's avatar
Linus Torvalds committed
218
	}
219
	write_unlock_irq(&filp->f_owner.lock);
Linus Torvalds's avatar
Linus Torvalds committed
220 221
}

222 223
int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
		int force)
Linus Torvalds's avatar
Linus Torvalds committed
224 225
{
	int err;
226

Linus Torvalds's avatar
Linus Torvalds committed
227 228 229 230
	err = security_file_set_fowner(filp);
	if (err)
		return err;

231
	f_modown(filp, pid, type, force);
Linus Torvalds's avatar
Linus Torvalds committed
232 233
	return 0;
}
234
EXPORT_SYMBOL(__f_setown);
Linus Torvalds's avatar
Linus Torvalds committed
235

236 237 238 239 240 241 242 243 244 245 246 247
int f_setown(struct file *filp, unsigned long arg, int force)
{
	enum pid_type type;
	struct pid *pid;
	int who = arg;
	int result;
	type = PIDTYPE_PID;
	if (who < 0) {
		type = PIDTYPE_PGID;
		who = -who;
	}
	rcu_read_lock();
248
	pid = find_vpid(who);
249 250 251 252
	result = __f_setown(filp, pid, type, force);
	rcu_read_unlock();
	return result;
}
Linus Torvalds's avatar
Linus Torvalds committed
253 254 255 256
EXPORT_SYMBOL(f_setown);

void f_delown(struct file *filp)
{
257
	f_modown(filp, NULL, PIDTYPE_PID, 1);
258 259 260 261 262
}

pid_t f_getown(struct file *filp)
{
	pid_t pid;
263
	read_lock(&filp->f_owner.lock);
264
	pid = pid_vnr(filp->f_owner.pid);
265 266
	if (filp->f_owner.pid_type == PIDTYPE_PGID)
		pid = -pid;
267
	read_unlock(&filp->f_owner.lock);
268
	return pid;
Linus Torvalds's avatar
Linus Torvalds committed
269 270
}

Peter Zijlstra's avatar
Peter Zijlstra committed
271 272 273 274 275 276 277 278 279 280
static int f_setown_ex(struct file *filp, unsigned long arg)
{
	struct f_owner_ex * __user owner_p = (void * __user)arg;
	struct f_owner_ex owner;
	struct pid *pid;
	int type;
	int ret;

	ret = copy_from_user(&owner, owner_p, sizeof(owner));
	if (ret)
281
		return -EFAULT;
Peter Zijlstra's avatar
Peter Zijlstra committed
282 283 284 285 286 287 288 289 290 291

	switch (owner.type) {
	case F_OWNER_TID:
		type = PIDTYPE_MAX;
		break;

	case F_OWNER_PID:
		type = PIDTYPE_PID;
		break;

292
	case F_OWNER_PGRP:
Peter Zijlstra's avatar
Peter Zijlstra committed
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328
		type = PIDTYPE_PGID;
		break;

	default:
		return -EINVAL;
	}

	rcu_read_lock();
	pid = find_vpid(owner.pid);
	if (owner.pid && !pid)
		ret = -ESRCH;
	else
		ret = __f_setown(filp, pid, type, 1);
	rcu_read_unlock();

	return ret;
}

static int f_getown_ex(struct file *filp, unsigned long arg)
{
	struct f_owner_ex * __user owner_p = (void * __user)arg;
	struct f_owner_ex owner;
	int ret = 0;

	read_lock(&filp->f_owner.lock);
	owner.pid = pid_vnr(filp->f_owner.pid);
	switch (filp->f_owner.pid_type) {
	case PIDTYPE_MAX:
		owner.type = F_OWNER_TID;
		break;

	case PIDTYPE_PID:
		owner.type = F_OWNER_PID;
		break;

	case PIDTYPE_PGID:
329
		owner.type = F_OWNER_PGRP;
Peter Zijlstra's avatar
Peter Zijlstra committed
330 331 332 333 334 335 336 337 338
		break;

	default:
		WARN_ON(1);
		ret = -EINVAL;
		break;
	}
	read_unlock(&filp->f_owner.lock);

339
	if (!ret) {
Peter Zijlstra's avatar
Peter Zijlstra committed
340
		ret = copy_to_user(owner_p, &owner, sizeof(owner));
341 342 343
		if (ret)
			ret = -EFAULT;
	}
Peter Zijlstra's avatar
Peter Zijlstra committed
344 345 346
	return ret;
}

347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371
#ifdef CONFIG_CHECKPOINT_RESTORE
static int f_getowner_uids(struct file *filp, unsigned long arg)
{
	struct user_namespace *user_ns = current_user_ns();
	uid_t * __user dst = (void * __user)arg;
	uid_t src[2];
	int err;

	read_lock(&filp->f_owner.lock);
	src[0] = from_kuid(user_ns, filp->f_owner.uid);
	src[1] = from_kuid(user_ns, filp->f_owner.euid);
	read_unlock(&filp->f_owner.lock);

	err  = put_user(src[0], &dst[0]);
	err |= put_user(src[1], &dst[1]);

	return err;
}
#else
static int f_getowner_uids(struct file *filp, unsigned long arg)
{
	return -EINVAL;
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375 376 377 378
static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
		struct file *filp)
{
	long err = -EINVAL;

	switch (cmd) {
	case F_DUPFD:
379
	case F_DUPFD_CLOEXEC:
Jiri Slaby's avatar
Jiri Slaby committed
380
		if (arg >= rlimit(RLIMIT_NOFILE))
Al Viro's avatar
Al Viro committed
381
			break;
382 383 384 385 386
		err = alloc_fd(arg, cmd == F_DUPFD_CLOEXEC ? O_CLOEXEC : 0);
		if (err >= 0) {
			get_file(filp);
			fd_install(err, filp);
		}
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
		break;
	case F_GETFD:
		err = get_close_on_exec(fd) ? FD_CLOEXEC : 0;
		break;
	case F_SETFD:
		err = 0;
		set_close_on_exec(fd, arg & FD_CLOEXEC);
		break;
	case F_GETFL:
		err = filp->f_flags;
		break;
	case F_SETFL:
		err = setfl(fd, filp, arg);
		break;
	case F_GETLK:
		err = fcntl_getlk(filp, (struct flock __user *) arg);
		break;
	case F_SETLK:
	case F_SETLKW:
406
		err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
Linus Torvalds's avatar
Linus Torvalds committed
407 408 409 410 411 412 413 414 415
		break;
	case F_GETOWN:
		/*
		 * XXX If f_owner is a process group, the
		 * negative return value will get converted
		 * into an error.  Oops.  If we keep the
		 * current syscall conventions, the only way
		 * to fix this will be in libc.
		 */
416
		err = f_getown(filp);
Linus Torvalds's avatar
Linus Torvalds committed
417 418 419 420 421
		force_successful_syscall_return();
		break;
	case F_SETOWN:
		err = f_setown(filp, arg, 1);
		break;
Peter Zijlstra's avatar
Peter Zijlstra committed
422 423 424 425 426 427
	case F_GETOWN_EX:
		err = f_getown_ex(filp, arg);
		break;
	case F_SETOWN_EX:
		err = f_setown_ex(filp, arg);
		break;
428 429 430
	case F_GETOWNER_UIDS:
		err = f_getowner_uids(filp, arg);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
431 432 433 434 435
	case F_GETSIG:
		err = filp->f_owner.signum;
		break;
	case F_SETSIG:
		/* arg == 0 restores default behaviour. */
436
		if (!valid_signal(arg)) {
Linus Torvalds's avatar
Linus Torvalds committed
437 438 439 440 441 442 443 444 445 446 447 448 449 450
			break;
		}
		err = 0;
		filp->f_owner.signum = arg;
		break;
	case F_GETLEASE:
		err = fcntl_getlease(filp);
		break;
	case F_SETLEASE:
		err = fcntl_setlease(fd, filp, arg);
		break;
	case F_NOTIFY:
		err = fcntl_dirnotify(fd, filp, arg);
		break;
451 452 453 454
	case F_SETPIPE_SZ:
	case F_GETPIPE_SZ:
		err = pipe_fcntl(filp, cmd, arg);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
455 456 457 458 459 460
	default:
		break;
	}
	return err;
}

461 462 463 464 465 466 467 468 469 470 471 472 473
static int check_fcntl_cmd(unsigned cmd)
{
	switch (cmd) {
	case F_DUPFD:
	case F_DUPFD_CLOEXEC:
	case F_GETFD:
	case F_SETFD:
	case F_GETFL:
		return 1;
	}
	return 0;
}

474
SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
Linus Torvalds's avatar
Linus Torvalds committed
475 476
{	
	struct file *filp;
477
	int fput_needed;
Linus Torvalds's avatar
Linus Torvalds committed
478 479
	long err = -EBADF;

480
	filp = fget_raw_light(fd, &fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483
	if (!filp)
		goto out;

484
	if (unlikely(filp->f_mode & FMODE_PATH)) {
485 486
		if (!check_fcntl_cmd(cmd))
			goto out1;
487 488
	}

Linus Torvalds's avatar
Linus Torvalds committed
489
	err = security_file_fcntl(filp, cmd, arg);
490 491
	if (!err)
		err = do_fcntl(fd, cmd, arg, filp);
Linus Torvalds's avatar
Linus Torvalds committed
492

493 494
out1:
 	fput_light(filp, fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
495 496 497 498 499
out:
	return err;
}

#if BITS_PER_LONG == 32
500 501
SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
		unsigned long, arg)
Linus Torvalds's avatar
Linus Torvalds committed
502 503
{	
	struct file * filp;
504 505
	long err = -EBADF;
	int fput_needed;
Linus Torvalds's avatar
Linus Torvalds committed
506

507
	filp = fget_raw_light(fd, &fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
508 509 510
	if (!filp)
		goto out;

511
	if (unlikely(filp->f_mode & FMODE_PATH)) {
512 513
		if (!check_fcntl_cmd(cmd))
			goto out1;
514 515
	}

Linus Torvalds's avatar
Linus Torvalds committed
516
	err = security_file_fcntl(filp, cmd, arg);
517 518
	if (err)
		goto out1;
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521 522 523 524 525
	
	switch (cmd) {
		case F_GETLK64:
			err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
			break;
		case F_SETLK64:
		case F_SETLKW64:
526 527
			err = fcntl_setlk64(fd, filp, cmd,
					(struct flock64 __user *) arg);
Linus Torvalds's avatar
Linus Torvalds committed
528 529 530 531 532
			break;
		default:
			err = do_fcntl(fd, cmd, arg, filp);
			break;
	}
533 534
out1:
	fput_light(filp, fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
535 536 537 538 539 540 541
out:
	return err;
}
#endif

/* Table to convert sigio signal codes into poll band bitmaps */

542
static const long band_table[NSIGPOLL] = {
Linus Torvalds's avatar
Linus Torvalds committed
543 544 545 546 547 548 549 550 551 552 553
	POLLIN | POLLRDNORM,			/* POLL_IN */
	POLLOUT | POLLWRNORM | POLLWRBAND,	/* POLL_OUT */
	POLLIN | POLLRDNORM | POLLMSG,		/* POLL_MSG */
	POLLERR,				/* POLL_ERR */
	POLLPRI | POLLRDBAND,			/* POLL_PRI */
	POLLHUP | POLLERR			/* POLL_HUP */
};

static inline int sigio_perm(struct task_struct *p,
                             struct fown_struct *fown, int sig)
{
554 555 556 557 558
	const struct cred *cred;
	int ret;

	rcu_read_lock();
	cred = __task_cred(p);
559 560 561
	ret = ((uid_eq(fown->euid, GLOBAL_ROOT_UID) ||
		uid_eq(fown->euid, cred->suid) || uid_eq(fown->euid, cred->uid) ||
		uid_eq(fown->uid,  cred->suid) || uid_eq(fown->uid,  cred->uid)) &&
562 563 564
	       !security_file_send_sigiotask(p, fown, sig));
	rcu_read_unlock();
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
565 566 567
}

static void send_sigio_to_task(struct task_struct *p,
568
			       struct fown_struct *fown,
Peter Zijlstra's avatar
Peter Zijlstra committed
569
			       int fd, int reason, int group)
Linus Torvalds's avatar
Linus Torvalds committed
570
{
571 572 573 574 575 576 577
	/*
	 * F_SETSIG can change ->signum lockless in parallel, make
	 * sure we read it once and use the same value throughout.
	 */
	int signum = ACCESS_ONCE(fown->signum);

	if (!sigio_perm(p, fown, signum))
Linus Torvalds's avatar
Linus Torvalds committed
578 579
		return;

580
	switch (signum) {
Linus Torvalds's avatar
Linus Torvalds committed
581 582 583 584 585 586 587 588
		siginfo_t si;
		default:
			/* Queue a rt signal with the appropriate fd as its
			   value.  We use SI_SIGIO as the source, not 
			   SI_KERNEL, since kernel signals always get 
			   delivered even if we can't queue.  Failure to
			   queue in this case _should_ be reported; we fall
			   back to SIGIO in that case. --sct */
589
			si.si_signo = signum;
Linus Torvalds's avatar
Linus Torvalds committed
590 591 592 593 594
			si.si_errno = 0;
		        si.si_code  = reason;
			/* Make sure we are called with one of the POLL_*
			   reasons, otherwise we could leak kernel stack into
			   userspace.  */
595
			BUG_ON((reason & __SI_MASK) != __SI_POLL);
Linus Torvalds's avatar
Linus Torvalds committed
596 597 598 599 600
			if (reason - POLL_IN >= NSIGPOLL)
				si.si_band  = ~0L;
			else
				si.si_band = band_table[reason - POLL_IN];
			si.si_fd    = fd;
Peter Zijlstra's avatar
Peter Zijlstra committed
601
			if (!do_send_sig_info(signum, &si, p, group))
Linus Torvalds's avatar
Linus Torvalds committed
602 603 604
				break;
		/* fall-through: fall back on the old plain SIGIO signal */
		case 0:
Peter Zijlstra's avatar
Peter Zijlstra committed
605
			do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611
	}
}

void send_sigio(struct fown_struct *fown, int fd, int band)
{
	struct task_struct *p;
612 613
	enum pid_type type;
	struct pid *pid;
Peter Zijlstra's avatar
Peter Zijlstra committed
614
	int group = 1;
Linus Torvalds's avatar
Linus Torvalds committed
615 616
	
	read_lock(&fown->lock);
Peter Zijlstra's avatar
Peter Zijlstra committed
617

618
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
619 620 621 622 623
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

Linus Torvalds's avatar
Linus Torvalds committed
624 625 626 627 628
	pid = fown->pid;
	if (!pid)
		goto out_unlock_fown;
	
	read_lock(&tasklist_lock);
629
	do_each_pid_task(pid, type, p) {
Peter Zijlstra's avatar
Peter Zijlstra committed
630
		send_sigio_to_task(p, fown, fd, band, group);
631
	} while_each_pid_task(pid, type, p);
Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635 636 637
	read_unlock(&tasklist_lock);
 out_unlock_fown:
	read_unlock(&fown->lock);
}

static void send_sigurg_to_task(struct task_struct *p,
Peter Zijlstra's avatar
Peter Zijlstra committed
638
				struct fown_struct *fown, int group)
Linus Torvalds's avatar
Linus Torvalds committed
639 640
{
	if (sigio_perm(p, fown, SIGURG))
Peter Zijlstra's avatar
Peter Zijlstra committed
641
		do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646
}

int send_sigurg(struct fown_struct *fown)
{
	struct task_struct *p;
647 648
	enum pid_type type;
	struct pid *pid;
Peter Zijlstra's avatar
Peter Zijlstra committed
649
	int group = 1;
650
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
651 652
	
	read_lock(&fown->lock);
Peter Zijlstra's avatar
Peter Zijlstra committed
653

654
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
655 656 657 658 659
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663 664 665 666
	pid = fown->pid;
	if (!pid)
		goto out_unlock_fown;

	ret = 1;
	
	read_lock(&tasklist_lock);
667
	do_each_pid_task(pid, type, p) {
Peter Zijlstra's avatar
Peter Zijlstra committed
668
		send_sigurg_to_task(p, fown, group);
669
	} while_each_pid_task(pid, type, p);
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674 675
	read_unlock(&tasklist_lock);
 out_unlock_fown:
	read_unlock(&fown->lock);
	return ret;
}

676
static DEFINE_SPINLOCK(fasync_lock);
677
static struct kmem_cache *fasync_cache __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
678

679 680 681 682 683 684
static void fasync_free_rcu(struct rcu_head *head)
{
	kmem_cache_free(fasync_cache,
			container_of(head, struct fasync_struct, fa_rcu));
}

Linus Torvalds's avatar
Linus Torvalds committed
685
/*
686 687 688 689 690 691 692
 * Remove a fasync entry. If successfully removed, return
 * positive and clear the FASYNC flag. If no entry exists,
 * do nothing and return 0.
 *
 * NOTE! It is very important that the FASYNC flag always
 * match the state "is the filp on a fasync list".
 *
Linus Torvalds's avatar
Linus Torvalds committed
693
 */
694
int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
Linus Torvalds's avatar
Linus Torvalds committed
695 696 697 698
{
	struct fasync_struct *fa, **fp;
	int result = 0;

699
	spin_lock(&filp->f_lock);
700
	spin_lock(&fasync_lock);
701 702 703
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
		if (fa->fa_file != filp)
			continue;
704 705 706 707 708

		spin_lock_irq(&fa->fa_lock);
		fa->fa_file = NULL;
		spin_unlock_irq(&fa->fa_lock);

709
		*fp = fa->fa_next;
710
		call_rcu(&fa->fa_rcu, fasync_free_rcu);
711 712 713
		filp->f_flags &= ~FASYNC;
		result = 1;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
714
	}
715
	spin_unlock(&fasync_lock);
716 717 718 719
	spin_unlock(&filp->f_lock);
	return result;
}

720 721 722 723 724
struct fasync_struct *fasync_alloc(void)
{
	return kmem_cache_alloc(fasync_cache, GFP_KERNEL);
}

725
/*
726 727 728
 * NOTE! This can be used only for unused fasync entries:
 * entries that actually got inserted on the fasync list
 * need to be released by rcu - see fasync_remove_entry.
729
 */
730
void fasync_free(struct fasync_struct *new)
731
{
732 733
	kmem_cache_free(fasync_cache, new);
}
734

735 736 737
/*
 * Insert a new entry into the fasync list.  Return the pointer to the
 * old one if we didn't use the new one.
738 739 740
 *
 * NOTE! It is very important that the FASYNC flag always
 * match the state "is the filp on a fasync list".
741 742 743 744
 */
struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
{
        struct fasync_struct *fa, **fp;
745 746

	spin_lock(&filp->f_lock);
747
	spin_lock(&fasync_lock);
Linus Torvalds's avatar
Linus Torvalds committed
748
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
749 750
		if (fa->fa_file != filp)
			continue;
751 752

		spin_lock_irq(&fa->fa_lock);
753
		fa->fa_fd = fd;
754
		spin_unlock_irq(&fa->fa_lock);
755
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
756 757
	}

758
	spin_lock_init(&new->fa_lock);
759 760 761 762
	new->magic = FASYNC_MAGIC;
	new->fa_file = filp;
	new->fa_fd = fd;
	new->fa_next = *fapp;
763
	rcu_assign_pointer(*fapp, new);
764 765
	filp->f_flags |= FASYNC;

Linus Torvalds's avatar
Linus Torvalds committed
766
out:
767
	spin_unlock(&fasync_lock);
768
	spin_unlock(&filp->f_lock);
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
	return fa;
}

/*
 * Add a fasync entry. Return negative on error, positive if
 * added, and zero if did nothing but change an existing one.
 */
static int fasync_add_entry(int fd, struct file *filp, struct fasync_struct **fapp)
{
	struct fasync_struct *new;

	new = fasync_alloc();
	if (!new)
		return -ENOMEM;

	/*
	 * fasync_insert_entry() returns the old (update) entry if
	 * it existed.
	 *
	 * So free the (unused) new entry and return 0 to let the
	 * caller know that we didn't add any new fasync entries.
	 */
	if (fasync_insert_entry(fd, filp, fapp, new)) {
		fasync_free(new);
		return 0;
	}

	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
797 798
}

799 800 801 802 803 804 805 806 807 808 809 810 811
/*
 * fasync_helper() is used by almost all character device drivers
 * to set up the fasync queue, and for regular files by the file
 * lease code. It returns negative on error, 0 if it did no changes
 * and positive if it added/deleted the entry.
 */
int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
{
	if (!on)
		return fasync_remove_entry(filp, fapp);
	return fasync_add_entry(fd, filp, fapp);
}

Linus Torvalds's avatar
Linus Torvalds committed
812 813
EXPORT_SYMBOL(fasync_helper);

814 815 816 817
/*
 * rcu_read_lock() is held
 */
static void kill_fasync_rcu(struct fasync_struct *fa, int sig, int band)
Linus Torvalds's avatar
Linus Torvalds committed
818 819
{
	while (fa) {
820
		struct fown_struct *fown;
821 822
		unsigned long flags;

Linus Torvalds's avatar
Linus Torvalds committed
823 824 825 826 827
		if (fa->magic != FASYNC_MAGIC) {
			printk(KERN_ERR "kill_fasync: bad magic number in "
			       "fasync_struct!\n");
			return;
		}
828
		spin_lock_irqsave(&fa->fa_lock, flags);
829 830 831 832 833 834 835 836
		if (fa->fa_file) {
			fown = &fa->fa_file->f_owner;
			/* Don't send SIGURG to processes which have not set a
			   queued signum: SIGURG has its own default signalling
			   mechanism. */
			if (!(sig == SIGURG && fown->signum == 0))
				send_sigio(fown, fa->fa_fd, band);
		}
837
		spin_unlock_irqrestore(&fa->fa_lock, flags);
838
		fa = rcu_dereference(fa->fa_next);
Linus Torvalds's avatar
Linus Torvalds committed
839 840 841 842 843 844 845 846 847
	}
}

void kill_fasync(struct fasync_struct **fp, int sig, int band)
{
	/* First a quick test without locking: usually
	 * the list is empty.
	 */
	if (*fp) {
848 849 850
		rcu_read_lock();
		kill_fasync_rcu(rcu_dereference(*fp), sig, band);
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
851 852 853 854
	}
}
EXPORT_SYMBOL(kill_fasync);

855
static int __init fcntl_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
856
{
857 858 859 860 861
	/*
	 * Please add new bits here to ensure allocation uniqueness.
	 * Exceptions: O_NONBLOCK is a two bit define on parisc; O_NDELAY
	 * is defined as O_NONBLOCK on some platforms and not on others.
	 */
862
	BUILD_BUG_ON(19 - 1 /* for O_RDONLY being 0 */ != HWEIGHT32(
863 864
		O_RDONLY	| O_WRONLY	| O_RDWR	|
		O_CREAT		| O_EXCL	| O_NOCTTY	|
865
		O_TRUNC		| O_APPEND	| /* O_NONBLOCK	| */
866 867 868
		__O_SYNC	| O_DSYNC	| FASYNC	|
		O_DIRECT	| O_LARGEFILE	| O_DIRECTORY	|
		O_NOFOLLOW	| O_NOATIME	| O_CLOEXEC	|
869
		__FMODE_EXEC	| O_PATH
870 871
		));

Linus Torvalds's avatar
Linus Torvalds committed
872
	fasync_cache = kmem_cache_create("fasync_cache",
873
		sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
874 875 876
	return 0;
}

877
module_init(fcntl_init)