erl_driver

This function will write information about the Erlang runtime system into the ErlDrvSysInfo structure referred to by the first argument. The second argument should be the size of the ErlDrvSysInfo structure, i.e., sizeof(ErlDrvSysInfo).

See the documentation of the ErlDrvSysInfo structure for information about specific fields.

The driver_output function is used to send data from the driver up to the emulator. The data will be received as terms or binary data, depending on how the driver port was opened.

The data is queued in the port owner process' message queue. Note that this does not yield to the emulator. (Since the driver and the emulator run in the same thread.)

The parameter buf points to the data to send, and len is the number of bytes.

The return value for all output functions is 0. (Unless the driver is used for distribution, in which case it can fail and return -1. For normal use, the output function always returns 0.)

The driver_output2 function first sends hbuf (length in hlen) data as a list, regardless of port settings. Then buf is sent as a binary or list. E.g. if hlen is 3 then the port owner process will receive [H1, H2, H3 | T].

The point of sending data as a list header, is to facilitate matching on the data received.

The return value is 0 for normal use.

This function sends data to port owner process from a driver binary, it has a header buffer (hbuf and hlen) just like driver_output2. The hbuf parameter can be NULL.

The parameter offset is an offset into the binary and len is the number of bytes to send.

Driver binaries are created with driver_alloc_binary.

The data in the header is sent as a list and the binary as an Erlang binary in the tail of the list.

E.g. if hlen is 2, then the port owner process will receive [H1, H2 | <<T>>].

The return value is 0 for normal use.

Note that, using the binary syntax in Erlang, the driver application can match the header directly from the binary, so the header can be put in the binary, and hlen can be set to 0.

This function sends data from an IO vector, ev, to the port owner process. It has a header buffer (hbuf and hlen), just like driver_output2.

The skip parameter is a number of bytes to skip of the ev vector from the head.

You get vectors of ErlIOVec type from the driver queue (see below), and the outputv driver entry function. You can also make them yourself, if you want to send several ErlDrvBinary buffers at once. Often it is faster to use driver_output or driver_output_binary.

E.g. if hlen is 2 and ev points to an array of three binaries, the port owner process will receive [H1, H2, <<B1>>, <<B2>> | <<B3>>].

The return value is 0 for normal use.

The comment for driver_output_binary applies for driver_outputv too.

This function collects several segments of data, referenced by ev, by copying them in order to the buffer buf, of the size len.

If the data is to be sent from the driver to the port owner process, it is faster to use driver_outputv.

The return value is the space left in the buffer, i.e. if the ev contains less than len bytes it's the difference, and if ev contains len bytes or more, it's 0. This is faster if there is more than one header byte, since the binary syntax can construct integers directly from the binary.

This function sets a timer on the driver, which will count down and call the driver when it is timed out. The time parameter is the time in milliseconds before the timer expires.

When the timer reaches 0 and expires, the driver entry function timeout is called.

Note that there is only one timer on each driver instance; setting a new timer will replace an older one.

Return value is 0 (-1 only when the timeout driver function is NULL).

This function cancels a timer set with driver_set_timer.

The return value is 0.

This function reads the current time of a timer, and places the result in time_left. This is the time in milliseconds, before the timeout will occur.

The return value is 0.

This function reads a timestamp into the memory pointed to by the parameter now. See the description of ErlDrvNowData for specification of its fields.

The return value is 0 unless the now pointer is not valid, in which case it is < 0.

This function is used by drivers to provide the emulator with events to check for. This enables the emulator to call the driver when something has happened asynchronously.

The event argument identifies an OS-specific event object. On Unix systems, the functions select/poll are used. The event object must be a socket or pipe (or other object that select/poll can use). On windows, the Win32 API function WaitForMultipleObjects is used. This places other restrictions on the event object. Refer to the Win32 SDK documentation. On Enea OSE, the receive function is used. See the for more details.

The mode argument is a bitwise-or combination of ERL_DRV_READ, ERL_DRV_WRITE and ERL_DRV_USE. The first two specify whether to wait for read events and/or write events. A fired read event will call ready_input while a fired write event will call ready_output.

