emulator test drivers: Conform to updated driver API

27 files changed, 386 insertions, 190 deletions

diff --git a/erts/emulator/test/a_SUITE_data/timer_driver.c b/erts/emulator/test/a_SUITE_data/timer_driver.c
index ef4dcdf501..44be94e0f0 100644
--- a/erts/emulator/test/a_SUITE_data/timer_driver.c
+++ b/erts/emulator/test/a_SUITE_data/timer_driver.c
@@ -17,7 +17,9 @@
 #define CANCELLED 4
 
 static ErlDrvData timer_start(ErlDrvPort, char*);
-static void timer_stop(ErlDrvData), timer_read(ErlDrvData, char*, int), timer(ErlDrvData);
+static void timer_stop(ErlDrvData),
+    timer_read(ErlDrvData, char*, ErlDrvSizeT),
+    timer(ErlDrvData);
 
 static ErlDrvEntry timer_driver_entry =
 {
@@ -33,6 +35,16 @@ static ErlDrvEntry timer_driver_entry =
     NULL,
     timer,
     NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -47,8 +59,9 @@ static ErlDrvData timer_start(ErlDrvPort port, char *buf)
 }
 
 /* set the timer, this is monitored from erlang measuring the time */
-static void timer_read(ErlDrvData port, char *buf, int len)
+static void timer_read(ErlDrvData p, char *buf, ErlDrvSizeT len)
 {
+    ErlDrvPort port = (ErlDrvPort) p;
     char reply[1];
 
     if (buf[0] == START_TIMER) { 
@@ -62,8 +75,9 @@ static void timer_read(ErlDrvData port, char *buf, int len)
     }
 }
 
-static void timer_stop(ErlDrvData port)
+static void timer_stop(ErlDrvData p)
 {
+    ErlDrvPort port = (ErlDrvPort) p;
     driver_cancel_timer(port);
 }
 
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 1e98844838..66971654a2 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -50,13 +50,32 @@ typedef struct {
 
 ErlDrvData testcase_drv_start(ErlDrvPort port, char *command);
 void testcase_drv_stop(ErlDrvData drv_data);
-void testcase_drv_run(ErlDrvData drv_data, char *buf, int len);
+void testcase_drv_run(ErlDrvData drv_data, char *buf, ErlDrvSizeT len);
 
 static ErlDrvEntry testcase_drv_entry = { 
     NULL,
     testcase_drv_start,
     testcase_drv_stop,
-    testcase_drv_run
+    testcase_drv_run,
+    NULL,
+    NULL,
+    "testcase_drv",
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
+    NULL
 };
 
 
@@ -92,7 +111,7 @@ testcase_drv_stop(ErlDrvData drv_data)
 }
 
 void
