sys_eventfd.c revision 1.9.4.1
1 /* $NetBSD: sys_eventfd.c,v 1.9.4.1 2023/11/26 12:33:19 bouyer Exp $ */ 2 3 /*- 4 * Copyright (c) 2020 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #include <sys/cdefs.h> 33 __KERNEL_RCSID(0, "$NetBSD: sys_eventfd.c,v 1.9.4.1 2023/11/26 12:33:19 bouyer Exp $"); 34 35 /* 36 * eventfd 37 * 38 * Eventfd objects present a simple counting object associated with a 39 * file descriptor. Writes and reads to this file descriptor increment 40 * and decrement the count, respectively. When the count is non-zero, 41 * the descriptor is considered "readable", and when less than the max 42 * value (EVENTFD_MAXVAL), is considered "writable". 43 * 44 * This implementation is API compatible with the Linux eventfd(2) 45 * interface. 46 */ 47 48 #include <sys/param.h> 49 #include <sys/types.h> 50 #include <sys/condvar.h> 51 #include <sys/eventfd.h> 52 #include <sys/file.h> 53 #include <sys/filedesc.h> 54 #include <sys/kauth.h> 55 #include <sys/mutex.h> 56 #include <sys/poll.h> 57 #include <sys/proc.h> 58 #include <sys/select.h> 59 #include <sys/stat.h> 60 #include <sys/syscallargs.h> 61 #include <sys/uio.h> 62 63 struct eventfd { 64 kmutex_t efd_lock; 65 kcondvar_t efd_read_wait; 66 kcondvar_t efd_write_wait; 67 struct selinfo efd_read_sel; 68 struct selinfo efd_write_sel; 69 eventfd_t efd_val; 70 int64_t efd_nwaiters; 71 bool efd_restarting; 72 bool efd_is_semaphore; 73 74 /* 75 * Information kept for stat(2). 76 */ 77 struct timespec efd_btime; /* time created */ 78 struct timespec efd_mtime; /* last write */ 79 struct timespec efd_atime; /* last read */ 80 }; 81 82 #define EVENTFD_MAXVAL (UINT64_MAX - 1) 83 84 /* 85 * eventfd_create: 86 * 87 * Create an eventfd object. 88 */ 89 static struct eventfd * 90 eventfd_create(unsigned int const val, int const flags) 91 { 92 struct eventfd * const efd = kmem_zalloc(sizeof(*efd), KM_SLEEP); 93 94 mutex_init(&efd->efd_lock, MUTEX_DEFAULT, IPL_NONE); 95 cv_init(&efd->efd_read_wait, "efdread"); 96 cv_init(&efd->efd_write_wait, "efdwrite"); 97 selinit(&efd->efd_read_sel); 98 selinit(&efd->efd_write_sel); 99 efd->efd_val = val; 100 efd->efd_is_semaphore = !!(flags & EFD_SEMAPHORE); 101 getnanotime(&efd->efd_btime); 102 103 /* Caller deals with EFD_CLOEXEC and EFD_NONBLOCK. */ 104 105 return efd; 106 } 107 108 /* 109 * eventfd_destroy: 110 * 111 * Destroy an eventfd object. 112 */ 113 static void 114 eventfd_destroy(struct eventfd * const efd) 115 { 116 117 KASSERT(efd->efd_nwaiters == 0); 118 119 cv_destroy(&efd->efd_read_wait); 120 cv_destroy(&efd->efd_write_wait); 121 122 seldestroy(&efd->efd_read_sel); 123 seldestroy(&efd->efd_write_sel); 124 125 mutex_destroy(&efd->efd_lock); 126 127 kmem_free(efd, sizeof(*efd)); 128 } 129 130 /* 131 * eventfd_wait: 132 * 133 * Block on an eventfd. Handles non-blocking, as well as 134 * the restart cases. 135 */ 136 static int 137 eventfd_wait(struct eventfd * const efd, int const fflag, bool const is_write) 138 { 139 kcondvar_t *waitcv; 140 int error; 141 142 if (fflag & FNONBLOCK) { 143 return EAGAIN; 144 } 145 146 /* 147 * We're going to block. Check if we need to return ERESTART. 148 */ 149 if (efd->efd_restarting) { 150 return ERESTART; 151 } 152 153 if (is_write) { 154 waitcv = &efd->efd_write_wait; 155 } else { 156 waitcv = &efd->efd_read_wait; 157 } 158 159 efd->efd_nwaiters++; 160 KASSERT(efd->efd_nwaiters > 0); 161 error = cv_wait_sig(waitcv, &efd->efd_lock); 162 efd->efd_nwaiters--; 163 KASSERT(efd->efd_nwaiters >= 0); 164 165 /* 166 * If a restart was triggered while we were asleep, we need 167 * to return ERESTART if no other error was returned. 168 */ 169 if (efd->efd_restarting) { 170 if (error == 0) { 171 error = ERESTART; 172 } 173 } 174 175 return error; 176 } 177 178 /* 179 * eventfd_wake: 180 * 181 * Wake LWPs block on an eventfd. 182 */ 183 static void 184 eventfd_wake(struct eventfd * const efd, bool const is_write) 185 { 186 kcondvar_t *waitcv = NULL; 187 struct selinfo *sel; 188 int pollev; 189 190 if (is_write) { 191 waitcv = &efd->efd_read_wait; 192 sel = &efd->efd_read_sel; 193 pollev = POLLIN | POLLRDNORM; 194 } else { 195 waitcv = &efd->efd_write_wait; 196 sel = &efd->efd_write_sel; 197 pollev = POLLOUT | POLLWRNORM; 198 } 199 if (waitcv != NULL) { 200 cv_broadcast(waitcv); 201 } 202 selnotify(sel, pollev, NOTE_SUBMIT); 203 } 204 205 /* 206 * eventfd file operations 207 */ 208 209 static int 210 eventfd_fop_read(file_t * const fp, off_t * const offset, 211 struct uio * const uio, kauth_cred_t const cred, int const flags) 212 { 213 struct eventfd * const efd = fp->f_eventfd; 214 int const fflag = fp->f_flag; 215 eventfd_t return_value; 216 int error; 217 218 if (uio->uio_resid < sizeof(eventfd_t)) { 219 return EINVAL; 220 } 221 222 mutex_enter(&efd->efd_lock); 223 224 while (efd->efd_val == 0) { 225 if ((error = eventfd_wait(efd, fflag, false)) != 0) { 226 mutex_exit(&efd->efd_lock); 227 return error; 228 } 229 } 230 231 if (efd->efd_is_semaphore) { 232 return_value = 1; 233 efd->efd_val--; 234 } else { 235 return_value = efd->efd_val; 236 efd->efd_val = 0; 237 } 238 239 getnanotime(&efd->efd_atime); 240 eventfd_wake(efd, false); 241 242 mutex_exit(&efd->efd_lock); 243 244 error = uiomove(&return_value, sizeof(return_value), uio); 245 246 return error; 247 } 248 249 static int 250 eventfd_fop_write(file_t * const fp, off_t * const offset, 251 struct uio * const uio, kauth_cred_t const cred, int const flags) 252 { 253 struct eventfd * const efd = fp->f_eventfd; 254 int const fflag = fp->f_flag; 255 eventfd_t write_value; 256 int error; 257 258 if (uio->uio_resid < sizeof(eventfd_t)) { 259 return EINVAL; 260 } 261 262 if ((error = uiomove(&write_value, sizeof(write_value), uio)) != 0) { 263 return error; 264 } 265 266 if (write_value > EVENTFD_MAXVAL) { 267 error = EINVAL; 268 goto out; 269 } 270 271 mutex_enter(&efd->efd_lock); 272 273 KASSERT(efd->efd_val <= EVENTFD_MAXVAL); 274 while ((EVENTFD_MAXVAL - efd->efd_val) < write_value) { 275 if ((error = eventfd_wait(efd, fflag, true)) != 0) { 276 mutex_exit(&efd->efd_lock); 277 goto out; 278 } 279 } 280 281 efd->efd_val += write_value; 282 KASSERT(efd->efd_val <= EVENTFD_MAXVAL); 283 284 getnanotime(&efd->efd_mtime); 285 eventfd_wake(efd, true); 286 287 mutex_exit(&efd->efd_lock); 288 289 out: 290 if (error) { 291 /* 292 * Undo the effect of uiomove() so that the error 293 * gets reported correctly; see dofilewrite(). 294 */ 295 uio->uio_resid += sizeof(write_value); 296 } 297 return error; 298 } 299 300 static int 301 eventfd_ioctl(file_t * const fp, u_long const cmd, void * const data) 302 { 303 struct eventfd * const efd = fp->f_eventfd; 304 305 switch (cmd) { 306 case FIONBIO: 307 return 0; 308 309 case FIONREAD: 310 mutex_enter(&efd->efd_lock); 311 *(int *)data = efd->efd_val != 0 ? sizeof(eventfd_t) : 0; 312 mutex_exit(&efd->efd_lock); 313 return 0; 314 315 case FIONWRITE: 316 *(int *)data = 0; 317 return 0; 318 319 case FIONSPACE: 320 /* 321 * FIONSPACE doesn't really work for eventfd, because the 322 * writability depends on the contents (value) being written. 323 */ 324 break; 325 326 default: 327 break; 328 } 329 330 return EPASSTHROUGH; 331 } 332 333 static int 334 eventfd_fop_poll(file_t * const fp, int const events) 335 { 336 struct eventfd * const efd = fp->f_eventfd; 337 int revents = 0; 338 339 /* 340 * Note that Linux will return POLLERR if the eventfd count 341 * overflows, but that is not possible in the normal read/write 342 * API, only with Linux kernel-internal interfaces. So, this 343 * implementation never returns POLLERR. 344 * 345 * Also note that the Linux eventfd(2) man page does not 346 * specifically discuss returning POLLRDNORM, but we check 347 * for that event in addition to POLLIN. 348 */ 349 350 mutex_enter(&efd->efd_lock); 351 352 if (events & (POLLIN | POLLRDNORM)) { 353 if (efd->efd_val != 0) { 354 revents |= events & (POLLIN | POLLRDNORM); 355 } else { 356 selrecord(curlwp, &efd->efd_read_sel); 357 } 358 } 359 360 if (events & (POLLOUT | POLLWRNORM)) { 361 if (efd->efd_val < EVENTFD_MAXVAL) { 362 revents |= events & (POLLOUT | POLLWRNORM); 363 } else { 364 selrecord(curlwp, &efd->efd_write_sel); 365 } 366 } 367 368 mutex_exit(&efd->efd_lock); 369 370 return revents; 371 } 372 373 static int 374 eventfd_fop_stat(file_t * const fp, struct stat * const st) 375 { 376 struct eventfd * const efd = fp->f_eventfd; 377 378 memset(st, 0, sizeof(*st)); 379 380 mutex_enter(&efd->efd_lock); 381 st->st_size = (off_t)efd->efd_val; 382 st->st_blksize = sizeof(eventfd_t); 383 st->st_mode = S_IFIFO | S_IRUSR | S_IWUSR; 384 st->st_blocks = 1; 385 st->st_birthtimespec = st->st_ctimespec = efd->efd_btime; 386 st->st_atimespec = efd->efd_atime; 387 st->st_mtimespec = efd->efd_mtime; 388 st->st_uid = kauth_cred_geteuid(fp->f_cred); 389 st->st_gid = kauth_cred_getegid(fp->f_cred); 390 mutex_exit(&efd->efd_lock); 391 392 return 0; 393 } 394 395 static int 396 eventfd_fop_close(file_t * const fp) 397 { 398 struct eventfd * const efd = fp->f_eventfd; 399 400 fp->f_eventfd = NULL; 401 eventfd_destroy(efd); 402 403 return 0; 404 } 405 406 static void 407 eventfd_filt_read_detach(struct knote * const kn) 408 { 409 struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd; 410 411 mutex_enter(&efd->efd_lock); 412 KASSERT(kn->kn_hook == efd); 413 selremove_knote(&efd->efd_read_sel, kn); 414 mutex_exit(&efd->efd_lock); 415 } 416 417 static int 418 eventfd_filt_read(struct knote * const kn, long const hint) 419 { 420 struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd; 421 int rv; 422 423 if (hint & NOTE_SUBMIT) { 424 KASSERT(mutex_owned(&efd->efd_lock)); 425 } else { 426 mutex_enter(&efd->efd_lock); 427 } 428 429 kn->kn_data = (int64_t)efd->efd_val; 430 rv = (eventfd_t)kn->kn_data > 0; 431 432 if ((hint & NOTE_SUBMIT) == 0) { 433 mutex_exit(&efd->efd_lock); 434 } 435 436 return rv; 437 } 438 439 static const struct filterops eventfd_read_filterops = { 440 .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE, 441 .f_detach = eventfd_filt_read_detach, 442 .f_event = eventfd_filt_read, 443 }; 444 445 static void 446 eventfd_filt_write_detach(struct knote * const kn) 447 { 448 struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd; 449 450 mutex_enter(&efd->efd_lock); 451 KASSERT(kn->kn_hook == efd); 452 selremove_knote(&efd->efd_write_sel, kn); 453 mutex_exit(&efd->efd_lock); 454 } 455 456 static int 457 eventfd_filt_write(struct knote * const kn, long const hint) 458 { 459 struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd; 460 int rv; 461 462 if (hint & NOTE_SUBMIT) { 463 KASSERT(mutex_owned(&efd->efd_lock)); 464 } else { 465 mutex_enter(&efd->efd_lock); 466 } 467 468 kn->kn_data = (int64_t)efd->efd_val; 469 rv = (eventfd_t)kn->kn_data < EVENTFD_MAXVAL; 470 471 if ((hint & NOTE_SUBMIT) == 0) { 472 mutex_exit(&efd->efd_lock); 473 } 474 475 return rv; 476 } 477 478 static const struct filterops eventfd_write_filterops = { 479 .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE, 480 .f_detach = eventfd_filt_write_detach, 481 .f_event = eventfd_filt_write, 482 }; 483 484 static int 485 eventfd_fop_kqfilter(file_t * const fp, struct knote * const kn) 486 { 487 struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd; 488 struct selinfo *sel; 489 490 switch (kn->kn_filter) { 491 case EVFILT_READ: 492 sel = &efd->efd_read_sel; 493 kn->kn_fop = &eventfd_read_filterops; 494 break; 495 496 case EVFILT_WRITE: 497 sel = &efd->efd_write_sel; 498 kn->kn_fop = &eventfd_write_filterops; 499 break; 500 501 default: 502 return EINVAL; 503 } 504 505 kn->kn_hook = efd; 506 507 mutex_enter(&efd->efd_lock); 508 selrecord_knote(sel, kn); 509 mutex_exit(&efd->efd_lock); 510 511 return 0; 512 } 513 514 static void 515 eventfd_fop_restart(file_t * const fp) 516 { 517 struct eventfd * const efd = fp->f_eventfd; 518 519 /* 520 * Unblock blocked reads/writes in order to allow close() to complete. 521 * System calls return ERESTART so that the fd is revalidated. 522 */ 523 524 mutex_enter(&efd->efd_lock); 525 526 if (efd->efd_nwaiters != 0) { 527 efd->efd_restarting = true; 528 cv_broadcast(&efd->efd_read_wait); 529 cv_broadcast(&efd->efd_write_wait); 530 } 531 532 mutex_exit(&efd->efd_lock); 533 } 534 535 static const struct fileops eventfd_fileops = { 536 .fo_name = "eventfd", 537 .fo_read = eventfd_fop_read, 538 .fo_write = eventfd_fop_write, 539 .fo_ioctl = eventfd_ioctl, 540 .fo_fcntl = fnullop_fcntl, 541 .fo_poll = eventfd_fop_poll, 542 .fo_stat = eventfd_fop_stat, 543 .fo_close = eventfd_fop_close, 544 .fo_kqfilter = eventfd_fop_kqfilter, 545 .fo_restart = eventfd_fop_restart, 546 }; 547 548 /* 549 * eventfd(2) system call 550 */ 551 int 552 do_eventfd(struct lwp * const l, unsigned int const val, int const flags, 553 register_t *retval) 554 { 555 file_t *fp; 556 int fd, error; 557 558 if (flags & ~(EFD_CLOEXEC | EFD_NONBLOCK | EFD_SEMAPHORE)) { 559 return EINVAL; 560 } 561 562 if ((error = fd_allocfile(&fp, &fd)) != 0) { 563 return error; 564 } 565 566 fp->f_flag = FREAD | FWRITE; 567 if (flags & EFD_NONBLOCK) { 568 fp->f_flag |= FNONBLOCK; 569 } 570 fp->f_type = DTYPE_EVENTFD; 571 fp->f_ops = &eventfd_fileops; 572 fp->f_eventfd = eventfd_create(val, flags); 573 fd_set_exclose(l, fd, !!(flags & EFD_CLOEXEC)); 574 fd_affix(curproc, fp, fd); 575 576 *retval = fd; 577 return 0; 578 } 579 580 int 581 sys_eventfd(struct lwp *l, const struct sys_eventfd_args *uap, 582 register_t *retval) 583 { 584 /* { 585 syscallarg(unsigned int) val; 586 syscallarg(int) flags; 587 } */ 588 589 return do_eventfd(l, SCARG(uap, val), SCARG(uap, flags), retval); 590 } 591
Indexes created Sat Sep 20 22:09:52 GMT 2025