mailbox.h

Include dependency graph for mailbox.h:

This graph shows which files directly or indirectly include mailbox.h:

Mailbox management functions such as send and receive functions.

Mailbox management functions should be used to send messages to a certain process or port and to receive them.

Defines

ATOMIC

TYPEDEF_CONTEXT

TYPEDEF_GLOBALCONTEXT

TYPEDEF_HEAP

TYPEDEF_MAILBOXMESSAGE

TYPEDEF_MESSAGE

Typedefs

typedef struct Context Context

typedef struct GlobalContext GlobalContext

typedef struct Heap Heap

typedef struct MailboxMessage MailboxMessage

typedef struct Message Message

Enums

enum MessageType

Values:

enumerator NormalMessage

enumerator KillSignal

enumerator GCSignal

enumerator ProcessInfoRequestSignal

enumerator TrapAnswerSignal

enumerator TrapExceptionSignal

enumerator FlushMonitorSignal

enumerator FlushInfoMonitorSignal

enumerator SetGroupLeaderSignal

enumerator MonitorSignal

enumerator UnlinkIDSignal

enumerator UnlinkIDAckSignal

enumerator UnlinkRemoteIDSignal

enumerator UnlinkRemoteIDAckSignal

enumerator LinkExitSignal

enumerator DemonitorSignal

enumerator MonitorDownSignal

enumerator CodeServerResumeSignal

enumerator AliasMessageSignal

enum process_info_mode_t

Values:

enumerator ProcessInfoSingle

enumerator ProcessInfoList

Functions

void mailbox_init(Mailbox *mbox)

Initialize the mailbox.

Parameters:

mbox – the mailbox to initialize.

size_t mailbox_len(Mailbox *mbox)

Compute the mailbox length, in messages.

To be called from the process only.

Parameters:

mbox – the mailbox to get the length of.

size_t mailbox_normal_message_len(Mailbox *mbox)

Compute the number of queued messages in the mailbox, not counting signals.

This is what message_queue_len reports: normal messages plus accepted alias messages not yet converted, which OTP counts as queued even if the alias is deactivated before reception. To be called from the process only.

Parameters:

mbox – the mailbox to get the number of messages of.

size_t mailbox_size(Mailbox *mbox)

Compute the mailbox size, in bytes.

To be called from the process only.

Parameters:

mbox – the mailbox to get the size of.

MailboxMessage *mailbox_process_outer_list_native(Mailbox *mbox)

Process the outer list of messages, ignoring aliases.

Alias-blind variant of mailbox_process_outer_list, for callers that never own an active alias: native (port) processes, context teardown and crashdump. To be called from the process only.

Parameters:

mbox – the mailbox to work with

Returns:

the signal messages in received order.

MailboxMessage *mailbox_process_outer_list(Context *ctx)

Process the outer list of messages, delivering alias messages in send order.

AliasMessageSignals are validated in ctx’s own monitor list and, when the alias is active, converted to normal messages in place so they keep send order relative to plain messages from the same sender. To be called from the process only, while not holding the processes table lock (the reply_demonitor path takes it).

Parameters:

ctx – the context whose mailbox is processed

Returns:

the remaining (non-alias) signal messages in received order.

void mailbox_send(Context *c, term t)

Sends a message to a certain mailbox.

Sends a term to a certain process or port mailbox. Can be called from another process. Cannot be called from a task or from ISR.

Parameters:

c – the process context.
t – the term that will be sent.

void mailbox_send_term_signal(Context *c, enum MessageType type, term t)

Sends a term-based signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal
t – the term added to the message

void mailbox_send_immediate_signal(Context *c, enum MessageType type, term immediate)

Sends an immediate signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal
immediate – the immediate term to send (atom or pid)

bool mailbox_send_process_info_request_signal(Context *c, int32_t sender_pid, process_info_mode_t mode, const term atoms[], size_t atoms_len)

Sends a process info request signal to a certain mailbox.

Parameters:

c – the process context.
sender_pid – the sender of the signal (to get the answer)
mode – whether the answer is a single item tuple or a list of them
atoms – array of atom terms to query
atoms_len – number of atoms in the array

Returns:

