fcntl.c 16.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
#define SETFL_MASK (O_APPEND | O_NONBLOCK | O_NDELAY | O_DIRECT | O_NOATIME)
Linus Torvalds's avatar
Linus Torvalds committed
30 31 32

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

36 37 38 39 40
	/*
	 * 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
41 42 43 44
		return -EPERM;

	/* O_NOATIME can only be set by the owner or superuser */
	if ((arg & O_NOATIME) && !(filp->f_flags & O_NOATIME))
45
		if (!inode_owner_or_capable(inode))
Linus Torvalds's avatar
Linus Torvalds committed
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
			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;

64
	/*
65
	 * ->fasync() is responsible for setting the FASYNC bit.
66
	 */
67 68 69 70 71
	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;
72 73
		if (error > 0)
			error = 0;
Linus Torvalds's avatar
Linus Torvalds committed
74
	}
75
	spin_lock(&filp->f_lock);
Linus Torvalds's avatar
Linus Torvalds committed
76
	filp->f_flags = (arg & SETFL_MASK) | (filp->f_flags & ~SETFL_MASK);
77
	spin_unlock(&filp->f_lock);
78

Linus Torvalds's avatar
Linus Torvalds committed
79 80 81 82
 out:
	return error;
}

83
static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
84
                     int force)
Linus Torvalds's avatar
Linus Torvalds committed
85
{
86
	write_lock_irq(&filp->f_owner.lock);
Linus Torvalds's avatar
Linus Torvalds committed
87
	if (force || !filp->f_owner.pid) {
88 89 90
		put_pid(filp->f_owner.pid);
		filp->f_owner.pid = get_pid(pid);
		filp->f_owner.pid_type = type;
91 92 93 94 95 96

		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
97
	}
98
	write_unlock_irq(&filp->f_owner.lock);
Linus Torvalds's avatar
Linus Torvalds committed
99 100
}

101 102
int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
		int force)
Linus Torvalds's avatar
Linus Torvalds committed
103 104
{
	int err;
105

Linus Torvalds's avatar
Linus Torvalds committed
106 107 108 109
	err = security_file_set_fowner(filp);
	if (err)
		return err;

110
	f_modown(filp, pid, type, force);
Linus Torvalds's avatar
Linus Torvalds committed
111 112
	return 0;
}
113
EXPORT_SYMBOL(__f_setown);
Linus Torvalds's avatar
Linus Torvalds committed
114

115 116 117 118 119 120 121 122 123 124 125 126
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();
127
	pid = find_vpid(who);
128 129 130 131
	result = __f_setown(filp, pid, type, force);
	rcu_read_unlock();
	return result;
}
Linus Torvalds's avatar
Linus Torvalds committed
132 133 134 135
EXPORT_SYMBOL(f_setown);

void f_delown(struct file *filp)
{
136
	f_modown(filp, NULL, PIDTYPE_PID, 1);
137 138 139 140 141
}

pid_t f_getown(struct file *filp)
{
	pid_t pid;
142
	read_lock(&filp->f_owner.lock);
143
	pid = pid_vnr(filp->f_owner.pid);
144 145
	if (filp->f_owner.pid_type == PIDTYPE_PGID)
		pid = -pid;
146
	read_unlock(&filp->f_owner.lock);
147
	return pid;
Linus Torvalds's avatar
Linus Torvalds committed
148 149
}

Peter Zijlstra's avatar
Peter Zijlstra committed
150 151 152 153 154 155 156 157 158 159
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)
160
		return -EFAULT;
Peter Zijlstra's avatar
Peter Zijlstra committed
161 162 163 164 165 166 167 168 169 170

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

	case F_OWNER_PID:
		type = PIDTYPE_PID;
		break;

171
	case F_OWNER_PGRP:
Peter Zijlstra's avatar
Peter Zijlstra committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
		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:
208
		owner.type = F_OWNER_PGRP;
Peter Zijlstra's avatar
Peter Zijlstra committed
209 210 211 212 213 214 215 216 217
		break;

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

218
	if (!ret) {
Peter Zijlstra's avatar
Peter Zijlstra committed
219
		ret = copy_to_user(owner_p, &owner, sizeof(owner));
220 221 222
		if (ret)
			ret = -EFAULT;
	}
Peter Zijlstra's avatar
Peter Zijlstra committed
223 224 225
	return ret;
}

226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
#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
251 252 253 254 255 256 257
static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,
		struct file *filp)
{
	long err = -EINVAL;

