lib/librte_eal/common/eal_common_trace_ctf.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2020 Marvell International Ltd.
   3  */
   4
   5 #include <inttypes.h>
   6 #include <time.h>
   7
   8 #include <rte_byteorder.h>
   9 #include <rte_common.h>
  10 #include <rte_time.h>
  11 #include <rte_trace.h>
  12 #include <rte_version.h>
  13
  14 #include "eal_trace.h"
  15
  16 __rte_format_printf(2, 0)
  17 static int
  18 metadata_printf(char **str, const char *fmt, ...)
  19 {
  20         va_list ap;
  21         int rc;
  22
  23         *str = NULL;
  24         va_start(ap, fmt);
  25         rc = vasprintf(str, fmt, ap);
  26         va_end(ap);
  27
  28         return rc;
  29 }
  30
  31 static int
  32 meta_copy(char **meta, int *offset, char *str, int rc)
  33 {
  34         int count = *offset;
  35         char *ptr = *meta;
  36
  37         if (rc < 0)
  38                 return rc;
  39
  40         ptr = realloc(ptr, count + rc);
  41         if (ptr == NULL)
  42                 goto free_str;
  43
  44         memcpy(RTE_PTR_ADD(ptr, count), str, rc);
  45         count += rc;
  46         free(str);
  47
  48         *meta = ptr;
  49         *offset = count;
  50
  51         return rc;
  52
  53 free_str:
  54         if (str)
  55                 free(str);
  56         return -ENOMEM;
  57 }
  58
  59 static int
  60 meta_data_type_emit(char **meta, int *offset)
  61 {
  62         char *str = NULL;
  63         int rc;
  64
  65         rc = metadata_printf(&str,
  66                 "/* CTF 1.8 */\n"
  67                 "typealias integer {size = 8; base = x;}:= uint8_t;\n"
  68                 "typealias integer {size = 16; base = x;} := uint16_t;\n"
  69                 "typealias integer {size = 32; base = x;} := uint32_t;\n"
  70                 "typealias integer {size = 64; base = x;} := uint64_t;\n"
  71                 "typealias integer {size = 8; signed = true;}  := int8_t;\n"
  72                 "typealias integer {size = 16; signed = true;} := int16_t;\n"
  73                 "typealias integer {size = 32; signed = true;} := int32_t;\n"
  74                 "typealias integer {size = 64; signed = true;} := int64_t;\n"
  75 #ifdef RTE_ARCH_64
  76                 "typealias integer {size = 64; base = x;} := uintptr_t;\n"
  77 #else
  78                 "typealias integer {size = 32; base = x;} := uintptr_t;\n"
  79 #endif
  80 #ifdef RTE_ARCH_64
  81                 "typealias integer {size = 64; base = x;} := long;\n"
  82 #else
  83                 "typealias integer {size = 32; base = x;} := long;\n"
  84 #endif
  85                 "typealias integer {size = 8; signed = false; encoding = ASCII; } := string_bounded_t;\n\n"
  86                 "typealias floating_point {\n"
  87                 "    exp_dig = 8;\n"
  88                 "    mant_dig = 24;\n"
  89                 "} := float;\n\n"
  90                 "typealias floating_point {\n"
  91                 "    exp_dig = 11;\n"
  92                 "    mant_dig = 53;\n"
  93                 "} := double;\n\n");
  94
  95         return meta_copy(meta, offset, str, rc);
  96 }
  97
  98 static int
  99 is_be(void)
 100 {
 101 #if RTE_BYTE_ORDER == RTE_BIG_ENDIAN
 102         return 1;
 103 #else
 104         return 0;
 105 #endif
 106 }
 107
 108 static int
 109 meta_header_emit(char **meta, int *offset)
 110 {
 111         struct trace *trace = trace_obj_get();
 112         char uustr[RTE_UUID_STRLEN];
 113         char *str = NULL;
 114         int rc;
 115
 116         rte_uuid_unparse(trace->uuid, uustr, RTE_UUID_STRLEN);
 117         rc = metadata_printf(&str,
 118                 "trace {\n"
 119                 "    major = 1;\n"
 120                 "    minor = 8;\n"
 121                 "    uuid = \"%s\";\n"
 122                 "    byte_order = %s;\n"
 123                 "    packet.header := struct {\n"
 124                 "           uint32_t magic;\n"
 125                 "           uint8_t  uuid[16];\n"
 126                 "    };\n"
 127                 "};\n\n", uustr, is_be() ? "be" : "le");
 128         return meta_copy(meta, offset, str, rc);
 129 }
 130
 131 static int
 132 meta_env_emit(char **meta, int *offset)
 133 {
 134         char *str = NULL;
 135         int rc;
 136
 137         rc = metadata_printf(&str,
 138                 "env {\n"
 139                 "    dpdk_version = \"%s\";\n"
 140                 "    tracer_name = \"dpdk\";\n"
 141                 "};\n\n", rte_version());
 142         return meta_copy(meta, offset, str, rc);
 143 }
 144
 145 static int
 146 meta_clock_pass1_emit(char **meta, int *offset)
 147 {
 148         char *str = NULL;
 149         int rc;
 150
 151         rc = metadata_printf(&str,
 152                 "clock {\n"
 153                 "    name = \"dpdk\";\n"
 154                 "    freq = ");
 155         return meta_copy(meta, offset, str, rc);
 156 }
 157
 158 static int
 159 meta_clock_pass2_emit(char **meta, int *offset)
 160 {
 161         char *str = NULL;
 162         int rc;
 163
 164         rc = metadata_printf(&str,
 165                 "%20"PRIu64";\n"
 166                 "    offset_s =", 0);
 167         return meta_copy(meta, offset, str, rc);
 168 }
 169
 170 static int
 171 meta_clock_pass3_emit(char **meta, int *offset)
 172 {
 173         char *str = NULL;
 174         int rc;
 175
 176         rc = metadata_printf(&str,
 177                 "%20"PRIu64";\n"
 178                 "    offset =", 0);
 179         return meta_copy(meta, offset, str, rc);
 180 }
 181
 182 static int
 183 meta_clock_pass4_emit(char **meta, int *offset)
 184 {
 185         char *str = NULL;
 186         int rc;
 187
 188         rc = metadata_printf(&str,
 189                 "%20"PRIu64";\n};\n\n"
 190                 "typealias integer {\n"
 191                 "    size = 48; align = 1; signed = false;\n"
 192                 "    map = clock.dpdk.value;\n"
 193                 "} := uint48_clock_dpdk_t;\n\n", 0);
 194
 195         return meta_copy(meta, offset, str, rc);
 196 }
 197
 198 static int
 199 meta_stream_emit(char **meta, int *offset)
 200 {
 201         char *str = NULL;
 202         int rc;
 203
 204         rc = metadata_printf(&str,
 205                 "stream {\n"
 206                 "    packet.context := struct {\n"
 207                 "         uint32_t cpu_id;\n"
 208                 "         string_bounded_t name[32];\n"
 209                 "    };\n"
 210                 "    event.header := struct {\n"
 211                 "          uint48_clock_dpdk_t timestamp;\n"
 212                 "          uint16_t id;\n"
 213                 "    } align(64);\n"
 214                 "};\n\n");
 215         return meta_copy(meta, offset, str, rc);
 216 }
 217
 218 static int
 219 meta_event_emit(char **meta, int *offset, struct trace_point *tp)
 220 {
 221         char *str = NULL;
 222         int rc;
 223
 224         rc = metadata_printf(&str,
 225                 "event {\n"
 226                 "    id = %d;\n"
 227                 "    name = \"%s\";\n"
 228                 "    fields := struct {\n"
 229                 "        %s\n"
 230                 "    };\n"
 231                 "};\n\n", trace_id_get(tp->handle), tp->name, tp->ctf_field);
 232         return meta_copy(meta, offset, str, rc);
 233 }
 234
 235 int
 236 trace_metadata_create(void)
 237 {
 238         struct trace_point_head *tp_list = trace_list_head_get();
 239         struct trace *trace = trace_obj_get();
 240         struct trace_point *tp;
 241         int rc, offset = 0;
 242         char *meta = NULL;
 243
 244         rc = meta_data_type_emit(&meta, &offset);
 245         if (rc < 0)
 246                 goto fail;
 247
 248         rc = meta_header_emit(&meta, &offset);
 249         if (rc < 0)
 250                 goto fail;
 251
 252         rc = meta_env_emit(&meta, &offset);
 253         if (rc < 0)
 254                 goto fail;
 255
 256         rc = meta_clock_pass1_emit(&meta, &offset);
 257         if (rc < 0)
 258                 goto fail;
 259         trace->ctf_meta_offset_freq = offset;
 260
 261         rc = meta_clock_pass2_emit(&meta, &offset);
 262         if (rc < 0)
 263                 goto fail;
 264         trace->ctf_meta_offset_freq_off_s = offset;
 265
 266         rc = meta_clock_pass3_emit(&meta, &offset);
 267         if (rc < 0)
 268                 goto fail;
 269         trace->ctf_meta_offset_freq_off = offset;
 270
 271         rc = meta_clock_pass4_emit(&meta, &offset);
 272         if (rc < 0)
 273                 goto fail;
 274
 275         rc = meta_stream_emit(&meta, &offset);
 276         if (rc < 0)
 277                 goto fail;
 278
 279         STAILQ_FOREACH(tp, tp_list, next)
 280                 if (meta_event_emit(&meta, &offset, tp) < 0)
 281                         goto fail;
 282
 283         trace->ctf_meta = meta;
 284         return 0;
 285
 286 fail:
 287         if (meta)
 288                 free(meta);
 289         return -EBADF;
 290 }
 291
 292 void
 293 trace_metadata_destroy(void)
 294 {
 295         struct trace *trace = trace_obj_get();
 296
 297         if (trace->ctf_meta) {
 298                 free(trace->ctf_meta);
 299                 trace->ctf_meta = NULL;
 300         }
 301 }
 302