sys/compat/linux/linux_event.c

   1 /*-
   2  * Copyright (c) 2007 Roman Divacky
   3  * Copyright (c) 2014 Dmitry Chagin
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD$");
  30
  31 #include "opt_compat.h"
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/imgact.h>
  36 #include <sys/kernel.h>
  37 #include <sys/limits.h>
  38 #include <sys/lock.h>
  39 #include <sys/mutex.h>
  40 #include <sys/capsicum.h>
  41 #include <sys/types.h>
  42 #include <sys/user.h>
  43 #include <sys/file.h>
  44 #include <sys/filedesc.h>
  45 #include <sys/filio.h>
  46 #include <sys/errno.h>
  47 #include <sys/event.h>
  48 #include <sys/poll.h>
  49 #include <sys/proc.h>
  50 #include <sys/selinfo.h>
  51 #include <sys/sx.h>
  52 #include <sys/syscallsubr.h>
  53 #include <sys/timespec.h>
  54
  55 #ifdef COMPAT_LINUX32
  56 #include <machine/../linux32/linux.h>
  57 #include <machine/../linux32/linux32_proto.h>
  58 #else
  59 #include <machine/../linux/linux.h>
  60 #include <machine/../linux/linux_proto.h>
  61 #endif
  62
  63 #include <compat/linux/linux_emul.h>
  64 #include <compat/linux/linux_event.h>
  65 #include <compat/linux/linux_file.h>
  66 #include <compat/linux/linux_util.h>
  67
  68 /*
  69  * epoll defines 'struct epoll_event' with the field 'data' as 64 bits
  70  * on all architectures. But on 32 bit architectures BSD 'struct kevent' only
  71  * has 32 bit opaque pointer as 'udata' field. So we can't pass epoll supplied
  72  * data verbatuim. Therefore we allocate 64-bit memory block to pass
  73  * user supplied data for every file descriptor.
  74  */
  75
  76 typedef uint64_t        epoll_udata_t;
  77
  78 struct epoll_emuldata {
  79         uint32_t        fdc;            /* epoll udata max index */
  80         epoll_udata_t   udata[1];       /* epoll user data vector */
  81 };
  82
  83 #define EPOLL_DEF_SZ            16
  84 #define EPOLL_SIZE(fdn)                 \
  85         (sizeof(struct epoll_emuldata)+(fdn) * sizeof(epoll_udata_t))
  86
  87 struct epoll_event {
  88         uint32_t        events;
  89         epoll_udata_t   data;
  90 }
  91 #if defined(__amd64__)
  92 __attribute__((packed))
  93 #endif
  94 ;
  95
  96 #define LINUX_MAX_EVENTS        (INT_MAX / sizeof(struct epoll_event))
  97
  98 static void     epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata);
  99 static int      epoll_to_kevent(struct thread *td, struct file *epfp,
 100                     int fd, struct epoll_event *l_event, int *kev_flags,
 101                     struct kevent *kevent, int *nkevents);
 102 static void     kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event);
 103 static int      epoll_kev_copyout(void *arg, struct kevent *kevp, int count);
 104 static int      epoll_kev_copyin(void *arg, struct kevent *kevp, int count);
 105 static int      epoll_delete_event(struct thread *td, struct file *epfp,
 106                     int fd, int filter);
 107 static int      epoll_delete_all_events(struct thread *td, struct file *epfp,
 108                     int fd);
 109
 110 struct epoll_copyin_args {
 111         struct kevent   *changelist;
 112 };
 113
 114 struct epoll_copyout_args {
 115         struct epoll_event      *leventlist;
 116         struct proc             *p;
 117         uint32_t                count;
 118         int                     error;
 119 };
 120
 121 /* eventfd */
 122 typedef uint64_t        eventfd_t;
 123
 124 static fo_rdwr_t        eventfd_read;
 125 static fo_rdwr_t        eventfd_write;
 126 static fo_truncate_t    eventfd_truncate;
 127 static fo_ioctl_t       eventfd_ioctl;
 128 static fo_poll_t        eventfd_poll;
 129 static fo_kqfilter_t    eventfd_kqfilter;
 130 static fo_stat_t        eventfd_stat;
 131 static fo_close_t       eventfd_close;
 132 static fo_fill_kinfo_t  eventfd_fill_kinfo;
 133
 134 static struct fileops eventfdops = {
 135         .fo_read = eventfd_read,
 136         .fo_write = eventfd_write,
 137         .fo_truncate = eventfd_truncate,
 138         .fo_ioctl = eventfd_ioctl,
 139         .fo_poll = eventfd_poll,
 140         .fo_kqfilter = eventfd_kqfilter,
 141         .fo_stat = eventfd_stat,
 142         .fo_close = eventfd_close,
 143         .fo_chmod = invfo_chmod,
 144         .fo_chown = invfo_chown,
 145         .fo_sendfile = invfo_sendfile,
 146         .fo_fill_kinfo = eventfd_fill_kinfo,
 147         .fo_flags = DFLAG_PASSABLE
 148 };
 149
 150 static void     filt_eventfddetach(struct knote *kn);
 151 static int      filt_eventfdread(struct knote *kn, long hint);
 152 static int      filt_eventfdwrite(struct knote *kn, long hint);
 153
 154 static struct filterops eventfd_rfiltops = {
 155         .f_isfd = 1,
 156         .f_detach = filt_eventfddetach,
 157         .f_event = filt_eventfdread
 158 };
 159 static struct filterops eventfd_wfiltops = {
 160         .f_isfd = 1,
 161         .f_detach = filt_eventfddetach,
 162         .f_event = filt_eventfdwrite
 163 };
 164
 165 struct eventfd {
 166         eventfd_t       efd_count;
 167         uint32_t        efd_flags;
 168         struct selinfo  efd_sel;
 169         struct mtx      efd_lock;
 170 };
 171
 172 static int      eventfd_create(struct thread *td, uint32_t initval, int flags);
 173
 174
 175 static void
 176 epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata)
 177 {
 178         struct linux_pemuldata *pem;
 179         struct epoll_emuldata *emd;
 180         struct proc *p;
 181
 182         p = td->td_proc;
 183
 184         pem = pem_find(p);
 185         KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
 186
 187         LINUX_PEM_XLOCK(pem);
 188         if (pem->epoll == NULL) {
 189                 emd = malloc(EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
 190                 emd->fdc = fd;
 191                 pem->epoll = emd;
 192         } else {
 193                 emd = pem->epoll;
 194                 if (fd > emd->fdc) {
 195                         emd = realloc(emd, EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
 196                         emd->fdc = fd;
 197                         pem->epoll = emd;
 198                 }
 199         }
 200         emd->udata[fd] = udata;
 201         LINUX_PEM_XUNLOCK(pem);
 202 }
 203
 204 static int
 205 epoll_create_common(struct thread *td, int flags)
 206 {
 207         int error;
 208
 209         error = kern_kqueue(td, flags, NULL);
 210         if (error)
 211                 return (error);
 212
 213         epoll_fd_install(td, EPOLL_DEF_SZ, 0);
 214
 215         return (0);
 216 }
 217
 218 int
 219 linux_epoll_create(struct thread *td, struct linux_epoll_create_args *args)
 220 {
 221
 222         /*
 223          * args->size is unused. Linux just tests it
 224          * and then forgets it as well.
 225          */
 226         if (args->size <= 0)
 227                 return (EINVAL);
 228
 229         return (epoll_create_common(td, 0));
 230 }
 231
 232 int
 233 linux_epoll_create1(struct thread *td, struct linux_epoll_create1_args *args)
 234 {
 235         int flags;
 236
 237         if ((args->flags & ~(LINUX_O_CLOEXEC)) != 0)
 238                 return (EINVAL);
 239
 240         flags = 0;
 241         if ((args->flags & LINUX_O_CLOEXEC) != 0)
 242                 flags |= O_CLOEXEC;
 243
 244         return (epoll_create_common(td, flags));
 245 }
 246
 247 /* Structure converting function from epoll to kevent. */
 248 static int
 249 epoll_to_kevent(struct thread *td, struct file *epfp,
 250     int fd, struct epoll_event *l_event, int *kev_flags,
 251     struct kevent *kevent, int *nkevents)
 252 {
 253         uint32_t levents = l_event->events;
 254         struct linux_pemuldata *pem;
 255         struct proc *p;
 256
 257         /* flags related to how event is registered */
 258         if ((levents & LINUX_EPOLLONESHOT) != 0)
 259                 *kev_flags |= EV_ONESHOT;
 260         if ((levents & LINUX_EPOLLET) != 0)
 261                 *kev_flags |= EV_CLEAR;
 262         if ((levents & LINUX_EPOLLERR) != 0)
 263                 *kev_flags |= EV_ERROR;
 264         if ((levents & LINUX_EPOLLRDHUP) != 0)
 265                 *kev_flags |= EV_EOF;
 266
 267         /* flags related to what event is registered */
 268         if ((levents & LINUX_EPOLL_EVRD) != 0) {
 269                 EV_SET(kevent++, fd, EVFILT_READ, *kev_flags, 0, 0, 0);
 270                 ++(*nkevents);
 271         }
 272         if ((levents & LINUX_EPOLL_EVWR) != 0) {
 273                 EV_SET(kevent++, fd, EVFILT_WRITE, *kev_flags, 0, 0, 0);
 274                 ++(*nkevents);
 275         }
 276
 277         if ((levents & ~(LINUX_EPOLL_EVSUP)) != 0) {
 278                 p = td->td_proc;
 279
 280                 pem = pem_find(p);
 281                 KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
 282                 KASSERT(pem->epoll != NULL, ("epoll proc epolldata not found.\n"));
 283
 284                 LINUX_PEM_XLOCK(pem);
 285                 if ((pem->flags & LINUX_XUNSUP_EPOLL) == 0) {
 286                         pem->flags |= LINUX_XUNSUP_EPOLL;
 287                         LINUX_PEM_XUNLOCK(pem);
 288                         linux_msg(td, "epoll_ctl unsupported flags: 0x%x\n",
 289                             levents);
 290                 } else
 291                         LINUX_PEM_XUNLOCK(pem);
 292                 return (EINVAL);
 293         }
 294
 295         return (0);
 296 }
 297
 298 /*
 299  * Structure converting function from kevent to epoll. In a case
 300  * this is called on error in registration we store the error in
 301  * event->data and pick it up later in linux_epoll_ctl().
 302  */
 303 static void
 304 kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event)
 305 {
 306
 307         if ((kevent->flags & EV_ERROR) != 0) {
 308                 l_event->events = LINUX_EPOLLERR;
 309                 return;
 310         }
 311
 312         switch (kevent->filter) {
 313         case EVFILT_READ:
 314                 l_event->events = LINUX_EPOLLIN|LINUX_EPOLLRDNORM|LINUX_EPOLLPRI;
 315                 if ((kevent->flags & EV_EOF) != 0)
 316                         l_event->events |= LINUX_EPOLLRDHUP;
 317         break;
 318         case EVFILT_WRITE:
 319                 l_event->events = LINUX_EPOLLOUT|LINUX_EPOLLWRNORM;
 320         break;
 321         }
 322 }
 323
 324 /*
 325  * Copyout callback used by kevent. This converts kevent
 326  * events to epoll events and copies them back to the
 327  * userspace. This is also called on error on registering
 328  * of the filter.
 329  */
 330 static int
 331 epoll_kev_copyout(void *arg, struct kevent *kevp, int count)
 332 {
 333         struct epoll_copyout_args *args;
 334         struct linux_pemuldata *pem;
 335         struct epoll_emuldata *emd;
 336         struct epoll_event *eep;
 337         int error, fd, i;
 338
 339         args = (struct epoll_copyout_args*) arg;
 340         eep = malloc(sizeof(*eep) * count, M_EPOLL, M_WAITOK | M_ZERO);
 341
 342         pem = pem_find(args->p);
 343         KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
 344         LINUX_PEM_SLOCK(pem);
 345         emd = pem->epoll;
 346         KASSERT(emd != NULL, ("epoll proc epolldata not found.\n"));
 347
 348         for (i = 0; i < count; i++) {
 349                 kevent_to_epoll(&kevp[i], &eep[i]);
 350
 351                 fd = kevp[i].ident;
 352                 KASSERT(fd <= emd->fdc, ("epoll user data vector"
 353                                                     " is too small.\n"));
 354                 eep[i].data = emd->udata[fd];
 355         }
 356         LINUX_PEM_SUNLOCK(pem);
 357
 358         error = copyout(eep, args->leventlist, count * sizeof(*eep));
 359         if (error == 0) {
 360                 args->leventlist += count;
 361                 args->count += count;
 362         } else if (args->error == 0)
 363                 args->error = error;
 364
 365         free(eep, M_EPOLL);
 366         return (error);
 367 }
 368
 369 /*
 370  * Copyin callback used by kevent. This copies already
 371  * converted filters from kernel memory to the kevent
 372  * internal kernel memory. Hence the memcpy instead of
 373  * copyin.
 374  */
 375 static int
 376 epoll_kev_copyin(void *arg, struct kevent *kevp, int count)
 377 {
 378         struct epoll_copyin_args *args;
 379
 380         args = (struct epoll_copyin_args*) arg;
 381
 382         memcpy(kevp, args->changelist, count * sizeof(*kevp));
 383         args->changelist += count;
 384
 385         return (0);
 386 }
 387
 388 /*
 389  * Load epoll filter, convert it to kevent filter
 390  * and load it into kevent subsystem.
 391  */
 392 int
 393 linux_epoll_ctl(struct thread *td, struct linux_epoll_ctl_args *args)
 394 {
 395         struct file *epfp, *fp;
 396         struct epoll_copyin_args ciargs;
 397         struct kevent kev[2];
 398         struct kevent_copyops k_ops = { &ciargs,
 399                                         NULL,
 400                                         epoll_kev_copyin};
 401         struct epoll_event le;
 402         cap_rights_t rights;
 403         int kev_flags;
 404         int nchanges = 0;
 405         int error;
 406
 407         if (args->op != LINUX_EPOLL_CTL_DEL) {
 408                 error = copyin(args->event, &le, sizeof(le));
 409                 if (error != 0)
 410                         return (error);
 411         }
 412
 413         error = fget(td, args->epfd,
 414             cap_rights_init(&rights, CAP_KQUEUE_CHANGE), &epfp);
 415         if (error != 0)
 416                 return (error);
 417         if (epfp->f_type != DTYPE_KQUEUE)
 418                 goto leave1;
 419
 420          /* Protect user data vector from incorrectly supplied fd. */
 421         error = fget(td, args->fd, cap_rights_init(&rights, CAP_POLL_EVENT), &fp);
 422         if (error != 0)
 423                 goto leave1;
 424
 425         /* Linux disallows spying on himself */
 426         if (epfp == fp) {
 427                 error = EINVAL;
 428                 goto leave0;
 429         }
 430
 431         ciargs.changelist = kev;
 432
 433         switch (args->op) {
 434         case LINUX_EPOLL_CTL_MOD:
 435                 /*
 436                  * We don't memorize which events were set for this FD
 437                  * on this level, so just delete all we could have set:
 438                  * EVFILT_READ and EVFILT_WRITE, ignoring any errors
 439                  */
 440                 error = epoll_delete_all_events(td, epfp, args->fd);
 441                 if (error)
 442                         goto leave0;
 443                 /* FALLTHROUGH */
 444
 445         case LINUX_EPOLL_CTL_ADD:
 446                         kev_flags = EV_ADD | EV_ENABLE;
 447                 break;
 448
 449         case LINUX_EPOLL_CTL_DEL:
 450                 /* CTL_DEL means unregister this fd with this epoll */
 451                 error = epoll_delete_all_events(td, epfp, args->fd);
 452                 goto leave0;
 453
 454         default:
 455                 error = EINVAL;
 456                 goto leave0;
 457         }
 458
 459         error = epoll_to_kevent(td, epfp, args->fd, &le, &kev_flags,
 460             kev, &nchanges);
 461         if (error)
 462                 goto leave0;
 463
 464         epoll_fd_install(td, args->fd, le.data);
 465
 466         error = kern_kevent_fp(td, epfp, nchanges, 0, &k_ops, NULL);
 467
 468 leave0:
 469         fdrop(fp, td);
 470
 471 leave1:
 472         fdrop(epfp, td);
 473         return (error);
 474 }
 475
 476 /*
 477  * Wait for a filter to be triggered on the epoll file descriptor.
 478  */
 479 static int
 480 linux_epoll_wait_common(struct thread *td, int epfd, struct epoll_event *events,
 481     int maxevents, int timeout, sigset_t *uset)
 482 {
 483         struct file *epfp;
 484         struct timespec ts, *tsp;
 485         cap_rights_t rights;
 486         struct epoll_copyout_args coargs;
 487         struct kevent_copyops k_ops = { &coargs,
 488                                         epoll_kev_copyout,
 489                                         NULL};
 490         int error;
 491
 492         if (maxevents <= 0 || maxevents > LINUX_MAX_EVENTS)
 493                 return (EINVAL);
 494
 495         if (uset != NULL) {
 496                 error = kern_sigprocmask(td, SIG_SETMASK, uset,
 497                     &td->td_oldsigmask, 0);
 498                 if (error != 0)
 499                         return (error);
 500                 td->td_pflags |= TDP_OLDMASK;
 501                 /*
 502                  * Make sure that ast() is called on return to
 503                  * usermode and TDP_OLDMASK is cleared, restoring old
 504                  * sigmask.
 505                  */
 506                 thread_lock(td);
 507                 td->td_flags |= TDF_ASTPENDING;
 508                 thread_unlock(td);
 509         }
 510
 511         error = fget(td, epfd,
 512             cap_rights_init(&rights, CAP_KQUEUE_EVENT), &epfp);
 513         if (error != 0)
 514                 return (error);
 515
 516         coargs.leventlist = events;
 517         coargs.p = td->td_proc;
 518         coargs.count = 0;
 519         coargs.error = 0;
 520
 521         if (timeout != -1) {
 522                 if (timeout < 0) {
 523                         error = EINVAL;
 524                         goto leave;
 525                 }
 526                 /* Convert from milliseconds to timespec. */
 527                 ts.tv_sec = timeout / 1000;
 528                 ts.tv_nsec = (timeout % 1000) * 1000000;
 529                 tsp = &ts;
 530         } else {
 531                 tsp = NULL;
 532         }
 533
 534         error = kern_kevent_fp(td, epfp, 0, maxevents, &k_ops, tsp);
 535         if (error == 0 && coargs.error != 0)
 536                 error = coargs.error;
 537
 538         /*
 539          * kern_kevent might return ENOMEM which is not expected from epoll_wait.
 540          * Maybe we should translate that but I don't think it matters at all.
 541          */
 542         if (error == 0)
 543                 td->td_retval[0] = coargs.count;
 544 leave:
 545         fdrop(epfp, td);
 546         return (error);
 547 }
 548
 549 int
 550 linux_epoll_wait(struct thread *td, struct linux_epoll_wait_args *args)
 551 {
 552
 553         return (linux_epoll_wait_common(td, args->epfd, args->events,
 554             args->maxevents, args->timeout, NULL));
 555 }
 556
 557 int
 558 linux_epoll_pwait(struct thread *td, struct linux_epoll_pwait_args *args)
 559 {
 560         sigset_t mask, *pmask;
 561         l_sigset_t lmask;
 562         int error;
 563
 564         if (args->mask != NULL) {
 565                 error = copyin(args->mask, &lmask, sizeof(l_sigset_t));
 566                 if (error != 0)
 567                         return (error);
 568                 linux_to_bsd_sigset(&lmask, &mask);
 569                 pmask = &mask;
 570         } else
 571                 pmask = NULL;
 572         return (linux_epoll_wait_common(td, args->epfd, args->events,
 573             args->maxevents, args->timeout, pmask));
 574 }
 575
 576 static int
 577 epoll_delete_event(struct thread *td, struct file *epfp, int fd, int filter)
 578 {
 579         struct epoll_copyin_args ciargs;
 580         struct kevent kev;
 581         struct kevent_copyops k_ops = { &ciargs,
 582                                         NULL,
 583                                         epoll_kev_copyin};
 584         int error;
 585
 586         ciargs.changelist = &kev;
 587         EV_SET(&kev, fd, filter, EV_DELETE | EV_DISABLE, 0, 0, 0);
 588
 589         error = kern_kevent_fp(td, epfp, 1, 0, &k_ops, NULL);
 590
 591         /*
 592          * here we ignore ENONT, because we don't keep track of events here
 593          */
 594         if (error == ENOENT)
 595                 error = 0;
 596         return (error);
 597 }
 598
 599 static int
 600 epoll_delete_all_events(struct thread *td, struct file *epfp, int fd)
 601 {
 602         int error1, error2;
 603
 604         error1 = epoll_delete_event(td, epfp, fd, EVFILT_READ);
 605         error2 = epoll_delete_event(td, epfp, fd, EVFILT_WRITE);
 606
 607         /* report any errors we got */
 608         return (error1 == 0 ? error2 : error1);
 609 }
 610
 611 static int
 612 eventfd_create(struct thread *td, uint32_t initval, int flags)
 613 {
 614         struct filedesc *fdp;
 615         struct eventfd *efd;
 616         struct file *fp;
 617         int fflags, fd, error;
 618
 619         fflags = 0;
 620         if ((flags & LINUX_O_CLOEXEC) != 0)
 621                 fflags |= O_CLOEXEC;
 622
 623         fdp = td->td_proc->p_fd;
 624         error = falloc(td, &fp, &fd, fflags);
 625         if (error)
 626                 return (error);
 627
 628         efd = malloc(sizeof(*efd), M_EPOLL, M_WAITOK | M_ZERO);
 629         efd->efd_flags = flags;
 630         efd->efd_count = initval;
 631         mtx_init(&efd->efd_lock, "eventfd", NULL, MTX_DEF);
 632
 633         knlist_init_mtx(&efd->efd_sel.si_note, &efd->efd_lock);
 634
 635         fflags = FREAD | FWRITE;
 636         if ((flags & LINUX_O_NONBLOCK) != 0)
 637                 fflags |= FNONBLOCK;
 638
 639         finit(fp, fflags, DTYPE_LINUXEFD, efd, &eventfdops);
 640         fdrop(fp, td);
 641
 642         td->td_retval[0] = fd;
 643         return (error);
 644 }
 645
 646 int
 647 linux_eventfd(struct thread *td, struct linux_eventfd_args *args)
 648 {
 649
 650         return (eventfd_create(td, args->initval, 0));
 651 }
 652
 653 int
 654 linux_eventfd2(struct thread *td, struct linux_eventfd2_args *args)
 655 {
 656
 657         if ((args->flags & ~(LINUX_O_CLOEXEC|LINUX_O_NONBLOCK|LINUX_EFD_SEMAPHORE)) != 0)
 658                 return (EINVAL);
 659
 660         return (eventfd_create(td, args->initval, args->flags));
 661 }
 662
 663 static int
 664 eventfd_close(struct file *fp, struct thread *td)
 665 {
 666         struct eventfd *efd;
 667
 668         efd = fp->f_data;
 669         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 670                 return (EBADF);
 671
 672         seldrain(&efd->efd_sel);
 673         knlist_destroy(&efd->efd_sel.si_note);
 674
 675         fp->f_ops = &badfileops;
 676         mtx_destroy(&efd->efd_lock);
 677         free(efd, M_EPOLL);
 678
 679         return (0);
 680 }
 681
 682 static int
 683 eventfd_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
 684         int flags, struct thread *td)
 685 {
 686         struct eventfd *efd;
 687         eventfd_t count;
 688         int error;
 689
 690         efd = fp->f_data;
 691         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 692                 return (EBADF);
 693
 694         if (uio->uio_resid < sizeof(eventfd_t))
 695                 return (EINVAL);
 696
 697         error = 0;
 698         mtx_lock(&efd->efd_lock);
 699 retry:
 700         if (efd->efd_count == 0) {
 701                 if ((efd->efd_flags & LINUX_O_NONBLOCK) != 0) {
 702                         mtx_unlock(&efd->efd_lock);
 703                         return (EAGAIN);
 704                 }
 705                 error = mtx_sleep(&efd->efd_count, &efd->efd_lock, PCATCH, "lefdrd", 0);
 706                 if (error == 0)
 707                         goto retry;
 708         }
 709         if (error == 0) {
 710                 if ((efd->efd_flags & LINUX_EFD_SEMAPHORE) != 0) {
 711                         count = 1;
 712                         --efd->efd_count;
 713                 } else {
 714                         count = efd->efd_count;
 715                         efd->efd_count = 0;
 716                 }
 717                 KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
 718                 selwakeup(&efd->efd_sel);
 719                 wakeup(&efd->efd_count);
 720                 mtx_unlock(&efd->efd_lock);
 721                 error = uiomove(&count, sizeof(eventfd_t), uio);
 722         } else
 723                 mtx_unlock(&efd->efd_lock);
 724
 725         return (error);
 726 }
 727
 728 static int
 729 eventfd_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
 730          int flags, struct thread *td)
 731 {
 732         struct eventfd *efd;
 733         eventfd_t count;
 734         int error;
 735
 736         efd = fp->f_data;
 737         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 738                 return (EBADF);
 739
 740         if (uio->uio_resid < sizeof(eventfd_t))
 741                 return (EINVAL);
 742
 743         error = uiomove(&count, sizeof(eventfd_t), uio);
 744         if (error)
 745                 return (error);
 746         if (count == UINT64_MAX)
 747                 return (EINVAL);
 748
 749         mtx_lock(&efd->efd_lock);
 750 retry:
 751         if (UINT64_MAX - efd->efd_count <= count) {
 752                 if ((efd->efd_flags & LINUX_O_NONBLOCK) != 0) {
 753                         mtx_unlock(&efd->efd_lock);
 754                         /* Do not not return the number of bytes written */
 755                         uio->uio_resid += sizeof(eventfd_t);
 756                         return (EAGAIN);
 757                 }
 758                 error = mtx_sleep(&efd->efd_count, &efd->efd_lock,
 759                     PCATCH, "lefdwr", 0);
 760                 if (error == 0)
 761                         goto retry;
 762         }
 763         if (error == 0) {
 764                 efd->efd_count += count;
 765                 KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
 766                 selwakeup(&efd->efd_sel);
 767                 wakeup(&efd->efd_count);
 768         }
 769         mtx_unlock(&efd->efd_lock);
 770
 771         return (error);
 772 }
 773
 774 static int
 775 eventfd_poll(struct file *fp, int events, struct ucred *active_cred,
 776         struct thread *td)
 777 {
 778         struct eventfd *efd;
 779         int revents = 0;
 780
 781         efd = fp->f_data;
 782         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 783                 return (POLLERR);
 784
 785         mtx_lock(&efd->efd_lock);
 786         if ((events & (POLLIN|POLLRDNORM)) && efd->efd_count > 0)
 787                 revents |= events & (POLLIN|POLLRDNORM);
 788         if ((events & (POLLOUT|POLLWRNORM)) && UINT64_MAX - 1 > efd->efd_count)
 789                 revents |= events & (POLLOUT|POLLWRNORM);
 790         if (revents == 0)
 791                 selrecord(td, &efd->efd_sel);
 792         mtx_unlock(&efd->efd_lock);
 793
 794         return (revents);
 795 }
 796
 797 /*ARGSUSED*/
 798 static int
 799 eventfd_kqfilter(struct file *fp, struct knote *kn)
 800 {
 801         struct eventfd *efd;
 802
 803         efd = fp->f_data;
 804         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 805                 return (EINVAL);
 806
 807         mtx_lock(&efd->efd_lock);
 808         switch (kn->kn_filter) {
 809         case EVFILT_READ:
 810                 kn->kn_fop = &eventfd_rfiltops;
 811                 break;
 812         case EVFILT_WRITE:
 813                 kn->kn_fop = &eventfd_wfiltops;
 814                 break;
 815         default:
 816                 mtx_unlock(&efd->efd_lock);
 817                 return (EINVAL);
 818         }
 819
 820         kn->kn_hook = efd;
 821         knlist_add(&efd->efd_sel.si_note, kn, 1);
 822         mtx_unlock(&efd->efd_lock);
 823
 824         return (0);
 825 }
 826
 827 static void
 828 filt_eventfddetach(struct knote *kn)
 829 {
 830         struct eventfd *efd = kn->kn_hook;
 831
 832         mtx_lock(&efd->efd_lock);
 833         knlist_remove(&efd->efd_sel.si_note, kn, 1);
 834         mtx_unlock(&efd->efd_lock);
 835 }
 836
 837 /*ARGSUSED*/
 838 static int
 839 filt_eventfdread(struct knote *kn, long hint)
 840 {
 841         struct eventfd *efd = kn->kn_hook;
 842         int ret;
 843
 844         mtx_assert(&efd->efd_lock, MA_OWNED);
 845         ret = (efd->efd_count > 0);
 846
 847         return (ret);
 848 }
 849
 850 /*ARGSUSED*/
 851 static int
 852 filt_eventfdwrite(struct knote *kn, long hint)
 853 {
 854         struct eventfd *efd = kn->kn_hook;
 855         int ret;
 856
 857         mtx_assert(&efd->efd_lock, MA_OWNED);
 858         ret = (UINT64_MAX - 1 > efd->efd_count);
 859
 860         return (ret);
 861 }
 862
 863 /*ARGSUSED*/
 864 static int
 865 eventfd_truncate(struct file *fp, off_t length, struct ucred *active_cred,
 866         struct thread *td)
 867 {
 868
 869         return (ENXIO);
 870 }
 871
 872 /*ARGSUSED*/
 873 static int
 874 eventfd_ioctl(struct file *fp, u_long cmd, void *data,
 875         struct ucred *active_cred, struct thread *td)
 876 {
 877         struct eventfd *efd;
 878
 879         efd = fp->f_data;
 880         if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
 881                 return (EINVAL);
 882
 883         switch (cmd)
 884         {
 885         case FIONBIO:
 886                 if (*(int *)data)
 887                         efd->efd_flags |= LINUX_O_NONBLOCK;
 888                 else
 889                         efd->efd_flags &= ~LINUX_O_NONBLOCK;
 890         case FIOASYNC:
 891                 return (0);
 892         default:
 893                 return (ENXIO);
 894         }
 895 }
 896
 897 /*ARGSUSED*/
 898 static int
 899 eventfd_stat(struct file *fp, struct stat *st, struct ucred *active_cred,
 900         struct thread *td)
 901 {
 902
 903         return (ENXIO);
 904 }
 905
 906 /*ARGSUSED*/
 907 static int
 908 eventfd_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
 909 {
 910
 911         kif->kf_type = KF_TYPE_UNKNOWN;
 912         return (0);
 913 }