src/bin/lttng-sessiond/trace-kernel.cpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  *
   4  * SPDX-License-Identifier: GPL-2.0-only
   5  *
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13
  14 #include <lttng/event.h>
  15 #include <lttng/lttng-error.h>
  16 #include <lttng/kernel-probe.h>
  17 #include <lttng/userspace-probe.h>
  18 #include <lttng/userspace-probe-internal.hpp>
  19 #include <lttng/event-rule/event-rule.h>
  20 #include <lttng/event-rule/event-rule-internal.hpp>
  21 #include <lttng/event-rule/kernel-kprobe.h>
  22 #include <lttng/event-rule/kernel-kprobe-internal.hpp>
  23 #include <lttng/event-rule/kernel-syscall.h>
  24 #include <lttng/event-rule/kernel-syscall-internal.hpp>
  25 #include <lttng/event-rule/kernel-tracepoint.h>
  26 #include <lttng/event-rule/kernel-tracepoint-internal.hpp>
  27 #include <lttng/event-rule/kernel-uprobe.h>
  28 #include <lttng/event-rule/kernel-uprobe-internal.hpp>
  29 #include <common/common.hpp>
  30 #include <common/defaults.hpp>
  31 #include <common/trace-chunk.hpp>
  32 #include <common/macros.hpp>
  33
  34 #include "consumer.hpp"
  35 #include "trace-kernel.hpp"
  36 #include "lttng-sessiond.hpp"
  37 #include "notification-thread-commands.hpp"
  38
  39 /*
  40  * Find the channel name for the given kernel session.
  41  */
  42 struct ltt_kernel_channel *trace_kernel_get_channel_by_name(
  43                 const char *name, struct ltt_kernel_session *session)
  44 {
  45         struct ltt_kernel_channel *chan;
  46
  47         LTTNG_ASSERT(session);
  48         LTTNG_ASSERT(name);
  49
  50         /*
  51          * If we receive an empty string for channel name, it means the
  52          * default channel name is requested.
  53          */
  54         if (name[0] == '\0')
  55                 name = DEFAULT_CHANNEL_NAME;
  56
  57         DBG("Trying to find channel %s", name);
  58
  59         cds_list_for_each_entry(chan, &session->channel_list.head, list) {
  60                 if (strcmp(name, chan->channel->name) == 0) {
  61                         DBG("Found channel by name %s", name);
  62                         return chan;
  63                 }
  64         }
  65
  66         return NULL;
  67 }
  68
  69 /*
  70  * Find the event for the given channel.
  71  */
  72 struct ltt_kernel_event *trace_kernel_find_event(
  73                 char *name, struct ltt_kernel_channel *channel,
  74                 enum lttng_event_type type,
  75                 struct lttng_bytecode *filter)
  76 {
  77         struct ltt_kernel_event *ev;
  78         int found = 0;
  79
  80         LTTNG_ASSERT(name);
  81         LTTNG_ASSERT(channel);
  82
  83         cds_list_for_each_entry(ev, &channel->events_list.head, list) {
  84                 if (type != LTTNG_EVENT_ALL && ev->type != type) {
  85                         continue;
  86                 }
  87                 if (strcmp(name, ev->event->name)) {
  88                         continue;
  89                 }
  90                 if ((ev->filter && !filter) || (!ev->filter && filter)) {
  91                         continue;
  92                 }
  93                 if (ev->filter && filter) {
  94                         if (ev->filter->len != filter->len ||
  95                                         memcmp(ev->filter->data, filter->data,
  96                                                 filter->len) != 0) {
  97                                 continue;
  98                         }
  99                 }
 100                 found = 1;
 101                 break;
 102         }
 103         if (found) {
 104                 DBG("Found event %s for channel %s", name,
 105                         channel->channel->name);
 106                 return ev;
 107         } else {
 108                 return NULL;
 109         }
 110 }
 111
 112 /*
 113  * Find the event name for the given channel.
 114  */
 115 struct ltt_kernel_event *trace_kernel_get_event_by_name(
 116                 char *name, struct ltt_kernel_channel *channel,
 117                 enum lttng_event_type type)
 118 {
 119         struct ltt_kernel_event *ev;
 120         int found = 0;
 121
 122         LTTNG_ASSERT(name);
 123         LTTNG_ASSERT(channel);
 124
 125         cds_list_for_each_entry(ev, &channel->events_list.head, list) {
 126                 if (type != LTTNG_EVENT_ALL && ev->type != type) {
 127                         continue;
 128                 }
 129                 if (strcmp(name, ev->event->name)) {
 130                         continue;
 131                 }
 132                 found = 1;
 133                 break;
 134         }
 135         if (found) {
 136                 DBG("Found event %s for channel %s", name,
 137                         channel->channel->name);
 138                 return ev;
 139         } else {
 140                 return NULL;
 141         }
 142 }
 143
 144 /*
 145  * Allocate and initialize a kernel session data structure.
 146  *
 147  * Return pointer to structure or NULL.
 148  */
 149 struct ltt_kernel_session *trace_kernel_create_session(void)
 150 {
 151         struct ltt_kernel_session *lks = NULL;
 152
 153         /* Allocate a new ltt kernel session */
 154         lks = new ltt_kernel_session;
 155         if (lks == NULL) {
 156                 PERROR("create kernel session zmalloc");
 157                 goto alloc_error;
 158         }
 159
 160         lks->active = 0;
 161
 162         /* Init data structure */
 163         CDS_INIT_LIST_HEAD(&lks->channel_list.head);
 164
 165         lks->tracker_pid = process_attr_tracker_create();
 166         if (!lks->tracker_pid) {
 167                 goto error;
 168         }
 169         lks->tracker_vpid = process_attr_tracker_create();
 170         if (!lks->tracker_vpid) {
 171                 goto error;
 172         }
 173         lks->tracker_uid = process_attr_tracker_create();
 174         if (!lks->tracker_uid) {
 175                 goto error;
 176         }
 177         lks->tracker_vuid = process_attr_tracker_create();
 178         if (!lks->tracker_vuid) {
 179                 goto error;
 180         }
 181         lks->tracker_gid = process_attr_tracker_create();
 182         if (!lks->tracker_gid) {
 183                 goto error;
 184         }
 185         lks->tracker_vgid = process_attr_tracker_create();
 186         if (!lks->tracker_vgid) {
 187                 goto error;
 188         }
 189         lks->consumer = consumer_create_output(CONSUMER_DST_LOCAL);
 190         if (lks->consumer == NULL) {
 191                 goto error;
 192         }
 193
 194         return lks;
 195
 196 error:
 197         process_attr_tracker_destroy(lks->tracker_pid);
 198         process_attr_tracker_destroy(lks->tracker_vpid);
 199         process_attr_tracker_destroy(lks->tracker_uid);
 200         process_attr_tracker_destroy(lks->tracker_vuid);
 201         process_attr_tracker_destroy(lks->tracker_gid);
 202         process_attr_tracker_destroy(lks->tracker_vgid);
 203         delete (lks);
 204
 205 alloc_error:
 206         return NULL;
 207 }
 208
 209 /*
 210  * Allocate and initialize a kernel channel data structure.
 211  *
 212  * Return pointer to structure or NULL.
 213  */
 214 struct ltt_kernel_channel *trace_kernel_create_channel(
 215                 struct lttng_channel *chan)
 216 {
 217         struct ltt_kernel_channel *lkc;
 218         struct lttng_channel_extended *extended = NULL;
 219
 220         LTTNG_ASSERT(chan);
 221
 222         lkc = zmalloc<ltt_kernel_channel>();
 223         if (lkc == NULL) {
 224                 PERROR("ltt_kernel_channel zmalloc");
 225                 goto error;
 226         }
 227
 228         lkc->channel = zmalloc<lttng_channel>();
 229         if (lkc->channel == NULL) {
 230                 PERROR("lttng_channel zmalloc");
 231                 goto error;
 232         }
 233
 234         extended = zmalloc<lttng_channel_extended>();
 235         if (!extended) {
 236                 PERROR("lttng_channel_channel zmalloc");
 237                 goto error;
 238         }
 239         memcpy(lkc->channel, chan, sizeof(struct lttng_channel));
 240         memcpy(extended, chan->attr.extended.ptr, sizeof(struct lttng_channel_extended));
 241         lkc->channel->attr.extended.ptr = extended;
 242         extended = NULL;
 243
 244         /*
 245          * If we receive an empty string for channel name, it means the
 246          * default channel name is requested.
 247          */
 248         if (chan->name[0] == '\0') {
 249                 strncpy(lkc->channel->name, DEFAULT_CHANNEL_NAME,
 250                         sizeof(lkc->channel->name));
 251         }
 252         lkc->channel->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 253
 254         lkc->fd = -1;
 255         lkc->stream_count = 0;
 256         lkc->event_count = 0;
 257         lkc->enabled = 1;
 258         lkc->published_to_notification_thread = false;
 259         /* Init linked list */
 260         CDS_INIT_LIST_HEAD(&lkc->events_list.head);
 261         CDS_INIT_LIST_HEAD(&lkc->stream_list.head);
 262         CDS_INIT_LIST_HEAD(&lkc->ctx_list);
 263
 264         return lkc;
 265
 266 error:
 267         if (lkc) {
 268                 free(lkc->channel);
 269         }
 270         free(extended);
 271         free(lkc);
 272         return NULL;
 273 }
 274
 275 /*
 276  * Allocate and init a kernel context object.
 277  *
 278  * Return the allocated object or NULL on error.
 279  */
 280 struct ltt_kernel_context *trace_kernel_create_context(
 281                 struct lttng_kernel_abi_context *ctx)
 282 {
 283         struct ltt_kernel_context *kctx;
 284
 285         kctx = zmalloc<ltt_kernel_context>();
 286         if (!kctx) {
 287                 PERROR("zmalloc kernel context");
 288                 goto error;
 289         }
 290
 291         if (ctx) {
 292                 memcpy(&kctx->ctx, ctx, sizeof(kctx->ctx));
 293         }
 294 error:
 295         return kctx;
 296 }
 297
 298 /*
 299  * Allocate and init a kernel context object from an existing kernel context
 300  * object.
 301  *
 302  * Return the allocated object or NULL on error.
 303  */
 304 struct ltt_kernel_context *trace_kernel_copy_context(
 305                 struct ltt_kernel_context *kctx)
 306 {
 307         struct ltt_kernel_context *kctx_copy;
 308
 309         LTTNG_ASSERT(kctx);
 310         kctx_copy = zmalloc<ltt_kernel_context>();
 311         if (!kctx_copy) {
 312                 PERROR("zmalloc ltt_kernel_context");
 313                 goto error;
 314         }
 315
 316         memcpy(kctx_copy, kctx, sizeof(*kctx_copy));
 317         memset(&kctx_copy->list, 0, sizeof(kctx_copy->list));
 318
 319 error:
 320         return kctx_copy;
 321 }
 322
 323 /*
 324  * Allocate and initialize a kernel event. Set name and event type.
 325  * We own filter_expression, and filter.
 326  *
 327  * Return pointer to structure or NULL.
 328  */
 329 enum lttng_error_code trace_kernel_create_event(
 330                 struct lttng_event *ev, char *filter_expression,
 331                 struct lttng_bytecode *filter,
 332                 struct ltt_kernel_event **kernel_event)
 333 {
 334         enum lttng_error_code ret;
 335         struct lttng_kernel_abi_event *attr;
 336         struct ltt_kernel_event *local_kernel_event;
 337         struct lttng_userspace_probe_location *userspace_probe_location = NULL;
 338
 339         LTTNG_ASSERT(ev);
 340
 341         local_kernel_event = zmalloc<ltt_kernel_event>();
 342         attr = zmalloc<lttng_kernel_abi_event>();
 343         if (local_kernel_event == NULL || attr == NULL) {
 344                 PERROR("kernel event zmalloc");
 345                 ret = LTTNG_ERR_NOMEM;
 346                 goto error;
 347         }
 348
 349         switch (ev->type) {
 350         case LTTNG_EVENT_PROBE:
 351                 attr->instrumentation = LTTNG_KERNEL_ABI_KPROBE;
 352                 attr->u.kprobe.addr = ev->attr.probe.addr;
 353                 attr->u.kprobe.offset = ev->attr.probe.offset;
 354                 strncpy(attr->u.kprobe.symbol_name,
 355                                 ev->attr.probe.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN);
 356                 attr->u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 357                 break;
 358         case LTTNG_EVENT_USERSPACE_PROBE:
 359         {
 360                 const struct lttng_userspace_probe_location* location = NULL;
 361                 const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
 362
 363                 location = lttng_event_get_userspace_probe_location(ev);
 364                 if (!location) {
 365                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 366                         goto error;
 367                 }
 368
 369                 /*
 370                  * From this point on, the specific term 'uprobe' is used
 371                  * instead of the generic 'userspace probe' because it's the
 372                  * technology used at the moment for this instrumentation.
 373                  * LTTng currently implements userspace probes using uprobes.
 374                  * In the interactions with the kernel tracer, we use the
 375                  * uprobe term.
 376                  */
 377                 attr->instrumentation = LTTNG_KERNEL_ABI_UPROBE;
 378
 379                 lookup = lttng_userspace_probe_location_get_lookup_method(
 380                                 location);
 381                 if (!lookup) {
 382                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 383                         goto error;
 384                 }
 385
 386                 /*
 387                  * From the kernel tracer's perspective, all userspace probe
 388                  * event types are all the same: a file and an offset.
 389                  */
 390                 switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) {
 391                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
 392                         /* Get the file descriptor on the target binary. */
 393                         attr->u.uprobe.fd =
 394                                         lttng_userspace_probe_location_function_get_binary_fd(location);
 395
 396                         /*
 397                          * Save a reference to the probe location used during
 398                          * the listing of events.
 399                          */
 400                         userspace_probe_location =
 401                                         lttng_userspace_probe_location_copy(location);
 402                         break;
 403                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
 404                         /* Get the file descriptor on the target binary. */
 405                         attr->u.uprobe.fd =
 406                                         lttng_userspace_probe_location_tracepoint_get_binary_fd(location);
 407
 408                         /*
 409                          * Save a reference to the probe location used during the listing of
 410                          * events.
 411                          */
 412                         userspace_probe_location =
 413                                         lttng_userspace_probe_location_copy(location);
 414                         break;
 415                 default:
 416                         DBG("Unsupported lookup method type");
 417                         ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
 418                         goto error;
 419                 }
 420                 break;
 421         }
 422         case LTTNG_EVENT_FUNCTION:
 423                 attr->instrumentation = LTTNG_KERNEL_ABI_KRETPROBE;
 424                 attr->u.kretprobe.addr = ev->attr.probe.addr;
 425                 attr->u.kretprobe.offset = ev->attr.probe.offset;
 426                 strncpy(attr->u.kretprobe.symbol_name,
 427                                 ev->attr.probe.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN);
 428                 attr->u.kretprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 429                 break;
 430         case LTTNG_EVENT_FUNCTION_ENTRY:
 431                 attr->instrumentation = LTTNG_KERNEL_ABI_FUNCTION;
 432                 strncpy(attr->u.ftrace.symbol_name,
 433                                 ev->attr.ftrace.symbol_name, LTTNG_KERNEL_ABI_SYM_NAME_LEN);
 434                 attr->u.ftrace.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 435                 break;
 436         case LTTNG_EVENT_TRACEPOINT:
 437                 attr->instrumentation = LTTNG_KERNEL_ABI_TRACEPOINT;
 438                 break;
 439         case LTTNG_EVENT_SYSCALL:
 440                 attr->instrumentation = LTTNG_KERNEL_ABI_SYSCALL;
 441                 attr->u.syscall.abi = LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL;
 442                 attr->u.syscall.entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT;
 443                 attr->u.syscall.match = LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME;
 444                 break;
 445         case LTTNG_EVENT_ALL:
 446                 attr->instrumentation = LTTNG_KERNEL_ABI_ALL;
 447                 break;
 448         default:
 449                 ERR("Unknown kernel instrumentation type (%d)", ev->type);
 450                 ret = LTTNG_ERR_INVALID;
 451                 goto error;
 452         }
 453
 454         /* Copy event name */
 455         strncpy(attr->name, ev->name, LTTNG_KERNEL_ABI_SYM_NAME_LEN);
 456         attr->name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 457
 458         /* Setting up a kernel event */
 459         local_kernel_event->fd = -1;
 460         local_kernel_event->event = attr;
 461         local_kernel_event->enabled = 1;
 462         local_kernel_event->filter_expression = filter_expression;
 463         local_kernel_event->filter = filter;
 464         local_kernel_event->userspace_probe_location = userspace_probe_location;
 465
 466         *kernel_event = local_kernel_event;
 467
 468         return LTTNG_OK;
 469
 470 error:
 471         free(filter_expression);
 472         free(filter);
 473         free(local_kernel_event);
 474         free(attr);
 475         return ret;
 476 }
 477
 478 /*
 479  * Allocate and initialize a kernel token event rule.
 480  *
 481  * Return pointer to structure or NULL.
 482  */
 483 enum lttng_error_code trace_kernel_create_event_notifier_rule(
 484                 struct lttng_trigger *trigger,
 485                 uint64_t token,
 486                 uint64_t error_counter_index,
 487                 struct ltt_kernel_event_notifier_rule **event_notifier_rule)
 488 {
 489         enum lttng_error_code ret = LTTNG_OK;
 490         enum lttng_condition_type condition_type;
 491         enum lttng_event_rule_type event_rule_type;
 492         enum lttng_condition_status condition_status;
 493         struct ltt_kernel_event_notifier_rule *local_kernel_token_event_rule;
 494         const struct lttng_condition *condition = NULL;
 495         const struct lttng_event_rule *event_rule = NULL;
 496
 497         LTTNG_ASSERT(event_notifier_rule);
 498
 499         condition = lttng_trigger_get_const_condition(trigger);
 500         LTTNG_ASSERT(condition);
 501
 502         condition_type = lttng_condition_get_type(condition);
 503         LTTNG_ASSERT(condition_type == LTTNG_CONDITION_TYPE_EVENT_RULE_MATCHES);
 504
 505         condition_status = lttng_condition_event_rule_matches_get_rule(
 506                         condition, &event_rule);
 507         LTTNG_ASSERT(condition_status == LTTNG_CONDITION_STATUS_OK);
 508         LTTNG_ASSERT(event_rule);
 509
 510         event_rule_type = lttng_event_rule_get_type(event_rule);
 511         LTTNG_ASSERT(event_rule_type != LTTNG_EVENT_RULE_TYPE_UNKNOWN);
 512
 513         local_kernel_token_event_rule =
 514                         zmalloc<ltt_kernel_event_notifier_rule>();
 515         if (local_kernel_token_event_rule == NULL) {
 516                 PERROR("Failed to allocate ltt_kernel_token_event_rule structure");
 517                 ret = LTTNG_ERR_NOMEM;
 518                 goto error;
 519         }
 520
 521         local_kernel_token_event_rule->fd = -1;
 522         local_kernel_token_event_rule->enabled = 1;
 523         local_kernel_token_event_rule->token = token;
 524         local_kernel_token_event_rule->error_counter_index = error_counter_index;
 525
 526         /* Get the reference of the event rule. */
 527         lttng_trigger_get(trigger);
 528
 529         local_kernel_token_event_rule->trigger = trigger;
 530         /* The event rule still owns the filter and bytecode. */
 531         local_kernel_token_event_rule->filter =
 532                         lttng_event_rule_get_filter_bytecode(event_rule);
 533
 534         DBG3("Created kernel event notifier rule: token =  %" PRIu64,
 535                         local_kernel_token_event_rule->token);
 536 error:
 537         *event_notifier_rule = local_kernel_token_event_rule;
 538         return ret;
 539 }
 540
 541 /*
 542  * Initialize a kernel trigger from an event rule.
 543  */
 544 enum lttng_error_code trace_kernel_init_event_notifier_from_event_rule(
 545                 const struct lttng_event_rule *rule,
 546                 struct lttng_kernel_abi_event_notifier *kernel_event_notifier)
 547 {
 548         enum lttng_error_code ret_code;
 549         const char *name;
 550         int strncpy_ret;
 551
 552         switch (lttng_event_rule_get_type(rule)) {
 553         case LTTNG_EVENT_RULE_TYPE_KERNEL_KPROBE:
 554         {
 555                 uint64_t address = 0, offset = 0;
 556                 const char *symbol_name = NULL;
 557                 const struct lttng_kernel_probe_location *location = NULL;
 558                 enum lttng_kernel_probe_location_status k_status;
 559                 enum lttng_event_rule_status status;
 560
 561                 status = lttng_event_rule_kernel_kprobe_get_location(rule, &location);
 562                 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 563                         ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL;
 564                         goto error;
 565                 }
 566
 567                 switch (lttng_kernel_probe_location_get_type(location)) {
 568                 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_ADDRESS:
 569                 {
 570                         k_status = lttng_kernel_probe_location_address_get_address(
 571                                         location, &address);
 572                         LTTNG_ASSERT(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK);
 573                         break;
 574                 }
 575                 case LTTNG_KERNEL_PROBE_LOCATION_TYPE_SYMBOL_OFFSET:
 576                 {
 577                         k_status = lttng_kernel_probe_location_symbol_get_offset(
 578                                         location, &offset);
 579                         LTTNG_ASSERT(k_status == LTTNG_KERNEL_PROBE_LOCATION_STATUS_OK);
 580                         symbol_name = lttng_kernel_probe_location_symbol_get_name(
 581                                         location);
 582                         break;
 583                 }
 584                 default:
 585                         abort();
 586                 }
 587
 588                 kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_KPROBE;
 589                 kernel_event_notifier->event.u.kprobe.addr = address;
 590                 kernel_event_notifier->event.u.kprobe.offset = offset;
 591                 if (symbol_name) {
 592                         strncpy_ret = lttng_strncpy(
 593                                         kernel_event_notifier->event.u.kprobe.symbol_name,
 594                                         symbol_name,
 595                                         sizeof(kernel_event_notifier->event.u.kprobe.symbol_name));
 596
 597                         if (strncpy_ret) {
 598                                 ret_code = LTTNG_ERR_INVALID;
 599                                 goto error;
 600                         }
 601                 }
 602
 603                 kernel_event_notifier->event.u.kprobe.symbol_name[LTTNG_KERNEL_ABI_SYM_NAME_LEN - 1] = '\0';
 604
 605                 status = lttng_event_rule_kernel_kprobe_get_event_name(rule, &name);
 606                 LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
 607                 ret_code = LTTNG_OK;
 608                 break;
 609         }
 610         case LTTNG_EVENT_RULE_TYPE_KERNEL_UPROBE:
 611         {
 612                 const struct lttng_userspace_probe_location* location = NULL;
 613                 const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
 614                 enum lttng_event_rule_status status;
 615
 616                 status = lttng_event_rule_kernel_uprobe_get_location(rule, &location);
 617                 if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 618                         ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL;
 619                         goto error;
 620                 }
 621
 622                 kernel_event_notifier->event.instrumentation = LTTNG_KERNEL_ABI_UPROBE;
 623
 624                 lookup = lttng_userspace_probe_location_get_lookup_method(
 625                                 location);
 626                 if (!lookup) {
 627                         ret_code = LTTNG_ERR_PROBE_LOCATION_INVAL;
 628                         goto error;
 629                 }
 630
 631                 /*
 632                  * From the kernel tracer's perspective, all userspace probe
 633                  * event types are all the same: a file and an offset.
 634                  */
 635                 switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) {
 636                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
 637                         /* Get the file descriptor on the target binary. */
 638                         kernel_event_notifier->event.u.uprobe.fd =
 639                                         lttng_userspace_probe_location_function_get_binary_fd(location);
 640
 641                         break;
 642                 case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
 643                         /* Get the file descriptor on the target binary. */
 644                         kernel_event_notifier->event.u.uprobe.fd =
 645                                         lttng_userspace_probe_location_tracepoint_get_binary_fd(location);
 646                         break;
 647                 default:
 648                         abort();
 649                 }
 650
 651                 status = lttng_event_rule_kernel_uprobe_get_event_name(
 652                                 rule, &name);
 653                 LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
 654                 ret_code = LTTNG_OK;
 655                 break;
 656         }
 657         case LTTNG_EVENT_RULE_TYPE_KERNEL_TRACEPOINT:
 658         {
 659                 const enum lttng_event_rule_status status =
 660                                 lttng_event_rule_kernel_tracepoint_get_name_pattern(
 661                                                 rule, &name);
 662
 663                 LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
 664                 kernel_event_notifier->event.instrumentation =
 665                                 LTTNG_KERNEL_ABI_TRACEPOINT;
 666
 667                 ret_code = LTTNG_OK;
 668                 break;
 669         }
 670         case LTTNG_EVENT_RULE_TYPE_KERNEL_SYSCALL:
 671         {
 672                 const enum lttng_event_rule_status status =
 673                                 lttng_event_rule_kernel_syscall_get_name_pattern(
 674                                                 rule, &name);
 675                 const enum lttng_event_rule_kernel_syscall_emission_site
 676                         emission_site =
 677                         lttng_event_rule_kernel_syscall_get_emission_site(rule);
 678                 enum lttng_kernel_abi_syscall_entryexit entryexit;
 679
 680                 LTTNG_ASSERT(status == LTTNG_EVENT_RULE_STATUS_OK);
 681                 LTTNG_ASSERT(emission_site != LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_UNKNOWN);
 682
 683                 switch(emission_site) {
 684                 case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY:
 685                         entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRY;
 686                         break;
 687                 case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_EXIT:
 688                         entryexit = LTTNG_KERNEL_ABI_SYSCALL_EXIT;
 689                         break;
 690                 case LTTNG_EVENT_RULE_KERNEL_SYSCALL_EMISSION_SITE_ENTRY_EXIT:
 691                         entryexit = LTTNG_KERNEL_ABI_SYSCALL_ENTRYEXIT;
 692                         break;
 693                 default:
 694                         abort();
 695                         break;
 696                 }
 697
 698                 kernel_event_notifier->event.instrumentation =
 699                                 LTTNG_KERNEL_ABI_SYSCALL;
 700                 kernel_event_notifier->event.u.syscall.abi =
 701                                 LTTNG_KERNEL_ABI_SYSCALL_ABI_ALL;
 702                 kernel_event_notifier->event.u.syscall.entryexit =
 703                                 entryexit;
 704                 kernel_event_notifier->event.u.syscall.match =
 705                                 LTTNG_KERNEL_ABI_SYSCALL_MATCH_NAME;
 706                 ret_code = LTTNG_OK;
 707                 break;
 708         }
 709         default:
 710                 abort();
 711                 break;
 712         }
 713
 714         strncpy_ret = lttng_strncpy(kernel_event_notifier->event.name, name,
 715                         LTTNG_KERNEL_ABI_SYM_NAME_LEN);
 716         if (strncpy_ret) {
 717                 ret_code = LTTNG_ERR_INVALID;
 718                 goto error;
 719         }
 720
 721 error:
 722         return ret_code;
 723 }
 724 /*
 725  * Allocate and initialize a kernel metadata.
 726  *
 727  * Return pointer to structure or NULL.
 728  */
 729 struct ltt_kernel_metadata *trace_kernel_create_metadata(void)
 730 {
 731         int ret;
 732         struct ltt_kernel_metadata *lkm;
 733         struct lttng_channel *chan;
 734
 735         lkm = zmalloc<ltt_kernel_metadata>();
 736         chan = zmalloc<lttng_channel>();
 737         if (lkm == NULL || chan == NULL) {
 738                 PERROR("kernel metadata zmalloc");
 739                 goto error;
 740         }
 741
 742         ret = lttng_strncpy(
 743                         chan->name, DEFAULT_METADATA_NAME, sizeof(chan->name));
 744         if (ret) {
 745                 ERR("Failed to initialize metadata channel name to `%s`",
 746                                 DEFAULT_METADATA_NAME);
 747                 goto error;
 748         }
 749
 750         /* Set default attributes */
 751         chan->attr.overwrite = DEFAULT_METADATA_OVERWRITE;
 752         chan->attr.subbuf_size = default_get_metadata_subbuf_size();
 753         chan->attr.num_subbuf = DEFAULT_METADATA_SUBBUF_NUM;
 754         chan->attr.switch_timer_interval = DEFAULT_METADATA_SWITCH_TIMER;
 755         chan->attr.read_timer_interval = DEFAULT_METADATA_READ_TIMER;;
 756
 757
 758         /*
 759          * The metadata channel of kernel sessions must use the "mmap"
 760          * back-end since the consumer daemon accumulates complete
 761          * metadata units before sending them to the relay daemon in
 762          * live mode. The consumer daemon also needs to extract the contents
 763          * of the metadata cache when computing a rotation position.
 764          *
 765          * In both cases, it is not possible to rely on the splice
 766          * back-end as the consumer daemon may need to accumulate more
 767          * content than can be backed by the ring buffer's underlying
 768          * pages.
 769          */
 770         chan->attr.output = LTTNG_EVENT_MMAP;
 771         chan->attr.tracefile_size = 0;
 772         chan->attr.tracefile_count = 0;
 773         chan->attr.live_timer_interval = 0;
 774
 775         /* Init metadata */
 776         lkm->fd = -1;
 777         lkm->conf = chan;
 778
 779         return lkm;
 780
 781 error:
 782         free(lkm);
 783         free(chan);
 784         return NULL;
 785 }
 786
 787 /*
 788  * Allocate and initialize a kernel stream. The stream is set to ACTIVE_FD by
 789  * default.
 790  *
 791  * Return pointer to structure or NULL.
 792  */
 793 struct ltt_kernel_stream *trace_kernel_create_stream(const char *name,
 794                 unsigned int count)
 795 {
 796         int ret;
 797         struct ltt_kernel_stream *lks;
 798
 799         LTTNG_ASSERT(name);
 800
 801         lks = zmalloc<ltt_kernel_stream>();
 802         if (lks == NULL) {
 803                 PERROR("kernel stream zmalloc");
 804                 goto error;
 805         }
 806
 807         /* Set name */
 808         ret = snprintf(lks->name, sizeof(lks->name), "%s_%u", name, count);
 809         if (ret < 0) {
 810                 PERROR("snprintf stream name");
 811                 goto error;
 812         }
 813         lks->name[sizeof(lks->name) - 1] = '\0';
 814
 815         /* Init stream */
 816         lks->fd = -1;
 817         lks->state = 0;
 818         lks->cpu = count;
 819
 820         return lks;
 821
 822 error:
 823         return NULL;
 824 }
 825
 826 /*
 827  * Cleanup kernel stream structure.
 828  */
 829 void trace_kernel_destroy_stream(struct ltt_kernel_stream *stream)
 830 {
 831         LTTNG_ASSERT(stream);
 832
 833         DBG("[trace] Closing stream fd %d", stream->fd);
 834         /* Close kernel fd */
 835         if (stream->fd >= 0) {
 836                 int ret;
 837
 838                 ret = close(stream->fd);
 839                 if (ret) {
 840                         PERROR("close");
 841                 }
 842         }
 843         /* Remove from stream list */
 844         cds_list_del(&stream->list);
 845
 846         free(stream);
 847 }
 848
 849 /*
 850  * Cleanup kernel event structure.
 851  */
 852 void trace_kernel_destroy_event(struct ltt_kernel_event *event)
 853 {
 854         LTTNG_ASSERT(event);
 855
 856         if (event->fd >= 0) {
 857                 int ret;
 858
 859                 DBG("[trace] Closing event fd %d", event->fd);
 860                 /* Close kernel fd */
 861                 ret = close(event->fd);
 862                 if (ret) {
 863                         PERROR("close");
 864                 }
 865         } else {
 866                 DBG("[trace] Tearing down event (no associated file descriptor)");
 867         }
 868
 869         /* Remove from event list */
 870         cds_list_del(&event->list);
 871
 872         free(event->filter_expression);
 873         free(event->filter);
 874
 875         free(event->event);
 876         free(event);
 877 }
 878
 879 /*
 880  * Cleanup kernel event structure.
 881  */
 882 static void free_token_event_rule_rcu(struct rcu_head *rcu_node)
 883 {
 884         struct ltt_kernel_event_notifier_rule *rule = caa_container_of(rcu_node,
 885                         struct ltt_kernel_event_notifier_rule, rcu_node);
 886
 887         free(rule);
 888 }
 889
 890 void trace_kernel_destroy_event_notifier_rule(
 891                 struct ltt_kernel_event_notifier_rule *event)
 892 {
 893         LTTNG_ASSERT(event);
 894
 895         if (event->fd >= 0) {
 896                 const int ret = close(event->fd);
 897
 898                 DBG("Closing kernel event notifier rule file descriptor: fd = %d",
 899                                 event->fd);
 900                 if (ret) {
 901                         PERROR("Failed to close kernel event notifier file descriptor: fd = %d",
 902                                         event->fd);
 903                 }
 904         } else {
 905                 DBG("Destroying kernel event notifier rule (no associated file descriptor)");
 906         }
 907
 908         lttng_trigger_put(event->trigger);
 909         call_rcu(&event->rcu_node, free_token_event_rule_rcu);
 910 }
 911 /*
 912  * Cleanup kernel context structure.
 913  */
 914 void trace_kernel_destroy_context(struct ltt_kernel_context *ctx)
 915 {
 916         LTTNG_ASSERT(ctx);
 917
 918         if (ctx->in_list) {
 919                 cds_list_del(&ctx->list);
 920         }
 921         free(ctx);
 922 }
 923
 924 /*
 925  * Cleanup kernel channel structure.
 926  */
 927 void trace_kernel_destroy_channel(struct ltt_kernel_channel *channel)
 928 {
 929         struct ltt_kernel_stream *stream, *stmp;
 930         struct ltt_kernel_event *event, *etmp;
 931         struct ltt_kernel_context *ctx, *ctmp;
 932         int ret;
 933         enum lttng_error_code status;
 934
 935         LTTNG_ASSERT(channel);
 936
 937         DBG("[trace] Closing channel fd %d", channel->fd);
 938         /* Close kernel fd */
 939         if (channel->fd >= 0) {
 940                 ret = close(channel->fd);
 941                 if (ret) {
 942                         PERROR("close");
 943                 }
 944         }
 945
 946         /* For each stream in the channel list */
 947         cds_list_for_each_entry_safe(stream, stmp, &channel->stream_list.head, list) {
 948                 trace_kernel_destroy_stream(stream);
 949         }
 950
 951         /* For each event in the channel list */
 952         cds_list_for_each_entry_safe(event, etmp, &channel->events_list.head, list) {
 953                 trace_kernel_destroy_event(event);
 954         }
 955
 956         /* For each context in the channel list */
 957         cds_list_for_each_entry_safe(ctx, ctmp, &channel->ctx_list, list) {
 958                 trace_kernel_destroy_context(ctx);
 959         }
 960
 961         /* Remove from channel list */
 962         cds_list_del(&channel->list);
 963
 964         if (the_notification_thread_handle &&
 965                         channel->published_to_notification_thread) {
 966                 status = notification_thread_command_remove_channel(
 967                                 the_notification_thread_handle, channel->key,
 968                                 LTTNG_DOMAIN_KERNEL);
 969                 LTTNG_ASSERT(status == LTTNG_OK);
 970         }
 971         free(channel->channel->attr.extended.ptr);
 972         free(channel->channel);
 973         free(channel);
 974 }
 975
 976 /*
 977  * Cleanup kernel metadata structure.
 978  */
 979 void trace_kernel_destroy_metadata(struct ltt_kernel_metadata *metadata)
 980 {
 981         LTTNG_ASSERT(metadata);
 982
 983         DBG("[trace] Closing metadata fd %d", metadata->fd);
 984         /* Close kernel fd */
 985         if (metadata->fd >= 0) {
 986                 int ret;
 987
 988                 ret = close(metadata->fd);
 989                 if (ret) {
 990                         PERROR("close");
 991                 }
 992         }
 993
 994         free(metadata->conf);
 995         free(metadata);
 996 }
 997
 998 /*
 999  * Cleanup kernel session structure
1000  */
1001 void trace_kernel_destroy_session(struct ltt_kernel_session *session)
1002 {
1003         struct ltt_kernel_channel *channel, *ctmp;
1004         int ret;
1005
1006         LTTNG_ASSERT(session);
1007
1008         DBG("[trace] Closing session fd %d", session->fd);
1009         /* Close kernel fds */
1010         if (session->fd >= 0) {
1011                 ret = close(session->fd);
1012                 if (ret) {
1013                         PERROR("close");
1014                 }
1015         }
1016
1017         if (session->metadata_stream_fd >= 0) {
1018                 DBG("[trace] Closing metadata stream fd %d", session->metadata_stream_fd);
1019                 ret = close(session->metadata_stream_fd);
1020                 if (ret) {
1021                         PERROR("close");
1022                 }
1023         }
1024
1025         if (session->metadata != NULL) {
1026                 trace_kernel_destroy_metadata(session->metadata);
1027         }
1028
1029         cds_list_for_each_entry_safe(channel, ctmp, &session->channel_list.head, list) {
1030                 trace_kernel_destroy_channel(channel);
1031         }
1032 }
1033
1034 /* Free elements needed by destroy notifiers. */
1035 void trace_kernel_free_session(struct ltt_kernel_session *session)
1036 {
1037         /* Wipe consumer output object */
1038         consumer_output_put(session->consumer);
1039
1040         process_attr_tracker_destroy(session->tracker_pid);
1041         process_attr_tracker_destroy(session->tracker_vpid);
1042         process_attr_tracker_destroy(session->tracker_uid);
1043         process_attr_tracker_destroy(session->tracker_vuid);
1044         process_attr_tracker_destroy(session->tracker_gid);
1045         process_attr_tracker_destroy(session->tracker_vgid);
1046
1047         delete (session);
1048 }