X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=lttng-statedump-impl.c;h=dc037508c055b7f61b8c758d581bd0178e26552a;hp=765fcea852279f211db220856d83358a6748b14a;hb=740572854b9a9a2670ef6185afc9707608559368;hpb=8240b2e21a7ce1653d5e45b01c4709c86c3fb636 diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c index 765fcea8..dc037508 100644 --- a/lttng-statedump-impl.c +++ b/lttng-statedump-impl.c @@ -1,4 +1,5 @@ -/* +/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1) + * * lttng-statedump.c * * Linux Trace Toolkit Next Generation Kernel State Dump @@ -6,20 +7,6 @@ * Copyright 2005 Jean-Hugues Deschenes * Copyright 2006-2012 Mathieu Desnoyers * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; only - * version 2.1 of the License. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA - * * Changes: * Eric Clement: Add listing of network IP interface * 2006, 2007 Mathieu Desnoyers Fix kernel threads @@ -45,20 +32,46 @@ #include #include #include - -#include "lttng-events.h" -#include "wrapper/irqdesc.h" -#include "wrapper/spinlock.h" - -#ifdef CONFIG_GENERIC_HARDIRQS +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef CONFIG_LTTNG_HAS_LIST_IRQ #include #endif /* Define the tracepoints, but do not build the probes */ #define CREATE_TRACE_POINTS -#define TRACE_INCLUDE_PATH ../instrumentation/events/lttng-module +#define TRACE_INCLUDE_PATH instrumentation/events/lttng-module #define TRACE_INCLUDE_FILE lttng-statedump -#include "instrumentation/events/lttng-module/lttng-statedump.h" +#define LTTNG_INSTRUMENTATION +#include + +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); +#ifdef LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY +DEFINE_TRACE(lttng_statedump_cpu_topology); +#endif + +struct lttng_fd_ctx { + char *page; + struct lttng_session *session; + struct task_struct *p; + struct files_struct *files; +}; /* * Protected by the trace lock. @@ -97,7 +110,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) @@ -141,34 +204,61 @@ 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); + 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, flags, file->f_mode); + spin_unlock(&dentry->d_lock); + goto end; + } + trace_lttng_statedump_file_descriptor(ctx->session, ctx->p, fd, s, + flags, file->f_mode); +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 }; + struct files_struct *files; 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: + files = p->files; + if (!files) + goto end; + ctx.files = files; + lttng_iterate_fd(files, 0, lttng_dump_one_fd, &ctx); +end: task_unlock(p); } @@ -176,7 +266,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(); @@ -187,6 +281,28 @@ int lttng_enumerate_file_descriptors(struct lttng_session *session) return 0; } +#ifdef LTTNG_HAVE_STATEDUMP_CPU_TOPOLOGY +static +int lttng_enumerate_cpu_topology(struct lttng_session *session) +{ + int cpu; + const cpumask_t *cpumask = cpu_possible_mask; + + for (cpu = cpumask_first(cpumask); cpu < nr_cpu_ids; + cpu = cpumask_next(cpu, cpumask)) { + trace_lttng_statedump_cpu_topology(session, &cpu_data(cpu)); + } + + return 0; +} +#else +static +int lttng_enumerate_cpu_topology(struct lttng_session *session) +{ + return 0; +} +#endif + #if 0 /* * FIXME: we cannot take a mmap_sem while in a RCU read-side critical section @@ -211,7 +327,7 @@ void lttng_enumerate_task_vm_maps(struct lttng_session *session, down_read(&mm->mmap_sem); while (map) { if (map->vm_file) - ino = map->vm_file->f_dentry->d_inode->i_ino; + ino = map->vm_file->lttng_f_dentry->d_inode->i_ino; else ino = 0; trace_lttng_statedump_vm_map(session, p, map, ino); @@ -235,14 +351,10 @@ int lttng_enumerate_vm_maps(struct lttng_session *session) } #endif -#ifdef CONFIG_GENERIC_HARDIRQS - -#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,39)) -#define irq_desc_get_chip(desc) get_irq_desc_chip(desc) -#endif +#ifdef CONFIG_LTTNG_HAS_LIST_IRQ static -void lttng_list_interrupts(struct lttng_session *session) +int lttng_list_interrupts(struct lttng_session *session) { unsigned int irq; unsigned long flags = 0; @@ -256,23 +368,28 @@ void lttng_list_interrupts(struct lttng_session *session) irq_desc_get_chip(desc)->name ? : "unnamed_irq_chip"; local_irq_save(flags); - wrapper_desc_spin_lock(&desc->lock); + raw_spin_lock(&desc->lock); for (action = desc->action; action; action = action->next) { trace_lttng_statedump_interrupt(session, irq, irq_chip_name, action); } - wrapper_desc_spin_unlock(&desc->lock); + raw_spin_unlock(&desc->lock); local_irq_restore(flags); } + return 0; #undef irq_to_desc } #else static inline -void 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, @@ -281,23 +398,14 @@ void lttng_statedump_process_ns(struct lttng_session *session, enum lttng_execution_submode submode, enum lttng_process_status status) { - struct nsproxy *proxy; struct pid_namespace *pid_ns; - rcu_read_lock(); - proxy = task_nsproxy(p); - if (proxy) { - pid_ns = proxy->pid_ns; - do { - trace_lttng_statedump_process_state(session, - p, type, mode, submode, status, pid_ns); - pid_ns = pid_ns->parent; - } while (pid_ns); - } else { + pid_ns = task_active_pid_ns(p); + do { trace_lttng_statedump_process_state(session, - p, type, mode, submode, status, NULL); - } - rcu_read_unlock(); + p, type, mode, submode, status, pid_ns); + pid_ns = pid_ns->parent; + } while (pid_ns); } static @@ -370,15 +478,40 @@ void lttng_statedump_work_func(struct work_struct *work) static int do_lttng_statedump(struct lttng_session *session) { - int cpu; + int cpu, ret; - 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); + 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 0: + break; + case -ENOSYS: + printk(KERN_WARNING "LTTng: block device enumeration is not supported by kernel\n"); + break; + default: + return ret; + } + ret = lttng_enumerate_cpu_topology(session); + if (ret) + return ret; /* TODO lttng_dump_idt_table(session); */ /* TODO lttng_dump_softirq_vec(session); */ @@ -397,10 +530,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 +542,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_DESCRIPTION("LTTng statedump provider"); +MODULE_VERSION(__stringify(LTTNG_MODULES_MAJOR_VERSION) "." + __stringify(LTTNG_MODULES_MINOR_VERSION) "." + __stringify(LTTNG_MODULES_PATCHLEVEL_VERSION) + LTTNG_MODULES_EXTRAVERSION);