svcadm(8)을 검색하려면 섹션에서 8 을 선택하고, 맨 페이지 이름에 svcadm을 입력하고 검색을 누른다.
kqueue(2)
The system call provides a generic method of notifying the user
when an event happens or a condition holds, based on the results
of small pieces of kernel code termed filters. A kevent is iden‐
tified by the (ident, filter) pair; there may only be one unique
kevent per kqueue. The filter is executed upon the initial reg‐
istration of a kevent in order to detect whether a preexisting
condition is present, and is also executed whenever an event is
passed to the filter for evaluation. If the filter determines
that the condition should be reported, then the kevent is placed
on the kqueue for the user to retrieve. The filter is also run
when the user attempts to retrieve the kevent from the kqueue.
If the filter indicates that the condition that triggered the
event no longer holds, the kevent is removed from the kqueue and
is not returned. Multiple events which trigger the filter do not
result in multiple kevents being placed on the kqueue; instead,
the filter will aggregate the events into a single struct kevent.
Calling on a file descriptor will remove any kevents that refer‐
ence the descriptor. The system call creates a new kernel event
queue and returns a descriptor. The queue is not inherited by a
child created with However, if is called without the flag, then
the descriptor table is shared, which will allow sharing of the
kqueue between two processes. The system call is used to regis‐
ter events with the queue, and return any pending events to the
user. The argument is a pointer to an array of structures, as
defined in All changes contained in the are applied before any
pending events are read from the queue. The argument gives the
size of The argument is a pointer to an array of kevent struc‐
tures. The argument determines the size of When is zero, will
return immediately even if there is a specified unlike If is a
non-NULL pointer, it specifies a maximum interval to wait for an
event, which will be interpreted as a struct timespec. If is a
NULL pointer, waits indefinitely. To effect a poll, the argument
should be non-NULL, pointing to a zero-valued structure. The
same array may be used for the and The macro is provided for ease
of initializing a kevent structure. The structure is defined as:
struct kevent { uintptr_t ident; /* identifier for
this event */ short filter; /* filter for event
*/ u_short flags; /* action flags for kqueue */
u_int fflags; /* filter flag value */
int64_t data; /* filter data value */
void *udata; /* opaque user data identifier */
uint64_t ext[4]; /* extensions */ }; The fields of
are: Value used to identify this event. The exact interpretation
is determined by the attached filter, but often is a file de‐
scriptor. Identifies the kernel filter used to process this
event. The pre-defined system filters are described below. Ac‐
tions to perform on the event. Filter-specific flags. Filter-
specific data value. Opaque user-defined value passed through
the kernel unchanged. Extended data passed to and from kernel.
The and members use is defined by the filter. If the filter does
not use them, the members are copied unchanged. The and members
are always passed through the kernel as-is, making additional
context available to application. The field can contain the fol‐
lowing values: Adds the event to the kqueue. Re-adding an exist‐
ing event will modify the parameters of the original event, and
not result in a duplicate entry. Adding an event automatically
enables it, unless overridden by the EV_DISABLE flag. Permit to
return the event if it is triggered. Disable the event so will
not return it. The filter itself is not disabled. Disable the
event source immediately after delivery of an event. See above.
Removes the event from the kqueue. Events which are attached to
file descriptors are automatically deleted on the last close of
the descriptor. This flag is useful for making bulk changes to a
kqueue without draining any pending events. When passed as in‐
put, it forces to always be returned. When a filter is success‐
fully added the field will be zero. Causes the event to return
only the first occurrence of the filter being triggered. After
the user retrieves the event from the kqueue, it is deleted. Af‐
ter the event is retrieved by the user, its state is reset. This
is useful for filters which report state transitions instead of
the current state. Note that some filters may automatically set
this flag internally. Filters may set this flag to indicate fil‐
ter-specific EOF condition. See below. The predefined system
filters are listed below. Arguments may be passed to and from
the filter via the and fields in the kevent structure. Takes a
descriptor as the identifier, and returns whenever there is data
available to read. The behavior of the filter is slightly dif‐
ferent depending on the descriptor type. Sockets which have pre‐
viously been passed to return when there is an incoming connec‐
tion pending. contains the size of the listen backlog. Other
socket descriptors return when there is data to be read, subject
to the value of the socket buffer. This may be overridden with a
per-filter low water mark at the time the filter is added by set‐
ting the flag in and specifying the new low water mark in On re‐
turn, contains the number of bytes of protocol data available to
read. If the read direction of the socket has shutdown, then the
filter also sets in and returns the socket error (if any) in It
is possible for EOF to be returned (indicating the connection is
gone) while there is still data pending in the socket buffer.
Returns when the file pointer is not at the end of file. con‐
tains the offset from current position to end of file, and may be
negative. This behavior is different from where read events are
triggered for regular files unconditionally. This event can be
triggered unconditionally by setting the flag in Returns when the
there is data to read; contains the number of bytes available.
When the last writer disconnects, the filter will set in This may
be cleared by passing in at which point the filter will resume
waiting for data to become available before returning. Returns
when the BPF buffer is full, the BPF timeout has expired, or when
the BPF has enabled and there is any data to read; contains the
number of bytes available. Takes a descriptor as the identifier,
and returns whenever it is possible to write to the descriptor.
For sockets, pipes and fifos, will contain the amount of space
remaining in the write buffer. The filter will set EV_EOF when
the reader disconnects, and for the fifo case, this may be
cleared by use of Note that this filter is not supported for vn‐
odes or BPF devices. For sockets, the low water mark and socket
error handling is identical to the case. Takes a descriptor as
the identifier, and returns whenever there is no remaining data
in the write buffer. Events for this filter are not registered
with directly but are registered via the member of an asynchro‐
nous I/O request when it is scheduled via an asynchronous I/O
system call such as The filter returns under the same conditions
as For more details on this filter see Takes a file descriptor as
the identifier and the events to watch for in and returns when
one or more of the requested events occurs on the descriptor.
The events to monitor are: The file referenced by the descriptor
had its attributes changed. A file descriptor referencing the
monitored file, was closed. The closed file descriptor did not
have write access. A file descriptor referencing the monitored
file, was closed. The closed file descriptor had write access.
This note, as well as are not activated when files are closed
forcibly by Instead, is sent for such events. The system call
was called on the file referenced by the descriptor. For regular
file, the file referenced by the descriptor was extended. For
directory, reports that a directory entry was added or removed,
as the result of rename operation. The event is not reported
when a name is changed inside the directory. The link count on
the file changed. In particular, the event is reported if a sub‐
directory was created or deleted inside the directory referenced
by the descriptor. The file referenced by the descriptor was
opened. A read occurred on the file referenced by the descrip‐
tor. The file referenced by the descriptor was renamed. Access
to the file was revoked via or the underlying file system was un‐
mounted. A write occurred on the file referenced by the descrip‐
tor. On return, contains the events which triggered the filter.
Takes the process ID to monitor as the identifier and the events
to watch for in and returns when the process performs one or more
of the requested events. If a process can normally see another
process, it can attach an event to it. The events to monitor
are: The process has exited. The exit status will be stored in
The process has called The process has executed a new process via
or a similar call. Follow a process across calls. The parent
process registers a new kevent to monitor the child process using
the same as the original event. The child process will signal an
event with set in and the parent PID in If the parent process
fails to register a new kevent it will signal an event with set
in and the child process will not signal a event. On return,
contains the events which triggered the filter. Takes the
process descriptor created by to monitor as the identifier and
the events to watch for in and returns when the associated
process performs one or more of the requested events. The events
to monitor are: The process has exited. The exit status will be
stored in On return, contains the events which triggered the fil‐
ter. Takes the signal number to monitor as the identifier and
returns when the given signal is delivered to the process. This
coexists with the and facilities, and has a lower precedence.
The filter will record all attempts to deliver a signal to a
process, even if the signal has been marked as except for the
signal, which, if ignored, will not be recorded by the filter.
Event notification happens after normal signal delivery process‐
ing. returns the number of times the signal has occurred since
the last call to This filter automatically sets the flag inter‐
nally. Establishes an arbitrary timer identified by When adding
a timer, specifies the moment to fire the timer (for or the time‐
out period. The timer will be periodic unless or is specified.
On return, contains the number of times the timeout has expired
since the last call to For non-monotonic timers, this filter au‐
tomatically sets the flag internally. The filter accepts the
following flags in the argument: is in seconds. is in millisec‐
onds. is in microseconds. is in nanoseconds. The specified ex‐
piration time is absolute. If is not set, the default is mil‐
liseconds. On return, contains the events which triggered the
filter. If an existing timer is re-added, the existing timer
will be effectively canceled (throwing away any undelivered
record of previous timer expiration) and re-started using the new
parameters contained in and There is a system wide limit on the
number of timers which is controlled by the sysctl. Establishes
a user event identified by which is not associated with any ker‐
nel mechanism but is triggered by user level code. The lower 24
bits of the may be used for user defined flags and manipulated
using the following: Ignore the input Bitwise AND Bitwise OR Copy
Control mask for User defined flag mask for A user event is trig‐
gered for output with the following: Cause the event to be trig‐
gered. On return, contains the users defined flags in the lower
24 bits. If is non-zero, i.e., the function is potentially
blocking, the call is a cancellation point. Otherwise, i.e., if
is zero, the call is not cancellable. Cancellation can only oc‐
cur before any changes are made to the kqueue, or when the call
was blocked and no changes to the queue were requested. The sys‐
tem call creates a new kernel event queue and returns a file de‐
scriptor. If there was an error creating the kernel event queue,
a value of -1 is returned and errno set. The system call returns
the number of events placed in the up to the value given by If an
error occurs while processing an element of the and there is
enough room in the then the event will be placed in the with set
in and the system error in Otherwise, will be returned, and will
be set to indicate the error condition. If the time limit ex‐
pires, then returns 0. #include <sys/event.h> #include <err.h>
#include <fcntl.h> #include <stdio.h> #include <stdlib.h> #in‐
clude <string.h>
int main(int argc, char **argv) {
struct kevent event; /* Event we want to monitor */
struct kevent tevent; /* Event triggered */
int kq, fd, ret;
if (argc != 2) err(EXIT_FAILURE, "Usage: %s path\n",
argv[0]);
fd = open(argv[1], O_RDONLY);
if (fd == -1) err(EXIT_FAILURE, "Failed to open
'%s'", argv[1]);
/* Create kqueue. */
kq = kqueue();
if (kq == -1) err(EXIT_FAILURE, "kqueue() failed");
/* Initialize kevent structure. */
EV_SET(&event, fd, EVFILT_VNODE, EV_ADD | EV_CLEAR,
NOTE_WRITE, 0, NULL);
/* Attach event to the kqueue. */
ret = kevent(kq, &event, 1, NULL, 0, NULL);
if (ret == -1) err(EXIT_FAILURE, "kevent register");
if (event.flags & EV_ERROR) errx(EXIT_FAILURE, "Event
error: %s", strerror(event.data));
for (;;) { /* Sleep until something happens. */
ret = kevent(kq, NULL, 0, &tevent, 1, NULL); if
(ret == -1) { err(EXIT_FAILURE, "kevent wait");
} else if (ret > 0) { printf("Something was
written in '%s'\n", argv[1]); }
} } The system call fails if: The kernel failed to allocate
enough memory for the kernel queue. The rlimit (see for the cur‐
rent user would be exceeded. The per-process descriptor table is
full. The system file table is full. The system call fails if:
The process does not have permission to register a filter. There
was an error reading or writing the structure. The specified de‐
scriptor is invalid. A signal was delivered before the timeout
expired and before any events were placed on the kqueue for re‐
turn. A cancellation request was delivered to the thread, but
not yet handled. The specified time limit or filter is invalid.
The event could not be found to be modified or deleted. No mem‐
ory was available to register the event or, in the special case
of a timer, the maximum number of timers has been exceeded. This
maximum is configurable via the sysctl. The specified process to
attach to does not exist. When call fails with error, all
changes in the have been applied. The and system calls first ap‐
peared in The system and this manual page were written by The
value is limited to 24 hours; longer timeouts will be silently
reinterpreted as 24 hours. In versions older than failed to
parse without including manually.