src/lib/lttng-ctl/event-expr.c

   1 /*
   2  * event-expr.c
   3  *
   4  * Linux Trace Toolkit Control Library
   5  *
   6  * Copyright (C) 2020 Philippe Proulx <pproulx@efficios.com>
   7  *
   8  * SPDX-License-Identifier: LGPL-2.1-only
   9  *
  10  */
  11
  12 #define _LGPL_SOURCE
  13 #include <assert.h>
  14 #include <stddef.h>
  15
  16 #include <common/error.h>
  17 #include <common/macros.h>
  18 #include <lttng/event-expr-internal.h>
  19
  20 enum lttng_event_expr_type lttng_event_expr_get_type(
  21                 const struct lttng_event_expr *expr)
  22 {
  23         enum lttng_event_expr_type type;
  24
  25         if (!expr) {
  26                 type = LTTNG_EVENT_EXPR_TYPE_INVALID;
  27                 goto end;
  28         }
  29
  30         type = expr->type;
  31
  32 end:
  33         return type;
  34 }
  35
  36 static
  37 struct lttng_event_expr *create_empty_expr(enum lttng_event_expr_type type,
  38                 size_t size)
  39 {
  40         struct lttng_event_expr *expr;
  41
  42         expr = zmalloc(size);
  43         if (!expr) {
  44                 goto end;
  45         }
  46
  47         expr->type = type;
  48
  49 end:
  50         return expr;
  51 }
  52
  53 static
  54 struct lttng_event_expr_field *create_field_event_expr(
  55                 enum lttng_event_expr_type type,
  56                 const char *name)
  57 {
  58         struct lttng_event_expr_field *expr =
  59                         container_of(
  60                                 create_empty_expr(type, sizeof(*expr)),
  61                                 struct lttng_event_expr_field, parent);
  62
  63         if (!expr) {
  64                 goto error;
  65         }
  66
  67         assert(name);
  68         expr->name = strdup(name);
  69         if (!expr->name) {
  70                 goto error;
  71         }
  72
  73         goto end;
  74
  75 error:
  76         if (expr) {
  77                 lttng_event_expr_destroy(&expr->parent);
  78         }
  79         expr = NULL;
  80
  81 end:
  82         return expr;
  83 }
  84
  85 struct lttng_event_expr *lttng_event_expr_event_payload_field_create(
  86                 const char *field_name)
  87 {
  88         struct lttng_event_expr *expr = NULL;
  89
  90         if (!field_name) {
  91                 goto end;
  92         }
  93
  94         expr = &create_field_event_expr(
  95                         LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD,
  96                         field_name)->parent;
  97
  98 end:
  99         return expr;
 100 }
 101
 102 struct lttng_event_expr *lttng_event_expr_channel_context_field_create(
 103                 const char *field_name)
 104 {
 105         struct lttng_event_expr *expr = NULL;
 106
 107         if (!field_name) {
 108                 goto end;
 109         }
 110
 111         expr = &create_field_event_expr(
 112                         LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD,
 113                         field_name)->parent;
 114
 115 end:
 116         return expr;
 117 }
 118
 119 struct lttng_event_expr *lttng_event_expr_app_specific_context_field_create(
 120                 const char *provider_name, const char *type_name)
 121 {
 122         struct lttng_event_expr_app_specific_context_field *expr = NULL;
 123         struct lttng_event_expr *ret_parent_expr;
 124
 125         if (!type_name || !provider_name) {
 126                 goto error;
 127         }
 128
 129         expr = container_of(create_empty_expr(
 130                         LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD,
 131                         sizeof(*expr)),
 132                         struct lttng_event_expr_app_specific_context_field,
 133                         parent);
 134         if (!expr) {
 135                 goto error;
 136         }
 137
 138         expr->provider_name = strdup(provider_name);
 139         if (!expr->provider_name) {
 140                 goto error;
 141         }
 142
 143         expr->type_name = strdup(type_name);
 144         if (!expr->type_name) {
 145                 goto error;
 146         }
 147
 148         ret_parent_expr = &expr->parent;
 149         goto end;
 150
 151 error:
 152         if (expr) {
 153                 lttng_event_expr_destroy(&expr->parent);
 154         }
 155         ret_parent_expr = NULL;
 156
 157 end:
 158         return ret_parent_expr;
 159 }
 160
 161 struct lttng_event_expr *lttng_event_expr_array_field_element_create(
 162                 struct lttng_event_expr *array_field_expr,
 163                 unsigned int index)
 164 {
 165         struct lttng_event_expr_array_field_element *expr = NULL;
 166         struct lttng_event_expr *ret_parent_expr;
 167
 168         /* The parent array field expression must be an l-value */
 169         if (!array_field_expr ||
 170                         !lttng_event_expr_is_lvalue(array_field_expr)) {
 171                 goto error;
 172         }
 173
 174         expr = container_of(create_empty_expr(
 175                         LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT,
 176                         sizeof(*expr)),
 177                         struct lttng_event_expr_array_field_element,
 178                         parent);
 179         if (!expr) {
 180                 goto error;
 181         }
 182
 183         expr->array_field_expr = array_field_expr;
 184         expr->index = index;
 185         ret_parent_expr = &expr->parent;
 186         goto end;
 187
 188 error:
 189         if (expr) {
 190                 lttng_event_expr_destroy(&expr->parent);
 191         }
 192         ret_parent_expr = NULL;
 193
 194 end:
 195         return ret_parent_expr;
 196 }
 197
 198 const char *lttng_event_expr_event_payload_field_get_name(
 199                 const struct lttng_event_expr *expr)
 200 {
 201         const char *ret = NULL;
 202
 203         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD) {
 204                 goto end;
 205         }
 206
 207         ret = container_of(expr,
 208                         const struct lttng_event_expr_field, parent)->name;
 209
 210 end:
 211         return ret;
 212 }
 213
 214 const char *lttng_event_expr_channel_context_field_get_name(
 215                 const struct lttng_event_expr *expr)
 216 {
 217         const char *ret = NULL;
 218
 219         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD) {
 220                 goto end;
 221         }
 222
 223         ret = container_of(expr,
 224                         const struct lttng_event_expr_field, parent)->name;
 225
 226 end:
 227         return ret;
 228 }
 229
 230 const char *lttng_event_expr_app_specific_context_field_get_provider_name(
 231                 const struct lttng_event_expr *expr)
 232 {
 233         const char *ret = NULL;
 234
 235         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD) {
 236                 goto end;
 237         }
 238
 239         ret = container_of(expr,
 240                         const struct lttng_event_expr_app_specific_context_field,
 241                         parent)->provider_name;
 242
 243 end:
 244         return ret;
 245 }
 246
 247 const char *lttng_event_expr_app_specific_context_field_get_type_name(
 248                 const struct lttng_event_expr *expr)
 249 {
 250         const char *ret = NULL;
 251
 252         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD) {
 253                 goto end;
 254         }
 255
 256         ret = container_of(expr,
 257                         const struct lttng_event_expr_app_specific_context_field,
 258                         parent)->type_name;
 259
 260 end:
 261         return ret;
 262 }
 263
 264 const struct lttng_event_expr *
 265 lttng_event_expr_array_field_element_get_parent_expr(
 266                 const struct lttng_event_expr *expr)
 267 {
 268         const struct lttng_event_expr *ret = NULL;
 269
 270         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT) {
 271                 goto end;
 272         }
 273
 274         ret = container_of(expr,
 275                         const struct lttng_event_expr_array_field_element,
 276                         parent)->array_field_expr;
 277
 278 end:
 279         return ret;
 280 }
 281
 282 enum lttng_event_expr_status lttng_event_expr_array_field_element_get_index(
 283                 const struct lttng_event_expr *expr, unsigned int *index)
 284 {
 285         enum lttng_event_expr_status ret = LTTNG_EVENT_EXPR_STATUS_OK;
 286
 287         if (!expr || expr->type != LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT ||
 288                         !index) {
 289                 ret = LTTNG_EVENT_EXPR_STATUS_INVALID;
 290                 goto end;
 291         }
 292
 293         *index = container_of(expr,
 294                         const struct lttng_event_expr_array_field_element,
 295                         parent)->index;
 296
 297 end:
 298         return ret;
 299 }
 300
 301 bool lttng_event_expr_is_equal(const struct lttng_event_expr *expr_a,
 302                 const struct lttng_event_expr *expr_b)
 303 {
 304         bool is_equal = true;
 305
 306         if (!expr_a && !expr_b) {
 307                 /* Both `NULL`: equal */
 308                 goto end;
 309         }
 310
 311         if (!expr_a || !expr_b) {
 312                 /* Only one `NULL`: not equal */
 313                 goto not_equal;
 314         }
 315
 316         if (expr_a->type != expr_b->type) {
 317                 /* Different types: not equal */
 318                 goto not_equal;
 319         }
 320
 321         switch (expr_a->type) {
 322         case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
 323         case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
 324         {
 325                 const struct lttng_event_expr_field *field_expr_a =
 326                                 container_of(expr_a,
 327                                         const struct lttng_event_expr_field,
 328                                         parent);
 329                 const struct lttng_event_expr_field *field_expr_b =
 330                                 container_of(expr_b,
 331                                         const struct lttng_event_expr_field,
 332                                         parent);
 333
 334                 if (strcmp(field_expr_a->name, field_expr_b->name) != 0) {
 335                         goto not_equal;
 336                 }
 337
 338                 break;
 339         }
 340         case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
 341         {
 342                 const struct lttng_event_expr_app_specific_context_field *field_expr_a =
 343                                 container_of(expr_a,
 344                                         const struct lttng_event_expr_app_specific_context_field,
 345                                         parent);
 346                 const struct lttng_event_expr_app_specific_context_field *field_expr_b =
 347                                 container_of(expr_b,
 348                                         const struct lttng_event_expr_app_specific_context_field,
 349                                         parent);
 350
 351                 if (strcmp(field_expr_a->provider_name,
 352                                 field_expr_b->provider_name) != 0) {
 353                         goto not_equal;
 354                 }
 355
 356                 if (strcmp(field_expr_a->type_name,
 357                                 field_expr_b->type_name) != 0) {
 358                         goto not_equal;
 359                 }
 360
 361                 break;
 362         }
 363         case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
 364         {
 365                 const struct lttng_event_expr_array_field_element *elem_expr_a =
 366                                 container_of(expr_a,
 367                                         const struct lttng_event_expr_array_field_element,
 368                                         parent);
 369                 const struct lttng_event_expr_array_field_element *elem_expr_b =
 370                                 container_of(expr_b,
 371                                         const struct lttng_event_expr_array_field_element,
 372                                         parent);
 373
 374                 if (!lttng_event_expr_is_equal(elem_expr_a->array_field_expr,
 375                                 elem_expr_b->array_field_expr)) {
 376                         goto not_equal;
 377                 }
 378
 379                 if (elem_expr_a->index != elem_expr_b->index) {
 380                         goto not_equal;
 381                 }
 382
 383                 break;
 384         }
 385         default:
 386                 break;
 387         }
 388
 389         goto end;
 390
 391 not_equal:
 392         is_equal = false;
 393
 394 end:
 395         return is_equal;
 396 }
 397
 398 void lttng_event_expr_destroy(struct lttng_event_expr *expr)
 399 {
 400         if (!expr) {
 401                 goto end;
 402         }
 403
 404         switch (expr->type) {
 405         case LTTNG_EVENT_EXPR_TYPE_EVENT_PAYLOAD_FIELD:
 406         case LTTNG_EVENT_EXPR_TYPE_CHANNEL_CONTEXT_FIELD:
 407         {
 408                 struct lttng_event_expr_field *field_expr =
 409                                 container_of(expr,
 410                                         struct lttng_event_expr_field, parent);
 411
 412                 free(field_expr->name);
 413                 break;
 414         }
 415         case LTTNG_EVENT_EXPR_TYPE_APP_SPECIFIC_CONTEXT_FIELD:
 416         {
 417                 struct lttng_event_expr_app_specific_context_field *field_expr =
 418                                 container_of(expr,
 419                                         struct lttng_event_expr_app_specific_context_field,
 420                                         parent);
 421
 422                 free(field_expr->provider_name);
 423                 free(field_expr->type_name);
 424                 break;
 425         }
 426         case LTTNG_EVENT_EXPR_TYPE_ARRAY_FIELD_ELEMENT:
 427         {
 428                 struct lttng_event_expr_array_field_element *elem_expr =
 429                                 container_of(expr,
 430                                         struct lttng_event_expr_array_field_element,
 431                                         parent);
 432
 433                 lttng_event_expr_destroy(elem_expr->array_field_expr);
 434                 break;
 435         }
 436         default:
 437                 break;
 438         }
 439
 440         free(expr);
 441
 442 end:
 443         return;
 444 }