src/common/actions/rotate-session.c

   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 <assert.h>
   9 #include <common/error.h>
  10 #include <common/macros.h>
  11 #include <lttng/action/action-internal.h>
  12 #include <lttng/action/rotate-session-internal.h>
  13 #include <lttng/action/rotate-session.h>
  14
  15 struct lttng_action_rotate_session {
  16         struct lttng_action parent;
  17
  18         /* Owned by this. */
  19         char *session_name;
  20 };
  21
  22 struct lttng_action_rotate_session_comm {
  23         /* Includes the trailing \0. */
  24         uint32_t session_name_len;
  25
  26         /*
  27          * Variable data:
  28          *
  29          *  - session name (null terminated)
  30          */
  31         char data[];
  32 } LTTNG_PACKED;
  33
  34 static struct lttng_action_rotate_session *action_rotate_session_from_action(
  35                 struct lttng_action *action)
  36 {
  37         assert(action);
  38
  39         return container_of(action, struct lttng_action_rotate_session, parent);
  40 }
  41
  42 static const struct lttng_action_rotate_session *action_rotate_session_from_action_const(
  43                 const struct lttng_action *action)
  44 {
  45         assert(action);
  46
  47         return container_of(action, struct lttng_action_rotate_session, parent);
  48 }
  49
  50 static bool lttng_action_rotate_session_validate(struct lttng_action *action)
  51 {
  52         bool valid;
  53         struct lttng_action_rotate_session *action_rotate_session;
  54
  55         if (!action) {
  56                 valid = false;
  57                 goto end;
  58         }
  59
  60         action_rotate_session = action_rotate_session_from_action(action);
  61
  62         /* A non-empty session name is mandatory. */
  63         if (!action_rotate_session->session_name ||
  64                         strlen(action_rotate_session->session_name) == 0) {
  65                 valid = false;
  66                 goto end;
  67         }
  68
  69         valid = true;
  70 end:
  71         return valid;
  72 }
  73
  74 static bool lttng_action_rotate_session_is_equal(const struct lttng_action *_a, const struct lttng_action *_b)
  75 {
  76         bool is_equal = false;
  77         const struct lttng_action_rotate_session *a, *b;
  78
  79         a = action_rotate_session_from_action_const(_a);
  80         b = action_rotate_session_from_action_const(_b);
  81
  82         /* Action is not valid if this is not true. */
  83         assert(a->session_name);
  84         assert(b->session_name);
  85         if (strcmp(a->session_name, b->session_name)) {
  86                 goto end;
  87         }
  88
  89         is_equal = true;
  90 end:
  91         return is_equal;
  92 }
  93 static int lttng_action_rotate_session_serialize(
  94                 struct lttng_action *action, struct lttng_dynamic_buffer *buf)
  95 {
  96         struct lttng_action_rotate_session *action_rotate_session;
  97         struct lttng_action_rotate_session_comm comm;
  98         size_t session_name_len;
  99         int ret;
 100
 101         assert(action);
 102         assert(buf);
 103
 104         action_rotate_session = action_rotate_session_from_action(action);
 105
 106         assert(action_rotate_session->session_name);
 107
 108         DBG("Serializing rotate session action: session-name: %s",
 109                         action_rotate_session->session_name);
 110
 111         session_name_len = strlen(action_rotate_session->session_name) + 1;
 112         comm.session_name_len = session_name_len;
 113
 114         ret = lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
 115         if (ret) {
 116                 ret = -1;
 117                 goto end;
 118         }
 119
 120         ret = lttng_dynamic_buffer_append(buf,
 121                         action_rotate_session->session_name, session_name_len);
 122         if (ret) {
 123                 ret = -1;
 124                 goto end;
 125         }
 126
 127         ret = 0;
 128 end:
 129         return ret;
 130 }
 131
 132 static void lttng_action_rotate_session_destroy(struct lttng_action *action)
 133 {
 134         struct lttng_action_rotate_session *action_rotate_session;
 135
 136         if (!action) {
 137                 goto end;
 138         }
 139
 140         action_rotate_session = action_rotate_session_from_action(action);
 141
 142         free(action_rotate_session->session_name);
 143         free(action_rotate_session);
 144
 145 end:
 146         return;
 147 }
 148
 149 ssize_t lttng_action_rotate_session_create_from_buffer(
 150                 const struct lttng_buffer_view *view,
 151                 struct lttng_action **p_action)
 152 {
 153         ssize_t consumed_len;
 154         struct lttng_action_rotate_session_comm *comm;
 155         const char *session_name;
 156         struct lttng_action *action;
 157         enum lttng_action_status status;
 158
 159         action = lttng_action_rotate_session_create();
 160         if (!action) {
 161                 consumed_len = -1;
 162                 goto end;
 163         }
 164
 165         comm = (struct lttng_action_rotate_session_comm *) view->data;
 166         session_name = (const char *) &comm->data;
 167
 168         if (!lttng_buffer_view_contains_string(
 169                         view, session_name, comm->session_name_len)) {
 170                 consumed_len = -1;
 171                 goto end;
 172         }
 173
 174         status = lttng_action_rotate_session_set_session_name(
 175                         action, session_name);
 176         if (status != LTTNG_ACTION_STATUS_OK) {
 177                 consumed_len = -1;
 178                 goto end;
 179         }
 180
 181         consumed_len = sizeof(struct lttng_action_rotate_session_comm) +
 182                 comm->session_name_len;
 183         *p_action = action;
 184         action = NULL;
 185
 186 end:
 187         lttng_action_rotate_session_destroy(action);
 188
 189         return consumed_len;
 190 }
 191
 192 struct lttng_action *lttng_action_rotate_session_create(void)
 193 {
 194         struct lttng_action *action;
 195
 196         action = zmalloc(sizeof(struct lttng_action_rotate_session));
 197         if (!action) {
 198                 goto end;
 199         }
 200
 201         lttng_action_init(action, LTTNG_ACTION_TYPE_ROTATE_SESSION,
 202                         lttng_action_rotate_session_validate,
 203                         lttng_action_rotate_session_serialize,
 204                         lttng_action_rotate_session_is_equal,
 205                         lttng_action_rotate_session_destroy);
 206
 207 end:
 208         return action;
 209 }
 210
 211 enum lttng_action_status lttng_action_rotate_session_set_session_name(
 212                 struct lttng_action *action, const char *session_name)
 213 {
 214         struct lttng_action_rotate_session *action_rotate_session;
 215         enum lttng_action_status status;
 216
 217         if (!action || !session_name || strlen(session_name) == 0) {
 218                 status = LTTNG_ACTION_STATUS_INVALID;
 219                 goto end;
 220         }
 221
 222         action_rotate_session = action_rotate_session_from_action(action);
 223
 224         free(action_rotate_session->session_name);
 225
 226         action_rotate_session->session_name = strdup(session_name);
 227         if (!action_rotate_session->session_name) {
 228                 status = LTTNG_ACTION_STATUS_ERROR;
 229                 goto end;
 230         }
 231
 232         status = LTTNG_ACTION_STATUS_OK;
 233 end:
 234         return status;
 235 }
 236
 237 enum lttng_action_status lttng_action_rotate_session_get_session_name(
 238                 const struct lttng_action *action, const char **session_name)
 239 {
 240         const struct lttng_action_rotate_session *action_rotate_session;
 241         enum lttng_action_status status;
 242
 243         if (!action || !session_name) {
 244                 status = LTTNG_ACTION_STATUS_INVALID;
 245                 goto end;
 246         }
 247
 248         action_rotate_session = action_rotate_session_from_action_const(action);
 249
 250         *session_name = action_rotate_session->session_name;
 251
 252         status = LTTNG_ACTION_STATUS_OK;
 253 end:
 254         return status;
 255 }