[net-next-2.6.git] / fs / eventfd.c

/*
 *  fs/eventfd.c
 *
 *  Copyright (C) 2007  Davide Libenzi <davidel@xmailserver.org>
 *
 */

#include <linux/file.h>
#include <linux/poll.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/spinlock.h>
#include <linux/anon_inodes.h>
#include <linux/syscalls.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/eventfd.h>

struct eventfd_ctx {
	struct kref kref;
	wait_queue_head_t wqh;
	/*
	 * Every time that a write(2) is performed on an eventfd, the
	 * value of the __u64 being written is added to "count" and a
	 * wakeup is performed on "wqh". A read(2) will return the "count"
	 * value to userspace, and will reset "count" to zero. The kernel
	 * side eventfd_signal() also, adds to the "count" counter and
	 * issue a wakeup.
	 */
	__u64 count;
	unsigned int flags;
};

/**
 * eventfd_signal - Adds @n to the eventfd counter.
 * @ctx: [in] Pointer to the eventfd context.
 * @n: [in] Value of the counter to be added to the eventfd internal counter.
 *          The value cannot be negative.
 *
 * This function is supposed to be called by the kernel in paths that do not
 * allow sleeping. In this function we allow the counter to reach the ULLONG_MAX
 * value, and we signal this as overflow condition by returining a POLLERR
 * to poll(2).
 *
 * Returns @n in case of success, a non-negative number lower than @n in case
 * of overflow, or the following error codes:
 *
 * -EINVAL    : The value of @n is negative.
 */
int eventfd_signal(struct eventfd_ctx *ctx, int n)
{
	unsigned long flags;

	if (n < 0)
		return -EINVAL;
	spin_lock_irqsave(&ctx->wqh.lock, flags);
	if (ULLONG_MAX - ctx->count < n)
		n = (int) (ULLONG_MAX - ctx->count);
	ctx->count += n;
	if (waitqueue_active(&ctx->wqh))
		wake_up_locked_poll(&ctx->wqh, POLLIN);
	spin_unlock_irqrestore(&ctx->wqh.lock, flags);

	return n;
}
EXPORT_SYMBOL_GPL(eventfd_signal);

static void eventfd_free_ctx(struct eventfd_ctx *ctx)
{
	kfree(ctx);
}

static void eventfd_free(struct kref *kref)
{
	struct eventfd_ctx *ctx = container_of(kref, struct eventfd_ctx, kref);

	eventfd_free_ctx(ctx);
}

/**
 * eventfd_ctx_get - Acquires a reference to the internal eventfd context.
 * @ctx: [in] Pointer to the eventfd context.
 *
 * Returns: In case of success, returns a pointer to the eventfd context.
 */
struct eventfd_ctx *eventfd_ctx_get(struct eventfd_ctx *ctx)
{
	kref_get(&ctx->kref);
	return ctx;
}
EXPORT_SYMBOL_GPL(eventfd_ctx_get);

/**
 * eventfd_ctx_put - Releases a reference to the internal eventfd context.
 * @ctx: [in] Pointer to eventfd context.
 *
 * The eventfd context reference must have been previously acquired either
 * with eventfd_ctx_get() or eventfd_ctx_fdget()).
 */
void eventfd_ctx_put(struct eventfd_ctx *ctx)
{
	kref_put(&ctx->kref, eventfd_free);
}
EXPORT_SYMBOL_GPL(eventfd_ctx_put);

static int eventfd_release(struct inode *inode, struct file *file)
{
	struct eventfd_ctx *ctx = file->private_data;

	wake_up_poll(&ctx->wqh, POLLHUP);
	eventfd_ctx_put(ctx);
	return 0;
}

static unsigned int eventfd_poll(struct file *file, poll_table *wait)
{
	struct eventfd_ctx *ctx = file->private_data;
	unsigned int events = 0;
	unsigned long flags;

	poll_wait(file, &ctx->wqh, wait);

	spin_lock_irqsave(&ctx->wqh.lock, flags);
	if (ctx->count > 0)
		events |= POLLIN;
	if (ctx->count == ULLONG_MAX)
		events |= POLLERR;
	if (ULLONG_MAX - 1 > ctx->count)
		events |= POLLOUT;
	spin_unlock_irqrestore(&ctx->wqh.lock, flags);

	return events;
}

