UST consumer: fix read on hangup, and UST get subbuf error handling
[lttng-tools.git] / lttng-sessiond / ust-app.c
CommitLineData
91d76f53
DG
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
82a3637f
DG
6 * as published by the Free Software Foundation; only version 2
7 * of the License.
91d76f53
DG
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>
099e26bd 24#include <string.h>
aba8e916
DG
25#include <sys/stat.h>
26#include <sys/types.h>
099e26bd 27#include <unistd.h>
91d76f53 28
1e307fab 29#include <lttngerr.h>
48842b30 30#include <lttng-share.h>
1e307fab 31
f6a9efaa 32#include "hashtable.h"
56fff090 33#include "ust-app.h"
48842b30 34#include "ust-consumer.h"
d80a6244
DG
35#include "ust-ctl.h"
36
37/*
38 * Delete ust app event safely. RCU read lock must be held before calling
39 * this function.
40 */
41static void delete_ust_app_event(int sock, struct ust_app_event *ua_event)
42{
43 /* TODO : remove context */
44 //struct ust_app_ctx *ltctx;
45 //cds_lfht_for_each_entry(lte->ctx, &iter, ltctx, node) {
46 // delete_ust_app_ctx(sock, ltctx);
47 //}
48
49 ustctl_release_object(sock, ua_event->obj);
50 free(ua_event);
51}
52
53/*
54 * Delete ust app stream safely. RCU read lock must be held before calling
55 * this function.
56 */
57static void delete_ust_app_stream(int sock, struct ltt_ust_stream *stream)
58{
59 //TODO
60 //stream is used for passing to consumer.
61 //send_channel_streams is responsible for freeing the streams.
62 //note that this will not play well with flight recorder mode:
63 //we might need a criterion to discard the streams.
64}
65
66/*
67 * Delete ust app channel safely. RCU read lock must be held before calling
68 * this function.
69 */
70static void delete_ust_app_channel(int sock, struct ust_app_channel *ua_chan)
71{
72 int ret;
73 struct cds_lfht_iter iter;
74 struct ust_app_event *ua_event;
75 struct ltt_ust_stream *stream, *stmp;
76
77 cds_list_for_each_entry_safe(stream, stmp, &ua_chan->streams.head, list) {
78 delete_ust_app_stream(sock, stream);
79 }
80
81 /* TODO : remove channel context */
82 //cds_lfht_for_each_entry(ltc->ctx, &iter, ltctx, node) {
83 // hashtable_del(ltc->ctx, &iter);
84 // delete_ust_app_ctx(sock, ltctx);
85 //}
86 //ret = hashtable_destroy(ltc->ctx);
87
88 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
89 hashtable_del(ua_chan->events, &iter);
90 delete_ust_app_event(sock, ua_event);
91 }
92
93 ret = hashtable_destroy(ua_chan->events);
94 if (ret < 0) {
95 ERR("UST app destroy session hashtable failed");
96 goto error;
97 }
98
99error:
100 return;
101}
102
103/*
104 * Delete ust app session safely. RCU read lock must be held before calling
105 * this function.
106 */
107static void delete_ust_app_session(int sock,
108 struct ust_app_session *ua_sess)
109{
110 int ret;
111 struct cds_lfht_iter iter;
112 struct ust_app_channel *ua_chan;
113
114 if (ua_sess->metadata) {
115 /*
116 * We do NOT release the stream object and metadata object since they
117 * are release when fds are sent to the consumer.
118 */
119 }
120
121 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
122 hashtable_del(ua_sess->channels, &iter);
123 delete_ust_app_channel(sock, ua_chan);
124 }
125
126 ret = hashtable_destroy(ua_sess->channels);
127 if (ret < 0) {
128 ERR("UST app destroy session hashtable failed");
129 goto error;
130 }
131
132error:
133 return;
134}
91d76f53
DG
135
136/*
284d8f55
DG
137 * Delete a traceable application structure from the global list. Never call
138 * this function outside of a call_rcu call.
91d76f53 139 */
284d8f55 140static void delete_ust_app(struct ust_app *app)
91d76f53 141{
f6a9efaa
DG
142 int ret;
143 struct cds_lfht_node *node;
144 struct cds_lfht_iter iter;
284d8f55 145 struct ust_app_session *ua_sess;
44d3bd01 146
f6a9efaa 147 rcu_read_lock();
44d3bd01 148
f6a9efaa
DG
149 /* Remove from key hash table */
150 node = hashtable_lookup(ust_app_sock_key_map,
284d8f55 151 (void *) ((unsigned long) app->key.sock), sizeof(void *), &iter);
f6a9efaa 152 if (node == NULL) {
284d8f55
DG
153 /* Not suppose to happen */
154 ERR("UST app key %d not found in key hash table", app->key.sock);
d80a6244 155 goto end;
284d8f55
DG
156 }
157
158 ret = hashtable_del(ust_app_sock_key_map, &iter);
159 if (ret) {
160 ERR("UST app unable to delete app sock %d from key hash table",
161 app->key.sock);
f6a9efaa 162 } else {
284d8f55
DG
163 DBG2("UST app pair sock %d key %d deleted",
164 app->key.sock, app->key.pid);
f6a9efaa
DG
165 }
166
d80a6244
DG
167 /* Socket is already closed at this point */
168
169 /* Delete ust app sessions info */
284d8f55
DG
170 if (app->sock_closed) {
171 app->key.sock = -1;
d80a6244
DG
172 }
173
284d8f55
DG
174 cds_lfht_for_each_entry(app->sessions, &iter, ua_sess, node) {
175 hashtable_del(app->sessions, &iter);
176 delete_ust_app_session(app->key.sock, ua_sess);
d80a6244 177 }
f6a9efaa 178
284d8f55 179 ret = hashtable_destroy(app->sessions);
d80a6244
DG
180 if (ret < 0) {
181 ERR("UST app destroy session hashtable failed");
182 goto end;
183 }
184
284d8f55
DG
185 if (!app->sock_closed) {
186 close(app->key.sock);
d80a6244
DG
187 }
188
284d8f55
DG
189 DBG2("UST app pid %d deleted", app->key.pid);
190 free(app);
d80a6244 191end:
f6a9efaa 192 rcu_read_unlock();
099e26bd
DG
193}
194
195/*
f6a9efaa 196 * URCU intermediate call to delete an UST app.
099e26bd 197 */
f6a9efaa 198static void delete_ust_app_rcu(struct rcu_head *head)
099e26bd 199{
f6a9efaa
DG
200 struct cds_lfht_node *node =
201 caa_container_of(head, struct cds_lfht_node, head);
202 struct ust_app *app =
203 caa_container_of(node, struct ust_app, node);
204
205 delete_ust_app(app);
099e26bd
DG
206}
207
208/*
421cb601
DG
209 * Find an ust_app using the sock and return it. RCU read side lock must be
210 * held before calling this helper function.
099e26bd 211 */
f6a9efaa 212static struct ust_app *find_app_by_sock(int sock)
099e26bd 213{
f6a9efaa
DG
214 struct cds_lfht_node *node;
215 struct ust_app_key *key;
216 struct cds_lfht_iter iter;
f6a9efaa 217
f6a9efaa
DG
218 node = hashtable_lookup(ust_app_sock_key_map,
219 (void *)((unsigned long) sock), sizeof(void *), &iter);
220 if (node == NULL) {
221 DBG2("UST app find by sock %d key not found", sock);
f6a9efaa
DG
222 goto error;
223 }
224
225 key = caa_container_of(node, struct ust_app_key, node);
226
227 node = hashtable_lookup(ust_app_ht,
228 (void *)((unsigned long) key->pid), sizeof(void *), &iter);
229 if (node == NULL) {
230 DBG2("UST app find by sock %d not found", sock);
f6a9efaa
DG
231 goto error;
232 }
f6a9efaa
DG
233 return caa_container_of(node, struct ust_app, node);
234
235error:
236 return NULL;
099e26bd
DG
237}
238
239/*
5b4a0ec0 240 * Open metadata onto the UST tracer for a UST session.
0177d773 241 */
5b4a0ec0
DG
242static int open_ust_metadata(struct ust_app *app,
243 struct ust_app_session *ua_sess)
0177d773 244{
5b4a0ec0
DG
245 int ret;
246 struct lttng_ust_channel_attr uattr;
0177d773 247
5b4a0ec0
DG
248 uattr.overwrite = ua_sess->metadata->attr.overwrite;
249 uattr.subbuf_size = ua_sess->metadata->attr.subbuf_size;
250 uattr.num_subbuf = ua_sess->metadata->attr.num_subbuf;
251 uattr.switch_timer_interval =
252 ua_sess->metadata->attr.switch_timer_interval;
253 uattr.read_timer_interval =
254 ua_sess->metadata->attr.read_timer_interval;
255 uattr.output = ua_sess->metadata->attr.output;
256
257 /* UST tracer metadata creation */
258 ret = ustctl_open_metadata(app->key.sock, ua_sess->handle, &uattr,
259 &ua_sess->metadata->obj);
260 if (ret < 0) {
261 ERR("UST app open metadata failed for app pid:%d",
262 app->key.pid);
f6a9efaa 263 goto error;
0177d773 264 }
f6a9efaa
DG
265
266error:
5b4a0ec0 267 return ret;
91d76f53
DG
268}
269
270/*
5b4a0ec0 271 * Create stream onto the UST tracer for a UST session.
91d76f53 272 */
5b4a0ec0
DG
273static int create_ust_stream(struct ust_app *app,
274 struct ust_app_session *ua_sess)
91d76f53 275{
5b4a0ec0 276 int ret;
421cb601 277
5b4a0ec0
DG
278 ret = ustctl_create_stream(app->key.sock, ua_sess->metadata->obj,
279 &ua_sess->metadata->stream_obj);
280 if (ret < 0) {
281 ERR("UST create metadata stream failed");
421cb601 282 goto error;
91d76f53 283 }
421cb601 284
421cb601 285error:
5b4a0ec0 286 return ret;
91d76f53
DG
287}
288
b551a063 289/*
5b4a0ec0 290 * Create the specified channel onto the UST tracer for a UST session.
b551a063 291 */
5b4a0ec0
DG
292static int create_ust_channel(struct ust_app *app,
293 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan)
b551a063 294{
5b4a0ec0 295 int ret;
b551a063 296
5b4a0ec0
DG
297 /* TODO: remove cast and use lttng-ust-abi.h */
298 ret = ustctl_create_channel(app->key.sock, ua_sess->handle,
299 (struct lttng_ust_channel_attr *)&ua_chan->attr, &ua_chan->obj);
300 if (ret < 0) {
301 DBG("Error creating channel %s for app (pid: %d, sock: %d) "
302 "and session handle %d with ret %d",
303 ua_chan->name, app->key.pid, app->key.sock,
304 ua_sess->handle, ret);
b551a063
DG
305 goto error;
306 }
307
5b4a0ec0
DG
308 ua_chan->handle = ua_chan->obj->handle;
309 ua_chan->attr.shm_fd = ua_chan->obj->shm_fd;
310 ua_chan->attr.wait_fd = ua_chan->obj->wait_fd;
311 ua_chan->attr.memory_map_size = ua_chan->obj->memory_map_size;
b551a063 312
5b4a0ec0
DG
313 DBG2("UST app channel %s created successfully for pid:%d and sock:%d",
314 ua_chan->name, app->key.pid, app->key.sock);
b551a063 315
b551a063
DG
316error:
317 return ret;
318}
319
91d76f53 320/*
5b4a0ec0 321 * Create the specified event onto the UST tracer for a UST session.
91d76f53 322 */
5b4a0ec0
DG
323static int create_ust_event(struct ust_app *app,
324 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
325 struct ust_app_event *ua_event)
91d76f53 326{
5b4a0ec0 327 int ret = 0;
284d8f55 328
5b4a0ec0
DG
329 /* Create UST event on tracer */
330 ret = ustctl_create_event(app->key.sock, &ua_event->attr, ua_chan->obj,
331 &ua_event->obj);
332 if (ret < 0) {
333 ERR("Error ustctl create event %s for app pid: %d with ret %d",
334 ua_event->attr.name, app->key.pid, ret);
335 goto error;
91d76f53 336 }
f6a9efaa 337
5b4a0ec0
DG
338 ua_event->handle = ua_event->obj->handle;
339 ua_event->enabled = 1;
284d8f55 340
5b4a0ec0
DG
341 DBG2("UST app event %s created successfully for pid:%d",
342 ua_event->attr.name, app->key.pid);
f6a9efaa 343
5b4a0ec0
DG
344error:
345 return ret;
91d76f53 346}
48842b30
DG
347
348/*
349 * Alloc new UST app session.
350 */
421cb601 351static struct ust_app_session *alloc_ust_app_session(void)
48842b30
DG
352{
353 struct ust_app_session *ua_sess;
354
421cb601 355 /* Init most of the default value by allocating and zeroing */
48842b30
DG
356 ua_sess = zmalloc(sizeof(struct ust_app_session));
357 if (ua_sess == NULL) {
358 PERROR("malloc");
359 goto error;
360 }
361
48842b30
DG
362 ua_sess->handle = -1;
363 ua_sess->channels = hashtable_new_str(0);
48842b30
DG
364
365 return ua_sess;
366
367error:
368 return NULL;
369}
370
421cb601
DG
371/*
372 * Alloc new UST app channel.
373 */
284d8f55
DG
374static struct ust_app_channel *alloc_ust_app_channel(char *name,
375 struct lttng_ust_channel *attr)
48842b30
DG
376{
377 struct ust_app_channel *ua_chan;
378
421cb601 379 /* Init most of the default value by allocating and zeroing */
48842b30
DG
380 ua_chan = zmalloc(sizeof(struct ust_app_channel));
381 if (ua_chan == NULL) {
382 PERROR("malloc");
383 goto error;
384 }
385
284d8f55 386 /* Setup channel name */
48842b30
DG
387 strncpy(ua_chan->name, name, sizeof(ua_chan->name));
388 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
284d8f55 389
48842b30 390 ua_chan->handle = -1;
48842b30 391 ua_chan->ctx = hashtable_new(0);
48842b30
DG
392 ua_chan->events = hashtable_new_str(0);
393 hashtable_node_init(&ua_chan->node, (void *) ua_chan->name,
394 strlen(ua_chan->name));
395
284d8f55
DG
396 CDS_INIT_LIST_HEAD(&ua_chan->streams.head);
397
398 /* Copy attributes */
399 if (attr) {
400 memcpy(&ua_chan->attr, attr, sizeof(ua_chan->attr));
401 }
402
48842b30
DG
403 DBG3("UST app channel %s allocated", ua_chan->name);
404
405 return ua_chan;
406
407error:
408 return NULL;
409}
410
421cb601
DG
411/*
412 * Alloc new UST app event.
413 */
284d8f55
DG
414static struct ust_app_event *alloc_ust_app_event(char *name,
415 struct lttng_ust_event *attr)
48842b30
DG
416{
417 struct ust_app_event *ua_event;
418
421cb601 419 /* Init most of the default value by allocating and zeroing */
48842b30
DG
420 ua_event = zmalloc(sizeof(struct ust_app_event));
421 if (ua_event == NULL) {
422 PERROR("malloc");
423 goto error;
424 }
425
426 strncpy(ua_event->name, name, sizeof(ua_event->name));
427 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
428 ua_event->ctx = hashtable_new(0);
429 hashtable_node_init(&ua_event->node, (void *) ua_event->name,
430 strlen(ua_event->name));
431
284d8f55
DG
432 /* Copy attributes */
433 if (attr) {
434 memcpy(&ua_event->attr, attr, sizeof(ua_event->attr));
435 }
436
48842b30
DG
437 DBG3("UST app event %s allocated", ua_event->name);
438
439 return ua_event;
440
441error:
442 return NULL;
443}
444
5b4a0ec0
DG
445/*
446 * Copy data between an UST app event and a LTT event.
447 */
421cb601 448static void shadow_copy_event(struct ust_app_event *ua_event,
48842b30
DG
449 struct ltt_ust_event *uevent)
450{
451 strncpy(ua_event->name, uevent->attr.name, sizeof(ua_event->name));
452 ua_event->name[sizeof(ua_event->name) - 1] = '\0';
453
5b4a0ec0
DG
454 /* Copy event attributes */
455 memcpy(&ua_event->attr, &uevent->attr, sizeof(ua_event->attr));
456
48842b30
DG
457 /* TODO: support copy context */
458}
459
5b4a0ec0
DG
460/*
461 * Copy data between an UST app channel and a LTT channel.
462 */
421cb601 463static void shadow_copy_channel(struct ust_app_channel *ua_chan,
48842b30
DG
464 struct ltt_ust_channel *uchan)
465{
466 struct cds_lfht_iter iter;
5b4a0ec0 467 struct cds_lfht_node *ua_event_node;
48842b30
DG
468 struct ltt_ust_event *uevent;
469 struct ust_app_event *ua_event;
470
421cb601 471 DBG2("Shadow copy of UST app channel %s", ua_chan->name);
48842b30
DG
472
473 strncpy(ua_chan->name, uchan->name, sizeof(ua_chan->name));
474 ua_chan->name[sizeof(ua_chan->name) - 1] = '\0';
5b4a0ec0
DG
475 /* Copy event attributes */
476 memcpy(&ua_chan->attr, &uchan->attr, sizeof(ua_chan->attr));
48842b30
DG
477
478 /* TODO: support copy context */
479
421cb601 480 /* Copy all events from ltt ust channel to ust app channel */
5b4a0ec0 481 cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
48842b30
DG
482 ua_event_node = hashtable_lookup(ua_chan->events,
483 (void *) uevent->attr.name, strlen(uevent->attr.name), &iter);
484 if (ua_event_node == NULL) {
421cb601 485 DBG2("UST event %s not found on shadow copy channel",
48842b30 486 uevent->attr.name);
284d8f55 487 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
48842b30 488 if (ua_event == NULL) {
5b4a0ec0 489 continue;
48842b30 490 }
421cb601 491 shadow_copy_event(ua_event, uevent);
48842b30 492 hashtable_add_unique(ua_chan->events, &ua_event->node);
48842b30 493 }
48842b30
DG
494 }
495
421cb601 496 DBG3("Shadow copy channel done");
48842b30
DG
497}
498
5b4a0ec0
DG
499/*
500 * Copy data between a UST app session and a regular LTT session.
501 */
421cb601 502static void shadow_copy_session(struct ust_app_session *ua_sess,
48842b30
DG
503 struct ltt_ust_session *usess)
504{
5b4a0ec0 505 struct cds_lfht_node *ua_chan_node;
48842b30
DG
506 struct cds_lfht_iter iter;
507 struct ltt_ust_channel *uchan;
508 struct ust_app_channel *ua_chan;
509
421cb601 510 DBG2("Shadow copy of session handle %d", ua_sess->handle);
48842b30
DG
511
512 ua_sess->uid = usess->uid;
513
514 /* TODO: support all UST domain */
515
516 /* Iterate over all channels in global domain. */
5b4a0ec0
DG
517 cds_lfht_for_each_entry(usess->domain_global.channels, &iter,
518 uchan, node) {
48842b30 519 ua_chan_node = hashtable_lookup(ua_sess->channels,
421cb601 520 (void *)uchan->name, strlen(uchan->name), &iter);
5b4a0ec0
DG
521 if (ua_chan_node != NULL) {
522 continue;
523 }
421cb601 524
5b4a0ec0
DG
525 DBG2("Channel %s not found on shadow session copy, creating it",
526 uchan->name);
527 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
528 if (ua_chan == NULL) {
529 /* malloc failed... continuing */
530 continue;
48842b30
DG
531 }
532
5b4a0ec0
DG
533 shadow_copy_channel(ua_chan, uchan);
534 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
48842b30
DG
535 }
536}
537
421cb601
DG
538/*
539 * Return ust app session from the app session hashtable using the UST session
540 * uid.
541 */
48842b30
DG
542static struct ust_app_session *lookup_session_by_app(
543 struct ltt_ust_session *usess, struct ust_app *app)
544{
545 struct cds_lfht_iter iter;
546 struct cds_lfht_node *node;
547
548 /* Get right UST app session from app */
549 node = hashtable_lookup(app->sessions,
421cb601 550 (void *) ((unsigned long) usess->uid), sizeof(void *), &iter);
48842b30
DG
551 if (node == NULL) {
552 goto error;
553 }
554
555 return caa_container_of(node, struct ust_app_session, node);
556
557error:
558 return NULL;
559}
560
421cb601
DG
561/*
562 * Create a UST session onto the tracer of app and add it the session
563 * hashtable.
564 *
565 * Return ust app session or NULL on error.
566 */
567static struct ust_app_session *create_ust_app_session(
568 struct ltt_ust_session *usess, struct ust_app *app)
569{
570 int ret;
571 struct ust_app_session *ua_sess;
572
573 ua_sess = lookup_session_by_app(usess, app);
574 if (ua_sess == NULL) {
575 DBG2("UST app pid: %d session uid %d not found, creating it",
576 app->key.pid, usess->uid);
577 ua_sess = alloc_ust_app_session();
578 if (ua_sess == NULL) {
579 /* Only malloc can failed so something is really wrong */
580 goto error;
581 }
582 shadow_copy_session(ua_sess, usess);
583 }
584
585 if (ua_sess->handle == -1) {
586 ret = ustctl_create_session(app->key.sock);
587 if (ret < 0) {
588 ERR("Error creating session for app pid %d, sock %d",
589 app->key.pid, app->key.sock);
590 /* TODO: free() ua_sess */
591 goto error;
592 }
593
594 DBG2("UST app ustctl create session handle %d", ret);
595 ua_sess->handle = ret;
596
597 /* Add ust app session to app's HT */
598 hashtable_node_init(&ua_sess->node,
599 (void *)((unsigned long) ua_sess->uid), sizeof(void *));
600 hashtable_add_unique(app->sessions, &ua_sess->node);
601
602 DBG2("UST app session created successfully with handle %d", ret);
603 }
604
605 return ua_sess;
606
607error:
608 return NULL;
609}
610
284d8f55 611/*
5b4a0ec0 612 * Create UST app channel and create it on the tracer.
284d8f55 613 */
5b4a0ec0
DG
614static struct ust_app_channel *create_ust_app_channel(
615 struct ust_app_session *ua_sess, struct ltt_ust_channel *uchan,
616 struct ust_app *app)
617{
618 int ret = 0;
619 struct cds_lfht_iter iter;
620 struct cds_lfht_node *ua_chan_node;
621 struct ust_app_channel *ua_chan;
622
623 /* Lookup channel in the ust app session */
624 ua_chan_node = hashtable_lookup(ua_sess->channels,
625 (void *)uchan->name, strlen(uchan->name), &iter);
626 if (ua_chan_node == NULL) {
627 DBG2("Unable to find channel %s in ust session uid %u",
628 uchan->name, ua_sess->uid);
629 ua_chan = alloc_ust_app_channel(uchan->name, &uchan->attr);
630 if (ua_chan == NULL) {
631 goto error;
632 }
633 shadow_copy_channel(ua_chan, uchan);
634
635 hashtable_add_unique(ua_sess->channels, &ua_chan->node);
636 } else {
637 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
638 }
639
640 ret = create_ust_channel(app, ua_sess, ua_chan);
641 if (ret < 0) {
642 goto error;
643 }
644
645 return ua_chan;
646
647error:
648 return NULL;
649}
650
651/*
652 * Create UST app event and create it on the tracer side.
653 */
654static struct ust_app_event *create_ust_app_event(
655 struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan,
656 struct ltt_ust_event *uevent, struct ust_app *app)
284d8f55
DG
657{
658 int ret;
5b4a0ec0
DG
659 struct cds_lfht_iter iter;
660 struct cds_lfht_node *ua_event_node;
661 struct ust_app_event *ua_event;
284d8f55 662
5b4a0ec0
DG
663 /* Get event node */
664 ua_event_node = hashtable_lookup(ua_chan->events,
665 (void *)uevent->attr.name, strlen(uevent->attr.name), &iter);
666 if (ua_event_node == NULL) {
667 DBG2("UST app event %s not found, creating it", uevent->attr.name);
668 /* Does not exist so create one */
669 ua_event = alloc_ust_app_event(uevent->attr.name, &uevent->attr);
670 if (ua_event == NULL) {
671 /* Only malloc can failed so something is really wrong */
672 goto error;
673 }
674 shadow_copy_event(ua_event, uevent);
675
676 hashtable_add_unique(ua_chan->events, &ua_event->node);
677 } else {
678 ua_event = caa_container_of(ua_event_node, struct ust_app_event, node);
679 }
680
681 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
284d8f55 682 if (ret < 0) {
284d8f55
DG
683 goto error;
684 }
685
5b4a0ec0 686 return ua_event;
284d8f55 687
5b4a0ec0
DG
688error:
689 return NULL;
690}
691
692/*
693 * Create UST metadata and open it on the tracer side.
694 */
695static int create_ust_app_metadata(struct ust_app_session *ua_sess,
696 char *pathname, struct ust_app *app)
697{
698 int ret = 0;
699
700 if (ua_sess->metadata == NULL) {
701 /* Allocate UST metadata */
702 ua_sess->metadata = trace_ust_create_metadata(pathname);
703 if (ua_sess->metadata == NULL) {
704 ERR("UST app session %d creating metadata failed",
705 ua_sess->handle);
706 goto error;
707 }
708
709 ret = open_ust_metadata(app, ua_sess);
710 if (ret < 0) {
711 goto error;
712 }
713
714 DBG2("UST metadata opened for app pid %d", app->key.pid);
715 }
716
717 /* Open UST metadata stream */
718 if (ua_sess->metadata->stream_obj == NULL) {
719 ret = create_ust_stream(app, ua_sess);
720 if (ret < 0) {
721 goto error;
722 }
723
724 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d",
725 pathname, app->name, app->key.pid);
726 if (ret < 0) {
727 PERROR("asprintf UST create stream");
728 goto error;
729 }
730
731 ret = mkdir(ua_sess->metadata->pathname, S_IRWXU | S_IRWXG);
732 if (ret < 0) {
733 PERROR("mkdir UST metadata");
734 goto error;
735 }
736
737 ret = snprintf(ua_sess->metadata->pathname, PATH_MAX, "%s/%s-%d/metadata",
738 pathname, app->name, app->key.pid);
739 if (ret < 0) {
740 PERROR("asprintf UST create stream");
741 goto error;
742 }
743
744 DBG2("UST metadata stream object created for app pid %d",
745 app->key.pid);
746 } else {
747 ERR("Attempting to create stream without metadata opened");
748 goto error;
749 }
750
751 return 0;
752
753error:
754 return -1;
755}
756
757/*
758 * Return pointer to traceable apps list.
759 */
760struct cds_lfht *ust_app_get_ht(void)
761{
762 return ust_app_ht;
763}
764
765/*
766 * Return ust app pointer or NULL if not found.
767 */
768struct ust_app *ust_app_find_by_pid(pid_t pid)
769{
770 struct cds_lfht_node *node;
771 struct cds_lfht_iter iter;
772
773 rcu_read_lock();
774 node = hashtable_lookup(ust_app_ht,
775 (void *)((unsigned long) pid), sizeof(void *), &iter);
776 if (node == NULL) {
777 DBG2("UST app no found with pid %d", pid);
778 goto error;
779 }
780 rcu_read_unlock();
781
782 DBG2("Found UST app by pid %d", pid);
783
784 return caa_container_of(node, struct ust_app, node);
785
786error:
787 rcu_read_unlock();
788 return NULL;
789}
790
791/*
792 * Using pid and uid (of the app), allocate a new ust_app struct and
793 * add it to the global traceable app list.
794 *
795 * On success, return 0, else return malloc ENOMEM.
796 */
797int ust_app_register(struct ust_register_msg *msg, int sock)
798{
799 struct ust_app *lta;
800
801 lta = zmalloc(sizeof(struct ust_app));
802 if (lta == NULL) {
803 PERROR("malloc");
804 return -ENOMEM;
805 }
806
807 lta->ppid = msg->ppid;
808 lta->uid = msg->uid;
809 lta->gid = msg->gid;
810 lta->v_major = msg->major;
811 lta->v_minor = msg->minor;
812 strncpy(lta->name, msg->name, sizeof(lta->name));
813 lta->name[16] = '\0';
814 lta->sessions = hashtable_new(0);
815
816 /* Set key map */
817 lta->key.pid = msg->pid;
818 hashtable_node_init(&lta->node, (void *)((unsigned long)lta->key.pid),
819 sizeof(void *));
820 lta->key.sock = sock;
821 hashtable_node_init(&lta->key.node, (void *)((unsigned long)lta->key.sock),
822 sizeof(void *));
823
824 rcu_read_lock();
825 hashtable_add_unique(ust_app_sock_key_map, &lta->key.node);
826 hashtable_add_unique(ust_app_ht, &lta->node);
827 rcu_read_unlock();
828
829 DBG("App registered with pid:%d ppid:%d uid:%d gid:%d sock:%d name:%s"
830 " (version %d.%d)", lta->key.pid, lta->ppid, lta->uid, lta->gid,
831 lta->key.sock, lta->name, lta->v_major, lta->v_minor);
832
833 return 0;
834}
835
836/*
837 * Unregister app by removing it from the global traceable app list and freeing
838 * the data struct.
839 *
840 * The socket is already closed at this point so no close to sock.
841 */
842void ust_app_unregister(int sock)
843{
844 struct ust_app *lta;
845 struct cds_lfht_node *node;
846 struct cds_lfht_iter iter;
847
848 rcu_read_lock();
849 lta = find_app_by_sock(sock);
850 if (lta == NULL) {
851 ERR("Unregister app sock %d not found!", sock);
852 goto error;
853 }
854
855 DBG("PID %d unregistering with sock %d", lta->key.pid, sock);
856
857 /* Get the node reference for a call_rcu */
858 node = hashtable_lookup(ust_app_ht,
859 (void *)((unsigned long) lta->key.pid), sizeof(void *), &iter);
860 if (node == NULL) {
861 ERR("Unable to find app sock %d by pid %d", sock, lta->key.pid);
862 goto error;
863 }
284d8f55 864
5b4a0ec0
DG
865 /* We got called because the socket was closed on the remote end. */
866 close(sock);
867 /* Using a flag because we still need "sock" as a key. */
868 lta->sock_closed = 1;
869 hashtable_del(ust_app_ht, &iter);
870 call_rcu(&node->head, delete_ust_app_rcu);
284d8f55 871error:
5b4a0ec0
DG
872 rcu_read_unlock();
873 return;
284d8f55
DG
874}
875
876/*
5b4a0ec0 877 * Return traceable_app_count
284d8f55 878 */
5b4a0ec0 879unsigned long ust_app_list_count(void)
284d8f55 880{
5b4a0ec0 881 unsigned long count;
284d8f55 882
5b4a0ec0
DG
883 rcu_read_lock();
884 count = hashtable_get_count(ust_app_ht);
885 rcu_read_unlock();
284d8f55 886
5b4a0ec0 887 return count;
284d8f55
DG
888}
889
5b4a0ec0
DG
890/*
891 * Fill events array with all events name of all registered apps.
892 */
893int ust_app_list_events(struct lttng_event **events)
421cb601 894{
5b4a0ec0
DG
895 int ret, handle;
896 size_t nbmem, count = 0;
421cb601 897 struct cds_lfht_iter iter;
5b4a0ec0
DG
898 struct ust_app *app;
899 struct lttng_event *tmp;
421cb601 900
5b4a0ec0
DG
901 nbmem = UST_APP_EVENT_LIST_SIZE;
902 tmp = zmalloc(nbmem * sizeof(struct lttng_event));
903 if (tmp == NULL) {
904 PERROR("zmalloc ust app events");
905 ret = -ENOMEM;
421cb601
DG
906 goto error;
907 }
908
5b4a0ec0 909 rcu_read_lock();
421cb601 910
5b4a0ec0
DG
911 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
912 handle = ustctl_tracepoint_list(app->key.sock);
913 if (handle < 0) {
914 ERR("UST app list events getting handle failed for app pid %d",
915 app->key.pid);
916 continue;
917 }
421cb601 918
5b4a0ec0
DG
919 while ((ret = ustctl_tracepoint_list_get(app->key.sock, handle,
920 tmp[count].name)) != -ENOENT) {
921 if (count > nbmem) {
922 DBG2("Reallocating event list from %zu to %zu bytes", nbmem,
923 nbmem + UST_APP_EVENT_LIST_SIZE);
924 nbmem += UST_APP_EVENT_LIST_SIZE;
925 tmp = realloc(tmp, nbmem);
926 if (tmp == NULL) {
927 PERROR("realloc ust app events");
928 ret = -ENOMEM;
929 goto rcu_error;
930 }
931 }
421cb601 932
5b4a0ec0
DG
933 tmp[count].type = LTTNG_UST_TRACEPOINT;
934 tmp[count].pid = app->key.pid;
935 tmp[count].enabled = -1;
936 count++;
421cb601 937 }
421cb601
DG
938 }
939
5b4a0ec0
DG
940 ret = count;
941 *events = tmp;
421cb601 942
5b4a0ec0 943 DBG2("UST app list events done (%zu events)", count);
421cb601 944
5b4a0ec0
DG
945rcu_error:
946 rcu_read_unlock();
421cb601 947error:
5b4a0ec0 948 return ret;
421cb601
DG
949}
950
5b4a0ec0
DG
951/*
952 * Free and clean all traceable apps of the global list.
953 */
954void ust_app_clean_list(void)
421cb601 955{
5b4a0ec0
DG
956 int ret;
957 struct cds_lfht_node *node;
958 struct cds_lfht_iter iter;
959 struct ust_app *app;
421cb601 960
5b4a0ec0 961 DBG2("UST app cleaning registered apps hash table");
421cb601 962
5b4a0ec0 963 rcu_read_lock();
421cb601 964
5b4a0ec0
DG
965 cds_lfht_for_each(ust_app_ht, &iter, node) {
966 app = caa_container_of(node, struct ust_app, node);
967 close(app->key.sock);
968 app->sock_closed = 1;
421cb601 969
5b4a0ec0
DG
970 ret = hashtable_del(ust_app_ht, &iter);
971 if (!ret) {
972 call_rcu(&node->head, delete_ust_app_rcu);
421cb601 973 }
421cb601
DG
974 }
975
5b4a0ec0
DG
976 hashtable_destroy(ust_app_ht);
977 hashtable_destroy(ust_app_sock_key_map);
421cb601 978
5b4a0ec0
DG
979 rcu_read_unlock();
980}
981
982/*
983 * Init UST app hash table.
984 */
985void ust_app_ht_alloc(void)
986{
987 ust_app_ht = hashtable_new(0);
988 ust_app_sock_key_map = hashtable_new(0);
421cb601
DG
989}
990
991/*
5b4a0ec0 992 * For a specific UST session, create the channel for all registered apps.
421cb601 993 */
5b4a0ec0 994int ust_app_create_channel_all(struct ltt_ust_session *usess,
48842b30
DG
995 struct ltt_ust_channel *uchan)
996{
997 int ret = 0;
998 struct cds_lfht_iter iter;
48842b30
DG
999 struct ust_app *app;
1000 struct ust_app_session *ua_sess;
1001 struct ust_app_channel *ua_chan;
1002
421cb601
DG
1003 if (usess == NULL || uchan == NULL) {
1004 ERR("Adding UST global channel to NULL values");
1005 ret = -1;
1006 goto error;
1007 }
1008
48842b30
DG
1009 DBG2("UST app adding channel %s to global domain for session uid %d",
1010 uchan->name, usess->uid);
1011
1012 rcu_read_lock();
421cb601 1013
5b4a0ec0
DG
1014 /* For every registered applications */
1015 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
421cb601
DG
1016 /* Create session on the tracer side and add it to app session HT */
1017 ua_sess = create_ust_app_session(usess, app);
509cbaf8 1018 if (ua_sess == NULL) {
5b4a0ec0 1019 continue;
48842b30
DG
1020 }
1021
421cb601
DG
1022 /* Create channel onto application */
1023 ua_chan = create_ust_app_channel(ua_sess, uchan, app);
1024 if (ua_chan == NULL) {
5b4a0ec0 1025 continue;
48842b30 1026 }
48842b30 1027 }
5b4a0ec0 1028
48842b30
DG
1029 rcu_read_unlock();
1030
421cb601 1031error:
48842b30
DG
1032 return ret;
1033}
1034
5b4a0ec0
DG
1035/*
1036 * For a specific UST session and UST channel, create the event for all
1037 * registered apps.
1038 */
1039int ust_app_create_event_all(struct ltt_ust_session *usess,
48842b30
DG
1040 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
1041{
1042 int ret = 0;
1043 struct cds_lfht_iter iter;
5b4a0ec0 1044 struct cds_lfht_node *ua_chan_node;
48842b30
DG
1045 struct ust_app *app;
1046 struct ust_app_session *ua_sess;
1047 struct ust_app_channel *ua_chan;
1048 struct ust_app_event *ua_event;
48842b30 1049
284d8f55 1050 DBG("UST app creating event %s for all apps for session uid %d",
48842b30
DG
1051 uevent->attr.name, usess->uid);
1052
1053 rcu_read_lock();
421cb601
DG
1054
1055 /* For all registered applications */
5b4a0ec0 1056 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
421cb601
DG
1057 /* Create session on the tracer side and add it to app session HT */
1058 ua_sess = create_ust_app_session(usess, app);
509cbaf8 1059 if (ua_sess == NULL) {
5b4a0ec0 1060 continue;
48842b30
DG
1061 }
1062
1063 /* Lookup channel in the ust app session */
1064 ua_chan_node = hashtable_lookup(ua_sess->channels,
421cb601 1065 (void *)uchan->name, strlen(uchan->name), &iter);
48842b30 1066 if (ua_chan_node == NULL) {
421cb601
DG
1067 ERR("Channel %s not found in session uid %d. Skipping",
1068 uchan->name, usess->uid);
5b4a0ec0 1069 continue;
48842b30 1070 }
48842b30
DG
1071 ua_chan = caa_container_of(ua_chan_node, struct ust_app_channel, node);
1072
421cb601
DG
1073 ua_event = create_ust_app_event(ua_sess, ua_chan, uevent, app);
1074 if (ua_event == NULL) {
5b4a0ec0 1075 continue;
48842b30 1076 }
48842b30 1077 }
5b4a0ec0 1078
48842b30
DG
1079 rcu_read_unlock();
1080
1081 return ret;
1082}
1083
5b4a0ec0
DG
1084/*
1085 * Start tracing for a specific UST session and app.
1086 */
421cb601 1087int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
48842b30
DG
1088{
1089 int ret = 0;
1090 struct cds_lfht_iter iter;
48842b30
DG
1091 struct ust_app_session *ua_sess;
1092 struct ust_app_channel *ua_chan;
5b4a0ec0 1093 struct ltt_ust_stream *ustream;
48842b30 1094
421cb601 1095 DBG("Starting tracing for ust app pid %d", app->key.pid);
5cf5d0e7 1096
509cbaf8
MD
1097 rcu_read_lock();
1098
421cb601
DG
1099 ua_sess = lookup_session_by_app(usess, app);
1100 if (ua_sess == NULL) {
1101 /* Only malloc can failed so something is really wrong */
509cbaf8 1102 goto error_rcu_unlock;
421cb601 1103 }
48842b30 1104
421cb601
DG
1105 ret = create_ust_app_metadata(ua_sess, usess->pathname, app);
1106 if (ret < 0) {
509cbaf8 1107 goto error_rcu_unlock;
421cb601 1108 }
48842b30 1109
421cb601 1110 /* For each channel */
5b4a0ec0 1111 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
421cb601
DG
1112 /* Create all streams */
1113 while (1) {
5b4a0ec0 1114 /* Create UST stream */
421cb601
DG
1115 ustream = zmalloc(sizeof(*ustream));
1116 if (ustream == NULL) {
1117 PERROR("zmalloc ust stream");
509cbaf8 1118 goto error_rcu_unlock;
421cb601 1119 }
48842b30 1120
421cb601
DG
1121 ret = ustctl_create_stream(app->key.sock, ua_chan->obj,
1122 &ustream->obj);
48842b30 1123 if (ret < 0) {
421cb601
DG
1124 /* Got all streams */
1125 break;
48842b30 1126 }
421cb601 1127 ustream->handle = ustream->obj->handle;
48842b30 1128
421cb601
DG
1129 /* Order is important */
1130 cds_list_add_tail(&ustream->list, &ua_chan->streams.head);
1131 ret = snprintf(ustream->pathname, PATH_MAX, "%s/%s-%d/%s_%u",
1132 usess->pathname, app->name, app->key.pid,
1133 ua_chan->name, ua_chan->streams.count++);
aba8e916
DG
1134 if (ret < 0) {
1135 PERROR("asprintf UST create stream");
421cb601 1136 continue;
aba8e916 1137 }
421cb601
DG
1138 DBG2("UST stream %d ready at %s", ua_chan->streams.count,
1139 ustream->pathname);
1140 }
421cb601 1141 }
aba8e916 1142
421cb601 1143 /* Setup UST consumer socket and send fds to it */
ba5d816e 1144 ret = ust_consumer_send_session(ust_consumer_fd, ua_sess);
421cb601 1145 if (ret < 0) {
509cbaf8 1146 goto error_rcu_unlock;
421cb601 1147 }
48842b30 1148
421cb601
DG
1149 /* This start the UST tracing */
1150 ret = ustctl_start_session(app->key.sock, ua_sess->handle);
1151 if (ret < 0) {
1152 ERR("Error starting tracing for app pid: %d", app->key.pid);
509cbaf8 1153 goto error_rcu_unlock;
421cb601 1154 }
5b4a0ec0 1155
509cbaf8 1156 rcu_read_unlock();
48842b30 1157
421cb601
DG
1158 /* Quiescent wait after starting trace */
1159 ustctl_wait_quiescent(app->key.sock);
48842b30 1160
421cb601 1161 return 0;
48842b30 1162
509cbaf8
MD
1163error_rcu_unlock:
1164 rcu_read_unlock();
421cb601
DG
1165 return -1;
1166}
48842b30 1167
5b4a0ec0
DG
1168/*
1169 * Start tracing for the UST session.
1170 */
421cb601
DG
1171int ust_app_start_trace_all(struct ltt_ust_session *usess)
1172{
1173 int ret = 0;
1174 struct cds_lfht_iter iter;
421cb601 1175 struct ust_app *app;
48842b30 1176
421cb601
DG
1177 DBG("Starting all UST traces");
1178
1179 rcu_read_lock();
421cb601 1180
5b4a0ec0 1181 cds_lfht_for_each_entry(ust_app_ht, &iter, app, node) {
421cb601 1182 ret = ust_app_start_trace(usess, app);
48842b30 1183 if (ret < 0) {
5b4a0ec0
DG
1184 /* Continue to next apps even on error */
1185 continue;
48842b30 1186 }
48842b30 1187 }
5b4a0ec0 1188
48842b30
DG
1189 rcu_read_unlock();
1190
1191 return 0;
1192}
487cf67c 1193
5b4a0ec0
DG
1194/*
1195 * Add channels/events from UST global domain to registered apps at sock.
1196 */
487cf67c
DG
1197void ust_app_global_update(struct ltt_ust_session *usess, int sock)
1198{
1199 int ret = 0;
487cf67c 1200 struct cds_lfht_iter iter;
487cf67c
DG
1201 struct ust_app *app;
1202 struct ust_app_session *ua_sess;
1203 struct ust_app_channel *ua_chan;
1204 struct ust_app_event *ua_event;
1f3580c7
DG
1205
1206 if (usess == NULL) {
5b4a0ec0 1207 ERR("No UST session on global update. Returning");
1f3580c7
DG
1208 goto error;
1209 }
1210
487cf67c
DG
1211 DBG2("UST app global update for app sock %d for session uid %d", sock,
1212 usess->uid);
1213
284d8f55
DG
1214 rcu_read_lock();
1215
487cf67c
DG
1216 app = find_app_by_sock(sock);
1217 if (app == NULL) {
1218 ERR("Failed to update app sock %d", sock);
1219 goto error;
1220 }
1221
421cb601 1222 ua_sess = create_ust_app_session(usess, app);
487cf67c 1223 if (ua_sess == NULL) {
487cf67c
DG
1224 goto error;
1225 }
1226
284d8f55
DG
1227 /*
1228 * We can iterate safely here over all UST app session sicne the create ust
1229 * app session above made a shadow copy of the UST global domain from the
1230 * ltt ust session.
1231 */
1232 cds_lfht_for_each_entry(ua_sess->channels, &iter, ua_chan, node) {
1233 ret = create_ust_channel(app, ua_sess, ua_chan);
1234 if (ret < 0) {
1235 /* FIXME: Should we quit here or continue... */
1236 continue;
487cf67c
DG
1237 }
1238
284d8f55
DG
1239 /* For each events */
1240 cds_lfht_for_each_entry(ua_chan->events, &iter, ua_event, node) {
1241 ret = create_ust_event(app, ua_sess, ua_chan, ua_event);
1242 if (ret < 0) {
1243 /* FIXME: Should we quit here or continue... */
1244 continue;
487cf67c 1245 }
36dc12cc 1246 }
487cf67c
DG
1247 }
1248
36dc12cc 1249 if (usess->start_trace) {
421cb601 1250 ret = ust_app_start_trace(usess, app);
36dc12cc 1251 if (ret < 0) {
36dc12cc
DG
1252 goto error;
1253 }
1254
36dc12cc
DG
1255 DBG2("UST trace started for app pid %d", app->key.pid);
1256 }
1257
487cf67c
DG
1258error:
1259 rcu_read_unlock();
1260 return;
1261}
This page took 0.144814 seconds and 4 git commands to generate.