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

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23
  24 #include <common/common.h>
  25 #include <common/defaults.h>
  26
  27 #include "trace-ust.h"
  28
  29 /*
  30  * Find the channel in the hashtable.
  31  */
  32 struct ltt_ust_channel *trace_ust_find_channel_by_name(struct lttng_ht *ht,
  33                 char *name)
  34 {
  35         struct lttng_ht_node_str *node;
  36         struct lttng_ht_iter iter;
  37
  38         rcu_read_lock();
  39         lttng_ht_lookup(ht, (void *)name, &iter);
  40         node = lttng_ht_iter_get_node_str(&iter);
  41         if (node == NULL) {
  42                 rcu_read_unlock();
  43                 goto error;
  44         }
  45         rcu_read_unlock();
  46
  47         DBG2("Trace UST channel %s found by name", name);
  48
  49         return caa_container_of(node, struct ltt_ust_channel, node);
  50
  51 error:
  52         DBG2("Trace UST channel %s not found by name", name);
  53         return NULL;
  54 }
  55
  56 /*
  57  * Find the event in the hashtable.
  58  */
  59 struct ltt_ust_event *trace_ust_find_event_by_name(struct lttng_ht *ht,
  60                 char *name)
  61 {
  62         struct lttng_ht_node_str *node;
  63         struct lttng_ht_iter iter;
  64
  65         rcu_read_lock();
  66         lttng_ht_lookup(ht, (void *) name, &iter);
  67         node = lttng_ht_iter_get_node_str(&iter);
  68         if (node == NULL) {
  69                 rcu_read_unlock();
  70                 goto error;
  71         }
  72         rcu_read_unlock();
  73
  74         DBG2("Trace UST event found by name %s", name);
  75
  76         return caa_container_of(node, struct ltt_ust_event, node);
  77
  78 error:
  79         DBG2("Trace UST event NOT found by name %s", name);
  80         return NULL;
  81 }
  82
  83 /*
  84  * Allocate and initialize a ust session data structure.
  85  *
  86  * Return pointer to structure or NULL.
  87  */
  88 struct ltt_ust_session *trace_ust_create_session(char *path,
  89                 unsigned int session_id, struct lttng_domain *domain)
  90 {
  91         int ret;
  92         struct ltt_ust_session *lus;
  93
  94         /* Allocate a new ltt ust session */
  95         lus = zmalloc(sizeof(struct ltt_ust_session));
  96         if (lus == NULL) {
  97                 PERROR("create ust session zmalloc");
  98                 goto error;
  99         }
 100
 101         /* Init data structure */
 102         lus->id = session_id;
 103         lus->start_trace = 0;
 104
 105         /* Alloc UST domain hash tables */
 106         lus->domain_pid = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
 107         lus->domain_exec = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
 108
 109         /* Alloc UST global domain channels' HT */
 110         lus->domain_global.channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
 111
 112         lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
 113         if (lus->consumer == NULL) {
 114                 goto error;
 115         }
 116
 117         /*
 118          * The tmp_consumer stays NULL until a set_consumer_uri command is
 119          * executed. At this point, the consumer should be nullify until an
 120          * enable_consumer command. This assignment is symbolic since we've zmalloc
 121          * the struct.
 122          */
 123         lus->tmp_consumer = NULL;
 124
 125         /* Use the default consumer output which is the tracing session path. */
 126         ret = snprintf(lus->consumer->dst.trace_path, PATH_MAX, "%s/ust", path);
 127         if (ret < 0) {
 128                 PERROR("snprintf UST consumer trace path");
 129                 goto error;
 130         }
 131
 132         /* Set session path */
 133         ret = snprintf(lus->pathname, PATH_MAX, "%s/ust", path);
 134         if (ret < 0) {
 135                 PERROR("snprintf kernel traces path");
 136                 goto error_free_session;
 137         }
 138
 139         DBG2("UST trace session create successful");
 140
 141         return lus;
 142
 143 error_free_session:
 144         lttng_ht_destroy(lus->domain_global.channels);
 145         lttng_ht_destroy(lus->domain_exec);
 146         lttng_ht_destroy(lus->domain_pid);
 147         free(lus);
 148 error:
 149         return NULL;
 150 }
 151
 152 /*
 153  * Allocate and initialize a ust channel data structure.
 154  *
 155  * Return pointer to structure or NULL.
 156  */
 157 struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan,
 158                 char *path)
 159 {
 160         int ret;
 161         struct ltt_ust_channel *luc;
 162
 163         luc = zmalloc(sizeof(struct ltt_ust_channel));
 164         if (luc == NULL) {
 165                 PERROR("ltt_ust_channel zmalloc");
 166                 goto error;
 167         }
 168
 169         /* Copy UST channel attributes */
 170         luc->attr.overwrite = chan->attr.overwrite;
 171         luc->attr.subbuf_size = chan->attr.subbuf_size;
 172         luc->attr.num_subbuf = chan->attr.num_subbuf;
 173         luc->attr.switch_timer_interval = chan->attr.switch_timer_interval;
 174         luc->attr.read_timer_interval = chan->attr.read_timer_interval;
 175         luc->attr.output = (enum lttng_ust_output) chan->attr.output;
 176
 177         /* Translate to UST output enum */
 178         switch (luc->attr.output) {
 179         default:
 180                 luc->attr.output = LTTNG_UST_MMAP;
 181                 break;
 182         }
 183
 184         /* Copy channel name */
 185         strncpy(luc->name, chan->name, sizeof(luc->name));
 186         luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 187
 188         /* Init node */
 189         lttng_ht_node_init_str(&luc->node, luc->name);
 190         /* Alloc hash tables */
 191         luc->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
 192         luc->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
 193
 194         /* Set trace output path */
 195         ret = snprintf(luc->pathname, PATH_MAX, "%s", path);
 196         if (ret < 0) {
 197                 PERROR("asprintf ust create channel");
 198                 goto error_free_channel;
 199         }
 200
 201         DBG2("Trace UST channel %s created", luc->name);
 202
 203         return luc;
 204
 205 error_free_channel:
 206         lttng_ht_destroy(luc->ctx);
 207         lttng_ht_destroy(luc->events);
 208         free(luc);
 209 error:
 210         return NULL;
 211 }
 212
 213 /*
 214  * Allocate and initialize a ust event. Set name and event type.
 215  *
 216  * Return pointer to structure or NULL.
 217  */
 218 struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev)
 219 {
 220         struct ltt_ust_event *lue;
 221
 222         lue = zmalloc(sizeof(struct ltt_ust_event));
 223         if (lue == NULL) {
 224                 PERROR("ust event zmalloc");
 225                 goto error;
 226         }
 227
 228         switch (ev->type) {
 229         case LTTNG_EVENT_PROBE:
 230                 lue->attr.instrumentation = LTTNG_UST_PROBE;
 231                 break;
 232         case LTTNG_EVENT_FUNCTION:
 233                 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
 234                 break;
 235         case LTTNG_EVENT_FUNCTION_ENTRY:
 236                 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
 237                 break;
 238         case LTTNG_EVENT_TRACEPOINT:
 239                 lue->attr.instrumentation = LTTNG_UST_TRACEPOINT;
 240                 break;
 241         default:
 242                 ERR("Unknown ust instrumentation type (%d)", ev->type);
 243                 goto error_free_event;
 244         }
 245
 246         /* Copy event name */
 247         strncpy(lue->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN);
 248         lue->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
 249
 250         switch (ev->loglevel_type) {
 251         case LTTNG_EVENT_LOGLEVEL_ALL:
 252                 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
 253                 lue->attr.loglevel = -1;        /* Force to -1 */
 254                 break;
 255         case LTTNG_EVENT_LOGLEVEL_RANGE:
 256                 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
 257                 lue->attr.loglevel = ev->loglevel;
 258                 break;
 259         case LTTNG_EVENT_LOGLEVEL_SINGLE:
 260                 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
 261                 lue->attr.loglevel = ev->loglevel;
 262                 break;
 263         default:
 264                 ERR("Unknown ust loglevel type (%d)", ev->loglevel_type);
 265                 goto error_free_event;
 266         }
 267
 268
 269         /* Init node */
 270         lttng_ht_node_init_str(&lue->node, lue->attr.name);
 271         /* Alloc context hash tables */
 272         lue->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
 273         if (lue->ctx == NULL) {
 274                 ERR("Unable to create context hash table for event %s", ev->name);
 275                 goto error_free_event;
 276         }
 277
 278         DBG2("Trace UST event %s, loglevel (%d,%d) created",
 279                 lue->attr.name, lue->attr.loglevel_type,
 280                 lue->attr.loglevel);
 281
 282         return lue;
 283
 284 error_free_event:
 285         free(lue);
 286 error:
 287         return NULL;
 288 }
 289
 290 /*
 291  * Allocate and initialize a ust metadata.
 292  *
 293  * Return pointer to structure or NULL.
 294  */
 295 struct ltt_ust_metadata *trace_ust_create_metadata(char *path)
 296 {
 297         int ret;
 298         struct ltt_ust_metadata *lum;
 299
 300         lum = zmalloc(sizeof(struct ltt_ust_metadata));
 301         if (lum == NULL) {
 302                 PERROR("ust metadata zmalloc");
 303                 goto error;
 304         }
 305
 306         /* Set default attributes */
 307         lum->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
 308         lum->attr.subbuf_size = DEFAULT_METADATA_SUBBUF_SIZE;
 309         lum->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
 310         lum->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
 311         lum->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
 312         lum->attr.output = LTTNG_UST_MMAP;
 313
 314         lum->handle = -1;
 315         /* Set metadata trace path */
 316         ret = snprintf(lum->pathname, PATH_MAX, "%s/metadata", path);
 317         if (ret < 0) {
 318                 PERROR("asprintf ust metadata");
 319                 goto error_free_metadata;
 320         }
 321
 322         return lum;
 323
 324 error_free_metadata:
 325         free(lum);
 326 error:
 327         return NULL;
 328 }
 329
 330 /*
 331  * Allocate and initialize an UST context.
 332  *
 333  * Return pointer to structure or NULL.
 334  */
 335 struct ltt_ust_context *trace_ust_create_context(
 336                 struct lttng_event_context *ctx)
 337 {
 338         struct ltt_ust_context *uctx;
 339         enum lttng_ust_context_type utype;
 340
 341         switch (ctx->ctx) {
 342         case LTTNG_EVENT_CONTEXT_VTID:
 343                 utype = LTTNG_UST_CONTEXT_VTID;
 344                 break;
 345         case LTTNG_EVENT_CONTEXT_VPID:
 346                 utype = LTTNG_UST_CONTEXT_VPID;
 347                 break;
 348         case LTTNG_EVENT_CONTEXT_PTHREAD_ID:
 349                 utype = LTTNG_UST_CONTEXT_PTHREAD_ID;
 350                 break;
 351         case LTTNG_EVENT_CONTEXT_PROCNAME:
 352                 utype = LTTNG_UST_CONTEXT_PROCNAME;
 353                 break;
 354         default:
 355                 ERR("Invalid UST context");
 356                 return NULL;
 357         }
 358
 359         uctx = zmalloc(sizeof(struct ltt_ust_context));
 360         if (uctx == NULL) {
 361                 PERROR("zmalloc ltt_ust_context");
 362                 goto error;
 363         }
 364
 365         uctx->ctx.ctx = utype;
 366         lttng_ht_node_init_ulong(&uctx->node, (unsigned long) uctx->ctx.ctx);
 367
 368         return uctx;
 369
 370 error:
 371         return NULL;
 372 }
 373
 374 /*
 375  * RCU safe free context structure.
 376  */
 377 static void destroy_context_rcu(struct rcu_head *head)
 378 {
 379         struct lttng_ht_node_ulong *node =
 380                 caa_container_of(head, struct lttng_ht_node_ulong, head);
 381         struct ltt_ust_context *ctx =
 382                 caa_container_of(node, struct ltt_ust_context, node);
 383
 384         free(ctx);
 385 }
 386
 387 /*
 388  * Cleanup UST context hash table.
 389  */
 390 static void destroy_contexts(struct lttng_ht *ht)
 391 {
 392         int ret;
 393         struct lttng_ht_node_ulong *node;
 394         struct lttng_ht_iter iter;
 395
 396         cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) {
 397                 ret = lttng_ht_del(ht, &iter);
 398                 if (!ret) {
 399                         call_rcu(&node->head, destroy_context_rcu);
 400                 }
 401         }
 402
 403         lttng_ht_destroy(ht);
 404 }
 405
 406 /*
 407  * Cleanup ust event structure.
 408  */
 409 void trace_ust_destroy_event(struct ltt_ust_event *event)
 410 {
 411         DBG2("Trace destroy UST event %s", event->attr.name);
 412         destroy_contexts(event->ctx);
 413
 414         free(event);
 415 }
 416
 417 /*
 418  * URCU intermediate call to complete destroy event.
 419  */
 420 static void destroy_event_rcu(struct rcu_head *head)
 421 {
 422         struct lttng_ht_node_str *node =
 423                 caa_container_of(head, struct lttng_ht_node_str, head);
 424         struct ltt_ust_event *event =
 425                 caa_container_of(node, struct ltt_ust_event, node);
 426
 427         trace_ust_destroy_event(event);
 428 }
 429
 430 /*
 431  * Cleanup UST events hashtable.
 432  */
 433 static void destroy_events(struct lttng_ht *events)
 434 {
 435         int ret;
 436         struct lttng_ht_node_str *node;
 437         struct lttng_ht_iter iter;
 438
 439         cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) {
 440                 ret = lttng_ht_del(events, &iter);
 441                 assert(!ret);
 442                 call_rcu(&node->head, destroy_event_rcu);
 443         }
 444
 445         lttng_ht_destroy(events);
 446 }
 447
 448 /*
 449  * Cleanup ust channel structure.
 450  */
 451 void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
 452 {
 453         DBG2("Trace destroy UST channel %s", channel->name);
 454
 455         rcu_read_lock();
 456
 457         /* Destroying all events of the channel */
 458         destroy_events(channel->events);
 459         /* Destroying all context of the channel */
 460         destroy_contexts(channel->ctx);
 461
 462         free(channel);
 463
 464         rcu_read_unlock();
 465 }
 466
 467 /*
 468  * URCU intermediate call to complete destroy channel.
 469  */
 470 static void destroy_channel_rcu(struct rcu_head *head)
 471 {
 472         struct lttng_ht_node_str *node =
 473                 caa_container_of(head, struct lttng_ht_node_str, head);
 474         struct ltt_ust_channel *channel =
 475                 caa_container_of(node, struct ltt_ust_channel, node);
 476
 477         trace_ust_destroy_channel(channel);
 478 }
 479
 480 /*
 481  * Cleanup ust metadata structure.
 482  */
 483 void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata)
 484 {
 485         if (!metadata->handle) {
 486                 return;
 487         }
 488         DBG2("Trace UST destroy metadata %d", metadata->handle);
 489         free(metadata);
 490 }
 491
 492 /*
 493  * Iterate over a hash table containing channels and cleanup safely.
 494  */
 495 static void destroy_channels(struct lttng_ht *channels)
 496 {
 497         int ret;
 498         struct lttng_ht_node_str *node;
 499         struct lttng_ht_iter iter;
 500
 501         rcu_read_lock();
 502
 503         cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) {
 504                 ret = lttng_ht_del(channels, &iter);
 505                 assert(!ret);
 506                 call_rcu(&node->head, destroy_channel_rcu);
 507         }
 508
 509         lttng_ht_destroy(channels);
 510
 511         rcu_read_unlock();
 512 }
 513
 514 /*
 515  * Cleanup UST pid domain.
 516  */
 517 static void destroy_domain_pid(struct lttng_ht *ht)
 518 {
 519         int ret;
 520         struct lttng_ht_iter iter;
 521         struct ltt_ust_domain_pid *dpid;
 522
 523         cds_lfht_for_each_entry(ht->ht, &iter.iter, dpid, node.node) {
 524                 ret = lttng_ht_del(ht , &iter);
 525                 assert(!ret);
 526                 destroy_channels(dpid->channels);
 527         }
 528
 529         lttng_ht_destroy(ht);
 530 }
 531
 532 /*
 533  * Cleanup UST exec name domain.
 534  */
 535 static void destroy_domain_exec(struct lttng_ht *ht)
 536 {
 537         int ret;
 538         struct lttng_ht_iter iter;
 539         struct ltt_ust_domain_exec *dexec;
 540
 541         cds_lfht_for_each_entry(ht->ht, &iter.iter, dexec, node.node) {
 542                 ret = lttng_ht_del(ht , &iter);
 543                 assert(!ret);
 544                 destroy_channels(dexec->channels);
 545         }
 546
 547         lttng_ht_destroy(ht);
 548 }
 549
 550 /*
 551  * Cleanup UST global domain.
 552  */
 553 static void destroy_domain_global(struct ltt_ust_domain_global *dom)
 554 {
 555         destroy_channels(dom->channels);
 556 }
 557
 558 /*
 559  * Cleanup ust session structure
 560  */
 561 void trace_ust_destroy_session(struct ltt_ust_session *session)
 562 {
 563         /* Extra protection */
 564         if (session == NULL) {
 565                 return;
 566         }
 567
 568         rcu_read_lock();
 569
 570         DBG2("Trace UST destroy session %u", session->id);
 571
 572         /* Cleaning up UST domain */
 573         destroy_domain_global(&session->domain_global);
 574         destroy_domain_pid(session->domain_pid);
 575         destroy_domain_exec(session->domain_exec);
 576
 577         free(session);
 578
 579         rcu_read_unlock();
 580 }