ERL_DRV_USE specifies if we are using the event object or if we want to close it. On an emulator with SMP support, it is not safe to clear all events and then close the event object after driver_select has returned. Another thread may still be using the event object internally. To safely close an event object call driver_select with ERL_DRV_USE and on==0. That will clear all events and then call stop_select when it is safe to close the event object. ERL_DRV_USE should be set together with the first event for an event object. It is harmless to set ERL_DRV_USE even though it already has been done. Clearing all events but keeping ERL_DRV_USE set will indicate that we are using the event object and probably will set events for it again.

The return value is 0 (failure, -1, only if the ready_input/ready_output is NULL).

This function allocates a memory block of the size specified in size, and returns it. This only fails on out of memory, in that case NULL is returned. (This is most often a wrapper for malloc).

Memory allocated must be explicitly freed with a corresponding call to driver_free (unless otherwise stated).

This function is thread-safe.

This function resizes a memory block, either in place, or by allocating a new block, copying the data and freeing the old block. A pointer is returned to the reallocated memory. On failure (out of memory), NULL is returned. (This is most often a wrapper for realloc.)

This function is thread-safe.

This function frees the memory pointed to by ptr. The memory should have been allocated with driver_alloc. All allocated memory should be deallocated, just once. There is no garbage collection in drivers.

This function is thread-safe.

This function allocates a driver binary with a memory block of at least size bytes, and returns a pointer to it, or NULL on failure (out of memory). When a driver binary has been sent to the emulator, it must not be altered. Every allocated binary should be freed by a corresponding call to driver_free_binary (unless otherwise stated).

Note that a driver binary has an internal reference counter, this means that calling driver_free_binary it may not actually dispose of it. If it's sent to the emulator, it may be referenced there.

The driver binary has a field, orig_bytes, which marks the start of the data in the binary.

This function is thread-safe.

This function resizes a driver binary, while keeping the data. The resized driver binary is returned. On failure (out of memory), NULL is returned.

This function is only thread-safe when the emulator with SMP support is used.

This function frees a driver binary bin, allocated previously with driver_alloc_binary. Since binaries in Erlang are reference counted, the binary may still be around.

This function is only thread-safe when the emulator with SMP support is used.

Returns current reference count on bin.

This function is only thread-safe when the emulator with SMP support is used.

Increments the reference count on bin and returns the reference count reached after the increment.

This function is only thread-safe when the emulator with SMP support is used.

Decrements the reference count on bin and returns the reference count reached after the decrement.

This function is only thread-safe when the emulator with SMP support is used.

This function enqueues data in the driver queue. The data in buf is copied (len bytes) and placed at the end of the driver queue. The driver queue is normally used in a FIFO way.

The driver queue is available to queue output from the emulator to the driver (data from the driver to the emulator is queued by the emulator in normal erlang message queues). This can be useful if the driver has to wait for slow devices etc, and wants to yield back to the emulator. The driver queue is implemented as an ErlIOVec.

When the queue contains data, the driver won't close, until the queue is empty.

The return value is 0.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function puts data at the head of the driver queue. The data in buf is copied (len bytes) and placed at the beginning of the queue.

The return value is 0.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function dequeues data by moving the head pointer forward in the driver queue by size bytes. The data in the queue will be deallocated.

The return value is the number of bytes remaining in the queue or -1 on failure.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function returns the number of bytes currently in the driver queue.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function enqueues a driver binary in the driver queue. The data in bin at offset with length len is placed at the end of the queue. This function is most often faster than driver_enq, because the data doesn't have to be copied.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

The return value is 0.

This function puts data in the binary bin, at offset with length len at the head of the driver queue. It is most often faster than driver_pushq, because the data doesn't have to be copied.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

The return value is 0.

This function retrieves the driver queue into a supplied ErlIOVec ev. It also returns the queue size. This is one of two ways to get data out of the queue.

If ev is NULL all ones i.e. -1 type cast to ErlDrvSizeT is returned.