static void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt)
{
	*cnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count;
	ctx->count -= *cnt;
}

/**
 * eventfd_ctx_remove_wait_queue - Read the current counter and removes wait queue.
 * @ctx: [in] Pointer to eventfd context.
 * @wait: [in] Wait queue to be removed.
 * @cnt: [out] Pointer to the 64bit conter value.
 *
 * Returns zero if successful, or the following error codes:
 *
 * -EAGAIN      : The operation would have blocked.
 *
 * This is used to atomically remove a wait queue entry from the eventfd wait
 * queue head, and read/reset the counter value.
 */
int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_t *wait,
				  __u64 *cnt)
{
	unsigned long flags;

	spin_lock_irqsave(&ctx->wqh.lock, flags);
	eventfd_ctx_do_read(ctx, cnt);
	__remove_wait_queue(&ctx->wqh, wait);
	if (*cnt != 0 && waitqueue_active(&ctx->wqh))
		wake_up_locked_poll(&ctx->wqh, POLLOUT);
	spin_unlock_irqrestore(&ctx->wqh.lock, flags);

	return *cnt != 0 ? 0 : -EAGAIN;
}
EXPORT_SYMBOL_GPL(eventfd_ctx_remove_wait_queue);

/**
 * eventfd_ctx_read - Reads the eventfd counter or wait if it is zero.
 * @ctx: [in] Pointer to eventfd context.
 * @no_wait: [in] Different from zero if the operation should not block.
 * @cnt: [out] Pointer to the 64bit conter value.
 *
 * Returns zero if successful, or the following error codes:
 *
 * -EAGAIN      : The operation would have blocked but @no_wait was nonzero.
 * -ERESTARTSYS : A signal interrupted the wait operation.
 *
 * If @no_wait is zero, the function might sleep until the eventfd internal
 * counter becomes greater than zero.
 */
ssize_t eventfd_ctx_read(struct eventfd_ctx *ctx, int no_wait, __u64 *cnt)
{
	ssize_t res;
	DECLARE_WAITQUEUE(wait, current);

	spin_lock_irq(&ctx->wqh.lock);
	*cnt = 0;
	res = -EAGAIN;
	if (ctx->count > 0)
		res = 0;
	else if (!no_wait) {
		__add_wait_queue(&ctx->wqh, &wait);
		for (;;) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (ctx->count > 0) {
				res = 0;
				break;
			}
			if (signal_pending(current)) {
				res = -ERESTARTSYS;
				break;
			}
			spin_unlock_irq(&ctx->wqh.lock);
			schedule();
			spin_lock_irq(&ctx->wqh.lock);
		}
		__remove_wait_queue(&ctx->wqh, &wait);
		__set_current_state(TASK_RUNNING);
	}
	if (likely(res == 0)) {
		eventfd_ctx_do_read(ctx, cnt);
		if (waitqueue_active(&ctx->wqh))
			wake_up_locked_poll(&ctx->wqh, POLLOUT);
	}
	spin_unlock_irq(&ctx->wqh.lock);

	return res;
}
EXPORT_SYMBOL_GPL(eventfd_ctx_read);

static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count,
			    loff_t *ppos)
{
	struct eventfd_ctx *ctx = file->private_data;
	ssize_t res;
	__u64 cnt;

	if (count < sizeof(cnt))
		return -EINVAL;
	res = eventfd_ctx_read(ctx, file->f_flags & O_NONBLOCK, &cnt);
	if (res < 0)
		return res;

	return put_user(cnt, (__u64 __user *) buf) ? -EFAULT : sizeof(cnt);
}

