context.h

Include dependency graph for context.h:

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

Context struct and related management functions.

A context represent the state of a running erlang process or port.

Defines

MAX_REG 16

CONTEXT_MONITOR_RESOURCE_TAG 0x2

CONTEXT_MONITOR_MONITORED_PID_TAG 0x3

CONTEXT_MONITOR_MONITORING_PID_TAG 0x1

Typedefs

typedef enum NativeHandlerResult NativeHandlerResult

typedef NativeHandlerResult (*native_handler_f)(Context *ctx)

Enums

enum NativeHandlerResult

Values:

enumerator NativeTerminate = 1

enumerator NativeContinue

enum ContextFlags

Values:

enumerator NoFlags = 0

enumerator WaitingTimeout = 1

enumerator WaitingTimeoutExpired = 2

enumerator Running = 4

enumerator Ready = 8

enumerator Killed = 16

enumerator Trap = 32

enum HeapGrowthStrategy

Values:

enumerator BoundedFreeHeapGrowth = 0

enumerator MinimumHeapGrowth

enumerator FibonacciHeapGrowth

Functions

Context *context_new(GlobalContext *glb)

Creates a new context.

Allocates a new Context struct and initialize it. The newly created context is also inserted into the processes table, however it is not scheduled, allowing for further initialization.

Parameters:

• glb – The global context of this virtual machine instance.

Returns:

created context.

void context_destroy(Context *c)

Destroys a context.

Frees context resources and memory and removes it from the processes table. This should be called from the scheduler only. To actually delete a context that was created with context_new, use scheduler_terminate.

Parameters:

• c – the context that will be destroyed.

static inline void context_ensure_fpregs(Context *c)

Ensure we have FP registers, allocating them if necessary.

Parameters:

• c – context fo allocate FP registers for

int context_execute_loop(Context *ctx, Module *mod, const char *function_name, int arity)

Starts executing a function.

Start executing bytecode for the specified function, this function will block until it terminates. The outcome is saved to x[0] register.

Parameters:

• ctx – the context that will be used to run the specified functions, x registers must be set to function arguments.

• mod – the module name C string.

• function_name – the function name C string.

• arity – the function arity (number of arguments that are required).

Returns:

1 if an error occurred, otherwise 0 is always returned.

static inline int context_is_port_driver(const Context *ctx)

Returns 1 if the context is a port driver.

Checks if the given context has a native_handler or not.

Parameters:

• ctx – a valid context

Returns:

1 if ctx is a port driver, otherwise 0 is returned.

static inline void context_clean_registers(Context *ctx, int live)

Cleans up unused registers.

Sets to NIL unused registers, x[0] - x[live - 1] will not be overwritten.

Parameters:

• ctx – a valid context

• live – number of used registers

static inline term *context_stack_base(const Context *ctx)

Returns a context’s stack base.

Used for stack traces

Parameters:

• ctx – a valid context.

Returns:

the stack base

static inline size_t context_stack_size(const Context *ctx)

Returns a context’s stack size.

Return the number of terms currently on the stack. Used for stack traces.

Parameters:

• ctx – a valid context.

Returns:

stack size in terms

static inline size_t context_avail_free_memory(const Context *ctx)

Returns available free memory in term units.

Returns the number of terms that can fit either on the heap.

Parameters:

• ctx – a valid context.

Returns:

available free memory that is avail_size_in_bytes / sizeof(term).

static inline bool context_is_term_equal_to_atom_string(Context *ctx, term atom_a, AtomString atom_string_b)

Compares a term with an AtomString.

Checks if the given term and the given AtomString refers to the same atom. This function is just a shortcut that uses the corresponding funtion from globalcontext.

Parameters:

• ctx – the current Context.

• atom_a – any term of any type, when it is not an atom false is always returned.

• atom_string_b – an atom string, which is the atom length followed by atom characters.

Returns:

true if they both refer to the same atom, otherwise false.

size_t context_message_queue_len(Context *ctx)

Returns number of messages in the process’s mailbox.

Parameters:

• ctx – a valid context.

Returns:

the number of messages in the process’s mailbox

size_t context_size(Context *ctx)

Returns total amount of size (in byes) occupied by the process.

Parameters:

• ctx – a valid context.

Returns:

total amount of size (in byes) occupied by the process

void context_update_flags(Context *ctx, int mask, int value)

Set or clear a flag on another context.

atomically update flags <- (flags & mask) | value

Parameters:

• ctx – the context to set/clear flag on.

• mask – the mask to apply on flags

• value – the value to set

static inline int context_get_flags(Context *ctx, int mask)

Get flags on a given context.

Parameters:

• ctx – the context to get flags on.

• mask – the mask to apply on flags

void context_process_kill_signal(Context *ctx, struct TermSignal *signal)

