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