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