src/lttng-context-callstack.c

   1 /* SPDX-License-Identifier: (GPL-2.0-only or LGPL-2.1-only)
   2  *
   3  * lttng-context-callstack.c
   4  *
   5  * LTTng callstack event context.
   6  *
   7  * Copyright (C) 2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  * Copyright (C) 2014 Francis Giraldeau <francis.giraldeau@gmail.com>
   9  *
  10  * The callstack context can be added to any kernel event. It records
  11  * either the kernel or the userspace callstack, up to a max depth. The
  12  * context is a CTF sequence, such that it uses only the space required
  13  * for the number of callstack entries.
  14  *
  15  * It allocates callstack buffers per-CPU up to 4 interrupt nesting.
  16  * This nesting limit is the same as defined in the ring buffer. It
  17  * therefore uses a fixed amount of memory, proportional to the number
  18  * of CPUs:
  19  *
  20  *   size = cpus * nest * depth * sizeof(unsigned long)
  21  *
  22  * Which is 4096 bytes per CPU on 64-bit host and a depth of 128.
  23  * The allocation is done at the initialization to avoid memory
  24  * allocation overhead while tracing, using a shallow stack.
  25  *
  26  * The kernel callstack is recovered using save_stack_trace(), and the
  27  * userspace callstack uses save_stack_trace_user(). They rely on frame
  28  * pointers. These are usually available for the kernel, but the
  29  * compiler option -fomit-frame-pointer frequently used in popular Linux
  30  * distributions may cause the userspace callstack to be unreliable, and
  31  * is a known limitation of this approach. If frame pointers are not
  32  * available, it produces no error, but the callstack will be empty. We
  33  * still provide the feature, because it works well for runtime
  34  * environments having frame pointers. In the future, unwind support
  35  * and/or last branch record may provide a solution to this problem.
  36  *
  37  * The symbol name resolution is left to the trace reader.
  38  */
  39
  40 #include <linux/module.h>
  41 #include <linux/slab.h>
  42 #include <linux/sched.h>
  43 #include <linux/utsname.h>
  44 #include <linux/stacktrace.h>
  45 #include <linux/spinlock.h>
  46 #include <ringbuffer/backend.h>
  47 #include <ringbuffer/frontend.h>
  48 #include <lttng/events.h>
  49 #include <lttng/events-internal.h>
  50 #include <lttng/tracer.h>
  51 #include <lttng/endian.h>
  52 #include "wrapper/vmalloc.h"
  53
  54 #ifdef CONFIG_ARCH_STACKWALK
  55 #include "lttng-context-callstack-stackwalk-impl.h"
  56 #else
  57 #include "lttng-context-callstack-legacy-impl.h"
  58 #endif
  59
  60 #define NR_FIELDS       2
  61
  62 static
  63 void field_data_free(struct field_data *fdata)
  64 {
  65         if (!fdata)
  66                 return;
  67         free_percpu(fdata->cs_percpu);
  68         kfree(fdata);
  69 }
  70
  71 static
  72 struct field_data __percpu *field_data_create(enum lttng_cs_ctx_modes mode)
  73 {
  74         struct lttng_cs __percpu *cs_set;
  75         struct field_data *fdata;
  76
  77         fdata = kzalloc(sizeof(*fdata), GFP_KERNEL);
  78         if (!fdata)
  79                 return NULL;
  80         cs_set = alloc_percpu(struct lttng_cs);
  81         if (!cs_set)
  82                 goto error_alloc;
  83         lttng_cs_set_init(cs_set);
  84         fdata->cs_percpu = cs_set;
  85         fdata->mode = mode;
  86         return fdata;
  87
  88 error_alloc:
  89         field_data_free(fdata);
  90         return NULL;
  91 }
  92
  93 static
  94 void lttng_callstack_sequence_destroy(void *priv)
  95 {
  96         struct field_data *fdata = priv;
  97
  98         field_data_free(fdata);
  99 }
 100
 101 static const struct lttng_kernel_event_field *event_fields_kernel[NR_FIELDS] = {
 102         lttng_kernel_static_event_field("_callstack_kernel_length",
 103                 lttng_kernel_static_type_integer_from_type(unsigned int, __BYTE_ORDER, 10),
 104                 false, false),
 105         lttng_kernel_static_event_field("callstack_kernel",
 106                 lttng_kernel_static_type_sequence(NULL,
 107                         lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
 108                         0, none),
 109                 false, false),
 110 };
 111
 112 static const struct lttng_kernel_event_field *event_fields_user[NR_FIELDS] = {
 113         lttng_kernel_static_event_field("_callstack_user_length",
 114                 lttng_kernel_static_type_integer_from_type(unsigned int, __BYTE_ORDER, 10),
 115                 false, false),
 116         lttng_kernel_static_event_field("callstack_user",
 117                 lttng_kernel_static_type_sequence(NULL,
 118                         lttng_kernel_static_type_integer_from_type(unsigned long, __BYTE_ORDER, 16),
 119                         0, none),
 120                 false, false),
 121 };
 122
 123 static
 124 const struct lttng_kernel_event_field **lttng_cs_event_fields(enum lttng_cs_ctx_modes mode)
 125 {
 126         switch (mode) {
 127         case CALLSTACK_KERNEL:
 128                 return event_fields_kernel;
 129         case CALLSTACK_USER:
 130                 return event_fields_user;
 131         default:
 132                 return NULL;
 133         }
 134 }
 135
 136 static
 137 int __lttng_add_callstack_generic(struct lttng_kernel_ctx **ctx,
 138                 enum lttng_cs_ctx_modes mode)
 139 {
 140         const struct lttng_kernel_event_field **event_fields;
 141         struct lttng_kernel_ctx_field ctx_field;
 142         struct field_data *fdata;
 143         int ret, i;
 144
 145         ret = init_type(mode);
 146         if (ret)
 147                 return ret;
 148         event_fields = lttng_cs_event_fields(mode);
 149         if (!event_fields) {
 150                 return -EINVAL;
 151         }
 152         for (i = 0; i < NR_FIELDS; i++) {
 153                 if (lttng_kernel_find_context(*ctx, event_fields[i]->name))
 154                         return -EEXIST;
 155         }
 156         fdata = field_data_create(mode);
 157         if (!fdata) {
 158                 ret = -ENOMEM;
 159                 goto error_create;
 160         }
 161         memset(&ctx_field, 0, sizeof(ctx_field));
 162         ctx_field.event_field = event_fields[0];
 163         ctx_field.get_size = lttng_callstack_length_get_size;
 164         ctx_field.record = lttng_callstack_length_record;
 165         ctx_field.priv = fdata;
 166         ret = lttng_kernel_context_append(ctx, &ctx_field);
 167         if (ret) {
 168                 ret = -ENOMEM;
 169                 goto error_append0;
 170         }
 171
 172         memset(&ctx_field, 0, sizeof(ctx_field));
 173         ctx_field.event_field = event_fields[1];
 174         ctx_field.get_size = lttng_callstack_sequence_get_size;
 175         ctx_field.record = lttng_callstack_sequence_record;
 176         ctx_field.destroy = lttng_callstack_sequence_destroy;
 177         ctx_field.priv = fdata;
 178         ret = lttng_kernel_context_append(ctx, &ctx_field);
 179         if (ret) {
 180                 ret = -ENOMEM;
 181                 goto error_append1;
 182         }
 183         return 0;
 184
 185 error_append1:
 186         lttng_kernel_context_remove_last(ctx);
 187 error_append0:
 188         field_data_free(fdata);
 189 error_create:
 190         return ret;
 191 }
 192
 193 /**
 194  *      lttng_add_callstack_to_ctx - add callstack event context
 195  *
 196  *      @ctx: the lttng_ctx pointer to initialize
 197  *      @type: the context type
 198  *
 199  *      Supported callstack type supported:
 200  *      LTTNG_KERNEL_CONTEXT_CALLSTACK_KERNEL
 201  *              Records the callstack of the kernel
 202  *      LTTNG_KERNEL_CONTEXT_CALLSTACK_USER
 203  *              Records the callstack of the userspace program (from the kernel)
 204  *
 205  * Return 0 for success, or error code.
 206  */
 207 int lttng_add_callstack_to_ctx(struct lttng_kernel_ctx **ctx, int type)
 208 {
 209         switch (type) {
 210         case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_KERNEL:
 211                 return __lttng_add_callstack_generic(ctx, CALLSTACK_KERNEL);
 212 #ifdef CONFIG_X86
 213         case LTTNG_KERNEL_ABI_CONTEXT_CALLSTACK_USER:
 214                 return __lttng_add_callstack_generic(ctx, CALLSTACK_USER);
 215 #endif
 216         default:
 217                 return -EINVAL;
 218         }
 219 }
 220 EXPORT_SYMBOL_GPL(lttng_add_callstack_to_ctx);