The R13B03 release.OTP_R13B03

1 files changed, 1964 insertions, 0 deletions

diff --git a/erts/emulator/beam/erl_bif_ddll.c b/erts/emulator/beam/erl_bif_ddll.c
new file mode 100644
index 0000000000..9d5f0d9c02
--- /dev/null
+++ b/erts/emulator/beam/erl_bif_ddll.c
@@ -0,0 +1,1964 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 2006-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%
+ */
+
+/*
+ * BIFs belonging to the 'erl_ddll' module together with utility
+ * functions for dynamic loading. The actual loading is done in
+ * erl_sys_ddll.c in respective system dependent directory.  The
+ * driver structure contains a handle to the actual loaded "module" as
+ * well as record keeping information about processes having loaded
+ * the driver and processes monitoring the driver. A process in any
+ * way involved in ddll-drivers, get a special flag, which triggers
+ * cleenup at process exit.
+ */
+
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#define ERL_SYS_DRV
+
+#include "sys.h"
+#include "erl_vm.h"
+#include "global.h"
+#include "erl_process.h"
+#include "error.h"
+#include "erl_driver.h"
+#include "bif.h"
+#include "big.h"
+#include "dist.h"
+#include "erl_version.h"
+
+#ifdef ERTS_SMP
+#define DDLL_SMP 1
+#else
+#define DDLL_SMP 0
+#endif
+
+
+/*
+ * Local types
+ */
+
+typedef struct {
+    Eterm pid;
+    Process *proc;
+    Uint status;
+    Uint count;
+} ProcEntryInfo;
+
+/*
+ * Forward
+ */
+static char *pick_list_or_atom(Eterm name_term);
+static erts_driver_t *lookup_driver(char *name);
+static Eterm mkatom(char *str);
+static void add_proc_loaded(DE_Handle *dh, Process *proc); 
+static void add_proc_loaded_deref(DE_Handle *dh, Process *proc);
+static void set_driver_reloading(DE_Handle *dh, Process *proc, char *path, char *name, Uint flags);
+static int load_driver_entry(DE_Handle **dhp, char *path, char *name);
+static int do_unload_driver_entry(DE_Handle *dh, Eterm *save_name);
+static int do_load_driver_entry(DE_Handle *dh, char *path, char *name);
+#if 0
+static void unload_driver_entry(DE_Handle *dh);
+#endif
+static int reload_driver_entry(DE_Handle *dh);
+static int build_proc_info(DE_Handle *dh, ProcEntryInfo **out_pei, Uint filter);
+static int is_last_user(DE_Handle *dh, Process *proc);
+static DE_ProcEntry *find_proc_entry(DE_Handle *dh, Process *proc, Uint status);
+static void remove_proc_entry(DE_Handle *dh, DE_ProcEntry *pe);
+static int num_procs(DE_Handle *dh, Uint status);
+/*static int num_entries(DE_Handle *dh, Process *proc, Uint status);*/
+static void notify_proc(Process *proc, Eterm ref, Eterm driver_name, 
+			Eterm type, Eterm tag, int errcode);
+static void notify_all(DE_Handle *dh, char *name, Uint awaiting, Eterm type, Eterm tag);
+static int load_error_need(int code);
+static Eterm build_load_error_hp(Eterm *hp, int code);
+static Eterm build_load_error(Process *p, int code);
+static int errdesc_to_code(Eterm errdesc, int *code /* out */);
+static Eterm add_monitor(Process *p, DE_Handle *dh, Uint status);
+static Eterm notify_when_loaded(Process *p, Eterm name_term, char *name,
+				ErtsProcLocks plocks);
+static Eterm notify_when_unloaded(Process *p, Eterm name_term, char *name,
+				  ErtsProcLocks plocks, Uint flag);
+static void first_ddll_reference(DE_Handle *dh);
+static void dereference_all_processes(DE_Handle *dh);
+static void restore_process_references(DE_Handle *dh);
+static void ddll_no_more_references(void *vdh);
+
+#define lock_drv_list() erts_smp_mtx_lock(&erts_driver_list_lock)
+#define unlock_drv_list() erts_smp_mtx_unlock(&erts_driver_list_lock)
+#define assert_drv_list_locked() \
+    ERTS_SMP_LC_ASSERT(erts_smp_lc_mtx_is_locked(&erts_driver_list_lock))
+#define assert_drv_list_not_locked() \
+    ERTS_SMP_LC_ASSERT(!erts_smp_lc_mtx_is_locked(&erts_driver_list_lock))
+
+
+#define FREE_PORT_FLAGS (ERTS_PORT_SFLGS_DEAD & (~ERTS_PORT_SFLG_INITIALIZING))
+
+/*
+ *    try_load(Path, Name, OptionList) -> {ok,Status} | 
+ *                                        {ok, PendingStatus, Ref} | 
+ *                                        {error, ErrorDesc}
+ *       Path = Name = string() | atom()
+ *	 OptionList = [ Option ]
+ *	 Option = {driver_options, DriverOptionList} | 
+ *                {monitor,MonitorOption} | 
+ *                {reload, ReloadOption}
+ *	 DriverOptionList = [ DriverOption ]
+ *	 DriverOption = kill_ports
+ *	 MonitorOption = pending_driver | pending
+ *	 ReloadOption = pending_driver | pending
+ *	 Status = loaded | already_loaded | PendingStatus
+ *	 PendingStatus = pending_driver | pending_process
+ *	 Ref = ref()
+ *	 ErrorDesc = ErrorAtom | OpaqueError
+ *	 ErrorAtom = linked_in_driver | inconsistent |
+ *	             permanent | pending
+ */
+/*
+ * Try to load. If the driver is OK, add as LOADED.  If the driver is
+ * UNLOAD, possibly change to reload and add as LOADED, 
+ * there should be no other
+ * LOADED tagged pid's.  If the driver is RELOAD then add/increment as
+ * LOADED (should be some LOADED pid).  If the driver is not present,
+ * really load and add as LOADED {ok,loaded} {ok,pending_driver}
+ * {error, permanent} {error,load_error()}
+ */
+BIF_RETTYPE erl_ddll_try_load_3(Process *p, Eterm path_term, 
+				Eterm name_term, Eterm options)
+{
+    char *path = NULL;
+    int path_len;
+    char *name = NULL;
+    DE_Handle *dh;
+    erts_driver_t *drv;
+    int res;
+    Eterm soft_error_term = NIL;
+    Eterm ok_term = NIL;
+    Eterm *hp;
+    Eterm t;
+    int monitor = 0;
+    int reload = 0;
+    Eterm l;
+    Uint flags = 0;
+    int kill_ports = 0;
+    int do_build_load_error = 0;
+    int build_this_load_error = 0;
+
+    for(l = options; is_list(l); l =  CDR(list_val(l))) {
+	Eterm opt = CAR(list_val(l));
+	Eterm *tp;
+	if (is_not_tuple(opt)) {
+	    goto error;
+	}
+	tp = tuple_val(opt);
+	if (*tp != make_arityval(2) || is_not_atom(tp[1])) {
+	    goto error;
+	}
+	switch (tp[1]) {
+	case am_driver_options:
+	    {
+		Eterm ll;
+		for(ll = tp[2]; is_list(ll); ll = CDR(list_val(ll))) {
+		    Eterm dopt = CAR(list_val(ll));
+		    if (dopt == am_kill_ports) {
+			flags |= ERL_DE_FL_KILL_PORTS;
+		    } else {
+			goto error;
+		    }
+		}
+		if (is_not_nil(ll)) {
+		    goto error;
+		}
+	    }
+	    break;
+	case am_monitor:
+	    if (tp[2] == am_pending_driver) {
+		monitor = 1;
+	    } else if (tp[2] == am_pending ) {
+		monitor = 2;
+	    } else {
+		goto error;
+	    }
+	    break;
+	case am_reload:
+	    if (tp[2] == am_pending_driver) {
+		reload = 1;
+	    } else if (tp[2] == am_pending ) {
+		reload = 2;
+	    } else {
+		goto error;
+	    }
+	    break;
+	default:
+	    goto error;
+	}
+    }
+    if (is_not_nil(l)) {
+	goto error;
+    }
+
+
+    if ((name = pick_list_or_atom(name_term)) == NULL) {
+	goto error;
+    }
+
+    path_len = io_list_len(path_term);
+
+    if (path_len <= 0) {
+	goto error;
+    }
+    path = erts_alloc(ERTS_ALC_T_DDLL_TMP_BUF, path_len + 1 /* might need path separator */ + sys_strlen(name) + 1);
+    if (io_list_to_buf(path_term, path, path_len) != 0) {
+	goto error;
+    }
+    while (path_len > 0 && (path[path_len-1] == '\\' || path[path_len-1] == '/')) {
+	--path_len;
+    }
+    path[path_len++] = '/';
+    /*path[path_len] = '\0';*/
+    sys_strcpy(path+path_len,name);
+
+#if DDLL_SMP
+    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+    lock_drv_list();
+#endif
+    if ((drv = lookup_driver(name)) != NULL) {
+	if (drv->handle == NULL) {
+	    /* static_driver */
+	    soft_error_term = am_linked_in_driver;
+	    goto soft_error;
+	} else {
+	    dh = drv->handle;
+	    if (dh->status == ERL_DE_OK) {
+		int is_last = is_last_user(dh,p);
+		if (reload == 1 && !is_last) {
+		    /*Want reload if no other users, 
+		      but there are others...*/
+		    soft_error_term = am_pending_process;
+		    goto soft_error;
+		} 
+		if (reload != 0) {
+		    DE_ProcEntry *old;
+		    if ((dh->flags & ERL_FL_CONSISTENT_MASK) != 
+			(flags &  ERL_FL_CONSISTENT_MASK)) {
+			soft_error_term = am_inconsistent;
+			goto soft_error;
+		    }
+		    if ((old = find_proc_entry(dh, p, ERL_DE_PROC_LOADED)) == 
+			NULL) {
+			soft_error_term = am_not_loaded_by_this_process;
+			goto soft_error;
+		    } else {
+			remove_proc_entry(dh, old);
+			erts_ddll_dereference_driver(dh);
+			erts_free(ERTS_ALC_T_DDLL_PROCESS, old);
+		    }
+		    /* Reload requested and granted */
+		    dereference_all_processes(dh);
+		    set_driver_reloading(dh, p, path, name, flags);
+		    if (dh->flags & ERL_DE_FL_KILL_PORTS) {
+			kill_ports = 1;
+		    }
+		    ok_term = (reload == 1) ? am_pending_driver : 
+			am_pending_process;
+		} else {
+		    /* Already loaded and healthy (might be by me) */
+		    if (sys_strcmp(dh->full_path, path) || 
+			(dh->flags & ERL_FL_CONSISTENT_MASK) != 
+			(flags &  ERL_FL_CONSISTENT_MASK)) {
+			soft_error_term = am_inconsistent;
+			goto soft_error;
+		    }
+		    add_proc_loaded(dh,p);
+		    erts_ddll_reference_driver(dh);
+		    monitor = 0;
+		    ok_term = mkatom("already_loaded");
+		}
+	    } else if (dh->status == ERL_DE_UNLOAD ||
+		       dh->status == ERL_DE_FORCE_UNLOAD) {
+		/* pending driver */
+		if (reload != 0) {
+		    soft_error_term = am_not_loaded_by_this_process;
+		    goto soft_error;
+		} 
+		if (sys_strcmp(dh->full_path, path) || 
+		    (dh->flags & ERL_FL_CONSISTENT_MASK) != 
+		    (flags &  ERL_FL_CONSISTENT_MASK)) {
+		    soft_error_term = am_inconsistent;
+		    goto soft_error;
+		}
+		dh->status = ERL_DE_OK;
+		notify_all(dh, drv->name, 
+			   ERL_DE_PROC_AWAIT_UNLOAD, am_UP, 
+			   am_unload_cancelled);
+		add_proc_loaded(dh,p);
+		erts_ddll_reference_driver(dh);
+		monitor = 0;
+		ok_term = mkatom("already_loaded");
+	    } else if (dh->status == ERL_DE_RELOAD ||
+		       dh->status == ERL_DE_FORCE_RELOAD) {
+		if (reload != 0) {
+		    soft_error_term = am_pending_reload;
+		    goto soft_error;
+		}
+		if (sys_strcmp(dh->reload_full_path, path) || 
+		    (dh->reload_flags & ERL_FL_CONSISTENT_MASK) != 
+		        (flags &  ERL_FL_CONSISTENT_MASK)) {
+		    soft_error_term = am_inconsistent;
+		    goto soft_error;
+		}
+		/* Load of granted unload... */
+		add_proc_loaded_deref(dh,p); /* Dont reference, will happen after reload */
+		++monitor;
+		ok_term = am_pending_driver;
+	    } else { /* ERL_DE_PERMANENT */
+		soft_error_term = am_permanent;
+		goto soft_error;
+	    }
+	}
+    } else { /* driver non-existing */
+	if (reload != 0) {
+	    soft_error_term = am_not_loaded;
+	    goto soft_error;
+	} 
+	if ((res = load_driver_entry(&dh, path, name)) !=  ERL_DE_NO_ERROR) {
+	    build_this_load_error = res;
+	    do_build_load_error = 1;
+	    soft_error_term = am_undefined;
+	    goto soft_error;
+	} else {
+	    dh->flags = flags;
+	    add_proc_loaded(dh,p);
+	    first_ddll_reference(dh);
+	    monitor = 0;
+	    ok_term = mkatom("loaded");
+	}
+    }
+    assert_drv_list_locked();
+    if (kill_ports) {
+	int j;
+	/* Avoid closing the driver by referencing it */
+	erts_ddll_reference_driver(dh);
+	ASSERT(dh->status == ERL_DE_RELOAD);
+	dh->status = ERL_DE_FORCE_RELOAD;
+#if DDLL_SMP
+	unlock_drv_list();
+#endif
+	for (j = 0; j < erts_max_ports; j++) {
+	    Port* prt = &erts_port[j];
+#ifdef DDLL_SMP
+	    erts_smp_port_state_lock(prt);
+#endif 
+	    if (!(prt->status & FREE_PORT_FLAGS) &&
+		prt->drv_ptr->handle == dh) {
+#if DDLL_SMP
+		erts_smp_atomic_inc(&prt->refc);
+		/* Extremely rare spinlock */
+		while(prt->status & ERTS_PORT_SFLG_INITIALIZING) {
+		       erts_smp_port_state_unlock(prt);
+		       erts_smp_port_state_lock(prt);
+	        }
+		erts_smp_port_state_unlock(prt);
+		erts_smp_mtx_lock(prt->lock);
+		if (!(prt->status & ERTS_PORT_SFLGS_DEAD)) {
+		    driver_failure_atom(j, "driver_unloaded");
+		}
+#else
+		driver_failure_atom(j, "driver_unloaded");
+#endif
+		erts_port_release(prt);
+	    }
+	    else erts_smp_port_state_unlock(prt);
+	}
+	/* Dereference, eventually causing driver destruction */
+#if DDLL_SMP
+	lock_drv_list(); 
+#endif
+	erts_ddll_dereference_driver(dh);
+    } 
+
+#if DDLL_SMP
+    erts_ddll_reference_driver(dh);
+    unlock_drv_list();
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    lock_drv_list();
+    erts_ddll_dereference_driver(dh);
+#endif
+
+    p->flags |= F_USING_DDLL;
+    if (monitor) {
+	Eterm mref = add_monitor(p, dh, ERL_DE_PROC_AWAIT_LOAD);
+	hp = HAlloc(p,4);
+	t = TUPLE3(hp, am_ok, ok_term, mref);
+    } else {
+	hp = HAlloc(p,3);
+	t = TUPLE2(hp, am_ok, ok_term);
+    }
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    BIF_RET(t);
+ soft_error:
+#if DDLL_SMP
+    unlock_drv_list();
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+#endif
+    if (do_build_load_error) {
+	soft_error_term = build_load_error(p, build_this_load_error);
+    }
+
+    hp = HAlloc(p,3);
+    t = TUPLE2(hp, am_error, soft_error_term);
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    BIF_RET(t);
+ error:
+    assert_drv_list_not_locked();
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    if (path != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) path);
+    }
+    if (name != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    }
+    BIF_ERROR(p,BADARG);
+}
+
+/*
+ * try_unload(Name, OptionList) -> {ok,Status} | 
+ *                                 {ok,PendingStatus, Ref} | 
+ *                                 {error, ErrorAtom}
+ *        Name = string() | atom()
+ *	  OptionList = [ Option ]
+ *	  Option = {monitor,MonitorOption} | kill_ports
+ *	  MonitorOption = pending_driver | pending
+ *	  Status = unloaded | PendingStatus 
+ *	  PendingStatus = pending_driver | pending_process
+ *	  Ref = ref()
+ *	  ErrorAtom = linked_in_driver | not_loaded | 
+ *	              not_loaded_by_this_process | permanent
+ */
+
+/* 
+   You have to have loaded the driver and the pid state 
+   is LOADED or AWAIT_LOAD. You will be removed from the list
+   regardless of driver state.
+   If the driver is loaded by someone else to, return is
+   {ok, pending_process}
+   If the driver is loaded but locked by a port, return is
+   {ok, pending_driver}
+   If the driver is loaded and free to unload (you're the last holding it)
+   {ok, unloaded}
+   If it's not loaded or not loaded by you
+   {error, not_loaded} or {error, not_loaded_by_you}
+
+   Internally, if its in state UNLOADING, just return {ok, pending_driver} and
+   remove/decrement this pid (which should be an LOADED tagged one).
+   If the state is RELOADING, this pid should be in list as LOADED tagged, 
+   only AWAIT_LOAD would be possible but not allowed for unloading, remove it 
+   and, if the last LOADED tagged, change from RELOAD to UNLOAD and notify
+   any AWAIT_LOAD-waiters with {'DOWN', ref(), driver, name(), load_cancelled}
+   If the driver made itself permanent, {'UP', ref(), driver, name(), permanent}
+*/
+Eterm erl_ddll_try_unload_2(Process *p, Eterm name_term, Eterm options)
+{
+    char *name = NULL;
+    Eterm ok_term = NIL;
+    Eterm soft_error_term = NIL;
+    erts_driver_t *drv;
+    DE_Handle *dh;
+    DE_ProcEntry *pe;
+    Eterm *hp;
+    Eterm t;
+    int monitor = 0;
+    Eterm l;
+    int kill_ports = 0;
+
+    erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
+
+    for(l = options; is_list(l); l =  CDR(list_val(l))) {
+	Eterm opt = CAR(list_val(l));
+	Eterm *tp;
+	if (is_not_tuple(opt)) {
+	    if (opt == am_kill_ports) {
+		kill_ports = 1;
+		continue;
+	    } else {
+		goto error;
+	    }
+	}
+	tp = tuple_val(opt);
+	if (*tp != make_arityval(2) || tp[1] != am_monitor) {
+	    goto error;
+	}
+	if (tp[2] == am_pending_driver) { 
+	    monitor = 1;
+	} else if (tp[2] == am_pending) {
+	    monitor = 2;
+	} else {
+	    goto error;
+	}
+    }
+    if (is_not_nil(l)) {
+	goto error;
+    }
+
+    if ((name = pick_list_or_atom(name_term)) == NULL) {
+	goto error;
+    }
+
+#if DDLL_SMP
+    lock_drv_list();
+#endif
+
+    if ((drv = lookup_driver(name)) == NULL) {
+	soft_error_term = am_not_loaded;
+	goto soft_error;
+    }
+
+    if (drv->handle == NULL) {
+	soft_error_term = am_linked_in_driver;
+	goto soft_error;
+    } else if (drv->handle->status == ERL_DE_PERMANENT) {
+	soft_error_term = am_permanent;
+	goto soft_error;
+    }	
+    dh = drv->handle;
+    if (dh->flags & ERL_DE_FL_KILL_PORTS) {
+	kill_ports = 1;
+    }
+    if ((pe = find_proc_entry(dh, p, ERL_DE_PROC_LOADED)) == NULL) {
+	if (num_procs(dh, ERL_DE_PROC_LOADED) > 0) {
+	    soft_error_term = am_not_loaded_by_this_process;
+	    goto soft_error;
+	}
+    } else {
+	remove_proc_entry(dh, pe);
+	if (!(pe->flags & ERL_DE_FL_DEREFERENCED)) {
+	    erts_ddll_dereference_driver(dh);
+	}
+	erts_free(ERTS_ALC_T_DDLL_PROCESS, pe);
+    }
+    if (num_procs(dh, ERL_DE_PROC_LOADED) > 0) {
+	ok_term = am_pending_process;
+	--monitor;
+	goto done;
+    }
+    if (dh->status == ERL_DE_RELOAD ||
+	dh->status == ERL_DE_FORCE_RELOAD) {
+	notify_all(dh, drv->name, 
+		   ERL_DE_PROC_AWAIT_LOAD, am_DOWN, am_load_cancelled);
+	erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_full_path);
+	erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_driver_name);
+	dh->reload_full_path = dh->reload_driver_name = NULL; 
+	dh->reload_flags = 0;
+    } 
+    if (dh->port_count > 0) {
+	++kill_ports;
+    }
+    dh->status = ERL_DE_UNLOAD;
+    ok_term = am_pending_driver;
+done:
+    assert_drv_list_locked();
+    if (kill_ports > 1) {
+	int j;
+	/* Avoid closing the driver by referencing it */
+	erts_ddll_reference_driver(dh);
+	dh->status = ERL_DE_FORCE_UNLOAD;
+#if DDLL_SMP
+	unlock_drv_list();
+#endif
+	for (j = 0; j < erts_max_ports; j++) {
+	    Port* prt = &erts_port[j];
+#if DDLL_SMP
+	    erts_smp_port_state_lock(prt);
+#endif
+	    if (!(prt->status &  FREE_PORT_FLAGS) 
+		&& prt->drv_ptr->handle == dh) {
+#if DDLL_SMP
+		erts_smp_atomic_inc(&prt->refc);
+		/* Extremely rare spinlock */
+		while(prt->status & ERTS_PORT_SFLG_INITIALIZING) {
+		       erts_smp_port_state_unlock(prt);
+		       erts_smp_port_state_lock(prt);
+	        }
+		erts_smp_port_state_unlock(prt);
+		erts_smp_mtx_lock(prt->lock);
+		if (!(prt->status & ERTS_PORT_SFLGS_DEAD)) {
+		    driver_failure_atom(j, "driver_unloaded");
+		}
+#else
+		driver_failure_atom(j, "driver_unloaded");
+#endif
+		erts_port_release(prt);
+	    }
+	    else erts_smp_port_state_unlock(prt);
+	}
+#if DDLL_SMP
+	lock_drv_list(); 
+#endif
+	erts_ddll_dereference_driver(dh);
+    } 
+
+#if DDLL_SMP
+    erts_ddll_reference_driver(dh);
+    unlock_drv_list();
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    lock_drv_list();
+    erts_ddll_dereference_driver(dh);
+#endif
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    p->flags |= F_USING_DDLL;
+    if (monitor > 0) {
+	Eterm mref = add_monitor(p, dh, ERL_DE_PROC_AWAIT_UNLOAD);
+	hp = HAlloc(p,4);
+	t = TUPLE3(hp, am_ok, ok_term, mref);
+    } else {
+	hp = HAlloc(p,3);
+	t = TUPLE2(hp, am_ok, ok_term);
+    }
+    if (kill_ports > 1) {
+	ERTS_BIF_CHK_EXITED(p); /* May be exited by port killing */
+    }
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    BIF_RET(t);
+ 
+soft_error:
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    hp = HAlloc(p,3);
+    t = TUPLE2(hp, am_error, soft_error_term);
+    BIF_RET(t);
+ 
+ error: /* No lock fiddling before going here */
+    assert_drv_list_not_locked();
+    if (name != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    }
+    erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
+    BIF_ERROR(p,BADARG);
+}
+
+
+/* 
+ * A shadow of the "real" demonitor BIF
+ */
+BIF_RETTYPE erl_ddll_demonitor_1(Process *p, Eterm ref)
+{
+   if (is_not_internal_ref(ref)) {
+       BIF_ERROR(p, BADARG);
+   }
+   if (p->flags & F_USING_DDLL) {
+       erts_ddll_remove_monitor(p, ref, ERTS_PROC_LOCK_MAIN);
+   }
+   BIF_RET(am_true);
+}
+
+/* 
+ * A shadow of the "real" monitor BIF
+ */
+BIF_RETTYPE erl_ddll_monitor_2(Process *p, Eterm dr, Eterm what)
+{
+    if (dr != am_driver) {
+	BIF_ERROR(p,BADARG);
+    }
+    return erts_ddll_monitor_driver(p, what, ERTS_PROC_LOCK_MAIN);
+}
+
+/* 
+ * Return list of loaded drivers {ok,[string()]} 
+ */
+Eterm erl_ddll_loaded_drivers_0(Process *p)
+{
+    Eterm *hp;
+    int need = 3;
+    Eterm res = NIL;
+    erts_driver_t *drv;
+#if DDLL_SMP
+    lock_drv_list();
+#endif
+    for (drv = driver_list; drv; drv = drv->next) {
+	need += sys_strlen(drv->name)*2+2;
+    }
+    hp = HAlloc(p,need);
+    for (drv = driver_list; drv; drv = drv->next) {
+	Eterm l;
+	l = buf_to_intlist(&hp, drv->name, sys_strlen(drv->name), NIL);
+	res = CONS(hp,l,res);
+	hp += 2;
+    }
+    res = TUPLE2(hp,am_ok,res);
+    /* hp += 3 */
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    BIF_RET(res);
+}
+
+/* 
+ * More detailed info about loaded drivers: 
+ * item is processes, driver_options, port_count, linked_in_driver, 
+ * permanent, awaiting_load, awaiting_unload 
+ */
+Eterm erl_ddll_info_2(Process *p, Eterm name_term, Eterm item) 
+{
+    char *name = NULL;
+    Eterm res = NIL;
+    erts_driver_t *drv;
+    ProcEntryInfo *pei = NULL;
+    int num_pei;
+    Eterm *hp;
+    int i;
+    Uint filter;
+#if DDLL_SMP
+    int have_lock = 0;
+#endif
+
+    if ((name = pick_list_or_atom(name_term)) == NULL) {
+	goto error;
+    }
+
+    if (!is_atom(item)) {
+	goto error;
+    }
+
+#if DDLL_SMP 
+    lock_drv_list();
+    have_lock = 1;
+#endif
+    if ((drv = lookup_driver(name)) == NULL) {
+	goto error;
+    }
+    
+    switch (item) {
+    case am_processes:
+	filter = ERL_DE_PROC_LOADED;
+	break;
+    case am_driver_options:
+	if (drv->handle == NULL) {
+	    res = am_linked_in_driver;
+	} else {
+	    Uint start_flags = drv->handle->flags & ERL_FL_CONSISTENT_MASK;
+	    /* Cheating, only one flag for now... */
+	    if (start_flags & ERL_DE_FL_KILL_PORTS) {
+		Eterm *myhp;
+		myhp = HAlloc(p,2);
+		res = CONS(myhp,am_kill_ports,NIL);
+	    } else {
+		res = NIL;
+	    }
+	}
+	goto done;
+    case am_port_count:
+	if (drv->handle == NULL) {
+	    res = am_linked_in_driver;
+	} else if (drv->handle->status == ERL_DE_PERMANENT) {
+	    res = am_permanent;
+	} else {
+	    res = make_small(drv->handle->port_count);
+	}
+	goto done;
+    case am_linked_in_driver:
+	if (drv->handle == NULL){
+	    res = am_true;
+	} else {
+	    res = am_false;
+	}
+	goto done;
+    case am_permanent:
+	if (drv->handle != NULL && drv->handle->status == ERL_DE_PERMANENT) {
+	    res = am_true;
+	} else {
+	    res = am_false;
+	}
+	goto done;
+    case am_awaiting_load:
+	filter = ERL_DE_PROC_AWAIT_LOAD;
+	break;
+    case am_awaiting_unload:
+	filter = ERL_DE_PROC_AWAIT_UNLOAD;
+	break;
+    default:
+	goto error;
+    }
+
+    if (drv->handle == NULL) {
+	res = am_linked_in_driver;
+	goto done;
+    } else if (drv->handle->status == ERL_DE_PERMANENT) {
+	res = am_permanent;
+	goto done;
+    }
+    num_pei = build_proc_info(drv->handle, &pei, filter);
+    if (!num_pei) {
+	goto done;
+    }
+    hp = HAlloc(p,num_pei * (2+3));
+    for (i = 0; i < num_pei; ++ i) {
+	Eterm tpl = TUPLE2(hp,pei[i].pid,make_small(pei[i].count));
+	hp += 3;
+	res = CONS(hp,tpl,res);
+	hp += 2;
+    }    
+ done:    
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    if (pei)
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, pei);
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    BIF_RET(res);
+ error:
+    if (name != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    }
+#if DDLL_SMP
+    if (have_lock) {
+	unlock_drv_list();
+    }
+#endif
+    BIF_ERROR(p,BADARG);
+}
+
+/*
+ * Backend for erl_ddll:format_error, handles all "soft" errors returned by builtins,
+ * possibly by calling the system specific error handler
+ */
+Eterm erl_ddll_format_error_int_1(Process *p, Eterm code_term)
+{
+    char *errstring = NULL;
+    int errint;
+    int len;
+    Eterm ret = NIL;
+    Eterm *hp;
+
+    /* These errors can only appear in the erlang interface, not in the interface provided
+       to drivers... */
+    switch (code_term) {
+    case am_inconsistent:
+	errstring = "Driver name and/or driver options are inconsistent with "
+	    "currently loaded driver";
+	break;
+    case am_linked_in_driver:
+	errstring = "Driver is statically linked and "
+	    "cannot be loaded/unloaded";
+	break;
+    case am_permanent:
+	errstring = "DDLL driver is permanent an can not be unloaded/loaded";
+	break;
+    case am_not_loaded:
+	errstring = "DDLL driver is not loaded";
+	break;
+    case am_not_loaded_by_this_process:
+	errstring = "DDLL driver was not loaded by this process";
+	break;
+    case am_not_pending:
+	errstring = "DDLL load not pending for this driver name";
+	break;
+    case am_already_loaded:
+	errstring = "DDLL driver is already loaded successfully";
+	break;
+    case am_pending_reload:
+	errstring = "Driver reloading is already pending";
+	break;
+    case am_pending_process:
+	errstring = "Driver is loaded by others when attempting "
+	    "option {reload, pending_driver}";
+	break;
+    default:
+	/* A "real" error, we translate the atom to a code and translate the code 
+	   to a string in the same manner as in the interface provided to drivers... */
+	if (errdesc_to_code(code_term,&errint) != 0) {
+	    goto error;
+	}
+#if DDLL_SMP 
+	lock_drv_list();
+#endif
+	errstring = erts_ddll_error(errint);
+#if DDLL_SMP
+	unlock_drv_list();
+#endif
+	break;
+    }
+    if (errstring == NULL) {
+	goto error;
+    }
+    len = sys_strlen(errstring);
+    hp = HAlloc(p, 2 * len);
+    ret = buf_to_intlist(&hp, errstring, len, NIL);
+    BIF_RET(ret);
+ error:
+    BIF_ERROR(p,BADARG);
+} 
+
+void erts_ddll_init(void)
+{
+    erl_sys_ddll_init();
+}
+
+/* Return value as a bif, called by erlang:monitor */
+Eterm erts_ddll_monitor_driver(Process *p,
+			       Eterm description,
+			       ErtsProcLocks plocks) 
+{
+    Eterm *tp;
+    Eterm ret;
+    char *name;
+
+    if (is_not_tuple(description)) {
+	BIF_ERROR(p,BADARG);
+    }
+    tp = tuple_val(description);
+    if (*tp != make_arityval(2)) {
+	BIF_ERROR(p,BADARG);
+    }
+    if ((name = pick_list_or_atom(tp[1])) == NULL) {
+	BIF_ERROR(p,BADARG);
+    }
+    switch (tp[2]) {
+    case am_loaded:
+	ERTS_BIF_PREP_RET(ret, notify_when_loaded(p,tp[1],name,plocks));
+	break;
+    case am_unloaded:
+	ERTS_BIF_PREP_RET(ret, notify_when_unloaded(p,tp[1],name,plocks,
+						    ERL_DE_PROC_AWAIT_UNLOAD));
+	break;
+    case am_unloaded_only:
+	ERTS_BIF_PREP_RET(ret, 
+			  notify_when_unloaded(p,tp[1],name,plocks,
+					       ERL_DE_PROC_AWAIT_UNLOAD_ONLY));
+	break;
+    default:
+	ERTS_BIF_PREP_ERROR(ret,p,BADARG);
+	break;
+    }
+
+    erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    return ret;
+}
+
+void erts_ddll_remove_monitor(Process *p, Eterm ref, ErtsProcLocks plocks)
+{ 
+    erts_driver_t *drv;
+    erts_smp_proc_unlock(p, plocks);
+    lock_drv_list();
+    drv = driver_list;
+    while (drv != NULL) {
+	if (drv->handle != NULL && drv->handle->status != ERL_DE_PERMANENT) {
+	    DE_ProcEntry **pe = &(drv->handle->procs);
+	    while ((*pe) != NULL) {
+		if ((*pe)->proc == p && 
+		    ((*pe)->awaiting_status == ERL_DE_PROC_AWAIT_LOAD ||
+		     (*pe)->awaiting_status == ERL_DE_PROC_AWAIT_UNLOAD ||
+		     (*pe)->awaiting_status == 
+		     ERL_DE_PROC_AWAIT_UNLOAD_ONLY) &&
+		    eq(make_internal_ref(&((*pe)->heap)),ref)) {
+		    DE_ProcEntry *r = *pe;
+		    *pe = r->next;
+		    erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) r);
+		    goto done;
+		} 
+		pe = &((*pe)->next);
+	    }
+	}
+	drv = drv->next;
+    }
+ done:
+    unlock_drv_list();
+    erts_smp_proc_lock(p, plocks);
+}
+
+/* 
+ * Called from erl_process.c.
+ */
+void erts_ddll_proc_dead(Process *p, ErtsProcLocks plocks) 
+{
+    erts_driver_t *drv;
+    erts_smp_proc_unlock(p, plocks);
+    lock_drv_list();
+    drv = driver_list;
+    while (drv != NULL) {
+	if (drv->handle != NULL && drv->handle->status != ERL_DE_PERMANENT) {
+	    DE_ProcEntry **pe = &(drv->handle->procs);
+	    int kill_ports = (drv->handle->flags & ERL_DE_FL_KILL_PORTS);
+	    int left = 0;
+	    while ((*pe) != NULL) {
+		if ((*pe)->proc == p) {
+		    DE_ProcEntry *r = *pe;
+		    *pe = r->next;
+		    if (!(r->flags & ERL_DE_FL_DEREFERENCED) && 
+			r->awaiting_status == ERL_DE_PROC_LOADED) {
+			erts_ddll_dereference_driver(drv->handle);
+		    }
+		    erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) r);
+		} else {
+		    if ((*pe)->awaiting_status == ERL_DE_PROC_LOADED) {
+			++left;
+		    }
+		    pe = &((*pe)->next);
+		}
+	    }
+	    if (!left) {
+		DE_Handle *dh = drv->handle;
+		if (dh->status == ERL_DE_RELOAD ||
+		    dh->status == ERL_DE_FORCE_RELOAD) {
+		    notify_all(dh, drv->name, 
+			       ERL_DE_PROC_AWAIT_LOAD, am_DOWN, am_load_cancelled);
+		    erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_full_path);
+		    erts_free(ERTS_ALC_T_DDLL_HANDLE,dh->reload_driver_name);
+		    dh->reload_full_path = dh->reload_driver_name = NULL; 
+		    dh->reload_flags = 0;
+		} 
+		dh->status = ERL_DE_UNLOAD;
+	    }
+	    if (!left && drv->handle->port_count > 0) {
+		if (kill_ports) {
+		    int j;
+		    DE_Handle *dh = drv->handle;
+		    erts_ddll_reference_driver(dh);
+		    dh->status = ERL_DE_FORCE_UNLOAD;
+#if DDLL_SMP
+		    unlock_drv_list();
+#endif
+		    for (j = 0; j < erts_max_ports; j++) {
+			Port* prt = &erts_port[j];
+#if DDLL_SMP
+			erts_smp_port_state_lock(prt);
+#endif
+			if (!(prt->status & FREE_PORT_FLAGS) &&
+			    prt->drv_ptr->handle == dh) {
+#if DDLL_SMP
+			    erts_smp_atomic_inc(&prt->refc);
+			    while(prt->status & ERTS_PORT_SFLG_INITIALIZING) {
+				erts_smp_port_state_unlock(prt);
+				erts_smp_port_state_lock(prt);
+			    }
+			    erts_smp_port_state_unlock(prt);
+			    erts_smp_mtx_lock(prt->lock);
+			    if (!(prt->status & ERTS_PORT_SFLGS_DEAD)) {
+				driver_failure_atom(j, "driver_unloaded");
+			    }
+#else
+			    driver_failure_atom(j, "driver_unloaded");
+#endif
+			    erts_port_release(prt);
+			}
+			else erts_smp_port_state_unlock(prt);
+		    } 
+#if DDLL_SMP
+		    lock_drv_list(); /* Needed for future list operations */
+#endif
+		    drv = drv->next; /* before allowing destruction */
+		    erts_ddll_dereference_driver(dh);
+		} else {
+		    drv = drv->next;
+		}
+	    } else {
+		drv = drv->next;
+	    }
+	} else {
+	    drv = drv->next;
+	}
+    }
+    unlock_drv_list();
+    erts_smp_proc_lock(p, plocks);
+}
+void erts_ddll_lock_driver(DE_Handle *dh, char *name)
+{
+    DE_ProcEntry *p,*q;
+    assert_drv_list_locked();
+    notify_all(dh, name, 
+	       ERL_DE_PROC_AWAIT_LOAD, am_UP, am_permanent);
+    notify_all(dh, name, 
+	       ERL_DE_PROC_AWAIT_UNLOAD, am_UP, am_permanent);
+    notify_all(dh, name, 
+	       ERL_DE_PROC_AWAIT_UNLOAD_ONLY, am_UP, am_permanent);
+    
+    p = dh->procs; 
+    while(p != NULL) {
+	q = p;
+	p = p->next;
+	erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) q);
+    }
+    dh->procs = NULL;
+    erts_ddll_reference_driver(dh);
+    dh->status = ERL_DE_PERMANENT;
+}
+
+
+void erts_ddll_increment_port_count(DE_Handle *dh) 
+{
+    assert_drv_list_locked();
+    dh->port_count++;
+}
+
+void erts_ddll_decrement_port_count(DE_Handle *dh)
+{
+    assert_drv_list_locked();
+    ASSERT(dh->port_count > 0);
+    dh->port_count--;
+}
+
+static void first_ddll_reference(DE_Handle *dh) 
+{
+    assert_drv_list_locked();
+    erts_refc_init(&(dh->refc),1);
+}
+
+void erts_ddll_reference_driver(DE_Handle *dh)
+{
+    assert_drv_list_locked();
+    if (erts_refc_inctest(&(dh->refc),1) == 1) {
+	erts_refc_inc(&(dh->refc),2); /* add a reference for the scheduled operation */
+    }
+}
+
+void erts_ddll_reference_referenced_driver(DE_Handle *dh)
+{
+    erts_refc_inc(&(dh->refc),2);
+}
+
+void erts_ddll_dereference_driver(DE_Handle *dh)
+{
+    if (erts_refc_dectest(&(dh->refc),0) == 0) {
+	/* No lock here, but if the driver is referenced again,
+	   the scheduled deletion is added as a reference too, see above */
+	erts_schedule_misc_op(ddll_no_more_references, (void *) dh);
+    }
+}
+static void dereference_all_processes(DE_Handle *dh) 
+{
+    DE_ProcEntry *p;
+    assert_drv_list_locked();
+    for(p  = dh->procs;p != NULL; p = p->next) {
+	if (p->awaiting_status == ERL_DE_PROC_LOADED) {
+	    ASSERT(!(p->flags & ERL_DE_FL_DEREFERENCED));
+	    erts_ddll_dereference_driver(dh);
+	    p->flags |= ERL_DE_FL_DEREFERENCED;
+	}
+    }
+}
+
+static void restore_process_references(DE_Handle *dh) 
+{
+    DE_ProcEntry *p;
+    assert_drv_list_locked();
+    ASSERT(erts_refc_read(&(dh->refc),0) == 0);
+    for(p  = dh->procs;p != NULL; p = p->next) {
+	if (p->awaiting_status == ERL_DE_PROC_LOADED) {
+	    ASSERT(p->flags & ERL_DE_FL_DEREFERENCED);
+	    erts_refc_inc(&(dh->refc),1);
+	    p->flags &= ~ERL_DE_FL_DEREFERENCED;
+	}
+    }
+}
+    
+
+int erts_ddll_driver_ok(DE_Handle *dh) 
+{
+    assert_drv_list_locked();
+    return ((dh == NULL) || (dh->status != ERL_DE_FORCE_UNLOAD &&
+			     dh->status != ERL_DE_FORCE_RELOAD));
+}
+
+
+static void ddll_no_more_references(void *vdh)
+{
+    DE_Handle *dh = (DE_Handle *) vdh;
+    int x;
+
+    lock_drv_list();
+
+    x = erts_refc_read(&(dh->refc),0);
+    if (x > 0) {
+	x = erts_refc_dectest(&(dh->refc),0); /* delete the reference added for me */
+    }
+
+
+    if (x == 0) {
+	DE_ProcEntry **p = &(dh->procs);
+	Eterm save_driver_name = am_undefined;
+	ASSERT(dh->status != ERL_DE_OK);
+	do_unload_driver_entry(dh,&save_driver_name);
+	while (*p != NULL) {
+	    DE_ProcEntry *q;
+	    if ((*p)->awaiting_status == ERL_DE_PROC_AWAIT_UNLOAD ||
+		(*p)->awaiting_status == ERL_DE_PROC_AWAIT_UNLOAD_ONLY) {
+		notify_proc((*p)->proc, 
+			    make_internal_ref(&((*p)->heap)),
+			    save_driver_name,am_DOWN,am_unloaded, 0);
+		q = *p;
+		*p = q->next;
+		erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) q);
+	    } else {
+		ASSERT(dh->status == ERL_DE_RELOAD ||
+		       dh->status == ERL_DE_FORCE_RELOAD);
+		p = &((*p)->next);
+	    }
+	}
+
+	if (dh->status == ERL_DE_UNLOAD || dh->status == ERL_DE_FORCE_UNLOAD) {
+	    ASSERT(dh->full_path != NULL);
+	    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh->full_path);
+	    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh);
+	} else { /* ERL_DE_RELOAD || ERL_DE_FORCE_RELOAD */
+	    int reload_res =
+		reload_driver_entry(dh);
+	    p = &(dh->procs);
+	    while (*p != NULL) {
+		DE_ProcEntry *q;
+		if ((*p)->awaiting_status == ERL_DE_PROC_AWAIT_LOAD) {
+		    if (reload_res == 0) {
+			notify_proc((*p)->proc, 
+				    make_internal_ref(&((*p)->heap)),
+				    save_driver_name, am_UP, am_loaded, 0);
+		    } else {
+			notify_proc((*p)->proc, 
+				    make_internal_ref(&((*p)->heap)),
+				    save_driver_name, am_DOWN, am_load_failure, reload_res);
+		    }
+		    q = *p;
+		    *p = q->next;
+		    erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) q);
+		} else {
+		    if (reload_res != 0) {
+			DE_ProcEntry *q = *p;
+			*p = q->next;
+			erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) q);
+		    } else {
+			p = &((*p)->next);
+		    }
+		}
+	    }
+	    if (reload_res != 0) {
+		ASSERT(dh->full_path == NULL);
+		erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh);
+	    }
+	}
+    }
+    unlock_drv_list();
+}    
+
+char *erts_ddll_error(int code) {
+    switch (code) {
+    case ERL_DE_NO_ERROR:
+	return "No error";
+    case ERL_DE_LOAD_ERROR_NO_INIT:
+	return "No driver init in dynamic library";
+    case  ERL_DE_LOAD_ERROR_FAILED_INIT:
+	return "Driver init failed";
+    case ERL_DE_LOAD_ERROR_BAD_NAME:
+	return "Bad driver name";
+    case ERL_DE_LOAD_ERROR_NAME_TO_LONG:
+	return "Driver name to long";
+    case ERL_DE_LOAD_ERROR_INCORRECT_VERSION:
+	return "Driver compiled with incorrect version of erl_driver.h";
+    case ERL_DE_ERROR_NO_DDLL_FUNCTIONALITY:
+	return "DDLL functionality not available on this platform";
+    case ERL_DE_ERROR_UNSPECIFIED:
+	return "Unspecified dynamic library error";
+    case ERL_DE_LOOKUP_ERROR_NOT_FOUND:
+	return "Symbol not found in dynamic library";
+    default:
+	return erts_sys_ddll_error(code);
+    }
+}
+
+/*
+ * Utilities
+ */
+static Eterm notify_when_loaded(Process *p, Eterm name_term, char *name, ErtsProcLocks plocks)
+{ 
+    Eterm r = NIL;
+    Eterm immediate_tag = NIL;
+    Eterm immediate_type = NIL;
+    erts_driver_t *drv;
+
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & plocks);
+#if DDLL_SMP 
+    lock_drv_list();
+#endif
+    if ((drv = lookup_driver(name)) == NULL) {
+	immediate_tag = am_unloaded;
+	immediate_type = am_DOWN;
+	goto immediate;
+    }
+    if (drv->handle == NULL || drv->handle->status == ERL_DE_PERMANENT) {
+	immediate_tag = am_permanent;
+	immediate_type = am_UP;
+	goto immediate;
+    }	
+
+    switch (drv->handle->status) {
+    case ERL_DE_OK:
+	immediate_tag = am_loaded;
+	immediate_type = am_UP;
+	goto immediate;
+    case ERL_DE_UNLOAD:
+    case ERL_DE_FORCE_UNLOAD:
+	immediate_tag = am_load_cancelled;
+	immediate_type = am_DOWN;
+	goto immediate;
+    case ERL_DE_RELOAD:
+    case ERL_DE_FORCE_RELOAD:
+	break;
+    default:
+	erl_exit(1,"Internal error, unknown state %u in dynamic driver.", drv->handle->status);
+    }
+    p->flags |= F_USING_DDLL;
+    r = add_monitor(p, drv->handle, ERL_DE_PROC_AWAIT_LOAD);
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    BIF_RET(r);
+ immediate:
+    r =  erts_make_ref(p);
+#if DDLL_SMP 
+    erts_smp_proc_unlock(p, plocks);
+#endif
+    notify_proc(p, r, name_term, immediate_type, immediate_tag, 0);
+#if DDLL_SMP
+    unlock_drv_list();
+    erts_smp_proc_lock(p, plocks);
+#endif
+    BIF_RET(r);
+}
+
+static Eterm notify_when_unloaded(Process *p, Eterm name_term, char *name, ErtsProcLocks plocks, Uint flag)
+{ 
+    Eterm r = NIL;
+    Eterm immediate_tag = NIL;
+    Eterm immediate_type = NIL;
+    erts_driver_t *drv;
+
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & plocks);
+#if DDLL_SMP 
+    lock_drv_list();
+#endif
+    if ((drv = lookup_driver(name)) == NULL) {
+	immediate_tag = am_unloaded;
+	immediate_type = am_DOWN;
+	goto immediate;
+    }
+    if (drv->handle == NULL || drv->handle->status == ERL_DE_PERMANENT) {
+	immediate_tag = am_permanent;
+	immediate_type = am_UP;
+	goto immediate;
+    }	
+
+    p->flags |= F_USING_DDLL;
+    r = add_monitor(p, drv->handle, flag);
+#if DDLL_SMP
+    unlock_drv_list();
+#endif
+    BIF_RET(r);
+ immediate:
+    r =  erts_make_ref(p);
+#if DDLL_SMP 
+    erts_smp_proc_unlock(p, plocks);
+#endif
+    notify_proc(p, r, name_term, immediate_type, immediate_tag, 0);
+#if DDLL_SMP
+    unlock_drv_list();
+    erts_smp_proc_lock(p, plocks);
+#endif
+    BIF_RET(r);
+}
+
+
+static int is_last_user(DE_Handle *dh, Process *proc) {
+    DE_ProcEntry *p = dh->procs;
+    int found = 0;
+
+    assert_drv_list_locked();
+
+    while (p != NULL) {
+	if (p->proc == proc && p->awaiting_status == ERL_DE_PROC_LOADED) {
+	    if (found == 0) {
+		found = 1;
+	    } else {
+		return 0;
+	    }
+	} else if (p->awaiting_status == ERL_DE_PROC_LOADED) {
+	    return 0;
+	}
+	p = p->next;
+    }
+    return found;
+}
+    
+static DE_ProcEntry *find_proc_entry(DE_Handle *dh, Process *proc, Uint status)
+{
+    DE_ProcEntry *p = dh->procs;
+
+    assert_drv_list_locked();
+
+    while (p != NULL) {
+	if (p->proc == proc && p->awaiting_status == status) {
+	    return p;
+	}
+	p = p->next;
+    }
+    return NULL;
+}
+
+static void remove_proc_entry(DE_Handle *dh, DE_ProcEntry *pe)
+{
+    DE_ProcEntry **p = &(dh->procs);
+
+    while (*p != NULL && *p != pe) {
+	p = &((*p)->next);
+    }
+    if ((*p) != NULL) {
+	*p = (*p)->next;
+    }
+}
+
+static int num_procs(DE_Handle *dh, Uint status) {
+    DE_ProcEntry *p = dh->procs;
+    int i = 0;
+
+    assert_drv_list_locked();
+
+    while (p != NULL) {
+	if (p->awaiting_status == status) {
+	    ++i;
+	}
+	p = p->next;
+    }
+    return i;
+}
+/*
+static int num_entries(DE_Handle *dh, Process *proc, Uint status) {    
+    DE_ProcEntry *p = dh->procs;
+    int i = 0;
+
+    assert_drv_list_locked();
+    while (p != NULL) {
+	if (p->awaiting_status == status && p->proc == proc) {
+	    ++i;
+	}
+	p = p->next;
+    }
+    return i;
+}
+*/
+static void add_proc_loaded(DE_Handle *dh, Process *proc) 
+{
+    DE_ProcEntry *p;
+    assert_drv_list_locked();
+    p = erts_alloc(ERTS_ALC_T_DDLL_PROCESS, sizeof(DE_ProcEntry));
+    p->proc = proc;
+    p->flags = 0;
+    p->awaiting_status = ERL_DE_PROC_LOADED;
+    p->next = dh->procs;
+    dh->procs = p;
+}
+
+static void add_proc_loaded_deref(DE_Handle *dh, Process *proc) 
+{
+    DE_ProcEntry *p;
+    assert_drv_list_locked();
+    p = erts_alloc(ERTS_ALC_T_DDLL_PROCESS, sizeof(DE_ProcEntry));
+    p->proc = proc;
+    p->awaiting_status = ERL_DE_PROC_LOADED;
+    p->flags = ERL_DE_FL_DEREFERENCED;
+    p->next = dh->procs;
+    dh->procs = p;
+}
+
+static Eterm copy_ref(Eterm ref, Eterm *hp)
+{
+    RefThing *ptr = ref_thing_ptr(ref);
+    memcpy(hp, ptr, sizeof(RefThing));
+    return (make_internal_ref(hp));
+}
+
+static void add_proc_waiting(DE_Handle *dh, Process *proc, 
+			     Uint status, Eterm ref) 
+{
+    DE_ProcEntry *p;
+    assert_drv_list_locked();
+    p = erts_alloc(ERTS_ALC_T_DDLL_PROCESS, sizeof(DE_ProcEntry));
+    p->proc = proc;
+    p->flags = 0;
+    p->awaiting_status = status;
+    copy_ref(ref, p->heap);
+    p->next = dh->procs;
+    dh->procs = p;
+}
+
+static Eterm add_monitor(Process *p, DE_Handle *dh, Uint status)
+{
+    Eterm r;
+
+    assert_drv_list_locked();
+    r = erts_make_ref(p);
+    add_proc_waiting(dh, p, status, r);
+    return r;
+}
+    
+
+static void set_driver_reloading(DE_Handle *dh, Process *proc, char *path, char *name, Uint flags)
+{
+    DE_ProcEntry *p;
+
+    assert_drv_list_locked();
+    p = erts_alloc(ERTS_ALC_T_DDLL_PROCESS, sizeof(DE_ProcEntry));
+    p->proc = proc;
+    p->awaiting_status = ERL_DE_OK;
+    p->next = dh->procs;
+    p->flags = ERL_DE_FL_DEREFERENCED;
+    dh->procs = p;
+    dh->status = ERL_DE_RELOAD;
+    dh->reload_full_path = erts_alloc(ERTS_ALC_T_DDLL_HANDLE, sys_strlen(path) + 1);
+    strcpy(dh->reload_full_path,path);
+    dh->reload_driver_name = erts_alloc(ERTS_ALC_T_DDLL_HANDLE, sys_strlen(name) + 1);
+    strcpy(dh->reload_driver_name,name);
+    dh->reload_flags = flags;
+}
+
+static int do_load_driver_entry(DE_Handle *dh, char *path, char *name)
+{
+    void *init_handle;
+    int res;
+    ErlDrvEntry *dp;
+
+    assert_drv_list_locked();
+
+    if ((res =  erts_sys_ddll_open(path, &(dh->handle))) != ERL_DE_NO_ERROR) {
+	return res;
+    }
+    
+    if ((res = erts_sys_ddll_load_driver_init(dh->handle, 
+					      &init_handle)) != ERL_DE_NO_ERROR) {
+	erts_sys_ddll_close(dh->handle);
+	return ERL_DE_LOAD_ERROR_NO_INIT;
+    }
+    
+    dp = erts_sys_ddll_call_init(init_handle);
+    if (dp == NULL) {
+	erts_sys_ddll_close(dh->handle);
+	return ERL_DE_LOAD_ERROR_FAILED_INIT;
+    }
+
+    switch (dp->extended_marker) {
+    case 0:
+	/*
+	 * This may be an old driver that has been recompiled. If so,
+	 * at least the fields that existed in extended driver version
+	 * 1.0 should be zero. If not, a it is a bad driver. We cannot
+	 * be completely certain that this is a valid driver but this is
+	 * the best we can do with old drivers...
+	 */
+	if (dp->major_version != 0
+	    || dp->minor_version != 0
+	    || dp->driver_flags != 0
+	    || dp->handle2 != NULL
+	    || dp->process_exit != NULL) {
+	    /* Old driver; needs to be recompiled... */
+	    return ERL_DE_LOAD_ERROR_INCORRECT_VERSION;
+	}
+	break;
+    case ERL_DRV_EXTENDED_MARKER:
+	if (ERL_DRV_EXTENDED_MAJOR_VERSION != dp->major_version
+	    || ERL_DRV_EXTENDED_MINOR_VERSION < dp->minor_version) {
+	    /* Incompatible driver version */
+	    return ERL_DE_LOAD_ERROR_INCORRECT_VERSION;
+	}
+	break;
+    default:
+	/* Old driver; needs to be recompiled... */
+	return ERL_DE_LOAD_ERROR_INCORRECT_VERSION;
+    }
+
+    if (strcmp(name, dp->driver_name) != 0) {
+	erts_sys_ddll_close(dh->handle);
+	return ERL_DE_LOAD_ERROR_BAD_NAME;
+    }
+    erts_smp_atomic_init(&(dh->refc), (long) 0);
+    dh->port_count = 0;
+    dh->full_path = erts_alloc(ERTS_ALC_T_DDLL_HANDLE, sys_strlen(path) + 1);
+    sys_strcpy(dh->full_path, path);
+    dh->flags = 0;
+    dh->status = ERL_DE_OK;
+
+    if (erts_add_driver_entry(dp, dh, 1) != 0 /* io.c */) { 
+	/*
+	 * The init in the driver struct did not return 0 
+	 */
+	erts_free(ERTS_ALC_T_DDLL_HANDLE, dh->full_path);
+	dh->full_path = NULL;
+	erts_sys_ddll_close(dh->handle);
+	return ERL_DE_LOAD_ERROR_FAILED_INIT;
+    }
+
+    return ERL_DE_NO_ERROR;
+}
+
+static int do_unload_driver_entry(DE_Handle *dh, Eterm *save_name)
+{
+    erts_driver_t *q, *p = driver_list;
+
+    assert_drv_list_locked();
+
+    while (p != NULL) {
+	if (p->handle == dh) {
+		
+	    q = p;
+	    if (p->prev == NULL) {
+		driver_list = p->next;
+	    } else {
+		p->prev->next = p->next;
+	    }
+	    if (p->next != NULL) {
+		p->next->prev = p->prev;
+	    }
+
+	    if (save_name != NULL) {
+		*save_name = mkatom(q->name);
+	    } 
+	    /* XXX:PaN Future locking problems? Don't dare to let go of the diver_list lock here!*/
+	    if (q->finish) {
+		int fpe_was_unmasked = erts_block_fpe();
+		(*(q->finish))();
+		erts_unblock_fpe(fpe_was_unmasked);
+	    }
+	    erts_sys_ddll_close(dh->handle);
+	    erts_destroy_driver(q);
+	    return 1;
+	}
+	p = p->next;
+    }
+    return 0;
+}
+
+static int load_driver_entry(DE_Handle **dhp, char *path, char *name)
+{
+    int res;
+    DE_Handle *dh = erts_alloc(ERTS_ALC_T_DDLL_HANDLE, sizeof(DE_Handle));
+
+    assert_drv_list_locked();
+
+    dh->handle = NULL;
+    dh->procs = NULL;
+    dh->port_count = 0;
+    erts_refc_init(&(dh->refc), (long) 0);
+    dh->status = -1;
+    dh->reload_full_path = NULL;
+    dh->reload_driver_name = NULL;
+    dh->reload_flags = 0;
+    dh->full_path = NULL;
+    dh->flags = 0;
+
+    if ((res = do_load_driver_entry(dh, path, name)) != ERL_DE_NO_ERROR) {
+	erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh);
+	dh = NULL;
+    }
+    *dhp = dh;
+    return res;
+}
+
+#if 0
+static void unload_driver_entry(DE_Handle *dh)
+{
+    do_unload_driver_entry(dh, NULL);
+    if (dh->full_path != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh->full_path);
+    }
+    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh);
+}
+#endif
+static int reload_driver_entry(DE_Handle *dh)
+{
+    char *path = dh->reload_full_path;
+    char *name = dh->reload_driver_name;
+    int loadres;
+    Uint flags = dh->reload_flags;
+
+    assert_drv_list_locked();
+
+    dh->reload_full_path = NULL;
+    dh->reload_driver_name = NULL;
+
+    ASSERT(erts_refc_read(&(dh->refc),0) == 0);
+    ASSERT(dh->full_path != NULL);
+    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) dh->full_path);
+    dh->full_path = NULL;
+
+    loadres = do_load_driver_entry(dh, path, name);
+    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) path);
+    erts_free(ERTS_ALC_T_DDLL_HANDLE, (void *) name);
+    if (loadres == ERL_DE_NO_ERROR) {
+	dh->status = ERL_DE_OK;
+	dh->flags = flags;
+    }
+    restore_process_references(dh);
+    return loadres;
+}
+ 
+/*
+ * Notification {tag = atom(), ref = ref(), driver_name = atom()} or
+ *              {'$DDLL_load_failure', ref = ref(), driver_name = atom(), 
+ *               error_term = atom() | {system_error, int()}}
+ */
+   
+static void notify_proc(Process *proc, Eterm ref, Eterm driver_name, Eterm type, 
+			Eterm tag, int errcode)
+{
+    Eterm mess;
+    Eterm r;
+    Eterm *hp;
+    ErlHeapFragment *bp;
+    ErlOffHeap *ohp;
+    ErtsProcLocks rp_locks = 0;
+    ERTS_SMP_CHK_NO_PROC_LOCKS;
+
+    assert_drv_list_locked();
+    if (errcode != 0) {
+	int need = load_error_need(errcode);
+	Eterm e;
+	hp = erts_alloc_message_heap(6 /* tuple */ + 3 /* Error tuple */ + 
+				     REF_THING_SIZE + need, &bp, &ohp, 
+				     proc, &rp_locks);
+	r = copy_ref(ref,hp);
+	hp += REF_THING_SIZE;
+	e = build_load_error_hp(hp, errcode);
+	hp += need;
+	mess = TUPLE2(hp,tag,e);
+	hp += 3;
+	mess = TUPLE5(hp,type,r,am_driver,driver_name,mess);
+    } else {	
+	hp = erts_alloc_message_heap(6 /* tuple */ + REF_THING_SIZE, &bp, &ohp, proc, &rp_locks);
+	r = copy_ref(ref,hp);
+	hp += REF_THING_SIZE;
+	mess = TUPLE5(hp,type,r,am_driver,driver_name,tag);
+    }
+    erts_queue_message(proc, &rp_locks, bp, mess, am_undefined);
+    erts_smp_proc_unlock(proc, rp_locks);
+    ERTS_SMP_CHK_NO_PROC_LOCKS;
+}
+
+static void notify_all(DE_Handle *dh, char *name, Uint awaiting, Eterm type, Eterm tag)
+{
+    DE_ProcEntry **p;
+
+    assert_drv_list_locked();
+
+    p = &(dh->procs);
+    while (*p != NULL) {
+	if ((*p)->awaiting_status == awaiting) {
+	    DE_ProcEntry *pe;
+	    pe = *p;
+	    *p = pe->next;
+	    notify_proc(pe->proc, make_internal_ref(&(pe->heap)), mkatom(name), type, tag, 0);
+	    erts_free(ERTS_ALC_T_DDLL_PROCESS, (void *) pe);
+	} else {
+	    p = &((*p)->next);
+	}
+    }
+}
+
+
+
+typedef struct errcode_entry {
+    char *atm;
+    int code;
+} ErrcodeEntry;
+
+static ErrcodeEntry errcode_tab[] = {
+    {"no_error", ERL_DE_NO_ERROR},
+    {"no_driver_init", ERL_DE_LOAD_ERROR_NO_INIT},
+    {"driver_init_failed", ERL_DE_LOAD_ERROR_FAILED_INIT},
+    {"bad_driver_name", ERL_DE_LOAD_ERROR_BAD_NAME},
+    {"driver_name_to_long", ERL_DE_LOAD_ERROR_NAME_TO_LONG},
+    {"driver_incorrect_version", ERL_DE_LOAD_ERROR_INCORRECT_VERSION},
+    {"no_ddll_available",  ERL_DE_ERROR_NO_DDLL_FUNCTIONALITY},
+    {"unspecified_error", ERL_DE_ERROR_UNSPECIFIED},
+    {"symbol_not_found", ERL_DE_LOOKUP_ERROR_NOT_FOUND},
+    {NULL,0}
+};
+
+static int errdesc_to_code(Eterm errdesc, int *code /* out */)
+{
+    int i;
+    if (is_atom(errdesc)) {
+	Atom *ap = atom_tab(atom_val(errdesc)); 
+	for (i = 0; errcode_tab[i].atm != NULL; ++i) {
+	    int len = sys_strlen(errcode_tab[i].atm);
+	    if (len == ap->len && 
+		!sys_strncmp(errcode_tab[i].atm,(char *) ap->name,len)) {
+		*code = errcode_tab[i].code;
+		return 0;
+	    }
+	}
+	return -1;
+    } else if (is_tuple(errdesc)) {
+	Eterm *tp = tuple_val(errdesc);
+	if (*tp != make_arityval(2) || tp[1] != am_open_error || is_not_small(tp[2])) {
+	    return -1;
+	}
+	*code = signed_val(tp[2]);
+	return 0;
+    }
+    return -1;
+}
+
+static Eterm build_load_error(Process *p, int code)
+{
+    int need = load_error_need(code);
+    Eterm *hp = NULL;
+    ERTS_SMP_LC_ASSERT(ERTS_PROC_LOCK_MAIN & erts_proc_lc_my_proc_locks(p));
+    if (need) {
+	hp = HAlloc(p,need);
+    }
+    return build_load_error_hp(hp,code);
+}
+    
+static int load_error_need(int code)
+{
+    ErrcodeEntry *ee = errcode_tab;
+    while (ee->atm != NULL) {
+	if (ee->code == code) {
+	    return 0;
+	}
+	++ee;
+    }
+    return 3;
+}
+
+static Eterm build_load_error_hp(Eterm *hp, int code)
+{
+    ErrcodeEntry *ee = errcode_tab;
+    while (ee->atm != NULL) {
+	if (ee->code == code) {
+	    return mkatom(ee->atm);
+	}
+	++ee;
+    }
+    return TUPLE2(hp,am_open_error, make_small(code));
+}
+    
+
+
+static Eterm mkatom(char *str)
+{
+    return am_atom_put(str, sys_strlen(str));
+}
+
+static char *pick_list_or_atom(Eterm name_term)
+{ 
+    char *name = NULL;
+    int name_len;
+    if (is_atom(name_term)) {
+	Atom *ap = atom_tab(atom_val(name_term));
+	if (ap->len == 0) {
+	    /* If io_lists with zero length is not allowed, 
+	       then the empty atom shouldn't */
+	    goto error;
+	}
+	name = erts_alloc(ERTS_ALC_T_DDLL_TMP_BUF, ap->len + 1);
+	memcpy(name,ap->name,ap->len);
+	name[ap->len] = '\0';
+    } else {
+	name_len = io_list_len(name_term);
+	if (name_len <= 0) {
+	    goto error;
+	}
+	name = erts_alloc(ERTS_ALC_T_DDLL_TMP_BUF, name_len + 1);
+	if (io_list_to_buf(name_term, name, name_len) != 0) {
+	    goto error;
+	}
+	name[name_len] = '\0';
+    }
+    return name;
+ error:
+    if (name != NULL) {
+	erts_free(ERTS_ALC_T_DDLL_TMP_BUF, (void *) name);
+    }
+    return NULL;
+}
+
+static int build_proc_info(DE_Handle *dh, ProcEntryInfo **out_pei, Uint filter)
+{
+    ProcEntryInfo *pei = NULL;
+    int num_pei = 0;
+    int num_pei_allocated = 0;
+    int i;
+    DE_ProcEntry *pe;
+
+    assert_drv_list_locked();
+
+    for (pe = dh->procs; pe != NULL; pe = pe->next) {
+	Eterm id = pe->proc->id;
+	Uint stat = pe->awaiting_status;
+	if (stat == ERL_DE_PROC_AWAIT_UNLOAD_ONLY) {
+	    stat = ERL_DE_PROC_AWAIT_UNLOAD;
+	}
+	if (stat != filter) {
+	    continue;
+	}
+	for (i = 0; i < num_pei; ++i) {
+	    if (pei[i].pid == id && pei[i].status == stat) {
+		break;
+	    }
+	}
+	if (i < num_pei) {
+	    pei[i].count++;
+	} else {
+	    if (num_pei >= num_pei_allocated) {
+		pei = (pei == NULL) 
+		    ? erts_alloc(ERTS_ALC_T_DDLL_TMP_BUF, 
+				 sizeof(ProcEntryInfo) * (num_pei_allocated = 10))
+		    : erts_realloc(ERTS_ALC_T_DDLL_TMP_BUF, pei,
+				   sizeof(ProcEntryInfo) * (num_pei_allocated += 10));
+	    }
+	    pei[num_pei].pid = id;
+	    pei[num_pei].proc = pe->proc;
+	    pei[num_pei].status = stat;
+	    pei[num_pei].count = 1;
+	    ++num_pei;
+	}
+    }
+    *out_pei = pei;
+    return num_pei;
+}
+	    
+    
+
+static erts_driver_t *lookup_driver(char *name)
+{
+    erts_driver_t *drv;
+    assert_drv_list_locked();
+    for (drv = driver_list; drv != NULL && strcmp(drv->name, name); drv = drv->next)
+	;
+    return drv;
+}