src/lttng-event-notifier-notification.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * lttng-event-notifier-notification.c
   4  *
   5  * Copyright (C) 2020 Francis Deslauriers <francis.deslauriers@efficios.com>
   6  */
   7
   8 #include <linux/bug.h>
   9
  10 #include <lttng/lttng-bytecode.h>
  11 #include <lttng/events.h>
  12 #include <lttng/msgpack.h>
  13 #include <lttng/event-notifier-notification.h>
  14 #include <wrapper/barrier.h>
  15
  16 /*
  17  * The capture buffer size needs to be below 1024 bytes to avoid the
  18  * frame to be larger than the 1024 limit enforced by the kernel. If we
  19  * ever need to increase it, we will need to use a memory allocation
  20  * scheme which allows allocating temporary memory chunks from the
  21  * instrumentation sites. This could be done by adapting lttng
  22  * tp-mempool to become nmi-safe and lock-free.
  23  */
  24 #define CAPTURE_BUFFER_SIZE 512
  25
  26 struct lttng_event_notifier_notification {
  27         int notification_fd;
  28         uint64_t event_notifier_token;
  29         uint8_t capture_buf[CAPTURE_BUFFER_SIZE];
  30         struct lttng_msgpack_writer writer;
  31         bool has_captures;
  32 };
  33
  34 static
  35 int capture_enum(struct lttng_msgpack_writer *writer,
  36                 struct lttng_interpreter_output *output)
  37 {
  38         int ret;
  39
  40         /*
  41          * Enums are captured as a map containing 2 key-value pairs. Such as:
  42          * - type: enum
  43          *   value: 177
  44          */
  45         ret = lttng_msgpack_begin_map(writer, 2);
  46         if (ret) {
  47                 WARN_ON_ONCE(1);
  48                 goto end;
  49         }
  50
  51         ret = lttng_msgpack_write_str(writer, "type");
  52         if (ret) {
  53                 WARN_ON_ONCE(1);
  54                 goto end;
  55         }
  56
  57         ret = lttng_msgpack_write_str(writer, "enum");
  58         if (ret) {
  59                 WARN_ON_ONCE(1);
  60                 goto end;
  61         }
  62
  63         ret = lttng_msgpack_write_str(writer, "value");
  64         if (ret) {
  65                 WARN_ON_ONCE(1);
  66                 goto end;
  67         }
  68
  69         switch (output->type) {
  70         case LTTNG_INTERPRETER_TYPE_SIGNED_ENUM:
  71                 ret = lttng_msgpack_write_signed_integer(writer, output->u.s);
  72                 if (ret) {
  73                         WARN_ON_ONCE(1);
  74                         goto end;
  75                 }
  76                 break;
  77         case LTTNG_INTERPRETER_TYPE_UNSIGNED_ENUM:
  78                 ret = lttng_msgpack_write_signed_integer(writer, output->u.u);
  79                 if (ret) {
  80                         WARN_ON_ONCE(1);
  81                         goto end;
  82                 }
  83                 break;
  84         default:
  85                 WARN_ON(1);
  86         }
  87
  88         ret = lttng_msgpack_end_map(writer);
  89         if (ret)
  90                 WARN_ON_ONCE(1);
  91
  92 end:
  93         return ret;
  94 }
  95
  96 static
  97 int64_t capture_sequence_element_signed(uint8_t *ptr,
  98                 const struct lttng_integer_type *type)
  99 {
 100         int64_t value = 0;
 101         unsigned int size = type->size;
 102         bool byte_order_reversed = type->reverse_byte_order;
 103
 104         switch (size) {
 105         case 8:
 106                 value = *ptr;
 107                 break;
 108         case 16:
 109         {
 110                 int16_t tmp;
 111                 tmp = *(int16_t *) ptr;
 112                 if (byte_order_reversed)
 113                         __swab16s(&tmp);
 114
 115                 value = tmp;
 116                 break;
 117         }
 118         case 32:
 119         {
 120                 int32_t tmp;
 121                 tmp = *(int32_t *) ptr;
 122                 if (byte_order_reversed)
 123                         __swab32s(&tmp);
 124
 125                 value = tmp;
 126                 break;
 127         }
 128         case 64:
 129         {
 130                 int64_t tmp;
 131                 tmp = *(int64_t *) ptr;
 132                 if (byte_order_reversed)
 133                         __swab64s(&tmp);
 134
 135                 value = tmp;
 136                 break;
 137         }
 138         default:
 139                 WARN_ON(1);
 140         }
 141
 142         return value;
 143 }
 144
 145 static
 146 uint64_t capture_sequence_element_unsigned(uint8_t *ptr,
 147                 const struct lttng_integer_type *type)
 148 {
 149         uint64_t value = 0;
 150         unsigned int size = type->size;
 151         bool byte_order_reversed = type->reverse_byte_order;
 152
 153         switch (size) {
 154         case 8:
 155                 value = *ptr;
 156                 break;
 157         case 16:
 158         {
 159                 uint16_t tmp;
 160                 tmp = *(uint16_t *) ptr;
 161                 if (byte_order_reversed)
 162                         __swab16s(&tmp);
 163
 164                 value = tmp;
 165                 break;
 166         }
 167         case 32:
 168         {
 169                 uint32_t tmp;
 170                 tmp = *(uint32_t *) ptr;
 171                 if (byte_order_reversed)
 172                         __swab32s(&tmp);
 173
 174                 value = tmp;
 175                 break;
 176         }
 177         case 64:
 178         {
 179                 uint64_t tmp;
 180                 tmp = *(uint64_t *) ptr;
 181                 if (byte_order_reversed)
 182                         __swab64s(&tmp);
 183
 184                 value = tmp;
 185                 break;
 186         }
 187         default:
 188                 WARN_ON(1);
 189         }
 190
 191         return value;
 192 }
 193
 194 int capture_sequence(struct lttng_msgpack_writer *writer,
 195                 struct lttng_interpreter_output *output)
 196 {
 197         const struct lttng_integer_type *integer_type = NULL;
 198         const struct lttng_type *nested_type;
 199         uint8_t *ptr;
 200         bool signedness;
 201         int ret, i;
 202
 203         ret = lttng_msgpack_begin_array(writer, output->u.sequence.nr_elem);
 204         if (ret) {
 205                 WARN_ON_ONCE(1);
 206                 goto end;
 207         }
 208
 209         ptr = (uint8_t *) output->u.sequence.ptr;
 210         nested_type = output->u.sequence.nested_type;
 211         switch (nested_type->type) {
 212         case lttng_kernel_type_integer:
 213                 integer_type = &nested_type->u.integer;
 214                 break;
 215         case lttng_kernel_type_enum_nestable:
 216                 /* Treat enumeration as an integer. */
 217                 integer_type = &nested_type->u.enum_nestable.container_type->u.integer;
 218                 break;
 219         default:
 220                 /* Capture of array of non-integer are not supported. */
 221                 WARN_ON(1);
 222         }
 223         signedness = integer_type->signedness;
 224         for (i = 0; i < output->u.sequence.nr_elem; i++) {
 225                 if (signedness) {
 226                         ret = lttng_msgpack_write_signed_integer(writer,
 227                                 capture_sequence_element_signed(ptr, integer_type));
 228                         if (ret) {
 229                                 WARN_ON_ONCE(1);
 230                                 goto end;
 231                         }
 232                 } else {
 233                         ret = lttng_msgpack_write_unsigned_integer(writer,
 234                                 capture_sequence_element_unsigned(ptr, integer_type));
 235                         if (ret) {
 236                                 WARN_ON_ONCE(1);
 237                                 goto end;
 238                         }
 239                 }
 240
 241                 /*
 242                  * We assume that alignment is smaller or equal to the size.
 243                  * This currently holds true but if it changes in the future,
 244                  * we will want to change the pointer arithmetics below to
 245                  * take into account that the next element might be further
 246                  * away.
 247                  */
 248                 WARN_ON(integer_type->alignment > integer_type->size);
 249
 250                 /* Size is in number of bits. */
 251                 ptr += (integer_type->size / CHAR_BIT) ;
 252         }
 253
 254         ret = lttng_msgpack_end_array(writer);
 255         if (ret)
 256                 WARN_ON_ONCE(1);
 257 end:
 258         return ret;
 259 }
 260
 261 static
 262 int notification_append_capture(
 263                 struct lttng_event_notifier_notification *notif,
 264                 struct lttng_interpreter_output *output)
 265 {
 266         struct lttng_msgpack_writer *writer = &notif->writer;
 267         int ret = 0;
 268
 269         switch (output->type) {
 270         case LTTNG_INTERPRETER_TYPE_S64:
 271                 ret = lttng_msgpack_write_signed_integer(writer, output->u.s);
 272                 if (ret) {
 273                         WARN_ON_ONCE(1);
 274                         goto end;
 275                 }
 276                 break;
 277         case LTTNG_INTERPRETER_TYPE_U64:
 278                 ret = lttng_msgpack_write_unsigned_integer(writer, output->u.u);
 279                 if (ret) {
 280                         WARN_ON_ONCE(1);
 281                         goto end;
 282                 }
 283                 break;
 284         case LTTNG_INTERPRETER_TYPE_STRING:
 285                 ret = lttng_msgpack_write_str(writer, output->u.str.str);
 286                 if (ret) {
 287                         WARN_ON_ONCE(1);
 288                         goto end;
 289                 }
 290                 break;
 291         case LTTNG_INTERPRETER_TYPE_SEQUENCE:
 292                 ret = capture_sequence(writer, output);
 293                 if (ret) {
 294                         WARN_ON_ONCE(1);
 295                         goto end;
 296                 }
 297                 break;
 298         case LTTNG_INTERPRETER_TYPE_SIGNED_ENUM:
 299         case LTTNG_INTERPRETER_TYPE_UNSIGNED_ENUM:
 300                 ret = capture_enum(writer, output);
 301                 if (ret) {
 302                         WARN_ON_ONCE(1);
 303                         goto end;
 304                 }
 305                 break;
 306         default:
 307                 ret = -1;
 308                 WARN_ON(1);
 309         }
 310 end:
 311         return ret;
 312 }
 313
 314 static
 315 int notification_append_empty_capture(
 316                 struct lttng_event_notifier_notification *notif)
 317 {
 318         int ret = lttng_msgpack_write_nil(&notif->writer);
 319         if (ret)
 320                 WARN_ON_ONCE(1);
 321
 322         return ret;
 323 }
 324
 325 static
 326 int notification_init(struct lttng_event_notifier_notification *notif,
 327                 struct lttng_event_notifier *event_notifier)
 328 {
 329         struct lttng_msgpack_writer *writer = &notif->writer;
 330         int ret = 0;
 331
 332         notif->has_captures = false;
 333
 334         if (event_notifier->num_captures > 0) {
 335                 lttng_msgpack_writer_init(writer, notif->capture_buf,
 336                                 CAPTURE_BUFFER_SIZE);
 337
 338                 ret = lttng_msgpack_begin_array(writer, event_notifier->num_captures);
 339                 if (ret) {
 340                         WARN_ON_ONCE(1);
 341                         goto end;
 342                 }
 343
 344                 notif->has_captures = true;
 345         }
 346
 347 end:
 348         return ret;
 349 }
 350
 351 static
 352 void record_error(struct lttng_event_notifier *event_notifier)
 353 {
 354
 355         struct lttng_event_notifier_group *event_notifier_group = event_notifier->group;
 356         struct lttng_counter *error_counter;
 357         size_t dimension_index[1];
 358         int ret;
 359
 360         /*
 361          * lttng_smp_load_acquire paired with lttng_smp_store_release orders
 362          * creation of the error counter and setting error_counter_len
 363          * before the error_counter is used.
 364          */
 365         error_counter = lttng_smp_load_acquire(&event_notifier_group->error_counter);
 366         /* This group may not have an error counter attached to it. */
 367         if (!error_counter)
 368                 return;
 369
 370         dimension_index[0] = event_notifier->error_counter_index;
 371
 372         ret = error_counter->ops->counter_add(error_counter->counter,
 373                         dimension_index, 1);
 374         if (ret)
 375                 WARN_ON_ONCE(1);
 376 }
 377
 378 static
 379 void notification_send(struct lttng_event_notifier_notification *notif,
 380                 struct lttng_event_notifier *event_notifier)
 381 {
 382         struct lttng_event_notifier_group *event_notifier_group = event_notifier->group;
 383         struct lib_ring_buffer_ctx ctx;
 384         struct lttng_kernel_event_notifier_notification kernel_notif;
 385         size_t capture_buffer_content_len, reserve_size;
 386         int ret;
 387
 388         reserve_size = sizeof(kernel_notif);
 389         kernel_notif.token = event_notifier->user_token;
 390
 391         if (notif->has_captures) {
 392                 capture_buffer_content_len = notif->writer.write_pos - notif->writer.buffer;
 393         } else {
 394                 capture_buffer_content_len = 0;
 395         }
 396
 397         WARN_ON_ONCE(capture_buffer_content_len > CAPTURE_BUFFER_SIZE);
 398
 399         reserve_size += capture_buffer_content_len;
 400         kernel_notif.capture_buf_size = capture_buffer_content_len;
 401
 402         lib_ring_buffer_ctx_init(&ctx, event_notifier_group->chan, NULL, reserve_size,
 403                         lttng_alignof(kernel_notif), -1);
 404         ret = event_notifier_group->ops->event_reserve(&ctx, 0);
 405         if (ret < 0) {
 406                 record_error(event_notifier);
 407                 return;
 408         }
 409
 410         lib_ring_buffer_align_ctx(&ctx, lttng_alignof(kernel_notif));
 411
 412         /* Write the notif structure. */
 413         event_notifier_group->ops->event_write(&ctx, &kernel_notif,
 414                         sizeof(kernel_notif));
 415
 416         /*
 417          * Write the capture buffer. No need to realigned as the below is a raw
 418          * char* buffer.
 419          */
 420         event_notifier_group->ops->event_write(&ctx, &notif->capture_buf,
 421                         capture_buffer_content_len);
 422
 423         event_notifier_group->ops->event_commit(&ctx);
 424         irq_work_queue(&event_notifier_group->wakeup_pending);
 425 }
 426
 427 void lttng_event_notifier_notification_send(struct lttng_event_notifier *event_notifier,
 428                 struct lttng_probe_ctx *lttng_probe_ctx,
 429                 const char *stack_data,
 430                 struct lttng_kernel_notifier_ctx *notif_ctx)
 431 {
 432         struct lttng_event_notifier_notification notif = { 0 };
 433         int ret;
 434
 435         if (unlikely(!READ_ONCE(event_notifier->enabled)))
 436                 return;
 437
 438         ret = notification_init(&notif, event_notifier);
 439         if (ret) {
 440                 WARN_ON_ONCE(1);
 441                 goto end;
 442         }
 443
 444         if (unlikely(notif_ctx->eval_capture)) {
 445                 struct lttng_bytecode_runtime *capture_bc_runtime;
 446
 447                 /*
 448                  * Iterate over all the capture bytecodes. If the interpreter
 449                  * functions returns successfully, append the value of the
 450                  * `output` parameter to the capture buffer. If the interpreter
 451                  * fails, append an empty capture to the buffer.
 452                  */
 453                 list_for_each_entry_rcu(capture_bc_runtime,
 454                                 &event_notifier->capture_bytecode_runtime_head, node) {
 455                         struct lttng_interpreter_output output;
 456
 457                         if (capture_bc_runtime->interpreter_funcs.capture(capture_bc_runtime,
 458                                         lttng_probe_ctx, stack_data, &output) & LTTNG_INTERPRETER_RECORD_FLAG)
 459                                 ret = notification_append_capture(&notif, &output);
 460                         else
 461                                 ret = notification_append_empty_capture(&notif);
 462
 463                         if (ret)
 464                                 printk(KERN_WARNING "Error appending capture to notification");
 465                 }
 466         }
 467
 468         /*
 469          * Send the notification (including the capture buffer) to the
 470          * sessiond.
 471          */
 472         notification_send(&notif, event_notifier);
 473 end:
 474         return;
 475 }