static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count,
			     loff_t *ppos)
{
	struct eventfd_ctx *ctx = file->private_data;
	ssize_t res;
	__u64 ucnt;
	DECLARE_WAITQUEUE(wait, current);

	if (count < sizeof(ucnt))
		return -EINVAL;
	if (copy_from_user(&ucnt, buf, sizeof(ucnt)))
		return -EFAULT;
	if (ucnt == ULLONG_MAX)
		return -EINVAL;
	spin_lock_irq(&ctx->wqh.lock);
	res = -EAGAIN;
	if (ULLONG_MAX - ctx->count > ucnt)
		res = sizeof(ucnt);
	else if (!(file->f_flags & O_NONBLOCK)) {
		__add_wait_queue(&ctx->wqh, &wait);
		for (res = 0;;) {
			set_current_state(TASK_INTERRUPTIBLE);
			if (ULLONG_MAX - ctx->count > ucnt) {
				res = sizeof(ucnt);
				break;
			}
			if (signal_pending(current)) {
				res = -ERESTARTSYS;
				break;
			}
			spin_unlock_irq(&ctx->wqh.lock);
			schedule();
			spin_lock_irq(&ctx->wqh.lock);
		}
		__remove_wait_queue(&ctx->wqh, &wait);
		__set_current_state(TASK_RUNNING);
	}
	if (likely(res > 0)) {
		ctx->count += ucnt;
		if (waitqueue_active(&ctx->wqh))
			wake_up_locked_poll(&ctx->wqh, POLLIN);
	}
	spin_unlock_irq(&ctx->wqh.lock);

	return res;
}

static const struct file_operations eventfd_fops = {
	.release	= eventfd_release,
	.poll		= eventfd_poll,
	.read		= eventfd_read,
	.write		= eventfd_write,
};

/**
 * eventfd_fget - Acquire a reference of an eventfd file descriptor.
 * @fd: [in] Eventfd file descriptor.
 *
 * Returns a pointer to the eventfd file structure in case of success, or the
 * following error pointer:
 *
 * -EBADF    : Invalid @fd file descriptor.
 * -EINVAL   : The @fd file descriptor is not an eventfd file.
 */
struct file *eventfd_fget(int fd)
{
	struct file *file;

	file = fget(fd);
	if (!file)
		return ERR_PTR(-EBADF);
	if (file->f_op != &eventfd_fops) {
		fput(file);
		return ERR_PTR(-EINVAL);
	}

	return file;
}
EXPORT_SYMBOL_GPL(eventfd_fget);

/**
 * eventfd_ctx_fdget - Acquires a reference to the internal eventfd context.
 * @fd: [in] Eventfd file descriptor.
 *
 * Returns a pointer to the internal eventfd context, otherwise the error
 * pointers returned by the following functions:
 *
 * eventfd_fget
 */
struct eventfd_ctx *eventfd_ctx_fdget(int fd)
{
	struct file *file;
	struct eventfd_ctx *ctx;

	file = eventfd_fget(fd);
	if (IS_ERR(file))
		return (struct eventfd_ctx *) file;
	ctx = eventfd_ctx_get(file->private_data);
	fput(file);

	return ctx;
}
EXPORT_SYMBOL_GPL(eventfd_ctx_fdget);

/**
 * eventfd_ctx_fileget - Acquires a reference to the internal eventfd context.
 * @file: [in] Eventfd file pointer.
 *
 * Returns a pointer to the internal eventfd context, otherwise the error
 * pointer:
 *
 * -EINVAL   : The @fd file descriptor is not an eventfd file.
 */
struct eventfd_ctx *eventfd_ctx_fileget(struct file *file)
{
	if (file->f_op != &eventfd_fops)
		return ERR_PTR(-EINVAL);

	return eventfd_ctx_get(file->private_data);
}
EXPORT_SYMBOL_GPL(eventfd_ctx_fileget);

/**
 * eventfd_file_create - Creates an eventfd file pointer.
 * @count: Initial eventfd counter value.
 * @flags: Flags for the eventfd file.
 *
 * This function creates an eventfd file pointer, w/out installing it into
 * the fd table. This is useful when the eventfd file is used during the
 * initialization of data structures that require extra setup after the eventfd
 * creation. So the eventfd creation is split into the file pointer creation
 * phase, and the file descriptor installation phase.
 * In this way races with userspace closing the newly installed file descriptor
 * can be avoided.
 * Returns an eventfd file pointer, or a proper error pointer.
 */
