Add missing Makefile.am in common/
[lttng-tools.git] / lttng-sessiond / ust-app.c
1 /*
2 * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; only version 2
7 * of the License.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 #define _GNU_SOURCE
20 #include <errno.h>
21 #include <pthread.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <sys/types.h>
27 #include <unistd.h>
28 #include <runas.h>
29
30 #include <urcu/compiler.h>
31 #include <lttngerr.h>
32 #include <lttng-share.h>
33 #include <runas.h>
34
35 #include "../common/hashtable.h"
36 #include "ust-app.h"
37 #include "ust-consumer.h"
38 #include "ust-ctl.h"
39
40 /*
41 * Delete ust context safely. RCU read lock must be held before calling
42 * this function.
43 */
44 static
45 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
46 {
47 if (ua_ctx->obj) {
48 ustctl_release_object(sock, ua_ctx->obj);
49 free(ua_ctx->obj);
50 }
51 free(ua_ctx);
52 }
53
54 /*
55 * Delete ust app event safely. RCU read lock must be held before calling
56 * this function.
57 */
58 static
59 void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
60 {
61 int ret;
62 struct cds_lfht_iter iter;
63 struct ust_app_ctx *ua_ctx;
64
65 cds_lfht_for_each_entry(ua_event->ctx, &iter, ua_ctx, node) {
66 ret = hashtable_del(ua_event->ctx, &iter);
67 assert(!ret);
68 delete_ust_app_ctx(sock, ua_ctx);
69 }
70 ret = hashtable_destroy(ua_event->ctx);
71 assert(!ret);
72
73 if (ua_event->obj != NULL) {
74 ustctl_release_object(sock, ua_event->obj);
75 free(ua_event->obj);
76 }
77 free(ua_event);
78 }
79
80 /*
81 * Delete ust app stream safely. RCU read lock must be held before calling
82 * this function.
83 */
84 static
85 void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
86 {
87 if (stream->obj) {
88 ustctl_release_object(sock, stream->obj);
89 free(stream->obj);
90 }
91 free(stream);
92 }
93
94 /*
95 * Delete ust app channel safely. RCU read lock must be held before calling
96 * this function.
97 */
98 static
99 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
100 {
101 int ret;
102 struct cds_lfht_iter iter;
103 struct ust_app_event *ua_event;
104 struct ust_app_ctx *ua_ctx;
105 struct ltt_ust_stream *stream, *stmp;
106
107 /* Wipe stream */
108 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
109 cds_list_del(&stream->list);
110 delete_ust_app_stream(sock, stream);
111 }
112
113 /* Wipe context */
114 cds_lfht_for_each_entry(ua_chan->ctx, &iter, ua_ctx, node) {
115 ret = hashtable_del(ua_chan->ctx, &iter);
116 assert(!ret);
117 delete_ust_app_ctx(sock, ua_ctx);
118 }
119 ret = hashtable_destroy(ua_chan->ctx);
120 assert(!ret);
121
122 /* Wipe events */
123 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
124 ret = hashtable_del(ua_chan->events, &iter);
125 assert(!ret);
126 delete_ust_app_event(sock, ua_event);
127 }
128 ret = hashtable_destroy(ua_chan->events);
129 assert(!ret);
130
131 if (ua_chan->obj != NULL) {
132 ustctl_release_object(sock, ua_chan->obj);
133 free(ua_chan->obj);
134 }
135 free(ua_chan);
136 }
137
138 /*
139 * Delete ust app session safely. RCU read lock must be held before calling
140 * this function.
141 */
142 static
143 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess)
144 {
145 int ret;
146 struct cds_lfht_iter iter;
147 struct ust_app_channel *ua_chan;
148
149 if (ua_sess->metadata) {
150 if (ua_sess->metadata->stream_obj) {
151 ustctl_release_object(sock, ua_sess->metadata->stream_obj);
152 free(ua_sess->metadata->stream_obj);
153 }
154 if (ua_sess->metadata->obj) {
155 ustctl_release_object(sock, ua_sess->metadata->obj);
156 free(ua_sess->metadata->obj);
157 }
158 }
159
160 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
161 ret = hashtable_del(ua_sess->channels, &iter);
162 assert(!ret);
163 delete_ust_app_channel(sock, ua_chan);
164 }
165 ret = hashtable_destroy(ua_sess->channels);
166 assert(!ret);
167
168 if (ua_sess->handle != -1) {
169 ustctl_release_handle(sock, ua_sess->handle);
170 }
171 free(ua_sess);
172 }
173
174 /*
175 * Delete a traceable application structure from the global list. Never call
176 * this function outside of a call_rcu call.
177 */
178 static
179 void delete_ust_app(struct ust_app *app)
180 {
181 int ret, sock;
182 struct cds_lfht_node *node;
183 struct cds_lfht_iter iter;
184 struct ust_app_session *ua_sess;
185
186 rcu_read_lock();
187
188 /* Remove from key hash table */
189 node = hashtable_lookup(ust_app_sock_key_map,
190 (void *) ((unsigned long) app->key.sock), sizeof(void *), &iter);
191 if (node == NULL) {
192 /* Not suppose to happen */
193 ERR("UST app key %d not found in key hash table", app->key.sock);
194 goto end;
195 }
196
197 ret = hashtable_del(ust_app_sock_key_map, &iter);
198 if (ret) {
199 ERR("UST app unable to delete app sock %d from key hash table",
200 app->key.sock);
201 } else {
202 DBG2("UST app pair sock %d key %d deleted",
203 app->key.sock, app->key.pid);
204 }
205
206 /* Socket is already closed at this point */
207
208 /* Delete ust app sessions info */
209 sock = app->key.sock;
210 app->key.sock = -1;
211
212 /* Wipe sessions */
213 cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
214 ret = hashtable_del(app->sessions, &iter);
215 assert(!ret);
216 delete_ust_app_session(app->key.sock, ua_sess);
217 }
218 ret = hashtable_destroy(app->sessions);
219 assert(!ret);
220
221 /*
222 * Wait until we have removed the key from the sock hash table
223 * before closing this socket, otherwise an application could
224 * re-use the socket ID and race with the teardown, using the
225 * same hash table entry.
226 */
227 close(sock);
228
229 DBG2("UST app pid %d deleted", app->key.pid);
230 free(app);
231 end:
232 rcu_read_unlock();
233 }
234
235 /*
236 * URCU intermediate call to delete an UST app.
237 */
238 static
239 void delete_ust_app_rcu(struct rcu_head *head)
240 {
241 struct cds_lfht_node *node =
242 caa_container_of(head, struct cds_lfht_node, head);
243 struct ust_app *app =
244 caa_container_of(node, struct ust_app, node);
245
246 delete_ust_app(app);
247 }
248
249 /*
250 * Alloc new UST app session.
251 */
252 static
253 struct ust_app_session *alloc_ust_app_session(void)
254 {
255 struct ust_app_session *ua_sess;
256
257 /* Init most of the default value by allocating and zeroing */
258 ua_sess = zmalloc(sizeof(struct ust_app_session));
259 if (ua_sess == NULL) {
260 PERROR("malloc");
261 goto error;
262 }
263
264 ua_sess->handle = -1;
265 ua_sess->channels = hashtable_new_str(0);
266
267 return ua_sess;
268
269 error:
270 return NULL;
271 }
272
273 /*
274 * Alloc new UST app channel.
275 */
276 static
277 struct ust_app_channel *alloc_ust_app_channel(char *name,
278 struct lttng_ust_channel *attr)
279 {
280 struct ust_app_channel *ua_chan;
281
282 /* Init most of the default value by allocating and zeroing */
283 ua_chan = zmalloc(sizeof(struct ust_app_channel));
284 if (ua_chan == NULL) {
285 PERROR("malloc");
286 goto error;
287 }
288
289 /* Setup channel name */
290 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
291 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
292
293 ua_chan->enabled = 1;
294 ua_chan->handle = -1;
295 ua_chan->ctx = hashtable_new(0);
296 ua_chan->events = hashtable_new_str(0);
297 hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
298 strlen(ua_chan->name));
299
300 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
301
302 /* Copy attributes */
303 if (attr) {
304 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
305 }
306
307 DBG3("UST app channel %s allocated", ua_chan->name);
308
309 return ua_chan;
310
311 error:
312 return NULL;
313 }
314
315 /*
316 * Alloc new UST app event.
317 */
318 static
319 struct ust_app_event *alloc_ust_app_event(char *name,
320 struct lttng_ust_event *attr)
321 {
322 struct ust_app_event *ua_event;
323
324 /* Init most of the default value by allocating and zeroing */
325 ua_event = zmalloc(sizeof(struct ust_app_event));
326 if (ua_event == NULL) {
327 PERROR("malloc");
328 goto error;
329 }
330
331 ua_event->enabled = 1;
332 strncpy(ua_event->name, name, sizeof(ua_event->name));
333 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
334 ua_event->ctx = hashtable_new(0);
335 hashtable_node_init(&ua_event->node, (void *) ua_event->name,
336 strlen(ua_event->name));
337
338 /* Copy attributes */
339 if (attr) {
340 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
341 }
342
343 DBG3("UST app event %s allocated", ua_event->name);
344
345 return ua_event;
346
347 error:
348 return NULL;
349 }
350
351 /*
352 * Alloc new UST app context.
353 */
354 static
355 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
356 {
357 struct ust_app_ctx *ua_ctx;
358
359 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
360 if (ua_ctx == NULL) {
361 goto error;
362 }
363
364 if (uctx) {
365 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
366 }
367
368 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
369
370 error:
371 return ua_ctx;
372 }
373
374 /*
375 * Find an ust_app using the sock and return it. RCU read side lock must be
376 * held before calling this helper function.
377 */
378 static
379 struct ust_app *find_app_by_sock(int sock)
380 {
381 struct cds_lfht_node *node;
382 struct ust_app_key *key;
383 struct cds_lfht_iter iter;
384
385 node = hashtable_lookup(ust_app_sock_key_map,
386 (void *)((unsigned long) sock), sizeof(void *), &iter);
387 if (node == NULL) {
388 DBG2("UST app find by sock %d key not found", sock);
389 goto error;
390 }
391
392 key = caa_container_of(node, struct ust_app_key, node);
393
394 node = hashtable_lookup(ust_app_ht,
395 (void *)((unsigned long) key->pid), sizeof(void *), &iter);
396 if (node == NULL) {
397 DBG2("UST app find by sock %d not found", sock);
398 goto error;
399 }
400 return caa_container_of(node, struct ust_app, node);
401
402 error:
403 return NULL;
404 }
405
406 /*
407 * Create the channel context on the tracer.
408 */
409 static
410 int create_ust_channel_context(struct ust_app_channel *ua_chan,
411 struct ust_app_ctx *ua_ctx, struct ust_app *app)
412 {
413 int ret;
414
415 ret = ustctl_add_context(app->key.sock, &ua_ctx->ctx,
416 ua_chan->obj, &ua_ctx->obj);
417 if (ret < 0) {
418 goto error;
419 }
420
421 ua_ctx->handle = ua_ctx->obj->handle;
422
423 DBG2("UST app context added to channel %s successfully", ua_chan->name);
424
425 error:
426 return ret;
427 }
428
429 /*
430 * Create the event context on the tracer.
431 */
432 static
433 int create_ust_event_context(struct ust_app_event *ua_event,
434 struct ust_app_ctx *ua_ctx, struct ust_app *app)
435 {
436 int ret;
437
438 ret = ustctl_add_context(app->key.sock, &ua_ctx->ctx,
439 ua_event->obj, &ua_ctx->obj);
440 if (ret < 0) {
441 goto error;
442 }
443
444 ua_ctx->handle = ua_ctx->obj->handle;
445
446 DBG2("UST app context added to event %s successfully", ua_event->name);
447
448 error:
449 return ret;
450 }
451
452 /*
453 * Disable the specified event on to UST tracer for the UST session.
454 */
455 static int disable_ust_event(struct ust_app *app,
456 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
457 {
458 int ret;
459
460 ret = ustctl_disable(app->key.sock, ua_event->obj);
461 if (ret < 0) {
462 ERR("UST app event %s disable failed for app (pid: %d) "
463 "and session handle %d with ret %d",
464 ua_event->attr.name, app->key.pid, ua_sess->handle, ret);
465 goto error;
466 }
467
468 DBG2("UST app event %s disabled successfully for app (pid: %d)",
469 ua_event->attr.name, app->key.pid);
470
471 error:
472 return ret;
473 }
474
475 /*
476 * Disable the specified channel on to UST tracer for the UST session.
477 */
478 static int disable_ust_channel(struct ust_app *app,
479 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
480 {
481 int ret;
482
483 ret = ustctl_disable(app->key.sock, ua_chan->obj);
484 if (ret < 0) {
485 ERR("UST app channel %s disable failed for app (pid: %d) "
486 "and session handle %d with ret %d",
487 ua_chan->name, app->key.pid, ua_sess->handle, ret);
488 goto error;
489 }
490
491 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
492 ua_chan->name, app->key.pid);
493
494 error:
495 return ret;
496 }
497
498 /*
499 * Enable the specified channel on to UST tracer for the UST session.
500 */
501 static int enable_ust_channel(struct ust_app *app,
502 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
503 {
504 int ret;
505
506 ret = ustctl_enable(app->key.sock, ua_chan->obj);
507 if (ret < 0) {
508 ERR("UST app channel %s enable failed for app (pid: %d) "
509 "and session handle %d with ret %d",
510 ua_chan->name, app->key.pid, ua_sess->handle, ret);
511 goto error;
512 }
513
514 ua_chan->enabled = 1;
515
516 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
517 ua_chan->name, app->key.pid);
518
519 error:
520 return ret;
521 }
522
523 /*
524 * Enable the specified event on to UST tracer for the UST session.
525 */
526 static int enable_ust_event(struct ust_app *app,
527 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
528 {
529 int ret;
530
531 ret = ustctl_enable(app->key.sock, ua_event->obj);
532 if (ret < 0) {
533 ERR("UST app event %s enable failed for app (pid: %d) "
534 "and session handle %d with ret %d",
535 ua_event->attr.name, app->key.pid, ua_sess->handle, ret);
536 goto error;
537 }
538
539 DBG2("UST app event %s enabled successfully for app (pid: %d)",
540 ua_event->attr.name, app->key.pid);
541
542 error:
543 return ret;
544 }
545
546 /*
547 * Open metadata onto the UST tracer for a UST session.
548 */
549 static int open_ust_metadata(struct ust_app *app,
550 struct ust_app_session *ua_sess)
551 {
552 int ret;
553 struct lttng_ust_channel_attr uattr;
554
555 uattr.overwrite = ua_sess->metadata->attr.overwrite;
556 uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
557 uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
558 uattr.switch_timer_interval =
559 ua_sess->metadata->attr.switch_timer_interval;
560 uattr.read_timer_interval =
561 ua_sess->metadata->attr.read_timer_interval;
562 uattr.output = ua_sess->metadata->attr.output;
563
564 /* UST tracer metadata creation */
565 ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
566 &ua_sess->metadata->obj);
567 if (ret < 0) {
568 ERR("UST app open metadata failed for app pid:%d",
569 app->key.pid);
570 goto error;
571 }
572
573 ua_sess->metadata->handle = ua_sess->metadata->obj->handle;
574
575 error:
576 return ret;
577 }
578
579 /*
580 * Create stream onto the UST tracer for a UST session.
581 */
582 static int create_ust_stream(struct ust_app *app,
583 struct ust_app_session *ua_sess)
584 {
585 int ret;
586
587 ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
588 &ua_sess->metadata->stream_obj);
589 if (ret < 0) {
590 ERR("UST create metadata stream failed");
591 goto error;
592 }
593
594 error:
595 return ret;
596 }
597
598 /*
599 * Create the specified channel onto the UST tracer for a UST session.
600 */
601 static int create_ust_channel(struct ust_app *app,
602 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
603 {
604 int ret;
605
606 /* TODO: remove cast and use lttng-ust-abi.h */
607 ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
608 (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
609 if (ret < 0) {
610 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
611 "and session handle %d with ret %d",
612 ua_chan->name, app->key.pid, app->key.sock,
613 ua_sess->handle, ret);
614 goto error;
615 }
616
617 ua_chan->handle = ua_chan->obj->handle;
618 ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
619 ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
620 ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
621
622 DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
623 ua_chan->name, app->key.pid, app->key.sock);
624
625 /* If channel is not enabled, disable it on the tracer */
626 if (!ua_chan->enabled) {
627 ret = disable_ust_channel(app, ua_sess, ua_chan);
628 if (ret < 0) {
629 goto error;
630 }
631 }
632
633 error:
634 return ret;
635 }
636
637 /*
638 * Create the specified event onto the UST tracer for a UST session.
639 */
640 static
641 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
642 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
643 {
644 int ret = 0;
645
646 /* Create UST event on tracer */
647 ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj,
648 &ua_event->obj);
649 if (ret < 0) {
650 ERR("Error ustctl create event %s for app pid: %d with ret %d",
651 ua_event->attr.name, app->key.pid, ret);
652 goto error;
653 }
654
655 ua_event->handle = ua_event->obj->handle;
656
657 DBG2("UST app event %s created successfully for pid:%d",
658 ua_event->attr.name, app->key.pid);
659
660 /* If event not enabled, disable it on the tracer */
661 if (!ua_event->enabled) {
662 ret = disable_ust_event(app, ua_sess, ua_event);
663 if (ret < 0) {
664 goto error;
665 }
666 }
667
668 error:
669 return ret;
670 }
671
672 /*
673 * Copy data between an UST app event and a LTT event.
674 */
675 static void shadow_copy_event(struct ust_app_event *ua_event,
676 struct ltt_ust_event *uevent)
677 {
678 struct cds_lfht_iter iter;
679 struct ltt_ust_context *uctx;
680 struct ust_app_ctx *ua_ctx;
681
682 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
683 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
684
685 /* Copy event attributes */
686 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
687
688 cds_lfht_for_each_entry(uevent->ctx, &iter, uctx, node) {
689 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
690 if (ua_ctx == NULL) {
691 continue;
692 }
693 hashtable_node_init(&ua_ctx->node,
694 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
695 hashtable_add_unique(ua_event->ctx, &ua_ctx->node);
696 }
697 }
698
699 /*
700 * Copy data between an UST app channel and a LTT channel.
701 */
702 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
703 struct ltt_ust_channel *uchan)
704 {
705 struct cds_lfht_iter iter;
706 struct cds_lfht_node *ua_event_node;
707 struct ltt_ust_event *uevent;
708 struct ltt_ust_context *uctx;
709 struct ust_app_event *ua_event;
710 struct ust_app_ctx *ua_ctx;
711
712 DBG2("Shadow copy of UST app channel %s", ua_chan->name);
713
714 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
715 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
716 /* Copy event attributes */
717 memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr));
718
719 cds_lfht_for_each_entry(uchan->ctx, &iter, uctx, node) {
720 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
721 if (ua_ctx == NULL) {
722 continue;
723 }
724 hashtable_node_init(&ua_ctx->node,
725 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
726 hashtable_add_unique(ua_chan->ctx, &ua_ctx->node);
727 }
728
729 /* Copy all events from ltt ust channel to ust app channel */
730 cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
731 struct cds_lfht_iter uiter;
732
733 ua_event_node = hashtable_lookup(ua_chan->events,
734 (void *) uevent->attr.name, strlen(uevent->attr.name),
735 &uiter);
736 if (ua_event_node == NULL) {
737 DBG2("UST event %s not found on shadow copy channel",
738 uevent->attr.name);
739 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
740 if (ua_event == NULL) {
741 continue;
742 }
743 shadow_copy_event(ua_event, uevent);
744 hashtable_add_unique(ua_chan->events, &ua_event->node);
745 }
746 }
747
748 DBG3("Shadow copy channel done");
749 }
750
751 /*
752 * Copy data between a UST app session and a regular LTT session.
753 */
754 static void shadow_copy_session(struct ust_app_session *ua_sess,
755 struct ltt_ust_session *usess,
756 struct ust_app *app)
757 {
758 struct cds_lfht_node *ua_chan_node;
759 struct cds_lfht_iter iter;
760 struct ltt_ust_channel *uchan;
761 struct ust_app_channel *ua_chan;
762 time_t rawtime;
763 struct tm *timeinfo;
764 char datetime[16];
765 int ret;
766
767 /* Get date and time for unique app path */
768 time(&rawtime);
769 timeinfo = localtime(&rawtime);
770 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
771
772 DBG2("Shadow copy of session handle %d", ua_sess->handle);
773
774 ua_sess->id = usess->id;
775 ua_sess->uid = usess->uid;
776 ua_sess->gid = usess->gid;
777
778 ret = snprintf(ua_sess->path, PATH_MAX,
779 "%s/%s-%d-%s",
780 usess->pathname, app->name, app->key.pid,
781 datetime);
782 if (ret < 0) {
783 PERROR("asprintf UST shadow copy session");
784 /* TODO: We cannot return an error from here.. */
785 assert(0);
786 }
787
788 /* TODO: support all UST domain */
789
790 /* Iterate over all channels in global domain. */
791 cds_lfht_for_each_entry(usess->domain_global.channels, &iter,
792 uchan, node) {
793 struct cds_lfht_iter uiter;
794
795 ua_chan_node = hashtable_lookup(ua_sess->channels,
796 (void *)uchan->name, strlen(uchan->name),
797 &uiter);
798 if (ua_chan_node != NULL) {
799 continue;
800 }
801
802 DBG2("Channel %s not found on shadow session copy, creating it",
803 uchan->name);
804 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
805 if (ua_chan == NULL) {
806 /* malloc failed... continuing */
807 continue;
808 }
809
810 shadow_copy_channel(ua_chan, uchan);
811 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
812 }
813 }
814
815 /*
816 * Lookup sesison wrapper.
817 */
818 static
819 void __lookup_session_by_app(struct ltt_ust_session *usess,
820 struct ust_app *app, struct cds_lfht_iter *iter)
821 {
822 /* Get right UST app session from app */
823 (void) hashtable_lookup(app->sessions,
824 (void *) ((unsigned long) usess->id), sizeof(void *),
825 iter);
826 }
827
828 /*
829 * Return ust app session from the app session hashtable using the UST session
830 * id.
831 */
832 static struct ust_app_session *lookup_session_by_app(
833 struct ltt_ust_session *usess, struct ust_app *app)
834 {
835 struct cds_lfht_iter iter;
836 struct cds_lfht_node *node;
837
838 __lookup_session_by_app(usess, app, &iter);
839 node = hashtable_iter_get_node(&iter);
840 if (node == NULL) {
841 goto error;
842 }
843
844 return caa_container_of(node, struct ust_app_session, node);
845
846 error:
847 return NULL;
848 }
849
850 /*
851 * Create a UST session onto the tracer of app and add it the session
852 * hashtable.
853 *
854 * Return ust app session or NULL on error.
855 */
856 static struct ust_app_session *create_ust_app_session(
857 struct ltt_ust_session *usess, struct ust_app *app)
858 {
859 int ret;
860 struct ust_app_session *ua_sess;
861
862 ua_sess = lookup_session_by_app(usess, app);
863 if (ua_sess == NULL) {
864 DBG2("UST app pid: %d session id %d not found, creating it",
865 app->key.pid, usess->id);
866 ua_sess = alloc_ust_app_session();
867 if (ua_sess == NULL) {
868 /* Only malloc can failed so something is really wrong */
869 goto error;
870 }
871 shadow_copy_session(ua_sess, usess, app);
872 }
873
874 if (ua_sess->handle == -1) {
875 ret = ustctl_create_session(app->key.sock);
876 if (ret < 0) {
877 ERR("Error creating session for app pid %d, sock %d",
878 app->key.pid, app->key.sock);
879 /* TODO: free() ua_sess */
880 goto error;
881 }
882
883 DBG2("UST app ustctl create session handle %d", ret);
884 ua_sess->handle = ret;
885
886 /* Add ust app session to app's HT */
887 hashtable_node_init(&ua_sess->node,
888 (void *)((unsigned long) ua_sess->id), sizeof(void *));
889 hashtable_add_unique(app->sessions, &ua_sess->node);
890
891 DBG2("UST app session created successfully with handle %d", ret);
892 }
893
894 return ua_sess;
895
896 error:
897 return NULL;
898 }
899
900 /*
901 * Create a context for the channel on the tracer.
902 */
903 static
904 int create_ust_app_channel_context(struct ust_app_session *ua_sess,
905 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
906 struct ust_app *app)
907 {
908 int ret = 0;
909 struct cds_lfht_iter iter;
910 struct cds_lfht_node *node;
911 struct ust_app_ctx *ua_ctx;
912
913 DBG2("UST app adding context to channel %s", ua_chan->name);
914
915 node = hashtable_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx),
916 sizeof(void *), &iter);
917 if (node != NULL) {
918 ret = -EEXIST;
919 goto error;
920 }
921
922 ua_ctx = alloc_ust_app_ctx(uctx);
923 if (ua_ctx == NULL) {
924 /* malloc failed */
925 ret = -1;
926 goto error;
927 }
928
929 hashtable_node_init(&ua_ctx->node,
930 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
931 hashtable_add_unique(ua_chan->ctx, &ua_ctx->node);
932
933 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
934 if (ret < 0) {
935 goto error;
936 }
937
938 error:
939 return ret;
940 }
941
942 /*
943 * Create an UST context and enable it for the event on the tracer.
944 */
945 static
946 int create_ust_app_event_context(struct ust_app_session *ua_sess,
947 struct ust_app_event *ua_event, struct lttng_ust_context *uctx,
948 struct ust_app *app)
949 {
950 int ret = 0;
951 struct cds_lfht_iter iter;
952 struct cds_lfht_node *node;
953 struct ust_app_ctx *ua_ctx;
954
955 DBG2("UST app adding context to event %s", ua_event->name);
956
957 node = hashtable_lookup(ua_event->ctx, (void *)((unsigned long)uctx->ctx),
958 sizeof(void *), &iter);
959 if (node != NULL) {
960 ret = -EEXIST;
961 goto error;
962 }
963
964 ua_ctx = alloc_ust_app_ctx(uctx);
965 if (ua_ctx == NULL) {
966 /* malloc failed */
967 ret = -1;
968 goto error;
969 }
970
971 hashtable_node_init(&ua_ctx->node,
972 (void *)((unsigned long) ua_ctx->ctx.ctx), sizeof(void *));
973 hashtable_add_unique(ua_event->ctx, &ua_ctx->node);
974
975 ret = create_ust_event_context(ua_event, ua_ctx, app);
976 if (ret < 0) {
977 goto error;
978 }
979
980 error:
981 return ret;
982 }
983
984 /*
985 * Enable on the tracer side a ust app event for the session and channel.
986 */
987 static
988 int enable_ust_app_event(struct ust_app_session *ua_sess,
989 struct ust_app_event *ua_event, struct ust_app *app)
990 {
991 int ret;
992
993 ret = enable_ust_event(app, ua_sess, ua_event);
994 if (ret < 0) {
995 goto error;
996 }
997
998 ua_event->enabled = 1;
999
1000 error:
1001 return ret;
1002 }
1003
1004 /*
1005 * Disable on the tracer side a ust app event for the session and channel.
1006 */
1007 static int disable_ust_app_event(struct ust_app_session *ua_sess,
1008 struct ust_app_event *ua_event, struct ust_app *app)
1009 {
1010 int ret;
1011
1012 ret = disable_ust_event(app, ua_sess, ua_event);
1013 if (ret < 0) {
1014 goto error;
1015 }
1016
1017 ua_event->enabled = 0;
1018
1019 error:
1020 return ret;
1021 }
1022
1023 /*
1024 * Lookup ust app channel for session and disable it on the tracer side.
1025 */
1026 static
1027 int disable_ust_app_channel(struct ust_app_session *ua_sess,
1028 struct ust_app_channel *ua_chan, struct ust_app *app)
1029 {
1030 int ret;
1031
1032 ret = disable_ust_channel(app, ua_sess, ua_chan);
1033 if (ret < 0) {
1034 goto error;
1035 }
1036
1037 ua_chan->enabled = 0;
1038
1039 error:
1040 return ret;
1041 }
1042
1043 /*
1044 * Lookup ust app channel for session and enable it on the tracer side.
1045 */
1046 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
1047 struct ltt_ust_channel *uchan, struct ust_app *app)
1048 {
1049 int ret = 0;
1050 struct cds_lfht_iter iter;
1051 struct cds_lfht_node *ua_chan_node;
1052 struct ust_app_channel *ua_chan;
1053
1054 ua_chan_node = hashtable_lookup(ua_sess->channels,
1055 (void *)uchan->name, strlen(uchan->name), &iter);
1056 if (ua_chan_node == NULL) {
1057 DBG2("Unable to find channel %s in ust session id %u",
1058 uchan->name, ua_sess->id);
1059 goto error;
1060 }
1061
1062 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1063
1064 ret = enable_ust_channel(app, ua_sess, ua_chan);
1065 if (ret < 0) {
1066 goto error;
1067 }
1068
1069 error:
1070 return ret;
1071 }
1072
1073 /*
1074 * Create UST app channel and create it on the tracer.
1075 */
1076 static struct ust_app_channel *create_ust_app_channel(
1077 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
1078 struct ust_app *app)
1079 {
1080 int ret = 0;
1081 struct cds_lfht_iter iter;
1082 struct cds_lfht_node *ua_chan_node;
1083 struct ust_app_channel *ua_chan;
1084
1085 /* Lookup channel in the ust app session */
1086 ua_chan_node = hashtable_lookup(ua_sess->channels,
1087 (void *)uchan->name, strlen(uchan->name), &iter);
1088 if (ua_chan_node == NULL) {
1089 DBG2("Unable to find channel %s in ust session id %u",
1090 uchan->name, ua_sess->id);
1091 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
1092 if (ua_chan == NULL) {
1093 goto error;
1094 }
1095 shadow_copy_channel(ua_chan, uchan);
1096
1097 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
1098 } else {
1099 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1100 }
1101
1102 ret = create_ust_channel(app, ua_sess, ua_chan);
1103 if (ret < 0) {
1104 goto error;
1105 }
1106
1107 return ua_chan;
1108
1109 error:
1110 return NULL;
1111 }
1112
1113 /*
1114 * Create UST app event and create it on the tracer side.
1115 */
1116 static
1117 int create_ust_app_event(struct ust_app_session *ua_sess,
1118 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
1119 struct ust_app *app)
1120 {
1121 int ret = 0;
1122 struct cds_lfht_iter iter;
1123 struct cds_lfht_node *ua_event_node;
1124 struct ust_app_event *ua_event;
1125
1126 /* Get event node */
1127 ua_event_node = hashtable_lookup(ua_chan->events,
1128 (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
1129 if (ua_event_node != NULL) {
1130 ERR("UST app event %s already exist. Stopping creation.",
1131 uevent->attr.name);
1132 goto end;
1133 }
1134
1135 /* Does not exist so create one */
1136 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1137 if (ua_event == NULL) {
1138 /* Only malloc can failed so something is really wrong */
1139 ret = -ENOMEM;
1140 goto error;
1141 }
1142 shadow_copy_event(ua_event, uevent);
1143
1144 /* Create it on the tracer side */
1145 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1146 if (ret < 0) {
1147 rcu_read_lock();
1148 delete_ust_app_event(app->key.sock, ua_event);
1149 rcu_read_unlock();
1150 goto error;
1151 }
1152
1153 ua_event->enabled = 1;
1154
1155 hashtable_add_unique(ua_chan->events, &ua_event->node);
1156
1157 DBG2("UST app create event %s for PID %d completed",
1158 ua_event->name, app->key.pid);
1159
1160 end:
1161 error:
1162 return ret;
1163 }
1164
1165 /*
1166 * Create UST metadata and open it on the tracer side.
1167 */
1168 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
1169 char *pathname, struct ust_app *app)
1170 {
1171 int ret = 0;
1172
1173 if (ua_sess->metadata == NULL) {
1174 /* Allocate UST metadata */
1175 ua_sess->metadata = trace_ust_create_metadata(pathname);
1176 if (ua_sess->metadata == NULL) {
1177 ERR("UST app session %d creating metadata failed",
1178 ua_sess->handle);
1179 goto error;
1180 }
1181
1182 ret = open_ust_metadata(app, ua_sess);
1183 if (ret < 0) {
1184 goto error;
1185 }
1186
1187 DBG2("UST metadata opened for app pid %d", app->key.pid);
1188 }
1189
1190 /* Open UST metadata stream */
1191 if (ua_sess->metadata->stream_obj == NULL) {
1192 ret = create_ust_stream(app, ua_sess);
1193 if (ret < 0) {
1194 goto error;
1195 }
1196
1197 ret = mkdir_run_as(ua_sess->path, S_IRWXU | S_IRWXG,
1198 ua_sess->uid, ua_sess->gid);
1199 if (ret < 0) {
1200 PERROR("mkdir UST metadata");
1201 goto error;
1202 }
1203
1204 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
1205 "%s/metadata", ua_sess->path);
1206 if (ret < 0) {
1207 PERROR("asprintf UST create stream");
1208 goto error;
1209 }
1210
1211 DBG2("UST metadata stream object created for app pid %d",
1212 app->key.pid);
1213 } else {
1214 ERR("Attempting to create stream without metadata opened");
1215 goto error;
1216 }
1217
1218 return 0;
1219
1220 error:
1221 return -1;
1222 }
1223
1224 /*
1225 * Return pointer to traceable apps list.
1226 */
1227 struct cds_lfht *ust_app_get_ht(void)
1228 {
1229 return ust_app_ht;
1230 }
1231
1232 /*
1233 * Return ust app pointer or NULL if not found.
1234 */
1235 struct ust_app *ust_app_find_by_pid(pid_t pid)
1236 {
1237 struct cds_lfht_node *node;
1238 struct cds_lfht_iter iter;
1239
1240 rcu_read_lock();
1241 node = hashtable_lookup(ust_app_ht,
1242 (void *)((unsigned long) pid), sizeof(void *), &iter);
1243 if (node == NULL) {
1244 DBG2("UST app no found with pid %d", pid);
1245 goto error;
1246 }
1247 rcu_read_unlock();
1248
1249 DBG2("Found UST app by pid %d", pid);
1250
1251 return caa_container_of(node, struct ust_app, node);
1252
1253 error:
1254 rcu_read_unlock();
1255 return NULL;
1256 }
1257
1258 /*
1259 * Using pid and uid (of the app), allocate a new ust_app struct and
1260 * add it to the global traceable app list.
1261 *
1262 * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
1263 * bitness is not supported.
1264 */
1265 int ust_app_register(struct ust_register_msg *msg, int sock)
1266 {
1267 struct ust_app *lta;
1268
1269 if ((msg->bits_per_long == 64 && ust_consumerd64_fd == -EINVAL)
1270 || (msg->bits_per_long == 32 && ust_consumerd32_fd == -EINVAL)) {
1271 ERR("Registration failed: application \"%s\" (pid: %d) has "
1272 "%d-bit long, but no consumerd for this long size is available.\n",
1273 msg->name, msg->pid, msg->bits_per_long);
1274 close(sock);
1275 return -EINVAL;
1276 }
1277 lta = zmalloc(sizeof(struct ust_app));
1278 if (lta == NULL) {
1279 PERROR("malloc");
1280 return -ENOMEM;
1281 }
1282
1283 lta->ppid = msg->ppid;
1284 lta->uid = msg->uid;
1285 lta->gid = msg->gid;
1286 lta->bits_per_long = msg->bits_per_long;
1287 lta->v_major = msg->major;
1288 lta->v_minor = msg->minor;
1289 strncpy(lta->name, msg->name, sizeof(lta->name));
1290 lta->name[16] = '\0';
1291 lta->sessions = hashtable_new(0);
1292
1293 /* Set key map */
1294 lta->key.pid = msg->pid;
1295 hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
1296 sizeof(void *));
1297 lta->key.sock = sock;
1298 hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
1299 sizeof(void *));
1300
1301 rcu_read_lock();
1302 hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
1303 hashtable_add_unique(ust_app_ht, &lta->node);
1304 rcu_read_unlock();
1305
1306 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
1307 " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
1308 lta->key.sock, lta->name, lta->v_major, lta->v_minor);
1309
1310 return 0;
1311 }
1312
1313 /*
1314 * Unregister app by removing it from the global traceable app list and freeing
1315 * the data struct.
1316 *
1317 * The socket is already closed at this point so no close to sock.
1318 */
1319 void ust_app_unregister(int sock)
1320 {
1321 struct ust_app *lta;
1322 struct cds_lfht_node *node;
1323 struct cds_lfht_iter iter;
1324 int ret;
1325
1326 rcu_read_lock();
1327 lta = find_app_by_sock(sock);
1328 if (lta == NULL) {
1329 ERR("Unregister app sock %d not found!", sock);
1330 goto error;
1331 }
1332
1333 DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
1334
1335 /* Get the node reference for a call_rcu */
1336 node = hashtable_lookup(ust_app_ht,
1337 (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
1338 if (node == NULL) {
1339 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
1340 goto error;
1341 }
1342
1343 ret = hashtable_del(ust_app_ht, &iter);
1344 assert(!ret);
1345 call_rcu(&node->head, delete_ust_app_rcu);
1346 error:
1347 rcu_read_unlock();
1348 return;
1349 }
1350
1351 /*
1352 * Return traceable_app_count
1353 */
1354 unsigned long ust_app_list_count(void)
1355 {
1356 unsigned long count;
1357
1358 rcu_read_lock();
1359 count = hashtable_get_count(ust_app_ht);
1360 rcu_read_unlock();
1361
1362 return count;
1363 }
1364
1365 /*
1366 * Fill events array with all events name of all registered apps.
1367 */
1368 int ust_app_list_events(struct lttng_event **events)
1369 {
1370 int ret, handle;
1371 size_t nbmem, count = 0;
1372 struct cds_lfht_iter iter;
1373 struct ust_app *app;
1374 struct lttng_event *tmp;
1375
1376 nbmem = UST_APP_EVENT_LIST_SIZE;
1377 tmp = zmalloc(nbmem * sizeof(struct lttng_event));
1378 if (tmp == NULL) {
1379 PERROR("zmalloc ust app events");
1380 ret = -ENOMEM;
1381 goto error;
1382 }
1383
1384 rcu_read_lock();
1385
1386 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1387 struct lttng_ust_tracepoint_iter uiter;
1388
1389 handle = ustctl_tracepoint_list(app->key.sock);
1390 if (handle < 0) {
1391 ERR("UST app list events getting handle failed for app pid %d",
1392 app->key.pid);
1393 continue;
1394 }
1395
1396 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
1397 &uiter)) != -ENOENT) {
1398 if (count >= nbmem) {
1399 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
1400 2 * nbmem);
1401 nbmem *= 2;
1402 tmp = realloc(tmp, nbmem * sizeof(struct lttng_event));
1403 if (tmp == NULL) {
1404 PERROR("realloc ust app events");
1405 ret = -ENOMEM;
1406 goto rcu_error;
1407 }
1408 }
1409 memcpy(tmp[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
1410 memcpy(tmp[count].loglevel, uiter.loglevel, LTTNG_UST_SYM_NAME_LEN);
1411 tmp[count].loglevel_value = uiter.loglevel_value;
1412 tmp[count].type = LTTNG_UST_TRACEPOINT;
1413 tmp[count].pid = app->key.pid;
1414 tmp[count].enabled = -1;
1415 count++;
1416 }
1417 }
1418
1419 ret = count;
1420 *events = tmp;
1421
1422 DBG2("UST app list events done (%zu events)", count);
1423
1424 rcu_error:
1425 rcu_read_unlock();
1426 error:
1427 return ret;
1428 }
1429
1430 /*
1431 * Free and clean all traceable apps of the global list.
1432 */
1433 void ust_app_clean_list(void)
1434 {
1435 int ret;
1436 struct cds_lfht_iter iter;
1437 struct ust_app *app;
1438
1439 DBG2("UST app cleaning registered apps hash table");
1440
1441 rcu_read_lock();
1442
1443 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1444 ret = hashtable_del(ust_app_ht, &iter);
1445 assert(!ret);
1446 call_rcu(&iter.node->head, delete_ust_app_rcu);
1447 }
1448
1449 hashtable_destroy(ust_app_ht);
1450 hashtable_destroy(ust_app_sock_key_map);
1451
1452 rcu_read_unlock();
1453 }
1454
1455 /*
1456 * Init UST app hash table.
1457 */
1458 void ust_app_ht_alloc(void)
1459 {
1460 ust_app_ht = hashtable_new(0);
1461 ust_app_sock_key_map = hashtable_new(0);
1462 }
1463
1464 /*
1465 * For a specific UST session, disable the channel for all registered apps.
1466 */
1467 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
1468 struct ltt_ust_channel *uchan)
1469 {
1470 int ret = 0;
1471 struct cds_lfht_iter iter;
1472 struct cds_lfht_node *ua_chan_node;
1473 struct ust_app *app;
1474 struct ust_app_session *ua_sess;
1475 struct ust_app_channel *ua_chan;
1476
1477 if (usess == NULL || uchan == NULL) {
1478 ERR("Disabling UST global channel with NULL values");
1479 ret = -1;
1480 goto error;
1481 }
1482
1483 DBG2("UST app disabling channel %s from global domain for session id %d",
1484 uchan->name, usess->id);
1485
1486 rcu_read_lock();
1487
1488 /* For every registered applications */
1489 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1490 struct cds_lfht_iter uiter;
1491
1492 ua_sess = lookup_session_by_app(usess, app);
1493 if (ua_sess == NULL) {
1494 continue;
1495 }
1496
1497 /* Get channel */
1498 ua_chan_node = hashtable_lookup(ua_sess->channels,
1499 (void *)uchan->name, strlen(uchan->name), &uiter);
1500 /* If the session if found for the app, the channel must be there */
1501 assert(ua_chan_node);
1502
1503 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1504 /* The channel must not be already disabled */
1505 assert(ua_chan->enabled == 1);
1506
1507 /* Disable channel onto application */
1508 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
1509 if (ret < 0) {
1510 /* XXX: We might want to report this error at some point... */
1511 continue;
1512 }
1513 }
1514
1515 rcu_read_unlock();
1516
1517 error:
1518 return ret;
1519 }
1520
1521 /*
1522 * For a specific UST session, enable the channel for all registered apps.
1523 */
1524 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
1525 struct ltt_ust_channel *uchan)
1526 {
1527 int ret = 0;
1528 struct cds_lfht_iter iter;
1529 struct ust_app *app;
1530 struct ust_app_session *ua_sess;
1531
1532 if (usess == NULL || uchan == NULL) {
1533 ERR("Adding UST global channel to NULL values");
1534 ret = -1;
1535 goto error;
1536 }
1537
1538 DBG2("UST app enabling channel %s to global domain for session id %d",
1539 uchan->name, usess->id);
1540
1541 rcu_read_lock();
1542
1543 /* For every registered applications */
1544 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1545 ua_sess = lookup_session_by_app(usess, app);
1546 if (ua_sess == NULL) {
1547 continue;
1548 }
1549
1550 /* Enable channel onto application */
1551 ret = enable_ust_app_channel(ua_sess, uchan, app);
1552 if (ret < 0) {
1553 /* XXX: We might want to report this error at some point... */
1554 continue;
1555 }
1556 }
1557
1558 rcu_read_unlock();
1559
1560 error:
1561 return ret;
1562 }
1563
1564 /*
1565 * Disable an event in a channel and for a specific session.
1566 */
1567 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
1568 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1569 {
1570 int ret = 0;
1571 struct cds_lfht_iter iter;
1572 struct cds_lfht_node *ua_chan_node, *ua_event_node;
1573 struct ust_app *app;
1574 struct ust_app_session *ua_sess;
1575 struct ust_app_channel *ua_chan;
1576 struct ust_app_event *ua_event;
1577
1578 DBG("UST app disabling event %s for all apps in channel "
1579 "%s for session id %d", uevent->attr.name, uchan->name, usess->id);
1580
1581 rcu_read_lock();
1582
1583 /* For all registered applications */
1584 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1585 struct cds_lfht_iter uiter;
1586
1587 ua_sess = lookup_session_by_app(usess, app);
1588 if (ua_sess == NULL) {
1589 /* Next app */
1590 continue;
1591 }
1592
1593 /* Lookup channel in the ust app session */
1594 ua_chan_node = hashtable_lookup(ua_sess->channels,
1595 (void *)uchan->name, strlen(uchan->name), &uiter);
1596 if (ua_chan_node == NULL) {
1597 DBG2("Channel %s not found in session id %d for app pid %d."
1598 "Skipping", uchan->name, usess->id, app->key.pid);
1599 continue;
1600 }
1601 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1602
1603 ua_event_node = hashtable_lookup(ua_chan->events,
1604 (void *)uevent->attr.name, strlen(uevent->attr.name), &uiter);
1605 if (ua_event_node == NULL) {
1606 DBG2("Event %s not found in channel %s for app pid %d."
1607 "Skipping", uevent->attr.name, uchan->name, app->key.pid);
1608 continue;
1609 }
1610 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
1611
1612 ret = disable_ust_app_event(ua_sess, ua_event, app);
1613 if (ret < 0) {
1614 /* XXX: Report error someday... */
1615 continue;
1616 }
1617 }
1618
1619 rcu_read_unlock();
1620
1621 return ret;
1622 }
1623
1624 /*
1625 * For a specific UST session and UST channel, the event for all
1626 * registered apps.
1627 */
1628 int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
1629 struct ltt_ust_channel *uchan)
1630 {
1631 int ret = 0;
1632 struct cds_lfht_iter iter;
1633 struct cds_lfht_node *ua_chan_node;
1634 struct ust_app *app;
1635 struct ust_app_session *ua_sess;
1636 struct ust_app_channel *ua_chan;
1637 struct ust_app_event *ua_event;
1638
1639 DBG("UST app disabling all event for all apps in channel "
1640 "%s for session id %d", uchan->name, usess->id);
1641
1642 rcu_read_lock();
1643
1644 /* For all registered applications */
1645 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1646 struct cds_lfht_iter uiter;
1647
1648 ua_sess = lookup_session_by_app(usess, app);
1649 /* If ua_sess is NULL, there is a code flow error */
1650 assert(ua_sess);
1651
1652 /* Lookup channel in the ust app session */
1653 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1654 strlen(uchan->name), &uiter);
1655 /* If the channel is not found, there is a code flow error */
1656 assert(ua_chan_node);
1657
1658 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1659
1660 /* Disable each events of channel */
1661 cds_lfht_for_each_entry(ua_chan->events, &uiter, ua_event, node) {
1662 ret = disable_ust_app_event(ua_sess, ua_event, app);
1663 if (ret < 0) {
1664 /* XXX: Report error someday... */
1665 continue;
1666 }
1667 }
1668 }
1669
1670 rcu_read_unlock();
1671
1672 return ret;
1673 }
1674
1675 /*
1676 * For a specific UST session, create the channel for all registered apps.
1677 */
1678 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
1679 struct ltt_ust_channel *uchan)
1680 {
1681 int ret = 0;
1682 struct cds_lfht_iter iter;
1683 struct ust_app *app;
1684 struct ust_app_session *ua_sess;
1685 struct ust_app_channel *ua_chan;
1686
1687 if (usess == NULL || uchan == NULL) {
1688 ERR("Adding UST global channel to NULL values");
1689 ret = -1;
1690 goto error;
1691 }
1692
1693 DBG2("UST app adding channel %s to global domain for session id %d",
1694 uchan->name, usess->id);
1695
1696 rcu_read_lock();
1697
1698 /* For every registered applications */
1699 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1700 /*
1701 * Create session on the tracer side and add it to app session HT. Note
1702 * that if session exist, it will simply return a pointer to the ust
1703 * app session.
1704 */
1705 ua_sess = create_ust_app_session(usess, app);
1706 if (ua_sess == NULL) {
1707 continue;
1708 }
1709
1710 /* Create channel onto application */
1711 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
1712 if (ua_chan == NULL) {
1713 continue;
1714 }
1715 }
1716
1717 rcu_read_unlock();
1718
1719 error:
1720 return ret;
1721 }
1722
1723 /*
1724 * Enable event for a specific session and channel on the tracer.
1725 */
1726 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
1727 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1728 {
1729 int ret = 0;
1730 struct cds_lfht_iter iter;
1731 struct cds_lfht_node *ua_chan_node, *ua_event_node;
1732 struct ust_app *app;
1733 struct ust_app_session *ua_sess;
1734 struct ust_app_channel *ua_chan;
1735 struct ust_app_event *ua_event;
1736
1737 DBG("UST app enabling event %s for all apps for session id %d",
1738 uevent->attr.name, usess->id);
1739
1740 /*
1741 * NOTE: At this point, this function is called only if the session and
1742 * channel passed are already created for all apps. and enabled on the
1743 * tracer also.
1744 */
1745
1746 rcu_read_lock();
1747
1748 /* For all registered applications */
1749 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1750 struct cds_lfht_iter uiter;
1751
1752 ua_sess = lookup_session_by_app(usess, app);
1753 /* If ua_sess is NULL, there is a code flow error */
1754 assert(ua_sess);
1755
1756 /* Lookup channel in the ust app session */
1757 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1758 strlen(uchan->name), &uiter);
1759 /* If the channel is not found, there is a code flow error */
1760 assert(ua_chan_node);
1761
1762 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1763
1764 ua_event_node = hashtable_lookup(ua_chan->events,
1765 (void*)uevent->attr.name, strlen(uevent->attr.name), &uiter);
1766 if (ua_event_node == NULL) {
1767 DBG3("UST app enable event %s not found for app PID %d."
1768 "Skipping app", uevent->attr.name, app->key.pid);
1769 continue;
1770 }
1771 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
1772
1773 ret = enable_ust_app_event(ua_sess, ua_event, app);
1774 if (ret < 0) {
1775 goto error;
1776 }
1777 }
1778
1779 error:
1780 rcu_read_unlock();
1781 return ret;
1782 }
1783
1784 /*
1785 * For a specific existing UST session and UST channel, creates the event for
1786 * all registered apps.
1787 */
1788 int ust_app_create_event_glb(struct ltt_ust_session *usess,
1789 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1790 {
1791 int ret = 0;
1792 struct cds_lfht_iter iter;
1793 struct cds_lfht_node *ua_chan_node;
1794 struct ust_app *app;
1795 struct ust_app_session *ua_sess;
1796 struct ust_app_channel *ua_chan;
1797
1798 DBG("UST app creating event %s for all apps for session id %d",
1799 uevent->attr.name, usess->id);
1800
1801 /*
1802 * NOTE: At this point, this function is called only if the session and
1803 * channel passed are already created for all apps. and enabled on the
1804 * tracer also.
1805 */
1806
1807 rcu_read_lock();
1808
1809 /* For all registered applications */
1810 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
1811 struct cds_lfht_iter uiter;
1812
1813 ua_sess = lookup_session_by_app(usess, app);
1814 /* If ua_sess is NULL, there is a code flow error */
1815 assert(ua_sess);
1816
1817 /* Lookup channel in the ust app session */
1818 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
1819 strlen(uchan->name), &uiter);
1820 /* If the channel is not found, there is a code flow error */
1821 assert(ua_chan_node);
1822
1823 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1824
1825 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1826 if (ret < 0) {
1827 continue;
1828 }
1829 }
1830
1831 rcu_read_unlock();
1832
1833 return ret;
1834 }
1835
1836 /*
1837 * Start tracing for a specific UST session and app.
1838 */
1839 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
1840 {
1841 int ret = 0;
1842 struct cds_lfht_iter iter;
1843 struct ust_app_session *ua_sess;
1844 struct ust_app_channel *ua_chan;
1845 struct ltt_ust_stream *ustream;
1846 int consumerd_fd;
1847
1848 DBG("Starting tracing for ust app pid %d", app->key.pid);
1849
1850 rcu_read_lock();
1851
1852 ua_sess = lookup_session_by_app(usess, app);
1853 if (ua_sess == NULL) {
1854 goto error_rcu_unlock;
1855 }
1856
1857 /* Upon restart, we skip the setup, already done */
1858 if (ua_sess->started) {
1859 goto skip_setup;
1860 }
1861
1862 ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1863 if (ret < 0) {
1864 goto error_rcu_unlock;
1865 }
1866
1867 /* For each channel */
1868 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1869 /* Create all streams */
1870 while (1) {
1871 /* Create UST stream */
1872 ustream = zmalloc(sizeof(*ustream));
1873 if (ustream == NULL) {
1874 PERROR("zmalloc ust stream");
1875 goto error_rcu_unlock;
1876 }
1877
1878 ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1879 &ustream->obj);
1880 if (ret < 0) {
1881 /* Got all streams */
1882 break;
1883 }
1884 ustream->handle = ustream->obj->handle;
1885
1886 /* Order is important */
1887 cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1888 ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s_%u",
1889 ua_sess->path, ua_chan->name,
1890 ua_chan->streams.count++);
1891 if (ret < 0) {
1892 PERROR("asprintf UST create stream");
1893 continue;
1894 }
1895 DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1896 ustream->pathname);
1897 }
1898 }
1899
1900 switch (app->bits_per_long) {
1901 case 64:
1902 consumerd_fd = ust_consumerd64_fd;
1903 break;
1904 case 32:
1905 consumerd_fd = ust_consumerd32_fd;
1906 break;
1907 default:
1908 ret = -EINVAL;
1909 goto error_rcu_unlock;
1910 }
1911
1912 /* Setup UST consumer socket and send fds to it */
1913 ret = ust_consumer_send_session(consumerd_fd, ua_sess);
1914 if (ret < 0) {
1915 goto error_rcu_unlock;
1916 }
1917 ua_sess->started = 1;
1918
1919 skip_setup:
1920 /* This start the UST tracing */
1921 ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1922 if (ret < 0) {
1923 ERR("Error starting tracing for app pid: %d", app->key.pid);
1924 goto error_rcu_unlock;
1925 }
1926
1927 rcu_read_unlock();
1928
1929 /* Quiescent wait after starting trace */
1930 ustctl_wait_quiescent(app->key.sock);
1931
1932 return 0;
1933
1934 error_rcu_unlock:
1935 rcu_read_unlock();
1936 return -1;
1937 }
1938
1939 /*
1940 * Stop tracing for a specific UST session and app.
1941 */
1942 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
1943 {
1944 int ret = 0;
1945 struct cds_lfht_iter iter;
1946 struct ust_app_session *ua_sess;
1947 struct ust_app_channel *ua_chan;
1948
1949 DBG("Stopping tracing for ust app pid %d", app->key.pid);
1950
1951 rcu_read_lock();
1952
1953 ua_sess = lookup_session_by_app(usess, app);
1954 if (ua_sess == NULL) {
1955 /* Only malloc can failed so something is really wrong */
1956 goto error_rcu_unlock;
1957 }
1958
1959 /* This inhibits UST tracing */
1960 ret = ustctl_stop_session(app->key.sock, ua_sess->handle);
1961 if (ret < 0) {
1962 ERR("Error stopping tracing for app pid: %d", app->key.pid);
1963 goto error_rcu_unlock;
1964 }
1965
1966 /* Quiescent wait after stopping trace */
1967 ustctl_wait_quiescent(app->key.sock);
1968
1969 /* Flushing buffers */
1970 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1971 ret = ustctl_sock_flush_buffer(app->key.sock, ua_chan->obj);
1972 if (ret < 0) {
1973 ERR("UST app PID %d channel %s flush failed",
1974 app->key.pid, ua_chan->name);
1975 ERR("Ended with ret %d", ret);
1976 /* Continuing flushing all buffers */
1977 continue;
1978 }
1979 }
1980
1981 /* Flush all buffers before stopping */
1982 ret = ustctl_sock_flush_buffer(app->key.sock, ua_sess->metadata->obj);
1983 if (ret < 0) {
1984 ERR("UST app PID %d metadata flush failed", app->key.pid);
1985 ERR("Ended with ret %d", ret);
1986 }
1987
1988 rcu_read_unlock();
1989
1990 return 0;
1991
1992 error_rcu_unlock:
1993 rcu_read_unlock();
1994 return -1;
1995 }
1996
1997 /*
1998 * Destroy a specific UST session in apps.
1999 */
2000 int ust_app_destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
2001 {
2002 struct ust_app_session *ua_sess;
2003 struct lttng_ust_object_data obj;
2004 struct cds_lfht_iter iter;
2005 struct cds_lfht_node *node;
2006 int ret;
2007
2008 DBG("Destroy tracing for ust app pid %d", app->key.pid);
2009
2010 rcu_read_lock();
2011
2012 __lookup_session_by_app(usess, app, &iter);
2013 node = hashtable_iter_get_node(&iter);
2014 if (node == NULL) {
2015 /* Only malloc can failed so something is really wrong */
2016 goto error_rcu_unlock;
2017 }
2018 ua_sess = caa_container_of(node, struct ust_app_session, node);
2019 ret = hashtable_del(app->sessions, &iter);
2020 assert(!ret);
2021 delete_ust_app_session(app->key.sock, ua_sess);
2022 obj.handle = ua_sess->handle;
2023 obj.shm_fd = -1;
2024 obj.wait_fd = -1;
2025 obj.memory_map_size = 0;
2026 ustctl_release_object(app->key.sock, &obj);
2027
2028 rcu_read_unlock();
2029
2030 /* Quiescent wait after stopping trace */
2031 ustctl_wait_quiescent(app->key.sock);
2032
2033 return 0;
2034
2035 error_rcu_unlock:
2036 rcu_read_unlock();
2037 return -1;
2038 }
2039
2040 /*
2041 * Start tracing for the UST session.
2042 */
2043 int ust_app_start_trace_all(struct ltt_ust_session *usess)
2044 {
2045 int ret = 0;
2046 struct cds_lfht_iter iter;
2047 struct ust_app *app;
2048
2049 DBG("Starting all UST traces");
2050
2051 rcu_read_lock();
2052
2053 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2054 ret = ust_app_start_trace(usess, app);
2055 if (ret < 0) {
2056 /* Continue to next apps even on error */
2057 continue;
2058 }
2059 }
2060
2061 rcu_read_unlock();
2062
2063 return 0;
2064 }
2065
2066 /*
2067 * Start tracing for the UST session.
2068 */
2069 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
2070 {
2071 int ret = 0;
2072 struct cds_lfht_iter iter;
2073 struct ust_app *app;
2074
2075 DBG("Stopping all UST traces");
2076
2077 rcu_read_lock();
2078
2079 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2080 ret = ust_app_stop_trace(usess, app);
2081 if (ret < 0) {
2082 /* Continue to next apps even on error */
2083 continue;
2084 }
2085 }
2086
2087 rcu_read_unlock();
2088
2089 return 0;
2090 }
2091
2092 /*
2093 * Destroy app UST session.
2094 */
2095 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
2096 {
2097 int ret = 0;
2098 struct cds_lfht_iter iter;
2099 struct ust_app *app;
2100
2101 DBG("Destroy all UST traces");
2102
2103 rcu_read_lock();
2104
2105 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2106 ret = ust_app_destroy_trace(usess, app);
2107 if (ret < 0) {
2108 /* Continue to next apps even on error */
2109 continue;
2110 }
2111 }
2112
2113 rcu_read_unlock();
2114
2115 return 0;
2116 }
2117
2118 /*
2119 * Add channels/events from UST global domain to registered apps at sock.
2120 */
2121 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
2122 {
2123 int ret = 0;
2124 struct cds_lfht_iter iter;
2125 struct ust_app *app;
2126 struct ust_app_session *ua_sess;
2127 struct ust_app_channel *ua_chan;
2128 struct ust_app_event *ua_event;
2129
2130 if (usess == NULL) {
2131 ERR("No UST session on global update. Returning");
2132 goto error;
2133 }
2134
2135 DBG2("UST app global update for app sock %d for session id %d", sock,
2136 usess->id);
2137
2138 rcu_read_lock();
2139
2140 app = find_app_by_sock(sock);
2141 if (app == NULL) {
2142 ERR("Failed to update app sock %d", sock);
2143 goto error;
2144 }
2145
2146 ua_sess = create_ust_app_session(usess, app);
2147 if (ua_sess == NULL) {
2148 goto error;
2149 }
2150
2151 /*
2152 * We can iterate safely here over all UST app session sicne the create ust
2153 * app session above made a shadow copy of the UST global domain from the
2154 * ltt ust session.
2155 */
2156 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
2157 struct cds_lfht_iter uiter;
2158
2159 ret = create_ust_channel(app, ua_sess, ua_chan);
2160 if (ret < 0) {
2161 /* FIXME: Should we quit here or continue... */
2162 continue;
2163 }
2164
2165 /* For each events */
2166 cds_lfht_for_each_entry(ua_chan->events, &uiter, ua_event, node) {
2167 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
2168 if (ret < 0) {
2169 /* FIXME: Should we quit here or continue... */
2170 continue;
2171 }
2172 }
2173 }
2174
2175 if (usess->start_trace) {
2176 ret = ust_app_start_trace(usess, app);
2177 if (ret < 0) {
2178 goto error;
2179 }
2180
2181 DBG2("UST trace started for app pid %d", app->key.pid);
2182 }
2183
2184 error:
2185 rcu_read_unlock();
2186 return;
2187 }
2188
2189 /*
2190 * Add context to a specific channel for global UST domain.
2191 */
2192 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
2193 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
2194 {
2195 int ret = 0;
2196 struct cds_lfht_node *ua_chan_node;
2197 struct cds_lfht_iter iter;
2198 struct ust_app_channel *ua_chan = NULL;
2199 struct ust_app_session *ua_sess;
2200 struct ust_app *app;
2201
2202 rcu_read_lock();
2203
2204 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2205 struct cds_lfht_iter uiter;
2206
2207 ua_sess = lookup_session_by_app(usess, app);
2208 if (ua_sess == NULL) {
2209 continue;
2210 }
2211
2212 /* Lookup channel in the ust app session */
2213 ua_chan_node = hashtable_lookup(ua_sess->channels,
2214 (void *)uchan->name, strlen(uchan->name), &uiter);
2215 if (ua_chan_node == NULL) {
2216 continue;
2217 }
2218 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
2219 node);
2220
2221 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
2222 if (ret < 0) {
2223 continue;
2224 }
2225 }
2226
2227 rcu_read_unlock();
2228 return ret;
2229 }
2230
2231 /*
2232 * Add context to a specific event in a channel for global UST domain.
2233 */
2234 int ust_app_add_ctx_event_glb(struct ltt_ust_session *usess,
2235 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent,
2236 struct ltt_ust_context *uctx)
2237 {
2238 int ret = 0;
2239 struct cds_lfht_node *ua_chan_node, *ua_event_node;
2240 struct cds_lfht_iter iter;
2241 struct ust_app_session *ua_sess;
2242 struct ust_app_event *ua_event;
2243 struct ust_app_channel *ua_chan = NULL;
2244 struct ust_app *app;
2245
2246 rcu_read_lock();
2247
2248 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
2249 struct cds_lfht_iter uiter;
2250
2251 ua_sess = lookup_session_by_app(usess, app);
2252 if (ua_sess == NULL) {
2253 continue;
2254 }
2255
2256 /* Lookup channel in the ust app session */
2257 ua_chan_node = hashtable_lookup(ua_sess->channels,
2258 (void *)uchan->name, strlen(uchan->name), &uiter);
2259 if (ua_chan_node == NULL) {
2260 continue;
2261 }
2262 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
2263 node);
2264
2265 ua_event_node = hashtable_lookup(ua_chan->events,
2266 (void *)uevent->attr.name, strlen(uevent->attr.name), &uiter);
2267 if (ua_event_node == NULL) {
2268 continue;
2269 }
2270 ua_event = caa_container_of(ua_event_node, struct ust_app_event,
2271 node);
2272
2273 ret = create_ust_app_event_context(ua_sess, ua_event, &uctx->ctx, app);
2274 if (ret < 0) {
2275 continue;
2276 }
2277 }
2278
2279 rcu_read_unlock();
2280 return ret;
2281 }
2282
2283 /*
2284 * Enable event for a channel from a UST session for a specific PID.
2285 */
2286 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
2287 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2288 {
2289 int ret = 0;
2290 struct cds_lfht_iter iter;
2291 struct cds_lfht_node *ua_chan_node, *ua_event_node;
2292 struct ust_app *app;
2293 struct ust_app_session *ua_sess;
2294 struct ust_app_channel *ua_chan;
2295 struct ust_app_event *ua_event;
2296
2297 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
2298
2299 rcu_read_lock();
2300
2301 app = ust_app_find_by_pid(pid);
2302 if (app == NULL) {
2303 ERR("UST app enable event per PID %d not found", pid);
2304 ret = -1;
2305 goto error;
2306 }
2307
2308 ua_sess = lookup_session_by_app(usess, app);
2309 /* If ua_sess is NULL, there is a code flow error */
2310 assert(ua_sess);
2311
2312 /* Lookup channel in the ust app session */
2313 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
2314 strlen(uchan->name), &iter);
2315 /* If the channel is not found, there is a code flow error */
2316 assert(ua_chan_node);
2317
2318 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2319
2320 ua_event_node = hashtable_lookup(ua_chan->events,
2321 (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
2322 if (ua_event_node == NULL) {
2323 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
2324 if (ret < 0) {
2325 goto error;
2326 }
2327 } else {
2328 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2329
2330 ret = enable_ust_app_event(ua_sess, ua_event, app);
2331 if (ret < 0) {
2332 goto error;
2333 }
2334 }
2335
2336 error:
2337 rcu_read_unlock();
2338 return ret;
2339 }
2340
2341 /*
2342 * Disable event for a channel from a UST session for a specific PID.
2343 */
2344 int ust_app_disable_event_pid(struct ltt_ust_session *usess,
2345 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2346 {
2347 int ret = 0;
2348 struct cds_lfht_iter iter;
2349 struct cds_lfht_node *ua_chan_node, *ua_event_node;
2350 struct ust_app *app;
2351 struct ust_app_session *ua_sess;
2352 struct ust_app_channel *ua_chan;
2353 struct ust_app_event *ua_event;
2354
2355 DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
2356
2357 rcu_read_lock();
2358
2359 app = ust_app_find_by_pid(pid);
2360 if (app == NULL) {
2361 ERR("UST app disable event per PID %d not found", pid);
2362 ret = -1;
2363 goto error;
2364 }
2365
2366 ua_sess = lookup_session_by_app(usess, app);
2367 /* If ua_sess is NULL, there is a code flow error */
2368 assert(ua_sess);
2369
2370 /* Lookup channel in the ust app session */
2371 ua_chan_node = hashtable_lookup(ua_sess->channels, (void *)uchan->name,
2372 strlen(uchan->name), &iter);
2373 if (ua_chan_node == NULL) {
2374 /* Channel does not exist, skip disabling */
2375 goto error;
2376 }
2377 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2378
2379 ua_event_node = hashtable_lookup(ua_chan->events,
2380 (void*)uevent->attr.name, strlen(uevent->attr.name), &iter);
2381 if (ua_event_node == NULL) {
2382 /* Event does not exist, skip disabling */
2383 goto error;
2384 }
2385 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2386
2387 ret = disable_ust_app_event(ua_sess, ua_event, app);
2388 if (ret < 0) {
2389 goto error;
2390 }
2391
2392 error:
2393 rcu_read_unlock();
2394 return ret;
2395 }
This page took 0.080659 seconds and 4 git commands to generate.