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