src/common/actions/action.c

   1 /*
   2  * Copyright (C) 2017 Jérémie Galarneau <jeremie.galarneau@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 <lttng/action/action-internal.h>
  11 #include <lttng/action/group-internal.h>
  12 #include <lttng/action/notify-internal.h>
  13 #include <lttng/action/rotate-session-internal.h>
  14 #include <lttng/action/snapshot-session-internal.h>
  15 #include <lttng/action/start-session-internal.h>
  16 #include <lttng/action/stop-session-internal.h>
  17
  18 LTTNG_HIDDEN
  19 const char *lttng_action_type_string(enum lttng_action_type action_type)
  20 {
  21         switch (action_type) {
  22         case LTTNG_ACTION_TYPE_UNKNOWN:
  23                 return "UNKNOWN";
  24         case LTTNG_ACTION_TYPE_GROUP:
  25                 return "GROUP";
  26         case LTTNG_ACTION_TYPE_NOTIFY:
  27                 return "NOTIFY";
  28         case LTTNG_ACTION_TYPE_ROTATE_SESSION:
  29                 return "ROTATE_SESSION";
  30         case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION:
  31                 return "SNAPSHOT_SESSION";
  32         case LTTNG_ACTION_TYPE_START_SESSION:
  33                 return "START_SESSION";
  34         case LTTNG_ACTION_TYPE_STOP_SESSION:
  35                 return "STOP_SESSION";
  36         default:
  37                 return "???";
  38         }
  39 }
  40
  41 enum lttng_action_type lttng_action_get_type(const struct lttng_action *action)
  42 {
  43         return action ? action->type : LTTNG_ACTION_TYPE_UNKNOWN;
  44 }
  45
  46 LTTNG_HIDDEN
  47 void lttng_action_init(
  48                 struct lttng_action *action,
  49                 enum lttng_action_type type,
  50                 action_validate_cb validate,
  51                 action_serialize_cb serialize,
  52                 action_equal_cb equal,
  53                 action_destroy_cb destroy)
  54 {
  55         urcu_ref_init(&action->ref);
  56         action->type = type;
  57         action->validate = validate;
  58         action->serialize = serialize;
  59         action->equal = equal;
  60         action->destroy = destroy;
  61 }
  62
  63 static
  64 void action_destroy_ref(struct urcu_ref *ref)
  65 {
  66         struct lttng_action *action =
  67                         container_of(ref, struct lttng_action, ref);
  68
  69         action->destroy(action);
  70 }
  71
  72 LTTNG_HIDDEN
  73 void lttng_action_get(struct lttng_action *action)
  74 {
  75         urcu_ref_get(&action->ref);
  76 }
  77
  78 LTTNG_HIDDEN
  79 void lttng_action_put(struct lttng_action *action)
  80 {
  81         if (!action) {
  82                 return;
  83         }
  84
  85         assert(action->destroy);
  86         urcu_ref_put(&action->ref, action_destroy_ref);
  87 }
  88
  89 void lttng_action_destroy(struct lttng_action *action)
  90 {
  91         lttng_action_put(action);
  92 }
  93
  94 LTTNG_HIDDEN
  95 bool lttng_action_validate(struct lttng_action *action)
  96 {
  97         bool valid;
  98
  99         if (!action) {
 100                 valid = false;
 101                 goto end;
 102         }
 103
 104         if (!action->validate) {
 105                 /* Sub-class guarantees that it can never be invalid. */
 106                 valid = true;
 107                 goto end;
 108         }
 109
 110         valid = action->validate(action);
 111 end:
 112         return valid;
 113 }
 114
 115 LTTNG_HIDDEN
 116 int lttng_action_serialize(struct lttng_action *action,
 117                 struct lttng_payload *payload)
 118 {
 119         int ret;
 120         struct lttng_action_comm action_comm = {
 121                 .action_type = (int8_t) action->type,
 122         };
 123
 124         ret = lttng_dynamic_buffer_append(&payload->buffer, &action_comm,
 125                         sizeof(action_comm));
 126         if (ret) {
 127                 goto end;
 128         }
 129
 130         ret = action->serialize(action, payload);
 131         if (ret) {
 132                 goto end;
 133         }
 134 end:
 135         return ret;
 136 }
 137
 138 LTTNG_HIDDEN
 139 ssize_t lttng_action_create_from_payload(struct lttng_payload_view *view,
 140                 struct lttng_action **action)
 141 {
 142         ssize_t consumed_len, specific_action_consumed_len;
 143         action_create_from_payload_cb create_from_payload_cb;
 144         const struct lttng_action_comm *action_comm;
 145         const struct lttng_payload_view action_comm_view =
 146                         lttng_payload_view_from_view(
 147                                         view, 0, sizeof(*action_comm));
 148
 149         if (!view || !action) {
 150                 consumed_len = -1;
 151                 goto end;
 152         }
 153
 154         if (!lttng_payload_view_is_valid(&action_comm_view)) {
 155                 /* Payload not large enough to contain the header. */
 156                 consumed_len = -1;
 157                 goto end;
 158         }
 159
 160         action_comm = (const struct lttng_action_comm *) action_comm_view.buffer.data;
 161
 162         DBG("Create action from payload: action-type=%s",
 163                         lttng_action_type_string(action_comm->action_type));
 164
 165         switch (action_comm->action_type) {
 166         case LTTNG_ACTION_TYPE_NOTIFY:
 167                 create_from_payload_cb = lttng_action_notify_create_from_payload;
 168                 break;
 169         case LTTNG_ACTION_TYPE_ROTATE_SESSION:
 170                 create_from_payload_cb =
 171                                 lttng_action_rotate_session_create_from_payload;
 172                 break;
 173         case LTTNG_ACTION_TYPE_SNAPSHOT_SESSION:
 174                 create_from_payload_cb =
 175                                 lttng_action_snapshot_session_create_from_payload;
 176                 break;
 177         case LTTNG_ACTION_TYPE_START_SESSION:
 178                 create_from_payload_cb =
 179                                 lttng_action_start_session_create_from_payload;
 180                 break;
 181         case LTTNG_ACTION_TYPE_STOP_SESSION:
 182                 create_from_payload_cb =
 183                                 lttng_action_stop_session_create_from_payload;
 184                 break;
 185         case LTTNG_ACTION_TYPE_GROUP:
 186                 create_from_payload_cb = lttng_action_group_create_from_payload;
 187                 break;
 188         default:
 189                 ERR("Failed to create action from payload, unhandled action type: action-type=%u (%s)",
 190                                 action_comm->action_type,
 191                                 lttng_action_type_string(
 192                                                 action_comm->action_type));
 193                 consumed_len = -1;
 194                 goto end;
 195         }
 196
 197         {
 198                 /* Create buffer view for the action-type-specific data. */
 199                 struct lttng_payload_view specific_action_view =
 200                                 lttng_payload_view_from_view(view,
 201                                                 sizeof(struct lttng_action_comm),
 202                                                 -1);
 203
 204                 specific_action_consumed_len = create_from_payload_cb(
 205                                 &specific_action_view, action);
 206         }
 207         if (specific_action_consumed_len < 0) {
 208                 ERR("Failed to create specific action from buffer.");
 209                 consumed_len = -1;
 210                 goto end;
 211         }
 212
 213         assert(*action);
 214
 215         consumed_len = sizeof(struct lttng_action_comm) +
 216                        specific_action_consumed_len;
 217
 218 end:
 219         return consumed_len;
 220 }
 221
 222 LTTNG_HIDDEN
 223 bool lttng_action_is_equal(const struct lttng_action *a,
 224                 const struct lttng_action *b)
 225 {
 226         bool is_equal = false;
 227
 228         if (!a || !b) {
 229                 goto end;
 230         }
 231
 232         if (a->type != b->type) {
 233                 goto end;
 234         }
 235
 236         if (a == b) {
 237                 is_equal = true;
 238                 goto end;
 239         }
 240
 241         assert(a->equal);
 242         is_equal = a->equal(a, b);
 243 end:
 244         return is_equal;
 245 }