Lines Matching defs:kn
146 static int knote_attach(struct knote *kn, struct kqueue *kq);
147 static void knote_drop(struct knote *kn, struct thread *td);
148 static void knote_drop_detached(struct knote *kn, struct thread *td);
149 static void knote_enqueue(struct knote *kn);
150 static void knote_dequeue(struct knote *kn);
153 static void knote_free(struct knote *kn);
155 static void filt_kqdetach(struct knote *kn);
156 static int filt_kqueue(struct knote *kn, long hint);
157 static int filt_procattach(struct knote *kn);
158 static void filt_procdetach(struct knote *kn);
159 static int filt_proc(struct knote *kn, long hint);
160 static int filt_fileattach(struct knote *kn);
162 static void filt_timerexpire_l(struct knote *kn, bool proc_locked);
163 static int filt_timerattach(struct knote *kn);
164 static void filt_timerdetach(struct knote *kn);
165 static void filt_timerstart(struct knote *kn, sbintime_t to);
166 static void filt_timertouch(struct knote *kn, struct kevent *kev,
168 static int filt_timervalidate(struct knote *kn, sbintime_t *to);
169 static int filt_timer(struct knote *kn, long hint);
170 static int filt_userattach(struct knote *kn);
171 static void filt_userdetach(struct knote *kn);
172 static int filt_user(struct knote *kn, long hint);
173 static void filt_usertouch(struct knote *kn, struct kevent *kev,
213 #define KNOTE_ACTIVATE(kn, islock) do { \
215 mtx_assert(&(kn)->kn_kq->kq_lock, MA_OWNED); \
217 KQ_LOCK((kn)->kn_kq); \
218 (kn)->kn_status |= KN_ACTIVE; \
219 if (((kn)->kn_status & (KN_QUEUED | KN_DISABLED)) == 0) \
220 knote_enqueue((kn)); \
222 KQ_UNLOCK((kn)->kn_kq); \
248 kn_list_lock(struct knote *kn)
252 knl = kn->kn_knlist;
274 kn_in_flux(struct knote *kn)
277 return (kn->kn_influx > 0);
281 kn_enter_flux(struct knote *kn)
284 KQ_OWNED(kn->kn_kq);
285 MPASS(kn->kn_influx < INT_MAX);
286 kn->kn_influx++;
290 kn_leave_flux(struct knote *kn)
293 KQ_OWNED(kn->kn_kq);
294 MPASS(kn->kn_influx > 0);
295 kn->kn_influx--;
296 return (kn->kn_influx == 0);
324 filt_nullattach(struct knote *kn)
369 filt_fileattach(struct knote *kn)
372 return (fo_kqfilter(kn->kn_fp, kn));
377 kqueue_kqfilter(struct file *fp, struct knote *kn)
379 struct kqueue *kq = kn->kn_fp->f_data;
381 if (kn->kn_filter != EVFILT_READ)
384 kn->kn_status |= KN_KQUEUE;
385 kn->kn_fop = &kqread_filtops;
386 knlist_add(&kq->kq_sel.si_note, kn, 0);
392 filt_kqdetach(struct knote *kn)
394 struct kqueue *kq = kn->kn_fp->f_data;
396 knlist_remove(&kq->kq_sel.si_note, kn, 0);
401 filt_kqueue(struct knote *kn, long hint)
403 struct kqueue *kq = kn->kn_fp->f_data;
405 kn->kn_data = kq->kq_count;
406 return (kn->kn_data > 0);
411 filt_procattach(struct knote *kn)
418 if (kn->kn_sfflags & NOTE_EXIT)
419 p = pfind_any(kn->kn_id);
421 p = pfind(kn->kn_id);
432 kn->kn_ptr.p_proc = p;
433 kn->kn_flags |= EV_CLEAR; /* automatically set */
439 if (kn->kn_flags & EV_FLAG2) {
440 kn->kn_flags &= ~EV_FLAG2;
441 kn->kn_data = kn->kn_sdata; /* ppid */
442 kn->kn_fflags = NOTE_CHILD;
443 kn->kn_sfflags &= ~(NOTE_EXIT | NOTE_EXEC | NOTE_FORK);
450 if (kn->kn_flags & EV_FLAG1) {
451 kn->kn_flags &= ~EV_FLAG1;
454 knlist_add(p->p_klist, kn, 1);
462 if (immediate || (exiting && filt_proc(kn, NOTE_EXIT)))
463 KNOTE_ACTIVATE(kn, 0);
480 filt_procdetach(struct knote *kn)
483 knlist_remove(kn->kn_knlist, kn, 0);
484 kn->kn_ptr.p_proc = NULL;
489 filt_proc(struct knote *kn, long hint)
494 p = kn->kn_ptr.p_proc;
502 if (kn->kn_sfflags & event)
503 kn->kn_fflags |= event;
507 kn->kn_flags |= EV_EOF | EV_ONESHOT;
508 kn->kn_ptr.p_proc = NULL;
509 if (kn->kn_fflags & NOTE_EXIT)
510 kn->kn_data = KW_EXITCODE(p->p_xexit, p->p_xsig);
511 if (kn->kn_fflags == 0)
512 kn->kn_flags |= EV_DROP;
516 return (kn->kn_fflags != 0);
531 struct knote *kn;
541 SLIST_FOREACH(kn, &list->kl_list, kn_selnext) {
542 kq = kn->kn_kq;
544 if (kn_in_flux(kn) && (kn->kn_status & KN_SCAN) == 0) {
552 if ((kn->kn_sfflags & NOTE_TRACK) == 0) {
553 if (kn->kn_fop->f_event(kn, NOTE_FORK))
554 KNOTE_ACTIVATE(kn, 1);
565 kn_enter_flux(kn);
579 kev.filter = kn->kn_filter;
580 kev.flags = kn->kn_flags | EV_ADD | EV_ENABLE | EV_ONESHOT |
582 kev.fflags = kn->kn_sfflags;
583 kev.data = kn->kn_id; /* parent */
584 kev.udata = kn->kn_kevent.udata;/* preserve udata */
587 kn->kn_fflags |= NOTE_TRACKERR;
594 kev.filter = kn->kn_filter;
595 kev.flags = kn->kn_flags | EV_ADD | EV_ENABLE | EV_FLAG1;
596 kev.fflags = kn->kn_sfflags;
597 kev.data = kn->kn_id; /* parent */
598 kev.udata = kn->kn_kevent.udata;/* preserve udata */
601 kn->kn_fflags |= NOTE_TRACKERR;
602 if (kn->kn_fop->f_event(kn, NOTE_FORK))
603 KNOTE_ACTIVATE(kn, 0);
606 kn_leave_flux(kn);
678 struct knote *kn;
691 callout_reset_sbt_on(&kc->c, kc->next, 0, filt_timerexpire, kc->kn,
711 filt_timerexpire_l(kc->kn, true);
718 filt_timerexpire_l(struct knote *kn, bool proc_locked)
725 kc = kn->kn_ptr.p_v;
727 if ((kn->kn_flags & EV_ONESHOT) != 0 || kc->to == 0) {
728 kn->kn_data++;
729 KNOTE_ACTIVATE(kn, 0);
738 kn->kn_data += delta;
742 KNOTE_ACTIVATE(kn, 0); /* XXX - handle locking */
781 filt_timervalidate(struct knote *kn, sbintime_t *to)
786 if (kn->kn_sdata < 0)
788 if (kn->kn_sdata == 0 && (kn->kn_flags & EV_ONESHOT) == 0)
789 kn->kn_sdata = 1;
794 if ((kn->kn_sfflags & ~(NOTE_TIMER_PRECMASK | NOTE_ABSTIME)) != 0)
797 *to = timer2sbintime(kn->kn_sdata, kn->kn_sfflags);
800 if ((kn->kn_sfflags & NOTE_ABSTIME) != 0) {
809 filt_timerattach(struct knote *kn)
816 error = filt_timervalidate(kn, &to);
819 KASSERT(to > 0 || (kn->kn_flags & EV_ONESHOT) != 0 ||
820 (kn->kn_sfflags & NOTE_ABSTIME) != 0,
830 if ((kn->kn_sfflags & NOTE_ABSTIME) == 0)
831 kn->kn_flags |= EV_CLEAR; /* automatically set */
832 kn->kn_status &= ~KN_DETACHED; /* knlist_add clears it */
833 kn->kn_ptr.p_v = kc = malloc(sizeof(*kc), M_KQUEUE, M_WAITOK);
834 kc->kn = kn;
839 filt_timerstart(kn, to);
845 filt_timerstart(struct knote *kn, sbintime_t to)
849 kc = kn->kn_ptr.p_v;
850 if ((kn->kn_sfflags & NOTE_ABSTIME) != 0) {
861 filt_timerdetach(struct knote *kn)
867 kc = kn->kn_ptr.p_v;
886 kn->kn_status |= KN_DETACHED; /* knlist_remove sets it */
890 filt_timertouch(struct knote *kn, struct kevent *kev, u_long type)
901 kc = kn->kn_ptr.p_v;
921 kq = kn->kn_kq;
923 if (kn->kn_status & KN_QUEUED)
924 knote_dequeue(kn);
926 kn->kn_status &= ~KN_ACTIVE;
927 kn->kn_data = 0;
931 kn->kn_sfflags = kev->fflags;
932 kn->kn_sdata = kev->data;
933 error = filt_timervalidate(kn, &to);
935 kn->kn_flags |= EV_ERROR;
936 kn->kn_data = error;
938 filt_timerstart(kn, to);
943 *kev = kn->kn_kevent;
944 if (kn->kn_flags & EV_CLEAR) {
945 kn->kn_data = 0;
946 kn->kn_fflags = 0;
957 filt_timer(struct knote *kn, long hint)
960 return (kn->kn_data != 0);
964 filt_userattach(struct knote *kn)
970 kn->kn_hook = NULL;
971 if (kn->kn_fflags & NOTE_TRIGGER)
972 kn->kn_hookid = 1;
974 kn->kn_hookid = 0;
979 filt_userdetach(__unused struct knote *kn)
988 filt_user(struct knote *kn, __unused long hint)
991 return (kn->kn_hookid);
995 filt_usertouch(struct knote *kn, struct kevent *kev, u_long type)
1002 kn->kn_hookid = 1;
1011 kn->kn_sfflags &= kev->fflags;
1015 kn->kn_sfflags |= kev->fflags;
1019 kn->kn_sfflags = kev->fflags;
1026 kn->kn_sdata = kev->data;
1028 kn->kn_hookid = 0;
1029 kn->kn_data = 0;
1030 kn->kn_fflags = 0;
1035 *kev = kn->kn_kevent;
1036 kev->fflags = kn->kn_sfflags;
1037 kev->data = kn->kn_sdata;
1038 if (kn->kn_flags & EV_CLEAR) {
1039 kn->kn_hookid = 0;
1040 kn->kn_data = 0;
1041 kn->kn_fflags = 0;
1494 struct knote *kn, *tkn;
1503 kn = NULL;
1578 SLIST_FOREACH(kn, &kq->kq_knlist[kev->ident], kn_link)
1579 if (kev->filter == kn->kn_filter)
1606 SLIST_FOREACH(kn, list, kn_link)
1607 if (kev->ident == kn->kn_id &&
1608 kev->filter == kn->kn_filter)
1614 if (kn != NULL && kn_in_flux(kn)) {
1630 * kn now contains the matching knote, or NULL if no match
1632 if (kn == NULL) {
1634 kn = tkn;
1636 if (kn == NULL) {
1641 kn->kn_fp = fp;
1642 kn->kn_kq = kq;
1643 kn->kn_fop = fops;
1651 kn->kn_sfflags = kev->fflags;
1652 kn->kn_sdata = kev->data;
1655 kn->kn_kevent = *kev;
1656 kn->kn_kevent.flags &= ~(EV_ADD | EV_DELETE |
1658 kn->kn_status = KN_DETACHED;
1660 kn->kn_status |= KN_DISABLED;
1661 kn_enter_flux(kn);
1663 error = knote_attach(kn, kq);
1666 tkn = kn;
1670 if ((error = kn->kn_fop->f_attach(kn)) != 0) {
1671 knote_drop_detached(kn, td);
1674 knl = kn_list_lock(kn);
1685 kn_enter_flux(kn);
1687 knote_drop(kn, td);
1692 kn->kn_flags |= EV_ONESHOT;
1693 KNOTE_ACTIVATE(kn, 1);
1697 kn->kn_status &= ~KN_DISABLED;
1699 kn->kn_status |= KN_DISABLED;
1706 kn->kn_status |= KN_SCAN;
1707 kn_enter_flux(kn);
1709 knl = kn_list_lock(kn);
1711 kn->kn_kevent.udata = kev->udata;
1713 fops->f_touch(kn, kev, EVENT_REGISTER);
1715 kn->kn_sfflags = kev->fflags;
1716 kn->kn_sdata = kev->data;
1721 * We can get here with kn->kn_knlist == NULL. This can happen when
1730 if ((kn->kn_status & KN_DISABLED) == 0)
1731 event = kn->kn_fop->f_event(kn, 0);
1737 kn->kn_status |= KN_ACTIVE;
1738 if ((kn->kn_status & (KN_ACTIVE | KN_DISABLED | KN_QUEUED)) ==
1740 knote_enqueue(kn);
1741 kn->kn_status &= ~KN_SCAN;
1742 kn_leave_flux(kn);
1919 struct knote *kn, *marker;
1986 kn = TAILQ_FIRST(&kq->kq_head);
1988 if ((kn->kn_status == KN_MARKER && kn != marker) ||
1989 kn_in_flux(kn)) {
2000 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe);
2001 if ((kn->kn_status & KN_DISABLED) == KN_DISABLED) {
2002 kn->kn_status &= ~KN_QUEUED;
2006 if (kn == marker) {
2012 KASSERT(!kn_in_flux(kn),
2013 ("knote %p is unexpectedly in flux", kn));
2015 if ((kn->kn_flags & EV_DROP) == EV_DROP) {
2016 kn->kn_status &= ~KN_QUEUED;
2017 kn_enter_flux(kn);
2024 knote_drop(kn, td);
2027 } else if ((kn->kn_flags & EV_ONESHOT) == EV_ONESHOT) {
2028 kn->kn_status &= ~KN_QUEUED;
2029 kn_enter_flux(kn);
2036 *kevp = kn->kn_kevent;
2037 knote_drop(kn, td);
2039 kn = NULL;
2041 kn->kn_status |= KN_SCAN;
2042 kn_enter_flux(kn);
2044 if ((kn->kn_status & KN_KQUEUE) == KN_KQUEUE)
2046 knl = kn_list_lock(kn);
2047 if (kn->kn_fop->f_event(kn, 0) == 0) {
2050 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE |
2052 kn_leave_flux(kn);
2058 touch = (!kn->kn_fop->f_isfd &&
2059 kn->kn_fop->f_touch != NULL);
2061 kn->kn_fop->f_touch(kn, kevp, EVENT_PROCESS);
2063 *kevp = kn->kn_kevent;
2066 if (kn->kn_flags & (EV_CLEAR | EV_DISPATCH)) {
2071 if (touch == 0 && kn->kn_flags & EV_CLEAR) {
2072 kn->kn_data = 0;
2073 kn->kn_fflags = 0;
2075 if (kn->kn_flags & EV_DISPATCH)
2076 kn->kn_status |= KN_DISABLED;
2077 kn->kn_status &= ~(KN_QUEUED | KN_ACTIVE);
2080 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe);
2082 kn->kn_status &= ~KN_SCAN;
2083 kn_leave_flux(kn);
2212 struct knote *kn;
2229 while ((kn = SLIST_FIRST(&kq->kq_knlist[i])) != NULL) {
2230 if (kn_in_flux(kn)) {
2235 kn_enter_flux(kn);
2237 knote_drop(kn, td);
2243 while ((kn = SLIST_FIRST(&kq->kq_knhash[i])) != NULL) {
2244 if (kn_in_flux(kn)) {
2250 kn_enter_flux(kn);
2252 knote_drop(kn, td);
2374 struct knote *kn, *tkn;
2392 SLIST_FOREACH_SAFE(kn, &list->kl_list, kn_selnext, tkn) {
2393 kq = kn->kn_kq;
2395 if (kn_in_flux(kn) && (kn->kn_status & KN_SCAN) == 0) {
2406 kn_enter_flux(kn);
2408 error = kn->kn_fop->f_event(kn, hint);
2410 kn_leave_flux(kn);
2412 KNOTE_ACTIVATE(kn, 1);
2415 if (kn->kn_fop->f_event(kn, hint))
2416 KNOTE_ACTIVATE(kn, 1);
2428 knlist_add(struct knlist *knl, struct knote *kn, int islocked)
2432 KQ_NOTOWNED(kn->kn_kq);
2433 KASSERT(kn_in_flux(kn), ("knote %p not in flux", kn));
2434 KASSERT((kn->kn_status & KN_DETACHED) != 0,
2435 ("knote %p was not detached", kn));
2438 SLIST_INSERT_HEAD(&knl->kl_list, kn, kn_selnext);
2441 KQ_LOCK(kn->kn_kq);
2442 kn->kn_knlist = knl;
2443 kn->kn_status &= ~KN_DETACHED;
2444 KQ_UNLOCK(kn->kn_kq);
2448 knlist_remove_kq(struct knlist *knl, struct knote *kn, int knlislocked,
2454 mtx_assert(&kn->kn_kq->kq_lock, kqislocked ? MA_OWNED : MA_NOTOWNED);
2455 KASSERT(kqislocked || kn_in_flux(kn), ("knote %p not in flux", kn));
2456 KASSERT((kn->kn_status & KN_DETACHED) == 0,
2457 ("knote %p was already detached", kn));
2460 SLIST_REMOVE(&knl->kl_list, kn, knote, kn_selnext);
2461 kn->kn_knlist = NULL;
2465 KQ_LOCK(kn->kn_kq);
2466 kn->kn_status |= KN_DETACHED;
2468 KQ_UNLOCK(kn->kn_kq);
2475 knlist_remove(struct knlist *knl, struct knote *kn, int islocked)
2478 knlist_remove_kq(knl, kn, islocked, 0);
2591 struct knote *kn, *kn2;
2603 SLIST_FOREACH_SAFE(kn, &knl->kl_list, kn_selnext, kn2) {
2604 kq = kn->kn_kq;
2606 if (kn_in_flux(kn)) {
2610 knlist_remove_kq(knl, kn, 1, 1);
2612 kn_enter_flux(kn);
2614 knote_drop_detached(kn, td);
2617 kn->kn_flags |= EV_EOF | EV_ONESHOT;
2625 kn = SLIST_FIRST(&knl->kl_list);
2626 kq = kn->kn_kq;
2628 KASSERT(kn_in_flux(kn), ("knote removed w/o list lock"));
2654 struct knote *kn;
2669 (kn = SLIST_FIRST(&kq->kq_knlist[fd])) != NULL) {
2670 if (kn_in_flux(kn)) {
2678 kn_enter_flux(kn);
2681 knote_drop(kn, td);
2689 knote_attach(struct knote *kn, struct kqueue *kq)
2693 KASSERT(kn_in_flux(kn), ("knote %p not marked influx", kn));
2698 if (kn->kn_fop->f_isfd) {
2699 if (kn->kn_id >= kq->kq_knlistsize)
2701 list = &kq->kq_knlist[kn->kn_id];
2705 list = &kq->kq_knhash[KN_HASH(kn->kn_id, kq->kq_knhashmask)];
2707 SLIST_INSERT_HEAD(list, kn, kn_link);
2712 knote_drop(struct knote *kn, struct thread *td)
2715 if ((kn->kn_status & KN_DETACHED) == 0)
2716 kn->kn_fop->f_detach(kn);
2717 knote_drop_detached(kn, td);
2721 knote_drop_detached(struct knote *kn, struct thread *td)
2726 kq = kn->kn_kq;
2728 KASSERT((kn->kn_status & KN_DETACHED) != 0,
2729 ("knote %p still attached", kn));
2733 KASSERT(kn->kn_influx == 1,
2734 ("knote_drop called on %p with influx %d", kn, kn->kn_influx));
2736 if (kn->kn_fop->f_isfd)
2737 list = &kq->kq_knlist[kn->kn_id];
2739 list = &kq->kq_knhash[KN_HASH(kn->kn_id, kq->kq_knhashmask)];
2742 SLIST_REMOVE(list, kn, knote, kn_link);
2743 if (kn->kn_status & KN_QUEUED)
2744 knote_dequeue(kn);
2747 if (kn->kn_fop->f_isfd) {
2748 fdrop(kn->kn_fp, td);
2749 kn->kn_fp = NULL;
2751 kqueue_fo_release(kn->kn_kevent.filter);
2752 kn->kn_fop = NULL;
2753 knote_free(kn);
2757 knote_enqueue(struct knote *kn)
2759 struct kqueue *kq = kn->kn_kq;
2761 KQ_OWNED(kn->kn_kq);
2762 KASSERT((kn->kn_status & KN_QUEUED) == 0, ("knote already queued"));
2764 TAILQ_INSERT_TAIL(&kq->kq_head, kn, kn_tqe);
2765 kn->kn_status |= KN_QUEUED;
2771 knote_dequeue(struct knote *kn)
2773 struct kqueue *kq = kn->kn_kq;
2775 KQ_OWNED(kn->kn_kq);
2776 KASSERT(kn->kn_status & KN_QUEUED, ("knote not queued"));
2778 TAILQ_REMOVE(&kq->kq_head, kn, kn_tqe);
2779 kn->kn_status &= ~KN_QUEUED;
2801 knote_free(struct knote *kn)
2804 uma_zfree(knote_zone, kn);