src/lib/lttng-ust/lttng-context.c

   1 /*
   2  * SPDX-License-Identifier: LGPL-2.1-only
   3  *
   4  * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  *
   6  * LTTng UST trace/channel/event context management.
   7  */
   8
   9 #define _LGPL_SOURCE
  10 #include <lttng/ust-events.h>
  11 #include <lttng/ust-tracer.h>
  12 #include <common/ust-context-provider.h>
  13 #include <lttng/urcu/pointer.h>
  14 #include <lttng/urcu/urcu-ust.h>
  15 #include "common/logging.h"
  16 #include "common/macros.h"
  17 #include <stddef.h>
  18 #include <string.h>
  19 #include <assert.h>
  20 #include <limits.h>
  21 #include "common/tracepoint.h"
  22
  23 #include "context-internal.h"
  24
  25 /*
  26  * The filter implementation requires that two consecutive "get" for the
  27  * same context performed by the same thread return the same result.
  28  */
  29
  30 int lttng_find_context(struct lttng_ust_ctx *ctx, const char *name)
  31 {
  32         unsigned int i;
  33         const char *subname;
  34
  35         if (!ctx)
  36                 return 0;
  37         if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
  38                 subname = name + strlen("$ctx.");
  39         } else {
  40                 subname = name;
  41         }
  42         for (i = 0; i < ctx->nr_fields; i++) {
  43                 /* Skip allocated (but non-initialized) contexts */
  44                 if (!ctx->fields[i].event_field->name)
  45                         continue;
  46                 if (!strcmp(ctx->fields[i].event_field->name, subname))
  47                         return 1;
  48         }
  49         return 0;
  50 }
  51
  52 int lttng_get_context_index(struct lttng_ust_ctx *ctx, const char *name)
  53 {
  54         unsigned int i;
  55         const char *subname;
  56
  57         if (!ctx)
  58                 return -1;
  59         if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) {
  60                 subname = name + strlen("$ctx.");
  61         } else {
  62                 subname = name;
  63         }
  64         for (i = 0; i < ctx->nr_fields; i++) {
  65                 /* Skip allocated (but non-initialized) contexts */
  66                 if (!ctx->fields[i].event_field->name)
  67                         continue;
  68                 if (!strcmp(ctx->fields[i].event_field->name, subname))
  69                         return i;
  70         }
  71         return -1;
  72 }
  73
  74 static int lttng_find_context_provider(struct lttng_ust_ctx *ctx, const char *name)
  75 {
  76         unsigned int i;
  77
  78         for (i = 0; i < ctx->nr_fields; i++) {
  79                 /* Skip allocated (but non-initialized) contexts */
  80                 if (!ctx->fields[i].event_field->name)
  81                         continue;
  82                 if (!strncmp(ctx->fields[i].event_field->name, name,
  83                                 strlen(name)))
  84                         return 1;
  85         }
  86         return 0;
  87 }
  88
  89 /*
  90  * Note: as we append context information, the pointer location may change.
  91  * lttng_ust_context_add_field leaves the new last context initialized to NULL.
  92  */
  93 static
  94 int lttng_ust_context_add_field(struct lttng_ust_ctx **ctx_p)
  95 {
  96         struct lttng_ust_ctx *ctx;
  97
  98         if (!*ctx_p) {
  99                 *ctx_p = zmalloc(sizeof(struct lttng_ust_ctx));
 100                 if (!*ctx_p)
 101                         return -ENOMEM;
 102                 (*ctx_p)->largest_align = 1;
 103         }
 104         ctx = *ctx_p;
 105         if (ctx->nr_fields + 1 > ctx->allocated_fields) {
 106                 struct lttng_ust_ctx_field *new_fields;
 107
 108                 ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields);
 109                 new_fields = zmalloc(ctx->allocated_fields * sizeof(*new_fields));
 110                 if (!new_fields)
 111                         return -ENOMEM;
 112                 /* Copy elements */
 113                 if (ctx->fields)
 114                         memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields);
 115                 free(ctx->fields);
 116                 ctx->fields = new_fields;
 117         }
 118         ctx->nr_fields++;
 119         return 0;
 120 }
 121
 122 static size_t get_type_max_align(const struct lttng_ust_type_common *type)
 123 {
 124         switch (type->type) {
 125         case lttng_ust_type_integer:
 126                 return lttng_ust_get_type_integer(type)->alignment;
 127         case lttng_ust_type_string:
 128                 return CHAR_BIT;
 129         case lttng_ust_type_dynamic:
 130                 return 0;
 131         case lttng_ust_type_enum:
 132                 return get_type_max_align(lttng_ust_get_type_enum(type)->container_type);
 133         case lttng_ust_type_array:
 134                 return max_t(size_t, get_type_max_align(lttng_ust_get_type_array(type)->elem_type),
 135                                 lttng_ust_get_type_array(type)->alignment);
 136         case lttng_ust_type_sequence:
 137                 return max_t(size_t, get_type_max_align(lttng_ust_get_type_sequence(type)->elem_type),
 138                                 lttng_ust_get_type_sequence(type)->alignment);
 139         case lttng_ust_type_struct:
 140         {
 141                 unsigned int i;
 142                 size_t field_align = 0;
 143                 const struct lttng_ust_type_struct *struct_type = lttng_ust_get_type_struct(type);
 144
 145                 for (i = 0; i < struct_type->nr_fields; i++) {
 146                         field_align = max_t(size_t,
 147                                 get_type_max_align(struct_type->fields[i]->type),
 148                                 field_align);
 149                 }
 150                 return field_align;
 151         }
 152         default:
 153                 WARN_ON_ONCE(1);
 154                 return 0;
 155         }
 156 }
 157
 158 /*
 159  * lttng_context_update() should be called at least once between context
 160  * modification and trace start.
 161  */
 162 static
 163 void lttng_context_update(struct lttng_ust_ctx *ctx)
 164 {
 165         int i;
 166         size_t largest_align = 8;       /* in bits */
 167
 168         for (i = 0; i < ctx->nr_fields; i++) {
 169                 size_t field_align = 8;
 170
 171                 field_align = get_type_max_align(ctx->fields[i].event_field->type);
 172                 largest_align = max_t(size_t, largest_align, field_align);
 173         }
 174         ctx->largest_align = largest_align >> 3;        /* bits to bytes */
 175 }
 176
 177 int lttng_ust_context_append_rcu(struct lttng_ust_ctx **ctx_p,
 178                 const struct lttng_ust_ctx_field *f)
 179 {
 180         struct lttng_ust_ctx *old_ctx = *ctx_p, *new_ctx = NULL;
 181         struct lttng_ust_ctx_field *new_fields = NULL;
 182         int ret;
 183
 184         if (old_ctx) {
 185                 new_ctx = zmalloc(sizeof(struct lttng_ust_ctx));
 186                 if (!new_ctx)
 187                         return -ENOMEM;
 188                 *new_ctx = *old_ctx;
 189                 new_fields = zmalloc(new_ctx->allocated_fields * sizeof(*new_fields));
 190                 if (!new_fields) {
 191                         free(new_ctx);
 192                         return -ENOMEM;
 193                 }
 194                 /* Copy elements */
 195                 memcpy(new_fields, old_ctx->fields,
 196                                 sizeof(*old_ctx->fields) * old_ctx->nr_fields);
 197                 new_ctx->fields = new_fields;
 198         }
 199         ret = lttng_ust_context_add_field(&new_ctx);
 200         if (ret) {
 201                 free(new_fields);
 202                 free(new_ctx);
 203                 return ret;
 204         }
 205         new_ctx->fields[new_ctx->nr_fields - 1] = *f;
 206         lttng_context_update(new_ctx);
 207         lttng_ust_rcu_assign_pointer(*ctx_p, new_ctx);
 208         lttng_ust_urcu_synchronize_rcu();
 209         if (old_ctx) {
 210                 free(old_ctx->fields);
 211                 free(old_ctx);
 212         }
 213         return 0;
 214 }
 215
 216 int lttng_ust_context_append(struct lttng_ust_ctx **ctx_p,
 217                 const struct lttng_ust_ctx_field *f)
 218 {
 219         int ret;
 220
 221         ret = lttng_ust_context_add_field(ctx_p);
 222         if (ret)
 223                 return ret;
 224         (*ctx_p)->fields[(*ctx_p)->nr_fields - 1] = *f;
 225         lttng_context_update(*ctx_p);
 226         return 0;
 227 }
 228
 229 void lttng_destroy_context(struct lttng_ust_ctx *ctx)
 230 {
 231         int i;
 232
 233         if (!ctx)
 234                 return;
 235         for (i = 0; i < ctx->nr_fields; i++) {
 236                 if (ctx->fields[i].destroy)
 237                         ctx->fields[i].destroy(ctx->fields[i].priv);
 238         }
 239         free(ctx->fields);
 240         free(ctx);
 241 }
 242
 243 /*
 244  * Can be safely performed concurrently with tracing using the struct
 245  * lttng_ctx. Using RCU update. Needs to match RCU read-side handling of
 246  * contexts.
 247  *
 248  * This does not allow adding, removing, or changing typing of the
 249  * contexts, since this needs to stay invariant for metadata. However,
 250  * it allows updating the handlers associated with all contexts matching
 251  * a provider (by name) while tracing is using it, in a way that ensures
 252  * a single RCU read-side critical section see either all old, or all
 253  * new handlers.
 254  */
 255 int lttng_ust_context_set_provider_rcu(struct lttng_ust_ctx **_ctx,
 256                 const char *name,
 257                 size_t (*get_size)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
 258                         size_t offset),
 259                 void (*record)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
 260                         struct lttng_ust_ring_buffer_ctx *ctx,
 261                         struct lttng_ust_channel_buffer *chan),
 262                 void (*get_value)(void *priv, struct lttng_ust_probe_ctx *probe_ctx,
 263                         struct lttng_ust_ctx_value *value),
 264                 void *priv)
 265 {
 266         int i, ret;
 267         struct lttng_ust_ctx *ctx = *_ctx, *new_ctx;
 268         struct lttng_ust_ctx_field *new_fields;
 269
 270         if (!ctx || !lttng_find_context_provider(ctx, name))
 271                 return 0;
 272         /*
 273          * We have at least one instance of context for the provider.
 274          */
 275         new_ctx = zmalloc(sizeof(*new_ctx));
 276         if (!new_ctx)
 277                 return -ENOMEM;
 278         *new_ctx = *ctx;
 279         new_fields = zmalloc(sizeof(*new_fields) * ctx->allocated_fields);
 280         if (!new_fields) {
 281                 ret = -ENOMEM;
 282                 goto field_error;
 283         }
 284         /* Copy elements */
 285         memcpy(new_fields, ctx->fields,
 286                 sizeof(*new_fields) * ctx->allocated_fields);
 287         for (i = 0; i < ctx->nr_fields; i++) {
 288                 if (strncmp(new_fields[i].event_field->name,
 289                                 name, strlen(name)) != 0)
 290                         continue;
 291                 new_fields[i].get_size = get_size;
 292                 new_fields[i].record = record;
 293                 new_fields[i].get_value = get_value;
 294                 new_fields[i].priv = priv;
 295         }
 296         new_ctx->fields = new_fields;
 297         lttng_ust_rcu_assign_pointer(*_ctx, new_ctx);
 298         lttng_ust_urcu_synchronize_rcu();
 299         free(ctx->fields);
 300         free(ctx);
 301         return 0;
 302
 303 field_error:
 304         free(new_ctx);
 305         return ret;
 306 }
 307
 308 int lttng_context_init_all(struct lttng_ust_ctx **ctx)
 309 {
 310         int ret;
 311
 312         ret = lttng_add_pthread_id_to_ctx(ctx);
 313         if (ret) {
 314                 WARN("Cannot add context lttng_add_pthread_id_to_ctx");
 315                 goto error;
 316         }
 317         ret = lttng_add_vtid_to_ctx(ctx);
 318         if (ret) {
 319                 WARN("Cannot add context lttng_add_vtid_to_ctx");
 320                 goto error;
 321         }
 322         ret = lttng_add_vpid_to_ctx(ctx);
 323         if (ret) {
 324                 WARN("Cannot add context lttng_add_vpid_to_ctx");
 325                 goto error;
 326         }
 327         ret = lttng_add_procname_to_ctx(ctx);
 328         if (ret) {
 329                 WARN("Cannot add context lttng_add_procname_to_ctx");
 330                 goto error;
 331         }
 332         ret = lttng_add_cpu_id_to_ctx(ctx);
 333         if (ret) {
 334                 WARN("Cannot add context lttng_add_cpu_id_to_ctx");
 335                 goto error;
 336         }
 337         ret = lttng_add_cgroup_ns_to_ctx(ctx);
 338         if (ret) {
 339                 WARN("Cannot add context lttng_add_cgroup_ns_to_ctx");
 340                 goto error;
 341         }
 342         ret = lttng_add_ipc_ns_to_ctx(ctx);
 343         if (ret) {
 344                 WARN("Cannot add context lttng_add_ipc_ns_to_ctx");
 345                 goto error;
 346         }
 347         ret = lttng_add_mnt_ns_to_ctx(ctx);
 348         if (ret) {
 349                 WARN("Cannot add context lttng_add_mnt_ns_to_ctx");
 350                 goto error;
 351         }
 352         ret = lttng_add_net_ns_to_ctx(ctx);
 353         if (ret) {
 354                 WARN("Cannot add context lttng_add_net_ns_to_ctx");
 355                 goto error;
 356         }
 357         ret = lttng_add_pid_ns_to_ctx(ctx);
 358         if (ret) {
 359                 WARN("Cannot add context lttng_add_pid_ns_to_ctx");
 360                 goto error;
 361         }
 362         ret = lttng_add_time_ns_to_ctx(ctx);
 363         if (ret) {
 364                 WARN("Cannot add context lttng_add_time_ns_to_ctx");
 365                 goto error;
 366         }
 367         ret = lttng_add_user_ns_to_ctx(ctx);
 368         if (ret) {
 369                 WARN("Cannot add context lttng_add_user_ns_to_ctx");
 370                 goto error;
 371         }
 372         ret = lttng_add_uts_ns_to_ctx(ctx);
 373         if (ret) {
 374                 WARN("Cannot add context lttng_add_uts_ns_to_ctx");
 375                 goto error;
 376         }
 377         ret = lttng_add_vuid_to_ctx(ctx);
 378         if (ret) {
 379                 WARN("Cannot add context lttng_add_vuid_to_ctx");
 380                 goto error;
 381         }
 382         ret = lttng_add_veuid_to_ctx(ctx);
 383         if (ret) {
 384                 WARN("Cannot add context lttng_add_veuid_to_ctx");
 385                 goto error;
 386         }
 387         ret = lttng_add_vsuid_to_ctx(ctx);
 388         if (ret) {
 389                 WARN("Cannot add context lttng_add_vsuid_to_ctx");
 390                 goto error;
 391         }
 392         ret = lttng_add_vgid_to_ctx(ctx);
 393         if (ret) {
 394                 WARN("Cannot add context lttng_add_vgid_to_ctx");
 395                 goto error;
 396         }
 397         ret = lttng_add_vegid_to_ctx(ctx);
 398         if (ret) {
 399                 WARN("Cannot add context lttng_add_vegid_to_ctx");
 400                 goto error;
 401         }
 402         ret = lttng_add_vsgid_to_ctx(ctx);
 403         if (ret) {
 404                 WARN("Cannot add context lttng_add_vsgid_to_ctx");
 405                 goto error;
 406         }
 407         lttng_context_update(*ctx);
 408         return 0;
 409
 410 error:
 411         lttng_destroy_context(*ctx);
 412         return ret;
 413 }