erts: Add lttng tracepoints for drivers

* driver_event
* driver_flush
* driver_finish
* driver_init
* driver_output
* driver_outputv
* driver_process_exit
* driver_ready_async
* driver_ready_input
* driver_ready_output
* driver_start
* driver_stop
* driver_stop_select
* driver_timeout

4 files changed, 359 insertions, 1 deletions

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_port_task.c b/erts/emulator/beam/erl_port_task.c
index e85395e062..377e47adde 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 {								\
@@ -1728,6 +1741,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);
 		}
 	    }
@@ -1736,6 +1750,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,
@@ -1747,6 +1762,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);
@@ -1756,6 +1772,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/erlang_lttng.h b/erts/emulator/beam/erlang_lttng.h
index 5b5dc5548e..b5cd90d93e 100644
--- a/erts/emulator/beam/erlang_lttng.h
+++ b/erts/emulator/beam/erlang_lttng.h
@@ -59,6 +59,255 @@ typedef struct {
 #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)
+    )
+)
+
+
 /* Memory Allocator */
 
 TRACEPOINT_EVENT(
diff --git a/erts/emulator/beam/io.c b/erts/emulator/beam/io.c
index 797e4cdadc..b213be23db 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)
@@ -1724,6 +1737,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);
@@ -1826,6 +1848,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);
@@ -1949,7 +1980,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];
@@ -3489,6 +3519,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);
 	}
@@ -3551,6 +3592,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();
@@ -3881,6 +3932,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,
@@ -4294,6 +4355,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);
 
@@ -5056,6 +5126,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();
@@ -7102,6 +7181,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);
@@ -7579,6 +7667,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;