Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f4a1d08c authored by Steven Rostedt (Red Hat)'s avatar Steven Rostedt (Red Hat) Committed by Steven Rostedt
Browse files

blktrace/tracing: Use trace_seq_has_overflowed() helper function 



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: default avatarPetr Mladek <pmladek@suse.cz>
Signed-off-by: default avatarSteven Rostedt <rostedt@goodmis.org>
parent 19a7fe20

kernel/trace/blktrace.c

+66 −82
Original line number Diff line number Diff line
@@ -1142,9 +1142,9 @@ static void get_pdu_remap(const struct trace_entry *ent, 
	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];

	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);



	return trace_seq_printf(&iter->seq,

	trace_seq_printf(&iter->seq,

			 "%3d,%-3d %2d %5d.%09lu %5u %2s %3s ",

			 MAJOR(t->device), MINOR(t->device), iter->cpu,

			 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];

	const struct blk_io_trace *t = te_blk_io_trace(iter->ent);



	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);

}



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;

	int pdu_len;

	int i, end, ret;

	int i, end;



	pdu_buf = pdu_start(ent);

	pdu_len = te_blk_io_trace(ent)->pdu_len;



	if (!pdu_len)

		return 1;

		return;



	/* find the last zero that needs to be printed */

	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;

	end++;



	if (!trace_seq_putc(s, '('))

		return 0;

	trace_seq_putc(s, '(');



	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]);

		if (!ret)

			return ret;



		/*

		 * stop when the rest is just zeroes and indicate so

		 * with a ".." appended

		 */

		if (i == end && end != pdu_len - 1)

			return trace_seq_puts(s, " ..) ");

		if (i == end && end != pdu_len - 1) {

			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];



	trace_find_cmdline(ent->pid, cmd);



	if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {

		int ret;



		ret = trace_seq_printf(s, "%u ", t_bytes(ent));

		if (!ret)

			return 0;

		ret = blk_log_dump_pdu(s, ent);

		if (!ret)

			return 0;

		return trace_seq_printf(s, "[%s]\n", cmd);

		trace_seq_printf(s, "%u ", t_bytes(ent));

		blk_log_dump_pdu(s, ent);

		trace_seq_printf(s, "[%s]\n", cmd);

	} else {

		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);

		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)

{

	if (t_action(ent) & BLK_TC_ACT(BLK_TC_PC)) {

		int ret;



		ret = blk_log_dump_pdu(s, ent);

		if (ret)

			return trace_seq_printf(s, "[%d]\n", t_error(ent));

		return 0;

		blk_log_dump_pdu(s, ent);

		trace_seq_printf(s, "[%d]\n", t_error(ent));

	} else {

		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_sec(ent), t_error(ent));

		return trace_seq_printf(s, "%llu [%d]\n",

		else

			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, };



	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),

			 MAJOR(r.device_from), MINOR(r.device_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];



	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];



	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];



	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);

}



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);



	ret = trace_seq_putmem(s, t + 1, t->pdu_len);

	if (ret)

		return trace_seq_putc(s, '\n');

	return ret;

	trace_seq_putmem(s, t + 1, t->pdu_len);

	trace_seq_putc(s, '\n');

}



/*
@@ -1339,7 +1327,7 @@ static void blk_tracer_reset(struct trace_array *tr) 


static const struct {

	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[] = {

	[__BLK_TA_QUEUE]	= {{  "Q", "queue" },	   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;

	const struct blk_io_trace *t;

	u16 what;

	int ret;

	bool long_act;

	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;



	if (t->action == BLK_TN_MESSAGE) {

		ret = log_action(iter, long_act ? "message" : "m");

		if (ret)

			ret = blk_log_msg(s, iter->ent);

		goto out;

		log_action(iter, long_act ? "message" : "m");

		blk_log_msg(s, iter->ent);

	}



	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 {

		ret = log_action(iter, what2act[what].act[long_act]);

		if (ret)

			ret = what2act[what].print(s, iter->ent);

		log_action(iter, what2act[what].act[long_act]);

		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,
@@ -1397,7 +1381,7 @@ static enum print_line_t blk_trace_event_print(struct trace_iterator *iter, 
	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 blk_io_trace *t = (struct blk_io_trace *)iter->ent;
@@ -1407,9 +1391,8 @@ static int blk_trace_synthesize_old_trace(struct trace_iterator *iter) 
		.time     = iter->ts,

	};



	if (!trace_seq_putmem(s, &old, offset))

		return 0;

	return trace_seq_putmem(s, &t->sector,

	trace_seq_putmem(s, &old, offset);

	trace_seq_putmem(s, &t->sector,

			 sizeof(old) - offset + t->pdu_len);

}
@@ -1417,8 +1400,9 @@ static enum print_line_t 
blk_trace_event_print_binary(struct trace_iterator *iter, int flags,

			     struct trace_event *event)

{

	return blk_trace_synthesize_old_trace(iter) ?

			TRACE_TYPE_HANDLED : TRACE_TYPE_PARTIAL_LINE;

	blk_trace_synthesize_old_trace(iter);



	return trace_handle_return(&iter->seq);

}



static enum print_line_t blk_tracer_print_line(struct trace_iterator *iter)