OTP-8335 Even more NIF features

30 files changed, 2817 insertions, 344 deletions

diff --git a/erts/doc/src/erl_driver.xml b/erts/doc/src/erl_driver.xml
index 5d7a11b70a..63108f41f0 100644
--- a/erts/doc/src/erl_driver.xml
+++ b/erts/doc/src/erl_driver.xml
@@ -299,6 +299,8 @@ typedef struct ErlDrvSysInfo {
    int smp_support;
    int async_threads;
    int scheduler_threads;
+   int nif_major_version;
+   int nif_minor_version;
 } ErlDrvSysInfo;
       </code>
 
@@ -365,9 +367,14 @@ typedef struct ErlDrvSysInfo {
            (the same as returned by
           <seealso marker="erts:erlang#system_info_schedulers">erlang:system_info(schedulers)</seealso>).
         </item>
+        <tag><c>nif_major_version</c></tag>
+        <item>The value of <c>ERL_NIF_MAJOR_VERSION</c> when the runtime system was compiled.
+        </item>
+        <tag><c>nif_minor_version</c></tag>
+        <item>The value of <c>ERL_NIF_MINOR_VERSION</c> when the runtime system was compiled.
+        </item>
         </taglist>
       </item>
-
       <tag><marker id="ErlDrvBinary"/>ErlDrvBinary</tag>
       <item>
       <p/>
diff --git a/erts/doc/src/erl_nif.xml b/erts/doc/src/erl_nif.xml
index 2902d70976..c013d96fc4 100644
--- a/erts/doc/src/erl_nif.xml
+++ b/erts/doc/src/erl_nif.xml
@@ -41,7 +41,9 @@
 	</p><p><em>R13B04</em>: The function prototypes of the NIFs
 	have changed to expect <c>argc</c> and <c>argv</c>
 	arguments. The arity of a NIF is by that no longer limited to
-	3.</p></warning>
+	3.</p>
+  <p>enif_get_data renamed as enif_priv_data.</p>
+  </warning>
 
     <p>A NIF library contains native implementation of some functions
     of an erlang module. The native implemented functions (NIFs) are
@@ -113,16 +115,71 @@ ok
      dynamic library will mean that static data defined by the library
      will be shared as well. To avoid unintentionally shared static
      data, each Erlang module code can keep its own private data. This
-     global private data can be set when the NIF library is loaded and
-     then retrieved by calling <seealso marker="erl_nif#enif_get_data">enif_get_data()</seealso>.</p>
-    <p>There is currently no way to explicitly unload a NIF
-     library. A library will be automatically unloaded when the module
-     code that it belongs to is purged by the code server. A NIF
-     library will can also be unloaded by replacing it with another
-     version of the library by a second call to
+     private data can be set when the NIF library is loaded and
+     then retrieved by calling <seealso marker="erl_nif#enif_priv_data">enif_priv_data()</seealso>.</p>
+    <p>There is no way to explicitly unload a NIF library. A library will be
+     automatically unloaded when the module code that it belongs to is purged
+     by the code server. A NIF library will also be unloaded if it is replaced
+     by another version of the library by a second call to
      <c>erlang:load_nif/2</c> from the same module code.</p> 
   </description>
-
+  <section>
+  <title>FUNCTIONALITY</title>
+  <p>All functions that a NIF library needs to do with Erlang are
+      performed through the NIF API functions. There are functions
+      for the following functionality:</p>
+    <taglist>
+      <tag>Read and write Erlang terms</tag>
+      <item><p>Any Erlang terms can be passed to a NIF as function arguments and
+      be returned as function return value. The terms are of C-type <c>ERL_NIF_TERM</c>
+      and can only be read or written using API functions. Most functions to read
+      the content of a term are prefixed <c>enif_get_</c> and usually return
+      true (or false) if the term was of the expected type (or not).    
+      The functions to write terms are all prefixed <c>enif_make_</c> and usually
+      return the created <c>ERL_NIF_TERM</c>. There are also some functions
+      to query terms, like <c>enif_is_atom</c>, <c>enif_is_identical</c> and
+      <c>enif_compare</c>.</p></item>
+      <tag>Resource objects</tag>
+      <item><p>Resource objects are a way to return pointers to native data
+      structures from a NIF in a safe way. A resource object is just a block
+      of memory allocated with <seealso marker="erl_nif#enif_alloc_resource">enif_alloc_resource()</seealso>.
+      A handle ("safe pointer") to this memory block can then be returned to Erlang by the use of
+      <seealso marker="erl_nif#enif_make_resource">enif_make_resource()</seealso>.
+      The term returned by <c>enif_make_resource</c>
+      is totally opaque in nature. It can be stored and passed between processses
+      on the same node, but the only real end usage is to pass it back as argument to a NIF.
+      The NIF can then do <seealso marker="erl_nif#enif_get_resource">enif_get_resource()</seealso>
+      and get back a pointer to the memory block that is guaranteed to still be
+      valid. A resource object will not be deallocated until the last handle term
+      has been garbage collected by the VM and the resource has been
+      released with <seealso marker="erl_nif#enif_release_resource">enif_release_resource()</seealso>
+      (not necessarily in that order).</p>      
+      <p>All resource objects are created as instances of some <em>resource type</em>.
+      This makes resources from different modules or applications to be distinguishable. 
+      A resource type is created by calling
+      <seealso marker="erl_nif#enif_open_resource_type">enif_open_resource_type()</seealso>
+      when a library is loaded. Objects of that resource type can then later be allocated
+      and <c>enif_get_resource</c> verifies that the resource is of the expected type.
+      A resource type can have a destructor function that is automatically
+      called when resources of that type are released (by either the garbage
+      collector or <c>enif_release_resource</c>). Resource types also support
+      upgrade in runtime by allowing a loaded NIF library to takeover an already
+      existing resource type and thereby "inherit" all existing objects of that type.
+      The destructor of the new library will thereafter be called for the inherited
+      objects and the library with the old destructor function can be safely
+      unloaded. Resource types are uniquely identified by a supplied name string.
+      </p>
+      </item>
+      <tag>Threads and concurrency</tag>
+      <item><p>A NIF is thread-safe without any explicit synchronization as
+      long as it acts as a pure function and only operates on the supplied
+      arguments. As soon as you access a shared state either through static
+      variables or <seealso marker="erl_nif#enif_priv_data">enif_priv_data</seealso>
+      you need to supply your own explicit synchronization.</p>
+      <p>The library initialization callbacks <c>load</c>, <c>reload</c> and
+      <c>upgrade</c> are all thread-safe even for shared state data.</p></item>
+    </taglist>
+  </section>
   <section>
     <title>INITIALIZATION</title>
     <taglist>
@@ -146,7 +203,7 @@ ok
         and there is no previously loaded library for this module.</p>
         <p><c>*priv_data</c> can be set to point to some private data
            that the library needs in able to keep a state between NIF 
-           calls. <c>enif_get_data()</c> will return this pointer.</p> 
+           calls. <c>enif_priv_data()</c> will return this pointer.</p> 
         <p><c>load_info</c> is the second argument to <seealso
            marker="erlang#load_nif-2">erlang:load_nif/2</seealso>.</p>
         <p>The library will fail to load if <c>load</c> returns
@@ -168,13 +225,11 @@ ok
       <tag><marker id="upgrade"/>int (*upgrade)(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)</tag>
        <item><p><c>upgrade</c> is called when the NIF library is loaded
         and there is no previously loaded library for this module
-        code, BUT there is old code of this module with a
-        loaded NIF library.</p>
+        code, BUT there is old code of this module with a loaded NIF library.</p>
         <p>Works the same as <c>load</c>. The only difference is that
         <c>*old_priv_data</c> already contains the value set by the
          last call to <c>load</c> or <c>reload</c> for the old module
-         code. It is allowed to write to both *priv_data and
-         *old_priv_data.</p> 
+         code. It is allowed to write to both *priv_data and *old_priv_data.</p> 
         <p>The library will fail to load if <c>upgrade</c> returns
            anything other than 0 or if <c>upgrade</c> is NULL.</p>
       </item>
@@ -185,7 +240,6 @@ ok
        of the same module may or may not exist.</p>
       </item>
 
-
     </taglist>
   </section>
 
@@ -193,6 +247,14 @@ ok
     <title>DATA TYPES</title>
 
     <taglist>
+      <tag><marker id="ERL_NIF_TERM"/>ERL_NIF_TERM</tag>
+       <item>
+        <p>Variables of type <c>ERL_NIF_TERM</c> can refer to any Erlang term.
+        This is an opaque type and values of it can only by used either as
+        arguments to API functions or as return values from NIFs. A variable of
+        type <c>ERL_NIF_TERM</c> is only valid until the NIF call, where it was
+        obtained, returns.</p>
+      </item>
      <tag><marker id="ErlNifEnv"/>ErlNifEnv</tag>
       <item>
         <p><c>ErlNifEnv</c> contains information about the context in
@@ -236,15 +298,41 @@ typedef struct {
           inspected binary term. <c>data</c> is a pointer to a buffer
           of <c>size</c> bytes with the raw content of the binary.</p>
       </item>
-      <tag><marker id="ERL_NIF_TERM"/>ERL_NIF_TERM</tag>
+      <tag><marker id="ErlNifResourceType"/>ErlNifResourceType</tag>
        <item>
-        <p>Variables of type <c>ERL_NIF_TERM</c> can refere to any
-        Erlang term. This is an opaque type and values of it can only
-        by used either as arguments to API functions or as return
-        values from NIFs. A variable of type <c>ERL_NIF_TERM</c> is
-        only valid until the NIF call, where it was obtained,
-        returns.</p>
-      </item>
+          <p>Each instance of <c>ErlNifResourceType</c> represent a class of
+          memory managed resource objects that can be garbage collected.
+          Each resource type has a unique name and a destructor function that
+          is called when objects of its type are released.</p>
+        </item>
+        <tag><marker id="ErlNifResourceDtor"/>ErlNifResourceDtor</tag>
+         <item>
+           <p/>
+           <code type="none">
+typedef void ErlNifResourceDtor(ErlNifEnv* env, void* obj);
+</code>
+            <p>The function prototype of a resource destructor function.
+            A destructor function is not allowed to call any term-making functions.</p>
+          </item>
+          <tag><marker id="ErlNifCharEncoding"/>ErlNifCharEncoding</tag>
+           <item>
+             <p/>
+             <code type="none">
+typedef enum {
+    ERL_NIF_LATIN1
+}ErlNifCharEncoding;
+</code>
+              <p>The character encoding used in strings. The only supported
+              encoding is currently <c>ERL_NIF_LATIN1</c> for iso-latin-1
+              (8-bit ascii).</p>
+            </item>
+            <tag><marker id="ErlNifSysInfo"/>ErlNifSysInfo</tag>
+             <item>
+                <p>Used by <seealso marker="erl_nif#enif_system_info">enif_system_info</seealso>
+                to return information about the runtime system. Contains currently
+                the exact same content as <seealso marker="erl_driver#ErlDrvSysInfo">ErlDrvSysInfo</seealso>.</p>
+              </item>
+
     </taglist>
   </section>
 
@@ -257,7 +345,18 @@ typedef struct {
       <fsummary>Create a new binary.</fsummary>
       <desc><p>Allocate a new binary of size of <c>size</c>
       bytes. Initialize the structure pointed to by <c>bin</c> to
-      refer to the allocated binary. Return false if allocation failed.</p></desc>
+      refer to the allocated binary. The binary must either be released by 
+      <seealso marker="erl_nif#enif_release_binary">enif_release_binary()</seealso> 
+      or ownership transferred to an erlang term with 
+      <seealso marker="erl_nif#enif_make_binary">enif_make_binary()</seealso>. 
+      An allocated (and owned) <c>ErlNifBinary</c> can be kept between NIF
+      calls.</p>
+        <p>Return false if allocation failed.</p>
+      </desc>
+    </func>
+    <func><name><ret>void*</ret><nametext>enif_alloc_resource(ErlNifEnv* env, ErlNifResourceType* type, unsigned size)</nametext></name>
+      <fsummary>Allocate a memory managed resource object</fsummary>
+      <desc><p>Allocate a memory managed resource object of type <c>type</c> and size <c>size</c> bytes.</p></desc>
     </func>
     <func><name><ret>int</ret><nametext>enif_compare(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)</nametext></name>
       <fsummary>Compare two terms</fsummary>
@@ -267,13 +366,50 @@ typedef struct {
       operators <c>==</c>, <c>/=</c>, <c>=&lt;</c>, <c>&lt;</c>,
       <c>&gt;=</c> and <c>&gt;</c> (but <em>not</em> <c>=:=</c> or <c>=/=</c>).</p></desc>
     </func>
+    <func><name><ret>void</ret><nametext>enif_cond_broadcast(ErlNifCond *cnd)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_cond_broadcast">erl_drv_cond_broadcast()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>ErlNifCond*</ret><nametext>enif_cond_create(char *name)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_cond_create">erl_drv_cond_create()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_cond_destroy(ErlNifCond *cnd)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_cond_destroy">erl_drv_cond_destroy()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_cond_signal(ErlNifCond *cnd)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_cond_signal">erl_drv_cond_signal()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_cond_wait">erl_drv_cond_wait()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_equal_tids">erl_drv_equal_tids()</seealso>.
+          </p></desc>
+    </func>
     <func><name><ret>void</ret><nametext>enif_free(ErlNifEnv* env, void* ptr)</nametext></name>
       <fsummary>Free dynamic memory</fsummary>
       <desc><p>Free memory allocated by <c>enif_alloc</c>.</p></desc>
     </func>
-    <func><name><ret>void*</ret><nametext>enif_get_data(ErlNifEnv* env)</nametext></name>
-      <fsummary>Get the private data of a NIF library</fsummary>
-      <desc><p>Return the pointer to the private data that was set by <c>load</c>, <c>reload</c> or <c>upgrade</c>.</p></desc>
+    <func><name><ret>int</ret><nametext>enif_get_atom(ErlNifEnv* env, 
+                  ERL_NIF_TERM term, char* buf, unsigned size)
+                             </nametext></name>
+      <fsummary>Get the text representation of an atom term</fsummary>
+      <desc><p>Write a null-terminated string, in the buffer pointed to by
+              <c>buf</c> of size <c>size</c>, consisting of the string 
+              representation of the atom <c>term</c>. Return the number of bytes
+              written (including terminating null character) or 0 if
+              <c>term</c> is not an atom with maximum length of 
+              <c>size-1</c>.</p></desc>
     </func>
     <func><name><ret>int</ret><nametext>enif_get_double(ErlNifEnv* env, ERL_NIF_TERM term, double* dp)</nametext></name>
       <fsummary>Read a floating-point number term.</fsummary>
@@ -292,16 +428,49 @@ typedef struct {
       <c>list</c> or return false if <c>list</c> is not a non-empty
       list.</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_get_long(ErlNifEnv* env, ERL_NIF_TERM term, long int* ip)</nametext></name>
+      <fsummary>Read an long integer term.</fsummary>
+      <desc><p>Set <c>*ip</c> to the long integer value of
+      <c>term</c> or return false if <c>term</c> is not an integer or is
+      outside the bounds of type <c>long int</c>.</p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp)</nametext></name>
+      <fsummary>Get the pointer to a resource object</fsummary>
+      <desc><p>Set <c>*objp</c> to point to the resource object referred to by <c>term</c>.
+      Return false if <c>term</c> is not a handle to a resource object of type <c>type</c>.</p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_get_string(ErlNifEnv* env, 
+                                ERL_NIF_TERM list, char* buf, unsigned size,
+                                ErlNifCharEncoding encode)</nametext></name>
+      <fsummary>Get a C-string from a list.</fsummary>
+      <desc><p>Write a null-terminated string, in the buffer pointed to by
+              <c>buf</c> with size <c>size</c>, consisting of the characters
+              in the string <c>list</c>. The characters are written using encoding
+              <c>encode</c>. Return the number of bytes written
+              (including terminating null character), or <c>-size</c> if the
+              string was truncated due to buffer space, or 0 if <c>list</c>
+              is not a string that can be encoded with <c>encode</c> or
+              if <c>size</c> was less than 1.              
+              The written string is always null-terminated unless buffer
+              <c>size</c> is less than 1.</p></desc>
+    </func>
     <func><name><ret>int</ret><nametext>enif_get_tuple(ErlNifEnv* env, ERL_NIF_TERM term, int* arity, const ERL_NIF_TERM** array)</nametext></name>
       <fsummary>Inspect the elements of a tuple.</fsummary>
       <desc><p>If <c>term</c> is a tuple, set <c>*array</c> to point
       to an array containing the elements of the tuple and set
       <c>*arity</c> to the number of elements. Note that the array
-      is read-only an <c>(*array)[N-1]</c> will be the Nth element of
+      is read-only and <c>(*array)[N-1]</c> will be the Nth element of
       the tuple. <c>*array</c> is undefined if the arity of the tuple
       is zero.</p><p>Return false if <c>term</c> is not a
       tuple.</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_get_uint(ErlNifEnv* env, ERL_NIF_TERM term, unsigned int* ip)</nametext></name>
+      <fsummary>Read an unsigned integer term.</fsummary>
+      <desc><p>Set <c>*ip</c> to the unsigned integer value of
+      <c>term</c> or return false if <c>term</c> is not an unsigned integer or is
+      outside the bounds of type <c>unsigned int</c></p></desc>
+    </func>
+
     <func><name><ret>int</ret><nametext>enif_get_ulong(ErlNifEnv* env, ERL_NIF_TERM term, unsigned long* ip)</nametext></name>
       <fsummary>Read an unsigned integer term.</fsummary>
       <desc><p>Set <c>*ip</c> to the unsigned long integer value of
@@ -310,10 +479,21 @@ typedef struct {
     </func>
     <func><name><ret>int</ret><nametext>enif_inspect_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term, ErlNifBinary* bin)</nametext></name>
       <fsummary>Inspect the content of a binary</fsummary>
-      <desc><p>Initialize the structure pointed to by <c>bin</c> with
-      transient information about the binary term
+      <desc><p>Initialize the structure pointed to by <c>bin</c> with 
+              information about the binary term
       <c>bin_term</c>. Return false if <c>bin_term</c> is not a binary.</p></desc> 
     </func>
+    <func><name><ret>int</ret><nametext>enif_inspect_iolist_as_binary(ErlNifEnv* 
+                                env, ERL_NIF_TERM term, ErlNifBinary* bin)
+                              </nametext></name>
+      <fsummary>Inspect the content of an iolist</fsummary>
+      <desc><p>Initialize the structure pointed to by <c>bin</c> with one
+      continuous buffer with the same byte content as <c>iolist</c>. As with 
+      inspect_binary, the data pointed to by <c>bin</c> is transient and does 
+      not need to be released. Return false if <c>iolist</c> is not an
+      iolist.</p>
+      </desc> 
+    </func>
     <func><name><ret>int</ret><nametext>enif_is_atom(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
       <fsummary>Determine if a term is an atom</fsummary>
       <desc><p>Return true if <c>term</c> is an atom.</p></desc>
@@ -322,19 +502,36 @@ typedef struct {
       <fsummary>Determine if a term is a binary</fsummary>
       <desc><p>Return true if <c>term</c> is a binary</p></desc>
     </func>
+    <func><name><ret>int</ret><nametext>enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
+      <fsummary>Determine if a term is an empty list</fsummary>
+      <desc><p>Return true if <c>term</c> is an empty list.</p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
+      <fsummary>Determine if a term is a fun</fsummary>
+      <desc><p>Return true if <c>term</c> is a fun.</p></desc>
+    </func>
     <func><name><ret>int</ret><nametext>enif_is_identical(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs)</nametext></name>
       <fsummary>Erlang operator =:=</fsummary>
-      <desc><p>Return true if and only if the two terms are
-      identical. Corresponds to the Erlang operators <c>=:=</c> and
+      <desc><p>Return true if the two terms are identical. Corresponds to the
+      Erlang operators <c>=:=</c> and
       <c>=/=</c>.</p></desc> 
     </func>
+    <func><name><ret>int</ret><nametext>enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
+      <fsummary>Determine if a term is a pid</fsummary>
+      <desc><p>Return true if <c>term</c> is a pid.</p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
+      <fsummary>Determine if a term is a port</fsummary>
+      <desc><p>Return true if <c>term</c> is a port.</p></desc>
+    </func>
+
     <func><name><ret>int</ret><nametext>enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)</nametext></name>
       <fsummary>Determine if a term is a reference</fsummary>
       <desc><p>Return true if <c>term</c> is a reference.</p></desc>
     </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_atom(ErlNifEnv* env, const char* name)</nametext></name>
       <fsummary>Create an atom term</fsummary>
-      <desc><p>Create an atom term from the C-string <c>name</c>. Atom
+      <desc><p>Create an atom term from the C-string <c>name</c>. Unlike other terms, atom
       terms may be saved and used between NIF calls.</p></desc>
     </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_badarg(ErlNifEnv* env)</nametext></name>
@@ -343,8 +540,10 @@ typedef struct {
     </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)</nametext></name>
       <fsummary>Make a binary term.</fsummary>
-      <desc><p>Make a binary term from <c>bin</c>. Will also release
-      the binary.</p></desc>
+      <desc><p>Make a binary term from <c>bin</c>. Any ownership of 
+              the binary data will be transferred to the created term and
+              <c>bin</c> should be considered read-only for the rest of the NIF
+              call and then as released.</p></desc>
     </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_double(ErlNifEnv* env, double d)</nametext></name>
       <fsummary>Create an floating-point term</fsummary>
@@ -367,18 +566,62 @@ typedef struct {
       <c>cnt</c> number of arguments (after <c>cnt</c>) of type ERL_NIF_TERM as the
       elements of the list. An empty list is returned if <c>cnt</c> is 0.</p></desc>
     </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list1(ErlNifEnv* env, ERL_NIF_TERM e1)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)</nametext></name>
+      <fsummary>Create a list term.</fsummary>
+      <desc><p>Create an ordinary list term with length indicated by the
+      function name. Prefere these functions (macros) over the variadic
+      <c>enif_make_list</c>  to get compile time error if the number of
+      arguments does not match.</p></desc>
+    </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list_cell(ErlNifEnv* env, ERL_NIF_TERM head, ERL_NIF_TERM tail)</nametext></name>
       <fsummary>Create a list cell.</fsummary>
       <desc><p>Create a list cell <c>[head | tail]</c>.</p></desc>
     </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)</nametext></name>
+      <fsummary>Create a list term from an array.</fsummary>
+      <desc><p>Create an ordinary list containing the elements of array <c>arr</c>
+      of length <c>cnt</c>. An empty list is returned if <c>cnt</c> is 0.</p></desc>
+    </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_long(ErlNifEnv* env, long int i)</nametext></name>
+      <fsummary>Create an integer term from a long int</fsummary>
+      <desc><p>Create an integer term from a <c>long int</c>.</p></desc>
+    </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_ref(ErlNifEnv* env)</nametext></name>
       <fsummary>Create a reference.</fsummary>
       <desc><p>Create a reference like <seealso marker="erlang#make_ref-0">erlang:make_ref/0</seealso>.</p></desc>
     </func>
-    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_string(ErlNifEnv* env, const char* string)</nametext></name>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_resource(ErlNifEnv* env, void* obj)</nametext></name>
+      <fsummary>Create an opaque handle to a resource object</fsummary>
+      <desc><p>Create an opaque handle to a memory managed resource object
+      obtained by <seealso marker="erl_nif#enif_alloc_resource">enif_alloc_resource</seealso>.
+      No ownership transfer is done, the resource object still needs to be released by
+      <seealso marker="erl_nif#enif_release_resource">enif_release_resource</seealso>.</p>
+      <p>Note that the only defined behaviour when using of a resource term in
+      an Erlang program is to store it and send it between processes on the
+      same node. Other operations such as matching or <c>term_to_binary</c>
+      will have unpredictable (but harmless) results.</p></desc>
+    </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_string(ErlNifEnv* env, const char* string, ErlNifCharEncoding encoding)</nametext></name>
       <fsummary>Create a string.</fsummary>
       <desc><p>Create a list containing the characters of the
-      C-string <c>string</c>.</p></desc>
+      null-terminated string <c>string</c> with encoding <c>encoding</c>.</p></desc>
+    </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_sub_binary(ErlNifEnv* 
+      env, ERL_NIF_TERM bin_term, unsigned pos, unsigned size)</nametext></name>
+      <fsummary>Make a subbinary term.</fsummary>
+      <desc><p>Make a subbinary of binary <c>bin_term</c>, starting at 
+              zero-based position <c>pos</c> with a length of <c>size</c> bytes. 
+              <c>bin_term</c> must be a binary or bitstring and
+              <c>pos+size</c> must be less or equal to the number of whole
+              bytes in <c>bin_term</c>.</p></desc>
     </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)</nametext></name>
       <fsummary>Create a tuple term.</fsummary>
@@ -386,13 +629,205 @@ typedef struct {
       <c>cnt</c> number of arguments (after <c>cnt</c>) of type ERL_NIF_TERM as the
       elements of the tuple.</p></desc>
     </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple1(ErlNifEnv* env, ERL_NIF_TERM e1)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple2(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple3(ErlNifEnv* env, ERL_NIF_TERM e1, ERL_NIF_TERM e2, ERL_NIF_TERM e3)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple4(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e4)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple5(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e5)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple6(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e6)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple7(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e7)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple8(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e8)</nametext></name>
+    <name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple9(ErlNifEnv* env, ERL_NIF_TERM e1, ..., ERL_NIF_TERM e9)</nametext></name>
+      <fsummary>Create a tuple term.</fsummary>
+      <desc><p>Create a tuple term with length indicated by the
+      function name. Prefere these functions (macros) over the variadic
+      <c>enif_make_tuple</c>  to get compile time error if the number of
+      arguments does not match.</p></desc>
+    </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)</nametext></name>
+      <fsummary>Create a tuple term from an array.</fsummary>
+      <desc><p>Create a tuple containing the elements of array <c>arr</c>
+      of length <c>cnt</c>.</p></desc>
+    </func>
+    <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_uint(ErlNifEnv* env, unsigned int i)</nametext></name>
+      <fsummary>Create an unsigned integer term</fsummary>
+      <desc><p>Create an integer term from an <c>unsigned int</c>.</p></desc>
+    </func>
     <func><name><ret>ERL_NIF_TERM</ret><nametext>enif_make_ulong(ErlNifEnv* env, unsigned long i)</nametext></name>
       <fsummary>Create an integer term from an unsigned long int</fsummary>
       <desc><p>Create an integer term from an <c>unsigned long int</c>.</p></desc>
     </func>
+    <func><name><ret>ErlNifMutex*</ret><nametext>enif_mutex_create(char *name)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_create">erl_drv_mutex_create()</seealso>.
+    </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_mutex_destroy(ErlNifMutex *mtx)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_destroy">erl_drv_mutex_destroy()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_mutex_lock(ErlNifMutex *mtx)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_lock">erl_drv_mutex_lock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_mutex_trylock(ErlNifMutex *mtx)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_trylock">erl_drv_mutex_trylock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_mutex_unlock(ErlNifMutex *mtx)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_mutex_unlock">erl_drv_mutex_unlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>ErlNifResourceType*</ret><nametext>enif_open_resource_type(ErlNifEnv* env, const char* name,
+                             ErlNifResourceDtor* dtor, ErlNifResourceFlags flags, ErlNifResourceFlags* tried)</nametext></name>
+      <fsummary>Create or takeover a resource type</fsummary>
+      <desc><p>Create or takeover a resource type identified by the string
+      <c>name</c> and give it the destructor function pointed to by <c>dtor</c>.
+      Argument <c>flags</c> can have the following values:</p>
+      <taglist>
+        <tag><c>ERL_NIF_RT_CREATE</c></tag>
+              <item>Create a new resource type that does not already exist.</item>
+        <tag><c>ERL_NIF_RT_TAKEOVER</c></tag>
+              <item>Open an existing resource type and take over ownership of all its instances.
+               The supplied destructor <c>dtor</c> will be called both for existing instances
+               as well as new instances not yet created by the calling NIF library.</item>            
+      </taglist>
+      <p>The two flag values can be combined with bitwise-or. To avoid unintentionally
+      name clashes a good practice is to include the module name as part of the
+      type <c>name</c>. The <c>dtor</c> may  be <c>NULL</c> in case no destructor
+      is needed.</p>
+      <p>On success, return a pointer to the resource type and <c>*tried</c>
+      will be set to either <c>ERL_NIF_RT_CREATE</c> or
+      <c>ERL_NIF_RT_TAKEOVER</c> to indicate what was actually done.
+       On failure, return <c>NULL</c> and set <c>*tried</c> to <c>flags</c>.
+       It is allowed to set <c>tried</c> to <c>NULL</c>.</p>
+       <p>Note that <c>enif_open_resource_type</c> is only allowed to be called in the three callbacks
+       <seealso marker="erl_nif#load">load</seealso>, <seealso marker="erl_nif#reload">reload</seealso>
+       and <seealso marker="erl_nif#upgrade">upgrade</seealso>.</p>
+      </desc>
+    </func>
+    <func><name><ret>void*</ret><nametext>enif_priv_data(ErlNifEnv* env)</nametext></name>
+      <fsummary>Get the private data of a NIF library</fsummary>
+      <desc><p>Return the pointer to the private data that was set by <c>load</c>,
+      <c>reload</c> or <c>upgrade</c>.</p>
+      <p>Was previously named <c>enif_get_data</c>.</p></desc>
+    </func>
     <func><name><ret>void</ret><nametext>enif_release_binary(ErlNifEnv* env, ErlNifBinary* bin)</nametext></name>
       <fsummary>Release a binary.</fsummary>
-      <desc><p>Release a binary obtained from <c>enif_alloc_binary</c> or <c>enif_inspect_binary</c>.</p></desc>
+      <desc><p>Release a binary obtained 
+              from <c>enif_alloc_binary</c>.</p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_release_resource(ErlNifEnv* env, void* obj)</nametext></name>
+      <fsummary>Release a resource object.</fsummary>
+      <desc><p>Release a resource objects obtained from <c>enif_alloc_resource</c>.
+      The object may still be alive if it is referred to by Erlang terms. Each call to
+      <c>enif_release_resource</c> must correspond to a previous call to <c>enif_alloc_resource</c>.
+      References made by <c>enif_make_resource</c> can only be released by the garbage collector.</p></desc>
+    </func>
+    <func><name><ret>ErlNifRWLock*</ret><nametext>enif_rwlock_create(char *name)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_create">erl_drv_rwlock_create()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_rwlock_destroy(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_destroy">erl_drv_rwlock_destroy()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_rwlock_rlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_rlock">erl_drv_rwlock_rlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_rwlock_runlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_runlock">erl_drv_rwlock_runlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_rwlock_rwlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_rwlock">erl_drv_rwlock_rwlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_rwlock_rwunlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_rwunlock">erl_drv_rwlock_rwunlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_rwlock_tryrlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_tryrlock">erl_drv_rwlock_tryrlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_rwlock_tryrwlock(ErlNifRWLock *rwlck)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_rwlock_tryrwlock">erl_drv_rwlock_tryrwlock()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>unsigned</ret><nametext>enif_sizeof_resource(ErlNifEnv* env, void* obj)</nametext></name>
+      <fsummary>Get the byte size of a resource object</fsummary>
+      <desc><p>Get the byte size of a resource object <c>obj</c> obtained by
+      <c>enif_alloc_resource</c>.</p></desc>
+    </func>
+    <func>
+      <name><ret>void</ret><nametext>enif_system_info(ErlNifSysInfo *sys_info_ptr, size_t size)</nametext></name>
+      <fsummary>Get information about the Erlang runtime system</fsummary>
+      <desc><p>Same as <seealso marker="erl_driver#driver_system_info">driver_system_info()</seealso>.
+            </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_thread_create(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_create">erl_drv_thread_create()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_thread_exit(void *resp)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_exit">erl_drv_thread_exit()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_thread_join(ErlNifTid, void **respp)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_join">erl_drv_thread_join ()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>ErlNifThreadOpts*</ret><nametext>enif_thread_opts_create(char *name)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_opts_create">erl_drv_thread_opts_create()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_thread_opts_destroy(ErlNifThreadOpts *opts)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_opts_destroy">erl_drv_thread_opts_destroy()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>ErlNifTid</ret><nametext>enif_thread_self(void)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_thread_self">erl_drv_thread_self()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>int</ret><nametext>enif_tsd_key_create(char *name, ErlNifTSDKey *key)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_create">erl_drv_tsd_key_create()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_tsd_key_destroy(ErlNifTSDKey key)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_key_destroy">erl_drv_tsd_key_destroy()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void*</ret><nametext>enif_tsd_get(ErlNifTSDKey key)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_get">erl_drv_tsd_get()</seealso>.
+          </p></desc>
+    </func>
+    <func><name><ret>void</ret><nametext>enif_tsd_set(ErlNifTSDKey key, void *data)</nametext></name>
+    <fsummary></fsummary>
+    <desc><p>Same as <seealso marker="erl_driver#erl_drv_tsd_set">erl_drv_tsd_set()</seealso>.
+          </p></desc>
     </func>
   </funcs>
   <section>
diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index 2fe12be43e..a81ab28847 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -419,7 +419,7 @@ include $(ERL_TOP)/make/otp_release_targets.mk
 
 RELSYSDIR = $(RELEASE_PATH)/erts-$(VSN)
 
-RELEASE_INCLUDES = beam/erl_driver.h sys/$(ERLANG_OSTYPE)/driver_int.h beam/erl_nif.h beam/erl_nif_api_funcs.h
+RELEASE_INCLUDES = beam/erl_driver.h sys/$(ERLANG_OSTYPE)/driver_int.h beam/erl_nif.h beam/erl_nif_api_funcs.h beam/erl_drv_nif.h
 ifeq ($(TARGET),win32)
 RELEASE_INCLUDES += sys/$(ERLANG_OSTYPE)/erl_win_dyn_driver.h
 endif
diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index d3a1ed4e7d..b1feec7074 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1999-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1999-2010. 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%
  */
 
@@ -642,21 +642,9 @@ purge_module(int module)
     /*
      * Unload any NIF library
      */
-    if (modp->old_nif.handle != NULL) {
-	if (modp->old_nif.entry->unload != NULL) {
-	    ErlNifEnv env;
-	    env.nif_data = modp->old_nif.data;
-	    env.proc = NULL; /* BUGBUG: unlink can not access calling process */
-	    env.hp = NULL;
-	    env.hp_end = NULL;
-	    env.heap_frag_sz = 0;
-	    env.fpe_was_unmasked = erts_block_fpe();
-	    modp->old_nif.entry->unload(NULL, modp->old_nif.data);
-	    erts_unblock_fpe(env.fpe_was_unmasked);
-	}
-	erts_sys_ddll_close(modp->old_nif.handle);
-	modp->old_nif.handle = NULL;
-	modp->old_nif.entry = NULL;
+    if (modp->old_nif != NULL) {
+	erts_unload_nif(modp->old_nif);
+	modp->old_nif = NULL;
     }
 
     /*
@@ -732,8 +720,7 @@ delete_code(Process *c_p, ErtsProcLocks c_p_locks, Module* modp)
     modp->code = NULL;
     modp->code_length = 0;
     modp->catches = BEAM_CATCHES_NIL;
-    modp->nif.handle = NULL;
-    modp->nif.entry = NULL;
+    modp->nif = NULL;
 }
 
 
diff --git a/erts/emulator/beam/beam_emu.c b/erts/emulator/beam/beam_emu.c
index 13757b7d1c..2f7f48193d 100644
--- a/erts/emulator/beam/beam_emu.c
+++ b/erts/emulator/beam/beam_emu.c
@@ -2973,7 +2973,7 @@ void process_main(void)
 	   * I[-1]: Arity
 	   * I[0]: &&call_nif
 	   * I[1]: Function pointer to NIF function
-	   * I[2]: priv_data pointer
+	   * I[2]: Pointer to erl_module_nif
 	   */
      	 BifFunction vbf;
 
@@ -2989,7 +2989,7 @@ void process_main(void)
 	     typedef Eterm NifF(struct enif_environment_t*, int argc, Eterm argv[]);
 	     NifF* fp = vbf = (NifF*) I[1];
 	     struct enif_environment_t env;
-	     erts_pre_nif(&env, c_p, (void*)I[2]);
+	     erts_pre_nif(&env, c_p, (struct erl_module_nif*)I[2]);
 	     reg[0] = r(0);
 	     tmp_arg1 = (*fp)(&env, tmp_arg2, reg);
 	     erts_post_nif(&env);
diff --git a/erts/emulator/beam/binary.c b/erts/emulator/beam/binary.c
index 49bc0d6457..08c64610a2 100644
--- a/erts/emulator/beam/binary.c
+++ b/erts/emulator/beam/binary.c
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1996-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1996-2010. 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%
  */
 
@@ -180,7 +180,7 @@ erts_realloc_binary(Eterm bin, size_t size)
 }
 
 byte*
-erts_get_aligned_binary_bytes(Eterm bin, byte** base_ptr)
+erts_get_aligned_binary_bytes_extra(Eterm bin, byte** base_ptr, unsigned extra)
 {
     byte* bytes;
     Eterm* real_bin;
@@ -208,10 +208,10 @@ erts_get_aligned_binary_bytes(Eterm bin, byte** base_ptr)
 	bytes = (byte *)(&(((ErlHeapBin *) real_bin)->data)) + offs;
     }
     if (bit_offs) {
-	byte* buf = (byte *) erts_alloc(ERTS_ALC_T_TMP, byte_size);
-
-	erts_copy_bits(bytes, bit_offs, 1, buf, 0, 1, byte_size*8);
+	byte* buf = (byte *) erts_alloc(ERTS_ALC_T_TMP, byte_size + extra);
 	*base_ptr = buf;
+	buf += extra;
+	erts_copy_bits(bytes, bit_offs, 1, buf, 0, 1, byte_size*8);	
 	bytes = buf;
     }
     return bytes;
diff --git a/erts/emulator/beam/erl_binary.h b/erts/emulator/beam/erl_binary.h
index f8ecdde997..21d4e3fdfd 100644
--- a/erts/emulator/beam/erl_binary.h
+++ b/erts/emulator/beam/erl_binary.h
@@ -150,7 +150,7 @@ do {									\
 
 void erts_init_binary(void);
 
-byte* erts_get_aligned_binary_bytes(Eterm, byte**);
+byte* erts_get_aligned_binary_bytes_extra(Eterm, byte**, unsigned extra);
 
 #if defined(__i386__) || !defined(__GNUC__)
 /*
@@ -166,6 +166,7 @@ byte* erts_get_aligned_binary_bytes(Eterm, byte**);
 #define ERTS_CHK_BIN_ALIGNMENT(B) \
   do { ASSERT(!(B) || (((Uint) &((Binary *)(B))->orig_bytes[0]) & ERTS_BIN_ALIGNMENT_MASK) == ((Uint) 0)) } while(0)
 
+ERTS_GLB_INLINE byte* erts_get_aligned_binary_bytes(Eterm bin, byte** base_ptr);
 ERTS_GLB_INLINE void erts_free_aligned_binary_bytes(byte* buf);
 ERTS_GLB_INLINE Binary *erts_bin_drv_alloc_fnf(Uint size);
 ERTS_GLB_INLINE Binary *erts_bin_drv_alloc(Uint size);
@@ -178,6 +179,14 @@ ERTS_GLB_INLINE Binary *erts_create_magic_binary(Uint size,
 
 #if ERTS_GLB_INLINE_INCL_FUNC_DEF
 
+#include <stddef.h> /* offsetof */
+
+ERTS_GLB_INLINE byte*
+erts_get_aligned_binary_bytes(Eterm bin, byte** base_ptr)
+{
+    return erts_get_aligned_binary_bytes_extra(bin, base_ptr, 0);
+}
+
 ERTS_GLB_INLINE void
 erts_free_aligned_binary_bytes(byte* buf)
 {
@@ -189,7 +198,7 @@ erts_free_aligned_binary_bytes(byte* buf)
 ERTS_GLB_INLINE Binary *
 erts_bin_drv_alloc_fnf(Uint size)
 {
-    Uint bsize = sizeof(Binary) - 1 + size;
+    Uint bsize = ERTS_SIZEOF_Binary(size);
     void *res;
     res = erts_alloc_fnf(ERTS_ALC_T_DRV_BINARY, bsize);
     ERTS_CHK_BIN_ALIGNMENT(res);
@@ -199,7 +208,7 @@ erts_bin_drv_alloc_fnf(Uint size)
 ERTS_GLB_INLINE Binary *
 erts_bin_drv_alloc(Uint size)
 {
-    Uint bsize = sizeof(Binary) - 1 + size;
+    Uint bsize = ERTS_SIZEOF_Binary(size);
     void *res;
     res = erts_alloc(ERTS_ALC_T_DRV_BINARY, bsize);
     ERTS_CHK_BIN_ALIGNMENT(res);
@@ -210,7 +219,7 @@ erts_bin_drv_alloc(Uint size)
 ERTS_GLB_INLINE Binary *
 erts_bin_nrml_alloc(Uint size)
 {
-    Uint bsize = sizeof(Binary) - 1 + size;
+    Uint bsize = ERTS_SIZEOF_Binary(size);
     void *res;
     res = erts_alloc(ERTS_ALC_T_BINARY, bsize);
     ERTS_CHK_BIN_ALIGNMENT(res);
@@ -221,7 +230,7 @@ ERTS_GLB_INLINE Binary *
 erts_bin_realloc_fnf(Binary *bp, Uint size)
 {
     Binary *nbp;
-    Uint bsize = sizeof(Binary) - 1 + size;
+    Uint bsize = ERTS_SIZEOF_Binary(size);
     ASSERT((bp->flags & BIN_FLAG_MAGIC) == 0);
     if (bp->flags & BIN_FLAG_DRV)
 	nbp = erts_realloc_fnf(ERTS_ALC_T_DRV_BINARY, (void *) bp, bsize);
@@ -235,7 +244,7 @@ ERTS_GLB_INLINE Binary *
 erts_bin_realloc(Binary *bp, Uint size)
 {
     Binary *nbp;
-    Uint bsize = sizeof(Binary) - 1 + size;
+    Uint bsize = ERTS_SIZEOF_Binary(size);
     ASSERT((bp->flags & BIN_FLAG_MAGIC) == 0);
     if (bp->flags & BIN_FLAG_DRV)
 	nbp = erts_realloc_fnf(ERTS_ALC_T_DRV_BINARY, (void *) bp, bsize);
diff --git a/erts/emulator/beam/erl_driver.h b/erts/emulator/beam/erl_driver.h
index cdb584b282..489e74d960 100644
--- a/erts/emulator/beam/erl_driver.h
+++ b/erts/emulator/beam/erl_driver.h
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1999-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1999-2010. 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%
  */
 
@@ -65,6 +65,8 @@
 #  error SIZEOF_LONG_LONG mismatch
 #endif
 
+#include "erl_drv_nif.h"
+
 #include <stdlib.h>
 
 #if defined(VXWORKS)
@@ -116,7 +118,7 @@ typedef struct {
 
 #define ERL_DRV_EXTENDED_MARKER		(0xfeeeeeed)
 #define ERL_DRV_EXTENDED_MAJOR_VERSION	1
-#define ERL_DRV_EXTENDED_MINOR_VERSION	4
+#define ERL_DRV_EXTENDED_MINOR_VERSION	5
 
 /*
  * The emulator will refuse to load a driver with different major
@@ -195,22 +197,6 @@ typedef struct {
     unsigned char data[sizeof(void *)*4];
 } ErlDrvMonitor;
 
-
-/*
- * System info
- */
-
-typedef struct {
-    int driver_major_version;
-    int driver_minor_version;
-    char *erts_version;
-    char *otp_release;
-    int thread_support;
-    int smp_support;
-    int async_threads;
-    int scheduler_threads;
-}  ErlDrvSysInfo;
-
 typedef struct {
     unsigned long megasecs;
     unsigned long secs;
@@ -255,9 +241,6 @@ typedef struct ErlDrvCond_ ErlDrvCond;
 typedef struct ErlDrvRWLock_ ErlDrvRWLock;
 typedef int ErlDrvTSDKey;
 
-typedef struct {
-    int suggested_stack_size;
-} ErlDrvThreadOpts;
 
 /*
  * 
diff --git a/erts/emulator/beam/erl_drv_nif.h b/erts/emulator/beam/erl_drv_nif.h
new file mode 100644
index 0000000000..ea013a49a3
--- /dev/null
+++ b/erts/emulator/beam/erl_drv_nif.h
@@ -0,0 +1,48 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2010. 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%
+ */
+
+/*
+ * Common structures for both erl_driver.h and erl_nif.h
+ */
+
+#ifndef __ERL_DRV_NIF_H__
+#define __ERL_DRV_NIF_H__
+
+typedef struct {
+    int driver_major_version;
+    int driver_minor_version;
+    char *erts_version;
+    char *otp_release;
+    int thread_support;
+    int smp_support;
+    int async_threads;
+    int scheduler_threads;
+    int nif_major_version;
+    int nif_minor_version;
+}  ErlDrvSysInfo;
+
+typedef struct {
+    int suggested_stack_size;
+} ErlDrvThreadOpts;
+
+#endif  /* __ERL_DRV_NIF_H__ */
+
+
+
+
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 17cf3b9597..e97ab328cd 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -296,6 +296,7 @@ erl_init(void)
     erl_sys_init_final();
 #endif
     packet_parser_init();
+    erl_nif_init();
 }
 
 static void
diff --git a/erts/emulator/beam/erl_nif.c b/erts/emulator/beam/erl_nif.c
index 2cb93112ae..585a6c1fdf 100644
--- a/erts/emulator/beam/erl_nif.c
+++ b/erts/emulator/beam/erl_nif.c
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 2009-2010. 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%
  */
 /* Erlang Native InterFace
@@ -34,9 +34,26 @@
 #include "beam_bp.h"
 
 #include <limits.h>
+#include <stddef.h> /* offsetof */
+
+
+/* Information about a loaded nif library.
+ * Each successful call to erlang:load_nif will allocate an instance of
+ * erl_module_nif. Two calls opening the same library will thus have the same
+ * 'handle'.
+ */
+struct erl_module_nif {
+    void* priv_data;
+    void* handle;             /* "dlopen" */
+    struct enif_entry_t* entry;
+    erts_refc_t rt_cnt;       /* number of resource types */
+    erts_refc_t rt_dtor_cnt;  /* number of resource types with destructors */
+    int is_orphan;            /* if erlang module has been purged */
+};
+
 
 #define MIN_HEAP_FRAG_SZ 200
-static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need);
+static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need, Eterm* hp);
 
 static ERTS_INLINE Eterm* alloc_heap(ErlNifEnv* env, unsigned need)
 {
@@ -45,43 +62,88 @@ static ERTS_INLINE Eterm* alloc_heap(ErlNifEnv* env, unsigned need)
     if (env->hp <= env->hp_end) {
 	return hp;
     }
-    env->hp = hp;
-    return alloc_heap_heavy(env,need);
+    return alloc_heap_heavy(env, need, hp);
 }
 
-static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need)
-{
-    Eterm* hp;
-
-    if (env->heap_frag_sz == 0) {       
+static Eterm* alloc_heap_heavy(ErlNifEnv* env, unsigned need, Eterm* hp)
+{    
+    unsigned frag_sz;
+    env->hp = hp;
+    if (env->heap_frag == NULL) {       
 	ASSERT(HEAP_LIMIT(env->proc) == env->hp_end);
 	HEAP_TOP(env->proc) = env->hp;	
-	env->heap_frag_sz = need + MIN_HEAP_FRAG_SZ;
     }
     else {
 	HRelease(env->proc, env->hp_end, env->hp);
-	env->heap_frag_sz *= 2;
     }
-    hp = erts_heap_alloc(env->proc, env->heap_frag_sz);
+    frag_sz = need + MIN_HEAP_FRAG_SZ;
+    hp = erts_heap_alloc(env->proc, frag_sz);
     env->hp = hp + need;
-    env->hp_end = hp + env->heap_frag_sz;
+    env->hp_end = hp + frag_sz;
+    env->heap_frag = MBUF(env->proc);
     return hp;
 }
 
-void erts_pre_nif(ErlNifEnv* env, Process* p, void* nif_data)
+void erts_pre_nif(ErlNifEnv* env, Process* p, struct erl_module_nif* mod_nif)
 {
-    env->nif_data = nif_data;
+    env->mod_nif = mod_nif;
     env->proc = p;
     env->hp = HEAP_TOP(p);
     env->hp_end = HEAP_LIMIT(p);
-    env->heap_frag_sz = 0;
+    env->heap_frag = NULL;
+    env->fpe_was_unmasked = erts_block_fpe();
+    env->tmp_obj_list = NULL;
+}
+
+static void pre_nif_noproc(ErlNifEnv* env, struct erl_module_nif* mod_nif)
+{
+    env->mod_nif = mod_nif;
+    env->proc = NULL;
+    env->hp = NULL;
+    env->hp_end = NULL;
+    env->heap_frag = NULL;
     env->fpe_was_unmasked = erts_block_fpe();
+    env->tmp_obj_list = NULL;
+}
+
+static ERTS_INLINE void free_tmp_objs(ErlNifEnv* env)
+{
+    while (env->tmp_obj_list != NULL) {
+	struct enif_tmp_obj_t* free_me = env->tmp_obj_list;
+	env->tmp_obj_list = free_me->next;
+	free_me->dtor(free_me);
+    }
 }
 
 void erts_post_nif(ErlNifEnv* env)
 {
     erts_unblock_fpe(env->fpe_was_unmasked);
-    if (env->heap_frag_sz == 0) {
+    if (env->heap_frag == NULL) {
+	ASSERT(env->hp_end == HEAP_LIMIT(env->proc));
+	ASSERT(env->hp >= HEAP_TOP(env->proc));
+	ASSERT(env->hp <= HEAP_LIMIT(env->proc));	
+	HEAP_TOP(env->proc) = env->hp;
+    }
+    else {
+	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);
+	HRelease(env->proc, env->hp_end, env->hp);
+    }
+    free_tmp_objs(env);
+}
+
+static void post_nif_noproc(ErlNifEnv* env)
+{
+    erts_unblock_fpe(env->fpe_was_unmasked);
+    free_tmp_objs(env);
+}
+
+
+/* Flush out our cached heap pointers to allow an ordinary HAlloc
+*/
+static void enable_halloc(ErlNifEnv* env)
+{
+    if (env->heap_frag == NULL) {
 	ASSERT(env->hp_end == HEAP_LIMIT(env->proc));
 	ASSERT(env->hp >= HEAP_TOP(env->proc));
 	ASSERT(env->hp <= HEAP_LIMIT(env->proc));	
@@ -89,14 +151,35 @@ void erts_post_nif(ErlNifEnv* env)
     }
     else {
 	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
-	ASSERT(env->hp_end - env->hp <= env->heap_frag_sz);
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);
 	HRelease(env->proc, env->hp_end, env->hp);
     }
 }
 
-void* enif_get_data(ErlNifEnv* env)
+/* Restore cached heap pointers
+*/
+static void disable_halloc(ErlNifEnv* env)
 {
-    return env->nif_data;
+    if (env->heap_frag == NULL) {
+	ASSERT(env->hp_end == HEAP_LIMIT(env->proc));
+	ASSERT(env->hp <= HEAP_TOP(env->proc));
+	ASSERT(env->hp <= HEAP_LIMIT(env->proc));	
+	env->hp = HEAP_TOP(env->proc);
+    }
+    else {
+	ASSERT(env->hp_end != HEAP_LIMIT(env->proc));
+	ASSERT(env->hp_end - env->hp <= env->heap_frag->size);       
+	env->heap_frag = MBUF(env->proc);
+	ASSERT(env->heap_frag != NULL);
+	env->hp = env->heap_frag->mem + env->heap_frag->used_size;
+	env->hp_end = env->heap_frag->mem + env->heap_frag->size;
+    }
+}
+
+
+void* enif_priv_data(ErlNifEnv* env)
+{
+    return env->mod_nif->priv_data;
 }
 
 void* enif_alloc(ErlNifEnv* env, size_t size)
@@ -104,6 +187,11 @@ void* enif_alloc(ErlNifEnv* env, size_t size)
     return erts_alloc_fnf(ERTS_ALC_T_NIF, (Uint) size);
 }
 
+void* enif_realloc(ErlNifEnv* env, void* ptr, size_t size)
+{
+    return erts_realloc_fnf(ERTS_ALC_T_NIF, ptr, size);
+}
+
 void enif_free(ErlNifEnv* env, void* ptr)
 {
     erts_free(ERTS_ALC_T_NIF, ptr);
@@ -119,25 +207,94 @@ int enif_is_binary(ErlNifEnv* env, ERL_NIF_TERM term)
     return is_binary(term) && (binary_bitsize(term) % 8 == 0);
 }
 
+int enif_is_empty_list(ErlNifEnv* env, ERL_NIF_TERM term)
+{
+    return is_nil(term);
+}
+
+int enif_is_fun(ErlNifEnv* env, ERL_NIF_TERM term)
+{
+    return is_fun(term);
+}
+
+int enif_is_pid(ErlNifEnv* env, ERL_NIF_TERM term)
+{
+    return is_pid(term);
+}
+
+int enif_is_port(ErlNifEnv* env, ERL_NIF_TERM term)
+{
+    return is_port(term);
+}
+
 int enif_is_ref(ErlNifEnv* env, ERL_NIF_TERM term)
 {
     return is_ref(term);
 }
 
+static void aligned_binary_dtor(struct enif_tmp_obj_t* obj)
+{
+    erts_free_aligned_binary_bytes((byte*)obj);
+}
 
 int enif_inspect_binary(ErlNifEnv* env, Eterm bin_term, ErlNifBinary* bin)
 {
-    bin->tmp_alloc = NULL;
-    bin->data = erts_get_aligned_binary_bytes(bin_term, &bin->tmp_alloc);
+    union {
+	struct enif_tmp_obj_t* tmp;
+	byte* raw_ptr;
+    }u;
+    u.tmp = NULL;
+    bin->data = erts_get_aligned_binary_bytes_extra(bin_term, &u.raw_ptr,
+						    sizeof(struct enif_tmp_obj_t));
     if (bin->data == NULL) {
 	return 0;
     }
+    if (u.tmp != NULL) {
+	u.tmp->next = env->tmp_obj_list;
+	u.tmp->dtor = &aligned_binary_dtor;
+	env->tmp_obj_list = u.tmp;
+    }
     bin->bin_term = bin_term;
     bin->size = binary_size(bin_term);
     bin->ref_bin = NULL;
     return 1;
 }
 
+static void tmp_alloc_dtor(struct enif_tmp_obj_t* obj)
+{
+    erts_free(ERTS_ALC_T_TMP,  obj);
+}
+
+int enif_inspect_iolist_as_binary(ErlNifEnv* env, Eterm term, ErlNifBinary* bin)
+{
+    struct enif_tmp_obj_t* tobj;
+    int sz;
+    if (is_binary(term)) {
+	return enif_inspect_binary(env,term,bin);
+    }
+    if (is_nil(term)) {
+	bin->data = (unsigned char*) &bin->data; /* dummy non-NULL */
+	bin->size = 0;
+	bin->bin_term = THE_NON_VALUE;
+	bin->ref_bin = NULL;
+	return 1;
+    }
+    if ((sz = io_list_len(term)) < 0) {
+	return 0;
+    }
+    
+    tobj = erts_alloc(ERTS_ALC_T_TMP, sz + sizeof(struct enif_tmp_obj_t));
+    tobj->next = env->tmp_obj_list;
+    tobj->dtor = &tmp_alloc_dtor;
+    env->tmp_obj_list = tobj;
+
+    bin->data = (unsigned char*) &tobj[1]; 
+    bin->size = sz;
+    bin->bin_term = THE_NON_VALUE;
+    bin->ref_bin = NULL;
+    io_list_to_buf(term, (char*) bin->data, sz);
+    return 1;
+}
 
 int enif_alloc_binary(ErlNifEnv* env, unsigned size, ErlNifBinary* bin)
 {
@@ -154,46 +311,48 @@ int enif_alloc_binary(ErlNifEnv* env, unsigned size, ErlNifBinary* bin)
     bin->size = size;
     bin->data = (unsigned char*) refbin->orig_bytes;
     bin->bin_term = THE_NON_VALUE;
-    bin->tmp_alloc = NULL;
     bin->ref_bin = refbin;
     return 1;
 }
 
 int enif_realloc_binary(ErlNifEnv* env, ErlNifBinary* bin, unsigned size)
 {
-    Binary* oldbin;
-    Binary* newbin;
-    ASSERT(bin->ref_bin != NULL);
-
-    oldbin = (Binary*) bin->ref_bin; 
-    newbin = (Binary *) erts_bin_realloc_fnf(oldbin, size);
-    if (!newbin) {
-	return 0;
-    }    
-    newbin->orig_size = size;
-    bin->ref_bin = newbin;
-    bin->data = (unsigned char*) newbin->orig_bytes;
-    bin->size = size;
+    if (bin->ref_bin != NULL) {
+	Binary* oldbin;
+	Binary* newbin;
+    
+	oldbin = (Binary*) bin->ref_bin; 
+	newbin = (Binary *) erts_bin_realloc_fnf(oldbin, size);
+	if (!newbin) {
+	    return 0;
+	}    
+	newbin->orig_size = size;
+	bin->ref_bin = newbin;
+	bin->data = (unsigned char*) newbin->orig_bytes;
+	bin->size = size;
+    }
+    else {
+	unsigned char* old_data = bin->data;
+	unsigned cpy_sz = (size < bin->size ? size : bin->size);  
+	enif_alloc_binary(env, size, bin);
+	sys_memcpy(bin->data, old_data, cpy_sz); 
+    }
     return 1;
 }
 
 
 void enif_release_binary(ErlNifEnv* env, ErlNifBinary* bin)
 {
-    if (bin->ref_bin == NULL) {
-	erts_free_aligned_binary_bytes(bin->tmp_alloc);
-    }
-    else {
+    if (bin->ref_bin != NULL) {
 	Binary* refbin = bin->ref_bin;
-	ASSERT(bin->tmp_alloc == NULL);
 	ASSERT(bin->bin_term == THE_NON_VALUE);
 	if (erts_refc_dectest(&refbin->refc, 0) == 0) {
 	    erts_bin_free(refbin);
 	}
     }
 #ifdef DEBUG
+    bin->data = NULL;
     bin->bin_term = THE_NON_VALUE;
-    bin->tmp_alloc = NULL;
     bin->ref_bin = NULL;
 #endif
 }
@@ -208,7 +367,7 @@ int enif_compare(ErlNifEnv* env, Eterm lhs, Eterm rhs)
     return cmp(lhs,rhs);
 }
 
-int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, Eterm** array)
+int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, const Eterm** array)
 {
     Eterm* ptr;
     if (is_not_tuple(tpl)) {
@@ -220,16 +379,47 @@ int enif_get_tuple(ErlNifEnv* env, Eterm tpl, int* arity, Eterm** array)
     return 1;
 }
 
+int enif_get_string(ErlNifEnv *env, ERL_NIF_TERM list, char* buf, unsigned len,
+		    ErlNifCharEncoding encoding)
+{
+    Eterm* listptr;
+    int n = 0;
+
+    ASSERT(encoding == ERL_NIF_LATIN1);
+    if (len < 1) {
+	return 0;
+    }
+    while (is_not_nil(list)) { 	    
+	if (is_not_list(list)) {
+	    buf[n] = '\0';
+	    return 0;
+	}
+	listptr = list_val(list);
+    
+	if (!is_byte(*listptr)) {
+	    buf[n] = '\0';
+	    return 0;
+	}
+	buf[n++] = unsigned_val(*listptr);
+	if (n >= len) {
+	    buf[n-1] = '\0'; /* truncate */
+	    return -len;
+	}
+	list = CDR(listptr);
+    }
+    buf[n] = '\0';
+    return n + 1;
+}
+
 Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)
 {
-    if (bin->ref_bin == NULL) {
-	erts_free_aligned_binary_bytes(bin->tmp_alloc);
+    if (bin->bin_term != THE_NON_VALUE) {
 	return bin->bin_term;
     }
-    else {
+    else if (bin->ref_bin != NULL) {
 	Binary* bptr = bin->ref_bin;
 	ProcBin* pb;
-	ASSERT(bin->tmp_alloc == NULL);
+	Eterm bin_term;
 	
 	/* !! Copy-paste from new_binary() !! */
 	pb = (ProcBin *) alloc_heap(env, PROC_BIN_SIZE);
@@ -242,15 +432,67 @@ Eterm enif_make_binary(ErlNifEnv* env, ErlNifBinary* bin)
 	pb->flags = 0;
 	
 	MSO(env->proc).overhead += pb->size / sizeof(Eterm);
-	return make_binary(pb);
+	bin_term = make_binary(pb);	
+	if (erts_refc_read(&bptr->refc, 1) == 1) {
+	    /* Total ownership transfer */
+	    bin->ref_bin = NULL;
+	    bin->bin_term = bin_term;
+	}
+	return bin_term;
+    }
+    else {
+	enable_halloc(env);
+	bin->bin_term = new_binary(env->proc, bin->data, bin->size);
+	disable_halloc(env);
+	return bin->bin_term;
     }
 }
 
+Eterm enif_make_sub_binary(ErlNifEnv* env, ERL_NIF_TERM bin_term,
+			   unsigned pos, unsigned size)
+{
+    ErlSubBin* sb;
+    Eterm orig;
+    Uint offset, bit_offset, bit_size; 
+    unsigned src_size;
+
+    ASSERT(is_binary(bin_term));
+    src_size = binary_size(bin_term);
+    ASSERT(pos <= src_size);
+    ASSERT(size <= src_size);
+    ASSERT(pos + size <= src_size);   
+    sb = (ErlSubBin*) alloc_heap(env, ERL_SUB_BIN_SIZE);
+    ERTS_GET_REAL_BIN(bin_term, orig, offset, bit_offset, bit_size);
+    sb->thing_word = HEADER_SUB_BIN;
+    sb->size = size;
+    sb->offs = offset + pos;
+    sb->orig = orig;
+    sb->bitoffs = bit_offset;
+    sb->bitsize = 0;
+    sb->is_writable = 0;
+    return make_binary(sb);
+}
+
+
 Eterm enif_make_badarg(ErlNifEnv* env)
 {
     BIF_ERROR(env->proc, BADARG);
 }
 
+int enif_get_atom(ErlNifEnv* env, Eterm atom, char* buf, unsigned len)
+{
+    Atom* ap;
+    if (is_not_atom(atom)) {
+	return 0;
+    }
+    ap = atom_tab(atom_val(atom));
+    if (ap->len+1 > len) {
+	return 0;
+    }
+    sys_memcpy(buf, ap->name, ap->len);
+    buf[ap->len] = '\0';
+    return ap->len + 1;
+}
 
 int enif_get_int(ErlNifEnv* env, Eterm term, int* ip)
 {
@@ -268,6 +510,29 @@ int enif_get_int(ErlNifEnv* env, Eterm term, int* ip)
 #endif     
 }
 
+int enif_get_uint(ErlNifEnv* env, Eterm term, unsigned* ip)
+{
+#if SIZEOF_INT == SIZEOF_VOID_P
+    return term_to_Uint(term, (Uint*)ip);
+#elif SIZEOF_LONG == SIZEOF_VOID_P
+    Uint i;
+    if (!term_to_Uint(term, &i) || i > UINT_MAX) {
+	return 0;
+    }
+    *ip = (unsigned) i;
+    return 1;
+#endif     
+}
+
+int enif_get_long(ErlNifEnv* env, Eterm term, long* ip)
+{
+#if SIZEOF_LONG == SIZEOF_VOID_P
+    return term_to_Sint(term, ip);
+#else
+#  error Unknown long word size 
+#endif     
+}
+
 int enif_get_ulong(ErlNifEnv* env, Eterm term, unsigned long* ip)
 {
 #if SIZEOF_LONG == SIZEOF_VOID_P
@@ -307,18 +572,26 @@ ERL_NIF_TERM enif_make_int(ErlNifEnv* env, int i)
 #endif
 }
 
-ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i)
+ERL_NIF_TERM enif_make_uint(ErlNifEnv* env, unsigned i)
 {
-#if SIZEOF_LONG == SIZEOF_VOID_P
-    Eterm* hp;
-    Uint sz = 0;
-    erts_bld_uint(NULL, &sz, i);
-    hp = alloc_heap(env,sz);
-    return erts_bld_uint(&hp, NULL, i);
-#else
+#if SIZEOF_INT == SIZEOF_VOID_P
+    return IS_USMALL(0,i) ? make_small(i) : uint_to_big(i,alloc_heap(env,2));
+#elif SIZEOF_LONG == SIZEOF_VOID_P
+    return make_small(i);
+#endif
+}
+
+ERL_NIF_TERM enif_make_long(ErlNifEnv* env, long i)
+{
+#if SIZEOF_LONG != SIZEOF_VOID_P
 #  error Unknown long word size 
 #endif     
+    return IS_SSMALL(i) ? make_small(i) : small_to_big(i, alloc_heap(env,2));
+}
 
+ERL_NIF_TERM enif_make_ulong(ErlNifEnv* env, unsigned long i)
+{
+    return IS_USMALL(0,i) ? make_small(i) : uint_to_big(i,alloc_heap(env,2));
 }
 
 ERL_NIF_TERM enif_make_double(ErlNifEnv* env, double d)
@@ -355,6 +628,19 @@ ERL_NIF_TERM enif_make_tuple(ErlNifEnv* env, unsigned cnt, ...)
     return ret;
 }
 
+ERL_NIF_TERM enif_make_tuple_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)
+{
+    Eterm* hp = alloc_heap(env,cnt+1);
+    Eterm ret = make_tuple(hp);
+    const Eterm* src = arr;
+
+    *hp++ = make_arityval(cnt);
+    while (cnt--) {
+	*hp++ = *src++;	   
+    }
+    return ret;
+}
+
 ERL_NIF_TERM enif_make_list_cell(ErlNifEnv* env, Eterm car, Eterm cdr)
 {
     Eterm* hp = alloc_heap(env,2);
@@ -384,10 +670,29 @@ ERL_NIF_TERM enif_make_list(ErlNifEnv* env, unsigned cnt, ...)
     return ret;
 }
 
-ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string)
+ERL_NIF_TERM enif_make_list_from_array(ErlNifEnv* env, const ERL_NIF_TERM arr[], unsigned cnt)
+{
+    Eterm* hp = alloc_heap(env,cnt*2);
+    Eterm ret = make_list(hp);
+    Eterm* last = &ret;
+    const Eterm* src = arr;
+
+    while (cnt--) {
+	*last = make_list(hp);
+	*hp = *src++;
+	last = ++hp;
+	++hp;
+    }
+    *last = NIL;
+    return ret;
+}
+
+ERL_NIF_TERM enif_make_string(ErlNifEnv* env, const char* string,
+			      ErlNifCharEncoding encoding)
 {    
     Sint n = sys_strlen(string);    
     Eterm* hp = alloc_heap(env,n*2);
+    ASSERT(encoding == ERL_NIF_LATIN1);
     return erts_bld_string_n(&hp,NULL,string,n); 
 }
 
@@ -397,32 +702,265 @@ ERL_NIF_TERM enif_make_ref(ErlNifEnv* env)
     return erts_make_ref_in_buffer(hp);
 }
 
-#if 0 /* To be continued... */
-typedef struct enif_handle_type_t
+void enif_system_info(ErlNifSysInfo *sip, size_t si_size)
 {
-    struct enif_handle_type_t* next;
-    struct enif_handle_type_t* prev;
-    const char* name;
-    void (*dtor)(void* obj);
-    erts_smp_atomic_t ref_cnt;  /* num of handles of this type */
-}ErlNifHandleType;
+    driver_system_info(sip, si_size);
+}
 
-ErlNifHandleType*
-enif_create_handle_type(ErlNifEnv* env, const char* type_name, 
-			void (*dtor)(void *))
+
+ErlNifMutex* enif_mutex_create(char *name) { return erl_drv_mutex_create(name); }
+void enif_mutex_destroy(ErlNifMutex *mtx) {  erl_drv_mutex_destroy(mtx); }
+int enif_mutex_trylock(ErlNifMutex *mtx) { return erl_drv_mutex_trylock(mtx); }
+void enif_mutex_lock(ErlNifMutex *mtx) { erl_drv_mutex_lock(mtx); }
+void enif_mutex_unlock(ErlNifMutex *mtx) { erl_drv_mutex_unlock(mtx); }
+ErlNifCond* enif_cond_create(char *name) { return erl_drv_cond_create(name); }
+void enif_cond_destroy(ErlNifCond *cnd) { erl_drv_cond_destroy(cnd); }
+void enif_cond_signal(ErlNifCond *cnd) { erl_drv_cond_signal(cnd); }
+void enif_cond_broadcast(ErlNifCond *cnd) { erl_drv_cond_broadcast(cnd); }
+void enif_cond_wait(ErlNifCond *cnd, ErlNifMutex *mtx) { erl_drv_cond_wait(cnd,mtx); }
+ErlNifRWLock* enif_rwlock_create(char *name) { return erl_drv_rwlock_create(name); }
+void enif_rwlock_destroy(ErlNifRWLock *rwlck) { erl_drv_rwlock_destroy(rwlck); }
+int enif_rwlock_tryrlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrlock(rwlck); }
+void enif_rwlock_rlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rlock(rwlck); }
+void enif_rwlock_runlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_runlock(rwlck); }
+int enif_rwlock_tryrwlock(ErlNifRWLock *rwlck) { return erl_drv_rwlock_tryrwlock(rwlck); }
+void enif_rwlock_rwlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwlock(rwlck); }
+void enif_rwlock_rwunlock(ErlNifRWLock *rwlck) { erl_drv_rwlock_rwunlock(rwlck); }
+int enif_tsd_key_create(char *name, ErlNifTSDKey *key) { return erl_drv_tsd_key_create(name,key); }
+void enif_tsd_key_destroy(ErlNifTSDKey key) { erl_drv_tsd_key_destroy(key); }
+void enif_tsd_set(ErlNifTSDKey key, void *data) { erl_drv_tsd_set(key,data); }
+void* enif_tsd_get(ErlNifTSDKey key) { return erl_drv_tsd_get(key); }
+ErlNifThreadOpts* enif_thread_opts_create(char *name) { return (ErlNifThreadOpts*) erl_drv_thread_opts_create(name); }
+void enif_thread_opts_destroy(ErlNifThreadOpts *opts) { erl_drv_thread_opts_destroy((ErlDrvThreadOpts*)opts); }
+int enif_thread_create(char *name, ErlNifTid *tid, void* (*func)(void *),
+		       void *args, ErlNifThreadOpts *opts) {
+    return erl_drv_thread_create(name,tid,func,args,(ErlDrvThreadOpts*)opts);
+}
+ErlNifTid enif_thread_self(void) { return erl_drv_thread_self(); }
+int enif_equal_tids(ErlNifTid tid1, ErlNifTid tid2) { return erl_drv_equal_tids(tid1,tid2); }
+void enif_thread_exit(void *resp) { erl_drv_thread_exit(resp); }
+int enif_thread_join(ErlNifTid tid, void **respp) { return erl_drv_thread_join(tid,respp); }
+
+int enif_fprintf(void* filep, const char* format, ...) 
+{ 
+    int ret;
+    va_list arglist;
+    va_start(arglist, format);
+    ret = erts_vfprintf((FILE*)filep, format, arglist);
+    va_end(arglist);
+    return ret;
+}    
+
+/***********************************************************
+ **       Memory managed (GC'ed) "resource" objects       **
+ ***********************************************************/
+
+
+struct enif_resource_type_t
 {
+    struct enif_resource_type_t* next;   /* list of all resource types */
+    struct enif_resource_type_t* prev;    
+    struct erl_module_nif* owner;  /* that created this type and thus implements the destructor*/
+    ErlNifResourceDtor* dtor;      /* user destructor function */
+    erts_refc_t refc;  /* num of resources of this type (HOTSPOT warning)
+                          +1 for active erl_module_nif */
+    char name[1];
+};
+
+/* dummy node in circular list */
+struct enif_resource_type_t resource_type_list; 
+
+typedef struct enif_resource_t
+{
+    struct enif_resource_type_t* type;
+#ifdef DEBUG
+    erts_refc_t nif_refc;
+#endif
+    char data[1];
+}ErlNifResource;
+
+#define SIZEOF_ErlNifResource(SIZE) (offsetof(ErlNifResource,data) + (SIZE))
+#define DATA_TO_RESOURCE(PTR) ((ErlNifResource*)((char*)(PTR) - offsetof(ErlNifResource,data)))
 