struct file *eventfd_file_create(unsigned int count, int flags)
{
	struct file *file;
	struct eventfd_ctx *ctx;

	/* Check the EFD_* constants for consistency.  */
	BUILD_BUG_ON(EFD_CLOEXEC != O_CLOEXEC);
	BUILD_BUG_ON(EFD_NONBLOCK != O_NONBLOCK);

	if (flags & ~EFD_FLAGS_SET)
		return ERR_PTR(-EINVAL);

	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
	if (!ctx)
		return ERR_PTR(-ENOMEM);

	kref_init(&ctx->kref);
	init_waitqueue_head(&ctx->wqh);
	ctx->count = count;
	ctx->flags = flags;

	file = anon_inode_getfile("[eventfd]", &eventfd_fops, ctx,
				  O_RDWR | (flags & EFD_SHARED_FCNTL_FLAGS));
	if (IS_ERR(file))
		eventfd_free_ctx(ctx);

	return file;
}

SYSCALL_DEFINE2(eventfd2, unsigned int, count, int, flags)
{
	int fd, error;
	struct file *file;

	error = get_unused_fd_flags(flags & EFD_SHARED_FCNTL_FLAGS);
	if (error < 0)
		return error;
	fd = error;

	file = eventfd_file_create(count, flags);
	if (IS_ERR(file)) {
		error = PTR_ERR(file);
		goto err_put_unused_fd;
	}
	fd_install(fd, file);

	return fd;

err_put_unused_fd:
	put_unused_fd(fd);

	return error;
}

SYSCALL_DEFINE1(eventfd, unsigned int, count)
{
	return sys_eventfd2(count, 0);
}
Commit	Line	Data
e1ad7468 DL	1	/*
	2	* fs/eventfd.c
	3	*
	4	* Copyright (C) 2007 Davide Libenzi <davidel@xmailserver.org>
	5	*
	6	*/
	7
	8	#include <linux/file.h>
	9	#include <linux/poll.h>
	10	#include <linux/init.h>
	11	#include <linux/fs.h>
	12	#include <linux/sched.h>
	13	#include <linux/kernel.h>
	14	#include <linux/list.h>
	15	#include <linux/spinlock.h>
	16	#include <linux/anon_inodes.h>
7747cdb2	17	#include <linux/syscalls.h>
5718607b	18	#include <linux/module.h>
13389010 DL	19	#include <linux/kref.h>
13389010 DL	20	#include <linux/eventfd.h>
e1ad7468 DL	21
e1ad7468 DL	22	struct eventfd_ctx {
13389010	23	struct kref kref;
e1ad7468 DL	24	wait_queue_head_t wqh;
	25	/*
	26	* Every time that a write(2) is performed on an eventfd, the
	27	* value of the __u64 being written is added to "count" and a
	28	* wakeup is performed on "wqh". A read(2) will return the "count"
	29	* value to userspace, and will reset "count" to zero. The kernel
13389010	30	* side eventfd_signal() also, adds to the "count" counter and
e1ad7468 DL	31	* issue a wakeup.
	32	*/
	33	__u64 count;
bcd0b235	34	unsigned int flags;
e1ad7468 DL	35	};
e1ad7468 DL	36
13389010 DL	37	/**
	38	* eventfd_signal - Adds @n to the eventfd counter.
	39	* @ctx: [in] Pointer to the eventfd context.
	40	* @n: [in] Value of the counter to be added to the eventfd internal counter.
	41	* The value cannot be negative.
	42	*
	43	* This function is supposed to be called by the kernel in paths that do not
	44	* allow sleeping. In this function we allow the counter to reach the ULLONG_MAX
	45	* value, and we signal this as overflow condition by returining a POLLERR
	46	* to poll(2).
	47	*
	48	* Returns @n in case of success, a non-negative number lower than @n in case
	49	* of overflow, or the following error codes:
	50	*
	51	* -EINVAL : The value of @n is negative.
e1ad7468	52	*/
13389010	53	int eventfd_signal(struct eventfd_ctx *ctx, int n)
e1ad7468	54	{
e1ad7468 DL	55	unsigned long flags;
	56
	57	if (n < 0)
	58	return -EINVAL;
d48eb233	59	spin_lock_irqsave(&ctx->wqh.lock, flags);
e1ad7468 DL	60	if (ULLONG_MAX - ctx->count < n)
	61	n = (int) (ULLONG_MAX - ctx->count);
	62	ctx->count += n;
	63	if (waitqueue_active(&ctx->wqh))
39510888	64	wake_up_locked_poll(&ctx->wqh, POLLIN);
d48eb233	65	spin_unlock_irqrestore(&ctx->wqh.lock, flags);
e1ad7468 DL	66
	67	return n;
	68	}
