Commit | Line | Data |
---|---|---|
54d01ffb 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. | |
54d01ffb | 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. | |
54d01ffb | 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. | |
54d01ffb DG |
16 | */ |
17 | ||
be040666 | 18 | #define _GNU_SOURCE |
d87bfb32 | 19 | #include <errno.h> |
54d01ffb | 20 | #include <urcu/list.h> |
2bdd86d4 | 21 | #include <string.h> |
54d01ffb DG |
22 | |
23 | #include <lttng/lttng.h> | |
db758600 | 24 | #include <common/error.h> |
10a8a223 | 25 | #include <common/sessiond-comm/sessiond-comm.h> |
54d01ffb DG |
26 | |
27 | #include "channel.h" | |
28 | #include "event.h" | |
4771f025 | 29 | #include "kernel.h" |
7923a38c | 30 | #include "lttng-sessiond.h" |
9df8df5e | 31 | #include "ust-ctl.h" |
edb67388 DG |
32 | #include "ust-app.h" |
33 | #include "trace-kernel.h" | |
34 | #include "trace-ust.h" | |
54d01ffb | 35 | |
025faf73 DG |
36 | /* |
37 | * Add unique UST event based on the event name, filter bytecode and loglevel. | |
38 | */ | |
18eace3b DG |
39 | static void add_unique_ust_event(struct lttng_ht *ht, |
40 | struct ltt_ust_event *event) | |
41 | { | |
42 | struct cds_lfht_node *node_ptr; | |
43 | struct ltt_ust_ht_key key; | |
44 | ||
45 | assert(ht); | |
46 | assert(ht->ht); | |
47 | assert(event); | |
48 | ||
49 | key.name = event->attr.name; | |
50 | key.filter = (struct lttng_filter_bytecode *) event->filter; | |
51 | key.loglevel = event->attr.loglevel; | |
4031e53e | 52 | key.exclusion = event->exclusion; |
18eace3b DG |
53 | |
54 | node_ptr = cds_lfht_add_unique(ht->ht, | |
55 | ht->hash_fct(event->node.key, lttng_ht_seed), | |
56 | trace_ust_ht_match_event, &key, &event->node.node); | |
57 | assert(node_ptr == &event->node.node); | |
58 | } | |
59 | ||
8c9ae521 DG |
60 | /* |
61 | * Setup a lttng_event used to enable *all* syscall tracing. | |
62 | */ | |
63 | static void init_syscalls_kernel_event(struct lttng_event *event) | |
64 | { | |
0525e9ae DG |
65 | assert(event); |
66 | ||
8c9ae521 DG |
67 | event->name[0] = '\0'; |
68 | /* | |
69 | * We use LTTNG_EVENT* here since the trace kernel creation will make the | |
70 | * right changes for the kernel. | |
71 | */ | |
72 | event->type = LTTNG_EVENT_SYSCALL; | |
73 | } | |
74 | ||
54d01ffb | 75 | /* |
7a3d1328 | 76 | * Disable kernel tracepoint event for a channel from the kernel session. |
54d01ffb | 77 | */ |
d3a56674 DG |
78 | int event_kernel_disable_tracepoint(struct ltt_kernel_channel *kchan, |
79 | char *event_name) | |
54d01ffb DG |
80 | { |
81 | int ret; | |
82 | struct ltt_kernel_event *kevent; | |
83 | ||
0525e9ae DG |
84 | assert(kchan); |
85 | ||
54d01ffb DG |
86 | kevent = trace_kernel_get_event_by_name(event_name, kchan); |
87 | if (kevent == NULL) { | |
f73fabfd | 88 | ret = LTTNG_ERR_NO_EVENT; |
54d01ffb DG |
89 | goto error; |
90 | } | |
91 | ||
92 | ret = kernel_disable_event(kevent); | |
93 | if (ret < 0) { | |
f73fabfd | 94 | ret = LTTNG_ERR_KERN_DISABLE_FAIL; |
54d01ffb DG |
95 | goto error; |
96 | } | |
97 | ||
98 | DBG("Kernel event %s disable for channel %s.", | |
99 | kevent->event->name, kchan->channel->name); | |
100 | ||
f73fabfd | 101 | ret = LTTNG_OK; |
54d01ffb DG |
102 | |
103 | error: | |
104 | return ret; | |
105 | } | |
106 | ||
107 | /* | |
7a3d1328 | 108 | * Disable kernel tracepoint events for a channel from the kernel session. |
54d01ffb | 109 | */ |
d3a56674 | 110 | int event_kernel_disable_all_tracepoints(struct ltt_kernel_channel *kchan) |
54d01ffb DG |
111 | { |
112 | int ret; | |
113 | struct ltt_kernel_event *kevent; | |
114 | ||
0525e9ae DG |
115 | assert(kchan); |
116 | ||
54d01ffb DG |
117 | /* For each event in the kernel session */ |
118 | cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { | |
119 | ret = kernel_disable_event(kevent); | |
120 | if (ret < 0) { | |
121 | /* We continue disabling the rest */ | |
122 | continue; | |
123 | } | |
124 | } | |
f73fabfd | 125 | ret = LTTNG_OK; |
7a3d1328 MD |
126 | return ret; |
127 | } | |
128 | ||
129 | /* | |
130 | * Disable kernel syscall events for a channel from the kernel session. | |
131 | */ | |
d3a56674 | 132 | int event_kernel_disable_all_syscalls(struct ltt_kernel_channel *kchan) |
7a3d1328 MD |
133 | { |
134 | ERR("Cannot disable syscall tracing for existing session. Please destroy session instead."); | |
f73fabfd | 135 | return LTTNG_OK; /* Return OK so disable all succeeds */ |
7a3d1328 | 136 | } |
54d01ffb | 137 | |
7a3d1328 MD |
138 | /* |
139 | * Disable all kernel event for a channel from the kernel session. | |
140 | */ | |
d3a56674 | 141 | int event_kernel_disable_all(struct ltt_kernel_channel *kchan) |
7a3d1328 MD |
142 | { |
143 | int ret; | |
144 | ||
0525e9ae DG |
145 | assert(kchan); |
146 | ||
d3a56674 | 147 | ret = event_kernel_disable_all_tracepoints(kchan); |
f73fabfd | 148 | if (ret != LTTNG_OK) |
7a3d1328 | 149 | return ret; |
d3a56674 | 150 | ret = event_kernel_disable_all_syscalls(kchan); |
54d01ffb DG |
151 | return ret; |
152 | } | |
153 | ||
154 | /* | |
7a3d1328 | 155 | * Enable kernel tracepoint event for a channel from the kernel session. |
7ea8750c | 156 | * We own filter_expression and filter. |
54d01ffb | 157 | */ |
d3a56674 DG |
158 | int event_kernel_enable_tracepoint(struct ltt_kernel_channel *kchan, |
159 | struct lttng_event *event) | |
54d01ffb DG |
160 | { |
161 | int ret; | |
162 | struct ltt_kernel_event *kevent; | |
163 | ||
0525e9ae DG |
164 | assert(kchan); |
165 | assert(event); | |
166 | ||
54d01ffb DG |
167 | kevent = trace_kernel_get_event_by_name(event->name, kchan); |
168 | if (kevent == NULL) { | |
169 | ret = kernel_create_event(event, kchan); | |
170 | if (ret < 0) { | |
bd29c13d DG |
171 | switch (-ret) { |
172 | case EEXIST: | |
f73fabfd | 173 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
bd29c13d DG |
174 | break; |
175 | case ENOSYS: | |
f73fabfd | 176 | ret = LTTNG_ERR_KERN_EVENT_ENOSYS; |
bd29c13d DG |
177 | break; |
178 | default: | |
f73fabfd | 179 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
bd29c13d | 180 | break; |
d87bfb32 | 181 | } |
7a3d1328 | 182 | goto end; |
54d01ffb DG |
183 | } |
184 | } else if (kevent->enabled == 0) { | |
185 | ret = kernel_enable_event(kevent); | |
186 | if (ret < 0) { | |
f73fabfd | 187 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
7a3d1328 | 188 | goto end; |
54d01ffb | 189 | } |
42224349 DG |
190 | } else { |
191 | /* At this point, the event is considered enabled */ | |
f73fabfd | 192 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
42224349 | 193 | goto end; |
54d01ffb | 194 | } |
42224349 | 195 | |
f73fabfd | 196 | ret = LTTNG_OK; |
7a3d1328 | 197 | end: |
54d01ffb DG |
198 | return ret; |
199 | } | |
200 | ||
201 | /* | |
7a3d1328 | 202 | * Enable all kernel tracepoint events of a channel of the kernel session. |
54d01ffb | 203 | */ |
d3a56674 DG |
204 | int event_kernel_enable_all_tracepoints(struct ltt_kernel_channel *kchan, |
205 | int kernel_tracer_fd) | |
54d01ffb DG |
206 | { |
207 | int size, i, ret; | |
208 | struct ltt_kernel_event *kevent; | |
8f69e5eb | 209 | struct lttng_event *event_list = NULL; |
54d01ffb | 210 | |
0525e9ae DG |
211 | assert(kchan); |
212 | ||
54d01ffb DG |
213 | /* For each event in the kernel session */ |
214 | cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { | |
8f69e5eb DG |
215 | if (kevent->enabled == 0) { |
216 | ret = kernel_enable_event(kevent); | |
217 | if (ret < 0) { | |
218 | /* Enable failed but still continue */ | |
219 | continue; | |
220 | } | |
54d01ffb DG |
221 | } |
222 | } | |
223 | ||
224 | size = kernel_list_events(kernel_tracer_fd, &event_list); | |
225 | if (size < 0) { | |
f73fabfd | 226 | ret = LTTNG_ERR_KERN_LIST_FAIL; |
7a3d1328 | 227 | goto end; |
54d01ffb DG |
228 | } |
229 | ||
230 | for (i = 0; i < size; i++) { | |
231 | kevent = trace_kernel_get_event_by_name(event_list[i].name, kchan); | |
232 | if (kevent == NULL) { | |
233 | /* Default event type for enable all */ | |
234 | event_list[i].type = LTTNG_EVENT_TRACEPOINT; | |
235 | /* Enable each single tracepoint event */ | |
236 | ret = kernel_create_event(&event_list[i], kchan); | |
237 | if (ret < 0) { | |
238 | /* Ignore error here and continue */ | |
239 | } | |
240 | } | |
241 | } | |
54d01ffb | 242 | free(event_list); |
8f69e5eb | 243 | |
f73fabfd | 244 | ret = LTTNG_OK; |
7a3d1328 | 245 | end: |
54d01ffb DG |
246 | return ret; |
247 | } | |
8c9ae521 DG |
248 | |
249 | /* | |
8b037137 | 250 | * Enable all kernel sycalls events of a channel of the kernel session. |
8c9ae521 | 251 | */ |
d3a56674 DG |
252 | int event_kernel_enable_all_syscalls(struct ltt_kernel_channel *kchan, |
253 | int kernel_tracer_fd) | |
8c9ae521 DG |
254 | { |
255 | int ret; | |
256 | struct lttng_event event; | |
257 | ||
0525e9ae DG |
258 | assert(kchan); |
259 | ||
8c9ae521 DG |
260 | init_syscalls_kernel_event(&event); |
261 | ||
262 | DBG("Enabling all syscall tracing"); | |
263 | ||
264 | ret = kernel_create_event(&event, kchan); | |
265 | if (ret < 0) { | |
8f69e5eb | 266 | if (ret == -EEXIST) { |
f73fabfd | 267 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
8f69e5eb | 268 | } else { |
f73fabfd | 269 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
8f69e5eb | 270 | } |
7a3d1328 | 271 | goto end; |
8c9ae521 | 272 | } |
8f69e5eb | 273 | |
f73fabfd | 274 | ret = LTTNG_OK; |
7a3d1328 MD |
275 | end: |
276 | return ret; | |
277 | } | |
8c9ae521 | 278 | |
7a3d1328 MD |
279 | /* |
280 | * Enable all kernel events of a channel of the kernel session. | |
281 | */ | |
d3a56674 DG |
282 | int event_kernel_enable_all(struct ltt_kernel_channel *kchan, |
283 | int kernel_tracer_fd) | |
7a3d1328 | 284 | { |
6bd8707a | 285 | int tp_ret; |
7a3d1328 | 286 | |
0525e9ae DG |
287 | assert(kchan); |
288 | ||
d3a56674 | 289 | tp_ret = event_kernel_enable_all_tracepoints(kchan, kernel_tracer_fd); |
f73fabfd | 290 | if (tp_ret != LTTNG_OK) { |
7a3d1328 MD |
291 | goto end; |
292 | } | |
bd29c13d DG |
293 | |
294 | /* | |
295 | * Reaching this code path means that all tracepoints were enabled without | |
296 | * errors so we ignore the error value of syscalls. | |
297 | * | |
298 | * At the moment, failing to enable syscalls on "lttng enable-event -a -k" | |
299 | * is not considered an error that need to be returned to the client since | |
300 | * tracepoints did not fail. Future work will allow us to send back | |
301 | * multiple errors to the client in one API call. | |
302 | */ | |
d3a56674 | 303 | (void) event_kernel_enable_all_syscalls(kchan, kernel_tracer_fd); |
bd29c13d | 304 | |
7a3d1328 | 305 | end: |
bd29c13d | 306 | return tp_ret; |
8c9ae521 | 307 | } |
2bdd86d4 | 308 | |
7f79d3a1 DG |
309 | /* |
310 | * ============================ | |
311 | * UST : The Ultimate Frontier! | |
312 | * ============================ | |
313 | */ | |
314 | ||
76d45b40 DG |
315 | /* |
316 | * Enable all UST tracepoints for a channel from a UST session. | |
317 | */ | |
7972aab2 | 318 | int event_ust_enable_all_tracepoints(struct ltt_ust_session *usess, |
6b453b5e JG |
319 | struct ltt_ust_channel *uchan, |
320 | char *filter_expression, | |
321 | struct lttng_filter_bytecode *filter) | |
76d45b40 | 322 | { |
6775595e | 323 | int ret, i, size; |
bec39940 | 324 | struct lttng_ht_iter iter; |
76d45b40 | 325 | struct ltt_ust_event *uevent = NULL; |
7f79d3a1 | 326 | struct lttng_event *events = NULL; |
76d45b40 | 327 | |
0525e9ae DG |
328 | assert(usess); |
329 | assert(uchan); | |
330 | ||
025faf73 DG |
331 | rcu_read_lock(); |
332 | ||
7972aab2 DG |
333 | /* Enable existing events */ |
334 | cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, | |
335 | node.node) { | |
336 | if (uevent->enabled == 0) { | |
337 | ret = ust_app_enable_event_glb(usess, uchan, uevent); | |
338 | if (ret < 0) { | |
76d45b40 DG |
339 | continue; |
340 | } | |
7972aab2 DG |
341 | uevent->enabled = 1; |
342 | } | |
343 | } | |
76d45b40 | 344 | |
7972aab2 DG |
345 | /* Get all UST available events */ |
346 | size = ust_app_list_events(&events); | |
347 | if (size < 0) { | |
348 | ret = LTTNG_ERR_UST_LIST_FAIL; | |
349 | goto error; | |
350 | } | |
76d45b40 | 351 | |
7972aab2 DG |
352 | for (i = 0; i < size; i++) { |
353 | /* | |
354 | * Check if event exist and if so, continue since it was enable | |
355 | * previously. | |
356 | */ | |
357 | uevent = trace_ust_find_event(uchan->events, events[i].name, filter, | |
10646003 | 358 | events[i].loglevel, NULL); |
7972aab2 | 359 | if (uevent != NULL) { |
76d45b40 DG |
360 | ret = ust_app_enable_event_pid(usess, uchan, uevent, |
361 | events[i].pid); | |
362 | if (ret < 0) { | |
7972aab2 | 363 | if (ret != -LTTNG_UST_ERR_EXIST) { |
f73fabfd | 364 | ret = LTTNG_ERR_UST_ENABLE_FAIL; |
7972aab2 | 365 | goto error; |
76d45b40 | 366 | } |
76d45b40 | 367 | } |
7972aab2 DG |
368 | continue; |
369 | } | |
76d45b40 | 370 | |
7972aab2 | 371 | /* Create ust event */ |
6b453b5e JG |
372 | uevent = trace_ust_create_event(&events[i], filter_expression, |
373 | filter, NULL); | |
7972aab2 DG |
374 | if (uevent == NULL) { |
375 | ret = LTTNG_ERR_FATAL; | |
376 | goto error_destroy; | |
76d45b40 DG |
377 | } |
378 | ||
7972aab2 DG |
379 | /* Create event for the specific PID */ |
380 | ret = ust_app_enable_event_pid(usess, uchan, uevent, | |
381 | events[i].pid); | |
382 | if (ret < 0) { | |
383 | if (ret == -LTTNG_UST_ERR_EXIST) { | |
384 | ret = LTTNG_ERR_UST_EVENT_EXIST; | |
385 | goto error; | |
386 | } else { | |
387 | ret = LTTNG_ERR_UST_ENABLE_FAIL; | |
388 | goto error_destroy; | |
389 | } | |
390 | } | |
391 | ||
392 | uevent->enabled = 1; | |
393 | /* Add ltt ust event to channel */ | |
394 | rcu_read_lock(); | |
395 | add_unique_ust_event(uchan->events, uevent); | |
396 | rcu_read_unlock(); | |
76d45b40 | 397 | } |
7972aab2 | 398 | free(events); |
76d45b40 | 399 | |
025faf73 | 400 | rcu_read_unlock(); |
f73fabfd | 401 | return LTTNG_OK; |
76d45b40 | 402 | |
7f79d3a1 | 403 | error_destroy: |
76d45b40 | 404 | trace_ust_destroy_event(uevent); |
7f79d3a1 DG |
405 | |
406 | error: | |
407 | free(events); | |
025faf73 | 408 | rcu_read_unlock(); |
76d45b40 DG |
409 | return ret; |
410 | } | |
411 | ||
2bdd86d4 MD |
412 | /* |
413 | * Enable UST tracepoint event for a channel from a UST session. | |
7ea8750c | 414 | * We own filter_expression, filter, and exclusion. |
2bdd86d4 | 415 | */ |
7972aab2 | 416 | int event_ust_enable_tracepoint(struct ltt_ust_session *usess, |
025faf73 | 417 | struct ltt_ust_channel *uchan, struct lttng_event *event, |
6b453b5e | 418 | char *filter_expression, |
f1613f52 JI |
419 | struct lttng_filter_bytecode *filter, |
420 | struct lttng_event_exclusion *exclusion) | |
2bdd86d4 | 421 | { |
f73fabfd | 422 | int ret = LTTNG_OK, to_create = 0; |
edb67388 DG |
423 | struct ltt_ust_event *uevent; |
424 | ||
0525e9ae DG |
425 | assert(usess); |
426 | assert(uchan); | |
427 | assert(event); | |
428 | ||
18eace3b DG |
429 | rcu_read_lock(); |
430 | ||
025faf73 | 431 | uevent = trace_ust_find_event(uchan->events, event->name, filter, |
10646003 | 432 | event->loglevel, exclusion); |
edb67388 | 433 | if (uevent == NULL) { |
6b453b5e JG |
434 | uevent = trace_ust_create_event(event, filter_expression, |
435 | filter, exclusion); | |
7ea8750c MD |
436 | /* We have passed ownership */ |
437 | filter_expression = NULL; | |
438 | filter = NULL; | |
439 | exclusion = NULL; | |
edb67388 | 440 | if (uevent == NULL) { |
95a82664 | 441 | ret = LTTNG_ERR_UST_ENABLE_FAIL; |
edb67388 DG |
442 | goto error; |
443 | } | |
025faf73 | 444 | |
fc34caaa | 445 | /* Valid to set it after the goto error since uevent is still NULL */ |
edb67388 DG |
446 | to_create = 1; |
447 | } | |
2bdd86d4 | 448 | |
7f79d3a1 DG |
449 | if (uevent->enabled) { |
450 | /* It's already enabled so everything is OK */ | |
5bcdda4f | 451 | ret = LTTNG_ERR_UST_EVENT_ENABLED; |
7f79d3a1 DG |
452 | goto end; |
453 | } | |
454 | ||
fc34caaa DG |
455 | uevent->enabled = 1; |
456 | ||
7972aab2 DG |
457 | if (to_create) { |
458 | /* Create event on all UST registered apps for session */ | |
459 | ret = ust_app_create_event_glb(usess, uchan, uevent); | |
460 | } else { | |
461 | /* Enable event on all UST registered apps for session */ | |
462 | ret = ust_app_enable_event_glb(usess, uchan, uevent); | |
463 | } | |
48842b30 | 464 | |
7972aab2 DG |
465 | if (ret < 0) { |
466 | if (ret == -LTTNG_UST_ERR_EXIST) { | |
467 | ret = LTTNG_ERR_UST_EVENT_EXIST; | |
468 | goto end; | |
469 | } else { | |
470 | ret = LTTNG_ERR_UST_ENABLE_FAIL; | |
471 | goto error; | |
edb67388 | 472 | } |
2bdd86d4 | 473 | } |
48842b30 | 474 | |
7f79d3a1 | 475 | if (to_create) { |
fc34caaa | 476 | /* Add ltt ust event to channel */ |
18eace3b | 477 | add_unique_ust_event(uchan->events, uevent); |
7f79d3a1 | 478 | } |
edb67388 | 479 | |
7f79d3a1 DG |
480 | DBG("Event UST %s %s in channel %s", uevent->attr.name, |
481 | to_create ? "created" : "enabled", uchan->name); | |
482 | ||
f73fabfd | 483 | ret = LTTNG_OK; |
fc34caaa | 484 | |
fb89d070 | 485 | end: |
18eace3b | 486 | rcu_read_unlock(); |
7ea8750c MD |
487 | free(filter_expression); |
488 | free(filter); | |
489 | free(exclusion); | |
fc34caaa | 490 | return ret; |
edb67388 DG |
491 | |
492 | error: | |
fc34caaa DG |
493 | /* |
494 | * Only destroy event on creation time (not enabling time) because if the | |
495 | * event is found in the channel (to_create == 0), it means that at some | |
496 | * point the enable_event worked and it's thus valid to keep it alive. | |
497 | * Destroying it also implies that we also destroy it's shadow copy to sync | |
498 | * everyone up. | |
499 | */ | |
500 | if (to_create) { | |
501 | /* In this code path, the uevent was not added to the hash table */ | |
502 | trace_ust_destroy_event(uevent); | |
503 | } | |
18eace3b | 504 | rcu_read_unlock(); |
7ea8750c MD |
505 | free(filter_expression); |
506 | free(filter); | |
507 | free(exclusion); | |
2bdd86d4 MD |
508 | return ret; |
509 | } | |
510 | ||
7f79d3a1 DG |
511 | /* |
512 | * Disable UST tracepoint of a channel from a UST session. | |
513 | */ | |
7972aab2 | 514 | int event_ust_disable_tracepoint(struct ltt_ust_session *usess, |
7f79d3a1 | 515 | struct ltt_ust_channel *uchan, char *event_name) |
2bdd86d4 MD |
516 | { |
517 | int ret; | |
7f79d3a1 | 518 | struct ltt_ust_event *uevent; |
18eace3b DG |
519 | struct lttng_ht_node_str *node; |
520 | struct lttng_ht_iter iter; | |
18eace3b | 521 | struct lttng_ht *ht; |
2bdd86d4 | 522 | |
0525e9ae DG |
523 | assert(usess); |
524 | assert(uchan); | |
525 | assert(event_name); | |
526 | ||
18eace3b DG |
527 | ht = uchan->events; |
528 | ||
18eace3b | 529 | rcu_read_lock(); |
025faf73 DG |
530 | |
531 | /* | |
532 | * We use a custom lookup since we need the iterator for the next_duplicate | |
533 | * call in the do while loop below. | |
534 | */ | |
535 | cds_lfht_lookup(ht->ht, ht->hash_fct((void *) event_name, lttng_ht_seed), | |
536 | trace_ust_ht_match_event_by_name, event_name, &iter.iter); | |
18eace3b DG |
537 | node = lttng_ht_iter_get_node_str(&iter); |
538 | if (node == NULL) { | |
539 | DBG2("Trace UST event NOT found by name %s", event_name); | |
f73fabfd | 540 | ret = LTTNG_ERR_UST_EVENT_NOT_FOUND; |
7f79d3a1 | 541 | goto error; |
2bdd86d4 | 542 | } |
7f79d3a1 | 543 | |
18eace3b DG |
544 | do { |
545 | uevent = caa_container_of(node, struct ltt_ust_event, node); | |
025faf73 DG |
546 | assert(uevent); |
547 | ||
18eace3b DG |
548 | if (uevent->enabled == 0) { |
549 | /* It's already disabled so everything is OK */ | |
a1dcaf0f | 550 | goto next; |
7f79d3a1 | 551 | } |
18eace3b | 552 | |
7972aab2 DG |
553 | ret = ust_app_disable_event_glb(usess, uchan, uevent); |
554 | if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) { | |
555 | ret = LTTNG_ERR_UST_DISABLE_FAIL; | |
18eace3b DG |
556 | goto error; |
557 | } | |
18eace3b DG |
558 | uevent->enabled = 0; |
559 | ||
025faf73 DG |
560 | DBG2("Event UST %s disabled in channel %s", uevent->attr.name, |
561 | uchan->name); | |
562 | ||
a1dcaf0f | 563 | next: |
18eace3b DG |
564 | /* Get next duplicate event by name. */ |
565 | cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name, | |
566 | event_name, &iter.iter); | |
567 | node = lttng_ht_iter_get_node_str(&iter); | |
568 | } while (node); | |
7f79d3a1 | 569 | |
f73fabfd | 570 | ret = LTTNG_OK; |
7f79d3a1 | 571 | |
7f79d3a1 | 572 | error: |
18eace3b | 573 | rcu_read_unlock(); |
7f79d3a1 DG |
574 | return ret; |
575 | } | |
576 | ||
577 | /* | |
578 | * Disable all UST tracepoints for a channel from a UST session. | |
579 | */ | |
7972aab2 | 580 | int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess, |
7f79d3a1 DG |
581 | struct ltt_ust_channel *uchan) |
582 | { | |
6775595e | 583 | int ret, i, size; |
bec39940 | 584 | struct lttng_ht_iter iter; |
7f79d3a1 DG |
585 | struct ltt_ust_event *uevent = NULL; |
586 | struct lttng_event *events = NULL; | |
587 | ||
0525e9ae DG |
588 | assert(usess); |
589 | assert(uchan); | |
590 | ||
025faf73 DG |
591 | rcu_read_lock(); |
592 | ||
7972aab2 DG |
593 | /* Disabling existing events */ |
594 | cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, | |
595 | node.node) { | |
596 | if (uevent->enabled == 1) { | |
597 | ret = event_ust_disable_tracepoint(usess, uchan, | |
598 | uevent->attr.name); | |
599 | if (ret < 0) { | |
7f79d3a1 DG |
600 | continue; |
601 | } | |
602 | } | |
7f79d3a1 | 603 | } |
7972aab2 DG |
604 | |
605 | /* Get all UST available events */ | |
606 | size = ust_app_list_events(&events); | |
607 | if (size < 0) { | |
608 | ret = LTTNG_ERR_UST_LIST_FAIL; | |
7f79d3a1 DG |
609 | goto error; |
610 | } | |
611 | ||
7972aab2 DG |
612 | for (i = 0; i < size; i++) { |
613 | ret = event_ust_disable_tracepoint(usess, uchan, | |
614 | events[i].name); | |
615 | if (ret != LTTNG_OK) { | |
616 | /* Continue to disable the rest... */ | |
617 | continue; | |
618 | } | |
619 | } | |
620 | free(events); | |
621 | ||
025faf73 | 622 | rcu_read_unlock(); |
f73fabfd | 623 | return LTTNG_OK; |
7f79d3a1 DG |
624 | |
625 | error: | |
626 | free(events); | |
025faf73 | 627 | rcu_read_unlock(); |
2bdd86d4 MD |
628 | return ret; |
629 | } | |
f20baf8e DG |
630 | |
631 | /* | |
632 | * Enable all JUL event for a given UST session. | |
633 | * | |
634 | * Return LTTNG_OK on success or else a LTTNG_ERR* code. | |
635 | */ | |
b2064f54 | 636 | int event_jul_enable_all(struct ltt_ust_session *usess, |
7923a38c | 637 | struct lttng_event *event, struct lttng_filter_bytecode *filter) |
f20baf8e DG |
638 | { |
639 | int ret; | |
640 | struct jul_event *jevent; | |
f20baf8e DG |
641 | struct lttng_ht_iter iter; |
642 | ||
643 | assert(usess); | |
644 | ||
645 | DBG("Event JUL enabling ALL events for session %" PRIu64, usess->id); | |
646 | ||
f20baf8e | 647 | /* Enable event on JUL application through TCP socket. */ |
7923a38c | 648 | ret = event_jul_enable(usess, event, filter); |
f20baf8e DG |
649 | if (ret != LTTNG_OK) { |
650 | goto error; | |
651 | } | |
652 | ||
653 | /* Flag every event that they are now enabled. */ | |
654 | rcu_read_lock(); | |
655 | cds_lfht_for_each_entry(usess->domain_jul.events->ht, &iter.iter, jevent, | |
656 | node.node) { | |
657 | jevent->enabled = 1; | |
658 | } | |
659 | rcu_read_unlock(); | |
660 | ||
661 | ret = LTTNG_OK; | |
662 | ||
663 | error: | |
664 | return ret; | |
665 | } | |
666 | ||
667 | /* | |
668 | * Enable a single JUL event for a given UST session. | |
669 | * | |
670 | * Return LTTNG_OK on success or else a LTTNG_ERR* code. | |
671 | */ | |
7923a38c DG |
672 | int event_jul_enable(struct ltt_ust_session *usess, struct lttng_event *event, |
673 | struct lttng_filter_bytecode *filter) | |
f20baf8e DG |
674 | { |
675 | int ret, created = 0; | |
676 | struct jul_event *jevent; | |
677 | ||
678 | assert(usess); | |
679 | assert(event); | |
680 | ||
b2064f54 DG |
681 | DBG("Event JUL enabling %s for session %" PRIu64 " with loglevel type %d " |
682 | "and loglevel %d", event->name, usess->id, event->loglevel_type, | |
683 | event->loglevel); | |
f20baf8e | 684 | |
4a4ab2c3 | 685 | jevent = jul_find_event(event->name, event->loglevel, &usess->domain_jul); |
f20baf8e | 686 | if (!jevent) { |
7923a38c | 687 | jevent = jul_create_event(event->name, filter); |
f20baf8e DG |
688 | if (!jevent) { |
689 | ret = LTTNG_ERR_NOMEM; | |
690 | goto error; | |
691 | } | |
b2064f54 DG |
692 | jevent->loglevel = event->loglevel; |
693 | jevent->loglevel_type = event->loglevel_type; | |
f20baf8e DG |
694 | created = 1; |
695 | } | |
696 | ||
697 | /* Already enabled? */ | |
698 | if (jevent->enabled) { | |
699 | goto end; | |
700 | } | |
701 | ||
702 | ret = jul_enable_event(jevent); | |
703 | if (ret != LTTNG_OK) { | |
704 | goto error; | |
705 | } | |
706 | ||
707 | /* If the event was created prior to the enable, add it to the domain. */ | |
708 | if (created) { | |
709 | jul_add_event(jevent, &usess->domain_jul); | |
710 | } | |
711 | ||
712 | end: | |
713 | return LTTNG_OK; | |
714 | ||
715 | error: | |
716 | if (created) { | |
717 | jul_destroy_event(jevent); | |
718 | } | |
719 | return ret; | |
720 | } | |
721 | ||
722 | /* | |
723 | * Disable a single JUL event for a given UST session. | |
724 | * | |
725 | * Return LTTNG_OK on success or else a LTTNG_ERR* code. | |
726 | */ | |
727 | int event_jul_disable(struct ltt_ust_session *usess, char *event_name) | |
728 | { | |
729 | int ret; | |
730 | struct jul_event *jevent; | |
7923a38c DG |
731 | struct ltt_ust_event *uevent = NULL; |
732 | struct ltt_ust_channel *uchan = NULL; | |
733 | char *ust_event_name; | |
f20baf8e DG |
734 | |
735 | assert(usess); | |
736 | assert(event_name); | |
737 | ||
738 | DBG("Event JUL disabling %s for session %" PRIu64, event_name, usess->id); | |
739 | ||
4a4ab2c3 | 740 | jevent = jul_find_event_by_name(event_name, &usess->domain_jul); |
f20baf8e DG |
741 | if (!jevent) { |
742 | ret = LTTNG_ERR_UST_EVENT_NOT_FOUND; | |
743 | goto error; | |
744 | } | |
745 | ||
746 | /* Already disabled? */ | |
747 | if (!jevent->enabled) { | |
748 | goto end; | |
749 | } | |
750 | ||
7923a38c DG |
751 | /* |
752 | * Disable it on the UST side. First get the channel reference then find | |
753 | * the event and finally disable it. | |
754 | */ | |
755 | uchan = trace_ust_find_channel_by_name(usess->domain_global.channels, | |
756 | DEFAULT_JUL_CHANNEL_NAME); | |
757 | if (!uchan) { | |
758 | ret = LTTNG_ERR_UST_CHAN_NOT_FOUND; | |
759 | goto error; | |
760 | } | |
761 | ||
762 | if (is_root) { | |
763 | ust_event_name = DEFAULT_SYS_JUL_EVENT_NAME; | |
764 | } else { | |
765 | ust_event_name = DEFAULT_USER_JUL_EVENT_NAME; | |
766 | } | |
767 | ||
768 | /* | |
769 | * The loglevel is hardcoded with 0 here since the JUL ust event is set | |
770 | * with the loglevel type to ALL thus the loglevel stays 0. The event's | |
771 | * filter is the one handling the loglevel for JUL. | |
772 | */ | |
773 | uevent = trace_ust_find_event(uchan->events, ust_event_name, | |
774 | jevent->filter, 0, NULL); | |
775 | /* If the JUL event exists, it must be available on the UST side. */ | |
776 | assert(uevent); | |
777 | ||
778 | ret = ust_app_disable_event_glb(usess, uchan, uevent); | |
779 | if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) { | |
780 | ret = LTTNG_ERR_UST_DISABLE_FAIL; | |
781 | goto error; | |
782 | } | |
3910e60d | 783 | uevent->enabled = 0; |
7923a38c | 784 | |
f20baf8e DG |
785 | ret = jul_disable_event(jevent); |
786 | if (ret != LTTNG_OK) { | |
787 | goto error; | |
788 | } | |
789 | ||
790 | end: | |
791 | return LTTNG_OK; | |
792 | ||
793 | error: | |
794 | return ret; | |
795 | } | |
796 | /* | |
797 | * Disable all JUL event for a given UST session. | |
798 | * | |
799 | * Return LTTNG_OK on success or else a LTTNG_ERR* code. | |
800 | */ | |
801 | int event_jul_disable_all(struct ltt_ust_session *usess) | |
802 | { | |
803 | int ret, do_disable = 0; | |
804 | struct jul_event *jevent; | |
805 | struct lttng_ht_iter iter; | |
806 | ||
807 | assert(usess); | |
808 | ||
809 | /* Enable event on JUL application through TCP socket. */ | |
810 | ret = event_jul_disable(usess, "*"); | |
811 | if (ret != LTTNG_OK) { | |
812 | if (ret == LTTNG_ERR_UST_EVENT_NOT_FOUND) { | |
813 | /* | |
814 | * This means that no enable all was done before but still a user | |
815 | * could want to disable everything even though the * wild card | |
816 | * event does not exists. | |
817 | */ | |
818 | do_disable = 1; | |
819 | } else { | |
820 | goto error; | |
821 | } | |
822 | } | |
823 | ||
824 | /* Flag every event that they are now enabled. */ | |
825 | rcu_read_lock(); | |
826 | cds_lfht_for_each_entry(usess->domain_jul.events->ht, &iter.iter, jevent, | |
827 | node.node) { | |
828 | if (jevent->enabled && do_disable) { | |
829 | ret = event_jul_disable(usess, jevent->name); | |
830 | if (ret != LTTNG_OK) { | |
831 | rcu_read_unlock(); | |
832 | goto error; | |
833 | } | |
834 | } | |
835 | jevent->enabled = 0; | |
836 | } | |
837 | rcu_read_unlock(); | |
838 | ||
839 | ret = LTTNG_OK; | |
840 | ||
841 | error: | |
842 | return ret; | |
843 | } |