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 static void do_cmd_force_switch()
 792 {
 793         struct blocked_consumer *bc;
 794
 795         list_for_each_entry(bc, &blocked_consumers, list) {
 796                 ltt_force_switch(bc->buf, FORCE_FLUSH);
 797         }
 798 }
 799
 800 int process_client_cmd(char *recvbuf, struct ustcomm_source *src)
 801 {
 802         int result;
 803         char trace_name[] = "auto";
 804         char trace_type[] = "ustrelay";
 805         int len;
 806
 807         DBG("received a message! it's: %s", recvbuf);
 808         len = strlen(recvbuf);
 809
 810         if(!strcmp(recvbuf, "print_markers")) {
 811                 print_markers(stderr);
 812         }
 813         else if(!strcmp(recvbuf, "list_markers")) {
 814                 char *ptr;
 815                 size_t size;
 816                 FILE *fp;
 817
 818                 fp = open_memstream(&ptr, &size);
 819                 print_markers(fp);
 820                 fclose(fp);
 821
 822                 result = ustcomm_send_reply(&ustcomm_app.server, ptr, src);
 823
 824                 free(ptr);
 825         }
 826         else if(!strcmp(recvbuf, "start")) {
 827                 /* start is an operation that setups the trace, allocates it and starts it */
 828                 result = ltt_trace_setup(trace_name);
 829                 if(result < 0) {
 830                         ERR("ltt_trace_setup failed");
 831                         return -1;
 832                 }
 833
 834                 result = ltt_trace_set_type(trace_name, trace_type);
 835                 if(result < 0) {
 836                         ERR("ltt_trace_set_type failed");
 837                         return -1;
 838                 }
 839
 840                 result = ltt_trace_alloc(trace_name);
 841                 if(result < 0) {
 842                         ERR("ltt_trace_alloc failed");
 843                         return -1;
 844                 }
 845
 846                 inform_consumer_daemon(trace_name);
 847
 848                 result = ltt_trace_start(trace_name);
 849                 if(result < 0) {
 850                         ERR("ltt_trace_start failed");
 851                         return -1;
 852                 }
 853         }
 854         else if(!strcmp(recvbuf, "trace_setup")) {
 855                 DBG("trace setup");
 856
 857                 result = ltt_trace_setup(trace_name);
 858                 if(result < 0) {
 859                         ERR("ltt_trace_setup failed");
 860                         return -1;
 861                 }
 862
 863                 result = ltt_trace_set_type(trace_name, trace_type);
 864                 if(result < 0) {
 865                         ERR("ltt_trace_set_type failed");
 866                         return -1;
 867                 }
 868         }
 869         else if(!strcmp(recvbuf, "trace_alloc")) {
 870                 DBG("trace alloc");
 871
 872                 result = ltt_trace_alloc(trace_name);
 873                 if(result < 0) {
 874                         ERR("ltt_trace_alloc failed");
 875                         return -1;
 876                 }
 877                 inform_consumer_daemon(trace_name);
 878         }
 879         else if(!strcmp(recvbuf, "trace_create")) {
 880                 DBG("trace create");
 881
 882                 result = ltt_trace_setup(trace_name);
 883                 if(result < 0) {
 884                         ERR("ltt_trace_setup failed");
 885                         return -1;
 886                 }
 887
 888                 result = ltt_trace_set_type(trace_name, trace_type);
 889                 if(result < 0) {
 890                         ERR("ltt_trace_set_type failed");
 891                         return -1;
 892                 }
 893         }
 894         else if(!strcmp(recvbuf, "trace_start")) {
 895                 DBG("trace start");
 896
 897                 result = ltt_trace_alloc(trace_name);
 898                 if(result < 0) {
 899                         ERR("ltt_trace_alloc failed");
 900                         return -1;
 901                 }
 902                 if(!result) {
 903                         inform_consumer_daemon(trace_name);
 904                 }
 905
 906                 result = ltt_trace_start(trace_name);
 907                 if(result < 0) {
 908                         ERR("ltt_trace_start failed");
 909                         return -1;
 910                 }
 911         }
 912         else if(!strcmp(recvbuf, "trace_stop")) {
 913                 DBG("trace stop");
 914
 915                 result = ltt_trace_stop(trace_name);
 916                 if(result < 0) {
 917                         ERR("ltt_trace_stop failed");
 918                         return -1;
 919                 }
 920         }
 921         else if(!strcmp(recvbuf, "trace_destroy")) {
 922
 923                 DBG("trace destroy");
 924
 925                 result = ltt_trace_destroy(trace_name, 0);
 926                 if(result < 0) {
 927                         ERR("ltt_trace_destroy failed");
 928                         return -1;
 929                 }
 930         }
 931         else if(nth_token_is(recvbuf, "get_shmid", 0) == 1) {
 932                 do_cmd_get_shmid(recvbuf, src);
 933         }
 934         else if(nth_token_is(recvbuf, "get_n_subbufs", 0) == 1) {
 935                 do_cmd_get_n_subbufs(recvbuf, src);
 936         }
 937         else if(nth_token_is(recvbuf, "get_subbuf_size", 0) == 1) {
 938                 do_cmd_get_subbuf_size(recvbuf, src);
 939         }
 940         else if(nth_token_is(recvbuf, "load_probe_lib", 0) == 1) {
 941                 char *libfile;
 942
 943                 libfile = nth_token(recvbuf, 1);
 944
 945                 DBG("load_probe_lib loading %s", libfile);
 946
 947                 free(libfile);
 948         }
 949         else if(nth_token_is(recvbuf, "get_subbuffer", 0) == 1) {
 950                 do_cmd_get_subbuffer(recvbuf, src);
 951         }
 952         else if(nth_token_is(recvbuf, "put_subbuffer", 0) == 1) {
 953                 do_cmd_put_subbuffer(recvbuf, src);
 954         }
 955         else if(nth_token_is(recvbuf, "set_subbuf_size", 0) == 1) {
 956                 do_cmd_set_subbuf_size(recvbuf, src);
 957         }
 958         else if(nth_token_is(recvbuf, "set_subbuf_num", 0) == 1) {
 959                 do_cmd_set_subbuf_num(recvbuf, src);
 960         }
 961         else if(nth_token_is(recvbuf, "enable_marker", 0) == 1) {
 962                 char *channel_slash_name = nth_token(recvbuf, 1);
 963                 char channel_name[256]="";
 964                 char marker_name[256]="";
 965
 966                 result = sscanf(channel_slash_name, "%255[^/]/%255s", channel_name, marker_name);
 967
 968                 if(channel_name == NULL || marker_name == NULL) {
 969                         WARN("invalid marker name");
 970                         goto next_cmd;
 971                 }
 972
 973                 result = ltt_marker_connect(channel_name, marker_name, "default");
 974                 if(result < 0) {
 975                         WARN("could not enable marker; channel=%s, name=%s", channel_name, marker_name);
 976                 }
 977         }
 978         else if(nth_token_is(recvbuf, "disable_marker", 0) == 1) {
 979                 char *channel_slash_name = nth_token(recvbuf, 1);
 980                 char *marker_name;
 981                 char *channel_name;
 982
 983                 result = sscanf(channel_slash_name, "%a[^/]/%as", &channel_name, &marker_name);
 984
 985                 if(marker_name == NULL) {
 986                 }
 987
 988                 result = ltt_marker_disconnect(channel_name, marker_name, "default");
 989                 if(result < 0) {
 990                         WARN("could not disable marker; channel=%s, name=%s", channel_name, marker_name);
 991                 }
 992         }
 993         else if(nth_token_is(recvbuf, "get_pidunique", 0) == 1) {
 994                 char *reply;
 995
 996                 asprintf(&reply, "%lld", pidunique);
 997
 998                 result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
 999                 if(result) {
1000                         ERR("listener: get_pidunique: ustcomm_send_reply failed");
1001                         goto next_cmd;
1002                 }
1003
1004                 free(reply);
1005         }
1006         else if(nth_token_is(recvbuf, "get_sock_path", 0) == 1) {
1007                 char *reply = getenv("UST_DAEMON_SOCKET");
1008                 if(!reply) {
1009                         asprintf(&reply, "%s/%s", SOCK_DIR, "ustd");
1010                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
1011                         free(reply);
1012                 }
1013                 else {
1014                         result = ustcomm_send_reply(&ustcomm_app.server, reply, src);
1015                 }
1016                 if(result)
1017                         ERR("ustcomm_send_reply failed");
1018         }
1019         else if(nth_token_is(recvbuf, "set_sock_path", 0) == 1) {
1020                 char *sock_path = nth_token(recvbuf, 1);
1021                 result = setenv("UST_DAEMON_SOCKET", sock_path, 1);
1022                 if(result)
1023                         ERR("cannot set UST_DAEMON_SOCKET environment variable");
1024         }
1025         else if(nth_token_is(recvbuf, "force_switch", 0) == 1) {
1026                 do_cmd_force_switch();
1027         }
1028         else {
1029                 ERR("unable to parse message: %s", recvbuf);
1030         }
1031
1032 next_cmd:
1033
1034         return 0;
1035 }
1036
1037 void *listener_main(void *p)
1038 {
1039         int result;
1040
1041         DBG("LISTENER");
1042
1043         pthread_cleanup_push(listener_cleanup, NULL);
1044
1045         for(;;) {
1046                 struct mpentries mpent;
1047
1048                 multipoll_init(&mpent);
1049
1050                 blocked_consumers_add_to_mp(&mpent);
1051                 ustcomm_mp_add_app_clients(&mpent, &ustcomm_app, process_client_cmd);
1052
1053                 result = multipoll_poll(&mpent, -1);
1054                 if(result == -1) {
1055                         ERR("error in multipoll_poll");
1056                 }
1057
1058                 multipoll_destroy(&mpent);
1059         }
1060
1061         pthread_cleanup_pop(1);
1062 }
1063
1064 /* These should only be accessed in the parent thread,
1065  * not the listener.
1066  */
1067 static volatile sig_atomic_t have_listener = 0;
1068 static pthread_t listener_thread;
1069
1070 void create_listener(void)
1071 {
1072         int result;
1073         sigset_t sig_all_blocked;
1074         sigset_t orig_parent_mask;
1075
1076         if(have_listener) {
1077                 WARN("not creating listener because we already had one");
1078                 return;
1079         }
1080
1081         /* A new thread created by pthread_create inherits the signal mask
1082          * from the parent. To avoid any signal being received by the
1083          * listener thread, we block all signals temporarily in the parent,
1084          * while we create the listener thread.
1085          */
1086
1087         sigfillset(&sig_all_blocked);
1088
1089         result = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask);
1090         if(result) {
1091                 PERROR("pthread_sigmask: %s", strerror(result));
1092         }
1093
1094         result = pthread_create(&listener_thread, NULL, listener_main, NULL);
1095         if(result == -1) {
1096                 PERROR("pthread_create");
1097         }
1098
1099         /* Restore original signal mask in parent */
1100         result = pthread_sigmask(SIG_SETMASK, &orig_parent_mask, NULL);
1101         if(result) {
1102                 PERROR("pthread_sigmask: %s", strerror(result));
1103         }
1104         else {
1105                 have_listener = 1;
1106         }
1107 }
1108
1109 static int init_socket(void)
1110 {
1111         return ustcomm_init_app(getpid(), &ustcomm_app);
1112 }
1113
1114 #define AUTOPROBE_DISABLED      0
1115 #define AUTOPROBE_ENABLE_ALL    1
1116 #define AUTOPROBE_ENABLE_REGEX  2
1117 static int autoprobe_method = AUTOPROBE_DISABLED;
1118 static regex_t autoprobe_regex;
1119
1120 static void auto_probe_connect(struct marker *m)
1121 {
1122         int result;
1123
1124         char* concat_name = NULL;
1125         const char *probe_name = "default";
1126
1127         if(autoprobe_method == AUTOPROBE_DISABLED) {
1128                 return;
1129         }
1130         else if(autoprobe_method == AUTOPROBE_ENABLE_REGEX) {
1131                 result = asprintf(&concat_name, "%s/%s", m->channel, m->name);
1132                 if(result == -1) {
1133                         ERR("auto_probe_connect: asprintf failed (marker %s/%s)",
1134                                 m->channel, m->name);
1135                         return;
1136                 }
1137                 if (regexec(&autoprobe_regex, concat_name, 0, NULL, 0)) {
1138                         free(concat_name);
1139                         return;
1140                 }
1141                 free(concat_name);
1142         }
1143
1144         result = ltt_marker_connect(m->channel, m->name, probe_name);
1145         if(result && result != -EEXIST)
1146                 ERR("ltt_marker_connect (marker = %s/%s, errno = %d)", m->channel, m->name, -result);
1147
1148         DBG("auto connected marker %s (addr: %p) %s to probe default", m->channel, m, m->name);
1149
1150 }
1151
1152 static void __attribute__((constructor)) init()
1153 {
1154         int result;
1155         char* autoprobe_val = NULL;
1156         char* subbuffer_size_val = NULL;
1157         char* subbuffer_count_val = NULL;
1158         unsigned int subbuffer_size;
1159         unsigned int subbuffer_count;
1160         unsigned int power;
1161
1162         /* Assign the pidunique, to be able to differentiate the processes with same
1163          * pid, (before and after an exec).
1164          */
1165         pidunique = make_pidunique();
1166
1167         DBG("Tracectl constructor");
1168
1169         result = init_socket();
1170         if(result == -1) {
1171                 ERR("init_socket error");
1172                 return;
1173         }
1174
1175         create_listener();
1176
1177         autoprobe_val = getenv("UST_AUTOPROBE");
1178         if(autoprobe_val) {
1179                 struct marker_iter iter;
1180
1181                 DBG("Autoprobe enabled.");
1182
1183                 /* Ensure markers are initialized */
1184                 //init_markers();
1185
1186                 /* Ensure marker control is initialized, for the probe */
1187                 init_marker_control();
1188
1189                 /* first, set the callback that will connect the
1190                  * probe on new markers
1191                  */
1192                 if(autoprobe_val[0] == '/') {
1193                         result = regcomp(&autoprobe_regex, autoprobe_val+1, 0);
1194                         if (result) {
1195                                 char regexerr[150];
1196
1197                                 regerror(result, &autoprobe_regex, regexerr, sizeof(regexerr));
1198                                 ERR("cannot parse regex %s (%s), will ignore UST_AUTOPROBE", autoprobe_val, regexerr);
1199                                 /* don't crash the application just for this */
1200                         }
1201                         else {
1202                                 autoprobe_method = AUTOPROBE_ENABLE_REGEX;
1203                         }
1204                 }
1205                 else {
1206                         /* just enable all instrumentation */
1207                         autoprobe_method = AUTOPROBE_ENABLE_ALL;
1208                 }
1209
1210                 marker_set_new_marker_cb(auto_probe_connect);
1211
1212                 /* Now, connect the probes that were already registered. */
1213                 marker_iter_reset(&iter);
1214                 marker_iter_start(&iter);
1215
1216                 DBG("now iterating on markers already registered");
1217                 while(iter.marker) {
1218                         DBG("now iterating on marker %s", iter.marker->name);
1219                         auto_probe_connect(iter.marker);
1220                         marker_iter_next(&iter);
1221                 }
1222         }
1223
1224         if(getenv("UST_OVERWRITE")) {
1225                 int val = atoi(getenv("UST_OVERWRITE"));
1226                 if(val == 0 || val == 1) {
1227                         STORE_SHARED(ust_channels_overwrite_by_default, val);
1228                 }
1229                 else {
1230                         WARN("invalid value for UST_OVERWRITE");
1231                 }
1232         }
1233
1234         if(getenv("UST_AUTOCOLLECT")) {
1235                 int val = atoi(getenv("UST_AUTOCOLLECT"));
1236                 if(val == 0 || val == 1) {
1237                         STORE_SHARED(ust_channels_request_collection_by_default, val);
1238                 }
1239                 else {
1240                         WARN("invalid value for UST_AUTOCOLLECT");
1241                 }
1242         }
1243
1244         subbuffer_size_val = getenv("UST_SUBBUF_SIZE");
1245         if(subbuffer_size_val) {
1246                 sscanf(subbuffer_size_val, "%u", &subbuffer_size);
1247                 power = pow2_higher_or_eq(subbuffer_size);
1248                 if(power != subbuffer_size)
1249                         WARN("using the next power of two for buffer size = %u\n", power);
1250                 chan_infos[LTT_CHANNEL_UST].def_subbufsize = power;
1251         }
1252
1253         subbuffer_count_val = getenv("UST_SUBBUF_NUM");
1254         if(subbuffer_count_val) {
1255                 sscanf(subbuffer_count_val, "%u", &subbuffer_count);
1256                 if(subbuffer_count < 2)
1257                         subbuffer_count = 2;
1258                 chan_infos[LTT_CHANNEL_UST].def_subbufcount = subbuffer_count;
1259         }
1260
1261         if(getenv("UST_TRACE")) {
1262                 char trace_name[] = "auto";
1263                 char trace_type[] = "ustrelay";
1264
1265                 DBG("starting early tracing");
1266
1267                 /* Ensure marker control is initialized */
1268                 init_marker_control();
1269
1270                 /* Ensure markers are initialized */
1271                 init_markers();
1272
1273                 /* Ensure buffers are initialized, for the transport to be available.
1274                  * We are about to set a trace type and it will fail without this.
1275                  */
1276                 init_ustrelay_transport();
1277
1278                 /* FIXME: When starting early tracing (here), depending on the
1279                  * order of constructors, it is very well possible some marker
1280                  * sections are not yet registered. Because of this, some
1281                  * channels may not be registered. Yet, we are about to ask the
1282                  * daemon to collect the channels. Channels which are not yet
1283                  * registered will not be collected.
1284                  *
1285                  * Currently, in LTTng, there is no way to add a channel after
1286                  * trace start. The reason for this is that it induces complex
1287                  * concurrency issues on the trace structures, which can only
1288                  * be resolved using RCU. This has not been done yet. As a
1289                  * workaround, we are forcing the registration of the "ust"
1290                  * channel here. This is the only channel (apart from metadata)
1291                  * that can be reliably used in early tracing.
1292                  *
1293                  * Non-early tracing does not have this problem and can use
1294                  * arbitrary channel names.
1295                  */
1296                 ltt_channels_register("ust");
1297
1298                 result = ltt_trace_setup(trace_name);
1299                 if(result < 0) {
1300                         ERR("ltt_trace_setup failed");
1301                         return;
1302                 }
1303
1304                 result = ltt_trace_set_type(trace_name, trace_type);
1305                 if(result < 0) {
1306                         ERR("ltt_trace_set_type failed");
1307                         return;
1308                 }
1309
1310                 result = ltt_trace_alloc(trace_name);
1311                 if(result < 0) {
1312                         ERR("ltt_trace_alloc failed");
1313                         return;
1314                 }
1315
1316                 result = ltt_trace_start(trace_name);
1317                 if(result < 0) {
1318                         ERR("ltt_trace_start failed");
1319                         return;
1320                 }
1321
1322                 /* Do this after the trace is started in order to avoid creating confusion
1323                  * if the trace fails to start. */
1324                 inform_consumer_daemon(trace_name);
1325         }
1326
1327         return;
1328
1329         /* should decrementally destroy stuff if error */
1330
1331 }
1332
1333 /* This is only called if we terminate normally, not with an unhandled signal,
1334  * so we cannot rely on it. However, for now, LTTV requires that the header of
1335  * the last sub-buffer contain a valid end time for the trace. This is done
1336  * automatically only when the trace is properly stopped.
1337  *
1338  * If the traced program crashed, it is always possible to manually add the
1339  * right value in the header, or to open the trace in text mode.
1340  *
1341  * FIXME: Fix LTTV so it doesn't need this.
1342  */
1343
1344 static void destroy_traces(void)
1345 {
1346         int result;
1347
1348         /* if trace running, finish it */
1349
1350         DBG("destructor stopping traces");
1351
1352         result = ltt_trace_stop("auto");
1353         if(result == -1) {
1354                 ERR("ltt_trace_stop error");
1355         }
1356
1357         result = ltt_trace_destroy("auto", 0);
1358         if(result == -1) {
1359                 ERR("ltt_trace_destroy error");
1360         }
1361 }
1362
1363 static int trace_recording(void)
1364 {
1365         int retval = 0;
1366         struct ust_trace *trace;
1367
1368         ltt_lock_traces();
1369
1370         list_for_each_entry(trace, &ltt_traces.head, list) {
1371                 if(trace->active) {
1372                         retval = 1;
1373                         break;
1374                 }
1375         }
1376
1377         ltt_unlock_traces();
1378
1379         return retval;
1380 }
1381
1382 #if 0
1383 static int have_consumer(void)
1384 {
1385         return !list_empty(&blocked_consumers);
1386 }
1387 #endif
1388
1389 int restarting_usleep(useconds_t usecs)
1390 {
1391         struct timespec tv;
1392         int result;
1393
1394         tv.tv_sec = 0;
1395         tv.tv_nsec = usecs * 1000;
1396
1397         do {
1398                 result = nanosleep(&tv, &tv);
1399         } while(result == -1 && errno == EINTR);
1400
1401         return result;
1402 }
1403
1404 static void stop_listener(void)
1405 {
1406         int result;
1407
1408         if(!have_listener)
1409                 return;
1410
1411         result = pthread_cancel(listener_thread);
1412         if(result != 0) {
1413                 ERR("pthread_cancel: %s", strerror(result));
1414         }
1415         result = pthread_join(listener_thread, NULL);
1416         if(result != 0) {
1417                 ERR("pthread_join: %s", strerror(result));
1418         }
1419 }
1420
1421 /* This destructor keeps the process alive for a few seconds in order
1422  * to leave time to ustd to connect to its buffers. This is necessary
1423  * for programs whose execution is very short. It is also useful in all
1424  * programs when tracing is started close to the end of the program
1425  * execution.
1426  *
1427  * FIXME: For now, this only works for the first trace created in a
1428  * process.
1429  */
1430
1431 static void __attribute__((destructor)) keepalive()
1432 {
1433         if(trace_recording() && LOAD_SHARED(buffers_to_export)) {
1434                 int total = 0;
1435                 DBG("Keeping process alive for consumer daemon...");
1436                 while(LOAD_SHARED(buffers_to_export)) {
1437                         const int interv = 200000;
1438                         restarting_usleep(interv);
1439                         total += interv;
1440
1441                         if(total >= 3000000) {
1442                                 WARN("non-consumed buffers remaining after wait limit; not waiting anymore");
1443                                 break;
1444                         }
1445                 }
1446                 DBG("Finally dying...");
1447         }
1448
1449         destroy_traces();
1450
1451         /* Ask the listener to stop and clean up. */
1452         stop_listener();
1453 }
1454
1455 void ust_potential_exec(void)
1456 {
1457         trace_mark(ust, potential_exec, MARK_NOARGS);
1458
1459         DBG("test");
1460
1461         keepalive();
1462 }
1463
1464 /* Notify ust that there was a fork. This needs to be called inside
1465  * the new process, anytime a process whose memory is not shared with
1466  * the parent is created. If this function is not called, the events
1467  * of the new process will not be collected.
1468  *
1469  * Signals should be disabled before the fork and reenabled only after
1470  * this call in order to guarantee tracing is not started before ust_fork()
1471  * sanitizes the new process.
1472  */
1473
1474 static void ust_fork(void)
1475 {
1476         struct blocked_consumer *bc;
1477         struct blocked_consumer *deletable_bc = NULL;
1478         int result;
1479
1480         /* FIXME: technically, the locks could have been taken before the fork */
1481         DBG("ust: forking");
1482
1483         /* break lock if necessary */
1484         ltt_unlock_traces();
1485
1486         ltt_trace_stop("auto");
1487         ltt_trace_destroy("auto", 1);
1488         /* Delete all active connections */
1489         ustcomm_close_all_connections(&ustcomm_app.server);
1490
1491         /* Delete all blocked consumers */
1492         list_for_each_entry(bc, &blocked_consumers, list) {
1493                 result = close(bc->fd_producer);
1494                 if(result == -1) {
1495                         PERROR("close");
1496                 }
1497                 free(deletable_bc);
1498                 deletable_bc = bc;
1499                 list_del(&bc->list);
1500         }
1501
1502         /* free app, keeping socket file */
1503         ustcomm_fini_app(&ustcomm_app, 1);
1504
1505         STORE_SHARED(buffers_to_export, 0);
1506         have_listener = 0;
1507         init_socket();
1508         create_listener();
1509         ltt_trace_setup("auto");
1510         result = ltt_trace_set_type("auto", "ustrelay");
1511         if(result < 0) {
1512                 ERR("ltt_trace_set_type failed");
1513                 return;
1514         }
1515
1516         ltt_trace_alloc("auto");
1517         ltt_trace_start("auto");
1518         inform_consumer_daemon("auto");
1519 }
1520
1521 void ust_before_fork(ust_fork_info_t *fork_info)
1522 {
1523         /* Disable signals. This is to avoid that the child
1524          * intervenes before it is properly setup for tracing. It is
1525          * safer to disable all signals, because then we know we are not
1526          * breaking anything by restoring the original mask.
1527          */
1528         sigset_t all_sigs;
1529         int result;
1530
1531         /* FIXME:
1532                 - only do this if tracing is active
1533         */
1534
1535         /* Disable signals */
1536         sigfillset(&all_sigs);
1537         result = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs);
1538         if(result == -1) {
1539                 PERROR("sigprocmask");
1540                 return;
1541         }
1542 }
1543
1544 /* Don't call this function directly in a traced program */
1545 static void ust_after_fork_common(ust_fork_info_t *fork_info)
1546 {
1547         int result;
1548
1549         /* Restore signals */
1550         result = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL);
1551         if(result == -1) {
1552                 PERROR("sigprocmask");
1553                 return;
1554         }
1555 }
1556
1557 void ust_after_fork_parent(ust_fork_info_t *fork_info)
1558 {
1559         /* Reenable signals */
1560         ust_after_fork_common(fork_info);
1561 }
1562
1563 void ust_after_fork_child(ust_fork_info_t *fork_info)
1564 {
1565         /* First sanitize the child */
1566         ust_fork();
1567
1568         /* Then reenable interrupts */
1569         ust_after_fork_common(fork_info);
1570 }
1571