Merge branch 'egil/erts/tracing-beam-lttng/OTP-10282'

* egil/erts/tracing-beam-lttng/OTP-10282:
  erts: Don't use ratio in carrier lttng tracepoints
  Add lttng testcases
  erts: Extend erlang:system_info/1 with lttng
  Refactor and fix dtrace define in erl_message
  erts: Add lttng tracepoints for async pool queue
  erts: Add lttng tracepoints for drivers
  erts: Add lttng tracepoints for scheduler events
  erts: Add lttng tracepoints for memory carriers
  erts: Update lttng-wrapper with mfa conversion
  erts: Teach lttng to configure and build system

23 files changed, 1517 insertions, 28 deletions

diff --git a/configure.in b/configure.in
index fc9aeee455..8a7f372a50 100644
--- a/configure.in
+++ b/configure.in
@@ -234,8 +234,8 @@ AS_HELP_STRING([--enable-native-libs],
                [compile Erlang libraries to native code]))
 
 AC_ARG_WITH(dynamic-trace,
-AS_HELP_STRING([--with-dynamic-trace={dtrace|systemtap}],
-	       [specify use of dynamic trace framework, dtrace or systemtap])
+AS_HELP_STRING([--with-dynamic-trace={dtrace|lttng|systemtap}],
+	       [specify use of dynamic trace framework, dtrace, lttng or systemtap])
 AS_HELP_STRING([--without-dynamic-trace], 
                [don't enable any dynamic tracing (default)]))
 AC_ARG_ENABLE(vm-probes,
diff --git a/erts/configure.in b/erts/configure.in
index 77a4d32787..0257079c3b 100644
--- a/erts/configure.in
+++ b/erts/configure.in
@@ -234,8 +234,8 @@ AS_HELP_STRING([--enable-m32-build],
 ],enable_m32_build=no)
 
 AC_ARG_WITH(dynamic-trace,
-AS_HELP_STRING([--with-dynamic-trace={dtrace|systemtap}],
-	       [specify use of dynamic trace framework, dtrace or systemtap])
+AS_HELP_STRING([--with-dynamic-trace={dtrace|lttng|systemtap}],
+	       [specify use of dynamic trace framework, dtrace, lttng or systemtap])
 AS_HELP_STRING([--without-dynamic-trace], 
                [don't enable any dynamic tracing (default)]))
 
@@ -245,6 +245,10 @@ fi
 
 case "$with_dynamic_trace" in
      no) DYNAMIC_TRACE_FRAMEWORK=;;
+     lttng)
+            AC_DEFINE(USE_LTTNG,[1],
+                      [Define if you want to use lttng for dynamic tracing])
+            DYNAMIC_TRACE_FRAMEWORK=lttng;;
      dtrace) 
 	    AC_DEFINE(USE_DTRACE,[1],
 		[Define if you want to use dtrace for dynamic tracing])
@@ -280,10 +284,12 @@ AS_HELP_STRING([--enable-vm-probes],
 			fi)
 
 AC_SUBST(USE_VM_PROBES)
-if test X"$use_vm_probes" = X"yes"; then
-   USE_VM_PROBES=yes
-   AC_DEFINE(USE_VM_PROBES,[1],
-	     [Define to enable VM dynamic trace probes])
+if test X"$DYNAMIC_TRACE_FRAMEWORK" != X"lttng"; then
+    if test X"$use_vm_probes" = X"yes"; then
+        USE_VM_PROBES=yes
+        AC_DEFINE(USE_VM_PROBES,[1],
+                  [Define to enable VM dynamic trace probes])
+    fi
 fi
 
 AC_ARG_WITH(assumed-cache-line-size,
@@ -3756,14 +3762,20 @@ dnl
 LM_FIND_EMU_CC
 
 dnl
-dnl DTrace
+dnl DTrace & LTTNG
 dnl
 case $DYNAMIC_TRACE_FRAMEWORK in
      dtrace|systemtap)
         AC_CHECK_TOOL(DTRACE, dtrace, none)
         test "$DTRACE" = "none" && AC_MSG_ERROR([No dtrace utility found.]);
+        enable_lttng_test=no
 	enable_dtrace_test=yes;;
-     *) enable_dtrace_test=no;;
+     lttng)
+        enable_lttng_test=yes
+        enable_dtrace_test=no;;
+     *)
+        enable_lttng_test=no
+        enable_dtrace_test=no;;
 esac        
 		     
 AC_SUBST(DTRACE)
@@ -3830,6 +3842,37 @@ if test "$enable_dtrace_test" = "yes" ; then
         fi
 fi
 
+if test "$enable_lttng_test" = "yes" ; then
+    AC_CHECK_HEADERS(lttng/tracepoint.h)
+    AC_CHECK_HEADERS(lttng/tracepoint-event.h)
+    dnl The macro tracepoint_enabled is not present in older lttng versions
+    dnl checking for tracepoint_enabled
+    AC_MSG_CHECKING([for tracepoint_enabled in lttng/tracepoint.h])
+    AC_COMPILE_IFELSE(
+        [AC_LANG_PROGRAM(
+            [#include <lttng/tracepoint.h>
+             #define TRACEPOINT_PROVIDER com_ericsson_otp
+             TRACEPOINT_EVENT(
+                 com_ericsson_otp,
+                 dummy,
+                 TP_ARGS(int, my_int),
+                 TP_FIELDS(ctf_integer(int, my_int, my_int)))
+             #define TRACEPOINT_CREATE_PROBES
+             #define TRACEPOINT_DEFINE],
+            [if(tracepoint_enabled(com_ericsson_otp,dummy)) do {} while(0)])],
+        [AC_MSG_RESULT([yes])],
+        [AC_MSG_ERROR([no (must be present)])])
+    if test "x$ac_cv_header_lttng_tracepoint_h" = "xyes" \
+        -a "x$ac_cv_header_lttng_tracepoint_event_h" = "xyes"; then
+        # No straight forward way to test for liblttng-ust when no public symbol exists,
+        # just add the lib.
+        LIBS="$LIBS -llttng-ust -ldl"
+    else
+        AC_MSG_ERROR([No LTTng support found.])
+    fi
+fi
+
+
 dnl
 dnl SSL, SSH and CRYPTO need the OpenSSL libraries
 dnl
diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index 12148ad9c7..3a5cfddc30 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -779,6 +779,8 @@ RUN_OBJS = \
 	$(OBJDIR)/erl_ptab.o		$(OBJDIR)/erl_map.o \
 	$(OBJDIR)/erl_msacc.o
 
+LTTNG_OBJS = $(OBJDIR)/erlang_lttng.o
+
 ifeq ($(TARGET),win32)
 DRV_OBJS = \
 	$(OBJDIR)/registry_drv.o \
@@ -885,7 +887,7 @@ ifdef HIPE_ENABLED
 EXTRA_BASE_OBJS += $(HIPE_OBJS)
 endif
 
-BASE_OBJS = $(EMU_OBJS) $(RUN_OBJS) $(OS_OBJS) $(EXTRA_BASE_OBJS)
+BASE_OBJS = $(EMU_OBJS) $(RUN_OBJS) $(OS_OBJS) $(EXTRA_BASE_OBJS) $(LTTNG_OBJS)
 
 before_DTrace_OBJS =	$(BASE_OBJS) $(DRV_OBJS)
 
diff --git a/erts/emulator/beam/erl_alloc.h b/erts/emulator/beam/erl_alloc.h
index 71e4713624..ee2013bd93 100644
--- a/erts/emulator/beam/erl_alloc.h
+++ b/erts/emulator/beam/erl_alloc.h
@@ -235,9 +235,9 @@ void *erts_alloc(ErtsAlcType_t type, Uint size)
     void *res;
     ERTS_MSACC_PUSH_AND_SET_STATE_X(ERTS_MSACC_STATE_ALLOC);
     res = (*erts_allctrs[ERTS_ALC_T2A(type)].alloc)(
-	ERTS_ALC_T2N(type),
-	erts_allctrs[ERTS_ALC_T2A(type)].extra,
-	size);
+            ERTS_ALC_T2N(type),
+            erts_allctrs[ERTS_ALC_T2A(type)].extra,
+            size);
     if (!res)
 	erts_alloc_n_enomem(ERTS_ALC_T2N(type), size);
     ERTS_MSACC_POP_STATE_X();
@@ -564,5 +564,3 @@ NAME##_free(TYPE *p)							\
 #undef ERTS_ALC_ATTRIBUTES
 
 #endif /* #ifndef ERL_ALLOC_H__ */
-
-
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index 5e7dd7cce8..6e682019ba 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -52,6 +52,7 @@
 #ifdef ERTS_ENABLE_LOCK_COUNT
 #include "erl_lock_count.h"
 #endif
+#include "lttng-wrapper.h"
 
 #if defined(ERTS_ALLOC_UTIL_HARD_DEBUG) && defined(__GNUC__)
 #warning "* * * * * * * * * *"