Nothing is removed from the queue by this function, that must be done with driver_deq.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function retrieves the driver queue as a pointer to an array of SysIOVecs. It also returns the number of elements in vlen. This is one of two ways to get data out of the queue.

Nothing is removed from the queue by this function, that must be done with driver_deq.

The returned array is suitable to use with the Unix system call writev.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function enqueues the data in ev, skipping the first skip bytes of it, at the end of the driver queue. It is faster than driver_enq, because the data doesn't have to be copied.

The return value is 0.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function puts the data in ev, skipping the first skip bytes of it, at the head of the driver queue. It is faster than driver_pushq, because the data doesn't have to be copied.

The return value is 0.

This function can be called from an arbitrary thread if a port data lock associated with the port is locked by the calling thread during the call.

This function creates a port data lock associated with the port. NOTE: Once a port data lock has been created, it has to be locked during all operations on the driver queue of the port.

On success a newly created port data lock is returned. On failure NULL is returned. driver_pdl_create() will fail if port is invalid or if a port data lock already has been associated with the port.

This function locks the port data lock passed as argument (pdl).

This function is thread-safe.

This function unlocks the port data lock passed as argument (pdl).

This function is thread-safe.

This function returns the current reference count of the port data lock passed as argument (pdl).

This function is thread-safe.

This function increments the reference count of the port data lock passed as argument (pdl).

The current reference count after the increment has been performed is returned.

This function is thread-safe.

This function decrements the reference count of the port data lock passed as argument (pdl).

The current reference count after the decrement has been performed is returned.

This function is thread-safe.

Start monitoring a process from a driver. When a process is monitored, a process exit will result in a call to the provided process_exit call-back in the ErlDrvEntry structure. The ErlDrvMonitor structure is filled in, for later removal or compare.

The process parameter should be the return value of an earlier call to driver_caller or driver_connected call.

The function returns 0 on success, < 0 if no call-back is provided and > 0 if the process is no longer alive.

This function cancels a monitor created earlier.

The function returns 0 if a monitor was removed and > 0 if the monitor did no longer exist.

The function returns the process id associated with a living monitor. It can be used in the process_exit call-back to get the process identification for the exiting process.

The function returns driver_term_nil if the monitor no longer exists.

This function is used to compare two ErlDrvMonitors. It can also be used to imply some artificial order on monitors, for whatever reason.

The function returns 0 if monitor1 and monitor2 are equal, < 0 if monitor1 is less than monitor2 and > 0 if monitor1 is greater than monitor2.

This function adds a driver entry to the list of drivers known by Erlang. The init function of the de parameter is called.

This function removes a driver entry de previously added with add_driver_entry.

Driver entries added by the erl_ddll erlang interface can not be removed by using this interface.

This function returns the atom name of the erlang error, given the error number in error. Error atoms are: einval, enoent, etc. It can be used to make error terms from the driver.

Sets and gets limits that will be used for controling the busy state of the port message queue.

The port message queue will be set into a busy state when the amount of command data queued on the message queue reaches the high limit. The port message queue will be set into a not busy state when the amount of command data queued on the message queue falls below the low limit. Command data is in this context data passed to the port using either Port ! {Owner, {command, Data}}, or port_command/[2,3]. Note that these limits only concerns command data that have not yet reached the port. The busy port feature can be used for data that has reached the port.

Valid limits are values in the range [ERL_DRV_BUSY_MSGQ_LIM_MIN, ERL_DRV_BUSY_MSGQ_LIM_MAX]. Limits will be automatically adjusted to be sane. That is, the system will adjust values so that the low limit used is lower than or equal to the high limit used. By default the high limit will be 8 kB and the low limit will be 4 kB.

By passing a pointer to an integer variable containing the value ERL_DRV_BUSY_MSGQ_READ_ONLY, currently used limit will be read and written back to the integer variable. A new limit can be set by passing a pointer to an integer variable containing a valid limit. The passed value will be written to the internal limit. The internal limit will then be adjusted. After this the adjusted limit will be written back to the integer variable from which the new value was read. Values are in bytes.