	switch (cmd) {
	case F_DUPFD:
258 259
		err = f_dupfd(arg, filp, 0);
		break;
260
	case F_DUPFD_CLOEXEC:
261
		err = f_dupfd(arg, filp, FD_CLOEXEC);
Linus Torvalds's avatar
Linus Torvalds committed
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
		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:
281
		err = fcntl_setlk(fd, filp, cmd, (struct flock __user *) arg);
Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285 286 287 288 289 290
		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.
		 */
291
		err = f_getown(filp);
Linus Torvalds's avatar
Linus Torvalds committed
292 293 294 295 296
		force_successful_syscall_return();
		break;
	case F_SETOWN:
		err = f_setown(filp, arg, 1);
		break;
Peter Zijlstra's avatar
Peter Zijlstra committed
297 298 299 300 301 302
	case F_GETOWN_EX:
		err = f_getown_ex(filp, arg);
		break;
	case F_SETOWN_EX:
		err = f_setown_ex(filp, arg);
		break;
303 304 305
	case F_GETOWNER_UIDS:
		err = f_getowner_uids(filp, arg);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
306 307 308 309 310
	case F_GETSIG:
		err = filp->f_owner.signum;
		break;
	case F_SETSIG:
		/* arg == 0 restores default behaviour. */
311
		if (!valid_signal(arg)) {
Linus Torvalds's avatar
Linus Torvalds committed
312 313 314 315 316 317 318 319 320 321 322 323 324 325
			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;
326 327 328 329
	case F_SETPIPE_SZ:
	case F_GETPIPE_SZ:
		err = pipe_fcntl(filp, cmd, arg);
		break;
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332 333 334 335
	default:
		break;
	}
	return err;
}

336 337 338 339 340 341 342 343 344 345 346 347 348
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;
}

349
SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)
Linus Torvalds's avatar
Linus Torvalds committed
350 351
{	
	struct file *filp;
352
	int fput_needed;
Linus Torvalds's avatar
Linus Torvalds committed
353 354
	long err = -EBADF;

355
	filp = fget_raw_light(fd, &fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
356 357 358
	if (!filp)
		goto out;

359
	if (unlikely(filp->f_mode & FMODE_PATH)) {
360 361
		if (!check_fcntl_cmd(cmd))
			goto out1;
362 363
	}

Linus Torvalds's avatar
Linus Torvalds committed
364
	err = security_file_fcntl(filp, cmd, arg);
365 366
	if (!err)
		err = do_fcntl(fd, cmd, arg, filp);
Linus Torvalds's avatar
Linus Torvalds committed
367

368 369
out1:
 	fput_light(filp, fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
370 371 372 373 374
out:
	return err;
}

#if BITS_PER_LONG == 32
375 376
SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
		unsigned long, arg)
Linus Torvalds's avatar
Linus Torvalds committed
377 378
{	
	struct file * filp;
379 380
	long err = -EBADF;
	int fput_needed;
Linus Torvalds's avatar
Linus Torvalds committed
381

382
	filp = fget_raw_light(fd, &fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
383 384 385
	if (!filp)
		goto out;

386
	if (unlikely(filp->f_mode & FMODE_PATH)) {
387 388
		if (!check_fcntl_cmd(cmd))
			goto out1;
389 390
	}

Linus Torvalds's avatar
Linus Torvalds committed
391
	err = security_file_fcntl(filp, cmd, arg);
392 393
	if (err)
		goto out1;
Linus Torvalds's avatar
Linus Torvalds committed
394 395 396 397 398 399 400
	
	switch (cmd) {
		case F_GETLK64:
			err = fcntl_getlk64(filp, (struct flock64 __user *) arg);
			break;
		case F_SETLK64:
		case F_SETLKW64:
401 402
			err = fcntl_setlk64(fd, filp, cmd,
					(struct flock64 __user *) arg);
Linus Torvalds's avatar
Linus Torvalds committed
403 404 405 406 407
			break;
		default:
			err = do_fcntl(fd, cmd, arg, filp);
			break;
	}
408 409
out1:
	fput_light(filp, fput_needed);
Linus Torvalds's avatar
Linus Torvalds committed
410 411 412 413 414 415 416
out:
	return err;
}
#endif

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

417
static const long band_table[NSIGPOLL] = {
Linus Torvalds's avatar
Linus Torvalds committed
418 419 420 421 422 423 424 425 426 427 428
	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)
{
429 430 431 432 433
	const struct cred *cred;
	int ret;

	rcu_read_lock();
	cred = __task_cred(p);
434 435 436
	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)) &&
437 438 439
	       !security_file_send_sigiotask(p, fown, sig));
	rcu_read_unlock();
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
440 441 442
}

