src/common/event-rule/kprobe.c

   1 /*
   2  * Copyright (C) 2019 Jonathan Rajotte <jonathan.rajotte-julien@efficios.com>
   3  *
   4  * SPDX-License-Identifier: LGPL-2.1-only
   5  *
   6  */
   7
   8 #include <assert.h>
   9 #include <common/credentials.h>
  10 #include <common/error.h>
  11 #include <common/macros.h>
  12 #include <common/payload.h>
  13 #include <common/payload-view.h>
  14 #include <common/runas.h>
  15 #include <common/hashtable/hashtable.h>
  16 #include <common/hashtable/utils.h>
  17 #include <ctype.h>
  18 #include <lttng/constant.h>
  19 #include <lttng/event-rule/event-rule-internal.h>
  20 #include <lttng/event-rule/kprobe-internal.h>
  21 #include <lttng/kernel-probe.h>
  22 #include <lttng/kernel-probe-internal.h>
  23 #include <stdio.h>
  24
  25 #define IS_KPROBE_EVENT_RULE(rule) \
  26         (lttng_event_rule_get_type(rule) == LTTNG_EVENT_RULE_TYPE_KPROBE)
  27
  28 #if (LTTNG_SYMBOL_NAME_LEN == 256)
  29 #define LTTNG_SYMBOL_NAME_LEN_SCANF_IS_A_BROKEN_API "255"
  30 #endif
  31
  32 static void lttng_event_rule_kprobe_destroy(struct lttng_event_rule *rule)
  33 {
  34         struct lttng_event_rule_kprobe *kprobe;
  35
  36         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
  37
  38         lttng_kernel_probe_location_destroy(kprobe->location);
  39         free(kprobe->name);
  40         free(kprobe);
  41 }
  42
  43 static bool lttng_event_rule_kprobe_validate(
  44                 const struct lttng_event_rule *rule)
  45 {
  46         bool valid = false;
  47         struct lttng_event_rule_kprobe *kprobe;
  48
  49         if (!rule) {
  50                 goto end;
  51         }
  52
  53         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
  54
  55         /* Required field. */
  56         if (!kprobe->name) {
  57                 ERR("Invalid name event rule: a name must be set.");
  58                 goto end;
  59         }
  60
  61         /* Required field. */
  62         if(!kprobe->location) {
  63                 ERR("Invalid name event rule: a location must be set.");
  64                 goto end;
  65         }
  66
  67         valid = true;
  68 end:
  69         return valid;
  70 }
  71
  72 static int lttng_event_rule_kprobe_serialize(
  73                 const struct lttng_event_rule *rule,
  74                 struct lttng_payload *payload)
  75 {
  76         int ret;
  77         size_t name_len, header_offset, size_before_location;
  78         struct lttng_event_rule_kprobe *kprobe;
  79         struct lttng_event_rule_kprobe_comm kprobe_comm;
  80         struct lttng_event_rule_kprobe_comm *header;
  81
  82         if (!rule || !IS_KPROBE_EVENT_RULE(rule)) {
  83                 ret = -1;
  84                 goto end;
  85         }
  86
  87         header_offset = payload->buffer.size;
  88
  89         DBG("Serializing kprobe event rule.");
  90         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
  91
  92         name_len = strlen(kprobe->name) + 1;
  93         kprobe_comm.name_len = name_len;
  94
  95         ret = lttng_dynamic_buffer_append(
  96                         &payload->buffer, &kprobe_comm, sizeof(kprobe_comm));
  97         if (ret) {
  98                 goto end;
  99         }
 100
 101         ret = lttng_dynamic_buffer_append(&payload->buffer, kprobe->name, name_len);
 102         if (ret) {
 103                 goto end;
 104         }
 105
 106         size_before_location = payload->buffer.size;
 107
 108         ret = lttng_kernel_probe_location_serialize(kprobe->location, payload);
 109         if (ret < 0) {
 110                 goto end;
 111         }
 112
 113         /* Update the header regarding the probe size. */
 114         header = (struct lttng_event_rule_kprobe_comm*) (
 115                         (char *) payload->buffer.data + header_offset);
 116         header->location_len = payload->buffer.size - size_before_location;
 117
 118         ret = 0;
 119
 120 end:
 121         return ret;
 122 }
 123
 124 static bool lttng_event_rule_kprobe_is_equal(const struct lttng_event_rule *_a,
 125                 const struct lttng_event_rule *_b)
 126 {
 127         bool is_equal = false;
 128         struct lttng_event_rule_kprobe *a, *b;
 129
 130         a = container_of(_a, struct lttng_event_rule_kprobe, parent);
 131         b = container_of(_b, struct lttng_event_rule_kprobe, parent);
 132
 133         /* Quick checks */
 134         if (!!a->name != !!b->name) {
 135                 goto end;
 136         }
 137
 138         /* Long check */
 139         assert(a->name);
 140         assert(b->name);
 141         if (strcmp(a->name, b->name)) {
 142                 goto end;
 143         }
 144
 145         is_equal = lttng_kernel_probe_location_is_equal(
 146                         a->location, b->location);
 147 end:
 148         return is_equal;
 149 }
 150
 151 static enum lttng_error_code lttng_event_rule_kprobe_generate_filter_bytecode(
 152                 struct lttng_event_rule *rule,
 153                 const struct lttng_credentials *creds)
 154 {
 155         /* Nothing to do. */
 156         return LTTNG_OK;
 157 }
 158
 159 static const char *lttng_event_rule_kprobe_get_filter(
 160                 const struct lttng_event_rule *rule)
 161 {
 162         /* Not supported. */
 163         return NULL;
 164 }
 165
 166 static const struct lttng_filter_bytecode *
 167 lttng_event_rule_kprobe_get_filter_bytecode(const struct lttng_event_rule *rule)
 168 {
 169         /* Not supported. */
 170         return NULL;
 171 }
 172
 173 static struct lttng_event_exclusion *
 174 lttng_event_rule_kprobe_generate_exclusions(const struct lttng_event_rule *rule)
 175 {
 176         /* Not supported. */
 177         return NULL;
 178 }
 179
 180 static unsigned long
 181 lttng_event_rule_kprobe_hash(
 182                 const struct lttng_event_rule *rule)
 183 {
 184         unsigned long hash;
 185         struct lttng_event_rule_kprobe *krule =
 186                         container_of(rule, typeof(*krule), parent);
 187
 188         hash = hash_key_ulong((void *) LTTNG_EVENT_RULE_TYPE_KPROBE,
 189                         lttng_ht_seed);
 190         hash ^= hash_key_str(krule->name, lttng_ht_seed);
 191         hash ^= lttng_kernel_probe_location_hash(krule->location);
 192
 193         return hash;
 194 }
 195
 196 struct lttng_event_rule *lttng_event_rule_kprobe_create()
 197 {
 198         struct lttng_event_rule *rule = NULL;
 199         struct lttng_event_rule_kprobe *krule;
 200
 201         krule = zmalloc(sizeof(struct lttng_event_rule_kprobe));
 202         if (!krule) {
 203                 goto end;
 204         }
 205
 206         rule = &krule->parent;
 207         lttng_event_rule_init(&krule->parent, LTTNG_EVENT_RULE_TYPE_KPROBE);
 208         krule->parent.validate = lttng_event_rule_kprobe_validate;
 209         krule->parent.serialize = lttng_event_rule_kprobe_serialize;
 210         krule->parent.equal = lttng_event_rule_kprobe_is_equal;
 211         krule->parent.destroy = lttng_event_rule_kprobe_destroy;
 212         krule->parent.generate_filter_bytecode =
 213                         lttng_event_rule_kprobe_generate_filter_bytecode;
 214         krule->parent.get_filter = lttng_event_rule_kprobe_get_filter;
 215         krule->parent.get_filter_bytecode =
 216                         lttng_event_rule_kprobe_get_filter_bytecode;
 217         krule->parent.generate_exclusions =
 218                         lttng_event_rule_kprobe_generate_exclusions;
 219         krule->parent.hash = lttng_event_rule_kprobe_hash;
 220 end:
 221         return rule;
 222 }
 223
 224 LTTNG_HIDDEN
 225 ssize_t lttng_event_rule_kprobe_create_from_payload(
 226                 struct lttng_payload_view *view,
 227                 struct lttng_event_rule **_event_rule)
 228 {
 229         ssize_t ret, offset = 0;
 230         enum lttng_event_rule_status status;
 231         const struct lttng_event_rule_kprobe_comm *kprobe_comm;
 232         const char *name;
 233         struct lttng_buffer_view current_buffer_view;
 234         struct lttng_event_rule *rule = NULL;
 235         struct lttng_event_rule_kprobe *kprobe = NULL;
 236         struct lttng_kernel_probe_location *location;
 237
 238         if (!_event_rule) {
 239                 ret = -1;
 240                 goto end;
 241         }
 242
 243         current_buffer_view = lttng_buffer_view_from_view(
 244                         &view->buffer, offset, sizeof(*kprobe_comm));
 245         if (!lttng_buffer_view_is_valid(&current_buffer_view)) {
 246                 ERR("Failed to initialize from malformed event rule kprobe: buffer too short to contain header.");
 247                 ret = -1;
 248                 goto end;
 249         }
 250
 251         kprobe_comm = (typeof(kprobe_comm)) current_buffer_view.data;
 252
 253         rule = lttng_event_rule_kprobe_create();
 254         if (!rule) {
 255                 ERR("Failed to create event rule kprobe.");
 256                 ret = -1;
 257                 goto end;
 258         }
 259
 260         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
 261
 262         /* Skip to payload */
 263         offset += current_buffer_view.size;
 264
 265         {
 266                 /* Map the name. */
 267                 struct lttng_payload_view current_payload_view =
 268                                 lttng_payload_view_from_view(view, offset,
 269                                                 kprobe_comm->name_len);
 270
 271                 if (!lttng_payload_view_is_valid(&current_payload_view)) {
 272                         ret = -1;
 273                         goto end;
 274                 }
 275
 276                 name = current_payload_view.buffer.data;
 277                 if (!lttng_buffer_view_contains_string(
 278                                 &current_payload_view.buffer, name,
 279                                 kprobe_comm->name_len)) {
 280                         ret = -1;
 281                         goto end;
 282                 }
 283         }
 284
 285         /* Skip after the name. */
 286         offset += kprobe_comm->name_len;
 287
 288         /* Map the kernel probe location. */
 289         {
 290                 struct lttng_payload_view current_payload_view =
 291                                 lttng_payload_view_from_view(view, offset,
 292                                                 kprobe_comm->location_len);
 293
 294                 if (!lttng_payload_view_is_valid(&current_payload_view)) {
 295                         ret = -1;
 296                         goto end;
 297                 }
 298
 299                 ret = lttng_kernel_probe_location_create_from_payload(
 300                                 &current_payload_view, &location);
 301                 if (ret < 0) {
 302                         ret = -1;
 303                         goto end;
 304                 }
 305         }
 306
 307         if (ret != kprobe_comm->location_len) {
 308                 ret = -1;
 309                 goto end;
 310         }
 311
 312         kprobe->location = location;
 313
 314         /* Skip after the location */
 315         offset += kprobe_comm->location_len;
 316
 317         status = lttng_event_rule_kprobe_set_name(rule, name);
 318         if (status != LTTNG_EVENT_RULE_STATUS_OK) {
 319                 ERR("Failed to set event rule kprobe name.");
 320                 ret = -1;
 321                 goto end;
 322         }
 323
 324         *_event_rule = rule;
 325         rule = NULL;
 326         ret = offset;
 327 end:
 328         lttng_event_rule_destroy(rule);
 329         return ret;
 330 }
 331
 332 enum lttng_event_rule_status lttng_event_rule_kprobe_set_location(
 333                 struct lttng_event_rule *rule,
 334                 const struct lttng_kernel_probe_location *location)
 335 {
 336         struct lttng_kernel_probe_location *location_copy = NULL;
 337         struct lttng_event_rule_kprobe *kprobe;
 338         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 339
 340         if (!rule || !IS_KPROBE_EVENT_RULE(rule) || !location) {
 341                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 342                 goto end;
 343         }
 344
 345         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
 346         location_copy = lttng_kernel_probe_location_copy(location);
 347         if (!location_copy) {
 348                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 349                 goto end;
 350         }
 351
 352         if (kprobe->location) {
 353                 lttng_kernel_probe_location_destroy(kprobe->location);
 354         }
 355
 356         kprobe->location = location_copy;
 357         location_copy = NULL;
 358 end:
 359         lttng_kernel_probe_location_destroy(location_copy);
 360         return status;
 361 }
 362
 363 enum lttng_event_rule_status lttng_event_rule_kprobe_get_location(
 364                 const struct lttng_event_rule *rule,
 365                 const struct lttng_kernel_probe_location **location)
 366 {
 367         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 368         struct lttng_event_rule_kprobe *kprobe;
 369
 370         if (!rule || !IS_KPROBE_EVENT_RULE(rule) || !location) {
 371                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 372                 goto end;
 373         }
 374
 375         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
 376         *location = kprobe->location;
 377
 378         if (!*location) {
 379                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 380                 goto end;
 381         }
 382
 383 end:
 384         return status;
 385 }
 386
 387 enum lttng_event_rule_status lttng_event_rule_kprobe_set_name(
 388                 struct lttng_event_rule *rule, const char *name)
 389 {
 390         char *name_copy = NULL;
 391         struct lttng_event_rule_kprobe *kprobe;
 392         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 393
 394         if (!rule || !IS_KPROBE_EVENT_RULE(rule) || !name ||
 395                         strlen(name) == 0) {
 396                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 397                 goto end;
 398         }
 399
 400         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
 401         name_copy = strdup(name);
 402         if (!name_copy) {
 403                 status = LTTNG_EVENT_RULE_STATUS_ERROR;
 404                 goto end;
 405         }
 406
 407         free(kprobe->name);
 408
 409         kprobe->name = name_copy;
 410         name_copy = NULL;
 411 end:
 412         return status;
 413 }
 414
 415 enum lttng_event_rule_status lttng_event_rule_kprobe_get_name(
 416                 const struct lttng_event_rule *rule, const char **name)
 417 {
 418         struct lttng_event_rule_kprobe *kprobe;
 419         enum lttng_event_rule_status status = LTTNG_EVENT_RULE_STATUS_OK;
 420
 421         if (!rule || !IS_KPROBE_EVENT_RULE(rule) || !name) {
 422                 status = LTTNG_EVENT_RULE_STATUS_INVALID;
 423                 goto end;
 424         }
 425
 426         kprobe = container_of(rule, struct lttng_event_rule_kprobe, parent);
 427         if (!kprobe->name) {
 428                 status = LTTNG_EVENT_RULE_STATUS_UNSET;
 429                 goto end;
 430         }
 431
 432         *name = kprobe->name;
 433 end:
 434         return status;
 435 }