--- /dev/null
+/*
+ * LTT ascii binary buffer to ascii converter.
+ *
+ * Copyright 2008 - 2009 Lai Jiangshan (laijs@cn.fujitsu.com)
+ * Copyright 2009 - Mathieu Desnoyers mathieu.desnoyers@polymtl.ca
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+/*
+ * TODO
+ *
+ * Move to new switch behavior: Wait for data for the duration of the
+ * timer interval + safety, if none is coming, consider that no activity occured
+ * in the buffer.
+ *
+ * Fix case when having a text file open and destroying trace.
+ *
+ * - Automate periodical switch:
+ *
+ * The debugfs file "switch_timer" receives a timer period as parameter
+ * (e.g. echo 100 > switch_timer) to activate the timer per channel. This can
+ * also be accessed through the internal API _before the trace session starts_.
+ * This timer will insure that we periodically have subbuffers to read, and
+ * therefore that the merge-sort does not wait endlessly for a subbuffer.
+ *
+ * - If a channel is switched and read without data, make sure it is still
+ * considered afterward (not removed from the queue).
+ *
+ * - Create a ascii/tracename/ALL file to merge-sort all active channels.
+ * - Create a ascii/tracename/README file to contain the text output legend.
+ * - Remove leading zeroes from timestamps.
+ * - Enhance pretty-printing to make sure all types used for addesses output in
+ * the form 0xAB00000000 (not decimal). This is true for %p and 0x%...X.
+ * - Hotplug support
+ */
+
+
+
+
+#include <linux/module.h>
+#include <linux/seq_file.h>
+#include <linux/debugfs.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/cpu.h>
+#include <linux/fs.h>
+
+#include "ltt-tracer.h"
+#include "ltt-relay.h"
+#include "ltt-relay-lockless.h"
+
+#if 0
+#define DEBUGP printk
+#else
+#define DEBUGP(fmt , a...)
+#endif
+
+struct dentry *ltt_ascii_dir_dentry;
+EXPORT_SYMBOL_GPL(ltt_ascii_dir_dentry);
+
+struct ltt_relay_iter;
+
+struct ltt_relay_cpu_iter {
+ /* cpu buffer information */
+ struct ltt_chanbuf *buf;
+ struct ltt_relay_iter *iter;
+ int sb_ref; /* holding a reference to a subbuffer */
+ long read_sb_offset; /* offset of the subbuffer read */
+
+ /* current event information */
+ struct ltt_subbuffer_header *header;
+ long hdr_offset; /* event header offset */
+ long payload_offset; /* event payload offset */
+ u64 tsc; /* full 64-bits timestamp value */
+ u32 data_size;
+ u16 chID; /* channel ID, const */
+ u16 eID;
+};
+
+struct ltt_relay_iter {
+ struct ltt_relay_cpu_iter iter_cpu[NR_CPUS];
+ struct ltt_chan *chan;
+ loff_t pos;
+ int cpu;
+ int nr_refs;
+};
+
+/*
+ * offset of 0 in subbuffer means "subbuf size" (filled subbuffer).
+ */
+static int is_subbuffer_offset_end(struct ltt_relay_cpu_iter *citer,
+ long offset)
+{
+ struct ltt_chan *chan = container_of(citer->buf->a.chan,
+ struct ltt_chan, a);
+ long sub_offset = SUBBUF_OFFSET(offset - 1, chan) + 1;
+
+ return (sub_offset <= citer->header->data_size);
+}
+
+static u64 calculate_tsc(u64 pre_tsc, u64 read_tsc, unsigned int rflags)
+{
+ u64 new_tsc = read_tsc;
+
+ if (rflags != LTT_RFLAG_ID_SIZE_TSC) {
+ BUG_ON(read_tsc >> LTT_TSC_BITS);
+
+ new_tsc = (pre_tsc & ~LTT_TSC_MASK) + read_tsc;
+ if (read_tsc < (pre_tsc & LTT_TSC_MASK))
+ new_tsc += 1UL << LTT_TSC_BITS;
+ }
+
+ return new_tsc;
+}
+
+/*
+ * calculate payload offset */
+static inline long calculate_payload_offset(long offset, u16 chID, u16 eID)
+{
+ const char *fmt;
+
+ if (!ltt_get_alignment())
+ return offset;
+
+ fmt = marker_get_fmt_from_id(chID, eID);
+ BUG_ON(!fmt);
+
+ return offset + ltt_fmt_largest_align(offset, fmt);
+}
+
+static void update_new_event(struct ltt_relay_cpu_iter *citer, long hdr_offset)
+{
+ u64 read_tsc;
+ unsigned int rflags;
+ long tmp_offset;
+
+ WARN_ON_ONCE(hdr_offset != citer->hdr_offset);
+
+ tmp_offset = ltt_read_event_header(&citer->buf->a, hdr_offset,
+ &read_tsc, &citer->data_size,
+ &citer->eID, &rflags);
+ citer->payload_offset = calculate_payload_offset(tmp_offset,
+ citer->chID,
+ citer->eID);
+
+ citer->tsc = calculate_tsc(citer->tsc, read_tsc, rflags);
+}
+
+static void update_event_size(struct ltt_relay_cpu_iter *citer, long hdr_offset)
+{
+ char output[1];
+ const char *fmt;
+ size_t data_size;
+
+ if (citer->data_size != INT_MAX)
+ return;
+
+ fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
+ BUG_ON(!fmt);
+ ltt_serialize_printf(citer->buf, citer->payload_offset,
+ &data_size, output, 0, fmt);
+ citer->data_size = data_size;
+}
+
+static void update_cpu_iter(struct ltt_relay_cpu_iter *citer, long hdr_offset)
+{
+ if (unlikely((!citer->sb_ref)
+ || is_subbuffer_offset_end(citer, hdr_offset))) {
+ citer->header = NULL;
+ return;
+ }
+ update_new_event(citer, hdr_offset);
+ update_event_size(citer, hdr_offset);
+}
+
+/*
+ * returns 0 if we get a subbuffer reference.
+ * else, the buffer has not available data, try again later.
+ */
+static int subbuffer_start(struct ltt_relay_cpu_iter *citer, long *offset)
+{
+ int ret;
+ struct ltt_relay_iter *iter = citer->iter;
+
+ ret = ltt_chanbuf_get_subbuf(citer->buf, offset);
+ if (!ret) {
+ citer->header = ltt_relay_read_offset_address(&citer->buf->a,
+ *offset);
+ citer->hdr_offset = (*offset) + ltt_sb_header_size();
+ citer->tsc = citer->header->cycle_count_begin;
+ iter->nr_refs++;
+ citer->sb_ref = 1;
+ return 0;
+ } else {
+ if (ltt_chanbuf_is_finalized(citer->buf))
+ return -ENODATA;
+ else
+ return -EAGAIN;
+ }
+}
+
+static void subbuffer_stop(struct ltt_relay_cpu_iter *citer,
+ long offset)
+{
+ int ret;
+ struct ltt_relay_iter *iter = citer->iter;
+
+ WARN_ON_ONCE(!citer->sb_ref);
+ ret = ltt_chanbuf_put_subbuf(citer->buf, offset);
+ WARN_ON_ONCE(ret);
+ citer->sb_ref = 0;
+ iter->nr_refs--;
+}
+
+static void ltt_relay_advance_cpu_iter(struct ltt_relay_cpu_iter *citer)
+{
+ long old_offset = citer->payload_offset;
+ long new_offset = citer->payload_offset;
+ int ret;
+
+ /* find that whether we read all data in this subbuffer */
+ if (unlikely(is_subbuffer_offset_end(citer,
+ old_offset + citer->data_size))) {
+ DEBUGP(KERN_DEBUG "LTT ASCII stop cpu %d offset %lX\n",
+ citer->buf->a.cpu, citer->read_sb_offset);
+ subbuffer_stop(citer, citer->read_sb_offset);
+ for (;;) {
+ ret = subbuffer_start(citer, &citer->read_sb_offset);
+ DEBUGP(KERN_DEBUG
+ "LTT ASCII start cpu %d ret %d offset %lX\n",
+ citer->buf->a.cpu, ret, citer->read_sb_offset);
+ if (!ret || ret == -ENODATA) {
+ break; /* got data, or finalized */
+ } else { /* -EAGAIN */
+ if (signal_pending(current))
+ break;
+ schedule_timeout_interruptible(1);
+ //TODO: check for no-data delay. take ref. break
+ }
+ }
+ } else {
+ new_offset += citer->data_size;
+ citer->hdr_offset = new_offset + ltt_align(new_offset, sizeof(struct ltt_event_header));
+ DEBUGP(KERN_DEBUG
+ "LTT ASCII old_offset %lX new_offset %lX cpu %d\n",
+ old_offset, new_offset, citer->buf->a.cpu);
+ }
+
+ update_cpu_iter(citer, citer->hdr_offset);
+}
+
+static int cpu_iter_eof(struct ltt_relay_cpu_iter *citer)
+{
+ return !citer->sb_ref;
+}
+
+static int ltt_relay_iter_eof(struct ltt_relay_iter *iter)
+{
+ return iter->nr_refs == 0;
+}
+
+static void ltt_relay_advance_iter(struct ltt_relay_iter *iter)
+{
+ int i;
+ struct ltt_relay_cpu_iter *curr, *min = NULL;
+ iter->cpu = -1;
+
+ /*
+ * find the event with the minimum tsc.
+ * TODO: use min-heep for 4096CPUS
+ */
+ for_each_possible_cpu(i) {
+ curr = &iter->iter_cpu[i];
+
+ if (!curr->buf->a.allocated || !curr->header)
+ continue;
+
+ if (cpu_iter_eof(curr))
+ continue;
+
+ if (!min || curr->tsc < min->tsc) {
+ min = curr;
+ iter->cpu = i;
+ }
+ }
+
+ /* update cpu_iter for next ltt_relay_advance_iter() */
+ if (min)
+ ltt_relay_advance_cpu_iter(min);
+}
+
+static void *ascii_next(struct seq_file *m, void *v, loff_t *ppos)
+{
+ struct ltt_relay_iter *iter = m->private;
+
+ WARN_ON_ONCE(!iter->nr_refs);
+ BUG_ON(v != iter);
+
+ ltt_relay_advance_iter(iter);
+ return (ltt_relay_iter_eof(iter) || signal_pending(current))
+ ? NULL : iter;
+}
+
+static void *ascii_start(struct seq_file *m, loff_t *ppos)
+{
+ struct ltt_relay_iter *iter = m->private;
+
+ ltt_relay_advance_iter(iter);
+ return (ltt_relay_iter_eof(iter) || signal_pending(current))
+ ? NULL : iter;
+}
+
+static void ascii_stop(struct seq_file *m, void *v)
+{
+}
+
+static
+int seq_serialize(struct seq_file *m, struct ltt_chanbuf *buf,
+ size_t buf_offset, const char *fmt, size_t *data_size)
+{
+ int len;
+
+ if (m->count < m->size) {
+ len = ltt_serialize_printf(buf, buf_offset, data_size,
+ m->buf + m->count,
+ m->size - m->count, fmt);
+ if (m->count + len < m->size) {
+ m->count += len;
+ return 0;
+ }
+ }
+
+ m->count = m->size;
+ return -1;
+}
+
+static int ascii_show(struct seq_file *m, void *v)
+{
+ struct ltt_relay_iter *iter = v;
+ struct ltt_relay_cpu_iter *citer;
+ const char *name;
+ const char *fmt;
+ unsigned long long tsc;
+ size_t data_size;
+
+ if (iter->cpu == -1)
+ return 0;
+
+ citer = &iter->iter_cpu[iter->cpu];
+ WARN_ON_ONCE(!citer->sb_ref);
+ /*
+ * Nothing to show, we are at the end of the last subbuffer currently
+ * having data.
+ */
+ if (!citer->header)
+ return 0;
+
+ tsc = citer->tsc;
+ name = marker_get_name_from_id(citer->chID, citer->eID);
+ fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
+
+ if (!name || !fmt)
+ return 0;
+
+ seq_printf(m, "event:%16.16s: cpu:%2d time:%20.20llu ",
+ name, iter->cpu, tsc);
+ seq_serialize(m, citer->buf, citer->payload_offset, fmt, &data_size);
+ seq_puts(m, "\n");
+ if (citer->data_size == INT_MAX)
+ citer->data_size = data_size;
+
+ return 0;
+}
+
+static struct seq_operations ascii_seq_ops = {
+ .start = ascii_start,
+ .next = ascii_next,
+ .stop = ascii_stop,
+ .show = ascii_show,
+};
+
+/* FIXME : cpu hotplug support */
+static int ltt_relay_iter_open_channel(struct ltt_relay_iter *iter,
+ struct ltt_chan *chan)
+{
+ int i, ret;
+ u16 chID = ltt_channels_get_index_from_name(chan->a.filename);
+
+ /* we don't need lock relay_channels_mutex */
+ for_each_possible_cpu(i) {
+ struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
+
+ citer->buf = per_cpu_ptr(chan->a.buf, i);
+ if (!citer->buf->a.allocated)
+ continue;
+
+ citer->iter = iter; /* easy lazy parent info */
+ citer->chID = chID;
+
+ ret = ltt_chanbuf_open_read(citer->buf);
+ if (ret) {
+ /* Failed to open a percpu buffer, close everything. */
+ citer->buf = NULL;
+ goto error;
+ }
+
+ for (;;) {
+ ret = subbuffer_start(citer,
+ &citer->read_sb_offset);
+ DEBUGP(KERN_DEBUG
+ "LTT ASCII open start "
+ "cpu %d ret %d offset %lX\n",
+ citer->buf->a.cpu, ret, citer->read_sb_offset);
+ if (!ret || ret == -ENODATA) {
+ break; /* got data, or finalized */
+ } else { /* -EAGAIN */
+ if (signal_pending(current))
+ break;
+ schedule_timeout_interruptible(1);
+ }
+ }
+ update_cpu_iter(citer, citer->hdr_offset);
+ }
+ if (!iter->nr_refs) {
+ ret = -ENODATA;
+ goto error;
+ }
+
+ return 0;
+
+error:
+ for_each_possible_cpu(i) {
+ struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
+
+ if (!citer->buf)
+ break;
+
+ if (citer->buf->a.allocated)
+ ltt_chanbuf_release_read(citer->buf);
+ }
+ return ret;
+}
+
+/* FIXME : cpu hotplug support */
+static int ltt_relay_iter_release_channel(struct ltt_relay_iter *iter)
+{
+ int i;
+
+ for_each_possible_cpu(i) {
+ struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
+
+ if (citer->sb_ref) {
+ WARN_ON_ONCE(!citer->buf->a.allocated);
+ DEBUGP(KERN_DEBUG
+ "LTT ASCII release stop cpu %d offset %lX\n",
+ citer->buf->a.cpu, citer->read_sb_offset);
+ subbuffer_stop(&iter->iter_cpu[i],
+ citer->read_sb_offset);
+ }
+ if (citer->buf->a.allocated)
+ ltt_chanbuf_release_read(citer->buf);
+ }
+ WARN_ON_ONCE(iter->nr_refs);
+ return 0;
+}
+
+static int ltt_relay_ascii_open(struct inode *inode, struct file *file)
+{
+ int ret;
+ struct ltt_chan *chan = inode->i_private;
+ struct ltt_relay_iter *iter = kzalloc(sizeof(*iter), GFP_KERNEL);
+ if (!iter)
+ return -ENOMEM;
+
+ iter->chan = chan;
+ ret = ltt_relay_iter_open_channel(iter, chan);
+ if (ret)
+ goto error_free_alloc;
+
+ ret = seq_open(file, &ascii_seq_ops);
+ if (ret)
+ goto error_release_channel;
+ ((struct seq_file *)file->private_data)->private = iter;
+ return 0;
+
+error_release_channel:
+ ltt_relay_iter_release_channel(iter);
+error_free_alloc:
+ kfree(iter);
+ return ret;
+}
+
+static int ltt_relay_ascii_release(struct inode *inode, struct file *file)
+{
+ struct seq_file *seq = file->private_data;
+ struct ltt_relay_iter *iter = seq->private;
+
+ ltt_relay_iter_release_channel(iter);
+ kfree(iter);
+ return 0;
+}
+
+static struct file_operations ltt_ascii_fops =
+{
+ .read = seq_read,
+ .open = ltt_relay_ascii_open,
+ .release = ltt_relay_ascii_release,
+ .llseek = no_llseek,
+ .owner = THIS_MODULE,
+};
+
+int ltt_ascii_create(struct ltt_chan *chan)
+{
+ struct dentry *dentry;
+
+ dentry = debugfs_create_file(chan->a.filename,
+ S_IRUSR | S_IRGRP,
+ chan->a.trace->dentry.ascii_root,
+ chan, <t_ascii_fops);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ if (!dentry)
+ return -EEXIST;
+
+ chan->a.ascii_dentry = dentry;
+ dentry->d_inode->i_private = chan;
+ return 0;
+}
+EXPORT_SYMBOL_GPL(ltt_ascii_create);
+
+void ltt_ascii_remove(struct ltt_chan *chan)
+{
+ struct dentry *dentry;
+
+ dentry = dget(chan->a.ascii_dentry);
+ debugfs_remove(dentry);
+ /* TODO: wait / wakeup instead */
+ /*
+ * Wait for every reference to the dentry to be gone,
+ * except us.
+ */
+ while (atomic_read(&dentry->d_count) != 1)
+ msleep(100);
+ dput(dentry);
+}
+EXPORT_SYMBOL_GPL(ltt_ascii_remove);
+
+int ltt_ascii_create_dir(struct ltt_trace *new_trace)
+{
+ new_trace->dentry.ascii_root = debugfs_create_dir(new_trace->trace_name,
+ ltt_ascii_dir_dentry);
+ if (!new_trace->dentry.ascii_root)
+ return -EEXIST;
+ return 0;
+}
+EXPORT_SYMBOL_GPL(ltt_ascii_create_dir);
+
+void ltt_ascii_remove_dir(struct ltt_trace *trace)
+{
+ debugfs_remove(trace->dentry.ascii_root);
+}
+EXPORT_SYMBOL_GPL(ltt_ascii_remove_dir);
+
+__init int ltt_ascii_init(void)
+{
+ ltt_ascii_dir_dentry = debugfs_create_dir(LTT_ASCII, get_ltt_root());
+
+ return ltt_ascii_dir_dentry ? 0 : -EFAULT;
+}
+
+__exit void ltt_ascii_exit(void)
+{
+ debugfs_remove(ltt_ascii_dir_dentry);
+ put_ltt_root();
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Lai Jiangshan@FNST and Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Ascii Converter");
--- /dev/null
+/*
+ * ltt/ltt-channels.c
+ *
+ * (C) Copyright 2008 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ *
+ * LTTng channel management.
+ *
+ * Author:
+ * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include "ltt-channels.h"
+
+/*
+ * ltt_channel_mutex may be nested inside the LTT trace mutex.
+ * ltt_channel_mutex mutex may be nested inside markers mutex.
+ */
+static DEFINE_MUTEX(ltt_channel_mutex);
+static LIST_HEAD(ltt_channels);
+/*
+ * Index of next channel in array. Makes sure that as long as a trace channel is
+ * allocated, no array index will be re-used when a channel is freed and then
+ * another channel is allocated. This index is cleared and the array indexeds
+ * get reassigned when the index_kref goes back to 0, which indicates that no
+ * more trace channels are allocated.
+ */
+static unsigned int free_index;
+/* index_kref is protected by both ltt_channel_mutex and lock_markers */
+static struct kref index_kref; /* Keeps track of allocated trace channels */
+
+static struct ltt_channel_setting *lookup_channel(const char *name)
+{
+ struct ltt_channel_setting *iter;
+
+ list_for_each_entry(iter, <t_channels, list)
+ if (strcmp(name, iter->name) == 0)
+ return iter;
+ return NULL;
+}
+
+/*
+ * Must be called when channel refcount falls to 0 _and_ also when the last
+ * trace is freed. This function is responsible for compacting the channel and
+ * event IDs when no users are active.
+ *
+ * Called with lock_markers() and channels mutex held.
+ */
+static void release_channel_setting(struct kref *kref)
+{
+ struct ltt_channel_setting *setting = container_of(kref,
+ struct ltt_channel_setting, kref);
+ struct ltt_channel_setting *iter;
+
+ if (atomic_read(&index_kref.refcount) == 0
+ && atomic_read(&setting->kref.refcount) == 0) {
+ list_del(&setting->list);
+ kfree(setting);
+
+ free_index = 0;
+ list_for_each_entry(iter, <t_channels, list) {
+ iter->index = free_index++;
+ iter->free_event_id = 0;
+ }
+ }
+}
+
+/*
+ * Perform channel index compaction when the last trace channel is freed.
+ *
+ * Called with lock_markers() and channels mutex held.
+ */
+static void release_trace_channel(struct kref *kref)
+{
+ struct ltt_channel_setting *iter, *n;
+
+ list_for_each_entry_safe(iter, n, <t_channels, list)
+ release_channel_setting(&iter->kref);
+ if (atomic_read(&index_kref.refcount) == 0)
+ markers_compact_event_ids();
+}
+
+/*
+ * ltt_channel_trace_ref : Is there an existing trace session ?
+ *
+ * Must be called with lock_markers() held.
+ */
+int ltt_channels_trace_ref(void)
+{
+ return !!atomic_read(&index_kref.refcount);
+}
+EXPORT_SYMBOL_GPL(ltt_channels_trace_ref);
+
+/**
+ * ltt_channels_register - Register a trace channel.
+ * @name: channel name
+ *
+ * Uses refcounting.
+ */
+int ltt_channels_register(const char *name)
+{
+ struct ltt_channel_setting *setting;
+ int ret = 0;
+
+ mutex_lock(<t_channel_mutex);
+ setting = lookup_channel(name);
+ if (setting) {
+ if (atomic_read(&setting->kref.refcount) == 0)
+ goto init_kref;
+ else {
+ kref_get(&setting->kref);
+ goto end;
+ }
+ }
+ setting = kzalloc(sizeof(*setting), GFP_KERNEL);
+ if (!setting) {
+ ret = -ENOMEM;
+ goto end;
+ }
+ list_add(&setting->list, <t_channels);
+ strncpy(setting->name, name, PATH_MAX-1);
+ setting->index = free_index++;
+init_kref:
+ kref_init(&setting->kref);
+end:
+ mutex_unlock(<t_channel_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_register);
+
+/**
+ * ltt_channels_unregister - Unregister a trace channel.
+ * @name: channel name
+ * @compacting: performing compaction
+ *
+ * Must be called with markers mutex held.
+ */
+int ltt_channels_unregister(const char *name, int compacting)
+{
+ struct ltt_channel_setting *setting;
+ int ret = 0;
+
+ if (!compacting)
+ mutex_lock(<t_channel_mutex);
+ setting = lookup_channel(name);
+ if (!setting || atomic_read(&setting->kref.refcount) == 0) {
+ ret = -ENOENT;
+ goto end;
+ }
+ kref_put(&setting->kref, release_channel_setting);
+ if (!compacting && atomic_read(&index_kref.refcount) == 0)
+ markers_compact_event_ids();
+end:
+ if (!compacting)
+ mutex_unlock(<t_channel_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_unregister);
+
+/**
+ * ltt_channels_set_default - Set channel default behavior.
+ * @name: default channel name
+ * @sb_size: size of the subbuffers
+ * @n_sb: number of subbuffers
+ */
+int ltt_channels_set_default(const char *name,
+ unsigned int sb_size,
+ unsigned int n_sb)
+{
+ struct ltt_channel_setting *setting;
+ int ret = 0;
+
+ mutex_lock(<t_channel_mutex);
+ setting = lookup_channel(name);
+ if (!setting || atomic_read(&setting->kref.refcount) == 0) {
+ ret = -ENOENT;
+ goto end;
+ }
+ setting->sb_size = sb_size;
+ setting->n_sb = n_sb;
+end:
+ mutex_unlock(<t_channel_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_set_default);
+
+/**
+ * ltt_channels_get_name_from_index - get channel name from channel index
+ * @index: channel index
+ *
+ * Allows to lookup the channel name given its index. Done to keep the name
+ * information outside of each trace channel instance.
+ */
+const char *ltt_channels_get_name_from_index(unsigned int index)
+{
+ struct ltt_channel_setting *iter;
+
+ list_for_each_entry(iter, <t_channels, list)
+ if (iter->index == index && atomic_read(&iter->kref.refcount))
+ return iter->name;
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_get_name_from_index);
+
+static struct ltt_channel_setting *
+ltt_channels_get_setting_from_name(const char *name)
+{
+ struct ltt_channel_setting *iter;
+
+ list_for_each_entry(iter, <t_channels, list)
+ if (!strcmp(iter->name, name)
+ && atomic_read(&iter->kref.refcount))
+ return iter;
+ return NULL;
+}
+
+/**
+ * ltt_channels_get_index_from_name - get channel index from channel name
+ * @name: channel name
+ *
+ * Allows to lookup the channel index given its name. Done to keep the name
+ * information outside of each trace channel instance.
+ * Returns -1 if not found.
+ */
+int ltt_channels_get_index_from_name(const char *name)
+{
+ struct ltt_channel_setting *setting;
+
+ setting = ltt_channels_get_setting_from_name(name);
+ if (setting)
+ return setting->index;
+ else
+ return -1;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_get_index_from_name);
+
+/**
+ * ltt_channels_trace_alloc - Allocate channel structures for a trace
+ *
+ * Use the current channel list to allocate the channels for a trace.
+ * Called with trace lock held. Does not perform the trace buffer allocation,
+ * because we must let the user overwrite specific channel sizes.
+ */
+int ltt_channels_trace_alloc(struct ltt_trace *trace, int overwrite)
+{
+ struct channel **chan = NULL;
+ struct ltt_channel_setting *chans, *iter;
+ int ret = 0;
+
+ lock_markers();
+ mutex_lock(<t_channel_mutex);
+ if (!free_index)
+ goto end;
+ if (!atomic_read(&index_kref.refcount))
+ kref_init(&index_kref);
+ else
+ kref_get(&index_kref);
+ trace->nr_channels = free_index;
+ chan = kzalloc(sizeof(struct channel *) * free_index, GFP_KERNEL);
+ if (!chan)
+ goto end;
+ chans = kzalloc(sizeof(struct ltt_channel_setting) * free_index,
+ GFP_KERNEL);
+ if (!chan_settings)
+ goto free_chan;
+ list_for_each_entry(iter, <t_channels, list) {
+ if (!atomic_read(&iter->kref.refcount))
+ continue;
+ chans[iter->index].sb_size = iter->sb_size;
+ chans[iter->index].n_sb = iter->n_sb;
+ chans[iter->index].overwrite = overwrite;
+ strncpy(chans[iter->index].filename, iter->name,
+ NAME_MAX - 1);
+ chans[iter->index].switch_timer_interval = 0;
+ chans[iter->index].read_timer_interval = LTT_READ_TIMER_INTERVAL;
+ }
+ trace->channels = chan;
+ trace->settings = chans;
+end:
+ mutex_unlock(<t_channel_mutex);
+ unlock_markers();
+ return ret;
+
+free_chan:
+ kfree(chan);
+ ret = -ENOMEM;
+ goto end;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc);
+
+/**
+ * ltt_channels_trace_free - Free one trace's channels
+ * @channels: channels to free
+ *
+ * Called with trace lock held. The actual channel buffers must be freed before
+ * this function is called.
+ */
+void ltt_channels_trace_free(struct ltt_trace *trace)
+{
+ lock_markers();
+ mutex_lock(<t_channel_mutex);
+ kfree(trace->settings);
+ kfree(trace->channels);
+ kref_put(&index_kref, release_trace_channel);
+ mutex_unlock(<t_channel_mutex);
+ unlock_markers();
+ marker_update_probes();
+}
+EXPORT_SYMBOL_GPL(ltt_channels_trace_free);
+
+/**
+ * ltt_channels_trace_set_timer - set switch timer
+ * @channel: channel
+ * @interval: interval of timer interrupt, in jiffies. 0 inhibits timer.
+ */
+
+void ltt_channels_trace_set_timer(struct ltt_chan *chan,
+ unsigned long interval)
+{
+ chan->switch_timer_interval = interval;
+}
+EXPORT_SYMBOL_GPL(ltt_channels_trace_set_timer);
+
+/**
+ * _ltt_channels_get_event_id - get next event ID for a marker
+ * @channel: channel name
+ * @name: event name
+ *
+ * Returns a unique event ID (for this channel) or < 0 on error.
+ * Must be called with channels mutex held.
+ */
+int _ltt_channels_get_event_id(const char *channel, const char *name)
+{
+ struct ltt_channel_setting *setting;
+ int ret;
+
+ setting = ltt_channels_get_setting_from_name(channel);
+ if (!setting) {
+ ret = -ENOENT;
+ goto end;
+ }
+ if (strcmp(channel, "metadata") == 0) {
+ if (strcmp(name, "core_marker_id") == 0)
+ ret = 0;
+ else if (strcmp(name, "core_marker_format") == 0)
+ ret = 1;
+ else
+ ret = -ENOENT;
+ goto end;
+ }
+ if (setting->free_event_id == EVENTS_PER_CHANNEL - 1) {
+ ret = -ENOSPC;
+ goto end;
+ }
+ ret = setting->free_event_id++;
+end:
+ return ret;
+}
+
+/**
+ * ltt_channels_get_event_id - get next event ID for a marker
+ * @channel: channel name
+ * @name: event name
+ *
+ * Returns a unique event ID (for this channel) or < 0 on error.
+ */
+int ltt_channels_get_event_id(const char *channel, const char *name)
+{
+ int ret;
+
+ mutex_lock(<t_channel_mutex);
+ ret = _ltt_channels_get_event_id(channel, name);
+ mutex_unlock(<t_channel_mutex);
+ return ret;
+}
+
+/**
+ * ltt_channels_reset_event_ids - reset event IDs at compaction
+ *
+ * Called with lock marker and channel mutex held.
+ */
+void _ltt_channels_reset_event_ids(void)
+{
+ struct ltt_channel_setting *iter;
+
+ list_for_each_entry(iter, <t_channels, list)
+ iter->free_event_id = 0;
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Channel Management");
--- /dev/null
+#ifndef _LTT_CHANNELS_H
+#define _LTT_CHANNELS_H
+
+/*
+ * Copyright (C) 2008 Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ *
+ * Dynamic tracer channel allocation.
+
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/limits.h>
+#include <linux/kref.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/ltt-core.h>
+
+#define EVENTS_PER_CHANNEL 65536
+
+#define LTT_READ_TIMER_INTERVAL 10000 /* us */
+
+/*
+ * Forward declaration of locking-specific per-cpu buffer structure.
+ */
+struct ltt_trace;
+struct ltt_serialize_closure;
+struct ltt_probe_private_data;
+
+/* Serialization callback '%k' */
+typedef size_t (*ltt_serialize_cb)(struct ltt_chanbuf *buf, size_t buf_offset,
+ struct ltt_serialize_closure *closure,
+ void *serialize_private,
+ unsigned int stack_pos_ctx,
+ int *largest_align,
+ const char *fmt, va_list *args);
+
+struct ltt_probe_private_data {
+ struct ltt_trace *trace; /*
+ * Target trace, for metadata
+ * or statedump.
+ */
+ ltt_serialize_cb serializer; /*
+ * Serialization function override.
+ */
+ void *serialize_private; /*
+ * Private data for serialization
+ * functions.
+ */
+};
+
+struct ltt_channel_setting {
+ unsigned int sb_size;
+ unsigned int n_sb;
+ int overwrite;
+ unsigned long switch_timer_interval;
+ unsigned long read_timer_interval;
+ struct kref kref; /* Number of references to structure content */
+ struct list_head list;
+ unsigned int index; /* index of channel in trace channel array */
+ u16 free_event_id; /* Next event ID to allocate */
+ char name[PATH_MAX];
+};
+
+int ltt_channels_register(const char *name);
+int ltt_channels_unregister(const char *name, int compacting);
+int ltt_channels_set_default(const char *name,
+ unsigned int subbuf_size,
+ unsigned int subbuf_cnt);
+const char *ltt_channels_get_name_from_index(unsigned int index);
+int ltt_channels_get_index_from_name(const char *name);
+int ltt_channels_trace_ref(void);
+struct ltt_chan *ltt_channels_trace_alloc(unsigned int *nr_channels,
+ int overwrite, int active);
+void ltt_channels_trace_free(struct ltt_chan *channels,
+ unsigned int nr_channels);
+void ltt_channels_trace_set_timer(struct ltt_channel_setting *chan,
+ unsigned long interval);
+
+int _ltt_channels_get_event_id(const char *channel, const char *name);
+int ltt_channels_get_event_id(const char *channel, const char *name);
+void _ltt_channels_reset_event_ids(void);
+
+#endif /* _LTT_CHANNELS_H */
--- /dev/null
+/*
+ * Copyright (C) 2008 Mathieu Desnoyers
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/debugfs.h>
+#include <linux/fs.h>
+#include <linux/mutex.h>
+
+#include "ltt-tracer.h"
+
+#define LTT_FILTER_DIR "filter"
+
+/*
+ * Protects the ltt_filter_dir allocation.
+ */
+static DEFINE_MUTEX(ltt_filter_mutex);
+
+static struct dentry *ltt_filter_dir;
+
+struct dentry *get_filter_root(void)
+{
+ struct dentry *ltt_root_dentry;
+
+ mutex_lock(<t_filter_mutex);
+ if (!ltt_filter_dir) {
+ ltt_root_dentry = get_ltt_root();
+ if (!ltt_root_dentry)
+ goto err_no_root;
+
+ ltt_filter_dir = debugfs_create_dir(LTT_FILTER_DIR,
+ ltt_root_dentry);
+ if (!ltt_filter_dir)
+ printk(KERN_ERR
+ "ltt_filter_init: failed to create dir %s\n",
+ LTT_FILTER_DIR);
+ }
+err_no_root:
+ mutex_unlock(<t_filter_mutex);
+ return ltt_filter_dir;
+}
+EXPORT_SYMBOL_GPL(get_filter_root);
+
+static void __exit ltt_filter_exit(void)
+{
+ debugfs_remove(ltt_filter_dir);
+}
+
+module_exit(ltt_filter_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>");
+MODULE_DESCRIPTION("Linux Trace Toolkit Filter");
--- /dev/null
+/*
+ * (C) Copyright 2009 -
+ * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
+ *
+ * LTTng kprobes integration module.
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/kprobes.h>
+#include <linux/marker.h>
+#include <linux/mutex.h>
+#include <linux/jhash.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/debugfs.h>
+#include <linux/kallsyms.h>
+
+#include "ltt-type-serializer.h"
+#include "ltt-tracer.h"
+
+#define LTT_KPROBES_DIR "kprobes"
+#define LTT_KPROBES_ENABLE "enable"
+#define LTT_KPROBES_DISABLE "disable"
+#define LTT_KPROBES_LIST "list"
+
+/* Active LTTng kprobes hash table */
+static DEFINE_MUTEX(ltt_kprobes_mutex);
+
+#define LTT_KPROBE_HASH_BITS 6
+#define LTT_KPROBE_TABLE_SIZE (1 << LTT_KPROBE_HASH_BITS)
+static struct hlist_head ltt_kprobe_table[LTT_KPROBE_TABLE_SIZE];
+
+struct kprobe_entry {
+ struct hlist_node hlist;
+ struct kprobe kp;
+ char key[0];
+};
+
+static struct dentry *ltt_kprobes_dir,
+ *ltt_kprobes_enable_dentry,
+ *ltt_kprobes_disable_dentry,
+ *ltt_kprobes_list_dentry;
+
+static int module_exit;
+
+
+static void trace_kprobe_table_entry(void *call_data, struct kprobe_entry *e)
+{
+ unsigned long addr;
+ char *namebuf = (char *)__get_free_page(GFP_KERNEL);
+
+ if (e->kp.addr) {
+ sprint_symbol(namebuf, (unsigned long)e->kp.addr);
+ addr = (unsigned long)e->kp.addr;
+ } else {
+ strncpy(namebuf, e->kp.symbol_name, PAGE_SIZE - 1);
+ /* TODO : add offset */
+ addr = kallsyms_lookup_name(namebuf);
+ }
+ if (addr)
+ __trace_mark(0, kprobe_state, kprobe_table, call_data,
+ "ip 0x%lX symbol %s", addr, namebuf);
+ free_page((unsigned long)namebuf);
+}
+
+DEFINE_MARKER(kernel, kprobe, "ip %lX");
+
+static int ltt_kprobe_handler_pre(struct kprobe *p, struct pt_regs *regs)
+{
+ struct marker *marker;
+ unsigned long data;
+
+ data = (unsigned long)p->addr;
+ marker = &GET_MARKER(kernel, kprobe);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+ return 0;
+}
+
+static int ltt_register_kprobe(const char *key)
+{
+ struct hlist_head *head;
+ struct hlist_node *node;
+ struct kprobe_entry *e = NULL;
+ char *symbol_name = NULL;
+ unsigned long addr;
+ unsigned int offset = 0;
+ u32 hash;
+ size_t key_len = strlen(key) + 1;
+ int ret;
+
+ if (key_len == 1)
+ return -ENOENT; /* only \0 */
+
+ if (sscanf(key, "%li", &addr) != 1)
+ addr = 0;
+
+ if (!addr) {
+ const char *symbol_end = NULL;
+ unsigned int symbol_len; /* includes final \0 */
+
+ symbol_end = strchr(key, ' ');
+ if (symbol_end)
+ symbol_len = symbol_end - key + 1;
+ else
+ symbol_len = key_len;
+ symbol_name = kmalloc(symbol_len, GFP_KERNEL);
+ if (!symbol_name) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ memcpy(symbol_name, key, symbol_len - 1);
+ symbol_name[symbol_len-1] = '\0';
+ if (symbol_end) {
+ symbol_end++; /* start of offset */
+ if (sscanf(symbol_end, "%i", &offset) != 1)
+ offset = 0;
+ }
+ }
+
+ hash = jhash(key, key_len-1, 0);
+ head = <t_kprobe_table[hash & ((1 << LTT_KPROBE_HASH_BITS)-1)];
+ hlist_for_each_entry(e, node, head, hlist) {
+ if (!strcmp(key, e->key)) {
+ printk(KERN_NOTICE "Kprobe %s busy\n", key);
+ ret = -EBUSY;
+ goto error;
+ }
+ }
+ /*
+ * Using kzalloc here to allocate a variable length element. Could
+ * cause some memory fragmentation if overused.
+ */
+ e = kzalloc(sizeof(struct kprobe_entry) + key_len, GFP_KERNEL);
+ if (!e) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ memcpy(e->key, key, key_len);
+ hlist_add_head(&e->hlist, head);
+ e->kp.pre_handler = ltt_kprobe_handler_pre;
+ e->kp.symbol_name = symbol_name;
+ e->kp.offset = offset;
+ e->kp.addr = (void *)addr;
+ ret = register_kprobe(&e->kp);
+ if (ret < 0)
+ goto error_list_del;
+ trace_kprobe_table_entry(NULL, e);
+ return 0;
+
+error_list_del:
+ hlist_del(&e->hlist);
+error:
+ kfree(symbol_name);
+ kfree(e);
+ return ret;
+}
+
+static int ltt_unregister_kprobe(const char *key)
+{
+ struct hlist_head *head;
+ struct hlist_node *node;
+ struct kprobe_entry *e;
+ int found = 0;
+ size_t key_len = strlen(key) + 1;
+ u32 hash;
+
+ hash = jhash(key, key_len-1, 0);
+ head = <t_kprobe_table[hash & ((1 << LTT_KPROBE_HASH_BITS)-1)];
+ hlist_for_each_entry(e, node, head, hlist) {
+ if (!strcmp(key, e->key)) {
+ found = 1;
+ break;
+ }
+ }
+ if (!found)
+ return -ENOENT;
+ hlist_del(&e->hlist);
+ unregister_kprobe(&e->kp);
+ kfree(e->kp.symbol_name);
+ kfree(e);
+ return 0;
+}
+
+static void ltt_unregister_all_kprobes(void)
+{
+ struct kprobe_entry *e;
+ struct hlist_head *head;
+ struct hlist_node *node, *tmp;
+ unsigned int i;
+
+ for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
+ head = <t_kprobe_table[i];
+ hlist_for_each_entry_safe(e, node, tmp, head, hlist) {
+ hlist_del(&e->hlist);
+ unregister_kprobe(&e->kp);
+ kfree(e->kp.symbol_name);
+ kfree(e);
+ }
+ }
+}
+
+/*
+ * Allows to specify either
+ * - symbol
+ * - symbol offset
+ * - address
+ */
+static ssize_t enable_op_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err, buf_size;
+ char *end;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+
+ mutex_lock(<t_kprobes_mutex);
+ if (module_exit) {
+ err = -EPERM;
+ goto error;
+ }
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto error;
+ buf[buf_size] = '\0';
+ end = strchr(buf, '\n');
+ if (end)
+ *end = '\0';
+ err = ltt_register_kprobe(buf);
+ if (err)
+ goto error;
+
+ mutex_unlock(<t_kprobes_mutex);
+ free_page((unsigned long)buf);
+ return count;
+error:
+ mutex_unlock(<t_kprobes_mutex);
+ free_page((unsigned long)buf);
+ return err;
+}
+
+static const struct file_operations ltt_kprobes_enable = {
+ .write = enable_op_write,
+};
+
+static ssize_t disable_op_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err, buf_size;
+ char *end;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+
+ mutex_lock(<t_kprobes_mutex);
+ if (module_exit)
+ goto end;
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto error;
+ buf[buf_size] = '\0';
+ end = strchr(buf, '\n');
+ if (end)
+ *end = '\0';
+ err = ltt_unregister_kprobe(buf);
+ if (err)
+ goto error;
+end:
+ mutex_unlock(<t_kprobes_mutex);
+ free_page((unsigned long)buf);
+ return count;
+error:
+ mutex_unlock(<t_kprobes_mutex);
+ free_page((unsigned long)buf);
+ return err;
+}
+
+static const struct file_operations ltt_kprobes_disable = {
+ .write = disable_op_write,
+};
+
+/*
+ * This seqfile read is not perfectly safe, as a kprobe could be removed from
+ * the hash table between two reads. This will result in an incomplete output.
+ */
+static struct kprobe_entry *ltt_find_next_kprobe(struct kprobe_entry *prev)
+{
+ struct kprobe_entry *e;
+ struct hlist_head *head;
+ struct hlist_node *node;
+ unsigned int i;
+ int found = 0;
+
+ if (prev == (void *)-1UL)
+ return NULL;
+
+ if (!prev)
+ found = 1;
+
+ for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
+ head = <t_kprobe_table[i];
+ hlist_for_each_entry(e, node, head, hlist) {
+ if (found)
+ return e;
+ if (e == prev)
+ found = 1;
+ }
+ }
+ return NULL;
+}
+
+static void *lk_next(struct seq_file *m, void *p, loff_t *pos)
+{
+ m->private = ltt_find_next_kprobe(m->private);
+ if (!m->private) {
+ m->private = (void *)-1UL;
+ return NULL;
+ }
+ return m->private;
+}
+
+static void *lk_start(struct seq_file *m, loff_t *pos)
+{
+ mutex_lock(<t_kprobes_mutex);
+ if (!*pos)
+ m->private = NULL;
+ m->private = ltt_find_next_kprobe(m->private);
+ if (!m->private) {
+ m->private = (void *)-1UL;
+ return NULL;
+ }
+ return m->private;
+}
+
+static void lk_stop(struct seq_file *m, void *p)
+{
+ mutex_unlock(<t_kprobes_mutex);
+}
+
+static int lk_show(struct seq_file *m, void *p)
+{
+ struct kprobe_entry *e = m->private;
+ seq_printf(m, "%s\n", e->key);
+ return 0;
+}
+
+static const struct seq_operations ltt_kprobes_list_op = {
+ .start = lk_start,
+ .next = lk_next,
+ .stop = lk_stop,
+ .show = lk_show,
+};
+
+static int ltt_kprobes_list_open(struct inode *inode, struct file *file)
+{
+ int ret;
+
+ ret = seq_open(file, <t_kprobes_list_op);
+ if (ret == 0)
+ ((struct seq_file *)file->private_data)->private = NULL;
+ return ret;
+}
+
+static int ltt_kprobes_list_release(struct inode *inode, struct file *file)
+{
+ struct seq_file *seq = file->private_data;
+
+ seq->private = NULL;
+ return seq_release(inode, file);
+}
+
+static const struct file_operations ltt_kprobes_list = {
+ .open = ltt_kprobes_list_open,
+ .read = seq_read,
+ .llseek = seq_lseek,
+ .release = ltt_kprobes_list_release,
+};
+
+/*
+ * kprobes table dump. Callback invoked by ltt-statedump. ltt-statedump must
+ * take a reference to this module before calling this callback.
+ */
+void ltt_dump_kprobes_table(void *call_data)
+{
+ struct kprobe_entry *e;
+ struct hlist_head *head;
+ struct hlist_node *node;
+ unsigned int i;
+
+ for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
+ head = <t_kprobe_table[i];
+ hlist_for_each_entry(e, node, head, hlist)
+ trace_kprobe_table_entry(call_data, e);
+ }
+}
+EXPORT_SYMBOL_GPL(ltt_dump_kprobes_table);
+
+static int __init ltt_kprobes_init(void)
+{
+ struct dentry *ltt_root_dentry;
+ int ret = 0;
+
+ printk(KERN_INFO "LTT : ltt-kprobes init\n");
+ mutex_lock(<t_kprobes_mutex);
+
+ ltt_root_dentry = get_ltt_root();
+ if (!ltt_root_dentry) {
+ ret = -ENOENT;
+ goto err_no_root;
+ }
+
+ ltt_kprobes_dir = debugfs_create_dir(LTT_KPROBES_DIR, ltt_root_dentry);
+ if (!ltt_kprobes_dir) {
+ printk(KERN_ERR
+ "ltt_kprobes_init: failed to create dir %s\n",
+ LTT_KPROBES_DIR);
+ ret = -ENOMEM;
+ goto err_no_dir;
+ }
+
+ ltt_kprobes_enable_dentry = debugfs_create_file(LTT_KPROBES_ENABLE,
+ S_IWUSR,
+ ltt_kprobes_dir, NULL,
+ <t_kprobes_enable);
+ if (IS_ERR(ltt_kprobes_enable_dentry) || !ltt_kprobes_enable_dentry) {
+ printk(KERN_ERR
+ "ltt_kprobes_init: failed to create file %s\n",
+ LTT_KPROBES_ENABLE);
+ ret = -ENOMEM;
+ goto err_no_enable;
+ }
+
+ ltt_kprobes_disable_dentry = debugfs_create_file(LTT_KPROBES_DISABLE,
+ S_IWUSR,
+ ltt_kprobes_dir, NULL,
+ <t_kprobes_disable);
+ if (IS_ERR(ltt_kprobes_disable_dentry) || !ltt_kprobes_disable_dentry) {
+ printk(KERN_ERR
+ "ltt_kprobes_init: failed to create file %s\n",
+ LTT_KPROBES_DISABLE);
+ ret = -ENOMEM;
+ goto err_no_disable;
+ }
+
+ ltt_kprobes_list_dentry = debugfs_create_file(LTT_KPROBES_LIST,
+ S_IWUSR, ltt_kprobes_dir,
+ NULL, <t_kprobes_list);
+ if (IS_ERR(ltt_kprobes_list_dentry) || !ltt_kprobes_list_dentry) {
+ printk(KERN_ERR
+ "ltt_kprobes_init: failed to create file %s\n",
+ LTT_KPROBES_LIST);
+ ret = -ENOMEM;
+ goto err_no_list;
+ }
+ ltt_statedump_register_kprobes_dump(ltt_dump_kprobes_table);
+
+ mutex_unlock(<t_kprobes_mutex);
+ return ret;
+
+err_no_list:
+ debugfs_remove(ltt_kprobes_disable_dentry);
+err_no_disable:
+ debugfs_remove(ltt_kprobes_enable_dentry);
+err_no_enable:
+ debugfs_remove(ltt_kprobes_dir);
+err_no_dir:
+err_no_root:
+ mutex_unlock(<t_kprobes_mutex);
+ return ret;
+}
+module_init(ltt_kprobes_init);
+
+static void __exit ltt_kprobes_exit(void)
+{
+ printk(KERN_INFO "LTT : ltt-kprobes exit\n");
+ mutex_lock(<t_kprobes_mutex);
+ module_exit = 1;
+ ltt_statedump_unregister_kprobes_dump(ltt_dump_kprobes_table);
+ debugfs_remove(ltt_kprobes_list_dentry);
+ debugfs_remove(ltt_kprobes_disable_dentry);
+ debugfs_remove(ltt_kprobes_enable_dentry);
+ debugfs_remove(ltt_kprobes_dir);
+ ltt_unregister_all_kprobes();
+ mutex_unlock(<t_kprobes_mutex);
+}
+module_exit(ltt_kprobes_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Kprobes Support");
--- /dev/null
+/*
+ * Copyright (C) 2007 Mathieu Desnoyers
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/stat.h>
+#include <linux/vmalloc.h>
+#include <linux/marker.h>
+#include <linux/uaccess.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+#include <linux/list.h>
+#include <linux/mutex.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+
+#include "ltt-tracer.h"
+
+#define DEFAULT_CHANNEL "cpu"
+#define DEFAULT_PROBE "default"
+
+LIST_HEAD(probes_list);
+
+/*
+ * Mutex protecting the probe slab cache.
+ * Nests inside the traces mutex.
+ */
+DEFINE_MUTEX(probes_mutex);
+
+struct ltt_available_probe default_probe = {
+ .name = "default",
+ .format = NULL,
+ .probe_func = ltt_vtrace,
+ .callbacks[0] = ltt_serialize_data,
+};
+
+static struct kmem_cache *markers_loaded_cachep;
+static LIST_HEAD(markers_loaded_list);
+/*
+ * List sorted by name strcmp order.
+ */
+static LIST_HEAD(probes_registered_list);
+
+static struct ltt_available_probe *get_probe_from_name(const char *pname)
+{
+ struct ltt_available_probe *iter;
+ int comparison, found = 0;
+
+ if (!pname)
+ pname = DEFAULT_PROBE;
+ list_for_each_entry(iter, &probes_registered_list, node) {
+ comparison = strcmp(pname, iter->name);
+ if (!comparison)
+ found = 1;
+ if (comparison <= 0)
+ break;
+ }
+ if (found)
+ return iter;
+ else
+ return NULL;
+}
+
+int ltt_probe_register(struct ltt_available_probe *pdata)
+{
+ int ret = 0;
+ int comparison;
+ struct ltt_available_probe *iter;
+
+ mutex_lock(&probes_mutex);
+ list_for_each_entry_reverse(iter, &probes_registered_list, node) {
+ comparison = strcmp(pdata->name, iter->name);
+ if (!comparison) {
+ ret = -EBUSY;
+ goto end;
+ } else if (comparison > 0) {
+ /* We belong to the location right after iter. */
+ list_add(&pdata->node, &iter->node);
+ goto end;
+ }
+ }
+ /* Should be added at the head of the list */
+ list_add(&pdata->node, &probes_registered_list);
+end:
+ mutex_unlock(&probes_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_probe_register);
+
+/*
+ * Called when a probe does not want to be called anymore.
+ */
+int ltt_probe_unregister(struct ltt_available_probe *pdata)
+{
+ int ret = 0;
+ struct ltt_active_marker *amark, *tmp;
+
+ mutex_lock(&probes_mutex);
+ list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) {
+ if (amark->probe == pdata) {
+ ret = marker_probe_unregister_private_data(
+ pdata->probe_func, amark);
+ if (ret)
+ goto end;
+ list_del(&amark->node);
+ kmem_cache_free(markers_loaded_cachep, amark);
+ }
+ }
+ list_del(&pdata->node);
+end:
+ mutex_unlock(&probes_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_probe_unregister);
+
+/*
+ * Connect marker "mname" to probe "pname".
+ * Only allow _only_ probe instance to be connected to a marker.
+ */
+int ltt_marker_connect(const char *channel, const char *mname,
+ const char *pname)
+{
+ int ret;
+ struct ltt_active_marker *pdata;
+ struct ltt_available_probe *probe;
+
+ ltt_lock_traces();
+ mutex_lock(&probes_mutex);
+ probe = get_probe_from_name(pname);
+ if (!probe) {
+ ret = -ENOENT;
+ goto end;
+ }
+ pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
+ if (pdata && !IS_ERR(pdata)) {
+ ret = -EEXIST;
+ goto end;
+ }
+ pdata = kmem_cache_zalloc(markers_loaded_cachep, GFP_KERNEL);
+ if (!pdata) {
+ ret = -ENOMEM;
+ goto end;
+ }
+ pdata->probe = probe;
+ /*
+ * ID has priority over channel in case of conflict.
+ */
+ ret = marker_probe_register(channel, mname, NULL,
+ probe->probe_func, pdata);
+ if (ret)
+ kmem_cache_free(markers_loaded_cachep, pdata);
+ else
+ list_add(&pdata->node, &markers_loaded_list);
+end:
+ mutex_unlock(&probes_mutex);
+ ltt_unlock_traces();
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_marker_connect);
+
+/*
+ * Disconnect marker "mname", probe "pname".
+ */
+int ltt_marker_disconnect(const char *channel, const char *mname,
+ const char *pname)
+{
+ struct ltt_active_marker *pdata;
+ struct ltt_available_probe *probe;
+ int ret = 0;
+
+ mutex_lock(&probes_mutex);
+ probe = get_probe_from_name(pname);
+ if (!probe) {
+ ret = -ENOENT;
+ goto end;
+ }
+ pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
+ if (IS_ERR(pdata)) {
+ ret = PTR_ERR(pdata);
+ goto end;
+ } else if (!pdata) {
+ /*
+ * Not registered by us.
+ */
+ ret = -EPERM;
+ goto end;
+ }
+ ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata);
+ if (ret)
+ goto end;
+ else {
+ list_del(&pdata->node);
+ kmem_cache_free(markers_loaded_cachep, pdata);
+ }
+end:
+ mutex_unlock(&probes_mutex);
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_marker_disconnect);
+
+static void disconnect_all_markers(void)
+{
+ struct ltt_active_marker *pdata, *tmp;
+
+ list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) {
+ marker_probe_unregister_private_data(pdata->probe->probe_func,
+ pdata);
+ list_del(&pdata->node);
+ kmem_cache_free(markers_loaded_cachep, pdata);
+ }
+}
+
+static int __init marker_control_init(void)
+{
+ int ret;
+
+ markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0);
+
+ ret = ltt_probe_register(&default_probe);
+ BUG_ON(ret);
+ ret = ltt_marker_connect("metadata", "core_marker_format",
+ DEFAULT_PROBE);
+ BUG_ON(ret);
+ ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE);
+ BUG_ON(ret);
+
+ return 0;
+}
+module_init(marker_control_init);
+
+static void __exit marker_control_exit(void)
+{
+ int ret;
+
+ ret = ltt_marker_disconnect("metadata", "core_marker_format",
+ DEFAULT_PROBE);
+ BUG_ON(ret);
+ ret = ltt_marker_disconnect("metadata", "core_marker_id",
+ DEFAULT_PROBE);
+ BUG_ON(ret);
+ ret = ltt_probe_unregister(&default_probe);
+ BUG_ON(ret);
+ disconnect_all_markers();
+ kmem_cache_destroy(markers_loaded_cachep);
+ marker_synchronize_unregister();
+}
+module_exit(marker_control_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control");
--- /dev/null
+/*
+ * LTTng serializing code.
+ *
+ * Copyright Mathieu Desnoyers, March 2007.
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ *
+ * See this discussion about weirdness about passing va_list and then va_list to
+ * functions. (related to array argument passing). va_list seems to be
+ * implemented as an array on x86_64, but not on i386... This is why we pass a
+ * va_list * to ltt_vtrace.
+ */
+
+#include <stdarg.h>
+#include <linux/ctype.h>
+#include <linux/string.h>
+#include <linux/module.h>
+
+#include "ltt-tracer.h"
+
+enum ltt_type {
+ LTT_TYPE_SIGNED_INT,
+ LTT_TYPE_UNSIGNED_INT,
+ LTT_TYPE_STRING,
+ LTT_TYPE_NONE,
+};
+
+#define LTT_ATTRIBUTE_NETWORK_BYTE_ORDER (1<<1)
+
+/*
+ * Stack used to keep track of string length at size calculation, passed to
+ * string copy to handle racy input string updates.
+ * Can be used by any context; this is ensured by putting the stack position
+ * back to its original position after using it.
+ */
+#define TRACER_STACK_LEN (PAGE_SIZE / sizeof(unsigned long))
+static DEFINE_PER_CPU(unsigned long [TRACER_STACK_LEN],
+ tracer_stack);
+static DEFINE_PER_CPU(unsigned int, tracer_stack_pos);
+
+/*
+ * Inspired from vsnprintf
+ *
+ * The serialization format string supports the basic printf format strings.
+ * In addition, it defines new formats that can be used to serialize more
+ * complex/non portable data structures.
+ *
+ * Typical use:
+ *
+ * field_name %ctype
+ * field_name #tracetype %ctype
+ * field_name #tracetype %ctype1 %ctype2 ...
+ *
+ * A conversion is performed between format string types supported by GCC and
+ * the trace type requested. GCC type is used to perform type checking on format
+ * strings. Trace type is used to specify the exact binary representation
+ * in the trace. A mapping is done between one or more GCC types to one trace
+ * type. Sign extension, if required by the conversion, is performed following
+ * the trace type.
+ *
+ * If a gcc format is not declared with a trace format, the gcc format is
+ * also used as binary representation in the trace.
+ *
+ * Strings are supported with %s.
+ * A single tracetype (sequence) can take multiple c types as parameter.
+ *
+ * c types:
+ *
+ * see printf(3).
+ *
+ * Note: to write a uint32_t in a trace, the following expression is recommended
+ * si it can be portable:
+ *
+ * ("#4u%lu", (unsigned long)var)
+ *
+ * trace types:
+ *
+ * Serialization specific formats :
+ *
+ * Fixed size integers
+ * #1u writes uint8_t
+ * #2u writes uint16_t
+ * #4u writes uint32_t
+ * #8u writes uint64_t
+ * #1d writes int8_t
+ * #2d writes int16_t
+ * #4d writes int32_t
+ * #8d writes int64_t
+ * i.e.:
+ * #1u%lu #2u%lu #4d%lu #8d%lu #llu%hu #d%lu
+ *
+ * * Attributes:
+ *
+ * n: (for network byte order)
+ * #ntracetype%ctype
+ * is written in the trace in network byte order.
+ *
+ * i.e.: #bn4u%lu, #n%lu, #b%u
+ *
+ * TODO (eventually)
+ * Variable length sequence
+ * #a #tracetype1 #tracetype2 %array_ptr %elem_size %num_elems
+ * In the trace:
+ * #a specifies that this is a sequence
+ * #tracetype1 is the type of elements in the sequence
+ * #tracetype2 is the type of the element count
+ * GCC input:
+ * array_ptr is a pointer to an array that contains members of size
+ * elem_size.
+ * num_elems is the number of elements in the array.
+ * i.e.: #a #lu #lu %p %lu %u
+ *
+ * Callback
+ * #k callback (taken from the probe data)
+ * The following % arguments are exepected by the callback
+ *
+ * i.e.: #a #lu #lu #k %p
+ *
+ * Note: No conversion is done from floats to integers, nor from integers to
+ * floats between c types and trace types. float conversion from double to float
+ * or from float to double is also not supported.
+ *
+ * REMOVE
+ * %*b expects sizeof(data), data
+ * where sizeof(data) is 1, 2, 4 or 8
+ *
+ * Fixed length struct, union or array.
+ * FIXME: unable to extract those sizes statically.
+ * %*r expects sizeof(*ptr), ptr
+ * %*.*r expects sizeof(*ptr), __alignof__(*ptr), ptr
+ * struct and unions removed.
+ * Fixed length array:
+ * [%p]#a[len #tracetype]
+ * i.e.: [%p]#a[12 #lu]
+ *
+ * Variable length sequence
+ * %*.*:*v expects sizeof(*ptr), __alignof__(*ptr), elem_num, ptr
+ * where elem_num is the number of elements in the sequence
+ */
+static inline
+const char *parse_trace_type(const char *fmt, char *trace_size,
+ enum ltt_type *trace_type,
+ unsigned long *attributes)
+{
+ int qualifier; /* 'h', 'l', or 'L' for integer fields */
+ /* 'z' support added 23/7/1999 S.H. */
+ /* 'z' changed to 'Z' --davidm 1/25/99 */
+ /* 't' added for ptrdiff_t */
+
+ /* parse attributes. */
+repeat:
+ switch (*fmt) {
+ case 'n':
+ *attributes |= LTT_ATTRIBUTE_NETWORK_BYTE_ORDER;
+ ++fmt;
+ goto repeat;
+ }
+
+ /* get the conversion qualifier */
+ qualifier = -1;
+ if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
+ *fmt == 'Z' || *fmt == 'z' || *fmt == 't' ||
+ *fmt == 'S' || *fmt == '1' || *fmt == '2' ||
+ *fmt == '4' || *fmt == 8) {
+ qualifier = *fmt;
+ ++fmt;
+ if (qualifier == 'l' && *fmt == 'l') {
+ qualifier = 'L';
+ ++fmt;
+ }
+ }
+
+ switch (*fmt) {
+ case 'c':
+ *trace_type = LTT_TYPE_UNSIGNED_INT;
+ *trace_size = sizeof(unsigned char);
+ goto parse_end;
+ case 's':
+ *trace_type = LTT_TYPE_STRING;
+ goto parse_end;
+ case 'p':
+ *trace_type = LTT_TYPE_UNSIGNED_INT;
+ *trace_size = sizeof(void *);
+ goto parse_end;
+ case 'd':
+ case 'i':
+ *trace_type = LTT_TYPE_SIGNED_INT;
+ break;
+ case 'o':
+ case 'u':
+ case 'x':
+ case 'X':
+ *trace_type = LTT_TYPE_UNSIGNED_INT;
+ break;
+ default:
+ if (!*fmt)
+ --fmt;
+ goto parse_end;
+ }
+ switch (qualifier) {
+ case 'L':
+ *trace_size = sizeof(long long);
+ break;
+ case 'l':
+ *trace_size = sizeof(long);
+ break;
+ case 'Z':
+ case 'z':
+ *trace_size = sizeof(size_t);
+ break;
+ case 't':
+ *trace_size = sizeof(ptrdiff_t);
+ break;
+ case 'h':
+ *trace_size = sizeof(short);
+ break;
+ case '1':
+ *trace_size = sizeof(uint8_t);
+ break;
+ case '2':
+ *trace_size = sizeof(uint16_t);
+ break;
+ case '4':
+ *trace_size = sizeof(uint32_t);
+ break;
+ case '8':
+ *trace_size = sizeof(uint64_t);
+ break;
+ default:
+ *trace_size = sizeof(int);
+ }
+
+parse_end:
+ return fmt;
+}
+
+/*
+ * Restrictions:
+ * Field width and precision are *not* supported.
+ * %n not supported.
+ */
+static inline
+const char *parse_c_type(const char *fmt, char *c_size, enum ltt_type *c_type,
+ char *outfmt)
+{
+ int qualifier; /* 'h', 'l', or 'L' for integer fields */
+ /* 'z' support added 23/7/1999 S.H. */
+ /* 'z' changed to 'Z' --davidm 1/25/99 */
+ /* 't' added for ptrdiff_t */
+
+ /* process flags : ignore standard print formats for now. */
+repeat:
+ switch (*fmt) {
+ case '-':
+ case '+':
+ case ' ':
+ case '#':
+ case '0':
+ ++fmt;
+ goto repeat;
+ }
+
+ /* get the conversion qualifier */
+ qualifier = -1;
+ if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
+ *fmt == 'Z' || *fmt == 'z' || *fmt == 't' ||
+ *fmt == 'S') {
+ qualifier = *fmt;
+ ++fmt;
+ if (qualifier == 'l' && *fmt == 'l') {
+ qualifier = 'L';
+ ++fmt;
+ }
+ }
+
+ if (outfmt) {
+ if (qualifier != -1)
+ *outfmt++ = (char)qualifier;
+ *outfmt++ = *fmt;
+ *outfmt = 0;
+ }
+
+ switch (*fmt) {
+ case 'c':
+ *c_type = LTT_TYPE_UNSIGNED_INT;
+ *c_size = sizeof(unsigned char);
+ goto parse_end;
+ case 's':
+ *c_type = LTT_TYPE_STRING;
+ goto parse_end;
+ case 'p':
+ *c_type = LTT_TYPE_UNSIGNED_INT;
+ *c_size = sizeof(void *);
+ goto parse_end;
+ case 'd':
+ case 'i':
+ *c_type = LTT_TYPE_SIGNED_INT;
+ break;
+ case 'o':
+ case 'u':
+ case 'x':
+ case 'X':
+ *c_type = LTT_TYPE_UNSIGNED_INT;
+ break;
+ default:
+ if (!*fmt)
+ --fmt;
+ goto parse_end;
+ }
+ switch (qualifier) {
+ case 'L':
+ *c_size = sizeof(long long);
+ break;
+ case 'l':
+ *c_size = sizeof(long);
+ break;
+ case 'Z':
+ case 'z':
+ *c_size = sizeof(size_t);
+ break;
+ case 't':
+ *c_size = sizeof(ptrdiff_t);
+ break;
+ case 'h':
+ *c_size = sizeof(short);
+ break;
+ default:
+ *c_size = sizeof(int);
+ }
+
+parse_end:
+ return fmt;
+}
+
+static inline
+size_t serialize_trace_data(struct ltt_chanbuf *buf, size_t buf_offset,
+ char trace_size, enum ltt_type trace_type,
+ char c_size, enum ltt_type c_type,
+ unsigned int *stack_pos_ctx,
+ int *largest_align,
+ va_list *args)
+{
+ union {
+ unsigned long v_ulong;
+ uint64_t v_uint64;
+ struct {
+ const char *s;
+ size_t len;
+ } v_string;
+ } tmp;
+
+ /*
+ * Be careful about sign extension here.
+ * Sign extension is done with the destination (trace) type.
+ */
+ switch (trace_type) {
+ case LTT_TYPE_SIGNED_INT:
+ switch (c_size) {
+ case 1:
+ tmp.v_ulong = (long)(int8_t)va_arg(*args, int);
+ break;
+ case 2:
+ tmp.v_ulong = (long)(int16_t)va_arg(*args, int);
+ break;
+ case 4:
+ tmp.v_ulong = (long)(int32_t)va_arg(*args, int);
+ break;
+ case 8:
+ tmp.v_uint64 = va_arg(*args, int64_t);
+ break;
+ default:
+ BUG();
+ }
+ break;
+ case LTT_TYPE_UNSIGNED_INT:
+ switch (c_size) {
+ case 1:
+ tmp.v_ulong = (unsigned long)(uint8_t)va_arg(*args, unsigned int);
+ break;
+ case 2:
+ tmp.v_ulong = (unsigned long)(uint16_t)va_arg(*args, unsigned int);
+ break;
+ case 4:
+ tmp.v_ulong = (unsigned long)(uint32_t)va_arg(*args, unsigned int);
+ break;
+ case 8:
+ tmp.v_uint64 = va_arg(*args, uint64_t);
+ break;
+ default:
+ BUG();
+ }
+ break;
+ case LTT_TYPE_STRING:
+ tmp.v_string.s = va_arg(*args, const char *);
+ if ((unsigned long)tmp.v_string.s < PAGE_SIZE)
+ tmp.v_string.s = "<NULL>";
+ if (!buf) {
+ /*
+ * Reserve tracer stack entry.
+ */
+ __get_cpu_var(tracer_stack_pos)++;
+ WARN_ON_ONCE(__get_cpu_var(tracer_stack_pos)
+ > TRACER_STACK_LEN);
+ barrier();
+ __get_cpu_var(tracer_stack)[*stack_pos_ctx] =
+ strlen(tmp.v_string.s) + 1;
+ }
+ tmp.v_string.len = __get_cpu_var(tracer_stack)
+ [(*stack_pos_ctx)++];
+ if (buf)
+ ltt_relay_strncpy(&buf->a, buf->a.chan, buf_offset,
+ tmp.v_string.s, tmp.v_string.len);
+ buf_offset += tmp.v_string.len;
+ goto copydone;
+ default:
+ BUG();
+ }
+
+ /*
+ * If trace_size is lower or equal to 4 bytes, there is no sign
+ * extension to do because we are already encoded in a long. Therefore,
+ * we can combine signed and unsigned ops. 4 bytes float also works
+ * with this, because we do a simple copy of 4 bytes into 4 bytes
+ * without manipulation (and we do not support conversion from integers
+ * to floats).
+ * It is also the case if c_size is 8 bytes, which is the largest
+ * possible integer.
+ */
+ if (ltt_get_alignment()) {
+ buf_offset += ltt_align(buf_offset, trace_size);
+ if (largest_align)
+ *largest_align = max_t(int, *largest_align, trace_size);
+ }
+ if (trace_size <= 4 || c_size == 8) {
+ if (buf) {
+ switch (trace_size) {
+ case 1:
+ if (c_size == 8)
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint8_t[]){ (uint8_t)tmp.v_uint64 },
+ sizeof(uint8_t));
+ else
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint8_t[]){ (uint8_t)tmp.v_ulong },
+ sizeof(uint8_t));
+ break;
+ case 2:
+ if (c_size == 8)
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint16_t[]){ (uint16_t)tmp.v_uint64 },
+ sizeof(uint16_t));
+ else
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint16_t[]){ (uint16_t)tmp.v_ulong },
+ sizeof(uint16_t));
+ break;
+ case 4:
+ if (c_size == 8)
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint32_t[]){ (uint32_t)tmp.v_uint64 },
+ sizeof(uint32_t));
+ else
+ ltt_relay_write(&buf->a, buf->a.chan,
+ buf_offset,
+ (uint32_t[]){ (uint32_t)tmp.v_ulong },
+ sizeof(uint32_t));
+ break;
+ case 8:
+ /*
+ * c_size cannot be other than 8 here because
+ * trace_size > 4.
+ */
+ ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
+ (uint64_t[]){ (uint64_t)tmp.v_uint64 },
+ sizeof(uint64_t));
+ break;
+ default:
+ BUG();
+ }
+ }
+ buf_offset += trace_size;
+ goto copydone;
+ } else {
+ /*
+ * Perform sign extension.
+ */
+ if (buf) {
+ switch (trace_type) {
+ case LTT_TYPE_SIGNED_INT:
+ ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
+ (int64_t[]){ (int64_t)tmp.v_ulong },
+ sizeof(int64_t));
+ break;
+ case LTT_TYPE_UNSIGNED_INT:
+ ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
+ (uint64_t[]){ (uint64_t)tmp.v_ulong },
+ sizeof(uint64_t));
+ break;
+ default:
+ BUG();
+ }
+ }
+ buf_offset += trace_size;
+ goto copydone;
+ }
+
+copydone:
+ return buf_offset;
+}
+
+notrace size_t
+ltt_serialize_data(struct ltt_chanbuf *buf, size_t buf_offset,
+ struct ltt_serialize_closure *closure,
+ void *serialize_private, unsigned int stack_pos_ctx,
+ int *largest_align, const char *fmt, va_list *args)
+{
+ char trace_size = 0, c_size = 0; /*
+ * 0 (unset), 1, 2, 4, 8 bytes.
+ */
+ enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
+ unsigned long attributes = 0;
+
+ for (; *fmt ; ++fmt) {
+ switch (*fmt) {
+ case '#':
+ /* tracetypes (#) */
+ ++fmt; /* skip first '#' */
+ if (*fmt == '#') /* Escaped ## */
+ break;
+ attributes = 0;
+ fmt = parse_trace_type(fmt, &trace_size, &trace_type,
+ &attributes);
+ break;
+ case '%':
+ /* c types (%) */
+ ++fmt; /* skip first '%' */
+ if (*fmt == '%') /* Escaped %% */
+ break;
+ fmt = parse_c_type(fmt, &c_size, &c_type, NULL);
+ /*
+ * Output c types if no trace types has been
+ * specified.
+ */
+ if (!trace_size)
+ trace_size = c_size;
+ if (trace_type == LTT_TYPE_NONE)
+ trace_type = c_type;
+ if (c_type == LTT_TYPE_STRING)
+ trace_type = LTT_TYPE_STRING;
+ /* perform trace write */
+ buf_offset = serialize_trace_data(buf, buf_offset,
+ trace_size,
+ trace_type, c_size,
+ c_type,
+ &stack_pos_ctx,
+ largest_align,
+ args);
+ trace_size = 0;
+ c_size = 0;
+ trace_type = LTT_TYPE_NONE;
+ c_size = LTT_TYPE_NONE;
+ attributes = 0;
+ break;
+ /* default is to skip the text, doing nothing */
+ }
+ }
+ return buf_offset;
+}
+EXPORT_SYMBOL_GPL(ltt_serialize_data);
+
+static inline
+uint64_t unserialize_base_type(struct ltt_chanbuf *buf,
+ size_t *ppos, char trace_size,
+ enum ltt_type trace_type)
+{
+ uint64_t tmp;
+
+ *ppos += ltt_align(*ppos, trace_size);
+ ltt_relay_read(&buf->a, *ppos, &tmp, trace_size);
+ *ppos += trace_size;
+
+ switch (trace_type) {
+ case LTT_TYPE_SIGNED_INT:
+ switch (trace_size) {
+ case 1:
+ return (uint64_t)*(int8_t *)&tmp;
+ case 2:
+ return (uint64_t)*(int16_t *)&tmp;
+ case 4:
+ return (uint64_t)*(int32_t *)&tmp;
+ case 8:
+ return tmp;
+ }
+ break;
+ case LTT_TYPE_UNSIGNED_INT:
+ switch (trace_size) {
+ case 1:
+ return (uint64_t)*(uint8_t *)&tmp;
+ case 2:
+ return (uint64_t)*(uint16_t *)&tmp;
+ case 4:
+ return (uint64_t)*(uint32_t *)&tmp;
+ case 8:
+ return tmp;
+ }
+ break;
+ default:
+ break;
+ }
+
+ BUG();
+ return 0;
+}
+
+static
+int serialize_printf_data(struct ltt_chanbuf *buf, size_t *ppos,
+ char trace_size, enum ltt_type trace_type,
+ char c_size, enum ltt_type c_type, char *output,
+ ssize_t outlen, const char *outfmt)
+{
+ u64 value;
+ outlen = outlen < 0 ? 0 : outlen;
+
+ if (trace_type == LTT_TYPE_STRING) {
+ size_t len = ltt_relay_read_cstr(&buf->a, *ppos, output,
+ outlen);
+ *ppos += len + 1;
+ return len;
+ }
+
+ value = unserialize_base_type(buf, ppos, trace_size, trace_type);
+
+ if (c_size == 8)
+ return snprintf(output, outlen, outfmt, value);
+ else
+ return snprintf(output, outlen, outfmt, (unsigned int)value);
+}
+
+/**
+ * ltt_serialize_printf - Format a string and place it in a buffer
+ * @buf: The ltt-relay buffer that store binary data
+ * @buf_offset: binary data's offset in @buf (should be masked to use as offset)
+ * @msg_size: return message's length
+ * @output: The buffer to place the result into
+ * @outlen: The size of the buffer, including the trailing '\0'
+ * @fmt: The format string to use
+ *
+ * The return value is the number of characters which would
+ * be generated for the given input, excluding the trailing
+ * '\0', as per ISO C99. If the return is greater than or equal to @outlen,
+ * the resulting string is truncated.
+ */
+size_t ltt_serialize_printf(struct ltt_chanbuf *buf, unsigned long buf_offset,
+ size_t *msg_size, char *output, size_t outlen,
+ const char *fmt)
+{
+ char trace_size = 0, c_size = 0; /*
+ * 0 (unset), 1, 2, 4, 8 bytes.
+ */
+ enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
+ unsigned long attributes = 0;
+ char outfmt[4] = "%";
+ size_t outpos = 0;
+ size_t len;
+ size_t msgpos = buf_offset;
+
+ for (; *fmt ; ++fmt) {
+ switch (*fmt) {
+ case '#':
+ /* tracetypes (#) */
+ ++fmt; /* skip first '#' */
+ if (*fmt == '#') { /* Escaped ## */
+ if (outpos < outlen)
+ output[outpos] = '#';
+ outpos++;
+ break;
+ }
+ attributes = 0;
+ fmt = parse_trace_type(fmt, &trace_size, &trace_type,
+ &attributes);
+ break;
+ case '%':
+ /* c types (%) */
+ ++fmt; /* skip first '%' */
+ if (*fmt == '%') { /* Escaped %% */
+ if (outpos < outlen)
+ output[outpos] = '%';
+ outpos++;
+ break;
+ }
+ fmt = parse_c_type(fmt, &c_size, &c_type, outfmt + 1);
+ /*
+ * Output c types if no trace types has been
+ * specified.
+ */
+ if (!trace_size)
+ trace_size = c_size;
+ if (trace_type == LTT_TYPE_NONE)
+ trace_type = c_type;
+ if (c_type == LTT_TYPE_STRING)
+ trace_type = LTT_TYPE_STRING;
+
+ /* perform trace printf */
+ len = serialize_printf_data(buf, &msgpos, trace_size,
+ trace_type, c_size, c_type,
+ output + outpos,
+ outlen - outpos, outfmt);
+ outpos += len;
+ trace_size = 0;
+ c_size = 0;
+ trace_type = LTT_TYPE_NONE;
+ c_size = LTT_TYPE_NONE;
+ attributes = 0;
+ break;
+ default:
+ if (outpos < outlen)
+ output[outpos] = *fmt;
+ outpos++;
+ break;
+ }
+ }
+ if (msg_size)
+ *msg_size = (size_t)(msgpos - buf_offset);
+ /*
+ * Make sure we end output with terminating \0 when truncated.
+ */
+ if (outpos >= outlen + 1)
+ output[outlen] = '\0';
+ return outpos;
+}
+EXPORT_SYMBOL_GPL(ltt_serialize_printf);
+
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+
+unsigned int ltt_fmt_largest_align(size_t align_drift, const char *fmt)
+{
+ char trace_size = 0, c_size = 0;
+ enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
+ unsigned long attributes = 0;
+ int largest_align = 1;
+
+ for (; *fmt ; ++fmt) {
+ switch (*fmt) {
+ case '#':
+ /* tracetypes (#) */
+ ++fmt; /* skip first '#' */
+ if (*fmt == '#') /* Escaped ## */
+ break;
+ attributes = 0;
+ fmt = parse_trace_type(fmt, &trace_size, &trace_type,
+ &attributes);
+
+ largest_align = max_t(int, largest_align, trace_size);
+ if (largest_align >= ltt_get_alignment())
+ goto exit;
+ break;
+ case '%':
+ /* c types (%) */
+ ++fmt; /* skip first '%' */
+ if (*fmt == '%') /* Escaped %% */
+ break;
+ fmt = parse_c_type(fmt, &c_size, &c_type, NULL);
+ /*
+ * Output c types if no trace types has been
+ * specified.
+ */
+ if (!trace_size)
+ trace_size = c_size;
+ if (trace_type == LTT_TYPE_NONE)
+ trace_type = c_type;
+ if (c_type == LTT_TYPE_STRING)
+ trace_type = LTT_TYPE_STRING;
+
+ largest_align = max_t(int, largest_align, trace_size);
+ if (largest_align >= ltt_get_alignment())
+ goto exit;
+
+ trace_size = 0;
+ c_size = 0;
+ trace_type = LTT_TYPE_NONE;
+ c_size = LTT_TYPE_NONE;
+ break;
+ }
+ }
+
+exit:
+ largest_align = min_t(int, largest_align, ltt_get_alignment());
+ return (largest_align - align_drift) & (largest_align - 1);
+}
+EXPORT_SYMBOL_GPL(ltt_fmt_largest_align);
+
+#endif
+
+/*
+ * Calculate data size
+ * Assume that the padding for alignment starts at a sizeof(void *) address.
+ */
+static notrace
+size_t ltt_get_data_size(struct ltt_serialize_closure *closure,
+ void *serialize_private, unsigned int stack_pos_ctx,
+ int *largest_align, const char *fmt, va_list *args)
+{
+ ltt_serialize_cb cb = closure->callbacks[0];
+ closure->cb_idx = 0;
+ return (size_t)cb(NULL, 0, closure, serialize_private, stack_pos_ctx,
+ largest_align, fmt, args);
+}
+
+static notrace
+void ltt_write_event_data(struct ltt_chanbuf *buf, size_t buf_offset,
+ struct ltt_serialize_closure *closure,
+ void *serialize_private, unsigned int stack_pos_ctx,
+ int largest_align, const char *fmt, va_list *args)
+{
+ ltt_serialize_cb cb = closure->callbacks[0];
+ closure->cb_idx = 0;
+ buf_offset += ltt_align(buf_offset, largest_align);
+ cb(buf, buf_offset, closure, serialize_private, stack_pos_ctx, NULL,
+ fmt, args);
+}
+
+
+notrace
+void ltt_vtrace(const struct marker *mdata, void *probe_data, void *call_data,
+ const char *fmt, va_list *args)
+{
+ int largest_align, ret;
+ struct ltt_active_marker *pdata;
+ uint16_t eID;
+ size_t data_size, slot_size;
+ unsigned int chan_index;
+ struct ltt_chanbuf *buf;
+ struct ltt_chan *chan;
+ struct ltt_trace *trace, *dest_trace = NULL;
+ uint64_t tsc;
+ long buf_offset;
+ va_list args_copy;
+ struct ltt_serialize_closure closure;
+ struct ltt_probe_private_data *private_data = call_data;
+ void *serialize_private = NULL;
+ int cpu;
+ unsigned int rflags;
+ unsigned int stack_pos_ctx;
+
+ /*
+ * This test is useful for quickly exiting static tracing when no trace
+ * is active. We expect to have an active trace when we get here.
+ */
+ if (unlikely(ltt_traces.num_active_traces == 0))
+ return;
+
+ rcu_read_lock_sched_notrace();
+ cpu = smp_processor_id();
+ __get_cpu_var(ltt_nesting)++;
+ stack_pos_ctx = __get_cpu_var(tracer_stack_pos);
+ /*
+ * asm volatile and "memory" clobber prevent the compiler from moving
+ * instructions out of the ltt nesting count. This is required to ensure
+ * that probe side-effects which can cause recursion (e.g. unforeseen
+ * traps, divisions by 0, ...) are triggered within the incremented
+ * nesting count section.
+ */
+ barrier();
+ pdata = (struct ltt_active_marker *)probe_data;
+ eID = mdata->event_id;
+ chan_index = mdata->channel_id;
+ closure.callbacks = pdata->probe->callbacks;
+
+ if (unlikely(private_data)) {
+ dest_trace = private_data->trace;
+ if (private_data->serializer)
+ closure.callbacks = &private_data->serializer;
+ serialize_private = private_data->serialize_private;
+ }
+
+ va_copy(args_copy, *args);
+ /*
+ * Assumes event payload to start on largest_align alignment.
+ */
+ largest_align = 1; /* must be non-zero for ltt_align */
+ data_size = ltt_get_data_size(&closure, serialize_private,
+ stack_pos_ctx, &largest_align,
+ fmt, &args_copy);
+ largest_align = min_t(int, largest_align, sizeof(void *));
+ va_end(args_copy);
+
+ /* Iterate on each trace */
+ list_for_each_entry_rcu(trace, <t_traces.head, list) {
+ /*
+ * Expect the filter to filter out events. If we get here,
+ * we went through tracepoint activation as a first step.
+ */
+ if (unlikely(dest_trace && trace != dest_trace))
+ continue;
+ if (unlikely(!trace->active))
+ continue;
+ if (unlikely(!ltt_run_filter(trace, eID)))
+ continue;
+#ifdef LTT_DEBUG_EVENT_SIZE
+ rflags = LTT_RFLAG_ID_SIZE;
+#else
+ if (unlikely(eID >= LTT_FREE_EVENTS))
+ rflags = LTT_RFLAG_ID;
+ else
+ rflags = 0;
+#endif
+ /*
+ * Skip channels added after trace creation.
+ */
+ if (unlikely(chan_index >= trace->nr_channels))
+ continue;
+ chan = &trace->channels[chan_index];
+ if (!chan->active)
+ continue;
+
+ /* reserve space : header and data */
+ ret = ltt_reserve_slot(chan, trace, data_size, largest_align,
+ cpu, &buf, &slot_size, &buf_offset,
+ &tsc, &rflags);
+ if (unlikely(ret < 0))
+ continue; /* buffer full */
+
+ va_copy(args_copy, *args);
+ /* Out-of-order write : header and data */
+ buf_offset = ltt_write_event_header(&buf->a, &chan->a,
+ buf_offset, eID, data_size,
+ tsc, rflags);
+ ltt_write_event_data(buf, buf_offset, &closure,
+ serialize_private, stack_pos_ctx,
+ largest_align, fmt, &args_copy);
+ va_end(args_copy);
+ /* Out-of-order commit */
+ ltt_commit_slot(buf, chan, buf_offset, data_size, slot_size);
+ }
+ /*
+ * asm volatile and "memory" clobber prevent the compiler from moving
+ * instructions out of the ltt nesting count. This is required to ensure
+ * that probe side-effects which can cause recursion (e.g. unforeseen
+ * traps, divisions by 0, ...) are triggered within the incremented
+ * nesting count section.
+ */
+ barrier();
+ __get_cpu_var(tracer_stack_pos) = stack_pos_ctx;
+ __get_cpu_var(ltt_nesting)--;
+ rcu_read_unlock_sched_notrace();
+}
+EXPORT_SYMBOL_GPL(ltt_vtrace);
+
+notrace
+void ltt_trace(const struct marker *mdata, void *probe_data, void *call_data,
+ const char *fmt, ...)
+{
+ va_list args;
+
+ va_start(args, fmt);
+ ltt_vtrace(mdata, probe_data, call_data, fmt, &args);
+ va_end(args);
+}
+EXPORT_SYMBOL_GPL(ltt_trace);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Serializer");
--- /dev/null
+/*
+ * Linux Trace Toolkit Kernel State Dump
+ *
+ * Copyright 2005 -
+ * Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
+ *
+ * Changes:
+ * Eric Clement: Add listing of network IP interface
+ * 2006, 2007 Mathieu Desnoyers Fix kernel threads
+ * Various updates
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/netlink.h>
+#include <linux/inet.h>
+#include <linux/ip.h>
+#include <linux/kthread.h>
+#include <linux/proc_fs.h>
+#include <linux/file.h>
+#include <linux/interrupt.h>
+#include <linux/irqnr.h>
+#include <linux/cpu.h>
+#include <linux/netdevice.h>
+#include <linux/inetdevice.h>
+#include <linux/sched.h>
+#include <linux/mm.h>
+#include <linux/marker.h>
+#include <linux/fdtable.h>
+#include <linux/swap.h>
+#include <linux/wait.h>
+#include <linux/mutex.h>
+
+#include "ltt-tracer.h"
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+#include <linux/irq.h>
+#endif
+
+#define NB_PROC_CHUNK 20
+
+/*
+ * Protected by the trace lock.
+ */
+static struct delayed_work cpu_work[NR_CPUS];
+static DECLARE_WAIT_QUEUE_HEAD(statedump_wq);
+static atomic_t kernel_threads_to_run;
+
+static void empty_cb(void *call_data)
+{
+}
+
+static DEFINE_MUTEX(statedump_cb_mutex);
+static void (*ltt_dump_kprobes_table_cb)(void *call_data) = empty_cb;
+
+enum lttng_thread_type {
+ LTTNG_USER_THREAD = 0,
+ LTTNG_KERNEL_THREAD = 1,
+};
+
+enum lttng_execution_mode {
+ LTTNG_USER_MODE = 0,
+ LTTNG_SYSCALL = 1,
+ LTTNG_TRAP = 2,
+ LTTNG_IRQ = 3,
+ LTTNG_SOFTIRQ = 4,
+ LTTNG_MODE_UNKNOWN = 5,
+};
+
+enum lttng_execution_submode {
+ LTTNG_NONE = 0,
+ LTTNG_UNKNOWN = 1,
+};
+
+enum lttng_process_status {
+ LTTNG_UNNAMED = 0,
+ LTTNG_WAIT_FORK = 1,
+ LTTNG_WAIT_CPU = 2,
+ LTTNG_EXIT = 3,
+ LTTNG_ZOMBIE = 4,
+ LTTNG_WAIT = 5,
+ LTTNG_RUN = 6,
+ LTTNG_DEAD = 7,
+};
+
+#ifdef CONFIG_INET
+static void ltt_enumerate_device(struct ltt_probe_private_data *call_data,
+ struct net_device *dev)
+{
+ struct in_device *in_dev;
+ struct in_ifaddr *ifa;
+
+ if (dev->flags & IFF_UP) {
+ in_dev = in_dev_get(dev);
+ if (in_dev) {
+ for (ifa = in_dev->ifa_list; ifa != NULL;
+ ifa = ifa->ifa_next)
+ __trace_mark(0, netif_state,
+ network_ipv4_interface,
+ call_data,
+ "name %s address #n4u%lu up %d",
+ dev->name,
+ (unsigned long)ifa->ifa_address,
+ 0);
+ in_dev_put(in_dev);
+ }
+ } else
+ __trace_mark(0, netif_state, network_ip_interface,
+ call_data, "name %s address #n4u%lu up %d",
+ dev->name, 0UL, 0);
+}
+
+static inline int
+ltt_enumerate_network_ip_interface(struct ltt_probe_private_data *call_data)
+{
+ struct net_device *dev;
+
+ read_lock(&dev_base_lock);
+ for_each_netdev(&init_net, dev)
+ ltt_enumerate_device(call_data, dev);
+ read_unlock(&dev_base_lock);
+
+ return 0;
+}
+#else /* CONFIG_INET */
+static inline int
+ltt_enumerate_network_ip_interface(struct ltt_probe_private_data *call_data)
+{
+ return 0;
+}
+#endif /* CONFIG_INET */
+
+
+static inline void
+ltt_enumerate_task_fd(struct ltt_probe_private_data *call_data,
+ struct task_struct *t, char *tmp)
+{
+ struct fdtable *fdt;
+ struct file *filp;
+ unsigned int i;
+ const unsigned char *path;
+
+ if (!t->files)
+ return;
+
+ spin_lock(&t->files->file_lock);
+ fdt = files_fdtable(t->files);
+ for (i = 0; i < fdt->max_fds; i++) {
+ filp = fcheck_files(t->files, i);
+ if (!filp)
+ continue;
+ path = d_path(&filp->f_path, tmp, PAGE_SIZE);
+ /* Make sure we give at least some info */
+ __trace_mark(0, fd_state, file_descriptor, call_data,
+ "filename %s pid %d fd %u",
+ (IS_ERR(path))?(filp->f_dentry->d_name.name):(path),
+ t->pid, i);
+ }
+ spin_unlock(&t->files->file_lock);
+}
+
+static inline int
+ltt_enumerate_file_descriptors(struct ltt_probe_private_data *call_data)
+{
+ struct task_struct *t = &init_task;
+ char *tmp = (char *)__get_free_page(GFP_KERNEL);
+
+ /* Enumerate active file descriptors */
+ do {
+ read_lock(&tasklist_lock);
+ if (t != &init_task)
+ atomic_dec(&t->usage);
+ t = next_task(t);
+ atomic_inc(&t->usage);
+ read_unlock(&tasklist_lock);
+ task_lock(t);
+ ltt_enumerate_task_fd(call_data, t, tmp);
+ task_unlock(t);
+ } while (t != &init_task);
+ free_page((unsigned long)tmp);
+ return 0;
+}
+
+static inline void
+ltt_enumerate_task_vm_maps(struct ltt_probe_private_data *call_data,
+ struct task_struct *t)
+{
+ struct mm_struct *mm;
+ struct vm_area_struct *map;
+ unsigned long ino;
+
+ /* get_task_mm does a task_lock... */
+ mm = get_task_mm(t);
+ if (!mm)
+ return;
+
+ map = mm->mmap;
+ if (map) {
+ down_read(&mm->mmap_sem);
+ while (map) {
+ if (map->vm_file)
+ ino = map->vm_file->f_dentry->d_inode->i_ino;
+ else
+ ino = 0;
+ __trace_mark(0, vm_state, vm_map, call_data,
+ "pid %d start %lu end %lu flags %lu "
+ "pgoff %lu inode %lu",
+ t->pid, map->vm_start, map->vm_end,
+ map->vm_flags, map->vm_pgoff << PAGE_SHIFT,
+ ino);
+ map = map->vm_next;
+ }
+ up_read(&mm->mmap_sem);
+ }
+ mmput(mm);
+}
+
+static inline int
+ltt_enumerate_vm_maps(struct ltt_probe_private_data *call_data)
+{
+ struct task_struct *t = &init_task;
+
+ do {
+ read_lock(&tasklist_lock);
+ if (t != &init_task)
+ atomic_dec(&t->usage);
+ t = next_task(t);
+ atomic_inc(&t->usage);
+ read_unlock(&tasklist_lock);
+ ltt_enumerate_task_vm_maps(call_data, t);
+ } while (t != &init_task);
+ return 0;
+}
+
+#ifdef CONFIG_GENERIC_HARDIRQS
+static inline void list_interrupts(struct ltt_probe_private_data *call_data)
+{
+ unsigned int irq;
+ unsigned long flags = 0;
+ struct irq_desc *desc;
+
+ /* needs irq_desc */
+ for_each_irq_desc(irq, desc) {
+ struct irqaction *action;
+ const char *irq_chip_name =
+ desc->chip->name ? : "unnamed_irq_chip";
+
+ local_irq_save(flags);
+ raw_spin_lock(&desc->lock);
+ for (action = desc->action; action; action = action->next)
+ __trace_mark(0, irq_state, interrupt, call_data,
+ "name %s action %s irq_id %u",
+ irq_chip_name, action->name, irq);
+ raw_spin_unlock(&desc->lock);
+ local_irq_restore(flags);
+ }
+}
+#else
+static inline void list_interrupts(struct ltt_probe_private_data *call_data)
+{
+}
+#endif
+
+static inline int
+ltt_enumerate_process_states(struct ltt_probe_private_data *call_data)
+{
+ struct task_struct *t = &init_task;
+ struct task_struct *p = t;
+ enum lttng_process_status status;
+ enum lttng_thread_type type;
+ enum lttng_execution_mode mode;
+ enum lttng_execution_submode submode;
+
+ do {
+ mode = LTTNG_MODE_UNKNOWN;
+ submode = LTTNG_UNKNOWN;
+
+ read_lock(&tasklist_lock);
+ if (t != &init_task) {
+ atomic_dec(&t->usage);
+ t = next_thread(t);
+ }
+ if (t == p) {
+ p = next_task(t);
+ t = p;
+ }
+ atomic_inc(&t->usage);
+ read_unlock(&tasklist_lock);
+
+ task_lock(t);
+
+ if (t->exit_state == EXIT_ZOMBIE)
+ status = LTTNG_ZOMBIE;
+ else if (t->exit_state == EXIT_DEAD)
+ status = LTTNG_DEAD;
+ else if (t->state == TASK_RUNNING) {
+ /* Is this a forked child that has not run yet? */
+ if (list_empty(&t->rt.run_list))
+ status = LTTNG_WAIT_FORK;
+ else
+ /*
+ * All tasks are considered as wait_cpu;
+ * the viewer will sort out if the task was
+ * really running at this time.
+ */
+ status = LTTNG_WAIT_CPU;
+ } else if (t->state &
+ (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)) {
+ /* Task is waiting for something to complete */
+ status = LTTNG_WAIT;
+ } else
+ status = LTTNG_UNNAMED;
+ submode = LTTNG_NONE;
+
+ /*
+ * Verification of t->mm is to filter out kernel threads;
+ * Viewer will further filter out if a user-space thread was
+ * in syscall mode or not.
+ */
+ if (t->mm)
+ type = LTTNG_USER_THREAD;
+ else
+ type = LTTNG_KERNEL_THREAD;
+
+ __trace_mark(0, task_state, process_state, call_data,
+ "pid %d parent_pid %d name %s type %d mode %d "
+ "submode %d status %d tgid %d",
+ t->pid, t->parent->pid, t->comm,
+ type, mode, submode, status, t->tgid);
+ task_unlock(t);
+ } while (t != &init_task);
+
+ return 0;
+}
+
+void ltt_statedump_register_kprobes_dump(void (*callback)(void *call_data))
+{
+ mutex_lock(&statedump_cb_mutex);
+ ltt_dump_kprobes_table_cb = callback;
+ mutex_unlock(&statedump_cb_mutex);
+}
+EXPORT_SYMBOL_GPL(ltt_statedump_register_kprobes_dump);
+
+void ltt_statedump_unregister_kprobes_dump(void (*callback)(void *call_data))
+{
+ mutex_lock(&statedump_cb_mutex);
+ ltt_dump_kprobes_table_cb = empty_cb;
+ mutex_unlock(&statedump_cb_mutex);
+}
+EXPORT_SYMBOL_GPL(ltt_statedump_unregister_kprobes_dump);
+
+void ltt_statedump_work_func(struct work_struct *work)
+{
+ if (atomic_dec_and_test(&kernel_threads_to_run))
+ /* If we are the last thread, wake up do_ltt_statedump */
+ wake_up(&statedump_wq);
+}
+
+static int do_ltt_statedump(struct ltt_probe_private_data *call_data)
+{
+ int cpu;
+ struct module *cb_owner;
+
+ printk(KERN_DEBUG "LTT state dump thread start\n");
+ ltt_enumerate_process_states(call_data);
+ ltt_enumerate_file_descriptors(call_data);
+ list_modules(call_data);
+ ltt_enumerate_vm_maps(call_data);
+ list_interrupts(call_data);
+ ltt_enumerate_network_ip_interface(call_data);
+ ltt_dump_swap_files(call_data);
+ ltt_dump_sys_call_table(call_data);
+ ltt_dump_softirq_vec(call_data);
+ ltt_dump_idt_table(call_data);
+
+ mutex_lock(&statedump_cb_mutex);
+
+ cb_owner = __module_address((unsigned long)ltt_dump_kprobes_table_cb);
+ __module_get(cb_owner);
+ ltt_dump_kprobes_table_cb(call_data);
+ module_put(cb_owner);
+
+ mutex_unlock(&statedump_cb_mutex);
+
+ /*
+ * Fire off a work queue on each CPU. Their sole purpose in life
+ * is to guarantee that each CPU has been in a state where is was in
+ * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
+ */
+ get_online_cpus();
+ atomic_set(&kernel_threads_to_run, num_online_cpus());
+ for_each_online_cpu(cpu) {
+ INIT_DELAYED_WORK(&cpu_work[cpu], ltt_statedump_work_func);
+ 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));
+ put_online_cpus();
+ /* Our work is done */
+ printk(KERN_DEBUG "LTT state dump end\n");
+ __trace_mark(0, global_state, statedump_end,
+ call_data, MARK_NOARGS);
+ return 0;
+}
+
+/*
+ * Called with trace lock held.
+ */
+int ltt_statedump_start(struct ltt_trace *trace)
+{
+ struct ltt_probe_private_data call_data;
+ printk(KERN_DEBUG "LTT state dump begin\n");
+
+ call_data.trace = trace;
+ call_data.serializer = NULL;
+ return do_ltt_statedump(&call_data);
+}
+
+static int __init statedump_init(void)
+{
+ int ret;
+ printk(KERN_DEBUG "LTT : State dump init\n");
+ ret = ltt_module_register(LTT_FUNCTION_STATEDUMP,
+ ltt_statedump_start, THIS_MODULE);
+ return ret;
+}
+
+static void __exit statedump_exit(void)
+{
+ printk(KERN_DEBUG "LTT : State dump exit\n");
+ ltt_module_unregister(LTT_FUNCTION_STATEDUMP);
+}
+
+module_init(statedump_init)
+module_exit(statedump_exit)
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Jean-Hugues Deschenes");
+MODULE_DESCRIPTION("Linux Trace Toolkit Statedump");
--- /dev/null
+/*
+ * LTT trace control module over debugfs.
+ *
+ * Copyright 2008 - Zhaolei <zhaolei@cn.fujitsu.com>
+ *
+ * Copyright 2009 - Gui Jianfeng <guijianfeng@cn.fujitsu.com>
+ * Make mark-control work in debugfs
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+/*
+ * Todo:
+ * Impl read operations for control file to read attributes
+ * Create a README file in ltt control dir, for display help info
+ */
+
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <linux/notifier.h>
+#include <linux/jiffies.h>
+#include <linux/marker.h>
+
+#include "ltt-tracer.h"
+
+#define LTT_CONTROL_DIR "control"
+#define MARKERS_CONTROL_DIR "markers"
+#define LTT_SETUP_TRACE_FILE "setup_trace"
+#define LTT_DESTROY_TRACE_FILE "destroy_trace"
+
+#define LTT_WRITE_MAXLEN (128)
+
+struct dentry *ltt_control_dir, *ltt_setup_trace_file, *ltt_destroy_trace_file,
+ *markers_control_dir;
+
+/*
+ * the traces_lock nests inside control_lock.
+ * control_lock protects the consistency of directories presented in ltt
+ * directory.
+ */
+static DEFINE_MUTEX(control_lock);
+
+/*
+ * big note about locking for marker control files :
+ * If a marker control file is added/removed manually racing with module
+ * load/unload, there may be warning messages appearing, but those two
+ * operations should be able to execute concurrently without any lock
+ * synchronizing their operation one wrt another.
+ * Locking the marker mutex, module mutex and also keeping a mutex here
+ * from mkdir/rmdir _and_ from the notifier called from module load/unload makes
+ * life miserable and just asks for deadlocks.
+ */
+
+/*
+ * lookup a file/dir in parent dir.
+ * only designed to work well for debugfs.
+ * (although it maybe ok for other fs)
+ *
+ * return:
+ * file/dir's dentry on success
+ * NULL on failure
+ */
+static struct dentry *dir_lookup(struct dentry *parent, const char *name)
+{
+ struct qstr q;
+ struct dentry *d;
+
+ q.name = name;
+ q.len = strlen(name);
+ q.hash = full_name_hash(q.name, q.len);
+
+ d = d_lookup(parent, &q);
+ if (d)
+ dput(d);
+
+ return d;
+}
+
+
+static ssize_t alloc_write(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *cmd = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", cmd) != 1) {
+ err = -EPERM;
+ goto err_get_cmd;
+ }
+
+ if ((cmd[0] != 'Y' && cmd[0] != 'y' && cmd[0] != '1') || cmd[1]) {
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ err = ltt_trace_alloc(file->f_dentry->d_parent->d_name.name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "alloc_write: ltt_trace_alloc failed: %d\n",
+ err);
+ goto err_alloc_trace;
+ }
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return count;
+
+err_alloc_trace:
+err_bad_cmd:
+err_get_cmd:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return err;
+}
+
+static const struct file_operations ltt_alloc_operations = {
+ .write = alloc_write,
+};
+
+
+static ssize_t enabled_write(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *cmd = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", cmd) != 1) {
+ err = -EPERM;
+ goto err_get_cmd;
+ }
+
+ if (cmd[1]) {
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ switch (cmd[0]) {
+ case 'Y':
+ case 'y':
+ case '1':
+ err = ltt_trace_start(file->f_dentry->d_parent->d_name.name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR
+ "enabled_write: ltt_trace_start failed: %d\n",
+ err);
+ err = -EPERM;
+ goto err_start_trace;
+ }
+ break;
+ case 'N':
+ case 'n':
+ case '0':
+ err = ltt_trace_stop(file->f_dentry->d_parent->d_name.name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR
+ "enabled_write: ltt_trace_stop failed: %d\n",
+ err);
+ err = -EPERM;
+ goto err_stop_trace;
+ }
+ break;
+ default:
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return count;
+
+err_stop_trace:
+err_start_trace:
+err_bad_cmd:
+err_get_cmd:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return err;
+}
+
+static const struct file_operations ltt_enabled_operations = {
+ .write = enabled_write,
+};
+
+
+static ssize_t trans_write(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *trans_name = (char *)__get_free_page(GFP_KERNEL);
+ int err = 0;
+ int buf_size;
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", trans_name) != 1) {
+ err = -EPERM;
+ goto err_get_transname;
+ }
+
+ err = ltt_trace_set_type(file->f_dentry->d_parent->d_name.name,
+ trans_name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "trans_write: ltt_trace_set_type failed: %d\n",
+ err);
+ goto err_set_trans;
+ }
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trans_name);
+ return count;
+
+err_set_trans:
+err_get_transname:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trans_name);
+ return err;
+}
+
+static const struct file_operations ltt_trans_operations = {
+ .write = trans_write,
+};
+
+
+static ssize_t channel_subbuf_num_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ unsigned int num;
+ const char *channel_name;
+ const char *trace_name;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%u", &num) != 1) {
+ err = -EPERM;
+ goto err_get_number;
+ }
+
+ channel_name = file->f_dentry->d_parent->d_name.name;
+ trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
+
+ err = ltt_trace_set_channel_subbufcount(trace_name, channel_name, num);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_subbuf_num_write: "
+ "ltt_trace_set_channel_subbufcount failed: %d\n", err);
+ goto err_set_subbufcount;
+ }
+
+ free_page((unsigned long)buf);
+ return count;
+
+err_set_subbufcount:
+err_get_number:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ return err;
+}
+
+static const struct file_operations ltt_channel_subbuf_num_operations = {
+ .write = channel_subbuf_num_write,
+};
+
+
+static
+ssize_t channel_subbuf_size_write(struct file *file,
+ const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ unsigned int num;
+ const char *channel_name;
+ const char *trace_name;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%u", &num) != 1) {
+ err = -EPERM;
+ goto err_get_number;
+ }
+
+ channel_name = file->f_dentry->d_parent->d_name.name;
+ trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
+
+ err = ltt_trace_set_channel_subbufsize(trace_name, channel_name, num);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_subbuf_size_write: "
+ "ltt_trace_set_channel_subbufsize failed: %d\n", err);
+ goto err_set_subbufsize;
+ }
+
+ free_page((unsigned long)buf);
+ return count;
+
+err_set_subbufsize:
+err_get_number:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ return err;
+}
+
+static const struct file_operations ltt_channel_subbuf_size_operations = {
+ .write = channel_subbuf_size_write,
+};
+
+static
+ssize_t channel_switch_timer_write(struct file *file,
+ const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ unsigned long num;
+ const char *channel_name;
+ const char *trace_name;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%lu", &num) != 1) {
+ err = -EPERM;
+ goto err_get_number;
+ }
+
+ channel_name = file->f_dentry->d_parent->d_name.name;
+ trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
+
+ /* Convert from ms to us */
+ num *= 1000;
+
+ err = ltt_trace_set_channel_switch_timer(trace_name, channel_name, num);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_switch_timer_write: "
+ "ltt_trace_set_channel_switch_timer failed: %d\n", err);
+ goto err_set_switch_timer;
+ }
+
+ free_page((unsigned long)buf);
+ return count;
+
+err_set_switch_timer:
+err_get_number:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ return err;
+}
+
+static struct file_operations ltt_channel_switch_timer_operations = {
+ .write = channel_switch_timer_write,
+};
+
+static
+ssize_t channel_overwrite_write(struct file *file,
+ const char __user *user_buf, size_t count,
+ loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ const char *channel_name;
+ const char *trace_name;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *cmd = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", cmd) != 1) {
+ err = -EPERM;
+ goto err_get_cmd;
+ }
+
+ if (cmd[1]) {
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ channel_name = file->f_dentry->d_parent->d_name.name;
+ trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
+
+ switch (cmd[0]) {
+ case 'Y':
+ case 'y':
+ case '1':
+ err = ltt_trace_set_channel_overwrite(trace_name, channel_name,
+ 1);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_overwrite_write: "
+ "ltt_trace_set_channel_overwrite failed: %d\n",
+ err);
+ goto err_set_subbufsize;
+ }
+ break;
+ case 'N':
+ case 'n':
+ case '0':
+ err = ltt_trace_set_channel_overwrite(trace_name, channel_name,
+ 0);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_overwrite_write: "
+ "ltt_trace_set_channel_overwrite failed: %d\n",
+ err);
+ goto err_set_subbufsize;
+ }
+ break;
+ default:
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return count;
+
+err_set_subbufsize:
+err_bad_cmd:
+err_get_cmd:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return err;
+}
+
+static const struct file_operations ltt_channel_overwrite_operations = {
+ .write = channel_overwrite_write,
+};
+
+
+static
+ssize_t channel_enable_write(struct file *file,
+ const char __user *user_buf, size_t count,
+ loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ const char *channel_name;
+ const char *trace_name;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *cmd = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", cmd) != 1) {
+ err = -EPERM;
+ goto err_get_cmd;
+ }
+
+ if (cmd[1]) {
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ channel_name = file->f_dentry->d_parent->d_name.name;
+ trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
+
+ switch (cmd[0]) {
+ case 'Y':
+ case 'y':
+ case '1':
+ err = ltt_trace_set_channel_enable(trace_name, channel_name,
+ 1);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_enable_write: "
+ "ltt_trace_set_channel_enable failed: %d\n",
+ err);
+ goto err_set_subbufsize;
+ }
+ break;
+ case 'N':
+ case 'n':
+ case '0':
+ err = ltt_trace_set_channel_enable(trace_name, channel_name,
+ 0);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "channel_enable_write: "
+ "ltt_trace_set_channel_enable failed: %d\n",
+ err);
+ goto err_set_subbufsize;
+ }
+ break;
+ default:
+ err = -EPERM;
+ goto err_bad_cmd;
+ }
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return count;
+
+err_set_subbufsize:
+err_bad_cmd:
+err_get_cmd:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)cmd);
+ return err;
+}
+
+static const struct file_operations ltt_channel_enable_operations = {
+ .write = channel_enable_write,
+};
+
+
+static int _create_trace_control_dir(const char *trace_name,
+ struct ltt_trace *trace)
+{
+ int err;
+ struct dentry *trace_root, *channel_root;
+ struct dentry *tmp_den;
+ int i;
+
+ /* debugfs/control/trace_name */
+ trace_root = debugfs_create_dir(trace_name, ltt_control_dir);
+ if (IS_ERR(trace_root) || !trace_root) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create control root dir of %s failed\n", trace_name);
+ err = -ENOMEM;
+ goto err_create_trace_root;
+ }
+
+ /* debugfs/control/trace_name/alloc */
+ tmp_den = debugfs_create_file("alloc", S_IWUSR, trace_root, NULL,
+ <t_alloc_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create file of alloc failed\n");
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ /* debugfs/control/trace_name/trans */
+ tmp_den = debugfs_create_file("trans", S_IWUSR, trace_root, NULL,
+ <t_trans_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create file of trans failed\n");
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ /* debugfs/control/trace_name/enabled */
+ tmp_den = debugfs_create_file("enabled", S_IWUSR, trace_root, NULL,
+ <t_enabled_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create file of enabled failed\n");
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ /* debugfs/control/trace_name/channel/ */
+ channel_root = debugfs_create_dir("channel", trace_root);
+ if (IS_ERR(channel_root) || !channel_root) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create dir of channel failed\n");
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ /*
+ * Create dir and files in debugfs/ltt/control/trace_name/channel/
+ * Following things(without <>) will be created:
+ * `-- <control>
+ * `-- <trace_name>
+ * `-- <channel>
+ * |-- <channel_name>
+ * | |-- enable
+ * | |-- overwrite
+ * | |-- subbuf_num
+ * | |-- subbuf_size
+ * | `-- switch_timer
+ * `-- ...
+ */
+
+ for (i = 0; i < trace->nr_channels; i++) {
+ struct dentry *channel_den;
+ struct ltt_chan *chan;
+
+ chan = &trace->channels[i];
+ if (!chan->active)
+ continue;
+ channel_den = debugfs_create_dir(chan->a.filename,
+ channel_root);
+ if (IS_ERR(channel_den) || !channel_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create channel dir of %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ tmp_den = debugfs_create_file("subbuf_num", S_IWUSR,
+ channel_den, NULL,
+ <t_channel_subbuf_num_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create subbuf_num in %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ tmp_den = debugfs_create_file("subbuf_size", S_IWUSR,
+ channel_den, NULL,
+ <t_channel_subbuf_size_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create subbuf_size in %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ tmp_den = debugfs_create_file("enable", S_IWUSR, channel_den,
+ NULL,
+ <t_channel_enable_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create enable in %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ tmp_den = debugfs_create_file("overwrite", S_IWUSR, channel_den,
+ NULL,
+ <t_channel_overwrite_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create overwrite in %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+
+ tmp_den = debugfs_create_file("switch_timer", S_IWUSR,
+ channel_den, NULL,
+ <t_channel_switch_timer_operations);
+ if (IS_ERR(tmp_den) || !tmp_den) {
+ printk(KERN_ERR "_create_trace_control_dir: "
+ "create switch_timer in %s failed\n",
+ chan->a.filename);
+ err = -ENOMEM;
+ goto err_create_subdir;
+ }
+ }
+
+ return 0;
+
+err_create_subdir:
+ debugfs_remove_recursive(trace_root);
+err_create_trace_root:
+ return err;
+}
+
+static
+ssize_t setup_trace_write(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ int err = 0;
+ int buf_size;
+ struct ltt_trace *trace;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *trace_name = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", trace_name) != 1) {
+ err = -EPERM;
+ goto err_get_tracename;
+ }
+
+ mutex_lock(&control_lock);
+ ltt_lock_traces();
+
+ err = _ltt_trace_setup(trace_name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR
+ "setup_trace_write: ltt_trace_setup failed: %d\n", err);
+ goto err_setup_trace;
+ }
+ trace = _ltt_trace_find_setup(trace_name);
+ BUG_ON(!trace);
+ err = _create_trace_control_dir(trace_name, trace);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR "setup_trace_write: "
+ "_create_trace_control_dir failed: %d\n", err);
+ goto err_create_trace_control_dir;
+ }
+
+ ltt_unlock_traces();
+ mutex_unlock(&control_lock);
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trace_name);
+ return count;
+
+err_create_trace_control_dir:
+ ltt_trace_destroy(trace_name);
+err_setup_trace:
+ ltt_unlock_traces();
+ mutex_unlock(&control_lock);
+err_get_tracename:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trace_name);
+ return err;
+}
+
+static const struct file_operations ltt_setup_trace_operations = {
+ .write = setup_trace_write,
+};
+
+static
+ssize_t destroy_trace_write(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ struct dentry *trace_den;
+ int buf_size;
+ int err = 0;
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ char *trace_name = (char *)__get_free_page(GFP_KERNEL);
+
+ buf_size = min_t(size_t, count, PAGE_SIZE - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto err_copy_from_user;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", trace_name) != 1) {
+ err = -EPERM;
+ goto err_get_tracename;
+ }
+
+ mutex_lock(&control_lock);
+
+ err = ltt_trace_destroy(trace_name);
+ if (IS_ERR_VALUE(err)) {
+ printk(KERN_ERR
+ "destroy_trace_write: ltt_trace_destroy failed: %d\n",
+ err);
+ err = -EPERM;
+ goto err_destroy_trace;
+ }
+
+ trace_den = dir_lookup(ltt_control_dir, trace_name);
+ if (!trace_den) {
+ printk(KERN_ERR
+ "destroy_trace_write: lookup for %s's dentry failed\n",
+ trace_name);
+ err = -ENOENT;
+ goto err_get_dentry;
+ }
+
+ debugfs_remove_recursive(trace_den);
+
+ mutex_unlock(&control_lock);
+
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trace_name);
+ return count;
+
+err_get_dentry:
+err_destroy_trace:
+ mutex_unlock(&control_lock);
+err_get_tracename:
+err_copy_from_user:
+ free_page((unsigned long)buf);
+ free_page((unsigned long)trace_name);
+ return err;
+}
+
+static const struct file_operations ltt_destroy_trace_operations = {
+ .write = destroy_trace_write,
+};
+
+static void init_marker_dir(struct dentry *dentry,
+ const struct inode_operations *opt)
+{
+ dentry->d_inode->i_op = opt;
+}
+
+static
+ssize_t marker_enable_read(struct file *filp, char __user *ubuf,
+ size_t cnt, loff_t *ppos)
+{
+ char *buf;
+ const char *channel, *marker;
+ int len, enabled, present;
+
+ marker = filp->f_dentry->d_parent->d_name.name;
+ channel = filp->f_dentry->d_parent->d_parent->d_name.name;
+
+ len = 0;
+ buf = (char *)__get_free_page(GFP_KERNEL);
+
+ /*
+ * Note: we cannot take the marker lock to make these two checks
+ * atomic, because the marker mutex nests inside the module mutex, taken
+ * inside the marker present check.
+ */
+ enabled = is_marker_enabled(channel, marker);
+ present = is_marker_present(channel, marker);
+
+ if (enabled && present)
+ len = snprintf(buf, PAGE_SIZE, "%d\n", 1);
+ else if (enabled && !present)
+ len = snprintf(buf, PAGE_SIZE, "%d\n", 2);
+ else
+ len = snprintf(buf, PAGE_SIZE, "%d\n", 0);
+
+
+ if (len >= PAGE_SIZE) {
+ len = PAGE_SIZE;
+ buf[PAGE_SIZE] = '\0';
+ }
+ len = simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
+ free_page((unsigned long)buf);
+
+ return len;
+}
+
+static
+ssize_t marker_enable_write(struct file *filp, const char __user *ubuf,
+ size_t cnt, loff_t *ppos)
+{
+ char *buf = (char *)__get_free_page(GFP_KERNEL);
+ int buf_size;
+ ssize_t ret = 0;
+ const char *channel, *marker;
+
+ marker = filp->f_dentry->d_parent->d_name.name;
+ channel = filp->f_dentry->d_parent->d_parent->d_name.name;
+
+ buf_size = min_t(size_t, cnt, PAGE_SIZE - 1);
+ ret = copy_from_user(buf, ubuf, buf_size);
+ if (ret)
+ goto end;
+
+ buf[buf_size] = 0;
+
+ switch (buf[0]) {
+ case 'Y':
+ case 'y':
+ case '1':
+ ret = ltt_marker_connect(channel, marker, "default");
+ if (ret)
+ goto end;
+ break;
+ case 'N':
+ case 'n':
+ case '0':
+ ret = ltt_marker_disconnect(channel, marker, "default");
+ if (ret)
+ goto end;
+ break;
+ default:
+ ret = -EPERM;
+ goto end;
+ }
+ ret = cnt;
+end:
+ free_page((unsigned long)buf);
+ return ret;
+}
+
+static const struct file_operations enable_fops = {
+ .read = marker_enable_read,
+ .write = marker_enable_write,
+};
+
+/*
+ * In practice, the output size should never be larger than 4096 kB. If it
+ * ever happens, the output will simply be truncated.
+ */
+static
+ssize_t marker_info_read(struct file *filp, char __user *ubuf,
+ size_t cnt, loff_t *ppos)
+{
+ char *buf;
+ const char *channel, *marker;
+ int len;
+ struct marker_iter iter;
+
+ marker = filp->f_dentry->d_parent->d_name.name;
+ channel = filp->f_dentry->d_parent->d_parent->d_name.name;
+
+ len = 0;
+ buf = (char *)__get_free_page(GFP_KERNEL);
+
+ if (is_marker_enabled(channel, marker) &&
+ !is_marker_present(channel, marker)) {
+ len += snprintf(buf + len, PAGE_SIZE - len,
+ "Marker Pre-enabled\n");
+ goto out;
+ }
+
+ marker_iter_reset(&iter);
+ marker_iter_start(&iter);
+ for (; iter.marker != NULL; marker_iter_next(&iter)) {
+ if (!strcmp(iter.marker->channel, channel) &&
+ !strcmp(iter.marker->name, marker))
+ len += snprintf(buf + len, PAGE_SIZE - len,
+ "Location: %s\n"
+ "format: \"%s\"\nstate: %d\n"
+ "event_id: %hu\n"
+ "call: 0x%p\n"
+ "probe %s : 0x%p\n\n",
+#ifdef CONFIG_MODULES
+ iter.module ? iter.module->name :
+#endif
+ "Core Kernel",
+ iter.marker->format,
+ _imv_read(iter.marker->state),
+ iter.marker->event_id,
+ iter.marker->call,
+ iter.marker->ptype ?
+ "multi" : "single", iter.marker->ptype ?
+ (void *)iter.marker->multi :
+ (void *)iter.marker->single.func);
+ if (len >= PAGE_SIZE)
+ break;
+ }
+ marker_iter_stop(&iter);
+
+out:
+ if (len >= PAGE_SIZE) {
+ len = PAGE_SIZE;
+ buf[PAGE_SIZE] = '\0';
+ }
+
+ len = simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
+ free_page((unsigned long)buf);
+
+ return len;
+}
+
+static const struct file_operations info_fops = {
+ .read = marker_info_read,
+};
+
+static int marker_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+{
+ struct dentry *marker_d, *enable_d, *info_d, *channel_d;
+ int ret;
+
+ ret = 0;
+ channel_d = (struct dentry *)dir->i_private;
+ mutex_unlock(&dir->i_mutex);
+
+ marker_d = debugfs_create_dir(dentry->d_name.name,
+ channel_d);
+ if (IS_ERR(marker_d)) {
+ ret = PTR_ERR(marker_d);
+ goto out;
+ }
+
+ enable_d = debugfs_create_file("enable", 0644, marker_d,
+ NULL, &enable_fops);
+ if (IS_ERR(enable_d) || !enable_d) {
+ printk(KERN_ERR
+ "%s: create file of %s failed\n",
+ __func__, "enable");
+ ret = -ENOMEM;
+ goto remove_marker_dir;
+ }
+
+ info_d = debugfs_create_file("info", 0644, marker_d,
+ NULL, &info_fops);
+ if (IS_ERR(info_d) || !info_d) {
+ printk(KERN_ERR
+ "%s: create file of %s failed\n",
+ __func__, "info");
+ ret = -ENOMEM;
+ goto remove_enable_dir;
+ }
+
+ goto out;
+
+remove_enable_dir:
+ debugfs_remove(enable_d);
+remove_marker_dir:
+ debugfs_remove(marker_d);
+out:
+ mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+ return ret;
+}
+
+static int marker_rmdir(struct inode *dir, struct dentry *dentry)
+{
+ struct dentry *marker_d, *channel_d;
+ const char *channel, *name;
+ int ret, enabled, present;
+
+ ret = 0;
+
+ channel_d = (struct dentry *)dir->i_private;
+ channel = channel_d->d_name.name;
+
+ marker_d = dir_lookup(channel_d, dentry->d_name.name);
+
+ if (!marker_d) {
+ ret = -ENOENT;
+ goto out;
+ }
+
+ name = marker_d->d_name.name;
+
+ enabled = is_marker_enabled(channel, name);
+ present = is_marker_present(channel, name);
+
+ if (present || (!present && enabled)) {
+ ret = -EPERM;
+ goto out;
+ }
+
+ mutex_unlock(&dir->i_mutex);
+ mutex_unlock(&dentry->d_inode->i_mutex);
+ debugfs_remove_recursive(marker_d);
+ mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+ mutex_lock(&dentry->d_inode->i_mutex);
+out:
+ return ret;
+}
+
+const struct inode_operations channel_dir_opt = {
+ .lookup = simple_lookup,
+ .mkdir = marker_mkdir,
+ .rmdir = marker_rmdir,
+};
+
+static int channel_mkdir(struct inode *dir, struct dentry *dentry, int mode)
+{
+ struct dentry *channel_d;
+ int ret;
+
+ ret = 0;
+ mutex_unlock(&dir->i_mutex);
+
+ channel_d = debugfs_create_dir(dentry->d_name.name,
+ markers_control_dir);
+ if (IS_ERR(channel_d)) {
+ ret = PTR_ERR(channel_d);
+ goto out;
+ }
+
+ channel_d->d_inode->i_private = (void *)channel_d;
+ init_marker_dir(channel_d, &channel_dir_opt);
+out:
+ mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+ return ret;
+}
+
+static int channel_rmdir(struct inode *dir, struct dentry *dentry)
+{
+ struct dentry *channel_d;
+ int ret;
+
+ ret = 0;
+
+ channel_d = dir_lookup(markers_control_dir, dentry->d_name.name);
+ if (!channel_d) {
+ ret = -ENOENT;
+ goto out;
+ }
+
+ if (list_empty(&channel_d->d_subdirs)) {
+ mutex_unlock(&dir->i_mutex);
+ mutex_unlock(&dentry->d_inode->i_mutex);
+ debugfs_remove(channel_d);
+ mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
+ mutex_lock(&dentry->d_inode->i_mutex);
+ } else
+ ret = -EPERM;
+
+out:
+ return ret;
+}
+
+const struct inode_operations root_dir_opt = {
+ .lookup = simple_lookup,
+ .mkdir = channel_mkdir,
+ .rmdir = channel_rmdir
+};
+
+static int build_marker_file(struct marker *marker)
+{
+ struct dentry *channel_d, *marker_d, *enable_d, *info_d;
+ int err;
+
+ channel_d = dir_lookup(markers_control_dir, marker->channel);
+ if (!channel_d) {
+ channel_d = debugfs_create_dir(marker->channel,
+ markers_control_dir);
+ if (IS_ERR(channel_d) || !channel_d) {
+ printk(KERN_ERR
+ "%s: build channel dir of %s failed\n",
+ __func__, marker->channel);
+ err = -ENOMEM;
+ goto err_build_fail;
+ }
+ channel_d->d_inode->i_private = (void *)channel_d;
+ init_marker_dir(channel_d, &channel_dir_opt);
+ }
+
+ marker_d = dir_lookup(channel_d, marker->name);
+ if (!marker_d) {
+ marker_d = debugfs_create_dir(marker->name, channel_d);
+ if (IS_ERR(marker_d) || !marker_d) {
+ printk(KERN_ERR
+ "%s: marker dir of %s failed\n",
+ __func__, marker->name);
+ err = -ENOMEM;
+ goto err_build_fail;
+ }
+ }
+
+ enable_d = dir_lookup(marker_d, "enable");
+ if (!enable_d) {
+ enable_d = debugfs_create_file("enable", 0644, marker_d,
+ NULL, &enable_fops);
+ if (IS_ERR(enable_d) || !enable_d) {
+ printk(KERN_ERR
+ "%s: create file of %s failed\n",
+ __func__, "enable");
+ err = -ENOMEM;
+ goto err_build_fail;
+ }
+ }
+
+ info_d = dir_lookup(marker_d, "info");
+ if (!info_d) {
+ info_d = debugfs_create_file("info", 0444, marker_d,
+ NULL, &info_fops);
+ if (IS_ERR(info_d) || !info_d) {
+ printk(KERN_ERR
+ "%s: create file of %s failed\n",
+ __func__, "enable");
+ err = -ENOMEM;
+ goto err_build_fail;
+ }
+ }
+
+ return 0;
+
+err_build_fail:
+ return err;
+}
+
+static int build_marker_control_files(void)
+{
+ struct marker_iter iter;
+ int err;
+
+ err = 0;
+ if (!markers_control_dir)
+ return -EEXIST;
+
+ marker_iter_reset(&iter);
+ marker_iter_start(&iter);
+ for (; iter.marker != NULL; marker_iter_next(&iter)) {
+ err = build_marker_file(iter.marker);
+ if (err)
+ goto out;
+ }
+ marker_iter_stop(&iter);
+
+out:
+ return err;
+}
+
+#ifdef CONFIG_MODULES
+static int remove_marker_control_dir(struct module *mod, struct marker *marker)
+{
+ struct dentry *channel_d, *marker_d;
+ const char *channel, *name;
+ int count;
+ struct marker_iter iter;
+
+ count = 0;
+
+ channel_d = dir_lookup(markers_control_dir, marker->channel);
+ if (!channel_d)
+ return -ENOENT;
+ channel = channel_d->d_name.name;
+
+ marker_d = dir_lookup(channel_d, marker->name);
+ if (!marker_d)
+ return -ENOENT;
+ name = marker_d->d_name.name;
+
+ marker_iter_reset(&iter);
+ marker_iter_start(&iter);
+ for (; iter.marker != NULL; marker_iter_next(&iter)) {
+ if (!strcmp(iter.marker->channel, channel) &&
+ !strcmp(iter.marker->name, name) && mod != iter.module)
+ count++;
+ }
+
+ if (count > 0)
+ goto end;
+
+ debugfs_remove_recursive(marker_d);
+ if (list_empty(&channel_d->d_subdirs))
+ debugfs_remove(channel_d);
+
+end:
+ marker_iter_stop(&iter);
+ return 0;
+}
+
+static void cleanup_control_dir(struct module *mod, struct marker *begin,
+ struct marker *end)
+{
+ struct marker *iter;
+
+ if (!markers_control_dir)
+ return;
+
+ for (iter = begin; iter < end; iter++)
+ remove_marker_control_dir(mod, iter);
+
+ return;
+}
+
+static void build_control_dir(struct module *mod, struct marker *begin,
+ struct marker *end)
+{
+ struct marker *iter;
+ int err;
+
+ err = 0;
+ if (!markers_control_dir)
+ return;
+
+ for (iter = begin; iter < end; iter++) {
+ err = build_marker_file(iter);
+ if (err)
+ goto err_build_fail;
+ }
+
+ return;
+err_build_fail:
+ cleanup_control_dir(mod, begin, end);
+}
+
+static int module_notify(struct notifier_block *self,
+ unsigned long val, void *data)
+{
+ struct module *mod = data;
+
+ switch (val) {
+ case MODULE_STATE_COMING:
+ build_control_dir(mod, mod->markers,
+ mod->markers + mod->num_markers);
+ break;
+ case MODULE_STATE_GOING:
+ cleanup_control_dir(mod, mod->markers,
+ mod->markers + mod->num_markers);
+ break;
+ }
+ return NOTIFY_DONE;
+}
+#else
+static inline int module_notify(struct notifier_block *self,
+ unsigned long val, void *data)
+{
+ return 0;
+}
+#endif
+
+static struct notifier_block module_nb = {
+ .notifier_call = module_notify,
+};
+
+static int __init ltt_trace_control_init(void)
+{
+ int err = 0;
+ struct dentry *ltt_root_dentry;
+
+ ltt_root_dentry = get_ltt_root();
+ if (!ltt_root_dentry) {
+ err = -ENOENT;
+ goto err_no_root;
+ }
+
+ ltt_control_dir = debugfs_create_dir(LTT_CONTROL_DIR, ltt_root_dentry);
+ if (IS_ERR(ltt_control_dir) || !ltt_control_dir) {
+ printk(KERN_ERR
+ "ltt_channel_control_init: create dir of %s failed\n",
+ LTT_CONTROL_DIR);
+ err = -ENOMEM;
+ goto err_create_control_dir;
+ }
+
+ ltt_setup_trace_file = debugfs_create_file(LTT_SETUP_TRACE_FILE,
+ S_IWUSR, ltt_root_dentry,
+ NULL,
+ <t_setup_trace_operations);
+ if (IS_ERR(ltt_setup_trace_file) || !ltt_setup_trace_file) {
+ printk(KERN_ERR
+ "ltt_channel_control_init: create file of %s failed\n",
+ LTT_SETUP_TRACE_FILE);
+ err = -ENOMEM;
+ goto err_create_setup_trace_file;
+ }
+
+ ltt_destroy_trace_file = debugfs_create_file(LTT_DESTROY_TRACE_FILE,
+ S_IWUSR, ltt_root_dentry,
+ NULL,
+ <t_destroy_trace_operations);
+ if (IS_ERR(ltt_destroy_trace_file) || !ltt_destroy_trace_file) {
+ printk(KERN_ERR
+ "ltt_channel_control_init: create file of %s failed\n",
+ LTT_DESTROY_TRACE_FILE);
+ err = -ENOMEM;
+ goto err_create_destroy_trace_file;
+ }
+
+ markers_control_dir = debugfs_create_dir(MARKERS_CONTROL_DIR,
+ ltt_root_dentry);
+ if (IS_ERR(markers_control_dir) || !markers_control_dir) {
+ printk(KERN_ERR
+ "ltt_channel_control_init: create dir of %s failed\n",
+ MARKERS_CONTROL_DIR);
+ err = -ENOMEM;
+ goto err_create_marker_control_dir;
+ }
+
+ init_marker_dir(markers_control_dir, &root_dir_opt);
+
+ if (build_marker_control_files())
+ goto err_build_fail;
+
+ if (!register_module_notifier(&module_nb))
+ return 0;
+
+err_build_fail:
+ debugfs_remove_recursive(markers_control_dir);
+ markers_control_dir = NULL;
+err_create_marker_control_dir:
+ debugfs_remove(ltt_destroy_trace_file);
+err_create_destroy_trace_file:
+ debugfs_remove(ltt_setup_trace_file);
+err_create_setup_trace_file:
+ debugfs_remove(ltt_control_dir);
+err_create_control_dir:
+err_no_root:
+ return err;
+}
+
+static void __exit ltt_trace_control_exit(void)
+{
+ struct dentry *trace_dir;
+
+ /* destory all traces */
+ list_for_each_entry(trace_dir, <t_control_dir->d_subdirs,
+ d_u.d_child) {
+ ltt_trace_stop(trace_dir->d_name.name);
+ ltt_trace_destroy(trace_dir->d_name.name);
+ }
+
+ /* clean dirs in debugfs */
+ debugfs_remove(ltt_setup_trace_file);
+ debugfs_remove(ltt_destroy_trace_file);
+ debugfs_remove_recursive(ltt_control_dir);
+ debugfs_remove_recursive(markers_control_dir);
+ unregister_module_notifier(&module_nb);
+ put_ltt_root();
+}
+
+module_init(ltt_trace_control_init);
+module_exit(ltt_trace_control_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Zhao Lei <zhaolei@cn.fujitsu.com>");
+MODULE_DESCRIPTION("Linux Trace Toolkit Trace Controller");
--- /dev/null
+/*
+ * ltt/ltt-tracer.c
+ *
+ * Copyright (c) 2005-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * Tracing management internal kernel API. Trace buffer allocation/free, tracing
+ * start/stop.
+ *
+ * Author:
+ * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ *
+ * Inspired from LTT :
+ * Karim Yaghmour (karim@opersys.com)
+ * Tom Zanussi (zanussi@us.ibm.com)
+ * Bob Wisniewski (bob@watson.ibm.com)
+ * And from K42 :
+ * Bob Wisniewski (bob@watson.ibm.com)
+ *
+ * Changelog:
+ * 22/09/06, Move to the marker/probes mechanism.
+ * 19/10/05, Complete lockless mechanism.
+ * 27/05/05, Modular redesign and rewrite.
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/time.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/rcupdate.h>
+#include <linux/sched.h>
+#include <linux/bitops.h>
+#include <linux/fs.h>
+#include <linux/cpu.h>
+#include <linux/kref.h>
+#include <linux/delay.h>
+#include <linux/vmalloc.h>
+#include <asm/atomic.h>
+
+#include "ltt-tracer.h"
+
+static void synchronize_trace(void)
+{
+ synchronize_sched();
+#ifdef CONFIG_PREEMPT_RT
+ synchronize_rcu();
+#endif
+}
+
+static void async_wakeup(unsigned long data);
+
+static DEFINE_TIMER(ltt_async_wakeup_timer, async_wakeup, 0, 0);
+
+/* Default callbacks for modules */
+notrace
+int ltt_filter_control_default(enum ltt_filter_control_msg msg,
+ struct ltt_trace *trace)
+{
+ return 0;
+}
+
+int ltt_statedump_default(struct ltt_trace *trace)
+{
+ return 0;
+}
+
+/* Callbacks for registered modules */
+
+int (*ltt_filter_control_functor)
+ (enum ltt_filter_control_msg msg, struct ltt_trace *trace) =
+ ltt_filter_control_default;
+struct module *ltt_filter_control_owner;
+
+/* These function pointers are protected by a trace activation check */
+struct module *ltt_run_filter_owner;
+int (*ltt_statedump_functor)(struct ltt_trace *trace) = ltt_statedump_default;
+struct module *ltt_statedump_owner;
+
+struct chan_info_struct {
+ const char *name;
+ unsigned int def_sb_size;
+ unsigned int def_n_sb;
+} chan_infos[] = {
+ [LTT_CHANNEL_METADATA] = {
+ LTT_METADATA_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_FD_STATE] = {
+ LTT_FD_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_GLOBAL_STATE] = {
+ LTT_GLOBAL_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_IRQ_STATE] = {
+ LTT_IRQ_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_MODULE_STATE] = {
+ LTT_MODULE_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_NETIF_STATE] = {
+ LTT_NETIF_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_SOFTIRQ_STATE] = {
+ LTT_SOFTIRQ_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_SWAP_STATE] = {
+ LTT_SWAP_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_SYSCALL_STATE] = {
+ LTT_SYSCALL_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_TASK_STATE] = {
+ LTT_TASK_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_VM_STATE] = {
+ LTT_VM_STATE_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_MED,
+ LTT_DEFAULT_N_SUBBUFS_MED,
+ },
+ [LTT_CHANNEL_FS] = {
+ LTT_FS_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_MED,
+ LTT_DEFAULT_N_SUBBUFS_MED,
+ },
+ [LTT_CHANNEL_INPUT] = {
+ LTT_INPUT_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_IPC] = {
+ LTT_IPC_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_LOW,
+ LTT_DEFAULT_N_SUBBUFS_LOW,
+ },
+ [LTT_CHANNEL_KERNEL] = {
+ LTT_KERNEL_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_HIGH,
+ LTT_DEFAULT_N_SUBBUFS_HIGH,
+ },
+ [LTT_CHANNEL_MM] = {
+ LTT_MM_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_MED,
+ LTT_DEFAULT_N_SUBBUFS_MED,
+ },
+ [LTT_CHANNEL_RCU] = {
+ LTT_RCU_CHANNEL,
+ LTT_DEFAULT_SUBBUF_SIZE_MED,
+ LTT_DEFAULT_N_SUBBUFS_MED,
+ },
+ [LTT_CHANNEL_DEFAULT] = {
+ NULL,
+ LTT_DEFAULT_SUBBUF_SIZE_MED,
+ LTT_DEFAULT_N_SUBBUFS_MED,
+ },
+};
+
+static enum ltt_channels get_channel_type_from_name(const char *name)
+{
+ int i;
+
+ if (!name)
+ return LTT_CHANNEL_DEFAULT;
+
+ for (i = 0; i < ARRAY_SIZE(chan_infos); i++)
+ if (chan_infos[i].name && !strcmp(name, chan_infos[i].name))
+ return (enum ltt_channels)i;
+
+ return LTT_CHANNEL_DEFAULT;
+}
+
+/**
+ * ltt_module_register - LTT module registration
+ * @name: module type
+ * @function: callback to register
+ * @owner: module which owns the callback
+ *
+ * The module calling this registration function must ensure that no
+ * trap-inducing code will be executed by "function". E.g. vmalloc_sync_all()
+ * must be called between a vmalloc and the moment the memory is made visible to
+ * "function". This registration acts as a vmalloc_sync_all. Therefore, only if
+ * the module allocates virtual memory after its registration must it
+ * synchronize the TLBs.
+ */
+int ltt_module_register(enum ltt_module_function name, void *function,
+ struct module *owner)
+{
+ int ret = 0;
+
+ /*
+ * Make sure no page fault can be triggered by the module about to be
+ * registered. We deal with this here so we don't have to call
+ * vmalloc_sync_all() in each module's init.
+ */
+ vmalloc_sync_all();
+
+ switch (name) {
+ case LTT_FUNCTION_RUN_FILTER:
+ if (ltt_run_filter_owner != NULL) {
+ ret = -EEXIST;
+ goto end;
+ }
+ ltt_filter_register((ltt_run_filter_functor)function);
+ ltt_run_filter_owner = owner;
+ break;
+ case LTT_FUNCTION_FILTER_CONTROL:
+ if (ltt_filter_control_owner != NULL) {
+ ret = -EEXIST;
+ goto end;
+ }
+ ltt_filter_control_functor =
+ (int (*)(enum ltt_filter_control_msg,
+ struct ltt_trace *))function;
+ ltt_filter_control_owner = owner;
+ break;
+ case LTT_FUNCTION_STATEDUMP:
+ if (ltt_statedump_owner != NULL) {
+ ret = -EEXIST;
+ goto end;
+ }
+ ltt_statedump_functor =
+ (int (*)(struct ltt_trace *))function;
+ ltt_statedump_owner = owner;
+ break;
+ }
+end:
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_module_register);
+
+/**
+ * ltt_module_unregister - LTT module unregistration
+ * @name: module type
+ */
+void ltt_module_unregister(enum ltt_module_function name)
+{
+ switch (name) {
+ case LTT_FUNCTION_RUN_FILTER:
+ ltt_filter_unregister();
+ ltt_run_filter_owner = NULL;
+ /* Wait for preempt sections to finish */
+ synchronize_trace();
+ break;
+ case LTT_FUNCTION_FILTER_CONTROL:
+ ltt_filter_control_functor = ltt_filter_control_default;
+ ltt_filter_control_owner = NULL;
+ break;
+ case LTT_FUNCTION_STATEDUMP:
+ ltt_statedump_functor = ltt_statedump_default;
+ ltt_statedump_owner = NULL;
+ break;
+ }
+
+}
+EXPORT_SYMBOL_GPL(ltt_module_unregister);
+
+static LIST_HEAD(ltt_transport_list);
+
+/**
+ * ltt_transport_register - LTT transport registration
+ * @transport: transport structure
+ *
+ * Registers a transport which can be used as output to extract the data out of
+ * LTTng. The module calling this registration function must ensure that no
+ * trap-inducing code will be executed by the transport functions. E.g.
+ * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
+ * is made visible to the transport function. This registration acts as a
+ * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
+ * after its registration must it synchronize the TLBs.
+ */
+void ltt_transport_register(struct ltt_transport *transport)
+{
+ /*
+ * Make sure no page fault can be triggered by the module about to be
+ * registered. We deal with this here so we don't have to call
+ * vmalloc_sync_all() in each module's init.
+ */
+ vmalloc_sync_all();
+
+ ltt_lock_traces();
+ list_add_tail(&transport->node, <t_transport_list);
+ ltt_unlock_traces();
+}
+EXPORT_SYMBOL_GPL(ltt_transport_register);
+
+/**
+ * ltt_transport_unregister - LTT transport unregistration
+ * @transport: transport structure
+ */
+void ltt_transport_unregister(struct ltt_transport *transport)
+{
+ ltt_lock_traces();
+ list_del(&transport->node);
+ ltt_unlock_traces();
+}
+EXPORT_SYMBOL_GPL(ltt_transport_unregister);
+
+static inline
+int is_channel_overwrite(enum ltt_channels chan, enum trace_mode mode)
+{
+ switch (mode) {
+ case LTT_TRACE_NORMAL:
+ return 0;
+ case LTT_TRACE_FLIGHT:
+ switch (chan) {
+ case LTT_CHANNEL_METADATA:
+ return 0;
+ default:
+ return 1;
+ }
+ case LTT_TRACE_HYBRID:
+ switch (chan) {
+ case LTT_CHANNEL_KERNEL:
+ case LTT_CHANNEL_FS:
+ case LTT_CHANNEL_MM:
+ case LTT_CHANNEL_RCU:
+ case LTT_CHANNEL_IPC:
+ case LTT_CHANNEL_INPUT:
+ return 1;
+ default:
+ return 0;
+ }
+ default:
+ return 0;
+ }
+}
+
+/**
+ * _ltt_trace_find - find a trace by given name.
+ * trace_name: trace name
+ *
+ * Returns a pointer to the trace structure, NULL if not found.
+ */
+static struct ltt_trace *_ltt_trace_find(const char *trace_name)
+{
+ struct ltt_trace *trace;
+
+ list_for_each_entry(trace, <t_traces.head, list)
+ if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
+ return trace;
+
+ return NULL;
+}
+
+/* _ltt_trace_find_setup :
+ * find a trace in setup list by given name.
+ *
+ * Returns a pointer to the trace structure, NULL if not found.
+ */
+struct ltt_trace *_ltt_trace_find_setup(const char *trace_name)
+{
+ struct ltt_trace *trace;
+
+ list_for_each_entry(trace, <t_traces.setup_head, list)
+ if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
+ return trace;
+
+ return NULL;
+}
+EXPORT_SYMBOL_GPL(_ltt_trace_find_setup);
+
+/**
+ * ltt_release_trace - Release a LTT trace
+ * @kref : reference count on the trace
+ */
+void ltt_release_trace(struct kref *kref)
+{
+ struct ltt_trace *trace = container_of(kref, struct ltt_trace, kref);
+
+ trace->ops->remove_dirs(trace);
+ module_put(trace->transport->owner);
+ ltt_channels_trace_free(trace);
+ kfree(trace);
+}
+EXPORT_SYMBOL_GPL(ltt_release_trace);
+
+static inline void prepare_chan_size_num(unsigned int *subbuf_size,
+ unsigned int *n_subbufs)
+{
+ /* Make sure the subbuffer size is larger than a page */
+ *subbuf_size = max_t(unsigned int, *subbuf_size, PAGE_SIZE);
+
+ /* round to next power of 2 */
+ *subbuf_size = 1 << get_count_order(*subbuf_size);
+ *n_subbufs = 1 << get_count_order(*n_subbufs);
+
+ /* Subbuf size and number must both be power of two */
+ WARN_ON(hweight32(*subbuf_size) != 1);
+ WARN_ON(hweight32(*n_subbufs) != 1);
+}
+
+int _ltt_trace_setup(const char *trace_name)
+{
+ int err = 0;
+ struct ltt_trace *new_trace = NULL;
+ int metadata_index;
+ unsigned int chan;
+ enum ltt_channels chantype;
+
+ if (_ltt_trace_find_setup(trace_name)) {
+ printk(KERN_ERR "LTT : Trace name %s already used.\n",
+ trace_name);
+ err = -EEXIST;
+ goto traces_error;
+ }
+
+ if (_ltt_trace_find(trace_name)) {
+ printk(KERN_ERR "LTT : Trace name %s already used.\n",
+ trace_name);
+ err = -EEXIST;
+ goto traces_error;
+ }
+
+ new_trace = kzalloc(sizeof(struct ltt_trace), GFP_KERNEL);
+ if (!new_trace) {
+ printk(KERN_ERR
+ "LTT : Unable to allocate memory for trace %s\n",
+ trace_name);
+ err = -ENOMEM;
+ goto traces_error;
+ }
+ strncpy(new_trace->trace_name, trace_name, NAME_MAX);
+ if (ltt_channels_trace_alloc(&new_trace->nr_channels, 0)) {
+ printk(KERN_ERR
+ "LTT : Unable to allocate memory for chaninfo %s\n",
+ trace_name);
+ err = -ENOMEM;
+ goto trace_free;
+ }
+
+ /*
+ * Force metadata channel to no overwrite.
+ */
+ metadata_index = ltt_channels_get_index_from_name("metadata");
+ WARN_ON(metadata_index < 0);
+ new_trace->settings[metadata_index].overwrite = 0;
+
+ /*
+ * Set hardcoded tracer defaults for some channels
+ */
+ for (chan = 0; chan < new_trace->nr_channels; chan++) {
+ chantype = get_channel_type_from_name(
+ ltt_channels_get_name_from_index(chan));
+ new_trace->settings[chan].sb_size =
+ chan_infos[chantype].def_sb_size;
+ new_trace->settings[chan].n_sb =
+ chan_infos[chantype].def_n_sb;
+ }
+
+ list_add(&new_trace->list, <t_traces.setup_head);
+ return 0;
+
+trace_free:
+ kfree(new_trace);
+traces_error:
+ return err;
+}
+EXPORT_SYMBOL_GPL(_ltt_trace_setup);
+
+
+int ltt_trace_setup(const char *trace_name)
+{
+ int ret;
+ ltt_lock_traces();
+ ret = _ltt_trace_setup(trace_name);
+ ltt_unlock_traces();
+ return ret;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_setup);
+
+/* must be called from within a traces lock. */
+static void _ltt_trace_free(struct ltt_trace *trace)
+{
+ list_del(&trace->list);
+ kfree(trace);
+}
+
+int ltt_trace_set_type(const char *trace_name, const char *trace_type)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ struct ltt_transport *tran_iter, *transport = NULL;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ list_for_each_entry(tran_iter, <t_transport_list, node) {
+ if (!strcmp(tran_iter->name, trace_type)) {
+ transport = tran_iter;
+ break;
+ }
+ }
+ if (!transport) {
+ printk(KERN_ERR "LTT : Transport %s is not present.\n",
+ trace_type);
+ err = -EINVAL;
+ goto traces_error;
+ }
+
+ trace->transport = transport;
+
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_set_type);
+
+int ltt_trace_set_channel_subbufsize(const char *trace_name,
+ const char *channel_name,
+ unsigned int size)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ int index;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ index = ltt_channels_get_index_from_name(channel_name);
+ if (index < 0) {
+ printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+ trace->settings[index].sb_size = size;
+
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufsize);
+
+int ltt_trace_set_channel_subbufcount(const char *trace_name,
+ const char *channel_name,
+ unsigned int cnt)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ int index;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ index = ltt_channels_get_index_from_name(channel_name);
+ if (index < 0) {
+ printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+ trace->settings[index].n_sb = cnt;
+
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufcount);
+
+int ltt_trace_set_channel_switch_timer(const char *trace_name,
+ const char *channel_name,
+ unsigned long interval)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ int index;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ index = ltt_channels_get_index_from_name(channel_name);
+ if (index < 0) {
+ printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+ ltt_channels_trace_set_timer(&trace->settings[index], interval);
+
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_set_channel_switch_timer);
+
+int ltt_trace_set_channel_overwrite(const char *trace_name,
+ const char *channel_name,
+ unsigned int overwrite)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ int index;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ /*
+ * Always put the metadata channel in non-overwrite mode :
+ * This is a very low traffic channel and it can't afford to have its
+ * data overwritten : this data (marker info) is necessary to be
+ * able to read the trace.
+ */
+ if (overwrite && !strcmp(channel_name, "metadata")) {
+ printk(KERN_ERR "LTT : Trying to set metadata channel to "
+ "overwrite mode\n");
+ err = -EINVAL;
+ goto traces_error;
+ }
+
+ index = ltt_channels_get_index_from_name(channel_name);
+ if (index < 0) {
+ printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ trace->settings[index].overwrite = overwrite;
+
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_set_channel_overwrite);
+
+int ltt_trace_alloc(const char *trace_name)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+ int sb_size, n_sb;
+ unsigned long flags;
+ int chan;
+ const char *channel_name;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (!trace) {
+ printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
+ err = -ENOENT;
+ goto traces_error;
+ }
+
+ kref_init(&trace->kref);
+ init_waitqueue_head(&trace->kref_wq);
+ trace->active = 0;
+ get_trace_clock();
+ trace->freq_scale = trace_clock_freq_scale();
+
+ if (!trace->transport) {
+ printk(KERN_ERR "LTT : Transport is not set.\n");
+ err = -EINVAL;
+ goto transport_error;
+ }
+ if (!try_module_get(trace->transport->owner)) {
+ printk(KERN_ERR "LTT : Can't lock transport module.\n");
+ err = -ENODEV;
+ goto transport_error;
+ }
+ trace->ops = &trace->transport->ops;
+
+ err = trace->ops->create_dirs(trace);
+ if (err) {
+ printk(KERN_ERR "LTT : Can't create dir for trace %s.\n",
+ trace_name);
+ goto dirs_error;
+ }
+
+ local_irq_save(flags);
+ trace->start_freq = trace_clock_frequency();
+ trace->start_tsc = trace_clock_read64();
+ do_gettimeofday(&trace->start_time);
+ local_irq_restore(flags);
+
+ for (chan = 0; chan < trace->nr_channels; chan++) {
+ channel_name = ltt_channels_get_name_from_index(chan);
+ WARN_ON(!channel_name);
+ /*
+ * note: sb_size and n_sb will be overwritten with updated
+ * values by channel creation.
+ */
+ sb_size = trace->settings[chan].sb_size;
+ n_sb = trace->settings[chan].n_sb;
+ prepare_chan_size_num(&sb_size, &n_sb);
+ trace->channels[chan] = ltt_create_channel(channel_name,
+ trace, NULL, sb_size, n_sb,
+ trace->settings[chan].overwrite,
+ trace->settings[chan].switch_timer_interval,
+ trace->settings[chan].read_timer_interval);
+ if (err != 0) {
+ printk(KERN_ERR "LTT : Can't create channel %s.\n",
+ channel_name);
+ goto create_channel_error;
+ }
+ }
+
+ list_del(&trace->list);
+ if (list_empty(<t_traces.head))
+ set_kernel_trace_flag_all_tasks();
+ list_add_rcu(&trace->list, <t_traces.head);
+ synchronize_trace();
+
+ ltt_unlock_traces();
+
+ return 0;
+
+create_channel_error:
+ for (chan--; chan >= 0; chan--)
+ ltt_channel_destroy(trace->channels[chan]);
+ trace->ops->remove_dirs(trace);
+
+dirs_error:
+ module_put(trace->transport->owner);
+transport_error:
+ put_trace_clock();
+traces_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_alloc);
+
+/*
+ * It is worked as a wrapper for current version of ltt_control.ko.
+ * We will make a new ltt_control based on debugfs, and control each channel's
+ * buffer.
+ */
+static
+int ltt_trace_create(const char *trace_name, const char *trace_type,
+ enum trace_mode mode,
+ unsigned int subbuf_size_low, unsigned int n_subbufs_low,
+ unsigned int subbuf_size_med, unsigned int n_subbufs_med,
+ unsigned int subbuf_size_high, unsigned int n_subbufs_high)
+{
+ int err = 0;
+
+ err = ltt_trace_setup(trace_name);
+ if (IS_ERR_VALUE(err))
+ return err;
+
+ err = ltt_trace_set_type(trace_name, trace_type);
+ if (IS_ERR_VALUE(err))
+ return err;
+
+ err = ltt_trace_alloc(trace_name);
+ if (IS_ERR_VALUE(err))
+ return err;
+
+ return err;
+}
+
+/* Must be called while sure that trace is in the list. */
+static int _ltt_trace_destroy(struct ltt_trace *trace)
+{
+ int err = -EPERM;
+
+ if (trace == NULL) {
+ err = -ENOENT;
+ goto traces_error;
+ }
+ if (trace->active) {
+ printk(KERN_ERR
+ "LTT : Can't destroy trace %s : tracer is active\n",
+ trace->trace_name);
+ err = -EBUSY;
+ goto active_error;
+ }
+ /* Everything went fine */
+ list_del_rcu(&trace->list);
+ synchronize_trace();
+ if (list_empty(<t_traces.head)) {
+ clear_kernel_trace_flag_all_tasks();
+ }
+ return 0;
+
+ /* error handling */
+active_error:
+traces_error:
+ return err;
+}
+
+/* Sleepable part of the destroy */
+static void __ltt_trace_destroy(struct ltt_trace *trace)
+{
+ int i;
+
+ for (i = 0; i < trace->nr_channels; i++)
+ ltt_channel_destroy(trace->channels[i]);
+ kref_put(&trace->kref, ltt_release_trace);
+}
+
+int ltt_trace_destroy(const char *trace_name)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find(trace_name);
+ if (trace) {
+ err = _ltt_trace_destroy(trace);
+ if (err)
+ goto error;
+
+ __ltt_trace_destroy(trace);
+ ltt_unlock_traces();
+ put_trace_clock();
+
+ return 0;
+ }
+
+ trace = _ltt_trace_find_setup(trace_name);
+ if (trace) {
+ _ltt_trace_free(trace);
+ ltt_unlock_traces();
+ return 0;
+ }
+
+ err = -ENOENT;
+
+ /* Error handling */
+error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_destroy);
+
+/* must be called from within a traces lock. */
+static int _ltt_trace_start(struct ltt_trace *trace)
+{
+ int err = 0;
+
+ if (trace == NULL) {
+ err = -ENOENT;
+ goto traces_error;
+ }
+ if (trace->active)
+ printk(KERN_INFO "LTT : Tracing already active for trace %s\n",
+ trace->trace_name);
+ if (!try_module_get(ltt_run_filter_owner)) {
+ err = -ENODEV;
+ printk(KERN_ERR "LTT : Can't lock filter module.\n");
+ goto get_ltt_run_filter_error;
+ }
+ trace->active = 1;
+ /* Read by trace points without protection : be careful */
+ ltt_traces.num_active_traces++;
+ return err;
+
+ /* error handling */
+get_ltt_run_filter_error:
+traces_error:
+ return err;
+}
+
+int ltt_trace_start(const char *trace_name)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+
+ ltt_lock_traces();
+
+ trace = _ltt_trace_find(trace_name);
+ err = _ltt_trace_start(trace);
+ if (err)
+ goto no_trace;
+
+ ltt_unlock_traces();
+
+ /*
+ * Call the kernel state dump.
+ * Events will be mixed with real kernel events, it's ok.
+ * Notice that there is no protection on the trace : that's exactly
+ * why we iterate on the list and check for trace equality instead of
+ * directly using this trace handle inside the logging function.
+ */
+
+ ltt_dump_marker_state(trace);
+
+ if (!try_module_get(ltt_statedump_owner)) {
+ err = -ENODEV;
+ printk(KERN_ERR
+ "LTT : Can't lock state dump module.\n");
+ } else {
+ ltt_statedump_functor(trace);
+ module_put(ltt_statedump_owner);
+ }
+
+ return err;
+
+ /* Error handling */
+no_trace:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_start);
+
+/* must be called from within traces lock */
+static int _ltt_trace_stop(struct ltt_trace *trace)
+{
+ int err = -EPERM;
+
+ if (trace == NULL) {
+ err = -ENOENT;
+ goto traces_error;
+ }
+ if (!trace->active)
+ printk(KERN_INFO "LTT : Tracing not active for trace %s\n",
+ trace->trace_name);
+ if (trace->active) {
+ trace->active = 0;
+ ltt_traces.num_active_traces--;
+ synchronize_trace(); /* Wait for each tracing to be finished */
+ }
+ module_put(ltt_run_filter_owner);
+ /* Everything went fine */
+ return 0;
+
+ /* Error handling */
+traces_error:
+ return err;
+}
+
+int ltt_trace_stop(const char *trace_name)
+{
+ int err = 0;
+ struct ltt_trace *trace;
+
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+ err = _ltt_trace_stop(trace);
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_trace_stop);
+
+/**
+ * ltt_control - Trace control in-kernel API
+ * @msg: Action to perform
+ * @trace_name: Trace on which the action must be done
+ * @trace_type: Type of trace (normal, flight, hybrid)
+ * @args: Arguments specific to the action
+ */
+int ltt_control(enum ltt_control_msg msg, const char *trace_name,
+ const char *trace_type, union ltt_control_args args)
+{
+ int err = -EPERM;
+
+ printk(KERN_ALERT "ltt_control : trace %s\n", trace_name);
+ switch (msg) {
+ case LTT_CONTROL_START:
+ printk(KERN_DEBUG "Start tracing %s\n", trace_name);
+ err = ltt_trace_start(trace_name);
+ break;
+ case LTT_CONTROL_STOP:
+ printk(KERN_DEBUG "Stop tracing %s\n", trace_name);
+ err = ltt_trace_stop(trace_name);
+ break;
+ case LTT_CONTROL_CREATE_TRACE:
+ printk(KERN_DEBUG "Creating trace %s\n", trace_name);
+ err = ltt_trace_create(trace_name, trace_type,
+ args.new_trace.mode,
+ args.new_trace.subbuf_size_low,
+ args.new_trace.n_subbufs_low,
+ args.new_trace.subbuf_size_med,
+ args.new_trace.n_subbufs_med,
+ args.new_trace.subbuf_size_high,
+ args.new_trace.n_subbufs_high);
+ break;
+ case LTT_CONTROL_DESTROY_TRACE:
+ printk(KERN_DEBUG "Destroying trace %s\n", trace_name);
+ err = ltt_trace_destroy(trace_name);
+ break;
+ }
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_control);
+
+/**
+ * ltt_filter_control - Trace filter control in-kernel API
+ * @msg: Action to perform on the filter
+ * @trace_name: Trace on which the action must be done
+ */
+int ltt_filter_control(enum ltt_filter_control_msg msg, const char *trace_name)
+{
+ int err;
+ struct ltt_trace *trace;
+
+ printk(KERN_DEBUG "ltt_filter_control : trace %s\n", trace_name);
+ ltt_lock_traces();
+ trace = _ltt_trace_find(trace_name);
+ if (trace == NULL) {
+ printk(KERN_ALERT
+ "Trace does not exist. Cannot proxy control request\n");
+ err = -ENOENT;
+ goto trace_error;
+ }
+ if (!try_module_get(ltt_filter_control_owner)) {
+ err = -ENODEV;
+ goto get_module_error;
+ }
+ switch (msg) {
+ case LTT_FILTER_DEFAULT_ACCEPT:
+ printk(KERN_DEBUG
+ "Proxy filter default accept %s\n", trace_name);
+ err = (*ltt_filter_control_functor)(msg, trace);
+ break;
+ case LTT_FILTER_DEFAULT_REJECT:
+ printk(KERN_DEBUG
+ "Proxy filter default reject %s\n", trace_name);
+ err = (*ltt_filter_control_functor)(msg, trace);
+ break;
+ default:
+ err = -EPERM;
+ }
+ module_put(ltt_filter_control_owner);
+
+get_module_error:
+trace_error:
+ ltt_unlock_traces();
+ return err;
+}
+EXPORT_SYMBOL_GPL(ltt_filter_control);
+
+int __init ltt_init(void)
+{
+ /* Make sure no page fault can be triggered by this module */
+ vmalloc_sync_all();
+ init_timer_deferrable(<t_async_wakeup_timer);
+ return 0;
+}
+
+module_init(ltt_init)
+
+static void __exit ltt_exit(void)
+{
+ struct ltt_trace *trace;
+ struct list_head *pos, *n;
+
+ ltt_lock_traces();
+ /* Stop each trace, currently being read by RCU read-side */
+ list_for_each_entry_rcu(trace, <t_traces.head, list)
+ _ltt_trace_stop(trace);
+ /* Wait for quiescent state. Readers have preemption disabled. */
+ synchronize_trace();
+ /* Safe iteration is now permitted. It does not have to be RCU-safe
+ * because no readers are left. */
+ list_for_each_safe(pos, n, <t_traces.head) {
+ trace = container_of(pos, struct ltt_trace, list);
+ /* _ltt_trace_destroy does a synchronize_trace() */
+ _ltt_trace_destroy(trace);
+ __ltt_trace_destroy(trace);
+ }
+ /* free traces in pre-alloc status */
+ list_for_each_safe(pos, n, <t_traces.setup_head) {
+ trace = container_of(pos, struct ltt_trace, list);
+ _ltt_trace_free(trace);
+ }
+
+ ltt_unlock_traces();
+}
+
+module_exit(ltt_exit)
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Tracer Kernel API");
--- /dev/null
+/**
+ * ltt-type-serializer.c
+ *
+ * LTTng specialized type serializer.
+ *
+ * Copyright Mathieu Desnoyers, 2008.
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+#include <linux/module.h>
+
+#include "ltt-type-serializer.h"
+#include "ltt-relay-lockless.h"
+
+notrace
+void _ltt_specialized_trace(void *probe_data,
+ void *serialize_private, unsigned int data_size,
+ unsigned int largest_align)
+{
+ struct ltt_event *event = probe_data;
+ int ret;
+ uint16_t eID;
+ size_t slot_size;
+ struct ltt_chanbuf *buf;
+ struct ltt_channel *chan;
+ struct ltt_session *session;
+ uint64_t tsc;
+ long buf_offset;
+ int cpu;
+ unsigned int rflags;
+
+ /* disabled from tracepoints rcu_read_lock_sched_notrace(); */
+ cpu = smp_processor_id();
+ __get_cpu_var(ltt_nesting)++;
+ /*
+ * asm volatile and "memory" clobber prevent the compiler from moving
+ * instructions out of the ltt nesting count. This is required to ensure
+ * that probe side-effects which can cause recursion (e.g. unforeseen
+ * traps, divisions by 0, ...) are triggered within the incremented
+ * nesting count section.
+ */
+ barrier();
+ eID = event->id;
+ chan = event->chan;
+ session = chan->session;
+
+ if (unlikely(!session->active))
+ goto skip;
+ if (unlikely(!ltt_run_filter(session, chan, event)))
+ goto skip;
+#ifdef LTT_DEBUG_EVENT_SIZE
+ rflags = LTT_RFLAG_ID_SIZE;
+#else
+ if (unlikely(eID >= LTT_FREE_EVENTS))
+ rflags = LTT_RFLAG_ID;
+ else
+ rflags = 0;
+#endif
+ /* reserve space : header and data */
+ ret = ltt_reserve_slot(chan, trace, data_size, largest_align,
+ cpu, &buf, &slot_size, &buf_offset, &tsc,
+ &rflags);
+ if (unlikely(ret < 0))
+ goto skip; /* buffer full */
+
+ /* Out-of-order write : header and data */
+ buf_offset = ltt_write_event_header(&buf->a, &chan->a,
+ buf_offset, eID, data_size,
+ tsc, rflags);
+ if (data_size) {
+ buf_offset += ltt_align(buf_offset, largest_align);
+ ltt_relay_write(&buf->a, &chan->a, buf_offset,
+ serialize_private, data_size);
+ buf_offset += data_size;
+ }
+ /* Out-of-order commit */
+ ltt_commit_slot(buf, chan, buf_offset, data_size, slot_size);
+skip:
+ /*
+ * asm volatile and "memory" clobber prevent the compiler from moving
+ * instructions out of the ltt nesting count. This is required to ensure
+ * that probe side-effects which can cause recursion (e.g. unforeseen
+ * traps, divisions by 0, ...) are triggered within the incremented
+ * nesting count section.
+ */
+ barrier();
+ __get_cpu_var(ltt_nesting)--;
+ /* disabled from tracepoints rcu_read_unlock_sched_notrace(); */
+}
+EXPORT_SYMBOL_GPL(_ltt_specialized_trace);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("LTT type serializer");
--- /dev/null
+#ifndef _LTT_TYPE_SERIALIZER_H
+#define _LTT_TYPE_SERIALIZER_H
+
+#include <linux/if.h> /* For IFNAMSIZ */
+
+#include "ltt-tracer.h"
+
+/*
+ * largest_align must be non-zero, equal to the minimum between the largest type
+ * and sizeof(void *).
+ */
+extern void _ltt_specialized_trace(void *probe_data,
+ void *serialize_private, unsigned int data_size,
+ unsigned int largest_align);
+
+/*
+ * Statically check that 0 < largest_align < sizeof(void *) to make sure it is
+ * dumb-proof. It will make sure 0 is changed into 1 and unsigned long long is
+ * changed into sizeof(void *) on 32-bit architectures.
+ */
+static inline void ltt_specialized_trace(void *probe_data,
+ void *serialize_private, unsigned int data_size,
+ unsigned int largest_align)
+{
+ largest_align = min_t(unsigned int, largest_align, sizeof(void *));
+ largest_align = max_t(unsigned int, largest_align, 1);
+ _ltt_specialized_trace(probe_data, serialize_private, data_size,
+ largest_align);
+}
+
+/*
+ * Type serializer definitions.
+ */
+
+/*
+ * Return size of structure without end-of-structure padding.
+ */
+#define serialize_sizeof(type) offsetof(typeof(type), end_field)
+
+struct serialize_long_int {
+ unsigned long f1;
+ unsigned int f2;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_int_int_long {
+ unsigned int f1;
+ unsigned int f2;
+ unsigned long f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_int_int_short {
+ unsigned int f1;
+ unsigned int f2;
+ unsigned short f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_long {
+ unsigned long f1;
+ unsigned long f2;
+ unsigned long f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_int {
+ unsigned long f1;
+ unsigned long f2;
+ unsigned int f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_short_char {
+ unsigned long f1;
+ unsigned long f2;
+ unsigned short f3;
+ unsigned char f4;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_short {
+ unsigned long f1;
+ unsigned long f2;
+ unsigned short f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_short_char {
+ unsigned long f1;
+ unsigned short f2;
+ unsigned char f3;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_short {
+ unsigned long f1;
+ unsigned short f2;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_char {
+ unsigned long f1;
+ unsigned char f2;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_ifname {
+ unsigned long f1;
+ unsigned char f2[IFNAMSIZ];
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_sizet_int {
+ size_t f1;
+ unsigned int f2;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_sizet_int {
+ unsigned long f1;
+ unsigned long f2;
+ size_t f3;
+ unsigned int f4;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_long_long_sizet_int_int {
+ unsigned long f1;
+ unsigned long f2;
+ size_t f3;
+ unsigned int f4;
+ unsigned int f5;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_l4421224411111 {
+ unsigned long f1;
+ uint32_t f2;
+ uint32_t f3;
+ uint16_t f4;
+ uint8_t f5;
+ uint16_t f6;
+ uint16_t f7;
+ uint32_t f8;
+ uint32_t f9;
+ uint8_t f10;
+ uint8_t f11;
+ uint8_t f12;
+ uint8_t f13;
+ uint8_t f14;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_l214421224411111 {
+ unsigned long f1;
+ uint16_t f2;
+ uint8_t f3;
+ uint32_t f4;
+ uint32_t f5;
+ uint16_t f6;
+ uint8_t f7;
+ uint16_t f8;
+ uint16_t f9;
+ uint32_t f10;
+ uint32_t f11;
+ uint8_t f12;
+ uint8_t f13;
+ uint8_t f14;
+ uint8_t f15;
+ uint8_t f16;
+ uint8_t end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+
+struct serialize_l4412228 {
+ unsigned long f1;
+ uint32_t f2;
+ uint32_t f3;
+ uint8_t f4;
+ uint16_t f5;
+ uint16_t f6;
+ uint16_t f7;
+ uint64_t f8;
+ unsigned char end_field[0];
+} RING_BUFFER_ALIGN_ATTR;
+#endif /* _LTT_TYPE_SERIALIZER_H */
--- /dev/null
+/*
+ * Copyright (C) 2008 Mathieu Desnoyers
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/marker.h>
+#include <linux/uaccess.h>
+#include <linux/gfp.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
+#include <linux/slab.h>
+
+#include "ltt-type-serializer.h"
+
+#define LTT_WRITE_EVENT_FILE "write_event"
+
+DEFINE_MARKER(userspace, event, "string %s");
+static struct dentry *ltt_event_file;
+
+/**
+ * write_event - write a userspace string into the trace system
+ * @file: file pointer
+ * @user_buf: user string
+ * @count: length to copy, including the final NULL
+ * @ppos: unused
+ *
+ * Copy a string into a trace event, in channel "userspace", event "event".
+ * Copies until either \n or \0 is reached.
+ * On success, returns the number of bytes copied from the source, including the
+ * \n or \0 character (if there was one in the count range). It cannot return
+ * more than count.
+ * Inspired from tracing_mark_write implementation from Steven Rostedt and
+ * Ingo Molnar.
+ */
+static
+ssize_t write_event(struct file *file, const char __user *user_buf,
+ size_t count, loff_t *ppos)
+{
+ struct marker *marker;
+ char *buf, *end;
+ long copycount;
+ ssize_t ret;
+
+ buf = kmalloc(count + 1, GFP_KERNEL);
+ if (!buf) {
+ ret = -ENOMEM;
+ goto string_out;
+ }
+ copycount = strncpy_from_user(buf, user_buf, count);
+ if (copycount < 0) {
+ ret = -EFAULT;
+ goto string_err;
+ }
+ /* Cut from the first nil or newline. */
+ buf[copycount] = '\0';
+ end = strchr(buf, '\n');
+ if (end) {
+ *end = '\0';
+ copycount = end - buf;
+ }
+ /* Add final \0 to copycount */
+ copycount++;
+ marker = &GET_MARKER(userspace, event);
+ ltt_specialized_trace(marker, marker->single.probe_private, buf,
+ copycount, sizeof(char));
+ /* If there is no \0 nor \n in count, do not return a larger value */
+ ret = min_t(size_t, copycount, count);
+string_err:
+ kfree(buf);
+string_out:
+ return ret;
+}
+
+static const struct file_operations ltt_userspace_operations = {
+ .write = write_event,
+};
+
+static int __init ltt_userspace_init(void)
+{
+ struct dentry *ltt_root_dentry;
+ int err = 0;
+
+ ltt_root_dentry = get_ltt_root();
+ if (!ltt_root_dentry) {
+ err = -ENOENT;
+ goto err_no_root;
+ }
+
+ ltt_event_file = debugfs_create_file(LTT_WRITE_EVENT_FILE,
+ S_IWUGO,
+ ltt_root_dentry,
+ NULL,
+ <t_userspace_operations);
+ if (IS_ERR(ltt_event_file) || !ltt_event_file) {
+ printk(KERN_ERR
+ "ltt_userspace_init: failed to create file %s\n",
+ LTT_WRITE_EVENT_FILE);
+ err = -EPERM;
+ goto err_no_file;
+ }
+
+ return err;
+err_no_file:
+ put_ltt_root();
+err_no_root:
+ return err;
+}
+
+static void __exit ltt_userspace_exit(void)
+{
+ debugfs_remove(ltt_event_file);
+ put_ltt_root();
+}
+
+module_init(ltt_userspace_init);
+module_exit(ltt_userspace_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>");
+MODULE_DESCRIPTION("Linux Trace Toolkit Userspace Event");
--- /dev/null
+# LTTng tracing probes
+
+ifdef CONFIG_FTRACE
+CFLAGS_REMOVE_kernel-trace.o = -pg
+CFLAGS_REMOVE_mm-trace.o = -pg
+CFLAGS_REMOVE_fs-trace.o = -pg
+CFLAGS_REMOVE_ipc-trace.o = -pg
+CFLAGS_REMOVE_lockdep-trace.o = -pg
+CFLAGS_REMOVE_rcu-trace.o = -pg
+CFLAGS_REMOVE_syscall-trace.o = -pg
+CFLAGS_REMOVE_trap-trace.o = -pg
+CFLAGS_REMOVE_pm-trace.o = -pg
+endif
+
+obj-m += kernel-trace.o mm-trace.o fs-trace.o ipc-trace.o lockdep-trace.o \
+ rcu-trace.o syscall-trace.o trap-trace.o pm-trace.o
+
+ifeq ($(CONFIG_NET),y)
+ifdef CONFIG_FTRACE
+CFLAGS_REMOVE_net-trace.o = -pg
+CFLAGS_REMOVE_net-extended-trace.o = -pg
+endif
+obj-m += net-trace.o net-extended-trace.o
+endif
+
+ifdef CONFIG_JBD2
+ifdef CONFIG_FTRACE
+CFLAGS_REMOVE_jbd2-trace.o = -pg
+endif
+obj-m += jbd2-trace.o
+endif
+
+#ifdef CONFIG_EXT4_FS
+#ifdef CONFIG_FTRACE
+#CFLAGS_REMOVE_ext4-trace.o = -pg
+#endif
+#obj-$(CONFIG_LTT_TRACEPROBES) += ext4-trace.o
+#endif
+
+ifdef CONFIG_BLOCK
+ifdef CONFIG_FTRACE
+CFLAGS_REMOVE_block-trace.o = -pg
+endif
+obj-m += block-trace.o
+endif
+
+
--- /dev/null
+/*
+ * ltt/probes/block-trace.c
+ *
+ * block layer tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+
+#include <trace/events/block.h>
+
+/*
+ * Add rq cmd as a sequence. Needs new type. (size + binary blob)
+ */
+
+void probe_block_rq_abort(void *data, struct request_queue *q, struct request *rq)
+{
+ int rw = rq->cmd_flags & 0x03;
+
+ if (blk_discard_rq(rq))
+ rw |= (1 << BIO_RW_DISCARD);
+
+ if (blk_pc_request(rq)) {
+ trace_mark_tp(block, rq_abort_pc, block_rq_abort,
+ probe_block_rq_abort,
+ "data_len %u rw %d errors %d",
+ blk_rq_bytes(rq), rw, rq->errors);
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both rq_abort_pc and rq_abort_fs
+ * markers to have the rq_abort_fs marker enabled.
+ */
+ trace_mark(block, rq_abort_fs,
+ "hard_sector %llu "
+ "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
+ rw, rq->errors);
+ }
+}
+
+void probe_block_rq_insert(void *data, struct request_queue *q, struct request *rq)
+{
+ int rw = rq->cmd_flags & 0x03;
+
+ if (blk_discard_rq(rq))
+ rw |= (1 << BIO_RW_DISCARD);
+
+ if (blk_pc_request(rq)) {
+ trace_mark_tp(block, rq_insert_pc, block_rq_insert,
+ probe_block_rq_insert,
+ "data_len %u rw %d errors %d",
+ blk_rq_bytes(rq), rw, rq->errors);
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both rq_insert_pc and
+ * rq_insert_fs markers to have the rq_insert_fs marker enabled.
+ */
+ trace_mark(block, rq_insert_fs,
+ "hard_sector %llu "
+ "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
+ rw, rq->errors);
+ }
+}
+
+void probe_block_rq_issue(void *data, struct request_queue *q, struct request *rq)
+{
+ int rw = rq->cmd_flags & 0x03;
+
+ if (blk_discard_rq(rq))
+ rw |= (1 << BIO_RW_DISCARD);
+
+ if (blk_pc_request(rq)) {
+ trace_mark_tp(block, rq_issue_pc, block_rq_issue,
+ probe_block_rq_issue,
+ "data_len %u rw %d errors %d",
+ blk_rq_bytes(rq), rw, rq->errors);
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both rq_issue_pc and rq_issue_fs
+ * markers to have the rq_issue_fs marker enabled.
+ */
+ trace_mark(block, rq_issue_fs,
+ "hard_sector %llu "
+ "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
+ rw, rq->errors);
+ }
+}
+
+void probe_block_rq_requeue(void *data, struct request_queue *q, struct request *rq)
+{
+ int rw = rq->cmd_flags & 0x03;
+
+ if (blk_discard_rq(rq))
+ rw |= (1 << BIO_RW_DISCARD);
+
+ if (blk_pc_request(rq)) {
+ trace_mark_tp(block, rq_requeue_pc, block_rq_requeue,
+ probe_block_rq_requeue,
+ "data_len %u rw %d errors %d",
+ blk_rq_bytes(rq), rw, rq->errors);
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both rq_requeue_pc and
+ * rq_requeue_fs markers to have the rq_requeue_fs marker
+ * enabled.
+ */
+ trace_mark(block, rq_requeue_fs,
+ "hard_sector %llu "
+ "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
+ rw, rq->errors);
+ }
+}
+
+void probe_block_rq_complete(void *data, struct request_queue *q, struct request *rq)
+{
+ int rw = rq->cmd_flags & 0x03;
+
+ if (blk_discard_rq(rq))
+ rw |= (1 << BIO_RW_DISCARD);
+
+ if (blk_pc_request(rq)) {
+ trace_mark_tp(block, rq_complete_pc, block_rq_complete,
+ probe_block_rq_complete,
+ "data_len %u rw %d errors %d",
+ blk_rq_bytes(rq), rw, rq->errors);
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both rq_complete_pc and
+ * rq_complete_fs markers to have the rq_complete_fs marker
+ * enabled.
+ */
+ trace_mark(block, rq_complete_fs,
+ "hard_sector %llu "
+ "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
+ rw, rq->errors);
+ }
+}
+
+void probe_block_bio_bounce(void *data, struct request_queue *q, struct bio *bio)
+{
+ trace_mark_tp(block, bio_bounce, block_bio_bounce,
+ probe_block_bio_bounce,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+}
+
+void probe_block_bio_complete(void *data, struct request_queue *q, struct bio *bio)
+{
+ trace_mark_tp(block, bio_complete, block_bio_complete,
+ probe_block_bio_complete,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+}
+
+void probe_block_bio_backmerge(void *data, struct request_queue *q, struct bio *bio)
+{
+ trace_mark_tp(block, bio_backmerge, block_bio_backmerge,
+ probe_block_bio_backmerge,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+}
+
+void probe_block_bio_frontmerge(void *data, struct request_queue *q, struct bio *bio)
+{
+ trace_mark_tp(block, bio_frontmerge, block_bio_frontmerge,
+ probe_block_bio_frontmerge,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+}
+
+void probe_block_bio_queue(void *data, struct request_queue *q, struct bio *bio)
+{
+ trace_mark_tp(block, bio_queue, block_bio_queue,
+ probe_block_bio_queue,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+}
+
+void probe_block_getrq(void *data, struct request_queue *q, struct bio *bio, int rw)
+{
+ if (bio) {
+ trace_mark_tp(block, getrq_bio, block_getrq,
+ probe_block_getrq,
+ "sector %llu size %u "
+ "rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both getrq_bio and getrq markers
+ * to have the getrq marker enabled.
+ */
+ trace_mark(block, getrq, "rw %d", rw);
+ }
+}
+
+void probe_block_sleeprq(void *data, struct request_queue *q, struct bio *bio, int rw)
+{
+ if (bio) {
+ trace_mark_tp(block, sleeprq_bio, block_sleeprq,
+ probe_block_sleeprq,
+ "sector %llu size %u "
+ "rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
+ } else {
+ /*
+ * FIXME Using a simple trace_mark for the second event
+ * possibility because tracepoints do not support multiple
+ * connections to the same probe yet. They should have some
+ * refcounting. Need to enable both sleeprq_bio and sleeprq
+ * markers to have the sleeprq marker enabled.
+ */
+ trace_mark(block, sleeprq, "rw %d", rw);
+ }
+}
+
+void probe_block_plug(void *data, struct request_queue *q)
+{
+ trace_mark_tp(block, plug, block_plug, probe_block_plug,
+ MARK_NOARGS);
+}
+
+void probe_block_unplug_io(void *data, struct request_queue *q)
+{
+ unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
+
+ trace_mark_tp(block, unplug_io, block_unplug_io, probe_block_unplug_io,
+ "pdu %u", pdu);
+}
+
+void probe_block_unplug_timer(void *data, struct request_queue *q)
+{
+ unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
+
+ trace_mark_tp(block, unplug_timer, block_unplug_timer,
+ probe_block_unplug_timer,
+ "pdu %u", pdu);
+}
+
+void probe_block_split(void *data, struct request_queue *q, struct bio *bio,
+ unsigned int pdu)
+{
+ trace_mark_tp(block, split, block_split,
+ probe_block_split,
+ "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d pdu %u",
+ (unsigned long long)bio->bi_sector, bio->bi_size,
+ bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE), pdu);
+}
+
+void probe_block_remap(void *data, struct request_queue *q, struct bio *bio,
+ dev_t dev, sector_t from)
+{
+ trace_mark_tp(block, remap, block_remap,
+ probe_block_remap,
+ "device_from %lu sector_from %llu device_to %lu "
+ "size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
+ "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
+ "not_uptodate #1u%d",
+ (unsigned long)bio->bi_bdev->bd_dev,
+ (unsigned long long)from,
+ (unsigned long)dev,
+ bio->bi_size, bio->bi_rw,
+ !bio_flagged(bio, BIO_UPTODATE));
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Block Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/ext4-trace.c
+ *
+ * ext4 tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/writeback.h>
+#include <linux/debugfs.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <trace/events/ext4.h>
+
+#include "../ltt-tracer.h"
+#include "../../fs/ext4/mballoc.h"
+
+static struct dentry *ext4_filter_dentry, *ext4_filter_dev_dentry,
+ *ext4_filter_inode_dentry;
+static DEFINE_MUTEX(ext4_filter_mutex);
+/* Make sure we don't race between module exit and file write */
+static int module_exits;
+
+struct rcu_dev_filter {
+ struct rcu_head rcu;
+ char devname[NAME_MAX];
+};
+
+static struct rcu_dev_filter *dev_filter;
+/* ~0UL inode_filter enables all inodes */
+static unsigned long inode_filter = ~0UL;
+
+/*
+ * Probes are executed in rcu_sched read-side critical section.
+ */
+
+static int do_dev_filter(const char *dev)
+{
+ struct rcu_dev_filter *ldev_filter = rcu_dereference(dev_filter);
+
+ if (unlikely(ldev_filter))
+ if (unlikely(strcmp(ldev_filter->devname, dev)))
+ return 0;
+ return 1;
+}
+
+static int do_inode_filter(unsigned long ino)
+{
+ if (unlikely(inode_filter != ~0UL))
+ if (unlikely(inode_filter != ino))
+ return 0;
+ return 1;
+}
+
+/*
+ * Logical AND between dev and inode filter.
+ */
+static int do_filter(const char *dev, unsigned long ino)
+{
+ if (unlikely(!do_dev_filter(dev)))
+ return 0;
+ if (unlikely(!do_inode_filter(ino)))
+ return 0;
+ return 1;
+}
+
+
+void probe_ext4_free_inode(void *data, struct inode *inode)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, free_inode, ext4_free_inode,
+ probe_ext4_free_inode,
+ "dev %s ino %lu mode %d uid %lu gid %lu blocks %llu",
+ inode->i_sb->s_id, inode->i_ino, inode->i_mode,
+ (unsigned long) inode->i_uid, (unsigned long) inode->i_gid,
+ (unsigned long long) inode->i_blocks);
+}
+
+void probe_ext4_request_inode(void *data, struct inode *dir, int mode)
+{
+ if (unlikely(!do_filter(dir->i_sb->s_id, dir->i_ino)))
+ return;
+ trace_mark_tp(ext4, request_inode, ext4_request_inode,
+ probe_ext4_request_inode,
+ "dev %s dir %lu mode %d",
+ dir->i_sb->s_id, dir->i_ino, mode);
+}
+
+void probe_ext4_allocate_inode(void *data, struct inode *inode, struct inode *dir, int mode)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)
+ && !do_filter(dir->i_sb->s_id, dir->i_ino)))
+ return;
+ trace_mark_tp(ext4, allocate_inode, ext4_allocate_inode,
+ probe_ext4_allocate_inode,
+ "dev %s ino %lu dir %lu mode %d",
+ dir->i_sb->s_id, inode->i_ino, dir->i_ino, mode);
+}
+
+void probe_ext4_write_begin(void *data, struct inode *inode, loff_t pos, unsigned int len,
+ unsigned int flags)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, write_begin, ext4_write_begin,
+ probe_ext4_write_begin,
+ "dev %s ino %lu pos %llu len %u flags %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, flags);
+}
+
+void probe_ext4_ordered_write_end(void *data, struct inode *inode, loff_t pos,
+ unsigned int len, unsigned int copied)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, ordered_write_end, ext4_ordered_write_end,
+ probe_ext4_ordered_write_end,
+ "dev %s ino %lu pos %llu len %u copied %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, copied);
+}
+
+void probe_ext4_writeback_write_end(void *data, struct inode *inode, loff_t pos,
+ unsigned int len, unsigned int copied)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, writeback_write_end, ext4_writeback_write_end,
+ probe_ext4_writeback_write_end,
+ "dev %s ino %lu pos %llu len %u copied %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, copied);
+}
+
+void probe_ext4_journalled_write_end(void *data, struct inode *inode, loff_t pos,
+ unsigned int len, unsigned int copied)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, journalled_write_end, ext4_journalled_write_end,
+ probe_ext4_journalled_write_end,
+ "dev %s ino %lu pos %llu len %u copied %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, copied);
+}
+
+/*
+ * note : wbc_flags will have to be decoded by userspace.
+ * #1x uses a single byte in the trace. Limits to 8 bits.
+ */
+void probe_ext4_da_writepages(void *data, struct inode *inode,
+ struct writeback_control *wbc)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, da_writepages, ext4_da_writepages,
+ probe_ext4_da_writepages,
+ "dev %s ino %lu nr_to_write %ld "
+ "pages_skipped %ld range_start %llu range_end %llu "
+ "wbc_flags(nonblocking,for_kupdate,"
+ "for_reclaim,range_cyclic) #1x%u",
+ inode->i_sb->s_id, inode->i_ino, wbc->nr_to_write,
+ wbc->pages_skipped,
+ (unsigned long long) wbc->range_start,
+ (unsigned long long) wbc->range_end,
+ (wbc->nonblocking << 3)
+ | (wbc->for_kupdate << 2)
+ | (wbc->for_reclaim << 1)
+ | wbc->range_cyclic);
+}
+
+/*
+ * note : wbc_flags will have to be decoded by userspace.
+ * #1x uses a single byte in the trace. Limits to 8 bits.
+ */
+void probe_ext4_da_writepages_result(void *data, struct inode *inode,
+ struct writeback_control *wbc,
+ int ret, int pages_written)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, da_writepages_result, ext4_da_writepages_result,
+ probe_ext4_da_writepages_result,
+ "dev %s ino %lu ret %d pages_written %d "
+ "pages_skipped %ld "
+ "wbc_flags(encountered_congestion,"
+ "more_io,no_nrwrite_index_update) #1x%u",
+ inode->i_sb->s_id, inode->i_ino, ret, pages_written,
+ wbc->pages_skipped,
+ (wbc->encountered_congestion << 2)
+ | (wbc->more_io << 1)
+ | wbc->no_nrwrite_index_update);
+}
+
+void probe_ext4_da_write_begin(void *data, struct inode *inode, loff_t pos,
+ unsigned int len, unsigned int flags)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, da_write_begin, ext4_da_write_begin,
+ probe_ext4_da_write_begin,
+ "dev %s ino %lu pos %llu len %u flags %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, flags);
+}
+
+void probe_ext4_da_write_end(void *data, struct inode *inode, loff_t pos,
+ unsigned int len, unsigned int copied)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, da_write_end, ext4_da_write_end,
+ probe_ext4_da_write_end,
+ "dev %s ino %lu pos %llu len %u copied %u",
+ inode->i_sb->s_id, inode->i_ino,
+ (unsigned long long) pos, len, copied);
+}
+
+void probe_ext4_discard_blocks(void *data, struct super_block *sb, unsigned long long blk,
+ unsigned long long count)
+{
+ if (unlikely(!do_dev_filter(sb->s_id)))
+ return;
+ trace_mark_tp(ext4, discard_blocks, ext4_discard_blocks,
+ probe_ext4_discard_blocks,
+ "dev %s blk %llu count %llu",
+ sb->s_id, blk, count);
+}
+
+void probe_ext4_mb_new_inode_pa(void *data, struct ext4_allocation_context *ac,
+ struct ext4_prealloc_space *pa)
+{
+ if (unlikely(!do_filter(ac->ac_sb->s_id, ac->ac_inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, mb_new_inode_pa, ext4_mb_new_inode_pa,
+ probe_ext4_mb_new_inode_pa,
+ "dev %s ino %lu pstart %llu len %u lstart %u",
+ ac->ac_sb->s_id, ac->ac_inode->i_ino, pa->pa_pstart,
+ pa->pa_len, pa->pa_lstart);
+}
+
+void probe_ext4_mb_new_group_pa(void *data, struct ext4_allocation_context *ac,
+ struct ext4_prealloc_space *pa)
+{
+ if (unlikely(!do_dev_filter(ac->ac_sb->s_id)))
+ return;
+ trace_mark_tp(ext4, mb_new_group_pa, ext4_mb_new_group_pa,
+ probe_ext4_mb_new_group_pa,
+ "dev %s pstart %llu len %u lstart %u",
+ ac->ac_sb->s_id, pa->pa_pstart,
+ pa->pa_len, pa->pa_lstart);
+}
+
+void probe_ext4_mb_release_inode_pa(void *data, struct ext4_allocation_context *ac,
+ struct ext4_prealloc_space *pa,
+ unsigned long long block,
+ unsigned int count)
+{
+ if (unlikely(!do_filter(ac->ac_sb->s_id, ac->ac_inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, mb_release_inode_pa, ext4_mb_release_inode_pa,
+ probe_ext4_mb_release_inode_pa,
+ "dev %s ino %lu block %llu count %u",
+ ac->ac_sb->s_id, pa->pa_inode->i_ino, block, count);
+}
+
+void probe_ext4_mb_release_group_pa(void *data, struct ext4_allocation_context *ac,
+ struct ext4_prealloc_space *pa)
+{
+ if (unlikely(!do_dev_filter(ac->ac_sb->s_id)))
+ return;
+ trace_mark_tp(ext4, mb_release_group_pa, ext4_mb_release_group_pa,
+ probe_ext4_mb_release_group_pa,
+ "dev %s pstart %llu len %d",
+ ac->ac_sb->s_id, pa->pa_pstart, pa->pa_len);
+}
+
+void probe_ext4_discard_preallocations(void *data, struct inode *inode)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, discard_preallocations,
+ ext4_discard_preallocations,
+ probe_ext4_discard_preallocations,
+ "dev %s ino %lu",
+ inode->i_sb->s_id, inode->i_ino);
+}
+
+void probe_ext4_mb_discard_preallocations(void *data, struct super_block *sb, int needed)
+{
+ if (unlikely(!do_dev_filter(sb->s_id)))
+ return;
+ trace_mark_tp(ext4, mb_discard_preallocations,
+ ext4_mb_discard_preallocations,
+ probe_ext4_mb_discard_preallocations,
+ "dev %s needed %d",
+ sb->s_id, needed);
+}
+
+void probe_ext4_request_blocks(void *data, struct ext4_allocation_request *ar)
+{
+ if (ar->inode) {
+ if (unlikely(!do_filter(ar->inode->i_sb->s_id,
+ ar->inode->i_ino)))
+ return;
+ } else {
+ if (unlikely(!do_dev_filter(ar->inode->i_sb->s_id)))
+ return;
+ }
+ trace_mark_tp(ext4, request_blocks, ext4_request_blocks,
+ probe_ext4_request_blocks,
+ "dev %s flags %u len %u ino %lu "
+ "lblk %llu goal %llu lleft %llu lright %llu "
+ "pleft %llu pright %llu",
+ ar->inode->i_sb->s_id, ar->flags, ar->len,
+ ar->inode ? ar->inode->i_ino : 0,
+ (unsigned long long) ar->logical,
+ (unsigned long long) ar->goal,
+ (unsigned long long) ar->lleft,
+ (unsigned long long) ar->lright,
+ (unsigned long long) ar->pleft,
+ (unsigned long long) ar->pright);
+}
+
+void probe_ext4_allocate_blocks(void *data, struct ext4_allocation_request *ar,
+ unsigned long long block)
+{
+ if (ar->inode) {
+ if (unlikely(!do_filter(ar->inode->i_sb->s_id,
+ ar->inode->i_ino)))
+ return;
+ } else {
+ if (unlikely(!do_dev_filter(ar->inode->i_sb->s_id)))
+ return;
+ }
+ trace_mark_tp(ext4, allocate_blocks, ext4_allocate_blocks,
+ probe_ext4_allocate_blocks,
+ "dev %s block %llu flags %u len %u ino %lu "
+ "logical %llu goal %llu lleft %llu lright %llu "
+ "pleft %llu pright %llu",
+ ar->inode->i_sb->s_id, (unsigned long long) block,
+ ar->flags, ar->len, ar->inode ? ar->inode->i_ino : 0,
+ (unsigned long long) ar->logical,
+ (unsigned long long) ar->goal,
+ (unsigned long long) ar->lleft,
+ (unsigned long long) ar->lright,
+ (unsigned long long) ar->pleft,
+ (unsigned long long) ar->pright);
+}
+
+void probe_ext4_free_blocks(void *data, struct inode *inode, __u64 block,
+ unsigned long count, int metadata)
+{
+ if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, free_blocks, ext4_free_blocks,
+ probe_ext4_free_blocks,
+ "dev %s block %llu count %lu metadata %d ino %lu",
+ inode->i_sb->s_id, (unsigned long long)block,
+ count, metadata, inode->i_ino);
+}
+
+void probe_ext4_sync_file(void *data, struct file *file, struct dentry *dentry,
+ int datasync)
+{
+ if (unlikely(!do_dev_filter(dentry->d_inode->i_sb->s_id)))
+ return;
+ if (unlikely(!do_inode_filter(dentry->d_inode->i_ino)
+ && !do_inode_filter(dentry->d_parent->d_inode->i_ino)))
+ return;
+ trace_mark_tp(ext4, sync_file, ext4_sync_file,
+ probe_ext4_sync_file,
+ "dev %s datasync %d ino %ld parent %ld",
+ dentry->d_inode->i_sb->s_id, datasync, dentry->d_inode->i_ino,
+ dentry->d_parent->d_inode->i_ino);
+}
+
+void probe_ext4_sync_fs(void *data, struct super_block *sb, int wait)
+{
+ if (unlikely(!do_dev_filter(sb->s_id)))
+ return;
+ trace_mark_tp(ext4, sync_fs, ext4_sync_fs,
+ probe_ext4_sync_fs,
+ "dev %s wait %d",
+ sb->s_id, wait);
+}
+
+static void free_dev_filter(struct rcu_head *head)
+{
+ kfree(container_of(head, struct rcu_dev_filter, rcu));
+}
+
+static ssize_t dev_filter_op_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err = 0;
+ char buf[NAME_MAX];
+ int buf_size;
+ char name[NAME_MAX];
+ struct rcu_dev_filter *new, *old;
+
+ mutex_lock(&ext4_filter_mutex);
+ if (module_exits) {
+ err = -EPERM;
+ goto error;
+ }
+ buf_size = min(count, sizeof(buf) - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto error;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", name) != 1) {
+ err = -EPERM;
+ goto error;
+ }
+
+ old = dev_filter;
+
+ /* Empty string or * means all active */
+ if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
+ new = NULL;
+ } else {
+ new = kmalloc(sizeof(*new), GFP_KERNEL);
+ strcpy(new->devname, name);
+ }
+
+ rcu_assign_pointer(dev_filter, new);
+ if (old)
+ call_rcu_sched(&old->rcu, free_dev_filter);
+
+ mutex_unlock(&ext4_filter_mutex);
+ return count;
+
+error:
+ mutex_unlock(&ext4_filter_mutex);
+ return err;
+}
+
+static ssize_t dev_filter_op_read(struct file *filp, char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ ssize_t bcount;
+ const char *devname;
+
+ mutex_lock(&ext4_filter_mutex);
+ if (!dev_filter)
+ devname = "*";
+ else
+ devname = dev_filter->devname;
+ bcount = simple_read_from_buffer(buffer, count, ppos,
+ devname, strlen(devname));
+ mutex_unlock(&ext4_filter_mutex);
+ return bcount;
+}
+
+static struct file_operations ext4_dev_file_operations = {
+ .write = dev_filter_op_write,
+ .read = dev_filter_op_read,
+};
+
+static ssize_t inode_filter_op_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err = 0;
+ char buf[NAME_MAX];
+ int buf_size;
+ char name[NAME_MAX];
+ unsigned long inode_num;
+
+ mutex_lock(&ext4_filter_mutex);
+ if (module_exits) {
+ err = -EPERM;
+ goto error;
+ }
+ buf_size = min(count, sizeof(buf) - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto error;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", name) != 1) {
+ err = -EPERM;
+ goto error;
+ }
+
+ /* Empty string or * means all active */
+ if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
+ inode_filter = ~0UL;
+ } else {
+ if (sscanf(buf, "%lu", &inode_num) != 1) {
+ err = -EPERM;
+ goto error;
+ }
+ inode_filter = inode_num;
+ }
+
+ mutex_unlock(&ext4_filter_mutex);
+ return count;
+
+error:
+ mutex_unlock(&ext4_filter_mutex);
+ return err;
+}
+
+static ssize_t inode_filter_op_read(struct file *filp, char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ ssize_t bcount;
+ char inode_str[NAME_MAX];
+
+ mutex_lock(&ext4_filter_mutex);
+ if (inode_filter == ~0UL)
+ strcpy(inode_str, "*");
+ else {
+ bcount = snprintf(inode_str, sizeof(inode_str), "%lu",
+ inode_filter);
+ if (bcount == sizeof(inode_str))
+ bcount = -ENOSPC;
+ if (bcount < 0)
+ goto end;
+ }
+ bcount = simple_read_from_buffer(buffer, count, ppos,
+ inode_str, strlen(inode_str));
+end:
+ mutex_unlock(&ext4_filter_mutex);
+ return bcount;
+}
+
+static struct file_operations ext4_inode_file_operations = {
+ .write = inode_filter_op_write,
+ .read = inode_filter_op_read,
+};
+
+static void release_filter_dev(void)
+{
+ struct rcu_dev_filter *old;
+
+ mutex_lock(&ext4_filter_mutex);
+ module_exits = 1;
+ old = dev_filter;
+ rcu_assign_pointer(dev_filter, NULL);
+ if (old)
+ call_rcu_sched(&old->rcu, free_dev_filter);
+ mutex_unlock(&ext4_filter_mutex);
+}
+
+static int __init filter_init(void)
+{
+ struct dentry *filter_root_dentry;
+ int err = 0;
+
+ filter_root_dentry = get_filter_root();
+ if (!filter_root_dentry) {
+ err = -ENOENT;
+ goto end;
+ }
+
+ ext4_filter_dentry = debugfs_create_dir("ext4", filter_root_dentry);
+
+ if (IS_ERR(ext4_filter_dentry) || !ext4_filter_dentry) {
+ printk(KERN_ERR "Failed to create ext4 filter file\n");
+ err = -ENOMEM;
+ goto end;
+ }
+
+ ext4_filter_dev_dentry = debugfs_create_file("dev", S_IWUSR,
+ ext4_filter_dentry, NULL, &ext4_dev_file_operations);
+ if (IS_ERR(ext4_filter_dev_dentry) || !ext4_filter_dev_dentry) {
+ printk(KERN_ERR "Failed to create ext4 dev filter file\n");
+ err = -ENOMEM;
+ goto release_filter_dentry;
+ }
+
+ ext4_filter_inode_dentry = debugfs_create_file("inode", S_IWUSR,
+ ext4_filter_dentry, NULL, &ext4_inode_file_operations);
+ if (IS_ERR(ext4_filter_inode_dentry) || !ext4_filter_inode_dentry) {
+ printk(KERN_ERR "Failed to create ext4 inode filter file\n");
+ err = -ENOMEM;
+ goto release_filter_dev_dentry;
+ }
+
+ goto end;
+
+release_filter_dev_dentry:
+ debugfs_remove(ext4_filter_dev_dentry);
+release_filter_dentry:
+ debugfs_remove(ext4_filter_dentry);
+ release_filter_dev();
+end:
+ return err;
+}
+
+static void __exit filter_exit(void)
+{
+ debugfs_remove(ext4_filter_dev_dentry);
+ debugfs_remove(ext4_filter_inode_dentry);
+ debugfs_remove(ext4_filter_dentry);
+ release_filter_dev();
+}
+
+module_init(filter_init);
+module_exit(filter_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("ext4 Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/fs-trace.c
+ *
+ * FS tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/buffer_head.h>
+#include <trace/fs.h>
+
+#include "../ltt-type-serializer.h"
+
+void probe_fs_buffer_wait_start(void *_data, struct buffer_head *bh)
+{
+ trace_mark_tp(fs, buffer_wait_start, fs_buffer_wait_start,
+ probe_fs_buffer_wait_start, "bh %p", bh);
+}
+
+void probe_fs_buffer_wait_end(void *_data, struct buffer_head *bh)
+{
+ trace_mark_tp(fs, buffer_wait_end, fs_buffer_wait_end,
+ probe_fs_buffer_wait_end, "bh %p", bh);
+}
+
+void probe_fs_exec(void *_data, char *filename)
+{
+ trace_mark_tp(fs, exec, fs_exec, probe_fs_exec, "filename %s",
+ filename);
+}
+
+void probe_fs_ioctl(void *_data, unsigned int fd, unsigned int cmd, unsigned long arg)
+{
+ trace_mark_tp(fs, ioctl, fs_ioctl, probe_fs_ioctl,
+ "fd %u cmd %u arg %lu", fd, cmd, arg);
+}
+
+void probe_fs_open(void *_data, int fd, char *filename)
+{
+ trace_mark_tp(fs, open, fs_open, probe_fs_open,
+ "fd %d filename %s", fd, filename);
+}
+
+void probe_fs_close(void *_data, unsigned int fd)
+{
+ trace_mark_tp(fs, close, fs_close, probe_fs_close, "fd %u", fd);
+}
+
+void probe_fs_lseek(void *_data, unsigned int fd, long offset, unsigned int origin)
+{
+ trace_mark_tp(fs, lseek, fs_lseek, probe_fs_lseek,
+ "fd %u offset %ld origin %u", fd, offset, origin);
+}
+
+void probe_fs_llseek(void *_data, unsigned int fd, loff_t offset, unsigned int origin)
+{
+ trace_mark_tp(fs, llseek, fs_llseek, probe_fs_llseek,
+ "fd %u offset %lld origin %u", fd,
+ (long long)offset, origin);
+}
+
+void probe_fs_read(void *_data, unsigned int fd, char __user *buf, size_t count,
+ ssize_t ret);
+
+DEFINE_MARKER_TP(fs, read, fs_read, probe_fs_read,
+ "count %zu fd %u");
+
+notrace void probe_fs_read(void *_data, unsigned int fd, char __user *buf, size_t count,
+ ssize_t ret)
+{
+ struct marker *marker;
+ struct serialize_sizet_int data;
+
+ data.f1 = count;
+ data.f2 = fd;
+
+ marker = &GET_MARKER(fs, read);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(size_t));
+}
+
+void probe_fs_write(void *_data, unsigned int fd, char __user *buf, size_t count,
+ ssize_t ret);
+
+DEFINE_MARKER_TP(fs, write, fs_write, probe_fs_write,
+ "count %zu fd %u");
+
+notrace void probe_fs_write(void *_data, unsigned int fd, char __user *buf, size_t count,
+ ssize_t ret)
+{
+ struct marker *marker;
+ struct serialize_sizet_int data;
+
+ data.f1 = count;
+ data.f2 = fd;
+
+ marker = &GET_MARKER(fs, write);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(size_t));
+}
+
+void probe_fs_pread64(void *_data, unsigned int fd, char __user *buf, size_t count,
+ loff_t pos, ssize_t ret)
+{
+ trace_mark_tp(fs, pread64, fs_pread64, probe_fs_pread64,
+ "fd %u count %zu pos %llu",
+ fd, count, (unsigned long long)pos);
+}
+
+void probe_fs_pwrite64(void *_data, unsigned int fd, const char __user *buf,
+ size_t count, loff_t pos, ssize_t ret)
+{
+ trace_mark_tp(fs, pwrite64, fs_pwrite64, probe_fs_pwrite64,
+ "fd %u count %zu pos %llu",
+ fd, count, (unsigned long long)pos);
+}
+
+void probe_fs_readv(void *_data, unsigned long fd, const struct iovec __user *vec,
+ unsigned long vlen, ssize_t ret)
+{
+ trace_mark_tp(fs, readv, fs_readv, probe_fs_readv,
+ "fd %lu vlen %lu", fd, vlen);
+}
+
+void probe_fs_writev(void *_data, unsigned long fd, const struct iovec __user *vec,
+ unsigned long vlen, ssize_t ret)
+{
+ trace_mark_tp(fs, writev, fs_writev, probe_fs_writev,
+ "fd %lu vlen %lu", fd, vlen);
+}
+
+void probe_fs_select(void *_data, int fd, struct timespec *end_time)
+{
+ struct timespec tmptime;
+
+ if (end_time) {
+ tmptime = *end_time;
+ } else {
+ tmptime.tv_sec = -1L;
+ tmptime.tv_nsec = -1L;
+ }
+
+ trace_mark_tp(fs, select, fs_select, probe_fs_select,
+ "fd %d end_time_sec %ld end_time_nsec %ld", fd,
+ tmptime.tv_sec, tmptime.tv_nsec);
+}
+
+void probe_fs_poll(void *_data, int fd)
+{
+ trace_mark_tp(fs, pollfd, fs_poll, probe_fs_poll,
+ "fd %d", fd);
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("FS Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/ipc-trace.c
+ *
+ * IPC tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <trace/ipc.h>
+
+void probe_ipc_msg_create(void *data, long id, int flags)
+{
+ trace_mark_tp(ipc, msg_create, ipc_msg_create, probe_ipc_msg_create,
+ "id %ld flags %d", id, flags);
+}
+
+void probe_ipc_sem_create(void *data, long id, int flags)
+{
+ trace_mark_tp(ipc, sem_create, ipc_sem_create, probe_ipc_sem_create,
+ "id %ld flags %d", id, flags);
+}
+
+void probe_ipc_shm_create(void *data, long id, int flags)
+{
+ trace_mark_tp(ipc, shm_create, ipc_shm_create, probe_ipc_shm_create,
+ "id %ld flags %d", id, flags);
+}
+
+void probe_ipc_call(void *data, unsigned int call, unsigned int first)
+{
+ trace_mark_tp(ipc, call, ipc_call, probe_ipc_call,
+ "call %u first %d", call, first);
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("IPC Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/jbd2-trace.c
+ *
+ * JBD2 tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/debugfs.h>
+#include <linux/mutex.h>
+#include <linux/rcupdate.h>
+#include <trace/events/jbd2.h>
+
+#include "../ltt-tracer.h"
+
+static struct dentry *jbd2_filter_dentry, *jbd2_filter_dev_dentry;
+static DEFINE_MUTEX(jbd2_filter_mutex);
+/* Make sure we don't race between module exit and file write */
+static int module_exits;
+
+struct rcu_dev_filter {
+ struct rcu_head rcu;
+ char devname[NAME_MAX];
+};
+
+static struct rcu_dev_filter *dev_filter;
+
+/*
+ * Probes are executed in rcu_sched read-side critical section.
+ */
+static int do_filter(const char *dev)
+{
+ struct rcu_dev_filter *ldev_filter = rcu_dereference(dev_filter);
+
+ if (unlikely(ldev_filter))
+ if (unlikely(strcmp(ldev_filter->devname, dev)))
+ return 0;
+ return 1;
+}
+
+void probe_jbd2_checkpoint(void *data, journal_t *journal, int result)
+{
+ if (unlikely(!do_filter(journal->j_devname)))
+ return;
+ trace_mark_tp(jbd2, checkpoint, jbd2_checkpoint,
+ probe_jbd2_checkpoint, "dev %s need_checkpoint %d",
+ journal->j_devname, result);
+}
+
+void probe_jbd2_start_commit(void *data, journal_t *journal,
+ transaction_t *commit_transaction)
+{
+ if (unlikely(!do_filter(journal->j_devname)))
+ return;
+ trace_mark_tp(jbd2, start_commit, jbd2_start_commit,
+ probe_jbd2_start_commit, "dev %s transaction %d",
+ journal->j_devname, commit_transaction->t_tid);
+}
+
+void probe_jbd2_end_commit(void *data, journal_t *journal,
+ transaction_t *commit_transaction)
+{
+ if (unlikely(!do_filter(journal->j_devname)))
+ return;
+ trace_mark_tp(jbd2, end_commit, jbd2_end_commit,
+ probe_jbd2_end_commit, "dev %s transaction %d head %d",
+ journal->j_devname, commit_transaction->t_tid,
+ journal->j_tail_sequence);
+}
+
+static void free_dev_filter(struct rcu_head *head)
+{
+ kfree(container_of(head, struct rcu_dev_filter, rcu));
+}
+
+static ssize_t filter_op_write(struct file *file,
+ const char __user *user_buf, size_t count, loff_t *ppos)
+{
+ int err = 0;
+ char buf[NAME_MAX];
+ int buf_size;
+ char name[NAME_MAX];
+ struct rcu_dev_filter *new, *old;
+
+ mutex_lock(&jbd2_filter_mutex);
+ if (module_exits) {
+ err = -EPERM;
+ goto error;
+ }
+ buf_size = min(count, sizeof(buf) - 1);
+ err = copy_from_user(buf, user_buf, buf_size);
+ if (err)
+ goto error;
+ buf[buf_size] = 0;
+
+ if (sscanf(buf, "%s", name) != 1) {
+ err = -EPERM;
+ goto error;
+ }
+
+ old = dev_filter;
+
+ /* Empty string or * means all active */
+ if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
+ new = NULL;
+ } else {
+ new = kmalloc(sizeof(*new), GFP_KERNEL);
+ strcpy(new->devname, name);
+ }
+
+ rcu_assign_pointer(dev_filter, new);
+ if (old)
+ call_rcu_sched(&old->rcu, free_dev_filter);
+
+ mutex_unlock(&jbd2_filter_mutex);
+ return count;
+
+error:
+ mutex_unlock(&jbd2_filter_mutex);
+ return err;
+}
+
+static ssize_t filter_op_read(struct file *filp, char __user *buffer,
+ size_t count, loff_t *ppos)
+{
+ ssize_t bcount;
+ const char *devname;
+
+ mutex_lock(&jbd2_filter_mutex);
+ if (!dev_filter)
+ devname = "*";
+ else
+ devname = dev_filter->devname;
+ bcount = simple_read_from_buffer(buffer, count, ppos,
+ devname, strlen(devname));
+ mutex_unlock(&jbd2_filter_mutex);
+ return bcount;
+}
+
+static struct file_operations jbd2_file_operations = {
+ .write = filter_op_write,
+ .read = filter_op_read,
+};
+
+static void release_filter_dev(void)
+{
+ struct rcu_dev_filter *old;
+
+ mutex_lock(&jbd2_filter_mutex);
+ module_exits = 1;
+ old = dev_filter;
+ rcu_assign_pointer(dev_filter, NULL);
+ if (old)
+ call_rcu_sched(&old->rcu, free_dev_filter);
+ mutex_unlock(&jbd2_filter_mutex);
+}
+
+static int __init filter_init(void)
+{
+ struct dentry *filter_root_dentry;
+ int err = 0;
+
+ filter_root_dentry = get_filter_root();
+ if (!filter_root_dentry) {
+ err = -ENOENT;
+ goto end;
+ }
+
+ jbd2_filter_dentry = debugfs_create_dir("jbd2", filter_root_dentry);
+
+ if (IS_ERR(jbd2_filter_dentry) || !jbd2_filter_dentry) {
+ printk(KERN_ERR "Failed to create jbd2 filter file\n");
+ err = -ENOMEM;
+ goto end;
+ }
+
+ jbd2_filter_dev_dentry = debugfs_create_file("dev", S_IWUSR,
+ jbd2_filter_dentry, NULL, &jbd2_file_operations);
+ if (IS_ERR(jbd2_filter_dentry) || !jbd2_filter_dentry) {
+ printk(KERN_ERR "Failed to create jbd2 filter file\n");
+ err = -ENOMEM;
+ goto release_filter_dentry;
+ }
+
+ goto end;
+
+release_filter_dentry:
+ debugfs_remove(jbd2_filter_dentry);
+ release_filter_dev();
+end:
+ return err;
+}
+
+static void __exit filter_exit(void)
+{
+ debugfs_remove(jbd2_filter_dev_dentry);
+ debugfs_remove(jbd2_filter_dentry);
+ release_filter_dev();
+}
+
+module_init(filter_init);
+module_exit(filter_exit);
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("JBD2 Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/kernel-trace.c
+ *
+ * kernel tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/irq.h>
+#include <trace/events/signal.h>
+#include <trace/irq.h>
+#include <trace/sched.h>
+#include <trace/timer.h>
+#include <trace/kernel.h>
+#include <trace/fault.h>
+#include <trace/events/sched.h>
+
+#include "../ltt-tracer.h"
+#include "../ltt-type-serializer.h"
+
+/*
+ * This should probably be added to s390.
+ */
+#ifdef CONFIG_S390
+static struct pt_regs *get_irq_regs(void)
+{
+ return task_pt_regs(current);
+}
+#endif
+
+/*
+ * FIXME :
+ * currently, the specialized tracepoint probes cannot call into other marker
+ * probes, such as ftrace enable/disable. Given we want them to be as fast as
+ * possible, it might not be so bad to lose this flexibility. But that means
+ * such probes would have to connect to tracepoints on their own.
+ */
+
+/* kernel_irq_entry specialized tracepoint probe */
+
+void probe_irq_entry(void *_data, unsigned int id, struct pt_regs *regs,
+ struct irqaction *action);
+
+DEFINE_MARKER_TP(kernel, irq_entry, irq_entry, probe_irq_entry,
+ "ip %lu handler %p irq_id #2u%u kernel_mode #1u%u");
+
+notrace void probe_irq_entry(void *_data, unsigned int id, struct pt_regs *regs,
+ struct irqaction *action)
+{
+ struct marker *marker;
+ struct serialize_long_long_short_char data;
+
+ if (unlikely(!regs))
+ regs = get_irq_regs();
+ if (likely(regs)) {
+ data.f1 = instruction_pointer(regs);
+ data.f4 = !user_mode(regs);
+ } else {
+ data.f1 = 0UL;
+ data.f4 = 1;
+ }
+ data.f2 = (unsigned long) (action ? action->handler : NULL);
+ data.f3 = id;
+
+ marker = &GET_MARKER(kernel, irq_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_irq_next_handler(void *_data, unsigned int id, struct irqaction *action,
+ irqreturn_t prev_ret);
+
+DEFINE_MARKER_TP(kernel, irq_next_handler, irq_next_handler,
+ probe_irq_next_handler,
+ "handler %p prev_ret #1u%u");
+
+notrace void probe_irq_next_handler(void *_data, unsigned int id, struct irqaction *action,
+ irqreturn_t prev_ret)
+{
+ struct marker *marker;
+ struct serialize_long_char data;
+
+ data.f1 = (unsigned long) (action ? action->handler : NULL);
+ data.f2 = prev_ret;
+
+ marker = &GET_MARKER(kernel, irq_next_handler);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_irq_exit specialized tracepoint probe */
+
+void probe_irq_exit(void *_data, irqreturn_t retval);
+
+DEFINE_MARKER_TP(kernel, irq_exit, irq_exit, probe_irq_exit,
+ "handled #1u%u");
+
+notrace void probe_irq_exit(void *_data, irqreturn_t retval)
+{
+ struct marker *marker;
+ unsigned char data;
+
+ data = IRQ_RETVAL(retval);
+
+ marker = &GET_MARKER(kernel, irq_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+/* kernel_softirq_entry specialized tracepoint probe */
+
+void probe_softirq_entry(void *_data, struct softirq_action *h,
+ struct softirq_action *softirq_vec);
+
+DEFINE_MARKER_TP(kernel, softirq_entry, softirq_entry,
+ probe_softirq_entry, "softirq_id #1u%lu");
+
+notrace void probe_softirq_entry(void *_data, struct softirq_action *h,
+ struct softirq_action *softirq_vec)
+{
+ struct marker *marker;
+ unsigned char data;
+
+ data = ((unsigned long)h - (unsigned long)softirq_vec) / sizeof(*h);
+
+ marker = &GET_MARKER(kernel, softirq_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+/* kernel_softirq_exit specialized tracepoint probe */
+
+void probe_softirq_exit(void *_data, struct softirq_action *h,
+ struct softirq_action *softirq_vec);
+
+DEFINE_MARKER_TP(kernel, softirq_exit, softirq_exit,
+ probe_softirq_exit, "softirq_id #1u%lu");
+
+notrace void probe_softirq_exit(void *_data, struct softirq_action *h,
+ struct softirq_action *softirq_vec)
+{
+ struct marker *marker;
+ unsigned char data;
+
+ data = ((unsigned long)h - (unsigned long)softirq_vec) / sizeof(*h);
+
+ marker = &GET_MARKER(kernel, softirq_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+/* kernel_softirq_raise specialized tracepoint probe */
+
+void probe_softirq_raise(void *_data, unsigned int nr);
+
+DEFINE_MARKER_TP(kernel, softirq_raise, softirq_raise,
+ probe_softirq_raise, "softirq_id #1u%u");
+
+notrace void probe_softirq_raise(void *_data, unsigned int nr)
+{
+ struct marker *marker;
+ unsigned char data;
+
+ data = nr;
+
+ marker = &GET_MARKER(kernel, softirq_raise);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+/* Standard probes */
+void probe_irq_tasklet_low_entry(void *_data, struct tasklet_struct *t)
+{
+ trace_mark_tp(kernel, tasklet_low_entry, irq_tasklet_low_entry,
+ probe_irq_tasklet_low_entry, "func %p data %lu",
+ t->func, t->data);
+}
+
+void probe_irq_tasklet_low_exit(void *_data, struct tasklet_struct *t)
+{
+ trace_mark_tp(kernel, tasklet_low_exit, irq_tasklet_low_exit,
+ probe_irq_tasklet_low_exit, "func %p data %lu",
+ t->func, t->data);
+}
+
+void probe_irq_tasklet_high_entry(void *_data, struct tasklet_struct *t)
+{
+ trace_mark_tp(kernel, tasklet_high_entry, irq_tasklet_high_entry,
+ probe_irq_tasklet_high_entry, "func %p data %lu",
+ t->func, t->data);
+}
+
+void probe_irq_tasklet_high_exit(void *_data, struct tasklet_struct *t)
+{
+ trace_mark_tp(kernel, tasklet_high_exit, irq_tasklet_high_exit,
+ probe_irq_tasklet_high_exit, "func %p data %lu",
+ t->func, t->data);
+}
+
+void probe_sched_kthread_stop(void *_data, struct task_struct *t)
+{
+ trace_mark_tp(kernel, kthread_stop, sched_kthread_stop,
+ probe_sched_kthread_stop, "pid %d", t->pid);
+}
+
+void probe_sched_kthread_stop_ret(void *_data, int ret)
+{
+ trace_mark_tp(kernel, kthread_stop_ret, sched_kthread_stop_ret,
+ probe_sched_kthread_stop_ret, "ret %d", ret);
+}
+
+void probe_sched_wait_task(void *_data, struct task_struct *p)
+{
+ trace_mark_tp(kernel, sched_wait_task, sched_wait_task,
+ probe_sched_wait_task, "pid %d state #2d%ld",
+ p->pid, p->state);
+}
+
+/* kernel_sched_try_wakeup specialized tracepoint probe */
+
+void probe_sched_wakeup(void *_data, struct task_struct *p, int success);
+
+DEFINE_MARKER_TP(kernel, sched_try_wakeup, sched_wakeup,
+ probe_sched_wakeup, "pid %d cpu_id %u state #2d%ld");
+
+notrace void probe_sched_wakeup(void *_data, struct task_struct *p, int success)
+{
+ struct marker *marker;
+ struct serialize_int_int_short data;
+
+ data.f1 = p->pid;
+ data.f2 = task_cpu(p);
+ data.f3 = p->state;
+
+ marker = &GET_MARKER(kernel, sched_try_wakeup);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(int));
+}
+
+void probe_sched_wakeup_new(void *_data, struct task_struct *p, int success)
+{
+ trace_mark_tp(kernel, sched_wakeup_new_task, sched_wakeup_new,
+ probe_sched_wakeup_new, "pid %d state #2d%ld cpu_id %u",
+ p->pid, p->state, task_cpu(p));
+}
+
+/* kernel_sched_schedule specialized tracepoint probe */
+
+void probe_sched_switch(void *_data, struct task_struct *prev,
+ struct task_struct *next);
+
+DEFINE_MARKER_TP(kernel, sched_schedule, sched_switch, probe_sched_switch,
+ "prev_pid %d next_pid %d prev_state #2d%ld");
+
+notrace void probe_sched_switch(void *_data, struct task_struct *prev,
+ struct task_struct *next)
+{
+ struct marker *marker;
+ struct serialize_int_int_short data;
+
+ data.f1 = prev->pid;
+ data.f2 = next->pid;
+ data.f3 = prev->state;
+
+ marker = &GET_MARKER(kernel, sched_schedule);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(int));
+}
+
+void probe_sched_migrate_task(void *_data, struct task_struct *p, int dest_cpu)
+{
+ trace_mark_tp(kernel, sched_migrate_task, sched_migrate_task,
+ probe_sched_migrate_task, "pid %d state #2d%ld dest_cpu %d",
+ p->pid, p->state, dest_cpu);
+}
+
+void probe_sched_signal_send(void *_data, int sig, struct siginfo *info, struct task_struct *t)
+{
+ trace_mark_tp(kernel, send_signal, signal_generate,
+ probe_sched_signal_send, "pid %d signal %d", t->pid, sig);
+}
+
+void probe_sched_process_free(void *_data, struct task_struct *p)
+{
+ trace_mark_tp(kernel, process_free, sched_process_free,
+ probe_sched_process_free, "pid %d", p->pid);
+}
+
+void probe_sched_process_exit(void *_data, struct task_struct *p)
+{
+ trace_mark_tp(kernel, process_exit, sched_process_exit,
+ probe_sched_process_exit, "pid %d", p->pid);
+}
+
+void probe_sched_process_wait(void *_data, struct pid *pid)
+{
+ trace_mark_tp(kernel, process_wait, sched_process_wait,
+ probe_sched_process_wait, "pid %d", pid_nr(pid));
+}
+
+void probe_sched_process_fork(void *_data, struct task_struct *parent,
+ struct task_struct *child)
+{
+ trace_mark_tp(kernel, process_fork, sched_process_fork,
+ probe_sched_process_fork,
+ "parent_pid %d child_pid %d child_tgid %d",
+ parent->pid, child->pid, child->tgid);
+}
+
+void probe_sched_kthread_create(void *_data, void *fn, int pid)
+{
+ trace_mark_tp(kernel, kthread_create, sched_kthread_create,
+ probe_sched_kthread_create,
+ "fn %p pid %d", fn, pid);
+}
+
+void probe_timer_itimer_expired(void *_data, struct signal_struct *sig)
+{
+ trace_mark_tp(kernel, timer_itimer_expired, timer_itimer_expired,
+ probe_timer_itimer_expired, "pid %d",
+ pid_nr(sig->leader_pid));
+}
+
+void probe_timer_itimer_set(void *_data, int which, struct itimerval *value)
+{
+ trace_mark_tp(kernel, timer_itimer_set,
+ timer_itimer_set, probe_timer_itimer_set,
+ "which %d interval_sec %ld interval_usec %ld "
+ "value_sec %ld value_usec %ld",
+ which,
+ value->it_interval.tv_sec,
+ value->it_interval.tv_usec,
+ value->it_value.tv_sec,
+ value->it_value.tv_usec);
+}
+
+/* kernel_timer_set specialized tracepoint probe */
+
+void probe_timer_set(void *_data, struct timer_list *timer);
+
+DEFINE_MARKER_TP(kernel, timer_set, timer_set, probe_timer_set,
+ "expires %lu function %p data %lu");
+
+notrace void probe_timer_set(void *_data, struct timer_list *timer)
+{
+ struct marker *marker;
+ struct serialize_long_long_long data;
+
+ data.f1 = timer->expires;
+ data.f2 = (unsigned long)timer->function;
+ data.f3 = timer->data;
+
+ marker = &GET_MARKER(kernel, timer_set);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_timer_update_time(void *_data, struct timespec *_xtime,
+ struct timespec *_wall_to_monotonic)
+{
+ trace_mark_tp(kernel, timer_update_time, timer_update_time,
+ probe_timer_update_time,
+ "jiffies #8u%llu xtime_sec %ld xtime_nsec %ld "
+ "walltomonotonic_sec %ld walltomonotonic_nsec %ld",
+ (unsigned long long)jiffies_64, _xtime->tv_sec, _xtime->tv_nsec,
+ _wall_to_monotonic->tv_sec, _wall_to_monotonic->tv_nsec);
+}
+
+void probe_timer_timeout(void *_data, struct task_struct *p)
+{
+ trace_mark_tp(kernel, timer_timeout, timer_timeout,
+ probe_timer_timeout, "pid %d", p->pid);
+}
+
+void probe_kernel_printk(void *_data, unsigned long retaddr)
+{
+ trace_mark_tp(kernel, printk, kernel_printk,
+ probe_kernel_printk, "ip 0x%lX", retaddr);
+}
+
+void probe_kernel_vprintk(void *_data, unsigned long retaddr, char *buf, int len)
+{
+ if (len > 0) {
+ unsigned int loglevel;
+ int mark_len;
+ char *mark_buf;
+ char saved_char;
+
+ if (buf[0] == '<' && buf[1] >= '0' &&
+ buf[1] <= '7' && buf[2] == '>') {
+ loglevel = buf[1] - '0';
+ mark_buf = &buf[3];
+ mark_len = len - 3;
+ } else {
+ loglevel = default_message_loglevel;
+ mark_buf = buf;
+ mark_len = len;
+ }
+ if (mark_buf[mark_len - 1] == '\n')
+ mark_len--;
+ saved_char = mark_buf[mark_len];
+ mark_buf[mark_len] = '\0';
+ trace_mark_tp(kernel, vprintk, kernel_vprintk,
+ probe_kernel_vprintk,
+ "loglevel #1u%u string %s ip 0x%lX",
+ loglevel, mark_buf, retaddr);
+ mark_buf[mark_len] = saved_char;
+ }
+}
+
+#ifdef CONFIG_MODULES
+void probe_kernel_module_free(void *_data, struct module *mod)
+{
+ trace_mark_tp(kernel, module_free, kernel_module_free,
+ probe_kernel_module_free, "name %s", mod->name);
+}
+
+void probe_kernel_module_load(void *_data, struct module *mod)
+{
+ trace_mark_tp(kernel, module_load, kernel_module_load,
+ probe_kernel_module_load, "name %s", mod->name);
+}
+#endif
+
+void probe_kernel_panic(void *_data, const char *fmt, va_list args)
+{
+ char info[64];
+ vsnprintf(info, sizeof(info), fmt, args);
+ trace_mark_tp(kernel, panic, kernel_panic, probe_kernel_panic,
+ "info %s", info);
+}
+
+void probe_kernel_kernel_kexec(void *_data, struct kimage *image)
+{
+ trace_mark_tp(kernel, kernel_kexec, kernel_kernel_kexec,
+ probe_kernel_kernel_kexec, "image %p", image);
+}
+
+void probe_kernel_crash_kexec(void *_data, struct kimage *image, struct pt_regs *regs)
+{
+ trace_mark_tp(kernel, crash_kexec, kernel_crash_kexec,
+ probe_kernel_crash_kexec, "image %p ip %p", image,
+ regs ? (void *)instruction_pointer(regs) : NULL);
+}
+
+/* kernel_page_fault_entry specialized tracepoint probe */
+
+void probe_kernel_page_fault_entry(void *_data, struct pt_regs *regs, int trapnr,
+ struct mm_struct *mm, struct vm_area_struct *vma,
+ unsigned long address, int write_access);
+
+DEFINE_MARKER_TP(kernel, page_fault_entry, page_fault_entry,
+ probe_kernel_page_fault_entry,
+ "ip #p%lu address #p%lu trap_id #2u%u write_access #1u%u");
+
+notrace void probe_kernel_page_fault_entry(void *_data, struct pt_regs *regs, int trapnr,
+ struct mm_struct *mm, struct vm_area_struct *vma,
+ unsigned long address, int write_access)
+{
+ struct marker *marker;
+ struct serialize_long_long_short_char data;
+
+ if (likely(regs))
+ data.f1 = instruction_pointer(regs);
+ else
+ data.f1 = 0UL;
+ data.f2 = address;
+ data.f3 = (unsigned short)trapnr;
+ data.f4 = (unsigned char)!!write_access;
+
+ marker = &GET_MARKER(kernel, page_fault_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_page_fault_exit specialized tracepoint probe */
+
+void probe_kernel_page_fault_exit(void *_data, int res);
+
+DEFINE_MARKER_TP(kernel, page_fault_exit, page_fault_exit,
+ probe_kernel_page_fault_exit,
+ "res %d");
+
+notrace void probe_kernel_page_fault_exit(void *_data, int res)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(kernel, page_fault_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &res, sizeof(res), sizeof(res));
+}
+
+/* kernel_page_fault_nosem_entry specialized tracepoint probe */
+
+void probe_kernel_page_fault_nosem_entry(void *_data, struct pt_regs *regs,
+ int trapnr, unsigned long address);
+
+DEFINE_MARKER_TP(kernel, page_fault_nosem_entry, page_fault_nosem_entry,
+ probe_kernel_page_fault_nosem_entry,
+ "ip #p%lu address #p%lu trap_id #2u%u");
+
+notrace void probe_kernel_page_fault_nosem_entry(void *_data, struct pt_regs *regs,
+ int trapnr, unsigned long address)
+{
+ struct marker *marker;
+ struct serialize_long_long_short data;
+
+ if (likely(regs))
+ data.f1 = instruction_pointer(regs);
+ else
+ data.f1 = 0UL;
+ data.f2 = address;
+ data.f3 = (unsigned short)trapnr;
+
+ marker = &GET_MARKER(kernel, page_fault_nosem_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_page_fault_nosem_exit specialized tracepoint probe */
+
+void probe_kernel_page_fault_nosem_exit(void *_data, int res);
+
+DEFINE_MARKER_TP(kernel, page_fault_nosem_exit, page_fault_nosem_exit,
+ probe_kernel_page_fault_nosem_exit,
+ MARK_NOARGS);
+
+notrace void probe_kernel_page_fault_nosem_exit(void *_data, int res)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(kernel, page_fault_nosem_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ NULL, 0, 0);
+}
+
+/* kernel_page_fault_get_user_entry specialized tracepoint probe */
+
+void probe_kernel_page_fault_get_user_entry(void *_data, struct mm_struct *mm,
+ struct vm_area_struct *vma, unsigned long address, int write_access);
+
+DEFINE_MARKER_TP(kernel, page_fault_get_user_entry, page_fault_get_user_entry,
+ probe_kernel_page_fault_get_user_entry,
+ "address #p%lu write_access #1u%u");
+
+notrace void probe_kernel_page_fault_get_user_entry(void *_data, struct mm_struct *mm,
+ struct vm_area_struct *vma, unsigned long address, int write_access)
+{
+ struct marker *marker;
+ struct serialize_long_char data;
+
+ data.f1 = address;
+ data.f2 = (unsigned char)!!write_access;
+
+ marker = &GET_MARKER(kernel, page_fault_get_user_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_page_fault_get_user_exit specialized tracepoint probe */
+
+void probe_kernel_page_fault_get_user_exit(void *_data, int res);
+
+DEFINE_MARKER_TP(kernel, page_fault_get_user_exit, page_fault_get_user_exit,
+ probe_kernel_page_fault_get_user_exit,
+ "res %d");
+
+notrace void probe_kernel_page_fault_get_user_exit(void *_data, int res)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(kernel, page_fault_get_user_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &res, sizeof(res), sizeof(res));
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("kernel Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/lockdep-trace.c
+ *
+ * lockdep tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/lockdep.h>
+#include <trace/lockdep.h>
+
+void probe_lockdep_hardirqs_on(void *data, unsigned long retaddr)
+{
+ trace_mark_tp(lockdep, hardirqs_on, lockdep_hardirqs_on,
+ probe_lockdep_hardirqs_on, "retaddr 0x%lX", retaddr);
+}
+
+void probe_lockdep_hardirqs_off(void *data, unsigned long retaddr)
+{
+ trace_mark_tp(lockdep, hardirqs_off, lockdep_hardirqs_off,
+ probe_lockdep_hardirqs_off, "retaddr 0x%lX", retaddr);
+}
+
+void probe_lockdep_softirqs_on(void *data, unsigned long retaddr)
+{
+ trace_mark_tp(lockdep, softirqs_on, lockdep_softirqs_on,
+ probe_lockdep_softirqs_on, "retaddr 0x%lX", retaddr);
+}
+
+void probe_lockdep_softirqs_off(void *data, unsigned long retaddr)
+{
+ trace_mark_tp(lockdep, softirqs_off, lockdep_softirqs_off,
+ probe_lockdep_softirqs_off, "retaddr 0x%lX", retaddr);
+}
+
+void probe_lockdep_lock_acquire(void *data, unsigned long retaddr,
+ unsigned int subclass, struct lockdep_map *lock, int trylock,
+ int read, int hardirqs_off)
+{
+ trace_mark_tp(lockdep, lock_acquire, lockdep_lock_acquire,
+ probe_lockdep_lock_acquire,
+ "retaddr 0x%lX subclass %u lock %p trylock %d read %d "
+ "hardirqs_off %d",
+ retaddr, subclass, lock, trylock, read, hardirqs_off);
+}
+
+void probe_lockdep_lock_release(void *data, unsigned long retaddr,
+ struct lockdep_map *lock, int nested)
+{
+ trace_mark_tp(lockdep, lock_release, lockdep_lock_release,
+ probe_lockdep_lock_release,
+ "retaddr 0x%lX lock %p nested %d",
+ retaddr, lock, nested);
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("lockdep Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/mm-trace.c
+ *
+ * MM tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/swap.h>
+
+#include <asm/pgtable.h>
+#include <asm/tlbflush.h>
+#include <linux/swapops.h>
+#include <trace/page_alloc.h>
+#include <trace/filemap.h>
+#include <trace/swap.h>
+#include <trace/hugetlb.h>
+
+#include "../ltt-type-serializer.h"
+
+void probe_wait_on_page_start(void *_data, struct page *page, int bit_nr)
+{
+ trace_mark_tp(mm, wait_on_page_start, wait_on_page_start,
+ probe_wait_on_page_start, "pfn %lu bit_nr %d",
+ page_to_pfn(page), bit_nr);
+}
+
+void probe_wait_on_page_end(void *_data, struct page *page, int bit_nr)
+{
+ trace_mark_tp(mm, wait_on_page_end, wait_on_page_end,
+ probe_wait_on_page_end, "pfn %lu bit_nr %d",
+ page_to_pfn(page), bit_nr);
+}
+
+void probe_hugetlb_page_free(void *_data, struct page *page)
+{
+ trace_mark_tp(mm, huge_page_free, hugetlb_page_free,
+ probe_hugetlb_page_free, "pfn %lu", page_to_pfn(page));
+}
+
+void probe_hugetlb_page_alloc(void *_data, struct page *page)
+{
+ if (page)
+ trace_mark_tp(mm, huge_page_alloc, hugetlb_page_alloc,
+ probe_hugetlb_page_alloc, "pfn %lu", page_to_pfn(page));
+}
+
+/* mm_page_free specialized tracepoint probe */
+
+void probe_page_free(void *_data, struct page *page, unsigned int order);
+
+DEFINE_MARKER_TP(mm, page_free, page_free, probe_page_free,
+ "pfn %lu order %u");
+
+notrace void probe_page_free(void *_data, struct page *page, unsigned int order)
+{
+ struct marker *marker;
+ struct serialize_long_int data;
+
+ data.f1 = page_to_pfn(page);
+ data.f2 = order;
+
+ marker = &GET_MARKER(mm, page_free);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* mm_page_alloc specialized tracepoint probe */
+
+void probe_page_alloc(void *_data, struct page *page, unsigned int order);
+
+DEFINE_MARKER_TP(mm, page_alloc, page_alloc, probe_page_alloc,
+ "pfn %lu order %u");
+
+notrace void probe_page_alloc(void *_data, struct page *page, unsigned int order)
+{
+ struct marker *marker;
+ struct serialize_long_int data;
+
+ if (unlikely(!page))
+ return;
+
+ data.f1 = page_to_pfn(page);
+ data.f2 = order;
+
+ marker = &GET_MARKER(mm, page_alloc);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+#ifdef CONFIG_SWAP
+void probe_swap_in(void *_data, struct page *page, swp_entry_t entry)
+{
+ trace_mark_tp(mm, swap_in, swap_in, probe_swap_in,
+ "pfn %lu filp %p offset %lu",
+ page_to_pfn(page),
+ get_swap_info_struct(swp_type(entry))->swap_file,
+ swp_offset(entry));
+}
+
+void probe_swap_out(void *_data, struct page *page)
+{
+ trace_mark_tp(mm, swap_out, swap_out, probe_swap_out,
+ "pfn %lu filp %p offset %lu",
+ page_to_pfn(page),
+ get_swap_info_struct(swp_type(
+ page_swp_entry(page)))->swap_file,
+ swp_offset(page_swp_entry(page)));
+}
+
+void probe_swap_file_close(void *_data, struct file *file)
+{
+ trace_mark_tp(mm, swap_file_close, swap_file_close,
+ probe_swap_file_close, "filp %p", file);
+}
+
+void probe_swap_file_open(void *_data, struct file *file, char *filename)
+{
+ trace_mark_tp(mm, swap_file_open, swap_file_open,
+ probe_swap_file_open, "filp %p filename %s",
+ file, filename);
+}
+#endif
+
+void probe_add_to_page_cache(void *_data, struct address_space *mapping, pgoff_t offset)
+{
+ trace_mark_tp(mm, add_to_page_cache, add_to_page_cache,
+ probe_add_to_page_cache,
+ "inode %lu sdev %u",
+ mapping->host->i_ino, mapping->host->i_sb->s_dev);
+}
+
+void probe_remove_from_page_cache(void *_data, struct address_space *mapping)
+{
+ trace_mark_tp(mm, remove_from_page_cache, remove_from_page_cache,
+ probe_remove_from_page_cache,
+ "inode %lu sdev %u",
+ mapping->host->i_ino, mapping->host->i_sb->s_dev);
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("MM Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/net-extended-trace.c
+ *
+ * Net tracepoint extended probes.
+ *
+ * These probes record many header fields from TCP and UDP messages. Here are
+ * the consequences of this:
+ * 1) it allows analyzing network traffic to provide some pcap-like
+ * functionality within LTTng
+ * 2) it allows offline synchronization of a group of concurrent traces
+ * recorded on different nodes
+ * 3) it increases tracing overhead
+ *
+ * You can leave out these probes or not activate them if you are not
+ * especially interested in the details of network traffic and do not wish to
+ * synchronize distributed traces.
+ *
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/in_route.h>
+#include <linux/ip.h>
+#include <linux/module.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <net/route.h>
+#include <trace/net.h>
+
+#include "../ltt-type-serializer.h"
+
+void probe_net_dev_xmit_extended(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, dev_xmit_extended, net_dev_xmit,
+ probe_net_dev_xmit_extended, "skb 0x%lX network_protocol #n2u%hu "
+ "transport_protocol #1u%u saddr #n4u%lu daddr #n4u%lu "
+ "tot_len #n2u%hu ihl #1u%u source #n2u%hu dest #n2u%hu seq #n4u%lu "
+ "ack_seq #n4u%lu doff #1u%u ack #1u%u rst #1u%u syn #1u%u fin #1u%u");
+
+notrace void probe_net_dev_xmit_extended(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+ struct serialize_l214421224411111 data;
+ struct iphdr *iph = ip_hdr(skb);
+ struct tcphdr *th = tcp_hdr(skb);
+
+ data.f1 = (unsigned long)skb;
+ data.f2 = skb->protocol;
+
+ if (ntohs(skb->protocol) == ETH_P_IP) {
+ data.f3 = ip_hdr(skb)->protocol;
+ data.f4 = iph->saddr;
+ data.f5 = iph->daddr;
+ data.f6 = iph->tot_len;
+ data.f7 = iph->ihl;
+
+ if (data.f3 == IPPROTO_TCP) {
+ data.f8 = th->source;
+ data.f9 = th->dest;
+ data.f10 = th->seq;
+ data.f11 = th->ack_seq;
+ data.f12 = th->doff;
+ data.f13 = th->ack;
+ data.f14 = th->rst;
+ data.f15 = th->syn;
+ data.f16 = th->fin;
+ }
+ }
+
+ marker = &GET_MARKER(net, dev_xmit_extended);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_tcpv4_rcv_extended(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, tcpv4_rcv_extended, net_tcpv4_rcv,
+ probe_tcpv4_rcv_extended, "skb 0x%lX saddr #n4u%lu daddr #n4u%lu "
+ "tot_len #n2u%hu ihl #1u%u source #n2u%hu dest #n2u%hu seq #n4u%lu "
+ "ack_seq #n4u%lu doff #1u%u ack #1u%u rst #1u%u syn #1u%u fin #1u%u");
+
+notrace void probe_tcpv4_rcv_extended(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+ struct serialize_l4421224411111 data;
+ struct iphdr *iph = ip_hdr(skb);
+ struct tcphdr *th = tcp_hdr(skb);
+
+ data.f1 = (unsigned long)skb;
+ data.f2 = iph->saddr;
+ data.f3 = iph->daddr;
+ data.f4 = iph->tot_len;
+ data.f5 = iph->ihl;
+ data.f6 = th->source;
+ data.f7 = th->dest;
+ data.f8 = th->seq;
+ data.f9 = th->ack_seq;
+ data.f10 = th->doff;
+ data.f11 = th->ack;
+ data.f12 = th->rst;
+ data.f13 = th->syn;
+ data.f14 = th->fin;
+
+ marker = &GET_MARKER(net, tcpv4_rcv_extended);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_udpv4_rcv_extended(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, udpv4_rcv_extended, net_udpv4_rcv,
+ probe_udpv4_rcv_extended, "skb 0x%lX saddr #n4u%lu daddr #n4u%lu "
+ "unicast #1u%u ulen #n2u%hu source #n2u%hu dest #n2u%hu "
+ "data_start #8u%lx");
+
+notrace void probe_udpv4_rcv_extended(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+ struct serialize_l4412228 data;
+ struct iphdr *iph = ip_hdr(skb);
+ struct rtable *rt = skb_rtable(skb);
+ struct udphdr *uh = udp_hdr(skb);
+
+ data.f1 = (unsigned long)skb;
+ data.f2 = iph->saddr;
+ data.f3 = iph->daddr;
+ data.f4 = rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST) ? 0 : 1;
+ data.f5 = uh->len;
+ data.f6 = uh->source;
+ data.f7 = uh->dest;
+ /* UDP header has not been pulled from skb->data, read the first 8
+ * bytes of UDP data if they are not in a fragment*/
+ data.f8 = 0;
+ if (skb_headlen(skb) >= sizeof(struct udphdr) + 8)
+ data.f8 = *(unsigned long long *)(skb->data + sizeof(*uh));
+ else if (skb_headlen(skb) >= sizeof(struct udphdr))
+ memcpy(&data.f8, skb->data + sizeof(struct udphdr),
+ skb_headlen(skb) - sizeof(struct udphdr));
+
+ marker = &GET_MARKER(net, udpv4_rcv_extended);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(unsigned long long));
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Benjamin Poirier");
+MODULE_DESCRIPTION("Net Tracepoint Extended Probes");
--- /dev/null
+/*
+ * ltt/probes/net-trace.c
+ *
+ * Net tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <linux/netdevice.h>
+#include <linux/string.h>
+#include <trace/net.h>
+#include <trace/ipv4.h>
+#include <trace/ipv6.h>
+#include <trace/socket.h>
+
+#include "../ltt-type-serializer.h"
+
+void probe_net_dev_xmit(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, dev_xmit, net_dev_xmit, probe_net_dev_xmit,
+ "skb %p protocol #n2u%hu");
+
+notrace void probe_net_dev_xmit(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+ struct serialize_long_short data;
+
+ data.f1 = (unsigned long)skb;
+ data.f2 = skb->protocol;
+
+ marker = &GET_MARKER(net, dev_xmit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_net_dev_receive(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, dev_receive, net_dev_receive, probe_net_dev_receive,
+ "skb %p protocol #n2u%hu");
+
+notrace void probe_net_dev_receive(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+ struct serialize_long_short data;
+
+ data.f1 = (unsigned long)skb;
+ data.f2 = skb->protocol;
+
+ marker = &GET_MARKER(net, dev_receive);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+void probe_ipv4_addr_add(void *_data, struct in_ifaddr *ifa)
+{
+ trace_mark_tp(netif_state, insert_ifa_ipv4, ipv4_addr_add,
+ probe_ipv4_addr_add, "label %s address #4u%u",
+ ifa->ifa_label, (unsigned int)ifa->ifa_address);
+}
+
+void probe_ipv4_addr_del(void *_data, struct in_ifaddr *ifa)
+{
+ trace_mark_tp(netif_state, del_ifa_ipv4, ipv4_addr_del,
+ probe_ipv4_addr_del, "label %s address #4u%u",
+ ifa->ifa_label, (unsigned int)ifa->ifa_address);
+}
+
+void probe_ipv6_addr_add(void *_data, struct inet6_ifaddr *ifa)
+{
+ __u8 *addr = ifa->addr.s6_addr;
+
+ trace_mark_tp(netif_state, insert_ifa_ipv6, ipv6_addr_add,
+ probe_ipv6_addr_add,
+ "label %s "
+ "a15 #1x%c a14 #1x%c a13 #1x%c a12 #1x%c "
+ "a11 #1x%c a10 #1x%c a9 #1x%c a8 #1x%c "
+ "a7 #1x%c a6 #1x%c a5 #1x%c a4 #1x%c "
+ "a3 #1x%c a2 #1x%c a1 #1x%c a0 #1x%c",
+ ifa->idev->dev->name,
+ addr[15], addr[14], addr[13], addr[12],
+ addr[11], addr[10], addr[9], addr[8],
+ addr[7], addr[6], addr[5], addr[4],
+ addr[3], addr[2], addr[1], addr[0]);
+}
+
+void probe_ipv6_addr_del(void *_data, struct inet6_ifaddr *ifa)
+{
+ __u8 *addr = ifa->addr.s6_addr;
+
+ trace_mark_tp(netif_state, insert_ifa_ipv6, ipv6_addr_del,
+ probe_ipv6_addr_del,
+ "label %s "
+ "a15 #1x%c a14 #1x%c a13 #1x%c a12 #1x%c "
+ "a11 #1x%c a10 #1x%c a9 #1x%c a8 #1x%c "
+ "a7 #1x%c a6 #1x%c a5 #1x%c a4 #1x%c "
+ "a3 #1x%c a2 #1x%c a1 #1x%c a0 #1x%c",
+ ifa->idev->dev->name,
+ addr[15], addr[14], addr[13], addr[12],
+ addr[11], addr[10], addr[9], addr[8],
+ addr[7], addr[6], addr[5], addr[4],
+ addr[3], addr[2], addr[1], addr[0]);
+}
+
+void probe_socket_create(void *_data, int family, int type, int protocol,
+ struct socket *sock, int ret)
+{
+ trace_mark_tp(net, socket_create, socket_create, probe_socket_create,
+ "family %d type %d protocol %d sock %p ret %d",
+ family, type, protocol, sock, ret);
+}
+
+void probe_socket_bind(void *_data, int fd, struct sockaddr __user *umyaddr, int addrlen,
+ int ret)
+{
+ trace_mark_tp(net, socket_bind, socket_bind, probe_socket_bind,
+ "fd %d umyaddr %p addrlen %d ret %d",
+ fd, umyaddr, addrlen, ret);
+}
+
+void probe_socket_connect(void *_data, int fd, struct sockaddr __user *uservaddr,
+ int addrlen, int ret)
+{
+ trace_mark_tp(net, socket_connect, socket_connect, probe_socket_connect,
+ "fd %d uservaddr %p addrlen %d ret %d",
+ fd, uservaddr, addrlen, ret);
+}
+
+void probe_socket_listen(void *_data, int fd, int backlog, int ret)
+{
+ trace_mark_tp(net, socket_listen, socket_listen, probe_socket_listen,
+ "fd %d backlog %d ret %d",
+ fd, backlog, ret);
+}
+
+void probe_socket_accept(void *_data, int fd, struct sockaddr __user *upeer_sockaddr,
+ int __user *upeer_addrlen, int flags, int ret)
+{
+ trace_mark_tp(net, socket_accept, socket_accept, probe_socket_accept,
+ "fd %d upeer_sockaddr %p upeer_addrlen %p flags %d ret %d",
+ fd, upeer_sockaddr, upeer_addrlen, flags, ret);
+}
+
+void probe_socket_getsockname(void *_data, int fd, struct sockaddr __user *usockaddr,
+ int __user *usockaddr_len, int ret)
+{
+ trace_mark_tp(net, socket_getsockname, socket_getsockname,
+ probe_socket_getsockname,
+ "fd %d usockaddr %p usockaddr_len %p ret %d",
+ fd, usockaddr, usockaddr_len, ret);
+}
+
+void probe_socket_getpeername(void *_data, int fd, struct sockaddr __user *usockaddr,
+ int __user *usockaddr_len, int ret)
+{
+ trace_mark_tp(net, socket_getpeername, socket_getpeername,
+ probe_socket_getpeername,
+ "fd %d usockaddr %p usockaddr_len %p ret %d",
+ fd, usockaddr, usockaddr_len, ret);
+}
+
+void probe_socket_socketpair(void *_data, int family, int type, int protocol,
+ int __user *usockvec, int ret)
+{
+ trace_mark_tp(net, socket_socketpair, socket_socketpair,
+ probe_socket_socketpair,
+ "family %d type %d protocol %d usockvec %p ret %d",
+ family, type, protocol, usockvec, ret);
+}
+
+void probe_socket_sendmsg(void *_data, struct socket *sock, struct msghdr *msg, size_t size,
+ int ret);
+
+DEFINE_MARKER_TP(net, socket_sendmsg, net_socket_sendmsg,
+ probe_socket_sendmsg,
+ "sock %p msg %p size %zu ret %d");
+
+notrace void probe_socket_sendmsg(void *_data, struct socket *sock, struct msghdr *msg,
+ size_t size, int ret)
+{
+ struct marker *marker;
+ struct serialize_long_long_sizet_int data;
+
+ data.f1 = (unsigned long)sock;
+ data.f2 = (unsigned long)msg;
+ data.f3 = size;
+ data.f4 = ret;
+
+ marker = &GET_MARKER(net, socket_sendmsg);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(size_t));
+}
+
+void probe_socket_recvmsg(void *_data, struct socket *sock, struct msghdr *msg, size_t size,
+ int flags, int ret);
+
+DEFINE_MARKER_TP(net, socket_recvmsg, net_socket_recvmsg,
+ probe_socket_recvmsg,
+ "sock %p msg %p size %zu flags %d ret %d");
+
+notrace void probe_socket_recvmsg(void *_data, struct socket *sock, struct msghdr *msg,
+ size_t size, int flags, int ret)
+{
+ struct marker *marker;
+ struct serialize_long_long_sizet_int_int data;
+
+ data.f1 = (unsigned long)sock;
+ data.f2 = (unsigned long)msg;
+ data.f3 = size;
+ data.f4 = flags;
+ data.f5 = ret;
+
+ marker = &GET_MARKER(net, socket_recvmsg);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(size_t));
+}
+
+void probe_socket_setsockopt(void *_data, int fd, int level, int optname,
+ char __user *optval, int optlen, int ret)
+{
+ trace_mark_tp(net, socket_setsockopt, socket_setsockopt,
+ probe_socket_setsockopt,
+ "fd %d level %d optname %d optval %p optlen %d ret %d",
+ fd, level, optname, optval, optlen, ret);
+}
+
+void probe_socket_getsockopt(void *_data, int fd, int level, int optname,
+ char __user *optval, int __user *optlen, int ret)
+{
+ trace_mark_tp(net, socket_getsockopt, socket_getsockopt,
+ probe_socket_getsockopt,
+ "fd %d level %d optname %d optval %p optlen %p ret %d",
+ fd, level, optname, optval, optlen, ret);
+}
+
+void probe_socket_shutdown(void *_data, int fd, int how, int ret)
+{
+ trace_mark_tp(net, socket_shutdown, socket_shutdown,
+ probe_socket_shutdown,
+ "fd %d how %d ret %d",
+ fd, how, ret);
+}
+
+void probe_socket_call(void *_data, int call, unsigned long a0)
+{
+ trace_mark_tp(net, socket_call, socket_call, probe_socket_call,
+ "call %d a0 %lu", call, a0);
+}
+
+void probe_tcpv4_rcv(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, tcpv4_rcv, net_tcpv4_rcv, probe_tcpv4_rcv,
+ "skb %p");
+
+notrace void probe_tcpv4_rcv(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(net, tcpv4_rcv);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &skb, sizeof(skb), sizeof(skb));
+}
+
+void probe_udpv4_rcv(void *_data, struct sk_buff *skb);
+
+DEFINE_MARKER_TP(net, udpv4_rcv, net_udpv4_rcv, probe_udpv4_rcv,
+ "skb %p");
+
+notrace void probe_udpv4_rcv(void *_data, struct sk_buff *skb)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(net, udpv4_rcv);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &skb, sizeof(skb), sizeof(skb));
+}
+
+#ifdef CONFIG_NETPOLL
+void probe_net_napi_schedule(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_schedule, net_napi_schedule,
+ probe_net_napi_schedule,
+ "napi_struct %p name %s");
+
+notrace void probe_net_napi_schedule(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ struct serialize_long_ifname data;
+ size_t data_len = 0;
+
+ data.f1 = (unsigned long)n;
+ data_len += sizeof(data.f1);
+ /* No need to align for strings */
+ strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
+ data_len += strlen(data.f2) + 1;
+
+ marker = &GET_MARKER(net, napi_schedule);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, data_len, sizeof(long));
+}
+
+void probe_net_napi_poll(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_poll, net_napi_poll,
+ probe_net_napi_poll,
+ "napi_struct %p name %s");
+
+notrace void probe_net_napi_poll(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ struct serialize_long_ifname data;
+ size_t data_len = 0;
+
+ data.f1 = (unsigned long)n;
+ data_len += sizeof(data.f1);
+ /* No need to align for strings */
+ strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
+ data_len += strlen(data.f2) + 1;
+
+ marker = &GET_MARKER(net, napi_poll);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, data_len, sizeof(long));
+}
+
+void probe_net_napi_complete(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_complete, net_napi_complete,
+ probe_net_napi_complete,
+ "napi_struct %p name %s");
+
+notrace void probe_net_napi_complete(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ struct serialize_long_ifname data;
+ size_t data_len = 0;
+
+ data.f1 = (unsigned long)n;
+ data_len += sizeof(data.f1);
+ /* No need to align for strings */
+ strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
+ data_len += strlen(data.f2) + 1;
+
+ marker = &GET_MARKER(net, napi_complete);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, data_len, sizeof(long));
+}
+#else /* !CONFIG_NETPOLL */
+void probe_net_napi_schedule(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_schedule, net_napi_schedule,
+ probe_net_napi_schedule,
+ "napi_struct %p");
+
+notrace void probe_net_napi_schedule(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ unsigned long data;
+
+ data = (unsigned long)n;
+
+ marker = &GET_MARKER(net, napi_schedule);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+void probe_net_napi_poll(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_poll, net_napi_poll,
+ probe_net_napi_poll,
+ "napi_struct %p");
+
+notrace void probe_net_napi_poll(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ unsigned long data;
+
+ data = (unsigned long)n;
+
+ marker = &GET_MARKER(net, napi_poll);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+
+void probe_net_napi_complete(void *_data, struct napi_struct *n);
+
+DEFINE_MARKER_TP(net, napi_complete, net_napi_complete,
+ probe_net_napi_complete,
+ "napi_struct %p");
+
+notrace void probe_net_napi_complete(void *_data, struct napi_struct *n)
+{
+ struct marker *marker;
+ unsigned long data;
+
+ data = (unsigned long)n;
+
+ marker = &GET_MARKER(net, napi_complete);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, sizeof(data), sizeof(data));
+}
+#endif
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Net Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/pm-trace.c
+ *
+ * Power Management tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <trace/pm.h>
+
+void probe_pm_idle_entry(void *_data)
+{
+ trace_mark_tp(pm, idle_entry, pm_idle_entry,
+ probe_pm_idle_entry, "irqstate #1%d",
+ irqs_disabled());
+}
+
+void probe_pm_idle_exit(void *_data)
+{
+ trace_mark_tp(pm, idle_exit, pm_idle_exit,
+ probe_pm_idle_exit, "irqstate #1%d",
+ irqs_disabled());
+}
+
+void probe_pm_suspend_entry(void *_data)
+{
+ trace_mark_tp(pm, suspend_entry, pm_suspend_entry,
+ probe_pm_suspend_entry, "irqstate #1%d",
+ irqs_disabled());
+}
+
+void probe_pm_suspend_exit(void *_data)
+{
+ trace_mark_tp(pm, suspend_exit, pm_suspend_exit,
+ probe_pm_suspend_exit, "irqstate #1%d",
+ irqs_disabled());
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Power Management Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/rcu-trace.c
+ *
+ * RCU tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <trace/rcu.h>
+
+#ifdef CONFIG_TREE_RCU
+void probe_rcu_tree_callback(void *data, struct rcu_head *head)
+{
+ trace_mark_tp(rcu, tree_callback, rcu_tree_callback,
+ probe_rcu_tree_callback, "func %p", head->func);
+}
+
+void probe_rcu_tree_call_rcu(void *data, struct rcu_head *head, unsigned long ip)
+{
+ trace_mark_tp(rcu, tree_call_rcu, rcu_tree_call_rcu,
+ probe_rcu_tree_call_rcu, "func %p ip 0x%lX", head->func, ip);
+}
+
+void probe_rcu_tree_call_rcu_bh(void *data, struct rcu_head *head, unsigned long ip)
+{
+ trace_mark_tp(rcu, tree_call_rcu_bh, rcu_tree_call_rcu_bh,
+ probe_rcu_tree_call_rcu_bh, "func %p ip 0x%lX",
+ head->func, ip);
+}
+#endif
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("RCU Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/syscall-trace.c
+ *
+ * System call tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <trace/syscall.h>
+
+#include "../ltt-type-serializer.h"
+
+
+/* kernel_syscall_entry specialized tracepoint probe */
+
+void probe_syscall_entry(void *_data, struct pt_regs *regs, long id);
+
+DEFINE_MARKER_TP(kernel, syscall_entry, syscall_entry,
+ probe_syscall_entry, "ip #p%ld syscall_id #2u%u");
+
+notrace void probe_syscall_entry(void *_data, struct pt_regs *regs, long id)
+{
+ struct marker *marker;
+ struct serialize_long_short data;
+
+ data.f1 = instruction_pointer(regs);
+ data.f2 = (unsigned short)id;
+
+ marker = &GET_MARKER(kernel, syscall_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_syscall_exit specialized tracepoint probe */
+
+void probe_syscall_exit(void *_data, long ret);
+
+DEFINE_MARKER_TP(kernel, syscall_exit, syscall_exit,
+ probe_syscall_exit, "ret %ld");
+
+notrace void probe_syscall_exit(void *_data, long ret)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(kernel, syscall_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &ret, sizeof(ret), sizeof(ret));
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("syscall Tracepoint Probes");
--- /dev/null
+/*
+ * ltt/probes/trap-trace.c
+ *
+ * Trap tracepoint probes.
+ *
+ * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
+ * Dual LGPL v2.1/GPL v2 license.
+ */
+
+#include <linux/module.h>
+#include <trace/trap.h>
+
+#include "../ltt-type-serializer.h"
+
+/* kernel_trap_entry specialized tracepoint probe */
+
+void probe_trap_entry(void *_data, struct pt_regs *regs, long id);
+
+DEFINE_MARKER_TP(kernel, trap_entry, trap_entry,
+ probe_trap_entry, "ip #p%ld trap_id #2u%u");
+
+notrace void probe_trap_entry(void *_data, struct pt_regs *regs, long id)
+{
+ struct marker *marker;
+ struct serialize_long_short data;
+
+ if (likely(regs))
+ data.f1 = instruction_pointer(regs);
+ else
+ data.f1 = 0UL;
+ data.f2 = (unsigned short)id;
+
+ marker = &GET_MARKER(kernel, trap_entry);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ &data, serialize_sizeof(data), sizeof(long));
+}
+
+/* kernel_syscall_exit specialized tracepoint probe */
+
+void probe_trap_exit(void *_data);
+
+DEFINE_MARKER_TP(kernel, trap_exit, trap_exit,
+ probe_trap_exit, MARK_NOARGS);
+
+notrace void probe_trap_exit(void *_data)
+{
+ struct marker *marker;
+
+ marker = &GET_MARKER(kernel, trap_exit);
+ ltt_specialized_trace(marker, marker->single.probe_private,
+ NULL, 0, 0);
+}
+
+MODULE_LICENSE("GPL and additional rights");
+MODULE_AUTHOR("Mathieu Desnoyers");
+MODULE_DESCRIPTION("Trap Tracepoint Probes");
+++ /dev/null
-/*
- * LTT ascii binary buffer to ascii converter.
- *
- * Copyright 2008 - 2009 Lai Jiangshan (laijs@cn.fujitsu.com)
- * Copyright 2009 - Mathieu Desnoyers mathieu.desnoyers@polymtl.ca
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-/*
- * TODO
- *
- * Move to new switch behavior: Wait for data for the duration of the
- * timer interval + safety, if none is coming, consider that no activity occured
- * in the buffer.
- *
- * Fix case when having a text file open and destroying trace.
- *
- * - Automate periodical switch:
- *
- * The debugfs file "switch_timer" receives a timer period as parameter
- * (e.g. echo 100 > switch_timer) to activate the timer per channel. This can
- * also be accessed through the internal API _before the trace session starts_.
- * This timer will insure that we periodically have subbuffers to read, and
- * therefore that the merge-sort does not wait endlessly for a subbuffer.
- *
- * - If a channel is switched and read without data, make sure it is still
- * considered afterward (not removed from the queue).
- *
- * - Create a ascii/tracename/ALL file to merge-sort all active channels.
- * - Create a ascii/tracename/README file to contain the text output legend.
- * - Remove leading zeroes from timestamps.
- * - Enhance pretty-printing to make sure all types used for addesses output in
- * the form 0xAB00000000 (not decimal). This is true for %p and 0x%...X.
- * - Hotplug support
- */
-
-
-
-
-#include <linux/module.h>
-#include <linux/seq_file.h>
-#include <linux/debugfs.h>
-#include <linux/module.h>
-#include <linux/string.h>
-#include <linux/delay.h>
-#include <linux/slab.h>
-#include <linux/cpu.h>
-#include <linux/fs.h>
-
-#include "ltt-tracer.h"
-#include "ltt-relay.h"
-#include "ltt-relay-lockless.h"
-
-#if 0
-#define DEBUGP printk
-#else
-#define DEBUGP(fmt , a...)
-#endif
-
-struct dentry *ltt_ascii_dir_dentry;
-EXPORT_SYMBOL_GPL(ltt_ascii_dir_dentry);
-
-struct ltt_relay_iter;
-
-struct ltt_relay_cpu_iter {
- /* cpu buffer information */
- struct ltt_chanbuf *buf;
- struct ltt_relay_iter *iter;
- int sb_ref; /* holding a reference to a subbuffer */
- long read_sb_offset; /* offset of the subbuffer read */
-
- /* current event information */
- struct ltt_subbuffer_header *header;
- long hdr_offset; /* event header offset */
- long payload_offset; /* event payload offset */
- u64 tsc; /* full 64-bits timestamp value */
- u32 data_size;
- u16 chID; /* channel ID, const */
- u16 eID;
-};
-
-struct ltt_relay_iter {
- struct ltt_relay_cpu_iter iter_cpu[NR_CPUS];
- struct ltt_chan *chan;
- loff_t pos;
- int cpu;
- int nr_refs;
-};
-
-/*
- * offset of 0 in subbuffer means "subbuf size" (filled subbuffer).
- */
-static int is_subbuffer_offset_end(struct ltt_relay_cpu_iter *citer,
- long offset)
-{
- struct ltt_chan *chan = container_of(citer->buf->a.chan,
- struct ltt_chan, a);
- long sub_offset = SUBBUF_OFFSET(offset - 1, chan) + 1;
-
- return (sub_offset <= citer->header->data_size);
-}
-
-static u64 calculate_tsc(u64 pre_tsc, u64 read_tsc, unsigned int rflags)
-{
- u64 new_tsc = read_tsc;
-
- if (rflags != LTT_RFLAG_ID_SIZE_TSC) {
- BUG_ON(read_tsc >> LTT_TSC_BITS);
-
- new_tsc = (pre_tsc & ~LTT_TSC_MASK) + read_tsc;
- if (read_tsc < (pre_tsc & LTT_TSC_MASK))
- new_tsc += 1UL << LTT_TSC_BITS;
- }
-
- return new_tsc;
-}
-
-/*
- * calculate payload offset */
-static inline long calculate_payload_offset(long offset, u16 chID, u16 eID)
-{
- const char *fmt;
-
- if (!ltt_get_alignment())
- return offset;
-
- fmt = marker_get_fmt_from_id(chID, eID);
- BUG_ON(!fmt);
-
- return offset + ltt_fmt_largest_align(offset, fmt);
-}
-
-static void update_new_event(struct ltt_relay_cpu_iter *citer, long hdr_offset)
-{
- u64 read_tsc;
- unsigned int rflags;
- long tmp_offset;
-
- WARN_ON_ONCE(hdr_offset != citer->hdr_offset);
-
- tmp_offset = ltt_read_event_header(&citer->buf->a, hdr_offset,
- &read_tsc, &citer->data_size,
- &citer->eID, &rflags);
- citer->payload_offset = calculate_payload_offset(tmp_offset,
- citer->chID,
- citer->eID);
-
- citer->tsc = calculate_tsc(citer->tsc, read_tsc, rflags);
-}
-
-static void update_event_size(struct ltt_relay_cpu_iter *citer, long hdr_offset)
-{
- char output[1];
- const char *fmt;
- size_t data_size;
-
- if (citer->data_size != INT_MAX)
- return;
-
- fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
- BUG_ON(!fmt);
- ltt_serialize_printf(citer->buf, citer->payload_offset,
- &data_size, output, 0, fmt);
- citer->data_size = data_size;
-}
-
-static void update_cpu_iter(struct ltt_relay_cpu_iter *citer, long hdr_offset)
-{
- if (unlikely((!citer->sb_ref)
- || is_subbuffer_offset_end(citer, hdr_offset))) {
- citer->header = NULL;
- return;
- }
- update_new_event(citer, hdr_offset);
- update_event_size(citer, hdr_offset);
-}
-
-/*
- * returns 0 if we get a subbuffer reference.
- * else, the buffer has not available data, try again later.
- */
-static int subbuffer_start(struct ltt_relay_cpu_iter *citer, long *offset)
-{
- int ret;
- struct ltt_relay_iter *iter = citer->iter;
-
- ret = ltt_chanbuf_get_subbuf(citer->buf, offset);
- if (!ret) {
- citer->header = ltt_relay_read_offset_address(&citer->buf->a,
- *offset);
- citer->hdr_offset = (*offset) + ltt_sb_header_size();
- citer->tsc = citer->header->cycle_count_begin;
- iter->nr_refs++;
- citer->sb_ref = 1;
- return 0;
- } else {
- if (ltt_chanbuf_is_finalized(citer->buf))
- return -ENODATA;
- else
- return -EAGAIN;
- }
-}
-
-static void subbuffer_stop(struct ltt_relay_cpu_iter *citer,
- long offset)
-{
- int ret;
- struct ltt_relay_iter *iter = citer->iter;
-
- WARN_ON_ONCE(!citer->sb_ref);
- ret = ltt_chanbuf_put_subbuf(citer->buf, offset);
- WARN_ON_ONCE(ret);
- citer->sb_ref = 0;
- iter->nr_refs--;
-}
-
-static void ltt_relay_advance_cpu_iter(struct ltt_relay_cpu_iter *citer)
-{
- long old_offset = citer->payload_offset;
- long new_offset = citer->payload_offset;
- int ret;
-
- /* find that whether we read all data in this subbuffer */
- if (unlikely(is_subbuffer_offset_end(citer,
- old_offset + citer->data_size))) {
- DEBUGP(KERN_DEBUG "LTT ASCII stop cpu %d offset %lX\n",
- citer->buf->a.cpu, citer->read_sb_offset);
- subbuffer_stop(citer, citer->read_sb_offset);
- for (;;) {
- ret = subbuffer_start(citer, &citer->read_sb_offset);
- DEBUGP(KERN_DEBUG
- "LTT ASCII start cpu %d ret %d offset %lX\n",
- citer->buf->a.cpu, ret, citer->read_sb_offset);
- if (!ret || ret == -ENODATA) {
- break; /* got data, or finalized */
- } else { /* -EAGAIN */
- if (signal_pending(current))
- break;
- schedule_timeout_interruptible(1);
- //TODO: check for no-data delay. take ref. break
- }
- }
- } else {
- new_offset += citer->data_size;
- citer->hdr_offset = new_offset + ltt_align(new_offset, sizeof(struct ltt_event_header));
- DEBUGP(KERN_DEBUG
- "LTT ASCII old_offset %lX new_offset %lX cpu %d\n",
- old_offset, new_offset, citer->buf->a.cpu);
- }
-
- update_cpu_iter(citer, citer->hdr_offset);
-}
-
-static int cpu_iter_eof(struct ltt_relay_cpu_iter *citer)
-{
- return !citer->sb_ref;
-}
-
-static int ltt_relay_iter_eof(struct ltt_relay_iter *iter)
-{
- return iter->nr_refs == 0;
-}
-
-static void ltt_relay_advance_iter(struct ltt_relay_iter *iter)
-{
- int i;
- struct ltt_relay_cpu_iter *curr, *min = NULL;
- iter->cpu = -1;
-
- /*
- * find the event with the minimum tsc.
- * TODO: use min-heep for 4096CPUS
- */
- for_each_possible_cpu(i) {
- curr = &iter->iter_cpu[i];
-
- if (!curr->buf->a.allocated || !curr->header)
- continue;
-
- if (cpu_iter_eof(curr))
- continue;
-
- if (!min || curr->tsc < min->tsc) {
- min = curr;
- iter->cpu = i;
- }
- }
-
- /* update cpu_iter for next ltt_relay_advance_iter() */
- if (min)
- ltt_relay_advance_cpu_iter(min);
-}
-
-static void *ascii_next(struct seq_file *m, void *v, loff_t *ppos)
-{
- struct ltt_relay_iter *iter = m->private;
-
- WARN_ON_ONCE(!iter->nr_refs);
- BUG_ON(v != iter);
-
- ltt_relay_advance_iter(iter);
- return (ltt_relay_iter_eof(iter) || signal_pending(current))
- ? NULL : iter;
-}
-
-static void *ascii_start(struct seq_file *m, loff_t *ppos)
-{
- struct ltt_relay_iter *iter = m->private;
-
- ltt_relay_advance_iter(iter);
- return (ltt_relay_iter_eof(iter) || signal_pending(current))
- ? NULL : iter;
-}
-
-static void ascii_stop(struct seq_file *m, void *v)
-{
-}
-
-static
-int seq_serialize(struct seq_file *m, struct ltt_chanbuf *buf,
- size_t buf_offset, const char *fmt, size_t *data_size)
-{
- int len;
-
- if (m->count < m->size) {
- len = ltt_serialize_printf(buf, buf_offset, data_size,
- m->buf + m->count,
- m->size - m->count, fmt);
- if (m->count + len < m->size) {
- m->count += len;
- return 0;
- }
- }
-
- m->count = m->size;
- return -1;
-}
-
-static int ascii_show(struct seq_file *m, void *v)
-{
- struct ltt_relay_iter *iter = v;
- struct ltt_relay_cpu_iter *citer;
- const char *name;
- const char *fmt;
- unsigned long long tsc;
- size_t data_size;
-
- if (iter->cpu == -1)
- return 0;
-
- citer = &iter->iter_cpu[iter->cpu];
- WARN_ON_ONCE(!citer->sb_ref);
- /*
- * Nothing to show, we are at the end of the last subbuffer currently
- * having data.
- */
- if (!citer->header)
- return 0;
-
- tsc = citer->tsc;
- name = marker_get_name_from_id(citer->chID, citer->eID);
- fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
-
- if (!name || !fmt)
- return 0;
-
- seq_printf(m, "event:%16.16s: cpu:%2d time:%20.20llu ",
- name, iter->cpu, tsc);
- seq_serialize(m, citer->buf, citer->payload_offset, fmt, &data_size);
- seq_puts(m, "\n");
- if (citer->data_size == INT_MAX)
- citer->data_size = data_size;
-
- return 0;
-}
-
-static struct seq_operations ascii_seq_ops = {
- .start = ascii_start,
- .next = ascii_next,
- .stop = ascii_stop,
- .show = ascii_show,
-};
-
-/* FIXME : cpu hotplug support */
-static int ltt_relay_iter_open_channel(struct ltt_relay_iter *iter,
- struct ltt_chan *chan)
-{
- int i, ret;
- u16 chID = ltt_channels_get_index_from_name(chan->a.filename);
-
- /* we don't need lock relay_channels_mutex */
- for_each_possible_cpu(i) {
- struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
-
- citer->buf = per_cpu_ptr(chan->a.buf, i);
- if (!citer->buf->a.allocated)
- continue;
-
- citer->iter = iter; /* easy lazy parent info */
- citer->chID = chID;
-
- ret = ltt_chanbuf_open_read(citer->buf);
- if (ret) {
- /* Failed to open a percpu buffer, close everything. */
- citer->buf = NULL;
- goto error;
- }
-
- for (;;) {
- ret = subbuffer_start(citer,
- &citer->read_sb_offset);
- DEBUGP(KERN_DEBUG
- "LTT ASCII open start "
- "cpu %d ret %d offset %lX\n",
- citer->buf->a.cpu, ret, citer->read_sb_offset);
- if (!ret || ret == -ENODATA) {
- break; /* got data, or finalized */
- } else { /* -EAGAIN */
- if (signal_pending(current))
- break;
- schedule_timeout_interruptible(1);
- }
- }
- update_cpu_iter(citer, citer->hdr_offset);
- }
- if (!iter->nr_refs) {
- ret = -ENODATA;
- goto error;
- }
-
- return 0;
-
-error:
- for_each_possible_cpu(i) {
- struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
-
- if (!citer->buf)
- break;
-
- if (citer->buf->a.allocated)
- ltt_chanbuf_release_read(citer->buf);
- }
- return ret;
-}
-
-/* FIXME : cpu hotplug support */
-static int ltt_relay_iter_release_channel(struct ltt_relay_iter *iter)
-{
- int i;
-
- for_each_possible_cpu(i) {
- struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
-
- if (citer->sb_ref) {
- WARN_ON_ONCE(!citer->buf->a.allocated);
- DEBUGP(KERN_DEBUG
- "LTT ASCII release stop cpu %d offset %lX\n",
- citer->buf->a.cpu, citer->read_sb_offset);
- subbuffer_stop(&iter->iter_cpu[i],
- citer->read_sb_offset);
- }
- if (citer->buf->a.allocated)
- ltt_chanbuf_release_read(citer->buf);
- }
- WARN_ON_ONCE(iter->nr_refs);
- return 0;
-}
-
-static int ltt_relay_ascii_open(struct inode *inode, struct file *file)
-{
- int ret;
- struct ltt_chan *chan = inode->i_private;
- struct ltt_relay_iter *iter = kzalloc(sizeof(*iter), GFP_KERNEL);
- if (!iter)
- return -ENOMEM;
-
- iter->chan = chan;
- ret = ltt_relay_iter_open_channel(iter, chan);
- if (ret)
- goto error_free_alloc;
-
- ret = seq_open(file, &ascii_seq_ops);
- if (ret)
- goto error_release_channel;
- ((struct seq_file *)file->private_data)->private = iter;
- return 0;
-
-error_release_channel:
- ltt_relay_iter_release_channel(iter);
-error_free_alloc:
- kfree(iter);
- return ret;
-}
-
-static int ltt_relay_ascii_release(struct inode *inode, struct file *file)
-{
- struct seq_file *seq = file->private_data;
- struct ltt_relay_iter *iter = seq->private;
-
- ltt_relay_iter_release_channel(iter);
- kfree(iter);
- return 0;
-}
-
-static struct file_operations ltt_ascii_fops =
-{
- .read = seq_read,
- .open = ltt_relay_ascii_open,
- .release = ltt_relay_ascii_release,
- .llseek = no_llseek,
- .owner = THIS_MODULE,
-};
-
-int ltt_ascii_create(struct ltt_chan *chan)
-{
- struct dentry *dentry;
-
- dentry = debugfs_create_file(chan->a.filename,
- S_IRUSR | S_IRGRP,
- chan->a.trace->dentry.ascii_root,
- chan, <t_ascii_fops);
- if (IS_ERR(dentry))
- return PTR_ERR(dentry);
-
- if (!dentry)
- return -EEXIST;
-
- chan->a.ascii_dentry = dentry;
- dentry->d_inode->i_private = chan;
- return 0;
-}
-EXPORT_SYMBOL_GPL(ltt_ascii_create);
-
-void ltt_ascii_remove(struct ltt_chan *chan)
-{
- struct dentry *dentry;
-
- dentry = dget(chan->a.ascii_dentry);
- debugfs_remove(dentry);
- /* TODO: wait / wakeup instead */
- /*
- * Wait for every reference to the dentry to be gone,
- * except us.
- */
- while (atomic_read(&dentry->d_count) != 1)
- msleep(100);
- dput(dentry);
-}
-EXPORT_SYMBOL_GPL(ltt_ascii_remove);
-
-int ltt_ascii_create_dir(struct ltt_trace *new_trace)
-{
- new_trace->dentry.ascii_root = debugfs_create_dir(new_trace->trace_name,
- ltt_ascii_dir_dentry);
- if (!new_trace->dentry.ascii_root)
- return -EEXIST;
- return 0;
-}
-EXPORT_SYMBOL_GPL(ltt_ascii_create_dir);
-
-void ltt_ascii_remove_dir(struct ltt_trace *trace)
-{
- debugfs_remove(trace->dentry.ascii_root);
-}
-EXPORT_SYMBOL_GPL(ltt_ascii_remove_dir);
-
-__init int ltt_ascii_init(void)
-{
- ltt_ascii_dir_dentry = debugfs_create_dir(LTT_ASCII, get_ltt_root());
-
- return ltt_ascii_dir_dentry ? 0 : -EFAULT;
-}
-
-__exit void ltt_ascii_exit(void)
-{
- debugfs_remove(ltt_ascii_dir_dentry);
- put_ltt_root();
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Lai Jiangshan@FNST and Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Ascii Converter");
+++ /dev/null
-/*
- * ltt/ltt-channels.c
- *
- * (C) Copyright 2008 - Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
- *
- * LTTng channel management.
- *
- * Author:
- * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/mutex.h>
-#include <linux/slab.h>
-#include <linux/vmalloc.h>
-#include "ltt-channels.h"
-
-/*
- * ltt_channel_mutex may be nested inside the LTT trace mutex.
- * ltt_channel_mutex mutex may be nested inside markers mutex.
- */
-static DEFINE_MUTEX(ltt_channel_mutex);
-static LIST_HEAD(ltt_channels);
-/*
- * Index of next channel in array. Makes sure that as long as a trace channel is
- * allocated, no array index will be re-used when a channel is freed and then
- * another channel is allocated. This index is cleared and the array indexeds
- * get reassigned when the index_kref goes back to 0, which indicates that no
- * more trace channels are allocated.
- */
-static unsigned int free_index;
-/* index_kref is protected by both ltt_channel_mutex and lock_markers */
-static struct kref index_kref; /* Keeps track of allocated trace channels */
-
-static struct ltt_channel_setting *lookup_channel(const char *name)
-{
- struct ltt_channel_setting *iter;
-
- list_for_each_entry(iter, <t_channels, list)
- if (strcmp(name, iter->name) == 0)
- return iter;
- return NULL;
-}
-
-/*
- * Must be called when channel refcount falls to 0 _and_ also when the last
- * trace is freed. This function is responsible for compacting the channel and
- * event IDs when no users are active.
- *
- * Called with lock_markers() and channels mutex held.
- */
-static void release_channel_setting(struct kref *kref)
-{
- struct ltt_channel_setting *setting = container_of(kref,
- struct ltt_channel_setting, kref);
- struct ltt_channel_setting *iter;
-
- if (atomic_read(&index_kref.refcount) == 0
- && atomic_read(&setting->kref.refcount) == 0) {
- list_del(&setting->list);
- kfree(setting);
-
- free_index = 0;
- list_for_each_entry(iter, <t_channels, list) {
- iter->index = free_index++;
- iter->free_event_id = 0;
- }
- }
-}
-
-/*
- * Perform channel index compaction when the last trace channel is freed.
- *
- * Called with lock_markers() and channels mutex held.
- */
-static void release_trace_channel(struct kref *kref)
-{
- struct ltt_channel_setting *iter, *n;
-
- list_for_each_entry_safe(iter, n, <t_channels, list)
- release_channel_setting(&iter->kref);
- if (atomic_read(&index_kref.refcount) == 0)
- markers_compact_event_ids();
-}
-
-/*
- * ltt_channel_trace_ref : Is there an existing trace session ?
- *
- * Must be called with lock_markers() held.
- */
-int ltt_channels_trace_ref(void)
-{
- return !!atomic_read(&index_kref.refcount);
-}
-EXPORT_SYMBOL_GPL(ltt_channels_trace_ref);
-
-/**
- * ltt_channels_register - Register a trace channel.
- * @name: channel name
- *
- * Uses refcounting.
- */
-int ltt_channels_register(const char *name)
-{
- struct ltt_channel_setting *setting;
- int ret = 0;
-
- mutex_lock(<t_channel_mutex);
- setting = lookup_channel(name);
- if (setting) {
- if (atomic_read(&setting->kref.refcount) == 0)
- goto init_kref;
- else {
- kref_get(&setting->kref);
- goto end;
- }
- }
- setting = kzalloc(sizeof(*setting), GFP_KERNEL);
- if (!setting) {
- ret = -ENOMEM;
- goto end;
- }
- list_add(&setting->list, <t_channels);
- strncpy(setting->name, name, PATH_MAX-1);
- setting->index = free_index++;
-init_kref:
- kref_init(&setting->kref);
-end:
- mutex_unlock(<t_channel_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_register);
-
-/**
- * ltt_channels_unregister - Unregister a trace channel.
- * @name: channel name
- * @compacting: performing compaction
- *
- * Must be called with markers mutex held.
- */
-int ltt_channels_unregister(const char *name, int compacting)
-{
- struct ltt_channel_setting *setting;
- int ret = 0;
-
- if (!compacting)
- mutex_lock(<t_channel_mutex);
- setting = lookup_channel(name);
- if (!setting || atomic_read(&setting->kref.refcount) == 0) {
- ret = -ENOENT;
- goto end;
- }
- kref_put(&setting->kref, release_channel_setting);
- if (!compacting && atomic_read(&index_kref.refcount) == 0)
- markers_compact_event_ids();
-end:
- if (!compacting)
- mutex_unlock(<t_channel_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_unregister);
-
-/**
- * ltt_channels_set_default - Set channel default behavior.
- * @name: default channel name
- * @sb_size: size of the subbuffers
- * @n_sb: number of subbuffers
- */
-int ltt_channels_set_default(const char *name,
- unsigned int sb_size,
- unsigned int n_sb)
-{
- struct ltt_channel_setting *setting;
- int ret = 0;
-
- mutex_lock(<t_channel_mutex);
- setting = lookup_channel(name);
- if (!setting || atomic_read(&setting->kref.refcount) == 0) {
- ret = -ENOENT;
- goto end;
- }
- setting->sb_size = sb_size;
- setting->n_sb = n_sb;
-end:
- mutex_unlock(<t_channel_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_set_default);
-
-/**
- * ltt_channels_get_name_from_index - get channel name from channel index
- * @index: channel index
- *
- * Allows to lookup the channel name given its index. Done to keep the name
- * information outside of each trace channel instance.
- */
-const char *ltt_channels_get_name_from_index(unsigned int index)
-{
- struct ltt_channel_setting *iter;
-
- list_for_each_entry(iter, <t_channels, list)
- if (iter->index == index && atomic_read(&iter->kref.refcount))
- return iter->name;
- return NULL;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_get_name_from_index);
-
-static struct ltt_channel_setting *
-ltt_channels_get_setting_from_name(const char *name)
-{
- struct ltt_channel_setting *iter;
-
- list_for_each_entry(iter, <t_channels, list)
- if (!strcmp(iter->name, name)
- && atomic_read(&iter->kref.refcount))
- return iter;
- return NULL;
-}
-
-/**
- * ltt_channels_get_index_from_name - get channel index from channel name
- * @name: channel name
- *
- * Allows to lookup the channel index given its name. Done to keep the name
- * information outside of each trace channel instance.
- * Returns -1 if not found.
- */
-int ltt_channels_get_index_from_name(const char *name)
-{
- struct ltt_channel_setting *setting;
-
- setting = ltt_channels_get_setting_from_name(name);
- if (setting)
- return setting->index;
- else
- return -1;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_get_index_from_name);
-
-/**
- * ltt_channels_trace_alloc - Allocate channel structures for a trace
- *
- * Use the current channel list to allocate the channels for a trace.
- * Called with trace lock held. Does not perform the trace buffer allocation,
- * because we must let the user overwrite specific channel sizes.
- */
-int ltt_channels_trace_alloc(struct ltt_trace *trace, int overwrite)
-{
- struct channel **chan = NULL;
- struct ltt_channel_setting *chans, *iter;
- int ret = 0;
-
- lock_markers();
- mutex_lock(<t_channel_mutex);
- if (!free_index)
- goto end;
- if (!atomic_read(&index_kref.refcount))
- kref_init(&index_kref);
- else
- kref_get(&index_kref);
- trace->nr_channels = free_index;
- chan = kzalloc(sizeof(struct channel *) * free_index, GFP_KERNEL);
- if (!chan)
- goto end;
- chans = kzalloc(sizeof(struct ltt_channel_setting) * free_index,
- GFP_KERNEL);
- if (!chan_settings)
- goto free_chan;
- list_for_each_entry(iter, <t_channels, list) {
- if (!atomic_read(&iter->kref.refcount))
- continue;
- chans[iter->index].sb_size = iter->sb_size;
- chans[iter->index].n_sb = iter->n_sb;
- chans[iter->index].overwrite = overwrite;
- strncpy(chans[iter->index].filename, iter->name,
- NAME_MAX - 1);
- chans[iter->index].switch_timer_interval = 0;
- chans[iter->index].read_timer_interval = LTT_READ_TIMER_INTERVAL;
- }
- trace->channels = chan;
- trace->settings = chans;
-end:
- mutex_unlock(<t_channel_mutex);
- unlock_markers();
- return ret;
-
-free_chan:
- kfree(chan);
- ret = -ENOMEM;
- goto end;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_trace_alloc);
-
-/**
- * ltt_channels_trace_free - Free one trace's channels
- * @channels: channels to free
- *
- * Called with trace lock held. The actual channel buffers must be freed before
- * this function is called.
- */
-void ltt_channels_trace_free(struct ltt_trace *trace)
-{
- lock_markers();
- mutex_lock(<t_channel_mutex);
- kfree(trace->settings);
- kfree(trace->channels);
- kref_put(&index_kref, release_trace_channel);
- mutex_unlock(<t_channel_mutex);
- unlock_markers();
- marker_update_probes();
-}
-EXPORT_SYMBOL_GPL(ltt_channels_trace_free);
-
-/**
- * ltt_channels_trace_set_timer - set switch timer
- * @channel: channel
- * @interval: interval of timer interrupt, in jiffies. 0 inhibits timer.
- */
-
-void ltt_channels_trace_set_timer(struct ltt_chan *chan,
- unsigned long interval)
-{
- chan->switch_timer_interval = interval;
-}
-EXPORT_SYMBOL_GPL(ltt_channels_trace_set_timer);
-
-/**
- * _ltt_channels_get_event_id - get next event ID for a marker
- * @channel: channel name
- * @name: event name
- *
- * Returns a unique event ID (for this channel) or < 0 on error.
- * Must be called with channels mutex held.
- */
-int _ltt_channels_get_event_id(const char *channel, const char *name)
-{
- struct ltt_channel_setting *setting;
- int ret;
-
- setting = ltt_channels_get_setting_from_name(channel);
- if (!setting) {
- ret = -ENOENT;
- goto end;
- }
- if (strcmp(channel, "metadata") == 0) {
- if (strcmp(name, "core_marker_id") == 0)
- ret = 0;
- else if (strcmp(name, "core_marker_format") == 0)
- ret = 1;
- else
- ret = -ENOENT;
- goto end;
- }
- if (setting->free_event_id == EVENTS_PER_CHANNEL - 1) {
- ret = -ENOSPC;
- goto end;
- }
- ret = setting->free_event_id++;
-end:
- return ret;
-}
-
-/**
- * ltt_channels_get_event_id - get next event ID for a marker
- * @channel: channel name
- * @name: event name
- *
- * Returns a unique event ID (for this channel) or < 0 on error.
- */
-int ltt_channels_get_event_id(const char *channel, const char *name)
-{
- int ret;
-
- mutex_lock(<t_channel_mutex);
- ret = _ltt_channels_get_event_id(channel, name);
- mutex_unlock(<t_channel_mutex);
- return ret;
-}
-
-/**
- * ltt_channels_reset_event_ids - reset event IDs at compaction
- *
- * Called with lock marker and channel mutex held.
- */
-void _ltt_channels_reset_event_ids(void)
-{
- struct ltt_channel_setting *iter;
-
- list_for_each_entry(iter, <t_channels, list)
- iter->free_event_id = 0;
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Channel Management");
+++ /dev/null
-#ifndef _LTT_CHANNELS_H
-#define _LTT_CHANNELS_H
-
-/*
- * Copyright (C) 2008 Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
- *
- * Dynamic tracer channel allocation.
-
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/limits.h>
-#include <linux/kref.h>
-#include <linux/list.h>
-#include <linux/timer.h>
-#include <linux/ltt-core.h>
-
-#define EVENTS_PER_CHANNEL 65536
-
-#define LTT_READ_TIMER_INTERVAL 10000 /* us */
-
-/*
- * Forward declaration of locking-specific per-cpu buffer structure.
- */
-struct ltt_trace;
-struct ltt_serialize_closure;
-struct ltt_probe_private_data;
-
-/* Serialization callback '%k' */
-typedef size_t (*ltt_serialize_cb)(struct ltt_chanbuf *buf, size_t buf_offset,
- struct ltt_serialize_closure *closure,
- void *serialize_private,
- unsigned int stack_pos_ctx,
- int *largest_align,
- const char *fmt, va_list *args);
-
-struct ltt_probe_private_data {
- struct ltt_trace *trace; /*
- * Target trace, for metadata
- * or statedump.
- */
- ltt_serialize_cb serializer; /*
- * Serialization function override.
- */
- void *serialize_private; /*
- * Private data for serialization
- * functions.
- */
-};
-
-struct ltt_channel_setting {
- unsigned int sb_size;
- unsigned int n_sb;
- int overwrite;
- unsigned long switch_timer_interval;
- unsigned long read_timer_interval;
- struct kref kref; /* Number of references to structure content */
- struct list_head list;
- unsigned int index; /* index of channel in trace channel array */
- u16 free_event_id; /* Next event ID to allocate */
- char name[PATH_MAX];
-};
-
-int ltt_channels_register(const char *name);
-int ltt_channels_unregister(const char *name, int compacting);
-int ltt_channels_set_default(const char *name,
- unsigned int subbuf_size,
- unsigned int subbuf_cnt);
-const char *ltt_channels_get_name_from_index(unsigned int index);
-int ltt_channels_get_index_from_name(const char *name);
-int ltt_channels_trace_ref(void);
-struct ltt_chan *ltt_channels_trace_alloc(unsigned int *nr_channels,
- int overwrite, int active);
-void ltt_channels_trace_free(struct ltt_chan *channels,
- unsigned int nr_channels);
-void ltt_channels_trace_set_timer(struct ltt_channel_setting *chan,
- unsigned long interval);
-
-int _ltt_channels_get_event_id(const char *channel, const char *name);
-int ltt_channels_get_event_id(const char *channel, const char *name);
-void _ltt_channels_reset_event_ids(void);
-
-#endif /* _LTT_CHANNELS_H */
+++ /dev/null
-/*
- * Copyright (C) 2008 Mathieu Desnoyers
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/debugfs.h>
-#include <linux/fs.h>
-#include <linux/mutex.h>
-
-#include "ltt-tracer.h"
-
-#define LTT_FILTER_DIR "filter"
-
-/*
- * Protects the ltt_filter_dir allocation.
- */
-static DEFINE_MUTEX(ltt_filter_mutex);
-
-static struct dentry *ltt_filter_dir;
-
-struct dentry *get_filter_root(void)
-{
- struct dentry *ltt_root_dentry;
-
- mutex_lock(<t_filter_mutex);
- if (!ltt_filter_dir) {
- ltt_root_dentry = get_ltt_root();
- if (!ltt_root_dentry)
- goto err_no_root;
-
- ltt_filter_dir = debugfs_create_dir(LTT_FILTER_DIR,
- ltt_root_dentry);
- if (!ltt_filter_dir)
- printk(KERN_ERR
- "ltt_filter_init: failed to create dir %s\n",
- LTT_FILTER_DIR);
- }
-err_no_root:
- mutex_unlock(<t_filter_mutex);
- return ltt_filter_dir;
-}
-EXPORT_SYMBOL_GPL(get_filter_root);
-
-static void __exit ltt_filter_exit(void)
-{
- debugfs_remove(ltt_filter_dir);
-}
-
-module_exit(ltt_filter_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>");
-MODULE_DESCRIPTION("Linux Trace Toolkit Filter");
+++ /dev/null
-/*
- * (C) Copyright 2009 -
- * Mathieu Desnoyers (mathieu.desnoyers@polymtl.ca)
- *
- * LTTng kprobes integration module.
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/kprobes.h>
-#include <linux/marker.h>
-#include <linux/mutex.h>
-#include <linux/jhash.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
-#include <linux/debugfs.h>
-#include <linux/kallsyms.h>
-
-#include "ltt-type-serializer.h"
-#include "ltt-tracer.h"
-
-#define LTT_KPROBES_DIR "kprobes"
-#define LTT_KPROBES_ENABLE "enable"
-#define LTT_KPROBES_DISABLE "disable"
-#define LTT_KPROBES_LIST "list"
-
-/* Active LTTng kprobes hash table */
-static DEFINE_MUTEX(ltt_kprobes_mutex);
-
-#define LTT_KPROBE_HASH_BITS 6
-#define LTT_KPROBE_TABLE_SIZE (1 << LTT_KPROBE_HASH_BITS)
-static struct hlist_head ltt_kprobe_table[LTT_KPROBE_TABLE_SIZE];
-
-struct kprobe_entry {
- struct hlist_node hlist;
- struct kprobe kp;
- char key[0];
-};
-
-static struct dentry *ltt_kprobes_dir,
- *ltt_kprobes_enable_dentry,
- *ltt_kprobes_disable_dentry,
- *ltt_kprobes_list_dentry;
-
-static int module_exit;
-
-
-static void trace_kprobe_table_entry(void *call_data, struct kprobe_entry *e)
-{
- unsigned long addr;
- char *namebuf = (char *)__get_free_page(GFP_KERNEL);
-
- if (e->kp.addr) {
- sprint_symbol(namebuf, (unsigned long)e->kp.addr);
- addr = (unsigned long)e->kp.addr;
- } else {
- strncpy(namebuf, e->kp.symbol_name, PAGE_SIZE - 1);
- /* TODO : add offset */
- addr = kallsyms_lookup_name(namebuf);
- }
- if (addr)
- __trace_mark(0, kprobe_state, kprobe_table, call_data,
- "ip 0x%lX symbol %s", addr, namebuf);
- free_page((unsigned long)namebuf);
-}
-
-DEFINE_MARKER(kernel, kprobe, "ip %lX");
-
-static int ltt_kprobe_handler_pre(struct kprobe *p, struct pt_regs *regs)
-{
- struct marker *marker;
- unsigned long data;
-
- data = (unsigned long)p->addr;
- marker = &GET_MARKER(kernel, kprobe);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
- return 0;
-}
-
-static int ltt_register_kprobe(const char *key)
-{
- struct hlist_head *head;
- struct hlist_node *node;
- struct kprobe_entry *e = NULL;
- char *symbol_name = NULL;
- unsigned long addr;
- unsigned int offset = 0;
- u32 hash;
- size_t key_len = strlen(key) + 1;
- int ret;
-
- if (key_len == 1)
- return -ENOENT; /* only \0 */
-
- if (sscanf(key, "%li", &addr) != 1)
- addr = 0;
-
- if (!addr) {
- const char *symbol_end = NULL;
- unsigned int symbol_len; /* includes final \0 */
-
- symbol_end = strchr(key, ' ');
- if (symbol_end)
- symbol_len = symbol_end - key + 1;
- else
- symbol_len = key_len;
- symbol_name = kmalloc(symbol_len, GFP_KERNEL);
- if (!symbol_name) {
- ret = -ENOMEM;
- goto error;
- }
- memcpy(symbol_name, key, symbol_len - 1);
- symbol_name[symbol_len-1] = '\0';
- if (symbol_end) {
- symbol_end++; /* start of offset */
- if (sscanf(symbol_end, "%i", &offset) != 1)
- offset = 0;
- }
- }
-
- hash = jhash(key, key_len-1, 0);
- head = <t_kprobe_table[hash & ((1 << LTT_KPROBE_HASH_BITS)-1)];
- hlist_for_each_entry(e, node, head, hlist) {
- if (!strcmp(key, e->key)) {
- printk(KERN_NOTICE "Kprobe %s busy\n", key);
- ret = -EBUSY;
- goto error;
- }
- }
- /*
- * Using kzalloc here to allocate a variable length element. Could
- * cause some memory fragmentation if overused.
- */
- e = kzalloc(sizeof(struct kprobe_entry) + key_len, GFP_KERNEL);
- if (!e) {
- ret = -ENOMEM;
- goto error;
- }
- memcpy(e->key, key, key_len);
- hlist_add_head(&e->hlist, head);
- e->kp.pre_handler = ltt_kprobe_handler_pre;
- e->kp.symbol_name = symbol_name;
- e->kp.offset = offset;
- e->kp.addr = (void *)addr;
- ret = register_kprobe(&e->kp);
- if (ret < 0)
- goto error_list_del;
- trace_kprobe_table_entry(NULL, e);
- return 0;
-
-error_list_del:
- hlist_del(&e->hlist);
-error:
- kfree(symbol_name);
- kfree(e);
- return ret;
-}
-
-static int ltt_unregister_kprobe(const char *key)
-{
- struct hlist_head *head;
- struct hlist_node *node;
- struct kprobe_entry *e;
- int found = 0;
- size_t key_len = strlen(key) + 1;
- u32 hash;
-
- hash = jhash(key, key_len-1, 0);
- head = <t_kprobe_table[hash & ((1 << LTT_KPROBE_HASH_BITS)-1)];
- hlist_for_each_entry(e, node, head, hlist) {
- if (!strcmp(key, e->key)) {
- found = 1;
- break;
- }
- }
- if (!found)
- return -ENOENT;
- hlist_del(&e->hlist);
- unregister_kprobe(&e->kp);
- kfree(e->kp.symbol_name);
- kfree(e);
- return 0;
-}
-
-static void ltt_unregister_all_kprobes(void)
-{
- struct kprobe_entry *e;
- struct hlist_head *head;
- struct hlist_node *node, *tmp;
- unsigned int i;
-
- for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
- head = <t_kprobe_table[i];
- hlist_for_each_entry_safe(e, node, tmp, head, hlist) {
- hlist_del(&e->hlist);
- unregister_kprobe(&e->kp);
- kfree(e->kp.symbol_name);
- kfree(e);
- }
- }
-}
-
-/*
- * Allows to specify either
- * - symbol
- * - symbol offset
- * - address
- */
-static ssize_t enable_op_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err, buf_size;
- char *end;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
-
- mutex_lock(<t_kprobes_mutex);
- if (module_exit) {
- err = -EPERM;
- goto error;
- }
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto error;
- buf[buf_size] = '\0';
- end = strchr(buf, '\n');
- if (end)
- *end = '\0';
- err = ltt_register_kprobe(buf);
- if (err)
- goto error;
-
- mutex_unlock(<t_kprobes_mutex);
- free_page((unsigned long)buf);
- return count;
-error:
- mutex_unlock(<t_kprobes_mutex);
- free_page((unsigned long)buf);
- return err;
-}
-
-static const struct file_operations ltt_kprobes_enable = {
- .write = enable_op_write,
-};
-
-static ssize_t disable_op_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err, buf_size;
- char *end;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
-
- mutex_lock(<t_kprobes_mutex);
- if (module_exit)
- goto end;
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto error;
- buf[buf_size] = '\0';
- end = strchr(buf, '\n');
- if (end)
- *end = '\0';
- err = ltt_unregister_kprobe(buf);
- if (err)
- goto error;
-end:
- mutex_unlock(<t_kprobes_mutex);
- free_page((unsigned long)buf);
- return count;
-error:
- mutex_unlock(<t_kprobes_mutex);
- free_page((unsigned long)buf);
- return err;
-}
-
-static const struct file_operations ltt_kprobes_disable = {
- .write = disable_op_write,
-};
-
-/*
- * This seqfile read is not perfectly safe, as a kprobe could be removed from
- * the hash table between two reads. This will result in an incomplete output.
- */
-static struct kprobe_entry *ltt_find_next_kprobe(struct kprobe_entry *prev)
-{
- struct kprobe_entry *e;
- struct hlist_head *head;
- struct hlist_node *node;
- unsigned int i;
- int found = 0;
-
- if (prev == (void *)-1UL)
- return NULL;
-
- if (!prev)
- found = 1;
-
- for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
- head = <t_kprobe_table[i];
- hlist_for_each_entry(e, node, head, hlist) {
- if (found)
- return e;
- if (e == prev)
- found = 1;
- }
- }
- return NULL;
-}
-
-static void *lk_next(struct seq_file *m, void *p, loff_t *pos)
-{
- m->private = ltt_find_next_kprobe(m->private);
- if (!m->private) {
- m->private = (void *)-1UL;
- return NULL;
- }
- return m->private;
-}
-
-static void *lk_start(struct seq_file *m, loff_t *pos)
-{
- mutex_lock(<t_kprobes_mutex);
- if (!*pos)
- m->private = NULL;
- m->private = ltt_find_next_kprobe(m->private);
- if (!m->private) {
- m->private = (void *)-1UL;
- return NULL;
- }
- return m->private;
-}
-
-static void lk_stop(struct seq_file *m, void *p)
-{
- mutex_unlock(<t_kprobes_mutex);
-}
-
-static int lk_show(struct seq_file *m, void *p)
-{
- struct kprobe_entry *e = m->private;
- seq_printf(m, "%s\n", e->key);
- return 0;
-}
-
-static const struct seq_operations ltt_kprobes_list_op = {
- .start = lk_start,
- .next = lk_next,
- .stop = lk_stop,
- .show = lk_show,
-};
-
-static int ltt_kprobes_list_open(struct inode *inode, struct file *file)
-{
- int ret;
-
- ret = seq_open(file, <t_kprobes_list_op);
- if (ret == 0)
- ((struct seq_file *)file->private_data)->private = NULL;
- return ret;
-}
-
-static int ltt_kprobes_list_release(struct inode *inode, struct file *file)
-{
- struct seq_file *seq = file->private_data;
-
- seq->private = NULL;
- return seq_release(inode, file);
-}
-
-static const struct file_operations ltt_kprobes_list = {
- .open = ltt_kprobes_list_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = ltt_kprobes_list_release,
-};
-
-/*
- * kprobes table dump. Callback invoked by ltt-statedump. ltt-statedump must
- * take a reference to this module before calling this callback.
- */
-void ltt_dump_kprobes_table(void *call_data)
-{
- struct kprobe_entry *e;
- struct hlist_head *head;
- struct hlist_node *node;
- unsigned int i;
-
- for (i = 0; i < LTT_KPROBE_TABLE_SIZE; i++) {
- head = <t_kprobe_table[i];
- hlist_for_each_entry(e, node, head, hlist)
- trace_kprobe_table_entry(call_data, e);
- }
-}
-EXPORT_SYMBOL_GPL(ltt_dump_kprobes_table);
-
-static int __init ltt_kprobes_init(void)
-{
- struct dentry *ltt_root_dentry;
- int ret = 0;
-
- printk(KERN_INFO "LTT : ltt-kprobes init\n");
- mutex_lock(<t_kprobes_mutex);
-
- ltt_root_dentry = get_ltt_root();
- if (!ltt_root_dentry) {
- ret = -ENOENT;
- goto err_no_root;
- }
-
- ltt_kprobes_dir = debugfs_create_dir(LTT_KPROBES_DIR, ltt_root_dentry);
- if (!ltt_kprobes_dir) {
- printk(KERN_ERR
- "ltt_kprobes_init: failed to create dir %s\n",
- LTT_KPROBES_DIR);
- ret = -ENOMEM;
- goto err_no_dir;
- }
-
- ltt_kprobes_enable_dentry = debugfs_create_file(LTT_KPROBES_ENABLE,
- S_IWUSR,
- ltt_kprobes_dir, NULL,
- <t_kprobes_enable);
- if (IS_ERR(ltt_kprobes_enable_dentry) || !ltt_kprobes_enable_dentry) {
- printk(KERN_ERR
- "ltt_kprobes_init: failed to create file %s\n",
- LTT_KPROBES_ENABLE);
- ret = -ENOMEM;
- goto err_no_enable;
- }
-
- ltt_kprobes_disable_dentry = debugfs_create_file(LTT_KPROBES_DISABLE,
- S_IWUSR,
- ltt_kprobes_dir, NULL,
- <t_kprobes_disable);
- if (IS_ERR(ltt_kprobes_disable_dentry) || !ltt_kprobes_disable_dentry) {
- printk(KERN_ERR
- "ltt_kprobes_init: failed to create file %s\n",
- LTT_KPROBES_DISABLE);
- ret = -ENOMEM;
- goto err_no_disable;
- }
-
- ltt_kprobes_list_dentry = debugfs_create_file(LTT_KPROBES_LIST,
- S_IWUSR, ltt_kprobes_dir,
- NULL, <t_kprobes_list);
- if (IS_ERR(ltt_kprobes_list_dentry) || !ltt_kprobes_list_dentry) {
- printk(KERN_ERR
- "ltt_kprobes_init: failed to create file %s\n",
- LTT_KPROBES_LIST);
- ret = -ENOMEM;
- goto err_no_list;
- }
- ltt_statedump_register_kprobes_dump(ltt_dump_kprobes_table);
-
- mutex_unlock(<t_kprobes_mutex);
- return ret;
-
-err_no_list:
- debugfs_remove(ltt_kprobes_disable_dentry);
-err_no_disable:
- debugfs_remove(ltt_kprobes_enable_dentry);
-err_no_enable:
- debugfs_remove(ltt_kprobes_dir);
-err_no_dir:
-err_no_root:
- mutex_unlock(<t_kprobes_mutex);
- return ret;
-}
-module_init(ltt_kprobes_init);
-
-static void __exit ltt_kprobes_exit(void)
-{
- printk(KERN_INFO "LTT : ltt-kprobes exit\n");
- mutex_lock(<t_kprobes_mutex);
- module_exit = 1;
- ltt_statedump_unregister_kprobes_dump(ltt_dump_kprobes_table);
- debugfs_remove(ltt_kprobes_list_dentry);
- debugfs_remove(ltt_kprobes_disable_dentry);
- debugfs_remove(ltt_kprobes_enable_dentry);
- debugfs_remove(ltt_kprobes_dir);
- ltt_unregister_all_kprobes();
- mutex_unlock(<t_kprobes_mutex);
-}
-module_exit(ltt_kprobes_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Kprobes Support");
+++ /dev/null
-/*
- * Copyright (C) 2007 Mathieu Desnoyers
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/stat.h>
-#include <linux/vmalloc.h>
-#include <linux/marker.h>
-#include <linux/uaccess.h>
-#include <linux/string.h>
-#include <linux/ctype.h>
-#include <linux/list.h>
-#include <linux/mutex.h>
-#include <linux/seq_file.h>
-#include <linux/slab.h>
-
-#include "ltt-tracer.h"
-
-#define DEFAULT_CHANNEL "cpu"
-#define DEFAULT_PROBE "default"
-
-LIST_HEAD(probes_list);
-
-/*
- * Mutex protecting the probe slab cache.
- * Nests inside the traces mutex.
- */
-DEFINE_MUTEX(probes_mutex);
-
-struct ltt_available_probe default_probe = {
- .name = "default",
- .format = NULL,
- .probe_func = ltt_vtrace,
- .callbacks[0] = ltt_serialize_data,
-};
-
-static struct kmem_cache *markers_loaded_cachep;
-static LIST_HEAD(markers_loaded_list);
-/*
- * List sorted by name strcmp order.
- */
-static LIST_HEAD(probes_registered_list);
-
-static struct ltt_available_probe *get_probe_from_name(const char *pname)
-{
- struct ltt_available_probe *iter;
- int comparison, found = 0;
-
- if (!pname)
- pname = DEFAULT_PROBE;
- list_for_each_entry(iter, &probes_registered_list, node) {
- comparison = strcmp(pname, iter->name);
- if (!comparison)
- found = 1;
- if (comparison <= 0)
- break;
- }
- if (found)
- return iter;
- else
- return NULL;
-}
-
-int ltt_probe_register(struct ltt_available_probe *pdata)
-{
- int ret = 0;
- int comparison;
- struct ltt_available_probe *iter;
-
- mutex_lock(&probes_mutex);
- list_for_each_entry_reverse(iter, &probes_registered_list, node) {
- comparison = strcmp(pdata->name, iter->name);
- if (!comparison) {
- ret = -EBUSY;
- goto end;
- } else if (comparison > 0) {
- /* We belong to the location right after iter. */
- list_add(&pdata->node, &iter->node);
- goto end;
- }
- }
- /* Should be added at the head of the list */
- list_add(&pdata->node, &probes_registered_list);
-end:
- mutex_unlock(&probes_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_probe_register);
-
-/*
- * Called when a probe does not want to be called anymore.
- */
-int ltt_probe_unregister(struct ltt_available_probe *pdata)
-{
- int ret = 0;
- struct ltt_active_marker *amark, *tmp;
-
- mutex_lock(&probes_mutex);
- list_for_each_entry_safe(amark, tmp, &markers_loaded_list, node) {
- if (amark->probe == pdata) {
- ret = marker_probe_unregister_private_data(
- pdata->probe_func, amark);
- if (ret)
- goto end;
- list_del(&amark->node);
- kmem_cache_free(markers_loaded_cachep, amark);
- }
- }
- list_del(&pdata->node);
-end:
- mutex_unlock(&probes_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_probe_unregister);
-
-/*
- * Connect marker "mname" to probe "pname".
- * Only allow _only_ probe instance to be connected to a marker.
- */
-int ltt_marker_connect(const char *channel, const char *mname,
- const char *pname)
-{
- int ret;
- struct ltt_active_marker *pdata;
- struct ltt_available_probe *probe;
-
- ltt_lock_traces();
- mutex_lock(&probes_mutex);
- probe = get_probe_from_name(pname);
- if (!probe) {
- ret = -ENOENT;
- goto end;
- }
- pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
- if (pdata && !IS_ERR(pdata)) {
- ret = -EEXIST;
- goto end;
- }
- pdata = kmem_cache_zalloc(markers_loaded_cachep, GFP_KERNEL);
- if (!pdata) {
- ret = -ENOMEM;
- goto end;
- }
- pdata->probe = probe;
- /*
- * ID has priority over channel in case of conflict.
- */
- ret = marker_probe_register(channel, mname, NULL,
- probe->probe_func, pdata);
- if (ret)
- kmem_cache_free(markers_loaded_cachep, pdata);
- else
- list_add(&pdata->node, &markers_loaded_list);
-end:
- mutex_unlock(&probes_mutex);
- ltt_unlock_traces();
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_marker_connect);
-
-/*
- * Disconnect marker "mname", probe "pname".
- */
-int ltt_marker_disconnect(const char *channel, const char *mname,
- const char *pname)
-{
- struct ltt_active_marker *pdata;
- struct ltt_available_probe *probe;
- int ret = 0;
-
- mutex_lock(&probes_mutex);
- probe = get_probe_from_name(pname);
- if (!probe) {
- ret = -ENOENT;
- goto end;
- }
- pdata = marker_get_private_data(channel, mname, probe->probe_func, 0);
- if (IS_ERR(pdata)) {
- ret = PTR_ERR(pdata);
- goto end;
- } else if (!pdata) {
- /*
- * Not registered by us.
- */
- ret = -EPERM;
- goto end;
- }
- ret = marker_probe_unregister(channel, mname, probe->probe_func, pdata);
- if (ret)
- goto end;
- else {
- list_del(&pdata->node);
- kmem_cache_free(markers_loaded_cachep, pdata);
- }
-end:
- mutex_unlock(&probes_mutex);
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_marker_disconnect);
-
-static void disconnect_all_markers(void)
-{
- struct ltt_active_marker *pdata, *tmp;
-
- list_for_each_entry_safe(pdata, tmp, &markers_loaded_list, node) {
- marker_probe_unregister_private_data(pdata->probe->probe_func,
- pdata);
- list_del(&pdata->node);
- kmem_cache_free(markers_loaded_cachep, pdata);
- }
-}
-
-static int __init marker_control_init(void)
-{
- int ret;
-
- markers_loaded_cachep = KMEM_CACHE(ltt_active_marker, 0);
-
- ret = ltt_probe_register(&default_probe);
- BUG_ON(ret);
- ret = ltt_marker_connect("metadata", "core_marker_format",
- DEFAULT_PROBE);
- BUG_ON(ret);
- ret = ltt_marker_connect("metadata", "core_marker_id", DEFAULT_PROBE);
- BUG_ON(ret);
-
- return 0;
-}
-module_init(marker_control_init);
-
-static void __exit marker_control_exit(void)
-{
- int ret;
-
- ret = ltt_marker_disconnect("metadata", "core_marker_format",
- DEFAULT_PROBE);
- BUG_ON(ret);
- ret = ltt_marker_disconnect("metadata", "core_marker_id",
- DEFAULT_PROBE);
- BUG_ON(ret);
- ret = ltt_probe_unregister(&default_probe);
- BUG_ON(ret);
- disconnect_all_markers();
- kmem_cache_destroy(markers_loaded_cachep);
- marker_synchronize_unregister();
-}
-module_exit(marker_control_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Marker Control");
+++ /dev/null
-/*
- * LTTng serializing code.
- *
- * Copyright Mathieu Desnoyers, March 2007.
- *
- * Dual LGPL v2.1/GPL v2 license.
- *
- * See this discussion about weirdness about passing va_list and then va_list to
- * functions. (related to array argument passing). va_list seems to be
- * implemented as an array on x86_64, but not on i386... This is why we pass a
- * va_list * to ltt_vtrace.
- */
-
-#include <stdarg.h>
-#include <linux/ctype.h>
-#include <linux/string.h>
-#include <linux/module.h>
-
-#include "ltt-tracer.h"
-
-enum ltt_type {
- LTT_TYPE_SIGNED_INT,
- LTT_TYPE_UNSIGNED_INT,
- LTT_TYPE_STRING,
- LTT_TYPE_NONE,
-};
-
-#define LTT_ATTRIBUTE_NETWORK_BYTE_ORDER (1<<1)
-
-/*
- * Stack used to keep track of string length at size calculation, passed to
- * string copy to handle racy input string updates.
- * Can be used by any context; this is ensured by putting the stack position
- * back to its original position after using it.
- */
-#define TRACER_STACK_LEN (PAGE_SIZE / sizeof(unsigned long))
-static DEFINE_PER_CPU(unsigned long [TRACER_STACK_LEN],
- tracer_stack);
-static DEFINE_PER_CPU(unsigned int, tracer_stack_pos);
-
-/*
- * Inspired from vsnprintf
- *
- * The serialization format string supports the basic printf format strings.
- * In addition, it defines new formats that can be used to serialize more
- * complex/non portable data structures.
- *
- * Typical use:
- *
- * field_name %ctype
- * field_name #tracetype %ctype
- * field_name #tracetype %ctype1 %ctype2 ...
- *
- * A conversion is performed between format string types supported by GCC and
- * the trace type requested. GCC type is used to perform type checking on format
- * strings. Trace type is used to specify the exact binary representation
- * in the trace. A mapping is done between one or more GCC types to one trace
- * type. Sign extension, if required by the conversion, is performed following
- * the trace type.
- *
- * If a gcc format is not declared with a trace format, the gcc format is
- * also used as binary representation in the trace.
- *
- * Strings are supported with %s.
- * A single tracetype (sequence) can take multiple c types as parameter.
- *
- * c types:
- *
- * see printf(3).
- *
- * Note: to write a uint32_t in a trace, the following expression is recommended
- * si it can be portable:
- *
- * ("#4u%lu", (unsigned long)var)
- *
- * trace types:
- *
- * Serialization specific formats :
- *
- * Fixed size integers
- * #1u writes uint8_t
- * #2u writes uint16_t
- * #4u writes uint32_t
- * #8u writes uint64_t
- * #1d writes int8_t
- * #2d writes int16_t
- * #4d writes int32_t
- * #8d writes int64_t
- * i.e.:
- * #1u%lu #2u%lu #4d%lu #8d%lu #llu%hu #d%lu
- *
- * * Attributes:
- *
- * n: (for network byte order)
- * #ntracetype%ctype
- * is written in the trace in network byte order.
- *
- * i.e.: #bn4u%lu, #n%lu, #b%u
- *
- * TODO (eventually)
- * Variable length sequence
- * #a #tracetype1 #tracetype2 %array_ptr %elem_size %num_elems
- * In the trace:
- * #a specifies that this is a sequence
- * #tracetype1 is the type of elements in the sequence
- * #tracetype2 is the type of the element count
- * GCC input:
- * array_ptr is a pointer to an array that contains members of size
- * elem_size.
- * num_elems is the number of elements in the array.
- * i.e.: #a #lu #lu %p %lu %u
- *
- * Callback
- * #k callback (taken from the probe data)
- * The following % arguments are exepected by the callback
- *
- * i.e.: #a #lu #lu #k %p
- *
- * Note: No conversion is done from floats to integers, nor from integers to
- * floats between c types and trace types. float conversion from double to float
- * or from float to double is also not supported.
- *
- * REMOVE
- * %*b expects sizeof(data), data
- * where sizeof(data) is 1, 2, 4 or 8
- *
- * Fixed length struct, union or array.
- * FIXME: unable to extract those sizes statically.
- * %*r expects sizeof(*ptr), ptr
- * %*.*r expects sizeof(*ptr), __alignof__(*ptr), ptr
- * struct and unions removed.
- * Fixed length array:
- * [%p]#a[len #tracetype]
- * i.e.: [%p]#a[12 #lu]
- *
- * Variable length sequence
- * %*.*:*v expects sizeof(*ptr), __alignof__(*ptr), elem_num, ptr
- * where elem_num is the number of elements in the sequence
- */
-static inline
-const char *parse_trace_type(const char *fmt, char *trace_size,
- enum ltt_type *trace_type,
- unsigned long *attributes)
-{
- int qualifier; /* 'h', 'l', or 'L' for integer fields */
- /* 'z' support added 23/7/1999 S.H. */
- /* 'z' changed to 'Z' --davidm 1/25/99 */
- /* 't' added for ptrdiff_t */
-
- /* parse attributes. */
-repeat:
- switch (*fmt) {
- case 'n':
- *attributes |= LTT_ATTRIBUTE_NETWORK_BYTE_ORDER;
- ++fmt;
- goto repeat;
- }
-
- /* get the conversion qualifier */
- qualifier = -1;
- if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
- *fmt == 'Z' || *fmt == 'z' || *fmt == 't' ||
- *fmt == 'S' || *fmt == '1' || *fmt == '2' ||
- *fmt == '4' || *fmt == 8) {
- qualifier = *fmt;
- ++fmt;
- if (qualifier == 'l' && *fmt == 'l') {
- qualifier = 'L';
- ++fmt;
- }
- }
-
- switch (*fmt) {
- case 'c':
- *trace_type = LTT_TYPE_UNSIGNED_INT;
- *trace_size = sizeof(unsigned char);
- goto parse_end;
- case 's':
- *trace_type = LTT_TYPE_STRING;
- goto parse_end;
- case 'p':
- *trace_type = LTT_TYPE_UNSIGNED_INT;
- *trace_size = sizeof(void *);
- goto parse_end;
- case 'd':
- case 'i':
- *trace_type = LTT_TYPE_SIGNED_INT;
- break;
- case 'o':
- case 'u':
- case 'x':
- case 'X':
- *trace_type = LTT_TYPE_UNSIGNED_INT;
- break;
- default:
- if (!*fmt)
- --fmt;
- goto parse_end;
- }
- switch (qualifier) {
- case 'L':
- *trace_size = sizeof(long long);
- break;
- case 'l':
- *trace_size = sizeof(long);
- break;
- case 'Z':
- case 'z':
- *trace_size = sizeof(size_t);
- break;
- case 't':
- *trace_size = sizeof(ptrdiff_t);
- break;
- case 'h':
- *trace_size = sizeof(short);
- break;
- case '1':
- *trace_size = sizeof(uint8_t);
- break;
- case '2':
- *trace_size = sizeof(uint16_t);
- break;
- case '4':
- *trace_size = sizeof(uint32_t);
- break;
- case '8':
- *trace_size = sizeof(uint64_t);
- break;
- default:
- *trace_size = sizeof(int);
- }
-
-parse_end:
- return fmt;
-}
-
-/*
- * Restrictions:
- * Field width and precision are *not* supported.
- * %n not supported.
- */
-static inline
-const char *parse_c_type(const char *fmt, char *c_size, enum ltt_type *c_type,
- char *outfmt)
-{
- int qualifier; /* 'h', 'l', or 'L' for integer fields */
- /* 'z' support added 23/7/1999 S.H. */
- /* 'z' changed to 'Z' --davidm 1/25/99 */
- /* 't' added for ptrdiff_t */
-
- /* process flags : ignore standard print formats for now. */
-repeat:
- switch (*fmt) {
- case '-':
- case '+':
- case ' ':
- case '#':
- case '0':
- ++fmt;
- goto repeat;
- }
-
- /* get the conversion qualifier */
- qualifier = -1;
- if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L' ||
- *fmt == 'Z' || *fmt == 'z' || *fmt == 't' ||
- *fmt == 'S') {
- qualifier = *fmt;
- ++fmt;
- if (qualifier == 'l' && *fmt == 'l') {
- qualifier = 'L';
- ++fmt;
- }
- }
-
- if (outfmt) {
- if (qualifier != -1)
- *outfmt++ = (char)qualifier;
- *outfmt++ = *fmt;
- *outfmt = 0;
- }
-
- switch (*fmt) {
- case 'c':
- *c_type = LTT_TYPE_UNSIGNED_INT;
- *c_size = sizeof(unsigned char);
- goto parse_end;
- case 's':
- *c_type = LTT_TYPE_STRING;
- goto parse_end;
- case 'p':
- *c_type = LTT_TYPE_UNSIGNED_INT;
- *c_size = sizeof(void *);
- goto parse_end;
- case 'd':
- case 'i':
- *c_type = LTT_TYPE_SIGNED_INT;
- break;
- case 'o':
- case 'u':
- case 'x':
- case 'X':
- *c_type = LTT_TYPE_UNSIGNED_INT;
- break;
- default:
- if (!*fmt)
- --fmt;
- goto parse_end;
- }
- switch (qualifier) {
- case 'L':
- *c_size = sizeof(long long);
- break;
- case 'l':
- *c_size = sizeof(long);
- break;
- case 'Z':
- case 'z':
- *c_size = sizeof(size_t);
- break;
- case 't':
- *c_size = sizeof(ptrdiff_t);
- break;
- case 'h':
- *c_size = sizeof(short);
- break;
- default:
- *c_size = sizeof(int);
- }
-
-parse_end:
- return fmt;
-}
-
-static inline
-size_t serialize_trace_data(struct ltt_chanbuf *buf, size_t buf_offset,
- char trace_size, enum ltt_type trace_type,
- char c_size, enum ltt_type c_type,
- unsigned int *stack_pos_ctx,
- int *largest_align,
- va_list *args)
-{
- union {
- unsigned long v_ulong;
- uint64_t v_uint64;
- struct {
- const char *s;
- size_t len;
- } v_string;
- } tmp;
-
- /*
- * Be careful about sign extension here.
- * Sign extension is done with the destination (trace) type.
- */
- switch (trace_type) {
- case LTT_TYPE_SIGNED_INT:
- switch (c_size) {
- case 1:
- tmp.v_ulong = (long)(int8_t)va_arg(*args, int);
- break;
- case 2:
- tmp.v_ulong = (long)(int16_t)va_arg(*args, int);
- break;
- case 4:
- tmp.v_ulong = (long)(int32_t)va_arg(*args, int);
- break;
- case 8:
- tmp.v_uint64 = va_arg(*args, int64_t);
- break;
- default:
- BUG();
- }
- break;
- case LTT_TYPE_UNSIGNED_INT:
- switch (c_size) {
- case 1:
- tmp.v_ulong = (unsigned long)(uint8_t)va_arg(*args, unsigned int);
- break;
- case 2:
- tmp.v_ulong = (unsigned long)(uint16_t)va_arg(*args, unsigned int);
- break;
- case 4:
- tmp.v_ulong = (unsigned long)(uint32_t)va_arg(*args, unsigned int);
- break;
- case 8:
- tmp.v_uint64 = va_arg(*args, uint64_t);
- break;
- default:
- BUG();
- }
- break;
- case LTT_TYPE_STRING:
- tmp.v_string.s = va_arg(*args, const char *);
- if ((unsigned long)tmp.v_string.s < PAGE_SIZE)
- tmp.v_string.s = "<NULL>";
- if (!buf) {
- /*
- * Reserve tracer stack entry.
- */
- __get_cpu_var(tracer_stack_pos)++;
- WARN_ON_ONCE(__get_cpu_var(tracer_stack_pos)
- > TRACER_STACK_LEN);
- barrier();
- __get_cpu_var(tracer_stack)[*stack_pos_ctx] =
- strlen(tmp.v_string.s) + 1;
- }
- tmp.v_string.len = __get_cpu_var(tracer_stack)
- [(*stack_pos_ctx)++];
- if (buf)
- ltt_relay_strncpy(&buf->a, buf->a.chan, buf_offset,
- tmp.v_string.s, tmp.v_string.len);
- buf_offset += tmp.v_string.len;
- goto copydone;
- default:
- BUG();
- }
-
- /*
- * If trace_size is lower or equal to 4 bytes, there is no sign
- * extension to do because we are already encoded in a long. Therefore,
- * we can combine signed and unsigned ops. 4 bytes float also works
- * with this, because we do a simple copy of 4 bytes into 4 bytes
- * without manipulation (and we do not support conversion from integers
- * to floats).
- * It is also the case if c_size is 8 bytes, which is the largest
- * possible integer.
- */
- if (ltt_get_alignment()) {
- buf_offset += ltt_align(buf_offset, trace_size);
- if (largest_align)
- *largest_align = max_t(int, *largest_align, trace_size);
- }
- if (trace_size <= 4 || c_size == 8) {
- if (buf) {
- switch (trace_size) {
- case 1:
- if (c_size == 8)
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint8_t[]){ (uint8_t)tmp.v_uint64 },
- sizeof(uint8_t));
- else
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint8_t[]){ (uint8_t)tmp.v_ulong },
- sizeof(uint8_t));
- break;
- case 2:
- if (c_size == 8)
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint16_t[]){ (uint16_t)tmp.v_uint64 },
- sizeof(uint16_t));
- else
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint16_t[]){ (uint16_t)tmp.v_ulong },
- sizeof(uint16_t));
- break;
- case 4:
- if (c_size == 8)
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint32_t[]){ (uint32_t)tmp.v_uint64 },
- sizeof(uint32_t));
- else
- ltt_relay_write(&buf->a, buf->a.chan,
- buf_offset,
- (uint32_t[]){ (uint32_t)tmp.v_ulong },
- sizeof(uint32_t));
- break;
- case 8:
- /*
- * c_size cannot be other than 8 here because
- * trace_size > 4.
- */
- ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
- (uint64_t[]){ (uint64_t)tmp.v_uint64 },
- sizeof(uint64_t));
- break;
- default:
- BUG();
- }
- }
- buf_offset += trace_size;
- goto copydone;
- } else {
- /*
- * Perform sign extension.
- */
- if (buf) {
- switch (trace_type) {
- case LTT_TYPE_SIGNED_INT:
- ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
- (int64_t[]){ (int64_t)tmp.v_ulong },
- sizeof(int64_t));
- break;
- case LTT_TYPE_UNSIGNED_INT:
- ltt_relay_write(&buf->a, buf->a.chan, buf_offset,
- (uint64_t[]){ (uint64_t)tmp.v_ulong },
- sizeof(uint64_t));
- break;
- default:
- BUG();
- }
- }
- buf_offset += trace_size;
- goto copydone;
- }
-
-copydone:
- return buf_offset;
-}
-
-notrace size_t
-ltt_serialize_data(struct ltt_chanbuf *buf, size_t buf_offset,
- struct ltt_serialize_closure *closure,
- void *serialize_private, unsigned int stack_pos_ctx,
- int *largest_align, const char *fmt, va_list *args)
-{
- char trace_size = 0, c_size = 0; /*
- * 0 (unset), 1, 2, 4, 8 bytes.
- */
- enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
- unsigned long attributes = 0;
-
- for (; *fmt ; ++fmt) {
- switch (*fmt) {
- case '#':
- /* tracetypes (#) */
- ++fmt; /* skip first '#' */
- if (*fmt == '#') /* Escaped ## */
- break;
- attributes = 0;
- fmt = parse_trace_type(fmt, &trace_size, &trace_type,
- &attributes);
- break;
- case '%':
- /* c types (%) */
- ++fmt; /* skip first '%' */
- if (*fmt == '%') /* Escaped %% */
- break;
- fmt = parse_c_type(fmt, &c_size, &c_type, NULL);
- /*
- * Output c types if no trace types has been
- * specified.
- */
- if (!trace_size)
- trace_size = c_size;
- if (trace_type == LTT_TYPE_NONE)
- trace_type = c_type;
- if (c_type == LTT_TYPE_STRING)
- trace_type = LTT_TYPE_STRING;
- /* perform trace write */
- buf_offset = serialize_trace_data(buf, buf_offset,
- trace_size,
- trace_type, c_size,
- c_type,
- &stack_pos_ctx,
- largest_align,
- args);
- trace_size = 0;
- c_size = 0;
- trace_type = LTT_TYPE_NONE;
- c_size = LTT_TYPE_NONE;
- attributes = 0;
- break;
- /* default is to skip the text, doing nothing */
- }
- }
- return buf_offset;
-}
-EXPORT_SYMBOL_GPL(ltt_serialize_data);
-
-static inline
-uint64_t unserialize_base_type(struct ltt_chanbuf *buf,
- size_t *ppos, char trace_size,
- enum ltt_type trace_type)
-{
- uint64_t tmp;
-
- *ppos += ltt_align(*ppos, trace_size);
- ltt_relay_read(&buf->a, *ppos, &tmp, trace_size);
- *ppos += trace_size;
-
- switch (trace_type) {
- case LTT_TYPE_SIGNED_INT:
- switch (trace_size) {
- case 1:
- return (uint64_t)*(int8_t *)&tmp;
- case 2:
- return (uint64_t)*(int16_t *)&tmp;
- case 4:
- return (uint64_t)*(int32_t *)&tmp;
- case 8:
- return tmp;
- }
- break;
- case LTT_TYPE_UNSIGNED_INT:
- switch (trace_size) {
- case 1:
- return (uint64_t)*(uint8_t *)&tmp;
- case 2:
- return (uint64_t)*(uint16_t *)&tmp;
- case 4:
- return (uint64_t)*(uint32_t *)&tmp;
- case 8:
- return tmp;
- }
- break;
- default:
- break;
- }
-
- BUG();
- return 0;
-}
-
-static
-int serialize_printf_data(struct ltt_chanbuf *buf, size_t *ppos,
- char trace_size, enum ltt_type trace_type,
- char c_size, enum ltt_type c_type, char *output,
- ssize_t outlen, const char *outfmt)
-{
- u64 value;
- outlen = outlen < 0 ? 0 : outlen;
-
- if (trace_type == LTT_TYPE_STRING) {
- size_t len = ltt_relay_read_cstr(&buf->a, *ppos, output,
- outlen);
- *ppos += len + 1;
- return len;
- }
-
- value = unserialize_base_type(buf, ppos, trace_size, trace_type);
-
- if (c_size == 8)
- return snprintf(output, outlen, outfmt, value);
- else
- return snprintf(output, outlen, outfmt, (unsigned int)value);
-}
-
-/**
- * ltt_serialize_printf - Format a string and place it in a buffer
- * @buf: The ltt-relay buffer that store binary data
- * @buf_offset: binary data's offset in @buf (should be masked to use as offset)
- * @msg_size: return message's length
- * @output: The buffer to place the result into
- * @outlen: The size of the buffer, including the trailing '\0'
- * @fmt: The format string to use
- *
- * The return value is the number of characters which would
- * be generated for the given input, excluding the trailing
- * '\0', as per ISO C99. If the return is greater than or equal to @outlen,
- * the resulting string is truncated.
- */
-size_t ltt_serialize_printf(struct ltt_chanbuf *buf, unsigned long buf_offset,
- size_t *msg_size, char *output, size_t outlen,
- const char *fmt)
-{
- char trace_size = 0, c_size = 0; /*
- * 0 (unset), 1, 2, 4, 8 bytes.
- */
- enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
- unsigned long attributes = 0;
- char outfmt[4] = "%";
- size_t outpos = 0;
- size_t len;
- size_t msgpos = buf_offset;
-
- for (; *fmt ; ++fmt) {
- switch (*fmt) {
- case '#':
- /* tracetypes (#) */
- ++fmt; /* skip first '#' */
- if (*fmt == '#') { /* Escaped ## */
- if (outpos < outlen)
- output[outpos] = '#';
- outpos++;
- break;
- }
- attributes = 0;
- fmt = parse_trace_type(fmt, &trace_size, &trace_type,
- &attributes);
- break;
- case '%':
- /* c types (%) */
- ++fmt; /* skip first '%' */
- if (*fmt == '%') { /* Escaped %% */
- if (outpos < outlen)
- output[outpos] = '%';
- outpos++;
- break;
- }
- fmt = parse_c_type(fmt, &c_size, &c_type, outfmt + 1);
- /*
- * Output c types if no trace types has been
- * specified.
- */
- if (!trace_size)
- trace_size = c_size;
- if (trace_type == LTT_TYPE_NONE)
- trace_type = c_type;
- if (c_type == LTT_TYPE_STRING)
- trace_type = LTT_TYPE_STRING;
-
- /* perform trace printf */
- len = serialize_printf_data(buf, &msgpos, trace_size,
- trace_type, c_size, c_type,
- output + outpos,
- outlen - outpos, outfmt);
- outpos += len;
- trace_size = 0;
- c_size = 0;
- trace_type = LTT_TYPE_NONE;
- c_size = LTT_TYPE_NONE;
- attributes = 0;
- break;
- default:
- if (outpos < outlen)
- output[outpos] = *fmt;
- outpos++;
- break;
- }
- }
- if (msg_size)
- *msg_size = (size_t)(msgpos - buf_offset);
- /*
- * Make sure we end output with terminating \0 when truncated.
- */
- if (outpos >= outlen + 1)
- output[outlen] = '\0';
- return outpos;
-}
-EXPORT_SYMBOL_GPL(ltt_serialize_printf);
-
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
-
-unsigned int ltt_fmt_largest_align(size_t align_drift, const char *fmt)
-{
- char trace_size = 0, c_size = 0;
- enum ltt_type trace_type = LTT_TYPE_NONE, c_type = LTT_TYPE_NONE;
- unsigned long attributes = 0;
- int largest_align = 1;
-
- for (; *fmt ; ++fmt) {
- switch (*fmt) {
- case '#':
- /* tracetypes (#) */
- ++fmt; /* skip first '#' */
- if (*fmt == '#') /* Escaped ## */
- break;
- attributes = 0;
- fmt = parse_trace_type(fmt, &trace_size, &trace_type,
- &attributes);
-
- largest_align = max_t(int, largest_align, trace_size);
- if (largest_align >= ltt_get_alignment())
- goto exit;
- break;
- case '%':
- /* c types (%) */
- ++fmt; /* skip first '%' */
- if (*fmt == '%') /* Escaped %% */
- break;
- fmt = parse_c_type(fmt, &c_size, &c_type, NULL);
- /*
- * Output c types if no trace types has been
- * specified.
- */
- if (!trace_size)
- trace_size = c_size;
- if (trace_type == LTT_TYPE_NONE)
- trace_type = c_type;
- if (c_type == LTT_TYPE_STRING)
- trace_type = LTT_TYPE_STRING;
-
- largest_align = max_t(int, largest_align, trace_size);
- if (largest_align >= ltt_get_alignment())
- goto exit;
-
- trace_size = 0;
- c_size = 0;
- trace_type = LTT_TYPE_NONE;
- c_size = LTT_TYPE_NONE;
- break;
- }
- }
-
-exit:
- largest_align = min_t(int, largest_align, ltt_get_alignment());
- return (largest_align - align_drift) & (largest_align - 1);
-}
-EXPORT_SYMBOL_GPL(ltt_fmt_largest_align);
-
-#endif
-
-/*
- * Calculate data size
- * Assume that the padding for alignment starts at a sizeof(void *) address.
- */
-static notrace
-size_t ltt_get_data_size(struct ltt_serialize_closure *closure,
- void *serialize_private, unsigned int stack_pos_ctx,
- int *largest_align, const char *fmt, va_list *args)
-{
- ltt_serialize_cb cb = closure->callbacks[0];
- closure->cb_idx = 0;
- return (size_t)cb(NULL, 0, closure, serialize_private, stack_pos_ctx,
- largest_align, fmt, args);
-}
-
-static notrace
-void ltt_write_event_data(struct ltt_chanbuf *buf, size_t buf_offset,
- struct ltt_serialize_closure *closure,
- void *serialize_private, unsigned int stack_pos_ctx,
- int largest_align, const char *fmt, va_list *args)
-{
- ltt_serialize_cb cb = closure->callbacks[0];
- closure->cb_idx = 0;
- buf_offset += ltt_align(buf_offset, largest_align);
- cb(buf, buf_offset, closure, serialize_private, stack_pos_ctx, NULL,
- fmt, args);
-}
-
-
-notrace
-void ltt_vtrace(const struct marker *mdata, void *probe_data, void *call_data,
- const char *fmt, va_list *args)
-{
- int largest_align, ret;
- struct ltt_active_marker *pdata;
- uint16_t eID;
- size_t data_size, slot_size;
- unsigned int chan_index;
- struct ltt_chanbuf *buf;
- struct ltt_chan *chan;
- struct ltt_trace *trace, *dest_trace = NULL;
- uint64_t tsc;
- long buf_offset;
- va_list args_copy;
- struct ltt_serialize_closure closure;
- struct ltt_probe_private_data *private_data = call_data;
- void *serialize_private = NULL;
- int cpu;
- unsigned int rflags;
- unsigned int stack_pos_ctx;
-
- /*
- * This test is useful for quickly exiting static tracing when no trace
- * is active. We expect to have an active trace when we get here.
- */
- if (unlikely(ltt_traces.num_active_traces == 0))
- return;
-
- rcu_read_lock_sched_notrace();
- cpu = smp_processor_id();
- __get_cpu_var(ltt_nesting)++;
- stack_pos_ctx = __get_cpu_var(tracer_stack_pos);
- /*
- * asm volatile and "memory" clobber prevent the compiler from moving
- * instructions out of the ltt nesting count. This is required to ensure
- * that probe side-effects which can cause recursion (e.g. unforeseen
- * traps, divisions by 0, ...) are triggered within the incremented
- * nesting count section.
- */
- barrier();
- pdata = (struct ltt_active_marker *)probe_data;
- eID = mdata->event_id;
- chan_index = mdata->channel_id;
- closure.callbacks = pdata->probe->callbacks;
-
- if (unlikely(private_data)) {
- dest_trace = private_data->trace;
- if (private_data->serializer)
- closure.callbacks = &private_data->serializer;
- serialize_private = private_data->serialize_private;
- }
-
- va_copy(args_copy, *args);
- /*
- * Assumes event payload to start on largest_align alignment.
- */
- largest_align = 1; /* must be non-zero for ltt_align */
- data_size = ltt_get_data_size(&closure, serialize_private,
- stack_pos_ctx, &largest_align,
- fmt, &args_copy);
- largest_align = min_t(int, largest_align, sizeof(void *));
- va_end(args_copy);
-
- /* Iterate on each trace */
- list_for_each_entry_rcu(trace, <t_traces.head, list) {
- /*
- * Expect the filter to filter out events. If we get here,
- * we went through tracepoint activation as a first step.
- */
- if (unlikely(dest_trace && trace != dest_trace))
- continue;
- if (unlikely(!trace->active))
- continue;
- if (unlikely(!ltt_run_filter(trace, eID)))
- continue;
-#ifdef LTT_DEBUG_EVENT_SIZE
- rflags = LTT_RFLAG_ID_SIZE;
-#else
- if (unlikely(eID >= LTT_FREE_EVENTS))
- rflags = LTT_RFLAG_ID;
- else
- rflags = 0;
-#endif
- /*
- * Skip channels added after trace creation.
- */
- if (unlikely(chan_index >= trace->nr_channels))
- continue;
- chan = &trace->channels[chan_index];
- if (!chan->active)
- continue;
-
- /* reserve space : header and data */
- ret = ltt_reserve_slot(chan, trace, data_size, largest_align,
- cpu, &buf, &slot_size, &buf_offset,
- &tsc, &rflags);
- if (unlikely(ret < 0))
- continue; /* buffer full */
-
- va_copy(args_copy, *args);
- /* Out-of-order write : header and data */
- buf_offset = ltt_write_event_header(&buf->a, &chan->a,
- buf_offset, eID, data_size,
- tsc, rflags);
- ltt_write_event_data(buf, buf_offset, &closure,
- serialize_private, stack_pos_ctx,
- largest_align, fmt, &args_copy);
- va_end(args_copy);
- /* Out-of-order commit */
- ltt_commit_slot(buf, chan, buf_offset, data_size, slot_size);
- }
- /*
- * asm volatile and "memory" clobber prevent the compiler from moving
- * instructions out of the ltt nesting count. This is required to ensure
- * that probe side-effects which can cause recursion (e.g. unforeseen
- * traps, divisions by 0, ...) are triggered within the incremented
- * nesting count section.
- */
- barrier();
- __get_cpu_var(tracer_stack_pos) = stack_pos_ctx;
- __get_cpu_var(ltt_nesting)--;
- rcu_read_unlock_sched_notrace();
-}
-EXPORT_SYMBOL_GPL(ltt_vtrace);
-
-notrace
-void ltt_trace(const struct marker *mdata, void *probe_data, void *call_data,
- const char *fmt, ...)
-{
- va_list args;
-
- va_start(args, fmt);
- ltt_vtrace(mdata, probe_data, call_data, fmt, &args);
- va_end(args);
-}
-EXPORT_SYMBOL_GPL(ltt_trace);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Serializer");
+++ /dev/null
-/*
- * Linux Trace Toolkit Kernel State Dump
- *
- * Copyright 2005 -
- * Jean-Hugues Deschenes <jean-hugues.deschenes@polymtl.ca>
- *
- * Changes:
- * Eric Clement: Add listing of network IP interface
- * 2006, 2007 Mathieu Desnoyers Fix kernel threads
- * Various updates
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/netlink.h>
-#include <linux/inet.h>
-#include <linux/ip.h>
-#include <linux/kthread.h>
-#include <linux/proc_fs.h>
-#include <linux/file.h>
-#include <linux/interrupt.h>
-#include <linux/irqnr.h>
-#include <linux/cpu.h>
-#include <linux/netdevice.h>
-#include <linux/inetdevice.h>
-#include <linux/sched.h>
-#include <linux/mm.h>
-#include <linux/marker.h>
-#include <linux/fdtable.h>
-#include <linux/swap.h>
-#include <linux/wait.h>
-#include <linux/mutex.h>
-
-#include "ltt-tracer.h"
-
-#ifdef CONFIG_GENERIC_HARDIRQS
-#include <linux/irq.h>
-#endif
-
-#define NB_PROC_CHUNK 20
-
-/*
- * Protected by the trace lock.
- */
-static struct delayed_work cpu_work[NR_CPUS];
-static DECLARE_WAIT_QUEUE_HEAD(statedump_wq);
-static atomic_t kernel_threads_to_run;
-
-static void empty_cb(void *call_data)
-{
-}
-
-static DEFINE_MUTEX(statedump_cb_mutex);
-static void (*ltt_dump_kprobes_table_cb)(void *call_data) = empty_cb;
-
-enum lttng_thread_type {
- LTTNG_USER_THREAD = 0,
- LTTNG_KERNEL_THREAD = 1,
-};
-
-enum lttng_execution_mode {
- LTTNG_USER_MODE = 0,
- LTTNG_SYSCALL = 1,
- LTTNG_TRAP = 2,
- LTTNG_IRQ = 3,
- LTTNG_SOFTIRQ = 4,
- LTTNG_MODE_UNKNOWN = 5,
-};
-
-enum lttng_execution_submode {
- LTTNG_NONE = 0,
- LTTNG_UNKNOWN = 1,
-};
-
-enum lttng_process_status {
- LTTNG_UNNAMED = 0,
- LTTNG_WAIT_FORK = 1,
- LTTNG_WAIT_CPU = 2,
- LTTNG_EXIT = 3,
- LTTNG_ZOMBIE = 4,
- LTTNG_WAIT = 5,
- LTTNG_RUN = 6,
- LTTNG_DEAD = 7,
-};
-
-#ifdef CONFIG_INET
-static void ltt_enumerate_device(struct ltt_probe_private_data *call_data,
- struct net_device *dev)
-{
- struct in_device *in_dev;
- struct in_ifaddr *ifa;
-
- if (dev->flags & IFF_UP) {
- in_dev = in_dev_get(dev);
- if (in_dev) {
- for (ifa = in_dev->ifa_list; ifa != NULL;
- ifa = ifa->ifa_next)
- __trace_mark(0, netif_state,
- network_ipv4_interface,
- call_data,
- "name %s address #n4u%lu up %d",
- dev->name,
- (unsigned long)ifa->ifa_address,
- 0);
- in_dev_put(in_dev);
- }
- } else
- __trace_mark(0, netif_state, network_ip_interface,
- call_data, "name %s address #n4u%lu up %d",
- dev->name, 0UL, 0);
-}
-
-static inline int
-ltt_enumerate_network_ip_interface(struct ltt_probe_private_data *call_data)
-{
- struct net_device *dev;
-
- read_lock(&dev_base_lock);
- for_each_netdev(&init_net, dev)
- ltt_enumerate_device(call_data, dev);
- read_unlock(&dev_base_lock);
-
- return 0;
-}
-#else /* CONFIG_INET */
-static inline int
-ltt_enumerate_network_ip_interface(struct ltt_probe_private_data *call_data)
-{
- return 0;
-}
-#endif /* CONFIG_INET */
-
-
-static inline void
-ltt_enumerate_task_fd(struct ltt_probe_private_data *call_data,
- struct task_struct *t, char *tmp)
-{
- struct fdtable *fdt;
- struct file *filp;
- unsigned int i;
- const unsigned char *path;
-
- if (!t->files)
- return;
-
- spin_lock(&t->files->file_lock);
- fdt = files_fdtable(t->files);
- for (i = 0; i < fdt->max_fds; i++) {
- filp = fcheck_files(t->files, i);
- if (!filp)
- continue;
- path = d_path(&filp->f_path, tmp, PAGE_SIZE);
- /* Make sure we give at least some info */
- __trace_mark(0, fd_state, file_descriptor, call_data,
- "filename %s pid %d fd %u",
- (IS_ERR(path))?(filp->f_dentry->d_name.name):(path),
- t->pid, i);
- }
- spin_unlock(&t->files->file_lock);
-}
-
-static inline int
-ltt_enumerate_file_descriptors(struct ltt_probe_private_data *call_data)
-{
- struct task_struct *t = &init_task;
- char *tmp = (char *)__get_free_page(GFP_KERNEL);
-
- /* Enumerate active file descriptors */
- do {
- read_lock(&tasklist_lock);
- if (t != &init_task)
- atomic_dec(&t->usage);
- t = next_task(t);
- atomic_inc(&t->usage);
- read_unlock(&tasklist_lock);
- task_lock(t);
- ltt_enumerate_task_fd(call_data, t, tmp);
- task_unlock(t);
- } while (t != &init_task);
- free_page((unsigned long)tmp);
- return 0;
-}
-
-static inline void
-ltt_enumerate_task_vm_maps(struct ltt_probe_private_data *call_data,
- struct task_struct *t)
-{
- struct mm_struct *mm;
- struct vm_area_struct *map;
- unsigned long ino;
-
- /* get_task_mm does a task_lock... */
- mm = get_task_mm(t);
- if (!mm)
- return;
-
- map = mm->mmap;
- if (map) {
- down_read(&mm->mmap_sem);
- while (map) {
- if (map->vm_file)
- ino = map->vm_file->f_dentry->d_inode->i_ino;
- else
- ino = 0;
- __trace_mark(0, vm_state, vm_map, call_data,
- "pid %d start %lu end %lu flags %lu "
- "pgoff %lu inode %lu",
- t->pid, map->vm_start, map->vm_end,
- map->vm_flags, map->vm_pgoff << PAGE_SHIFT,
- ino);
- map = map->vm_next;
- }
- up_read(&mm->mmap_sem);
- }
- mmput(mm);
-}
-
-static inline int
-ltt_enumerate_vm_maps(struct ltt_probe_private_data *call_data)
-{
- struct task_struct *t = &init_task;
-
- do {
- read_lock(&tasklist_lock);
- if (t != &init_task)
- atomic_dec(&t->usage);
- t = next_task(t);
- atomic_inc(&t->usage);
- read_unlock(&tasklist_lock);
- ltt_enumerate_task_vm_maps(call_data, t);
- } while (t != &init_task);
- return 0;
-}
-
-#ifdef CONFIG_GENERIC_HARDIRQS
-static inline void list_interrupts(struct ltt_probe_private_data *call_data)
-{
- unsigned int irq;
- unsigned long flags = 0;
- struct irq_desc *desc;
-
- /* needs irq_desc */
- for_each_irq_desc(irq, desc) {
- struct irqaction *action;
- const char *irq_chip_name =
- desc->chip->name ? : "unnamed_irq_chip";
-
- local_irq_save(flags);
- raw_spin_lock(&desc->lock);
- for (action = desc->action; action; action = action->next)
- __trace_mark(0, irq_state, interrupt, call_data,
- "name %s action %s irq_id %u",
- irq_chip_name, action->name, irq);
- raw_spin_unlock(&desc->lock);
- local_irq_restore(flags);
- }
-}
-#else
-static inline void list_interrupts(struct ltt_probe_private_data *call_data)
-{
-}
-#endif
-
-static inline int
-ltt_enumerate_process_states(struct ltt_probe_private_data *call_data)
-{
- struct task_struct *t = &init_task;
- struct task_struct *p = t;
- enum lttng_process_status status;
- enum lttng_thread_type type;
- enum lttng_execution_mode mode;
- enum lttng_execution_submode submode;
-
- do {
- mode = LTTNG_MODE_UNKNOWN;
- submode = LTTNG_UNKNOWN;
-
- read_lock(&tasklist_lock);
- if (t != &init_task) {
- atomic_dec(&t->usage);
- t = next_thread(t);
- }
- if (t == p) {
- p = next_task(t);
- t = p;
- }
- atomic_inc(&t->usage);
- read_unlock(&tasklist_lock);
-
- task_lock(t);
-
- if (t->exit_state == EXIT_ZOMBIE)
- status = LTTNG_ZOMBIE;
- else if (t->exit_state == EXIT_DEAD)
- status = LTTNG_DEAD;
- else if (t->state == TASK_RUNNING) {
- /* Is this a forked child that has not run yet? */
- if (list_empty(&t->rt.run_list))
- status = LTTNG_WAIT_FORK;
- else
- /*
- * All tasks are considered as wait_cpu;
- * the viewer will sort out if the task was
- * really running at this time.
- */
- status = LTTNG_WAIT_CPU;
- } else if (t->state &
- (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)) {
- /* Task is waiting for something to complete */
- status = LTTNG_WAIT;
- } else
- status = LTTNG_UNNAMED;
- submode = LTTNG_NONE;
-
- /*
- * Verification of t->mm is to filter out kernel threads;
- * Viewer will further filter out if a user-space thread was
- * in syscall mode or not.
- */
- if (t->mm)
- type = LTTNG_USER_THREAD;
- else
- type = LTTNG_KERNEL_THREAD;
-
- __trace_mark(0, task_state, process_state, call_data,
- "pid %d parent_pid %d name %s type %d mode %d "
- "submode %d status %d tgid %d",
- t->pid, t->parent->pid, t->comm,
- type, mode, submode, status, t->tgid);
- task_unlock(t);
- } while (t != &init_task);
-
- return 0;
-}
-
-void ltt_statedump_register_kprobes_dump(void (*callback)(void *call_data))
-{
- mutex_lock(&statedump_cb_mutex);
- ltt_dump_kprobes_table_cb = callback;
- mutex_unlock(&statedump_cb_mutex);
-}
-EXPORT_SYMBOL_GPL(ltt_statedump_register_kprobes_dump);
-
-void ltt_statedump_unregister_kprobes_dump(void (*callback)(void *call_data))
-{
- mutex_lock(&statedump_cb_mutex);
- ltt_dump_kprobes_table_cb = empty_cb;
- mutex_unlock(&statedump_cb_mutex);
-}
-EXPORT_SYMBOL_GPL(ltt_statedump_unregister_kprobes_dump);
-
-void ltt_statedump_work_func(struct work_struct *work)
-{
- if (atomic_dec_and_test(&kernel_threads_to_run))
- /* If we are the last thread, wake up do_ltt_statedump */
- wake_up(&statedump_wq);
-}
-
-static int do_ltt_statedump(struct ltt_probe_private_data *call_data)
-{
- int cpu;
- struct module *cb_owner;
-
- printk(KERN_DEBUG "LTT state dump thread start\n");
- ltt_enumerate_process_states(call_data);
- ltt_enumerate_file_descriptors(call_data);
- list_modules(call_data);
- ltt_enumerate_vm_maps(call_data);
- list_interrupts(call_data);
- ltt_enumerate_network_ip_interface(call_data);
- ltt_dump_swap_files(call_data);
- ltt_dump_sys_call_table(call_data);
- ltt_dump_softirq_vec(call_data);
- ltt_dump_idt_table(call_data);
-
- mutex_lock(&statedump_cb_mutex);
-
- cb_owner = __module_address((unsigned long)ltt_dump_kprobes_table_cb);
- __module_get(cb_owner);
- ltt_dump_kprobes_table_cb(call_data);
- module_put(cb_owner);
-
- mutex_unlock(&statedump_cb_mutex);
-
- /*
- * Fire off a work queue on each CPU. Their sole purpose in life
- * is to guarantee that each CPU has been in a state where is was in
- * syscall mode (i.e. not in a trap, an IRQ or a soft IRQ).
- */
- get_online_cpus();
- atomic_set(&kernel_threads_to_run, num_online_cpus());
- for_each_online_cpu(cpu) {
- INIT_DELAYED_WORK(&cpu_work[cpu], ltt_statedump_work_func);
- 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));
- put_online_cpus();
- /* Our work is done */
- printk(KERN_DEBUG "LTT state dump end\n");
- __trace_mark(0, global_state, statedump_end,
- call_data, MARK_NOARGS);
- return 0;
-}
-
-/*
- * Called with trace lock held.
- */
-int ltt_statedump_start(struct ltt_trace *trace)
-{
- struct ltt_probe_private_data call_data;
- printk(KERN_DEBUG "LTT state dump begin\n");
-
- call_data.trace = trace;
- call_data.serializer = NULL;
- return do_ltt_statedump(&call_data);
-}
-
-static int __init statedump_init(void)
-{
- int ret;
- printk(KERN_DEBUG "LTT : State dump init\n");
- ret = ltt_module_register(LTT_FUNCTION_STATEDUMP,
- ltt_statedump_start, THIS_MODULE);
- return ret;
-}
-
-static void __exit statedump_exit(void)
-{
- printk(KERN_DEBUG "LTT : State dump exit\n");
- ltt_module_unregister(LTT_FUNCTION_STATEDUMP);
-}
-
-module_init(statedump_init)
-module_exit(statedump_exit)
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Jean-Hugues Deschenes");
-MODULE_DESCRIPTION("Linux Trace Toolkit Statedump");
+++ /dev/null
-/*
- * LTT trace control module over debugfs.
- *
- * Copyright 2008 - Zhaolei <zhaolei@cn.fujitsu.com>
- *
- * Copyright 2009 - Gui Jianfeng <guijianfeng@cn.fujitsu.com>
- * Make mark-control work in debugfs
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-/*
- * Todo:
- * Impl read operations for control file to read attributes
- * Create a README file in ltt control dir, for display help info
- */
-
-#include <linux/module.h>
-#include <linux/fs.h>
-#include <linux/uaccess.h>
-#include <linux/debugfs.h>
-#include <linux/notifier.h>
-#include <linux/jiffies.h>
-#include <linux/marker.h>
-
-#include "ltt-tracer.h"
-
-#define LTT_CONTROL_DIR "control"
-#define MARKERS_CONTROL_DIR "markers"
-#define LTT_SETUP_TRACE_FILE "setup_trace"
-#define LTT_DESTROY_TRACE_FILE "destroy_trace"
-
-#define LTT_WRITE_MAXLEN (128)
-
-struct dentry *ltt_control_dir, *ltt_setup_trace_file, *ltt_destroy_trace_file,
- *markers_control_dir;
-
-/*
- * the traces_lock nests inside control_lock.
- * control_lock protects the consistency of directories presented in ltt
- * directory.
- */
-static DEFINE_MUTEX(control_lock);
-
-/*
- * big note about locking for marker control files :
- * If a marker control file is added/removed manually racing with module
- * load/unload, there may be warning messages appearing, but those two
- * operations should be able to execute concurrently without any lock
- * synchronizing their operation one wrt another.
- * Locking the marker mutex, module mutex and also keeping a mutex here
- * from mkdir/rmdir _and_ from the notifier called from module load/unload makes
- * life miserable and just asks for deadlocks.
- */
-
-/*
- * lookup a file/dir in parent dir.
- * only designed to work well for debugfs.
- * (although it maybe ok for other fs)
- *
- * return:
- * file/dir's dentry on success
- * NULL on failure
- */
-static struct dentry *dir_lookup(struct dentry *parent, const char *name)
-{
- struct qstr q;
- struct dentry *d;
-
- q.name = name;
- q.len = strlen(name);
- q.hash = full_name_hash(q.name, q.len);
-
- d = d_lookup(parent, &q);
- if (d)
- dput(d);
-
- return d;
-}
-
-
-static ssize_t alloc_write(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *cmd = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", cmd) != 1) {
- err = -EPERM;
- goto err_get_cmd;
- }
-
- if ((cmd[0] != 'Y' && cmd[0] != 'y' && cmd[0] != '1') || cmd[1]) {
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- err = ltt_trace_alloc(file->f_dentry->d_parent->d_name.name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "alloc_write: ltt_trace_alloc failed: %d\n",
- err);
- goto err_alloc_trace;
- }
-
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return count;
-
-err_alloc_trace:
-err_bad_cmd:
-err_get_cmd:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return err;
-}
-
-static const struct file_operations ltt_alloc_operations = {
- .write = alloc_write,
-};
-
-
-static ssize_t enabled_write(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *cmd = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", cmd) != 1) {
- err = -EPERM;
- goto err_get_cmd;
- }
-
- if (cmd[1]) {
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- switch (cmd[0]) {
- case 'Y':
- case 'y':
- case '1':
- err = ltt_trace_start(file->f_dentry->d_parent->d_name.name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR
- "enabled_write: ltt_trace_start failed: %d\n",
- err);
- err = -EPERM;
- goto err_start_trace;
- }
- break;
- case 'N':
- case 'n':
- case '0':
- err = ltt_trace_stop(file->f_dentry->d_parent->d_name.name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR
- "enabled_write: ltt_trace_stop failed: %d\n",
- err);
- err = -EPERM;
- goto err_stop_trace;
- }
- break;
- default:
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return count;
-
-err_stop_trace:
-err_start_trace:
-err_bad_cmd:
-err_get_cmd:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return err;
-}
-
-static const struct file_operations ltt_enabled_operations = {
- .write = enabled_write,
-};
-
-
-static ssize_t trans_write(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *trans_name = (char *)__get_free_page(GFP_KERNEL);
- int err = 0;
- int buf_size;
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", trans_name) != 1) {
- err = -EPERM;
- goto err_get_transname;
- }
-
- err = ltt_trace_set_type(file->f_dentry->d_parent->d_name.name,
- trans_name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "trans_write: ltt_trace_set_type failed: %d\n",
- err);
- goto err_set_trans;
- }
-
- free_page((unsigned long)buf);
- free_page((unsigned long)trans_name);
- return count;
-
-err_set_trans:
-err_get_transname:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)trans_name);
- return err;
-}
-
-static const struct file_operations ltt_trans_operations = {
- .write = trans_write,
-};
-
-
-static ssize_t channel_subbuf_num_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- unsigned int num;
- const char *channel_name;
- const char *trace_name;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%u", &num) != 1) {
- err = -EPERM;
- goto err_get_number;
- }
-
- channel_name = file->f_dentry->d_parent->d_name.name;
- trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
-
- err = ltt_trace_set_channel_subbufcount(trace_name, channel_name, num);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_subbuf_num_write: "
- "ltt_trace_set_channel_subbufcount failed: %d\n", err);
- goto err_set_subbufcount;
- }
-
- free_page((unsigned long)buf);
- return count;
-
-err_set_subbufcount:
-err_get_number:
-err_copy_from_user:
- free_page((unsigned long)buf);
- return err;
-}
-
-static const struct file_operations ltt_channel_subbuf_num_operations = {
- .write = channel_subbuf_num_write,
-};
-
-
-static
-ssize_t channel_subbuf_size_write(struct file *file,
- const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- unsigned int num;
- const char *channel_name;
- const char *trace_name;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%u", &num) != 1) {
- err = -EPERM;
- goto err_get_number;
- }
-
- channel_name = file->f_dentry->d_parent->d_name.name;
- trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
-
- err = ltt_trace_set_channel_subbufsize(trace_name, channel_name, num);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_subbuf_size_write: "
- "ltt_trace_set_channel_subbufsize failed: %d\n", err);
- goto err_set_subbufsize;
- }
-
- free_page((unsigned long)buf);
- return count;
-
-err_set_subbufsize:
-err_get_number:
-err_copy_from_user:
- free_page((unsigned long)buf);
- return err;
-}
-
-static const struct file_operations ltt_channel_subbuf_size_operations = {
- .write = channel_subbuf_size_write,
-};
-
-static
-ssize_t channel_switch_timer_write(struct file *file,
- const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- unsigned long num;
- const char *channel_name;
- const char *trace_name;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%lu", &num) != 1) {
- err = -EPERM;
- goto err_get_number;
- }
-
- channel_name = file->f_dentry->d_parent->d_name.name;
- trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
-
- /* Convert from ms to us */
- num *= 1000;
-
- err = ltt_trace_set_channel_switch_timer(trace_name, channel_name, num);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_switch_timer_write: "
- "ltt_trace_set_channel_switch_timer failed: %d\n", err);
- goto err_set_switch_timer;
- }
-
- free_page((unsigned long)buf);
- return count;
-
-err_set_switch_timer:
-err_get_number:
-err_copy_from_user:
- free_page((unsigned long)buf);
- return err;
-}
-
-static struct file_operations ltt_channel_switch_timer_operations = {
- .write = channel_switch_timer_write,
-};
-
-static
-ssize_t channel_overwrite_write(struct file *file,
- const char __user *user_buf, size_t count,
- loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- const char *channel_name;
- const char *trace_name;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *cmd = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", cmd) != 1) {
- err = -EPERM;
- goto err_get_cmd;
- }
-
- if (cmd[1]) {
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- channel_name = file->f_dentry->d_parent->d_name.name;
- trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
-
- switch (cmd[0]) {
- case 'Y':
- case 'y':
- case '1':
- err = ltt_trace_set_channel_overwrite(trace_name, channel_name,
- 1);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_overwrite_write: "
- "ltt_trace_set_channel_overwrite failed: %d\n",
- err);
- goto err_set_subbufsize;
- }
- break;
- case 'N':
- case 'n':
- case '0':
- err = ltt_trace_set_channel_overwrite(trace_name, channel_name,
- 0);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_overwrite_write: "
- "ltt_trace_set_channel_overwrite failed: %d\n",
- err);
- goto err_set_subbufsize;
- }
- break;
- default:
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return count;
-
-err_set_subbufsize:
-err_bad_cmd:
-err_get_cmd:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return err;
-}
-
-static const struct file_operations ltt_channel_overwrite_operations = {
- .write = channel_overwrite_write,
-};
-
-
-static
-ssize_t channel_enable_write(struct file *file,
- const char __user *user_buf, size_t count,
- loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- const char *channel_name;
- const char *trace_name;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *cmd = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", cmd) != 1) {
- err = -EPERM;
- goto err_get_cmd;
- }
-
- if (cmd[1]) {
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- channel_name = file->f_dentry->d_parent->d_name.name;
- trace_name = file->f_dentry->d_parent->d_parent->d_parent->d_name.name;
-
- switch (cmd[0]) {
- case 'Y':
- case 'y':
- case '1':
- err = ltt_trace_set_channel_enable(trace_name, channel_name,
- 1);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_enable_write: "
- "ltt_trace_set_channel_enable failed: %d\n",
- err);
- goto err_set_subbufsize;
- }
- break;
- case 'N':
- case 'n':
- case '0':
- err = ltt_trace_set_channel_enable(trace_name, channel_name,
- 0);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "channel_enable_write: "
- "ltt_trace_set_channel_enable failed: %d\n",
- err);
- goto err_set_subbufsize;
- }
- break;
- default:
- err = -EPERM;
- goto err_bad_cmd;
- }
-
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return count;
-
-err_set_subbufsize:
-err_bad_cmd:
-err_get_cmd:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)cmd);
- return err;
-}
-
-static const struct file_operations ltt_channel_enable_operations = {
- .write = channel_enable_write,
-};
-
-
-static int _create_trace_control_dir(const char *trace_name,
- struct ltt_trace *trace)
-{
- int err;
- struct dentry *trace_root, *channel_root;
- struct dentry *tmp_den;
- int i;
-
- /* debugfs/control/trace_name */
- trace_root = debugfs_create_dir(trace_name, ltt_control_dir);
- if (IS_ERR(trace_root) || !trace_root) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create control root dir of %s failed\n", trace_name);
- err = -ENOMEM;
- goto err_create_trace_root;
- }
-
- /* debugfs/control/trace_name/alloc */
- tmp_den = debugfs_create_file("alloc", S_IWUSR, trace_root, NULL,
- <t_alloc_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create file of alloc failed\n");
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- /* debugfs/control/trace_name/trans */
- tmp_den = debugfs_create_file("trans", S_IWUSR, trace_root, NULL,
- <t_trans_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create file of trans failed\n");
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- /* debugfs/control/trace_name/enabled */
- tmp_den = debugfs_create_file("enabled", S_IWUSR, trace_root, NULL,
- <t_enabled_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create file of enabled failed\n");
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- /* debugfs/control/trace_name/channel/ */
- channel_root = debugfs_create_dir("channel", trace_root);
- if (IS_ERR(channel_root) || !channel_root) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create dir of channel failed\n");
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- /*
- * Create dir and files in debugfs/ltt/control/trace_name/channel/
- * Following things(without <>) will be created:
- * `-- <control>
- * `-- <trace_name>
- * `-- <channel>
- * |-- <channel_name>
- * | |-- enable
- * | |-- overwrite
- * | |-- subbuf_num
- * | |-- subbuf_size
- * | `-- switch_timer
- * `-- ...
- */
-
- for (i = 0; i < trace->nr_channels; i++) {
- struct dentry *channel_den;
- struct ltt_chan *chan;
-
- chan = &trace->channels[i];
- if (!chan->active)
- continue;
- channel_den = debugfs_create_dir(chan->a.filename,
- channel_root);
- if (IS_ERR(channel_den) || !channel_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create channel dir of %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- tmp_den = debugfs_create_file("subbuf_num", S_IWUSR,
- channel_den, NULL,
- <t_channel_subbuf_num_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create subbuf_num in %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- tmp_den = debugfs_create_file("subbuf_size", S_IWUSR,
- channel_den, NULL,
- <t_channel_subbuf_size_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create subbuf_size in %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- tmp_den = debugfs_create_file("enable", S_IWUSR, channel_den,
- NULL,
- <t_channel_enable_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create enable in %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- tmp_den = debugfs_create_file("overwrite", S_IWUSR, channel_den,
- NULL,
- <t_channel_overwrite_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create overwrite in %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
-
- tmp_den = debugfs_create_file("switch_timer", S_IWUSR,
- channel_den, NULL,
- <t_channel_switch_timer_operations);
- if (IS_ERR(tmp_den) || !tmp_den) {
- printk(KERN_ERR "_create_trace_control_dir: "
- "create switch_timer in %s failed\n",
- chan->a.filename);
- err = -ENOMEM;
- goto err_create_subdir;
- }
- }
-
- return 0;
-
-err_create_subdir:
- debugfs_remove_recursive(trace_root);
-err_create_trace_root:
- return err;
-}
-
-static
-ssize_t setup_trace_write(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- int err = 0;
- int buf_size;
- struct ltt_trace *trace;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *trace_name = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", trace_name) != 1) {
- err = -EPERM;
- goto err_get_tracename;
- }
-
- mutex_lock(&control_lock);
- ltt_lock_traces();
-
- err = _ltt_trace_setup(trace_name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR
- "setup_trace_write: ltt_trace_setup failed: %d\n", err);
- goto err_setup_trace;
- }
- trace = _ltt_trace_find_setup(trace_name);
- BUG_ON(!trace);
- err = _create_trace_control_dir(trace_name, trace);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR "setup_trace_write: "
- "_create_trace_control_dir failed: %d\n", err);
- goto err_create_trace_control_dir;
- }
-
- ltt_unlock_traces();
- mutex_unlock(&control_lock);
-
- free_page((unsigned long)buf);
- free_page((unsigned long)trace_name);
- return count;
-
-err_create_trace_control_dir:
- ltt_trace_destroy(trace_name);
-err_setup_trace:
- ltt_unlock_traces();
- mutex_unlock(&control_lock);
-err_get_tracename:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)trace_name);
- return err;
-}
-
-static const struct file_operations ltt_setup_trace_operations = {
- .write = setup_trace_write,
-};
-
-static
-ssize_t destroy_trace_write(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- struct dentry *trace_den;
- int buf_size;
- int err = 0;
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- char *trace_name = (char *)__get_free_page(GFP_KERNEL);
-
- buf_size = min_t(size_t, count, PAGE_SIZE - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto err_copy_from_user;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", trace_name) != 1) {
- err = -EPERM;
- goto err_get_tracename;
- }
-
- mutex_lock(&control_lock);
-
- err = ltt_trace_destroy(trace_name);
- if (IS_ERR_VALUE(err)) {
- printk(KERN_ERR
- "destroy_trace_write: ltt_trace_destroy failed: %d\n",
- err);
- err = -EPERM;
- goto err_destroy_trace;
- }
-
- trace_den = dir_lookup(ltt_control_dir, trace_name);
- if (!trace_den) {
- printk(KERN_ERR
- "destroy_trace_write: lookup for %s's dentry failed\n",
- trace_name);
- err = -ENOENT;
- goto err_get_dentry;
- }
-
- debugfs_remove_recursive(trace_den);
-
- mutex_unlock(&control_lock);
-
- free_page((unsigned long)buf);
- free_page((unsigned long)trace_name);
- return count;
-
-err_get_dentry:
-err_destroy_trace:
- mutex_unlock(&control_lock);
-err_get_tracename:
-err_copy_from_user:
- free_page((unsigned long)buf);
- free_page((unsigned long)trace_name);
- return err;
-}
-
-static const struct file_operations ltt_destroy_trace_operations = {
- .write = destroy_trace_write,
-};
-
-static void init_marker_dir(struct dentry *dentry,
- const struct inode_operations *opt)
-{
- dentry->d_inode->i_op = opt;
-}
-
-static
-ssize_t marker_enable_read(struct file *filp, char __user *ubuf,
- size_t cnt, loff_t *ppos)
-{
- char *buf;
- const char *channel, *marker;
- int len, enabled, present;
-
- marker = filp->f_dentry->d_parent->d_name.name;
- channel = filp->f_dentry->d_parent->d_parent->d_name.name;
-
- len = 0;
- buf = (char *)__get_free_page(GFP_KERNEL);
-
- /*
- * Note: we cannot take the marker lock to make these two checks
- * atomic, because the marker mutex nests inside the module mutex, taken
- * inside the marker present check.
- */
- enabled = is_marker_enabled(channel, marker);
- present = is_marker_present(channel, marker);
-
- if (enabled && present)
- len = snprintf(buf, PAGE_SIZE, "%d\n", 1);
- else if (enabled && !present)
- len = snprintf(buf, PAGE_SIZE, "%d\n", 2);
- else
- len = snprintf(buf, PAGE_SIZE, "%d\n", 0);
-
-
- if (len >= PAGE_SIZE) {
- len = PAGE_SIZE;
- buf[PAGE_SIZE] = '\0';
- }
- len = simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
- free_page((unsigned long)buf);
-
- return len;
-}
-
-static
-ssize_t marker_enable_write(struct file *filp, const char __user *ubuf,
- size_t cnt, loff_t *ppos)
-{
- char *buf = (char *)__get_free_page(GFP_KERNEL);
- int buf_size;
- ssize_t ret = 0;
- const char *channel, *marker;
-
- marker = filp->f_dentry->d_parent->d_name.name;
- channel = filp->f_dentry->d_parent->d_parent->d_name.name;
-
- buf_size = min_t(size_t, cnt, PAGE_SIZE - 1);
- ret = copy_from_user(buf, ubuf, buf_size);
- if (ret)
- goto end;
-
- buf[buf_size] = 0;
-
- switch (buf[0]) {
- case 'Y':
- case 'y':
- case '1':
- ret = ltt_marker_connect(channel, marker, "default");
- if (ret)
- goto end;
- break;
- case 'N':
- case 'n':
- case '0':
- ret = ltt_marker_disconnect(channel, marker, "default");
- if (ret)
- goto end;
- break;
- default:
- ret = -EPERM;
- goto end;
- }
- ret = cnt;
-end:
- free_page((unsigned long)buf);
- return ret;
-}
-
-static const struct file_operations enable_fops = {
- .read = marker_enable_read,
- .write = marker_enable_write,
-};
-
-/*
- * In practice, the output size should never be larger than 4096 kB. If it
- * ever happens, the output will simply be truncated.
- */
-static
-ssize_t marker_info_read(struct file *filp, char __user *ubuf,
- size_t cnt, loff_t *ppos)
-{
- char *buf;
- const char *channel, *marker;
- int len;
- struct marker_iter iter;
-
- marker = filp->f_dentry->d_parent->d_name.name;
- channel = filp->f_dentry->d_parent->d_parent->d_name.name;
-
- len = 0;
- buf = (char *)__get_free_page(GFP_KERNEL);
-
- if (is_marker_enabled(channel, marker) &&
- !is_marker_present(channel, marker)) {
- len += snprintf(buf + len, PAGE_SIZE - len,
- "Marker Pre-enabled\n");
- goto out;
- }
-
- marker_iter_reset(&iter);
- marker_iter_start(&iter);
- for (; iter.marker != NULL; marker_iter_next(&iter)) {
- if (!strcmp(iter.marker->channel, channel) &&
- !strcmp(iter.marker->name, marker))
- len += snprintf(buf + len, PAGE_SIZE - len,
- "Location: %s\n"
- "format: \"%s\"\nstate: %d\n"
- "event_id: %hu\n"
- "call: 0x%p\n"
- "probe %s : 0x%p\n\n",
-#ifdef CONFIG_MODULES
- iter.module ? iter.module->name :
-#endif
- "Core Kernel",
- iter.marker->format,
- _imv_read(iter.marker->state),
- iter.marker->event_id,
- iter.marker->call,
- iter.marker->ptype ?
- "multi" : "single", iter.marker->ptype ?
- (void *)iter.marker->multi :
- (void *)iter.marker->single.func);
- if (len >= PAGE_SIZE)
- break;
- }
- marker_iter_stop(&iter);
-
-out:
- if (len >= PAGE_SIZE) {
- len = PAGE_SIZE;
- buf[PAGE_SIZE] = '\0';
- }
-
- len = simple_read_from_buffer(ubuf, cnt, ppos, buf, len);
- free_page((unsigned long)buf);
-
- return len;
-}
-
-static const struct file_operations info_fops = {
- .read = marker_info_read,
-};
-
-static int marker_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
- struct dentry *marker_d, *enable_d, *info_d, *channel_d;
- int ret;
-
- ret = 0;
- channel_d = (struct dentry *)dir->i_private;
- mutex_unlock(&dir->i_mutex);
-
- marker_d = debugfs_create_dir(dentry->d_name.name,
- channel_d);
- if (IS_ERR(marker_d)) {
- ret = PTR_ERR(marker_d);
- goto out;
- }
-
- enable_d = debugfs_create_file("enable", 0644, marker_d,
- NULL, &enable_fops);
- if (IS_ERR(enable_d) || !enable_d) {
- printk(KERN_ERR
- "%s: create file of %s failed\n",
- __func__, "enable");
- ret = -ENOMEM;
- goto remove_marker_dir;
- }
-
- info_d = debugfs_create_file("info", 0644, marker_d,
- NULL, &info_fops);
- if (IS_ERR(info_d) || !info_d) {
- printk(KERN_ERR
- "%s: create file of %s failed\n",
- __func__, "info");
- ret = -ENOMEM;
- goto remove_enable_dir;
- }
-
- goto out;
-
-remove_enable_dir:
- debugfs_remove(enable_d);
-remove_marker_dir:
- debugfs_remove(marker_d);
-out:
- mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
- return ret;
-}
-
-static int marker_rmdir(struct inode *dir, struct dentry *dentry)
-{
- struct dentry *marker_d, *channel_d;
- const char *channel, *name;
- int ret, enabled, present;
-
- ret = 0;
-
- channel_d = (struct dentry *)dir->i_private;
- channel = channel_d->d_name.name;
-
- marker_d = dir_lookup(channel_d, dentry->d_name.name);
-
- if (!marker_d) {
- ret = -ENOENT;
- goto out;
- }
-
- name = marker_d->d_name.name;
-
- enabled = is_marker_enabled(channel, name);
- present = is_marker_present(channel, name);
-
- if (present || (!present && enabled)) {
- ret = -EPERM;
- goto out;
- }
-
- mutex_unlock(&dir->i_mutex);
- mutex_unlock(&dentry->d_inode->i_mutex);
- debugfs_remove_recursive(marker_d);
- mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
- mutex_lock(&dentry->d_inode->i_mutex);
-out:
- return ret;
-}
-
-const struct inode_operations channel_dir_opt = {
- .lookup = simple_lookup,
- .mkdir = marker_mkdir,
- .rmdir = marker_rmdir,
-};
-
-static int channel_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
- struct dentry *channel_d;
- int ret;
-
- ret = 0;
- mutex_unlock(&dir->i_mutex);
-
- channel_d = debugfs_create_dir(dentry->d_name.name,
- markers_control_dir);
- if (IS_ERR(channel_d)) {
- ret = PTR_ERR(channel_d);
- goto out;
- }
-
- channel_d->d_inode->i_private = (void *)channel_d;
- init_marker_dir(channel_d, &channel_dir_opt);
-out:
- mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
- return ret;
-}
-
-static int channel_rmdir(struct inode *dir, struct dentry *dentry)
-{
- struct dentry *channel_d;
- int ret;
-
- ret = 0;
-
- channel_d = dir_lookup(markers_control_dir, dentry->d_name.name);
- if (!channel_d) {
- ret = -ENOENT;
- goto out;
- }
-
- if (list_empty(&channel_d->d_subdirs)) {
- mutex_unlock(&dir->i_mutex);
- mutex_unlock(&dentry->d_inode->i_mutex);
- debugfs_remove(channel_d);
- mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT);
- mutex_lock(&dentry->d_inode->i_mutex);
- } else
- ret = -EPERM;
-
-out:
- return ret;
-}
-
-const struct inode_operations root_dir_opt = {
- .lookup = simple_lookup,
- .mkdir = channel_mkdir,
- .rmdir = channel_rmdir
-};
-
-static int build_marker_file(struct marker *marker)
-{
- struct dentry *channel_d, *marker_d, *enable_d, *info_d;
- int err;
-
- channel_d = dir_lookup(markers_control_dir, marker->channel);
- if (!channel_d) {
- channel_d = debugfs_create_dir(marker->channel,
- markers_control_dir);
- if (IS_ERR(channel_d) || !channel_d) {
- printk(KERN_ERR
- "%s: build channel dir of %s failed\n",
- __func__, marker->channel);
- err = -ENOMEM;
- goto err_build_fail;
- }
- channel_d->d_inode->i_private = (void *)channel_d;
- init_marker_dir(channel_d, &channel_dir_opt);
- }
-
- marker_d = dir_lookup(channel_d, marker->name);
- if (!marker_d) {
- marker_d = debugfs_create_dir(marker->name, channel_d);
- if (IS_ERR(marker_d) || !marker_d) {
- printk(KERN_ERR
- "%s: marker dir of %s failed\n",
- __func__, marker->name);
- err = -ENOMEM;
- goto err_build_fail;
- }
- }
-
- enable_d = dir_lookup(marker_d, "enable");
- if (!enable_d) {
- enable_d = debugfs_create_file("enable", 0644, marker_d,
- NULL, &enable_fops);
- if (IS_ERR(enable_d) || !enable_d) {
- printk(KERN_ERR
- "%s: create file of %s failed\n",
- __func__, "enable");
- err = -ENOMEM;
- goto err_build_fail;
- }
- }
-
- info_d = dir_lookup(marker_d, "info");
- if (!info_d) {
- info_d = debugfs_create_file("info", 0444, marker_d,
- NULL, &info_fops);
- if (IS_ERR(info_d) || !info_d) {
- printk(KERN_ERR
- "%s: create file of %s failed\n",
- __func__, "enable");
- err = -ENOMEM;
- goto err_build_fail;
- }
- }
-
- return 0;
-
-err_build_fail:
- return err;
-}
-
-static int build_marker_control_files(void)
-{
- struct marker_iter iter;
- int err;
-
- err = 0;
- if (!markers_control_dir)
- return -EEXIST;
-
- marker_iter_reset(&iter);
- marker_iter_start(&iter);
- for (; iter.marker != NULL; marker_iter_next(&iter)) {
- err = build_marker_file(iter.marker);
- if (err)
- goto out;
- }
- marker_iter_stop(&iter);
-
-out:
- return err;
-}
-
-#ifdef CONFIG_MODULES
-static int remove_marker_control_dir(struct module *mod, struct marker *marker)
-{
- struct dentry *channel_d, *marker_d;
- const char *channel, *name;
- int count;
- struct marker_iter iter;
-
- count = 0;
-
- channel_d = dir_lookup(markers_control_dir, marker->channel);
- if (!channel_d)
- return -ENOENT;
- channel = channel_d->d_name.name;
-
- marker_d = dir_lookup(channel_d, marker->name);
- if (!marker_d)
- return -ENOENT;
- name = marker_d->d_name.name;
-
- marker_iter_reset(&iter);
- marker_iter_start(&iter);
- for (; iter.marker != NULL; marker_iter_next(&iter)) {
- if (!strcmp(iter.marker->channel, channel) &&
- !strcmp(iter.marker->name, name) && mod != iter.module)
- count++;
- }
-
- if (count > 0)
- goto end;
-
- debugfs_remove_recursive(marker_d);
- if (list_empty(&channel_d->d_subdirs))
- debugfs_remove(channel_d);
-
-end:
- marker_iter_stop(&iter);
- return 0;
-}
-
-static void cleanup_control_dir(struct module *mod, struct marker *begin,
- struct marker *end)
-{
- struct marker *iter;
-
- if (!markers_control_dir)
- return;
-
- for (iter = begin; iter < end; iter++)
- remove_marker_control_dir(mod, iter);
-
- return;
-}
-
-static void build_control_dir(struct module *mod, struct marker *begin,
- struct marker *end)
-{
- struct marker *iter;
- int err;
-
- err = 0;
- if (!markers_control_dir)
- return;
-
- for (iter = begin; iter < end; iter++) {
- err = build_marker_file(iter);
- if (err)
- goto err_build_fail;
- }
-
- return;
-err_build_fail:
- cleanup_control_dir(mod, begin, end);
-}
-
-static int module_notify(struct notifier_block *self,
- unsigned long val, void *data)
-{
- struct module *mod = data;
-
- switch (val) {
- case MODULE_STATE_COMING:
- build_control_dir(mod, mod->markers,
- mod->markers + mod->num_markers);
- break;
- case MODULE_STATE_GOING:
- cleanup_control_dir(mod, mod->markers,
- mod->markers + mod->num_markers);
- break;
- }
- return NOTIFY_DONE;
-}
-#else
-static inline int module_notify(struct notifier_block *self,
- unsigned long val, void *data)
-{
- return 0;
-}
-#endif
-
-static struct notifier_block module_nb = {
- .notifier_call = module_notify,
-};
-
-static int __init ltt_trace_control_init(void)
-{
- int err = 0;
- struct dentry *ltt_root_dentry;
-
- ltt_root_dentry = get_ltt_root();
- if (!ltt_root_dentry) {
- err = -ENOENT;
- goto err_no_root;
- }
-
- ltt_control_dir = debugfs_create_dir(LTT_CONTROL_DIR, ltt_root_dentry);
- if (IS_ERR(ltt_control_dir) || !ltt_control_dir) {
- printk(KERN_ERR
- "ltt_channel_control_init: create dir of %s failed\n",
- LTT_CONTROL_DIR);
- err = -ENOMEM;
- goto err_create_control_dir;
- }
-
- ltt_setup_trace_file = debugfs_create_file(LTT_SETUP_TRACE_FILE,
- S_IWUSR, ltt_root_dentry,
- NULL,
- <t_setup_trace_operations);
- if (IS_ERR(ltt_setup_trace_file) || !ltt_setup_trace_file) {
- printk(KERN_ERR
- "ltt_channel_control_init: create file of %s failed\n",
- LTT_SETUP_TRACE_FILE);
- err = -ENOMEM;
- goto err_create_setup_trace_file;
- }
-
- ltt_destroy_trace_file = debugfs_create_file(LTT_DESTROY_TRACE_FILE,
- S_IWUSR, ltt_root_dentry,
- NULL,
- <t_destroy_trace_operations);
- if (IS_ERR(ltt_destroy_trace_file) || !ltt_destroy_trace_file) {
- printk(KERN_ERR
- "ltt_channel_control_init: create file of %s failed\n",
- LTT_DESTROY_TRACE_FILE);
- err = -ENOMEM;
- goto err_create_destroy_trace_file;
- }
-
- markers_control_dir = debugfs_create_dir(MARKERS_CONTROL_DIR,
- ltt_root_dentry);
- if (IS_ERR(markers_control_dir) || !markers_control_dir) {
- printk(KERN_ERR
- "ltt_channel_control_init: create dir of %s failed\n",
- MARKERS_CONTROL_DIR);
- err = -ENOMEM;
- goto err_create_marker_control_dir;
- }
-
- init_marker_dir(markers_control_dir, &root_dir_opt);
-
- if (build_marker_control_files())
- goto err_build_fail;
-
- if (!register_module_notifier(&module_nb))
- return 0;
-
-err_build_fail:
- debugfs_remove_recursive(markers_control_dir);
- markers_control_dir = NULL;
-err_create_marker_control_dir:
- debugfs_remove(ltt_destroy_trace_file);
-err_create_destroy_trace_file:
- debugfs_remove(ltt_setup_trace_file);
-err_create_setup_trace_file:
- debugfs_remove(ltt_control_dir);
-err_create_control_dir:
-err_no_root:
- return err;
-}
-
-static void __exit ltt_trace_control_exit(void)
-{
- struct dentry *trace_dir;
-
- /* destory all traces */
- list_for_each_entry(trace_dir, <t_control_dir->d_subdirs,
- d_u.d_child) {
- ltt_trace_stop(trace_dir->d_name.name);
- ltt_trace_destroy(trace_dir->d_name.name);
- }
-
- /* clean dirs in debugfs */
- debugfs_remove(ltt_setup_trace_file);
- debugfs_remove(ltt_destroy_trace_file);
- debugfs_remove_recursive(ltt_control_dir);
- debugfs_remove_recursive(markers_control_dir);
- unregister_module_notifier(&module_nb);
- put_ltt_root();
-}
-
-module_init(ltt_trace_control_init);
-module_exit(ltt_trace_control_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Zhao Lei <zhaolei@cn.fujitsu.com>");
-MODULE_DESCRIPTION("Linux Trace Toolkit Trace Controller");
+++ /dev/null
-/*
- * ltt/ltt-tracer.c
- *
- * Copyright (c) 2005-2010 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * Tracing management internal kernel API. Trace buffer allocation/free, tracing
- * start/stop.
- *
- * Author:
- * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * Inspired from LTT :
- * Karim Yaghmour (karim@opersys.com)
- * Tom Zanussi (zanussi@us.ibm.com)
- * Bob Wisniewski (bob@watson.ibm.com)
- * And from K42 :
- * Bob Wisniewski (bob@watson.ibm.com)
- *
- * Changelog:
- * 22/09/06, Move to the marker/probes mechanism.
- * 19/10/05, Complete lockless mechanism.
- * 27/05/05, Modular redesign and rewrite.
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/time.h>
-#include <linux/module.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/init.h>
-#include <linux/rcupdate.h>
-#include <linux/sched.h>
-#include <linux/bitops.h>
-#include <linux/fs.h>
-#include <linux/cpu.h>
-#include <linux/kref.h>
-#include <linux/delay.h>
-#include <linux/vmalloc.h>
-#include <asm/atomic.h>
-
-#include "ltt-tracer.h"
-
-static void synchronize_trace(void)
-{
- synchronize_sched();
-#ifdef CONFIG_PREEMPT_RT
- synchronize_rcu();
-#endif
-}
-
-static void async_wakeup(unsigned long data);
-
-static DEFINE_TIMER(ltt_async_wakeup_timer, async_wakeup, 0, 0);
-
-/* Default callbacks for modules */
-notrace
-int ltt_filter_control_default(enum ltt_filter_control_msg msg,
- struct ltt_trace *trace)
-{
- return 0;
-}
-
-int ltt_statedump_default(struct ltt_trace *trace)
-{
- return 0;
-}
-
-/* Callbacks for registered modules */
-
-int (*ltt_filter_control_functor)
- (enum ltt_filter_control_msg msg, struct ltt_trace *trace) =
- ltt_filter_control_default;
-struct module *ltt_filter_control_owner;
-
-/* These function pointers are protected by a trace activation check */
-struct module *ltt_run_filter_owner;
-int (*ltt_statedump_functor)(struct ltt_trace *trace) = ltt_statedump_default;
-struct module *ltt_statedump_owner;
-
-struct chan_info_struct {
- const char *name;
- unsigned int def_sb_size;
- unsigned int def_n_sb;
-} chan_infos[] = {
- [LTT_CHANNEL_METADATA] = {
- LTT_METADATA_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_FD_STATE] = {
- LTT_FD_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_GLOBAL_STATE] = {
- LTT_GLOBAL_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_IRQ_STATE] = {
- LTT_IRQ_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_MODULE_STATE] = {
- LTT_MODULE_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_NETIF_STATE] = {
- LTT_NETIF_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_SOFTIRQ_STATE] = {
- LTT_SOFTIRQ_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_SWAP_STATE] = {
- LTT_SWAP_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_SYSCALL_STATE] = {
- LTT_SYSCALL_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_TASK_STATE] = {
- LTT_TASK_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_VM_STATE] = {
- LTT_VM_STATE_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_MED,
- LTT_DEFAULT_N_SUBBUFS_MED,
- },
- [LTT_CHANNEL_FS] = {
- LTT_FS_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_MED,
- LTT_DEFAULT_N_SUBBUFS_MED,
- },
- [LTT_CHANNEL_INPUT] = {
- LTT_INPUT_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_IPC] = {
- LTT_IPC_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_LOW,
- LTT_DEFAULT_N_SUBBUFS_LOW,
- },
- [LTT_CHANNEL_KERNEL] = {
- LTT_KERNEL_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_HIGH,
- LTT_DEFAULT_N_SUBBUFS_HIGH,
- },
- [LTT_CHANNEL_MM] = {
- LTT_MM_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_MED,
- LTT_DEFAULT_N_SUBBUFS_MED,
- },
- [LTT_CHANNEL_RCU] = {
- LTT_RCU_CHANNEL,
- LTT_DEFAULT_SUBBUF_SIZE_MED,
- LTT_DEFAULT_N_SUBBUFS_MED,
- },
- [LTT_CHANNEL_DEFAULT] = {
- NULL,
- LTT_DEFAULT_SUBBUF_SIZE_MED,
- LTT_DEFAULT_N_SUBBUFS_MED,
- },
-};
-
-static enum ltt_channels get_channel_type_from_name(const char *name)
-{
- int i;
-
- if (!name)
- return LTT_CHANNEL_DEFAULT;
-
- for (i = 0; i < ARRAY_SIZE(chan_infos); i++)
- if (chan_infos[i].name && !strcmp(name, chan_infos[i].name))
- return (enum ltt_channels)i;
-
- return LTT_CHANNEL_DEFAULT;
-}
-
-/**
- * ltt_module_register - LTT module registration
- * @name: module type
- * @function: callback to register
- * @owner: module which owns the callback
- *
- * The module calling this registration function must ensure that no
- * trap-inducing code will be executed by "function". E.g. vmalloc_sync_all()
- * must be called between a vmalloc and the moment the memory is made visible to
- * "function". This registration acts as a vmalloc_sync_all. Therefore, only if
- * the module allocates virtual memory after its registration must it
- * synchronize the TLBs.
- */
-int ltt_module_register(enum ltt_module_function name, void *function,
- struct module *owner)
-{
- int ret = 0;
-
- /*
- * Make sure no page fault can be triggered by the module about to be
- * registered. We deal with this here so we don't have to call
- * vmalloc_sync_all() in each module's init.
- */
- vmalloc_sync_all();
-
- switch (name) {
- case LTT_FUNCTION_RUN_FILTER:
- if (ltt_run_filter_owner != NULL) {
- ret = -EEXIST;
- goto end;
- }
- ltt_filter_register((ltt_run_filter_functor)function);
- ltt_run_filter_owner = owner;
- break;
- case LTT_FUNCTION_FILTER_CONTROL:
- if (ltt_filter_control_owner != NULL) {
- ret = -EEXIST;
- goto end;
- }
- ltt_filter_control_functor =
- (int (*)(enum ltt_filter_control_msg,
- struct ltt_trace *))function;
- ltt_filter_control_owner = owner;
- break;
- case LTT_FUNCTION_STATEDUMP:
- if (ltt_statedump_owner != NULL) {
- ret = -EEXIST;
- goto end;
- }
- ltt_statedump_functor =
- (int (*)(struct ltt_trace *))function;
- ltt_statedump_owner = owner;
- break;
- }
-end:
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_module_register);
-
-/**
- * ltt_module_unregister - LTT module unregistration
- * @name: module type
- */
-void ltt_module_unregister(enum ltt_module_function name)
-{
- switch (name) {
- case LTT_FUNCTION_RUN_FILTER:
- ltt_filter_unregister();
- ltt_run_filter_owner = NULL;
- /* Wait for preempt sections to finish */
- synchronize_trace();
- break;
- case LTT_FUNCTION_FILTER_CONTROL:
- ltt_filter_control_functor = ltt_filter_control_default;
- ltt_filter_control_owner = NULL;
- break;
- case LTT_FUNCTION_STATEDUMP:
- ltt_statedump_functor = ltt_statedump_default;
- ltt_statedump_owner = NULL;
- break;
- }
-
-}
-EXPORT_SYMBOL_GPL(ltt_module_unregister);
-
-static LIST_HEAD(ltt_transport_list);
-
-/**
- * ltt_transport_register - LTT transport registration
- * @transport: transport structure
- *
- * Registers a transport which can be used as output to extract the data out of
- * LTTng. The module calling this registration function must ensure that no
- * trap-inducing code will be executed by the transport functions. E.g.
- * vmalloc_sync_all() must be called between a vmalloc and the moment the memory
- * is made visible to the transport function. This registration acts as a
- * vmalloc_sync_all. Therefore, only if the module allocates virtual memory
- * after its registration must it synchronize the TLBs.
- */
-void ltt_transport_register(struct ltt_transport *transport)
-{
- /*
- * Make sure no page fault can be triggered by the module about to be
- * registered. We deal with this here so we don't have to call
- * vmalloc_sync_all() in each module's init.
- */
- vmalloc_sync_all();
-
- ltt_lock_traces();
- list_add_tail(&transport->node, <t_transport_list);
- ltt_unlock_traces();
-}
-EXPORT_SYMBOL_GPL(ltt_transport_register);
-
-/**
- * ltt_transport_unregister - LTT transport unregistration
- * @transport: transport structure
- */
-void ltt_transport_unregister(struct ltt_transport *transport)
-{
- ltt_lock_traces();
- list_del(&transport->node);
- ltt_unlock_traces();
-}
-EXPORT_SYMBOL_GPL(ltt_transport_unregister);
-
-static inline
-int is_channel_overwrite(enum ltt_channels chan, enum trace_mode mode)
-{
- switch (mode) {
- case LTT_TRACE_NORMAL:
- return 0;
- case LTT_TRACE_FLIGHT:
- switch (chan) {
- case LTT_CHANNEL_METADATA:
- return 0;
- default:
- return 1;
- }
- case LTT_TRACE_HYBRID:
- switch (chan) {
- case LTT_CHANNEL_KERNEL:
- case LTT_CHANNEL_FS:
- case LTT_CHANNEL_MM:
- case LTT_CHANNEL_RCU:
- case LTT_CHANNEL_IPC:
- case LTT_CHANNEL_INPUT:
- return 1;
- default:
- return 0;
- }
- default:
- return 0;
- }
-}
-
-/**
- * _ltt_trace_find - find a trace by given name.
- * trace_name: trace name
- *
- * Returns a pointer to the trace structure, NULL if not found.
- */
-static struct ltt_trace *_ltt_trace_find(const char *trace_name)
-{
- struct ltt_trace *trace;
-
- list_for_each_entry(trace, <t_traces.head, list)
- if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
- return trace;
-
- return NULL;
-}
-
-/* _ltt_trace_find_setup :
- * find a trace in setup list by given name.
- *
- * Returns a pointer to the trace structure, NULL if not found.
- */
-struct ltt_trace *_ltt_trace_find_setup(const char *trace_name)
-{
- struct ltt_trace *trace;
-
- list_for_each_entry(trace, <t_traces.setup_head, list)
- if (!strncmp(trace->trace_name, trace_name, NAME_MAX))
- return trace;
-
- return NULL;
-}
-EXPORT_SYMBOL_GPL(_ltt_trace_find_setup);
-
-/**
- * ltt_release_trace - Release a LTT trace
- * @kref : reference count on the trace
- */
-void ltt_release_trace(struct kref *kref)
-{
- struct ltt_trace *trace = container_of(kref, struct ltt_trace, kref);
-
- trace->ops->remove_dirs(trace);
- module_put(trace->transport->owner);
- ltt_channels_trace_free(trace);
- kfree(trace);
-}
-EXPORT_SYMBOL_GPL(ltt_release_trace);
-
-static inline void prepare_chan_size_num(unsigned int *subbuf_size,
- unsigned int *n_subbufs)
-{
- /* Make sure the subbuffer size is larger than a page */
- *subbuf_size = max_t(unsigned int, *subbuf_size, PAGE_SIZE);
-
- /* round to next power of 2 */
- *subbuf_size = 1 << get_count_order(*subbuf_size);
- *n_subbufs = 1 << get_count_order(*n_subbufs);
-
- /* Subbuf size and number must both be power of two */
- WARN_ON(hweight32(*subbuf_size) != 1);
- WARN_ON(hweight32(*n_subbufs) != 1);
-}
-
-int _ltt_trace_setup(const char *trace_name)
-{
- int err = 0;
- struct ltt_trace *new_trace = NULL;
- int metadata_index;
- unsigned int chan;
- enum ltt_channels chantype;
-
- if (_ltt_trace_find_setup(trace_name)) {
- printk(KERN_ERR "LTT : Trace name %s already used.\n",
- trace_name);
- err = -EEXIST;
- goto traces_error;
- }
-
- if (_ltt_trace_find(trace_name)) {
- printk(KERN_ERR "LTT : Trace name %s already used.\n",
- trace_name);
- err = -EEXIST;
- goto traces_error;
- }
-
- new_trace = kzalloc(sizeof(struct ltt_trace), GFP_KERNEL);
- if (!new_trace) {
- printk(KERN_ERR
- "LTT : Unable to allocate memory for trace %s\n",
- trace_name);
- err = -ENOMEM;
- goto traces_error;
- }
- strncpy(new_trace->trace_name, trace_name, NAME_MAX);
- if (ltt_channels_trace_alloc(&new_trace->nr_channels, 0)) {
- printk(KERN_ERR
- "LTT : Unable to allocate memory for chaninfo %s\n",
- trace_name);
- err = -ENOMEM;
- goto trace_free;
- }
-
- /*
- * Force metadata channel to no overwrite.
- */
- metadata_index = ltt_channels_get_index_from_name("metadata");
- WARN_ON(metadata_index < 0);
- new_trace->settings[metadata_index].overwrite = 0;
-
- /*
- * Set hardcoded tracer defaults for some channels
- */
- for (chan = 0; chan < new_trace->nr_channels; chan++) {
- chantype = get_channel_type_from_name(
- ltt_channels_get_name_from_index(chan));
- new_trace->settings[chan].sb_size =
- chan_infos[chantype].def_sb_size;
- new_trace->settings[chan].n_sb =
- chan_infos[chantype].def_n_sb;
- }
-
- list_add(&new_trace->list, <t_traces.setup_head);
- return 0;
-
-trace_free:
- kfree(new_trace);
-traces_error:
- return err;
-}
-EXPORT_SYMBOL_GPL(_ltt_trace_setup);
-
-
-int ltt_trace_setup(const char *trace_name)
-{
- int ret;
- ltt_lock_traces();
- ret = _ltt_trace_setup(trace_name);
- ltt_unlock_traces();
- return ret;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_setup);
-
-/* must be called from within a traces lock. */
-static void _ltt_trace_free(struct ltt_trace *trace)
-{
- list_del(&trace->list);
- kfree(trace);
-}
-
-int ltt_trace_set_type(const char *trace_name, const char *trace_type)
-{
- int err = 0;
- struct ltt_trace *trace;
- struct ltt_transport *tran_iter, *transport = NULL;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- list_for_each_entry(tran_iter, <t_transport_list, node) {
- if (!strcmp(tran_iter->name, trace_type)) {
- transport = tran_iter;
- break;
- }
- }
- if (!transport) {
- printk(KERN_ERR "LTT : Transport %s is not present.\n",
- trace_type);
- err = -EINVAL;
- goto traces_error;
- }
-
- trace->transport = transport;
-
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_set_type);
-
-int ltt_trace_set_channel_subbufsize(const char *trace_name,
- const char *channel_name,
- unsigned int size)
-{
- int err = 0;
- struct ltt_trace *trace;
- int index;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- index = ltt_channels_get_index_from_name(channel_name);
- if (index < 0) {
- printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
- err = -ENOENT;
- goto traces_error;
- }
- trace->settings[index].sb_size = size;
-
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufsize);
-
-int ltt_trace_set_channel_subbufcount(const char *trace_name,
- const char *channel_name,
- unsigned int cnt)
-{
- int err = 0;
- struct ltt_trace *trace;
- int index;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- index = ltt_channels_get_index_from_name(channel_name);
- if (index < 0) {
- printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
- err = -ENOENT;
- goto traces_error;
- }
- trace->settings[index].n_sb = cnt;
-
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_set_channel_subbufcount);
-
-int ltt_trace_set_channel_switch_timer(const char *trace_name,
- const char *channel_name,
- unsigned long interval)
-{
- int err = 0;
- struct ltt_trace *trace;
- int index;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- index = ltt_channels_get_index_from_name(channel_name);
- if (index < 0) {
- printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
- err = -ENOENT;
- goto traces_error;
- }
- ltt_channels_trace_set_timer(&trace->settings[index], interval);
-
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_set_channel_switch_timer);
-
-int ltt_trace_set_channel_overwrite(const char *trace_name,
- const char *channel_name,
- unsigned int overwrite)
-{
- int err = 0;
- struct ltt_trace *trace;
- int index;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- /*
- * Always put the metadata channel in non-overwrite mode :
- * This is a very low traffic channel and it can't afford to have its
- * data overwritten : this data (marker info) is necessary to be
- * able to read the trace.
- */
- if (overwrite && !strcmp(channel_name, "metadata")) {
- printk(KERN_ERR "LTT : Trying to set metadata channel to "
- "overwrite mode\n");
- err = -EINVAL;
- goto traces_error;
- }
-
- index = ltt_channels_get_index_from_name(channel_name);
- if (index < 0) {
- printk(KERN_ERR "LTT : Channel %s not found\n", channel_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- trace->settings[index].overwrite = overwrite;
-
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_set_channel_overwrite);
-
-int ltt_trace_alloc(const char *trace_name)
-{
- int err = 0;
- struct ltt_trace *trace;
- int sb_size, n_sb;
- unsigned long flags;
- int chan;
- const char *channel_name;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find_setup(trace_name);
- if (!trace) {
- printk(KERN_ERR "LTT : Trace not found %s\n", trace_name);
- err = -ENOENT;
- goto traces_error;
- }
-
- kref_init(&trace->kref);
- init_waitqueue_head(&trace->kref_wq);
- trace->active = 0;
- get_trace_clock();
- trace->freq_scale = trace_clock_freq_scale();
-
- if (!trace->transport) {
- printk(KERN_ERR "LTT : Transport is not set.\n");
- err = -EINVAL;
- goto transport_error;
- }
- if (!try_module_get(trace->transport->owner)) {
- printk(KERN_ERR "LTT : Can't lock transport module.\n");
- err = -ENODEV;
- goto transport_error;
- }
- trace->ops = &trace->transport->ops;
-
- err = trace->ops->create_dirs(trace);
- if (err) {
- printk(KERN_ERR "LTT : Can't create dir for trace %s.\n",
- trace_name);
- goto dirs_error;
- }
-
- local_irq_save(flags);
- trace->start_freq = trace_clock_frequency();
- trace->start_tsc = trace_clock_read64();
- do_gettimeofday(&trace->start_time);
- local_irq_restore(flags);
-
- for (chan = 0; chan < trace->nr_channels; chan++) {
- channel_name = ltt_channels_get_name_from_index(chan);
- WARN_ON(!channel_name);
- /*
- * note: sb_size and n_sb will be overwritten with updated
- * values by channel creation.
- */
- sb_size = trace->settings[chan].sb_size;
- n_sb = trace->settings[chan].n_sb;
- prepare_chan_size_num(&sb_size, &n_sb);
- trace->channels[chan] = ltt_create_channel(channel_name,
- trace, NULL, sb_size, n_sb,
- trace->settings[chan].overwrite,
- trace->settings[chan].switch_timer_interval,
- trace->settings[chan].read_timer_interval);
- if (err != 0) {
- printk(KERN_ERR "LTT : Can't create channel %s.\n",
- channel_name);
- goto create_channel_error;
- }
- }
-
- list_del(&trace->list);
- if (list_empty(<t_traces.head))
- set_kernel_trace_flag_all_tasks();
- list_add_rcu(&trace->list, <t_traces.head);
- synchronize_trace();
-
- ltt_unlock_traces();
-
- return 0;
-
-create_channel_error:
- for (chan--; chan >= 0; chan--)
- ltt_channel_destroy(trace->channels[chan]);
- trace->ops->remove_dirs(trace);
-
-dirs_error:
- module_put(trace->transport->owner);
-transport_error:
- put_trace_clock();
-traces_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_alloc);
-
-/*
- * It is worked as a wrapper for current version of ltt_control.ko.
- * We will make a new ltt_control based on debugfs, and control each channel's
- * buffer.
- */
-static
-int ltt_trace_create(const char *trace_name, const char *trace_type,
- enum trace_mode mode,
- unsigned int subbuf_size_low, unsigned int n_subbufs_low,
- unsigned int subbuf_size_med, unsigned int n_subbufs_med,
- unsigned int subbuf_size_high, unsigned int n_subbufs_high)
-{
- int err = 0;
-
- err = ltt_trace_setup(trace_name);
- if (IS_ERR_VALUE(err))
- return err;
-
- err = ltt_trace_set_type(trace_name, trace_type);
- if (IS_ERR_VALUE(err))
- return err;
-
- err = ltt_trace_alloc(trace_name);
- if (IS_ERR_VALUE(err))
- return err;
-
- return err;
-}
-
-/* Must be called while sure that trace is in the list. */
-static int _ltt_trace_destroy(struct ltt_trace *trace)
-{
- int err = -EPERM;
-
- if (trace == NULL) {
- err = -ENOENT;
- goto traces_error;
- }
- if (trace->active) {
- printk(KERN_ERR
- "LTT : Can't destroy trace %s : tracer is active\n",
- trace->trace_name);
- err = -EBUSY;
- goto active_error;
- }
- /* Everything went fine */
- list_del_rcu(&trace->list);
- synchronize_trace();
- if (list_empty(<t_traces.head)) {
- clear_kernel_trace_flag_all_tasks();
- }
- return 0;
-
- /* error handling */
-active_error:
-traces_error:
- return err;
-}
-
-/* Sleepable part of the destroy */
-static void __ltt_trace_destroy(struct ltt_trace *trace)
-{
- int i;
-
- for (i = 0; i < trace->nr_channels; i++)
- ltt_channel_destroy(trace->channels[i]);
- kref_put(&trace->kref, ltt_release_trace);
-}
-
-int ltt_trace_destroy(const char *trace_name)
-{
- int err = 0;
- struct ltt_trace *trace;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find(trace_name);
- if (trace) {
- err = _ltt_trace_destroy(trace);
- if (err)
- goto error;
-
- __ltt_trace_destroy(trace);
- ltt_unlock_traces();
- put_trace_clock();
-
- return 0;
- }
-
- trace = _ltt_trace_find_setup(trace_name);
- if (trace) {
- _ltt_trace_free(trace);
- ltt_unlock_traces();
- return 0;
- }
-
- err = -ENOENT;
-
- /* Error handling */
-error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_destroy);
-
-/* must be called from within a traces lock. */
-static int _ltt_trace_start(struct ltt_trace *trace)
-{
- int err = 0;
-
- if (trace == NULL) {
- err = -ENOENT;
- goto traces_error;
- }
- if (trace->active)
- printk(KERN_INFO "LTT : Tracing already active for trace %s\n",
- trace->trace_name);
- if (!try_module_get(ltt_run_filter_owner)) {
- err = -ENODEV;
- printk(KERN_ERR "LTT : Can't lock filter module.\n");
- goto get_ltt_run_filter_error;
- }
- trace->active = 1;
- /* Read by trace points without protection : be careful */
- ltt_traces.num_active_traces++;
- return err;
-
- /* error handling */
-get_ltt_run_filter_error:
-traces_error:
- return err;
-}
-
-int ltt_trace_start(const char *trace_name)
-{
- int err = 0;
- struct ltt_trace *trace;
-
- ltt_lock_traces();
-
- trace = _ltt_trace_find(trace_name);
- err = _ltt_trace_start(trace);
- if (err)
- goto no_trace;
-
- ltt_unlock_traces();
-
- /*
- * Call the kernel state dump.
- * Events will be mixed with real kernel events, it's ok.
- * Notice that there is no protection on the trace : that's exactly
- * why we iterate on the list and check for trace equality instead of
- * directly using this trace handle inside the logging function.
- */
-
- ltt_dump_marker_state(trace);
-
- if (!try_module_get(ltt_statedump_owner)) {
- err = -ENODEV;
- printk(KERN_ERR
- "LTT : Can't lock state dump module.\n");
- } else {
- ltt_statedump_functor(trace);
- module_put(ltt_statedump_owner);
- }
-
- return err;
-
- /* Error handling */
-no_trace:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_start);
-
-/* must be called from within traces lock */
-static int _ltt_trace_stop(struct ltt_trace *trace)
-{
- int err = -EPERM;
-
- if (trace == NULL) {
- err = -ENOENT;
- goto traces_error;
- }
- if (!trace->active)
- printk(KERN_INFO "LTT : Tracing not active for trace %s\n",
- trace->trace_name);
- if (trace->active) {
- trace->active = 0;
- ltt_traces.num_active_traces--;
- synchronize_trace(); /* Wait for each tracing to be finished */
- }
- module_put(ltt_run_filter_owner);
- /* Everything went fine */
- return 0;
-
- /* Error handling */
-traces_error:
- return err;
-}
-
-int ltt_trace_stop(const char *trace_name)
-{
- int err = 0;
- struct ltt_trace *trace;
-
- ltt_lock_traces();
- trace = _ltt_trace_find(trace_name);
- err = _ltt_trace_stop(trace);
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_trace_stop);
-
-/**
- * ltt_control - Trace control in-kernel API
- * @msg: Action to perform
- * @trace_name: Trace on which the action must be done
- * @trace_type: Type of trace (normal, flight, hybrid)
- * @args: Arguments specific to the action
- */
-int ltt_control(enum ltt_control_msg msg, const char *trace_name,
- const char *trace_type, union ltt_control_args args)
-{
- int err = -EPERM;
-
- printk(KERN_ALERT "ltt_control : trace %s\n", trace_name);
- switch (msg) {
- case LTT_CONTROL_START:
- printk(KERN_DEBUG "Start tracing %s\n", trace_name);
- err = ltt_trace_start(trace_name);
- break;
- case LTT_CONTROL_STOP:
- printk(KERN_DEBUG "Stop tracing %s\n", trace_name);
- err = ltt_trace_stop(trace_name);
- break;
- case LTT_CONTROL_CREATE_TRACE:
- printk(KERN_DEBUG "Creating trace %s\n", trace_name);
- err = ltt_trace_create(trace_name, trace_type,
- args.new_trace.mode,
- args.new_trace.subbuf_size_low,
- args.new_trace.n_subbufs_low,
- args.new_trace.subbuf_size_med,
- args.new_trace.n_subbufs_med,
- args.new_trace.subbuf_size_high,
- args.new_trace.n_subbufs_high);
- break;
- case LTT_CONTROL_DESTROY_TRACE:
- printk(KERN_DEBUG "Destroying trace %s\n", trace_name);
- err = ltt_trace_destroy(trace_name);
- break;
- }
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_control);
-
-/**
- * ltt_filter_control - Trace filter control in-kernel API
- * @msg: Action to perform on the filter
- * @trace_name: Trace on which the action must be done
- */
-int ltt_filter_control(enum ltt_filter_control_msg msg, const char *trace_name)
-{
- int err;
- struct ltt_trace *trace;
-
- printk(KERN_DEBUG "ltt_filter_control : trace %s\n", trace_name);
- ltt_lock_traces();
- trace = _ltt_trace_find(trace_name);
- if (trace == NULL) {
- printk(KERN_ALERT
- "Trace does not exist. Cannot proxy control request\n");
- err = -ENOENT;
- goto trace_error;
- }
- if (!try_module_get(ltt_filter_control_owner)) {
- err = -ENODEV;
- goto get_module_error;
- }
- switch (msg) {
- case LTT_FILTER_DEFAULT_ACCEPT:
- printk(KERN_DEBUG
- "Proxy filter default accept %s\n", trace_name);
- err = (*ltt_filter_control_functor)(msg, trace);
- break;
- case LTT_FILTER_DEFAULT_REJECT:
- printk(KERN_DEBUG
- "Proxy filter default reject %s\n", trace_name);
- err = (*ltt_filter_control_functor)(msg, trace);
- break;
- default:
- err = -EPERM;
- }
- module_put(ltt_filter_control_owner);
-
-get_module_error:
-trace_error:
- ltt_unlock_traces();
- return err;
-}
-EXPORT_SYMBOL_GPL(ltt_filter_control);
-
-int __init ltt_init(void)
-{
- /* Make sure no page fault can be triggered by this module */
- vmalloc_sync_all();
- init_timer_deferrable(<t_async_wakeup_timer);
- return 0;
-}
-
-module_init(ltt_init)
-
-static void __exit ltt_exit(void)
-{
- struct ltt_trace *trace;
- struct list_head *pos, *n;
-
- ltt_lock_traces();
- /* Stop each trace, currently being read by RCU read-side */
- list_for_each_entry_rcu(trace, <t_traces.head, list)
- _ltt_trace_stop(trace);
- /* Wait for quiescent state. Readers have preemption disabled. */
- synchronize_trace();
- /* Safe iteration is now permitted. It does not have to be RCU-safe
- * because no readers are left. */
- list_for_each_safe(pos, n, <t_traces.head) {
- trace = container_of(pos, struct ltt_trace, list);
- /* _ltt_trace_destroy does a synchronize_trace() */
- _ltt_trace_destroy(trace);
- __ltt_trace_destroy(trace);
- }
- /* free traces in pre-alloc status */
- list_for_each_safe(pos, n, <t_traces.setup_head) {
- trace = container_of(pos, struct ltt_trace, list);
- _ltt_trace_free(trace);
- }
-
- ltt_unlock_traces();
-}
-
-module_exit(ltt_exit)
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Tracer Kernel API");
+++ /dev/null
-/**
- * ltt-type-serializer.c
- *
- * LTTng specialized type serializer.
- *
- * Copyright Mathieu Desnoyers, 2008.
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-#include <linux/module.h>
-
-#include "ltt-type-serializer.h"
-#include "ltt-relay-lockless.h"
-
-notrace
-void _ltt_specialized_trace(void *probe_data,
- void *serialize_private, unsigned int data_size,
- unsigned int largest_align)
-{
- struct ltt_event *event = probe_data;
- int ret;
- uint16_t eID;
- size_t slot_size;
- struct ltt_chanbuf *buf;
- struct ltt_channel *chan;
- struct ltt_session *session;
- uint64_t tsc;
- long buf_offset;
- int cpu;
- unsigned int rflags;
-
- /* disabled from tracepoints rcu_read_lock_sched_notrace(); */
- cpu = smp_processor_id();
- __get_cpu_var(ltt_nesting)++;
- /*
- * asm volatile and "memory" clobber prevent the compiler from moving
- * instructions out of the ltt nesting count. This is required to ensure
- * that probe side-effects which can cause recursion (e.g. unforeseen
- * traps, divisions by 0, ...) are triggered within the incremented
- * nesting count section.
- */
- barrier();
- eID = event->id;
- chan = event->chan;
- session = chan->session;
-
- if (unlikely(!session->active))
- goto skip;
- if (unlikely(!ltt_run_filter(session, chan, event)))
- goto skip;
-#ifdef LTT_DEBUG_EVENT_SIZE
- rflags = LTT_RFLAG_ID_SIZE;
-#else
- if (unlikely(eID >= LTT_FREE_EVENTS))
- rflags = LTT_RFLAG_ID;
- else
- rflags = 0;
-#endif
- /* reserve space : header and data */
- ret = ltt_reserve_slot(chan, trace, data_size, largest_align,
- cpu, &buf, &slot_size, &buf_offset, &tsc,
- &rflags);
- if (unlikely(ret < 0))
- goto skip; /* buffer full */
-
- /* Out-of-order write : header and data */
- buf_offset = ltt_write_event_header(&buf->a, &chan->a,
- buf_offset, eID, data_size,
- tsc, rflags);
- if (data_size) {
- buf_offset += ltt_align(buf_offset, largest_align);
- ltt_relay_write(&buf->a, &chan->a, buf_offset,
- serialize_private, data_size);
- buf_offset += data_size;
- }
- /* Out-of-order commit */
- ltt_commit_slot(buf, chan, buf_offset, data_size, slot_size);
-skip:
- /*
- * asm volatile and "memory" clobber prevent the compiler from moving
- * instructions out of the ltt nesting count. This is required to ensure
- * that probe side-effects which can cause recursion (e.g. unforeseen
- * traps, divisions by 0, ...) are triggered within the incremented
- * nesting count section.
- */
- barrier();
- __get_cpu_var(ltt_nesting)--;
- /* disabled from tracepoints rcu_read_unlock_sched_notrace(); */
-}
-EXPORT_SYMBOL_GPL(_ltt_specialized_trace);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("LTT type serializer");
+++ /dev/null
-#ifndef _LTT_TYPE_SERIALIZER_H
-#define _LTT_TYPE_SERIALIZER_H
-
-#include <linux/if.h> /* For IFNAMSIZ */
-
-#include "ltt-tracer.h"
-
-/*
- * largest_align must be non-zero, equal to the minimum between the largest type
- * and sizeof(void *).
- */
-extern void _ltt_specialized_trace(void *probe_data,
- void *serialize_private, unsigned int data_size,
- unsigned int largest_align);
-
-/*
- * Statically check that 0 < largest_align < sizeof(void *) to make sure it is
- * dumb-proof. It will make sure 0 is changed into 1 and unsigned long long is
- * changed into sizeof(void *) on 32-bit architectures.
- */
-static inline void ltt_specialized_trace(void *probe_data,
- void *serialize_private, unsigned int data_size,
- unsigned int largest_align)
-{
- largest_align = min_t(unsigned int, largest_align, sizeof(void *));
- largest_align = max_t(unsigned int, largest_align, 1);
- _ltt_specialized_trace(probe_data, serialize_private, data_size,
- largest_align);
-}
-
-/*
- * Type serializer definitions.
- */
-
-/*
- * Return size of structure without end-of-structure padding.
- */
-#define serialize_sizeof(type) offsetof(typeof(type), end_field)
-
-struct serialize_long_int {
- unsigned long f1;
- unsigned int f2;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_int_int_long {
- unsigned int f1;
- unsigned int f2;
- unsigned long f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_int_int_short {
- unsigned int f1;
- unsigned int f2;
- unsigned short f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_long {
- unsigned long f1;
- unsigned long f2;
- unsigned long f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_int {
- unsigned long f1;
- unsigned long f2;
- unsigned int f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_short_char {
- unsigned long f1;
- unsigned long f2;
- unsigned short f3;
- unsigned char f4;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_short {
- unsigned long f1;
- unsigned long f2;
- unsigned short f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_short_char {
- unsigned long f1;
- unsigned short f2;
- unsigned char f3;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_short {
- unsigned long f1;
- unsigned short f2;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_char {
- unsigned long f1;
- unsigned char f2;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_ifname {
- unsigned long f1;
- unsigned char f2[IFNAMSIZ];
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_sizet_int {
- size_t f1;
- unsigned int f2;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_sizet_int {
- unsigned long f1;
- unsigned long f2;
- size_t f3;
- unsigned int f4;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_long_long_sizet_int_int {
- unsigned long f1;
- unsigned long f2;
- size_t f3;
- unsigned int f4;
- unsigned int f5;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_l4421224411111 {
- unsigned long f1;
- uint32_t f2;
- uint32_t f3;
- uint16_t f4;
- uint8_t f5;
- uint16_t f6;
- uint16_t f7;
- uint32_t f8;
- uint32_t f9;
- uint8_t f10;
- uint8_t f11;
- uint8_t f12;
- uint8_t f13;
- uint8_t f14;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_l214421224411111 {
- unsigned long f1;
- uint16_t f2;
- uint8_t f3;
- uint32_t f4;
- uint32_t f5;
- uint16_t f6;
- uint8_t f7;
- uint16_t f8;
- uint16_t f9;
- uint32_t f10;
- uint32_t f11;
- uint8_t f12;
- uint8_t f13;
- uint8_t f14;
- uint8_t f15;
- uint8_t f16;
- uint8_t end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-
-struct serialize_l4412228 {
- unsigned long f1;
- uint32_t f2;
- uint32_t f3;
- uint8_t f4;
- uint16_t f5;
- uint16_t f6;
- uint16_t f7;
- uint64_t f8;
- unsigned char end_field[0];
-} RING_BUFFER_ALIGN_ATTR;
-#endif /* _LTT_TYPE_SERIALIZER_H */
+++ /dev/null
-/*
- * Copyright (C) 2008 Mathieu Desnoyers
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/marker.h>
-#include <linux/uaccess.h>
-#include <linux/gfp.h>
-#include <linux/fs.h>
-#include <linux/debugfs.h>
-#include <linux/slab.h>
-
-#include "ltt-type-serializer.h"
-
-#define LTT_WRITE_EVENT_FILE "write_event"
-
-DEFINE_MARKER(userspace, event, "string %s");
-static struct dentry *ltt_event_file;
-
-/**
- * write_event - write a userspace string into the trace system
- * @file: file pointer
- * @user_buf: user string
- * @count: length to copy, including the final NULL
- * @ppos: unused
- *
- * Copy a string into a trace event, in channel "userspace", event "event".
- * Copies until either \n or \0 is reached.
- * On success, returns the number of bytes copied from the source, including the
- * \n or \0 character (if there was one in the count range). It cannot return
- * more than count.
- * Inspired from tracing_mark_write implementation from Steven Rostedt and
- * Ingo Molnar.
- */
-static
-ssize_t write_event(struct file *file, const char __user *user_buf,
- size_t count, loff_t *ppos)
-{
- struct marker *marker;
- char *buf, *end;
- long copycount;
- ssize_t ret;
-
- buf = kmalloc(count + 1, GFP_KERNEL);
- if (!buf) {
- ret = -ENOMEM;
- goto string_out;
- }
- copycount = strncpy_from_user(buf, user_buf, count);
- if (copycount < 0) {
- ret = -EFAULT;
- goto string_err;
- }
- /* Cut from the first nil or newline. */
- buf[copycount] = '\0';
- end = strchr(buf, '\n');
- if (end) {
- *end = '\0';
- copycount = end - buf;
- }
- /* Add final \0 to copycount */
- copycount++;
- marker = &GET_MARKER(userspace, event);
- ltt_specialized_trace(marker, marker->single.probe_private, buf,
- copycount, sizeof(char));
- /* If there is no \0 nor \n in count, do not return a larger value */
- ret = min_t(size_t, copycount, count);
-string_err:
- kfree(buf);
-string_out:
- return ret;
-}
-
-static const struct file_operations ltt_userspace_operations = {
- .write = write_event,
-};
-
-static int __init ltt_userspace_init(void)
-{
- struct dentry *ltt_root_dentry;
- int err = 0;
-
- ltt_root_dentry = get_ltt_root();
- if (!ltt_root_dentry) {
- err = -ENOENT;
- goto err_no_root;
- }
-
- ltt_event_file = debugfs_create_file(LTT_WRITE_EVENT_FILE,
- S_IWUGO,
- ltt_root_dentry,
- NULL,
- <t_userspace_operations);
- if (IS_ERR(ltt_event_file) || !ltt_event_file) {
- printk(KERN_ERR
- "ltt_userspace_init: failed to create file %s\n",
- LTT_WRITE_EVENT_FILE);
- err = -EPERM;
- goto err_no_file;
- }
-
- return err;
-err_no_file:
- put_ltt_root();
-err_no_root:
- return err;
-}
-
-static void __exit ltt_userspace_exit(void)
-{
- debugfs_remove(ltt_event_file);
- put_ltt_root();
-}
-
-module_init(ltt_userspace_init);
-module_exit(ltt_userspace_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>");
-MODULE_DESCRIPTION("Linux Trace Toolkit Userspace Event");
+++ /dev/null
-# LTTng tracing probes
-
-ifdef CONFIG_FTRACE
-CFLAGS_REMOVE_kernel-trace.o = -pg
-CFLAGS_REMOVE_mm-trace.o = -pg
-CFLAGS_REMOVE_fs-trace.o = -pg
-CFLAGS_REMOVE_ipc-trace.o = -pg
-CFLAGS_REMOVE_lockdep-trace.o = -pg
-CFLAGS_REMOVE_rcu-trace.o = -pg
-CFLAGS_REMOVE_syscall-trace.o = -pg
-CFLAGS_REMOVE_trap-trace.o = -pg
-CFLAGS_REMOVE_pm-trace.o = -pg
-endif
-
-obj-m += kernel-trace.o mm-trace.o fs-trace.o ipc-trace.o lockdep-trace.o \
- rcu-trace.o syscall-trace.o trap-trace.o pm-trace.o
-
-ifeq ($(CONFIG_NET),y)
-ifdef CONFIG_FTRACE
-CFLAGS_REMOVE_net-trace.o = -pg
-CFLAGS_REMOVE_net-extended-trace.o = -pg
-endif
-obj-m += net-trace.o net-extended-trace.o
-endif
-
-ifdef CONFIG_JBD2
-ifdef CONFIG_FTRACE
-CFLAGS_REMOVE_jbd2-trace.o = -pg
-endif
-obj-m += jbd2-trace.o
-endif
-
-#ifdef CONFIG_EXT4_FS
-#ifdef CONFIG_FTRACE
-#CFLAGS_REMOVE_ext4-trace.o = -pg
-#endif
-#obj-$(CONFIG_LTT_TRACEPROBES) += ext4-trace.o
-#endif
-
-ifdef CONFIG_BLOCK
-ifdef CONFIG_FTRACE
-CFLAGS_REMOVE_block-trace.o = -pg
-endif
-obj-m += block-trace.o
-endif
-
-
+++ /dev/null
-/*
- * ltt/probes/block-trace.c
- *
- * block layer tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-
-#include <trace/events/block.h>
-
-/*
- * Add rq cmd as a sequence. Needs new type. (size + binary blob)
- */
-
-void probe_block_rq_abort(void *data, struct request_queue *q, struct request *rq)
-{
- int rw = rq->cmd_flags & 0x03;
-
- if (blk_discard_rq(rq))
- rw |= (1 << BIO_RW_DISCARD);
-
- if (blk_pc_request(rq)) {
- trace_mark_tp(block, rq_abort_pc, block_rq_abort,
- probe_block_rq_abort,
- "data_len %u rw %d errors %d",
- blk_rq_bytes(rq), rw, rq->errors);
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both rq_abort_pc and rq_abort_fs
- * markers to have the rq_abort_fs marker enabled.
- */
- trace_mark(block, rq_abort_fs,
- "hard_sector %llu "
- "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
- rw, rq->errors);
- }
-}
-
-void probe_block_rq_insert(void *data, struct request_queue *q, struct request *rq)
-{
- int rw = rq->cmd_flags & 0x03;
-
- if (blk_discard_rq(rq))
- rw |= (1 << BIO_RW_DISCARD);
-
- if (blk_pc_request(rq)) {
- trace_mark_tp(block, rq_insert_pc, block_rq_insert,
- probe_block_rq_insert,
- "data_len %u rw %d errors %d",
- blk_rq_bytes(rq), rw, rq->errors);
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both rq_insert_pc and
- * rq_insert_fs markers to have the rq_insert_fs marker enabled.
- */
- trace_mark(block, rq_insert_fs,
- "hard_sector %llu "
- "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
- rw, rq->errors);
- }
-}
-
-void probe_block_rq_issue(void *data, struct request_queue *q, struct request *rq)
-{
- int rw = rq->cmd_flags & 0x03;
-
- if (blk_discard_rq(rq))
- rw |= (1 << BIO_RW_DISCARD);
-
- if (blk_pc_request(rq)) {
- trace_mark_tp(block, rq_issue_pc, block_rq_issue,
- probe_block_rq_issue,
- "data_len %u rw %d errors %d",
- blk_rq_bytes(rq), rw, rq->errors);
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both rq_issue_pc and rq_issue_fs
- * markers to have the rq_issue_fs marker enabled.
- */
- trace_mark(block, rq_issue_fs,
- "hard_sector %llu "
- "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
- rw, rq->errors);
- }
-}
-
-void probe_block_rq_requeue(void *data, struct request_queue *q, struct request *rq)
-{
- int rw = rq->cmd_flags & 0x03;
-
- if (blk_discard_rq(rq))
- rw |= (1 << BIO_RW_DISCARD);
-
- if (blk_pc_request(rq)) {
- trace_mark_tp(block, rq_requeue_pc, block_rq_requeue,
- probe_block_rq_requeue,
- "data_len %u rw %d errors %d",
- blk_rq_bytes(rq), rw, rq->errors);
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both rq_requeue_pc and
- * rq_requeue_fs markers to have the rq_requeue_fs marker
- * enabled.
- */
- trace_mark(block, rq_requeue_fs,
- "hard_sector %llu "
- "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
- rw, rq->errors);
- }
-}
-
-void probe_block_rq_complete(void *data, struct request_queue *q, struct request *rq)
-{
- int rw = rq->cmd_flags & 0x03;
-
- if (blk_discard_rq(rq))
- rw |= (1 << BIO_RW_DISCARD);
-
- if (blk_pc_request(rq)) {
- trace_mark_tp(block, rq_complete_pc, block_rq_complete,
- probe_block_rq_complete,
- "data_len %u rw %d errors %d",
- blk_rq_bytes(rq), rw, rq->errors);
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both rq_complete_pc and
- * rq_complete_fs markers to have the rq_complete_fs marker
- * enabled.
- */
- trace_mark(block, rq_complete_fs,
- "hard_sector %llu "
- "rw %d errors %d", (unsigned long long)blk_rq_pos(rq),
- rw, rq->errors);
- }
-}
-
-void probe_block_bio_bounce(void *data, struct request_queue *q, struct bio *bio)
-{
- trace_mark_tp(block, bio_bounce, block_bio_bounce,
- probe_block_bio_bounce,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
-}
-
-void probe_block_bio_complete(void *data, struct request_queue *q, struct bio *bio)
-{
- trace_mark_tp(block, bio_complete, block_bio_complete,
- probe_block_bio_complete,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
-}
-
-void probe_block_bio_backmerge(void *data, struct request_queue *q, struct bio *bio)
-{
- trace_mark_tp(block, bio_backmerge, block_bio_backmerge,
- probe_block_bio_backmerge,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
-}
-
-void probe_block_bio_frontmerge(void *data, struct request_queue *q, struct bio *bio)
-{
- trace_mark_tp(block, bio_frontmerge, block_bio_frontmerge,
- probe_block_bio_frontmerge,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
-}
-
-void probe_block_bio_queue(void *data, struct request_queue *q, struct bio *bio)
-{
- trace_mark_tp(block, bio_queue, block_bio_queue,
- probe_block_bio_queue,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
-}
-
-void probe_block_getrq(void *data, struct request_queue *q, struct bio *bio, int rw)
-{
- if (bio) {
- trace_mark_tp(block, getrq_bio, block_getrq,
- probe_block_getrq,
- "sector %llu size %u "
- "rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both getrq_bio and getrq markers
- * to have the getrq marker enabled.
- */
- trace_mark(block, getrq, "rw %d", rw);
- }
-}
-
-void probe_block_sleeprq(void *data, struct request_queue *q, struct bio *bio, int rw)
-{
- if (bio) {
- trace_mark_tp(block, sleeprq_bio, block_sleeprq,
- probe_block_sleeprq,
- "sector %llu size %u "
- "rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE));
- } else {
- /*
- * FIXME Using a simple trace_mark for the second event
- * possibility because tracepoints do not support multiple
- * connections to the same probe yet. They should have some
- * refcounting. Need to enable both sleeprq_bio and sleeprq
- * markers to have the sleeprq marker enabled.
- */
- trace_mark(block, sleeprq, "rw %d", rw);
- }
-}
-
-void probe_block_plug(void *data, struct request_queue *q)
-{
- trace_mark_tp(block, plug, block_plug, probe_block_plug,
- MARK_NOARGS);
-}
-
-void probe_block_unplug_io(void *data, struct request_queue *q)
-{
- unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
-
- trace_mark_tp(block, unplug_io, block_unplug_io, probe_block_unplug_io,
- "pdu %u", pdu);
-}
-
-void probe_block_unplug_timer(void *data, struct request_queue *q)
-{
- unsigned int pdu = q->rq.count[READ] + q->rq.count[WRITE];
-
- trace_mark_tp(block, unplug_timer, block_unplug_timer,
- probe_block_unplug_timer,
- "pdu %u", pdu);
-}
-
-void probe_block_split(void *data, struct request_queue *q, struct bio *bio,
- unsigned int pdu)
-{
- trace_mark_tp(block, split, block_split,
- probe_block_split,
- "sector %llu size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d pdu %u",
- (unsigned long long)bio->bi_sector, bio->bi_size,
- bio->bi_rw, !bio_flagged(bio, BIO_UPTODATE), pdu);
-}
-
-void probe_block_remap(void *data, struct request_queue *q, struct bio *bio,
- dev_t dev, sector_t from)
-{
- trace_mark_tp(block, remap, block_remap,
- probe_block_remap,
- "device_from %lu sector_from %llu device_to %lu "
- "size %u rw(FAILFAST_DRIVER,FAILFAST_TRANSPORT,"
- "FAILFAST_DEV,DISCARD,META,SYNC,BARRIER,AHEAD,RW) %lX "
- "not_uptodate #1u%d",
- (unsigned long)bio->bi_bdev->bd_dev,
- (unsigned long long)from,
- (unsigned long)dev,
- bio->bi_size, bio->bi_rw,
- !bio_flagged(bio, BIO_UPTODATE));
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Block Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/ext4-trace.c
- *
- * ext4 tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/writeback.h>
-#include <linux/debugfs.h>
-#include <linux/mutex.h>
-#include <linux/rcupdate.h>
-#include <trace/events/ext4.h>
-
-#include "../ltt-tracer.h"
-#include "../../fs/ext4/mballoc.h"
-
-static struct dentry *ext4_filter_dentry, *ext4_filter_dev_dentry,
- *ext4_filter_inode_dentry;
-static DEFINE_MUTEX(ext4_filter_mutex);
-/* Make sure we don't race between module exit and file write */
-static int module_exits;
-
-struct rcu_dev_filter {
- struct rcu_head rcu;
- char devname[NAME_MAX];
-};
-
-static struct rcu_dev_filter *dev_filter;
-/* ~0UL inode_filter enables all inodes */
-static unsigned long inode_filter = ~0UL;
-
-/*
- * Probes are executed in rcu_sched read-side critical section.
- */
-
-static int do_dev_filter(const char *dev)
-{
- struct rcu_dev_filter *ldev_filter = rcu_dereference(dev_filter);
-
- if (unlikely(ldev_filter))
- if (unlikely(strcmp(ldev_filter->devname, dev)))
- return 0;
- return 1;
-}
-
-static int do_inode_filter(unsigned long ino)
-{
- if (unlikely(inode_filter != ~0UL))
- if (unlikely(inode_filter != ino))
- return 0;
- return 1;
-}
-
-/*
- * Logical AND between dev and inode filter.
- */
-static int do_filter(const char *dev, unsigned long ino)
-{
- if (unlikely(!do_dev_filter(dev)))
- return 0;
- if (unlikely(!do_inode_filter(ino)))
- return 0;
- return 1;
-}
-
-
-void probe_ext4_free_inode(void *data, struct inode *inode)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, free_inode, ext4_free_inode,
- probe_ext4_free_inode,
- "dev %s ino %lu mode %d uid %lu gid %lu blocks %llu",
- inode->i_sb->s_id, inode->i_ino, inode->i_mode,
- (unsigned long) inode->i_uid, (unsigned long) inode->i_gid,
- (unsigned long long) inode->i_blocks);
-}
-
-void probe_ext4_request_inode(void *data, struct inode *dir, int mode)
-{
- if (unlikely(!do_filter(dir->i_sb->s_id, dir->i_ino)))
- return;
- trace_mark_tp(ext4, request_inode, ext4_request_inode,
- probe_ext4_request_inode,
- "dev %s dir %lu mode %d",
- dir->i_sb->s_id, dir->i_ino, mode);
-}
-
-void probe_ext4_allocate_inode(void *data, struct inode *inode, struct inode *dir, int mode)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)
- && !do_filter(dir->i_sb->s_id, dir->i_ino)))
- return;
- trace_mark_tp(ext4, allocate_inode, ext4_allocate_inode,
- probe_ext4_allocate_inode,
- "dev %s ino %lu dir %lu mode %d",
- dir->i_sb->s_id, inode->i_ino, dir->i_ino, mode);
-}
-
-void probe_ext4_write_begin(void *data, struct inode *inode, loff_t pos, unsigned int len,
- unsigned int flags)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, write_begin, ext4_write_begin,
- probe_ext4_write_begin,
- "dev %s ino %lu pos %llu len %u flags %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, flags);
-}
-
-void probe_ext4_ordered_write_end(void *data, struct inode *inode, loff_t pos,
- unsigned int len, unsigned int copied)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, ordered_write_end, ext4_ordered_write_end,
- probe_ext4_ordered_write_end,
- "dev %s ino %lu pos %llu len %u copied %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, copied);
-}
-
-void probe_ext4_writeback_write_end(void *data, struct inode *inode, loff_t pos,
- unsigned int len, unsigned int copied)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, writeback_write_end, ext4_writeback_write_end,
- probe_ext4_writeback_write_end,
- "dev %s ino %lu pos %llu len %u copied %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, copied);
-}
-
-void probe_ext4_journalled_write_end(void *data, struct inode *inode, loff_t pos,
- unsigned int len, unsigned int copied)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, journalled_write_end, ext4_journalled_write_end,
- probe_ext4_journalled_write_end,
- "dev %s ino %lu pos %llu len %u copied %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, copied);
-}
-
-/*
- * note : wbc_flags will have to be decoded by userspace.
- * #1x uses a single byte in the trace. Limits to 8 bits.
- */
-void probe_ext4_da_writepages(void *data, struct inode *inode,
- struct writeback_control *wbc)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, da_writepages, ext4_da_writepages,
- probe_ext4_da_writepages,
- "dev %s ino %lu nr_to_write %ld "
- "pages_skipped %ld range_start %llu range_end %llu "
- "wbc_flags(nonblocking,for_kupdate,"
- "for_reclaim,range_cyclic) #1x%u",
- inode->i_sb->s_id, inode->i_ino, wbc->nr_to_write,
- wbc->pages_skipped,
- (unsigned long long) wbc->range_start,
- (unsigned long long) wbc->range_end,
- (wbc->nonblocking << 3)
- | (wbc->for_kupdate << 2)
- | (wbc->for_reclaim << 1)
- | wbc->range_cyclic);
-}
-
-/*
- * note : wbc_flags will have to be decoded by userspace.
- * #1x uses a single byte in the trace. Limits to 8 bits.
- */
-void probe_ext4_da_writepages_result(void *data, struct inode *inode,
- struct writeback_control *wbc,
- int ret, int pages_written)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, da_writepages_result, ext4_da_writepages_result,
- probe_ext4_da_writepages_result,
- "dev %s ino %lu ret %d pages_written %d "
- "pages_skipped %ld "
- "wbc_flags(encountered_congestion,"
- "more_io,no_nrwrite_index_update) #1x%u",
- inode->i_sb->s_id, inode->i_ino, ret, pages_written,
- wbc->pages_skipped,
- (wbc->encountered_congestion << 2)
- | (wbc->more_io << 1)
- | wbc->no_nrwrite_index_update);
-}
-
-void probe_ext4_da_write_begin(void *data, struct inode *inode, loff_t pos,
- unsigned int len, unsigned int flags)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, da_write_begin, ext4_da_write_begin,
- probe_ext4_da_write_begin,
- "dev %s ino %lu pos %llu len %u flags %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, flags);
-}
-
-void probe_ext4_da_write_end(void *data, struct inode *inode, loff_t pos,
- unsigned int len, unsigned int copied)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, da_write_end, ext4_da_write_end,
- probe_ext4_da_write_end,
- "dev %s ino %lu pos %llu len %u copied %u",
- inode->i_sb->s_id, inode->i_ino,
- (unsigned long long) pos, len, copied);
-}
-
-void probe_ext4_discard_blocks(void *data, struct super_block *sb, unsigned long long blk,
- unsigned long long count)
-{
- if (unlikely(!do_dev_filter(sb->s_id)))
- return;
- trace_mark_tp(ext4, discard_blocks, ext4_discard_blocks,
- probe_ext4_discard_blocks,
- "dev %s blk %llu count %llu",
- sb->s_id, blk, count);
-}
-
-void probe_ext4_mb_new_inode_pa(void *data, struct ext4_allocation_context *ac,
- struct ext4_prealloc_space *pa)
-{
- if (unlikely(!do_filter(ac->ac_sb->s_id, ac->ac_inode->i_ino)))
- return;
- trace_mark_tp(ext4, mb_new_inode_pa, ext4_mb_new_inode_pa,
- probe_ext4_mb_new_inode_pa,
- "dev %s ino %lu pstart %llu len %u lstart %u",
- ac->ac_sb->s_id, ac->ac_inode->i_ino, pa->pa_pstart,
- pa->pa_len, pa->pa_lstart);
-}
-
-void probe_ext4_mb_new_group_pa(void *data, struct ext4_allocation_context *ac,
- struct ext4_prealloc_space *pa)
-{
- if (unlikely(!do_dev_filter(ac->ac_sb->s_id)))
- return;
- trace_mark_tp(ext4, mb_new_group_pa, ext4_mb_new_group_pa,
- probe_ext4_mb_new_group_pa,
- "dev %s pstart %llu len %u lstart %u",
- ac->ac_sb->s_id, pa->pa_pstart,
- pa->pa_len, pa->pa_lstart);
-}
-
-void probe_ext4_mb_release_inode_pa(void *data, struct ext4_allocation_context *ac,
- struct ext4_prealloc_space *pa,
- unsigned long long block,
- unsigned int count)
-{
- if (unlikely(!do_filter(ac->ac_sb->s_id, ac->ac_inode->i_ino)))
- return;
- trace_mark_tp(ext4, mb_release_inode_pa, ext4_mb_release_inode_pa,
- probe_ext4_mb_release_inode_pa,
- "dev %s ino %lu block %llu count %u",
- ac->ac_sb->s_id, pa->pa_inode->i_ino, block, count);
-}
-
-void probe_ext4_mb_release_group_pa(void *data, struct ext4_allocation_context *ac,
- struct ext4_prealloc_space *pa)
-{
- if (unlikely(!do_dev_filter(ac->ac_sb->s_id)))
- return;
- trace_mark_tp(ext4, mb_release_group_pa, ext4_mb_release_group_pa,
- probe_ext4_mb_release_group_pa,
- "dev %s pstart %llu len %d",
- ac->ac_sb->s_id, pa->pa_pstart, pa->pa_len);
-}
-
-void probe_ext4_discard_preallocations(void *data, struct inode *inode)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, discard_preallocations,
- ext4_discard_preallocations,
- probe_ext4_discard_preallocations,
- "dev %s ino %lu",
- inode->i_sb->s_id, inode->i_ino);
-}
-
-void probe_ext4_mb_discard_preallocations(void *data, struct super_block *sb, int needed)
-{
- if (unlikely(!do_dev_filter(sb->s_id)))
- return;
- trace_mark_tp(ext4, mb_discard_preallocations,
- ext4_mb_discard_preallocations,
- probe_ext4_mb_discard_preallocations,
- "dev %s needed %d",
- sb->s_id, needed);
-}
-
-void probe_ext4_request_blocks(void *data, struct ext4_allocation_request *ar)
-{
- if (ar->inode) {
- if (unlikely(!do_filter(ar->inode->i_sb->s_id,
- ar->inode->i_ino)))
- return;
- } else {
- if (unlikely(!do_dev_filter(ar->inode->i_sb->s_id)))
- return;
- }
- trace_mark_tp(ext4, request_blocks, ext4_request_blocks,
- probe_ext4_request_blocks,
- "dev %s flags %u len %u ino %lu "
- "lblk %llu goal %llu lleft %llu lright %llu "
- "pleft %llu pright %llu",
- ar->inode->i_sb->s_id, ar->flags, ar->len,
- ar->inode ? ar->inode->i_ino : 0,
- (unsigned long long) ar->logical,
- (unsigned long long) ar->goal,
- (unsigned long long) ar->lleft,
- (unsigned long long) ar->lright,
- (unsigned long long) ar->pleft,
- (unsigned long long) ar->pright);
-}
-
-void probe_ext4_allocate_blocks(void *data, struct ext4_allocation_request *ar,
- unsigned long long block)
-{
- if (ar->inode) {
- if (unlikely(!do_filter(ar->inode->i_sb->s_id,
- ar->inode->i_ino)))
- return;
- } else {
- if (unlikely(!do_dev_filter(ar->inode->i_sb->s_id)))
- return;
- }
- trace_mark_tp(ext4, allocate_blocks, ext4_allocate_blocks,
- probe_ext4_allocate_blocks,
- "dev %s block %llu flags %u len %u ino %lu "
- "logical %llu goal %llu lleft %llu lright %llu "
- "pleft %llu pright %llu",
- ar->inode->i_sb->s_id, (unsigned long long) block,
- ar->flags, ar->len, ar->inode ? ar->inode->i_ino : 0,
- (unsigned long long) ar->logical,
- (unsigned long long) ar->goal,
- (unsigned long long) ar->lleft,
- (unsigned long long) ar->lright,
- (unsigned long long) ar->pleft,
- (unsigned long long) ar->pright);
-}
-
-void probe_ext4_free_blocks(void *data, struct inode *inode, __u64 block,
- unsigned long count, int metadata)
-{
- if (unlikely(!do_filter(inode->i_sb->s_id, inode->i_ino)))
- return;
- trace_mark_tp(ext4, free_blocks, ext4_free_blocks,
- probe_ext4_free_blocks,
- "dev %s block %llu count %lu metadata %d ino %lu",
- inode->i_sb->s_id, (unsigned long long)block,
- count, metadata, inode->i_ino);
-}
-
-void probe_ext4_sync_file(void *data, struct file *file, struct dentry *dentry,
- int datasync)
-{
- if (unlikely(!do_dev_filter(dentry->d_inode->i_sb->s_id)))
- return;
- if (unlikely(!do_inode_filter(dentry->d_inode->i_ino)
- && !do_inode_filter(dentry->d_parent->d_inode->i_ino)))
- return;
- trace_mark_tp(ext4, sync_file, ext4_sync_file,
- probe_ext4_sync_file,
- "dev %s datasync %d ino %ld parent %ld",
- dentry->d_inode->i_sb->s_id, datasync, dentry->d_inode->i_ino,
- dentry->d_parent->d_inode->i_ino);
-}
-
-void probe_ext4_sync_fs(void *data, struct super_block *sb, int wait)
-{
- if (unlikely(!do_dev_filter(sb->s_id)))
- return;
- trace_mark_tp(ext4, sync_fs, ext4_sync_fs,
- probe_ext4_sync_fs,
- "dev %s wait %d",
- sb->s_id, wait);
-}
-
-static void free_dev_filter(struct rcu_head *head)
-{
- kfree(container_of(head, struct rcu_dev_filter, rcu));
-}
-
-static ssize_t dev_filter_op_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err = 0;
- char buf[NAME_MAX];
- int buf_size;
- char name[NAME_MAX];
- struct rcu_dev_filter *new, *old;
-
- mutex_lock(&ext4_filter_mutex);
- if (module_exits) {
- err = -EPERM;
- goto error;
- }
- buf_size = min(count, sizeof(buf) - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto error;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", name) != 1) {
- err = -EPERM;
- goto error;
- }
-
- old = dev_filter;
-
- /* Empty string or * means all active */
- if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
- new = NULL;
- } else {
- new = kmalloc(sizeof(*new), GFP_KERNEL);
- strcpy(new->devname, name);
- }
-
- rcu_assign_pointer(dev_filter, new);
- if (old)
- call_rcu_sched(&old->rcu, free_dev_filter);
-
- mutex_unlock(&ext4_filter_mutex);
- return count;
-
-error:
- mutex_unlock(&ext4_filter_mutex);
- return err;
-}
-
-static ssize_t dev_filter_op_read(struct file *filp, char __user *buffer,
- size_t count, loff_t *ppos)
-{
- ssize_t bcount;
- const char *devname;
-
- mutex_lock(&ext4_filter_mutex);
- if (!dev_filter)
- devname = "*";
- else
- devname = dev_filter->devname;
- bcount = simple_read_from_buffer(buffer, count, ppos,
- devname, strlen(devname));
- mutex_unlock(&ext4_filter_mutex);
- return bcount;
-}
-
-static struct file_operations ext4_dev_file_operations = {
- .write = dev_filter_op_write,
- .read = dev_filter_op_read,
-};
-
-static ssize_t inode_filter_op_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err = 0;
- char buf[NAME_MAX];
- int buf_size;
- char name[NAME_MAX];
- unsigned long inode_num;
-
- mutex_lock(&ext4_filter_mutex);
- if (module_exits) {
- err = -EPERM;
- goto error;
- }
- buf_size = min(count, sizeof(buf) - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto error;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", name) != 1) {
- err = -EPERM;
- goto error;
- }
-
- /* Empty string or * means all active */
- if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
- inode_filter = ~0UL;
- } else {
- if (sscanf(buf, "%lu", &inode_num) != 1) {
- err = -EPERM;
- goto error;
- }
- inode_filter = inode_num;
- }
-
- mutex_unlock(&ext4_filter_mutex);
- return count;
-
-error:
- mutex_unlock(&ext4_filter_mutex);
- return err;
-}
-
-static ssize_t inode_filter_op_read(struct file *filp, char __user *buffer,
- size_t count, loff_t *ppos)
-{
- ssize_t bcount;
- char inode_str[NAME_MAX];
-
- mutex_lock(&ext4_filter_mutex);
- if (inode_filter == ~0UL)
- strcpy(inode_str, "*");
- else {
- bcount = snprintf(inode_str, sizeof(inode_str), "%lu",
- inode_filter);
- if (bcount == sizeof(inode_str))
- bcount = -ENOSPC;
- if (bcount < 0)
- goto end;
- }
- bcount = simple_read_from_buffer(buffer, count, ppos,
- inode_str, strlen(inode_str));
-end:
- mutex_unlock(&ext4_filter_mutex);
- return bcount;
-}
-
-static struct file_operations ext4_inode_file_operations = {
- .write = inode_filter_op_write,
- .read = inode_filter_op_read,
-};
-
-static void release_filter_dev(void)
-{
- struct rcu_dev_filter *old;
-
- mutex_lock(&ext4_filter_mutex);
- module_exits = 1;
- old = dev_filter;
- rcu_assign_pointer(dev_filter, NULL);
- if (old)
- call_rcu_sched(&old->rcu, free_dev_filter);
- mutex_unlock(&ext4_filter_mutex);
-}
-
-static int __init filter_init(void)
-{
- struct dentry *filter_root_dentry;
- int err = 0;
-
- filter_root_dentry = get_filter_root();
- if (!filter_root_dentry) {
- err = -ENOENT;
- goto end;
- }
-
- ext4_filter_dentry = debugfs_create_dir("ext4", filter_root_dentry);
-
- if (IS_ERR(ext4_filter_dentry) || !ext4_filter_dentry) {
- printk(KERN_ERR "Failed to create ext4 filter file\n");
- err = -ENOMEM;
- goto end;
- }
-
- ext4_filter_dev_dentry = debugfs_create_file("dev", S_IWUSR,
- ext4_filter_dentry, NULL, &ext4_dev_file_operations);
- if (IS_ERR(ext4_filter_dev_dentry) || !ext4_filter_dev_dentry) {
- printk(KERN_ERR "Failed to create ext4 dev filter file\n");
- err = -ENOMEM;
- goto release_filter_dentry;
- }
-
- ext4_filter_inode_dentry = debugfs_create_file("inode", S_IWUSR,
- ext4_filter_dentry, NULL, &ext4_inode_file_operations);
- if (IS_ERR(ext4_filter_inode_dentry) || !ext4_filter_inode_dentry) {
- printk(KERN_ERR "Failed to create ext4 inode filter file\n");
- err = -ENOMEM;
- goto release_filter_dev_dentry;
- }
-
- goto end;
-
-release_filter_dev_dentry:
- debugfs_remove(ext4_filter_dev_dentry);
-release_filter_dentry:
- debugfs_remove(ext4_filter_dentry);
- release_filter_dev();
-end:
- return err;
-}
-
-static void __exit filter_exit(void)
-{
- debugfs_remove(ext4_filter_dev_dentry);
- debugfs_remove(ext4_filter_inode_dentry);
- debugfs_remove(ext4_filter_dentry);
- release_filter_dev();
-}
-
-module_init(filter_init);
-module_exit(filter_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("ext4 Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/fs-trace.c
- *
- * FS tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/buffer_head.h>
-#include <trace/fs.h>
-
-#include "../ltt-type-serializer.h"
-
-void probe_fs_buffer_wait_start(void *_data, struct buffer_head *bh)
-{
- trace_mark_tp(fs, buffer_wait_start, fs_buffer_wait_start,
- probe_fs_buffer_wait_start, "bh %p", bh);
-}
-
-void probe_fs_buffer_wait_end(void *_data, struct buffer_head *bh)
-{
- trace_mark_tp(fs, buffer_wait_end, fs_buffer_wait_end,
- probe_fs_buffer_wait_end, "bh %p", bh);
-}
-
-void probe_fs_exec(void *_data, char *filename)
-{
- trace_mark_tp(fs, exec, fs_exec, probe_fs_exec, "filename %s",
- filename);
-}
-
-void probe_fs_ioctl(void *_data, unsigned int fd, unsigned int cmd, unsigned long arg)
-{
- trace_mark_tp(fs, ioctl, fs_ioctl, probe_fs_ioctl,
- "fd %u cmd %u arg %lu", fd, cmd, arg);
-}
-
-void probe_fs_open(void *_data, int fd, char *filename)
-{
- trace_mark_tp(fs, open, fs_open, probe_fs_open,
- "fd %d filename %s", fd, filename);
-}
-
-void probe_fs_close(void *_data, unsigned int fd)
-{
- trace_mark_tp(fs, close, fs_close, probe_fs_close, "fd %u", fd);
-}
-
-void probe_fs_lseek(void *_data, unsigned int fd, long offset, unsigned int origin)
-{
- trace_mark_tp(fs, lseek, fs_lseek, probe_fs_lseek,
- "fd %u offset %ld origin %u", fd, offset, origin);
-}
-
-void probe_fs_llseek(void *_data, unsigned int fd, loff_t offset, unsigned int origin)
-{
- trace_mark_tp(fs, llseek, fs_llseek, probe_fs_llseek,
- "fd %u offset %lld origin %u", fd,
- (long long)offset, origin);
-}
-
-void probe_fs_read(void *_data, unsigned int fd, char __user *buf, size_t count,
- ssize_t ret);
-
-DEFINE_MARKER_TP(fs, read, fs_read, probe_fs_read,
- "count %zu fd %u");
-
-notrace void probe_fs_read(void *_data, unsigned int fd, char __user *buf, size_t count,
- ssize_t ret)
-{
- struct marker *marker;
- struct serialize_sizet_int data;
-
- data.f1 = count;
- data.f2 = fd;
-
- marker = &GET_MARKER(fs, read);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(size_t));
-}
-
-void probe_fs_write(void *_data, unsigned int fd, char __user *buf, size_t count,
- ssize_t ret);
-
-DEFINE_MARKER_TP(fs, write, fs_write, probe_fs_write,
- "count %zu fd %u");
-
-notrace void probe_fs_write(void *_data, unsigned int fd, char __user *buf, size_t count,
- ssize_t ret)
-{
- struct marker *marker;
- struct serialize_sizet_int data;
-
- data.f1 = count;
- data.f2 = fd;
-
- marker = &GET_MARKER(fs, write);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(size_t));
-}
-
-void probe_fs_pread64(void *_data, unsigned int fd, char __user *buf, size_t count,
- loff_t pos, ssize_t ret)
-{
- trace_mark_tp(fs, pread64, fs_pread64, probe_fs_pread64,
- "fd %u count %zu pos %llu",
- fd, count, (unsigned long long)pos);
-}
-
-void probe_fs_pwrite64(void *_data, unsigned int fd, const char __user *buf,
- size_t count, loff_t pos, ssize_t ret)
-{
- trace_mark_tp(fs, pwrite64, fs_pwrite64, probe_fs_pwrite64,
- "fd %u count %zu pos %llu",
- fd, count, (unsigned long long)pos);
-}
-
-void probe_fs_readv(void *_data, unsigned long fd, const struct iovec __user *vec,
- unsigned long vlen, ssize_t ret)
-{
- trace_mark_tp(fs, readv, fs_readv, probe_fs_readv,
- "fd %lu vlen %lu", fd, vlen);
-}
-
-void probe_fs_writev(void *_data, unsigned long fd, const struct iovec __user *vec,
- unsigned long vlen, ssize_t ret)
-{
- trace_mark_tp(fs, writev, fs_writev, probe_fs_writev,
- "fd %lu vlen %lu", fd, vlen);
-}
-
-void probe_fs_select(void *_data, int fd, struct timespec *end_time)
-{
- struct timespec tmptime;
-
- if (end_time) {
- tmptime = *end_time;
- } else {
- tmptime.tv_sec = -1L;
- tmptime.tv_nsec = -1L;
- }
-
- trace_mark_tp(fs, select, fs_select, probe_fs_select,
- "fd %d end_time_sec %ld end_time_nsec %ld", fd,
- tmptime.tv_sec, tmptime.tv_nsec);
-}
-
-void probe_fs_poll(void *_data, int fd)
-{
- trace_mark_tp(fs, pollfd, fs_poll, probe_fs_poll,
- "fd %d", fd);
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("FS Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/ipc-trace.c
- *
- * IPC tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <trace/ipc.h>
-
-void probe_ipc_msg_create(void *data, long id, int flags)
-{
- trace_mark_tp(ipc, msg_create, ipc_msg_create, probe_ipc_msg_create,
- "id %ld flags %d", id, flags);
-}
-
-void probe_ipc_sem_create(void *data, long id, int flags)
-{
- trace_mark_tp(ipc, sem_create, ipc_sem_create, probe_ipc_sem_create,
- "id %ld flags %d", id, flags);
-}
-
-void probe_ipc_shm_create(void *data, long id, int flags)
-{
- trace_mark_tp(ipc, shm_create, ipc_shm_create, probe_ipc_shm_create,
- "id %ld flags %d", id, flags);
-}
-
-void probe_ipc_call(void *data, unsigned int call, unsigned int first)
-{
- trace_mark_tp(ipc, call, ipc_call, probe_ipc_call,
- "call %u first %d", call, first);
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("IPC Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/jbd2-trace.c
- *
- * JBD2 tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/debugfs.h>
-#include <linux/mutex.h>
-#include <linux/rcupdate.h>
-#include <trace/events/jbd2.h>
-
-#include "../ltt-tracer.h"
-
-static struct dentry *jbd2_filter_dentry, *jbd2_filter_dev_dentry;
-static DEFINE_MUTEX(jbd2_filter_mutex);
-/* Make sure we don't race between module exit and file write */
-static int module_exits;
-
-struct rcu_dev_filter {
- struct rcu_head rcu;
- char devname[NAME_MAX];
-};
-
-static struct rcu_dev_filter *dev_filter;
-
-/*
- * Probes are executed in rcu_sched read-side critical section.
- */
-static int do_filter(const char *dev)
-{
- struct rcu_dev_filter *ldev_filter = rcu_dereference(dev_filter);
-
- if (unlikely(ldev_filter))
- if (unlikely(strcmp(ldev_filter->devname, dev)))
- return 0;
- return 1;
-}
-
-void probe_jbd2_checkpoint(void *data, journal_t *journal, int result)
-{
- if (unlikely(!do_filter(journal->j_devname)))
- return;
- trace_mark_tp(jbd2, checkpoint, jbd2_checkpoint,
- probe_jbd2_checkpoint, "dev %s need_checkpoint %d",
- journal->j_devname, result);
-}
-
-void probe_jbd2_start_commit(void *data, journal_t *journal,
- transaction_t *commit_transaction)
-{
- if (unlikely(!do_filter(journal->j_devname)))
- return;
- trace_mark_tp(jbd2, start_commit, jbd2_start_commit,
- probe_jbd2_start_commit, "dev %s transaction %d",
- journal->j_devname, commit_transaction->t_tid);
-}
-
-void probe_jbd2_end_commit(void *data, journal_t *journal,
- transaction_t *commit_transaction)
-{
- if (unlikely(!do_filter(journal->j_devname)))
- return;
- trace_mark_tp(jbd2, end_commit, jbd2_end_commit,
- probe_jbd2_end_commit, "dev %s transaction %d head %d",
- journal->j_devname, commit_transaction->t_tid,
- journal->j_tail_sequence);
-}
-
-static void free_dev_filter(struct rcu_head *head)
-{
- kfree(container_of(head, struct rcu_dev_filter, rcu));
-}
-
-static ssize_t filter_op_write(struct file *file,
- const char __user *user_buf, size_t count, loff_t *ppos)
-{
- int err = 0;
- char buf[NAME_MAX];
- int buf_size;
- char name[NAME_MAX];
- struct rcu_dev_filter *new, *old;
-
- mutex_lock(&jbd2_filter_mutex);
- if (module_exits) {
- err = -EPERM;
- goto error;
- }
- buf_size = min(count, sizeof(buf) - 1);
- err = copy_from_user(buf, user_buf, buf_size);
- if (err)
- goto error;
- buf[buf_size] = 0;
-
- if (sscanf(buf, "%s", name) != 1) {
- err = -EPERM;
- goto error;
- }
-
- old = dev_filter;
-
- /* Empty string or * means all active */
- if (name[0] == '\0' || (name[0] == '*' && name[1] == '\0')) {
- new = NULL;
- } else {
- new = kmalloc(sizeof(*new), GFP_KERNEL);
- strcpy(new->devname, name);
- }
-
- rcu_assign_pointer(dev_filter, new);
- if (old)
- call_rcu_sched(&old->rcu, free_dev_filter);
-
- mutex_unlock(&jbd2_filter_mutex);
- return count;
-
-error:
- mutex_unlock(&jbd2_filter_mutex);
- return err;
-}
-
-static ssize_t filter_op_read(struct file *filp, char __user *buffer,
- size_t count, loff_t *ppos)
-{
- ssize_t bcount;
- const char *devname;
-
- mutex_lock(&jbd2_filter_mutex);
- if (!dev_filter)
- devname = "*";
- else
- devname = dev_filter->devname;
- bcount = simple_read_from_buffer(buffer, count, ppos,
- devname, strlen(devname));
- mutex_unlock(&jbd2_filter_mutex);
- return bcount;
-}
-
-static struct file_operations jbd2_file_operations = {
- .write = filter_op_write,
- .read = filter_op_read,
-};
-
-static void release_filter_dev(void)
-{
- struct rcu_dev_filter *old;
-
- mutex_lock(&jbd2_filter_mutex);
- module_exits = 1;
- old = dev_filter;
- rcu_assign_pointer(dev_filter, NULL);
- if (old)
- call_rcu_sched(&old->rcu, free_dev_filter);
- mutex_unlock(&jbd2_filter_mutex);
-}
-
-static int __init filter_init(void)
-{
- struct dentry *filter_root_dentry;
- int err = 0;
-
- filter_root_dentry = get_filter_root();
- if (!filter_root_dentry) {
- err = -ENOENT;
- goto end;
- }
-
- jbd2_filter_dentry = debugfs_create_dir("jbd2", filter_root_dentry);
-
- if (IS_ERR(jbd2_filter_dentry) || !jbd2_filter_dentry) {
- printk(KERN_ERR "Failed to create jbd2 filter file\n");
- err = -ENOMEM;
- goto end;
- }
-
- jbd2_filter_dev_dentry = debugfs_create_file("dev", S_IWUSR,
- jbd2_filter_dentry, NULL, &jbd2_file_operations);
- if (IS_ERR(jbd2_filter_dentry) || !jbd2_filter_dentry) {
- printk(KERN_ERR "Failed to create jbd2 filter file\n");
- err = -ENOMEM;
- goto release_filter_dentry;
- }
-
- goto end;
-
-release_filter_dentry:
- debugfs_remove(jbd2_filter_dentry);
- release_filter_dev();
-end:
- return err;
-}
-
-static void __exit filter_exit(void)
-{
- debugfs_remove(jbd2_filter_dev_dentry);
- debugfs_remove(jbd2_filter_dentry);
- release_filter_dev();
-}
-
-module_init(filter_init);
-module_exit(filter_exit);
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("JBD2 Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/kernel-trace.c
- *
- * kernel tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/irq.h>
-#include <trace/events/signal.h>
-#include <trace/irq.h>
-#include <trace/sched.h>
-#include <trace/timer.h>
-#include <trace/kernel.h>
-#include <trace/fault.h>
-#include <trace/events/sched.h>
-
-#include "../ltt-tracer.h"
-#include "../ltt-type-serializer.h"
-
-/*
- * This should probably be added to s390.
- */
-#ifdef CONFIG_S390
-static struct pt_regs *get_irq_regs(void)
-{
- return task_pt_regs(current);
-}
-#endif
-
-/*
- * FIXME :
- * currently, the specialized tracepoint probes cannot call into other marker
- * probes, such as ftrace enable/disable. Given we want them to be as fast as
- * possible, it might not be so bad to lose this flexibility. But that means
- * such probes would have to connect to tracepoints on their own.
- */
-
-/* kernel_irq_entry specialized tracepoint probe */
-
-void probe_irq_entry(void *_data, unsigned int id, struct pt_regs *regs,
- struct irqaction *action);
-
-DEFINE_MARKER_TP(kernel, irq_entry, irq_entry, probe_irq_entry,
- "ip %lu handler %p irq_id #2u%u kernel_mode #1u%u");
-
-notrace void probe_irq_entry(void *_data, unsigned int id, struct pt_regs *regs,
- struct irqaction *action)
-{
- struct marker *marker;
- struct serialize_long_long_short_char data;
-
- if (unlikely(!regs))
- regs = get_irq_regs();
- if (likely(regs)) {
- data.f1 = instruction_pointer(regs);
- data.f4 = !user_mode(regs);
- } else {
- data.f1 = 0UL;
- data.f4 = 1;
- }
- data.f2 = (unsigned long) (action ? action->handler : NULL);
- data.f3 = id;
-
- marker = &GET_MARKER(kernel, irq_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_irq_next_handler(void *_data, unsigned int id, struct irqaction *action,
- irqreturn_t prev_ret);
-
-DEFINE_MARKER_TP(kernel, irq_next_handler, irq_next_handler,
- probe_irq_next_handler,
- "handler %p prev_ret #1u%u");
-
-notrace void probe_irq_next_handler(void *_data, unsigned int id, struct irqaction *action,
- irqreturn_t prev_ret)
-{
- struct marker *marker;
- struct serialize_long_char data;
-
- data.f1 = (unsigned long) (action ? action->handler : NULL);
- data.f2 = prev_ret;
-
- marker = &GET_MARKER(kernel, irq_next_handler);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_irq_exit specialized tracepoint probe */
-
-void probe_irq_exit(void *_data, irqreturn_t retval);
-
-DEFINE_MARKER_TP(kernel, irq_exit, irq_exit, probe_irq_exit,
- "handled #1u%u");
-
-notrace void probe_irq_exit(void *_data, irqreturn_t retval)
-{
- struct marker *marker;
- unsigned char data;
-
- data = IRQ_RETVAL(retval);
-
- marker = &GET_MARKER(kernel, irq_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-/* kernel_softirq_entry specialized tracepoint probe */
-
-void probe_softirq_entry(void *_data, struct softirq_action *h,
- struct softirq_action *softirq_vec);
-
-DEFINE_MARKER_TP(kernel, softirq_entry, softirq_entry,
- probe_softirq_entry, "softirq_id #1u%lu");
-
-notrace void probe_softirq_entry(void *_data, struct softirq_action *h,
- struct softirq_action *softirq_vec)
-{
- struct marker *marker;
- unsigned char data;
-
- data = ((unsigned long)h - (unsigned long)softirq_vec) / sizeof(*h);
-
- marker = &GET_MARKER(kernel, softirq_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-/* kernel_softirq_exit specialized tracepoint probe */
-
-void probe_softirq_exit(void *_data, struct softirq_action *h,
- struct softirq_action *softirq_vec);
-
-DEFINE_MARKER_TP(kernel, softirq_exit, softirq_exit,
- probe_softirq_exit, "softirq_id #1u%lu");
-
-notrace void probe_softirq_exit(void *_data, struct softirq_action *h,
- struct softirq_action *softirq_vec)
-{
- struct marker *marker;
- unsigned char data;
-
- data = ((unsigned long)h - (unsigned long)softirq_vec) / sizeof(*h);
-
- marker = &GET_MARKER(kernel, softirq_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-/* kernel_softirq_raise specialized tracepoint probe */
-
-void probe_softirq_raise(void *_data, unsigned int nr);
-
-DEFINE_MARKER_TP(kernel, softirq_raise, softirq_raise,
- probe_softirq_raise, "softirq_id #1u%u");
-
-notrace void probe_softirq_raise(void *_data, unsigned int nr)
-{
- struct marker *marker;
- unsigned char data;
-
- data = nr;
-
- marker = &GET_MARKER(kernel, softirq_raise);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-/* Standard probes */
-void probe_irq_tasklet_low_entry(void *_data, struct tasklet_struct *t)
-{
- trace_mark_tp(kernel, tasklet_low_entry, irq_tasklet_low_entry,
- probe_irq_tasklet_low_entry, "func %p data %lu",
- t->func, t->data);
-}
-
-void probe_irq_tasklet_low_exit(void *_data, struct tasklet_struct *t)
-{
- trace_mark_tp(kernel, tasklet_low_exit, irq_tasklet_low_exit,
- probe_irq_tasklet_low_exit, "func %p data %lu",
- t->func, t->data);
-}
-
-void probe_irq_tasklet_high_entry(void *_data, struct tasklet_struct *t)
-{
- trace_mark_tp(kernel, tasklet_high_entry, irq_tasklet_high_entry,
- probe_irq_tasklet_high_entry, "func %p data %lu",
- t->func, t->data);
-}
-
-void probe_irq_tasklet_high_exit(void *_data, struct tasklet_struct *t)
-{
- trace_mark_tp(kernel, tasklet_high_exit, irq_tasklet_high_exit,
- probe_irq_tasklet_high_exit, "func %p data %lu",
- t->func, t->data);
-}
-
-void probe_sched_kthread_stop(void *_data, struct task_struct *t)
-{
- trace_mark_tp(kernel, kthread_stop, sched_kthread_stop,
- probe_sched_kthread_stop, "pid %d", t->pid);
-}
-
-void probe_sched_kthread_stop_ret(void *_data, int ret)
-{
- trace_mark_tp(kernel, kthread_stop_ret, sched_kthread_stop_ret,
- probe_sched_kthread_stop_ret, "ret %d", ret);
-}
-
-void probe_sched_wait_task(void *_data, struct task_struct *p)
-{
- trace_mark_tp(kernel, sched_wait_task, sched_wait_task,
- probe_sched_wait_task, "pid %d state #2d%ld",
- p->pid, p->state);
-}
-
-/* kernel_sched_try_wakeup specialized tracepoint probe */
-
-void probe_sched_wakeup(void *_data, struct task_struct *p, int success);
-
-DEFINE_MARKER_TP(kernel, sched_try_wakeup, sched_wakeup,
- probe_sched_wakeup, "pid %d cpu_id %u state #2d%ld");
-
-notrace void probe_sched_wakeup(void *_data, struct task_struct *p, int success)
-{
- struct marker *marker;
- struct serialize_int_int_short data;
-
- data.f1 = p->pid;
- data.f2 = task_cpu(p);
- data.f3 = p->state;
-
- marker = &GET_MARKER(kernel, sched_try_wakeup);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(int));
-}
-
-void probe_sched_wakeup_new(void *_data, struct task_struct *p, int success)
-{
- trace_mark_tp(kernel, sched_wakeup_new_task, sched_wakeup_new,
- probe_sched_wakeup_new, "pid %d state #2d%ld cpu_id %u",
- p->pid, p->state, task_cpu(p));
-}
-
-/* kernel_sched_schedule specialized tracepoint probe */
-
-void probe_sched_switch(void *_data, struct task_struct *prev,
- struct task_struct *next);
-
-DEFINE_MARKER_TP(kernel, sched_schedule, sched_switch, probe_sched_switch,
- "prev_pid %d next_pid %d prev_state #2d%ld");
-
-notrace void probe_sched_switch(void *_data, struct task_struct *prev,
- struct task_struct *next)
-{
- struct marker *marker;
- struct serialize_int_int_short data;
-
- data.f1 = prev->pid;
- data.f2 = next->pid;
- data.f3 = prev->state;
-
- marker = &GET_MARKER(kernel, sched_schedule);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(int));
-}
-
-void probe_sched_migrate_task(void *_data, struct task_struct *p, int dest_cpu)
-{
- trace_mark_tp(kernel, sched_migrate_task, sched_migrate_task,
- probe_sched_migrate_task, "pid %d state #2d%ld dest_cpu %d",
- p->pid, p->state, dest_cpu);
-}
-
-void probe_sched_signal_send(void *_data, int sig, struct siginfo *info, struct task_struct *t)
-{
- trace_mark_tp(kernel, send_signal, signal_generate,
- probe_sched_signal_send, "pid %d signal %d", t->pid, sig);
-}
-
-void probe_sched_process_free(void *_data, struct task_struct *p)
-{
- trace_mark_tp(kernel, process_free, sched_process_free,
- probe_sched_process_free, "pid %d", p->pid);
-}
-
-void probe_sched_process_exit(void *_data, struct task_struct *p)
-{
- trace_mark_tp(kernel, process_exit, sched_process_exit,
- probe_sched_process_exit, "pid %d", p->pid);
-}
-
-void probe_sched_process_wait(void *_data, struct pid *pid)
-{
- trace_mark_tp(kernel, process_wait, sched_process_wait,
- probe_sched_process_wait, "pid %d", pid_nr(pid));
-}
-
-void probe_sched_process_fork(void *_data, struct task_struct *parent,
- struct task_struct *child)
-{
- trace_mark_tp(kernel, process_fork, sched_process_fork,
- probe_sched_process_fork,
- "parent_pid %d child_pid %d child_tgid %d",
- parent->pid, child->pid, child->tgid);
-}
-
-void probe_sched_kthread_create(void *_data, void *fn, int pid)
-{
- trace_mark_tp(kernel, kthread_create, sched_kthread_create,
- probe_sched_kthread_create,
- "fn %p pid %d", fn, pid);
-}
-
-void probe_timer_itimer_expired(void *_data, struct signal_struct *sig)
-{
- trace_mark_tp(kernel, timer_itimer_expired, timer_itimer_expired,
- probe_timer_itimer_expired, "pid %d",
- pid_nr(sig->leader_pid));
-}
-
-void probe_timer_itimer_set(void *_data, int which, struct itimerval *value)
-{
- trace_mark_tp(kernel, timer_itimer_set,
- timer_itimer_set, probe_timer_itimer_set,
- "which %d interval_sec %ld interval_usec %ld "
- "value_sec %ld value_usec %ld",
- which,
- value->it_interval.tv_sec,
- value->it_interval.tv_usec,
- value->it_value.tv_sec,
- value->it_value.tv_usec);
-}
-
-/* kernel_timer_set specialized tracepoint probe */
-
-void probe_timer_set(void *_data, struct timer_list *timer);
-
-DEFINE_MARKER_TP(kernel, timer_set, timer_set, probe_timer_set,
- "expires %lu function %p data %lu");
-
-notrace void probe_timer_set(void *_data, struct timer_list *timer)
-{
- struct marker *marker;
- struct serialize_long_long_long data;
-
- data.f1 = timer->expires;
- data.f2 = (unsigned long)timer->function;
- data.f3 = timer->data;
-
- marker = &GET_MARKER(kernel, timer_set);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_timer_update_time(void *_data, struct timespec *_xtime,
- struct timespec *_wall_to_monotonic)
-{
- trace_mark_tp(kernel, timer_update_time, timer_update_time,
- probe_timer_update_time,
- "jiffies #8u%llu xtime_sec %ld xtime_nsec %ld "
- "walltomonotonic_sec %ld walltomonotonic_nsec %ld",
- (unsigned long long)jiffies_64, _xtime->tv_sec, _xtime->tv_nsec,
- _wall_to_monotonic->tv_sec, _wall_to_monotonic->tv_nsec);
-}
-
-void probe_timer_timeout(void *_data, struct task_struct *p)
-{
- trace_mark_tp(kernel, timer_timeout, timer_timeout,
- probe_timer_timeout, "pid %d", p->pid);
-}
-
-void probe_kernel_printk(void *_data, unsigned long retaddr)
-{
- trace_mark_tp(kernel, printk, kernel_printk,
- probe_kernel_printk, "ip 0x%lX", retaddr);
-}
-
-void probe_kernel_vprintk(void *_data, unsigned long retaddr, char *buf, int len)
-{
- if (len > 0) {
- unsigned int loglevel;
- int mark_len;
- char *mark_buf;
- char saved_char;
-
- if (buf[0] == '<' && buf[1] >= '0' &&
- buf[1] <= '7' && buf[2] == '>') {
- loglevel = buf[1] - '0';
- mark_buf = &buf[3];
- mark_len = len - 3;
- } else {
- loglevel = default_message_loglevel;
- mark_buf = buf;
- mark_len = len;
- }
- if (mark_buf[mark_len - 1] == '\n')
- mark_len--;
- saved_char = mark_buf[mark_len];
- mark_buf[mark_len] = '\0';
- trace_mark_tp(kernel, vprintk, kernel_vprintk,
- probe_kernel_vprintk,
- "loglevel #1u%u string %s ip 0x%lX",
- loglevel, mark_buf, retaddr);
- mark_buf[mark_len] = saved_char;
- }
-}
-
-#ifdef CONFIG_MODULES
-void probe_kernel_module_free(void *_data, struct module *mod)
-{
- trace_mark_tp(kernel, module_free, kernel_module_free,
- probe_kernel_module_free, "name %s", mod->name);
-}
-
-void probe_kernel_module_load(void *_data, struct module *mod)
-{
- trace_mark_tp(kernel, module_load, kernel_module_load,
- probe_kernel_module_load, "name %s", mod->name);
-}
-#endif
-
-void probe_kernel_panic(void *_data, const char *fmt, va_list args)
-{
- char info[64];
- vsnprintf(info, sizeof(info), fmt, args);
- trace_mark_tp(kernel, panic, kernel_panic, probe_kernel_panic,
- "info %s", info);
-}
-
-void probe_kernel_kernel_kexec(void *_data, struct kimage *image)
-{
- trace_mark_tp(kernel, kernel_kexec, kernel_kernel_kexec,
- probe_kernel_kernel_kexec, "image %p", image);
-}
-
-void probe_kernel_crash_kexec(void *_data, struct kimage *image, struct pt_regs *regs)
-{
- trace_mark_tp(kernel, crash_kexec, kernel_crash_kexec,
- probe_kernel_crash_kexec, "image %p ip %p", image,
- regs ? (void *)instruction_pointer(regs) : NULL);
-}
-
-/* kernel_page_fault_entry specialized tracepoint probe */
-
-void probe_kernel_page_fault_entry(void *_data, struct pt_regs *regs, int trapnr,
- struct mm_struct *mm, struct vm_area_struct *vma,
- unsigned long address, int write_access);
-
-DEFINE_MARKER_TP(kernel, page_fault_entry, page_fault_entry,
- probe_kernel_page_fault_entry,
- "ip #p%lu address #p%lu trap_id #2u%u write_access #1u%u");
-
-notrace void probe_kernel_page_fault_entry(void *_data, struct pt_regs *regs, int trapnr,
- struct mm_struct *mm, struct vm_area_struct *vma,
- unsigned long address, int write_access)
-{
- struct marker *marker;
- struct serialize_long_long_short_char data;
-
- if (likely(regs))
- data.f1 = instruction_pointer(regs);
- else
- data.f1 = 0UL;
- data.f2 = address;
- data.f3 = (unsigned short)trapnr;
- data.f4 = (unsigned char)!!write_access;
-
- marker = &GET_MARKER(kernel, page_fault_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_page_fault_exit specialized tracepoint probe */
-
-void probe_kernel_page_fault_exit(void *_data, int res);
-
-DEFINE_MARKER_TP(kernel, page_fault_exit, page_fault_exit,
- probe_kernel_page_fault_exit,
- "res %d");
-
-notrace void probe_kernel_page_fault_exit(void *_data, int res)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(kernel, page_fault_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &res, sizeof(res), sizeof(res));
-}
-
-/* kernel_page_fault_nosem_entry specialized tracepoint probe */
-
-void probe_kernel_page_fault_nosem_entry(void *_data, struct pt_regs *regs,
- int trapnr, unsigned long address);
-
-DEFINE_MARKER_TP(kernel, page_fault_nosem_entry, page_fault_nosem_entry,
- probe_kernel_page_fault_nosem_entry,
- "ip #p%lu address #p%lu trap_id #2u%u");
-
-notrace void probe_kernel_page_fault_nosem_entry(void *_data, struct pt_regs *regs,
- int trapnr, unsigned long address)
-{
- struct marker *marker;
- struct serialize_long_long_short data;
-
- if (likely(regs))
- data.f1 = instruction_pointer(regs);
- else
- data.f1 = 0UL;
- data.f2 = address;
- data.f3 = (unsigned short)trapnr;
-
- marker = &GET_MARKER(kernel, page_fault_nosem_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_page_fault_nosem_exit specialized tracepoint probe */
-
-void probe_kernel_page_fault_nosem_exit(void *_data, int res);
-
-DEFINE_MARKER_TP(kernel, page_fault_nosem_exit, page_fault_nosem_exit,
- probe_kernel_page_fault_nosem_exit,
- MARK_NOARGS);
-
-notrace void probe_kernel_page_fault_nosem_exit(void *_data, int res)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(kernel, page_fault_nosem_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- NULL, 0, 0);
-}
-
-/* kernel_page_fault_get_user_entry specialized tracepoint probe */
-
-void probe_kernel_page_fault_get_user_entry(void *_data, struct mm_struct *mm,
- struct vm_area_struct *vma, unsigned long address, int write_access);
-
-DEFINE_MARKER_TP(kernel, page_fault_get_user_entry, page_fault_get_user_entry,
- probe_kernel_page_fault_get_user_entry,
- "address #p%lu write_access #1u%u");
-
-notrace void probe_kernel_page_fault_get_user_entry(void *_data, struct mm_struct *mm,
- struct vm_area_struct *vma, unsigned long address, int write_access)
-{
- struct marker *marker;
- struct serialize_long_char data;
-
- data.f1 = address;
- data.f2 = (unsigned char)!!write_access;
-
- marker = &GET_MARKER(kernel, page_fault_get_user_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_page_fault_get_user_exit specialized tracepoint probe */
-
-void probe_kernel_page_fault_get_user_exit(void *_data, int res);
-
-DEFINE_MARKER_TP(kernel, page_fault_get_user_exit, page_fault_get_user_exit,
- probe_kernel_page_fault_get_user_exit,
- "res %d");
-
-notrace void probe_kernel_page_fault_get_user_exit(void *_data, int res)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(kernel, page_fault_get_user_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &res, sizeof(res), sizeof(res));
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("kernel Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/lockdep-trace.c
- *
- * lockdep tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/lockdep.h>
-#include <trace/lockdep.h>
-
-void probe_lockdep_hardirqs_on(void *data, unsigned long retaddr)
-{
- trace_mark_tp(lockdep, hardirqs_on, lockdep_hardirqs_on,
- probe_lockdep_hardirqs_on, "retaddr 0x%lX", retaddr);
-}
-
-void probe_lockdep_hardirqs_off(void *data, unsigned long retaddr)
-{
- trace_mark_tp(lockdep, hardirqs_off, lockdep_hardirqs_off,
- probe_lockdep_hardirqs_off, "retaddr 0x%lX", retaddr);
-}
-
-void probe_lockdep_softirqs_on(void *data, unsigned long retaddr)
-{
- trace_mark_tp(lockdep, softirqs_on, lockdep_softirqs_on,
- probe_lockdep_softirqs_on, "retaddr 0x%lX", retaddr);
-}
-
-void probe_lockdep_softirqs_off(void *data, unsigned long retaddr)
-{
- trace_mark_tp(lockdep, softirqs_off, lockdep_softirqs_off,
- probe_lockdep_softirqs_off, "retaddr 0x%lX", retaddr);
-}
-
-void probe_lockdep_lock_acquire(void *data, unsigned long retaddr,
- unsigned int subclass, struct lockdep_map *lock, int trylock,
- int read, int hardirqs_off)
-{
- trace_mark_tp(lockdep, lock_acquire, lockdep_lock_acquire,
- probe_lockdep_lock_acquire,
- "retaddr 0x%lX subclass %u lock %p trylock %d read %d "
- "hardirqs_off %d",
- retaddr, subclass, lock, trylock, read, hardirqs_off);
-}
-
-void probe_lockdep_lock_release(void *data, unsigned long retaddr,
- struct lockdep_map *lock, int nested)
-{
- trace_mark_tp(lockdep, lock_release, lockdep_lock_release,
- probe_lockdep_lock_release,
- "retaddr 0x%lX lock %p nested %d",
- retaddr, lock, nested);
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("lockdep Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/mm-trace.c
- *
- * MM tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/mm.h>
-#include <linux/swap.h>
-
-#include <asm/pgtable.h>
-#include <asm/tlbflush.h>
-#include <linux/swapops.h>
-#include <trace/page_alloc.h>
-#include <trace/filemap.h>
-#include <trace/swap.h>
-#include <trace/hugetlb.h>
-
-#include "../ltt-type-serializer.h"
-
-void probe_wait_on_page_start(void *_data, struct page *page, int bit_nr)
-{
- trace_mark_tp(mm, wait_on_page_start, wait_on_page_start,
- probe_wait_on_page_start, "pfn %lu bit_nr %d",
- page_to_pfn(page), bit_nr);
-}
-
-void probe_wait_on_page_end(void *_data, struct page *page, int bit_nr)
-{
- trace_mark_tp(mm, wait_on_page_end, wait_on_page_end,
- probe_wait_on_page_end, "pfn %lu bit_nr %d",
- page_to_pfn(page), bit_nr);
-}
-
-void probe_hugetlb_page_free(void *_data, struct page *page)
-{
- trace_mark_tp(mm, huge_page_free, hugetlb_page_free,
- probe_hugetlb_page_free, "pfn %lu", page_to_pfn(page));
-}
-
-void probe_hugetlb_page_alloc(void *_data, struct page *page)
-{
- if (page)
- trace_mark_tp(mm, huge_page_alloc, hugetlb_page_alloc,
- probe_hugetlb_page_alloc, "pfn %lu", page_to_pfn(page));
-}
-
-/* mm_page_free specialized tracepoint probe */
-
-void probe_page_free(void *_data, struct page *page, unsigned int order);
-
-DEFINE_MARKER_TP(mm, page_free, page_free, probe_page_free,
- "pfn %lu order %u");
-
-notrace void probe_page_free(void *_data, struct page *page, unsigned int order)
-{
- struct marker *marker;
- struct serialize_long_int data;
-
- data.f1 = page_to_pfn(page);
- data.f2 = order;
-
- marker = &GET_MARKER(mm, page_free);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* mm_page_alloc specialized tracepoint probe */
-
-void probe_page_alloc(void *_data, struct page *page, unsigned int order);
-
-DEFINE_MARKER_TP(mm, page_alloc, page_alloc, probe_page_alloc,
- "pfn %lu order %u");
-
-notrace void probe_page_alloc(void *_data, struct page *page, unsigned int order)
-{
- struct marker *marker;
- struct serialize_long_int data;
-
- if (unlikely(!page))
- return;
-
- data.f1 = page_to_pfn(page);
- data.f2 = order;
-
- marker = &GET_MARKER(mm, page_alloc);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-#ifdef CONFIG_SWAP
-void probe_swap_in(void *_data, struct page *page, swp_entry_t entry)
-{
- trace_mark_tp(mm, swap_in, swap_in, probe_swap_in,
- "pfn %lu filp %p offset %lu",
- page_to_pfn(page),
- get_swap_info_struct(swp_type(entry))->swap_file,
- swp_offset(entry));
-}
-
-void probe_swap_out(void *_data, struct page *page)
-{
- trace_mark_tp(mm, swap_out, swap_out, probe_swap_out,
- "pfn %lu filp %p offset %lu",
- page_to_pfn(page),
- get_swap_info_struct(swp_type(
- page_swp_entry(page)))->swap_file,
- swp_offset(page_swp_entry(page)));
-}
-
-void probe_swap_file_close(void *_data, struct file *file)
-{
- trace_mark_tp(mm, swap_file_close, swap_file_close,
- probe_swap_file_close, "filp %p", file);
-}
-
-void probe_swap_file_open(void *_data, struct file *file, char *filename)
-{
- trace_mark_tp(mm, swap_file_open, swap_file_open,
- probe_swap_file_open, "filp %p filename %s",
- file, filename);
-}
-#endif
-
-void probe_add_to_page_cache(void *_data, struct address_space *mapping, pgoff_t offset)
-{
- trace_mark_tp(mm, add_to_page_cache, add_to_page_cache,
- probe_add_to_page_cache,
- "inode %lu sdev %u",
- mapping->host->i_ino, mapping->host->i_sb->s_dev);
-}
-
-void probe_remove_from_page_cache(void *_data, struct address_space *mapping)
-{
- trace_mark_tp(mm, remove_from_page_cache, remove_from_page_cache,
- probe_remove_from_page_cache,
- "inode %lu sdev %u",
- mapping->host->i_ino, mapping->host->i_sb->s_dev);
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("MM Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/net-extended-trace.c
- *
- * Net tracepoint extended probes.
- *
- * These probes record many header fields from TCP and UDP messages. Here are
- * the consequences of this:
- * 1) it allows analyzing network traffic to provide some pcap-like
- * functionality within LTTng
- * 2) it allows offline synchronization of a group of concurrent traces
- * recorded on different nodes
- * 3) it increases tracing overhead
- *
- * You can leave out these probes or not activate them if you are not
- * especially interested in the details of network traffic and do not wish to
- * synchronize distributed traces.
- *
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/in_route.h>
-#include <linux/ip.h>
-#include <linux/module.h>
-#include <linux/tcp.h>
-#include <linux/udp.h>
-#include <net/route.h>
-#include <trace/net.h>
-
-#include "../ltt-type-serializer.h"
-
-void probe_net_dev_xmit_extended(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, dev_xmit_extended, net_dev_xmit,
- probe_net_dev_xmit_extended, "skb 0x%lX network_protocol #n2u%hu "
- "transport_protocol #1u%u saddr #n4u%lu daddr #n4u%lu "
- "tot_len #n2u%hu ihl #1u%u source #n2u%hu dest #n2u%hu seq #n4u%lu "
- "ack_seq #n4u%lu doff #1u%u ack #1u%u rst #1u%u syn #1u%u fin #1u%u");
-
-notrace void probe_net_dev_xmit_extended(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
- struct serialize_l214421224411111 data;
- struct iphdr *iph = ip_hdr(skb);
- struct tcphdr *th = tcp_hdr(skb);
-
- data.f1 = (unsigned long)skb;
- data.f2 = skb->protocol;
-
- if (ntohs(skb->protocol) == ETH_P_IP) {
- data.f3 = ip_hdr(skb)->protocol;
- data.f4 = iph->saddr;
- data.f5 = iph->daddr;
- data.f6 = iph->tot_len;
- data.f7 = iph->ihl;
-
- if (data.f3 == IPPROTO_TCP) {
- data.f8 = th->source;
- data.f9 = th->dest;
- data.f10 = th->seq;
- data.f11 = th->ack_seq;
- data.f12 = th->doff;
- data.f13 = th->ack;
- data.f14 = th->rst;
- data.f15 = th->syn;
- data.f16 = th->fin;
- }
- }
-
- marker = &GET_MARKER(net, dev_xmit_extended);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_tcpv4_rcv_extended(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, tcpv4_rcv_extended, net_tcpv4_rcv,
- probe_tcpv4_rcv_extended, "skb 0x%lX saddr #n4u%lu daddr #n4u%lu "
- "tot_len #n2u%hu ihl #1u%u source #n2u%hu dest #n2u%hu seq #n4u%lu "
- "ack_seq #n4u%lu doff #1u%u ack #1u%u rst #1u%u syn #1u%u fin #1u%u");
-
-notrace void probe_tcpv4_rcv_extended(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
- struct serialize_l4421224411111 data;
- struct iphdr *iph = ip_hdr(skb);
- struct tcphdr *th = tcp_hdr(skb);
-
- data.f1 = (unsigned long)skb;
- data.f2 = iph->saddr;
- data.f3 = iph->daddr;
- data.f4 = iph->tot_len;
- data.f5 = iph->ihl;
- data.f6 = th->source;
- data.f7 = th->dest;
- data.f8 = th->seq;
- data.f9 = th->ack_seq;
- data.f10 = th->doff;
- data.f11 = th->ack;
- data.f12 = th->rst;
- data.f13 = th->syn;
- data.f14 = th->fin;
-
- marker = &GET_MARKER(net, tcpv4_rcv_extended);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_udpv4_rcv_extended(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, udpv4_rcv_extended, net_udpv4_rcv,
- probe_udpv4_rcv_extended, "skb 0x%lX saddr #n4u%lu daddr #n4u%lu "
- "unicast #1u%u ulen #n2u%hu source #n2u%hu dest #n2u%hu "
- "data_start #8u%lx");
-
-notrace void probe_udpv4_rcv_extended(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
- struct serialize_l4412228 data;
- struct iphdr *iph = ip_hdr(skb);
- struct rtable *rt = skb_rtable(skb);
- struct udphdr *uh = udp_hdr(skb);
-
- data.f1 = (unsigned long)skb;
- data.f2 = iph->saddr;
- data.f3 = iph->daddr;
- data.f4 = rt->rt_flags & (RTCF_BROADCAST | RTCF_MULTICAST) ? 0 : 1;
- data.f5 = uh->len;
- data.f6 = uh->source;
- data.f7 = uh->dest;
- /* UDP header has not been pulled from skb->data, read the first 8
- * bytes of UDP data if they are not in a fragment*/
- data.f8 = 0;
- if (skb_headlen(skb) >= sizeof(struct udphdr) + 8)
- data.f8 = *(unsigned long long *)(skb->data + sizeof(*uh));
- else if (skb_headlen(skb) >= sizeof(struct udphdr))
- memcpy(&data.f8, skb->data + sizeof(struct udphdr),
- skb_headlen(skb) - sizeof(struct udphdr));
-
- marker = &GET_MARKER(net, udpv4_rcv_extended);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(unsigned long long));
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Benjamin Poirier");
-MODULE_DESCRIPTION("Net Tracepoint Extended Probes");
+++ /dev/null
-/*
- * ltt/probes/net-trace.c
- *
- * Net tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <linux/netdevice.h>
-#include <linux/string.h>
-#include <trace/net.h>
-#include <trace/ipv4.h>
-#include <trace/ipv6.h>
-#include <trace/socket.h>
-
-#include "../ltt-type-serializer.h"
-
-void probe_net_dev_xmit(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, dev_xmit, net_dev_xmit, probe_net_dev_xmit,
- "skb %p protocol #n2u%hu");
-
-notrace void probe_net_dev_xmit(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
- struct serialize_long_short data;
-
- data.f1 = (unsigned long)skb;
- data.f2 = skb->protocol;
-
- marker = &GET_MARKER(net, dev_xmit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_net_dev_receive(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, dev_receive, net_dev_receive, probe_net_dev_receive,
- "skb %p protocol #n2u%hu");
-
-notrace void probe_net_dev_receive(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
- struct serialize_long_short data;
-
- data.f1 = (unsigned long)skb;
- data.f2 = skb->protocol;
-
- marker = &GET_MARKER(net, dev_receive);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-void probe_ipv4_addr_add(void *_data, struct in_ifaddr *ifa)
-{
- trace_mark_tp(netif_state, insert_ifa_ipv4, ipv4_addr_add,
- probe_ipv4_addr_add, "label %s address #4u%u",
- ifa->ifa_label, (unsigned int)ifa->ifa_address);
-}
-
-void probe_ipv4_addr_del(void *_data, struct in_ifaddr *ifa)
-{
- trace_mark_tp(netif_state, del_ifa_ipv4, ipv4_addr_del,
- probe_ipv4_addr_del, "label %s address #4u%u",
- ifa->ifa_label, (unsigned int)ifa->ifa_address);
-}
-
-void probe_ipv6_addr_add(void *_data, struct inet6_ifaddr *ifa)
-{
- __u8 *addr = ifa->addr.s6_addr;
-
- trace_mark_tp(netif_state, insert_ifa_ipv6, ipv6_addr_add,
- probe_ipv6_addr_add,
- "label %s "
- "a15 #1x%c a14 #1x%c a13 #1x%c a12 #1x%c "
- "a11 #1x%c a10 #1x%c a9 #1x%c a8 #1x%c "
- "a7 #1x%c a6 #1x%c a5 #1x%c a4 #1x%c "
- "a3 #1x%c a2 #1x%c a1 #1x%c a0 #1x%c",
- ifa->idev->dev->name,
- addr[15], addr[14], addr[13], addr[12],
- addr[11], addr[10], addr[9], addr[8],
- addr[7], addr[6], addr[5], addr[4],
- addr[3], addr[2], addr[1], addr[0]);
-}
-
-void probe_ipv6_addr_del(void *_data, struct inet6_ifaddr *ifa)
-{
- __u8 *addr = ifa->addr.s6_addr;
-
- trace_mark_tp(netif_state, insert_ifa_ipv6, ipv6_addr_del,
- probe_ipv6_addr_del,
- "label %s "
- "a15 #1x%c a14 #1x%c a13 #1x%c a12 #1x%c "
- "a11 #1x%c a10 #1x%c a9 #1x%c a8 #1x%c "
- "a7 #1x%c a6 #1x%c a5 #1x%c a4 #1x%c "
- "a3 #1x%c a2 #1x%c a1 #1x%c a0 #1x%c",
- ifa->idev->dev->name,
- addr[15], addr[14], addr[13], addr[12],
- addr[11], addr[10], addr[9], addr[8],
- addr[7], addr[6], addr[5], addr[4],
- addr[3], addr[2], addr[1], addr[0]);
-}
-
-void probe_socket_create(void *_data, int family, int type, int protocol,
- struct socket *sock, int ret)
-{
- trace_mark_tp(net, socket_create, socket_create, probe_socket_create,
- "family %d type %d protocol %d sock %p ret %d",
- family, type, protocol, sock, ret);
-}
-
-void probe_socket_bind(void *_data, int fd, struct sockaddr __user *umyaddr, int addrlen,
- int ret)
-{
- trace_mark_tp(net, socket_bind, socket_bind, probe_socket_bind,
- "fd %d umyaddr %p addrlen %d ret %d",
- fd, umyaddr, addrlen, ret);
-}
-
-void probe_socket_connect(void *_data, int fd, struct sockaddr __user *uservaddr,
- int addrlen, int ret)
-{
- trace_mark_tp(net, socket_connect, socket_connect, probe_socket_connect,
- "fd %d uservaddr %p addrlen %d ret %d",
- fd, uservaddr, addrlen, ret);
-}
-
-void probe_socket_listen(void *_data, int fd, int backlog, int ret)
-{
- trace_mark_tp(net, socket_listen, socket_listen, probe_socket_listen,
- "fd %d backlog %d ret %d",
- fd, backlog, ret);
-}
-
-void probe_socket_accept(void *_data, int fd, struct sockaddr __user *upeer_sockaddr,
- int __user *upeer_addrlen, int flags, int ret)
-{
- trace_mark_tp(net, socket_accept, socket_accept, probe_socket_accept,
- "fd %d upeer_sockaddr %p upeer_addrlen %p flags %d ret %d",
- fd, upeer_sockaddr, upeer_addrlen, flags, ret);
-}
-
-void probe_socket_getsockname(void *_data, int fd, struct sockaddr __user *usockaddr,
- int __user *usockaddr_len, int ret)
-{
- trace_mark_tp(net, socket_getsockname, socket_getsockname,
- probe_socket_getsockname,
- "fd %d usockaddr %p usockaddr_len %p ret %d",
- fd, usockaddr, usockaddr_len, ret);
-}
-
-void probe_socket_getpeername(void *_data, int fd, struct sockaddr __user *usockaddr,
- int __user *usockaddr_len, int ret)
-{
- trace_mark_tp(net, socket_getpeername, socket_getpeername,
- probe_socket_getpeername,
- "fd %d usockaddr %p usockaddr_len %p ret %d",
- fd, usockaddr, usockaddr_len, ret);
-}
-
-void probe_socket_socketpair(void *_data, int family, int type, int protocol,
- int __user *usockvec, int ret)
-{
- trace_mark_tp(net, socket_socketpair, socket_socketpair,
- probe_socket_socketpair,
- "family %d type %d protocol %d usockvec %p ret %d",
- family, type, protocol, usockvec, ret);
-}
-
-void probe_socket_sendmsg(void *_data, struct socket *sock, struct msghdr *msg, size_t size,
- int ret);
-
-DEFINE_MARKER_TP(net, socket_sendmsg, net_socket_sendmsg,
- probe_socket_sendmsg,
- "sock %p msg %p size %zu ret %d");
-
-notrace void probe_socket_sendmsg(void *_data, struct socket *sock, struct msghdr *msg,
- size_t size, int ret)
-{
- struct marker *marker;
- struct serialize_long_long_sizet_int data;
-
- data.f1 = (unsigned long)sock;
- data.f2 = (unsigned long)msg;
- data.f3 = size;
- data.f4 = ret;
-
- marker = &GET_MARKER(net, socket_sendmsg);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(size_t));
-}
-
-void probe_socket_recvmsg(void *_data, struct socket *sock, struct msghdr *msg, size_t size,
- int flags, int ret);
-
-DEFINE_MARKER_TP(net, socket_recvmsg, net_socket_recvmsg,
- probe_socket_recvmsg,
- "sock %p msg %p size %zu flags %d ret %d");
-
-notrace void probe_socket_recvmsg(void *_data, struct socket *sock, struct msghdr *msg,
- size_t size, int flags, int ret)
-{
- struct marker *marker;
- struct serialize_long_long_sizet_int_int data;
-
- data.f1 = (unsigned long)sock;
- data.f2 = (unsigned long)msg;
- data.f3 = size;
- data.f4 = flags;
- data.f5 = ret;
-
- marker = &GET_MARKER(net, socket_recvmsg);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(size_t));
-}
-
-void probe_socket_setsockopt(void *_data, int fd, int level, int optname,
- char __user *optval, int optlen, int ret)
-{
- trace_mark_tp(net, socket_setsockopt, socket_setsockopt,
- probe_socket_setsockopt,
- "fd %d level %d optname %d optval %p optlen %d ret %d",
- fd, level, optname, optval, optlen, ret);
-}
-
-void probe_socket_getsockopt(void *_data, int fd, int level, int optname,
- char __user *optval, int __user *optlen, int ret)
-{
- trace_mark_tp(net, socket_getsockopt, socket_getsockopt,
- probe_socket_getsockopt,
- "fd %d level %d optname %d optval %p optlen %p ret %d",
- fd, level, optname, optval, optlen, ret);
-}
-
-void probe_socket_shutdown(void *_data, int fd, int how, int ret)
-{
- trace_mark_tp(net, socket_shutdown, socket_shutdown,
- probe_socket_shutdown,
- "fd %d how %d ret %d",
- fd, how, ret);
-}
-
-void probe_socket_call(void *_data, int call, unsigned long a0)
-{
- trace_mark_tp(net, socket_call, socket_call, probe_socket_call,
- "call %d a0 %lu", call, a0);
-}
-
-void probe_tcpv4_rcv(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, tcpv4_rcv, net_tcpv4_rcv, probe_tcpv4_rcv,
- "skb %p");
-
-notrace void probe_tcpv4_rcv(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(net, tcpv4_rcv);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &skb, sizeof(skb), sizeof(skb));
-}
-
-void probe_udpv4_rcv(void *_data, struct sk_buff *skb);
-
-DEFINE_MARKER_TP(net, udpv4_rcv, net_udpv4_rcv, probe_udpv4_rcv,
- "skb %p");
-
-notrace void probe_udpv4_rcv(void *_data, struct sk_buff *skb)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(net, udpv4_rcv);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &skb, sizeof(skb), sizeof(skb));
-}
-
-#ifdef CONFIG_NETPOLL
-void probe_net_napi_schedule(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_schedule, net_napi_schedule,
- probe_net_napi_schedule,
- "napi_struct %p name %s");
-
-notrace void probe_net_napi_schedule(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- struct serialize_long_ifname data;
- size_t data_len = 0;
-
- data.f1 = (unsigned long)n;
- data_len += sizeof(data.f1);
- /* No need to align for strings */
- strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
- data_len += strlen(data.f2) + 1;
-
- marker = &GET_MARKER(net, napi_schedule);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, data_len, sizeof(long));
-}
-
-void probe_net_napi_poll(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_poll, net_napi_poll,
- probe_net_napi_poll,
- "napi_struct %p name %s");
-
-notrace void probe_net_napi_poll(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- struct serialize_long_ifname data;
- size_t data_len = 0;
-
- data.f1 = (unsigned long)n;
- data_len += sizeof(data.f1);
- /* No need to align for strings */
- strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
- data_len += strlen(data.f2) + 1;
-
- marker = &GET_MARKER(net, napi_poll);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, data_len, sizeof(long));
-}
-
-void probe_net_napi_complete(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_complete, net_napi_complete,
- probe_net_napi_complete,
- "napi_struct %p name %s");
-
-notrace void probe_net_napi_complete(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- struct serialize_long_ifname data;
- size_t data_len = 0;
-
- data.f1 = (unsigned long)n;
- data_len += sizeof(data.f1);
- /* No need to align for strings */
- strcpy(data.f2, n->dev ? n->dev->name : "<unk>");
- data_len += strlen(data.f2) + 1;
-
- marker = &GET_MARKER(net, napi_complete);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, data_len, sizeof(long));
-}
-#else /* !CONFIG_NETPOLL */
-void probe_net_napi_schedule(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_schedule, net_napi_schedule,
- probe_net_napi_schedule,
- "napi_struct %p");
-
-notrace void probe_net_napi_schedule(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- unsigned long data;
-
- data = (unsigned long)n;
-
- marker = &GET_MARKER(net, napi_schedule);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-void probe_net_napi_poll(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_poll, net_napi_poll,
- probe_net_napi_poll,
- "napi_struct %p");
-
-notrace void probe_net_napi_poll(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- unsigned long data;
-
- data = (unsigned long)n;
-
- marker = &GET_MARKER(net, napi_poll);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-
-void probe_net_napi_complete(void *_data, struct napi_struct *n);
-
-DEFINE_MARKER_TP(net, napi_complete, net_napi_complete,
- probe_net_napi_complete,
- "napi_struct %p");
-
-notrace void probe_net_napi_complete(void *_data, struct napi_struct *n)
-{
- struct marker *marker;
- unsigned long data;
-
- data = (unsigned long)n;
-
- marker = &GET_MARKER(net, napi_complete);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, sizeof(data), sizeof(data));
-}
-#endif
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Net Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/pm-trace.c
- *
- * Power Management tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <trace/pm.h>
-
-void probe_pm_idle_entry(void *_data)
-{
- trace_mark_tp(pm, idle_entry, pm_idle_entry,
- probe_pm_idle_entry, "irqstate #1%d",
- irqs_disabled());
-}
-
-void probe_pm_idle_exit(void *_data)
-{
- trace_mark_tp(pm, idle_exit, pm_idle_exit,
- probe_pm_idle_exit, "irqstate #1%d",
- irqs_disabled());
-}
-
-void probe_pm_suspend_entry(void *_data)
-{
- trace_mark_tp(pm, suspend_entry, pm_suspend_entry,
- probe_pm_suspend_entry, "irqstate #1%d",
- irqs_disabled());
-}
-
-void probe_pm_suspend_exit(void *_data)
-{
- trace_mark_tp(pm, suspend_exit, pm_suspend_exit,
- probe_pm_suspend_exit, "irqstate #1%d",
- irqs_disabled());
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Power Management Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/rcu-trace.c
- *
- * RCU tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <trace/rcu.h>
-
-#ifdef CONFIG_TREE_RCU
-void probe_rcu_tree_callback(void *data, struct rcu_head *head)
-{
- trace_mark_tp(rcu, tree_callback, rcu_tree_callback,
- probe_rcu_tree_callback, "func %p", head->func);
-}
-
-void probe_rcu_tree_call_rcu(void *data, struct rcu_head *head, unsigned long ip)
-{
- trace_mark_tp(rcu, tree_call_rcu, rcu_tree_call_rcu,
- probe_rcu_tree_call_rcu, "func %p ip 0x%lX", head->func, ip);
-}
-
-void probe_rcu_tree_call_rcu_bh(void *data, struct rcu_head *head, unsigned long ip)
-{
- trace_mark_tp(rcu, tree_call_rcu_bh, rcu_tree_call_rcu_bh,
- probe_rcu_tree_call_rcu_bh, "func %p ip 0x%lX",
- head->func, ip);
-}
-#endif
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("RCU Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/syscall-trace.c
- *
- * System call tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <trace/syscall.h>
-
-#include "../ltt-type-serializer.h"
-
-
-/* kernel_syscall_entry specialized tracepoint probe */
-
-void probe_syscall_entry(void *_data, struct pt_regs *regs, long id);
-
-DEFINE_MARKER_TP(kernel, syscall_entry, syscall_entry,
- probe_syscall_entry, "ip #p%ld syscall_id #2u%u");
-
-notrace void probe_syscall_entry(void *_data, struct pt_regs *regs, long id)
-{
- struct marker *marker;
- struct serialize_long_short data;
-
- data.f1 = instruction_pointer(regs);
- data.f2 = (unsigned short)id;
-
- marker = &GET_MARKER(kernel, syscall_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_syscall_exit specialized tracepoint probe */
-
-void probe_syscall_exit(void *_data, long ret);
-
-DEFINE_MARKER_TP(kernel, syscall_exit, syscall_exit,
- probe_syscall_exit, "ret %ld");
-
-notrace void probe_syscall_exit(void *_data, long ret)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(kernel, syscall_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &ret, sizeof(ret), sizeof(ret));
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("syscall Tracepoint Probes");
+++ /dev/null
-/*
- * ltt/probes/trap-trace.c
- *
- * Trap tracepoint probes.
- *
- * (C) Copyright 2009 - Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
- * Dual LGPL v2.1/GPL v2 license.
- */
-
-#include <linux/module.h>
-#include <trace/trap.h>
-
-#include "../ltt-type-serializer.h"
-
-/* kernel_trap_entry specialized tracepoint probe */
-
-void probe_trap_entry(void *_data, struct pt_regs *regs, long id);
-
-DEFINE_MARKER_TP(kernel, trap_entry, trap_entry,
- probe_trap_entry, "ip #p%ld trap_id #2u%u");
-
-notrace void probe_trap_entry(void *_data, struct pt_regs *regs, long id)
-{
- struct marker *marker;
- struct serialize_long_short data;
-
- if (likely(regs))
- data.f1 = instruction_pointer(regs);
- else
- data.f1 = 0UL;
- data.f2 = (unsigned short)id;
-
- marker = &GET_MARKER(kernel, trap_entry);
- ltt_specialized_trace(marker, marker->single.probe_private,
- &data, serialize_sizeof(data), sizeof(long));
-}
-
-/* kernel_syscall_exit specialized tracepoint probe */
-
-void probe_trap_exit(void *_data);
-
-DEFINE_MARKER_TP(kernel, trap_exit, trap_exit,
- probe_trap_exit, MARK_NOARGS);
-
-notrace void probe_trap_exit(void *_data)
-{
- struct marker *marker;
-
- marker = &GET_MARKER(kernel, trap_exit);
- ltt_specialized_trace(marker, marker->single.probe_private,
- NULL, 0, 0);
-}
-
-MODULE_LICENSE("GPL and additional rights");
-MODULE_AUTHOR("Mathieu Desnoyers");
-MODULE_DESCRIPTION("Trap Tracepoint Probes");
projects / lttng-modules.git / commitdiff
