Fix file permissions for lttng-statedump-impl.c

[lttng-modules.git] / lttng-statedump-impl.c

diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c
index be498acc437155223dd50bcc944cced350fa017e..a633657a3966ca702410eac440c0def819fc8d17 100644 (file)
--- a/lttng-statedump-impl.c
+++ b/lttng-statedump-impl.c
@@ -49,8 +49,12 @@
 #include "lttng-events.h"
 #include "wrapper/irqdesc.h"
 #include "wrapper/spinlock.h"
+#include "wrapper/fdtable.h"
+#include "wrapper/nsproxy.h"
+#include "wrapper/irq.h"
+#include "wrapper/tracepoint.h"
 
-#ifdef CONFIG_GENERIC_HARDIRQS
+#ifdef CONFIG_LTTNG_HAS_LIST_IRQ
 #include <linux/irq.h>
 #endif
 
@@ -60,6 +64,12 @@
 #define TRACE_INCLUDE_FILE lttng-statedump
 #include "instrumentation/events/lttng-module/lttng-statedump.h"
 
+struct lttng_fd_ctx {
+       char *page;
+       struct lttng_session *session;
+       struct task_struct *p;
+};
+
 /*
  * Protected by the trace lock.
  */
@@ -141,34 +151,35 @@ int lttng_enumerate_network_ip_interface(struct lttng_session *session)
 }
 #endif /* CONFIG_INET */
 
+static
+int lttng_dump_one_fd(const void *p, struct file *file, unsigned int fd)
+{
+       const struct lttng_fd_ctx *ctx = p;
+       const char *s = d_path(&file->f_path, ctx->page, PAGE_SIZE);
+
+       if (IS_ERR(s)) {
+               struct dentry *dentry = file->f_path.dentry;
+
+               /* Make sure we give at least some info */
+               spin_lock(&dentry->d_lock);
+               trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd,
+                       dentry->d_name.name);
+               spin_unlock(&dentry->d_lock);
+               goto end;
+       }
+       trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s);
+end:
+       return 0;
+}
 
 static
 void lttng_enumerate_task_fd(struct lttng_session *session,
                struct task_struct *p, char *tmp)
 {
-       struct fdtable *fdt;
-       struct file *filp;
-       unsigned int i;
-       const unsigned char *path;
+       struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .p = p };
 
        task_lock(p);
-       if (!p->files)
-               goto unlock_task;
-       spin_lock(&p->files->file_lock);
-       fdt = files_fdtable(p->files);
-       for (i = 0; i < fdt->max_fds; i++) {
-               filp = fcheck_files(p->files, i);
-               if (!filp)
-                       continue;
-               path = d_path(&filp->f_path, tmp, PAGE_SIZE);
-               /* Make sure we give at least some info */
-               trace_lttng_statedump_file_descriptor(session, p, i,
-                       IS_ERR(path) ?
-                               filp->f_dentry->d_name.name :
-                               path);
-       }
-       spin_unlock(&p->files->file_lock);
-unlock_task:
+       lttng_iterate_fd(p->files, 0, lttng_dump_one_fd, &ctx);
        task_unlock(p);
 }
 
@@ -235,7 +246,7 @@ int lttng_enumerate_vm_maps(struct lttng_session *session)
 }
 #endif
 
-#ifdef CONFIG_GENERIC_HARDIRQS
+#ifdef CONFIG_LTTNG_HAS_LIST_IRQ
 
 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39))
 #define irq_desc_get_chip(desc) get_irq_desc_chip(desc)
@@ -268,7 +279,7 @@ void lttng_list_interrupts(struct lttng_session *session)
 }
 #else
 static inline
-void list_interrupts(struct lttng_session *session)
+void lttng_list_interrupts(struct lttng_session *session)
 {
 }
 #endif
@@ -287,7 +298,7 @@ void lttng_statedump_process_ns(struct lttng_session *session,
        rcu_read_lock();
        proxy = task_nsproxy(p);
        if (proxy) {
-               pid_ns = proxy->pid_ns;
+               pid_ns = lttng_get_proxy_pid_ns(proxy);
                do {
                        trace_lttng_statedump_process_state(session,
                                p, type, mode, submode, status, pid_ns);
@@ -372,7 +383,6 @@ int do_lttng_statedump(struct lttng_session *session)
 {
        int cpu;
 
-       printk(KERN_DEBUG "LTT state dump thread start\n");
        trace_lttng_statedump_start(session);
        lttng_enumerate_process_states(session);
        lttng_enumerate_file_descriptors(session);
@@ -397,10 +407,9 @@ int do_lttng_statedump(struct lttng_session *session)
                schedule_delayed_work_on(cpu, &cpu_work[cpu], 0);
        }
        /* Wait for all threads to run */
-       __wait_event(statedump_wq, (atomic_read(&kernel_threads_to_run) != 0));
+       __wait_event(statedump_wq, (atomic_read(&kernel_threads_to_run) == 0));
        put_online_cpus();
        /* Our work is done */
-       printk(KERN_DEBUG "LTT state dump end\n");
        trace_lttng_statedump_end(session);
        return 0;
 }
@@ -410,11 +419,32 @@ int do_lttng_statedump(struct lttng_session *session)
  */
 int lttng_statedump_start(struct lttng_session *session)
 {
-       printk(KERN_DEBUG "LTTng: state dump begin\n");
        return do_lttng_statedump(session);
 }
 EXPORT_SYMBOL_GPL(lttng_statedump_start);
 
+static
+int __init lttng_statedump_init(void)
+{
+       /*
+        * Allow module to load even if the fixup cannot be done. This
+        * will allow seemless transition when the underlying issue fix
+        * is merged into the Linux kernel, and when tracepoint.c
+        * "tracepoint_module_notify" is turned into a static function.
+        */
+       (void) wrapper_lttng_fixup_sig(THIS_MODULE);
+       return 0;
+}
+
+module_init(lttng_statedump_init);
+
+static
+void __exit lttng_statedump_exit(void)
+{
+}
+
+module_exit(lttng_statedump_exit);
+
 MODULE_LICENSE("GPL and additional rights");
 MODULE_AUTHOR("Jean-Hugues Deschenes");
 MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Statedump");