X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=lttng-statedump-impl.c;h=f8613525f06cbe738c4870af8d0a7a27de7c9442;hb=refs%2Fheads%2Fstable-2.5;hp=1bf58ad43d126c8bf0d128f089a01619a6dd05a5;hpb=29021503335cd774f4f7da3da71f3543cc1df2ec;p=lttng-modules.git diff --git a/lttng-statedump-impl.c b/lttng-statedump-impl.c index 1bf58ad4..f8613525 100644 --- a/lttng-statedump-impl.c +++ b/lttng-statedump-impl.c @@ -56,6 +56,7 @@ #include "wrapper/irq.h" #include "wrapper/tracepoint.h" #include "wrapper/genhd.h" +#include "wrapper/time.h" #ifdef CONFIG_LTTNG_HAS_LIST_IRQ #include @@ -79,7 +80,7 @@ struct lttng_fd_ctx { char *page; struct lttng_session *session; struct task_struct *p; - struct fdtable *fdt; + struct files_struct *files; }; /* @@ -140,6 +141,14 @@ int lttng_enumerate_block_devices(struct lttng_session *session) 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]; @@ -211,13 +220,24 @@ 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; - if (test_bit(fd, ctx->fdt->close_on_exec)) + 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; @@ -240,10 +260,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); - ctx.fdt = files_fdtable(p->files); - 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); } @@ -251,7 +276,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(); @@ -317,7 +346,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; @@ -339,15 +368,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, @@ -359,8 +393,20 @@ 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) || \ + LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,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 { @@ -372,7 +418,13 @@ 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) || \ + LTTNG_UBUNTU_KERNEL_RANGE(3,16,1,11, 3,17,0,0)) + /* (nothing) */ +#else rcu_read_unlock(); +#endif } static @@ -445,15 +497,37 @@ 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); - lttng_enumerate_block_devices(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; + } /* TODO lttng_dump_idt_table(session); */ /* TODO lttng_dump_softirq_vec(session); */