src/common/session-consumed-size.c

   1 /*
   2  * Copyright (C) 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License, version 2.1 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
  11  * for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  16  */
  17
  18 #include <lttng/condition/condition-internal.h>
  19 #include <lttng/condition/session-consumed-size-internal.h>
  20 #include <lttng/constant.h>
  21 #include <common/macros.h>
  22 #include <common/error.h>
  23 #include <assert.h>
  24 #include <math.h>
  25 #include <float.h>
  26 #include <time.h>
  27
  28 #define IS_CONSUMED_SIZE_CONDITION(condition) ( \
  29         lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
  30         )
  31
  32 #define IS_CONSUMED_SIZE_EVALUATION(evaluation) ( \
  33         lttng_evaluation_get_type(evaluation) == LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE \
  34         )
  35
  36 static
  37 void lttng_condition_session_consumed_size_destroy(struct lttng_condition *condition)
  38 {
  39         struct lttng_condition_session_consumed_size *consumed_size;
  40
  41         consumed_size = container_of(condition,
  42                         struct lttng_condition_session_consumed_size, parent);
  43
  44         free(consumed_size->session_name);
  45         free(consumed_size);
  46 }
  47
  48 static
  49 bool lttng_condition_session_consumed_size_validate(
  50                 const struct lttng_condition *condition)
  51 {
  52         bool valid = false;
  53         struct lttng_condition_session_consumed_size *consumed;
  54
  55         if (!condition) {
  56                 goto end;
  57         }
  58
  59         consumed = container_of(condition, struct lttng_condition_session_consumed_size,
  60                         parent);
  61         if (!consumed->session_name) {
  62                 ERR("Invalid buffer condition: a target session name must be set.");
  63                 goto end;
  64         }
  65         if (!consumed->consumed_threshold_bytes.set) {
  66                 ERR("Invalid session condition: a threshold must be set.");
  67                 goto end;
  68         }
  69
  70         valid = true;
  71 end:
  72         return valid;
  73 }
  74
  75 static
  76 int lttng_condition_session_consumed_size_serialize(
  77                 const struct lttng_condition *condition,
  78                 struct lttng_dynamic_buffer *buf)
  79 {
  80         int ret;
  81         size_t session_name_len;
  82         struct lttng_condition_session_consumed_size *consumed;
  83         struct lttng_condition_session_consumed_size_comm consumed_comm;
  84
  85         if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition)) {
  86                 ret = -1;
  87                 goto end;
  88         }
  89
  90         DBG("Serializing session consumed size condition");
  91         consumed = container_of(condition,
  92                         struct lttng_condition_session_consumed_size,
  93                         parent);
  94
  95         session_name_len = strlen(consumed->session_name) + 1;
  96         if (session_name_len > LTTNG_NAME_MAX) {
  97                 ret = -1;
  98                 goto end;
  99         }
 100
 101         consumed_comm.consumed_threshold_bytes =
 102                         consumed->consumed_threshold_bytes.value;
 103         consumed_comm.session_name_len = (uint32_t) session_name_len;
 104
 105         ret = lttng_dynamic_buffer_append(buf, &consumed_comm,
 106                         sizeof(consumed_comm));
 107         if (ret) {
 108                 goto end;
 109         }
 110         ret = lttng_dynamic_buffer_append(buf, consumed->session_name,
 111                         session_name_len);
 112         if (ret) {
 113                 goto end;
 114         }
 115 end:
 116         return ret;
 117 }
 118
 119 static
 120 bool lttng_condition_session_consumed_size_is_equal(const struct lttng_condition *_a,
 121                 const struct lttng_condition *_b)
 122 {
 123         bool is_equal = false;
 124         struct lttng_condition_session_consumed_size *a, *b;
 125
 126         a = container_of(_a, struct lttng_condition_session_consumed_size, parent);
 127         b = container_of(_b, struct lttng_condition_session_consumed_size, parent);
 128
 129         if (a->consumed_threshold_bytes.set && b->consumed_threshold_bytes.set) {
 130                 uint64_t a_value, b_value;
 131
 132                 a_value = a->consumed_threshold_bytes.value;
 133                 b_value = b->consumed_threshold_bytes.value;
 134                 if (a_value != b_value) {
 135                         goto end;
 136                 }
 137         }
 138
 139         if ((a->session_name && !b->session_name) ||
 140                         (!a->session_name && b->session_name)) {
 141                 goto end;
 142         }
 143
 144         is_equal = true;
 145 end:
 146         return is_equal;
 147 }
 148
 149 struct lttng_condition *lttng_condition_session_consumed_size_create(void)
 150 {
 151         struct lttng_condition_session_consumed_size *condition;
 152
 153         condition = zmalloc(sizeof(struct lttng_condition_session_consumed_size));
 154         if (!condition) {
 155                 return NULL;
 156         }
 157
 158         lttng_condition_init(&condition->parent, LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE);
 159         condition->parent.validate = lttng_condition_session_consumed_size_validate;
 160         condition->parent.serialize = lttng_condition_session_consumed_size_serialize;
 161         condition->parent.equal = lttng_condition_session_consumed_size_is_equal;
 162         condition->parent.destroy = lttng_condition_session_consumed_size_destroy;
 163         return &condition->parent;
 164 }
 165
 166 static
 167 ssize_t init_condition_from_buffer(struct lttng_condition *condition,
 168                 const struct lttng_buffer_view *src_view)
 169 {
 170         ssize_t ret, condition_size;
 171         enum lttng_condition_status status;
 172         const struct lttng_condition_session_consumed_size_comm *condition_comm;
 173         const char *session_name;
 174         struct lttng_buffer_view names_view;
 175
 176         if (src_view->size < sizeof(*condition_comm)) {
 177                 ERR("Failed to initialize from malformed condition buffer: buffer too short to contain header");
 178                 ret = -1;
 179                 goto end;
 180         }
 181
 182         condition_comm = (const struct lttng_condition_session_consumed_size_comm *) src_view->data;
 183         names_view = lttng_buffer_view_from_view(src_view,
 184                         sizeof(*condition_comm), -1);
 185
 186         if (condition_comm->session_name_len > LTTNG_NAME_MAX) {
 187                 ERR("Failed to initialize from malformed condition buffer: name exceeds LTTNG_MAX_NAME");
 188                 ret = -1;
 189                 goto end;
 190         }
 191
 192         if (names_view.size < condition_comm->session_name_len) {
 193                 ERR("Failed to initialize from malformed condition buffer: buffer too short to contain element names");
 194                 ret = -1;
 195                 goto end;
 196         }
 197
 198         status = lttng_condition_session_consumed_size_set_threshold(condition,
 199                         condition_comm->consumed_threshold_bytes);
 200         if (status != LTTNG_CONDITION_STATUS_OK) {
 201                 ERR("Failed to initialize session consumed condition threshold");
 202                 ret = -1;
 203                 goto end;
 204         }
 205
 206         session_name = names_view.data;
 207         if (*(session_name + condition_comm->session_name_len - 1) != '\0') {
 208                 ERR("Malformed session name encountered in condition buffer");
 209                 ret = -1;
 210                 goto end;
 211         }
 212
 213         status = lttng_condition_session_consumed_size_set_session_name(condition,
 214                         session_name);
 215         if (status != LTTNG_CONDITION_STATUS_OK) {
 216                 ERR("Failed to set buffer consumed session name");
 217                 ret = -1;
 218                 goto end;
 219         }
 220
 221         if (!lttng_condition_validate(condition)) {
 222                 ret = -1;
 223                 goto end;
 224         }
 225
 226         condition_size = sizeof(*condition_comm) +
 227                         (ssize_t) condition_comm->session_name_len;
 228         ret = condition_size;
 229 end:
 230         return ret;
 231 }
 232
 233 LTTNG_HIDDEN
 234 ssize_t lttng_condition_session_consumed_size_create_from_buffer(
 235                 const struct lttng_buffer_view *view,
 236                 struct lttng_condition **_condition)
 237 {
 238         ssize_t ret;
 239         struct lttng_condition *condition =
 240                         lttng_condition_session_consumed_size_create();
 241
 242         if (!_condition || !condition) {
 243                 ret = -1;
 244                 goto error;
 245         }
 246
 247         ret = init_condition_from_buffer(condition, view);
 248         if (ret < 0) {
 249                 goto error;
 250         }
 251
 252         *_condition = condition;
 253         return ret;
 254 error:
 255         lttng_condition_destroy(condition);
 256         return ret;
 257 }
 258
 259 static
 260 struct lttng_evaluation *create_evaluation_from_buffer(
 261                 const struct lttng_buffer_view *view)
 262 {
 263         const struct lttng_evaluation_session_consumed_size_comm *comm =
 264                         (const struct lttng_evaluation_session_consumed_size_comm *) view->data;
 265         struct lttng_evaluation *evaluation = NULL;
 266
 267         if (view->size < sizeof(*comm)) {
 268                 goto end;
 269         }
 270
 271         evaluation = lttng_evaluation_session_consumed_size_create(
 272                         comm->session_consumed);
 273 end:
 274         return evaluation;
 275 }
 276
 277 LTTNG_HIDDEN
 278 ssize_t lttng_evaluation_session_consumed_size_create_from_buffer(
 279                 const struct lttng_buffer_view *view,
 280                 struct lttng_evaluation **_evaluation)
 281 {
 282         ssize_t ret;
 283         struct lttng_evaluation *evaluation = NULL;
 284
 285         if (!_evaluation) {
 286                 ret = -1;
 287                 goto error;
 288         }
 289
 290         evaluation = create_evaluation_from_buffer(view);
 291         if (!evaluation) {
 292                 ret = -1;
 293                 goto error;
 294         }
 295
 296         *_evaluation = evaluation;
 297         ret = sizeof(struct lttng_evaluation_session_consumed_size_comm);
 298         return ret;
 299 error:
 300         lttng_evaluation_destroy(evaluation);
 301         return ret;
 302 }
 303
 304 enum lttng_condition_status
 305 lttng_condition_session_consumed_size_get_threshold(
 306                 const struct lttng_condition *condition,
 307                 uint64_t *consumed_threshold_bytes)
 308 {
 309         struct lttng_condition_session_consumed_size *consumed;
 310         enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
 311
 312         if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) || !consumed_threshold_bytes) {
 313                 status = LTTNG_CONDITION_STATUS_INVALID;
 314                 goto end;
 315         }
 316
 317         consumed = container_of(condition, struct lttng_condition_session_consumed_size,
 318                         parent);
 319         if (!consumed->consumed_threshold_bytes.set) {
 320                 status = LTTNG_CONDITION_STATUS_UNSET;
 321                 goto end;
 322         }
 323         *consumed_threshold_bytes = consumed->consumed_threshold_bytes.value;
 324 end:
 325         return status;
 326 }
 327
 328 enum lttng_condition_status
 329 lttng_condition_session_consumed_size_set_threshold(
 330                 struct lttng_condition *condition, uint64_t consumed_threshold_bytes)
 331 {
 332         struct lttng_condition_session_consumed_size *consumed;
 333         enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
 334
 335         if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition)) {
 336                 status = LTTNG_CONDITION_STATUS_INVALID;
 337                 goto end;
 338         }
 339
 340         consumed = container_of(condition, struct lttng_condition_session_consumed_size,
 341                         parent);
 342         consumed->consumed_threshold_bytes.set = true;
 343         consumed->consumed_threshold_bytes.value = consumed_threshold_bytes;
 344 end:
 345         return status;
 346 }
 347
 348 enum lttng_condition_status
 349 lttng_condition_session_consumed_size_get_session_name(
 350                 const struct lttng_condition *condition,
 351                 const char **session_name)
 352 {
 353         struct lttng_condition_session_consumed_size *consumed;
 354         enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
 355
 356         if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) || !session_name) {
 357                 status = LTTNG_CONDITION_STATUS_INVALID;
 358                 goto end;
 359         }
 360
 361         consumed = container_of(condition, struct lttng_condition_session_consumed_size,
 362                         parent);
 363         if (!consumed->session_name) {
 364                 status = LTTNG_CONDITION_STATUS_UNSET;
 365                 goto end;
 366         }
 367         *session_name = consumed->session_name;
 368 end:
 369         return status;
 370 }
 371
 372 enum lttng_condition_status
 373 lttng_condition_session_consumed_size_set_session_name(
 374                 struct lttng_condition *condition, const char *session_name)
 375 {
 376         char *session_name_copy;
 377         struct lttng_condition_session_consumed_size *consumed;
 378         enum lttng_condition_status status = LTTNG_CONDITION_STATUS_OK;
 379
 380         if (!condition || !IS_CONSUMED_SIZE_CONDITION(condition) ||
 381                         !session_name || strlen(session_name) == 0) {
 382                 status = LTTNG_CONDITION_STATUS_INVALID;
 383                 goto end;
 384         }
 385
 386         consumed = container_of(condition, struct lttng_condition_session_consumed_size,
 387                         parent);
 388         session_name_copy = strdup(session_name);
 389         if (!session_name_copy) {
 390                 status = LTTNG_CONDITION_STATUS_ERROR;
 391                 goto end;
 392         }
 393
 394         if (consumed->session_name) {
 395                 free(consumed->session_name);
 396         }
 397         consumed->session_name = session_name_copy;
 398 end:
 399         return status;
 400 }
 401
 402 static
 403 int lttng_evaluation_session_consumed_size_serialize(
 404                 struct lttng_evaluation *evaluation,
 405                 struct lttng_dynamic_buffer *buf)
 406 {
 407         struct lttng_evaluation_session_consumed_size *consumed;
 408         struct lttng_evaluation_session_consumed_size_comm comm;
 409
 410         consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
 411                         parent);
 412         comm.session_consumed = consumed->session_consumed;
 413         return lttng_dynamic_buffer_append(buf, &comm, sizeof(comm));
 414 }
 415
 416 static
 417 void lttng_evaluation_session_consumed_size_destroy(
 418                 struct lttng_evaluation *evaluation)
 419 {
 420         struct lttng_evaluation_session_consumed_size *consumed;
 421
 422         consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
 423                         parent);
 424         free(consumed);
 425 }
 426
 427 LTTNG_HIDDEN
 428 struct lttng_evaluation *lttng_evaluation_session_consumed_size_create(
 429                 uint64_t consumed)
 430 {
 431         struct lttng_evaluation_session_consumed_size *consumed_eval;
 432
 433         consumed_eval = zmalloc(sizeof(struct lttng_evaluation_session_consumed_size));
 434         if (!consumed_eval) {
 435                 goto end;
 436         }
 437
 438         consumed_eval->parent.type = LTTNG_CONDITION_TYPE_SESSION_CONSUMED_SIZE;
 439         consumed_eval->session_consumed = consumed;
 440         consumed_eval->parent.serialize = lttng_evaluation_session_consumed_size_serialize;
 441         consumed_eval->parent.destroy = lttng_evaluation_session_consumed_size_destroy;
 442 end:
 443         return &consumed_eval->parent;
 444 }
 445
 446 enum lttng_evaluation_status
 447 lttng_evaluation_session_consumed_size_get_consumed_size(
 448                 const struct lttng_evaluation *evaluation,
 449                 uint64_t *session_consumed)
 450 {
 451         struct lttng_evaluation_session_consumed_size *consumed;
 452         enum lttng_evaluation_status status = LTTNG_EVALUATION_STATUS_OK;
 453
 454         if (!evaluation || !IS_CONSUMED_SIZE_EVALUATION(evaluation) ||
 455                         !session_consumed) {
 456                 status = LTTNG_EVALUATION_STATUS_INVALID;
 457                 goto end;
 458         }
 459
 460         consumed = container_of(evaluation, struct lttng_evaluation_session_consumed_size,
 461                         parent);
 462         *session_consumed = consumed->session_consumed;
 463 end:
 464         return status;
 465 }