+static ErlNifResourceType* find_resource_type(const char* name)
+{
+    ErlNifResourceType* type;
+    for (type = resource_type_list.next;
+	 type != &resource_type_list;
+	 type = type->next) {
+
+	if (sys_strcmp(type->name, name) == 0) {
+	    return type;
+	}
+    }
+    return NULL;
+}
+
+#define in_area(ptr,start,nbytes) \
+    ((unsigned long)((char*)(ptr) - (char*)(start)) < (nbytes))
+
+
+static void close_lib(struct erl_module_nif* lib)
+{
+    ASSERT(lib != NULL);
+    ASSERT(lib->handle != NULL);
+    ASSERT(erts_refc_read(&lib->rt_dtor_cnt,0) == 0);
+
+    if (lib->entry != NULL && lib->entry->unload != NULL) {
+	ErlNifEnv env;
+	pre_nif_noproc(&env, lib);
+	lib->entry->unload(&env, lib->priv_data);
+	post_nif_noproc(&env);
+    }
+    erts_sys_ddll_close(lib->handle);
+    lib->handle = NULL;
 }
 
-ERL_NIF_TERM enif_make_handle(ErlNifEnv* env, ErlNifHandleType* htype, void* obj)
+static void steal_resource_type(ErlNifResourceType* type)
 {
+    struct erl_module_nif* lib = type->owner;
+
+    if (type->dtor != NULL
+	&& erts_refc_dectest(&lib->rt_dtor_cnt, 0) == 0
+	&& lib->is_orphan) {
+	/* last type with destructor gone, close orphan lib */
 
+	close_lib(lib);
+    }
+    if (erts_refc_dectest(&lib->rt_cnt, 0) == 0
+	&& lib->is_orphan) {
+	erts_free(ERTS_ALC_T_NIF, lib);
+    }
 }
 
