src/bin/lttng-sessiond/kernel.c

   1 /*
   2  * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <fcntl.h>
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <inttypes.h>
  15 #include <sys/types.h>
  16
  17 #include <common/common.h>
  18 #include <common/hashtable/utils.h>
  19 #include <common/trace-chunk.h>
  20 #include <common/kernel-ctl/kernel-ctl.h>
  21 #include <common/kernel-ctl/kernel-ioctl.h>
  22 #include <common/sessiond-comm/sessiond-comm.h>
  23 #include <common/tracker.h>
  24 #include <common/utils.h>
  25 #include <lttng/event.h>
  26 #include <lttng/lttng-error.h>
  27 #include <lttng/tracker.h>
  28
  29 #include <lttng/userspace-probe.h>
  30 #include <lttng/userspace-probe-internal.h>
  31 #include <lttng/condition/on-event.h>
  32 #include <lttng/condition/on-event-internal.h>
  33 #include <lttng/event-rule/event-rule.h>
  34 #include <lttng/event-rule/event-rule-internal.h>
  35 #include <lttng/event-rule/userspace-probe-internal.h>
  36 #include <lttng/map/map.h>
  37 #include <lttng/map/map-internal.h>
  38 #include <lttng/map/map-query-internal.h>
  39 #include <lttng/map-key.h>
  40 #include <lttng/map-key-internal.h>
  41
  42 #include "event-notifier-error-accounting.h"
  43 #include "lttng-sessiond.h"
  44 #include "lttng-syscall.h"
  45 #include "condition-internal.h"
  46 #include "consumer.h"
  47 #include "kernel.h"
  48 #include "kernel-consumer.h"
  49 #include "kern-modules.h"
  50 #include "map.h"
  51 #include "sessiond-config.h"
  52 #include "utils.h"
  53 #include "rotate.h"
  54 #include "modprobe.h"
  55 #include "tracker.h"
  56 #include "notification-thread-commands.h"
  57
  58 /*
  59  * Key used to reference a channel between the sessiond and the consumer. This
  60  * is only read and updated with the session_list lock held.
  61  */
  62 static uint64_t next_kernel_channel_key;
  63
  64 static const char *module_proc_lttng = "/proc/lttng";
  65
  66 static int kernel_tracer_fd = -1;
  67 static int kernel_tracer_event_notifier_group_fd = -1;
  68 static int kernel_tracer_event_notifier_group_notification_fd = -1;
  69 static struct cds_lfht *kernel_token_to_event_notifier_rule_ht;
  70
  71 /*
  72  * Add context on a kernel channel.
  73  *
  74  * Assumes the ownership of ctx.
  75  */
  76 int kernel_add_channel_context(struct ltt_kernel_channel *chan,
  77                 struct ltt_kernel_context *ctx)
  78 {
  79         int ret;
  80
  81         assert(chan);
  82         assert(ctx);
  83
  84         DBG("Adding context to channel %s", chan->channel->name);
  85         ret = kernctl_add_context(chan->fd, &ctx->ctx);
  86         if (ret < 0) {
  87                 switch (-ret) {
  88                 case ENOSYS:
  89                         /* Exists but not available for this kernel */
  90                         ret = LTTNG_ERR_KERN_CONTEXT_UNAVAILABLE;
  91                         goto error;
  92                 case EEXIST:
  93                         /* If EEXIST, we just ignore the error */
  94                         ret = 0;
  95                         goto end;
  96                 default:
  97                         PERROR("add context ioctl");
  98                         ret = LTTNG_ERR_KERN_CONTEXT_FAIL;
  99                         goto error;
 100                 }
 101         }
 102         ret = 0;
 103
 104 end:
 105         cds_list_add_tail(&ctx->list, &chan->ctx_list);
 106         ctx->in_list = true;
 107         ctx = NULL;
 108 error:
 109         if (ctx) {
 110                 trace_kernel_destroy_context(ctx);
 111         }
 112         return ret;
 113 }
 114
 115 /*
 116  * Create a new kernel session, register it to the kernel tracer and add it to
 117  * the session daemon session.
 118  */
 119 int kernel_create_session(struct ltt_session *session)
 120 {
 121         int ret;
 122         struct ltt_kernel_session *lks;
 123
 124         assert(session);
 125
 126         /* Allocate data structure */
 127         lks = trace_kernel_create_session();
 128         if (lks == NULL) {
 129                 ret = -1;
 130                 goto error;
 131         }
 132
 133         /* Kernel tracer session creation */
 134         ret = kernctl_create_session(kernel_tracer_fd);
 135         if (ret < 0) {
 136                 PERROR("ioctl kernel create session");
 137                 goto error;
 138         }
 139
 140         lks->fd = ret;
 141         /* Prevent fd duplication after execlp() */
 142         ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
 143         if (ret < 0) {
 144                 PERROR("fcntl session fd");
 145         }
 146
 147         lks->id = session->id;
 148         lks->consumer_fds_sent = 0;
 149         session->kernel_session = lks;
 150
 151         DBG("Kernel session created (fd: %d)", lks->fd);
 152
 153         /*
 154          * This is necessary since the creation time is present in the session
 155          * name when it is generated.
 156          */
 157         if (session->has_auto_generated_name) {
 158                 ret = kernctl_session_set_name(lks->fd, DEFAULT_SESSION_NAME);
 159         } else {
 160                 ret = kernctl_session_set_name(lks->fd, session->name);
 161         }
 162         if (ret) {
 163                 WARN("Could not set kernel session name for session %" PRIu64 " name: %s",
 164                         session->id, session->name);
 165         }
 166
 167         ret = kernctl_session_set_creation_time(lks->fd, session->creation_time);
 168         if (ret) {
 169                 WARN("Could not set kernel session creation time for session %" PRIu64 " name: %s",
 170                         session->id, session->name);
 171         }
 172
 173         return 0;
 174
 175 error:
 176         if (lks) {
 177                 trace_kernel_destroy_session(lks);
 178                 trace_kernel_free_session(lks);
 179         }
 180         return ret;
 181 }
 182
 183 /*
 184  * Create a kernel channel, register it to the kernel tracer and add it to the
 185  * kernel session.
 186  */
 187 int kernel_create_channel(struct ltt_kernel_session *session,
 188                 struct lttng_channel *chan)
 189 {
 190         int ret;
 191         struct ltt_kernel_channel *lkc;
 192
 193         assert(session);
 194         assert(chan);
 195
 196         /* Allocate kernel channel */
 197         lkc = trace_kernel_create_channel(chan);
 198         if (lkc == NULL) {
 199                 goto error;
 200         }
 201
 202         DBG3("Kernel create channel %s with attr: %d, %" PRIu64 ", %" PRIu64 ", %u, %u, %d, %d",
 203                         chan->name, lkc->channel->attr.overwrite,
 204                         lkc->channel->attr.subbuf_size, lkc->channel->attr.num_subbuf,
 205                         lkc->channel->attr.switch_timer_interval, lkc->channel->attr.read_timer_interval,
 206                         lkc->channel->attr.live_timer_interval, lkc->channel->attr.output);
 207
 208         /* Kernel tracer channel creation */
 209         ret = kernctl_create_channel(session->fd, &lkc->channel->attr);
 210         if (ret < 0) {
 211                 PERROR("ioctl kernel create channel");
 212                 goto error;
 213         }
 214
 215         /* Setup the channel fd */
 216         lkc->fd = ret;
 217         /* Prevent fd duplication after execlp() */
 218         ret = fcntl(lkc->fd, F_SETFD, FD_CLOEXEC);
 219         if (ret < 0) {
 220                 PERROR("fcntl session fd");
 221         }
 222
 223         /* Add channel to session */
 224         cds_list_add(&lkc->list, &session->channel_list.head);
 225         session->channel_count++;
 226         lkc->session = session;
 227         lkc->key = ++next_kernel_channel_key;
 228
 229         DBG("Kernel channel %s created (fd: %d, key: %" PRIu64 ")",
 230                         lkc->channel->name, lkc->fd, lkc->key);
 231
 232         return 0;
 233
 234 error:
 235         if (lkc) {
 236                 free(lkc->channel);
 237                 free(lkc);
 238         }
 239         return -1;
 240 }
 241
 242 /*
 243  * Create a kernel event notifier group, register it to the kernel tracer and
 244  * add it to the kernel session.
 245  */
 246 static int kernel_create_event_notifier_group(int *event_notifier_group_fd)
 247 {
 248         int ret;
 249         int local_fd = -1;
 250
 251         assert(event_notifier_group_fd);
 252
 253         /* Kernel event notifier group creation. */
 254         ret = kernctl_create_event_notifier_group(kernel_tracer_fd);
 255         if (ret < 0) {
 256                 PERROR("Failed to create kernel event notifier group");
 257                 ret = -1;
 258                 goto error;
 259         }
 260
 261         local_fd = ret;
 262
 263         /* Prevent fd duplication after execlp(). */
 264         ret = fcntl(local_fd, F_SETFD, FD_CLOEXEC);
 265         if (ret < 0) {
 266                 PERROR("Failed to set FD_CLOEXEC on kernel event notifier group file descriptor: fd = %d",
 267                                 local_fd);
 268                 goto error;
 269         }
 270
 271         DBG("Created kernel event notifier group: fd = %d", local_fd);
 272         *event_notifier_group_fd = local_fd;
 273         local_fd = -1;
 274         ret = 0;
 275 error:
 276         if (local_fd >= 0) {
 277                 ret = close(local_fd);
 278                 if (ret) {
 279                         PERROR("Failed to close kernel event notifier group file descriptor: fd = %d",
 280                                         local_fd);
 281                 }
 282         }
 283
 284         return ret;
 285 }
 286
 287 /*
 288  * Compute the offset of the instrumentation byte in the binary based on the
 289  * function probe location using the ELF lookup method.
 290  *
 291  * Returns 0 on success and set the offset out parameter to the offset of the
 292  * elf symbol
 293  * Returns -1 on error
 294  */
 295 static
 296 int extract_userspace_probe_offset_function_elf(
 297                 const struct lttng_userspace_probe_location *probe_location,
 298                 uid_t uid, gid_t gid, uint64_t *offset)
 299 {
 300         int fd;
 301         int ret = 0;
 302         const char *symbol = NULL;
 303         const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
 304         enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
 305
 306         assert(lttng_userspace_probe_location_get_type(probe_location) ==
 307                         LTTNG_USERSPACE_PROBE_LOCATION_TYPE_FUNCTION);
 308
 309         lookup = lttng_userspace_probe_location_get_lookup_method(
 310                         probe_location);
 311         if (!lookup) {
 312                 ret = -1;
 313                 goto end;
 314         }
 315
 316         lookup_method_type =
 317                         lttng_userspace_probe_location_lookup_method_get_type(lookup);
 318
 319         assert(lookup_method_type ==
 320                         LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF);
 321
 322         symbol = lttng_userspace_probe_location_function_get_function_name(
 323                         probe_location);
 324         if (!symbol) {
 325                 ret = -1;
 326                 goto end;
 327         }
 328
 329         fd = lttng_userspace_probe_location_function_get_binary_fd(probe_location);
 330         if (fd < 0) {
 331                 ret = -1;
 332                 goto end;
 333         }
 334
 335         ret = run_as_extract_elf_symbol_offset(fd, symbol, uid, gid, offset);
 336         if (ret < 0) {
 337                 DBG("userspace probe offset calculation failed for "
 338                                 "function %s", symbol);
 339                 goto end;
 340         }
 341
 342         DBG("userspace probe elf offset for %s is 0x%jd", symbol, (intmax_t)(*offset));
 343 end:
 344         return ret;
 345 }
 346
 347 /*
 348  * Compute the offsets of the instrumentation bytes in the binary based on the
 349  * tracepoint probe location using the SDT lookup method. This function
 350  * allocates the offsets buffer, the caller must free it.
 351  *
 352  * Returns 0 on success and set the offset out parameter to the offsets of the
 353  * SDT tracepoint.
 354  * Returns -1 on error.
 355  */
 356 static
 357 int extract_userspace_probe_offset_tracepoint_sdt(
 358                 const struct lttng_userspace_probe_location *probe_location,
 359                 uid_t uid, gid_t gid, uint64_t **offsets,
 360                 uint32_t *offsets_count)
 361 {
 362         enum lttng_userspace_probe_location_lookup_method_type lookup_method_type;
 363         const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
 364         const char *probe_name = NULL, *provider_name = NULL;
 365         int ret = 0;
 366         int fd, i;
 367
 368         assert(lttng_userspace_probe_location_get_type(probe_location) ==
 369                         LTTNG_USERSPACE_PROBE_LOCATION_TYPE_TRACEPOINT);
 370
 371         lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
 372         if (!lookup) {
 373                 ret = -1;
 374                 goto end;
 375         }
 376
 377         lookup_method_type =
 378                         lttng_userspace_probe_location_lookup_method_get_type(lookup);
 379
 380         assert(lookup_method_type ==
 381                         LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT);
 382
 383
 384         probe_name = lttng_userspace_probe_location_tracepoint_get_probe_name(
 385                         probe_location);
 386         if (!probe_name) {
 387                 ret = -1;
 388                 goto end;
 389         }
 390
 391         provider_name = lttng_userspace_probe_location_tracepoint_get_provider_name(
 392                         probe_location);
 393         if (!provider_name) {
 394                 ret = -1;
 395                 goto end;
 396         }
 397
 398         fd = lttng_userspace_probe_location_tracepoint_get_binary_fd(probe_location);
 399         if (fd < 0) {
 400                 ret = -1;
 401                 goto end;
 402         }
 403
 404         ret = run_as_extract_sdt_probe_offsets(fd, provider_name, probe_name,
 405                         uid, gid, offsets, offsets_count);
 406         if (ret < 0) {
 407                 DBG("userspace probe offset calculation failed for sdt "
 408                                 "probe %s:%s", provider_name, probe_name);
 409                 goto end;
 410         }
 411
 412         if (*offsets_count == 0) {
 413                 DBG("no userspace probe offset found");
 414                 goto end;
 415         }
 416
 417         DBG("%u userspace probe SDT offsets found for %s:%s at:",
 418                         *offsets_count, provider_name, probe_name);
 419         for (i = 0; i < *offsets_count; i++) {
 420                 DBG("\t0x%jd", (intmax_t)((*offsets)[i]));
 421         }
 422 end:
 423         return ret;
 424 }
 425
 426 static
 427 int userspace_probe_add_callsite(
 428                 const struct lttng_userspace_probe_location *location,
 429                 uid_t uid, gid_t gid, int fd)
 430 {
 431         const struct lttng_userspace_probe_location_lookup_method *lookup_method = NULL;
 432         enum lttng_userspace_probe_location_lookup_method_type type;
 433         int ret;
 434
 435         lookup_method = lttng_userspace_probe_location_get_lookup_method(location);
 436         if (!lookup_method) {
 437                 ret = -1;
 438                 goto end;
 439         }
 440
 441         type = lttng_userspace_probe_location_lookup_method_get_type(lookup_method);
 442         switch (type) {
 443         case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
 444         {
 445                 struct lttng_kernel_event_callsite callsite;
 446                 uint64_t offset;
 447
 448                 ret = extract_userspace_probe_offset_function_elf(location,
 449                                 uid, gid, &offset);
 450                 if (ret) {
 451                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 452                         goto end;
 453                 }
 454
 455                 callsite.u.uprobe.offset = offset;
 456                 ret = kernctl_add_callsite(fd, &callsite);
 457                 if (ret) {
 458                         WARN("Failed to add callsite to ELF userspace probe.");
 459                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 460                         goto end;
 461                 }
 462                 break;
 463         }
 464         case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
 465         {
 466                 int i;
 467                 uint64_t *offsets = NULL;
 468                 uint32_t offsets_count;
 469                 struct lttng_kernel_event_callsite callsite;
 470
 471                 /*
 472                  * This call allocates the offsets buffer. This buffer must be freed
 473                  * by the caller
 474                  */
 475                 ret = extract_userspace_probe_offset_tracepoint_sdt(location,
 476                                 uid, gid, &offsets, &offsets_count);
 477                 if (ret) {
 478                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 479                         goto end;
 480                 }
 481                 for (i = 0; i < offsets_count; i++) {
 482                         callsite.u.uprobe.offset = offsets[i];
 483                         ret = kernctl_add_callsite(fd, &callsite);
 484                         if (ret) {
 485                                 WARN("Failed to add callsite to SDT userspace probe");
 486                                 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 487                                 free(offsets);
 488                                 goto end;
 489                         }
 490                 }
 491                 free(offsets);
 492                 break;
 493         }
 494         default:
 495                 ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 496                 goto end;
 497         }
 498 end:
 499         return ret;
 500 }
 501
 502 /*
 503  * Extract the offsets of the instrumentation point for the different lookup
 504  * methods.
 505  */
 506 static
 507 int userspace_probe_event_add_callsites(struct lttng_event *ev,
 508                         struct ltt_kernel_session *session, int fd)
 509 {
 510         int ret;
 511         const struct lttng_userspace_probe_location *location = NULL;
 512
 513         assert(ev);
 514         assert(ev->type == LTTNG_EVENT_USERSPACE_PROBE);
 515
 516         location = lttng_event_get_userspace_probe_location(ev);
 517         if (!location) {
 518                 ret = -1;
 519                 goto end;
 520         }
 521
 522         ret = userspace_probe_add_callsite(location, session->uid, session->gid,
 523                 fd);
 524         if (ret) {
 525                 WARN("Failed to add callsite to userspace probe event '%s'",
 526                                 ev->name);
 527         }
 528
 529 end:
 530         return ret;
 531 }
 532
 533 /*
 534  * Extract the offsets of the instrumentation point for the different look-up
 535  * methods.
 536  */
 537 static int userspace_probe_event_rule_add_callsites(
 538                 const struct lttng_event_rule *rule,
 539                 const struct lttng_credentials *creds,
 540                 int fd)
 541 {
 542         int ret;
 543         enum lttng_event_rule_status status;
 544         enum lttng_event_rule_type event_rule_type;
 545         const struct lttng_userspace_probe_location *location = NULL;
 546
 547         assert(rule);
 548         assert(creds);
 549
 550         event_rule_type = lttng_event_rule_get_type(rule);
 551         assert(event_rule_type == LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE);
 552
 553         status = lttng_event_rule_userspace_probe_get_location(rule, &location);
 554         if (status != LTTNG_EVENT_RULE_STATUS_OK || !location) {
 555                 ret = -1;
 556                 goto end;
 557         }
 558
 559         ret = userspace_probe_add_callsite(location,
 560                         lttng_credentials_get_uid(creds),
 561                         lttng_credentials_get_gid(creds), fd);
 562         if (ret) {
 563                 WARN("Failed to add callsite to user space probe object: fd = %d",
 564                                 fd);
 565         }
 566
 567 end:
 568         return ret;
 569 }
 570
 571 /*
 572  * Create a kernel event, enable it to the kernel tracer and add it to the
 573  * channel event list of the kernel session.
 574  * We own filter_expression and filter.
 575  */
 576 int kernel_create_event(struct lttng_event *ev,
 577                 struct ltt_kernel_channel *channel,
 578                 char *filter_expression,
 579                 struct lttng_bytecode *filter)
 580 {
 581         int err, fd;
 582         enum lttng_error_code ret;
 583         struct ltt_kernel_event *event;
 584
 585         assert(ev);
 586         assert(channel);
 587
 588         /* We pass ownership of filter_expression and filter */
 589         ret = trace_kernel_create_event(ev, filter_expression,
 590                         filter, &event);
 591         if (ret != LTTNG_OK) {
 592                 goto error;
 593         }
 594
 595         fd = kernctl_create_event(channel->fd, event->event);
 596         if (fd < 0) {
 597                 switch (-fd) {
 598                 case EEXIST:
 599                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 600                         break;
 601                 case ENOSYS:
 602                         WARN("Event type not implemented");
 603                         ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
 604                         break;
 605                 case ENOENT:
 606                         WARN("Event %s not found!", ev->name);
 607                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 608                         break;
 609                 default:
 610                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 611                         PERROR("create event ioctl");
 612                 }
 613                 goto free_event;
 614         }
 615
 616         event->type = ev->type;
 617         event->fd = fd;
 618         /* Prevent fd duplication after execlp() */
 619         err = fcntl(event->fd, F_SETFD, FD_CLOEXEC);
 620         if (err < 0) {
 621                 PERROR("fcntl session fd");
 622         }
 623
 624         if (filter) {
 625                 err = kernctl_filter(event->fd, filter);
 626                 if (err < 0) {
 627                         switch (-err) {
 628                         case ENOMEM:
 629                                 ret = LTTNG_ERR_FILTER_NOMEM;
 630                                 break;
 631                         default:
 632                                 ret = LTTNG_ERR_FILTER_INVAL;
 633                                 break;
 634                         }
 635                         goto filter_error;
 636                 }
 637         }
 638
 639         if (ev->type == LTTNG_EVENT_USERSPACE_PROBE) {
 640                 ret = userspace_probe_event_add_callsites(ev, channel->session,
 641                                 event->fd);
 642                 if (ret) {
 643                         goto add_callsite_error;
 644                 }
 645         }
 646
 647         err = kernctl_enable(event->fd);
 648         if (err < 0) {
 649                 switch (-err) {
 650                 case EEXIST:
 651                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 652                         break;
 653                 default:
 654                         PERROR("enable kernel event");
 655                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 656                         break;
 657                 }
 658                 goto enable_error;
 659         }
 660
 661         /* Add event to event list */
 662         cds_list_add(&event->list, &channel->events_list.head);
 663         channel->event_count++;
 664
 665         DBG("Event %s created (fd: %d)", ev->name, event->fd);
 666
 667         return 0;
 668
 669 add_callsite_error:
 670 enable_error:
 671 filter_error:
 672         {
 673                 int closeret;
 674
 675                 closeret = close(event->fd);
 676                 if (closeret) {
 677                         PERROR("close event fd");
 678                 }
 679         }
 680 free_event:
 681         free(event);
 682 error:
 683         return ret;
 684 }
 685
 686 /*
 687  * Disable a kernel channel.
 688  */
 689 int kernel_disable_channel(struct ltt_kernel_channel *chan)
 690 {
 691         int ret;
 692
 693         assert(chan);
 694
 695         ret = kernctl_disable(chan->fd);
 696         if (ret < 0) {
 697                 PERROR("disable chan ioctl");
 698                 goto error;
 699         }
 700
 701         chan->enabled = 0;
 702         DBG("Kernel channel %s disabled (fd: %d, key: %" PRIu64 ")",
 703                         chan->channel->name, chan->fd, chan->key);
 704
 705         return 0;
 706
 707 error:
 708         return ret;
 709 }
 710
 711 /*
 712  * Enable a kernel channel.
 713  */
 714 int kernel_enable_channel(struct ltt_kernel_channel *chan)
 715 {
 716         int ret;
 717
 718         assert(chan);
 719
 720         ret = kernctl_enable(chan->fd);
 721         if (ret < 0 && ret != -EEXIST) {
 722                 PERROR("Enable kernel chan");
 723                 goto error;
 724         }
 725
 726         chan->enabled = 1;
 727         DBG("Kernel channel %s enabled (fd: %d, key: %" PRIu64 ")",
 728                         chan->channel->name, chan->fd, chan->key);
 729
 730         return 0;
 731
 732 error:
 733         return ret;
 734 }
 735
 736 /*
 737  * Enable a kernel event.
 738  */
 739 int kernel_enable_event(struct ltt_kernel_event *event)
 740 {
 741         int ret;
 742
 743         assert(event);
 744
 745         ret = kernctl_enable(event->fd);
 746         if (ret < 0) {
 747                 switch (-ret) {
 748                 case EEXIST:
 749                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 750                         break;
 751                 default:
 752                         PERROR("enable kernel event");
 753                         break;
 754                 }
 755                 goto error;
 756         }
 757
 758         event->enabled = 1;
 759         DBG("Kernel event %s enabled (fd: %d)", event->event->name, event->fd);
 760
 761         return 0;
 762
 763 error:
 764         return ret;
 765 }
 766
 767 /*
 768  * Disable a kernel event.
 769  */
 770 int kernel_disable_event(struct ltt_kernel_event *event)
 771 {
 772         int ret;
 773
 774         assert(event);
 775
 776         ret = kernctl_disable(event->fd);
 777         if (ret < 0) {
 778                 switch (-ret) {
 779                 case EEXIST:
 780                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 781                         break;
 782                 default:
 783                         PERROR("disable kernel event");
 784                         break;
 785                 }
 786                 goto error;
 787         }
 788
 789         event->enabled = 0;
 790         DBG("Kernel event %s disabled (fd: %d)", event->event->name, event->fd);
 791
 792         return 0;
 793
 794 error:
 795         return ret;
 796 }
 797
 798 /*
 799  * Disable a kernel event notifier.
 800  */
 801 static
 802 int kernel_disable_event_notifier_rule(struct ltt_kernel_event_notifier_rule *event)
 803 {
 804         int ret;
 805
 806         assert(event);
 807
 808         rcu_read_lock();
 809         cds_lfht_del(kernel_token_to_event_notifier_rule_ht, &event->ht_node);
 810         rcu_read_unlock();
 811
 812         ret = kernctl_disable(event->fd);
 813         if (ret < 0) {
 814                 switch (-ret) {
 815                 case EEXIST:
 816                         ret = LTTNG_ERR_KERN_EVENT_EXIST;
 817                         break;
 818                 default:
 819                         PERROR("Failed to disable kernel event notifier: fd = %d, token = %" PRIu64,
 820                                         event->fd, event->token);
 821                         break;
 822                 }
 823                 goto error;
 824         }
 825
 826         event->enabled = 0;
 827         DBG("Disabled kernel event notifier: fd = %d, token = %" PRIu64,
 828                         event->fd, event->token);
 829
 830 error:
 831         return ret;
 832 }
 833
 834 static
 835 struct process_attr_tracker *_kernel_get_process_attr_tracker(
 836                 struct ltt_kernel_session *session,
 837                 enum lttng_process_attr process_attr)
 838 {
 839         switch (process_attr) {
 840         case LTTNG_PROCESS_ATTR_PROCESS_ID:
 841                 return session->tracker_pid;
 842         case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
 843                 return session->tracker_vpid;
 844         case LTTNG_PROCESS_ATTR_USER_ID:
 845                 return session->tracker_uid;
 846         case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
 847                 return session->tracker_vuid;
 848         case LTTNG_PROCESS_ATTR_GROUP_ID:
 849                 return session->tracker_gid;
 850         case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
 851                 return session->tracker_vgid;
 852         default:
 853                 return NULL;
 854         }
 855 }
 856
 857 const struct process_attr_tracker *kernel_get_process_attr_tracker(
 858                 struct ltt_kernel_session *session,
 859                 enum lttng_process_attr process_attr)
 860 {
 861         return (const struct process_attr_tracker *)
 862                         _kernel_get_process_attr_tracker(session, process_attr);
 863 }
 864
 865 enum lttng_error_code kernel_process_attr_tracker_set_tracking_policy(
 866                 struct ltt_kernel_session *session,
 867                 enum lttng_process_attr process_attr,
 868                 enum lttng_tracking_policy policy)
 869 {
 870         int ret;
 871         enum lttng_error_code ret_code = LTTNG_OK;
 872         struct process_attr_tracker *tracker =
 873                         _kernel_get_process_attr_tracker(session, process_attr);
 874         enum lttng_tracking_policy previous_policy;
 875
 876         if (!tracker) {
 877                 ret_code = LTTNG_ERR_INVALID;
 878                 goto end;
 879         }
 880
 881         previous_policy = process_attr_tracker_get_tracking_policy(tracker);
 882         ret = process_attr_tracker_set_tracking_policy(tracker, policy);
 883         if (ret) {
 884                 ret_code = LTTNG_ERR_UNK;
 885                 goto end;
 886         }
 887
 888         if (previous_policy == policy) {
 889                 goto end;
 890         }
 891
 892         switch (policy) {
 893         case LTTNG_TRACKING_POLICY_INCLUDE_ALL:
 894                 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
 895                         /*
 896                          * Maintain a special case for the process ID process
 897                          * attribute tracker as it was the only supported
 898                          * attribute prior to 2.12.
 899                          */
 900                         ret = kernctl_track_pid(session->fd, -1);
 901                 } else {
 902                         ret = kernctl_track_id(session->fd, process_attr, -1);
 903                 }
 904                 break;
 905         case LTTNG_TRACKING_POLICY_EXCLUDE_ALL:
 906         case LTTNG_TRACKING_POLICY_INCLUDE_SET:
 907                 /* fall-through. */
 908                 if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
 909                         /*
 910                          * Maintain a special case for the process ID process
 911                          * attribute tracker as it was the only supported
 912                          * attribute prior to 2.12.
 913                          */
 914                         ret = kernctl_untrack_pid(session->fd, -1);
 915                 } else {
 916                         ret = kernctl_untrack_id(session->fd, process_attr, -1);
 917                 }
 918                 break;
 919         default:
 920                 abort();
 921         }
 922         /* kern-ctl error handling */
 923         switch (-ret) {
 924         case 0:
 925                 ret_code = LTTNG_OK;
 926                 break;
 927         case EINVAL:
 928                 ret_code = LTTNG_ERR_INVALID;
 929                 break;
 930         case ENOMEM:
 931                 ret_code = LTTNG_ERR_NOMEM;
 932                 break;
 933         case EEXIST:
 934                 ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
 935                 break;
 936         default:
 937                 ret_code = LTTNG_ERR_UNK;
 938                 break;
 939         }
 940 end:
 941         return ret_code;
 942 }
 943
 944 enum lttng_error_code kernel_process_attr_tracker_inclusion_set_add_value(
 945                 struct ltt_kernel_session *session,
 946                 enum lttng_process_attr process_attr,
 947                 const struct process_attr_value *value)
 948 {
 949         int ret, integral_value;
 950         enum lttng_error_code ret_code;
 951         struct process_attr_tracker *tracker;
 952         enum process_attr_tracker_status status;
 953
 954         /*
 955          * Convert process attribute tracker value to the integral
 956          * representation required by the kern-ctl API.
 957          */
 958         switch (process_attr) {
 959         case LTTNG_PROCESS_ATTR_PROCESS_ID:
 960         case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
 961                 integral_value = (int) value->value.pid;
 962                 break;
 963         case LTTNG_PROCESS_ATTR_USER_ID:
 964         case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
 965                 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) {
 966                         uid_t uid;
 967
 968                         ret_code = utils_user_id_from_name(
 969                                         value->value.user_name, &uid);
 970                         if (ret_code != LTTNG_OK) {
 971                                 goto end;
 972                         }
 973                         integral_value = (int) uid;
 974                 } else {
 975                         integral_value = (int) value->value.uid;
 976                 }
 977                 break;
 978         case LTTNG_PROCESS_ATTR_GROUP_ID:
 979         case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
 980                 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) {
 981                         gid_t gid;
 982
 983                         ret_code = utils_group_id_from_name(
 984                                         value->value.group_name, &gid);
 985                         if (ret_code != LTTNG_OK) {
 986                                 goto end;
 987                         }
 988                         integral_value = (int) gid;
 989                 } else {
 990                         integral_value = (int) value->value.gid;
 991                 }
 992                 break;
 993         default:
 994                 ret_code = LTTNG_ERR_INVALID;
 995                 goto end;
 996         }
 997
 998         tracker = _kernel_get_process_attr_tracker(session, process_attr);
 999         if (!tracker) {
1000                 ret_code = LTTNG_ERR_INVALID;
1001                 goto end;
1002         }
1003
1004         status = process_attr_tracker_inclusion_set_add_value(tracker, value);
1005         if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
1006                 switch (status) {
1007                 case PROCESS_ATTR_TRACKER_STATUS_EXISTS:
1008                         ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
1009                         break;
1010                 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
1011                         ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
1012                         break;
1013                 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
1014                 default:
1015                         ret_code = LTTNG_ERR_UNK;
1016                         break;
1017                 }
1018                 goto end;
1019         }
1020
1021         DBG("Kernel track %s %d for session id %" PRIu64,
1022                         lttng_process_attr_to_string(process_attr),
1023                         integral_value, session->id);
1024         if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
1025                 /*
1026                  * Maintain a special case for the process ID process attribute
1027                  * tracker as it was the only supported attribute prior to 2.12.
1028                  */
1029                 ret = kernctl_track_pid(session->fd, integral_value);
1030         } else {
1031                 ret = kernctl_track_id(
1032                                 session->fd, process_attr, integral_value);
1033         }
1034         if (ret == 0) {
1035                 ret_code = LTTNG_OK;
1036                 goto end;
1037         }
1038
1039         kernel_wait_quiescent();
1040
1041         /* kern-ctl error handling */
1042         switch (-ret) {
1043         case 0:
1044                 ret_code = LTTNG_OK;
1045                 break;
1046         case EINVAL:
1047                 ret_code = LTTNG_ERR_INVALID;
1048                 break;
1049         case ENOMEM:
1050                 ret_code = LTTNG_ERR_NOMEM;
1051                 break;
1052         case EEXIST:
1053                 ret_code = LTTNG_ERR_PROCESS_ATTR_EXISTS;
1054                 break;
1055         default:
1056                 ret_code = LTTNG_ERR_UNK;
1057                 break;
1058         }
1059
1060         /* Attempt to remove the value from the tracker. */
1061         status = process_attr_tracker_inclusion_set_remove_value(
1062                         tracker, value);
1063         if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
1064                 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
1065                                 lttng_process_attr_to_string(process_attr),
1066                                 integral_value);
1067         }
1068 end:
1069         return ret_code;
1070 }
1071
1072 enum lttng_error_code kernel_process_attr_tracker_inclusion_set_remove_value(
1073                 struct ltt_kernel_session *session,
1074                 enum lttng_process_attr process_attr,
1075                 const struct process_attr_value *value)
1076 {
1077         int ret, integral_value;
1078         enum lttng_error_code ret_code;
1079         struct process_attr_tracker *tracker;
1080         enum process_attr_tracker_status status;
1081
1082         /*
1083          * Convert process attribute tracker value to the integral
1084          * representation required by the kern-ctl API.
1085          */
1086         switch (process_attr) {
1087         case LTTNG_PROCESS_ATTR_PROCESS_ID:
1088         case LTTNG_PROCESS_ATTR_VIRTUAL_PROCESS_ID:
1089                 integral_value = (int) value->value.pid;
1090                 break;
1091         case LTTNG_PROCESS_ATTR_USER_ID:
1092         case LTTNG_PROCESS_ATTR_VIRTUAL_USER_ID:
1093                 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_USER_NAME) {
1094                         uid_t uid;
1095
1096                         ret_code = utils_user_id_from_name(
1097                                         value->value.user_name, &uid);
1098                         if (ret_code != LTTNG_OK) {
1099                                 goto end;
1100                         }
1101                         integral_value = (int) uid;
1102                 } else {
1103                         integral_value = (int) value->value.uid;
1104                 }
1105                 break;
1106         case LTTNG_PROCESS_ATTR_GROUP_ID:
1107         case LTTNG_PROCESS_ATTR_VIRTUAL_GROUP_ID:
1108                 if (value->type == LTTNG_PROCESS_ATTR_VALUE_TYPE_GROUP_NAME) {
1109                         gid_t gid;
1110
1111                         ret_code = utils_group_id_from_name(
1112                                         value->value.group_name, &gid);
1113                         if (ret_code != LTTNG_OK) {
1114                                 goto end;
1115                         }
1116                         integral_value = (int) gid;
1117                 } else {
1118                         integral_value = (int) value->value.gid;
1119                 }
1120                 break;
1121         default:
1122                 ret_code = LTTNG_ERR_INVALID;
1123                 goto end;
1124         }
1125
1126         tracker = _kernel_get_process_attr_tracker(session, process_attr);
1127         if (!tracker) {
1128                 ret_code = LTTNG_ERR_INVALID;
1129                 goto end;
1130         }
1131
1132         status = process_attr_tracker_inclusion_set_remove_value(
1133                         tracker, value);
1134         if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
1135                 switch (status) {
1136                 case PROCESS_ATTR_TRACKER_STATUS_MISSING:
1137                         ret_code = LTTNG_ERR_PROCESS_ATTR_MISSING;
1138                         break;
1139                 case PROCESS_ATTR_TRACKER_STATUS_INVALID_TRACKING_POLICY:
1140                         ret_code = LTTNG_ERR_PROCESS_ATTR_TRACKER_INVALID_TRACKING_POLICY;
1141                         break;
1142                 case PROCESS_ATTR_TRACKER_STATUS_ERROR:
1143                 default:
1144                         ret_code = LTTNG_ERR_UNK;
1145                         break;
1146                 }
1147                 goto end;
1148         }
1149
1150         DBG("Kernel track %s %d for session id %" PRIu64,
1151                         lttng_process_attr_to_string(process_attr),
1152                         integral_value, session->id);
1153         if (process_attr == LTTNG_PROCESS_ATTR_PROCESS_ID) {
1154                 /*
1155                  * Maintain a special case for the process ID process attribute
1156                  * tracker as it was the only supported attribute prior to 2.12.
1157                  */
1158                 ret = kernctl_untrack_pid(session->fd, integral_value);
1159         } else {
1160                 ret = kernctl_untrack_id(
1161                                 session->fd, process_attr, integral_value);
1162         }
1163         if (ret == 0) {
1164                 ret_code = LTTNG_OK;
1165                 goto end;
1166         }
1167         kernel_wait_quiescent();
1168
1169         /* kern-ctl error handling */
1170         switch (-ret) {
1171         case 0:
1172                 ret_code = LTTNG_OK;
1173                 break;
1174         case EINVAL:
1175                 ret_code = LTTNG_ERR_INVALID;
1176                 break;
1177         case ENOMEM:
1178                 ret_code = LTTNG_ERR_NOMEM;
1179                 break;
1180         case ENOENT:
1181                 ret_code = LTTNG_ERR_PROCESS_ATTR_MISSING;
1182                 break;
1183         default:
1184                 ret_code = LTTNG_ERR_UNK;
1185                 break;
1186         }
1187
1188         /* Attempt to add the value to the tracker. */
1189         status = process_attr_tracker_inclusion_set_add_value(
1190                         tracker, value);
1191         if (status != PROCESS_ATTR_TRACKER_STATUS_OK) {
1192                 ERR("Failed to roll-back the tracking of kernel %s process attribute %d while handling a kern-ctl error",
1193                                 lttng_process_attr_to_string(process_attr),
1194                                 integral_value);
1195         }
1196 end:
1197         return ret_code;
1198 }
1199
1200 /*
1201  * Create kernel metadata, open from the kernel tracer and add it to the
1202  * kernel session.
1203  */
1204 int kernel_open_metadata(struct ltt_kernel_session *session)
1205 {
1206         int ret;
1207         struct ltt_kernel_metadata *lkm = NULL;
1208
1209         assert(session);
1210
1211         /* Allocate kernel metadata */
1212         lkm = trace_kernel_create_metadata();
1213         if (lkm == NULL) {
1214                 goto error;
1215         }
1216
1217         /* Kernel tracer metadata creation */
1218         ret = kernctl_open_metadata(session->fd, &lkm->conf->attr);
1219         if (ret < 0) {
1220                 goto error_open;
1221         }
1222
1223         lkm->fd = ret;
1224         lkm->key = ++next_kernel_channel_key;
1225         /* Prevent fd duplication after execlp() */
1226         ret = fcntl(lkm->fd, F_SETFD, FD_CLOEXEC);
1227         if (ret < 0) {
1228                 PERROR("fcntl session fd");
1229         }
1230
1231         session->metadata = lkm;
1232
1233         DBG("Kernel metadata opened (fd: %d)", lkm->fd);
1234
1235         return 0;
1236
1237 error_open:
1238         trace_kernel_destroy_metadata(lkm);
1239 error:
1240         return -1;
1241 }
1242
1243 /*
1244  * Start tracing session.
1245  */
1246 int kernel_start_session(struct ltt_kernel_session *session)
1247 {
1248         int ret;
1249
1250         assert(session);
1251
1252         ret = kernctl_start_session(session->fd);
1253         if (ret < 0) {
1254                 PERROR("ioctl start session");
1255                 goto error;
1256         }
1257
1258         DBG("Kernel session started");
1259
1260         return 0;
1261
1262 error:
1263         return ret;
1264 }
1265
1266 /*
1267  * Make a kernel wait to make sure in-flight probe have completed.
1268  */
1269 void kernel_wait_quiescent(void)
1270 {
1271         int ret;
1272         int fd = kernel_tracer_fd;
1273
1274         DBG("Kernel quiescent wait on %d", fd);
1275
1276         ret = kernctl_wait_quiescent(fd);
1277         if (ret < 0) {
1278                 PERROR("wait quiescent ioctl");
1279                 ERR("Kernel quiescent wait failed");
1280         }
1281 }
1282
1283 /*
1284  *  Force flush buffer of metadata.
1285  */
1286 int kernel_metadata_flush_buffer(int fd)
1287 {
1288         int ret;
1289
1290         DBG("Kernel flushing metadata buffer on fd %d", fd);
1291
1292         ret = kernctl_buffer_flush(fd);
1293         if (ret < 0) {
1294                 ERR("Fail to flush metadata buffers %d (ret: %d)", fd, ret);
1295         }
1296
1297         return 0;
1298 }
1299
1300 /*
1301  * Force flush buffer for channel.
1302  */
1303 int kernel_flush_buffer(struct ltt_kernel_channel *channel)
1304 {
1305         int ret;
1306         struct ltt_kernel_stream *stream;
1307
1308         assert(channel);
1309
1310         DBG("Flush buffer for channel %s", channel->channel->name);
1311
1312         cds_list_for_each_entry(stream, &channel->stream_list.head, list) {
1313                 DBG("Flushing channel stream %d", stream->fd);
1314                 ret = kernctl_buffer_flush(stream->fd);
1315                 if (ret < 0) {
1316                         PERROR("ioctl");
1317                         ERR("Fail to flush buffer for stream %d (ret: %d)",
1318                                         stream->fd, ret);
1319                 }
1320         }
1321
1322         return 0;
1323 }
1324
1325 /*
1326  * Stop tracing session.
1327  */
1328 int kernel_stop_session(struct ltt_kernel_session *session)
1329 {
1330         int ret;
1331
1332         assert(session);
1333
1334         ret = kernctl_stop_session(session->fd);
1335         if (ret < 0) {
1336                 goto error;
1337         }
1338
1339         DBG("Kernel session stopped");
1340
1341         return 0;
1342
1343 error:
1344         return ret;
1345 }
1346
1347 /*
1348  * Open stream of channel, register it to the kernel tracer and add it
1349  * to the stream list of the channel.
1350  *
1351  * Note: given that the streams may appear in random order wrt CPU
1352  * number (e.g. cpu hotplug), the index value of the stream number in
1353  * the stream name is not necessarily linked to the CPU number.
1354  *
1355  * Return the number of created stream. Else, a negative value.
1356  */
1357 int kernel_open_channel_stream(struct ltt_kernel_channel *channel)
1358 {
1359         int ret;
1360         struct ltt_kernel_stream *lks;
1361
1362         assert(channel);
1363
1364         while ((ret = kernctl_create_stream(channel->fd)) >= 0) {
1365                 lks = trace_kernel_create_stream(channel->channel->name,
1366                                 channel->stream_count);
1367                 if (lks == NULL) {
1368                         ret = close(ret);
1369                         if (ret) {
1370                                 PERROR("close");
1371                         }
1372                         goto error;
1373                 }
1374
1375                 lks->fd = ret;
1376                 /* Prevent fd duplication after execlp() */
1377                 ret = fcntl(lks->fd, F_SETFD, FD_CLOEXEC);
1378                 if (ret < 0) {
1379                         PERROR("fcntl session fd");
1380                 }
1381
1382                 lks->tracefile_size = channel->channel->attr.tracefile_size;
1383                 lks->tracefile_count = channel->channel->attr.tracefile_count;
1384
1385                 /* Add stream to channel stream list */
1386                 cds_list_add(&lks->list, &channel->stream_list.head);
1387                 channel->stream_count++;
1388
1389                 DBG("Kernel stream %s created (fd: %d, state: %d)", lks->name, lks->fd,
1390                                 lks->state);
1391         }
1392
1393         return channel->stream_count;
1394
1395 error:
1396         return -1;
1397 }
1398
1399 /*
1400  * Open the metadata stream and set it to the kernel session.
1401  */
1402 int kernel_open_metadata_stream(struct ltt_kernel_session *session)
1403 {
1404         int ret;
1405
1406         assert(session);
1407
1408         ret = kernctl_create_stream(session->metadata->fd);
1409         if (ret < 0) {
1410                 PERROR("kernel create metadata stream");
1411                 goto error;
1412         }
1413
1414         DBG("Kernel metadata stream created (fd: %d)", ret);
1415         session->metadata_stream_fd = ret;
1416         /* Prevent fd duplication after execlp() */
1417         ret = fcntl(session->metadata_stream_fd, F_SETFD, FD_CLOEXEC);
1418         if (ret < 0) {
1419                 PERROR("fcntl session fd");
1420         }
1421
1422         return 0;
1423
1424 error:
1425         return -1;
1426 }
1427
1428 /*
1429  * Get the event list from the kernel tracer and return the number of elements.
1430  */
1431 ssize_t kernel_list_events(struct lttng_event **events)
1432 {
1433         int fd, ret;
1434         char *event;
1435         size_t nbmem, count = 0;
1436         FILE *fp;
1437         struct lttng_event *elist;
1438
1439         assert(events);
1440
1441         fd = kernctl_tracepoint_list(kernel_tracer_fd);
1442         if (fd < 0) {
1443                 PERROR("kernel tracepoint list");
1444                 goto error;
1445         }
1446
1447         fp = fdopen(fd, "r");
1448         if (fp == NULL) {
1449                 PERROR("kernel tracepoint list fdopen");
1450                 goto error_fp;
1451         }
1452
1453         /*
1454          * Init memory size counter
1455          * See kernel-ctl.h for explanation of this value
1456          */
1457         nbmem = KERNEL_EVENT_INIT_LIST_SIZE;
1458         elist = zmalloc(sizeof(struct lttng_event) * nbmem);
1459         if (elist == NULL) {
1460                 PERROR("alloc list events");
1461                 count = -ENOMEM;
1462                 goto end;
1463         }
1464
1465         while (fscanf(fp, "event { name = %m[^;]; };\n", &event) == 1) {
1466                 if (count >= nbmem) {
1467                         struct lttng_event *new_elist;
1468                         size_t new_nbmem;
1469
1470                         new_nbmem = nbmem << 1;
1471                         DBG("Reallocating event list from %zu to %zu bytes",
1472                                         nbmem, new_nbmem);
1473                         new_elist = realloc(elist, new_nbmem * sizeof(struct lttng_event));
1474                         if (new_elist == NULL) {
1475                                 PERROR("realloc list events");
1476                                 free(event);
1477                                 free(elist);
1478                                 count = -ENOMEM;
1479                                 goto end;
1480                         }
1481                         /* Zero the new memory */
1482                         memset(new_elist + nbmem, 0,
1483                                 (new_nbmem - nbmem) * sizeof(struct lttng_event));
1484                         nbmem = new_nbmem;
1485                         elist = new_elist;
1486                 }
1487                 strncpy(elist[count].name, event, LTTNG_SYMBOL_NAME_LEN);
1488                 elist[count].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
1489                 elist[count].enabled = -1;
1490                 count++;
1491                 free(event);
1492         }
1493
1494         *events = elist;
1495         DBG("Kernel list events done (%zu events)", count);
1496 end:
1497         ret = fclose(fp);       /* closes both fp and fd */
1498         if (ret) {
1499                 PERROR("fclose");
1500         }
1501         return count;
1502
1503 error_fp:
1504         ret = close(fd);
1505         if (ret) {
1506                 PERROR("close");
1507         }
1508 error:
1509         return -1;
1510 }
1511
1512 /*
1513  * Get kernel version and validate it.
1514  */
1515 int kernel_validate_version(struct lttng_kernel_tracer_version *version,
1516                 struct lttng_kernel_tracer_abi_version *abi_version)
1517 {
1518         int ret;
1519
1520         ret = kernctl_tracer_version(kernel_tracer_fd, version);
1521         if (ret < 0) {
1522                 ERR("Failed to retrieve the lttng-modules version");
1523                 goto error;
1524         }
1525
1526         /* Validate version */
1527         if (version->major != VERSION_MAJOR) {
1528                 ERR("Kernel tracer major version (%d) is not compatible with lttng-tools major version (%d)",
1529                         version->major, VERSION_MAJOR);
1530                 goto error_version;
1531         }
1532         ret = kernctl_tracer_abi_version(kernel_tracer_fd, abi_version);
1533         if (ret < 0) {
1534                 ERR("Failed to retrieve lttng-modules ABI version");
1535                 goto error;
1536         }
1537         if (abi_version->major != LTTNG_MODULES_ABI_MAJOR_VERSION) {
1538                 ERR("Kernel tracer ABI version (%d.%d) does not match the expected ABI major version (%d.*)",
1539                         abi_version->major, abi_version->minor,
1540                         LTTNG_MODULES_ABI_MAJOR_VERSION);
1541                 goto error;
1542         }
1543         DBG2("Kernel tracer version validated (%d.%d, ABI %d.%d)",
1544                         version->major, version->minor,
1545                         abi_version->major, abi_version->minor);
1546         return 0;
1547
1548 error_version:
1549         ret = -1;
1550
1551 error:
1552         ERR("Kernel tracer version check failed; kernel tracing will not be available");
1553         return ret;
1554 }
1555
1556 /*
1557  * Kernel work-arounds called at the start of sessiond main().
1558  */
1559 int init_kernel_workarounds(void)
1560 {
1561         int ret;
1562         FILE *fp;
1563
1564         /*
1565          * boot_id needs to be read once before being used concurrently
1566          * to deal with a Linux kernel race. A fix is proposed for
1567          * upstream, but the work-around is needed for older kernels.
1568          */
1569         fp = fopen("/proc/sys/kernel/random/boot_id", "r");
1570         if (!fp) {
1571                 goto end_boot_id;
1572         }
1573         while (!feof(fp)) {
1574                 char buf[37] = "";
1575
1576                 ret = fread(buf, 1, sizeof(buf), fp);
1577                 if (ret < 0) {
1578                         /* Ignore error, we don't really care */
1579                 }
1580         }
1581         ret = fclose(fp);
1582         if (ret) {
1583                 PERROR("fclose");
1584         }
1585 end_boot_id:
1586         return 0;
1587 }
1588
1589 /*
1590  * Teardown of a kernel session, keeping data required by destroy notifiers.
1591  */
1592 void kernel_destroy_session(struct ltt_kernel_session *ksess)
1593 {
1594         struct lttng_trace_chunk *trace_chunk;
1595
1596         if (ksess == NULL) {
1597                 DBG3("No kernel session when tearing down session");
1598                 return;
1599         }
1600
1601         DBG("Tearing down kernel session");
1602         trace_chunk = ksess->current_trace_chunk;
1603
1604         /*
1605          * Destroy channels on the consumer if at least one FD has been sent and we
1606          * are in no output mode because the streams are in *no* monitor mode so we
1607          * have to send a command to clean them up or else they leaked.
1608          */
1609         if (!ksess->output_traces && ksess->consumer_fds_sent) {
1610                 int ret;
1611                 struct consumer_socket *socket;
1612                 struct lttng_ht_iter iter;
1613
1614                 /* For each consumer socket. */
1615                 rcu_read_lock();
1616                 cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1617                                 socket, node.node) {
1618                         struct ltt_kernel_channel *chan;
1619
1620                         /* For each channel, ask the consumer to destroy it. */
1621                         cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1622                                 ret = kernel_consumer_destroy_channel(socket, chan);
1623                                 if (ret < 0) {
1624                                         /* Consumer is probably dead. Use next socket. */
1625                                         continue;
1626                                 }
1627                         }
1628                 }
1629                 rcu_read_unlock();
1630         }
1631
1632         /* Close any relayd session */
1633         consumer_output_send_destroy_relayd(ksess->consumer);
1634
1635         trace_kernel_destroy_session(ksess);
1636         lttng_trace_chunk_put(trace_chunk);
1637 }
1638
1639 /* Teardown of data required by destroy notifiers. */
1640 void kernel_free_session(struct ltt_kernel_session *ksess)
1641 {
1642         if (ksess == NULL) {
1643                 return;
1644         }
1645         trace_kernel_free_session(ksess);
1646 }
1647
1648 /*
1649  * Destroy a kernel channel object. It does not do anything on the tracer side.
1650  */
1651 void kernel_destroy_channel(struct ltt_kernel_channel *kchan)
1652 {
1653         struct ltt_kernel_session *ksess = NULL;
1654
1655         assert(kchan);
1656         assert(kchan->channel);
1657
1658         DBG3("Kernel destroy channel %s", kchan->channel->name);
1659
1660         /* Update channel count of associated session. */
1661         if (kchan->session) {
1662                 /* Keep pointer reference so we can update it after the destroy. */
1663                 ksess = kchan->session;
1664         }
1665
1666         trace_kernel_destroy_channel(kchan);
1667
1668         /*
1669          * At this point the kernel channel is not visible anymore. This is safe
1670          * since in order to work on a visible kernel session, the tracing session
1671          * lock (ltt_session.lock) MUST be acquired.
1672          */
1673         if (ksess) {
1674                 ksess->channel_count--;
1675         }
1676 }
1677
1678 /*
1679  * Take a snapshot for a given kernel session.
1680  *
1681  * Return LTTNG_OK on success or else return a LTTNG_ERR code.
1682  */
1683 enum lttng_error_code kernel_snapshot_record(
1684                 struct ltt_kernel_session *ksess,
1685                 const struct consumer_output *output, int wait,
1686                 uint64_t nb_packets_per_stream)
1687 {
1688         int err, ret, saved_metadata_fd;
1689         enum lttng_error_code status = LTTNG_OK;
1690         struct consumer_socket *socket;
1691         struct lttng_ht_iter iter;
1692         struct ltt_kernel_metadata *saved_metadata;
1693         char *trace_path = NULL;
1694         size_t consumer_path_offset = 0;
1695
1696         assert(ksess);
1697         assert(ksess->consumer);
1698         assert(output);
1699
1700         DBG("Kernel snapshot record started");
1701
1702         /* Save current metadata since the following calls will change it. */
1703         saved_metadata = ksess->metadata;
1704         saved_metadata_fd = ksess->metadata_stream_fd;
1705
1706         rcu_read_lock();
1707
1708         ret = kernel_open_metadata(ksess);
1709         if (ret < 0) {
1710                 status = LTTNG_ERR_KERN_META_FAIL;
1711                 goto error;
1712         }
1713
1714         ret = kernel_open_metadata_stream(ksess);
1715         if (ret < 0) {
1716                 status = LTTNG_ERR_KERN_META_FAIL;
1717                 goto error_open_stream;
1718         }
1719
1720         trace_path = setup_channel_trace_path(ksess->consumer,
1721                         DEFAULT_KERNEL_TRACE_DIR, &consumer_path_offset);
1722         if (!trace_path) {
1723                 status = LTTNG_ERR_INVALID;
1724                 goto error;
1725         }
1726         /* Send metadata to consumer and snapshot everything. */
1727         cds_lfht_for_each_entry(output->socks->ht, &iter.iter,
1728                         socket, node.node) {
1729                 struct ltt_kernel_channel *chan;
1730
1731                 pthread_mutex_lock(socket->lock);
1732                 /* This stream must not be monitored by the consumer. */
1733                 ret = kernel_consumer_add_metadata(socket, ksess, 0);
1734                 pthread_mutex_unlock(socket->lock);
1735                 if (ret < 0) {
1736                         status = LTTNG_ERR_KERN_META_FAIL;
1737                         goto error_consumer;
1738                 }
1739
1740                 /* For each channel, ask the consumer to snapshot it. */
1741                 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1742                         status = consumer_snapshot_channel(socket, chan->key, output, 0,
1743                                         ksess->uid, ksess->gid,
1744                                         &trace_path[consumer_path_offset], wait,
1745                                         nb_packets_per_stream);
1746                         if (status != LTTNG_OK) {
1747                                 (void) kernel_consumer_destroy_metadata(socket,
1748                                                 ksess->metadata);
1749                                 goto error_consumer;
1750                         }
1751                 }
1752
1753                 /* Snapshot metadata, */
1754                 status = consumer_snapshot_channel(socket, ksess->metadata->key, output,
1755                                 1, ksess->uid, ksess->gid, &trace_path[consumer_path_offset],
1756                                 wait, 0);
1757                 if (status != LTTNG_OK) {
1758                         goto error_consumer;
1759                 }
1760
1761                 /*
1762                  * The metadata snapshot is done, ask the consumer to destroy it since
1763                  * it's not monitored on the consumer side.
1764                  */
1765                 (void) kernel_consumer_destroy_metadata(socket, ksess->metadata);
1766         }
1767
1768 error_consumer:
1769         /* Close newly opened metadata stream. It's now on the consumer side. */
1770         err = close(ksess->metadata_stream_fd);
1771         if (err < 0) {
1772                 PERROR("close snapshot kernel");
1773         }
1774
1775 error_open_stream:
1776         trace_kernel_destroy_metadata(ksess->metadata);
1777 error:
1778         /* Restore metadata state.*/
1779         ksess->metadata = saved_metadata;
1780         ksess->metadata_stream_fd = saved_metadata_fd;
1781         rcu_read_unlock();
1782         free(trace_path);
1783         return status;
1784 }
1785
1786 /*
1787  * Get the syscall mask array from the kernel tracer.
1788  *
1789  * Return 0 on success else a negative value. In both case, syscall_mask should
1790  * be freed.
1791  */
1792 int kernel_syscall_mask(int chan_fd, char **syscall_mask, uint32_t *nr_bits)
1793 {
1794         assert(syscall_mask);
1795         assert(nr_bits);
1796
1797         return kernctl_syscall_mask(chan_fd, syscall_mask, nr_bits);
1798 }
1799
1800 static
1801 int kernel_tracer_abi_greater_or_equal(unsigned int major, unsigned int minor)
1802 {
1803         int ret;
1804         struct lttng_kernel_tracer_abi_version abi;
1805
1806         ret = kernctl_tracer_abi_version(kernel_tracer_fd, &abi);
1807         if (ret < 0) {
1808                 ERR("Failed to retrieve lttng-modules ABI version");
1809                 goto error;
1810         }
1811
1812         ret = abi.major > major || (abi.major == major && abi.minor >= minor);
1813 error:
1814         return ret;
1815 }
1816
1817 /*
1818  * Check for the support of the RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS via abi
1819  * version number.
1820  *
1821  * Return 1 on success, 0 when feature is not supported, negative value in case
1822  * of errors.
1823  */
1824 int kernel_supports_ring_buffer_snapshot_sample_positions(void)
1825 {
1826         /*
1827          * RING_BUFFER_SNAPSHOT_SAMPLE_POSITIONS was introduced in 2.3
1828          */
1829         return kernel_tracer_abi_greater_or_equal(2, 3);
1830 }
1831
1832 /*
1833  * Check for the support of the packet sequence number via abi version number.
1834  *
1835  * Return 1 on success, 0 when feature is not supported, negative value in case
1836  * of errors.
1837  */
1838 int kernel_supports_ring_buffer_packet_sequence_number(void)
1839 {
1840         /*
1841          * Packet sequence number was introduced in LTTng 2.8,
1842          * lttng-modules ABI 2.1.
1843          */
1844         return kernel_tracer_abi_greater_or_equal(2, 1);
1845 }
1846
1847 /*
1848  * Check for the support of event notifiers via abi version number.
1849  *
1850  * Return 1 on success, 0 when feature is not supported, negative value in case
1851  * of errors.
1852  */
1853 int kernel_supports_event_notifiers(void)
1854 {
1855         /*
1856          * Event notifiers were introduced in LTTng 2.13, lttng-modules ABI 2.6.
1857          */
1858         return kernel_tracer_abi_greater_or_equal(2, 6);
1859 }
1860
1861 /*
1862  * Rotate a kernel session.
1863  *
1864  * Return LTTNG_OK on success or else an LTTng error code.
1865  */
1866 enum lttng_error_code kernel_rotate_session(struct ltt_session *session)
1867 {
1868         int ret;
1869         enum lttng_error_code status = LTTNG_OK;
1870         struct consumer_socket *socket;
1871         struct lttng_ht_iter iter;
1872         struct ltt_kernel_session *ksess = session->kernel_session;
1873
1874         assert(ksess);
1875         assert(ksess->consumer);
1876
1877         DBG("Rotate kernel session %s started (session %" PRIu64 ")",
1878                         session->name, session->id);
1879
1880         rcu_read_lock();
1881
1882         /*
1883          * Note that this loop will end after one iteration given that there is
1884          * only one kernel consumer.
1885          */
1886         cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
1887                         socket, node.node) {
1888                 struct ltt_kernel_channel *chan;
1889
1890                 /* For each channel, ask the consumer to rotate it. */
1891                 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
1892                         DBG("Rotate kernel channel %" PRIu64 ", session %s",
1893                                         chan->key, session->name);
1894                         ret = consumer_rotate_channel(socket, chan->key,
1895                                         ksess->uid, ksess->gid, ksess->consumer,
1896                                         /* is_metadata_channel */ false);
1897                         if (ret < 0) {
1898                                 status = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
1899                                 goto error;
1900                         }
1901                 }
1902
1903                 /*
1904                  * Rotate the metadata channel.
1905                  */
1906                 ret = consumer_rotate_channel(socket, ksess->metadata->key,
1907                                 ksess->uid, ksess->gid, ksess->consumer,
1908                                 /* is_metadata_channel */ true);
1909                 if (ret < 0) {
1910                         status = LTTNG_ERR_ROTATION_FAIL_CONSUMER;
1911                         goto error;
1912                 }
1913         }
1914
1915 error:
1916         rcu_read_unlock();
1917         return status;
1918 }
1919
1920 enum lttng_error_code kernel_create_channel_subdirectories(
1921                 const struct ltt_kernel_session *ksess)
1922 {
1923         enum lttng_error_code ret = LTTNG_OK;
1924         enum lttng_trace_chunk_status chunk_status;
1925
1926         rcu_read_lock();
1927         assert(ksess->current_trace_chunk);
1928
1929         /*
1930          * Create the index subdirectory which will take care
1931          * of implicitly creating the channel's path.
1932          */
1933         chunk_status = lttng_trace_chunk_create_subdirectory(
1934                         ksess->current_trace_chunk,
1935                         DEFAULT_KERNEL_TRACE_DIR "/" DEFAULT_INDEX_DIR);
1936         if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
1937                 ret = LTTNG_ERR_CREATE_DIR_FAIL;
1938                 goto error;
1939         }
1940 error:
1941         rcu_read_unlock();
1942         return ret;
1943 }
1944
1945 /*
1946  * Setup necessary data for kernel tracer action.
1947  */
1948 LTTNG_HIDDEN
1949 int init_kernel_tracer(void)
1950 {
1951         int ret;
1952         bool is_root = !getuid();
1953
1954         /* Modprobe lttng kernel modules */
1955         ret = modprobe_lttng_control();
1956         if (ret < 0) {
1957                 goto error;
1958         }
1959
1960         /* Open debugfs lttng */
1961         kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
1962         if (kernel_tracer_fd < 0) {
1963                 DBG("Failed to open %s", module_proc_lttng);
1964                 goto error_open;
1965         }
1966
1967         /* Validate kernel version */
1968         ret = kernel_validate_version(&kernel_tracer_version,
1969                         &kernel_tracer_abi_version);
1970         if (ret < 0) {
1971                 goto error_version;
1972         }
1973
1974         ret = modprobe_lttng_data();
1975         if (ret < 0) {
1976                 goto error_modules;
1977         }
1978
1979         ret = kernel_supports_ring_buffer_snapshot_sample_positions();
1980         if (ret < 0) {
1981                 goto error_modules;
1982         }
1983         if (ret < 1) {
1984                 WARN("Kernel tracer does not support buffer monitoring. "
1985                         "The monitoring timer of channels in the kernel domain "
1986                         "will be set to 0 (disabled).");
1987         }
1988
1989         ret = kernel_supports_event_notifiers();
1990         if (ret < 0) {
1991                 ERR("Failed to check for kernel tracer event notifier support");
1992                 goto error_modules;
1993         }
1994         ret = kernel_create_event_notifier_group(&kernel_tracer_event_notifier_group_fd);
1995         if (ret < 0) {
1996                 /* This is not fatal. */
1997                 WARN("Failed to create kernel event notifier group");
1998                 kernel_tracer_event_notifier_group_fd = -1;
1999         } else {
2000                 enum event_notifier_error_accounting_status error_accounting_status;
2001                 enum lttng_error_code error_code_ret =
2002                                 kernel_create_event_notifier_group_notification_fd(
2003                                                 &kernel_tracer_event_notifier_group_notification_fd);
2004
2005                 if (error_code_ret != LTTNG_OK) {
2006                         goto error_modules;
2007                 }
2008
2009                 error_accounting_status = event_notifier_error_accounting_register_kernel(
2010                                 kernel_tracer_event_notifier_group_fd);
2011                 if (error_accounting_status != EVENT_NOTIFIER_ERROR_ACCOUNTING_STATUS_OK) {
2012                         ERR("Error initializing event notifier error accounting for kernel tracer.");
2013                         error_code_ret = LTTNG_ERR_EVENT_NOTIFIER_ERROR_ACCOUNTING;
2014                         goto error_modules;
2015                 }
2016
2017                 kernel_token_to_event_notifier_rule_ht = cds_lfht_new(
2018                                 DEFAULT_HT_SIZE, 1, 0,
2019                                 CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING,
2020                                 NULL);
2021                 if (!kernel_token_to_event_notifier_rule_ht) {
2022                         goto error_token_ht;
2023                 }
2024         }
2025
2026         DBG("Kernel tracer initialized: kernel tracer fd = %d, event notifier group fd = %d, event notifier group notification fd = %d",
2027                         kernel_tracer_fd, kernel_tracer_event_notifier_group_fd,
2028                         kernel_tracer_event_notifier_group_notification_fd);
2029
2030         ret = syscall_init_table(kernel_tracer_fd);
2031         if (ret < 0) {
2032                 ERR("Unable to populate syscall table. Syscall tracing won't "
2033                         "work for this session daemon.");
2034         }
2035
2036         return 0;
2037
2038 error_version:
2039         modprobe_remove_lttng_control();
2040         ret = close(kernel_tracer_fd);
2041         if (ret) {
2042                 PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2043                                 kernel_tracer_fd);
2044         }
2045         kernel_tracer_fd = -1;
2046         return LTTNG_ERR_KERN_VERSION;
2047
2048
2049 error_token_ht:
2050         ret = close(kernel_tracer_event_notifier_group_notification_fd);
2051         if (ret) {
2052                 PERROR("Failed to close kernel tracer event notifier group notification file descriptor: fd = %d",
2053                                 kernel_tracer_event_notifier_group_notification_fd);
2054         }
2055
2056 error_modules:
2057         ret = close(kernel_tracer_event_notifier_group_fd);
2058         if (ret) {
2059                 PERROR("Failed to close kernel tracer event notifier group file descriptor: fd = %d",
2060                                 kernel_tracer_event_notifier_group_fd);
2061         }
2062
2063         ret = close(kernel_tracer_fd);
2064         if (ret) {
2065                 PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2066                                 kernel_tracer_fd);
2067         }
2068
2069 error_open:
2070         modprobe_remove_lttng_control();
2071
2072 error:
2073         WARN("No kernel tracer available");
2074         kernel_tracer_fd = -1;
2075         if (!is_root) {
2076                 return LTTNG_ERR_NEED_ROOT_SESSIOND;
2077         } else {
2078                 return LTTNG_ERR_KERN_NA;
2079         }
2080 }
2081
2082 LTTNG_HIDDEN
2083 void cleanup_kernel_tracer(void)
2084 {
2085         DBG2("Closing kernel event notifier group notification file descriptor");
2086         if (kernel_tracer_event_notifier_group_notification_fd >= 0) {
2087                 int ret = notification_thread_command_remove_tracer_event_source(
2088                                 notification_thread_handle,
2089                                 kernel_tracer_event_notifier_group_notification_fd);
2090                 if (ret != LTTNG_OK) {
2091                         ERR("Failed to remove kernel event notifier notification from notification thread");
2092                 }
2093
2094                 ret = close(kernel_tracer_event_notifier_group_notification_fd);
2095                 if (ret) {
2096                         PERROR("Failed to close kernel event notifier group notification file descriptor: fd = %d",
2097                                         kernel_tracer_event_notifier_group_notification_fd);
2098                 }
2099
2100                 kernel_tracer_event_notifier_group_notification_fd = -1;
2101         }
2102
2103         if (kernel_token_to_event_notifier_rule_ht) {
2104                 const int ret = cds_lfht_destroy(
2105                                 kernel_token_to_event_notifier_rule_ht, NULL);
2106                 assert(ret == 0);
2107         }
2108
2109         DBG2("Closing kernel event notifier group file descriptor");
2110         if (kernel_tracer_event_notifier_group_fd >= 0) {
2111                 const int ret = close(kernel_tracer_event_notifier_group_fd);
2112
2113                 if (ret) {
2114                         PERROR("Failed to close kernel event notifier group file descriptor: fd = %d",
2115                                         kernel_tracer_event_notifier_group_fd);
2116                 }
2117
2118                 kernel_tracer_event_notifier_group_fd = -1;
2119         }
2120
2121         DBG2("Closing kernel fd");
2122         if (kernel_tracer_fd >= 0) {
2123                 const int ret = close(kernel_tracer_fd);
2124
2125                 if (ret) {
2126                         PERROR("Failed to close kernel tracer file descriptor: fd = %d",
2127                                         kernel_tracer_fd);
2128                 }
2129
2130                 kernel_tracer_fd = -1;
2131         }
2132
2133         free(syscall_table);
2134 }
2135
2136 LTTNG_HIDDEN
2137 bool kernel_tracer_is_initialized(void)
2138 {
2139         return kernel_tracer_fd >= 0;
2140 }
2141 static
2142 enum lttng_error_code  kernel_clear_session_channels(struct ltt_session *session)
2143 {
2144         int ret;
2145         enum lttng_error_code status = LTTNG_OK;
2146         struct consumer_socket *socket;
2147         struct lttng_ht_iter iter;
2148         struct ltt_kernel_session *ksess = session->kernel_session;
2149
2150         assert(ksess);
2151         assert(ksess->consumer);
2152
2153         rcu_read_lock();
2154
2155         if (ksess->active) {
2156                 ERR("Expecting inactive session %s (%" PRIu64 ")", session->name, session->id);
2157                 status = LTTNG_ERR_FATAL;
2158                 goto end;
2159         }
2160
2161         /*
2162          * Note that this loop will end after one iteration given that there is
2163          * only one kernel consumer.
2164          */
2165         cds_lfht_for_each_entry(ksess->consumer->socks->ht, &iter.iter,
2166                         socket, node.node) {
2167                 struct ltt_kernel_channel *chan;
2168
2169                 /* For each channel, ask the consumer to clear it. */
2170                 cds_list_for_each_entry(chan, &ksess->channel_list.head, list) {
2171                         DBG("Clear kernel channel %" PRIu64 ", session %s",
2172                                         chan->key, session->name);
2173                         ret = consumer_clear_channel(socket, chan->key);
2174                         if (ret < 0) {
2175                                 goto error;
2176                         }
2177                 }
2178
2179                 if (!ksess->metadata) {
2180                         /*
2181                          * Nothing to do for the metadata.
2182                          * This is a snapshot session.
2183                          * The metadata is genererated on the fly.
2184                          */
2185                         continue;
2186                 }
2187
2188                 /*
2189                  * Clear the metadata channel.
2190                  * Metadata channel is not cleared per se but we still need to
2191                  * perform a rotation operation on it behind the scene.
2192                  */
2193                 ret = consumer_clear_channel(socket, ksess->metadata->key);
2194                 if (ret < 0) {
2195                         goto error;
2196                 }
2197         }
2198
2199
2200         goto end;
2201 error:
2202         switch (-ret) {
2203         case LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED:
2204               status = LTTNG_ERR_CLEAR_RELAY_DISALLOWED;
2205               break;
2206         default:
2207               status = LTTNG_ERR_CLEAR_FAIL_CONSUMER;
2208               break;
2209         }
2210 end:
2211         rcu_read_unlock();
2212         return status;
2213 }
2214
2215 static
2216 enum lttng_error_code kernel_map_clear_all(struct ltt_kernel_map *map)
2217 {
2218         enum lttng_error_code status;
2219         uint64_t descr_count, i;
2220         int ret;
2221
2222         assert(map);
2223
2224         ret = kernctl_counter_map_descriptor_count(map->fd, &descr_count);
2225         if (ret) {
2226                 ERR("Error getting map descriptor count");
2227                 status = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2228                 goto end;
2229         }
2230
2231         for(i = 0; i < descr_count; i++) {
2232                 struct lttng_kernel_counter_map_descriptor descriptor = {0};
2233                 struct lttng_kernel_counter_clear counter_clear = {0};
2234
2235                 descriptor.descriptor_index = i;
2236
2237                 ret = kernctl_counter_map_descriptor(map->fd, &descriptor);
2238                 if (ret) {
2239                         ERR("Error getting map descriptor %"PRIu64, i);
2240                         status = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2241                         goto end;
2242                 }
2243
2244                 counter_clear.index.number_dimensions = 1;
2245                 counter_clear.index.dimension_indexes[0] = descriptor.array_index;
2246
2247                 ret = kernctl_counter_clear(map->fd, &counter_clear);
2248                 if (ret) {
2249                         ERR("Error clearing value of map descriptor %"PRIu64, i);
2250                         status = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2251                         goto end;
2252                 }
2253         }
2254
2255         status = LTTNG_OK;
2256 end:
2257         return status;
2258 }
2259
2260 static
2261 enum lttng_error_code kernel_clear_session_maps(struct ltt_session *session)
2262 {
2263         enum lttng_error_code status = LTTNG_OK;
2264         struct ltt_kernel_map *map;
2265         struct ltt_kernel_session *ksess = session->kernel_session;
2266
2267         assert(ksess);
2268
2269         cds_list_for_each_entry(map, &ksess->map_list.head, list) {
2270                 DBG("Clear kernel map %" PRIu64 ", session %s",
2271                                 map->key, session->name);
2272                 status = kernel_map_clear_all(map);
2273                 if (status != LTTNG_OK) {
2274                         ERR("Clearing all values of map");
2275                         goto end;
2276                 }
2277         }
2278
2279 end:
2280         return status;
2281 }
2282
2283 /*
2284  *  Clear a kernel session.
2285  *
2286  * Return LTTNG_OK on success or else an LTTng error code.
2287  */
2288 enum lttng_error_code kernel_clear_session(struct ltt_session *session)
2289 {
2290         enum lttng_error_code status = LTTNG_OK;
2291         struct ltt_kernel_session *ksess = session->kernel_session;
2292
2293         assert(ksess);
2294         assert(ksess->consumer);
2295
2296         DBG("Clear kernel session %s (session %" PRIu64 ")",
2297                         session->name, session->id);
2298
2299         rcu_read_lock();
2300
2301         if (ksess->active) {
2302                 ERR("Expecting inactive session %s (%" PRIu64 ")", session->name, session->id);
2303                 status = LTTNG_ERR_FATAL;
2304                 goto end;
2305         }
2306
2307         status = kernel_clear_session_channels(session);
2308         if (status != LTTNG_OK) {
2309                 goto end;
2310         }
2311         /*
2312          * Iterate and clear all kernel maps.
2313          */
2314         status = kernel_clear_session_maps(session);
2315         if (status != LTTNG_OK) {
2316                 goto end;
2317         }
2318
2319
2320 end:
2321         rcu_read_unlock();
2322         return status;
2323 }
2324
2325 enum lttng_error_code kernel_create_event_notifier_group_notification_fd(
2326                 int *event_notifier_group_notification_fd)
2327 {
2328         int local_fd = -1, ret;
2329         enum lttng_error_code error_code_ret;
2330
2331         assert(event_notifier_group_notification_fd);
2332
2333         ret = kernctl_create_event_notifier_group_notification_fd(
2334                         kernel_tracer_event_notifier_group_fd);
2335         if (ret < 0) {
2336                 PERROR("Failed to create kernel event notifier group notification file descriptor");
2337                 error_code_ret = LTTNG_ERR_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD;
2338                 goto error;
2339         }
2340
2341         local_fd = ret;
2342
2343         /* Prevent fd duplication after execlp(). */
2344         ret = fcntl(local_fd, F_SETFD, FD_CLOEXEC);
2345         if (ret < 0) {
2346                 PERROR("Failed to set FD_CLOEXEC on kernel event notifier group notification file descriptor: fd = %d",
2347                                 local_fd);
2348                 error_code_ret = LTTNG_ERR_EVENT_NOTIFIER_GROUP_NOTIFICATION_FD;
2349                 goto error;
2350         }
2351
2352         DBG("Created kernel notifier group notification file descriptor: fd = %d",
2353                         local_fd);
2354         error_code_ret = LTTNG_OK;
2355         *event_notifier_group_notification_fd = local_fd;
2356         local_fd = -1;
2357
2358 error:
2359         if (local_fd >= 0) {
2360                 ret = close(local_fd);
2361                 if (ret) {
2362                         PERROR("Failed to close kernel event notifier group notification file descriptor: fd = %d",
2363                                         local_fd);
2364                 }
2365         }
2366
2367         return error_code_ret;
2368 }
2369
2370 enum lttng_error_code kernel_destroy_event_notifier_group_notification_fd(
2371                 int event_notifier_group_notification_fd)
2372 {
2373         enum lttng_error_code ret_code = LTTNG_OK;
2374
2375         DBG("Closing event notifier group notification file descriptor: fd = %d",
2376                         event_notifier_group_notification_fd);
2377         if (event_notifier_group_notification_fd >= 0) {
2378                 const int ret = close(event_notifier_group_notification_fd);
2379                 if (ret) {
2380                         PERROR("Failed to close event notifier group notification file descriptor: fd = %d",
2381                                         event_notifier_group_notification_fd);
2382                 }
2383         }
2384
2385         return ret_code;
2386 }
2387
2388 static
2389 unsigned long hash_trigger(const struct lttng_trigger *trigger)
2390 {
2391         const struct lttng_condition *condition =
2392                         lttng_trigger_get_const_condition(trigger);
2393
2394         return lttng_condition_hash(condition);
2395 }
2396
2397 static
2398 int match_trigger(struct cds_lfht_node *node, const void *key)
2399 {
2400         const struct ltt_kernel_event_notifier_rule *event_notifier_rule;
2401         const struct lttng_trigger *trigger = key;
2402
2403         event_notifier_rule = caa_container_of(node,
2404                         const struct ltt_kernel_event_notifier_rule, ht_node);
2405
2406         return lttng_trigger_is_equal(trigger, event_notifier_rule->trigger);
2407 }
2408
2409 static
2410 int add_key_token(struct lttng_kernel_key_token *kernel_key_token,
2411                 const struct lttng_map_key_token *key_token)
2412 {
2413         int ret;
2414         switch (key_token->type) {
2415         case LTTNG_MAP_KEY_TOKEN_TYPE_STRING:
2416         {
2417                 const struct lttng_map_key_token_string *str_token;
2418                 str_token = (typeof(str_token)) key_token;
2419
2420                 kernel_key_token->type = LTTNG_KERNEL_KEY_TOKEN_STRING;
2421                 kernel_key_token->arg.string_ptr = (uint64_t) str_token->string;
2422
2423                 break;
2424         }
2425         case LTTNG_MAP_KEY_TOKEN_TYPE_VARIABLE:
2426         {
2427                 const struct lttng_map_key_token_variable *var_token;
2428                 var_token = (typeof(var_token)) key_token;
2429                 switch (var_token->type) {
2430                 case LTTNG_MAP_KEY_TOKEN_VARIABLE_TYPE_EVENT_NAME:
2431                         kernel_key_token->type = LTTNG_KERNEL_KEY_TOKEN_EVENT_NAME;
2432                         break;
2433                 case LTTNG_MAP_KEY_TOKEN_VARIABLE_TYPE_PROVIDER_NAME:
2434                         /* The kernel events don't have providers */
2435                         ERR("Provider variable token type not supported for kernel tracer");
2436                         ret = -1;
2437                         goto end;
2438                 default:
2439                         abort();
2440                 }
2441
2442                 break;
2443         }
2444         default:
2445                 abort();
2446         }
2447         ret = 0;
2448 end:
2449         return ret;
2450 }
2451
2452 enum lttng_error_code kernel_create_event_counter(
2453                 struct ltt_kernel_map *kmap,
2454                 const struct lttng_credentials *creds,
2455                 uint64_t action_tracer_token,
2456                 const struct lttng_event_rule *event_rule,
2457                 struct lttng_map_key *key)
2458 {
2459         int err, fd, ret = 0;
2460         unsigned int i, key_token_count;
2461         enum lttng_error_code error_code_ret;
2462         enum lttng_map_key_status status;
2463         struct ltt_kernel_event_counter *event_counter;
2464         struct lttng_kernel_counter_event k_counter_event = {};
2465
2466
2467         event_counter = zmalloc(sizeof(*event_counter));
2468         if (!event_counter) {
2469                 error_code_ret = LTTNG_ERR_NOMEM;
2470                 goto error;
2471         }
2472
2473         trace_kernel_init_event_counter_from_event_rule(event_rule,
2474                         &k_counter_event);
2475         event_counter->fd = -1;
2476         event_counter->enabled = 1;
2477         event_counter->action_tracer_token = action_tracer_token;
2478         event_counter->filter = lttng_event_rule_get_filter_bytecode(event_rule);
2479
2480         k_counter_event.event.token = action_tracer_token;
2481
2482         /* Set the key pattern for this event counter. */
2483         k_counter_event.key.nr_dimensions = 1;
2484
2485         status = lttng_map_key_get_token_count(key, &key_token_count);
2486         if (status != LTTNG_MAP_KEY_STATUS_OK) {
2487                 error_code_ret = LTTNG_ERR_UNK;
2488                 goto error;
2489         }
2490
2491         assert(key_token_count > 0);
2492
2493         k_counter_event.key.key_dimensions[0].nr_key_tokens = key_token_count;
2494
2495         for (i = 0; i < key_token_count; i++) {
2496                 const struct lttng_map_key_token *token =
2497                                 lttng_map_key_get_token_at_index(key, i);
2498
2499                 ret = add_key_token(&k_counter_event.key.key_dimensions[0].key_tokens[i],
2500                                 token);
2501                 if (ret) {
2502                         ERR("Error appending map key token");
2503                         error_code_ret = LTTNG_ERR_INVALID;
2504                         goto error;
2505                 }
2506         }
2507
2508         fd = kernctl_create_counter_event(kmap->fd, &k_counter_event);
2509         if (fd < 0) {
2510                 switch (-fd) {
2511                 case EEXIST:
2512                         error_code_ret = LTTNG_ERR_KERN_EVENT_EXIST;
2513                         break;
2514                 case ENOSYS:
2515                         WARN("Event counter type not implemented");
2516                         error_code_ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
2517                         break;
2518                 case ENOENT:
2519                         WARN("Event counter %s not found!", k_counter_event.event.name);
2520                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2521                         break;
2522                 default:
2523                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2524                         PERROR("create event counter ioctl");
2525                 }
2526         }
2527
2528         event_counter->fd = fd;
2529         event_counter->enabled = true;
2530
2531         /* Prevent fd duplication after execlp() */
2532         err = fcntl(fd, F_SETFD, FD_CLOEXEC);
2533         if (err < 0) {
2534                 PERROR("fcntl session fd");
2535         }
2536
2537         if (event_counter->filter) {
2538                 err = kernctl_filter(event_counter->fd, event_counter->filter);
2539                 if (err < 0) {
2540                         switch (-err) {
2541                         case ENOMEM:
2542                                 error_code_ret = LTTNG_ERR_FILTER_NOMEM;
2543                                 break;
2544                         default:
2545                                 error_code_ret = LTTNG_ERR_FILTER_INVAL;
2546                                 break;
2547                         }
2548                         goto filter_error;
2549                 }
2550         }
2551         if (lttng_event_rule_get_type(event_rule) ==
2552                         LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE) {
2553                 ret = userspace_probe_event_rule_add_callsites(
2554                                 event_rule, creds, event_counter->fd);
2555                 if (ret) {
2556                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2557                         goto add_callsite_error;
2558                 }
2559         }
2560
2561         err = kernctl_enable(event_counter->fd);
2562         if (err < 0) {
2563                 switch (-err) {
2564                 case EEXIST:
2565                         error_code_ret = LTTNG_ERR_KERN_EVENT_EXIST;
2566                         break;
2567                 default:
2568                         PERROR("enable kernel counter event");
2569                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2570                         break;
2571                 }
2572                 goto enable_error;
2573         }
2574
2575         /* Add event to event list */
2576         rcu_read_lock();
2577         lttng_ht_node_init_u64(&event_counter->ht_node,
2578                         event_counter->action_tracer_token);
2579         lttng_ht_add_unique_u64(kmap->event_counters_ht,
2580                         &event_counter->ht_node);
2581         rcu_read_unlock();
2582         kmap->event_count++;
2583
2584         DBG("Kernel event counter %s created (fd: %d)",
2585                         event_counter->event->name,
2586                         event_counter->fd);
2587         error_code_ret = LTTNG_OK;
2588
2589 add_callsite_error:
2590 filter_error:
2591 enable_error:
2592 error:
2593         return error_code_ret;
2594 }
2595
2596 static enum lttng_error_code kernel_create_event_notifier_rule(
2597                 struct lttng_trigger *trigger,
2598                 const struct lttng_credentials *creds, uint64_t token)
2599 {
2600         int err, fd, ret = 0;
2601         enum lttng_error_code error_code_ret;
2602         enum lttng_condition_status condition_status;
2603         enum lttng_condition_type condition_type;
2604         enum lttng_event_rule_type event_rule_type;
2605         struct ltt_kernel_event_notifier_rule *event_notifier_rule;
2606         struct lttng_kernel_event_notifier kernel_event_notifier = {};
2607         unsigned int capture_bytecode_count = 0, i;
2608         const struct lttng_condition *condition = NULL;
2609         const struct lttng_event_rule *event_rule = NULL;
2610         enum lttng_condition_status cond_status;
2611
2612         assert(trigger);
2613
2614         condition = lttng_trigger_get_const_condition(trigger);
2615         assert(condition);
2616
2617         condition_type = lttng_condition_get_type(condition);
2618         assert(condition_type == LTTNG_CONDITION_TYPE_ON_EVENT);
2619
2620         /* Does not acquire a reference. */
2621         condition_status = lttng_condition_on_event_get_rule(
2622                         condition, &event_rule);
2623         assert(condition_status == LTTNG_CONDITION_STATUS_OK);
2624         assert(event_rule);
2625
2626         event_rule_type = lttng_event_rule_get_type(event_rule);
2627         assert(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN);
2628
2629         error_code_ret = trace_kernel_create_event_notifier_rule(trigger, token,
2630                         lttng_condition_on_event_get_error_counter_index(condition),
2631                         &event_notifier_rule);
2632         if (error_code_ret != LTTNG_OK) {
2633                 goto error;
2634         }
2635
2636         error_code_ret = trace_kernel_init_event_notifier_from_event_rule(
2637                         event_rule, &kernel_event_notifier);
2638         if (error_code_ret != LTTNG_OK) {
2639                 goto free_event;
2640         }
2641
2642         kernel_event_notifier.event.token = event_notifier_rule->token;
2643         kernel_event_notifier.error_counter_idx =
2644                         lttng_condition_on_event_get_error_counter_index(condition);
2645
2646         fd = kernctl_create_event_notifier(
2647                         kernel_tracer_event_notifier_group_fd,
2648                         &kernel_event_notifier);
2649         if (fd < 0) {
2650                 switch (-fd) {
2651                 case EEXIST:
2652                         error_code_ret = LTTNG_ERR_KERN_EVENT_EXIST;
2653                         break;
2654                 case ENOSYS:
2655                         WARN("Failed to create kernel event notifier: not notifier type not implemented");
2656                         error_code_ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
2657                         break;
2658                 case ENOENT:
2659                         WARN("Failed to create kernel event notifier: not found: name = '%s'",
2660                                         kernel_event_notifier.event.name);
2661                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2662                         break;
2663                 default:
2664                         PERROR("Failed to create kernel event notifier: error code = %d, name = '%s'",
2665                                         fd, kernel_event_notifier.event.name);
2666                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2667                 }
2668                 goto free_event;
2669         }
2670
2671         event_notifier_rule->fd = fd;
2672         /* Prevent fd duplication after execlp(). */
2673         err = fcntl(event_notifier_rule->fd, F_SETFD, FD_CLOEXEC);
2674         if (err < 0) {
2675                 PERROR("Failed to set FD_CLOEXEC on kernel event notifier file descriptor: fd = %d",
2676                                 fd);
2677                 error_code_ret = LTTNG_ERR_FATAL;
2678                 goto set_cloexec_error;
2679         }
2680
2681         if (event_notifier_rule->filter) {
2682                 err = kernctl_filter(event_notifier_rule->fd, event_notifier_rule->filter);
2683                 if (err < 0) {
2684                         switch (-err) {
2685                         case ENOMEM:
2686                                 error_code_ret = LTTNG_ERR_FILTER_NOMEM;
2687                                 break;
2688                         default:
2689                                 error_code_ret = LTTNG_ERR_FILTER_INVAL;
2690                                 break;
2691                         }
2692                         goto filter_error;
2693                 }
2694         }
2695
2696         if (lttng_event_rule_get_type(event_rule) ==
2697                         LTTNG_EVENT_RULE_TYPE_USERSPACE_PROBE) {
2698                 ret = userspace_probe_event_rule_add_callsites(
2699                                 event_rule, creds, event_notifier_rule->fd);
2700                 if (ret) {
2701                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2702                         goto add_callsite_error;
2703                 }
2704         }
2705
2706         /* Set the capture bytecode if any */
2707         cond_status = lttng_condition_on_event_get_capture_descriptor_count(condition, &capture_bytecode_count);
2708         assert(cond_status == LTTNG_CONDITION_STATUS_OK);
2709         for (i = 0; i < capture_bytecode_count; i++) {
2710                 const struct lttng_bytecode *capture_bytecode =
2711                                 lttng_condition_on_event_get_capture_bytecode_at_index(
2712                                                 condition, i);
2713                 if (capture_bytecode == NULL) {
2714                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2715                         goto error;
2716                 }
2717
2718                 ret = kernctl_capture(event_notifier_rule->fd, capture_bytecode);
2719                 if (ret < 0) {
2720                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2721                         goto error;
2722                 }
2723         }
2724
2725         err = kernctl_enable(event_notifier_rule->fd);
2726         if (err < 0) {
2727                 switch (-err) {
2728                 case EEXIST:
2729                         error_code_ret = LTTNG_ERR_KERN_EVENT_EXIST;
2730                         break;
2731                 default:
2732                         PERROR("enable kernel event notifier");
2733                         error_code_ret = LTTNG_ERR_KERN_ENABLE_FAIL;
2734                         break;
2735                 }
2736                 goto enable_error;
2737         }
2738
2739         /* Add trigger to kernel token mapping in the hash table. */
2740         rcu_read_lock();
2741         cds_lfht_add(kernel_token_to_event_notifier_rule_ht, hash_trigger(trigger),
2742                         &event_notifier_rule->ht_node);
2743         rcu_read_unlock();
2744
2745         DBG("Created kernel event notifier: name = '%s', fd = %d",
2746                         kernel_event_notifier.event.name,
2747                         event_notifier_rule->fd);
2748
2749         return LTTNG_OK;
2750
2751 add_callsite_error:
2752 enable_error:
2753 set_cloexec_error:
2754 filter_error:
2755         {
2756                 const int close_ret = close(event_notifier_rule->fd);
2757
2758                 if (close_ret) {
2759                         PERROR("Failed to close kernel event notifier file descriptor: fd = %d",
2760                                         event_notifier_rule->fd);
2761                 }
2762         }
2763 free_event:
2764         free(event_notifier_rule);
2765 error:
2766         return error_code_ret;
2767 }
2768
2769 enum lttng_error_code kernel_register_event_notifier(
2770                 struct lttng_trigger *trigger,
2771                 const struct lttng_credentials *cmd_creds)
2772 {
2773         enum lttng_error_code ret;
2774         enum lttng_condition_status status;
2775         enum lttng_domain_type domain_type;
2776         const struct lttng_event_rule *event_rule;
2777         const struct lttng_condition *const condition =
2778                         lttng_trigger_get_const_condition(trigger);
2779         const uint64_t token = lttng_trigger_get_tracer_token(trigger);
2780
2781         assert(condition);
2782
2783         /* Does not acquire a reference to the event rule. */
2784         status = lttng_condition_on_event_get_rule(
2785                         condition, &event_rule);
2786         assert(status == LTTNG_CONDITION_STATUS_OK);
2787
2788         domain_type = lttng_event_rule_get_domain_type(event_rule);
2789         assert(domain_type == LTTNG_DOMAIN_KERNEL);
2790
2791         ret = kernel_create_event_notifier_rule(trigger, cmd_creds, token);
2792         if (ret != LTTNG_OK) {
2793                 ERR("Failed to create kernel event notifier rule");
2794         }
2795
2796         return ret;
2797 }
2798
2799 enum lttng_error_code kernel_unregister_event_notifier(
2800                 const struct lttng_trigger *trigger)
2801 {
2802         struct ltt_kernel_event_notifier_rule *token_event_rule_element;
2803         struct cds_lfht_node *node;
2804         struct cds_lfht_iter iter;
2805         enum lttng_error_code error_code_ret;
2806         int ret;
2807
2808         rcu_read_lock();
2809
2810         cds_lfht_lookup(kernel_token_to_event_notifier_rule_ht,
2811                         hash_trigger(trigger), match_trigger, trigger, &iter);
2812
2813         node = cds_lfht_iter_get_node(&iter);
2814         if (!node) {
2815                 error_code_ret = LTTNG_ERR_TRIGGER_NOT_FOUND;
2816                 goto error;
2817         }
2818
2819         token_event_rule_element = caa_container_of(node,
2820                         struct ltt_kernel_event_notifier_rule, ht_node);
2821
2822         ret = kernel_disable_event_notifier_rule(token_event_rule_element);
2823         if (ret) {
2824                 error_code_ret = LTTNG_ERR_FATAL;
2825                 goto error;
2826         }
2827
2828         trace_kernel_destroy_event_notifier_rule(token_event_rule_element);
2829         error_code_ret = LTTNG_OK;
2830
2831 error:
2832         rcu_read_unlock();
2833
2834         return error_code_ret;
2835 }
2836
2837 struct key_ht_entry {
2838         char *key;
2839         struct lttng_ht_node_str node;
2840 };
2841
2842 enum lttng_error_code kernel_list_map_values(const struct ltt_kernel_map *map,
2843                 const struct lttng_map_query *query,
2844                 struct lttng_map_content **map_content)
2845 {
2846         enum lttng_map_status map_status;
2847         enum lttng_error_code ret_code;
2848         const char *map_name = NULL;
2849         uint64_t descr_count, descr_idx, cpu_idx;
2850         struct lttng_map_content *local_map_content;
2851         struct lttng_ht *key_ht;
2852         struct lttng_ht *values = NULL;
2853         struct lttng_ht_node_str *node;
2854         struct key_ht_entry *ht_entry;
2855         struct lttng_ht_iter iter;
2856         enum lttng_map_query_status map_query_status;
2857         const char *key_filter;
2858         bool sum_cpus = lttng_map_query_get_config_sum_by_cpu(query);
2859         enum lttng_map_query_config_cpu config_cpu;
2860         int ret;
2861         int selected_cpu;
2862
2863
2864         local_map_content = lttng_map_content_create(LTTNG_BUFFER_GLOBAL);
2865         if (!local_map_content) {
2866                 ERR("Error creating map content");
2867                 ret_code = LTTNG_ERR_NOMEM;
2868                 goto end;
2869         }
2870
2871         map_query_status = lttng_map_query_get_key_filter(query, &key_filter);
2872         if (map_query_status == LTTNG_MAP_QUERY_STATUS_NONE) {
2873                 key_filter = NULL;
2874         } else if (map_query_status != LTTNG_MAP_QUERY_STATUS_OK) {
2875                 ret_code = LTTNG_ERR_INVALID;
2876                 goto end;
2877         }
2878
2879         config_cpu = lttng_map_query_get_config_cpu(query);
2880         if (config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) {
2881                 unsigned int count;
2882                 map_query_status = lttng_map_query_get_cpu_count(query, &count);
2883                 assert(map_query_status == LTTNG_MAP_QUERY_STATUS_OK);
2884                 assert(count == 1);
2885
2886                 map_query_status = lttng_map_query_get_cpu_at_index(query, 0,
2887                                 &selected_cpu);
2888                 assert(map_query_status == LTTNG_MAP_QUERY_STATUS_OK);
2889         }
2890
2891         map_status = lttng_map_get_name(map->map, &map_name);
2892         assert(map_status == LTTNG_MAP_STATUS_OK);
2893
2894         DBG("Listing kernel map values: map-name = '%s'", map_name);
2895
2896         ret = kernctl_counter_map_descriptor_count(map->fd, &descr_count);
2897         if (ret) {
2898                 ERR("Error getting map descriptor count");
2899                 ret_code = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2900                 goto end;
2901         }
2902
2903         /*
2904          * The kernel tracer sends us descriptors that may be identical aside
2905          * from their user token field. This ABI was design this way to cover a
2906          * potential use case where the user wants to know what enabler might
2907          * have contributed to a specific bucket.
2908          *
2909          * We use this hashtable to de-duplicate keys.
2910          */
2911         if (sum_cpus) {
2912                 values = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
2913                 if (!values) {
2914                         ret_code = LTTNG_ERR_NOMEM;
2915                         goto end;
2916                 }
2917         }
2918
2919         DBG("Querying kernel for all map values: "
2920                         "map-name = '%s', key-value count = %"PRIu64,
2921                         map_name, descr_count);
2922         for (cpu_idx = 0; cpu_idx < utils_get_number_of_possible_cpus(); cpu_idx++) {
2923                 struct lttng_kernel_counter_read value = {0};
2924
2925                 if (config_cpu == LTTNG_MAP_QUERY_CONFIG_CPU_SUBSET) {
2926                         if (selected_cpu != cpu_idx) {
2927                                 continue;
2928                         }
2929                 }
2930
2931                 if (!sum_cpus) {
2932                         values = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
2933                         assert(values);
2934                 }
2935
2936                 key_ht = lttng_ht_new(0, LTTNG_HT_TYPE_STRING);
2937                 if (!key_ht) {
2938                         ret_code = LTTNG_ERR_NOMEM;
2939                         goto end;
2940                 }
2941
2942                 for(descr_idx = 0; descr_idx < descr_count; descr_idx++) {
2943                         struct lttng_kernel_counter_map_descriptor descriptor = {0};
2944
2945                         DBG("Querying kernel for map key-value descriptor: "
2946                                         "map-name = '%s', descriptor = %"PRIu64,
2947                                         map_name, descr_idx);
2948                         descriptor.descriptor_index = descr_idx;
2949
2950                         ret = kernctl_counter_map_descriptor(map->fd, &descriptor);
2951                         if (ret) {
2952                                 ERR("Error getting map descriptor %"PRIu64, descr_idx);
2953                                 ret_code = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2954                                 goto end;
2955                         }
2956
2957                         if (key_filter && strcmp(key_filter, descriptor.key) != 0) {
2958                                 continue;
2959                         }
2960
2961                         lttng_ht_lookup(key_ht, descriptor.key, &iter);
2962                         node = lttng_ht_iter_get_node_str(&iter);
2963                         if (node) {
2964                                 /* This key was already appended to the list. */
2965                                 continue;
2966                         }
2967
2968
2969                         value.index.number_dimensions = 1;
2970                         value.index.dimension_indexes[0] = descriptor.array_index;
2971                         value.cpu = cpu_idx;
2972
2973                         DBG("Querying kernel for map descriptor value: "
2974                                         "map-name = '%s', counter-index = %"PRIu64,
2975                                         map_name, descriptor.array_index);
2976                         ret = kernctl_counter_read_value(map->fd, &value);
2977                         if (ret) {
2978                                 ERR("Error getting value of map descriptor %"PRIu64, descr_idx);
2979                                 ret_code = LTTNG_ERR_MAP_VALUES_LIST_FAIL;
2980                                 goto end;
2981                         }
2982
2983                         map_add_or_increment_map_values(values, descriptor.key,
2984                                         value.value.value, value.value.underflow,
2985                                         value.value.overflow);
2986
2987                         ht_entry = zmalloc(sizeof(*ht_entry));
2988                         assert(ht_entry);
2989                         ht_entry->key = strdup(descriptor.key);
2990                         lttng_ht_node_init_str(&ht_entry->node, ht_entry->key);
2991                         lttng_ht_add_unique_str(key_ht, &ht_entry->node);
2992                 }
2993
2994                 if (!sum_cpus) {
2995                         ret = map_new_content_section(local_map_content,
2996                                         LTTNG_MAP_KEY_VALUE_PAIR_LIST_TYPE_KERNEL,
2997                                         sum_cpus, 0,
2998                                         cpu_idx, values);
2999                         if (ret) {
3000                                 abort();
3001                         }
3002
3003                         lttng_ht_destroy(values);
3004                 }
3005
3006                 /*
3007                  * Remove all the keys before destroying the hashtable.
3008                  */
3009                 cds_lfht_for_each_entry(key_ht->ht, &iter.iter, ht_entry, node.node) {
3010                         struct lttng_ht_iter entry_iter;
3011
3012                         entry_iter.iter.node = &ht_entry->node.node;
3013                         lttng_ht_del(key_ht, &entry_iter);
3014
3015                         free(ht_entry);
3016                 }
3017
3018                 lttng_ht_destroy(key_ht);
3019         }
3020
3021         if (sum_cpus) {
3022                 ret = map_new_content_section(local_map_content,
3023                                 LTTNG_MAP_KEY_VALUE_PAIR_LIST_TYPE_KERNEL,
3024                                 sum_cpus, 0, 0, values);
3025                 if (ret) {
3026                         abort();
3027                 }
3028                 lttng_ht_destroy(values);
3029         }
3030
3031
3032         *map_content = local_map_content;
3033         local_map_content = NULL;
3034         ret_code = LTTNG_OK;
3035
3036 end:
3037         lttng_map_content_destroy(local_map_content);
3038         return ret_code;
3039 }
3040
3041 int kernel_get_notification_fd(void)
3042 {
3043         return kernel_tracer_event_notifier_group_notification_fd;
3044 }