include/lttng/trigger/trigger-internal.h

   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 #ifndef LTTNG_TRIGGER_INTERNAL_H
   9 #define LTTNG_TRIGGER_INTERNAL_H
  10
  11 #include <common/credentials.h>
  12 #include <common/dynamic-array.h>
  13 #include <common/macros.h>
  14 #include <common/optional.h>
  15 #include <lttng/trigger/trigger.h>
  16 #include <pthread.h>
  17 #include <stdbool.h>
  18 #include <stdint.h>
  19 #include <sys/types.h>
  20 #include <urcu/ref.h>
  21
  22 struct lttng_payload;
  23 struct lttng_payload_view;
  24
  25 struct lttng_trigger {
  26         /* Reference counting is only exposed to internal users. */
  27         struct urcu_ref ref;
  28
  29         struct lttng_condition *condition;
  30         struct lttng_action *action;
  31         char *name;
  32         /* For now only the uid portion of the credentials is used. */
  33         struct lttng_credentials creds;
  34         /*
  35          * Internal use only.
  36          * The unique token passed to the tracer to identify an event-rule
  37          * notification.
  38          */
  39         LTTNG_OPTIONAL(uint64_t) tracer_token;
  40
  41         /*
  42          * Is the trigger registered?
  43          *
  44          * This is necessary since a reference holder might be interested in the
  45          * overall state of the trigger from the point of view of its owner.
  46          *
  47          * The main user is the action executor since we want to prevent the
  48          * execution of actions related to a trigger that is unregistered.
  49          *
  50          * Not considered for `is_equal`.
  51          */
  52         bool registered;
  53
  54         /*
  55          * The lock is used to protect against concurrent trigger execution and
  56          * trigger removal.
  57          */
  58         pthread_mutex_t lock;
  59 };
  60
  61 struct lttng_triggers {
  62         struct lttng_dynamic_pointer_array array;
  63 };
  64
  65 struct lttng_trigger_comm {
  66         /*
  67          * Credentials, only the uid portion is used for now.
  68          * Used as an override when desired by the root user.
  69          */
  70         uint64_t uid;
  71         /*
  72          * Length of the variable length payload (name, condition, and
  73          * an action).
  74          */
  75         uint32_t length;
  76         /* Includes '\0' terminator. */
  77         uint32_t name_length;
  78         /* A null-terminated name, a condition, and an action follow. */
  79         char payload[];
  80 } LTTNG_PACKED;
  81
  82 struct lttng_triggers_comm {
  83         uint32_t count;
  84         uint32_t length;
  85         /* Count * lttng_trigger_comm structure */
  86         char payload[];
  87 };
  88
  89 LTTNG_HIDDEN
  90 ssize_t lttng_trigger_create_from_payload(struct lttng_payload_view *view,
  91                 struct lttng_trigger **trigger);
  92
  93 LTTNG_HIDDEN
  94 int lttng_trigger_serialize(const struct lttng_trigger *trigger,
  95                 struct lttng_payload *payload);
  96
  97 LTTNG_HIDDEN
  98 bool lttng_trigger_validate(const struct lttng_trigger *trigger);
  99
 100 LTTNG_HIDDEN
 101 int lttng_trigger_assign_name(
 102                 struct lttng_trigger *dst, const struct lttng_trigger *src);
 103
 104 LTTNG_HIDDEN
 105 void lttng_trigger_set_tracer_token(
 106                 struct lttng_trigger *trigger, uint64_t token);
 107
 108 LTTNG_HIDDEN
 109 uint64_t lttng_trigger_get_tracer_token(const struct lttng_trigger *trigger);
 110
 111 LTTNG_HIDDEN
 112 int lttng_trigger_generate_name(struct lttng_trigger *trigger,
 113                 uint64_t unique_id);
 114
 115 LTTNG_HIDDEN
 116 bool lttng_trigger_is_equal(
 117                 const struct lttng_trigger *a, const struct lttng_trigger *b);
 118
 119 LTTNG_HIDDEN
 120 void lttng_trigger_get(struct lttng_trigger *trigger);
 121
 122 LTTNG_HIDDEN
 123 void lttng_trigger_put(struct lttng_trigger *trigger);
 124
 125 /*
 126  * Allocate a new set of triggers.
 127  * The returned object must be freed via lttng_triggers_destroy.
 128  */
 129 LTTNG_HIDDEN
 130 struct lttng_triggers *lttng_triggers_create(void);
 131
 132 /*
 133  * Return the a pointer to a mutable element at index "index" of an
 134  * lttng_triggers set.
 135  *
 136  * This differs from the public `lttng_triggers_get_at_index` in that
 137  * the returned pointer to a mutable trigger.
 138  *
 139  * The ownership of the trigger set element is NOT transfered.
 140  * The returned object can NOT be freed via lttng_trigger_destroy.
 141  */
 142 LTTNG_HIDDEN
 143 struct lttng_trigger *lttng_triggers_borrow_mutable_at_index(
 144                 const struct lttng_triggers *triggers, unsigned int index);
 145
 146 /*
 147  * Add a trigger to the triggers set.
 148  *
 149  * A reference to the added trigger is acquired on behalf of the trigger set
 150  * on success.
 151  */
 152 LTTNG_HIDDEN
 153 int lttng_triggers_add(
 154                 struct lttng_triggers *triggers, struct lttng_trigger *trigger);
 155
 156 /*
 157  * Serialize a trigger set to an lttng_payload object.
 158  * Return LTTNG_OK on success, negative lttng error code on error.
 159  */
 160 LTTNG_HIDDEN
 161 int lttng_triggers_serialize(const struct lttng_triggers *triggers,
 162                 struct lttng_payload *payload);
 163
 164 LTTNG_HIDDEN
 165 ssize_t lttng_triggers_create_from_payload(struct lttng_payload_view *view,
 166                 struct lttng_triggers **triggers);
 167
 168 LTTNG_HIDDEN
 169 const struct lttng_credentials *lttng_trigger_get_credentials(
 170                 const struct lttng_trigger *trigger);
 171
 172 LTTNG_HIDDEN
 173 void lttng_trigger_set_credentials(struct lttng_trigger *trigger,
 174                 const struct lttng_credentials *creds);
 175
 176 /*
 177  * Return the type of any underlying domain restriction. If no particular
 178  * requirement is present, returns LTTNG_DOMAIN_NONE.
 179  */
 180 LTTNG_HIDDEN
 181 enum lttng_domain_type lttng_trigger_get_underlying_domain_type_restriction(
 182                 const struct lttng_trigger *trigger);
 183
 184 /*
 185  * Generate any bytecode related to the trigger.
 186  * On success LTTNG_OK. On error, returns lttng_error code.
 187  */
 188 LTTNG_HIDDEN
 189 enum lttng_error_code lttng_trigger_generate_bytecode(
 190                 struct lttng_trigger *trigger,
 191                 const struct lttng_credentials *creds);
 192
 193 LTTNG_HIDDEN
 194 struct lttng_trigger *lttng_trigger_copy(const struct lttng_trigger *trigger);
 195
 196 /*
 197  * A given trigger needs a tracer notifier if
 198  *  it has an event-rule condition,
 199  *  AND
 200  *  it has one or more sessiond-execution action.
 201  */
 202 LTTNG_HIDDEN
 203 bool lttng_trigger_needs_tracer_notifier(const struct lttng_trigger *trigger);
 204
 205 LTTNG_HIDDEN
 206 void lttng_trigger_set_as_registered(struct lttng_trigger *trigger);
 207
 208 LTTNG_HIDDEN
 209 void lttng_trigger_set_as_unregistered(struct lttng_trigger *trigger);
 210
 211 /*
 212  * The trigger must be locked before calling lttng_trigger_is_registered.
 213  *
 214  * The lock is necessary since a trigger can be unregistered at any time.
 215  *
 216  * Manipulations requiring that the trigger be registered must always acquire
 217  * the trigger lock for the duration of the manipulation using
 218  * `lttng_trigger_lock` and `lttng_trigger_unlock`.
 219  */
 220 LTTNG_HIDDEN
 221 bool lttng_trigger_is_registered(struct lttng_trigger *trigger);
 222
 223 LTTNG_HIDDEN
 224 void lttng_trigger_lock(struct lttng_trigger *trigger);
 225
 226 LTTNG_HIDDEN
 227 void lttng_trigger_unlock(struct lttng_trigger *trigger);
 228
 229 #endif /* LTTNG_TRIGGER_INTERNAL_H */