static void send_sigio_to_task(struct task_struct *p,
443
			       struct fown_struct *fown,
Peter Zijlstra's avatar
Peter Zijlstra committed
444
			       int fd, int reason, int group)
Linus Torvalds's avatar
Linus Torvalds committed
445
{
446 447 448 449 450 451 452
	/*
	 * 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
453 454
		return;

455
	switch (signum) {
Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460 461 462 463
		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 */
464
			si.si_signo = signum;
Linus Torvalds's avatar
Linus Torvalds committed
465 466 467 468 469
			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.  */
470
			BUG_ON((reason & __SI_MASK) != __SI_POLL);
Linus Torvalds's avatar
Linus Torvalds committed
471 472 473 474 475
			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
476
			if (!do_send_sig_info(signum, &si, p, group))
Linus Torvalds's avatar
Linus Torvalds committed
477 478 479
				break;
		/* fall-through: fall back on the old plain SIGIO signal */
		case 0:
Peter Zijlstra's avatar
Peter Zijlstra committed
480
			do_send_sig_info(SIGIO, SEND_SIG_PRIV, p, group);
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483 484 485 486
	}
}

void send_sigio(struct fown_struct *fown, int fd, int band)
{
	struct task_struct *p;
487 488
	enum pid_type type;
	struct pid *pid;
Peter Zijlstra's avatar
Peter Zijlstra committed
489
	int group = 1;
Linus Torvalds's avatar
Linus Torvalds committed
490 491
	
	read_lock(&fown->lock);
Peter Zijlstra's avatar
Peter Zijlstra committed
492

493
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
494 495 496 497 498
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

Linus Torvalds's avatar
Linus Torvalds committed
499 500 501 502 503
	pid = fown->pid;
	if (!pid)
		goto out_unlock_fown;
	
	read_lock(&tasklist_lock);
504
	do_each_pid_task(pid, type, p) {
Peter Zijlstra's avatar
Peter Zijlstra committed
505
		send_sigio_to_task(p, fown, fd, band, group);
506
	} while_each_pid_task(pid, type, p);
Linus Torvalds's avatar
Linus Torvalds committed
507 508 509 510 511 512
	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
513
				struct fown_struct *fown, int group)
Linus Torvalds's avatar
Linus Torvalds committed
514 515
{
	if (sigio_perm(p, fown, SIGURG))
Peter Zijlstra's avatar
Peter Zijlstra committed
516
		do_send_sig_info(SIGURG, SEND_SIG_PRIV, p, group);
Linus Torvalds's avatar
Linus Torvalds committed
517 518 519 520 521
}

int send_sigurg(struct fown_struct *fown)
{
	struct task_struct *p;
522 523
	enum pid_type type;
	struct pid *pid;
Peter Zijlstra's avatar
Peter Zijlstra committed
524
	int group = 1;
525
	int ret = 0;
Linus Torvalds's avatar
Linus Torvalds committed
526 527
	
	read_lock(&fown->lock);
Peter Zijlstra's avatar
Peter Zijlstra committed
528

529
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
530 531 532 533 534
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

Linus Torvalds's avatar
Linus Torvalds committed
535 536 537 538 539 540 541
	pid = fown->pid;
	if (!pid)
		goto out_unlock_fown;

	ret = 1;
	
	read_lock(&tasklist_lock);
542
	do_each_pid_task(pid, type, p) {
Peter Zijlstra's avatar
Peter Zijlstra committed
543
		send_sigurg_to_task(p, fown, group);
544
	} while_each_pid_task(pid, type, p);
Linus Torvalds's avatar
Linus Torvalds committed
545 546 547 548 549 550
	read_unlock(&tasklist_lock);
 out_unlock_fown:
	read_unlock(&fown->lock);
	return ret;
}

551
static DEFINE_SPINLOCK(fasync_lock);
552
static struct kmem_cache *fasync_cache __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
553

554 555 556 557 558 559
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
560
/*
561 562 563 564 565 566 567
 * 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
568
 */
569
int fasync_remove_entry(struct file *filp, struct fasync_struct **fapp)
Linus Torvalds's avatar
Linus Torvalds committed
570 571 572 573
{
	struct fasync_struct *fa, **fp;
	int result = 0;

574
	spin_lock(&filp->f_lock);
575
	spin_lock(&fasync_lock);
576 577 578
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
		if (fa->fa_file != filp)
			continue;
579 580 581 582 583

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

584
		*fp = fa->fa_next;
585
		call_rcu(&fa->fa_rcu, fasync_free_rcu);
586 587 588
		filp->f_flags &= ~FASYNC;
		result = 1;
		break;
Linus Torvalds's avatar
Linus Torvalds committed
589
	}
