The R13B03 release.OTP_R13B03

4 files changed, 1732 insertions, 0 deletions

diff --git a/lib/runtime_tools/c_src/Makefile b/lib/runtime_tools/c_src/Makefile
new file mode 100644
index 0000000000..19184f2e8d
--- /dev/null
+++ b/lib/runtime_tools/c_src/Makefile
@@ -0,0 +1,5 @@
+#
+# Invoke with GNU make or clearmake -C gnu.
+#
+include $(ERL_TOP)/make/run_make.mk
+
diff --git a/lib/runtime_tools/c_src/Makefile.in b/lib/runtime_tools/c_src/Makefile.in
new file mode 100644
index 0000000000..05b5598e51
--- /dev/null
+++ b/lib/runtime_tools/c_src/Makefile.in
@@ -0,0 +1,151 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1999-2009. All Rights Reserved.
+# 
+# The contents of this file are subject to the Erlang Public License,
+# Version 1.1, (the "License"); you may not use this file except in
+# compliance with the License. You should have received a copy of the
+# Erlang Public License along with this software. If not, it can be
+# retrieved online at http://www.erlang.org/.
+# 
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+# the License for the specific language governing rights and limitations
+# under the License.
+# 
+# %CopyrightEnd%
+#
+include $(ERL_TOP)/make/target.mk
+include $(ERL_TOP)/make/$(TARGET)/otp.mk
+
+# ----------------------------------------------------
+# Application version
+# ----------------------------------------------------
+include ../vsn.mk
+VSN=$(RUNTIME_TOOLS_VSN)
+
+# ----------------------------------------------------
+# The following variables differ on different systems, we set
+# reasonable defaults, if something different is needed it should
+# be set for that system only.
+# ----------------------------------------------------
+CC = @CC@
+CFLAGS = @DED_CFLAGS@
+LD = @DED_LD@
+SHELL = /bin/sh
+LIBS = @LIBS@
+LDFLAGS += @DED_LDFLAGS@
+ERLANG_OSTYPE = @ERLANG_OSTYPE@
+
+SYSINCLUDE = 	-I$(ERL_TOP)/erts/emulator/beam \
+		-I$(ERL_TOP)/erts/emulator/sys/$(ERLANG_OSTYPE) \
+		-I$(ERL_TOP)/erts/include/internal \
+		-I$(ERL_TOP)/erts/include/internal/$(ERLANG_OSTYPE) \
+		-I$(ERL_TOP)/erts/include \
+		-I$(ERL_TOP)/erts/include/$(ERLANG_OSTYPE)
+ifeq ($(findstring vxworks,$(TARGET)),vxworks)
+	SYSINCLUDE += -I$(ERL_TOP)/erts/etc/vxworks
+endif
+
+TRACE_DRV_INCLUDES = $(SYSINCLUDE)
+
+ALL_CFLAGS = $(CFLAGS) @DEFS@ $(TYPE_FLAGS) $(TRACE_DRV_INCLUDES)
+
+
+ifeq ($(TYPE),debug)
+TYPEMARKER = .debug
+TYPE_FLAGS = -g -DDEBUG @DEBUG_FLAGS@
+else
+TYPEMARKER =
+TYPE_FLAGS = -O2
+endif
+
+ROOTDIR = $(ERL_TOP)/lib
+PRIVDIR = ../priv
+LIBDIR = $(PRIVDIR)/lib/$(TARGET)
+OBJDIR = $(PRIVDIR)/obj/$(TARGET)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/runtime_tools-$(VSN)
+
+# ----------------------------------------------------
+# Misc Macros
+# ----------------------------------------------------
+TRACE_IP_DRV_OBJS = \
+	$(OBJDIR)/trace_ip_drv.o
+
+TRACE_FILE_DRV_OBJS = \
+	$(OBJDIR)/trace_file_drv.o
+
+ifeq ($(findstring win32,$(TARGET)), win32)
+SOLIBS = $(LIBDIR)/trace_ip_drv.dll $(LIBDIR)/trace_file_drv.dll
+LN=cp
+else
+ifeq ($(findstring vxworks,$(TARGET)),vxworks)
+SOLIBS = $(LIBDIR)/trace_ip_drv.eld $(LIBDIR)/trace_file_drv.eld
+else
+SOLIBS = $(LIBDIR)/trace_ip_drv.so $(LIBDIR)/trace_file_drv.so
+endif
+endif
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+debug opt: $(OBJDIR) $(BINDIR) $(SOLIBS)
+
+$(OBJDIR):
+	-@mkdir -p $(OBJDIR)
+
+$(BINDIR):
+	-@mkdir -p $(BINDIR)
+
+$(OBJDIR)/%.o: %.c
+	$(INSTALL_DIR) $(OBJDIR)
+	$(CC) -c -o $@ $(ALL_CFLAGS) $<
+
+$(LIBDIR)/trace_ip_drv.so: $(TRACE_IP_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ -lc $(LIBS)
+
+$(LIBDIR)/trace_file_drv.so: $(TRACE_FILE_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ -lc $(LIBS)
+
+$(LIBDIR)/trace_ip_drv.dll: $(TRACE_IP_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+$(LIBDIR)/trace_file_drv.dll: $(TRACE_FILE_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ $(LIBS)
+#
+# VxWorks is simply to different from Unix in this sense.
+# Here are the inference rules for VxWorks
+#
+$(LIBDIR)/trace_ip_drv.eld: $(TRACE_IP_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ 
+
+$(LIBDIR)/trace_file_drv.eld: $(TRACE_FILE_DRV_OBJS)
+	$(INSTALL_DIR) $(LIBDIR)
+	$(LD) $(LDFLAGS) -o $@ $^ 
+
+clean:
+	rm -f $(SOLIBS) $(TRACE_IP_DRV_OBJS) $(TRACE_FILE_DRV_OBJS)
+	rm -f core *~
+
+docs:
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+	$(INSTALL_DIR) $(RELSYSDIR)/priv/lib
+	$(INSTALL_PROGRAM) $(SOLIBS) $(RELSYSDIR)/priv/lib
+
+release_docs_spec:
+
diff --git a/lib/runtime_tools/c_src/trace_file_drv.c b/lib/runtime_tools/c_src/trace_file_drv.c
new file mode 100644
index 0000000000..482fcc0288
--- /dev/null
+++ b/lib/runtime_tools/c_src/trace_file_drv.c
@@ -0,0 +1,638 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1999-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+
+/*
+ * Purpose: Send trace messages to a file.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifdef __WIN32__
+#  include <io.h>
+#  define write _write
+#  define open _open
+#  define close _close
+#  define unlink _unlink
+#else
+#  include <unistd.h>
+#endif
+#include <errno.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#ifdef VXWORKS
+#  include "reclaim.h"
+#endif
+
+
+
+/*
+ * Deduce MAXPATHLEN, which is the one to use in this file, 
+ * from any available definition.
+ */
+#ifndef MAXPATHLEN
+#  ifdef PATH_MAX /* Posix */
+#    define MAXPATHLEN PATH_MAX
+#  else
+#    ifdef _POSIX_PATH_MAX /* Posix */
+#      define MAXPATHLEN _POSIX_PATH_MAX
+#    else
+#      ifdef MAXPATH
+#        define MAXPATHLEN MAXPATH
+#      else
+#        ifdef MAX_PATH
+#          define MAXPATHLEN MAX_PATH
+#        else
+#          ifdef _MAX_PATH
+#            define MAXPATHLEN _MAX_PATH
+#         else
+#            error Could not define MAXPATHLEN
+#          endif
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+
+
+#ifdef DEBUG
+#ifndef __WIN32__
+#define ASSERT(X) do {if (!(X)) {erl_exit(1,"%s",#X);} } while(0)
+#else
+#include <assert.h>
+#define ASSERT(X) assert(X)
+#endif
+#else
+#define ASSERT(X)
+#endif
+
+
+
+#include "erl_driver.h"
+
+
+
+/*
+** Protocol from driver:
+** '\0' -> ok
+** '\1' ++ String -> {error, Atom}
+**
+** Protocol when opening (arguments to start):
+** ["w <WrapSize> <WrapCnt> <TailIndex> "] "n <Filename>"
+** Where...
+** <Filename>, a string ('\0' terminated):
+**    The filename where the trace output is to be written.
+** "w ...", if present orders a size limited wrapping log.
+** <WrapSize>, an unsigned integer:
+**    The size limit of each log file.
+** <WrapCnt>, an unsigned integer:
+**    The number of log files.
+** <TailIndex>, an unsigned integer:
+**    The (zero based) index of where to insert the filename
+**    sequence count "a".."z","aa".."az","ba".."zz","aaa"...
+**
+** Port control messages handled:
+** 'f' -> '\0' (ok) | '\1' ++ String (error) : Flush file.
+**
+** The package written to the file looks like this:
+** +--+--------+-----------------------------------+
+** |Op|Size NBO|Term in external format or empty   |
+** +--+--------+-----------------------------------+
+** Op, a char, for conformance with the IP driver:
+**    0 = binary, 1 = drop
+**    If Op is 1, then Size reflects the number of dropped messages. The 
+**    op 1 is never used in this driver.
+** Size, a 32 bit interger in network byte order:
+**    Either the size of the binary term, or the number of packet's dropped.
+** Term, an array of bytes:
+**    An erlang term in the external format or simply empty if Op == 1, the
+**    term is Size long.
+*/ 
+
+typedef int FILETYPE;
+
+#define BUFFER_SIZE (BUFSIZ*8)
+
+#define OP_BINARY 0
+#define OP_DROP   1
+
+/*
+** State structures
+*/
+
+typedef struct trace_file_name {
+    char name[MAXPATHLEN+1]; /* Incl. space for terminating '\0' */
+    unsigned suffix;         /* Index of suffix start */
+    unsigned tail;           /* Index of tail start */
+    unsigned len;            /* Total length (strlen) */
+    unsigned cnt;            /* Current file count 0 <= cnt <= n */
+    unsigned n;              /* Number of files */
+} TraceFileName;
+
+typedef struct trace_file_wrap_data {
+    TraceFileName cur;  /* Current trace file */
+    TraceFileName del;  /* Next file to delete when wrapping */
+    unsigned      size; /* File max size */
+    int           cnt;  /* How many remains before starting to wrap */
+    unsigned long time; /* Time to pass until starting to delete old files */
+    unsigned      len;  /* Current file len */
+} TraceFileWrapData;
+
+typedef struct trace_file_data {
+    FILETYPE fd;
+    ErlDrvPort port;
+    struct trace_file_data *next, *prev;
+    TraceFileWrapData *wrap; /* == NULL => no wrap */
+    int buff_siz;
+    int buff_pos;
+    unsigned char buff[1]; /* You guessed it, will be longer... */
+} TraceFileData;
+
+static TraceFileData *first_data; 
+
+/*
+** Interface routines
+*/
+static ErlDrvData trace_file_start(ErlDrvPort port, char *buff);
+static void trace_file_stop(ErlDrvData handle);
+static void trace_file_output(ErlDrvData handle, char *buff, int bufflen);
+static void trace_file_finish(void);
+static int trace_file_control(ErlDrvData handle, unsigned int command, 
+			      char* buff, int count, 
+			      char** res, int res_size);
+static void trace_file_timeout(ErlDrvData handle);
+
+/*
+** Internal routines
+*/
+static unsigned digits(unsigned n);
+static void next_name(TraceFileName *tfn);
+static void *my_alloc(size_t size);
+static int my_write(TraceFileData *data, unsigned char *buff, int siz);
+static int my_flush(TraceFileData *data);
+static void put_be(unsigned n, unsigned char *s);
+static void close_unlink_port(TraceFileData *data); 
+static int wrap_file(TraceFileData *data);
+
+/*
+** The driver struct
+*/
+ErlDrvEntry trace_file_driver_entry = {
+    NULL,		   /* F_PTR init, N/A */
+    trace_file_start,      /* L_PTR start, called when port is opened */
+    trace_file_stop,       /* F_PTR stop, called when port is closed */
+    trace_file_output,     /* F_PTR output, called when erlang has sent */
+    NULL,                  /* F_PTR ready_input, called when input descriptor 
+			      ready */
+    NULL,                  /* F_PTR ready_output, called when output 
+			      descriptor ready */
+    "trace_file_drv",      /* char *driver_name, the argument to open_port */
+    trace_file_finish,     /* F_PTR finish, called when unloaded */
+    NULL,                  /* void * that is not used (BC) */
+    trace_file_control,    /* F_PTR control, port_control callback */
+    trace_file_timeout,    /* F_PTR timeout, driver_set_timer callback */
+    NULL                   /* F_PTR outputv, reserved */
+};
+
+/*
+** Driver initialization routine
+*/
+DRIVER_INIT(trace_file_drv)
+{
+    first_data = NULL;
+    return &trace_file_driver_entry;
+}
+
+/*
+** Driver interface routines
+*/
+
+/*
+** Open a port
+*/
+static ErlDrvData trace_file_start(ErlDrvPort port, char *buff)
+{
+    unsigned size, cnt, time, tail, len;
+    char *p;
+    TraceFileData     *data;
+    TraceFileWrapData *wrap;
+    FILETYPE fd;
+    int n, w;
+    static const char name[] = "trace_file_drv";
+
+#ifdef HARDDEBUG
+    fprintf(stderr,"hello (%s)\r\n", buff);
+#endif
+    w = 0; /* Index of where sscanf gave up */
+    size = 0; /* Warning elimination */
+    cnt = 0;  /* -""- */
+    time = 0;  /* -""- */
+    tail = 0; /* -""- */
+    n = sscanf(buff, "trace_file_drv %n w %u %u %u %u %n",
+	       &w, &size, &cnt, &time, &tail, &w);
+
+    if (w < sizeof(name) || (n != 0 && n != 4))
+	return ERL_DRV_ERROR_BADARG;
+
+    /* Search for "n <Filename>" in the rest of the string */
+    p = buff + w;
+    for (p = buff + w; *p == ' '; p++); /* Skip space (necessary?) */
+    if (*p++ != 'n')
+	return ERL_DRV_ERROR_BADARG;
+    if (*p++ != ' ')
+	return ERL_DRV_ERROR_BADARG;
+    /* Here we are at the start of the filename; p */
+    len = strlen(p);
+    if (tail >= len)
+	/* Tail must start within filename */
+	return ERL_DRV_ERROR_BADARG;
+
+    data = my_alloc(sizeof(TraceFileData) - 1 + BUFFER_SIZE);
+
+    /* We have to check the length in case we are running on 
+     * VxWorks since too long pathnames may cause bus errors
+     * instead of error return from file operations.
+     */
+    if (n == 4) {
+	/* Size limited wrapping log */
+	unsigned d = digits(cnt); /* Nof digits in filename counter */
+	if (len+d >= MAXPATHLEN) {
+	    errno = ENAMETOOLONG; 
+	    return ERL_DRV_ERROR_ERRNO;
+	}
+	wrap = my_alloc(sizeof(TraceFileWrapData));
+	wrap->size = size;
+	wrap->cnt = cnt;
+	wrap->time = time;
+	wrap->len = 0;
+	strcpy(wrap->cur.name, p);
+	wrap->cur.suffix = tail;
+	wrap->cur.tail = tail;
+	wrap->cur.len = len;
+	wrap->cur.cnt = cnt;
+	wrap->cur.n = cnt;
+	next_name(&wrap->cur); /* Incr to suffix "0" */
+	wrap->del = wrap->cur; /* Struct copy! */
+	p = wrap->cur.name; /* Use new name for open */
+    } else {
+	/* Regular log */
+	if (len >= MAXPATHLEN) {
+	    errno = ENAMETOOLONG; 
+	    return ERL_DRV_ERROR_ERRNO;
+	}
+	wrap = NULL;
+    }
+
+    if ((fd = open(p, O_WRONLY | O_TRUNC | O_CREAT
+#ifdef O_BINARY
+		   | O_BINARY
+#endif
+		   , 0777)) < 0) {
+	if (wrap)
+	    driver_free(wrap);
+	driver_free(data);
+	return ERL_DRV_ERROR_ERRNO;
+    } 
+
+    data->fd = fd;
+    data->port = port;
+    data->buff_siz = BUFFER_SIZE;
+    data->buff_pos = 0;
+    data->wrap = wrap;
+
+    if (first_data) {
+	data->prev = first_data->prev;
+	first_data->prev = data;
+    } else
+	data->prev = NULL;
+    data->next = first_data;
+    first_data = data;
+
+    if (wrap && wrap->time > 0)
+	driver_set_timer(port, wrap->time);
+
+    return (ErlDrvData) data;
+}
+
+
+/*
+** Close a port
+*/
+static void trace_file_stop(ErlDrvData handle)
+{
+    close_unlink_port((TraceFileData *) handle);
+}
+
+/*
+** Data sent from erlang to port.
+*/
+static void trace_file_output(ErlDrvData handle, char *buff, int bufflen)
+{
+    int heavy = 0;
+    TraceFileData *data = (TraceFileData *) handle;
+    unsigned char b[5] = "";
+    put_be((unsigned) bufflen, b + 1);
+    switch (my_write(data, b, sizeof(b))) {
+    case 1:
+	heavy = !0;
+    case 0:
+	switch (my_write(data, buff, bufflen)) {
+	case 1:
+	    heavy = !0;
+	case 0:
+	    break;
+	case -1:
+	    driver_failure_posix(data->port, errno); /* XXX */
+	    return;
+	}
+	break;
+    case -1:
+	driver_failure_posix(data->port, errno); /* XXX */
+	return;
+    }
+    if (data->wrap) {
+	TraceFileWrapData *wrap = data->wrap;
+	/* Size limited wrapping log files */
+	wrap->len += sizeof(b) + bufflen;
+	if (wrap->time == 0 && wrap->len >= wrap->size) {
+	    if (wrap_file(data) < 0) {
+		driver_failure_posix(data->port, errno); /* XXX */
+		return;
+	    }
+	    heavy = !0;
+	}
+    }
+    if (heavy) {
+	set_port_control_flags(data->port, PORT_CONTROL_FLAG_HEAVY);
+    }
+}
+
+/*
+** Control message from erlang, we handle $f, which is flush.
+*/
+static int trace_file_control(ErlDrvData handle, unsigned int command, 
+			      char* buff, int count, 
+			      char** res, int res_size)
+{
+    if (command == 'f') {
+	TraceFileData *data = (TraceFileData *) handle;
+	if (my_flush(data) < 0) {
+	    driver_failure_posix(data->port, errno); /* XXX */
+	}
+	if (res_size < 1) {
+	    *res = my_alloc(1);
+	}
+	**res = '\0';
+	return 1;
+    } 
+    return -1;
+}
+
+/*
+** Timeout from driver_set_timer.
+*/
+static void trace_file_timeout(ErlDrvData handle) {
+    TraceFileData *data = (TraceFileData *) handle;
+    if (data->wrap) {
+	if (wrap_file(data) < 0) {
+	    driver_failure_posix(data->port, errno); /* XXX */
+	    return;
+	} else {
+	    driver_set_timer(data->port, data->wrap->time);
+	}
+    }
+}
+
+/*
+** Driver unloaded
+*/
+static void trace_file_finish(void)
+{
+    while (first_data != NULL) {
+	close_unlink_port(first_data);
+    }
+}
+
+/*
+** Internal helpers
+*/
+
+/* Calculate needed number of digits in filename counter.
+**/
+static unsigned digits(unsigned n) {
+    unsigned m, i;
+    for (m = 10, i = 1;  n >= m;  i++, m *= 10) ;
+    return i;
+}
+
+/*
+** Increment filename.
+**
+** The filename counter counts "0"-"9","10"-"19"..."[n->n]","0"...,
+** but also "","0" which is used for initialization.
+*/
+static void next_name(TraceFileName *n) {
+    if (n->cnt >= n->n) {
+	n->cnt = 0;
+	/* Circular count from "[n->n]" to "0", or from "" to "0" */
+	memmove(&n->name[n->suffix+1], 
+		&n->name[n->tail], 
+		n->len+1 - n->tail); /* Including '\0' */
+	n->name[n->suffix] = '0';
+	n->len -= n->tail - n->suffix - 1;
+	n->tail = n->suffix + 1;
+    } else {
+	int i = n->tail;
+	n->cnt++;
+	do {
+	    i--;
+	    /* Increment from the end, 
+	     * '0'..'1', carry propagate forward */
+	    if (n->name[i] < '9') {
+		n->name[i]++;
+		return;
+	    } else
+		n->name[i] = '0';
+	} while (i > n->suffix);
+	/* Wrapped around from "99..99" to "00..00", 
+	 * need one more character */
+	memmove(&n->name[n->tail+1],
+		&n->name[n->tail],
+		n->len+1 - n->tail); /* Incl '\0' */
+	n->name[n->tail++] = '0';
+	n->name[n->suffix] = '1';
+	n->len++;
+    }
+}
+
+/*
+** Yet another malloc wrapper
+*/
+static void *my_alloc(size_t size) 
+{
+    void *ret;
+    if ((ret = (void *) driver_alloc(size)) == NULL) {
+	/* May or may not work... */
+	fprintf(stderr, "Could not allocate %d bytes of memory in %s.",
+		(int) size, __FILE__);
+	exit(1);
+    }
+    return ret;
+}
+
+/*
+** A write wrapper that regards it as an error if not all data was written.
+*/
+static int do_write(FILETYPE fd, unsigned char *buff, int siz) {
+    int w = write(fd, buff, siz);
+    if (w != siz) {
+	if (w >= 0) {
+	    errno = ENOSPC;
+	}
+	return -1;
+    }
+    return siz;
+}
+
+/*
+** Returns 0 if write to cache, 1 i write to file, and -1 if write failed.
+*/
+static int my_write(TraceFileData *data, unsigned char *buff, int siz) 
+{
+    int wrote, w;
+
+    if (data->buff_siz - data->buff_pos >= siz) {
+	memcpy(data->buff + data->buff_pos, buff, siz);
+	data->buff_pos += siz; 
+	return 0;
+    }
+    
+    wrote = data->buff_siz - data->buff_pos;
+    memcpy(data->buff + data->buff_pos, buff, wrote);
+    if (do_write(data->fd, data->buff, data->buff_siz) < 0) {
+	return -1;
+    }
+    data->buff_pos = 0;
+    if (siz - wrote >= data->buff_siz) {
+	/* Write directly, no need to buffer... */
+	if (do_write(data->fd, buff + wrote, siz - wrote) < 0) {
+	    return -1;
+	}
+	return 1;
+    } 
+    memcpy(data->buff, buff + wrote, siz - wrote);
+    data->buff_pos = siz - wrote;
+    set_port_control_flags(data->port, PORT_CONTROL_FLAG_HEAVY);
+    return 1;
+}
+
+/* 
+** Returns negative if it failed to write.
+ */
+static int my_flush(TraceFileData *data)
+{
+    if (do_write(data->fd, data->buff, data->buff_pos) < 0) {
+	return -1;
+    }
+    data->buff_pos = 0;
+    return 0;
+}
+
+/*
+** Write unsigned to buffer in big endian
+*/
+static void put_be(unsigned n, unsigned char *s)
+{
+    s[0] = n >> 24;
+    s[1] = (n >> 16) & 0xFFFFU;
+    s[2] = (n >> 8) & 0xFFFFU;
+    s[3] = n & 0xFFFFU;
+}
+
+/*
+** Wrapper that only closes non-negative filehandles
+*/
+static void do_close(FILETYPE fd) {
+    if (fd != -1) {
+	close(fd);
+    }
+}
+
+/*
+** Close the whole port and clean up
+*/
+static void close_unlink_port(TraceFileData *data) 
+{
+    my_flush(data);
+    do_close(data->fd);
+
+    if (data->next)
+	data->next->prev = data->prev;
+    if (data->prev)
+	data->prev->next = data->next;
+    else
+	first_data = data->next;
+
+    if (data->wrap)
+	driver_free(data->wrap);
+    driver_free(data);
+}
+
+/*
+** Wrap to new file - close the current, open a new and
+** perhaps delete a too old one
+**
+** Returns negative if something failed.
+*/
+static int wrap_file(TraceFileData *data) {
+    if (my_flush(data) < 0) {
+	close(data->fd);
+	data->fd = -1;
+	return -1;
+    }
+    close(data->fd);
+    data->fd = -1;
+    data->buff_pos = 0;
+    data->wrap->len = 0;
+    /* Count down before starting to remove old files */
+    if (data->wrap->cnt > 0)
+	data->wrap->cnt--;
+    if (data->wrap->cnt == 0) {
+	/* Remove an old file */
+	unlink(data->wrap->del.name);
+	next_name(&data->wrap->del);
+    }
+    next_name(&data->wrap->cur);
+    data->fd = open(data->wrap->cur.name, O_WRONLY | O_TRUNC | O_CREAT
+#ifdef O_BINARY
+	      | O_BINARY
+#endif
+	      , 0777);
+    if (data->fd < 0) {
+	data->fd = -1;
+	return -1;
+    }
+    return 0;
+}
+
diff --git a/lib/runtime_tools/c_src/trace_ip_drv.c b/lib/runtime_tools/c_src/trace_ip_drv.c
new file mode 100644
index 0000000000..d2ed1a294b
--- /dev/null
+++ b/lib/runtime_tools/c_src/trace_ip_drv.c
@@ -0,0 +1,938 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1999-2009. All Rights Reserved.
+ * 
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ * 
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ * 
+ * %CopyrightEnd%
+ */
+/*
+** This is a trace port, which means it cannot be busy and takes
+** no opcodes.
+** Send trace messages over the net.
+*/
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#ifdef __WIN32__
+#    include <winsock2.h>
+#    include <windows.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#ifndef __WIN32__
+#    ifdef VXWORKS
+#        include <sockLib.h>
+#        include <sys/times.h>
+#        include <iosLib.h>
+#        include <taskLib.h>
+#        include <selectLib.h>
+#        include <ioLib.h>
+#        include "reclaim.h"
+#    endif 
+#        include <unistd.h>
+#        include <errno.h>
+#        include <sys/types.h>
+#        include <sys/socket.h>
+#        include <netinet/in.h>
+#        include <fcntl.h>
+#endif
+
+#ifdef DEBUG
+#    ifndef __WIN32__
+         /* erl_exit is not available to dll_drivers on windows. */
+         void erl_exit(int, char *, ...);
+#        define ASSERT(X)                               \
+                    do {				\
+                        if (!(X)) {			\
+                            erl_exit(1,"%s",#X);	\
+                        } 				\
+                    } while(0) 
+#    else 
+#        include <assert.h>
+#        define ASSERT(X) assert(X)
+#    endif
+#else 
+#    define ASSERT(X)
+#endif 
+
+#define sock2event(s) ((ErlDrvEvent)(long)(s))
+#define event2sock(p) ((SOCKET)(long)(p))
+
+#include "erl_driver.h"
+
+/*
+** Protocol from driver:
+** '\0' -> ok
+** '\1' ++ String -> {error, Atom}
+** Protocol when opening (arguments to start):
+** <Portno> <Quesize> <Fl>
+** Where...
+** Portno, ascii string representing a number:
+**     The TCP port number to listen to.
+** Quesize, ascii string representing a number:
+**     The number of messages to que up before dropping.
+** Fl, ascii string representing a flag byte:
+**     0x1 -> Drop oldest when que is full (instead of last arrived)
+**     0x2 -> Fill the que even if noone is listening.
+**
+** The package sent over the network looks like this:
+** +--+--------+-----------------------------------+
+** |Op|Size NBO|Term in external format or empty   |
+** +--+--------+-----------------------------------+
+** Op, a char:
+**    0 = binary, 1 = drop
+**    If Op is 1, then Size reflects the number of dropped messages.
+** Size, a 32 bit interger in network byte order:
+**    Either the size of the binary term, or the number of packet's dropped. 
+** Term, an array of bytes:
+**    An erlang term in the external format or simply empty if Op == 1, the
+**    term is Size long.
+*/ 
+
+/*
+** SO, most of the differences between WinDoze and Posixish OS'es 
+** is handeled here, but the multiplexing (driver_select) is also quite
+** interesting, see my_driver_select further down in the file...
+*/
+
+#ifndef __WIN32__
+#    define FLAG_READ ERL_DRV_READ
+#    define FLAG_WRITE ERL_DRV_WRITE
+     typedef int SOCKET;
+#    define INVALID_SOCKET -1
+#    define IS_INVALID_SOCKET(S) ((S) < 0)
+#    define closesocket(Sock) close(Sock)
+#    define ERRNO errno
+#    ifdef EWOULDBLOCK
+#        define ERRNO_BLOCK EWOULDBLOCK
+#    else
+#        ifdef EAGAIN
+#            define ERRNO_BLOCK EAGAIN
+#        else
+#            error "No EWOULDBLOCK found"
+#        endif
+#    endif
+#else /* Win32 */
+#    define FLAG_READ (FD_READ | FD_CONNECT | FD_ACCEPT)
+#    define FLAG_WRITE FD_WRITE
+#    define ERRNO WSAGetLastError()
+#    define ERRNO_BLOCK WSAEWOULDBLOCK
+#    define IS_INVALID_SOCKET(S) ((S) == INVALID_SOCKET)
+#endif
+
+
+/*
+** Option flags
+*/
+#define FLAG_DROP_OLDEST    1
+#define FLAG_FILL_ALWAYS    2
+#define FLAG_LISTEN_PORT    4
+
+/*
+** Op's in messages
+*/
+#define OP_BINARY 0
+#define OP_DROP   1
+     
+/*
+** State structure
+*/
+
+typedef struct trace_ip_message {
+    int siz; /* the size of the "binary data" */
+    int written; /* if only a part was written, when == siz, all is written */
+    unsigned char bin[1]; /* The opcode, the Size and optionally the binary. */
+} TraceIpMessage;
+    
+
+typedef struct trace_ip_data {
+    unsigned flags;
+    int listen_portno;
+    SOCKET listenfd;
+    SOCKET fd;
+#ifdef __WIN32__
+    unsigned listen_event_mask;
+    HANDLE listen_event;
+    unsigned event_mask;
+    HANDLE event;
+#endif
+    ErlDrvPort port;
+    struct trace_ip_data *next;
+    int quesiz;
+    int questart;
+    int questop;
+    TraceIpMessage *que[1]; /* You guessed it, will be longer... */
+} TraceIpData;
+
+static TraceIpData *first_data; 
+
+/*
+** Interface routines
+*/
+static ErlDrvData trace_ip_start(ErlDrvPort port, char *buff);
+static void trace_ip_stop(ErlDrvData handle);
+static void trace_ip_output(ErlDrvData handle, char *buff, int bufflen);
+#ifdef __WIN32__
+static void trace_ip_event(ErlDrvData handle, ErlDrvEvent event);
+#endif
+static void trace_ip_ready_input(ErlDrvData handle, ErlDrvEvent fd);
+static void trace_ip_ready_output(ErlDrvData handle, ErlDrvEvent fd);
+static void trace_ip_finish(void); /* No arguments, despite what might be stated
+				     in any documentation */
+static int trace_ip_control(ErlDrvData handle, unsigned int command, 
+			    char* buff, int count, 
+			    char** res, int res_size);
+
+/*
+** Internal routines
+*/
+static void *my_alloc(size_t size);
+static ErlDrvBinary *my_alloc_binary(int size);
+static int write_until_done(SOCKET s, char *buff, int bufflen);
+static unsigned get_be(unsigned char *s);
+static void put_be32(unsigned n, unsigned char *s);
+static void put_be16(unsigned n, unsigned char *s);
+static TraceIpData *lookup_data_by_port(int portno);
+static int set_nonblocking(SOCKET sock);
+static TraceIpMessage *make_buffer(int datasiz, unsigned char op, 
+				   unsigned number);
+static void enque_message(TraceIpData *data, unsigned char *buff, int bufflen,
+			  int byteswritten);
+static void clean_que(TraceIpData *data);
+static void close_client(TraceIpData *data);
+static int trywrite(TraceIpData *data, unsigned char *buff, int bufflen);
+static SOCKET my_accept(SOCKET sock);
+static void close_unlink_port(TraceIpData *data);
+enum MySelectOp { SELECT_ON, SELECT_OFF, SELECT_CLOSE };
+static int my_driver_select(TraceIpData *desc, SOCKET fd, int flags, enum MySelectOp);
+static void stop_select(ErlDrvEvent event, void*);
+
+/*
+** The driver struct
+*/
+ErlDrvEntry trace_ip_driver_entry = {
+    NULL,	           /* F_PTR init, N/A */
+    trace_ip_start,        /* L_PTR start, called when port is opened */
+    trace_ip_stop,         /* F_PTR stop, called when port is closed */
+    trace_ip_output,       /* F_PTR output, called when erlang has sent */
+#ifdef __WIN32__
+    trace_ip_event,        /* Anything happens on an associated event */
+    NULL,                  /* Write selections not supported on win32 */
+#else
+    trace_ip_ready_input,  /* F_PTR ready_input, called when input descriptor 
+			      ready */
+    trace_ip_ready_output, /* F_PTR ready_output, called when output 
+			      descriptor ready */
+#endif
+    "trace_ip_drv",        /* char *driver_name, the argument to open_port */
+    trace_ip_finish,       /* F_PTR finish, called when unloaded */
+    NULL,                  /* void * that is not used */
+    trace_ip_control,      /* F_PTR control, port_control callback */
+    NULL,                  /* F_PTR timeout, reserved */
+    NULL,                  /* F_PTR outputv, reserved */
+    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,
+    NULL,                  /* process_exit */
+    stop_select
+};
+
+/*
+** Driver initialization routine
+**
+** No matter what's stated otherwise, this function shall return a pointer.
+*/
+
+DRIVER_INIT(trace_ip_drv)
+{
+    first_data = NULL;
+    /*trace_ip_driver_entry.handle = handle; ??? What is this, and why? It is no more! */
+    return &trace_ip_driver_entry;
+}
+
+/*
+** Driver interface routines
+*/
+
+/*
+** Open a port
+*/
+static ErlDrvData trace_ip_start(ErlDrvPort port, char *buff)
+{
+    TraceIpData *ret;
+    int portno;
+    int quesiz;
+    int flags;
+    SOCKET s;
+    struct sockaddr_in sin;
+    int reuse = 1;
+
+#ifdef HARDDEBUG
+    fprintf(stderr,"trace_ip_drv/trace_ip_start (%s)\r\n", buff);
+#endif
+    if (sscanf(buff,"trace_ip_drv %d %d %d",&portno, &quesiz, &flags) != 3)
+	return ERL_DRV_ERROR_GENERAL;
+
+    if (flags > 3 || flags < 0 || portno < 0 || quesiz < 0)
+	return ERL_DRV_ERROR_GENERAL;
+    
+    if (lookup_data_by_port(portno) != NULL)
+	return ERL_DRV_ERROR_GENERAL;
+    
+    if (IS_INVALID_SOCKET(s = socket(AF_INET, SOCK_STREAM, 0)))
+	return ERL_DRV_ERROR_GENERAL;
+
+    if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, 
+		   (char *) &reuse, sizeof(reuse)) < 0) {
+	closesocket(s);
+	return ERL_DRV_ERROR_GENERAL;
+    }
+
+
+    memset(&sin, 0, sizeof(sin));
+    sin.sin_family = AF_INET;
+    sin.sin_addr.s_addr = INADDR_ANY;
+    sin.sin_port = htons((short) portno);
+    
+    if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) != 0) {
+	closesocket(s);
+	return ERL_DRV_ERROR_GENERAL;
+    }
+
+    if (portno == 0) {
+#ifdef HAVE_SOCKLEN_T
+	socklen_t sinlen = sizeof(sin);
+#else
+	int  sinlen = (int) sizeof(sin);
+#endif
+	if (getsockname(s, (struct sockaddr *)&sin, &sinlen) != 0) {
+	    closesocket(s);
+	    return ERL_DRV_ERROR_GENERAL;
+	} else {
+	    portno = ntohs(sin.sin_port);
+	}
+    }    
+
+    if (listen(s, 1)) { /* No significant backlog needed */
+	closesocket(s);
+	return ERL_DRV_ERROR_GENERAL;
+    }
+
+    if (set_nonblocking(s) != 0){
+	closesocket(s);
+	return ERL_DRV_ERROR_GENERAL;
+    }
+    
+    /* OK, the socket is created, lets build the structure. */
+    /* Deliberately one more pointer than the quesize specified... */
+    ret = my_alloc(sizeof(TraceIpData) + 
+		   quesiz * sizeof(TraceIpMessage *));
+    
+    ret->flags = flags | FLAG_LISTEN_PORT;
+    ret->listen_portno = portno;
+    ret->listenfd = s;
+    ret->fd = INVALID_SOCKET;
+    ret->port = port;
+    ret->next = first_data;
+    ret->quesiz = quesiz+1;
+    ret->questart = ret->questop = 0;
+    memset(ret->que, 0, ret->quesiz);
+    
+    first_data = ret;
+#ifdef __WIN32__
+    ret->listen_event_mask = 0;
+    ret->listen_event = 0;
+    ret->event_mask = 0;
+    ret->event = 0;
+#endif
+    my_driver_select(ret, s, FLAG_READ, SELECT_ON);
+    set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY);
+
+    return (ErlDrvData) ret;
+}
+
+/*
+** Close a port
+*/
+static void trace_ip_stop(ErlDrvData handle)
+{
+    close_unlink_port((TraceIpData *) handle);
+}
+
+/*
+** Data sent from erlang to port.
+*/
+static void trace_ip_output(ErlDrvData handle, char *buff, int bufflen)
+{
+    TraceIpData *data = (TraceIpData *) handle;
+    if (data->flags & FLAG_LISTEN_PORT) {
+	if (data->flags & FLAG_FILL_ALWAYS) {
+	    enque_message(data, buff, bufflen, 0);
+	}
+	return;
+    }
+    if (data->que[data->questart] != NULL) {
+	trace_ip_ready_output(handle, sock2event(data->fd));
+    }
+    if (data->que[data->questart] == NULL) {
+	int written = trywrite(data, buff, bufflen);
+	if (written >= 0 && written < bufflen + 5) {
+	    enque_message(data, buff, bufflen, written);
+	    my_driver_select(data, data->fd, FLAG_WRITE, SELECT_ON);
+	}
+	return;
+    }
+    enque_message(data, buff, bufflen, 0);
+    return;
+}
+
+/*
+** We have something to read from a file descriptor
+*/
+static void trace_ip_ready_input(ErlDrvData handle, ErlDrvEvent fd)
+{
+    TraceIpData *data = (TraceIpData *) handle;
+    int client;
+
+    if (!(data->flags & FLAG_LISTEN_PORT) && event2sock(fd) == data->listenfd) {
+	/*
+	** Someone tries to connect to already connected port, 
+	** just accept and close.
+	*/
+	if (!IS_INVALID_SOCKET((client = my_accept(data->listenfd)))) {
+	    closesocket(client);
+	}
+	return;
+    }
+
+    if (event2sock(fd) == data->listenfd) {
+	/*
+	** Maybe accept, we are a listen port...
+	*/
+	if (!IS_INVALID_SOCKET((client = my_accept(data->listenfd)))) {
+	    data->fd = client;
+	    set_nonblocking(client);
+	    if (data->que[data->questart] != NULL) {
+		my_driver_select(data, data->fd, FLAG_WRITE | FLAG_READ, SELECT_ON);
+	    } else {
+		my_driver_select(data, data->fd, FLAG_READ, SELECT_ON);
+	    }
+	    data->flags &= ~(FLAG_LISTEN_PORT);
+	}
+	return;
+    }
+
+    /*
+     * It is a probably EOF because the other end closed the socket,
+     * but better make sure.
+     */
+
+    if ((SOCKET)(long)fd == data->fd) {
+#ifdef __WIN32__
+	close_client(data);
+#else
+	int res;
+	char sbuf[128];
+	
+	if ((res = read(data->fd, sbuf, sizeof sbuf)) == 0) {
+	    close_client(data);
+	}
+
+	/*
+	 * Something else. Just ignore it.
+	 *
+	 * When /dev/poll is used on Solaris, this callback can
+	 * be called even if there is nothing to read. An attempt
+	 * to read will result in an EAGAIN error.
+	 */
+#ifdef DEBUG
+	if (res < 0) {
+	    fprintf(stderr, "Read on fd %d failed with errno=%d\r\n",
+		    data->fd, errno);
+	}
+#endif
+#endif
+	return;
+    }
+
+    ASSERT(0);
+}
+
+#ifdef __WIN32__
+static void trace_ip_event(ErlDrvData handle, ErlDrvEvent event) 
+{
+   TraceIpData *data = (TraceIpData *) handle;
+   if ((HANDLE)event == data->event) {
+       WSANETWORKEVENTS netEv;
+       if (WSAEnumNetworkEvents(data->fd, data->event, &netEv) != 0) {
+	   return;
+       }
+       if (netEv.lNetworkEvents & FLAG_WRITE) {
+	   trace_ip_ready_output(handle, (ErlDrvEvent)data->fd);
+       }
+       if (netEv.lNetworkEvents & FLAG_READ) {
+	   trace_ip_ready_input(handle, (ErlDrvEvent)data->fd);
+       }
+   } else if ((HANDLE)event == data->listen_event) {
+       trace_ip_ready_input(handle, (ErlDrvEvent)data->listenfd);
+   }
+}
+#endif /* ifdef __WIN32__ */
+       
+/*
+** We can write to a file descriptor
+*/
+static void trace_ip_ready_output(ErlDrvData handle, ErlDrvEvent fd)
+{
+    TraceIpData *data = (TraceIpData *) handle;
+    int res;
+    int towrite;
+    TraceIpMessage *tim;
+
+    ASSERT(!(data->flags & FLAG_LISTEN_PORT) &&
+	   data->que[data->questart] != NULL &&
+	   (SOCKET)(long)fd == data->fd);
+    
+    tim = data->que[data->questart];
+    towrite = tim->siz - tim->written;
+    while((res = write_until_done(data->fd, 
+				  tim->bin + tim->written, towrite)) 
+	  == towrite) {
+	driver_free(tim);
+	data->que[data->questart] = NULL;
+	if (data->questart == data->questop) {
+	    /*
+	    ** We wrote the last message in the que, dont
+	    ** step forward, just 'deselect'
+	    */
+	    my_driver_select(data, data->fd, FLAG_WRITE, SELECT_OFF);
+	    /*
+	    ** We are really done...
+	    */
+	    return;
+	}
+	if (++(data->questart) == data->quesiz)
+	    data->questart = 0;
+	tim = data->que[data->questart];
+	ASSERT(tim != NULL);
+	towrite = tim->siz - tim->written;
+    }
+    if (res < 0) {
+	close_client(data);
+	return;
+    }
+
+    tim->written += res;
+}
+
+/*
+** Control message from erlang, we handle $p, which is get_listen_port.
+*/
+static int trace_ip_control(ErlDrvData handle, unsigned int command, 
+			      char* buff, int count, 
+			      char** res, int res_size)
+{
+    register void *void_ptr; /* Soft type cast */
+
+    if (command == 'p') {
+	TraceIpData *data = (TraceIpData *) handle;
+	ErlDrvBinary *b = my_alloc_binary(3);
+	b->orig_bytes[0] = '\0'; /* OK */
+	put_be16(data->listen_portno, &(b->orig_bytes[1]));
+	*res = void_ptr = b;
+	return 0;
+    } 
+    return -1;
+}
+
+/*
+** Driver unloaded
+*/
+static void trace_ip_finish(void)
+{
+    while (first_data != NULL) {
+	close_unlink_port(first_data);
+    }
+}
+
+/*
+** Internal helpers
+*/
+
+/*
+** Yet another malloc wrapper
+*/
+static void *my_alloc(size_t size) 
+{
+    void *ret;
+    if ((ret = driver_alloc(size)) == NULL) {
+	/* May or may not work... */
+	fprintf(stderr, "Could not allocate %d bytes of memory in %s.",
+		(int) size, __FILE__);
+	exit(1);
+    }
+    return ret;
+}
+
+/*
+** Yet another malloc wrapper
+*/
+static ErlDrvBinary *my_alloc_binary(int size)
+{
+    ErlDrvBinary *ret;
+    if ((ret = driver_alloc_binary(size)) == NULL) {
+	/* May or may not work... */
+	fprintf(stderr, "Could not allocate a binary of %d bytes in %s.",
+		(int) size, __FILE__);
+	exit(1);
+    }
+    return ret;
+}
+
+/*
+** Write to a nonblocking descriptor until it states EWOULDBLOCK
+*/
+static int write_until_done(SOCKET s, char *buff, int bufflen)
+{
+    int ret = 0;
+    int res = 0;
+
+#ifdef HARDDEBUG
+    fprintf(stderr, "Writing %d characters.\r\n", bufflen);
+#endif
+
+    while(ret < bufflen && (res = send(s, buff + ret, bufflen - ret, 0)) > 0) {
+	ret += res;
+    }
+    if (ret < bufflen) {
+	if (res == 0) {
+	    fprintf(stderr, "internal error in trace_ip_drv, "
+		     "write to nonblocking "
+		     "returned 0!");
+	    exit(1);
+	} else if (ERRNO != ERRNO_BLOCK) {
+		return -1;
+	}
+    }
+    return ret;
+}
+
+/*
+** Translate big endian integer in buffer to unsigned
+*/
+static unsigned get_be(unsigned char *s)
+{
+    return s[3] | (s[2] << 8) | (s[1] << 16) | s[0] << 24;
+}
+
+/*
+** Write unsigned to buffer in big endian
+*/
+
+static void put_be32(unsigned n, unsigned char *s)
+{
+    s[0] = n >> 24U;
+    s[1] = n >> 16U;
+    s[2] = n >> 8U;
+    s[3] = n;
+}
+
+static void put_be16(unsigned n, unsigned char *s)
+{
+    s[0] = n >> 8U;
+    s[1] = n;
+}
+
+/*
+** Lookup a port's data structure by the *TCP/IP port number*
+*/
+static TraceIpData *lookup_data_by_port(int portno)
+{
+    TraceIpData *tmp = first_data;
+    while (tmp != NULL && tmp->listen_portno != portno)
+	tmp = tmp->next;
+    return tmp;
+}
+
+/*
+** Create a TraceIpMessage buffer (the binary data NOT filled in)
+*/
+static TraceIpMessage *make_buffer(int datasiz, unsigned char op, 
+				   unsigned number)
+{
+    TraceIpMessage *ret = my_alloc(sizeof(TraceIpMessage) + 
+				   (datasiz + 4)); 
+    ret->siz = datasiz + 5;
+    ret->written = 0;
+    ret->bin[0] = op;
+    put_be32(number, ret->bin + 1);
+    return ret;
+}
+
+/*
+** Add message to que, discarding in a politically correct way...
+** The FLAG_DROP_OLDEST is currently ingored...
+*/
+static void enque_message(TraceIpData *data, unsigned char *buff, int bufflen,
+			  int byteswritten)
+{
+    int diff = data->questop - data->questart;
+    TraceIpMessage *tim;
+
+    if (diff == -1 || diff == data->quesiz - 1) {
+	put_be32(get_be((data->que[data->questop])->bin + 1) + 1, 
+		 (data->que[data->questop])->bin + 1);
+    } else if (diff == -2 || diff == data->quesiz - 2) {
+	ASSERT(byteswritten == 0);
+	if (++(data->questop) ==  data->quesiz) {
+	    data->questop = 0;
+	}
+	data->que[data->questop] = make_buffer(0, OP_DROP, 1);
+    } else {
+	if (data->que[data->questop] != NULL &&
+	    ++(data->questop) ==  data->quesiz) {
+	    data->questop = 0;
+	}
+	tim = make_buffer(bufflen, OP_BINARY, bufflen);
+	tim->written = byteswritten;
+	memcpy(tim->bin + 5, buff, bufflen);
+	data->que[data->questop] = tim;
+    }
+}
+
+/*
+** Clean a que
+*/
+static void clean_que(TraceIpData *data)
+{
+    int b = data->questart;
+    int e = data->questop;
+
+    while (b != e) {
+	if (data->que[b] != NULL) {
+	    driver_free(data->que[b]);
+	    data->que[b] = NULL;
+	}
+	if (++b >= data->quesiz) {
+	    b = 0;
+	}
+    }
+    if (data->que[b] != NULL) {
+	driver_free(data->que[b]);
+	data->que[b] = NULL;
+    }
+    data->questart = data->questop = 0;
+}
+    
+/*
+** Cleanup closed client (or close the client and cleanup)
+*/
+static void close_client(TraceIpData *data) 
+{
+    my_driver_select(data, data->fd, FLAG_WRITE | FLAG_READ, SELECT_CLOSE);
+    data->flags |= FLAG_LISTEN_PORT;
+    if (!(data->flags & FLAG_FILL_ALWAYS)) {
+	clean_que(data);
+    }
+}
+
+/*
+** Try to write a message from erlang directly (only called when que is empty 
+** and client is connected)
+*/
+static int trywrite(TraceIpData *data, unsigned char *buff, int bufflen)
+{
+    unsigned char op[5];
+    int res;
+
+    op[0] = OP_BINARY;
+    put_be32(bufflen, op + 1);
+
+    if ((res = write_until_done(data->fd, op, 5)) < 0) {
+	close_client(data);
+	return -1;
+    }
+    if (res < 5) {
+	return res;
+    }
+
+    if ((res = write_until_done(data->fd, buff, bufflen)) < 0) {
+	close_client(data);
+	return -1;
+    }
+
+    return res + 5;
+}
+
+/*
+** accept wrapper
+*/
+static SOCKET my_accept(SOCKET sock)
+{
+    struct sockaddr_in sin;
+    int sin_size = sizeof(sin);
+
+    return accept(sock, (struct sockaddr *) &sin, &sin_size);
+}
+
+/*
+** Close the whole port and clean up
+*/
+static void close_unlink_port(TraceIpData *data) 
+{
+    TraceIpData **tmp;
+
+    data->flags = 0;
+    if (!IS_INVALID_SOCKET(data->fd)) {
+	close_client(data);
+    }
+    my_driver_select(data, data->listenfd, FLAG_READ, SELECT_CLOSE);
+
+    for(tmp = &first_data; *tmp != NULL && *tmp != data; 
+	tmp = &((*tmp)->next))
+	;
+    if (*tmp != NULL) {
+	*tmp = (*tmp)->next;
+    }
+    driver_free(data);
+}
+
+
+
+
+#ifdef __WIN32__
+/*
+** Mostly stolen from inet_drv in the emulator.
+*/
+static int my_driver_select(TraceIpData *desc, SOCKET fd, 
+			    int flags, enum MySelectOp op)
+{
+    HANDLE *event;
+    unsigned *event_mask;
+    int ret = -1;
+    unsigned save_event_mask; 
+
+    if(fd == desc->listenfd) {
+	event = &(desc->listen_event);
+	event_mask = &(desc->listen_event_mask);
+    } else if(fd == desc->fd) {
+	event = &(desc->event);
+	event_mask = &(desc->event_mask);
+    } else { 
+	return -1;
+    }
+
+    save_event_mask = *event_mask;
+
+    if (op==SELECT_ON) {
+	*event_mask |= flags;
+    } else {
+	*event_mask &= (~flags);
+    }
+    if (*event_mask != 0 && *event == 0) { 
+	*event = WSACreateEvent();
+	driver_select(desc->port, *event, ERL_DRV_READ|ERL_DRV_USE, 1);
+    }
+
+    /* The RIGHT WAY (TM) to do this is to make sure:
+       A) The cancelling of all network events is done with
+          NULL as the event parameter (bug in NT's winsock),
+       B) The actual event handle is reset so that it is only
+          raised if one of the requested network events is active,
+       C) Avoid race conditions by making sure that the event cannot be set
+          while we are preparing to set the correct network event mask.
+       The simplest way to do it is to turn off all events, reset the
+       event handle and then, if event_mask != 0, turn on the appropriate
+       events again. */
+    if (WSAEventSelect(fd, NULL, 0) != 0) {
+	*event_mask = save_event_mask;
+	goto error;
+    }
+    if (!ResetEvent(*event)) {
+	*event_mask = 0;
+	goto error;
+    }
+    if (*event_mask != 0) {
+	if (WSAEventSelect(fd, 
+			   *event, 
+			   *event_mask) != 0) {
+	    *event_mask = 0;
+	    goto error;
+	}
+    }
+    ret = 0;
+error:
+    if (*event_mask == 0 && *event != 0 && (op==SELECT_CLOSE || ret!=0)) {
+	WSAEventSelect(fd, NULL, 0); /* Not necessary? 
+					Well, actually I dont know, and
+					MS documentation states nothing
+					about what happens if WSAEventSelect
+					is called with empty event mask and 
+					then the event is deleted. */ 
+	driver_select(desc->port, *event, ERL_DRV_READ|ERL_DRV_USE, 0);
+	*event = 0;
+	if (op == SELECT_CLOSE) {
+	    closesocket(fd);
+	}
+    }
+    return ret;
+}
+
+static void stop_select(ErlDrvEvent event, void* _)
+{
+    WSACloseEvent((HANDLE)event);
+}
+
+#else /* UNIX/VXWORKS */
+
+static int my_driver_select(TraceIpData *desc, SOCKET fd, int flags, enum MySelectOp op)
+{
+    if (op != SELECT_OFF) {
+	flags |= ERL_DRV_USE;
+    }
+    return driver_select(desc->port, sock2event(fd), flags, (op==SELECT_ON));
+}	    
+
+static void stop_select(ErlDrvEvent event, void* _)
+{
+    closesocket((SOCKET)(long)event);
+}
+
+#endif /* !__WIN32__ */
+
+/*
+** Set socket nonblocking, keep this at end of file.
+*/
+#undef ERRNO_BLOCK
+#undef ASSERT
+#ifndef WANT_NONBLOCKING
+#define WANT_NONBLOCKING
+#endif
+#include "sys.h"
+static int set_nonblocking(SOCKET sock)
+{
+    SET_NONBLOCKING(sock);
+    return 0;
+}
+
+