Merge branch 'rickard/port-optimizations/OTP-10336' into rickard/r16/port-optimizations/OTP-10336

* rickard/port-optimizations/OTP-10336:
  Change annotate level for emacs-22 in cerl
  Update etp-commands
  Add documentation on communication in Erlang
  Add support for busy port message queue
  Add driver callback epilogue
  Implement true asynchronous signaling between processes and ports
  Add erl_drv_[send|output]_term
  Move busy port flag
  Use rwlock for driver list
  Optimize management of port tasks
  Improve configuration of process and port tables
  Remove R9 compatibility features
  Use ptab functionality also for ports
  Prepare for use of ptab functionality also for ports
  Atomic port state
  Generalize process table implementation
  Implement functionality for delaying thread progress from unmanaged threads

Conflicts:
	erts/doc/src/erl_driver.xml
	erts/doc/src/erlang.xml
	erts/emulator/beam/beam_bif_load.c
	erts/emulator/beam/beam_bp.c
	erts/emulator/beam/beam_emu.c
	erts/emulator/beam/bif.c
	erts/emulator/beam/copy.c
	erts/emulator/beam/erl_alloc.c
	erts/emulator/beam/erl_alloc.types
	erts/emulator/beam/erl_bif_info.c
	erts/emulator/beam/erl_bif_port.c
	erts/emulator/beam/erl_bif_trace.c
	erts/emulator/beam/erl_init.c
	erts/emulator/beam/erl_message.c
	erts/emulator/beam/erl_port_task.c
	erts/emulator/beam/erl_process.c
	erts/emulator/beam/erl_process.h
	erts/emulator/beam/erl_process_lock.c
	erts/emulator/beam/erl_trace.c
	erts/emulator/beam/export.h
	erts/emulator/beam/global.h
	erts/emulator/beam/io.c
	erts/emulator/sys/unix/sys.c
	erts/emulator/sys/vxworks/sys.c
	erts/emulator/test/port_SUITE.erl
	erts/etc/unix/cerl.src
	erts/preloaded/ebin/erlang.beam
	erts/preloaded/ebin/prim_inet.beam
	erts/preloaded/src/prim_inet.erl
	lib/hipe/cerl/erl_bif_types.erl
	lib/kernel/doc/src/inet.xml
	lib/kernel/src/inet.erl

4 files changed, 112 insertions, 153 deletions

diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index ce014c19c2..474408ae7c 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -200,17 +200,6 @@ static void event_large_fd_error(ErlDrvPort, ErtsSysFdType, ErlDrvEventData);
 #endif
 static void steal_pending_stop_select(erts_dsprintf_buf_t*, ErlDrvPort,
 				      ErtsDrvEventState*, int mode, int on);
-static ERTS_INLINE Eterm
-drvport2id(ErlDrvPort dp)
-{
-    Port *pp = erts_drvport2port(dp);
-    if (pp)
-	return pp->id;
-    else {
-	ASSERT(0);
-	return am_undefined;
-    }
-}
 
 #ifdef ERTS_SMP
 ERTS_SCHED_PREF_QUICK_ALLOC_IMPL(removed_fd, struct removed_fd, 64, ERTS_ALC_T_FD_LIST)
@@ -378,7 +367,7 @@ abort_task(Eterm id, ErtsPortTaskHandle *pthp, EventStateType type)
 	       || !erts_port_task_is_scheduled(pthp));
     }
     else if (erts_port_task_is_scheduled(pthp)) {
-	erts_port_task_abort(id, pthp);
+	erts_port_task_abort(pthp);
 	ASSERT(erts_is_port_alive(id));
     }
 }
