Skip to contentSkip to conversation

splice patches for ftrace

RFC PATCH In review Eduard - Gabriel Munteanu 5 participants 10 messages Feb 9, 2009 – Feb 11, 2009 Tracing

lore
Share & tools
lore
#0 lore raw

cover splice patches for ftrace

Hi,

This implements splice support so we can use it in kmemtrace-user. Please check it out and tell me what you think.

The "RFC" in the subject reads like "I tested this the best I could, although kmemtrace-user isn't still ready.". As we speak, I'm working on making kmemtrace over ftrace and kmemtrace-user work together nicely.

Cheers,
Eduard

Eduard - Gabriel Munteanu (2):
trace: Move pipe waiting code out of tracing_read_pipe().
trace: splice support for tracing_pipe

 kernel/trace/trace.c |  205 +++++++++++++++++++++++++++++++++++++++++++-------
 kernel/trace/trace.h |    6 ++
 2 files changed, 182 insertions(+), 29 deletions(-)
#1 lore raw

RFC PATCH 1/2 trace: Move pipe waiting code out of tracing_read_pipe().

This moves the pipe waiting code from tracing_read_pipe() into tracing_wait_pipe(), which is useful to implement other fops, like splice_read.

---
 kernel/trace/trace.c |   69 +++++++++++++++++++++++++++++---------------------
 1 files changed, 40 insertions(+), 29 deletions(-)
kernel/trace/trace.c +40 -29
index ef4dbac..130c4f5 100644
@@ -2359,37 +2359,15 @@ tracing_poll_pipe(struct file *filp, poll_table *poll_table)
 	}
 }
 
