libust/tracectl.c

   1 /* Copyright (C) 2009  Pierre-Marc Fournier
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public
   5  * License as published by the Free Software Foundation; either
   6  * version 2.1 of the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  16  */
  17
  18 /* This file contains the implementation of the UST listener thread, which
  19  * receives trace control commands. It also coordinates the initialization of
  20  * libust.
  21  */
  22
  23 #define _GNU_SOURCE
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <stdint.h>
  27 #include <pthread.h>
  28 #include <signal.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/un.h>
  32 #include <fcntl.h>
  33 #include <poll.h>
  34 #include <regex.h>
  35 #include <urcu/uatomic_arch.h>
  36
  37 #include <ust/marker.h>
  38 #include <ust/tracectl.h>
  39 #include "tracer.h"
  40 #include "usterr.h"
  41 #include "ustcomm.h"
  42 #include "buffers.h"
  43 #include "marker-control.h"
  44 #include "multipoll.h"
  45
  46 #define USTSIGNAL SIGIO
  47
  48 #define MAX_MSG_SIZE (100)
  49 #define MSG_NOTIF 1
  50 #define MSG_REGISTER_NOTIF 2
  51
  52 /* This should only be accessed by the constructor, before the creation
  53  * of the listener, and then only by the listener.
  54  */
  55 s64 pidunique = -1LL;
  56
  57 extern struct chan_info_struct chan_infos[];
  58
  59 struct list_head blocked_consumers = LIST_HEAD_INIT(blocked_consumers);
  60
  61 static struct ustcomm_app ustcomm_app;
  62
  63 struct tracecmd { /* no padding */
  64         uint32_t size;
  65         uint16_t command;
  66 };
  67
  68 /* volatile because shared between the listener and the main thread */
  69 int buffers_to_export = 0;
  70
  71 struct trctl_msg {
  72         /* size: the size of all the fields except size itself */
  73         uint32_t size;
  74         uint16_t type;
  75         /* Only the necessary part of the payload is transferred. It
  76          * may even be none of it.
  77          */
  78         char payload[94];
  79 };
  80
  81 struct consumer_channel {
  82         int fd;
  83         struct ltt_channel_struct *chan;
  84 };
  85
  86 struct blocked_consumer {
  87         int fd_consumer;
  88         int fd_producer;
  89         int tmp_poll_idx;
  90
  91         /* args to ustcomm_send_reply */
  92         struct ustcomm_server server;
  93         struct ustcomm_source src;
  94
  95         /* args to ust_buffers_get_subbuf */
  96         struct ust_buffer *buf;
  97
  98         struct list_head list;
  99 };
 100
 101 static long long make_pidunique(void)
 102 {
 103         s64 retval;
 104         struct timeval tv;
 105
 106         gettimeofday(&tv, NULL);
 107
 108         retval = tv.tv_sec;
 109         retval <<= 32;
 110         retval |= tv.tv_usec;
 111
 112         return retval;
 113 }
 114
 115 static void print_markers(FILE *fp)
 116 {
 117         struct marker_iter iter;
 118
 119         lock_markers();
 120         marker_iter_reset(&iter);
 121         marker_iter_start(&iter);
 122
 123         while(iter.marker) {
 124                 fprintf(fp, "marker: %s/%s %d \"%s\" %p\n", iter.marker->channel, iter.marker->name, (int)imv_read(iter.marker->state), iter.marker->format, iter.marker->location);
 125                 marker_iter_next(&iter);
 126         }
 127         unlock_markers();
 128 }
 129
 130 static int init_socket(void);
 131
 132 /* Ask the daemon to collect a trace called trace_name and being
 133  * produced by this pid.
 134  *
 135  * The trace must be at least allocated. (It can also be started.)
 136  * This is because _ltt_trace_find is used.
 137  */
 138
 139 static void inform_consumer_daemon(const char *trace_name)
 140 {
 141         int i,j;
 142         struct ust_trace *trace;
 143         pid_t pid = getpid();
 144         int result;
 145
 146         ltt_lock_traces();
 147
 148         trace = _ltt_trace_find(trace_name);
 149         if(trace == NULL) {
 150                 WARN("inform_consumer_daemon: could not find trace \"%s\"; it is probably already destroyed", trace_name);
 151                 goto finish;
 152         }
 153
 154         for(i=0; i < trace->nr_channels; i++) {
 155                 if(trace->channels[i].request_collection) {
 156                         /* iterate on all cpus */
 157                         for(j=0; j<trace->channels[i].n_cpus; j++) {
 158                                 char *buf;
 159                                 asprintf(&buf, "%s_%d", trace->channels[i].channel_name, j);
 160                                 result = ustcomm_request_consumer(pid, buf);
 161                                 if(result == -1) {
 162                                         WARN("Failed to request collection for channel %s. Is the daemon available?", trace->channels[i].channel_name);
 163                                         /* continue even if fail */
 164                                 }
 165                                 free(buf);
 166                                 STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)+1);
 167                         }
 168                 }
 169         }
 170
 171         finish:
 172         ltt_unlock_traces();
 173 }
 174
 175 int process_blkd_consumer_act(void *priv, int fd, short events)
 176 {
 177         int result;
 178         long consumed_old = 0;
 179         char *reply;
 180         struct blocked_consumer *bc = (struct blocked_consumer *) priv;
 181         char inbuf;
 182
 183         result = read(bc->fd_producer, &inbuf, 1);
 184         if(result == -1) {
 185                 PERROR("read");
 186                 return -1;
 187         }
 188         if(result == 0) {
 189                 int res;
 190                 DBG("listener: got messsage that a buffer ended");
 191
 192                 res = close(bc->fd_producer);
 193                 if(res == -1) {
 194                         PERROR("close");
 195                 }
 196
 197                 list_del(&bc->list);
 198
 199                 result = ustcomm_send_reply(&bc->server, "END", &bc->src);
 200                 if(result < 0) {
 201                         ERR("ustcomm_send_reply failed");
 202                         return -1;
 203                 }
 204
 205                 return 0;
 206         }
 207
 208         result = ust_buffers_get_subbuf(bc->buf, &consumed_old);
 209         if(result == -EAGAIN) {
 210                 WARN("missed buffer?");
 211                 return 0;
 212         }
 213         else if(result < 0) {
 214                 ERR("ust_buffers_get_subbuf: error: %s", strerror(-result));
 215         }
 216         asprintf(&reply, "%s %ld", "OK", consumed_old);
 217         result = ustcomm_send_reply(&bc->server, reply, &bc->src);
 218         if(result < 0) {
 219                 ERR("ustcomm_send_reply failed");
 220                 free(reply);
 221                 return -1;
 222         }
 223         free(reply);
 224
 225         list_del(&bc->list);
 226
 227         return 0;
 228 }
 229
 230 void blocked_consumers_add_to_mp(struct mpentries *ent)
 231 {
 232         struct blocked_consumer *bc;
 233
 234         list_for_each_entry(bc, &blocked_consumers, list) {
 235                 multipoll_add(ent, bc->fd_producer, POLLIN, process_blkd_consumer_act, bc, NULL);
 236         }
 237
 238 }
 239
 240 void seperate_channel_cpu(const char *channel_and_cpu, char **channel, int *cpu)
 241 {
 242         const char *sep;
 243
 244         sep = rindex(channel_and_cpu, '_');
 245         if(sep == NULL) {
 246                 *cpu = -1;
 247                 sep = channel_and_cpu + strlen(channel_and_cpu);
 248         }
 249         else {
 250                 *cpu = atoi(sep+1);
 251         }
 252
 253         asprintf(channel, "%.*s", (int)(sep-channel_and_cpu), channel_and_cpu);
 254 }
 255
 256 static int do_cmd_get_shmid(const char *recvbuf, struct ustcomm_source *src)
 257 {
 258         int retval = 0;
 259         struct ust_trace *trace;
 260         char trace_name[] = "auto";
 261         int i;
 262         char *channel_and_cpu;
 263         int found = 0;
 264         int result;
 265         char *ch_name;
 266         int ch_cpu;
 267
 268         DBG("get_shmid");
 269
 270         channel_and_cpu = nth_token(recvbuf, 1);
 271         if(channel_and_cpu == NULL) {
 272                 ERR("cannot parse channel");
 273                 goto end;
 274         }
 275
 276         seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
 277         if(ch_cpu == -1) {
 278                 ERR("problem parsing channel name");
 279                 goto free_short_chan_name;
 280         }
 281
 282         ltt_lock_traces();
 283         trace = _ltt_trace_find(trace_name);
 284         ltt_unlock_traces();
 285
 286         if(trace == NULL) {
 287                 ERR("cannot find trace!");
 288                 retval = -1;
 289                 goto free_short_chan_name;
 290         }
 291
 292         for(i=0; i<trace->nr_channels; i++) {
 293                 struct ust_channel *channel = &trace->channels[i];
 294                 struct ust_buffer *buf = channel->buf[ch_cpu];
 295
 296                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 297                         char *reply;
 298
 299 //                      DBG("the shmid for the requested channel is %d", buf->shmid);
 300 //                      DBG("the shmid for its buffer structure is %d", channel->buf_struct_shmids);
 301                         asprintf(&reply, "%d %d", buf->shmid, channel->buf_struct_shmids[ch_cpu]);
 302
 303                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 304                         if(result) {
 305                                 ERR("ustcomm_send_reply failed");
 306                                 free(reply);
 307                                 retval = -1;
 308                                 goto free_short_chan_name;
 309                         }
 310
 311                         free(reply);
 312
 313                         found = 1;
 314                         break;
 315                 }
 316         }
 317
 318         if(!found) {
 319                 ERR("channel not found (%s)", channel_and_cpu);
 320         }
 321
 322         free_short_chan_name:
 323         free(ch_name);
 324
 325         end:
 326         return retval;
 327 }
 328
 329 static int do_cmd_get_n_subbufs(const char *recvbuf, struct ustcomm_source *src)
 330 {
 331         int retval = 0;
 332         struct ust_trace *trace;
 333         char trace_name[] = "auto";
 334         int i;
 335         char *channel_and_cpu;
 336         int found = 0;
 337         int result;
 338         char *ch_name;
 339         int ch_cpu;
 340
 341         DBG("get_n_subbufs");
 342
 343         channel_and_cpu = nth_token(recvbuf, 1);
 344         if(channel_and_cpu == NULL) {
 345                 ERR("cannot parse channel");
 346                 goto end;
 347         }
 348
 349         seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
 350         if(ch_cpu == -1) {
 351                 ERR("problem parsing channel name");
 352                 goto free_short_chan_name;
 353         }
 354
 355         ltt_lock_traces();
 356         trace = _ltt_trace_find(trace_name);
 357         ltt_unlock_traces();
 358
 359         if(trace == NULL) {
 360                 ERR("cannot find trace!");
 361                 retval = -1;
 362                 goto free_short_chan_name;
 363         }
 364
 365         for(i=0; i<trace->nr_channels; i++) {
 366                 struct ust_channel *channel = &trace->channels[i];
 367
 368                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 369                         char *reply;
 370
 371                         DBG("the n_subbufs for the requested channel is %d", channel->subbuf_cnt);
 372                         asprintf(&reply, "%d", channel->subbuf_cnt);
 373
 374                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 375                         if(result) {
 376                                 ERR("ustcomm_send_reply failed");
 377                                 free(reply);
 378                                 retval = -1;
 379                                 goto free_short_chan_name;
 380                         }
 381
 382                         free(reply);
 383                         found = 1;
 384                         break;
 385                 }
 386         }
 387         if(found == 0) {
 388                 ERR("unable to find channel");
 389         }
 390
 391         free_short_chan_name:
 392         free(ch_name);
 393
 394         end:
 395         return retval;
 396 }
 397
 398 static int do_cmd_get_subbuf_size(const char *recvbuf, struct ustcomm_source *src)
 399 {
 400         int retval = 0;
 401         struct ust_trace *trace;
 402         char trace_name[] = "auto";
 403         int i;
 404         char *channel_and_cpu;
 405         int found = 0;
 406         int result;
 407         char *ch_name;
 408         int ch_cpu;
 409
 410         DBG("get_subbuf_size");
 411
 412         channel_and_cpu = nth_token(recvbuf, 1);
 413         if(channel_and_cpu == NULL) {
 414                 ERR("cannot parse channel");
 415                 goto end;
 416         }
 417
 418         seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
 419         if(ch_cpu == -1) {
 420                 ERR("problem parsing channel name");
 421                 goto free_short_chan_name;
 422         }
 423
 424         ltt_lock_traces();
 425         trace = _ltt_trace_find(trace_name);
 426         ltt_unlock_traces();
 427
 428         if(trace == NULL) {
 429                 ERR("cannot find trace!");
 430                 retval = -1;
 431                 goto free_short_chan_name;
 432         }
 433
 434         for(i=0; i<trace->nr_channels; i++) {
 435                 struct ust_channel *channel = &trace->channels[i];
 436
 437                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 438                         char *reply;
 439
 440                         DBG("the subbuf_size for the requested channel is %zd", channel->subbuf_size);
 441                         asprintf(&reply, "%zd", channel->subbuf_size);
 442
 443                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 444                         if(result) {
 445                                 ERR("ustcomm_send_reply failed");
 446                                 free(reply);
 447                                 retval = -1;
 448                                 goto free_short_chan_name;
 449                         }
 450
 451                         free(reply);
 452                         found = 1;
 453                         break;
 454                 }
 455         }
 456         if(found == 0) {
 457                 ERR("unable to find channel");
 458         }
 459
 460         free_short_chan_name:
 461         free(ch_name);
 462
 463         end:
 464         return retval;
 465 }
 466
 467 /* Return the power of two which is equal or higher to v */
 468
 469 static unsigned int pow2_higher_or_eq(unsigned int v)
 470 {
 471         int hb = fls(v);
 472         int hbm1 = hb-1;
 473         int retval = 1<<(hb-1);
 474
 475         if(v-retval == 0)
 476                 return retval;
 477         else
 478                 return retval<<1;
 479 }
 480
 481 static int do_cmd_set_subbuf_size(const char *recvbuf, struct ustcomm_source *src)
 482 {
 483         char *channel_slash_size;
 484         char ch_name[256]="";
 485         unsigned int size, power;
 486         int retval = 0;
 487         struct ust_trace *trace;
 488         char trace_name[] = "auto";
 489         int i;
 490         int found = 0;
 491
 492         DBG("set_subbuf_size");
 493
 494         channel_slash_size = nth_token(recvbuf, 1);
 495         sscanf(channel_slash_size, "%255[^/]/%u", ch_name, &size);
 496
 497         if(ch_name == NULL) {
 498                 ERR("cannot parse channel");
 499                 goto end;
 500         }
 501
 502         power = pow2_higher_or_eq(size);
 503         power = max_t(unsigned int, 2u, power);
 504         if (power != size)
 505                 WARN("using the next power of two for buffer size = %u\n", power);
 506
 507         ltt_lock_traces();
 508         trace = _ltt_trace_find_setup(trace_name);
 509         if(trace == NULL) {
 510                 ERR("cannot find trace!");
 511                 retval = -1;
 512                 goto end;
 513         }
 514
 515         for(i = 0; i < trace->nr_channels; i++) {
 516                 struct ust_channel *channel = &trace->channels[i];
 517
 518                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 519
 520                         channel->subbuf_size = power;
 521                         DBG("the set_subbuf_size for the requested channel is %zd", channel->subbuf_size);
 522
 523                         found = 1;
 524                         break;
 525                 }
 526         }
 527         if(found == 0) {
 528                 ERR("unable to find channel");
 529         }
 530
 531         end:
 532         ltt_unlock_traces();
 533         return retval;
 534 }
 535
 536 static int do_cmd_set_subbuf_num(const char *recvbuf, struct ustcomm_source *src)
 537 {
 538         char *channel_slash_num;
 539         char ch_name[256]="";
 540         unsigned int num;
 541         int retval = 0;
 542         struct ust_trace *trace;
 543         char trace_name[] = "auto";
 544         int i;
 545         int found = 0;
 546
 547         DBG("set_subbuf_num");
 548
 549         channel_slash_num = nth_token(recvbuf, 1);
 550         sscanf(channel_slash_num, "%255[^/]/%u", ch_name, &num);
 551
 552         if(ch_name == NULL) {
 553                 ERR("cannot parse channel");
 554                 goto end;
 555         }
 556         if (num < 2) {
 557                 ERR("subbuffer count should be greater than 2");
 558                 goto end;
 559         }
 560
 561         ltt_lock_traces();
 562         trace = _ltt_trace_find_setup(trace_name);
 563         if(trace == NULL) {
 564                 ERR("cannot find trace!");
 565                 retval = -1;
 566                 goto end;
 567         }
 568
 569         for(i = 0; i < trace->nr_channels; i++) {
 570                 struct ust_channel *channel = &trace->channels[i];
 571
 572                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 573
 574                         channel->subbuf_cnt = num;
 575                         DBG("the set_subbuf_cnt for the requested channel is %zd", channel->subbuf_cnt);
 576
 577                         found = 1;
 578                         break;
 579                 }
 580         }
 581         if(found == 0) {
 582                 ERR("unable to find channel");
 583         }
 584
 585         end:
 586         ltt_unlock_traces();
 587         return retval;
 588 }
 589
 590 static int do_cmd_get_subbuffer(const char *recvbuf, struct ustcomm_source *src)
 591 {
 592         int retval = 0;
 593         struct ust_trace *trace;
 594         char trace_name[] = "auto";
 595         int i;
 596         char *channel_and_cpu;
 597         int found = 0;
 598         char *ch_name;
 599         int ch_cpu;
 600
 601         DBG("get_subbuf");
 602
 603         channel_and_cpu = nth_token(recvbuf, 1);
 604         if(channel_and_cpu == NULL) {
 605                 ERR("cannot parse channel");
 606                 goto end;
 607         }
 608
 609         seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
 610         if(ch_cpu == -1) {
 611                 ERR("problem parsing channel name");
 612                 goto free_short_chan_name;
 613         }
 614
 615         ltt_lock_traces();
 616         trace = _ltt_trace_find(trace_name);
 617
 618         if(trace == NULL) {
 619                 int result;
 620
 621                 DBG("Cannot find trace. It was likely destroyed by the user.");
 622                 result = ustcomm_send_reply(&ustcomm_app.server, "NOTFOUND", src);
 623                 if(result) {
 624                         ERR("ustcomm_send_reply failed");
 625                         retval = -1;
 626                         goto unlock_traces;
 627                 }
 628
 629                 goto unlock_traces;
 630         }
 631
 632         for(i=0; i<trace->nr_channels; i++) {
 633                 struct ust_channel *channel = &trace->channels[i];
 634
 635                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 636                         struct ust_buffer *buf = channel->buf[ch_cpu];
 637                         struct blocked_consumer *bc;
 638
 639                         found = 1;
 640
 641                         bc = (struct blocked_consumer *) malloc(sizeof(struct blocked_consumer));
 642                         if(bc == NULL) {
 643                                 ERR("malloc returned NULL");
 644                                 goto unlock_traces;
 645                         }
 646                         bc->fd_consumer = src->fd;
 647                         bc->fd_producer = buf->data_ready_fd_read;
 648                         bc->buf = buf;
 649                         bc->src = *src;
 650                         bc->server = ustcomm_app.server;
 651
 652                         list_add(&bc->list, &blocked_consumers);
 653
 654                         /* Being here is the proof the daemon has mapped the buffer in its
 655                          * memory. We may now decrement buffers_to_export.
 656                          */
 657                         if(uatomic_read(&buf->consumed) == 0) {
 658                                 DBG("decrementing buffers_to_export");
 659                                 STORE_SHARED(buffers_to_export, LOAD_SHARED(buffers_to_export)-1);
 660                         }
 661
 662                         break;
 663                 }
 664         }
 665         if(found == 0) {
 666                 ERR("unable to find channel");
 667         }
 668
 669         unlock_traces:
 670         ltt_unlock_traces();
 671
 672         free_short_chan_name:
 673         free(ch_name);
 674
 675         end:
 676         return retval;
 677 }
 678
 679 static int do_cmd_put_subbuffer(const char *recvbuf, struct ustcomm_source *src)
 680 {
 681         int retval = 0;
 682         struct ust_trace *trace;
 683         char trace_name[] = "auto";
 684         int i;
 685         char *channel_and_cpu;
 686         int found = 0;
 687         int result;
 688         char *ch_name;
 689         int ch_cpu;
 690         long consumed_old;
 691         char *consumed_old_str;
 692         char *endptr;
 693         char *reply = NULL;
 694
 695         DBG("put_subbuf");
 696
 697         channel_and_cpu = strdup(nth_token(recvbuf, 1));
 698         if(channel_and_cpu == NULL) {
 699                 ERR("cannot parse channel");
 700                 retval = -1;
 701                 goto end;
 702         }
 703
 704         consumed_old_str = strdup(nth_token(recvbuf, 2));
 705         if(consumed_old_str == NULL) {
 706                 ERR("cannot parse consumed_old");
 707                 retval = -1;
 708                 goto free_channel_and_cpu;
 709         }
 710         consumed_old = strtol(consumed_old_str, &endptr, 10);
 711         if(*endptr != '\0') {
 712                 ERR("invalid value for consumed_old");
 713                 retval = -1;
 714                 goto free_consumed_old_str;
 715         }
 716
 717         seperate_channel_cpu(channel_and_cpu, &ch_name, &ch_cpu);
 718         if(ch_cpu == -1) {
 719                 ERR("problem parsing channel name");
 720                 retval = -1;
 721                 goto free_short_chan_name;
 722         }
 723
 724         ltt_lock_traces();
 725         trace = _ltt_trace_find(trace_name);
 726
 727         if(trace == NULL) {
 728                 DBG("Cannot find trace. It was likely destroyed by the user.");
 729                 result = ustcomm_send_reply(&ustcomm_app.server, "NOTFOUND", src);
 730                 if(result) {
 731                         ERR("ustcomm_send_reply failed");
 732                         retval = -1;
 733                         goto unlock_traces;
 734                 }
 735
 736                 goto unlock_traces;
 737         }
 738
 739         for(i=0; i<trace->nr_channels; i++) {
 740                 struct ust_channel *channel = &trace->channels[i];
 741
 742                 if(!strcmp(trace->channels[i].channel_name, ch_name)) {
 743                         struct ust_buffer *buf = channel->buf[ch_cpu];
 744
 745                         found = 1;
 746
 747                         result = ust_buffers_put_subbuf(buf, consumed_old);
 748                         if(result < 0) {
 749                                 WARN("ust_buffers_put_subbuf: error (subbuf=%s)", channel_and_cpu);
 750                                 asprintf(&reply, "%s", "ERROR");
 751                         }
 752                         else {
 753                                 DBG("ust_buffers_put_subbuf: success (subbuf=%s)", channel_and_cpu);
 754                                 asprintf(&reply, "%s", "OK");
 755                         }
 756
 757                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 758                         if(result) {
 759                                 ERR("ustcomm_send_reply failed");
 760                                 free(reply);
 761                                 retval = -1;
 762                                 goto unlock_traces;
 763                         }
 764
 765                         free(reply);
 766                         break;
 767                 }
 768         }
 769         if(found == 0) {
 770                 ERR("unable to find channel");
 771         }
 772
 773         unlock_traces:
 774         ltt_unlock_traces();
 775         free_short_chan_name:
 776         free(ch_name);
 777         free_consumed_old_str:
 778         free(consumed_old_str);
 779         free_channel_and_cpu:
 780         free(channel_and_cpu);
 781
 782         end:
 783         return retval;
 784 }
 785
 786 static void listener_cleanup(void *ptr)
 787 {
 788         ustcomm_fini_app(&ustcomm_app, 0);
 789 }
 790
 791 int process_client_cmd(char *recvbuf, struct ustcomm_source *src)
 792 {
 793         int result;
 794         char trace_name[] = "auto";
 795         char trace_type[] = "ustrelay";
 796         int len;
 797
 798         DBG("received a message! it's: %s", recvbuf);
 799         len = strlen(recvbuf);
 800
 801         if(!strcmp(recvbuf, "print_markers")) {
 802                 print_markers(stderr);
 803         }
 804         else if(!strcmp(recvbuf, "list_markers")) {
 805                 char *ptr;
 806                 size_t size;
 807                 FILE *fp;
 808
 809                 fp = open_memstream(&ptr, &size);
 810                 print_markers(fp);
 811                 fclose(fp);
 812
 813                 result = ustcomm_send_reply(&ustcomm_app.server, ptr, src);
 814
 815                 free(ptr);
 816         }
 817         else if(!strcmp(recvbuf, "start")) {
 818                 /* start is an operation that setups the trace, allocates it and starts it */
 819                 result = ltt_trace_setup(trace_name);
 820                 if(result < 0) {
 821                         ERR("ltt_trace_setup failed");
 822                         return -1;
 823                 }
 824
 825                 result = ltt_trace_set_type(trace_name, trace_type);
 826                 if(result < 0) {
 827                         ERR("ltt_trace_set_type failed");
 828                         return -1;
 829                 }
 830
 831                 result = ltt_trace_alloc(trace_name);
 832                 if(result < 0) {
 833                         ERR("ltt_trace_alloc failed");
 834                         return -1;
 835                 }
 836
 837                 inform_consumer_daemon(trace_name);
 838
 839                 result = ltt_trace_start(trace_name);
 840                 if(result < 0) {
 841                         ERR("ltt_trace_start failed");
 842                         return -1;
 843                 }
 844         }
 845         else if(!strcmp(recvbuf, "trace_setup")) {
 846                 DBG("trace setup");
 847
 848                 result = ltt_trace_setup(trace_name);
 849                 if(result < 0) {
 850                         ERR("ltt_trace_setup failed");
 851                         return -1;
 852                 }
 853
 854                 result = ltt_trace_set_type(trace_name, trace_type);
 855                 if(result < 0) {
 856                         ERR("ltt_trace_set_type failed");
 857                         return -1;
 858                 }
 859         }
 860         else if(!strcmp(recvbuf, "trace_alloc")) {
 861                 DBG("trace alloc");
 862
 863                 result = ltt_trace_alloc(trace_name);
 864                 if(result < 0) {
 865                         ERR("ltt_trace_alloc failed");
 866                         return -1;
 867                 }
 868                 inform_consumer_daemon(trace_name);
 869         }
 870         else if(!strcmp(recvbuf, "trace_create")) {
 871                 DBG("trace create");
 872
 873                 result = ltt_trace_setup(trace_name);
 874                 if(result < 0) {
 875                         ERR("ltt_trace_setup failed");
 876                         return -1;
 877                 }
 878
 879                 result = ltt_trace_set_type(trace_name, trace_type);
 880                 if(result < 0) {
 881                         ERR("ltt_trace_set_type failed");
 882                         return -1;
 883                 }
 884         }
 885         else if(!strcmp(recvbuf, "trace_start")) {
 886                 DBG("trace start");
 887
 888                 result = ltt_trace_alloc(trace_name);
 889                 if(result < 0) {
 890                         ERR("ltt_trace_alloc failed");
 891                         return -1;
 892                 }
 893                 if(!result) {
 894                         inform_consumer_daemon(trace_name);
 895                 }
 896
 897                 result = ltt_trace_start(trace_name);
 898                 if(result < 0) {
 899                         ERR("ltt_trace_start failed");
 900                         return -1;
 901                 }
 902         }
 903         else if(!strcmp(recvbuf, "trace_stop")) {
 904                 DBG("trace stop");
 905
 906                 result = ltt_trace_stop(trace_name);
 907                 if(result < 0) {
 908                         ERR("ltt_trace_stop failed");
 909                         return -1;
 910                 }
 911         }
 912         else if(!strcmp(recvbuf, "trace_destroy")) {
 913
 914                 DBG("trace destroy");
 915
 916                 result = ltt_trace_destroy(trace_name, 0);
 917                 if(result < 0) {
 918                         ERR("ltt_trace_destroy failed");
 919                         return -1;
 920                 }
 921         }
 922         else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) {
 923                 do_cmd_get_shmid(recvbuf, src);
 924         }
 925         else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) {
 926                 do_cmd_get_n_subbufs(recvbuf, src);
 927         }
 928         else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) {
 929                 do_cmd_get_subbuf_size(recvbuf, src);
 930         }
 931         else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) {
 932                 char *libfile;
 933
 934                 libfile = nth_token(recvbuf, 1);
 935
 936                 DBG("load_probe_lib loading %s", libfile);
 937
 938                 free(libfile);
 939         }
 940         else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) {
 941                 do_cmd_get_subbuffer(recvbuf, src);
 942         }
 943         else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) {
 944                 do_cmd_put_subbuffer(recvbuf, src);
 945         }
 946         else if(nth_token_is(recvbuf, "set_subbuf_size", 0) == 1) {
 947                 do_cmd_set_subbuf_size(recvbuf, src);
 948         }
 949         else if(nth_token_is(recvbuf, "set_subbuf_num", 0) == 1) {
 950                 do_cmd_set_subbuf_num(recvbuf, src);
 951         }
 952         else if(nth_token_is(recvbuf, "enable_marker", 0) == 1) {
 953                 char *channel_slash_name = nth_token(recvbuf, 1);
 954                 char channel_name[256]="";
 955                 char marker_name[256]="";
 956
 957                 result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name);
 958
 959                 if(channel_name == NULL || marker_name == NULL) {
 960                         WARN("invalid marker name");
 961                         goto next_cmd;
 962                 }
 963
 964                 result = ltt_marker_connect(channel_name, marker_name, "default");
 965                 if(result < 0) {
 966                         WARN("could not enable marker; channel=%s, name=%s", channel_name, marker_name);
 967                 }
 968         }
 969         else if(nth_token_is(recvbuf, "disable_marker", 0) == 1) {
 970                 char *channel_slash_name = nth_token(recvbuf, 1);
 971                 char *marker_name;
 972                 char *channel_name;
 973
 974                 result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name);
 975
 976                 if(marker_name == NULL) {
 977                 }
 978
 979                 result = ltt_marker_disconnect(channel_name, marker_name, "default");
 980                 if(result < 0) {
 981                         WARN("could not disable marker; channel=%s, name=%s", channel_name, marker_name);
 982                 }
 983         }
 984         else if(nth_token_is(recvbuf, "get_pidunique", 0) == 1) {
 985                 char *reply;
 986
 987                 asprintf(&reply, "%lld", pidunique);
 988
 989                 result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 990                 if(result) {
 991                         ERR("listener: get_pidunique: ustcomm_send_reply failed");
 992                         goto next_cmd;
 993                 }
 994
 995                 free(reply);
 996         }
 997         else if(nth_token_is(recvbuf, "get_sock_path", 0) == 1) {
 998                 char *reply = getenv("UST_DAEMON_SOCKET");
 999                 if(!reply) {
1000                         asprintf(&reply, "%s/%s", SOCK_DIR, "ustd");
1001                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
1002                         free(reply);
1003                 }
1004                 else {
1005                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
1006                 }
1007                 if(result)
1008                         ERR("ustcomm_send_reply failed");
1009         }
1010         else if(nth_token_is(recvbuf, "set_sock_path", 0) == 1) {
1011                 char *sock_path = nth_token(recvbuf, 1);
1012                 result = setenv("UST_DAEMON_SOCKET", sock_path, 1);
1013                 if(result)
1014                         ERR("cannot set UST_DAEMON_SOCKET environment variable");
1015         }
1016         else {
1017                 ERR("unable to parse message: %s", recvbuf);
1018         }
1019
1020 next_cmd:
1021
1022         return 0;
1023 }
1024
1025 void *listener_main(void *p)
1026 {
1027         int result;
1028
1029         DBG("LISTENER");
1030
1031         pthread_cleanup_push(listener_cleanup, NULL);
1032
1033         for(;;) {
1034                 struct mpentries mpent;
1035
1036                 multipoll_init(&mpent);
1037
1038                 blocked_consumers_add_to_mp(&mpent);
1039                 ustcomm_mp_add_app_clients(&mpent, &ustcomm_app, process_client_cmd);
1040
1041                 result = multipoll_poll(&mpent, -1);
1042                 if(result == -1) {
1043                         ERR("error in multipoll_poll");
1044                 }
1045
1046                 multipoll_destroy(&mpent);
1047         }
1048
1049         pthread_cleanup_pop(1);
1050 }
1051
1052 /* These should only be accessed in the parent thread,
1053  * not the listener.
1054  */
1055 static volatile sig_atomic_t have_listener = 0;
1056 static pthread_t listener_thread;
1057
1058 void create_listener(void)
1059 {
1060         int result;
1061         sigset_t sig_all_blocked;
1062         sigset_t orig_parent_mask;
1063
1064         if(have_listener) {
1065                 WARN("not creating listener because we already had one");
1066                 return;
1067         }
1068
1069         /* A new thread created by pthread_create inherits the signal mask
1070          * from the parent. To avoid any signal being received by the
1071          * listener thread, we block all signals temporarily in the parent,
1072          * while we create the listener thread.
1073          */
1074
1075         sigfillset(&sig_all_blocked);
1076
1077         result = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask);
1078         if(result) {
1079                 PERROR("pthread_sigmask: %s", strerror(result));
1080         }
1081
1082         result = pthread_create(&listener_thread, NULL, listener_main, NULL);
1083         if(result == -1) {
1084                 PERROR("pthread_create");
1085         }
1086
1087         /* Restore original signal mask in parent */
1088         result = pthread_sigmask(SIG_SETMASK, &orig_parent_mask, NULL);
1089         if(result) {
1090                 PERROR("pthread_sigmask: %s", strerror(result));
1091         }
1092         else {
1093                 have_listener = 1;
1094         }
1095 }
1096
1097 static int init_socket(void)
1098 {
1099         return ustcomm_init_app(getpid(), &ustcomm_app);
1100 }
1101
1102 #define AUTOPROBE_DISABLED      0
1103 #define AUTOPROBE_ENABLE_ALL    1
1104 #define AUTOPROBE_ENABLE_REGEX  2
1105 static int autoprobe_method = AUTOPROBE_DISABLED;
1106 static regex_t autoprobe_regex;
1107
1108 static void auto_probe_connect(struct marker *m)
1109 {
1110         int result;
1111
1112         char* concat_name = NULL;
1113         const char *probe_name = "default";
1114
1115         if(autoprobe_method == AUTOPROBE_DISABLED) {
1116                 return;
1117         }
1118         else if(autoprobe_method == AUTOPROBE_ENABLE_REGEX) {
1119                 result = asprintf(&concat_name, "%s/%s", m->channel, m->name);
1120                 if(result == -1) {
1121                         ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1122                                 m->channel, m->name);
1123                         return;
1124                 }
1125                 if (regexec(&autoprobe_regex, concat_name, 0, NULL, 0)) {
1126                         free(concat_name);
1127                         return;
1128                 }
1129                 free(concat_name);
1130         }
1131
1132         result = ltt_marker_connect(m->channel, m->name, probe_name);
1133         if(result && result != -EEXIST)
1134                 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m->channel, m->name, -result);
1135
1136         DBG("auto connected marker %s (addr: %p) %s to probe default", m->channel, m, m->name);
1137
1138 }
1139
1140 static void __attribute__((constructor)) init()
1141 {
1142         int result;
1143         char* autoprobe_val = NULL;
1144         char* subbuffer_size_val = NULL;
1145         char* subbuffer_count_val = NULL;
1146         unsigned int subbuffer_size;
1147         unsigned int subbuffer_count;
1148         unsigned int power;
1149
1150         /* Assign the pidunique, to be able to differentiate the processes with same
1151          * pid, (before and after an exec).
1152          */
1153         pidunique = make_pidunique();
1154
1155         DBG("Tracectl constructor");
1156
1157         result = init_socket();
1158         if(result == -1) {
1159                 ERR("init_socket error");
1160                 return;
1161         }
1162
1163         create_listener();
1164
1165         autoprobe_val = getenv("UST_AUTOPROBE");
1166         if(autoprobe_val) {
1167                 struct marker_iter iter;
1168
1169                 DBG("Autoprobe enabled.");
1170
1171                 /* Ensure markers are initialized */
1172                 //init_markers();
1173
1174                 /* Ensure marker control is initialized, for the probe */
1175                 init_marker_control();
1176
1177                 /* first, set the callback that will connect the
1178                  * probe on new markers
1179                  */
1180                 if(autoprobe_val[0] == '/') {
1181                         result = regcomp(&autoprobe_regex, autoprobe_val+1, 0);
1182                         if (result) {
1183                                 char regexerr[150];
1184
1185                                 regerror(result, &autoprobe_regex, regexerr, sizeof(regexerr));
1186                                 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val, regexerr);
1187                                 /* don't crash the application just for this */
1188                         }
1189                         else {
1190                                 autoprobe_method = AUTOPROBE_ENABLE_REGEX;
1191                         }
1192                 }
1193                 else {
1194                         /* just enable all instrumentation */
1195                         autoprobe_method = AUTOPROBE_ENABLE_ALL;
1196                 }
1197
1198                 marker_set_new_marker_cb(auto_probe_connect);
1199
1200                 /* Now, connect the probes that were already registered. */
1201                 marker_iter_reset(&iter);
1202                 marker_iter_start(&iter);
1203
1204                 DBG("now iterating on markers already registered");
1205                 while(iter.marker) {
1206                         DBG("now iterating on marker %s", iter.marker->name);
1207                         auto_probe_connect(iter.marker);
1208                         marker_iter_next(&iter);
1209                 }
1210         }
1211
1212         if(getenv("UST_OVERWRITE")) {
1213                 int val = atoi(getenv("UST_OVERWRITE"));
1214                 if(val == 0 || val == 1) {
1215                         STORE_SHARED(ust_channels_overwrite_by_default, val);
1216                 }
1217                 else {
1218                         WARN("invalid value for UST_OVERWRITE");
1219                 }
1220         }
1221
1222         if(getenv("UST_AUTOCOLLECT")) {
1223                 int val = atoi(getenv("UST_AUTOCOLLECT"));
1224                 if(val == 0 || val == 1) {
1225                         STORE_SHARED(ust_channels_request_collection_by_default, val);
1226                 }
1227                 else {
1228                         WARN("invalid value for UST_AUTOCOLLECT");
1229                 }
1230         }
1231
1232         subbuffer_size_val = getenv("UST_SUBBUF_SIZE");
1233         if(subbuffer_size_val) {
1234                 sscanf(subbuffer_size_val, "%u", &subbuffer_size);
1235                 power = pow2_higher_or_eq(subbuffer_size);
1236                 if(power != subbuffer_size)
1237                         WARN("using the next power of two for buffer size = %u\n", power);
1238                 chan_infos[LTT_CHANNEL_UST].def_subbufsize = power;
1239         }
1240
1241         subbuffer_count_val = getenv("UST_SUBBUF_NUM");
1242         if(subbuffer_count_val) {
1243                 sscanf(subbuffer_count_val, "%u", &subbuffer_count);
1244                 if(subbuffer_count < 2)
1245                         subbuffer_count = 2;
1246                 chan_infos[LTT_CHANNEL_UST].def_subbufcount = subbuffer_count;
1247         }
1248
1249         if(getenv("UST_TRACE")) {
1250                 char trace_name[] = "auto";
1251                 char trace_type[] = "ustrelay";
1252
1253                 DBG("starting early tracing");
1254
1255                 /* Ensure marker control is initialized */
1256                 init_marker_control();
1257
1258                 /* Ensure markers are initialized */
1259                 init_markers();
1260
1261                 /* Ensure buffers are initialized, for the transport to be available.
1262                  * We are about to set a trace type and it will fail without this.
1263                  */
1264                 init_ustrelay_transport();
1265
1266                 /* FIXME: When starting early tracing (here), depending on the
1267                  * order of constructors, it is very well possible some marker
1268                  * sections are not yet registered. Because of this, some
1269                  * channels may not be registered. Yet, we are about to ask the
1270                  * daemon to collect the channels. Channels which are not yet
1271                  * registered will not be collected.
1272                  *
1273                  * Currently, in LTTng, there is no way to add a channel after
1274                  * trace start. The reason for this is that it induces complex
1275                  * concurrency issues on the trace structures, which can only
1276                  * be resolved using RCU. This has not been done yet. As a
1277                  * workaround, we are forcing the registration of the "ust"
1278                  * channel here. This is the only channel (apart from metadata)
1279                  * that can be reliably used in early tracing.
1280                  *
1281                  * Non-early tracing does not have this problem and can use
1282                  * arbitrary channel names.
1283                  */
1284                 ltt_channels_register("ust");
1285
1286                 result = ltt_trace_setup(trace_name);
1287                 if(result < 0) {
1288                         ERR("ltt_trace_setup failed");
1289                         return;
1290                 }
1291
1292                 result = ltt_trace_set_type(trace_name, trace_type);
1293                 if(result < 0) {
1294                         ERR("ltt_trace_set_type failed");
1295                         return;
1296                 }
1297
1298                 result = ltt_trace_alloc(trace_name);
1299                 if(result < 0) {
1300                         ERR("ltt_trace_alloc failed");
1301                         return;
1302                 }
1303
1304                 result = ltt_trace_start(trace_name);
1305                 if(result < 0) {
1306                         ERR("ltt_trace_start failed");
1307                         return;
1308                 }
1309
1310                 /* Do this after the trace is started in order to avoid creating confusion
1311                  * if the trace fails to start. */
1312                 inform_consumer_daemon(trace_name);
1313         }
1314
1315         return;
1316
1317         /* should decrementally destroy stuff if error */
1318
1319 }
1320
1321 /* This is only called if we terminate normally, not with an unhandled signal,
1322  * so we cannot rely on it. However, for now, LTTV requires that the header of
1323  * the last sub-buffer contain a valid end time for the trace. This is done
1324  * automatically only when the trace is properly stopped.
1325  *
1326  * If the traced program crashed, it is always possible to manually add the
1327  * right value in the header, or to open the trace in text mode.
1328  *
1329  * FIXME: Fix LTTV so it doesn't need this.
1330  */
1331
1332 static void destroy_traces(void)
1333 {
1334         int result;
1335
1336         /* if trace running, finish it */
1337
1338         DBG("destructor stopping traces");
1339
1340         result = ltt_trace_stop("auto");
1341         if(result == -1) {
1342                 ERR("ltt_trace_stop error");
1343         }
1344
1345         result = ltt_trace_destroy("auto", 0);
1346         if(result == -1) {
1347                 ERR("ltt_trace_destroy error");
1348         }
1349 }
1350
1351 static int trace_recording(void)
1352 {
1353         int retval = 0;
1354         struct ust_trace *trace;
1355
1356         ltt_lock_traces();
1357
1358         list_for_each_entry(trace, &ltt_traces.head, list) {
1359                 if(trace->active) {
1360                         retval = 1;
1361                         break;
1362                 }
1363         }
1364
1365         ltt_unlock_traces();
1366
1367         return retval;
1368 }
1369
1370 #if 0
1371 static int have_consumer(void)
1372 {
1373         return !list_empty(&blocked_consumers);
1374 }
1375 #endif
1376
1377 int restarting_usleep(useconds_t usecs)
1378 {
1379         struct timespec tv;
1380         int result;
1381
1382         tv.tv_sec = 0;
1383         tv.tv_nsec = usecs * 1000;
1384
1385         do {
1386                 result = nanosleep(&tv, &tv);
1387         } while(result == -1 && errno == EINTR);
1388
1389         return result;
1390 }
1391
1392 static void stop_listener(void)
1393 {
1394         int result;
1395
1396         if(!have_listener)
1397                 return;
1398
1399         result = pthread_cancel(listener_thread);
1400         if(result != 0) {
1401                 ERR("pthread_cancel: %s", strerror(result));
1402         }
1403         result = pthread_join(listener_thread, NULL);
1404         if(result != 0) {
1405                 ERR("pthread_join: %s", strerror(result));
1406         }
1407 }
1408
1409 /* This destructor keeps the process alive for a few seconds in order
1410  * to leave time to ustd to connect to its buffers. This is necessary
1411  * for programs whose execution is very short. It is also useful in all
1412  * programs when tracing is started close to the end of the program
1413  * execution.
1414  *
1415  * FIXME: For now, this only works for the first trace created in a
1416  * process.
1417  */
1418
1419 static void __attribute__((destructor)) keepalive()
1420 {
1421         if(trace_recording() && LOAD_SHARED(buffers_to_export)) {
1422                 int total = 0;
1423                 DBG("Keeping process alive for consumer daemon...");
1424                 while(LOAD_SHARED(buffers_to_export)) {
1425                         const int interv = 200000;
1426                         restarting_usleep(interv);
1427                         total += interv;
1428
1429                         if(total >= 3000000) {
1430                                 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1431                                 break;
1432                         }
1433                 }
1434                 DBG("Finally dying...");
1435         }
1436
1437         destroy_traces();
1438
1439         /* Ask the listener to stop and clean up. */
1440         stop_listener();
1441 }
1442
1443 void ust_potential_exec(void)
1444 {
1445         trace_mark(ust, potential_exec, MARK_NOARGS);
1446
1447         DBG("test");
1448
1449         keepalive();
1450 }
1451
1452 /* Notify ust that there was a fork. This needs to be called inside
1453  * the new process, anytime a process whose memory is not shared with
1454  * the parent is created. If this function is not called, the events
1455  * of the new process will not be collected.
1456  *
1457  * Signals should be disabled before the fork and reenabled only after
1458  * this call in order to guarantee tracing is not started before ust_fork()
1459  * sanitizes the new process.
1460  */
1461
1462 static void ust_fork(void)
1463 {
1464         struct blocked_consumer *bc;
1465         struct blocked_consumer *deletable_bc = NULL;
1466         int result;
1467
1468         /* FIXME: technically, the locks could have been taken before the fork */
1469         DBG("ust: forking");
1470
1471         /* break lock if necessary */
1472         ltt_unlock_traces();
1473
1474         ltt_trace_stop("auto");
1475         ltt_trace_destroy("auto", 1);
1476         /* Delete all active connections */
1477         ustcomm_close_all_connections(&ustcomm_app.server);
1478
1479         /* Delete all blocked consumers */
1480         list_for_each_entry(bc, &blocked_consumers, list) {
1481                 result = close(bc->fd_producer);
1482                 if(result == -1) {
1483                         PERROR("close");
1484                 }
1485                 free(deletable_bc);
1486                 deletable_bc = bc;
1487                 list_del(&bc->list);
1488         }
1489
1490         /* free app, keeping socket file */
1491         ustcomm_fini_app(&ustcomm_app, 1);
1492
1493         STORE_SHARED(buffers_to_export, 0);
1494         have_listener = 0;
1495         init_socket();
1496         create_listener();
1497         ltt_trace_setup("auto");
1498         result = ltt_trace_set_type("auto", "ustrelay");
1499         if(result < 0) {
1500                 ERR("ltt_trace_set_type failed");
1501                 return;
1502         }
1503
1504         ltt_trace_alloc("auto");
1505         ltt_trace_start("auto");
1506         inform_consumer_daemon("auto");
1507 }
1508
1509 void ust_before_fork(ust_fork_info_t *fork_info)
1510 {
1511         /* Disable signals. This is to avoid that the child
1512          * intervenes before it is properly setup for tracing. It is
1513          * safer to disable all signals, because then we know we are not
1514          * breaking anything by restoring the original mask.
1515          */
1516         sigset_t all_sigs;
1517         int result;
1518
1519         /* FIXME:
1520                 - only do this if tracing is active
1521         */
1522
1523         /* Disable signals */
1524         sigfillset(&all_sigs);
1525         result = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs);
1526         if(result == -1) {
1527                 PERROR("sigprocmask");
1528                 return;
1529         }
1530 }
1531
1532 /* Don't call this function directly in a traced program */
1533 static void ust_after_fork_common(ust_fork_info_t *fork_info)
1534 {
1535         int result;
1536
1537         /* Restore signals */
1538         result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL);
1539         if(result == -1) {
1540                 PERROR("sigprocmask");
1541                 return;
1542         }
1543 }
1544
1545 void ust_after_fork_parent(ust_fork_info_t *fork_info)
1546 {
1547         /* Reenable signals */
1548         ust_after_fork_common(fork_info);
1549 }
1550
1551 void ust_after_fork_child(ust_fork_info_t *fork_info)
1552 {
1553         /* First sanitize the child */
1554         ust_fork();
1555
1556         /* Then reenable interrupts */
1557         ust_after_fork_common(fork_info);
1558 }
1559