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