Process a kill signal, setting the exit reason and changing the killed flag.

Parameters:

• ctx – the context being executed

• signal – the kill message

void context_process_process_info_request_signal(Context *ctx, struct BuiltInAtomRequestSignal *signal)

Process a process info request signal.

Parameters:

• ctx – the context being executed

• signal – the kill message

bool context_process_signal_trap_answer(Context *ctx, struct TermSignal *signal)

Process a trap answer signal.

Parameters:

• ctx – the context being executed

• signal – the answer message

Returns:

true if successful, false in case of memory error

void context_process_flush_monitor_signal(Context *ctx, uint64_t ref_ticks, bool info)

Process a flush monitor signal.

Parameters:

• ctx – the context being executed

• ref_ticks – the monitor reference

• info – whether to return FALSE_ATOM if no message was flushed.

bool context_get_process_info(Context *ctx, term *out, size_t *term_size, term atom_key, Heap *heap)

Get process information.

Parameters:

• ctx – the context being executed

• out – the answer term. Can be NULL if only the size matters.

• term_size – the size of the answer term, in words.

• atom_key – the key representing the info to get

• heap – the heap to allocate the answer to

Returns:

true if successful, false in case of an error in which case *out is filled with an exception atom if it was not NULL

struct Monitor *monitor_link_new(term monitor_pid)

Half-link process to another process.

Parameters:

• monitor_pid – process to link to

Returns:

the allocated monitor or NULL if allocation failed

struct Monitor *monitor_new(term monitor_pid, uint64_t ref_ticks, bool is_monitoring)

Create a monitor on a process.

Parameters:

• monitor_pid – monitoring process

• ref_ticks – reference of the monitor

• is_monitoring – if ctx is the monitoring process

Returns:

the allocated monitor or NULL if allocation failed

struct Monitor *monitor_resource_monitor_new(void *resource, uint64_t ref_ticks)

Create a resource monitor.

Parameters:

• resource – resource object

• ref_ticks – reference associated with the monitor

• process_id – process being monitored

Returns:

the allocated resource monitor or NULL if allocation failed

void context_unlink(Context *ctx, term monitor_pid)

Half-unlink process to another process.

Called within the process only. For the other end of the link, an UnlinkSignal is sent that calls this function.

Parameters:

• ctx – the context being executed

• monitor_pid – process to unlink from

Returns:

0 on success

void context_demonitor(Context *ctx, uint64_t ref_ticks)

Destroy a monitor on a process.

Called within the process only. This function is called from DemonitorSignal.

Parameters:

• ctx – the context being executed

• ref_ticks – reference of the monitor to remove

Returns:

0 on success

term context_get_monitor_pid(Context *ctx, uint64_t ref_ticks, bool *is_monitoring)

Get target of a monitor.

Parameters:

• ctx – the context being executed

• ref_ticks – reference of the monitor to remove

• is_monitoring – whether ctx is the monitoring process.

Returns:

pid of monitoring process, self() if process is monitoring (and not monitored) or term_invalid() if no monitor could be found.

void context_add_monitor(Context *ctx, struct Monitor *new_monitor)

Add a monitor on a process.

Called within the process only. This function is called from MonitorSignal. Monitor is not added if it already exists. Monitors are identified by a reference, but links have no reference and a link can only exist once.

Parameters:

• ctx – the context being executed

• new_monitor – monitor object to add

struct Context

#include <context.h>

Collaboration diagram for Context:

Public Members

GlobalContext *global

Heap heap

term *e

term x[16 + 1]

struct ListHead extended_x_regs

struct ListHead processes_list_head

struct ListHead processes_table_head

int32_t process_id

struct TimerListItem timer_list_head

struct ListHead monitors_head

avm_float_t *fr

size_t min_heap_size

size_t max_heap_size

enum HeapGrowthStrategy heap_growth_strategy

unsigned long cp

Module *saved_module

const void *saved_ip

void *restore_trap_handler

Mailbox mailbox

struct ListHead dictionary

native_handler_f native_handler

uint64_t reductions

unsigned int leader

unsigned int has_min_heap_size

unsigned int has_max_heap_size

bool trap_exit

unsigned int trace_calls

unsigned int trace_call_args

unsigned int trace_returns

unsigned int trace_send

unsigned int trace_receive

enum ContextFlags flags

void *platform_data

term group_leader

term bs

size_t bs_offset

term exit_reason

struct Monitor

#include <context.h>

Collaboration diagram for Monitor:

A regular monitor or a half link.

Public Members

struct ListHead monitor_list_head

uint64_t ref_ticks

term monitor_obj

struct ExtendedRegister

#include <context.h>

Collaboration diagram for ExtendedRegister:

Public Members

struct ListHead head

unsigned int index

term value