X-Git-Url: http://git.lttng.org/?p=lttng-modules.git;a=blobdiff_plain;f=lttng-statedump-impl.c;h=bab5d9ff4c2cf1dcdef90e03e777ac5f96a6ebe2;hp=35e18a473201b9756430055fd38278071cd50aa6;hb=2260bfdd2ee4ba82ae61cbfaf4e9c88717886b09;hpb=461277e79d60d55afc769d76ece385681835d02b

diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c
old mode 100755
new mode 100644
index 35e18a47..bab5d9ff
--- a/lttng-statedump-impl.c
+++ b/lttng-statedump-impl.c
@@ -45,14 +45,17 @@
 #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_LTTNG_HAS_LIST_IRQ
 #include <linux/irq.h>
@@ -62,12 +65,22 @@
 #define CREATE_TRACE_POINTS
 #define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module
 #define TRACE_INCLUDE_FILE lttng-statedump
+#define LTTNG_INSTRUMENTATION
 #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;
 	struct task_struct *p;
+	struct files_struct *files;
 };
 
 /*
@@ -107,7 +120,57 @@ 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;
+
+		/*
+		 * Don't show empty devices or things that have been
+		 * suppressed
+		 */
+		if (get_capacity(disk) == 0 ||
+		    (disk->flags & GENHD_FL_SUPPRESS_PARTITION_INFO))
+			continue;
+
+		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)
@@ -151,23 +214,55 @@ int lttng_enumerate_network_ip_interface(struct lttng_session *session)
 }
 #endif /* CONFIG_INET */
 
+#ifdef FD_ISSET	/* For old kernels lacking close_on_exec() */
+static inline bool lttng_close_on_exec(int fd, const struct fdtable *fdt)
+{
+	return FD_ISSET(fd, fdt->close_on_exec);
+}
+#else
+static inline bool lttng_close_on_exec(int fd, const struct fdtable *fdt)
+{
+	return close_on_exec(fd, fdt);
+}
+#endif
+
 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);
+	unsigned int flags = file->f_flags;
+	struct fdtable *fdt;
 
+	/*
+	 * We don't expose kernel internal flags, only userspace-visible
+	 * flags.
+	 */
+	flags &= ~FMODE_NONOTIFY;
+	fdt = files_fdtable(ctx->files);
+	/*
+	 * We need to check here again whether fd is within the fdt
+	 * max_fds range, because we might be seeing a different
+	 * files_fdtable() than iterate_fd(), assuming only RCU is
+	 * protecting the read. In reality, iterate_fd() holds
+	 * file_lock, which should ensure the fdt does not change while
+	 * the lock is taken, but we are not aware whether this is
+	 * guaranteed or not, so play safe.
+	 */
+	if (fd < fdt->max_fds && lttng_close_on_exec(fd, fdt))
+		flags |= O_CLOEXEC;
 	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);
+			dentry->d_name.name, flags, file->f_mode);
 		spin_unlock(&dentry->d_lock);
 		goto end;
 	}
-	trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s);
+	trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s,
+		flags, file->f_mode);
 end:
 	return 0;
 }
@@ -177,9 +272,15 @@ void lttng_enumerate_task_fd(struct lttng_session *session,
 		struct task_struct *p, char *tmp)
 {
 	struct lttng_fd_ctx ctx = { .page = tmp, .session = session, .p = p };
+	struct files_struct *files;
 
 	task_lock(p);
-	lttng_iterate_fd(p->files, 0, lttng_dump_one_fd, &ctx);
+	files = p->files;
+	if (!files)
+		goto end;
+	ctx.files = files;
+	lttng_iterate_fd(files, 0, lttng_dump_one_fd, &ctx);
+end:
 	task_unlock(p);
 }
 
