1 /* $NetBSD: kern_event.c,v 1.28 2006/06/07 22:33:39 kardel 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.27 2001/07/05 17:10:44 rwatson Exp $ 29 */ 30 31 #include <sys/cdefs.h> 32 __KERNEL_RCSID(0, "$NetBSD: kern_event.c,v 1.28 2006/06/07 22:33:39 kardel Exp $"); 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/kernel.h> 37 #include <sys/proc.h> 38 #include <sys/malloc.h> 39 #include <sys/unistd.h> 40 #include <sys/file.h> 41 #include <sys/fcntl.h> 42 #include <sys/select.h> 43 #include <sys/queue.h> 44 #include <sys/event.h> 45 #include <sys/eventvar.h> 46 #include <sys/poll.h> 47 #include <sys/pool.h> 48 #include <sys/protosw.h> 49 #include <sys/socket.h> 50 #include <sys/socketvar.h> 51 #include <sys/stat.h> 52 #include <sys/uio.h> 53 #include <sys/mount.h> 54 #include <sys/filedesc.h> 55 #include <sys/sa.h> 56 #include <sys/syscallargs.h> 57 #include <sys/kauth.h> 58 59 static void kqueue_wakeup(struct kqueue *kq); 60 61 static int kqueue_scan(struct file *, size_t, struct kevent *, 62 const struct timespec *, struct lwp *, register_t *, 63 const struct kevent_ops *); 64 static int kqueue_read(struct file *fp, off_t *offset, struct uio *uio, 65 kauth_cred_t cred, int flags); 66 static int kqueue_write(struct file *fp, off_t *offset, struct uio *uio, 67 kauth_cred_t cred, int flags); 68 static int kqueue_ioctl(struct file *fp, u_long com, void *data, 69 struct lwp *l); 70 static int kqueue_fcntl(struct file *fp, u_int com, void *data, 71 struct lwp *l); 72 static int kqueue_poll(struct file *fp, int events, struct lwp *l); 73 static int kqueue_kqfilter(struct file *fp, struct knote *kn); 74 static int kqueue_stat(struct file *fp, struct stat *sp, struct lwp *l); 75 static int kqueue_close(struct file *fp, struct lwp *l); 76 77 static const struct fileops kqueueops = { 78 kqueue_read, kqueue_write, kqueue_ioctl, kqueue_fcntl, kqueue_poll, 79 kqueue_stat, kqueue_close, kqueue_kqfilter 80 }; 81 82 static void knote_attach(struct knote *kn, struct filedesc *fdp); 83 static void knote_drop(struct knote *kn, struct lwp *l, 84 struct filedesc *fdp); 85 static void knote_enqueue(struct knote *kn); 86 static void knote_dequeue(struct knote *kn); 87 88 static void filt_kqdetach(struct knote *kn); 89 static int filt_kqueue(struct knote *kn, long hint); 90 static int filt_procattach(struct knote *kn); 91 static void filt_procdetach(struct knote *kn); 92 static int filt_proc(struct knote *kn, long hint); 93 static int filt_fileattach(struct knote *kn); 94 static void filt_timerexpire(void *knx); 95 static int filt_timerattach(struct knote *kn); 96 static void filt_timerdetach(struct knote *kn); 97 static int filt_timer(struct knote *kn, long hint); 98 99 static const struct filterops kqread_filtops = 100 { 1, NULL, filt_kqdetach, filt_kqueue }; 101 static const struct filterops proc_filtops = 102 { 0, filt_procattach, filt_procdetach, filt_proc }; 103 static const struct filterops file_filtops = 104 { 1, filt_fileattach, NULL, NULL }; 105 static const struct filterops timer_filtops = 106 { 0, filt_timerattach, filt_timerdetach, filt_timer }; 107 108 static POOL_INIT(kqueue_pool, sizeof(struct kqueue), 0, 0, 0, "kqueuepl", NULL); 109 static POOL_INIT(knote_pool, sizeof(struct knote), 0, 0, 0, "knotepl", NULL); 110 static int kq_ncallouts = 0; 111 static int kq_calloutmax = (4 * 1024); 112 113 MALLOC_DEFINE(M_KEVENT, "kevent", "kevents/knotes"); 114 115 #define KNOTE_ACTIVATE(kn) \ 116 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_HASHSIZE 64 /* XXX should be tunable */ 123 #define KN_HASH(val, mask) (((val) ^ (val >> 8)) & (mask)) 124 125 extern const struct filterops sig_filtops; 126 127 /* 128 * Table for for all system-defined filters. 129 * These should be listed in the numeric order of the EVFILT_* defines. 130 * If filtops is NULL, the filter isn't implemented in NetBSD. 131 * End of list is when name is NULL. 132 */ 133 struct kfilter { 134 const char *name; /* name of filter */ 135 uint32_t filter; /* id of filter */ 136 const struct filterops *filtops;/* operations for filter */ 137 }; 138 139 /* System defined filters */ 140 static const struct kfilter sys_kfilters[] = { 141 { "EVFILT_READ", EVFILT_READ, &file_filtops }, 142 { "EVFILT_WRITE", EVFILT_WRITE, &file_filtops }, 143 { "EVFILT_AIO", EVFILT_AIO, NULL }, 144 { "EVFILT_VNODE", EVFILT_VNODE, &file_filtops }, 145 { "EVFILT_PROC", EVFILT_PROC, &proc_filtops }, 146 { "EVFILT_SIGNAL", EVFILT_SIGNAL, &sig_filtops }, 147 { "EVFILT_TIMER", EVFILT_TIMER, &timer_filtops }, 148 { NULL, 0, NULL }, /* end of list */ 149 }; 150 151 /* User defined kfilters */ 152 static struct kfilter *user_kfilters; /* array */ 153 static int user_kfilterc; /* current offset */ 154 static int user_kfiltermaxc; /* max size so far */ 155 156 /* 157 * Find kfilter entry by name, or NULL if not found. 158 */ 159 static const struct kfilter * 160 kfilter_byname_sys(const char *name) 161 { 162 int i; 163 164 for (i = 0; sys_kfilters[i].name != NULL; i++) { 165 if (strcmp(name, sys_kfilters[i].name) == 0) 166 return (&sys_kfilters[i]); 167 } 168 return (NULL); 169 } 170 171 static struct kfilter * 172 kfilter_byname_user(const char *name) 173 { 174 int i; 175 176 /* user_kfilters[] could be NULL if no filters were registered */ 177 if (!user_kfilters) 178 return (NULL); 179 180 for (i = 0; user_kfilters[i].name != NULL; i++) { 181 if (user_kfilters[i].name != '\0' && 182 strcmp(name, user_kfilters[i].name) == 0) 183 return (&user_kfilters[i]); 184 } 185 return (NULL); 186 } 187 188 static const struct kfilter * 189 kfilter_byname(const char *name) 190 { 191 const struct kfilter *kfilter; 192 193 if ((kfilter = kfilter_byname_sys(name)) != NULL) 194 return (kfilter); 195 196 return (kfilter_byname_user(name)); 197 } 198 199 /* 200 * Find kfilter entry by filter id, or NULL if not found. 201 * Assumes entries are indexed in filter id order, for speed. 202 */ 203 static const struct kfilter * 204 kfilter_byfilter(uint32_t filter) 205 { 206 const struct kfilter *kfilter; 207 208 if (filter < EVFILT_SYSCOUNT) /* it's a system filter */ 209 kfilter = &sys_kfilters[filter]; 210 else if (user_kfilters != NULL && 211 filter < EVFILT_SYSCOUNT + user_kfilterc) 212 /* it's a user filter */ 213 kfilter = &user_kfilters[filter - EVFILT_SYSCOUNT]; 214 else 215 return (NULL); /* out of range */ 216 KASSERT(kfilter->filter == filter); /* sanity check! */ 217 return (kfilter); 218 } 219 220 /* 221 * Register a new kfilter. Stores the entry in user_kfilters. 222 * Returns 0 if operation succeeded, or an appropriate errno(2) otherwise. 223 * If retfilter != NULL, the new filterid is returned in it. 224 */ 225 int 226 kfilter_register(const char *name, const struct filterops *filtops, 227 int *retfilter) 228 { 229 struct kfilter *kfilter; 230 void *space; 231 int len; 232 233 if (name == NULL || name[0] == '\0' || filtops == NULL) 234 return (EINVAL); /* invalid args */ 235 if (kfilter_byname(name) != NULL) 236 return (EEXIST); /* already exists */ 237 if (user_kfilterc > 0xffffffff - EVFILT_SYSCOUNT) 238 return (EINVAL); /* too many */ 239 240 /* check if need to grow user_kfilters */ 241 if (user_kfilterc + 1 > user_kfiltermaxc) { 242 /* 243 * Grow in KFILTER_EXTENT chunks. Use malloc(9), because we 244 * want to traverse user_kfilters as an array. 245 */ 246 user_kfiltermaxc += KFILTER_EXTENT; 247 kfilter = malloc(user_kfiltermaxc * sizeof(struct filter *), 248 M_KEVENT, M_WAITOK); 249 250 /* copy existing user_kfilters */ 251 if (user_kfilters != NULL) 252 memcpy((caddr_t)kfilter, (caddr_t)user_kfilters, 253 user_kfilterc * sizeof(struct kfilter *)); 254 /* zero new sections */ 255 memset((caddr_t)kfilter + 256 user_kfilterc * sizeof(struct kfilter *), 0, 257 (user_kfiltermaxc - user_kfilterc) * 258 sizeof(struct kfilter *)); 259 /* switch to new kfilter */ 260 if (user_kfilters != NULL) 261 free(user_kfilters, M_KEVENT); 262 user_kfilters = kfilter; 263 } 264 len = strlen(name) + 1; /* copy name */ 265 space = malloc(len, M_KEVENT, M_WAITOK); 266 memcpy(space, name, len); 267 user_kfilters[user_kfilterc].name = space; 268 269 user_kfilters[user_kfilterc].filter = user_kfilterc + EVFILT_SYSCOUNT; 270 271 len = sizeof(struct filterops); /* copy filtops */ 272 space = malloc(len, M_KEVENT, M_WAITOK); 273 memcpy(space, filtops, len); 274 user_kfilters[user_kfilterc].filtops = space; 275 276 if (retfilter != NULL) 277 *retfilter = user_kfilters[user_kfilterc].filter; 278 user_kfilterc++; /* finally, increment count */ 279 return (0); 280 } 281 282 /* 283 * Unregister a kfilter previously registered with kfilter_register. 284 * This retains the filter id, but clears the name and frees filtops (filter 285 * operations), so that the number isn't reused during a boot. 286 * Returns 0 if operation succeeded, or an appropriate errno(2) otherwise. 287 */ 288 int 289 kfilter_unregister(const char *name) 290 { 291 struct kfilter *kfilter; 292 293 if (name == NULL || name[0] == '\0') 294 return (EINVAL); /* invalid name */ 295 296 if (kfilter_byname_sys(name) != NULL) 297 return (EINVAL); /* can't detach system filters */ 298 299 kfilter = kfilter_byname_user(name); 300 if (kfilter == NULL) /* not found */ 301 return (ENOENT); 302 303 if (kfilter->name[0] != '\0') { 304 /* XXXUNCONST Cast away const (but we know it's safe. */ 305 free(__UNCONST(kfilter->name), M_KEVENT); 306 kfilter->name = ""; /* mark as `not implemented' */ 307 } 308 if (kfilter->filtops != NULL) { 309 /* XXXUNCONST Cast away const (but we know it's safe. */ 310 free(__UNCONST(kfilter->filtops), M_KEVENT); 311 kfilter->filtops = NULL; /* mark as `not implemented' */ 312 } 313 return (0); 314 } 315 316 317 /* 318 * Filter attach method for EVFILT_READ and EVFILT_WRITE on normal file 319 * descriptors. Calls struct fileops kqfilter method for given file descriptor. 320 */ 321 static int 322 filt_fileattach(struct knote *kn) 323 { 324 struct file *fp; 325 326 fp = kn->kn_fp; 327 return ((*fp->f_ops->fo_kqfilter)(fp, kn)); 328 } 329 330 /* 331 * Filter detach method for EVFILT_READ on kqueue descriptor. 332 */ 333 static void 334 filt_kqdetach(struct knote *kn) 335 { 336 struct kqueue *kq; 337 338 kq = (struct kqueue *)kn->kn_fp->f_data; 339 SLIST_REMOVE(&kq->kq_sel.sel_klist, kn, knote, kn_selnext); 340 } 341 342 /* 343 * Filter event method for EVFILT_READ on kqueue descriptor. 344 */ 345 /*ARGSUSED*/ 346 static int 347 filt_kqueue(struct knote *kn, long hint) 348 { 349 struct kqueue *kq; 350 351 kq = (struct kqueue *)kn->kn_fp->f_data; 352 kn->kn_data = kq->kq_count; 353 return (kn->kn_data > 0); 354 } 355 356 /* 357 * Filter attach method for EVFILT_PROC. 358 */ 359 static int 360 filt_procattach(struct knote *kn) 361 { 362 struct proc *p; 363 364 p = pfind(kn->kn_id); 365 if (p == NULL) 366 return (ESRCH); 367 368 /* 369 * Fail if it's not owned by you, or the last exec gave us 370 * setuid/setgid privs (unless you're root). 371 */ 372 if ((kauth_cred_getuid(p->p_cred) != kauth_cred_getuid(curproc->p_cred) || 373 (p->p_flag & P_SUGID)) 374 && kauth_authorize_generic(curproc->p_cred, KAUTH_GENERIC_ISSUSER, 375 &curproc->p_acflag) != 0) 376 return (EACCES); 377 378 kn->kn_ptr.p_proc = p; 379 kn->kn_flags |= EV_CLEAR; /* automatically set */ 380 381 /* 382 * internal flag indicating registration done by kernel 383 */ 384 if (kn->kn_flags & EV_FLAG1) { 385 kn->kn_data = kn->kn_sdata; /* ppid */ 386 kn->kn_fflags = NOTE_CHILD; 387 kn->kn_flags &= ~EV_FLAG1; 388 } 389 390 /* XXXSMP lock the process? */ 391 SLIST_INSERT_HEAD(&p->p_klist, kn, kn_selnext); 392 393 return (0); 394 } 395 396 /* 397 * Filter detach method for EVFILT_PROC. 398 * 399 * The knote may be attached to a different process, which may exit, 400 * leaving nothing for the knote to be attached to. So when the process 401 * exits, the knote is marked as DETACHED and also flagged as ONESHOT so 402 * it will be deleted when read out. However, as part of the knote deletion, 403 * this routine is called, so a check is needed to avoid actually performing 404 * a detach, because the original process might not exist any more. 405 */ 406 static void 407 filt_procdetach(struct knote *kn) 408 { 409 struct proc *p; 410 411 if (kn->kn_status & KN_DETACHED) 412 return; 413 414 p = kn->kn_ptr.p_proc; 415 KASSERT(p->p_stat == SZOMB || pfind(kn->kn_id) == p); 416 417 /* XXXSMP lock the process? */ 418 SLIST_REMOVE(&p->p_klist, kn, knote, kn_selnext); 419 } 420 421 /* 422 * Filter event method for EVFILT_PROC. 423 */ 424 static int 425 filt_proc(struct knote *kn, long hint) 426 { 427 u_int event; 428 429 /* 430 * mask off extra data 431 */ 432 event = (u_int)hint & NOTE_PCTRLMASK; 433 434 /* 435 * if the user is interested in this event, record it. 436 */ 437 if (kn->kn_sfflags & event) 438 kn->kn_fflags |= event; 439 440 /* 441 * process is gone, so flag the event as finished. 442 */ 443 if (event == NOTE_EXIT) { 444 /* 445 * Detach the knote from watched process and mark 446 * it as such. We can't leave this to kqueue_scan(), 447 * since the process might not exist by then. And we 448 * have to do this now, since psignal KNOTE() is called 449 * also for zombies and we might end up reading freed 450 * memory if the kevent would already be picked up 451 * and knote g/c'ed. 452 */ 453 kn->kn_fop->f_detach(kn); 454 kn->kn_status |= KN_DETACHED; 455 456 /* Mark as ONESHOT, so that the knote it g/c'ed when read */ 457 kn->kn_flags |= (EV_EOF | EV_ONESHOT); 458 return (1); 459 } 460 461 /* 462 * process forked, and user wants to track the new process, 463 * so attach a new knote to it, and immediately report an 464 * event with the parent's pid. 465 */ 466 if ((event == NOTE_FORK) && (kn->kn_sfflags & NOTE_TRACK)) { 467 struct kevent kev; 468 int error; 469 470 /* 471 * register knote with new process. 472 */ 473 kev.ident = hint & NOTE_PDATAMASK; /* pid */ 474 kev.filter = kn->kn_filter; 475 kev.flags = kn->kn_flags | EV_ADD | EV_ENABLE | EV_FLAG1; 476 kev.fflags = kn->kn_sfflags; 477 kev.data = kn->kn_id; /* parent */ 478 kev.udata = kn->kn_kevent.udata; /* preserve udata */ 479 error = kqueue_register(kn->kn_kq, &kev, NULL); 480 if (error) 481 kn->kn_fflags |= NOTE_TRACKERR; 482 } 483 484 return (kn->kn_fflags != 0); 485 } 486 487 static void 488 filt_timerexpire(void *knx) 489 { 490 struct knote *kn = knx; 491 int tticks; 492 493 kn->kn_data++; 494 KNOTE_ACTIVATE(kn); 495 496 if ((kn->kn_flags & EV_ONESHOT) == 0) { 497 tticks = mstohz(kn->kn_sdata); 498 callout_schedule((struct callout *)kn->kn_hook, tticks); 499 } 500 } 501 502 /* 503 * data contains amount of time to sleep, in milliseconds 504 */ 505 static int 506 filt_timerattach(struct knote *kn) 507 { 508 struct callout *calloutp; 509 int tticks; 510 511 if (kq_ncallouts >= kq_calloutmax) 512 return (ENOMEM); 513 kq_ncallouts++; 514 515 tticks = mstohz(kn->kn_sdata); 516 517 /* if the supplied value is under our resolution, use 1 tick */ 518 if (tticks == 0) { 519 if (kn->kn_sdata == 0) 520 return (EINVAL); 521 tticks = 1; 522 } 523 524 kn->kn_flags |= EV_CLEAR; /* automatically set */ 525 MALLOC(calloutp, struct callout *, sizeof(*calloutp), 526 M_KEVENT, 0); 527 callout_init(calloutp); 528 callout_reset(calloutp, tticks, filt_timerexpire, kn); 529 kn->kn_hook = calloutp; 530 531 return (0); 532 } 533 534 static void 535 filt_timerdetach(struct knote *kn) 536 { 537 struct callout *calloutp; 538 539 calloutp = (struct callout *)kn->kn_hook; 540 callout_stop(calloutp); 541 FREE(calloutp, M_KEVENT); 542 kq_ncallouts--; 543 } 544 545 static int 546 filt_timer(struct knote *kn, long hint) 547 { 548 return (kn->kn_data != 0); 549 } 550 551 /* 552 * filt_seltrue: 553 * 554 * This filter "event" routine simulates seltrue(). 555 */ 556 int 557 filt_seltrue(struct knote *kn, long hint) 558 { 559 560 /* 561 * We don't know how much data can be read/written, 562 * but we know that it *can* be. This is about as 563 * good as select/poll does as well. 564 */ 565 kn->kn_data = 0; 566 return (1); 567 } 568 569 /* 570 * This provides full kqfilter entry for device switch tables, which 571 * has same effect as filter using filt_seltrue() as filter method. 572 */ 573 static void 574 filt_seltruedetach(struct knote *kn) 575 { 576 /* Nothing to do */ 577 } 578 579 static const struct filterops seltrue_filtops = 580 { 1, NULL, filt_seltruedetach, filt_seltrue }; 581 582 int 583 seltrue_kqfilter(dev_t dev, struct knote *kn) 584 { 585 switch (kn->kn_filter) { 586 case EVFILT_READ: 587 case EVFILT_WRITE: 588 kn->kn_fop = &seltrue_filtops; 589 break; 590 default: 591 return (1); 592 } 593 594 /* Nothing more to do */ 595 return (0); 596 } 597 598 /* 599 * kqueue(2) system call. 600 */ 601 int 602 sys_kqueue(struct lwp *l, void *v, register_t *retval) 603 { 604 struct filedesc *fdp; 605 struct kqueue *kq; 606 struct file *fp; 607 struct proc *p; 608 int fd, error; 609 610 p = l->l_proc; 611 fdp = p->p_fd; 612 error = falloc(p, &fp, &fd); /* setup a new file descriptor */ 613 if (error) 614 return (error); 615 fp->f_flag = FREAD | FWRITE; 616 fp->f_type = DTYPE_KQUEUE; 617 fp->f_ops = &kqueueops; 618 kq = pool_get(&kqueue_pool, PR_WAITOK); 619 memset((char *)kq, 0, sizeof(struct kqueue)); 620 simple_lock_init(&kq->kq_lock); 621 TAILQ_INIT(&kq->kq_head); 622 fp->f_data = (caddr_t)kq; /* store the kqueue with the fp */ 623 *retval = fd; 624 if (fdp->fd_knlistsize < 0) 625 fdp->fd_knlistsize = 0; /* this process has a kq */ 626 kq->kq_fdp = fdp; 627 FILE_SET_MATURE(fp); 628 FILE_UNUSE(fp, l); /* falloc() does FILE_USE() */ 629 return (error); 630 } 631 632 /* 633 * kevent(2) system call. 634 */ 635 static int 636 kevent_fetch_changes(void *private, const struct kevent *changelist, 637 struct kevent *changes, size_t index, int n) 638 { 639 return copyin(changelist + index, changes, n * sizeof(*changes)); 640 } 641 642 static int 643 kevent_put_events(void *private, struct kevent *events, 644 struct kevent *eventlist, size_t index, int n) 645 { 646 return copyout(events, eventlist + index, n * sizeof(*events)); 647 } 648 649 static const struct kevent_ops kevent_native_ops = { 650 keo_private: NULL, 651 keo_fetch_timeout: copyin, 652 keo_fetch_changes: kevent_fetch_changes, 653 keo_put_events: kevent_put_events, 654 }; 655 656 int 657 sys_kevent(struct lwp *l, void *v, register_t *retval) 658 { 659 struct sys_kevent_args /* { 660 syscallarg(int) fd; 661 syscallarg(const struct kevent *) changelist; 662 syscallarg(size_t) nchanges; 663 syscallarg(struct kevent *) eventlist; 664 syscallarg(size_t) nevents; 665 syscallarg(const struct timespec *) timeout; 666 } */ *uap = v; 667 668 return kevent1(l, retval, SCARG(uap, fd), SCARG(uap, changelist), 669 SCARG(uap, nchanges), SCARG(uap, eventlist), SCARG(uap, nevents), 670 SCARG(uap, timeout), &kevent_native_ops); 671 } 672 673 int 674 kevent1(struct lwp *l, register_t *retval, int fd, 675 const struct kevent *changelist, size_t nchanges, struct kevent *eventlist, 676 size_t nevents, const struct timespec *timeout, 677 const struct kevent_ops *keops) 678 { 679 struct kevent *kevp; 680 struct kqueue *kq; 681 struct file *fp; 682 struct timespec ts; 683 struct proc *p; 684 size_t i, n, ichange; 685 int nerrors, error; 686 687 p = l->l_proc; 688 /* check that we're dealing with a kq */ 689 fp = fd_getfile(p->p_fd, fd); 690 if (fp == NULL) 691 return (EBADF); 692 693 if (fp->f_type != DTYPE_KQUEUE) { 694 simple_unlock(&fp->f_slock); 695 return (EBADF); 696 } 697 698 FILE_USE(fp); 699 700 if (timeout != NULL) { 701 error = (*keops->keo_fetch_timeout)(timeout, &ts, sizeof(ts)); 702 if (error) 703 goto done; 704 timeout = &ts; 705 } 706 707 kq = (struct kqueue *)fp->f_data; 708 nerrors = 0; 709 ichange = 0; 710 711 /* traverse list of events to register */ 712 while (nchanges > 0) { 713 /* copyin a maximum of KQ_EVENTS at each pass */ 714 n = MIN(nchanges, KQ_NEVENTS); 715 error = (*keops->keo_fetch_changes)(keops->keo_private, 716 changelist, kq->kq_kev, ichange, n); 717 if (error) 718 goto done; 719 for (i = 0; i < n; i++) { 720 kevp = &kq->kq_kev[i]; 721 kevp->flags &= ~EV_SYSFLAGS; 722 /* register each knote */ 723 error = kqueue_register(kq, kevp, l); 724 if (error) { 725 if (nevents != 0) { 726 kevp->flags = EV_ERROR; 727 kevp->data = error; 728 error = (*keops->keo_put_events) 729 (keops->keo_private, kevp, 730 eventlist, nerrors, 1); 731 if (error) 732 goto done; 733 nevents--; 734 nerrors++; 735 } else { 736 goto done; 737 } 738 } 739 } 740 nchanges -= n; /* update the results */ 741 ichange += n; 742 } 743 if (nerrors) { 744 *retval = nerrors; 745 error = 0; 746 goto done; 747 } 748 749 /* actually scan through the events */ 750 error = kqueue_scan(fp, nevents, eventlist, timeout, l, retval, keops); 751 done: 752 FILE_UNUSE(fp, l); 753 return (error); 754 } 755 756 /* 757 * Register a given kevent kev onto the kqueue 758 */ 759 int 760 kqueue_register(struct kqueue *kq, struct kevent *kev, struct lwp *l) 761 { 762 const struct kfilter *kfilter; 763 struct filedesc *fdp; 764 struct file *fp; 765 struct knote *kn; 766 int s, error; 767 768 fdp = kq->kq_fdp; 769 fp = NULL; 770 kn = NULL; 771 error = 0; 772 kfilter = kfilter_byfilter(kev->filter); 773 if (kfilter == NULL || kfilter->filtops == NULL) { 774 /* filter not found nor implemented */ 775 return (EINVAL); 776 } 777 778 /* search if knote already exists */ 779 if (kfilter->filtops->f_isfd) { 780 /* monitoring a file descriptor */ 781 if ((fp = fd_getfile(fdp, kev->ident)) == NULL) 782 return (EBADF); /* validate descriptor */ 783 FILE_USE(fp); 784 785 if (kev->ident < fdp->fd_knlistsize) { 786 SLIST_FOREACH(kn, &fdp->fd_knlist[kev->ident], kn_link) 787 if (kq == kn->kn_kq && 788 kev->filter == kn->kn_filter) 789 break; 790 } 791 } else { 792 /* 793 * not monitoring a file descriptor, so 794 * lookup knotes in internal hash table 795 */ 796 if (fdp->fd_knhashmask != 0) { 797 struct klist *list; 798 799 list = &fdp->fd_knhash[ 800 KN_HASH((u_long)kev->ident, fdp->fd_knhashmask)]; 801 SLIST_FOREACH(kn, list, kn_link) 802 if (kev->ident == kn->kn_id && 803 kq == kn->kn_kq && 804 kev->filter == kn->kn_filter) 805 break; 806 } 807 } 808 809 if (kn == NULL && ((kev->flags & EV_ADD) == 0)) { 810 error = ENOENT; /* filter not found */ 811 goto done; 812 } 813 814 /* 815 * kn now contains the matching knote, or NULL if no match 816 */ 817 if (kev->flags & EV_ADD) { 818 /* add knote */ 819 820 if (kn == NULL) { 821 /* create new knote */ 822 kn = pool_get(&knote_pool, PR_WAITOK); 823 if (kn == NULL) { 824 error = ENOMEM; 825 goto done; 826 } 827 kn->kn_fp = fp; 828 kn->kn_kq = kq; 829 kn->kn_fop = kfilter->filtops; 830 831 /* 832 * apply reference count to knote structure, and 833 * do not release it at the end of this routine. 834 */ 835 fp = NULL; 836 837 kn->kn_sfflags = kev->fflags; 838 kn->kn_sdata = kev->data; 839 kev->fflags = 0; 840 kev->data = 0; 841 kn->kn_kevent = *kev; 842 843 knote_attach(kn, fdp); 844 if ((error = kfilter->filtops->f_attach(kn)) != 0) { 845 knote_drop(kn, l, fdp); 846 goto done; 847 } 848 } else { 849 /* modify existing knote */ 850 851 /* 852 * The user may change some filter values after the 853 * initial EV_ADD, but doing so will not reset any 854 * filter which have already been triggered. 855 */ 856 kn->kn_sfflags = kev->fflags; 857 kn->kn_sdata = kev->data; 858 kn->kn_kevent.udata = kev->udata; 859 } 860 861 s = splsched(); 862 if (kn->kn_fop->f_event(kn, 0)) 863 KNOTE_ACTIVATE(kn); 864 splx(s); 865 866 } else if (kev->flags & EV_DELETE) { /* delete knote */ 867 kn->kn_fop->f_detach(kn); 868 knote_drop(kn, l, fdp); 869 goto done; 870 } 871 872 /* disable knote */ 873 if ((kev->flags & EV_DISABLE) && 874 ((kn->kn_status & KN_DISABLED) == 0)) { 875 s = splsched(); 876 kn->kn_status |= KN_DISABLED; 877 splx(s); 878 } 879 880 /* enable knote */ 881 if ((kev->flags & EV_ENABLE) && (kn->kn_status & KN_DISABLED)) { 882 s = splsched(); 883 kn->kn_status &= ~KN_DISABLED; 884 if ((kn->kn_status & KN_ACTIVE) && 885 ((kn->kn_status & KN_QUEUED) == 0)) 886 knote_enqueue(kn); 887 splx(s); 888 } 889 890 done: 891 if (fp != NULL) 892 FILE_UNUSE(fp, l); 893 return (error); 894 } 895 896 /* 897 * Scan through the list of events on fp (for a maximum of maxevents), 898 * returning the results in to ulistp. Timeout is determined by tsp; if 899 * NULL, wait indefinitely, if 0 valued, perform a poll, otherwise wait 900 * as appropriate. 901 */ 902 static int 903 kqueue_scan(struct file *fp, size_t maxevents, struct kevent *ulistp, 904 const struct timespec *tsp, struct lwp *l, register_t *retval, 905 const struct kevent_ops *keops) 906 { 907 struct proc *p = l->l_proc; 908 struct kqueue *kq; 909 struct kevent *kevp; 910 struct timeval atv; 911 struct knote *kn, *marker=NULL; 912 size_t count, nkev, nevents; 913 int s, timeout, error; 914 915 kq = (struct kqueue *)fp->f_data; 916 count = maxevents; 917 nkev = nevents = error = 0; 918 if (count == 0) 919 goto done; 920 921 if (tsp) { /* timeout supplied */ 922 TIMESPEC_TO_TIMEVAL(&atv, tsp); 923 if (itimerfix(&atv)) { 924 error = EINVAL; 925 goto done; 926 } 927 timeout = tvtohz(&atv); 928 if (timeout <= 0) 929 timeout = -1; /* do poll */ 930 } else { 931 /* no timeout, wait forever */ 932 timeout = 0; 933 } 934 935 MALLOC(marker, struct knote *, sizeof(*marker), M_KEVENT, M_WAITOK); 936 memset(marker, 0, sizeof(*marker)); 937 938 goto start; 939 940 retry: 941 if (tsp) { 942 /* 943 * We have to recalculate the timeout on every retry. 944 */ 945 timeout = hzto(&atv); 946 if (timeout <= 0) 947 goto done; 948 } 949 950 start: 951 kevp = kq->kq_kev; 952 s = splsched(); 953 simple_lock(&kq->kq_lock); 954 if (kq->kq_count == 0) { 955 if (timeout < 0) { 956 error = EWOULDBLOCK; 957 simple_unlock(&kq->kq_lock); 958 } else { 959 kq->kq_state |= KQ_SLEEP; 960 error = ltsleep(kq, PSOCK | PCATCH | PNORELOCK, 961 "kqread", timeout, &kq->kq_lock); 962 } 963 splx(s); 964 if (error == 0) 965 goto retry; 966 /* don't restart after signals... */ 967 if (error == ERESTART) 968 error = EINTR; 969 else if (error == EWOULDBLOCK) 970 error = 0; 971 goto done; 972 } 973 974 /* mark end of knote list */ 975 TAILQ_INSERT_TAIL(&kq->kq_head, marker, kn_tqe); 976 simple_unlock(&kq->kq_lock); 977 978 while (count) { /* while user wants data ... */ 979 simple_lock(&kq->kq_lock); 980 kn = TAILQ_FIRST(&kq->kq_head); /* get next knote */ 981 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 982 if (kn == marker) { /* if it's our marker, stop */ 983 /* What if it's some else's marker? */ 984 simple_unlock(&kq->kq_lock); 985 splx(s); 986 if (count == maxevents) 987 goto retry; 988 goto done; 989 } 990 kq->kq_count--; 991 simple_unlock(&kq->kq_lock); 992 993 if (kn->kn_status & KN_DISABLED) { 994 /* don't want disabled events */ 995 kn->kn_status &= ~KN_QUEUED; 996 continue; 997 } 998 if ((kn->kn_flags & EV_ONESHOT) == 0 && 999 kn->kn_fop->f_event(kn, 0) == 0) { 1000 /* 1001 * non-ONESHOT event that hasn't 1002 * triggered again, so de-queue. 1003 */ 1004 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE); 1005 continue; 1006 } 1007 *kevp = kn->kn_kevent; 1008 kevp++; 1009 nkev++; 1010 if (kn->kn_flags & EV_ONESHOT) { 1011 /* delete ONESHOT events after retrieval */ 1012 kn->kn_status &= ~KN_QUEUED; 1013 splx(s); 1014 kn->kn_fop->f_detach(kn); 1015 knote_drop(kn, l, p->p_fd); 1016 s = splsched(); 1017 } else if (kn->kn_flags & EV_CLEAR) { 1018 /* clear state after retrieval */ 1019 kn->kn_data = 0; 1020 kn->kn_fflags = 0; 1021 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE); 1022 } else { 1023 /* add event back on list */ 1024 simple_lock(&kq->kq_lock); 1025 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe); 1026 kq->kq_count++; 1027 simple_unlock(&kq->kq_lock); 1028 } 1029 count--; 1030 if (nkev == KQ_NEVENTS) { 1031 /* do copyouts in KQ_NEVENTS chunks */ 1032 splx(s); 1033 error = (*keops->keo_put_events)(keops->keo_private, 1034 &kq->kq_kev[0], ulistp, nevents, nkev); 1035 nevents += nkev; 1036 nkev = 0; 1037 kevp = kq->kq_kev; 1038 s = splsched(); 1039 if (error) 1040 break; 1041 } 1042 } 1043 1044 /* remove marker */ 1045 simple_lock(&kq->kq_lock); 1046 TAILQ_REMOVE(&kq->kq_head, marker, kn_tqe); 1047 simple_unlock(&kq->kq_lock); 1048 splx(s); 1049 done: 1050 if (marker) 1051 FREE(marker, M_KEVENT); 1052 1053 if (nkev != 0) 1054 /* copyout remaining events */ 1055 error = (*keops->keo_put_events)(keops->keo_private, 1056 &kq->kq_kev[0], ulistp, nevents, nkev); 1057 *retval = maxevents - count; 1058 1059 return (error); 1060 } 1061 1062 /* 1063 * struct fileops read method for a kqueue descriptor. 1064 * Not implemented. 1065 * XXX: This could be expanded to call kqueue_scan, if desired. 1066 */ 1067 /*ARGSUSED*/ 1068 static int 1069 kqueue_read(struct file *fp, off_t *offset, struct uio *uio, 1070 kauth_cred_t cred, int flags) 1071 { 1072 1073 return (ENXIO); 1074 } 1075 1076 /* 1077 * struct fileops write method for a kqueue descriptor. 1078 * Not implemented. 1079 */ 1080 /*ARGSUSED*/ 1081 static int 1082 kqueue_write(struct file *fp, off_t *offset, struct uio *uio, 1083 kauth_cred_t cred, int flags) 1084 { 1085 1086 return (ENXIO); 1087 } 1088 1089 /* 1090 * struct fileops ioctl method for a kqueue descriptor. 1091 * 1092 * Two ioctls are currently supported. They both use struct kfilter_mapping: 1093 * KFILTER_BYNAME find name for filter, and return result in 1094 * name, which is of size len. 1095 * KFILTER_BYFILTER find filter for name. len is ignored. 1096 */ 1097 /*ARGSUSED*/ 1098 static int 1099 kqueue_ioctl(struct file *fp, u_long com, void *data, struct lwp *l) 1100 { 1101 struct kfilter_mapping *km; 1102 const struct kfilter *kfilter; 1103 char *name; 1104 int error; 1105 1106 km = (struct kfilter_mapping *)data; 1107 error = 0; 1108 1109 switch (com) { 1110 case KFILTER_BYFILTER: /* convert filter -> name */ 1111 kfilter = kfilter_byfilter(km->filter); 1112 if (kfilter != NULL) 1113 error = copyoutstr(kfilter->name, km->name, km->len, 1114 NULL); 1115 else 1116 error = ENOENT; 1117 break; 1118 1119 case KFILTER_BYNAME: /* convert name -> filter */ 1120 MALLOC(name, char *, KFILTER_MAXNAME, M_KEVENT, M_WAITOK); 1121 error = copyinstr(km->name, name, KFILTER_MAXNAME, NULL); 1122 if (error) { 1123 FREE(name, M_KEVENT); 1124 break; 1125 } 1126 kfilter = kfilter_byname(name); 1127 if (kfilter != NULL) 1128 km->filter = kfilter->filter; 1129 else 1130 error = ENOENT; 1131 FREE(name, M_KEVENT); 1132 break; 1133 1134 default: 1135 error = ENOTTY; 1136 1137 } 1138 return (error); 1139 } 1140 1141 /* 1142 * struct fileops fcntl method for a kqueue descriptor. 1143 * Not implemented. 1144 */ 1145 /*ARGSUSED*/ 1146 static int 1147 kqueue_fcntl(struct file *fp, u_int com, void *data, struct lwp *l) 1148 { 1149 1150 return (ENOTTY); 1151 } 1152 1153 /* 1154 * struct fileops poll method for a kqueue descriptor. 1155 * Determine if kqueue has events pending. 1156 */ 1157 static int 1158 kqueue_poll(struct file *fp, int events, struct lwp *l) 1159 { 1160 struct kqueue *kq; 1161 int revents; 1162 1163 kq = (struct kqueue *)fp->f_data; 1164 revents = 0; 1165 if (events & (POLLIN | POLLRDNORM)) { 1166 if (kq->kq_count) { 1167 revents |= events & (POLLIN | POLLRDNORM); 1168 } else { 1169 selrecord(l, &kq->kq_sel); 1170 } 1171 } 1172 return (revents); 1173 } 1174 1175 /* 1176 * struct fileops stat method for a kqueue descriptor. 1177 * Returns dummy info, with st_size being number of events pending. 1178 */ 1179 static int 1180 kqueue_stat(struct file *fp, struct stat *st, struct lwp *l) 1181 { 1182 struct kqueue *kq; 1183 1184 kq = (struct kqueue *)fp->f_data; 1185 memset((void *)st, 0, sizeof(*st)); 1186 st->st_size = kq->kq_count; 1187 st->st_blksize = sizeof(struct kevent); 1188 st->st_mode = S_IFIFO; 1189 return (0); 1190 } 1191 1192 /* 1193 * struct fileops close method for a kqueue descriptor. 1194 * Cleans up kqueue. 1195 */ 1196 static int 1197 kqueue_close(struct file *fp, struct lwp *l) 1198 { 1199 struct proc *p = l->l_proc; 1200 struct kqueue *kq; 1201 struct filedesc *fdp; 1202 struct knote **knp, *kn, *kn0; 1203 int i; 1204 1205 kq = (struct kqueue *)fp->f_data; 1206 fdp = p->p_fd; 1207 for (i = 0; i < fdp->fd_knlistsize; i++) { 1208 knp = &SLIST_FIRST(&fdp->fd_knlist[i]); 1209 kn = *knp; 1210 while (kn != NULL) { 1211 kn0 = SLIST_NEXT(kn, kn_link); 1212 if (kq == kn->kn_kq) { 1213 kn->kn_fop->f_detach(kn); 1214 FILE_UNUSE(kn->kn_fp, l); 1215 pool_put(&knote_pool, kn); 1216 *knp = kn0; 1217 } else { 1218 knp = &SLIST_NEXT(kn, kn_link); 1219 } 1220 kn = kn0; 1221 } 1222 } 1223 if (fdp->fd_knhashmask != 0) { 1224 for (i = 0; i < fdp->fd_knhashmask + 1; i++) { 1225 knp = &SLIST_FIRST(&fdp->fd_knhash[i]); 1226 kn = *knp; 1227 while (kn != NULL) { 1228 kn0 = SLIST_NEXT(kn, kn_link); 1229 if (kq == kn->kn_kq) { 1230 kn->kn_fop->f_detach(kn); 1231 /* XXX non-fd release of kn->kn_ptr */ 1232 pool_put(&knote_pool, kn); 1233 *knp = kn0; 1234 } else { 1235 knp = &SLIST_NEXT(kn, kn_link); 1236 } 1237 kn = kn0; 1238 } 1239 } 1240 } 1241 pool_put(&kqueue_pool, kq); 1242 fp->f_data = NULL; 1243 1244 return (0); 1245 } 1246 1247 /* 1248 * wakeup a kqueue 1249 */ 1250 static void 1251 kqueue_wakeup(struct kqueue *kq) 1252 { 1253 int s; 1254 1255 s = splsched(); 1256 simple_lock(&kq->kq_lock); 1257 if (kq->kq_state & KQ_SLEEP) { /* if currently sleeping ... */ 1258 kq->kq_state &= ~KQ_SLEEP; 1259 wakeup(kq); /* ... wakeup */ 1260 } 1261 1262 /* Notify select/poll and kevent. */ 1263 selnotify(&kq->kq_sel, 0); 1264 simple_unlock(&kq->kq_lock); 1265 splx(s); 1266 } 1267 1268 /* 1269 * struct fileops kqfilter method for a kqueue descriptor. 1270 * Event triggered when monitored kqueue changes. 1271 */ 1272 /*ARGSUSED*/ 1273 static int 1274 kqueue_kqfilter(struct file *fp, struct knote *kn) 1275 { 1276 struct kqueue *kq; 1277 1278 KASSERT(fp == kn->kn_fp); 1279 kq = (struct kqueue *)kn->kn_fp->f_data; 1280 if (kn->kn_filter != EVFILT_READ) 1281 return (1); 1282 kn->kn_fop = &kqread_filtops; 1283 SLIST_INSERT_HEAD(&kq->kq_sel.sel_klist, kn, kn_selnext); 1284 return (0); 1285 } 1286 1287 1288 /* 1289 * Walk down a list of knotes, activating them if their event has triggered. 1290 */ 1291 void 1292 knote(struct klist *list, long hint) 1293 { 1294 struct knote *kn; 1295 1296 SLIST_FOREACH(kn, list, kn_selnext) 1297 if (kn->kn_fop->f_event(kn, hint)) 1298 KNOTE_ACTIVATE(kn); 1299 } 1300 1301 /* 1302 * Remove all knotes from a specified klist 1303 */ 1304 void 1305 knote_remove(struct lwp *l, struct klist *list) 1306 { 1307 struct knote *kn; 1308 1309 while ((kn = SLIST_FIRST(list)) != NULL) { 1310 kn->kn_fop->f_detach(kn); 1311 knote_drop(kn, l, l->l_proc->p_fd); 1312 } 1313 } 1314 1315 /* 1316 * Remove all knotes referencing a specified fd 1317 */ 1318 void 1319 knote_fdclose(struct lwp *l, int fd) 1320 { 1321 struct filedesc *fdp; 1322 struct klist *list; 1323 1324 fdp = l->l_proc->p_fd; 1325 list = &fdp->fd_knlist[fd]; 1326 knote_remove(l, list); 1327 } 1328 1329 /* 1330 * Attach a new knote to a file descriptor 1331 */ 1332 static void 1333 knote_attach(struct knote *kn, struct filedesc *fdp) 1334 { 1335 struct klist *list; 1336 int size; 1337 1338 if (! kn->kn_fop->f_isfd) { 1339 /* if knote is not on an fd, store on internal hash table */ 1340 if (fdp->fd_knhashmask == 0) 1341 fdp->fd_knhash = hashinit(KN_HASHSIZE, HASH_LIST, 1342 M_KEVENT, M_WAITOK, &fdp->fd_knhashmask); 1343 list = &fdp->fd_knhash[KN_HASH(kn->kn_id, fdp->fd_knhashmask)]; 1344 goto done; 1345 } 1346 1347 /* 1348 * otherwise, knote is on an fd. 1349 * knotes are stored in fd_knlist indexed by kn->kn_id. 1350 */ 1351 if (fdp->fd_knlistsize <= kn->kn_id) { 1352 /* expand list, it's too small */ 1353 size = fdp->fd_knlistsize; 1354 while (size <= kn->kn_id) { 1355 /* grow in KQ_EXTENT chunks */ 1356 size += KQ_EXTENT; 1357 } 1358 list = malloc(size * sizeof(struct klist *), M_KEVENT,M_WAITOK); 1359 if (fdp->fd_knlist) { 1360 /* copy existing knlist */ 1361 memcpy((caddr_t)list, (caddr_t)fdp->fd_knlist, 1362 fdp->fd_knlistsize * sizeof(struct klist *)); 1363 } 1364 /* 1365 * Zero new memory. Stylistically, SLIST_INIT() should be 1366 * used here, but that does same thing as the memset() anyway. 1367 */ 1368 memset(&list[fdp->fd_knlistsize], 0, 1369 (size - fdp->fd_knlistsize) * sizeof(struct klist *)); 1370 1371 /* switch to new knlist */ 1372 if (fdp->fd_knlist != NULL) 1373 free(fdp->fd_knlist, M_KEVENT); 1374 fdp->fd_knlistsize = size; 1375 fdp->fd_knlist = list; 1376 } 1377 1378 /* get list head for this fd */ 1379 list = &fdp->fd_knlist[kn->kn_id]; 1380 done: 1381 /* add new knote */ 1382 SLIST_INSERT_HEAD(list, kn, kn_link); 1383 kn->kn_status = 0; 1384 } 1385 1386 /* 1387 * Drop knote. 1388 * Should be called at spl == 0, since we don't want to hold spl 1389 * while calling FILE_UNUSE and free. 1390 */ 1391 static void 1392 knote_drop(struct knote *kn, struct lwp *l, struct filedesc *fdp) 1393 { 1394 struct klist *list; 1395 1396 if (kn->kn_fop->f_isfd) 1397 list = &fdp->fd_knlist[kn->kn_id]; 1398 else 1399 list = &fdp->fd_knhash[KN_HASH(kn->kn_id, fdp->fd_knhashmask)]; 1400 1401 SLIST_REMOVE(list, kn, knote, kn_link); 1402 if (kn->kn_status & KN_QUEUED) 1403 knote_dequeue(kn); 1404 if (kn->kn_fop->f_isfd) 1405 FILE_UNUSE(kn->kn_fp, l); 1406 pool_put(&knote_pool, kn); 1407 } 1408 1409 1410 /* 1411 * Queue new event for knote. 1412 */ 1413 static void 1414 knote_enqueue(struct knote *kn) 1415 { 1416 struct kqueue *kq; 1417 int s; 1418 1419 kq = kn->kn_kq; 1420 KASSERT((kn->kn_status & KN_QUEUED) == 0); 1421 1422 s = splsched(); 1423 simple_lock(&kq->kq_lock); 1424 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe); 1425 kn->kn_status |= KN_QUEUED; 1426 kq->kq_count++; 1427 simple_unlock(&kq->kq_lock); 1428 splx(s); 1429 kqueue_wakeup(kq); 1430 } 1431 1432 /* 1433 * Dequeue event for knote. 1434 */ 1435 static void 1436 knote_dequeue(struct knote *kn) 1437 { 1438 struct kqueue *kq; 1439 int s; 1440 1441 KASSERT(kn->kn_status & KN_QUEUED); 1442 kq = kn->kn_kq; 1443 1444 s = splsched(); 1445 simple_lock(&kq->kq_lock); 1446 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe); 1447 kn->kn_status &= ~KN_QUEUED; 1448 kq->kq_count--; 1449 simple_unlock(&kq->kq_lock); 1450 splx(s); 1451 } 1452