5718607b	69	EXPORT_SYMBOL_GPL(eventfd_signal);
e1ad7468	70
562787a5 DL	71	static void eventfd_free_ctx(struct eventfd_ctx *ctx)
	72	{
	73	kfree(ctx);
	74	}
	75
13389010 DL	76	static void eventfd_free(struct kref *kref)
	77	{
	78	struct eventfd_ctx *ctx = container_of(kref, struct eventfd_ctx, kref);
	79
562787a5	80	eventfd_free_ctx(ctx);
13389010 DL	81	}
	82
	83	/**
	84	* eventfd_ctx_get - Acquires a reference to the internal eventfd context.
	85	* @ctx: [in] Pointer to the eventfd context.
	86	*
	87	* Returns: In case of success, returns a pointer to the eventfd context.
	88	*/
	89	struct eventfd_ctx eventfd_ctx_get(struct eventfd_ctx ctx)
	90	{
	91	kref_get(&ctx->kref);
	92	return ctx;
	93	}
	94	EXPORT_SYMBOL_GPL(eventfd_ctx_get);
	95
	96	/**
	97	* eventfd_ctx_put - Releases a reference to the internal eventfd context.
	98	* @ctx: [in] Pointer to eventfd context.
	99	*
	100	* The eventfd context reference must have been previously acquired either
	101	* with eventfd_ctx_get() or eventfd_ctx_fdget()).
	102	*/
	103	void eventfd_ctx_put(struct eventfd_ctx *ctx)
	104	{
	105	kref_put(&ctx->kref, eventfd_free);
	106	}
	107	EXPORT_SYMBOL_GPL(eventfd_ctx_put);
	108
e1ad7468 DL	109	static int eventfd_release(struct inode inode, struct file file)
e1ad7468 DL	110	{
13389010 DL	111	struct eventfd_ctx *ctx = file->private_data;
	112
	113	wake_up_poll(&ctx->wqh, POLLHUP);
	114	eventfd_ctx_put(ctx);
e1ad7468 DL	115	return 0;
	116	}
	117
	118	static unsigned int eventfd_poll(struct file file, poll_table wait)
	119	{
	120	struct eventfd_ctx *ctx = file->private_data;
	121	unsigned int events = 0;
	122	unsigned long flags;
	123
	124	poll_wait(file, &ctx->wqh, wait);
	125
d48eb233	126	spin_lock_irqsave(&ctx->wqh.lock, flags);
e1ad7468 DL	127	if (ctx->count > 0)
	128	events \|= POLLIN;
	129	if (ctx->count == ULLONG_MAX)
	130	events \|= POLLERR;
	131	if (ULLONG_MAX - 1 > ctx->count)
	132	events \|= POLLOUT;
d48eb233	133	spin_unlock_irqrestore(&ctx->wqh.lock, flags);
e1ad7468 DL	134
	135	return events;
	136	}
	137