-int enif_get_handle(ErlNifEnv* env, ERL_NIF_TERM term, void** objp)
+ErlNifResourceType*
+enif_open_resource_type(ErlNifEnv* env, const char* type_name, 
+			  ErlNifResourceDtor* dtor,
+			  enum ErlNifResourceFlags flags,
+			  enum ErlNifResourceFlags* tried)
 {
+    ErlNifResourceType* type = find_resource_type(type_name);
+    enum ErlNifResourceFlags op = flags;
+    ASSERT(erts_smp_is_system_blocked(0));
+    if (type == NULL) {
+	if (flags & ERL_NIF_RT_CREATE) {
+	    type = erts_alloc(ERTS_ALC_T_NIF,
+			      sizeof(struct enif_resource_type_t) 
+			      + sys_strlen(type_name));
+	    type->dtor = dtor;
+	    sys_strcpy(type->name, type_name);
+	    erts_refc_init(&type->refc, 1);
+	    type->owner = env->mod_nif;
+	    type->prev = &resource_type_list;
+	    type->next = resource_type_list.next;
+	    type->next->prev = type;
+	    type->prev->next = type;
+	    op = ERL_NIF_RT_CREATE;
+	}
+    }
+    else {
+	if (flags & ERL_NIF_RT_TAKEOVER) {	
+	    steal_resource_type(type);
+	    op = ERL_NIF_RT_TAKEOVER;
+	}
+	else {
+	    type = NULL;
+	}
+    }
+    if (type != NULL) {
+	type->owner = env->mod_nif;
+	type->dtor = dtor;
+	if (type->dtor != NULL) {
+	    erts_refc_inc(&type->owner->rt_dtor_cnt, 1);
+	}
+	erts_refc_inc(&type->owner->rt_cnt, 1);    
+    }
+    if (tried != NULL) {
+	*tried = op;
+    }
+    return type;
+}
+
+static void nif_resource_dtor(Binary* bin)
+{
+    ErlNifResource* resource = (ErlNifResource*) ERTS_MAGIC_BIN_DATA(bin);
+    ErlNifResourceType* type = resource->type;
+    ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
+
+    if (type->dtor != NULL) {
+	ErlNifEnv env;
+	pre_nif_noproc(&env, type->owner);
+	type->dtor(&env,resource->data);
+	post_nif_noproc(&env);
+    }
+    if (erts_refc_dectest(&type->refc, 0) == 0) {
+	ASSERT(type->next == NULL);
+	ASSERT(type->owner != NULL);
+	ASSERT(type->owner->is_orphan);
+	steal_resource_type(type);
+	erts_free(ERTS_ALC_T_NIF, type);
+    }
 }