@@ -3125,6 +3126,7 @@ cpool_insert(Allctr_t *allctr, Carrier_t *crr)
 
     erts_smp_atomic_set_wb(&crr->allctr,
 			   ((erts_aint_t) allctr)|ERTS_CRR_ALCTR_FLG_IN_POOL);
+    LTTNG3(carrier_pool_put, ERTS_ALC_A2AD(allctr->alloc_no), allctr->ix, CARRIER_SZ(crr));
 }
 
 static void
@@ -3240,6 +3242,7 @@ cpool_fetch(Allctr_t *allctr, UWord size)
     first_old_traitor = allctr->cpool.traitor_list.next;
     cpool_entrance = NULL;
 
+    LTTNG3(carrier_pool_get, ERTS_ALC_A2AD(allctr->alloc_no), allctr->ix, (unsigned long)size);
     /*
      * Search my own pooled_list,
      * i.e my abandoned carriers that were in the pool last time I checked.
@@ -3925,6 +3928,21 @@ create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
 
     }
 
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+    if (LTTNG_ENABLED(carrier_create)) {
+        lttng_decl_carrier_stats(mbc_stats);
+        lttng_decl_carrier_stats(sbc_stats);
+        LTTNG_CARRIER_STATS_TO_LTTNG_STATS(&(allctr->mbcs), mbc_stats);
+        LTTNG_CARRIER_STATS_TO_LTTNG_STATS(&(allctr->sbcs), sbc_stats);
+        LTTNG5(carrier_create,
+                ERTS_ALC_A2AD(allctr->alloc_no),
+                allctr->ix,
+                crr_sz,
+                mbc_stats,
+                sbc_stats);
+    }
+#endif
+
     DEBUG_SAVE_ALIGNMENT(crr);
     return blk;
 }
@@ -4148,6 +4166,21 @@ destroy_carrier(Allctr_t *allctr, Block_t *blk, Carrier_t **busy_pcrr_pp)
                 allctr->remove_mbc(allctr, crr);
 	}
 
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(carrier_destroy)) {
+            lttng_decl_carrier_stats(mbc_stats);
+            lttng_decl_carrier_stats(sbc_stats);
+            LTTNG_CARRIER_STATS_TO_LTTNG_STATS(&(allctr->mbcs), mbc_stats);
+            LTTNG_CARRIER_STATS_TO_LTTNG_STATS(&(allctr->sbcs), sbc_stats);
+            LTTNG5(carrier_destroy,
+                ERTS_ALC_A2AD(allctr->alloc_no),
+                allctr->ix,
+                crr_sz,
+                mbc_stats,
+                sbc_stats);
+        }
+#endif
+
 #ifdef ERTS_SMP
 	schedule_dealloc_carrier(allctr, crr);
 #else
diff --git a/erts/emulator/beam/erl_alloc_util.h b/erts/emulator/beam/erl_alloc_util.h
index b7d717ed23..afdff1a71e 100644
--- a/erts/emulator/beam/erl_alloc_util.h
+++ b/erts/emulator/beam/erl_alloc_util.h
@@ -30,6 +30,7 @@
 #endif
 
 #include "erl_mseg.h"
+#include "lttng-wrapper.h"
 
 #define ERTS_AU_PREF_ALLOC_BITS 11
 #define ERTS_AU_MAX_PREF_ALLOC_INSTANCES (1 << ERTS_AU_PREF_ALLOC_BITS)
@@ -417,6 +418,18 @@ typedef struct {
     } blocks;
 } CarriersStats_t;
 
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+#define LTTNG_CARRIER_STATS_TO_LTTNG_STATS(CSP, LSP)            \
+    do {                                                        \
+        (LSP)->carriers.size = (CSP)->curr.norm.mseg.size       \
+                             + (CSP)->curr.norm.sys_alloc.size; \
+        (LSP)->carriers.no   = (CSP)->curr.norm.mseg.no         \
+                             + (CSP)->curr.norm.sys_alloc.no;   \
+        (LSP)->blocks.size   = (CSP)->blocks.curr.size;         \
+        (LSP)->blocks.no     = (CSP)->blocks.curr.no;           \
+    } while (0)
+#endif
+
 #ifdef ERTS_SMP
 
 typedef union ErtsAllctrDDBlock_t_ ErtsAllctrDDBlock_t;
diff --git a/erts/emulator/beam/erl_async.c b/erts/emulator/beam/erl_async.c
index cdeeb5281b..69240f7886 100644
--- a/erts/emulator/beam/erl_async.c
+++ b/erts/emulator/beam/erl_async.c
@@ -28,6 +28,7 @@
 #include "erl_thr_queue.h"
 #include "erl_async.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 
 #define ERTS_MAX_ASYNC_READY_CALLS_IN_SEQ 20
 
@@ -281,6 +282,13 @@ static ERTS_INLINE void async_add(ErtsAsync *a, ErtsAsyncQ* q)
 #endif
 
     erts_thr_q_enqueue(&q->thr_q, a);
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+    if (LTTNG_ENABLED(aio_pool_add)) {
+        lttng_decl_portbuf(port_str);
+        lttng_portid_to_str(a->port, port_str);
+        LTTNG2(aio_pool_add, port_str, -1);
+    }
+#endif
 #ifdef USE_VM_PROBES
     if (DTRACE_ENABLED(aio_pool_add)) {
         DTRACE_CHARBUF(port_str, 16);
@@ -317,6 +325,14 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 	    if (saved_fin_deq)
 		erts_thr_q_append_finalize_dequeue_data(&a->q.fin_deq, &fin_deq);
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+            if (LTTNG_ENABLED(aio_pool_get)) {
+                lttng_decl_portbuf(port_str);
+                int length = erts_thr_q_length_dirty(q);
+                lttng_portid_to_str(a->port, port_str);
+                LTTNG2(aio_pool_get, port_str, length);
+            }
+#endif
 #ifdef USE_VM_PROBES
             if (DTRACE_ENABLED(aio_pool_get)) {
                 DTRACE_CHARBUF(port_str, 16);
diff --git a/erts/emulator/beam/erl_bif_ddll.c b/erts/emulator/beam/erl_bif_ddll.c
index f006856b6a..b526eda41d 100644
--- a/erts/emulator/beam/erl_bif_ddll.c
+++ b/erts/emulator/beam/erl_bif_ddll.c
@@ -48,6 +48,7 @@
 #include "erl_version.h"
 #include "erl_bif_unique.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 
 #ifdef ERTS_SMP
 #define DDLL_SMP 1
@@ -1619,6 +1620,7 @@ static int do_unload_driver_entry(DE_Handle *dh, Eterm *save_name)
 	    if (q->finish) {
 		int fpe_was_unmasked = erts_block_fpe();
 		DTRACE1(driver_finish, q->name);
+                LTTNG1(driver_finish, q->name);
 		(*(q->finish))();
 		erts_unblock_fpe(fpe_was_unmasked);
 	    }
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index d35bbb80b8..0b2c26a548 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -126,6 +126,9 @@ static char erts_system_version[] = ("Erlang/OTP " ERLANG_OTP_RELEASE
 #ifdef ERTS_FRMPTR
 				     " [frame-pointer]"
 #endif
+#ifdef USE_LTTNG
+				     " [lttng]"
+#endif
 #ifdef USE_DTRACE
 				     " [dtrace]"
 #endif
@@ -2748,6 +2751,9 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 #elif defined(USE_SYSTEMTAP)
 	DECL_AM(systemtap);
 	BIF_RET(AM_systemtap);
+#elif defined(USE_LTTNG)
+	DECL_AM(lttng);
+	BIF_RET(AM_lttng);
 #else
 	BIF_RET(am_none);
 #endif
diff --git a/erts/emulator/beam/erl_message.c b/erts/emulator/beam/erl_message.c
index 88efb2c59f..bc0a55068b 100644
--- a/erts/emulator/beam/erl_message.c
+++ b/erts/emulator/beam/erl_message.c
@@ -766,17 +766,7 @@ erts_send_message(Process* sender,
 		utag = DT_UTAG(sender);
 	    else
 		utag = copy_struct(DT_UTAG(sender), dt_utag_size, &hp, ohp);
-#ifdef DTRACE_TAG_HARDDEBUG
-	    erts_fprintf(stderr,
-			 "Dtrace -> (%T) Spreading tag (%T) with "
-			 "message %T!\r\n",sender->common.id, utag, message);
-#endif
 	}
-#endif
-        BM_MESSAGE_COPIED(msize);
-        BM_SWAP_TIMER(copy,send);
-
-#ifdef USE_VM_PROBES
         if (DTRACE_ENABLED(message_send)) {
             if (have_seqtrace(stoken)) {
 		tok_label = signed_val(SEQ_TRACE_T_LABEL(stoken));
@@ -787,6 +777,9 @@ erts_send_message(Process* sender,
 		    msize, tok_label, tok_lastcnt, tok_serial);
         }
 #endif
+        BM_MESSAGE_COPIED(msize);
+        BM_SWAP_TIMER(copy,send);
+
     } else {
         Eterm *hp;
 
@@ -822,8 +815,10 @@ erts_send_message(Process* sender,
 	    BM_MESSAGE_COPIED(msz);
 	    BM_SWAP_TIMER(copy,send);
 	}
+#ifdef USE_VM_PROBES
         DTRACE6(message_send, sender_name, receiver_name,
                 msize, tok_label, tok_lastcnt, tok_serial);
+#endif
     }
 
     res = queue_message(sender,
diff --git a/erts/emulator/beam/erl_port_task.c b/erts/emulator/beam/erl_port_task.c
index b200344af5..ec07d145ab 100644
--- a/erts/emulator/beam/erl_port_task.c
+++ b/erts/emulator/beam/erl_port_task.c
@@ -35,6 +35,7 @@
 #include "dist.h"
 #include "erl_check_io.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 #include <stdarg.h>
 
 /*
@@ -69,6 +70,18 @@ static void chk_task_queues(Port *pp, ErtsPortTask *execq, int processing_busy_q
 #else
 #define  DTRACE_DRIVER(PROBE_NAME, PP) do {} while(0)
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+#define LTTNG_DRIVER(TRACEPOINT, PP)                              \
+    if (LTTNG_ENABLED(TRACEPOINT)) {                              \
+        lttng_decl_portbuf(port_str);                             \
+        lttng_decl_procbuf(proc_str);                             \
+        lttng_pid_to_str(ERTS_PORT_GET_CONNECTED(PP), proc_str);  \
+        lttng_port_to_str((PP), port_str);                        \
+        LTTNG3(TRACEPOINT, proc_str, port_str, (PP)->name);       \
+    }
+#else
+#define LTTNG_DRIVER(TRACEPOINT, PP) do {} while(0)
+#endif
 
 #define ERTS_SMP_LC_VERIFY_RQ(RQ, PP)					\
     do {								\
@@ -1752,6 +1765,7 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 		reds = ERTS_PORT_REDS_TIMEOUT;
 		if (!(state & ERTS_PORT_SFLGS_DEAD)) {
 		    DTRACE_DRIVER(driver_timeout, pp);
+		    LTTNG_DRIVER(driver_timeout, pp);
 		    (*pp->drv_ptr->timeout)((ErlDrvData) pp->drv_data);
 		}
 	    }
@@ -1760,6 +1774,7 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 	    reds = ERTS_PORT_REDS_INPUT;
 	    ASSERT((state & ERTS_PORT_SFLGS_DEAD) == 0);
             DTRACE_DRIVER(driver_ready_input, pp);
+            LTTNG_DRIVER(driver_ready_input, pp);
 	    /* NOTE some windows drivers use ->ready_input
 	       for input and output */
 	    (*pp->drv_ptr->ready_input)((ErlDrvData) pp->drv_data,
@@ -1771,6 +1786,7 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 	    reds = ERTS_PORT_REDS_OUTPUT;
 	    ASSERT((state & ERTS_PORT_SFLGS_DEAD) == 0);
             DTRACE_DRIVER(driver_ready_output, pp);
+            LTTNG_DRIVER(driver_ready_output, pp);
 	    (*pp->drv_ptr->ready_output)((ErlDrvData) pp->drv_data,
 					 ptp->u.alive.td.io.event);
 	    reset_executed_io_task_handle(ptp);
@@ -1780,6 +1796,7 @@ erts_port_task_execute(ErtsRunQueue *runq, Port **curr_port_pp)
 	    reds = ERTS_PORT_REDS_EVENT;
 	    ASSERT((state & ERTS_PORT_SFLGS_DEAD) == 0);
             DTRACE_DRIVER(driver_event, pp);
+            LTTNG_DRIVER(driver_event, pp);
 	    (*pp->drv_ptr->event)((ErlDrvData) pp->drv_data,
 				  ptp->u.alive.td.io.event,
 				  ptp->u.alive.td.io.event_data);
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index 794af60b2f..57a7b0f288 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -43,6 +43,7 @@
 #include "erl_thr_queue.h"
 #include "erl_async.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 #include "erl_ptab.h"
 #include "erl_bif_unique.h"
 #define ERTS_WANT_TIMER_WHEEL_API
@@ -3217,6 +3218,7 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	    ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_CHECK_IO);
 
 	    ASSERT(!erts_port_task_have_outstanding_io_tasks());