-/*
- * Consumer reader.
- */
-static ssize_t
-tracing_read_pipe(struct file *filp, char __user *ubuf,
-		  size_t cnt, loff_t *ppos)
+/* Must be called with trace_types_lock mutex held. */
+static int tracing_wait_pipe(struct file *filp)
 {
 	struct trace_iterator *iter = filp->private_data;
-	ssize_t sret;
-
-	/* return any leftover data */
-	sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
-	if (sret != -EBUSY)
-		return sret;
-
-	trace_seq_reset(&iter->seq);
 
-	mutex_lock(&trace_types_lock);
-	if (iter->trace->read) {
-		sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);
-		if (sret)
-			goto out;
-	}
-
-waitagain:
-	sret = 0;
 	while (trace_empty(iter)) {
 
 		if ((filp->f_flags & O_NONBLOCK)) {
-			sret = -EAGAIN;
-			goto out;
+			return -EAGAIN;
 		}
 
 		/*
@@ -2414,12 +2392,11 @@ waitagain:
 		iter->tr->waiter = NULL;
 
 		if (signal_pending(current)) {
-			sret = -EINTR;
-			goto out;
+			return -EINTR;
 		}
 
 		if (iter->trace != current_trace)
-			goto out;
+			return 0;
 
 		/*
 		 * We block until we read something and tracing is disabled.
@@ -2436,9 +2413,43 @@ waitagain:
 		continue;
 	}
 
+	return 1;
+}
+
+/*
+ * Consumer reader.
+ */
+static ssize_t
+tracing_read_pipe(struct file *filp, char __user *ubuf,
+		  size_t cnt, loff_t *ppos)
+{
+	struct trace_iterator *iter = filp->private_data;
+	ssize_t sret;
+
+	/* return any leftover data */
+	sret = trace_seq_to_user(&iter->seq, ubuf, cnt);
+	if (sret != -EBUSY)
+		return sret;
+
+	trace_seq_reset(&iter->seq);
+
+	mutex_lock(&trace_types_lock);
+	if (iter->trace->read) {
+		sret = iter->trace->read(iter, filp, ubuf, cnt, ppos);
+		if (sret)
+			goto out;
+	}
+
+waitagain:
+	sret = tracing_wait_pipe(filp);
+	if (sret <= 0)
+		goto out;
+
 	/* stop when tracing is finished */
-	if (trace_empty(iter))
+	if (trace_empty(iter)) {
+		sret = 0;
 		goto out;
+	}
 
 	if (cnt >= PAGE_SIZE)
 		cnt = PAGE_SIZE - 1;
Signature · 1 line
1.6.0.6
#2 lore raw

RFC PATCH 2/2 trace: splice support for tracing_pipe

Added and implemented tracing_pipe_fops->splice_read(). This allows userspace programs to get tracing data more efficiently.

---
 kernel/trace/trace.c |  136 ++++++++++++++++++++++++++++++++++++++++++++++++++
 kernel/trace/trace.h |    6 ++
 2 files changed, 142 insertions(+), 0 deletions(-)
kernel/trace/trace.c +136 -0
index 130c4f5..5b136ed 100644
@@ -31,6 +31,7 @@
 #include <linux/fs.h>
 #include <linux/kprobes.h>
 #include <linux/writeback.h>
+#include <linux/splice.h>
 
 #include <linux/stacktrace.h>
 #include <linux/ring_buffer.h>
@@ -364,6 +365,25 @@ ssize_t trace_seq_to_user(struct trace_seq *s, char __user *ubuf, size_t cnt)
 	return cnt;
 }
 
+ssize_t trace_seq_to_buffer(struct trace_seq *s, void *buf, size_t cnt)
+{
+	int len;
+	void *ret;
+
+	if (s->len <= s->readpos)
+		return -EBUSY;
+
+	len = s->len - s->readpos;
+	if (cnt > len)
+		cnt = len;
+	ret = memcpy(buf, s->buffer + s->readpos, cnt);
+	if (!ret)
+		return -EFAULT;
+
+	s->readpos += len;
+	return cnt;
+}
+
 static void
 trace_print_seq(struct seq_file *m, struct trace_seq *s)
 {
@@ -2495,6 +2515,121 @@ out:
 	return sret;
 }
 
+static void tracing_pipe_buf_release(struct pipe_inode_info *pipe,
+				     struct pipe_buffer *buf)
+{
+	__free_page(buf->page);
+}
+
+static void tracing_spd_release_pipe(struct splice_pipe_desc *spd,
+				     unsigned int idx)
+{
+	__free_page(spd->pages[idx]);
+}
+
+static struct pipe_buf_operations tracing_pipe_buf_ops = {
+	.can_merge = 0,
+	.map = generic_pipe_buf_map,
+	.unmap = generic_pipe_buf_unmap,
+	.confirm = generic_pipe_buf_confirm,
+	.release = tracing_pipe_buf_release,
+	.steal = generic_pipe_buf_steal,
+	.get = generic_pipe_buf_get,
+};
+
+static ssize_t tracing_splice_read_pipe(struct file *filp,
+					loff_t *ppos,
+					struct pipe_inode_info *pipe,
+					size_t len,
+					unsigned int flags)
+{
+	struct page *pages[PIPE_BUFFERS];
+	struct partial_page partial[PIPE_BUFFERS];
+	struct trace_iterator *iter = filp->private_data;
+	struct splice_pipe_desc spd = {
+		.pages = pages,
+		.partial = partial,
+		.nr_pages = 0, /* This gets updated below. */
+		.flags = flags,
+		.ops = &tracing_pipe_buf_ops,
+		.spd_release = tracing_spd_release_pipe,
+	};
+	ssize_t ret;
+	size_t count, rem;
+	unsigned int i;
+
+	mutex_lock(&trace_types_lock);
+
+	if (iter->trace->splice_read) {
+		ret = iter->trace->splice_read(iter, filp,
+					       ppos, pipe, len, flags);
+		if (ret)
+			goto out;
+	}
+
+	ret = tracing_wait_pipe(filp);
+	if (ret <= 0)
+		goto out;
+
+	if (!iter->ent && !find_next_entry_inc(iter)) {
+		ret = -EFAULT;
+		goto out;
+	}
+
+	/* Fill as many pages as possible. */
+	for (i = 0, rem = len; i < PIPE_BUFFERS && rem; i++) {
+		pages[i] = alloc_page(GFP_KERNEL);
+
+		/* Seq buffer is page-sized, exactly what we need. */
+		for (;;) {
+			count = iter->seq.len;
+			ret = print_trace_line(iter);
+			count = iter->seq.len - count;
+			if (rem < count) {
+				rem = 0;
+				iter->seq.len -= count;
+				break;
+			}
+			if (ret == TRACE_TYPE_PARTIAL_LINE) {
+				iter->seq.len -= count;
+				break;
+			}
+
+			trace_consume(iter);
+			rem -= count;
+			if (!find_next_entry_inc(iter))	{
+				rem = 0;
+				iter->ent = NULL;
+				break;
+			}
+		}
+
+		/* Copy the data into the page, so we can start over. */
+		ret = trace_seq_to_buffer(&iter->seq,
+					  page_address(pages[i]),
+					  iter->seq.len);
+		if (ret < 0) {
+			__free_page(pages[i]);
+			break;
+		}
+		partial[i].offset = 0;
+		partial[i].len = iter->seq.len;
+
+		trace_seq_reset(&iter->seq);
+	}
+
+	mutex_unlock(&trace_types_lock);
+
+	spd.nr_pages = i;
+
+	return splice_to_pipe(pipe, &spd);
+
+out:
+	mutex_unlock(&trace_types_lock);
+
+	return ret;
+}
+
 static ssize_t
 tracing_entries_read(struct file *filp, char __user *ubuf,
 		     size_t cnt, loff_t *ppos)
@@ -2658,6 +2793,7 @@ static struct file_operations tracing_pipe_fops = {
 	.open		= tracing_open_pipe,
 	.poll		= tracing_poll_pipe,
 	.read		= tracing_read_pipe,
+	.splice_read	= tracing_splice_read_pipe,
 	.release	= tracing_release_pipe,
 };
 
kernel/trace/trace.h +6 -0
index f2742fb..d58c305 100644
@@ -352,6 +352,12 @@ struct tracer {
 	ssize_t			(*read)(struct trace_iterator *iter,
 					struct file *filp, char __user *ubuf,
 					size_t cnt, loff_t *ppos);
+	ssize_t			(*splice_read)(struct trace_iterator *iter,
+					       struct file *filp,
+					       loff_t *ppos,
+					       struct pipe_inode_info *pipe,
+					       size_t len,
+					       unsigned int flags);
 #ifdef CONFIG_FTRACE_STARTUP_TEST
 	int			(*selftest)(struct tracer *trace,
 					    struct trace_array *tr);
Signature · 1 line
1.6.0.6
#3 lore raw

Re: [RFC PATCH 2/2] trace: splice support for tracing_pipe

Quoted 2 lines · Eduard - Gabriel Munteanu

Added and implemented tracing_pipe_fops->splice_read(). This allows userspace programs to get tracing data more efficiently.

Cool!

The structure of the splice state machine looks good - havent tested it yet.

A few comments:

kernel/trace/trace.c out: · line 2538

Quoted 9 lines
kernel/trace/trace.c +9 -0
+static struct pipe_buf_operations tracing_pipe_buf_ops = {
+	.can_merge = 0,
+	.map = generic_pipe_buf_map,
+	.unmap = generic_pipe_buf_unmap,
+	.confirm = generic_pipe_buf_confirm,
+	.release = tracing_pipe_buf_release,
+	.steal = generic_pipe_buf_steal,
+	.get = generic_pipe_buf_get,
+};

this looks nicer:

static struct pipe_buf_operations tracing_pipe_buf_ops = {
.can_merge = 0,
.map = generic_pipe_buf_map,
.unmap = generic_pipe_buf_unmap,
.confirm = generic_pipe_buf_confirm,
.release = tracing_pipe_buf_release,
.steal = generic_pipe_buf_steal,
.get = generic_pipe_buf_get,
};

(and this is how we do these things elsewhere in the tracing code)

ditto:

kernel/trace/trace.c out: · line 2556

Quoted 8 lines
kernel/trace/trace.c +8 -0
+	struct splice_pipe_desc spd = {
+		.pages = pages,
+		.partial = partial,
+		.nr_pages = 0, /* This gets updated below. */
+		.flags = flags,
+		.ops = &tracing_pipe_buf_ops,
+		.spd_release = tracing_spd_release_pipe,
+	};

+ for (i = 0, rem = len; i < PIPE_BUFFERS && rem; i++) {
+ pages[i] = alloc_page(GFP_KERNEL);
+
+ /* Seq buffer is page-sized, exactly what we need. */
+ for (;;) {

Ok, that's a minor bug: should check for NULL alloc_page() return.

kernel/trace/trace.c out: · line 2630

Quoted 4 lines
kernel/trace/trace.c +4 -0
+out:
+	mutex_unlock(&trace_types_lock);
+
+	return ret;

please name this label as 'out_err' - which it really is. We generally use the 'out:' label for error-less exits.

Btw., this is how we do structure initializations:

kernel/trace/trace.c static struct file_operations tracing_pipe_fops = { · line 2798

Quoted 6 lines
kernel/trace/trace.c +1 -0
 	.open		= tracing_open_pipe,
 	.poll		= tracing_poll_pipe,
 	.read		= tracing_read_pipe,
+	.splice_read	= tracing_splice_read_pipe,
 	.release	= tracing_release_pipe,
 };

One more thing, i'd suggest to split this loop (which is an iterator in a larger loop):

+ /* Seq buffer is page-sized, exactly what we need. */
+ for (;;) {
+ count = iter->seq.len;
+ ret = print_trace_line(iter);
[...]
+ }

Out into a separate helper inline function. This really is a "fill in pipe page" logic and having it separate makes it easier to review the splice-loop code pattern itself.

Thanks,

Ingo

maintainer
#7 lore raw
In reply to Eduard - Gabriel Munteanu
Quoted 8 lines · Eduard - Gabriel Munteanu

Hi,

This implements splice support so we can use it in kmemtrace-user. Please check it out and tell me what you think.

The "RFC" in the subject reads like "I tested this the best I could, although kmemtrace-user isn't still ready.". As we speak, I'm working on making kmemtrace over ftrace and kmemtrace-user work together nicely.

Hi Eduard!

Thanks, I'll give it a test. I've been playing on my spare time with a ring buffer splice interface. But I've not had the time to get it working fully. My version would be a binary only interface, but I really like the text interface you have.

You can look at my old changes at:

git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git

The branch tip/splice-broken

As the name suggests, it is still broken ;-)

-- Steve

#8 lore raw
Quoted 19 lines · Steven Rostedt
Quoted 8 lines · Eduard - Gabriel Munteanu

Hi,

This implements splice support so we can use it in kmemtrace-user. Please check it out and tell me what you think.

The "RFC" in the subject reads like "I tested this the best I could, although kmemtrace-user isn't still ready.". As we speak, I'm working on making kmemtrace over ftrace and kmemtrace-user work together nicely.

Hi Eduard!

Thanks, I'll give it a test. I've been playing on my spare time with a ring buffer splice interface. But I've not had the time to get it working fully. My version would be a binary only interface, but I really like the text interface you have.

Quoted 7 lines

You can look at my old changes at:

git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git

The branch tip/splice-broken

As the name suggests, it is still broken ;-)

I'd suggest we pick up Eduard's, with the fixes i suggested - because they clearly work for his kmemtrace utility!

Then pick up whatever is left in your branch.

Ingo

maintainer
#4 lore raw

Re: [RFC PATCH 2/2] trace: splice support for tracing_pipe

In reply to Eduard - Gabriel Munteanu
Quoted 8 lines · Eduard - Gabriel Munteanu
kernel/trace/trace.c +8 -0
+
+static ssize_t tracing_splice_read_pipe(struct file *filp,
+					loff_t *ppos,
+					struct pipe_inode_info *pipe,
+					size_t len,
+					unsigned int flags)
+{
+	struct page *pages[PIPE_BUFFERS];

kernel/trace/trace.c out: · line 2556

Quoted 10 lines
kernel/trace/trace.c +10 -0
+	struct partial_page partial[PIPE_BUFFERS];
+	struct trace_iterator *iter = filp->private_data;
+	struct splice_pipe_desc spd = {
+		.pages = pages,
+		.partial = partial,
+		.nr_pages = 0, /* This gets updated below. */
+		.flags = flags,
+		.ops = &tracing_pipe_buf_ops,
+		.spd_release = tracing_spd_release_pipe,
+	};

Note, this is getting a little stack heavy. It is still in bounds, but I get very nervous when I see structure arrays on the stack. If either the structure or the array grows large, we can be in trouble.

-- Steve

#5 lore raw

Re: [RFC PATCH 2/2] trace: splice support for tracing_pipe

Quoted 15 lines · Steven Rostedt
Quoted 14 lines · Eduard - Gabriel Munteanu
kernel/trace/trace.c +14 -0
+
+static ssize_t tracing_splice_read_pipe(struct file *filp,
+					loff_t *ppos,
+					struct pipe_inode_info *pipe,
+					size_t len,
+					unsigned int flags)
+{
+	struct page *pages[PIPE_BUFFERS];
+	struct partial_page partial[PIPE_BUFFERS];
+	struct trace_iterator *iter = filp->private_data;
+	struct splice_pipe_desc spd = {
+		.pages = pages,
+		.partial = partial,
+		.nr_pages = 0, /* This gets updated below. */
Quoted 8 lines

kernel/trace/trace.c out: · line 2556

Quoted 4 lines
kernel/trace/trace.c +4 -0
+		.flags = flags,
+		.ops = &tracing_pipe_buf_ops,
+		.spd_release = tracing_spd_release_pipe,
+	};

Note, this is getting a little stack heavy. It is still in bounds, but I get very nervous when I see structure arrays on the stack. If either the structure or the array grows large, we can be in trouble.

Good point - but note that this is how splice support is implemented in a number of other files - so if PIPE_BUFFERS or partial_page grows in size, those places will fail too.

Ingo

#6 lore raw

Re: [RFC PATCH 2/2] trace: splice support for tracing_pipe

Quoted 27 lines · Ingo Molnar
Quoted 15 lines · Steven Rostedt
Quoted 14 lines · Eduard - Gabriel Munteanu
kernel/trace/trace.c +14 -0
+
+static ssize_t tracing_splice_read_pipe(struct file *filp,
+					loff_t *ppos,
+					struct pipe_inode_info *pipe,
+					size_t len,
+					unsigned int flags)
+{
+	struct page *pages[PIPE_BUFFERS];
+	struct partial_page partial[PIPE_BUFFERS];
+	struct trace_iterator *iter = filp->private_data;
+	struct splice_pipe_desc spd = {
+		.pages = pages,
+		.partial = partial,
+		.nr_pages = 0, /* This gets updated below. */
Quoted 8 lines

kernel/trace/trace.c out: · line 2556

Quoted 4 lines
kernel/trace/trace.c +4 -0
+		.flags = flags,
+		.ops = &tracing_pipe_buf_ops,
+		.spd_release = tracing_spd_release_pipe,
+	};

Note, this is getting a little stack heavy. It is still in bounds, but I get very nervous when I see structure arrays on the stack. If either the structure or the array grows large, we can be in trouble.

Quoted 5 lines

Good point - but note that this is how splice support is implemented in a number of other files - so if PIPE_BUFFERS or partial_page grows in size, those places will fail too.

Ingo

I first thought they can be declared as static, since the read_pipe functions are not supposed to be reentrant, only one reader is allowed inside the pipe (serialized with a global mutex).
But the mutex is released while waiting, and still, I guess it should be reentrant one day if we plan to let the user having one trace_pipe per cpu trace.

Would a dynamic allocation be too much overhead for that?