+
+void* enif_alloc_resource(ErlNifEnv* env, ErlNifResourceType* type, unsigned size)
+{
+    Binary* bin = erts_create_magic_binary(SIZEOF_ErlNifResource(size), &nif_resource_dtor);
+    ErlNifResource* resource = ERTS_MAGIC_BIN_DATA(bin);
+    resource->type = type;
+    erts_refc_inc(&bin->refc, 1);
+#ifdef DEBUG
+    erts_refc_init(&resource->nif_refc, 1);
+#endif
+    erts_refc_inc(&resource->type->refc, 2);
+    return resource->data;
+}
+
+void enif_release_resource(ErlNifEnv* env, void* obj)
+{
+    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_DATA(resource);
+
+    ASSERT(ERTS_MAGIC_BIN_DESTRUCTOR(bin) == &nif_resource_dtor);
+#ifdef DEBUG
+    erts_refc_dec(&resource->nif_refc, 0);
 #endif
+    if (erts_refc_dectest(&bin->binary.refc, 0) == 0) {
+	erts_bin_free(&bin->binary);
+    }
+}
+
+ERL_NIF_TERM enif_make_resource(ErlNifEnv* env, void* obj)
+{
+    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    ErtsBinary* bin = ERTS_MAGIC_BIN_FROM_DATA(resource);
+    Eterm* hp = alloc_heap(env,PROC_BIN_SIZE);
+    return erts_mk_magic_binary_term(&hp, &MSO(env->proc), &bin->binary);
+}
+
+int enif_get_resource(ErlNifEnv* env, ERL_NIF_TERM term, ErlNifResourceType* type,
+		      void** objp)
+{
+    Binary* mbin;
+    ErlNifResource* resource;
+    if (!ERTS_TERM_IS_MAGIC_BINARY(term)) {
+	return 0;
+    }
+    mbin = ((ProcBin*) binary_val(term))->val;
+    resource = (ErlNifResource*) ERTS_MAGIC_BIN_DATA(mbin);
+    if (ERTS_MAGIC_BIN_DESTRUCTOR(mbin) != &nif_resource_dtor
+	|| resource->type != type) {	
+	return 0;
+    }
+    *objp = resource->data;
+    return 1;
+}
+
+unsigned enif_sizeof_resource(ErlNifEnv* env, void* obj)
+{
+    ErlNifResource* resource = DATA_TO_RESOURCE(obj);
+    Binary* bin = &ERTS_MAGIC_BIN_FROM_DATA(resource)->binary;
+    return ERTS_MAGIC_BIN_DATA_SIZE(bin) - offsetof(ErlNifResource,data);
+}
 
 /***************************************************************************
  **                              load_nif/2                               **
@@ -445,10 +983,7 @@ static Uint** get_func_pp(Eterm* mod_code, Eterm f_atom, unsigned arity)
     return NULL;
 }
 
-#define in_area(ptr,start,nbytes) \
-    ((unsigned long)((char*)(ptr) - (char*)(start)) < (nbytes))
-
-static void refresh_cached_nif_data(Eterm* mod_code,
+/*static void refresh_cached_nif_data(Eterm* mod_code,
 				    struct erl_module_nif* mod_nif)
 {
     int i;
@@ -459,9 +994,9 @@ static void refresh_cached_nif_data(Eterm* mod_code,
 	
 	erts_atom_get(func->name, sys_strlen(func->name), &f_atom); 
 	code_ptr = *get_func_pp(mod_code, f_atom, func->arity);
-	code_ptr[5+2] = (Uint) mod_nif->data;
+	code_ptr[5+2] = (Uint) mod_nif->priv_data;
     }
-}
+}*/
 
 static Eterm mkatom(const char *str)
 {
@@ -567,6 +1102,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
     ErtsSysDdllError errdesc = ERTS_SYS_DDLL_ERROR_INIT;
     Eterm ret = am_ok;
     int veto;
+    struct erl_module_nif* lib = NULL;
 
     len = intlist_to_buf(BIF_ARG_1, lib_name, sizeof(lib_name)-1);
     if (len < 1) {
@@ -652,16 +1188,27 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 
     /* Call load, reload or upgrade:
      */
-    if (mod->nif.handle != NULL) { /* Reload */
+
+
+    lib = erts_alloc(ERTS_ALC_T_NIF, sizeof(struct erl_module_nif));
+    lib->handle = handle;
+    lib->entry = entry;
+    erts_refc_init(&lib->rt_cnt, 0);
+    erts_refc_init(&lib->rt_dtor_cnt, 0);
+    lib->is_orphan = 0;
+    env.mod_nif = lib;
+    if (mod->nif != NULL) { /* Reload */
 	int k;
-	ASSERT(mod->nif.entry != NULL);
+        lib->priv_data = mod->nif->priv_data;
+
+	ASSERT(mod->nif->entry != NULL);
 	if (entry->reload == NULL) {
 	    ret = load_nif_error(BIF_P,reload,"Reload not supported by this NIF library.");
 	    goto error;
 	}
 	/* Check that no NIF is removed */
-	for (k=0; k < mod->nif.entry->num_of_funcs; k++) {
-	    ErlNifFunc* old_func = &mod->nif.entry->funcs[k];
+	for (k=0; k < mod->nif->entry->num_of_funcs; k++) {
+	    ErlNifFunc* old_func = &mod->nif->entry->funcs[k];
 	    for (i=0; i < entry->num_of_funcs; i++) {
 		if (old_func->arity == entry->funcs[i].arity
 		    && sys_strcmp(old_func->name, entry->funcs[i].name) == 0) {			   
@@ -675,37 +1222,39 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 		goto error;
 	    }
 	}       
-	erts_pre_nif(&env, BIF_P, mod->nif.data);
-	veto = entry->reload(&env, &env.nif_data, BIF_ARG_2);
+	erts_pre_nif(&env, BIF_P, lib);
+	veto = entry->reload(&env, &lib->priv_data, BIF_ARG_2);
 	erts_post_nif(&env);
 	if (veto) {
 	    ret = load_nif_error(BIF_P, reload, "Library reload-call unsuccessful.");
 	}
 	else {
-	    erts_sys_ddll_close(mod->nif.handle);
+	    mod->nif->entry = NULL; /* to prevent 'unload' callback */
+	    erts_unload_nif(mod->nif);
 	}
     }
     else {
-	if (mod->old_nif.handle != NULL) { /* Upgrade */
-	    void* prev_old_data = mod->old_nif.data;
+	lib->priv_data = NULL;
+	if (mod->old_nif != NULL) { /* Upgrade */
+	    void* prev_old_data = mod->old_nif->priv_data;
 	    if (entry->upgrade == NULL) {
 		ret = load_nif_error(BIF_P, upgrade, "Upgrade not supported by this NIF library.");
 		goto error;
 	    }
-	    erts_pre_nif(&env, BIF_P, NULL);
-	    veto = entry->upgrade(&env, &env.nif_data, &mod->old_nif.data, BIF_ARG_2);
+	    erts_pre_nif(&env, BIF_P, lib);
+	    veto = entry->upgrade(&env, &lib->priv_data, &mod->old_nif->priv_data, BIF_ARG_2);
 	    erts_post_nif(&env);
 	    if (veto) {
-		mod->old_nif.data = prev_old_data;
+		mod->old_nif->priv_data = prev_old_data;
 		ret = load_nif_error(BIF_P, upgrade, "Library upgrade-call unsuccessful.");
 	    }
-	    else if (mod->old_nif.data != prev_old_data) {
-		refresh_cached_nif_data(mod->old_code, &mod->old_nif);
-	    }
+	    /*else if (mod->old_nif->priv_data != prev_old_data) {
+		refresh_cached_nif_data(mod->old_code, mod->old_nif);
+	    }*/
 	}
 	else if (entry->load != NULL) { /* Initial load */
-	    erts_pre_nif(&env, BIF_P, NULL);
-	    veto = entry->load(&env, &env.nif_data, BIF_ARG_2);
+	    erts_pre_nif(&env, BIF_P, lib);
+	    veto = entry->load(&env, &lib->priv_data, BIF_ARG_2);
 	    erts_post_nif(&env);
 	    if (veto) {
 		ret = load_nif_error(BIF_P, "load", "Library load-call unsuccessful.");
@@ -716,9 +1265,7 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 	/*
 	** Everything ok, patch the beam code with op_call_nif
 	*/
-	mod->nif.data = env.nif_data;
-	mod->nif.handle = handle;
-	mod->nif.entry = entry;
+        mod->nif = lib; 
 	for (i=0; i < entry->num_of_funcs; i++)
 	{
 	    Uint* code_ptr;
@@ -727,17 +1274,21 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
 	    
 	    if (code_ptr[1] == 0) {
 		code_ptr[5+0] = (Uint) BeamOp(op_call_nif);		
-	    } else { /* Function traced, patch the original instruction word */
+	    }
+	    else { /* Function traced, patch the original instruction word */
 		BpData* bp = (BpData*) code_ptr[1];
 	        bp->orig_instr = (Uint) BeamOp(op_call_nif); 
 	    }	    
 	    code_ptr[5+1] = (Uint) entry->funcs[i].fptr;
-	    code_ptr[5+2] = (Uint) mod->nif.data;
+	    code_ptr[5+2] = (Uint) lib;
 	}
     }
     else {    
     error:
 	ASSERT(ret != am_ok);
+        if (lib != NULL) {
+	    erts_free(ERTS_ALC_T_NIF, lib);
+	}
 	if (handle != NULL) {
 	    erts_sys_ddll_close(handle);
 	}
@@ -749,3 +1300,53 @@ BIF_RETTYPE load_nif_2(BIF_ALIST_2)
     BIF_RET(ret);
 }
 
+
+void
+erts_unload_nif(struct erl_module_nif* lib)
+{
+    ErlNifResourceType* rt;
+    ErlNifResourceType* next;
+    ASSERT(erts_smp_is_system_blocked(0));
+    ASSERT(lib != NULL);
+    ASSERT(!lib->is_orphan);
+    for (rt = resource_type_list.next;
+	 rt != &resource_type_list;
+	 rt = next) {
+
+	next = rt->next;
+	if (rt->owner == lib) {
+	    rt->next->prev = rt->prev;
+	    rt->prev->next = rt->next;
+	    rt->next = NULL;
+	    rt->prev = NULL;
+	    if (erts_refc_dectest(&rt->refc, 0) == 0) {
+		if (rt->dtor != NULL) {
+		    erts_refc_dec(&lib->rt_dtor_cnt, 0);
+		}
+		erts_refc_dec(&lib->rt_cnt, 0);
+		erts_free(ERTS_ALC_T_NIF, rt);
+	    }
+	}
+    }
+    if (erts_refc_read(&lib->rt_dtor_cnt, 0) == 0) {
+	close_lib(lib);
+	if (erts_refc_read(&lib->rt_cnt, 0) == 0) {
+	    erts_free(ERTS_ALC_T_NIF, lib);
+	    return;
+	}
+    }
+    else {
+	ASSERT(erts_refc_read(&lib->rt_cnt, 1) > 0);
+    }
+    lib->is_orphan = 1;
+}	
+
+void erl_nif_init()
+{
+    resource_type_list.next = &resource_type_list;
+    resource_type_list.prev = &resource_type_list;
+    resource_type_list.dtor = NULL;
+    resource_type_list.owner = NULL;
+    resource_type_list.name[0] = '\0';
+}
+
diff --git a/erts/emulator/beam/erl_nif.h b/erts/emulator/beam/erl_nif.h
index e5e6d65c0e..1ccf00293e 100644
--- a/erts/emulator/beam/erl_nif.h
+++ b/erts/emulator/beam/erl_nif.h
@@ -1,25 +1,30 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 2009-2010. 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%
  */
 
 /* Include file for writers of Native Implemented Functions. 
 */
 
+#ifndef __ERL_NIF_H__
+#define __ERL_NIF_H__
+
+#include "erl_drv_nif.h"
+
 /* Version history:
 ** 0.1: R13B03
 ** 1.0: R13B04
@@ -63,11 +68,32 @@ typedef struct
 
     /* Internals (avert your eyes) */
     ERL_NIF_TERM bin_term;
-    unsigned char* tmp_alloc;
     void* ref_bin;
-    
 }ErlNifBinary;
 
+typedef struct enif_resource_type_t ErlNifResourceType;
+typedef void ErlNifResourceDtor(ErlNifEnv*, void*);
+enum ErlNifResourceFlags
+{
+    ERL_NIF_RT_CREATE = 1,
+    ERL_NIF_RT_TAKEOVER = 2
+};
+
+typedef enum
+{
+    ERL_NIF_LATIN1 = 1
+}ErlNifCharEncoding;
+
+typedef ErlDrvSysInfo ErlNifSysInfo;
+
+typedef struct ErlDrvTid_ *ErlNifTid;
+typedef struct ErlDrvMutex_ ErlNifMutex;
+typedef struct ErlDrvCond_ ErlNifCond;
+typedef struct ErlDrvRWLock_ ErlNifRWLock;
+typedef int ErlNifTSDKey;
+
+typedef ErlDrvThreadOpts ErlNifThreadOpts;
+
 #if (defined(__WIN32__) || defined(_WIN32) || defined(_WIN32_))
 #  define ERL_NIF_API_FUNC_DECL(RET_TYPE, NAME, ARGS) RET_TYPE (*NAME) ARGS
 typedef struct {
@@ -124,3 +150,5 @@ ERL_NIF_INIT_DECL(NAME)			\
     return &entry;			\
 }
 
+#endif /* __ERL_NIF_H__ */
+
diff --git a/erts/emulator/beam/erl_nif_api_funcs.h b/erts/emulator/beam/erl_nif_api_funcs.h
index 7556806ce4..ec07a976b2 100644
--- a/erts/emulator/beam/erl_nif_api_funcs.h
+++ b/erts/emulator/beam/erl_nif_api_funcs.h
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 2009-2010. 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%
  */
 
@@ -22,7 +22,7 @@
 #endif
 
 #ifdef ERL_NIF_API_FUNC_DECL
-ERL_NIF_API_FUNC_DECL(void*,enif_get_data,(ErlNifEnv*));
+ERL_NIF_API_FUNC_DECL(void*,enif_priv_data,(ErlNifEnv*));
 ERL_NIF_API_FUNC_DECL(void*,enif_alloc,(ErlNifEnv*, size_t size));
 ERL_NIF_API_FUNC_DECL(void,enif_free,(ErlNifEnv*, void* ptr));
 ERL_NIF_API_FUNC_DECL(int,enif_is_atom,(ErlNifEnv*, ERL_NIF_TERM term));
@@ -36,7 +36,7 @@ ERL_NIF_API_FUNC_DECL(int,enif_get_int,(ErlNifEnv*, ERL_NIF_TERM term, int* ip))
 ERL_NIF_API_FUNC_DECL(int,enif_get_ulong,(ErlNifEnv*, ERL_NIF_TERM term, unsigned long* ip));
 ERL_NIF_API_FUNC_DECL(int,enif_get_double,(ErlNifEnv*, ERL_NIF_TERM term, double* dp));
 ERL_NIF_API_FUNC_DECL(int,enif_get_list_cell,(ErlNifEnv* env, ERL_NIF_TERM term, ERL_NIF_TERM* head, ERL_NIF_TERM* tail));
-ERL_NIF_API_FUNC_DECL(int,enif_get_tuple,(ErlNifEnv* env, ERL_NIF_TERM tpl, int* arity, ERL_NIF_TERM** array));
+ERL_NIF_API_FUNC_DECL(int,enif_get_tuple,(ErlNifEnv* env, ERL_NIF_TERM tpl, int* arity, const ERL_NIF_TERM** array));
 ERL_NIF_API_FUNC_DECL(int,enif_is_identical,(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
 ERL_NIF_API_FUNC_DECL(int,enif_compare,(ErlNifEnv* env, ERL_NIF_TERM lhs, ERL_NIF_TERM rhs));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_binary,(ErlNifEnv* env, ErlNifBinary* bin));
@@ -49,15 +49,69 @@ ERL_NIF_API_FUNC_DECL(int,enif_make_existing_atom,(ErlNifEnv* env, const char* n
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_tuple,(ErlNifEnv* env, unsigned cnt, ...));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list,(ErlNifEnv* env, unsigned cnt, ...));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list_cell,(ErlNifEnv* env, ERL_NIF_TERM car, ERL_NIF_TERM cdr));
-ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_string,(ErlNifEnv* env, const char* string));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_string,(ErlNifEnv* env, const char* string, ErlNifCharEncoding));
 ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_ref,(ErlNifEnv* env));
+
+ERL_NIF_API_FUNC_DECL(ErlNifMutex*,enif_mutex_create,(char *name));
+ERL_NIF_API_FUNC_DECL(void,enif_mutex_destroy,(ErlNifMutex *mtx));
+ERL_NIF_API_FUNC_DECL(int,enif_mutex_trylock,(ErlNifMutex *mtx));
+ERL_NIF_API_FUNC_DECL(void,enif_mutex_lock,(ErlNifMutex *mtx));
+ERL_NIF_API_FUNC_DECL(void,enif_mutex_unlock,(ErlNifMutex *mtx));
+ERL_NIF_API_FUNC_DECL(ErlNifCond*,enif_cond_create,(char *name));
+ERL_NIF_API_FUNC_DECL(void,enif_cond_destroy,(ErlNifCond *cnd));
+ERL_NIF_API_FUNC_DECL(void,enif_cond_signal,(ErlNifCond *cnd));
+ERL_NIF_API_FUNC_DECL(void,enif_cond_broadcast,(ErlNifCond *cnd));
+ERL_NIF_API_FUNC_DECL(void,enif_cond_wait,(ErlNifCond *cnd, ErlNifMutex *mtx));
+ERL_NIF_API_FUNC_DECL(ErlNifRWLock*,enif_rwlock_create,(char *name));
+ERL_NIF_API_FUNC_DECL(void,enif_rwlock_destroy,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(int,enif_rwlock_tryrlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(void,enif_rwlock_rlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(void,enif_rwlock_runlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(int,enif_rwlock_tryrwlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(void,enif_rwlock_rwlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(void,enif_rwlock_rwunlock,(ErlNifRWLock *rwlck));
+ERL_NIF_API_FUNC_DECL(int,enif_tsd_key_create,(char *name, ErlNifTSDKey *key));
+ERL_NIF_API_FUNC_DECL(void,enif_tsd_key_destroy,(ErlNifTSDKey key));
+ERL_NIF_API_FUNC_DECL(void,enif_tsd_set,(ErlNifTSDKey key, void *data));
+ERL_NIF_API_FUNC_DECL(void*,enif_tsd_get,(ErlNifTSDKey key));
+ERL_NIF_API_FUNC_DECL(ErlNifThreadOpts*,enif_thread_opts_create,(char *name));
+ERL_NIF_API_FUNC_DECL(void,enif_thread_opts_destroy,(ErlNifThreadOpts *opts));
+ERL_NIF_API_FUNC_DECL(int,enif_thread_create,(char *name,ErlNifTid *tid,void * (*func)(void *),void *args,ErlNifThreadOpts *opts));
+ERL_NIF_API_FUNC_DECL(ErlNifTid,enif_thread_self,(void));
+ERL_NIF_API_FUNC_DECL(int,enif_equal_tids,(ErlNifTid tid1, ErlNifTid tid2));
+ERL_NIF_API_FUNC_DECL(void,enif_thread_exit,(void *resp));
+ERL_NIF_API_FUNC_DECL(int,enif_thread_join,(ErlNifTid, void **respp));
+
+ERL_NIF_API_FUNC_DECL(void*,enif_realloc,(ErlNifEnv*, void* ptr, size_t size));
+ERL_NIF_API_FUNC_DECL(void,enif_system_info,(ErlNifSysInfo *sip, size_t si_size));
+ERL_NIF_API_FUNC_DECL(int,enif_fprintf,(void/* FILE* */ *filep, const char *format, ...));
+ERL_NIF_API_FUNC_DECL(int,enif_inspect_iolist_as_binary,(ErlNifEnv*, ERL_NIF_TERM term, ErlNifBinary* bin));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_sub_binary,(ErlNifEnv*, ERL_NIF_TERM bin_term, unsigned pos, unsigned size));
+ERL_NIF_API_FUNC_DECL(int,enif_get_string,(ErlNifEnv*, ERL_NIF_TERM list, char* buf, unsigned len, ErlNifCharEncoding));
+ERL_NIF_API_FUNC_DECL(int,enif_get_atom,(ErlNifEnv*, ERL_NIF_TERM atom, char* buf, unsigned len));
+ERL_NIF_API_FUNC_DECL(int,enif_is_fun,(ErlNifEnv*, ERL_NIF_TERM term));
+ERL_NIF_API_FUNC_DECL(int,enif_is_pid,(ErlNifEnv*, ERL_NIF_TERM term));
+ERL_NIF_API_FUNC_DECL(int,enif_is_port,(ErlNifEnv*, ERL_NIF_TERM term));
+ERL_NIF_API_FUNC_DECL(int,enif_get_uint,(ErlNifEnv*, ERL_NIF_TERM term, unsigned* ip));
+ERL_NIF_API_FUNC_DECL(int,enif_get_long,(ErlNifEnv*, ERL_NIF_TERM term, long* ip));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_uint,(ErlNifEnv*, unsigned i));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_long,(ErlNifEnv*, long i));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_tuple_from_array,(ErlNifEnv*, const ERL_NIF_TERM arr[], unsigned cnt));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_list_from_array,(ErlNifEnv*, const ERL_NIF_TERM arr[], unsigned cnt));
+ERL_NIF_API_FUNC_DECL(int,enif_is_empty_list,(ErlNifEnv*, ERL_NIF_TERM term));
+ERL_NIF_API_FUNC_DECL(ErlNifResourceType*,enif_open_resource_type,(ErlNifEnv*, const char* type_name, void (*dtor)(ErlNifEnv*,void *), enum ErlNifResourceFlags flags, enum ErlNifResourceFlags* tried));
+ERL_NIF_API_FUNC_DECL(void*,enif_alloc_resource,(ErlNifEnv*, ErlNifResourceType* type, unsigned size));
+ERL_NIF_API_FUNC_DECL(void,enif_release_resource,(ErlNifEnv*, void* obj));
+ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_resource,(ErlNifEnv*, void* obj));
+ERL_NIF_API_FUNC_DECL(int,enif_get_resource,(ErlNifEnv*, ERL_NIF_TERM term, ErlNifResourceType* type, void** objp));
+ERL_NIF_API_FUNC_DECL(unsigned,enif_sizeof_resource,(ErlNifEnv*, void* obj));
 /*
 ** Add last to keep compatibility on Windows!!!
 */
 #endif
 
 #ifdef ERL_NIF_API_FUNC_MACRO
-#  define enif_get_data ERL_NIF_API_FUNC_MACRO(enif_get_data)
+#  define enif_priv_data ERL_NIF_API_FUNC_MACRO(enif_priv_data)
 #  define enif_alloc ERL_NIF_API_FUNC_MACRO(enif_alloc)
 #  define enif_free ERL_NIF_API_FUNC_MACRO(enif_free)
 #  define enif_is_atom ERL_NIF_API_FUNC_MACRO(enif_is_atom)
@@ -88,5 +142,84 @@ ERL_NIF_API_FUNC_DECL(ERL_NIF_TERM,enif_make_ref,(ErlNifEnv* env));
 #  define enif_make_string ERL_NIF_API_FUNC_MACRO(enif_make_string)
 #  define enif_make_ref ERL_NIF_API_FUNC_MACRO(enif_make_ref)
 
+#  define enif_mutex_create ERL_NIF_API_FUNC_MACRO(enif_mutex_create) 
+#  define enif_mutex_destroy ERL_NIF_API_FUNC_MACRO(enif_mutex_destroy) 
+#  define enif_mutex_trylock ERL_NIF_API_FUNC_MACRO(enif_mutex_trylock) 
+#  define enif_mutex_lock ERL_NIF_API_FUNC_MACRO(enif_mutex_lock) 
+#  define enif_mutex_unlock ERL_NIF_API_FUNC_MACRO(enif_mutex_unlock) 
+#  define enif_cond_create ERL_NIF_API_FUNC_MACRO(enif_cond_create) 
+#  define enif_cond_destroy ERL_NIF_API_FUNC_MACRO(enif_cond_destroy) 
+#  define enif_cond_signal ERL_NIF_API_FUNC_MACRO(enif_cond_signal) 
+#  define enif_cond_broadcast ERL_NIF_API_FUNC_MACRO(enif_cond_broadcast) 
+#  define enif_cond_wait ERL_NIF_API_FUNC_MACRO(enif_cond_wait) 
+#  define enif_rwlock_create ERL_NIF_API_FUNC_MACRO(enif_rwlock_create) 
+#  define enif_rwlock_destroy ERL_NIF_API_FUNC_MACRO(enif_rwlock_destroy) 
+#  define enif_rwlock_tryrlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_tryrlock) 
+#  define enif_rwlock_rlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_rlock) 
+#  define enif_rwlock_runlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_runlock) 
+#  define enif_rwlock_tryrwlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_tryrwlock) 
+#  define enif_rwlock_rwlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_rwlock) 
+#  define enif_rwlock_rwunlock ERL_NIF_API_FUNC_MACRO(enif_rwlock_rwunlock) 
+#  define enif_tsd_key_create ERL_NIF_API_FUNC_MACRO(enif_tsd_key_create) 
+#  define enif_tsd_key_destroy ERL_NIF_API_FUNC_MACRO(enif_tsd_key_destroy) 
+#  define enif_tsd_set ERL_NIF_API_FUNC_MACRO(enif_tsd_set) 
+#  define enif_tsd_get ERL_NIF_API_FUNC_MACRO(enif_tsd_get) 
+#  define enif_thread_opts_create ERL_NIF_API_FUNC_MACRO(enif_thread_opts_create) 
+#  define enif_thread_opts_destroy ERL_NIF_API_FUNC_MACRO(enif_thread_opts_destroy) 
+#  define enif_thread_create ERL_NIF_API_FUNC_MACRO(enif_thread_create) 
+#  define enif_thread_self ERL_NIF_API_FUNC_MACRO(enif_thread_self) 
+#  define enif_equal_tids ERL_NIF_API_FUNC_MACRO(enif_equal_tids) 
+#  define enif_thread_exit ERL_NIF_API_FUNC_MACRO(enif_thread_exit) 
+#  define enif_thread_join ERL_NIF_API_FUNC_MACRO(enif_thread_join) 
+
+#  define enif_realloc ERL_NIF_API_FUNC_MACRO(enif_realloc) 
+#  define enif_system_info ERL_NIF_API_FUNC_MACRO(enif_system_info) 
+#  define enif_fprintf ERL_NIF_API_FUNC_MACRO(enif_fprintf) 
+#  define enif_inspect_iolist_as_binary ERL_NIF_API_FUNC_MACRO(enif_inspect_iolist_as_binary)
+#  define enif_make_sub_binary ERL_NIF_API_FUNC_MACRO(enif_make_sub_binary)
+#  define enif_get_string ERL_NIF_API_FUNC_MACRO(enif_get_string)
+#  define enif_get_atom ERL_NIF_API_FUNC_MACRO(enif_get_atom)
+#  define enif_is_fun ERL_NIF_API_FUNC_MACRO(enif_is_fun)
+#  define enif_is_pid ERL_NIF_API_FUNC_MACRO(enif_is_pid)
+#  define enif_is_port ERL_NIF_API_FUNC_MACRO(enif_is_port)
+#  define enif_get_uint ERL_NIF_API_FUNC_MACRO(enif_get_uint)
+#  define enif_get_long ERL_NIF_API_FUNC_MACRO(enif_get_long)
+#  define enif_make_uint ERL_NIF_API_FUNC_MACRO(enif_make_uint)
+#  define enif_make_long ERL_NIF_API_FUNC_MACRO(enif_make_long)
+#  define enif_make_tuple_from_array ERL_NIF_API_FUNC_MACRO(enif_make_tuple_from_array)
+#  define enif_make_list_from_array ERL_NIF_API_FUNC_MACRO(enif_make_list_from_array)
+#  define enif_is_empty_list ERL_NIF_API_FUNC_MACRO(enif_is_empty_list)
+#  define enif_open_resource_type ERL_NIF_API_FUNC_MACRO(enif_open_resource_type)
+#  define enif_alloc_resource ERL_NIF_API_FUNC_MACRO(enif_alloc_resource)
+#  define enif_release_resource ERL_NIF_API_FUNC_MACRO(enif_release_resource)
+#  define enif_make_resource ERL_NIF_API_FUNC_MACRO(enif_make_resource)
+#  define enif_get_resource ERL_NIF_API_FUNC_MACRO(enif_get_resource)
+#  define enif_sizeof_resource ERL_NIF_API_FUNC_MACRO(enif_sizeof_resource)
+
+#endif
+
+#ifndef enif_make_list1
+#  define enif_make_list1(ENV,E1) enif_make_list(ENV,1,E1)
+#  define enif_make_list2(ENV,E1,E2) enif_make_list(ENV,2,E1,E2)
+#  define enif_make_list3(ENV,E1,E2,E3) enif_make_list(ENV,3,E1,E2,E3)
+#  define enif_make_list4(ENV,E1,E2,E3,E4) enif_make_list(ENV,4,E1,E2,E3,E4)
+#  define enif_make_list5(ENV,E1,E2,E3,E4,E5) enif_make_list(ENV,5,E1,E2,E3,E4,E5)
+#  define enif_make_list6(ENV,E1,E2,E3,E4,E5,E6) enif_make_list(ENV,6,E1,E2,E3,E4,E5,E6)
+#  define enif_make_list7(ENV,E1,E2,E3,E4,E5,E6,E7) enif_make_list(ENV,7,E1,E2,E3,E4,E5,E6,E7)
+#  define enif_make_list8(ENV,E1,E2,E3,E4,E5,E6,E7,E8) enif_make_list(ENV,8,E1,E2,E3,E4,E5,E6,E7,E8)
+#  define enif_make_list9(ENV,E1,E2,E3,E4,E5,E6,E7,E8,E9) enif_make_list(ENV,9,E1,E2,E3,E4,E5,E6,E7,E8,E9)
+#  define enif_make_tuple1(ENV,E1) enif_make_tuple(ENV,1,E1)
+#  define enif_make_tuple2(ENV,E1,E2) enif_make_tuple(ENV,2,E1,E2)
+#  define enif_make_tuple3(ENV,E1,E2,E3) enif_make_tuple(ENV,3,E1,E2,E3)
+#  define enif_make_tuple4(ENV,E1,E2,E3,E4) enif_make_tuple(ENV,4,E1,E2,E3,E4)
+#  define enif_make_tuple5(ENV,E1,E2,E3,E4,E5) enif_make_tuple(ENV,5,E1,E2,E3,E4,E5)
+#  define enif_make_tuple6(ENV,E1,E2,E3,E4,E5,E6) enif_make_tuple(ENV,6,E1,E2,E3,E4,E5,E6)
+#  define enif_make_tuple7(ENV,E1,E2,E3,E4,E5,E6,E7) enif_make_tuple(ENV,7,E1,E2,E3,E4,E5,E6,E7)
+#  define enif_make_tuple8(ENV,E1,E2,E3,E4,E5,E6,E7,E8) enif_make_tuple(ENV,8,E1,E2,E3,E4,E5,E6,E7,E8)
+#  define enif_make_tuple9(ENV,E1,E2,E3,E4,E5,E6,E7,E8,E9) enif_make_tuple(ENV,9,E1,E2,E3,E4,E5,E6,E7,E8,E9)
+#endif
+
+#ifndef enif_get_data
+#  define enif_get_data enif_priv_data /* deprecated */
 #endif
 
diff --git a/erts/emulator/beam/external.c b/erts/emulator/beam/external.c
index b011d4c0de..099eddd195 100644
--- a/erts/emulator/beam/external.c
+++ b/erts/emulator/beam/external.c
@@ -1027,11 +1027,12 @@ static uLongf binary2term_uncomp_size(byte* data, Sint size)
 
     err = inflateInit(&stream);
     if (err == Z_OK) {
-	while ((err = inflate(&stream, Z_NO_FLUSH)) == Z_OK) {
-	    uncomp_size += chunk_size - stream.avail_out;
+	do {
 	    stream.next_out = tmp_buf;
-	    stream.avail_out = chunk_size;
-	}
+	    stream.avail_out = chunk_size;	   
+	    err = inflate(&stream, Z_NO_FLUSH);
+	    uncomp_size += chunk_size - stream.avail_out;
+	}while (err == Z_OK);
 	inflateEnd(&stream);
     }
     erts_free(ERTS_ALC_T_TMP, tmp_buf);
diff --git a/erts/emulator/beam/global.h b/erts/emulator/beam/global.h
index 8def007c63..cab249a53f 100644
--- a/erts/emulator/beam/global.h
+++ b/erts/emulator/beam/global.h
@@ -76,19 +76,29 @@ typedef struct line_buf {  /* Buffer used in line oriented I/O */
 			      The rest is the overflow buffer. */
 } LineBuf;
 
+/* Temporary object header, auto-deallocated when NIF returns. */
+struct enif_tmp_obj_t {
+    struct enif_tmp_obj_t* next;
+    void (*dtor)(struct enif_tmp_obj_t*);
+    /*char data[];*/
+};
 struct enif_environment_t /* ErlNifEnv */
 {
-    void* nif_data;
+    struct erl_module_nif* mod_nif;
     Process* proc;
     Eterm* hp;
     Eterm* hp_end;
-    unsigned heap_frag_sz;
+    ErlHeapFragment* heap_frag;
     int fpe_was_unmasked;
+    struct enif_tmp_obj_t* tmp_obj_list;
 };
-extern void erts_pre_nif(struct enif_environment_t*, Process*, void* nif_data);
+extern void erts_pre_nif(struct enif_environment_t*, Process*,
+			 struct erl_module_nif*);
 extern void erts_post_nif(struct enif_environment_t* env);
 extern Eterm erts_nif_taints(Process* p);
-extern void erts_print_nif_taints(int to, void* to_arg); 
+extern void erts_print_nif_taints(int to, void* to_arg);
+void erts_unload_nif(struct erl_module_nif* nif);
+extern void erl_nif_init(void);
 
 /*
  * Port Specific Data.
@@ -403,6 +413,9 @@ typedef struct binary {
     char orig_bytes[1]; /* to be continued */
 } Binary;
 
+#define ERTS_SIZEOF_Binary(Sz) \
+    (offsetof(Binary,orig_bytes) + (Sz))
+
 typedef struct {
     ERTS_INTERNAL_BINARY_FIELDS
     long orig_size;
@@ -435,7 +448,9 @@ typedef union {
 #define ERTS_MAGIC_BIN_ORIG_SIZE(Sz) \
   (sizeof(void (*)(Binary *)) + (Sz))
 #define ERTS_MAGIC_BIN_SIZE(Sz) \
-  (sizeof(ErtsMagicBinary) - 1 + (Sz))
+  (offsetof(ErtsMagicBinary,magic_bin_data) + (Sz))
+#define ERTS_MAGIC_BIN_FROM_DATA(DATA) \
+  ((ErtsBinary*)((char*)(DATA) - offsetof(ErtsMagicBinary,magic_bin_data)))
 
 #define Binary2ErlDrvBinary(B) (&((ErtsBinary *) (B))->driver.binary)
 #define ErlDrvBinary2Binary(D) ((Binary *) \
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index c5de180cb2..ad0b909b2a 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -31,6 +31,7 @@
 
 /* must be included BEFORE global.h (since it includes erl_driver.h) */
 #include "erl_sys_driver.h"
+#include "erl_nif.h"
 
 #include "erl_vm.h"
 #include "global.h"
@@ -1078,7 +1079,7 @@ int erts_write_to_port(Eterm caller_id, Port *p, Eterm list)
 	}
 	cbin = driver_alloc_binary(csize);
 	if (!cbin)
-	    erts_alloc_enomem(ERTS_ALC_T_DRV_BINARY, sizeof(Binary) + csize);
+	    erts_alloc_enomem(ERTS_ALC_T_DRV_BINARY, ERTS_SIZEOF_Binary(csize));
 
 	/* Element 0 is for driver usage to add header block */
 	ivp[0].iov_base = NULL;
@@ -4473,7 +4474,14 @@ driver_system_info(ErlDrvSysInfo *sip, size_t si_size)
 	sip->async_threads = erts_async_max_threads;
 	sip->scheduler_threads = erts_no_schedulers;
     }
-
+    /*
+     * 'nif_minor_version' is the last field in the third version
+     * (driver version 1.5, NIF version 1.0) 
+     */
+    if (si_size >= ERL_DRV_SYS_INFO_SIZE(nif_minor_version)) {
+	sip->nif_major_version = ERL_NIF_MAJOR_VERSION;
+	sip->nif_minor_version = ERL_NIF_MINOR_VERSION;
+    }
 }
 
 
diff --git a/erts/emulator/beam/module.c b/erts/emulator/beam/module.c
index 57a43c89f4..91e4ccce70 100644
--- a/erts/emulator/beam/module.c
+++ b/erts/emulator/beam/module.c
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1996-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1996-2010. 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%
  */
 
@@ -66,12 +66,8 @@ static Module* module_alloc(Module* tmpl)
     obj->code_length = 0;
     obj->old_code_length = 0;
     obj->slot.index = -1;
-    obj->nif.handle = NULL;
-    obj->old_nif.handle = NULL;
-    obj->nif.entry = NULL;
-    obj->old_nif.entry = NULL;
-    obj->nif.data = NULL;
-    obj->old_nif.data = NULL;
+    obj->nif = NULL;
+    obj->old_nif = NULL;
     return obj;
 }
 
diff --git a/erts/emulator/beam/module.h b/erts/emulator/beam/module.h
index 314be8e2ee..87d13b3607 100644
--- a/erts/emulator/beam/module.h
+++ b/erts/emulator/beam/module.h
@@ -1,19 +1,19 @@
 /*
  * %CopyrightBegin%
- * 
- * Copyright Ericsson AB 1996-2009. All Rights Reserved.
- * 
+ *
+ * Copyright Ericsson AB 1996-2010. 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%
  */
 
@@ -24,11 +24,6 @@
 #include "index.h"
 #endif
 
-struct erl_module_nif {
-    void* handle;
-    struct enif_entry_t* entry;
-    void* data;
-};
 
 typedef struct erl_module {
     IndexSlot slot;		/* Must be located at top of struct! */
@@ -39,8 +34,8 @@ typedef struct erl_module {
     int code_length;		/* Length of loaded code in bytes. */
     int old_code_length;	/* Length of old loaded code in bytes */
     unsigned catches, old_catches;
-    struct erl_module_nif nif;
-    struct erl_module_nif old_nif;
+    struct erl_module_nif* nif;
+    struct erl_module_nif* old_nif;
 } Module; 
 
 Module* erts_get_module(Eterm mod);
diff --git a/erts/emulator/beam/utils.c b/erts/emulator/beam/utils.c
index 687e6fa67b..31efddc0f2 100644
--- a/erts/emulator/beam/utils.c
+++ b/erts/emulator/beam/utils.c
@@ -124,26 +124,28 @@ erts_heap_alloc(Process* p, Uint need)
 #endif /* FORCE_HEAP_FRAGS */
 
     n = need;
+    bp = MBUF(p);
+    if (bp != NULL && need <= (bp->size - bp->used_size)) {
+	Eterm* ret = bp->mem + bp->used_size;
+	bp->used_size += need;
+	return ret;
+    }
 #ifdef DEBUG
     n++;
 #endif
     bp = (ErlHeapFragment*)
 	ERTS_HEAP_ALLOC(ERTS_ALC_T_HEAP_FRAG, ERTS_HEAP_FRAG_SIZE(n));
 
-#ifdef DEBUG
-    n--;
-#endif
-
-#if defined(DEBUG)
-    for (i = 0; i <= n; i++) {
-	bp->mem[i] = ERTS_HOLE_MARKER;
-    }
-#elif defined(CHECK_FOR_HOLES)
+#if defined(DEBUG) || defined(CHECK_FOR_HOLES)
     for (i = 0; i < n; i++) {
 	bp->mem[i] = ERTS_HOLE_MARKER;
     }
 #endif
 
+#ifdef DEBUG
+    n--;
+#endif
+
     /*
      * When we have created a heap fragment, we are no longer allowed
      * to store anything more on the heap. 
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index e47161fcbc..522caec8f1 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -1,38 +1,50 @@
 %%
 %% %CopyrightBegin%
-%% 
-%% Copyright Ericsson AB 2009. All Rights Reserved.
-%% 
+%%
+%% Copyright Ericsson AB 2009-2010. 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%
 %%
 
 -module(nif_SUITE).
 
 %%-define(line_trace,true).
+%%-define(CHECK(Exp,Got), ?line check(Exp,Got,?LINE)).
+-define(CHECK(Exp,Got), ?line Exp = Got).
 
 -include("test_server.hrl").
 
 -export([all/1, fin_per_testcase/2, basic/1, reload/1, upgrade/1, heap_frag/1,
-	 types/1, many_args/1, neg/1]).
+	 types/1, many_args/1, binaries/1, get_string/1, get_atom/1, api_macros/1,
+	 from_array/1, iolist_as_binary/1, resource/1, resource_takeover/1,
+	 threading/1, neg/1]).
 
 -export([many_args_100/100]).
 -define(nif_stub,nif_stub_error(?LINE)).
 
 all(suite) ->
-    [basic, reload, upgrade, heap_frag, types, many_args, neg].
+    [basic, reload, upgrade, heap_frag, types, many_args, binaries, get_string,
+     get_atom, api_macros, from_array, iolist_as_binary, resource,
+     resource_takeover, threading, neg].
+
+%%init_per_testcase(_Case, Config) ->
+%%    ?line Dog = ?t:timetrap(?t:seconds(60*60*24)),
+%%    [{watchdog, Dog}|Config].
 
 fin_per_testcase(_Func, _Config) ->
+    %%Dog = ?config(watchdog, Config),
+    %%?t:timetrap_cancel(Dog),
     P1 = code:purge(nif_mod),
     Del = code:delete(nif_mod),
     P2 = code:purge(nif_mod),
@@ -51,6 +63,7 @@ basic(Config) when is_list(Config) ->
 reload(doc) -> ["Test reload callback in nif lib"];
 reload(suite) -> [];  
 reload(Config) when is_list(Config) ->    
+    TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
 
     ?line Data = ?config(data_dir, Config),
@@ -58,16 +71,16 @@ reload(Config) when is_list(Config) ->
     ?line {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
     ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
-    ?line nif_mod:load_nif_lib(Config, 1),
+    ?line ok = nif_mod:load_nif_lib(Config, 1),
 
     ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
     ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),    
         
-    ?line nif_mod:load_nif_lib(Config, 2),
+    ?line ok = nif_mod:load_nif_lib(Config, 2),
     ?line 2 = nif_mod:lib_version(),
     ?line [{reload,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),    
 
-    ?line nif_mod:load_nif_lib(Config, 1),
+    ?line ok = nif_mod:load_nif_lib(Config, 1),
     ?line 1 = nif_mod:lib_version(),
     ?line [{reload,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),    
 
@@ -79,11 +92,13 @@ reload(Config) when is_list(Config) ->
     ?line [{unload,1,3,103}] = nif_mod_call_history(),    
 
     ?line [?MODULE, nif_mod] = erlang:system_info(taints),
+    ?line verify_tmpmem(TmpMem),
     ok.
 
 upgrade(doc) -> ["Test upgrade callback in nif lib"];
 upgrade(suite) -> [];  
 upgrade(Config) when is_list(Config) ->    
+    TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
 
     ?line Data = ?config(data_dir, Config),
@@ -91,7 +106,7 @@ upgrade(Config) when is_list(Config) ->
     ?line {ok,nif_mod,Bin} = compile:file(File, [binary,return_errors]),
     ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
-    ?line nif_mod:load_nif_lib(Config, 1),
+    ?line ok = nif_mod:load_nif_lib(Config, 1),
     ?line {Pid,MRef} = nif_mod:start(),
     ?line 1 = call(Pid,lib_version),
 
@@ -104,7 +119,7 @@ upgrade(Config) when is_list(Config) ->
     ?line 1 = call(Pid,lib_version),
     ?line [{lib_version,1,4,104}] = nif_mod_call_history(),
 
-    ?line nif_mod:load_nif_lib(Config, 1),
+    ?line ok = nif_mod:load_nif_lib(Config, 1),
     ?line 1 = nif_mod:lib_version(),
     ?line [{upgrade,1,5,105},{lib_version,1,6,106}] = nif_mod_call_history(),
 
@@ -131,7 +146,7 @@ upgrade(Config) when is_list(Config) ->
     ?line {Pid2,MRef2} = nif_mod:start(),
     ?line undefined = call(Pid2,lib_version),
 
-    ?line nif_mod:load_nif_lib(Config, 1),
+    ?line ok = nif_mod:load_nif_lib(Config, 1),
     ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
     ?line 1 = call(Pid2,lib_version),
     ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102},{lib_version,1,3,103}] = nif_mod_call_history(),
@@ -142,7 +157,7 @@ upgrade(Config) when is_list(Config) ->
     ?line 1 = call(Pid2,lib_version),
     ?line [{lib_version,1,4,104}] = nif_mod_call_history(),
 
-    ?line nif_mod:load_nif_lib(Config, 2),
+    ?line ok = nif_mod:load_nif_lib(Config, 2),
     ?line 2 = nif_mod:lib_version(),
     ?line [{upgrade,2,1,201},{lib_version,2,2,202}] = nif_mod_call_history(),
 
@@ -167,14 +182,17 @@ upgrade(Config) when is_list(Config) ->
     ?line [{unload,2,4,204}] = nif_mod_call_history(),    
 
     ?line [?MODULE, nif_mod] = erlang:system_info(taints),    
+    ?line verify_tmpmem(TmpMem),
     ok.
 
 heap_frag(doc) -> ["Test NIF building heap fragments"];
 heap_frag(suite) -> [];  
 heap_frag(Config) when is_list(Config) ->    
+    TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
     
     heap_frag_do(1,1000000),
+    ?line verify_tmpmem(TmpMem),
     ok.
 
 heap_frag_do(N, Max) when N > Max ->
@@ -188,6 +206,7 @@ heap_frag_do(N, Max) ->
 types(doc) -> ["Type tests"];
 types(suite) -> [];
 types(Config) when is_list(Config) ->
+    TmpMem = tmpmem(),
     ensure_lib_loaded(Config),
     ?line ok = type_test(),
     lists:foreach(fun(Tpl) ->
@@ -197,6 +216,7 @@ types(Config) when is_list(Config) ->
                   [{},{ok},{{}},{[],{}},{1,2,3,4,5}]),
     Stuff = [[],{},0,0.0,(1 bsl 100),(fun()-> ok end),make_ref(),self()],
     [eq_cmp(A,clone(B)) || A<-Stuff, B<-Stuff],                   
+    ?line verify_tmpmem(TmpMem),
     ok.
 
 clone(X) ->
@@ -227,17 +247,506 @@ eq_cmp_do(A,B) ->
 many_args(doc) -> ["Test NIF with many arguments"];
 many_args(suite) -> [];
 many_args(Config) when is_list(Config) ->
+    TmpMem = tmpmem(),
     ?line ensure_lib_loaded(Config ,1),
     ?line ok = apply(?MODULE,many_args_100,lists:seq(1,100)),
     ?line ok = many_args_100(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100),
+    ?line verify_tmpmem(TmpMem),
     ok.
 
-        
+binaries(doc) -> ["Test NIF binary handling."];
+binaries(suite) -> [];
+binaries(Config) when is_list(Config) ->
+    TmpMem = tmpmem(),
+    ?line ensure_lib_loaded(Config, 1),
+    ?line RefcBin = list_to_binary(lists:seq(1,255)),
+    ?line RefcBin = clone_bin(RefcBin),
+    ?line HeapBin = list_to_binary(lists:seq(1,20)),
+    ?line HeapBin = clone_bin(HeapBin),
+    ?line <<_:8,Sub1:6/binary,_/binary>> = RefcBin, 
+    ?line <<_:8,Sub2:6/binary,_/binary>> = HeapBin,
+    ?line Sub1 = Sub2,
+    ?line Sub1 = clone_bin(Sub1),
+    ?line Sub2 = clone_bin(Sub2),
+    ?line <<_:9,Sub3:6/binary,_/bitstring>> = RefcBin, 
+    ?line <<_:9,Sub4:6/binary,_/bitstring>> = HeapBin,
+    ?line Sub3 = Sub4,
+    ?line Sub3 = clone_bin(Sub3),
+    ?line Sub4 = clone_bin(Sub4),
+    %% When NIFs get bitstring support
+    %%?line <<_:8,Sub5:27/bitstring,_/bitstring>> = RefcBin, 
+    %%?line <<_:8,Sub6:27/bitstring,_/bitstring>> = HeapBin,
+    %%?line Sub5 = Sub6,
+    %%?line Sub5 = clone_bin(Sub5),
+    %%?line Sub6 = clone_bin(Sub6),
+    %%?line <<_:9,Sub7:27/bitstring,_/bitstring>> = RefcBin, 
+    %%?line <<_:9,Sub8:27/bitstring,_/bitstring>> = HeapBin,
+    %%?line Sub7 = Sub8,
+    %%?line Sub7 = clone_bin(Sub7),
+    %%?line Sub8 = clone_bin(Sub8),
+    %%?line <<>> = clone_bin(<<>>),
+
+    <<_:8,SubBinA:200/binary,_/binary>> = RefcBin,
+    <<_:9,SubBinB:200/binary,_/bitstring>> = RefcBin,
+    <<_:8,SubBinC:17/binary,_/binary>> = HeapBin,
+    <<_:9,SubBinD:17/binary,_/bitstring>> = HeapBin,
+    test_make_sub_bin(RefcBin),
+    test_make_sub_bin(HeapBin),
+    test_make_sub_bin(SubBinA),
+    test_make_sub_bin(SubBinB),
+    test_make_sub_bin(SubBinC),
+    test_make_sub_bin(SubBinD),
+    
+    ?line verify_tmpmem(TmpMem),
+    ok.
+
+test_make_sub_bin(Bin) ->
+    Size = byte_size(Bin),
+    Rest10 = Size - 10,
+    Rest1 = Size - 1,
+    ?line Bin = make_sub_bin(Bin, 0, Size),
+    <<_:10/binary,Sub0:Rest10/binary>> = Bin,
+    ?line Sub0 = make_sub_bin(Bin, 10, Rest10),
+    <<Sub1:10/binary,_/binary>> = Bin,
+    ?line Sub1 = make_sub_bin(Bin, 0, 10),
+    <<_:7/binary,Sub2:10/binary,_/binary>> = Bin,
+    ?line Sub2 = make_sub_bin(Bin, 7, 10),
+    ?line <<>> = make_sub_bin(Bin, 0, 0),
+    ?line <<>> = make_sub_bin(Bin, 10, 0),
+    ?line <<>> = make_sub_bin(Bin, Rest1, 0),
+    ?line <<>> = make_sub_bin(Bin, Size, 0),
+    ok.
+    
+get_string(doc) -> ["Test enif_get_string"];
+get_string(suite) -> [];
+get_string(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    ?line {7, <<"hejsan",0,_:3/binary>>} = string_to_bin("hejsan",10),
+    ?line {7, <<"hejsan",0,_>>} = string_to_bin("hejsan",8),
+    ?line {7, <<"hejsan",0>>} = string_to_bin("hejsan",7),
+    ?line {-6, <<"hejsa",0>>} = string_to_bin("hejsan",6),
+    ?line {-5, <<"hejs",0>>} = string_to_bin("hejsan",5),
+    ?line {-1, <<0>>} = string_to_bin("hejsan",1),
+    ?line {0, <<>>} = string_to_bin("hejsan",0),
+    ?line {1, <<0>>} = string_to_bin("",1),
+    ?line {0, <<>>} = string_to_bin("",0),
+    ok.
+
+get_atom(doc) -> ["Test enif_get_atom"];
+get_atom(suite) -> [];
+get_atom(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    ?line {7, <<"hejsan",0,_:3/binary>>} = atom_to_bin(hejsan,10),
+    ?line {7, <<"hejsan",0,_>>} = atom_to_bin(hejsan,8),
+    ?line {7, <<"hejsan",0>>} = atom_to_bin(hejsan,7),
+    ?line {0, <<_:6/binary>>} = atom_to_bin(hejsan,6),
+    ?line {0, <<>>} = atom_to_bin(hejsan,0),
+    ?line {1, <<0>>} = atom_to_bin('',1),
+    ?line {0, <<>>} = atom_to_bin('',0),
+    ok.
+
+api_macros(doc) -> ["Test macros enif_make_list<N> and enif_make_tuple<N>"];
+api_macros(suite) -> [];
+api_macros(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    Expected = {[lists:seq(1,N) || N <- lists:seq(1,9)],
+		[list_to_tuple(lists:seq(1,N)) || N <- lists:seq(1,9)]
+	       },
+    ?line Expected = macros(list_to_tuple(lists:seq(1,9))),
+    ok.
+
+from_array(doc) -> ["enif_make_[tuple|list]_from_array"];
+from_array(suite) -> [];
+from_array(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    lists:foreach(fun(Tpl) ->
+			  Lst = tuple_to_list(Tpl),
+			  ?line {Lst,Tpl} = tuple_2_list_and_tuple(Tpl)
+		  end,
+		  [{}, {1,2,3}, {[4,5],[],{},{6,7}}, {{}}, {[]}]),
+    ok.
+
+iolist_as_binary(doc) -> ["enif_inspect_iolist_as_binary"];
+iolist_as_binary(suite) -> [];
+iolist_as_binary(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    TmpMem = tmpmem(),
+    List = [<<"hejsan">>, <<>>, [], [17], [<<>>],
+	    [127,128,255,0],
+	    [1, 2, 3, <<"abc">>, [<<"def">>,4], 5, <<"ghi">>],
+	    [1, 2, 3, <<"abc">>, [<<"def">>,4], 5 | <<"ghi">>]],
+	    
+    lists:foreach(fun(IoL) ->
+			  B1 = erlang:iolist_to_binary(IoL),
+			  ?line B2 = iolist_2_bin(IoL),
+			  ?line B1 = B2
+		  end,
+		  List),
+    ?line verify_tmpmem(TmpMem),
+    ok.
+
+resource(doc) -> ["Test memory managed objects, aka 'resources'"];
+resource(suite) -> [];
+resource(Config) when is_list(Config) ->
+    ?line ensure_lib_loaded(Config, 1),
+    ?line Type = get_resource_type(0),
+    resource_hugo(Type),
+    resource_otto(Type),
+    resource_new(Type),
+    resource_neg(Type),
+    ok.
+
+resource_hugo(Type) ->
+    DtorCall = resource_hugo_do(Type),
+    erlang:garbage_collect(),
+    ?line DtorCall = last_resource_dtor_call(),
+    ok.
+
+resource_hugo_do(Type) ->
+    HugoBin = <<"Hugo Hacker">>,
+    ?line HugoPtr = alloc_resource(Type, HugoBin),
+    ?line Hugo = make_resource(HugoPtr),
+    ?line <<>> = Hugo,
+    release_resource(HugoPtr),
+    erlang:garbage_collect(),
+    ?line {HugoPtr,HugoBin} = get_resource(Type,Hugo),
+    Pid = spawn_link(fun() -> 			     
+			     receive {Pid, Type, Resource, Ptr, Bin} ->
+				     Pid ! {self(), got_it},
+				     receive {Pid, check_it} ->
+					     ?line {Ptr,Bin} = get_resource(Type,Resource),
+					     Pid ! {self(), ok}
+				     end
+			     end
+		     end),
+    Pid ! {self(), Type, Hugo, HugoPtr, HugoBin},
+    ?line {Pid, got_it} = receive_any(),
+    erlang:garbage_collect(),   % just to make our ProcBin move in memory
+    Pid ! {self(), check_it},
+    ?line {Pid, ok} = receive_any(),
+    ?line [] = last_resource_dtor_call(),
+    ?line {HugoPtr,HugoBin} = get_resource(Type,Hugo),
+    {HugoPtr, HugoBin, 1}.
+
+resource_otto(Type) ->
+    {OttoPtr, OttoBin} = resource_otto_do(Type),
+    erlang:garbage_collect(),
+    ?line [] = last_resource_dtor_call(),
+    release_resource(OttoPtr),
+    ?line {OttoPtr,OttoBin,1} = last_resource_dtor_call(),
+    ok.
+    
+resource_otto_do(Type) ->
+    OttoBin = <<"Otto Ordonnans">>,
+    ?line OttoPtr = alloc_resource(Type, OttoBin),
+    ?line Otto = make_resource(OttoPtr),
+    ?line <<>> = Otto,
+    %% forget resource term but keep referenced by NIF
+    {OttoPtr, OttoBin}.    
+
+resource_new(Type) ->
+    ?line {PtrB,BinB} = resource_new_do1(Type),
+    erlang:garbage_collect(),
+    ?line {PtrB,BinB,1} = last_resource_dtor_call(),
+    ok.
+    
+resource_new_do1(Type) ->
+    ?line {{PtrA,BinA}, {ResB,PtrB,BinB}} = resource_new_do2(Type),
+    erlang:garbage_collect(),
+    ?line {PtrA,BinA,1} = last_resource_dtor_call(),
+    ?line {PtrB,BinB} = get_resource(Type, ResB),
+    %% forget ResB and make it garbage
+    {PtrB,BinB}.
+    
+resource_new_do2(Type) ->
+    BinA = <<"NewA">>,
+    BinB = <<"NewB">>,
+    ?line ResA = make_new_resource(Type, BinA),
+    ?line ResB = make_new_resource(Type, BinB),
+    ?line <<>> = ResA,
+    ?line <<>> = ResB,
+    ?line {PtrA,BinA} = get_resource(Type, ResA),
+    ?line {PtrB,BinB} = get_resource(Type, ResB),
+    ?line true = (PtrA =/= PtrB),
+    ?line [] = last_resource_dtor_call(),
+    %% forget ResA and make it garbage
+    {{PtrA,BinA}, {ResB,PtrB,BinB}}.
+
+resource_neg(TypeA) ->
+    TypeB = get_resource_type(1),
+    Aptr = alloc_resource(TypeA, <<"Arnold">>),
+    Bptr = alloc_resource(TypeB, <<"Bobo">>),
+    ?line {'EXIT',{badarg,_}} = (catch get_resource(TypeA, Bptr)),
+    ?line {'EXIT',{badarg,_}} = (catch get_resource(TypeB, Aptr)),
+    ok.
     
+-define(RT_CREATE,1).
+-define(RT_TAKEOVER,2).
+
+resource_takeover(doc) -> ["Test resource takeover by module reload and upgrade"];
+resource_takeover(suite) -> [];  
+resource_takeover(Config) when is_list(Config) ->    
+    TmpMem = tmpmem(),
+    ensure_lib_loaded(Config),
+
+    ?line Data = ?config(data_dir, Config),
+    ?line File = filename:join(Data, "nif_mod"),
+    ?line {ok,nif_mod,ModBin} = compile:file(File, [binary,return_errors]),
+    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
+
+    ?line ok = nif_mod:load_nif_lib(Config, 1, 
+				    [{resource_type, 0, ?RT_CREATE, "resource_type_A",resource_dtor_A,
+				      ?RT_CREATE},
+				     {resource_type, 1, ?RT_CREATE, "resource_type_null_A",null,
+				      ?RT_CREATE},
+				     {resource_type, 2, ?RT_CREATE bor ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
+				      ?RT_CREATE},
+				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
+				      ?RT_CREATE},
+				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneX",null,
+				      ?RT_CREATE},
+				     {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
+				      ?RT_TAKEOVER}
+				    ]),
+
+    ?line hold_nif_mod_priv_data(nif_mod:get_priv_data_ptr()),
+    ?line [{load,1,1,101},{get_priv_data_ptr,1,2,102}] = nif_mod_call_history(),
+
+    ?line {Holder, _MRef} = spawn_opt(fun resource_holder/0, [link, monitor]),
+
+    {A1,BinA1} = make_resource(0,Holder,"A1"),
+    {A2,BinA2} = make_resource(0,Holder,"A2"),
+    {A3,BinA3} = make_resource(0,Holder,"A3"),
+
+    {NA1,_BinNA1} = make_resource(1,Holder,"NA1"),
+    {NA2,BinNA2} = make_resource(1,Holder,"NA2"),
+    {NA3,_BinNA3} = make_resource(1,Holder,"NA3"),
+
+    {AN1,BinAN1} = make_resource(2,Holder,"AN1"),
+    {AN2,_BinAN2} = make_resource(2,Holder,"AN2"),
+    {AN3,BinAN3} = make_resource(2,Holder,"AN3"),
+
+    {BGX1,BinBGX1} = make_resource(3,Holder,"BGX1"),
+    {BGX2,BinBGX2} = make_resource(3,Holder,"BGX2"),
+
+    {NGX1,_BinNGX1} = make_resource(4,Holder,"NGX1"),
+    {NGX2,_BinNGX2} = make_resource(4,Holder,"NGX2"),
+
+    ?line [] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(A1),
+    ?line [{{resource_dtor_A_v1,BinA1},1,3,103}] = nif_mod_call_history(),    
+
+    ?line ok = forget_resource(NA1),
+    ?line [] = nif_mod_call_history(), % no dtor
+
+    ?line ok = forget_resource(AN1),
+    ?CHECK([{{resource_dtor_A_v1,BinAN1},1,4,104}] , nif_mod_call_history()),
+
+    ?line ok = forget_resource(BGX1),
+    ?CHECK([{{resource_dtor_B_v1,BinBGX1},1,5,105}], nif_mod_call_history()),
+
+    ?line ok = forget_resource(NGX1),
+    ?CHECK([], nif_mod_call_history()), % no dtor
+
+    ?line ok = nif_mod:load_nif_lib(Config, 2,
+				    [{resource_type, 0, ?RT_TAKEOVER, "resource_type_A",resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, 1, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, 2, ?RT_TAKEOVER, "resource_type_A_null",null,
+				      ?RT_TAKEOVER},
+				     {resource_type, null, ?RT_TAKEOVER, "Pink unicorn", resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, null, ?RT_CREATE, "resource_type_B_goneX",resource_dtor_B,
+				      ?RT_CREATE},
+				     {resource_type, null, ?RT_CREATE, "resource_type_null_goneX",null,
+				      ?RT_CREATE},
+				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneY",resource_dtor_B,
+				      ?RT_CREATE},
+				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneY",null,
+				      ?RT_CREATE}
+				    ]),
+    ?CHECK([{reload,2,1,201}], nif_mod_call_history()),
+
+    ?line BinA2 = read_resource(0,A2),
+    ?line ok = forget_resource(A2),
+    ?CHECK([{{resource_dtor_A_v2,BinA2},2,2,202}], nif_mod_call_history()),    
+
+    ?line ok = forget_resource(NA2),
+    ?CHECK([{{resource_dtor_A_v2,BinNA2},2,3,203}], nif_mod_call_history()),    
+
+    ?line ok = forget_resource(AN2),
+    ?CHECK([], nif_mod_call_history()),    % no dtor
+
+    ?line ok = forget_resource(BGX2),  % calling dtor in orphan library v1 still loaded
+    ?CHECK([{{resource_dtor_B_v1,BinBGX2},1,6,106}], nif_mod_call_history()),
+    % How to test that lib v1 is closed here?
+
+    ?line ok = forget_resource(NGX2),
+    ?CHECK([], nif_mod_call_history()),  % no dtor
+
+    {BGY1,BinBGY1} = make_resource(3,Holder,"BGY1"),
+    {NGY1,_BinNGY1} = make_resource(4,Holder,"NGY1"),
+
+    %% Module upgrade with same lib-version
+    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
+    ?line undefined = nif_mod:lib_version(),
+    ?line ok = nif_mod:load_nif_lib(Config, 2,
+				    [{resource_type, 2, ?RT_TAKEOVER, "resource_type_A",resource_dtor_B,
+				      ?RT_TAKEOVER},
+				     {resource_type, 0, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",null,
+				      ?RT_TAKEOVER},
+				     {resource_type, 1, ?RT_TAKEOVER, "resource_type_A_null",resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, null, ?RT_TAKEOVER, "Pink elephant", resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, 3, ?RT_CREATE, "resource_type_B_goneZ",resource_dtor_B,
+				      ?RT_CREATE},
+				     {resource_type, 4, ?RT_CREATE, "resource_type_null_goneZ",null,
+				      ?RT_CREATE}
+				    ]),
+
+    ?line 2 = nif_mod:lib_version(),
+    ?CHECK([{upgrade,2,4,204},{lib_version,2,5,205}], nif_mod_call_history()),
+
+    ?line ok = forget_resource(A3),
+    ?CHECK([{{resource_dtor_B_v2,BinA3},2,6,206}], nif_mod_call_history()),    
+
+    ?line ok = forget_resource(NA3),
+    ?CHECK([], nif_mod_call_history()),    
+
+    ?line ok = forget_resource(AN3),
+    ?CHECK([{{resource_dtor_A_v2,BinAN3},2,7,207}], nif_mod_call_history()),
+
+    {A4,BinA4} = make_resource(2,Holder, "A4"),
+    {NA4,BinNA4} = make_resource(0,Holder, "NA4"),
+    {AN4,_BinAN4} = make_resource(1,Holder, "AN4"),
+
+    {BGZ1,BinBGZ1} = make_resource(3,Holder,"BGZ1"),
+    {NGZ1,_BinNGZ1} = make_resource(4,Holder,"NGZ1"),
+
+    ?line false = code:purge(nif_mod),
+    ?line [] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(NGY1),
+    ?line [] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(BGY1),  % calling dtor in orphan library v2 still loaded
+    ?line [{{resource_dtor_B_v2,BinBGY1},2,8,208},{unload,2,9,209}] = nif_mod_call_history(),
+
+    %% Module upgrade with other lib-version
+    ?line {module,nif_mod} = erlang:load_module(nif_mod,ModBin),
+    ?line undefined = nif_mod:lib_version(),
+    ?line ok = nif_mod:load_nif_lib(Config, 1,
+				    [{resource_type, 2, ?RT_TAKEOVER, "resource_type_A",resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, 0, ?RT_TAKEOVER bor ?RT_CREATE, "resource_type_null_A",resource_dtor_A,
+				      ?RT_TAKEOVER},
+				     {resource_type, 1, ?RT_TAKEOVER, "resource_type_A_null",null,
+				      ?RT_TAKEOVER},
+				     {resource_type, null, ?RT_TAKEOVER, "Mr Pink", resource_dtor_A,
+				      ?RT_TAKEOVER}
+				    ]),
+
+    ?line 1 = nif_mod:lib_version(),
+    ?line [{upgrade,1,1,101},{lib_version,1,2,102}] = nif_mod_call_history(),
+
+    %%?line false= check_process_code(Pid, nif_mod),
+    ?line false = code:purge(nif_mod),
+    %% no unload here as we still have instances with destructors
+    ?line [] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(BGZ1),  % calling dtor in orphan library v2 still loaded
+    ?line [{{resource_dtor_B_v2,BinBGZ1},2,10,210},{unload,2,11,211}] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(NGZ1),
+    ?line [] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(A4),
+    ?line [{{resource_dtor_A_v1,BinA4},1,3,103}] = nif_mod_call_history(),
+
+    ?line ok = forget_resource(NA4),
+    ?line [{{resource_dtor_A_v1,BinNA4},1,4,104}] = nif_mod_call_history(),
 
+    ?line ok = forget_resource(AN4),
+    ?line [] = nif_mod_call_history(),
+
+    ?line [?MODULE, nif_mod] = erlang:system_info(taints),
+    ?line verify_tmpmem(TmpMem),    
+    ok.
+
+make_resource(Type,Holder,Str) when is_list(Str) ->
+    Bin = list_to_binary(Str),
+    A1 = make_resource_do(Type,Holder,Bin),
+    ?line Bin = read_resource(Type,A1),
+    {A1,Bin}.
+
+make_resource_do(Type, Holder, Bin) ->
+    Holder ! {self(), make, Type, Bin},
+    {Holder, make_ok, Id} = receive_any(),
+    {Holder,Id}.
+
+read_resource(Type, {Holder,Id}) ->
+    Holder ! {self(), get, Type, Id},
+    {Holder, get_ok, Bin} = receive_any(),
+    Bin.
+
+forget_resource({Holder,Id}) ->
+    Holder ! {self(), forget, Id},
+    {Holder, forget_ok, Id} = receive_any(),
+    ok.
+
+
+resource_holder() ->
+    resource_holder([]).
+resource_holder(List) ->
+    %%io:format("resource_holder waiting for msg\n", []),
+    Msg = receive_any(),
+    %%io:format("resource_holder got ~p with list = ~p\n", [Msg,List]),
+    case Msg of
+	{Pid, make, Type, Bin} ->	    
+	    ?line Resource = nif_mod:make_new_resource(Type, Bin),
+	    Id = {make_ref(),Bin},
+	    Pid ! {self(), make_ok, Id},
+	    resource_holder([{Id,Resource} | List]);
+	{Pid, get, Type, Id} ->
+	    {Id,Resource} = lists:keyfind(Id, 1, List),
+	    Pid ! {self(), get_ok, nif_mod:get_resource(Type, Resource)},
+	    resource_holder(List);
+	
+	{Pid, forget, Id} ->
+	    NewList = lists:keydelete(Id, 1, List),
+	    %%io:format("resource_holder forget: NewList = ~p\n", [NewList]),
+	    resource_holder(Pid, {self(),forget_ok,Id}, NewList)
+    end.
+
+resource_holder(Pid,Reply,List) ->
+    erlang:garbage_collect(),
+    %%io:format("resource_holder GC'ed, now send ~p to ~p\n", [Reply,Pid]),
+    Pid ! Reply,
+    resource_holder(List).
+
+
+threading(doc) -> ["Test the threading API functions (reuse tests from driver API)"];
+threading(Config) when is_list(Config) ->    
+    ?line Data = ?config(data_dir, Config),
+    ?line File = filename:join(Data, "tester"),
+    ?line {ok,tester,ModBin} = compile:file(File, [binary,return_errors]),
+    ?line {module,tester} = erlang:load_module(tester,ModBin),
+
+    ?line ok = tester:load_nif_lib(Config, "basic"),   
+    ?line ok = tester:run(),
+
+    ?line ok = tester:load_nif_lib(Config, "rwlock"),
+    ?line ok = tester:run(),
+
+    ?line ok = tester:load_nif_lib(Config, "tsd"),
+    ?line ok = tester:run().
+    
 neg(doc) -> ["Negative testing of load_nif"];
-neg(suite) -> [];
 neg(Config) when is_list(Config) ->
+    TmpMem = tmpmem(),
     ?line {'EXIT',{badarg,_}} = (catch erlang:load_nif(badarg, 0)),
     ?line {error,{load_failed,_}} = erlang:load_nif("pink_unicorn", 0),
     
@@ -247,23 +756,61 @@ neg(Config) when is_list(Config) ->
     ?line {module,nif_mod} = erlang:load_module(nif_mod,Bin),
 
     ?line {error,{bad_lib,_}} = nif_mod:load_nif_lib(Config, no_init),    
+    ?line verify_tmpmem(TmpMem),
     ?line ok.
 
 
 
 ensure_lib_loaded(Config) ->
     ensure_lib_loaded(Config, 1).
-
 ensure_lib_loaded(Config, Ver) ->
     ?line case lib_version() of
 	      undefined ->
 		  ?line Path = ?config(data_dir, Config),    
 		  ?line Lib = "nif_SUITE." ++ integer_to_list(Ver),
-		  ?line ok = erlang:load_nif(filename:join(Path,Lib), 0);
+		  ?line ok = erlang:load_nif(filename:join(Path,Lib), []);
 	      Ver when is_integer(Ver) ->
 		  ok
 	  end.
 
+tmpmem() ->
+    case erlang:system_info({allocator,temp_alloc}) of
+	false -> undefined;
+	MemInfo ->
+	    MSBCS = lists:foldl(
+		      fun ({instance, _, L}, Acc) ->
+			      {value,{_,MBCS}} = lists:keysearch(mbcs, 1, L),
+			      {value,{_,SBCS}} = lists:keysearch(sbcs, 1, L),
+			      [MBCS,SBCS | Acc]
+		      end,
+		      [],
+		      MemInfo),
+	    lists:foldl(
+	      fun(L, {Bl0,BlSz0}) ->
+		      {value,{_,Bl,_,_}} = lists:keysearch(blocks, 1, L),
+		      {value,{_,BlSz,_,_}} = lists:keysearch(blocks_size, 1, L),
+		      {Bl0+Bl,BlSz0+BlSz}
+	      end, {0,0}, MSBCS)
+    end.
+
+verify_tmpmem(MemInfo) ->
+    %%wait_for_test_procs(),
+    case tmpmem() of
+	MemInfo ->
+	    io:format("Tmp mem info: ~p", [MemInfo]),
+	    case MemInfo of
+		{notsup,undefined} ->
+		    %% Use 'erl +Mea max' to do more complete memory leak testing.
+		    {comment,"Incomplete or no mem leak testing"};
+		_ ->
+		    ok
+	    end;
+	Other ->
+	    io:format("Expected: ~p", [MemInfo]),
+	    io:format("Actual:   ~p", [Other]),
+	    ?t:fail()
+    end.
+
 call(Pid,Cmd) ->
     %%io:format("~p calling ~p with ~p\n",[self(), Pid, Cmd]),
     Pid ! {self(), Cmd},
@@ -274,6 +821,15 @@ call(Pid,Cmd) ->
 receive_any() ->
     receive M -> M end.	     
 
+%% check(Exp,Got,Line) ->
+%%     case Got of
+%% 	Exp -> Exp;	    
+%% 	_ ->
+%% 	    io:format("CHECK at ~p: Expected ~p but got ~p\n",[Line,Exp,Got]),
+%% 	    Got
+%%     end.
+	    
+
 %% The NIFs:
 lib_version() -> undefined.
 call_history() -> ?nif_stub.
@@ -285,6 +841,20 @@ tuple_2_list(_) -> ?nif_stub.
 is_identical(_,_) -> ?nif_stub.
 compare(_,_) -> ?nif_stub.
 many_args_100(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_) -> ?nif_stub.
-    
+clone_bin(_) -> ?nif_stub.
+make_sub_bin(_,_,_) -> ?nif_stub.
+string_to_bin(_,_) -> ?nif_stub.
+atom_to_bin(_,_) -> ?nif_stub.    
+macros(_) -> ?nif_stub.
+tuple_2_list_and_tuple(_) -> ?nif_stub.
+iolist_2_bin(_) -> ?nif_stub.
+get_resource_type(_) -> ?nif_stub.
+alloc_resource(_,_) -> ?nif_stub.
+make_resource(_) -> ?nif_stub.
+get_resource(_,_) -> ?nif_stub.
+release_resource(_) -> ?nif_stub.
+last_resource_dtor_call() -> ?nif_stub.
+make_new_resource(_,_) -> ?nif_stub.
+
 nif_stub_error(Line) ->
     exit({nif_not_loaded,module,?MODULE,line,Line}).
diff --git a/erts/emulator/test/nif_SUITE_data/Makefile.src b/erts/emulator/test/nif_SUITE_data/Makefile.src
index 6a8b4f1245..ab4ff77add 100644
--- a/erts/emulator/test/nif_SUITE_data/Makefile.src
+++ b/erts/emulator/test/nif_SUITE_data/Makefile.src
@@ -4,11 +4,22 @@ NIF_LIBS = nif_SUITE.1@dll@ \
            nif_mod.2@dll@ \
            nif_mod.3@dll@
 
-all: $(NIF_LIBS)
+all: $(NIF_LIBS) basic@dll@ rwlock@dll@ tsd@dll@
 
 
 @SHLIB_RULES@
 
 $(NIF_LIBS): nif_SUITE.c nif_mod.c nif_mod.h
 
+basic@dll@: tester.c testcase_driver.h
 
+rwlock@dll@: tester.c testcase_driver.h
+
+tsd@dll@: tester.c testcase_driver.h
+
+DRIVER_DIR = ../erl_drv_thread_SUITE_data
+
+basic.c rwlock.c tsd.c: $(DRIVER_DIR)/$@
+	cat head.txt > $@
+	cat $(DRIVER_DIR)/$@ | sed -e 's/erl_drv_/enif_/g' -e 's/driver_/enif_/g' -e 's/ErlDrv/ErlNif/g' >> $@
+	cat tail.txt >> $@
diff --git a/erts/emulator/test/nif_SUITE_data/head.txt b/erts/emulator/test/nif_SUITE_data/head.txt
new file mode 100644
index 0000000000..4b9b44276f
--- /dev/null
+++ b/erts/emulator/test/nif_SUITE_data/head.txt
@@ -0,0 +1,5 @@
+/* Do NOT edit this file!!!
+**
+** This is a NIF'ified COPY of the original in ../erl_drv_thread_SUITE_data/
+*/
+
diff --git a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
index 4532062dce..7d05a9a880 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_SUITE.c
@@ -15,6 +15,7 @@ typedef struct
     int ref_cnt;
     CallInfo* call_history;
     NifModPrivData* nif_mod;
+    union { ErlNifResourceType* t; long l; } rt_arr[2];
 }PrivData;
 
 void add_call(ErlNifEnv* env, PrivData* data, const char* func_name)
@@ -26,12 +27,29 @@ void add_call(ErlNifEnv* env, PrivData* data, const char* func_name)
     call->static_cntA = ++static_cntA;
     call->static_cntB = ++static_cntB;
     data->call_history = call;
+    call->arg = NULL;
+    call->arg_sz = 0;
 }
 
 #define ADD_CALL(FUNC_NAME) add_call(env, enif_get_data(env),FUNC_NAME)
 
