src/bin/lttng-sessiond/ust-registry.c

   1 /*
   2  * Copyright (C) 2013 - David Goulet <dgoulet@efficios.com>
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License, version 2 only, as
   6  * published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc., 51
  15  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17 #define _GNU_SOURCE
  18 #include <assert.h>
  19 #include <inttypes.h>
  20
  21 #include <common/common.h>
  22 #include <common/hashtable/utils.h>
  23 #include <lttng/lttng.h>
  24
  25 #include "ust-registry.h"
  26
  27 /*
  28  * Hash table match function for event in the registry.
  29  */
  30 static int ht_match_event(struct cds_lfht_node *node, const void *_key)
  31 {
  32         struct ust_registry_event *event;
  33         const struct ust_registry_event *key;
  34
  35         assert(node);
  36         assert(_key);
  37
  38         event = caa_container_of(node, struct ust_registry_event, node.node);
  39         assert(event);
  40         key = _key;
  41
  42         /* It has to be a perfect match. */
  43         if (strncmp(event->name, key->name, sizeof(event->name)) != 0) {
  44                 goto no_match;
  45         }
  46
  47         /* It has to be a perfect match. */
  48         if (strncmp(event->signature, key->signature,
  49                                 strlen(event->signature) != 0)) {
  50                 goto no_match;
  51         }
  52
  53         /* Match */
  54         return 1;
  55
  56 no_match:
  57         return 0;
  58 }
  59
  60 static unsigned long ht_hash_event(void *_key, unsigned long seed)
  61 {
  62         uint64_t xored_key;
  63         struct ust_registry_event *key = _key;
  64
  65         assert(key);
  66
  67         xored_key = (uint64_t) (hash_key_str(key->name, seed) ^
  68                         hash_key_str(key->signature, seed));
  69
  70         return hash_key_u64(&xored_key, seed);
  71 }
  72
  73 /*
  74  * Allocate event and initialize it. This does NOT set a valid event id from a
  75  * registry.
  76  */
  77 static struct ust_registry_event *alloc_event(int session_objd,
  78                 int channel_objd, char *name, char *sig, size_t nr_fields,
  79                 struct ustctl_field *fields, int loglevel, char *model_emf_uri)
  80 {
  81         struct ust_registry_event *event = NULL;
  82
  83         event = zmalloc(sizeof(*event));
  84         if (!event) {
  85                 PERROR("zmalloc ust registry event");
  86                 goto error;
  87         }
  88
  89         event->session_objd = session_objd;
  90         event->channel_objd = channel_objd;
  91         /* Allocated by ustctl. */
  92         event->signature = sig;
  93         event->nr_fields = nr_fields;
  94         event->fields = fields;
  95         event->loglevel = loglevel;
  96         event->model_emf_uri = model_emf_uri;
  97         if (name) {
  98                 /* Copy event name and force NULL byte. */
  99                 strncpy(event->name, name, sizeof(event->name));
 100                 event->name[sizeof(event->name) - 1] = '\0';
 101         }
 102         cds_lfht_node_init(&event->node.node);
 103
 104 error:
 105         return event;
 106 }
 107
 108 /*
 109  * Free event data structure. This does NOT delete it from any hash table. It's
 110  * safe to pass a NULL pointer. This shoudl be called inside a call RCU if the
 111  * event is previously deleted from a rcu hash table.
 112  */
 113 static void destroy_event(struct ust_registry_event *event)
 114 {
 115         if (!event) {
 116                 return;
 117         }
 118
 119         free(event->fields);
 120         free(event->model_emf_uri);
 121         free(event->signature);
 122         free(event);
 123 }
 124
 125 /*
 126  * Destroy event function call of the call RCU.
 127  */
 128 static void destroy_event_rcu(struct rcu_head *head)
 129 {
 130         struct lttng_ht_node_u64 *node =
 131                 caa_container_of(head, struct lttng_ht_node_u64, head);
 132         struct ust_registry_event *event =
 133                 caa_container_of(node, struct ust_registry_event, node);
 134
 135         destroy_event(event);
 136 }
 137
 138 /*
 139  * Find an event using the name and signature in the given registry. RCU read
 140  * side lock MUST be acquired before calling this function and as long as the
 141  * event reference is kept by the caller.
 142  *
 143  * On success, the event pointer is returned else NULL.
 144  */
 145 struct ust_registry_event *ust_registry_find_event(
 146                 struct ust_registry_channel *chan, char *name, char *sig)
 147 {
 148         struct lttng_ht_node_u64 *node;
 149         struct lttng_ht_iter iter;
 150         struct ust_registry_event *event = NULL;
 151         struct ust_registry_event key;
 152
 153         assert(chan);
 154         assert(name);
 155         assert(sig);
 156
 157         /* Setup key for the match function. */
 158         strncpy(key.name, name, sizeof(key.name));
 159         key.name[sizeof(key.name) - 1] = '\0';
 160         key.signature = sig;
 161
 162         cds_lfht_lookup(chan->ht->ht, chan->ht->hash_fct(&key, lttng_ht_seed),
 163                         chan->ht->match_fct, &key, &iter.iter);
 164         node = lttng_ht_iter_get_node_u64(&iter);
 165         if (!node) {
 166                 goto end;
 167         }
 168         event = caa_container_of(node, struct ust_registry_event, node);
 169
 170 end:
 171         return event;
 172 }
 173
 174 /*
 175  * Create a ust_registry_event from the given parameters and add it to the
 176  * registry hash table. If event_id is valid, it is set with the newly created
 177  * event id.
 178  *
 179  * On success, return 0 else a negative value. The created event MUST be unique
 180  * so on duplicate entry -EINVAL is returned. On error, event_id is untouched.
 181  *
 182  * Should be called with session registry mutex held.
 183  */
 184 int ust_registry_create_event(struct ust_registry_session *session,
 185                 uint64_t chan_key, int session_objd, int channel_objd, char *name,
 186                 char *sig, size_t nr_fields, struct ustctl_field *fields, int loglevel,
 187                 char *model_emf_uri, int buffer_type, uint32_t *event_id_p)
 188 {
 189         int ret;
 190         uint32_t event_id;
 191         struct cds_lfht_node *nptr;
 192         struct ust_registry_event *event = NULL;
 193         struct ust_registry_channel *chan;
 194
 195         assert(session);
 196         assert(name);
 197         assert(sig);
 198         assert(event_id_p);
 199
 200         /*
 201          * This should not happen but since it comes from the UST tracer, an
 202          * external party, don't assert and simply validate values.
 203          */
 204         if (session_objd < 0 || channel_objd < 0) {
 205                 ret = -EINVAL;
 206                 goto error;
 207         }
 208
 209         rcu_read_lock();
 210
 211         chan = ust_registry_channel_find(session, chan_key);
 212         if (!chan) {
 213                 ret = -EINVAL;
 214                 goto error_unlock;
 215         }
 216
 217         /* Check if we've reached the maximum possible id. */
 218         if (ust_registry_is_max_id(chan->used_event_id)) {
 219                 ret = -ENOENT;
 220                 goto error_unlock;
 221         }
 222
 223         event = alloc_event(session_objd, channel_objd, name, sig, nr_fields,
 224                         fields, loglevel, model_emf_uri);
 225         if (!event) {
 226                 ret = -ENOMEM;
 227                 goto error_unlock;
 228         }
 229
 230         DBG3("UST registry creating event with event: %s, sig: %s, id: %u, "
 231                         "chan_objd: %u, sess_objd: %u, chan_id: %u", event->name,
 232                         event->signature, event->id, event->channel_objd,
 233                         event->session_objd, chan->chan_id);
 234
 235         /*
 236          * This is an add unique with a custom match function for event. The node
 237          * are matched using the event name and signature.
 238          */
 239         nptr = cds_lfht_add_unique(chan->ht->ht, chan->ht->hash_fct(event,
 240                                 lttng_ht_seed), chan->ht->match_fct, event, &event->node.node);
 241         if (nptr != &event->node.node) {
 242                 if (buffer_type == LTTNG_BUFFER_PER_UID) {
 243                         /*
 244                          * This is normal, we just have to send the event id of the
 245                          * returned node and make sure we destroy the previously allocated
 246                          * event object.
 247                          */
 248                         destroy_event(event);
 249                         event = caa_container_of(nptr, struct ust_registry_event,
 250                                         node.node);
 251                         assert(event);
 252                         event_id = event->id;
 253                 } else {
 254                         ERR("UST registry create event add unique failed for event: %s, "
 255                                         "sig: %s, id: %u, chan_objd: %u, sess_objd: %u",
 256                                         event->name, event->signature, event->id,
 257                                         event->channel_objd, event->session_objd);
 258                         ret = -EINVAL;
 259                         goto error_unlock;
 260                 }
 261         } else {
 262                 /* Request next event id if the node was successfully added. */
 263                 event_id = event->id = ust_registry_get_next_event_id(chan);
 264         }
 265
 266         *event_id_p = event_id;
 267
 268         if (!event->metadata_dumped) {
 269                 /* Append to metadata */
 270                 ret = ust_metadata_event_statedump(session, chan, event);
 271                 if (ret) {
 272                         ERR("Error appending event metadata (errno = %d)", ret);
 273                         rcu_read_unlock();
 274                         return ret;
 275                 }
 276         }
 277
 278         rcu_read_unlock();
 279         return 0;
 280
 281 error_unlock:
 282         rcu_read_unlock();
 283 error:
 284         destroy_event(event);
 285         return ret;
 286 }
 287
 288 /*
 289  * For a given event in a registry, delete the entry and destroy the event.
 290  * This MUST be called within a RCU read side lock section.
 291  */
 292 void ust_registry_destroy_event(struct ust_registry_channel *chan,
 293                 struct ust_registry_event *event)
 294 {
 295         int ret;
 296         struct lttng_ht_iter iter;
 297
 298         assert(chan);
 299         assert(event);
 300
 301         /* Delete the node first. */
 302         iter.iter.node = &event->node.node;
 303         ret = lttng_ht_del(chan->ht, &iter);
 304         assert(!ret);
 305
 306         call_rcu(&event->node.head, destroy_event_rcu);
 307
 308         return;
 309 }
 310
 311 /*
 312  * Destroy every element of the registry and free the memory. This does NOT
 313  * free the registry pointer since it might not have been allocated before so
 314  * it's the caller responsability.
 315  *
 316  * This MUST be called within a RCU read side lock section.
 317  */
 318 static void destroy_channel(struct ust_registry_channel *chan)
 319 {
 320         struct lttng_ht_iter iter;
 321         struct ust_registry_event *event;
 322
 323         assert(chan);
 324
 325         /* Destroy all event associated with this registry. */
 326         cds_lfht_for_each_entry(chan->ht->ht, &iter.iter, event, node.node) {
 327                 /* Delete the node from the ht and free it. */
 328                 ust_registry_destroy_event(chan, event);
 329         }
 330         lttng_ht_destroy(chan->ht);
 331
 332         free(chan);
 333 }
 334
 335 /*
 336  * Initialize registry with default values.
 337  */
 338 int ust_registry_channel_add(struct ust_registry_session *session,
 339                 uint64_t key)
 340 {
 341         int ret = 0;
 342         struct ust_registry_channel *chan;
 343
 344         assert(session);
 345
 346         chan = zmalloc(sizeof(*chan));
 347         if (!chan) {
 348                 PERROR("zmalloc ust registry channel");
 349                 ret = -ENOMEM;
 350                 goto error;
 351         }
 352
 353         chan->ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
 354         if (!chan->ht) {
 355                 ret = -ENOMEM;
 356                 goto error;
 357         }
 358
 359         /* Set custom match function. */
 360         chan->ht->match_fct = ht_match_event;
 361         chan->ht->hash_fct = ht_hash_event;
 362
 363         /*
 364          * Assign a channel ID right now since the event notification comes
 365          * *before* the channel notify so the ID needs to be set at this point so
 366          * the metadata can be dumped for that event.
 367          */
 368         if (ust_registry_is_max_id(session->used_channel_id)) {
 369                 ret = -1;
 370                 goto error;
 371         }
 372         chan->chan_id = ust_registry_get_next_chan_id(session);
 373
 374         rcu_read_lock();
 375         lttng_ht_node_init_u64(&chan->node, key);
 376         lttng_ht_add_unique_u64(session->channels, &chan->node);
 377         rcu_read_unlock();
 378
 379 error:
 380         return ret;
 381 }
 382
 383 /*
 384  * Find a channel in the given registry. RCU read side lock MUST be acquired
 385  * before calling this function and as long as the event reference is kept by
 386  * the caller.
 387  *
 388  * On success, the pointer is returned else NULL.
 389  */
 390 struct ust_registry_channel *ust_registry_channel_find(
 391                 struct ust_registry_session *session, uint64_t key)
 392 {
 393         struct lttng_ht_node_u64 *node;
 394         struct lttng_ht_iter iter;
 395         struct ust_registry_channel *chan = NULL;
 396
 397         assert(session);
 398         assert(session->channels);
 399
 400         DBG3("UST registry channel finding key %" PRIu64, key);
 401
 402         lttng_ht_lookup(session->channels, &key, &iter);
 403         node = lttng_ht_iter_get_node_u64(&iter);
 404         if (!node) {
 405                 goto end;
 406         }
 407         chan = caa_container_of(node, struct ust_registry_channel, node);
 408
 409 end:
 410         return chan;
 411 }
 412
 413 /*
 414  * Remove channel using key from registry and free memory.
 415  */
 416 void ust_registry_channel_del_free(struct ust_registry_session *session,
 417                 uint64_t key)
 418 {
 419         struct lttng_ht_iter iter;
 420         struct ust_registry_channel *chan;
 421
 422         assert(session);
 423
 424         rcu_read_lock();
 425         chan = ust_registry_channel_find(session, key);
 426         if (!chan) {
 427                 goto end;
 428         }
 429
 430         iter.iter.node = &chan->node.node;
 431         lttng_ht_del(session->channels, &iter);
 432
 433         destroy_channel(chan);
 434
 435 end:
 436         rcu_read_unlock();
 437         return;
 438 }
 439
 440 /*
 441  * Initialize registry with default values and set the newly allocated session
 442  * pointer to sessionp.
 443  *
 444  * Return 0 on success and sessionp is set or else return -1 and sessionp is
 445  * kept untouched.
 446  */
 447 int ust_registry_session_init(struct ust_registry_session **sessionp,
 448                 struct ust_app *app,
 449                 uint32_t bits_per_long,
 450                 uint32_t uint8_t_alignment,
 451                 uint32_t uint16_t_alignment,
 452                 uint32_t uint32_t_alignment,
 453                 uint32_t uint64_t_alignment,
 454                 uint32_t long_alignment,
 455                 int byte_order,
 456                 uint32_t major,
 457                 uint32_t minor)
 458 {
 459         int ret;
 460         struct ust_registry_session *session;
 461
 462         assert(sessionp);
 463
 464         session = zmalloc(sizeof(*session));
 465         if (!session) {
 466                 PERROR("zmalloc ust registry session");
 467                 goto error;
 468         }
 469
 470         pthread_mutex_init(&session->lock, NULL);
 471         session->bits_per_long = bits_per_long;
 472         session->uint8_t_alignment = uint8_t_alignment;
 473         session->uint16_t_alignment = uint16_t_alignment;
 474         session->uint32_t_alignment = uint32_t_alignment;
 475         session->uint64_t_alignment = uint64_t_alignment;
 476         session->long_alignment = long_alignment;
 477         session->byte_order = byte_order;
 478
 479         session->channels = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
 480         if (!session->channels) {
 481                 goto error;
 482         }
 483
 484         ret = lttng_uuid_generate(session->uuid);
 485         if (ret) {
 486                 ERR("Failed to generate UST uuid (errno = %d)", ret);
 487                 goto error;
 488         }
 489
 490         pthread_mutex_lock(&session->lock);
 491         ret = ust_metadata_session_statedump(session, app, major, minor);
 492         pthread_mutex_unlock(&session->lock);
 493         if (ret) {
 494                 ERR("Failed to generate session metadata (errno = %d)", ret);
 495                 goto error;
 496         }
 497
 498         *sessionp = session;
 499
 500         return 0;
 501
 502 error:
 503         return -1;
 504 }
 505
 506 /*
 507  * Destroy session registry. This does NOT free the given pointer since it
 508  * might get passed as a reference. The registry lock should NOT be acquired.
 509  */
 510 void ust_registry_session_destroy(struct ust_registry_session *reg)
 511 {
 512         int ret;
 513         struct lttng_ht_iter iter;
 514         struct ust_registry_channel *chan;
 515
 516         /* On error, EBUSY can be returned if lock. Code flow error. */
 517         ret = pthread_mutex_destroy(&reg->lock);
 518         assert(!ret);
 519
 520         rcu_read_lock();
 521         /* Destroy all event associated with this registry. */
 522         cds_lfht_for_each_entry(reg->channels->ht, &iter.iter, chan, node.node) {
 523                 /* Delete the node from the ht and free it. */
 524                 ret = lttng_ht_del(reg->channels, &iter);
 525                 assert(!ret);
 526                 destroy_channel(chan);
 527         }
 528         lttng_ht_destroy(reg->channels);
 529         rcu_read_unlock();
 530
 531         free(reg->metadata);
 532 }