Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[linux-2.6] / fs / eventfd.c
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>
17 #include <linux/eventfd.h>
18 #include <linux/syscalls.h>
19
20 struct eventfd_ctx {
21         wait_queue_head_t wqh;
22         /*
23          * Every time that a write(2) is performed on an eventfd, the
24          * value of the __u64 being written is added to "count" and a
25          * wakeup is performed on "wqh". A read(2) will return the "count"
26          * value to userspace, and will reset "count" to zero. The kernel
27          * size eventfd_signal() also, adds to the "count" counter and
28          * issue a wakeup.
29          */
30         __u64 count;
31         unsigned int flags;
32 };
33
34 /*
35  * Adds "n" to the eventfd counter "count". Returns "n" in case of
36  * success, or a value lower then "n" in case of coutner overflow.
37  * This function is supposed to be called by the kernel in paths
38  * that do not allow sleeping. In this function we allow the counter
39  * to reach the ULLONG_MAX value, and we signal this as overflow
40  * condition by returining a POLLERR to poll(2).
41  */
42 int eventfd_signal(struct file *file, int n)
43 {
44         struct eventfd_ctx *ctx = file->private_data;
45         unsigned long flags;
46
47         if (n < 0)
48                 return -EINVAL;
49         spin_lock_irqsave(&ctx->wqh.lock, flags);
50         if (ULLONG_MAX - ctx->count < n)
51                 n = (int) (ULLONG_MAX - ctx->count);
52         ctx->count += n;
53         if (waitqueue_active(&ctx->wqh))
54                 wake_up_locked_poll(&ctx->wqh, POLLIN);
55         spin_unlock_irqrestore(&ctx->wqh.lock, flags);
56
57         return n;
58 }
59
60 static int eventfd_release(struct inode *inode, struct file *file)
61 {
62         kfree(file->private_data);
63         return 0;
64 }
65
66 static unsigned int eventfd_poll(struct file *file, poll_table *wait)
67 {
68         struct eventfd_ctx *ctx = file->private_data;
69         unsigned int events = 0;
70         unsigned long flags;
71
72         poll_wait(file, &ctx->wqh, wait);
73
74         spin_lock_irqsave(&ctx->wqh.lock, flags);
75         if (ctx->count > 0)
76                 events |= POLLIN;
77         if (ctx->count == ULLONG_MAX)
78                 events |= POLLERR;
79         if (ULLONG_MAX - 1 > ctx->count)
80                 events |= POLLOUT;
81         spin_unlock_irqrestore(&ctx->wqh.lock, flags);
82
83         return events;
84 }
85
86 static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count,
87                             loff_t *ppos)
88 {
89         struct eventfd_ctx *ctx = file->private_data;
90         ssize_t res;
91         __u64 ucnt = 0;
92         DECLARE_WAITQUEUE(wait, current);
93
94         if (count < sizeof(ucnt))
95                 return -EINVAL;
96         spin_lock_irq(&ctx->wqh.lock);
97         res = -EAGAIN;
98         if (ctx->count > 0)
99                 res = sizeof(ucnt);
100         else if (!(file->f_flags & O_NONBLOCK)) {
101                 __add_wait_queue(&ctx->wqh, &wait);
102                 for (res = 0;;) {
103                         set_current_state(TASK_INTERRUPTIBLE);
104                         if (ctx->count > 0) {
105                                 res = sizeof(ucnt);
106                                 break;
107                         }
108                         if (signal_pending(current)) {
109                                 res = -ERESTARTSYS;
110                                 break;
111                         }
112                         spin_unlock_irq(&ctx->wqh.lock);
113                         schedule();
114                         spin_lock_irq(&ctx->wqh.lock);
115                 }
116                 __remove_wait_queue(&ctx->wqh, &wait);
117                 __set_current_state(TASK_RUNNING);
118         }
119         if (likely(res > 0)) {
120                 ucnt = (ctx->flags & EFD_SEMAPHORE) ? 1 : ctx->count;
121                 ctx->count -= ucnt;
122                 if (waitqueue_active(&ctx->wqh))
123                         wake_up_locked_poll(&ctx->wqh, POLLOUT);
124         }
125         spin_unlock_irq(&ctx->wqh.lock);
126         if (res > 0 && put_user(ucnt, (__u64 __user *) buf))
127                 return -EFAULT;
128
129         return res;
130 }
131
132 static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count,
133                              loff_t *ppos)
134 {
135         struct eventfd_ctx *ctx = file->private_data;
136         ssize_t res;
137         __u64 ucnt;
138         DECLARE_WAITQUEUE(wait, current);
139
140         if (count < sizeof(ucnt))
141                 return -EINVAL;
142         if (copy_from_user(&ucnt, buf, sizeof(ucnt)))
143                 return -EFAULT;
144         if (ucnt == ULLONG_MAX)
145                 return -EINVAL;
146         spin_lock_irq(&ctx->wqh.lock);
147         res = -EAGAIN;
148         if (ULLONG_MAX - ctx->count > ucnt)
149                 res = sizeof(ucnt);
150         else if (!(file->f_flags & O_NONBLOCK)) {
151                 __add_wait_queue(&ctx->wqh, &wait);
152                 for (res = 0;;) {
153                         set_current_state(TASK_INTERRUPTIBLE);
154                         if (ULLONG_MAX - ctx->count > ucnt) {
155                                 res = sizeof(ucnt);
156                                 break;
157                         }
158                         if (signal_pending(current)) {
159                                 res = -ERESTARTSYS;
160                                 break;
161                         }
162                         spin_unlock_irq(&ctx->wqh.lock);
163                         schedule();
164                         spin_lock_irq(&ctx->wqh.lock);
165                 }
166                 __remove_wait_queue(&ctx->wqh, &wait);
167                 __set_current_state(TASK_RUNNING);
168         }
169         if (likely(res > 0)) {
170                 ctx->count += ucnt;
171                 if (waitqueue_active(&ctx->wqh))
172                         wake_up_locked_poll(&ctx->wqh, POLLIN);
173         }
174         spin_unlock_irq(&ctx->wqh.lock);
175
176         return res;
177 }
178
179 static const struct file_operations eventfd_fops = {
180         .release        = eventfd_release,
181         .poll           = eventfd_poll,
182         .read           = eventfd_read,
183         .write          = eventfd_write,
184 };
185
186 struct file *eventfd_fget(int fd)
187 {
188         struct file *file;
189
190         file = fget(fd);
191         if (!file)
192                 return ERR_PTR(-EBADF);
193         if (file->f_op != &eventfd_fops) {
194                 fput(file);
195                 return ERR_PTR(-EINVAL);
196         }
197
198         return file;
199 }
200
201 SYSCALL_DEFINE2(eventfd2, unsigned int, count, int, flags)
202 {
203         int fd;
204         struct eventfd_ctx *ctx;
205
206         /* Check the EFD_* constants for consistency.  */
207         BUILD_BUG_ON(EFD_CLOEXEC != O_CLOEXEC);
208         BUILD_BUG_ON(EFD_NONBLOCK != O_NONBLOCK);
209
210         if (flags & ~EFD_FLAGS_SET)
211                 return -EINVAL;
212
213         ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
214         if (!ctx)
215                 return -ENOMEM;
216
217         init_waitqueue_head(&ctx->wqh);
218         ctx->count = count;
219         ctx->flags = flags;
220
221         /*
222          * When we call this, the initialization must be complete, since
223          * anon_inode_getfd() will install the fd.
224          */
225         fd = anon_inode_getfd("[eventfd]", &eventfd_fops, ctx,
226                               flags & EFD_SHARED_FCNTL_FLAGS);
227         if (fd < 0)
228                 kfree(ctx);
229         return fd;
230 }
231
232 SYSCALL_DEFINE1(eventfd, unsigned int, count)
233 {
234         return sys_eventfd2(count, 0);
235 }
236