590
	spin_unlock(&fasync_lock);
591 592 593 594
	spin_unlock(&filp->f_lock);
	return result;
}

595 596 597 598 599
struct fasync_struct *fasync_alloc(void)
{
	return kmem_cache_alloc(fasync_cache, GFP_KERNEL);
}

600
/*
601 602 603
 * 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.
604
 */
605
void fasync_free(struct fasync_struct *new)
606
{
607 608
	kmem_cache_free(fasync_cache, new);
}
609

610 611 612
/*
 * Insert a new entry into the fasync list.  Return the pointer to the
 * old one if we didn't use the new one.
613 614 615
 *
 * NOTE! It is very important that the FASYNC flag always
 * match the state "is the filp on a fasync list".
616 617 618 619
 */
struct fasync_struct *fasync_insert_entry(int fd, struct file *filp, struct fasync_struct **fapp, struct fasync_struct *new)
{
        struct fasync_struct *fa, **fp;
620 621

	spin_lock(&filp->f_lock);
622
	spin_lock(&fasync_lock);
Linus Torvalds's avatar
Linus Torvalds committed
623
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
624 625
		if (fa->fa_file != filp)
			continue;
626 627

		spin_lock_irq(&fa->fa_lock);
628
		fa->fa_fd = fd;
629
		spin_unlock_irq(&fa->fa_lock);
630
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
631 632
	}

633
	spin_lock_init(&new->fa_lock);
634 635 636 637
	new->magic = FASYNC_MAGIC;
	new->fa_file = filp;
	new->fa_fd = fd;
	new->fa_next = *fapp;
638
	rcu_assign_pointer(*fapp, new);
639 640
	filp->f_flags |= FASYNC;

Linus Torvalds's avatar
Linus Torvalds committed
641
out:
642
	spin_unlock(&fasync_lock);
643
	spin_unlock(&filp->f_lock);
644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
	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
672 673
}

674 675 676 677 678 679 680 681 682 683 684 685 686
/*
 * 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
687 688
EXPORT_SYMBOL(fasync_helper);

689 690 691 692
/*
 * 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
693 694
{
	while (fa) {
695
		struct fown_struct *fown;
696 697
		unsigned long flags;

Linus Torvalds's avatar
Linus Torvalds committed
698 699 700 701 702
		if (fa->magic != FASYNC_MAGIC) {
			printk(KERN_ERR "kill_fasync: bad magic number in "
			       "fasync_struct!\n");
			return;
		}
703
		spin_lock_irqsave(&fa->fa_lock, flags);
704 705 706 707 708 709 710 711
		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);
		}
712
		spin_unlock_irqrestore(&fa->fa_lock, flags);
713
		fa = rcu_dereference(fa->fa_next);
Linus Torvalds's avatar
Linus Torvalds committed
714 715 716 717 718 719 720 721 722
	}
}

void kill_fasync(struct fasync_struct **fp, int sig, int band)
{
	/* First a quick test without locking: usually
	 * the list is empty.
	 */
	if (*fp) {
723 724 725
		rcu_read_lock();
		kill_fasync_rcu(rcu_dereference(*fp), sig, band);
		rcu_read_unlock();
Linus Torvalds's avatar
Linus Torvalds committed
726 727 728 729
	}
}
EXPORT_SYMBOL(kill_fasync);

730
static int __init fcntl_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
731
{
732 733 734 735 736
	/*
	 * 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.
	 */
737
	BUILD_BUG_ON(19 - 1 /* for O_RDONLY being 0 */ != HWEIGHT32(
738 739
		O_RDONLY	| O_WRONLY	| O_RDWR	|
		O_CREAT		| O_EXCL	| O_NOCTTY	|
740
		O_TRUNC		| O_APPEND	| /* O_NONBLOCK	| */
741 742 743
		__O_SYNC	| O_DSYNC	| FASYNC	|
		O_DIRECT	| O_LARGEFILE	| O_DIRECTORY	|
		O_NOFOLLOW	| O_NOATIME	| O_CLOEXEC	|
744
		__FMODE_EXEC	| O_PATH
745 746
		));

Linus Torvalds's avatar
Linus Torvalds committed
747
	fasync_cache = kmem_cache_create("fasync_cache",
748
		sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
749 750 751
	return 0;
}

752
module_init(fcntl_init)