191007045SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 2edbe9817SJiri Olsa /* 3edbe9817SJiri Olsa * CTF writing support via babeltrace. 4edbe9817SJiri Olsa * 5edbe9817SJiri Olsa * Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com> 6edbe9817SJiri Olsa * Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de> 7edbe9817SJiri Olsa */ 8edbe9817SJiri Olsa 9a43783aeSArnaldo Carvalho de Melo #include <errno.h> 10fd20e811SArnaldo Carvalho de Melo #include <inttypes.h> 11edbe9817SJiri Olsa #include <linux/compiler.h> 12877a7a11SArnaldo Carvalho de Melo #include <linux/kernel.h> 137f7c536fSArnaldo Carvalho de Melo #include <linux/zalloc.h> 14edbe9817SJiri Olsa #include <babeltrace/ctf-writer/writer.h> 15edbe9817SJiri Olsa #include <babeltrace/ctf-writer/clock.h> 16edbe9817SJiri Olsa #include <babeltrace/ctf-writer/stream.h> 17edbe9817SJiri Olsa #include <babeltrace/ctf-writer/event.h> 18edbe9817SJiri Olsa #include <babeltrace/ctf-writer/event-types.h> 19edbe9817SJiri Olsa #include <babeltrace/ctf-writer/event-fields.h> 20e0a7cce5SWang Nan #include <babeltrace/ctf-ir/utils.h> 21edbe9817SJiri Olsa #include <babeltrace/ctf/events.h> 22edbe9817SJiri Olsa #include <traceevent/event-parse.h> 23edbe9817SJiri Olsa #include "asm/bug.h" 24*d0713d4cSNicholas Fraser #include "data-convert.h" 25edbe9817SJiri Olsa #include "session.h" 26edbe9817SJiri Olsa #include "debug.h" 27edbe9817SJiri Olsa #include "tool.h" 28edbe9817SJiri Olsa #include "evlist.h" 29edbe9817SJiri Olsa #include "evsel.h" 30edbe9817SJiri Olsa #include "machine.h" 31f6c12a00SJiri Olsa #include "config.h" 323052ba56SArnaldo Carvalho de Melo #include <linux/ctype.h> 336ef81c55SMamatha Inamdar #include <linux/err.h> 3488371c58SJiri Olsa #include <linux/time64.h> 3588371c58SJiri Olsa #include "util.h" 3688371c58SJiri Olsa #include "clockid.h" 37edbe9817SJiri Olsa 38edbe9817SJiri Olsa #define pr_N(n, fmt, ...) \ 39edbe9817SJiri Olsa eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__) 40edbe9817SJiri Olsa 41edbe9817SJiri Olsa #define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__) 42edbe9817SJiri Olsa #define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__) 43edbe9817SJiri Olsa 44edbe9817SJiri Olsa #define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__) 45edbe9817SJiri Olsa 46edbe9817SJiri Olsa struct evsel_priv { 47edbe9817SJiri Olsa struct bt_ctf_event_class *event_class; 48edbe9817SJiri Olsa }; 49edbe9817SJiri Olsa 5090e129ffSSebastian Andrzej Siewior #define MAX_CPUS 4096 5190e129ffSSebastian Andrzej Siewior 5290e129ffSSebastian Andrzej Siewior struct ctf_stream { 5390e129ffSSebastian Andrzej Siewior struct bt_ctf_stream *stream; 5490e129ffSSebastian Andrzej Siewior int cpu; 5589e5fa88SJiri Olsa u32 count; 5690e129ffSSebastian Andrzej Siewior }; 5790e129ffSSebastian Andrzej Siewior 58edbe9817SJiri Olsa struct ctf_writer { 59edbe9817SJiri Olsa /* writer primitives */ 60edbe9817SJiri Olsa struct bt_ctf_writer *writer; 6190e129ffSSebastian Andrzej Siewior struct ctf_stream **stream; 6290e129ffSSebastian Andrzej Siewior int stream_cnt; 63edbe9817SJiri Olsa struct bt_ctf_stream_class *stream_class; 64edbe9817SJiri Olsa struct bt_ctf_clock *clock; 65edbe9817SJiri Olsa 66edbe9817SJiri Olsa /* data types */ 67edbe9817SJiri Olsa union { 68edbe9817SJiri Olsa struct { 69edbe9817SJiri Olsa struct bt_ctf_field_type *s64; 70edbe9817SJiri Olsa struct bt_ctf_field_type *u64; 71edbe9817SJiri Olsa struct bt_ctf_field_type *s32; 72edbe9817SJiri Olsa struct bt_ctf_field_type *u32; 73edbe9817SJiri Olsa struct bt_ctf_field_type *string; 7426812d46SWang Nan struct bt_ctf_field_type *u32_hex; 75edbe9817SJiri Olsa struct bt_ctf_field_type *u64_hex; 76edbe9817SJiri Olsa }; 77edbe9817SJiri Olsa struct bt_ctf_field_type *array[6]; 78edbe9817SJiri Olsa } data; 79f5a08cedSWang Nan struct bt_ctf_event_class *comm_class; 80ebccba3fSWang Nan struct bt_ctf_event_class *exit_class; 81ebccba3fSWang Nan struct bt_ctf_event_class *fork_class; 82f9f6f2a9SGeneviève Bastien struct bt_ctf_event_class *mmap_class; 83f9f6f2a9SGeneviève Bastien struct bt_ctf_event_class *mmap2_class; 84edbe9817SJiri Olsa }; 85edbe9817SJiri Olsa 86edbe9817SJiri Olsa struct convert { 87edbe9817SJiri Olsa struct perf_tool tool; 88edbe9817SJiri Olsa struct ctf_writer writer; 89edbe9817SJiri Olsa 90edbe9817SJiri Olsa u64 events_size; 91edbe9817SJiri Olsa u64 events_count; 928ee4c46cSWang Nan u64 non_sample_count; 938fa46753SJiri Olsa 948fa46753SJiri Olsa /* Ordered events configured queue size. */ 958fa46753SJiri Olsa u64 queue_size; 96edbe9817SJiri Olsa }; 97edbe9817SJiri Olsa 98edbe9817SJiri Olsa static int value_set(struct bt_ctf_field_type *type, 99edbe9817SJiri Olsa struct bt_ctf_event *event, 100edbe9817SJiri Olsa const char *name, u64 val) 101edbe9817SJiri Olsa { 102edbe9817SJiri Olsa struct bt_ctf_field *field; 103edbe9817SJiri Olsa bool sign = bt_ctf_field_type_integer_get_signed(type); 104edbe9817SJiri Olsa int ret; 105edbe9817SJiri Olsa 106edbe9817SJiri Olsa field = bt_ctf_field_create(type); 107edbe9817SJiri Olsa if (!field) { 108edbe9817SJiri Olsa pr_err("failed to create a field %s\n", name); 109edbe9817SJiri Olsa return -1; 110edbe9817SJiri Olsa } 111edbe9817SJiri Olsa 112edbe9817SJiri Olsa if (sign) { 113edbe9817SJiri Olsa ret = bt_ctf_field_signed_integer_set_value(field, val); 114edbe9817SJiri Olsa if (ret) { 115edbe9817SJiri Olsa pr_err("failed to set field value %s\n", name); 116edbe9817SJiri Olsa goto err; 117edbe9817SJiri Olsa } 118edbe9817SJiri Olsa } else { 119edbe9817SJiri Olsa ret = bt_ctf_field_unsigned_integer_set_value(field, val); 120edbe9817SJiri Olsa if (ret) { 121edbe9817SJiri Olsa pr_err("failed to set field value %s\n", name); 122edbe9817SJiri Olsa goto err; 123edbe9817SJiri Olsa } 124edbe9817SJiri Olsa } 125edbe9817SJiri Olsa 126edbe9817SJiri Olsa ret = bt_ctf_event_set_payload(event, name, field); 127edbe9817SJiri Olsa if (ret) { 128edbe9817SJiri Olsa pr_err("failed to set payload %s\n", name); 129edbe9817SJiri Olsa goto err; 130edbe9817SJiri Olsa } 131edbe9817SJiri Olsa 132edbe9817SJiri Olsa pr2(" SET [%s = %" PRIu64 "]\n", name, val); 133edbe9817SJiri Olsa 134edbe9817SJiri Olsa err: 135edbe9817SJiri Olsa bt_ctf_field_put(field); 136edbe9817SJiri Olsa return ret; 137edbe9817SJiri Olsa } 138edbe9817SJiri Olsa 139edbe9817SJiri Olsa #define __FUNC_VALUE_SET(_name, _val_type) \ 140edbe9817SJiri Olsa static __maybe_unused int value_set_##_name(struct ctf_writer *cw, \ 141edbe9817SJiri Olsa struct bt_ctf_event *event, \ 142edbe9817SJiri Olsa const char *name, \ 143edbe9817SJiri Olsa _val_type val) \ 144edbe9817SJiri Olsa { \ 145edbe9817SJiri Olsa struct bt_ctf_field_type *type = cw->data._name; \ 146edbe9817SJiri Olsa return value_set(type, event, name, (u64) val); \ 147edbe9817SJiri Olsa } 148edbe9817SJiri Olsa 149edbe9817SJiri Olsa #define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name) 150edbe9817SJiri Olsa 151edbe9817SJiri Olsa FUNC_VALUE_SET(s32) 152edbe9817SJiri Olsa FUNC_VALUE_SET(u32) 153edbe9817SJiri Olsa FUNC_VALUE_SET(s64) 154edbe9817SJiri Olsa FUNC_VALUE_SET(u64) 155edbe9817SJiri Olsa __FUNC_VALUE_SET(u64_hex, u64) 156edbe9817SJiri Olsa 157069ee5c4SWang Nan static int string_set_value(struct bt_ctf_field *field, const char *string); 158069ee5c4SWang Nan static __maybe_unused int 159069ee5c4SWang Nan value_set_string(struct ctf_writer *cw, struct bt_ctf_event *event, 160069ee5c4SWang Nan const char *name, const char *string) 161069ee5c4SWang Nan { 162069ee5c4SWang Nan struct bt_ctf_field_type *type = cw->data.string; 163069ee5c4SWang Nan struct bt_ctf_field *field; 164069ee5c4SWang Nan int ret = 0; 165069ee5c4SWang Nan 166069ee5c4SWang Nan field = bt_ctf_field_create(type); 167069ee5c4SWang Nan if (!field) { 168069ee5c4SWang Nan pr_err("failed to create a field %s\n", name); 169069ee5c4SWang Nan return -1; 170069ee5c4SWang Nan } 171069ee5c4SWang Nan 172069ee5c4SWang Nan ret = string_set_value(field, string); 173069ee5c4SWang Nan if (ret) { 174069ee5c4SWang Nan pr_err("failed to set value %s\n", name); 175069ee5c4SWang Nan goto err_put_field; 176069ee5c4SWang Nan } 177069ee5c4SWang Nan 178069ee5c4SWang Nan ret = bt_ctf_event_set_payload(event, name, field); 179069ee5c4SWang Nan if (ret) 180069ee5c4SWang Nan pr_err("failed to set payload %s\n", name); 181069ee5c4SWang Nan 182069ee5c4SWang Nan err_put_field: 183069ee5c4SWang Nan bt_ctf_field_put(field); 184069ee5c4SWang Nan return ret; 185069ee5c4SWang Nan } 186069ee5c4SWang Nan 18769364727SSebastian Andrzej Siewior static struct bt_ctf_field_type* 1882c92f982STzvetomir Stoyanov (VMware) get_tracepoint_field_type(struct ctf_writer *cw, struct tep_format_field *field) 18969364727SSebastian Andrzej Siewior { 19069364727SSebastian Andrzej Siewior unsigned long flags = field->flags; 19169364727SSebastian Andrzej Siewior 192bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_STRING) 19369364727SSebastian Andrzej Siewior return cw->data.string; 19469364727SSebastian Andrzej Siewior 195bb39ccb2STzvetomir Stoyanov (VMware) if (!(flags & TEP_FIELD_IS_SIGNED)) { 19669364727SSebastian Andrzej Siewior /* unsigned long are mostly pointers */ 197bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_LONG || flags & TEP_FIELD_IS_POINTER) 19869364727SSebastian Andrzej Siewior return cw->data.u64_hex; 19969364727SSebastian Andrzej Siewior } 20069364727SSebastian Andrzej Siewior 201bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_SIGNED) { 20269364727SSebastian Andrzej Siewior if (field->size == 8) 20369364727SSebastian Andrzej Siewior return cw->data.s64; 20469364727SSebastian Andrzej Siewior else 20569364727SSebastian Andrzej Siewior return cw->data.s32; 20669364727SSebastian Andrzej Siewior } 20769364727SSebastian Andrzej Siewior 20869364727SSebastian Andrzej Siewior if (field->size == 8) 20969364727SSebastian Andrzej Siewior return cw->data.u64; 21069364727SSebastian Andrzej Siewior else 21169364727SSebastian Andrzej Siewior return cw->data.u32; 21269364727SSebastian Andrzej Siewior } 21369364727SSebastian Andrzej Siewior 214d4ae4213SWang Nan static unsigned long long adjust_signedness(unsigned long long value_int, int size) 215d4ae4213SWang Nan { 216d4ae4213SWang Nan unsigned long long value_mask; 217d4ae4213SWang Nan 218d4ae4213SWang Nan /* 219d4ae4213SWang Nan * value_mask = (1 << (size * 8 - 1)) - 1. 220d4ae4213SWang Nan * Directly set value_mask for code readers. 221d4ae4213SWang Nan */ 222d4ae4213SWang Nan switch (size) { 223d4ae4213SWang Nan case 1: 224d4ae4213SWang Nan value_mask = 0x7fULL; 225d4ae4213SWang Nan break; 226d4ae4213SWang Nan case 2: 227d4ae4213SWang Nan value_mask = 0x7fffULL; 228d4ae4213SWang Nan break; 229d4ae4213SWang Nan case 4: 230d4ae4213SWang Nan value_mask = 0x7fffffffULL; 231d4ae4213SWang Nan break; 232d4ae4213SWang Nan case 8: 233d4ae4213SWang Nan /* 234d4ae4213SWang Nan * For 64 bit value, return it self. There is no need 235d4ae4213SWang Nan * to fill high bit. 236d4ae4213SWang Nan */ 237d4ae4213SWang Nan /* Fall through */ 238d4ae4213SWang Nan default: 239d4ae4213SWang Nan /* BUG! */ 240d4ae4213SWang Nan return value_int; 241d4ae4213SWang Nan } 242d4ae4213SWang Nan 243d4ae4213SWang Nan /* If it is a positive value, don't adjust. */ 244d4ae4213SWang Nan if ((value_int & (~0ULL - value_mask)) == 0) 245d4ae4213SWang Nan return value_int; 246d4ae4213SWang Nan 247d4ae4213SWang Nan /* Fill upper part of value_int with 1 to make it a negative long long. */ 248d4ae4213SWang Nan return (value_int & value_mask) | ~value_mask; 249d4ae4213SWang Nan } 250d4ae4213SWang Nan 2515ea5888bSWang Nan static int string_set_value(struct bt_ctf_field *field, const char *string) 2525ea5888bSWang Nan { 2535ea5888bSWang Nan char *buffer = NULL; 2545ea5888bSWang Nan size_t len = strlen(string), i, p; 2555ea5888bSWang Nan int err; 2565ea5888bSWang Nan 2575ea5888bSWang Nan for (i = p = 0; i < len; i++, p++) { 2585ea5888bSWang Nan if (isprint(string[i])) { 2595ea5888bSWang Nan if (!buffer) 2605ea5888bSWang Nan continue; 2615ea5888bSWang Nan buffer[p] = string[i]; 2625ea5888bSWang Nan } else { 2635ea5888bSWang Nan char numstr[5]; 2645ea5888bSWang Nan 2655ea5888bSWang Nan snprintf(numstr, sizeof(numstr), "\\x%02x", 2665ea5888bSWang Nan (unsigned int)(string[i]) & 0xff); 2675ea5888bSWang Nan 2685ea5888bSWang Nan if (!buffer) { 2695ea5888bSWang Nan buffer = zalloc(i + (len - i) * 4 + 2); 2705ea5888bSWang Nan if (!buffer) { 2715ea5888bSWang Nan pr_err("failed to set unprintable string '%s'\n", string); 2725ea5888bSWang Nan return bt_ctf_field_string_set_value(field, "UNPRINTABLE-STRING"); 2735ea5888bSWang Nan } 2745ea5888bSWang Nan if (i > 0) 2755ea5888bSWang Nan strncpy(buffer, string, i); 2765ea5888bSWang Nan } 27797acec7dSShawn Landden memcpy(buffer + p, numstr, 4); 2785ea5888bSWang Nan p += 3; 2795ea5888bSWang Nan } 2805ea5888bSWang Nan } 2815ea5888bSWang Nan 2825ea5888bSWang Nan if (!buffer) 2835ea5888bSWang Nan return bt_ctf_field_string_set_value(field, string); 2845ea5888bSWang Nan err = bt_ctf_field_string_set_value(field, buffer); 2855ea5888bSWang Nan free(buffer); 2865ea5888bSWang Nan return err; 2875ea5888bSWang Nan } 2885ea5888bSWang Nan 28969364727SSebastian Andrzej Siewior static int add_tracepoint_field_value(struct ctf_writer *cw, 29069364727SSebastian Andrzej Siewior struct bt_ctf_event_class *event_class, 29169364727SSebastian Andrzej Siewior struct bt_ctf_event *event, 29269364727SSebastian Andrzej Siewior struct perf_sample *sample, 2932c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *fmtf) 29469364727SSebastian Andrzej Siewior { 29569364727SSebastian Andrzej Siewior struct bt_ctf_field_type *type; 29669364727SSebastian Andrzej Siewior struct bt_ctf_field *array_field; 29769364727SSebastian Andrzej Siewior struct bt_ctf_field *field; 29869364727SSebastian Andrzej Siewior const char *name = fmtf->name; 29969364727SSebastian Andrzej Siewior void *data = sample->raw_data; 30069364727SSebastian Andrzej Siewior unsigned long flags = fmtf->flags; 30169364727SSebastian Andrzej Siewior unsigned int n_items; 30269364727SSebastian Andrzej Siewior unsigned int i; 30369364727SSebastian Andrzej Siewior unsigned int offset; 30469364727SSebastian Andrzej Siewior unsigned int len; 30569364727SSebastian Andrzej Siewior int ret; 30669364727SSebastian Andrzej Siewior 307e0a7cce5SWang Nan name = fmtf->alias; 30869364727SSebastian Andrzej Siewior offset = fmtf->offset; 30969364727SSebastian Andrzej Siewior len = fmtf->size; 310bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_STRING) 311bb39ccb2STzvetomir Stoyanov (VMware) flags &= ~TEP_FIELD_IS_ARRAY; 31269364727SSebastian Andrzej Siewior 313bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_DYNAMIC) { 31469364727SSebastian Andrzej Siewior unsigned long long tmp_val; 31569364727SSebastian Andrzej Siewior 31669769ce1STzvetomir Stoyanov tmp_val = tep_read_number(fmtf->event->tep, 31769364727SSebastian Andrzej Siewior data + offset, len); 31869364727SSebastian Andrzej Siewior offset = tmp_val; 31969364727SSebastian Andrzej Siewior len = offset >> 16; 32069364727SSebastian Andrzej Siewior offset &= 0xffff; 32169364727SSebastian Andrzej Siewior } 32269364727SSebastian Andrzej Siewior 323bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_ARRAY) { 32469364727SSebastian Andrzej Siewior 32569364727SSebastian Andrzej Siewior type = bt_ctf_event_class_get_field_by_name( 32669364727SSebastian Andrzej Siewior event_class, name); 32769364727SSebastian Andrzej Siewior array_field = bt_ctf_field_create(type); 32869364727SSebastian Andrzej Siewior bt_ctf_field_type_put(type); 32969364727SSebastian Andrzej Siewior if (!array_field) { 33069364727SSebastian Andrzej Siewior pr_err("Failed to create array type %s\n", name); 33169364727SSebastian Andrzej Siewior return -1; 33269364727SSebastian Andrzej Siewior } 33369364727SSebastian Andrzej Siewior 33469364727SSebastian Andrzej Siewior len = fmtf->size / fmtf->arraylen; 33569364727SSebastian Andrzej Siewior n_items = fmtf->arraylen; 33669364727SSebastian Andrzej Siewior } else { 33769364727SSebastian Andrzej Siewior n_items = 1; 33869364727SSebastian Andrzej Siewior array_field = NULL; 33969364727SSebastian Andrzej Siewior } 34069364727SSebastian Andrzej Siewior 34169364727SSebastian Andrzej Siewior type = get_tracepoint_field_type(cw, fmtf); 34269364727SSebastian Andrzej Siewior 34369364727SSebastian Andrzej Siewior for (i = 0; i < n_items; i++) { 344bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_ARRAY) 34569364727SSebastian Andrzej Siewior field = bt_ctf_field_array_get_field(array_field, i); 34669364727SSebastian Andrzej Siewior else 34769364727SSebastian Andrzej Siewior field = bt_ctf_field_create(type); 34869364727SSebastian Andrzej Siewior 34969364727SSebastian Andrzej Siewior if (!field) { 35069364727SSebastian Andrzej Siewior pr_err("failed to create a field %s\n", name); 35169364727SSebastian Andrzej Siewior return -1; 35269364727SSebastian Andrzej Siewior } 35369364727SSebastian Andrzej Siewior 354bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_STRING) 3555ea5888bSWang Nan ret = string_set_value(field, data + offset + i * len); 356d4ae4213SWang Nan else { 357d4ae4213SWang Nan unsigned long long value_int; 358d4ae4213SWang Nan 35959c1baeeSTzvetomir Stoyanov (VMware) value_int = tep_read_number( 36069769ce1STzvetomir Stoyanov fmtf->event->tep, 361d4ae4213SWang Nan data + offset + i * len, len); 362d4ae4213SWang Nan 363bb39ccb2STzvetomir Stoyanov (VMware) if (!(flags & TEP_FIELD_IS_SIGNED)) 36469364727SSebastian Andrzej Siewior ret = bt_ctf_field_unsigned_integer_set_value( 36569364727SSebastian Andrzej Siewior field, value_int); 36669364727SSebastian Andrzej Siewior else 36769364727SSebastian Andrzej Siewior ret = bt_ctf_field_signed_integer_set_value( 368d4ae4213SWang Nan field, adjust_signedness(value_int, len)); 369d4ae4213SWang Nan } 370d4ae4213SWang Nan 37169364727SSebastian Andrzej Siewior if (ret) { 37269364727SSebastian Andrzej Siewior pr_err("failed to set file value %s\n", name); 37369364727SSebastian Andrzej Siewior goto err_put_field; 37469364727SSebastian Andrzej Siewior } 375bb39ccb2STzvetomir Stoyanov (VMware) if (!(flags & TEP_FIELD_IS_ARRAY)) { 37669364727SSebastian Andrzej Siewior ret = bt_ctf_event_set_payload(event, name, field); 37769364727SSebastian Andrzej Siewior if (ret) { 37869364727SSebastian Andrzej Siewior pr_err("failed to set payload %s\n", name); 37969364727SSebastian Andrzej Siewior goto err_put_field; 38069364727SSebastian Andrzej Siewior } 38169364727SSebastian Andrzej Siewior } 38269364727SSebastian Andrzej Siewior bt_ctf_field_put(field); 38369364727SSebastian Andrzej Siewior } 384bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_ARRAY) { 38569364727SSebastian Andrzej Siewior ret = bt_ctf_event_set_payload(event, name, array_field); 38669364727SSebastian Andrzej Siewior if (ret) { 38769364727SSebastian Andrzej Siewior pr_err("Failed add payload array %s\n", name); 38869364727SSebastian Andrzej Siewior return -1; 38969364727SSebastian Andrzej Siewior } 39069364727SSebastian Andrzej Siewior bt_ctf_field_put(array_field); 39169364727SSebastian Andrzej Siewior } 39269364727SSebastian Andrzej Siewior return 0; 39369364727SSebastian Andrzej Siewior 39469364727SSebastian Andrzej Siewior err_put_field: 39569364727SSebastian Andrzej Siewior bt_ctf_field_put(field); 39669364727SSebastian Andrzej Siewior return -1; 39769364727SSebastian Andrzej Siewior } 39869364727SSebastian Andrzej Siewior 39969364727SSebastian Andrzej Siewior static int add_tracepoint_fields_values(struct ctf_writer *cw, 40069364727SSebastian Andrzej Siewior struct bt_ctf_event_class *event_class, 40169364727SSebastian Andrzej Siewior struct bt_ctf_event *event, 4022c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *fields, 40369364727SSebastian Andrzej Siewior struct perf_sample *sample) 40469364727SSebastian Andrzej Siewior { 4052c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *field; 40669364727SSebastian Andrzej Siewior int ret; 40769364727SSebastian Andrzej Siewior 40869364727SSebastian Andrzej Siewior for (field = fields; field; field = field->next) { 40969364727SSebastian Andrzej Siewior ret = add_tracepoint_field_value(cw, event_class, event, sample, 41069364727SSebastian Andrzej Siewior field); 41169364727SSebastian Andrzej Siewior if (ret) 41269364727SSebastian Andrzej Siewior return -1; 41369364727SSebastian Andrzej Siewior } 41469364727SSebastian Andrzej Siewior return 0; 41569364727SSebastian Andrzej Siewior } 41669364727SSebastian Andrzej Siewior 41769364727SSebastian Andrzej Siewior static int add_tracepoint_values(struct ctf_writer *cw, 41869364727SSebastian Andrzej Siewior struct bt_ctf_event_class *event_class, 41969364727SSebastian Andrzej Siewior struct bt_ctf_event *event, 42032dcd021SJiri Olsa struct evsel *evsel, 42169364727SSebastian Andrzej Siewior struct perf_sample *sample) 42269364727SSebastian Andrzej Siewior { 4232c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *common_fields = evsel->tp_format->format.common_fields; 4242c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *fields = evsel->tp_format->format.fields; 42569364727SSebastian Andrzej Siewior int ret; 42669364727SSebastian Andrzej Siewior 42769364727SSebastian Andrzej Siewior ret = add_tracepoint_fields_values(cw, event_class, event, 42869364727SSebastian Andrzej Siewior common_fields, sample); 42969364727SSebastian Andrzej Siewior if (!ret) 43069364727SSebastian Andrzej Siewior ret = add_tracepoint_fields_values(cw, event_class, event, 43169364727SSebastian Andrzej Siewior fields, sample); 43269364727SSebastian Andrzej Siewior 43369364727SSebastian Andrzej Siewior return ret; 43469364727SSebastian Andrzej Siewior } 43569364727SSebastian Andrzej Siewior 4366122d57eSWang Nan static int 4376122d57eSWang Nan add_bpf_output_values(struct bt_ctf_event_class *event_class, 4386122d57eSWang Nan struct bt_ctf_event *event, 4396122d57eSWang Nan struct perf_sample *sample) 4406122d57eSWang Nan { 4416122d57eSWang Nan struct bt_ctf_field_type *len_type, *seq_type; 4426122d57eSWang Nan struct bt_ctf_field *len_field, *seq_field; 4436122d57eSWang Nan unsigned int raw_size = sample->raw_size; 4446122d57eSWang Nan unsigned int nr_elements = raw_size / sizeof(u32); 4456122d57eSWang Nan unsigned int i; 4466122d57eSWang Nan int ret; 4476122d57eSWang Nan 4486122d57eSWang Nan if (nr_elements * sizeof(u32) != raw_size) 449f2c8852eSWang Nan pr_warning("Incorrect raw_size (%u) in bpf output event, skip %zu bytes\n", 4506122d57eSWang Nan raw_size, nr_elements * sizeof(u32) - raw_size); 4516122d57eSWang Nan 4526122d57eSWang Nan len_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_len"); 4536122d57eSWang Nan len_field = bt_ctf_field_create(len_type); 4546122d57eSWang Nan if (!len_field) { 4556122d57eSWang Nan pr_err("failed to create 'raw_len' for bpf output event\n"); 4566122d57eSWang Nan ret = -1; 4576122d57eSWang Nan goto put_len_type; 4586122d57eSWang Nan } 4596122d57eSWang Nan 4606122d57eSWang Nan ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements); 4616122d57eSWang Nan if (ret) { 4626122d57eSWang Nan pr_err("failed to set field value for raw_len\n"); 4636122d57eSWang Nan goto put_len_field; 4646122d57eSWang Nan } 4656122d57eSWang Nan ret = bt_ctf_event_set_payload(event, "raw_len", len_field); 4666122d57eSWang Nan if (ret) { 4676122d57eSWang Nan pr_err("failed to set payload to raw_len\n"); 4686122d57eSWang Nan goto put_len_field; 4696122d57eSWang Nan } 4706122d57eSWang Nan 4716122d57eSWang Nan seq_type = bt_ctf_event_class_get_field_by_name(event_class, "raw_data"); 4726122d57eSWang Nan seq_field = bt_ctf_field_create(seq_type); 4736122d57eSWang Nan if (!seq_field) { 4746122d57eSWang Nan pr_err("failed to create 'raw_data' for bpf output event\n"); 4756122d57eSWang Nan ret = -1; 4766122d57eSWang Nan goto put_seq_type; 4776122d57eSWang Nan } 4786122d57eSWang Nan 4796122d57eSWang Nan ret = bt_ctf_field_sequence_set_length(seq_field, len_field); 4806122d57eSWang Nan if (ret) { 4816122d57eSWang Nan pr_err("failed to set length of 'raw_data'\n"); 4826122d57eSWang Nan goto put_seq_field; 4836122d57eSWang Nan } 4846122d57eSWang Nan 4856122d57eSWang Nan for (i = 0; i < nr_elements; i++) { 4866122d57eSWang Nan struct bt_ctf_field *elem_field = 4876122d57eSWang Nan bt_ctf_field_sequence_get_field(seq_field, i); 4886122d57eSWang Nan 4896122d57eSWang Nan ret = bt_ctf_field_unsigned_integer_set_value(elem_field, 4906122d57eSWang Nan ((u32 *)(sample->raw_data))[i]); 4916122d57eSWang Nan 4926122d57eSWang Nan bt_ctf_field_put(elem_field); 4936122d57eSWang Nan if (ret) { 4946122d57eSWang Nan pr_err("failed to set raw_data[%d]\n", i); 4956122d57eSWang Nan goto put_seq_field; 4966122d57eSWang Nan } 4976122d57eSWang Nan } 4986122d57eSWang Nan 4996122d57eSWang Nan ret = bt_ctf_event_set_payload(event, "raw_data", seq_field); 5006122d57eSWang Nan if (ret) 5016122d57eSWang Nan pr_err("failed to set payload for raw_data\n"); 5026122d57eSWang Nan 5036122d57eSWang Nan put_seq_field: 5046122d57eSWang Nan bt_ctf_field_put(seq_field); 5056122d57eSWang Nan put_seq_type: 5066122d57eSWang Nan bt_ctf_field_type_put(seq_type); 5076122d57eSWang Nan put_len_field: 5086122d57eSWang Nan bt_ctf_field_put(len_field); 5096122d57eSWang Nan put_len_type: 5106122d57eSWang Nan bt_ctf_field_type_put(len_type); 5116122d57eSWang Nan return ret; 5126122d57eSWang Nan } 5136122d57eSWang Nan 514a3073c8eSGeneviève Bastien static int 515a3073c8eSGeneviève Bastien add_callchain_output_values(struct bt_ctf_event_class *event_class, 516a3073c8eSGeneviève Bastien struct bt_ctf_event *event, 517a3073c8eSGeneviève Bastien struct ip_callchain *callchain) 518a3073c8eSGeneviève Bastien { 519a3073c8eSGeneviève Bastien struct bt_ctf_field_type *len_type, *seq_type; 520a3073c8eSGeneviève Bastien struct bt_ctf_field *len_field, *seq_field; 521a3073c8eSGeneviève Bastien unsigned int nr_elements = callchain->nr; 522a3073c8eSGeneviève Bastien unsigned int i; 523a3073c8eSGeneviève Bastien int ret; 524a3073c8eSGeneviève Bastien 525a3073c8eSGeneviève Bastien len_type = bt_ctf_event_class_get_field_by_name( 526a3073c8eSGeneviève Bastien event_class, "perf_callchain_size"); 527a3073c8eSGeneviève Bastien len_field = bt_ctf_field_create(len_type); 528a3073c8eSGeneviève Bastien if (!len_field) { 529a3073c8eSGeneviève Bastien pr_err("failed to create 'perf_callchain_size' for callchain output event\n"); 530a3073c8eSGeneviève Bastien ret = -1; 531a3073c8eSGeneviève Bastien goto put_len_type; 532a3073c8eSGeneviève Bastien } 533a3073c8eSGeneviève Bastien 534a3073c8eSGeneviève Bastien ret = bt_ctf_field_unsigned_integer_set_value(len_field, nr_elements); 535a3073c8eSGeneviève Bastien if (ret) { 536a3073c8eSGeneviève Bastien pr_err("failed to set field value for perf_callchain_size\n"); 537a3073c8eSGeneviève Bastien goto put_len_field; 538a3073c8eSGeneviève Bastien } 539a3073c8eSGeneviève Bastien ret = bt_ctf_event_set_payload(event, "perf_callchain_size", len_field); 540a3073c8eSGeneviève Bastien if (ret) { 541a3073c8eSGeneviève Bastien pr_err("failed to set payload to perf_callchain_size\n"); 542a3073c8eSGeneviève Bastien goto put_len_field; 543a3073c8eSGeneviève Bastien } 544a3073c8eSGeneviève Bastien 545a3073c8eSGeneviève Bastien seq_type = bt_ctf_event_class_get_field_by_name( 546a3073c8eSGeneviève Bastien event_class, "perf_callchain"); 547a3073c8eSGeneviève Bastien seq_field = bt_ctf_field_create(seq_type); 548a3073c8eSGeneviève Bastien if (!seq_field) { 549a3073c8eSGeneviève Bastien pr_err("failed to create 'perf_callchain' for callchain output event\n"); 550a3073c8eSGeneviève Bastien ret = -1; 551a3073c8eSGeneviève Bastien goto put_seq_type; 552a3073c8eSGeneviève Bastien } 553a3073c8eSGeneviève Bastien 554a3073c8eSGeneviève Bastien ret = bt_ctf_field_sequence_set_length(seq_field, len_field); 555a3073c8eSGeneviève Bastien if (ret) { 556a3073c8eSGeneviève Bastien pr_err("failed to set length of 'perf_callchain'\n"); 557a3073c8eSGeneviève Bastien goto put_seq_field; 558a3073c8eSGeneviève Bastien } 559a3073c8eSGeneviève Bastien 560a3073c8eSGeneviève Bastien for (i = 0; i < nr_elements; i++) { 561a3073c8eSGeneviève Bastien struct bt_ctf_field *elem_field = 562a3073c8eSGeneviève Bastien bt_ctf_field_sequence_get_field(seq_field, i); 563a3073c8eSGeneviève Bastien 564a3073c8eSGeneviève Bastien ret = bt_ctf_field_unsigned_integer_set_value(elem_field, 565a3073c8eSGeneviève Bastien ((u64 *)(callchain->ips))[i]); 566a3073c8eSGeneviève Bastien 567a3073c8eSGeneviève Bastien bt_ctf_field_put(elem_field); 568a3073c8eSGeneviève Bastien if (ret) { 569a3073c8eSGeneviève Bastien pr_err("failed to set callchain[%d]\n", i); 570a3073c8eSGeneviève Bastien goto put_seq_field; 571a3073c8eSGeneviève Bastien } 572a3073c8eSGeneviève Bastien } 573a3073c8eSGeneviève Bastien 574a3073c8eSGeneviève Bastien ret = bt_ctf_event_set_payload(event, "perf_callchain", seq_field); 575a3073c8eSGeneviève Bastien if (ret) 576a3073c8eSGeneviève Bastien pr_err("failed to set payload for raw_data\n"); 577a3073c8eSGeneviève Bastien 578a3073c8eSGeneviève Bastien put_seq_field: 579a3073c8eSGeneviève Bastien bt_ctf_field_put(seq_field); 580a3073c8eSGeneviève Bastien put_seq_type: 581a3073c8eSGeneviève Bastien bt_ctf_field_type_put(seq_type); 582a3073c8eSGeneviève Bastien put_len_field: 583a3073c8eSGeneviève Bastien bt_ctf_field_put(len_field); 584a3073c8eSGeneviève Bastien put_len_type: 585a3073c8eSGeneviève Bastien bt_ctf_field_type_put(len_type); 586a3073c8eSGeneviève Bastien return ret; 587a3073c8eSGeneviève Bastien } 588a3073c8eSGeneviève Bastien 589edbe9817SJiri Olsa static int add_generic_values(struct ctf_writer *cw, 590edbe9817SJiri Olsa struct bt_ctf_event *event, 59132dcd021SJiri Olsa struct evsel *evsel, 592edbe9817SJiri Olsa struct perf_sample *sample) 593edbe9817SJiri Olsa { 5941fc632ceSJiri Olsa u64 type = evsel->core.attr.sample_type; 595edbe9817SJiri Olsa int ret; 596edbe9817SJiri Olsa 597edbe9817SJiri Olsa /* 598edbe9817SJiri Olsa * missing: 599edbe9817SJiri Olsa * PERF_SAMPLE_TIME - not needed as we have it in 600edbe9817SJiri Olsa * ctf event header 601edbe9817SJiri Olsa * PERF_SAMPLE_READ - TODO 602edbe9817SJiri Olsa * PERF_SAMPLE_RAW - tracepoint fields are handled separately 603edbe9817SJiri Olsa * PERF_SAMPLE_BRANCH_STACK - TODO 604edbe9817SJiri Olsa * PERF_SAMPLE_REGS_USER - TODO 605edbe9817SJiri Olsa * PERF_SAMPLE_STACK_USER - TODO 606edbe9817SJiri Olsa */ 607edbe9817SJiri Olsa 608edbe9817SJiri Olsa if (type & PERF_SAMPLE_IP) { 60954cf776aSSebastian Andrzej Siewior ret = value_set_u64_hex(cw, event, "perf_ip", sample->ip); 610edbe9817SJiri Olsa if (ret) 611edbe9817SJiri Olsa return -1; 612edbe9817SJiri Olsa } 613edbe9817SJiri Olsa 614edbe9817SJiri Olsa if (type & PERF_SAMPLE_TID) { 61554cf776aSSebastian Andrzej Siewior ret = value_set_s32(cw, event, "perf_tid", sample->tid); 616edbe9817SJiri Olsa if (ret) 617edbe9817SJiri Olsa return -1; 618edbe9817SJiri Olsa 61954cf776aSSebastian Andrzej Siewior ret = value_set_s32(cw, event, "perf_pid", sample->pid); 620edbe9817SJiri Olsa if (ret) 621edbe9817SJiri Olsa return -1; 622edbe9817SJiri Olsa } 623edbe9817SJiri Olsa 624edbe9817SJiri Olsa if ((type & PERF_SAMPLE_ID) || 625edbe9817SJiri Olsa (type & PERF_SAMPLE_IDENTIFIER)) { 62654cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_id", sample->id); 627edbe9817SJiri Olsa if (ret) 628edbe9817SJiri Olsa return -1; 629edbe9817SJiri Olsa } 630edbe9817SJiri Olsa 631edbe9817SJiri Olsa if (type & PERF_SAMPLE_STREAM_ID) { 63254cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_stream_id", sample->stream_id); 633edbe9817SJiri Olsa if (ret) 634edbe9817SJiri Olsa return -1; 635edbe9817SJiri Olsa } 636edbe9817SJiri Olsa 637edbe9817SJiri Olsa if (type & PERF_SAMPLE_PERIOD) { 63854cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_period", sample->period); 639edbe9817SJiri Olsa if (ret) 640edbe9817SJiri Olsa return -1; 641edbe9817SJiri Olsa } 642edbe9817SJiri Olsa 643edbe9817SJiri Olsa if (type & PERF_SAMPLE_WEIGHT) { 64454cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_weight", sample->weight); 645edbe9817SJiri Olsa if (ret) 646edbe9817SJiri Olsa return -1; 647edbe9817SJiri Olsa } 648edbe9817SJiri Olsa 649edbe9817SJiri Olsa if (type & PERF_SAMPLE_DATA_SRC) { 65054cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_data_src", 65154cf776aSSebastian Andrzej Siewior sample->data_src); 652edbe9817SJiri Olsa if (ret) 653edbe9817SJiri Olsa return -1; 654edbe9817SJiri Olsa } 655edbe9817SJiri Olsa 656edbe9817SJiri Olsa if (type & PERF_SAMPLE_TRANSACTION) { 65754cf776aSSebastian Andrzej Siewior ret = value_set_u64(cw, event, "perf_transaction", 65854cf776aSSebastian Andrzej Siewior sample->transaction); 659edbe9817SJiri Olsa if (ret) 660edbe9817SJiri Olsa return -1; 661edbe9817SJiri Olsa } 662edbe9817SJiri Olsa 663edbe9817SJiri Olsa return 0; 664edbe9817SJiri Olsa } 665edbe9817SJiri Olsa 66690e129ffSSebastian Andrzej Siewior static int ctf_stream__flush(struct ctf_stream *cs) 66790e129ffSSebastian Andrzej Siewior { 66890e129ffSSebastian Andrzej Siewior int err = 0; 66990e129ffSSebastian Andrzej Siewior 67090e129ffSSebastian Andrzej Siewior if (cs) { 67190e129ffSSebastian Andrzej Siewior err = bt_ctf_stream_flush(cs->stream); 67290e129ffSSebastian Andrzej Siewior if (err) 67390e129ffSSebastian Andrzej Siewior pr_err("CTF stream %d flush failed\n", cs->cpu); 67490e129ffSSebastian Andrzej Siewior 67589e5fa88SJiri Olsa pr("Flush stream for cpu %d (%u samples)\n", 67689e5fa88SJiri Olsa cs->cpu, cs->count); 67789e5fa88SJiri Olsa 67889e5fa88SJiri Olsa cs->count = 0; 67990e129ffSSebastian Andrzej Siewior } 68090e129ffSSebastian Andrzej Siewior 68190e129ffSSebastian Andrzej Siewior return err; 68290e129ffSSebastian Andrzej Siewior } 68390e129ffSSebastian Andrzej Siewior 68490e129ffSSebastian Andrzej Siewior static struct ctf_stream *ctf_stream__create(struct ctf_writer *cw, int cpu) 68590e129ffSSebastian Andrzej Siewior { 68690e129ffSSebastian Andrzej Siewior struct ctf_stream *cs; 68790e129ffSSebastian Andrzej Siewior struct bt_ctf_field *pkt_ctx = NULL; 68890e129ffSSebastian Andrzej Siewior struct bt_ctf_field *cpu_field = NULL; 68990e129ffSSebastian Andrzej Siewior struct bt_ctf_stream *stream = NULL; 69090e129ffSSebastian Andrzej Siewior int ret; 69190e129ffSSebastian Andrzej Siewior 69290e129ffSSebastian Andrzej Siewior cs = zalloc(sizeof(*cs)); 69390e129ffSSebastian Andrzej Siewior if (!cs) { 69490e129ffSSebastian Andrzej Siewior pr_err("Failed to allocate ctf stream\n"); 69590e129ffSSebastian Andrzej Siewior return NULL; 69690e129ffSSebastian Andrzej Siewior } 69790e129ffSSebastian Andrzej Siewior 69890e129ffSSebastian Andrzej Siewior stream = bt_ctf_writer_create_stream(cw->writer, cw->stream_class); 69990e129ffSSebastian Andrzej Siewior if (!stream) { 70090e129ffSSebastian Andrzej Siewior pr_err("Failed to create CTF stream\n"); 70190e129ffSSebastian Andrzej Siewior goto out; 70290e129ffSSebastian Andrzej Siewior } 70390e129ffSSebastian Andrzej Siewior 70490e129ffSSebastian Andrzej Siewior pkt_ctx = bt_ctf_stream_get_packet_context(stream); 70590e129ffSSebastian Andrzej Siewior if (!pkt_ctx) { 70690e129ffSSebastian Andrzej Siewior pr_err("Failed to obtain packet context\n"); 70790e129ffSSebastian Andrzej Siewior goto out; 70890e129ffSSebastian Andrzej Siewior } 70990e129ffSSebastian Andrzej Siewior 71090e129ffSSebastian Andrzej Siewior cpu_field = bt_ctf_field_structure_get_field(pkt_ctx, "cpu_id"); 71190e129ffSSebastian Andrzej Siewior bt_ctf_field_put(pkt_ctx); 71290e129ffSSebastian Andrzej Siewior if (!cpu_field) { 71390e129ffSSebastian Andrzej Siewior pr_err("Failed to obtain cpu field\n"); 71490e129ffSSebastian Andrzej Siewior goto out; 71590e129ffSSebastian Andrzej Siewior } 71690e129ffSSebastian Andrzej Siewior 71790e129ffSSebastian Andrzej Siewior ret = bt_ctf_field_unsigned_integer_set_value(cpu_field, (u32) cpu); 71890e129ffSSebastian Andrzej Siewior if (ret) { 71990e129ffSSebastian Andrzej Siewior pr_err("Failed to update CPU number\n"); 72090e129ffSSebastian Andrzej Siewior goto out; 72190e129ffSSebastian Andrzej Siewior } 72290e129ffSSebastian Andrzej Siewior 72390e129ffSSebastian Andrzej Siewior bt_ctf_field_put(cpu_field); 72490e129ffSSebastian Andrzej Siewior 72590e129ffSSebastian Andrzej Siewior cs->cpu = cpu; 72690e129ffSSebastian Andrzej Siewior cs->stream = stream; 72790e129ffSSebastian Andrzej Siewior return cs; 72890e129ffSSebastian Andrzej Siewior 72990e129ffSSebastian Andrzej Siewior out: 73090e129ffSSebastian Andrzej Siewior if (cpu_field) 73190e129ffSSebastian Andrzej Siewior bt_ctf_field_put(cpu_field); 73290e129ffSSebastian Andrzej Siewior if (stream) 73390e129ffSSebastian Andrzej Siewior bt_ctf_stream_put(stream); 73490e129ffSSebastian Andrzej Siewior 73590e129ffSSebastian Andrzej Siewior free(cs); 73690e129ffSSebastian Andrzej Siewior return NULL; 73790e129ffSSebastian Andrzej Siewior } 73890e129ffSSebastian Andrzej Siewior 73990e129ffSSebastian Andrzej Siewior static void ctf_stream__delete(struct ctf_stream *cs) 74090e129ffSSebastian Andrzej Siewior { 74190e129ffSSebastian Andrzej Siewior if (cs) { 74290e129ffSSebastian Andrzej Siewior bt_ctf_stream_put(cs->stream); 74390e129ffSSebastian Andrzej Siewior free(cs); 74490e129ffSSebastian Andrzej Siewior } 74590e129ffSSebastian Andrzej Siewior } 74690e129ffSSebastian Andrzej Siewior 74790e129ffSSebastian Andrzej Siewior static struct ctf_stream *ctf_stream(struct ctf_writer *cw, int cpu) 74890e129ffSSebastian Andrzej Siewior { 74990e129ffSSebastian Andrzej Siewior struct ctf_stream *cs = cw->stream[cpu]; 75090e129ffSSebastian Andrzej Siewior 75190e129ffSSebastian Andrzej Siewior if (!cs) { 75290e129ffSSebastian Andrzej Siewior cs = ctf_stream__create(cw, cpu); 75390e129ffSSebastian Andrzej Siewior cw->stream[cpu] = cs; 75490e129ffSSebastian Andrzej Siewior } 75590e129ffSSebastian Andrzej Siewior 75690e129ffSSebastian Andrzej Siewior return cs; 75790e129ffSSebastian Andrzej Siewior } 75890e129ffSSebastian Andrzej Siewior 75990e129ffSSebastian Andrzej Siewior static int get_sample_cpu(struct ctf_writer *cw, struct perf_sample *sample, 76032dcd021SJiri Olsa struct evsel *evsel) 76190e129ffSSebastian Andrzej Siewior { 76290e129ffSSebastian Andrzej Siewior int cpu = 0; 76390e129ffSSebastian Andrzej Siewior 7641fc632ceSJiri Olsa if (evsel->core.attr.sample_type & PERF_SAMPLE_CPU) 76590e129ffSSebastian Andrzej Siewior cpu = sample->cpu; 76690e129ffSSebastian Andrzej Siewior 76790e129ffSSebastian Andrzej Siewior if (cpu > cw->stream_cnt) { 76890e129ffSSebastian Andrzej Siewior pr_err("Event was recorded for CPU %d, limit is at %d.\n", 76990e129ffSSebastian Andrzej Siewior cpu, cw->stream_cnt); 77090e129ffSSebastian Andrzej Siewior cpu = 0; 77190e129ffSSebastian Andrzej Siewior } 77290e129ffSSebastian Andrzej Siewior 77390e129ffSSebastian Andrzej Siewior return cpu; 77490e129ffSSebastian Andrzej Siewior } 77590e129ffSSebastian Andrzej Siewior 77689e5fa88SJiri Olsa #define STREAM_FLUSH_COUNT 100000 77789e5fa88SJiri Olsa 77889e5fa88SJiri Olsa /* 77989e5fa88SJiri Olsa * Currently we have no other way to determine the 78089e5fa88SJiri Olsa * time for the stream flush other than keep track 78189e5fa88SJiri Olsa * of the number of events and check it against 78289e5fa88SJiri Olsa * threshold. 78389e5fa88SJiri Olsa */ 78489e5fa88SJiri Olsa static bool is_flush_needed(struct ctf_stream *cs) 78589e5fa88SJiri Olsa { 78689e5fa88SJiri Olsa return cs->count >= STREAM_FLUSH_COUNT; 78789e5fa88SJiri Olsa } 78889e5fa88SJiri Olsa 789edbe9817SJiri Olsa static int process_sample_event(struct perf_tool *tool, 790b8f8eb84SArnaldo Carvalho de Melo union perf_event *_event, 791edbe9817SJiri Olsa struct perf_sample *sample, 79232dcd021SJiri Olsa struct evsel *evsel, 793edbe9817SJiri Olsa struct machine *machine __maybe_unused) 794edbe9817SJiri Olsa { 795edbe9817SJiri Olsa struct convert *c = container_of(tool, struct convert, tool); 796edbe9817SJiri Olsa struct evsel_priv *priv = evsel->priv; 797edbe9817SJiri Olsa struct ctf_writer *cw = &c->writer; 79890e129ffSSebastian Andrzej Siewior struct ctf_stream *cs; 799edbe9817SJiri Olsa struct bt_ctf_event_class *event_class; 800edbe9817SJiri Olsa struct bt_ctf_event *event; 801edbe9817SJiri Olsa int ret; 8021fc632ceSJiri Olsa unsigned long type = evsel->core.attr.sample_type; 803edbe9817SJiri Olsa 804edbe9817SJiri Olsa if (WARN_ONCE(!priv, "Failed to setup all events.\n")) 805edbe9817SJiri Olsa return 0; 806edbe9817SJiri Olsa 807edbe9817SJiri Olsa event_class = priv->event_class; 808edbe9817SJiri Olsa 809edbe9817SJiri Olsa /* update stats */ 810edbe9817SJiri Olsa c->events_count++; 811edbe9817SJiri Olsa c->events_size += _event->header.size; 812edbe9817SJiri Olsa 813edbe9817SJiri Olsa pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count); 814edbe9817SJiri Olsa 815edbe9817SJiri Olsa event = bt_ctf_event_create(event_class); 816edbe9817SJiri Olsa if (!event) { 817edbe9817SJiri Olsa pr_err("Failed to create an CTF event\n"); 818edbe9817SJiri Olsa return -1; 819edbe9817SJiri Olsa } 820edbe9817SJiri Olsa 821edbe9817SJiri Olsa bt_ctf_clock_set_time(cw->clock, sample->time); 822edbe9817SJiri Olsa 823edbe9817SJiri Olsa ret = add_generic_values(cw, event, evsel, sample); 824edbe9817SJiri Olsa if (ret) 825edbe9817SJiri Olsa return -1; 826edbe9817SJiri Olsa 8271fc632ceSJiri Olsa if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) { 82869364727SSebastian Andrzej Siewior ret = add_tracepoint_values(cw, event_class, event, 82969364727SSebastian Andrzej Siewior evsel, sample); 83069364727SSebastian Andrzej Siewior if (ret) 83169364727SSebastian Andrzej Siewior return -1; 83269364727SSebastian Andrzej Siewior } 83369364727SSebastian Andrzej Siewior 834a3073c8eSGeneviève Bastien if (type & PERF_SAMPLE_CALLCHAIN) { 835a3073c8eSGeneviève Bastien ret = add_callchain_output_values(event_class, 836a3073c8eSGeneviève Bastien event, sample->callchain); 837a3073c8eSGeneviève Bastien if (ret) 838a3073c8eSGeneviève Bastien return -1; 839a3073c8eSGeneviève Bastien } 840a3073c8eSGeneviève Bastien 841c754c382SArnaldo Carvalho de Melo if (evsel__is_bpf_output(evsel)) { 8426122d57eSWang Nan ret = add_bpf_output_values(event_class, event, sample); 8436122d57eSWang Nan if (ret) 8446122d57eSWang Nan return -1; 8456122d57eSWang Nan } 8466122d57eSWang Nan 84790e129ffSSebastian Andrzej Siewior cs = ctf_stream(cw, get_sample_cpu(cw, sample, evsel)); 84889e5fa88SJiri Olsa if (cs) { 84989e5fa88SJiri Olsa if (is_flush_needed(cs)) 85089e5fa88SJiri Olsa ctf_stream__flush(cs); 85189e5fa88SJiri Olsa 85289e5fa88SJiri Olsa cs->count++; 85390e129ffSSebastian Andrzej Siewior bt_ctf_stream_append_event(cs->stream, event); 85489e5fa88SJiri Olsa } 85590e129ffSSebastian Andrzej Siewior 856edbe9817SJiri Olsa bt_ctf_event_put(event); 85790e129ffSSebastian Andrzej Siewior return cs ? 0 : -1; 858edbe9817SJiri Olsa } 859edbe9817SJiri Olsa 860f5a08cedSWang Nan #define __NON_SAMPLE_SET_FIELD(_name, _type, _field) \ 861f5a08cedSWang Nan do { \ 862f5a08cedSWang Nan ret = value_set_##_type(cw, event, #_field, _event->_name._field);\ 863f5a08cedSWang Nan if (ret) \ 864f5a08cedSWang Nan return -1; \ 865f5a08cedSWang Nan } while(0) 866f5a08cedSWang Nan 867f5a08cedSWang Nan #define __FUNC_PROCESS_NON_SAMPLE(_name, body) \ 868f5a08cedSWang Nan static int process_##_name##_event(struct perf_tool *tool, \ 869f5a08cedSWang Nan union perf_event *_event, \ 870f5a08cedSWang Nan struct perf_sample *sample, \ 871f5a08cedSWang Nan struct machine *machine) \ 872f5a08cedSWang Nan { \ 873f5a08cedSWang Nan struct convert *c = container_of(tool, struct convert, tool);\ 874f5a08cedSWang Nan struct ctf_writer *cw = &c->writer; \ 875f5a08cedSWang Nan struct bt_ctf_event_class *event_class = cw->_name##_class;\ 876f5a08cedSWang Nan struct bt_ctf_event *event; \ 877f5a08cedSWang Nan struct ctf_stream *cs; \ 878f5a08cedSWang Nan int ret; \ 879f5a08cedSWang Nan \ 880f5a08cedSWang Nan c->non_sample_count++; \ 881f5a08cedSWang Nan c->events_size += _event->header.size; \ 882f5a08cedSWang Nan event = bt_ctf_event_create(event_class); \ 883f5a08cedSWang Nan if (!event) { \ 884f5a08cedSWang Nan pr_err("Failed to create an CTF event\n"); \ 885f5a08cedSWang Nan return -1; \ 886f5a08cedSWang Nan } \ 887f5a08cedSWang Nan \ 888f5a08cedSWang Nan bt_ctf_clock_set_time(cw->clock, sample->time); \ 889f5a08cedSWang Nan body \ 890f5a08cedSWang Nan cs = ctf_stream(cw, 0); \ 891f5a08cedSWang Nan if (cs) { \ 892f5a08cedSWang Nan if (is_flush_needed(cs)) \ 893f5a08cedSWang Nan ctf_stream__flush(cs); \ 894f5a08cedSWang Nan \ 895f5a08cedSWang Nan cs->count++; \ 896f5a08cedSWang Nan bt_ctf_stream_append_event(cs->stream, event); \ 897f5a08cedSWang Nan } \ 898f5a08cedSWang Nan bt_ctf_event_put(event); \ 899f5a08cedSWang Nan \ 900f5a08cedSWang Nan return perf_event__process_##_name(tool, _event, sample, machine);\ 901f5a08cedSWang Nan } 902f5a08cedSWang Nan 903f5a08cedSWang Nan __FUNC_PROCESS_NON_SAMPLE(comm, 904f5a08cedSWang Nan __NON_SAMPLE_SET_FIELD(comm, u32, pid); 905f5a08cedSWang Nan __NON_SAMPLE_SET_FIELD(comm, u32, tid); 906f5a08cedSWang Nan __NON_SAMPLE_SET_FIELD(comm, string, comm); 907f5a08cedSWang Nan ) 908ebccba3fSWang Nan __FUNC_PROCESS_NON_SAMPLE(fork, 909ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, pid); 910ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, ppid); 911ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, tid); 912ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, ptid); 913ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u64, time); 914ebccba3fSWang Nan ) 915ebccba3fSWang Nan 916ebccba3fSWang Nan __FUNC_PROCESS_NON_SAMPLE(exit, 917ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, pid); 918ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, ppid); 919ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, tid); 920ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u32, ptid); 921ebccba3fSWang Nan __NON_SAMPLE_SET_FIELD(fork, u64, time); 922ebccba3fSWang Nan ) 923f9f6f2a9SGeneviève Bastien __FUNC_PROCESS_NON_SAMPLE(mmap, 924f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap, u32, pid); 925f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap, u32, tid); 926f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap, u64_hex, start); 927f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap, string, filename); 928f9f6f2a9SGeneviève Bastien ) 929f9f6f2a9SGeneviève Bastien __FUNC_PROCESS_NON_SAMPLE(mmap2, 930f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap2, u32, pid); 931f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap2, u32, tid); 932f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap2, u64_hex, start); 933f9f6f2a9SGeneviève Bastien __NON_SAMPLE_SET_FIELD(mmap2, string, filename); 934f9f6f2a9SGeneviève Bastien ) 935f5a08cedSWang Nan #undef __NON_SAMPLE_SET_FIELD 936f5a08cedSWang Nan #undef __FUNC_PROCESS_NON_SAMPLE 937f5a08cedSWang Nan 938e0a7cce5SWang Nan /* If dup < 0, add a prefix. Else, add _dupl_X suffix. */ 939e0a7cce5SWang Nan static char *change_name(char *name, char *orig_name, int dup) 940e0a7cce5SWang Nan { 941e0a7cce5SWang Nan char *new_name = NULL; 942e0a7cce5SWang Nan size_t len; 943e0a7cce5SWang Nan 944e0a7cce5SWang Nan if (!name) 945e0a7cce5SWang Nan name = orig_name; 946e0a7cce5SWang Nan 947e0a7cce5SWang Nan if (dup >= 10) 948e0a7cce5SWang Nan goto out; 949e0a7cce5SWang Nan /* 950e0a7cce5SWang Nan * Add '_' prefix to potential keywork. According to 9516edfd0ebSKees Cook * Mathieu Desnoyers (https://lore.kernel.org/lkml/1074266107.40857.1422045946295.JavaMail.zimbra@efficios.com), 9524d39c89fSIngo Molnar * further CTF spec updating may require us to use '$'. 953e0a7cce5SWang Nan */ 954e0a7cce5SWang Nan if (dup < 0) 955e0a7cce5SWang Nan len = strlen(name) + sizeof("_"); 956e0a7cce5SWang Nan else 957e0a7cce5SWang Nan len = strlen(orig_name) + sizeof("_dupl_X"); 958e0a7cce5SWang Nan 959e0a7cce5SWang Nan new_name = malloc(len); 960e0a7cce5SWang Nan if (!new_name) 961e0a7cce5SWang Nan goto out; 962e0a7cce5SWang Nan 963e0a7cce5SWang Nan if (dup < 0) 964e0a7cce5SWang Nan snprintf(new_name, len, "_%s", name); 965e0a7cce5SWang Nan else 966e0a7cce5SWang Nan snprintf(new_name, len, "%s_dupl_%d", orig_name, dup); 967e0a7cce5SWang Nan 968e0a7cce5SWang Nan out: 969e0a7cce5SWang Nan if (name != orig_name) 970e0a7cce5SWang Nan free(name); 971e0a7cce5SWang Nan return new_name; 972e0a7cce5SWang Nan } 973e0a7cce5SWang Nan 974e0a7cce5SWang Nan static int event_class_add_field(struct bt_ctf_event_class *event_class, 975e0a7cce5SWang Nan struct bt_ctf_field_type *type, 9762c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *field) 977e0a7cce5SWang Nan { 978e0a7cce5SWang Nan struct bt_ctf_field_type *t = NULL; 979e0a7cce5SWang Nan char *name; 980e0a7cce5SWang Nan int dup = 1; 981e0a7cce5SWang Nan int ret; 982e0a7cce5SWang Nan 983e0a7cce5SWang Nan /* alias was already assigned */ 984e0a7cce5SWang Nan if (field->alias != field->name) 985e0a7cce5SWang Nan return bt_ctf_event_class_add_field(event_class, type, 986e0a7cce5SWang Nan (char *)field->alias); 987e0a7cce5SWang Nan 988e0a7cce5SWang Nan name = field->name; 989e0a7cce5SWang Nan 990e0a7cce5SWang Nan /* If 'name' is a keywork, add prefix. */ 991e0a7cce5SWang Nan if (bt_ctf_validate_identifier(name)) 992e0a7cce5SWang Nan name = change_name(name, field->name, -1); 993e0a7cce5SWang Nan 994e0a7cce5SWang Nan if (!name) { 995e0a7cce5SWang Nan pr_err("Failed to fix invalid identifier."); 996e0a7cce5SWang Nan return -1; 997e0a7cce5SWang Nan } 998e0a7cce5SWang Nan while ((t = bt_ctf_event_class_get_field_by_name(event_class, name))) { 999e0a7cce5SWang Nan bt_ctf_field_type_put(t); 1000e0a7cce5SWang Nan name = change_name(name, field->name, dup++); 1001e0a7cce5SWang Nan if (!name) { 1002e0a7cce5SWang Nan pr_err("Failed to create dup name for '%s'\n", field->name); 1003e0a7cce5SWang Nan return -1; 1004e0a7cce5SWang Nan } 1005e0a7cce5SWang Nan } 1006e0a7cce5SWang Nan 1007e0a7cce5SWang Nan ret = bt_ctf_event_class_add_field(event_class, type, name); 1008e0a7cce5SWang Nan if (!ret) 1009e0a7cce5SWang Nan field->alias = name; 1010e0a7cce5SWang Nan 1011e0a7cce5SWang Nan return ret; 1012e0a7cce5SWang Nan } 1013e0a7cce5SWang Nan 101469364727SSebastian Andrzej Siewior static int add_tracepoint_fields_types(struct ctf_writer *cw, 10152c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *fields, 101669364727SSebastian Andrzej Siewior struct bt_ctf_event_class *event_class) 101769364727SSebastian Andrzej Siewior { 10182c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *field; 101969364727SSebastian Andrzej Siewior int ret; 102069364727SSebastian Andrzej Siewior 102169364727SSebastian Andrzej Siewior for (field = fields; field; field = field->next) { 102269364727SSebastian Andrzej Siewior struct bt_ctf_field_type *type; 102369364727SSebastian Andrzej Siewior unsigned long flags = field->flags; 102469364727SSebastian Andrzej Siewior 102569364727SSebastian Andrzej Siewior pr2(" field '%s'\n", field->name); 102669364727SSebastian Andrzej Siewior 102769364727SSebastian Andrzej Siewior type = get_tracepoint_field_type(cw, field); 102869364727SSebastian Andrzej Siewior if (!type) 102969364727SSebastian Andrzej Siewior return -1; 103069364727SSebastian Andrzej Siewior 103169364727SSebastian Andrzej Siewior /* 103269364727SSebastian Andrzej Siewior * A string is an array of chars. For this we use the string 103369364727SSebastian Andrzej Siewior * type and don't care that it is an array. What we don't 103469364727SSebastian Andrzej Siewior * support is an array of strings. 103569364727SSebastian Andrzej Siewior */ 1036bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_STRING) 1037bb39ccb2STzvetomir Stoyanov (VMware) flags &= ~TEP_FIELD_IS_ARRAY; 103869364727SSebastian Andrzej Siewior 1039bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_ARRAY) 104069364727SSebastian Andrzej Siewior type = bt_ctf_field_type_array_create(type, field->arraylen); 104169364727SSebastian Andrzej Siewior 1042e0a7cce5SWang Nan ret = event_class_add_field(event_class, type, field); 104369364727SSebastian Andrzej Siewior 1044bb39ccb2STzvetomir Stoyanov (VMware) if (flags & TEP_FIELD_IS_ARRAY) 104569364727SSebastian Andrzej Siewior bt_ctf_field_type_put(type); 104669364727SSebastian Andrzej Siewior 104769364727SSebastian Andrzej Siewior if (ret) { 1048e0a7cce5SWang Nan pr_err("Failed to add field '%s': %d\n", 1049e0a7cce5SWang Nan field->name, ret); 105069364727SSebastian Andrzej Siewior return -1; 105169364727SSebastian Andrzej Siewior } 105269364727SSebastian Andrzej Siewior } 105369364727SSebastian Andrzej Siewior 105469364727SSebastian Andrzej Siewior return 0; 105569364727SSebastian Andrzej Siewior } 105669364727SSebastian Andrzej Siewior 105769364727SSebastian Andrzej Siewior static int add_tracepoint_types(struct ctf_writer *cw, 105832dcd021SJiri Olsa struct evsel *evsel, 105969364727SSebastian Andrzej Siewior struct bt_ctf_event_class *class) 106069364727SSebastian Andrzej Siewior { 10612c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *common_fields = evsel->tp_format->format.common_fields; 10622c92f982STzvetomir Stoyanov (VMware) struct tep_format_field *fields = evsel->tp_format->format.fields; 106369364727SSebastian Andrzej Siewior int ret; 106469364727SSebastian Andrzej Siewior 106569364727SSebastian Andrzej Siewior ret = add_tracepoint_fields_types(cw, common_fields, class); 106669364727SSebastian Andrzej Siewior if (!ret) 106769364727SSebastian Andrzej Siewior ret = add_tracepoint_fields_types(cw, fields, class); 106869364727SSebastian Andrzej Siewior 106969364727SSebastian Andrzej Siewior return ret; 107069364727SSebastian Andrzej Siewior } 107169364727SSebastian Andrzej Siewior 10726122d57eSWang Nan static int add_bpf_output_types(struct ctf_writer *cw, 10736122d57eSWang Nan struct bt_ctf_event_class *class) 10746122d57eSWang Nan { 10756122d57eSWang Nan struct bt_ctf_field_type *len_type = cw->data.u32; 10766122d57eSWang Nan struct bt_ctf_field_type *seq_base_type = cw->data.u32_hex; 10776122d57eSWang Nan struct bt_ctf_field_type *seq_type; 10786122d57eSWang Nan int ret; 10796122d57eSWang Nan 10806122d57eSWang Nan ret = bt_ctf_event_class_add_field(class, len_type, "raw_len"); 10816122d57eSWang Nan if (ret) 10826122d57eSWang Nan return ret; 10836122d57eSWang Nan 10846122d57eSWang Nan seq_type = bt_ctf_field_type_sequence_create(seq_base_type, "raw_len"); 10856122d57eSWang Nan if (!seq_type) 10866122d57eSWang Nan return -1; 10876122d57eSWang Nan 10886122d57eSWang Nan return bt_ctf_event_class_add_field(class, seq_type, "raw_data"); 10896122d57eSWang Nan } 10906122d57eSWang Nan 109132dcd021SJiri Olsa static int add_generic_types(struct ctf_writer *cw, struct evsel *evsel, 1092edbe9817SJiri Olsa struct bt_ctf_event_class *event_class) 1093edbe9817SJiri Olsa { 10941fc632ceSJiri Olsa u64 type = evsel->core.attr.sample_type; 1095edbe9817SJiri Olsa 1096edbe9817SJiri Olsa /* 1097edbe9817SJiri Olsa * missing: 1098edbe9817SJiri Olsa * PERF_SAMPLE_TIME - not needed as we have it in 1099edbe9817SJiri Olsa * ctf event header 1100edbe9817SJiri Olsa * PERF_SAMPLE_READ - TODO 1101edbe9817SJiri Olsa * PERF_SAMPLE_CALLCHAIN - TODO 11026122d57eSWang Nan * PERF_SAMPLE_RAW - tracepoint fields and BPF output 11036122d57eSWang Nan * are handled separately 1104edbe9817SJiri Olsa * PERF_SAMPLE_BRANCH_STACK - TODO 1105edbe9817SJiri Olsa * PERF_SAMPLE_REGS_USER - TODO 1106edbe9817SJiri Olsa * PERF_SAMPLE_STACK_USER - TODO 1107edbe9817SJiri Olsa */ 1108edbe9817SJiri Olsa 1109edbe9817SJiri Olsa #define ADD_FIELD(cl, t, n) \ 1110edbe9817SJiri Olsa do { \ 1111edbe9817SJiri Olsa pr2(" field '%s'\n", n); \ 1112edbe9817SJiri Olsa if (bt_ctf_event_class_add_field(cl, t, n)) { \ 1113e0a7cce5SWang Nan pr_err("Failed to add field '%s';\n", n); \ 1114edbe9817SJiri Olsa return -1; \ 1115edbe9817SJiri Olsa } \ 1116edbe9817SJiri Olsa } while (0) 1117edbe9817SJiri Olsa 1118edbe9817SJiri Olsa if (type & PERF_SAMPLE_IP) 111954cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64_hex, "perf_ip"); 1120edbe9817SJiri Olsa 1121edbe9817SJiri Olsa if (type & PERF_SAMPLE_TID) { 112254cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.s32, "perf_tid"); 112354cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.s32, "perf_pid"); 1124edbe9817SJiri Olsa } 1125edbe9817SJiri Olsa 1126edbe9817SJiri Olsa if ((type & PERF_SAMPLE_ID) || 1127edbe9817SJiri Olsa (type & PERF_SAMPLE_IDENTIFIER)) 112854cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_id"); 1129edbe9817SJiri Olsa 1130edbe9817SJiri Olsa if (type & PERF_SAMPLE_STREAM_ID) 113154cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_stream_id"); 1132edbe9817SJiri Olsa 1133edbe9817SJiri Olsa if (type & PERF_SAMPLE_PERIOD) 113454cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_period"); 1135edbe9817SJiri Olsa 1136edbe9817SJiri Olsa if (type & PERF_SAMPLE_WEIGHT) 113754cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_weight"); 1138edbe9817SJiri Olsa 1139edbe9817SJiri Olsa if (type & PERF_SAMPLE_DATA_SRC) 114054cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_data_src"); 1141edbe9817SJiri Olsa 1142edbe9817SJiri Olsa if (type & PERF_SAMPLE_TRANSACTION) 114354cf776aSSebastian Andrzej Siewior ADD_FIELD(event_class, cw->data.u64, "perf_transaction"); 1144edbe9817SJiri Olsa 1145a3073c8eSGeneviève Bastien if (type & PERF_SAMPLE_CALLCHAIN) { 1146a3073c8eSGeneviève Bastien ADD_FIELD(event_class, cw->data.u32, "perf_callchain_size"); 1147a3073c8eSGeneviève Bastien ADD_FIELD(event_class, 1148a3073c8eSGeneviève Bastien bt_ctf_field_type_sequence_create( 1149a3073c8eSGeneviève Bastien cw->data.u64_hex, "perf_callchain_size"), 1150a3073c8eSGeneviève Bastien "perf_callchain"); 1151a3073c8eSGeneviève Bastien } 1152a3073c8eSGeneviève Bastien 1153edbe9817SJiri Olsa #undef ADD_FIELD 1154edbe9817SJiri Olsa return 0; 1155edbe9817SJiri Olsa } 1156edbe9817SJiri Olsa 115732dcd021SJiri Olsa static int add_event(struct ctf_writer *cw, struct evsel *evsel) 1158edbe9817SJiri Olsa { 1159edbe9817SJiri Olsa struct bt_ctf_event_class *event_class; 1160edbe9817SJiri Olsa struct evsel_priv *priv; 11618ab2e96dSArnaldo Carvalho de Melo const char *name = evsel__name(evsel); 1162edbe9817SJiri Olsa int ret; 1163edbe9817SJiri Olsa 11641fc632ceSJiri Olsa pr("Adding event '%s' (type %d)\n", name, evsel->core.attr.type); 1165edbe9817SJiri Olsa 1166edbe9817SJiri Olsa event_class = bt_ctf_event_class_create(name); 1167edbe9817SJiri Olsa if (!event_class) 1168edbe9817SJiri Olsa return -1; 1169edbe9817SJiri Olsa 1170edbe9817SJiri Olsa ret = add_generic_types(cw, evsel, event_class); 1171edbe9817SJiri Olsa if (ret) 1172edbe9817SJiri Olsa goto err; 1173edbe9817SJiri Olsa 11741fc632ceSJiri Olsa if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) { 117569364727SSebastian Andrzej Siewior ret = add_tracepoint_types(cw, evsel, event_class); 117669364727SSebastian Andrzej Siewior if (ret) 117769364727SSebastian Andrzej Siewior goto err; 117869364727SSebastian Andrzej Siewior } 117969364727SSebastian Andrzej Siewior 1180c754c382SArnaldo Carvalho de Melo if (evsel__is_bpf_output(evsel)) { 11816122d57eSWang Nan ret = add_bpf_output_types(cw, event_class); 11826122d57eSWang Nan if (ret) 11836122d57eSWang Nan goto err; 11846122d57eSWang Nan } 11856122d57eSWang Nan 1186edbe9817SJiri Olsa ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class); 1187edbe9817SJiri Olsa if (ret) { 1188edbe9817SJiri Olsa pr("Failed to add event class into stream.\n"); 1189edbe9817SJiri Olsa goto err; 1190edbe9817SJiri Olsa } 1191edbe9817SJiri Olsa 1192edbe9817SJiri Olsa priv = malloc(sizeof(*priv)); 1193edbe9817SJiri Olsa if (!priv) 1194edbe9817SJiri Olsa goto err; 1195edbe9817SJiri Olsa 1196edbe9817SJiri Olsa priv->event_class = event_class; 1197edbe9817SJiri Olsa evsel->priv = priv; 1198edbe9817SJiri Olsa return 0; 1199edbe9817SJiri Olsa 1200edbe9817SJiri Olsa err: 1201edbe9817SJiri Olsa bt_ctf_event_class_put(event_class); 1202edbe9817SJiri Olsa pr_err("Failed to add event '%s'.\n", name); 1203edbe9817SJiri Olsa return -1; 1204edbe9817SJiri Olsa } 1205edbe9817SJiri Olsa 1206edbe9817SJiri Olsa static int setup_events(struct ctf_writer *cw, struct perf_session *session) 1207edbe9817SJiri Olsa { 120863503dbaSJiri Olsa struct evlist *evlist = session->evlist; 120932dcd021SJiri Olsa struct evsel *evsel; 1210edbe9817SJiri Olsa int ret; 1211edbe9817SJiri Olsa 1212e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evlist, evsel) { 1213edbe9817SJiri Olsa ret = add_event(cw, evsel); 1214edbe9817SJiri Olsa if (ret) 1215edbe9817SJiri Olsa return ret; 1216edbe9817SJiri Olsa } 1217edbe9817SJiri Olsa return 0; 1218edbe9817SJiri Olsa } 1219edbe9817SJiri Olsa 1220f5a08cedSWang Nan #define __NON_SAMPLE_ADD_FIELD(t, n) \ 1221f5a08cedSWang Nan do { \ 1222f5a08cedSWang Nan pr2(" field '%s'\n", #n); \ 1223f5a08cedSWang Nan if (bt_ctf_event_class_add_field(event_class, cw->data.t, #n)) {\ 1224f5a08cedSWang Nan pr_err("Failed to add field '%s';\n", #n);\ 1225f5a08cedSWang Nan return -1; \ 1226f5a08cedSWang Nan } \ 1227f5a08cedSWang Nan } while(0) 1228f5a08cedSWang Nan 1229f5a08cedSWang Nan #define __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(_name, body) \ 1230f5a08cedSWang Nan static int add_##_name##_event(struct ctf_writer *cw) \ 1231f5a08cedSWang Nan { \ 1232f5a08cedSWang Nan struct bt_ctf_event_class *event_class; \ 1233f5a08cedSWang Nan int ret; \ 1234f5a08cedSWang Nan \ 1235f5a08cedSWang Nan pr("Adding "#_name" event\n"); \ 1236f5a08cedSWang Nan event_class = bt_ctf_event_class_create("perf_" #_name);\ 1237f5a08cedSWang Nan if (!event_class) \ 1238f5a08cedSWang Nan return -1; \ 1239f5a08cedSWang Nan body \ 1240f5a08cedSWang Nan \ 1241f5a08cedSWang Nan ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);\ 1242f5a08cedSWang Nan if (ret) { \ 1243f5a08cedSWang Nan pr("Failed to add event class '"#_name"' into stream.\n");\ 1244f5a08cedSWang Nan return ret; \ 1245f5a08cedSWang Nan } \ 1246f5a08cedSWang Nan \ 1247f5a08cedSWang Nan cw->_name##_class = event_class; \ 1248f5a08cedSWang Nan bt_ctf_event_class_put(event_class); \ 1249f5a08cedSWang Nan return 0; \ 1250f5a08cedSWang Nan } 1251f5a08cedSWang Nan 1252f5a08cedSWang Nan __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(comm, 1253f5a08cedSWang Nan __NON_SAMPLE_ADD_FIELD(u32, pid); 1254f5a08cedSWang Nan __NON_SAMPLE_ADD_FIELD(u32, tid); 1255f5a08cedSWang Nan __NON_SAMPLE_ADD_FIELD(string, comm); 1256f5a08cedSWang Nan ) 1257f5a08cedSWang Nan 1258ebccba3fSWang Nan __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(fork, 1259ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, pid); 1260ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, ppid); 1261ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, tid); 1262ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, ptid); 1263ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u64, time); 1264ebccba3fSWang Nan ) 1265ebccba3fSWang Nan 1266ebccba3fSWang Nan __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(exit, 1267ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, pid); 1268ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, ppid); 1269ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, tid); 1270ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u32, ptid); 1271ebccba3fSWang Nan __NON_SAMPLE_ADD_FIELD(u64, time); 1272ebccba3fSWang Nan ) 1273ebccba3fSWang Nan 1274f9f6f2a9SGeneviève Bastien __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap, 1275f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u32, pid); 1276f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u32, tid); 1277f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u64_hex, start); 1278f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(string, filename); 1279f9f6f2a9SGeneviève Bastien ) 1280f9f6f2a9SGeneviève Bastien 1281f9f6f2a9SGeneviève Bastien __FUNC_ADD_NON_SAMPLE_EVENT_CLASS(mmap2, 1282f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u32, pid); 1283f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u32, tid); 1284f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(u64_hex, start); 1285f9f6f2a9SGeneviève Bastien __NON_SAMPLE_ADD_FIELD(string, filename); 1286f9f6f2a9SGeneviève Bastien ) 1287f5a08cedSWang Nan #undef __NON_SAMPLE_ADD_FIELD 1288f5a08cedSWang Nan #undef __FUNC_ADD_NON_SAMPLE_EVENT_CLASS 1289f5a08cedSWang Nan 1290f5a08cedSWang Nan static int setup_non_sample_events(struct ctf_writer *cw, 1291f5a08cedSWang Nan struct perf_session *session __maybe_unused) 1292f5a08cedSWang Nan { 1293f5a08cedSWang Nan int ret; 1294f5a08cedSWang Nan 1295f5a08cedSWang Nan ret = add_comm_event(cw); 1296f5a08cedSWang Nan if (ret) 1297f5a08cedSWang Nan return ret; 1298ebccba3fSWang Nan ret = add_exit_event(cw); 1299ebccba3fSWang Nan if (ret) 1300ebccba3fSWang Nan return ret; 1301ebccba3fSWang Nan ret = add_fork_event(cw); 1302ebccba3fSWang Nan if (ret) 1303ebccba3fSWang Nan return ret; 1304f9f6f2a9SGeneviève Bastien ret = add_mmap_event(cw); 1305f9f6f2a9SGeneviève Bastien if (ret) 1306f9f6f2a9SGeneviève Bastien return ret; 1307f9f6f2a9SGeneviève Bastien ret = add_mmap2_event(cw); 1308f9f6f2a9SGeneviève Bastien if (ret) 1309f9f6f2a9SGeneviève Bastien return ret; 1310f5a08cedSWang Nan return 0; 1311f5a08cedSWang Nan } 1312f5a08cedSWang Nan 13135141d735SWang Nan static void cleanup_events(struct perf_session *session) 13145141d735SWang Nan { 131563503dbaSJiri Olsa struct evlist *evlist = session->evlist; 131632dcd021SJiri Olsa struct evsel *evsel; 13175141d735SWang Nan 1318e5cadb93SArnaldo Carvalho de Melo evlist__for_each_entry(evlist, evsel) { 13195141d735SWang Nan struct evsel_priv *priv; 13205141d735SWang Nan 13215141d735SWang Nan priv = evsel->priv; 13225141d735SWang Nan bt_ctf_event_class_put(priv->event_class); 13235141d735SWang Nan zfree(&evsel->priv); 13245141d735SWang Nan } 13255141d735SWang Nan 1326c12995a5SJiri Olsa evlist__delete(evlist); 13275141d735SWang Nan session->evlist = NULL; 13285141d735SWang Nan } 13295141d735SWang Nan 133090e129ffSSebastian Andrzej Siewior static int setup_streams(struct ctf_writer *cw, struct perf_session *session) 133190e129ffSSebastian Andrzej Siewior { 133290e129ffSSebastian Andrzej Siewior struct ctf_stream **stream; 133390e129ffSSebastian Andrzej Siewior struct perf_header *ph = &session->header; 133490e129ffSSebastian Andrzej Siewior int ncpus; 133590e129ffSSebastian Andrzej Siewior 133690e129ffSSebastian Andrzej Siewior /* 133790e129ffSSebastian Andrzej Siewior * Try to get the number of cpus used in the data file, 133890e129ffSSebastian Andrzej Siewior * if not present fallback to the MAX_CPUS. 133990e129ffSSebastian Andrzej Siewior */ 134090e129ffSSebastian Andrzej Siewior ncpus = ph->env.nr_cpus_avail ?: MAX_CPUS; 134190e129ffSSebastian Andrzej Siewior 134290e129ffSSebastian Andrzej Siewior stream = zalloc(sizeof(*stream) * ncpus); 134390e129ffSSebastian Andrzej Siewior if (!stream) { 134490e129ffSSebastian Andrzej Siewior pr_err("Failed to allocate streams.\n"); 134590e129ffSSebastian Andrzej Siewior return -ENOMEM; 134690e129ffSSebastian Andrzej Siewior } 134790e129ffSSebastian Andrzej Siewior 134890e129ffSSebastian Andrzej Siewior cw->stream = stream; 134990e129ffSSebastian Andrzej Siewior cw->stream_cnt = ncpus; 135090e129ffSSebastian Andrzej Siewior return 0; 135190e129ffSSebastian Andrzej Siewior } 135290e129ffSSebastian Andrzej Siewior 135390e129ffSSebastian Andrzej Siewior static void free_streams(struct ctf_writer *cw) 135490e129ffSSebastian Andrzej Siewior { 135590e129ffSSebastian Andrzej Siewior int cpu; 135690e129ffSSebastian Andrzej Siewior 135790e129ffSSebastian Andrzej Siewior for (cpu = 0; cpu < cw->stream_cnt; cpu++) 135890e129ffSSebastian Andrzej Siewior ctf_stream__delete(cw->stream[cpu]); 135990e129ffSSebastian Andrzej Siewior 1360d8f9da24SArnaldo Carvalho de Melo zfree(&cw->stream); 136190e129ffSSebastian Andrzej Siewior } 136290e129ffSSebastian Andrzej Siewior 1363edbe9817SJiri Olsa static int ctf_writer__setup_env(struct ctf_writer *cw, 1364edbe9817SJiri Olsa struct perf_session *session) 1365edbe9817SJiri Olsa { 1366edbe9817SJiri Olsa struct perf_header *header = &session->header; 1367edbe9817SJiri Olsa struct bt_ctf_writer *writer = cw->writer; 1368edbe9817SJiri Olsa 1369edbe9817SJiri Olsa #define ADD(__n, __v) \ 1370edbe9817SJiri Olsa do { \ 1371edbe9817SJiri Olsa if (bt_ctf_writer_add_environment_field(writer, __n, __v)) \ 1372edbe9817SJiri Olsa return -1; \ 1373edbe9817SJiri Olsa } while (0) 1374edbe9817SJiri Olsa 1375edbe9817SJiri Olsa ADD("host", header->env.hostname); 1376edbe9817SJiri Olsa ADD("sysname", "Linux"); 1377edbe9817SJiri Olsa ADD("release", header->env.os_release); 1378edbe9817SJiri Olsa ADD("version", header->env.version); 1379edbe9817SJiri Olsa ADD("machine", header->env.arch); 1380edbe9817SJiri Olsa ADD("domain", "kernel"); 1381edbe9817SJiri Olsa ADD("tracer_name", "perf"); 1382edbe9817SJiri Olsa 1383edbe9817SJiri Olsa #undef ADD 1384edbe9817SJiri Olsa return 0; 1385edbe9817SJiri Olsa } 1386edbe9817SJiri Olsa 138788371c58SJiri Olsa static int ctf_writer__setup_clock(struct ctf_writer *cw, 138888371c58SJiri Olsa struct perf_session *session, 138988371c58SJiri Olsa bool tod) 1390edbe9817SJiri Olsa { 1391edbe9817SJiri Olsa struct bt_ctf_clock *clock = cw->clock; 139288371c58SJiri Olsa const char *desc = "perf clock"; 139388371c58SJiri Olsa int64_t offset = 0; 1394edbe9817SJiri Olsa 139588371c58SJiri Olsa if (tod) { 139688371c58SJiri Olsa struct perf_env *env = &session->header.env; 139788371c58SJiri Olsa 139888371c58SJiri Olsa if (!env->clock.enabled) { 139988371c58SJiri Olsa pr_err("Can't provide --tod time, missing clock data. " 140088371c58SJiri Olsa "Please record with -k/--clockid option.\n"); 140188371c58SJiri Olsa return -1; 140288371c58SJiri Olsa } 140388371c58SJiri Olsa 140488371c58SJiri Olsa desc = clockid_name(env->clock.clockid); 140588371c58SJiri Olsa offset = env->clock.tod_ns - env->clock.clockid_ns; 140688371c58SJiri Olsa } 1407edbe9817SJiri Olsa 1408edbe9817SJiri Olsa #define SET(__n, __v) \ 1409edbe9817SJiri Olsa do { \ 1410edbe9817SJiri Olsa if (bt_ctf_clock_set_##__n(clock, __v)) \ 1411edbe9817SJiri Olsa return -1; \ 1412edbe9817SJiri Olsa } while (0) 1413edbe9817SJiri Olsa 1414edbe9817SJiri Olsa SET(frequency, 1000000000); 141588371c58SJiri Olsa SET(offset, offset); 141688371c58SJiri Olsa SET(description, desc); 1417edbe9817SJiri Olsa SET(precision, 10); 1418edbe9817SJiri Olsa SET(is_absolute, 0); 1419edbe9817SJiri Olsa 1420edbe9817SJiri Olsa #undef SET 1421edbe9817SJiri Olsa return 0; 1422edbe9817SJiri Olsa } 1423edbe9817SJiri Olsa 1424edbe9817SJiri Olsa static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex) 1425edbe9817SJiri Olsa { 1426edbe9817SJiri Olsa struct bt_ctf_field_type *type; 1427edbe9817SJiri Olsa 1428edbe9817SJiri Olsa type = bt_ctf_field_type_integer_create(size); 1429edbe9817SJiri Olsa if (!type) 1430edbe9817SJiri Olsa return NULL; 1431edbe9817SJiri Olsa 1432edbe9817SJiri Olsa if (sign && 1433edbe9817SJiri Olsa bt_ctf_field_type_integer_set_signed(type, 1)) 1434edbe9817SJiri Olsa goto err; 1435edbe9817SJiri Olsa 1436edbe9817SJiri Olsa if (hex && 1437edbe9817SJiri Olsa bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL)) 1438edbe9817SJiri Olsa goto err; 1439edbe9817SJiri Olsa 1440f8dd2d5fSWang Nan #if __BYTE_ORDER == __BIG_ENDIAN 1441f8dd2d5fSWang Nan bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_BIG_ENDIAN); 1442f8dd2d5fSWang Nan #else 1443f8dd2d5fSWang Nan bt_ctf_field_type_set_byte_order(type, BT_CTF_BYTE_ORDER_LITTLE_ENDIAN); 1444f8dd2d5fSWang Nan #endif 1445f8dd2d5fSWang Nan 1446edbe9817SJiri Olsa pr2("Created type: INTEGER %d-bit %ssigned %s\n", 1447edbe9817SJiri Olsa size, sign ? "un" : "", hex ? "hex" : ""); 1448edbe9817SJiri Olsa return type; 1449edbe9817SJiri Olsa 1450edbe9817SJiri Olsa err: 1451edbe9817SJiri Olsa bt_ctf_field_type_put(type); 1452edbe9817SJiri Olsa return NULL; 1453edbe9817SJiri Olsa } 1454edbe9817SJiri Olsa 1455edbe9817SJiri Olsa static void ctf_writer__cleanup_data(struct ctf_writer *cw) 1456edbe9817SJiri Olsa { 1457edbe9817SJiri Olsa unsigned int i; 1458edbe9817SJiri Olsa 1459edbe9817SJiri Olsa for (i = 0; i < ARRAY_SIZE(cw->data.array); i++) 1460edbe9817SJiri Olsa bt_ctf_field_type_put(cw->data.array[i]); 1461edbe9817SJiri Olsa } 1462edbe9817SJiri Olsa 1463edbe9817SJiri Olsa static int ctf_writer__init_data(struct ctf_writer *cw) 1464edbe9817SJiri Olsa { 1465edbe9817SJiri Olsa #define CREATE_INT_TYPE(type, size, sign, hex) \ 1466edbe9817SJiri Olsa do { \ 1467edbe9817SJiri Olsa (type) = create_int_type(size, sign, hex); \ 1468edbe9817SJiri Olsa if (!(type)) \ 1469edbe9817SJiri Olsa goto err; \ 1470edbe9817SJiri Olsa } while (0) 1471edbe9817SJiri Olsa 1472edbe9817SJiri Olsa CREATE_INT_TYPE(cw->data.s64, 64, true, false); 1473edbe9817SJiri Olsa CREATE_INT_TYPE(cw->data.u64, 64, false, false); 1474edbe9817SJiri Olsa CREATE_INT_TYPE(cw->data.s32, 32, true, false); 1475edbe9817SJiri Olsa CREATE_INT_TYPE(cw->data.u32, 32, false, false); 147626812d46SWang Nan CREATE_INT_TYPE(cw->data.u32_hex, 32, false, true); 1477edbe9817SJiri Olsa CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true); 1478edbe9817SJiri Olsa 1479edbe9817SJiri Olsa cw->data.string = bt_ctf_field_type_string_create(); 1480edbe9817SJiri Olsa if (cw->data.string) 1481edbe9817SJiri Olsa return 0; 1482edbe9817SJiri Olsa 1483edbe9817SJiri Olsa err: 1484edbe9817SJiri Olsa ctf_writer__cleanup_data(cw); 1485edbe9817SJiri Olsa pr_err("Failed to create data types.\n"); 1486edbe9817SJiri Olsa return -1; 1487edbe9817SJiri Olsa } 1488edbe9817SJiri Olsa 1489edbe9817SJiri Olsa static void ctf_writer__cleanup(struct ctf_writer *cw) 1490edbe9817SJiri Olsa { 1491edbe9817SJiri Olsa ctf_writer__cleanup_data(cw); 1492edbe9817SJiri Olsa 1493edbe9817SJiri Olsa bt_ctf_clock_put(cw->clock); 149490e129ffSSebastian Andrzej Siewior free_streams(cw); 1495edbe9817SJiri Olsa bt_ctf_stream_class_put(cw->stream_class); 1496edbe9817SJiri Olsa bt_ctf_writer_put(cw->writer); 1497edbe9817SJiri Olsa 1498edbe9817SJiri Olsa /* and NULL all the pointers */ 1499edbe9817SJiri Olsa memset(cw, 0, sizeof(*cw)); 1500edbe9817SJiri Olsa } 1501edbe9817SJiri Olsa 150288371c58SJiri Olsa static int ctf_writer__init(struct ctf_writer *cw, const char *path, 150388371c58SJiri Olsa struct perf_session *session, bool tod) 1504edbe9817SJiri Olsa { 1505edbe9817SJiri Olsa struct bt_ctf_writer *writer; 1506edbe9817SJiri Olsa struct bt_ctf_stream_class *stream_class; 1507edbe9817SJiri Olsa struct bt_ctf_clock *clock; 150890e129ffSSebastian Andrzej Siewior struct bt_ctf_field_type *pkt_ctx_type; 150990e129ffSSebastian Andrzej Siewior int ret; 1510edbe9817SJiri Olsa 1511edbe9817SJiri Olsa /* CTF writer */ 1512edbe9817SJiri Olsa writer = bt_ctf_writer_create(path); 1513edbe9817SJiri Olsa if (!writer) 1514edbe9817SJiri Olsa goto err; 1515edbe9817SJiri Olsa 1516edbe9817SJiri Olsa cw->writer = writer; 1517edbe9817SJiri Olsa 1518edbe9817SJiri Olsa /* CTF clock */ 1519edbe9817SJiri Olsa clock = bt_ctf_clock_create("perf_clock"); 1520edbe9817SJiri Olsa if (!clock) { 1521edbe9817SJiri Olsa pr("Failed to create CTF clock.\n"); 1522edbe9817SJiri Olsa goto err_cleanup; 1523edbe9817SJiri Olsa } 1524edbe9817SJiri Olsa 1525edbe9817SJiri Olsa cw->clock = clock; 1526edbe9817SJiri Olsa 152788371c58SJiri Olsa if (ctf_writer__setup_clock(cw, session, tod)) { 1528edbe9817SJiri Olsa pr("Failed to setup CTF clock.\n"); 1529edbe9817SJiri Olsa goto err_cleanup; 1530edbe9817SJiri Olsa } 1531edbe9817SJiri Olsa 1532edbe9817SJiri Olsa /* CTF stream class */ 1533edbe9817SJiri Olsa stream_class = bt_ctf_stream_class_create("perf_stream"); 1534edbe9817SJiri Olsa if (!stream_class) { 1535edbe9817SJiri Olsa pr("Failed to create CTF stream class.\n"); 1536edbe9817SJiri Olsa goto err_cleanup; 1537edbe9817SJiri Olsa } 1538edbe9817SJiri Olsa 1539edbe9817SJiri Olsa cw->stream_class = stream_class; 1540edbe9817SJiri Olsa 1541edbe9817SJiri Olsa /* CTF clock stream setup */ 1542edbe9817SJiri Olsa if (bt_ctf_stream_class_set_clock(stream_class, clock)) { 1543edbe9817SJiri Olsa pr("Failed to assign CTF clock to stream class.\n"); 1544edbe9817SJiri Olsa goto err_cleanup; 1545edbe9817SJiri Olsa } 1546edbe9817SJiri Olsa 1547edbe9817SJiri Olsa if (ctf_writer__init_data(cw)) 1548edbe9817SJiri Olsa goto err_cleanup; 1549edbe9817SJiri Olsa 155090e129ffSSebastian Andrzej Siewior /* Add cpu_id for packet context */ 155190e129ffSSebastian Andrzej Siewior pkt_ctx_type = bt_ctf_stream_class_get_packet_context_type(stream_class); 155290e129ffSSebastian Andrzej Siewior if (!pkt_ctx_type) 1553edbe9817SJiri Olsa goto err_cleanup; 1554edbe9817SJiri Olsa 155590e129ffSSebastian Andrzej Siewior ret = bt_ctf_field_type_structure_add_field(pkt_ctx_type, cw->data.u32, "cpu_id"); 155690e129ffSSebastian Andrzej Siewior bt_ctf_field_type_put(pkt_ctx_type); 155790e129ffSSebastian Andrzej Siewior if (ret) 155890e129ffSSebastian Andrzej Siewior goto err_cleanup; 1559edbe9817SJiri Olsa 1560edbe9817SJiri Olsa /* CTF clock writer setup */ 1561edbe9817SJiri Olsa if (bt_ctf_writer_add_clock(writer, clock)) { 1562edbe9817SJiri Olsa pr("Failed to assign CTF clock to writer.\n"); 1563edbe9817SJiri Olsa goto err_cleanup; 1564edbe9817SJiri Olsa } 1565edbe9817SJiri Olsa 1566edbe9817SJiri Olsa return 0; 1567edbe9817SJiri Olsa 1568edbe9817SJiri Olsa err_cleanup: 1569edbe9817SJiri Olsa ctf_writer__cleanup(cw); 1570edbe9817SJiri Olsa err: 1571edbe9817SJiri Olsa pr_err("Failed to setup CTF writer.\n"); 1572edbe9817SJiri Olsa return -1; 1573edbe9817SJiri Olsa } 1574edbe9817SJiri Olsa 157590e129ffSSebastian Andrzej Siewior static int ctf_writer__flush_streams(struct ctf_writer *cw) 157690e129ffSSebastian Andrzej Siewior { 157790e129ffSSebastian Andrzej Siewior int cpu, ret = 0; 157890e129ffSSebastian Andrzej Siewior 157990e129ffSSebastian Andrzej Siewior for (cpu = 0; cpu < cw->stream_cnt && !ret; cpu++) 158090e129ffSSebastian Andrzej Siewior ret = ctf_stream__flush(cw->stream[cpu]); 158190e129ffSSebastian Andrzej Siewior 158290e129ffSSebastian Andrzej Siewior return ret; 158390e129ffSSebastian Andrzej Siewior } 158490e129ffSSebastian Andrzej Siewior 15858fa46753SJiri Olsa static int convert__config(const char *var, const char *value, void *cb) 15868fa46753SJiri Olsa { 15878fa46753SJiri Olsa struct convert *c = cb; 15888fa46753SJiri Olsa 158925ce4bb8SArnaldo Carvalho de Melo if (!strcmp(var, "convert.queue-size")) 159025ce4bb8SArnaldo Carvalho de Melo return perf_config_u64(&c->queue_size, var, value); 15918fa46753SJiri Olsa 1592b8cbb349SWang Nan return 0; 15938fa46753SJiri Olsa } 15948fa46753SJiri Olsa 15953275f68eSWang Nan int bt_convert__perf2ctf(const char *input, const char *path, 15963275f68eSWang Nan struct perf_data_convert_opts *opts) 1597edbe9817SJiri Olsa { 1598edbe9817SJiri Olsa struct perf_session *session; 15998ceb41d7SJiri Olsa struct perf_data data = { 16002d4f2799SJiri Olsa .path = input, 1601edbe9817SJiri Olsa .mode = PERF_DATA_MODE_READ, 16023275f68eSWang Nan .force = opts->force, 1603edbe9817SJiri Olsa }; 1604edbe9817SJiri Olsa struct convert c = { 1605edbe9817SJiri Olsa .tool = { 1606edbe9817SJiri Olsa .sample = process_sample_event, 1607edbe9817SJiri Olsa .mmap = perf_event__process_mmap, 1608edbe9817SJiri Olsa .mmap2 = perf_event__process_mmap2, 1609edbe9817SJiri Olsa .comm = perf_event__process_comm, 1610edbe9817SJiri Olsa .exit = perf_event__process_exit, 1611edbe9817SJiri Olsa .fork = perf_event__process_fork, 1612edbe9817SJiri Olsa .lost = perf_event__process_lost, 1613edbe9817SJiri Olsa .tracing_data = perf_event__process_tracing_data, 1614edbe9817SJiri Olsa .build_id = perf_event__process_build_id, 1615f3b3614aSHari Bathini .namespaces = perf_event__process_namespaces, 1616edbe9817SJiri Olsa .ordered_events = true, 1617edbe9817SJiri Olsa .ordering_requires_timestamps = true, 1618edbe9817SJiri Olsa }, 1619edbe9817SJiri Olsa }; 1620edbe9817SJiri Olsa struct ctf_writer *cw = &c.writer; 1621ecc4c561SArnaldo Carvalho de Melo int err; 1622edbe9817SJiri Olsa 1623ebccba3fSWang Nan if (opts->all) { 1624f5a08cedSWang Nan c.tool.comm = process_comm_event; 1625ebccba3fSWang Nan c.tool.exit = process_exit_event; 1626ebccba3fSWang Nan c.tool.fork = process_fork_event; 1627f9f6f2a9SGeneviève Bastien c.tool.mmap = process_mmap_event; 1628f9f6f2a9SGeneviève Bastien c.tool.mmap2 = process_mmap2_event; 1629ebccba3fSWang Nan } 1630f5a08cedSWang Nan 1631ecc4c561SArnaldo Carvalho de Melo err = perf_config(convert__config, &c); 1632ecc4c561SArnaldo Carvalho de Melo if (err) 1633ecc4c561SArnaldo Carvalho de Melo return err; 16348fa46753SJiri Olsa 1635ecc4c561SArnaldo Carvalho de Melo err = -1; 1636edbe9817SJiri Olsa /* perf.data session */ 16378ceb41d7SJiri Olsa session = perf_session__new(&data, 0, &c.tool); 163888371c58SJiri Olsa if (IS_ERR(session)) 163988371c58SJiri Olsa return PTR_ERR(session); 164088371c58SJiri Olsa 164188371c58SJiri Olsa /* CTF writer */ 164288371c58SJiri Olsa if (ctf_writer__init(cw, path, session, opts->tod)) 164388371c58SJiri Olsa goto free_session; 1644edbe9817SJiri Olsa 16458fa46753SJiri Olsa if (c.queue_size) { 16468fa46753SJiri Olsa ordered_events__set_alloc_size(&session->ordered_events, 16478fa46753SJiri Olsa c.queue_size); 16488fa46753SJiri Olsa } 16498fa46753SJiri Olsa 1650edbe9817SJiri Olsa /* CTF writer env/clock setup */ 1651edbe9817SJiri Olsa if (ctf_writer__setup_env(cw, session)) 165288371c58SJiri Olsa goto free_writer; 1653edbe9817SJiri Olsa 1654edbe9817SJiri Olsa /* CTF events setup */ 1655edbe9817SJiri Olsa if (setup_events(cw, session)) 165688371c58SJiri Olsa goto free_writer; 1657edbe9817SJiri Olsa 1658f5a08cedSWang Nan if (opts->all && setup_non_sample_events(cw, session)) 165988371c58SJiri Olsa goto free_writer; 1660f5a08cedSWang Nan 166190e129ffSSebastian Andrzej Siewior if (setup_streams(cw, session)) 166288371c58SJiri Olsa goto free_writer; 166390e129ffSSebastian Andrzej Siewior 1664b7b61cbeSArnaldo Carvalho de Melo err = perf_session__process_events(session); 1665edbe9817SJiri Olsa if (!err) 166690e129ffSSebastian Andrzej Siewior err = ctf_writer__flush_streams(cw); 1667c2141055SHe Kuang else 1668c2141055SHe Kuang pr_err("Error during conversion.\n"); 1669edbe9817SJiri Olsa 1670edbe9817SJiri Olsa fprintf(stderr, 1671edbe9817SJiri Olsa "[ perf data convert: Converted '%s' into CTF data '%s' ]\n", 16722d4f2799SJiri Olsa data.path, path); 1673edbe9817SJiri Olsa 1674edbe9817SJiri Olsa fprintf(stderr, 16758ee4c46cSWang Nan "[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples", 1676edbe9817SJiri Olsa (double) c.events_size / 1024.0 / 1024.0, 1677edbe9817SJiri Olsa c.events_count); 1678edbe9817SJiri Olsa 16798ee4c46cSWang Nan if (!c.non_sample_count) 16808ee4c46cSWang Nan fprintf(stderr, ") ]\n"); 16818ee4c46cSWang Nan else 16828ee4c46cSWang Nan fprintf(stderr, ", %" PRIu64 " non-samples) ]\n", c.non_sample_count); 16838ee4c46cSWang Nan 16845141d735SWang Nan cleanup_events(session); 1685c2141055SHe Kuang perf_session__delete(session); 1686c2141055SHe Kuang ctf_writer__cleanup(cw); 1687c2141055SHe Kuang 1688c2141055SHe Kuang return err; 1689c2141055SHe Kuang 1690edbe9817SJiri Olsa free_writer: 1691edbe9817SJiri Olsa ctf_writer__cleanup(cw); 169288371c58SJiri Olsa free_session: 169388371c58SJiri Olsa perf_session__delete(session); 1694c2141055SHe Kuang pr_err("Error during conversion setup.\n"); 1695edbe9817SJiri Olsa return err; 1696edbe9817SJiri Olsa } 1697