usr/src/uts/common/io/eventfd.c

   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 (0);
  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         mutex_exit(&state->efd_lock);
 236
 237         return (0);
 238 }
 239
 240 /*ARGSUSED*/
 241 static int
 242 eventfd_ioctl(dev_t dev, int cmd, intptr_t arg, int md, cred_t *cr, int *rv)
 243 {
 244         eventfd_state_t *state;
 245         minor_t minor = getminor(dev);
 246
 247         state = ddi_get_soft_state(eventfd_softstate, minor);
 248
 249         switch (cmd) {
 250         case EVENTFDIOC_SEMAPHORE: {
 251                 mutex_enter(&state->efd_lock);
 252                 state->efd_semaphore ^= 1;
 253                 mutex_exit(&state->efd_lock);
 254
 255                 return (0);
 256         }
 257
 258         default:
 259                 break;
 260         }
 261
 262         return (ENOTTY);
 263 }
 264
 265 /*ARGSUSED*/
 266 static int
 267 eventfd_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
 268 {
 269         eventfd_state_t *state, **sp;
 270         minor_t minor = getminor(dev);
 271
 272         state = ddi_get_soft_state(eventfd_softstate, minor);
 273
 274         if (state->efd_pollhd.ph_list != NULL) {
 275                 pollwakeup(&state->efd_pollhd, POLLERR);
 276                 pollhead_clean(&state->efd_pollhd);
 277         }
 278
 279         mutex_enter(&eventfd_lock);
 280
 281         /*
 282          * Remove our state from our global list.
 283          */
 284         for (sp = &eventfd_state; *sp != state; sp = &((*sp)->efd_next))
 285                 VERIFY(*sp != NULL);
 286
 287         *sp = (*sp)->efd_next;
 288
 289         ddi_soft_state_free(eventfd_softstate, minor);
 290         vmem_free(eventfd_minor, (void *)(uintptr_t)minor, 1);
 291
 292         mutex_exit(&eventfd_lock);
 293
 294         return (0);
 295 }
 296
 297 static int
 298 eventfd_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
 299 {
 300         switch (cmd) {
 301         case DDI_ATTACH:
 302                 break;
 303
 304         case DDI_RESUME:
 305                 return (DDI_SUCCESS);
 306
 307         default:
 308                 return (DDI_FAILURE);
 309         }
 310
 311         mutex_enter(&eventfd_lock);
 312
 313         if (ddi_soft_state_init(&eventfd_softstate,
 314             sizeof (eventfd_state_t), 0) != 0) {
 315                 cmn_err(CE_NOTE, "/dev/eventfd failed to create soft state");
 316                 mutex_exit(&eventfd_lock);
 317                 return (DDI_FAILURE);
 318         }
 319
 320         if (ddi_create_minor_node(devi, "eventfd", S_IFCHR,
 321             EVENTFDMNRN_EVENTFD, DDI_PSEUDO, 0) == DDI_FAILURE) {
 322                 cmn_err(CE_NOTE, "/dev/eventfd couldn't create minor node");
 323                 ddi_soft_state_fini(&eventfd_softstate);
 324                 mutex_exit(&eventfd_lock);
 325                 return (DDI_FAILURE);
 326         }
 327
 328         ddi_report_dev(devi);
 329         eventfd_devi = devi;
 330
 331         eventfd_minor = vmem_create("eventfd_minor", (void *)EVENTFDMNRN_CLONE,
 332             UINT32_MAX - EVENTFDMNRN_CLONE, 1, NULL, NULL, NULL, 0,
 333             VM_SLEEP | VMC_IDENTIFIER);
 334
 335         mutex_exit(&eventfd_lock);
 336
 337         return (DDI_SUCCESS);
 338 }
 339
 340 /*ARGSUSED*/
 341 static int
 342 eventfd_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
 343 {
 344         switch (cmd) {
 345         case DDI_DETACH:
 346                 break;
 347
 348         case DDI_SUSPEND:
 349                 return (DDI_SUCCESS);
 350
 351         default:
 352                 return (DDI_FAILURE);
 353         }
 354
 355         mutex_enter(&eventfd_lock);
 356         vmem_destroy(eventfd_minor);
 357
 358         ddi_remove_minor_node(eventfd_devi, NULL);
 359         eventfd_devi = NULL;
 360
 361         ddi_soft_state_fini(&eventfd_softstate);
 362         mutex_exit(&eventfd_lock);
 363
 364         return (DDI_SUCCESS);
 365 }
 366
 367 /*ARGSUSED*/
 368 static int
 369 eventfd_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
 370 {
 371         int error;
 372
 373         switch (infocmd) {
 374         case DDI_INFO_DEVT2DEVINFO:
 375                 *result = (void *)eventfd_devi;
 376                 error = DDI_SUCCESS;
 377                 break;
 378         case DDI_INFO_DEVT2INSTANCE:
 379                 *result = NULL;
 380                 error = DDI_SUCCESS;
 381                 break;
 382         default:
 383                 error = DDI_FAILURE;
 384         }
 385         return (error);
 386 }
 387
 388 static struct cb_ops eventfd_cb_ops = {
 389         eventfd_open,           /* open */
 390         eventfd_close,          /* close */
 391         nulldev,                /* strategy */
 392         nulldev,                /* print */
 393         nodev,                  /* dump */
 394         eventfd_read,           /* read */
 395         eventfd_write,          /* write */
 396         eventfd_ioctl,          /* ioctl */
 397         nodev,                  /* devmap */
 398         nodev,                  /* mmap */
 399         nodev,                  /* segmap */
 400         eventfd_poll,           /* poll */
 401         ddi_prop_op,            /* cb_prop_op */
 402         0,                      /* streamtab  */
 403         D_NEW | D_MP            /* Driver compatibility flag */
 404 };
 405
 406 static struct dev_ops eventfd_ops = {
 407         DEVO_REV,               /* devo_rev */
 408         0,                      /* refcnt */
 409         eventfd_info,           /* get_dev_info */
 410         nulldev,                /* identify */
 411         nulldev,                /* probe */
 412         eventfd_attach,         /* attach */
 413         eventfd_detach,         /* detach */
 414         nodev,                  /* reset */
 415         &eventfd_cb_ops,        /* driver operations */
 416         NULL,                   /* bus operations */
 417         nodev,                  /* dev power */
 418         ddi_quiesce_not_needed, /* quiesce */
 419 };
 420
 421 static struct modldrv modldrv = {
 422         &mod_driverops,         /* module type (this is a pseudo driver) */
 423         "eventfd support",      /* name of module */
 424         &eventfd_ops,           /* driver ops */
 425 };
 426
 427 static struct modlinkage modlinkage = {
 428         MODREV_1,
 429         (void *)&modldrv,
 430         NULL
 431 };
 432
 433 int
 434 _init(void)
 435 {
 436         return (mod_install(&modlinkage));
 437 }
 438
 439 int
 440 _info(struct modinfo *modinfop)
 441 {
 442         return (mod_info(&modlinkage, modinfop));
 443 }
 444
 445 int
 446 _fini(void)
 447 {
 448         return (mod_remove(&modlinkage));
 449 }