The busy message queue feature can be disabled either by setting the ERL_DRV_FLAG_NO_BUSY_MSGQ driver flag in the driver_entry used by the driver, or by calling this function with ERL_DRV_BUSY_MSGQ_DISABLED as a limit (either low or high). When this feature has been disabled it cannot be enabled again. When reading the limits both of them will be ERL_DRV_BUSY_MSGQ_DISABLED, if this feature has been disabled.

Processes sending command data to the port will be suspended if either the port is busy or if the port message queue is busy. Suspended processes will be resumed when neither the port is busy, nor the port message queue is busy.

For information about busy port functionality see the documentation of the set_busy_port() function.

This function set and unset the busy state of the port. If on is non-zero, the port is set to busy, if it's zero the port is set to not busy. You typically want to combine this feature with the busy port message queue functionality.

Processes sending command data to the port will be suspended if either the port is busy or if the port message queue is busy. Suspended processes will be resumed when neither the port is busy, nor the port message queue is busy. Command data is in this context data passed to the port using either Port ! {Owner, {command, Data}}, or port_command/[2,3].

If the ERL_DRV_FLAG_SOFT_BUSY has been set in the driver_entry, data can be forced into the driver via port_command(Port, Data, [force]) even though the driver has signaled that it is busy.

For information about busy port message queue functionality see the documentation of the erl_drv_busy_msgq_limits() function.

This function sets flags for how the control driver entry function will return data to the port owner process. (The control function is called from port_control/3 in erlang.)

Currently there are only two meaningful values for flags: 0 means that data is returned in a list, and PORT_CONTROL_FLAG_BINARY means data is returned as a binary from control.

This function signals to erlang that the driver has encountered an EOF and should be closed, unless the port was opened with the eof option, in that case eof is sent to the port. Otherwise, the port is closed and an 'EXIT' message is sent to the port owner process.

The return value is 0.

These functions signal to Erlang that the driver has encountered an error and should be closed. The port is closed and the tuple {'EXIT', error, Err}, is sent to the port owner process, where error is an error atom (driver_failure_atom and driver_failure_posix), or an integer (driver_failure).

The driver should fail only when in severe error situations, when the driver cannot possibly keep open, for instance buffer allocation gets out of memory. For normal errors it is more appropriate to send error codes with driver_output.

The return value is 0.

This function returns the port owner process.

Note that this function is not thread-safe, not even when the emulator with SMP support is used.

This function returns the process id of the process that made the current call to the driver. The process id can be used with driver_send_term to send back data to the caller. driver_caller() only returns valid data when currently executing in one of the following driver callbacks:

Note that this function is not thread-safe, not even when the emulator with SMP support is used.

This functions sends data in the special driver term format to the port owner process. This is a fast way to deliver term data from a driver. It also needs no binary conversion, so the port owner process receives data as normal Erlang terms. The erl_drv_send_term() functions can be used for sending to any arbitrary process on the local node.

The term parameter points to an array of ErlDrvTermData, with n elements. This array contains terms described in the driver term format. Every term consists of one to four elements in the array. The term first has a term type, and then arguments. The port parameter specifies the sending port.

Tuples, maps and lists (with the exception of strings, see below), are built in reverse polish notation, so that to build a tuple, the elements are given first, and then the tuple term, with a count. Likewise for lists and maps.

A tuple must be specified with the number of elements. (The elements precede the ERL_DRV_TUPLE term.)

A list must be specified with the number of elements, including the tail, which is the last term preceding ERL_DRV_LIST.

A map must be specified with the number of key-value pairs N. The key-value pairs must precede the ERL_DRV_MAP in this order: key1,value1,key2,value2,...,keyN,valueN. Duplicate keys are not allowed.

The special term ERL_DRV_STRING_CONS is used to "splice" in a string in a list, a string given this way is not a list per se, but the elements are elements of the surrounding list.