@@ -187,7 +288,11 @@ static
 int lttng_enumerate_file_descriptors(struct lttng_session *session)
 {
 	struct task_struct *p;
-	char *tmp = (char *) __get_free_page(GFP_KERNEL);
+	char *tmp;
+
+	tmp = (char *) __get_free_page(GFP_KERNEL);
+	if (!tmp)
+		return -ENOMEM;
 
 	/* Enumerate active file descriptors */
 	rcu_read_lock();
@@ -253,7 +358,7 @@ int lttng_enumerate_vm_maps(struct lttng_session *session)
 #endif
 
 static
-void lttng_list_interrupts(struct lttng_session *session)
+int lttng_list_interrupts(struct lttng_session *session)
 {
 	unsigned int irq;
 	unsigned long flags = 0;
@@ -275,15 +380,20 @@ void lttng_list_interrupts(struct lttng_session *session)
 		wrapper_desc_spin_unlock(&desc->lock);
 		local_irq_restore(flags);
 	}
+	return 0;
 #undef irq_to_desc
 }
 #else
 static inline
-void lttng_list_interrupts(struct lttng_session *session)
+int lttng_list_interrupts(struct lttng_session *session)
 {
+	return 0;
 }
 #endif
 
+/*
+ * Called with task lock held.
+ */
 static
 void lttng_statedump_process_ns(struct lttng_session *session,
 		struct task_struct *p,
@@ -295,8 +405,19 @@ void lttng_statedump_process_ns(struct lttng_session *session,
 	struct nsproxy *proxy;
 	struct pid_namespace *pid_ns;
 
+	/*
+	 * Back and forth on locking strategy within Linux upstream for nsproxy.
+	 * See Linux upstream commit 728dba3a39c66b3d8ac889ddbe38b5b1c264aec3
+	 * "namespaces: Use task_lock and not rcu to protect nsproxy"
+	 * for details.
+	 */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
+		LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0))
+	proxy = p->nsproxy;
+#else
 	rcu_read_lock();
 	proxy = task_nsproxy(p);
+#endif
 	if (proxy) {
 		pid_ns = lttng_get_proxy_pid_ns(proxy);
 		do {
@@ -308,7 +429,12 @@ void lttng_statedump_process_ns(struct lttng_session *session,
 		trace_lttng_statedump_process_state(session,
 			p, type, mode, submode, status, NULL);
 	}
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,17,0) || \
+		LTTNG_UBUNTU_KERNEL_RANGE(3,13,11,36, 3,14,0,0))
+	/* (nothing) */
+#else
 	rcu_read_unlock();
+#endif
 }
 
 static
@@ -381,14 +507,35 @@ void lttng_statedump_work_func(struct work_struct *work)
 static
 int do_lttng_statedump(struct lttng_session *session)
 {
-	int cpu;
+	int cpu, ret;
 
 	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);
+	ret = lttng_enumerate_process_states(session);
+	if (ret)
+		return ret;
+	ret = lttng_enumerate_file_descriptors(session);
+	if (ret)
+		return ret;
+	/*
+	 * FIXME
+	 * ret = lttng_enumerate_vm_maps(session);
+	 * if (ret)
+	 * 	return ret;
+	 */
+	ret = lttng_list_interrupts(session);
+	if (ret)
+		return ret;
+	ret = lttng_enumerate_network_ip_interface(session);
+	if (ret)
+		return ret;
+	ret = lttng_enumerate_block_devices(session);
+	switch (ret) {
+	case -ENOSYS:
+		printk(KERN_WARNING "LTTng: block device enumeration is not supported by kernel\n");
+		break;
+	default:
+		return ret;
+	}
 
 	/* TODO lttng_dump_idt_table(session); */
 	/* TODO lttng_dump_softirq_vec(session); */
@@ -426,7 +573,14 @@ EXPORT_SYMBOL_GPL(lttng_statedump_start);
 static
 int __init lttng_statedump_init(void)
 {
-	return wrapper_lttng_fixup_sig(THIS_MODULE);
+	/*
+	 * 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);
@@ -441,3 +595,7 @@ 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);