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/capability.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 } 914