+            LTTNG2(scheduler_poll, esdp->no, 1);
 	    erl_sys_schedule(1); /* Might give us something to do */
 
 	    ERTS_MSACC_POP_STATE_M();
@@ -3340,6 +3342,7 @@ scheduler_wait(int *fcalls, ErtsSchedulerData *esdp, ErtsRunQueue *rq)
 	ASSERT(!erts_port_task_have_outstanding_io_tasks());
 
 	ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_CHECK_IO);
+        LTTNG2(scheduler_poll, esdp->no, 0);
 
 	erl_sys_schedule(0);
 
@@ -9558,7 +9561,10 @@ Process *schedule(Process *p, int calls)
 	    erts_sys_schedule_interrupt(0);
 #endif
 	    erts_smp_runq_unlock(rq);
-	    ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_CHECK_IO);
+
+            ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_CHECK_IO);
+            LTTNG2(scheduler_poll, esdp->no, 1);
+
 	    erl_sys_schedule(1);
 	    ERTS_MSACC_POP_STATE_M();
 
diff --git a/erts/emulator/beam/erl_thr_queue.c b/erts/emulator/beam/erl_thr_queue.c
index 7ff456b915..30c9d70c59 100644
--- a/erts/emulator/beam/erl_thr_queue.c
+++ b/erts/emulator/beam/erl_thr_queue.c
@@ -780,3 +780,35 @@ erts_thr_q_dequeue(ErtsThrQ_t *q)
     return res;
 #endif
 }
