f6f2c64ae9895958af62592b15cccee9b42527ff
[lttng-tools.git] / src / bin / 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 modify
5 * it under the terms of the GNU General Public License, version 2 only,
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
16 */
17
18 #define _GNU_SOURCE
19 #include <errno.h>
20 #include <pthread.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <unistd.h>
27 #include <urcu/compiler.h>
28 #include <lttng/ust-error.h>
29
30 #include <common/common.h>
31 #include <common/sessiond-comm/sessiond-comm.h>
32
33 #include "fd-limit.h"
34 #include "health.h"
35 #include "ust-app.h"
36 #include "ust-consumer.h"
37 #include "ust-ctl.h"
38
39 /*
40 * Match function for the hash table lookup.
41 *
42 * It matches an ust app event based on three attributes which are the event
43 * name, the filter bytecode and the loglevel.
44 */
45 static int ht_match_ust_app_event(struct cds_lfht_node *node, const void *_key)
46 {
47 struct ust_app_event *event;
48 const struct ust_app_ht_key *key;
49
50 assert(node);
51 assert(_key);
52
53 event = caa_container_of(node, struct ust_app_event, node.node);
54 key = _key;
55
56 /* Match the 3 elements of the key: name, filter and loglevel. */
57
58 /* Event name */
59 if (strncmp(event->attr.name, key->name, sizeof(event->attr.name)) != 0) {
60 goto no_match;
61 }
62
63 /* Event loglevel. */
64 if (event->attr.loglevel != key->loglevel) {
65 if (event->attr.loglevel_type == LTTNG_UST_LOGLEVEL_ALL
66 && key->loglevel == 0 && event->attr.loglevel == -1) {
67 /*
68 * Match is accepted. This is because on event creation, the
69 * loglevel is set to -1 if the event loglevel type is ALL so 0 and
70 * -1 are accepted for this loglevel type since 0 is the one set by
71 * the API when receiving an enable event.
72 */
73 } else {
74 goto no_match;
75 }
76 }
77
78 /* One of the filters is NULL, fail. */
79 if ((key->filter && !event->filter) || (!key->filter && event->filter)) {
80 goto no_match;
81 }
82
83 if (key->filter && event->filter) {
84 /* Both filters exists, check length followed by the bytecode. */
85 if (event->filter->len != key->filter->len ||
86 memcmp(event->filter->data, key->filter->data,
87 event->filter->len) != 0) {
88 goto no_match;
89 }
90 }
91
92 /* Match. */
93 return 1;
94
95 no_match:
96 return 0;
97 }
98
99 /*
100 * Unique add of an ust app event in the given ht. This uses the custom
101 * ht_match_ust_app_event match function and the event name as hash.
102 */
103 static void add_unique_ust_app_event(struct lttng_ht *ht,
104 struct ust_app_event *event)
105 {
106 struct cds_lfht_node *node_ptr;
107 struct ust_app_ht_key key;
108
109 assert(ht);
110 assert(ht->ht);
111 assert(event);
112
113 key.name = event->attr.name;
114 key.filter = event->filter;
115 key.loglevel = event->attr.loglevel;
116
117 node_ptr = cds_lfht_add_unique(ht->ht,
118 ht->hash_fct(event->node.key, lttng_ht_seed),
119 ht_match_ust_app_event, &key, &event->node.node);
120 assert(node_ptr == &event->node.node);
121 }
122
123 /*
124 * Delete ust context safely. RCU read lock must be held before calling
125 * this function.
126 */
127 static
128 void delete_ust_app_ctx(int sock, struct ust_app_ctx *ua_ctx)
129 {
130 if (ua_ctx->obj) {
131 ustctl_release_object(sock, ua_ctx->obj);
132 free(ua_ctx->obj);
133 }
134 free(ua_ctx);
135 }
136
137 /*
138 * Delete ust app event safely. RCU read lock must be held before calling
139 * this function.
140 */
141 static
142 void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
143 {
144 free(ua_event->filter);
145
146 if (ua_event->obj != NULL) {
147 ustctl_release_object(sock, ua_event->obj);
148 free(ua_event->obj);
149 }
150 free(ua_event);
151 }
152
153 /*
154 * Delete ust app stream safely. RCU read lock must be held before calling
155 * this function.
156 */
157 static
158 void delete_ust_app_stream(int sock, struct ust_app_stream *stream)
159 {
160 if (stream->obj) {
161 ustctl_release_object(sock, stream->obj);
162 lttng_fd_put(LTTNG_FD_APPS, 2);
163 free(stream->obj);
164 }
165 free(stream);
166 }
167
168 /*
169 * Delete ust app channel safely. RCU read lock must be held before calling
170 * this function.
171 */
172 static
173 void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
174 {
175 int ret;
176 struct lttng_ht_iter iter;
177 struct ust_app_event *ua_event;
178 struct ust_app_ctx *ua_ctx;
179 struct ust_app_stream *stream, *stmp;
180
181 /* Wipe stream */
182 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
183 cds_list_del(&stream->list);
184 delete_ust_app_stream(sock, stream);
185 }
186
187 /* Wipe context */
188 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter.iter, ua_ctx, node.node) {
189 ret = lttng_ht_del(ua_chan->ctx, &iter);
190 assert(!ret);
191 delete_ust_app_ctx(sock, ua_ctx);
192 }
193 lttng_ht_destroy(ua_chan->ctx);
194
195 /* Wipe events */
196 cds_lfht_for_each_entry(ua_chan->events->ht, &iter.iter, ua_event,
197 node.node) {
198 ret = lttng_ht_del(ua_chan->events, &iter);
199 assert(!ret);
200 delete_ust_app_event(sock, ua_event);
201 }
202 lttng_ht_destroy(ua_chan->events);
203
204 if (ua_chan->obj != NULL) {
205 ustctl_release_object(sock, ua_chan->obj);
206 lttng_fd_put(LTTNG_FD_APPS, 2);
207 free(ua_chan->obj);
208 }
209 free(ua_chan);
210 }
211
212 /*
213 * Delete ust app session safely. RCU read lock must be held before calling
214 * this function.
215 */
216 static
217 void delete_ust_app_session(int sock, struct ust_app_session *ua_sess)
218 {
219 int ret;
220 struct lttng_ht_iter iter;
221 struct ust_app_channel *ua_chan;
222
223 if (ua_sess->metadata) {
224 if (ua_sess->metadata->stream_obj) {
225 ustctl_release_object(sock, ua_sess->metadata->stream_obj);
226 lttng_fd_put(LTTNG_FD_APPS, 2);
227 free(ua_sess->metadata->stream_obj);
228 }
229 if (ua_sess->metadata->obj) {
230 ustctl_release_object(sock, ua_sess->metadata->obj);
231 lttng_fd_put(LTTNG_FD_APPS, 2);
232 free(ua_sess->metadata->obj);
233 }
234 trace_ust_destroy_metadata(ua_sess->metadata);
235 }
236
237 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
238 node.node) {
239 ret = lttng_ht_del(ua_sess->channels, &iter);
240 assert(!ret);
241 delete_ust_app_channel(sock, ua_chan);
242 }
243 lttng_ht_destroy(ua_sess->channels);
244
245 if (ua_sess->handle != -1) {
246 ustctl_release_handle(sock, ua_sess->handle);
247 }
248 free(ua_sess);
249 }
250
251 /*
252 * Delete a traceable application structure from the global list. Never call
253 * this function outside of a call_rcu call.
254 */
255 static
256 void delete_ust_app(struct ust_app *app)
257 {
258 int ret, sock;
259 struct ust_app_session *ua_sess, *tmp_ua_sess;
260
261 rcu_read_lock();
262
263 /* Delete ust app sessions info */
264 sock = app->sock;
265 app->sock = -1;
266
267 lttng_ht_destroy(app->sessions);
268
269 /* Wipe sessions */
270 cds_list_for_each_entry_safe(ua_sess, tmp_ua_sess, &app->teardown_head,
271 teardown_node) {
272 /* Free every object in the session and the session. */
273 delete_ust_app_session(sock, ua_sess);
274 }
275
276 /*
277 * Wait until we have deleted the application from the sock hash table
278 * before closing this socket, otherwise an application could re-use the
279 * socket ID and race with the teardown, using the same hash table entry.
280 *
281 * It's OK to leave the close in call_rcu. We want it to stay unique for
282 * all RCU readers that could run concurrently with unregister app,
283 * therefore we _need_ to only close that socket after a grace period. So
284 * it should stay in this RCU callback.
285 *
286 * This close() is a very important step of the synchronization model so
287 * every modification to this function must be carefully reviewed.
288 */
289 ret = close(sock);
290 if (ret) {
291 PERROR("close");
292 }
293 lttng_fd_put(LTTNG_FD_APPS, 1);
294
295 DBG2("UST app pid %d deleted", app->pid);
296 free(app);
297
298 rcu_read_unlock();
299 }
300
301 /*
302 * URCU intermediate call to delete an UST app.
303 */
304 static
305 void delete_ust_app_rcu(struct rcu_head *head)
306 {
307 struct lttng_ht_node_ulong *node =
308 caa_container_of(head, struct lttng_ht_node_ulong, head);
309 struct ust_app *app =
310 caa_container_of(node, struct ust_app, pid_n);
311
312 DBG3("Call RCU deleting app PID %d", app->pid);
313 delete_ust_app(app);
314 }
315
316 /*
317 * Alloc new UST app session.
318 */
319 static
320 struct ust_app_session *alloc_ust_app_session(void)
321 {
322 struct ust_app_session *ua_sess;
323
324 /* Init most of the default value by allocating and zeroing */
325 ua_sess = zmalloc(sizeof(struct ust_app_session));
326 if (ua_sess == NULL) {
327 PERROR("malloc");
328 goto error;
329 }
330
331 ua_sess->handle = -1;
332 ua_sess->channels = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
333
334 return ua_sess;
335
336 error:
337 return NULL;
338 }
339
340 /*
341 * Alloc new UST app channel.
342 */
343 static
344 struct ust_app_channel *alloc_ust_app_channel(char *name,
345 struct lttng_ust_channel *attr)
346 {
347 struct ust_app_channel *ua_chan;
348
349 /* Init most of the default value by allocating and zeroing */
350 ua_chan = zmalloc(sizeof(struct ust_app_channel));
351 if (ua_chan == NULL) {
352 PERROR("malloc");
353 goto error;
354 }
355
356 /* Setup channel name */
357 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
358 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
359
360 ua_chan->enabled = 1;
361 ua_chan->handle = -1;
362 ua_chan->ctx = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
363 ua_chan->events = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
364 lttng_ht_node_init_str(&ua_chan->node, ua_chan->name);
365
366 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
367
368 /* Copy attributes */
369 if (attr) {
370 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
371 }
372
373 DBG3("UST app channel %s allocated", ua_chan->name);
374
375 return ua_chan;
376
377 error:
378 return NULL;
379 }
380
381 /*
382 * Allocate and initialize a UST app stream.
383 *
384 * Return newly allocated stream pointer or NULL on error.
385 */
386 static struct ust_app_stream *alloc_ust_app_stream(void)
387 {
388 struct ust_app_stream *stream = NULL;
389
390 stream = zmalloc(sizeof(*stream));
391 if (stream == NULL) {
392 PERROR("zmalloc ust app stream");
393 goto error;
394 }
395
396 /* Zero could be a valid value for a handle so flag it to -1. */
397 stream->handle = -1;
398
399 error:
400 return stream;
401 }
402
403 /*
404 * Alloc new UST app event.
405 */
406 static
407 struct ust_app_event *alloc_ust_app_event(char *name,
408 struct lttng_ust_event *attr)
409 {
410 struct ust_app_event *ua_event;
411
412 /* Init most of the default value by allocating and zeroing */
413 ua_event = zmalloc(sizeof(struct ust_app_event));
414 if (ua_event == NULL) {
415 PERROR("malloc");
416 goto error;
417 }
418
419 ua_event->enabled = 1;
420 strncpy(ua_event->name, name, sizeof(ua_event->name));
421 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
422 lttng_ht_node_init_str(&ua_event->node, ua_event->name);
423
424 /* Copy attributes */
425 if (attr) {
426 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
427 }
428
429 DBG3("UST app event %s allocated", ua_event->name);
430
431 return ua_event;
432
433 error:
434 return NULL;
435 }
436
437 /*
438 * Alloc new UST app context.
439 */
440 static
441 struct ust_app_ctx *alloc_ust_app_ctx(struct lttng_ust_context *uctx)
442 {
443 struct ust_app_ctx *ua_ctx;
444
445 ua_ctx = zmalloc(sizeof(struct ust_app_ctx));
446 if (ua_ctx == NULL) {
447 goto error;
448 }
449
450 if (uctx) {
451 memcpy(&ua_ctx->ctx, uctx, sizeof(ua_ctx->ctx));
452 }
453
454 DBG3("UST app context %d allocated", ua_ctx->ctx.ctx);
455
456 error:
457 return ua_ctx;
458 }
459
460 /*
461 * Allocate a filter and copy the given original filter.
462 *
463 * Return allocated filter or NULL on error.
464 */
465 static struct lttng_ust_filter_bytecode *alloc_copy_ust_app_filter(
466 struct lttng_ust_filter_bytecode *orig_f)
467 {
468 struct lttng_ust_filter_bytecode *filter = NULL;
469
470 /* Copy filter bytecode */
471 filter = zmalloc(sizeof(*filter) + orig_f->len);
472 if (!filter) {
473 PERROR("zmalloc alloc ust app filter");
474 goto error;
475 }
476
477 memcpy(filter, orig_f, sizeof(*filter) + orig_f->len);
478
479 error:
480 return filter;
481 }
482
483 /*
484 * Find an ust_app using the sock and return it. RCU read side lock must be
485 * held before calling this helper function.
486 */
487 static
488 struct ust_app *find_app_by_sock(int sock)
489 {
490 struct lttng_ht_node_ulong *node;
491 struct lttng_ht_iter iter;
492
493 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
494 node = lttng_ht_iter_get_node_ulong(&iter);
495 if (node == NULL) {
496 DBG2("UST app find by sock %d not found", sock);
497 goto error;
498 }
499
500 return caa_container_of(node, struct ust_app, sock_n);
501
502 error:
503 return NULL;
504 }
505
506 /*
507 * Lookup for an ust app event based on event name, filter bytecode and the
508 * event loglevel.
509 *
510 * Return an ust_app_event object or NULL on error.
511 */
512 static struct ust_app_event *find_ust_app_event(struct lttng_ht *ht,
513 char *name, struct lttng_ust_filter_bytecode *filter, int loglevel)
514 {
515 struct lttng_ht_iter iter;
516 struct lttng_ht_node_str *node;
517 struct ust_app_event *event = NULL;
518 struct ust_app_ht_key key;
519
520 assert(name);
521 assert(ht);
522
523 /* Setup key for event lookup. */
524 key.name = name;
525 key.filter = filter;
526 key.loglevel = loglevel;
527
528 /* Lookup using the event name as hash and a custom match fct. */
529 cds_lfht_lookup(ht->ht, ht->hash_fct((void *) name, lttng_ht_seed),
530 ht_match_ust_app_event, &key, &iter.iter);
531 node = lttng_ht_iter_get_node_str(&iter);
532 if (node == NULL) {
533 goto end;
534 }
535
536 event = caa_container_of(node, struct ust_app_event, node);
537
538 end:
539 return event;
540 }
541
542 /*
543 * Create the channel context on the tracer.
544 */
545 static
546 int create_ust_channel_context(struct ust_app_channel *ua_chan,
547 struct ust_app_ctx *ua_ctx, struct ust_app *app)
548 {
549 int ret;
550
551 health_code_update(&health_thread_cmd);
552
553 ret = ustctl_add_context(app->sock, &ua_ctx->ctx,
554 ua_chan->obj, &ua_ctx->obj);
555 if (ret < 0) {
556 goto error;
557 }
558
559 ua_ctx->handle = ua_ctx->obj->handle;
560
561 DBG2("UST app context created successfully for channel %s", ua_chan->name);
562
563 error:
564 health_code_update(&health_thread_cmd);
565 return ret;
566 }
567
568 /*
569 * Set the filter on the tracer.
570 */
571 static
572 int set_ust_event_filter(struct ust_app_event *ua_event,
573 struct ust_app *app)
574 {
575 int ret;
576
577 health_code_update(&health_thread_cmd);
578
579 if (!ua_event->filter) {
580 ret = 0;
581 goto error;
582 }
583
584 ret = ustctl_set_filter(app->sock, ua_event->filter,
585 ua_event->obj);
586 if (ret < 0) {
587 goto error;
588 }
589
590 DBG2("UST filter set successfully for event %s", ua_event->name);
591
592 error:
593 health_code_update(&health_thread_cmd);
594 return ret;
595 }
596
597 /*
598 * Disable the specified event on to UST tracer for the UST session.
599 */
600 static int disable_ust_event(struct ust_app *app,
601 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
602 {
603 int ret;
604
605 health_code_update(&health_thread_cmd);
606
607 ret = ustctl_disable(app->sock, ua_event->obj);
608 if (ret < 0) {
609 ERR("UST app event %s disable failed for app (pid: %d) "
610 "and session handle %d with ret %d",
611 ua_event->attr.name, app->pid, ua_sess->handle, ret);
612 goto error;
613 }
614
615 DBG2("UST app event %s disabled successfully for app (pid: %d)",
616 ua_event->attr.name, app->pid);
617
618 error:
619 health_code_update(&health_thread_cmd);
620 return ret;
621 }
622
623 /*
624 * Disable the specified channel on to UST tracer for the UST session.
625 */
626 static int disable_ust_channel(struct ust_app *app,
627 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
628 {
629 int ret;
630
631 health_code_update(&health_thread_cmd);
632
633 ret = ustctl_disable(app->sock, ua_chan->obj);
634 if (ret < 0) {
635 ERR("UST app channel %s disable failed for app (pid: %d) "
636 "and session handle %d with ret %d",
637 ua_chan->name, app->pid, ua_sess->handle, ret);
638 goto error;
639 }
640
641 DBG2("UST app channel %s disabled successfully for app (pid: %d)",
642 ua_chan->name, app->pid);
643
644 error:
645 health_code_update(&health_thread_cmd);
646 return ret;
647 }
648
649 /*
650 * Enable the specified channel on to UST tracer for the UST session.
651 */
652 static int enable_ust_channel(struct ust_app *app,
653 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
654 {
655 int ret;
656
657 health_code_update(&health_thread_cmd);
658
659 ret = ustctl_enable(app->sock, ua_chan->obj);
660 if (ret < 0) {
661 ERR("UST app channel %s enable failed for app (pid: %d) "
662 "and session handle %d with ret %d",
663 ua_chan->name, app->pid, ua_sess->handle, ret);
664 goto error;
665 }
666
667 ua_chan->enabled = 1;
668
669 DBG2("UST app channel %s enabled successfully for app (pid: %d)",
670 ua_chan->name, app->pid);
671
672 error:
673 health_code_update(&health_thread_cmd);
674 return ret;
675 }
676
677 /*
678 * Enable the specified event on to UST tracer for the UST session.
679 */
680 static int enable_ust_event(struct ust_app *app,
681 struct ust_app_session *ua_sess, struct ust_app_event *ua_event)
682 {
683 int ret;
684
685 health_code_update(&health_thread_cmd);
686
687 ret = ustctl_enable(app->sock, ua_event->obj);
688 if (ret < 0) {
689 ERR("UST app event %s enable failed for app (pid: %d) "
690 "and session handle %d with ret %d",
691 ua_event->attr.name, app->pid, ua_sess->handle, ret);
692 goto error;
693 }
694
695 DBG2("UST app event %s enabled successfully for app (pid: %d)",
696 ua_event->attr.name, app->pid);
697
698 error:
699 health_code_update(&health_thread_cmd);
700 return ret;
701 }
702
703 /*
704 * Open metadata onto the UST tracer for a UST session.
705 */
706 static int open_ust_metadata(struct ust_app *app,
707 struct ust_app_session *ua_sess)
708 {
709 int ret;
710 struct lttng_ust_channel_attr uattr;
711
712 health_code_update(&health_thread_cmd);
713
714 uattr.overwrite = ua_sess->metadata->attr.overwrite;
715 uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
716 uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
717 uattr.switch_timer_interval =
718 ua_sess->metadata->attr.switch_timer_interval;
719 uattr.read_timer_interval =
720 ua_sess->metadata->attr.read_timer_interval;
721 uattr.output = ua_sess->metadata->attr.output;
722
723 /* We are going to receive 2 fds, we need to reserve them. */
724 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
725 if (ret < 0) {
726 ERR("Exhausted number of available FD upon metadata open");
727 goto error;
728 }
729 /* UST tracer metadata creation */
730 ret = ustctl_open_metadata(app->sock, ua_sess->handle, &uattr,
731 &ua_sess->metadata->obj);
732 if (ret < 0) {
733 ERR("UST app open metadata failed for app pid:%d with ret %d",
734 app->pid, ret);
735 goto error;
736 }
737
738 ua_sess->metadata->handle = ua_sess->metadata->obj->handle;
739
740 error:
741 health_code_update(&health_thread_cmd);
742 return ret;
743 }
744
745 /*
746 * Create metadata stream onto the UST tracer for a given session.
747 */
748 static int create_ust_metadata_stream(struct ust_app *app,
749 struct ust_app_session *ua_sess)
750 {
751 int ret;
752
753 health_code_update(&health_thread_cmd);
754
755 /* We are going to receive 2 fds, we need to reserve them. */
756 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
757 if (ret < 0) {
758 ERR("Exhausted number of available FD upon metadata stream create");
759 goto error;
760 }
761 ret = ustctl_create_stream(app->sock, ua_sess->metadata->obj,
762 &ua_sess->metadata->stream_obj);
763 if (ret < 0) {
764 lttng_fd_put(LTTNG_FD_APPS, 2);
765 ERR("UST create metadata stream failed");
766 goto error;
767 }
768
769 error:
770 health_code_update(&health_thread_cmd);
771 return ret;
772 }
773
774 /*
775 * Create stream onto the UST tracer for a given channel.
776 *
777 * Return -ENOENT if no more stream is available for this channel.
778 * On success, return 0.
779 * On error, return a negative value.
780 */
781 static int create_ust_stream(struct ust_app *app,
782 struct ust_app_channel *ua_chan, struct ust_app_stream *stream)
783 {
784 int ret;
785
786 assert(app);
787 assert(ua_chan);
788 assert(ua_chan->obj);
789 assert(stream);
790
791 health_code_update(&health_thread_cmd);
792
793 /* We are going to receive 2 fds, we need to reserve them. */
794 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
795 if (ret < 0) {
796 ERR("Exhausted number of available FD on stream creation");
797 /* Just to make sure we never return -ENOENT. */
798 ret = -1;
799 goto error;
800 }
801
802 /*
803 * Set the stream name before creating it. On error, we don't have to
804 * delete it on the tracer side.
805 */
806 ret = snprintf(stream->name, sizeof(stream->name), "%s_%u",
807 ua_chan->name, ua_chan->streams.count);
808 if (ret < 0) {
809 /* Without the stream name we can't continue using it. */
810 PERROR("snprintf UST create stream");
811 /* Just to make sure we never return -ENOENT. */
812 ret = -1;
813 goto error;
814 }
815
816 ret = ustctl_create_stream(app->sock, ua_chan->obj, &stream->obj);
817 if (ret < 0) {
818 lttng_fd_put(LTTNG_FD_APPS, 2);
819 /* Indicates that there is no more stream for that channel. */
820 if (ret != -LTTNG_UST_ERR_NOENT) {
821 ERR("UST create metadata stream failed (ret: %d)", ret);
822 }
823 goto error;
824 }
825
826 /* Set stream handle with the returned value. */
827 stream->handle = stream->obj->handle;
828
829 error:
830 health_code_update(&health_thread_cmd);
831 return ret;
832 }
833
834 /*
835 * Create the specified channel onto the UST tracer for a UST session.
836 */
837 static int create_ust_channel(struct ust_app *app,
838 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
839 {
840 int ret;
841
842 health_code_update(&health_thread_cmd);
843
844 /* TODO: remove cast and use lttng-ust-abi.h */
845
846 /* We are going to receive 2 fds, we need to reserve them. */
847 ret = lttng_fd_get(LTTNG_FD_APPS, 2);
848 if (ret < 0) {
849 ERR("Exhausted number of available FD upon create channel");
850 goto error;
851 }
852
853 health_code_update(&health_thread_cmd);
854
855 ret = ustctl_create_channel(app->sock, ua_sess->handle,
856 (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
857 if (ret < 0) {
858 ERR("Creating channel %s for app (pid: %d, sock: %d) "
859 "and session handle %d with ret %d",
860 ua_chan->name, app->pid, app->sock,
861 ua_sess->handle, ret);
862 lttng_fd_put(LTTNG_FD_APPS, 2);
863 goto error;
864 }
865
866 ua_chan->handle = ua_chan->obj->handle;
867
868 DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
869 ua_chan->name, app->pid, app->sock);
870
871 health_code_update(&health_thread_cmd);
872
873 /* If channel is not enabled, disable it on the tracer */
874 if (!ua_chan->enabled) {
875 ret = disable_ust_channel(app, ua_sess, ua_chan);
876 if (ret < 0) {
877 goto error;
878 }
879 }
880
881 error:
882 health_code_update(&health_thread_cmd);
883 return ret;
884 }
885
886 /*
887 * Create the specified event onto the UST tracer for a UST session.
888 */
889 static
890 int create_ust_event(struct ust_app *app, struct ust_app_session *ua_sess,
891 struct ust_app_channel *ua_chan, struct ust_app_event *ua_event)
892 {
893 int ret = 0;
894
895 health_code_update(&health_thread_cmd);
896
897 /* Create UST event on tracer */
898 ret = ustctl_create_event(app->sock, &ua_event->attr, ua_chan->obj,
899 &ua_event->obj);
900 if (ret < 0) {
901 ERR("Error ustctl create event %s for app pid: %d with ret %d",
902 ua_event->attr.name, app->pid, ret);
903 goto error;
904 }
905
906 ua_event->handle = ua_event->obj->handle;
907
908 DBG2("UST app event %s created successfully for pid:%d",
909 ua_event->attr.name, app->pid);
910
911 health_code_update(&health_thread_cmd);
912
913 /* Set filter if one is present. */
914 if (ua_event->filter) {
915 ret = set_ust_event_filter(ua_event, app);
916 if (ret < 0) {
917 goto error;
918 }
919 }
920
921 /* If event not enabled, disable it on the tracer */
922 if (ua_event->enabled == 0) {
923 ret = disable_ust_event(app, ua_sess, ua_event);
924 if (ret < 0) {
925 /*
926 * If we hit an EPERM, something is wrong with our disable call. If
927 * we get an EEXIST, there is a problem on the tracer side since we
928 * just created it.
929 */
930 switch (ret) {
931 case -LTTNG_UST_ERR_PERM:
932 /* Code flow problem */
933 assert(0);
934 case -LTTNG_UST_ERR_EXIST:
935 /* It's OK for our use case. */
936 ret = 0;
937 break;
938 default:
939 break;
940 }
941 goto error;
942 }
943 }
944
945 error:
946 health_code_update(&health_thread_cmd);
947 return ret;
948 }
949
950 /*
951 * Copy data between an UST app event and a LTT event.
952 */
953 static void shadow_copy_event(struct ust_app_event *ua_event,
954 struct ltt_ust_event *uevent)
955 {
956 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
957 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
958
959 ua_event->enabled = uevent->enabled;
960
961 /* Copy event attributes */
962 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
963
964 /* Copy filter bytecode */
965 if (uevent->filter) {
966 ua_event->filter = alloc_copy_ust_app_filter(uevent->filter);
967 /* Filter might be NULL here in case of ENONEM. */
968 }
969 }
970
971 /*
972 * Copy data between an UST app channel and a LTT channel.
973 */
974 static void shadow_copy_channel(struct ust_app_channel *ua_chan,
975 struct ltt_ust_channel *uchan)
976 {
977 struct lttng_ht_iter iter;
978 struct ltt_ust_event *uevent;
979 struct ltt_ust_context *uctx;
980 struct ust_app_event *ua_event;
981 struct ust_app_ctx *ua_ctx;
982
983 DBG2("UST app shadow copy of channel %s started", ua_chan->name);
984
985 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
986 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
987 /* Copy event attributes */
988 memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr));
989
990 ua_chan->enabled = uchan->enabled;
991
992 cds_lfht_for_each_entry(uchan->ctx->ht, &iter.iter, uctx, node.node) {
993 ua_ctx = alloc_ust_app_ctx(&uctx->ctx);
994 if (ua_ctx == NULL) {
995 continue;
996 }
997 lttng_ht_node_init_ulong(&ua_ctx->node,
998 (unsigned long) ua_ctx->ctx.ctx);
999 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
1000 }
1001
1002 /* Copy all events from ltt ust channel to ust app channel */
1003 cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent, node.node) {
1004 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1005 uevent->filter, uevent->attr.loglevel);
1006 if (ua_event == NULL) {
1007 DBG2("UST event %s not found on shadow copy channel",
1008 uevent->attr.name);
1009 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1010 if (ua_event == NULL) {
1011 continue;
1012 }
1013 shadow_copy_event(ua_event, uevent);
1014 add_unique_ust_app_event(ua_chan->events, ua_event);
1015 }
1016 }
1017
1018 DBG3("UST app shadow copy of channel %s done", ua_chan->name);
1019 }
1020
1021 /*
1022 * Copy data between a UST app session and a regular LTT session.
1023 */
1024 static void shadow_copy_session(struct ust_app_session *ua_sess,
1025 struct ltt_ust_session *usess, struct ust_app *app)
1026 {
1027 struct lttng_ht_node_str *ua_chan_node;
1028 struct lttng_ht_iter iter;
1029 struct ltt_ust_channel *uchan;
1030 struct ust_app_channel *ua_chan;
1031 time_t rawtime;
1032 struct tm *timeinfo;
1033 char datetime[16];
1034 int ret;
1035
1036 /* Get date and time for unique app path */
1037 time(&rawtime);
1038 timeinfo = localtime(&rawtime);
1039 strftime(datetime, sizeof(datetime), "%Y%m%d-%H%M%S", timeinfo);
1040
1041 DBG2("Shadow copy of session handle %d", ua_sess->handle);
1042
1043 ua_sess->id = usess->id;
1044 ua_sess->uid = usess->uid;
1045 ua_sess->gid = usess->gid;
1046
1047 ret = snprintf(ua_sess->path, PATH_MAX, "%s-%d-%s/", app->name, app->pid,
1048 datetime);
1049 if (ret < 0) {
1050 PERROR("asprintf UST shadow copy session");
1051 /* TODO: We cannot return an error from here.. */
1052 assert(0);
1053 }
1054
1055 /* TODO: support all UST domain */
1056
1057 /* Iterate over all channels in global domain. */
1058 cds_lfht_for_each_entry(usess->domain_global.channels->ht, &iter.iter,
1059 uchan, node.node) {
1060 struct lttng_ht_iter uiter;
1061
1062 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1063 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
1064 if (ua_chan_node != NULL) {
1065 /* Session exist. Contiuing. */
1066 continue;
1067 }
1068
1069 DBG2("Channel %s not found on shadow session copy, creating it",
1070 uchan->name);
1071 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
1072 if (ua_chan == NULL) {
1073 /* malloc failed FIXME: Might want to do handle ENOMEM .. */
1074 continue;
1075 }
1076
1077 shadow_copy_channel(ua_chan, uchan);
1078 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
1079 }
1080 }
1081
1082 /*
1083 * Lookup sesison wrapper.
1084 */
1085 static
1086 void __lookup_session_by_app(struct ltt_ust_session *usess,
1087 struct ust_app *app, struct lttng_ht_iter *iter)
1088 {
1089 /* Get right UST app session from app */
1090 lttng_ht_lookup(app->sessions, (void *)((unsigned long) usess->id), iter);
1091 }
1092
1093 /*
1094 * Return ust app session from the app session hashtable using the UST session
1095 * id.
1096 */
1097 static struct ust_app_session *lookup_session_by_app(
1098 struct ltt_ust_session *usess, struct ust_app *app)
1099 {
1100 struct lttng_ht_iter iter;
1101 struct lttng_ht_node_ulong *node;
1102
1103 __lookup_session_by_app(usess, app, &iter);
1104 node = lttng_ht_iter_get_node_ulong(&iter);
1105 if (node == NULL) {
1106 goto error;
1107 }
1108
1109 return caa_container_of(node, struct ust_app_session, node);
1110
1111 error:
1112 return NULL;
1113 }
1114
1115 /*
1116 * Create a session on the tracer side for the given app.
1117 *
1118 * On success, ua_sess_ptr is populated with the session pointer or else left
1119 * untouched. If the session was created, is_created is set to 1. On error,
1120 * it's left untouched. Note that ua_sess_ptr is mandatory but is_created can
1121 * be NULL.
1122 *
1123 * Returns 0 on success or else a negative code which is either -ENOMEM or
1124 * -ENOTCONN which is the default code if the ustctl_create_session fails.
1125 */
1126 static int create_ust_app_session(struct ltt_ust_session *usess,
1127 struct ust_app *app, struct ust_app_session **ua_sess_ptr,
1128 int *is_created)
1129 {
1130 int ret, created = 0;
1131 struct ust_app_session *ua_sess;
1132
1133 assert(usess);
1134 assert(app);
1135 assert(ua_sess_ptr);
1136
1137 health_code_update(&health_thread_cmd);
1138
1139 ua_sess = lookup_session_by_app(usess, app);
1140 if (ua_sess == NULL) {
1141 DBG2("UST app pid: %d session id %d not found, creating it",
1142 app->pid, usess->id);
1143 ua_sess = alloc_ust_app_session();
1144 if (ua_sess == NULL) {
1145 /* Only malloc can failed so something is really wrong */
1146 ret = -ENOMEM;
1147 goto error;
1148 }
1149 shadow_copy_session(ua_sess, usess, app);
1150 created = 1;
1151 }
1152
1153 health_code_update(&health_thread_cmd);
1154
1155 if (ua_sess->handle == -1) {
1156 ret = ustctl_create_session(app->sock);
1157 if (ret < 0) {
1158 ERR("Creating session for app pid %d", app->pid);
1159 delete_ust_app_session(-1, ua_sess);
1160 if (ret != -ENOMEM) {
1161 /*
1162 * Tracer is probably gone or got an internal error so let's
1163 * behave like it will soon unregister or not usable.
1164 */
1165 ret = -ENOTCONN;
1166 }
1167 goto error;
1168 }
1169
1170 ua_sess->handle = ret;
1171
1172 /* Add ust app session to app's HT */
1173 lttng_ht_node_init_ulong(&ua_sess->node, (unsigned long) ua_sess->id);
1174 lttng_ht_add_unique_ulong(app->sessions, &ua_sess->node);
1175
1176 DBG2("UST app session created successfully with handle %d", ret);
1177 }
1178
1179 *ua_sess_ptr = ua_sess;
1180 if (is_created) {
1181 *is_created = created;
1182 }
1183 /* Everything went well. */
1184 ret = 0;
1185
1186 error:
1187 health_code_update(&health_thread_cmd);
1188 return ret;
1189 }
1190
1191 /*
1192 * Create a context for the channel on the tracer.
1193 */
1194 static
1195 int create_ust_app_channel_context(struct ust_app_session *ua_sess,
1196 struct ust_app_channel *ua_chan, struct lttng_ust_context *uctx,
1197 struct ust_app *app)
1198 {
1199 int ret = 0;
1200 struct lttng_ht_iter iter;
1201 struct lttng_ht_node_ulong *node;
1202 struct ust_app_ctx *ua_ctx;
1203
1204 DBG2("UST app adding context to channel %s", ua_chan->name);
1205
1206 lttng_ht_lookup(ua_chan->ctx, (void *)((unsigned long)uctx->ctx), &iter);
1207 node = lttng_ht_iter_get_node_ulong(&iter);
1208 if (node != NULL) {
1209 ret = -EEXIST;
1210 goto error;
1211 }
1212
1213 ua_ctx = alloc_ust_app_ctx(uctx);
1214 if (ua_ctx == NULL) {
1215 /* malloc failed */
1216 ret = -1;
1217 goto error;
1218 }
1219
1220 lttng_ht_node_init_ulong(&ua_ctx->node, (unsigned long) ua_ctx->ctx.ctx);
1221 lttng_ht_add_unique_ulong(ua_chan->ctx, &ua_ctx->node);
1222
1223 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
1224 if (ret < 0) {
1225 goto error;
1226 }
1227
1228 error:
1229 return ret;
1230 }
1231
1232 /*
1233 * Enable on the tracer side a ust app event for the session and channel.
1234 */
1235 static
1236 int enable_ust_app_event(struct ust_app_session *ua_sess,
1237 struct ust_app_event *ua_event, struct ust_app *app)
1238 {
1239 int ret;
1240
1241 ret = enable_ust_event(app, ua_sess, ua_event);
1242 if (ret < 0) {
1243 goto error;
1244 }
1245
1246 ua_event->enabled = 1;
1247
1248 error:
1249 return ret;
1250 }
1251
1252 /*
1253 * Disable on the tracer side a ust app event for the session and channel.
1254 */
1255 static int disable_ust_app_event(struct ust_app_session *ua_sess,
1256 struct ust_app_event *ua_event, struct ust_app *app)
1257 {
1258 int ret;
1259
1260 ret = disable_ust_event(app, ua_sess, ua_event);
1261 if (ret < 0) {
1262 goto error;
1263 }
1264
1265 ua_event->enabled = 0;
1266
1267 error:
1268 return ret;
1269 }
1270
1271 /*
1272 * Lookup ust app channel for session and disable it on the tracer side.
1273 */
1274 static
1275 int disable_ust_app_channel(struct ust_app_session *ua_sess,
1276 struct ust_app_channel *ua_chan, struct ust_app *app)
1277 {
1278 int ret;
1279
1280 ret = disable_ust_channel(app, ua_sess, ua_chan);
1281 if (ret < 0) {
1282 goto error;
1283 }
1284
1285 ua_chan->enabled = 0;
1286
1287 error:
1288 return ret;
1289 }
1290
1291 /*
1292 * Lookup ust app channel for session and enable it on the tracer side.
1293 */
1294 static int enable_ust_app_channel(struct ust_app_session *ua_sess,
1295 struct ltt_ust_channel *uchan, struct ust_app *app)
1296 {
1297 int ret = 0;
1298 struct lttng_ht_iter iter;
1299 struct lttng_ht_node_str *ua_chan_node;
1300 struct ust_app_channel *ua_chan;
1301
1302 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
1303 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
1304 if (ua_chan_node == NULL) {
1305 DBG2("Unable to find channel %s in ust session id %u",
1306 uchan->name, ua_sess->id);
1307 goto error;
1308 }
1309
1310 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1311
1312 ret = enable_ust_channel(app, ua_sess, ua_chan);
1313 if (ret < 0) {
1314 goto error;
1315 }
1316
1317 error:
1318 return ret;
1319 }
1320
1321 /*
1322 * Create UST app channel and create it on the tracer. Set ua_chanp of the
1323 * newly created channel if not NULL.
1324 */
1325 static int create_ust_app_channel(struct ust_app_session *ua_sess,
1326 struct ltt_ust_channel *uchan, struct ust_app *app,
1327 struct ust_app_channel **ua_chanp)
1328 {
1329 int ret = 0;
1330 struct lttng_ht_iter iter;
1331 struct lttng_ht_node_str *ua_chan_node;
1332 struct ust_app_channel *ua_chan;
1333
1334 /* Lookup channel in the ust app session */
1335 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
1336 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
1337 if (ua_chan_node != NULL) {
1338 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1339 goto end;
1340 }
1341
1342 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
1343 if (ua_chan == NULL) {
1344 /* Only malloc can fail here */
1345 ret = -ENOMEM;
1346 goto error;
1347 }
1348 shadow_copy_channel(ua_chan, uchan);
1349
1350 ret = create_ust_channel(app, ua_sess, ua_chan);
1351 if (ret < 0) {
1352 /* Not found previously means that it does not exist on the tracer */
1353 assert(ret != -LTTNG_UST_ERR_EXIST);
1354 goto error;
1355 }
1356
1357 /* Only add the channel if successful on the tracer side. */
1358 lttng_ht_add_unique_str(ua_sess->channels, &ua_chan->node);
1359
1360 DBG2("UST app create channel %s for PID %d completed", ua_chan->name,
1361 app->pid);
1362
1363 end:
1364 if (ua_chanp) {
1365 *ua_chanp = ua_chan;
1366 }
1367
1368 /* Everything went well. */
1369 return 0;
1370
1371 error:
1372 delete_ust_app_channel(-1, ua_chan);
1373 return ret;
1374 }
1375
1376 /*
1377 * Create UST app event and create it on the tracer side.
1378 */
1379 static
1380 int create_ust_app_event(struct ust_app_session *ua_sess,
1381 struct ust_app_channel *ua_chan, struct ltt_ust_event *uevent,
1382 struct ust_app *app)
1383 {
1384 int ret = 0;
1385 struct ust_app_event *ua_event;
1386
1387 /* Get event node */
1388 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
1389 uevent->filter, uevent->attr.loglevel);
1390 if (ua_event != NULL) {
1391 ret = -EEXIST;
1392 goto end;
1393 }
1394
1395 /* Does not exist so create one */
1396 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
1397 if (ua_event == NULL) {
1398 /* Only malloc can failed so something is really wrong */
1399 ret = -ENOMEM;
1400 goto end;
1401 }
1402 shadow_copy_event(ua_event, uevent);
1403
1404 /* Create it on the tracer side */
1405 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1406 if (ret < 0) {
1407 /* Not found previously means that it does not exist on the tracer */
1408 assert(ret != -LTTNG_UST_ERR_EXIST);
1409 goto error;
1410 }
1411
1412 add_unique_ust_app_event(ua_chan->events, ua_event);
1413
1414 DBG2("UST app create event %s for PID %d completed", ua_event->name,
1415 app->pid);
1416
1417 end:
1418 return ret;
1419
1420 error:
1421 /* Valid. Calling here is already in a read side lock */
1422 delete_ust_app_event(-1, ua_event);
1423 return ret;
1424 }
1425
1426 /*
1427 * Create UST metadata and open it on the tracer side.
1428 */
1429 static int create_ust_app_metadata(struct ust_app_session *ua_sess,
1430 char *pathname, struct ust_app *app)
1431 {
1432 int ret = 0;
1433
1434 if (ua_sess->metadata == NULL) {
1435 /* Allocate UST metadata */
1436 ua_sess->metadata = trace_ust_create_metadata(pathname);
1437 if (ua_sess->metadata == NULL) {
1438 /* malloc() failed */
1439 goto error;
1440 }
1441
1442 ret = open_ust_metadata(app, ua_sess);
1443 if (ret < 0) {
1444 DBG3("Opening metadata failed. Cleaning up memory");
1445
1446 /* Cleanup failed metadata struct */
1447 free(ua_sess->metadata);
1448 /*
1449 * This is very important because delete_ust_app_session check if
1450 * the pointer is null or not in order to delete the metadata.
1451 */
1452 ua_sess->metadata = NULL;
1453 goto error;
1454 }
1455
1456 DBG2("UST metadata opened for app pid %d", app->pid);
1457 }
1458
1459 /* Open UST metadata stream */
1460 if (ua_sess->metadata->stream_obj == NULL) {
1461 ret = create_ust_metadata_stream(app, ua_sess);
1462 if (ret < 0) {
1463 goto error;
1464 }
1465
1466 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX,
1467 "%s/metadata", ua_sess->path);
1468 if (ret < 0) {
1469 PERROR("asprintf UST create stream");
1470 goto error;
1471 }
1472
1473 DBG2("UST metadata stream object created for app pid %d",
1474 app->pid);
1475 } else {
1476 ERR("Attempting to create stream without metadata opened");
1477 goto error;
1478 }
1479
1480 return 0;
1481
1482 error:
1483 return -1;
1484 }
1485
1486 /*
1487 * Return pointer to traceable apps list.
1488 */
1489 struct lttng_ht *ust_app_get_ht(void)
1490 {
1491 return ust_app_ht;
1492 }
1493
1494 /*
1495 * Return ust app pointer or NULL if not found.
1496 */
1497 struct ust_app *ust_app_find_by_pid(pid_t pid)
1498 {
1499 struct lttng_ht_node_ulong *node;
1500 struct lttng_ht_iter iter;
1501
1502 rcu_read_lock();
1503 lttng_ht_lookup(ust_app_ht, (void *)((unsigned long) pid), &iter);
1504 node = lttng_ht_iter_get_node_ulong(&iter);
1505 if (node == NULL) {
1506 DBG2("UST app no found with pid %d", pid);
1507 goto error;
1508 }
1509 rcu_read_unlock();
1510
1511 DBG2("Found UST app by pid %d", pid);
1512
1513 return caa_container_of(node, struct ust_app, pid_n);
1514
1515 error:
1516 rcu_read_unlock();
1517 return NULL;
1518 }
1519
1520 /*
1521 * Using pid and uid (of the app), allocate a new ust_app struct and
1522 * add it to the global traceable app list.
1523 *
1524 * On success, return 0, else return malloc -ENOMEM, or -EINVAL if app
1525 * bitness is not supported.
1526 */
1527 int ust_app_register(struct ust_register_msg *msg, int sock)
1528 {
1529 struct ust_app *lta;
1530 int ret;
1531
1532 if ((msg->bits_per_long == 64 &&
1533 (uatomic_read(&ust_consumerd64_fd) == -EINVAL))
1534 || (msg->bits_per_long == 32 &&
1535 (uatomic_read(&ust_consumerd32_fd) == -EINVAL))) {
1536 ERR("Registration failed: application \"%s\" (pid: %d) has "
1537 "%d-bit long, but no consumerd for this long size is available.\n",
1538 msg->name, msg->pid, msg->bits_per_long);
1539 ret = close(sock);
1540 if (ret) {
1541 PERROR("close");
1542 }
1543 lttng_fd_put(LTTNG_FD_APPS, 1);
1544 return -EINVAL;
1545 }
1546 if (msg->major != LTTNG_UST_COMM_MAJOR) {
1547 ERR("Registration failed: application \"%s\" (pid: %d) has "
1548 "communication protocol version %u.%u, but sessiond supports 2.x.\n",
1549 msg->name, msg->pid, msg->major, msg->minor);
1550 ret = close(sock);
1551 if (ret) {
1552 PERROR("close");
1553 }
1554 lttng_fd_put(LTTNG_FD_APPS, 1);
1555 return -EINVAL;
1556 }
1557 lta = zmalloc(sizeof(struct ust_app));
1558 if (lta == NULL) {
1559 PERROR("malloc");
1560 return -ENOMEM;
1561 }
1562
1563 lta->ppid = msg->ppid;
1564 lta->uid = msg->uid;
1565 lta->gid = msg->gid;
1566 lta->compatible = 0; /* Not compatible until proven */
1567 lta->bits_per_long = msg->bits_per_long;
1568 lta->v_major = msg->major;
1569 lta->v_minor = msg->minor;
1570 strncpy(lta->name, msg->name, sizeof(lta->name));
1571 lta->name[16] = '\0';
1572 lta->sessions = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1573
1574 lta->pid = msg->pid;
1575 lttng_ht_node_init_ulong(&lta->pid_n, (unsigned long)lta->pid);
1576 lta->sock = sock;
1577 lttng_ht_node_init_ulong(&lta->sock_n, (unsigned long)lta->sock);
1578
1579 CDS_INIT_LIST_HEAD(&lta->teardown_head);
1580
1581 rcu_read_lock();
1582
1583 /*
1584 * On a re-registration, we want to kick out the previous registration of
1585 * that pid
1586 */
1587 lttng_ht_add_replace_ulong(ust_app_ht, &lta->pid_n);
1588
1589 /*
1590 * The socket _should_ be unique until _we_ call close. So, a add_unique
1591 * for the ust_app_ht_by_sock is used which asserts fail if the entry was
1592 * already in the table.
1593 */
1594 lttng_ht_add_unique_ulong(ust_app_ht_by_sock, &lta->sock_n);
1595
1596 rcu_read_unlock();
1597
1598 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
1599 " (version %d.%d)", lta->pid, lta->ppid, lta->uid, lta->gid,
1600 lta->sock, lta->name, lta->v_major, lta->v_minor);
1601
1602 return 0;
1603 }
1604
1605 /*
1606 * Unregister app by removing it from the global traceable app list and freeing
1607 * the data struct.
1608 *
1609 * The socket is already closed at this point so no close to sock.
1610 */
1611 void ust_app_unregister(int sock)
1612 {
1613 struct ust_app *lta;
1614 struct lttng_ht_node_ulong *node;
1615 struct lttng_ht_iter iter;
1616 struct ust_app_session *ua_sess;
1617 int ret;
1618
1619 rcu_read_lock();
1620
1621 /* Get the node reference for a call_rcu */
1622 lttng_ht_lookup(ust_app_ht_by_sock, (void *)((unsigned long) sock), &iter);
1623 node = lttng_ht_iter_get_node_ulong(&iter);
1624 if (node == NULL) {
1625 ERR("Unable to find app by sock %d", sock);
1626 goto error;
1627 }
1628
1629 lta = caa_container_of(node, struct ust_app, sock_n);
1630
1631 DBG("PID %d unregistering with sock %d", lta->pid, sock);
1632
1633 /* Remove application from PID hash table */
1634 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
1635 assert(!ret);
1636
1637 /* Assign second node for deletion */
1638 iter.iter.node = &lta->pid_n.node;
1639
1640 /*
1641 * Ignore return value since the node might have been removed before by an
1642 * add replace during app registration because the PID can be reassigned by
1643 * the OS.
1644 */
1645 ret = lttng_ht_del(ust_app_ht, &iter);
1646 if (ret) {
1647 DBG3("Unregister app by PID %d failed. This can happen on pid reuse",
1648 lta->pid);
1649 }
1650
1651 /* Remove sessions so they are not visible during deletion.*/
1652 cds_lfht_for_each_entry(lta->sessions->ht, &iter.iter, ua_sess,
1653 node.node) {
1654 ret = lttng_ht_del(lta->sessions, &iter);
1655 if (ret) {
1656 /* The session was already removed so scheduled for teardown. */
1657 continue;
1658 }
1659
1660 /*
1661 * Add session to list for teardown. This is safe since at this point we
1662 * are the only one using this list.
1663 */
1664 cds_list_add(&ua_sess->teardown_node, &lta->teardown_head);
1665 }
1666
1667 /* Free memory */
1668 call_rcu(&lta->pid_n.head, delete_ust_app_rcu);
1669
1670 error:
1671 rcu_read_unlock();
1672 return;
1673 }
1674
1675 /*
1676 * Return traceable_app_count
1677 */
1678 unsigned long ust_app_list_count(void)
1679 {
1680 unsigned long count;
1681
1682 rcu_read_lock();
1683 count = lttng_ht_get_count(ust_app_ht);
1684 rcu_read_unlock();
1685
1686 return count;
1687 }
1688
1689 /*
1690 * Fill events array with all events name of all registered apps.
1691 */
1692 int ust_app_list_events(struct lttng_event **events)
1693 {
1694 int ret, handle;
1695 size_t nbmem, count = 0;
1696 struct lttng_ht_iter iter;
1697 struct ust_app *app;
1698 struct lttng_event *tmp_event;
1699
1700 nbmem = UST_APP_EVENT_LIST_SIZE;
1701 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event));
1702 if (tmp_event == NULL) {
1703 PERROR("zmalloc ust app events");
1704 ret = -ENOMEM;
1705 goto error;
1706 }
1707
1708 rcu_read_lock();
1709
1710 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
1711 struct lttng_ust_tracepoint_iter uiter;
1712
1713 health_code_update(&health_thread_cmd);
1714
1715 if (!app->compatible) {
1716 /*
1717 * TODO: In time, we should notice the caller of this error by
1718 * telling him that this is a version error.
1719 */
1720 continue;
1721 }
1722 handle = ustctl_tracepoint_list(app->sock);
1723 if (handle < 0) {
1724 ERR("UST app list events getting handle failed for app pid %d",
1725 app->pid);
1726 continue;
1727 }
1728
1729 while ((ret = ustctl_tracepoint_list_get(app->sock, handle,
1730 &uiter)) != -LTTNG_UST_ERR_NOENT) {
1731 health_code_update(&health_thread_cmd);
1732 if (count >= nbmem) {
1733 /* In case the realloc fails, we free the memory */
1734 void *ptr;
1735
1736 DBG2("Reallocating event list from %zu to %zu entries", nbmem,
1737 2 * nbmem);
1738 nbmem *= 2;
1739 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event));
1740 if (ptr == NULL) {
1741 PERROR("realloc ust app events");
1742 free(tmp_event);
1743 ret = -ENOMEM;
1744 goto rcu_error;
1745 }
1746 tmp_event = ptr;
1747 }
1748 memcpy(tmp_event[count].name, uiter.name, LTTNG_UST_SYM_NAME_LEN);
1749 tmp_event[count].loglevel = uiter.loglevel;
1750 tmp_event[count].type = (enum lttng_event_type) LTTNG_UST_TRACEPOINT;
1751 tmp_event[count].pid = app->pid;
1752 tmp_event[count].enabled = -1;
1753 count++;
1754 }
1755 }
1756
1757 ret = count;
1758 *events = tmp_event;
1759
1760 DBG2("UST app list events done (%zu events)", count);
1761
1762 rcu_error:
1763 rcu_read_unlock();
1764 error:
1765 health_code_update(&health_thread_cmd);
1766 return ret;
1767 }
1768
1769 /*
1770 * Fill events array with all events name of all registered apps.
1771 */
1772 int ust_app_list_event_fields(struct lttng_event_field **fields)
1773 {
1774 int ret, handle;
1775 size_t nbmem, count = 0;
1776 struct lttng_ht_iter iter;
1777 struct ust_app *app;
1778 struct lttng_event_field *tmp_event;
1779
1780 nbmem = UST_APP_EVENT_LIST_SIZE;
1781 tmp_event = zmalloc(nbmem * sizeof(struct lttng_event_field));
1782 if (tmp_event == NULL) {
1783 PERROR("zmalloc ust app event fields");
1784 ret = -ENOMEM;
1785 goto error;
1786 }
1787
1788 rcu_read_lock();
1789
1790 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
1791 struct lttng_ust_field_iter uiter;
1792
1793 health_code_update(&health_thread_cmd);
1794
1795 if (!app->compatible) {
1796 /*
1797 * TODO: In time, we should notice the caller of this error by
1798 * telling him that this is a version error.
1799 */
1800 continue;
1801 }
1802 handle = ustctl_tracepoint_field_list(app->sock);
1803 if (handle < 0) {
1804 ERR("UST app list event fields getting handle failed for app pid %d",
1805 app->pid);
1806 continue;
1807 }
1808
1809 while ((ret = ustctl_tracepoint_field_list_get(app->sock, handle,
1810 &uiter)) != -LTTNG_UST_ERR_NOENT) {
1811 health_code_update(&health_thread_cmd);
1812 if (count >= nbmem) {
1813 /* In case the realloc fails, we free the memory */
1814 void *ptr;
1815
1816 DBG2("Reallocating event field list from %zu to %zu entries", nbmem,
1817 2 * nbmem);
1818 nbmem *= 2;
1819 ptr = realloc(tmp_event, nbmem * sizeof(struct lttng_event_field));
1820 if (ptr == NULL) {
1821 PERROR("realloc ust app event fields");
1822 free(tmp_event);
1823 ret = -ENOMEM;
1824 goto rcu_error;
1825 }
1826 tmp_event = ptr;
1827 }
1828
1829 memcpy(tmp_event[count].field_name, uiter.field_name, LTTNG_UST_SYM_NAME_LEN);
1830 tmp_event[count].type = uiter.type;
1831 tmp_event[count].nowrite = uiter.nowrite;
1832
1833 memcpy(tmp_event[count].event.name, uiter.event_name, LTTNG_UST_SYM_NAME_LEN);
1834 tmp_event[count].event.loglevel = uiter.loglevel;
1835 tmp_event[count].event.type = LTTNG_UST_TRACEPOINT;
1836 tmp_event[count].event.pid = app->pid;
1837 tmp_event[count].event.enabled = -1;
1838 count++;
1839 }
1840 }
1841
1842 ret = count;
1843 *fields = tmp_event;
1844
1845 DBG2("UST app list event fields done (%zu events)", count);
1846
1847 rcu_error:
1848 rcu_read_unlock();
1849 error:
1850 health_code_update(&health_thread_cmd);
1851 return ret;
1852 }
1853
1854 /*
1855 * Free and clean all traceable apps of the global list.
1856 */
1857 void ust_app_clean_list(void)
1858 {
1859 int ret;
1860 struct ust_app *app;
1861 struct lttng_ht_iter iter;
1862
1863 DBG2("UST app cleaning registered apps hash table");
1864
1865 rcu_read_lock();
1866
1867 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
1868 ret = lttng_ht_del(ust_app_ht, &iter);
1869 assert(!ret);
1870 call_rcu(&app->pid_n.head, delete_ust_app_rcu);
1871 }
1872
1873 /* Cleanup socket hash table */
1874 cds_lfht_for_each_entry(ust_app_ht_by_sock->ht, &iter.iter, app,
1875 sock_n.node) {
1876 ret = lttng_ht_del(ust_app_ht_by_sock, &iter);
1877 assert(!ret);
1878 }
1879
1880 /* Destroy is done only when the ht is empty */
1881 lttng_ht_destroy(ust_app_ht);
1882 lttng_ht_destroy(ust_app_ht_by_sock);
1883
1884 rcu_read_unlock();
1885 }
1886
1887 /*
1888 * Init UST app hash table.
1889 */
1890 void ust_app_ht_alloc(void)
1891 {
1892 ust_app_ht = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1893 ust_app_ht_by_sock = lttng_ht_new(0, LTTNG_HT_TYPE_ULONG);
1894 }
1895
1896 /*
1897 * For a specific UST session, disable the channel for all registered apps.
1898 */
1899 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
1900 struct ltt_ust_channel *uchan)
1901 {
1902 int ret = 0;
1903 struct lttng_ht_iter iter;
1904 struct lttng_ht_node_str *ua_chan_node;
1905 struct ust_app *app;
1906 struct ust_app_session *ua_sess;
1907 struct ust_app_channel *ua_chan;
1908
1909 if (usess == NULL || uchan == NULL) {
1910 ERR("Disabling UST global channel with NULL values");
1911 ret = -1;
1912 goto error;
1913 }
1914
1915 DBG2("UST app disabling channel %s from global domain for session id %d",
1916 uchan->name, usess->id);
1917
1918 rcu_read_lock();
1919
1920 /* For every registered applications */
1921 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
1922 struct lttng_ht_iter uiter;
1923 if (!app->compatible) {
1924 /*
1925 * TODO: In time, we should notice the caller of this error by
1926 * telling him that this is a version error.
1927 */
1928 continue;
1929 }
1930 ua_sess = lookup_session_by_app(usess, app);
1931 if (ua_sess == NULL) {
1932 continue;
1933 }
1934
1935 /* Get channel */
1936 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
1937 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
1938 /* If the session if found for the app, the channel must be there */
1939 assert(ua_chan_node);
1940
1941 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1942 /* The channel must not be already disabled */
1943 assert(ua_chan->enabled == 1);
1944
1945 /* Disable channel onto application */
1946 ret = disable_ust_app_channel(ua_sess, ua_chan, app);
1947 if (ret < 0) {
1948 /* XXX: We might want to report this error at some point... */
1949 continue;
1950 }
1951 }
1952
1953 rcu_read_unlock();
1954
1955 error:
1956 return ret;
1957 }
1958
1959 /*
1960 * For a specific UST session, enable the channel for all registered apps.
1961 */
1962 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
1963 struct ltt_ust_channel *uchan)
1964 {
1965 int ret = 0;
1966 struct lttng_ht_iter iter;
1967 struct ust_app *app;
1968 struct ust_app_session *ua_sess;
1969
1970 if (usess == NULL || uchan == NULL) {
1971 ERR("Adding UST global channel to NULL values");
1972 ret = -1;
1973 goto error;
1974 }
1975
1976 DBG2("UST app enabling channel %s to global domain for session id %d",
1977 uchan->name, usess->id);
1978
1979 rcu_read_lock();
1980
1981 /* For every registered applications */
1982 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
1983 if (!app->compatible) {
1984 /*
1985 * TODO: In time, we should notice the caller of this error by
1986 * telling him that this is a version error.
1987 */
1988 continue;
1989 }
1990 ua_sess = lookup_session_by_app(usess, app);
1991 if (ua_sess == NULL) {
1992 continue;
1993 }
1994
1995 /* Enable channel onto application */
1996 ret = enable_ust_app_channel(ua_sess, uchan, app);
1997 if (ret < 0) {
1998 /* XXX: We might want to report this error at some point... */
1999 continue;
2000 }
2001 }
2002
2003 rcu_read_unlock();
2004
2005 error:
2006 return ret;
2007 }
2008
2009 /*
2010 * Disable an event in a channel and for a specific session.
2011 */
2012 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
2013 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
2014 {
2015 int ret = 0;
2016 struct lttng_ht_iter iter, uiter;
2017 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
2018 struct ust_app *app;
2019 struct ust_app_session *ua_sess;
2020 struct ust_app_channel *ua_chan;
2021 struct ust_app_event *ua_event;
2022
2023 DBG("UST app disabling event %s for all apps in channel "
2024 "%s for session id %d", uevent->attr.name, uchan->name, usess->id);
2025
2026 rcu_read_lock();
2027
2028 /* For all registered applications */
2029 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2030 if (!app->compatible) {
2031 /*
2032 * TODO: In time, we should notice the caller of this error by
2033 * telling him that this is a version error.
2034 */
2035 continue;
2036 }
2037 ua_sess = lookup_session_by_app(usess, app);
2038 if (ua_sess == NULL) {
2039 /* Next app */
2040 continue;
2041 }
2042
2043 /* Lookup channel in the ust app session */
2044 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
2045 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
2046 if (ua_chan_node == NULL) {
2047 DBG2("Channel %s not found in session id %d for app pid %d."
2048 "Skipping", uchan->name, usess->id, app->pid);
2049 continue;
2050 }
2051 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2052
2053 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &uiter);
2054 ua_event_node = lttng_ht_iter_get_node_str(&uiter);
2055 if (ua_event_node == NULL) {
2056 DBG2("Event %s not found in channel %s for app pid %d."
2057 "Skipping", uevent->attr.name, uchan->name, app->pid);
2058 continue;
2059 }
2060 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2061
2062 ret = disable_ust_app_event(ua_sess, ua_event, app);
2063 if (ret < 0) {
2064 /* XXX: Report error someday... */
2065 continue;
2066 }
2067 }
2068
2069 rcu_read_unlock();
2070
2071 return ret;
2072 }
2073
2074 /*
2075 * For a specific UST session and UST channel, the event for all
2076 * registered apps.
2077 */
2078 int ust_app_disable_all_event_glb(struct ltt_ust_session *usess,
2079 struct ltt_ust_channel *uchan)
2080 {
2081 int ret = 0;
2082 struct lttng_ht_iter iter, uiter;
2083 struct lttng_ht_node_str *ua_chan_node;
2084 struct ust_app *app;
2085 struct ust_app_session *ua_sess;
2086 struct ust_app_channel *ua_chan;
2087 struct ust_app_event *ua_event;
2088
2089 DBG("UST app disabling all event for all apps in channel "
2090 "%s for session id %d", uchan->name, usess->id);
2091
2092 rcu_read_lock();
2093
2094 /* For all registered applications */
2095 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2096 if (!app->compatible) {
2097 /*
2098 * TODO: In time, we should notice the caller of this error by
2099 * telling him that this is a version error.
2100 */
2101 continue;
2102 }
2103 ua_sess = lookup_session_by_app(usess, app);
2104 if (!ua_sess) {
2105 /* The application has problem or is probably dead. */
2106 continue;
2107 }
2108
2109 /* Lookup channel in the ust app session */
2110 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
2111 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
2112 /* If the channel is not found, there is a code flow error */
2113 assert(ua_chan_node);
2114
2115 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2116
2117 /* Disable each events of channel */
2118 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
2119 node.node) {
2120 ret = disable_ust_app_event(ua_sess, ua_event, app);
2121 if (ret < 0) {
2122 /* XXX: Report error someday... */
2123 continue;
2124 }
2125 }
2126 }
2127
2128 rcu_read_unlock();
2129
2130 return ret;
2131 }
2132
2133 /*
2134 * For a specific UST session, create the channel for all registered apps.
2135 */
2136 int ust_app_create_channel_glb(struct ltt_ust_session *usess,
2137 struct ltt_ust_channel *uchan)
2138 {
2139 int ret = 0, created;
2140 struct lttng_ht_iter iter;
2141 struct ust_app *app;
2142 struct ust_app_session *ua_sess = NULL;
2143
2144 /* Very wrong code flow */
2145 assert(usess);
2146 assert(uchan);
2147
2148 DBG2("UST app adding channel %s to global domain for session id %d",
2149 uchan->name, usess->id);
2150
2151 rcu_read_lock();
2152
2153 /* For every registered applications */
2154 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2155 if (!app->compatible) {
2156 /*
2157 * TODO: In time, we should notice the caller of this error by
2158 * telling him that this is a version error.
2159 */
2160 continue;
2161 }
2162 /*
2163 * Create session on the tracer side and add it to app session HT. Note
2164 * that if session exist, it will simply return a pointer to the ust
2165 * app session.
2166 */
2167 ret = create_ust_app_session(usess, app, &ua_sess, &created);
2168 if (ret < 0) {
2169 switch (ret) {
2170 case -ENOTCONN:
2171 /*
2172 * The application's socket is not valid. Either a bad socket
2173 * or a timeout on it. We can't inform the caller that for a
2174 * specific app, the session failed so lets continue here.
2175 */
2176 continue;
2177 case -ENOMEM:
2178 default:
2179 goto error_rcu_unlock;
2180 }
2181 }
2182 assert(ua_sess);
2183
2184 /* Create channel onto application. We don't need the chan ref. */
2185 ret = create_ust_app_channel(ua_sess, uchan, app, NULL);
2186 if (ret < 0) {
2187 if (ret == -ENOMEM) {
2188 /* No more memory is a fatal error. Stop right now. */
2189 goto error_rcu_unlock;
2190 }
2191 /* Cleanup the created session if it's the case. */
2192 if (created) {
2193 delete_ust_app_session(app->sock, ua_sess);
2194 }
2195 }
2196 }
2197
2198 error_rcu_unlock:
2199 rcu_read_unlock();
2200 return ret;
2201 }
2202
2203 /*
2204 * Enable event for a specific session and channel on the tracer.
2205 */
2206 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
2207 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
2208 {
2209 int ret = 0;
2210 struct lttng_ht_iter iter, uiter;
2211 struct lttng_ht_node_str *ua_chan_node;
2212 struct ust_app *app;
2213 struct ust_app_session *ua_sess;
2214 struct ust_app_channel *ua_chan;
2215 struct ust_app_event *ua_event;
2216
2217 DBG("UST app enabling event %s for all apps for session id %d",
2218 uevent->attr.name, usess->id);
2219
2220 /*
2221 * NOTE: At this point, this function is called only if the session and
2222 * channel passed are already created for all apps. and enabled on the
2223 * tracer also.
2224 */
2225
2226 rcu_read_lock();
2227
2228 /* For all registered applications */
2229 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2230 if (!app->compatible) {
2231 /*
2232 * TODO: In time, we should notice the caller of this error by
2233 * telling him that this is a version error.
2234 */
2235 continue;
2236 }
2237 ua_sess = lookup_session_by_app(usess, app);
2238 if (!ua_sess) {
2239 /* The application has problem or is probably dead. */
2240 continue;
2241 }
2242
2243 /* Lookup channel in the ust app session */
2244 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
2245 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
2246 /* If the channel is not found, there is a code flow error */
2247 assert(ua_chan_node);
2248
2249 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2250
2251 /* Get event node */
2252 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
2253 uevent->filter, uevent->attr.loglevel);
2254 if (ua_event == NULL) {
2255 DBG3("UST app enable event %s not found for app PID %d."
2256 "Skipping app", uevent->attr.name, app->pid);
2257 continue;
2258 }
2259
2260 ret = enable_ust_app_event(ua_sess, ua_event, app);
2261 if (ret < 0) {
2262 goto error;
2263 }
2264 }
2265
2266 error:
2267 rcu_read_unlock();
2268 return ret;
2269 }
2270
2271 /*
2272 * For a specific existing UST session and UST channel, creates the event for
2273 * all registered apps.
2274 */
2275 int ust_app_create_event_glb(struct ltt_ust_session *usess,
2276 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
2277 {
2278 int ret = 0;
2279 struct lttng_ht_iter iter, uiter;
2280 struct lttng_ht_node_str *ua_chan_node;
2281 struct ust_app *app;
2282 struct ust_app_session *ua_sess;
2283 struct ust_app_channel *ua_chan;
2284
2285 DBG("UST app creating event %s for all apps for session id %d",
2286 uevent->attr.name, usess->id);
2287
2288 rcu_read_lock();
2289
2290 /* For all registered applications */
2291 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2292 if (!app->compatible) {
2293 /*
2294 * TODO: In time, we should notice the caller of this error by
2295 * telling him that this is a version error.
2296 */
2297 continue;
2298 }
2299 ua_sess = lookup_session_by_app(usess, app);
2300 if (!ua_sess) {
2301 /* The application has problem or is probably dead. */
2302 continue;
2303 }
2304
2305 /* Lookup channel in the ust app session */
2306 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
2307 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
2308 /* If the channel is not found, there is a code flow error */
2309 assert(ua_chan_node);
2310
2311 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2312
2313 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
2314 if (ret < 0) {
2315 if (ret != -LTTNG_UST_ERR_EXIST) {
2316 /* Possible value at this point: -ENOMEM. If so, we stop! */
2317 break;
2318 }
2319 DBG2("UST app event %s already exist on app PID %d",
2320 uevent->attr.name, app->pid);
2321 continue;
2322 }
2323 }
2324
2325 rcu_read_unlock();
2326
2327 return ret;
2328 }
2329
2330 /*
2331 * Start tracing for a specific UST session and app.
2332 */
2333 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
2334 {
2335 int ret = 0;
2336 struct lttng_ht_iter iter;
2337 struct ust_app_session *ua_sess;
2338 struct ust_app_channel *ua_chan;
2339 struct ust_app_stream *ustream;
2340 struct consumer_socket *socket;
2341
2342 DBG("Starting tracing for ust app pid %d", app->pid);
2343
2344 rcu_read_lock();
2345
2346 if (!app->compatible) {
2347 goto end;
2348 }
2349
2350 ua_sess = lookup_session_by_app(usess, app);
2351 if (ua_sess == NULL) {
2352 /* The session is in teardown process. Ignore and continue. */
2353 goto end;
2354 }
2355
2356 /* Upon restart, we skip the setup, already done */
2357 if (ua_sess->started) {
2358 goto skip_setup;
2359 }
2360
2361 /* Create directories if consumer is LOCAL and has a path defined. */
2362 if (usess->consumer->type == CONSUMER_DST_LOCAL &&
2363 strlen(usess->consumer->dst.trace_path) > 0) {
2364 ret = run_as_mkdir_recursive(usess->consumer->dst.trace_path,
2365 S_IRWXU | S_IRWXG, usess->uid, usess->gid);
2366 if (ret < 0) {
2367 if (ret != -EEXIST) {
2368 ERR("Trace directory creation error");
2369 ret = -1;
2370 goto error_rcu_unlock;
2371 }
2372 }
2373 }
2374
2375 ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
2376 if (ret < 0) {
2377 ret = LTTNG_ERR_UST_META_FAIL;
2378 goto error_rcu_unlock;
2379 }
2380
2381 /* For each channel */
2382 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
2383 node.node) {
2384 /* Create all streams */
2385 while (1) {
2386 /* Create UST stream */
2387 ustream = alloc_ust_app_stream();
2388 if (ustream == NULL) {
2389 goto error_rcu_unlock;
2390 }
2391
2392 health_code_update(&health_thread_cmd);
2393
2394 ret = create_ust_stream(app, ua_chan, ustream);
2395 if (ret < 0) {
2396 /* Free unused memory after this point. */
2397 free(ustream);
2398 if (ret == -LTTNG_UST_ERR_NOENT) {
2399 /* Got all streams. Continue normal execution. */
2400 break;
2401 }
2402 /* Error at this point. Stop everything. */
2403 ret = LTTNG_ERR_UST_STREAM_FAIL;
2404 goto error_rcu_unlock;
2405 }
2406
2407 health_code_update(&health_thread_cmd);
2408
2409 /* Order is important this is why a list is used. */
2410 cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
2411 ua_chan->streams.count++;
2412
2413 DBG2("UST stream %d ready (handle: %d)", ua_chan->streams.count,
2414 ustream->handle);
2415 }
2416
2417 health_code_update(&health_thread_cmd);
2418 }
2419
2420 switch (app->bits_per_long) {
2421 case 64:
2422 socket = consumer_find_socket(uatomic_read(&ust_consumerd64_fd),
2423 usess->consumer);
2424 if (socket == NULL) {
2425 goto skip_setup;
2426 }
2427 break;
2428 case 32:
2429 socket = consumer_find_socket(uatomic_read(&ust_consumerd32_fd),
2430 usess->consumer);
2431 if (socket == NULL) {
2432 goto skip_setup;
2433 }
2434 break;
2435 default:
2436 ret = -EINVAL;
2437 goto error_rcu_unlock;
2438 }
2439
2440 /* Setup UST consumer socket and send fds to it */
2441 ret = ust_consumer_send_session(ua_sess, usess->consumer, socket);
2442 if (ret < 0) {
2443 goto error_rcu_unlock;
2444 }
2445
2446 health_code_update(&health_thread_cmd);
2447
2448 skip_setup:
2449 /* This start the UST tracing */
2450 ret = ustctl_start_session(app->sock, ua_sess->handle);
2451 if (ret < 0) {
2452 ERR("Error starting tracing for app pid: %d (ret: %d)", app->pid, ret);
2453 goto error_rcu_unlock;
2454 }
2455
2456 /* Indicate that the session has been started once */
2457 ua_sess->started = 1;
2458
2459 health_code_update(&health_thread_cmd);
2460
2461 /* Quiescent wait after starting trace */
2462 ustctl_wait_quiescent(app->sock);
2463
2464 end:
2465 rcu_read_unlock();
2466 health_code_update(&health_thread_cmd);
2467 return 0;
2468
2469 error_rcu_unlock:
2470 rcu_read_unlock();
2471 health_code_update(&health_thread_cmd);
2472 return -1;
2473 }
2474
2475 /*
2476 * Stop tracing for a specific UST session and app.
2477 */
2478 int ust_app_stop_trace(struct ltt_ust_session *usess, struct ust_app *app)
2479 {
2480 int ret = 0;
2481 struct lttng_ht_iter iter;
2482 struct ust_app_session *ua_sess;
2483 struct ust_app_channel *ua_chan;
2484
2485 DBG("Stopping tracing for ust app pid %d", app->pid);
2486
2487 rcu_read_lock();
2488
2489 if (!app->compatible) {
2490 goto end;
2491 }
2492
2493 ua_sess = lookup_session_by_app(usess, app);
2494 if (ua_sess == NULL) {
2495 goto end;
2496 }
2497
2498 /*
2499 * If started = 0, it means that stop trace has been called for a session
2500 * that was never started. It's possible since we can have a fail start
2501 * from either the application manager thread or the command thread. Simply
2502 * indicate that this is a stop error.
2503 */
2504 if (!ua_sess->started) {
2505 goto error_rcu_unlock;
2506 }
2507
2508 health_code_update(&health_thread_cmd);
2509
2510 /* This inhibits UST tracing */
2511 ret = ustctl_stop_session(app->sock, ua_sess->handle);
2512 if (ret < 0) {
2513 ERR("Error stopping tracing for app pid: %d (ret: %d)", app->pid, ret);
2514 goto error_rcu_unlock;
2515 }
2516
2517 health_code_update(&health_thread_cmd);
2518
2519 /* Quiescent wait after stopping trace */
2520 ustctl_wait_quiescent(app->sock);
2521
2522 health_code_update(&health_thread_cmd);
2523
2524 /* Flushing buffers */
2525 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
2526 node.node) {
2527 health_code_update(&health_thread_cmd);
2528 ret = ustctl_sock_flush_buffer(app->sock, ua_chan->obj);
2529 if (ret < 0) {
2530 ERR("UST app PID %d channel %s flush failed with ret %d",
2531 app->pid, ua_chan->name, ret);
2532 /* Continuing flushing all buffers */
2533 continue;
2534 }
2535 }
2536
2537 health_code_update(&health_thread_cmd);
2538
2539 /* Flush all buffers before stopping */
2540 ret = ustctl_sock_flush_buffer(app->sock, ua_sess->metadata->obj);
2541 if (ret < 0) {
2542 ERR("UST app PID %d metadata flush failed with ret %d", app->pid,
2543 ret);
2544 }
2545
2546 end:
2547 rcu_read_unlock();
2548 health_code_update(&health_thread_cmd);
2549 return 0;
2550
2551 error_rcu_unlock:
2552 rcu_read_unlock();
2553 health_code_update(&health_thread_cmd);
2554 return -1;
2555 }
2556
2557 /*
2558 * Destroy a specific UST session in apps.
2559 */
2560 static int destroy_trace(struct ltt_ust_session *usess, struct ust_app *app)
2561 {
2562 struct ust_app_session *ua_sess;
2563 struct lttng_ust_object_data obj;
2564 struct lttng_ht_iter iter;
2565 struct lttng_ht_node_ulong *node;
2566 int ret;
2567
2568 DBG("Destroy tracing for ust app pid %d", app->pid);
2569
2570 rcu_read_lock();
2571
2572 if (!app->compatible) {
2573 goto end;
2574 }
2575
2576 __lookup_session_by_app(usess, app, &iter);
2577 node = lttng_ht_iter_get_node_ulong(&iter);
2578 if (node == NULL) {
2579 /* Session is being or is deleted. */
2580 goto end;
2581 }
2582 ua_sess = caa_container_of(node, struct ust_app_session, node);
2583 ret = lttng_ht_del(app->sessions, &iter);
2584 if (ret) {
2585 /* Already scheduled for teardown. */
2586 goto end;
2587 }
2588
2589 obj.handle = ua_sess->handle;
2590 obj.shm_fd = -1;
2591 obj.wait_fd = -1;
2592 obj.memory_map_size = 0;
2593 health_code_update(&health_thread_cmd);
2594 ustctl_release_object(app->sock, &obj);
2595
2596 health_code_update(&health_thread_cmd);
2597 delete_ust_app_session(app->sock, ua_sess);
2598
2599 /* Quiescent wait after stopping trace */
2600 ustctl_wait_quiescent(app->sock);
2601
2602 end:
2603 rcu_read_unlock();
2604 health_code_update(&health_thread_cmd);
2605 return 0;
2606 }
2607
2608 /*
2609 * Start tracing for the UST session.
2610 */
2611 int ust_app_start_trace_all(struct ltt_ust_session *usess)
2612 {
2613 int ret = 0;
2614 struct lttng_ht_iter iter;
2615 struct ust_app *app;
2616
2617 DBG("Starting all UST traces");
2618
2619 rcu_read_lock();
2620
2621 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2622 ret = ust_app_start_trace(usess, app);
2623 if (ret < 0) {
2624 /* Continue to next apps even on error */
2625 continue;
2626 }
2627 }
2628
2629 rcu_read_unlock();
2630
2631 return 0;
2632 }
2633
2634 /*
2635 * Start tracing for the UST session.
2636 */
2637 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
2638 {
2639 int ret = 0;
2640 struct lttng_ht_iter iter;
2641 struct ust_app *app;
2642
2643 DBG("Stopping all UST traces");
2644
2645 rcu_read_lock();
2646
2647 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2648 ret = ust_app_stop_trace(usess, app);
2649 if (ret < 0) {
2650 /* Continue to next apps even on error */
2651 continue;
2652 }
2653 }
2654
2655 rcu_read_unlock();
2656
2657 return 0;
2658 }
2659
2660 /*
2661 * Destroy app UST session.
2662 */
2663 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
2664 {
2665 int ret = 0;
2666 struct lttng_ht_iter iter;
2667 struct ust_app *app;
2668
2669 DBG("Destroy all UST traces");
2670
2671 rcu_read_lock();
2672
2673 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2674 ret = destroy_trace(usess, app);
2675 if (ret < 0) {
2676 /* Continue to next apps even on error */
2677 continue;
2678 }
2679 }
2680
2681 rcu_read_unlock();
2682
2683 return 0;
2684 }
2685
2686 /*
2687 * Add channels/events from UST global domain to registered apps at sock.
2688 */
2689 void ust_app_global_update(struct ltt_ust_session *usess, int sock)
2690 {
2691 int ret = 0;
2692 struct lttng_ht_iter iter, uiter, iter_ctx;
2693 struct ust_app *app;
2694 struct ust_app_session *ua_sess = NULL;
2695 struct ust_app_channel *ua_chan;
2696 struct ust_app_event *ua_event;
2697 struct ust_app_ctx *ua_ctx;
2698
2699 assert(usess);
2700
2701 DBG2("UST app global update for app sock %d for session id %d", sock,
2702 usess->id);
2703
2704 rcu_read_lock();
2705
2706 app = find_app_by_sock(sock);
2707 if (app == NULL) {
2708 ERR("Failed to update app sock %d", sock);
2709 goto error;
2710 }
2711
2712 if (!app->compatible) {
2713 goto error;
2714 }
2715
2716 ret = create_ust_app_session(usess, app, &ua_sess, NULL);
2717 if (ret < 0) {
2718 /* Tracer is probably gone or ENOMEM. */
2719 goto error;
2720 }
2721 assert(ua_sess);
2722
2723 /*
2724 * We can iterate safely here over all UST app session sicne the create ust
2725 * app session above made a shadow copy of the UST global domain from the
2726 * ltt ust session.
2727 */
2728 cds_lfht_for_each_entry(ua_sess->channels->ht, &iter.iter, ua_chan,
2729 node.node) {
2730 ret = create_ust_channel(app, ua_sess, ua_chan);
2731 if (ret < 0) {
2732 /* FIXME: Should we quit here or continue... */
2733 continue;
2734 }
2735
2736 cds_lfht_for_each_entry(ua_chan->ctx->ht, &iter_ctx.iter, ua_ctx,
2737 node.node) {
2738 ret = create_ust_channel_context(ua_chan, ua_ctx, app);
2739 if (ret < 0) {
2740 /* FIXME: Should we quit here or continue... */
2741 continue;
2742 }
2743 }
2744
2745
2746 /* For each events */
2747 cds_lfht_for_each_entry(ua_chan->events->ht, &uiter.iter, ua_event,
2748 node.node) {
2749 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
2750 if (ret < 0) {
2751 /* FIXME: Should we quit here or continue... */
2752 continue;
2753 }
2754 }
2755 }
2756
2757 if (usess->start_trace) {
2758 ret = ust_app_start_trace(usess, app);
2759 if (ret < 0) {
2760 goto error;
2761 }
2762
2763 DBG2("UST trace started for app pid %d", app->pid);
2764 }
2765
2766 error:
2767 rcu_read_unlock();
2768 return;
2769 }
2770
2771 /*
2772 * Add context to a specific channel for global UST domain.
2773 */
2774 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
2775 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
2776 {
2777 int ret = 0;
2778 struct lttng_ht_node_str *ua_chan_node;
2779 struct lttng_ht_iter iter, uiter;
2780 struct ust_app_channel *ua_chan = NULL;
2781 struct ust_app_session *ua_sess;
2782 struct ust_app *app;
2783
2784 rcu_read_lock();
2785
2786 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2787 if (!app->compatible) {
2788 /*
2789 * TODO: In time, we should notice the caller of this error by
2790 * telling him that this is a version error.
2791 */
2792 continue;
2793 }
2794 ua_sess = lookup_session_by_app(usess, app);
2795 if (ua_sess == NULL) {
2796 continue;
2797 }
2798
2799 /* Lookup channel in the ust app session */
2800 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &uiter);
2801 ua_chan_node = lttng_ht_iter_get_node_str(&uiter);
2802 if (ua_chan_node == NULL) {
2803 continue;
2804 }
2805 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel,
2806 node);
2807
2808 ret = create_ust_app_channel_context(ua_sess, ua_chan, &uctx->ctx, app);
2809 if (ret < 0) {
2810 continue;
2811 }
2812 }
2813
2814 rcu_read_unlock();
2815 return ret;
2816 }
2817
2818 /*
2819 * Enable event for a channel from a UST session for a specific PID.
2820 */
2821 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
2822 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2823 {
2824 int ret = 0;
2825 struct lttng_ht_iter iter;
2826 struct lttng_ht_node_str *ua_chan_node;
2827 struct ust_app *app;
2828 struct ust_app_session *ua_sess;
2829 struct ust_app_channel *ua_chan;
2830 struct ust_app_event *ua_event;
2831
2832 DBG("UST app enabling event %s for PID %d", uevent->attr.name, pid);
2833
2834 rcu_read_lock();
2835
2836 app = ust_app_find_by_pid(pid);
2837 if (app == NULL) {
2838 ERR("UST app enable event per PID %d not found", pid);
2839 ret = -1;
2840 goto error;
2841 }
2842
2843 if (!app->compatible) {
2844 ret = 0;
2845 goto error;
2846 }
2847
2848 ua_sess = lookup_session_by_app(usess, app);
2849 if (!ua_sess) {
2850 /* The application has problem or is probably dead. */
2851 goto error;
2852 }
2853
2854 /* Lookup channel in the ust app session */
2855 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2856 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2857 /* If the channel is not found, there is a code flow error */
2858 assert(ua_chan_node);
2859
2860 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2861
2862 ua_event = find_ust_app_event(ua_chan->events, uevent->attr.name,
2863 uevent->filter, uevent->attr.loglevel);
2864 if (ua_event == NULL) {
2865 ret = create_ust_app_event(ua_sess, ua_chan, uevent, app);
2866 if (ret < 0) {
2867 goto error;
2868 }
2869 } else {
2870 ret = enable_ust_app_event(ua_sess, ua_event, app);
2871 if (ret < 0) {
2872 goto error;
2873 }
2874 }
2875
2876 error:
2877 rcu_read_unlock();
2878 return ret;
2879 }
2880
2881 /*
2882 * Disable event for a channel from a UST session for a specific PID.
2883 */
2884 int ust_app_disable_event_pid(struct ltt_ust_session *usess,
2885 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent, pid_t pid)
2886 {
2887 int ret = 0;
2888 struct lttng_ht_iter iter;
2889 struct lttng_ht_node_str *ua_chan_node, *ua_event_node;
2890 struct ust_app *app;
2891 struct ust_app_session *ua_sess;
2892 struct ust_app_channel *ua_chan;
2893 struct ust_app_event *ua_event;
2894
2895 DBG("UST app disabling event %s for PID %d", uevent->attr.name, pid);
2896
2897 rcu_read_lock();
2898
2899 app = ust_app_find_by_pid(pid);
2900 if (app == NULL) {
2901 ERR("UST app disable event per PID %d not found", pid);
2902 ret = -1;
2903 goto error;
2904 }
2905
2906 if (!app->compatible) {
2907 ret = 0;
2908 goto error;
2909 }
2910
2911 ua_sess = lookup_session_by_app(usess, app);
2912 if (!ua_sess) {
2913 /* The application has problem or is probably dead. */
2914 goto error;
2915 }
2916
2917 /* Lookup channel in the ust app session */
2918 lttng_ht_lookup(ua_sess->channels, (void *)uchan->name, &iter);
2919 ua_chan_node = lttng_ht_iter_get_node_str(&iter);
2920 if (ua_chan_node == NULL) {
2921 /* Channel does not exist, skip disabling */
2922 goto error;
2923 }
2924 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
2925
2926 lttng_ht_lookup(ua_chan->events, (void *)uevent->attr.name, &iter);
2927 ua_event_node = lttng_ht_iter_get_node_str(&iter);
2928 if (ua_event_node == NULL) {
2929 /* Event does not exist, skip disabling */
2930 goto error;
2931 }
2932 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
2933
2934 ret = disable_ust_app_event(ua_sess, ua_event, app);
2935 if (ret < 0) {
2936 goto error;
2937 }
2938
2939 error:
2940 rcu_read_unlock();
2941 return ret;
2942 }
2943
2944 /*
2945 * Validate version of UST apps and set the compatible bit.
2946 */
2947 int ust_app_validate_version(int sock)
2948 {
2949 int ret;
2950 struct ust_app *app;
2951
2952 rcu_read_lock();
2953
2954 app = find_app_by_sock(sock);
2955 assert(app);
2956
2957 health_code_update(&health_thread_cmd);
2958
2959 ret = ustctl_tracer_version(sock, &app->version);
2960 if (ret < 0) {
2961 goto error;
2962 }
2963
2964 /* Validate version */
2965 if (app->version.major != UST_APP_MAJOR_VERSION) {
2966 goto error;
2967 }
2968
2969 DBG2("UST app PID %d is compatible with internal major version %d "
2970 "(supporting == %d)", app->pid, app->version.major,
2971 UST_APP_MAJOR_VERSION);
2972 app->compatible = 1;
2973 rcu_read_unlock();
2974 health_code_update(&health_thread_cmd);
2975 return 0;
2976
2977 error:
2978 DBG2("UST app PID %d is not compatible with internal major version %d "
2979 "(supporting == %d)", app->pid, app->version.major,
2980 UST_APP_MAJOR_VERSION);
2981 app->compatible = 0;
2982 rcu_read_unlock();
2983 health_code_update(&health_thread_cmd);
2984 return -1;
2985 }
2986
2987 /*
2988 * Calibrate registered applications.
2989 */
2990 int ust_app_calibrate_glb(struct lttng_ust_calibrate *calibrate)
2991 {
2992 int ret = 0;
2993 struct lttng_ht_iter iter;
2994 struct ust_app *app;
2995
2996 rcu_read_lock();
2997
2998 cds_lfht_for_each_entry(ust_app_ht->ht, &iter.iter, app, pid_n.node) {
2999 if (!app->compatible) {
3000 /*
3001 * TODO: In time, we should notice the caller of this error by
3002 * telling him that this is a version error.
3003 */
3004 continue;
3005 }
3006
3007 health_code_update(&health_thread_cmd);
3008
3009 ret = ustctl_calibrate(app->sock, calibrate);
3010 if (ret < 0) {
3011 switch (ret) {
3012 case -ENOSYS:
3013 /* Means that it's not implemented on the tracer side. */
3014 ret = 0;
3015 break;
3016 default:
3017 /* TODO: Report error to user */
3018 DBG2("Calibrate app PID %d returned with error %d",
3019 app->pid, ret);
3020 break;
3021 }
3022 }
3023 }
3024
3025 DBG("UST app global domain calibration finished");
3026
3027 rcu_read_unlock();
3028
3029 health_code_update(&health_thread_cmd);
3030
3031 return ret;
3032 }
This page took 0.159541 seconds and 3 git commands to generate.