fcntl.c 16.3 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 fd f = fdget_raw(fd);
Linus Torvalds's avatar
Linus Torvalds committed
352 353
	long err = -EBADF;

354
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
355 356
		goto out;

357
	if (unlikely(f.file->f_mode & FMODE_PATH)) {
358 359
		if (!check_fcntl_cmd(cmd))
			goto out1;
360 361
	}

362
	err = security_file_fcntl(f.file, cmd, arg);
363
	if (!err)
364
		err = do_fcntl(fd, cmd, arg, f.file);
Linus Torvalds's avatar
Linus Torvalds committed
365

366
out1:
367
 	fdput(f);
Linus Torvalds's avatar
Linus Torvalds committed
368 369 370 371 372
out:
	return err;
}

#if BITS_PER_LONG == 32
373 374
SYSCALL_DEFINE3(fcntl64, unsigned int, fd, unsigned int, cmd,
		unsigned long, arg)
Linus Torvalds's avatar
Linus Torvalds committed
375
{	
376
	struct fd f = fdget_raw(fd);
377
	long err = -EBADF;
Linus Torvalds's avatar
Linus Torvalds committed
378

379
	if (!f.file)
Linus Torvalds's avatar
Linus Torvalds committed
380 381
		goto out;

382
	if (unlikely(f.file->f_mode & FMODE_PATH)) {
383 384
		if (!check_fcntl_cmd(cmd))
			goto out1;
385 386
	}

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

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

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

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

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

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

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

489
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
490 491 492 493 494
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

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

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

525
	type = fown->pid_type;
Peter Zijlstra's avatar
Peter Zijlstra committed
526 527 528 529 530
	if (type == PIDTYPE_MAX) {
		group = 0;
		type = PIDTYPE_PID;
	}

Linus Torvalds's avatar
Linus Torvalds committed
531 532 533 534 535 536 537
	pid = fown->pid;
	if (!pid)
		goto out_unlock_fown;

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

547
static DEFINE_SPINLOCK(fasync_lock);
548
static struct kmem_cache *fasync_cache __read_mostly;
Linus Torvalds's avatar
Linus Torvalds committed
549

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

570
	spin_lock(&filp->f_lock);
571
	spin_lock(&fasync_lock);
572 573 574
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
		if (fa->fa_file != filp)
			continue;
575 576 577 578 579

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

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

591 592 593 594 595
struct fasync_struct *fasync_alloc(void)
{
	return kmem_cache_alloc(fasync_cache, GFP_KERNEL);
}

596
/*
597 598 599
 * 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.
600
 */
601
void fasync_free(struct fasync_struct *new)
602
{
603 604
	kmem_cache_free(fasync_cache, new);
}
605

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

	spin_lock(&filp->f_lock);
618
	spin_lock(&fasync_lock);
Linus Torvalds's avatar
Linus Torvalds committed
619
	for (fp = fapp; (fa = *fp) != NULL; fp = &fa->fa_next) {
620 621
		if (fa->fa_file != filp)
			continue;
622 623

		spin_lock_irq(&fa->fa_lock);
624
		fa->fa_fd = fd;
625
		spin_unlock_irq(&fa->fa_lock);
626
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
627 628
	}

629
	spin_lock_init(&new->fa_lock);
630 631 632 633
	new->magic = FASYNC_MAGIC;
	new->fa_file = filp;
	new->fa_fd = fd;
	new->fa_next = *fapp;
634
	rcu_assign_pointer(*fapp, new);
635 636
	filp->f_flags |= FASYNC;

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

670 671 672 673 674 675 676 677 678 679 680 681 682
/*
 * 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
683 684
EXPORT_SYMBOL(fasync_helper);

685 686 687 688
/*
 * 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
689 690
{
	while (fa) {
691
		struct fown_struct *fown;
692 693
		unsigned long flags;

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

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

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

Linus Torvalds's avatar
Linus Torvalds committed
743
	fasync_cache = kmem_cache_create("fasync_cache",
744
		sizeof(struct fasync_struct), 0, SLAB_PANIC, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
745 746 747
	return 0;
}

748
module_init(fcntl_init)