src/bin/lttng-sessiond/snapshot.cpp

   1 /*
   2  * Copyright (C) 2013 David Goulet <dgoulet@efficios.com>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include "consumer-output.hpp"
  10 #include "snapshot-output.hpp"
  11 #include "snapshot.hpp"
  12 #include "utils.hpp"
  13
  14 #include <common/defaults.hpp>
  15 #include <common/urcu.hpp>
  16
  17 #include <inttypes.h>
  18 #include <string.h>
  19 #include <urcu/uatomic.h>
  20
  21 /*
  22  * Return the atomically incremented value of next_output_id.
  23  */
  24 static inline unsigned long get_next_output_id(struct snapshot *snapshot)
  25 {
  26         return uatomic_add_return(&snapshot->next_output_id, 1);
  27 }
  28
  29 /*
  30  * Initialized snapshot output with the given values.
  31  *
  32  * Return 0 on success or else a negative value.
  33  */
  34 static int output_init(const ltt_session::locked_ref& session,
  35                        uint64_t max_size,
  36                        const char *name,
  37                        struct lttng_uri *uris,
  38                        size_t nb_uri,
  39                        struct consumer_output *consumer,
  40                        struct snapshot_output *output,
  41                        struct snapshot *snapshot)
  42 {
  43         int ret = 0, i;
  44
  45         /*
  46          * max_size of -1ULL means unset. Set to default (unlimited).
  47          */
  48         if (max_size == (uint64_t) -1ULL) {
  49                 max_size = 0;
  50         }
  51         output->max_size = max_size;
  52
  53         if (snapshot) {
  54                 output->id = get_next_output_id(snapshot);
  55         }
  56         lttng_ht_node_init_ulong(&output->node, (unsigned long) output->id);
  57
  58         if (name && name[0] != '\0') {
  59                 if (lttng_strncpy(output->name, name, sizeof(output->name))) {
  60                         ret = -LTTNG_ERR_INVALID;
  61                         goto error;
  62                 }
  63         } else {
  64                 /* Set default name. */
  65                 ret = snprintf(output->name,
  66                                sizeof(output->name),
  67                                "%s-%" PRIu32,
  68                                DEFAULT_SNAPSHOT_NAME,
  69                                output->id);
  70                 if (ret < 0) {
  71                         ret = -ENOMEM;
  72                         goto error;
  73                 }
  74         }
  75
  76         if (!consumer) {
  77                 goto end;
  78         }
  79
  80         output->consumer = consumer_copy_output(consumer);
  81         if (!output->consumer) {
  82                 ret = -ENOMEM;
  83                 goto error;
  84         }
  85         output->consumer->snapshot = 1;
  86
  87         /* No URL given. */
  88         if (nb_uri == 0) {
  89                 ret = 0;
  90                 goto end;
  91         }
  92
  93         if (uris[0].dtype == LTTNG_DST_PATH) {
  94                 memset(output->consumer->dst.session_root_path,
  95                        0,
  96                        sizeof(output->consumer->dst.session_root_path));
  97                 if (lttng_strncpy(output->consumer->dst.session_root_path,
  98                                   uris[0].dst.path,
  99                                   sizeof(output->consumer->dst.session_root_path))) {
 100                         ret = -LTTNG_ERR_INVALID;
 101                         goto error;
 102                 }
 103                 output->consumer->type = CONSUMER_DST_LOCAL;
 104                 ret = 0;
 105                 goto end;
 106         }
 107
 108         if (nb_uri != 2) {
 109                 /* Absolutely needs two URIs for network. */
 110                 ret = -LTTNG_ERR_INVALID;
 111                 goto error;
 112         }
 113
 114         for (i = 0; i < nb_uri; i++) {
 115                 /* Network URIs */
 116                 ret = consumer_set_network_uri(session, output->consumer, &uris[i]);
 117                 if (ret < 0) {
 118                         goto error;
 119                 }
 120         }
 121
 122 error:
 123 end:
 124         return ret;
 125 }
 126
 127 /*
 128  * Initialize a snapshot output object using the given parameters and URI(s).
 129  * The name value and uris can be NULL.
 130  *
 131  * Return 0 on success or else a negative value.
 132  */
 133 int snapshot_output_init_with_uri(const ltt_session::locked_ref& session,
 134                                   uint64_t max_size,
 135                                   const char *name,
 136                                   struct lttng_uri *uris,
 137                                   size_t nb_uri,
 138                                   struct consumer_output *consumer,
 139                                   struct snapshot_output *output,
 140                                   struct snapshot *snapshot)
 141 {
 142         return output_init(session, max_size, name, uris, nb_uri, consumer, output, snapshot);
 143 }
 144
 145 /*
 146  * Initialize a snapshot output object using the given parameters. The name
 147  * value and url can be NULL.
 148  *
 149  * Return 0 on success or else a negative value.
 150  */
 151 int snapshot_output_init(const ltt_session::locked_ref& session,
 152                          uint64_t max_size,
 153                          const char *name,
 154                          const char *ctrl_url,
 155                          const char *data_url,
 156                          struct consumer_output *consumer,
 157                          struct snapshot_output *output,
 158                          struct snapshot *snapshot)
 159 {
 160         int ret = 0, nb_uri;
 161         struct lttng_uri *uris = nullptr;
 162
 163         /* Create an array of URIs from URLs. */
 164         nb_uri = uri_parse_str_urls(ctrl_url, data_url, &uris);
 165         if (nb_uri < 0) {
 166                 ret = nb_uri;
 167                 goto error;
 168         }
 169
 170         ret = output_init(session, max_size, name, uris, nb_uri, consumer, output, snapshot);
 171
 172 error:
 173         free(uris);
 174         return ret;
 175 }
 176
 177 struct snapshot_output *snapshot_output_alloc()
 178 {
 179         return new snapshot_output;
 180 }
 181
 182 /*
 183  * Delete output from the snapshot object.
 184  */
 185 void snapshot_delete_output(struct snapshot *snapshot, struct snapshot_output *output)
 186 {
 187         int ret;
 188         struct lttng_ht_iter iter;
 189
 190         LTTNG_ASSERT(snapshot);
 191         LTTNG_ASSERT(snapshot->output_ht);
 192         LTTNG_ASSERT(output);
 193
 194         iter.iter.node = &output->node.node;
 195         const lttng::urcu::read_lock_guard read_lock;
 196         ret = lttng_ht_del(snapshot->output_ht, &iter);
 197         LTTNG_ASSERT(!ret);
 198         /*
 199          * This is safe because the ownership of a snapshot object is in a session
 200          * for which the session lock need to be acquired to read and modify it.
 201          */
 202         snapshot->nb_output--;
 203 }
 204
 205 /*
 206  * Add output object to the snapshot.
 207  */
 208 void snapshot_add_output(struct snapshot *snapshot, struct snapshot_output *output)
 209 {
 210         LTTNG_ASSERT(snapshot);
 211         LTTNG_ASSERT(snapshot->output_ht);
 212         LTTNG_ASSERT(output);
 213
 214         const lttng::urcu::read_lock_guard read_lock;
 215         lttng_ht_add_unique_ulong(snapshot->output_ht, &output->node);
 216         /*
 217          * This is safe because the ownership of a snapshot object is in a session
 218          * for which the session lock need to be acquired to read and modify it.
 219          */
 220         snapshot->nb_output++;
 221 }
 222
 223 /*
 224  * Destroy and free a snapshot output object.
 225  */
 226 void snapshot_output_destroy(struct snapshot_output *obj)
 227 {
 228         LTTNG_ASSERT(obj);
 229
 230         if (obj->consumer) {
 231                 consumer_output_send_destroy_relayd(obj->consumer);
 232                 consumer_output_put(obj->consumer);
 233         }
 234
 235         delete obj;
 236 }
 237
 238 /*
 239  * RCU read side lock MUST be acquired before calling this since the returned
 240  * pointer is in a RCU hash table.
 241  *
 242  * Return the reference on success or else NULL.
 243  */
 244 struct snapshot_output *snapshot_find_output_by_name(const char *name, struct snapshot *snapshot)
 245 {
 246         LTTNG_ASSERT(snapshot);
 247         LTTNG_ASSERT(name);
 248
 249         for (auto *output : lttng::urcu::lfht_iteration_adapter<snapshot_output,
 250                                                                 decltype(snapshot_output::node),
 251                                                                 &snapshot_output::node>(
 252                      *snapshot->output_ht->ht)) {
 253                 if (!strncmp(output->name, name, strlen(name))) {
 254                         return output;
 255                 }
 256         }
 257
 258         /* Not found */
 259         return nullptr;
 260 }
 261
 262 /*
 263  * RCU read side lock MUST be acquired before calling this since the returned
 264  * pointer is in a RCU hash table.
 265  *
 266  * Return the reference on success or else NULL.
 267  */
 268 struct snapshot_output *snapshot_find_output_by_id(uint32_t id, struct snapshot *snapshot)
 269 {
 270         struct lttng_ht_node_ulong *node;
 271         struct lttng_ht_iter iter;
 272         struct snapshot_output *output = nullptr;
 273
 274         LTTNG_ASSERT(snapshot);
 275         ASSERT_RCU_READ_LOCKED();
 276
 277         lttng_ht_lookup(snapshot->output_ht, (void *) ((unsigned long) id), &iter);
 278         node = lttng_ht_iter_get_node<lttng_ht_node_ulong>(&iter);
 279         if (!node) {
 280                 DBG3("Snapshot output not found with id %" PRId32, id);
 281                 goto error;
 282         }
 283         output = lttng::utils::container_of(node, &snapshot_output::node);
 284
 285 error:
 286         return output;
 287 }
 288
 289 /*
 290  * Initialized a snapshot object that was already allocated.
 291  *
 292  * Return 0 on success or else a negative errno value.
 293  */
 294 int snapshot_init(struct snapshot *obj)
 295 {
 296         int ret;
 297
 298         LTTNG_ASSERT(obj);
 299
 300         memset(obj, 0, sizeof(struct snapshot));
 301
 302         obj->output_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
 303         if (!obj->output_ht) {
 304                 ret = -ENOMEM;
 305                 goto error;
 306         }
 307
 308         ret = 0;
 309
 310 error:
 311         return ret;
 312 }
 313
 314 /*
 315  * Destroy snapshot object but the pointer is not freed so it's safe to pass a
 316  * static reference.
 317  */
 318 void snapshot_destroy(struct snapshot *obj)
 319 {
 320         if (!obj->output_ht) {
 321                 return;
 322         }
 323
 324         for (auto *output :
 325              lttng::urcu::lfht_iteration_adapter<snapshot_output,
 326                                                  decltype(snapshot_output::node),
 327                                                  &snapshot_output::node>(*obj->output_ht->ht)) {
 328                 snapshot_delete_output(obj, output);
 329                 snapshot_output_destroy(output);
 330         }
 331
 332         lttng_ht_destroy(obj->output_ht);
 333 }