src/bin/lttng-sessiond/kernel.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program 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
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _LGPL_SOURCE
  19 #include <errno.h>
  20 #include <fcntl.h>
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <inttypes.h>
  26
  27 #include <common/common.h>
  28 #include <common/kernel-ctl/kernel-ctl.h>
  29 #include <common/kernel-ctl/kernel-ioctl.h>
  30 #include <common/sessiond-comm/sessiond-comm.h>
  31
  32 #include "consumer.h"
  33 #include "kernel.h"
  34 #include "kernel-consumer.h"
  35 #include "kern-modules.h"
  36 #include "utils.h"
  37
  38 /*
  39  * Add context on a kernel channel.
  40  *
  41  * Assumes the ownership of ctx.
  42  */
  43 int kernel_add_channel_context(struct ltt_kernel_channel *chan,
  44                 struct ltt_kernel_context *ctx)
  45 {
  46         int ret;
  47
  48         assert(chan);
  49         assert(ctx);
  50
  51         DBG("Adding context to channel %s", chan->channel->name);
  52         ret = kernctl_add_context(chan->fd, &ctx->ctx);
  53         if (ret < 0) {
  54                 switch (errno) {
  55                 case ENOSYS:
  56                         /* Exists but not available for this kernel */
  57                         ret = LTTNG_ERR_KERN_CONTEXT_UNAVAILABLE;
  58                         goto error;
  59                 case EEXIST:
  60                         /* If EEXIST, we just ignore the error */
  61                         ret = 0;
  62                         goto end;
  63                 default:
  64                         PERROR("add context ioctl");
  65                         ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
  66                         goto error;
  67                 }
  68         }
  69
  70 end:
  71         cds_list_add_tail(&ctx->list, &chan->ctx_list);
  72         ctx->in_list = true;
  73         ctx = NULL;
  74 error:
  75         if (ctx) {
  76                 trace_kernel_destroy_context(ctx);
  77         }
  78         return ret;
  79 }
  80
  81 /*
  82  * Create a new kernel session, register it to the kernel tracer and add it to
  83  * the session daemon session.
  84  */
  85 int kernel_create_session(struct ltt_session *session, int tracer_fd)
  86 {
  87         int ret;
  88         struct ltt_kernel_session *lks;
  89
  90         assert(session);
  91
  92         /* Allocate data structure */
  93         lks = trace_kernel_create_session();
  94         if (lks == NULL) {
  95                 ret = -1;
  96                 goto error;
  97         }
  98
  99         /* Kernel tracer session creation */
 100         ret = kernctl_create_session(tracer_fd);
 101         if (ret < 0) {
 102                 PERROR("ioctl kernel create session");
 103                 goto error;
 104         }
 105
 106         lks->fd = ret;
 107         /* Prevent fd duplication after execlp() */
 108         ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
 109         if (ret < 0) {
 110                 PERROR("fcntl session fd");
 111         }
 112
 113         lks->id = session->id;
 114         lks->consumer_fds_sent = 0;
 115         session->kernel_session = lks;
 116
 117         DBG("Kernel session created (fd: %d)", lks->fd);
 118
 119         return 0;
 120
 121 error:
 122         if (lks) {
 123                 trace_kernel_destroy_session(lks);
 124         }
 125         return ret;
 126 }
 127
 128 /*
 129  * Create a kernel channel, register it to the kernel tracer and add it to the
 130  * kernel session.
 131  */
 132 int kernel_create_channel(struct ltt_kernel_session *session,
 133                 struct lttng_channel *chan)
 134 {
 135         int ret;
 136         struct ltt_kernel_channel *lkc;
 137
 138         assert(session);
 139         assert(chan);
 140
 141         /* Allocate kernel channel */
 142         lkc = trace_kernel_create_channel(chan);
 143         if (lkc == NULL) {
 144                 goto error;
 145         }
 146
 147         DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d, %d",
 148                         chan->name, lkc->channel->attr.overwrite,
 149                         lkc->channel->attr.subbuf_size, lkc->channel->attr.num_subbuf,
 150                         lkc->channel->attr.switch_timer_interval, lkc->channel->attr.read_timer_interval,
 151                         lkc->channel->attr.live_timer_interval, lkc->channel->attr.output);
 152
 153         /* Kernel tracer channel creation */
 154         ret = kernctl_create_channel(session->fd, &lkc->channel->attr);
 155         if (ret < 0) {
 156                 PERROR("ioctl kernel create channel");
 157                 goto error;
 158         }
 159
 160         /* Setup the channel fd */
 161         lkc->fd = ret;
 162         /* Prevent fd duplication after execlp() */
 163         ret = fcntl(lkc->fd, F_SETFD, FD_CLOEXEC);
 164         if (ret < 0) {
 165                 PERROR("fcntl session fd");
 166         }
 167
 168         /* Add channel to session */
 169         cds_list_add(&lkc->list, &session->channel_list.head);
 170         session->channel_count++;
 171         lkc->session = session;
 172
 173         DBG("Kernel channel %s created (fd: %d)", lkc->channel->name, lkc->fd);
 174
 175         return 0;
 176
 177 error:
 178         if (lkc) {
 179                 free(lkc->channel);
 180                 free(lkc);
 181         }
 182         return -1;
 183 }
 184
 185 /*
 186  * Create a kernel event, enable it to the kernel tracer and add it to the
 187  * channel event list of the kernel session.
 188  * We own filter_expression and filter.
 189  */
 190 int kernel_create_event(struct lttng_event *ev,
 191                 struct ltt_kernel_channel *channel,
 192                 char *filter_expression,
 193                 struct lttng_filter_bytecode *filter)
 194 {
 195         int ret;
 196         struct ltt_kernel_event *event;
 197
 198         assert(ev);
 199         assert(channel);
 200
 201         /* We pass ownership of filter_expression and filter */
 202         event = trace_kernel_create_event(ev, filter_expression,
 203                         filter);
 204         if (event == NULL) {
 205                 ret = -1;
 206                 goto error;
 207         }
 208
 209         ret = kernctl_create_event(channel->fd, event->event);
 210         if (ret < 0) {
 211                 switch (errno) {
 212                 case EEXIST:
 213                         break;
 214                 case ENOSYS:
 215                         WARN("Event type not implemented");
 216                         break;
 217                 case ENOENT:
 218                         WARN("Event %s not found!", ev->name);
 219                         break;
 220                 default:
 221                         PERROR("create event ioctl");
 222                 }
 223                 ret = -errno;
 224                 goto free_event;
 225         }
 226
 227         event->type = ev->type;
 228         event->fd = ret;
 229         /* Prevent fd duplication after execlp() */
 230         ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
 231         if (ret < 0) {
 232                 PERROR("fcntl session fd");
 233         }
 234
 235         if (filter) {
 236                 ret = kernctl_filter(event->fd, filter);
 237                 if (ret) {
 238                         goto filter_error;
 239                 }
 240         }
 241
 242         ret = kernctl_enable(event->fd);
 243         if (ret < 0) {
 244                 switch (errno) {
 245                 case EEXIST:
 246                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 247                         break;
 248                 default:
 249                         PERROR("enable kernel event");
 250                         break;
 251                 }
 252                 goto enable_error;
 253         }
 254
 255         /* Add event to event list */
 256         cds_list_add(&event->list, &channel->events_list.head);
 257         channel->event_count++;
 258
 259         DBG("Event %s created (fd: %d)", ev->name, event->fd);
 260
 261         return 0;
 262
 263 enable_error:
 264 filter_error:
 265         {
 266                 int closeret;
 267
 268                 closeret = close(event->fd);
 269                 if (closeret) {
 270                         PERROR("close event fd");
 271                 }
 272         }
 273 free_event:
 274         free(event);
 275 error:
 276         return ret;
 277 }
 278
 279 /*
 280  * Disable a kernel channel.
 281  */
 282 int kernel_disable_channel(struct ltt_kernel_channel *chan)
 283 {
 284         int ret;
 285
 286         assert(chan);
 287
 288         ret = kernctl_disable(chan->fd);
 289         if (ret < 0) {
 290                 PERROR("disable chan ioctl");
 291                 ret = errno;
 292                 goto error;
 293         }
 294
 295         chan->enabled = 0;
 296         DBG("Kernel channel %s disabled (fd: %d)", chan->channel->name, chan->fd);
 297
 298         return 0;
 299
 300 error:
 301         return ret;
 302 }
 303
 304 /*
 305  * Enable a kernel channel.
 306  */
 307 int kernel_enable_channel(struct ltt_kernel_channel *chan)
 308 {
 309         int ret;
 310
 311         assert(chan);
 312
 313         ret = kernctl_enable(chan->fd);
 314         if (ret < 0 && errno != EEXIST) {
 315                 PERROR("Enable kernel chan");
 316                 goto error;
 317         }
 318
 319         chan->enabled = 1;
 320         DBG("Kernel channel %s enabled (fd: %d)", chan->channel->name, chan->fd);
 321
 322         return 0;
 323
 324 error:
 325         return ret;
 326 }
 327
 328 /*
 329  * Enable a kernel event.
 330  */
 331 int kernel_enable_event(struct ltt_kernel_event *event)
 332 {
 333         int ret;
 334
 335         assert(event);
 336
 337         ret = kernctl_enable(event->fd);
 338         if (ret < 0) {
 339                 switch (errno) {
 340                 case EEXIST:
 341                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 342                         break;
 343                 default:
 344                         PERROR("enable kernel event");
 345                         break;
 346                 }
 347                 goto error;
 348         }
 349
 350         event->enabled = 1;
 351         DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd);
 352
 353         return 0;
 354
 355 error:
 356         return ret;
 357 }
 358
 359 /*
 360  * Disable a kernel event.
 361  */
 362 int kernel_disable_event(struct ltt_kernel_event *event)
 363 {
 364         int ret;
 365
 366         assert(event);
 367
 368         ret = kernctl_disable(event->fd);
 369         if (ret < 0) {
 370                 switch (errno) {
 371                 case EEXIST:
 372                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 373                         break;
 374                 default:
 375                         PERROR("disable kernel event");
 376                         break;
 377                 }
 378                 goto error;
 379         }
 380
 381         event->enabled = 0;
 382         DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd);
 383
 384         return 0;
 385
 386 error:
 387         return ret;
 388 }
 389
 390
 391 int kernel_track_pid(struct ltt_kernel_session *session, int pid)
 392 {
 393         int ret;
 394
 395         DBG("Kernel track PID %d for session id %" PRIu64 ".",
 396                         pid, session->id);
 397         ret = kernctl_track_pid(session->fd, pid);
 398         if (!ret) {
 399                 return LTTNG_OK;
 400         }
 401         switch (errno) {
 402         case EINVAL:
 403                 return LTTNG_ERR_INVALID;
 404         case ENOMEM:
 405                 return LTTNG_ERR_NOMEM;
 406         case EEXIST:
 407                 return LTTNG_ERR_PID_TRACKED;
 408         default:
 409                 return LTTNG_ERR_UNK;
 410         }
 411 }
 412
 413 int kernel_untrack_pid(struct ltt_kernel_session *session, int pid)
 414 {
 415         int ret;
 416
 417         DBG("Kernel untrack PID %d for session id %" PRIu64 ".",
 418                         pid, session->id);
 419         ret = kernctl_untrack_pid(session->fd, pid);
 420         if (!ret) {
 421                 return LTTNG_OK;
 422         }
 423         switch (errno) {
 424         case EINVAL:
 425                 return LTTNG_ERR_INVALID;
 426         case ENOMEM:
 427                 return LTTNG_ERR_NOMEM;
 428         case ENOENT:
 429                 return LTTNG_ERR_PID_NOT_TRACKED;
 430         default:
 431                 return LTTNG_ERR_UNK;
 432         }
 433 }
 434
 435 ssize_t kernel_list_tracker_pids(struct ltt_kernel_session *session,
 436                 int **_pids)
 437 {
 438         int fd, ret;
 439         int pid;
 440         ssize_t nbmem, count = 0;
 441         FILE *fp;
 442         int *pids;
 443
 444         fd = kernctl_list_tracker_pids(session->fd);
 445         if (fd < 0) {
 446                 PERROR("kernel tracker pids list");
 447                 goto error;
 448         }
 449
 450         fp = fdopen(fd, "r");
 451         if (fp == NULL) {
 452                 PERROR("kernel tracker pids list fdopen");
 453                 goto error_fp;
 454         }
 455
 456         nbmem = KERNEL_TRACKER_PIDS_INIT_LIST_SIZE;
 457         pids = zmalloc(sizeof(*pids) * nbmem);
 458         if (pids == NULL) {
 459                 PERROR("alloc list pids");
 460                 count = -ENOMEM;
 461                 goto end;
 462         }
 463
 464         while (fscanf(fp, "process { pid = %u; };\n", &pid) == 1) {
 465                 if (count >= nbmem) {
 466                         int *new_pids;
 467                         size_t new_nbmem;
 468
 469                         new_nbmem = nbmem << 1;
 470                         DBG("Reallocating pids list from %zu to %zu entries",
 471                                         nbmem, new_nbmem);
 472                         new_pids = realloc(pids, new_nbmem * sizeof(*new_pids));
 473                         if (new_pids == NULL) {
 474                                 PERROR("realloc list events");
 475                                 free(pids);
 476                                 count = -ENOMEM;
 477                                 goto end;
 478                         }
 479                         /* Zero the new memory */
 480                         memset(new_pids + nbmem, 0,
 481                                 (new_nbmem - nbmem) * sizeof(*new_pids));
 482                         nbmem = new_nbmem;
 483                         pids = new_pids;
 484                 }
 485                 pids[count++] = pid;
 486         }
 487
 488         *_pids = pids;
 489         DBG("Kernel list tracker pids done (%zd pids)", count);
 490 end:
 491         ret = fclose(fp);       /* closes both fp and fd */
 492         if (ret) {
 493                 PERROR("fclose");
 494         }
 495         return count;
 496
 497 error_fp:
 498         ret = close(fd);
 499         if (ret) {
 500                 PERROR("close");
 501         }
 502 error:
 503         return -1;
 504 }
 505
 506 /*
 507  * Create kernel metadata, open from the kernel tracer and add it to the
 508  * kernel session.
 509  */
 510 int kernel_open_metadata(struct ltt_kernel_session *session)
 511 {
 512         int ret;
 513         struct ltt_kernel_metadata *lkm = NULL;
 514
 515         assert(session);
 516
 517         /* Allocate kernel metadata */
 518         lkm = trace_kernel_create_metadata();
 519         if (lkm == NULL) {
 520                 goto error;
 521         }
 522
 523         /* Kernel tracer metadata creation */
 524         ret = kernctl_open_metadata(session->fd, &lkm->conf->attr);
 525         if (ret < 0) {
 526                 goto error_open;
 527         }
 528
 529         lkm->fd = ret;
 530         /* Prevent fd duplication after execlp() */
 531         ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC);
 532         if (ret < 0) {
 533                 PERROR("fcntl session fd");
 534         }
 535
 536         session->metadata = lkm;
 537
 538         DBG("Kernel metadata opened (fd: %d)", lkm->fd);
 539
 540         return 0;
 541
 542 error_open:
 543         trace_kernel_destroy_metadata(lkm);
 544 error:
 545         return -1;
 546 }
 547
 548 /*
 549  * Start tracing session.
 550  */
 551 int kernel_start_session(struct ltt_kernel_session *session)
 552 {
 553         int ret;
 554
 555         assert(session);
 556
 557         ret = kernctl_start_session(session->fd);
 558         if (ret < 0) {
 559                 PERROR("ioctl start session");
 560                 goto error;
 561         }
 562
 563         DBG("Kernel session started");
 564
 565         return 0;
 566
 567 error:
 568         return ret;
 569 }
 570
 571 /*
 572  * Make a kernel wait to make sure in-flight probe have completed.
 573  */
 574 void kernel_wait_quiescent(int fd)
 575 {
 576         int ret;
 577
 578         DBG("Kernel quiescent wait on %d", fd);
 579
 580         ret = kernctl_wait_quiescent(fd);
 581         if (ret < 0) {
 582                 PERROR("wait quiescent ioctl");
 583                 ERR("Kernel quiescent wait failed");
 584         }
 585 }
 586
 587 /*
 588  * Kernel calibrate
 589  */
 590 int kernel_calibrate(int fd, struct lttng_kernel_calibrate *calibrate)
 591 {
 592         int ret;
 593
 594         assert(calibrate);
 595
 596         ret = kernctl_calibrate(fd, calibrate);
 597         if (ret < 0) {
 598                 PERROR("calibrate ioctl");
 599                 return -1;
 600         }
 601
 602         return 0;
 603 }
 604
 605
 606 /*
 607  *  Force flush buffer of metadata.
 608  */
 609 int kernel_metadata_flush_buffer(int fd)
 610 {
 611         int ret;
 612
 613         DBG("Kernel flushing metadata buffer on fd %d", fd);
 614
 615         ret = kernctl_buffer_flush(fd);
 616         if (ret < 0) {
 617                 ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret);
 618         }
 619
 620         return 0;
 621 }
 622
 623 /*
 624  * Force flush buffer for channel.
 625  */
 626 int kernel_flush_buffer(struct ltt_kernel_channel *channel)
 627 {
 628         int ret;
 629         struct ltt_kernel_stream *stream;
 630
 631         assert(channel);
 632
 633         DBG("Flush buffer for channel %s", channel->channel->name);
 634
 635         cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
 636                 DBG("Flushing channel stream %d", stream->fd);
 637                 ret = kernctl_buffer_flush(stream->fd);
 638                 if (ret < 0) {
 639                         PERROR("ioctl");
 640                         ERR("Fail to flush buffer for stream %d (ret: %d)",
 641                                         stream->fd, ret);
 642                 }
 643         }
 644
 645         return 0;
 646 }
 647
 648 /*
 649  * Stop tracing session.
 650  */
 651 int kernel_stop_session(struct ltt_kernel_session *session)
 652 {
 653         int ret;
 654
 655         assert(session);
 656
 657         ret = kernctl_stop_session(session->fd);
 658         if (ret < 0) {
 659                 goto error;
 660         }
 661
 662         DBG("Kernel session stopped");
 663
 664         return 0;
 665
 666 error:
 667         return ret;
 668 }
 669
 670 /*
 671  * Open stream of channel, register it to the kernel tracer and add it
 672  * to the stream list of the channel.
 673  *
 674  * Note: given that the streams may appear in random order wrt CPU
 675  * number (e.g. cpu hotplug), the index value of the stream number in
 676  * the stream name is not necessarily linked to the CPU number.
 677  *
 678  * Return the number of created stream. Else, a negative value.
 679  */
 680 int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
 681 {
 682         int ret;
 683         struct ltt_kernel_stream *lks;
 684
 685         assert(channel);
 686
 687         while ((ret = kernctl_create_stream(channel->fd)) >= 0) {
 688                 lks = trace_kernel_create_stream(channel->channel->name,
 689                                 channel->stream_count);
 690                 if (lks == NULL) {
 691                         ret = close(ret);
 692                         if (ret) {
 693                                 PERROR("close");
 694                         }
 695                         goto error;
 696                 }
 697
 698                 lks->fd = ret;
 699                 /* Prevent fd duplication after execlp() */
 700                 ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
 701                 if (ret < 0) {
 702                         PERROR("fcntl session fd");
 703                 }
 704
 705                 lks->tracefile_size = channel->channel->attr.tracefile_size;
 706                 lks->tracefile_count = channel->channel->attr.tracefile_count;
 707
 708                 /* Add stream to channel stream list */
 709                 cds_list_add(&lks->list, &channel->stream_list.head);
 710                 channel->stream_count++;
 711
 712                 DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd,
 713                                 lks->state);
 714         }
 715
 716         return channel->stream_count;
 717
 718 error:
 719         return -1;
 720 }
 721
 722 /*
 723  * Open the metadata stream and set it to the kernel session.
 724  */
 725 int kernel_open_metadata_stream(struct ltt_kernel_session *session)
 726 {
 727         int ret;
 728
 729         assert(session);
 730
 731         ret = kernctl_create_stream(session->metadata->fd);
 732         if (ret < 0) {
 733                 PERROR("kernel create metadata stream");
 734                 goto error;
 735         }
 736
 737         DBG("Kernel metadata stream created (fd: %d)", ret);
 738         session->metadata_stream_fd = ret;
 739         /* Prevent fd duplication after execlp() */
 740         ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC);
 741         if (ret < 0) {
 742                 PERROR("fcntl session fd");
 743         }
 744
 745         return 0;
 746
 747 error:
 748         return -1;
 749 }
 750
 751 /*
 752  * Get the event list from the kernel tracer and return the number of elements.
 753  */
 754 ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events)
 755 {
 756         int fd, ret;
 757         char *event;
 758         size_t nbmem, count = 0;
 759         FILE *fp;
 760         struct lttng_event *elist;
 761
 762         assert(events);
 763
 764         fd = kernctl_tracepoint_list(tracer_fd);
 765         if (fd < 0) {
 766                 PERROR("kernel tracepoint list");
 767                 goto error;
 768         }
 769
 770         fp = fdopen(fd, "r");
 771         if (fp == NULL) {
 772                 PERROR("kernel tracepoint list fdopen");
 773                 goto error_fp;
 774         }
 775
 776         /*
 777          * Init memory size counter
 778          * See kernel-ctl.h for explanation of this value
 779          */
 780         nbmem = KERNEL_EVENT_INIT_LIST_SIZE;
 781         elist = zmalloc(sizeof(struct lttng_event) * nbmem);
 782         if (elist == NULL) {
 783                 PERROR("alloc list events");
 784                 count = -ENOMEM;
 785                 goto end;
 786         }
 787
 788         while (fscanf(fp, "event { name = %m[^;]; };\n", &event) == 1) {
 789                 if (count >= nbmem) {
 790                         struct lttng_event *new_elist;
 791                         size_t new_nbmem;
 792
 793                         new_nbmem = nbmem << 1;
 794                         DBG("Reallocating event list from %zu to %zu bytes",
 795                                         nbmem, new_nbmem);
 796                         new_elist = realloc(elist, new_nbmem * sizeof(struct lttng_event));
 797                         if (new_elist == NULL) {
 798                                 PERROR("realloc list events");
 799                                 free(event);
 800                                 free(elist);
 801                                 count = -ENOMEM;
 802                                 goto end;
 803                         }
 804                         /* Zero the new memory */
 805                         memset(new_elist + nbmem, 0,
 806                                 (new_nbmem - nbmem) * sizeof(struct lttng_event));
 807                         nbmem = new_nbmem;
 808                         elist = new_elist;
 809                 }
 810                 strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN);
 811                 elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 812                 elist[count].enabled = -1;
 813                 count++;
 814                 free(event);
 815         }
 816
 817         *events = elist;
 818         DBG("Kernel list events done (%zu events)", count);
 819 end:
 820         ret = fclose(fp);       /* closes both fp and fd */
 821         if (ret) {
 822                 PERROR("fclose");
 823         }
 824         return count;
 825
 826 error_fp:
 827         ret = close(fd);
 828         if (ret) {
 829                 PERROR("close");
 830         }
 831 error:
 832         return -1;
 833 }
 834
 835 /*
 836  * Get kernel version and validate it.
 837  */
 838 int kernel_validate_version(int tracer_fd)
 839 {
 840         int ret;
 841         struct lttng_kernel_tracer_version version;
 842         struct lttng_kernel_tracer_abi_version abi_version;
 843
 844         ret = kernctl_tracer_version(tracer_fd, &version);
 845         if (ret < 0) {
 846                 ERR("Failed to retrieve the lttng-modules version");
 847                 goto error;
 848         }
 849
 850         /* Validate version */
 851         if (version.major != VERSION_MAJOR) {
 852                 ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)",
 853                         version.major, VERSION_MAJOR);
 854                 goto error_version;
 855         }
 856         ret = kernctl_tracer_abi_version(tracer_fd, &abi_version);
 857         if (ret < 0) {
 858                 ERR("Failed to retrieve lttng-modules ABI version");
 859                 goto error;
 860         }
 861         if (abi_version.major != LTTNG_MODULES_ABI_MAJOR_VERSION) {
 862                 ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
 863                         abi_version.major, abi_version.minor,
 864                         LTTNG_MODULES_ABI_MAJOR_VERSION);
 865                 goto error;
 866         }
 867         DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
 868                         version.major, version.minor,
 869                         abi_version.major, abi_version.minor);
 870         return 0;
 871
 872 error_version:
 873         ret = -1;
 874
 875 error:
 876         ERR("Kernel tracer version check failed; kernel tracing will not be available");
 877         return ret;
 878 }
 879
 880 /*
 881  * Kernel work-arounds called at the start of sessiond main().
 882  */
 883 int init_kernel_workarounds(void)
 884 {
 885         int ret;
 886         FILE *fp;
 887
 888         /*
 889          * boot_id needs to be read once before being used concurrently
 890          * to deal with a Linux kernel race. A fix is proposed for
 891          * upstream, but the work-around is needed for older kernels.
 892          */
 893         fp = fopen("/proc/sys/kernel/random/boot_id", "r");
 894         if (!fp) {
 895                 goto end_boot_id;
 896         }
 897         while (!feof(fp)) {
 898                 char buf[37] = "";
 899
 900                 ret = fread(buf, 1, sizeof(buf), fp);
 901                 if (ret < 0) {
 902                         /* Ignore error, we don't really care */
 903                 }
 904         }
 905         ret = fclose(fp);
 906         if (ret) {
 907                 PERROR("fclose");
 908         }
 909 end_boot_id:
 910         return 0;
 911 }
 912
 913 /*
 914  * Complete teardown of a kernel session.
 915  */
 916 void kernel_destroy_session(struct ltt_kernel_session *ksess)
 917 {
 918         if (ksess == NULL) {
 919                 DBG3("No kernel session when tearing down session");
 920                 return;
 921         }
 922
 923         DBG("Tearing down kernel session");
 924
 925         /*
 926          * Destroy channels on the consumer if at least one FD has been sent and we
 927          * are in no output mode because the streams are in *no* monitor mode so we
 928          * have to send a command to clean them up or else they leaked.
 929          */
 930         if (!ksess->output_traces && ksess->consumer_fds_sent) {
 931                 int ret;
 932                 struct consumer_socket *socket;
 933                 struct lttng_ht_iter iter;
 934
 935                 /* For each consumer socket. */
 936                 rcu_read_lock();
 937                 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
 938                                 socket, node.node) {
 939                         struct ltt_kernel_channel *chan;
 940
 941                         /* For each channel, ask the consumer to destroy it. */
 942                         cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
 943                                 ret = kernel_consumer_destroy_channel(socket, chan);
 944                                 if (ret < 0) {
 945                                         /* Consumer is probably dead. Use next socket. */
 946                                         continue;
 947                                 }
 948                         }
 949                 }
 950                 rcu_read_unlock();
 951         }
 952
 953         /* Close any relayd session */
 954         consumer_output_send_destroy_relayd(ksess->consumer);
 955
 956         trace_kernel_destroy_session(ksess);
 957 }
 958
 959 /*
 960  * Destroy a kernel channel object. It does not do anything on the tracer side.
 961  */
 962 void kernel_destroy_channel(struct ltt_kernel_channel *kchan)
 963 {
 964         struct ltt_kernel_session *ksess = NULL;
 965
 966         assert(kchan);
 967         assert(kchan->channel);
 968
 969         DBG3("Kernel destroy channel %s", kchan->channel->name);
 970
 971         /* Update channel count of associated session. */
 972         if (kchan->session) {
 973                 /* Keep pointer reference so we can update it after the destroy. */
 974                 ksess = kchan->session;
 975         }
 976
 977         trace_kernel_destroy_channel(kchan);
 978
 979         /*
 980          * At this point the kernel channel is not visible anymore. This is safe
 981          * since in order to work on a visible kernel session, the tracing session
 982          * lock (ltt_session.lock) MUST be acquired.
 983          */
 984         if (ksess) {
 985                 ksess->channel_count--;
 986         }
 987 }
 988
 989 /*
 990  * Take a snapshot for a given kernel session.
 991  *
 992  * Return 0 on success or else return a LTTNG_ERR code.
 993  */
 994 int kernel_snapshot_record(struct ltt_kernel_session *ksess,
 995                 struct snapshot_output *output, int wait,
 996                 uint64_t nb_packets_per_stream)
 997 {
 998         int err, ret, saved_metadata_fd;
 999         struct consumer_socket *socket;
1000         struct lttng_ht_iter iter;
1001         struct ltt_kernel_metadata *saved_metadata;
1002
1003         assert(ksess);
1004         assert(ksess->consumer);
1005         assert(output);
1006
1007         DBG("Kernel snapshot record started");
1008
1009         /* Save current metadata since the following calls will change it. */
1010         saved_metadata = ksess->metadata;
1011         saved_metadata_fd = ksess->metadata_stream_fd;
1012
1013         rcu_read_lock();
1014
1015         ret = kernel_open_metadata(ksess);
1016         if (ret < 0) {
1017                 ret = LTTNG_ERR_KERN_META_FAIL;
1018                 goto error;
1019         }
1020
1021         ret = kernel_open_metadata_stream(ksess);
1022         if (ret < 0) {
1023                 ret = LTTNG_ERR_KERN_META_FAIL;
1024                 goto error_open_stream;
1025         }
1026
1027         /* Send metadata to consumer and snapshot everything. */
1028         cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1029                         socket, node.node) {
1030                 struct consumer_output *saved_output;
1031                 struct ltt_kernel_channel *chan;
1032
1033                 /*
1034                  * Temporarly switch consumer output for our snapshot output. As long
1035                  * as the session lock is taken, this is safe.
1036                  */
1037                 saved_output = ksess->consumer;
1038                 ksess->consumer = output->consumer;
1039
1040                 pthread_mutex_lock(socket->lock);
1041                 /* This stream must not be monitored by the consumer. */
1042                 ret = kernel_consumer_add_metadata(socket, ksess, 0);
1043                 pthread_mutex_unlock(socket->lock);
1044                 /* Put back the saved consumer output into the session. */
1045                 ksess->consumer = saved_output;
1046                 if (ret < 0) {
1047                         ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1048                         goto error_consumer;
1049                 }
1050
1051                 /* For each channel, ask the consumer to snapshot it. */
1052                 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1053                         pthread_mutex_lock(socket->lock);
1054                         ret = consumer_snapshot_channel(socket, chan->fd, output, 0,
1055                                         ksess->uid, ksess->gid,
1056                                         DEFAULT_KERNEL_TRACE_DIR, wait,
1057                                         nb_packets_per_stream);
1058                         pthread_mutex_unlock(socket->lock);
1059                         if (ret < 0) {
1060                                 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1061                                 (void) kernel_consumer_destroy_metadata(socket,
1062                                                 ksess->metadata);
1063                                 goto error_consumer;
1064                         }
1065                 }
1066
1067                 /* Snapshot metadata, */
1068                 pthread_mutex_lock(socket->lock);
1069                 ret = consumer_snapshot_channel(socket, ksess->metadata->fd, output,
1070                                 1, ksess->uid, ksess->gid,
1071                                 DEFAULT_KERNEL_TRACE_DIR, wait, 0);
1072                 pthread_mutex_unlock(socket->lock);
1073                 if (ret < 0) {
1074                         ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1075                         goto error_consumer;
1076                 }
1077
1078                 /*
1079                  * The metadata snapshot is done, ask the consumer to destroy it since
1080                  * it's not monitored on the consumer side.
1081                  */
1082                 (void) kernel_consumer_destroy_metadata(socket, ksess->metadata);
1083         }
1084
1085         ret = LTTNG_OK;
1086
1087 error_consumer:
1088         /* Close newly opened metadata stream. It's now on the consumer side. */
1089         err = close(ksess->metadata_stream_fd);
1090         if (err < 0) {
1091                 PERROR("close snapshot kernel");
1092         }
1093
1094 error_open_stream:
1095         trace_kernel_destroy_metadata(ksess->metadata);
1096 error:
1097         /* Restore metadata state.*/
1098         ksess->metadata = saved_metadata;
1099         ksess->metadata_stream_fd = saved_metadata_fd;
1100
1101         rcu_read_unlock();
1102         return ret;
1103 }
1104
1105 /*
1106  * Get the syscall mask array from the kernel tracer.
1107  *
1108  * Return 0 on success else a negative value. In both case, syscall_mask should
1109  * be freed.
1110  */
1111 int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits)
1112 {
1113         assert(syscall_mask);
1114         assert(nr_bits);
1115
1116         return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits);
1117 }