+static void*    resource_dtor_last = NULL;
+static unsigned resource_dtor_last_sz = 0;
+static char     resource_dtor_last_data[20];
+static int resource_dtor_cnt = 0;
+
+static void resource_dtor(ErlNifEnv* env, void* obj)
+{
+    resource_dtor_last = obj;
+    resource_dtor_cnt++;
+    resource_dtor_last_sz = enif_sizeof_resource(env, obj);
+    assert(resource_dtor_last_sz <= sizeof(resource_dtor_last_data));
+    memcpy(resource_dtor_last_data, obj, resource_dtor_last_sz);
+}
+
 static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
+    /*ERL_NIF_TERM head, tail;*/
     PrivData* data = enif_alloc(env, sizeof(PrivData));
     assert(data != NULL);
     data->ref_cnt = 1;
@@ -39,7 +57,26 @@ static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
     data->nif_mod = NULL;
 
     add_call(env, data, "load");
-    
+
+    /*
+    head = load_info;
+    data->rt_cnt = 0;
+    for (head=load_info; enif_get_list_cell(env,load_info,&head,&tail);
+	  head=tail) {
+	char buf[20];
+	int n = enif_get_string(env,head,buf,sizeof(buf));
+	assert(n > 0);
+	assert(i < sizeof(data->rt_arr)/sizeof(*data->rt_arr));
+	data->rt_arr[data->rt_cnt++].t = enif_create_resource_type(env,buf,resource_dtor,
+								   ERL_NIF_RT_CREATE,NULL);	   
+    }
+    assert(enif_is_empty_list(env,head)); 
+    */
+    data->rt_arr[0].t = enif_open_resource_type(env,"Gold",resource_dtor,
+						ERL_NIF_RT_CREATE,NULL);
+    data->rt_arr[1].t = enif_open_resource_type(env,"Silver",resource_dtor,
+						ERL_NIF_RT_CREATE,NULL);
+
     *priv_data = data;
     return 0;
 }
