Merge branch 'tip/tracing/ftrace' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace into tracing/ftrace
This commit is contained in:
Ingo Molnar
Коммит
ae216dd239
|
|
@ -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)
|
||||
{
|
||||
|
|
@ -2368,6 +2388,63 @@ tracing_poll_pipe(struct file *filp, poll_table *poll_table)
|
|||
}
|
||||
}
|
||||
|
||||
/* Must be called with trace_types_lock mutex held. */
|
||||
static int tracing_wait_pipe(struct file *filp)
|
||||
{
|
||||
struct trace_iterator *iter = filp->private_data;
|
||||
|
||||
while (trace_empty(iter)) {
|
||||
|
||||
if ((filp->f_flags & O_NONBLOCK)) {
|
||||
return -EAGAIN;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is a make-shift waitqueue. The reason we don't use
|
||||
* an actual wait queue is because:
|
||||
* 1) we only ever have one waiter
|
||||
* 2) the tracing, traces all functions, we don't want
|
||||
* the overhead of calling wake_up and friends
|
||||
* (and tracing them too)
|
||||
* Anyway, this is really very primitive wakeup.
|
||||
*/
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
iter->tr->waiter = current;
|
||||
|
||||
mutex_unlock(&trace_types_lock);
|
||||
|
||||
/* sleep for 100 msecs, and try again. */
|
||||
schedule_timeout(HZ/10);
|
||||
|
||||
mutex_lock(&trace_types_lock);
|
||||
|
||||
iter->tr->waiter = NULL;
|
||||
|
||||
if (signal_pending(current)) {
|
||||
return -EINTR;
|
||||
}
|
||||
|
||||
if (iter->trace != current_trace)
|
||||
return 0;
|
||||
|
||||
/*
|
||||
* We block until we read something and tracing is disabled.
|
||||
* We still block if tracing is disabled, but we have never
|
||||
* read anything. This allows a user to cat this file, and
|
||||
* then enable tracing. But after we have read something,
|
||||
* we give an EOF when tracing is again disabled.
|
||||
*
|
||||
* iter->pos will be 0 if we haven't read anything.
|
||||
*/
|
||||
if (!tracer_enabled && iter->pos)
|
||||
break;
|
||||
|
||||
continue;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Consumer reader.
|
||||
*/
|
||||
|
|
@ -2393,61 +2470,15 @@ tracing_read_pipe(struct file *filp, char __user *ubuf,
|
|||
}
|
||||
|
||||
waitagain:
|
||||
sret = 0;
|
||||
while (trace_empty(iter)) {
|
||||
|
||||
if ((filp->f_flags & O_NONBLOCK)) {
|
||||
sret = -EAGAIN;
|
||||
goto out;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is a make-shift waitqueue. The reason we don't use
|
||||
* an actual wait queue is because:
|
||||
* 1) we only ever have one waiter
|
||||
* 2) the tracing, traces all functions, we don't want
|
||||
* the overhead of calling wake_up and friends
|
||||
* (and tracing them too)
|
||||
* Anyway, this is really very primitive wakeup.
|
||||
*/
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
iter->tr->waiter = current;
|
||||
|
||||
mutex_unlock(&trace_types_lock);
|
||||
|
||||
/* sleep for 100 msecs, and try again. */
|
||||
schedule_timeout(HZ/10);
|
||||
|
||||
mutex_lock(&trace_types_lock);
|
||||
|
||||
iter->tr->waiter = NULL;
|
||||
|
||||
if (signal_pending(current)) {
|
||||
sret = -EINTR;
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (iter->trace != current_trace)
|
||||
goto out;
|
||||
|
||||
/*
|
||||
* We block until we read something and tracing is disabled.
|
||||
* We still block if tracing is disabled, but we have never
|
||||
* read anything. This allows a user to cat this file, and
|
||||
* then enable tracing. But after we have read something,
|
||||
* we give an EOF when tracing is again disabled.
|
||||
*
|
||||
* iter->pos will be 0 if we haven't read anything.
|
||||
*/
|
||||
if (!tracer_enabled && iter->pos)
|
||||
break;
|
||||
|
||||
continue;
|
||||
}
|
||||
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;
|
||||
|
|
@ -2493,6 +2524,135 @@ 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 size_t
|
||||
tracing_fill_pipe_page(struct page *pages, size_t rem,
|
||||
struct trace_iterator *iter)
|
||||
{
|
||||
size_t count;
|
||||
int ret;
|
||||
|
||||
/* 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;
|
||||
}
|
||||
}
|
||||
|
||||
return rem;
|
||||
}
|
||||
|
||||
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 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_err;
|
||||
}
|
||||
|
||||
ret = tracing_wait_pipe(filp);
|
||||
if (ret <= 0)
|
||||
goto out_err;
|
||||
|
||||
if (!iter->ent && !find_next_entry_inc(iter)) {
|
||||
ret = -EFAULT;
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
/* Fill as many pages as possible. */
|
||||
for (i = 0, rem = len; i < PIPE_BUFFERS && rem; i++) {
|
||||
pages[i] = alloc_page(GFP_KERNEL);
|
||||
if (!pages[i])
|
||||
break;
|
||||
|
||||
rem = tracing_fill_pipe_page(pages[i], rem, iter);
|
||||
|
||||
/* 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_err:
|
||||
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)
|
||||
|
|
@ -2656,6 +2816,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,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -353,6 +353,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);
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче