blob: 08d3bd602f73d8f219ee1f259c0cbaa839245c56 [file] [log] [blame]
Davide Libenzie1ad7462007-05-10 22:23:19 -07001/*
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>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010012#include <linux/sched/signal.h>
Davide Libenzie1ad7462007-05-10 22:23:19 -070013#include <linux/kernel.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090014#include <linux/slab.h>
Davide Libenzie1ad7462007-05-10 22:23:19 -070015#include <linux/list.h>
16#include <linux/spinlock.h>
17#include <linux/anon_inodes.h>
Adrian Bunk7747cdb2008-02-06 01:36:49 -080018#include <linux/syscalls.h>
Paul Gortmaker630d9c42011-11-16 23:57:37 -050019#include <linux/export.h>
Davide Libenzi13389012009-06-30 11:41:11 -070020#include <linux/kref.h>
21#include <linux/eventfd.h>
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -080022#include <linux/proc_fs.h>
23#include <linux/seq_file.h>
Davide Libenzie1ad7462007-05-10 22:23:19 -070024
25struct eventfd_ctx {
Davide Libenzi13389012009-06-30 11:41:11 -070026 struct kref kref;
Davide Libenzie1ad7462007-05-10 22:23:19 -070027 wait_queue_head_t wqh;
28 /*
29 * Every time that a write(2) is performed on an eventfd, the
30 * value of the __u64 being written is added to "count" and a
31 * wakeup is performed on "wqh". A read(2) will return the "count"
32 * value to userspace, and will reset "count" to zero. The kernel
Davide Libenzi13389012009-06-30 11:41:11 -070033 * side eventfd_signal() also, adds to the "count" counter and
Davide Libenzie1ad7462007-05-10 22:23:19 -070034 * issue a wakeup.
35 */
36 __u64 count;
Davide Libenzibcd0b232009-03-31 15:24:18 -070037 unsigned int flags;
Davide Libenzie1ad7462007-05-10 22:23:19 -070038};
39
Davide Libenzi13389012009-06-30 11:41:11 -070040/**
41 * eventfd_signal - Adds @n to the eventfd counter.
42 * @ctx: [in] Pointer to the eventfd context.
43 * @n: [in] Value of the counter to be added to the eventfd internal counter.
44 * The value cannot be negative.
45 *
46 * This function is supposed to be called by the kernel in paths that do not
47 * allow sleeping. In this function we allow the counter to reach the ULLONG_MAX
Linus Torvaldsa9a08842018-02-11 14:34:03 -080048 * value, and we signal this as overflow condition by returning a EPOLLERR
Davide Libenzi13389012009-06-30 11:41:11 -070049 * to poll(2).
50 *
Masanari Iida20d5a862015-09-22 12:04:17 +090051 * Returns the amount by which the counter was incremented. This will be less
Sha Zhengjuee62c6b2012-05-31 16:26:41 -070052 * than @n if the counter has overflowed.
Davide Libenzie1ad7462007-05-10 22:23:19 -070053 */
Sha Zhengjuee62c6b2012-05-31 16:26:41 -070054__u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n)
Davide Libenzie1ad7462007-05-10 22:23:19 -070055{
Davide Libenzie1ad7462007-05-10 22:23:19 -070056 unsigned long flags;
57
Davide Libenzid48eb232007-05-18 12:02:33 -070058 spin_lock_irqsave(&ctx->wqh.lock, flags);
Davide Libenzie1ad7462007-05-10 22:23:19 -070059 if (ULLONG_MAX - ctx->count < n)
Sha Zhengjuee62c6b2012-05-31 16:26:41 -070060 n = ULLONG_MAX - ctx->count;
Davide Libenzie1ad7462007-05-10 22:23:19 -070061 ctx->count += n;
62 if (waitqueue_active(&ctx->wqh))
Linus Torvaldsa9a08842018-02-11 14:34:03 -080063 wake_up_locked_poll(&ctx->wqh, EPOLLIN);
Davide Libenzid48eb232007-05-18 12:02:33 -070064 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
Davide Libenzie1ad7462007-05-10 22:23:19 -070065
66 return n;
67}
Rusty Russell57186072009-06-12 22:27:09 -060068EXPORT_SYMBOL_GPL(eventfd_signal);
Davide Libenzie1ad7462007-05-10 22:23:19 -070069
Davide Libenzi562787a2009-09-22 16:43:57 -070070static void eventfd_free_ctx(struct eventfd_ctx *ctx)
71{
72 kfree(ctx);
73}
74
Davide Libenzi13389012009-06-30 11:41:11 -070075static void eventfd_free(struct kref *kref)
76{
77 struct eventfd_ctx *ctx = container_of(kref, struct eventfd_ctx, kref);
78
Davide Libenzi562787a2009-09-22 16:43:57 -070079 eventfd_free_ctx(ctx);
Davide Libenzi13389012009-06-30 11:41:11 -070080}
81
82/**
Davide Libenzi13389012009-06-30 11:41:11 -070083 * eventfd_ctx_put - Releases a reference to the internal eventfd context.
84 * @ctx: [in] Pointer to eventfd context.
85 *
86 * The eventfd context reference must have been previously acquired either
Eric Biggers105f2b72018-01-06 09:45:44 -080087 * with eventfd_ctx_fdget() or eventfd_ctx_fileget().
Davide Libenzi13389012009-06-30 11:41:11 -070088 */
89void eventfd_ctx_put(struct eventfd_ctx *ctx)
90{
91 kref_put(&ctx->kref, eventfd_free);
92}
93EXPORT_SYMBOL_GPL(eventfd_ctx_put);
94
Davide Libenzie1ad7462007-05-10 22:23:19 -070095static int eventfd_release(struct inode *inode, struct file *file)
96{
Davide Libenzi13389012009-06-30 11:41:11 -070097 struct eventfd_ctx *ctx = file->private_data;
98
Linus Torvaldsa9a08842018-02-11 14:34:03 -080099 wake_up_poll(&ctx->wqh, EPOLLHUP);
Davide Libenzi13389012009-06-30 11:41:11 -0700100 eventfd_ctx_put(ctx);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700101 return 0;
102}
103
Linus Torvaldsa11e1d42018-06-28 09:43:44 -0700104static __poll_t eventfd_poll(struct file *file, poll_table *wait)
Davide Libenzie1ad7462007-05-10 22:23:19 -0700105{
106 struct eventfd_ctx *ctx = file->private_data;
Al Viro076ccb72017-07-03 01:02:18 -0400107 __poll_t events = 0;
Chris Masone22553e2015-02-17 13:46:07 -0800108 u64 count;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700109
Linus Torvaldsa11e1d42018-06-28 09:43:44 -0700110 poll_wait(file, &ctx->wqh, wait);
111
Paolo Bonzinia484c3d2016-03-22 14:27:14 -0700112 /*
113 * All writes to ctx->count occur within ctx->wqh.lock. This read
114 * can be done outside ctx->wqh.lock because we know that poll_wait
115 * takes that lock (through add_wait_queue) if our caller will sleep.
116 *
117 * The read _can_ therefore seep into add_wait_queue's critical
118 * section, but cannot move above it! add_wait_queue's spin_lock acts
119 * as an acquire barrier and ensures that the read be ordered properly
120 * against the writes. The following CAN happen and is safe:
121 *
122 * poll write
123 * ----------------- ------------
124 * lock ctx->wqh.lock (in poll_wait)
125 * count = ctx->count
126 * __add_wait_queue
127 * unlock ctx->wqh.lock
128 * lock ctx->qwh.lock
129 * ctx->count += n
130 * if (waitqueue_active)
131 * wake_up_locked_poll
132 * unlock ctx->qwh.lock
133 * eventfd_poll returns 0
134 *
135 * but the following, which would miss a wakeup, cannot happen:
136 *
137 * poll write
138 * ----------------- ------------
139 * count = ctx->count (INVALID!)
140 * lock ctx->qwh.lock
141 * ctx->count += n
142 * **waitqueue_active is false**
143 * **no wake_up_locked_poll!**
144 * unlock ctx->qwh.lock
145 * lock ctx->wqh.lock (in poll_wait)
146 * __add_wait_queue
147 * unlock ctx->wqh.lock
148 * eventfd_poll returns 0
149 */
150 count = READ_ONCE(ctx->count);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700151
Chris Masone22553e2015-02-17 13:46:07 -0800152 if (count > 0)
Linus Torvaldsa11e1d42018-06-28 09:43:44 -0700153 events |= EPOLLIN;
Chris Masone22553e2015-02-17 13:46:07 -0800154 if (count == ULLONG_MAX)
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800155 events |= EPOLLERR;
Chris Masone22553e2015-02-17 13:46:07 -0800156 if (ULLONG_MAX - 1 > count)
Linus Torvaldsa11e1d42018-06-28 09:43:44 -0700157 events |= EPOLLOUT;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700158
159 return events;
160}
161
Davide Libenzicb289d62010-01-13 09:34:36 -0800162static void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt)
Davide Libenzie1ad7462007-05-10 22:23:19 -0700163{
Davide Libenzicb289d62010-01-13 09:34:36 -0800164 *cnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count;
165 ctx->count -= *cnt;
166}
167
168/**
169 * eventfd_ctx_remove_wait_queue - Read the current counter and removes wait queue.
170 * @ctx: [in] Pointer to eventfd context.
171 * @wait: [in] Wait queue to be removed.
Randy Dunlap36182182011-02-20 20:08:35 -0800172 * @cnt: [out] Pointer to the 64-bit counter value.
Davide Libenzicb289d62010-01-13 09:34:36 -0800173 *
Randy Dunlap36182182011-02-20 20:08:35 -0800174 * Returns %0 if successful, or the following error codes:
Davide Libenzicb289d62010-01-13 09:34:36 -0800175 *
176 * -EAGAIN : The operation would have blocked.
177 *
178 * This is used to atomically remove a wait queue entry from the eventfd wait
179 * queue head, and read/reset the counter value.
180 */
Ingo Molnarac6424b2017-06-20 12:06:13 +0200181int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *wait,
Davide Libenzicb289d62010-01-13 09:34:36 -0800182 __u64 *cnt)
183{
184 unsigned long flags;
185
186 spin_lock_irqsave(&ctx->wqh.lock, flags);
187 eventfd_ctx_do_read(ctx, cnt);
188 __remove_wait_queue(&ctx->wqh, wait);
189 if (*cnt != 0 && waitqueue_active(&ctx->wqh))
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800190 wake_up_locked_poll(&ctx->wqh, EPOLLOUT);
Davide Libenzicb289d62010-01-13 09:34:36 -0800191 spin_unlock_irqrestore(&ctx->wqh.lock, flags);
192
193 return *cnt != 0 ? 0 : -EAGAIN;
194}
195EXPORT_SYMBOL_GPL(eventfd_ctx_remove_wait_queue);
196
Eric Biggersb6364572018-01-06 09:45:43 -0800197static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count,
198 loff_t *ppos)
Davide Libenzicb289d62010-01-13 09:34:36 -0800199{
Eric Biggersb6364572018-01-06 09:45:43 -0800200 struct eventfd_ctx *ctx = file->private_data;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700201 ssize_t res;
Eric Biggersb6364572018-01-06 09:45:43 -0800202 __u64 ucnt = 0;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700203 DECLARE_WAITQUEUE(wait, current);
204
Eric Biggersb6364572018-01-06 09:45:43 -0800205 if (count < sizeof(ucnt))
206 return -EINVAL;
207
Davide Libenzid48eb232007-05-18 12:02:33 -0700208 spin_lock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700209 res = -EAGAIN;
Davide Libenzibcd0b232009-03-31 15:24:18 -0700210 if (ctx->count > 0)
Eric Biggersb6364572018-01-06 09:45:43 -0800211 res = sizeof(ucnt);
212 else if (!(file->f_flags & O_NONBLOCK)) {
Davide Libenzie1ad7462007-05-10 22:23:19 -0700213 __add_wait_queue(&ctx->wqh, &wait);
Davide Libenzicb289d62010-01-13 09:34:36 -0800214 for (;;) {
Davide Libenzie1ad7462007-05-10 22:23:19 -0700215 set_current_state(TASK_INTERRUPTIBLE);
216 if (ctx->count > 0) {
Eric Biggersb6364572018-01-06 09:45:43 -0800217 res = sizeof(ucnt);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700218 break;
219 }
220 if (signal_pending(current)) {
221 res = -ERESTARTSYS;
222 break;
223 }
Davide Libenzid48eb232007-05-18 12:02:33 -0700224 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700225 schedule();
Davide Libenzid48eb232007-05-18 12:02:33 -0700226 spin_lock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700227 }
228 __remove_wait_queue(&ctx->wqh, &wait);
229 __set_current_state(TASK_RUNNING);
230 }
Eric Biggersb6364572018-01-06 09:45:43 -0800231 if (likely(res > 0)) {
232 eventfd_ctx_do_read(ctx, &ucnt);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700233 if (waitqueue_active(&ctx->wqh))
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800234 wake_up_locked_poll(&ctx->wqh, EPOLLOUT);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700235 }
Davide Libenzid48eb232007-05-18 12:02:33 -0700236 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700237
Eric Biggersb6364572018-01-06 09:45:43 -0800238 if (res > 0 && put_user(ucnt, (__u64 __user *)buf))
239 return -EFAULT;
240
Davide Libenzie1ad7462007-05-10 22:23:19 -0700241 return res;
242}
243
244static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count,
245 loff_t *ppos)
246{
247 struct eventfd_ctx *ctx = file->private_data;
248 ssize_t res;
249 __u64 ucnt;
250 DECLARE_WAITQUEUE(wait, current);
251
252 if (count < sizeof(ucnt))
253 return -EINVAL;
254 if (copy_from_user(&ucnt, buf, sizeof(ucnt)))
255 return -EFAULT;
256 if (ucnt == ULLONG_MAX)
257 return -EINVAL;
Davide Libenzid48eb232007-05-18 12:02:33 -0700258 spin_lock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700259 res = -EAGAIN;
260 if (ULLONG_MAX - ctx->count > ucnt)
261 res = sizeof(ucnt);
262 else if (!(file->f_flags & O_NONBLOCK)) {
263 __add_wait_queue(&ctx->wqh, &wait);
264 for (res = 0;;) {
265 set_current_state(TASK_INTERRUPTIBLE);
266 if (ULLONG_MAX - ctx->count > ucnt) {
267 res = sizeof(ucnt);
268 break;
269 }
270 if (signal_pending(current)) {
271 res = -ERESTARTSYS;
272 break;
273 }
Davide Libenzid48eb232007-05-18 12:02:33 -0700274 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700275 schedule();
Davide Libenzid48eb232007-05-18 12:02:33 -0700276 spin_lock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700277 }
278 __remove_wait_queue(&ctx->wqh, &wait);
279 __set_current_state(TASK_RUNNING);
280 }
Davide Libenzibcd0b232009-03-31 15:24:18 -0700281 if (likely(res > 0)) {
Davide Libenzie1ad7462007-05-10 22:23:19 -0700282 ctx->count += ucnt;
283 if (waitqueue_active(&ctx->wqh))
Linus Torvaldsa9a08842018-02-11 14:34:03 -0800284 wake_up_locked_poll(&ctx->wqh, EPOLLIN);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700285 }
Davide Libenzid48eb232007-05-18 12:02:33 -0700286 spin_unlock_irq(&ctx->wqh.lock);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700287
288 return res;
289}
290
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800291#ifdef CONFIG_PROC_FS
Joe Perchesa3816ab2014-09-29 16:08:25 -0700292static void eventfd_show_fdinfo(struct seq_file *m, struct file *f)
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800293{
294 struct eventfd_ctx *ctx = f->private_data;
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800295
296 spin_lock_irq(&ctx->wqh.lock);
Joe Perchesa3816ab2014-09-29 16:08:25 -0700297 seq_printf(m, "eventfd-count: %16llx\n",
298 (unsigned long long)ctx->count);
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800299 spin_unlock_irq(&ctx->wqh.lock);
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800300}
301#endif
302
Davide Libenzie1ad7462007-05-10 22:23:19 -0700303static const struct file_operations eventfd_fops = {
Cyrill Gorcunovcbac5542012-12-17 16:04:57 -0800304#ifdef CONFIG_PROC_FS
305 .show_fdinfo = eventfd_show_fdinfo,
306#endif
Davide Libenzie1ad7462007-05-10 22:23:19 -0700307 .release = eventfd_release,
Linus Torvaldsa11e1d42018-06-28 09:43:44 -0700308 .poll = eventfd_poll,
Davide Libenzie1ad7462007-05-10 22:23:19 -0700309 .read = eventfd_read,
310 .write = eventfd_write,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200311 .llseek = noop_llseek,
Davide Libenzie1ad7462007-05-10 22:23:19 -0700312};
313
Davide Libenzi13389012009-06-30 11:41:11 -0700314/**
315 * eventfd_fget - Acquire a reference of an eventfd file descriptor.
316 * @fd: [in] Eventfd file descriptor.
317 *
318 * Returns a pointer to the eventfd file structure in case of success, or the
319 * following error pointer:
320 *
321 * -EBADF : Invalid @fd file descriptor.
322 * -EINVAL : The @fd file descriptor is not an eventfd file.
323 */
Davide Libenzie1ad7462007-05-10 22:23:19 -0700324struct file *eventfd_fget(int fd)
325{
326 struct file *file;
327
328 file = fget(fd);
329 if (!file)
330 return ERR_PTR(-EBADF);
331 if (file->f_op != &eventfd_fops) {
332 fput(file);
333 return ERR_PTR(-EINVAL);
334 }
335
336 return file;
337}
Rusty Russell57186072009-06-12 22:27:09 -0600338EXPORT_SYMBOL_GPL(eventfd_fget);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700339
Davide Libenzi13389012009-06-30 11:41:11 -0700340/**
341 * eventfd_ctx_fdget - Acquires a reference to the internal eventfd context.
342 * @fd: [in] Eventfd file descriptor.
343 *
344 * Returns a pointer to the internal eventfd context, otherwise the error
345 * pointers returned by the following functions:
346 *
347 * eventfd_fget
348 */
349struct eventfd_ctx *eventfd_ctx_fdget(int fd)
350{
Davide Libenzi13389012009-06-30 11:41:11 -0700351 struct eventfd_ctx *ctx;
Al Viro36a74112013-12-23 16:51:33 -0500352 struct fd f = fdget(fd);
353 if (!f.file)
354 return ERR_PTR(-EBADF);
355 ctx = eventfd_ctx_fileget(f.file);
356 fdput(f);
Davide Libenzi13389012009-06-30 11:41:11 -0700357 return ctx;
358}
359EXPORT_SYMBOL_GPL(eventfd_ctx_fdget);
360
361/**
362 * eventfd_ctx_fileget - Acquires a reference to the internal eventfd context.
363 * @file: [in] Eventfd file pointer.
364 *
365 * Returns a pointer to the internal eventfd context, otherwise the error
366 * pointer:
367 *
368 * -EINVAL : The @fd file descriptor is not an eventfd file.
369 */
370struct eventfd_ctx *eventfd_ctx_fileget(struct file *file)
371{
Eric Biggers105f2b72018-01-06 09:45:44 -0800372 struct eventfd_ctx *ctx;
373
Davide Libenzi13389012009-06-30 11:41:11 -0700374 if (file->f_op != &eventfd_fops)
375 return ERR_PTR(-EINVAL);
376
Eric Biggers105f2b72018-01-06 09:45:44 -0800377 ctx = file->private_data;
378 kref_get(&ctx->kref);
379 return ctx;
Davide Libenzi13389012009-06-30 11:41:11 -0700380}
381EXPORT_SYMBOL_GPL(eventfd_ctx_fileget);
382
Dominik Brodowski2fc96f82018-03-11 11:34:37 +0100383static int do_eventfd(unsigned int count, int flags)
Davide Libenzie1ad7462007-05-10 22:23:19 -0700384{
Davide Libenzie1ad7462007-05-10 22:23:19 -0700385 struct eventfd_ctx *ctx;
Eric Biggers7d815162018-01-06 09:45:42 -0800386 int fd;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700387
Ulrich Dreppere38b36f2008-07-23 21:29:42 -0700388 /* Check the EFD_* constants for consistency. */
389 BUILD_BUG_ON(EFD_CLOEXEC != O_CLOEXEC);
390 BUILD_BUG_ON(EFD_NONBLOCK != O_NONBLOCK);
391
Davide Libenzibcd0b232009-03-31 15:24:18 -0700392 if (flags & ~EFD_FLAGS_SET)
Eric Biggers7d815162018-01-06 09:45:42 -0800393 return -EINVAL;
Ulrich Drepperb087498e2008-07-23 21:29:25 -0700394
Davide Libenzie1ad7462007-05-10 22:23:19 -0700395 ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
396 if (!ctx)
Eric Biggers7d815162018-01-06 09:45:42 -0800397 return -ENOMEM;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700398
Davide Libenzi13389012009-06-30 11:41:11 -0700399 kref_init(&ctx->kref);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700400 init_waitqueue_head(&ctx->wqh);
Davide Libenzie1ad7462007-05-10 22:23:19 -0700401 ctx->count = count;
Davide Libenzibcd0b232009-03-31 15:24:18 -0700402 ctx->flags = flags;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700403
Eric Biggers7d815162018-01-06 09:45:42 -0800404 fd = anon_inode_getfd("[eventfd]", &eventfd_fops, ctx,
405 O_RDWR | (flags & EFD_SHARED_FCNTL_FLAGS));
406 if (fd < 0)
Davide Libenzi562787a2009-09-22 16:43:57 -0700407 eventfd_free_ctx(ctx);
408
Al Viro2030a422008-02-23 06:46:49 -0500409 return fd;
Davide Libenzie1ad7462007-05-10 22:23:19 -0700410}
411
Dominik Brodowski2fc96f82018-03-11 11:34:37 +0100412SYSCALL_DEFINE2(eventfd2, unsigned int, count, int, flags)
413{
414 return do_eventfd(count, flags);
415}
416
Heiko Carstensd4e82042009-01-14 14:14:34 +0100417SYSCALL_DEFINE1(eventfd, unsigned int, count)
Ulrich Drepperb087498e2008-07-23 21:29:25 -0700418{
Dominik Brodowski2fc96f82018-03-11 11:34:37 +0100419 return do_eventfd(count, 0);
Ulrich Drepperb087498e2008-07-23 21:29:25 -0700420}
Davide Libenzibcd0b232009-03-31 15:24:18 -0700421