cb289d62 DL	138	static void eventfd_ctx_do_read(struct eventfd_ctx ctx, __u64 cnt)
	139	{
	140	*cnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count;
	141	ctx->count -= *cnt;
	142	}
	143
	144	/**
	145	* eventfd_ctx_remove_wait_queue - Read the current counter and removes wait queue.
	146	* @ctx: [in] Pointer to eventfd context.
	147	* @wait: [in] Wait queue to be removed.
	148	* @cnt: [out] Pointer to the 64bit conter value.
	149	*
	150	* Returns zero if successful, or the following error codes:
	151	*
	152	* -EAGAIN : The operation would have blocked.
	153	*
	154	* This is used to atomically remove a wait queue entry from the eventfd wait
	155	* queue head, and read/reset the counter value.
	156	*/
	157	int eventfd_ctx_remove_wait_queue(struct eventfd_ctx ctx, wait_queue_t wait,
	158	__u64 *cnt)
	159	{
	160	unsigned long flags;
	161
	162	spin_lock_irqsave(&ctx->wqh.lock, flags);
	163	eventfd_ctx_do_read(ctx, cnt);
	164	__remove_wait_queue(&ctx->wqh, wait);
	165	if (*cnt != 0 && waitqueue_active(&ctx->wqh))
	166	wake_up_locked_poll(&ctx->wqh, POLLOUT);
	167	spin_unlock_irqrestore(&ctx->wqh.lock, flags);
	168
	169	return *cnt != 0 ? 0 : -EAGAIN;
	170	}
	171	EXPORT_SYMBOL_GPL(eventfd_ctx_remove_wait_queue);
	172
	173	/**
	174	* eventfd_ctx_read - Reads the eventfd counter or wait if it is zero.
	175	* @ctx: [in] Pointer to eventfd context.
	176	* @no_wait: [in] Different from zero if the operation should not block.
	177	* @cnt: [out] Pointer to the 64bit conter value.
	178	*
	179	* Returns zero if successful, or the following error codes:
	180	*
	181	* -EAGAIN : The operation would have blocked but @no_wait was nonzero.
	182	* -ERESTARTSYS : A signal interrupted the wait operation.
	183	*
	184	* If @no_wait is zero, the function might sleep until the eventfd internal
	185	* counter becomes greater than zero.
	186	*/
	187	ssize_t eventfd_ctx_read(struct eventfd_ctx ctx, int no_wait, __u64 cnt)
e1ad7468	188	{
e1ad7468	189	ssize_t res;
e1ad7468 DL	190	DECLARE_WAITQUEUE(wait, current);
e1ad7468 DL	191
d48eb233	192	spin_lock_irq(&ctx->wqh.lock);
cb289d62	193	*cnt = 0;
e1ad7468	194	res = -EAGAIN;
bcd0b235	195	if (ctx->count > 0)
cb289d62 DL	196	res = 0;
cb289d62 DL	197	else if (!no_wait) {
e1ad7468	198	__add_wait_queue(&ctx->wqh, &wait);
cb289d62	199	for (;;) {
e1ad7468 DL	200	set_current_state(TASK_INTERRUPTIBLE);
e1ad7468 DL	201	if (ctx->count > 0) {
cb289d62	202	res = 0;
e1ad7468 DL	203	break;
	204	}
	205	if (signal_pending(current)) {
	206	res = -ERESTARTSYS;
	207	break;
	208	}
d48eb233	209	spin_unlock_irq(&ctx->wqh.lock);
e1ad7468	210	schedule();
d48eb233	211	spin_lock_irq(&ctx->wqh.lock);
e1ad7468 DL	212	}
	213	__remove_wait_queue(&ctx->wqh, &wait);
	214	__set_current_state(TASK_RUNNING);
	215	}
cb289d62 DL	216	if (likely(res == 0)) {
cb289d62 DL	217	eventfd_ctx_do_read(ctx, cnt);
e1ad7468	218	if (waitqueue_active(&ctx->wqh))
39510888	219	wake_up_locked_poll(&ctx->wqh, POLLOUT);
e1ad7468	220	}
d48eb233	221	spin_unlock_irq(&ctx->wqh.lock);
e1ad7468 DL	222
	223	return res;
	224	}
cb289d62 DL	225	EXPORT_SYMBOL_GPL(eventfd_ctx_read);
	226
	227	static ssize_t eventfd_read(struct file file, char __user buf, size_t count,
	228	loff_t *ppos)
	229	{
	230	struct eventfd_ctx *ctx = file->private_data;
	231	ssize_t res;
	232	__u64 cnt;
	233
	234	if (count < sizeof(cnt))
	235	return -EINVAL;
	236	res = eventfd_ctx_read(ctx, file->f_flags & O_NONBLOCK, &cnt);
	237	if (res < 0)
	238	return res;
	239
	240	return put_user(cnt, (__u64 __user *) buf) ? -EFAULT : sizeof(cnt);
	241	}
