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