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/notify-internal.h>
  12 #include <lttng/action/rotate-session-internal.h>
  13 #include <lttng/action/start-session-internal.h>
  14 #include <lttng/action/stop-session-internal.h>
  15
  16 static const char *lttng_action_type_string(enum lttng_action_type action_type)
  17 {
  18         switch (action_type) {
  19         case LTTNG_ACTION_TYPE_UNKNOWN:
  20                 return "UNKNOWN";
  21         case LTTNG_ACTION_TYPE_NOTIFY:
  22                 return "NOTIFY";
  23         case LTTNG_ACTION_TYPE_ROTATE_SESSION:
  24                 return "ROTATE_SESSION";
  25         case LTTNG_ACTION_TYPE_START_SESSION:
  26                 return "START_SESSION";
  27         case LTTNG_ACTION_TYPE_STOP_SESSION:
  28                 return "STOP_SESSION";
  29         default:
  30                 return "???";
  31         }
  32 }
  33
  34 enum lttng_action_type lttng_action_get_type(struct lttng_action *action)
  35 {
  36         return action ? action->type : LTTNG_ACTION_TYPE_UNKNOWN;
  37 }
  38
  39 LTTNG_HIDDEN
  40 enum lttng_action_type lttng_action_get_type_const(
  41                 const struct lttng_action *action)
  42 {
  43         return action->type;
  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         action->type = type;
  56         action->validate = validate;
  57         action->serialize = serialize;
  58         action->equal = equal;
  59         action->destroy = destroy;
  60 }
  61
  62 void lttng_action_destroy(struct lttng_action *action)
  63 {
  64         if (!action) {
  65                 return;
  66         }
  67
  68         assert(action->destroy);
  69         action->destroy(action);
  70 }
  71
  72 LTTNG_HIDDEN
  73 bool lttng_action_validate(struct lttng_action *action)
  74 {
  75         bool valid;
  76
  77         if (!action) {
  78                 valid = false;
  79                 goto end;
  80         }
  81
  82         if (!action->validate) {
  83                 /* Sub-class guarantees that it can never be invalid. */
  84                 valid = true;
  85                 goto end;
  86         }
  87
  88         valid = action->validate(action);
  89 end:
  90         return valid;
  91 }
  92
  93 LTTNG_HIDDEN
  94 int lttng_action_serialize(struct lttng_action *action,
  95                 struct lttng_payload *payload)
  96 {
  97         int ret;
  98         struct lttng_action_comm action_comm = {
  99                 .action_type = (int8_t) action->type,
 100         };
 101
 102         ret = lttng_dynamic_buffer_append(&payload->buffer, &action_comm,
 103                         sizeof(action_comm));
 104         if (ret) {
 105                 goto end;
 106         }
 107
 108         ret = action->serialize(action, payload);
 109         if (ret) {
 110                 goto end;
 111         }
 112 end:
 113         return ret;
 114 }
 115
 116 LTTNG_HIDDEN
 117 ssize_t lttng_action_create_from_payload(struct lttng_payload_view *view,
 118                 struct lttng_action **action)
 119 {
 120         ssize_t consumed_len, specific_action_consumed_len;
 121         const struct lttng_action_comm *action_comm;
 122         action_create_from_payload_cb create_from_payload_cb;
 123
 124         if (!view || !action) {
 125                 consumed_len = -1;
 126                 goto end;
 127         }
 128
 129         action_comm = (const struct lttng_action_comm *) view->buffer.data;
 130
 131         DBG("Create action from payload: action-type=%s",
 132                         lttng_action_type_string(action_comm->action_type));
 133
 134         switch (action_comm->action_type) {
 135         case LTTNG_ACTION_TYPE_NOTIFY:
 136                 create_from_payload_cb = lttng_action_notify_create_from_payload;
 137                 break;
 138         case LTTNG_ACTION_TYPE_ROTATE_SESSION:
 139                 create_from_payload_cb =
 140                                 lttng_action_rotate_session_create_from_payload;
 141                 break;
 142         case LTTNG_ACTION_TYPE_START_SESSION:
 143                 create_from_payload_cb =
 144                                 lttng_action_start_session_create_from_payload;
 145                 break;
 146         case LTTNG_ACTION_TYPE_STOP_SESSION:
 147                 create_from_payload_cb =
 148                                 lttng_action_stop_session_create_from_payload;
 149                 break;
 150         default:
 151                 ERR("Failed to create action from payload, unhandled action type: action-type=%u (%s)",
 152                                 action_comm->action_type,
 153                                 lttng_action_type_string(
 154                                                 action_comm->action_type));
 155                 consumed_len = -1;
 156                 goto end;
 157         }
 158
 159         {
 160                 /* Create buffer view for the action-type-specific data. */
 161                 struct lttng_payload_view specific_action_view =
 162                                 lttng_payload_view_from_view(view,
 163                                                 sizeof(struct lttng_action_comm),
 164                                                 -1);
 165
 166                 specific_action_consumed_len = create_from_payload_cb(
 167                                 &specific_action_view, action);
 168         }
 169         if (specific_action_consumed_len < 0) {
 170                 ERR("Failed to create specific action from buffer.");
 171                 consumed_len = -1;
 172                 goto end;
 173         }
 174
 175         assert(*action);
 176
 177         consumed_len = sizeof(struct lttng_action_comm) +
 178                        specific_action_consumed_len;
 179
 180 end:
 181         return consumed_len;
 182 }
 183
 184 LTTNG_HIDDEN
 185 bool lttng_action_is_equal(const struct lttng_action *a,
 186                 const struct lttng_action *b)
 187 {
 188         bool is_equal = false;
 189
 190         if (!a || !b) {
 191                 goto end;
 192         }
 193
 194         if (a->type != b->type) {
 195                 goto end;
 196         }
 197
 198         if (a == b) {
 199                 is_equal = true;
 200                 goto end;
 201         }
 202
 203         assert(a->equal);
 204         is_equal = a->equal(a, b);
 205 end:
 206         return is_equal;
 207 }