lttng-filter.h

   1 /* SPDX-License-Identifier: MIT
   2  *
   3  * lttng-filter.h
   4  *
   5  * LTTng modules filter header.
   6  *
   7  * Copyright (C) 2010-2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  */
   9
  10 #ifndef _LTTNG_FILTER_H
  11 #define _LTTNG_FILTER_H
  12
  13 #include <linux/kernel.h>
  14
  15 #include <lttng-events.h>
  16 #include <filter-bytecode.h>
  17
  18 /* Filter stack length, in number of entries */
  19 #define FILTER_STACK_LEN        10      /* includes 2 dummy */
  20 #define FILTER_STACK_EMPTY      1
  21
  22 #define FILTER_MAX_DATA_LEN     65536
  23
  24 #ifdef DEBUG
  25 #define dbg_printk(fmt, args...)                                \
  26         printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt,          \
  27                 __FILE__, __func__, __LINE__, ## args)
  28 #else
  29 #define dbg_printk(fmt, args...)                                \
  30 do {                                                            \
  31         /* do nothing but check printf format */                \
  32         if (0)                                                  \
  33                 printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt,  \
  34                         __FILE__, __func__, __LINE__, ## args); \
  35 } while (0)
  36 #endif
  37
  38 /* Linked bytecode. Child of struct lttng_bytecode_runtime. */
  39 struct bytecode_runtime {
  40         struct lttng_bytecode_runtime p;
  41         size_t data_len;
  42         size_t data_alloc_len;
  43         char *data;
  44         uint16_t len;
  45         char code[];
  46 };
  47
  48 enum entry_type {
  49         REG_S64,
  50         REG_DOUBLE,
  51         REG_STRING,
  52         REG_STAR_GLOB_STRING,
  53         REG_TYPE_UNKNOWN,
  54         REG_PTR,
  55 };
  56
  57 enum load_type {
  58         LOAD_ROOT_CONTEXT,
  59         LOAD_ROOT_APP_CONTEXT,
  60         LOAD_ROOT_PAYLOAD,
  61         LOAD_OBJECT,
  62 };
  63
  64 enum object_type {
  65         OBJECT_TYPE_S8,
  66         OBJECT_TYPE_S16,
  67         OBJECT_TYPE_S32,
  68         OBJECT_TYPE_S64,
  69         OBJECT_TYPE_U8,
  70         OBJECT_TYPE_U16,
  71         OBJECT_TYPE_U32,
  72         OBJECT_TYPE_U64,
  73
  74         OBJECT_TYPE_DOUBLE,
  75         OBJECT_TYPE_STRING,
  76         OBJECT_TYPE_STRING_SEQUENCE,
  77
  78         OBJECT_TYPE_SEQUENCE,
  79         OBJECT_TYPE_ARRAY,
  80         OBJECT_TYPE_STRUCT,
  81         OBJECT_TYPE_VARIANT,
  82
  83         OBJECT_TYPE_DYNAMIC,
  84 };
  85
  86 struct filter_get_index_data {
  87         uint64_t offset;        /* in bytes */
  88         size_t ctx_index;
  89         size_t array_len;
  90         struct {
  91                 size_t len;
  92                 enum object_type type;
  93                 bool rev_bo;    /* reverse byte order */
  94                 bool user;      /* from userspace */
  95         } elem;
  96 };
  97
  98 /* Validation stack */
  99 struct vstack_load {
 100         enum load_type type;
 101         enum object_type object_type;
 102         const struct lttng_event_field *field;
 103         bool rev_bo;    /* reverse byte order */
 104         bool user;      /* from userspace */
 105 };
 106
 107 struct vstack_entry {
 108         enum entry_type type;
 109         struct vstack_load load;
 110 };
 111
 112 struct vstack {
 113         int top;        /* top of stack */
 114         struct vstack_entry e[FILTER_STACK_LEN];
 115 };
 116
 117 static inline
 118 void vstack_init(struct vstack *stack)
 119 {
 120         stack->top = -1;
 121 }
 122
 123 static inline
 124 struct vstack_entry *vstack_ax(struct vstack *stack)
 125 {
 126         if (unlikely(stack->top < 0))
 127                 return NULL;
 128         return &stack->e[stack->top];
 129 }
 130
 131 static inline
 132 struct vstack_entry *vstack_bx(struct vstack *stack)
 133 {
 134         if (unlikely(stack->top < 1))
 135                 return NULL;
 136         return &stack->e[stack->top - 1];
 137 }
 138
 139 static inline
 140 int vstack_push(struct vstack *stack)
 141 {
 142         if (stack->top >= FILTER_STACK_LEN - 1) {
 143                 printk(KERN_WARNING "Stack full\n");
 144                 return -EINVAL;
 145         }
 146         ++stack->top;
 147         return 0;
 148 }
 149
 150 static inline
 151 int vstack_pop(struct vstack *stack)
 152 {
 153         if (unlikely(stack->top < 0)) {
 154                 printk(KERN_WARNING "Stack empty\n");
 155                 return -EINVAL;
 156         }
 157         stack->top--;
 158         return 0;
 159 }
 160
 161 /* Execution stack */
 162 enum estack_string_literal_type {
 163         ESTACK_STRING_LITERAL_TYPE_NONE,
 164         ESTACK_STRING_LITERAL_TYPE_PLAIN,
 165         ESTACK_STRING_LITERAL_TYPE_STAR_GLOB,
 166 };
 167
 168 struct load_ptr {
 169         enum load_type type;
 170         enum object_type object_type;
 171         const void *ptr;
 172         bool rev_bo;
 173         bool user;      /* from userspace */
 174         /* Temporary place-holders for contexts. */
 175         union {
 176                 int64_t s64;
 177                 uint64_t u64;
 178                 double d;
 179         } u;
 180         /*
 181          * "field" is only needed when nested under a variant, in which
 182          * case we cannot specialize the nested operations.
 183          */
 184         const struct lttng_event_field *field;
 185 };
 186
 187 struct estack_entry {
 188         union {
 189                 int64_t v;
 190
 191                 struct {
 192                         const char *str;
 193                         const char __user *user_str;
 194                         size_t seq_len;
 195                         enum estack_string_literal_type literal_type;
 196                         bool user;              /* is string from userspace ? */
 197                 } s;
 198                 struct load_ptr ptr;
 199         } u;
 200 };
 201
 202 struct estack {
 203         int top;        /* top of stack */
 204         struct estack_entry e[FILTER_STACK_LEN];
 205 };
 206
 207 #define estack_ax_v     ax
 208 #define estack_bx_v     bx
 209
 210 #define estack_ax(stack, top)                                   \
 211         ({                                                      \
 212                 BUG_ON((top) <= FILTER_STACK_EMPTY);            \
 213                 &(stack)->e[top];                               \
 214         })
 215
 216 #define estack_bx(stack, top)                                   \
 217         ({                                                      \
 218                 BUG_ON((top) <= FILTER_STACK_EMPTY + 1);        \
 219                 &(stack)->e[(top) - 1];                         \
 220         })
 221
 222 #define estack_push(stack, top, ax, bx)                         \
 223         do {                                                    \
 224                 BUG_ON((top) >= FILTER_STACK_LEN - 1);          \
 225                 (stack)->e[(top) - 1].u.v = (bx);               \
 226                 (bx) = (ax);                                    \
 227                 ++(top);                                        \
 228         } while (0)
 229
 230 #define estack_pop(stack, top, ax, bx)                          \
 231         do {                                                    \
 232                 BUG_ON((top) <= FILTER_STACK_EMPTY);            \
 233                 (ax) = (bx);                                    \
 234                 (bx) = (stack)->e[(top) - 2].u.v;               \
 235                 (top)--;                                        \
 236         } while (0)
 237
 238 const char *lttng_filter_print_op(enum filter_op op);
 239
 240 int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode);
 241 int lttng_filter_validate_bytecode_load(struct bytecode_runtime *bytecode);
 242 int lttng_filter_specialize_bytecode(struct lttng_event *event,
 243                 struct bytecode_runtime *bytecode);
 244
 245 uint64_t lttng_filter_false(void *filter_data,
 246                 struct lttng_probe_ctx *lttng_probe_ctx,
 247                 const char *filter_stack_data);
 248 uint64_t lttng_filter_interpret_bytecode(void *filter_data,
 249                 struct lttng_probe_ctx *lttng_probe_ctx,
 250                 const char *filter_stack_data);
 251
 252 #endif /* _LTTNG_FILTER_H */