true if the signal was sent, false on allocation failure, in which case no answer will ever be sent back

void mailbox_send_ref_signal(Context *c, enum MessageType type, uint64_t ref_ticks)

Sends a ref signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal
ref_ticks – the ref

void mailbox_send_immediate_ref_signal(Context *c, enum MessageType type, term immediate, uint64_t ref_ticks)

Sends an immediate and ref signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal
immediate – the immediate term to send (atom or pid)
ref_ticks – the ref

void mailbox_send_monitor_signal(Context *c, enum MessageType type, struct Monitor *monitor)

Sends a ref immediate signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal
monitor – the monitor

void mailbox_send_empty_body_signal(Context *c, enum MessageType type)

Sends an empty body signal to a certain mailbox.

Parameters:

c – the process context.
type – the type of the signal

void mailbox_post_message(Context *c, MailboxMessage *m)

Post a message.

Post a message to a given context. Context gets ownership of the created message.

Parameters:

c – the process context.
m – the mailbox message to send

void mailbox_enqueue_message(Context *c, MailboxMessage *m)

Enqueue message.

This function does not signal the process to be ready and is only meant to be called from a task by globalcontext_send_message_from_task.

Parameters:

c – the process context.
m – the message to enqueue

void mailbox_reset(Mailbox *mbox)

Reset mailbox receive pointer.

To be called from the process only.

Parameters:

mbox – the mailbox to work with

void mailbox_next(Mailbox *mbox)

Advance pointer to next message in a receive loop.

To be called from the process only.

Parameters:

mbox – the mailbox to work with

static inline bool mailbox_has_next(Mailbox *mbox)

Determine if there is a next item in message list.

To be called from the process only.

Parameters:

mbox – the mailbox to test

Returns:

true if peek would succeed.

bool mailbox_peek(Context *ctx, term *out)

Gets next message from a mailbox (without removing it).

Peek the mailbox and retrieve a term that has been previously queued on a certain process or driver mailbox. To be called from the process only.

Parameters:

ctx – the calling context, owning the mailbox and where the message should be copied to.
out – the allocated term.

Returns:

true if a term was available

MailboxMessage *mailbox_take_message(Mailbox *mbox)

Take next message from mailbox.

Remove the first message from the mailbox and return it. To be called from the process only. This function is intended for some corner cases, such as certain port drivers.

Parameters:

mbox – the mailbox to take the next message from.

Message *mailbox_first(Mailbox *mbox)

Get first message from mailbox.

Get the first message and sets the receive pointer to it so it can be removed later. Used by ports & drivers. To be called from the process only.

Parameters:

mbox – the mailbox to get the current message from.

Returns:

first message or NULL.

void mailbox_destroy(Mailbox *mbox, Heap *heap)

Free memory associated with a mailbox.

All messages in the mailbox will be freed or appended to the heap.

Parameters:

mbox – the mailbox to free.
heap – the heap to add messages to.

MailboxMessage *mailbox_message_create_from_term(enum MessageType type, term t)

Allocate and serialize a term to a mailbox message.

Can be called from a task or even ISR (provided malloc works).

Parameters:

type – the message type, can be NormalMessage or a signal type
t – the term that will be sent

void mailbox_message_dispose(MailboxMessage *m, Heap *heap)

Dispose a (processed) mailbox message. The message will be freed or appended to current heap and will be destroyed on garbage collect. This function is called by mailbox_remove and is only needed for signal messages.

Parameters:

m – the message to free.
heap – heap to append the message to.

Message *mailbox_message_create_normal_message_from_term(term t)

Allocate and serialize a term to a normal message.

Can be called from a task or even ISR (provided malloc works).

Parameters:

t – the term that will be sent

void mailbox_message_dispose_unsent(Message *m, GlobalContext *global, bool from_task)

Dispose an unsent normal message. The message will be freed.

Parameters:

m – the message to dispose.
global – the global context
from_task – boolean, true if called from a task, false otherwise

static inline void mailbox_remove_message(Mailbox *mbox, Heap *heap)

Remove next message from mailbox.

Discard a term that has been previously queued on a certain process or driver mailbox. To be called from the process only. Term messages are actually added as fragments to the heap and will be gone at next GC.

Parameters: