src/common/actions/snapshot-session.cpp

   1 /*
   2  * Copyright (C) 2019 Simon Marchi <simon.marchi@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #include <common/error.hpp>
   9 #include <common/macros.hpp>
  10 #include <common/mi-lttng.hpp>
  11 #include <common/payload-view.hpp>
  12 #include <common/payload.hpp>
  13 #include <common/snapshot.hpp>
  14 #include <inttypes.h>
  15 #include <lttng/action/action-internal.hpp>
  16 #include <lttng/action/rate-policy-internal.hpp>
  17 #include <lttng/action/rate-policy.h>
  18 #include <lttng/action/snapshot-session-internal.hpp>
  19 #include <lttng/action/snapshot-session.h>
  20 #include <lttng/snapshot-internal.hpp>
  21 #include <lttng/snapshot.h>
  22
  23 #define IS_SNAPSHOT_SESSION_ACTION(action) \
  24         (lttng_action_get_type(action) == LTTNG_ACTION_TYPE_SNAPSHOT_SESSION)
  25
  26 struct lttng_action_snapshot_session {
  27         struct lttng_action parent;
  28
  29         /* Owned by this. */
  30         char *session_name;
  31
  32         /*
  33          * When non-NULL, use this custom output when taking the snapshot,
  34          * rather than the session's registered snapshot output.
  35          *
  36          * Owned by this.
  37          */
  38         struct lttng_snapshot_output *output;
  39         struct lttng_rate_policy *policy;
  40 };
  41
  42 struct lttng_action_snapshot_session_comm {
  43         /* All string lengths include the trailing \0. */
  44         uint32_t session_name_len;
  45         uint32_t snapshot_output_len;
  46         uint32_t rate_policy_len;
  47
  48         /*
  49          * Variable data (all strings are null-terminated):
  50          *
  51          *  - session name string
  52          *  - snapshot output object
  53          *  - policy object
  54          */
  55         char data[];
  56 } LTTNG_PACKED;
  57
  58 static const struct lttng_rate_policy *
  59 lttng_action_snapshot_session_internal_get_rate_policy(
  60                 const struct lttng_action *action);
  61
  62 static struct lttng_action_snapshot_session *
  63 action_snapshot_session_from_action(struct lttng_action *action)
  64 {
  65         LTTNG_ASSERT(action);
  66
  67         return container_of(
  68                         action, struct lttng_action_snapshot_session, parent);
  69 }
  70
  71 static const struct lttng_action_snapshot_session *
  72 action_snapshot_session_from_action_const(const struct lttng_action *action)
  73 {
  74         LTTNG_ASSERT(action);
  75
  76         return container_of(
  77                         action, struct lttng_action_snapshot_session, parent);
  78 }
  79
  80 static bool lttng_action_snapshot_session_validate(struct lttng_action *action)
  81 {
  82         bool valid = false;
  83         struct lttng_action_snapshot_session *action_snapshot_session;
  84
  85         if (!action) {
  86                 goto end;
  87         }
  88
  89         action_snapshot_session = action_snapshot_session_from_action(action);
  90
  91         /* A non-empty session name is mandatory. */
  92         if (!action_snapshot_session->session_name ||
  93                         strlen(action_snapshot_session->session_name) == 0) {
  94                 goto end;
  95         }
  96
  97         if (action_snapshot_session->output &&
  98                         !lttng_snapshot_output_validate(action_snapshot_session->output)) {
  99                 goto end;
 100         }
 101
 102         valid = true;
 103 end:
 104         return valid;
 105 }
 106
 107 static bool lttng_action_snapshot_session_is_equal(
 108                 const struct lttng_action *_a, const struct lttng_action *_b)
 109 {
 110         bool is_equal = false;
 111         const struct lttng_action_snapshot_session *a, *b;
 112
 113         a = action_snapshot_session_from_action_const(_a);
 114         b = action_snapshot_session_from_action_const(_b);
 115
 116         /* Action is not valid if this is not true. */
 117         LTTNG_ASSERT(a->session_name);
 118         LTTNG_ASSERT(b->session_name);
 119         if (strcmp(a->session_name, b->session_name)) {
 120                 goto end;
 121         }
 122
 123         if (a->output && b->output &&
 124                         !lttng_snapshot_output_is_equal(a->output, b->output)) {
 125                 goto end;
 126         } else if (!!a->output != !!b->output) {
 127                 goto end;
 128         }
 129
 130         is_equal = lttng_rate_policy_is_equal(a->policy, b->policy);
 131 end:
 132         return is_equal;
 133 }
 134
 135 static size_t serialize_strlen(const char *str)
 136 {
 137         return str ? strlen(str) + 1 : 0;
 138 }
 139
 140 static int lttng_action_snapshot_session_serialize(
 141                 struct lttng_action *action, struct lttng_payload *payload)
 142 {
 143         struct lttng_action_snapshot_session *action_snapshot_session;
 144         struct lttng_action_snapshot_session_comm comm = {};
 145         int ret;
 146         size_t size_before_comm;
 147
 148         LTTNG_ASSERT(action);
 149         LTTNG_ASSERT(payload);
 150
 151         size_before_comm = payload->buffer.size;
 152
 153         action_snapshot_session = action_snapshot_session_from_action(action);
 154         comm.session_name_len =
 155                 serialize_strlen(action_snapshot_session->session_name);
 156
 157         /* Add header. */
 158         ret = lttng_dynamic_buffer_append(
 159                         &payload->buffer, &comm, sizeof(comm));
 160         if (ret) {
 161                 goto end;
 162         }
 163
 164         LTTNG_ASSERT(action_snapshot_session->session_name);
 165         DBG("Serializing snapshot session action: session-name: %s",
 166                         action_snapshot_session->session_name);
 167
 168         /* Add session name. */
 169         ret = lttng_dynamic_buffer_append(&payload->buffer,
 170                         action_snapshot_session->session_name,
 171                         comm.session_name_len);
 172         if (ret) {
 173                 goto end;
 174         }
 175
 176         /* Serialize the snapshot output object, if any. */
 177         if (action_snapshot_session->output) {
 178                 const size_t size_before_output = payload->buffer.size;
 179                 struct lttng_action_snapshot_session_comm *comm_in_payload;
 180
 181                 ret = lttng_snapshot_output_serialize(
 182                                 action_snapshot_session->output,
 183                                 payload);
 184                 if (ret) {
 185                         goto end;
 186                 }
 187
 188                 comm_in_payload = (typeof(comm_in_payload))(
 189                                 payload->buffer.data + size_before_comm);
 190                 /* Adjust action length in header. */
 191                 comm_in_payload->snapshot_output_len =
 192                                 payload->buffer.size - size_before_output;
 193         }
 194
 195         /* Serialize the rate policy. */
 196         {
 197                 const size_t size_before_output = payload->buffer.size;
 198                 struct lttng_action_snapshot_session_comm *comm_in_payload;
 199
 200                 ret = lttng_rate_policy_serialize(
 201                                 action_snapshot_session->policy, payload);
 202                 if (ret) {
 203                         ret = -1;
 204                         goto end;
 205                 }
 206
 207                 comm_in_payload = (typeof(comm_in_payload))(
 208                                 payload->buffer.data + size_before_comm);
 209                 /* Adjust rate policy length in header. */
 210                 comm_in_payload->rate_policy_len =
 211                                 payload->buffer.size - size_before_output;
 212         }
 213
 214 end:
 215         return ret;
 216 }
 217
 218 static void lttng_action_snapshot_session_destroy(struct lttng_action *action)
 219 {
 220         struct lttng_action_snapshot_session *action_snapshot_session;
 221
 222         if (!action) {
 223                 goto end;
 224         }
 225
 226         action_snapshot_session = action_snapshot_session_from_action(action);
 227
 228         free(action_snapshot_session->session_name);
 229         lttng_snapshot_output_destroy(action_snapshot_session->output);
 230         lttng_rate_policy_destroy(action_snapshot_session->policy);
 231         free(action_snapshot_session);
 232
 233 end:
 234         return;
 235 }
 236
 237 ssize_t lttng_action_snapshot_session_create_from_payload(
 238                 struct lttng_payload_view *view,
 239                 struct lttng_action **p_action)
 240 {
 241         ssize_t consumed_len;
 242         const char *variable_data;
 243         struct lttng_action *action;
 244         enum lttng_action_status status;
 245         struct lttng_snapshot_output *snapshot_output = NULL;
 246         struct lttng_rate_policy *policy = NULL;
 247         const struct lttng_action_snapshot_session_comm *comm;
 248         const struct lttng_payload_view snapshot_session_comm_view =
 249                         lttng_payload_view_from_view(
 250                                 view, 0, sizeof(*comm));
 251
 252         action = lttng_action_snapshot_session_create();
 253         if (!action) {
 254                 goto error;
 255         }
 256
 257         if (!lttng_payload_view_is_valid(&snapshot_session_comm_view)) {
 258                 /* Payload not large enough to contain the header. */
 259                 goto error;
 260         }
 261
 262         comm = (typeof(comm)) snapshot_session_comm_view.buffer.data;
 263         variable_data = (const char *) &comm->data;
 264
 265         consumed_len = sizeof(struct lttng_action_snapshot_session_comm);
 266
 267         if (!lttng_buffer_view_contains_string(
 268                         &view->buffer, variable_data, comm->session_name_len)) {
 269                 goto error;
 270         }
 271
 272         status = lttng_action_snapshot_session_set_session_name(
 273                         action, variable_data);
 274         if (status != LTTNG_ACTION_STATUS_OK) {
 275                 goto error;
 276         }
 277
 278         variable_data += comm->session_name_len;
 279         consumed_len += comm->session_name_len;
 280
 281         /* If there is a snapshot output object, deserialize it. */
 282         if (comm->snapshot_output_len > 0) {
 283                 ssize_t snapshot_output_consumed_len;
 284                 enum lttng_action_status action_status;
 285                 struct lttng_payload_view snapshot_output_buffer_view =
 286                         lttng_payload_view_from_view(view, consumed_len,
 287                                 comm->snapshot_output_len);
 288
 289                 if (!lttng_payload_view_is_valid(&snapshot_output_buffer_view)) {
 290                         ERR("Failed to create buffer view for snapshot output.");
 291                         goto error;
 292                 }
 293
 294                 snapshot_output_consumed_len =
 295                                 lttng_snapshot_output_create_from_payload(
 296                                                 &snapshot_output_buffer_view,
 297                                                 &snapshot_output);
 298                 if (snapshot_output_consumed_len != comm->snapshot_output_len) {
 299                         ERR("Failed to deserialize snapshot output object: "
 300                                         "consumed-len: %zd, expected-len: %" PRIu32,
 301                                         snapshot_output_consumed_len,
 302                                         comm->snapshot_output_len);
 303                         goto error;
 304                 }
 305
 306                 action_status = lttng_action_snapshot_session_set_output(
 307                         action, snapshot_output);
 308                 if (action_status != LTTNG_ACTION_STATUS_OK) {
 309                         goto error;
 310                 }
 311
 312                 /* Ownership has been transferred to the action. */
 313                 snapshot_output = NULL;
 314         }
 315
 316         variable_data += comm->snapshot_output_len;
 317         consumed_len += comm->snapshot_output_len;
 318
 319         /* Rate policy. */
 320         if (comm->rate_policy_len <= 0) {
 321                 ERR("Rate policy should be present.");
 322                 goto error;
 323         }
 324         {
 325                 ssize_t rate_policy_consumed_len;
 326                 struct lttng_payload_view policy_view =
 327                                 lttng_payload_view_from_view(view, consumed_len,
 328                                                 comm->rate_policy_len);
 329
 330                 if (!lttng_payload_view_is_valid(&policy_view)) {
 331                         ERR("Failed to create buffer view for rate policy.");
 332                         goto error;
 333                 }
 334
 335                 rate_policy_consumed_len =
 336                                 lttng_rate_policy_create_from_payload(
 337                                                 &policy_view, &policy);
 338                 if (rate_policy_consumed_len < 0) {
 339                         goto error;
 340                 }
 341
 342                 if (rate_policy_consumed_len != comm->rate_policy_len) {
 343                         ERR("Failed to deserialize rate policy object: "
 344                             "consumed-len: %zd, expected-len: %" PRIu32,
 345                                         rate_policy_consumed_len,
 346                                         comm->rate_policy_len);
 347                         goto error;
 348                 }
 349
 350                 status = lttng_action_snapshot_session_set_rate_policy(
 351                                 action, policy);
 352                 if (status != LTTNG_ACTION_STATUS_OK) {
 353                         goto error;
 354                 }
 355         }
 356
 357         variable_data += comm->rate_policy_len;
 358         consumed_len += comm->rate_policy_len;
 359
 360         *p_action = action;
 361         action = NULL;
 362
 363         goto end;
 364
 365 error:
 366         consumed_len = -1;
 367
 368 end:
 369         lttng_rate_policy_destroy(policy);
 370         lttng_action_snapshot_session_destroy(action);
 371         lttng_snapshot_output_destroy(snapshot_output);
 372
 373         return consumed_len;
 374 }
 375
 376 static enum lttng_error_code lttng_action_snapshot_session_mi_serialize(
 377                 const struct lttng_action *action, struct mi_writer *writer)
 378 {
 379         int ret;
 380         enum lttng_error_code ret_code;
 381         enum lttng_action_status status;
 382         const char *session_name = NULL;
 383         const struct lttng_snapshot_output *output = NULL;
 384         const struct lttng_rate_policy *policy = NULL;
 385
 386         LTTNG_ASSERT(action);
 387         LTTNG_ASSERT(IS_SNAPSHOT_SESSION_ACTION(action));
 388
 389         status = lttng_action_snapshot_session_get_session_name(
 390                         action, &session_name);
 391         LTTNG_ASSERT(status == LTTNG_ACTION_STATUS_OK);
 392         LTTNG_ASSERT(session_name != NULL);
 393
 394         status = lttng_action_snapshot_session_get_rate_policy(action, &policy);
 395         LTTNG_ASSERT(status == LTTNG_ACTION_STATUS_OK);
 396         LTTNG_ASSERT(policy != NULL);
 397
 398         /* Open action snapshot session element. */
 399         ret = mi_lttng_writer_open_element(
 400                         writer, mi_lttng_element_action_snapshot_session);
 401         if (ret) {
 402                 goto mi_error;
 403         }
 404
 405         /* Session name. */
 406         ret = mi_lttng_writer_write_element_string(
 407                         writer, mi_lttng_element_session_name, session_name);
 408         if (ret) {
 409                 goto mi_error;
 410         }
 411
 412         /* Output if any. */
 413         status = lttng_action_snapshot_session_get_output(action, &output);
 414         if (status == LTTNG_ACTION_STATUS_OK) {
 415                 LTTNG_ASSERT(output != NULL);
 416                 ret_code = lttng_snapshot_output_mi_serialize(output, writer);
 417                 if (ret_code != LTTNG_OK) {
 418                         goto end;
 419                 }
 420         } else if (status != LTTNG_ACTION_STATUS_UNSET) {
 421                 /* This should not happen at this point. */
 422                 abort();
 423         }
 424
 425         /* Rate policy. */
 426         ret_code = lttng_rate_policy_mi_serialize(policy, writer);
 427         if (ret_code != LTTNG_OK) {
 428                 goto end;
 429         }
 430
 431         /* Close action_snapshot_session element. */
 432         ret = mi_lttng_writer_close_element(writer);
 433         if (ret) {
 434                 goto mi_error;
 435         }
 436
 437         ret_code = LTTNG_OK;
 438         goto end;
 439
 440 mi_error:
 441         ret_code = LTTNG_ERR_MI_IO_FAIL;
 442 end:
 443         return ret_code;
 444 }
 445
 446 struct lttng_action *lttng_action_snapshot_session_create(void)
 447 {
 448         struct lttng_action *action = NULL;
 449         struct lttng_rate_policy *policy = NULL;
 450         enum lttng_action_status status;
 451
 452         /* Create a every N = 1 rate policy. */
 453         policy = lttng_rate_policy_every_n_create(1);
 454         if (!policy) {
 455                 goto end;
 456         }
 457
 458         action = (lttng_action *) zmalloc(sizeof(struct lttng_action_snapshot_session));
 459         if (!action) {
 460                 goto end;
 461         }
 462
 463         lttng_action_init(action, LTTNG_ACTION_TYPE_SNAPSHOT_SESSION,
 464                         lttng_action_snapshot_session_validate,
 465                         lttng_action_snapshot_session_serialize,
 466                         lttng_action_snapshot_session_is_equal,
 467                         lttng_action_snapshot_session_destroy,
 468                         lttng_action_snapshot_session_internal_get_rate_policy,
 469                         lttng_action_generic_add_error_query_results,
 470                         lttng_action_snapshot_session_mi_serialize);
 471
 472         status = lttng_action_snapshot_session_set_rate_policy(action, policy);
 473         if (status != LTTNG_ACTION_STATUS_OK) {
 474                 free(action);
 475                 action = NULL;
 476                 goto end;
 477         }
 478
 479 end:
 480         lttng_rate_policy_destroy(policy);
 481         return action;
 482 }
 483
 484 enum lttng_action_status lttng_action_snapshot_session_set_session_name(
 485                 struct lttng_action *action, const char *session_name)
 486 {
 487         struct lttng_action_snapshot_session *action_snapshot_session;
 488         enum lttng_action_status status;
 489
 490         if (!action || !IS_SNAPSHOT_SESSION_ACTION(action) || !session_name ||
 491                         strlen(session_name) == 0) {
 492                 status = LTTNG_ACTION_STATUS_INVALID;
 493                 goto end;
 494         }
 495
 496         action_snapshot_session = action_snapshot_session_from_action(action);
 497
 498         free(action_snapshot_session->session_name);
 499
 500         action_snapshot_session->session_name = strdup(session_name);
 501         if (!action_snapshot_session->session_name) {
 502                 status = LTTNG_ACTION_STATUS_ERROR;
 503                 goto end;
 504         }
 505
 506         status = LTTNG_ACTION_STATUS_OK;
 507 end:
 508         return status;
 509 }
 510
 511 enum lttng_action_status lttng_action_snapshot_session_get_session_name(
 512                 const struct lttng_action *action, const char **session_name)
 513 {
 514         const struct lttng_action_snapshot_session *action_snapshot_session;
 515         enum lttng_action_status status;
 516
 517         if (!action || !IS_SNAPSHOT_SESSION_ACTION(action) || !session_name) {
 518                 status = LTTNG_ACTION_STATUS_INVALID;
 519                 goto end;
 520         }
 521
 522         action_snapshot_session = action_snapshot_session_from_action_const(action);
 523
 524         if (action_snapshot_session->session_name) {
 525                 *session_name = action_snapshot_session->session_name;
 526                 status = LTTNG_ACTION_STATUS_OK;
 527         } else {
 528                 status = LTTNG_ACTION_STATUS_UNSET;
 529         }
 530
 531 end:
 532
 533         return status;
 534 }
 535
 536 enum lttng_action_status lttng_action_snapshot_session_set_output(
 537                 struct lttng_action *action,
 538                 struct lttng_snapshot_output *output)
 539 {
 540         struct lttng_action_snapshot_session *action_snapshot_session;
 541         enum lttng_action_status status;
 542
 543         if (!action || !IS_SNAPSHOT_SESSION_ACTION(action) || !output) {
 544                 status = LTTNG_ACTION_STATUS_INVALID;
 545                 goto end;
 546         }
 547
 548         action_snapshot_session = action_snapshot_session_from_action(action);
 549
 550         lttng_snapshot_output_destroy(action_snapshot_session->output);
 551         action_snapshot_session->output = output;
 552
 553         status = LTTNG_ACTION_STATUS_OK;
 554
 555 end:
 556         return status;
 557 }
 558
 559 enum lttng_action_status lttng_action_snapshot_session_get_output(
 560                 const struct lttng_action *action,
 561                 const struct lttng_snapshot_output **output)
 562 {
 563         const struct lttng_action_snapshot_session *action_snapshot_session;
 564         enum lttng_action_status status;
 565
 566         if (!action || !IS_SNAPSHOT_SESSION_ACTION(action)|| !output) {
 567                 status = LTTNG_ACTION_STATUS_INVALID;
 568                 goto end;
 569         }
 570
 571         action_snapshot_session = action_snapshot_session_from_action_const(action);
 572
 573         if (action_snapshot_session->output) {
 574                 *output = action_snapshot_session->output;
 575                 status = LTTNG_ACTION_STATUS_OK;
 576         } else {
 577                 status = LTTNG_ACTION_STATUS_UNSET;
 578         }
 579
 580 end:
 581         return status;
 582 }
 583
 584 enum lttng_action_status lttng_action_snapshot_session_set_rate_policy(
 585                 struct lttng_action *action,
 586                 const struct lttng_rate_policy *policy)
 587 {
 588         enum lttng_action_status status;
 589         struct lttng_action_snapshot_session *snapshot_session_action;
 590         struct lttng_rate_policy *copy = NULL;
 591
 592         if (!action || !policy || !IS_SNAPSHOT_SESSION_ACTION(action)) {
 593                 status = LTTNG_ACTION_STATUS_INVALID;
 594                 goto end;
 595         }
 596
 597         copy = lttng_rate_policy_copy(policy);
 598         if (!copy) {
 599                 status = LTTNG_ACTION_STATUS_ERROR;
 600                 goto end;
 601         }
 602
 603         snapshot_session_action = action_snapshot_session_from_action(action);
 604
 605         /* Free the previous rate policy .*/
 606         lttng_rate_policy_destroy(snapshot_session_action->policy);
 607
 608         /* Assign the policy. */
 609         snapshot_session_action->policy = copy;
 610         status = LTTNG_ACTION_STATUS_OK;
 611         copy = NULL;
 612
 613 end:
 614         lttng_rate_policy_destroy(copy);
 615         return status;
 616 }
 617
 618 enum lttng_action_status lttng_action_snapshot_session_get_rate_policy(
 619                 const struct lttng_action *action,
 620                 const struct lttng_rate_policy **policy)
 621 {
 622         enum lttng_action_status status;
 623         const struct lttng_action_snapshot_session *snapshot_session_action;
 624
 625         if (!action || !policy || !IS_SNAPSHOT_SESSION_ACTION(action)) {
 626                 status = LTTNG_ACTION_STATUS_INVALID;
 627                 goto end;
 628         }
 629
 630         snapshot_session_action =
 631                         action_snapshot_session_from_action_const(action);
 632
 633         *policy = snapshot_session_action->policy;
 634         status = LTTNG_ACTION_STATUS_OK;
 635 end:
 636         return status;
 637 }
 638
 639 static const struct lttng_rate_policy *
 640 lttng_action_snapshot_session_internal_get_rate_policy(
 641                 const struct lttng_action *action)
 642 {
 643         const struct lttng_action_snapshot_session *_action;
 644         _action = action_snapshot_session_from_action_const(action);
 645
 646         return _action->policy;
 647 }