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 <fcntl.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <string.h>
  23 #include <unistd.h>
  24 #include <inttypes.h>
  25
  26 #include <common/common.h>
  27 #include <common/kernel-ctl/kernel-ctl.h>
  28 #include <common/kernel-ctl/kernel-ioctl.h>
  29 #include <common/sessiond-comm/sessiond-comm.h>
  30
  31 #include "consumer.h"
  32 #include "kernel.h"
  33 #include "kernel-consumer.h"
  34 #include "kern-modules.h"
  35 #include "utils.h"
  36
  37 /*
  38  * Add context on a kernel channel.
  39  *
  40  * Assumes the ownership of ctx.
  41  */
  42 int kernel_add_channel_context(struct ltt_kernel_channel *chan,
  43                 struct ltt_kernel_context *ctx)
  44 {
  45         int ret;
  46
  47         assert(chan);
  48         assert(ctx);
  49
  50         DBG("Adding context to channel %s", chan->channel->name);
  51         ret = kernctl_add_context(chan->fd, &ctx->ctx);
  52         if (ret < 0) {
  53                 switch (-ret) {
  54                 case ENOSYS:
  55                         /* Exists but not available for this kernel */
  56                         ret = LTTNG_ERR_KERN_CONTEXT_UNAVAILABLE;
  57                         goto error;
  58                 case EEXIST:
  59                         /* If EEXIST, we just ignore the error */
  60                         ret = 0;
  61                         goto end;
  62                 default:
  63                         PERROR("add context ioctl");
  64                         ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
  65                         goto error;
  66                 }
  67         }
  68
  69 end:
  70         cds_list_add_tail(&ctx->list, &chan->ctx_list);
  71         ctx->in_list = true;
  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 (-ret) {
 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                 goto free_event;
 223         }
 224
 225         event->type = ev->type;
 226         event->fd = ret;
 227         /* Prevent fd duplication after execlp() */
 228         ret = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
 229         if (ret < 0) {
 230                 PERROR("fcntl session fd");
 231         }
 232
 233         if (filter) {
 234                 ret = kernctl_filter(event->fd, filter);
 235                 if (ret) {
 236                         goto filter_error;
 237                 }
 238         }
 239
 240         ret = kernctl_enable(event->fd);
 241         if (ret < 0) {
 242                 switch (-ret) {
 243                 case EEXIST:
 244                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 245                         break;
 246                 default:
 247                         PERROR("enable kernel event");
 248                         break;
 249                 }
 250                 goto enable_error;
 251         }
 252
 253         /* Add event to event list */
 254         cds_list_add(&event->list, &channel->events_list.head);
 255         channel->event_count++;
 256
 257         DBG("Event %s created (fd: %d)", ev->name, event->fd);
 258
 259         return 0;
 260
 261 enable_error:
 262 filter_error:
 263         {
 264                 int closeret;
 265
 266                 closeret = close(event->fd);
 267                 if (closeret) {
 268                         PERROR("close event fd");
 269                 }
 270         }
 271 free_event:
 272         free(event);
 273 error:
 274         return ret;
 275 }
 276
 277 /*
 278  * Disable a kernel channel.
 279  */
 280 int kernel_disable_channel(struct ltt_kernel_channel *chan)
 281 {
 282         int ret;
 283
 284         assert(chan);
 285
 286         ret = kernctl_disable(chan->fd);
 287         if (ret < 0) {
 288                 PERROR("disable chan ioctl");
 289                 goto error;
 290         }
 291
 292         chan->enabled = 0;
 293         DBG("Kernel channel %s disabled (fd: %d)", chan->channel->name, chan->fd);
 294
 295         return 0;
 296
 297 error:
 298         return ret;
 299 }
 300
 301 /*
 302  * Enable a kernel channel.
 303  */
 304 int kernel_enable_channel(struct ltt_kernel_channel *chan)
 305 {
 306         int ret;
 307
 308         assert(chan);
 309
 310         ret = kernctl_enable(chan->fd);
 311         if (ret < 0 && ret != -EEXIST) {
 312                 PERROR("Enable kernel chan");
 313                 goto error;
 314         }
 315
 316         chan->enabled = 1;
 317         DBG("Kernel channel %s enabled (fd: %d)", chan->channel->name, chan->fd);
 318
 319         return 0;
 320
 321 error:
 322         return ret;
 323 }
 324
 325 /*
 326  * Enable a kernel event.
 327  */
 328 int kernel_enable_event(struct ltt_kernel_event *event)
 329 {
 330         int ret;
 331
 332         assert(event);
 333
 334         ret = kernctl_enable(event->fd);
 335         if (ret < 0) {
 336                 switch (-ret) {
 337                 case EEXIST:
 338                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 339                         break;
 340                 default:
 341                         PERROR("enable kernel event");
 342                         break;
 343                 }
 344                 goto error;
 345         }
 346
 347         event->enabled = 1;
 348         DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd);
 349
 350         return 0;
 351
 352 error:
 353         return ret;
 354 }
 355
 356 /*
 357  * Disable a kernel event.
 358  */
 359 int kernel_disable_event(struct ltt_kernel_event *event)
 360 {
 361         int ret;
 362
 363         assert(event);
 364
 365         ret = kernctl_disable(event->fd);
 366         if (ret < 0) {
 367                 switch (-ret) {
 368                 case EEXIST:
 369                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 370                         break;
 371                 default:
 372                         PERROR("disable kernel event");
 373                         break;
 374                 }
 375                 goto error;
 376         }
 377
 378         event->enabled = 0;
 379         DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd);
 380
 381         return 0;
 382
 383 error:
 384         return ret;
 385 }
 386
 387 static
 388 struct lttng_tracker_list *get_id_tracker_list(struct ltt_kernel_session *session,
 389                 enum lttng_tracker_type tracker_type)
 390 {
 391         switch (tracker_type) {
 392         case LTTNG_TRACKER_PID:
 393                 return session->tracker_list_pid;
 394         case LTTNG_TRACKER_VPID:
 395                 return session->tracker_list_vpid;
 396         case LTTNG_TRACKER_UID:
 397                 return session->tracker_list_uid;
 398         case LTTNG_TRACKER_VUID:
 399                 return session->tracker_list_vuid;
 400         case LTTNG_TRACKER_GID:
 401                 return session->tracker_list_gid;
 402         case LTTNG_TRACKER_VGID:
 403                 return session->tracker_list_vgid;
 404         default:
 405                 return NULL;
 406         }
 407 }
 408
 409 int kernel_track_id(enum lttng_tracker_type tracker_type,
 410                 struct ltt_kernel_session *session,
 411                 struct lttng_tracker_id *id)
 412 {
 413         int ret, value;
 414         struct lttng_tracker_list *tracker_list;
 415
 416         ret = lttng_tracker_id_lookup_string(tracker_type,
 417                         id, &value);
 418         if (ret != LTTNG_OK) {
 419                 return ret;
 420         }
 421
 422         /* Add to list. */
 423         tracker_list = get_id_tracker_list(session, tracker_type);
 424         if (!tracker_list) {
 425                 return LTTNG_ERR_INVALID;
 426         }
 427         ret = lttng_tracker_list_add(tracker_list, id);
 428         if (ret != LTTNG_OK) {
 429                 return ret;
 430         }
 431
 432         switch (tracker_type) {
 433         case LTTNG_TRACKER_PID:
 434                 DBG("Kernel track PID %d for session id %" PRIu64 ".",
 435                                 value, session->id);
 436                 ret = kernctl_track_pid(session->fd, value);
 437                 if (!ret) {
 438                         return LTTNG_OK;
 439                 }
 440                 break;
 441         case LTTNG_TRACKER_VPID:
 442                 DBG("Kernel track VPID %d for session id %" PRIu64 ".",
 443                                 value, session->id);
 444                 ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VPID, value);
 445                 if (!ret) {
 446                         return LTTNG_OK;
 447                 }
 448                 break;
 449         case LTTNG_TRACKER_UID:
 450                 DBG("Kernel track UID %d for session id %" PRIu64 ".",
 451                                 value, session->id);
 452                 ret = kernctl_track_id(session->fd, LTTNG_TRACKER_UID, value);
 453                 if (!ret) {
 454                         return LTTNG_OK;
 455                 }
 456                 break;
 457         case LTTNG_TRACKER_GID:
 458                 DBG("Kernel track GID %d for session id %" PRIu64 ".",
 459                                 value, session->id);
 460                 ret = kernctl_track_id(session->fd, LTTNG_TRACKER_GID, value);
 461                 if (!ret) {
 462                         return LTTNG_OK;
 463                 }
 464                 break;
 465         case LTTNG_TRACKER_VUID:
 466                 DBG("Kernel track VUID %d for session id %" PRIu64 ".",
 467                                 value, session->id);
 468                 ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VUID, value);
 469                 if (!ret) {
 470                         return LTTNG_OK;
 471                 }
 472                 break;
 473         case LTTNG_TRACKER_VGID:
 474                 DBG("Kernel track VGID %d for session id %" PRIu64 ".",
 475                                 value, session->id);
 476                 ret = kernctl_track_id(session->fd, LTTNG_TRACKER_VGID, value);
 477                 if (!ret) {
 478                         return LTTNG_OK;
 479                 }
 480                 break;
 481         default:
 482                 return LTTNG_ERR_INVALID;
 483         }
 484         switch (-ret) {
 485         case EINVAL:
 486                 return LTTNG_ERR_INVALID;
 487         case ENOMEM:
 488                 return LTTNG_ERR_NOMEM;
 489         case EEXIST:
 490                 return LTTNG_ERR_ID_TRACKED;
 491         default:
 492                 return LTTNG_ERR_UNK;
 493         }
 494 }
 495
 496 int kernel_untrack_id(enum lttng_tracker_type tracker_type,
 497                 struct ltt_kernel_session *session,
 498                 struct lttng_tracker_id *id)
 499 {
 500         int ret, value;
 501         struct lttng_tracker_list *tracker_list;
 502
 503         ret = lttng_tracker_id_lookup_string(tracker_type,
 504                         id, &value);
 505         if (ret != LTTNG_OK) {
 506                 return ret;
 507         }
 508
 509         /* Remove from list. */
 510         tracker_list = get_id_tracker_list(session, tracker_type);
 511         if (!tracker_list) {
 512                 return LTTNG_ERR_INVALID;
 513         }
 514         ret = lttng_tracker_list_remove(tracker_list, id);
 515         if (ret != LTTNG_OK) {
 516                 return ret;
 517         }
 518
 519         switch (tracker_type) {
 520         case LTTNG_TRACKER_PID:
 521                 DBG("Kernel untrack PID %d for session id %" PRIu64 ".",
 522                                 value, session->id);
 523                 ret = kernctl_untrack_pid(session->fd, value);
 524                 if (!ret) {
 525                         return LTTNG_OK;
 526                 }
 527                 break;
 528         case LTTNG_TRACKER_VPID:
 529                 DBG("Kernel untrack VPID %d for session id %" PRIu64 ".",
 530                                 value, session->id);
 531                 ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VPID, value);
 532                 if (!ret) {
 533                         return LTTNG_OK;
 534                 }
 535                 break;
 536         case LTTNG_TRACKER_UID:
 537                 DBG("Kernel untrack UID %d for session id %" PRIu64 ".",
 538                                 value, session->id);
 539                 ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_UID, value);
 540                 if (!ret) {
 541                         return LTTNG_OK;
 542                 }
 543                 break;
 544         case LTTNG_TRACKER_GID:
 545                 DBG("Kernel untrack GID %d for session id %" PRIu64 ".",
 546                                 value, session->id);
 547                 ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_GID, value);
 548                 if (!ret) {
 549                         return LTTNG_OK;
 550                 }
 551                 break;
 552         case LTTNG_TRACKER_VUID:
 553                 DBG("Kernel untrack VUID %d for session id %" PRIu64 ".",
 554                                 value, session->id);
 555                 ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VUID, value);
 556                 if (!ret) {
 557                         return LTTNG_OK;
 558                 }
 559                 break;
 560         case LTTNG_TRACKER_VGID:
 561                 DBG("Kernel untrack VGID %d for session id %" PRIu64 ".",
 562                                 value, session->id);
 563                 ret = kernctl_untrack_id(session->fd, LTTNG_TRACKER_VGID, value);
 564                 if (!ret) {
 565                         return LTTNG_OK;
 566                 }
 567                 break;
 568         default:
 569                 return LTTNG_ERR_INVALID;
 570         }
 571
 572         switch (-ret) {
 573         case EINVAL:
 574                 return LTTNG_ERR_INVALID;
 575         case ENOMEM:
 576                 return LTTNG_ERR_NOMEM;
 577         case ENOENT:
 578                 return LTTNG_ERR_ID_NOT_TRACKED;
 579         default:
 580                 return LTTNG_ERR_UNK;
 581         }
 582 }
 583
 584 /*
 585  * Called with session lock held.
 586  */
 587 ssize_t kernel_list_tracker_ids(enum lttng_tracker_type tracker_type,
 588                 struct ltt_kernel_session *session,
 589                 struct lttng_tracker_id **_ids)
 590 {
 591         struct lttng_tracker_list *tracker_list;
 592
 593         tracker_list = get_id_tracker_list(session, tracker_type);
 594         if (!tracker_list) {
 595                 return -LTTNG_ERR_INVALID;
 596         }
 597         return lttng_tracker_id_get_list(tracker_list, _ids);
 598 }
 599
 600 /*
 601  * Create kernel metadata, open from the kernel tracer and add it to the
 602  * kernel session.
 603  */
 604 int kernel_open_metadata(struct ltt_kernel_session *session)
 605 {
 606         int ret;
 607         struct ltt_kernel_metadata *lkm = NULL;
 608
 609         assert(session);
 610
 611         /* Allocate kernel metadata */
 612         lkm = trace_kernel_create_metadata();
 613         if (lkm == NULL) {
 614                 goto error;
 615         }
 616
 617         /* Kernel tracer metadata creation */
 618         ret = kernctl_open_metadata(session->fd, &lkm->conf->attr);
 619         if (ret < 0) {
 620                 goto error_open;
 621         }
 622
 623         lkm->fd = ret;
 624         /* Prevent fd duplication after execlp() */
 625         ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC);
 626         if (ret < 0) {
 627                 PERROR("fcntl session fd");
 628         }
 629
 630         session->metadata = lkm;
 631
 632         DBG("Kernel metadata opened (fd: %d)", lkm->fd);
 633
 634         return 0;
 635
 636 error_open:
 637         trace_kernel_destroy_metadata(lkm);
 638 error:
 639         return -1;
 640 }
 641
 642 /*
 643  * Start tracing session.
 644  */
 645 int kernel_start_session(struct ltt_kernel_session *session)
 646 {
 647         int ret;
 648
 649         assert(session);
 650
 651         ret = kernctl_start_session(session->fd);
 652         if (ret < 0) {
 653                 PERROR("ioctl start session");
 654                 goto error;
 655         }
 656
 657         DBG("Kernel session started");
 658
 659         return 0;
 660
 661 error:
 662         return ret;
 663 }
 664
 665 /*
 666  * Make a kernel wait to make sure in-flight probe have completed.
 667  */
 668 void kernel_wait_quiescent(int fd)
 669 {
 670         int ret;
 671
 672         DBG("Kernel quiescent wait on %d", fd);
 673
 674         ret = kernctl_wait_quiescent(fd);
 675         if (ret < 0) {
 676                 PERROR("wait quiescent ioctl");
 677                 ERR("Kernel quiescent wait failed");
 678         }
 679 }
 680
 681 /*
 682  *  Force flush buffer of metadata.
 683  */
 684 int kernel_metadata_flush_buffer(int fd)
 685 {
 686         int ret;
 687
 688         DBG("Kernel flushing metadata buffer on fd %d", fd);
 689
 690         ret = kernctl_buffer_flush(fd);
 691         if (ret < 0) {
 692                 ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret);
 693         }
 694
 695         return 0;
 696 }
 697
 698 /*
 699  * Force flush buffer for channel.
 700  */
 701 int kernel_flush_buffer(struct ltt_kernel_channel *channel)
 702 {
 703         int ret;
 704         struct ltt_kernel_stream *stream;
 705
 706         assert(channel);
 707
 708         DBG("Flush buffer for channel %s", channel->channel->name);
 709
 710         cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
 711                 DBG("Flushing channel stream %d", stream->fd);
 712                 ret = kernctl_buffer_flush(stream->fd);
 713                 if (ret < 0) {
 714                         PERROR("ioctl");
 715                         ERR("Fail to flush buffer for stream %d (ret: %d)",
 716                                         stream->fd, ret);
 717                 }
 718         }
 719
 720         return 0;
 721 }
 722
 723 /*
 724  * Stop tracing session.
 725  */
 726 int kernel_stop_session(struct ltt_kernel_session *session)
 727 {
 728         int ret;
 729
 730         assert(session);
 731
 732         ret = kernctl_stop_session(session->fd);
 733         if (ret < 0) {
 734                 goto error;
 735         }
 736
 737         DBG("Kernel session stopped");
 738
 739         return 0;
 740
 741 error:
 742         return ret;
 743 }
 744
 745 /*
 746  * Open stream of channel, register it to the kernel tracer and add it
 747  * to the stream list of the channel.
 748  *
 749  * Note: given that the streams may appear in random order wrt CPU
 750  * number (e.g. cpu hotplug), the index value of the stream number in
 751  * the stream name is not necessarily linked to the CPU number.
 752  *
 753  * Return the number of created stream. Else, a negative value.
 754  */
 755 int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
 756 {
 757         int ret;
 758         struct ltt_kernel_stream *lks;
 759
 760         assert(channel);
 761
 762         while ((ret = kernctl_create_stream(channel->fd)) >= 0) {
 763                 lks = trace_kernel_create_stream(channel->channel->name,
 764                                 channel->stream_count);
 765                 if (lks == NULL) {
 766                         ret = close(ret);
 767                         if (ret) {
 768                                 PERROR("close");
 769                         }
 770                         goto error;
 771                 }
 772
 773                 lks->fd = ret;
 774                 /* Prevent fd duplication after execlp() */
 775                 ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
 776                 if (ret < 0) {
 777                         PERROR("fcntl session fd");
 778                 }
 779
 780                 lks->tracefile_size = channel->channel->attr.tracefile_size;
 781                 lks->tracefile_count = channel->channel->attr.tracefile_count;
 782
 783                 /* Add stream to channel stream list */
 784                 cds_list_add(&lks->list, &channel->stream_list.head);
 785                 channel->stream_count++;
 786
 787                 DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd,
 788                                 lks->state);
 789         }
 790
 791         return channel->stream_count;
 792
 793 error:
 794         return -1;
 795 }
 796
 797 /*
 798  * Open the metadata stream and set it to the kernel session.
 799  */
 800 int kernel_open_metadata_stream(struct ltt_kernel_session *session)
 801 {
 802         int ret;
 803
 804         assert(session);
 805
 806         ret = kernctl_create_stream(session->metadata->fd);
 807         if (ret < 0) {
 808                 PERROR("kernel create metadata stream");
 809                 goto error;
 810         }
 811
 812         DBG("Kernel metadata stream created (fd: %d)", ret);
 813         session->metadata_stream_fd = ret;
 814         /* Prevent fd duplication after execlp() */
 815         ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC);
 816         if (ret < 0) {
 817                 PERROR("fcntl session fd");
 818         }
 819
 820         return 0;
 821
 822 error:
 823         return -1;
 824 }
 825
 826 /*
 827  * Get the event list from the kernel tracer and return the number of elements.
 828  */
 829 ssize_t kernel_list_events(int tracer_fd, struct lttng_event **events)
 830 {
 831         int fd, ret;
 832         char *event;
 833         size_t nbmem, count = 0;
 834         FILE *fp;
 835         struct lttng_event *elist;
 836
 837         assert(events);
 838
 839         fd = kernctl_tracepoint_list(tracer_fd);
 840         if (fd < 0) {
 841                 PERROR("kernel tracepoint list");
 842                 goto error;
 843         }
 844
 845         fp = fdopen(fd, "r");
 846         if (fp == NULL) {
 847                 PERROR("kernel tracepoint list fdopen");
 848                 goto error_fp;
 849         }
 850
 851         /*
 852          * Init memory size counter
 853          * See kernel-ctl.h for explanation of this value
 854          */
 855         nbmem = KERNEL_EVENT_INIT_LIST_SIZE;
 856         elist = zmalloc(sizeof(struct lttng_event) * nbmem);
 857         if (elist == NULL) {
 858                 PERROR("alloc list events");
 859                 count = -ENOMEM;
 860                 goto end;
 861         }
 862
 863         while (fscanf(fp, "event { name = %m[^;]; };\n", &event) == 1) {
 864                 if (count >= nbmem) {
 865                         struct lttng_event *new_elist;
 866                         size_t new_nbmem;
 867
 868                         new_nbmem = nbmem << 1;
 869                         DBG("Reallocating event list from %zu to %zu bytes",
 870                                         nbmem, new_nbmem);
 871                         new_elist = realloc(elist, new_nbmem * sizeof(struct lttng_event));
 872                         if (new_elist == NULL) {
 873                                 PERROR("realloc list events");
 874                                 free(event);
 875                                 free(elist);
 876                                 count = -ENOMEM;
 877                                 goto end;
 878                         }
 879                         /* Zero the new memory */
 880                         memset(new_elist + nbmem, 0,
 881                                 (new_nbmem - nbmem) * sizeof(struct lttng_event));
 882                         nbmem = new_nbmem;
 883                         elist = new_elist;
 884                 }
 885                 strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN);
 886                 elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
 887                 elist[count].enabled = -1;
 888                 count++;
 889                 free(event);
 890         }
 891
 892         *events = elist;
 893         DBG("Kernel list events done (%zu events)", count);
 894 end:
 895         ret = fclose(fp);       /* closes both fp and fd */
 896         if (ret) {
 897                 PERROR("fclose");
 898         }
 899         return count;
 900
 901 error_fp:
 902         ret = close(fd);
 903         if (ret) {
 904                 PERROR("close");
 905         }
 906 error:
 907         return -1;
 908 }
 909
 910 /*
 911  * Get kernel version and validate it.
 912  */
 913 int kernel_validate_version(int tracer_fd)
 914 {
 915         int ret;
 916         struct lttng_kernel_tracer_version version;
 917         struct lttng_kernel_tracer_abi_version abi_version;
 918
 919         ret = kernctl_tracer_version(tracer_fd, &version);
 920         if (ret < 0) {
 921                 ERR("Failed to retrieve the lttng-modules version");
 922                 goto error;
 923         }
 924
 925         /* Validate version */
 926         if (version.major != VERSION_MAJOR) {
 927                 ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)",
 928                         version.major, VERSION_MAJOR);
 929                 goto error_version;
 930         }
 931         ret = kernctl_tracer_abi_version(tracer_fd, &abi_version);
 932         if (ret < 0) {
 933                 ERR("Failed to retrieve lttng-modules ABI version");
 934                 goto error;
 935         }
 936         if (abi_version.major != LTTNG_MODULES_ABI_MAJOR_VERSION) {
 937                 ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
 938                         abi_version.major, abi_version.minor,
 939                         LTTNG_MODULES_ABI_MAJOR_VERSION);
 940                 goto error;
 941         }
 942         DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
 943                         version.major, version.minor,
 944                         abi_version.major, abi_version.minor);
 945         return 0;
 946
 947 error_version:
 948         ret = -1;
 949
 950 error:
 951         ERR("Kernel tracer version check failed; kernel tracing will not be available");
 952         return ret;
 953 }
 954
 955 /*
 956  * Kernel work-arounds called at the start of sessiond main().
 957  */
 958 int init_kernel_workarounds(void)
 959 {
 960         int ret;
 961         FILE *fp;
 962
 963         /*
 964          * boot_id needs to be read once before being used concurrently
 965          * to deal with a Linux kernel race. A fix is proposed for
 966          * upstream, but the work-around is needed for older kernels.
 967          */
 968         fp = fopen("/proc/sys/kernel/random/boot_id", "r");
 969         if (!fp) {
 970                 goto end_boot_id;
 971         }
 972         while (!feof(fp)) {
 973                 char buf[37] = "";
 974
 975                 ret = fread(buf, 1, sizeof(buf), fp);
 976                 if (ret < 0) {
 977                         /* Ignore error, we don't really care */
 978                 }
 979         }
 980         ret = fclose(fp);
 981         if (ret) {
 982                 PERROR("fclose");
 983         }
 984 end_boot_id:
 985         return 0;
 986 }
 987
 988 /*
 989  * Complete teardown of a kernel session.
 990  */
 991 void kernel_destroy_session(struct ltt_kernel_session *ksess)
 992 {
 993         if (ksess == NULL) {
 994                 DBG3("No kernel session when tearing down session");
 995                 return;
 996         }
 997
 998         DBG("Tearing down kernel session");
 999
1000         /*
1001          * Destroy channels on the consumer if at least one FD has been sent and we
1002          * are in no output mode because the streams are in *no* monitor mode so we
1003          * have to send a command to clean them up or else they leaked.
1004          */
1005         if (!ksess->output_traces && ksess->consumer_fds_sent) {
1006                 int ret;
1007                 struct consumer_socket *socket;
1008                 struct lttng_ht_iter iter;
1009
1010                 /* For each consumer socket. */
1011                 rcu_read_lock();
1012                 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1013                                 socket, node.node) {
1014                         struct ltt_kernel_channel *chan;
1015
1016                         /* For each channel, ask the consumer to destroy it. */
1017                         cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1018                                 ret = kernel_consumer_destroy_channel(socket, chan);
1019                                 if (ret < 0) {
1020                                         /* Consumer is probably dead. Use next socket. */
1021                                         continue;
1022                                 }
1023                         }
1024                 }
1025                 rcu_read_unlock();
1026         }
1027
1028         /* Close any relayd session */
1029         consumer_output_send_destroy_relayd(ksess->consumer);
1030
1031         trace_kernel_destroy_session(ksess);
1032 }
1033
1034 /*
1035  * Destroy a kernel channel object. It does not do anything on the tracer side.
1036  */
1037 void kernel_destroy_channel(struct ltt_kernel_channel *kchan)
1038 {
1039         struct ltt_kernel_session *ksess = NULL;
1040
1041         assert(kchan);
1042         assert(kchan->channel);
1043
1044         DBG3("Kernel destroy channel %s", kchan->channel->name);
1045
1046         /* Update channel count of associated session. */
1047         if (kchan->session) {
1048                 /* Keep pointer reference so we can update it after the destroy. */
1049                 ksess = kchan->session;
1050         }
1051
1052         trace_kernel_destroy_channel(kchan);
1053
1054         /*
1055          * At this point the kernel channel is not visible anymore. This is safe
1056          * since in order to work on a visible kernel session, the tracing session
1057          * lock (ltt_session.lock) MUST be acquired.
1058          */
1059         if (ksess) {
1060                 ksess->channel_count--;
1061         }
1062 }
1063
1064 /*
1065  * Take a snapshot for a given kernel session.
1066  *
1067  * Return 0 on success or else return a LTTNG_ERR code.
1068  */
1069 int kernel_snapshot_record(struct ltt_kernel_session *ksess,
1070                 struct snapshot_output *output, int wait,
1071                 uint64_t nb_packets_per_stream)
1072 {
1073         int err, ret, saved_metadata_fd;
1074         struct consumer_socket *socket;
1075         struct lttng_ht_iter iter;
1076         struct ltt_kernel_metadata *saved_metadata;
1077
1078         assert(ksess);
1079         assert(ksess->consumer);
1080         assert(output);
1081
1082         DBG("Kernel snapshot record started");
1083
1084         /* Save current metadata since the following calls will change it. */
1085         saved_metadata = ksess->metadata;
1086         saved_metadata_fd = ksess->metadata_stream_fd;
1087
1088         rcu_read_lock();
1089
1090         ret = kernel_open_metadata(ksess);
1091         if (ret < 0) {
1092                 ret = LTTNG_ERR_KERN_META_FAIL;
1093                 goto error;
1094         }
1095
1096         ret = kernel_open_metadata_stream(ksess);
1097         if (ret < 0) {
1098                 ret = LTTNG_ERR_KERN_META_FAIL;
1099                 goto error_open_stream;
1100         }
1101
1102         /* Send metadata to consumer and snapshot everything. */
1103         cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1104                         socket, node.node) {
1105                 struct consumer_output *saved_output;
1106                 struct ltt_kernel_channel *chan;
1107
1108                 /*
1109                  * Temporarly switch consumer output for our snapshot output. As long
1110                  * as the session lock is taken, this is safe.
1111                  */
1112                 saved_output = ksess->consumer;
1113                 ksess->consumer = output->consumer;
1114
1115                 pthread_mutex_lock(socket->lock);
1116                 /* This stream must not be monitored by the consumer. */
1117                 ret = kernel_consumer_add_metadata(socket, ksess, 0);
1118                 pthread_mutex_unlock(socket->lock);
1119                 /* Put back the saved consumer output into the session. */
1120                 ksess->consumer = saved_output;
1121                 if (ret < 0) {
1122                         ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1123                         goto error_consumer;
1124                 }
1125
1126                 /* For each channel, ask the consumer to snapshot it. */
1127                 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1128                         ret = consumer_snapshot_channel(socket, chan->fd, output, 0,
1129                                         ksess->uid, ksess->gid,
1130                                         DEFAULT_KERNEL_TRACE_DIR, wait,
1131                                         nb_packets_per_stream);
1132                         if (ret < 0) {
1133                                 ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1134                                 (void) kernel_consumer_destroy_metadata(socket,
1135                                                 ksess->metadata);
1136                                 goto error_consumer;
1137                         }
1138                 }
1139
1140                 /* Snapshot metadata, */
1141                 ret = consumer_snapshot_channel(socket, ksess->metadata->fd, output,
1142                                 1, ksess->uid, ksess->gid,
1143                                 DEFAULT_KERNEL_TRACE_DIR, wait, 0);
1144                 if (ret < 0) {
1145                         ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
1146                         goto error_consumer;
1147                 }
1148
1149                 /*
1150                  * The metadata snapshot is done, ask the consumer to destroy it since
1151                  * it's not monitored on the consumer side.
1152                  */
1153                 (void) kernel_consumer_destroy_metadata(socket, ksess->metadata);
1154         }
1155
1156         ret = LTTNG_OK;
1157
1158 error_consumer:
1159         /* Close newly opened metadata stream. It's now on the consumer side. */
1160         err = close(ksess->metadata_stream_fd);
1161         if (err < 0) {
1162                 PERROR("close snapshot kernel");
1163         }
1164
1165 error_open_stream:
1166         trace_kernel_destroy_metadata(ksess->metadata);
1167 error:
1168         /* Restore metadata state.*/
1169         ksess->metadata = saved_metadata;
1170         ksess->metadata_stream_fd = saved_metadata_fd;
1171
1172         rcu_read_unlock();
1173         return ret;
1174 }
1175
1176 /*
1177  * Get the syscall mask array from the kernel tracer.
1178  *
1179  * Return 0 on success else a negative value. In both case, syscall_mask should
1180  * be freed.
1181  */
1182 int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits)
1183 {
1184         assert(syscall_mask);
1185         assert(nr_bits);
1186
1187         return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits);
1188 }