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