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 void
 219 string_fixed_replace(char *input, const char *search, const char *replace)
 220 {
 221         char *found;
 222         size_t len;
 223
 224         found = strstr(input, search);
 225         if (found == NULL)
 226                 return;
 227
 228         if (strlen(found) != strlen(search))
 229                 return;
 230
 231         len = strlen(replace);
 232         memcpy(found, replace, len);
 233         found[len] = '\0';
 234 }
 235
 236 static void
 237 ctf_fixup_align(char *str)
 238 {
 239         string_fixed_replace(str, "align", "_align");
 240 }
 241
 242 static void
 243 ctf_fixup_arrow_deref(char *str)
 244 {
 245         const char *replace = "_";
 246         const char *search = "->";
 247         char *found;
 248         size_t len;
 249
 250         found = strstr(str, search);
 251         if (found == NULL)
 252                 return;
 253
 254         do {
 255                 memcpy(found, replace, strlen(replace));
 256                 len = strlen(found + 2);
 257                 memcpy(found + 1, found + 2, len);
 258                 found[len + 1] = '\0';
 259                 found = strstr(str, search);
 260         } while (found != NULL);
 261 }
 262
 263 static void
 264 ctf_fixup_dot_deref(char *str)
 265 {
 266         const char *replace = "_";
 267         const char *search = ".";
 268         char *found;
 269         size_t len;
 270
 271         found = strstr(str, search);
 272         if (found == NULL)
 273                 return;
 274
 275         len = strlen(replace);
 276         do {
 277                 memcpy(found, replace, len);
 278                 found = strstr(str, search);
 279         } while (found != NULL);
 280 }
 281
 282 static void
 283 ctf_fixup_event(char *str)
 284 {
 285         string_fixed_replace(str, "event", "_event");
 286 }
 287
 288 static int
 289 ctf_fixup_keyword(char *str)
 290 {
 291         char dup_str[TRACE_CTF_FIELD_SIZE];
 292         char input[TRACE_CTF_FIELD_SIZE];
 293         const char *delim = ";";
 294         char *from;
 295         int len;
 296
 297         if (str == NULL)
 298                 return 0;
 299
 300         len = strlen(str);
 301         if (len >= TRACE_CTF_FIELD_SIZE) {
 302                 trace_err("ctf_field reached its maximum limit");
 303                 return -EMSGSIZE;
 304         }
 305
 306         /* Create duplicate string */
 307         strcpy(dup_str, str);
 308
 309         len = 0;
 310         from = strtok(dup_str, delim);
 311         while (from != NULL) {
 312                 strcpy(input, from);
 313                 ctf_fixup_align(input);
 314                 ctf_fixup_dot_deref(input);
 315                 ctf_fixup_arrow_deref(input);
 316                 ctf_fixup_event(input);
 317
 318                 strcpy(&input[strlen(input)], delim);
 319                 if ((len + strlen(input)) >= TRACE_CTF_FIELD_SIZE) {
 320                         trace_err("ctf_field reached its maximum limit");
 321                         return -EMSGSIZE;
 322                 }
 323
 324                 strcpy(str + len, input);
 325                 len += strlen(input);
 326                 from = strtok(NULL, delim);
 327         }
 328
 329         return 0;
 330 }
 331
 332 static int
 333 meta_event_emit(char **meta, int *offset, struct trace_point *tp)
 334 {
 335         char *str = NULL;
 336         int rc;
 337
 338         /* Fixup ctf field string in case it using reserved ctf keywords */
 339         rc = ctf_fixup_keyword(tp->ctf_field);
 340         if (rc)
 341                 return rc;
 342
 343         rc = metadata_printf(&str,
 344                 "event {\n"
 345                 "    id = %d;\n"
 346                 "    name = \"%s\";\n"
 347                 "    fields := struct {\n"
 348                 "        %s\n"
 349                 "    };\n"
 350                 "};\n\n", trace_id_get(tp->handle), tp->name, tp->ctf_field);
 351         return meta_copy(meta, offset, str, rc);
 352 }
 353
 354 int
 355 trace_metadata_create(void)
 356 {
 357         struct trace_point_head *tp_list = trace_list_head_get();
 358         struct trace *trace = trace_obj_get();
 359         struct trace_point *tp;
 360         int rc, offset = 0;
 361         char *meta = NULL;
 362
 363         rc = meta_data_type_emit(&meta, &offset);
 364         if (rc < 0)
 365                 goto fail;
 366
 367         rc = meta_header_emit(&meta, &offset);
 368         if (rc < 0)
 369                 goto fail;
 370
 371         rc = meta_env_emit(&meta, &offset);
 372         if (rc < 0)
 373                 goto fail;
 374
 375         rc = meta_clock_pass1_emit(&meta, &offset);
 376         if (rc < 0)
 377                 goto fail;
 378         trace->ctf_meta_offset_freq = offset;
 379
 380         rc = meta_clock_pass2_emit(&meta, &offset);
 381         if (rc < 0)
 382                 goto fail;
 383         trace->ctf_meta_offset_freq_off_s = offset;
 384
 385         rc = meta_clock_pass3_emit(&meta, &offset);
 386         if (rc < 0)
 387                 goto fail;
 388         trace->ctf_meta_offset_freq_off = offset;
 389
 390         rc = meta_clock_pass4_emit(&meta, &offset);
 391         if (rc < 0)
 392                 goto fail;
 393
 394         rc = meta_stream_emit(&meta, &offset);
 395         if (rc < 0)
 396                 goto fail;
 397
 398         STAILQ_FOREACH(tp, tp_list, next)
 399                 if (meta_event_emit(&meta, &offset, tp) < 0)
 400                         goto fail;
 401
 402         trace->ctf_meta = meta;
 403         return 0;
 404
 405 fail:
 406         if (meta)
 407                 free(meta);
 408         return -EBADF;
 409 }
 410
 411 void
 412 trace_metadata_destroy(void)
 413 {
 414         struct trace *trace = trace_obj_get();
 415
 416         if (trace->ctf_meta) {
 417                 free(trace->ctf_meta);
 418                 trace->ctf_meta = NULL;
 419         }
 420 }
 421