[lttng-modules.git] / ltt-ascii.c

/*
 * 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, &ltt_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 (ACCESS_ONCE(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");
Commit	Line	Data
1c8284eb MD	1	/*
	2	* LTT ascii binary buffer to ascii converter.
	3	*
	4	* Copyright 2008 - 2009 Lai Jiangshan (laijs@cn.fujitsu.com)
	5	* Copyright 2009 - Mathieu Desnoyers mathieu.desnoyers@polymtl.ca
	6	*
	7	* Dual LGPL v2.1/GPL v2 license.
	8	*/
	9
	10	/*
	11	* TODO
	12	*
	13	* Move to new switch behavior: Wait for data for the duration of the
	14	* timer interval + safety, if none is coming, consider that no activity occured
	15	* in the buffer.
	16	*
	17	* Fix case when having a text file open and destroying trace.
	18	*
	19	* - Automate periodical switch:
	20	*
	21	* The debugfs file "switch_timer" receives a timer period as parameter
	22	* (e.g. echo 100 > switch_timer) to activate the timer per channel. This can
	23	* also be accessed through the internal API _before the trace session starts_.
	24	* This timer will insure that we periodically have subbuffers to read, and
	25	* therefore that the merge-sort does not wait endlessly for a subbuffer.
	26	*
	27	* - If a channel is switched and read without data, make sure it is still
	28	* considered afterward (not removed from the queue).
	29	*
	30	* - Create a ascii/tracename/ALL file to merge-sort all active channels.
	31	* - Create a ascii/tracename/README file to contain the text output legend.
	32	* - Remove leading zeroes from timestamps.
	33	* - Enhance pretty-printing to make sure all types used for addesses output in
	34	* the form 0xAB00000000 (not decimal). This is true for %p and 0x%...X.
	35	* - Hotplug support
	36	*/
	37
	38
	39
	40
	41	#include <linux/module.h>
	42	#include <linux/seq_file.h>
	43	#include <linux/debugfs.h>
	44	#include <linux/module.h>
	45	#include <linux/string.h>
	46	#include <linux/delay.h>
	47	#include <linux/slab.h>
	48	#include <linux/cpu.h>
	49	#include <linux/fs.h>
	50
	51	#include "ltt-tracer.h"
	52	#include "ltt-relay.h"
	53	#include "ltt-relay-lockless.h"
	54
	55	#if 0
	56	#define DEBUGP printk
	57	#else
	58	#define DEBUGP(fmt , a...)
	59	#endif
	60
	61	struct dentry *ltt_ascii_dir_dentry;
	62	EXPORT_SYMBOL_GPL(ltt_ascii_dir_dentry);
	63
	64	struct ltt_relay_iter;