-testcase_drv_run(ErlDrvData drv_data, char *buf, int len)
+testcase_drv_run(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
 {
     InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) drv_data;
     ErlDrvTermData result_atom;
diff --git a/erts/emulator/test/busy_port_SUITE_data/busy_drv.c b/erts/emulator/test/busy_port_SUITE_data/busy_drv.c
index 1273d610ba..75106d3757 100644
--- a/erts/emulator/test/busy_port_SUITE_data/busy_drv.c
+++ b/erts/emulator/test/busy_port_SUITE_data/busy_drv.c
@@ -11,7 +11,8 @@
 #define YES 1
 
 static ErlDrvData busy_start(ErlDrvPort, char*);
-static void busy_stop(ErlDrvData), busy_from_erlang(ErlDrvData, char*, int);
+static void busy_stop(ErlDrvData),
+    busy_from_erlang(ErlDrvData, char*, ErlDrvSizeT);
 
 ErlDrvEntry busy_driver_entry =
 {
@@ -23,6 +24,20 @@ ErlDrvEntry busy_driver_entry =
     NULL,
     "busy_drv",
     NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -73,7 +88,7 @@ static void busy_stop(ErlDrvData port)
 }
 
 static void
-busy_from_erlang(ErlDrvData port, char* buf, int count)
+busy_from_erlang(ErlDrvData port, char* buf, ErlDrvSizeT count)
 {
     if ((ErlDrvPort)port == slave_port) {
 	set_busy_port(slave_port, next_slave_state);
diff --git a/erts/emulator/test/busy_port_SUITE_data/hs_busy_drv.c b/erts/emulator/test/busy_port_SUITE_data/hs_busy_drv.c
index 35919da2d0..9f6bd310c6 100644
--- a/erts/emulator/test/busy_port_SUITE_data/hs_busy_drv.c
+++ b/erts/emulator/test/busy_port_SUITE_data/hs_busy_drv.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  * 
- * Copyright Ericsson AB 2009. All Rights Reserved.
+ * Copyright Ericsson AB 2009-2011. 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
@@ -21,9 +21,9 @@
 #include "erl_driver.h"
 
 ErlDrvData start(ErlDrvPort port, char *command);
-void output(ErlDrvData drv_data, char *buf, int len);
-int control(ErlDrvData drv_data, unsigned int command, char *buf, 
-	    int len, char **rbuf, int rlen); 
+void output(ErlDrvData drv_data, char *buf, ErlDrvSizeT len);
+ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+		     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
 
 static ErlDrvEntry busy_drv_entry = { 
     NULL /* init */,
@@ -61,7 +61,7 @@ ErlDrvData start(ErlDrvPort port, char *command)
     return (ErlDrvData) port;
 }
 
-void output(ErlDrvData drv_data, char *buf, int len)
+void output(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
 {
     int res;
     ErlDrvPort port = (ErlDrvPort) drv_data;
@@ -76,8 +76,8 @@ void output(ErlDrvData drv_data, char *buf, int len)
 	driver_failure_atom(port, "driver_output_term failed");
 }
 
-int control(ErlDrvData drv_data, unsigned int command, char *buf, 
-	    int len, char **rbuf, int rlen)
+ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+		     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
 {
     switch (command) {
     case 'B': /* busy */
diff --git a/erts/emulator/test/ddll_SUITE_data/dummy_drv.c b/erts/emulator/test/ddll_SUITE_data/dummy_drv.c
index e0d5067743..86f2abf1b1 100644
--- a/erts/emulator/test/ddll_SUITE_data/dummy_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/dummy_drv.c
@@ -7,7 +7,7 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData dummy_start(ErlDrvPort, char*);
-static void dummy_read(ErlDrvData port, char *buf, int count);
+static void dummy_read(ErlDrvData port, char *buf, ErlDrvSizeT count);
 static void dummy_stop(ErlDrvData), easy_read(ErlDrvData, char*, int);
 
 static ErlDrvEntry dummy_driver_entry = { 
@@ -18,6 +18,21 @@ static ErlDrvEntry dummy_driver_entry = {
     NULL,
     NULL,
     "dummy_drv",
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -37,7 +52,7 @@ static ErlDrvData dummy_start(ErlDrvPort port,char *buf)
     return (ErlDrvData)port;
 }
 
-static void dummy_read(ErlDrvData port, char *buf, int count)
+static void dummy_read(ErlDrvData port, char *buf, ErlDrvSizeT count)
 {
     driver_output(erlang_port, buf, count);
 }
diff --git a/erts/emulator/test/ddll_SUITE_data/echo_drv.c b/erts/emulator/test/ddll_SUITE_data/echo_drv.c
index edf78a979d..2b3510c641 100644
--- a/erts/emulator/test/ddll_SUITE_data/echo_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/echo_drv.c
@@ -3,9 +3,10 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData echo_start(ErlDrvPort, char *);
-static void from_erlang(ErlDrvData, char*, int);
-static int echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-		     int len, char **rbuf, int rlen, unsigned *ret_flags);
+static void from_erlang(ErlDrvData, char*, ErlDrvSizeT);
+static ErlDrvSSizeT echo_call(ErlDrvData drv_data, unsigned int command,
+			      char *buf, ErlDrvSizeT len,
+			      char **rbuf, ErlDrvSizeT rlen, unsigned *ret_flags);
 static ErlDrvEntry echo_driver_entry = { 
     NULL,			/* Init */
     echo_start,
@@ -21,7 +22,15 @@ static ErlDrvEntry echo_driver_entry = {
     NULL,
     NULL,
     NULL,
-    echo_call
+    echo_call,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
+    NULL
 };
 
 DRIVER_INIT(echo_drv)
@@ -36,14 +45,15 @@ echo_start(ErlDrvPort port, char *buf)
 }
 
 static void
-from_erlang(ErlDrvData data, char *buf, int count)
+from_erlang(ErlDrvData data, char *buf, ErlDrvSizeT count)
 {
     driver_output((ErlDrvPort) data, buf, count);
 }
 
-static int 
-echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-	  int len, char **rbuf, int rlen, unsigned *ret_flags) 
+static ErlDrvSSizeT
+echo_call(ErlDrvData drv_data, unsigned int command,
+	  char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen,
+	  unsigned *ret_flags)
 {
     *rbuf = buf;
     *ret_flags |= DRIVER_CALL_KEEP_BUFFER;
diff --git a/erts/emulator/test/ddll_SUITE_data/echo_drv_fail_init.c b/erts/emulator/test/ddll_SUITE_data/echo_drv_fail_init.c
index 3b2a44d907..26aa03a012 100644
--- a/erts/emulator/test/ddll_SUITE_data/echo_drv_fail_init.c
+++ b/erts/emulator/test/ddll_SUITE_data/echo_drv_fail_init.c
@@ -3,9 +3,10 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData echo_start(ErlDrvPort, char *);
-static void from_erlang(ErlDrvData, char*, int);
-static int echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-		     int len, char **rbuf, int rlen, unsigned *ret_flags);
+static void from_erlang(ErlDrvData, char*, ErlDrvSizeT);
+static ErlDrvSSizeT echo_call(ErlDrvData drv_data, unsigned int command,
+			      char *buf, ErlDrvSizeT len,
+			      char **rbuf, ErlDrvSizeT rlen, unsigned *ret_flags);
 static int echo_failing_init(void);
 
 static ErlDrvEntry echo_driver_entry = { 
@@ -23,7 +24,15 @@ static ErlDrvEntry echo_driver_entry = {
     NULL,
     NULL,
     NULL,
-    echo_call
+    echo_call,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
+    NULL
 };
 
 DRIVER_INIT(echo_drv)
@@ -43,14 +52,15 @@ echo_start(ErlDrvPort port, char *buf)
 }
 
 static void
-from_erlang(ErlDrvData data, char *buf, int count)
+from_erlang(ErlDrvData data, char *buf, ErlDrvSizeT count)
 {
     driver_output((ErlDrvPort) data, buf, count);
 }
 
-static int 
-echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-	  int len, char **rbuf, int rlen, unsigned *ret_flags) 
+static ErlDrvSSizeT
+echo_call(ErlDrvData drv_data, unsigned int command,
+	  char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen,
+	  unsigned *ret_flags)
 {
     *rbuf = buf;
     *ret_flags |= DRIVER_CALL_KEEP_BUFFER;
diff --git a/erts/emulator/test/ddll_SUITE_data/initfail_drv.c b/erts/emulator/test/ddll_SUITE_data/initfail_drv.c
index b676ff5121..ad241b9c4f 100644
--- a/erts/emulator/test/ddll_SUITE_data/initfail_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/initfail_drv.c
@@ -3,7 +3,7 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData easy_start(ErlDrvPort, char*);
-static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, int);
+static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, ErlDrvSizeT);
 
 static ErlDrvEntry easy_driver_entry =
 {
@@ -14,6 +14,21 @@ static ErlDrvEntry easy_driver_entry =
   NULL,
   NULL,
   "easy",
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  NULL,
+  ERL_DRV_EXTENDED_MARKER,
+  ERL_DRV_EXTENDED_MAJOR_VERSION,
+  ERL_DRV_EXTENDED_MINOR_VERSION,
+  0,
+  NULL,
+  NULL,
   NULL
 };
 
@@ -34,7 +49,7 @@ static ErlDrvData easy_start(ErlDrvPort port, char *buf)
     return (ErlDrvData)port;
 }
 
-static void easy_read(ErlDrvData port, char *buf, int count)
+static void easy_read(ErlDrvData port, char *buf, ErlDrvSizeT count)
 {
     driver_output(erlang_port, buf, count);
 }
diff --git a/erts/emulator/test/ddll_SUITE_data/lock_drv.c b/erts/emulator/test/ddll_SUITE_data/lock_drv.c
index 2ec8fa3a29..d2605c5bfc 100644
--- a/erts/emulator/test/ddll_SUITE_data/lock_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/lock_drv.c
@@ -3,9 +3,10 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData echo_start(ErlDrvPort, char *);
-static void from_erlang(ErlDrvData, char*, int);
-static int echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-		     int len, char **rbuf, int rlen, unsigned *ret_flags);
+static void from_erlang(ErlDrvData, char*, ErlDrvSizeT);
+static ErlDrvSSizeT echo_call(ErlDrvData drv_data, unsigned int command,
+			      char *buf, ErlDrvSizeT len,
+			      char **rbuf, ErlDrvSizeT rlen, unsigned *ret_flags);
 static ErlDrvEntry echo_driver_entry = { 
     NULL,			/* Init */
     echo_start,
@@ -21,7 +22,15 @@ static ErlDrvEntry echo_driver_entry = {
     NULL,
     NULL,
     NULL,
-    echo_call
+    echo_call,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
+    NULL
 };
 
 DRIVER_INIT(echo_drv)
@@ -37,14 +46,15 @@ echo_start(ErlDrvPort port, char *buf)
 }
 
 static void
-from_erlang(ErlDrvData data, char *buf, int count)
+from_erlang(ErlDrvData data, char *buf, ErlDrvSizeT count)
 {
     driver_output((ErlDrvPort) data, buf, count);
 }
 
-static int 
-echo_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-	  int len, char **rbuf, int rlen, unsigned *ret_flags) 
+static ErlDrvSSizeT
+echo_call(ErlDrvData drv_data, unsigned int command,
+	  char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen,
+	  unsigned *ret_flags)
 {
     ErlDrvPort port = (ErlDrvPort) drv_data;
     driver_lock_driver(port);
diff --git a/erts/emulator/test/ddll_SUITE_data/noinit_drv.c b/erts/emulator/test/ddll_SUITE_data/noinit_drv.c
index 931386a305..5abf5c4dc6 100644
--- a/erts/emulator/test/ddll_SUITE_data/noinit_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/noinit_drv.c
@@ -3,7 +3,7 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData easy_start(ErlDrvPort, char*);
-static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, int);
+static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, ErlDrvSizeT);
 
 static ErlDrvEntry easy_driver_entry =
 {
@@ -14,6 +14,21 @@ static ErlDrvEntry easy_driver_entry =
     NULL,
     NULL,
     "easy",
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -28,7 +43,7 @@ DRIVER_INIT(noinit_drv)
 /*
  * Provoke an error when loading the module.
  */
-int no_driver_init(void *handle)
+ErlDrvEntry* no_driver_init(void *handle)
 #endif
 {
     erlang_port = (ErlDrvPort)-1;
@@ -46,7 +61,7 @@ static ErlDrvData easy_start(ErlDrvPort port,char *buf)
     return (ErlDrvData)port;
 }
 
-static void easy_read(ErlDrvData port, char *buf, int count)
+static void easy_read(ErlDrvData port, char *buf, ErlDrvSizeT count)
 {
     driver_output(erlang_port, buf, count);
 }
diff --git a/erts/emulator/test/ddll_SUITE_data/wrongname_drv.c b/erts/emulator/test/ddll_SUITE_data/wrongname_drv.c
index 3a35820ee7..ac7efa30de 100644
--- a/erts/emulator/test/ddll_SUITE_data/wrongname_drv.c
+++ b/erts/emulator/test/ddll_SUITE_data/wrongname_drv.c
@@ -7,7 +7,7 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData easy_start(ErlDrvPort, char*);
-static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, int);
+static void easy_stop(ErlDrvData), easy_read(ErlDrvData, char*, ErlDrvSizeT);
 
 static ErlDrvEntry easy_driver_entry =
 {
@@ -18,6 +18,21 @@ static ErlDrvEntry easy_driver_entry =
     NULL,
     NULL,
     "easy",
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -38,7 +53,7 @@ static ErlDrvData easy_start(ErlDrvPort port,char *buf)
     return (ErlDrvData)port;
 }
 
