Merge branch 'maint' into sverk/trace-process_dump-matchstate

Conflicts:
	erts/emulator/beam/erl_printf_term.c
	erts/emulator/beam/erl_term.c
	erts/emulator/beam/utils.c

8 files changed, 1463 insertions, 274 deletions

diff --git a/erts/emulator/sys/unix/driver_int.h b/erts/emulator/sys/unix/driver_int.h
index a7ee8087ab..a6b9085245 100644
--- a/erts/emulator/sys/unix/driver_int.h
+++ b/erts/emulator/sys/unix/driver_int.h
@@ -3,16 +3,17 @@
  * 
  * 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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  */
diff --git a/erts/emulator/sys/unix/erl_child_setup.c b/erts/emulator/sys/unix/erl_child_setup.c
index 5ad92dad02..a3c5c20641 100644
--- a/erts/emulator/sys/unix/erl_child_setup.c
+++ b/erts/emulator/sys/unix/erl_child_setup.c
@@ -3,16 +3,17 @@
  * 
  * Copyright Ericsson AB 2002-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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  */
@@ -55,7 +56,7 @@ void sys_sigrelease(int sig)
 #endif /* !SIG_SIGSET */
 
 #if defined(__ANDROID__)
-int __system_properties_fd(void);
+static int system_properties_fd(void);
 #endif /* __ANDROID__ */
 
 #if defined(__ANDROID__)
@@ -104,14 +105,19 @@ main(int argc, char *argv[])
 #if defined(HAVE_CLOSEFROM)
     closefrom(from);
 #elif defined(__ANDROID__)
-    for (i = from; i <= to; i++) {
-	if (i!=__system_properties_fd)
-	    (void) close(i);
+    if (from <= to) {
+	int spfd = system_properties_fd();
+	for (i = from; i <= to; i++) {
+	    if (i != spfd) {
+		(void) close(i);
+            }
+	}
     }
-#else
-    for (i = from; i <= to; i++)
+#else  /* !__ANDROID__ */
+    for (i = from; i <= to; i++) {
 	(void) close(i);
-#endif
+    }
+#endif /* HAVE_CLOSEFROM */
 
     if (!(argv[CS_ARGV_WD_IX][0] == '.' && argv[CS_ARGV_WD_IX][1] == '\0')
 	&& chdir(argv[CS_ARGV_WD_IX]) < 0)
@@ -143,9 +149,9 @@ main(int argc, char *argv[])
 }
 
 #if defined(__ANDROID__)
-int __system_properties_fd(void)
+static int system_properties_fd(void)
 {
-    int s, fd;
+    int fd;
     char *env;
 
     env = getenv("ANDROID_PROPERTY_WORKSPACE");
@@ -156,4 +162,3 @@ int __system_properties_fd(void)
     return fd;
 }
 #endif /* __ANDROID__ */
-
diff --git a/erts/emulator/sys/unix/erl_main.c b/erts/emulator/sys/unix/erl_main.c
index b26f93f77e..c417bea622 100644
--- a/erts/emulator/sys/unix/erl_main.c
+++ b/erts/emulator/sys/unix/erl_main.c
@@ -3,16 +3,17 @@
  * 
  * Copyright Ericsson AB 2000-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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  */
diff --git a/erts/emulator/sys/unix/erl_unix_sys.h b/erts/emulator/sys/unix/erl_unix_sys.h
index 26ed2fb558..8d4e98bf3a 100644
--- a/erts/emulator/sys/unix/erl_unix_sys.h
+++ b/erts/emulator/sys/unix/erl_unix_sys.h
@@ -3,16 +3,17 @@
  * 
  * Copyright Ericsson AB 1997-2011. All Rights Reserved.
  * 
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * 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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  *
@@ -45,7 +46,7 @@
 #include <fcntl.h>
 #include "erl_errno.h"
 #include <signal.h>
-
+#include <setjmp.h>
 
 #if HAVE_SYS_SOCKETIO_H
 #   include <sys/socketio.h>
@@ -114,11 +115,6 @@
 /*
  * Make sure that MAXPATHLEN is defined.
  */
-#ifdef GETHRTIME_WITH_CLOCK_GETTIME
-#undef HAVE_GETHRTIME
-#define HAVE_GETHRTIME 1
-#endif
-
 #ifndef MAXPATHLEN
 #   ifdef PATH_MAX
 #       define MAXPATHLEN PATH_MAX
@@ -160,35 +156,134 @@ typedef struct timeval SysTimeval;
 
 typedef struct tms SysTimes;
 
-extern int erts_ticks_per_sec;
-
-#define SYS_CLK_TCK (erts_ticks_per_sec)
+#define SYS_CLK_TCK (erts_sys_time_data__.r.o.ticks_per_sec)
 
 #define sys_times(Arg) times(Arg)
 
-#define ERTS_WRAP_SYS_TIMES 1
-extern int erts_ticks_per_sec_wrap;
-#define SYS_CLK_TCK_WRAP (erts_ticks_per_sec_wrap)
-extern clock_t sys_times_wrap(void);
+#if SIZEOF_LONG == 8
+typedef long ErtsMonotonicTime;
+typedef long ErtsSysHrTime;
+#elif SIZEOF_LONG_LONG == 8
+typedef long long ErtsMonotonicTime;
+typedef long long ErtsSysHrTime;
+#else
+#error No signed 64-bit type found...
+#endif
 
-#ifdef HAVE_GETHRTIME
-#ifdef GETHRTIME_WITH_CLOCK_GETTIME
-typedef long long SysHrTime;
+typedef ErtsMonotonicTime ErtsSystemTime;
 
-extern SysHrTime sys_gethrtime(void);
-#define sys_init_hrtime() /* Nothing */
+#define ERTS_MONOTONIC_TIME_MIN (((ErtsMonotonicTime) 1) << 63)
+#define ERTS_MONOTONIC_TIME_MAX (~ERTS_MONOTONIC_TIME_MIN)
 
-#else /* Real gethrtime (Solaris) */
+/*
+ * OS monotonic time and OS system time
+ */
+#undef ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) \
+    && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+#  if defined(__linux__)
+#    define ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__ 1
+#  endif
+#endif
 
-typedef hrtime_t SysHrTime;
+ErtsSystemTime erts_os_system_time(void);
 
-#define sys_gethrtime() gethrtime()
-#define sys_init_hrtime() /* Nothing */
+#undef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+#undef ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+#undef ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__
 
