Implement UST PID tracker
[lttng-tools.git] / src / bin / lttng-sessiond / trace-ust.c
CommitLineData
97ee3a89
DG
1/*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
d14d33bf
AM
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.
97ee3a89 7 *
d14d33bf
AM
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.
97ee3a89 12 *
d14d33bf
AM
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.
97ee3a89
DG
16 */
17
18#define _GNU_SOURCE
6c1c0768 19#define _LGPL_SOURCE
97ee3a89
DG
20#include <stdio.h>
21#include <stdlib.h>
22#include <string.h>
23#include <unistd.h>
d9bf3ca4 24#include <inttypes.h>
97ee3a89 25
990570ed
DG
26#include <common/common.h>
27#include <common/defaults.h>
97ee3a89 28
7972aab2 29#include "buffer-registry.h"
97ee3a89 30#include "trace-ust.h"
0b2dc8df 31#include "utils.h"
a9ad0c8f 32#include "ust-app.h"
97ee3a89 33
025faf73
DG
34/*
35 * Match function for the events hash table lookup.
36 *
37 * Matches by name only. Used by the disable command.
38 */
18eace3b
DG
39int trace_ust_ht_match_event_by_name(struct cds_lfht_node *node,
40 const void *_key)
41{
42 struct ltt_ust_event *event;
43 const char *name;
44
45 assert(node);
46 assert(_key);
47
48 event = caa_container_of(node, struct ltt_ust_event, node.node);
49 name = _key;
50
51 /* Event name */
52 if (strncmp(event->attr.name, name, sizeof(event->attr.name)) != 0) {
53 goto no_match;
54 }
55
025faf73 56 /* Match */
18eace3b
DG
57 return 1;
58
59no_match:
60 return 0;
61}
62
025faf73
DG
63/*
64 * Match function for the hash table lookup.
65 *
66 * It matches an ust event based on three attributes which are the event name,
67 * the filter bytecode and the loglevel.
68 */
18eace3b
DG
69int trace_ust_ht_match_event(struct cds_lfht_node *node, const void *_key)
70{
71 struct ltt_ust_event *event;
72 const struct ltt_ust_ht_key *key;
73
74 assert(node);
75 assert(_key);
76
77 event = caa_container_of(node, struct ltt_ust_event, node.node);
78 key = _key;
79
f19e9f8b 80 /* Match the 4 elements of the key: name, filter, loglevel, exclusions. */
18eace3b
DG
81
82 /* Event name */
83 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
18eace3b
DG
84 goto no_match;
85 }
86
87 /* Event loglevel. */
88 if (event->attr.loglevel != key->loglevel) {
025faf73
DG
89 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
90 && key->loglevel == 0 && event->attr.loglevel == -1) {
18eace3b 91 /*
025faf73
DG
92 * Match is accepted. This is because on event creation, the
93 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
94 * -1 are accepted for this loglevel type since 0 is the one set by
95 * the API when receiving an enable event.
18eace3b
DG
96 */
97 } else {
18eace3b
DG
98 goto no_match;
99 }
100 }
101
102 /* Only one of the filters is NULL, fail. */
103 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
18eace3b
DG
104 goto no_match;
105 }
106
025faf73
DG
107 if (key->filter && event->filter) {
108 /* Both filters exists, check length followed by the bytecode. */
109 if (event->filter->len != key->filter->len ||
110 memcmp(event->filter->data, key->filter->data,
111 event->filter->len) != 0) {
112 goto no_match;
113 }
18eace3b
DG
114 }
115
f19e9f8b
JI
116 /* If only one of the exclusions is NULL, fail. */
117 if ((key->exclusion && !event->exclusion) || (!key->exclusion && event->exclusion)) {
118 goto no_match;
119 }
120
121 if (key->exclusion && event->exclusion) {
122 /* Both exclusions exist; check count followed by names. */
123 if (event->exclusion->count != key->exclusion->count ||
124 memcmp(event->exclusion->names, key->exclusion->names,
125 event->exclusion->count * LTTNG_SYMBOL_NAME_LEN) != 0) {
126 goto no_match;
127 }
128 }
025faf73
DG
129 /* Match. */
130 return 1;
18eace3b
DG
131
132no_match:
133 return 0;
18eace3b
DG
134}
135
0177d773 136/*
2223c96f
DG
137 * Find the channel in the hashtable and return channel pointer. RCU read side
138 * lock MUST be acquired before calling this.
0177d773 139 */
bec39940 140struct ltt_ust_channel *trace_ust_find_channel_by_name(struct lttng_ht *ht,
f6a9efaa 141 char *name)
0177d773 142{
bec39940
DG
143 struct lttng_ht_node_str *node;
144 struct lttng_ht_iter iter;
0177d773 145
85076754
MD
146 /*
147 * If we receive an empty string for channel name, it means the
148 * default channel name is requested.
149 */
150 if (name[0] == '\0')
151 name = DEFAULT_CHANNEL_NAME;
152
bec39940
DG
153 lttng_ht_lookup(ht, (void *)name, &iter);
154 node = lttng_ht_iter_get_node_str(&iter);
f6a9efaa 155 if (node == NULL) {
44d3bd01
DG
156 goto error;
157 }
158
f6a9efaa 159 DBG2("Trace UST channel %s found by name", name);
0177d773 160
f6a9efaa 161 return caa_container_of(node, struct ltt_ust_channel, node);
97ee3a89
DG
162
163error:
f6a9efaa 164 DBG2("Trace UST channel %s not found by name", name);
97ee3a89
DG
165 return NULL;
166}
167
168/*
2223c96f
DG
169 * Find the event in the hashtable and return event pointer. RCU read side lock
170 * MUST be acquired before calling this.
97ee3a89 171 */
18eace3b 172struct ltt_ust_event *trace_ust_find_event(struct lttng_ht *ht,
10646003
JI
173 char *name, struct lttng_filter_bytecode *filter, int loglevel,
174 struct lttng_event_exclusion *exclusion)
97ee3a89 175{
bec39940
DG
176 struct lttng_ht_node_str *node;
177 struct lttng_ht_iter iter;
18eace3b 178 struct ltt_ust_ht_key key;
97ee3a89 179
18eace3b
DG
180 assert(name);
181 assert(ht);
182
183 key.name = name;
184 key.filter = filter;
185 key.loglevel = loglevel;
10646003 186 key.exclusion = exclusion;
18eace3b 187
18eace3b
DG
188 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
189 trace_ust_ht_match_event, &key, &iter.iter);
bec39940 190 node = lttng_ht_iter_get_node_str(&iter);
f6a9efaa 191 if (node == NULL) {
97ee3a89
DG
192 goto error;
193 }
194
18eace3b 195 DBG2("Trace UST event %s found", key.name);
f6a9efaa
DG
196
197 return caa_container_of(node, struct ltt_ust_event, node);
97ee3a89
DG
198
199error:
18eace3b 200 DBG2("Trace UST event %s NOT found", key.name);
97ee3a89
DG
201 return NULL;
202}
203
fefd409b
DG
204/*
205 * Lookup an agent in the session agents hash table by domain type and return
206 * the object if found else NULL.
4da703ad
JG
207 *
208 * RCU read side lock must be acquired before calling and only released
209 * once the agent is no longer in scope or being used.
fefd409b
DG
210 */
211struct agent *trace_ust_find_agent(struct ltt_ust_session *session,
212 enum lttng_domain_type domain_type)
213{
214 struct agent *agt = NULL;
215 struct lttng_ht_node_u64 *node;
216 struct lttng_ht_iter iter;
217 uint64_t key;
218
219 assert(session);
220
221 DBG3("Trace ust agent lookup for domain %d", domain_type);
222
223 key = domain_type;
224
225 lttng_ht_lookup(session->agents, &key, &iter);
226 node = lttng_ht_iter_get_node_u64(&iter);
227 if (!node) {
228 goto end;
229 }
230 agt = caa_container_of(node, struct agent, node);
231
232end:
233 return agt;
234}
235
97ee3a89
DG
236/*
237 * Allocate and initialize a ust session data structure.
238 *
239 * Return pointer to structure or NULL.
240 */
d9bf3ca4 241struct ltt_ust_session *trace_ust_create_session(uint64_t session_id)
97ee3a89
DG
242{
243 struct ltt_ust_session *lus;
244
245 /* Allocate a new ltt ust session */
ba7f0ae5 246 lus = zmalloc(sizeof(struct ltt_ust_session));
97ee3a89 247 if (lus == NULL) {
ba7f0ae5 248 PERROR("create ust session zmalloc");
97ee3a89
DG
249 goto error;
250 }
251
252 /* Init data structure */
a991f516 253 lus->id = session_id;
14fb1ebe 254 lus->active = 0;
97ee3a89 255
84ad93e8
DG
256 /* Set default metadata channel attribute. */
257 lus->metadata_attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
258 lus->metadata_attr.subbuf_size = default_get_metadata_subbuf_size();
259 lus->metadata_attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
260 lus->metadata_attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER;
261 lus->metadata_attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER;
262 lus->metadata_attr.output = LTTNG_UST_MMAP;
263
7972aab2
DG
264 /*
265 * Default buffer type. This can be changed through an enable channel
266 * requesting a different type. Note that this can only be changed once
267 * during the session lifetime which is at the first enable channel and
268 * only before start. The flag buffer_type_changed indicates the status.
269 */
8692d4e5 270 lus->buffer_type = LTTNG_BUFFER_PER_UID;
7972aab2
DG
271 /* Once set to 1, the buffer_type is immutable for the session. */
272 lus->buffer_type_changed = 0;
273 /* Init it in case it get used after allocation. */
274 CDS_INIT_LIST_HEAD(&lus->buffer_reg_uid_list);
f6a9efaa
DG
275
276 /* Alloc UST global domain channels' HT */
bec39940 277 lus->domain_global.channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
fefd409b
DG
278 /* Alloc agent hash table. */
279 lus->agents = lttng_ht_new(0, LTTNG_HT_TYPE_U64);
44d3bd01 280
00e2e675
DG
281 lus->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
282 if (lus->consumer == NULL) {
09a90bcd 283 goto error_consumer;
00e2e675
DG
284 }
285
286 /*
287 * The tmp_consumer stays NULL until a set_consumer_uri command is
288 * executed. At this point, the consumer should be nullify until an
289 * enable_consumer command. This assignment is symbolic since we've zmalloc
290 * the struct.
291 */
292 lus->tmp_consumer = NULL;
293
44d3bd01
DG
294 DBG2("UST trace session create successful");
295
97ee3a89
DG
296 return lus;
297
09a90bcd 298error_consumer:
0b2dc8df 299 ht_cleanup_push(lus->domain_global.channels);
fefd409b 300 ht_cleanup_push(lus->agents);
44844c29 301 free(lus);
97ee3a89
DG
302error:
303 return NULL;
304}
305
306/*
307 * Allocate and initialize a ust channel data structure.
308 *
309 * Return pointer to structure or NULL.
310 */
dec56f6c 311struct ltt_ust_channel *trace_ust_create_channel(struct lttng_channel *chan)
97ee3a89 312{
97ee3a89
DG
313 struct ltt_ust_channel *luc;
314
0525e9ae 315 assert(chan);
0525e9ae 316
37357452 317 luc = zmalloc(sizeof(struct ltt_ust_channel));
97ee3a89 318 if (luc == NULL) {
df0f840b 319 PERROR("ltt_ust_channel zmalloc");
97ee3a89
DG
320 goto error;
321 }
322
44d3bd01 323 /* Copy UST channel attributes */
48842b30
DG
324 luc->attr.overwrite = chan->attr.overwrite;
325 luc->attr.subbuf_size = chan->attr.subbuf_size;
326 luc->attr.num_subbuf = chan->attr.num_subbuf;
327 luc->attr.switch_timer_interval = chan->attr.switch_timer_interval;
328 luc->attr.read_timer_interval = chan->attr.read_timer_interval;
6775595e 329 luc->attr.output = (enum lttng_ust_output) chan->attr.output;
44d3bd01
DG
330
331 /* Translate to UST output enum */
332 switch (luc->attr.output) {
333 default:
334 luc->attr.output = LTTNG_UST_MMAP;
335 break;
97ee3a89 336 }
97ee3a89 337
85076754
MD
338 /*
339 * If we receive an empty string for channel name, it means the
340 * default channel name is requested.
341 */
342 if (chan->name[0] == '\0') {
343 strncpy(luc->name, DEFAULT_CHANNEL_NAME, sizeof(luc->name));
344 } else {
345 /* Copy channel name */
346 strncpy(luc->name, chan->name, sizeof(luc->name));
347 }
97ee3a89
DG
348 luc->name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
349
f6a9efaa 350 /* Init node */
bec39940 351 lttng_ht_node_init_str(&luc->node, luc->name);
31746f93
DG
352 CDS_INIT_LIST_HEAD(&luc->ctx_list);
353
f6a9efaa 354 /* Alloc hash tables */
bec39940
DG
355 luc->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
356 luc->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
f6a9efaa 357
1624d5b7
JD
358 /* On-disk circular buffer parameters */
359 luc->tracefile_size = chan->attr.tracefile_size;
360 luc->tracefile_count = chan->attr.tracefile_count;
361
f6a9efaa
DG
362 DBG2("Trace UST channel %s created", luc->name);
363
97ee3a89 364error:
7972aab2 365 return luc;
97ee3a89
DG
366}
367
368/*
369 * Allocate and initialize a ust event. Set name and event type.
49d21f93 370 * We own filter_expression, filter, and exclusion.
97ee3a89
DG
371 *
372 * Return pointer to structure or NULL.
373 */
025faf73 374struct ltt_ust_event *trace_ust_create_event(struct lttng_event *ev,
6b453b5e 375 char *filter_expression,
561c6897
JI
376 struct lttng_filter_bytecode *filter,
377 struct lttng_event_exclusion *exclusion)
97ee3a89
DG
378{
379 struct ltt_ust_event *lue;
97ee3a89 380
0525e9ae
DG
381 assert(ev);
382
37357452 383 lue = zmalloc(sizeof(struct ltt_ust_event));
44d3bd01 384 if (lue == NULL) {
ba7f0ae5 385 PERROR("ust event zmalloc");
97ee3a89
DG
386 goto error;
387 }
388
389 switch (ev->type) {
390 case LTTNG_EVENT_PROBE:
44d3bd01 391 lue->attr.instrumentation = LTTNG_UST_PROBE;
97ee3a89
DG
392 break;
393 case LTTNG_EVENT_FUNCTION:
44d3bd01 394 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
97ee3a89
DG
395 break;
396 case LTTNG_EVENT_FUNCTION_ENTRY:
44d3bd01 397 lue->attr.instrumentation = LTTNG_UST_FUNCTION;
97ee3a89
DG
398 break;
399 case LTTNG_EVENT_TRACEPOINT:
44d3bd01 400 lue->attr.instrumentation = LTTNG_UST_TRACEPOINT;
97ee3a89
DG
401 break;
402 default:
403 ERR("Unknown ust instrumentation type (%d)", ev->type);
44844c29 404 goto error_free_event;
97ee3a89
DG
405 }
406
407 /* Copy event name */
44d3bd01
DG
408 strncpy(lue->attr.name, ev->name, LTTNG_UST_SYM_NAME_LEN);
409 lue->attr.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
97ee3a89 410
0cda4f28 411 switch (ev->loglevel_type) {
8005f29a
MD
412 case LTTNG_EVENT_LOGLEVEL_ALL:
413 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_ALL;
22e25b71 414 lue->attr.loglevel = -1; /* Force to -1 */
0cda4f28 415 break;
8005f29a
MD
416 case LTTNG_EVENT_LOGLEVEL_RANGE:
417 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_RANGE;
22e25b71 418 lue->attr.loglevel = ev->loglevel;
8005f29a
MD
419 break;
420 case LTTNG_EVENT_LOGLEVEL_SINGLE:
421 lue->attr.loglevel_type = LTTNG_UST_LOGLEVEL_SINGLE;
22e25b71 422 lue->attr.loglevel = ev->loglevel;
0cda4f28
MD
423 break;
424 default:
4431494b 425 ERR("Unknown ust loglevel type (%d)", ev->loglevel_type);
0cda4f28
MD
426 goto error_free_event;
427 }
428
025faf73 429 /* Same layout. */
6b453b5e 430 lue->filter_expression = filter_expression;
025faf73 431 lue->filter = (struct lttng_ust_filter_bytecode *) filter;
561c6897 432 lue->exclusion = (struct lttng_event_exclusion *) exclusion;
0cda4f28 433
f6a9efaa 434 /* Init node */
bec39940 435 lttng_ht_node_init_str(&lue->node, lue->attr.name);
97ee3a89 436
300b8fd5
MD
437 DBG2("Trace UST event %s, loglevel (%d,%d) created",
438 lue->attr.name, lue->attr.loglevel_type,
439 lue->attr.loglevel);
284d8f55 440
97ee3a89
DG
441 return lue;
442
44844c29
MD
443error_free_event:
444 free(lue);
97ee3a89 445error:
49d21f93
MD
446 free(filter_expression);
447 free(filter);
448 free(exclusion);
97ee3a89
DG
449 return NULL;
450}
451
aa3514e9
MD
452static
453int trace_ust_context_type_event_to_ust(enum lttng_event_context_type type)
55cc08a6 454{
aa3514e9 455 int utype;
0525e9ae 456
aa3514e9 457 switch (type) {
9197c5c4
MD
458 case LTTNG_EVENT_CONTEXT_VTID:
459 utype = LTTNG_UST_CONTEXT_VTID;
460 break;
461 case LTTNG_EVENT_CONTEXT_VPID:
462 utype = LTTNG_UST_CONTEXT_VPID;
463 break;
464 case LTTNG_EVENT_CONTEXT_PTHREAD_ID:
465 utype = LTTNG_UST_CONTEXT_PTHREAD_ID;
466 break;
467 case LTTNG_EVENT_CONTEXT_PROCNAME:
468 utype = LTTNG_UST_CONTEXT_PROCNAME;
469 break;
7c612c2e
WP
470 case LTTNG_EVENT_CONTEXT_IP:
471 utype = LTTNG_UST_CONTEXT_IP;
472 break;
aa3514e9 473 case LTTNG_EVENT_CONTEXT_PERF_THREAD_COUNTER:
354e561b
MD
474 if (!ustctl_has_perf_counters()) {
475 utype = -1;
476 WARN("Perf counters not implemented in UST");
477 } else {
478 utype = LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER;
479 }
aa3514e9 480 break;
9197c5c4
MD
481 default:
482 ERR("Invalid UST context");
aa3514e9
MD
483 utype = -1;
484 break;
485 }
486 return utype;
487}
488
489/*
490 * Return 1 if contexts match, 0 otherwise.
491 */
492int trace_ust_match_context(struct ltt_ust_context *uctx,
493 struct lttng_event_context *ctx)
494{
495 int utype;
496
497 utype = trace_ust_context_type_event_to_ust(ctx->ctx);
498 if (utype < 0) {
499 return 0;
500 }
501 if (uctx->ctx.ctx != utype) {
502 return 0;
503 }
504 switch (utype) {
505 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
506 if (uctx->ctx.u.perf_counter.type
507 != ctx->u.perf_counter.type) {
508 return 0;
509 }
510 if (uctx->ctx.u.perf_counter.config
511 != ctx->u.perf_counter.config) {
512 return 0;
513 }
514 if (strncmp(uctx->ctx.u.perf_counter.name,
515 ctx->u.perf_counter.name,
516 LTTNG_UST_SYM_NAME_LEN)) {
517 return 0;
518 }
519 break;
520 default:
521 break;
522
523 }
524 return 1;
525}
526
527/*
528 * Allocate and initialize an UST context.
529 *
530 * Return pointer to structure or NULL.
531 */
532struct ltt_ust_context *trace_ust_create_context(
533 struct lttng_event_context *ctx)
534{
535 struct ltt_ust_context *uctx;
536 int utype;
537
538 assert(ctx);
539
540 utype = trace_ust_context_type_event_to_ust(ctx->ctx);
541 if (utype < 0) {
9197c5c4
MD
542 return NULL;
543 }
55cc08a6
DG
544
545 uctx = zmalloc(sizeof(struct ltt_ust_context));
546 if (uctx == NULL) {
547 PERROR("zmalloc ltt_ust_context");
548 goto error;
549 }
550
aa3514e9
MD
551 uctx->ctx.ctx = (enum lttng_ust_context_type) utype;
552 switch (utype) {
553 case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER:
554 uctx->ctx.u.perf_counter.type = ctx->u.perf_counter.type;
555 uctx->ctx.u.perf_counter.config = ctx->u.perf_counter.config;
556 strncpy(uctx->ctx.u.perf_counter.name, ctx->u.perf_counter.name,
557 LTTNG_UST_SYM_NAME_LEN);
558 uctx->ctx.u.perf_counter.name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0';
559 break;
560 default:
561 break;
562 }
bec39940 563 lttng_ht_node_init_ulong(&uctx->node, (unsigned long) uctx->ctx.ctx);
55cc08a6
DG
564
565 return uctx;
566
567error:
568 return NULL;
569}
570
a9ad0c8f
MD
571static
572void destroy_pid_tracker_node_rcu(struct rcu_head *head)
573{
574 struct ust_pid_tracker_node *tracker_node =
575 caa_container_of(head, struct ust_pid_tracker_node, node.head);
576 free(tracker_node);
577}
578
579static
580void destroy_pid_tracker_node(struct ust_pid_tracker_node *tracker_node)
581{
582
583 call_rcu(&tracker_node->node.head, destroy_pid_tracker_node_rcu);
584}
585
586static
587int init_pid_tracker(struct ust_pid_tracker *pid_tracker)
588{
589 int ret = 0;
590
591 pid_tracker->ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
592 if (!pid_tracker->ht) {
593 ret = -1;
594 goto end;
595 }
596
597end:
598 return ret;
599}
600
601/*
602 * Teardown pid tracker content, but don't free pid_tracker object.
603 */
604static
605void fini_pid_tracker(struct ust_pid_tracker *pid_tracker)
606{
607 struct ust_pid_tracker_node *tracker_node;
608 struct lttng_ht_iter iter;
609
610 if (!pid_tracker->ht) {
611 return;
612 }
613 rcu_read_lock();
614 cds_lfht_for_each_entry(pid_tracker->ht->ht,
615 &iter.iter, tracker_node, node.node) {
616 int ret = lttng_ht_del(pid_tracker->ht, &iter);
617
618 assert(!ret);
619 destroy_pid_tracker_node(tracker_node);
620 }
621 rcu_read_unlock();
622 ht_cleanup_push(pid_tracker->ht);
623 pid_tracker->ht = NULL;
624}
625
626static
627struct ust_pid_tracker_node *pid_tracker_lookup(
628 struct ust_pid_tracker *pid_tracker, int pid,
629 struct lttng_ht_iter *iter)
630{
631 unsigned long _pid = (unsigned long) pid;
632 struct lttng_ht_node_ulong *node;
633
634 lttng_ht_lookup(pid_tracker->ht, (void *) _pid, iter);
635 node = lttng_ht_iter_get_node_ulong(iter);
636 if (node) {
637 return caa_container_of(node, struct ust_pid_tracker_node,
638 node);
639 } else {
640 return NULL;
641 }
642}
643
644static
645int pid_tracker_add_pid(struct ust_pid_tracker *pid_tracker, int pid)
646{
647 int retval = LTTNG_OK;
648 struct ust_pid_tracker_node *tracker_node;
649 struct lttng_ht_iter iter;
650
651 if (pid < 0) {
652 retval = LTTNG_ERR_INVALID;
653 goto end;
654 }
655 tracker_node = pid_tracker_lookup(pid_tracker, pid, &iter);
656 if (tracker_node) {
657 /* Already exists. */
658 retval = LTTNG_ERR_INVALID;
659 goto end;
660 }
661 tracker_node = zmalloc(sizeof(*tracker_node));
662 if (!tracker_node) {
663 retval = LTTNG_ERR_NOMEM;
664 goto end;
665 }
666 lttng_ht_node_init_ulong(&tracker_node->node, (unsigned long) pid);
667 lttng_ht_add_unique_ulong(pid_tracker->ht, &tracker_node->node);
668end:
669 return retval;
670}
671
672static
673int pid_tracker_del_pid(struct ust_pid_tracker *pid_tracker, int pid)
674{
675 int retval = LTTNG_OK, ret;
676 struct ust_pid_tracker_node *tracker_node;
677 struct lttng_ht_iter iter;
678
679 if (pid < 0) {
680 retval = LTTNG_ERR_INVALID;
681 goto end;
682 }
683 tracker_node = pid_tracker_lookup(pid_tracker, pid, &iter);
684 if (!tracker_node) {
685 /* Not found */
686 retval = LTTNG_ERR_INVALID;
687 goto end;
688 }
689 ret = lttng_ht_del(pid_tracker->ht, &iter);
690 assert(!ret);
691
692 destroy_pid_tracker_node(tracker_node);
693end:
694 return retval;
695}
696
697/*
698 * The session lock is held when calling this function.
699 */
700int trace_ust_pid_tracker_lookup(struct ltt_ust_session *session, int pid)
701{
702 struct lttng_ht_iter iter;
703
704 if (!session->pid_tracker.ht) {
705 return 1;
706 }
707 if (pid_tracker_lookup(&session->pid_tracker, pid, &iter)) {
708 return 1;
709 }
710 return 0;
711}
712
713/*
714 * Called with the session lock held.
715 */
716int trace_ust_track_pid(struct ltt_ust_session *session, int pid)
717{
718 int retval = LTTNG_OK;
719
720 if (pid == -1) {
721 /* Track all pids: destroy tracker if exists. */
722 if (session->pid_tracker.ht) {
723 fini_pid_tracker(&session->pid_tracker);
724 /* Ensure all apps have session. */
725 ust_app_global_update_all(session);
726 }
727 } else {
728 int ret;
729
730 if (!session->pid_tracker.ht) {
731 /* Create tracker. */
732 if (init_pid_tracker(&session->pid_tracker)) {
733 ERR("Error initializing PID tracker");
734 retval = LTTNG_ERR_NOMEM;
735 goto end;
736 }
737 ret = pid_tracker_add_pid(&session->pid_tracker, pid);
738 if (ret != LTTNG_OK) {
739 retval = ret;
740 fini_pid_tracker(&session->pid_tracker);
741 goto end;
742 }
743 /* Remove all apps from session except pid. */
744 ust_app_global_update_all(session);
745 } else {
746 struct ust_app *app;
747
748 ret = pid_tracker_add_pid(&session->pid_tracker, pid);
749 if (ret != LTTNG_OK) {
750 retval = ret;
751 goto end;
752 }
753 /* Add session to application */
754 app = ust_app_find_by_pid(pid);
755 if (app) {
756 ust_app_global_update(session, app);
757 }
758 }
759 }
760end:
761 return retval;
762}
763
764/*
765 * Called with the session lock held.
766 */
767int trace_ust_untrack_pid(struct ltt_ust_session *session, int pid)
768{
769 int retval = LTTNG_OK;
770
771 if (pid == -1) {
772 /* Create empty tracker, replace old tracker. */
773 struct ust_pid_tracker tmp_tracker;
774
775 tmp_tracker = session->pid_tracker;
776 if (init_pid_tracker(&session->pid_tracker)) {
777 ERR("Error initializing PID tracker");
778 retval = LTTNG_ERR_NOMEM;
779 /* Rollback operation. */
780 session->pid_tracker = tmp_tracker;
781 goto end;
782 }
783 fini_pid_tracker(&tmp_tracker);
784
785 /* Remove session from all applications */
786 ust_app_global_update_all(session);
787 } else {
788 int ret;
789 struct ust_app *app;
790
791 if (!session->pid_tracker.ht) {
792 retval = LTTNG_ERR_INVALID;
793 goto end;
794 }
795 /* Remove PID from tracker */
796 ret = pid_tracker_del_pid(&session->pid_tracker, pid);
797 if (ret != LTTNG_OK) {
798 retval = ret;
799 goto end;
800 }
801 /* Remove session from application. */
802 app = ust_app_find_by_pid(pid);
803 if (app) {
804 ust_app_global_update(session, app);
805 }
806 }
807end:
808 return retval;
809}
810
f6a9efaa
DG
811/*
812 * RCU safe free context structure.
813 */
814static void destroy_context_rcu(struct rcu_head *head)
815{
bec39940
DG
816 struct lttng_ht_node_ulong *node =
817 caa_container_of(head, struct lttng_ht_node_ulong, head);
f6a9efaa
DG
818 struct ltt_ust_context *ctx =
819 caa_container_of(node, struct ltt_ust_context, node);
820
821 free(ctx);
822}
823
824/*
825 * Cleanup UST context hash table.
826 */
7bd39047 827static void destroy_contexts(struct lttng_ht *ht)
f6a9efaa
DG
828{
829 int ret;
bec39940
DG
830 struct lttng_ht_node_ulong *node;
831 struct lttng_ht_iter iter;
31746f93 832 struct ltt_ust_context *ctx;
f6a9efaa 833
0525e9ae
DG
834 assert(ht);
835
36b588ed 836 rcu_read_lock();
bec39940 837 cds_lfht_for_each_entry(ht->ht, &iter.iter, node, node) {
31746f93
DG
838 /* Remove from ordered list. */
839 ctx = caa_container_of(node, struct ltt_ust_context, node);
840 cds_list_del(&ctx->list);
841 /* Remove from channel's hash table. */
bec39940 842 ret = lttng_ht_del(ht, &iter);
f6a9efaa
DG
843 if (!ret) {
844 call_rcu(&node->head, destroy_context_rcu);
845 }
f6a9efaa 846 }
36b588ed 847 rcu_read_unlock();
ed52805d 848
0b2dc8df 849 ht_cleanup_push(ht);
f6a9efaa
DG
850}
851
97ee3a89
DG
852/*
853 * Cleanup ust event structure.
854 */
855void trace_ust_destroy_event(struct ltt_ust_event *event)
856{
0525e9ae
DG
857 assert(event);
858
f6a9efaa 859 DBG2("Trace destroy UST event %s", event->attr.name);
6b453b5e 860 free(event->filter_expression);
53a80697 861 free(event->filter);
40024f8a 862 free(event->exclusion);
97ee3a89
DG
863 free(event);
864}
865
f6a9efaa
DG
866/*
867 * URCU intermediate call to complete destroy event.
868 */
869static void destroy_event_rcu(struct rcu_head *head)
870{
bec39940
DG
871 struct lttng_ht_node_str *node =
872 caa_container_of(head, struct lttng_ht_node_str, head);
f6a9efaa
DG
873 struct ltt_ust_event *event =
874 caa_container_of(node, struct ltt_ust_event, node);
875
876 trace_ust_destroy_event(event);
877}
878
284d8f55
DG
879/*
880 * Cleanup UST events hashtable.
881 */
7bd39047 882static void destroy_events(struct lttng_ht *events)
ed52805d
DG
883{
884 int ret;
bec39940
DG
885 struct lttng_ht_node_str *node;
886 struct lttng_ht_iter iter;
ed52805d 887
0525e9ae
DG
888 assert(events);
889
36b588ed 890 rcu_read_lock();
bec39940
DG
891 cds_lfht_for_each_entry(events->ht, &iter.iter, node, node) {
892 ret = lttng_ht_del(events, &iter);
7bd39047
DG
893 assert(!ret);
894 call_rcu(&node->head, destroy_event_rcu);
ed52805d 895 }
36b588ed 896 rcu_read_unlock();
ed52805d 897
0b2dc8df 898 ht_cleanup_push(events);
ed52805d
DG
899}
900
97ee3a89
DG
901/*
902 * Cleanup ust channel structure.
36b588ed
MD
903 *
904 * Should _NOT_ be called with RCU read lock held.
97ee3a89 905 */
36b588ed 906static void _trace_ust_destroy_channel(struct ltt_ust_channel *channel)
97ee3a89 907{
0525e9ae
DG
908 assert(channel);
909
f6a9efaa 910 DBG2("Trace destroy UST channel %s", channel->name);
97ee3a89 911
7bd39047
DG
912 /* Destroying all events of the channel */
913 destroy_events(channel->events);
914 /* Destroying all context of the channel */
915 destroy_contexts(channel->ctx);
97ee3a89 916
97ee3a89 917 free(channel);
f6a9efaa
DG
918}
919
920/*
921 * URCU intermediate call to complete destroy channel.
922 */
923static void destroy_channel_rcu(struct rcu_head *head)
924{
bec39940
DG
925 struct lttng_ht_node_str *node =
926 caa_container_of(head, struct lttng_ht_node_str, head);
f6a9efaa
DG
927 struct ltt_ust_channel *channel =
928 caa_container_of(node, struct ltt_ust_channel, node);
929
36b588ed
MD
930 _trace_ust_destroy_channel(channel);
931}
932
933void trace_ust_destroy_channel(struct ltt_ust_channel *channel)
934{
935 call_rcu(&channel->node.head, destroy_channel_rcu);
97ee3a89
DG
936}
937
d5979e4a
DG
938/*
939 * Remove an UST channel from a channel HT.
940 */
941void trace_ust_delete_channel(struct lttng_ht *ht,
942 struct ltt_ust_channel *channel)
943{
944 int ret;
945 struct lttng_ht_iter iter;
946
947 assert(ht);
948 assert(channel);
949
950 iter.iter.node = &channel->node.node;
951 ret = lttng_ht_del(ht, &iter);
952 assert(!ret);
953}
954
97ee3a89 955/*
f6a9efaa 956 * Iterate over a hash table containing channels and cleanup safely.
97ee3a89 957 */
bec39940 958static void destroy_channels(struct lttng_ht *channels)
f6a9efaa
DG
959{
960 int ret;
bec39940
DG
961 struct lttng_ht_node_str *node;
962 struct lttng_ht_iter iter;
f6a9efaa 963
0525e9ae
DG
964 assert(channels);
965
24d1723f
DG
966 rcu_read_lock();
967
bec39940
DG
968 cds_lfht_for_each_entry(channels->ht, &iter.iter, node, node) {
969 ret = lttng_ht_del(channels, &iter);
7bd39047
DG
970 assert(!ret);
971 call_rcu(&node->head, destroy_channel_rcu);
f6a9efaa 972 }
36b588ed 973 rcu_read_unlock();
ed52805d 974
0b2dc8df 975 ht_cleanup_push(channels);
f6a9efaa
DG
976}
977
f6a9efaa
DG
978/*
979 * Cleanup UST global domain.
980 */
981static void destroy_domain_global(struct ltt_ust_domain_global *dom)
982{
0525e9ae
DG
983 assert(dom);
984
f6a9efaa
DG
985 destroy_channels(dom->channels);
986}
97ee3a89 987
f6a9efaa
DG
988/*
989 * Cleanup ust session structure
36b588ed
MD
990 *
991 * Should *NOT* be called with RCU read-side lock held.
f6a9efaa
DG
992 */
993void trace_ust_destroy_session(struct ltt_ust_session *session)
994{
fefd409b 995 struct agent *agt;
7972aab2 996 struct buffer_reg_uid *reg, *sreg;
fefd409b 997 struct lttng_ht_iter iter;
7972aab2 998
0525e9ae 999 assert(session);
97ee3a89 1000
d9bf3ca4 1001 DBG2("Trace UST destroy session %" PRIu64, session->id);
f6a9efaa 1002
f6a9efaa
DG
1003 /* Cleaning up UST domain */
1004 destroy_domain_global(&session->domain_global);
fefd409b 1005
0c0fcd77 1006 rcu_read_lock();
fefd409b 1007 cds_lfht_for_each_entry(session->agents->ht, &iter.iter, agt, node.node) {
d0edf546
JG
1008 int ret = lttng_ht_del(session->agents, &iter);
1009
1010 assert(!ret);
fefd409b
DG
1011 agent_destroy(agt);
1012 }
0c0fcd77 1013 rcu_read_unlock();
7972aab2 1014
8ada2175
MD
1015 ht_cleanup_push(session->agents);
1016
7972aab2
DG
1017 /* Cleanup UID buffer registry object(s). */
1018 cds_list_for_each_entry_safe(reg, sreg, &session->buffer_reg_uid_list,
1019 lnode) {
1020 cds_list_del(&reg->lnode);
1021 buffer_reg_uid_remove(reg);
1022 buffer_reg_uid_destroy(reg, session->consumer);
1023 }
44d3bd01 1024
3f8e211f
DG
1025 consumer_destroy_output(session->consumer);
1026 consumer_destroy_output(session->tmp_consumer);
1027
a9ad0c8f
MD
1028 fini_pid_tracker(&session->pid_tracker);
1029
97ee3a89
DG
1030 free(session);
1031}
This page took 0.156551 seconds and 4 git commands to generate.