e1ad7468 DL	242
	243	static ssize_t eventfd_write(struct file file, const char __user buf, size_t count,
	244	loff_t *ppos)
	245	{
	246	struct eventfd_ctx *ctx = file->private_data;
	247	ssize_t res;
	248	__u64 ucnt;
	249	DECLARE_WAITQUEUE(wait, current);
	250
	251	if (count < sizeof(ucnt))
	252	return -EINVAL;
	253	if (copy_from_user(&ucnt, buf, sizeof(ucnt)))
	254	return -EFAULT;
	255	if (ucnt == ULLONG_MAX)
	256	return -EINVAL;
d48eb233	257	spin_lock_irq(&ctx->wqh.lock);
e1ad7468 DL	258	res = -EAGAIN;
	259	if (ULLONG_MAX - ctx->count > ucnt)
	260	res = sizeof(ucnt);
	261	else if (!(file->f_flags & O_NONBLOCK)) {
	262	__add_wait_queue(&ctx->wqh, &wait);
	263	for (res = 0;;) {
	264	set_current_state(TASK_INTERRUPTIBLE);
	265	if (ULLONG_MAX - ctx->count > ucnt) {
	266	res = sizeof(ucnt);
	267	break;
	268	}
	269	if (signal_pending(current)) {
	270	res = -ERESTARTSYS;
	271	break;
	272	}
d48eb233	273	spin_unlock_irq(&ctx->wqh.lock);
e1ad7468	274	schedule();
d48eb233	275	spin_lock_irq(&ctx->wqh.lock);
e1ad7468 DL	276	}
	277	__remove_wait_queue(&ctx->wqh, &wait);
	278	__set_current_state(TASK_RUNNING);
	279	}
bcd0b235	280	if (likely(res > 0)) {
e1ad7468 DL	281	ctx->count += ucnt;
e1ad7468 DL	282	if (waitqueue_active(&ctx->wqh))
39510888	283	wake_up_locked_poll(&ctx->wqh, POLLIN);
e1ad7468	284	}
d48eb233	285	spin_unlock_irq(&ctx->wqh.lock);
e1ad7468 DL	286
	287	return res;
	288	}
	289
	290	static const struct file_operations eventfd_fops = {
	291	.release = eventfd_release,
	292	.poll = eventfd_poll,
	293	.read = eventfd_read,
	294	.write = eventfd_write,
	295	};
	296
13389010 DL	297	/**
	298	* eventfd_fget - Acquire a reference of an eventfd file descriptor.
	299	* @fd: [in] Eventfd file descriptor.
	300	*
	301	* Returns a pointer to the eventfd file structure in case of success, or the
	302	* following error pointer:
	303	*
	304	* -EBADF : Invalid @fd file descriptor.
	305	* -EINVAL : The @fd file descriptor is not an eventfd file.
	306	*/
e1ad7468 DL	307	struct file *eventfd_fget(int fd)
	308	{
	309	struct file *file;
	310
	311	file = fget(fd);
	312	if (!file)
	313	return ERR_PTR(-EBADF);
	314	if (file->f_op != &eventfd_fops) {
	315	fput(file);
	316	return ERR_PTR(-EINVAL);
	317	}
	318
	319	return file;
	320	}
