src/common/actions/rotate-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 <lttng/action/action-internal.hpp>
  12 #include <lttng/action/rate-policy-internal.hpp>
  13 #include <lttng/action/rate-policy.h>
  14 #include <lttng/action/rotate-session-internal.hpp>
  15 #include <lttng/action/rotate-session.h>
  16
  17 #define IS_ROTATE_SESSION_ACTION(action) \
  18         (lttng_action_get_type(action) == LTTNG_ACTION_TYPE_ROTATE_SESSION)
  19
  20 namespace {
  21 struct lttng_action_rotate_session {
  22         struct lttng_action parent;
  23
  24         /* Owned by this. */
  25         char *session_name;
  26         struct lttng_rate_policy *policy;
  27 };
  28
  29 struct lttng_action_rotate_session_comm {
  30         /* Includes the trailing \0. */
  31         uint32_t session_name_len;
  32
  33         /*
  34          * Variable data:
  35          *
  36          *  - session name (null terminated)
  37          *  - policy
  38          */
  39         char data[];
  40 } LTTNG_PACKED;
  41 } /* namespace */
  42
  43 static const struct lttng_rate_policy *
  44 lttng_action_rotate_session_internal_get_rate_policy(
  45                 const struct lttng_action *action);
  46
  47 static struct lttng_action_rotate_session *action_rotate_session_from_action(
  48                 struct lttng_action *action)
  49 {
  50         LTTNG_ASSERT(action);
  51
  52         return lttng::utils::container_of(action, &lttng_action_rotate_session::parent);
  53 }
  54
  55 static const struct lttng_action_rotate_session *
  56 action_rotate_session_from_action_const(const struct lttng_action *action)
  57 {
  58         LTTNG_ASSERT(action);
  59
  60         return lttng::utils::container_of(action, &lttng_action_rotate_session::parent);
  61 }
  62
  63 static bool lttng_action_rotate_session_validate(struct lttng_action *action)
  64 {
  65         bool valid;
  66         struct lttng_action_rotate_session *action_rotate_session;
  67
  68         if (!action) {
  69                 valid = false;
  70                 goto end;
  71         }
  72
  73         action_rotate_session = action_rotate_session_from_action(action);
  74
  75         /* A non-empty session name is mandatory. */
  76         if (!action_rotate_session->session_name ||
  77                         strlen(action_rotate_session->session_name) == 0) {
  78                 valid = false;
  79                 goto end;
  80         }
  81
  82         valid = true;
  83 end:
  84         return valid;
  85 }
  86
  87 static bool lttng_action_rotate_session_is_equal(
  88                 const struct lttng_action *_a, const struct lttng_action *_b)
  89 {
  90         bool is_equal = false;
  91         const struct lttng_action_rotate_session *a, *b;
  92
  93         a = action_rotate_session_from_action_const(_a);
  94         b = action_rotate_session_from_action_const(_b);
  95
  96         /* Action is not valid if this is not true. */
  97         LTTNG_ASSERT(a->session_name);
  98         LTTNG_ASSERT(b->session_name);
  99         if (strcmp(a->session_name, b->session_name)) {
 100                 goto end;
 101         }
 102
 103         is_equal = lttng_rate_policy_is_equal(a->policy, b->policy);
 104 end:
 105         return is_equal;
 106 }
 107 static int lttng_action_rotate_session_serialize(
 108                 struct lttng_action *action, struct lttng_payload *payload)
 109 {
 110         struct lttng_action_rotate_session *action_rotate_session;
 111         struct lttng_action_rotate_session_comm comm;
 112         size_t session_name_len;
 113         int ret;
 114
 115         LTTNG_ASSERT(action);
 116         LTTNG_ASSERT(payload);
 117
 118         action_rotate_session = action_rotate_session_from_action(action);
 119
 120         LTTNG_ASSERT(action_rotate_session->session_name);
 121
 122         DBG("Serializing rotate session action: session-name: %s",
 123                         action_rotate_session->session_name);
 124
 125         session_name_len = strlen(action_rotate_session->session_name) + 1;
 126         comm.session_name_len = session_name_len;
 127
 128         ret = lttng_dynamic_buffer_append(
 129                         &payload->buffer, &comm, sizeof(comm));
 130         if (ret) {
 131                 ret = -1;
 132                 goto end;
 133         }
 134
 135         ret = lttng_dynamic_buffer_append(&payload->buffer,
 136                         action_rotate_session->session_name, session_name_len);
 137         if (ret) {
 138                 ret = -1;
 139                 goto end;
 140         }
 141
 142         ret = lttng_rate_policy_serialize(
 143                         action_rotate_session->policy, payload);
 144         if (ret) {
 145                 ret = -1;
 146                 goto end;
 147         }
 148 end:
 149         return ret;
 150 }
 151
 152 static void lttng_action_rotate_session_destroy(struct lttng_action *action)
 153 {
 154         struct lttng_action_rotate_session *action_rotate_session;
 155
 156         if (!action) {
 157                 goto end;
 158         }
 159
 160         action_rotate_session = action_rotate_session_from_action(action);
 161
 162         lttng_rate_policy_destroy(action_rotate_session->policy);
 163         free(action_rotate_session->session_name);
 164         free(action_rotate_session);
 165
 166 end:
 167         return;
 168 }
 169
 170 ssize_t lttng_action_rotate_session_create_from_payload(
 171                 struct lttng_payload_view *view,
 172                 struct lttng_action **p_action)
 173 {
 174         ssize_t consumed_len, ret;
 175         const struct lttng_action_rotate_session_comm *comm;
 176         const char *session_name;
 177         struct lttng_action *action;
 178         enum lttng_action_status status;
 179         struct lttng_rate_policy *policy = NULL;
 180
 181         action = lttng_action_rotate_session_create();
 182         if (!action) {
 183                 consumed_len = -1;
 184                 goto end;
 185         }
 186
 187         comm = (typeof(comm)) view->buffer.data;
 188         session_name = (const char *) &comm->data;
 189
 190         if (!lttng_buffer_view_contains_string(
 191                         &view->buffer, session_name, comm->session_name_len)) {
 192                 consumed_len = -1;
 193                 goto end;
 194         }
 195         consumed_len = sizeof(*comm) + comm->session_name_len;
 196
 197         /* Rate policy. */
 198         {
 199                 struct lttng_payload_view policy_view =
 200                                 lttng_payload_view_from_view(
 201                                                 view, consumed_len, -1);
 202                 ret = lttng_rate_policy_create_from_payload(
 203                                 &policy_view, &policy);
 204                 if (ret < 0) {
 205                         consumed_len = -1;
 206                         goto end;
 207                 }
 208                 consumed_len += ret;
 209         }
 210
 211         status = lttng_action_rotate_session_set_session_name(
 212                         action, session_name);
 213         if (status != LTTNG_ACTION_STATUS_OK) {
 214                 consumed_len = -1;
 215                 goto end;
 216         }
 217
 218         LTTNG_ASSERT(policy);
 219         status = lttng_action_rotate_session_set_rate_policy(action, policy);
 220         if (status != LTTNG_ACTION_STATUS_OK) {
 221                 consumed_len = -1;
 222                 goto end;
 223         }
 224
 225         *p_action = action;
 226         action = NULL;
 227
 228 end:
 229         lttng_rate_policy_destroy(policy);
 230         lttng_action_rotate_session_destroy(action);
 231
 232         return consumed_len;
 233 }
 234
 235 static enum lttng_error_code lttng_action_rotate_session_mi_serialize(
 236                 const struct lttng_action *action, struct mi_writer *writer)
 237 {
 238         int ret;
 239         enum lttng_error_code ret_code;
 240         enum lttng_action_status status;
 241         const char *session_name = NULL;
 242         const struct lttng_rate_policy *policy = NULL;
 243
 244         LTTNG_ASSERT(action);
 245         LTTNG_ASSERT(IS_ROTATE_SESSION_ACTION(action));
 246
 247         status = lttng_action_rotate_session_get_session_name(
 248                         action, &session_name);
 249         LTTNG_ASSERT(status == LTTNG_ACTION_STATUS_OK);
 250         LTTNG_ASSERT(session_name != NULL);
 251
 252         status = lttng_action_notify_get_rate_policy(action, &policy);
 253         LTTNG_ASSERT(status == LTTNG_ACTION_STATUS_OK);
 254         LTTNG_ASSERT(policy != NULL);
 255
 256         /* Open action rotate session element. */
 257         ret = mi_lttng_writer_open_element(
 258                         writer, mi_lttng_element_action_rotate_session);
 259         if (ret) {
 260                 goto mi_error;
 261         }
 262
 263         /* Session name. */
 264         ret = mi_lttng_writer_write_element_string(
 265                         writer, mi_lttng_element_session_name, session_name);
 266         if (ret) {
 267                 goto mi_error;
 268         }
 269
 270         /* Rate policy. */
 271         ret_code = lttng_rate_policy_mi_serialize(policy, writer);
 272         if (ret_code != LTTNG_OK) {
 273                 goto end;
 274         }
 275
 276         /* Close action rotate session element. */
 277         ret = mi_lttng_writer_close_element(writer);
 278         if (ret) {
 279                 goto mi_error;
 280         }
 281
 282         ret_code = LTTNG_OK;
 283         goto end;
 284
 285 mi_error:
 286         ret_code = LTTNG_ERR_MI_IO_FAIL;
 287 end:
 288         return ret_code;
 289 }
 290
 291 struct lttng_action *lttng_action_rotate_session_create(void)
 292 {
 293         struct lttng_action_rotate_session *action_rotate = NULL;
 294         struct lttng_rate_policy *policy = NULL;
 295         enum lttng_action_status status;
 296
 297         /* Create a every N = 1 rate policy. */
 298         policy = lttng_rate_policy_every_n_create(1);
 299         if (!policy) {
 300                 goto end;
 301         }
 302
 303         action_rotate = zmalloc<lttng_action_rotate_session>();
 304         if (!action_rotate) {
 305                 goto end;
 306         }
 307
 308         lttng_action_init(&action_rotate->parent,
 309                         LTTNG_ACTION_TYPE_ROTATE_SESSION,
 310                         lttng_action_rotate_session_validate,
 311                         lttng_action_rotate_session_serialize,
 312                         lttng_action_rotate_session_is_equal,
 313                         lttng_action_rotate_session_destroy,
 314                         lttng_action_rotate_session_internal_get_rate_policy,
 315                         lttng_action_generic_add_error_query_results,
 316                         lttng_action_rotate_session_mi_serialize);
 317
 318         status = lttng_action_rotate_session_set_rate_policy(
 319                         &action_rotate->parent, policy);
 320         if (status != LTTNG_ACTION_STATUS_OK) {
 321                 lttng_action_destroy(&action_rotate->parent);
 322                 action_rotate = NULL;
 323                 goto end;
 324         }
 325
 326 end:
 327         lttng_rate_policy_destroy(policy);
 328         return action_rotate ? &action_rotate->parent : nullptr;
 329 }
 330
 331 enum lttng_action_status lttng_action_rotate_session_set_session_name(
 332                 struct lttng_action *action, const char *session_name)
 333 {
 334         struct lttng_action_rotate_session *action_rotate_session;
 335         enum lttng_action_status status;
 336
 337         if (!action || !IS_ROTATE_SESSION_ACTION(action) || !session_name ||
 338                         strlen(session_name) == 0) {
 339                 status = LTTNG_ACTION_STATUS_INVALID;
 340                 goto end;
 341         }
 342
 343         action_rotate_session = action_rotate_session_from_action(action);
 344
 345         free(action_rotate_session->session_name);
 346
 347         action_rotate_session->session_name = strdup(session_name);
 348         if (!action_rotate_session->session_name) {
 349                 status = LTTNG_ACTION_STATUS_ERROR;
 350                 goto end;
 351         }
 352
 353         status = LTTNG_ACTION_STATUS_OK;
 354 end:
 355         return status;
 356 }
 357
 358 enum lttng_action_status lttng_action_rotate_session_get_session_name(
 359                 const struct lttng_action *action, const char **session_name)
 360 {
 361         const struct lttng_action_rotate_session *action_rotate_session;
 362         enum lttng_action_status status;
 363
 364         if (!action || !IS_ROTATE_SESSION_ACTION(action) || !session_name) {
 365                 status = LTTNG_ACTION_STATUS_INVALID;
 366                 goto end;
 367         }
 368
 369         action_rotate_session = action_rotate_session_from_action_const(action);
 370
 371         *session_name = action_rotate_session->session_name;
 372
 373         status = LTTNG_ACTION_STATUS_OK;
 374 end:
 375         return status;
 376 }
 377
 378 enum lttng_action_status lttng_action_rotate_session_set_rate_policy(
 379                 struct lttng_action *action,
 380                 const struct lttng_rate_policy *policy)
 381 {
 382         enum lttng_action_status status;
 383         struct lttng_action_rotate_session *rotate_session_action;
 384         struct lttng_rate_policy *copy = NULL;
 385
 386         if (!action || !policy || !IS_ROTATE_SESSION_ACTION(action)) {
 387                 status = LTTNG_ACTION_STATUS_INVALID;
 388                 goto end;
 389         }
 390
 391         copy = lttng_rate_policy_copy(policy);
 392         if (!copy) {
 393                 status = LTTNG_ACTION_STATUS_ERROR;
 394                 goto end;
 395         }
 396
 397         rotate_session_action = action_rotate_session_from_action(action);
 398
 399         /* Free the previous rate policy .*/
 400         lttng_rate_policy_destroy(rotate_session_action->policy);
 401
 402         /* Assign the policy. */
 403         rotate_session_action->policy = copy;
 404         status = LTTNG_ACTION_STATUS_OK;
 405         copy = NULL;
 406
 407 end:
 408         lttng_rate_policy_destroy(copy);
 409         return status;
 410 }
 411
 412 enum lttng_action_status lttng_action_rotate_session_get_rate_policy(
 413                 const struct lttng_action *action,
 414                 const struct lttng_rate_policy **policy)
 415 {
 416         enum lttng_action_status status;
 417         const struct lttng_action_rotate_session *rotate_session_action;
 418
 419         if (!action || !policy || !IS_ROTATE_SESSION_ACTION(action)) {
 420                 status = LTTNG_ACTION_STATUS_INVALID;
 421                 goto end;
 422         }
 423
 424         rotate_session_action = action_rotate_session_from_action_const(action);
 425
 426         *policy = rotate_session_action->policy;
 427         status = LTTNG_ACTION_STATUS_OK;
 428 end:
 429         return status;
 430 }
 431
 432 static const struct lttng_rate_policy *
 433 lttng_action_rotate_session_internal_get_rate_policy(
 434                 const struct lttng_action *action)
 435 {
 436         const struct lttng_action_rotate_session *_action;
 437         _action = action_rotate_session_from_action_const(action);
 438
 439         return _action->policy;
 440 }