@@ -80,11 +117,19 @@ static ERL_NIF_TERM make_call_history(ErlNifEnv* env, CallInfo** headp)
 
     while (*headp != NULL) {
 	CallInfo* call = *headp;
-	ERL_NIF_TERM tpl = enif_make_tuple(env, 4, 
-					   enif_make_atom(env,call->func_name),
-					   enif_make_int(env,call->lib_ver),
-					   enif_make_int(env,call->static_cntA),
-					   enif_make_int(env,call->static_cntB));
+	ERL_NIF_TERM func_term = enif_make_atom(env,call->func_name);
+	ERL_NIF_TERM tpl;
+	if (call->arg != NULL) {
+	    ErlNifBinary arg_bin;
+	    enif_alloc_binary(env, call->arg_sz, &arg_bin);
+	    memcpy(arg_bin.data, call->arg, call->arg_sz);
+	    func_term = enif_make_tuple2(env, func_term,
+					 enif_make_binary(env, &arg_bin));
+	}
+	tpl = enif_make_tuple4(env, func_term, 					    
+			       enif_make_int(env,call->lib_ver),
+			       enif_make_int(env,call->static_cntA),
+			       enif_make_int(env,call->static_cntB));
 	list = enif_make_list_cell(env, tpl, list);
 	*headp = call->next;
 	enif_free(env,call);
@@ -117,11 +162,14 @@ static ERL_NIF_TERM hold_nif_mod_priv_data(ErlNifEnv* env, int argc, const ERL_N
 static ERL_NIF_TERM nif_mod_call_history(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     PrivData* data = (PrivData*) enif_get_data(env);
-
+    ERL_NIF_TERM ret;
     if (data->nif_mod == NULL) {
-	return enif_make_string(env,"nif_mod pointer is NULL");
+	return enif_make_string(env,"nif_mod pointer is NULL", ERL_NIF_LATIN1);
     }
-    return make_call_history(env,&data->nif_mod->call_history);
+    enif_mutex_lock(data->nif_mod->mtx);
+    ret = make_call_history(env, &data->nif_mod->call_history);
+    enif_mutex_unlock(data->nif_mod->mtx);
+    return ret;
 }
 
 static ERL_NIF_TERM list_seq(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
@@ -150,12 +198,34 @@ static int test_int(ErlNifEnv* env, int i1)
     return 1;
 }
 
+static int test_uint(ErlNifEnv* env, unsigned i1)
+{
+    unsigned i2 = 0;
+    ERL_NIF_TERM int_term = enif_make_uint(env, i1);
+    if (!enif_get_uint(env,int_term, &i2) || i1 != i2) {
+	fprintf(stderr, "test_uint(%u) ...FAILED i2=%u\r\n", i1, i2);
+	return 0;
+    }
+    return 1;
+}
+
+static int test_long(ErlNifEnv* env, long i1)
+{
+    long i2 = 0;
+    ERL_NIF_TERM int_term = enif_make_long(env, i1);
+    if (!enif_get_long(env,int_term, &i2) || i1 != i2) {
+	fprintf(stderr, "test_long(%ld) ...FAILED i2=%ld\r\n", i1, i2);
+	return 0;
+    }
+    return 1;
+}
+
 static int test_ulong(ErlNifEnv* env, unsigned long i1)
 {
     unsigned long i2 = 0;
     ERL_NIF_TERM int_term = enif_make_ulong(env, i1);
     if (!enif_get_ulong(env,int_term, &i2) || i1 != i2) {
-	fprintf(stderr, "SVERK: test_ulong(%lu) ...FAILED i2=%lu\r\n", i1, i2);
+	fprintf(stderr, "test_ulong(%lu) ...FAILED i2=%lu\r\n", i1, i2);
 	return 0;
     }
     return 1;
@@ -166,7 +236,7 @@ static int test_double(ErlNifEnv* env, double d1)
     double d2 = 0;
     ERL_NIF_TERM term = enif_make_double(env, d1);
     if (!enif_get_double(env,term, &d2) || d1 != d2) {
-	fprintf(stderr, "SVERK: test_double(%e) ...FAILED i2=%e\r\n", d1, d2);
+	fprintf(stderr, "test_double(%e) ...FAILED i2=%e\r\n", d1, d2);
 	return 0;
     }
     return 1;
@@ -180,32 +250,59 @@ static int test_double(ErlNifEnv* env, double d1)
 static ERL_NIF_TERM type_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     int i;
-    unsigned long u;
+    int sint;
+    unsigned uint;
+    long slong;
+    unsigned long ulong;
     double d;
     ERL_NIF_TERM atom, ref1, ref2;
 
-    i = INT_MIN;
+    sint = INT_MIN;
     do {
-	if (!test_int(env,i)) {
+	if (!test_int(env,sint)) {
 	    goto error;
 	}
-	i += ~i / 3 + 1;
-    } while (i < 0);
-    i = INT_MAX;
+	sint += ~sint / 3 + 1;
+    } while (sint < 0);
+    sint = INT_MAX;
     do {
-	if (!test_int(env,i)) {
+	if (!test_int(env,sint)) {
 	    goto error;
 	}
-	i -= i / 3 + 1;
-    } while (i >= 0);
+	sint -= sint / 3 + 1;
+    } while (sint >= 0);
 
-    u = ULONG_MAX;
+    slong = LONG_MIN;
+    do {
+	if (!test_long(env,slong)) {
+	    goto error;
+	}
+	slong += ~slong / 3 + 1;
+    } while (slong < 0);
+    slong = LONG_MAX;
+    do {
+	if (!test_long(env,slong)) {
+	    goto error;
+	}
+	slong -= slong / 3 + 1;
+    } while (slong >= 0);
+
+
+    uint = UINT_MAX;
     for (;;) {
-	if (!test_ulong(env,u)) {
+	if (!test_uint(env,uint)) {
 	    
 	}
-	if (u == 0) break;
-	u -= u / 3 + 1;
+	if (uint == 0) break;
+	uint -= uint / 3 + 1;
+    }
+    ulong = ULONG_MAX;
+    for (;;) {
+	if (!test_ulong(env,ulong)) {
+	    
+	}
+	if (ulong == 0) break;
+	ulong -= ulong / 3 + 1;
     }    
 
     if (MAX_SMALL < INT_MAX) { /* 32-bit */
@@ -219,11 +316,17 @@ static ERL_NIF_TERM type_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
 		goto error;
 	    }
 	}
+	for (i=-10 ; i <= 10; i++) {
+	    if (!test_uint(env,MAX_SMALL+i)) {
+		goto error;
+	    }
+	}
     }
     assert((MAX_SMALL < INT_MAX) == (MIN_SMALL > INT_MIN));
 
-    for (u=0 ; u < 10; u++) {
-	if (!test_ulong(env,MAX_SMALL+u) || !test_ulong(env,MAX_SMALL-u)) {
+    for (i=-10 ; i < 10; i++) {
+	if (!test_long(env,MAX_SMALL+i) || !test_ulong(env,MAX_SMALL+i) ||
+	    !test_long(env,MIN_SMALL+i)) {
 	    goto error;
 	}
     }
@@ -236,12 +339,12 @@ static ERL_NIF_TERM type_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
 
     if (!enif_make_existing_atom(env,"nif_SUITE", &atom)
 	|| !enif_is_identical(env,atom,enif_make_atom(env,"nif_SUITE"))) {
-	fprintf(stderr, "SVERK: nif_SUITE not an atom?\r\n");
+	fprintf(stderr, "nif_SUITE not an atom?\r\n");
 	goto error;
     }
     for (i=2; i; i--) {
 	if (enif_make_existing_atom(env,"nif_SUITE_pink_unicorn", &atom)) {
-	    fprintf(stderr, "SVERK: pink unicorn exist?\r\n");
+	    fprintf(stderr, "pink unicorn exist?\r\n");
 	    goto error;
 	}
     }
@@ -249,7 +352,8 @@ static ERL_NIF_TERM type_test(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[
     ref2 = enif_make_ref(env);
     if (!enif_is_ref(env,ref1) || !enif_is_ref(env,ref2) 
 	|| enif_is_identical(env,ref1,ref2) || enif_compare(env,ref1,ref2)==0) {
-	fprintf(stderr, "SVERK: strange refs?\r\n");
+	fprintf(stderr, "strange refs?\r\n");
+	goto error;
     }
     return enif_make_atom(env,"ok");
 
@@ -260,7 +364,7 @@ error:
 static ERL_NIF_TERM tuple_2_list(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     int arity = -1;
-    ERL_NIF_TERM* ptr;
+    const ERL_NIF_TERM* ptr;
     ERL_NIF_TERM list = enif_make_list(env,0);
 
     if (argc!=1 || !enif_get_tuple(env,argv[0],&arity,&ptr)) {
@@ -304,6 +408,213 @@ badarg:
     return enif_make_badarg(env);
 }
 
+static ERL_NIF_TERM clone_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary ibin;
+    if (enif_inspect_binary(env,argv[0],&ibin)) {
+	ErlNifBinary obin;
+	enif_alloc_binary(env,ibin.size,&obin);
+	memcpy(obin.data,ibin.data,ibin.size);
+	/*enif_release_binary(env,&ibin);*/
+	return enif_make_binary(env,&obin);
+    }
+    else {
+	return enif_make_badarg(env);
+    }
+}
+
+static ERL_NIF_TERM make_sub_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    int pos, size;
+    if (!enif_get_int(env,argv[1],&pos) || !enif_get_int(env,argv[2],&size)) {
+	return enif_make_badarg(env);
+    }
+    return enif_make_sub_binary(env,argv[0],pos,size);
+}
+
+static ERL_NIF_TERM string_to_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary obin;
+    unsigned size;
+    int n;
+    if (!enif_get_int(env,argv[1],(int*)&size) 
+	|| !enif_alloc_binary(env,size,&obin)) {
+	return enif_make_badarg(env);
+    }
+    n = enif_get_string(env, argv[0], (char*)obin.data, size, ERL_NIF_LATIN1);
+    return enif_make_tuple(env, 2, enif_make_int(env,n),
+			   enif_make_binary(env,&obin));
+}
+
+static ERL_NIF_TERM atom_to_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary obin;
+    unsigned size;
+    int n;
+    if (!enif_get_int(env,argv[1],(int*)&size) 
+	|| !enif_alloc_binary(env,size,&obin)) {
+	return enif_make_badarg(env);
+    }
+    n = enif_get_atom(env, argv[0], (char*)obin.data, size);
+    return enif_make_tuple(env, 2, enif_make_int(env,n),
+			   enif_make_binary(env,&obin));
+}
+
+static ERL_NIF_TERM macros(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    const ERL_NIF_TERM* a;
+    ERL_NIF_TERM lists, tuples;
+    int arity;
+    if (!enif_get_tuple(env, argv[0], &arity, &a) || arity != 9) {
+	return enif_make_badarg(env);
+    }
+    
+    lists = enif_make_list(env,9,
+			   enif_make_list1(env,a[0]),
+			   enif_make_list2(env,a[0],a[1]),
+			   enif_make_list3(env,a[0],a[1],a[2]),
+			   enif_make_list4(env,a[0],a[1],a[2],a[3]),
+			   enif_make_list5(env,a[0],a[1],a[2],a[3],a[4]),
+			   enif_make_list6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
+			   enif_make_list7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
+			   enif_make_list8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
+			   enif_make_list9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
+    tuples = enif_make_list(env,9,
+			    enif_make_tuple1(env,a[0]),
+			    enif_make_tuple2(env,a[0],a[1]),
+			    enif_make_tuple3(env,a[0],a[1],a[2]),
+			    enif_make_tuple4(env,a[0],a[1],a[2],a[3]),
+			    enif_make_tuple5(env,a[0],a[1],a[2],a[3],a[4]),
+			    enif_make_tuple6(env,a[0],a[1],a[2],a[3],a[4],a[5]),
+			    enif_make_tuple7(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6]),
+			    enif_make_tuple8(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]),
+			    enif_make_tuple9(env,a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8]));
+    return enif_make_tuple2(env,lists,tuples);
+}
+
+static ERL_NIF_TERM tuple_2_list_and_tuple(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    const ERL_NIF_TERM* arr;
+    int arity;
+    if (!enif_get_tuple(env,argv[0],&arity,&arr)) {
+	return enif_make_badarg(env);
+    }
+    return enif_make_tuple2(env, 
+			    enif_make_list_from_array(env, arr, arity),
+			    enif_make_tuple_from_array(env, arr, arity));
+}
+
+static ERL_NIF_TERM iolist_2_bin(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary obin;
+    if (!enif_inspect_iolist_as_binary(env, argv[0], &obin)) {
+	return enif_make_badarg(env);
+    }
+    return enif_make_binary(env,&obin);
+}
+
+static ERL_NIF_TERM last_resource_dtor_call(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary bin;
+    ERL_NIF_TERM ret;
+    if (resource_dtor_last != NULL) {
+	enif_alloc_binary(env, resource_dtor_last_sz, &bin);
+	memcpy(bin.data, resource_dtor_last_data, resource_dtor_last_sz);
+	ret = enif_make_tuple3(env,
+				enif_make_long(env, (long)resource_dtor_last),
+				enif_make_binary(env, &bin),  
+				enif_make_int(env, resource_dtor_cnt));
+    }
+    else {
+	ret = enif_make_list(env,0);
+    }
+    resource_dtor_last = NULL;
+    resource_dtor_last_sz = 0;
+    resource_dtor_cnt = 0;
+    return ret;
+}
+
+static ERL_NIF_TERM get_resource_type(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    PrivData* data = (PrivData*) enif_get_data(env);
+    int ix;
+    
+    if (!enif_get_int(env, argv[0], &ix) || ix >= 2) {
+	return enif_make_badarg(env);
+    }
+    return enif_make_long(env, data->rt_arr[ix].l);
+}
+
+static ERL_NIF_TERM alloc_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary data_bin;
+    union { ErlNifResourceType* t; long l;} type;
+    union { void* p; long l;} data;
+    if (!enif_get_long(env, argv[0], &type.l)
+	|| !enif_inspect_binary(env, argv[1], &data_bin)
+	|| (data.p = enif_alloc_resource(env, type.t, data_bin.size))==NULL) {
+
+	return enif_make_badarg(env);
+    }
+    memcpy(data.p, data_bin.data, data_bin.size);
+    return enif_make_long(env, data.l);
+}
+
+static ERL_NIF_TERM make_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    union { void* p; long l; } data;
+    if (!enif_get_long(env, argv[0], &data.l)) {
+	return enif_make_badarg(env);
+    }
+    return enif_make_resource(env, data.p);
+}
+
+static ERL_NIF_TERM make_new_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary data_bin;
+    union { ErlNifResourceType* t; long l;} type;
+    void* data;
+    ERL_NIF_TERM ret;
+    if (!enif_get_long(env, argv[0], &type.l)
+	|| !enif_inspect_binary(env, argv[1], &data_bin)
+	|| (data = enif_alloc_resource(env, type.t, data_bin.size))==NULL) {
+
+	return enif_make_badarg(env);
+    }
+    ret = enif_make_resource(env, data);
+    memcpy(data, data_bin.data, data_bin.size);
+    enif_release_resource(env, data);
+    return ret;
+}
+
+static ERL_NIF_TERM get_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    ErlNifBinary data_bin;
+    union { ErlNifResourceType* t; long l; } type;
+    union { void* p; long l; } data;
+
+    if (!enif_get_long(env, argv[0], &type.l)
+	|| !enif_get_resource(env, argv[1], type.t, &data.p)) {
+	return enif_make_badarg(env);
+    }
+
+    enif_alloc_binary(env, enif_sizeof_resource(env,data.p), &data_bin);    
+    memcpy(data_bin.data, data.p, data_bin.size);
+    return enif_make_tuple2(env, enif_make_long(env,data.l),
+			    enif_make_binary(env, &data_bin));
+}
+
+static ERL_NIF_TERM release_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    union { void* p; long l; } data;
+    if (!enif_get_long(env, argv[0], &data.l)) {
+	return enif_make_badarg(env);
+    }
+    enif_release_resource(env, data.p);
+    return enif_make_atom(env,"ok");
+}
+
+
 static ErlNifFunc nif_funcs[] =
 {
     {"lib_version", 0, lib_version},
@@ -315,7 +626,22 @@ static ErlNifFunc nif_funcs[] =
     {"tuple_2_list", 1, tuple_2_list},
     {"is_identical",2,is_identical},
     {"compare",2,compare},
-    {"many_args_100", 100, many_args_100}
+    {"many_args_100", 100, many_args_100},
+    {"clone_bin", 1, clone_bin},
+    {"make_sub_bin", 3, make_sub_bin},
+    {"string_to_bin", 2, string_to_bin},
+    {"atom_to_bin", 2, atom_to_bin},
+    {"macros", 1, macros},
+    {"tuple_2_list_and_tuple",1,tuple_2_list_and_tuple},
+    {"iolist_2_bin", 1, iolist_2_bin},
+    {"get_resource_type", 1, get_resource_type},
+    {"alloc_resource", 2, alloc_resource},
+    {"make_resource", 1, make_resource},
+    {"get_resource", 2, get_resource},
+    {"release_resource", 1, release_resource},
+    {"last_resource_dtor_call", 0, last_resource_dtor_call},
+    {"make_new_resource", 2, make_new_resource}
+
 };
 
 ERL_NIF_INIT(nif_SUITE,nif_funcs,load,reload,upgrade,unload)
