1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2017 Joyent, Inc.
14 */
15
16 /*
17 * Support for the eventfd facility, a Linux-borne facility for user-generated
18 * file descriptor-based events.
19 */
20
21 #include <sys/ddi.h>
22 #include <sys/sunddi.h>
23 #include <sys/eventfd.h>
24 #include <sys/conf.h>
25 #include <sys/vmem.h>
26 #include <sys/sysmacros.h>
27 #include <sys/filio.h>
28 #include <sys/stat.h>
29 #include <sys/file.h>
30
31 struct eventfd_state;
32 typedef struct eventfd_state eventfd_state_t;
33
34 struct eventfd_state {
35 kmutex_t efd_lock; /* lock protecting state */
36 boolean_t efd_semaphore; /* boolean: sema. semantics */
37 kcondvar_t efd_cv; /* condvar */
38 pollhead_t efd_pollhd; /* poll head */
39 uint64_t efd_value; /* value */
40 size_t efd_bwriters; /* count of blocked writers */
41 eventfd_state_t *efd_next; /* next state on global list */
42 };
43
44 /*
45 * Internal global variables.
46 */
47 static kmutex_t eventfd_lock; /* lock protecting state */
48 static dev_info_t *eventfd_devi; /* device info */
49 static vmem_t *eventfd_minor; /* minor number arena */
50 static void *eventfd_softstate; /* softstate pointer */
51 static eventfd_state_t *eventfd_state; /* global list of state */
52
53 /*ARGSUSED*/
54 static int
55 eventfd_open(dev_t *devp, int flag, int otyp, cred_t *cred_p)
56 {
57 eventfd_state_t *state;
58 major_t major = getemajor(*devp);
59 minor_t minor = getminor(*devp);
60
61 if (minor != EVENTFDMNRN_EVENTFD)
62 return (ENXIO);
63
64 mutex_enter(&eventfd_lock);
65
66 minor = (minor_t)(uintptr_t)vmem_alloc(eventfd_minor, 1,
67 VM_BESTFIT | VM_SLEEP);
68
69 if (ddi_soft_state_zalloc(eventfd_softstate, minor) != DDI_SUCCESS) {
70 vmem_free(eventfd_minor, (void *)(uintptr_t)minor, 1);
71 mutex_exit(&eventfd_lock);
72 return (NULL);
73 }
74
75 state = ddi_get_soft_state(eventfd_softstate, minor);
76 *devp = makedevice(major, minor);
77
78 state->efd_next = eventfd_state;
79 eventfd_state = state;
80
81 mutex_exit(&eventfd_lock);
82
83 return (0);
84 }
85
86 /*ARGSUSED*/
87 static int
88 eventfd_read(dev_t dev, uio_t *uio, cred_t *cr)
89 {
90 eventfd_state_t *state;
91 minor_t minor = getminor(dev);
92 uint64_t val, oval;
93 int err;
94
95 if (uio->uio_resid < sizeof (val))
96 return (EINVAL);
97
98 state = ddi_get_soft_state(eventfd_softstate, minor);
99
100 mutex_enter(&state->efd_lock);
101
102 while (state->efd_value == 0) {
103 if (uio->uio_fmode & (FNDELAY|FNONBLOCK)) {
104 mutex_exit(&state->efd_lock);
105 return (EAGAIN);
106 }
107
108 if (!cv_wait_sig_swap(&state->efd_cv, &state->efd_lock)) {
109 mutex_exit(&state->efd_lock);
110 return (EINTR);
111 }
112 }
113
114 /*
115 * We have a non-zero value and we own the lock; our behavior now
116 * depends on whether or not EFD_SEMAPHORE was set when the eventfd
117 * was created.
118 */
119 val = oval = state->efd_value;
120
121 if (state->efd_semaphore) {
122 state->efd_value--;
123 val = 1;
124 } else {
125 state->efd_value = 0;
126 }
127
128 err = uiomove(&val, sizeof (val), UIO_READ, uio);
129
130 /*
131 * Wake any writers blocked on this eventfd as this read operation may
132 * have created adequate capacity for their values.
133 */
134 if (state->efd_bwriters != 0) {
135 cv_broadcast(&state->efd_cv);
136 }
137 mutex_exit(&state->efd_lock);
138
139 /*
140 * It is necessary to emit POLLOUT events only when the eventfd
141 * transitions from EVENTFD_VALMAX to a lower value. At all other
142 * times, it is already considered writable by poll.
143 */
144 if (oval == EVENTFD_VALMAX) {
145 pollwakeup(&state->efd_pollhd, POLLWRNORM | POLLOUT);
146 }
147
148 return (err);
149 }
150
151 /*ARGSUSED*/
152 static int
153 eventfd_write(dev_t dev, struct uio *uio, cred_t *credp)
154 {
155 eventfd_state_t *state;
156 minor_t minor = getminor(dev);
157 uint64_t val, oval;
158 int err;
159
160 if (uio->uio_resid < sizeof (val))
161 return (EINVAL);
162
163 if ((err = uiomove(&val, sizeof (val), UIO_WRITE, uio)) != 0)
164 return (err);
165
166 if (val > EVENTFD_VALMAX)
167 return (EINVAL);
168
169 state = ddi_get_soft_state(eventfd_softstate, minor);
170
171 mutex_enter(&state->efd_lock);
172
173 while (val > EVENTFD_VALMAX - state->efd_value) {
174 if (uio->uio_fmode & (FNDELAY|FNONBLOCK)) {
175 mutex_exit(&state->efd_lock);
176 return (EAGAIN);
177 }
178
179 state->efd_bwriters++;
180 if (!cv_wait_sig_swap(&state->efd_cv, &state->efd_lock)) {
181 state->efd_bwriters--;
182 mutex_exit(&state->efd_lock);
183 return (EINTR);
184 }
185 state->efd_bwriters--;
186 }
187
188 /*
189 * We now know that we can add the value without overflowing.
190 */
191 state->efd_value = (oval = state->efd_value) + val;
192
193 /*
194 * If the value was previously "empty", notify blocked readers that
195 * data is available.
196 */
197 if (oval == 0) {
198 cv_broadcast(&state->efd_cv);
199 }
200 mutex_exit(&state->efd_lock);
201
202 /*
203 * Notify pollers as well if the eventfd is now readable.
204 */
205 if (oval == 0) {
206 pollwakeup(&state->efd_pollhd, POLLRDNORM | POLLIN);
207 }
208
209 return (0);
210 }
211
212 /*ARGSUSED*/
213 static int
214 eventfd_poll(dev_t dev, short events, int anyyet, short *reventsp,
215 struct pollhead **phpp)
216 {
217 eventfd_state_t *state;
218 minor_t minor = getminor(dev);
219 short revents = 0;
220
221 state = ddi_get_soft_state(eventfd_softstate, minor);
222
223 mutex_enter(&state->efd_lock);
224
225 if (state->efd_value > 0)
226 revents |= POLLRDNORM | POLLIN;
227
228 if (state->efd_value < EVENTFD_VALMAX)
229 revents |= POLLWRNORM | POLLOUT;
230
231 *reventsp = revents & events;
232 if ((*reventsp == 0 && !anyyet) || (events & POLLET)) {
233 *phpp = &state->efd_pollhd;
234 }
235
236 mutex_exit(&state->efd_lock);
237
238 return (0);
239 }
240
241 /*ARGSUSED*/
242 static int
243 eventfd_ioctl(dev_t dev, int cmd, intptr_t arg, int md, cred_t *cr, int *rv)
244 {
245 eventfd_state_t *state;
246 minor_t minor = getminor(dev);
247
248 state = ddi_get_soft_state(eventfd_softstate, minor);
249
250 switch (cmd) {
251 case EVENTFDIOC_SEMAPHORE: {
252 mutex_enter(&state->efd_lock);
253 state->efd_semaphore ^= 1;
254 mutex_exit(&state->efd_lock);
255
256 return (0);
257 }
258
259 default:
260 break;
261 }
262
263 return (ENOTTY);
264 }
265
266 /*ARGSUSED*/
267 static int
268 eventfd_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
269 {
270 eventfd_state_t *state, **sp;
271 minor_t minor = getminor(dev);
272
273 state = ddi_get_soft_state(eventfd_softstate, minor);
274
275 if (state->efd_pollhd.ph_list != NULL) {
276 pollwakeup(&state->efd_pollhd, POLLERR);
277 pollhead_clean(&state->efd_pollhd);
278 }
279
280 mutex_enter(&eventfd_lock);
281
282 /*
283 * Remove our state from our global list.
284 */
285 for (sp = &eventfd_state; *sp != state; sp = &((*sp)->efd_next))
286 VERIFY(*sp != NULL);
287
288 *sp = (*sp)->efd_next;
289
290 ddi_soft_state_free(eventfd_softstate, minor);
291 vmem_free(eventfd_minor, (void *)(uintptr_t)minor, 1);
292
293 mutex_exit(&eventfd_lock);
294
295 return (0);
296 }
297
298 static int
299 eventfd_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
300 {
301 switch (cmd) {
302 case DDI_ATTACH:
303 break;
304
305 case DDI_RESUME:
306 return (DDI_SUCCESS);
307
308 default:
309 return (DDI_FAILURE);
310 }
311
312 mutex_enter(&eventfd_lock);
313
314 if (ddi_soft_state_init(&eventfd_softstate,
315 sizeof (eventfd_state_t), 0) != 0) {
316 cmn_err(CE_NOTE, "/dev/eventfd failed to create soft state");
317 mutex_exit(&eventfd_lock);
318 return (DDI_FAILURE);
319 }
320
321 if (ddi_create_minor_node(devi, "eventfd", S_IFCHR,
322 EVENTFDMNRN_EVENTFD, DDI_PSEUDO, NULL) == DDI_FAILURE) {
323 cmn_err(CE_NOTE, "/dev/eventfd couldn't create minor node");
324 ddi_soft_state_fini(&eventfd_softstate);
325 mutex_exit(&eventfd_lock);
326 return (DDI_FAILURE);
327 }
328
329 ddi_report_dev(devi);
330 eventfd_devi = devi;
331
332 eventfd_minor = vmem_create("eventfd_minor", (void *)EVENTFDMNRN_CLONE,
333 UINT32_MAX - EVENTFDMNRN_CLONE, 1, NULL, NULL, NULL, 0,
334 VM_SLEEP | VMC_IDENTIFIER);
335
336 mutex_exit(&eventfd_lock);
337
338 return (DDI_SUCCESS);
339 }
340
341 /*ARGSUSED*/
342 static int
343 eventfd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
344 {
345 switch (cmd) {
346 case DDI_DETACH:
347 break;
348
349 case DDI_SUSPEND:
350 return (DDI_SUCCESS);
351
352 default:
353 return (DDI_FAILURE);
354 }
355
356 mutex_enter(&eventfd_lock);
357 vmem_destroy(eventfd_minor);
358
359 ddi_remove_minor_node(eventfd_devi, NULL);
360 eventfd_devi = NULL;
361
362 ddi_soft_state_fini(&eventfd_softstate);
363 mutex_exit(&eventfd_lock);
364
365 return (DDI_SUCCESS);
366 }
367
368 /*ARGSUSED*/
369 static int
370 eventfd_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
371 {
372 int error;
373
374 switch (infocmd) {
375 case DDI_INFO_DEVT2DEVINFO:
376 *result = (void *)eventfd_devi;
377 error = DDI_SUCCESS;
378 break;
379 case DDI_INFO_DEVT2INSTANCE:
380 *result = (void *)0;
381 error = DDI_SUCCESS;
382 break;
383 default:
384 error = DDI_FAILURE;
385 }
386 return (error);
387 }
388
389 static struct cb_ops eventfd_cb_ops = {
390 eventfd_open, /* open */
391 eventfd_close, /* close */
392 nulldev, /* strategy */
393 nulldev, /* print */
394 nodev, /* dump */
395 eventfd_read, /* read */
396 eventfd_write, /* write */
397 eventfd_ioctl, /* ioctl */
398 nodev, /* devmap */
399 nodev, /* mmap */
400 nodev, /* segmap */
401 eventfd_poll, /* poll */
402 ddi_prop_op, /* cb_prop_op */
403 0, /* streamtab */
404 D_NEW | D_MP /* Driver compatibility flag */
405 };
406
407 static struct dev_ops eventfd_ops = {
408 DEVO_REV, /* devo_rev */
409 0, /* refcnt */
410 eventfd_info, /* get_dev_info */
411 nulldev, /* identify */
412 nulldev, /* probe */
413 eventfd_attach, /* attach */
414 eventfd_detach, /* detach */
415 nodev, /* reset */
416 &eventfd_cb_ops, /* driver operations */
417 NULL, /* bus operations */
418 nodev, /* dev power */
419 ddi_quiesce_not_needed, /* quiesce */
420 };
421
422 static struct modldrv modldrv = {
423 &mod_driverops, /* module type (this is a pseudo driver) */
424 "eventfd support", /* name of module */
425 &eventfd_ops, /* driver ops */
426 };
427
428 static struct modlinkage modlinkage = {
429 MODREV_1,
430 (void *)&modldrv,
431 NULL
432 };
433
434 int
435 _init(void)
436 {
437 return (mod_install(&modlinkage));
438 }
439
440 int
441 _info(struct modinfo *modinfop)
442 {
443 return (mod_info(&modlinkage, modinfop));
444 }
445
446 int
447 _fini(void)
448 {
449 return (mod_remove(&modlinkage));
450 }