Fix: incorrect rwbs field type in block_bio_queue

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

diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c
index 04acf6eff3409beb78944fad9476d44c74098cec..e9fe829f17bad251a4a985997c011c7acdd2f191 100644 (file)
--- a/lttng-statedump-impl.c
+++ b/lttng-statedump-impl.c
@@ -45,13 +45,19 @@
 #include <linux/swap.h>
 #include <linux/wait.h>
 #include <linux/mutex.h>
+#include <linux/device.h>
 
 #include "lttng-events.h"
+#include "lttng-tracer.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"
+#include "wrapper/genhd.h"
 
-#ifdef CONFIG_GENERIC_HARDIRQS
+#ifdef CONFIG_LTTNG_HAS_LIST_IRQ
 #include <linux/irq.h>
 #endif
 
@@ -61,6 +67,14 @@
 #define TRACE_INCLUDE_FILE lttng-statedump
 #include "instrumentation/events/lttng-module/lttng-statedump.h"
 
+DEFINE_TRACE(lttng_statedump_block_device);
+DEFINE_TRACE(lttng_statedump_end);
+DEFINE_TRACE(lttng_statedump_interrupt);
+DEFINE_TRACE(lttng_statedump_file_descriptor);
+DEFINE_TRACE(lttng_statedump_start);
+DEFINE_TRACE(lttng_statedump_process_state);
+DEFINE_TRACE(lttng_statedump_network_interface);
+
 struct lttng_fd_ctx {
        char *page;
        struct lttng_session *session;
@@ -104,7 +118,49 @@ enum lttng_process_status {
        LTTNG_DEAD = 7,
 };
 
+static
+int lttng_enumerate_block_devices(struct lttng_session *session)
+{
+       struct class *ptr_block_class;
+       struct device_type *ptr_disk_type;
+       struct class_dev_iter iter;
+       struct device *dev;
+
+       ptr_block_class = wrapper_get_block_class();
+       if (!ptr_block_class)
+               return -ENOSYS;
+       ptr_disk_type = wrapper_get_disk_type();
+       if (!ptr_disk_type) {
+               return -ENOSYS;
+       }
+       class_dev_iter_init(&iter, ptr_block_class, NULL, ptr_disk_type);
+       while ((dev = class_dev_iter_next(&iter))) {
+               struct disk_part_iter piter;
+               struct gendisk *disk = dev_to_disk(dev);
+               struct hd_struct *part;
+
+               disk_part_iter_init(&piter, disk, DISK_PITER_INCL_PART0);
+               while ((part = disk_part_iter_next(&piter))) {
+                       char name_buf[BDEVNAME_SIZE];
+                       char *p;
+
+                       p = wrapper_disk_name(disk, part->partno, name_buf);
+                       if (!p) {
+                               disk_part_iter_exit(&piter);
+                               class_dev_iter_exit(&iter);
+                               return -ENOSYS;
+                       }
+                       trace_lttng_statedump_block_device(session,
+                                       part_devt(part), name_buf);
+               }
+               disk_part_iter_exit(&piter);
+       }
+       class_dev_iter_exit(&iter);
+       return 0;
+}
+
 #ifdef CONFIG_INET
+
 static
 void lttng_enumerate_device(struct lttng_session *session,
                struct net_device *dev)
@@ -243,7 +299,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)
@@ -276,7 +332,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
@@ -295,7 +351,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);
@@ -380,13 +436,13 @@ 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);
        /* FIXME lttng_enumerate_vm_maps(session); */
        lttng_list_interrupts(session);
        lttng_enumerate_network_ip_interface(session);
+       lttng_enumerate_block_devices(session);
 
        /* TODO lttng_dump_idt_table(session); */
        /* TODO lttng_dump_softirq_vec(session); */
@@ -408,7 +464,6 @@ int do_lttng_statedump(struct lttng_session *session)
        __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;
 }
@@ -418,11 +473,36 @@ 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");
+MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "."
+       __stringify(LTTNG_MODULES_MINOR_VERSION) "."
+       __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION)
+       LTTNG_MODULES_EXTRAVERSION);