Manpages - dispatch_source_create.3

Dispatch event sources may be used to monitor a variety of system objects and events including file descriptors, mach ports, processes, virtual filesystem nodes, signal delivery and timers.

When a state change occurs, the dispatch source will submit its event handler block to its target queue.

The

function creates a new dispatch source object that may be retained and released with calls to

and

respectively. The

parameter specifies the target queue of the new source object, it will be retained by the source object. Pass the

constant to use the default target queue (the default priority global concurrent queue).

Newly created sources are created in a suspended state. After the source has been configured by setting an event handler, cancellation handler, registration handler, context, etc., the source must be activated by a call to

before any events will be delivered.

Dispatch sources may be one of the following types:

DISPATCH_SOURCE_TYPE_DATA_ADD

DISPATCH_SOURCE_TYPE_DATA_OR

DISPATCH_SOURCE_TYPE_DATA_REPLACE

DISPATCH_SOURCE_TYPE_MACH_SEND

DISPATCH_SOURCE_TYPE_MACH_RECV

DISPATCH_SOURCE_TYPE_MEMORYPRESSURE

DISPATCH_SOURCE_TYPE_PROC

DISPATCH_SOURCE_TYPE_READ

DISPATCH_SOURCE_TYPE_SIGNAL

DISPATCH_SOURCE_TYPE_TIMER

DISPATCH_SOURCE_TYPE_VNODE

DISPATCH_SOURCE_TYPE_WRITE

The

and

arguments to

and the return values of the

and

functions should be interpreted according to the type of the dispatch source.

The

function returns the underlying handle to the dispatch source (i.e. file descriptor, mach port, process identifer, etc.). The result of this function may be cast directly to the underlying type.

The

function returns the set of flags that were specified at source creation time via the

argument.

The

function returns the currently pending data for the dispatch source. This function should only be called from within the source’s event handler. The result of calling this function from any other context is undefined.

The

function is intended for use with the

and

source types. The result of using this function with any other source type is undefined. Data merging is performed according to the source type:

is atomically added to the source’s data

is atomically bitwise ORed into the source’s data

atomically replaces the source’s data.

If the source data value resulting from the merge operation is 0, the source handler will not be invoked. This can happen if:

the atomic addition wraps for sources of type

0 is merged for sources of type

In order to receive events from the dispatch source, an event handler should be specified via

The event handler block is submitted to the source’s target queue when the state of the underlying system handle changes, or when an event occurs. If a source is resumed with no event handler block set, events will be quietly ignored. If the event handler block is changed while the source is suspended, or from a block running on a serial queue that is the source’s target queue, then the next event handler invocation will use the new block.

Dispatch sources may be suspended or resumed independently of their target queues using

and

on the dispatch source directly. The data describing events which occur while a source is suspended are coalesced and delivered once the source is resumed.

The

block need not be reentrant safe, as it is not resubmitted to the target

until any prior invocation for that dispatch source has completed. When the handler is set, the dispatch source will perform a

on the

block.

To unset the event handler, call

and pass NULL as

This unsets the event handler regardless of whether the handler was a function pointer or a block. Registration and cancellation handlers (see below) may be unset in the same way, but as noted below, a cancellation handler may be required.

When

is called on a suspended or newly created source, there may be a brief delay before the source is ready to receive events from the underlying system handle. During this delay, the event handler will not be invoked, and events will be missed.

Once the dispatch source is registered with the underlying system and is ready to process all events its optional registration handler will be submitted to its target queue. This registration handler may be specified via

The event handler will not be called until the registration handler finishes. If the source is canceled (see below) before it is registered, its registration handler will not be called.

The

function asynchronously cancels the dispatch source, preventing any further invocation of its event handler block. Cancellation does not interrupt a currently executing handler block (non-preemptive). If a source is canceled before the first time it is resumed, its event handler will never be called. (In this case, note that the source must be resumed before it can be released.)

The

function may be used to determine whether the specified source has been canceled. A non-zero value will be returned if the source is canceled.

When a dispatch source is canceled its optional cancellation handler will be submitted to its target queue. The cancellation handler may be specified via

This cancellation handler is invoked only once, and only as a direct consequence of calling

a cancellation handler is required for file descriptor and mach port based sources in order to safely close the descriptor or destroy the port. Closing the descriptor or port before the cancellation handler has run may result in a race condition: if a new descriptor is allocated with the same value as the recently closed descriptor while the source’s event handler is still running, the event handler may read/write data to the wrong descriptor.

The following section contains a summary of supported dispatch event types and the interpretation of their parameters and returned data.

Sources of this type allow applications to manually trigger the source’s event handler via a call to