-#endif /* GETHRTIME_WITH_CLOCK_GETTIME */
-#endif /* HAVE_GETHRTIME */
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+#  define ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT 1
+#  define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT (1000*1000*1000)
+#  if defined(__linux__)
+#    define ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__ 1
+#  endif
+#elif defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+#  define ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT 1
+#  define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT (1000*1000*1000)
+#elif defined(OS_MONOTONIC_TIME_USING_GETHRTIME)
+#  define ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT 1
+#  define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT (1000*1000*1000)
+#elif defined(OS_MONOTONIC_TIME_USING_TIMES)
+#  define ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT 1
+/* Time unit determined at runtime... */
+#  define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT 0
+#else /* No OS monotonic available... */
+#  define ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT (1000*1000)
+#endif
+
+/*
+ * erts_sys_hrtime() is the highest resolution
+ * time function found. Time unit is nano-seconds.
+ * It may or may not be monotonic.
+ */
+ErtsSysHrTime erts_sys_hrtime(void);
+
+struct erts_sys_time_read_only_data__ {
+#ifdef ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__
+    ErtsMonotonicTime (*os_monotonic_time)(void);
+#endif
+#ifdef ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__
+    void (*os_times)(ErtsMonotonicTime *, ErtsSystemTime *);
+#endif
+    int ticks_per_sec;
+};
+
+typedef struct {
+    union {
+	struct erts_sys_time_read_only_data__ o;
+	char align__[(((sizeof(struct erts_sys_time_read_only_data__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } r;
+} ErtsSysTimeData__;
+
+extern ErtsSysTimeData__ erts_sys_time_data__;
+
+#ifdef ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT
+
+#ifdef ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__
+ERTS_GLB_INLINE
+#endif
+ErtsMonotonicTime erts_os_monotonic_time(void);
 
-#if (defined(HAVE_GETHRVTIME) || defined(HAVE_CLOCK_GETTIME))
+#ifdef ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__
+ERTS_GLB_INLINE
+#endif
+void erts_os_times(ErtsMonotonicTime *, ErtsSystemTime *);
+
+#if ERTS_GLB_INLINE_INCL_FUNC_DEF
+
+#ifdef ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__
+
+ERTS_GLB_INLINE ErtsMonotonicTime
+erts_os_monotonic_time(void)
+{
+    return (*erts_sys_time_data__.r.o.os_monotonic_time)();
+}
+
+#endif /* ERTS_OS_MONOTONIC_INLINE_FUNC_PTR_CALL__ */
+
+#ifdef ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__
+
+ERTS_GLB_INLINE void
+erts_os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+    return (*erts_sys_time_data__.r.o.os_times)(mtimep, stimep);
+}
+
+#endif /* ERTS_OS_TIMES_INLINE_FUNC_PTR_CALL__ */
+
+#endif /* ERTS_GLB_INLINE_INCL_FUNC_DEF */
+
+#endif /* ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT */
+
+/*
+ *
+ */
+
+#if (defined(HAVE_GETHRVTIME) || defined(HAVE_CLOCK_GETTIME_CPU_TIME))
 typedef long long SysCpuTime;
 typedef struct timespec SysTimespec;
 
@@ -200,7 +295,7 @@ typedef struct timespec SysTimespec;
 int sys_start_hrvtime(void);
 int sys_stop_hrvtime(void);
 
-#elif defined(HAVE_CLOCK_GETTIME)
+#elif defined(HAVE_CLOCK_GETTIME_CPU_TIME)
 #define sys_clock_gettime(cid,tp) clock_gettime((cid),&(tp))
 #define sys_get_proc_cputime(t,tp) sys_clock_gettime(CLOCK_PROCESS_CPUTIME_ID,(tp))
 
@@ -211,13 +306,8 @@ int sys_stop_hrvtime(void);
 #define SYS_CLOCK_RESOLUTION 1
 
 /* These are defined in sys.c */
-#if defined(SIG_SIGSET)		/* Old SysV */
-RETSIGTYPE (*sys_sigset())();
-#elif defined(SIG_SIGNAL)	/* Old BSD */
-RETSIGTYPE (*sys_sigset())();
-#else
-RETSIGTYPE (*sys_sigset(int, RETSIGTYPE (*func)(int)))(int);
-#endif
+typedef void (*SIGFUNC)(int);
+extern SIGFUNC sys_signal(int, SIGFUNC);
 extern void sys_sigrelease(int);
 extern void sys_sigblock(int);
 extern void sys_stop_cat(void);
@@ -247,6 +337,8 @@ extern void sys_stop_cat(void);
 #  define HAVE_ISFINITE
 #endif
 
+#define erts_isfinite isfinite
+
 #ifdef NO_FPE_SIGNALS
 
 #define erts_get_current_fp_exception() NULL
@@ -354,4 +446,28 @@ extern int exit_async(void);
 
 #define ERTS_EXIT_AFTER_DUMP _exit
 
+#if !defined(__APPLE__) && !defined(__MACH__)
+/* Some OS X versions do not allow (ab)using signal handlers like this */
+#define ERTS_HAVE_TRY_CATCH 1
+
+/* We try to simulate a try catch in C with the help of signal handlers.
+ * Only use this as a very last resort, as it is not very portable and
+ * quite unstable. It is also not thread safe, so make sure that only
+ * one thread can call this at a time!
+ */
+extern void erts_sys_sigsegv_handler(int);
+extern jmp_buf erts_sys_sigsegv_jmp;
+#define ERTS_SYS_TRY_CATCH(EXPR,CATCH)                                  \
+    do {                                                                \
+        SIGFUNC prev_handler = sys_signal(SIGSEGV,                      \
+                                          erts_sys_sigsegv_handler);    \
+        if (!setjmp(erts_sys_sigsegv_jmp)) {                            \
+            EXPR;                                                       \
+        } else {                                                        \
+            CATCH;                                                      \
+        }                                                               \
+        sys_signal(SIGSEGV,prev_handler);                               \
+    } while(0)
+#endif
+
 #endif /* #ifndef _ERL_UNIX_SYS_H */
diff --git a/erts/emulator/sys/unix/erl_unix_sys_ddll.c b/erts/emulator/sys/unix/erl_unix_sys_ddll.c
index 2659d623c7..daed5af1b6 100644
--- a/erts/emulator/sys/unix/erl_unix_sys_ddll.c
+++ b/erts/emulator/sys/unix/erl_unix_sys_ddll.c
@@ -3,16 +3,17 @@
  * 
  * Copyright Ericsson AB 2006-2013. 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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  */
diff --git a/erts/emulator/sys/unix/sys.c b/erts/emulator/sys/unix/sys.c
index cd87b320e2..8d7da3e47e 100644
--- a/erts/emulator/sys/unix/sys.c
+++ b/erts/emulator/sys/unix/sys.c
@@ -3,16 +3,17 @@
  *
  * Copyright Ericsson AB 1996-2014. 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/.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * 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.
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
  * %CopyrightEnd%
  */
@@ -34,6 +35,7 @@
 #include <termios.h>
 #include <ctype.h>
 #include <sys/utsname.h>
+#include <sys/select.h>
 
 #ifdef ISC32
 #include <sys/bsdtypes.h>
@@ -85,14 +87,24 @@ static erts_smp_rwmtx_t environ_rwmtx;
 #define DISABLE_VFORK 0
 #endif
 
+#if defined IOV_MAX
+#define MAXIOV IOV_MAX
+#elif defined UIO_MAXIOV
+#define MAXIOV UIO_MAXIOV
+#else
+#define MAXIOV 16
+#endif
+
 #ifdef USE_THREADS
 #  ifdef ENABLE_CHILD_WAITER_THREAD
 #    define CHLDWTHR ENABLE_CHILD_WAITER_THREAD
 #  else
 #    define CHLDWTHR 0
 #  endif
+#  define FDBLOCK 1
 #else
 #  define CHLDWTHR 0
+#  define FDBLOCK 0
 #endif
 /*
  * [OTP-3906]
@@ -121,6 +133,15 @@ struct ErtsSysReportExit_ {
 #endif
 };
 
+/* Used by the fd driver iff the fd could not be set to non-blocking */
+typedef struct ErtsSysBlocking_ {
+    ErlDrvPDL pdl;
+    int res;
+    int err;
+    unsigned int pkey;
+} ErtsSysBlocking;
+
+
 /* This data is shared by these drivers - initialized by spawn_init() */
 static struct driver_data {
     ErlDrvPort port_num;
@@ -129,6 +150,8 @@ static struct driver_data {
     int pid;
     int alive;
     int status;
+    int terminating;
+    ErtsSysBlocking *blocking;
 } *driver_data;			/* indexed by fd */
 
 static ErtsSysReportExit *report_exit_list;
@@ -202,8 +225,14 @@ static erts_smp_atomic_t sys_misc_mem_sz;
 #if defined(ERTS_SMP)
 static void smp_sig_notify(char c);
 static int sig_notify_fds[2] = {-1, -1};
+
+static int sig_suspend_fds[2] = {-1, -1};
+#define ERTS_SYS_SUSPEND_SIGNAL SIGUSR2
+
 #endif
 
+jmp_buf erts_sys_sigsegv_jmp;
+
 #if CHLDWTHR || defined(ERTS_SMP)
 erts_mtx_t chld_stat_mtx;
 #endif
@@ -280,7 +309,7 @@ struct {
     int (*event)(ErlDrvPort, ErlDrvEvent, ErlDrvEventData);
     void (*check_io_as_interrupt)(void);
     void (*check_io_interrupt)(int);
-    void (*check_io_interrupt_tmd)(int, erts_short_time_t);
+    void (*check_io_interrupt_tmd)(int, ErtsMonotonicTime);
     void (*check_io)(int);
     Uint (*size)(void);
     Eterm (*info)(void *);
@@ -386,9 +415,9 @@ erts_sys_schedule_interrupt(int set)
 
 #ifdef ERTS_SMP
 void
-erts_sys_schedule_interrupt_timed(int set, erts_short_time_t msec)
+erts_sys_schedule_interrupt_timed(int set, ErtsMonotonicTime timeout_time)
 {
-    ERTS_CHK_IO_INTR_TMD(set, msec);
+    ERTS_CHK_IO_INTR_TMD(set, timeout_time);
 }
 #endif
 
@@ -504,11 +533,14 @@ thr_create_prepare_child(void *vtcdp)
 void
 erts_sys_pre_init(void)
 {
+#ifdef USE_THREADS
+    erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
+#endif
+
     erts_printf_add_cr_to_stdout = 1;
     erts_printf_add_cr_to_stderr = 1;
+
 #ifdef USE_THREADS
-    {
-    erts_thr_init_data_t eid = ERTS_THR_INIT_DATA_DEF_INITER;
 
     eid.thread_create_child_func = thr_create_prepare_child;
     /* Before creation in parent */
@@ -531,6 +563,12 @@ erts_sys_pre_init(void)
     erts_lcnt_init();
 #endif
 
+#endif /* USE_THREADS */
+
+    erts_init_sys_time_sup();
+
+#ifdef USE_THREADS
+
 #if CHLDWTHR || defined(ERTS_SMP)
     erts_mtx_init(&chld_stat_mtx, "child_status");
 #endif
@@ -541,7 +579,7 @@ erts_sys_pre_init(void)
     erts_cnd_init(&chld_stat_cnd);
     children_alive = 0;
 #endif
-    }
+
 #ifdef ERTS_SMP
     erts_smp_atomic32_init_nob(&erts_break_requested, 0);
     erts_smp_atomic32_init_nob(&erts_got_sigusr1, 0);
@@ -554,7 +592,9 @@ erts_sys_pre_init(void)
 #if !CHLDWTHR && !defined(ERTS_SMP)
     children_died = 0;
 #endif
+
 #endif /* USE_THREADS */
+
     erts_smp_atomic_init_nob(&sys_misc_mem_sz, 0);
 
     {
@@ -640,39 +680,7 @@ erl_sys_init(void)
 
 /* signal handling */
 
-#ifdef SIG_SIGSET		/* Old SysV */
-RETSIGTYPE (*sys_sigset(sig, func))()
-int sig;
-RETSIGTYPE (*func)();
-{
-    return(sigset(sig, func));
-}
-void sys_sigblock(int sig)
-{
-    sighold(sig);
-}
-void sys_sigrelease(int sig)
-{
-    sigrelse(sig);
-}
-#else /* !SIG_SIGSET */
-#ifdef SIG_SIGNAL		/* Old BSD */
-RETSIGTYPE (*sys_sigset(sig, func))(int, int)
-int sig;
-RETSIGTYPE (*func)();
-{
-    return(signal(sig, func));
-}
-sys_sigblock(int sig)
-{
-    sigblock(sig);
-}
-sys_sigrelease(int sig)
-{
-    sigsetmask(sigblock(0) & ~sigmask(sig));
-}
-#else /* !SIG_SIGNAL */	/* The True Way - POSIX!:-) */
-RETSIGTYPE (*sys_sigset(int sig, RETSIGTYPE (*func)(int)))(int)
+SIGFUNC sys_signal(int sig, SIGFUNC func)
 {
     struct sigaction act, oact;
 
@@ -705,23 +713,35 @@ void sys_sigrelease(int sig)
     sigaddset(&mask, sig);
     sigprocmask(SIG_UNBLOCK, &mask, (sigset_t *)NULL);
 }
-#endif /* !SIG_SIGNAL */
-#endif /* !SIG_SIGSET */
 
-#if (0) /* not used? -- gordon */
-static void (*break_func)();
-static RETSIGTYPE break_handler(int sig)
-{
-#ifdef QNX
-    /* Turn off SIGCHLD during break processing */
-    sys_sigblock(SIGCHLD);
-#endif
-    (*break_func)();
-#ifdef QNX
-    sys_sigrelease(SIGCHLD);
-#endif
+void erts_sys_sigsegv_handler(int signo) {
+    if (signo == SIGSEGV) {
+        longjmp(erts_sys_sigsegv_jmp, 1);
+    }
+}
+
+/*
+ * Function returns 1 if we can read from all values in between
+ * start and stop.
+ */
+int
+erts_sys_is_area_readable(char *start, char *stop) {
+    int fds[2];
+    if (!pipe(fds)) {
+        /* We let write try to figure out if the pointers are readable */
+        int res = write(fds[1], start, (char*)stop - (char*)start);
+        if (res == -1) {
+            close(fds[0]);
+            close(fds[1]);
+            return 0;
+        }
+        close(fds[0]);
+        close(fds[1]);
+        return 1;
+    }
+    return 0;
+
 }
-#endif /* 0 */
 
 static ERTS_INLINE int
 prepare_crash_dump(int secs)
@@ -849,9 +869,23 @@ sigusr1_exit(void)
 
 #ifdef ETHR_UNUSABLE_SIGUSRX
 #warning "Unusable SIGUSR1 & SIGUSR2. Disabling use of these signals"
-#endif
 
-#ifndef ETHR_UNUSABLE_SIGUSRX
+#else
+
+#ifdef ERTS_SMP
+void
+sys_thr_suspend(erts_tid_t tid) {
+    erts_thr_kill(tid, ERTS_SYS_SUSPEND_SIGNAL);
+}
+
+void
+sys_thr_resume(erts_tid_t tid) {
+    int i = 0, res;
+    do {
+        res = write(sig_suspend_fds[1],&i,sizeof(i));
+    } while (res < 0 && errno == EAGAIN);
+}
+#endif
 
 #if (defined(SIG_SIGSET) || defined(SIG_SIGNAL))
 static RETSIGTYPE user_signal1(void)
@@ -866,20 +900,20 @@ static RETSIGTYPE user_signal1(int signum)
 #endif
 }
 
-#ifdef QUANTIFY
+#ifdef ERTS_SMP
 #if (defined(SIG_SIGSET) || defined(SIG_SIGNAL))
-static RETSIGTYPE user_signal2(void)
+static RETSIGTYPE suspend_signal(void)
 #else
-static RETSIGTYPE user_signal2(int signum)
+static RETSIGTYPE suspend_signal(int signum)
 #endif
 {
-#ifdef ERTS_SMP
-   smp_sig_notify('2');
-#else
-   quantify_save_data();
-#endif
+   int res;
+   int buf[1];
+   do {
+     res = read(sig_suspend_fds[0], buf, sizeof(int));
+   } while (res < 0 && errno == EINTR);
 }
-#endif
+#endif /* #ifdef ERTS_SMP */
 
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
 
@@ -904,9 +938,9 @@ static RETSIGTYPE do_quit(int signum)
 
 /* Disable break */
 void erts_set_ignore_break(void) {
-    sys_sigset(SIGINT,  SIG_IGN);
-    sys_sigset(SIGQUIT, SIG_IGN);
-    sys_sigset(SIGTSTP, SIG_IGN);
+    sys_signal(SIGINT,  SIG_IGN);
+    sys_signal(SIGQUIT, SIG_IGN);
+    sys_signal(SIGTSTP, SIG_IGN);
 }
 
 /* Don't use ctrl-c for break handler but let it be 
@@ -929,14 +963,14 @@ void erts_replace_intr(void) {
 
 void init_break_handler(void)
 {
-   sys_sigset(SIGINT, request_break);
+   sys_signal(SIGINT, request_break);
 #ifndef ETHR_UNUSABLE_SIGUSRX
-   sys_sigset(SIGUSR1, user_signal1);
-#ifdef QUANTIFY
-   sys_sigset(SIGUSR2, user_signal2);
-#endif
+   sys_signal(SIGUSR1, user_signal1);
+#ifdef ERTS_SMP
+   sys_signal(ERTS_SYS_SUSPEND_SIGNAL, suspend_signal);
+#endif /* #ifdef ERTS_SMP */
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
-   sys_sigset(SIGQUIT, do_quit);
+   sys_signal(SIGQUIT, do_quit);
 }
 
 int sys_max_files(void)
@@ -953,8 +987,13 @@ static void block_signals(void)
    sys_sigblock(SIGINT);
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_sigblock(SIGUSR1);
+#endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
+#endif /* #ifndef ERTS_SMP */
+
+#if defined(ERTS_SMP) && !defined(ETHR_UNUSABLE_SIGUSRX)
+   sys_sigblock(ERTS_SYS_SUSPEND_SIGNAL);
 #endif
-#endif
+
 }
 
 static void unblock_signals(void)
@@ -968,26 +1007,13 @@ static void unblock_signals(void)
 #ifndef ETHR_UNUSABLE_SIGUSRX
    sys_sigrelease(SIGUSR1);
 #endif /* #ifndef ETHR_UNUSABLE_SIGUSRX */
+#endif /* #ifndef ERTS_SMP */
+
+#if defined(ERTS_SMP) && !defined(ETHR_UNUSABLE_SIGUSRX)
+   sys_sigrelease(ERTS_SYS_SUSPEND_SIGNAL);
 #endif
-}
-/************************** Time stuff **************************/
-#ifdef HAVE_GETHRTIME
-#ifdef GETHRTIME_WITH_CLOCK_GETTIME
 
-SysHrTime sys_gethrtime(void)
-{
-    struct timespec ts;
-    long long result;
-    if (clock_gettime(CLOCK_MONOTONIC,&ts) != 0) {
-	erl_exit(1,"Fatal, could not get clock_monotonic value!, "
-		 "errno = %d\n", errno);
-    }
-    result = ((long long) ts.tv_sec) * 1000000000LL + 
-	((long long) ts.tv_nsec);
-    return (SysHrTime) result;
 }
-#endif
-#endif
 
 /************************** OS info *******************************/
 
@@ -1094,11 +1120,16 @@ void fini_getenv_state(GETENV_STATE *state)
 /* Driver interfaces */
 static ErlDrvData spawn_start(ErlDrvPort, char*, SysDriverOpts*);
 static ErlDrvData fd_start(ErlDrvPort, char*, SysDriverOpts*);
+#if FDBLOCK
+static void fd_async(void *);
+static void fd_ready_async(ErlDrvData drv_data, ErlDrvThreadData thread_data);
+#endif
 static ErlDrvSSizeT fd_control(ErlDrvData, unsigned int, char *, ErlDrvSizeT,
 			       char **, ErlDrvSizeT);
 static ErlDrvData vanilla_start(ErlDrvPort, char*, SysDriverOpts*);
 static int spawn_init(void);
 static void fd_stop(ErlDrvData);
+static void fd_flush(ErlDrvData);
 static void stop(ErlDrvData);
 static void ready_input(ErlDrvData, ErlDrvEvent);
 static void ready_output(ErlDrvData, ErlDrvEvent);
@@ -1143,8 +1174,12 @@ struct erl_drv_entry fd_driver_entry = {
     fd_control,
     NULL,
     outputv,
-    NULL, /* ready_async */
-    NULL, /* flush */
+#if FDBLOCK
+    fd_ready_async, /* ready_async */
+#else
+    NULL,
+#endif
+    fd_flush, /* flush */
     NULL, /* call */
     NULL, /* event */
     ERL_DRV_EXTENDED_MARKER,
@@ -1198,13 +1233,28 @@ static RETSIGTYPE onchld(int signum)
 #endif
 }
 
+static int set_blocking_data(struct driver_data *dd) {
+
+    dd->blocking = erts_alloc(ERTS_ALC_T_SYS_BLOCKING, sizeof(ErtsSysBlocking));
+
+    erts_smp_atomic_add_nob(&sys_misc_mem_sz, sizeof(ErtsSysBlocking));
+
+    dd->blocking->pdl = driver_pdl_create(dd->port_num);
+    dd->blocking->res = 0;
+    dd->blocking->err = 0;
+    dd->blocking->pkey = driver_async_port_key(dd->port_num);
+
+    return 1;
+}
+
 static int set_driver_data(ErlDrvPort port_num,
 			   int ifd,
 			   int ofd,
 			   int packet_bytes,
 			   int read_write,
 			   int exit_status,
-			   int pid)
+			   int pid,
+                           int is_blocking)
 {
     Port *prt;
     ErtsSysReportExit *report_exit;
@@ -1236,8 +1286,13 @@ static int set_driver_data(ErlDrvPort port_num,
 	driver_data[ifd].pid = pid;
 	driver_data[ifd].alive = 1;
 	driver_data[ifd].status = 0;
+        driver_data[ifd].terminating = 0;
+        driver_data[ifd].blocking = NULL;
 	if (read_write & DO_WRITE) {
 	    driver_data[ifd].ofd = ofd;
+            if (is_blocking && FDBLOCK)
+                if (!set_blocking_data(driver_data+ifd))
+                    return -1;
 	    if (ifd != ofd)
 		driver_data[ofd] = driver_data[ifd];  /* structure copy */
 	} else {		/* DO_READ only */
@@ -1253,6 +1308,11 @@ static int set_driver_data(ErlDrvPort port_num,
 	driver_data[ofd].pid = pid;
 	driver_data[ofd].alive = 1;
 	driver_data[ofd].status = 0;
+        driver_data[ofd].terminating = 0;
+        driver_data[ofd].blocking = NULL;
+        if (is_blocking && FDBLOCK)
+            if (!set_blocking_data(driver_data+ofd))
+                return -1;
 	return(ofd);
     }
 }
@@ -1262,11 +1322,13 @@ static int spawn_init()
    int i;
 #if CHLDWTHR
    erts_thr_opts_t thr_opts = ERTS_THR_OPTS_DEFAULT_INITER;
+
    thr_opts.detached = 0;
    thr_opts.suggested_stack_size = 0; /* Smallest possible */
+   thr_opts.name = "child_waiter";
 #endif
 
-   sys_sigset(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
+   sys_signal(SIGPIPE, SIG_IGN); /* Ignore - we'll handle the write failure */
    driver_data = (struct driver_data *)
        erts_alloc(ERTS_ALC_T_DRV_TAB, max_files * sizeof(struct driver_data));
    erts_smp_atomic_add_nob(&sys_misc_mem_sz,
@@ -1279,7 +1341,7 @@ static int spawn_init()
    sys_sigblock(SIGCHLD);
 #endif
 
-   sys_sigset(SIGCHLD, onchld); /* Reap children */
+   sys_signal(SIGCHLD, onchld); /* Reap children */
 
 #if CHLDWTHR
    erts_thr_create(&child_waiter_tid, child_waiter, NULL, &thr_opts);
@@ -1745,7 +1807,7 @@ static ErlDrvData spawn_start(ErlDrvPort port_num, char* name, SysDriverOpts* op
     }
 
     res = set_driver_data(port_num, ifd[0], ofd[1], opts->packet_bytes,
-			  opts->read_write, opts->exit_status, pid);
+			  opts->read_write, opts->exit_status, pid, 0);
     /* Don't unblock SIGCHLD until now, since the call above must
        first complete putting away the info about our new subprocess. */
     unblock_signals();
@@ -1830,6 +1892,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 			   SysDriverOpts* opts)
 {
     ErlDrvData res;
+    int non_blocking = 0;
 
     if (((opts->read_write & DO_READ) && opts->ifd >= max_files) ||
 	((opts->read_write & DO_WRITE) && opts->ofd >= max_files))
@@ -1902,6 +1965,20 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
      * case - it can be called with any old pre-existing file descriptors,
      * the relations between which (if they're even two) we can only guess
      * at - still, we try our best...
+     *
+     * Added note OTP 18: Some systems seem to use stdout/stderr to log data
+     * using unix pipes, so we cannot allow the system to block on a write.
+     * Therefore we use an async thread to write the data to fd's that could
+     * not be set to non-blocking. When no async threads are available we
+     * fall back on the old behaviour.
+     *
+     * Also the guarantee about what is delivered to the OS has changed.
+     * Pre 18 the fd driver did no flushing of data before terminating.
+     * Now it does. This is because we want to be able to guarantee that things
+     * such as escripts and friends really have outputted all data before
+     * terminating. This could potentially block the termination of the system
+     * for a very long time, but if the user wants to terminate fast she should
+     * use erlang:halt with flush=false.
      */
 
     if (opts->read_write & DO_READ) {
@@ -1924,6 +2001,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 		       imagine a scenario where setting non-blocking mode
 		       here would cause problems - go ahead and do it. */
 
+                    non_blocking = 1;
 		    SET_NONBLOCKING(opts->ofd);
 
 		} else {	/* output fd is a tty, input fd isn't */
@@ -1966,6 +2044,7 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
 			(nfd = open(tty, O_WRONLY)) != -1) {
 			dup2(nfd, opts->ofd);
 			close(nfd);
+                        non_blocking = 1;
 			SET_NONBLOCKING(opts->ofd);
 		    }
 		}
@@ -1974,8 +2053,9 @@ static ErlDrvData fd_start(ErlDrvPort port_num, char* name,
     }
     CHLD_STAT_LOCK;
     res = (ErlDrvData)(long)set_driver_data(port_num, opts->ifd, opts->ofd,
-				      opts->packet_bytes,
-				      opts->read_write, 0, -1);
+                                            opts->packet_bytes,
+                                            opts->read_write, 0, -1,
+                                            !non_blocking);
     CHLD_STAT_UNLOCK;
     return res;
 }
@@ -2001,14 +2081,30 @@ static void nbio_stop_fd(ErlDrvPort prt, int fd)
     SET_BLOCKING(fd);
 }
 
-static void fd_stop(ErlDrvData fd)  /* Does not close the fds */
+static void fd_stop(ErlDrvData ev)  /* Does not close the fds */
 {
     int ofd;
+    int fd = (int)(long)ev;
+    ErlDrvPort prt = driver_data[fd].port_num;
     
-    nbio_stop_fd(driver_data[(int)(long)fd].port_num, (int)(long)fd);
-    ofd = driver_data[(int)(long)fd].ofd;
-    if (ofd != (int)(long)fd && ofd != -1) 
-	nbio_stop_fd(driver_data[(int)(long)fd].port_num, (int)(long)ofd);
+#if FDBLOCK
+    if (driver_data[fd].blocking) {
+        erts_free(ERTS_ALC_T_SYS_BLOCKING,driver_data[fd].blocking);
+        driver_data[fd].blocking = NULL;
+        erts_smp_atomic_add_nob(&sys_misc_mem_sz, -1*sizeof(ErtsSysBlocking));
+    }
+#endif
+
+    nbio_stop_fd(prt, fd);
+    ofd = driver_data[fd].ofd;
+    if (ofd != fd && ofd != -1)
+	nbio_stop_fd(prt, ofd);
+}
+
+static void fd_flush(ErlDrvData fd)
+{
+    if (!driver_data[(int)(long)fd].terminating)
+        driver_data[(int)(long)fd].terminating = 1;
 }
 
 static ErlDrvData vanilla_start(ErlDrvPort port_num, char* name,
@@ -2031,8 +2127,8 @@ static ErlDrvData vanilla_start(ErlDrvPort port_num, char* name,
 
     CHLD_STAT_LOCK;
     res = (ErlDrvData)(long)set_driver_data(port_num, fd, fd,
-				      opts->packet_bytes,
-				      opts->read_write, 0, -1);
+                                            opts->packet_bytes,
+                                            opts->read_write, 0, -1, 0);
     CHLD_STAT_UNLOCK;
     return res;
 }
@@ -2069,6 +2165,7 @@ static void stop(ErlDrvData fd)
     }
 }
 
+/* used by fd_driver */
 static void outputv(ErlDrvData e, ErlIOVec* ev)
 {
     int fd = (int)(long)e;
@@ -2094,12 +2191,21 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
     ev->iov[0].iov_base = lbp;
     ev->iov[0].iov_len = pb;
     ev->size += pb;
+
+    if (driver_data[fd].blocking && FDBLOCK)
+        driver_pdl_lock(driver_data[fd].blocking->pdl);
+
     if ((sz = driver_sizeq(ix)) > 0) {
 	driver_enqv(ix, ev, 0);
+
+        if (driver_data[fd].blocking && FDBLOCK)
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+
 	if (sz + ev->size >= (1 << 13))
 	    set_busy_port(ix, 1);
     }
-    else {
+    else if (!driver_data[fd].blocking || !FDBLOCK) {
+        /* We try to write directly if the fd in non-blocking */
 	int vsize = ev->vsize > MAX_VSIZE ? MAX_VSIZE : ev->vsize;
 
 	n = writev(ofd, (const void *) (ev->iov), vsize);
@@ -2115,10 +2221,22 @@ static void outputv(ErlDrvData e, ErlIOVec* ev)
 	driver_enqv(ix, ev, n);  /* n is the skip value */
 	driver_select(ix, ofd, ERL_DRV_WRITE|ERL_DRV_USE, 1);
     }
+#if FDBLOCK
+    else {
+        if (ev->size != 0) {
+            driver_enqv(ix, ev, 0);
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+            driver_async(ix, &driver_data[fd].blocking->pkey,
+                         fd_async, driver_data+fd, NULL);
+        } else {
+            driver_pdl_unlock(driver_data[fd].blocking->pdl);
+        }
+    }
+#endif
     /* return 0;*/
 }
 
-
+/* Used by spawn_driver and vanilla driver */
 static void output(ErlDrvData e, char* buf, ErlDrvSizeT len)
 {
     int fd = (int)(long)e;
@@ -2181,6 +2299,23 @@ static int port_inp_failure(ErlDrvPort port_num, int ready_fd, int res)
     ASSERT(res <= 0);
     (void) driver_select(port_num, ready_fd, ERL_DRV_READ|ERL_DRV_WRITE, 0); 
     clear_fd_data(ready_fd);
+
+    if (driver_data[ready_fd].blocking && FDBLOCK) {
+        driver_pdl_lock(driver_data[ready_fd].blocking->pdl);
+        if (driver_sizeq(driver_data[ready_fd].port_num) > 0) {
+            driver_pdl_unlock(driver_data[ready_fd].blocking->pdl);
+            /* We have stuff in the output queue, so we just
+               set the state to terminating and wait for fd_async_ready
+               to terminate the port */
+            if (res == 0)
+                driver_data[ready_fd].terminating = 2;
+            else
+                driver_data[ready_fd].terminating = -err;
+            return 0;
+        }
+        driver_pdl_unlock(driver_data[ready_fd].blocking->pdl);
+    }
+
     if (res == 0) {
 	if (driver_data[ready_fd].report_exit) {
 	    CHLD_STAT_LOCK;
@@ -2231,6 +2366,7 @@ static void ready_input(ErlDrvData e, ErlDrvEvent ready_fd)
     port_num = driver_data[fd].port_num;
     packet_bytes = driver_data[fd].packet_bytes;
 
+
     if (packet_bytes == 0) {
 	byte *read_buf = (byte *) erts_alloc(ERTS_ALC_T_SYS_READ_BUF,
 					     ERTS_SYS_READ_BUF_SZ);
@@ -2354,6 +2490,8 @@ static void ready_output(ErlDrvData e, ErlDrvEvent ready_fd)
 
     if ((iv = (struct iovec*) driver_peekq(ix, &vsize)) == NULL) {
 	driver_select(ix, ready_fd, ERL_DRV_WRITE, 0);
+        if (driver_data[fd].terminating)
+            driver_failure_atom(driver_data[fd].port_num,"normal");
 	return; /* 0; */
     }
     vsize = vsize > MAX_VSIZE ? MAX_VSIZE : vsize;
@@ -2379,6 +2517,86 @@ static void stop_select(ErlDrvEvent fd, void* _)
     close((int)fd);
 }
 
+#if FDBLOCK
+
+static void
+fd_async(void *async_data)
+{
+    int res;
+    struct driver_data *dd = (struct driver_data*)async_data;
+    SysIOVec      *iov0;
+    SysIOVec      *iov;
+    int            iovlen;
+    int            err = 0;
+    /* much of this code is stolen from efile_drv:invoke_writev */
+    driver_pdl_lock(dd->blocking->pdl);
+    iov0 = driver_peekq(dd->port_num, &iovlen);
+    iovlen = iovlen < MAXIOV ? iovlen : MAXIOV;
+    iov = erts_alloc_fnf(ERTS_ALC_T_SYS_WRITE_BUF,
+                         sizeof(SysIOVec)*iovlen);
+    if (!iov) {
+        res = -1;
+        err = ENOMEM;
+        driver_pdl_unlock(dd->blocking->pdl);
+    } else {
+        memcpy(iov,iov0,iovlen*sizeof(SysIOVec));
+        driver_pdl_unlock(dd->blocking->pdl);
+
+        do {
+            res = writev(dd->ofd, iov, iovlen);
+        } while (res < 0 && errno == EINTR);
+        if (res < 0)
+            err = errno;
+
+        erts_free(ERTS_ALC_T_SYS_WRITE_BUF, iov);
+    }
+    dd->blocking->res = res;
+    dd->blocking->err = err;
+}
+
+void fd_ready_async(ErlDrvData drv_data,
+                    ErlDrvThreadData thread_data) {
+    struct driver_data *dd = (struct driver_data *)thread_data;
+    ErlDrvPort port_num = dd->port_num;
+
+    ASSERT(dd->blocking);
+    ASSERT(dd == (driver_data + (int)(long)drv_data));
+
+    if (dd->blocking->res > 0) {
+        driver_pdl_lock(dd->blocking->pdl);
+        if (driver_deq(port_num, dd->blocking->res) == 0) {
+            driver_pdl_unlock(dd->blocking->pdl);
+            set_busy_port(port_num, 0);
+            if (dd->terminating) {
+                /* The port is has been ordered to terminate
+                   from either fd_flush or port_inp_failure */
+                if (dd->terminating == 1)
+                    driver_failure_atom(port_num, "normal");
+                else if (dd->terminating == 2)
+                    driver_failure_eof(port_num);
+                else if (dd->terminating < 0)
+                    driver_failure_posix(port_num, -dd->terminating);
+                return; /* -1; */
+            }
+        } else {
+            driver_pdl_unlock(dd->blocking->pdl);
+            /* still data left to write in queue */
+            driver_async(port_num, &dd->blocking->pkey, fd_async, dd, NULL);
+            return /* 0; */;
+        }
+    } else if (dd->blocking->res < 0) {
+        if (dd->blocking->err == ERRNO_BLOCK) {
+            set_busy_port(port_num, 1);
+            /* still data left to write in queue */
+            driver_async(port_num, &dd->blocking->pkey, fd_async, dd, NULL);
+        } else
+            driver_failure_posix(port_num, dd->blocking->err);
+        return; /* -1; */
+    }
+    return; /* 0; */
+}
+
+#endif
 
 void erts_do_break_handling(void)
 {
@@ -2648,18 +2866,30 @@ void sys_preload_end(Preload* p)
     /* Nothing */
 }
 
-/* Read a key from console (?) */
-
+/* Read a key from console, used by break.c
+   Here we assume that all schedulers are stopped so that erl_poll
+   does not interfere with the select below.
+*/
 int sys_get_key(fd)
 int fd;
 {
-    int c;
+    int c, ret;
     unsigned char rbuf[64];
+    fd_set fds;
 
     fflush(stdout);		/* Flush query ??? */
 
-    if ((c = read(fd,rbuf,64)) <= 0) {
-      return c; 
+    FD_ZERO(&fds);
+    FD_SET(fd,&fds);
+
+    ret = select(fd+1, &fds, NULL, NULL, NULL);
+
+    if (ret == 1) {
+        do {
+            c = read(fd,rbuf,64);
+        } while (c < 0 && errno == EAGAIN);
+        if (c <= 0)
+            return c;
     }
 
     return rbuf[0]; 
@@ -2983,13 +3213,6 @@ signal_dispatcher_thread_func(void *unused)
 	    case '1': /* SIGUSR1 */
 		sigusr1_exit();
 		break;
-#ifdef QUANTIFY
-	    case '2': /* SIGUSR2 */
-		quantify_save_data(); /* Might take a substantial amount of
-					 time, but this is a test/debug
-					 build */
-		break;
-#endif
 	    default:
 		erl_exit(ERTS_ABORT_EXIT,
 			 "signal-dispatcher thread received unknown "
@@ -3007,6 +3230,7 @@ init_smp_sig_notify(void)
 {
     erts_smp_thr_opts_t thr_opts = ERTS_SMP_THR_OPTS_DEFAULT_INITER;
     thr_opts.detached = 1;
+    thr_opts.name = "sys_sig_dispatcher";
 
     if (pipe(sig_notify_fds) < 0) {
 	erl_exit(ERTS_ABORT_EXIT,
@@ -3021,6 +3245,17 @@ init_smp_sig_notify(void)
 			NULL,
 			&thr_opts);
 }
+
+static void
+init_smp_sig_suspend(void) {
+  if (pipe(sig_suspend_fds) < 0) {
+    erl_exit(ERTS_ABORT_EXIT,
+	     "Failed to create sig_suspend pipe: %s (%d)\n",
+	     erl_errno_id(errno),
+	     errno);
+  }
+}
+
 #ifdef __DARWIN__
 
 int erts_darwin_main_thread_pipe[2];
@@ -3048,9 +3283,11 @@ erts_sys_main_thread(void)
 #endif
 
     smp_sig_notify(0); /* Notify initialized */
-    while (1) {
-	/* Wait for a signal to arrive... */
+
+    /* Wait for a signal to arrive... */
+
 #ifdef __DARWIN__
+    while (1) {
 	/*
 	 * The wx driver needs to be able to steal the main thread for Cocoa to
 	 * work properly.
@@ -3065,12 +3302,24 @@ erts_sys_main_thread(void)
 	    void* (*func)(void*);
 	    void* arg;
 	    void *resp;
-	    read(erts_darwin_main_thread_pipe[0],&func,sizeof(void* (*)(void*)));
-	    read(erts_darwin_main_thread_pipe[0],&arg, sizeof(void*));
+            res = read(erts_darwin_main_thread_pipe[0],&func,sizeof(void* (*)(void*)));
+            if (res != sizeof(void* (*)(void*)))
+                break;
+            res = read(erts_darwin_main_thread_pipe[0],&arg,sizeof(void*));
+            if (res != sizeof(void*))
+                break;
 	    resp = (*func)(arg);
 	    write(erts_darwin_main_thread_result_pipe[1],&resp,sizeof(void *));
 	}
-#else
+
+        if (res == -1 && errno != EINTR)
+            break;
+    }
+    /* Something broke with the main thread pipe, so we ignore it for now.
+       Most probably erts has closed this pipe and is about to exit. */
+#endif /* #ifdef __DARWIN__ */
+
+    while (1) {
 #ifdef DEBUG
 	int res =
 #else
@@ -3079,7 +3328,6 @@ erts_sys_main_thread(void)
 	    select(0, NULL, NULL, NULL, NULL);
 	ASSERT(res < 0);
 	ASSERT(errno == EINTR);
-#endif
     }
 }
 
@@ -3171,6 +3419,7 @@ erl_sys_args(int* argc, char** argv)
 
 #ifdef ERTS_SMP
     init_smp_sig_notify();
+    init_smp_sig_suspend();
 #endif
 
     /* Handled arguments have been marked with NULL. Slide arguments
diff --git a/erts/emulator/sys/unix/sys_float.c b/erts/emulator/sys/unix/sys_float.c
index cafeab547e..1ef9e5eef7 100644
--- a/erts/emulator/sys/unix/sys_float.c
+++ b/erts/emulator/sys/unix/sys_float.c
@@ -3,16 +3,17 @@
  *
  * Copyright Ericsson AB 2001-2013. 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/.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * 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.
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
  * %CopyrightEnd%
  */
@@ -32,7 +33,7 @@ void
 erts_sys_init_float(void)
 {
 # ifdef SIGFPE
-    sys_sigset(SIGFPE, SIG_IGN); /* Ignore so we can test for NaN and Inf */
+    sys_signal(SIGFPE, SIG_IGN); /* Ignore so we can test for NaN and Inf */
 # endif
 }
 
@@ -85,7 +86,7 @@ static void set_current_fp_exception(unsigned long pc)
 
 void erts_fp_check_init_error(volatile unsigned long *fpexnp)
 {
-    char buf[64];
+    char buf[128];
     snprintf(buf, sizeof buf, "ERTS_FP_CHECK_INIT at %p: detected unhandled FPE at %p\r\n",
 	     __builtin_return_address(0), (void*)*fpexnp);
     if (write(2, buf, strlen(buf)) <= 0)
@@ -667,7 +668,7 @@ static void fpe_sig_handler(int sig)
 
 static void erts_thread_catch_fp_exceptions(void)
 {
-    sys_sigset(SIGFPE, fpe_sig_handler);
+    sys_signal(SIGFPE, fpe_sig_handler);
     unmask_fpe();
 }
 
diff --git a/erts/emulator/sys/unix/sys_time.c b/erts/emulator/sys/unix/sys_time.c
index fcce54a2c4..2e1914f564 100644
--- a/erts/emulator/sys/unix/sys_time.c
+++ b/erts/emulator/sys/unix/sys_time.c
@@ -3,16 +3,17 @@
  * 
  * Copyright Ericsson AB 2005-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.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * %CopyrightEnd%
  */
@@ -31,8 +32,21 @@
 #  undef _FILE_OFFSET_BITS
 #endif
 
+#include <stdlib.h>
 #include "sys.h"
 #include "global.h"
+#include "erl_os_monotonic_time_extender.h"
+
+#undef ERTS_HAVE_ERTS_OS_TIMES_IMPL__
+#undef ERTS_HAVE_ERTS_SYS_HRTIME_IMPL__
+
+#if defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME) \
+    || defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME) \
+    || defined(SYS_HRTIME_USING_MACH_CLOCK_GET_TIME)
+#  include <mach/clock.h>
+#  include <mach/mach.h>
+#  define ERTS_MACH_CLOCKS
+#endif
 
 #ifdef NO_SYSCONF
 #  define TICKS_PER_SEC()	HZ
@@ -53,9 +67,23 @@
 
 /******************* Routines for time measurement *********************/
 
-int erts_ticks_per_sec = 0; /* Will be SYS_CLK_TCK in erl_unix_sys.h */
-int erts_ticks_per_sec_wrap = 0; /* Will be SYS_CLK_TCK_WRAP */
-static int ticks_bsr = 0; /* Shift wrapped tick value this much to the right */
+#undef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+#undef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+#undef ERTS_SYS_TIME_INTERNAL_STATE_READ_MOSTLY__
+
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+
+static Uint32
+get_tick_count(void)
+{
+    struct tms unused;
+    return (Uint32) times(&unused);
+}
+
+#define ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+#define ERTS_SYS_TIME_INTERNAL_STATE_READ_MOSTLY__
+
+#endif
 
 /* 
  * init timers, chose a tick length, and return it.
@@ -63,37 +91,824 @@ static int ticks_bsr = 0; /* Shift wrapped tick value this much to the right */
  * does almost everything. Other platforms have to
  * emulate Unix in this sense.
  */
-int sys_init_time(void)
+
+ErtsSysTimeData__ erts_sys_time_data__ erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+
+#define ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+
+static ErtsMonotonicTime clock_gettime_monotonic(void);
+static ErtsMonotonicTime clock_gettime_monotonic_verified(void);
+#if defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
+static ErtsMonotonicTime clock_gettime_monotonic_raw(void);
+#endif
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+static void clock_gettime_times(ErtsMonotonicTime *, ErtsSystemTime *);
+static void clock_gettime_times_verified(ErtsMonotonicTime *, ErtsSystemTime *);
+#if defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
+static void clock_gettime_times_raw(ErtsMonotonicTime *, ErtsSystemTime *);
+#endif
+#endif
+
+#endif /* defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME) */
+
+#ifdef ERTS_MACH_CLOCKS
+#  define ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+typedef struct {
+    clock_id_t id;
+    clock_serv_t srv;
+    char *name;
+} ErtsMachClock;
+
+typedef struct {
+    host_name_port_t host;
+    struct {
+	ErtsMachClock monotonic;
+	ErtsMachClock wall;
+    } clock;
+} ErtsMachClocks;
+static void mach_clocks_init(void);
+static void mach_clocks_fini(void);
+#  ifdef HAVE_CLOCK_GET_ATTRIBUTES
+#    define ERTS_HAVE_MACH_CLOCK_GETRES
+static Sint64
+mach_clock_getres(ErtsMachClock *clk);
+#  endif    
+#endif /* ERTS_MACH_CLOCKS */
+
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+struct sys_time_internal_state_read_only__ {
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+    int times_shift;
+#endif
+#ifdef ERTS_MACH_CLOCKS
+    ErtsMachClocks mach;
+#endif
+};
+#endif
+
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_MOSTLY__
+struct sys_time_internal_state_read_mostly__ {
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+    ErtsOsMonotonicTimeExtendState os_mtime_xtnd;
+#endif
+};
+#endif
+
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+struct sys_time_internal_state_write_freq__ {
+    erts_smp_mtx_t mtx;
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    ErtsMonotonicTime last_delivered;
+#endif
+};
+#endif
+
+#if defined(ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__)	\
+    || defined(ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__)
+static struct {
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_ONLY__
+    union {
+	struct sys_time_internal_state_read_only__ o;
+	char align__[(((sizeof(struct sys_time_internal_state_read_only__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } r;
+#endif
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_READ_MOSTLY__
+    union {
+	struct sys_time_internal_state_read_mostly__ m;
+	char align__[(((sizeof(struct sys_time_internal_state_read_mostly__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } wr;
+#endif
+#ifdef ERTS_SYS_TIME_INTERNAL_STATE_WRITE_FREQ__
+    union {
+	struct sys_time_internal_state_write_freq__ f;
+	char align__[(((sizeof(struct sys_time_internal_state_write_freq__) - 1)
+		       / ASSUMED_CACHE_LINE_SIZE) + 1)
+		     * ASSUMED_CACHE_LINE_SIZE];
+    } w;
+#endif
+} internal_state erts_align_attribute(ERTS_CACHE_LINE_SIZE);
+#endif
+
+void
+sys_init_time(ErtsSysInitTimeResult *init_resp)
 {
+#if defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
+    int major, minor, build, vsn;
+#endif
+#if defined(ERTS_MACH_CLOCKS)
+    mach_clocks_init();
+#endif
+#if !defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
+
+    init_resp->have_os_monotonic_time = 0;
+
+#else /* defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT) */
+
+#ifdef ERTS_HAVE_CORRECTED_OS_MONOTONIC_TIME
+    init_resp->have_corrected_os_monotonic_time = 1;
+#else
+    init_resp->have_corrected_os_monotonic_time = 0;
+#endif
+
+    init_resp->os_monotonic_time_info.resolution = (Uint64) 1000*1000*1000;
+#if defined(HAVE_CLOCK_GETRES) && defined(MONOTONIC_CLOCK_ID)
+    {
+	struct timespec ts;
+	if (clock_getres(MONOTONIC_CLOCK_ID, &ts) == 0) {
+	    if (ts.tv_sec == 0 && ts.tv_nsec != 0)
+		init_resp->os_monotonic_time_info.resolution /= ts.tv_nsec;
+	    else if (ts.tv_sec >= 1)
+		init_resp->os_monotonic_time_info.resolution = 1;
+	}
+    }
+#elif defined(ERTS_HAVE_MACH_CLOCK_GETRES) && defined(MONOTONIC_CLOCK_ID)
+    init_resp->os_monotonic_time_info.resolution
+	= mach_clock_getres(&internal_state.r.o.mach.clock.monotonic);
+#endif
+
+#ifdef MONOTONIC_CLOCK_ID_STR
+    init_resp->os_monotonic_time_info.clock_id = MONOTONIC_CLOCK_ID_STR;
+#else
+    init_resp->os_monotonic_time_info.clock_id = NULL;
+#endif
+
+    init_resp->os_monotonic_time_info.locked_use = 0;
+
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    init_resp->os_monotonic_time_info.func = "clock_gettime";
+#elif defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+    init_resp->os_monotonic_time_info.func = "clock_get_time";
+#elif defined(OS_MONOTONIC_TIME_USING_GETHRTIME)
+    init_resp->os_monotonic_time_info.func = "gethrtime";
+#elif defined(OS_MONOTONIC_TIME_USING_TIMES)
+    init_resp->os_monotonic_time_info.func = "times";
+#else
+# error Unknown erts_os_monotonic_time() implementation
+#endif
+
+    init_resp->have_os_monotonic_time = 1;
+
+    os_version(&major, &minor, &build);
+
+    vsn = ERTS_MK_VSN_INT(major, minor, build);
+
+
+#if defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+    if (vsn >= ERTS_MK_VSN_INT(2, 6, 33)) {
+	erts_sys_time_data__.r.o.os_monotonic_time =
+	    clock_gettime_monotonic;
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+	erts_sys_time_data__.r.o.os_times =
+	    clock_gettime_times;
+#endif
+    }
+    else {
+	/*
+	 * Linux versions prior to 2.6.33 have a
+	 * known bug that sometimes cause the NTP
+	 * adjusted monotonic clock to take small
+	 * steps backwards. Use raw monotonic clock
+	 * if it is present; otherwise, fall back
+	 * on locked verification of values.
+	 */
+	init_resp->have_corrected_os_monotonic_time = 0;
+#if defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
+	/* We know that CLOCK_MONOTONIC_RAW is defined,
+	   but we don't know if we got a kernel that
+	   supports it. Support for CLOCK_MONOTONIC_RAW
+	   appeared in kernel 2.6.28... */
+	if (vsn >= ERTS_MK_VSN_INT(2, 6, 28)) {
+	    erts_sys_time_data__.r.o.os_monotonic_time =
+		clock_gettime_monotonic_raw;
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+	    erts_sys_time_data__.r.o.os_times =
+		clock_gettime_times_raw;
+#endif
+	    init_resp->os_monotonic_time_info.clock_id =
+		"CLOCK_MONOTONIC_RAW";
+	}
+	else
+#endif /* defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW) */
+	{
+	    erts_sys_time_data__.r.o.os_monotonic_time =
+		clock_gettime_monotonic_verified;
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+	    erts_sys_time_data__.r.o.os_times =
+		clock_gettime_times_verified;
+#endif
+	    erts_smp_mtx_init(&internal_state.w.f.mtx,
+			      "os_monotonic_time");
+	    internal_state.w.f.last_delivered
+		= clock_gettime_monotonic();
+	    init_resp->os_monotonic_time_info.locked_use = 1;
+	}
+    }
+#else /* !(defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)) */
+    {
+	char flavor[1024];
+
+	os_flavor(flavor, sizeof(flavor));
+
+	if (sys_strcmp(flavor, "sunos") == 0) {
+	    /*
+	     * Don't trust hrtime on multi processors
+	     * on SunOS prior to SunOS 5.8
+	     */
+	    if (vsn < ERTS_MK_VSN_INT(5, 8, 0)) {
+#if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_CONF)
+		if (sysconf(_SC_NPROCESSORS_CONF) > 1)
+#endif
+		    init_resp->have_os_monotonic_time = 0;
+	    }
+	}
+    }
+#endif /* !(defined(__linux__) && defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)) */
+
+#endif /* defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT) */
+
+#ifdef ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+    init_resp->os_monotonic_time_unit = ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT;
+#endif
+    init_resp->sys_clock_resolution = SYS_CLOCK_RESOLUTION;
+
     /* 
-     * This (erts_ticks_per_sec) is only for times() (CLK_TCK), 
-     * the resolution is always one millisecond..
+     * This (erts_sys_time_data__.r.o.ticks_per_sec) is only for
+     * times() (CLK_TCK), the resolution is always one millisecond..
      */
-    if ((erts_ticks_per_sec = TICKS_PER_SEC()) < 0)
-	erl_exit(1, "Can't get clock ticks/sec\n");
-    if (erts_ticks_per_sec >= 1000) {
-	/* Workaround for beta linux kernels, need to be done in runtime
-	   to make erlang run on both 2.4 and 2.5 kernels. In the future, 
-	   the kernel ticks might as 
-	   well be used as a high res timer instead, but that's for when the 
-	   majority uses kernels with HZ == 1024 */
-	ticks_bsr = 3;
-    } else {
-	ticks_bsr = 0;
+    if ((erts_sys_time_data__.r.o.ticks_per_sec = TICKS_PER_SEC()) < 0)
+	erl_exit(ERTS_ABORT_EXIT, "Can't get clock ticks/sec\n");
+    
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+#if ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT
+#  error Time unit is supposed to be determined at runtime...
+#endif
+    {
+	ErtsMonotonicTime resolution = erts_sys_time_data__.r.o.ticks_per_sec;
+	ErtsMonotonicTime time_unit = resolution;
+	int shift = 0;
+
+	while (time_unit < 1000*1000) {
+	    time_unit <<= 1;
+	    shift++;
+	}
+
+	init_resp->os_monotonic_time_info.resolution = resolution;
+	init_resp->os_monotonic_time_unit = time_unit;
+	init_resp->os_monotonic_time_info.extended = 1;
+	internal_state.r.o.times_shift = shift;
+
+	erts_init_os_monotonic_time_extender(&internal_state.wr.m.os_mtime_xtnd,
+					     get_tick_count,
+					     (1 << 29) / resolution);
+    }
+#endif /* defined(OS_MONOTONIC_TIME_USING_TIMES) */
+
+#ifdef WALL_CLOCK_ID_STR
+    init_resp->os_system_time_info.clock_id = WALL_CLOCK_ID_STR;
+#else
+    init_resp->os_system_time_info.clock_id = NULL;
+#endif
+
+    init_resp->os_system_time_info.locked_use = 0;
+    init_resp->os_system_time_info.resolution = (Uint64) 1000*1000*1000;
+#if defined(HAVE_CLOCK_GETRES) && defined(WALL_CLOCK_ID)
+    {
+	struct timespec ts;
+	if (clock_getres(WALL_CLOCK_ID, &ts) == 0) {
+	    if (ts.tv_sec == 0 && ts.tv_nsec != 0)
+		init_resp->os_system_time_info.resolution /= ts.tv_nsec;
+	    else if (ts.tv_sec >= 1)
+		init_resp->os_system_time_info.resolution = 1;
+	}
     }
-    erts_ticks_per_sec_wrap = (erts_ticks_per_sec >> ticks_bsr);
-    return SYS_CLOCK_RESOLUTION;
+#elif defined(ERTS_HAVE_MACH_CLOCK_GETRES) && defined(WALL_CLOCK_ID)
+    init_resp->os_system_time_info.resolution
+	= mach_clock_getres(&internal_state.r.o.mach.clock.wall);
+#endif
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+    init_resp->os_system_time_info.func = "clock_gettime";
+#elif defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME)
+    init_resp->os_system_time_info.func = "clock_get_time";
+#elif defined(OS_SYSTEM_TIME_GETTIMEOFDAY)
+    init_resp->os_system_time_info.func = "gettimeofday";    
+    init_resp->os_system_time_info.resolution = 1000*1000;
+    init_resp->os_system_time_info.clock_id = NULL;
+#else
+#  error Missing erts_os_system_time() implementation
+#endif
+
+}
+
+void
+erts_late_sys_init_time(void)
+{
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+    erts_late_init_os_monotonic_time_extender(&internal_state.wr.m.os_mtime_xtnd);
+#endif
+}
+
+static ERTS_INLINE ErtsSystemTime
+adj_stime_time_unit(ErtsSystemTime stime, Uint32 res)
+{
+    if (res == ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT)
+	return stime;
+    if (res == (Uint32) 1000*1000*1000
+	&& ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT == 1000*1000)
+	return stime/1000;
+    if (res == (Uint32) 1000*1000
+	&& ERTS_COMPILE_TIME_MONOTONIC_TIME_UNIT == 1000*1000*1000)
+	return stime*1000;
+    return ((ErtsSystemTime)
+	    erts_time_unit_conversion(stime,
+				      (Uint32) res,
+				      (Uint32) ERTS_MONOTONIC_TIME_UNIT));
 }
 
-clock_t sys_times_wrap(void)
+#define ERTS_TimeSpec2Sint64(TS)				\
+    ((((Sint64) (TS)->tv_sec) * ((Sint64) 1000*1000*1000))	\
+     + ((Sint64) (TS)->tv_nsec))
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * POSIX clock_gettime()                                                     *
+\*                                                                           */
+
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME) \
+    || defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+static ERTS_INLINE Sint64
+posix_clock_gettime(clockid_t id, char *name)
+{
+    struct timespec ts;
+
+    if (clock_gettime(id, &ts) != 0) {
+	int err = errno;
+	char *errstr = err ? strerror(err) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_gettime(%s, _) failed: %s (%d)\n",
+		 name, errstr, err);
+    }
+    return ERTS_TimeSpec2Sint64(&ts);
+}
+
+#endif /* defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME) \
+	  || defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+ErtsSystemTime
+erts_os_system_time(void)
+{
+    Sint64 stime = posix_clock_gettime(WALL_CLOCK_ID,
+				       WALL_CLOCK_ID_STR);
+    return adj_stime_time_unit((ErtsSystemTime) stime,
+			       (Uint32) 1000*1000*1000);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+#if defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME)
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+#define ERTS_HAVE_ERTS_OS_TIMES_IMPL__
+
+static ERTS_INLINE void
+posix_clock_gettime_times(clockid_t mid, char *mname,
+			  ErtsMonotonicTime *mtimep,
+			  clockid_t sid, char *sname,
+			  ErtsSystemTime *stimep)
+{
+    struct timespec mts, sts;
+    int mres, sres, merr, serr;
+
+    mres = clock_gettime(mid, &mts);
+    merr = errno;
+    sres = clock_gettime(sid, &sts);
+    serr = errno;
+    
+    if (mres != 0) {
+	char *errstr = merr ? strerror(merr) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_gettime(%s, _) failed: %s (%d)\n",
+		 mname, errstr, merr);
+    }
+    if (sres != 0) {
+	char *errstr = serr ? strerror(serr) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_gettime(%s, _) failed: %s (%d)\n",
+		 sname, errstr, serr);
+    }
+
+    *mtimep = (ErtsMonotonicTime) ERTS_TimeSpec2Sint64(&mts);
+    *stimep = (ErtsSystemTime) ERTS_TimeSpec2Sint64(&sts);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+#if defined(__linux__)
+
+static ErtsMonotonicTime clock_gettime_monotonic_verified(void)
+{
+    ErtsMonotonicTime mtime;
+
+    mtime = (ErtsMonotonicTime) posix_clock_gettime(MONOTONIC_CLOCK_ID,
+						    MONOTONIC_CLOCK_ID_STR);
+
+    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    if (mtime < internal_state.w.f.last_delivered)
+	mtime = internal_state.w.f.last_delivered;
+    else
+	internal_state.w.f.last_delivered = mtime;
+    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+
+    return mtime;
+}
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+static void clock_gettime_times_verified(ErtsMonotonicTime *mtimep,
+					 ErtsSystemTime *stimep)
+{
+    posix_clock_gettime_times(MONOTONIC_CLOCK_ID,
+			      MONOTONIC_CLOCK_ID_STR,
+			      mtimep,
+			      WALL_CLOCK_ID,
+			      WALL_CLOCK_ID_STR,
+			      stimep);
+
+    erts_smp_mtx_lock(&internal_state.w.f.mtx);
+    if (*mtimep < internal_state.w.f.last_delivered)
+	*mtimep = internal_state.w.f.last_delivered;
+    else
+	internal_state.w.f.last_delivered = *mtimep;
+    erts_smp_mtx_unlock(&internal_state.w.f.mtx);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+static ErtsMonotonicTime clock_gettime_monotonic(void)
 {
-    SysTimes dummy;
-    clock_t result = (sys_times(&dummy) >> ticks_bsr);
-    return result;
+    return (ErtsMonotonicTime) posix_clock_gettime(MONOTONIC_CLOCK_ID,
+						   MONOTONIC_CLOCK_ID_STR);
 }
 
+#if defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
 
+static ErtsMonotonicTime clock_gettime_monotonic_raw(void)
+{
+    return (ErtsMonotonicTime) posix_clock_gettime(CLOCK_MONOTONIC_RAW,
+						   "CLOCK_MONOTONIC_RAW");
+}
+
+#endif /* defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW) */
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+static void clock_gettime_times(ErtsMonotonicTime *mtimep,
+				ErtsSystemTime *stimep)
+{
+    posix_clock_gettime_times(MONOTONIC_CLOCK_ID,
+			      MONOTONIC_CLOCK_ID_STR,
+			      mtimep,
+			      WALL_CLOCK_ID,
+			      WALL_CLOCK_ID_STR,
+			      stimep);
+}
+
+#if defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW)
+
+static void clock_gettime_times_raw(ErtsMonotonicTime *mtimep,
+				    ErtsSystemTime *stimep)
+{
+    posix_clock_gettime_times(CLOCK_MONOTONIC_RAW,
+			      "CLOCK_MONOTONIC_RAW",
+			      mtimep,
+			      WALL_CLOCK_ID,
+			      WALL_CLOCK_ID_STR,
+			      stimep);
+}
+
+#endif /* defined(HAVE_CLOCK_GETTIME_MONOTONIC_RAW) */
+
+#endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+#else /* !defined(__linux__) */
+
+ErtsMonotonicTime erts_os_monotonic_time(void)
+{
+    return posix_clock_gettime(MONOTONIC_CLOCK_ID,
+			       MONOTONIC_CLOCK_ID_STR);
+}
+
+#if defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME)
+
+void erts_os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+   posix_clock_gettime_times(MONOTONIC_CLOCK_ID,
+			     MONOTONIC_CLOCK_ID_STR,
+			     mtimep,
+			     WALL_CLOCK_ID,
+			     WALL_CLOCK_ID_STR,
+			     stimep);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_CLOCK_GETTIME) */
+
+#endif /* !defined(__linux__) */
+
+#endif /* defined(OS_MONOTONIC_TIME_USING_CLOCK_GETTIME) */
+
+#if defined(SYS_HRTIME_USING_CLOCK_GETTIME)
+#  define ERTS_HAVE_ERTS_SYS_HRTIME_IMPL__
+
+ErtsSysHrTime
+erts_sys_hrtime(void)
+{
+    return (ErtsSysHrTime) posix_clock_gettime(HRTIME_CLOCK_ID,
+					       HRTIME_CLOCK_ID_STR);
+}
+
+#endif /* defined(SYS_HRTIME_USING_CLOCK_GETTIME) */
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * MACH clock_get_time()                                                     *
+\*                                                                           */
+
+#if defined(ERTS_MACH_CLOCKS)
+
+static void
+mach_clocks_fini(void)
+{
+    mach_port_t task = mach_task_self();
+    mach_port_deallocate(task, internal_state.r.o.mach.host);
+#if defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+    mach_port_deallocate(task, internal_state.r.o.mach.clock.monotonic.srv);
+#endif
+#if defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME)
+    mach_port_deallocate(task, internal_state.r.o.mach.clock.wall.srv);
+#endif
+}
+
+static void
+mach_clocks_init(void)
+{
+    kern_return_t kret;
+    host_name_port_t host;
+    clock_id_t id;
+    clock_serv_t *clck_srv_p;
+    char *name;
+
+    host = internal_state.r.o.mach.host = mach_host_self();
+
+#if defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME) \
+    ||  defined(SYS_HRTIME_USING_MACH_CLOCK_GET_TIME)
+    id = internal_state.r.o.mach.clock.monotonic.id = MONOTONIC_CLOCK_ID;
+    name = internal_state.r.o.mach.clock.monotonic.name = MONOTONIC_CLOCK_ID_STR;
+    clck_srv_p = &internal_state.r.o.mach.clock.monotonic.srv;
+    kret = host_get_clock_service(host, id, clck_srv_p);
+    if (kret != KERN_SUCCESS) {
+	erl_exit(ERTS_ABORT_EXIT,
+		 "host_get_clock_service(_, %s, _) failed\n",
+		 name);
+    }
+#endif
+
+#if defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME)
+    id = internal_state.r.o.mach.clock.wall.id = WALL_CLOCK_ID;
+    name = internal_state.r.o.mach.clock.wall.name = WALL_CLOCK_ID_STR;
+    clck_srv_p = &internal_state.r.o.mach.clock.wall.srv;
+    kret = host_get_clock_service(host, id, clck_srv_p);
+    if (kret != KERN_SUCCESS) {
+	erl_exit(ERTS_ABORT_EXIT,
+		 "host_get_clock_service(_, %s, _) failed\n",
+		 name);
+    }
+#endif
+
+    if (atexit(mach_clocks_fini) != 0) {
+	int err = errno;
+	char *errstr = err ? strerror(err) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "Failed to register mach_clocks_fini() "
+		 "for call at exit: %s (%d)\n",
+		 errstr, err);
+    }
+}
+
+#ifdef ERTS_HAVE_MACH_CLOCK_GETRES
+
+static Sint64
+mach_clock_getres(ErtsMachClock *clk)
+{
+    kern_return_t kret;
+    natural_t attr[1];
+    mach_msg_type_number_t cnt;
+
+    cnt = sizeof(attr);
+    kret = clock_get_attributes(clk->srv,
+				CLOCK_GET_TIME_RES,
+				(clock_attr_t) attr,
+				&cnt);
+    if (kret != KERN_SUCCESS || cnt != 1) {
+	erl_exit(ERTS_ABORT_EXIT,	
+		 "clock_get_attributes(%s, _) failed\n",
+		 clk->name);
+    }
+
+    return (Sint64) attr[0];
+}
+
+#endif /* ERTS_HAVE_MACH_CLOCK_GETRES */
+
+static ERTS_INLINE Sint64
+mach_clock_get_time(ErtsMachClock *clk)
+{
+    kern_return_t kret;
+    mach_timespec_t time_spec;
+
+    kret = clock_get_time(clk->srv, &time_spec);
+    if (kret != KERN_SUCCESS)
+	erl_exit(ERTS_ABORT_EXIT, "clock_get_time(%s, _) failed\n", clk->name);
+
+    return ERTS_TimeSpec2Sint64(&time_spec);
+}
+
+#endif /* defined(ERTS_MACH_CLOCKS) */
+
+#if defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME)
+
+#define ERTS_HAVE_ERTS_OS_TIMES_IMPL__
+
+ErtsSystemTime
+erts_os_system_time(void)
+{
+    Sint64 stime = mach_clock_get_time(&internal_state.r.o.mach.clock.wall);
+    return adj_stime_time_unit((ErtsSystemTime) stime,
+			       (Uint32) 1000*1000*1000);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME) */
+
+#if defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME)
+
+ErtsMonotonicTime
+erts_os_monotonic_time(void)
+{
+    return (ErtsMonotonicTime)
+	mach_clock_get_time(&internal_state.r.o.mach.clock.monotonic);
+}
+
+#if defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME)
+
+#define ERTS_HAVE_ERTS_OS_TIMES_IMPL__
+
+void
+erts_os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+    kern_return_t mkret, skret;
+    mach_timespec_t mon_time_spec, sys_time_spec;
+
+    mkret = clock_get_time(internal_state.r.o.mach.clock.monotonic.srv,
+			   &mon_time_spec);
+    skret = clock_get_time(internal_state.r.o.mach.clock.wall.srv,
+			   &sys_time_spec);
+
+    if (mkret != KERN_SUCCESS)
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_get_time(%s, _) failed\n",
+		 internal_state.r.o.mach.clock.monotonic.name);
+    if (skret != KERN_SUCCESS)
+	erl_exit(ERTS_ABORT_EXIT,
+		 "clock_get_time(%s, _) failed\n",
+		 internal_state.r.o.mach.clock.wall.name);
+
+    *mtimep = (ErtsMonotonicTime) ERTS_TimeSpec2Sint64(&mon_time_spec);
+    *stimep = (ErtsSystemTime) ERTS_TimeSpec2Sint64(&sys_time_spec);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_USING_MACH_CLOCK_GET_TIME) */
+
+#endif /* defined(OS_MONOTONIC_TIME_USING_MACH_CLOCK_GET_TIME) */
+
+#if defined(SYS_HRTIME_USING_MACH_CLOCK_GET_TIME)
+
+#define ERTS_HAVE_ERTS_SYS_HRTIME_IMPL__
+
+ErtsSysHrTime
+erts_sys_hrtime(void)
+{
+    return (ErtsSysHrTime)
+	mach_clock_get_time(&internal_state.r.o.mach.clock.monotonic);
+}
+
+#endif /* defined(SYS_HRTIME_USING_MACH_CLOCK_GET_TIME) */
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * Solaris gethrtime() - OS monotonic time                                   *
+\*                                                                           */
+
+#if defined(OS_MONOTONIC_TIME_USING_GETHRTIME)
+
+ErtsMonotonicTime erts_os_monotonic_time(void)
+{
+    return (ErtsMonotonicTime) gethrtime();
+}
+
+#endif /* defined(OS_MONOTONIC_TIME_USING_GETHRTIME) */
+
+#if defined(SYS_HRTIME_USING_GETHRTIME)
+
+#define ERTS_HAVE_ERTS_SYS_HRTIME_IMPL__
+
+ErtsSysHrTime
+erts_sys_hrtime(void)
+{
+    return (ErtsSysHrTime) gethrtime();
+}
+
+#endif /* defined(SYS_HRTIME_USING_GETHRTIME) */
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * gettimeofday() - OS system time                                           *
+\*                                                                           */
+
+#if defined(OS_SYSTEM_TIME_GETTIMEOFDAY)
+
+ErtsSystemTime
+erts_os_system_time(void)
+{
+    ErtsSystemTime stime;
+    struct timeval tv;
+
+    if (gettimeofday(&tv, NULL) != 0) {
+	int err = errno;
+	char *errstr = err ? strerror(err) : "unknown";
+	erl_exit(ERTS_ABORT_EXIT,
+		 "gettimeofday(_, NULL) failed: %s (%d)\n",
+		 errstr, err);
+    }
+
+    stime = (ErtsSystemTime) tv.tv_sec;
+    stime *= (ErtsSystemTime) 1000*1000;
+    stime += (ErtsSystemTime) tv.tv_usec;
+
+    return adj_stime_time_unit(stime, (Uint32) 1000*1000);
+}
+
+#endif /* defined(OS_SYSTEM_TIME_GETTIMEOFDAY) */
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * times() - OS monotonic time                                               *
+\*                                                                           */
+
+#if defined(OS_MONOTONIC_TIME_USING_TIMES)
+
+ErtsMonotonicTime
+erts_os_monotonic_time(void)
+{
+    Uint32 ticks = get_tick_count();
+    ERTS_CHK_EXTEND_OS_MONOTONIC_TIME(&internal_state.wr.m.os_mtime_xtnd,
+				      ticks);
+    return ERTS_EXTEND_OS_MONOTONIC_TIME(&internal_state.wr.m.os_mtime_xtnd,
+					 ticks) << internal_state.r.o.times_shift;
+}
+
+#endif
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
+ * Fallbacks                                                                 *
+\*                                                                           */
+
+#ifndef ERTS_HAVE_ERTS_SYS_HRTIME_IMPL__
+
+ErtsSysHrTime
+erts_sys_hrtime(void)
+{
+    return (ErtsSysHrTime) ERTS_MONOTONIC_TO_NSEC(erts_os_system_time());
+}
+
+#endif
+
+#if !defined(ERTS_HAVE_ERTS_OS_TIMES_IMPL__) \
+    && defined(ERTS_HAVE_OS_MONOTONIC_TIME_SUPPORT)
+
+void
+erts_os_times(ErtsMonotonicTime *mtimep, ErtsSystemTime *stimep)
+{
+    *mtimep = erts_os_monotonic_time();
+    *stimep = erts_os_system_time();
+}
+
+#endif
 
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #ifdef HAVE_GETHRVTIME_PROCFS_IOCTL