aboutsummaryrefslogtreecommitdiffstats
path: root/erts/emulator/beam/io.c
diff options
context:
space:
mode:
authorErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
committerErlang/OTP <[email protected]>2009-11-20 14:54:40 +0000
commit84adefa331c4159d432d22840663c38f155cd4c1 (patch)
treebff9a9c66adda4df2106dfd0e5c053ab182a12bd /erts/emulator/beam/io.c
downloadotp-84adefa331c4159d432d22840663c38f155cd4c1.tar.gz
otp-84adefa331c4159d432d22840663c38f155cd4c1.tar.bz2
otp-84adefa331c4159d432d22840663c38f155cd4c1.zip
The R13B03 release.OTP_R13B03
Diffstat (limited to 'erts/emulator/beam/io.c')
-rw-r--r--erts/emulator/beam/io.c4732
1 files changed, 4732 insertions, 0 deletions
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
new file mode 100644
index 0000000000..61985271e6
--- /dev/null
+++ b/erts/emulator/beam/io.c
@@ -0,0 +1,4732 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2009. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+/*
+ * I/O routines for manipulating ports.
+ */
+
+#define ERL_IO_C__
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "sys.h"
+
+/* must be included BEFORE global.h (since it includes erl_driver.h) */
+#include "erl_sys_driver.h"
+
+#include "erl_vm.h"
+#include "global.h"
+#include "erl_process.h"
+#include "dist.h"
+#include "big.h"
+#include "erl_binary.h"
+#include "erl_bits.h"
+#include "erl_version.h"
+#include "error.h"
+
+extern ErlDrvEntry fd_driver_entry;
+extern ErlDrvEntry vanilla_driver_entry;
+extern ErlDrvEntry spawn_driver_entry;
+extern ErlDrvEntry *driver_tab[]; /* table of static drivers, only used during initialization */
+
+erts_driver_t *driver_list; /* List of all drivers, static and dynamic. */
+erts_smp_mtx_t erts_driver_list_lock; /* Mutex for driver list */
+static erts_smp_tsd_key_t driver_list_lock_status_key; /*stop recursive locks when calling
+ driver init */
+static erts_smp_tsd_key_t driver_list_last_error_key; /* Save last DDLL error on a
+ per thread basis (for BC interfaces) */
+
+Port* erts_port; /* The port table */
+erts_smp_atomic_t erts_ports_alive;
+erts_smp_atomic_t erts_bytes_out; /* No bytes sent out of the system */
+erts_smp_atomic_t erts_bytes_in; /* No bytes gotten into the system */
+
+Uint erts_max_ports;
+Uint erts_port_tab_index_mask;
+
+const ErlDrvTermData driver_term_nil = (ErlDrvTermData)NIL;
+
+erts_driver_t vanilla_driver;
+erts_driver_t spawn_driver;
+erts_driver_t fd_driver;
+
+static int init_driver(erts_driver_t *, ErlDrvEntry *, DE_Handle *);
+static void terminate_port(Port *p);
+static void pdl_init(void);
+
+static ERTS_INLINE ErlIOQueue*
+drvport2ioq(ErlDrvPort drvport)
+{
+ int ix = (int) drvport;
+ if (ix < 0 || erts_max_ports <= ix)
+ return NULL;
+ if (erts_port[ix].status & ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP)
+ return NULL;
+ ERTS_LC_ASSERT(!erts_port[ix].port_data_lock
+ || erts_lc_mtx_is_locked(&erts_port[ix].port_data_lock->mtx));
+ ERTS_SMP_LC_ASSERT(erts_port[ix].port_data_lock
+ || erts_lc_is_port_locked(&erts_port[ix]));
+ return &erts_port[ix].ioq;
+}
+
+static ERTS_INLINE int
+is_port_ioq_empty(Port *pp)
+{
+ int res;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
+ if (!pp->port_data_lock)
+ res = (pp->ioq.size == 0);
+ else {
+ ErlDrvPDL pdl = pp->port_data_lock;
+ erts_mtx_lock(&pdl->mtx);
+ res = (pp->ioq.size == 0);
+ erts_mtx_unlock(&pdl->mtx);
+ }
+ return res;
+}
+
+int
+erts_is_port_ioq_empty(Port *pp)
+{
+ return is_port_ioq_empty(pp);
+}
+
+Uint
+erts_port_ioq_size(Port *pp)
+{
+ int res;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
+ if (!pp->port_data_lock)
+ res = pp->ioq.size;
+ else {
+ ErlDrvPDL pdl = pp->port_data_lock;
+ erts_mtx_lock(&pdl->mtx);
+ res = pp->ioq.size;
+ erts_mtx_unlock(&pdl->mtx);
+ }
+ return (Uint) res;
+}
+
+/*
+ * Line buffered I/O.
+ */
+typedef struct line_buf_context {
+ LineBuf **b;
+ char *buf;
+ int left;
+ int retlen;
+} LineBufContext;
+
+#define LINEBUF_EMPTY 0
+#define LINEBUF_EOL 1
+#define LINEBUF_NOEOL 2
+#define LINEBUF_ERROR -1
+
+#define LINEBUF_STATE(LBC) ((*(LBC).b)->data[0])
+
+#define LINEBUF_DATA(LBC) (((*(LBC).b)->data) + 1)
+#define LINEBUF_DATALEN(LBC) ((LBC).retlen)
+
+#define LINEBUF_INITIAL 100
+
+
+/* The 'number' field in a port now has two parts: the lowest bits
+ contain the index in the port table, and the higher bits are a counter
+ which is incremented each time we look for a free port and start from
+ the beginning of the table. erts_max_ports is the number of file descriptors,
+ rounded up to a power of 2.
+ To get the index from a port, use the macro 'internal_port_index';
+ 'port_number' returns the whole number field.
+*/
+
+static erts_smp_spinlock_t get_free_port_lck;
+static Uint last_port_num;
+static Uint port_num_mask;
+erts_smp_atomic_t erts_ports_snapshot; /* Identifies the _next_ snapshot (not the ongoing) */
+
+
+static ERTS_INLINE void
+kill_port(Port *pp)
+{
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(pp));
+ erts_port_task_free_port(pp);
+ ASSERT(pp->status & ERTS_PORT_SFLGS_DEAD);
+}
+
+#ifdef ERTS_SMP
+
+#ifdef ERTS_ENABLE_LOCK_CHECK
+int
+erts_lc_is_port_locked(Port *prt)
+{
+ if (!prt)
+ return 0;
+ return erts_smp_lc_mtx_is_locked(prt->lock);
+}
+#endif
+
+#endif /* #ifdef ERTS_SMP */
+
+static int
+get_free_port(void)
+{
+ Uint num;
+ Uint tries = erts_max_ports;
+ Port* port;
+
+ erts_smp_spin_lock(&get_free_port_lck);
+ num = last_port_num + 1;
+ for (;; ++num) {
+ port = &erts_port[num & erts_port_tab_index_mask];
+
+ erts_smp_port_state_lock(port);
+ if (port->status & ERTS_PORT_SFLG_FREE) {
+ last_port_num = num;
+ erts_smp_spin_unlock(&get_free_port_lck);
+ break;
+ }
+ erts_smp_port_state_unlock(port);
+
+ if (--tries == 0) {
+ erts_smp_spin_unlock(&get_free_port_lck);
+ return -1;
+ }
+ }
+ port->status = ERTS_PORT_SFLG_INITIALIZING;
+#ifdef ERTS_SMP
+ ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&port->refc) == 0);
+ erts_smp_atomic_set(&port->refc, 2); /* Port alive + lock */
+#endif
+ erts_smp_port_state_unlock(port);
+ return num & port_num_mask;
+}
+
+/*
+ * erts_test_next_port() is only used for testing.
+ */
+Sint
+erts_test_next_port(int set, Uint next)
+{
+ Uint i, num;
+ Sint res = -1;
+
+ erts_smp_spin_lock(&get_free_port_lck);
+ if (set) {
+ last_port_num = (next - 1) & port_num_mask;
+ }
+ num = last_port_num + 1;
+
+ for (i=0; i < erts_max_ports && res<0; ++i, ++num) {
+
+ Port* port = &erts_port[num & erts_port_tab_index_mask];
+
+ erts_smp_port_state_lock(port);
+
+ if (port->status & ERTS_PORT_SFLG_FREE) {
+ last_port_num = num - 1;
+ res = num & port_num_mask;
+ }
+ erts_smp_port_state_unlock(port);
+ }
+ erts_smp_spin_unlock(&get_free_port_lck);
+ return res;
+}
+
+void
+erts_port_cleanup(Port *prt)
+{
+#ifdef ERTS_SMP
+ Uint32 port_specific;
+ erts_smp_mtx_t *mtx;
+#endif
+ erts_driver_t *driver;
+
+ erts_smp_port_state_lock(prt);
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ driver = prt->drv_ptr;
+ prt->drv_ptr = NULL;
+ ASSERT(driver);
+
+#ifdef ERTS_SMP
+
+ ASSERT(prt->status & ERTS_PORT_SFLG_FREE_SCHEDULED);
+ ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&prt->refc) == 0);
+
+ port_specific = (prt->status & ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK);
+
+ mtx = prt->lock;
+ ASSERT(mtx);
+
+ prt->lock = NULL;
+
+ ASSERT(prt->status & ERTS_PORT_SFLG_PORT_DEBUG);
+ ASSERT(!(prt->status & ERTS_PORT_SFLG_FREE));
+ prt->status = ERTS_PORT_SFLG_FREE;
+
+ erts_smp_port_state_unlock(prt);
+ erts_smp_mtx_unlock(mtx);
+
+ if (port_specific) {
+ erts_smp_mtx_destroy(mtx);
+ erts_free(ERTS_ALC_T_PORT_LOCK, mtx);
+ }
+#endif
+
+ if (driver->handle)
+ erts_ddll_dereference_driver(driver->handle);
+}
+
+
+/*
+** Initialize v_start to point to the small fixed vector.
+** Once (reallocated) we never reset the pointer to the small vector
+** This is a possible optimisation.
+*/
+static void initq(Port* prt)
+{
+ ErlIOQueue* q = &prt->ioq;
+
+ ERTS_LC_ASSERT(!prt->port_data_lock);
+
+ q->size = 0;
+ q->v_head = q->v_tail = q->v_start = q->v_small;
+ q->v_end = q->v_small + SMALL_IO_QUEUE;
+ q->b_head = q->b_tail = q->b_start = q->b_small;
+ q->b_end = q->b_small + SMALL_IO_QUEUE;
+}
+
+static void stopq(Port* prt)
+{
+ ErlIOQueue* q;
+ ErlDrvBinary** binp;
+
+ if (prt->port_data_lock)
+ driver_pdl_lock(prt->port_data_lock);
+
+ q = &prt->ioq;
+ binp = q->b_head;
+
+ if (q->v_start != q->v_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->v_start);
+
+ while(binp < q->b_tail) {
+ if (*binp != NULL)
+ driver_free_binary(*binp);
+ binp++;
+ }
+ if (q->b_start != q->b_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->b_start);
+ q->v_start = q->v_end = q->v_head = q->v_tail = NULL;
+ q->b_start = q->b_end = q->b_head = q->b_tail = NULL;
+ q->size = 0;
+
+ if (prt->port_data_lock) {
+ driver_pdl_unlock(prt->port_data_lock);
+ driver_pdl_dec_refc(prt->port_data_lock);
+ prt->port_data_lock = NULL;
+ }
+}
+
+
+
+static void
+setup_port(Port* prt, Eterm pid, erts_driver_t *driver,
+ ErlDrvData drv_data, char *name, Uint32 xstatus)
+{
+ ErtsRunQueue *runq = erts_get_runq_current(NULL);
+ char *new_name, *old_name;
+#ifdef DEBUG
+ /* Make sure the debug flags survives until port is freed */
+ xstatus |= ERTS_PORT_SFLG_PORT_DEBUG;
+#endif
+ ASSERT(runq);
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+
+ new_name = (char*) erts_alloc(ERTS_ALC_T_PORT_NAME, sys_strlen(name)+1);
+ sys_strcpy(new_name, name);
+ erts_smp_runq_lock(runq);
+ erts_smp_atomic_inc(&erts_ports_alive);
+ erts_smp_port_state_lock(prt);
+ prt->status = ERTS_PORT_SFLG_CONNECTED | xstatus;
+ prt->snapshot = (Uint32) erts_smp_atomic_read(&erts_ports_snapshot);
+ old_name = prt->name;
+ prt->name = new_name;
+#ifdef ERTS_SMP
+ erts_smp_atomic_set(&prt->run_queue, (long) runq);
+#endif
+ ASSERT(!prt->drv_ptr);
+ prt->drv_ptr = driver;
+ erts_smp_port_state_unlock(prt);
+ erts_smp_runq_unlock(runq);
+#ifdef ERTS_SMP
+ ASSERT(!prt->xports);
+#endif
+ if (old_name) {
+ erts_free(ERTS_ALC_T_PORT_NAME, (void *) old_name);
+ }
+
+ prt->control_flags = 0;
+ prt->connected = pid;
+ prt->drv_data = (long) drv_data;
+ prt->bytes_in = 0;
+ prt->bytes_out = 0;
+ prt->dist_entry = NULL;
+ prt->reg = NULL;
+#ifdef ERTS_SMP
+ prt->ptimer = NULL;
+#else
+ sys_memset(&prt->tm, 0, sizeof(ErlTimer));
+#endif
+ erts_port_task_handle_init(&prt->timeout_task);
+ prt->suspended = NULL;
+ sys_strcpy(prt->name, name);
+ prt->nlinks = NULL;
+ prt->monitors = NULL;
+ prt->linebuf = NULL;
+ prt->bp = NULL;
+ prt->data = am_undefined;
+ /* Set default tracing */
+ erts_get_default_tracing(&(prt->trace_flags), &(prt->tracer_proc));
+
+ prt->psd = NULL;
+
+ initq(prt);
+}
+
+void
+erts_wake_process_later(Port *prt, Process *process)
+{
+ ErtsProcList** p;
+ ErtsProcList* new_p;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if (prt->status & ERTS_PORT_SFLGS_DEAD)
+ return;
+
+ for (p = &(prt->suspended); *p != NULL; p = &((*p)->next))
+ /* Empty loop body */;
+
+ new_p = erts_proclist_create(process);
+ new_p->next = NULL;
+ *p = new_p;
+}
+
+/*
+ Opens a driver.
+ Returns the non-negative port number, if successful.
+ If there is an error, -1 or -2 or -3 is returned. -2 means that
+ there is valid error information in *error_number_ptr.
+ Returning -3 means that an error in the given options was detected
+ (*error_number_ptr must contain either BADARG or SYSTEM_LIMIT).
+ The driver start function must obey the same conventions.
+*/
+int
+erts_open_driver(erts_driver_t* driver, /* Pointer to driver. */
+ Eterm pid, /* Current process. */
+ char* name, /* Driver name. */
+ SysDriverOpts* opts, /* Options. */
+ int *error_number_ptr) /* errno in case -2 is returned */
+{
+ int port_num;
+ int port_ix;
+ ErlDrvData drv_data = 0;
+ Uint32 xstatus = 0;
+ Port *port;
+ int fpe_was_unmasked;
+
+ if (error_number_ptr)
+ *error_number_ptr = 0;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if ((port_num = get_free_port()) < 0) {
+ if (error_number_ptr) {
+ *error_number_ptr = SYSTEM_LIMIT;
+ }
+ return -3;
+ }
+
+ port_ix = port_num & erts_port_tab_index_mask;
+ port = &erts_port[port_ix];
+ port->id = make_internal_port(port_num);
+
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ if (!driver) {
+ for (driver = driver_list; driver; driver = driver->next) {
+ if (sys_strcmp(driver->name, name) == 0)
+ break;
+ }
+ if (!driver) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ if (error_number_ptr)
+ *error_number_ptr = BADARG;
+ return -3;
+ }
+ }
+ if (driver == &spawn_driver) {
+ char *p;
+ erts_driver_t *d;
+
+ /*
+ * Dig out the name of the driver or port program.
+ */
+
+ if (!(opts->spawn_type & ERTS_SPAWN_EXECUTABLE)) {
+ /* No spawn driver default */
+ driver = NULL;
+ }
+
+
+ if (opts->spawn_type != ERTS_SPAWN_EXECUTABLE) {
+ p = name;
+ while(*p != '\0' && *p != ' ')
+ p++;
+ if (*p == '\0')
+ p = NULL;
+ else
+ *p = '\0';
+
+ /*
+ * Search for a driver having this name. Defaults to spawn_driver
+ * if not found.
+ */
+
+ for (d = driver_list; d; d = d->next) {
+ if (strcmp(d->name, name) == 0 &&
+ erts_ddll_driver_ok(d->handle)) {
+ driver = d;
+ break;
+ }
+ }
+ if (p != NULL)
+ *p = ' ';
+ }
+ }
+
+ if (driver == NULL || (driver != &spawn_driver && opts->exit_status)) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ if (error_number_ptr) {
+ *error_number_ptr = BADARG;
+ }
+ /* Need to mark the port as free again */
+ erts_smp_port_state_lock(port);
+ port->status = ERTS_PORT_SFLG_FREE;
+#ifdef ERTS_SMP
+ ERTS_SMP_LC_ASSERT(erts_smp_atomic_read(&port->refc) == 2);
+ erts_smp_atomic_set(&port->refc, 0);
+#endif
+ erts_smp_port_state_unlock(port);
+ return -3;
+ }
+
+ /*
+ * We'll set up the port before calling the start function,
+ * to allow message sending and setting timers in the start function.
+ */
+
+#ifdef ERTS_SMP
+ ASSERT(!port->lock);
+ port->lock = driver->lock;
+ if (!port->lock) {
+ port->lock = erts_alloc(ERTS_ALC_T_PORT_LOCK,
+ sizeof(erts_smp_mtx_t));
+ erts_smp_mtx_init_x(port->lock,
+ "port_lock",
+ port->id);
+ xstatus |= ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK;
+ }
+#endif
+
+ if (driver->handle != NULL) {
+ erts_ddll_increment_port_count(driver->handle);
+ erts_ddll_reference_driver(driver->handle);
+ }
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+
+#ifdef ERTS_SMP
+ erts_smp_mtx_lock(port->lock);
+#endif
+
+ setup_port(port, pid, driver, drv_data, name, xstatus);
+
+ if (IS_TRACED_FL(port, F_TRACE_PORTS)) {
+ trace_port_open(port,
+ pid,
+ am_atom_put(port->name, strlen(port->name)));
+ }
+
+ if (driver->start) {
+ if (IS_TRACED_FL(port, F_TRACE_SCHED_PORTS)) {
+ trace_sched_ports_where(port, am_in, am_start);
+ }
+ port->caller = pid;
+ fpe_was_unmasked = erts_block_fpe();
+ drv_data = (*driver->start)((ErlDrvPort)(port_ix),
+ name, opts);
+ erts_unblock_fpe(fpe_was_unmasked);
+ port->caller = NIL;
+ erts_unblock_fpe(fpe_was_unmasked);
+ if (IS_TRACED_FL(port, F_TRACE_SCHED_PORTS)) {
+ trace_sched_ports_where(port, am_out, am_start);
+ }
+ if (error_number_ptr && ((long) drv_data) == (long) -2)
+ *error_number_ptr = errno;
+#ifdef ERTS_SMP
+ if (port->xports)
+ erts_smp_xports_unlock(port);
+ ASSERT(!port->xports);
+#endif
+ }
+
+ if (((long)drv_data) == -1 ||
+ ((long)drv_data) == -2 ||
+ ((long)drv_data) == -3) {
+ int res = (int) ((long) drv_data);
+
+ if (res == -3 && error_number_ptr) {
+ *error_number_ptr = BADARG;
+ }
+
+ /*
+ * Must clean up the port.
+ */
+#ifdef ERTS_SMP
+ erts_cancel_smp_ptimer(port->ptimer);
+#else
+ erl_cancel_timer(&(port->tm));
+#endif
+ stopq(port);
+ kill_port(port);
+ if (port->linebuf != NULL) {
+ erts_free(ERTS_ALC_T_LINEBUF,
+ (void *) port->linebuf);
+ port->linebuf = NULL;
+ }
+ if (driver->handle != NULL) {
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ erts_ddll_decrement_port_count(driver->handle);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ erts_port_release(port);
+ return res;
+ }
+ port->drv_data = (long) drv_data;
+ return port_ix;
+}
+
+#ifdef ERTS_SMP
+
+struct ErtsXPortsList_ {
+ ErtsXPortsList *next;
+ Port *port;
+};
+
+ERTS_SCHED_PREF_QUICK_ALLOC_IMPL(xports_list, ErtsXPortsList, 50, ERTS_ALC_T_XPORTS_LIST)
+
+#endif
+
+/*
+ * Driver function to create new instances of a driver
+ * Historical reason: to be used with inet_drv for creating
+ * accept sockets inorder to avoid a global table.
+ */
+ErlDrvPort
+driver_create_port(ErlDrvPort creator_port_ix, /* Creating port */
+ ErlDrvTermData pid, /* Owner/Caller */
+ char* name, /* Driver name */
+ ErlDrvData drv_data) /* Driver data */
+{
+ Port *creator_port;
+ Port* port;
+ erts_driver_t *driver;
+ Process *rp;
+ int port_num;
+ Eterm port_id;
+ Uint32 xstatus = 0;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ creator_port = erts_drvport2port(creator_port_ix);
+ if (!creator_port)
+ return (ErlDrvTermData) -1;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(creator_port));
+
+ driver = creator_port->drv_ptr;
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ if (!erts_ddll_driver_ok(driver->handle)) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ return (ErlDrvTermData) -1;
+ }
+
+ rp = erts_pid2proc(NULL, 0, pid, ERTS_PROC_LOCK_LINK);
+ if (!rp) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ return (ErlDrvTermData) -1; /* pid does not exist */
+ }
+ if ((port_num = get_free_port()) < 0) {
+ errno = ENFILE;
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ return (ErlDrvTermData) -1;
+ }
+
+ port_id = make_internal_port(port_num);
+ port = &erts_port[port_num & erts_port_tab_index_mask];
+
+#ifdef ERTS_SMP
+ ASSERT(!port->lock);
+ port->lock = driver->lock;
+ if (!port->lock) {
+ ErtsXPortsList *xplp = xports_list_alloc();
+ xplp->port = port;
+ xplp->next = creator_port->xports;
+ creator_port->xports = xplp;
+ port->lock = erts_alloc(ERTS_ALC_T_PORT_LOCK,
+ sizeof(erts_smp_mtx_t));
+ erts_smp_mtx_init_locked_x(port->lock, "port_lock", port_id);
+ xstatus |= ERTS_PORT_SFLG_PORT_SPECIFIC_LOCK;
+ }
+
+#endif
+
+ if (driver->handle != NULL) {
+ erts_ddll_increment_port_count(driver->handle);
+ erts_ddll_reference_referenced_driver(driver->handle);
+ }
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(port));
+
+ setup_port(port, pid, driver, drv_data, name, xstatus);
+ port->id = port_id;
+
+ erts_add_link(&(port->nlinks), LINK_PID, pid);
+ erts_add_link(&(rp->nlinks), LINK_PID, port_id);
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+ return port_num & erts_port_tab_index_mask;
+}
+
+#ifdef ERTS_SMP
+void
+erts_smp_xports_unlock(Port *prt)
+{
+ ErtsXPortsList *xplp;
+
+ ASSERT(prt);
+ xplp = prt->xports;
+ ASSERT(xplp);
+ while (xplp) {
+ ErtsXPortsList *free_xplp;
+ if (xplp->port->xports)
+ erts_smp_xports_unlock(xplp->port);
+ erts_port_release(xplp->port);
+ free_xplp = xplp;
+ xplp = xplp->next;
+ xports_list_free(free_xplp);
+ }
+ prt->xports = NULL;
+}
+#endif
+
+/* Fills a possibly deep list of chars and binaries into vec
+** Small characters are first stored in the buffer buf of length ln
+** binaries found are copied and linked into msoh
+** Return vector length on succsess,
+** -1 on overflow
+** -2 on type error
+*/
+
+#define SET_VEC(iov, bv, bin, ptr, len, vlen) do { \
+ (iov)->iov_base = (ptr); \
+ (iov)->iov_len = (len); \
+ *(bv)++ = (bin); \
+ (iov)++; \
+ (vlen)++; \
+} while(0)
+
+static int
+io_list_to_vec(Eterm obj, /* io-list */
+ SysIOVec* iov, /* io vector */
+ ErlDrvBinary** binv, /* binary reference vector */
+ ErlDrvBinary* cbin, /* binary to store characters */
+ int bin_limit) /* small binaries limit */
+{
+ DECLARE_ESTACK(s);
+ Eterm* objp;
+ char *buf = cbin->orig_bytes;
+ int len = cbin->orig_size;
+ int csize = 0;
+ int vlen = 0;
+ char* cptr = buf;
+
+ goto L_jump_start; /* avoid push */
+
+ while (!ESTACK_ISEMPTY(s)) {
+ obj = ESTACK_POP(s);
+ L_jump_start:
+ if (is_list(obj)) {
+ L_iter_list:
+ objp = list_val(obj);
+ obj = CAR(objp);
+ if (is_byte(obj)) {
+ if (len == 0)
+ goto L_overflow;
+ *buf++ = unsigned_val(obj);
+ csize++;
+ len--;
+ } else if (is_binary(obj)) {
+ ESTACK_PUSH(s, CDR(objp));
+ goto handle_binary;
+ } else if (is_list(obj)) {
+ ESTACK_PUSH(s, CDR(objp));
+ goto L_iter_list; /* on head */
+ } else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+ obj = CDR(objp);
+ if (is_list(obj))
+ goto L_iter_list; /* on tail */
+ else if (is_binary(obj)) {
+ goto handle_binary;
+ } else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+ } else if (is_binary(obj)) {
+ Eterm real_bin;
+ Uint offset;
+ Eterm* bptr;
+ int size;
+ int bitoffs;
+ int bitsize;
+
+ handle_binary:
+ size = binary_size(obj);
+ ERTS_GET_REAL_BIN(obj, real_bin, offset, bitoffs, bitsize);
+ ASSERT(bitsize == 0);
+ bptr = binary_val(real_bin);
+ if (*bptr == HEADER_PROC_BIN) {
+ ProcBin* pb = (ProcBin *) bptr;
+ if (bitoffs != 0) {
+ if (len < size) {
+ goto L_overflow;
+ }
+ erts_copy_bits(pb->bytes+offset, bitoffs, 1,
+ (byte *) buf, 0, 1, size*8);
+ csize += size;
+ buf += size;
+ len -= size;
+ } else if (bin_limit && size < bin_limit) {
+ if (len < size) {
+ goto L_overflow;
+ }
+ sys_memcpy(buf, pb->bytes+offset, size);
+ csize += size;
+ buf += size;
+ len -= size;
+ } else {
+ if (csize != 0) {
+ SET_VEC(iov, binv, cbin, cptr, csize, vlen);
+ cptr = buf;
+ csize = 0;
+ }
+ if (pb->flags) {
+ erts_emasculate_writable_binary(pb);
+ }
+ SET_VEC(iov, binv, Binary2ErlDrvBinary(pb->val),
+ pb->bytes+offset, size, vlen);
+ }
+ } else {
+ ErlHeapBin* hb = (ErlHeapBin *) bptr;
+ if (len < size) {
+ goto L_overflow;
+ }
+ copy_binary_to_buffer(buf, 0,
+ ((byte *) hb->data)+offset, bitoffs,
+ 8*size);
+ csize += size;
+ buf += size;
+ len -= size;
+ }
+ } else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+ }
+
+ if (csize != 0) {
+ SET_VEC(iov, binv, cbin, cptr, csize, vlen);
+ }
+
+ DESTROY_ESTACK(s);
+ return vlen;
+
+ L_type_error:
+ DESTROY_ESTACK(s);
+ return -2;
+
+ L_overflow:
+ DESTROY_ESTACK(s);
+ return -1;
+}
+
+#define IO_LIST_VEC_COUNT(obj) \
+do { \
+ int _size = binary_size(obj); \
+ Eterm _real; \
+ Uint _offset; \
+ int _bitoffs; \
+ int _bitsize; \
+ ERTS_GET_REAL_BIN(obj, _real, _offset, _bitoffs, _bitsize); \
+ ASSERT(_bitsize == 0); \
+ if (thing_subtag(*binary_val(_real)) == REFC_BINARY_SUBTAG && \
+ _bitoffs == 0) { \
+ b_size += _size; \
+ in_clist = 0; \
+ v_size++; \
+ if (_size >= bin_limit) { \
+ p_in_clist = 0; \
+ p_v_size++; \
+ } else { \
+ p_c_size += _size; \
+ if (!p_in_clist) { \
+ p_in_clist = 1; \
+ p_v_size++; \
+ } \
+ } \
+ } else { \
+ c_size += _size; \
+ if (!in_clist) { \
+ in_clist = 1; \
+ v_size++; \
+ } \
+ p_c_size += _size; \
+ if (!p_in_clist) { \
+ p_in_clist = 1; \
+ p_v_size++; \
+ } \
+ } \
+} while (0)
+
+
+/*
+** Size of a io list in bytes
+** return -1 if error
+** returns: - Total size of io list
+** vsize - SysIOVec size needed for a writev
+** csize - Number of bytes not in binary (in the common binary)
+** pvsize - SysIOVec size needed if packing small binaries
+** pcsize - Number of bytes in the common binary if packing
+*/
+
+static int
+io_list_vec_len(Eterm obj, int* vsize, int* csize,
+ int bin_limit, /* small binaries limit */
+ int * pvsize, int * pcsize)
+{
+ DECLARE_ESTACK(s);
+ Eterm* objp;
+ int v_size = 0;
+ int c_size = 0;
+ int b_size = 0;
+ int in_clist = 0;
+ int p_v_size = 0;
+ int p_c_size = 0;
+ int p_in_clist = 0;
+
+ goto L_jump_start; /* avoid a push */
+
+ while (!ESTACK_ISEMPTY(s)) {
+ obj = ESTACK_POP(s);
+ L_jump_start:
+ if (is_list(obj)) {
+ L_iter_list:
+ objp = list_val(obj);
+ obj = CAR(objp);
+
+ if (is_byte(obj)) {
+ c_size++;
+ if (!in_clist) {
+ in_clist = 1;
+ v_size++;
+ }
+ p_c_size++;
+ if (!p_in_clist) {
+ p_in_clist = 1;
+ p_v_size++;
+ }
+ }
+ else if (is_binary(obj)) {
+ IO_LIST_VEC_COUNT(obj);
+ }
+ else if (is_list(obj)) {
+ ESTACK_PUSH(s, CDR(objp));
+ goto L_iter_list; /* on head */
+ }
+ else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+
+ obj = CDR(objp);
+ if (is_list(obj))
+ goto L_iter_list; /* on tail */
+ else if (is_binary(obj)) { /* binary tail is OK */
+ IO_LIST_VEC_COUNT(obj);
+ }
+ else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+ }
+ else if (is_binary(obj)) {
+ IO_LIST_VEC_COUNT(obj);
+ }
+ else if (!is_nil(obj)) {
+ goto L_type_error;
+ }
+ }
+
+ DESTROY_ESTACK(s);
+ if (vsize != NULL)
+ *vsize = v_size;
+ if (csize != NULL)
+ *csize = c_size;
+ if (pvsize != NULL)
+ *pvsize = p_v_size;
+ if (pcsize != NULL)
+ *pcsize = p_c_size;
+ return c_size + b_size;
+
+ L_type_error:
+ DESTROY_ESTACK(s);
+ return -1;
+}
+
+#define ERL_SMALL_IO_BIN_LIMIT (4*ERL_ONHEAP_BIN_LIMIT)
+#define SMALL_WRITE_VEC 16
+
+
+/* write data to a port */
+int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
+{
+ char *buf;
+ erts_driver_t *drv = p->drv_ptr;
+ int size;
+ int fpe_was_unmasked;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ p->caller = caller_id;
+ if (drv->outputv != NULL) {
+ int vsize;
+ int csize;
+ int pvsize;
+ int pcsize;
+ int blimit;
+ SysIOVec iv[SMALL_WRITE_VEC];
+ ErlDrvBinary* bv[SMALL_WRITE_VEC];
+ SysIOVec* ivp;
+ ErlDrvBinary** bvp;
+ ErlDrvBinary* cbin;
+ ErlIOVec ev;
+
+ if ((size = io_list_vec_len(list, &vsize, &csize,
+ ERL_SMALL_IO_BIN_LIMIT,
+ &pvsize, &pcsize)) < 0) {
+ goto bad_value;
+ }
+ /* To pack or not to pack (small binaries) ...? */
+ vsize++;
+ if (vsize <= SMALL_WRITE_VEC) {
+ /* Do NOT pack */
+ blimit = 0;
+ } else {
+ /* Do pack */
+ vsize = pvsize + 1;
+ csize = pcsize;
+ blimit = ERL_SMALL_IO_BIN_LIMIT;
+ }
+ /* Use vsize and csize from now on */
+ if (vsize <= SMALL_WRITE_VEC) {
+ ivp = iv;
+ bvp = bv;
+ } else {
+ ivp = (SysIOVec *) erts_alloc(ERTS_ALC_T_TMP,
+ vsize * sizeof(SysIOVec));
+ bvp = (ErlDrvBinary**) erts_alloc(ERTS_ALC_T_TMP,
+ vsize * sizeof(ErlDrvBinary*));
+ }
+ cbin = driver_alloc_binary(csize);
+ if (!cbin)
+ erts_alloc_enomem(ERTS_ALC_T_DRV_BINARY, sizeof(Binary) + csize);
+
+ /* Element 0 is for driver usage to add header block */
+ ivp[0].iov_base = NULL;
+ ivp[0].iov_len = 0;
+ bvp[0] = NULL;
+ ev.vsize = io_list_to_vec(list, ivp+1, bvp+1, cbin, blimit);
+ ev.vsize++;
+#if 0
+ /* This assertion may say something useful, but it can
+ be falsified during the emulator test suites. */
+ ASSERT((ev.vsize >= 0) && (ev.vsize == vsize));
+#endif
+ ev.size = size; /* total size */
+ ev.iov = ivp;
+ ev.binv = bvp;
+ fpe_was_unmasked = erts_block_fpe();
+ (*drv->outputv)((ErlDrvData)p->drv_data, &ev);
+ erts_unblock_fpe(fpe_was_unmasked);
+ if (ivp != iv) {
+ erts_free(ERTS_ALC_T_TMP, (void *) ivp);
+ }
+ if (bvp != bv) {
+ erts_free(ERTS_ALC_T_TMP, (void *) bvp);
+ }
+ driver_free_binary(cbin);
+ } else {
+ int r;
+
+ /* Try with an 8KB buffer first (will often be enough I guess). */
+ size = 8*1024;
+ /* See below why the extra byte is added. */
+ buf = erts_alloc(ERTS_ALC_T_TMP, size+1);
+ r = io_list_to_buf(list, buf, size);
+
+ if (r >= 0) {
+ size -= r;
+ fpe_was_unmasked = erts_block_fpe();
+ (*drv->output)((ErlDrvData)p->drv_data, buf, size);
+ erts_unblock_fpe(fpe_was_unmasked);
+ erts_free(ERTS_ALC_T_TMP, buf);
+ }
+ else if (r == -2) {
+ erts_free(ERTS_ALC_T_TMP, buf);
+ goto bad_value;
+ }
+ else {
+ ASSERT(r == -1); /* Overflow */
+ erts_free(ERTS_ALC_T_TMP, buf);
+ if ((size = io_list_len(list)) < 0) {
+ goto bad_value;
+ }
+
+ /*
+ * I know drivers that pad space with '\0' this is clearly
+ * incorrect but I don't feel like fixing them now, insted
+ * add ONE extra byte.
+ */
+ buf = erts_alloc(ERTS_ALC_T_TMP, size+1);
+ r = io_list_to_buf(list, buf, size);
+ fpe_was_unmasked = erts_block_fpe();
+ (*drv->output)((ErlDrvData)p->drv_data, buf, size);
+ erts_unblock_fpe(fpe_was_unmasked);
+ erts_free(ERTS_ALC_T_TMP, buf);
+ }
+ }
+ p->bytes_out += size;
+ erts_smp_atomic_add(&erts_bytes_out, size);
+
+#ifdef ERTS_SMP
+ if (p->xports)
+ erts_smp_xports_unlock(p);
+ ASSERT(!p->xports);
+#endif
+ p->caller = NIL;
+ return 0;
+
+ bad_value:
+ p->caller = NIL;
+ {
+ erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp, "Bad value on output port '%s'\n", p->name);
+ erts_send_error_to_logger_nogl(dsbufp);
+ return 1;
+ }
+}
+
+/* initialize the port array */
+void init_io(void)
+{
+ int i;
+ ErlDrvEntry** dp;
+ ErlDrvEntry* drv;
+ char maxports[21]; /* enough for any 64-bit integer */
+ size_t maxportssize = sizeof(maxports);
+ Uint ports_bits = ERTS_PORTS_BITS;
+ Sint port_extra_shift;
+
+#ifdef ERTS_SMP
+ init_xports_list_alloc();
+#endif
+
+ pdl_init();
+
+ if (erts_sys_getenv("ERL_MAX_PORTS", maxports, &maxportssize) == 0)
+ erts_max_ports = atoi(maxports);
+ else
+ erts_max_ports = sys_max_files();
+
+ if (erts_max_ports > ERTS_MAX_PORTS)
+ erts_max_ports = ERTS_MAX_PORTS;
+ if (erts_max_ports < 1024)
+ erts_max_ports = 1024;
+
+ if (erts_use_r9_pids_ports) {
+ ports_bits = ERTS_R9_PORTS_BITS;
+ if (erts_max_ports > ERTS_MAX_R9_PORTS)
+ erts_max_ports = ERTS_MAX_R9_PORTS;
+ }
+
+ port_extra_shift = erts_fit_in_bits(erts_max_ports - 1);
+ port_num_mask = (1 << ports_bits) - 1;
+
+ erts_port_tab_index_mask = ~(~((Uint) 0) << port_extra_shift);
+ erts_max_ports = 1 << port_extra_shift;
+
+ erts_smp_mtx_init(&erts_driver_list_lock,"driver_list");
+ driver_list = NULL;
+ erts_smp_tsd_key_create(&driver_list_lock_status_key);
+ erts_smp_tsd_key_create(&driver_list_last_error_key);
+
+ if (erts_max_ports * sizeof(Port) <= erts_max_ports) {
+ /* More memory needed than the whole address space. */
+ erts_alloc_enomem(ERTS_ALC_T_PORT_TABLE, ~((Uint) 0));
+ }
+
+ erts_port = (Port *) erts_alloc(ERTS_ALC_T_PORT_TABLE,
+ erts_max_ports * sizeof(Port));
+
+ erts_smp_atomic_init(&erts_bytes_out, 0);
+ erts_smp_atomic_init(&erts_bytes_in, 0);
+ erts_smp_atomic_init(&erts_ports_alive, 0);
+
+ for (i = 0; i < erts_max_ports; i++) {
+ erts_port_task_init_sched(&erts_port[i].sched);
+#ifdef ERTS_SMP
+ erts_smp_atomic_init(&erts_port[i].refc, 0);
+ erts_port[i].lock = NULL;
+ erts_port[i].xports = NULL;
+ erts_smp_spinlock_init(&erts_port[i].state_lck, "port_state");
+#endif
+ erts_port[i].tracer_proc = NIL;
+ erts_port[i].trace_flags = 0;
+
+ erts_port[i].drv_ptr = NULL;
+ erts_port[i].status = ERTS_PORT_SFLG_FREE;
+ erts_port[i].name = NULL;
+ erts_port[i].nlinks = NULL;
+ erts_port[i].monitors = NULL;
+ erts_port[i].linebuf = NULL;
+ erts_port[i].port_data_lock = NULL;
+ }
+
+ erts_smp_atomic_init(&erts_ports_snapshot, (long) 0);
+ last_port_num = 0;
+ erts_smp_spinlock_init(&get_free_port_lck, "get_free_port");
+
+ sys_init_io();
+
+ erts_smp_tsd_set(driver_list_lock_status_key, (void *) 1);
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+
+ init_driver(&fd_driver, &fd_driver_entry, NULL);
+ init_driver(&vanilla_driver, &vanilla_driver_entry, NULL);
+ init_driver(&spawn_driver, &spawn_driver_entry, NULL);
+ for (dp = driver_tab; *dp != NULL; dp++) {
+ drv = *dp;
+ erts_add_driver_entry(*dp, NULL, 1);
+ }
+
+ erts_smp_tsd_set(driver_list_lock_status_key, NULL);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+}
+
+/*
+ * Buffering of data when using line oriented I/O on ports
+ */
+
+/*
+ * Buffer states
+ */
+#define LINEBUF_MAIN 0
+#define LINEBUF_FULL 1
+#define LINEBUF_CR_INSIDE 2
+#define LINEBUF_CR_AFTER 3
+
+/*
+ * Creates a LineBuf to be added to the port structure,
+ * Returns: Pointer to a newly allocated and initialized LineBuf.
+ * Parameters:
+ * bufsiz - The (maximum) size of the line buffer.
+ */
+LineBuf *allocate_linebuf(bufsiz)
+int bufsiz;
+{
+ int ovsiz = (bufsiz < LINEBUF_INITIAL) ? bufsiz : LINEBUF_INITIAL;
+ LineBuf *lb = (LineBuf *) erts_alloc(ERTS_ALC_T_LINEBUF,
+ sizeof(LineBuf)+ovsiz);
+ lb->ovsiz = ovsiz;
+ lb->bufsiz = bufsiz;
+ lb->ovlen = 0;
+ lb->data[0] = LINEBUF_MAIN; /* state */
+ return lb;
+}
+
+/*
+ * Initializes a LineBufContext to be used in calls to read_linebuf
+ * or flush_linebuf.
+ * Returns: 0 if ok, <0 on error.
+ * Parameters:
+ * lc - Pointer to an allocated LineBufContext.
+ * lb - Pointer to a LineBuf structure (probably from the Port structure).
+ * buf - A buffer containing the data to be read and split to lines.
+ * len - The number of bytes in buf.
+ */
+static int init_linebuf_context(LineBufContext *lc, LineBuf **lb, char *buf, int len)
+{
+ if(lc == NULL || lb == NULL)
+ return -1;
+ lc->b = lb;
+ lc->buf = buf;
+ lc->left = len;
+ return 0;
+}
+
+static void resize_linebuf(LineBuf **b)
+{
+ int newsiz = (((*b)->ovsiz * 2) > (*b)->bufsiz) ? (*b)->bufsiz :
+ (*b)->ovsiz * 2;
+ *b = (LineBuf *) erts_realloc(ERTS_ALC_T_LINEBUF,
+ (void *) *b,
+ sizeof(LineBuf)+newsiz);
+ (*b)->ovsiz = newsiz;
+}
+
+/*
+ * Delivers all data in the buffer regardless of newlines (always
+ * an LINEBUF_NOEOL. Has to be called until it return LINEBUF_EMPTY.
+ * Return values and barameters as read_linebuf (see below).
+ */
+static int flush_linebuf(LineBufContext *bp)
+{
+ bp->retlen = (*bp->b)->ovlen;
+ switch(LINEBUF_STATE(*bp)){
+ case LINEBUF_CR_INSIDE:
+ if((*bp->b)->ovlen >= (*bp->b)->ovsiz)
+ resize_linebuf(bp->b);
+ LINEBUF_DATA(*bp)[((*bp->b)->ovlen)++] = '\r';
+ ++bp->retlen; /* fall through instead of switching state... */
+ case LINEBUF_MAIN:
+ case LINEBUF_FULL:
+ (*bp->b)->ovlen = 0;
+ LINEBUF_STATE(*bp) = LINEBUF_MAIN;
+ if(!bp->retlen)
+ return LINEBUF_EMPTY;
+ return LINEBUF_NOEOL;
+ case LINEBUF_CR_AFTER:
+ LINEBUF_STATE(*bp) = LINEBUF_CR_INSIDE;
+ (*bp->b)->ovlen = 0;
+ if(!bp->retlen)
+ return LINEBUF_EMPTY;
+ return LINEBUF_NOEOL;
+ default:
+ return LINEBUF_ERROR;
+ }
+}
+
+/*
+ * Reads input from a buffer and "chops" it up in lines.
+ * Has to be called repeatedly until it returns LINEBUF_EMPTY
+ * to get all lines in buffer.
+ * Handles both <LF> and <CR><LF> style newlines.
+ * On Unix, this is slightly incorrect, as <CR><LF> is NOT to be regarded
+ * as a newline together, but i treat newlines equally in all systems
+ * to avoid putting this in sys.c or clutter it with #ifdef's.
+ * Returns: LINEBUF_EMPTY if there is no more data that can be
+ * determined as a line (only part of a line left), LINEBUF_EOL if a whole
+ * line could be delivered and LINEBUF_NOEOL if the buffer size has been
+ * exceeded. The data and the data length can be accesed through the
+ * LINEBUF_DATA and the LINEBUF_DATALEN macros applied to the LineBufContext.
+ * Parameters:
+ * bp - A LineBufContext that is initialized with
+ * the init_linebuf_context call. The context has to be retained during
+ * all calls that returns other than LINEBUF_EMPTY. When LINEBUF_EMPTY
+ * is returned the context can be discarded and a new can be created when new
+ * data arrives (the state is saved in the Port structure).
+ */
+static int read_linebuf(LineBufContext *bp)
+{
+ for(;;){
+ if(bp->left == 0)
+ return LINEBUF_EMPTY;
+ if(*bp->buf == '\n'){
+ LINEBUF_STATE(*bp) = LINEBUF_MAIN;
+ ++(bp->buf);
+ --(bp->left);
+ bp->retlen = (*bp->b)->ovlen;
+ (*bp->b)->ovlen = 0;
+ return LINEBUF_EOL;
+ }
+ switch(LINEBUF_STATE(*bp)){
+ case LINEBUF_MAIN:
+ if((*bp->b)->ovlen == (*bp->b)->bufsiz)
+ LINEBUF_STATE(*bp) = LINEBUF_FULL;
+ else if(*bp->buf == '\r'){
+ ++(bp->buf);
+ --(bp->left);
+ LINEBUF_STATE(*bp) = LINEBUF_CR_INSIDE;
+ } else {
+ if((*bp->b)->ovlen >= (*bp->b)->ovsiz)
+ resize_linebuf(bp->b);
+ LINEBUF_DATA(*bp)[((*bp->b)->ovlen)++] = *((bp->buf)++);
+ --(bp->left);
+ }
+ continue;
+ case LINEBUF_FULL:
+ if(*bp->buf == '\r'){
+ ++(bp->buf);
+ --(bp->left);
+ LINEBUF_STATE(*bp) = LINEBUF_CR_AFTER;
+ } else {
+ bp->retlen = (*bp->b)->ovlen;
+ (*bp->b)->ovlen = 0;
+ LINEBUF_STATE(*bp) = LINEBUF_MAIN;
+ return LINEBUF_NOEOL;
+ }
+ continue;
+ case LINEBUF_CR_INSIDE:
+ if((*bp->b)->ovlen >= (*bp->b)->ovsiz)
+ resize_linebuf(bp->b);
+ LINEBUF_DATA(*bp)[((*bp->b)->ovlen)++] = '\r';
+ LINEBUF_STATE(*bp) = LINEBUF_MAIN;
+ continue;
+ case LINEBUF_CR_AFTER:
+ bp->retlen = (*bp->b)->ovlen;
+ (*bp->b)->ovlen = 0;
+ LINEBUF_STATE(*bp) = LINEBUF_CR_INSIDE;
+ return LINEBUF_NOEOL;
+ default:
+ return LINEBUF_ERROR;
+ }
+ }
+}
+
+static void
+deliver_result(Eterm sender, Eterm pid, Eterm res)
+{
+ Process *rp;
+ ErtsProcLocks rp_locks = 0;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ ASSERT(is_internal_port(sender)
+ && is_internal_pid(pid)
+ && internal_pid_index(pid) < erts_max_processes);
+
+ rp = erts_pid2proc_opt(NULL, 0, pid, 0, ERTS_P2P_FLG_SMP_INC_REFC);
+
+ if (rp) {
+ Eterm tuple;
+ ErlHeapFragment *bp;
+ ErlOffHeap *ohp;
+ Eterm* hp;
+ Uint sz_res;
+ sz_res = size_object(res);
+ hp = erts_alloc_message_heap(sz_res + 3, &bp, &ohp, rp, &rp_locks);
+ res = copy_struct(res, sz_res, &hp, ohp);
+ tuple = TUPLE2(hp, sender, res);
+ erts_queue_message(rp, &rp_locks, bp, tuple, NIL);
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+ }
+}
+
+
+/*
+ * Deliver a "read" message.
+ * hbuf -- byte that are always formated as a list
+ * hlen -- number of byte in header
+ * buf -- data
+ * len -- length of data
+ */
+
+static void deliver_read_message(Port* prt, Eterm to,
+ char *hbuf, int hlen,
+ char *buf, int len, int eol)
+{
+ int need;
+ Eterm listp;
+ Eterm tuple;
+ Process* rp;
+ Eterm* hp;
+ ErlHeapFragment *bp;
+ ErlOffHeap *ohp;
+ ErtsProcLocks rp_locks = 0;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ need = 3 + 3 + 2*hlen;
+ if (prt->status & ERTS_PORT_SFLG_LINEBUF_IO) {
+ need += 3;
+ }
+ if (prt->status & ERTS_PORT_SFLG_BINARY_IO && buf != NULL) {
+ need += PROC_BIN_SIZE;
+ } else {
+ need += 2*len;
+ }
+
+ rp = erts_pid2proc_opt(NULL, 0, to, 0, ERTS_P2P_FLG_SMP_INC_REFC);
+ if (!rp)
+ return;
+
+ hp = erts_alloc_message_heap(need, &bp, &ohp, rp, &rp_locks);
+
+ listp = NIL;
+ if ((prt->status & ERTS_PORT_SFLG_BINARY_IO) == 0) {
+ listp = buf_to_intlist(&hp, buf, len, listp);
+ } else if (buf != NULL) {
+ ProcBin* pb;
+ Binary* bptr;
+
+ bptr = erts_bin_nrml_alloc(len);
+ bptr->flags = 0;
+ bptr->orig_size = len;
+ erts_refc_init(&bptr->refc, 1);
+ sys_memcpy(bptr->orig_bytes, buf, len);
+
+ pb = (ProcBin *) hp;
+ pb->thing_word = HEADER_PROC_BIN;
+ pb->size = len;
+ pb->next = ohp->mso;
+ ohp->mso = pb;
+ pb->val = bptr;
+ pb->bytes = (byte*) bptr->orig_bytes;
+ pb->flags = 0;
+ hp += PROC_BIN_SIZE;
+
+ ohp->overhead += pb->size / sizeof(Eterm);
+ listp = make_binary(pb);
+ }
+
+ /* Prepend the header */
+ if (hlen > 0) {
+ listp = buf_to_intlist(&hp, hbuf, hlen, listp);
+ }
+
+ if (prt->status & ERTS_PORT_SFLG_LINEBUF_IO){
+ listp = TUPLE2(hp, (eol) ? am_eol : am_noeol, listp);
+ hp += 3;
+ }
+ tuple = TUPLE2(hp, am_data, listp);
+ hp += 3;
+
+ tuple = TUPLE2(hp, prt->id, tuple);
+ hp += 3;
+
+ erts_queue_message(rp, &rp_locks, bp, tuple, am_undefined);
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+}
+
+/*
+ * Deliver all lines in a line buffer, repeats calls to
+ * deliver_read_message, and takes the same parameters.
+ */
+static void deliver_linebuf_message(Port* prt, Eterm to,
+ char* hbuf, int hlen,
+ char *buf, int len)
+{
+ LineBufContext lc;
+ int ret;
+ if(init_linebuf_context(&lc,&(prt->linebuf), buf, len) < 0)
+ return;
+ while((ret = read_linebuf(&lc)) > LINEBUF_EMPTY)
+ deliver_read_message(prt, to, hbuf, hlen, LINEBUF_DATA(lc),
+ LINEBUF_DATALEN(lc), (ret == LINEBUF_EOL));
+}
+
+/*
+ * Deliver any nonterminated lines in the line buffer before the
+ * port gets closed.
+ * Has to be called before terminate_port.
+ * Parameters:
+ * prt - Pointer to a Port structure for this port.
+ */
+static void flush_linebuf_messages(Port *prt)
+{
+ LineBufContext lc;
+ int ret;
+
+ ERTS_SMP_LC_ASSERT(!prt || erts_lc_is_port_locked(prt));
+ if(prt == NULL || !(prt->status & ERTS_PORT_SFLG_LINEBUF_IO))
+ return;
+
+ if(init_linebuf_context(&lc,&(prt->linebuf), NULL, 0) < 0)
+ return;
+ while((ret = flush_linebuf(&lc)) > LINEBUF_EMPTY)
+ deliver_read_message(prt,
+ prt->connected,
+ NULL,
+ 0,
+ LINEBUF_DATA(lc),
+ LINEBUF_DATALEN(lc),
+ (ret == LINEBUF_EOL));
+}
+
+static void
+deliver_vec_message(Port* prt, /* Port */
+ Eterm to, /* Receiving pid */
+ char* hbuf, /* "Header" buffer... */
+ int hlen, /* ... and its length */
+ ErlDrvBinary** binv, /* Vector of binaries */
+ SysIOVec* iov, /* I/O vector */
+ int vsize, /* Size of binv & iov */
+ int csize) /* Size of characters in
+ iov (not hlen) */
+{
+ int need;
+ Eterm listp;
+ Eterm tuple;
+ Process* rp;
+ Eterm* hp;
+ ErlHeapFragment *bp;
+ ErlOffHeap *ohp;
+ ErtsProcLocks rp_locks = 0;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ /*
+ * Check arguments for validity.
+ */
+
+ rp = erts_pid2proc_opt(NULL, 0, to, 0, ERTS_P2P_FLG_SMP_INC_REFC);
+ if (!rp)
+ return;
+
+ /*
+ * Calculate the exact number of heap words needed.
+ */
+
+ need = 3 + 3; /* Heap space for two tuples */
+ if (prt->status & ERTS_PORT_SFLG_BINARY_IO) {
+ need += (2+PROC_BIN_SIZE)*vsize - 2 + hlen*2;
+ } else {
+ need += (hlen+csize)*2;
+ }
+
+ hp = erts_alloc_message_heap(need, &bp, &ohp, rp, &rp_locks);
+
+ listp = NIL;
+ iov += vsize;
+
+ if ((prt->status & ERTS_PORT_SFLG_BINARY_IO) == 0) {
+ Eterm* thp = hp;
+ while (vsize--) {
+ iov--;
+ listp = buf_to_intlist(&thp, iov->iov_base, iov->iov_len, listp);
+ }
+ hp = thp;
+ } else {
+ binv += vsize;
+ while (vsize--) {
+ ErlDrvBinary* b;
+ ProcBin* pb = (ProcBin*) hp;
+ byte* base;
+
+ iov--;
+ binv--;
+ if ((b = *binv) == NULL) {
+ b = driver_alloc_binary(iov->iov_len);
+ sys_memcpy(b->orig_bytes, iov->iov_base, iov->iov_len);
+ base = (byte*) b->orig_bytes;
+ } else {
+ /* Must increment reference count, caller calls free */
+ driver_binary_inc_refc(b);
+ base = iov->iov_base;
+ }
+ pb->thing_word = HEADER_PROC_BIN;
+ pb->size = iov->iov_len;
+ pb->next = ohp->mso;
+ ohp->mso = pb;
+ pb->val = ErlDrvBinary2Binary(b);
+ pb->bytes = base;
+ pb->flags = 0;
+ hp += PROC_BIN_SIZE;
+
+ ohp->overhead += iov->iov_len / sizeof(Eterm);
+
+ if (listp == NIL) { /* compatible with deliver_bin_message */
+ listp = make_binary(pb);
+ } else {
+ listp = CONS(hp, make_binary(pb), listp);
+ hp += 2;
+ }
+ }
+ }
+
+ if (hlen > 0) { /* Prepend the header */
+ Eterm* thp = hp;
+ listp = buf_to_intlist(&thp, hbuf, hlen, listp);
+ hp = thp;
+ }
+
+ tuple = TUPLE2(hp, am_data, listp);
+ hp += 3;
+ tuple = TUPLE2(hp, prt->id, tuple);
+ hp += 3;
+
+ erts_queue_message(rp, &rp_locks, bp, tuple, am_undefined);
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+}
+
+
+static void deliver_bin_message(Port* prt, /* port */
+ Eterm to, /* receiving pid */
+ char* hbuf, /* "header" buffer */
+ int hlen, /* and it's length */
+ ErlDrvBinary* bin, /* binary data */
+ int offs, /* offset into binary */
+ int len) /* length of binary */
+{
+ SysIOVec vec;
+
+ vec.iov_base = bin->orig_bytes+offs;
+ vec.iov_len = len;
+ deliver_vec_message(prt, to, hbuf, hlen, &bin, &vec, 1, len);
+}
+
+/* flush the port I/O queue and terminate if empty */
+/*
+ * Note.
+ *
+ * The test for (p->status & ERTS_PORT_SFLGS_DEAD) == 0 is important since the
+ * driver's flush function might call driver_async, which when using no
+ * threads and being short circuited will notice that the io queue is empty
+ * (after calling the driver's async_ready) and recursively call
+ * terminate_port. So when we get back here, the port is already terminated.
+ */
+static void flush_port(Port *p)
+{
+ int fpe_was_unmasked;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+
+ if (p->drv_ptr->flush != NULL) {
+ if (IS_TRACED_FL(p, F_TRACE_SCHED_PORTS)) {
+ trace_sched_ports_where(p, am_in, am_flush);
+ }
+ fpe_was_unmasked = erts_block_fpe();
+ (*p->drv_ptr->flush)((ErlDrvData)p->drv_data);
+ erts_unblock_fpe(fpe_was_unmasked);
+ if (IS_TRACED_FL(p, F_TRACE_SCHED_PORTS)) {
+ trace_sched_ports_where(p, am_out, am_flush);
+ }
+#ifdef ERTS_SMP
+ if (p->xports)
+ erts_smp_xports_unlock(p);
+ ASSERT(!p->xports);
+#endif
+ }
+ if ((p->status & ERTS_PORT_SFLGS_DEAD) == 0 && is_port_ioq_empty(p)) {
+ terminate_port(p);
+ }
+}
+
+/* stop and delete a port that is ERTS_PORT_SFLG_CLOSING */
+static void
+terminate_port(Port *prt)
+{
+ Eterm send_closed_port_id;
+ Eterm connected_id = NIL /* Initialize to silence compiler */;
+ erts_driver_t *drv;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ ASSERT(!prt->nlinks);
+ ASSERT(!prt->monitors);
+
+ if (prt->status & ERTS_PORT_SFLG_SEND_CLOSED) {
+ erts_port_status_band_set(prt, ~ERTS_PORT_SFLG_SEND_CLOSED);
+ send_closed_port_id = prt->id;
+ connected_id = prt->connected;
+ }
+ else {
+ send_closed_port_id = NIL;
+ }
+
+#ifdef ERTS_SMP
+ erts_cancel_smp_ptimer(prt->ptimer);
+#else
+ erl_cancel_timer(&prt->tm);
+#endif
+
+ drv = prt->drv_ptr;
+ if ((drv != NULL) && (drv->stop != NULL)) {
+ int fpe_was_unmasked = erts_block_fpe();
+ (*drv->stop)((ErlDrvData)prt->drv_data);
+ erts_unblock_fpe(fpe_was_unmasked);
+#ifdef ERTS_SMP
+ if (prt->xports)
+ erts_smp_xports_unlock(prt);
+ ASSERT(!prt->xports);
+#endif
+ }
+ if(drv->handle != NULL) {
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ erts_ddll_decrement_port_count(drv->handle);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ stopq(prt); /* clear queue memory */
+ if(prt->linebuf != NULL){
+ erts_free(ERTS_ALC_T_LINEBUF, (void *) prt->linebuf);
+ prt->linebuf = NULL;
+ }
+ if (prt->bp != NULL) {
+ free_message_buffer(prt->bp);
+ prt->bp = NULL;
+ prt->data = am_undefined;
+ }
+
+ if (prt->psd)
+ erts_free(ERTS_ALC_T_PRTSD, prt->psd);
+
+ kill_port(prt);
+
+ /*
+ * We don't want to send the closed message until after the
+ * port has been removed from the port table (in kill_port()).
+ */
+ if (is_internal_port(send_closed_port_id))
+ deliver_result(send_closed_port_id, connected_id, am_closed);
+
+ ASSERT(prt->dist_entry == NULL);
+}
+
+void
+erts_terminate_port(Port *pp)
+{
+ terminate_port(pp);
+}
+
+static void sweep_one_monitor(ErtsMonitor *mon, void *vpsc)
+{
+ ErtsMonitor *rmon;
+ Process *rp;
+
+ ASSERT(mon->type == MON_ORIGIN);
+ ASSERT(is_internal_pid(mon->pid));
+ rp = erts_pid2proc(NULL, 0, mon->pid, ERTS_PROC_LOCK_LINK);
+ if (!rp) {
+ goto done;
+ }
+ rmon = erts_remove_monitor(&(rp->monitors),mon->ref);
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+ if (rmon == NULL) {
+ goto done;
+ }
+ erts_destroy_monitor(rmon);
+ done:
+ erts_destroy_monitor(mon);
+}
+
+
+
+typedef struct {
+ Eterm port;
+ Eterm reason;
+} SweepContext;
+
+static void sweep_one_link(ErtsLink *lnk, void *vpsc)
+{
+ SweepContext *psc = vpsc;
+ DistEntry *dep;
+ Process *rp;
+
+
+ ASSERT(lnk->type == LINK_PID);
+
+ if (is_external_pid(lnk->pid)) {
+ dep = external_pid_dist_entry(lnk->pid);
+ if(dep != erts_this_dist_entry) {
+ ErtsDistLinkData dld;
+ ErtsDSigData dsd;
+ int code;
+ code = erts_dsig_prepare(&dsd, dep, NULL, ERTS_DSP_NO_LOCK, 0);
+ switch (code) {
+ case ERTS_DSIG_PREP_NOT_ALIVE:
+ case ERTS_DSIG_PREP_NOT_CONNECTED:
+ break;
+ case ERTS_DSIG_PREP_CONNECTED:
+ erts_remove_dist_link(&dld, psc->port, lnk->pid, dep);
+ erts_destroy_dist_link(&dld);
+ code = erts_dsig_send_exit(&dsd, psc->port, lnk->pid,
+ psc->reason);
+ ASSERT(code == ERTS_DSIG_SEND_OK);
+ break;
+ default:
+ ASSERT(! "Invalid dsig prepare result");
+ break;
+ }
+ }
+ } else {
+ ErtsProcLocks rp_locks = ERTS_PROC_LOCK_LINK|ERTS_PROC_LOCKS_XSIG_SEND;
+ ASSERT(is_internal_pid(lnk->pid));
+ rp = erts_pid2proc(NULL, 0, lnk->pid, rp_locks);
+ if (rp) {
+ ErtsLink *rlnk = erts_remove_link(&(rp->nlinks), psc->port);
+
+ if (rlnk) {
+ int xres = erts_send_exit_signal(NULL,
+ psc->port,
+ rp,
+ &rp_locks,
+ psc->reason,
+ NIL,
+ NULL,
+ 0);
+ if (xres >= 0 && IS_TRACED_FL(rp, F_TRACE_PROCS)) {
+ /* We didn't exit the process and it is traced */
+ if (IS_TRACED_FL(rp, F_TRACE_PROCS)) {
+ trace_proc(NULL, rp, am_getting_unlinked,
+ psc->port);
+ }
+ }
+ erts_destroy_link(rlnk);
+ }
+
+ erts_smp_proc_unlock(rp, rp_locks);
+ }
+ }
+ erts_destroy_link(lnk);
+}
+
+/* 'from' is sending 'this_port' an exit signal, (this_port must be internal).
+ * If reason is normal we don't do anything, *unless* from is our connected
+ * process in which case we close the port. Any other reason kills the port.
+ * If 'from' is ourself we always die.
+ * When a driver has data in ioq then driver will be set to closing
+ * and become inaccessible to the processes. One exception exists and
+ * that is to kill a port till reason kill. Then the port is stopped.
+ *
+ */
+void
+erts_do_exit_port(Port *p, Eterm from, Eterm reason)
+{
+ ErtsLink *lnk;
+ Eterm rreason;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+
+ rreason = (reason == am_kill) ? am_killed : reason;
+
+ if ((p->status & (ERTS_PORT_SFLGS_DEAD
+ | ERTS_PORT_SFLG_EXITING
+ | ERTS_PORT_SFLG_IMMORTAL))
+ || ((reason == am_normal) &&
+ ((from != p->connected) && (from != p->id)))) {
+ return;
+ }
+
+ if (IS_TRACED_FL(p, F_TRACE_PORTS)) {
+ trace_port(p, am_closed, reason);
+ }
+
+ erts_trace_check_exiting(p->id);
+
+ /*
+ * Setting the port to not busy here, frees the list of pending
+ * processes and makes them runnable.
+ */
+ set_busy_port((ErlDrvPort)internal_port_index(p->id), 0);
+
+ if (p->reg != NULL)
+ (void) erts_unregister_name(NULL, 0, p, p->reg->name);
+
+ erts_port_status_bor_set(p, ERTS_PORT_SFLG_EXITING);
+
+ {
+ SweepContext sc = {p->id, rreason};
+ lnk = p->nlinks;
+ p->nlinks = NULL;
+ erts_sweep_links(lnk, &sweep_one_link, &sc);
+ }
+ {
+ ErtsMonitor *moni = p->monitors;
+ p->monitors = NULL;
+ erts_sweep_monitors(moni, &sweep_one_monitor, NULL);
+ }
+
+
+ if ((p->status & ERTS_PORT_SFLG_DISTRIBUTION) && p->dist_entry) {
+ erts_do_net_exits(p->dist_entry, rreason);
+ erts_deref_dist_entry(p->dist_entry);
+ p->dist_entry = NULL;
+ erts_port_status_band_set(p, ~ERTS_PORT_SFLG_DISTRIBUTION);
+ }
+
+ if ((reason != am_kill) && !is_port_ioq_empty(p)) {
+ erts_port_status_bandor_set(p,
+ ~ERTS_PORT_SFLG_EXITING, /* must turn it off */
+ ERTS_PORT_SFLG_CLOSING);
+ flush_port(p);
+ }
+ else {
+ terminate_port(p);
+ }
+}
+
+/* About the states ERTS_PORT_SFLG_EXITING and ERTS_PORT_SFLG_CLOSING used above.
+**
+** ERTS_PORT_SFLG_EXITING is a recursion protection for erts_do_exit_port().
+** It is unclear whether this state is necessary or not, it might be possible
+** to merge it with ERTS_PORT_SFLG_CLOSING. ERTS_PORT_SFLG_EXITING only persists
+** over a section of sequential (but highly recursive) code.
+**
+** ERTS_PORT_SFLG_CLOSING is a state where the port is in Limbo, waiting to
+** pass on. All links are removed, and the port receives in/out-put events so
+** as soon as the port queue gets empty terminate_port() is called.
+*/
+
+
+
+/* Command should be of the form
+** {PID, close}
+** {PID, {command, io-list}}
+** {PID, {connect, New_PID}}
+**
+**
+*/
+void erts_port_command(Process *proc,
+ Eterm caller_id,
+ Port *port,
+ Eterm command)
+{
+ Eterm *tp;
+ Eterm pid;
+
+ if (!port)
+ return;
+
+ erts_smp_proc_unlock(proc, ERTS_PROC_LOCK_MAIN);
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ASSERT(!INVALID_PORT(port, port->id));
+
+ if (is_tuple_arity(command, 2)) {
+ tp = tuple_val(command);
+ if ((pid = port->connected) == tp[1]) {
+ /* PID must be connected */
+ if (tp[2] == am_close) {
+ erts_port_status_bor_set(port, ERTS_PORT_SFLG_SEND_CLOSED);
+ erts_do_exit_port(port, pid, am_normal);
+ goto done;
+ } else if (is_tuple_arity(tp[2], 2)) {
+ tp = tuple_val(tp[2]);
+ if (tp[1] == am_command) {
+ if (erts_write_to_port(caller_id, port, tp[2]) == 0)
+ goto done;
+ } else if ((tp[1] == am_connect) && is_internal_pid(tp[2])) {
+ port->connected = tp[2];
+ deliver_result(port->id, pid, am_connected);
+ goto done;
+ }
+ }
+ }
+ }
+
+ {
+ ErtsProcLocks rp_locks = ERTS_PROC_LOCKS_XSIG_SEND;
+ Process* rp = erts_pid2proc_opt(NULL, 0,
+ port->connected, rp_locks,
+ ERTS_P2P_FLG_SMP_INC_REFC);
+ if (rp) {
+ (void) erts_send_exit_signal(NULL,
+ port->id,
+ rp,
+ &rp_locks,
+ am_badsig,
+ NIL,
+ NULL,
+ 0);
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+ }
+
+ }
+ done:
+ erts_smp_proc_lock(proc, ERTS_PROC_LOCK_MAIN);
+}
+
+/*
+ * Control a port synchronously.
+ * Returns either a list or a binary.
+ */
+Eterm
+erts_port_control(Process* p, Port* prt, Uint command, Eterm iolist)
+{
+ byte* to_port = NULL; /* Buffer to write to port. */
+ /* Initialization is for shutting up
+ warning about use before set. */
+ int to_len = 0; /* Length of buffer. */
+ int must_free = 0; /* True if the buffer should be freed. */
+ char port_result[ERL_ONHEAP_BIN_LIMIT]; /* Default buffer for result from port. */
+ char* port_resp; /* Pointer to result buffer. */
+ int n;
+ int (*control)(ErlDrvData, unsigned, char*, int, char**, int);
+ int fpe_was_unmasked;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if ((control = prt->drv_ptr->control) == NULL) {
+ return THE_NON_VALUE;
+ }
+
+ /*
+ * Convert the iolist to a buffer, pointed to by to_port,
+ * and with its length in to_len.
+ */
+ if (is_binary(iolist) && binary_bitoffset(iolist) == 0) {
+ Uint bitoffs;
+ Uint bitsize;
+ ERTS_GET_BINARY_BYTES(iolist, to_port, bitoffs, bitsize);
+ to_len = binary_size(iolist);
+ } else {
+ int r;
+
+ /* Try with an 8KB buffer first (will often be enough I guess). */
+ to_len = 8*1024;
+ to_port = erts_alloc(ERTS_ALC_T_TMP, to_len);
+ must_free = 1;
+
+ /*
+ * In versions before R10B, we used to reserve random
+ * amounts of extra memory. From R10B, we allocate the
+ * exact amount.
+ */
+ r = io_list_to_buf(iolist, (char*) to_port, to_len);
+ if (r >= 0) {
+ to_len -= r;
+ } else if (r == -2) { /* Type error */
+ erts_free(ERTS_ALC_T_TMP, (void *) to_port);
+ return THE_NON_VALUE;
+ } else {
+ ASSERT(r == -1); /* Overflow */
+ erts_free(ERTS_ALC_T_TMP, (void *) to_port);
+ if ((to_len = io_list_len(iolist)) < 0) { /* Type error */
+ return THE_NON_VALUE;
+ }
+ must_free = 1;
+ to_port = erts_alloc(ERTS_ALC_T_TMP, to_len);
+ r = io_list_to_buf(iolist, (char*) to_port, to_len);
+ ASSERT(r == 0);
+ }
+ }
+
+ prt->caller = p->id; /* Internal pid */
+
+ erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ /*
+ * Call the port's control routine.
+ */
+
+ port_resp = port_result;
+ fpe_was_unmasked = erts_block_fpe();
+ n = control((ErlDrvData)prt->drv_data, command, (char*)to_port, to_len,
+ &port_resp, sizeof(port_result));
+ erts_unblock_fpe(fpe_was_unmasked);
+ if (must_free) {
+ erts_free(ERTS_ALC_T_TMP, (void *) to_port);
+ }
+ prt->caller = NIL;
+#ifdef ERTS_SMP
+ if (prt->xports)
+ erts_smp_xports_unlock(prt);
+ ASSERT(!prt->xports);
+#endif
+
+ erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+ /*
+ * Handle the result.
+ */
+
+ if (n < 0) {
+ return THE_NON_VALUE;
+ }
+
+ if ((prt->control_flags & PORT_CONTROL_FLAG_BINARY) == 0) { /* List result */
+ Eterm ret;
+ Eterm* hp = HAlloc(p, 2*n);
+ ret = buf_to_intlist(&hp, port_resp, n, NIL);
+ if (port_resp != port_result) {
+ driver_free(port_resp);
+ }
+ return ret;
+ }
+ else if (port_resp == NULL) {
+ return NIL;
+ }
+ else { /* Binary result */
+ ErlDrvBinary *dbin;
+ ErlHeapBin *hbin;
+ if (port_resp != port_result) {
+ dbin = (ErlDrvBinary *) port_resp;
+ if (dbin->orig_size > ERL_ONHEAP_BIN_LIMIT) {
+ ProcBin* pb = (ProcBin *) HAlloc(p, PROC_BIN_SIZE);
+ pb->thing_word = HEADER_PROC_BIN;
+ pb->size = dbin->orig_size;
+ pb->next = MSO(p).mso;
+ MSO(p).mso = pb;
+ pb->val = ErlDrvBinary2Binary(dbin);
+ pb->bytes = (byte*) dbin->orig_bytes;
+ pb->flags = 0;
+ MSO(p).overhead += dbin->orig_size / sizeof(Eterm);
+ return make_binary(pb);
+ }
+ port_resp = dbin->orig_bytes;
+ n = dbin->orig_size;
+ } else {
+ dbin = NULL;
+ }
+ hbin = (ErlHeapBin*) HAlloc(p, heap_bin_size(n));
+ ASSERT(n <= ERL_ONHEAP_BIN_LIMIT);
+ hbin->thing_word = header_heap_bin(n);
+ hbin->size = n;
+ sys_memcpy(hbin->data, port_resp, n);
+ if (dbin != NULL) {
+ driver_free_binary(dbin);
+ }
+ return make_binary(hbin);
+ }
+}
+
+typedef struct {
+ int to;
+ void *arg;
+} prt_one_lnk_data;
+
+static void prt_one_monitor(ErtsMonitor *mon, void *vprtd)
+{
+ prt_one_lnk_data *prtd = (prt_one_lnk_data *) vprtd;
+ erts_print(prtd->to, prtd->arg, "(%T,%T)", mon->pid,mon->ref);
+}
+
+static void prt_one_lnk(ErtsLink *lnk, void *vprtd)
+{
+ prt_one_lnk_data *prtd = (prt_one_lnk_data *) vprtd;
+ erts_print(prtd->to, prtd->arg, "%T", lnk->pid);
+}
+
+void
+print_port_info(int to, void *arg, int i)
+{
+ Port* p = &erts_port[i];
+
+ if (p->status & ERTS_PORT_SFLGS_DEAD)
+ return;
+
+ erts_print(to, arg, "=port:%T\n", p->id);
+ erts_print(to, arg, "Slot: %d\n", i);
+ if (p->status & ERTS_PORT_SFLG_CONNECTED) {
+ erts_print(to, arg, "Connected: %T", p->connected);
+ erts_print(to, arg, "\n");
+ }
+
+ if (p->nlinks != NULL) {
+ prt_one_lnk_data prtd;
+ prtd.to = to;
+ prtd.arg = arg;
+ erts_print(to, arg, "Links: ");
+ erts_doforall_links(p->nlinks, &prt_one_lnk, &prtd);
+ erts_print(to, arg, "\n");
+ }
+ if (p->monitors != NULL) {
+ prt_one_lnk_data prtd;
+ prtd.to = to;
+ prtd.arg = arg;
+ erts_print(to, arg, "Monitors: ");
+ erts_doforall_monitors(p->monitors, &prt_one_monitor, &prtd);
+ erts_print(to, arg, "\n");
+ }
+
+ if (p->reg != NULL)
+ erts_print(to, arg, "Registered as: %T\n", p->reg->name);
+
+ if (p->drv_ptr == &fd_driver) {
+ erts_print(to, arg, "Port is UNIX fd not opened by emulator: %s\n", p->name);
+ } else if (p->drv_ptr == &vanilla_driver) {
+ erts_print(to, arg, "Port is a file: %s\n",p->name);
+ } else if (p->drv_ptr == &spawn_driver) {
+ erts_print(to, arg, "Port controls external process: %s\n",p->name);
+ } else {
+ erts_print(to, arg, "Port controls linked-in driver: %s\n",p->name);
+ }
+}
+
+void
+set_busy_port(ErlDrvPort port_num, int on)
+{
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(&erts_port[port_num]));
+
+ if (on) {
+ erts_port_status_bor_set(&erts_port[port_num],
+ ERTS_PORT_SFLG_PORT_BUSY);
+ } else {
+ ErtsProcList* plp = erts_port[port_num].suspended;
+ erts_port_status_band_set(&erts_port[port_num],
+ ~ERTS_PORT_SFLG_PORT_BUSY);
+ erts_port[port_num].suspended = NULL;
+
+ if (erts_port[port_num].dist_entry) {
+ /*
+ * Processes suspended on distribution ports are
+ * normally queued on the dist entry.
+ */
+ erts_dist_port_not_busy(&erts_port[port_num]);
+ }
+
+ /*
+ * Resume, in a round-robin fashion, all processes waiting on the port.
+ *
+ * This version submitted by Tony Rogvall. The earlier version used
+ * to resume the processes in order, which caused starvation of all but
+ * the first process.
+ */
+
+ if (plp) {
+ /* First proc should be resumed last */
+ if (plp->next) {
+ erts_resume_processes(plp->next);
+ plp->next = NULL;
+ }
+ erts_resume_processes(plp);
+ }
+ }
+}
+
+void set_port_control_flags(ErlDrvPort port_num, int flags)
+{
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(&erts_port[port_num]));
+
+ erts_port[port_num].control_flags = flags;
+}
+
+int get_port_flags(ErlDrvPort ix) {
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if (prt == NULL)
+ return 0;
+
+ return (prt->status & ERTS_PORT_SFLG_BINARY_IO ? PORT_FLAG_BINARY : 0)
+ | (prt->status & ERTS_PORT_SFLG_LINEBUF_IO ? PORT_FLAG_LINE : 0);
+}
+
+
+void erts_raw_port_command(Port* p, byte* buf, Uint len)
+{
+ int fpe_was_unmasked;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+
+ if (len > (Uint) INT_MAX)
+ erl_exit(ERTS_ABORT_EXIT,
+ "Absurdly large data buffer (%bpu bytes) passed to"
+ "output callback of %s driver.\n",
+ len,
+ p->drv_ptr->name ? p->drv_ptr->name : "unknown");
+
+ p->caller = NIL;
+ fpe_was_unmasked = erts_block_fpe();
+ (*p->drv_ptr->output)((ErlDrvData)p->drv_data, (char*) buf, (int) len);
+ erts_unblock_fpe(fpe_was_unmasked);
+}
+
+int async_ready(Port *p, void* data)
+{
+ int need_free = 1;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (p) {
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+ ASSERT(!(p->status & ERTS_PORT_SFLGS_DEAD));
+ if (p->drv_ptr->ready_async != NULL) {
+ (*p->drv_ptr->ready_async)((ErlDrvData)p->drv_data, data);
+ need_free = 0;
+#ifdef ERTS_SMP
+ if (p->xports)
+ erts_smp_xports_unlock(p);
+ ASSERT(!p->xports);
+#endif
+ }
+ if ((p->status & ERTS_PORT_SFLG_CLOSING) && is_port_ioq_empty(p)) {
+ terminate_port(p);
+ }
+ }
+ return need_free;
+}
+
+static void
+report_missing_drv_callback(Port *p, char *drv_type, char *callback)
+{
+ ErtsPortNames *pnp = erts_get_port_names(p->id);
+ char *unknown = "<unknown>";
+ char *drv_name = pnp->driver_name ? pnp->driver_name : unknown;
+ char *prt_name = pnp->name ? pnp->name : unknown;
+ erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp, "%T: %s driver '%s' ", p->id, drv_type, drv_name);
+ if (sys_strcmp(drv_name, prt_name) != 0)
+ erts_dsprintf(dsbufp, "(%s) ", prt_name);
+ erts_dsprintf(dsbufp, "does not implement the %s callback!\n", callback);
+ erts_free_port_names(pnp);
+ erts_send_error_to_logger_nogl(dsbufp);
+}
+
+void
+erts_stale_drv_select(Eterm port,
+ ErlDrvEvent hndl,
+ int mode,
+ int deselect)
+{
+ char *type;
+ ErlDrvPort drv_port = internal_port_index(port);
+ ErtsPortNames *pnp = erts_get_port_names(port);
+ erts_dsprintf_buf_t *dsbufp;
+
+ switch (mode) {
+ case ERL_DRV_READ | ERL_DRV_WRITE:
+ type = "Input/Output";
+ goto deselect;
+ case ERL_DRV_WRITE:
+ type = "Output";
+ goto deselect;
+ case ERL_DRV_READ:
+ type = "Input";
+ deselect:
+ if (deselect) {
+ driver_select(drv_port, hndl,
+ mode | ERL_DRV_USE_NO_CALLBACK,
+ 0);
+ }
+ break;
+ default:
+ type = "Event";
+ if (deselect)
+ driver_event(drv_port, hndl, NULL);
+ break;
+ }
+
+ dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp,
+ "%T: %s: %s driver gone away without deselecting!\n",
+ port,
+ pnp->name ? pnp->name : "<unknown>",
+ type);
+ erts_free_port_names(pnp);
+ erts_send_error_to_logger_nogl(dsbufp);
+}
+
+ErtsPortNames *
+erts_get_port_names(Eterm id)
+{
+ ErtsPortNames *pnp;
+ ASSERT(is_nil(id) || is_internal_port(id));
+
+ if (is_not_internal_port(id)) {
+ pnp = erts_alloc(ERTS_ALC_T_PORT_NAMES, sizeof(ErtsPortNames));
+ pnp->name = NULL;
+ pnp->driver_name = NULL;
+ }
+ else {
+ Port* prt = &erts_port[internal_port_index(id)];
+ int do_realloc = 1;
+ int len = -1;
+ size_t pnp_len = sizeof(ErtsPortNames);
+#ifndef DEBUG
+ pnp_len += 100; /* In most cases 100 characters will be enough... */
+#endif
+ pnp = erts_alloc(ERTS_ALC_T_PORT_NAMES, pnp_len);
+ do {
+ int nlen;
+ char *name, *driver_name;
+ if (len > 0) {
+ erts_free(ERTS_ALC_T_PORT_NAMES, pnp);
+ pnp_len = sizeof(ErtsPortNames) + len;
+ pnp = erts_alloc(ERTS_ALC_T_PORT_NAMES, pnp_len);
+ }
+ erts_smp_port_state_lock(prt);
+ if (id != prt->id) {
+ len = nlen = 0;
+ name = driver_name = NULL;
+ }
+ else {
+ name = prt->name;
+ len = nlen = name ? sys_strlen(name) + 1 : 0;
+ driver_name = (prt->drv_ptr ? prt->drv_ptr->name : NULL);
+ len += driver_name ? sys_strlen(driver_name) + 1 : 0;
+ }
+ if (len <= pnp_len - sizeof(ErtsPortNames)) {
+ if (!name)
+ pnp->name = NULL;
+ else {
+ pnp->name = ((char *) pnp) + sizeof(ErtsPortNames);
+ sys_strcpy(pnp->name, name);
+ }
+ if (!driver_name)
+ pnp->driver_name = NULL;
+ else {
+ pnp->driver_name = (((char *) pnp)
+ + sizeof(ErtsPortNames)
+ + nlen);
+ sys_strcpy(pnp->driver_name, driver_name);
+ }
+ do_realloc = 0;
+ }
+ erts_smp_port_state_unlock(prt);
+ } while (do_realloc);
+ }
+ return pnp;
+}
+
+void
+erts_free_port_names(ErtsPortNames *pnp)
+{
+ erts_free(ERTS_ALC_T_PORT_NAMES, pnp);
+}
+
+static void schedule_port_timeout(Port *p)
+{
+ /*
+ * Scheduling of port timeouts can be done without port locking, but
+ * since the task handle is stored in the port structure and the ptimer
+ * structure is protected by the port lock we require the port to be
+ * locked for now...
+ *
+ * TODO: Implement scheduling of port timeouts without locking
+ * the port.
+ * /Rickard
+ */
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(p));
+ (void) erts_port_task_schedule(p->id,
+ &p->timeout_task,
+ ERTS_PORT_TASK_TIMEOUT,
+ (ErlDrvEvent) -1,
+ NULL);
+}
+
+ErlDrvTermData driver_mk_term_nil(void)
+{
+ return driver_term_nil;
+}
+
+void driver_report_exit(int ix, int status)
+{
+ Port* prt = erts_drvport2port(ix);
+ Eterm* hp;
+ Eterm tuple;
+ Process *rp;
+ Eterm pid;
+ ErlHeapFragment *bp = NULL;
+ ErlOffHeap *ohp;
+ ErtsProcLocks rp_locks = 0;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ pid = prt->connected;
+ ASSERT(is_internal_pid(pid));
+ rp = erts_pid2proc_opt(NULL, 0, pid, 0, ERTS_P2P_FLG_SMP_INC_REFC);
+ if (!rp)
+ return;
+
+ hp = erts_alloc_message_heap(3+3, &bp, &ohp, rp, &rp_locks);
+
+ tuple = TUPLE2(hp, am_exit_status, make_small(status));
+ hp += 3;
+ tuple = TUPLE2(hp, prt->id, tuple);
+
+ erts_queue_message(rp, &rp_locks, bp, tuple, am_undefined);
+
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+}
+
+
+static ERTS_INLINE int
+deliver_term_check_port(ErlDrvPort drvport)
+{
+ int res;
+ int ix = (int) drvport;
+ if (ix < 0 || erts_max_ports <= ix)
+ res = -1; /* invalid */
+ else {
+ Port* prt = &erts_port[ix];
+ erts_smp_port_state_lock(prt);
+ if (!(prt->status & ERTS_PORT_SFLGS_INVALID_LOOKUP))
+ res = 1; /* ok */
+ else if (prt->status & ERTS_PORT_SFLG_CLOSING)
+ res = 0; /* closing */
+ else
+ res = -1; /* invalid (dead) */
+ erts_smp_port_state_unlock(prt);
+ }
+ return res;
+}
+
+#define ERTS_B2T_STATES_DEF_STATES_SZ 5
+#define ERTS_B2T_STATES_DEF_STATES_INC 100
+
+struct b2t_states__ {
+ int len;
+ int ix;
+ int used;
+ ErtsBinary2TermState *state;
+ ErtsBinary2TermState def_states[ERTS_B2T_STATES_DEF_STATES_SZ];
+#ifdef DEBUG
+ byte **org_ext;
+ byte *def_org_ext[ERTS_B2T_STATES_DEF_STATES_SZ];
+#endif
+};
+
+static ERTS_INLINE void
+init_b2t_states(struct b2t_states__ *b2tsp)
+{
+ b2tsp->len = ERTS_B2T_STATES_DEF_STATES_SZ;
+ b2tsp->ix = 0;
+ b2tsp->used = 0;
+ b2tsp->state = &b2tsp->def_states[0];
+#ifdef DEBUG
+ b2tsp->org_ext = &b2tsp->def_org_ext[0];
+#endif
+}
+
+static ERTS_INLINE void
+grow_b2t_states(struct b2t_states__ *b2tsp)
+{
+ if (b2tsp->state != &b2tsp->def_states[0]) {
+ b2tsp->len += ERTS_B2T_STATES_DEF_STATES_INC;
+ b2tsp->state = erts_realloc(ERTS_ALC_T_TMP,
+ b2tsp->state,
+ sizeof(ErtsBinary2TermState)*b2tsp->len);
+#ifdef DEBUG
+ b2tsp->org_ext = erts_realloc(ERTS_ALC_T_TMP,
+ b2tsp->org_ext,
+ sizeof(char *)*b2tsp->len);
+#endif
+ }
+ else {
+ ErtsBinary2TermState *new_states;
+ new_states = erts_alloc(ERTS_ALC_T_TMP,
+ (sizeof(ErtsBinary2TermState)
+ *ERTS_B2T_STATES_DEF_STATES_INC));
+ sys_memcpy((void *) new_states,
+ (void *) b2tsp->state,
+ sizeof(ErtsBinary2TermState)*ERTS_B2T_STATES_DEF_STATES_SZ);
+ b2tsp->state = new_states;
+ b2tsp->len = ERTS_B2T_STATES_DEF_STATES_INC;
+#ifdef DEBUG
+ {
+ byte **new_org_ext = erts_alloc(ERTS_ALC_T_TMP,
+ (sizeof(char *)
+ *ERTS_B2T_STATES_DEF_STATES_INC));
+ sys_memcpy((void *) new_org_ext,
+ (void *) b2tsp->org_ext,
+ sizeof(char *)*ERTS_B2T_STATES_DEF_STATES_SZ);
+ b2tsp->org_ext = new_org_ext;
+ }
+#endif
+ }
+}
+
+static ERTS_INLINE void
+cleanup_b2t_states(struct b2t_states__ *b2tsp)
+{
+ if (b2tsp->state != &b2tsp->def_states[0]) {
+ erts_free(ERTS_ALC_T_TMP, b2tsp->state);
+#ifdef DEBUG
+ erts_free(ERTS_ALC_T_TMP, b2tsp->org_ext);
+#endif
+ }
+}
+
+
+/*
+ * Generate an Erlang term from data in an array (representing a simple stack
+ * machine to build terms).
+ * Returns:
+ * -1 on error in input data
+ * 0 if the message was not delivered (bad to pid or closed port)
+ * 1 if the message was delivered successfully
+ */
+
+static int
+driver_deliver_term(ErlDrvPort port,
+ Eterm to,
+ ErlDrvTermData* data,
+ int len)
+{
+#define ERTS_DDT_FAIL do { res = -1; goto done; } while (0)
+ Uint need = 0;
+ int depth = 0;
+ int res;
+ Eterm *hp = NULL, *hp_start = NULL, *hp_end = NULL;
+ ErlDrvTermData* ptr;
+ ErlDrvTermData* ptr_end;
+ DECLARE_ESTACK(stack);
+ Eterm mess = NIL; /* keeps compiler happy */
+ Process* rp = NULL;
+ ErlHeapFragment *bp = NULL;
+ ErlOffHeap *ohp;
+ ErtsProcLocks rp_locks = 0;
+ struct b2t_states__ b2t;
+
+ init_b2t_states(&b2t);
+
+ /*
+ * We used to check port and process here. In the SMP enabled emulator,
+ * however, we don't want to that until we have verified the term.
+ */
+
+ /*
+ * Check ErlDrvTermData for consistency and calculate needed heap size
+ * and stack depth.
+ */
+ ptr = data;
+ ptr_end = ptr + len;
+
+ while (ptr < ptr_end) {
+ ErlDrvTermData tag = *ptr++;
+
+#define ERTS_DDT_CHK_ENOUGH_ARGS(NEED) \
+ if (ptr+((NEED)-1) >= ptr_end) ERTS_DDT_FAIL;
+
+ switch(tag) {
+ case ERL_DRV_NIL: /* no arguments */
+ depth++;
+ break;
+ case ERL_DRV_ATOM: /* atom argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ if (is_not_atom(ptr[0])) ERTS_DDT_FAIL;
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_INT: /* signed int argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ /* check for bignum */
+ if (!IS_SSMALL((Sint)ptr[0]))
+ need += BIG_UINT_HEAP_SIZE; /* use small_to_big */
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_UINT: /* unsigned int argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ /* check for bignum */
+ if (!IS_USMALL(0, (Uint)ptr[0]))
+ need += BIG_UINT_HEAP_SIZE; /* use small_to_big */
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_INT64: /* pointer to signed 64-bit int argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ erts_bld_sint64(NULL, &need, *((Sint64 *) ptr[0]));
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_UINT64: /* pointer to unsigned 64-bit int argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ erts_bld_uint64(NULL, &need, *((Uint64 *) ptr[0]));
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_PORT: /* port argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ if (is_not_internal_port(ptr[0])) ERTS_DDT_FAIL;
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_BINARY: { /* ErlDrvBinary*, size, offs */
+ ErlDrvBinary* b;
+ Uint size;
+ Uint offset;
+ ERTS_DDT_CHK_ENOUGH_ARGS(3);
+ b = (ErlDrvBinary*) ptr[0];
+ size = ptr[1];
+ offset = ptr[2];
+ if (!b || size + offset > b->orig_size)
+ ERTS_DDT_FAIL; /* No binary or outside the binary */
+ need += (size <= ERL_ONHEAP_BIN_LIMIT
+ ? heap_bin_size(size)
+ : PROC_BIN_SIZE);
+ ptr += 3;
+ depth++;
+ break;
+ }
+ case ERL_DRV_BUF2BINARY: { /* char*, size */
+ byte *bufp;
+ Uint size;
+ ERTS_DDT_CHK_ENOUGH_ARGS(2);
+ bufp = (byte *) ptr[0];
+ size = (Uint) ptr[1];
+ if (!bufp && size > 0) ERTS_DDT_FAIL;
+ need += (size <= ERL_ONHEAP_BIN_LIMIT
+ ? heap_bin_size(size)
+ : PROC_BIN_SIZE);
+ ptr += 2;
+ depth++;
+ break;
+ }
+ case ERL_DRV_STRING: /* char*, length */
+ ERTS_DDT_CHK_ENOUGH_ARGS(2);
+ if ((char *) ptr[0] == NULL || (int) ptr[1] < 0) ERTS_DDT_FAIL;
+ need += ptr[1] * 2;
+ ptr += 2;
+ depth++;
+ break;
+ case ERL_DRV_STRING_CONS: /* char*, length */
+ ERTS_DDT_CHK_ENOUGH_ARGS(2);
+ if ((char *) ptr[0] == NULL || (int) ptr[1] < 0) ERTS_DDT_FAIL;
+ need += ptr[1] * 2;
+ if (depth < 1) ERTS_DDT_FAIL;
+ ptr += 2;
+ break;
+ case ERL_DRV_LIST: /* int */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ if ((int) ptr[0] <= 0) ERTS_DDT_FAIL;
+ need += (ptr[0]-1)*2; /* list cells */
+ depth -= ptr[0];
+ if (depth < 0) ERTS_DDT_FAIL;
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_TUPLE: { /* int */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ if ((int) ptr[0] < 0) ERTS_DDT_FAIL;
+ need += ptr[0]+1; /* vector positions + arityval */
+ depth -= ptr[0];
+ if (depth < 0) ERTS_DDT_FAIL;
+ ptr++;
+ depth++;
+ break;
+ }
+ case ERL_DRV_PID: /* pid argument */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ if (is_not_internal_pid(ptr[0])) ERTS_DDT_FAIL;
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_FLOAT: /* double * */
+ ERTS_DDT_CHK_ENOUGH_ARGS(1);
+ need += FLOAT_SIZE_OBJECT;
+ ptr++;
+ depth++;
+ break;
+ case ERL_DRV_EXT2TERM: { /* char *ext, int size */
+ byte* ext;
+ Sint size;
+ Sint hsz;
+
+ ERTS_DDT_CHK_ENOUGH_ARGS(2);
+ ext = (byte *) ptr[0];
+ size = (Sint) ptr[1];
+ if (!ext || size <= 0)
+ ERTS_DDT_FAIL;
+ if (b2t.len <= b2t.ix)
+ grow_b2t_states(&b2t);
+#ifdef DEBUG
+ b2t.org_ext[b2t.ix] = ext;
+#endif
+ hsz = erts_binary2term_prepare(&b2t.state[b2t.ix++], ext, size);
+ if (hsz < 0)
+ ERTS_DDT_FAIL; /* Invalid data */
+ need += hsz;
+ ptr += 2;
+ depth++;
+ break;
+ }
+ default:
+ ERTS_DDT_FAIL;
+ }
+#undef ERTS_DDT_CHK_ENOUGH_ARGS
+ }
+
+ if ((depth != 1) || (ptr != ptr_end))
+ ERTS_DDT_FAIL;
+
+ b2t.used = b2t.ix;
+ b2t.ix = 0;
+
+ /*
+ * The term is OK. Go ahead and validate the port and process.
+ */
+ res = deliver_term_check_port(port);
+ if (res <= 0)
+ goto done;
+
+ rp = erts_pid2proc_opt(NULL, 0, to, rp_locks, ERTS_P2P_FLG_SMP_INC_REFC);
+ if (!rp) {
+ res = 0;
+ goto done;
+ }
+
+ hp_start = hp = erts_alloc_message_heap(need, &bp, &ohp, rp, &rp_locks);
+ hp_end = hp + need;
+
+ /*
+ * Interpret the instructions and build the term.
+ */
+ ptr = data;
+ while (ptr < ptr_end) {
+ ErlDrvTermData tag = *ptr++;
+
+ switch(tag) {
+ case ERL_DRV_NIL: /* no arguments */
+ mess = NIL;
+ break;
+
+ case ERL_DRV_ATOM: /* atom argument */
+ mess = ptr[0];
+ ptr++;
+ break;
+
+ case ERL_DRV_INT: /* signed int argument */
+ if (IS_SSMALL((Sint)ptr[0]))
+ mess = make_small((Sint)ptr[0]);
+ else {
+ mess = small_to_big((Sint)ptr[0], hp);
+ hp += BIG_UINT_HEAP_SIZE;
+ }
+ ptr++;
+ break;
+
+ case ERL_DRV_UINT: /* unsigned int argument */
+ if (IS_USMALL(0, (Uint)ptr[0]))
+ mess = make_small((Uint)ptr[0]);
+ else {
+ mess = uint_to_big((Uint)ptr[0], hp);
+ hp += BIG_UINT_HEAP_SIZE;
+ }
+ ptr++;
+ break;
+
+ case ERL_DRV_INT64: /* pointer to unsigned 64-bit int argument */
+ mess = erts_bld_sint64(&hp, NULL, *((Sint64 *) ptr[0]));
+ ptr++;
+ break;
+
+ case ERL_DRV_UINT64: /* pointer to unsigned 64-bit int argument */
+ mess = erts_bld_uint64(&hp, NULL, *((Uint64 *) ptr[0]));
+ ptr++;
+ break;
+
+ case ERL_DRV_PORT: /* port argument */
+ mess = ptr[0];
+ ptr++;
+ break;
+
+ case ERL_DRV_BINARY: { /* ErlDrvBinary*, size, offs */
+ ErlDrvBinary* b = (ErlDrvBinary*) ptr[0];
+ Uint size = ptr[1];
+ Uint offset = ptr[2];
+
+ if (size <= ERL_ONHEAP_BIN_LIMIT) {
+ ErlHeapBin* hbp = (ErlHeapBin *) hp;
+ hp += heap_bin_size(size);
+ hbp->thing_word = header_heap_bin(size);
+ hbp->size = size;
+ if (size > 0) {
+ sys_memcpy((void *) hbp->data, (void *) (((byte*) b->orig_bytes) + offset), size);
+ }
+ mess = make_binary(hbp);
+ }
+ else {
+ ProcBin* pb = (ProcBin *) hp;
+ driver_binary_inc_refc(b); /* caller will free binary */
+ pb->thing_word = HEADER_PROC_BIN;
+ pb->size = size;
+ pb->next = ohp->mso;
+ ohp->mso = pb;
+ pb->val = ErlDrvBinary2Binary(b);
+ pb->bytes = ((byte*) b->orig_bytes) + offset;
+ pb->flags = 0;
+ mess = make_binary(pb);
+ hp += PROC_BIN_SIZE;
+ ohp->overhead += pb->size / sizeof(Eterm);
+ }
+ ptr += 3;
+ break;
+ }
+
+ case ERL_DRV_BUF2BINARY: { /* char*, size */
+ byte *bufp = (byte *) ptr[0];
+ Uint size = (Uint) ptr[1];
+ if (size <= ERL_ONHEAP_BIN_LIMIT) {
+ ErlHeapBin* hbp = (ErlHeapBin *) hp;
+ hp += heap_bin_size(size);
+ hbp->thing_word = header_heap_bin(size);
+ hbp->size = size;
+ if (size > 0) {
+ ASSERT(bufp);
+ sys_memcpy((void *) hbp->data, (void *) bufp, size);
+ }
+ mess = make_binary(hbp);
+ }
+ else {
+ ProcBin* pbp;
+ Binary* bp = erts_bin_nrml_alloc(size);
+ ASSERT(bufp);
+ bp->flags = 0;
+ bp->orig_size = (long) size;
+ erts_refc_init(&bp->refc, 1);
+ sys_memcpy((void *) bp->orig_bytes, (void *) bufp, size);
+ pbp = (ProcBin *) hp;
+ hp += PROC_BIN_SIZE;
+ pbp->thing_word = HEADER_PROC_BIN;
+ pbp->size = size;
+ pbp->next = ohp->mso;
+ ohp->mso = pbp;
+ pbp->val = bp;
+ pbp->bytes = (byte*) bp->orig_bytes;
+ pbp->flags = 0;
+ ohp->overhead += (pbp->size / sizeof(Eterm));
+ mess = make_binary(pbp);
+ }
+ ptr += 2;
+ break;
+ }
+
+ case ERL_DRV_STRING: /* char*, length */
+ mess = buf_to_intlist(&hp, (char*)ptr[0], ptr[1], NIL);
+ ptr += 2;
+ break;
+
+ case ERL_DRV_STRING_CONS: /* char*, length */
+ mess = ESTACK_POP(stack);
+ mess = buf_to_intlist(&hp, (char*)ptr[0], ptr[1], mess);
+ ptr += 2;
+ break;
+
+ case ERL_DRV_LIST: { /* unsigned */
+ Uint i = (int) ptr[0]; /* i > 0 */
+
+ mess = ESTACK_POP(stack);
+ i--;
+ while(i > 0) {
+ Eterm hd = ESTACK_POP(stack);
+
+ mess = CONS(hp, hd, mess);
+ hp += 2;
+ i--;
+ }
+ ptr++;
+ break;
+ }
+
+ case ERL_DRV_TUPLE: { /* int */
+ int size = (int)ptr[0];
+ Eterm* tp = hp;
+
+ *tp = make_arityval(size);
+ mess = make_tuple(tp);
+
+ tp += size; /* point at last element */
+ hp = tp+1; /* advance "heap" pointer */
+
+ while(size--) {
+ *tp-- = ESTACK_POP(stack);
+ }
+ ptr++;
+ break;
+ }
+
+ case ERL_DRV_PID: /* pid argument */
+ mess = ptr[0];
+ ptr++;
+ break;
+
+ case ERL_DRV_FLOAT: { /* double * */
+ FloatDef f;
+
+ mess = make_float(hp);
+ f.fd = *((double *) ptr[0]);
+ PUT_DOUBLE(f, hp);
+ hp += FLOAT_SIZE_OBJECT;
+ ptr++;
+ break;
+ }
+
+ case ERL_DRV_EXT2TERM: /* char *ext, int size */
+ ASSERT(b2t.org_ext[b2t.ix] == (byte *) ptr[0]);
+ mess = erts_binary2term_create(&b2t.state[b2t.ix++], &hp, ohp);
+ if (mess == THE_NON_VALUE)
+ ERTS_DDT_FAIL;
+ ptr += 2;
+ break;
+
+ }
+ ESTACK_PUSH(stack, mess);
+ }
+
+ res = 1;
+
+ done:
+
+ if (res > 0) {
+ mess = ESTACK_POP(stack); /* get resulting value */
+ if (bp)
+ bp = erts_resize_message_buffer(bp, hp - hp_start, &mess, 1);
+ else {
+ ASSERT(hp);
+ HRelease(rp, hp_end, hp);
+ }
+ /* send message */
+ erts_queue_message(rp, &rp_locks, bp, mess, am_undefined);
+ }
+ else {
+ if (b2t.ix > b2t.used)
+ b2t.used = b2t.ix;
+ for (b2t.ix = 0; b2t.ix < b2t.used; b2t.ix++)
+ erts_binary2term_abort(&b2t.state[b2t.ix]);
+ if (bp)
+ free_message_buffer(bp);
+ else if (hp) {
+ HRelease(rp, hp_end, hp);
+ }
+ }
+#ifdef ERTS_SMP
+ if (rp) {
+ if (rp_locks)
+ erts_smp_proc_unlock(rp, rp_locks);
+ erts_smp_proc_dec_refc(rp);
+ }
+#endif
+ cleanup_b2t_states(&b2t);
+ DESTROY_ESTACK(stack);
+ return res;
+#undef ERTS_DDT_FAIL
+}
+
+
+int
+driver_output_term(ErlDrvPort ix, ErlDrvTermData* data, int len)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if (prt == NULL)
+ return -1;
+ return driver_deliver_term(ix, prt->connected, data, len);
+}
+
+
+int
+driver_send_term(ErlDrvPort ix, ErlDrvTermData to, ErlDrvTermData* data, int len)
+{
+ return driver_deliver_term(ix, to, data, len);
+}
+
+
+/*
+ * Output a binary with hlen bytes from hbuf as list header
+ * and data is len length of bin starting from offset offs.
+ */
+
+int driver_output_binary(ErlDrvPort ix, char* hbuf, int hlen,
+ ErlDrvBinary* bin, int offs, int len)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ if (prt->status & ERTS_PORT_SFLG_CLOSING)
+ return 0;
+
+ prt->bytes_in += (hlen + len);
+ erts_smp_atomic_add(&erts_bytes_in, (long) (hlen + len));
+ if (prt->status & ERTS_PORT_SFLG_DISTRIBUTION) {
+ return erts_net_message(prt,
+ prt->dist_entry,
+ (byte*) hbuf, hlen,
+ (byte*) (bin->orig_bytes+offs), len);
+ }
+ else
+ deliver_bin_message(prt, prt->connected,
+ hbuf, hlen, bin, offs, len);
+ return 0;
+}
+
+/* driver_output2:
+** Delivers hlen bytes from hbuf to the port owner as a list;
+** after that, the port settings apply, buf is sent as binary or list.
+**
+** Example: if hlen = 3 then the port owner will receive the data
+** [H1,H2,H3 | T]
+*/
+int driver_output2(ErlDrvPort ix, char* hbuf, int hlen, char* buf, int len)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if (prt->status & ERTS_PORT_SFLG_CLOSING)
+ return 0;
+
+ prt->bytes_in += (hlen + len);
+ erts_smp_atomic_add(&erts_bytes_in, (long) (hlen + len));
+ if (prt->status & ERTS_PORT_SFLG_DISTRIBUTION) {
+ if (len == 0)
+ return erts_net_message(prt,
+ prt->dist_entry,
+ NULL, 0,
+ (byte*) hbuf, hlen);
+ else
+ return erts_net_message(prt,
+ prt->dist_entry,
+ (byte*) hbuf, hlen,
+ (byte*) buf, len);
+ }
+ else if(prt->status & ERTS_PORT_SFLG_LINEBUF_IO)
+ deliver_linebuf_message(prt, prt->connected, hbuf, hlen, buf, len);
+ else
+ deliver_read_message(prt, prt->connected, hbuf, hlen, buf, len, 0);
+ return 0;
+}
+
+/* Interface functions available to driver writers */
+
+int driver_output(ErlDrvPort ix, char* buf, int len)
+{
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ return driver_output2(ix, NULL, 0, buf, len);
+}
+
+int driver_outputv(ErlDrvPort ix, char* hbuf, int hlen, ErlIOVec* vec, int skip)
+{
+ int n;
+ int len;
+ int size;
+ SysIOVec* iov;
+ ErlDrvBinary** binv;
+ Port* prt;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ size = vec->size - skip; /* Size of remaining bytes in vector */
+ ASSERT(size >= 0);
+ if (size <= 0)
+ return driver_output2(ix, hbuf, hlen, NULL, 0);
+ ASSERT(hlen >= 0); /* debug only */
+ if (hlen < 0)
+ hlen = 0;
+
+ prt = erts_drvport2port(ix);
+ if (prt == NULL)
+ return -1;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ if (prt->status & ERTS_PORT_SFLG_CLOSING)
+ return 0;
+
+ /* size > 0 ! */
+ iov = vec->iov;
+ binv = vec->binv;
+ n = vec->vsize;
+ /* we use do here to strip iov_len=0 from beginning */
+ do {
+ len = iov->iov_len;
+ if (len <= skip) {
+ skip -= len;
+ iov++;
+ binv++;
+ n--;
+ } else {
+ iov->iov_base += skip;
+ iov->iov_len -= skip;
+ skip = 0;
+ }
+ } while (skip > 0);
+
+ /* XXX handle distribution !!! */
+ prt->bytes_in += (hlen + size);
+ erts_smp_atomic_add(&erts_bytes_in, (long) (hlen + size));
+ deliver_vec_message(prt, prt->connected, hbuf, hlen, binv, iov, n, size);
+ return 0;
+}
+
+/* Copy bytes from a vector into a buffer
+** input is a vector a buffer and a max length
+** return bytes copied
+*/
+int driver_vec_to_buf(vec, buf, len)
+ErlIOVec* vec;
+char* buf;
+int len;
+{
+ SysIOVec* iov = vec->iov;
+ int n = vec->vsize;
+ int orig_len = len;
+
+ while(n--) {
+ int ilen = iov->iov_len;
+ if (ilen < len) {
+ sys_memcpy(buf, iov->iov_base, ilen);
+ len -= ilen;
+ buf += ilen;
+ iov++;
+ }
+ else {
+ sys_memcpy(buf, iov->iov_base, len);
+ return orig_len;
+ }
+ }
+ return (orig_len - len);
+}
+
+
+/*
+ * - driver_alloc_binary() is thread safe (efile driver depend on it).
+ * - driver_realloc_binary(), and driver_free_binary() are *not* thread safe.
+ */
+
+/*
+ * reference count on driver binaries...
+ */
+
+long
+driver_binary_get_refc(ErlDrvBinary *dbp)
+{
+ Binary* bp = ErlDrvBinary2Binary(dbp);
+ return erts_refc_read(&bp->refc, 1);
+}
+
+long
+driver_binary_inc_refc(ErlDrvBinary *dbp)
+{
+ Binary* bp = ErlDrvBinary2Binary(dbp);
+ return erts_refc_inctest(&bp->refc, 2);
+}
+
+long
+driver_binary_dec_refc(ErlDrvBinary *dbp)
+{
+ Binary* bp = ErlDrvBinary2Binary(dbp);
+ return erts_refc_dectest(&bp->refc, 1);
+}
+
+
+/*
+** Allocation/Deallocation of binary objects
+*/
+
+ErlDrvBinary*
+driver_alloc_binary(int size)
+{
+ Binary* bin;
+
+ if (size < 0)
+ return NULL;
+
+ bin = erts_bin_drv_alloc_fnf((Uint) size);
+ if (!bin)
+ return NULL; /* The driver write must take action */
+ bin->flags = BIN_FLAG_DRV;
+ erts_refc_init(&bin->refc, 1);
+ bin->orig_size = (long) size;
+ return Binary2ErlDrvBinary(bin);
+}
+
+/* Reallocate space hold by binary */
+
+ErlDrvBinary* driver_realloc_binary(ErlDrvBinary* bin, int size)
+{
+ Binary* oldbin;
+ Binary* newbin;
+
+ if (!bin || size < 0) {
+ erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp,
+ "Bad use of driver_realloc_binary(%p, %d): "
+ "called with ",
+ bin, size);
+ if (!bin) {
+ erts_dsprintf(dsbufp, "NULL pointer as first argument");
+ if (size < 0)
+ erts_dsprintf(dsbufp, ", and ");
+ }
+ if (size < 0) {
+ erts_dsprintf(dsbufp, "negative size as second argument");
+ size = 0;
+ }
+ erts_send_warning_to_logger_nogl(dsbufp);
+ if (!bin)
+ return driver_alloc_binary(size);
+ }
+
+ oldbin = ErlDrvBinary2Binary(bin);
+ newbin = (Binary *) erts_bin_realloc_fnf(oldbin, size);
+ if (!newbin)
+ return NULL;
+
+ newbin->orig_size = size;
+ return Binary2ErlDrvBinary(newbin);
+}
+
+
+void driver_free_binary(dbin)
+ErlDrvBinary* dbin;
+{
+ Binary *bin;
+ if (!dbin) {
+ erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp,
+ "Bad use of driver_free_binary(%p): called with "
+ "NULL pointer as argument", dbin);
+ erts_send_warning_to_logger_nogl(dsbufp);
+ return;
+ }
+
+ bin = ErlDrvBinary2Binary(dbin);
+ if (erts_refc_dectest(&bin->refc, 0) == 0)
+ erts_bin_free(bin);
+}
+
+
+/*
+ * Allocation/deallocation of memory for drivers
+ */
+
+void *driver_alloc(size_t size)
+{
+ return erts_alloc_fnf(ERTS_ALC_T_DRV, (Uint) size);
+}
+
+void *driver_realloc(void *ptr, size_t size)
+{
+ return erts_realloc_fnf(ERTS_ALC_T_DRV, ptr, (Uint) size);
+}
+
+void driver_free(void *ptr)
+{
+ erts_free(ERTS_ALC_T_DRV, ptr);
+}
+
+/*
+ * Port Data Lock
+ */
+
+static void
+pdl_init(void)
+{
+}
+
+static ERTS_INLINE void
+pdl_init_refc(ErlDrvPDL pdl)
+{
+ erts_atomic_init(&pdl->refc, 1);
+}
+
+static ERTS_INLINE long
+pdl_read_refc(ErlDrvPDL pdl)
+{
+ long refc = erts_atomic_read(&pdl->refc);
+ ERTS_LC_ASSERT(refc >= 0);
+ return refc;
+}
+
+static ERTS_INLINE void
+pdl_inc_refc(ErlDrvPDL pdl)
+{
+ erts_atomic_inc(&pdl->refc);
+ ERTS_LC_ASSERT(driver_pdl_get_refc(pdl) > 1);
+}
+
+static ERTS_INLINE long
+pdl_inctest_refc(ErlDrvPDL pdl)
+{
+ long refc = erts_atomic_inctest(&pdl->refc);
+ ERTS_LC_ASSERT(refc > 1);
+ return refc;
+}
+
+#if 0 /* unused */
+static ERTS_INLINE void
+pdl_dec_refc(ErlDrvPDL pdl)
+{
+ erts_atomic_dec(&pdl->refc);
+ ERTS_LC_ASSERT(driver_pdl_get_refc(pdl) > 0);
+}
+#endif
+
+static ERTS_INLINE long
+pdl_dectest_refc(ErlDrvPDL pdl)
+{
+ long refc = erts_atomic_dectest(&pdl->refc);
+ ERTS_LC_ASSERT(refc >= 0);
+ return refc;
+}
+
+static ERTS_INLINE void pdl_destroy(ErlDrvPDL pdl)
+{
+ ERTS_LC_ASSERT(driver_pdl_get_refc(pdl) == 0);
+ erts_mtx_destroy(&pdl->mtx);
+ erts_free(ERTS_ALC_T_PORT_DATA_LOCK, pdl);
+}
+
+/*
+ * exported driver_pdl_* functions ...
+ */
+
+ErlDrvPDL
+driver_pdl_create(ErlDrvPort dp)
+{
+ ErlDrvPDL pdl;
+ Port *pp = erts_drvport2port(dp);
+ if (!pp || pp->port_data_lock)
+ return NULL;
+ pdl = erts_alloc(ERTS_ALC_T_PORT_DATA_LOCK,
+ sizeof(struct erl_drv_port_data_lock));
+ erts_mtx_init(&pdl->mtx, "port_data_lock");
+ pdl_init_refc(pdl);
+ pp->port_data_lock = pdl;
+#ifdef HARDDEBUG
+ erts_fprintf(stderr, "driver_pdl_create(%T) -> 0x%08X\r\n",pp->id,(unsigned) pdl);
+#endif
+ return pdl;
+}
+
+void
+driver_pdl_lock(ErlDrvPDL pdl)
+{
+#ifdef HARDDEBUG
+ erts_fprintf(stderr, "driver_pdl_lock(0x%08X)\r\n",(unsigned) pdl);
+#endif
+ pdl_inc_refc(pdl);
+ erts_mtx_lock(&pdl->mtx);
+}
+
+void
+driver_pdl_unlock(ErlDrvPDL pdl)
+{
+ long refc;
+#ifdef HARDDEBUG
+ erts_fprintf(stderr, "driver_pdl_unlock(0x%08X)\r\n",(unsigned) pdl);
+#endif
+ erts_mtx_unlock(&pdl->mtx);
+ refc = pdl_dectest_refc(pdl);
+ if (!refc)
+ pdl_destroy(pdl);
+}
+
+long
+driver_pdl_get_refc(ErlDrvPDL pdl)
+{
+ return pdl_read_refc(pdl);
+}
+
+long
+driver_pdl_inc_refc(ErlDrvPDL pdl)
+{
+ long refc = pdl_inctest_refc(pdl);
+#ifdef HARDDEBUG
+ erts_fprintf(stderr, "driver_pdl_inc_refc(0x%08X) -> %ld\r\n",(unsigned) pdl, refc);
+#endif
+ return refc;
+}
+
+long
+driver_pdl_dec_refc(ErlDrvPDL pdl)
+{
+ long refc = pdl_dectest_refc(pdl);
+#ifdef HARDDEBUG
+ erts_fprintf(stderr, "driver_pdl_dec_refc(0x%08X) -> %ld\r\n",(unsigned) pdl, refc);
+#endif
+ if (!refc)
+ pdl_destroy(pdl);
+ return refc;
+}
+
+/* expand queue to hold n elements in tail or head */
+static int expandq(ErlIOQueue* q, int n, int tail)
+/* tail: 0 if make room in head, make room in tail otherwise */
+{
+ int h_sz; /* room before header */
+ int t_sz; /* room after tail */
+ int q_sz; /* occupied */
+ int nvsz;
+ SysIOVec* niov;
+ ErlDrvBinary** nbinv;
+
+ h_sz = q->v_head - q->v_start;
+ t_sz = q->v_end - q->v_tail;
+ q_sz = q->v_tail - q->v_head;
+
+ if (tail && (n <= t_sz)) /* do we need to expand tail? */
+ return 0;
+ else if (!tail && (n <= h_sz)) /* do we need to expand head? */
+ return 0;
+ else if (n > (h_sz + t_sz)) { /* need to allocate */
+ /* we may get little extra but it ok */
+ nvsz = (q->v_end - q->v_start) + n;
+
+ niov = erts_alloc_fnf(ERTS_ALC_T_IOQ, nvsz * sizeof(SysIOVec));
+ if (!niov)
+ return -1;
+ nbinv = erts_alloc_fnf(ERTS_ALC_T_IOQ, nvsz * sizeof(ErlDrvBinary**));
+ if (!nbinv) {
+ erts_free(ERTS_ALC_T_IOQ, (void *) niov);
+ return -1;
+ }
+ if (tail) {
+ sys_memcpy(niov, q->v_head, q_sz*sizeof(SysIOVec));
+ if (q->v_start != q->v_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->v_start);
+ q->v_start = niov;
+ q->v_end = niov + nvsz;
+ q->v_head = q->v_start;
+ q->v_tail = q->v_head + q_sz;
+
+ sys_memcpy(nbinv, q->b_head, q_sz*sizeof(ErlDrvBinary*));
+ if (q->b_start != q->b_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->b_start);
+ q->b_start = nbinv;
+ q->b_end = nbinv + nvsz;
+ q->b_head = q->b_start;
+ q->b_tail = q->b_head + q_sz;
+ }
+ else {
+ sys_memcpy(niov+nvsz-q_sz, q->v_head, q_sz*sizeof(SysIOVec));
+ if (q->v_start != q->v_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->v_start);
+ q->v_start = niov;
+ q->v_end = niov + nvsz;
+ q->v_tail = q->v_end;
+ q->v_head = q->v_tail - q_sz;
+
+ sys_memcpy(nbinv+nvsz-q_sz, q->b_head, q_sz*sizeof(ErlDrvBinary*));
+ if (q->b_start != q->b_small)
+ erts_free(ERTS_ALC_T_IOQ, (void *) q->b_start);
+ q->b_start = nbinv;
+ q->b_end = nbinv + nvsz;
+ q->b_tail = q->b_end;
+ q->b_head = q->b_tail - q_sz;
+ }
+ }
+ else if (tail) { /* move to beginning to make room in tail */
+ sys_memmove(q->v_start, q->v_head, q_sz*sizeof(SysIOVec));
+ q->v_head = q->v_start;
+ q->v_tail = q->v_head + q_sz;
+ sys_memmove(q->b_start, q->b_head, q_sz*sizeof(ErlDrvBinary*));
+ q->b_head = q->b_start;
+ q->b_tail = q->b_head + q_sz;
+ }
+ else { /* move to end to make room */
+ sys_memmove(q->v_end-q_sz, q->v_head, q_sz*sizeof(SysIOVec));
+ q->v_tail = q->v_end;
+ q->v_head = q->v_tail-q_sz;
+ sys_memmove(q->b_end-q_sz, q->b_head, q_sz*sizeof(ErlDrvBinary*));
+ q->b_tail = q->b_end;
+ q->b_head = q->b_tail-q_sz;
+ }
+
+ return 0;
+}
+
+
+
+/* Put elements from vec at q tail */
+int driver_enqv(ErlDrvPort ix, ErlIOVec* vec, int skip)
+{
+ int n;
+ int len;
+ int size;
+ SysIOVec* iov;
+ ErlDrvBinary** binv;
+ ErlDrvBinary* b;
+ ErlIOQueue* q = drvport2ioq(ix);
+
+ if (q == NULL)
+ return -1;
+
+ size = vec->size - skip;
+ ASSERT(size >= 0); /* debug only */
+ if (size <= 0)
+ return 0;
+
+ iov = vec->iov;
+ binv = vec->binv;
+ n = vec->vsize;
+
+ /* we use do here to strip iov_len=0 from beginning */
+ do {
+ len = iov->iov_len;
+ if (len <= skip) {
+ skip -= len;
+ iov++;
+ binv++;
+ n--;
+ }
+ else {
+ iov->iov_base += skip;
+ iov->iov_len -= skip;
+ skip = 0;
+ }
+ } while(skip > 0);
+
+ if (q->v_tail + n >= q->v_end)
+ expandq(q, n, 1);
+
+ /* Queue and reference all binaries (remove zero length items) */
+ while(n--) {
+ if ((len = iov->iov_len) > 0) {
+ if ((b = *binv) == NULL) { /* speical case create binary ! */
+ b = driver_alloc_binary(len);
+ sys_memcpy(b->orig_bytes, iov->iov_base, len);
+ *q->b_tail++ = b;
+ q->v_tail->iov_len = len;
+ q->v_tail->iov_base = b->orig_bytes;
+ q->v_tail++;
+ }
+ else {
+ driver_binary_inc_refc(b);
+ *q->b_tail++ = b;
+ *q->v_tail++ = *iov;
+ }
+ }
+ iov++;
+ binv++;
+ }
+ q->size += size; /* update total size in queue */
+ return 0;
+}
+
+/* Put elements from vec at q head */
+int driver_pushqv(ErlDrvPort ix, ErlIOVec* vec, int skip)
+{
+ int n;
+ int len;
+ int size;
+ SysIOVec* iov;
+ ErlDrvBinary** binv;
+ ErlDrvBinary* b;
+ ErlIOQueue* q = drvport2ioq(ix);
+
+ if (q == NULL)
+ return -1;
+
+ if ((size = vec->size - skip) <= 0)
+ return 0;
+ iov = vec->iov;
+ binv = vec->binv;
+ n = vec->vsize;
+
+ /* we use do here to strip iov_len=0 from beginning */
+ do {
+ len = iov->iov_len;
+ if (len <= skip) {
+ skip -= len;
+ iov++;
+ binv++;
+ n--;
+ }
+ else {
+ iov->iov_base += skip;
+ iov->iov_len -= skip;
+ skip = 0;
+ }
+ } while(skip > 0);
+
+ if (q->v_head - n < q->v_start)
+ expandq(q, n, 0);
+
+ /* Queue and reference all binaries (remove zero length items) */
+ iov += (n-1); /* move to end */
+ binv += (n-1); /* move to end */
+ while(n--) {
+ if ((len = iov->iov_len) > 0) {
+ if ((b = *binv) == NULL) { /* speical case create binary ! */
+ b = driver_alloc_binary(len);
+ sys_memcpy(b->orig_bytes, iov->iov_base, len);
+ *--q->b_head = b;
+ q->v_head--;
+ q->v_head->iov_len = len;
+ q->v_head->iov_base = b->orig_bytes;
+ }
+ else {
+ driver_binary_inc_refc(b);
+ *--q->b_head = b;
+ *--q->v_head = *iov;
+ }
+ }
+ iov--;
+ binv--;
+ }
+ q->size += size; /* update total size in queue */
+ return 0;
+}
+
+
+/*
+** Remove size bytes from queue head
+** Return number of bytes that remain in queue
+*/
+int driver_deq(ErlDrvPort ix, int size)
+{
+ ErlIOQueue* q = drvport2ioq(ix);
+ int len;
+ int sz;
+
+ if ((q == NULL) || (sz = (q->size - size)) < 0)
+ return -1;
+ q->size = sz;
+ while (size > 0) {
+ ASSERT(q->v_head != q->v_tail);
+
+ len = q->v_head->iov_len;
+ if (len <= size) {
+ size -= len;
+ driver_free_binary(*q->b_head);
+ *q->b_head++ = NULL;
+ q->v_head++;
+ }
+ else {
+ q->v_head->iov_base += size;
+ q->v_head->iov_len -= size;
+ size = 0;
+ }
+ }
+
+ /* restart pointers (optimised for enq) */
+ if (q->v_head == q->v_tail) {
+ q->v_head = q->v_tail = q->v_start;
+ q->b_head = q->b_tail = q->b_start;
+ }
+ return sz;
+}
+
+
+int driver_peekqv(ErlDrvPort ix, ErlIOVec *ev) {
+ ErlIOQueue *q = drvport2ioq(ix);
+ ASSERT(ev);
+
+ if (! q) {
+ return -1;
+ } else {
+ if ((ev->vsize = q->v_tail - q->v_head) == 0) {
+ ev->size = 0;
+ ev->iov = NULL;
+ ev->binv = NULL;
+ } else {
+ ev->size = q->size;
+ ev->iov = q->v_head;
+ ev->binv = q->b_head;
+ }
+ return q->size;
+ }
+}
+
+SysIOVec* driver_peekq(ErlDrvPort ix, int* vlenp) /* length of io-vector */
+{
+ ErlIOQueue* q = drvport2ioq(ix);
+
+ if (q == NULL) {
+ *vlenp = -1;
+ return NULL;
+ }
+ if ((*vlenp = (q->v_tail - q->v_head)) == 0)
+ return NULL;
+ return q->v_head;
+}
+
+
+int driver_sizeq(ErlDrvPort ix)
+{
+ ErlIOQueue* q = drvport2ioq(ix);
+
+ if (q == NULL)
+ return -1;
+ return q->size;
+}
+
+
+/* Utils */
+
+/* Enqueue a binary */
+int driver_enq_bin(ErlDrvPort ix, ErlDrvBinary* bin, int offs, int len)
+{
+ SysIOVec iov;
+ ErlIOVec ev;
+
+ ASSERT(len >= 0);
+ if (len == 0)
+ return 0;
+ iov.iov_base = bin->orig_bytes + offs;
+ iov.iov_len = len;
+ ev.vsize = 1;
+ ev.size = len;
+ ev.iov = &iov;
+ ev.binv = &bin;
+ return driver_enqv(ix, &ev, 0);
+}
+
+int driver_enq(ErlDrvPort ix, char* buffer, int len)
+{
+ int code;
+ ErlDrvBinary* bin;
+
+ ASSERT(len >= 0);
+ if (len == 0)
+ return 0;
+ if ((bin = driver_alloc_binary(len)) == NULL)
+ return -1;
+ sys_memcpy(bin->orig_bytes, buffer, len);
+ code = driver_enq_bin(ix, bin, 0, len);
+ driver_free_binary(bin); /* dereference */
+ return code;
+}
+
+int driver_pushq_bin(ErlDrvPort ix, ErlDrvBinary* bin, int offs, int len)
+{
+ SysIOVec iov;
+ ErlIOVec ev;
+
+ ASSERT(len >= 0);
+ if (len == 0)
+ return 0;
+ iov.iov_base = bin->orig_bytes + offs;
+ iov.iov_len = len;
+ ev.vsize = 1;
+ ev.size = len;
+ ev.iov = &iov;
+ ev.binv = &bin;
+ return driver_pushqv(ix, &ev, 0);
+}
+
+int driver_pushq(ErlDrvPort ix, char* buffer, int len)
+{
+ int code;
+ ErlDrvBinary* bin;
+
+ ASSERT(len >= 0);
+ if (len == 0)
+ return 0;
+
+ if ((bin = driver_alloc_binary(len)) == NULL)
+ return -1;
+ sys_memcpy(bin->orig_bytes, buffer, len);
+ code = driver_pushq_bin(ix, bin, 0, len);
+ driver_free_binary(bin); /* dereference */
+ return code;
+}
+
+static ERTS_INLINE void
+drv_cancel_timer(Port *prt)
+{
+#ifdef ERTS_SMP
+ erts_cancel_smp_ptimer(prt->ptimer);
+#else
+ erl_cancel_timer(&prt->tm);
+#endif
+ if (erts_port_task_is_scheduled(&prt->timeout_task))
+ erts_port_task_abort(prt->id, &prt->timeout_task);
+}
+
+int driver_set_timer(ErlDrvPort ix, Uint t)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ if (prt->drv_ptr->timeout == NULL)
+ return -1;
+ drv_cancel_timer(prt);
+#ifdef ERTS_SMP
+ erts_create_smp_ptimer(&prt->ptimer,
+ prt->id,
+ (ErlTimeoutProc) schedule_port_timeout,
+ t);
+#else
+ erl_set_timer(&prt->tm,
+ (ErlTimeoutProc) schedule_port_timeout,
+ NULL,
+ prt,
+ t);
+#endif
+ return 0;
+}
+
+int driver_cancel_timer(ErlDrvPort ix)
+{
+ Port* prt = erts_drvport2port(ix);
+ if (prt == NULL)
+ return -1;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ drv_cancel_timer(prt);
+ return 0;
+}
+
+
+int
+driver_read_timer(ErlDrvPort ix, unsigned long* t)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+#ifdef ERTS_SMP
+ *t = prt->ptimer ? time_left(&prt->ptimer->timer.tm) : 0;
+#else
+ *t = time_left(&prt->tm);
+#endif
+ return 0;
+}
+
+int
+driver_get_now(ErlDrvNowData *now_data)
+{
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (now_data == NULL) {
+ return -1;
+ }
+ get_now(&(now_data->megasecs),&(now_data->secs),&(now_data->microsecs));
+ return 0;
+}
+
+static void ref_to_driver_monitor(Eterm ref, ErlDrvMonitor *mon)
+{
+ RefThing *refp;
+ ASSERT(is_internal_ref(ref));
+ ASSERT(sizeof(RefThing) <= sizeof(ErlDrvMonitor));
+ refp = ref_thing_ptr(ref);
+ memset(mon,0,sizeof(ErlDrvMonitor));
+ memcpy(mon,refp,sizeof(RefThing));
+}
+
+int driver_monitor_process(ErlDrvPort port,
+ ErlDrvTermData process,
+ ErlDrvMonitor *monitor)
+{
+ Port *prt = erts_drvport2port(port);
+ Process *rp;
+ Eterm ref;
+ Eterm buf[REF_THING_SIZE];
+ if (prt->drv_ptr->process_exit == NULL) {
+ return -1;
+ }
+ rp = erts_pid2proc_opt(NULL, 0,
+ (Eterm) process, ERTS_PROC_LOCK_LINK,
+ ERTS_P2P_FLG_ALLOW_OTHER_X);
+ if (!rp) {
+ return 1;
+ }
+ ref = erts_make_ref_in_buffer(buf);
+ erts_add_monitor(&(prt->monitors), MON_ORIGIN, ref, rp->id, NIL);
+ erts_add_monitor(&(rp->monitors), MON_TARGET, ref, prt->id, NIL);
+
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+ ref_to_driver_monitor(ref,monitor);
+ return 0;
+}
+
+int driver_demonitor_process(ErlDrvPort port,
+ const ErlDrvMonitor *monitor)
+{
+ Port *prt = erts_drvport2port(port);
+ Process *rp;
+ Eterm ref;
+ Eterm buf[REF_THING_SIZE];
+ ErtsMonitor *mon;
+ Eterm to;
+
+ memcpy(buf,monitor,sizeof(Eterm)*REF_THING_SIZE);
+ ref = make_internal_ref(buf);
+ mon = erts_lookup_monitor(prt->monitors, ref);
+ if (mon == NULL) {
+ return 1;
+ }
+ ASSERT(mon->type == MON_ORIGIN);
+ to = mon->pid;
+ ASSERT(is_internal_pid(to));
+ rp = erts_pid2proc_opt(NULL,
+ 0,
+ to,
+ ERTS_PROC_LOCK_LINK,
+ ERTS_P2P_FLG_ALLOW_OTHER_X);
+ mon = erts_remove_monitor(&(prt->monitors), ref);
+ if (mon) {
+ erts_destroy_monitor(mon);
+ }
+ if (rp) {
+ ErtsMonitor *rmon;
+ rmon = erts_remove_monitor(&(rp->monitors), ref);
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+ if (rmon != NULL) {
+ erts_destroy_monitor(rmon);
+ }
+ }
+ return 0;
+}
+
+ErlDrvTermData driver_get_monitored_process(ErlDrvPort port,
+ const ErlDrvMonitor *monitor)
+{
+ Port *prt = erts_drvport2port(port);
+ Eterm ref;
+ Eterm buf[REF_THING_SIZE];
+ ErtsMonitor *mon;
+ Eterm to;
+
+ memcpy(buf,monitor,sizeof(Eterm)*REF_THING_SIZE);
+ ref = make_internal_ref(buf);
+ mon = erts_lookup_monitor(prt->monitors, ref);
+ if (mon == NULL) {
+ return driver_term_nil;
+ }
+ ASSERT(mon->type == MON_ORIGIN);
+ to = mon->pid;
+ ASSERT(is_internal_pid(to));
+ return (ErlDrvTermData) to;
+}
+
+int driver_compare_monitors(const ErlDrvMonitor *monitor1,
+ const ErlDrvMonitor *monitor2)
+{
+ return memcmp(monitor1,monitor2,sizeof(ErlDrvMonitor));
+}
+
+void erts_fire_port_monitor(Port *prt, Eterm ref)
+{
+ ErtsMonitor *rmon;
+ void (*callback)(ErlDrvData drv_data, ErlDrvMonitor *monitor);
+ ErlDrvMonitor drv_monitor;
+ int fpe_was_unmasked;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ ASSERT(prt->drv_ptr != NULL);
+
+ if (erts_lookup_monitor(prt->monitors,ref) == NULL) {
+ return;
+ }
+ callback = prt->drv_ptr->process_exit;
+ ASSERT(callback != NULL);
+ ref_to_driver_monitor(ref,&drv_monitor);
+ fpe_was_unmasked = erts_block_fpe();
+ (*callback)((ErlDrvData) (prt->drv_data), &drv_monitor);
+ erts_unblock_fpe(fpe_was_unmasked);
+ /* remove monitor *after* callback */
+ rmon = erts_remove_monitor(&(prt->monitors),ref);
+ if (rmon) {
+ erts_destroy_monitor(rmon);
+ }
+}
+
+
+static int
+driver_failure_term(ErlDrvPort ix, Eterm term, int eof)
+{
+ Port* prt = erts_drvport2port(ix);
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ if (eof)
+ flush_linebuf_messages(prt);
+ if (prt->status & ERTS_PORT_SFLG_CLOSING) {
+ terminate_port(prt);
+ } else if (eof && (prt->status & ERTS_PORT_SFLG_SOFT_EOF)) {
+ deliver_result(prt->id, prt->connected, am_eof);
+ } else {
+ /* XXX UGLY WORK AROUND, Let do_exit_port terminate the port */
+ if (prt->port_data_lock)
+ driver_pdl_lock(prt->port_data_lock);
+ prt->ioq.size = 0;
+ if (prt->port_data_lock)
+ driver_pdl_unlock(prt->port_data_lock);
+ erts_do_exit_port(prt, prt->id, eof ? am_normal : term);
+ }
+ return 0;
+}
+
+
+
+/*
+** Do a (soft) exit. unlink the connected process before doing
+** driver posix error or (normal)
+*/
+int driver_exit(ErlDrvPort ix, int err)
+{
+ Port* prt = erts_drvport2port(ix);
+ Process* rp;
+ ErtsLink *lnk, *rlnk = NULL;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ if (prt == NULL)
+ return -1;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+
+ rp = erts_pid2proc(NULL, 0, prt->connected, ERTS_PROC_LOCK_LINK);
+ if (rp) {
+ rlnk = erts_remove_link(&(rp->nlinks),prt->id);
+ }
+
+ lnk = erts_remove_link(&(prt->nlinks),prt->connected);
+
+#ifdef ERTS_SMP
+ if (rp)
+ erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
+#endif
+
+ if (rlnk != NULL) {
+ erts_destroy_link(rlnk);
+ }
+
+ if (lnk != NULL) {
+ erts_destroy_link(lnk);
+ }
+
+ if (err == 0)
+ return driver_failure_term(ix, am_normal, 0);
+ else {
+ char* err_str = erl_errno_id(err);
+ Eterm am_err = am_atom_put(err_str, sys_strlen(err_str));
+ return driver_failure_term(ix, am_err, 0);
+ }
+}
+
+
+int driver_failure(ErlDrvPort ix, int code)
+{
+ return driver_failure_term(ix, make_small(code), code == 0);
+}
+
+int driver_failure_atom(ErlDrvPort ix, char* string)
+{
+ Eterm am = am_atom_put(string, strlen(string));
+ return driver_failure_term(ix, am, 0);
+}
+
+int driver_failure_posix(ErlDrvPort ix, int err)
+{
+ return driver_failure_atom(ix, erl_errno_id(err));
+}
+
+int driver_failure_eof(ErlDrvPort ix)
+{
+ return driver_failure_term(ix, NIL, 1);
+}
+
+
+
+ErlDrvTermData driver_mk_atom(char* string)
+{
+ Eterm am = am_atom_put(string, sys_strlen(string));
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ return (ErlDrvTermData) am;
+}
+
+ErlDrvTermData driver_mk_port(ErlDrvPort ix)
+{
+ Port* prt = erts_drvport2port(ix);
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ return (ErlDrvTermData) prt->id;
+}
+
+ErlDrvTermData driver_connected(ErlDrvPort ix)
+{
+ Port* prt = erts_drvport2port(ix);
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ if (prt == NULL)
+ return NIL;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ return prt->connected;
+}
+
+ErlDrvTermData driver_caller(ErlDrvPort ix)
+{
+ Port* prt = erts_drvport2port(ix);
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+ if (prt == NULL)
+ return NIL;
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ return prt->caller;
+}
+
+int driver_lock_driver(ErlDrvPort ix)
+{
+ Port* prt = erts_drvport2port(ix);
+ DE_Handle* dh;
+
+ ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+
+ if (prt == NULL) return -1;
+
+ ERTS_SMP_LC_ASSERT(erts_lc_is_port_locked(prt));
+ if ((dh = (DE_Handle*)prt->drv_ptr->handle ) == NULL) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ return -1;
+ }
+ erts_ddll_lock_driver(dh, prt->drv_ptr->name);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ return 0;
+}
+
+
+static int maybe_lock_driver_list(void)
+{
+ void *rec_lock;
+ rec_lock = erts_smp_tsd_get(driver_list_lock_status_key);
+ if (rec_lock == 0) {
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ return 1;
+ }
+ return 0;
+}
+static void maybe_unlock_driver_list(int doit)
+{
+ if (doit) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+}
+/*
+ These old interfaces are certainly not MT friendly. Hopefully they are only used internally,
+ but you never know, so they are kept for BC. As The sys ddll code has no notion
+ of locking, I use the driver list lock to mutex this from the code in erl_bif_ddll.c.
+ To allow dynamic code loading in the init functions of a driver, recursive locking is
+ handled as in add_driver_entry etc.
+ A TSD variable holds the last error for a thread, so that code like
+ ...
+ x = driver_dl_open(...);
+ if (x == NULL)
+ y = driver_dl_error();
+ ...
+ works as long as execution happens in one driver callback even in an SMP emulator.
+ Writing code using these interfaces spanning several driver callbacks between loading/lookup
+ and error handling may give undesired results...
+*/
+void *driver_dl_open(char * path)
+{
+ void *ptr;
+ int res;
+ int *last_error_p = erts_smp_tsd_get(driver_list_last_error_key);
+ int locked = maybe_lock_driver_list();
+ if ((res = erts_sys_ddll_open(path, &ptr)) == 0) {
+ maybe_unlock_driver_list(locked);
+ return ptr;
+ } else {
+ if (!last_error_p) {
+ last_error_p = erts_alloc(ERTS_ALC_T_DDLL_ERRCODES, sizeof(int));
+ erts_smp_tsd_set(driver_list_last_error_key,last_error_p);
+ }
+ *last_error_p = res;
+ maybe_unlock_driver_list(locked);
+ return NULL;
+ }
+}
+
+void *driver_dl_sym(void * handle, char *func_name)
+{
+ void *ptr;
+ int res;
+ int *last_error_p = erts_smp_tsd_get(driver_list_lock_status_key);
+ int locked = maybe_lock_driver_list();
+ if ((res = erts_sys_ddll_sym(handle, func_name, &ptr)) == 0) {
+ maybe_unlock_driver_list(locked);
+ return ptr;
+ } else {
+ if (!last_error_p) {
+ last_error_p = erts_alloc(ERTS_ALC_T_DDLL_ERRCODES, sizeof(int));
+ erts_smp_tsd_set(driver_list_lock_status_key,last_error_p);
+ }
+ *last_error_p = res;
+ maybe_unlock_driver_list(locked);
+ return NULL;
+ }
+}
+
+int driver_dl_close(void *handle)
+{
+ int res;
+ int locked = maybe_lock_driver_list();
+ res = erts_sys_ddll_close(handle);
+ maybe_unlock_driver_list(locked);
+ return res;
+}
+
+char *driver_dl_error(void)
+{
+ char *res;
+ int *last_error_p = erts_smp_tsd_get(driver_list_lock_status_key);
+ int locked = maybe_lock_driver_list();
+ res = erts_ddll_error((last_error_p != NULL) ? (*last_error_p) : ERL_DE_ERROR_UNSPECIFIED);
+ maybe_unlock_driver_list(locked);
+ return res;
+}
+
+
+#define ERL_DRV_SYS_INFO_SIZE(LAST_FIELD) \
+ (((size_t) &((ErlDrvSysInfo *) 0)->LAST_FIELD) \
+ + sizeof(((ErlDrvSysInfo *) 0)->LAST_FIELD))
+
+void
+driver_system_info(ErlDrvSysInfo *sip, size_t si_size)
+{
+ /*
+ * When adding fields in the ErlDrvSysInfo struct
+ * remember to increment ERL_DRV_EXTENDED_MINOR_VERSION
+ */
+
+ /*
+ * 'smp_support' is the last field in the first version
+ * of ErlDrvSysInfo (introduced in driver version 1.0).
+ */
+ if (!sip || si_size < ERL_DRV_SYS_INFO_SIZE(smp_support))
+ erl_exit(1,
+ "driver_system_info(%p, %ld) called with invalid arguments\n",
+ sip, si_size);
+
+ /*
+ * 'smp_support' is the last field in the first version
+ * of ErlDrvSysInfo (introduced in driver version 1.0).
+ */
+ if (si_size >= ERL_DRV_SYS_INFO_SIZE(smp_support)) {
+ sip->driver_major_version = ERL_DRV_EXTENDED_MAJOR_VERSION;
+ sip->driver_minor_version = ERL_DRV_EXTENDED_MINOR_VERSION;
+ sip->erts_version = ERLANG_VERSION;
+ sip->otp_release = ERLANG_OTP_RELEASE;
+ sip->thread_support =
+#ifdef USE_THREADS
+ 1
+#else
+ 0
+#endif
+ ;
+ sip->smp_support =
+#ifdef ERTS_SMP
+ 1
+#else
+ 0
+#endif
+ ;
+
+ }
+
+ /*
+ * 'scheduler_threads' is the last field in the second version
+ * of ErlDrvSysInfo (introduced in driver version 1.1).
+ */
+ if (si_size >= ERL_DRV_SYS_INFO_SIZE(scheduler_threads)) {
+ sip->async_threads = erts_async_max_threads;
+ sip->scheduler_threads = erts_no_schedulers;
+ }
+
+}
+
+
+static ERTS_INLINE Port *
+get_current_port(void)
+{
+ ErtsSchedulerData *esdp = erts_get_scheduler_data();
+ ASSERT(esdp);
+ ASSERT(esdp->current_port);
+ return esdp->current_port;
+}
+
+/*
+ * Default callbacks used if not supplied by driver.
+ */
+
+static void
+no_output_callback(ErlDrvData drv_data, char *buf, int len)
+{
+
+}
+
+static void
+no_event_callback(ErlDrvData drv_data, ErlDrvEvent event, ErlDrvEventData event_data)
+{
+ Port *prt = get_current_port();
+ report_missing_drv_callback(prt, "Event", "event()");
+ driver_event((ErlDrvPort) internal_port_index(prt->id), event, NULL);
+}
+
+static void
+no_ready_input_callback(ErlDrvData drv_data, ErlDrvEvent event)
+{
+ Port *prt = get_current_port();
+ report_missing_drv_callback(prt, "Input", "ready_input()");
+ driver_select((ErlDrvPort) internal_port_index(prt->id), event,
+ (ERL_DRV_READ | ERL_DRV_USE_NO_CALLBACK), 0);
+}
+
+static void
+no_ready_output_callback(ErlDrvData drv_data, ErlDrvEvent event)
+{
+ Port *prt = get_current_port();
+ report_missing_drv_callback(prt, "Output", "ready_output()");
+ driver_select((ErlDrvPort) internal_port_index(prt->id), event,
+ (ERL_DRV_WRITE | ERL_DRV_USE_NO_CALLBACK), 0);
+}
+
+static void
+no_timeout_callback(ErlDrvData drv_data)
+{
+
+}
+
+static void
+no_stop_select_callback(ErlDrvEvent event, void* private)
+{
+ erts_dsprintf_buf_t *dsbufp = erts_create_logger_dsbuf();
+ erts_dsprintf(dsbufp, "Driver does not implement stop_select callback "
+ "(event=%ld, private=%p)!\n", (long)event, private);
+ erts_send_error_to_logger_nogl(dsbufp);
+}
+
+
+static int
+init_driver(erts_driver_t *drv, ErlDrvEntry *de, DE_Handle *handle)
+{
+ drv->name = de->driver_name;
+ if (de->extended_marker == ERL_DRV_EXTENDED_MARKER) {
+ drv->version.major = de->major_version;
+ drv->version.minor = de->minor_version;
+ drv->flags = de->driver_flags;
+ }
+ else {
+ drv->version.major = 0;
+ drv->version.minor = 0;
+ drv->flags = 0;
+ }
+ drv->handle = handle;
+#ifdef ERTS_SMP
+ if (drv->flags & ERL_DRV_FLAG_USE_PORT_LOCKING)
+ drv->lock = NULL;
+ else {
+ drv->lock = erts_alloc(ERTS_ALC_T_DRIVER_LOCK,
+ sizeof(erts_smp_mtx_t));
+ erts_smp_mtx_init_x(drv->lock,
+ "driver_lock",
+#if defined(ERTS_ENABLE_LOCK_CHECK) || defined(ERTS_ENABLE_LOCK_COUNT)
+ am_atom_put(drv->name, sys_strlen(drv->name))
+#else
+ NIL
+#endif
+ );
+ }
+#endif
+ drv->entry = de;
+
+ drv->start = de->start;
+ drv->stop = de->stop;
+ drv->finish = de->finish;
+ drv->flush = de->flush;
+ drv->output = de->output ? de->output : no_output_callback;
+ drv->outputv = de->outputv;
+ drv->control = de->control;
+ drv->call = de->call;
+ drv->event = de->event ? de->event : no_event_callback;
+ drv->ready_input = de->ready_input ? de->ready_input : no_ready_input_callback;
+ drv->ready_output = de->ready_output ? de->ready_output : no_ready_output_callback;
+ drv->timeout = de->timeout ? de->timeout : no_timeout_callback;
+ drv->ready_async = de->ready_async;
+ if (de->extended_marker == ERL_DRV_EXTENDED_MARKER)
+ drv->process_exit = de->process_exit;
+ else
+ drv->process_exit = NULL;
+ if (de->minor_version >= 3/*R13A*/ && de->stop_select)
+ drv->stop_select = de->stop_select;
+ else
+ drv->stop_select = no_stop_select_callback;
+
+ if (!de->init)
+ return 0;
+ else {
+ int res;
+ int fpe_was_unmasked = erts_block_fpe();
+ res = (*de->init)();
+ erts_unblock_fpe(fpe_was_unmasked);
+ return res;
+ }
+}
+
+void
+erts_destroy_driver(erts_driver_t *drv)
+{
+#ifdef ERTS_SMP
+ if (drv->lock) {
+ erts_smp_mtx_destroy(drv->lock);
+ erts_free(ERTS_ALC_T_DRIVER_LOCK, drv->lock);
+ }
+#endif
+ erts_free(ERTS_ALC_T_DRIVER, drv);
+}
+
+/*
+ * Functions for maintaining a list of driver_entry struct
+ * Exposed in the driver interface, and therefore possibly locking directly.
+ */
+
+void add_driver_entry(ErlDrvEntry *drv){
+ void *rec_lock;
+ rec_lock = erts_smp_tsd_get(driver_list_lock_status_key);
+ /*
+ * Ignore result of erts_add_driver_entry, the init is not
+ * allowed to fail when drivers are added by drivers.
+ */
+ erts_add_driver_entry(drv, NULL, rec_lock != NULL);
+}
+
+int erts_add_driver_entry(ErlDrvEntry *de, DE_Handle *handle, int driver_list_locked)
+{
+ erts_driver_t *dp = erts_alloc(ERTS_ALC_T_DRIVER, sizeof(erts_driver_t));
+ int res;
+
+ if (!driver_list_locked) {
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ }
+
+ dp->next = driver_list;
+ dp->prev = NULL;
+ if (driver_list != NULL) {
+ driver_list->prev = dp;
+ }
+ driver_list = dp;
+
+ if (!driver_list_locked) {
+ erts_smp_tsd_set(driver_list_lock_status_key, (void *) 1);
+ }
+
+ res = init_driver(dp, de, handle);
+
+ if (res != 0) {
+ /*
+ * Remove it all again...
+ */
+ driver_list = dp->next;
+ if (driver_list != NULL) {
+ driver_list->prev = NULL;
+ }
+ erts_destroy_driver(dp);
+ }
+
+ if (!driver_list_locked) {
+ erts_smp_tsd_set(driver_list_lock_status_key, NULL);
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ return res;
+}
+
+/* Not allowed for dynamic drivers */
+int remove_driver_entry(ErlDrvEntry *drv)
+{
+ erts_driver_t *dp;
+ void *rec_lock;
+
+ rec_lock = erts_smp_tsd_get(driver_list_lock_status_key);
+ if (rec_lock == NULL) {
+ erts_smp_mtx_lock(&erts_driver_list_lock);
+ }
+ dp = driver_list;
+ while (dp && dp->entry != drv)
+ dp = dp->next;
+ if (dp) {
+ if (dp->handle) {
+ if (rec_lock == NULL) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ return -1;
+ }
+ if (dp->prev == NULL) {
+ driver_list = dp->next;
+ } else {
+ dp->prev->next = dp->next;
+ }
+ if (dp->next != NULL) {
+ dp->next->prev = dp->prev;
+ }
+ erts_destroy_driver(dp);
+ if (rec_lock == NULL) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ return 1;
+ }
+ if (rec_lock == NULL) {
+ erts_smp_mtx_unlock(&erts_driver_list_lock);
+ }
+ return 0;
+}
+
+/* very useful function that can be used in entries that are not used
+ * so that not every driver writer must supply a personal version
+ */
+int null_func(void)
+{
+ return 0;
+}
+
+int
+erl_drv_putenv(char *key, char *value)
+{
+ return erts_write_env(key, value);
+}
+
+int
+erl_drv_getenv(char *key, char *value, size_t *value_size)
+{
+ return erts_sys_getenv(key, value, value_size);
+}