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