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