mirrors/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2025-11-04 10:40:15 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

blktrace/tracing: Use trace_seq_has_overflowed() helper function

Browse source 
Checking the return code of every trace_seq_printf() operation and having
to return early if it overflowed makes the code messy.

Using the new trace_seq_has_overflowed() and trace_handle_return() functions
allows us to clean up the code.

In the future, trace_seq_printf() and friends will be turning into void
functions and not returning a value. The trace_seq_has_overflowed() is to
be used instead. This cleanup allows that change to take place.

Cc: Jens Axboe <axboe@fb.com>
Reviewed-by: Petr Mladek <pmladek@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Steven Rostedt (Red Hat) 2014-11-12 11:35:48 -05:00 committed by Steven Rostedt
parent 19a7fe2062
commit f4a1d08ce6
1 changed files with 66 additions and 82 deletions
repo.diff.show_diff_stats Download patch file Download diff file Expand all files Collapse all files

148
kernel/trace/blktrace.c
View file

@ -1142,9 +1142,9 @@ static void get_pdu_remap(const struct trace_entry *ent,
r->sector_from = be64_to_cpu(sector_from); r->sector_from = be64_to_cpu(sector_from);
} }
typedef int (blk_log_action_t) (struct trace_iterator *iter, const char *act); typedef void (blk_log_action_t) (struct trace_iterator *iter, const char *act);
static int blk_log_action_classic(struct trace_iterator *iter, const char *act) static void blk_log_action_classic(struct trace_iterator *iter, const char *act)
{ {
char rwbs[RWBS_LEN]; char rwbs[RWBS_LEN];
unsigned long long ts = iter->ts; unsigned long long ts = iter->ts;
@ -1154,33 +1154,33 @@ static int blk_log_action_classic(struct trace_iterator *iter, const char *act)
fill_rwbs(rwbs, t); fill_rwbs(rwbs, t);
return trace_seq_printf(&iter->seq, trace_seq_printf(&iter->seq,
"%3d,%-3d %2d %5d.%09lu %5u %2s %3s ", "%3d,%-3d %2d %5d.%09lu %5u %2s %3s ",
MAJOR(t->device), MINOR(t->device), iter->cpu, MAJOR(t->device), MINOR(t->device), iter->cpu,
secs, nsec_rem, iter->ent->pid, act, rwbs); secs, nsec_rem, iter->ent->pid, act, rwbs);
} }
static int blk_log_action(struct trace_iterator *iter, const char *act) static void blk_log_action(struct trace_iterator *iter, const char *act)
{ {
char rwbs[RWBS_LEN]; char rwbs[RWBS_LEN];
const struct blk_io_trace *t = te_blk_io_trace(iter->ent); const struct blk_io_trace *t = te_blk_io_trace(iter->ent);
fill_rwbs(rwbs, t); fill_rwbs(rwbs, t);
return trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ", trace_seq_printf(&iter->seq, "%3d,%-3d %2s %3s ",
MAJOR(t->device), MINOR(t->device), act, rwbs); MAJOR(t->device), MINOR(t->device), act, rwbs);
} }
static int blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent)
{ {
const unsigned char *pdu_buf; const unsigned char *pdu_buf;
int pdu_len; int pdu_len;
int i, end, ret; int i, end;
pdu_buf = pdu_start(ent); pdu_buf = pdu_start(ent);
pdu_len = te_blk_io_trace(ent)->pdu_len; pdu_len = te_blk_io_trace(ent)->pdu_len;
if (!pdu_len) if (!pdu_len)
return 1; return;
/* find the last zero that needs to be printed */ /* find the last zero that needs to be printed */
for (end = pdu_len - 1; end >= 0; end--) for (end = pdu_len - 1; end >= 0; end--)
@ -1188,119 +1188,107 @@ static int blk_log_dump_pdu(struct trace_seq *s, const struct trace_entry *ent)
break; break;
end++; end++;
if (!trace_seq_putc(s, '(')) trace_seq_putc(s, '(');
return 0;
for (i = 0; i < pdu_len; i++) { for (i = 0; i < pdu_len; i++) {
ret = trace_seq_printf(s, "%s%02x", trace_seq_printf(s, "%s%02x",
i == 0 ? "" : " ", pdu_buf[i]); i == 0 ? "" : " ", pdu_buf[i]);
if (!ret)
return ret;
/* /*
* stop when the rest is just zeroes and indicate so * stop when the rest is just zeroes and indicate so
* with a ".." appended * with a ".." appended
*/ */
if (i == end && end != pdu_len - 1) if (i == end && end != pdu_len - 1) {
return trace_seq_puts(s, " ..) "); trace_seq_puts(s, " ..) ");
return;
}
} }
return trace_seq_puts(s, ") "); trace_seq_puts(s, ") ");
} }
static int blk_log_generic(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_generic(struct trace_seq *s, const struct trace_entry *ent)
{ {
char cmd[TASK_COMM_LEN]; char cmd[TASK_COMM_LEN];
trace_find_cmdline(ent->pid, cmd); trace_find_cmdline(ent->pid, cmd);
if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) { if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {
int ret; trace_seq_printf(s, "%u ", t_bytes(ent));
blk_log_dump_pdu(s, ent);
ret = trace_seq_printf(s, "%u ", t_bytes(ent)); trace_seq_printf(s, "[%s]\n", cmd);
if (!ret)
return 0;
ret = blk_log_dump_pdu(s, ent);
if (!ret)
return 0;
return trace_seq_printf(s, "[%s]\n", cmd);
} else { } else {
if (t_sec(ent)) if (t_sec(ent))
return trace_seq_printf(s, "%llu + %u [%s]\n", trace_seq_printf(s, "%llu + %u [%s]\n",
t_sector(ent), t_sec(ent), cmd); t_sector(ent), t_sec(ent), cmd);
return trace_seq_printf(s, "[%s]\n", cmd); else
trace_seq_printf(s, "[%s]\n", cmd);
} }
} }
static int blk_log_with_error(struct trace_seq *s, static void blk_log_with_error(struct trace_seq *s,
const struct trace_entry *ent) const struct trace_entry *ent)
{ {
if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) { if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {
int ret; blk_log_dump_pdu(s, ent);
trace_seq_printf(s, "[%d]\n", t_error(ent));
ret = blk_log_dump_pdu(s, ent);
if (ret)
return trace_seq_printf(s, "[%d]\n", t_error(ent));
return 0;
} else { } else {
if (t_sec(ent)) if (t_sec(ent))
return trace_seq_printf(s, "%llu + %u [%d]\n", trace_seq_printf(s, "%llu + %u [%d]\n",
t_sector(ent), t_sector(ent),
t_sec(ent), t_error(ent)); t_sec(ent), t_error(ent));
return trace_seq_printf(s, "%llu [%d]\n", else
t_sector(ent), t_error(ent)); trace_seq_printf(s, "%llu [%d]\n",
t_sector(ent), t_error(ent));
} }
} }
static int blk_log_remap(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_remap(struct trace_seq *s, const struct trace_entry *ent)
{ {
struct blk_io_trace_remap r = { .device_from = 0, }; struct blk_io_trace_remap r = { .device_from = 0, };
get_pdu_remap(ent, &r); get_pdu_remap(ent, &r);
return trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n", trace_seq_printf(s, "%llu + %u <- (%d,%d) %llu\n",
t_sector(ent), t_sec(ent), t_sector(ent), t_sec(ent),
MAJOR(r.device_from), MINOR(r.device_from), MAJOR(r.device_from), MINOR(r.device_from),
(unsigned long long)r.sector_from); (unsigned long long)r.sector_from);
} }
static int blk_log_plug(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_plug(struct trace_seq *s, const struct trace_entry *ent)
{ {
char cmd[TASK_COMM_LEN]; char cmd[TASK_COMM_LEN];
trace_find_cmdline(ent->pid, cmd); trace_find_cmdline(ent->pid, cmd);
return trace_seq_printf(s, "[%s]\n", cmd); trace_seq_printf(s, "[%s]\n", cmd);
} }
static int blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_unplug(struct trace_seq *s, const struct trace_entry *ent)
{ {
char cmd[TASK_COMM_LEN]; char cmd[TASK_COMM_LEN];
trace_find_cmdline(ent->pid, cmd); trace_find_cmdline(ent->pid, cmd);
return trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent)); trace_seq_printf(s, "[%s] %llu\n", cmd, get_pdu_int(ent));
} }
static int blk_log_split(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_split(struct trace_seq *s, const struct trace_entry *ent)
{ {
char cmd[TASK_COMM_LEN]; char cmd[TASK_COMM_LEN];
trace_find_cmdline(ent->pid, cmd); trace_find_cmdline(ent->pid, cmd);
return trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector(ent), trace_seq_printf(s, "%llu / %llu [%s]\n", t_sector(ent),
get_pdu_int(ent), cmd); get_pdu_int(ent), cmd);
} }
static int blk_log_msg(struct trace_seq *s, const struct trace_entry *ent) static void blk_log_msg(struct trace_seq *s, const struct trace_entry *ent)
{ {
int ret;
const struct blk_io_trace *t = te_blk_io_trace(ent); const struct blk_io_trace *t = te_blk_io_trace(ent);
ret = trace_seq_putmem(s, t + 1, t->pdu_len); trace_seq_putmem(s, t + 1, t->pdu_len);
if (ret) trace_seq_putc(s, '\n');
return trace_seq_putc(s, '\n');
return ret;
} }
/* /*
@ -1339,7 +1327,7 @@ static void blk_tracer_reset(struct trace_array *tr)
static const struct { static const struct {
const char *act[2]; const char *act[2];
int (*print)(struct trace_seq *s, const struct trace_entry *ent); void (*print)(struct trace_seq *s, const struct trace_entry *ent);
} what2act[] = { } what2act[] = {
[__BLK_TA_QUEUE] = {{ "Q", "queue" }, blk_log_generic }, [__BLK_TA_QUEUE] = {{ "Q", "queue" }, blk_log_generic },
[__BLK_TA_BACKMERGE] = {{ "M", "backmerge" }, blk_log_generic }, [__BLK_TA_BACKMERGE] = {{ "M", "backmerge" }, blk_log_generic },
@ -1364,7 +1352,6 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
struct trace_seq *s = &iter->seq; struct trace_seq *s = &iter->seq;
const struct blk_io_trace *t; const struct blk_io_trace *t;
u16 what; u16 what;
int ret;
bool long_act; bool long_act;
blk_log_action_t *log_action; blk_log_action_t *log_action;
@ -1374,21 +1361,18 @@ static enum print_line_t print_one_line(struct trace_iterator *iter,
log_action = classic ? &blk_log_action_classic : &blk_log_action; log_action = classic ? &blk_log_action_classic : &blk_log_action;
if (t->action == BLK_TN_MESSAGE) { if (t->action == BLK_TN_MESSAGE) {
ret = log_action(iter, long_act ? "message" : "m"); log_action(iter, long_act ? "message" : "m");
if (ret) blk_log_msg(s, iter->ent);
ret = blk_log_msg(s, iter->ent);
goto out;
} }
if (unlikely(what == 0 || what >= ARRAY_SIZE(what2act))) if (unlikely(what == 0 || what >= ARRAY_SIZE(what2act)))
ret = trace_seq_printf(s, "Unknown action %x\n", what); trace_seq_printf(s, "Unknown action %x\n", what);
else { else {
ret = log_action(iter, what2act[what].act[long_act]); log_action(iter, what2act[what].act[long_act]);
if (ret) what2act[what].print(s, iter->ent);
ret = what2act[what].print(s, iter->ent);
} }
out:
return ret ? TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE; return trace_handle_return(s);
} }
static enum print_line_t blk_trace_event_print(struct trace_iterator *iter, static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
@ -1397,7 +1381,7 @@ static enum print_line_t blk_trace_event_print(struct trace_iterator *iter,
return print_one_line(iter, false); return print_one_line(iter, false);
} }
static int blk_trace_synthesize_old_trace(struct trace_iterator *iter) static void blk_trace_synthesize_old_trace(struct trace_iterator *iter)
{ {
struct trace_seq *s = &iter->seq; struct trace_seq *s = &iter->seq;
struct blk_io_trace *t = (struct blk_io_trace *)iter->ent; struct blk_io_trace *t = (struct blk_io_trace *)iter->ent;
@ -1407,18 +1391,18 @@ static int blk_trace_synthesize_old_trace(struct trace_iterator *iter)
.time = iter->ts, .time = iter->ts,
}; };
if (!trace_seq_putmem(s, &old, offset)) trace_seq_putmem(s, &old, offset);
return 0; trace_seq_putmem(s, &t->sector,
return trace_seq_putmem(s, &t->sector, sizeof(old) - offset + t->pdu_len);
sizeof(old) - offset + t->pdu_len);
} }
static enum print_line_t static enum print_line_t
blk_trace_event_print_binary(struct trace_iterator *iter, int flags, blk_trace_event_print_binary(struct trace_iterator *iter, int flags,
struct trace_event *event) struct trace_event *event)
{ {
return blk_trace_synthesize_old_trace(iter) ? blk_trace_synthesize_old_trace(iter);
TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;
return trace_handle_return(&iter->seq);
} }
static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter) static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)