+
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+int
+erts_thr_q_length_dirty(ErtsThrQ_t *q)
+{
+    int n = 0;
+#ifndef USE_THREADS
+    void *res;
+    ErtsThrQElement_t *tmp;
+
+    for (tmp = q->first; tmp != NULL; tmp = tmp->next) {
+        n++;
+    }
+#else
+    ErtsThrQElement_t *e;
+    erts_aint_t inext;
+
+    e = ErtsThrQDirtyReadEl(&q->head.head);
+    inext = erts_atomic_read_acqb(&e->next);
+
+    while (inext != ERTS_AINT_NULL) {
+        e = (ErtsThrQElement_t *) inext;
+        if (e != &q->tail.data.marker) {
+            /* don't count marker */
+            n++;
+        }
+        inext = erts_atomic_read_acqb(&e->next);
+    }
+#endif
+    return n;
+}
+#endif
diff --git a/erts/emulator/beam/erl_thr_queue.h b/erts/emulator/beam/erl_thr_queue.h
index 27a6d03224..f5e5522948 100644
--- a/erts/emulator/beam/erl_thr_queue.h
+++ b/erts/emulator/beam/erl_thr_queue.h
@@ -190,6 +190,10 @@ void erts_thr_q_append_finalize_dequeue_data(ErtsThrQFinDeQ_t *,
 int erts_thr_q_finalize_dequeue(ErtsThrQFinDeQ_t *);
 void erts_thr_q_finalize_dequeue_state_init(ErtsThrQFinDeQ_t *);
 
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+int erts_thr_q_length_dirty(ErtsThrQ_t *);
+#endif
+
 #ifdef ERTS_SMP
 ERTS_GLB_INLINE ErtsThrPrgrVal erts_thr_q_need_thr_progress(ErtsThrQ_t *q);
 #endif
diff --git a/erts/emulator/beam/erlang_lttng.c b/erts/emulator/beam/erlang_lttng.c
new file mode 100644
index 0000000000..fce40eedc1
--- /dev/null
+++ b/erts/emulator/beam/erlang_lttng.c
@@ -0,0 +1,32 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2016. All Rights Reserved.
+ *
+ * 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%
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#ifdef USE_LTTNG
+#define TRACEPOINT_CREATE_PROBES
+/*
+ * The header containing our TRACEPOINT_EVENTs.
+ */
+#define TRACEPOINT_DEFINE
+#include "erlang_lttng.h"
+#endif /* USE_LTTNG */
diff --git a/erts/emulator/beam/erlang_lttng.h b/erts/emulator/beam/erlang_lttng.h
new file mode 100644
index 0000000000..43ceeda671
--- /dev/null
+++ b/erts/emulator/beam/erlang_lttng.h
@@ -0,0 +1,424 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2016. All Rights Reserved.
+ *
+ * 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%
+ */
+
+#ifdef USE_LTTNG
+#undef TRACEPOINT_PROVIDER
+#define TRACEPOINT_PROVIDER com_ericsson_otp
+
+#undef TRACEPOINT_INCLUDE
+#define TRACEPOINT_INCLUDE "erlang_lttng.h"
+
+#if !defined(__ERLANG_LTTNG_H__) || defined(TRACEPOINT_HEADER_MULTI_READ)
+#define __ERLANG_LTTNG_H__
+
+#include <lttng/tracepoint.h>
+
+/* Schedulers */
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    scheduler_poll,
+    TP_ARGS(
+        int, id,
+        int, runnable
+    ),
+    TP_FIELDS(
+        ctf_integer(int, scheduler, id)
+        ctf_integer(int, runnable, runnable)
+    )
+)
+
+#ifndef LTTNG_CARRIER_STATS
+#define LTTNG_CARRIER_STATS
+typedef struct {
+    unsigned long no;
+    unsigned long size;
+} lttng_stat_values_t;
+
+typedef struct {
+    lttng_stat_values_t carriers;
+    lttng_stat_values_t blocks;
+} lttng_carrier_stats_t;
+#endif
+
+
+/* Port and Driver Scheduling */
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_start,
+    TP_ARGS(
+        char*, pid,
+        char*, driver,
+        char*, port
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(driver, driver)
+        ctf_string(port, port)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_init,
+    TP_ARGS(
+        char*, driver,
+        int, major,
+        int, minor,
+        int, flags
+    ),
+    TP_FIELDS(
+        ctf_string(driver, driver)
+        ctf_integer(int, major, major)
+        ctf_integer(int, minor, minor)
+        ctf_integer(int, flags, flags)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_outputv,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver,
+        size_t, bytes
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+        ctf_integer(size_t, bytes, bytes)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_output,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver,
+        size_t, bytes
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+        ctf_integer(size_t, bytes, bytes)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_ready_input,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_ready_output,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_event,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_timeout,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_stop_select,
+    TP_ARGS(
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_flush,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_stop,
+    TP_ARGS(
+        char*, pid,
+        char*, driver,
+        char*, port
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(driver, driver)
+        ctf_string(port, port)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_process_exit,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_ready_async,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_finish,
+    TP_ARGS(
+        char*, driver
+    ),
+    TP_FIELDS(
+        ctf_string(driver, driver)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_call,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver,
+        unsigned int, command,
+        size_t, bytes
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+        ctf_integer(unsigned int, command, command)
+        ctf_integer(size_t, bytes, bytes)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    driver_control,
+    TP_ARGS(
+        char*, pid,
+        char*, port,
+        char*, driver,
+        unsigned int, command,
+        size_t, bytes
+    ),
+    TP_FIELDS(
+        ctf_string(pid, pid)
+        ctf_string(port, port)
+        ctf_string(driver, driver)
+        ctf_integer(unsigned int, command, command)
+        ctf_integer(size_t, bytes, bytes)
+    )
+)
+
+/* Async pool */
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    aio_pool_get,
+    TP_ARGS(
+        char*, port,
+        int, length
+    ),
+    TP_FIELDS(
+        ctf_string(port, port)
+        ctf_integer(int, length, length)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    aio_pool_add,
+    TP_ARGS(
+        char*, port,
+        int, length
+    ),
+    TP_FIELDS(
+        ctf_string(port, port)
+        ctf_integer(int, length, length)
+    )
+)
+
+
+/* Memory Allocator */
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    carrier_create,
+    TP_ARGS(
+        const char*, type,
+        int, instance,
+        unsigned long, size,
+        lttng_carrier_stats_t *, mbcs,
+        lttng_carrier_stats_t *, sbcs
+    ),
+    TP_FIELDS(
+        ctf_string(type, type)
+        ctf_integer(int, instance, instance)
+        ctf_integer(unsigned long, size, size)
+        ctf_integer(unsigned long, mbc_carriers, mbcs->carriers.no)
+        ctf_integer(unsigned long, mbc_carriers_size, mbcs->carriers.size)
+        ctf_integer(unsigned long, mbc_blocks, mbcs->blocks.no)
+        ctf_integer(unsigned long, mbc_blocks_size, mbcs->blocks.size)
+        ctf_integer(unsigned long, sbc_carriers, sbcs->carriers.no)
+        ctf_integer(unsigned long, sbc_carriers_size, sbcs->carriers.size)
+        ctf_integer(unsigned long, sbc_blocks, sbcs->blocks.no)
+        ctf_integer(unsigned long, sbc_blocks_size, sbcs->blocks.size)
+    )
+)
+
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    carrier_destroy,
+    TP_ARGS(
+        const char*, type,
+        int, instance,
+        unsigned long, size,
+        lttng_carrier_stats_t *, mbcs,
+        lttng_carrier_stats_t *, sbcs
+    ),
+    TP_FIELDS(
+        ctf_string(type, type)
+        ctf_integer(int, instance, instance)
+        ctf_integer(unsigned long, size, size)
+        ctf_integer(unsigned long, mbc_carriers, mbcs->carriers.no)
+        ctf_integer(unsigned long, mbc_carriers_size, mbcs->carriers.size)
+        ctf_integer(unsigned long, mbc_blocks, mbcs->blocks.no)
+        ctf_integer(unsigned long, mbc_blocks_size, mbcs->blocks.size)
+        ctf_integer(unsigned long, sbc_carriers, sbcs->carriers.no)
+        ctf_integer(unsigned long, sbc_carriers_size, sbcs->carriers.size)
+        ctf_integer(unsigned long, sbc_blocks, sbcs->blocks.no)
+        ctf_integer(unsigned long, sbc_blocks_size, sbcs->blocks.size)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    carrier_pool_put,
+    TP_ARGS(
+        const char*, name,
+        int, instance,
+        unsigned long, size
+    ),
+    TP_FIELDS(
+        ctf_string(type, name)
+        ctf_integer(int, instance, instance)
+        ctf_integer(unsigned long, size, size)
+    )
+)
+
+TRACEPOINT_EVENT(
+    com_ericsson_otp,
+    carrier_pool_get,
+    TP_ARGS(
+        const char*, name,
+        int, instance,
+        unsigned long, size
+    ),
+    TP_FIELDS(
+        ctf_string(type, name)
+        ctf_integer(int, instance, instance)
+        ctf_integer(unsigned long, size, size)
+    )
+)
+
+#endif /* __ERLANG_LTTNG_H__ */
+#include <lttng/tracepoint-event.h>
+#endif /* USE_LTTNG */
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 29f28cc9dc..b85b581cdc 100644
--- a/erts/emulator/beam/io.c
+++ b/erts/emulator/beam/io.c
@@ -47,6 +47,7 @@
 #define ERTS_WANT_EXTERNAL_TAGS
 #include "external.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 #include "erl_map.h"
 #include "erl_bif_unique.h"
 #include "erl_hl_timer.h"
@@ -717,7 +718,19 @@ erts_open_driver(erts_driver_t* driver,	/* Pointer to driver. */
             DTRACE3(driver_start, process_str, driver->name, port_str);
         }
 #endif
+
 	ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_PORT);
+
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(driver_start)) {
+            lttng_decl_portbuf(port_str);
+            lttng_decl_procbuf(proc_str);
+            lttng_pid_to_str(pid, proc_str);
+            lttng_port_to_str(port, port_str);
+            LTTNG3(driver_start, proc_str, driver->name, port_str);
+        }
+#endif
+
 	fpe_was_unmasked = erts_block_fpe();
 	drv_data = (*driver->start)(ERTS_Port2ErlDrvPort(port), name, opts);
 	if (((SWord) drv_data) == -1)
@@ -1735,6 +1748,15 @@ call_driver_outputv(int bang_op,
 	    DTRACE4(driver_outputv, process_str, port_str, prt->name, size);
 	}
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(driver_outputv)) {
+            lttng_decl_portbuf(port_str);
+            lttng_decl_procbuf(proc_str);
+            lttng_pid_to_str(caller, proc_str);
+            lttng_port_to_str(prt, port_str);
+            LTTNG4(driver_outputv, proc_str, port_str, prt->name, size);
+        }
+#endif
 
 	prt->caller = caller;
 	(*drv->outputv)((ErlDrvData) prt->drv_data, evp);
@@ -1836,6 +1858,15 @@ call_driver_output(int bang_op,
 	    DTRACE4(driver_output, process_str, port_str, prt->name, size);
 	}
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(driver_output)) {
+            lttng_decl_portbuf(port_str);
+            lttng_decl_procbuf(proc_str);
+            lttng_pid_to_str(caller, proc_str);
+            lttng_port_to_str(prt, port_str);
+            LTTNG4(driver_output, proc_str, port_str, prt->name, size);
+        }
+#endif
 
 	prt->caller = caller;
 	(*drv->output)((ErlDrvData) prt->drv_data, bufp, size);
@@ -2141,7 +2172,6 @@ erts_port_output(Process *c_p,
 	DTRACE4(port_command, process_str, port_str, prt->name, "command");
     }
 #endif
-
     if (drv->outputv) {
 	ErlIOVec ev;
 	SysIOVec iv[SMALL_WRITE_VEC];
@@ -3697,6 +3727,17 @@ static void flush_port(Port *p)
             DTRACE3(driver_flush, process_str, port_str, p->name);
         }
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(driver_flush)) {
+            lttng_decl_portbuf(port_str);
+            lttng_decl_procbuf(proc_str);
+            lttng_pid_to_str(ERTS_PORT_GET_CONNECTED(p), proc_str);
+            lttng_port_to_str(p, port_str);
+            LTTNG3(driver_flush, proc_str, port_str, p->name);
+        }
+#endif
+
+
         if (IS_TRACED_FL(p, F_TRACE_SCHED_PORTS)) {
 	    trace_sched_ports_where(p, am_in, am_flush);
 	}
@@ -3760,6 +3801,16 @@ terminate_port(Port *prt)
             DTRACE3(driver_stop, process_str, drv->name, port_str);
         }
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+        if (LTTNG_ENABLED(driver_stop)) {
+            lttng_decl_portbuf(port_str);
+            lttng_decl_procbuf(proc_str);
+            lttng_pid_to_str(connected_id, proc_str);
+            lttng_port_to_str(prt, port_str);
+            LTTNG3(driver_stop, proc_str, drv->name, port_str);
+        }
+#endif
+
 	(*drv->stop)((ErlDrvData)prt->drv_data);
 	erts_unblock_fpe(fpe_was_unmasked);
 	ERTS_MSACC_POP_STATE_M();
@@ -4091,6 +4142,16 @@ call_driver_control(Eterm caller,
     
     ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_PORT);
 
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+    if (LTTNG_ENABLED(driver_control)) {
+        lttng_decl_procbuf(proc_str);
+        lttng_decl_portbuf(port_str);
+        lttng_pid_to_str(caller, proc_str);
+        lttng_port_to_str(prt, port_str);
+        LTTNG5(driver_control, proc_str, port_str, prt->name, command, size);
+    }
+#endif
+
     prt->caller = caller;
     cres = prt->drv_ptr->control((ErlDrvData) prt->drv_data,
 				 command,
@@ -4504,6 +4565,15 @@ call_driver_call(Eterm caller,
         DTRACE5(driver_call, process_str, port_str, prt->name, command, size);
     }
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+    if (LTTNG_ENABLED(driver_call)) {
+        lttng_decl_procbuf(proc_str);
+        lttng_decl_portbuf(port_str);
+        lttng_pid_to_str(caller,proc_str);
+        lttng_port_to_str(prt, port_str);
+        LTTNG5(driver_call, proc_str, port_str, prt->name, command, size);
+    }
+#endif
 
     ERTS_MSACC_SET_STATE_CACHED_M(ERTS_MSACC_STATE_PORT);
 
@@ -5266,6 +5336,15 @@ int async_ready(Port *p, void* data)
                 DTRACE3(driver_ready_async, process_str, port_str, p->name);
             }
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS 
+            if (LTTNG_ENABLED(driver_ready_async)) {
+                lttng_decl_portbuf(port_str);
+                lttng_decl_procbuf(proc_str);
+                lttng_pid_to_str(ERTS_PORT_GET_CONNECTED(p), proc_str);
+                lttng_port_to_str(p, port_str);
+                LTTNG3(driver_ready_async, proc_str, port_str, p->name);
+            }
+#endif
 	    (*p->drv_ptr->ready_async)((ErlDrvData)p->drv_data, data);
 	    need_free = 0;
 	    ERTS_MSACC_POP_STATE_M();
@@ -7312,6 +7391,15 @@ void erts_fire_port_monitor(Port *prt, Eterm ref)
         DTRACE3(driver_process_exit, process_str, port_str, prt->name);
     }
 #endif
+#ifdef USE_LTTNG_VM_TRACEPOINTS
+    if (LTTNG_ENABLED(driver_process_exit)) {
+        lttng_decl_portbuf(port_str);
+        lttng_decl_procbuf(proc_str);
+        lttng_pid_to_str(ERTS_PORT_GET_CONNECTED(prt), proc_str);
+        lttng_port_to_str(prt, port_str);
+        LTTNG3(driver_process_exit, proc_str, port_str, prt->name);
+    }
+#endif
     fpe_was_unmasked = erts_block_fpe();
     (*callback)((ErlDrvData) (prt->drv_data), &drv_monitor);
     erts_unblock_fpe(fpe_was_unmasked);
@@ -7789,6 +7877,8 @@ init_driver(erts_driver_t *drv, ErlDrvEntry *de, DE_Handle *handle)
 	int fpe_was_unmasked = erts_block_fpe();
         DTRACE4(driver_init, drv->name, drv->version.major, drv->version.minor,
                 drv->flags);
+        LTTNG4(driver_init, drv->name, drv->version.major, drv->version.minor,
+                drv->flags);
 	res = (*de->init)();
 	erts_unblock_fpe(fpe_was_unmasked);
 	return res;
diff --git a/erts/emulator/beam/lttng-wrapper.h b/erts/emulator/beam/lttng-wrapper.h
new file mode 100644
index 0000000000..294872c365
--- /dev/null
+++ b/erts/emulator/beam/lttng-wrapper.h
@@ -0,0 +1,107 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 1996-2016. All Rights Reserved.
+ *
+ * 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%
+ */
+
+#ifndef __LTTNG_WRAPPER_H__
+#define __LTTNG_WRAPPER_H__
+
+#ifdef USE_LTTNG
+
+#include "erlang_lttng.h"
+#define USE_LTTNG_VM_TRACEPOINTS
+
+#define LTTNG_BUFFER_SZ      (256)
+#define LTTNG_PROC_BUFFER_SZ (16)
+#define LTTNG_PORT_BUFFER_SZ (20)
+#define LTTNG_MFA_BUFFER_SZ  (256)
+
+#define lttng_decl_procbuf(Name) \
+    char Name[LTTNG_PROC_BUFFER_SZ]
+
+#define lttng_decl_portbuf(Name) \
+    char Name[LTTNG_PORT_BUFFER_SZ]
+
+#define lttng_decl_mfabuf(Name) \
+    char Name[LTTNG_MFA_BUFFER_SZ]
+
+#define lttng_decl_carrier_stats(Name) \
+    lttng_carrier_stats_t Name##_STATSTRUCT, *Name = &Name##_STATSTRUCT
+
+#define lttng_pid_to_str(pid, name) \
+    erts_snprintf(name, LTTNG_PROC_BUFFER_SZ, "%T", (pid))
+
+#define lttng_portid_to_str(pid, name) \
+    erts_snprintf(name, LTTNG_PORT_BUFFER_SZ, "%T", (pid))
+
+#define lttng_proc_to_str(p, name) \
+    lttng_pid_to_str(((p) ? (p)->common.id : ERTS_INVALID_PID), name)
+
+#define lttng_port_to_str(p, name) \
+    lttng_portid_to_str(((p) ? (p)->common.id : ERTS_INVALID_PORT), name)
+
+#define lttng_mfa_to_str(m,f,a, Name) \
+    erts_snprintf(Name, LTTNG_MFA_BUFFER_SZ, "%T:%T/%lu", (Eterm)(m), (Eterm)(f), (Uint)(a))
+
+#define lttng_proc_to_mfa_str(p, Name)                              \
+    do {                                                            \
+        if (ERTS_PROC_IS_EXITING((p))) {                            \
+            strcpy(Name, "<exiting>");                              \
+        } else {                                                    \
+            BeamInstr *_fptr = find_function_from_pc((p)->i);       \
+            if (_fptr) {                                            \
+                lttng_mfa_to_str(_fptr[0],_fptr[1],_fptr[2], Name); \
+            } else {                                                \
+                strcpy(Name, "<unknown>");                          \
+            }                                                       \
+        }                                                           \
+    } while(0)
+
+/* ErtsRunQueue->ErtsSchedulerData->Uint */
+#define lttng_rq_to_id(RQ) \
+    (RQ)->scheduler->no
+
+#define LTTNG_ENABLED(Name) \
+    tracepoint_enabled(com_ericsson_otp, Name)
+
+/* include a special LTTNG_DO for do_tracepoint ? */
+#define LTTNG1(Name, Arg1) \
+    tracepoint(com_ericsson_otp, Name, (Arg1))
+
+#define LTTNG2(Name, Arg1, Arg2) \
+    tracepoint(com_ericsson_otp, Name, (Arg1), (Arg2))
+
+#define LTTNG3(Name, Arg1, Arg2, Arg3) \
+    tracepoint(com_ericsson_otp, Name, (Arg1), (Arg2), (Arg3))
+
+#define LTTNG4(Name, Arg1, Arg2, Arg3, Arg4) \
+    tracepoint(com_ericsson_otp, Name, (Arg1), (Arg2), (Arg3), (Arg4))
+
+#define LTTNG5(Name, Arg1, Arg2, Arg3, Arg4, Arg5) \
+    tracepoint(com_ericsson_otp, Name, (Arg1), (Arg2), (Arg3), (Arg4), (Arg5))
+
+#else /* USE_LTTNG */
+
+#define LTTNG1(Name, Arg1) do {} while(0)
+#define LTTNG2(Name, Arg1, Arg2) do {} while(0)
+#define LTTNG3(Name, Arg1, Arg2, Arg3) do {} while(0)
+#define LTTNG4(Name, Arg1, Arg2, Arg3, Arg4) do {} while(0)
+#define LTTNG5(Name, Arg1, Arg2, Arg3, Arg4, Arg5) do {} while(0)
+
+#endif /* USE_LTTNG */
+#endif /* __LTTNG_WRAPPER_H__ */
diff --git a/erts/emulator/sys/common/erl_check_io.c b/erts/emulator/sys/common/erl_check_io.c
index f87196d724..0d5043fa2a 100644
--- a/erts/emulator/sys/common/erl_check_io.c
+++ b/erts/emulator/sys/common/erl_check_io.c
@@ -39,6 +39,7 @@
 #include "erl_check_io.h"
 #include "erl_thr_progress.h"
 #include "dtrace-wrapper.h"
+#include "lttng-wrapper.h"
 #define ERTS_WANT_TIMER_WHEEL_API
 #include "erl_time.h"
 
@@ -395,6 +396,7 @@ forget_removed(struct pollset_info* psi)
 	if (drv_ptr) {
 	    int was_unmasked = erts_block_fpe();
 	    DTRACE1(driver_stop_select, drv_ptr->name);
+	    LTTNG1(driver_stop_select, drv_ptr->name);
 	    (*drv_ptr->stop_select) ((ErlDrvEvent) fd, NULL);
 	    erts_unblock_fpe(was_unmasked);
 	    if (drv_ptr->handle) {
@@ -1055,6 +1057,7 @@ done_unknown:
     if (stop_select_fn) {
 	int was_unmasked = erts_block_fpe();
 	DTRACE1(driver_stop_select, name);
+	LTTNG1(driver_stop_select, "unknown");
 	(*stop_select_fn)(e, NULL);
 	erts_unblock_fpe(was_unmasked);
     }
diff --git a/erts/emulator/test/Makefile b/erts/emulator/test/Makefile
index 318db4b45e..0f716c11a1 100644
--- a/erts/emulator/test/Makefile
+++ b/erts/emulator/test/Makefile
@@ -70,6 +70,7 @@ MODULES= \
 	hash_SUITE \
 	hibernate_SUITE \
 	list_bif_SUITE \
+	lttng_SUITE \
 	map_SUITE \
 	match_spec_SUITE \
 	module_info_SUITE \
diff --git a/erts/emulator/test/lttng_SUITE.erl b/erts/emulator/test/lttng_SUITE.erl
new file mode 100644
index 0000000000..d0f6292d5b
--- /dev/null
+++ b/erts/emulator/test/lttng_SUITE.erl
@@ -0,0 +1,499 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1999-2011. All Rights Reserved.
+%% 
+%% 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%
+%%
+
+-module(lttng_SUITE).
+
+-export([all/0, suite/0]).
+-export([init_per_suite/1, end_per_suite/1]).
+-export([init_per_testcase/2, end_per_testcase/2]).
+
+-export([t_lttng_list/1,
+         t_carrier_pool/1,
+         t_memory_carrier/1,
+         t_async_io_pool/1,
+         t_driver_control_ready_async/1,
+         t_driver_start_stop/1,
+         t_driver_ready_input_output/1,
+         t_driver_timeout/1,
+         t_driver_caller/1,
+         t_driver_flush/1,
+         t_scheduler_poll/1]).
+
+-include_lib("common_test/include/ct.hrl").
+
+suite() ->
+    [{ct_hooks,[ts_install_cth]},
+     {timetrap, {seconds, 10}}].
+
+all() -> 
+    [t_lttng_list,
+     t_carrier_pool,
+     t_async_io_pool,
+     t_driver_start_stop,
+     t_driver_ready_input_output,
+     t_driver_control_ready_async,
+     t_driver_timeout,
+     t_driver_caller,
+     t_driver_flush,
+     t_scheduler_poll,
+     t_memory_carrier].
+
+
+init_per_suite(Config) ->
+    case erlang:system_info(dynamic_trace) of
+        lttng ->
+            ensure_lttng_stopped("--all"),
+            Config;
+        _ ->
+            {skip, "No LTTng configured on system."}
+    end.
+
+end_per_suite(_Config) ->
+    ensure_lttng_stopped("--all"),
+    ok.
+
+init_per_testcase(Case, Config) ->
+    Name = atom_to_list(Case),
+    ok = ensure_lttng_started(Name, Config),
+    [{session, Name}|Config].
+
+end_per_testcase(Case, _Config) ->
+    Name = atom_to_list(Case),
+    ok = ensure_lttng_stopped(Name),
+    ok.
+
+%% Not tested yet
+%%   com_ericsson_otp:driver_process_exit
+%%   com_ericsson_otp:driver_event
+
+%% tracepoints
+%%
+%%   com_ericsson_otp:carrier_pool_get
+%%   com_ericsson_otp:carrier_pool_put
+%%   com_ericsson_otp:carrier_destroy
+%%   com_ericsson_otp:carrier_create
+%%   com_ericsson_otp:aio_pool_add 
+%%   com_ericsson_otp:aio_pool_get 
+%%   com_ericsson_otp:driver_control
+%%   com_ericsson_otp:driver_call
+%%   com_ericsson_otp:driver_finish
+%%   com_ericsson_otp:driver_ready_async
+%%   com_ericsson_otp:driver_process_exit
+%%   com_ericsson_otp:driver_stop
+%%   com_ericsson_otp:driver_flush
+%%   com_ericsson_otp:driver_stop_select
+%%   com_ericsson_otp:driver_timeout
+%%   com_ericsson_otp:driver_event
+%%   com_ericsson_otp:driver_ready_output
+%%   com_ericsson_otp:driver_ready_input
+%%   com_ericsson_otp:driver_output
+%%   com_ericsson_otp:driver_outputv
+%%   com_ericsson_otp:driver_init
+%%   com_ericsson_otp:driver_start
+%%   com_ericsson_otp:scheduler_poll
+
+%%
+%% Testcases
+%%
+
+t_lttng_list(_Config) ->
+    {ok, _} = cmd("lttng list -u"),
+    ok.
+
+%% com_ericsson_otp:carrier_pool_get
+%% com_ericsson_otp:carrier_pool_put
+t_carrier_pool(Config) ->
+    case have_carriers() of
+        false ->
+            {skip, "No Memory Carriers configured on system."};
+        true ->
+            ok = lttng_start_event("com_ericsson_otp:carrier_pool*", Config),
+
+            ok = ets_load(),
+
+            Res = lttng_stop_and_view(Config),
+            ok = check_tracepoint("com_ericsson_otp:carrier_pool_get", Res),
+            ok = check_tracepoint("com_ericsson_otp:carrier_pool_put", Res),
+            ok
+    end.
+
+%% com_ericsson_otp:carrier_destroy
+%% com_ericsson_otp:carrier_create
+t_memory_carrier(Config) ->
+    case have_carriers() of
+        false ->
+            {skip, "No Memory Carriers configured on system."};
+        true ->
+            ok = lttng_start_event("com_ericsson_otp:carrier_*", Config),
+
+            ok = ets_load(),
+
+            Res = lttng_stop_and_view(Config),
+            ok = check_tracepoint("com_ericsson_otp:carrier_destroy", Res),
+            ok = check_tracepoint("com_ericsson_otp:carrier_create", Res),
+            ok
+    end.
+
+%% com_ericsson_otp:aio_pool_add
+%% com_ericsson_otp:aio_pool_get
+t_async_io_pool(Config) ->
+    case have_async_threads() of
+        false ->
+            {skip, "No Async Threads configured on system."};
+        true ->
+            ok = lttng_start_event("com_ericsson_otp:aio_pool_*", Config),
+
+            Path1 = proplists:get_value(priv_dir, Config),
+            {ok, [[Path2]]} = init:get_argument(home),
+            {ok, _} = file:list_dir(Path1),
+            {ok, _} = file:list_dir(Path2),
+            {ok, _} = file:list_dir(Path1),
+            {ok, _} = file:list_dir(Path2),
+
+            Res = lttng_stop_and_view(Config),
+            ok = check_tracepoint("com_ericsson_otp:aio_pool_add", Res),
+            ok = check_tracepoint("com_ericsson_otp:aio_pool_get", Res),
+            ok
+    end.
+
+
+%% com_ericsson_otp:driver_start
+%% com_ericsson_otp:driver_stop
+t_driver_start_stop(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_*", Config),
+    Path = proplists:get_value(priv_dir, Config),
+    Name = filename:join(Path, "sometext.txt"),
+    Bin  = txt(),
+    ok = file:write_file(Name, Bin),
+    {ok, Bin} = file:read_file(Name),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_start", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_stop", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_control", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_outputv", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_ready_async", Res),
+    ok.
+
+%% com_ericsson_otp:driver_control
+%% com_ericsson_otp:driver_outputv
+%% com_ericsson_otp:driver_ready_async
+t_driver_control_ready_async(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_control", Config),
+    ok = lttng_start_event("com_ericsson_otp:driver_outputv", Config),
+    ok = lttng_start_event("com_ericsson_otp:driver_ready_async", Config),
+    Path = proplists:get_value(priv_dir, Config),
+    Name = filename:join(Path, "sometext.txt"),
+    Bin  = txt(),
+    ok = file:write_file(Name, Bin),
+    {ok, Bin} = file:read_file(Name),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_control", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_outputv", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_ready_async", Res),
+    ok.
+
+%% com_ericsson_otp:driver_ready_input
+%% com_ericsson_otp:driver_ready_output
+t_driver_ready_input_output(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_ready_*", Config),
+    Me = self(),
+    Pid = spawn_link(fun() -> tcp_server(Me, active) end),
+    receive {Pid, accept} -> ok end,
+    Bin = txt(),
+    Sz  = byte_size(Bin),
+
+    {ok, Sock} = gen_tcp:connect("localhost", 5679, [binary, {packet, 2}]),
+    ok = gen_tcp:send(Sock, <<Sz:16, Bin/binary>>),
+    ok = gen_tcp:send(Sock, <<Sz:16, Bin/binary>>),
+    ok = gen_tcp:close(Sock),
+    receive {Pid, done} -> ok end,
+
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_ready_input", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_ready_output", Res),
+    ok.
+
+
+%% com_ericsson_otp:driver_stop_select
+%% com_ericsson_otp:driver_timeout
+t_driver_timeout(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_*", Config),
+    Me = self(),
+    Pid = spawn_link(fun() -> tcp_server(Me, timeout) end),
+    receive {Pid, accept} -> ok end,
+    {ok, Sock} = gen_tcp:connect("localhost", 5679, [binary]),
+    ok = gen_tcp:send(Sock, <<"hej">>),
+    receive {Pid, done} -> ok end,
+    ok = gen_tcp:close(Sock),
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_timeout", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_stop_select", Res),
+    ok.
+ 
+%% com_ericsson_otp:driver_call
+%% com_ericsson_otp:driver_output
+%% com_ericsson_otp:driver_init
+%% com_ericsson_otp:driver_finish
+t_driver_caller(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_*", Config),
+
+    Drv = 'caller_drv',
+    os:putenv("CALLER_DRV_USE_OUTPUTV", "false"),
+    
+    ok = load_driver(proplists:get_value(data_dir, Config), Drv),
+    Port = open_port({spawn, Drv}, []),
+    true = is_port(Port),
+
+    chk_caller(Port, start, self()),
+    chk_caller(Port, output, spawn_link(fun() ->
+                                                port_command(Port, "")
+                                        end)),
+    Port ! {self(), {command, ""}},
+    chk_caller(Port, output, self()),
+    chk_caller(Port, control, spawn_link(fun () ->
+                                                 port_control(Port, 0, "")
+                                         end)),
+    chk_caller(Port, call, spawn_link(fun() ->
+                                              erlang:port_call(Port, 0, "")
+                                      end)),
+ 
+    true = port_close(Port),
+    erl_ddll:unload_driver(Drv),
+
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_call", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_output", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_init", Res),
+    ok = check_tracepoint("com_ericsson_otp:driver_finish", Res),
+    ok.
+ 
+%% com_ericsson_otp:scheduler_poll
+t_scheduler_poll(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:scheduler_poll", Config),
+
+    ok = memory_load(),
+
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:scheduler_poll", Res),
+    ok.
+
+%% com_ericsson_otp:driver_flush
+t_driver_flush(Config) ->
+    ok = lttng_start_event("com_ericsson_otp:driver_flush", Config),
+
+    Me = self(),
+    Pid = spawn_link(fun() -> tcp_server(Me, passive_no_read) end),
+    receive {Pid, accept} -> ok end,
+    Bin = iolist_to_binary([txt() || _ <- lists:seq(1,100)]),
+    Sz  = byte_size(Bin),
+
+    %% We want to create a scenario where sendings stalls and we
+    %% queue packets in the driver.
+    %% When we close the socket it has to flush the queue.
+    {ok, Sock} = gen_tcp:connect("localhost", 5679, [binary, {packet, 2},
+                                                     {send_timeout, 10},
+                                                     {sndbuf, 10000000}]),
+    Pids = [spawn_link(fun() ->
+                               gen_tcp:send(Sock, <<Sz:16, Bin/binary>>),
+                               Me ! {self(), ok}
+                       end) || _ <- lists:seq(1,100)],
+    [receive {P, ok} -> ok end || P <- Pids],
+    ok = gen_tcp:close(Sock),
+    Pid ! die,
+    receive {Pid, done} -> ok end,
+
+    Res = lttng_stop_and_view(Config),
+    ok = check_tracepoint("com_ericsson_otp:driver_flush", Res),
+    ok.
+
+%%
+%% AUX
+%%
+
+chk_caller(Port, Callback, ExpectedCaller) ->
+    receive
+        {caller, Port, Callback, Caller} ->
+            ExpectedCaller = Caller
+    end.
+
+
+ets_load() ->
+    Tid = ets:new(ets_load, [public,set]),
+    N = erlang:system_info(schedulers_online),
+    Pids = [spawn_link(fun() -> ets_shuffle(Tid) end) || _ <- lists:seq(1,N)],
+    ok = ets_kill(Pids, 500),
+    ok.
+
+
+ets_kill([], _) -> ok;
+ets_kill([Pid|Pids], Time) ->
+    timer:sleep(Time),
+    Pid ! done,
+    ets_kill(Pids, Time).
+
+ets_shuffle(Tid) ->
+    Payload = lists:duplicate(100, $x),
+    ets_shuffle(Tid, 100, Payload).
+ets_shuffle(Tid, I, Data) ->
+    ets_shuffle(Tid, I, I, Data, Data).
+
+ets_shuffle(Tid, 0, N, _, Data) ->
+    ets_shuffle(Tid, N, N, Data, Data);
+ets_shuffle(Tid, I, N, Data, Data0) ->
+    receive
+        done -> ok
+    after 0 ->
+              Key = rand:uniform(1000),
+              Data1 = [I|Data],
+              ets:insert(Tid, {Key, Data1}),
+              ets_shuffle(Tid, I - 1, N, Data1, Data0)
+    end.
+
+
+
+
+memory_load() ->
+    Me = self(),
+    Pids0 = [spawn_link(fun() -> memory_loop(Me, 20, <<42>>) end) || _ <- lists:seq(1,30)],
+    timer:sleep(50),
+    Pids1 = [spawn_link(fun() -> memory_loop(Me, 20, <<42>>) end) || _ <- lists:seq(1,30)],
+    [receive {Pid, done} -> ok end || Pid <- Pids0 ++ Pids1],
+    timer:sleep(500),
+    ok.
+
+memory_loop(Parent, N, Bin) ->
+    memory_loop(Parent, N, Bin, []).
+
+memory_loop(Parent, 0, _Bin, _) ->
+    Parent ! {self(), done};
+memory_loop(Parent, N, Bin0, Ls) ->
+    Bin = binary:copy(<<Bin0/binary, Bin0/binary>>),
+    memory_loop(Parent, N - 1, Bin, [a,b,c|Ls]).
+
+tcp_server(Pid, Type) ->
+    {ok, LSock} = gen_tcp:listen(5679, [binary,
+                                        {reuseaddr, true},
+                                        {active, false}]),
+    Pid ! {self(), accept},
+    {ok, Sock} = gen_tcp:accept(LSock),
+    case Type of
+        passive_no_read ->
+            receive die -> ok end;
+        active ->
+            inet:setopts(Sock, [{active, once}, {packet,2}]),
+            receive Msg1 -> io:format("msg1: ~p~n", [Msg1]) end,
+            inet:setopts(Sock, [{active, once}, {packet,2}]),
+            receive Msg2 -> io:format("msg2: ~p~n", [Msg2]) end,
+            ok = gen_tcp:close(Sock);
+        timeout ->
+            Res = gen_tcp:recv(Sock, 2000, 1000),
+            io:format("res ~p~n", [Res])
+    end,
+    Pid ! {self(), done},
+    ok.
+
+txt() ->
+    <<"%% tracepoints\n"
+      "%%\n"
+      "%%   com_ericsson_otp:carrier_pool_get\n"
+      "%%   com_ericsson_otp:carrier_pool_put\n"
+      "%%   com_ericsson_otp:carrier_destroy\n"
+      "%%   com_ericsson_otp:carrier_create\n"
+      "%%   com_ericsson_otp:aio_pool_add\n"
+      "%%   com_ericsson_otp:aio_pool_get\n"
+      "%%   com_ericsson_otp:driver_control\n"
+      "%%   com_ericsson_otp:driver_call\n"
+      "%%   com_ericsson_otp:driver_finish\n"
+      "%%   com_ericsson_otp:driver_ready_async\n"
+      "%%   com_ericsson_otp:driver_process_exit\n"
+      "%%   com_ericsson_otp:driver_stop\n"
+      "%%   com_ericsson_otp:driver_flush\n"
+      "%%   com_ericsson_otp:driver_stop_select\n"
+      "%%   com_ericsson_otp:driver_timeout\n"
+      "%%   com_ericsson_otp:driver_event\n"
+      "%%   com_ericsson_otp:driver_ready_output\n"
+      "%%   com_ericsson_otp:driver_ready_input\n"
+      "%%   com_ericsson_otp:driver_output\n"
+      "%%   com_ericsson_otp:driver_outputv\n"
+      "%%   com_ericsson_otp:driver_init\n"
+      "%%   com_ericsson_otp:driver_start\n"
+      "%%   com_ericsson_otp:scheduler_poll">>.
+
+load_driver(Dir, Driver) ->
+    case erl_ddll:load_driver(Dir, Driver) of
+        ok -> ok;
+        {error, Error} = Res ->
+            io:format("~s\n", [erl_ddll:format_error(Error)]),
+            Res
+    end.
+
+%% check
+
+have_carriers() ->
+    Cap = element(3,erlang:system_info(allocator)),
+    case Cap -- [sys_alloc,sys_aligned_alloc] of
+        [] -> false;
+        _  -> true
+    end.
+
+have_async_threads() ->
+    Tps = erlang:system_info(thread_pool_size),
+    if Tps =:= 0 -> false;
+       true -> true
+    end.
+
+%% lttng
+lttng_stop_and_view(Config) ->
+    Path = proplists:get_value(priv_dir, Config),
+    Name = proplists:get_value(session, Config),
+    {ok,_} = cmd("lttng stop " ++ Name),
+    {ok,Res} = cmd("lttng view " ++ Name ++ " --trace-path=" ++ Path),
+    Res.
+
+check_tracepoint(TP, Data) ->
+    case re:run(Data, TP, [global]) of
+        {match, _} -> ok;
+        _ -> notfound
+    end.
+
+lttng_start_event(Event, Config) ->
+    Name = proplists:get_value(session, Config),
+    {ok, _} = cmd("lttng enable-event -u " ++ Event ++ " --session=" ++ Name),
+    {ok, _} = cmd("lttng start " ++ Name),
+    ok.
+
+ensure_lttng_started(Name, Config) ->
+    Out = case proplists:get_value(priv_dir, Config) of
+              undefined -> [];
+              Path -> "--output="++Path++" "
+          end,
+    {ok,_} = cmd("lttng create " ++ Out ++ Name),
+    ok.
+
+ensure_lttng_stopped(Name) ->
+    {ok,_} = cmd("lttng stop"),
+    {ok,_} = cmd("lttng destroy " ++ Name),
+    ok.
+
+cmd(Cmd) ->
+    io:format("<< ~ts~n", [Cmd]),
+    Res = os:cmd(Cmd),
+    io:format(">> ~ts~n", [Res]),
+    {ok,Res}.
diff --git a/erts/emulator/test/lttng_SUITE_data/Makefile.src b/erts/emulator/test/lttng_SUITE_data/Makefile.src
new file mode 100644
index 0000000000..fe7a1b6ef3
--- /dev/null
+++ b/erts/emulator/test/lttng_SUITE_data/Makefile.src
@@ -0,0 +1,7 @@
+
+MISC_DRVS = caller_drv@dll@
+
+
+all: $(MISC_DRVS)
+
+@SHLIB_RULES@
diff --git a/erts/emulator/test/lttng_SUITE_data/caller_drv.c b/erts/emulator/test/lttng_SUITE_data/caller_drv.c
new file mode 100644
index 0000000000..86fd0a2995
--- /dev/null
+++ b/erts/emulator/test/lttng_SUITE_data/caller_drv.c
@@ -0,0 +1,159 @@
+/* ``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.
+ * 
+ * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
+ * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
+ * AB. All Rights Reserved.''
+ * 
+ *     $Id$
+ */
+
+#include <stdlib.h>
+#include <string.h>
+#include "erl_driver.h"
+
+static int init();
+static void stop(ErlDrvData drv_data);
+static void finish();
+static void flush(ErlDrvData drv_data);
+static ErlDrvData start(ErlDrvPort port, char *command);
+static void output(ErlDrvData drv_data, char *buf, ErlDrvSizeT len);
+static void outputv(ErlDrvData drv_data, ErlIOVec *ev);
+static ErlDrvSSizeT control(ErlDrvData drv_data,
+			    unsigned int command, char *buf,
+			    ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen);
+static ErlDrvSSizeT call(ErlDrvData drv_data,
+			 unsigned int command,
+			 char *buf, ErlDrvSizeT len,
+			 char **rbuf, ErlDrvSizeT rlen,
+			 unsigned int *flags);
+
+static ErlDrvEntry caller_drv_entry = { 
+    init,
+    start,
+    stop,
+    output,
+    NULL /* ready_input */,
+    NULL /* ready_output */,
+    "caller_drv",
+    finish,
+    NULL /* handle */,
+    control,
+    NULL /* timeout */,
+    outputv,
+    NULL /* ready_async */,
+    flush,
+    call,
+    NULL /* event */,
+    ERL_DRV_EXTENDED_MARKER,
+    ERL_DRV_EXTENDED_MAJOR_VERSION,
+    ERL_DRV_EXTENDED_MINOR_VERSION,
+    ERL_DRV_FLAG_USE_PORT_LOCKING,
+    NULL /* handle2 */,
+    NULL /* handle_monitor */
+};
+
+DRIVER_INIT(caller_drv)
+{
+    char buf[10];
+    size_t bufsz = sizeof(buf);
+    char *use_outputv;
+    use_outputv = (erl_drv_getenv("CALLER_DRV_USE_OUTPUTV", buf, &bufsz) == 0
+		   ? buf
+		   : "false");
+    if (strcmp(use_outputv, "true") != 0)
+	caller_drv_entry.outputv = NULL;
+    return &caller_drv_entry;
+}
+
+void
+send_caller(ErlDrvData drv_data, char *func)
+{
+    int res;
+    ErlDrvPort port = (ErlDrvPort) drv_data;
+    ErlDrvTermData msg[] = {
+	ERL_DRV_ATOM,	driver_mk_atom("caller"),
+	ERL_DRV_PORT,	driver_mk_port(port),
+	ERL_DRV_ATOM,	driver_mk_atom(func),
+	ERL_DRV_PID,	driver_caller(port),
+	ERL_DRV_TUPLE,	(ErlDrvTermData) 4
+    };
+    res = erl_drv_output_term(driver_mk_port(port), msg, sizeof(msg)/sizeof(ErlDrvTermData));
+    if (res <= 0)
+	driver_failure_atom(port, "erl_drv_output_term failed");
+}
+
+static int
+init() {
+    return 0;
+}
+
+static void
+stop(ErlDrvData drv_data)
+{
+
+}
+
+static void
+flush(ErlDrvData drv_data)
+{
+
+}
+
+static void
+finish()
+{
+
+}
+
+static ErlDrvData
+start(ErlDrvPort port, char *command)
+{
+    send_caller((ErlDrvData) port, "start");
+    return (ErlDrvData) port;
+}
+
+static void
+output(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
+{
+    send_caller(drv_data, "output");
+}
+
+static void
+outputv(ErlDrvData drv_data, ErlIOVec *ev)
+{
+    send_caller(drv_data, "outputv");
+}
+
+static ErlDrvSSizeT
+control(ErlDrvData drv_data,
+	unsigned int command, char *buf, 
+	ErlDrvSizeT len, char **rbuf, ErlDrvSizeT rlen)
+{
+    send_caller(drv_data, "control");
+    return 0;
+}
+
+static ErlDrvSSizeT
+call(ErlDrvData drv_data,
+     unsigned int command,
+     char *buf, ErlDrvSizeT len,
+     char **rbuf, ErlDrvSizeT rlen,
+     unsigned int *flags)
+{
+    /* echo call */
+    if (len > rlen)
+	*rbuf = driver_alloc(len);
+    memcpy((void *) *rbuf, (void *) buf, len);
+    send_caller(drv_data, "call");
+    return len;
+}