diff --git a/erts/emulator/test/nif_SUITE_data/nif_mod.c b/erts/emulator/test/nif_SUITE_data/nif_mod.c
index 2f2267cf78..c075b74c57 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_mod.c
+++ b/erts/emulator/test/nif_SUITE_data/nif_mod.c
@@ -1,51 +1,182 @@
 #include "erl_nif.h"
 #include <string.h>
-#include <assert.h>
+#include <stdio.h>
 
 #include "nif_mod.h"
 
+#define CHECK(X) ((void)((X) || (check_abort(__LINE__),1)))
+#ifdef __GNUC__
+static void check_abort(unsigned line) __attribute__((noreturn));
+#endif
+static void check_abort(unsigned line)
+{
+    enif_fprintf(stderr, "Test CHECK failed at %s:%u\r\n",
+	    __FILE__, line);
+    abort();
+}
 
 static int static_cntA; /* zero by default */
 static int static_cntB = NIF_LIB_VER * 100;
 
-static void add_call(ErlNifEnv* env, NifModPrivData* data, const char* func_name)
+static ERL_NIF_TERM am_true;
+static ERL_NIF_TERM am_null;
+static ERL_NIF_TERM am_resource_type;
+static ERL_NIF_TERM am_resource_dtor_A;
+static ERL_NIF_TERM am_resource_dtor_B;
+
+static void init(ErlNifEnv* env)
+{
+    am_true = enif_make_atom(env, "true");
+    am_null = enif_make_atom(env, "null");
+    am_resource_type = enif_make_atom(env, "resource_type");
+    am_resource_dtor_A = enif_make_atom(env, "resource_dtor_A");
+    am_resource_dtor_B = enif_make_atom(env, "resource_dtor_B");
+}
+
+static void add_call_with_arg(ErlNifEnv* env, NifModPrivData* data, const char* func_name,
+			      const char* arg, int arg_sz)
 {
-    CallInfo* call = enif_alloc(env, sizeof(CallInfo)+strlen(func_name));
+    CallInfo* call = enif_alloc(env, sizeof(CallInfo)+strlen(func_name) + arg_sz);
     strcpy(call->func_name, func_name);
     call->lib_ver = NIF_LIB_VER;
     call->static_cntA = ++static_cntA;
     call->static_cntB = ++static_cntB;
+    call->arg_sz = arg_sz;
+    if (arg != NULL) {
+	call->arg = call->func_name + strlen(func_name) + 1;
+	memcpy(call->arg, arg, arg_sz);
+    }
+    else {
+	call->arg = NULL;
+    }
+    enif_mutex_lock(data->mtx);
     call->next = data->call_history;
     data->call_history = call;
+    enif_mutex_unlock(data->mtx);
+}
+
+static void add_call(ErlNifEnv* env, NifModPrivData* data,const char* func_name)
+{
+    add_call_with_arg(env, data, func_name, NULL, 0);
+}
+
+#define ADD_CALL(FUNC_NAME) add_call(env, enif_priv_data(env),FUNC_NAME)
+
+#define STRINGIFY_(X) #X
+#define STRINGIFY(X) STRINGIFY_(X)
+
+static void resource_dtor_A(ErlNifEnv* env, void* a)
+{
+    const char dtor_name[] = "resource_dtor_A_v"  STRINGIFY(NIF_LIB_VER); 
+
+    add_call_with_arg(env, enif_priv_data(env), dtor_name,
+		      a, enif_sizeof_resource(env, a));
+}
+
+static void resource_dtor_B(ErlNifEnv* env, void* a)
+{
+    const char dtor_name[] = "resource_dtor_B_v"  STRINGIFY(NIF_LIB_VER); 
+
+    add_call_with_arg(env, enif_priv_data(env), dtor_name,
+		      a, enif_sizeof_resource(env, a));
+}
+
+/* {resource_type, Ix|null, ErlNifResourceFlags in, "TypeName", dtor(A|B|null), ErlNifResourceFlags out}*/
+static void open_resource_type(ErlNifEnv* env, ERL_NIF_TERM op_tpl)
+{
+    NifModPrivData* data = enif_priv_data(env);
+    const ERL_NIF_TERM* arr;
+    int arity;
+    char rt_name[30];
+    union { enum ErlNifResourceFlags e; int i; } flags, exp_res, got_res;
+    unsigned ix;
+    ErlNifResourceDtor* dtor;
+    ErlNifResourceType* got_ptr;
+
+    CHECK(enif_get_tuple(env, op_tpl, &arity, &arr));
+    CHECK(arity == 6);
+    CHECK(enif_is_identical(env, arr[0], am_resource_type));
+    CHECK(enif_get_int(env, arr[2], &flags.i));
+    CHECK(enif_get_string(env, arr[3], rt_name, sizeof(rt_name), ERL_NIF_LATIN1) > 0);
+    CHECK(enif_get_int(env, arr[5], &exp_res.i));
+	
+    if (enif_is_identical(env, arr[4], am_null)) {
+	dtor = NULL;
+    }
+    else if (enif_is_identical(env, arr[4], am_resource_dtor_A)) {
+	dtor = resource_dtor_A;
+    }
+    else {
+	CHECK(enif_is_identical(env, arr[4], am_resource_dtor_B));
+	dtor = resource_dtor_B;
+    }
+
+    got_ptr = enif_open_resource_type(env, rt_name, dtor,
+				      flags.e, &got_res.e);
+
+    if (enif_get_uint(env, arr[1], &ix) && ix < RT_MAX && got_ptr != NULL) {
+	data->rt_arr[ix] = got_ptr;
+    }
+    else {
+	CHECK(enif_is_identical(env, arr[1], am_null));
+	CHECK(got_ptr == NULL);
+    }
+    CHECK(got_res.e == exp_res.e);
 }
 
