MsgSendPulsePtr(), MsgSendPulsePtr_r()

Send a pulse (containing a pointer) to a process


#include <sys/neutrino.h>

int MsgSendPulsePtr ( int coid,
                      int priority,
                      int code,
                      void *value );

int MsgSendPulsePtr_r ( int coid,
                        int priority,
                        int code,
                        void *value );


The ID of the connection to the channel to send the pulse on, which you've established by calling ConnectAttach() or one of its cover functions, such as message_connect().
The priority to use for the pulse, or -1 to use the priority of the calling thread. The priority must be within the range of valid priorities, which you can determine by calling sched_get_priority_min() and sched_get_priority_max().
The 8-bit pulse code.

Although code can be any 8-bit signed value, you should avoid code values less than zero, in order to avoid conflict with pulse codes generated by the kernel or a QNX Neutrino manager. These codes all start with _PULSE_CODE_ and are defined in <sys/neutrino.h>; for more information, see the documentation for the _pulse structure. A safe range of pulse values is _PULSE_CODE_MINAVAIL through _PULSE_CODE_MAXAVAIL.

The pointer that you want to use as the pulse value. The data that the pointer references isn't copied; the actual pointer value is transmitted.



Use the -l c option to qcc to link against this library. This library is usually included automatically.


The MsgSendPulsePtr() and MsgSendPulsePtr_r() kernel calls send a short, nonblocking message to a process's channel via the connection identified by coid. These functions are identical except in the way they indicate errors. See the Returns section for details.

You can use MsgSendPulsePtr() to wake up another thread in the same process and provide it with the address of an object to operate on. It's possible to use this function between processes, but as the pointer will be invalid in the receiving process, it might be clearer to send an integer value by using MsgSendPulse(). If you want to copy the data instead of a pointer to it, use MsgSend().

You can send a pulse to a process if:

Pulses are queued for the receiving process in the system, using a dynamic pool of memory objects. If pulses are generated faster than they can be consumed by the receiver, then over a period of time the system queue for the pulses could reach a low memory condition. If there's no memory available for the pulse to be queued in the system, the kernel fails the pulse request with an error of EAGAIN. If the priority, code and value don't change, the kernel compresses the pulses by storing an 8-bit count with an already queued pulse.

Note: The receiving thread's effective priority might change when you send a pulse to it. For more information, see Priority inheritance and messages in the Interprocess Communication (IPC) chapter of the System Architecture guide.

When you receive a pulse via the MsgReceive*() kernel call, the rcvid returned is zero. This indicates to the receiver that it's a pulse and, unlike a message, shouldn't be replied to using MsgReply*().

Blocking states

None for the local case. In the network case:

The calling thread is blocked while the pulse is delivered to the local Qnet manager, which transmits it to the remote Qnet. The remote Qnet does a MsgSendPulsePtr() on behalf of the caller, and the return value is transmitted back, at which point the calling thread is unblocked.

Native networking

You can use MsgSendPulsePtr() to send pulses across the network, but there isn't much point in doing so because the pointer value would be meaningless to the receiving process.


The only difference between the MsgSendPulsePtr() and MsgSendPulsePtr_r() functions is the way they indicate errors:

If an error occurs, this function returns -1 and sets errno. Any other value returned indicates success.
If successful, this function returns EOK. This function does NOT set errno, even on success. If an error occurs, it may return the negative of any value from the Errors section.


The kernel had insufficient resources to enqueue the pulse.
The connection indicated by coid is no longer connected to a channel or the connection indicated by coid doesn't exist. The channel may have been terminated by the server or the network manager if it failed to respond to multiple polls.
The host is down (e.g., a send across Qnet failed).
Unable to communicate with remote node (e.g., across Qnet).
The specified priority is invalid (e.g., 0).
The calling process doesn't have the required permission; see procmgr_ability().
A fault occurred in the server's address space when the kernel tried to write the pulse message to the server's receive message buffer.


QNX Neutrino

Cancellation point No
Interrupt handler No
Signal handler Yes
Thread Yes


If the server faults on delivery, the pulse is either lost or an error is returned.