1/*
2 * Copyright (c) 2003-2017 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28/*-
29 * Copyright (c) 1999,2000,2001 Jonathan Lemon <jlemon@FreeBSD.org>
30 * All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 *
41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 *
53 * $FreeBSD: src/sys/sys/event.h,v 1.5.2.5 2001/12/14 19:21:22 jlemon Exp $
54 */
55
56#ifndef _SYS_EVENT_H_
57#define _SYS_EVENT_H_
58
59#include <machine/types.h>
60#include <sys/cdefs.h>
61#include <stdint.h>
62
63/*
64 * Filter types
65 */
66#define EVFILT_READ (-1)
67#define EVFILT_WRITE (-2)
68#define EVFILT_AIO (-3) /* attached to aio requests */
69#define EVFILT_VNODE (-4) /* attached to vnodes */
70#define EVFILT_PROC (-5) /* attached to struct proc */
71#define EVFILT_SIGNAL (-6) /* attached to struct proc */
72#define EVFILT_TIMER (-7) /* timers */
73#define EVFILT_MACHPORT (-8) /* Mach portsets */
74#define EVFILT_FS (-9) /* Filesystem events */
75#define EVFILT_USER (-10) /* User events */
76 /* (-11) unused */
77#define EVFILT_VM (-12) /* Virtual memory events */
78
79#ifdef PRIVATE
80#define EVFILT_SOCK (-13) /* Socket events */
81#define EVFILT_MEMORYSTATUS (-14) /* Memorystatus events */
82#endif /* PRIVATE */
83#define EVFILT_EXCEPT (-15) /* Exception events */
84#ifdef PRIVATE
85#define EVFILT_WORKLOOP (-17) /* Workloop events */
86#endif /* PRIVATE */
87
88#define EVFILT_SYSCOUNT 17
89#define EVFILT_THREADMARKER EVFILT_SYSCOUNT /* Internal use only */
90
91#pragma pack(4)
92
93struct kevent {
94 uintptr_t ident; /* identifier for this event */
95 int16_t filter; /* filter for event */
96 uint16_t flags; /* general flags */
97 uint32_t fflags; /* filter-specific flags */
98 intptr_t data; /* filter-specific data */
99 void *udata; /* opaque user data identifier */
100};
101
102#ifdef KERNEL_PRIVATE
103
104struct user64_kevent {
105 uint64_t ident; /* identifier for this event */
106 int16_t filter; /* filter for event */
107 uint16_t flags; /* general flags */
108 uint32_t fflags; /* filter-specific flags */
109 int64_t data; /* filter-specific data */
110 user_addr_t udata; /* opaque user data identifier */
111};
112
113struct user32_kevent {
114 uint32_t ident; /* identifier for this event */
115 int16_t filter; /* filter for event */
116 uint16_t flags; /* general flags */
117 uint32_t fflags; /* filter-specific flags */
118 int32_t data; /* filter-specific data */
119 user32_addr_t udata; /* opaque user data identifier */
120};
121
122struct kevent_internal_s {
123 uint64_t ident; /* identifier for this event */
124 int16_t filter; /* filter for event */
125 uint16_t flags; /* general flags */
126 int32_t qos; /* quality of service */
127 uint32_t fflags; /* filter-specific flags */
128// uint32_t xflags; /* extra filter-specific flags */
129 int64_t data; /* filter-specific data */
130 uint64_t udata; /* opaque user data identifier */
131 uint64_t ext[4]; /* filter-specific extensions */
132};
133
134#endif /* KERNEL_PRIVATE */
135
136#pragma pack()
137
138struct kevent64_s {
139 uint64_t ident; /* identifier for this event */
140 int16_t filter; /* filter for event */
141 uint16_t flags; /* general flags */
142 uint32_t fflags; /* filter-specific flags */
143 int64_t data; /* filter-specific data */
144 uint64_t udata; /* opaque user data identifier */
145 uint64_t ext[2]; /* filter-specific extensions */
146};
147
148#ifdef PRIVATE
149struct kevent_qos_s {
150 uint64_t ident; /* identifier for this event */
151 int16_t filter; /* filter for event */
152 uint16_t flags; /* general flags */
153 int32_t qos; /* quality of service */
154 uint64_t udata; /* opaque user data identifier */
155 uint32_t fflags; /* filter-specific flags */
156 uint32_t xflags; /* extra filter-specific flags */
157 int64_t data; /* filter-specific data */
158 uint64_t ext[4]; /* filter-specific extensions */
159};
160
161/*
162 * Type definition for names/ids of dynamically allocated kqueues.
163 */
164typedef uint64_t kqueue_id_t;
165
166#endif /* PRIVATE */
167
168#define EV_SET(kevp, a, b, c, d, e, f) do { \
169 struct kevent *__kevp__ = (kevp); \
170 __kevp__->ident = (a); \
171 __kevp__->filter = (b); \
172 __kevp__->flags = (c); \
173 __kevp__->fflags = (d); \
174 __kevp__->data = (e); \
175 __kevp__->udata = (f); \
176} while(0)
177
178#define EV_SET64(kevp, a, b, c, d, e, f, g, h) do { \
179 struct kevent64_s *__kevp__ = (kevp); \
180 __kevp__->ident = (a); \
181 __kevp__->filter = (b); \
182 __kevp__->flags = (c); \
183 __kevp__->fflags = (d); \
184 __kevp__->data = (e); \
185 __kevp__->udata = (f); \
186 __kevp__->ext[0] = (g); \
187 __kevp__->ext[1] = (h); \
188} while(0)
189
190
191/* kevent system call flags */
192#define KEVENT_FLAG_NONE 0x000000 /* no flag value */
193#define KEVENT_FLAG_IMMEDIATE 0x000001 /* immediate timeout */
194#define KEVENT_FLAG_ERROR_EVENTS 0x000002 /* output events only include change errors */
195
196#ifdef PRIVATE
197
198/*
199 * Rather than provide an EV_SET_QOS macro for kevent_qos_t structure
200 * initialization, we encourage use of named field initialization support
201 * instead.
202 */
203
204#define KEVENT_FLAG_STACK_EVENTS 0x000004 /* output events treated as stack (grows down) */
205#define KEVENT_FLAG_STACK_DATA 0x000008 /* output data allocated as stack (grows down) */
206// 0x000010
207#define KEVENT_FLAG_WORKQ 0x000020 /* interact with the default workq kq */
208// KEVENT_FLAG_LEGACY32 0x000040
209// KEVENT_FLAG_LEGACY64 0x000080
210// 0x000100
211#define KEVENT_FLAG_WORKQ_MANAGER 0x000200 /* obsolete */
212#define KEVENT_FLAG_WORKLOOP 0x000400 /* interact with the specified workloop kq */
213#define KEVENT_FLAG_PARKING 0x000800 /* workq thread is parking */
214// KEVENT_FLAG_KERNEL 0x001000
215// KEVENT_FLAG_DYNAMIC_KQUEUE 0x002000
216// 0x004000
217#define KEVENT_FLAG_WORKLOOP_SERVICER_ATTACH 0x008000 /* obsolete */
218#define KEVENT_FLAG_WORKLOOP_SERVICER_DETACH 0x010000 /* obsolete */
219#define KEVENT_FLAG_DYNAMIC_KQ_MUST_EXIST 0x020000 /* kq lookup by id must exist */
220#define KEVENT_FLAG_DYNAMIC_KQ_MUST_NOT_EXIST 0x040000 /* kq lookup by id must not exist */
221#define KEVENT_FLAG_WORKLOOP_NO_WQ_THREAD 0x080000 /* obsolete */
222
223#ifdef XNU_KERNEL_PRIVATE
224
225#define KEVENT_FLAG_LEGACY32 0x0040 /* event data in legacy 32-bit format */
226#define KEVENT_FLAG_LEGACY64 0x0080 /* event data in legacy 64-bit format */
227#define KEVENT_FLAG_KERNEL 0x1000 /* caller is in-kernel */
228#define KEVENT_FLAG_DYNAMIC_KQUEUE 0x2000 /* kqueue is dynamically allocated */
229
230#define KEVENT_FLAG_USER (KEVENT_FLAG_IMMEDIATE | KEVENT_FLAG_ERROR_EVENTS | \
231 KEVENT_FLAG_STACK_EVENTS | KEVENT_FLAG_STACK_DATA | \
232 KEVENT_FLAG_WORKQ | KEVENT_FLAG_WORKLOOP | \
233 KEVENT_FLAG_DYNAMIC_KQ_MUST_EXIST | KEVENT_FLAG_DYNAMIC_KQ_MUST_NOT_EXIST)
234
235/*
236 * Since some filter ops are not part of the standard sysfilt_ops, we use
237 * kn_filtid starting from EVFILT_SYSCOUNT to identify these cases. This is to
238 * let kn_fops() get the correct fops for all cases.
239*/
240#define EVFILTID_KQREAD (EVFILT_SYSCOUNT)
241#define EVFILTID_PIPE_R (EVFILT_SYSCOUNT + 1)
242#define EVFILTID_PIPE_W (EVFILT_SYSCOUNT + 2)
243#define EVFILTID_PTSD (EVFILT_SYSCOUNT + 3)
244#define EVFILTID_SOREAD (EVFILT_SYSCOUNT + 4)
245#define EVFILTID_SOWRITE (EVFILT_SYSCOUNT + 5)
246#define EVFILTID_SCK (EVFILT_SYSCOUNT + 6)
247#define EVFILTID_SOEXCEPT (EVFILT_SYSCOUNT + 7)
248#define EVFILTID_SPEC (EVFILT_SYSCOUNT + 8)
249#define EVFILTID_BPFREAD (EVFILT_SYSCOUNT + 9)
250#define EVFILTID_NECP_FD (EVFILT_SYSCOUNT + 10)
251#define EVFILTID_FSEVENT (EVFILT_SYSCOUNT + 13)
252#define EVFILTID_VN (EVFILT_SYSCOUNT + 14)
253#define EVFILTID_TTY (EVFILT_SYSCOUNT + 16)
254#define EVFILTID_PTMX (EVFILT_SYSCOUNT + 17)
255
256#define EVFILTID_MAX (EVFILT_SYSCOUNT + 18)
257
258#endif /* defined(XNU_KERNEL_PRIVATE) */
259
260#define EV_SET_QOS 0
261
262#endif /* PRIVATE */
263
264/* actions */
265#define EV_ADD 0x0001 /* add event to kq (implies enable) */
266#define EV_DELETE 0x0002 /* delete event from kq */
267#define EV_ENABLE 0x0004 /* enable event */
268#define EV_DISABLE 0x0008 /* disable event (not reported) */
269
270/* flags */
271#define EV_ONESHOT 0x0010 /* only report one occurrence */
272#define EV_CLEAR 0x0020 /* clear event state after reporting */
273#define EV_RECEIPT 0x0040 /* force immediate event output */
274 /* ... with or without EV_ERROR */
275 /* ... use KEVENT_FLAG_ERROR_EVENTS */
276 /* on syscalls supporting flags */
277
278#define EV_DISPATCH 0x0080 /* disable event after reporting */
279#define EV_UDATA_SPECIFIC 0x0100 /* unique kevent per udata value */
280
281#define EV_DISPATCH2 (EV_DISPATCH | EV_UDATA_SPECIFIC)
282 /* ... in combination with EV_DELETE */
283 /* will defer delete until udata-specific */
284 /* event enabled. EINPROGRESS will be */
285 /* returned to indicate the deferral */
286
287#define EV_VANISHED 0x0200 /* report that source has vanished */
288 /* ... only valid with EV_DISPATCH2 */
289
290#define EV_SYSFLAGS 0xF000 /* reserved by system */
291#define EV_FLAG0 0x1000 /* filter-specific flag */
292#define EV_FLAG1 0x2000 /* filter-specific flag */
293
294/* returned values */
295#define EV_EOF 0x8000 /* EOF detected */
296#define EV_ERROR 0x4000 /* error, data contains errno */
297
298/*
299 * Filter specific flags for EVFILT_READ
300 *
301 * The default behavior for EVFILT_READ is to make the "read" determination
302 * relative to the current file descriptor read pointer.
303 *
304 * The EV_POLL flag indicates the determination should be made via poll(2)
305 * semantics. These semantics dictate always returning true for regular files,
306 * regardless of the amount of unread data in the file.
307 *
308 * On input, EV_OOBAND specifies that filter should actively return in the
309 * presence of OOB on the descriptor. It implies that filter will return
310 * if there is OOB data available to read OR when any other condition
311 * for the read are met (for example number of bytes regular data becomes >=
312 * low-watermark).
313 * If EV_OOBAND is not set on input, it implies that the filter should not actively
314 * return for out of band data on the descriptor. The filter will then only return
315 * when some other condition for read is met (ex: when number of regular data bytes
316 * >=low-watermark OR when socket can't receive more data (SS_CANTRCVMORE)).
317 *
318 * On output, EV_OOBAND indicates the presence of OOB data on the descriptor.
319 * If it was not specified as an input parameter, then the data count is the
320 * number of bytes before the current OOB marker, else data count is the number
321 * of bytes beyond OOB marker.
322 */
323#define EV_POLL EV_FLAG0
324#define EV_OOBAND EV_FLAG1
325
326/*
327 * data/hint fflags for EVFILT_USER, shared with userspace
328 */
329
330/*
331 * On input, NOTE_TRIGGER causes the event to be triggered for output.
332 */
333#define NOTE_TRIGGER 0x01000000
334
335/*
336 * On input, the top two bits of fflags specifies how the lower twenty four
337 * bits should be applied to the stored value of fflags.
338 *
339 * On output, the top two bits will always be set to NOTE_FFNOP and the
340 * remaining twenty four bits will contain the stored fflags value.
341 */
342#define NOTE_FFNOP 0x00000000 /* ignore input fflags */
343#define NOTE_FFAND 0x40000000 /* and fflags */
344#define NOTE_FFOR 0x80000000 /* or fflags */
345#define NOTE_FFCOPY 0xc0000000 /* copy fflags */
346#define NOTE_FFCTRLMASK 0xc0000000 /* mask for operations */
347#define NOTE_FFLAGSMASK 0x00ffffff
348
349#ifdef PRIVATE
350/*
351 * data/hint fflags for EVFILT_WORKLOOP, shared with userspace
352 *
353 * The ident for thread requests should be the dynamic ID of the workloop
354 * The ident for each sync waiter must be unique to that waiter [for this workloop]
355 *
356 *
357 * Commands:
358 *
359 * @const NOTE_WL_THREAD_REQUEST [in/out]
360 * The kevent represents asynchronous userspace work and its associated QoS.
361 * There can only be a single knote with this flag set per workloop.
362 *
363 * @const NOTE_WL_SYNC_WAIT [in/out]
364 * This bit is set when the caller is waiting to become the owner of a workloop.
365 * If the NOTE_WL_SYNC_WAKE bit is already set then the caller is not blocked,
366 * else it blocks until it is set.
367 *
368 * The QoS field of the knote is used to push on other owners or servicers.
369 *
370 * @const NOTE_WL_SYNC_WAKE [in/out]
371 * Marks the waiter knote as being eligible to become an owner
372 * This bit can only be set once, trying it again will fail with EALREADY.
373 *
374 *
375 * Flags/Modifiers:
376 *
377 * @const NOTE_WL_UPDATE_QOS [in] (only NOTE_WL_THREAD_REQUEST)
378 * For successful updates (EV_ADD only), learn the new userspace async QoS from
379 * the kevent qos field.
380 *
381 * @const NOTE_WL_END_OWNERSHIP [in]
382 * If the update is successful (including deletions) or returns ESTALE, and
383 * the caller thread or the "suspended" thread is currently owning the workloop,
384 * then ownership is forgotten.
385 *
386 * @const NOTE_WL_DISCOVER_OWNER [in]
387 * If the update is successful (including deletions), learn the owner identity
388 * from the loaded value during debounce. This requires an address to have been
389 * filled in the EV_EXTIDX_WL_ADDR ext field, but doesn't require a mask to have
390 * been set in the EV_EXTIDX_WL_MASK.
391 *
392 * @const NOTE_WL_IGNORE_ESTALE [in]
393 * If the operation would fail with ESTALE, mask the error and pretend the
394 * update was successful. However the operation itself didn't happen, meaning
395 * that:
396 * - attaching a new knote will not happen
397 * - dropping an existing knote will not happen
398 * - NOTE_WL_UPDATE_QOS or NOTE_WL_DISCOVER_OWNER will have no effect
399 *
400 * This modifier doesn't affect NOTE_WL_END_OWNERSHIP.
401 */
402#define NOTE_WL_THREAD_REQUEST 0x00000001
403#define NOTE_WL_SYNC_WAIT 0x00000004
404#define NOTE_WL_SYNC_WAKE 0x00000008
405#define NOTE_WL_COMMANDS_MASK 0x0000000f /* Mask of all the [in] commands above */
406
407#define NOTE_WL_UPDATE_QOS 0x00000010
408#define NOTE_WL_END_OWNERSHIP 0x00000020
409#define NOTE_WL_UPDATE_OWNER 0 /* ... compatibility define ... */
410#define NOTE_WL_DISCOVER_OWNER 0x00000080
411#define NOTE_WL_IGNORE_ESTALE 0x00000100
412#define NOTE_WL_UPDATES_MASK 0x000001f0 /* Mask of all the [in] updates above */
413
414/*
415 * EVFILT_WORKLOOP ext[] array indexes/meanings.
416 */
417#define EV_EXTIDX_WL_LANE 0 /* lane identifier [in: sync waiter]
418 [out: thread request] */
419#define EV_EXTIDX_WL_ADDR 1 /* debounce address [in: NULL==no debounce] */
420#define EV_EXTIDX_WL_MASK 2 /* debounce mask [in] */
421#define EV_EXTIDX_WL_VALUE 3 /* debounce value [in: not current->ESTALE]
422 [out: new/debounce value] */
423#endif /* PRIVATE */
424
425/*
426 * data/hint fflags for EVFILT_{READ|WRITE}, shared with userspace
427 *
428 * The default behavior for EVFILT_READ is to make the determination
429 * realtive to the current file descriptor read pointer.
430 */
431#define NOTE_LOWAT 0x00000001 /* low water mark */
432
433/* data/hint flags for EVFILT_EXCEPT, shared with userspace */
434#define NOTE_OOB 0x00000002 /* OOB data */
435
436/*
437 * data/hint fflags for EVFILT_VNODE, shared with userspace
438 */
439#define NOTE_DELETE 0x00000001 /* vnode was removed */
440#define NOTE_WRITE 0x00000002 /* data contents changed */
441#define NOTE_EXTEND 0x00000004 /* size increased */
442#define NOTE_ATTRIB 0x00000008 /* attributes changed */
443#define NOTE_LINK 0x00000010 /* link count changed */
444#define NOTE_RENAME 0x00000020 /* vnode was renamed */
445#define NOTE_REVOKE 0x00000040 /* vnode access was revoked */
446#define NOTE_NONE 0x00000080 /* No specific vnode event: to test for EVFILT_READ activation*/
447#define NOTE_FUNLOCK 0x00000100 /* vnode was unlocked by flock(2) */
448
449/*
450 * data/hint fflags for EVFILT_PROC, shared with userspace
451 *
452 * Please note that EVFILT_PROC and EVFILT_SIGNAL share the same knote list
453 * that hangs off the proc structure. They also both play games with the hint
454 * passed to KNOTE(). If NOTE_SIGNAL is passed as a hint, then the lower bits
455 * of the hint contain the signal. IF NOTE_FORK is passed, then the lower bits
456 * contain the PID of the child (but the pid does not get passed through in
457 * the actual kevent).
458 */
459enum {
460 eNoteReapDeprecated __deprecated_enum_msg("This kqueue(2) EVFILT_PROC flag is deprecated") = 0x10000000
461};
462
463#define NOTE_EXIT 0x80000000 /* process exited */
464#define NOTE_FORK 0x40000000 /* process forked */
465#define NOTE_EXEC 0x20000000 /* process exec'd */
466#define NOTE_REAP ((unsigned int)eNoteReapDeprecated /* 0x10000000 */) /* process reaped */
467#define NOTE_SIGNAL 0x08000000 /* shared with EVFILT_SIGNAL */
468#define NOTE_EXITSTATUS 0x04000000 /* exit status to be returned, valid for child process only */
469#define NOTE_EXIT_DETAIL 0x02000000 /* provide details on reasons for exit */
470
471#define NOTE_PDATAMASK 0x000fffff /* mask for signal & exit status */
472#define NOTE_PCTRLMASK (~NOTE_PDATAMASK)
473
474/*
475 * If NOTE_EXITSTATUS is present, provide additional info about exiting process.
476 */
477enum {
478 eNoteExitReparentedDeprecated __deprecated_enum_msg("This kqueue(2) EVFILT_PROC flag is no longer sent") = 0x00080000
479};
480#define NOTE_EXIT_REPARENTED ((unsigned int)eNoteExitReparentedDeprecated) /* exited while reparented */
481
482/*
483 * If NOTE_EXIT_DETAIL is present, these bits indicate specific reasons for exiting.
484 */
485#define NOTE_EXIT_DETAIL_MASK 0x00070000
486#define NOTE_EXIT_DECRYPTFAIL 0x00010000
487#define NOTE_EXIT_MEMORY 0x00020000
488#define NOTE_EXIT_CSERROR 0x00040000
489
490#ifdef PRIVATE
491
492/*
493 * If NOTE_EXIT_MEMORY is present, these bits indicate specific jetsam condition.
494 */
495#define NOTE_EXIT_MEMORY_DETAIL_MASK 0xfe000000
496#define NOTE_EXIT_MEMORY_VMPAGESHORTAGE 0x80000000 /* jetsam condition: lowest jetsam priority proc killed due to vm page shortage */
497#define NOTE_EXIT_MEMORY_VMTHRASHING 0x40000000 /* jetsam condition: lowest jetsam priority proc killed due to vm thrashing */
498#define NOTE_EXIT_MEMORY_HIWAT 0x20000000 /* jetsam condition: process reached its high water mark */
499#define NOTE_EXIT_MEMORY_PID 0x10000000 /* jetsam condition: special pid kill requested */
500#define NOTE_EXIT_MEMORY_IDLE 0x08000000 /* jetsam condition: idle process cleaned up */
501#define NOTE_EXIT_MEMORY_VNODE 0X04000000 /* jetsam condition: virtual node kill */
502#define NOTE_EXIT_MEMORY_FCTHRASHING 0x02000000 /* jetsam condition: lowest jetsam priority proc killed due to filecache thrashing */
503
504#endif
505
506/*
507 * data/hint fflags for EVFILT_VM, shared with userspace.
508 */
509#define NOTE_VM_PRESSURE 0x80000000 /* will react on memory pressure */
510#define NOTE_VM_PRESSURE_TERMINATE 0x40000000 /* will quit on memory pressure, possibly after cleaning up dirty state */
511#define NOTE_VM_PRESSURE_SUDDEN_TERMINATE 0x20000000 /* will quit immediately on memory pressure */
512#define NOTE_VM_ERROR 0x10000000 /* there was an error */
513
514#ifdef PRIVATE
515
516/*
517 * data/hint fflags for EVFILT_MEMORYSTATUS, shared with userspace.
518 */
519#define NOTE_MEMORYSTATUS_PRESSURE_NORMAL 0x00000001 /* system memory pressure has returned to normal */
520#define NOTE_MEMORYSTATUS_PRESSURE_WARN 0x00000002 /* system memory pressure has changed to the warning state */
521#define NOTE_MEMORYSTATUS_PRESSURE_CRITICAL 0x00000004 /* system memory pressure has changed to the critical state */
522#define NOTE_MEMORYSTATUS_LOW_SWAP 0x00000008 /* system is in a low-swap state */
523#define NOTE_MEMORYSTATUS_PROC_LIMIT_WARN 0x00000010 /* process memory limit has hit a warning state */
524#define NOTE_MEMORYSTATUS_PROC_LIMIT_CRITICAL 0x00000020 /* process memory limit has hit a critical state - soft limit */
525#define NOTE_MEMORYSTATUS_MSL_STATUS 0xf0000000 /* bits used to request change to process MSL status */
526
527#ifdef KERNEL_PRIVATE
528/*
529 * data/hint fflags for EVFILT_MEMORYSTATUS, but not shared with userspace.
530 */
531#define NOTE_MEMORYSTATUS_PROC_LIMIT_WARN_ACTIVE 0x00000040 /* Used to restrict sending a warn event only once, per active limit, soft limits only */
532#define NOTE_MEMORYSTATUS_PROC_LIMIT_WARN_INACTIVE 0x00000080 /* Used to restrict sending a warn event only once, per inactive limit, soft limit only */
533#define NOTE_MEMORYSTATUS_PROC_LIMIT_CRITICAL_ACTIVE 0x00000100 /* Used to restrict sending a critical event only once per active limit, soft limit only */
534#define NOTE_MEMORYSTATUS_PROC_LIMIT_CRITICAL_INACTIVE 0x00000200 /* Used to restrict sending a critical event only once per inactive limit, soft limit only */
535
536/*
537 * Use this mask to protect the kernel private flags.
538 */
539#define EVFILT_MEMORYSTATUS_ALL_MASK \
540 (NOTE_MEMORYSTATUS_PRESSURE_NORMAL | NOTE_MEMORYSTATUS_PRESSURE_WARN | NOTE_MEMORYSTATUS_PRESSURE_CRITICAL | NOTE_MEMORYSTATUS_LOW_SWAP | \
541 NOTE_MEMORYSTATUS_PROC_LIMIT_WARN | NOTE_MEMORYSTATUS_PROC_LIMIT_CRITICAL | NOTE_MEMORYSTATUS_MSL_STATUS)
542
543#endif /* KERNEL_PRIVATE */
544
545typedef enum vm_pressure_level {
546 kVMPressureNormal = 0,
547 kVMPressureWarning = 1,
548 kVMPressureUrgent = 2,
549 kVMPressureCritical = 3,
550} vm_pressure_level_t;
551
552#endif /* PRIVATE */
553
554/*
555 * data/hint fflags for EVFILT_TIMER, shared with userspace.
556 * The default is a (repeating) interval timer with the data
557 * specifying the timeout interval in milliseconds.
558 *
559 * All timeouts are implicitly EV_CLEAR events.
560 */
561#define NOTE_SECONDS 0x00000001 /* data is seconds */
562#define NOTE_USECONDS 0x00000002 /* data is microseconds */
563#define NOTE_NSECONDS 0x00000004 /* data is nanoseconds */
564#define NOTE_ABSOLUTE 0x00000008 /* absolute timeout */
565 /* ... implicit EV_ONESHOT, timeout uses the gettimeofday epoch */
566#define NOTE_LEEWAY 0x00000010 /* ext[1] holds leeway for power aware timers */
567#define NOTE_CRITICAL 0x00000020 /* system does minimal timer coalescing */
568#define NOTE_BACKGROUND 0x00000040 /* system does maximum timer coalescing */
569#define NOTE_MACH_CONTINUOUS_TIME 0x00000080
570 /*
571 * NOTE_MACH_CONTINUOUS_TIME:
572 * with NOTE_ABSOLUTE: causes the timer to continue to tick across sleep,
573 * still uses gettimeofday epoch
574 * with NOTE_MACHTIME and NOTE_ABSOLUTE: uses mach continuous time epoch
575 * without NOTE_ABSOLUTE (interval timer mode): continues to tick across sleep
576 */
577#define NOTE_MACHTIME 0x00000100 /* data is mach absolute time units */
578 /* timeout uses the mach absolute time epoch */
579
580#ifdef PRIVATE
581/*
582 * data/hint fflags for EVFILT_SOCK, shared with userspace.
583 *
584 */
585#define NOTE_CONNRESET 0x00000001 /* Received RST */
586#define NOTE_READCLOSED 0x00000002 /* Read side is shutdown */
587#define NOTE_WRITECLOSED 0x00000004 /* Write side is shutdown */
588#define NOTE_TIMEOUT 0x00000008 /* timeout: rexmt, keep-alive or persist */
589#define NOTE_NOSRCADDR 0x00000010 /* source address not available */
590#define NOTE_IFDENIED 0x00000020 /* interface denied connection */
591#define NOTE_SUSPEND 0x00000040 /* output queue suspended */
592#define NOTE_RESUME 0x00000080 /* output queue resumed */
593#define NOTE_KEEPALIVE 0x00000100 /* TCP Keepalive received */
594#define NOTE_ADAPTIVE_WTIMO 0x00000200 /* TCP adaptive write timeout */
595#define NOTE_ADAPTIVE_RTIMO 0x00000400 /* TCP adaptive read timeout */
596#define NOTE_CONNECTED 0x00000800 /* socket is connected */
597#define NOTE_DISCONNECTED 0x00001000 /* socket is disconnected */
598#define NOTE_CONNINFO_UPDATED 0x00002000 /* connection info was updated */
599#define NOTE_NOTIFY_ACK 0x00004000 /* notify acknowledgement */
600
601#define EVFILT_SOCK_LEVEL_TRIGGER_MASK \
602 (NOTE_READCLOSED | NOTE_WRITECLOSED | NOTE_SUSPEND | NOTE_RESUME | \
603 NOTE_CONNECTED | NOTE_DISCONNECTED)
604
605#define EVFILT_SOCK_ALL_MASK \
606 (NOTE_CONNRESET | NOTE_READCLOSED | NOTE_WRITECLOSED | NOTE_TIMEOUT | \
607 NOTE_NOSRCADDR | NOTE_IFDENIED | NOTE_SUSPEND | NOTE_RESUME | \
608 NOTE_KEEPALIVE | NOTE_ADAPTIVE_WTIMO | NOTE_ADAPTIVE_RTIMO | \
609 NOTE_CONNECTED | NOTE_DISCONNECTED | NOTE_CONNINFO_UPDATED | \
610 NOTE_NOTIFY_ACK)
611
612#endif /* PRIVATE */
613
614/*
615 * data/hint fflags for EVFILT_MACHPORT, shared with userspace.
616 *
617 * Only portsets are supported at this time.
618 *
619 * The fflags field can optionally contain the MACH_RCV_MSG, MACH_RCV_LARGE,
620 * and related trailer receive options as defined in <mach/message.h>.
621 * The presence of these flags directs the kevent64() call to attempt to receive
622 * the message during kevent delivery, rather than just indicate that a message exists.
623 * On setup, The ext[0] field contains the receive buffer pointer and ext[1] contains
624 * the receive buffer length. Upon event delivery, the actual received message size
625 * is returned in ext[1]. As with mach_msg(), the buffer must be large enough to
626 * receive the message and the requested (or default) message trailers. In addition,
627 * the fflags field contains the return code normally returned by mach_msg().
628 *
629 * If MACH_RCV_MSG is specified, and the ext[1] field specifies a zero length, the
630 * system call argument specifying an ouput area (kevent_qos) will be consulted. If
631 * the system call specified an output data area, the user-space address
632 * of the received message is carved from that provided output data area (if enough
633 * space remains there). The address and length of each received message is
634 * returned in the ext[0] and ext[1] fields (respectively) of the corresponding kevent.
635 *
636 * IF_MACH_RCV_VOUCHER_CONTENT is specified, the contents of the message voucher is
637 * extracted (as specified in the xflags field) and stored in ext[2] up to ext[3]
638 * length. If the input length is zero, and the system call provided a data area,
639 * the space for the voucher content is carved from the provided space and its
640 * address and length is returned in ext[2] and ext[3] respectively.
641 *
642 * If no message receipt options were provided in the fflags field on setup, no
643 * message is received by this call. Instead, on output, the data field simply
644 * contains the name of the actual port detected with a message waiting.
645 */
646
647/*
648 * DEPRECATED!!!!!!!!!
649 * NOTE_TRACK, NOTE_TRACKERR, and NOTE_CHILD are no longer supported as of 10.5
650 */
651/* additional flags for EVFILT_PROC */
652#define NOTE_TRACK 0x00000001 /* follow across forks */
653#define NOTE_TRACKERR 0x00000002 /* could not track child */
654#define NOTE_CHILD 0x00000004 /* am a child process */
655
656
657#ifdef PRIVATE
658#endif /* PRIVATE */
659
660#ifndef KERNEL
661/* Temporay solution for BootX to use inode.h till kqueue moves to vfs layer */
662#include <sys/queue.h>
663struct knote;
664SLIST_HEAD(klist, knote);
665#endif
666
667#ifdef KERNEL
668
669#ifdef XNU_KERNEL_PRIVATE
670#include <sys/queue.h>
671#include <kern/kern_types.h>
672#include <sys/fcntl.h> /* FREAD, FWRITE */
673#include <kern/debug.h> /* panic */
674#include <pthread/priority_private.h>
675
676#ifdef MALLOC_DECLARE
677MALLOC_DECLARE(M_KQUEUE);
678#endif
679
680TAILQ_HEAD(kqtailq, knote); /* a list of "queued" events */
681
682/* index into various kq queues */
683typedef uint8_t kq_index_t;
684typedef uint16_t kn_status_t;
685
686#define KN_ACTIVE 0x0001 /* event has been triggered */
687#define KN_QUEUED 0x0002 /* event is on queue */
688#define KN_DISABLED 0x0004 /* event is disabled */
689#define KN_DROPPING 0x0008 /* knote is being dropped */
690#define KN_LOCKED 0x0010 /* knote is locked (kq_knlocks) */
691#define KN_ATTACHING 0x0020 /* event is pending attach */
692#define KN_STAYACTIVE 0x0040 /* force event to stay active */
693#define KN_DEFERDELETE 0x0080 /* defer delete until re-enabled */
694#define KN_ATTACHED 0x0100 /* currently attached to source */
695#define KN_DISPATCH 0x0200 /* disables as part of deliver */
696#define KN_UDATA_SPECIFIC 0x0400 /* udata is part of matching */
697#define KN_SUPPRESSED 0x0800 /* event is suppressed during delivery */
698#define KN_MERGE_QOS 0x1000 /* f_event() / f_* ran concurrently and
699 overrides must merge */
700#define KN_REQVANISH 0x2000 /* requested EV_VANISH */
701#define KN_VANISHED 0x4000 /* has vanished */
702// 0x8000
703
704/* combination defines deferred-delete mode enabled */
705#define KN_DISPATCH2 (KN_DISPATCH | KN_UDATA_SPECIFIC)
706
707#define KNOTE_KQ_BITSIZE 42
708_Static_assert(KNOTE_KQ_BITSIZE >= VM_KERNEL_POINTER_SIGNIFICANT_BITS,
709 "Make sure sign extending kn_kq_packed is legit");
710
711struct kqueue;
712struct knote {
713 TAILQ_ENTRY(knote) kn_tqe; /* linkage for tail queue */
714 SLIST_ENTRY(knote) kn_link; /* linkage for search list */
715 SLIST_ENTRY(knote) kn_selnext; /* klist element chain */
716 uintptr_t kn_filtid:8, /* filter id to index filter ops */
717 kn_req_index:4, /* requested qos index */
718 kn_qos_index:4, /* in-use qos index */
719 kn_qos_override:4, /* qos override index */
720 kn_vnode_kqok:1,
721 kn_vnode_use_ofst:1;
722#if __LP64__
723 intptr_t kn_kq_packed : KNOTE_KQ_BITSIZE;
724#else
725 intptr_t kn_kq_packed;
726#endif
727 union {
728 void *kn_hook;
729 uint64_t kn_hook_data;
730 };
731 int64_t kn_sdata; /* saved data field */
732 union {
733 struct fileproc *p_fp; /* file data pointer */
734 struct proc *p_proc; /* proc pointer */
735 struct ipc_mqueue *p_mqueue; /* pset pointer */
736 } kn_ptr;
737 struct kevent_internal_s kn_kevent;
738 int kn_sfflags; /* saved filter flags */
739 int kn_hookid;
740 uint16_t kn_inuse; /* inuse count */
741 kn_status_t kn_status; /* status bits */
742
743#define kn_id kn_kevent.ident
744#define kn_filter kn_kevent.filter
745#define kn_flags kn_kevent.flags
746#define kn_qos kn_kevent.qos
747#define kn_udata kn_kevent.udata
748#define kn_fflags kn_kevent.fflags
749#define kn_xflags kn_kevent.xflags
750#define kn_data kn_kevent.data
751#define kn_ext kn_kevent.ext
752#define kn_fp kn_ptr.p_fp
753};
754
755static inline struct kqueue *
756knote_get_kq(struct knote *kn)
757{
758 return (struct kqueue *)kn->kn_kq_packed;
759}
760
761static inline int knote_get_seltype(struct knote *kn)
762{
763 switch (kn->kn_filter) {
764 case EVFILT_READ:
765 return FREAD;
766 case EVFILT_WRITE:
767 return FWRITE;
768 default:
769 panic("%s(%p): invalid filter %d\n",
770 __func__, kn, kn->kn_filter);
771 return 0;
772 }
773}
774
775static inline void knote_set_error(struct knote *kn, int error)
776{
777 kn->kn_flags |= EV_ERROR;
778 kn->kn_data = error;
779}
780
781struct filt_process_s {
782 int fp_fd;
783 unsigned int fp_flags;
784 user_addr_t fp_data_out;
785 user_size_t fp_data_size;
786 user_size_t fp_data_resid;
787};
788typedef struct filt_process_s *filt_process_data_t;
789
790/*
791 * Filter operators
792 *
793 * These routines, provided by each filter, are called to attach, detach, deliver events,
794 * change/update filter registration and process/deliver events:
795 *
796 * - the f_attach, f_touch, f_process, f_peek and f_detach callbacks are always
797 * serialized with respect to each other for the same knote.
798 *
799 * - the f_event routine is called with a use-count taken on the knote to
800 * prolongate its lifetime and protect against drop, but is not otherwise
801 * serialized with other routine calls.
802 *
803 * - the f_detach routine is always called last, and is serialized with all
804 * other callbacks, including f_event calls.
805 *
806 *
807 * Here are more details:
808 *
809 * f_isfd -
810 * identifies if the "ident" field in the kevent structure is a file-descriptor.
811 *
812 * If so, the knote is associated with the file descriptor prior to attach and
813 * auto-removed when the file descriptor is closed (this latter behavior may change
814 * for EV_DISPATCH2 kevent types to allow delivery of events identifying unintended
815 * closes).
816 *
817 * Otherwise the knote is hashed by the ident and has no auto-close behavior.
818 *
819 * f_adjusts_qos -
820 * identifies if the filter can adjust its QoS during its lifetime.
821 *
822 * Filters using this facility should request the new overrides they want
823 * using the appropriate FILTER_{RESET,ADJUST}_EVENT_QOS extended codes.
824 *
825 * Currently, EVFILT_MACHPORT is the only filter using this facility.
826 *
827 * f_extended_codes -
828 * identifies if the filter returns extended codes from its routines
829 * (see FILTER_ACTIVE, ...) or 0 / 1 values.
830 *
831 * f_attach -
832 * called to attach the knote to the underlying object that will be delivering events
833 * through it when EV_ADD is supplied and no existing matching event is found
834 *
835 * provided a knote that is pre-attached to the fd or hashed (see above) but is
836 * specially marked to avoid concurrent access until the attach is complete. The
837 * kevent structure embedded in this knote has been filled in with a sanitized
838 * version of the user-supplied kevent data. However, the user-supplied filter-specific
839 * flags (fflags) and data fields have been moved into the knote's kn_sfflags and kn_sdata
840 * fields respectively. These are usually interpretted as a set of "interest" flags and
841 * data by each filter - to be matched against delivered events.
842 *
843 * The attach operator indicated errors by setting the EV_ERROR flog in the flags field
844 * embedded in the knote's kevent structure - with the specific error indicated in the
845 * corresponding data field.
846 *
847 * The return value indicates if the knote should already be considered "activated" at
848 * the time of attach (one or more of the interest events has already occured).
849 *
850 * f_detach -
851 * called to disassociate the knote from the underlying object delivering events
852 * the filter should not attempt to deliver events through this knote after this
853 * operation returns control to the kq system.
854 *
855 * f_event -
856 * if the knote() function (or KNOTE() macro) is called against a list of knotes,
857 * this operator will be called on each knote in the list.
858 *
859 * The "hint" parameter is completely filter-specific, but usually indicates an
860 * event or set of events that have occured against the source object associated
861 * with the list.
862 *
863 * The return value indicates if the knote should already be considered "activated" at
864 * the time of attach (one or more of the interest events has already occured).
865 *
866 * f_process -
867 * called when attempting to deliver triggered events to user-space.
868 *
869 * If the knote was previously activated, this operator will be called when a
870 * thread is trying to deliver events to user-space. The filter gets one last
871 * chance to determine if the event/events are still interesting for this knote
872 * (are the conditions still right to deliver an event). If so, the filter
873 * fills in the output kevent structure with the information to be delivered.
874 *
875 * The input context/data parameter is used during event delivery. Some
876 * filters allow additional data delivery as part of event delivery. This
877 * context field indicates if space was made available for these additional
878 * items and how that space is to be allocated/carved-out.
879 *
880 * The filter may set EV_CLEAR or EV_ONESHOT in the output flags field to indicate
881 * special post-delivery dispositions for the knote.
882 *
883 * EV_CLEAR - indicates that all matching events have been delivered. Even
884 * though there were events to deliver now, there will not be any
885 * more until some additional events are delivered to the knote
886 * via the f_event operator, or the interest set is changed via
887 * the f_touch operator. The knote can remain deactivated after
888 * processing this event delivery.
889 *
890 * EV_ONESHOT - indicates that this is the last event to be delivered via
891 * this knote. It will automatically be deleted upon delivery
892 * (or if in dispatch-mode, upon re-enablement after this delivery).
893 *
894 * The return value indicates if the knote has delivered an output event.
895 * Unless one of the special output flags was set in the output kevent, a non-
896 * zero return value ALSO indicates that the knote should be re-activated
897 * for future event processing (in case it delivers level-based or a multi-edge
898 * type events like message queues that already exist).
899 *
900 * NOTE: In the future, the boolean may change to an enum that allows more
901 * explicit indication of just delivering a current event vs delivering
902 * an event with more events still pending.
903 *
904 * f_touch -
905 * called to update the knote with new state from the user during
906 * EVFILT_ADD/ENABLE/DISABLE on an already-attached knote.
907 *
908 * f_touch should copy relevant new data from the kevent into the knote.
909 *
910 * operator must lock against concurrent f_event operations.
911 *
912 * A return value of 1 indicates that the knote should now be considered
913 * 'activated'.
914 *
915 * f_touch can set EV_ERROR with specific error in the data field to
916 * return an error to the client. You should return 1 to indicate that
917 * the kevent needs to be activated and processed.
918 *
919 * f_peek -
920 * For knotes marked KN_STAYACTIVE, indicate if the knote is truly active
921 * at the moment (not used for event delivery, but for status checks).
922 *
923 * f_allow_drop -
924 *
925 * [OPTIONAL] If this function is non-null, then it indicates that the
926 * filter wants to validate EV_DELETE events. This is necessary if
927 * a particular filter needs to synchronize knote deletion with its own
928 * filter lock.
929 *
930 * When true is returned, the the EV_DELETE is allowed and can proceed.
931 *
932 * If false is returned, the EV_DELETE doesn't proceed, and the passed in
933 * kevent is used for the copyout to userspace.
934 *
935 * Currently, EVFILT_WORKLOOP is the only filter using this facility.
936 *
937 * f_post_register_wait -
938 * [OPTIONAL] called when attach or touch return the FILTER_REGISTER_WAIT
939 * extended code bit. It is possible to use this facility when the last
940 * register command wants to wait.
941 *
942 * Currently, EVFILT_WORKLOOP is the only filter using this facility.
943 */
944
945struct _kevent_register;
946struct knote_lock_ctx;
947struct proc;
948struct uthread;
949struct waitq;
950
951struct filterops {
952 bool f_isfd; /* true if ident == filedescriptor */
953 bool f_adjusts_qos; /* true if the filter can override the knote */
954 bool f_extended_codes; /* hooks return extended codes */
955
956 int (*f_attach)(struct knote *kn, struct kevent_internal_s *kev);
957 void (*f_detach)(struct knote *kn);
958 int (*f_event)(struct knote *kn, long hint);
959 int (*f_touch)(struct knote *kn, struct kevent_internal_s *kev);
960 int (*f_process)(struct knote *kn, struct filt_process_s *data, struct kevent_internal_s *kev);
961 int (*f_peek)(struct knote *kn);
962
963 /* optional & advanced */
964 bool (*f_allow_drop)(struct knote *kn, struct kevent_internal_s *kev);
965 void (*f_post_register_wait)(struct uthread *uth, struct knote_lock_ctx *ctx,
966 struct _kevent_register *ss_kr);
967};
968
969/*
970 * Extended codes returned by filter routines when f_extended_codes is set.
971 *
972 * FILTER_ACTIVE
973 * The filter is active and a call to f_process() may return an event.
974 *
975 * For f_process() the meaning is slightly different: the knote will be
976 * activated again as long as f_process returns FILTER_ACTIVE, unless
977 * EV_CLEAR is set, which require a new f_event to reactivate the knote.
978 *
979 * Valid: f_attach, f_event, f_touch, f_process, f_peek
980 * Implicit: -
981 * Ignored: -
982 *
983 * FILTER_REGISTER_WAIT
984 * The filter wants its f_post_register_wait() to be called.
985 *
986 * Note: It is only valid to ask for this behavior for a workloop kqueue,
987 * and is really only meant to be used by EVFILT_WORKLOOP.
988 *
989 * Valid: f_attach, f_touch
990 * Implicit: -
991 * Ignored: f_event, f_process, f_peek
992 *
993 * FILTER_UPDATE_REQ_QOS
994 * The filter wants the passed in QoS to be updated as the new intrinsic qos
995 * for this knote. If the kevent `qos` field is 0, no update is performed.
996 *
997 * This also will reset the event QoS, so FILTER_ADJUST_EVENT_QOS() must
998 * also be used if an override should be maintained.
999 *
1000 * Valid: f_touch
1001 * Implicit: f_attach
1002 * Ignored: f_event, f_process, f_peek
1003 *
1004 * FILTER_RESET_EVENT_QOS
1005 * FILTER_ADJUST_EVENT_QOS(qos)
1006 * The filter wants the QoS of the next event delivery to be overridden
1007 * at the specified QoS. This allows for the next event QoS to be elevated
1008 * from the knote requested qos (See FILTER_UPDATE_REQ_QOS).
1009 *
1010 * Event QoS Overrides are reset when a particular knote is no longer
1011 * active. Hence this is ignored if FILTER_ACTIVE isn't also returned.
1012 *
1013 * Races between an f_event() and any other f_* routine asking for
1014 * a specific QoS override are handled generically and the filters do not
1015 * have to worry about them.
1016 *
1017 * To use this facility, filters MUST set their f_adjusts_qos bit to true.
1018 *
1019 * It is expected that filters will return the new QoS they expect to be
1020 * applied from any f_* callback except for f_process() where no specific
1021 * information should be provided. Filters should not try to hide no-ops,
1022 * kevent will already optimize these away.
1023 *
1024 * Valid: f_touch, f_attach, f_event, f_process
1025 * Implicit: -
1026 * Ignored: f_peek
1027 */
1028#define FILTER_ACTIVE 0x00000001
1029#define FILTER_REGISTER_WAIT 0x00000002
1030#define FILTER_UPDATE_REQ_QOS 0x00000004
1031#define FILTER_ADJUST_EVENT_QOS_BIT 0x00000008
1032#define FILTER_ADJUST_EVENT_QOS_MASK 0x00000070
1033#define FILTER_ADJUST_EVENT_QOS_SHIFT 4
1034#define FILTER_ADJUST_EVENT_QOS(qos) \
1035 (((qos) << FILTER_ADJUST_EVENT_QOS_SHIFT) | FILTER_ADJUST_EVENT_QOS_BIT)
1036#define FILTER_RESET_EVENT_QOS FILTER_ADJUST_EVENT_QOS_BIT
1037
1038#define filter_call(_ops, call) \
1039 ((_ops)->f_extended_codes ? (_ops)->call : !!((_ops)->call))
1040
1041SLIST_HEAD(klist, knote);
1042extern void knote_init(void);
1043extern void klist_init(struct klist *list);
1044
1045#define KNOTE(list, hint) knote(list, hint)
1046#define KNOTE_ATTACH(list, kn) knote_attach(list, kn)
1047#define KNOTE_DETACH(list, kn) knote_detach(list, kn)
1048
1049extern void knote(struct klist *list, long hint);
1050extern int knote_attach(struct klist *list, struct knote *kn);
1051extern int knote_detach(struct klist *list, struct knote *kn);
1052extern void knote_vanish(struct klist *list);
1053extern void knote_link_waitqset_lazy_alloc(struct knote *kn);
1054extern boolean_t knote_link_waitqset_should_lazy_alloc(struct knote *kn);
1055extern int knote_link_waitq(struct knote *kn, struct waitq *wq, uint64_t *reserved_link);
1056extern int knote_unlink_waitq(struct knote *kn, struct waitq *wq);
1057extern void knote_fdclose(struct proc *p, int fd);
1058extern void knote_markstayactive(struct knote *kn);
1059extern void knote_clearstayactive(struct knote *kn);
1060extern const struct filterops *knote_fops(struct knote *kn);
1061extern void knote_set_error(struct knote *kn, int error);
1062
1063extern struct turnstile *kqueue_turnstile(struct kqueue *);
1064extern struct turnstile *kqueue_alloc_turnstile(struct kqueue *);
1065
1066int kevent_exit_on_workloop_ownership_leak(thread_t thread);
1067int kevent_proc_copy_uptrs(void *proc, uint64_t *buf, int bufsize);
1068int kevent_copyout_proc_dynkqids(void *proc, user_addr_t ubuf,
1069 uint32_t ubufsize, int32_t *nkqueues_out);
1070int kevent_copyout_dynkqinfo(void *proc, kqueue_id_t kq_id, user_addr_t ubuf,
1071 uint32_t ubufsize, int32_t *size_out);
1072int kevent_copyout_dynkqextinfo(void *proc, kqueue_id_t kq_id, user_addr_t ubuf,
1073 uint32_t ubufsize, int32_t *nknotes_out);
1074
1075#elif defined(KERNEL_PRIVATE) /* !XNU_KERNEL_PRIVATE: kexts still need a klist structure definition */
1076
1077#include <sys/queue.h>
1078struct proc;
1079struct knote;
1080SLIST_HEAD(klist, knote);
1081
1082#endif /* !XNU_KERNEL_PRIVATE && KERNEL_PRIVATE */
1083
1084#ifdef KERNEL_PRIVATE
1085#ifdef PRIVATE
1086
1087/* make these private functions available to the pthread kext */
1088extern int kevent_qos_internal(struct proc *p, int fd,
1089 user_addr_t changelist, int nchanges,
1090 user_addr_t eventlist, int nevents,
1091 user_addr_t data_out, user_size_t *data_available,
1092 unsigned int flags, int32_t *retval);
1093
1094extern int kevent_id_internal(struct proc *p, kqueue_id_t *id,
1095 user_addr_t changelist, int nchanges,
1096 user_addr_t eventlist, int nevents,
1097 user_addr_t data_out, user_size_t *data_available,
1098 unsigned int flags, int32_t *retval);
1099
1100#endif /* PRIVATE */
1101#endif /* KERNEL_PRIVATE */
1102
1103#else /* KERNEL */
1104
1105#include <sys/types.h>
1106
1107struct timespec;
1108
1109__BEGIN_DECLS
1110int kqueue(void);
1111int kevent(int kq,
1112 const struct kevent *changelist, int nchanges,
1113 struct kevent *eventlist, int nevents,
1114 const struct timespec *timeout);
1115int kevent64(int kq,
1116 const struct kevent64_s *changelist, int nchanges,
1117 struct kevent64_s *eventlist, int nevents,
1118 unsigned int flags,
1119 const struct timespec *timeout);
1120
1121#ifdef PRIVATE
1122int kevent_qos(int kq,
1123 const struct kevent_qos_s *changelist, int nchanges,
1124 struct kevent_qos_s *eventlist, int nevents,
1125 void *data_out, size_t *data_available,
1126 unsigned int flags);
1127
1128int kevent_id(kqueue_id_t id,
1129 const struct kevent_qos_s *changelist, int nchanges,
1130 struct kevent_qos_s *eventlist, int nevents,
1131 void *data_out, size_t *data_available,
1132 unsigned int flags);
1133#endif /* PRIVATE */
1134
1135__END_DECLS
1136
1137
1138#endif /* KERNEL */
1139
1140#ifdef PRIVATE
1141
1142/* Flags for pending events notified by kernel via return-to-kernel ast */
1143#define R2K_WORKLOOP_PENDING_EVENTS 0x1
1144#define R2K_WORKQ_PENDING_EVENTS 0x2
1145
1146#endif /* PRIVATE */
1147
1148#endif /* !_SYS_EVENT_H_ */
1149