65
66	struct ltt_relay_cpu_iter {
67	/* cpu buffer information */
68	struct ltt_chanbuf *buf;
69	struct ltt_relay_iter *iter;
70	int sb_ref; /* holding a reference to a subbuffer */
71	long read_sb_offset; /* offset of the subbuffer read */
72
73	/* current event information */
74	struct ltt_subbuffer_header *header;
75	long hdr_offset; /* event header offset */
76	long payload_offset; /* event payload offset */
77	u64 tsc; /* full 64-bits timestamp value */
78	u32 data_size;
79	u16 chID; /* channel ID, const */
80	u16 eID;
81	};
82
83	struct ltt_relay_iter {
84	struct ltt_relay_cpu_iter iter_cpu[NR_CPUS];
85	struct ltt_chan *chan;
86	loff_t pos;
87	int cpu;
88	int nr_refs;
89	};
90
91	/*
92	* offset of 0 in subbuffer means "subbuf size" (filled subbuffer).
93	*/
94	static int is_subbuffer_offset_end(struct ltt_relay_cpu_iter *citer,
95	long offset)
96	{
97	struct ltt_chan *chan = container_of(citer->buf->a.chan,
98	struct ltt_chan, a);
99	long sub_offset = SUBBUF_OFFSET(offset - 1, chan) + 1;
100
101	return (sub_offset <= citer->header->data_size);
102	}
103
104	static u64 calculate_tsc(u64 pre_tsc, u64 read_tsc, unsigned int rflags)
105	{
106	u64 new_tsc = read_tsc;
107
108	if (rflags != LTT_RFLAG_ID_SIZE_TSC) {
109	BUG_ON(read_tsc >> LTT_TSC_BITS);
110
111	new_tsc = (pre_tsc & ~LTT_TSC_MASK) + read_tsc;
112	if (read_tsc < (pre_tsc & LTT_TSC_MASK))
113	new_tsc += 1UL << LTT_TSC_BITS;
114	}
115
116	return new_tsc;
117	}
118
119	/*
120	* calculate payload offset */
121	static inline long calculate_payload_offset(long offset, u16 chID, u16 eID)
122	{
123	const char *fmt;
124
125	if (!ltt_get_alignment())
126	return offset;
127
128	fmt = marker_get_fmt_from_id(chID, eID);
129	BUG_ON(!fmt);
130
131	return offset + ltt_fmt_largest_align(offset, fmt);
132	}
133
134	static void update_new_event(struct ltt_relay_cpu_iter *citer, long hdr_offset)
135	{
136	u64 read_tsc;
137	unsigned int rflags;
138	long tmp_offset;
139
140	WARN_ON_ONCE(hdr_offset != citer->hdr_offset);
141
142	tmp_offset = ltt_read_event_header(&citer->buf->a, hdr_offset,
143	&read_tsc, &citer->data_size,
144	&citer->eID, &rflags);
145	citer->payload_offset = calculate_payload_offset(tmp_offset,
146	citer->chID,
147	citer->eID);
148
149	citer->tsc = calculate_tsc(citer->tsc, read_tsc, rflags);
150	}
151
152	static void update_event_size(struct ltt_relay_cpu_iter *citer, long hdr_offset)
153	{
154	char output[1];
155	const char *fmt;
156	size_t data_size;
157
158	if (citer->data_size != INT_MAX)
159	return;
160
161	fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
162	BUG_ON(!fmt);
163	ltt_serialize_printf(citer->buf, citer->payload_offset,
164	&data_size, output, 0, fmt);
165	citer->data_size = data_size;
166	}
167
168	static void update_cpu_iter(struct ltt_relay_cpu_iter *citer, long hdr_offset)
169	{
170	if (unlikely((!citer->sb_ref)
171	\|\| is_subbuffer_offset_end(citer, hdr_offset))) {
172	citer->header = NULL;
173	return;
174	}
175	update_new_event(citer, hdr_offset);
176	update_event_size(citer, hdr_offset);
177	}
178
179	/*
180	* returns 0 if we get a subbuffer reference.
181	* else, the buffer has not available data, try again later.
182	*/
183	static int subbuffer_start(struct ltt_relay_cpu_iter citer, long offset)
184	{
185	int ret;
186	struct ltt_relay_iter *iter = citer->iter;
187
188	ret = ltt_chanbuf_get_subbuf(citer->buf, offset);
189	if (!ret) {
190	citer->header = ltt_relay_read_offset_address(&citer->buf->a,
191	*offset);
192	citer->hdr_offset = (*offset) + ltt_sb_header_size();
193	citer->tsc = citer->header->cycle_count_begin;
194	iter->nr_refs++;
195	citer->sb_ref = 1;
196	return 0;
197	} else {
198	if (ltt_chanbuf_is_finalized(citer->buf))
199	return -ENODATA;
200	else
201	return -EAGAIN;
202	}
203	}
204
205	static void subbuffer_stop(struct ltt_relay_cpu_iter *citer,
206	long offset)
207	{
208	int ret;
209	struct ltt_relay_iter *iter = citer->iter;
210
211	WARN_ON_ONCE(!citer->sb_ref);
212	ret = ltt_chanbuf_put_subbuf(citer->buf, offset);
213	WARN_ON_ONCE(ret);
214	citer->sb_ref = 0;
215	iter->nr_refs--;
216	}
217
218	static void ltt_relay_advance_cpu_iter(struct ltt_relay_cpu_iter *citer)
219	{
220	long old_offset = citer->payload_offset;
221	long new_offset = citer->payload_offset;
222	int ret;
223
224	/* find that whether we read all data in this subbuffer */
225	if (unlikely(is_subbuffer_offset_end(citer,
226	old_offset + citer->data_size))) {
227	DEBUGP(KERN_DEBUG "LTT ASCII stop cpu %d offset %lX\n",
228	citer->buf->a.cpu, citer->read_sb_offset);
229	subbuffer_stop(citer, citer->read_sb_offset);
230	for (;;) {
231	ret = subbuffer_start(citer, &citer->read_sb_offset);
232	DEBUGP(KERN_DEBUG
233	"LTT ASCII start cpu %d ret %d offset %lX\n",
234	citer->buf->a.cpu, ret, citer->read_sb_offset);
235	if (!ret \|\| ret == -ENODATA) {
236	break; /* got data, or finalized */
237	} else { /* -EAGAIN */
238	if (signal_pending(current))
239	break;
240	schedule_timeout_interruptible(1);
241	//TODO: check for no-data delay. take ref. break
242	}
243	}
244	} else {
245	new_offset += citer->data_size;
246	citer->hdr_offset = new_offset + ltt_align(new_offset, sizeof(struct ltt_event_header));
247	DEBUGP(KERN_DEBUG
248	"LTT ASCII old_offset %lX new_offset %lX cpu %d\n",
249	old_offset, new_offset, citer->buf->a.cpu);
250	}
251
252	update_cpu_iter(citer, citer->hdr_offset);
253	}
254
255	static int cpu_iter_eof(struct ltt_relay_cpu_iter *citer)
256	{
257	return !citer->sb_ref;
258	}
259
260	static int ltt_relay_iter_eof(struct ltt_relay_iter *iter)
261	{
262	return iter->nr_refs == 0;
263	}
264
265	static void ltt_relay_advance_iter(struct ltt_relay_iter *iter)
266	{
267	int i;
268	struct ltt_relay_cpu_iter curr, min = NULL;
269	iter->cpu = -1;
270
271	/*
272	* find the event with the minimum tsc.
273	* TODO: use min-heep for 4096CPUS
274	*/
275	for_each_possible_cpu(i) {
276	curr = &iter->iter_cpu[i];
277
278	if (!curr->buf->a.allocated \|\| !curr->header)
279	continue;
280
281	if (cpu_iter_eof(curr))
282	continue;
283
284	if (!min \|\| curr->tsc < min->tsc) {
285	min = curr;
286	iter->cpu = i;
287	}
288	}
289
290	/* update cpu_iter for next ltt_relay_advance_iter() */
291	if (min)
292	ltt_relay_advance_cpu_iter(min);
293	}
294
295	static void ascii_next(struct seq_file m, void v, loff_t ppos)
296	{
297	struct ltt_relay_iter *iter = m->private;
298
299	WARN_ON_ONCE(!iter->nr_refs);
300	BUG_ON(v != iter);
301
302	ltt_relay_advance_iter(iter);
303	return (ltt_relay_iter_eof(iter) \|\| signal_pending(current))
304	? NULL : iter;
305	}
306
307	static void ascii_start(struct seq_file m, loff_t *ppos)
308	{
309	struct ltt_relay_iter *iter = m->private;
310
311	ltt_relay_advance_iter(iter);
312	return (ltt_relay_iter_eof(iter) \|\| signal_pending(current))
313	? NULL : iter;
314	}
315
316	static void ascii_stop(struct seq_file m, void v)
317	{
318	}
319
320	static
321	int seq_serialize(struct seq_file m, struct ltt_chanbuf buf,
322	size_t buf_offset, const char fmt, size_t data_size)
323	{
324	int len;
325
326	if (m->count < m->size) {
327	len = ltt_serialize_printf(buf, buf_offset, data_size,
328	m->buf + m->count,
329	m->size - m->count, fmt);
330	if (m->count + len < m->size) {
331	m->count += len;
332	return 0;
333	}
334	}
335
336	m->count = m->size;
337	return -1;
338	}
339
340	static int ascii_show(struct seq_file m, void v)
341	{
342	struct ltt_relay_iter *iter = v;
343	struct ltt_relay_cpu_iter *citer;
344	const char *name;
345	const char *fmt;
346	unsigned long long tsc;
347	size_t data_size;
348
349	if (iter->cpu == -1)
350	return 0;
351
352	citer = &iter->iter_cpu[iter->cpu];
353	WARN_ON_ONCE(!citer->sb_ref);
354	/*
355	* Nothing to show, we are at the end of the last subbuffer currently
356	* having data.
357	*/
358	if (!citer->header)
359	return 0;
360
361	tsc = citer->tsc;
362	name = marker_get_name_from_id(citer->chID, citer->eID);
363	fmt = marker_get_fmt_from_id(citer->chID, citer->eID);
364
365	if (!name \|\| !fmt)
366	return 0;
367
368	seq_printf(m, "event:%16.16s: cpu:%2d time:%20.20llu ",
369	name, iter->cpu, tsc);
370	seq_serialize(m, citer->buf, citer->payload_offset, fmt, &data_size);
371	seq_puts(m, "\n");
372	if (citer->data_size == INT_MAX)
373	citer->data_size = data_size;
374
375	return 0;
376	}
377
378	static struct seq_operations ascii_seq_ops = {
379	.start = ascii_start,
380	.next = ascii_next,
381	.stop = ascii_stop,
382	.show = ascii_show,
383	};
384
385	/* FIXME : cpu hotplug support */
386	static int ltt_relay_iter_open_channel(struct ltt_relay_iter *iter,
387	struct ltt_chan *chan)
388	{
389	int i, ret;
390	u16 chID = ltt_channels_get_index_from_name(chan->a.filename);
391
392	/* we don't need lock relay_channels_mutex */
393	for_each_possible_cpu(i) {
394	struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
395
396	citer->buf = per_cpu_ptr(chan->a.buf, i);
397	if (!citer->buf->a.allocated)
398	continue;
399
400	citer->iter = iter; /* easy lazy parent info */
401	citer->chID = chID;
402
403	ret = ltt_chanbuf_open_read(citer->buf);
404	if (ret) {
405	/* Failed to open a percpu buffer, close everything. */
406	citer->buf = NULL;
407	goto error;
408	}
409
410	for (;;) {
411	ret = subbuffer_start(citer,
412	&citer->read_sb_offset);
413	DEBUGP(KERN_DEBUG
414	"LTT ASCII open start "
415	"cpu %d ret %d offset %lX\n",
416	citer->buf->a.cpu, ret, citer->read_sb_offset);
417	if (!ret \|\| ret == -ENODATA) {
418	break; /* got data, or finalized */
419	} else { /* -EAGAIN */
420	if (signal_pending(current))
421	break;
422	schedule_timeout_interruptible(1);
423	}
424	}
425	update_cpu_iter(citer, citer->hdr_offset);
426	}
427	if (!iter->nr_refs) {
428	ret = -ENODATA;
429	goto error;
430	}
431
432	return 0;
433
434	error:
435	for_each_possible_cpu(i) {
436	struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
437
438	if (!citer->buf)
439	break;
440
441	if (citer->buf->a.allocated)
442	ltt_chanbuf_release_read(citer->buf);
443	}
444	return ret;
445	}
446
447	/* FIXME : cpu hotplug support */
448	static int ltt_relay_iter_release_channel(struct ltt_relay_iter *iter)
449	{
450	int i;
451
452	for_each_possible_cpu(i) {
453	struct ltt_relay_cpu_iter *citer = &iter->iter_cpu[i];
454
455	if (citer->sb_ref) {
456	WARN_ON_ONCE(!citer->buf->a.allocated);
457	DEBUGP(KERN_DEBUG
458	"LTT ASCII release stop cpu %d offset %lX\n",
459	citer->buf->a.cpu, citer->read_sb_offset);
460	subbuffer_stop(&iter->iter_cpu[i],
461	citer->read_sb_offset);
462	}
463	if (citer->buf->a.allocated)
464	ltt_chanbuf_release_read(citer->buf);
465	}
466	WARN_ON_ONCE(iter->nr_refs);
467	return 0;
468	}
469
470	static int ltt_relay_ascii_open(struct inode inode, struct file file)
471	{
472	int ret;
473	struct ltt_chan *chan = inode->i_private;
474	struct ltt_relay_iter iter = kzalloc(sizeof(iter), GFP_KERNEL);
475	if (!iter)
476	return -ENOMEM;
477
478	iter->chan = chan;
479	ret = ltt_relay_iter_open_channel(iter, chan);
480	if (ret)
481	goto error_free_alloc;
482
483	ret = seq_open(file, &ascii_seq_ops);
484	if (ret)
485	goto error_release_channel;
486	((struct seq_file *)file->private_data)->private = iter;
487	return 0;
488
489	error_release_channel:
490	ltt_relay_iter_release_channel(iter);
491	error_free_alloc:
492	kfree(iter);
493	return ret;
494	}
495
496	static int ltt_relay_ascii_release(struct inode inode, struct file file)
497	{
498	struct seq_file *seq = file->private_data;
499	struct ltt_relay_iter *iter = seq->private;
500
501	ltt_relay_iter_release_channel(iter);
502	kfree(iter);
503	return 0;
504	}
505
506	static struct file_operations ltt_ascii_fops =
507	{
508	.read = seq_read,
509	.open = ltt_relay_ascii_open,
510	.release = ltt_relay_ascii_release,
511	.llseek = no_llseek,
512	.owner = THIS_MODULE,
513	};
514
515	int ltt_ascii_create(struct ltt_chan *chan)
516	{
517	struct dentry *dentry;
518
519	dentry = debugfs_create_file(chan->a.filename,
520	S_IRUSR \| S_IRGRP,
521	chan->a.trace->dentry.ascii_root,
522	chan, &ltt_ascii_fops);
523	if (IS_ERR(dentry))
524	return PTR_ERR(dentry);
525
526	if (!dentry)
527	return -EEXIST;
528
529	chan->a.ascii_dentry = dentry;
530	dentry->d_inode->i_private = chan;
531	return 0;
532	}
533	EXPORT_SYMBOL_GPL(ltt_ascii_create);
534
535	void ltt_ascii_remove(struct ltt_chan *chan)
536	{
537	struct dentry *dentry;
538
539	dentry = dget(chan->a.ascii_dentry);
540	debugfs_remove(dentry);
541	/* TODO: wait / wakeup instead */
542	/*
543	* Wait for every reference to the dentry to be gone,
544	* except us.
545	*/
0bc7b654	546	while (ACCESS_ONCE(dentry->d_count) != 1)
1c8284eb MD	547	msleep(100);
	548	dput(dentry);
	549	}
	550	EXPORT_SYMBOL_GPL(ltt_ascii_remove);
	551
	552	int ltt_ascii_create_dir(struct ltt_trace *new_trace)
	553	{
	554	new_trace->dentry.ascii_root = debugfs_create_dir(new_trace->trace_name,
	555	ltt_ascii_dir_dentry);
	556	if (!new_trace->dentry.ascii_root)
	557	return -EEXIST;
	558	return 0;
	559	}
	560	EXPORT_SYMBOL_GPL(ltt_ascii_create_dir);
	561
	562	void ltt_ascii_remove_dir(struct ltt_trace *trace)
	563	{
	564	debugfs_remove(trace->dentry.ascii_root);
	565	}
	566	EXPORT_SYMBOL_GPL(ltt_ascii_remove_dir);
	567
13c60117	568	__init int ltt_ascii_init(void)
1c8284eb MD	569	{
1c8284eb MD	570	ltt_ascii_dir_dentry = debugfs_create_dir(LTT_ASCII, get_ltt_root());
1c8284eb MD	571
	572	return ltt_ascii_dir_dentry ? 0 : -EFAULT;
	573	}
	574
13c60117	575	__exit void ltt_ascii_exit(void)
1c8284eb MD	576	{
1c8284eb MD	577	debugfs_remove(ltt_ascii_dir_dentry);
2e6246b4	578	put_ltt_root();
1c8284eb MD	579	}
1c8284eb MD	580
1c8284eb MD	581	MODULE_LICENSE("GPL and additional rights");
	582	MODULE_AUTHOR("Lai Jiangshan@FNST and Mathieu Desnoyers");
	583	MODULE_DESCRIPTION("Linux Trace Toolkit Next Generation Ascii Converter");