The R13B03 release.OTP_R13B03

63 files changed, 9549 insertions, 0 deletions

diff --git a/lib/os_mon/AUTHORS b/lib/os_mon/AUTHORS
new file mode 100644
index 0000000000..22e34f8278
--- /dev/null
+++ b/lib/os_mon/AUTHORS
@@ -0,0 +1,12 @@
+Original Authors and Contributors:
+
+Martin Bj�rklund 
+Mats Nilsson 
+Magnus Fr�berg 
+Janne Lindblad
+Kenneth Lundin 
+Patrik Nyblom 
+Peter H�gfeldt
+Rickard Green
+Ingela Anderton
+Bj�rn-Egil Dahlberg
diff --git a/lib/os_mon/Makefile b/lib/os_mon/Makefile
new file mode 100644
index 0000000000..7eeec1577c
--- /dev/null
+++ b/lib/os_mon/Makefile
@@ -0,0 +1,40 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1996-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
+
+#
+# Macros
+#
+ifeq ($(findstring win32,$(TARGET)),win32)
+SUB_DIRECTORIES = src c_src mibs doc/src
+else
+SUB_DIRECTORIES = src c_src mibs doc/src
+endif
+
+include vsn.mk
+VSN = $(OS_MON_VSN)
+
+SPECIAL_TARGETS = 
+
+#
+# Default Subdir Targets
+#
+include $(ERL_TOP)/make/otp_subdir.mk
+
diff --git a/lib/os_mon/c_src/Makefile b/lib/os_mon/c_src/Makefile
new file mode 100644
index 0000000000..a34434a7e6
--- /dev/null
+++ b/lib/os_mon/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/os_mon/c_src/Makefile.in b/lib/os_mon/c_src/Makefile.in
new file mode 100644
index 0000000000..1a371eb380
--- /dev/null
+++ b/lib/os_mon/c_src/Makefile.in
@@ -0,0 +1,144 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1997-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
+
+CC = @CC@
+LD = @LD@
+LIBS = @LIBS@
+CPU_SUP_LIBS = @CPU_SUP_LIBS@
+
+BINDIR = ../priv/bin/$(TARGET)
+OBJDIR = ../priv/obj/$(TARGET)
+
+# ----------------------------------------------------
+# Application version
+# ----------------------------------------------------
+include ../vsn.mk
+VSN=$(OS_MON_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/os_mon-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+ifeq ($(findstring win32,$(TARGET)),win32)
+PROGRAMS = \
+	win32sysinfo.exe \
+	nteventlog.exe
+C_FILES=win32sysinfo.c \
+	nteventlog/elog_main.c \
+	nteventlog/elog_util.c \
+	nteventlog/elog_registry.c \
+	nteventlog/elog_pipe_stdin.c \
+	nteventlog/elog_format.c
+
+EVLOG_OBJECTS = \
+	$(OBJDIR)/elog_main.o \
+	$(OBJDIR)/elog_util.o \
+	$(OBJDIR)/elog_registry.o \
+	$(OBJDIR)/elog_pipe_stdin.o \
+	$(OBJDIR)/elog_format.o 
+
+ENTRY_OBJ=$(ERL_TOP)/erts/obj/$(TARGET)/port_entry.o
+PORT_ENTRY_POINT=erl_port_entry
+ENTRY_LDFLAGS=-entry:$(PORT_ENTRY_POINT)
+else
+ifeq ($(findstring vxworks_simso,$(TARGET)),vxworks_simso)
+PROGRAMS =
+else
+PROGRAMS = \
+	memsup @os_mon_programs@
+C_FILES= $(PROGRAMS:%=%.c)
+endif
+endif
+
+TARGET_FILES= $(PROGRAMS:%=$(BINDIR)/%)
+
+LDFLAGS = @LDFLAGS@
+
+ALL_CFLAGS = @CFLAGS@ @DEFS@ $(CFLAGS)
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+debug opt: $(OBJDIR) $(BINDIR) $(TARGET_FILES)
+
+$(OBJDIR):
+	-@mkdir -p $(OBJDIR)
+
+$(BINDIR):
+	-@mkdir -p $(BINDIR)
+
+clean:
+	rm -f $(TARGET_FILES)
+	rm -f core *~
+
+docs:
+
+# ----------------------------------------------------
+# Special Build Targets
+# ----------------------------------------------------
+
+$(BINDIR)/win32sysinfo.exe: $(OBJDIR)/win32sysinfo.o $(ENTRY_OBJ)
+	$(LD) $(LDFLAGS) $(ENTRY_LDFLAGS) -o $@ $(OBJDIR)/win32sysinfo.o $(ENTRY_OBJ)
+
+$(BINDIR)/nteventlog.exe: $(EVLOG_OBJECTS)
+	$(LD) $(LDFLAGS) $(ENTRY_LDFLAGS) -o $@ $(EVLOG_OBJECTS) $(ENTRY_OBJ)
+
+$(BINDIR)/ferrule: $(OBJDIR)/ferrule.o
+	$(LD) $(LDFLAGS) -o $@ $<
+
+$(BINDIR)/mod_syslog: $(OBJDIR)/mod_syslog.o
+	$(LD) $(LDFLAGS) -o $@ $<
+
+$(BINDIR)/memsup: $(OBJDIR)/memsup.o
+	$(LD) $(LDFLAGS) -o $@ $<
+
+$(BINDIR)/cpu_sup: $(OBJDIR)/cpu_sup.o
+	$(LD) $(LDFLAGS) -o $@ $< $(CPU_SUP_LIBS) 
+
+$(OBJDIR)/%.o: %.c
+	$(CC) -c -o $@ $(ALL_CFLAGS) $<
+
+$(OBJDIR)/%.o: nteventlog/%.c
+	$(CC) -c -o $@ $(ALL_CFLAGS) $<
+
+$(OBJDIR)/memsup.o: memsup.h
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+ifeq ($(findstring vxworks_simso,$(TARGET)),vxworks_simso)
+release_spec:
+else
+release_spec: opt
+	$(INSTALL_DIR) $(RELSYSDIR)/src
+	$(INSTALL_DATA) $(C_FILES) $(RELSYSDIR)/src
+	$(INSTALL_DIR) $(RELSYSDIR)/priv/bin
+	$(INSTALL_PROGRAM) $(TARGET_FILES) $(RELSYSDIR)/priv/bin
+endif
+
+release_docs_spec:
diff --git a/lib/os_mon/c_src/cpu_sup.c b/lib/os_mon/c_src/cpu_sup.c
new file mode 100644
index 0000000000..fbf318c614
--- /dev/null
+++ b/lib/os_mon/c_src/cpu_sup.c
@@ -0,0 +1,455 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1997-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%
+ */
+/*
+ * CPU supervision
+ *
+ * Uses kstat library only available on Solaris 2
+ * Compile with: gcc -o cpu_sup cpu_sup.c -lkstat
+ *
+ * Use open_port({spawn,Prog},[stream]) to communicate.
+ * 
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#if defined(__sun__)
+#include <kstat.h>
+#endif
+
+#include <sys/sysinfo.h>
+#include <errno.h>
+
+#if defined(__linux__)
+#include <string.h>  /* strlen */
+
+#define PROCSTAT "/proc/stat"
+#define BUFFERSIZE (256)
+typedef struct {
+    unsigned int id;
+    unsigned long long 
+	/* total, */
+	user, 
+	nice_user, 
+	kernel, 
+	idle, 
+	io_wait, 
+	hard_irq, 
+	soft_irq, 
+	steal;
+} cpu_t;
+
+#endif
+
+#define FD_IN		(0)
+#define FD_OUT		(1)
+#define FD_ERR		(2)
+
+#define PING		'p'
+#define NPROCS		'n'
+#define AVG1		'1'
+#define AVG5		'5'
+#define AVG15		'f'
+#define UTIL		'u'
+#define QUIT		'q'
+
+
+#define CU_CPU_ID	(0)
+#define CU_USER		(1)
+#define CU_NICE_USER	(2)
+#define CU_KERNEL	(3)
+#define CU_IO_WAIT	(4)
+#define CU_IDLE		(5)
+#define CU_HARD_IRQ	(6)
+#define CU_SOFT_IRQ	(7)
+#define CU_STEAL	(8)
+
+#define CU_VALUES	(9)
+#define CU_KSTAT_VALUES	(5)
+
+/*
+#define CU_FLG_CPU_ID		(0 << 1)
+#define CU_FLG_USER		(0 << 2)
+#define CU_FLG_NICE_USER	(0 << 3)
+#define CU_FLG_KERNEL		(0 << 4)
+#define CU_FLG_IO_WAIT		(0 << 5)
+#define CU_FLG_IDLE		(0 << 6)
+#define CU_FLG_HARD_IRQ		(0 << 7)
+#define CU_FLG_SOFT_IRQ		(0 << 8)
+#define CU_FLG_STEAL		(0 << 9)
+*/
+
+/* util_measure
+ * In:
+ * 	unsigned int **result_vec
+ * 	int *result_sz
+ * Purpose:
+ * 	Retrieve CPU utilization
+ * 	result_vec has 2 + np*ne*2 entries where np is number_of_cpus
+ * 	|------|------|
+ * 	|  np  |  ne  |
+ * 	|------|------|
+ * 	|val_id| value| (One entry)
+ * 	|------|------|
+ * 	|val_id| value| (One entry)
+ * 	|------|------|
+ *  	     ......
+ * 	|------|------|
+ * 	|val_id| value|
+ * 	|------|------|
+ * 	np = number of processors
+ * 	ne = number of entries per processor
+ */
+
+static void util_measure(unsigned int **result_vec, int *result_sz);
+
+static unsigned int misc_measure(char* name);
+static void send(unsigned int data);
+static void sendv(unsigned int data[], int ints);
+static void error(char* err_msg);
+
+#if defined(__sun__)
+static kstat_ctl_t *kstat_ctl;
+#endif
+
+#if defined(__linux__)
+static int processors_online() {
+    return (int)sysconf(_SC_NPROCESSORS_ONLN);
+}
+#endif
+
+int main(int argc, char** argv) {
+  char cmd;
+  int rc;
+  int sz;
+  unsigned int *rv;
+  unsigned int no_of_cpus = 0;
+
+#if defined(__sun__)
+  kstat_ctl = kstat_open();
+  if(!kstat_ctl)
+    error("Can't open header kstat");
+#endif
+
+#if defined(__linux__)
+    no_of_cpus = processors_online(); 
+    if ( (rv = (unsigned int*)malloc(sizeof(unsigned int)*(2 + 2*no_of_cpus*CU_VALUES))) == NULL) {
+	error("cpu_cup: malloc error");
+    }
+#endif
+
+  while(1) {
+
+    rc = read(FD_IN, &cmd, 1);
+    if (rc < 0) {
+      if (errno == EINTR)
+	continue;
+      error("Error reading from Erlang");
+    }
+
+    if(rc == 0)
+      error("Erlang has closed");
+    
+    switch(cmd) {
+    case PING:		send(4711);					break;
+#if defined(__sun__)
+    case NPROCS:	send(misc_measure("nproc"));			break;
+    case AVG1:		send(misc_measure("avenrun_1min"));		break;
+    case AVG5:		send(misc_measure("avenrun_5min"));		break;
+    case AVG15:		send(misc_measure("avenrun_15min"));		break;
+#endif
+    case UTIL:		util_measure(&rv,&sz); 	sendv(rv, sz);		break;
+    case QUIT:		free((void*)rv); return 0;
+    default:		error("Bad command");				break;
+    }
+  }
+  return 0; /* supress warnings */
+}
+/* ---------------------------- *
+ *     Linux stat functions 	*
+ * ---------------------------- */
+
+#if defined(__linux__)
+
+static cpu_t *read_procstat(FILE *fp, cpu_t *cpu) {
+    char buffer[BUFFERSIZE];
+
+    fgets(buffer, BUFFERSIZE, fp);
+    sscanf(buffer, "cpu%u %Lu %Lu %Lu %Lu %Lu %Lu %Lu %Lu",
+	&(cpu->id),
+	&(cpu->user),
+	&(cpu->nice_user),
+	&(cpu->kernel),
+	&(cpu->idle),
+	&(cpu->io_wait),
+	&(cpu->hard_irq),
+	&(cpu->soft_irq),
+	&(cpu->steal));
+
+    return cpu;
+}
+
+static void util_measure(unsigned int **result_vec, int *result_sz) {
+    int no_of_cpus = processors_online();
+    int i;
+    char buffer[BUFFERSIZE];
+    FILE *fp;
+    unsigned int *rv = NULL;
+    cpu_t cpu;
+ 
+    if ( (fp = fopen(PROCSTAT,"r")) == NULL) {
+	/* Check if procfs is mounted,
+	 *  otherwise:
+	 *  try and try again, bad procsfs.
+	 */
+	*result_sz = 0;
+	return;
+    }
+
+    fgets(buffer, BUFFERSIZE, fp); /*ignore read*/
+    rv = *result_vec; 
+    rv[0] = no_of_cpus;
+    rv[1] = CU_VALUES;
+    ++rv; /* first value is number of cpus */
+    ++rv; /* second value is number of entries */
+
+    for (i = 0; i < no_of_cpus; ++i) {
+	read_procstat(fp, &cpu);
+	      
+	rv[ 0] = CU_CPU_ID;    rv[ 1] = cpu.id;
+	rv[ 2] = CU_USER;      rv[ 3] = cpu.user;
+	rv[ 4] = CU_NICE_USER; rv[ 5] = cpu.nice_user;
+	rv[ 6] = CU_KERNEL;    rv[ 7] = cpu.kernel;
+	rv[ 8] = CU_IO_WAIT;   rv[ 9] = cpu.io_wait;
+	rv[10] = CU_IDLE;      rv[11] = cpu.idle;
+	rv[12] = CU_HARD_IRQ;  rv[13] = cpu.hard_irq;
+	rv[14] = CU_SOFT_IRQ;  rv[15] = cpu.soft_irq;
+	rv[16] = CU_STEAL;     rv[17] = cpu.steal;
+	rv += CU_VALUES*2;
+    }	
+
+    fclose(fp);
+    *result_sz = 2 + 2*CU_VALUES * no_of_cpus;
+}
+
+#endif
+
+/* ---------------------------- *
+ *     Unix kstat functions 	*
+ * ---------------------------- */
+
+#if defined(__sun__)
+static unsigned int misc_measure(char* name) {
+  static kstat_t *ksp = NULL;
+  kstat_named_t* entry;
+  kid_t kcid;
+
+  kcid = kstat_chain_update(kstat_ctl);
+
+  if(kcid == -1)
+    error("Error updating kstat chain");
+
+  if (!ksp || kcid != 0) {
+
+    /* The kstat chain changed (or we are initializing);
+       find system misc entry in the new chain... */
+    
+    ksp = kstat_lookup(kstat_ctl,"unix",0,"system_misc");
+    if(!ksp)
+      error("Can't open system_misc kstat");
+  }
+
+  kstat_read(kstat_ctl,ksp,NULL);
+  entry = kstat_data_lookup(ksp,name);
+  if(!entry)
+    return -1;
+  
+  if(entry->data_type != KSTAT_DATA_ULONG)
+    return -1;
+
+  return entry->value.ul;
+}
+
+
+static int cpu_cmp(const void *p1, const void *p2) {
+  kstat_t *ksp1 = *((kstat_t **) p1);
+  kstat_t *ksp2 = *((kstat_t **) p2);
+  
+  if (ksp1->ks_instance > ksp2->ks_instance)
+    return 1;
+  if (ksp1->ks_instance < ksp2->ks_instance)
+    return -1;
+  return 0;
+}
+
+
+static void util_measure(unsigned int **result_vec, int *result_sz) {
+  static int no_of_cpus = 0;
+  static kstat_t **cpu_ksps = NULL;
+  static unsigned int * resv = NULL;
+  unsigned int *rv = NULL;
+  kstat_t *ksp;
+  kid_t kcid;
+  int cpu_stats_read;
+  int i;
+
+  kcid = kstat_chain_update(kstat_ctl);
+
+  if(kcid == -1)
+    error("Error updating kstat chain");
+
+  if (no_of_cpus == 0 || kcid != 0) {
+
+    /* The kstat chain changed (or we are initializing);
+       find cpu_stat entries in the new chain... */
+
+    no_of_cpus = 0;
+
+    for(ksp = kstat_ctl->kc_chain; ksp; ksp = ksp->ks_next) {
+      if (strcmp(ksp->ks_module, "cpu_stat") == 0
+	  && ksp->ks_type == KSTAT_TYPE_RAW) {
+	no_of_cpus++;
+	/* Assumes that modifications of the cpu_stat_t struct
+	   in future releases of Solaris only are additions
+	   of fields at the end of the struct. */
+	if(ksp->ks_data_size < sizeof(cpu_stat_t))
+	  error("Error: unexpected kstat data size");
+      }
+    }
+
+    free((void *) cpu_ksps);
+    if (no_of_cpus > 0) {
+      cpu_ksps = (kstat_t **) malloc(no_of_cpus*sizeof(kstat_t *));
+      if(!cpu_ksps)
+	error("Error allocating memory");
+    
+      i = 0;
+      for(ksp = kstat_ctl->kc_chain;
+	  ksp && i < no_of_cpus;
+	  ksp = ksp->ks_next) {
+	if (strcmp(ksp->ks_module, "cpu_stat") == 0
+	    && ksp->ks_type == KSTAT_TYPE_RAW) {
+	  cpu_ksps[i++] = ksp;
+	}
+      }
+
+      if (i != no_of_cpus)
+	error("Error: private kstat chain copy unexpectedly changed");
+
+      /* Erlang assumes that cpu information are sent in ascending order;
+	 sort them ... */
+      qsort((void  *)cpu_ksps,(size_t)no_of_cpus,sizeof(kstat_t *),cpu_cmp);
+
+    }
+
+    free((void *) resv);
+/* kstat defined values are:
+ *	CU_CPU_ID
+ *	CU_USER
+ *	CU_KERNEL
+ *	CU_IO_WAIT
+ *	CU_IDLE
+ */
+    resv = (unsigned int *) malloc(sizeof(unsigned int)*(2 + 2*no_of_cpus*CU_KSTAT_VALUES));
+    if(!resv)
+      error("Error allocating memory");
+
+  }
+
+    /* Read cpu utilization statistics ... */
+
+    rv = resv;
+    rv++; /*first entry is np*/
+    rv++; /*second entry is ne*/
+    cpu_stats_read = 0;
+
+    for(i = 0; i < no_of_cpus; i++) {
+	if (kstat_read(kstat_ctl, cpu_ksps[i], NULL) != -1) {
+	    cpu_stat_t *cpu_stat = (cpu_stat_t *)cpu_ksps[i]->ks_data;
+	    
+	    rv[ 0] = CU_CPU_ID;    rv[ 1] = cpu_ksps[i]->ks_instance;
+	    rv[ 2] = CU_USER;      rv[ 3] = cpu_stat->cpu_sysinfo.cpu[CPU_USER];
+	    rv[ 4] = CU_KERNEL;    rv[ 5] = cpu_stat->cpu_sysinfo.cpu[CPU_KERNEL];
+	    rv[ 6] = CU_IO_WAIT;   rv[ 7] = cpu_stat->cpu_sysinfo.cpu[CPU_WAIT];
+	    rv[ 8] = CU_IDLE;      rv[ 9] = cpu_stat->cpu_sysinfo.cpu[CPU_IDLE];
+	    
+	    rv += CU_KSTAT_VALUES*2;
+	    cpu_stats_read++;
+ 	}
+    }
+    
+    resv[0] = cpu_stats_read;
+    resv[1] = CU_KSTAT_VALUES;
+
+    *result_vec = resv;
+    *result_sz = 2 + 2* CU_KSTAT_VALUES * cpu_stats_read;
+
+}
+#endif
+
+/* ---------------------------- *
+ *	 Generic functions 	*
+ * ---------------------------- */
+
+static void send(unsigned int data) { sendv(&data, 1); }
+
+static void sendv(unsigned int data[], int ints) {
+    static unsigned char *buf = NULL;
+    static int bufsz = 0;
+    int rc, di, bi, msgsz;
+
+    /* Assumes 32-bit integers... */
+
+    msgsz = 4*ints;
+
+    if(bufsz < msgsz) {
+	if (buf != NULL) free((void *) buf);
+	buf = malloc(msgsz);
+	if (!buf) error("Error allocating memory");
+	bufsz = msgsz;
+    }
+
+    for(bi = 0, di = 0; di < ints; di++) {
+	buf[bi++] = (data[di] >> 24) & 0xff;
+	buf[bi++] = (data[di] >> 16) & 0xff;
+	buf[bi++] = (data[di] >>  8) & 0xff;
+	buf[bi++] = (data[di]      ) & 0xff;
+    }
+
+  bi = 0;
+  do {
+    rc = write(FD_OUT, &buf[bi], msgsz - bi);
+    if (rc < 0) {
+      if (errno == EINTR)
+	continue;
+      error("Error writing to Erlang");
+    }
+    bi += rc;
+  } while(msgsz - bi > 0);
+
+}
+
+static void error(char* err_msg) {
+  write(FD_ERR, err_msg, strlen(err_msg));
+  write(FD_ERR, "\n", 1);
+  exit(-1);
+}
+
+
diff --git a/lib/os_mon/c_src/ferrule.c b/lib/os_mon/c_src/ferrule.c
new file mode 100644
index 0000000000..744f302b2d
--- /dev/null
+++ b/lib/os_mon/c_src/ferrule.c
@@ -0,0 +1,160 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1996-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 	<stdio.h>
+#include 	<string.h>
+#include 	<stropts.h>
+#include 	<poll.h>
+#include 	<unistd.h>
+#include 	<sys/types.h>
+#include 	<sys/stat.h>
+#include	<fcntl.h>
+#include	<sys/uio.h>
+
+	/* arguments */
+#define		OWNPATH		1
+#define		NARG		1
+
+	/* status codes */
+#define		OK		0
+#define 	NOT_OK		1
+
+	/* hardwired constants*/
+#define 	PIPENAME	"syslog.otp"
+#define		DIE_CMD		"die"
+#define		ONLY_STDIN_CMD	"only_stdin"
+#define 	BUFFER_SIZE	1001
+#define 	MAXPATH_SIZE	1001
+#define		STDIN		0
+#define		STDOUT		1
+#define		HEADER_SIZE	2
+#define		WAIT		10
+#define		INTERVAL	1
+#define		FALSE		0
+#define		TRUE		1
+#define		FDS_STDIN	0
+#define		FDS_PIPE	1
+
+main(int argc, char *argv[])
+/*	usage: ferrule ownpath */
+{
+    int		i, pipe_fd;
+    long	int	nfds=2L;
+    char	buf[BUFFER_SIZE], pipename[MAXPATH_SIZE], packet_size[2];
+    struct	pollfd	fds[2];
+    struct	stat	stat_buf;
+    
+    /* enough arguments? */
+    if(argc < NARG+1)
+	exit(NOT_OK);
+    
+    /* make pipe name */
+    strcpy(pipename, argv[OWNPATH]);
+    strcat(pipename, "/");
+    strcat(pipename, PIPENAME);
+    
+    /* wait for creation of pipe */
+    for(i=WAIT; i>0; i--)
+	if(stat(pipename, &stat_buf) == 0)
+	    break;
+	else{
+	    if(i == 0)
+		exit(NOT_OK);
+	    else
+		sleep(INTERVAL);
+	}
+    
+    /* open pipe, exit if error */
+    if((pipe_fd = open(pipename, O_RDONLY | O_NONBLOCK)) == -1)
+	exit(NOT_OK);
+    
+    /* setup for pipe */
+    fds[FDS_PIPE].fd = pipe_fd;
+    fds[FDS_PIPE].events = POLLRDNORM;
+    fds[FDS_PIPE].revents = 0;
+    
+    /* setup for stdin */
+    fds[FDS_STDIN].fd = STDIN;
+    fds[FDS_STDIN].events = POLLRDNORM;
+    fds[FDS_STDIN].revents = 0;
+    
+    /* loop */
+    while(1){
+	/* wait for input */
+	if(poll(&fds[0], nfds, INFTIM) == -1)
+	    exit(NOT_OK);
+
+	/* analyse input from pipe */
+	if(fds[FDS_PIPE].revents != 0){
+
+	    /* pipe error, error exit */
+	    if((fds[FDS_PIPE].revents & (POLLHUP | POLLERR | POLLNVAL)) != 0)
+		exit(NOT_OK);
+
+	    /* read pipe and write to stdout, exit if error */
+	    if((fds[FDS_PIPE].revents & POLLRDNORM) != 0){
+		i=0;
+		do{
+		    read(pipe_fd, &buf[i++], (size_t)1);
+		}while(buf[i-1] != '\n');
+		i--;
+
+		/* send if string is not empty */
+		if(i != 0){
+		    /* make packet size, [0]=MSB, [1]=LSB */
+		    packet_size[0] = (i >> 8) & 0xff;
+		    packet_size[1] = i & 0xff;
+
+		    /* send to OTP process */
+		    if(write(STDOUT, packet_size, HEADER_SIZE) != HEADER_SIZE)
+			exit(NOT_OK);
+		    if(write(STDOUT, buf, i) != i)
+			exit(NOT_OK);
+		}
+	    }
+	}
+
+	/* analyse input from stdin */
+	if(fds[FDS_STDIN].revents != 0){
+
+	    /* error exit */
+	    if((fds[FDS_STDIN].revents & (POLLHUP | POLLERR | POLLNVAL)) != 0)
+		exit(NOT_OK);
+
+	    /* read bytes */
+	    if((fds[FDS_STDIN].revents & POLLRDNORM) != 0){
+		/* get packet size, [0]=MSB, [1]=LSB */
+		if(read(STDIN, packet_size, HEADER_SIZE) != HEADER_SIZE)
+		    exit(NOT_OK);
+		i = (packet_size[0] << 8) | packet_size[1];
+
+		/* get packet */
+		if(read(STDIN, buf, i) != i)
+		    exit(NOT_OK);
+
+		/* check if die command */
+		if(strncmp(DIE_CMD, buf, i) == FALSE)
+		    exit(OK);
+
+		/* check if only_stdin command */
+		if(strncmp(ONLY_STDIN_CMD, buf, i) == FALSE)
+		    nfds=1L;
+	    }
+	}
+    }
+}
diff --git a/lib/os_mon/c_src/memsup.c b/lib/os_mon/c_src/memsup.c
new file mode 100644
index 0000000000..241e7718db
--- /dev/null
+++ b/lib/os_mon/c_src/memsup.c
@@ -0,0 +1,655 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1996-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:  Portprogram for supervision of memory usage.
+ *
+ *  Synopsis: memsup
+ *
+ *  PURPOSE OF THIS PROGRAM
+ *
+ *  This program supervises the memory status of the entire system, and
+ *  sends status reports upon request from the Erlang system
+ *
+ *  SPAWNING FROM ERLANG
+ *
+ *  This program is started from Erlang as follows,
+ *
+ *      Port = open_port({spawn, 'memsup'}, [{packet,1}]) for UNIX and VxWorks
+ *
+ *  Erlang sends one of the request condes defined in memsup.h and this program
+ *  answers in one of two ways:
+ *  * If the request is for simple memory data (which is used periodically
+ *    for monitoring) the answer is simply sent in two packets.
+ *  * If the request is for the system specific data, the answer is delivered
+ *    in two packets per value, first a tag value, then the actual
+ *    value. The values are delivered "as is", this interface is
+ *    mainly for VxWorks.
+ *  All numbers are sent as strings of hexadecimal digits.
+ *
+ *  SUNOS FAKING
+ *
+ *  When using SunOS 4, the memory report is faked. The total physical memory
+ *  is always reported to be 256MB, and the used fraction to be 128MB.
+ *  
+ *  If capabilities, such as sysconf or procfs, is not defined on the system 
+ *  memsup will fake memory usage as well.
+ *  
+ *  Following ordering is defined for extended memory,
+ *  Linux:	procfs -> sysinfo -> sysconf -> fake
+ *  Sunos:	sysconf -> fake
+ *  other:	arch specific
+ *  
+ *  Todo:
+ *  Memory retrieval should be defined by capabilities and not by archs.
+ *  Ordering should be defined arch.
+ *  
+ *  STANDARD INPUT, OUTPUT AND ERROR
+ *
+ *  This program communicates with Erlang through the standard
+ *  input and output file descriptors (0 and 1). These descriptors
+ *  (and the standard error descriptor 2) must NOT be closed
+ *  explicitely by this program at termination (in UNIX it is
+ *  taken care of by the operating system itself; in VxWorks
+ *  it is taken care of by the spawn driver part of the Emulator).
+ *
+ *  END OF FILE
+ *
+ *  If a read from a file descriptor returns zero (0), it means
+ *  that there is no process at the other end of the connection
+ *  having the connection open for writing (end-of-file).
+ *
+ *  COMPILING
+ *
+ *  When the target is VxWorks the identifier VXWORKS must be defined for
+ *  the preprocessor (usually by a -D option).
+ */
+
+#if defined(sgi) || defined(__sgi) || defined(__sgi__)
+#include <sys/types.h>
+#include <sys/sysmp.h>
+#endif
+
+#include <stdio.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#ifndef VXWORKS
+#include <unistd.h>
+#endif
+
+#if (defined(__unix__) || defined(unix)) && !defined(USG)
+#include <sys/param.h>
+#endif
+
+#include <stdarg.h>
+
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+
+#ifdef VXWORKS
+#include <vxWorks.h>
+#include <ioLib.h>
+#include <memLib.h>
+#endif
+
+#ifdef BSD4_4
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#if !defined (__OpenBSD__) && !defined (__NetBSD__) 
+#include <vm/vm_param.h>
+#endif
+#if defined (__FreeBSD__) || defined(__DragonFly__)
+#include <sys/vmmeter.h>
+#endif
+#endif
+
+#if defined (__linux__)
+#include <sys/sysinfo.h>
+#endif
+
+/* commands */
+#include "memsup.h"
+
+#define CMD_SIZE      1
+#define MAX_CMD_BUF   10
+#define ERLIN_FD      0
+#define ERLOUT_FD     1
+
+
+/* procfs */
+#if defined(__linux__) 
+#include <fcntl.h>
+#define MEMINFO "/proc/meminfo"
+#endif
+
+/*  prototypes */
+
+static void print_error(const char *,...);
+#ifdef VXWORKS
+extern int erl_mem_info_get(MEM_PART_STATS *);
+#endif
+
+#ifdef VXWORKS
+#define MAIN memsup
+
+static MEM_PART_STATS latest;
+static unsigned long latest_system_total; /* does not fit in the struct */
+
+#else
+#define MAIN main
+#endif
+
+
+/*
+ * example, we want procfs information, now give them something equivalent: 
+ * 
+ * MemTotal:      4029352 kB	old 	HighTotal + LowTotal
+ * MemFree:       1674168 kB	old	HighFree + LowFree
+ * MemShared:           0 kB    old 	now always zero; not calculated
+ * Buffers:        417164 kB	old	temporary storage for raw disk blocks
+ * Cached:         371312 kB	old	in-memory cache for files read from the disk (the page cache)
+
+ * Active:        1408492 kB	new
+
+ * Inact_dirty:      7772 kB    new
+ * Inact_clean:      2008 kB    new
+ * Inact_target:        0 kB    new
+ * Inact_laundry:       0 kB    new, and might be missing too
+
+ * HighTotal:           0 kB
+ * HighFree:            0 kB		memory area for userspace programs or for the pagecache
+ * LowTotal:      4029352 kB		
+ * LowFree:       1674168 kB		Highmem + kernel stuff, slab allocates here
+
+ * SwapTotal:     4194296 kB	old	total amount of swap space available
+ * SwapFree:      4194092 kB	old	Memory which has been evicted from RAM
+ * Inactive:       549224 kB	2.5.41+
+ * Dirty:             872 kB	2.5.41+	Memory which is waiting to get written back to the disk
+ * Writeback:           0 kB	2.5.41+	Memory which is actively being written back to the disk
+ * AnonPages:      787616 kB	??
+ * Mapped:         113612 kB	2.5.41+	files which have been mmaped, such as libraries
+ * Slab:           342864 kB	2.5.41+	in-kernel data structures cache
+ * CommitLimit:   6208972 kB	??
+ * Committed_AS:  1141444 kB	2.5.41+
+ * PageTables:       9368 kB	2.5.41+
+ * VmallocTotal: 34359738367 kB	??	total size of vmalloc memory area
+ * VmallocUsed:     57376 kB	??	amount of vmalloc area which is used
+ * VmallocChunk: 34359677947 kB	??	largest contigious block of vmalloc area which is free
+ * ReverseMaps:      5738       2.5.41+	number of rmap pte chains
+ * SwapCached:          0 kB	2.5.??+	
+ * HugePages_Total:     0	2.5.??+
+ * HugePages_Free:      0	2.5.??+
+ * HugePages_Rsvd:      0	2.5.??+
+ * Hugepagesize:     2048 kB	2.5.??
+ *
+ * This information should be generalized for generic platform i.e. erlang.
+ */
+
+
+
+#define F_MEM_TOTAL   (1 << 0)
+#define F_MEM_FREE    (1 << 1)
+#define F_MEM_BUFFERS (1 << 2)
+#define F_MEM_CACHED  (1 << 3)
+#define F_MEM_SHARED  (1 << 4)
+#define F_SWAP_TOTAL  (1 << 5)
+#define F_SWAP_FREE   (1 << 6)
+
+typedef struct {
+    unsigned int flag;
+    unsigned long pagesize;
+    unsigned long total;
+    unsigned long free;
+    unsigned long buffered;
+    unsigned long cached;
+    unsigned long shared;
+    unsigned long total_swap;
+    unsigned long free_swap;
+} memory_ext;
+
+typedef struct mem_table_struct {
+  const char *name;     /* memory type name */
+  unsigned long *slot; /* slot in return struct */
+} mem_table_struct;
+
+
+/*  static variables */
+
+static char *program_name;
+
+static void
+send(unsigned long value, unsigned long pagesize) {
+    char buf[32];
+    int left, bytes, res;
+    int hex_zeroes;
+
+    for (hex_zeroes = 0; (pagesize % 16) == 0; pagesize /= 16) {
+	hex_zeroes++;
+    }
+    
+    sprintf(buf+1, "%lx", value*pagesize);
+    bytes = strlen(buf+1);
+    while (hex_zeroes-- > 0) {
+	bytes++;
+	buf[bytes] = '0';
+    }
+    buf[0] = (char) bytes;
+    left = ++bytes;
+
+    while (left > 0) {
+	res = write(ERLOUT_FD, buf+bytes-left, left);
+	if (res <= 0){
+	    perror("Error writing to pipe");
+	    exit(1);
+	}
+	left -= res;
+    }
+}
+
+static void
+send_tag(int value){
+    unsigned char buf[2];
+    int res,left;
+
+    buf[0] = 1U;
+    buf[1] = (unsigned char) value;
+    left = 2;
+    while(left > 0) {
+	if((res = write(ERLOUT_FD, buf+left-2,left)) <= 0){
+	    perror("Error writing to pipe");
+	    exit(1);
+	} else {
+	    left -= res;
+	}
+    }
+}
+
+
+#ifdef VXWORKS
+static void load_statistics(void){
+    if(memPartInfoGet(memSysPartId,&latest) != OK)
+	memset(&latest,0,sizeof(latest));
+    latest_system_total = latest.numBytesFree + latest.numBytesAlloc;
+    erl_mem_info_get(&latest); /* if it fails, latest is untouched */
+}
+#endif
+
+#ifdef BSD4_4
+static int
+get_vmtotal(struct vmtotal *vt) {
+	static int vmtotal_mib[] = {CTL_VM, VM_METER};
+	size_t size = sizeof *vt;
+
+	return sysctl(vmtotal_mib, 2, vt, &size, NULL, 0) != -1;
+}
+#endif
+
+#if defined(__linux__)
+
+
+static int 
+get_mem_procfs(memory_ext *me){
+    int fd, nread;
+    char buffer[4097];
+    char *bp;
+    unsigned long value;
+    
+    me->flag = 0;
+    
+    if ( (fd = open(MEMINFO, O_RDONLY)) < 0) return -1;
+
+    if ( (nread = read(fd, buffer, 4096)) < 0) {
+        close(fd);
+	return -1;
+    }
+    close(fd);
+
+    buffer[nread] = '\0';
+    
+    /* Total and free is NEEDED! */
+    
+    bp = strstr(buffer, "MemTotal:");    
+    if (sscanf(bp, "MemTotal: %lu kB\n", &(me->total)))  me->flag |= F_MEM_TOTAL;
+
+    bp = strstr(buffer, "MemFree:");    
+    if (sscanf(bp, "MemFree: %lu kB\n", &(me->free)))    me->flag |= F_MEM_FREE;
+    
+    /* Extensions */
+    
+    bp = strstr(buffer, "Buffers:");    
+    if (sscanf(bp, "Buffers: %lu kB\n", &(me->buffered))) me->flag |= F_MEM_BUFFERS;
+    
+    bp = strstr(buffer, "Cached:");    
+    if (sscanf(bp, "Cached: %lu kB\n", &(me->cached)))   me->flag |= F_MEM_CACHED;
+    
+
+    /* Swap */
+    
+    bp = strstr(buffer, "SwapTotal:");    
+    if (sscanf(bp, "SwapTotal: %lu kB\n", &(me->total_swap))) me->flag |= F_SWAP_TOTAL;
+    
+    bp = strstr(buffer, "SwapFree:");    
+    if (sscanf(bp, "SwapFree: %lu kB\n", &(me->free_swap))) me->flag |= F_SWAP_FREE;
+    
+    me->pagesize = 1024; /* procfs defines its size in kB */
+    
+    return 1;   
+}
+#endif
+
+
+/* arch specific functions */
+
+#if defined(VXWORKS)
+static int
+get_extended_mem_vxwork(memory_ext *me) {
+    load_statistics();
+    me->total    = (latest.numBytesFree + latest.numBytesAlloc);
+    me->free     = latest.numBytesFree;
+    me->pagesize = 1;
+    me->flag     = F_MEM_TOTAL | F_MEM_FREE;
+    return 1;
+}
+#endif
+
+
+#if defined(__linux__) /* ifdef SYSINFO */
+/* sysinfo does not include cached memory which is a problem. */
+static int
+get_extended_mem_sysinfo(memory_ext *me) {
+    struct sysinfo info;
+    me->flag = 0;
+    if (sysinfo(&info) < 0) return -1;
+    me->pagesize   = 1; 
+    me->total      = info.totalram;
+    me->free       = info.freeram;
+    me->buffered   = info.bufferram;
+    me->shared     = info.sharedram;
+    me->total_swap = info.totalswap;
+    me->free_swap  = info.freeswap;
+    
+    me->flag = F_MEM_TOTAL | F_MEM_FREE | F_MEM_SHARED | F_MEM_BUFFERS | F_SWAP_TOTAL | F_SWAP_FREE;
+
+    return 1;
+}
+#endif
+
+
+#if defined(_SC_AVPHYS_PAGES)
+static int
+get_extended_mem_sysconf(memory_ext *me) {
+    me->total      = sysconf(_SC_PHYS_PAGES);
+    me->free       = sysconf(_SC_AVPHYS_PAGES);
+    me->pagesize   = sysconf(_SC_PAGESIZE);
+
+    me->flag = F_MEM_TOTAL | F_MEM_FREE;
+
+    return 1;
+}
+#endif
+
+#if defined(BSD4_4)
+static int
+get_extended_mem_bsd4(memory_ext *me) {
+    struct vmtotal vt;
+    long pgsz;
+
+    if (!get_vmtotal(&vt)) return 0;
+    if ((pgsz = sysconf(_SC_PAGESIZE)) == -1) return 0;
+
+    me->total      = (vt.t_free + vt.t_rm);
+    me->free       = vt.t_free;
+    me->pagesize   = pgsz;
+    
+    me->flag = F_MEM_TOTAL | F_MEM_FREE;
+    
+    return 1;
+}
+#endif
+
+#if defined(sgi) || defined(__sgi) || defined(__sgi__)
+static int
+get_extended_mem_sgi(memory_ext *me) {
+    struct rminfo rmi;
+    if (sysmp(MP_SAGET, MPSA_RMINFO, &rmi, sizeof(rmi)) < 0)  return -1;
+
+    me->total    = (unsigned long)(rmi.physmem);
+    me->free     = (unsigned long)(rmi.freemem);
+    me->pagesize = (unsigned long)getpagesize(); 
+    me->flag = F_MEM_TOTAL | F_MEM_FREE;
+    
+    return 1;
+}
+#endif
+
+static void
+get_extended_mem(memory_ext *me) {
+/* vxworks */
+#if defined(VXWORKS)
+    if (get_extended_mem_vxworks(me)) return;
+
+/* linux */
+#elif defined(__linux__)
+    if (get_mem_procfs(me))  return;
+    if (get_extended_mem_sysinfo(me)) return;
+
+/* bsd */
+#elif defined(BSD4_4)
+    if (get_extended_mem_bsd4(me))    return;
+
+/* sgi */
+#elif defined(sgi) || defined(__sgi) || defined(__sgi__)
+    if (get_extended_mem_sgi(me))     return;
+#endif
+
+/* Does this exist on others than Solaris2? */
+#if defined(_SC_AVPHYS_PAGES)
+    if (get_extended_mem_sysconf(me)) return;
+
+/* We fake the rest */
+/* SunOS4 (for example) */
+#else  
+    me->free     = (1<<27);	       	/* Fake! 128 MB used */
+    me->total    = (1<<28);		/* Fake! 256 MB total */
+    me->pagesize = 1;
+    me->flag = F_MEM_TOTAL | F_MEM_FREE;
+#endif
+}
+    
+
+static void 
+get_basic_mem(unsigned long *tot, unsigned long *used, unsigned long *pagesize){
+#if defined(VXWORKS)
+    load_statistics();
+    *tot = (latest.numBytesFree + latest.numBytesAlloc);
+    *used = latest.numBytesAlloc;
+    *pagesize = 1;
+#elif defined(_SC_AVPHYS_PAGES)	/* Does this exist on others than Solaris2? */
+    unsigned long avPhys, phys, pgSz;
+    
+    phys = sysconf(_SC_PHYS_PAGES);
+    avPhys = sysconf(_SC_AVPHYS_PAGES);
+    *used = (phys - avPhys);
+    *tot = phys;
+    *pagesize = sysconf(_SC_PAGESIZE);
+#elif defined(__linux__) && !defined(_SC_AVPHYS_PAGES)
+    memory_ext me;
+    if (get_mem_procfs(&me) < 0) {
+        print_error("ProcFS read error.");
+        exit(1);
+    }
+    *tot      = me.total;
+    *pagesize = me.pagesize;
+    *used     = me.total - me.free;
+#elif defined(BSD4_4)
+    struct vmtotal vt;
+    long pgsz;
+
+    if (!get_vmtotal(&vt)) goto fail;
+    if ((pgsz = sysconf(_SC_PAGESIZE)) == -1) goto fail;
+    *tot = (vt.t_free + vt.t_rm);
+    *used = vt.t_rm;
+    *pagesize = pgsz;
+    return;
+fail:
+    print_error("%s", strerror(errno));
+    exit(1);
+#elif defined(sgi) || defined(__sgi) || defined(__sgi__)
+    struct rminfo rmi;
+    if (sysmp(MP_SAGET, MPSA_RMINFO, &rmi, sizeof(rmi)) != -1) {
+	*tot = (unsigned long)(rmi.physmem);
+	*used = (unsigned long)(rmi.physmem - rmi.freemem);
+	*pagesize = (unsigned long)getpagesize(); 
+    } else {
+	print_error("%s", strerror(errno));
+	exit(1); 
+    }
+#else  /* SunOS4 */
+    *used = (1<<27);	       	/* Fake! 128 MB used */
+    *tot = (1<<28);		/* Fake! 256 MB total */
+    *pagesize = 1;
+#endif
+}    
+
+static void
+simple_show_mem(void){
+    unsigned long tot, used, pagesize;
+    get_basic_mem(&tot, &used, &pagesize);
+    send(used, pagesize);
+    send(tot, pagesize);
+}
+
+static void 
+extended_show_mem(void){
+    memory_ext me;
+    unsigned long ps;
+    
+    get_extended_mem(&me);
+    ps = me.pagesize;
+   
+    if (me.flag & F_MEM_TOTAL)  { send_tag(MEM_TOTAL);        send(me.total, ps);      }
+    if (me.flag & F_MEM_FREE)   { send_tag(MEM_FREE);         send(me.free, ps);       }
+
+    /* extensions */
+    if (me.flag & F_MEM_BUFFERS){ send_tag(MEM_BUFFERS);      send(me.buffered, ps);   }
+    if (me.flag & F_MEM_CACHED) { send_tag(MEM_CACHED);       send(me.cached, ps);     }
+    if (me.flag & F_MEM_SHARED) { send_tag(MEM_SHARED);       send(me.shared, ps);     }
+    
+    /* swap */
+    if (me.flag & F_SWAP_TOTAL) { send_tag(SWAP_TOTAL);       send(me.total_swap, ps); }
+    if (me.flag & F_SWAP_FREE)  { send_tag(SWAP_FREE);        send(me.free_swap, ps);  }
+    
+#ifdef VXWORKS
+    send_tag(SM_SYSTEM_TOTAL);
+    send(latest_system_total, 1);
+    send_tag(SM_LARGEST_FREE);
+    send(latest.maxBlockSizeFree, 1);
+    send_tag(SM_NUMBER_OF_FREE);
+    send(latest.numBlocksFree, 1);
+#else
+    /* total is system total*/
+    if (me.flag & F_MEM_TOTAL)  { send_tag(MEM_SYSTEM_TOTAL); send(me.total, ps);     }
+#endif
+    send_tag(SHOW_SYSTEM_MEM_END);
+}    
+
+static void
+message_loop(int erlin_fd)
+{
+    char cmdLen, cmd;
+    int res;
+    
+    while (1){
+	/*
+	 *  Wait for command from Erlang
+	 */
+	if ((res = read(erlin_fd, &cmdLen, 1)) < 0) {
+	    print_error("Error reading from Erlang.");
+	    return;
+	}
+
+	if (res == 1) {		/* Exactly one byte read ? */
+	    if (cmdLen == 1){	/* Should be! */
+		switch (read(erlin_fd, &cmd, 1)){
+		case 1:	  
+		    switch (cmd){
+		    case SHOW_MEM:
+			simple_show_mem();
+			break;
+		    case SHOW_SYSTEM_MEM:
+			extended_show_mem();
+			break;
+		    default:	/* ignore all other messages */
+			break;
+		    }
+		  break;
+		  
+		case 0:
+		  print_error("Erlang has closed.");
+		  return;
+
+		default:
+		  print_error("Error reading from Erlang.");
+		  return;
+		} /* switch() */
+	    } else { /* cmdLen != 1 */
+		print_error("Invalid command length (%d) received.", cmdLen);
+		return;
+	    }
+	} else {		/* Erlang end closed */
+	    print_error("Erlang has closed.");
+	    return;
+	}
+    }
+}
+
+/*
+ *  main
+ */
+int
+MAIN(int argc, char **argv)
+{
+  program_name = argv[0];
+  message_loop(ERLIN_FD);
+  return 0;
+}
+
+
+/*
+ *  print_error
+ *
+ */
+static void
+print_error(const char *format,...)
+{
+  va_list args;
+
+  va_start(args, format);
+  fprintf(stderr, "%s: ", program_name);
+  vfprintf(stderr, format, args);
+  va_end(args);
+  fprintf(stderr, " \n");
+}
+
+
+
+
+
diff --git a/lib/os_mon/c_src/memsup.h b/lib/os_mon/c_src/memsup.h
new file mode 100644
index 0000000000..926df0a847
--- /dev/null
+++ b/lib/os_mon/c_src/memsup.h
@@ -0,0 +1,46 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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 header defines the protocol between the erlang 
+ * memsup module and the C module.
+ */
+#ifndef _SYSMEM_H
+#define _SYSMEM_H
+
+/* Simple memory statistics */
+/*IG*/ #define SHOW_MEM 1 
+
+/* Extended memory statistics */
+/*IG*/ #define SHOW_SYSTEM_MEM 2
+
+/* Tags for the extended statistics */
+/*IG*/ #define SHOW_SYSTEM_MEM_END 0
+/*IG*/ #define MEM_SYSTEM_TOTAL 1
+/*IG*/ #define MEM_TOTAL 2
+/*IG*/ #define MEM_FREE 3
+/*IG*/ #define MEM_LARGEST_FREE 4
+/*IG*/ #define MEM_NUMBER_OF_FREE 5
+/*Extension*/
+/*IG*/ #define MEM_BUFFERS 6
+/*IG*/ #define MEM_CACHED 7
+/*IG*/ #define MEM_SHARED 8
+/*IG*/ #define SWAP_TOTAL 9
+/*IG*/ #define SWAP_FREE 10
+
+#endif
diff --git a/lib/os_mon/c_src/mod_syslog.c b/lib/os_mon/c_src/mod_syslog.c
new file mode 100644
index 0000000000..87fbfbac22
--- /dev/null
+++ b/lib/os_mon/c_src/mod_syslog.c
@@ -0,0 +1,137 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1996-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 	<stdio.h>
+#include 	<string.h>
+#include 	<unistd.h>
+#include 	<sys/types.h>
+#include 	<sys/stat.h>
+#include 	<signal.h>
+
+	/* arguments */
+#define		MODE		1
+#define		OWNPATH		2
+#define		SYSLOGCONF	3
+#define		NARG		3
+
+	/* status codes */
+#define		OK		0
+#define 	ARG_ERROR	-1
+#define 	FILE_ERROR	-2
+#define 	KILL_ERROR	-3
+#define		PIPE_NOT_FOUND	1
+
+	/* hardwired */
+#define 	SYSLOG_PID	"/etc/syslog.pid"
+#define 	PIPENAME	"syslog.otp"
+#define		SYSLOGCONF_ORIG	"syslog.conf.ORIG"
+#define		SYSLOGCONF_OTP	"syslog.conf.OTP"
+#define 	BUFFER_SIZE	1001
+#define 	MAXNAME_SIZE	1001
+#define		FALSE		0
+#define		TRUE		1
+#define		WAIT		1
+
+main(int argc, char *argv[])
+/*	usage: mod_syslog mode ownpath syslogconf */
+{
+    int	syslogd_pid, n_lines_copied=0;
+    int	otp_sw, find_sw=FALSE;
+    char	buf[BUFFER_SIZE], pipename[MAXNAME_SIZE], srcname[MAXNAME_SIZE];
+    FILE	*srcfile, *destfile, *pidfile;
+    
+    void	make_exit(int);
+    
+    /* enough arguments? */
+    if(argc < NARG+1)
+	make_exit(ARG_ERROR);
+    
+    /* enable OTP or not */
+    if(strcmp(argv[MODE], "otp") == 0)
+	otp_sw = TRUE;
+    else if(strcmp(argv[MODE], "nootp") == 0)
+	otp_sw = FALSE;
+    else
+	make_exit(ARG_ERROR);
+    
+    /* make pipename */
+    strcpy(pipename, argv[OWNPATH]);
+    strcat(pipename, "/");
+    strcat(pipename, PIPENAME);
+    
+    /* remove old pipe and make a new one */
+    if(otp_sw){
+	/* remove */
+	unlink(pipename);
+
+	/* make a new */
+	if(mknod(pipename, S_IFIFO | S_IRUSR | S_IWUSR | S_IRGRP |
+		 S_IWGRP | S_IROTH | S_IWOTH, (dev_t)0) != 0)
+	    make_exit(FILE_ERROR);
+    }
+    
+    /* make source filename */
+    strcpy(srcname, argv[OWNPATH]);
+    strcat(srcname, "/");
+    strcat(srcname, otp_sw?SYSLOGCONF_OTP:SYSLOGCONF_ORIG);
+    
+    /* open source and destination, exit if error */
+    if((srcfile = fopen(srcname, "r")) == NULL ||
+       (destfile = fopen(argv[SYSLOGCONF], "w")) == NULL)
+	make_exit(FILE_ERROR);
+    
+    /* copy source and destination, exit if error */
+    while(fgets(buf, BUFFER_SIZE-1, srcfile) != NULL){
+	/*	find_sw |= strstr(buf, PIPENAME) != NULL;	*/
+	n_lines_copied++;
+	if(fputs(buf, destfile) == EOF)
+	    make_exit(FILE_ERROR);
+    }
+    if(ferror(srcfile) || n_lines_copied == 0)
+	make_exit(FILE_ERROR);
+    
+    /* open pidfile, exit if error */
+    if((pidfile = fopen(SYSLOG_PID, "r")) == NULL)
+	make_exit(FILE_ERROR);
+    
+    /* read pid for syslogd, exit if error */
+    if(fscanf(pidfile, "%d", &syslogd_pid) == 0)
+	make_exit(FILE_ERROR);
+    
+    /* send HUP to syslogd, exit if error */
+    if(syslogd_pid < 0 || kill((pid_t)syslogd_pid, SIGHUP) != 0)
+	make_exit(KILL_ERROR);
+    
+    /* remove pipe */
+    if(!otp_sw){
+	sleep((unsigned)WAIT);
+	unlink(pipename);
+    }
+    
+    /* ending successful or with warning */
+    /* if(!find_sw && otp_sw)
+       make_exit(PIPE_NOT_FOUND);
+       else */
+    make_exit(OK);
+}
+
+void	make_exit(int exit_code)
+{
+    printf("%d", exit_code);
+    exit(0);
+}
diff --git a/lib/os_mon/c_src/nteventlog/elog_format.c b/lib/os_mon/c_src/nteventlog/elog_format.c
new file mode 100644
index 0000000000..c9fb6b7e1a
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_format.c
@@ -0,0 +1,173 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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 "elog_global.h"
+#include "elog_format.h"
+
+/*
+ * The Newline treatment bits of FormatMessage
+ * This value should suppress all other than hardcoded newlines
+ */
+#define NL_TREATMENT FORMAT_MESSAGE_MAX_WIDTH_MASK
+
+/*
+ * Expands %%NNN formats in strings with strings from a
+ * ParameterMessageFile (open).
+ * A return of NULL means there's nothing to expand
+ * or that the buffer is to small, which probably means the 
+ * same thing to the caller, that is use the
+ * original string as it is.
+ */
+static char *expand_message(char *toexpand, 
+			    HINSTANCE paramlib,
+			    char *buff, int bufflen){
+  char *oldpos;
+  int buffpos = 0;
+  char *pos = toexpand;
+  char *end;
+  unsigned long num;
+  char *replbuff = malloc(bufflen);
+  char *repl;
+  int replaced = 0;
+
+  while((oldpos = pos, pos = strstr(pos,"%%"))){
+    num = strtoul(pos + 2, &end, 0);
+    replaced = 1;
+    if(end == pos + 2 || num == 0){
+      repl = "%%";
+    } else {
+      if(!FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | 
+			FORMAT_MESSAGE_IGNORE_INSERTS | 
+			NL_TREATMENT,
+			(LPCVOID) paramlib,
+			(DWORD) num,
+			DEFAULT_LANGID,
+			replbuff,
+			(DWORD) bufflen,
+			NULL)){
+	repl = ""; /* this is how the event logger treats it... */
+      } else {
+	repl = replbuff;
+      }
+    }
+    if((int)(buffpos + strlen(repl) + (pos - oldpos) + 1) > bufflen){
+      free(replbuff);
+      return NULL;
+    }
+    strncpy(&(buff[buffpos]),oldpos, pos - oldpos);
+    buffpos += pos - oldpos;
+    strcpy(&(buff[buffpos]), repl);
+    buffpos += strlen(repl);
+    pos = end;
+  }
+  free(replbuff);
+  if(!replaced)
+    return NULL;
+  if((int) (buffpos + strlen(oldpos) + 1) > bufflen)
+    return NULL;
+  strcpy(&(buff[buffpos]),oldpos);
+  return buff;
+}
+
+/* 
+ * A lot to free when returning from format_message, lets make it easier
+ */
+static char *fm_free_up(char **argv, char *tmpbuff, 
+			char * tmpbuff2,
+			HINSTANCE elibrary, 
+			HINSTANCE plibrary){
+  if(plibrary != NULL){
+    FreeLibrary(plibrary);
+    while(*argv)
+      free(*argv++);
+  }
+  free(tmpbuff);
+  free(tmpbuff2);
+  if(elibrary != NULL)
+    FreeLibrary(elibrary);
+  return NULL;
+}
+
+#define FM_RETURN(X) \
+return (fm_free_up(argv, tmpbuff, tmpbuff2, elibrary, plibrary), (X))
+
+/*
+ * Formats an eventlog message into a string buffer.
+ * Returns NULL if message could not be formatted (buffer to small or 
+ * library error). 
+ */
+char *format_message(MessageFiles mf, DWORD id, 
+		     char *strings, int numstrings, 
+		     char *buff, int bufflen){
+  char *argv[MAX_PARAM_STRINGS];
+  int argc,i;
+  HINSTANCE elibrary = NULL;
+  HINSTANCE plibrary = NULL;
+  char *tmpbuff = malloc(bufflen);
+  char *tmpbuff2 = malloc(bufflen);
+
+  for(argc=0;argc < numstrings && argc < MAX_PARAM_STRINGS - 1; ++argc)
+    argv[argc] = 
+      (argc) ? argv[argc - 1] + strlen(argv[argc - 1]) + 1 : strings;
+
+  argv[argc] = NULL; 
+  
+  if((elibrary = LoadLibraryEx(mf.event, NULL, DONT_RESOLVE_DLL_REFERENCES)) 
+     == NULL)
+    FM_RETURN(NULL);
+
+  if(!FormatMessage(FORMAT_MESSAGE_FROM_HMODULE | 
+		    FORMAT_MESSAGE_IGNORE_INSERTS | NL_TREATMENT,
+		    (LPCVOID) elibrary,
+		    id,
+		    DEFAULT_LANGID,
+		    tmpbuff2,
+		    (DWORD) bufflen,
+		    NULL)){
+    FM_RETURN(NULL);
+  }
+
+  if(mf.param != NULL)
+    plibrary = LoadLibraryEx(mf.param, NULL, DONT_RESOLVE_DLL_REFERENCES);
+
+  if(plibrary){
+    for(i=0;argv[i];++i)
+      if(expand_message(argv[i], plibrary, tmpbuff, bufflen) != NULL)
+	argv[i] = strdup(tmpbuff);
+      else 
+	argv[i] = strdup(argv[i]); /* All gets malloced, so I don't have to
+				      bother what to free... */ 
+    if(expand_message(tmpbuff2, plibrary, tmpbuff, bufflen) != NULL)
+      strcpy(tmpbuff2,tmpbuff);
+  }
+
+  if(!FormatMessage(FORMAT_MESSAGE_FROM_STRING | 
+		    FORMAT_MESSAGE_ARGUMENT_ARRAY | NL_TREATMENT,
+		    (LPCVOID) tmpbuff2,
+		    id,
+		    DEFAULT_LANGID,
+		    buff,
+		    (DWORD) bufflen,
+		    argv)){
+    FM_RETURN(NULL);
+  }
+
+  FM_RETURN(buff);
+
+}
+#undef FM_RETURN
diff --git a/lib/os_mon/c_src/nteventlog/elog_format.h b/lib/os_mon/c_src/nteventlog/elog_format.h
new file mode 100644
index 0000000000..3fb19367ab
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_format.h
@@ -0,0 +1,40 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+#ifndef _ELOG_FORMAT_H
+#define _ELOG_FORMAT_H
+/*
+ * Module: elog_format
+ * Purpouse: Format messages in the eventlog.
+ * ToDo: Maximum buffersize is used...
+ */
+
+#include "elog_global.h"
+
+char *format_message(MessageFiles mf, DWORD id, 
+		     char *strings, int numstrings, 
+		     char *buff, int bufflen);
+/*
+ * Formats an eventlog message with the messagefiles
+ * in mf, the ID id, the stringarray strings, 
+ * containing numstrings strings into buff.
+ * if bufflen is to small or anything else failes, 
+ * the return value is NULL.
+ */
+
+#endif /* _ELOG_FORMAT_H */
diff --git a/lib/os_mon/c_src/nteventlog/elog_global.h b/lib/os_mon/c_src/nteventlog/elog_global.h
new file mode 100644
index 0000000000..f992b7184f
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_global.h
@@ -0,0 +1,57 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+#ifndef _ELOG_GLOBAL_H
+#define _ELOG_GLOBAL_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <process.h>
+
+#define STRICT
+#define WIN32_LEAN_AND_MEAN
+#include "windows.h"
+
+#ifdef _DEBUG
+/*#define HARDDEBUG*/
+#define DEBUG
+#endif
+
+/*
+ * Compile time limits
+ */
+#define SMALLBUFSIZ 512
+#define BIGBUFSIZ 2048
+#define MAX_PARAM_STRINGS 200
+#define MAX_FACILITY_NAME 100
+
+/*
+ * Structure containing message file names
+ */
+typedef struct _message_files {
+  char *event;
+  char *param;
+} MessageFiles;
+
+/*
+ * How to get the default language
+ */
+#define DEFAULT_LANGID MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT)
+
+#endif /* _ELOG_GLOBAL_H */
diff --git a/lib/os_mon/c_src/nteventlog/elog_main.c b/lib/os_mon/c_src/nteventlog/elog_main.c
new file mode 100644
index 0000000000..f79f32c8ef
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_main.c
@@ -0,0 +1,504 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+/*
+ * Module: elog_main
+ * Purpouse: Main program and logic in the nteventlog program
+ * which waits for logging events and sends them to erlang.
+ * At startup, the registry keys for the identifier given on the
+ * command line are read to see what log record was the last 
+ * displayed for this identifier. All "new" records are then 
+ * displayed. After that the program waits for new events to arrive 
+ * and displays them (sends them to erlang). If stdin is a pipe
+ * (not a console) an ACK is requested for every entry displayed.
+ * when the ACK is received, the registry entries for the identifier
+ * is updated, so that next time the program starts, only the new
+ * entries are displayed.
+ */
+#include "elog_global.h"
+#include "elog_util.h"
+#include "elog_pipe_stdin.h"
+#include "elog_format.h"
+#include "elog_registry.h"
+
+/*
+ * A race condition in the event log notification and the 
+ * event log reading results in us having to retry reading the
+ * eventlog after some time. One second seems to do it...
+ */
+#define RETRY_TIMEOUT 1000
+
+/*
+ * Constants for the logging formats.
+ */
+#define LOG_FORMAT "%s [%s] %s, %s: %s\n" 
+#define PIPE_LOG_FORMAT "%dH%s%dH%s%dH%s%dH%s%dH%s"
+#define PIPE_LOG_ACK "A"
+#define PIPE_LOG_EXTRA (5*10) /* 5 int */
+#define ACK_MAX 100
+#define TIME_FORMAT "%d-%b-%Y %H:%M:%S GMT"
+/*                    2  3  4  2  2  2     */
+#define TIME_BUFSIZ 25
+#define CANT_FORMAT_MESSAGE "[EventLogReader unable to format message text]"
+
+/* the default registry identification */
+#define DEFAULT_IDENT "DefaultIdent"
+
+/*#define HARDDEBUG*/
+
+/* Flag set if eventlog is purged and need reopening.*/
+static int reopen_event_log = 0;
+
+/*
+ * Calculates the needed buffersize for a record in the eventlog.
+ * if recordnum == 0, looks at next record, otherwise looks
+ * at the record with the given number.
+ */
+static DWORD needed(HANDLE elog, DWORD recordnum){
+  EVENTLOGRECORD dummy;
+  DWORD red, need;
+  DWORD last_error;
+  DWORD flags = 
+    EVENTLOG_FORWARDS_READ | 
+    ((recordnum) ? EVENTLOG_SEEK_READ : EVENTLOG_SEQUENTIAL_READ);
+#ifdef HARDDEBUG
+  fprintf(stderr,"Calculating need when recordnum = %lu\n",recordnum);
+#endif
+  if(!ReadEventLog(elog,
+		   flags,
+		   recordnum,
+		   &dummy,
+		   (DWORD) sizeof(EVENTLOGRECORD),
+		   &red,
+		   &need) &&
+     (last_error = GetLastError()) == ERROR_INSUFFICIENT_BUFFER){
+    return need;
+  } else if(last_error == ERROR_EVENTLOG_FILE_CHANGED){
+    reopen_event_log = 1;
+    return (DWORD) 0;
+  } else {
+#ifdef HARDDEBUG
+    output_error(last_error,"needed() failed to read eventlog");
+#endif
+    return (DWORD) 0;
+  }
+}  
+
+
+/*
+ * Checks (any type of) stdin for end of file.
+ * Expects data present on stdin.
+ */
+BOOL eof_on_stdin(void){
+  HANDLE in = GetStdHandle(STD_INPUT_HANDLE);
+  char x[1];
+  DWORD y;
+  INPUT_RECORD input;
+  DWORD red;
+  static int state = 1; /* Return pressed = 1, ^Z after that = 2 */
+
+  if(!console_stdin()){
+    return peek_pipe_stdin_eof();
+  }
+  /* Console input, may be just about every type of event, look for
+     ^Z pressed... */
+  if(!ReadConsoleInput(in,&input,1,&red))
+    return FALSE;
+  if(input.EventType != KEY_EVENT)
+    return FALSE;
+  if(input.Event.KeyEvent.bKeyDown){
+    switch(input.Event.KeyEvent.uChar.AsciiChar){
+    case 0:
+      break;
+    case 13:
+      x[0] = '\r';
+      WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),"\r\n",2,&y,NULL);
+      if(state == 2) 
+	return TRUE;
+      else
+	state = 1;
+      break;
+    case 26:
+      if(state == 1)
+	state = 2;
+      WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),"^Z",2,&y,NULL);
+      break;
+    default:
+      if(((unsigned char) input.Event.KeyEvent.uChar.AsciiChar) < ' '){
+	WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),"^",1,&y,NULL);
+	x[0] = input.Event.KeyEvent.uChar.AsciiChar + '@';
+      } else 
+	x[0] = input.Event.KeyEvent.uChar.AsciiChar;
+      WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),x,1,&y,NULL);
+      state = 0;
+      break;
+    }
+    return FALSE;
+  }
+  return FALSE;
+}
+
+/*
+ * Writes eventlog entries to erlang and requires ACK for
+ * each record.
+ */
+BOOL data_to_pipe(char *string, char *answer, int answer_siz){
+  unsigned char len[2];
+  unsigned char *ptr;
+  int siz = strlen(string);
+  HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
+  HANDLE in = GetStdHandle(STD_INPUT_HANDLE);
+  DWORD written, red;
+  DWORD left;
+
+  len[0] = (siz >> 8) & 0xFF;
+  len[1] = siz & 0xFF;
+  if(!WriteFile(out, len, 2, 
+	    &written, NULL) || written != 2)
+    return FALSE;
+  if(!WriteFile(out, string, siz, &written, NULL) ||
+     written != (DWORD) siz)
+    return FALSE;
+  /* Read ACK from erlang */
+  left = 2;
+  ptr = len;
+  for(;;){
+    if(!(red = read_pipe_stdin(ptr, left)))
+      return FALSE;
+    else if(red < left){
+      ptr += red;
+      left -= red;
+    } else {
+      break;
+    }
+  }
+  siz = len[0] << 8 | len[1];
+
+  if(siz >= answer_siz - 1)
+    return FALSE;
+
+  left = siz;
+  ptr = (unsigned char *) answer;
+  for(;;){
+    if(!(red = read_pipe_stdin(ptr, left))){
+      return FALSE;
+    } else if(red < left){
+      ptr += red;
+      left -= red;
+    } else {
+      break;
+    }
+  }
+  answer[siz] = '\0';
+  return TRUE;
+}
+
+/*
+ * The actual writing of records.
+ * Behaves differently if stdout is a pipe (erlang)
+ * or a console (test run).
+ */
+  
+BOOL output_record(char *category, EVENTLOGRECORD *event){
+  char *strbeg, *fac, *sev;
+  char eventfilename[MAX_PATH];
+  char paramfilename[MAX_PATH];
+  char bigbuff[BIGBUFSIZ];
+  MessageFiles mf;
+  char tbuff[TIME_BUFSIZ];
+  BOOL ret;
+  DWORD written;
+  char *buff;
+  char ackbuff[ACK_MAX];
+
+  mf = get_messagefiles(category,((char *)event)+sizeof(EVENTLOGRECORD),
+			eventfilename, MAX_PATH,
+			paramfilename, MAX_PATH);
+  if(!mf.event){
+    strcpy(bigbuff, CANT_FORMAT_MESSAGE);
+  } else {
+    strbeg = (char *) event;
+    strbeg += event->StringOffset;
+    if(!format_message(mf, event->EventID,
+		       strbeg, event->NumStrings, bigbuff, BIGBUFSIZ)){
+      strcpy(bigbuff, CANT_FORMAT_MESSAGE);
+    }
+  }
+  fac = ((char *)event)+sizeof(EVENTLOGRECORD);
+  sev = lookup_severity(event->EventType);
+  if(console_stdin()){
+    *tbuff = '\0';
+    strftime(tbuff, (size_t) TIME_BUFSIZ, TIME_FORMAT, 
+	     gmtime((time_t *)&(event->TimeGenerated)));
+    buff = 
+      malloc(strlen(bigbuff) + TIME_BUFSIZ /* date-time */ + 
+	     strlen(category) +
+	     strlen(fac) /* facility */   +
+	     strlen(sev) /*severity */+
+	     strlen(LOG_FORMAT) /* More than actually needed */ + 1);
+    sprintf(buff, LOG_FORMAT, tbuff, fac, category, sev, bigbuff); 
+    ret = WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buff, strlen(buff), 
+		    &written, NULL); /* Overlapped structure for stdout? */
+  free(buff);
+  } else { /* pipe */
+    sprintf(tbuff,"%lu", event->TimeGenerated); 
+    buff = malloc(strlen(bigbuff) + 
+		  strlen(tbuff) + 
+		  strlen(category) +
+		  strlen(fac) +
+		  strlen(sev) +
+		  strlen(PIPE_LOG_FORMAT) +
+		  PIPE_LOG_EXTRA);
+    sprintf(buff,PIPE_LOG_FORMAT,
+	    strlen(tbuff),tbuff,
+	    strlen(category), category,
+	    strlen(fac), fac,
+	    strlen(sev), sev,
+	    strlen(bigbuff), bigbuff);
+    ret = data_to_pipe(buff,ackbuff, ACK_MAX);
+    if(ret && strcmp(ackbuff,PIPE_LOG_ACK))
+      ret = FALSE;
+    free(buff);
+  }
+  return ret;
+}
+
+
+/*
+ * Read eventlog entries FOLLOWING the given record
+ * number and timestamp, and sends them to
+ * stdout. If timestamp does
+ * not correspond with record number, the
+ * log is concidered wrapped around
+ * and is reread from the beginning.
+ * time is ignored if 0.
+ * If record_number is 0, the whole log is read (if there is one).
+ * If the function is unsuccessful, the global variable 
+ * reopen_event_log may be set to TRUE, which means 
+ * that the eventlog has changed and has to be reopened.
+ * It's the callers responsibility to set reopen_event_log to
+ * 0 before calling.
+ */ 
+static int read_from(DWORD *record_number, DWORD *time, 
+		     HANDLE elog, char *category){
+  DWORD dummy;
+  static EVENTLOGRECORD *event = NULL;
+  static DWORD eventsiz = 0;
+  DWORD red, need;
+  /* Always begin reading from record 1, record 0 never exists */
+  DWORD tmp = (*record_number) ? *record_number : 1; 
+  DWORD ttmp = *time;
+  int skip = !!(*record_number); /* Dont skip if record_number == 0 */
+  int maybe_done = 0;
+  int i;
+
+  /* First try seeking to the correct place in the eventlog */
+  /* the variable skip tells us that we are rereading the */ 
+  /* last read eventlog record and the variable */
+  /* maybe_done tells us that we have read the last eventlog */
+  /* and an EOF is OK. */
+  for(;;){
+    if(!(need = needed(elog, tmp))){
+      if(maybe_done) /* Has read one correct record
+			and are satisfied with that. */
+	return 0;
+      /* Hmm, could not find the record? Try the oldest... */
+      if(!GetOldestEventLogRecord(elog, &tmp) ||
+	 !(need = needed(elog, tmp))){
+	/* Something's terribly wrong. */
+#ifdef HARDDEBUG
+	fprintf(stderr,"Could not get oldest eventlog record!\n",
+		need);
+#endif
+	return -1;
+      }
+      skip = 0;
+    }
+    /* need == number of bytes for this record, 
+       tmp == this recordnumber */
+    if(!event)
+      event = malloc(eventsiz = need);
+    else if(eventsiz < need)
+      event = realloc(event, eventsiz = need);
+    if(!ReadEventLog(elog,
+		     (DWORD) (EVENTLOG_FORWARDS_READ | 
+		     EVENTLOG_SEEK_READ),
+		     tmp,
+		     event,
+		     need,
+		     &red,
+		     &dummy)){
+      if(GetLastError() == ERROR_EVENTLOG_FILE_CHANGED){
+	reopen_event_log = 1;
+      } 
+#ifdef HARDDEBUG
+      output_error(GetLastError(), 
+		   "Failed first eventlog read in read_from\n");
+#endif
+      return -1;
+    }
+    if(skip){
+      if(ttmp && event->TimeWritten != ttmp){
+	/* Wrapped around eventlog */
+	tmp = 1;
+      } else {
+	maybe_done = 1;
+	++tmp;
+      }
+      skip = 0;
+    } else
+      break;
+  }
+  /* Got the first record in buffer, display and continue reading */
+  /* sequentially from here. */
+  for(i=1;;++i){
+    if(!output_record(category, event))
+      return -1;
+    *record_number = event->RecordNumber;
+    *time = event->TimeWritten;
+    if(!(need = needed(elog,(DWORD) 0)))
+      break; /* End of log */
+    if(eventsiz < need)
+      event = realloc(event, eventsiz = need);
+    if(!ReadEventLog(elog,
+		     (DWORD) EVENTLOG_FORWARDS_READ | 
+		     EVENTLOG_SEQUENTIAL_READ,
+		     (DWORD) 0,
+		     event,
+		     need,
+		     &red,
+		     &dummy)){
+      if(GetLastError() == ERROR_EVENTLOG_FILE_CHANGED){
+	reopen_event_log = 1;
+      } 
+      return -1;
+    }
+  }
+  return i;
+}
+
+/*
+ * Read unread events and wait for new to arrive.
+ */
+int main(int argc, char **argv){
+  HANDLE elog[NUM_CATEGORIES]; 
+  HANDLE events[NUM_CATEGORIES + 1]; /* The stdin handle goes 
+				      in here to */
+  int eventlen;
+  char *ident;
+  DWORD record = 0, time = 0; 
+  RegKeys rk[NUM_CATEGORIES];
+  int rklen = NUM_CATEGORIES;
+  int i;
+  int ret;
+  int x = 0;
+  int retry = 0;
+
+  if(argc < 2){
+    ident = DEFAULT_IDENT;
+  } else {
+    ident = argv[1];
+  }
+
+  if(!setup_pipe_stdin()){
+    fprintf(stderr,"%s: Stdin could not be initialized.\n",argv[0]);
+    return 1;
+  }
+  if(get_regkeys(ident, rk, &rklen) != 0){
+    fprintf(stderr, 
+	    "%s: Could not get/create registry parameters.\n", argv[0]);
+    return 1;
+  }
+  for(;;){
+    for(i=0; i<rklen; ++i){
+      elog[i] = OpenEventLog(NULL, rk[i].facility_name);
+      
+      if(elog[i] == NULL){
+	fprintf(stderr, 
+		"%s: Could not open \"%s\" eventlog.\n",
+		argv[0], rk[i].facility_name);
+	return 1;
+      }
+      if((events[i] = CreateEvent(NULL,FALSE,FALSE,NULL)) 
+	 == NULL){
+	fprintf(stderr,"%s: Could not create event object.\n", argv[0]);
+	return 1;
+      }
+      if(!NotifyChangeEventLog(elog[i],events[i])){
+	fprintf(stderr,"%s: Could not get eventlog notification.\n", argv[0]);
+	return 1;
+      }
+      if(read_from(&(rk[i].latest_record), 
+		   &(rk[i].latest_time),
+		   elog[i],
+		   rk[i].facility_name) > 0)
+	set_regkeys(ident, rk + i, 1); 
+    }
+    eventlen = rklen;
+    events[eventlen] = get_stdin_event();
+    ++eventlen;
+  
+    for(;;){  
+#ifdef HARDDEBUG
+      fprintf(stderr,"Entering Wait...\n");
+#endif
+      reopen_event_log = 0;
+      ret = WaitForMultipleObjects(eventlen,
+				   events,
+				   FALSE,
+				   (retry) ? 
+				   RETRY_TIMEOUT : 
+				   INFINITE);
+#ifdef HARDDEBUG
+      fprintf(stderr,"Wait returned!\n");
+#endif
+      if(ret == WAIT_TIMEOUT){ 
+	if(!retry){
+	  fprintf(stderr,"%s: Timeout when no such possible!\n", 
+		  argv[0]);
+	  return 1;
+	}
+	retry = 0;
+      } else {
+	if(((int) (ret - WAIT_OBJECT_0)) >= rklen && eof_on_stdin())
+	  goto done;
+	retry = 1;
+      }
+      for(i=0;i<rklen;++i){
+	if(read_from(&(rk[i].latest_record), 
+		     &(rk[i].latest_time),
+		     elog[i],
+		     rk[i].facility_name) > 0)
+	  set_regkeys(ident, rk + i, 1);
+      }
+      if(reopen_event_log)
+	break;
+    }
+    for(i=0; i < rklen; ++i){
+      CloseEventLog(elog[i]);
+      CloseHandle(events[i]);
+    }
+  }
+done:
+#ifdef DEBUG
+  fprintf(stderr,"%s: EOF\n", argv[0]);
+#endif
+  for(i=0; i < rklen; ++i)
+    CloseEventLog(elog[i]);
+  return 0;
+}
diff --git a/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.c b/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.c
new file mode 100644
index 0000000000..c333c455a3
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.c
@@ -0,0 +1,151 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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 "elog_global.h"
+#include "elog_pipe_stdin.h"
+
+/*
+ * Data for the handling of a pipe stdin,
+ * data is read in a separate thread, so locking and 
+ * event signaling needs to be done.
+ */
+
+static CRITICAL_SECTION io_crit;
+static char *stdin_buff = NULL;
+static int stdin_siz = 0;
+static int stdin_len = 0;
+static int stdin_eof = 0;
+/* end syncronized objects */
+static int stdin_is_console = 0;
+static HANDLE stdin_event;
+
+DWORD WINAPI stdin_thread(LPVOID ptr){
+  HANDLE in = GetStdHandle(STD_INPUT_HANDLE);
+  char buff[1];
+  DWORD red;
+  for(;;){
+    if(!ReadFile(in, buff, (DWORD) 1, &red, NULL)){
+      if(GetLastError() == ERROR_BROKEN_PIPE){
+	EnterCriticalSection(&io_crit);
+	stdin_eof = 1;
+	SetEvent(stdin_event);
+	LeaveCriticalSection(&io_crit);
+	return 0;
+      }
+      return 1;
+    }else if(red == 0){
+	EnterCriticalSection(&io_crit);
+	stdin_eof = 1;
+	SetEvent(stdin_event);
+	LeaveCriticalSection(&io_crit);
+	return 0;
+    }
+#ifdef HARDDEBUG
+    fprintf(stderr,"stdin_thread go data (%d)\n",(int)*buff);
+#endif
+    EnterCriticalSection(&io_crit);
+    if(stdin_len + 1 >= stdin_siz){
+      if(!stdin_siz)
+	stdin_buff = malloc(stdin_siz = 100);
+      else
+	stdin_buff = realloc(stdin_buff, stdin_siz +=100);
+    }
+    stdin_buff[stdin_len++] = *buff;
+    SetEvent(stdin_event);
+    LeaveCriticalSection(&io_crit);
+  }
+  return 0;
+}
+
+BOOL peek_pipe_stdin_eof(void){
+  BOOL ret;
+  EnterCriticalSection(&io_crit);
+  if((ret = !!stdin_eof))
+    ResetEvent(stdin_event); /* Now we "unsignal" */
+  LeaveCriticalSection(&io_crit);
+  return ret;
+}
+
+int read_pipe_stdin(char *buff, int max){
+  int ret;
+  EnterCriticalSection(&io_crit);
+  if(stdin_len == 0){
+    if(!stdin_eof){
+      LeaveCriticalSection(&io_crit);
+      WaitForSingleObject(stdin_event,INFINITE);
+      EnterCriticalSection(&io_crit);
+      if(!stdin_len){
+	if(stdin_eof){
+	  /* Stay signaled */
+	  LeaveCriticalSection(&io_crit);
+	  return 0;
+	} else {
+	  ResetEvent(stdin_event);
+	  LeaveCriticalSection(&io_crit);
+	  return -1;
+	}
+      }
+    } else {
+      /* Stay signaled */
+      LeaveCriticalSection(&io_crit);
+      return 0;
+    }
+  }
+#ifdef HARDDEBUG
+  fprintf(stderr,"read_pipe_stdin got data.\n"
+	  "max = %d, stdin_len = %d, *stdin_buff = %d\n",
+	  max,stdin_len,*stdin_buff);
+#endif
+  /* stdin_len should be something now */
+  if(stdin_len > max){
+    memcpy(buff,stdin_buff,max);
+    memmove(stdin_buff,stdin_buff + max,stdin_len - max);
+    stdin_len -= max;
+    ret = max;
+  } else {
+    memcpy(buff,stdin_buff,stdin_len);
+    ret = stdin_len;
+    stdin_len = 0;
+  }
+  if(!stdin_eof) /* Stay signaled if EOF */
+    ResetEvent(stdin_event);
+  LeaveCriticalSection(&io_crit);
+  return ret;
+}
+
+BOOL setup_pipe_stdin(void){
+  HANDLE in = GetStdHandle(STD_INPUT_HANDLE);
+  DWORD dummy;
+  if(GetConsoleMode(in, &dummy)){
+    stdin_is_console = 1;
+    stdin_event = in;
+    return TRUE;
+  }
+  stdin_event = CreateEvent(NULL, TRUE, FALSE, NULL);
+  InitializeCriticalSection(&io_crit);
+  return (_beginthreadex(NULL,0,&stdin_thread,NULL,0,&dummy));
+}
+
+BOOL console_stdin(void){
+  return stdin_is_console;
+}
+
+HANDLE get_stdin_event(void){
+  return stdin_event;
+}
+
diff --git a/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.h b/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.h
new file mode 100644
index 0000000000..a9a91b685f
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_pipe_stdin.h
@@ -0,0 +1,90 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+#ifndef _ELOG_PIPE_STDIN_H
+#define _ELOG_PIPE_STDIN_H
+/*
+ * Module: elog_pipe_stdin
+ * Purpouse: Read data from stdin when stdin is a pipe
+ * and deliver events only when data is really availabel or 
+ * end of file is reached.
+ * If we would wait on an ordinary pipe handle, we 
+ * would return immediately as it's always "signaled".
+ * some kind of asyncronous I/O in the win32 way is 
+ * not possible as it's not supported on anonymous pipes
+ * (besides we have not opened the file ourselves so we 
+ *  cannot specify that we want async I/O...).
+ * ToDo: The reading is inneficcient, the buffering 
+ * goes on forever, which would be dangerous if to much 
+ * data was passed into stdin. The handling of 
+ * Console stdin should be transparent instead of
+ * forcing the user of the module to check if this is a 
+ * console for selecting between ReadFile and 
+ * read_pipe_stdin.
+ * The handling of the event object is somewhat strange 
+ * because I want to know about EOF before I've read
+ * to it.
+ */
+
+BOOL peek_pipe_stdin_eof(void);
+/*
+ * Returns TRUE if eof is reached, regardless of 
+ * if there still is unread data in the buffer.
+ * Should not be called if console_stdin() returns TRUE.
+ * Resets the event object if it returns TRUE.
+ */
+
+int read_pipe_stdin(char *buff, int max);
+/*
+ * Reads from stdin, minimum 1 byte and
+ * maximum max bytes into buff. If EOF
+ * is reached and no bytes were read, 
+ * the return value is 0.
+ * Should not be called if console_stdin() returns TRUE.
+ * The event object for stdin will get unsignaled if
+ * end of file is not reached (if peek_pipe_stdin_eof()
+ * would return false).
+ */
+
+BOOL setup_pipe_stdin(void);
+/*
+ * Initializes the module, returns TRUE if OK.
+ * If stdin is a console, no thread is created
+ * and the event objet returned by get_Stdin_event 
+ * will be the console handle.
+ * Check if stdin was a console with the console_stdin() 
+ * function.
+ */
+
+BOOL console_stdin(void);
+/*
+ * Returns true if stdin was a console, in which case
+ * normal Win32 console I/O functions have to
+ * be used. 
+ * get_stdin_event() will return the console handle,
+ * which is signalled whenever an event reaches
+ * the console window (like mouse events etc).
+ */
+
+HANDLE get_stdin_event(void);
+/*
+ * Returns a event handle that can be waited upon with
+ * WaitForSingleObject and friends. It is possibly a console
+ * handle, see console_stdin().
+ */
+#endif /* _ELOG_PIPE_STDIN_H */
diff --git a/lib/os_mon/c_src/nteventlog/elog_registry.c b/lib/os_mon/c_src/nteventlog/elog_registry.c
new file mode 100644
index 0000000000..478db1e56b
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_registry.c
@@ -0,0 +1,295 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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 "elog_global.h"
+#include "elog_util.h"
+#include "elog_registry.h"
+
+/*
+ * Constants for get/set_regkeys
+ */
+#define APP_ROOT_KEY "SOFTWARE\\Ericsson\\Erlang"
+#define APP_SUB_KEY "EventLogReader"
+#define APP_VERSION "1.0"
+#define LATEST_RECORD_NAME "LatestRecord"
+#define LATEST_TIME_NAME "LatestTime"
+/*
+ * Constants for get_messagefiles
+ */
+#define LOG_KEY_TMPL "SYSTEM\\CurrentControlSet\\Services\\EventLog\\%s\\%s"
+#define EVENT_MSG_FILE_NAME "EventMessageFile"
+#define PARAM_MSG_FILE_NAME "ParameterMessageFile"
+MessageFiles get_messagefiles(const char *category, const char *facility,
+			      char *eventbuff, int eventbufflen,
+			      char *parambuff, int parambufflen){
+  char *b1 = malloc(strlen(LOG_KEY_TMPL)+strlen(category)+strlen(facility)+1);
+  HKEY key;
+  char name[1024];
+  char val[MAX_PATH];
+  MessageFiles mf = { NULL, NULL };
+  DWORD namelen, vallen, type, i, ret;
+
+  if(!b1)
+    return mf;
+  sprintf(b1,LOG_KEY_TMPL,category,facility);
+  if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, b1, 0, KEY_QUERY_VALUE, &key) !=
+     ERROR_SUCCESS){
+    free(b1);
+    return mf;
+  }
+  free(b1);
+  for(namelen=1024,vallen=MAX_PATH,i=0;
+      ERROR_SUCCESS == RegEnumValue(key,
+				    i,
+				    name,
+				    &namelen,
+				    NULL,
+				    &type,
+				    (LPBYTE) val,
+				    &vallen);
+      namelen=1024,vallen=MAX_PATH,++i){
+    if(!strcmp(name,EVENT_MSG_FILE_NAME)){
+      if(type == REG_EXPAND_SZ){
+	ret = ExpandEnvironmentStrings(val,eventbuff,eventbufflen);
+	if(((int) ret) > eventbufflen || !ret)
+	  break;
+      } else {
+	if(((int) strlen(val)) >= eventbufflen)
+	  break;
+	else
+	  strcpy(eventbuff,val);
+      }
+      mf.event = eventbuff;
+    } else if(!strcmp(name,PARAM_MSG_FILE_NAME)){
+      if(type == REG_EXPAND_SZ){
+	ret = ExpandEnvironmentStrings(val,parambuff,parambufflen);
+	if(((int) ret) > parambufflen || !ret)
+	  break;
+      } else {
+	if(((int) strlen(val)) >= parambufflen)
+	  break;
+	else
+	  strcpy(parambuff,val);
+      }
+      mf.param = parambuff;
+    }
+  }
+  RegCloseKey(key);
+  return mf;
+}
+
+
+int create_regkeys(char *identifier){
+  HKEY key,key2;
+  DWORD dispositions;
+  int i,j;
+  char *values[] = {
+    LATEST_RECORD_NAME,
+    LATEST_TIME_NAME,
+    NULL
+  };
+
+  DWORD zero = 0;
+
+  if(RegCreateKeyEx(HKEY_LOCAL_MACHINE,
+		    APP_ROOT_KEY "\\" APP_SUB_KEY "\\"
+		    APP_VERSION,
+		    0,
+		    NULL,
+		    REG_OPTION_NON_VOLATILE,
+		    KEY_CREATE_SUB_KEY,
+		    NULL,
+		    &key,
+		    &dispositions) != ERROR_SUCCESS){
+    return -1;
+  }
+  if(RegCreateKeyEx(key, 
+		    identifier, 
+		    0,
+		    NULL,
+		    REG_OPTION_NON_VOLATILE,
+		    KEY_CREATE_SUB_KEY,
+		    NULL,
+		    &key2,
+		    &dispositions)){
+    RegCloseKey(key);
+    return -1;
+  }
+  RegCloseKey(key);
+  for(i=0; category_tab[i] != NULL; ++i){
+    if(RegCreateKeyEx(key2,
+		      category_tab[i],
+		      0,
+		      NULL,
+		      REG_OPTION_NON_VOLATILE,
+		      KEY_SET_VALUE,
+		      NULL,
+		      &key,
+		      &dispositions) != ERROR_SUCCESS){
+      RegCloseKey(key2);
+      return -1;
+    }
+    for(j=0; values[j] != NULL; ++j){
+      if(RegSetValueEx(key, 
+		       values[j], 
+		       0, 
+		       REG_DWORD,
+		       (BYTE *) &zero,
+		       sizeof(DWORD)) != ERROR_SUCCESS){
+	RegCloseKey(key);
+	RegCloseKey(key2);
+	return -1;
+      }
+    }
+    RegCloseKey(key);
+  }
+  RegCloseKey(key2);
+  return 0;
+}
+  
+
+int set_regkeys(char *identifier, RegKeys *keys, int num_keys){
+  HKEY key;
+  char knbuff[SMALLBUFSIZ];
+  int i;
+  for(i=0; i<num_keys; ++i){
+    sprintf(knbuff,"%s\\%s\\%s\\%s\\%s", 
+	    APP_ROOT_KEY,
+	    APP_SUB_KEY,
+	    APP_VERSION,
+	    identifier,
+	    keys[i].facility_name);
+    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+		    knbuff,
+		    0,
+		    KEY_SET_VALUE,
+		    &key) != ERROR_SUCCESS){
+      return -1;
+    }
+    if(RegSetValueEx(key, 
+		     LATEST_RECORD_NAME,
+		     0,
+		     REG_DWORD,
+		     (BYTE *) &(keys[i].latest_record),
+		     sizeof(DWORD)) != ERROR_SUCCESS){
+      RegCloseKey(key);
+      return -1;
+    }
+    if(RegSetValueEx(key, 
+		     LATEST_TIME_NAME,
+		     0,
+		     REG_DWORD,
+		     (BYTE *) &(keys[i].latest_time),
+		     sizeof(DWORD)) != ERROR_SUCCESS){
+      RegCloseKey(key);
+      return -1;
+    }
+    RegCloseKey(key);
+  }
+  return 0;
+}
+
+
+int get_regkeys(char *identifier, RegKeys *keys, int *num_keys /* in out */){
+  HKEY key,key2;
+  int i;
+  char knbuff[SMALLBUFSIZ];
+  DWORD knlen;
+  char cnbuff[SMALLBUFSIZ];
+  DWORD cnlen;
+  FILETIME ft;
+  DWORD type, data, datasiz;
+
+  sprintf(knbuff,"%s\\%s\\%s\\%s", 
+	  APP_ROOT_KEY,
+	  APP_SUB_KEY,
+	  APP_VERSION,
+	  identifier);
+  if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+		  knbuff, 
+		  0,
+		  KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
+		  &key) != ERROR_SUCCESS){
+    if(create_regkeys(identifier)!= 0){
+#ifdef HARDDEBUG
+      fprintf(stderr,"Failed creating regkeys\n");
+#endif
+      return -1;
+    } else {
+      if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+		      knbuff, 
+		      0,
+		      KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
+		      &key) != ERROR_SUCCESS){
+#ifdef HARDDEBUG
+	fprintf(stderr,"Failed opening regkeys\n");
+#endif
+	return -1;
+      }
+    }
+  }
+  for(i = 0, knlen = SMALLBUFSIZ, cnlen = SMALLBUFSIZ; 
+      i < *num_keys &&
+	ERROR_SUCCESS == RegEnumKeyEx(key,
+				      i,
+				      knbuff,
+				      &knlen,
+				      NULL,
+				      cnbuff,
+				      &cnlen,
+				      &ft);
+      ++i, knlen = SMALLBUFSIZ, cnlen = SMALLBUFSIZ){
+    if(RegOpenKeyEx(key, 
+		    knbuff, 
+		    0, 
+		    KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
+		    &key2) != ERROR_SUCCESS)
+      continue;
+    strncpy(keys[i].facility_name, knbuff, 
+	    MAX_FACILITY_NAME);
+    keys[i].facility_name[MAX_FACILITY_NAME - 1] = '\0';
+    datasiz = sizeof(DWORD);
+    if(RegQueryValueEx(key2, 
+		       LATEST_RECORD_NAME,
+		       NULL,
+		       &type,
+		       (BYTE *) &data,
+		       &datasiz) != ERROR_SUCCESS)
+      keys[i].latest_record = 0;
+    else
+      keys[i].latest_record = data;
+    if(RegQueryValueEx(key2, 
+		       LATEST_TIME_NAME,
+		       NULL,
+		       &type,
+		       (BYTE *) &data,
+		       &datasiz) != ERROR_SUCCESS)
+      keys[i].latest_time = 0;
+    else
+      keys[i].latest_time = data;
+    RegCloseKey(key2);
+  }
+  *num_keys = i;
+  if(!*num_keys){
+#ifdef HARDDEBUG
+    fprintf(stderr,"get_regkeys got none!\n");
+#endif
+    return -1;
+  }
+  return 0;
+}
diff --git a/lib/os_mon/c_src/nteventlog/elog_registry.h b/lib/os_mon/c_src/nteventlog/elog_registry.h
new file mode 100644
index 0000000000..32876ae8bf
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_registry.h
@@ -0,0 +1,67 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+#ifndef _ELOG_REGISTRY_H
+#define _ELOG_REGISTRY_H
+/*
+ * Module: elog_registry
+ * Purpouse: Handle the registry reading and writing.
+ */
+
+#include "elog_global.h"
+
+/*
+ * A structure for the registry keys.
+ */
+typedef struct _reg_keys {
+  char facility_name[MAX_FACILITY_NAME];
+  DWORD latest_record;
+  DWORD latest_time;
+} RegKeys;
+
+MessageFiles get_messagefiles(const char *category, const char *facility,
+			      char *eventbuff, int eventbufflen,
+			      char *parambuff, int parambufflen);
+/*
+ * Return the EventMessageFile and then ParameterMessageFile for
+ * a facility under a category.
+ * The buffers should be at least MAX_PATH long to make
+ * sure the filenames can be stored.
+ * If facility is not found, both fields in the record are NULL,
+ * if the ParameterMessageFile is not found, the param filed of the record 
+ * is NULL.
+ */
+
+int create_regkeys(char *identifier);
+/* 
+ * Creates registry entries for this log identifier 
+ */
+int set_regkeys(char *identifier, RegKeys *keys, int num_keys);
+/*
+ * Updates the registry keys for the identifier. Multiple
+ * categories can be specified in the keys array.
+ */
+int get_regkeys(char *identifier, RegKeys *keys, int *num_keys /* in out */);
+/*
+ * Reads the keys from the registry database for this
+ * identifier, creating them if needed. The values
+ * for the different categories are stored in the 
+ * keys array as long as there is place.
+ */
+
+#endif /* _ELOG_REGISTRY_H */
diff --git a/lib/os_mon/c_src/nteventlog/elog_util.c b/lib/os_mon/c_src/nteventlog/elog_util.c
new file mode 100644
index 0000000000..ac14f2f3e4
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_util.c
@@ -0,0 +1,73 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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 "elog_global.h"
+#include "elog_util.h"
+
+char *category_tab[] = {
+  SYSTEM,
+  APPLICATION,
+  SECURITY,
+  NULL
+};
+
+SeverityEntry severity_tab[] = {
+  {EVENTLOG_ERROR_TYPE , "Error"},
+  {EVENTLOG_WARNING_TYPE, "Warning"},
+  {EVENTLOG_INFORMATION_TYPE, "Informational"},
+  {EVENTLOG_AUDIT_SUCCESS, "Audit_Success"},
+  {EVENTLOG_AUDIT_FAILURE, "Audit_Faulure"},
+  {0, "Severity_Unknown"}
+};
+
+int severity_tab_len = 
+sizeof(severity_tab)/sizeof(SeverityEntry);
+
+char *lookup_severity(WORD severity){
+  int i;
+  for(i=0;i<severity_tab_len-1;++i)
+    if(severity_tab[i].type == severity)
+      return severity_tab[i].desc;
+  return severity_tab[i].desc;
+}
+
+
+void output_error(DWORD error, char *extra){
+    char *msgbuf;
+    FormatMessage( 
+		  FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+		  NULL,
+		  error,
+		  DEFAULT_LANGID, 
+		  (LPTSTR) &msgbuf,    
+		  0,    
+		  NULL );
+    fprintf(stderr,"%s: %s", extra, msgbuf);
+    LocalFree(msgbuf);
+}
+
+
+#undef malloc
+void *my_malloc(size_t siz){
+  void *x;
+  if((x = malloc(siz)) == NULL){
+    fputs("Out of memory.", stderr);
+    exit(1);
+  }
+  return x;
+}
diff --git a/lib/os_mon/c_src/nteventlog/elog_util.h b/lib/os_mon/c_src/nteventlog/elog_util.h
new file mode 100644
index 0000000000..66f1a2519e
--- /dev/null
+++ b/lib/os_mon/c_src/nteventlog/elog_util.h
@@ -0,0 +1,79 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1998-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%
+ */
+#ifndef _ELOG_UTIL_H
+#define _ELOG_UTIL_H
+/*
+ * Module: elog_util
+ * Purpouse: Utilities for other elog modules.
+ */
+
+#include "elog_global.h"
+
+/*
+ * A table of eventlog categories in an NT system. NOTE that the NUM_CATEGORIES
+ * constant has to be updated if this table is!
+ */
+extern char *category_tab[];
+
+#define NUM_CATEGORIES 3
+
+/*
+ * Table for translation of severity constants o strings
+ */
+typedef struct _severity_tab {
+  WORD type;
+  char *desc;
+} SeverityEntry;
+
+extern SeverityEntry severity_tab[];
+extern int severity_tab_len;
+
+char *lookup_severity(WORD severity);
+/*
+ * Lookup in the above table.
+ */
+
+/*
+ * Safe malloc.
+ */
+void *my_malloc(size_t siz);
+#define malloc(X) my_malloc(X)
+
+/*
+ * Error reporting
+ */
+void output_error(DWORD error, char *extra);
+/*
+ * Formats a GetLastError() errorcode to text,
+ * prepended with 'extra':. Writes to stderr.
+ */
+
+/*
+ * I don't like mistyped strings...
+ */
+#define SYSTEM "System"
+#define APPLICATION "Application"
+#define SECURITY "Security"
+/*
+ * The mask to get the printable message id value
+ */
+#define EVENT_ID_MASK 0x0000FFFF
+
+#endif /* _ELOG_UTIL_H */
+
diff --git a/lib/os_mon/c_src/win32sysinfo.c b/lib/os_mon/c_src/win32sysinfo.c
new file mode 100644
index 0000000000..2a155aae87
--- /dev/null
+++ b/lib/os_mon/c_src/win32sysinfo.c
@@ -0,0 +1,318 @@
+/*
+ * %CopyrightBegin%
+ * 
+ * Copyright Ericsson AB 1997-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%
+ */
+
+/**
+ *  win32sysinfo.c
+ *
+ *  File:     win32sysinfo.c
+ *  Purpose:  Portprogram for supervision of disk and memory usage.
+ *
+ *  Synopsis: win32sysinfo
+ *
+ *  PURPOSE OF THIS PROGRAM
+ *
+ *  This program supervises the reports the memory status or disk status
+ *  on request from the Erlang system
+ *  
+ *
+ *  SPAWNING FROM ERLANG
+ *
+ *  This program is started from Erlang as follows,
+ *
+ *       Port = open_port({spawn, 'memsup'}, [{packet,1}]) for UNIX
+ *
+ *  COMMUNICATION
+ *
+ *    WIN32
+ * 
+ * get_disk_info 'd' (request info about all drives)
+ *      The result is returned as one packet per logical drive with the 
+ *      following format:
+ *      Drive Type AvailableBytes TotalBytes TotalBytesFree
+ *      END
+ *
+ *      Example: 
+ *      A:\ DRIVE_REMOVABLE 0 0 0
+ *      C:\ DRIVE_FIXED 10000000 20000000 10000000
+ *      END
+
+ * get_disk_info 'd'Driveroot (where Driveroot is a string like this "A:\\"
+ *      (request info of specific drive)
+ *      The result is returned with the same format as above exept that 
+ *      Type will be DRIVE_NOT_EXIST if the drive does not exist.
+ *
+ * get_mem_info 'm' (request info about memory)
+ * 
+ *      The result is returned as one packet with the following format
+ *      
+ *      
+ *      
+ *      
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <windows.h>
+#include "winbase.h"
+
+#define MEM_INFO 'm'
+#define DISK_INFO 'd'
+#define OK "o"
+
+#define ERLIN_FD      0
+#define ERLOUT_FD     1
+
+
+typedef BOOL (WINAPI *tfpGetDiskFreeSpaceEx)(LPCTSTR, PULARGE_INTEGER,PULARGE_INTEGER,PULARGE_INTEGER);
+
+static  tfpGetDiskFreeSpaceEx fpGetDiskFreeSpaceEx;
+
+static void
+return_answer(char* value)
+{
+    int left, bytes, res;
+
+    bytes = strlen(value); /* Skip trailing zero */
+
+    res = write(1,(char*) &bytes,1);
+    if (res != 1) {
+	fprintf(stderr,"win32sysinfo:Error writing to pipe");
+	exit(1);
+    }
+
+    left = bytes;
+
+    while (left > 0)
+    {
+	res = write(1, value+bytes-left, left);
+	if (res <= 0)
+	{
+	    fprintf(stderr,"win32sysinfo:Error writing to pipe");
+	    exit(1);
+	}
+	left -= res;
+    }
+}
+
+void output_drive_info(char* drive){
+    ULARGE_INTEGER availbytes,totbytesfree,totbytes;
+    OSVERSIONINFO osinfo;
+    char answer[512];
+    osinfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
+    GetVersionEx(&osinfo);
+    switch (GetDriveType(drive)) {
+    case DRIVE_UNKNOWN:
+	sprintf(answer,"%s DRIVE_UNKNOWN 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    case DRIVE_NO_ROOT_DIR:
+	sprintf(answer,"%s DRIVE_NO_ROOT_DIR 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    case DRIVE_REMOVABLE:
+	sprintf(answer,"%s DRIVE_REMOVABLE 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    case DRIVE_FIXED:
+	/*		if ((osinfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) &&
+			(LOWORD(osinfo.dwBuildNumber) <= 1000)) {
+			sprintf(answer,"%s API_NOT_SUPPORTED 0 0 0\n",drive);
+			return_answer(answer);
+			}
+			else
+			*/
+	    if (fpGetDiskFreeSpaceEx == NULL){
+		sprintf(answer,"%s API_NOT_SUPPORTED 0 0 0\n",drive);
+		return_answer(answer);
+	    }
+	    else
+		if (fpGetDiskFreeSpaceEx(drive,&availbytes,&totbytes,&totbytesfree)){
+		    sprintf(answer,"%s DRIVE_FIXED %I64u %I64u %I64u\n",drive,availbytes,totbytes,totbytesfree);
+		    return_answer(answer);
+		}
+		else {
+		    sprintf(answer,"%s API_ERROR 0 0 0\n",drive);
+		    return_answer(answer);
+		}
+	break;
+    case DRIVE_REMOTE:
+	sprintf(answer,"%s DRIVE_REMOTE 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    case DRIVE_CDROM:
+	sprintf(answer,"%s DRIVE_CDROM 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    case DRIVE_RAMDISK:
+	sprintf(answer,"%s DRIVE_RAMDISK 0 0 0\n",drive);
+	return_answer(answer);
+	break;
+    default:
+	sprintf(answer,"%s DRIVE_NOT_EXIST 0 0 0\n",drive);
+	return_answer(answer);
+    } /* switch */
+}
+    
+int load_if_possible() {
+    HINSTANCE lh;
+    if((lh = LoadLibrary("KERNEL32")) ==NULL)
+	return 0;		/* error */
+    if ((fpGetDiskFreeSpaceEx = 
+	 (tfpGetDiskFreeSpaceEx) GetProcAddress(lh,"GetDiskFreeSpaceExA")) ==NULL)
+	return GetLastError(); /* error */
+    return 1;
+}
+
+void get_disk_info_all(){
+    DWORD dwNumBytesForDriveStrings;
+    char DriveStrings[255];
+    char* dp = DriveStrings;
+    
+    dwNumBytesForDriveStrings = GetLogicalDriveStrings(254,dp);
+    if (dwNumBytesForDriveStrings != 0) {
+	/* GetLogicalDriveStringsIs supported on this platform */
+	while (*dp != 0) {
+	    output_drive_info(dp);
+	    dp = strchr(dp,0) +1;
+	}
+    }
+    else {
+	/* GetLogicalDriveStrings is not supported (some old W95) */
+	DWORD dwDriveMask = GetLogicalDrives();
+	int nDriveNum;
+	char drivename[]="A:\\";
+	/*printf("DriveName95 DriveType BytesAvail BytesTotal BytesTotalFree\n");*/
+	for (nDriveNum = 0; dwDriveMask != 0;nDriveNum++) {
+	    if (dwDriveMask & 1) {
+		drivename[0]='A'+ nDriveNum;
+		output_drive_info(drivename);
+	    }
+	    dwDriveMask = dwDriveMask >> 1;
+	}
+    }
+}
+
+void get_avail_mem_ext() {
+    char answer[512];
+    MEMORYSTATUSEX ms;
+    ms.dwLength=sizeof(MEMORYSTATUSEX);
+    GlobalMemoryStatusEx(&ms);
+    sprintf(answer,"%d %I64d %I64d %I64d %I64d %I64d %I64d\n",
+	    ms.dwMemoryLoad,
+	    ms.ullTotalPhys,
+	    ms.ullAvailPhys,
+	    ms.ullTotalPageFile,
+	    ms.ullAvailPageFile,
+	    ms.ullTotalVirtual,
+	    ms.ullAvailVirtual
+	    );
+    return_answer(answer);
+    /*    
+	DWORD     dwLength;
+	DWORD     dwMemoryLoad;
+	DWORDLONG ullTotalPhys;
+	DWORDLONG ullAvailPhys;
+	DWORDLONG ullTotalPageFile;
+	DWORDLONG ullAvailPageFile;
+	DWORDLONG ullTotalVirtual;
+	DWORDLONG ullAvailVirtual;
+    */
+}
+
+static void
+message_loop()
+{
+    char cmdLen;
+    char cmd[512];
+    int res;
+    
+    fprintf(stderr,"in message_loop\n");
+    /* Startup ACK. */
+    return_answer(OK);
+    while (1)
+    {
+	/*
+	 *  Wait for command from Erlang
+	 */
+	if ((res = read(0, &cmdLen, 1)) < 0) {
+	    fprintf(stderr,"win32sysinfo:Error reading from Erlang.");
+	    return;
+	}
+	
+	if (res != 1){	/* Exactly one byte read ? */ 
+	    fprintf(stderr,"win32sysinfo:Erlang has closed.");
+	    return;
+	}
+	if ((res = read(0, &cmd, cmdLen)) == cmdLen){
+	    if (cmdLen == 1) {
+		switch (cmd[0]) {
+		case MEM_INFO:
+		    get_avail_mem_ext();
+		    return_answer(OK);
+		    break;
+		case DISK_INFO:
+		    get_disk_info_all();
+		    return_answer(OK);
+		    break;
+		default:	/* ignore all other messages */
+		    break;
+		} /* switch */
+	    }
+	    else 
+		if ((res > 0) && (cmd[0]==DISK_INFO)) {
+		    cmd[cmdLen] = 0;
+		    output_drive_info(&cmd[1]);
+		    return_answer("OK");
+		    return;
+		}
+		else
+		    return_answer("xEND");
+	}    
+	else if (res == 0) {
+	    fprintf(stderr,"win32sysinfo:Erlang has closed.");
+	    return;
+	}
+	else {
+	    fprintf(stderr,"win32sysinfo:Error reading from Erlang.");
+	    return;
+	} 
+    }
+}
+
+int main(int argc, char ** argv){
+
+    _setmode(0, _O_BINARY);
+    _setmode(1, _O_BINARY);
+    load_if_possible();
+    message_loop();
+    return 0;    
+}
+
+
+
+
+
+
+
diff --git a/lib/os_mon/doc/html/.gitignore b/lib/os_mon/doc/html/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/doc/html/.gitignore
diff --git a/lib/os_mon/doc/man3/.gitignore b/lib/os_mon/doc/man3/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/doc/man3/.gitignore
diff --git a/lib/os_mon/doc/man6/.gitignore b/lib/os_mon/doc/man6/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/doc/man6/.gitignore
diff --git a/lib/os_mon/doc/pdf/.gitignore b/lib/os_mon/doc/pdf/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/doc/pdf/.gitignore
diff --git a/lib/os_mon/doc/src/Makefile b/lib/os_mon/doc/src/Makefile
new file mode 100644
index 0000000000..c9765749c9
--- /dev/null
+++ b/lib/os_mon/doc/src/Makefile
@@ -0,0 +1,124 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1997-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=$(OS_MON_VSN)
+APPLICATION=os_mon
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/$(APPLICATION)-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+XML_APPLICATION_FILES = ref_man.xml
+XML_REF3_FILES = cpu_sup.xml \
+	disksup.xml \
+	memsup.xml \
+	os_mon_mib.xml \
+	os_sup.xml \
+	nteventlog.xml
+
+XML_REF6_FILES = os_mon_app.xml 
+
+XML_PART_FILES = part_notes.xml
+XML_CHAPTER_FILES = notes.xml
+
+BOOK_FILES = book.xml
+
+GIF_FILES = \
+	note.gif \
+	warning.gif
+
+XML_FILES = \
+	$(BOOK_FILES) $(XML_CHAPTER_FILES) \
+	$(XML_PART_FILES) $(XML_REF3_FILES) $(XML_REF6_FILES) $(XML_APPLICATION_FILES)
+
+# ----------------------------------------------------
+
+HTML_FILES = $(XML_APPLICATION_FILES:%.xml=$(HTMLDIR)/%.html) \
+	$(XML_PART_FILES:%.xml=$(HTMLDIR)/%.html)
+
+INFO_FILE = ../../info
+
+MAN3_FILES = $(XML_REF3_FILES:%.xml=$(MAN3DIR)/%.3)
+
+MAN6_FILES = $(XML_REF6_FILES:%_app.xml=$(MAN6DIR)/%.6)
+
+HTML_REF_MAN_FILE = $(HTMLDIR)/index.html
+
+TOP_PDF_FILE = $(PDFDIR)/$(APPLICATION)-$(VSN).pdf
+
+# ----------------------------------------------------
+# FLAGS 
+# ----------------------------------------------------
+XML_FLAGS += 
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+$(HTMLDIR)/%.gif: %.gif
+	$(INSTALL_DATA) $< $@
+
+docs: pdf html man
+
+$(TOP_PDF_FILE): $(XML_FILES)
+
+pdf: $(TOP_PDF_FILE)
+
+html: gifs $(HTML_REF_MAN_FILE)
+
+man: $(MAN3_FILES) $(MAN6_FILES)
+
+gifs: $(GIF_FILES:%=$(HTMLDIR)/%)
+
+debug opt: 
+
+clean clean_docs:
+	rm -rf $(HTMLDIR)/*
+	rm -f $(MAN3DIR)/*
+	rm -f $(TOP_PDF_FILE) $(TOP_PDF_FILE:%.pdf=%.fo)
+	rm -f errs core *~ 
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_docs_spec: docs
+	$(INSTALL_DIR) $(RELSYSDIR)/doc/pdf
+	$(INSTALL_DATA) $(TOP_PDF_FILE) $(RELSYSDIR)/doc/pdf
+	$(INSTALL_DIR) $(RELSYSDIR)/doc/html
+	$(INSTALL_DATA) $(HTMLDIR)/* \
+		$(RELSYSDIR)/doc/html
+	$(INSTALL_DATA) $(INFO_FILE) $(RELSYSDIR)
+	$(INSTALL_DIR) $(RELEASE_PATH)/man/man3
+	$(INSTALL_DATA) $(MAN3DIR)/* $(RELEASE_PATH)/man/man3
+	$(INSTALL_DIR) $(RELEASE_PATH)/man/man6
+	$(INSTALL_DATA) $(MAN6DIR)/* $(RELEASE_PATH)/man/man6
+
+release_spec:
+
diff --git a/lib/os_mon/doc/src/book.xml b/lib/os_mon/doc/src/book.xml
new file mode 100644
index 0000000000..17645b81fd
--- /dev/null
+++ b/lib/os_mon/doc/src/book.xml
@@ -0,0 +1,45 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE book SYSTEM "book.dtd">
+
+<book xmlns:xi="http://www.w3.org/2001/XInclude">
+  <header titlestyle="normal">
+    <copyright>
+      <year>1997</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>OS_Mon</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <insidecover>
+  </insidecover>
+  <pagetext>OS_Mon</pagetext>
+  <preamble>
+    <contents level="2"></contents>
+  </preamble>
+  <applications>
+    <xi:include href="ref_man.xml"/>
+  </applications>
+  <releasenotes>
+    <xi:include href="notes.xml"/>
+  </releasenotes>
+  <listofterms></listofterms>
+  <index></index>
+</book>
+
diff --git a/lib/os_mon/doc/src/cpu_sup.xml b/lib/os_mon/doc/src/cpu_sup.xml
new file mode 100644
index 0000000000..7b28083fbc
--- /dev/null
+++ b/lib/os_mon/doc/src/cpu_sup.xml
@@ -0,0 +1,281 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>1997</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>cpu_sup</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>cpu_sup</module>
+  <modulesummary>A CPU Load and CPU Utilization Supervisor Process</modulesummary>
+  <description>
+    <p><c>cpu_sup</c> is a process which supervises the CPU load
+      and CPU utilization. It is part of the OS_Mon application, see
+      <seealso marker="os_mon_app">os_mon(6)</seealso>. Available for Unix,
+      although CPU utilization values (<c>util/0,1</c>) are only
+      available for Solaris and Linux.</p>
+    <p>The load values are proportional to how long time a runnable
+      Unix process has to spend in the run queue before it is scheduled.
+      Accordingly, higher values mean more system load. The returned
+      value divided by 256 produces the figure displayed by <c>rup</c>
+      and <c>top</c>. What is displayed as 2.00 in <c>rup</c>, is
+      displayed as load up to the second mark in <c>xload</c>.</p>
+    <p>For example, <c>rup</c> displays a load of 128 as 0.50, and
+      512 as 2.00.</p>
+    <p>If the user wants to view load values as percentage of machine
+      capacity, then this way of measuring presents a problem, because
+      the load values are not restricted to a fixed interval. In this
+      case, the following simple mathematical transformation can
+      produce the load value as a percentage:</p>
+    <code type="none">
+      PercentLoad = 100 * (1 - D/(D + Load))
+    </code>
+    <p><c>D</c> determines which load value should be associated with
+      which percentage. Choosing <c>D</c> = 50 means that 128 is 60% 
+      load, 256 is 80%, 512 is 90%, and so on.</p>
+    <p>Another way of measuring system load is to divide the number of
+      busy CPU cycles by the total number of CPU cycles. This produces 
+      values in the 0-100 range immediately. However, this method hides 
+      the fact that a machine can be more or less saturated. CPU
+      utilization is therefore a better name than system load for this
+      measure.</p>
+    <p>A server which receives just enough requests to never become
+      idle will score a CPU utilization of 100%. If the server receives
+      50% more requests, it will still scores 100%. When the system load
+      is calculated with the percentage formula shown previously,
+      the load will increase from 80% to 87%.</p>
+    <p>The <c>avg1/0</c>, <c>avg5/0</c>, and <c>avg15/0</c> functions
+      can be used for retrieving system load values, and
+      the <c>util/0</c> and <c>util/1</c> functions can be used for
+      retrieving CPU utilization values.</p>
+    <p>When run on Linux, <c>cpu_sup</c> assumes that the <c>/proc</c>
+      file system is present and accessible by <c>cpu_sup</c>. If it is
+      not, <c>cpu_sup</c> will terminate.</p>
+  </description>
+  <funcs>
+    <func>
+      <name>nprocs() -> UnixProcesses | {error, Reason}</name>
+      <fsummary>Get the number of UNIX processes running on this host</fsummary>
+      <type>
+        <v>UnixProcesses = int()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns the number of UNIX processes running on this machine.
+          This is a crude way of measuring the system load, but it may
+          be of interest in some cases.</p>
+        <p>Returns 0 if <c>cpu_sup</c> is not available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>avg1() -> SystemLoad | {error, Reason}</name>
+      <fsummary>Get the system load average for the last minute</fsummary>
+      <type>
+        <v>SystemLoad = int()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns the average system load in the last minute, as
+          described above. 0 represents no load, 256 represents the load
+          reported as 1.00 by <c>rup</c>.</p>
+        <p>Returns 0 if <c>cpu_sup</c> is not available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>avg5() -> SystemLoad | {error, Reason}</name>
+      <fsummary>Get the system load average for the last five minutes</fsummary>
+      <type>
+        <v>SystemLoad = int()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns the average system load in the last five minutes, as
+          described above. 0 represents no load, 256 represents the load
+          reported as 1.00 by <c>rup</c>.</p>
+        <p>Returns 0 if <c>cpu_sup</c> is not available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>avg15() -> SystemLoad | {error, Reason}</name>
+      <fsummary>Get the system load average for the last fifteen minutes</fsummary>
+      <type>
+        <v>SystemLoad = int()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns the average system load in the last 15 minutes, as
+          described above. 0 represents no load, 256 represents the load
+          reported as 1.00 by <c>rup</c>.</p>
+        <p>Returns 0 if <c>cpu_sup</c> is not available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>util() -> CpuUtil | {error, Reason}</name>
+      <fsummary>Get the CPU utilization</fsummary>
+      <type>
+        <v>CpuUtil = float()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns CPU utilization since the last call to
+          <c>util/0</c> or <c>util/1</c> by the calling process.</p>
+        <note>
+          <p>The returned value of the first call to <c>util/0</c> or
+            <c>util/1</c> by a process will on most systems be the CPU
+            utilization since system boot, but this is not guaranteed
+            and the value should therefore be regarded as garbage. This
+            also applies to the first call after a restart of
+            <c>cpu_sup</c>.</p>
+        </note>
+        <p>The CPU utilization is defined as the sum of the percentage
+          shares of the CPU cycles spent in all busy processor states
+          (see <c>util/1</c> below) in average on all CPUs.</p>
+        <p>Returns 0 if <c>cpu_sup</c> is not available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>util(Opts) -> UtilSpec | {error, Reason}</name>
+      <fsummary>Get the CPU utilization</fsummary>
+      <type>
+        <v>Opts = [detailed | per_cpu]</v>
+        <v>UtilSpec = UtilDesc | [UtilDesc]</v>
+        <v>&nbsp;UtilDesc = {Cpus, Busy, NonBusy, Misc}</v>
+        <v>&nbsp;&nbsp;Cpus = all | int() | [int()]()</v>
+        <v>&nbsp;&nbsp;Busy = NonBusy = {State, Share} | Share</v>
+        <v>&nbsp;&nbsp;&nbsp;State = user | nice_user | kernel</v>
+        <v>&nbsp;&nbsp;&nbsp;&nbsp;| wait | idle | atom()</v>
+        <v>&nbsp;&nbsp;&nbsp;Share = float()</v>
+        <v>&nbsp;&nbsp;Misc = []</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Returns CPU utilization since the last call to
+          <c>util/0</c> or <c>util/1</c> by the calling process, in
+          more detail than <c>util/0</c>.</p>
+        <note>
+          <p>The returned value of the first call to <c>util/0</c> or
+            <c>util/1</c> by a process will on most systems be the CPU
+            utilization since system boot, but this is not guaranteed
+            and the value should therefore be regarded as garbage. This
+            also applies to the first call after a restart of
+            <c>cpu_sup</c>.</p>
+        </note>
+        <p>Currently recognized options:</p>
+        <taglist>
+          <tag><c>detailed</c></tag>
+          <item>
+            <p>The returned <c>UtilDesc</c>(s) will be even more
+              detailed.</p>
+          </item>
+          <tag><c>per_cpu</c></tag>
+          <item>
+            <p>Each CPU will be specified separately (assuming this
+              information can be retrieved from the operating system),
+              that is, a list with one <c>UtilDesc</c> per CPU will be
+              returned.</p>
+          </item>
+        </taglist>
+        <p>Description of <c>UtilDesc = {Cpus, Busy, NonBusy, Misc}</c>:</p>
+        <taglist>
+          <tag><c>Cpus</c></tag>
+          <item>
+            <p>If the <c>detailed</c> and/or <c>per_cpu</c> option is
+              given, this is the CPU number, or a list of the CPU
+              numbers.</p>
+            <p>If not, this is the atom <c>all</c> which implies that
+              the <c>UtilDesc</c> contains information about all CPUs.</p>
+          </item>
+          <tag><c>Busy</c></tag>
+          <item>
+            <p>If the <c>detailed</c> option is given, this is a list
+              of <c>{State, Share}</c> tuples, where each tuple
+              contains information about a processor state that has
+              been identified as a busy processor state (see below).
+              The atom <c>State</c> is the name of the state, and
+              the float <c>Share</c> represents the percentage share of
+              the CPU cycles spent in this state since the last call to
+              <c>util/0</c> or <c>util/1</c>.</p>
+            <p>If not, this is the sum of the percentage shares of
+              the CPU cycles spent in all states identified as busy.</p>
+            <p>If the <c>per_cpu</c> is not given, the value(s)
+              presented are the average of all CPUs.</p>
+          </item>
+          <tag><c>NonBusy</c></tag>
+          <item>
+            <p>Similar to <c>Busy</c>, but for processor states that
+              have been identified as non-busy (see below).</p>
+          </item>
+          <tag><c>Misc</c></tag>
+          <item>
+            <p>Currently unused; reserved for future use.</p>
+          </item>
+        </taglist>
+        <p>Currently these processor states are identified as busy:</p>
+        <taglist>
+          <tag><c>user</c></tag>
+          <item>
+            <p>Executing code in user mode.</p>
+          </item>
+          <tag><c>nice_user</c></tag>
+          <item>
+            <p>Executing code in low priority (nice) user mode.
+              This state is currently only identified on Linux.</p>
+          </item>
+          <tag><c>kernel</c></tag>
+          <item>
+            <p>Executing code in kernel mode.</p>
+          </item>
+        </taglist>
+        <p>Currently these processor states are identified as non-busy:</p>
+        <taglist>
+          <tag><c>wait</c></tag>
+          <item>
+            <p>Waiting. This state is currently only identified on
+              Solaris.</p>
+          </item>
+          <tag><c>idle</c></tag>
+          <item>
+            <p>Idle.</p>
+          </item>
+        </taglist>
+        <note>
+          <p>Identified processor states may be different on different
+            operating systems and may change between different versions
+            of <c>cpu_sup</c> on the same operating system. The sum of
+            the percentage shares of the CPU cycles spent in all busy
+            and all non-busy processor states will always add up to
+            100%, though.</p>
+        </note>
+        <p>Returns <c>{all,0,0,[]}</c> if <c>cpu_sup</c> is not
+          available.</p>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="os_mon_app">os_mon(3)</seealso></p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/disksup.xml b/lib/os_mon/doc/src/disksup.xml
new file mode 100644
index 0000000000..bfa3d3578f
--- /dev/null
+++ b/lib/os_mon/doc/src/disksup.xml
@@ -0,0 +1,161 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>1996</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>disksup</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>disksup</module>
+  <modulesummary>A Disk Supervisor Process</modulesummary>
+  <description>
+    <p><c>disksup</c> is a process which supervises the available disk
+      space in the system. It is part of the OS_Mon application, see
+      <seealso marker="os_mon_app">os_mon(6)</seealso>. Available for Unix
+      and Windows.</p>
+    <p>Periodically checks the disks. For each disk or partition which
+      uses more than a certain amount of the available space, the alarm
+      <c>{{disk_almost_full, MountedOn}, []}</c> is set.</p>
+    <taglist>
+      <tag>On Unix</tag>
+      <item>
+        <p>All (locally) mounted disks are checked, including the swap
+          disk if it is present.</p>
+      </item>
+      <tag>On WIN32</tag>
+      <item>
+        <p>All logical drives of type "FIXED_DISK" are checked.</p>
+      </item>
+    </taglist>
+    <p>Alarms are reported to the SASL alarm handler, see
+      <seealso marker="sasl:alarm_handler">alarm_handler(3)</seealso>.
+      To set an alarm, <c>alarm_handler:set_alarm(Alarm)</c> is called
+      where <c>Alarm</c> is the alarm specified above.</p>
+    <p>The alarms are cleared automatically when the alarm cause is no
+      longer valid.</p>
+  </description>
+
+  <section>
+    <marker id="config"></marker>
+    <title>Configuration</title>
+    <p>The following configuration parameters can be used to change
+      the default values for time interval and threshold:</p>
+    <taglist>
+      <tag><c>disk_space_check_interval = int()>0</c></tag>
+      <item>
+        <p>The time interval, in minutes, for the periodic disk space
+          check. The default is 30 minutes.</p>
+      </item>
+      <tag><c>disk_almost_full_threshold = float()</c></tag>
+      <item>
+        <p>The threshold, as percentage of total disk space, for how
+          much disk can be utilized before the <c>disk_almost_full</c>
+          alarm is set. The default is 0.80 (80%).</p>
+      </item>
+    </taglist>
+    <p>See <seealso marker="kernel:config">config(4)</seealso> for
+      information about how to change the value of configuration
+      parameters.</p>
+  </section>
+  <funcs>
+    <func>
+      <name>get_disk_data() -> [DiskData]</name>
+      <fsummary>Get data for the disks in the system</fsummary>
+      <type>
+        <v>DiskData = {Id, KByte, Capacity}</v>
+        <v>&nbsp;Id = string()</v>
+        <v>&nbsp;KByte = int()</v>
+        <v>&nbsp;Capacity = int()</v>
+      </type>
+      <desc>
+        <p>Returns the result of the latest disk check. <c>Id</c> is a
+          string that identifies the disk or partition. <c>KByte</c> is
+          the total size of the disk or partition in kbytes.
+          <c>Capacity</c> is the percentage of disk space used.</p>
+        <p>The function is asynchronous in the sense that it does not
+          invoke a disk check, but returns the latest available value.</p>
+        <p>Returns <c>[{"none",0,0}]</c> if <c>disksup</c> is not
+          available.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_check_interval() -> MS</name>
+      <fsummary>Get time interval, in milliseconds, for the periodic disk space check</fsummary>
+      <type>
+        <v>MS = int()</v>
+      </type>
+      <desc>
+        <p>Returns the time interval, in milliseconds, for the periodic
+          disk space check.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_check_interval(Minutes) -> ok</name>
+      <fsummary>Set time interval, in minutes, for the periodic disk space check</fsummary>
+      <type>
+        <v>Minutes = int()>=1</v>
+      </type>
+      <desc>
+        <p>Changes the time interval, given in minutes, for the periodic
+          disk space check.</p>
+        <p>The change will take effect after the next disk space check
+          and is non-persist. That is, in case of a process restart,
+          this value is forgotten and the default value will be used.
+          See <seealso marker="#config">Configuration</seealso> above.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_almost_full_threshold() -> Percent</name>
+      <fsummary>Get threshold, in percent, for disk space utilization</fsummary>
+      <type>
+        <v>Percent = int()</v>
+      </type>
+      <desc>
+        <p>Returns the threshold, in percent, for disk space utilization.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_almost_full_threshold(Float) -> ok</name>
+      <fsummary>Set threshold, as percentage represented by a float, for disk space utilization</fsummary>
+      <type>
+        <v>Float = float(), 0=&lt;Float=&lt;1</v>
+      </type>
+      <desc>
+        <p>Changes the threshold, given as a float, for disk space
+          utilization.</p>
+        <p>The change will take effect during the next disk space check
+          and is non-persist. That is, in case of a process restart,
+          this value is forgotten and the default value will be used.
+          See <seealso marker="#config">Configuration</seealso> above.</p>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="sasl:alarm_handler">alarm_handler(3)</seealso>,
+      <seealso marker="os_mon_app">os_mon(3)</seealso></p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/fascicules.xml b/lib/os_mon/doc/src/fascicules.xml
new file mode 100644
index 0000000000..43090b4aed
--- /dev/null
+++ b/lib/os_mon/doc/src/fascicules.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE fascicules SYSTEM "fascicules.dtd">
+
+<fascicules>
+  <fascicule file="ref_man" href="ref_man_frame.html" entry="yes">
+    Reference Manual
+  </fascicule>
+  <fascicule file="part_notes" href="part_notes_frame.html" entry="no">
+    Release Notes
+  </fascicule>
+  <fascicule file="" href="../../../../doc/print.html" entry="no">
+    Off-Print
+  </fascicule>
+</fascicules>
+
diff --git a/lib/os_mon/doc/src/make.dep b/lib/os_mon/doc/src/make.dep
new file mode 100644
index 0000000000..b657f2e036
--- /dev/null
+++ b/lib/os_mon/doc/src/make.dep
@@ -0,0 +1,21 @@
+# ----------------------------------------------------
+# >>>> Do not edit this file <<<<
+# This file was automaticly generated by
+# /home/otp/bin/docdepend
+# ----------------------------------------------------
+
+
+# ----------------------------------------------------
+# TeX files that the DVI file depend on
+# ----------------------------------------------------
+
+book.dvi: book.tex cpu_sup.tex disksup.tex memsup.tex \
+		nteventlog.tex os_mon.tex os_mon_mib.tex os_sup.tex \
+		ref_man.tex
+
+# ----------------------------------------------------
+# Source inlined when transforming from source to LaTeX
+# ----------------------------------------------------
+
+book.tex: ref_man.xml
+
diff --git a/lib/os_mon/doc/src/memsup.xml b/lib/os_mon/doc/src/memsup.xml
new file mode 100644
index 0000000000..67d617375e
--- /dev/null
+++ b/lib/os_mon/doc/src/memsup.xml
@@ -0,0 +1,328 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>1996</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>memsup</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>memsup</module>
+  <modulesummary>A Memory Supervisor Process</modulesummary>
+  <description>
+    <p><c>memsup</c> is a process which supervises the memory usage for
+      the system and for individual processes. It is part of the OS_Mon
+      application, see <seealso marker="os_mon_app">os_mon(6)</seealso>.
+      Available for Unix, Windows and VxWorks.</p>
+    <p>Periodically performs a memory check:</p>
+    <list type="bulleted">
+      <item>
+        <p>If more than a certain amount of available system memory is
+          allocated, as reported by the underlying operating system,
+          the alarm <c>{system_memory_high_watermark, []}</c> is set.</p>
+      </item>
+      <item>
+        <p>If any Erlang process <c>Pid</c> in the system has allocated
+          more than a certain amount of total system memory, the alarm
+          <c>{process_memory_high_watermark, Pid}</c> is set.</p>
+      </item>
+    </list>
+    <p>Alarms are reported to the SASL alarm handler, see
+      <seealso marker="sasl:alarm_handler">alarm_handler(3)</seealso>.
+      To set an alarm, <c>alarm_handler:set_alarm(Alarm)</c> is called
+      where <c>Alarm</c> is either of the alarms specified above.</p>
+    <p>The alarms are cleared automatically when the alarm cause is no
+      longer valid.</p>
+    <p>The function 
+      <seealso marker="#get_memory_data/0">get_memory_data()</seealso>
+      can be used to retrieve the result of the latest periodic memory
+      check.</p>
+    <p>There is also a interface to system dependent memory data,
+      <seealso marker="#get_system_memory_data/0">get_system_memory_data()</seealso>.
+      The result is highly dependent on the underlying operating
+      system and the interface is targeted primarily for systems
+      without virtual memory (e.g. VxWorks). The output on other
+      systems is however still valid, although sparse.</p>
+    <p>A call to <c>get_system_memory_data/0</c> is more costly
+      than a call to <c>get_memory_data/0</c> as data is collected
+      synchronously when this function is called.</p>
+    <p>The total system memory reported under UNIX is the number of
+      physical pages of memory times the page size, and the available
+      memory is the number of available physical pages times the page
+      size. This is a reasonable measure as swapping should be avoided
+      anyway, but the task of defining total memory and available
+      memory is difficult because of virtual memory and swapping.</p>
+  </description>
+
+  <section>
+    <marker id="config"></marker>
+    <title>Configuration</title>
+    <p>The following configuration parameters can be used to change
+      the default values for time intervals and thresholds:</p>
+    <taglist>
+      <tag><c>memory_check_interval = int()>0</c></tag>
+      <item>
+        <p>The time interval, in minutes, for the periodic memory check.
+          The default is one minute.</p>
+      </item>
+      <tag><c>system_memory_high_watermark = float()</c></tag>
+      <item>
+        <p>The threshold, as percentage of system memory, for how much
+          system memory can be allocated before the corresponding alarm
+          is set. The default is 0.80 (80%).</p>
+      </item>
+      <tag><c>process_memory_high_watermark = float()</c></tag>
+      <item>
+        <p>The threshold, as percentage of system memory, for how much
+          system memory can be allocated by one Erlang process before
+          the corresponding alarm is set. The default is 0.05 (5%).</p>
+      </item>
+      <tag><c>memsup_helper_timeout = int()>0</c></tag>
+      <item>
+        <p>A timeout, in seconds, for how long the <c>memsup</c>
+          process should wait for a result from a memory check. If
+          the timeout expires, a warning message <c>"OS_MON (memsup) timeout"</c> is issued via <c>error_logger</c> and any
+          pending, synchronous client calls will return a dummy value.
+          Normally, this situation should not occur. There have been
+          cases on Linux, however, where the pseudo file from which
+          system data is read is temporarily unavailable when the system
+          is heavily loaded.</p>
+        <p>The default is 30 seconds. </p>
+      </item>
+      <tag><c>memsup_system_only = bool()</c></tag>
+      <item>
+        <p>Specifies whether the <c>memsup</c> process should only
+          check system memory usage (<c>true</c>) or not. The default is
+          <c>false</c>, meaning that information regarding both system
+          memory usage and Erlang process memory usage is collected.</p>
+        <p>It is recommended to set this parameter to <c>false</c> on
+          systems with many concurrent processes, as each process memory
+          check makes a traversal of the entire list of processes.</p>
+      </item>
+    </taglist>
+    <p>See <seealso marker="kernel:config">config(4)</seealso> for
+      information about how to change the value of configuration
+      parameters.</p>
+  </section>
+  <funcs>
+    <func>
+      <name>get_memory_data() -> {Total,Allocated,Worst}</name>
+      <fsummary>Get data for the memory in the system</fsummary>
+      <type>
+        <v>Total = Allocated = int()</v>
+        <v>Worst = {Pid, PidAllocated} | undefined</v>
+        <v>&nbsp;Pid = pid()</v>
+        <v>&nbsp;PidAllocated = int()</v>
+      </type>
+      <desc>
+        <p>Returns the result of the latest memory check, where
+          <c>Total</c> is the total memory size and <c>Allocated</c>
+          the allocated memory size, in bytes.</p>
+        <p><c>Worst</c> is the pid and number of allocated bytes of
+          the largest Erlang process on the node. If <c>memsup</c>
+          should not collect process data, that is if the configuration
+          parameter <c>memsup_system_only</c> was set to <c>true</c>,
+          <c>Worst</c> is <c>undefined</c>.</p>
+        <p>The function is normally asynchronous in the sense that it
+          does not invoke a memory check, but returns the latest
+          available value. The one exception if is the function is
+          called before a first memory check is finished, in which case
+          it does not return a value until the memory check is finished.</p>
+        <p>Returns <c>{0,0,{pid(),0}}</c> or <c>{0,0,undefined}</c> if
+          <c>memsup</c> is not available, or if all memory checks so far
+          have timed out.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_system_memory_data() -> MemDataList</name>
+      <fsummary>Get system dependent memory data</fsummary>
+      <type>
+        <v>MemDataList = [{Tag, Size}]</v>
+        <v>&nbsp;Tag = atom()</v>
+        <v>&nbsp;Size = int()</v>
+      </type>
+      <desc>
+        <p>Invokes a memory check and returns the resulting, system
+          dependent, data as a list of tagged tuples, where <c>Tag</c>
+          can be one of the following:</p>
+        <taglist>
+          <tag><c>total_memory</c></tag>
+          <item>The total amount of memory available to the Erlang emulator,
+           allocated and free. May or may not be equal to the amount
+           of memory configured in the system.</item>
+          <tag><c>free_memory</c></tag>
+          <item>The amount of free memory available to the Erlang emulator
+           for allocation.</item>
+          <tag><c>system_total_memory</c></tag>
+          <item>The amount of memory available to the whole operating
+           system. This may well be equal to <c>total_memory</c> but
+           not necessarily.</item>
+          <tag><c>largest_free</c></tag>
+          <item>The size of the largest contiguous free memory block
+           available to the Erlang emulator.</item>
+          <tag><c>number_of_free</c></tag>
+          <item>The number of free blocks available to the Erlang runtime
+           system. This gives a fair indication of how fragmented
+           the memory is.</item>
+          <tag><c>buffered_memory</c></tag>
+          <item>
+                The amount of memory the system uses for temporary storing raw disk blocks.
+          </item>
+          <tag><c>cached_memory</c></tag>
+          <item>
+                The amount of memory the system uses for cached files read from disk.
+          </item>
+          <tag><c>total_swap</c></tag>
+          <item>
+                The amount of total amount of memory the system has available
+                for disk swap.
+          </item>
+          <tag><c>free_swap</c></tag>
+          <item>
+                The amount of memory the system has available for disk swap.
+          </item>
+
+        </taglist>
+        <p>All memory sizes are presented as number of <em>bytes</em>.</p>
+        <p>The <c>largest_free</c> and <c>number_of_free</c> tags are
+          currently only returned on a VxWorks system.</p>
+        <p>Returns the empty list [] if <c>memsup</c> is not available,
+          or if the memory check times out.</p>
+	<note><p>
+	On linux the memory available to the emulator is <c>cached_memory</c> and <c>buffered_memory</c> in addition to 
+	<c>free_memory</c>.</p>
+	</note>
+      </desc>
+    </func>
+    <func>
+      <name>get_os_wordsize() -> Wordsize</name>
+      <fsummary>Get the wordsize of running os.</fsummary>
+      <type>
+        <v>Wordsize = 32 | 64 | unsupported_os</v>
+      </type>
+      <desc>
+        <p>Returns the wordsize of the current running operating system. </p>
+      </desc>
+    </func>
+    <func>
+      <name>get_check_interval() -> MS</name>
+      <fsummary>Get time interval, in milliseconds, for the periodic memory check</fsummary>
+      <type>
+        <v>MS = int()</v>
+      </type>
+      <desc>
+        <p>Returns the time interval, in milliseconds, for the periodic
+          memory check.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_check_interval(Minutes) -> ok</name>
+      <fsummary>Set time interval, in minutes, for the periodic memory check</fsummary>
+      <type>
+        <v>Minutes = int()>0</v>
+      </type>
+      <desc>
+        <p>Changes the time interval, given in minutes, for the periodic
+          memory check.</p>
+        <p>The change will take effect after the next memory check and is
+          non-persistent. That is, in case of a process restart, this
+          value is forgotten and the default value will be used. See
+          <seealso marker="#config">Configuration</seealso> above.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_procmem_high_watermark() -> int()</name>
+      <fsummary>Get threshold, in percent, for process memory allocation</fsummary>
+      <desc>
+        <p>Returns the threshold, in percent, for process memory
+          allocation.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_procmem_high_watermark(Float) -> ok</name>
+      <fsummary>Set threshold, as percentage represented by a float, for process memory allocation</fsummary>
+      <desc>
+        <p>Changes the threshold, given as a float, for process memory
+          allocation.</p>
+        <p>The change will take effect during the next periodic memory
+          check and is non-persistent. That is, in case of a process
+          restart, this value is forgotten and the default value will be
+          used. See <seealso marker="#config">Configuration</seealso>
+          above.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_sysmem_high_watermark() -> int()</name>
+      <fsummary>Get threshold, in percent, for system memory allocation</fsummary>
+      <desc>
+        <p>Returns the threshold, in percent, for system memory
+          allocation.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_sysmem_high_watermark(Float) -> ok</name>
+      <fsummary>Set threshold, given as a float, for system memory allocation</fsummary>
+      <desc>
+        <p>Changes the threshold, given as a float, for system memory
+          allocation.</p>
+        <p>The change will take effect during the next periodic memory
+          check and is non-persistent. That is, in case of a process
+          restart, this value is forgotten and the default value will be
+          used. See <seealso marker="#config">Configuration</seealso>
+          above.</p>
+      </desc>
+    </func>
+    <func>
+      <name>get_helper_timeout() -> Seconds</name>
+      <fsummary>Get the timeout value, in seconds, for memory checks</fsummary>
+      <type>
+        <v>Seconds = int()</v>
+      </type>
+      <desc>
+        <p>Returns the timeout value, in seconds, for memory checks.</p>
+      </desc>
+    </func>
+    <func>
+      <name>set_helper_timeout(Seconds) -> ok</name>
+      <fsummary>Set the timeout value, in seconds, for memory checks</fsummary>
+      <type>
+        <v>Seconds = int() (>= 1)</v>
+      </type>
+      <desc>
+        <p>Changes the timeout value, given in seconds, for memory
+          checks.</p>
+        <p>The change will take effect for the next memory check and is
+          non-persistent. That is, in the case of a process restart, this
+          value is forgotten and the default value will be used. See
+          <seealso marker="#config">Configuration</seealso> above.</p>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="sasl:alarm_handler">alarm_handler(3)</seealso>,
+      <seealso marker="os_mon_app">os_mon(3)</seealso></p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/note.gif b/lib/os_mon/doc/src/note.gif
new file mode 100644
index 0000000000..6fffe30419
--- /dev/null
+++ b/lib/os_mon/doc/src/note.gif
diff --git a/lib/os_mon/doc/src/notes.xml b/lib/os_mon/doc/src/notes.xml
new file mode 100644
index 0000000000..1a8551f57d
--- /dev/null
+++ b/lib/os_mon/doc/src/notes.xml
@@ -0,0 +1,537 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE chapter SYSTEM "chapter.dtd">
+
+<chapter>
+  <header>
+    <copyright>
+      <year>2004</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>OS_Mon Release Notes</title>
+    <prepared>otp_appnotes</prepared>
+    <docno>nil</docno>
+    <date>nil</date>
+    <rev>nil</rev>
+    <file>notes.xml</file>
+  </header>
+  <p>This document describes the changes made to the OS_Mon application.</p>
+
+<section><title>Os_Mon 2.2.4</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+          <p>
+	    Memsup did not read memory correctly on MaxOSX
+	    Snowleopard. This has now been corrected. (Thanks to Joel
+	    Reymont)</p>
+          <p>
+	    Own Id: OTP-8211</p>
+        </item>
+        <item>
+          <p>
+	    Removed unused code in <c>cpu_sup.erl</c>.</p>
+          <p>
+	    Own Id: OTP-8226</p>
+        </item>
+      </list>
+    </section>
+
+
+    <section><title>Improvements and New Features</title>
+      <list>
+        <item>
+          <p>
+	    The documentation is now built with open source tools
+	    (xsltproc and fop) that exists on most platforms. One
+	    visible change is that the frames are removed.</p>
+          <p>
+	    Own Id: OTP-8201</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.2.3</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+          <p>
+	    A missing define in <c>memsup.c</c> caused a build error
+	    on IRIX machines. This has now been fixed.</p>
+          <p>
+	    Own Id: OTP-8094</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.2.2</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+          <p>
+	    disksup:get_disk_data/0 returned disk volume in bytes
+	    instead of kbytes as stated in the documentation. The
+	    problem occurred on Windows only and is now corrected.</p>
+          <p>
+	    *** POTENTIAL INCOMPATIBILITY ***</p>
+          <p>
+	    Own Id: OTP-7741</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.2.1</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+	    <p>An error in <c>memsup</c> could cause <c>os_mon</c> to
+	    report erroneous memory values on windows for ranges of
+	    memory between 2GB and 4GB. This have now been fixed.</p>
+          <p>
+	    Own Id: OTP-7944</p>
+        </item>
+      </list>
+    </section>
+
+
+    <section><title>Improvements and New Features</title>
+      <list>
+        <item>
+	    <p>Added support for dragonfly OS.</p>
+          <p>
+	    Own Id: OTP-7938</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.2</title>
+
+    <section><title>Improvements and New Features</title>
+      <list>
+        <item>
+	    <p>The copyright notices have been updated.</p>
+          <p>
+	    Own Id: OTP-7851</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.1.8</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+	    <p>A problem with <c>OTP-OS-MON-MIB.mib</c> for 64-bit
+	    environments has now been fixed. The mib has been
+	    extended with 64-bit memory retrieval
+	    counterparts.</p><p>In addition, a new function
+	    <c>get_os_wordsize/0</c> has been added in the
+	    <c>memsup</c> module</p>
+          <p>
+	    Own Id: OTP-7441</p>
+        </item>
+        <item>
+	    <p>An error in <c>memsup.c</c> caused the compilation to
+	    crash on bsd environments. This has now been fixed.</p>
+          <p>
+	    Own Id: OTP-7558</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.1.7</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+	    <p>Fixed a build error that occurred on NetBSD (Thanks to
+	    Per Hedeland and Raphael Langerhorst)</p>
+          <p>
+	    Own Id: OTP-7505</p>
+        </item>
+      </list>
+    </section>
+
+
+    <section><title>Improvements and New Features</title>
+      <list>
+        <item>
+	    <p> Memory information in
+	    <c>memsup:get_system_memory_data/0</c> now has additional
+	    entries in its property list for linux.</p>
+          <p>
+	    Own Id: OTP-7409 Aux Id: seq10984 </p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.1.6</title>
+
+    <section><title>Fixed Bugs and Malfunctions</title>
+      <list>
+        <item>
+          <p>
+	    System information retrieval on darwin platforms with
+	    environments locales not conforming to the C locale
+	    caused an error in <c>cpu_sup</c> resulting in process
+	    termination.</p>
+          <p>
+	    Own Id: OTP-7320</p>
+        </item>
+      </list>
+    </section>
+
+</section>
+
+<section><title>Os_Mon 2.1.5</title>
+    <section><title>Improvements and New Features</title>
+      <list>
+        <item>
+          <p>
+	    CPU utilization, on linux, is now measured via a port
+	    program instead of os:cmd in erlang. This should enhance
+	    performance.</p>
+          <p>
+	    Own Id: OTP-7108 Aux Id: OTP-6935 </p>
+        </item>
+      </list>
+    </section>
+</section>
+
+  <section><title>Os_Mon 2.1.3</title>
+    <section><title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p>
+	    Extended memsup memory probing on linux to use a port
+	    program to probe memory usage. This is faster then the
+	    previous implementation.</p>
+          <p>
+	    Own Id: OTP-6860 Aux Id: seq10616 </p>
+        </item>
+      </list>
+    </section>
+   </section>
+
+
+  <section>
+    <title>Os_Mon 2.1.2.1</title>
+
+    <section>
+      <title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p>Minor Makefile changes.</p>
+          <p>Own Id: OTP-6689</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 2.1.2</title>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p>When the <c>memsup_system_only</c> flag was set to
+            <c>true</c>, a <c>badmatch</c> exception occurred in the
+            function <c>os_mon_mib:get_load/1</c>.</p>
+          <p>Own Id: OTP-6351 Aux Id: seq10517</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 2.1.1</title>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p>Did not build on Mac OS X.</p>
+          <p>Added support for IRIX. (Thanks to Michel Urvoy and
+            Daniel Solaz.)</p>
+          <p>Own Id: OTP-6136</p>
+        </item>
+      </list>
+    </section>
+
+    <section>
+      <title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p><c>disksup</c>: Now using <c>round(T*100)</c> instead of
+            <c>trunc(T*100)</c> when setting the threshold value
+            given a float <c>T</c>.</p>
+          <p>Own Id: OTP-6153</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>Os_Mon 2.1</title>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p>In 2.0, a call to <c>alarm_handler:get_alarms/0</c> was
+            introduced in <c>memsup</c> and <c>disksup</c>. This will
+            lead to problems if the default <c>alarm_handler</c>
+            event handler is not used, however, and the call has now
+            been removed. (Thanks to Serge Aleynikov for pointing
+            this out.)</p>
+          <p>Own Id: OTP-6029</p>
+        </item>
+        <item>
+          <p>A bug that in rare cases caused <c>cpu_sup</c> to crash
+            has been corrected.</p>
+          <p>Own Id: OTP-6102 Aux Id: seq10312 </p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 2.0</title>
+    <p>A note on backwards compatibility: The behaviour of OS_Mon 2.0 is
+      backwards compatible under normal operation, but has changed
+      somewhat in error situations: The services do not terminate
+      and the API functions do not raise exceptions in all cases where
+      they did before. Also, in the case where a service does terminate,
+      the exit reason may be different. See below for details.</p>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p>A call to a OS_Mon service (cpu_sup, disksup, ...) when
+            OS_Mon is not running, or when the service is not
+            available for the OS, or when the service is not started,
+            will no longer result in an exception. Instead a warning
+            is issued via error_logger and a dummy value is returned,
+            which one is specified in the man pages for the
+            respective service.</p>
+          <p>The reason is that it should not be necessary for a
+            service to be started on each and every node of a
+            distributed Erlang system for the OS-MON-MIB and other
+            OS_Mon users to work properly.</p>
+          <p>Own Id: OTP-4332 Aux Id: seq7358 </p>
+        </item>
+        <item>
+          <p>References to the obsolete EVA application in
+            OTP-OS-MON-MIB has been removed.</p>
+          <p>Own Id: OTP-5699</p>
+        </item>
+        <item>
+          <p>Setting the option <c>memsup_system_only</c> to
+            <c>true</c> did not work, but would crash the
+            <c>memsup</c> process.</p>
+          <p>Own Id: OTP-5890 Aux Id: seq10185 </p>
+        </item>
+        <item>
+          <p><c>cpu_sup:nprocs/0</c> returned 0 on FreeBsd.</p>
+          <p>Own Id: OTP-5901</p>
+        </item>
+        <item>
+          <p>If the OS_Mon service <c>disksup</c> or <c>memsup</c> was
+            restarted, the same alarm could be set twice. Also, set
+            alarms were not cleared when the application was stopped.</p>
+          <p>Own Id: OTP-5910</p>
+        </item>
+      </list>
+    </section>
+
+    <section>
+      <title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p>Thresholds and time intervals in <c>disksup</c> and
+            <c>memsup</c> are now configurable in run-time.</p>
+          <p>Own Id: OTP-4246 Aux Id: Seq7230 </p>
+        </item>
+        <item>
+          <p><c>memsup</c> can now handle systems with more than 4GB
+            of RAM.</p>
+          <p>Own Id: OTP-5800 Aux Id: seq10130 </p>
+        </item>
+        <item>
+          <p>The entire OS_Mon application (code and documentation)
+            has been reviewed and consequently updated with the goal
+            to make the application more robust, homogeneous and
+            easier to configure.</p>
+          <p>The behaviour under normal operation is backwards
+            compatible. However, recoverable errors now no longer
+            terminate the affected service (and thus possible the
+            entire application), instead <c>error_logger</c> is used
+            to warn the user if/when such errors occurs. Also, in the
+            case of unrecoverable errors, the services have been made
+            more homogeneous with respect to behavior and exit
+            reasons. See below for more information and refer to the
+            man pages for details.</p>
+          <p>Port handling has been unified, meaning that if a port
+            program sends garbage or unexpectedly dies, this is now
+            handled the same way by all OS_Mon services, namely
+            immediate process termination with the exit reason
+            <c>{port_error,Garbage}</c> or <c>{port_died,Reason}</c>,
+            respectively.</p>
+          <p>Application configuration parameter handling has been
+            unified. Bad parameter values are no longer silently
+            ignored (<c>disksup</c>) or cause application termination
+            (<c>memsup</c>, <c>os_sup</c>). Instead a warning is
+            issued and the default value for the parameter is used.
+            Also, some cases where a bad parameter value accidentally
+            could be accepted have been corrected.</p>
+          <p>Message handling has been unified. Unknown
+            (<c>gen_server-</c>) calls cause process termination,
+            whereas unknown casts and messages are now ignored by all
+            OS_Mon services.</p>
+          <p>Own Id: OTP-5897</p>
+        </item>
+        <item>
+          <p>The following changes have been made to the <c>os_sup</c>
+            service:</p>
+          <p>It is now available on Windows, using <c>nteventlog</c>
+            as backend.</p>
+          <p>On Solaris, enabling the service (that is, installing a
+            new configuration file for <c>syslogd</c> etc.) can now
+            be done outside the <c>os_sup</c> process. The reason for
+            this is that the Erlang emulator should normally not be
+            run with <c>root</c> privileges, as is otherwise
+            required. The new application configuration parameter
+            <c>os_sup_config</c> must be set to <c>false</c>.</p>
+          <p>Also, <c>os_sup</c> can now be configured using a new
+            configuration parameter <c>os_sup_mfa</c> to call an
+            arbitrary Erlang function when a message is received from
+            the OS.</p>
+          <p>Own Id: OTP-5925</p>
+        </item>
+        <item>
+          <p>The <c>memsup</c> service has been rewritten, replacing
+            the supervised <c>memsup_helper</c> with a linked help
+            process. This gives the <c>memsup</c> process more
+            control and prevents a situation where it gets out of
+            synch with the received memory data and thus possibly
+            returns erroneous results.</p>
+          <p>Own Id: OTP-5927</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 1.8.1</title>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p><c>cpu_sup:util/0</c> failed with error reason
+            <c>negative_diff</c> when called the first time on a
+            machine (hw) that had been up for a very long time.</p>
+          <p>Own Id: OTP-5869 Aux Id: seq10166</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 1.8</title>
+
+    <section>
+      <title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p>The memsup part of the OS_Mon application has been made
+            more stable. If there are (possibly temporary) problems
+            collecting memory data, the interface functions
+            (<c>get_memory_data/0</c>,
+            <c>get_system_memory_data/0</c>) now do not fail, but
+            return the previously collected value, if any, or a dummy
+            value otherwise. Also, a warning message is printed.</p>
+          <p>*** POTENTIAL INCOMPATIBILITY ***</p>
+          <p>Own Id: OTP-5798</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 1.7.4</title>
+
+    <section>
+      <title>Fixed Bugs and Malfunctions</title>
+      <list type="bulleted">
+        <item>
+          <p>Corrected several problems in the error handling/error
+            recovery (especially when OS_Mon is starting up).</p>
+          <p>Own Id: OTP-5559</p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 1.7.3</title>
+
+    <section>
+      <title>Improvements and New Features</title>
+      <list type="bulleted">
+        <item>
+          <p><c>memsup.c</c> will now compile on OpenBSD. (Thanks to
+            Geoff White and Jay Nelson.)</p>
+          <p>The <c>disksup</c> and <c>cpu_sup</c> modules now work on
+            Mac OS X (tested on Mac OS 10.3.8).</p>
+          <p>The <c>memsup</c> module should now work on Linux 2.6.* as
+            well as on older Linuxes. (<c>/proc/meminfo</c> has
+            slightly different formats in different releases of
+            Linux.)</p>
+          <p>Own Id: OTP-5421            <br></br>
+
+            Aux Id: OTP-5194, OTP-5228, OTP-5291 </p>
+        </item>
+      </list>
+    </section>
+  </section>
+
+  <section>
+    <title>OS_Mon 1.7.2</title>
+    <p>This version is identical with 1.7.</p>
+  </section>
+</chapter>
+
diff --git a/lib/os_mon/doc/src/nteventlog.xml b/lib/os_mon/doc/src/nteventlog.xml
new file mode 100644
index 0000000000..1e3fad90cd
--- /dev/null
+++ b/lib/os_mon/doc/src/nteventlog.xml
@@ -0,0 +1,104 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>1998</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>nteventlog</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>nteventlog</module>
+  <modulesummary>Interface to Windows Event Log</modulesummary>
+  <description>
+    <p><c>nteventlog</c> provides a generic interface to the Windows
+      event log. It is part of the OS_Mon application, see
+      <seealso marker="os_mon_app">os_mon(6)</seealso>. Available for
+      Windows versions where the event log is available. That is, not
+      for Windows 98 and some other older Windows versions, but for most
+      (all?) newer Windows versions.</p>
+    <p>This module is used as the Windows backend for <c>os_sup</c>, see
+      <seealso marker="os_sup">os_sup(3)</seealso>.</p>
+    <p>To retain backwards compatibility, this module can also be used
+      to start a standalone <c>nteventlog</c> process which is not part
+      of the OS_Mon supervision tree. When starting such a process,
+      the user has to supply an identifier as well as a callback
+      function to handle the messages.</p>
+    <p>The identifier, an arbitrary string, should be reused whenever
+      the same application (or node) wants to start the process.
+      <c>nteventlog</c> is informed about all events that have arrived
+      to the eventlog since the last accepted message for the current
+      identifier. As long as the same identifier is used, the same
+      eventlog record will not be sent to <c>nteventlog</c> more than
+      once (with the exception of when graved system failures arise, in
+      which case the last records written before the failure may be
+      sent to Erlang again after reboot).</p>
+    <p>If the event log is configured to wrap around automatically,
+      records that have arrived to the log and been overwritten when
+      <c>nteventlog</c> was not running are lost. It however detects
+      this state and loses no records that are not overwritten.</p>
+    <p>The callback function works as described in <c>os_sup(3)</c>.</p>
+  </description>
+  <funcs>
+    <func>
+      <name>start(Identifier, MFA) -> Result</name>
+      <name>start_link(Identifier, MFA) -> Result</name>
+      <fsummary>Start the NT eventlog server</fsummary>
+      <type>
+        <v>Identifier = string() | atom()</v>
+        <v>MFA = {Mod, Func, Args}</v>
+        <v>&nbsp;Mod = Func = atom()</v>
+        <v>&nbsp;Args = [term()]</v>
+        <v>Result = {ok, Pid} | {error, {already_started, Pid}}</v>
+        <v>Pid = pid()</v>
+      </type>
+      <desc>
+        <p>This function starts the standalone <c>nteventlog</c> process
+          and, if <c>start_link/2</c> is used, links to it.</p>
+        <p><c>Identifier</c> is an identifier as described above.</p>
+        <p><c>MFA</c> is the supplied callback function. When
+          <c>nteventlog</c> receives information about a new event, this
+          function will be called as <c>apply(Mod, Func, [Event|Args])</c> where <c>Event</c> is a tuple</p>
+      </desc>
+    </func>
+    <func>
+      <name>stop() -> stopped</name>
+      <fsummary>Stop the NT eventlog server</fsummary>
+      <type>
+        <v>Result = stopped</v>
+      </type>
+      <desc>
+        <p>Stops <c>nteventlog</c>. Usually only used during
+          development. The server does not have to be shut down
+          gracefully to maintain its state.</p>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="os_mon_app">os_mon(6)</seealso>,
+      <seealso marker="os_sup">os_sup(3)</seealso></p>
+    <p>Windows NT documentation</p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/os_mon_app.xml b/lib/os_mon/doc/src/os_mon_app.xml
new file mode 100644
index 0000000000..8b44b70c5f
--- /dev/null
+++ b/lib/os_mon/doc/src/os_mon_app.xml
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE appref SYSTEM "appref.dtd">
+
+<appref>
+  <header>
+    <copyright>
+      <year>1996</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>os_mon</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <app>os_mon</app>
+  <appsummary>OS Monitoring Application</appsummary>
+  <description>
+    <p>The operating system monitor, OS_Mon, provides the following
+      services:</p>
+    <list type="bulleted">
+      <item><seealso marker="cpu_sup">cpu_sup</seealso>
+       CPU load and utilization supervision (Unix)</item>
+      <item><seealso marker="disksup">disksup</seealso>
+       Disk supervision(Unix, Windows)</item>
+      <item><seealso marker="memsup">memsup</seealso>
+       Memory supervision (Unix, Windows, VxWorks)</item>
+      <item><seealso marker="os_sup">os_sup</seealso>
+       Interface to OS system messages (Solaris, Windows)</item>
+    </list>
+    <p>To simplify usage of OS_Mon on distributed Erlang systems, it is
+      not considered an error trying to use a service at a node where it
+      is not available (either because OS_Mon is not running, or because
+      the service is not available for that OS, or because the service
+      is not started). Instead, a warning message is issued via
+      <c>error_logger</c> and a dummy value is returned, which one is
+      specified in the man pages for the respective services.</p>
+  </description>
+
+  <section>
+    <title>Configuration</title>
+    <p>When OS_Mon is started, by default all services available for
+      the OS, except <c>os_sup</c>, are automatically started. This
+      configuration can be changed using the following application
+      configuration parameters:</p>
+    <taglist>
+      <tag><c>start_cpu_sup = bool()</c></tag>
+      <item>
+        <p>Specifies if <c>cpu_sup</c> should be started. Defaults to
+          <c>true</c>.</p>
+      </item>
+      <tag><c>start_disksup = bool()</c></tag>
+      <item>
+        <p>Specifies if <c>disksup</c> should be started. Defaults to
+          <c>true</c>.</p>
+      </item>
+      <tag><c>start_memsup = bool()</c></tag>
+      <item>
+        <p>Specifies if <c>memsup</c> should be started. Defaults to
+          <c>true</c>.</p>
+      </item>
+      <tag><c>start_os_sup = bool()</c></tag>
+      <item>
+        <p>Specifies if <c>os_sup</c> should be started. Defaults to
+          <c>false</c>.</p>
+      </item>
+    </taglist>
+    <p>Configuration parameters effecting the different OS_Mon services
+      are described in the respective man pages.</p>
+    <p>See <seealso marker="kernel:config">config(4)</seealso> for
+      information about how to change the value of configuration
+      parameters.</p>
+  </section>
+
+  <section>
+    <title>SNMP MIBs</title>
+    <p>The following MIBs are defined in OS_Mon:</p>
+    <taglist>
+      <tag>OTP-OS-MON-MIB</tag>
+      <item>
+        <p>This MIB contains objects for instrumentation of disk,
+          memory and CPU usage of the nodes in the system.</p>
+      </item>
+    </taglist>
+    <p>The MIB is stored in the <c>mibs</c> directory.  It is defined
+      in SNMPv2 SMI syntax. An SNMPv1 version of the MIB is delivered
+      in the <c>mibs/v1</c> directory.</p>
+    <p>The compiled MIB is located under <c>priv/mibs</c>, and
+      the generated <c>.hrl</c> file under the <c>include</c> directory.
+      To compile a MIB that IMPORTS the <c>OTP-OS-MON-MIB</c>, give
+      the option <c>{il, ["os_mon/priv/mibs"]}</c> to the MIB compiler.</p>
+    <p>If the MIB should be used in a system, it should be loaded into
+      an agent with a call to <c>os_mon_mib:load(Agent)</c>, where
+      <c>Agent</c> is the pid or registered name of an SNMP agent. Use
+      <c>os_mon_mib:unload(Agent)</c> to unload the MIB.
+      The implementation of this MIB uses Mnesia to store a cache with
+      data needed, which implicates that Mnesia must be up and running.
+      The MIB also use functions defined for the <c>OTP-MIB</c>, thus
+      that MIB must be loaded as well.</p>
+  </section>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="cpu_sup">cpu_sup(3)</seealso>,
+      <seealso marker="disksup">disksup(3)</seealso>,
+      <seealso marker="memsup">memsup(3)</seealso>,
+      <seealso marker="os_sup">os_sup(3)</seealso>,
+      <seealso marker="nteventlog">nteventlog(3)</seealso>,
+      <seealso marker="snmp:snmp">snmp(3)</seealso>.</p>
+  </section>
+</appref>
+
diff --git a/lib/os_mon/doc/src/os_mon_mib.xml b/lib/os_mon/doc/src/os_mon_mib.xml
new file mode 100644
index 0000000000..220d6a4a22
--- /dev/null
+++ b/lib/os_mon/doc/src/os_mon_mib.xml
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>2004</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>os_mon_mib</title>
+    <prepared>Ingela Andin</prepared>
+    <responsible></responsible>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>os_mon_mib</module>
+  <modulesummary>Loading and Unloading of OTP-OS-MON-MIB</modulesummary>
+  <description>
+    <p>Functions for loading and unloading the OTP-OS-MON-MIB into/from
+      an SNMP agent. The instrumentation of the OTP-OS-MON-MIB uses
+      Mnesia, hence Mnesia must be started prior to loading
+      the OTP-OS-MON-MIB.</p>
+  </description>
+  <funcs>
+    <func>
+      <name>load(Agent) -> ok | {error, Reason}</name>
+      <fsummary>Load the OTP-OS-MON-MIB</fsummary>
+      <type>
+        <v>Agent = pid() | atom()</v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Loads the OTP-OS-MON-MIB.</p>
+      </desc>
+    </func>
+    <func>
+      <name>unload(Agent) -> ok | {error, Reason}</name>
+      <fsummary>Unload the OTP-OS-MON-MIB</fsummary>
+      <type>
+        <v>Agent = pid() | atom() </v>
+        <v>Reason = term()</v>
+      </type>
+      <desc>
+        <p>Unloads the OTP-OS-MON-MIB.</p>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See Also</title>
+    <p><seealso marker="os_mon_app">os_mon(6)</seealso>,
+      <seealso marker="snmp:snmp">snmp(3)</seealso></p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/os_sup.xml b/lib/os_mon/doc/src/os_sup.xml
new file mode 100644
index 0000000000..792d18ba14
--- /dev/null
+++ b/lib/os_mon/doc/src/os_sup.xml
@@ -0,0 +1,241 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>1996</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>os_sup</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <module>os_sup</module>
+  <modulesummary>Interface to OS System Messages</modulesummary>
+  <description>
+    <p><c>os_sup</c> is a process providing a message passing service
+      from the operating system to the error logger in the Erlang
+      runtime system. It is part of the OS_Mon application, see
+      <seealso marker="os_mon_app">os_mon(6)</seealso>. Available for
+      Solaris and Windows.</p>
+    <p>Messages received from the operating system results in an
+      user defined callback function being called. This function can do
+      whatever filtering and formatting is necessary and then deploy any
+      type of logging suitable for the user's application.</p>
+  </description>
+
+  <section>
+    <title>Solaris Operation</title>
+    <p>The Solaris (SunOS 5.x) messages are retrieved from
+      the syslog-daemon, <c>syslogd</c>.</p>
+    <p>Enabling the service includes actions which require root
+      privileges, such as change of ownership and file privileges of an
+      executable binary file, and creating a modified copy of
+      the configuration file for <c>syslogd</c>. When <c>os_sup</c> is
+      terminated, the service must be disabled, meaning the original
+      configuration must be restored. Enabling/disabling can be done
+      either outside or inside <c>os_sup</c>, see
+      <seealso marker="#config">Configuration</seealso> below.</p>
+    <warning>
+      <p>This process cannot run in multiple instances on the same
+        hardware. OS_Mon must be configured to start <c>os_sup</c> on
+        one node only if two or more Erlang nodes execute on the same
+        machine.</p>
+    </warning>
+    <p>The format of received events is not defined.</p>
+  </section>
+
+  <section>
+    <title>Windows Operation</title>
+    <p>The Windows messages are retrieved from the eventlog file.</p>
+    <p>The <c>nteventlog</c> module is used to implement <c>os_sup</c>.
+      See <seealso marker="nteventlog">nteventlog(3)</seealso>. Note
+      that the start functions of <c>nteventlog</c> does not need to be
+      used, in this case the process is started automatically as part of
+      the OS_Mon supervision tree.</p>
+    <p>OS messages are formatted as a tuple
+      <c>{Time, Category, Facility, Severity, Message}</c>:</p>
+    <taglist>
+      <tag><c>Time = {MegaSecs, Secs, MicroSecs}</c></tag>
+      <item>
+        <p>A time stamp as returned by the BIF <c>now()</c>.</p>
+      </item>
+      <tag><c>Category = string()</c></tag>
+      <item>
+        <p>Usually one of <c>"System"</c>, <c>"Application"</c> or
+          <c>"Security"</c>. Note that the NT eventlog viewer has
+          another notion of category, which in most cases is totally
+          meaningless and therefore not imported into Erlang. What is
+          called a category here is one of the main three types of
+          events occurring in a normal NT system.</p>
+      </item>
+      <tag><c>Facility = string()</c></tag>
+      <item>
+        <p>The source of the message, usually the name of
+          the application that generated it. This could be almost any
+          string. When matching messages from certain applications,
+          the version number of the application may have to be
+          accounted for. This is what the NT event viewer calls
+          "source".</p>
+      </item>
+      <tag><c>Severity = string()</c></tag>
+      <item>
+        <p>One of <c>"Error"</c>, <c>"Warning"</c>,
+          <c>"Informational"</c>, <c>"Audit_Success"</c>,
+          <c>"Audit_Faulure"</c> or, in case of a currently unknown
+          Windows NT version <c>"Severity_Unknown"</c>.</p>
+      </item>
+      <tag><c>Message = string()</c></tag>
+      <item>
+        <p>Formatted exactly as it would be in the NT eventlog viewer.
+          Binary data is not imported into Erlang.</p>
+      </item>
+    </taglist>
+  </section>
+
+  <section>
+    <marker id="config"></marker>
+    <title>Configuration</title>
+    <taglist>
+      <tag><c>os_sup_mfa = {Module, Function, Args}</c></tag>
+      <item>
+        <p>The callback function to use. <c>Module</c> and
+          <c>Function</c> are atoms and <c>Args</c> is a list of terms.
+          When an OS message <c>Msg</c> is received, this function is
+          called as <c>apply(Module, Function, [Msg | Args])</c>.</p>
+        <p>Default is <c>{os_sup, error_report, [Tag]}</c> which will
+          send the event to the error logger using
+          <seealso marker="kernel:error_logger#error_report/2">error_logger:error_report(Tag, Msg)</seealso>. <c>Tag</c> is the value of
+          <c>os_sup_errortag</c>, see below.</p>
+      </item>
+      <tag><c>os_sup_errortag = atom()</c></tag>
+      <item>
+        <p>This parameter defines the error report type used when
+          messages are sent to error logger using the default callback
+          function. Default is <c>std_error</c>, which means the events
+          are handled by the standard event handler.</p>
+      </item>
+      <tag><c>os_sup_enable = bool()</c></tag>
+      <item>
+        <p>Solaris only. Defines if the service should be enabled (and
+          disabled) inside (<c>true</c>) or outside (<c>false</c>)
+          <c>os_sup</c>. For backwards compatibility reasons,
+          the default is <c>true</c>. The recommended value is
+          <c>false</c>, as the Erlang emulator should normally not be
+          run with <c>root</c> privileges, as is required for enabling
+          the service.</p>
+      </item>
+      <tag><c>os_sup_own = string()</c></tag>
+      <item>
+        <p>Solaris only. Defines the directory which contains
+          the backup copy and the Erlang specific configuration files
+          for <c>syslogd</c>, and a named pipe to receive the messages
+          from <c>syslogd</c>. Default is <c>"/etc"</c>.</p>
+      </item>
+      <tag><c>os_sup_syslogconf = string()</c></tag>
+      <item>
+        <p>Solaris only. Defines the full name of the configuration file
+          for <c>syslogd</c>. Default is <c>"/etc/syslog.conf"</c>.</p>
+      </item>
+    </taglist>
+  </section>
+  <funcs>
+    <func>
+      <name>enable() -> ok | {error, Res}</name>
+      <name>enable(Dir, Conf) -> ok | {error, Error}</name>
+      <fsummary>Enable the service (Solaris only)</fsummary>
+      <type>
+        <v>Dir = Conf = Res = string()</v>
+      </type>
+      <desc>
+        <p>Enables the <c>os_sup</c> service. Needed on Solaris only.</p>
+        <p>If the configuration parameter <c>os_sup_enable</c> is
+          <c>false</c>, this function is called automatically by
+          <c>os_sup</c>, using the values of <c>os_sup_own</c> and
+          <c>os_sup_syslogconf</c> as arguments.</p>
+        <p>If <c>os_sup_enable</c> is <c>true</c>, this function must
+          be called <em>before</em> OS_Mon/<c>os_sup</c> is started.
+          <c>Dir</c> defines the directory which contains the backup
+          copy and the Erlang specific configuration files for
+          <c>syslogd</c>, and a named pipe to receive the messages
+          from <c>syslogd</c>. Defaults to <c>"/etc"</c>. <c>Conf</c>
+          defines the full name of the configuration file for
+          <c>syslogd</c>. Default is <c>"/etc/syslog.conf"</c>.</p>
+        <p>Results in a OS call to:</p>
+        <code type="none"><![CDATA[
+<PRIVDIR>/bin/mod_syslog otp Dir Conf
+        ]]></code>
+        <p>where <c><![CDATA[<PRIVDIR>]]></c> is the <c>priv</c> directory of
+          OS_Mon, <c>code:priv_dir(os_mon)</c>.</p>
+        <p>Returns <c>ok</c> if this yields the expected result
+          <c>"0"</c>, and <c>{error, Res}</c> if it yields anything
+          else.</p>
+        <note>
+          <p>This function requires root privileges to succeed.</p>
+        </note>
+      </desc>
+    </func>
+    <func>
+      <name>disable() -> ok | {error, Res}</name>
+      <name>disable(Dir, Conf) -> ok | {error, Error}</name>
+      <fsummary>Disable the service (Solaris only)</fsummary>
+      <type>
+        <v>Dir = Conf = Res = string()</v>
+      </type>
+      <desc>
+        <p>Disables the <c>os_sup</c> service. Needed on Solaris only.</p>
+        <p>If the configuration parameter <c>os_sup_enable</c> is
+          <c>false</c>, this function is called automatically by
+          <c>os_sup</c>, using the same arguments as when
+          <c>enable/2</c> was called.</p>
+        <p>If <c>os_sup_enable</c> is <c>true</c>, this function must
+          be called <em>after</em> OS_Mon/<c>os_sup</c> is stopped.
+          <c>Dir</c> defines the directory which contains the backup
+          copy and the Erlang specific configuration files for
+          <c>syslogd</c>, and a named pipe to receive the messages
+          from <c>syslogd</c>. Defaults to <c>"/etc"</c>. <c>Conf</c>
+          defines the full name of the configuration file for
+          <c>syslogd</c>. Default is <c>"/etc/syslog.conf"</c>.</p>
+        <p>Results in a OS call to:</p>
+        <code type="none"><![CDATA[
+<PRIVDIR>/bin/mod_syslog nootp Dir Conf
+        ]]></code>
+        <p>where <c><![CDATA[<PRIVDIR>]]></c> is the <c>priv</c> directory of
+          OS_Mon, <c>code:priv_dir(os_mon)</c>.</p>
+        <p>Returns <c>ok</c> if this yields the expected result
+          <c>"0"</c>, and <c>{error, Res}</c> if it yields anything
+          else.</p>
+        <note>
+          <p>This function requires root privileges to succeed.</p>
+        </note>
+      </desc>
+    </func>
+  </funcs>
+
+  <section>
+    <title>See also</title>
+    <p><seealso marker="kernel:error_logger">error_logger(3)</seealso>,
+      <seealso marker="os_mon_app">os_mon(3)</seealso></p>
+    <p><c>syslogd(1M)</c>, <c>syslog.conf(4)</c> in the Solaris
+      documentation.</p>
+    <p></p>
+  </section>
+</erlref>
+
diff --git a/lib/os_mon/doc/src/part_notes.xml b/lib/os_mon/doc/src/part_notes.xml
new file mode 100644
index 0000000000..8fe226f53e
--- /dev/null
+++ b/lib/os_mon/doc/src/part_notes.xml
@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE part SYSTEM "part.dtd">
+
+<part xmlns:xi="http://www.w3.org/2001/XInclude">
+  <header>
+    <copyright>
+      <year>2004</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>OS_Mon Release Notes</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <description>
+    <p>The operating system monitor, OS_Mon, provides services for
+      monitoring CPU load, disk usage, memory usage and OS messages.</p>
+  </description>
+  <xi:include href="notes.xml"/>
+</part>
+
diff --git a/lib/os_mon/doc/src/ref_man.xml b/lib/os_mon/doc/src/ref_man.xml
new file mode 100644
index 0000000000..5a50c122fd
--- /dev/null
+++ b/lib/os_mon/doc/src/ref_man.xml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="latin1" ?>
+<!DOCTYPE application SYSTEM "application.dtd">
+
+<application xmlns:xi="http://www.w3.org/2001/XInclude">
+  <header>
+    <copyright>
+      <year>1996</year><year>2009</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    
+    </legalnotice>
+
+    <title>OS_Mon Reference Manual</title>
+    <prepared></prepared>
+    <docno></docno>
+    <date></date>
+    <rev></rev>
+  </header>
+  <description>
+    <p>The operating system monitor, OS_Mon, provides services for
+      monitoring CPU load, disk usage, memory usage and OS messages.</p>
+  </description>
+  <xi:include href="os_mon_app.xml"/>
+  <xi:include href="cpu_sup.xml"/>
+  <xi:include href="disksup.xml"/>
+  <xi:include href="memsup.xml"/>
+  <xi:include href="os_mon_mib.xml"/>
+  <xi:include href="os_sup.xml"/>
+  <xi:include href="nteventlog.xml"/>
+</application>
+
diff --git a/lib/os_mon/doc/src/user_guide.gif b/lib/os_mon/doc/src/user_guide.gif
new file mode 100644
index 0000000000..e6275a803d
--- /dev/null
+++ b/lib/os_mon/doc/src/user_guide.gif
diff --git a/lib/os_mon/doc/src/warning.gif b/lib/os_mon/doc/src/warning.gif
new file mode 100644
index 0000000000..96af52360e
--- /dev/null
+++ b/lib/os_mon/doc/src/warning.gif
diff --git a/lib/os_mon/ebin/.gitignore b/lib/os_mon/ebin/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/ebin/.gitignore
diff --git a/lib/os_mon/include/memsup.hrl b/lib/os_mon/include/memsup.hrl
new file mode 100644
index 0000000000..743d16522e
--- /dev/null
+++ b/lib/os_mon/include/memsup.hrl
@@ -0,0 +1,43 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1998-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%
+%%
+-ifndef(_memsup_hrl).
+-define(_memsup_hrl,true).
+%%% This file has to be kept consistent with ../c_src/memsup.h. 
+%%% Keep consistence manually.
+
+%% Defines
+
+-define( SHOW_MEM , 1 ).
+-define( SHOW_SYSTEM_MEM , 2 ).
+-define( SHOW_SYSTEM_MEM_END , 8#0 ).
+%% tags for extended statistics
+-define( MEM_SYSTEM_TOTAL , 1 ).
+-define( MEM_TOTAL , 2 ).
+-define( MEM_FREE , 3 ).
+-define( MEM_LARGEST_FREE , 4 ).
+-define( MEM_NUMBER_OF_FREE , 5 ).
+%% extensions 
+-define( MEM_BUFFERS , 6 ).
+-define( MEM_CACHED , 7 ).
+-define( MEM_SHARED , 8 ).
+-define( SWAP_TOTAL , 9 ).
+-define( SWAP_FREE , 10 ).
+
+-endif.
+
diff --git a/lib/os_mon/info b/lib/os_mon/info
new file mode 100644
index 0000000000..bc3f971c2a
--- /dev/null
+++ b/lib/os_mon/info
@@ -0,0 +1,3 @@
+group: oam
+short: A monitor which allows inspection of the underlying operating system
+
diff --git a/lib/os_mon/mibs/Makefile b/lib/os_mon/mibs/Makefile
new file mode 100644
index 0000000000..cbbc337491
--- /dev/null
+++ b/lib/os_mon/mibs/Makefile
@@ -0,0 +1,97 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1997-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=$(OS_MON_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/os_mon-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+
+MIB_FILES= OTP-OS-MON-MIB.mib 
+FUNCS_FILES = OTP-OS-MON-MIB.funcs
+
+BIN_TARGETS= $(MIB_FILES:%.mib=$(SNMP_BIN_TARGET_DIR)/%.bin)
+HRL_TARGETS= $(MIB_FILES:%.mib=$(SNMP_HRL_TARGET_DIR)/%.hrl)
+V1_MIB_FILES= $(MIB_FILES:%.mib=v1/%.mib.v1)
+
+TARGET_FILES= $(SNMP_BIN_TARGET_DIR)/OTP-REG.bin \
+  $(SNMP_BIN_TARGET_DIR)/OTP-TC.bin \
+  $(SNMP_BIN_TARGET_DIR)/OTP-MIB.bin \
+  $(BIN_TARGETS) $(HRL_TARGETS) $(V1_MIB_FILES)
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+SNMP_FLAGS =  -I $(SNMP_BIN_TARGET_DIR)
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+debug opt: $(TARGET_FILES)
+
+clean:
+	rm -f $(TARGET_FILES)
+	rm -f core
+
+docs:
+
+OTP_MIBDIR = $(shell if test -d ../../otp_mibs; then echo otp_mibs; \
+		      else echo sasl; fi)
+
+$(SNMP_BIN_TARGET_DIR)/OTP-REG.bin:     $(ERL_TOP)/lib/$(OTP_MIBDIR)/mibs/OTP-REG.mib
+	$(ERLC) -pa $(SNMP_TOOLKIT)/ebin -I $(SNMP_TOOLKIT)/priv/mibs $(SNMP_FLAGS) -o $(SNMP_BIN_TARGET_DIR) $<
+
+$(SNMP_BIN_TARGET_DIR)/OTP-TC.bin:     $(ERL_TOP)/lib/$(OTP_MIBDIR)/mibs/OTP-TC.mib
+	$(ERLC) -pa $(SNMP_TOOLKIT)/ebin -I $(SNMP_TOOLKIT)/priv/mibs $(SNMP_FLAGS) -o $(SNMP_BIN_TARGET_DIR) $<
+
+$(SNMP_BIN_TARGET_DIR)/OTP-MIB.bin:     $(ERL_TOP)/lib/$(OTP_MIBDIR)/mibs/OTP-MIB.mib
+	$(ERLC) -pa $(SNMP_TOOLKIT)/ebin -I $(SNMP_TOOLKIT)/priv/mibs $(SNMP_FLAGS) -o $(SNMP_BIN_TARGET_DIR) $<
+
+v1/%.mib.v1: %.mib
+	$(ERL_TOP)/lib/snmp/bin/snmp-v2tov1 -o $@ $<
+
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+	$(INSTALL_DIR) $(RELSYSDIR)/mibs
+	$(INSTALL_DIR) $(RELSYSDIR)/mibs/v1
+	$(INSTALL_DATA) $(MIB_FILES) $(FUNCS_FILES) $(RELSYSDIR)/mibs
+	$(INSTALL_DATA) $(V1_MIB_FILES) $(RELSYSDIR)/mibs/v1
+	$(INSTALL_DIR) $(RELSYSDIR)/include
+	$(INSTALL_DATA) $(HRL_TARGETS) $(RELSYSDIR)/include
+	$(INSTALL_DIR) $(RELSYSDIR)/priv/mibs
+	$(INSTALL_DATA) $(BIN_TARGETS) $(RELSYSDIR)/priv/mibs
+
+release_docs_spec:
diff --git a/lib/os_mon/mibs/OTP-OS-MON-MIB.funcs b/lib/os_mon/mibs/OTP-OS-MON-MIB.funcs
new file mode 100644
index 0000000000..7ed76517b9
--- /dev/null
+++ b/lib/os_mon/mibs/OTP-OS-MON-MIB.funcs
@@ -0,0 +1,5 @@
+{loadMemorySystemWatermark, {os_mon_mib, mem_sys_mark, []}}.
+{loadMemoryErlProcWatermark, {os_mon_mib, mem_proc_mark, []}}.
+{loadTable, {os_mon_mib, load_table, []}}.
+{diskAlmostFullThreshold, {os_mon_mib, disk_threshold, []}}.
+{diskTable, {os_mon_mib, disk_table, []}}.
diff --git a/lib/os_mon/mibs/OTP-OS-MON-MIB.mib b/lib/os_mon/mibs/OTP-OS-MON-MIB.mib
new file mode 100644
index 0000000000..d6ababdcea
--- /dev/null
+++ b/lib/os_mon/mibs/OTP-OS-MON-MIB.mib
@@ -0,0 +1,422 @@
+--
+-- %CopyrightBegin%
+-- 
+-- Copyright Ericsson AB 1997-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%
+--
+
+OTP-OS-MON-MIB DEFINITIONS ::= BEGIN
+ 
+IMPORTS
+    MODULE-IDENTITY, NOTIFICATION-TYPE, OBJECT-TYPE,
+    Counter32, Gauge32, Integer32, Unsigned32, Counter64
+        FROM SNMPv2-SMI
+    TEXTUAL-CONVENTION, DisplayString
+        FROM SNMPv2-TC
+    MODULE-COMPLIANCE, NOTIFICATION-GROUP, OBJECT-GROUP
+        FROM SNMPv2-CONF
+    otpModules, otpApplications
+        FROM OTP-REG
+    erlNodeId
+        FROM OTP-MIB
+    ;
+
+
+otpOsMonModule MODULE-IDENTITY
+    LAST-UPDATED  "0305090900Z"
+    ORGANIZATION  "Ericsson"
+    CONTACT-INFO
+        "Contact:  Erlang Support see license agreement for Erlang/OTP."
+
+    DESCRIPTION
+        "This MIB is part of the OTP MIB.  It defines MIB objects
+        for the os_mon application in OTP."
+
+    REVISION	"0508260900Z"
+    DESCRIPTION		
+        "Removed dependeny on EVA."
+    REVISION	"0305090900Z"
+    DESCRIPTION		
+        "Changed CONTACT-INFO as it was outdated, made it more generic
+	to avoid such changes in the future."
+    
+    REVISION     "9807080900Z"
+    DESCRIPTION
+        "Changed MAX-ACCESS for diskDescr from not-accessible to
+        read-only."
+
+    REVISION     "9801270900Z"
+    DESCRIPTION
+        "Changed erroneous name of this module to otpOsMonModule."
+
+    REVISION     "9712010900Z"
+    DESCRIPTION
+        "Converted to v2 SMI and placed in the OTP tree."
+
+    REVISION     "9608191700Z"
+    DESCRIPTION
+        "The initial revision of MIB module OTP-OS-MON-MIB."
+    ::= { otpModules 4 }
+
+OTPCounterBasedGauge64 ::= TEXTUAL-CONVENTION
+  STATUS       current
+  DESCRIPTION
+        "The CounterBasedGauge64 type represents a non-negative
+        integer, which may increase or decrease, but shall never
+        exceed a maximum value, nor fall below a minimum value. The
+        maximum value can not be greater than 2^64-1
+        (18446744073709551615 decimal), and the minimum value can
+
+        not be smaller than 0.  The value of a CounterBasedGauge64
+        has its maximum value whenever the information being modeled
+        is greater than or equal to its maximum value, and has its
+        minimum value whenever the information being modeled is
+        smaller than or equal to its minimum value.  If the
+        information being modeled subsequently decreases below
+        (increases above) the maximum (minimum) value, the
+        CounterBasedGauge64 also decreases (increases).
+
+        Note that this TC is not strictly supported in SMIv2,
+        because the 'always increasing' and 'counter wrap' semantics
+        associated with the Counter64 base type are not preserved.
+        It is possible that management applications which rely
+        solely upon the (Counter64) ASN.1 tag to determine object
+        semantics will mistakenly operate upon objects of this type
+        as they would for Counter64 objects.
+
+        This textual convention represents a limited and short-term
+        solution, and may be deprecated as a long term solution is
+        defined and deployed to replace it."
+  SYNTAX Counter64
+
+otpOsMonMIB     OBJECT IDENTIFIER ::= { otpApplications 2 }
+otpOsMonMIBConformance
+                OBJECT IDENTIFIER ::= { otpOsMonMIB 1 }
+otpOsMonMIBObjects
+                OBJECT IDENTIFIER ::= { otpOsMonMIB 2 }
+otpOsMonMIBAlarms
+                OBJECT IDENTIFIER ::= { otpOsMonMIB 4 }
+otpOsMonMIBAlarmsV2
+                OBJECT IDENTIFIER ::= { otpOsMonMIBAlarms 0 }
+
+
+-- Datatypes
+
+-- Managed Objects
+
+load            OBJECT IDENTIFIER ::= { otpOsMonMIBObjects 1 }
+disk            OBJECT IDENTIFIER ::= { otpOsMonMIBObjects 2 }
+
+loadMemorySystemWatermark OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION    
+        "Threshold in percent of the total available system
+        memory, which specifies how much memory can be allocated
+        by the system before an alarm is sent."
+    ::= { load 1 }
+
+loadMemoryErlProcWatermark OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only    
+    STATUS      current    
+    DESCRIPTION
+        "Threshold in percent of the total available system
+        memory, which specifies how much memory can be allocated
+        by one Erlang process before an alarm is sent."
+    ::= { load 2 }
+
+loadTable OBJECT-TYPE
+    SYNTAX      SEQUENCE OF LoadEntry
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+        "A table with load and memory information
+        for each node."
+    ::= { load 3 }
+
+loadEntry OBJECT-TYPE
+    SYNTAX      LoadEntry
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+        "A conceptual row in the loadTable."
+    INDEX   { loadErlNodeName }
+    ::= { loadTable 1 }
+
+LoadEntry ::= SEQUENCE {
+    loadErlNodeName                   DisplayString,
+    loadSystemTotalMemory             Gauge32,
+    loadSystemUsedMemory              Gauge32,
+    loadLargestErlProcess             DisplayString,
+    loadLargestErlProcessUsedMemory   Gauge32,
+    loadCpuLoad                       Integer32,
+    loadCpuLoad5                      Integer32,
+    loadCpuLoad15                     Integer32,
+    loadOsWordsize                    Unsigned32,
+    loadSystemTotalMemory64           OTPCounterBasedGauge64,
+    loadSystemUsedMemory64            OTPCounterBasedGauge64,
+    loadLargestErlProcessUsedMemory64 OTPCounterBasedGauge64
+    }
+
+loadErlNodeName OBJECT-TYPE
+    SYNTAX      DisplayString
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+        "The name of the erlang node, e.g. erlnode@host1."
+    ::= { loadEntry 1 }
+
+loadSystemTotalMemory OBJECT-TYPE
+    SYNTAX      Gauge32
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of total memory in the system."
+    ::= { loadEntry 2 }
+
+loadSystemUsedMemory OBJECT-TYPE
+    SYNTAX      Gauge32
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of used memory."
+    ::= { loadEntry 3 }
+
+loadLargestErlProcess OBJECT-TYPE
+    SYNTAX      DisplayString
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The process identifier (Pid) of the largest Erlang
+        process."
+    ::= { loadEntry 4 }
+
+loadLargestErlProcessUsedMemory OBJECT-TYPE
+    SYNTAX      Gauge32
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of memory used by the largest Erlang
+        process."
+    ::= { loadEntry 5 }
+
+loadCpuLoad OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The average load the last minute in percent of the CPU
+	where the Erlang node runs."
+    ::= { loadEntry 6 }
+
+loadCpuLoad5 OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The average load the last 5 minutes in percent of the CPU
+	where the Erlang node runs."
+    ::= { loadEntry 7}
+
+loadCpuLoad15 OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The average load the last 15 minutes in percent of the CPU
+	where the Erlang node runs."
+    ::= { loadEntry 8}
+
+loadOsWordsize OBJECT-TYPE
+    SYNTAX      Unsigned32
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The wordsize of the operating operating system."
+    ::= { loadEntry 9 }
+
+loadSystemTotalMemory64 OBJECT-TYPE
+    SYNTAX      OTPCounterBasedGauge64
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of total memory in the system for 64-bit operating system."
+    ::= { loadEntry 10 }
+
+loadSystemUsedMemory64 OBJECT-TYPE
+    SYNTAX      OTPCounterBasedGauge64
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of used memory for 64-bit operating system."
+    ::= { loadEntry 11 }
+
+loadLargestErlProcessUsedMemory64 OBJECT-TYPE
+    SYNTAX      OTPCounterBasedGauge64
+    UNITS       "bytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of memory used by the largest Erlang
+        process for 64-bit operating system.."
+    ::= { loadEntry 12 }
+
+diskAlmostFullThreshold OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only    
+    STATUS      current    
+    DESCRIPTION    
+        "Threshold in percent of the available disk space,
+        which specifies how much disk space can be used by
+        a disk or partition before an alarm is sent."
+    ::= { disk 1 }
+
+diskTable OBJECT-TYPE
+    SYNTAX      SEQUENCE OF DiskEntry
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+          "A table with all local disks or partitions on each
+          node."
+    ::= { disk 2 }
+
+diskEntry OBJECT-TYPE
+    SYNTAX      DiskEntry
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+          "A conceptual row in the diskTable."
+    INDEX      { erlNodeId, diskId }
+    ::= { diskTable 1 }
+
+DiskEntry ::= SEQUENCE {
+    diskId          Integer32,
+    diskDescr       DisplayString,
+    diskKBytes      Gauge32,
+    diskCapacity    Integer32
+    }
+
+diskId OBJECT-TYPE
+    SYNTAX      Integer32
+    MAX-ACCESS  not-accessible
+    STATUS      current
+    DESCRIPTION
+        "An integer that uniquely identifies the disk
+        or partition."
+    ::= { diskEntry 1 }
+
+diskDescr OBJECT-TYPE
+    SYNTAX     DisplayString
+    MAX-ACCESS read-only
+    STATUS     current
+    DESCRIPTION
+        "A string that identifies the disk or partition."
+    ::= { diskEntry 2 }
+
+diskKBytes OBJECT-TYPE
+    SYNTAX      Gauge32
+    UNITS       "kbytes"
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "The amount of total disk/partition space. "
+    ::= { diskEntry 3 }
+
+diskCapacity OBJECT-TYPE
+    SYNTAX      Integer32 (0..100)
+    MAX-ACCESS  read-only
+    STATUS      current
+    DESCRIPTION
+        "How much of the disk's/partition's total capacity has
+        been used, in percent."
+    ::= { diskEntry 4 }
+
+
+-- conformance information
+
+otpOsMonMIBCompliances
+                OBJECT IDENTIFIER ::= { otpOsMonMIBConformance 1 }
+otpOsMonMIBGroups
+                OBJECT IDENTIFIER ::= { otpOsMonMIBConformance 2 }
+
+
+-- compliance statements
+
+otpOsMonBasicCompliance MODULE-COMPLIANCE
+    STATUS  current
+    DESCRIPTION
+        "The compliance statement for SNMPv2 entities which
+        implement the OTP-OS-MON-MIB."
+    MODULE  -- this module
+        GROUP loadGroup
+        DESCRIPTION
+            "This group is mandatory for systems implementing the
+            load supervison functionality."
+        GROUP loadAlarmsGroup
+        DESCRIPTION
+            "This group is optional for systems implementing the
+            load supervison functionality."
+        GROUP diskGroup
+        DESCRIPTION
+            "This group is mandatory for system implementing the
+            disk supervison functionality."
+        GROUP diskAlarmsGroup
+        DESCRIPTION
+            "This group is optional for systems implementing the
+            disk supervison functionality."
+    ::= { otpOsMonMIBCompliances 1 }
+
+
+-- units of conformance
+
+loadGroup OBJECT-GROUP
+    OBJECTS { loadMemorySystemWatermark,
+              loadMemoryErlProcWatermark,
+              loadSystemTotalMemory,
+              loadSystemUsedMemory,
+              loadLargestErlProcess,
+              loadLargestErlProcessUsedMemory,
+              loadCpuLoad,
+              loadCpuLoad5,
+              loadCpuLoad15,
+              loadOsWordsize,
+              loadSystemTotalMemory64,
+              loadSystemUsedMemory64,
+              loadLargestErlProcessUsedMemory64}
+    STATUS  current
+    DESCRIPTION
+            "A collection of objects providing basic instrumentation
+            of the load of the OTP system."
+    ::= { otpOsMonMIBGroups 1 }
+
+diskGroup OBJECT-GROUP
+    OBJECTS { diskAlmostFullThreshold,
+              diskDescr,
+              diskKBytes,
+              diskCapacity }
+    STATUS  current
+    DESCRIPTION
+            "A collection of objects providing basic instrumentation
+            of the disks in the OTP system."
+    ::= { otpOsMonMIBGroups 3 }
+
+END
diff --git a/lib/os_mon/mibs/v1/.gitignore b/lib/os_mon/mibs/v1/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/mibs/v1/.gitignore
diff --git a/lib/os_mon/priv/bin/.gitignore b/lib/os_mon/priv/bin/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/priv/bin/.gitignore
diff --git a/lib/os_mon/priv/mibs/.gitignore b/lib/os_mon/priv/mibs/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/priv/mibs/.gitignore
diff --git a/lib/os_mon/priv/obj/.gitignore b/lib/os_mon/priv/obj/.gitignore
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/lib/os_mon/priv/obj/.gitignore
diff --git a/lib/os_mon/src/Makefile b/lib/os_mon/src/Makefile
new file mode 100644
index 0000000000..9a75446a89
--- /dev/null
+++ b/lib/os_mon/src/Makefile
@@ -0,0 +1,110 @@
+#
+# %CopyrightBegin%
+# 
+# Copyright Ericsson AB 1996-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=$(OS_MON_VSN)
+
+# ----------------------------------------------------
+# Release directory specification
+# ----------------------------------------------------
+RELSYSDIR = $(RELEASE_PATH)/lib/os_mon-$(VSN)
+
+# ----------------------------------------------------
+# Target Specs
+# ----------------------------------------------------
+MODULES= disksup memsup cpu_sup os_mon os_mon_mib os_sup os_mon_sysinfo \
+	nteventlog
+
+INCLUDE=../include
+CSRC=../c_src
+
+MEMSUP_HRL=$(INCLUDE)/memsup.hrl
+
+HRL_FILES= $(MEMSUP_HRL)
+ERL_FILES= $(MODULES:%=%.erl)
+
+APP_FILE= os_mon.app
+APP_SRC= $(APP_FILE).src
+APP_TARGET=$(EBIN)/$(APP_FILE)
+
+APPUP_FILE= os_mon.appup
+
+APPUP_SRC= $(APPUP_FILE).src
+APPUP_TARGET= ../ebin/$(APPUP_FILE)
+
+
+TARGET_FILES= $(MODULES:%=$(EBIN)/%.$(EMULATOR)) $(APP_TARGET) $(APPUP_TARGET)
+
+# ----------------------------------------------------
+# FLAGS
+# ----------------------------------------------------
+ERL_COMPILE_FLAGS += +warn_obsolete_guard -I$(INCLUDE)
+
+# ----------------------------------------------------
+# Targets
+# ----------------------------------------------------
+
+debug opt: $(TARGET_FILES)
+
+clean:
+	rm -f $(TARGET_FILES)
+	rm -f core *~
+
+docs:
+
+# ----------------------------------------------------
+# Special Build Targets
+# ----------------------------------------------------
+
+$(APP_TARGET): $(APP_SRC) ../vsn.mk
+	sed -e 's;%VSN%;$(VSN);' $< > $@
+
+$(APPUP_TARGET): $(APPUP_SRC) ../vsn.mk
+	sed -e 's;%VSN%;$(VSN);' $< > $@
+
+#-------------------------------------------------------
+# Special dependencies
+#-------------------------------------------------------
+$(EBIN)/memsup.$(EMULATOR): $(MEMSUP_HRL)
+
+# ----------------------------------------------------
+# Release Target
+# ---------------------------------------------------- 
+include $(ERL_TOP)/make/otp_release_targets.mk
+
+release_spec: opt
+	$(INSTALL_DIR) $(RELSYSDIR)/src
+	$(INSTALL_DATA) $(ERL_FILES) $(RELSYSDIR)/src
+	$(INSTALL_DATA) $(HRL_FILES) $(RELSYSDIR)/src
+	$(INSTALL_DIR) $(RELSYSDIR)/ebin
+	$(INSTALL_DATA) $(TARGET_FILES) $(RELSYSDIR)/ebin
+
+release_docs_spec:
+
+
+
+
+
+
+
diff --git a/lib/os_mon/src/cpu_sup.erl b/lib/os_mon/src/cpu_sup.erl
new file mode 100644
index 0000000000..742e20b1fa
--- /dev/null
+++ b/lib/os_mon/src/cpu_sup.erl
@@ -0,0 +1,776 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-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%
+%%
+-module(cpu_sup).
+
+%% API
+-export([start_link/0, start/0, stop/0]).
+-export([nprocs/0, avg1/0, avg5/0, avg15/0, util/0, util/1]).
+-export([dummy_reply/1]).
+
+%% For testing
+-export([ping/0]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+%% Internal protocol with the port program
+-define(nprocs,"n").
+-define(avg1,"1").
+-define(avg5,"5").
+-define(avg15,"f").
+-define(quit,"q").
+-define(ping,"p").
+-define(util,"u").
+
+-define(cu_cpu_id, 0).
+-define(cu_user, 1).
+-define(cu_nice_user, 2).
+-define(cu_kernel, 3).
+-define(cu_io_wait, 4).
+-define(cu_idle, 5).
+-define(cu_hard_irq, 6).
+-define(cu_soft_irq, 7).
+-define(cu_steal, 8).
+
+-define(INT32(D3,D2,D1,D0),
+	(((D3) bsl 24) bor ((D2) bsl 16) bor ((D1) bsl 8) bor (D0))).
+
+-define(MAX_UINT32, ((1 bsl 32) - 1)).
+
+-record(cpu_util, {cpu, busy = [], non_busy = []}).
+
+-record(state, {server, os_type}).
+%-record(state, {server, port = not_used, util = [], os_type}).
+
+-record(internal, {port = not_used, util = [], os_type}).
+
+%%----------------------------------------------------------------------
+%% Contract specifications 
+%%----------------------------------------------------------------------
+
+-type(util_cpus() :: 'all' | integer() | [integer()]).
+-type(util_state() :: 
+	'user' | 
+	'nice_user' | 
+	'kernel' |
+	'wait' |
+	'idle').
+-type(util_value() :: {util_state(), float()} | float()).
+-type(util_desc() :: {util_cpus(), util_value(), util_value(), []}).
+
+%%----------------------------------------------------------------------
+%% Exported functions
+%%----------------------------------------------------------------------
+
+start() ->
+    gen_server:start({local, cpu_sup}, cpu_sup, [], []).
+
+start_link() ->
+    gen_server:start_link({local, cpu_sup}, cpu_sup, [], []).
+
+stop() ->
+    gen_server:call(cpu_sup, ?quit, infinity).
+
+-spec(nprocs/0 :: () -> integer() | {'error', any()}).
+
+nprocs() ->
+    os_mon:call(cpu_sup, ?nprocs, infinity).
+
+-spec(avg1/0 :: () -> integer() | {'error', any()}).
+
+avg1() ->
+    os_mon:call(cpu_sup, ?avg1, infinity).
+
+-spec(avg5/0 :: () -> integer() | {'error', any()}).
+
+avg5() ->
+    os_mon:call(cpu_sup, ?avg5, infinity).
+
+-spec(avg15/0 :: () -> integer() | {'error', any()}).
+
+avg15() ->
+    os_mon:call(cpu_sup, ?avg15, infinity).
+
+-spec(util/1 :: ([ 'detailed' | 'per_cpu']) -> 
+	util_desc() | [util_desc()] | {'error', any()}).
+
+util(Args) when is_list (Args) ->
+   % Get arguments
+   case lists:foldl(
+	    fun (detailed, {_ , PC}) -> {true, PC  };
+	        (per_cpu , {D , _ }) -> {D   , true};
+	        (_       , _       ) -> badarg
+	    end, {false, false}, Args) of
+	badarg -> 
+	    erlang:error(badarg);
+	{Detailed, PerCpu} ->
+	    os_mon:call(cpu_sup, {?util, Detailed, PerCpu}, infinity)
+    end;
+util(_) ->
+    erlang:error(badarg).
+
+-spec(util/0 :: () -> float()).
+
+util() ->
+    case util([]) of
+	{all, Busy, _, _} -> Busy;
+	Error -> Error
+    end.
+
+dummy_reply(?nprocs) -> 0;
+dummy_reply(?avg1) ->   0;
+dummy_reply(?avg5) ->   0;
+dummy_reply(?avg15) ->  0;
+dummy_reply({?util,_,_}) -> {all, 0, 0, []}.
+
+%%----------------------------------------------------------------------
+%% For testing
+%%----------------------------------------------------------------------
+
+ping() ->
+    gen_server:call(cpu_sup,?ping).
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+%% init
+init([]) ->
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+    {ok, 
+	#state{	os_type = os:type(), 
+		server = measurement_server_start()
+	}
+    }.
+handle_call(?quit, _From, State) ->
+    {stop, normal, ok, State};
+handle_call({?util, D, PC}, {Client, _Tag},
+	#state{os_type = {unix, Flavor}} = State) 
+	when Flavor == sunos;
+	     Flavor == linux ->
+    case measurement_server_call(State#state.server, {?util, D, PC, Client}) of
+	{error, Reason} -> 
+	    {	reply, 
+		{error, Reason}, 
+		State#state{server=measurement_server_restart(State#state.server)}
+	    };
+	Result -> {reply, Result, State}
+    end;
+handle_call({?util, Detailed, PerCpu}, _From, State) ->
+    String = "OS_MON (cpu_sup), util/1 unavailable for this OS~n",
+    error_logger:warning_msg(String),
+    {reply, dummy_reply({?util, Detailed, PerCpu}), State};
+handle_call(Request, _From, State) when Request==?nprocs;
+					Request==?avg1;
+					Request==?avg5;
+					Request==?avg15;
+					Request==?ping ->
+    case measurement_server_call(State#state.server, Request) of
+	{error, Reason} -> 
+	    {	reply, 
+		{error, Reason}, 
+		State#state{server=measurement_server_restart(State#state.server)}
+	    };
+	Result -> {reply, Result, State}
+    end.
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+handle_info({'EXIT', _Port, Reason}, State) ->
+    {stop, {server_died, Reason}, State#state{server=not_used}};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, State) ->
+    exit(State#state.server, normal).
+
+%% os_mon-2.0
+%% For live downgrade to/upgrade from os_mon-1.8[.1]
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+	    process_flag(trap_exit, false);
+
+	%% Upgrade to this version
+	_Vsn ->
+	    process_flag(trap_exit, true)
+    end,
+    {ok, PrevState};
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% internal functions 
+%%----------------------------------------------------------------------
+
+get_uint32_measurement(Request, #internal{port = P, os_type = {unix, sunos}}) ->
+    port_server_call(P, Request);
+get_uint32_measurement(Request, #internal{os_type = {unix, linux}}) ->
+    {ok,F} = file:open("/proc/loadavg",[read,raw]),
+    {ok,D} = file:read(F,24),
+    ok = file:close(F),
+    {ok,[Load1,Load5,Load15,_PRun,PTotal],_} = io_lib:fread("~f ~f ~f ~d/~d", D),
+    case Request of
+	?avg1  -> sunify(Load1);
+	?avg5  -> sunify(Load5);
+	?avg15 -> sunify(Load15);
+	?ping -> 4711;
+	?nprocs -> PTotal
+    end;
+get_uint32_measurement(Request, #internal{os_type = {unix, freebsd}}) ->
+    D = os:cmd("/sbin/sysctl -n vm.loadavg") -- "\n",
+    {ok,[Load1,Load5,Load15],_} = io_lib:fread("{ ~f ~f ~f }", D),
+    %% We could count the lines from the ps command as well
+    case Request of
+	?avg1  -> sunify(Load1);
+	?avg5  -> sunify(Load5);
+	?avg15 -> sunify(Load15);
+	?ping -> 4711;
+	?nprocs ->
+	    Ps = os:cmd("/bin/ps -ax | /usr/bin/wc -l"),
+	    {ok, [N], _} = io_lib:fread("~d", Ps),
+	    N-1
+    end;
+get_uint32_measurement(Request, #internal{os_type = {unix, dragonfly}}) ->
+    D = os:cmd("/sbin/sysctl -n vm.loadavg") -- "\n",
+    {ok,[Load1,Load5,Load15],_} = io_lib:fread("{ ~f ~f ~f }", D),
+    %% We could count the lines from the ps command as well
+    case Request of
+	?avg1  -> sunify(Load1);
+	?avg5  -> sunify(Load5);
+	?avg15 -> sunify(Load15);
+	?ping -> 4711;
+	?nprocs ->
+	    Ps = os:cmd("/bin/ps -ax | /usr/bin/wc -l"),
+	    {ok, [N], _} = io_lib:fread("~d", Ps),
+	    N-1
+    end;
+get_uint32_measurement(Request, #internal{os_type = {unix, openbsd}}) ->
+    D = os:cmd("/sbin/sysctl -n vm.loadavg") -- "\n",
+    {ok, [L1, L5, L15], _} = io_lib:fread("~f ~f ~f", D),
+    case Request of
+	?avg1  -> sunify(L1);
+	?avg5  -> sunify(L5);
+	?avg15 -> sunify(L15);
+	?ping -> 4711;
+	?nprocs ->
+	    Ps = os:cmd("/bin/ps -ax | /usr/bin/wc -l"),
+	    {ok, [N], _} = io_lib:fread("~d", Ps),
+	    N-1
+    end;
+get_uint32_measurement(Request, #internal{os_type = {unix, darwin}}) ->
+    %% Get the load average using uptime, overriding Locale setting.
+    D = os:cmd("LANG=C LC_ALL=C uptime") -- "\n",
+    %% Here is a sample uptime string from Mac OS 10.3.8 (C Locale):
+    %%    "11:17  up 12 days, 20:39, 2 users, load averages: 1.07 0.95 0.66"
+    %% The safest way to extract the load averages seems to be grab everything
+    %% after the last colon and then do an fread on that.
+    Avg = lists:reverse(hd(string:tokens(lists:reverse(D), ":"))),
+    {ok,[L1,L5,L15],_} = io_lib:fread("~f ~f ~f", Avg),
+
+    case Request of
+	?avg1  -> sunify(L1);
+	?avg5  -> sunify(L5);
+	?avg15 -> sunify(L15);
+	?ping -> 4711;
+	?nprocs ->
+	    Ps = os:cmd("/bin/ps -ax | /usr/bin/wc -l"),
+	    {ok, [N], _} = io_lib:fread("~d", Ps),
+	    N-1
+    end;
+get_uint32_measurement(Request, #internal{os_type = {unix, Sys}}) when Sys == irix64;
+								 Sys == irix ->
+    %% Get the load average using uptime.
+    %% "8:01pm  up 2 days, 22:12,  4 users,  load average: 0.70, 0.58, 0.43"
+    D = os:cmd("uptime") -- "\n",
+    Avg = lists:reverse(hd(string:tokens(lists:reverse(D), ":"))),
+    {ok, [L1, L5, L15], _} = io_lib:fread("~f, ~f, ~f", Avg),
+    case Request of
+	?avg1  -> sunify(L1);
+	?avg5  -> sunify(L5);
+	?avg15 -> sunify(L15);
+	?ping -> 4711;
+	?nprocs ->
+	    {ok, ProcList} = file:list_dir("/proc/pinfo"),
+	    length(ProcList)
+    end;
+get_uint32_measurement(_, _) -> 
+    throw(not_implemented).
+
+
+get_util_measurement(?util, #internal{port = P }) ->
+    case port_server_call(P, ?util) of
+	{error, Error} -> {error, Error};
+        NewCpuUtil -> NewCpuUtil
+    end;
+get_util_measurement(_,_) ->
+    throw(not_implemented).
+
+%%----------------------------------------------------------------------
+%% BEGIN: tainted internal functions 
+%%----------------------------------------------------------------------
+
+sunify(Val)  ->
+    round(Val*256). % Note that Solaris and Linux load averages are
+		% measured quite differently anyway
+
+
+keysearchdelete(_, _, []) ->
+    {false, []};
+keysearchdelete(K, N, [T|Ts]) when element(N, T) == K ->
+    {{value, T}, Ts};
+keysearchdelete(K, N, [T|Ts]) ->
+    {X, NTs} = keysearchdelete(K, N, Ts),
+    {X, [T|NTs]}.
+
+%% Internal cpu utilization functions 
+
+%% cpu_util_diff(New, Old) takes a list of new cpu_util records as first
+%% argument and a list of old cpu_util records as second argument. The
+%% two lists have to be sorted on cpu index in ascending order.
+%%
+%% The returned value is a difference list in descending order.
+cpu_util_diff(New, Old) ->
+    cpu_util_diff(New, Old, []).
+
+cpu_util_diff([], [], Acc) ->
+    Acc;
+cpu_util_diff([#cpu_util{cpu      = Cpu,
+		     busy     = NewBusy,
+		     non_busy = NewNonBusy} | NewCpuUtils],
+	  [#cpu_util{cpu      = Cpu,
+		     busy     = OldBusy,
+		     non_busy = OldNonBusy} | OldCpuUtils],
+	  Acc) ->
+    {PreBusy, GotBusy} = state_list_diff(NewBusy, OldBusy),
+    {NonBusy, GotNonBusy} = state_list_diff(NewNonBusy, OldNonBusy),
+    Busy = case GotBusy orelse GotNonBusy of
+	   true ->
+	       PreBusy;
+	   false ->
+	       %% This can happen if cpu_sup:util/[0,1] is called
+	       %% again immediately after the previous call has
+	       %% returned. Because the user obviously is doing
+	       %% something we charge "user".
+	       lists:map(fun ({user, 0}) -> {user, 1};
+			     ({_, 0} = StateTup) -> StateTup
+			 end,
+			 PreBusy)
+       end,
+cpu_util_diff(NewCpuUtils, OldCpuUtils, [#cpu_util{cpu      = Cpu,
+						   busy     = Busy,
+						   non_busy = NonBusy}
+					 | Acc]);
+
+%% A new cpu appeared
+cpu_util_diff([#cpu_util{cpu = NC}|_] = New,
+	  [#cpu_util{cpu = OC}|_] = Old,
+	  Acc) when NC < OC ->
+cpu_util_diff(New, [#cpu_util{cpu = NC}|Old], Acc);
+cpu_util_diff([#cpu_util{cpu = NC}|_] = New, [], Acc) ->
+cpu_util_diff(New, [#cpu_util{cpu = NC}], Acc);
+
+%% An old cpu disappeared
+cpu_util_diff([#cpu_util{cpu = NC}|Ns],
+	  [#cpu_util{cpu = OC}|_] = Old,
+	  Acc) when NC > OC ->
+cpu_util_diff(Ns, Old, Acc);
+cpu_util_diff([], _Old, Acc) ->
+cpu_util_diff([], [], Acc).
+
+cpu_util_rel(NewCpuUtils, OldCpuUtils, Detailed, PerCpu) ->
+    cpu_util_rel(cpu_util_diff(NewCpuUtils, OldCpuUtils), Detailed, PerCpu).
+
+%% 
+%% cpu_util_rel/3 takes a difference list of cpu_util records as first
+%% argument, a boolean determining if the result should be detailed as
+%% second argument, and a boolean determining if the result should be
+%% per cpu as third argument. The first argument (the difference list)
+%% has to be sorted on cpu index in descending order.
+%% 
+cpu_util_rel(CUDiff, false, false) ->
+    {B, T} = lists:foldl(fun (#cpu_util{busy     = BusyList,
+					non_busy = NonBusyList},
+			      {BusyAcc, TotAcc}) ->
+				 Busy  = state_list_sum(BusyList),
+				 NonBusy = state_list_sum(NonBusyList),
+				 {BusyAcc+Busy, TotAcc+Busy+NonBusy}
+			 end,
+			 {0, 0},
+			 CUDiff),
+    BRel = B/T*100,
+    {all, BRel, 100-BRel, []};
+cpu_util_rel(CUDiff, true, false) ->
+    cpu_util_rel_det(CUDiff, #cpu_util{cpu = [], busy = [], non_busy = []}); 
+cpu_util_rel(CUDiff, false, true) ->
+    cpu_util_rel_pcpu(CUDiff, []);
+cpu_util_rel(CUDiff, true, true) ->
+    cpu_util_rel_det_pcpu(CUDiff, []).
+
+cpu_util_rel_pcpu([], Acc) ->
+    Acc;
+cpu_util_rel_pcpu([#cpu_util{cpu      = C,
+			     busy     = BusyList,
+			     non_busy = NonBusyList} | Rest], Acc) ->
+    Busy  = state_list_sum(BusyList),
+    NonBusy = state_list_sum(NonBusyList),
+    Tot = Busy + NonBusy,
+    cpu_util_rel_pcpu(Rest, [{C, Busy/Tot*100, NonBusy/Tot*100, []}|Acc]).
+
+cpu_util_rel_det([], #cpu_util{cpu      = CpuAcc,
+			       busy     = BusyAcc,
+			       non_busy = NonBusyAcc}) ->
+    Total = state_list_sum(BusyAcc) + state_list_sum(NonBusyAcc),
+    {CpuAcc, mk_rel_states(BusyAcc,Total), mk_rel_states(NonBusyAcc,Total), []};
+cpu_util_rel_det([#cpu_util{cpu      = Cpu,
+			    busy     = Busy,
+			    non_busy = NonBusy} | Rest],
+		 #cpu_util{cpu      = CpuAcc,
+			   busy     = BusyAcc,
+			   non_busy = NonBusyAcc}) ->
+    cpu_util_rel_det(Rest, #cpu_util{cpu      = [Cpu|CpuAcc],
+				     busy     = state_list_add(Busy,
+							       BusyAcc),
+				     non_busy = state_list_add(NonBusy,
+							       NonBusyAcc)}).
+
+cpu_util_rel_det_pcpu([], Acc) ->
+    Acc;
+cpu_util_rel_det_pcpu([#cpu_util{cpu      = Cpu,
+				 busy     = Busy,
+				 non_busy = NonBusy}| Rest], Acc) ->
+    Total = state_list_sum(Busy) + state_list_sum(NonBusy),
+    cpu_util_rel_det_pcpu(Rest,
+			  [{Cpu,
+			    mk_rel_states(Busy, Total),
+			    mk_rel_states(NonBusy, Total),
+			    []} | Acc]).
+
+mk_rel_states(States, Total) ->
+    lists:map(fun ({State, Value}) -> {State, 100*Value/Total} end, States).
+
+state_list_sum(StateList) ->
+    lists:foldl(fun ({_, X}, Acc) -> Acc+X end, 0, StateList).
+
+state_list_diff([],[]) ->
+    {[], false};
+state_list_diff([{State,ValueNew}|RestNew], []) ->
+    state_list_diff([{State, ValueNew} | RestNew], [{State, 0}]);
+state_list_diff([{State,ValueNew}|RestNew], [{State,ValueOld}|RestOld]) ->
+    ValDiff = val_diff(State, ValueNew, ValueOld),
+    {RestStateDiff, FoundDiff} = state_list_diff(RestNew, RestOld),
+    {[{State, ValDiff} | RestStateDiff], FoundDiff orelse ValDiff /= 0}.
+
+state_list_add([],[]) ->
+    [];
+state_list_add([{State, ValueA}|RestA], []) ->
+    [{State, ValueA} | state_list_add(RestA, [])];
+state_list_add([{State, ValueA} | RestA], [{State, ValueB} | RestB]) ->
+    [{State, ValueA + ValueB} | state_list_add(RestA, RestB)].
+
+one_step_backwards(State, New, Old) ->
+    case os:type() of
+	{unix, linux} ->
+	    %% This should never happen! But values sometimes takes a step
+	    %% backwards on linux. We'll ignore it as long as it's only
+	    %% one step...
+	    0;
+	_ ->
+	    val_diff2(State, New, Old)
+    end.
+
+val_diff(State, New, Old) when New == Old - 1 ->
+    one_step_backwards(State, New, Old);
+val_diff(State, ?MAX_UINT32, 0) ->
+    one_step_backwards(State, ?MAX_UINT32, 0);
+val_diff(State, New, Old) ->
+    val_diff2(State, New, Old).
+
+val_diff2(State, New, Old) when New > ?MAX_UINT32; Old > ?MAX_UINT32 ->
+    %% We obviously got uints > 32 bits
+    ensure_positive_diff(State, New - Old);
+val_diff2(State, New, Old) when New < Old ->
+    %% 32-bit integer wrapped
+    ensure_positive_diff(State, (?MAX_UINT32 + 1) + New - Old);
+val_diff2(_State, New, Old) ->
+    New - Old.
+
+ensure_positive_diff(_State, Diff) when Diff >= 0 ->
+    Diff;
+ensure_positive_diff(State, Diff) ->
+    throw({error, {negative_diff, State, Diff}}).
+%%----------------------------------------------------------------------
+%% END: tainted internal functions 
+%%----------------------------------------------------------------------
+
+%%----------------------------------------------------------------------
+%% cpu_sup measurement server wrapper
+%%----------------------------------------------------------------------
+
+measurement_server_call(Pid, Request) ->
+    Timeout = 5000,
+    Pid ! {self(), Request},
+    receive
+	{data, Data} -> Data
+    after Timeout -> 
+	{error, timeout}
+    end.
+
+measurement_server_restart(Pid) ->
+    exit(Pid, kill),
+    measurement_server_start().
+
+measurement_server_start() ->
+    spawn(fun() -> measurement_server_init() end).
+
+measurement_server_init() ->
+    process_flag(trap_exit, true),
+    OS = os:type(),
+    Server = case OS of
+	{unix, Flavor} when Flavor==sunos;
+			    Flavor==linux ->
+	    port_server_start();
+	{unix, Flavor} when Flavor==darwin;
+			    Flavor==freebsd;
+			    Flavor==dragonfly;
+			    Flavor==openbsd;
+			    Flavor==irix64;
+			    Flavor==irix ->
+	    not_used;
+	_ ->
+	    exit({unsupported_os, OS})
+    end, 
+    measurement_server_loop(#internal{port=Server, os_type=OS}).
+
+measurement_server_loop(State) ->
+    receive
+	{_, quit} ->
+	    State#internal.port ! {self(), ?quit}, 
+	    ok;
+	{'DOWN',Monitor,process,_,_} ->
+	    measurement_server_loop(State#internal{ util = lists:keydelete(
+		Monitor,
+		2,
+		State#internal.util)});
+	{Pid, {?util, D, PC, Client}} ->
+	    {Monitor, OldCpuUtil, Utils2} = case keysearchdelete(Client, 1, State#internal.util) of
+		{{value, {Client, Mon, U}}, Us} -> {Mon, U, Us};
+		{false, Us} -> {erlang:monitor(process, Client), [], Us}
+	    end,
+	    try get_util_measurement(?util, State) of
+		NewCpuUtil ->
+		    Result = cpu_util_rel(NewCpuUtil, OldCpuUtil, D, PC),
+		    Pid ! {data, Result},
+	   	    measurement_server_loop(State#internal{util=[{Client,Monitor,NewCpuUtil}|Utils2]})
+	    catch
+		Error -> 
+		    Pid ! {error, Error},
+		    measurement_server_loop(State)
+	    end;
+	{Pid, Request} ->
+	    try get_uint32_measurement(Request, State) of
+		Result -> Pid ! {data, Result}
+	    catch
+		Error -> Pid ! {error, Error}
+	    end,
+	    measurement_server_loop(State);
+        {'EXIT', Pid, _n} when State#internal.port == Pid -> 
+	    measurement_server_loop(State#internal{port = port_server_start()});
+	_Other ->
+	    measurement_server_loop(State)
+    end.
+
+%%----------------------------------------------------------------------
+%% cpu_sup port program server wrapper
+%%----------------------------------------------------------------------
+
+port_server_call(Pid, Command) ->
+    Pid ! {self(), Command},
+    receive
+	{Pid, {data, Result}} -> Result;
+	{Pid, {error, Reason}} -> {error, Reason}
+    end.
+    
+port_server_start() ->
+    Timeout = 6000,
+    Pid = spawn_link(fun() -> port_server_init(Timeout) end),
+    Pid ! {self(), ?ping},
+    receive
+	{Pid, {data,4711}} -> Pid;
+	{error,Reason} -> {error, Reason}
+    after Timeout -> 
+	{error, timeout}
+    end.
+
+port_server_init(Timeout) ->
+    Port = start_portprogram(),
+    port_server_loop(Port, Timeout).
+
+port_server_loop(Port, Timeout) ->
+    receive
+
+	% Adjust timeout
+	{Pid, {timeout, Timeout}} ->
+	    Pid ! {data, Timeout},
+	    port_server_loop(Port, Timeout);
+	% Number of processors
+        {Pid, ?nprocs} ->
+	    port_command(Port, ?nprocs),
+	    Result = port_receive_uint32(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+
+	% Average load for the past minute
+        {Pid, ?avg1} ->
+	    port_command(Port, ?avg1),
+	    Result = port_receive_uint32(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+
+	% Average load for the past five minutes
+        {Pid, ?avg5} ->
+	    port_command(Port, ?avg5),
+	    Result = port_receive_uint32(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+	
+	% Average load for the past 15 minutes
+        {Pid, ?avg15} ->
+	    port_command(Port, ?avg15),
+	    Result = port_receive_uint32(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+
+	{Pid, ?util} ->
+	    port_command(Port, ?util),
+	    Result = port_receive_util(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+
+	% Port ping
+	{Pid, ?ping} ->
+	    port_command(Port, ?ping),
+	    Result = port_receive_uint32(Port, Timeout),
+	    Pid ! {self(), {data, Result}},
+	    port_server_loop(Port, Timeout);
+
+	% Close port and this server
+	{Pid, ?quit} ->
+	    port_command(Port, ?quit),
+	    port_close(Port),
+	    Pid ! {self(), {data, quit}},
+	    ok;
+
+	% Ignore other commands
+	_ -> port_server_loop(Port, Timeout)
+    end.	
+
+port_receive_uint32( Port,  Timeout) -> port_receive_uint32(Port, Timeout, []).
+port_receive_uint32(_Port, _Timeout, [D3,D2,D1,D0]) -> ?INT32(D3,D2,D1,D0);
+port_receive_uint32(_Port, _Timeout, [_,_,_,_ | G]) -> exit({port_garbage, G});
+port_receive_uint32(Port, Timeout, D) ->
+    receive
+	{'EXIT', Port, Reason} -> exit({port_exit, Reason});
+	{Port, {data, ND}} -> port_receive_uint32(Port, Timeout, D ++ ND)
+    after Timeout -> exit(timeout_uint32) end.
+
+port_receive_util(Port, Timeout) ->
+    receive
+	{Port, {data, [ NP3,NP2,NP1,NP0,  % Number of processors
+		        NE3,NE2,NE1,NE0   % Number of entries per processor
+		      | CpuData]}} ->
+	    port_receive_cpu_util( ?INT32(NP3,NP2,NP1,NP0),
+				   ?INT32(NE3,NE2,NE1,NE0),
+				   CpuData, []);
+	{'EXIT', Port, Reason} -> exit({port_exit, Reason})
+    after Timeout -> exit(timeout_util) end.
+
+% per processor receive loop
+port_receive_cpu_util(0, _NE, [], CpuList) ->
+    % Return in ascending cpu_id order
+    lists:reverse(CpuList); 
+port_receive_cpu_util(0, _NE, Garbage, _) ->
+    exit( {port_garbage, Garbage});
+port_receive_cpu_util(NP, NE, CpuData, CpuList) ->
+    {CpuUtil, Rest} = port_receive_cpu_util_entries(NE, #cpu_util{}, CpuData),
+    port_receive_cpu_util(NP - 1, NE, Rest, [ CpuUtil | CpuList]).
+
+% per entry receive loop
+port_receive_cpu_util_entries(0, CU, Rest) ->
+    {CU, Rest};
+port_receive_cpu_util_entries(NE, CU,
+	[ CID3, CID2, CID1, CID0,
+	  Val3, Val2, Val1, Val0 |
+	  CpuData]) ->
+
+    TagId = ?INT32(CID3,CID2,CID1,CID0),
+    Value = ?INT32(Val3,Val2,Val1,Val0),
+
+    % Conversions from integers to atoms
+    case TagId of
+	?cu_cpu_id ->
+	    NewCU = CU#cpu_util{cpu = Value},
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_user ->
+	    NewCU = CU#cpu_util{
+		busy     = [{user, Value} | CU#cpu_util.busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_nice_user ->
+	    NewCU = CU#cpu_util{
+		busy     = [{nice_user, Value} | CU#cpu_util.busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_kernel ->
+	    NewCU = CU#cpu_util{
+		busy     = [{kernel, Value} | CU#cpu_util.busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_io_wait ->
+	    NewCU = CU#cpu_util{
+		non_busy = [{wait, Value} | CU#cpu_util.non_busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_idle ->	
+	    NewCU = CU#cpu_util{
+		non_busy = [{idle, Value} | CU#cpu_util.non_busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_hard_irq -> 	
+	    NewCU = CU#cpu_util{
+		busy =     [{hard_irq, Value} | CU#cpu_util.busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_soft_irq ->
+	    NewCU = CU#cpu_util{
+		busy =     [{soft_irq, Value} | CU#cpu_util.busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+	?cu_steal ->
+	    NewCU = CU#cpu_util{
+		non_busy = [{steal, Value} | CU#cpu_util.non_busy] },
+    	    port_receive_cpu_util_entries(NE - 1, NewCU, CpuData);
+    	Unhandled ->
+	    exit({unexpected_type_id, Unhandled})
+    end;
+port_receive_cpu_util_entries(_, _, Data) -> 
+     exit({data_mismatch, Data}).
+
+start_portprogram() ->
+    Command = filename:join([code:priv_dir(os_mon), "bin", "cpu_sup"]),
+    Port = open_port({spawn, Command}, [stream]),
+    port_command(Port, ?ping),
+    4711 = port_receive_uint32(Port, 5000),
+    Port.
diff --git a/lib/os_mon/src/disksup.erl b/lib/os_mon/src/disksup.erl
new file mode 100644
index 0000000000..3340f7ee72
--- /dev/null
+++ b/lib/os_mon/src/disksup.erl
@@ -0,0 +1,369 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+-module(disksup).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/0]).
+-export([get_disk_data/0,
+	 get_check_interval/0, set_check_interval/1,
+	 get_almost_full_threshold/0, set_almost_full_threshold/1]).
+-export([dummy_reply/1, param_type/2, param_default/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+%% Other exports
+-export([format_status/2]).
+
+-record(state, {threshold, timeout, os, diskdata = [],port}).
+
+%%----------------------------------------------------------------------
+%% API
+%%----------------------------------------------------------------------
+
+start_link() ->
+    gen_server:start_link({local, disksup}, disksup, [], []).
+
+get_disk_data() ->
+    os_mon:call(disksup, get_disk_data).
+
+get_check_interval() ->
+    os_mon:call(disksup, get_check_interval).
+set_check_interval(Minutes) ->
+    case param_type(disk_space_check_interval, Minutes) of
+	true ->
+	    os_mon:call(disksup, {set_check_interval, Minutes});
+	false ->
+	    erlang:error(badarg)
+    end.
+
+get_almost_full_threshold() ->
+    os_mon:call(disksup, get_almost_full_threshold).
+set_almost_full_threshold(Float) ->
+    case param_type(disk_almost_full_threshold, Float) of
+	true ->
+	    os_mon:call(disksup, {set_almost_full_threshold, Float});
+	false ->
+	    erlang:error(badarg)
+    end.
+
+dummy_reply(get_disk_data) ->
+    [{"none", 0, 0}];
+dummy_reply(get_check_interval) ->
+    minutes_to_ms(os_mon:get_env(disksup, disk_space_check_interval));
+dummy_reply({set_check_interval, _}) ->
+    ok;
+dummy_reply(get_almost_full_threshold) ->
+    round(os_mon:get_env(disksup, disk_almost_full_threshold) * 100);
+dummy_reply({set_almost_full_threshold, _}) ->
+    ok.
+
+param_type(disk_space_check_interval, Val) when is_integer(Val),
+						Val>=1 -> true;
+param_type(disk_almost_full_threshold, Val) when is_number(Val),
+						 0=<Val,
+						 Val=<1 -> true;
+param_type(_Param, _Val) -> false.
+
+param_default(disk_space_check_interval) -> 30;
+param_default(disk_almost_full_threshold) -> 0.80.
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+init([]) ->  
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+
+    OS = get_os(),
+    Port = case OS of
+		{unix, Flavor} when Flavor==sunos4;
+				    Flavor==solaris;
+				    Flavor==freebsd;
+				    Flavor==dragonfly;
+				    Flavor==darwin;
+				    Flavor==linux;
+				    Flavor==openbsd;
+				    Flavor==irix64;
+				    Flavor==irix ->
+		   start_portprogram();
+	       {win32, _OSname} ->
+		   not_used;
+	       _ ->
+		   exit({unsupported_os, OS})
+	   end,
+
+    %% Read the values of some configuration parameters
+    Threshold = os_mon:get_env(disksup, disk_almost_full_threshold),
+    Timeout = os_mon:get_env(disksup, disk_space_check_interval),
+
+    %% Initiation first disk check
+    self() ! timeout,
+
+    {ok, #state{port=Port, os=OS,
+		threshold=round(Threshold*100),
+		timeout=minutes_to_ms(Timeout)}}.
+
+handle_call(get_disk_data, _From, State) ->
+    {reply, State#state.diskdata, State};
+
+handle_call(get_check_interval, _From, State) ->
+    {reply, State#state.timeout, State};
+handle_call({set_check_interval, Minutes}, _From, State) ->
+    Timeout = minutes_to_ms(Minutes),
+    {reply, ok, State#state{timeout=Timeout}};
+
+handle_call(get_almost_full_threshold, _From, State) ->
+    {reply, State#state.threshold, State};
+handle_call({set_almost_full_threshold, Float}, _From, State) ->
+    Threshold = round(Float * 100),
+    {reply, ok, State#state{threshold=Threshold}};
+
+handle_call({set_threshold, Threshold}, _From, State) -> % test only
+    {reply, ok, State#state{threshold=Threshold}}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info(timeout, State) ->
+    NewDiskData = check_disk_space(State#state.os, State#state.port,
+				   State#state.threshold),
+    timer:send_after(State#state.timeout, timeout),
+    {noreply, State#state{diskdata = NewDiskData}};
+handle_info({'EXIT', _Port, Reason}, State) ->
+    {stop, {port_died, Reason}, State#state{port=not_used}};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, State) ->
+    clear_alarms(),
+    case State#state.port of
+	not_used ->
+	    ok;
+	Port ->
+	    port_close(Port)
+    end,
+    ok.
+
+%% os_mon-2.0.1
+%% For live downgrade to/upgrade from os_mon-1.8[.1]
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+	    State = case PrevState#state.port of
+			not_used -> PrevState#state{port=noport};
+			_ -> PrevState
+		    end,
+	    {ok, State};
+
+	%% Upgrade to this version
+	_Vsn ->
+	    State = case PrevState#state.port of
+			noport -> PrevState#state{port=not_used};
+			_ -> PrevState
+		    end,
+	    {ok, State}
+    end;
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% Other exports
+%%----------------------------------------------------------------------
+
+format_status(_Opt, [_PDict, #state{os = OS, threshold = Threshold,
+				    timeout = Timeout,
+				    diskdata = DiskData}]) ->
+    [{data, [{"OS", OS},
+	     {"Timeout", Timeout},
+	     {"Threshold", Threshold},
+	     {"DiskData", DiskData}]}].
+
+%%----------------------------------------------------------------------
+%% Internal functions
+%%----------------------------------------------------------------------
+
+get_os() ->
+    case os:type() of
+	{unix, sunos} ->
+	    case os:version() of
+		{5,_,_} -> {unix, solaris};
+		{4,_,_} -> {unix, sunos4};
+		V -> exit({unknown_os_version, V})
+	    end;
+        {unix, irix64} -> {unix, irix};
+	OS ->
+	    OS
+    end.
+
+%%--Port handling functions---------------------------------------------
+
+start_portprogram() -> 
+    open_port({spawn, "sh -s disksup 2>&1"}, [stream]).
+
+my_cmd(Cmd0, Port) ->
+    %% Insert a new line after the command, in case the command
+    %% contains a comment character
+    Cmd = io_lib:format("(~s\n) </dev/null; echo  \"\^M\"\n", [Cmd0]),
+    Port ! {self(), {command, [Cmd, 10]}},
+    get_reply(Port, []).
+
+get_reply(Port, O) ->
+    receive 
+        {Port, {data, N}} -> 
+            case newline(N, O) of
+                {ok, Str} -> Str;
+                {more, Acc} -> get_reply(Port, Acc)
+            end;
+        {'EXIT', Port, Reason} ->
+	    exit({port_died, Reason})
+    end.
+
+newline([13|_], B) -> {ok, lists:reverse(B)};
+newline([H|T], B) -> newline(T, [H|B]);
+newline([], B) -> {more, B}.
+
+%%--Check disk space----------------------------------------------------
+
+check_disk_space({win32,_}, not_used, Threshold) ->
+    Result = os_mon_sysinfo:get_disk_info(),
+    check_disks_win32(Result, Threshold);
+check_disk_space({unix, solaris}, Port, Threshold) ->
+    Result = my_cmd("/usr/bin/df -lk", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, irix}, Port, Threshold) ->
+    Result = my_cmd("/usr/sbin/df -lk",Port),
+    check_disks_irix(skip_to_eol(Result), Threshold);
+check_disk_space({unix, linux}, Port, Threshold) ->
+    Result = my_cmd("/bin/df -lk", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, dragonfly}, Port, Threshold) ->
+    Result = my_cmd("/bin/df -k -t ufs,hammer", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, freebsd}, Port, Threshold) ->
+    Result = my_cmd("/bin/df -k -t ufs", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, openbsd}, Port, Threshold) ->
+    Result = my_cmd("/bin/df -k -t ffs", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, sunos4}, Port, Threshold) ->
+    Result = my_cmd("df", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold);
+check_disk_space({unix, darwin}, Port, Threshold) ->
+    Result = my_cmd("/bin/df -k -t ufs,hfs", Port),
+    check_disks_solaris(skip_to_eol(Result), Threshold).
+
+% This code works for Linux and FreeBSD as well
+check_disks_solaris("", _Threshold) ->
+    [];
+check_disks_solaris("\n", _Threshold) ->
+    [];
+check_disks_solaris(Str, Threshold) ->
+    case io_lib:fread("~s~d~d~d~d%~s", Str) of
+	{ok, [_FS, KB, _Used, _Avail, Cap, MntOn], RestStr} ->
+	    if
+		Cap >= Threshold ->
+		    set_alarm({disk_almost_full, MntOn}, []);
+		true ->
+		    clear_alarm({disk_almost_full, MntOn})
+	    end,
+	    [{MntOn, KB, Cap} |
+	     check_disks_solaris(RestStr, Threshold)];
+	_Other ->
+	    check_disks_solaris(skip_to_eol(Str),Threshold)
+    end.
+
+%% Irix: like Linux with an extra FS type column and no '%'.
+check_disks_irix("", _Threshold) -> [];
+check_disks_irix("\n", _Threshold) -> [];
+check_disks_irix(Str, Threshold) ->
+    case io_lib:fread("~s~s~d~d~d~d~s", Str) of
+	{ok, [_FS, _FSType, KB, _Used, _Avail, Cap, MntOn], RestStr} ->
+	    if Cap >= Threshold -> set_alarm({disk_almost_full, MntOn}, []);
+	       true             -> clear_alarm({disk_almost_full, MntOn}) end,
+	    [{MntOn, KB, Cap} | check_disks_irix(RestStr, Threshold)];
+	_Other ->
+	    check_disks_irix(skip_to_eol(Str),Threshold)
+    end.
+
+check_disks_win32([], _Threshold) ->
+    [];
+check_disks_win32([H|T], Threshold) ->
+    case io_lib:fread("~s~s~d~d~d", H) of
+	{ok, [Drive,"DRIVE_FIXED",BAvail,BTot,_TotFree], _RestStr} ->
+	    Cap = trunc((BTot-BAvail) / BTot * 100),
+	    if
+		 Cap >= Threshold ->
+		    set_alarm({disk_almost_full, Drive}, []);
+		true ->
+		    clear_alarm({disk_almost_full, Drive})
+	    end,
+	    [{Drive, BTot div 1024, Cap} |
+	     check_disks_win32(T, Threshold)]; % Return Total Capacity in Kbytes
+	{ok,_,_RestStr} ->
+	    check_disks_win32(T,Threshold);
+	_Other ->
+	    []
+    end.
+
+%%--Alarm handling------------------------------------------------------
+
+set_alarm(AlarmId, AlarmDescr) ->
+    case get(AlarmId) of
+	set ->
+	    ok;
+	undefined ->
+	    alarm_handler:set_alarm({AlarmId, AlarmDescr}),
+	    put(AlarmId, set)
+    end.
+
+clear_alarm(AlarmId) ->
+    case get(AlarmId) of
+	set ->
+	    alarm_handler:clear_alarm(AlarmId),
+	    erase(AlarmId);
+	undefined ->
+	    ok
+    end.
+
+clear_alarms() ->
+    lists:foreach(fun({{disk_almost_full, _MntOn} = AlarmId, set}) ->
+			  alarm_handler:clear_alarm(AlarmId);
+		     (_Other) ->
+			  ignore
+		  end,
+		  get()).
+
+%%--Auxiliary-----------------------------------------------------------
+
+%% Type conversion
+minutes_to_ms(Minutes) ->
+    trunc(60000*Minutes).
+
+skip_to_eol([]) ->
+    [];
+skip_to_eol([$\n | T]) ->
+    T;
+skip_to_eol([_ | T]) ->
+    skip_to_eol(T).
diff --git a/lib/os_mon/src/memsup.erl b/lib/os_mon/src/memsup.erl
new file mode 100644
index 0000000000..822e1f939c
--- /dev/null
+++ b/lib/os_mon/src/memsup.erl
@@ -0,0 +1,1022 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+-module(memsup).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/0]). % for supervisor
+-export([get_memory_data/0, get_system_memory_data/0,
+	 get_check_interval/0, set_check_interval/1,
+	 get_procmem_high_watermark/0, set_procmem_high_watermark/1,
+	 get_sysmem_high_watermark/0, set_sysmem_high_watermark/1,
+	 get_helper_timeout/0, set_helper_timeout/1,
+	 get_os_wordsize/0]).
+-export([dummy_reply/1, param_type/2, param_default/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+%% Other exports
+-export([format_status/2]).
+
+-include("memsup.hrl").
+
+-record(state,
+	{os,                  % {OSfamily,OSname} | OSfamily
+	 port_mode,           % bool()
+
+	 mem_usage,           % undefined | {Alloc, Total}
+	 worst_mem_user,      % undefined | {Pid, Alloc}
+
+	 sys_only,            % bool()  memsup_system_only
+	 timeout,             % int()   memory_check_interval, ms
+	 helper_timeout,      % int()   memsup_helper_timeout, ms
+	 sys_mem_watermark,   % float() system_memory_high_watermark, %
+	 proc_mem_watermark,  % float() process_memory_high_watermark, %
+
+	 pid,                 % undefined | pid()
+	 wd_timer,            % undefined | TimerRef
+	 ext_wd_timer,        % undefined | TimerRef
+	 pending = [],        % [reg | {reg,From} | {ext,From}]
+	 ext_pending = []     % [{ext,From}]
+	}).
+
+%%----------------------------------------------------------------------
+%% API
+%%----------------------------------------------------------------------
+
+start_link() ->
+    gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).
+
+get_os_wordsize() ->
+    os_mon:call(memsup, get_os_wordsize, infinity).
+
+get_memory_data() ->
+    os_mon:call(memsup, get_memory_data, infinity).
+
+get_system_memory_data() ->
+    os_mon:call(memsup, get_system_memory_data, infinity).
+
+get_check_interval() ->
+    os_mon:call(memsup, get_check_interval, infinity).
+set_check_interval(Minutes) ->
+    case param_type(memory_check_interval, Minutes) of
+	true ->
+	    MS = minutes_to_ms(Minutes), % for backwards compatibility
+	    os_mon:call(memsup, {set_check_interval, MS}, infinity);
+	false ->
+	    erlang:error(badarg)
+    end.
+
+get_procmem_high_watermark() ->
+    os_mon:call(memsup, get_procmem_high_watermark, infinity).
+set_procmem_high_watermark(Float) ->
+    case param_type(process_memory_high_watermark, Float) of
+	true ->
+	    os_mon:call(memsup, {set_procmem_high_watermark, Float},
+			infinity);
+	false ->
+	    erlang:error(badarg)
+    end.
+
+get_sysmem_high_watermark() ->
+    os_mon:call(memsup, get_sysmem_high_watermark, infinity).
+set_sysmem_high_watermark(Float) ->
+    case param_type(system_memory_high_watermark, Float) of
+	true ->
+	    os_mon:call(memsup, {set_sysmem_high_watermark, Float},
+			infinity);
+	false ->
+	    erlang:error(badarg)
+    end.
+
+get_helper_timeout() ->
+    os_mon:call(memsup, get_helper_timeout, infinity).
+set_helper_timeout(Seconds) ->
+    case param_type(memsup_helper_timeout, Seconds) of
+	true ->
+	    os_mon:call(memsup, {set_helper_timeout, Seconds});
+	false ->
+	    erlang:error(badarg)
+    end.
+
+dummy_reply(get_memory_data) ->
+    dummy_reply(get_memory_data,
+		os_mon:get_env(memsup, memsup_system_only));
+dummy_reply(get_system_memory_data) ->
+    [];
+dummy_reply(get_os_wordsize) ->
+    0;
+dummy_reply(get_check_interval) ->
+    minutes_to_ms(os_mon:get_env(memsup, memory_check_interval));
+dummy_reply({set_check_interval, _}) ->
+    ok;
+dummy_reply(get_procmem_high_watermark) ->
+    trunc(100 * os_mon:get_env(memsup, process_memory_high_watermark));
+dummy_reply({set_procmem_high_watermark, _}) ->
+    ok;
+dummy_reply(get_sysmem_high_watermark) ->
+    trunc(100 * os_mon:get_env(memsup, system_memory_high_watermark));
+dummy_reply({set_sysmem_high_watermark, _}) ->
+    ok;
+dummy_reply(get_helper_timeout) ->
+    os_mon:get_env(memsup, memsup_helper_timeout);
+dummy_reply({set_helper_timeout, _}) ->
+    ok.
+dummy_reply(get_memory_data, true) ->
+    {0,0,undefined};
+dummy_reply(get_memory_data, false) ->
+    {0,0,{self(),0}}.
+
+param_type(memsup_system_only, Val) when Val==true; Val==false -> true;
+param_type(memory_check_interval, Val) when is_integer(Val),
+                                            Val>0 -> true;
+param_type(memsup_helper_timeout, Val) when is_integer(Val),
+                                            Val>0 -> true;
+param_type(system_memory_high_watermark, Val) when is_number(Val),
+						   0=<Val,
+						   Val=<1 -> true;
+param_type(process_memory_high_watermark, Val) when is_number(Val),
+						    0=<Val,
+						    Val=<1 -> true;
+param_type(_Param, _Val) -> false.
+
+param_default(memsup_system_only) -> false;
+param_default(memory_check_interval) -> 1;
+param_default(memsup_helper_timeout) -> 30;
+param_default(system_memory_high_watermark) -> 0.80;
+param_default(process_memory_high_watermark) -> 0.05.
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+init([]) ->
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+
+    OS = os:type(),
+    PortMode = case OS of
+		   {unix, darwin} -> false;
+		   {unix, freebsd} -> false;
+		   % Linux supports this.
+		   {unix, linux} -> true;
+		   {unix, openbsd} -> true;
+		   {unix, irix64} -> true;
+		   {unix, irix} -> true;
+		   {unix, sunos} -> true;
+		   {win32, _OSname} -> false;
+		   vxworks -> true;
+		   _ ->
+		       exit({unsupported_os, OS})
+	       end,
+    Pid = if
+	      PortMode ->
+		  spawn_link(fun() -> port_init() end);
+	      not PortMode ->
+		  undefined
+	  end,
+
+    %% Read the values of some configuration parameters
+    SysOnly = os_mon:get_env(memsup, memsup_system_only),
+    Timeout = os_mon:get_env(memsup, memory_check_interval),
+    HelperTimeout = os_mon:get_env(memsup, memsup_helper_timeout),
+    SysMem = os_mon:get_env(memsup, system_memory_high_watermark),
+    ProcMem = os_mon:get_env(memsup, process_memory_high_watermark),
+
+    %% Initiate first data collection
+    self() ! time_to_collect,
+
+    {ok, #state{os=OS, port_mode=PortMode,
+
+		sys_only           = SysOnly,
+		timeout            = minutes_to_ms(Timeout),
+		helper_timeout     = sec_to_ms(HelperTimeout),
+		sys_mem_watermark  = SysMem,
+		proc_mem_watermark = ProcMem,
+
+		pid=Pid}}.
+
+handle_call(get_os_wordsize, _From, State) ->
+    Wordsize = get_os_wordsize(State#state.os),
+    {reply, Wordsize, State};
+handle_call(get_memory_data, From, State) ->
+    %% Return result of latest memory check
+    case State#state.mem_usage of
+	{Alloc, Total} ->
+	    Worst = State#state.worst_mem_user,
+	    {reply, {Total, Alloc, Worst}, State};
+	
+	%% Special case: get_memory_data called before any memory data
+	%% has been collected
+	undefined ->
+	    case State#state.wd_timer of
+		undefined ->
+		    WDTimer = erlang:send_after(State#state.timeout,
+						self(),
+						reg_collection_timeout),
+		    Pending = [{reg,From}],
+		    if
+			State#state.port_mode ->
+			    State#state.pid ! {self(), collect_sys},
+			    {noreply, State#state{wd_timer=WDTimer,
+						  pending=Pending}};
+			true ->
+			    OS = State#state.os,
+			    Self = self(),
+			    Pid = spawn_link(fun() ->
+						     MU = get_memory_usage(OS),
+						     Self ! {collected_sys,MU}
+					     end),
+			    {noreply, State#state{pid=Pid,
+						  wd_timer=WDTimer,
+						  pending=Pending}}
+		    end;
+		_TimerRef ->
+		    Pending = [{reg,From} | State#state.pending],
+		    {noreply, State#state{pending=Pending}}
+	    end
+    end;
+
+handle_call(get_system_memory_data,From,#state{port_mode=true}=State) ->
+    %% When using a port, the extensive memory collection is slightly
+    %% different than a regular one
+    case State#state.ext_wd_timer of
+	undefined ->
+	    WDTimer = erlang:send_after(State#state.helper_timeout,
+					self(),
+					ext_collection_timeout),
+	    State#state.pid ! {self(), collect_ext_sys},
+	    {noreply, State#state{ext_wd_timer=WDTimer,
+				  ext_pending=[{ext,From}]}};
+	_TimerRef ->
+	    Pending = [{ext,From} | State#state.ext_pending],
+	    {noreply, State#state{ext_pending=Pending}}
+    end;
+handle_call(get_system_memory_data, From, State) ->
+    %% When not using a port, the regular memory collection is used
+    %% for extensive memory data as well
+    case State#state.wd_timer of
+	undefined ->
+	    WDTimer = erlang:send_after(State#state.helper_timeout,
+					self(),
+					reg_collection_timeout),
+	    OS = State#state.os,
+	    Self = self(),
+	    Pid = spawn_link(fun() ->
+				     MemUsage = get_memory_usage(OS),
+				     Self ! {collected_sys, MemUsage}
+			     end),
+	    {noreply, State#state{pid=Pid, wd_timer=WDTimer,
+				  pending=[{ext,From}]}};
+	_TimerRef ->
+	    Pending = [{ext,From} | State#state.pending],
+	    {noreply, State#state{pending=Pending}}
+    end;
+
+handle_call(get_check_interval, _From, State) ->
+    {reply, State#state.timeout, State};
+handle_call({set_check_interval, MS}, _From, State) ->
+    {reply, ok, State#state{timeout=MS}};
+
+handle_call(get_procmem_high_watermark, _From, State) ->
+    {reply, trunc(100 * State#state.proc_mem_watermark), State};
+handle_call({set_procmem_high_watermark, Float}, _From, State) ->
+    {reply, ok, State#state{proc_mem_watermark=Float}};
+
+handle_call(get_sysmem_high_watermark, _From, State) ->
+    {reply, trunc(100 * State#state.sys_mem_watermark), State};
+handle_call({set_sysmem_high_watermark, Float}, _From, State) ->
+    {reply, ok, State#state{sys_mem_watermark=Float}};
+
+handle_call(get_helper_timeout, _From, State) ->
+    {reply, ms_to_sec(State#state.helper_timeout), State};
+handle_call({set_helper_timeout, Seconds}, _From, State) ->
+    {reply, ok, State#state{helper_timeout=sec_to_ms(Seconds)}};
+
+%% The following are only for test purposes (whitebox testing).
+handle_call({set_sys_hw, HW}, _From, State) ->
+    {reply, ok, State#state{sys_mem_watermark=HW}};
+handle_call({set_pid_hw, HW}, _From, State) ->
+    {reply, ok, State#state{proc_mem_watermark=HW}};
+handle_call(get_state, _From, State) ->
+    {reply, State, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+%% It's time to check memory
+handle_info(time_to_collect, State) ->
+    case State#state.wd_timer of
+	undefined ->
+	    WDTimer = erlang:send_after(State#state.helper_timeout,
+					self(),
+					reg_collection_timeout),
+	    if
+		State#state.port_mode ->
+		    State#state.pid ! {self(), collect_sys},
+		    {noreply, State#state{wd_timer=WDTimer,
+					  pending=[reg]}};
+		true ->
+		    OS = State#state.os,
+		    Self = self(),
+		    Pid = spawn_link(fun() ->
+					     MU = get_memory_usage(OS),
+					     Self ! {collected_sys,MU}
+				     end),
+		    {noreply, State#state{pid=Pid, wd_timer=WDTimer,
+					  pending=[reg]}}
+	    end;
+	_TimerRef ->
+	    {noreply, State#state{pending=[reg|State#state.pending]}}
+    end;
+
+%% Memory data collected
+handle_info({collected_sys, {Alloc,Total}}, State) ->
+
+    %% Cancel watchdog timer (and as a security measure,
+    %% also flush any reg_collection_timeout message)
+    TimeSpent = case erlang:cancel_timer(State#state.wd_timer) of
+		    false ->
+			State#state.helper_timeout;
+		    TimeLeft ->
+			State#state.helper_timeout-TimeLeft
+		end,
+    flush(reg_collection_timeout),
+
+    %% First check if this is the result of a periodic memory check
+    %% and update alarms and State if this is the case
+    State2 =
+	case lists:member(reg, State#state.pending) of
+	    true ->
+
+		%% Check if system alarm should be set/cleared
+		if
+		    Alloc > State#state.sys_mem_watermark*Total ->
+			set_alarm(system_memory_high_watermark, []);
+		    true ->
+			clear_alarm(system_memory_high_watermark)
+		end,
+
+		%% Check if process data should be collected
+		case State#state.sys_only of
+		    false ->
+			{Pid, Bytes} = get_worst_memory_user(),
+			Threshold= State#state.proc_mem_watermark*Total,
+
+			%% Check if process alarm should be set/cleared
+			if
+			    Bytes > Threshold ->
+				set_alarm(process_memory_high_watermark,
+					  Pid);
+			    true ->
+				clear_alarm(process_memory_high_watermark)
+			end,
+			
+			State#state{mem_usage={Alloc, Total},
+				    worst_mem_user={Pid, Bytes}};
+		    true ->
+			State#state{mem_usage={Alloc, Total}}
+		end;
+	    false ->
+		State
+	end,
+
+    %% Then send a reply to all waiting clients, in preserved time order
+    Worst = State2#state.worst_mem_user,
+    SysMemUsage = get_ext_memory_usage(State2#state.os, {Alloc,Total}),
+    reply(State2#state.pending, {Total,Alloc,Worst}, SysMemUsage),
+
+    %% Last, if this was a periodic check, start a timer for the next
+    %% one. New timeout = interval-time spent collecting,
+    case lists:member(reg, State#state.pending) of
+	true ->
+	    Time = case State2#state.timeout - TimeSpent of
+		       MS when MS<0 ->
+			   0;
+		       MS ->
+			   MS
+		   end,
+	    erlang:send_after(Time, self(), time_to_collect);
+	false ->
+	    ignore
+    end,
+    {noreply, State2#state{wd_timer=undefined, pending=[]}};
+handle_info({'EXIT', Pid, normal}, State) when is_pid(Pid) ->
+    %% Temporary pid terminating when job is done
+    {noreply, State};
+
+%% Timeout during data collection
+handle_info(reg_collection_timeout, State) ->
+
+    %% Cancel memory collection (and as a security measure,
+    %% also flush any collected_sys message)
+    if
+	State#state.port_mode -> State#state.pid ! cancel;
+	true -> exit(State#state.pid, cancel)
+    end,
+    flush(collected_sys),
+
+    %% Issue a warning message
+    Str = "OS_MON (memsup) timeout, no data collected~n",
+    error_logger:warning_msg(Str),
+
+    %% Send a dummy reply to all waiting clients, preserving time order
+    reply(State#state.pending,
+	  dummy_reply(get_memory_data, State#state.sys_only),
+	  dummy_reply(get_system_memory_data)),
+
+    %% If it is a periodic check which has timed out, start a timer for
+    %% the next one
+    %% New timeout = interval-helper timeout
+    case lists:member(reg, State#state.pending) of
+	true ->
+	    Time =
+		case State#state.timeout-State#state.helper_timeout of
+		    MS when MS<0 -> 0;
+		    MS -> MS
+		end,
+	    erlang:send_after(Time, self(), time_to_collect);
+	false ->
+	    ignore
+    end,
+    {noreply, State#state{wd_timer=undefined, pending=[]}};
+handle_info({'EXIT', Pid, cancel}, State) when is_pid(Pid) ->
+    %% Temporary pid terminating as ordered
+    {noreply, State};
+
+%% Extensive memory data collected (port_mode==true only)
+handle_info({collected_ext_sys, SysMemUsage}, State) ->
+
+    %% Cancel watchdog timer (and as a security mearure,
+    %% also flush any ext_collection_timeout message)
+    erlang:cancel_timer(State#state.ext_wd_timer),
+    flush(ext_collection_timeout),
+
+    %% Send the reply to all waiting clients, preserving time order
+    reply(State#state.ext_pending, undef, SysMemUsage),
+
+    {noreply, State#state{ext_wd_timer=undefined, ext_pending=[]}};
+
+%% Timeout during ext memory data collection (port_mode==true only)
+handle_info(ext_collection_timeout, State) ->
+
+    %% Cancel memory collection (and as a security measure,
+    %% also flush any collected_ext_sys message)
+    State#state.pid ! ext_cancel,
+    flush(collected_ext_sys),
+
+    %% Issue a warning message
+    Str = "OS_MON (memsup) timeout, no data collected~n",
+    error_logger:warning_msg(Str),
+
+    %% Send a dummy reply to all waiting clients, preserving time order
+    SysMemUsage = dummy_reply(get_system_memory_data),
+    reply(State#state.ext_pending, undef, SysMemUsage),
+
+    {noreply, State#state{ext_wd_timer=undefined, ext_pending=[]}};
+
+%% Error in data collecting (port connected or temporary) process
+handle_info({'EXIT', Pid, Reason}, State) when is_pid(Pid) ->
+    {stop, Reason, State};
+	    
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, State) ->
+    if
+	State#state.port_mode -> State#state.pid ! close;
+	true -> ok
+    end,
+    clear_alarms(),
+    ok.
+
+%% os_mon-2.0.1
+%% For live downgrade to/upgrade from os_mon-1.8[.1] and -2.0
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+
+	    %% Kill the helper process, if there is one,
+	    %% and flush messages from it
+	    case PrevState#state.pid of
+		Pid when is_pid(Pid) ->
+		    unlink(Pid), % to prevent 'EXIT' message
+		    exit(Pid, cancel);
+		undefined -> ignore
+	    end,
+	    flush(collected_sys),
+	    flush(collected_ext_sys),
+
+	    %% Cancel timers, flush timeout messages
+	    %% and send dummy replies to any pending clients
+	    case PrevState#state.wd_timer of
+		undefined ->
+		    ignore;
+		TimerRef1 ->
+		    erlang:cancel_timer(TimerRef1),
+		    SysOnly = PrevState#state.sys_only,
+		    MemUsage = dummy_reply(get_memory_data, SysOnly),
+		    SysMemUsage1 = dummy_reply(get_system_memory_data),
+		    reply(PrevState#state.pending,MemUsage,SysMemUsage1)
+	    end,
+	    case PrevState#state.ext_wd_timer of
+		undefined ->
+		    ignore;
+		TimerRef2 ->
+		    erlang:cancel_timer(TimerRef2),
+		    SysMemUsage2 = dummy_reply(get_system_memory_data),
+		    reply(PrevState#state.pending, undef, SysMemUsage2)
+	    end,
+	    flush(reg_collection_timeout),
+	    flush(ext_collection_timeout),
+
+	    %% Downgrade to old state record
+	    State = {state,
+		     PrevState#state.timeout,
+		     PrevState#state.mem_usage,
+		     PrevState#state.worst_mem_user,
+		     PrevState#state.sys_mem_watermark,
+		     PrevState#state.proc_mem_watermark,
+		     not PrevState#state.sys_only, % collect_procmem
+		     undefined, % wd_timer
+		     [],        % pending
+		     undefined, % ext_wd_timer
+		     [],        % ext_pending
+		     PrevState#state.helper_timeout},
+	    {ok, State};
+
+	%% Upgrade to this version
+	_Vsn ->
+
+	    %% Old state record
+	    {state,
+	     Timeout, MemUsage, WorstMemUser,
+	     SysMemWatermark, ProcMemWatermark, CollProc,
+	     WDTimer, Pending, ExtWDTimer, ExtPending,
+	     HelperTimeout} = PrevState,
+	    SysOnly = not CollProc,
+
+	    %% Flush memsup_helper messages
+	    flush(collected_sys),
+	    flush(collected_proc),
+	    flush(collected_ext_sys),
+		     
+	    %% Cancel timers, flush timeout messages
+	    %% and send dummy replies to any pending clients
+	    case WDTimer of
+		undefined ->
+		    ignore;
+		TimerRef1 ->
+		    erlang:cancel_timer(TimerRef1),
+		    MemUsage = dummy_reply(get_memory_data, SysOnly),
+		    Pending2 = lists:map(fun(From) -> {reg,From} end,
+					 Pending),
+		    reply(Pending2, MemUsage, undef)
+	    end,
+	    case ExtWDTimer of
+		undefined ->
+		    ignore;
+		TimerRef2 ->
+		    erlang:cancel_timer(TimerRef2),
+		    SysMemUsage = dummy_reply(get_system_memory_data),
+		    ExtPending2 = lists:map(fun(From) -> {ext,From} end,
+					    ExtPending),
+		    reply(ExtPending2, undef, SysMemUsage)
+	    end,
+	    flush(reg_collection_timeout),
+	    flush(ext_collection_timeout),
+
+	    OS = os:type(),
+	    PortMode = case OS of
+			   {unix, darwin} -> false;
+			   {unix, freebsd} -> false;
+			   {unix, linux} -> false;
+			   {unix, openbsd} -> true;
+			   {unix, sunos} -> true;
+			   {win32, _OSname} -> false;
+			   vxworks -> true
+		       end,
+	    Pid = if
+		      PortMode -> spawn_link(fun() -> port_init() end);
+		      not PortMode -> undefined
+		  end,
+
+	    %% Upgrade to this state record
+	    State = #state{os = OS,
+			   port_mode = PortMode,
+			   mem_usage = MemUsage,
+			   worst_mem_user = WorstMemUser,
+			   sys_only  = SysOnly,
+			   timeout         = Timeout,
+			   helper_timeout  = HelperTimeout,
+			   sys_mem_watermark = SysMemWatermark,
+			   proc_mem_watermark = ProcMemWatermark,
+			   pid                = Pid,
+			   wd_timer           = undefined,
+			   ext_wd_timer       = undefined,
+			   pending            = [],
+			   ext_pending        = []},
+	    {ok, State}
+    end;
+code_change(_Vsn, State, "2.0") ->
+
+    %% Restart the port process (it must use new memsup code)
+    Pid = case State#state.port_mode of
+	      true ->
+		  State#state.pid ! close,
+		  spawn_link(fun() -> port_init() end);
+	      false ->
+		  State#state.pid
+	  end,
+    {ok, State#state{pid=Pid}};
+	  
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% Other exports
+%%----------------------------------------------------------------------
+
+format_status(_Opt, [_PDict, #state{timeout=Timeout, mem_usage=MemUsage,
+				    worst_mem_user=WorstMemUser}]) ->
+    {Allocated, Total} = MemUsage,
+    WorstMemFormat = case WorstMemUser of
+			 {Pid, Mem} ->
+			     [{"Pid", Pid}, {"Memory", Mem}];
+			 undefined ->
+			     undefined
+		     end,
+    [{data, [{"Timeout", Timeout}]},
+     {items, {"Memory Usage", [{"Allocated", Allocated},
+			       {"Total", Total}]}},
+     {items, {"Worst Memory User", WorstMemFormat}}].
+
+
+%%----------------------------------------------------------------------
+%% Internal functions
+%%----------------------------------------------------------------------
+
+%%-- Fetching kernel bit support ---------------------------------------
+
+get_os_wordsize({unix, sunos}) ->
+    String = clean_string(os:cmd("isainfo -b")),
+    erlang:list_to_integer(String);
+get_os_wordsize({unix, irix64})  -> 64;
+get_os_wordsize({unix, irix})    -> 32;
+get_os_wordsize({unix, linux})   -> get_os_wordsize_with_uname();
+get_os_wordsize({unix, darwin})  -> get_os_wordsize_with_uname();
+get_os_wordsize({unix, netbsd})  -> get_os_wordsize_with_uname();
+get_os_wordsize({unix, freebsd}) -> get_os_wordsize_with_uname();
+get_os_wordsize({unix, openbsd}) -> get_os_wordsize_with_uname();
+get_os_wordsize(_)               -> unsupported_os.
+
+get_os_wordsize_with_uname() ->
+    String = clean_string(os:cmd("uname -m")),
+    case String of
+	"x86_64"  -> 64;
+	"sparc64" -> 64;
+	_         -> 32
+    end.
+
+clean_string(String) -> lists:flatten(string:tokens(String,"\r\n\t ")).
+    
+
+%%--Replying to pending clients-----------------------------------------
+
+reply(Pending, MemUsage, SysMemUsage) ->
+    lists:foreach(fun(reg) ->
+			  ignore;
+		     ({reg, From}) ->
+			  gen_server:reply(From, MemUsage);
+		     ({ext, From}) ->
+			  gen_server:reply(From, SysMemUsage)
+		  end,
+		  lists:reverse(Pending)).
+
+%%--Collect memory data, no port----------------------------------------
+
+%% get_memory_usage(OS) -> {Alloc, Total}
+
+%% Darwin:
+%% Uses vm_stat command. This appears to lie about the page size in
+%% Mac OS X 10.2.2 - the pages given are based on 4000 bytes, but
+%% the vm_stat command tells us that it is 4096...
+get_memory_usage({unix,darwin}) ->
+    Str1 = os:cmd("/usr/bin/vm_stat"),
+    
+    {[Free],     Str2} = fread_value("Pages free:~d.", Str1),
+    {[Active],   Str3} = fread_value("Pages active:~d.", Str2),
+    {[Inactive], Str4} = fread_value("Pages inactive:~d.", Str3),
+    {[_],        Str5} = fread_value("Pages speculative:~d.", Str4),
+    {[Wired],       _} = fread_value("Pages wired down:~d.", Str5),
+
+    NMemUsed  = (Wired + Active + Inactive) * 4000,
+    NMemTotal = NMemUsed + Free * 4000,
+    {NMemUsed,NMemTotal};
+
+%% FreeBSD: Look in /usr/include/sys/vmmeter.h for the format of struct
+%% vmmeter
+get_memory_usage({unix,freebsd}) ->
+    PageSize  = freebsd_sysctl("vm.stats.vm.v_page_size"),
+    PageCount = freebsd_sysctl("vm.stats.vm.v_page_count"),
+    FreeCount = freebsd_sysctl("vm.stats.vm.v_free_count"),
+    NMemUsed  = (PageCount - FreeCount) * PageSize,
+    NMemTotal = PageCount * PageSize,
+    {NMemUsed, NMemTotal};
+
+%% Win32: Find out how much memory is in use by asking
+%% the os_mon_sysinfo process.
+get_memory_usage({win32,_OSname}) ->
+    [Result|_] = os_mon_sysinfo:get_mem_info(),
+    {ok, [_MemLoad, TotPhys, AvailPhys,
+	  _TotPage, _AvailPage, _TotV, _AvailV], _RestStr} =
+	io_lib:fread("~d~d~d~d~d~d~d", Result),
+    {TotPhys-AvailPhys, TotPhys}.
+
+fread_value(Format, Str0) ->
+    case io_lib:fread(Format, skip_to_eol(Str0)) of
+    	{error, {fread, input}} -> {[0], Str0};
+	{ok, Value, Str1} -> {Value, Str1}
+    end.
+
+skip_to_eol([]) -> [];
+skip_to_eol([$\n | T]) -> T;
+skip_to_eol([_ | T]) -> skip_to_eol(T).
+
+freebsd_sysctl(Def) ->
+    list_to_integer(os:cmd("/sbin/sysctl -n " ++ Def) -- "\n").
+
+%% get_ext_memory_usage(OS, {Alloc, Total}) -> [{Tag, Bytes}]
+get_ext_memory_usage(OS, {Alloc, Total}) ->
+    case OS of
+	{win32, _} ->
+	    [{total_memory, Total}, {free_memory, Total-Alloc},
+	     {system_total_memory, Total}];
+	{unix, linux} ->
+	    [{total_memory, Total}, {free_memory, Total-Alloc},
+	     %% corr. unless setrlimit() set
+	     {system_total_memory, Total}];
+	{unix, freebsd} ->
+	    [{total_memory, Total}, {free_memory, Total-Alloc},
+	     {system_total_memory, Total}];
+	{unix, darwin} ->
+	    [{total_memory, Total}, {free_memory, Total-Alloc},
+	     {system_total_memory, Total}];
+	_ -> % OSs using a port
+	    dummy % not sent anyway
+    end.
+
+%%--Collect memory data, using port-------------------------------------
+
+port_init() ->
+    process_flag(trap_exit, true),
+    Port = start_portprogram(),
+    port_idle(Port).
+
+start_portprogram() ->
+    Command = filename:join([code:priv_dir(os_mon), "bin", "memsup"]),
+    open_port({spawn, Command}, [{packet, 1}]).
+
+%% The connected process loops are a bit awkward (several different
+%% functions doing almost the same thing) as
+%%   a) strategies for receiving regular memory data and extensive
+%%      memory data are different
+%%   b) memory collection can be cancelled, in which case the process
+%%      should still wait for port response (which should come
+%%      eventually!) but not receive any requests or cancellations
+%%      meanwhile to prevent getting out of synch.
+port_idle(Port) ->
+    receive
+	{Memsup, collect_sys} ->
+	    Port ! {self(), {command, [?SHOW_MEM]}},
+	    get_memory_usage(Port, undefined, Memsup);
+	{Memsup, collect_ext_sys} ->
+	    Port ! {self(), {command, [?SHOW_SYSTEM_MEM]}},
+	    get_ext_memory_usage(Port, [], Memsup);
+	cancel ->
+	    %% Received after reply already has been delivered...
+	    port_idle(Port);
+	ext_cancel ->
+	    %% Received after reply already has been delivered...
+	    port_idle(Port);
+	close ->
+	    port_close(Port);
+	{Port, {data, Data}} ->
+	    exit({port_error, Data});
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+
+get_memory_usage(Port, Alloc, Memsup) ->
+    receive
+	{Port, {data, Data}} when Alloc==undefined ->
+	    get_memory_usage(Port, erlang:list_to_integer(Data, 16), Memsup);
+	{Port, {data, Data}} ->
+	    Total = erlang:list_to_integer(Data, 16),
+	    Memsup ! {collected_sys, {Alloc, Total}},
+	    port_idle(Port);
+	cancel ->
+	    get_memory_usage_cancelled(Port, Alloc);
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+get_memory_usage_cancelled(Port, Alloc) ->
+    receive
+	{Port, {data, _Data}} when Alloc==undefined ->
+	    get_memory_usage_cancelled(Port, 0);
+	{Port, {data, _Data}} ->
+	    port_idle(Port);
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+
+get_ext_memory_usage(Port, Accum, Memsup) ->
+    Tab = [
+	    {?MEM_SYSTEM_TOTAL,   system_total_memory},
+	    {?MEM_TOTAL,          total_memory},
+	    {?MEM_FREE,           free_memory},
+	    {?MEM_BUFFERS,        buffered_memory},
+	    {?MEM_CACHED,         cached_memory},
+	    {?MEM_SHARED,         shared_memory},
+	    {?MEM_LARGEST_FREE,   largest_free},
+	    {?MEM_NUMBER_OF_FREE, number_of_free},
+	    {?SWAP_TOTAL,	  total_swap},
+	    {?SWAP_FREE,	  free_swap}
+	],
+    receive
+	{Port, {data, [?SHOW_SYSTEM_MEM_END]}} ->
+	    Memsup ! {collected_ext_sys, Accum},
+	    port_idle(Port);
+	{Port, {data, [Tag]}} ->
+	    case lists:keysearch(Tag, 1, Tab) of
+		{value, {Tag, ATag}} ->
+		    get_ext_memory_usage(ATag, Port, Accum, Memsup);
+		_ ->
+		    exit({memsup_port_error, {Port,[Tag]}})
+	    end;
+	ext_cancel ->
+	    get_ext_memory_usage_cancelled(Port);
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+get_ext_memory_usage_cancelled(Port) ->
+    Tab = [
+	    {?MEM_SYSTEM_TOTAL,   system_total_memory},
+	    {?MEM_TOTAL,          total_memory},
+	    {?MEM_FREE,           free_memory},
+	    {?MEM_BUFFERS,        buffered_memory},
+	    {?MEM_CACHED,         cached_memory},
+	    {?MEM_SHARED,         shared_memory},
+	    {?MEM_LARGEST_FREE,   largest_free},
+	    {?MEM_NUMBER_OF_FREE, number_of_free},
+	    {?SWAP_TOTAL,	  total_swap},
+	    {?SWAP_FREE,	  free_swap}
+	],
+    receive
+	{Port, {data, [?SHOW_SYSTEM_MEM_END]}} ->
+	    port_idle(Port);
+	{Port, {data, [Tag]}} ->
+	    case lists:keysearch(Tag, 1, Tab) of
+		{value, {Tag, ATag}} ->
+		    get_ext_memory_usage_cancelled(ATag, Port);
+		_ ->
+		    exit({memsup_port_error, {Port,[Tag]}})
+	    end;
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+
+get_ext_memory_usage(ATag, Port, Accum0, Memsup) ->
+    receive
+	{Port, {data, Data}} ->
+	    Accum = [{ATag,erlang:list_to_integer(Data, 16)}|Accum0],
+	    get_ext_memory_usage(Port, Accum, Memsup);
+	cancel ->
+	    get_ext_memory_usage_cancelled(ATag, Port);
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+get_ext_memory_usage_cancelled(_ATag, Port) ->
+    receive
+	{Port, {data, _Data}} ->
+	    get_ext_memory_usage_cancelled(Port);
+	close ->
+	    port_close(Port);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason});
+	{'EXIT', _Memsup, _Reason} ->
+	    port_close(Port)
+    end.
+
+%%--Collect process data------------------------------------------------
+
+%% get_worst_memory_user() -> {Pid, Bytes}
+get_worst_memory_user()  ->
+    get_worst_memory_user(processes(), self(), 0).
+
+get_worst_memory_user([Pid|Pids], MaxPid, MaxMemBytes) ->
+    case process_memory(Pid) of
+	undefined ->
+	    get_worst_memory_user(Pids, MaxPid, MaxMemBytes);
+	MemoryBytes when MemoryBytes>MaxMemBytes ->
+	    get_worst_memory_user(Pids, Pid, MemoryBytes);
+	_MemoryBytes ->
+	    get_worst_memory_user(Pids, MaxPid, MaxMemBytes)
+    end;
+get_worst_memory_user([], MaxPid, MaxMemBytes) ->
+    {MaxPid, MaxMemBytes}.
+
+process_memory(Pid) ->
+    case process_info(Pid, memory) of
+	{memory, Bytes} ->
+	    Bytes;
+	undefined -> % Pid must have died
+	    undefined
+    end.
+
+%%--Alarm handling------------------------------------------------------
+
+set_alarm(AlarmId, AlarmDescr) ->
+    case get(AlarmId) of
+	set ->
+	    ok;
+	undefined ->
+	    alarm_handler:set_alarm({AlarmId, AlarmDescr}),
+	    put(AlarmId, set)
+    end.
+
+clear_alarm(AlarmId) ->
+    case get(AlarmId) of
+	set ->
+	    alarm_handler:clear_alarm(AlarmId),
+	    erase(AlarmId);
+	_ ->
+	    ok
+    end.
+
+clear_alarms() ->
+    lists:foreach(fun({system_memory_high_watermark = Id, set}) ->
+			  alarm_handler:clear_alarm(Id);
+		     ({process_memory_high_watermark = Id, set}) ->
+			  alarm_handler:clear_alarm(Id);
+		     (_Other) ->
+			  ignore
+		  end,
+		  get()).
+
+%%--Auxiliary-----------------------------------------------------------
+
+%% Type conversions
+minutes_to_ms(Minutes) -> trunc(60000*Minutes).
+sec_to_ms(Sec) -> trunc(1000*Sec).
+ms_to_sec(MS) -> MS div 1000.
+
+flush(Msg) ->
+    receive
+	{Msg, _} -> true;
+	Msg -> true
+    after 0 ->
+	    true
+    end.
diff --git a/lib/os_mon/src/nteventlog.erl b/lib/os_mon/src/nteventlog.erl
new file mode 100644
index 0000000000..d624048c29
--- /dev/null
+++ b/lib/os_mon/src/nteventlog.erl
@@ -0,0 +1,162 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1998-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%
+%%
+-module(nteventlog).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/2, start/2, stop/0]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+-record(state, {port, mfa}).
+
+%%----------------------------------------------------------------------
+%% API
+%%----------------------------------------------------------------------
+
+start_link(Ident, MFA) ->
+    gen_server:start_link({local, nteventlog}, nteventlog,
+			  [Ident, MFA], []).
+
+start(Ident, MFA) ->
+    gen_server:start({local, nteventlog}, nteventlog, [Ident, MFA], []).
+
+stop() ->
+    gen_server:call(nteventlog, stop).
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+init([Identifier,MFA0]) ->
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+
+    Port = case os:type() of
+	       {win32, _OSname} -> start_portprogram(Identifier);
+	       OS -> exit({unsupported_os, OS})
+	   end,
+
+    %% If we're using os_sup:error_report/2,
+    %% the setting of os_sup_errortag should be used as argument
+    MFA = case MFA0 of
+	      {os_sup, error_report, [_Tag]} ->
+		  Tag = os_mon:get_env(os_sup, os_sup_errortag),
+		  {os_sup, error_report, [Tag]};
+	      _ ->
+		  MFA0
+	  end,
+
+    {ok, #state{port=Port, mfa=MFA}}.
+
+handle_call(stop, _From, State) ->
+    {stop, normal, stopped, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({_Port, {data, Data}}, #state{mfa={M,F,A}} = State) ->
+    T = parse_log(Data),
+    apply(M, F, [T | A]),
+    State#state.port ! {self(), {command, "A"}},
+    {noreply, State};
+handle_info({'EXIT', _Port, Reason}, State) ->
+    {stop, {port_died, Reason}, State#state{port=not_used}};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, State) ->
+    case State#state.port of
+	not_used -> ignore;
+	Port ->
+	    port_close(Port)
+    end,
+    ok.
+
+%% os_mon-2.0
+%% For live downgrade to/upgrade from os_mon-1.8[.1]
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+	    process_flag(trap_exit, false),
+
+	    %% Downgrade to old State tuple
+	    State = {PrevState#state.port, PrevState#state.mfa},
+	    {ok, State};
+
+	%% Upgrade to this version
+	_Vsn ->
+	    process_flag(trap_exit, true),
+
+	    %% Upgrade to this state record
+	    {Port, MFA} = PrevState,
+	    State = #state{port=Port, mfa=MFA},
+	    {ok, State}
+    end;
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% Internal functions
+%%----------------------------------------------------------------------
+
+start_portprogram(Identifier) ->
+    Command =
+	filename:join([code:priv_dir(os_mon),"bin","nteventlog.exe"]) ++
+	" " ++ make_list(Identifier),
+    open_port({spawn,Command},[{packet,2}]).
+
+make_list(X) when is_atom(X) ->
+    atom_to_list(X);
+make_list(X) ->
+    X.
+
+holl_len([$H | Rest], Sum) ->
+    {Sum, Rest};
+holl_len([ N | Rest], Sum) ->
+    NN = N - $0,
+    holl_len(Rest, Sum * 10 + NN).
+holl_len(L) ->
+    holl_len(L,0).
+
+splitlist(L,N) ->
+    {lists:sublist(L,N),lists:nthtail(N,L)}. 
+
+hollerith(Str) ->
+    {Len, Rest} = holl_len(Str),
+    splitlist(Rest,Len).
+
+holl_time(Str) ->
+    {Holl,Rest} = hollerith(Str),
+    Rev = lists:reverse(Holl),
+    B = list_to_integer(lists:reverse(lists:sublist(Rev,6))),
+    A = list_to_integer(lists:reverse(lists:nthtail(6,Rev))),
+    {{A,B,0},Rest}.
+
+parse_log(Str) ->
+    {Time, Rest1} = holl_time(Str),
+    {Category,Rest2} = hollerith(Rest1),
+    {Facility,Rest3} = hollerith(Rest2),
+    {Severity,Rest4} = hollerith(Rest3),
+    {Message,_} = hollerith(Rest4),
+    {Time,Category,Facility,Severity,Message}.
diff --git a/lib/os_mon/src/os_mon.app.src b/lib/os_mon/src/os_mon.app.src
new file mode 100644
index 0000000000..15bbd2663c
--- /dev/null
+++ b/lib/os_mon/src/os_mon.app.src
@@ -0,0 +1,32 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+
+{application, os_mon,
+   [{description, "CPO  CXC 138 46"},
+    {vsn, "%VSN%"},
+    {modules, [os_mon, os_mon_mib, os_sup,
+               disksup, memsup, cpu_sup, os_mon_sysinfo, nteventlog]},
+    {registered, [os_mon_sup, os_mon_sysinfo, disksup, memsup, cpu_sup, 
+                  os_sup_server]},
+    {applications, [kernel, stdlib, sasl]},
+    {env, [{start_cpu_sup, true},
+	   {start_disksup, true},
+	   {start_memsup, true},
+	   {start_os_sup, false}]},
+    {mod, {os_mon, []}}]}.
diff --git a/lib/os_mon/src/os_mon.appup.src b/lib/os_mon/src/os_mon.appup.src
new file mode 100644
index 0000000000..f8e09a7d87
--- /dev/null
+++ b/lib/os_mon/src/os_mon.appup.src
@@ -0,0 +1,41 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 2001-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%
+%%
+
+{"%VSN%",
+ [
+  {"2.1",
+   [{load_module, cpu_sup},
+    {load_module, disksup},
+    {load_module, memsup},
+    {load_module, os_mon},
+    {load_module, os_mon_mib}]},
+  {"2.1.1",
+   [{load_module, os_mon_mib}]}
+ ],
+ [
+  {"2.1",
+   [{load_module, cpu_sup},
+    {load_module, disksup},
+    {load_module, memsup},
+    {load_module, os_mon},
+    {load_module, os_mon_mib}]},
+  {"2.1.1",
+   [{load_module, os_mon_mib}]}
+  ]
+}.
diff --git a/lib/os_mon/src/os_mon.erl b/lib/os_mon/src/os_mon.erl
new file mode 100644
index 0000000000..ef368571db
--- /dev/null
+++ b/lib/os_mon/src/os_mon.erl
@@ -0,0 +1,179 @@
+%% 
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+-module(os_mon).
+
+-behaviour(application).
+-behaviour(supervisor).
+
+%% API
+-export([call/2, call/3, get_env/2]).
+
+%% Application callbacks
+-export([start/2, stop/1]).
+
+%% Supervisor callbacks
+-export([init/1]).
+
+%%%-----------------------------------------------------------------
+%%% API
+%%%-----------------------------------------------------------------
+
+call(Service, Request) ->
+    call(Service, Request, 5000).
+
+call(Service, Request, Timeout) ->
+    try gen_server:call(server_name(Service), Request, Timeout)
+    catch
+	exit:{noproc, Call} ->
+	    case lists:keysearch(os_mon, 1,
+				 application:which_applications()) of
+		{value, _AppInfo} ->
+		    case startp(Service) of
+			true ->
+			    erlang:exit({noproc, Call});
+			false ->
+			    String = "OS_MON (~p) called by ~p, "
+				     "unavailable~n",
+			    error_logger:warning_msg(String,
+						     [Service, self()]),
+			    Service:dummy_reply(Request)
+		    end;
+		false ->
+		    String = "OS_MON (~p) called by ~p, not started~n",
+		    error_logger:warning_msg(String, [Service, self()]),
+		    Service:dummy_reply(Request)
+	    end
+    end.
+
+get_env(Service, Param) ->
+    case application:get_env(os_mon, Param) of
+	{ok, Value} ->
+	    case Service:param_type(Param, Value) of
+		true ->
+		    Value;
+		false ->
+		    String = "OS_MON (~p), ignoring "
+			     "bad configuration parameter (~p=~p)~n"
+	                     "Using default value instead~n",
+		    error_logger:warning_msg(String,
+					     [Service, Param, Value]),
+		    Service:param_default(Param)
+	    end;
+	undefined ->
+	    Service:param_default(Param)
+    end.
+
+%%%-----------------------------------------------------------------
+%%% Application callbacks
+%%%-----------------------------------------------------------------
+
+start(_, _) ->
+    supervisor:start_link({local, os_mon_sup}, os_mon, []).
+
+stop(_) ->
+    ok.
+
+%%%-----------------------------------------------------------------
+%%% Supervisor callbacks
+%%%-----------------------------------------------------------------
+
+init([]) ->
+    SupFlags = case os:type() of
+		   {win32, _} ->
+		       {one_for_one, 5, 3600};
+		   _ ->
+		       {one_for_one, 4, 3600}
+	       end,
+    SysInf = childspec(sysinfo, startp(sysinfo)),
+    DskSup = childspec(disksup, startp(disksup)),
+    MemSup = childspec(memsup,  startp(memsup)),
+    CpuSup = childspec(cpu_sup, startp(cpu_sup)),
+    OsSup  = childspec(os_sup,  startp(os_sup)),
+    {ok, {SupFlags, SysInf ++ DskSup ++ MemSup ++ CpuSup ++ OsSup}}.
+
+childspec(_Service, false) ->
+    [];
+childspec(cpu_sup, true) ->
+    [{cpu_sup, {cpu_sup, start_link, []},
+      permanent, 2000, worker, [cpu_sup]}];
+childspec(disksup, true) ->
+    [{disksup, {disksup, start_link, []},
+      permanent, 2000, worker, [disksup]}];
+childspec(memsup, true) ->
+    [{memsup, {memsup, start_link, []},
+      permanent, 2000, worker, [memsup]}];
+childspec(os_sup, true) ->
+    OS = os:type(),
+    Mod = case OS of
+	      {win32, _} -> nteventlog; % windows
+	      _ -> os_sup % solaris
+	  end,
+    [{os_sup, {os_sup, start_link, [OS]},
+      permanent, 10000, worker, [Mod]}];
+childspec(sysinfo, true) ->
+    [{os_mon_sysinfo, {os_mon_sysinfo, start_link, []},
+      permanent, 2000, worker, [os_mon_sysinfo]}].
+
+%%%-----------------------------------------------------------------
+%%% Internal functions (OS_Mon configuration)
+%%%-----------------------------------------------------------------
+
+startp(Service) ->
+    %% Available for this platform?
+    case lists:member(Service, services(os:type())) of
+	true ->
+	    %% Is there a start configuration parameter?
+	    case start_param(Service) of
+		none ->
+		    true;
+		Param ->
+		    %% Is the start configuration parameter 'true'?
+		    case application:get_env(os_mon, Param) of
+			{ok, true} ->
+			    true;
+			_ ->
+			    false
+		    end
+	    end;
+	false ->
+	    false
+    end.
+
+services({unix, sunos}) ->
+    [cpu_sup, disksup, memsup, os_sup];
+services({unix, _}) -> % Other unix.
+    [cpu_sup, disksup, memsup];
+services({win32, _}) ->
+    [disksup, memsup, os_sup, sysinfo];
+services(vxworks) ->
+    [memsup];
+services(_) ->
+    [].
+
+server_name(cpu_sup) -> cpu_sup;
+server_name(disksup) -> disksup;
+server_name(memsup) ->  memsup;
+server_name(os_sup) ->  os_sup_server;
+server_name(sysinfo) -> os_mon_sysinfo.
+
+start_param(cpu_sup) -> start_cpu_sup;
+start_param(disksup) -> start_disksup;
+start_param(memsup) ->  start_memsup;
+start_param(os_sup) ->  start_os_sup;
+start_param(sysinfo) -> none.
diff --git a/lib/os_mon/src/os_mon_mib.erl b/lib/os_mon/src/os_mon_mib.erl
new file mode 100644
index 0000000000..a4ce274a16
--- /dev/null
+++ b/lib/os_mon/src/os_mon_mib.erl
@@ -0,0 +1,250 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+-module(os_mon_mib).
+%%%-----------------------------------------------------------------
+%%% Description: This module implements the OS-MON-MIB.
+%%% The tables are implemented as shadow tables with the module
+%%% snmp_shadow_table.  Here the update functions are implemented.
+%%%-----------------------------------------------------------------
+
+-include("../../otp_mibs/include/OTP-MIB.hrl").
+      
+%% API
+-export([load/1, unload/1]).
+
+%% Deprecated API
+-export([init/1, stop/1]).
+
+-deprecated([{init,1,eventually},
+	     {stop,1,eventually}]).
+
+%% SNMP instrumentation
+-export([load_table/1, load_table/3, disk_table/1, disk_table/3,
+	 mem_sys_mark/1, mem_proc_mark/1, disk_threshold/1]).
+
+%% SNMP shadow functions
+-export([update_load_table/0, update_disk_table/0]).
+
+%% Exported for internal use via rpc
+-export([get_load/1, get_disks/1]).
+
+%% Shadow tables  
+-record(loadTable, {
+	loadErlNodeName, 
+	loadSystemTotalMemory, 
+	loadSystemUsedMemory,
+	loadLargestErlProcess, 
+	loadLargestErlProcessUsedMemory,
+	loadCpuLoad, 
+	loadCpuLoad5, 
+	loadCpuLoad15,
+	loadOsWordsize,
+	loadSystemTotalMemory64, 
+	loadSystemUsedMemory64,
+	loadLargestErlProcessUsedMemory64}).
+
+-record(diskTable,
+	{key, diskDescr, diskKBytes, diskCapacity}).
+
+%% Shadow argument macros 
+-define(loadShadowArgs, 
+	{loadTable, string, record_info(fields, loadTable), 5000,
+	 {os_mon_mib, update_load_table}}). 
+	
+-define(diskShadowArgs, 
+	{diskTable, {integer, integer}, record_info(fields, diskTable), 5000,
+	 {os_mon_mib, update_disk_table}}). 
+
+%% Misc
+-record(diskAlloc, {diskDescr, diskId}).
+
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
+
+%%-------------------------------------------------------------------------
+%% load(Agent) ->  ok | {error, Reason}
+%% Agent - pid() | atom()
+%% Reason - term()
+%% Description: Loads the OTP-OS-MON-MIB
+%%-------------------------------------------------------------------------
+load(Agent) ->
+    MibDir = filename:join(code:priv_dir(os_mon), "mibs"),
+    snmpa:load_mibs(Agent, [filename:join(MibDir, "OTP-OS-MON-MIB")]).
+
+%%-------------------------------------------------------------------------
+%% unload(Agent) ->  ok | {error, Reason}
+%% Agent - pid() | atom()
+%% Reason - term()
+%% Description: Unloads the OTP-OS-MON-MIB
+%%-------------------------------------------------------------------------
+unload(Agent) ->
+    snmpa:unload_mibs(Agent, ["OTP-OS-MON-MIB"]).
+    
+%% To be backwards compatible
+init(Agent) ->
+    load(Agent).
+stop(Agent) ->
+    unload(Agent).
+
+%%%=========================================================================
+%%%  SNMP instrumentation
+%%%=========================================================================
+load_table(Op) ->
+    snmp_shadow_table:table_func(Op, ?loadShadowArgs).
+load_table(Op, RowIndex, Cols) ->
+    snmp_shadow_table:table_func(Op, RowIndex, Cols, ?loadShadowArgs).
+
+disk_table(new) ->
+    Tab = diskAlloc,
+    Storage = ram_copies, 
+    case lists:member(Tab, mnesia:system_info(tables)) of
+	true ->
+	    case mnesia:table_info(Tab, storage_type) of
+		unknown ->
+		    {atomic, ok}=mnesia:add_table_copy(Tab, node(), Storage);
+		Storage ->
+		    catch delete_all(Tab)
+	    end;
+	false ->
+	    Nodes = [node()],
+	    Props = [{type, set},
+		     {attributes, record_info(fields, diskAlloc)},
+		     {local_content, true},
+		     {Storage, Nodes}],
+	    {atomic, ok} = mnesia:create_table(Tab, Props)
+    
+    end,
+    Rec = #diskAlloc{diskDescr = next_index, diskId = 1},
+    ok = mnesia:dirty_write(Rec),
+    snmp_shadow_table:table_func(new, ?diskShadowArgs).
+
+disk_table(Op, RowIndex, Cols) ->
+    snmp_shadow_table:table_func(Op, RowIndex, Cols, ?diskShadowArgs).
+
+mem_sys_mark(get) ->
+    {value, memsup:get_sysmem_high_watermark()};
+mem_sys_mark(_) ->
+    ok.
+
+mem_proc_mark(get) ->
+    {value, memsup:get_procmem_high_watermark()};
+mem_proc_mark(_) ->
+    ok.
+
+disk_threshold(get) ->
+    {value, disksup:get_almost_full_threshold()};
+disk_threshold(_) ->
+    ok.
+
+%%%=========================================================================
+%%%  SNMP shadow functions
+%%%=========================================================================
+update_load_table() ->
+    delete_all(loadTable),
+    lists:foreach(
+      fun(Node) ->
+	      case rpc:call(Node, os_mon_mib, get_load, [Node]) of
+		  Load when is_record(Load,loadTable) ->
+		      ok = mnesia:dirty_write(Load);
+		  _Else ->
+		      ok
+	      end
+      end, [node() | nodes()]).
+
+
+update_disk_table() ->
+    delete_all(diskTable),
+    node_update_disk_table(
+      otp_mib:erl_node_table(get_next, [], [?erlNodeName,?erlNodeOutBytes])).
+
+%%%========================================================================
+%%% Exported for internal use via rpc
+%%%========================================================================
+get_load(Node) ->
+    {Total, Allocated, PidString, PidAllocated} = case memsup:get_memory_data() of
+	{MemTot, MemAlloc, undefined}     -> {MemTot, MemAlloc, "undefined", 0};
+	{MemTot, MemAlloc, {Pid, PidMem}} -> {MemTot, MemAlloc, pid_to_str(Pid), PidMem} 
+    end,
+    OsWordsize = case memsup:get_os_wordsize() of
+	WS when is_integer(WS) -> WS;
+	_                      -> 0
+    end,
+    #loadTable{
+	loadErlNodeName                   = atom_to_list(Node),
+	loadSystemTotalMemory             = mask_int32(Total),
+	loadSystemUsedMemory              = mask_int32(Allocated),
+	loadLargestErlProcess             = PidString,
+	loadLargestErlProcessUsedMemory   = mask_int32(PidAllocated),
+	loadCpuLoad                       = get_cpu_load(avg1),   
+	loadCpuLoad5                      = get_cpu_load(avg5),
+	loadCpuLoad15                     = get_cpu_load(avg15),
+	loadOsWordsize                    = OsWordsize,  
+	loadSystemTotalMemory64           = Total,
+	loadSystemUsedMemory64            = Allocated,
+	loadLargestErlProcessUsedMemory64 = PidAllocated
+    }.
+
+mask_int32(Value) -> Value band ((1 bsl 32) - 1).
+
+get_disks(NodeId) ->
+    element(1,
+	    lists:mapfoldl(
+	      fun({Descr, KByte, Capacity}, DiskId) ->
+		      {#diskTable{key = {NodeId, DiskId}, 
+				  diskDescr = Descr,
+				  diskKBytes = KByte, 
+				  diskCapacity = Capacity},
+		       DiskId + 1}
+	      end, 1, disksup:get_disk_data())).
+
+
+%%%========================================================================
+%%% Internal functions
+%%%========================================================================
+node_update_disk_table([_, endOfTable]) -> 
+    ok;
+
+node_update_disk_table([{[?erlNodeName | IndexList], NodeStr}, _]) ->
+    Disks = rpc:call(list_to_atom(NodeStr), os_mon_mib, get_disks, 
+		     IndexList),
+    lists:foreach(fun(Disk) ->
+			  mnesia:dirty_write(Disk)
+		  end, Disks),
+    node_update_disk_table(otp_mib:erl_node_table(get_next, 
+						  IndexList, 
+						  [?erlNodeName, 
+						   ?erlNodeOutBytes])).
+
+get_cpu_load(X) when X == avg1; X == avg5; X == avg15 ->
+    case erlang:round(apply(cpu_sup, X, [])/2.56) of
+	Large when Large > 100 ->
+	    100;
+	Load ->
+	    Load
+    end.
+
+delete_all(Name) -> delete_all(mnesia:dirty_first(Name), Name).
+delete_all('$end_of_table', _Name) -> done;
+delete_all(Key, Name) ->
+    Next = mnesia:dirty_next(Name, Key),
+    ok = mnesia:dirty_delete({Name, Key}),
+    delete_all(Next, Name).
+
+pid_to_str(Pid) -> lists:flatten(io_lib:format("~w", [Pid])).
diff --git a/lib/os_mon/src/os_mon_sysinfo.erl b/lib/os_mon/src/os_mon_sysinfo.erl
new file mode 100644
index 0000000000..5d12bd95d1
--- /dev/null
+++ b/lib/os_mon/src/os_mon_sysinfo.erl
@@ -0,0 +1,147 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-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%
+%%
+-module(os_mon_sysinfo).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/0]).
+-export([get_disk_info/0, get_disk_info/1, get_mem_info/0]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+-define(DISK_INFO, $d).
+-define(MEM_INFO,  $m).
+-define(OK,        $o).
+
+-record(state, {port}).
+
+%%----------------------------------------------------------------------
+%% API
+%%----------------------------------------------------------------------
+
+start_link() ->
+    gen_server:start_link({local,os_mon_sysinfo}, os_mon_sysinfo, [],[]).
+
+get_disk_info() ->
+    gen_server:call(os_mon_sysinfo, get_disk_info).
+
+get_disk_info(DriveRoot) ->
+    gen_server:call(os_mon_sysinfo, {get_disk_info,DriveRoot}).
+
+get_mem_info() ->
+    gen_server:call(os_mon_sysinfo, get_mem_info).
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+init([]) ->
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+    Port = case os:type() of
+	       {win32, _OSname} -> start_portprogram();
+	       OS -> exit({unsupported_os, OS})
+	   end,
+    {ok, #state{port=Port}}.
+
+handle_call(get_disk_info, _From, State) ->
+    {reply, get_disk_info1(State#state.port), State};
+handle_call({get_disk_info,RootList}, _From, State) ->
+    {reply, get_disk_info1(State#state.port,RootList), State};
+handle_call(get_mem_info, _From, State) ->
+    {reply, get_mem_info1(State#state.port), State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({'EXIT', _Port, Reason}, State) ->
+    {stop, {port_died, Reason}, State#state{port=not_used}};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, State) ->
+    case State#state.port of
+	not_used ->
+	    ok;
+	Port ->
+	    port_close(Port)
+    end,
+    ok.
+
+%% os_mon-2.0
+%% For live downgrade to/upgrade from os_mon-1.8[.1]
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+	    process_flag(trap_exit, false);
+
+	%% Upgrade to this version
+	_Vsn ->
+	    process_flag(trap_exit, true)
+    end,
+    {ok, PrevState};
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% Internal functions
+%%----------------------------------------------------------------------
+
+start_portprogram() ->
+    Command =
+	filename:join([code:priv_dir(os_mon),"bin","win32sysinfo.exe"]),
+    Port = open_port({spawn,Command}, [{packet,1}]),
+    receive
+	{Port, {data, [?OK]}} ->
+	    Port;
+	{Port, {data, Data}} ->
+	    exit({port_error, Data});
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason})
+    after 5000 ->
+	    exit({port_error, timeout})
+    end.
+
+get_disk_info1(Port) ->
+    Port ! {self(),{command,[?DISK_INFO]}},
+    get_data(Port,[]).
+
+get_disk_info1(Port,PathList) ->
+    Port ! {self(),{command,[?DISK_INFO|[P++[0]||P <- PathList]]}},
+    get_data(Port,[]).
+
+get_mem_info1(Port) ->
+    Port ! {self(),{command,[?MEM_INFO]}},
+    get_data(Port,[]).
+
+get_data(Port, Sofar) ->
+    receive
+	{Port, {data, [?OK]}} ->
+	    lists:reverse(Sofar);
+	{Port, {data, Bytes}} ->
+	    get_data(Port, [Bytes|Sofar]);
+	{'EXIT', Port, Reason} ->
+	    exit({port_died, Reason})
+    after 5000 ->
+	    lists:reverse(Sofar)
+    end.
diff --git a/lib/os_mon/src/os_sup.erl b/lib/os_mon/src/os_sup.erl
new file mode 100644
index 0000000000..f5c6c138ba
--- /dev/null
+++ b/lib/os_mon/src/os_sup.erl
@@ -0,0 +1,258 @@
+%% 
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-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%
+%%
+-module(os_sup).
+-behaviour(gen_server).
+
+%% API
+-export([start_link/1, start/0, stop/0]).
+-export([error_report/2]).
+-export([enable/0, enable/2, disable/0, disable/2]).
+-export([param_type/2, param_default/1]).
+
+%% gen_server callbacks
+-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
+	 terminate/2, code_change/3]).
+
+-record(state, {port, mfa, config, path, conf}).
+
+%%----------------------------------------------------------------------
+%% API
+%%----------------------------------------------------------------------
+
+start_link({win32, _OSname}) ->
+    Identifier = os_sup,
+    MFA = os_mon:get_env(os_sup, os_sup_mfa),
+    gen_server:start_link({local, os_sup_server}, nteventlog,
+			  [Identifier, MFA], []);
+start_link(_OS) ->
+    gen_server:start_link({local, os_sup_server}, os_sup, [], []).
+
+start() -> % for testing
+    gen_server:start({local, os_sup_server}, os_sup, [], []).
+
+stop() ->
+    gen_server:call(os_sup_server, stop).
+
+error_report(LogData, Tag) ->
+    error_logger:error_report(Tag, LogData).
+
+enable() ->
+    command(enable).
+enable(Path, Conf) ->
+    command(enable, Path, Conf).
+
+disable() ->
+    command(disable).
+disable(Path, Conf) ->
+    command(disable, Path, Conf).
+
+param_type(os_sup_errortag, Val) when is_atom(Val) -> true;
+param_type(os_sup_own, Val) -> io_lib:printable_list(Val);
+param_type(os_sup_syslogconf, Val) -> io_lib:printable_list(Val);
+param_type(os_sup_enable, Val) when Val==true; Val==false -> true;
+param_type(os_sup_mfa, {Mod,Func,Args}) when is_atom(Mod),
+					     is_atom(Func),
+					     is_list(Args) -> true;
+param_type(_Param, _Val) -> false.
+
+param_default(os_sup_errortag) -> std_error;
+param_default(os_sup_own) -> "/etc";
+param_default(os_sup_syslogconf) -> "/etc/syslog.conf";
+param_default(os_sup_enable) -> true;
+param_default(os_sup_mfa) -> {os_sup, error_report, [std_error]}.
+
+%%----------------------------------------------------------------------
+%% gen_server callbacks
+%%----------------------------------------------------------------------
+
+init([]) ->
+    process_flag(trap_exit, true),
+    process_flag(priority, low),
+
+    case os:type() of
+	{unix, sunos} ->
+	    init2();
+	OS -> {stop, {unsupported_os, OS}}
+    end.
+
+init2() -> % Enable service if configured to do so
+    ConfigP = os_mon:get_env(os_sup, os_sup_enable),
+    case ConfigP of
+	true -> % ..yes -- do enable
+	    Path = os_mon:get_env(os_sup, os_sup_own),
+	    Conf = os_mon:get_env(os_sup, os_sup_syslogconf),
+	    case enable(Path, Conf) of
+		ok ->
+		    init3(#state{config=ConfigP, path=Path, conf=Conf});
+		{error, Error} ->
+		    {stop, {mod_syslog, Error}}
+	    end;
+	false -> % ..no -- skip directly to init3/1
+	    init3(#state{config=ConfigP})
+    end.
+
+init3(State0) ->
+    Port = start_portprogram(),
+
+    %% Read the values of some configuration parameters
+    MFA = case os_mon:get_env(os_sup, os_sup_mfa) of
+	      {os_sup, error_report, _} ->
+		  Tag = os_mon:get_env(os_sup, os_sup_errortag),
+		  {os_sup, error_report, [Tag]};
+	      MFA0 ->
+		  MFA0
+	  end,
+
+    {ok, State0#state{port=Port, mfa=MFA}}.
+
+handle_call(stop, _From, State) ->
+    {stop, normal, ok, State}.
+
+handle_cast(_Msg, State) ->
+    {noreply, State}.
+
+handle_info({_Port, {data, Data}}, #state{mfa={M,F,A}} = State) ->
+    apply(M, F, [Data | A]),
+    {noreply, State};
+handle_info({'EXIT', _Port, Reason}, State) ->
+    {stop, {port_died, Reason}, State#state{port=not_used}};
+handle_info(_Info, State) ->
+    {noreply, State}.
+
+terminate(_Reason, #state{port=Port} = State) ->
+    case State#state.config of
+	true when is_port(Port) ->
+	    Port ! {self(), {command, "only_stdin"}},
+	    Res = disable(State#state.path, State#state.conf),
+	    port_close(Port),
+	    if
+		Res/="0" -> exit({mod_syslog, Res});
+		true -> ok
+	    end;
+	true ->
+	    Res = disable(State#state.path, State#state.conf),
+	    if
+		Res/="0" -> exit({mod_syslog, Res});
+		true -> ok
+	    end;
+	false when is_port(Port) ->
+	    Port ! {self(), {command, "only_stdin"}},
+	    port_close(Port);
+	false ->
+	    ok
+    end.
+
+%% os_mon-2.0
+%% For live downgrade to/upgrade from os_mon-1.8[.1]
+code_change(Vsn, PrevState, "1.8") ->
+    case Vsn of
+
+	%% Downgrade from this version
+	{down, _Vsn} ->
+
+	    %% Find out the error tag used
+	    {DefM, DefF, _} = param_default(os_sup_mfa),
+	    Tag = case PrevState#state.mfa of
+
+		      %% Default callback function is used, then use
+		      %% the corresponding tag
+		      {DefM, DefF, [Tag0]} ->
+			  Tag0;
+
+		      %% Default callback function is *not* used
+		      %% (before the downgrade, that is)
+		      %% -- check the configuration parameter
+		      _ ->
+			  case application:get_env(os_mon,
+						   os_sup_errortag) of
+			      {ok, Tag1} ->
+				  Tag1;
+
+			      %% (actually, if it has no value,
+			      %%  the process should terminate
+			      %%  according to 1.8.1 version, but that
+			      %%  seems too harsh here)
+			      _ ->
+				  std_error
+			  end
+		  end,
+		      
+	    %% Downgrade to old state record
+	    State = {state, PrevState#state.port, Tag},
+	    {ok, State};
+
+	%% Upgrade to this version
+	_Vsn ->
+
+	    {state, Port, Tag} = PrevState,
+
+	    {DefM, DefF, _} = param_default(os_sup_mfa),
+	    MFA  = {DefM, DefF, [Tag]},
+
+	    %% We can safely assume the following configuration
+	    %% parameters are defined, otherwise os_sup would never had
+	    %% started in the first place.
+	    %% (We can *not* safely assume they haven't been changed,
+	    %%  but that's a weakness inherited from the 1.8.1 version)
+	    Path = application:get_env(os_mon, os_sup_own),
+	    Conf = application:get_env(os_mon, os_sup_syslogconf),
+
+	    %% Upgrade to this state record
+	    State = #state{port=Port, mfa=MFA, config=true,
+			   path=Path, conf=Conf},
+	    {ok, State}
+    end;
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
+
+%%----------------------------------------------------------------------
+%% Internal functions
+%%----------------------------------------------------------------------
+
+start_portprogram() ->
+    OwnPath = os_mon:get_env(os_sup, os_sup_own),
+    Command =
+	filename:join([code:priv_dir(os_mon), "bin", "ferrule"]) ++
+	" " ++ OwnPath,
+    open_port({spawn, Command}, [{packet, 2}]).
+
+%% os:cmd(cmd_str(enable)) should be done BEFORE starting os_sup
+%% os:cmd(cmd_str(disable)) should be done AFTER os_sup is terminated
+%% Both commands return "0" if successful
+command(Mode) ->
+    command(Mode, "/etc", "/etc/syslog.conf").
+command(Mode, Path, Conf) ->
+    case os:cmd(cmd_str(Mode, Path, Conf)) of
+	"0" ->
+	    ok;
+	Error ->
+	    {error, Error}
+    end.
+
+cmd_str(Mode, Path, Conf) ->
+    %% modpgm modesw ownpath syslogconf
+    PrivDir = code:priv_dir(os_mon),
+    ModeSw =
+	case Mode of
+	    enable ->
+		" otp ";
+	    disable ->
+		" nootp "
+	end,
+    PrivDir ++ "/bin/mod_syslog" ++ ModeSw ++ Path ++ " " ++ Conf.
diff --git a/lib/os_mon/vsn.mk b/lib/os_mon/vsn.mk
new file mode 100644
index 0000000000..d9f56416bf
--- /dev/null
+++ b/lib/os_mon/vsn.mk
@@ -0,0 +1 @@
+OS_MON_VSN = 2.2.4