-static void easy_read(ErlDrvData port, char *buf, int count)
+static void easy_read(ErlDrvData port, char *buf, ErlDrvSizeT count)
 {
     driver_output(erlang_port, buf, count);
 }
diff --git a/erts/emulator/test/driver_SUITE_data/async_blast_drv.c b/erts/emulator/test/driver_SUITE_data/async_blast_drv.c
index 3821f7e3dc..c2086c5860 100644
--- a/erts/emulator/test/driver_SUITE_data/async_blast_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/async_blast_drv.c
@@ -25,7 +25,7 @@ static void stop(ErlDrvData drv_data);
 static ErlDrvData start(ErlDrvPort port,
 			char *command);
 static void output(ErlDrvData drv_data,
-		   char *buf, int len);
+		   char *buf, ErlDrvSizeT len);
 static void ready_async(ErlDrvData drv_data,
 			ErlDrvThreadData thread_data);
 
@@ -107,7 +107,7 @@ static void ready_async(ErlDrvData drv_data,
 }
 
 static void output(ErlDrvData drv_data,
-		   char *buf, int len)
+		   char *buf, ErlDrvSizeT len)
 {
     async_blast_data_t *abd = (async_blast_data_t *) drv_data;
     if (abd->counter == 0) {
diff --git a/erts/emulator/test/driver_SUITE_data/caller_drv.c b/erts/emulator/test/driver_SUITE_data/caller_drv.c
index a78d51966f..1ed20b0638 100644
--- a/erts/emulator/test/driver_SUITE_data/caller_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/caller_drv.c
@@ -23,17 +23,17 @@
 static ErlDrvData start(ErlDrvPort port,
 			char *command);
 static void output(ErlDrvData drv_data,
-		   char *buf, int len);
+		   char *buf, ErlDrvSizeT len);
 static void outputv(ErlDrvData drv_data,
 		    ErlIOVec *ev);
-static int control(ErlDrvData drv_data,
-		   unsigned int command, char *buf, 
-		   int len, char **rbuf, int rlen);
-static int call(ErlDrvData drv_data,
-		unsigned int command,
-		char *buf, int len,
-		char **rbuf, int rlen,
-		unsigned int *flags);
+static ErlDrvSSizeT control(ErlDrvData drv_data,
+			    unsigned int command, char *buf,
+			    ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
+static ErlDrvSSizeT call(ErlDrvData drv_data,
+			 unsigned int command,
+			 char *buf, ErlDrvSizeT len,
+			 char **rbuf, ErlDrvSizeT rlen,
+			 unsigned int *flags);
 
 static ErlDrvEntry caller_drv_entry = { 
     NULL /* init */,
@@ -98,7 +98,7 @@ start(ErlDrvPort port, char *command)
 }
 
 static void
-output(ErlDrvData drv_data, char *buf, int len)
+output(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
 {
     send_caller(drv_data, "output");
 }
@@ -109,20 +109,20 @@ outputv(ErlDrvData drv_data, ErlIOVec *ev)
     send_caller(drv_data, "outputv");
 }
 
-static int
+static ErlDrvSSizeT
 control(ErlDrvData drv_data,
 	unsigned int command, char *buf, 
-	int len, char **rbuf, int rlen)
+	ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
 {
     send_caller(drv_data, "control");
     return 0;
 }
 
-static int
+static ErlDrvSSizeT
 call(ErlDrvData drv_data,
      unsigned int command,
-     char *buf, int len,
-     char **rbuf, int rlen,
+     char *buf, ErlDrvSizeT len,
+     char **rbuf, ErlDrvSizeT rlen,
      unsigned int *flags)
 {
     /* echo call */
diff --git a/erts/emulator/test/driver_SUITE_data/chkio_drv.c b/erts/emulator/test/driver_SUITE_data/chkio_drv.c
index bbdb09cfcb..40f1ad4fea 100644
--- a/erts/emulator/test/driver_SUITE_data/chkio_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/chkio_drv.c
@@ -141,8 +141,8 @@ static void chkio_drv_stop(ErlDrvData);
 static void chkio_drv_ready_input(ErlDrvData, ErlDrvEvent);
 static void chkio_drv_ready_output(ErlDrvData, ErlDrvEvent);
 static void chkio_drv_ready_event(ErlDrvData, ErlDrvEvent, ErlDrvEventData);
-static int chkio_drv_control(ErlDrvData, unsigned int,
-			    char *, int, char **, int);
+static ErlDrvSSizeT chkio_drv_control(ErlDrvData, unsigned int,
+				      char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 static void chkio_drv_timeout(ErlDrvData);
 static void chkio_drv_stop_select(ErlDrvEvent, void*);
 
@@ -188,7 +188,7 @@ stop_use_fallback_pollset(ChkioDrvData *cddp)
 	for (i = 0; i < CHKIO_FALLBACK_FDS; i++) {
 	    if (cbdp->dev_null[i].fd >= 0) {
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->dev_null[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->dev_null[i].fd,
 				  DO_WRITE,
 				  0) != 0) {
 		    fprintf(stderr,
@@ -200,7 +200,7 @@ stop_use_fallback_pollset(ChkioDrvData *cddp)
 	    }
 	    if (cbdp->dev_zero[i].fd >= 0) {
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->dev_zero[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->dev_zero[i].fd,
 				  DO_READ,
 				  0) != 0) {
 		    fprintf(stderr,
@@ -212,7 +212,7 @@ stop_use_fallback_pollset(ChkioDrvData *cddp)
 	    }
 	    if (cbdp->pipe_in[i].fd >= 0) {
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->pipe_in[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->pipe_in[i].fd,
 				  DO_READ,
 				  0) != 0) {
 		    fprintf(stderr,
@@ -224,7 +224,7 @@ stop_use_fallback_pollset(ChkioDrvData *cddp)
 	    }
 	    if (cbdp->pipe_out[i].fd >= 0) {
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->pipe_out[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->pipe_out[i].fd,
 				  DO_WRITE,
 				  0) != 0) {
 		    fprintf(stderr,
@@ -249,11 +249,11 @@ stop_driver_event(ChkioDrvData *cddp)
 	cddp->test_data = NULL;
 
 	if (cdep->in_fd >= 0) {
-	    driver_event(cddp->port, (ErlDrvEvent) cdep->in_fd, NULL);
+	    driver_event(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cdep->in_fd, NULL);
 	    close(cdep->in_fd);
 	}
 	if (cdep->out_fd >= 0) {
-	    driver_event(cddp->port, (ErlDrvEvent) cdep->out_fd, NULL);
+	    driver_event(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cdep->out_fd, NULL);
 	    close(cdep->out_fd);
 	}
 	driver_free(cdep);	    
@@ -268,7 +268,7 @@ stop_fd_change(ChkioDrvData *cddp)
 	cddp->test_data = NULL;
 	driver_cancel_timer(cddp->port);
 	if (cfcp->fds[0] >= 0) {
-	    driver_select(cddp->port, (ErlDrvEvent) cfcp->fds[0], DO_READ, 0);
+	    driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cfcp->fds[0], DO_READ, 0);
 	    close(cfcp->fds[0]);
 	    close(cfcp->fds[1]);
 	}
@@ -282,8 +282,8 @@ stop_bad_fd_in_pollset(ChkioDrvData *cddp)
     if (cddp->test_data) {
 	ChkioBadFdInPollset *bfipp = (ChkioBadFdInPollset *) cddp->test_data;
 	cddp->test_data = NULL;
-	driver_select(cddp->port, (ErlDrvEvent) bfipp->fds[0], DO_WRITE, 0);
-	driver_select(cddp->port, (ErlDrvEvent) bfipp->fds[1], DO_READ, 0);
+	driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) bfipp->fds[0], DO_WRITE, 0);
+	driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) bfipp->fds[1], DO_READ, 0);
 	driver_free((void *) bfipp);
     }
 }
@@ -296,21 +296,21 @@ stop_steal(ChkioDrvData *cddp)
 	cddp->test_data = NULL;
 	if (csp->driver_select_fds[0] >= 0)
 	    driver_select(cddp->port,
-			  (ErlDrvEvent) csp->driver_select_fds[0],
+			  (ErlDrvEvent) (ErlDrvSInt) csp->driver_select_fds[0],
 			  DO_READ,
 			  0);
 	if (csp->driver_select_fds[1] >= 0)
 	    driver_select(cddp->port,
-			  (ErlDrvEvent) csp->driver_select_fds[1],
+			  (ErlDrvEvent) (ErlDrvSInt) csp->driver_select_fds[1],
 			  DO_WRITE,
 			  0);
 	if (csp->driver_event_fds[0] >= 0)
 	    driver_event(cddp->port,
-			 (ErlDrvEvent) csp->driver_event_fds[0],
+			 (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[0],
 			 NULL);
 	if (csp->driver_event_fds[1] >= 0)
 	    driver_event(cddp->port,
-			 (ErlDrvEvent) csp->driver_event_fds[1],
+			 (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[1],
 			 NULL);
 	driver_free(csp);
     }
@@ -353,7 +353,7 @@ static void free_smp_select(ChkioSmpSelect* pip, ErlDrvPort port)
 	abort();
     }
     case Selected:
-	driver_select(port, (ErlDrvEvent)pip->read_fd, DO_READ, 0);
+	driver_select(port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ, 0);
 	/*fall through*/ 
     case Opened:
 	close(pip->read_fd);
@@ -475,8 +475,8 @@ chkio_drv_stop(ErlDrvData drv_data) {
 	fprintf(stderr,	"%s:%d: Failed to open /dev/null\n",
 		__FILE__, __LINE__);
     }
-    driver_select(cddp->port, (ErlDrvEvent) fd, DO_WRITE, 1);
-    driver_select(cddp->port, (ErlDrvEvent) fd, DO_WRITE, 0);
+    driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) fd, DO_WRITE, 1);
+    driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) fd, DO_WRITE, 0);
     close(fd);
 
 
@@ -491,7 +491,7 @@ chkio_drv_ready_output(ErlDrvData drv_data, ErlDrvEvent event)
 {
 #ifdef UNIX
     ChkioDrvData *cddp = (ChkioDrvData *) drv_data;
-    int fd = (int) event;
+    int fd = (int) (ErlDrvSInt) event;
 
     switch (cddp->test) {
     case CHKIO_USE_FALLBACK_POLLSET: {
@@ -533,7 +533,7 @@ chkio_drv_ready_input(ErlDrvData drv_data, ErlDrvEvent event)
 {
 #ifdef UNIX
     ChkioDrvData *cddp = (ChkioDrvData *) drv_data;
-    int fd = (int) event;
+    int fd = (int) (ErlDrvSInt) event;
 
     switch (cddp->test) {
     case CHKIO_USE_FALLBACK_POLLSET: {
@@ -630,7 +630,7 @@ chkio_drv_ready_event(ErlDrvData drv_data,
     case CHKIO_DRIVER_EVENT: {
 #ifdef HAVE_POLL_H
 	ChkioDriverEvent *cdep = cddp->test_data;
-	int fd = (int) event;
+	int fd = (int) (ErlDrvSInt) event;
 	if (fd == cdep->in_fd) {
 	    if (event_data->events == POLLIN
 		&& event_data->revents == POLLIN) {
@@ -679,7 +679,7 @@ chkio_drv_timeout(ErlDrvData drv_data)
 	int in_fd = cfcp->fds[0];
 	int out_fd = cfcp->fds[1];
 	if (in_fd >= 0) {
-	    if (driver_select(cddp->port, (ErlDrvEvent) in_fd, DO_READ, 0) < 0)
+	    if (driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) in_fd, DO_READ, 0) < 0)
 		driver_failure_atom(cddp->port, "deselect_failed");
 	    (void) write(out_fd, (void *) "!", 1);
 	    close(out_fd);
@@ -689,7 +689,7 @@ chkio_drv_timeout(ErlDrvData drv_data)
 	    driver_failure_posix(cddp->port, errno);
 	}
 	else {
-	    if (driver_select(cddp->port, (ErlDrvEvent) cfcp->fds[0],
+	    if (driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) cfcp->fds[0],
 			      DO_READ, 1) < 0)
 		driver_failure_atom(cddp->port, "select_failed");
 	    if (cfcp->fds[0] == in_fd)
@@ -709,14 +709,14 @@ chkio_drv_timeout(ErlDrvData drv_data)
 #endif /* UNIX */
 }
 
-static int
+static ErlDrvSSizeT
 chkio_drv_control(ErlDrvData drv_data,
 		 unsigned int command,
-		 char *buf, int len,
-		 char **rbuf, int rlen)
+		 char *buf, ErlDrvSizeT len,
+		 char **rbuf, ErlDrvSizeT rlen)
 {
     char *res_str;
-    int res_len = -1;
+    ErlDrvSSizeT res_len = -1;
 #ifndef UNIX
 #ifdef __WIN32__
     res_str = "skip: windows_different";
@@ -854,7 +854,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		int fds[2];
 		cbdp->dev_null[i].fd = open("/dev/null", O_WRONLY);
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->dev_null[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->dev_null[i].fd,
 				  DO_WRITE,
 				  1) != 0) {
 		    driver_failure_posix(cddp->port, errno);
@@ -862,7 +862,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		}
 		cbdp->dev_zero[i].fd = open("/dev/zero", O_RDONLY);
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->dev_zero[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->dev_zero[i].fd,
 				  DO_READ,
 				  1) != 0) {
 		    driver_failure_posix(cddp->port, errno);
@@ -873,7 +873,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		cbdp->pipe_in[i].fd = fds[0];
 		cbdp->pipe_out[i].fd = fds[1];
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->pipe_in[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->pipe_in[i].fd,
 				  DO_READ,
 				  1) != 0) {
 		    driver_failure_posix(cddp->port, EIO);
@@ -882,7 +882,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		if (i % 2 == 0)
 		    (void) write(cbdp->pipe_out[i].fd, "!", 1);
 		if (driver_select(cddp->port,
-				  (ErlDrvEvent) cbdp->pipe_out[i].fd,
+				  (ErlDrvEvent) (ErlDrvSInt) cbdp->pipe_out[i].fd,
 				  DO_WRITE,
 				  1) != 0) {
 		    driver_failure_posix(cddp->port, EIO);
@@ -928,8 +928,8 @@ chkio_drv_control(ErlDrvData drv_data,
 		bfipp->fds[0] = fds[9];
 		bfipp->fds[1] = fds[10];
 		cddp->test_data = (void *) bfipp;
-		driver_select(cddp->port, (ErlDrvEvent) fds[9], DO_WRITE, 1);
-		driver_select(cddp->port, (ErlDrvEvent) fds[10], DO_READ, 1);
+		driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) fds[9], DO_WRITE, 1);
+		driver_select(cddp->port, (ErlDrvEvent) (ErlDrvSInt) fds[10], DO_READ, 1);
 	    }
 	}
 	res_str = "ok";
@@ -965,7 +965,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		cdep->in_ok = 0;
 
 		res = driver_event(cddp->port,
-				   (ErlDrvEvent) in_fd,
+				   (ErlDrvEvent) (ErlDrvSInt) in_fd,
 				   &cdep->in_data);
 		if (res < 0) {
 		    res_str = "skip: driver_event() not supported";
@@ -985,7 +985,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		    cdep->out_ok = 0;
 
 		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) out_fd,
+				       (ErlDrvEvent) (ErlDrvSInt) out_fd,
 				       &cdep->out_data);
 		    if (res < 0) {
 			close(out_fd);
@@ -1062,7 +1062,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		    csp->event_data[0].events = POLLIN;
 		    csp->event_data[0].revents = 0;
 		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) csp->driver_event_fds[0],
+				       (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[0],
 				       &csp->event_data[0]);
 		    if (res < 0)
 			driver_failure_atom(cddp->port,
@@ -1071,7 +1071,7 @@ chkio_drv_control(ErlDrvData drv_data,
 			csp->event_data[1].events = POLLOUT;
 			csp->event_data[1].revents = 0;
 			res = driver_event(cddp->port,
-					   (ErlDrvEvent) csp->driver_event_fds[1],
+					   (ErlDrvEvent) (ErlDrvSInt) csp->driver_event_fds[1],
 					   &csp->event_data[1]);
 			if (res < 0)
 			    driver_failure_atom(cddp->port,
@@ -1083,7 +1083,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		/* Steal with driver_select() */
 		if (res >= 0) {
 		    res = driver_select(cddp->port,
-					(ErlDrvEvent) csp->driver_select_fds[0],
+					(ErlDrvEvent) (ErlDrvSInt) csp->driver_select_fds[0],
 					DO_READ,
 					1);
 		    if (res < 0)
@@ -1092,7 +1092,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		}
 		if (res >= 0) {
 		    res = driver_select(cddp->port,
-					(ErlDrvEvent) csp->driver_select_fds[1],
+					(ErlDrvEvent) (ErlDrvSInt) csp->driver_select_fds[1],
 					DO_WRITE,
 					1);
 		    if (res < 0)
@@ -1159,14 +1159,14 @@ chkio_drv_control(ErlDrvData drv_data,
 		csap->driver_event_fds[1] = write_fds[1];
 
 		res = driver_select(cddp->port,
-				    (ErlDrvEvent) csap->driver_select_fds[0],
+				    (ErlDrvEvent) (ErlDrvSInt) csap->driver_select_fds[0],
 				    DO_READ,
 				    1);
 		if (res < 0)
 		    driver_failure_atom(cddp->port, "driver_select_failed");
 		if (res >= 0) {
 		    res = driver_select(cddp->port,
-					(ErlDrvEvent) csap->driver_select_fds[1],
+					(ErlDrvEvent) (ErlDrvSInt) csap->driver_select_fds[1],
 					DO_WRITE,
 					1);
 		    if (res < 0)
@@ -1177,7 +1177,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		    csap->event_data[0].events = POLLIN;
 		    csap->event_data[0].revents = 0;
 		    res = driver_event(cddp->port,
-				       (ErlDrvEvent) csap->driver_event_fds[0],
+				       (ErlDrvEvent) (ErlDrvSInt) csap->driver_event_fds[0],
 				       &csap->event_data[0]);
 		    if (res < 0) {
 			close(csap->driver_event_fds[0]);
@@ -1190,7 +1190,7 @@ chkio_drv_control(ErlDrvData drv_data,
 			csap->event_data[1].events = POLLOUT;
 			csap->event_data[1].revents = 0;
 			res = driver_event(cddp->port,
-					   (ErlDrvEvent) csap->driver_event_fds[1],
+					   (ErlDrvEvent) (ErlDrvSInt) csap->driver_event_fds[1],
 					   &csap->event_data[1]);
 			if (res < 0)
 			    driver_failure_atom(cddp->port,
@@ -1285,7 +1285,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		}
 		else {
 		    TRACEF(("%T: Select on pipe [%d->%d]\n", cddp->id, pip->write_fd, pip->read_fd));
-		    if (driver_select(cddp->port, (ErlDrvEvent)pip->read_fd, DO_READ, 1)) {
+		    if (driver_select(cddp->port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ, 1)) {
 			fprintf(stderr, "driver_select failed for fd=%d\n", pip->read_fd);
 			abort();
 		    }
@@ -1314,7 +1314,7 @@ chkio_drv_control(ErlDrvData drv_data,
 		op >>= 1;
 		if (op & 1) {
 		    TRACEF(("%T: Deselect on pipe [%d->%d]\n", cddp->id, pip->write_fd, pip->read_fd));
-		    if (driver_select(cddp->port, (ErlDrvEvent)pip->read_fd, DO_READ, 0)) {
+		    if (driver_select(cddp->port, (ErlDrvEvent)(ErlDrvSInt)pip->read_fd, DO_READ, 0)) {
 			fprintf(stderr, "driver_(de)select failed for fd=%d\n", pip->read_fd);
 			abort();
 		    }
diff --git a/erts/emulator/test/driver_SUITE_data/io_ready_exit_drv.c b/erts/emulator/test/driver_SUITE_data/io_ready_exit_drv.c
index 6afa46b3a2..e6a3edcd74 100644
--- a/erts/emulator/test/driver_SUITE_data/io_ready_exit_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/io_ready_exit_drv.c
@@ -40,8 +40,9 @@ static void io_ready_exit_ready_input(ErlDrvData, ErlDrvEvent);
 static void io_ready_exit_ready_output(ErlDrvData, ErlDrvEvent);
 static void io_ready_exit_drv_output(ErlDrvData, char *, int);
 static void io_ready_exit_drv_finish(void);
-static int io_ready_exit_drv_control(ErlDrvData, unsigned int,
-				   char *, int, char **, int);
+static ErlDrvSSizeT io_ready_exit_drv_control(ErlDrvData, unsigned int,
+					      char *, ErlDrvSizeT,
+					      char **, ErlDrvSizeT);
 
 static ErlDrvEntry io_ready_exit_drv_entry = { 
     NULL, /* init */
@@ -56,7 +57,17 @@ static ErlDrvEntry io_ready_exit_drv_entry = {
     io_ready_exit_drv_control,
     NULL, /* timeout */
     NULL, /* outputv */
-    NULL  /* ready_async */
+    NULL, /* ready_async */
+    NULL, /* flush */
+    NULL, /* call */
+    NULL, /* event */
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0, /* ERL_DRV_FLAGs */
+    NULL, /* handle2 */
+    NULL, /* process_exit */
+    NULL  /* stop_select */
 };
 
 /* -------------------------------------------------------------------------
@@ -83,7 +94,7 @@ io_ready_exit_drv_stop(ErlDrvData drv_data) {
 #ifdef UNIX
     if (oeddp->fds[0] >= 0) {
 	driver_select(oeddp->port,
-		      (ErlDrvEvent) oeddp->fds[0],
+		      (ErlDrvEvent) (ErlDrvSInt) oeddp->fds[0],
 		      DO_READ|DO_WRITE,
 		      0);
 	close(oeddp->fds[0]);
@@ -109,15 +120,15 @@ io_ready_exit_ready_input(ErlDrvData drv_data, ErlDrvEvent event)
     driver_failure_atom(oeddp->port, "ready_input_driver_failure");
 }
 
-static int
+static ErlDrvSSizeT
 io_ready_exit_drv_control(ErlDrvData drv_data,
 			  unsigned int command,
-			  char *buf, int len,
-			  char **rbuf, int rlen)
+			  char *buf, ErlDrvSizeT len,
+			  char **rbuf, ErlDrvSizeT rlen)
 {
     char *abuf;
     char *res_str;
-    int res_len;
+    ErlDrvSSizeT res_len;
     IOReadyExitDrvData *oeddp = (IOReadyExitDrvData *) drv_data;
 #ifndef UNIX
     res_str = "nyiftos";
@@ -127,9 +138,9 @@ io_ready_exit_drv_control(ErlDrvData drv_data,
     }
     else {
 	res_str = "ok";
-	write(oeddp->fds[1], "!", 1);
+	(void) write(oeddp->fds[1], "!", 1);
 	driver_select(oeddp->port,
-		      (ErlDrvEvent) oeddp->fds[0],
+		      (ErlDrvEvent) (ErlDrvSInt) oeddp->fds[0],
 		      DO_READ|DO_WRITE,
 		      1);
     }
diff --git a/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c b/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
index e49de388b4..b2cc1e785a 100644
--- a/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/ioq_exit_drv.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2007-2010. All Rights Reserved.
+ * Copyright Ericsson AB 2007-2011. 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
@@ -91,7 +91,8 @@ static ErlDrvData start(ErlDrvPort port, char *command);
 static void stop(ErlDrvData drv_data);
 static void ready_input(ErlDrvData drv_data, ErlDrvEvent event); 
 static void ready_output(ErlDrvData drv_data, ErlDrvEvent event);  
-static int control(ErlDrvData, unsigned int, char *, int, char **, int);
+static ErlDrvSSizeT control(ErlDrvData, unsigned int,
+			    char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 static void timeout(ErlDrvData drv_data);
 static void ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data);
 static void flush(ErlDrvData drv_data);
@@ -155,10 +156,10 @@ start(ErlDrvPort port, char *command)
     return (ErlDrvData) ddp;
 }
 
-static int control(ErlDrvData drv_data,
-		   unsigned int command,
-		   char *buf, int len,
-		   char **rbuf, int rlen)
+static ErlDrvSSizeT control(ErlDrvData drv_data,
+			    unsigned int command,
+			    char *buf, ErlDrvSizeT len,
+			    char **rbuf, ErlDrvSizeT rlen)
 {
     IOQExitDrvData *ddp = (IOQExitDrvData *) drv_data;
     char *res_str = "nyiftos";
@@ -227,7 +228,7 @@ static int control(ErlDrvData drv_data,
     res_str = "ok";
 
  done: {
-	int res_len = strlen(res_str);
+	ErlDrvSSizeT res_len = strlen(res_str);
 	if (res_len > rlen) {
 	    char *abuf = driver_alloc(sizeof(char)*res_len);
 	    if (!abuf)
diff --git a/erts/emulator/test/driver_SUITE_data/many_events_drv.c b/erts/emulator/test/driver_SUITE_data/many_events_drv.c
index 7417dbf7f8..a34432a8fe 100644
--- a/erts/emulator/test/driver_SUITE_data/many_events_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/many_events_drv.c
@@ -3,14 +3,17 @@
 #endif
 
 #include <stdio.h>
+#include <string.h>
 #include "erl_driver.h"
 
 static ErlDrvPort erlang_port;
 static ErlDrvData many_events_start(ErlDrvPort, char *);
-static void from_erlang(ErlDrvData, char*, int);
+static void from_erlang(ErlDrvData, char*, ErlDrvSizeT);
 static void from_port(ErlDrvData drv_data, ErlDrvEvent event);
-static int many_events_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-		     int len, char **rbuf, int rlen, unsigned *ret_flags);
+static ErlDrvSSizeT many_events_call(ErlDrvData drv_data, unsigned int command,
+				     char *buf, ErlDrvSizeT len,
+				     char **rbuf, ErlDrvSizeT rlen,
+				     unsigned *ret_flags);
 static ErlDrvEntry many_events_driver_entry = { 
     NULL,			/* Init */
     many_events_start,
@@ -26,7 +29,15 @@ static ErlDrvEntry many_events_driver_entry = {
     NULL,
     NULL,
     NULL,
-    many_events_call
+    many_events_call,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
+    NULL
 };
 
 DRIVER_INIT(many_events_drv)
@@ -41,7 +52,7 @@ many_events_start(ErlDrvPort port, char *buf)
 }
 
 static void
-from_erlang(ErlDrvData data, char *buf, int count)
+from_erlang(ErlDrvData data, char *buf, ErlDrvSizeT count)
 {
     int i;
     int num;
@@ -87,9 +98,10 @@ static void from_port(ErlDrvData data, ErlDrvEvent ev)
     return;
 }
 
-static int 
-many_events_call(ErlDrvData drv_data, unsigned int command, char *buf, 
-	  int len, char **rbuf, int rlen, unsigned *ret_flags) 
+static ErlDrvSSizeT
+many_events_call(ErlDrvData drv_data, unsigned int command,
+		 char *buf, ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen,
+		 unsigned *ret_flags)
 {
     *rbuf = buf;
     *ret_flags |= DRIVER_CALL_KEEP_BUFFER;
diff --git a/erts/emulator/test/driver_SUITE_data/monitor_drv.c b/erts/emulator/test/driver_SUITE_data/monitor_drv.c
index 1da6a56a72..e714587354 100644
--- a/erts/emulator/test/driver_SUITE_data/monitor_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/monitor_drv.c
@@ -21,8 +21,8 @@
 #include "erl_driver.h"
 
 static ErlDrvData monitor_drv_start(ErlDrvPort, char *);
-static int monitor_drv_control(ErlDrvData, unsigned int,
-				char *, int, char **, int);
+static ErlDrvSSizeT monitor_drv_control(ErlDrvData, unsigned int,
+					char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 static void handle_monitor(ErlDrvData drv_data, ErlDrvMonitor *monitor);
 
 #define OP_I_AM_IPID 1
@@ -122,16 +122,16 @@ static void handle_monitor(ErlDrvData drv_data, ErlDrvMonitor *monitor)
     return;
 }
 
-static int
+static ErlDrvSSizeT
 monitor_drv_control(ErlDrvData drv_data,
 		     unsigned int command,
-		     char *ibuf, int ilen,
-		     char **rbuf, int rlen)
+		     char *ibuf, ErlDrvSizeT ilen,
+		     char **rbuf, ErlDrvSizeT rlen)
 {
     MyDrvData *data = (MyDrvData *) drv_data;
     char *answer = NULL;
     char buff[64];
-    int alen;
+    ErlDrvSSizeT alen;
 
     switch (command) {
     case OP_I_AM_IPID:
diff --git a/erts/emulator/test/driver_SUITE_data/otp_6879_drv.c b/erts/emulator/test/driver_SUITE_data/otp_6879_drv.c
index 8c0a9aadfd..ff44145ca7 100644
--- a/erts/emulator/test/driver_SUITE_data/otp_6879_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/otp_6879_drv.c
@@ -20,11 +20,11 @@
 #include <string.h>
 #include "erl_driver.h"
 
-static int call(ErlDrvData drv_data,
-		unsigned int command,
-		char *buf, int len,
-		char **rbuf, int rlen,
-		unsigned int *flags);
+static ErlDrvSSizeT call(ErlDrvData drv_data,
+			 unsigned int command,
+			 char *buf, ErlDrvSizeT len,
+			 char **rbuf, ErlDrvSizeT rlen,
+			 unsigned int *flags);
 
 static ErlDrvEntry otp_6879_drv_entry = { 
     NULL /* init */,
@@ -57,11 +57,11 @@ DRIVER_INIT(otp_6879_drv)
 }
 
 
-static int call(ErlDrvData drv_data,
-		unsigned int command,
-		char *buf, int len,
-		char **rbuf, int rlen,
-		unsigned int *flags)
+static ErlDrvSSizeT call(ErlDrvData drv_data,
+			 unsigned int command,
+			 char *buf, ErlDrvSizeT len,
+			 char **rbuf, ErlDrvSizeT rlen,
+			 unsigned int *flags)
 {
     /* echo call */
     if (len > rlen)
diff --git a/erts/emulator/test/driver_SUITE_data/otp_9302_drv.c b/erts/emulator/test/driver_SUITE_data/otp_9302_drv.c
index beee1b735f..221fd0ce51 100644
--- a/erts/emulator/test/driver_SUITE_data/otp_9302_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/otp_9302_drv.c
@@ -28,7 +28,7 @@ static void stop(ErlDrvData drv_data);
 static ErlDrvData start(ErlDrvPort port,
 			char *command);
 static void output(ErlDrvData drv_data,
-		   char *buf, int len);
+		   char *buf, ErlDrvSizeT len);
 static void ready_async(ErlDrvData drv_data,
 			ErlDrvThreadData thread_data);
 
@@ -196,13 +196,13 @@ static void ready_async(ErlDrvData drv_data,
 }
 
 static void output(ErlDrvData drv_data,
-		   char *buf, int len)
+		   char *buf, ErlDrvSizeT len)
 {
     Otp9302Data *data = (Otp9302Data *) drv_data;
     ErlDrvTermData td_port = driver_mk_port(data->port);
     ErlDrvTermData td_receiver = driver_caller(data->port);
     ErlDrvTermData td_job = driver_mk_atom("job");
-    unsigned int key = (unsigned int) data->port;
+    unsigned int key = (unsigned int) (ErlDrvSInt) data->port;
     long id[5];
     Otp9302AsyncData *ad[5];
     int i;
diff --git a/erts/emulator/test/driver_SUITE_data/outputv_drv.c b/erts/emulator/test/driver_SUITE_data/outputv_drv.c
index 87f66ae413..3e3d4a3a03 100644
--- a/erts/emulator/test/driver_SUITE_data/outputv_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/outputv_drv.c
@@ -3,7 +3,9 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData outputv_start(ErlDrvPort, char*);
-static void outputv_stop(ErlDrvData), outputv_read(ErlDrvData, char*, int), outputv(ErlDrvData, ErlIOVec*);
+static void outputv_stop(ErlDrvData),
+    outputv_read(ErlDrvData, char*, ErlDrvSizeT),
+    outputv(ErlDrvData, ErlIOVec*);
 
 static ErlDrvEntry outputv_driver_entry =
 {
@@ -19,6 +21,16 @@ static ErlDrvEntry outputv_driver_entry =
     NULL,
     NULL,
     outputv,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -38,7 +50,7 @@ static ErlDrvData outputv_start(ErlDrvPort port, char *buf)
     return (ErlDrvData)port;
 }
 
-static void outputv_read(ErlDrvData port, char *buf, int count)
+static void outputv_read(ErlDrvData port, char *buf, ErlDrvSizeT count)
 {
     erlang_port = (ErlDrvPort)-1;
 }
diff --git a/erts/emulator/test/driver_SUITE_data/peek_non_existing_queue_drv.c b/erts/emulator/test/driver_SUITE_data/peek_non_existing_queue_drv.c
index 3a5b5af13a..8e203f74ec 100644
--- a/erts/emulator/test/driver_SUITE_data/peek_non_existing_queue_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/peek_non_existing_queue_drv.c
@@ -66,7 +66,8 @@ typedef struct {
 
 static ErlDrvData start(ErlDrvPort, char *);
 static void stop(ErlDrvData);
-static int control(ErlDrvData, unsigned int, char *, int, char **, int);
+static ErlDrvSSizeT control(ErlDrvData, unsigned int,
+			    char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 static void ready_async(ErlDrvData, ErlDrvThreadData);
 static void async_test(void *);
 static void async_wait(void *);
@@ -121,10 +122,10 @@ static void stop(ErlDrvData drv_data)
     driver_free(drv_data);
 }
 
-static int control(ErlDrvData drv_data,
-		   unsigned int command,
-		   char *buf, int len,
-		   char **rbuf, int rlen)
+static ErlDrvSSizeT control(ErlDrvData drv_data,
+			    unsigned int command,
+			    char *buf, ErlDrvSizeT len,
+			    char **rbuf, ErlDrvSizeT rlen)
 {
     PeekNonXQDrvData *dp = (PeekNonXQDrvData *) drv_data;
     unsigned int key = 0;
@@ -158,7 +159,7 @@ static int control(ErlDrvData drv_data,
     }
 
  done: {
-	int res_len = strlen(res_str);
+	ErlDrvSSizeT res_len = strlen(res_str);
 	if (res_len > rlen) {
 	    char *abuf = driver_alloc(sizeof(char)*res_len);
 	    if (!abuf)
diff --git a/erts/emulator/test/driver_SUITE_data/queue_drv.c b/erts/emulator/test/driver_SUITE_data/queue_drv.c
index ded69f89f9..a02b57dc9a 100644
--- a/erts/emulator/test/driver_SUITE_data/queue_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/queue_drv.c
@@ -1,4 +1,5 @@
 #include <stdio.h>
+#include <string.h>
 #include "erl_driver.h"
 
 #define put_int32(i, s) {((char*)(s))[0] = (char)((i) >> 24) & 0xff; \
@@ -33,9 +34,10 @@
 static ErlDrvPort erlang_port;
 static unsigned opcode;		/* Opcode for next operation. */
 static ErlDrvData queue_start(ErlDrvPort, char*);
-static void queue_stop(ErlDrvData), queue_read(ErlDrvData, char*, int);
+static void queue_stop(ErlDrvData), queue_read(ErlDrvData, char*, ErlDrvSizeT);
 static void queue_outputv(ErlDrvData, ErlIOVec*);
-static int control(ErlDrvData, unsigned int, char*, int, char**, int);
+static ErlDrvSSizeT control(ErlDrvData, unsigned int,
+			    char*, ErlDrvSizeT, char**, ErlDrvSizeT);
 static ErlDrvBinary* read_head(ErlDrvPort, int bytes);
 
 static ErlDrvEntry queue_driver_entry =
@@ -52,6 +54,16 @@ static ErlDrvEntry queue_driver_entry =
     control,
     NULL,
     queue_outputv,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -73,7 +85,7 @@ static ErlDrvData queue_start(ErlDrvPort port, char *buf)
 }
 
 /* messages from Erlang */
-static void queue_read(ErlDrvData port, char *buf, int len)
+static void queue_read(ErlDrvData port, char *buf, ErlDrvSizeT len)
 {
 }
 
@@ -82,8 +94,9 @@ static void queue_stop(ErlDrvData port)
     erlang_port = (ErlDrvPort) -1;
 }
 
-static int
-control(ErlDrvData drv_data, unsigned command, char* buf, int len, char** rbuf, int rlen)
+static ErlDrvSSizeT
+control(ErlDrvData drv_data, unsigned command,
+	char* buf, ErlDrvSizeT len, char** rbuf, ErlDrvSizeT rlen)
 {
     ErlDrvBinary* b;
 
diff --git a/erts/emulator/test/driver_SUITE_data/sys_info_drv_impl.c b/erts/emulator/test/driver_SUITE_data/sys_info_drv_impl.c
index 2d3203ae5d..c6c70a2075 100644
--- a/erts/emulator/test/driver_SUITE_data/sys_info_drv_impl.c
+++ b/erts/emulator/test/driver_SUITE_data/sys_info_drv_impl.c
@@ -46,7 +46,8 @@
 #endif
 
 static ErlDrvData start(ErlDrvPort, char *);
-static int control(ErlDrvData, unsigned int, char *, int, char **, int);
+static ErlDrvSSizeT control(ErlDrvData, unsigned int,
+			    char *, ErlDrvSizeT, char **, ErlDrvSizeT);
 
 static ErlDrvEntry drv_entry = { 
     NULL /* init */,
@@ -84,13 +85,13 @@ start(ErlDrvPort port, char *command)
     return (ErlDrvData) port;
 }
 
-static int
+static ErlDrvSSizeT
 control(ErlDrvData drv_data,
 	unsigned int command,
-	char *buf, int len,
-	char **rbuf, int rlen)
+	char *buf, ErlDrvSizeT len,
+	char **rbuf, ErlDrvSizeT rlen)
 {
-    int res;
+    ErlDrvSSizeT res;
     char *str;
     size_t slen, slen2;
     ErlDrvPort port = (ErlDrvPort) drv_data;
diff --git a/erts/emulator/test/driver_SUITE_data/thr_alloc_drv.c b/erts/emulator/test/driver_SUITE_data/thr_alloc_drv.c
index c7edbba7f6..95a6ae9bdf 100644
--- a/erts/emulator/test/driver_SUITE_data/thr_alloc_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/thr_alloc_drv.c
@@ -21,14 +21,8 @@
 #include "erl_driver.h"
 
 ErlDrvData start(ErlDrvPort port, char *command);
-int control(ErlDrvData drv_data, unsigned int command, char *buf,
-	    int len, char **rbuf, int rlen);
-
-static int call(ErlDrvData drv_data,
-		unsigned int command,
-		char *buf, int len,
-		char **rbuf, int rlen,
-		unsigned int *flags);
+ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+		     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
 
 static ErlDrvEntry thr_alloc_drv_entry = { 
     NULL /* init */,
@@ -76,12 +70,12 @@ ErlDrvData start(ErlDrvPort port, char *command)
     return (ErlDrvData) port;
 }
 
-int control(ErlDrvData drv_data, unsigned int command, char *buf,
-	    int len, char **rbuf, int rlen)
+ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+		     ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
 {
     ErlDrvPort port = (ErlDrvPort) drv_data;
     char *result = "failure";
-    int result_len;
+    ErlDrvSSizeT result_len;
     if (len <= 20) {
 	int res;
 	ErlDrvTid tid;
diff --git a/erts/emulator/test/driver_SUITE_data/thr_free_drv.c b/erts/emulator/test/driver_SUITE_data/thr_free_drv.c
index 622a62ebea..c15059bcf4 100644
--- a/erts/emulator/test/driver_SUITE_data/thr_free_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/thr_free_drv.c
@@ -45,8 +45,8 @@ typedef struct {
 
 static ErlDrvData start(ErlDrvPort port, char *command);
 static void stop(ErlDrvData data);
-static int control(ErlDrvData drv_data, unsigned int command, char *buf,
-		   int len, char **rbuf, int rlen);
+static ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+			    ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
 
 static ErlDrvEntry thr_free_drv_entry = { 
     NULL /* init */,
@@ -194,14 +194,14 @@ static void stop(ErlDrvData drv_data)
     driver_free(td);
 }
 
-static int control(ErlDrvData drv_data, unsigned int command, char *buf,
-		   int len, char **rbuf, int rlen)
+static ErlDrvSSizeT control(ErlDrvData drv_data, unsigned int command, char *buf,
+			    ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
 {
     test_data *td = (test_data *) drv_data;
     char *result = "failure";
     int i, b;
     int res;
-    int result_len;
+    ErlDrvSSizeT result_len;
 
     if (td->b == -1) {
 	erl_drv_mutex_lock(td->ttd[0].mtx);
diff --git a/erts/emulator/test/driver_SUITE_data/timer_drv.c b/erts/emulator/test/driver_SUITE_data/timer_drv.c
index b96a95dd4c..70af662e5f 100644
--- a/erts/emulator/test/driver_SUITE_data/timer_drv.c
+++ b/erts/emulator/test/driver_SUITE_data/timer_drv.c
@@ -22,7 +22,9 @@
 
 static ErlDrvPort erlang_port;
 static ErlDrvData timer_start(ErlDrvPort, char*);
-static void timer_stop(ErlDrvData), timer_read(ErlDrvData, char*, int), timer(ErlDrvData);
+static void timer_stop(ErlDrvData),
+    timer_read(ErlDrvData, char*, ErlDrvSizeT),
+    timer(ErlDrvData);
 
 static ErlDrvEntry timer_driver_entry =
 {
@@ -38,6 +40,16 @@ static ErlDrvEntry timer_driver_entry =
     NULL,
     timer,
     NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    0,
+    NULL,
+    NULL,
     NULL
 };
 
@@ -57,8 +69,9 @@ static ErlDrvData timer_start(ErlDrvPort port, char *buf)
 }
 
 /* set the timer, this is monitored from erlang measuring the time */
-static void timer_read(ErlDrvData port, char *buf, int len)
+static void timer_read(ErlDrvData p, char *buf, ErlDrvSizeT len)
 {
+    ErlDrvPort port = (ErlDrvPort) p;
     char reply[1];
 
     if (buf[0] == START_TIMER) {