2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
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.
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.
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.
21 #include <urcu/list.h>
24 #include <lttng/lttng.h>
25 #include <common/error.h>
26 #include <common/sessiond-comm/sessiond-comm.h>
31 #include "lttng-sessiond.h"
34 #include "trace-kernel.h"
35 #include "trace-ust.h"
39 * Add unique UST event based on the event name, filter bytecode and loglevel.
41 static void add_unique_ust_event(struct lttng_ht
*ht
,
42 struct ltt_ust_event
*event
)
44 struct cds_lfht_node
*node_ptr
;
45 struct ltt_ust_ht_key key
;
51 key
.name
= event
->attr
.name
;
52 key
.filter
= (struct lttng_filter_bytecode
*) event
->filter
;
53 key
.loglevel
= event
->attr
.loglevel
;
54 key
.exclusion
= event
->exclusion
;
56 node_ptr
= cds_lfht_add_unique(ht
->ht
,
57 ht
->hash_fct(event
->node
.key
, lttng_ht_seed
),
58 trace_ust_ht_match_event
, &key
, &event
->node
.node
);
59 assert(node_ptr
== &event
->node
.node
);
63 * Disable kernel tracepoint event for a channel from the kernel session.
65 int event_kernel_disable_event(struct ltt_kernel_channel
*kchan
,
69 struct ltt_kernel_event
*kevent
;
73 kevent
= trace_kernel_get_event_by_name(event_name
, kchan
,
76 ret
= LTTNG_ERR_NO_EVENT
;
80 ret
= kernel_disable_event(kevent
);
82 ret
= LTTNG_ERR_KERN_DISABLE_FAIL
;
86 DBG("Kernel event %s disable for channel %s.",
87 kevent
->event
->name
, kchan
->channel
->name
);
96 * Disable kernel tracepoint events for a channel from the kernel session.
98 int event_kernel_disable_event_type(struct ltt_kernel_channel
*kchan
,
99 enum lttng_event_type type
)
102 struct ltt_kernel_event
*kevent
;
106 /* For each event in the kernel session */
107 cds_list_for_each_entry(kevent
, &kchan
->events_list
.head
, list
) {
108 if (type
!= LTTNG_EVENT_ALL
&& kevent
->type
!= type
)
110 ret
= kernel_disable_event(kevent
);
112 /* We continue disabling the rest */
121 * Disable all kernel event for a channel from the kernel session.
123 int event_kernel_disable_event_all(struct ltt_kernel_channel
*kchan
)
125 return event_kernel_disable_event_type(kchan
, LTTNG_EVENT_ALL
);
129 * Enable kernel tracepoint event for a channel from the kernel session.
130 * We own filter_expression and filter.
132 int event_kernel_enable_event(struct ltt_kernel_channel
*kchan
,
133 struct lttng_event
*event
, char *filter_expression
,
134 struct lttng_filter_bytecode
*filter
)
137 struct ltt_kernel_event
*kevent
;
142 kevent
= trace_kernel_find_event(event
->name
, kchan
,
143 event
->type
, filter
);
144 if (kevent
== NULL
) {
145 ret
= kernel_create_event(event
, kchan
,
146 filter_expression
, filter
);
147 /* We have passed ownership */
148 filter_expression
= NULL
;
153 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
156 ret
= LTTNG_ERR_KERN_EVENT_ENOSYS
;
159 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
164 } else if (kevent
->enabled
== 0) {
165 ret
= kernel_enable_event(kevent
);
167 ret
= LTTNG_ERR_KERN_ENABLE_FAIL
;
171 /* At this point, the event is considered enabled */
172 ret
= LTTNG_ERR_KERN_EVENT_EXIST
;
178 free(filter_expression
);
184 * ============================
185 * UST : The Ultimate Frontier!
186 * ============================
190 * Enable UST tracepoint event for a channel from a UST session.
191 * We own filter_expression, filter, and exclusion.
193 int event_ust_enable_tracepoint(struct ltt_ust_session
*usess
,
194 struct ltt_ust_channel
*uchan
, struct lttng_event
*event
,
195 char *filter_expression
,
196 struct lttng_filter_bytecode
*filter
,
197 struct lttng_event_exclusion
*exclusion
)
199 int ret
= LTTNG_OK
, to_create
= 0;
200 struct ltt_ust_event
*uevent
;
208 uevent
= trace_ust_find_event(uchan
->events
, event
->name
, filter
,
209 event
->loglevel
, exclusion
);
210 if (uevent
== NULL
) {
211 uevent
= trace_ust_create_event(event
, filter_expression
,
213 /* We have passed ownership */
214 filter_expression
= NULL
;
217 if (uevent
== NULL
) {
218 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
222 /* Valid to set it after the goto error since uevent is still NULL */
226 if (uevent
->enabled
) {
227 /* It's already enabled so everything is OK */
228 ret
= LTTNG_ERR_UST_EVENT_ENABLED
;
235 /* Create event on all UST registered apps for session */
236 ret
= ust_app_create_event_glb(usess
, uchan
, uevent
);
238 /* Enable event on all UST registered apps for session */
239 ret
= ust_app_enable_event_glb(usess
, uchan
, uevent
);
243 if (ret
== -LTTNG_UST_ERR_EXIST
) {
244 ret
= LTTNG_ERR_UST_EVENT_EXIST
;
247 ret
= LTTNG_ERR_UST_ENABLE_FAIL
;
253 /* Add ltt ust event to channel */
254 add_unique_ust_event(uchan
->events
, uevent
);
257 DBG("Event UST %s %s in channel %s", uevent
->attr
.name
,
258 to_create
? "created" : "enabled", uchan
->name
);
264 free(filter_expression
);
271 * Only destroy event on creation time (not enabling time) because if the
272 * event is found in the channel (to_create == 0), it means that at some
273 * point the enable_event worked and it's thus valid to keep it alive.
274 * Destroying it also implies that we also destroy it's shadow copy to sync
278 /* In this code path, the uevent was not added to the hash table */
279 trace_ust_destroy_event(uevent
);
282 free(filter_expression
);
289 * Disable UST tracepoint of a channel from a UST session.
291 int event_ust_disable_tracepoint(struct ltt_ust_session
*usess
,
292 struct ltt_ust_channel
*uchan
, char *event_name
)
295 struct ltt_ust_event
*uevent
;
296 struct lttng_ht_node_str
*node
;
297 struct lttng_ht_iter iter
;
309 * We use a custom lookup since we need the iterator for the next_duplicate
310 * call in the do while loop below.
312 cds_lfht_lookup(ht
->ht
, ht
->hash_fct((void *) event_name
, lttng_ht_seed
),
313 trace_ust_ht_match_event_by_name
, event_name
, &iter
.iter
);
314 node
= lttng_ht_iter_get_node_str(&iter
);
316 DBG2("Trace UST event NOT found by name %s", event_name
);
317 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
322 uevent
= caa_container_of(node
, struct ltt_ust_event
, node
);
325 if (uevent
->enabled
== 0) {
326 /* It's already disabled so everything is OK */
330 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
331 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
332 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
337 DBG2("Event UST %s disabled in channel %s", uevent
->attr
.name
,
341 /* Get next duplicate event by name. */
342 cds_lfht_next_duplicate(ht
->ht
, trace_ust_ht_match_event_by_name
,
343 event_name
, &iter
.iter
);
344 node
= lttng_ht_iter_get_node_str(&iter
);
355 * Enable all agent event for a given UST session.
357 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
359 int event_agent_enable_all(struct ltt_ust_session
*usess
,
360 struct agent
*agt
, struct lttng_event
*event
,
361 struct lttng_filter_bytecode
*filter
)
364 struct agent_event
*aevent
;
365 struct lttng_ht_iter iter
;
369 DBG("Event agent enabling ALL events for session %" PRIu64
, usess
->id
);
371 /* Enable event on agent application through TCP socket. */
372 ret
= event_agent_enable(usess
, agt
, event
, filter
);
373 if (ret
!= LTTNG_OK
) {
377 /* Flag every event that they are now enabled. */
379 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
392 * Enable a single agent event for a given UST session.
394 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
396 int event_agent_enable(struct ltt_ust_session
*usess
,
397 struct agent
*agt
, struct lttng_event
*event
,
398 struct lttng_filter_bytecode
*filter
)
400 int ret
, created
= 0;
401 struct agent_event
*aevent
;
407 DBG("Event agent enabling %s for session %" PRIu64
" with loglevel type %d "
408 "and loglevel %d", event
->name
, usess
->id
, event
->loglevel_type
,
411 aevent
= agent_find_event(event
->name
, event
->loglevel
, agt
);
413 aevent
= agent_create_event(event
->name
, filter
);
415 ret
= LTTNG_ERR_NOMEM
;
418 aevent
->loglevel
= event
->loglevel
;
419 aevent
->loglevel_type
= event
->loglevel_type
;
423 /* Already enabled? */
424 if (aevent
->enabled
) {
428 ret
= agent_enable_event(aevent
, agt
->domain
);
429 if (ret
!= LTTNG_OK
) {
433 /* If the event was created prior to the enable, add it to the domain. */
435 agent_add_event(aevent
, agt
);
443 agent_destroy_event(aevent
);
449 * Return the default event name associated with the provided UST domain. Return
452 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain
)
454 const char *default_event_name
= NULL
;
457 case LTTNG_DOMAIN_LOG4J
:
458 default_event_name
= DEFAULT_LOG4J_EVENT_NAME
;
460 case LTTNG_DOMAIN_JUL
:
461 default_event_name
= DEFAULT_JUL_EVENT_NAME
;
463 case LTTNG_DOMAIN_PYTHON
:
464 default_event_name
= DEFAULT_PYTHON_EVENT_NAME
;
470 return default_event_name
;
474 * Disable a single agent event for a given UST session.
476 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
478 int event_agent_disable(struct ltt_ust_session
*usess
, struct agent
*agt
,
482 struct agent_event
*aevent
;
483 struct ltt_ust_event
*uevent
= NULL
;
484 struct ltt_ust_channel
*uchan
= NULL
;
485 const char *ust_event_name
, *ust_channel_name
;
491 DBG("Event agent disabling %s for session %" PRIu64
, event_name
, usess
->id
);
493 aevent
= agent_find_event_by_name(event_name
, agt
);
495 ret
= LTTNG_ERR_UST_EVENT_NOT_FOUND
;
499 /* Already disabled? */
500 if (!aevent
->enabled
) {
504 if (agt
->domain
== LTTNG_DOMAIN_JUL
) {
505 ust_channel_name
= DEFAULT_JUL_CHANNEL_NAME
;
506 } else if (agt
->domain
== LTTNG_DOMAIN_LOG4J
) {
507 ust_channel_name
= DEFAULT_LOG4J_CHANNEL_NAME
;
508 } else if (agt
->domain
== LTTNG_DOMAIN_PYTHON
) {
509 ust_channel_name
= DEFAULT_PYTHON_CHANNEL_NAME
;
511 ret
= LTTNG_ERR_INVALID
;
516 * Disable it on the UST side. First get the channel reference then find
517 * the event and finally disable it.
519 uchan
= trace_ust_find_channel_by_name(usess
->domain_global
.channels
,
520 (char *) ust_channel_name
);
522 ret
= LTTNG_ERR_UST_CHAN_NOT_FOUND
;
526 ust_event_name
= event_get_default_agent_ust_name(agt
->domain
);
527 if (!ust_event_name
) {
528 ret
= LTTNG_ERR_FATAL
;
533 * The loglevel is hardcoded with 0 here since the agent ust event is set
534 * with the loglevel type to ALL thus the loglevel stays 0. The event's
535 * filter is the one handling the loglevel for agent.
537 uevent
= trace_ust_find_event(uchan
->events
, (char *) ust_event_name
,
538 aevent
->filter
, 0, NULL
);
539 /* If the agent event exists, it must be available on the UST side. */
542 ret
= ust_app_disable_event_glb(usess
, uchan
, uevent
);
543 if (ret
< 0 && ret
!= -LTTNG_UST_ERR_EXIST
) {
544 ret
= LTTNG_ERR_UST_DISABLE_FAIL
;
549 * Flag event that it's disabled so the shadow copy on the ust app side
550 * will disable it if an application shows up.
554 ret
= agent_disable_event(aevent
, agt
->domain
);
555 if (ret
!= LTTNG_OK
) {
566 * Disable all agent event for a given UST session.
568 * Return LTTNG_OK on success or else a LTTNG_ERR* code.
570 int event_agent_disable_all(struct ltt_ust_session
*usess
,
574 struct agent_event
*aevent
;
575 struct lttng_ht_iter iter
;
581 * Disable event on agent application. Continue to disable all other events
582 * if the * event is not found.
584 ret
= event_agent_disable(usess
, agt
, "*");
585 if (ret
!= LTTNG_OK
&& ret
!= LTTNG_ERR_UST_EVENT_NOT_FOUND
) {
589 /* Flag every event that they are now enabled. */
591 cds_lfht_for_each_entry(agt
->events
->ht
, &iter
.iter
, aevent
,
593 if (!aevent
->enabled
) {
597 ret
= event_agent_disable(usess
, agt
, aevent
->name
);
598 if (ret
!= LTTNG_OK
) {