Rename LTTng index in CTF index
[lttng-tools.git] / 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 #include <inttypes.h>
24
25 #include <common/common.h>
26 #include <common/defaults.h>
27
28 #include "buffer-registry.h"
29 #include "trace-ust.h"
30 #include "utils.h"
31
32 /*
33 * Match function for the events hash table lookup.
34 *
35 * Matches by name only. Used by the disable command.
36 */
37 int trace_ust_ht_match_event_by_name(struct cds_lfht_node *node,
38 const void *_key)
39 {
40 struct ltt_ust_event *event;
41 const char *name;
42
43 assert(node);
44 assert(_key);
45
46 event = caa_container_of(node, struct ltt_ust_event, node.node);
47 name = _key;
48
49 /* Event name */
50 if (strncmp(event->attr.name, name, sizeof(event->attr.name)) != 0) {
51 goto no_match;
52 }
53
54 /* Match */
55 return 1;
56
57 no_match:
58 return 0;
59 }
60
61 /*
62 * Match function for the hash table lookup.
63 *
64 * It matches an ust event based on three attributes which are the event name,
65 * the filter bytecode and the loglevel.
66 */
67 int trace_ust_ht_match_event(struct cds_lfht_node *node, const void *_key)
68 {
69 struct ltt_ust_event *event;
70 const struct ltt_ust_ht_key *key;
71
72 assert(node);
73 assert(_key);
74
75 event = caa_container_of(node, struct ltt_ust_event, node.node);
76 key = _key;
77
78 /* Match the 4 elements of the key: name, filter, loglevel, exclusions. */
79
80 /* Event name */
81 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
82 goto no_match;
83 }
84
85 /* Event loglevel. */
86 if (event->attr.loglevel != key->loglevel) {
87 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
88 && key->loglevel == 0 && event->attr.loglevel == -1) {
89 /*
90 * Match is accepted. This is because on event creation, the
91 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
92 * -1 are accepted for this loglevel type since 0 is the one set by
93 * the API when receiving an enable event.
94 */
95 } else {
96 goto no_match;
97 }
98 }
99
100 /* Only one of the filters is NULL, fail. */
101 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
102 goto no_match;
103 }
104
105 if (key->filter && event->filter) {
106 /* Both filters exists, check length followed by the bytecode. */
107 if (event->filter->len != key->filter->len ||
108 memcmp(event->filter->data, key->filter->data,
109 event->filter->len) != 0) {
110 goto no_match;
111 }
112 }
113
114 /* If only one of the exclusions is NULL, fail. */
115 if ((key->exclusion && !event->exclusion) || (!key->exclusion && event->exclusion)) {
116 goto no_match;
117 }
118
119 if (key->exclusion && event->exclusion) {
120 /* Both exclusions exist; check count followed by names. */
121 if (event->exclusion->count != key->exclusion->count ||
122 memcmp(event->exclusion->names, key->exclusion->names,
123 event->exclusion->count * LTTNG_SYMBOL_NAME_LEN) != 0) {
124 goto no_match;
125 }
126 }
127 /* Match. */
128 return 1;
129
130 no_match:
131 return 0;
132 }
133
134 /*
135 * Find the channel in the hashtable and return channel pointer. RCU read side
136 * lock MUST be acquired before calling this.
137 */
138 struct ltt_ust_channel *trace_ust_find_channel_by_name(struct lttng_ht *ht,
139 char *name)
140 {
141 struct lttng_ht_node_str *node;
142 struct lttng_ht_iter iter;
143
144 /*
145 * If we receive an empty string for channel name, it means the
146 * default channel name is requested.
147 */
148 if (name[0] == '\0')
149 name = DEFAULT_CHANNEL_NAME;
150
151 lttng_ht_lookup(ht, (void *)name, &iter);
152 node = lttng_ht_iter_get_node_str(&iter);
153 if (node == NULL) {
154 goto error;
155 }
156
157 DBG2("Trace UST channel %s found by name", name);
158
159 return caa_container_of(node, struct ltt_ust_channel, node);
160
161 error:
162 DBG2("Trace UST channel %s not found by name", name);
163 return NULL;
164 }
165
166 /*
167 * Find the event in the hashtable and return event pointer. RCU read side lock
168 * MUST be acquired before calling this.
169 */
170 struct ltt_ust_event *trace_ust_find_event(struct lttng_ht *ht,
171 char *name, struct lttng_filter_bytecode *filter, int loglevel,
172 struct lttng_event_exclusion *exclusion)
173 {
174 struct lttng_ht_node_str *node;
175 struct lttng_ht_iter iter;
176 struct ltt_ust_ht_key key;
177
178 assert(name);
179 assert(ht);
180
181 key.name = name;
182 key.filter = filter;
183 key.loglevel = loglevel;
184 key.exclusion = exclusion;
185
186 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
187 trace_ust_ht_match_event, &key, &iter.iter);
188 node = lttng_ht_iter_get_node_str(&iter);
189 if (node == NULL) {
190 goto error;
191 }
192
193 DBG2("Trace UST event %s found", key.name);
194
195 return caa_container_of(node, struct ltt_ust_event, node);
196
197 error:
198 DBG2("Trace UST event %s NOT found", key.name);
199 return NULL;
200 }
201
202 /*
203 * Allocate and initialize a ust session data structure.
204 *
205 * Return pointer to structure or NULL.
206 */
207 struct ltt_ust_session *trace_ust_create_session(uint64_t session_id)
208 {
209 int ret;
210 struct ltt_ust_session *lus;
211
212 /* Allocate a new ltt ust session */
213 lus = zmalloc(sizeof(struct ltt_ust_session));
214 if (lus == NULL) {
215 PERROR("create ust session zmalloc");
216 goto error;
217 }
218
219 /* Init data structure */
220 lus->id = session_id;
221 lus->start_trace = 0;
222
223 /*
224 * Default buffer type. This can be changed through an enable channel
225 * requesting a different type. Note that this can only be changed once
226 * during the session lifetime which is at the first enable channel and
227 * only before start. The flag buffer_type_changed indicates the status.
228 */
229 lus->buffer_type = LTTNG_BUFFER_PER_UID;
230 /* Once set to 1, the buffer_type is immutable for the session. */
231 lus->buffer_type_changed = 0;
232 /* Init it in case it get used after allocation. */
233 CDS_INIT_LIST_HEAD(&lus->buffer_reg_uid_list);
234
235 /* Alloc UST global domain channels' HT */
236 lus->domain_global.channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
237 ret = jul_init_domain(&lus->domain_jul);
238 if (ret < 0) {
239 goto error_consumer;
240 }
241
242 lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
243 if (lus->consumer == NULL) {
244 goto error_consumer;
245 }
246
247 /*
248 * The tmp_consumer stays NULL until a set_consumer_uri command is
249 * executed. At this point, the consumer should be nullify until an
250 * enable_consumer command. This assignment is symbolic since we've zmalloc
251 * the struct.
252 */
253 lus->tmp_consumer = NULL;
254
255 DBG2("UST trace session create successful");
256
257 return lus;
258
259 error_consumer:
260 ht_cleanup_push(lus->domain_global.channels);
261 jul_destroy_domain(&lus->domain_jul);
262 free(lus);
263 error:
264 return NULL;
265 }
266
267 /*
268 * Allocate and initialize a ust channel data structure.
269 *
270 * Return pointer to structure or NULL.
271 */
272 struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan)
273 {
274 struct ltt_ust_channel *luc;
275
276 assert(chan);
277
278 luc = zmalloc(sizeof(struct ltt_ust_channel));
279 if (luc == NULL) {
280 PERROR("ltt_ust_channel zmalloc");
281 goto error;
282 }
283
284 /* Copy UST channel attributes */
285 luc->attr.overwrite = chan->attr.overwrite;
286 luc->attr.subbuf_size = chan->attr.subbuf_size;
287 luc->attr.num_subbuf = chan->attr.num_subbuf;
288 luc->attr.switch_timer_interval = chan->attr.switch_timer_interval;
289 luc->attr.read_timer_interval = chan->attr.read_timer_interval;
290 luc->attr.output = (enum lttng_ust_output) chan->attr.output;
291
292 /* Translate to UST output enum */
293 switch (luc->attr.output) {
294 default:
295 luc->attr.output = LTTNG_UST_MMAP;
296 break;
297 }
298
299 /*
300 * If we receive an empty string for channel name, it means the
301 * default channel name is requested.
302 */
303 if (chan->name[0] == '\0') {
304 strncpy(luc->name, DEFAULT_CHANNEL_NAME, sizeof(luc->name));
305 } else {
306 /* Copy channel name */
307 strncpy(luc->name, chan->name, sizeof(luc->name));
308 }
309 luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
310
311 /* Init node */
312 lttng_ht_node_init_str(&luc->node, luc->name);
313 CDS_INIT_LIST_HEAD(&luc->ctx_list);
314
315 /* Alloc hash tables */
316 luc->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
317 luc->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
318
319 /* On-disk circular buffer parameters */
320 luc->tracefile_size = chan->attr.tracefile_size;
321 luc->tracefile_count = chan->attr.tracefile_count;
322
323 DBG2("Trace UST channel %s created", luc->name);
324
325 error:
326 return luc;
327 }
328
329 /*
330 * Allocate and initialize a ust event. Set name and event type.
331 *
332 * Return pointer to structure or NULL.
333 */
334 struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev,
335 struct lttng_filter_bytecode *filter,
336 struct lttng_event_exclusion *exclusion)
337 {
338 struct ltt_ust_event *lue;
339
340 assert(ev);
341
342 lue = zmalloc(sizeof(struct ltt_ust_event));
343 if (lue == NULL) {
344 PERROR("ust event zmalloc");
345 goto error;
346 }
347
348 switch (ev->type) {
349 case LTTNG_EVENT_PROBE:
350 lue->attr.instrumentation = LTTNG_UST_PROBE;
351 break;
352 case LTTNG_EVENT_FUNCTION:
353 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
354 break;
355 case LTTNG_EVENT_FUNCTION_ENTRY:
356 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
357 break;
358 case LTTNG_EVENT_TRACEPOINT:
359 lue->attr.instrumentation = LTTNG_UST_TRACEPOINT;
360 break;
361 default:
362 ERR("Unknown ust instrumentation type (%d)", ev->type);
363 goto error_free_event;
364 }
365
366 /* Copy event name */
367 strncpy(lue->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN);
368 lue->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
369
370 switch (ev->loglevel_type) {
371 case LTTNG_EVENT_LOGLEVEL_ALL:
372 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
373 lue->attr.loglevel = -1; /* Force to -1 */
374 break;
375 case LTTNG_EVENT_LOGLEVEL_RANGE:
376 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
377 lue->attr.loglevel = ev->loglevel;
378 break;
379 case LTTNG_EVENT_LOGLEVEL_SINGLE:
380 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
381 lue->attr.loglevel = ev->loglevel;
382 break;
383 default:
384 ERR("Unknown ust loglevel type (%d)", ev->loglevel_type);
385 goto error_free_event;
386 }
387
388 /* Same layout. */
389 lue->filter = (struct lttng_ust_filter_bytecode *) filter;
390 lue->exclusion = (struct lttng_event_exclusion *) exclusion;
391
392 /* Init node */
393 lttng_ht_node_init_str(&lue->node, lue->attr.name);
394
395 DBG2("Trace UST event %s, loglevel (%d,%d) created",
396 lue->attr.name, lue->attr.loglevel_type,
397 lue->attr.loglevel);
398
399 return lue;
400
401 error_free_event:
402 free(lue);
403 error:
404 return NULL;
405 }
406
407 /*
408 * Allocate and initialize a ust metadata.
409 *
410 * Return pointer to structure or NULL.
411 */
412 struct ltt_ust_metadata *trace_ust_create_metadata(char *path)
413 {
414 int ret;
415 struct ltt_ust_metadata *lum;
416
417 assert(path);
418
419 lum = zmalloc(sizeof(struct ltt_ust_metadata));
420 if (lum == NULL) {
421 PERROR("ust metadata zmalloc");
422 goto error;
423 }
424
425 /* Set default attributes */
426 lum->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
427 lum->attr.subbuf_size = default_get_metadata_subbuf_size();
428 lum->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
429 lum->attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER;
430 lum->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER;
431 lum->attr.output = LTTNG_UST_MMAP;
432
433 lum->handle = -1;
434 /* Set metadata trace path */
435 ret = snprintf(lum->pathname, PATH_MAX, "%s/" DEFAULT_METADATA_NAME, path);
436 if (ret < 0) {
437 PERROR("asprintf ust metadata");
438 goto error_free_metadata;
439 }
440
441 return lum;
442
443 error_free_metadata:
444 free(lum);
445 error:
446 return NULL;
447 }
448
449 /*
450 * Allocate and initialize an UST context.
451 *
452 * Return pointer to structure or NULL.
453 */
454 struct ltt_ust_context *trace_ust_create_context(
455 struct lttng_event_context *ctx)
456 {
457 struct ltt_ust_context *uctx;
458 enum lttng_ust_context_type utype;
459
460 assert(ctx);
461
462 switch (ctx->ctx) {
463 case LTTNG_EVENT_CONTEXT_VTID:
464 utype = LTTNG_UST_CONTEXT_VTID;
465 break;
466 case LTTNG_EVENT_CONTEXT_VPID:
467 utype = LTTNG_UST_CONTEXT_VPID;
468 break;
469 case LTTNG_EVENT_CONTEXT_PTHREAD_ID:
470 utype = LTTNG_UST_CONTEXT_PTHREAD_ID;
471 break;
472 case LTTNG_EVENT_CONTEXT_PROCNAME:
473 utype = LTTNG_UST_CONTEXT_PROCNAME;
474 break;
475 case LTTNG_EVENT_CONTEXT_IP:
476 utype = LTTNG_UST_CONTEXT_IP;
477 break;
478 default:
479 ERR("Invalid UST context");
480 return NULL;
481 }
482
483 uctx = zmalloc(sizeof(struct ltt_ust_context));
484 if (uctx == NULL) {
485 PERROR("zmalloc ltt_ust_context");
486 goto error;
487 }
488
489 uctx->ctx.ctx = utype;
490 lttng_ht_node_init_ulong(&uctx->node, (unsigned long) uctx->ctx.ctx);
491 CDS_INIT_LIST_HEAD(&uctx->list);
492
493 return uctx;
494
495 error:
496 return NULL;
497 }
498
499 /*
500 * RCU safe free context structure.
501 */
502 static void destroy_context_rcu(struct rcu_head *head)
503 {
504 struct lttng_ht_node_ulong *node =
505 caa_container_of(head, struct lttng_ht_node_ulong, head);
506 struct ltt_ust_context *ctx =
507 caa_container_of(node, struct ltt_ust_context, node);
508
509 free(ctx);
510 }
511
512 /*
513 * Cleanup UST context hash table.
514 */
515 static void destroy_contexts(struct lttng_ht *ht)
516 {
517 int ret;
518 struct lttng_ht_node_ulong *node;
519 struct lttng_ht_iter iter;
520 struct ltt_ust_context *ctx;
521
522 assert(ht);
523
524 rcu_read_lock();
525 cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) {
526 /* Remove from ordered list. */
527 ctx = caa_container_of(node, struct ltt_ust_context, node);
528 cds_list_del(&ctx->list);
529 /* Remove from channel's hash table. */
530 ret = lttng_ht_del(ht, &iter);
531 if (!ret) {
532 call_rcu(&node->head, destroy_context_rcu);
533 }
534 }
535 rcu_read_unlock();
536
537 ht_cleanup_push(ht);
538 }
539
540 /*
541 * Cleanup ust event structure.
542 */
543 void trace_ust_destroy_event(struct ltt_ust_event *event)
544 {
545 assert(event);
546
547 DBG2("Trace destroy UST event %s", event->attr.name);
548 free(event->filter);
549 free(event);
550 }
551
552 /*
553 * URCU intermediate call to complete destroy event.
554 */
555 static void destroy_event_rcu(struct rcu_head *head)
556 {
557 struct lttng_ht_node_str *node =
558 caa_container_of(head, struct lttng_ht_node_str, head);
559 struct ltt_ust_event *event =
560 caa_container_of(node, struct ltt_ust_event, node);
561
562 trace_ust_destroy_event(event);
563 }
564
565 /*
566 * Cleanup UST events hashtable.
567 */
568 static void destroy_events(struct lttng_ht *events)
569 {
570 int ret;
571 struct lttng_ht_node_str *node;
572 struct lttng_ht_iter iter;
573
574 assert(events);
575
576 rcu_read_lock();
577 cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) {
578 ret = lttng_ht_del(events, &iter);
579 assert(!ret);
580 call_rcu(&node->head, destroy_event_rcu);
581 }
582 rcu_read_unlock();
583
584 ht_cleanup_push(events);
585 }
586
587 /*
588 * Cleanup ust channel structure.
589 *
590 * Should _NOT_ be called with RCU read lock held.
591 */
592 static void _trace_ust_destroy_channel(struct ltt_ust_channel *channel)
593 {
594 assert(channel);
595
596 DBG2("Trace destroy UST channel %s", channel->name);
597
598 /* Destroying all events of the channel */
599 destroy_events(channel->events);
600 /* Destroying all context of the channel */
601 destroy_contexts(channel->ctx);
602
603 free(channel);
604 }
605
606 /*
607 * URCU intermediate call to complete destroy channel.
608 */
609 static void destroy_channel_rcu(struct rcu_head *head)
610 {
611 struct lttng_ht_node_str *node =
612 caa_container_of(head, struct lttng_ht_node_str, head);
613 struct ltt_ust_channel *channel =
614 caa_container_of(node, struct ltt_ust_channel, node);
615
616 _trace_ust_destroy_channel(channel);
617 }
618
619 void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
620 {
621 call_rcu(&channel->node.head, destroy_channel_rcu);
622 }
623
624 /*
625 * Remove an UST channel from a channel HT.
626 */
627 void trace_ust_delete_channel(struct lttng_ht *ht,
628 struct ltt_ust_channel *channel)
629 {
630 int ret;
631 struct lttng_ht_iter iter;
632
633 assert(ht);
634 assert(channel);
635
636 iter.iter.node = &channel->node.node;
637 ret = lttng_ht_del(ht, &iter);
638 assert(!ret);
639 }
640
641 /*
642 * Cleanup ust metadata structure.
643 */
644 void trace_ust_destroy_metadata(struct ltt_ust_metadata *metadata)
645 {
646 assert(metadata);
647
648 if (!metadata->handle) {
649 return;
650 }
651 DBG2("Trace UST destroy metadata %d", metadata->handle);
652 free(metadata);
653 }
654
655 /*
656 * Iterate over a hash table containing channels and cleanup safely.
657 */
658 static void destroy_channels(struct lttng_ht *channels)
659 {
660 int ret;
661 struct lttng_ht_node_str *node;
662 struct lttng_ht_iter iter;
663
664 assert(channels);
665
666 rcu_read_lock();
667
668 cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) {
669 ret = lttng_ht_del(channels, &iter);
670 assert(!ret);
671 call_rcu(&node->head, destroy_channel_rcu);
672 }
673 rcu_read_unlock();
674
675 ht_cleanup_push(channels);
676 }
677
678 /*
679 * Cleanup UST global domain.
680 */
681 static void destroy_domain_global(struct ltt_ust_domain_global *dom)
682 {
683 assert(dom);
684
685 destroy_channels(dom->channels);
686 }
687
688 /*
689 * Cleanup ust session structure
690 *
691 * Should *NOT* be called with RCU read-side lock held.
692 */
693 void trace_ust_destroy_session(struct ltt_ust_session *session)
694 {
695 struct buffer_reg_uid *reg, *sreg;
696
697 assert(session);
698
699 DBG2("Trace UST destroy session %" PRIu64, session->id);
700
701 /* Cleaning up UST domain */
702 destroy_domain_global(&session->domain_global);
703 jul_destroy_domain(&session->domain_jul);
704
705 /* Cleanup UID buffer registry object(s). */
706 cds_list_for_each_entry_safe(reg, sreg, &session->buffer_reg_uid_list,
707 lnode) {
708 cds_list_del(&reg->lnode);
709 buffer_reg_uid_remove(reg);
710 buffer_reg_uid_destroy(reg, session->consumer);
711 }
712
713 consumer_destroy_output(session->consumer);
714 consumer_destroy_output(session->tmp_consumer);
715
716 free(session);
717 }
This page took 0.046391 seconds and 4 git commands to generate.