Term type            Argument(s)
===========================================
ERL_DRV_NIL
ERL_DRV_ATOM         ErlDrvTermData atom (from driver_mk_atom(char *string))
ERL_DRV_INT          ErlDrvSInt integer
ERL_DRV_UINT         ErlDrvUInt integer
ERL_DRV_INT64        ErlDrvSInt64 *integer_ptr
ERL_DRV_UINT64       ErlDrvUInt64 *integer_ptr
ERL_DRV_PORT         ErlDrvTermData port (from driver_mk_port(ErlDrvPort port))
ERL_DRV_BINARY       ErlDrvBinary *bin, ErlDrvUInt len, ErlDrvUInt offset
ERL_DRV_BUF2BINARY   char *buf, ErlDrvUInt len
ERL_DRV_STRING       char *str, int len
ERL_DRV_TUPLE        int sz
ERL_DRV_LIST         int sz
ERL_DRV_PID          ErlDrvTermData pid (from driver_connected(ErlDrvPort port) or driver_caller(ErlDrvPort port))
ERL_DRV_STRING_CONS  char *str, int len
ERL_DRV_FLOAT        double *dbl
ERL_DRV_EXT2TERM     char *buf, ErlDrvUInt len
ERL_DRV_MAP          int sz
        

The unsigned integer data type ErlDrvUInt and the signed integer data type ErlDrvSInt are 64 bits wide on a 64 bit runtime system and 32 bits wide on a 32 bit runtime system. They were introduced in erts version 5.6, and replaced some of the int arguments in the list above.

The unsigned integer data type ErlDrvUInt64 and the signed integer data type ErlDrvSInt64 are always 64 bits wide. They were introduced in erts version 5.7.4.

To build the tuple {tcp, Port, [100 | Binary]}, the following call could be made.

    ErlDrvBinary* bin = ...
    ErlDrvPort port = ...
    ErlDrvTermData spec[] = {
        ERL_DRV_ATOM, driver_mk_atom("tcp"),
        ERL_DRV_PORT, driver_mk_port(drvport),
            ERL_DRV_INT, 100,
            ERL_DRV_BINARY, bin, 50, 0,
            ERL_DRV_LIST, 2,
        ERL_DRV_TUPLE, 3,
    };
    erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));
        
      

Where bin is a driver binary of length at least 50 and drvport is a port handle. Note that the ERL_DRV_LIST comes after the elements of the list, likewise the ERL_DRV_TUPLE.

The term ERL_DRV_STRING_CONS is a way to construct strings. It works differently from how ERL_DRV_STRING works. ERL_DRV_STRING_CONS builds a string list in reverse order, (as opposed to how ERL_DRV_LIST works), concatenating the strings added to a list. The tail must be given before ERL_DRV_STRING_CONS.

The ERL_DRV_STRING constructs a string, and ends it. (So it's the same as ERL_DRV_NIL followed by ERL_DRV_STRING_CONS.)

    /* to send [x, "abc", y] to the port: */
    ErlDrvTermData spec[] = {
        ERL_DRV_ATOM, driver_mk_atom("x"),
        ERL_DRV_STRING, (ErlDrvTermData)"abc", 3,
        ERL_DRV_ATOM, driver_mk_atom("y"),
        ERL_DRV_NIL,
        ERL_DRV_LIST, 4
    };
    erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));
        

    /* to send "abc123" to the port: */
    ErlDrvTermData spec[] = {
        ERL_DRV_NIL,        /* with STRING_CONS, the tail comes first */
        ERL_DRV_STRING_CONS, (ErlDrvTermData)"123", 3,
        ERL_DRV_STRING_CONS, (ErlDrvTermData)"abc", 3,
    };
    erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));
        

The ERL_DRV_EXT2TERM term type is used for passing a term encoded with the external format, i.e., a term that has been encoded by erlang:term_to_binary, erl_interface, etc. For example, if binp is a pointer to an ErlDrvBinary that contains the term {17, 4711} encoded with the external format and you want to wrap it in a two tuple with the tag my_tag, i.e., {my_tag, {17, 4711}}, you can do as follows:

    ErlDrvTermData spec[] = {
            ERL_DRV_ATOM, driver_mk_atom("my_tag"),
            ERL_DRV_EXT2TERM, (ErlDrvTermData) binp->orig_bytes, binp->orig_size
        ERL_DRV_TUPLE, 2,
    };
    erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));
        

