1 /* $OpenBSD: kern_event.c,v 1.79 2017/05/31 14:52:05 mikeb Exp $ */ 2 3 /*- 4 * Copyright (c) 1999,2000,2001 Jonathan Lemon <jlemon@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $FreeBSD: src/sys/kern/kern_event.c,v 1.22 2001/02/23 20:32:42 jlemon Exp $ 29 */ 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/kernel.h> 34 #include <sys/proc.h> 35 #include <sys/pledge.h> 36 #include <sys/malloc.h> 37 #include <sys/unistd.h> 38 #include <sys/file.h> 39 #include <sys/filedesc.h> 40 #include <sys/fcntl.h> 41 #include <sys/selinfo.h> 42 #include <sys/queue.h> 43 #include <sys/event.h> 44 #include <sys/eventvar.h> 45 #include <sys/ktrace.h> 46 #include <sys/pool.h> 47 #include <sys/protosw.h> 48 #include <sys/socket.h> 49 #include <sys/socketvar.h> 50 #include <sys/stat.h> 51 #include <sys/uio.h> 52 #include <sys/mount.h> 53 #include <sys/poll.h> 54 #include <sys/syscallargs.h> 55 #include <sys/timeout.h> 56 57 int kqueue_scan(struct kqueue *kq, int maxevents, 58 struct kevent *ulistp, const struct timespec *timeout, 59 struct proc *p, int *retval); 60 61 int kqueue_read(struct file *fp, off_t *poff, struct uio *uio, 62 struct ucred *cred); 63 int kqueue_write(struct file *fp, off_t *poff, struct uio *uio, 64 struct ucred *cred); 65 int kqueue_ioctl(struct file *fp, u_long com, caddr_t data, 66 struct proc *p); 67 int kqueue_poll(struct file *fp, int events, struct proc *p); 68 int kqueue_kqfilter(struct file *fp, struct knote *kn); 69 int kqueue_stat(struct file *fp, struct stat *st, struct proc *p); 70 int kqueue_close(struct file *fp, struct proc *p); 71 void kqueue_wakeup(struct kqueue *kq); 72 73 struct fileops kqueueops = { 74 kqueue_read, 75 kqueue_write, 76 kqueue_ioctl, 77 kqueue_poll, 78 kqueue_kqfilter, 79 kqueue_stat, 80 kqueue_close 81 }; 82 83 void knote_attach(struct knote *kn, struct filedesc *fdp); 84 void knote_drop(struct knote *kn, struct proc *p, struct filedesc *fdp); 85 void knote_enqueue(struct knote *kn); 86 void knote_dequeue(struct knote *kn); 87 #define knote_alloc() ((struct knote *)pool_get(&knote_pool, PR_WAITOK)) 88 #define knote_free(kn) pool_put(&knote_pool, (kn)) 89 90 void filt_kqdetach(struct knote *kn); 91 int filt_kqueue(struct knote *kn, long hint); 92 int filt_procattach(struct knote *kn); 93 void filt_procdetach(struct knote *kn); 94 int filt_proc(struct knote *kn, long hint); 95 int filt_fileattach(struct knote *kn); 96 void filt_timerexpire(void *knx); 97 int filt_timerattach(struct knote *kn); 98 void filt_timerdetach(struct knote *kn); 99 int filt_timer(struct knote *kn, long hint); 100 void filt_seltruedetach(struct knote *kn); 101 102 struct filterops kqread_filtops = 103 { 1, NULL, filt_kqdetach, filt_kqueue }; 104 struct filterops proc_filtops = 105 { 0, filt_procattach, filt_procdetach, filt_proc }; 106 struct filterops file_filtops = 107 { 1, filt_fileattach, NULL, NULL }; 108 struct filterops timer_filtops = 109 { 0, filt_timerattach, filt_timerdetach, filt_timer }; 110 111 struct pool knote_pool; 112 struct pool kqueue_pool; 113 int kq_ntimeouts = 0; 114 int kq_timeoutmax = (4 * 1024); 115 116 #define KNOTE_ACTIVATE(kn) do { \ 117 kn->kn_status |= KN_ACTIVE; \ 118 if ((kn->kn_status & (KN_QUEUED | KN_DISABLED)) == 0) \ 119 knote_enqueue(kn); \ 120 } while(0) 121 122 #define KN_HASH(val, mask) (((val) ^ (val >> 8)) & (mask)) 123 124 extern struct filterops sig_filtops; 125 #ifdef notyet 126 extern struct filterops aio_filtops; 127 #endif 128 129 /* 130 * Table for for all system-defined filters. 131 */ 132 struct filterops *sysfilt_ops[] = { 133 &file_filtops, /* EVFILT_READ */ 134 &file_filtops, /* EVFILT_WRITE */ 135 NULL, /*&aio_filtops,*/ /* EVFILT_AIO */ 136 &file_filtops, /* EVFILT_VNODE */ 137 &proc_filtops, /* EVFILT_PROC */ 138 &sig_filtops, /* EVFILT_SIGNAL */ 139 &timer_filtops, /* EVFILT_TIMER */ 140 }; 141 142 void KQREF(struct kqueue *); 143 void KQRELE(struct kqueue *); 144 145 void 146 KQREF(struct kqueue *kq) 147 { 148 ++kq->kq_refs; 149 } 150 151 void 152 KQRELE(struct kqueue *kq) 153 { 154 if (--kq->kq_refs == 0) { 155 pool_put(&kqueue_pool, kq); 156 } 157 } 158 159 void kqueue_init(void); 160 161 void 162 kqueue_init(void) 163 { 164 165 pool_init(&kqueue_pool, sizeof(struct kqueue), 0, IPL_NONE, PR_WAITOK, 166 "kqueuepl", NULL); 167 pool_init(&knote_pool, sizeof(struct knote), 0, IPL_NONE, PR_WAITOK, 168 "knotepl", NULL); 169 } 170 171 int 172 filt_fileattach(struct knote *kn) 173 { 174 struct file *fp = kn->kn_fp; 175 176 return fp->f_ops->fo_kqfilter(fp, kn); 177 } 178 179 int 180 kqueue_kqfilter(struct file *fp, struct knote *kn) 181 { 182 struct kqueue *kq = kn->kn_fp->f_data; 183 184 if (kn->kn_filter != EVFILT_READ) 185 return (EINVAL); 186 187 kn->kn_fop = &kqread_filtops; 188 SLIST_INSERT_HEAD(&kq->kq_sel.si_note, kn, kn_selnext); 189 return (0); 190 } 191 192 void 193 filt_kqdetach(struct knote *kn) 194 { 195 struct kqueue *kq = kn->kn_fp->f_data; 196 197 SLIST_REMOVE(&kq->kq_sel.si_note, kn, knote, kn_selnext); 198 } 199 200 int 201 filt_kqueue(struct knote *kn, long hint) 202 { 203 struct kqueue *kq = kn->kn_fp->f_data; 204 205 kn->kn_data = kq->kq_count; 206 return (kn->kn_data > 0); 207 } 208 209 int 210 filt_procattach(struct knote *kn) 211 { 212 struct process *pr; 213 214 if ((curproc->p_p->ps_flags & PS_PLEDGE) && 215 (curproc->p_p->ps_pledge & PLEDGE_PROC) == 0) 216 return pledge_fail(curproc, EPERM, PLEDGE_PROC); 217 218 if (kn->kn_id > PID_MAX) 219 return ESRCH; 220 221 pr = prfind(kn->kn_id); 222 if (pr == NULL) 223 return (ESRCH); 224 225 /* exiting processes can't be specified */ 226 if (pr->ps_flags & PS_EXITING) 227 return (ESRCH); 228 229 kn->kn_ptr.p_process = pr; 230 kn->kn_flags |= EV_CLEAR; /* automatically set */ 231 232 /* 233 * internal flag indicating registration done by kernel 234 */ 235 if (kn->kn_flags & EV_FLAG1) { 236 kn->kn_data = kn->kn_sdata; /* ppid */ 237 kn->kn_fflags = NOTE_CHILD; 238 kn->kn_flags &= ~EV_FLAG1; 239 } 240 241 /* XXX lock the proc here while adding to the list? */ 242 SLIST_INSERT_HEAD(&pr->ps_klist, kn, kn_selnext); 243 244 return (0); 245 } 246 247 /* 248 * The knote may be attached to a different process, which may exit, 249 * leaving nothing for the knote to be attached to. So when the process 250 * exits, the knote is marked as DETACHED and also flagged as ONESHOT so 251 * it will be deleted when read out. However, as part of the knote deletion, 252 * this routine is called, so a check is needed to avoid actually performing 253 * a detach, because the original process does not exist any more. 254 */ 255 void 256 filt_procdetach(struct knote *kn) 257 { 258 struct process *pr = kn->kn_ptr.p_process; 259 260 if (kn->kn_status & KN_DETACHED) 261 return; 262 263 /* XXX locking? this might modify another process. */ 264 SLIST_REMOVE(&pr->ps_klist, kn, knote, kn_selnext); 265 } 266 267 int 268 filt_proc(struct knote *kn, long hint) 269 { 270 u_int event; 271 272 /* 273 * mask off extra data 274 */ 275 event = (u_int)hint & NOTE_PCTRLMASK; 276 277 /* 278 * if the user is interested in this event, record it. 279 */ 280 if (kn->kn_sfflags & event) 281 kn->kn_fflags |= event; 282 283 /* 284 * process is gone, so flag the event as finished and remove it 285 * from the process's klist 286 */ 287 if (event == NOTE_EXIT) { 288 struct process *pr = kn->kn_ptr.p_process; 289 290 kn->kn_status |= KN_DETACHED; 291 kn->kn_flags |= (EV_EOF | EV_ONESHOT); 292 kn->kn_data = pr->ps_mainproc->p_xstat; 293 SLIST_REMOVE(&pr->ps_klist, kn, knote, kn_selnext); 294 return (1); 295 } 296 297 /* 298 * process forked, and user wants to track the new process, 299 * so attach a new knote to it, and immediately report an 300 * event with the parent's pid. 301 */ 302 if ((event == NOTE_FORK) && (kn->kn_sfflags & NOTE_TRACK)) { 303 struct kevent kev; 304 int error; 305 306 /* 307 * register knote with new process. 308 */ 309 kev.ident = hint & NOTE_PDATAMASK; /* pid */ 310 kev.filter = kn->kn_filter; 311 kev.flags = kn->kn_flags | EV_ADD | EV_ENABLE | EV_FLAG1; 312 kev.fflags = kn->kn_sfflags; 313 kev.data = kn->kn_id; /* parent */ 314 kev.udata = kn->kn_kevent.udata; /* preserve udata */ 315 error = kqueue_register(kn->kn_kq, &kev, NULL); 316 if (error) 317 kn->kn_fflags |= NOTE_TRACKERR; 318 } 319 320 return (kn->kn_fflags != 0); 321 } 322 323 static void 324 filt_timer_timeout_add(struct knote *kn) 325 { 326 struct timeval tv; 327 int tticks; 328 329 tv.tv_sec = kn->kn_sdata / 1000; 330 tv.tv_usec = (kn->kn_sdata % 1000) * 1000; 331 tticks = tvtohz(&tv); 332 timeout_add(kn->kn_hook, tticks ? tticks : 1); 333 } 334 335 void 336 filt_timerexpire(void *knx) 337 { 338 struct knote *kn = knx; 339 340 kn->kn_data++; 341 KNOTE_ACTIVATE(kn); 342 343 if ((kn->kn_flags & EV_ONESHOT) == 0) 344 filt_timer_timeout_add(kn); 345 } 346 347 348 /* 349 * data contains amount of time to sleep, in milliseconds 350 */ 351 int 352 filt_timerattach(struct knote *kn) 353 { 354 struct timeout *to; 355 356 if (kq_ntimeouts > kq_timeoutmax) 357 return (ENOMEM); 358 kq_ntimeouts++; 359 360 kn->kn_flags |= EV_CLEAR; /* automatically set */ 361 to = malloc(sizeof(*to), M_KEVENT, M_WAITOK); 362 timeout_set(to, filt_timerexpire, kn); 363 kn->kn_hook = to; 364 filt_timer_timeout_add(kn); 365 366 return (0); 367 } 368 369 void 370 filt_timerdetach(struct knote *kn) 371 { 372 struct timeout *to; 373 374 to = (struct timeout *)kn->kn_hook; 375 timeout_del(to); 376 free(to, M_KEVENT, sizeof(*to)); 377 kq_ntimeouts--; 378 } 379 380 int 381 filt_timer(struct knote *kn, long hint) 382 { 383 return (kn->kn_data != 0); 384 } 385 386 387 /* 388 * filt_seltrue: 389 * 390 * This filter "event" routine simulates seltrue(). 391 */ 392 int 393 filt_seltrue(struct knote *kn, long hint) 394 { 395 396 /* 397 * We don't know how much data can be read/written, 398 * but we know that it *can* be. This is about as 399 * good as select/poll does as well. 400 */ 401 kn->kn_data = 0; 402 return (1); 403 } 404 405 /* 406 * This provides full kqfilter entry for device switch tables, which 407 * has same effect as filter using filt_seltrue() as filter method. 408 */ 409 void 410 filt_seltruedetach(struct knote *kn) 411 { 412 /* Nothing to do */ 413 } 414 415 const struct filterops seltrue_filtops = 416 { 1, NULL, filt_seltruedetach, filt_seltrue }; 417 418 int 419 seltrue_kqfilter(dev_t dev, struct knote *kn) 420 { 421 switch (kn->kn_filter) { 422 case EVFILT_READ: 423 case EVFILT_WRITE: 424 kn->kn_fop = &seltrue_filtops; 425 break; 426 default: 427 return (EINVAL); 428 } 429 430 /* Nothing more to do */ 431 return (0); 432 } 433 434 int 435 sys_kqueue(struct proc *p, void *v, register_t *retval) 436 { 437 struct filedesc *fdp = p->p_fd; 438 struct kqueue *kq; 439 struct file *fp; 440 int fd, error; 441 442 fdplock(fdp); 443 error = falloc(p, 0, &fp, &fd); 444 fdpunlock(fdp); 445 if (error) 446 return (error); 447 fp->f_flag = FREAD | FWRITE; 448 fp->f_type = DTYPE_KQUEUE; 449 fp->f_ops = &kqueueops; 450 kq = pool_get(&kqueue_pool, PR_WAITOK|PR_ZERO); 451 TAILQ_INIT(&kq->kq_head); 452 fp->f_data = kq; 453 KQREF(kq); 454 *retval = fd; 455 if (fdp->fd_knlistsize < 0) 456 fdp->fd_knlistsize = 0; /* this process has a kq */ 457 kq->kq_fdp = fdp; 458 FILE_SET_MATURE(fp, p); 459 return (0); 460 } 461 462 int 463 sys_kevent(struct proc *p, void *v, register_t *retval) 464 { 465 struct filedesc* fdp = p->p_fd; 466 struct sys_kevent_args /* { 467 syscallarg(int) fd; 468 syscallarg(const struct kevent *) changelist; 469 syscallarg(int) nchanges; 470 syscallarg(struct kevent *) eventlist; 471 syscallarg(int) nevents; 472 syscallarg(const struct timespec *) timeout; 473 } */ *uap = v; 474 struct kevent *kevp; 475 struct kqueue *kq; 476 struct file *fp; 477 struct timespec ts; 478 int i, n, nerrors, error; 479 480 if ((fp = fd_getfile(fdp, SCARG(uap, fd))) == NULL || 481 (fp->f_type != DTYPE_KQUEUE)) 482 return (EBADF); 483 484 FREF(fp); 485 486 if (SCARG(uap, timeout) != NULL) { 487 error = copyin(SCARG(uap, timeout), &ts, sizeof(ts)); 488 if (error) 489 goto done; 490 #ifdef KTRACE 491 if (KTRPOINT(p, KTR_STRUCT)) 492 ktrreltimespec(p, &ts); 493 #endif 494 SCARG(uap, timeout) = &ts; 495 } 496 497 kq = fp->f_data; 498 nerrors = 0; 499 500 while (SCARG(uap, nchanges) > 0) { 501 n = SCARG(uap, nchanges) > KQ_NEVENTS ? 502 KQ_NEVENTS : SCARG(uap, nchanges); 503 error = copyin(SCARG(uap, changelist), kq->kq_kev, 504 n * sizeof(struct kevent)); 505 if (error) 506 goto done; 507 #ifdef KTRACE 508 if (KTRPOINT(p, KTR_STRUCT)) 509 ktrevent(p, kq->kq_kev, n); 510 #endif 511 for (i = 0; i < n; i++) { 512 kevp = &kq->kq_kev[i]; 513 kevp->flags &= ~EV_SYSFLAGS; 514 error = kqueue_register(kq, kevp, p); 515 if (error || (kevp->flags & EV_RECEIPT)) { 516 if (SCARG(uap, nevents) != 0) { 517 kevp->flags = EV_ERROR; 518 kevp->data = error; 519 copyout(kevp, SCARG(uap, eventlist), 520 sizeof(*kevp)); 521 SCARG(uap, eventlist)++; 522 SCARG(uap, nevents)--; 523 nerrors++; 524 } else { 525 goto done; 526 } 527 } 528 } 529 SCARG(uap, nchanges) -= n; 530 SCARG(uap, changelist) += n; 531 } 532 if (nerrors) { 533 *retval = nerrors; 534 error = 0; 535 goto done; 536 } 537 538 KQREF(kq); 539 FRELE(fp, p); 540 error = kqueue_scan(kq, SCARG(uap, nevents), SCARG(uap, eventlist), 541 SCARG(uap, timeout), p, &n); 542 KQRELE(kq); 543 *retval = n; 544 return (error); 545 546 done: 547 FRELE(fp, p); 548 return (error); 549 } 550 551 int 552 kqueue_register(struct kqueue *kq, struct kevent *kev, struct proc *p) 553 { 554 struct filedesc *fdp = kq->kq_fdp; 555 struct filterops *fops = NULL; 556 struct file *fp = NULL; 557 struct knote *kn = NULL; 558 int s, error = 0; 559 560 if (kev->filter < 0) { 561 if (kev->filter + EVFILT_SYSCOUNT < 0) 562 return (EINVAL); 563 fops = sysfilt_ops[~kev->filter]; /* to 0-base index */ 564 } 565 566 if (fops == NULL) { 567 /* 568 * XXX 569 * filter attach routine is responsible for ensuring that 570 * the identifier can be attached to it. 571 */ 572 return (EINVAL); 573 } 574 575 if (fops->f_isfd) { 576 /* validate descriptor */ 577 if (kev->ident > INT_MAX) 578 return (EBADF); 579 if ((fp = fd_getfile(fdp, kev->ident)) == NULL) 580 return (EBADF); 581 FREF(fp); 582 583 if (kev->ident < fdp->fd_knlistsize) { 584 SLIST_FOREACH(kn, &fdp->fd_knlist[kev->ident], kn_link) { 585 if (kq == kn->kn_kq && 586 kev->filter == kn->kn_filter) 587 break; 588 } 589 } 590 } else { 591 if (fdp->fd_knhashmask != 0) { 592 struct klist *list; 593 594 list = &fdp->fd_knhash[ 595 KN_HASH((u_long)kev->ident, fdp->fd_knhashmask)]; 596 SLIST_FOREACH(kn, list, kn_link) { 597 if (kev->ident == kn->kn_id && 598 kq == kn->kn_kq && 599 kev->filter == kn->kn_filter) 600 break; 601 } 602 } 603 } 604 605 if (kn == NULL && ((kev->flags & EV_ADD) == 0)) { 606 error = ENOENT; 607 goto done; 608 } 609 610 /* 611 * kn now contains the matching knote, or NULL if no match 612 */ 613 if (kev->flags & EV_ADD) { 614 615 if (kn == NULL) { 616 kn = knote_alloc(); 617 if (kn == NULL) { 618 error = ENOMEM; 619 goto done; 620 } 621 kn->kn_fp = fp; 622 kn->kn_kq = kq; 623 kn->kn_fop = fops; 624 625 /* 626 * apply reference count to knote structure, and 627 * do not release it at the end of this routine. 628 */ 629 fp = NULL; 630 631 kn->kn_sfflags = kev->fflags; 632 kn->kn_sdata = kev->data; 633 kev->fflags = 0; 634 kev->data = 0; 635 kn->kn_kevent = *kev; 636 637 knote_attach(kn, fdp); 638 if ((error = fops->f_attach(kn)) != 0) { 639 knote_drop(kn, p, fdp); 640 goto done; 641 } 642 } else { 643 /* 644 * The user may change some filter values after the 645 * initial EV_ADD, but doing so will not reset any 646 * filters which have already been triggered. 647 */ 648 kn->kn_sfflags = kev->fflags; 649 kn->kn_sdata = kev->data; 650 kn->kn_kevent.udata = kev->udata; 651 } 652 653 s = splhigh(); 654 if (kn->kn_fop->f_event(kn, 0)) 655 KNOTE_ACTIVATE(kn); 656 splx(s); 657 658 } else if (kev->flags & EV_DELETE) { 659 kn->kn_fop->f_detach(kn); 660 knote_drop(kn, p, p->p_fd); 661 goto done; 662 } 663 664 if ((kev->flags & EV_DISABLE) && 665 ((kn->kn_status & KN_DISABLED) == 0)) { 666 s = splhigh(); 667 kn->kn_status |= KN_DISABLED; 668 splx(s); 669 } 670 671 if ((kev->flags & EV_ENABLE) && (kn->kn_status & KN_DISABLED)) { 672 s = splhigh(); 673 kn->kn_status &= ~KN_DISABLED; 674 if ((kn->kn_status & KN_ACTIVE) && 675 ((kn->kn_status & KN_QUEUED) == 0)) 676 knote_enqueue(kn); 677 splx(s); 678 } 679 680 done: 681 if (fp != NULL) 682 FRELE(fp, p); 683 return (error); 684 } 685 686 int 687 kqueue_scan(struct kqueue *kq, int maxevents, struct kevent *ulistp, 688 const struct timespec *tsp, struct proc *p, int *retval) 689 { 690 struct kevent *kevp; 691 struct timeval atv, rtv, ttv; 692 struct knote *kn, marker; 693 int s, count, timeout, nkev = 0, error = 0; 694 695 count = maxevents; 696 if (count == 0) 697 goto done; 698 699 if (tsp != NULL) { 700 TIMESPEC_TO_TIMEVAL(&atv, tsp); 701 if (tsp->tv_sec == 0 && tsp->tv_nsec == 0) { 702 /* No timeout, just poll */ 703 timeout = -1; 704 goto start; 705 } 706 if (itimerfix(&atv)) { 707 error = EINVAL; 708 goto done; 709 } 710 711 timeout = atv.tv_sec > 24 * 60 * 60 ? 712 24 * 60 * 60 * hz : tvtohz(&atv); 713 714 getmicrouptime(&rtv); 715 timeradd(&atv, &rtv, &atv); 716 } else { 717 atv.tv_sec = 0; 718 atv.tv_usec = 0; 719 timeout = 0; 720 } 721 goto start; 722 723 retry: 724 if (atv.tv_sec || atv.tv_usec) { 725 getmicrouptime(&rtv); 726 if (timercmp(&rtv, &atv, >=)) 727 goto done; 728 ttv = atv; 729 timersub(&ttv, &rtv, &ttv); 730 timeout = ttv.tv_sec > 24 * 60 * 60 ? 731 24 * 60 * 60 * hz : tvtohz(&ttv); 732 } 733 734 start: 735 if (kq->kq_state & KQ_DYING) { 736 error = EBADF; 737 goto done; 738 } 739 740 kevp = kq->kq_kev; 741 s = splhigh(); 742 if (kq->kq_count == 0) { 743 if (timeout < 0) { 744 error = EWOULDBLOCK; 745 } else { 746 kq->kq_state |= KQ_SLEEP; 747 error = tsleep(kq, PSOCK | PCATCH, "kqread", timeout); 748 } 749 splx(s); 750 if (error == 0) 751 goto retry; 752 /* don't restart after signals... */ 753 if (error == ERESTART) 754 error = EINTR; 755 else if (error == EWOULDBLOCK) 756 error = 0; 757 goto done; 758 } 759 760 TAILQ_INSERT_TAIL(&kq->kq_head, &marker, kn_tqe); 761 while (count) { 762 kn = TAILQ_FIRST(&kq->kq_head); 763 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 764 if (kn == &marker) { 765 splx(s); 766 if (count == maxevents) 767 goto retry; 768 goto done; 769 } 770 if (kn->kn_status & KN_DISABLED) { 771 kn->kn_status &= ~KN_QUEUED; 772 kq->kq_count--; 773 continue; 774 } 775 if ((kn->kn_flags & EV_ONESHOT) == 0 && 776 kn->kn_fop->f_event(kn, 0) == 0) { 777 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE); 778 kq->kq_count--; 779 continue; 780 } 781 *kevp = kn->kn_kevent; 782 kevp++; 783 nkev++; 784 if (kn->kn_flags & EV_ONESHOT) { 785 kn->kn_status &= ~KN_QUEUED; 786 kq->kq_count--; 787 splx(s); 788 kn->kn_fop->f_detach(kn); 789 knote_drop(kn, p, p->p_fd); 790 s = splhigh(); 791 } else if (kn->kn_flags & (EV_CLEAR | EV_DISPATCH)) { 792 if (kn->kn_flags & EV_CLEAR) { 793 kn->kn_data = 0; 794 kn->kn_fflags = 0; 795 } 796 if (kn->kn_flags & EV_DISPATCH) 797 kn->kn_status |= KN_DISABLED; 798 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE); 799 kq->kq_count--; 800 } else { 801 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe); 802 } 803 count--; 804 if (nkev == KQ_NEVENTS) { 805 splx(s); 806 #ifdef KTRACE 807 if (KTRPOINT(p, KTR_STRUCT)) 808 ktrevent(p, kq->kq_kev, nkev); 809 #endif 810 error = copyout(kq->kq_kev, ulistp, 811 sizeof(struct kevent) * nkev); 812 ulistp += nkev; 813 nkev = 0; 814 kevp = kq->kq_kev; 815 s = splhigh(); 816 if (error) 817 break; 818 } 819 } 820 TAILQ_REMOVE(&kq->kq_head, &marker, kn_tqe); 821 splx(s); 822 done: 823 if (nkev != 0) { 824 #ifdef KTRACE 825 if (KTRPOINT(p, KTR_STRUCT)) 826 ktrevent(p, kq->kq_kev, nkev); 827 #endif 828 error = copyout(kq->kq_kev, ulistp, 829 sizeof(struct kevent) * nkev); 830 } 831 *retval = maxevents - count; 832 return (error); 833 } 834 835 /* 836 * XXX 837 * This could be expanded to call kqueue_scan, if desired. 838 */ 839 int 840 kqueue_read(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) 841 { 842 return (ENXIO); 843 } 844 845 int 846 kqueue_write(struct file *fp, off_t *poff, struct uio *uio, struct ucred *cred) 847 848 { 849 return (ENXIO); 850 } 851 852 int 853 kqueue_ioctl(struct file *fp, u_long com, caddr_t data, struct proc *p) 854 { 855 return (ENOTTY); 856 } 857 858 int 859 kqueue_poll(struct file *fp, int events, struct proc *p) 860 { 861 struct kqueue *kq = (struct kqueue *)fp->f_data; 862 int revents = 0; 863 int s = splhigh(); 864 865 if (events & (POLLIN | POLLRDNORM)) { 866 if (kq->kq_count) { 867 revents |= events & (POLLIN | POLLRDNORM); 868 } else { 869 selrecord(p, &kq->kq_sel); 870 kq->kq_state |= KQ_SEL; 871 } 872 } 873 splx(s); 874 return (revents); 875 } 876 877 int 878 kqueue_stat(struct file *fp, struct stat *st, struct proc *p) 879 { 880 struct kqueue *kq = fp->f_data; 881 882 memset(st, 0, sizeof(*st)); 883 st->st_size = kq->kq_count; 884 st->st_blksize = sizeof(struct kevent); 885 st->st_mode = S_IFIFO; 886 return (0); 887 } 888 889 int 890 kqueue_close(struct file *fp, struct proc *p) 891 { 892 struct kqueue *kq = fp->f_data; 893 struct filedesc *fdp = p->p_fd; 894 struct knote **knp, *kn, *kn0; 895 int i; 896 897 for (i = 0; i < fdp->fd_knlistsize; i++) { 898 knp = &SLIST_FIRST(&fdp->fd_knlist[i]); 899 kn = *knp; 900 while (kn != NULL) { 901 kn0 = SLIST_NEXT(kn, kn_link); 902 if (kq == kn->kn_kq) { 903 kn->kn_fop->f_detach(kn); 904 FRELE(kn->kn_fp, p); 905 knote_free(kn); 906 *knp = kn0; 907 } else { 908 knp = &SLIST_NEXT(kn, kn_link); 909 } 910 kn = kn0; 911 } 912 } 913 if (fdp->fd_knhashmask != 0) { 914 for (i = 0; i < fdp->fd_knhashmask + 1; i++) { 915 knp = &SLIST_FIRST(&fdp->fd_knhash[i]); 916 kn = *knp; 917 while (kn != NULL) { 918 kn0 = SLIST_NEXT(kn, kn_link); 919 if (kq == kn->kn_kq) { 920 kn->kn_fop->f_detach(kn); 921 /* XXX non-fd release of kn->kn_ptr */ 922 knote_free(kn); 923 *knp = kn0; 924 } else { 925 knp = &SLIST_NEXT(kn, kn_link); 926 } 927 kn = kn0; 928 } 929 } 930 } 931 fp->f_data = NULL; 932 933 kq->kq_state |= KQ_DYING; 934 kqueue_wakeup(kq); 935 KQRELE(kq); 936 937 return (0); 938 } 939 940 void 941 kqueue_wakeup(struct kqueue *kq) 942 { 943 944 if (kq->kq_state & KQ_SLEEP) { 945 kq->kq_state &= ~KQ_SLEEP; 946 wakeup(kq); 947 } 948 if (kq->kq_state & KQ_SEL) { 949 kq->kq_state &= ~KQ_SEL; 950 selwakeup(&kq->kq_sel); 951 } else 952 KNOTE(&kq->kq_sel.si_note, 0); 953 } 954 955 /* 956 * activate one knote. 957 */ 958 void 959 knote_activate(struct knote *kn) 960 { 961 KNOTE_ACTIVATE(kn); 962 } 963 964 /* 965 * walk down a list of knotes, activating them if their event has triggered. 966 */ 967 void 968 knote(struct klist *list, long hint) 969 { 970 struct knote *kn, *kn0; 971 972 SLIST_FOREACH_SAFE(kn, list, kn_selnext, kn0) 973 if (kn->kn_fop->f_event(kn, hint)) 974 KNOTE_ACTIVATE(kn); 975 } 976 977 /* 978 * remove all knotes from a specified klist 979 */ 980 void 981 knote_remove(struct proc *p, struct klist *list) 982 { 983 struct knote *kn; 984 985 while ((kn = SLIST_FIRST(list)) != NULL) { 986 kn->kn_fop->f_detach(kn); 987 knote_drop(kn, p, p->p_fd); 988 } 989 } 990 991 /* 992 * remove all knotes referencing a specified fd 993 */ 994 void 995 knote_fdclose(struct proc *p, int fd) 996 { 997 struct filedesc *fdp = p->p_fd; 998 struct klist *list = &fdp->fd_knlist[fd]; 999 1000 knote_remove(p, list); 1001 } 1002 1003 /* 1004 * handle a process exiting, including the triggering of NOTE_EXIT notes 1005 * XXX this could be more efficient, doing a single pass down the klist 1006 */ 1007 void 1008 knote_processexit(struct proc *p) 1009 { 1010 struct process *pr = p->p_p; 1011 1012 KNOTE(&pr->ps_klist, NOTE_EXIT); 1013 1014 /* remove other knotes hanging off the process */ 1015 knote_remove(p, &pr->ps_klist); 1016 } 1017 1018 void 1019 knote_attach(struct knote *kn, struct filedesc *fdp) 1020 { 1021 struct klist *list; 1022 int size; 1023 1024 if (!kn->kn_fop->f_isfd) { 1025 if (fdp->fd_knhashmask == 0) 1026 fdp->fd_knhash = hashinit(KN_HASHSIZE, M_TEMP, 1027 M_WAITOK, &fdp->fd_knhashmask); 1028 list = &fdp->fd_knhash[KN_HASH(kn->kn_id, fdp->fd_knhashmask)]; 1029 goto done; 1030 } 1031 1032 if (fdp->fd_knlistsize <= kn->kn_id) { 1033 size = fdp->fd_knlistsize; 1034 while (size <= kn->kn_id) 1035 size += KQEXTENT; 1036 list = mallocarray(size, sizeof(struct klist), M_TEMP, 1037 M_WAITOK); 1038 memcpy(list, fdp->fd_knlist, 1039 fdp->fd_knlistsize * sizeof(struct klist)); 1040 memset(&list[fdp->fd_knlistsize], 0, 1041 (size - fdp->fd_knlistsize) * sizeof(struct klist)); 1042 free(fdp->fd_knlist, M_TEMP, 1043 fdp->fd_knlistsize * sizeof(struct klist)); 1044 fdp->fd_knlistsize = size; 1045 fdp->fd_knlist = list; 1046 } 1047 list = &fdp->fd_knlist[kn->kn_id]; 1048 done: 1049 SLIST_INSERT_HEAD(list, kn, kn_link); 1050 kn->kn_status = 0; 1051 } 1052 1053 /* 1054 * should be called at spl == 0, since we don't want to hold spl 1055 * while calling FRELE and knote_free. 1056 */ 1057 void 1058 knote_drop(struct knote *kn, struct proc *p, struct filedesc *fdp) 1059 { 1060 struct klist *list; 1061 1062 if (kn->kn_fop->f_isfd) 1063 list = &fdp->fd_knlist[kn->kn_id]; 1064 else 1065 list = &fdp->fd_knhash[KN_HASH(kn->kn_id, fdp->fd_knhashmask)]; 1066 1067 SLIST_REMOVE(list, kn, knote, kn_link); 1068 if (kn->kn_status & KN_QUEUED) 1069 knote_dequeue(kn); 1070 if (kn->kn_fop->f_isfd) 1071 FRELE(kn->kn_fp, p); 1072 knote_free(kn); 1073 } 1074 1075 1076 void 1077 knote_enqueue(struct knote *kn) 1078 { 1079 struct kqueue *kq = kn->kn_kq; 1080 int s = splhigh(); 1081 1082 KASSERT((kn->kn_status & KN_QUEUED) == 0); 1083 1084 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe); 1085 kn->kn_status |= KN_QUEUED; 1086 kq->kq_count++; 1087 splx(s); 1088 kqueue_wakeup(kq); 1089 } 1090 1091 void 1092 knote_dequeue(struct knote *kn) 1093 { 1094 struct kqueue *kq = kn->kn_kq; 1095 int s = splhigh(); 1096 1097 KASSERT(kn->kn_status & KN_QUEUED); 1098 1099 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 1100 kn->kn_status &= ~KN_QUEUED; 1101 kq->kq_count--; 1102 splx(s); 1103 } 1104 1105 void 1106 klist_invalidate(struct klist *list) 1107 { 1108 struct knote *kn; 1109 1110 SLIST_FOREACH(kn, list, kn_selnext) { 1111 kn->kn_status |= KN_DETACHED; 1112 kn->kn_flags |= EV_EOF | EV_ONESHOT; 1113 } 1114 } 1115