Merge unknown syscall method with extended detail method

Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/Makefile b/Makefile
index 0de745f616be9ac8170eab3a696545889e04f9af..d25c3be33eb0cd11461bb9c9d697e3de37b69b82 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -21,7 +21,9 @@ ltt-relay-objs :=  ltt-events.o ltt-debugfs-abi.o \
                        lttng-context-vtid.o lttng-context-ppid.o \
                        lttng-context-vppid.o lttng-calibrate.o
 
-#add for testing       lttng-syscalls.o
+ifneq ($(CONFIG_HAVE_SYSCALL_TRACEPOINTS),)
+ltt-relay-objs += lttng-syscalls.o
+endif
 
 ifneq ($(CONFIG_PERF_EVENTS),)
 ltt-relay-objs += $(shell \

diff --git a/instrumentation/syscalls/headers/syscalls_unknown.h b/instrumentation/syscalls/headers/syscalls_unknown.h
new file mode 100644 (file)
index 0000000..ad39e2d
--- /dev/null
+++ b/instrumentation/syscalls/headers/syscalls_unknown.h
@@ -0,0 +1,45 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM syscalls_unknown
+
+#if !defined(_TRACE_SYSCALLS_UNKNOWN_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_SYSCALLS_UNKNOWN_H
+
+#include <linux/tracepoint.h>
+#include <linux/syscalls.h>
+
+#define UNKNOWN_SYSCALL_NRARGS 6
+
+TRACE_EVENT(sys_unknown,
+       TP_PROTO(unsigned int id, unsigned long *args),
+       TP_ARGS(id, args),
+       TP_STRUCT__entry(
+               __field(unsigned int, id)
+               __array(unsigned long, args, UNKNOWN_SYSCALL_NRARGS)
+       ),
+       TP_fast_assign(
+               tp_assign(id, id)
+               tp_memcpy(args, args, UNKNOWN_SYSCALL_NRARGS * sizeof(*args))
+       ),
+       TP_printk()
+)
+/* 
+ * This is going to hook on sys_exit in the kernel.
+ * We change the name so we don't clash with the sys_exit syscall entry
+ * event.
+ */
+TRACE_EVENT(exit_syscall,
+       TP_PROTO(long errno),
+       TP_ARGS(errno),
+       TP_STRUCT__entry(
+               __field(long, errno)
+       ),
+       TP_fast_assign(
+               tp_assign(errno, errno)
+       ),
+       TP_printk()
+)
+
+#endif /*  _TRACE_SYSCALLS_UNKNOWN_H */
+
+/* This part must be outside protection */
+#include "../../../probes/define_trace.h"

diff --git a/ltt-events.h b/ltt-events.h
index a556e5dfdb5a939d28cac269059329a010d3ed77..2437e76eab5296f8459869bbde249eec6e1f9edd 100644 (file)
--- a/ltt-events.h
+++ b/ltt-events.h
@@ -300,7 +300,7 @@ void ltt_event_put(const struct lttng_event_desc *desc);
 int ltt_probes_init(void);
 void ltt_probes_exit(void);
 
-#ifdef SYSCALL_DETAIL
+#ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 int lttng_syscalls_register(struct ltt_channel *chan, void *filter);
 int lttng_syscalls_unregister(struct ltt_channel *chan);
 #else

diff --git a/lttng-syscalls.c b/lttng-syscalls.c
index c0550ab0d08b692c50fa1b205b0566a96eca9575..1872f161faa22955587c609bbc8eb7013edebcde 100644 (file)
--- a/lttng-syscalls.c
+++ b/lttng-syscalls.c
@@ -37,6 +37,7 @@ static void syscall_entry_probe(void *__data, struct pt_regs *regs, long id);
 #define TRACE_INCLUDE_PATH ../instrumentation/syscalls/headers
 #include "instrumentation/syscalls/headers/syscalls_integers.h"
 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
+#include "instrumentation/syscalls/headers/syscalls_unknown.h"
 
 #undef TP_MODULE_OVERRIDE
 #undef TP_PROBE_CB
@@ -66,6 +67,8 @@ static struct trace_syscall_entry sc_table[] = {
 #include "instrumentation/syscalls/headers/syscalls_pointers.h"
 };
 
+static int sc_table_filled;
+
 #undef CREATE_SYSCALL_TABLE
 
 static void syscall_entry_probe(void *__data, struct pt_regs *regs, long id)
@@ -170,6 +173,27 @@ static void syscall_entry_probe(void *__data, struct pt_regs *regs, long id)
        }
 }
 
+static void fill_sc_table(void)
+{
+       int i;
+
+       if (sc_table_filled) {
+               smp_rmb();      /* read flag before table */
+               return;
+       }
+
+       for (i = 0; i < ARRAY_SIZE(sc_table); i++) {
+               if (sc_table[i].func)
+                       continue;
+               sc_table[i].func = __event_probe__sys_unknown;
+               sc_table[i].nrargs = UNKNOWN_SYSCALL_NRARGS;
+               sc_table[i].fields = __event_fields___sys_unknown;
+               sc_table[i].desc = &__event_desc___sys_unknown;
+       }
+       smp_wmb();      /* Fill sc table before set flag to 1 */
+       sc_table_filled = 1;
+}
+
 int lttng_syscalls_register(struct ltt_channel *chan, void *filter)
 {
        unsigned int i;
@@ -177,6 +201,8 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter)
 
        wrapper_vmalloc_sync_all();
 
+       fill_sc_table();
+
        if (!chan->sc_table) {
                /* create syscall table mapping syscall to events */
                chan->sc_table = kzalloc(sizeof(struct ltt_event *)
@@ -190,8 +216,7 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter)
                struct lttng_kernel_event ev;
                const struct lttng_event_desc *desc = sc_table[i].desc;
 
-               if (!desc)
-                       continue;
+               WARN_ON_ONCE(!desc);
                /*
                 * Skip those already populated by previous failed
                 * register for this channel.
@@ -216,6 +241,18 @@ int lttng_syscalls_register(struct ltt_channel *chan, void *filter)
        }
        ret = tracepoint_probe_register("sys_enter",
                        (void *) syscall_entry_probe, chan);
+       if (ret)
+               return ret;
+       /*
+        * We change the name of sys_exit tracepoint due to namespace
+        * conflict with sys_exit syscall entry.
+        */
+       ret = tracepoint_probe_register("sys_exit",
+                       (void *) __event_probe__exit_syscall, chan);
+       if (ret) {
+               WARN_ON_ONCE(tracepoint_probe_unregister("sys_enter",
+                       (void *) syscall_entry_probe, chan));
+       }
        return ret;
 }
 
@@ -228,6 +265,10 @@ int lttng_syscalls_unregister(struct ltt_channel *chan)
 
        if (!chan->sc_table)
                return 0;
+       ret = tracepoint_probe_unregister("sys_exit",
+                       (void *) __event_probe__exit_syscall, chan);
+       if (ret)
+               return ret;
        ret = tracepoint_probe_unregister("sys_enter",
                        (void *) syscall_entry_probe, chan);
        if (ret)

diff --git a/probes/Makefile b/probes/Makefile
index 8b02d5f5b5eaa3adcf43d657bfef940627ed301c..794a06993a8e0efac2a8147b6c3bf0fd8c1119ac 100644 (file)
--- a/probes/Makefile
+++ b/probes/Makefile
@@ -13,10 +13,6 @@ obj-m += lttng-probe-lttng.o
 obj-m += lttng-probe-sched.o
 obj-m += lttng-probe-irq.o
 
-ifneq ($(CONFIG_HAVE_SYSCALL_TRACEPOINTS),)
-obj-m += lttng-probe-syscalls.o
-endif
-
 ifneq ($(CONFIG_KVM),)
 obj-m += lttng-probe-kvm.o
 endif

diff --git a/probes/lttng-probe-syscalls.c b/probes/lttng-probe-syscalls.c
deleted file mode 100644 (file)
index 8ce73df..0000000
--- a/probes/lttng-probe-syscalls.c
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * probes/lttng-probe-syscalls.c
- *
- * Copyright 2010 (c) - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * LTTng syscalls probes.
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include "../ltt-events.h"
-
-/*
- * Create the tracepoint static inlines from the kernel to validate that our
- * trace event macros match the kernel we run on.
- */
-#include <trace/events/syscalls.h>
-
-/*
- * Create LTTng tracepoint probes.
- */
-#define LTTNG_PACKAGE_BUILD
-#define CREATE_TRACE_POINTS
-#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
-
-#include "../instrumentation/events/lttng-module/syscalls.h"
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@efficios.com>");
-MODULE_DESCRIPTION("LTTng generic syscall probes");