To build the map #{key1 => 100, key2 => {200, 300}}, the following call could be made.

    ErlDrvPort port = ...
    ErlDrvTermData spec[] = {
          ERL_DRV_ATOM, driver_mk_atom("key1"),
	  ERL_DRV_INT, 100,
          ERL_DRV_ATOM, driver_mk_atom("key2"),
	    ERL_DRV_INT, 200,
	    ERL_DRV_INT, 300,
	  ERL_DRV_TUPLE, 2,
	ERL_DRV_MAP, 2
    };
    erl_drv_output_term(driver_mk_port(drvport), spec, sizeof(spec) / sizeof(spec[0]));
        
      

If you want to pass a binary and don't already have the content of the binary in an ErlDrvBinary, you can benefit from using ERL_DRV_BUF2BINARY instead of creating an ErlDrvBinary via driver_alloc_binary() and then pass the binary via ERL_DRV_BINARY. The runtime system will often allocate binaries smarter if ERL_DRV_BUF2BINARY is used. However, if the content of the binary to pass already resides in an ErlDrvBinary, it is normally better to pass the binary using ERL_DRV_BINARY and the ErlDrvBinary in question.

The ERL_DRV_UINT, ERL_DRV_BUF2BINARY, and ERL_DRV_EXT2TERM term types were introduced in the 5.6 version of erts.

This function is only thread-safe when the emulator with SMP support is used.

The parameters term and n do the same thing as in erl_drv_output_term().

Note that this function is not thread-safe, not even when the emulator with SMP support is used.

This function returns an atom given a name string. The atom is created and won't change, so the return value may be saved and reused, which is faster than looking up the atom several times.

Note that this function is not thread-safe, not even when the emulator with SMP support is used.

This function converts a port handle to the erlang term format, usable in the erl_drv_output_term(), and erl_drv_send_term() functions.

Note that this function is not thread-safe, not even when the emulator with SMP support is used.

This function is the only way for a driver to send data to other processes than the port owner process. The receiver parameter specifies the process to receive the data.

The parameters port, term and n do the same thing as in erl_drv_output_term().

This function is only thread-safe when the emulator with SMP support is used.

The parameters term and n do the same thing as in erl_drv_output_term().

This function is only thread-safe when the emulator with SMP support is used.

This function performs an asynchronous call. The function async_invoke is invoked in a thread separate from the emulator thread. This enables the driver to perform time-consuming, blocking operations without blocking the emulator.

The async thread pool size can be set with the +A command line argument of erl(1). If no async thread pool is available, the call is made synchronously in the thread calling driver_async(). The current number of async threads in the async thread pool can be retrieved via driver_system_info().

If there is a thread pool available, a thread will be used. If the key argument is null, the threads from the pool are used in a round-robin way, each call to driver_async uses the next thread in the pool. With the key argument set, this behaviour is changed. The two same values of *key always get the same thread.

To make sure that a driver instance always uses the same thread, the following call can be used:

    unsigned int myKey = driver_async_port_key(myPort);

    r = driver_async(myPort, &myKey, myData, myFunc);
        

It is enough to initialize myKey once for each driver instance.

If a thread is already working, the calls will be queued up and executed in order. Using the same thread for each driver instance ensures that the calls will be made in sequence.

The async_data is the argument to the functions async_invoke and async_free. It's typically a pointer to a structure that contains a pipe or event that can be used to signal that the async operation completed. The data should be freed in async_free.

When the async operation is done, ready_async driver entry function is called. If ready_async is null in the driver entry, the async_free function is called instead.

The return value is -1 if the driver_async call fails.

This function calculates a key for later use in driver_async(). The keys are evenly distributed so that a fair mapping between port id's and async thread id's is achieved.

