void kp_event_tostring(ktap_state *ks, struct trace_seq *seq)
{
struct ktap_event *e = ks->current_event;
struct trace_iterator *iter;
struct trace_event *ev;
enum print_line_t ret = TRACE_TYPE_NO_CONSUME;
/* Simulate the iterator */
/*
* use temp percpu buffer as trace_iterator
* we cannot use same temp buffer as printf.
*/
iter = kp_percpu_data(KTAP_PERCPU_DATA_BUFFER2);
trace_seq_init(&iter->seq);
iter->ent = e->entry;
ev = &(e->call->event);
if (ev)
ret = ev->funcs->trace(iter, 0, ev);
if (ret != TRACE_TYPE_NO_CONSUME) {
struct trace_seq *s = &iter->seq;
int len = s->len >= PAGE_SIZE ? PAGE_SIZE - 1 : s->len;
s->buffer[len] = '\0';
trace_seq_puts(seq, s->buffer);
}
}
static void dbg_printf_pevent_info(struct event_format *event, struct pevent_record *rec)
{
static struct trace_seq s;
event->pevent->print_raw = 1;
trace_seq_init(&s);
pevent_event_info(&s, event, rec);
trace_seq_putc(&s, '\n');
trace_seq_terminate(&s);
fprintf(stderr, "%.*s", s.len, s.buffer);
trace_seq_destroy(&s);
}
void event_format__print(struct event_format *event,
int cpu, void *data, int size)
{
struct pevent_record record;
struct trace_seq s;
memset(&record, 0, sizeof(record));
record.cpu = cpu;
record.size = size;
record.data = data;
trace_seq_init(&s);
pevent_event_info(&s, event, &record);
trace_seq_do_printf(&s);
}
void event_format__fprintf(struct event_format *event,
int cpu, void *data, int size, FILE *fp)
{
struct tep_record record;
struct trace_seq s;
memset(&record, 0, sizeof(record));
record.cpu = cpu;
record.size = size;
record.data = data;
trace_seq_init(&s);
tep_event_info(&s, event, &record);
trace_seq_do_fprintf(&s, fp);
trace_seq_destroy(&s);
}
static void show_plugins(void)
{
struct pevent *pevent;
struct plugin_list *list;
struct trace_seq s;
pevent = pevent_alloc();
if (!pevent)
die("Can not allocate pevent\n");
trace_seq_init(&s);
list = tracecmd_load_plugins(pevent);
trace_util_print_plugins(&s, " ", "\n", list);
trace_seq_do_printf(&s);
tracecmd_unload_plugins(list, pevent);
pevent_free(pevent);
}
/* don't engage with tstring when printf, use buffer directly */
static int ktap_lib_printf(ktap_state *ks)
{
struct trace_seq *seq;
preempt_disable_notrace();
seq = kp_percpu_data(KTAP_PERCPU_DATA_BUFFER);
trace_seq_init(seq);
if (kp_strfmt(ks, seq))
return 0;
seq->buffer[seq->len] = '\0';
kp_transport_write(ks, seq->buffer, seq->len + 1);
preempt_enable_notrace();
return 0;
}
/**
* trace_print_seq - move the contents of trace_seq into a seq_file
* @m: the seq_file descriptor that is the destination
* @s: the trace_seq descriptor that is the source.
*
* Returns 0 on success and non zero on error. If it succeeds to
* write to the seq_file it will reset the trace_seq, otherwise
* it does not modify the trace_seq to let the caller try again.
*/
int trace_print_seq(struct seq_file *m, struct trace_seq *s)
{
int ret;
__trace_seq_init(s);
ret = seq_buf_print_seq(m, &s->seq);
/*
* Only reset this buffer if we successfully wrote to the
* seq_file buffer. This lets the caller try again or
* do something else with the contents.
*/
if (!ret)
trace_seq_init(s);
return ret;
}
/* don't engage with intern string in printf, use buffer directly */
static int kplib_printf(ktap_state_t *ks)
{
struct trace_seq *seq;
preempt_disable_notrace();
seq = kp_this_cpu_print_buffer(ks);
trace_seq_init(seq);
if (kp_str_fmt(ks, seq))
goto out;
seq->buffer[seq->len] = '\0';
kp_transport_write(ks, seq->buffer, seq->len + 1);
out:
preempt_enable_notrace();
return 0;
}
/* don't engage with tstring when printf, use buffer directly */
static int ktap_lib_printf(ktap_State *ks)
{
struct trace_seq *seq;
if (ks == G(ks)->mainthread) {
seq = &mainthread_printf_seq;
} else {
seq = &per_cpu(printf_seq, smp_processor_id());
}
trace_seq_init(seq);
if (kp_strfmt(ks, seq)) {
return 0;
}
seq->buffer[seq->len] = '\0';
kp_transport_write(ks, seq->buffer, seq->len);
return 0;
}
void print_event(struct pevent *pevent, int cpu, void *data, int size,
unsigned long long nsecs, char *comm)
{
struct pevent_record record;
struct trace_seq s;
int pid;
pevent->latency_format = latency_format;
record.ts = nsecs;
record.cpu = cpu;
record.size = size;
record.data = data;
pid = pevent_data_pid(pevent, &record);
if (!pevent_pid_is_registered(pevent, pid))
pevent_register_comm(pevent, comm, pid);
trace_seq_init(&s);
pevent_print_event(pevent, &s, &record);
trace_seq_do_printf(&s);
printf("\n");
}
void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
{
struct event_format *event;
struct pevent_record record;
struct trace_seq s;
int type;
type = trace_parse_common_type(pevent, data);
event = pevent_find_event(pevent, type);
if (!event) {
warning("ug! no event found for type %d", type);
return;
}
memset(&record, 0, sizeof(record));
record.cpu = cpu;
record.size = size;
record.data = data;
trace_seq_init(&s);
pevent_event_info(&s, event, &record);
trace_seq_do_printf(&s);
}
void
trace_view_store_get_value (GtkTreeModel *tree_model,
GtkTreeIter *iter,
gint column,
GValue *value)
{
TraceViewRecord *record;
TraceViewStore *trace_view_store;
struct trace_seq s;
struct pevent *pevent;
struct event_format *event;
struct record *data;
const gchar *comm;
gchar *str;
guint64 secs, usecs;
gint val;
int cpu;
g_return_if_fail (TRACE_VIEW_IS_LIST (tree_model));
g_return_if_fail (iter != NULL);
g_return_if_fail (column < TRACE_VIEW_STORE(tree_model)->n_columns);
g_value_init (value, TRACE_VIEW_STORE(tree_model)->column_types[column]);
trace_view_store = TRACE_VIEW_STORE(tree_model);
pevent = tracecmd_get_pevent(trace_view_store->handle);
record = (TraceViewRecord*)iter->user_data;
g_return_if_fail ( record != NULL );
column = get_visible_column(TRACE_VIEW_STORE(tree_model), column);
switch(column)
{
case TRACE_VIEW_STORE_COL_INDEX:
g_value_set_uint(value, record->pos);
break;
case TRACE_VIEW_STORE_COL_CPU:
g_value_set_uint(value, record->cpu);
break;
case TRACE_VIEW_STORE_COL_TS:
usecs = record->timestamp;
usecs /= 1000;
secs = usecs / 1000000ULL;
usecs -= secs * 1000000ULL;
str = g_strdup_printf("%llu.%06llu",
(long long)secs, (long long)usecs);
g_value_set_string(value, str);
g_free(str);
break;
case TRACE_VIEW_STORE_COL_COMM:
case TRACE_VIEW_STORE_COL_PID:
case TRACE_VIEW_STORE_COL_LAT:
case TRACE_VIEW_STORE_COL_EVENT:
case TRACE_VIEW_STORE_COL_INFO:
data = tracecmd_read_at(trace_view_store->handle, record->offset, &cpu);
g_assert(data != NULL);
if (cpu != record->cpu) {
free_record(data);
return;
}
switch (column) {
case TRACE_VIEW_STORE_COL_COMM:
case TRACE_VIEW_STORE_COL_PID:
val = pevent_data_pid(pevent, data);
if (column == TRACE_VIEW_STORE_COL_PID)
g_value_set_uint(value, val);
else {
comm = pevent_data_comm_from_pid(pevent, val);
g_value_set_string(value, comm);
}
break;
case TRACE_VIEW_STORE_COL_LAT:
trace_seq_init(&s);
pevent_data_lat_fmt(pevent, &s, data);
g_value_set_string(value, s.buffer);
trace_seq_destroy(&s);
break;
case TRACE_VIEW_STORE_COL_EVENT:
case TRACE_VIEW_STORE_COL_INFO:
val = pevent_data_type(pevent, data);
event = pevent_data_event_from_type(pevent, val);
if (!event) {
if (column == TRACE_VIEW_STORE_COL_EVENT)
g_value_set_string(value, "[UNKNOWN EVENT]");
break;
}
if (column == TRACE_VIEW_STORE_COL_EVENT) {
g_value_set_string(value, event->name);
break;
}
trace_seq_init(&s);
pevent_event_info(&s, event, data);
g_value_set_string(value, s.buffer);
trace_seq_destroy(&s);
break;
}
free_record(data);
}
}
/*
* trace_seq should work with being initialized with 0s.
*/
static inline void __trace_seq_init(struct trace_seq *s)
{
if (unlikely(!s->seq.size))
trace_seq_init(s);
}