@@ -492,7 +481,7 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
 			       int on)
 {
     void (*stop_select_fn)(ErlDrvEvent, void*) = NULL;
-    Eterm id = drvport2id(ix);
+    Eterm id = erts_drvport2id(ix);
     ErtsSysFdType fd = (ErtsSysFdType) e;
     ErtsPollEvents ctl_events = (ErtsPollEvents) 0;
     ErtsPollEvents new_events, old_events;
@@ -503,8 +492,8 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
     DTRACE_CHARBUF(name, 64);
 #endif
     
-    ERTS_SMP_LC_ASSERT(erts_drvport2port(ix)
-		       && erts_lc_is_port_locked(erts_drvport2port(ix)));
+    ERTS_SMP_LC_ASSERT(erts_drvport2port(ix, NULL)
+		       && erts_lc_is_port_locked(erts_drvport2port(ix, NULL)));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     if ((unsigned)fd >= (unsigned)erts_smp_atomic_read_nob(&drv_ev_state_len)) {
@@ -530,9 +519,9 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
     if (!on && (mode&ERL_DRV_USE_NO_CALLBACK) == ERL_DRV_USE) {
 	if (IS_FD_UNKNOWN(state)) {
 	    /* fast track to stop_select callback */
-	    stop_select_fn = erts_drvport2port(ix)->drv_ptr->stop_select;
+	    stop_select_fn = erts_drvport2port(ix, NULL)->drv_ptr->stop_select;
 #ifdef USE_VM_PROBES
-	    strncpy(name, erts_drvport2port(ix)->drv_ptr->name, sizeof(name)-1);
+	    strncpy(name, erts_drvport2port(ix, NULL)->drv_ptr->name, sizeof(name)-1);
 	    name[sizeof(name)-1] = '\0';
 #endif
 	    ret = 0;
@@ -665,14 +654,14 @@ ERTS_CIO_EXPORT(driver_select)(ErlDrvPort ix,
 		}
 	    }
 	    if ((mode & ERL_DRV_USE_NO_CALLBACK) == ERL_DRV_USE) {
-		erts_driver_t* drv_ptr = erts_drvport2port(ix)->drv_ptr;
+		erts_driver_t* drv_ptr = erts_drvport2port(ix, NULL)->drv_ptr;
 		ASSERT(new_events==0);
 		if (state->remove_cnt == 0 || !wake_poller) {
 		    /* Safe to close fd now as it is not in pollset
 		       or there was no need to eject fd (kernel poll) */
 		    stop_select_fn = drv_ptr->stop_select;
 #ifdef USE_VM_PROBES
-		    strncpy(name, erts_drvport2port(ix)->drv_ptr->name, sizeof(name)-1);
+		    strncpy(name, erts_drvport2port(ix, NULL)->drv_ptr->name, sizeof(name)-1);
 		    name[sizeof(name)-1] = '\0';
 #endif
 		}
@@ -719,13 +708,13 @@ ERTS_CIO_EXPORT(driver_event)(ErlDrvPort ix,
     ErtsPollEvents events;
     ErtsPollEvents add_events;
     ErtsPollEvents remove_events;
-    Eterm id = drvport2id(ix);
+    Eterm id = erts_drvport2id(ix);
     ErtsDrvEventState *state;
     int do_wake = 0;
     int ret;
 
-    ERTS_SMP_LC_ASSERT(erts_drvport2port(ix)
-		       && erts_lc_is_port_locked(erts_drvport2port(ix)));
+    ERTS_SMP_LC_ASSERT(erts_drvport2port(ix, NULL)
+		       && erts_lc_is_port_locked(erts_drvport2port(ix, NULL)));
 
 #ifdef ERTS_SYS_CONTINOUS_FD_NUMBERS
     if ((unsigned)fd >= (unsigned)erts_smp_atomic_read_nob(&drv_ev_state_len)) {
@@ -960,7 +949,7 @@ static void
 print_select_op(erts_dsprintf_buf_t *dsbufp,
 		ErlDrvPort ix, ErtsSysFdType fd, int mode, int on)
 {
-    Port *pp = erts_drvport2port(ix);
+    Port *pp = erts_drvport2port(ix, NULL);
     erts_dsprintf(dsbufp,
 		  "driver_select(%p, %d,%s%s%s%s, %d) "
 		  "by ",
@@ -971,8 +960,8 @@ print_select_op(erts_dsprintf_buf_t *dsbufp,
 		  mode & ERL_DRV_USE ? " ERL_DRV_USE" : "",
 		  mode & (ERL_DRV_USE_NO_CALLBACK & ~ERL_DRV_USE) ? "_NO_CALLBACK" : "",
 		  on);
-    print_driver_name(dsbufp, pp->id);
-    erts_dsprintf(dsbufp, "driver %T ", pp ? pp->id : NIL);
+    print_driver_name(dsbufp, pp->common.id);
+    erts_dsprintf(dsbufp, "driver %T ", pp ? pp->common.id : NIL);
 }
 
 static void
@@ -1031,7 +1020,7 @@ steal_pending_stop_select(erts_dsprintf_buf_t *dsbufp, ErlDrvPort ix,
 	state->driver.drv_ptr = NULL;
     }
     else if ((mode & ERL_DRV_USE_NO_CALLBACK) == ERL_DRV_USE) {
-	erts_driver_t* drv_ptr = erts_drvport2port(ix)->drv_ptr;
+	erts_driver_t* drv_ptr = erts_drvport2port(ix, NULL)->drv_ptr;
 	if (drv_ptr != state->driver.drv_ptr) {
 	    /* Some other driver wants the stop_select callback */
 	    if (state->driver.drv_ptr->handle) {
@@ -1053,7 +1042,7 @@ static void
 print_event_op(erts_dsprintf_buf_t *dsbufp,
 	       ErlDrvPort ix, ErtsSysFdType fd, ErlDrvEventData event_data)
 {
-    Port *pp = erts_drvport2port(ix);
+    Port *pp = erts_drvport2port(ix, NULL);
     erts_dsprintf(dsbufp, "driver_event(%p, %d, ", ix, (int) fd);
     if (!event_data)
 	erts_dsprintf(dsbufp, "NULL");
@@ -1062,8 +1051,8 @@ print_event_op(erts_dsprintf_buf_t *dsbufp,
 		      (unsigned int) event_data->events,
 		      (unsigned int) event_data->revents);
     erts_dsprintf(dsbufp, ") by ");
-    print_driver_name(dsbufp, pp->id);
-    erts_dsprintf(dsbufp, "driver %T ", pp ? pp->id : NIL);
+    print_driver_name(dsbufp, pp->common.id);
+    erts_dsprintf(dsbufp, "driver %T ", pp ? pp->common.id : NIL);
 }
 
 static void
@@ -1100,8 +1089,7 @@ iready(Eterm id, ErtsDrvEventState *state)
     if (erts_port_task_schedule(id,
 				&state->driver.select->intask,
 				ERTS_PORT_TASK_INPUT,
-				(ErlDrvEvent) state->fd,
-				NULL) != 0) {
+				(ErlDrvEvent) state->fd) != 0) {
 	stale_drv_select(id, state, ERL_DRV_READ);
     }
 }
@@ -1112,8 +1100,7 @@ oready(Eterm id, ErtsDrvEventState *state)
     if (erts_port_task_schedule(id,
 				&state->driver.select->outtask,
 				ERTS_PORT_TASK_OUTPUT,
-				(ErlDrvEvent) state->fd,
-				NULL) != 0) {
+				(ErlDrvEvent) state->fd) != 0) {
 	stale_drv_select(id, state, ERL_DRV_WRITE);
     }
 }
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index 9e7cbc017f..0b96eded76 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -123,7 +123,8 @@ struct ErtsSysReportExit_ {
 
 /* This data is shared by these drivers - initialized by spawn_init() */
 static struct driver_data {
-    int port_num, ofd, packet_bytes;
+    ErlDrvPort port_num;
+    int ofd, packet_bytes;
     ErtsSysReportExit *report_exit;
     int pid;
     int alive;
@@ -731,7 +732,8 @@ prepare_crash_dump(int secs)
 	list = CONS(hp, make_small(8), list); hp += 2;
 
 	/* send to heart port, CMD = 8, i.e. prepare crash dump =o */
-	erts_write_to_port(ERTS_INVALID_PID, heart_port, list);
+	erts_port_output(NULL, ERTS_PORT_SIG_FLG_FORCE_IMM_CALL, heart_port,
+			 heart_port->common.id, list, NULL);
     }
 
     /* Make sure we unregister at epmd (unknown fd) and get at least
@@ -1182,7 +1184,7 @@ static RETSIGTYPE onchld(int signum)
 #endif
 }
 
-static int set_driver_data(int port_num,
+static int set_driver_data(ErlDrvPort port_num,
 			   int ifd,
 			   int ofd,
 			   int packet_bytes,
@@ -1190,6 +1192,7 @@ static int set_driver_data(int port_num,
 			   int exit_status,
 			   int pid)
 {
+    Port *prt;
     ErtsSysReportExit *report_exit;
 
     if (!exit_status)
@@ -1198,7 +1201,7 @@ static int set_driver_data(int port_num,
 	report_exit = erts_alloc(ERTS_ALC_T_PRT_REP_EXIT,
 				 sizeof(ErtsSysReportExit));
 	report_exit->next = report_exit_list;
-	report_exit->port = erts_port[port_num].id;
+	report_exit->port = erts_drvport2id(port_num);
 	report_exit->pid = pid;
 	report_exit->ifd = read_write & DO_READ ? ifd : -1;
 	report_exit->ofd = read_write & DO_WRITE ? ofd : -1;
@@ -1208,7 +1211,9 @@ static int set_driver_data(int port_num,
 	report_exit_list = report_exit;
     }
 
-    erts_port[port_num].os_pid = pid;
+    prt = erts_drvport2port(port_num, NULL);
+    if (prt)
+	prt->os_pid = pid;
 
     if (read_write & DO_READ) {
 	driver_data[ifd].packet_bytes = packet_bytes;
@@ -1281,7 +1286,7 @@ static void close_pipes(int ifd[2], int ofd[2], int read_write)
     }
 }
 
-static void init_fd_data(int fd, int prt)
+static void init_fd_data(int fd, ErlDrvPort port_num)
 {
     fd_data[fd].buf = NULL;
     fd_data[fd].cpos = NULL;
@@ -1971,7 +1976,7 @@ static void clear_fd_data(int fd)
     fd_data[fd].psz = 0;
 }
 
-static void nbio_stop_fd(int prt, int fd)
+static void nbio_stop_fd(ErlDrvPort prt, int fd)
 {
     driver_select(prt,fd,DO_READ|DO_WRITE,0);
     clear_fd_data(fd);
@@ -2019,7 +2024,8 @@ static ErlDrvData vanilla_start(ErlDrvPort port_num, char* name,
 
 static void stop(ErlDrvData fd)
 {
-    int prt, ofd;
+    ErlDrvPort prt;
+    int ofd;
 
     prt = driver_data[(int)(long)fd].port_num;
     nbio_stop_fd(prt, (int)(long)fd);
@@ -2032,7 +2038,7 @@ static void stop(ErlDrvData fd)
 
     CHLD_STAT_LOCK;
 
-    /* Mark as unused. Maybe resetting the 'port_num' slot is better? */
+    /* Mark as unused. */
     driver_data[(int)(long)fd].pid = -1;
 
     CHLD_STAT_UNLOCK;
@@ -2048,7 +2054,7 @@ static void stop(ErlDrvData fd)
 static void outputv(ErlDrvData e, ErlIOVec* ev)
 {
     int fd = (int)(long)e;
-    int ix = driver_data[fd].port_num;
+    ErlDrvPort ix = driver_data[fd].port_num;
     int pb = driver_data[fd].packet_bytes;
     int ofd = driver_data[fd].ofd;
     ssize_t n;
@@ -2098,7 +2104,7 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
 static void output(ErlDrvData e, char* buf, ErlDrvSizeT len)
 {
     int fd = (int)(long)e;
-    int ix = driver_data[fd].port_num;
+    ErlDrvPort ix = driver_data[fd].port_num;
     int pb = driver_data[fd].packet_bytes;
     int ofd = driver_data[fd].ofd;
     ssize_t n;
@@ -2149,7 +2155,7 @@ static void output(ErlDrvData e, char* buf, ErlDrvSizeT len)
     return; /* 0; */
 }
 
-static int port_inp_failure(int port_num, int ready_fd, int res)
+static int port_inp_failure(ErlDrvPort port_num, int ready_fd, int res)
 				/* Result: 0 (eof) or -1 (error) */
 {
     int err = errno;
@@ -2199,7 +2205,7 @@ static int port_inp_failure(int port_num, int ready_fd, int res)
 static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
 {
     int fd = (int)(long)e;
-    int port_num;
+    ErlDrvPort port_num;
     int packet_bytes;
     int res;
     Uint h;
@@ -2322,7 +2328,7 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
 static void ready_output(ErlDrvData e, ErlDrvEvent ready_fd)
 {
     int fd = (int)(long)e;
-    int ix = driver_data[fd].port_num;
+    ErlDrvPort ix = driver_data[fd].port_num;
     int n;
     struct iovec* iv;
     int vsize;
@@ -2631,19 +2637,20 @@ report_exit_status(ErtsSysReportExit *rep, int status)
     Port *pp;
 #ifdef ERTS_SMP
     CHLD_STAT_UNLOCK;
-#endif
+    pp = erts_thr_id2port_sflgs(rep->port,
+				ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP);
+    CHLD_STAT_LOCK;
+#else
     pp = erts_id2port_sflgs(rep->port,
 			    NULL,
 			    0,
 			    ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP);
-#ifdef ERTS_SMP
-    CHLD_STAT_LOCK;
 #endif
     if (pp) {
 	if (rep->ifd >= 0) {
 	    driver_data[rep->ifd].alive = 0;
 	    driver_data[rep->ifd].status = status;
-	    (void) driver_select((ErlDrvPort) internal_port_index(pp->id),
+	    (void) driver_select((ErlDrvPort) pp,
 				 rep->ifd,
 				 (ERL_DRV_READ|ERL_DRV_USE),
 				 1);
@@ -2651,12 +2658,16 @@ report_exit_status(ErtsSysReportExit *rep, int status)
 	if (rep->ofd >= 0) {
 	    driver_data[rep->ofd].alive = 0;
 	    driver_data[rep->ofd].status = status;
-	    (void) driver_select((ErlDrvPort) internal_port_index(pp->id),
+	    (void) driver_select((ErlDrvPort) pp,
 				 rep->ofd,
 				 (ERL_DRV_WRITE|ERL_DRV_USE),
 				 1);
 	}
+#ifdef ERTS_SMP
+	erts_thr_port_release(pp);
+#else
 	erts_port_release(pp);
+#endif
     }
     erts_free(ERTS_ALC_T_PRT_REP_EXIT, rep);
 }
diff --git a/erts/emulator/sys/win32/erl_win_dyn_driver.h b/erts/emulator/sys/win32/erl_win_dyn_driver.h
index ec5141838a..8b6be2b2f1 100644
--- a/erts/emulator/sys/win32/erl_win_dyn_driver.h
+++ b/erts/emulator/sys/win32/erl_win_dyn_driver.h
@@ -74,7 +74,9 @@ WDD_TYPEDEF(ErlDrvTermData, driver_mk_port,(ErlDrvPort));
 WDD_TYPEDEF(ErlDrvTermData, driver_connected,(ErlDrvPort));
 WDD_TYPEDEF(ErlDrvTermData, driver_caller,(ErlDrvPort));
 WDD_TYPEDEF(ErlDrvTermData, driver_mk_term_nil,(void));
+WDD_TYPEDEF(int, erl_drv_output_term, (ErlDrvTermData, ErlDrvTermData*, int));
 WDD_TYPEDEF(int, driver_output_term, (ErlDrvPort, ErlDrvTermData*, int));
+WDD_TYPEDEF(int, erl_drv_send_term, (ErlDrvTermData, ErlDrvTermData, ErlDrvTermData*, int));
 WDD_TYPEDEF(int, driver_send_term, (ErlDrvPort, ErlDrvTermData, ErlDrvTermData*, int));
 WDD_TYPEDEF(long, driver_async, (ErlDrvPort,unsigned int*,void (*)(void*),void*,void (*)(void*)));
 WDD_TYPEDEF(int, driver_async_cancel, (unsigned int));
@@ -187,7 +189,9 @@ typedef struct {
     WDD_FTYPE(driver_connected) *driver_connected;
     WDD_FTYPE(driver_caller) *driver_caller;
     WDD_FTYPE(driver_mk_term_nil) *driver_mk_term_nil;
+    WDD_FTYPE(erl_drv_output_term) *erl_drv_output_term;
     WDD_FTYPE(driver_output_term) *driver_output_term;
+    WDD_FTYPE(erl_drv_send_term) *erl_drv_send_term;
     WDD_FTYPE(driver_send_term) *driver_send_term;
     WDD_FTYPE(driver_async) *driver_async;
     WDD_FTYPE(driver_async_cancel) *driver_async_cancel;
@@ -294,7 +298,9 @@ extern TWinDynDriverCallbacks WinDynDriverCallbacks;
 #define driver_connected (WinDynDriverCallbacks.driver_connected)
 #define driver_caller (WinDynDriverCallbacks.driver_caller)
 #define driver_mk_term_nil (WinDynDriverCallbacks.driver_mk_term_nil)
+#define erl_drv_output_term (WinDynDriverCallbacks.erl_drv_output_term)
 #define driver_output_term (WinDynDriverCallbacks.driver_output_term)
+#define erl_drv_send_term (WinDynDriverCallbacks.erl_drv_send_term)
 #define driver_send_term (WinDynDriverCallbacks.driver_send_term)
 #define driver_async (WinDynDriverCallbacks.driver_async)
 #define driver_async_cancel (WinDynDriverCallbacks.driver_async_cancel)
@@ -425,7 +431,9 @@ do {				                        \
 ((W).driver_connected) = driver_connected;		\
 ((W).driver_caller) = driver_caller;			\
 ((W).driver_mk_term_nil) = driver_mk_term_nil;		\
+((W).erl_drv_output_term) = erl_drv_output_term;	\
 ((W).driver_output_term) = driver_output_term;		\
+((W).erl_drv_send_term) = erl_drv_send_term;		\
 ((W).driver_send_term) = driver_send_term;		\
 ((W).driver_async) = driver_async;			\
 ((W).driver_async_cancel) = driver_async_cancel;	\
diff --git a/erts/emulator/sys/win32/sys.c b/erts/emulator/sys/win32/sys.c
index f19f4ebd8c..1cd9072cea 100755
--- a/erts/emulator/sys/win32/sys.c
+++ b/erts/emulator/sys/win32/sys.c
@@ -87,9 +87,6 @@ static erts_smp_tsd_key_t win32_errstr_key;
 
 static erts_smp_atomic_t pipe_creation_counter;
 
-static erts_smp_mtx_t sys_driver_data_lock;
-
-
 /* Results from application_type(_w) is one of */
 #define APPL_NONE 0
 #define APPL_DOS  1
@@ -97,7 +94,6 @@ static erts_smp_mtx_t sys_driver_data_lock;
 #define APPL_WIN32 3
 
 static int driver_write(long, HANDLE, byte*, int);
-static void common_stop(int);
 static int create_file_thread(struct async_io* aio, int mode);
 #ifdef ERTS_SMP
 static void close_active_handle(ErlDrvPort, HANDLE handle);
@@ -115,9 +111,6 @@ BOOL WINAPI ctrl_handler(DWORD dwCtrlType);
 
 #define PORT_BUFSIZ 4096
 
-#define PORT_FREE (-1)
-#define PORT_EXITING (-2)
-
 #define DRV_BUF_ALLOC(SZ) \
   erts_alloc_fnf(ERTS_ALC_T_DRV_DATA_BUF, (SZ))
 #define DRV_BUF_REALLOC(P, SZ) \
@@ -269,7 +262,8 @@ int erts_sys_prepare_crash_dump(int secs)
 	list = CONS(hp, make_small(8), list); hp += 2;
 
 	/* send to heart port, CMD = 8, i.e. prepare crash dump =o */
-	erts_write_to_port(NIL, heart_port, list);
+	erts_port_output(NULL, ERTS_PORT_SIG_FLG_FORCE_IMM_CALL, heart_port,
+			 heart_port->common.id, list, NULL);
 
 	return 1;
     }
@@ -474,7 +468,7 @@ typedef struct driver_data {
     byte *inbuf;		/* Buffer to use for overlapped read. */
     int outBufSize;		/* Size of output buffer. */
     byte *outbuf;		/* Buffer to use for overlapped write. */
-    ErlDrvPort port_num;		/* The port number. */
+    ErlDrvPort port_num;	/* The port handle. */
     int packet_bytes;		/* 0: continous stream, 1, 2, or 4: the number
 				 * of bytes in the packet header.
 				 */
@@ -484,8 +478,6 @@ typedef struct driver_data {
     int report_exit;            /* Do report exit status for the port */
 } DriverData;
 
-static DriverData* driver_data;	/* Pointer to array of driver data. */
-
 /* Driver interfaces */
 static ErlDrvData spawn_start(ErlDrvPort, char*, SysDriverOpts*);
 static ErlDrvData fd_start(ErlDrvPort, char*, SysDriverOpts*);
@@ -597,67 +589,53 @@ struct erl_drv_entry vanilla_driver_entry = {
  */
 
 static DriverData*
-new_driver_data(int port_num, int packet_bytes, int wait_objs_required, int use_threads)
+new_driver_data(ErlDrvPort port_num, int packet_bytes, int wait_objs_required, int use_threads)
 {
     DriverData* dp;
-    
-    erts_smp_mtx_lock(&sys_driver_data_lock);
 
-    DEBUGF(("new_driver_data(port_num %d, pb %d)\n",
-	    port_num, packet_bytes));
+    DEBUGF(("new_driver_data(%p, pb %d)\n", port_num, packet_bytes));
 
+    dp = driver_alloc(sizeof(DriverData));
+    if (!dp)
+	return NULL;
     /*
      * We used to test first at all that there is enough room in the
      * array used by WaitForMultipleObjects(), but that is not necessary
      * any more, since driver_select() can't fail.
      */
 
-    /*
-     * Search for a free slot.
-     */
+    dp->bytesInBuffer = 0;
+    dp->totalNeeded = packet_bytes;
+    dp->inBufSize = PORT_BUFSIZ;
+    dp->inbuf = DRV_BUF_ALLOC(dp->inBufSize);
+    if (dp->inbuf == NULL)
+	goto buf_alloc_error;
+    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
+    dp->outBufSize = 0;
+    dp->outbuf = NULL;
+    dp->port_num = port_num;
+    dp->packet_bytes = packet_bytes;
+    dp->port_pid = INVALID_HANDLE_VALUE;
+    if (init_async_io(&dp->in, use_threads) == -1)
+	goto async_io_error1;
+    if (init_async_io(&dp->out, use_threads) == -1)
+	goto async_io_error2;
 
-    for (dp = driver_data; dp < driver_data+max_files; dp++) {
-	if (dp->port_num == PORT_FREE) {
-	    dp->bytesInBuffer = 0;
-	    dp->totalNeeded = packet_bytes;
-	    dp->inBufSize = PORT_BUFSIZ;
-	    dp->inbuf = DRV_BUF_ALLOC(dp->inBufSize);
-	    if (dp->inbuf == NULL) {
-		erts_smp_mtx_unlock(&sys_driver_data_lock);
-		return NULL;
-	    }
-	    erts_smp_atomic_add_nob(&sys_misc_mem_sz, dp->inBufSize);
-	    dp->outBufSize = 0;
-	    dp->outbuf = NULL;
-	    dp->port_num = port_num;
-	    dp->packet_bytes = packet_bytes;
-	    dp->port_pid = INVALID_HANDLE_VALUE;
-	    if (init_async_io(&dp->in, use_threads) == -1)
-		break;
-	    if (init_async_io(&dp->out, use_threads) == -1)
-		break;
-	    erts_smp_mtx_unlock(&sys_driver_data_lock);
-	    return dp;
-	}
-    }
+    return dp;
 
-    /*
-     * Error or no free driver data.
-     */
+async_io_error2:
+    release_async_io(&dp->in, dp->port_num);
+async_io_error1:
+    release_async_io(&dp->out, dp->port_num);
 
-    if (dp < driver_data+max_files) {
-	release_async_io(&dp->in, dp->port_num);
-	release_async_io(&dp->out, dp->port_num);
-    }
-    erts_smp_mtx_unlock(&sys_driver_data_lock);
+buf_alloc_error:
+    driver_free(dp);
     return NULL;
 }
 
 static void
 release_driver_data(DriverData* dp)
 {
-    erts_smp_mtx_lock(&sys_driver_data_lock);
-
 #ifdef ERTS_SMP
 #ifdef USE_CANCELIOEX
     if (fpCancelIoEx != NULL) {
@@ -741,8 +719,7 @@ release_driver_data(DriverData* dp)
      * the exit thread.
      */
 
-    dp->port_num = PORT_FREE;
-    erts_smp_mtx_unlock(&sys_driver_data_lock);
+    driver_free(dp);
 }
 
 #ifdef ERTS_SMP
@@ -837,7 +814,6 @@ threaded_handle_closer(LPVOID param)
 static ErlDrvData
 set_driver_data(DriverData* dp, HANDLE ifd, HANDLE ofd, int read_write, int report_exit)
 {
-    int index = dp - driver_data;
     int result;
 
     dp->in.fd = ifd;
@@ -856,13 +832,12 @@ set_driver_data(DriverData* dp, HANDLE ifd, HANDLE ofd, int read_write, int repo
 			       ERL_DRV_WRITE|ERL_DRV_USE, 1);
 	ASSERT(result != -1);
     }
-    return (ErlDrvData)index;
+    return (ErlDrvData) dp;
 }
 
 static ErlDrvData
 reuse_driver_data(DriverData *dp, HANDLE ifd, HANDLE ofd, int read_write, ErlDrvPort port_num)
 {
-    int index = dp - driver_data;
     int result;
 
     dp->port_num = port_num;
@@ -881,7 +856,7 @@ reuse_driver_data(DriverData *dp, HANDLE ifd, HANDLE ofd, int read_write, ErlDrv
 			       ERL_DRV_WRITE|ERL_DRV_USE, 1);
 	ASSERT(result != -1);
     }
-    return (ErlDrvData)index;
+    return (ErlDrvData) dp;
 }
 
 /*
@@ -1154,12 +1129,6 @@ spawn_init(void)
 	((module != NULL) ? GetProcAddress(module,"CancelIoEx") : NULL);
     DEBUGF(("fpCancelIoEx = %p\r\n", fpCancelIoEx));
 #endif
-    driver_data = (struct driver_data *)
-	erts_alloc(ERTS_ALC_T_DRV_TAB, max_files * sizeof(struct driver_data));
-    erts_smp_atomic_add_nob(&sys_misc_mem_sz,
-			    max_files*sizeof(struct driver_data));
-    for (i = 0; i < max_files; i++)
-	driver_data[i].port_num = PORT_FREE;
 
     return 0;
 }
@@ -1290,9 +1259,12 @@ spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
 #endif
 	retval = set_driver_data(dp, hFromChild, hToChild, opts->read_write,
 				 opts->exit_status);
-	if (retval != ERL_DRV_ERROR_GENERAL && retval != ERL_DRV_ERROR_ERRNO)
-	    /* We assume that this cannot generate a negative number */
-	    erts_port[port_num].os_pid = (SWord) pid;
+	if (retval != ERL_DRV_ERROR_GENERAL && retval != ERL_DRV_ERROR_ERRNO) {
+	    Port *prt = erts_drvport2port_raw(port_num);
+		/* We assume that this cannot generate a negative number */
+	    ASSERT(prt);
+	    prt->os_pid = (SWord) pid;
+	}
     }
     
     if (retval != ERL_DRV_ERROR_GENERAL && retval != ERL_DRV_ERROR_ERRNO)
@@ -2281,12 +2253,10 @@ fd_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
 	 **/
 
 	if (!create_file_thread(&dp->in, DO_READ)) {
-	    dp->port_num = PORT_FREE;
 	    return ERL_DRV_ERROR_GENERAL;
 	}
 	
 	if (!create_file_thread(&dp->out, DO_WRITE)) {
-	    dp->port_num = PORT_FREE;
 	    return ERL_DRV_ERROR_GENERAL;
 	}
 	
@@ -2306,10 +2276,9 @@ fd_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
     }
 }
 
-static void fd_stop(ErlDrvData d)
+static void fd_stop(ErlDrvData data)
 {
-  int fd = (int)d;
-  DriverData* dp = driver_data+fd;
+  DriverData * dp = (DriverData *) data;
   /*
    * There's no way we can terminate an fd port in a consistent way.
    * Instead we let it live until it's opened again (which it is,
@@ -2372,16 +2341,10 @@ vanilla_start(ErlDrvPort port_num, char* name, SysDriverOpts* opts)
 }
 
 static void
-stop(ErlDrvData index)
-{
-    common_stop((int)index);
-}
-
-static void common_stop(int index)
+stop(ErlDrvData data)
 {
-    DriverData* dp = driver_data+index;
-
-    DEBUGF(("common_stop(%d)\n", index));
+    DriverData *dp = (DriverData *) data;
+    DEBUGF(("stop(%p)\n", dp));
 
     if (dp->in.ov.hEvent != NULL) {
 	(void) driver_select(dp->port_num,
@@ -2403,7 +2366,6 @@ static void common_stop(int index)
 	 */
 	HANDLE thread;
 	DWORD tid;
-	dp->port_num = PORT_EXITING;
 	thread = (HANDLE *) _beginthreadex(NULL, 0, threaded_exiter, dp, 0, &tid);
 	CloseHandle(thread);
     }
@@ -2528,22 +2490,17 @@ threaded_exiter(LPVOID param)
 
 static void
 output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
-/*     long drv_data;		/* The slot to use in the driver data table.
+/*     ErlDrvData drv_data;	/* The slot to use in the driver data table.
 				 * For Windows NT, this is *NOT* a file handle.
 				 * The handle is found in the driver data.
 				 */
 /*     char *buf;		/* Pointer to data to write to the port program. */
 /*     ErlDrvSizeT len;		/* Number of bytes to write. */
 {
-    DriverData* dp;
+    DriverData* dp = (DriverData *) drv_data;
     int pb;			/* The header size for this port. */
-    int port_num;		/* The actual port number (for diagnostics). */
     char* current;
 
-    dp = driver_data + (int)drv_data;
-    if ((port_num = dp->port_num) == -1)
-	return ; /*-1;*/
-
     pb = dp->packet_bytes;
 
     if ((pb+len) == 0)
@@ -2554,7 +2511,7 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
      */
 
     if ((pb == 2 && len > 65535) || (pb == 1 && len > 255)) {
-	driver_failure_posix(port_num, EINVAL);
+	driver_failure_posix(dp->port_num, EINVAL);
 	return ; /* -1; */
     }
 
@@ -2568,7 +2525,7 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
     ASSERT(!dp->outbuf);
     dp->outbuf = DRV_BUF_ALLOC(pb+len);
     if (!dp->outbuf) {
-	driver_failure_posix(port_num, ENOMEM);
+	driver_failure_posix(dp->port_num, ENOMEM);
 	return ; /* -1; */
     }
 
@@ -2598,7 +2555,7 @@ output(ErlDrvData drv_data, char* buf, ErlDrvSizeT len)
 	memcpy(current, buf, len);
     
     if (!async_write_file(&dp->out, dp->outbuf, pb+len)) {
-	set_busy_port(port_num, 1);
+	set_busy_port(dp->port_num, 1);
     } else {
 	dp->out.ov.Offset += pb+len; /* For vanilla driver. */
 	/* XXX OffsetHigh should be changed too. */
@@ -2633,10 +2590,9 @@ ready_input(ErlDrvData drv_data, ErlDrvEvent ready_event)
 {
     int error = 0;		/* The error code (assume initially no errors). */
     DWORD bytesRead;		/* Number of bytes read. */
-    DriverData* dp;
+    DriverData* dp = (DriverData *) drv_data;
     int pb;
 
-    dp = driver_data+(int)drv_data;
     pb = dp->packet_bytes;
 #ifdef ERTS_SMP
     if(dp->in.thread == (HANDLE) -1) {
@@ -2804,7 +2760,7 @@ static void
 ready_output(ErlDrvData drv_data, ErlDrvEvent ready_event)
 {
     DWORD bytesWritten;
-    DriverData* dp = driver_data + (int)drv_data;
+    DriverData *dp = (DriverData *) drv_data;
     int error;
 
 #ifdef ERTS_SMP
@@ -2812,7 +2768,7 @@ ready_output(ErlDrvData drv_data, ErlDrvEvent ready_event)
 	dp->out.async_io_active = 0;
     }
 #endif
-    DEBUGF(("ready_output(%d, 0x%x)\n", drv_data, ready_event));
+    DEBUGF(("ready_output(%p, 0x%x)\n", drv_data, ready_event));
     set_busy_port(dp->port_num, 0);
     if (!(dp->outbuf)) {
 	/* Happens because event sometimes get signalled during a successful
@@ -2867,7 +2823,7 @@ sys_init_io(void)
        can change our view of the number of open files possible.
        We estimate the number to twice the amount of ports. 
        We really dont know on windows, do we? */
-    max_files = 2*erts_max_ports;
+    max_files = 2*erts_ptab_max(&erts_port);
 }
 
 #ifdef ERTS_SMP
@@ -3322,9 +3278,6 @@ void erl_sys_init(void)
     noinherit_std_handle(STD_INPUT_HANDLE);
     noinherit_std_handle(STD_ERROR_HANDLE);
 
-
-    erts_smp_mtx_init(&sys_driver_data_lock, "sys_driver_data_lock");
-
 #ifdef ERTS_SMP
     erts_smp_tsd_key_create(&win32_errstr_key);
     InitializeCriticalSection(&htbc_lock);