-#define ADD_CALL(FUNC_NAME) add_call(env, enif_get_data(env),FUNC_NAME)
+static void do_load_info(ErlNifEnv* env, ERL_NIF_TERM load_info)
+{
+    NifModPrivData* data = enif_priv_data(env);
+    ERL_NIF_TERM head, tail;
+    unsigned ix;
+    for (ix=0; ix<RT_MAX; ix++) {
+	data->rt_arr[ix] = NULL;
+    }
+    for (head = load_info; enif_get_list_cell(env, head, &head, &tail);
+	  head = tail) {
+
+	open_resource_type(env, head);	
+    }    
+    CHECK(enif_is_empty_list(env, head));
+}
 
 static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
-    NifModPrivData* data = enif_alloc(env, sizeof(NifModPrivData));
-    assert(data != NULL);
+    NifModPrivData* data;
+
+    init(env);
+    data = enif_alloc(env, sizeof(NifModPrivData));
+    CHECK(data != NULL);
+    *priv_data = data;
+    data->mtx = enif_mutex_create("nif_mod_priv_data"); 
     data->ref_cnt = 1;
     data->call_history = NULL;
     add_call(env, data, "load");
 
-    data->calls = 0;
-    *priv_data = data;
+    do_load_info(env, load_info);
+    data->calls = 0;    
     return 0;
 }
 
 static int reload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
+    init(env);
     add_call(env, *priv_data, "reload");
+    
+    do_load_info(env, load_info);
     return 0;
 }
 
 static int upgrade(ErlNifEnv* env, void** priv_data, void** old_priv_data, ERL_NIF_TERM load_info)
 {
     NifModPrivData* data = *old_priv_data;
+    init(env);
     add_call(env, data, "upgrade");
     data->ref_cnt++;
+
     *priv_data = *old_priv_data;    
+    do_load_info(env, load_info);
+    
     return 0;
 }
 
@@ -53,9 +184,13 @@ static void unload(ErlNifEnv* env, void* priv_data)
 {
     NifModPrivData* data = priv_data;
     add_call(env, data, "unload");
+    enif_mutex_lock(data->mtx);
     if (--data->ref_cnt == 0) {
+	enif_mutex_unlock(data->mtx);
+	enif_mutex_destroy(data->mtx);
 	enif_free(env, data);
     }
+    enif_mutex_unlock(data->mtx);
 }
 
 static ERL_NIF_TERM lib_version(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
@@ -64,35 +199,51 @@ static ERL_NIF_TERM lib_version(ErlNifEnv* env, int argc, const ERL_NIF_TERM arg
     return enif_make_int(env, NIF_LIB_VER);
 }
 
-static ERL_NIF_TERM call_history(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM get_priv_data_ptr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    NifModPrivData* data = (NifModPrivData*) enif_get_data(env);
-    ERL_NIF_TERM list = enif_make_list(env, 0); /* NIL */
+    ADD_CALL("get_priv_data_ptr");
+    return enif_make_ulong(env, (unsigned long)enif_priv_data(env));
+}
 
-    while (data->call_history != NULL) {
-	CallInfo* call = data->call_history;
-	ERL_NIF_TERM tpl = enif_make_tuple(env, 2, 
-					   enif_make_atom(env,call->func_name),
-					   enif_make_int(env,call->lib_ver));
-	list = enif_make_list_cell(env, tpl, list);
-	data->call_history = call->next;
-	enif_free(env,call);
+static ERL_NIF_TERM make_new_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    NifModPrivData* data = (NifModPrivData*) enif_priv_data(env);
+    ErlNifBinary ibin;
+    char* a;
+    ERL_NIF_TERM ret;
+    unsigned ix;
+    if (!enif_get_uint(env, argv[0], &ix) || ix >= RT_MAX 
+	|| !enif_inspect_binary(env, argv[1], &ibin)) {
+	return enif_make_badarg(env);
     }
-    return list;
+    a = enif_alloc_resource(env, data->rt_arr[ix], ibin.size);
+    memcpy(a, ibin.data, ibin.size);
+    ret = enif_make_resource(env, a);
+    enif_release_resource(env, a);
+    return ret;
 }
 
-static ERL_NIF_TERM get_priv_data_ptr(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+static ERL_NIF_TERM get_resource(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    ADD_CALL("get_priv_data_ptr");
-    return enif_make_ulong(env, (unsigned long)enif_get_data(env));
+    NifModPrivData* data = (NifModPrivData*) enif_priv_data(env);
+    ErlNifBinary obin;
+    unsigned ix;
+    void* a;
+    if (!enif_get_uint(env, argv[0], &ix) || ix >= RT_MAX 
+	|| !enif_get_resource(env, argv[1], data->rt_arr[ix], &a)
+	|| !enif_alloc_binary(env, enif_sizeof_resource(env, a), &obin)) { 
+	return enif_make_badarg(env);
+    }
+    memcpy(obin.data, a, obin.size);
+    return enif_make_binary(env, &obin);
 }
 
-
 static ErlNifFunc nif_funcs[] =
 {
     {"lib_version", 0, lib_version},
-    {"call_history", 0, call_history},
-    {"get_priv_data_ptr", 0, get_priv_data_ptr}
+    {"get_priv_data_ptr", 0, get_priv_data_ptr},
+    {"make_new_resource", 2, make_new_resource},
+    {"get_resource", 2, get_resource}
 };
 
 #if NIF_LIB_VER != 3
diff --git a/erts/emulator/test/nif_SUITE_data/nif_mod.erl b/erts/emulator/test/nif_SUITE_data/nif_mod.erl
index 93da6590a0..7888a589e7 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_mod.erl
+++ b/erts/emulator/test/nif_SUITE_data/nif_mod.erl
@@ -21,15 +21,19 @@
 
 -include("test_server.hrl").
 
--export([load_nif_lib/2, start/0, lib_version/0, call_history/0, get_priv_data_ptr/0]).
+-export([load_nif_lib/2, load_nif_lib/3, start/0, lib_version/0, call_history/0,
+	 get_priv_data_ptr/0, make_new_resource/2, get_resource/2]).
 
 -export([loop/0, upgrade/1]).
 
 -define(nif_stub,nif_stub_error(?LINE)).
 
 load_nif_lib(Config, Ver) ->
+    load_nif_lib(Config, Ver, []).
+
+load_nif_lib(Config, Ver, LoadInfo) ->
     ?line Path = ?config(data_dir, Config),    
-    erlang:load_nif(filename:join(Path,libname(Ver)), 0).
+    erlang:load_nif(filename:join(Path,libname(Ver)), LoadInfo).
 
 libname(no_init) -> libname(3);
 libname(Ver) when is_integer(Ver) ->
@@ -59,6 +63,8 @@ lib_version() ->  % NIF
 
 call_history() -> ?nif_stub.    
 get_priv_data_ptr() -> ?nif_stub.
+make_new_resource(_,_) -> ?nif_stub.
+get_resource(_,_) -> ?nif_stub.
 
 nif_stub_error(Line) ->
     exit({nif_not_loaded,module,?MODULE,line,Line}).
diff --git a/erts/emulator/test/nif_SUITE_data/nif_mod.h b/erts/emulator/test/nif_SUITE_data/nif_mod.h
index 2dfdc75176..0eaf91d6e1 100644
--- a/erts/emulator/test/nif_SUITE_data/nif_mod.h
+++ b/erts/emulator/test/nif_SUITE_data/nif_mod.h
@@ -4,14 +4,19 @@ typedef struct call_info_t
     unsigned lib_ver;
     int static_cntA;
     int static_cntB;
+    char* arg;
+    int arg_sz;
     char func_name[1]; /* must be last */
 }CallInfo;
 
+#define RT_MAX 5
 
 typedef struct
 {
+    ErlNifMutex* mtx;
     int calls;
     int ref_cnt;
     CallInfo* call_history;
+    ErlNifResourceType* rt_arr[RT_MAX];
 }NifModPrivData;
 
diff --git a/erts/emulator/test/nif_SUITE_data/tail.txt b/erts/emulator/test/nif_SUITE_data/tail.txt
new file mode 100644
index 0000000000..7f06c118c1
--- /dev/null
+++ b/erts/emulator/test/nif_SUITE_data/tail.txt
@@ -0,0 +1,5 @@
+
+
+#include "tester.c"   /* poor mans linker */
+
+
diff --git a/erts/emulator/test/nif_SUITE_data/testcase_driver.h b/erts/emulator/test/nif_SUITE_data/testcase_driver.h
new file mode 100644
index 0000000000..98339e4746
--- /dev/null
+++ b/erts/emulator/test/nif_SUITE_data/testcase_driver.h
@@ -0,0 +1,59 @@
+/* ``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 via the world wide web 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.
+ * 
+ * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+ * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+ * AB. All Rights Reserved.''
+ * 
+ *     $Id$
+ */
+
+#ifndef TESTCASE_DRIVER_H__
+#define TESTCASE_DRIVER_H__
+
+#include "erl_nif.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+typedef struct {
+    char *testcase_name;
+    char *command;
+    int command_len;
+    void *extra;
+} TestCaseState_t;
+
+#define ASSERT_CLNUP(TCS, B, CLN)					\
+do {									\
+    if (!(B)) {								\
+	CLN;								\
+	testcase_assertion_failed((TCS), __FILE__, __LINE__, #B);	\
+    }									\
+} while (0)
+
+#define ASSERT(TCS, B) ASSERT_CLNUP(TCS, B, (void) 0)
+
+
+void testcase_printf(TestCaseState_t *tcs, char *frmt, ...);
+void testcase_succeeded(TestCaseState_t *tcs, char *frmt, ...);
+void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...);
+void testcase_failed(TestCaseState_t *tcs, char *frmt, ...);
+int testcase_assertion_failed(TestCaseState_t *tcs, char *file, int line,
+			      char *assertion);
+void *testcase_alloc(size_t size);
+void *testcase_realloc(void *ptr, size_t size);
+void testcase_free(void *ptr);
+
+
+char *testcase_name(void);
+void testcase_run(TestCaseState_t *tcs);
+void testcase_cleanup(TestCaseState_t *tcs);
+
+#endif
diff --git a/erts/emulator/test/nif_SUITE_data/tester.c b/erts/emulator/test/nif_SUITE_data/tester.c
new file mode 100644
index 0000000000..08466d0f18
--- /dev/null
+++ b/erts/emulator/test/nif_SUITE_data/tester.c
@@ -0,0 +1,73 @@
+#include "erl_nif.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+void testcase_printf(TestCaseState_t *tcs, char *frmt, ...)
+{
+    va_list va;
+    va_start(va, frmt);
+    vfprintf(stderr, frmt, va);
+    va_end(va);
+    fprintf(stderr, "\r");
+}
+
+void testcase_succeeded(TestCaseState_t *tcs, char *frmt, ...)
+{
+}
+
+void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...)
+{
+}
+
+void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
+{
+    va_list va;
+    va_start(va, frmt);
+    vfprintf(stderr, frmt, va);
+    va_end(va);
+    abort();
+}
+
+int testcase_assertion_failed(TestCaseState_t *tcs, char *file, int line,
+                              char *assertion)
+{
+    testcase_failed(tcs, "ASSERTION '%s' FAILED at %s:%d\r\n",
+		    assertion, file, line);
+    abort();
+    return 0; /*?*/
+}
+
+void *testcase_alloc(size_t size)
+{
+    return malloc(size);
+}
+void *testcase_realloc(void *ptr, size_t size)
+{
+    return realloc(ptr, size);
+}
+void testcase_free(void *ptr)
+{
+    free(ptr);
+}
+
+void testcase_run(TestCaseState_t *tcs);
+
+static int reload(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
+{
+    return 0;
+}
+
+static ERL_NIF_TERM run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{
+    testcase_run(NULL);
+    return enif_make_atom(env, "ok");
+}
+
+static ErlNifFunc nif_funcs[] =
+{
+    {"run", 0, run}
+};
+
+ERL_NIF_INIT(tester,nif_funcs,NULL,reload,NULL,NULL)
+
diff --git a/erts/emulator/test/nif_SUITE_data/tester.erl b/erts/emulator/test/nif_SUITE_data/tester.erl
new file mode 100644
index 0000000000..9df2158200
--- /dev/null
+++ b/erts/emulator/test/nif_SUITE_data/tester.erl
@@ -0,0 +1,13 @@
+-module(tester).
+
+-include("test_server.hrl").
+
+-export([load_nif_lib/2, run/0]).
+
+
+load_nif_lib(Config, LibName) ->
+    ?line Path = ?config(data_dir, Config),    
+    erlang:load_nif(filename:join(Path,LibName), []).
+
+run() ->
+    exit({nif_not_loaded,?MODULE,?LINE}).