This function locks the driver used by the port port in memory for the rest of the emulator process' lifetime. After this call, the driver behaves as one of Erlang's statically linked in drivers.

This function creates a new port executing the same driver code as the port creating the new port. A short description of the arguments:

The caller of driver_create_port() is allowed to manipulate the newly created port when driver_create_port() has returned. When port level locking is used, the creating port is, however, only allowed to manipulate the newly created port until the current driver call-back that was called by the emulator returns.

Arguments:

This function creates a new thread. On success 0 is returned; otherwise, an errno value is returned to indicate the error. The newly created thread will begin executing in the function pointed to by func, and func will be passed arg as argument. When erl_drv_thread_create() returns the thread identifier of the newly created thread will be available in *tid. opts can be either a NULL pointer, or a pointer to an ErlDrvThreadOpts structure. If opts is a NULL pointer, default options will be used; otherwise, the passed options will be used.

The created thread will terminate either when func returns or if erl_drv_thread_exit() is called by the thread. The exit value of the thread is either returned from func or passed as argument to erl_drv_thread_exit(). The driver creating the thread has the responsibility of joining the thread, via erl_drv_thread_join(), before the driver is unloaded. It is not possible to create "detached" threads, i.e., threads that don't need to be joined.

This function is thread-safe.

Arguments:

This function allocates and initialize a thread option structure. On failure NULL is returned. A thread option structure is used for passing options to erl_drv_thread_create(). If the structure isn't modified before it is passed to erl_drv_thread_create(), the default values will be used.

This function is thread-safe.

Arguments:

This function destroys thread options previously created by erl_drv_thread_opts_create().

This function is thread-safe.

Arguments:

This function terminates the calling thread with the exit value passed as argument. You are only allowed to terminate threads created with erl_drv_thread_create(). The exit value can later be retrieved by another thread via erl_drv_thread_join().

This function is thread-safe.

Arguments:

This function joins the calling thread with another thread, i.e., the calling thread is blocked until the thread identified by tid has terminated. On success 0 is returned; otherwise, an errno value is returned to indicate the error. A thread can only be joined once. The behavior of joining more than once is undefined, an emulator crash is likely. If exit_value == NULL, the exit value of the terminated thread will be ignored; otherwise, the exit value of the terminated thread will be stored at *exit_value.

This function is thread-safe.

This function returns the thread identifier of the calling thread.

This function is thread-safe.

Arguments:

This function compares two thread identifiers for equality, and returns 0 it they aren't equal, and a value not equal to 0 if they are equal.

This function is thread-safe.

Arguments:

This function creates a mutex and returns a pointer to it. On failure NULL is returned. The driver creating the mutex has the responsibility of destroying it before the driver is unloaded.

This function is thread-safe.

Arguments:

This function destroys a mutex previously created by erl_drv_mutex_create(). The mutex has to be in an unlocked state before being destroyed.

This function is thread-safe.

Arguments:

This function locks a mutex. The calling thread will be blocked until the mutex has been locked. A thread which currently has locked the mutex may not lock the same mutex again.

This function is thread-safe.

Arguments:

This function tries to lock a mutex. If successful 0, is returned; otherwise, EBUSY is returned. A thread which currently has locked the mutex may not try to lock the same mutex again.

This function is thread-safe.

Arguments:

This function unlocks a mutex. The mutex currently has to be locked by the calling thread.

This function is thread-safe.

Arguments:

This function creates a condition variable and returns a pointer to it. On failure NULL is returned. The driver creating the condition variable has the responsibility of destroying it before the driver is unloaded.

This function is thread-safe.

Arguments:

This function destroys a condition variable previously created by erl_drv_cond_create().

This function is thread-safe.

Arguments:

This function signals on a condition variable. That is, if other threads are waiting on the condition variable being signaled, one of them will be woken.

This function is thread-safe.

Arguments:

This function broadcasts on a condition variable. That is, if other threads are waiting on the condition variable being broadcast on, all of them will be woken.

This function is thread-safe.

Arguments: