1 files changed, 65 insertions, 1 deletions

diff --git a/kernel/module.c b/kernel/module.c
index 9db11911e04..661d73db786 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -46,6 +46,7 @@
 #include <asm/cacheflush.h>
 #include <linux/license.h>
 #include <asm/sections.h>
+#include <linux/tracepoint.h>
 
 #if 0
 #define DEBUGP printk
@@ -1831,6 +1832,8 @@ static noinline struct module *load_module(void __user *umod,
 #endif
         unsigned int markersindex;
         unsigned int markersstringsindex;
+        unsigned int tracepointsindex;
+        unsigned int tracepointsstringsindex;
         struct module *mod;
         long err = 0;
         void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
@@ -2117,6 +2120,9 @@ static noinline struct module *load_module(void __user *umod,
         markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");
         markersstringsindex = find_sec(hdr, sechdrs, secstrings,
                                         "__markers_strings");
+        tracepointsindex = find_sec(hdr, sechdrs, secstrings, "__tracepoints");
+        tracepointsstringsindex = find_sec(hdr, sechdrs, secstrings,
+                                        "__tracepoints_strings");
 
         /* Now do relocations. */
         for (i = 1; i < hdr->e_shnum; i++) {
@@ -2144,6 +2150,12 @@ static noinline struct module *load_module(void __user *umod,
         mod->num_markers =
                 sechdrs[markersindex].sh_size / sizeof(*mod->markers);
 #endif
+#ifdef CONFIG_TRACEPOINTS
+        mod->tracepoints = (void *)sechdrs[tracepointsindex].sh_addr;
+        mod->num_tracepoints =
+                sechdrs[tracepointsindex].sh_size / sizeof(*mod->tracepoints);
+#endif
+
 
         /* Find duplicate symbols */
         err = verify_export_symbols(mod);
@@ -2162,11 +2174,16 @@ static noinline struct module *load_module(void __user *umod,
 
         add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);
 
+        if (!mod->taints) {
 #ifdef CONFIG_MARKERS
-        if (!mod->taints)
                 marker_update_probe_range(mod->markers,
                         mod->markers + mod->num_markers);
 #endif
+#ifdef CONFIG_TRACEPOINTS
+                tracepoint_update_probe_range(mod->tracepoints,
+                        mod->tracepoints + mod->num_tracepoints);
+#endif
+        }
         err = module_finalize(hdr, sechdrs, mod);
         if (err < 0)
                 goto cleanup;
@@ -2717,3 +2734,50 @@ void module_update_markers(void)
         mutex_unlock(&module_mutex);
 }
 #endif
+
+#ifdef CONFIG_TRACEPOINTS
+void module_update_tracepoints(void)
+{
+        struct module *mod;
+
+        mutex_lock(&module_mutex);
+        list_for_each_entry(mod, &modules, list)
+                if (!mod->taints)
+                        tracepoint_update_probe_range(mod->tracepoints,
+                                mod->tracepoints + mod->num_tracepoints);
+        mutex_unlock(&module_mutex);
+}
+
+/*
+ * Returns 0 if current not found.
+ * Returns 1 if current found.
+ */
+int module_get_iter_tracepoints(struct tracepoint_iter *iter)
+{
+        struct module *iter_mod;
+        int found = 0;
+
+        mutex_lock(&module_mutex);
+        list_for_each_entry(iter_mod, &modules, list) {
+                if (!iter_mod->taints) {
+                        /*
+                         * Sorted module list
+                         */
+                        if (iter_mod < iter->module)
+                                continue;
+                        else if (iter_mod > iter->module)
+                                iter->tracepoint = NULL;
+                        found = tracepoint_get_iter_range(&iter->tracepoint,
+                                iter_mod->tracepoints,
+                                iter_mod->tracepoints
+                                        + iter_mod->num_tracepoints);
+                        if (found) {
+                                iter->module = iter_mod;
+                                break;
+                        }
+                }
+        }
+        mutex_unlock(&module_mutex);
+        return found;
+}
+#endif