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" |
9df8df5e | 30 | #include "ust-ctl.h" |
edb67388 DG |
31 | #include "ust-app.h" |
32 | #include "trace-kernel.h" | |
33 | #include "trace-ust.h" | |
54d01ffb | 34 | |
025faf73 DG |
35 | /* |
36 | * Add unique UST event based on the event name, filter bytecode and loglevel. | |
37 | */ | |
18eace3b DG |
38 | static void add_unique_ust_event(struct lttng_ht *ht, |
39 | struct ltt_ust_event *event) | |
40 | { | |
41 | struct cds_lfht_node *node_ptr; | |
42 | struct ltt_ust_ht_key key; | |
43 | ||
44 | assert(ht); | |
45 | assert(ht->ht); | |
46 | assert(event); | |
47 | ||
48 | key.name = event->attr.name; | |
49 | key.filter = (struct lttng_filter_bytecode *) event->filter; | |
50 | key.loglevel = event->attr.loglevel; | |
51 | ||
52 | node_ptr = cds_lfht_add_unique(ht->ht, | |
53 | ht->hash_fct(event->node.key, lttng_ht_seed), | |
54 | trace_ust_ht_match_event, &key, &event->node.node); | |
55 | assert(node_ptr == &event->node.node); | |
56 | } | |
57 | ||
8c9ae521 DG |
58 | /* |
59 | * Setup a lttng_event used to enable *all* syscall tracing. | |
60 | */ | |
61 | static void init_syscalls_kernel_event(struct lttng_event *event) | |
62 | { | |
0525e9ae DG |
63 | assert(event); |
64 | ||
8c9ae521 DG |
65 | event->name[0] = '\0'; |
66 | /* | |
67 | * We use LTTNG_EVENT* here since the trace kernel creation will make the | |
68 | * right changes for the kernel. | |
69 | */ | |
70 | event->type = LTTNG_EVENT_SYSCALL; | |
71 | } | |
72 | ||
54d01ffb | 73 | /* |
7a3d1328 | 74 | * Disable kernel tracepoint event for a channel from the kernel session. |
54d01ffb | 75 | */ |
d3a56674 DG |
76 | int event_kernel_disable_tracepoint(struct ltt_kernel_channel *kchan, |
77 | char *event_name) | |
54d01ffb DG |
78 | { |
79 | int ret; | |
80 | struct ltt_kernel_event *kevent; | |
81 | ||
0525e9ae DG |
82 | assert(kchan); |
83 | ||
54d01ffb DG |
84 | kevent = trace_kernel_get_event_by_name(event_name, kchan); |
85 | if (kevent == NULL) { | |
f73fabfd | 86 | ret = LTTNG_ERR_NO_EVENT; |
54d01ffb DG |
87 | goto error; |
88 | } | |
89 | ||
90 | ret = kernel_disable_event(kevent); | |
91 | if (ret < 0) { | |
f73fabfd | 92 | ret = LTTNG_ERR_KERN_DISABLE_FAIL; |
54d01ffb DG |
93 | goto error; |
94 | } | |
95 | ||
96 | DBG("Kernel event %s disable for channel %s.", | |
97 | kevent->event->name, kchan->channel->name); | |
98 | ||
f73fabfd | 99 | ret = LTTNG_OK; |
54d01ffb DG |
100 | |
101 | error: | |
102 | return ret; | |
103 | } | |
104 | ||
105 | /* | |
7a3d1328 | 106 | * Disable kernel tracepoint events for a channel from the kernel session. |
54d01ffb | 107 | */ |
d3a56674 | 108 | int event_kernel_disable_all_tracepoints(struct ltt_kernel_channel *kchan) |
54d01ffb DG |
109 | { |
110 | int ret; | |
111 | struct ltt_kernel_event *kevent; | |
112 | ||
0525e9ae DG |
113 | assert(kchan); |
114 | ||
54d01ffb DG |
115 | /* For each event in the kernel session */ |
116 | cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { | |
117 | ret = kernel_disable_event(kevent); | |
118 | if (ret < 0) { | |
119 | /* We continue disabling the rest */ | |
120 | continue; | |
121 | } | |
122 | } | |
f73fabfd | 123 | ret = LTTNG_OK; |
7a3d1328 MD |
124 | return ret; |
125 | } | |
126 | ||
127 | /* | |
128 | * Disable kernel syscall events for a channel from the kernel session. | |
129 | */ | |
d3a56674 | 130 | int event_kernel_disable_all_syscalls(struct ltt_kernel_channel *kchan) |
7a3d1328 MD |
131 | { |
132 | ERR("Cannot disable syscall tracing for existing session. Please destroy session instead."); | |
f73fabfd | 133 | return LTTNG_OK; /* Return OK so disable all succeeds */ |
7a3d1328 | 134 | } |
54d01ffb | 135 | |
7a3d1328 MD |
136 | /* |
137 | * Disable all kernel event for a channel from the kernel session. | |
138 | */ | |
d3a56674 | 139 | int event_kernel_disable_all(struct ltt_kernel_channel *kchan) |
7a3d1328 MD |
140 | { |
141 | int ret; | |
142 | ||
0525e9ae DG |
143 | assert(kchan); |
144 | ||
d3a56674 | 145 | ret = event_kernel_disable_all_tracepoints(kchan); |
f73fabfd | 146 | if (ret != LTTNG_OK) |
7a3d1328 | 147 | return ret; |
d3a56674 | 148 | ret = event_kernel_disable_all_syscalls(kchan); |
54d01ffb DG |
149 | return ret; |
150 | } | |
151 | ||
152 | /* | |
7a3d1328 | 153 | * Enable kernel tracepoint event for a channel from the kernel session. |
54d01ffb | 154 | */ |
d3a56674 DG |
155 | int event_kernel_enable_tracepoint(struct ltt_kernel_channel *kchan, |
156 | struct lttng_event *event) | |
54d01ffb DG |
157 | { |
158 | int ret; | |
159 | struct ltt_kernel_event *kevent; | |
160 | ||
0525e9ae DG |
161 | assert(kchan); |
162 | assert(event); | |
163 | ||
54d01ffb DG |
164 | kevent = trace_kernel_get_event_by_name(event->name, kchan); |
165 | if (kevent == NULL) { | |
166 | ret = kernel_create_event(event, kchan); | |
167 | if (ret < 0) { | |
bd29c13d DG |
168 | switch (-ret) { |
169 | case EEXIST: | |
f73fabfd | 170 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
bd29c13d DG |
171 | break; |
172 | case ENOSYS: | |
f73fabfd | 173 | ret = LTTNG_ERR_KERN_EVENT_ENOSYS; |
bd29c13d DG |
174 | break; |
175 | default: | |
f73fabfd | 176 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
bd29c13d | 177 | break; |
d87bfb32 | 178 | } |
7a3d1328 | 179 | goto end; |
54d01ffb DG |
180 | } |
181 | } else if (kevent->enabled == 0) { | |
182 | ret = kernel_enable_event(kevent); | |
183 | if (ret < 0) { | |
f73fabfd | 184 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
7a3d1328 | 185 | goto end; |
54d01ffb | 186 | } |
42224349 DG |
187 | } else { |
188 | /* At this point, the event is considered enabled */ | |
f73fabfd | 189 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
42224349 | 190 | goto end; |
54d01ffb | 191 | } |
42224349 | 192 | |
f73fabfd | 193 | ret = LTTNG_OK; |
7a3d1328 | 194 | end: |
54d01ffb DG |
195 | return ret; |
196 | } | |
197 | ||
198 | /* | |
7a3d1328 | 199 | * Enable all kernel tracepoint events of a channel of the kernel session. |
54d01ffb | 200 | */ |
d3a56674 DG |
201 | int event_kernel_enable_all_tracepoints(struct ltt_kernel_channel *kchan, |
202 | int kernel_tracer_fd) | |
54d01ffb DG |
203 | { |
204 | int size, i, ret; | |
205 | struct ltt_kernel_event *kevent; | |
8f69e5eb | 206 | struct lttng_event *event_list = NULL; |
54d01ffb | 207 | |
0525e9ae DG |
208 | assert(kchan); |
209 | ||
54d01ffb DG |
210 | /* For each event in the kernel session */ |
211 | cds_list_for_each_entry(kevent, &kchan->events_list.head, list) { | |
8f69e5eb DG |
212 | if (kevent->enabled == 0) { |
213 | ret = kernel_enable_event(kevent); | |
214 | if (ret < 0) { | |
215 | /* Enable failed but still continue */ | |
216 | continue; | |
217 | } | |
54d01ffb DG |
218 | } |
219 | } | |
220 | ||
221 | size = kernel_list_events(kernel_tracer_fd, &event_list); | |
222 | if (size < 0) { | |
f73fabfd | 223 | ret = LTTNG_ERR_KERN_LIST_FAIL; |
7a3d1328 | 224 | goto end; |
54d01ffb DG |
225 | } |
226 | ||
227 | for (i = 0; i < size; i++) { | |
228 | kevent = trace_kernel_get_event_by_name(event_list[i].name, kchan); | |
229 | if (kevent == NULL) { | |
230 | /* Default event type for enable all */ | |
231 | event_list[i].type = LTTNG_EVENT_TRACEPOINT; | |
232 | /* Enable each single tracepoint event */ | |
233 | ret = kernel_create_event(&event_list[i], kchan); | |
234 | if (ret < 0) { | |
235 | /* Ignore error here and continue */ | |
236 | } | |
237 | } | |
238 | } | |
54d01ffb | 239 | free(event_list); |
8f69e5eb | 240 | |
f73fabfd | 241 | ret = LTTNG_OK; |
7a3d1328 | 242 | end: |
54d01ffb DG |
243 | return ret; |
244 | } | |
8c9ae521 DG |
245 | |
246 | /* | |
7a3d1328 | 247 | * Enable all kernel tracepoint events of a channel of the kernel session. |
8c9ae521 | 248 | */ |
d3a56674 DG |
249 | int event_kernel_enable_all_syscalls(struct ltt_kernel_channel *kchan, |
250 | int kernel_tracer_fd) | |
8c9ae521 DG |
251 | { |
252 | int ret; | |
253 | struct lttng_event event; | |
254 | ||
0525e9ae DG |
255 | assert(kchan); |
256 | ||
8c9ae521 DG |
257 | init_syscalls_kernel_event(&event); |
258 | ||
259 | DBG("Enabling all syscall tracing"); | |
260 | ||
261 | ret = kernel_create_event(&event, kchan); | |
262 | if (ret < 0) { | |
8f69e5eb | 263 | if (ret == -EEXIST) { |
f73fabfd | 264 | ret = LTTNG_ERR_KERN_EVENT_EXIST; |
8f69e5eb | 265 | } else { |
f73fabfd | 266 | ret = LTTNG_ERR_KERN_ENABLE_FAIL; |
8f69e5eb | 267 | } |
7a3d1328 | 268 | goto end; |
8c9ae521 | 269 | } |
8f69e5eb | 270 | |
f73fabfd | 271 | ret = LTTNG_OK; |
7a3d1328 MD |
272 | end: |
273 | return ret; | |
274 | } | |
8c9ae521 | 275 | |
7a3d1328 MD |
276 | /* |
277 | * Enable all kernel events of a channel of the kernel session. | |
278 | */ | |
d3a56674 DG |
279 | int event_kernel_enable_all(struct ltt_kernel_channel *kchan, |
280 | int kernel_tracer_fd) | |
7a3d1328 | 281 | { |
6bd8707a | 282 | int tp_ret; |
7a3d1328 | 283 | |
0525e9ae DG |
284 | assert(kchan); |
285 | ||
d3a56674 | 286 | tp_ret = event_kernel_enable_all_tracepoints(kchan, kernel_tracer_fd); |
f73fabfd | 287 | if (tp_ret != LTTNG_OK) { |
7a3d1328 MD |
288 | goto end; |
289 | } | |
bd29c13d DG |
290 | |
291 | /* | |
292 | * Reaching this code path means that all tracepoints were enabled without | |
293 | * errors so we ignore the error value of syscalls. | |
294 | * | |
295 | * At the moment, failing to enable syscalls on "lttng enable-event -a -k" | |
296 | * is not considered an error that need to be returned to the client since | |
297 | * tracepoints did not fail. Future work will allow us to send back | |
298 | * multiple errors to the client in one API call. | |
299 | */ | |
d3a56674 | 300 | (void) event_kernel_enable_all_syscalls(kchan, kernel_tracer_fd); |
bd29c13d | 301 | |
7a3d1328 | 302 | end: |
bd29c13d | 303 | return tp_ret; |
8c9ae521 | 304 | } |
2bdd86d4 | 305 | |
7f79d3a1 DG |
306 | /* |
307 | * ============================ | |
308 | * UST : The Ultimate Frontier! | |
309 | * ============================ | |
310 | */ | |
311 | ||
76d45b40 DG |
312 | /* |
313 | * Enable all UST tracepoints for a channel from a UST session. | |
314 | */ | |
7972aab2 | 315 | int event_ust_enable_all_tracepoints(struct ltt_ust_session *usess, |
025faf73 | 316 | struct ltt_ust_channel *uchan, struct lttng_filter_bytecode *filter) |
76d45b40 | 317 | { |
6775595e | 318 | int ret, i, size; |
bec39940 | 319 | struct lttng_ht_iter iter; |
76d45b40 | 320 | struct ltt_ust_event *uevent = NULL; |
7f79d3a1 | 321 | struct lttng_event *events = NULL; |
76d45b40 | 322 | |
0525e9ae DG |
323 | assert(usess); |
324 | assert(uchan); | |
325 | ||
025faf73 DG |
326 | rcu_read_lock(); |
327 | ||
7972aab2 DG |
328 | /* Enable existing events */ |
329 | cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, | |
330 | node.node) { | |
331 | if (uevent->enabled == 0) { | |
332 | ret = ust_app_enable_event_glb(usess, uchan, uevent); | |
333 | if (ret < 0) { | |
76d45b40 DG |
334 | continue; |
335 | } | |
7972aab2 DG |
336 | uevent->enabled = 1; |
337 | } | |
338 | } | |
76d45b40 | 339 | |
7972aab2 DG |
340 | /* Get all UST available events */ |
341 | size = ust_app_list_events(&events); | |
342 | if (size < 0) { | |
343 | ret = LTTNG_ERR_UST_LIST_FAIL; | |
344 | goto error; | |
345 | } | |
76d45b40 | 346 | |
7972aab2 DG |
347 | for (i = 0; i < size; i++) { |
348 | /* | |
349 | * Check if event exist and if so, continue since it was enable | |
350 | * previously. | |
351 | */ | |
352 | uevent = trace_ust_find_event(uchan->events, events[i].name, filter, | |
353 | events[i].loglevel); | |
354 | if (uevent != NULL) { | |
76d45b40 DG |
355 | ret = ust_app_enable_event_pid(usess, uchan, uevent, |
356 | events[i].pid); | |
357 | if (ret < 0) { | |
7972aab2 | 358 | if (ret != -LTTNG_UST_ERR_EXIST) { |
f73fabfd | 359 | ret = LTTNG_ERR_UST_ENABLE_FAIL; |
7972aab2 | 360 | goto error; |
76d45b40 | 361 | } |
76d45b40 | 362 | } |
7972aab2 DG |
363 | continue; |
364 | } | |
76d45b40 | 365 | |
7972aab2 DG |
366 | /* Create ust event */ |
367 | uevent = trace_ust_create_event(&events[i], filter); | |
368 | if (uevent == NULL) { | |
369 | ret = LTTNG_ERR_FATAL; | |
370 | goto error_destroy; | |
76d45b40 DG |
371 | } |
372 | ||
7972aab2 DG |
373 | /* Create event for the specific PID */ |
374 | ret = ust_app_enable_event_pid(usess, uchan, uevent, | |
375 | events[i].pid); | |
376 | if (ret < 0) { | |
377 | if (ret == -LTTNG_UST_ERR_EXIST) { | |
378 | ret = LTTNG_ERR_UST_EVENT_EXIST; | |
379 | goto error; | |
380 | } else { | |
381 | ret = LTTNG_ERR_UST_ENABLE_FAIL; | |
382 | goto error_destroy; | |
383 | } | |
384 | } | |
385 | ||
386 | uevent->enabled = 1; | |
387 | /* Add ltt ust event to channel */ | |
388 | rcu_read_lock(); | |
389 | add_unique_ust_event(uchan->events, uevent); | |
390 | rcu_read_unlock(); | |
76d45b40 | 391 | } |
7972aab2 | 392 | free(events); |
76d45b40 | 393 | |
025faf73 | 394 | rcu_read_unlock(); |
f73fabfd | 395 | return LTTNG_OK; |
76d45b40 | 396 | |
7f79d3a1 | 397 | error_destroy: |
76d45b40 | 398 | trace_ust_destroy_event(uevent); |
7f79d3a1 DG |
399 | |
400 | error: | |
401 | free(events); | |
025faf73 | 402 | rcu_read_unlock(); |
76d45b40 DG |
403 | return ret; |
404 | } | |
405 | ||
2bdd86d4 MD |
406 | /* |
407 | * Enable UST tracepoint event for a channel from a UST session. | |
408 | */ | |
7972aab2 | 409 | int event_ust_enable_tracepoint(struct ltt_ust_session *usess, |
025faf73 DG |
410 | struct ltt_ust_channel *uchan, struct lttng_event *event, |
411 | struct lttng_filter_bytecode *filter) | |
2bdd86d4 | 412 | { |
f73fabfd | 413 | int ret = LTTNG_OK, to_create = 0; |
edb67388 DG |
414 | struct ltt_ust_event *uevent; |
415 | ||
0525e9ae DG |
416 | assert(usess); |
417 | assert(uchan); | |
418 | assert(event); | |
419 | ||
18eace3b DG |
420 | rcu_read_lock(); |
421 | ||
025faf73 | 422 | uevent = trace_ust_find_event(uchan->events, event->name, filter, |
18eace3b | 423 | event->loglevel); |
edb67388 | 424 | if (uevent == NULL) { |
025faf73 | 425 | uevent = trace_ust_create_event(event, filter); |
edb67388 | 426 | if (uevent == NULL) { |
95a82664 | 427 | ret = LTTNG_ERR_UST_ENABLE_FAIL; |
edb67388 DG |
428 | goto error; |
429 | } | |
025faf73 | 430 | |
fc34caaa | 431 | /* Valid to set it after the goto error since uevent is still NULL */ |
edb67388 DG |
432 | to_create = 1; |
433 | } | |
2bdd86d4 | 434 | |
7f79d3a1 DG |
435 | if (uevent->enabled) { |
436 | /* It's already enabled so everything is OK */ | |
5bcdda4f | 437 | ret = LTTNG_ERR_UST_EVENT_ENABLED; |
7f79d3a1 DG |
438 | goto end; |
439 | } | |
440 | ||
fc34caaa DG |
441 | uevent->enabled = 1; |
442 | ||
7972aab2 DG |
443 | if (to_create) { |
444 | /* Create event on all UST registered apps for session */ | |
445 | ret = ust_app_create_event_glb(usess, uchan, uevent); | |
446 | } else { | |
447 | /* Enable event on all UST registered apps for session */ | |
448 | ret = ust_app_enable_event_glb(usess, uchan, uevent); | |
449 | } | |
48842b30 | 450 | |
7972aab2 DG |
451 | if (ret < 0) { |
452 | if (ret == -LTTNG_UST_ERR_EXIST) { | |
453 | ret = LTTNG_ERR_UST_EVENT_EXIST; | |
454 | goto end; | |
455 | } else { | |
456 | ret = LTTNG_ERR_UST_ENABLE_FAIL; | |
457 | goto error; | |
edb67388 | 458 | } |
2bdd86d4 | 459 | } |
48842b30 | 460 | |
7f79d3a1 | 461 | if (to_create) { |
fc34caaa | 462 | /* Add ltt ust event to channel */ |
18eace3b | 463 | add_unique_ust_event(uchan->events, uevent); |
7f79d3a1 | 464 | } |
edb67388 | 465 | |
7f79d3a1 DG |
466 | DBG("Event UST %s %s in channel %s", uevent->attr.name, |
467 | to_create ? "created" : "enabled", uchan->name); | |
468 | ||
f73fabfd | 469 | ret = LTTNG_OK; |
fc34caaa | 470 | |
fb89d070 | 471 | end: |
18eace3b | 472 | rcu_read_unlock(); |
fc34caaa | 473 | return ret; |
edb67388 DG |
474 | |
475 | error: | |
fc34caaa DG |
476 | /* |
477 | * Only destroy event on creation time (not enabling time) because if the | |
478 | * event is found in the channel (to_create == 0), it means that at some | |
479 | * point the enable_event worked and it's thus valid to keep it alive. | |
480 | * Destroying it also implies that we also destroy it's shadow copy to sync | |
481 | * everyone up. | |
482 | */ | |
483 | if (to_create) { | |
484 | /* In this code path, the uevent was not added to the hash table */ | |
485 | trace_ust_destroy_event(uevent); | |
486 | } | |
18eace3b | 487 | rcu_read_unlock(); |
2bdd86d4 MD |
488 | return ret; |
489 | } | |
490 | ||
7f79d3a1 DG |
491 | /* |
492 | * Disable UST tracepoint of a channel from a UST session. | |
493 | */ | |
7972aab2 | 494 | int event_ust_disable_tracepoint(struct ltt_ust_session *usess, |
7f79d3a1 | 495 | struct ltt_ust_channel *uchan, char *event_name) |
2bdd86d4 MD |
496 | { |
497 | int ret; | |
7f79d3a1 | 498 | struct ltt_ust_event *uevent; |
18eace3b DG |
499 | struct lttng_ht_node_str *node; |
500 | struct lttng_ht_iter iter; | |
18eace3b | 501 | struct lttng_ht *ht; |
2bdd86d4 | 502 | |
0525e9ae DG |
503 | assert(usess); |
504 | assert(uchan); | |
505 | assert(event_name); | |
506 | ||
18eace3b DG |
507 | ht = uchan->events; |
508 | ||
18eace3b | 509 | rcu_read_lock(); |
025faf73 DG |
510 | |
511 | /* | |
512 | * We use a custom lookup since we need the iterator for the next_duplicate | |
513 | * call in the do while loop below. | |
514 | */ | |
515 | cds_lfht_lookup(ht->ht, ht->hash_fct((void *) event_name, lttng_ht_seed), | |
516 | trace_ust_ht_match_event_by_name, event_name, &iter.iter); | |
18eace3b DG |
517 | node = lttng_ht_iter_get_node_str(&iter); |
518 | if (node == NULL) { | |
519 | DBG2("Trace UST event NOT found by name %s", event_name); | |
f73fabfd | 520 | ret = LTTNG_ERR_UST_EVENT_NOT_FOUND; |
7f79d3a1 | 521 | goto error; |
2bdd86d4 | 522 | } |
7f79d3a1 | 523 | |
18eace3b DG |
524 | do { |
525 | uevent = caa_container_of(node, struct ltt_ust_event, node); | |
025faf73 DG |
526 | assert(uevent); |
527 | ||
18eace3b DG |
528 | if (uevent->enabled == 0) { |
529 | /* It's already disabled so everything is OK */ | |
530 | ret = LTTNG_OK; | |
531 | continue; | |
7f79d3a1 | 532 | } |
18eace3b | 533 | |
7972aab2 DG |
534 | ret = ust_app_disable_event_glb(usess, uchan, uevent); |
535 | if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) { | |
536 | ret = LTTNG_ERR_UST_DISABLE_FAIL; | |
18eace3b DG |
537 | goto error; |
538 | } | |
18eace3b DG |
539 | uevent->enabled = 0; |
540 | ||
025faf73 DG |
541 | DBG2("Event UST %s disabled in channel %s", uevent->attr.name, |
542 | uchan->name); | |
543 | ||
18eace3b DG |
544 | /* Get next duplicate event by name. */ |
545 | cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name, | |
546 | event_name, &iter.iter); | |
547 | node = lttng_ht_iter_get_node_str(&iter); | |
548 | } while (node); | |
7f79d3a1 | 549 | |
f73fabfd | 550 | ret = LTTNG_OK; |
7f79d3a1 | 551 | |
7f79d3a1 | 552 | error: |
18eace3b | 553 | rcu_read_unlock(); |
7f79d3a1 DG |
554 | return ret; |
555 | } | |
556 | ||
557 | /* | |
558 | * Disable all UST tracepoints for a channel from a UST session. | |
559 | */ | |
7972aab2 | 560 | int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess, |
7f79d3a1 DG |
561 | struct ltt_ust_channel *uchan) |
562 | { | |
6775595e | 563 | int ret, i, size; |
bec39940 | 564 | struct lttng_ht_iter iter; |
7f79d3a1 DG |
565 | struct ltt_ust_event *uevent = NULL; |
566 | struct lttng_event *events = NULL; | |
567 | ||
0525e9ae DG |
568 | assert(usess); |
569 | assert(uchan); | |
570 | ||
025faf73 DG |
571 | rcu_read_lock(); |
572 | ||
7972aab2 DG |
573 | /* Disabling existing events */ |
574 | cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, | |
575 | node.node) { | |
576 | if (uevent->enabled == 1) { | |
577 | ret = event_ust_disable_tracepoint(usess, uchan, | |
578 | uevent->attr.name); | |
579 | if (ret < 0) { | |
7f79d3a1 DG |
580 | continue; |
581 | } | |
582 | } | |
7f79d3a1 | 583 | } |
7972aab2 DG |
584 | |
585 | /* Get all UST available events */ | |
586 | size = ust_app_list_events(&events); | |
587 | if (size < 0) { | |
588 | ret = LTTNG_ERR_UST_LIST_FAIL; | |
7f79d3a1 DG |
589 | goto error; |
590 | } | |
591 | ||
7972aab2 DG |
592 | for (i = 0; i < size; i++) { |
593 | ret = event_ust_disable_tracepoint(usess, uchan, | |
594 | events[i].name); | |
595 | if (ret != LTTNG_OK) { | |
596 | /* Continue to disable the rest... */ | |
597 | continue; | |
598 | } | |
599 | } | |
600 | free(events); | |
601 | ||
025faf73 | 602 | rcu_read_unlock(); |
f73fabfd | 603 | return LTTNG_OK; |
7f79d3a1 DG |
604 | |
605 | error: | |
606 | free(events); | |
025faf73 | 607 | rcu_read_unlock(); |
2bdd86d4 MD |
608 | return ret; |
609 | } |