5718607b	321	EXPORT_SYMBOL_GPL(eventfd_fget);
e1ad7468	322
13389010 DL	323	/**
	324	* eventfd_ctx_fdget - Acquires a reference to the internal eventfd context.
	325	* @fd: [in] Eventfd file descriptor.
	326	*
	327	* Returns a pointer to the internal eventfd context, otherwise the error
	328	* pointers returned by the following functions:
	329	*
	330	* eventfd_fget
	331	*/
	332	struct eventfd_ctx *eventfd_ctx_fdget(int fd)
	333	{
	334	struct file *file;
	335	struct eventfd_ctx *ctx;
	336
	337	file = eventfd_fget(fd);
	338	if (IS_ERR(file))
	339	return (struct eventfd_ctx *) file;
	340	ctx = eventfd_ctx_get(file->private_data);
	341	fput(file);
	342
	343	return ctx;
	344	}
	345	EXPORT_SYMBOL_GPL(eventfd_ctx_fdget);
	346
	347	/**
	348	* eventfd_ctx_fileget - Acquires a reference to the internal eventfd context.
	349	* @file: [in] Eventfd file pointer.
	350	*
	351	* Returns a pointer to the internal eventfd context, otherwise the error
	352	* pointer:
	353	*
	354	* -EINVAL : The @fd file descriptor is not an eventfd file.
	355	*/
	356	struct eventfd_ctx eventfd_ctx_fileget(struct file file)
	357	{
	358	if (file->f_op != &eventfd_fops)
	359	return ERR_PTR(-EINVAL);
	360
	361	return eventfd_ctx_get(file->private_data);
	362	}
	363	EXPORT_SYMBOL_GPL(eventfd_ctx_fileget);
	364
562787a5 DL	365	/**
	366	* eventfd_file_create - Creates an eventfd file pointer.
	367	* @count: Initial eventfd counter value.
	368	* @flags: Flags for the eventfd file.
	369	*
	370	* This function creates an eventfd file pointer, w/out installing it into
	371	* the fd table. This is useful when the eventfd file is used during the
	372	* initialization of data structures that require extra setup after the eventfd
	373	* creation. So the eventfd creation is split into the file pointer creation
	374	* phase, and the file descriptor installation phase.
	375	* In this way races with userspace closing the newly installed file descriptor
	376	* can be avoided.
	377	* Returns an eventfd file pointer, or a proper error pointer.
	378	*/
	379	struct file *eventfd_file_create(unsigned int count, int flags)
e1ad7468	380	{
562787a5	381	struct file *file;
e1ad7468	382	struct eventfd_ctx *ctx;
e1ad7468	383
e38b36f3 UD	384	/* Check the EFD_* constants for consistency. */
	385	BUILD_BUG_ON(EFD_CLOEXEC != O_CLOEXEC);
	386	BUILD_BUG_ON(EFD_NONBLOCK != O_NONBLOCK);
	387
bcd0b235	388	if (flags & ~EFD_FLAGS_SET)
562787a5	389	return ERR_PTR(-EINVAL);
b087498e	390
e1ad7468 DL	391	ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
e1ad7468 DL	392	if (!ctx)
562787a5	393	return ERR_PTR(-ENOMEM);
e1ad7468	394
13389010	395	kref_init(&ctx->kref);
e1ad7468	396	init_waitqueue_head(&ctx->wqh);
e1ad7468	397	ctx->count = count;
bcd0b235	398	ctx->flags = flags;
e1ad7468	399
562787a5	400	file = anon_inode_getfile("[eventfd]", &eventfd_fops, ctx,
628ff7c1	401	O_RDWR \| (flags & EFD_SHARED_FCNTL_FLAGS));
562787a5 DL	402	if (IS_ERR(file))
	403	eventfd_free_ctx(ctx);
	404
	405	return file;
	406	}
	407
	408	SYSCALL_DEFINE2(eventfd2, unsigned int, count, int, flags)
	409	{
	410	int fd, error;
	411	struct file *file;
	412
	413	error = get_unused_fd_flags(flags & EFD_SHARED_FCNTL_FLAGS);
	414	if (error < 0)
	415	return error;
	416	fd = error;
	417
	418	file = eventfd_file_create(count, flags);
	419	if (IS_ERR(file)) {
	420	error = PTR_ERR(file);
	421	goto err_put_unused_fd;
	422	}
	423	fd_install(fd, file);
	424
2030a42c	425	return fd;
562787a5 DL	426
	427	err_put_unused_fd:
	428	put_unused_fd(fd);
	429
	430	return error;
e1ad7468 DL	431	}
e1ad7468 DL	432
d4e82042	433	SYSCALL_DEFINE1(eventfd, unsigned int, count)
b087498e UD	434	{
	435	return sys_eventfd2(count, 0);
	436	}
bcd0b235	437