diff --git a/[refs] b/[refs] index 37b08ba23c5f..a6a4635b12a7 100644 --- a/[refs] +++ b/[refs] @@ -1,2 +1,2 @@ --- -refs/heads/master: 939b366977d29b5c0d53d1ea3b0b8cefb1e76202 +refs/heads/master: b2821ae68b14480bfc85ea1629537163310bc5cd diff --git a/trunk/block/blktrace.c b/trunk/block/blktrace.c index 8f5c37b0f80f..3f25425ade12 100644 --- a/trunk/block/blktrace.c +++ b/trunk/block/blktrace.c @@ -24,7 +24,7 @@ #include #include #include -#include +#include #include <../kernel/trace/trace_output.h> static unsigned int blktrace_seq __read_mostly = 1; @@ -148,12 +148,11 @@ static int act_log_check(struct blk_trace *bt, u32 what, sector_t sector, /* * Data direction bit lookup */ -static u32 ddir_act[2] __read_mostly = { BLK_TC_ACT(BLK_TC_READ), - BLK_TC_ACT(BLK_TC_WRITE) }; +static u32 ddir_act[2] __read_mostly = { BLK_TC_ACT(BLK_TC_READ), BLK_TC_ACT(BLK_TC_WRITE) }; /* The ilog2() calls fall out because they're constant */ -#define MASK_TC_BIT(rw, __name) ((rw & (1 << BIO_RW_ ## __name)) << \ - (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - BIO_RW_ ## __name)) +#define MASK_TC_BIT(rw, __name) ( (rw & (1 << BIO_RW_ ## __name)) << \ + (ilog2(BLK_TC_ ## __name) + BLK_TC_SHIFT - BIO_RW_ ## __name) ) /* * The worker for the various blk_add_trace*() types. Fills out a @@ -220,16 +219,9 @@ static void __blk_add_trace(struct blk_trace *bt, sector_t sector, int bytes, t->magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION; t->sequence = ++(*sequence); t->time = ktime_to_ns(ktime_get()); -record_it: - /* - * These two are not needed in ftrace as they are in the - * generic trace_entry, filled by tracing_generic_entry_update, - * but for the trace_event->bin() synthesizer benefit we do it - * here too. - */ t->cpu = cpu; t->pid = pid; - +record_it: t->sector = sector; t->bytes = bytes; t->action = what; @@ -454,8 +446,7 @@ int do_blk_trace_setup(struct request_queue *q, char *name, dev_t dev, atomic_set(&bt->dropped, 0); ret = -EIO; - bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, - &blk_dropped_fops); + bt->dropped_file = debugfs_create_file("dropped", 0444, dir, bt, &blk_dropped_fops); if (!bt->dropped_file) goto err; @@ -537,10 +528,10 @@ EXPORT_SYMBOL_GPL(blk_trace_setup); int blk_trace_startstop(struct request_queue *q, int start) { + struct blk_trace *bt; int ret; - struct blk_trace *bt = q->blk_trace; - if (bt == NULL) + if ((bt = q->blk_trace) == NULL) return -EINVAL; /* @@ -676,14 +667,12 @@ static void blk_add_trace_rq_issue(struct request_queue *q, struct request *rq) blk_add_trace_rq(q, rq, BLK_TA_ISSUE); } -static void blk_add_trace_rq_requeue(struct request_queue *q, - struct request *rq) +static void blk_add_trace_rq_requeue(struct request_queue *q, struct request *rq) { blk_add_trace_rq(q, rq, BLK_TA_REQUEUE); } -static void blk_add_trace_rq_complete(struct request_queue *q, - struct request *rq) +static void blk_add_trace_rq_complete(struct request_queue *q, struct request *rq) { blk_add_trace_rq(q, rq, BLK_TA_COMPLETE); } @@ -720,14 +709,12 @@ static void blk_add_trace_bio_complete(struct request_queue *q, struct bio *bio) blk_add_trace_bio(q, bio, BLK_TA_COMPLETE); } -static void blk_add_trace_bio_backmerge(struct request_queue *q, - struct bio *bio) +static void blk_add_trace_bio_backmerge(struct request_queue *q, struct bio *bio) { blk_add_trace_bio(q, bio, BLK_TA_BACKMERGE); } -static void blk_add_trace_bio_frontmerge(struct request_queue *q, - struct bio *bio) +static void blk_add_trace_bio_frontmerge(struct request_queue *q, struct bio *bio) { blk_add_trace_bio(q, bio, BLK_TA_FRONTMERGE); } @@ -737,8 +724,7 @@ static void blk_add_trace_bio_queue(struct request_queue *q, struct bio *bio) blk_add_trace_bio(q, bio, BLK_TA_QUEUE); } -static void blk_add_trace_getrq(struct request_queue *q, - struct bio *bio, int rw) +static void blk_add_trace_getrq(struct request_queue *q, struct bio *bio, int rw) { if (bio) blk_add_trace_bio(q, bio, BLK_TA_GETRQ); @@ -751,8 +737,7 @@ static void blk_add_trace_getrq(struct request_queue *q, } -static void blk_add_trace_sleeprq(struct request_queue *q, - struct bio *bio, int rw) +static void blk_add_trace_sleeprq(struct request_queue *q, struct bio *bio, int rw) { if (bio) blk_add_trace_bio(q, bio, BLK_TA_SLEEPRQ); @@ -760,8 +745,7 @@ static void blk_add_trace_sleeprq(struct request_queue *q, struct blk_trace *bt = q->blk_trace; if (bt) - __blk_add_trace(bt, 0, 0, rw, BLK_TA_SLEEPRQ, - 0, 0, NULL); + __blk_add_trace(bt, 0, 0, rw, BLK_TA_SLEEPRQ, 0, 0, NULL); } } @@ -1102,7 +1086,6 @@ static void blk_tracer_start(struct trace_array *tr) if (blk_register_tracepoints()) atomic_dec(&blk_probes_ref); mutex_unlock(&blk_probe_mutex); - trace_flags &= ~TRACE_ITER_CONTEXT_INFO; } static int blk_tracer_init(struct trace_array *tr) @@ -1117,7 +1100,6 @@ static int blk_tracer_init(struct trace_array *tr) static void blk_tracer_stop(struct trace_array *tr) { - trace_flags |= TRACE_ITER_CONTEXT_INFO; mutex_lock(&blk_probe_mutex); if (atomic_dec_and_test(&blk_probes_ref)) blk_unregister_tracepoints(); @@ -1158,50 +1140,25 @@ static struct { [__BLK_TA_REMAP] = {{ "A", "remap" }, blk_log_remap }, }; -static int blk_trace_event_print(struct trace_iterator *iter, int flags) +static int blk_trace_event_print(struct trace_seq *s, struct trace_entry *ent, + int flags) { - struct trace_seq *s = &iter->seq; - const struct blk_io_trace *t = (struct blk_io_trace *)iter->ent; + const struct blk_io_trace *t = (struct blk_io_trace *)ent; const u16 what = t->action & ((1 << BLK_TC_SHIFT) - 1); int ret; - if (trace_print_context(iter)) - return TRACE_TYPE_PARTIAL_LINE; - if (unlikely(what == 0 || what > ARRAY_SIZE(what2act))) ret = trace_seq_printf(s, "Bad pc action %x\n", what); else { const bool long_act = !!(trace_flags & TRACE_ITER_VERBOSE); ret = blk_log_action_seq(s, t, what2act[what].act[long_act]); if (ret) - ret = what2act[what].print(s, iter->ent); + ret = what2act[what].print(s, ent); } return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; } -static int blk_trace_synthesize_old_trace(struct trace_iterator *iter) -{ - struct trace_seq *s = &iter->seq; - struct blk_io_trace *t = (struct blk_io_trace *)iter->ent; - const int offset = offsetof(struct blk_io_trace, sector); - struct blk_io_trace old = { - .magic = BLK_IO_TRACE_MAGIC | BLK_IO_TRACE_VERSION, - .time = ns2usecs(iter->ts), - }; - - if (!trace_seq_putmem(s, &old, offset)) - return 0; - return trace_seq_putmem(s, &t->sector, - sizeof(old) - offset + t->pdu_len); -} - -static int blk_trace_event_print_binary(struct trace_iterator *iter, int flags) -{ - return blk_trace_synthesize_old_trace(iter) ? - TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; -} - static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter) { const struct blk_io_trace *t; @@ -1243,7 +1200,7 @@ static struct trace_event trace_blk_event = { .latency_trace = blk_trace_event_print, .raw = trace_nop_print, .hex = trace_nop_print, - .binary = blk_trace_event_print_binary, + .binary = trace_nop_print, }; static int __init init_blk_tracer(void) diff --git a/trunk/kernel/trace/trace.c b/trunk/kernel/trace/trace.c index 152d0969adf8..2c720c79bc60 100644 --- a/trunk/kernel/trace/trace.c +++ b/trunk/kernel/trace/trace.c @@ -53,6 +53,11 @@ unsigned long __read_mostly tracing_thresh; */ static bool __read_mostly tracing_selftest_running; +/* + * If a tracer is running, we do not want to run SELFTEST. + */ +static bool __read_mostly tracing_selftest_disabled; + /* For tracers that don't implement custom flags */ static struct tracer_opt dummy_tracer_opt[] = { { } @@ -110,14 +115,19 @@ static cpumask_var_t __read_mostly tracing_buffer_mask; */ int ftrace_dump_on_oops; -static int tracing_set_tracer(char *buf); +static int tracing_set_tracer(const char *buf); + +#define BOOTUP_TRACER_SIZE 100 +static char bootup_tracer_buf[BOOTUP_TRACER_SIZE] __initdata; +static char *default_bootup_tracer; static int __init set_ftrace(char *str) { - tracing_set_tracer(str); + strncpy(bootup_tracer_buf, str, BOOTUP_TRACER_SIZE); + default_bootup_tracer = bootup_tracer_buf; return 1; } -__setup("ftrace", set_ftrace); +__setup("ftrace=", set_ftrace); static int __init set_ftrace_dump_on_oops(char *str) { @@ -227,7 +237,7 @@ static DECLARE_WAIT_QUEUE_HEAD(trace_wait); /* trace_flags holds trace_options default values */ unsigned long trace_flags = TRACE_ITER_PRINT_PARENT | TRACE_ITER_PRINTK | - TRACE_ITER_ANNOTATE | TRACE_ITER_CONTEXT_INFO; + TRACE_ITER_ANNOTATE; /** * trace_wake_up - wake up tasks waiting for trace input @@ -285,7 +295,6 @@ static const char *trace_options[] = { "userstacktrace", "sym-userobj", "printk-msg-only", - "context-info", NULL }; @@ -469,7 +478,7 @@ int register_tracer(struct tracer *type) type->flags->opts = dummy_tracer_opt; #ifdef CONFIG_FTRACE_STARTUP_TEST - if (type->selftest) { + if (type->selftest && !tracing_selftest_disabled) { struct tracer *saved_tracer = current_trace; struct trace_array *tr = &global_trace; int i; @@ -511,8 +520,25 @@ int register_tracer(struct tracer *type) out: tracing_selftest_running = false; mutex_unlock(&trace_types_lock); - lock_kernel(); + if (!ret && default_bootup_tracer) { + if (!strncmp(default_bootup_tracer, type->name, + BOOTUP_TRACER_SIZE)) { + printk(KERN_INFO "Starting tracer '%s'\n", + type->name); + /* Do we want this tracer to start on bootup? */ + tracing_set_tracer(type->name); + default_bootup_tracer = NULL; + /* disable other selftests, since this will break it. */ + tracing_selftest_disabled = 1; +#ifdef CONFIG_FTRACE_STARTUP_TEST + printk(KERN_INFO "Disabling FTRACE selftests due" + " to running tracer '%s'\n", type->name); +#endif + } + } + + lock_kernel(); return ret; } @@ -1172,8 +1198,8 @@ __find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts) } /* Find the next real entry, without updating the iterator itself */ -struct trace_entry *trace_find_next_entry(struct trace_iterator *iter, - int *ent_cpu, u64 *ent_ts) +static struct trace_entry * +find_next_entry(struct trace_iterator *iter, int *ent_cpu, u64 *ent_ts) { return __find_next_entry(iter, ent_cpu, ent_ts); } @@ -1352,6 +1378,57 @@ print_trace_header(struct seq_file *m, struct trace_iterator *iter) seq_puts(m, "\n"); } +static void +lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu) +{ + int hardirq, softirq; + char *comm; + + comm = trace_find_cmdline(entry->pid); + + trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid); + trace_seq_printf(s, "%3d", cpu); + trace_seq_printf(s, "%c%c", + (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : + (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.', + ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.')); + + hardirq = entry->flags & TRACE_FLAG_HARDIRQ; + softirq = entry->flags & TRACE_FLAG_SOFTIRQ; + if (hardirq && softirq) { + trace_seq_putc(s, 'H'); + } else { + if (hardirq) { + trace_seq_putc(s, 'h'); + } else { + if (softirq) + trace_seq_putc(s, 's'); + else + trace_seq_putc(s, '.'); + } + } + + if (entry->preempt_count) + trace_seq_printf(s, "%x", entry->preempt_count); + else + trace_seq_puts(s, "."); +} + +unsigned long preempt_mark_thresh = 100; + +static void +lat_print_timestamp(struct trace_seq *s, u64 abs_usecs, + unsigned long rel_usecs) +{ + trace_seq_printf(s, " %4lldus", abs_usecs); + if (rel_usecs > preempt_mark_thresh) + trace_seq_puts(s, "!: "); + else if (rel_usecs > 1) + trace_seq_puts(s, "+: "); + else + trace_seq_puts(s, " : "); +} + static void test_cpu_buff_start(struct trace_iterator *iter) { struct trace_seq *s = &iter->seq; @@ -1369,26 +1446,48 @@ static void test_cpu_buff_start(struct trace_iterator *iter) trace_seq_printf(s, "##### CPU %u buffer started ####\n", iter->cpu); } -static enum print_line_t print_lat_fmt(struct trace_iterator *iter) +static enum print_line_t +print_lat_fmt(struct trace_iterator *iter, unsigned int trace_idx, int cpu) { struct trace_seq *s = &iter->seq; unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK); + struct trace_entry *next_entry; struct trace_event *event; + unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE); struct trace_entry *entry = iter->ent; + unsigned long abs_usecs; + unsigned long rel_usecs; + u64 next_ts; + char *comm; int ret; test_cpu_buff_start(iter); - event = ftrace_find_event(entry->type); - - if (trace_flags & TRACE_ITER_CONTEXT_INFO) { - ret = trace_print_lat_context(iter); - if (ret) - return ret; + next_entry = find_next_entry(iter, NULL, &next_ts); + if (!next_entry) + next_ts = iter->ts; + rel_usecs = ns2usecs(next_ts - iter->ts); + abs_usecs = ns2usecs(iter->ts - iter->tr->time_start); + + if (verbose) { + comm = trace_find_cmdline(entry->pid); + trace_seq_printf(s, "%16s %5d %3d %d %08x %08x [%08lx]" + " %ld.%03ldms (+%ld.%03ldms): ", + comm, + entry->pid, cpu, entry->flags, + entry->preempt_count, trace_idx, + ns2usecs(iter->ts), + abs_usecs/1000, + abs_usecs % 1000, rel_usecs/1000, + rel_usecs % 1000); + } else { + lat_print_generic(s, entry, cpu); + lat_print_timestamp(s, abs_usecs, rel_usecs); } + event = ftrace_find_event(entry->type); if (event && event->latency_trace) { - ret = event->latency_trace(iter, sym_flags); + ret = event->latency_trace(s, entry, sym_flags); if (ret) return ret; return TRACE_TYPE_HANDLED; @@ -1404,22 +1503,35 @@ static enum print_line_t print_trace_fmt(struct trace_iterator *iter) unsigned long sym_flags = (trace_flags & TRACE_ITER_SYM_MASK); struct trace_entry *entry; struct trace_event *event; + unsigned long usec_rem; + unsigned long long t; + unsigned long secs; + char *comm; int ret; entry = iter->ent; test_cpu_buff_start(iter); - event = ftrace_find_event(entry->type); + comm = trace_find_cmdline(iter->ent->pid); - if (trace_flags & TRACE_ITER_CONTEXT_INFO) { - ret = trace_print_context(iter); - if (ret) - return ret; - } + t = ns2usecs(iter->ts); + usec_rem = do_div(t, 1000000ULL); + secs = (unsigned long)t; + + ret = trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid); + if (!ret) + return TRACE_TYPE_PARTIAL_LINE; + ret = trace_seq_printf(s, "[%03d] ", iter->cpu); + if (!ret) + return TRACE_TYPE_PARTIAL_LINE; + ret = trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem); + if (!ret) + return TRACE_TYPE_PARTIAL_LINE; + event = ftrace_find_event(entry->type); if (event && event->trace) { - ret = event->trace(iter, sym_flags); + ret = event->trace(s, entry, sym_flags); if (ret) return ret; return TRACE_TYPE_HANDLED; @@ -1440,16 +1552,14 @@ static enum print_line_t print_raw_fmt(struct trace_iterator *iter) entry = iter->ent; - if (trace_flags & TRACE_ITER_CONTEXT_INFO) { - ret = trace_seq_printf(s, "%d %d %llu ", - entry->pid, iter->cpu, iter->ts); - if (!ret) - return TRACE_TYPE_PARTIAL_LINE; - } + ret = trace_seq_printf(s, "%d %d %llu ", + entry->pid, iter->cpu, iter->ts); + if (!ret) + return TRACE_TYPE_PARTIAL_LINE; event = ftrace_find_event(entry->type); if (event && event->raw) { - ret = event->raw(iter, 0); + ret = event->raw(s, entry, 0); if (ret) return ret; return TRACE_TYPE_HANDLED; @@ -1470,15 +1580,13 @@ static enum print_line_t print_hex_fmt(struct trace_iterator *iter) entry = iter->ent; - if (trace_flags & TRACE_ITER_CONTEXT_INFO) { - SEQ_PUT_HEX_FIELD_RET(s, entry->pid); - SEQ_PUT_HEX_FIELD_RET(s, iter->cpu); - SEQ_PUT_HEX_FIELD_RET(s, iter->ts); - } + SEQ_PUT_HEX_FIELD_RET(s, entry->pid); + SEQ_PUT_HEX_FIELD_RET(s, iter->cpu); + SEQ_PUT_HEX_FIELD_RET(s, iter->ts); event = ftrace_find_event(entry->type); if (event && event->hex) - event->hex(iter, 0); + event->hex(s, entry, 0); SEQ_PUT_FIELD_RET(s, newline); @@ -1494,7 +1602,7 @@ static enum print_line_t print_printk_msg_only(struct trace_iterator *iter) trace_assign_type(field, entry); - ret = trace_seq_printf(s, "%s", field->buf); + ret = trace_seq_printf(s, field->buf); if (!ret) return TRACE_TYPE_PARTIAL_LINE; @@ -1509,15 +1617,13 @@ static enum print_line_t print_bin_fmt(struct trace_iterator *iter) entry = iter->ent; - if (trace_flags & TRACE_ITER_CONTEXT_INFO) { - SEQ_PUT_FIELD_RET(s, entry->pid); - SEQ_PUT_FIELD_RET(s, entry->cpu); - SEQ_PUT_FIELD_RET(s, iter->ts); - } + SEQ_PUT_FIELD_RET(s, entry->pid); + SEQ_PUT_FIELD_RET(s, entry->cpu); + SEQ_PUT_FIELD_RET(s, iter->ts); event = ftrace_find_event(entry->type); if (event && event->binary) - event->binary(iter, 0); + event->binary(s, entry, 0); return TRACE_TYPE_HANDLED; } @@ -1564,7 +1670,7 @@ static enum print_line_t print_trace_line(struct trace_iterator *iter) return print_raw_fmt(iter); if (iter->iter_flags & TRACE_FILE_LAT_FMT) - return print_lat_fmt(iter); + return print_lat_fmt(iter, iter->idx, iter->cpu); return print_trace_fmt(iter); } @@ -2166,7 +2272,7 @@ tracing_set_trace_read(struct file *filp, char __user *ubuf, return simple_read_from_buffer(ubuf, cnt, ppos, buf, r); } -static int tracing_set_tracer(char *buf) +static int tracing_set_tracer(const char *buf) { struct trace_array *tr = &global_trace; struct tracer *t; @@ -3084,5 +3190,26 @@ __init static int tracer_alloc_buffers(void) out: return ret; } + +__init static int clear_boot_tracer(void) +{ + /* + * The default tracer at boot buffer is an init section. + * This function is called in lateinit. If we did not + * find the boot tracer, then clear it out, to prevent + * later registration from accessing the buffer that is + * about to be freed. + */ + if (!default_bootup_tracer) + return 0; + + printk(KERN_INFO "ftrace bootup tracer '%s' not registered.\n", + default_bootup_tracer); + default_bootup_tracer = NULL; + + return 0; +} + early_initcall(tracer_alloc_buffers); fs_initcall(tracer_init_debugfs); +late_initcall(clear_boot_tracer); diff --git a/trunk/kernel/trace/trace.h b/trunk/kernel/trace/trace.h index f0c7a0f08cac..e603a291134b 100644 --- a/trunk/kernel/trace/trace.h +++ b/trunk/kernel/trace/trace.h @@ -405,10 +405,6 @@ void init_tracer_sysprof_debugfs(struct dentry *d_tracer); struct trace_entry *tracing_get_trace_entry(struct trace_array *tr, struct trace_array_cpu *data); - -struct trace_entry *trace_find_next_entry(struct trace_iterator *iter, - int *ent_cpu, u64 *ent_ts); - void tracing_generic_entry_update(struct trace_entry *entry, unsigned long flags, int pc); @@ -595,8 +591,7 @@ enum trace_iterator_flags { TRACE_ITER_ANNOTATE = 0x2000, TRACE_ITER_USERSTACKTRACE = 0x4000, TRACE_ITER_SYM_USEROBJ = 0x8000, - TRACE_ITER_PRINTK_MSGONLY = 0x10000, - TRACE_ITER_CONTEXT_INFO = 0x20000 /* Print pid/cpu/time */ + TRACE_ITER_PRINTK_MSGONLY = 0x10000 }; /* diff --git a/trunk/kernel/trace/trace_branch.c b/trunk/kernel/trace/trace_branch.c index ea62f101e615..1284145c8898 100644 --- a/trunk/kernel/trace/trace_branch.c +++ b/trunk/kernel/trace/trace_branch.c @@ -160,13 +160,14 @@ trace_print_print(struct trace_seq *s, struct trace_entry *entry, int flags) return TRACE_TYPE_PARTIAL_LINE; } -static int trace_branch_print(struct trace_iterator *iter, int flags) +static int +trace_branch_print(struct trace_seq *s, struct trace_entry *entry, int flags) { struct trace_branch *field; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); - if (trace_seq_printf(&iter->seq, "[%s] %s:%s:%d\n", + if (trace_seq_printf(s, "[%s] %s:%s:%d\n", field->correct ? " ok " : " MISS ", field->func, field->file, diff --git a/trunk/kernel/trace/trace_output.c b/trunk/kernel/trace/trace_output.c index c24503b281a0..1a4e144a9f8f 100644 --- a/trunk/kernel/trace/trace_output.c +++ b/trunk/kernel/trace/trace_output.c @@ -286,113 +286,6 @@ seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags) return ret; } -static void -lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu) -{ - int hardirq, softirq; - char *comm; - - comm = trace_find_cmdline(entry->pid); - - trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid); - trace_seq_printf(s, "%3d", cpu); - trace_seq_printf(s, "%c%c", - (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : - (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : '.', - ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.')); - - hardirq = entry->flags & TRACE_FLAG_HARDIRQ; - softirq = entry->flags & TRACE_FLAG_SOFTIRQ; - if (hardirq && softirq) { - trace_seq_putc(s, 'H'); - } else { - if (hardirq) { - trace_seq_putc(s, 'h'); - } else { - if (softirq) - trace_seq_putc(s, 's'); - else - trace_seq_putc(s, '.'); - } - } - - if (entry->preempt_count) - trace_seq_printf(s, "%x", entry->preempt_count); - else - trace_seq_puts(s, "."); -} - -static unsigned long preempt_mark_thresh = 100; - -static void -lat_print_timestamp(struct trace_seq *s, u64 abs_usecs, - unsigned long rel_usecs) -{ - trace_seq_printf(s, " %4lldus", abs_usecs); - if (rel_usecs > preempt_mark_thresh) - trace_seq_puts(s, "!: "); - else if (rel_usecs > 1) - trace_seq_puts(s, "+: "); - else - trace_seq_puts(s, " : "); -} - -int trace_print_context(struct trace_iterator *iter) -{ - struct trace_seq *s = &iter->seq; - struct trace_entry *entry = iter->ent; - char *comm = trace_find_cmdline(entry->pid); - unsigned long long t = ns2usecs(iter->ts); - unsigned long usec_rem = do_div(t, USEC_PER_SEC); - unsigned long secs = (unsigned long)t; - - if (!trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid)) - goto partial; - if (!trace_seq_printf(s, "[%03d] ", entry->cpu)) - goto partial; - if (!trace_seq_printf(s, "%5lu.%06lu: ", secs, usec_rem)) - goto partial; - - return 0; - -partial: - return TRACE_TYPE_PARTIAL_LINE; -} - -int trace_print_lat_context(struct trace_iterator *iter) -{ - u64 next_ts; - struct trace_seq *s = &iter->seq; - struct trace_entry *entry = iter->ent, - *next_entry = trace_find_next_entry(iter, NULL, - &next_ts); - unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE); - unsigned long abs_usecs = ns2usecs(iter->ts - iter->tr->time_start); - unsigned long rel_usecs; - - if (!next_entry) - next_ts = iter->ts; - rel_usecs = ns2usecs(next_ts - iter->ts); - - if (verbose) { - char *comm = trace_find_cmdline(entry->pid); - trace_seq_printf(s, "%16s %5d %3d %d %08x %08lx [%08lx]" - " %ld.%03ldms (+%ld.%03ldms): ", - comm, - entry->pid, entry->cpu, entry->flags, - entry->preempt_count, iter->idx, - ns2usecs(iter->ts), - abs_usecs/1000, - abs_usecs % 1000, rel_usecs/1000, - rel_usecs % 1000); - } else { - lat_print_generic(s, entry, entry->cpu); - lat_print_timestamp(s, abs_usecs, rel_usecs); - } - - return 0; -} - static const char state_to_char[] = TASK_STATE_TO_CHAR_STR; static int task_state_char(unsigned long state) @@ -484,18 +377,19 @@ int unregister_ftrace_event(struct trace_event *event) * Standard events */ -int trace_nop_print(struct trace_iterator *iter, int flags) +int +trace_nop_print(struct trace_seq *s, struct trace_entry *entry, int flags) { return 0; } /* TRACE_FN */ -static int trace_fn_latency(struct trace_iterator *iter, int flags) +static int +trace_fn_latency(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ftrace_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!seq_print_ip_sym(s, field->ip, flags)) goto partial; @@ -512,12 +406,12 @@ static int trace_fn_latency(struct trace_iterator *iter, int flags) return TRACE_TYPE_PARTIAL_LINE; } -static int trace_fn_trace(struct trace_iterator *iter, int flags) +static int +trace_fn_trace(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ftrace_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!seq_print_ip_sym(s, field->ip, flags)) goto partial; @@ -539,13 +433,14 @@ static int trace_fn_trace(struct trace_iterator *iter, int flags) return TRACE_TYPE_PARTIAL_LINE; } -static int trace_fn_raw(struct trace_iterator *iter, int flags) +static int +trace_fn_raw(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ftrace_entry *field; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); - if (!trace_seq_printf(&iter->seq, "%lx %lx\n", + if (!trace_seq_printf(s, "%lx %lx\n", field->ip, field->parent_ip)) return TRACE_TYPE_PARTIAL_LINE; @@ -553,12 +448,12 @@ static int trace_fn_raw(struct trace_iterator *iter, int flags) return 0; } -static int trace_fn_hex(struct trace_iterator *iter, int flags) +static int +trace_fn_hex(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ftrace_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); SEQ_PUT_HEX_FIELD_RET(s, field->ip); SEQ_PUT_HEX_FIELD_RET(s, field->parent_ip); @@ -566,12 +461,12 @@ static int trace_fn_hex(struct trace_iterator *iter, int flags) return 0; } -static int trace_fn_bin(struct trace_iterator *iter, int flags) +static int +trace_fn_bin(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ftrace_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); SEQ_PUT_FIELD_RET(s, field->ip); SEQ_PUT_FIELD_RET(s, field->parent_ip); @@ -589,19 +484,20 @@ static struct trace_event trace_fn_event = { }; /* TRACE_CTX an TRACE_WAKE */ -static int trace_ctxwake_print(struct trace_iterator *iter, char *delim) +static int +trace_ctxwake_print(struct trace_seq *s, struct trace_entry *entry, int flags, + char *delim) { struct ctx_switch_entry *field; char *comm; int S, T; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); T = task_state_char(field->next_state); S = task_state_char(field->prev_state); comm = trace_find_cmdline(field->next_pid); - if (!trace_seq_printf(&iter->seq, - " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n", + if (!trace_seq_printf(s, " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n", field->prev_pid, field->prev_prio, S, delim, @@ -614,27 +510,31 @@ static int trace_ctxwake_print(struct trace_iterator *iter, char *delim) return 0; } -static int trace_ctx_print(struct trace_iterator *iter, int flags) +static int +trace_ctx_print(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_print(iter, "==>"); + return trace_ctxwake_print(s, entry, flags, "==>"); } -static int trace_wake_print(struct trace_iterator *iter, int flags) +static int +trace_wake_print(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_print(iter, " +"); + return trace_ctxwake_print(s, entry, flags, " +"); } -static int trace_ctxwake_raw(struct trace_iterator *iter, char S) +static int +trace_ctxwake_raw(struct trace_seq *s, struct trace_entry *entry, int flags, + char S) { struct ctx_switch_entry *field; int T; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!S) task_state_char(field->prev_state); T = task_state_char(field->next_state); - if (!trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n", + if (!trace_seq_printf(s, "%d %d %c %d %d %d %c\n", field->prev_pid, field->prev_prio, S, @@ -647,24 +547,27 @@ static int trace_ctxwake_raw(struct trace_iterator *iter, char S) return 0; } -static int trace_ctx_raw(struct trace_iterator *iter, int flags) +static int +trace_ctx_raw(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_raw(iter, 0); + return trace_ctxwake_raw(s, entry, flags, 0); } -static int trace_wake_raw(struct trace_iterator *iter, int flags) +static int +trace_wake_raw(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_raw(iter, '+'); + return trace_ctxwake_raw(s, entry, flags, '+'); } -static int trace_ctxwake_hex(struct trace_iterator *iter, char S) +static int +trace_ctxwake_hex(struct trace_seq *s, struct trace_entry *entry, int flags, + char S) { struct ctx_switch_entry *field; - struct trace_seq *s = &iter->seq; int T; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!S) task_state_char(field->prev_state); @@ -681,22 +584,24 @@ static int trace_ctxwake_hex(struct trace_iterator *iter, char S) return 0; } -static int trace_ctx_hex(struct trace_iterator *iter, int flags) +static int +trace_ctx_hex(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_hex(iter, 0); + return trace_ctxwake_hex(s, entry, flags, 0); } -static int trace_wake_hex(struct trace_iterator *iter, int flags) +static int +trace_wake_hex(struct trace_seq *s, struct trace_entry *entry, int flags) { - return trace_ctxwake_hex(iter, '+'); + return trace_ctxwake_hex(s, entry, flags, '+'); } -static int trace_ctxwake_bin(struct trace_iterator *iter, int flags) +static int +trace_ctxwake_bin(struct trace_seq *s, struct trace_entry *entry, int flags) { struct ctx_switch_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); SEQ_PUT_FIELD_RET(s, field->prev_pid); SEQ_PUT_FIELD_RET(s, field->prev_prio); @@ -727,13 +632,14 @@ static struct trace_event trace_wake_event = { }; /* TRACE_SPECIAL */ -static int trace_special_print(struct trace_iterator *iter, int flags) +static int +trace_special_print(struct trace_seq *s, struct trace_entry *entry, int flags) { struct special_entry *field; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); - if (!trace_seq_printf(&iter->seq, "# %ld %ld %ld\n", + if (!trace_seq_printf(s, "# %ld %ld %ld\n", field->arg1, field->arg2, field->arg3)) @@ -742,12 +648,12 @@ static int trace_special_print(struct trace_iterator *iter, int flags) return 0; } -static int trace_special_hex(struct trace_iterator *iter, int flags) +static int +trace_special_hex(struct trace_seq *s, struct trace_entry *entry, int flags) { struct special_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); SEQ_PUT_HEX_FIELD_RET(s, field->arg1); SEQ_PUT_HEX_FIELD_RET(s, field->arg2); @@ -756,12 +662,12 @@ static int trace_special_hex(struct trace_iterator *iter, int flags) return 0; } -static int trace_special_bin(struct trace_iterator *iter, int flags) +static int +trace_special_bin(struct trace_seq *s, struct trace_entry *entry, int flags) { struct special_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); SEQ_PUT_FIELD_RET(s, field->arg1); SEQ_PUT_FIELD_RET(s, field->arg2); @@ -781,13 +687,13 @@ static struct trace_event trace_special_event = { /* TRACE_STACK */ -static int trace_stack_print(struct trace_iterator *iter, int flags) +static int +trace_stack_print(struct trace_seq *s, struct trace_entry *entry, int flags) { struct stack_entry *field; - struct trace_seq *s = &iter->seq; int i; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); for (i = 0; i < FTRACE_STACK_ENTRIES; i++) { if (i) { @@ -817,12 +723,13 @@ static struct trace_event trace_stack_event = { }; /* TRACE_USER_STACK */ -static int trace_user_stack_print(struct trace_iterator *iter, int flags) +static int +trace_user_stack_print(struct trace_seq *s, struct trace_entry *entry, + int flags) { struct userstack_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!seq_print_userip_objs(field, s, flags)) goto partial; @@ -846,12 +753,12 @@ static struct trace_event trace_user_stack_event = { }; /* TRACE_PRINT */ -static int trace_print_print(struct trace_iterator *iter, int flags) +static int +trace_print_print(struct trace_seq *s, struct trace_entry *entry, int flags) { struct print_entry *field; - struct trace_seq *s = &iter->seq; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); if (!seq_print_ip_sym(s, field->ip, flags)) goto partial; @@ -865,13 +772,14 @@ static int trace_print_print(struct trace_iterator *iter, int flags) return TRACE_TYPE_PARTIAL_LINE; } -static int trace_print_raw(struct trace_iterator *iter, int flags) +static int +trace_print_raw(struct trace_seq *s, struct trace_entry *entry, int flags) { struct print_entry *field; - trace_assign_type(field, iter->ent); + trace_assign_type(field, entry); - if (!trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf)) + if (!trace_seq_printf(s, "# %lx %s", field->ip, field->buf)) goto partial; return 0; diff --git a/trunk/kernel/trace/trace_output.h b/trunk/kernel/trace/trace_output.h index 3aeb31f6506b..1cbab5e3dc99 100644 --- a/trunk/kernel/trace/trace_output.h +++ b/trunk/kernel/trace/trace_output.h @@ -3,7 +3,8 @@ #include "trace.h" -typedef int (*trace_print_func)(struct trace_iterator *iter, int flags); +typedef int (*trace_print_func)(struct trace_seq *s, struct trace_entry *entry, + int flags); struct trace_event { struct hlist_node node; @@ -32,14 +33,12 @@ int seq_print_userip_objs(const struct userstack_entry *entry, int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm, unsigned long ip, unsigned long sym_flags); -int trace_print_context(struct trace_iterator *iter); -int trace_print_lat_context(struct trace_iterator *iter); - struct trace_event *ftrace_find_event(int type); int register_ftrace_event(struct trace_event *event); int unregister_ftrace_event(struct trace_event *event); -int trace_nop_print(struct trace_iterator *iter, int flags); +int +trace_nop_print(struct trace_seq *s, struct trace_entry *entry, int flags); #define MAX_MEMHEX_BYTES 8 #define HEX_CHARS (MAX_MEMHEX_BYTES*2 + 1)