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