The data will be merged with the source’s pending data via an atomic add or atomic bitwise OR, or direct replacement (based on the source’s type), and the event handler block will be submitted to the source’s target queue. The

is application defined. These sources have no

or

and zero should be used.

Sources of this type monitor a mach port with a send right for state changes. The

is the mach port (mach_port_t) to monitor and the

may be:

The port’s corresponding receive right has been destroyed

The data returned by

is a bitmask that indicates which of the events in the

were observed. Note that because this source type will request notifications on the provided port, it should not be mixed with the use of

on the same port.

Sources of this type monitor a mach port with a receive right for state changes. The

is the mach port (mach_port_t) to monitor and the

is unused and should be zero. The event handler block will be submitted to the target queue when a message on the mach port is waiting to be received.

Sources of this type monitor the system memory pressure condition for state changes. The

is unused and should be zero. The

may be one or more of the following:

The system memory pressure condition has returned to normal.

The system memory pressure condition has changed to warning.

The system memory pressure condition has changed to critical.

The data returned by

indicates which of the events in the

were observed.

Elevated memory pressure is a system-wide condition that applications registered for this source should react to by changing their future memory use behavior, e.g. by reducing cache sizes of newly initiated operations until memory pressure returns back to normal.

However, applications should

traverse and discard existing caches for past operations when the system memory pressure enters an elevated state, as that is likely to trigger VM operations that will further aggravate system memory pressure.

Sources of this type monitor processes for state changes. The

is the process identifier (pid_t) of the process to monitor and the

may be one or more of the following:

The process has exited and is available to

The process has created one or more child processes.

The process has become another executable image via a call to

or

A signal was delivered to the process.

The data returned by

is a bitmask that indicates which of the events in the

were observed.

Sources of this type monitor file descriptors for pending data. The

is the file descriptor (int) to monitor and the

is unused and should be zero.

The data returned by

is an estimated number of bytes available to be read from the descriptor. This estimate should be treated as a suggested

read buffer size. There are no guarantees that a complete read of this size will be performed.

Users of this source type are strongly encouraged to perform non-blocking I/O and handle any truncated reads or error conditions that may occur. See

for additional information about setting the

flag on a file descriptor.

Sources of this type monitor signals delivered to the current process. The

is the signal number to monitor (int) and the

is unused and should be zero.

The data returned by

is the number of signals received since the last invocation of the event handler block.

Unlike signal handlers specified via

the execution of the event handler block does not interrupt the current thread of execution; therefore the handler block is not limited to the use of signal safe interfaces defined in

Furthermore, multiple observers of a given signal are supported; thus allowing applications and libraries to cooperate safely. However, a dispatch source

install a signal handler or otherwise alter the behavior of signal delivery. Therefore, applications must ignore or at least catch any signal that terminates a process by default. For example, near the top of

signal(SIGTERM, SIG_IGN);

Sources of this type periodically submit the event handler block to the target queue. The

argument is unused and should be zero.

The data returned by

is the number of times the timer has fired since the last invocation of the event handler block.

The timer parameters are configured with the

function. Once this function returns, any pending source data accumulated for the previous timer parameters has been cleared; the next fire of the timer will occur at

and every

nanoseconds thereafter until the timer source is canceled.

Any fire of the timer may be delayed by the system in order to improve power consumption and system performance. The upper limit to the allowable delay may be configured with the

argument, the lower limit is under the control of the system.

For the initial timer fire at

the upper limit to the allowable delay is set to

nanoseconds. For the subsequent timer fires at

the upper limit is

The lower limit to the allowable delay may vary with process state such as visibility of application UI. If the specified timer source was created with a

of

the system will make a best effort to strictly observe the provided

value even if it is smaller than the current lower limit. Note that a minimal amount of delay is to be expected even if this flag is specified.

The

argument also determines which clock will be used for the timer: If

is

or was created with

the timer is based on up time (which is obtained from

on Apple platforms). If

was created with

the timer is based on

Sources of this type monitor the virtual filesystem nodes for state changes. The

is a file descriptor (int) referencing the node to monitor, and the

may be one or more of the following:

The referenced node was removed from the filesystem namespace via

A write to the referenced file occurred.

The referenced file was extended.

The metadata attributes of the referenced node have changed.

The link count on the referenced node has changed.

The referenced node was renamed.

Access to the referenced node was revoked via

or the underlying fileystem was unmounted.

The referenced file was unlocked by

or

The data returned by

is a bitmask that indicates which of the events in the

were observed.

Sources of this type monitor file descriptors for available write buffer space. The

is the file descriptor (int) to monitor and the

is unused and should be zero.

Users of this source type are strongly encouraged to perform non-blocking I/O and handle any truncated reads or error conditions that may occur. See

for additional information about setting the

flag on a file descriptor.