src/bin/lttng-sessiond/event.c

   1 /*
   2  * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License, version 2 only,
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  16  */
  17
  18 #define _GNU_SOURCE
  19 #define _LGPL_SOURCE
  20 #include <errno.h>
  21 #include <urcu/list.h>
  22 #include <string.h>
  23
  24 #include <lttng/lttng.h>
  25 #include <common/error.h>
  26 #include <common/sessiond-comm/sessiond-comm.h>
  27
  28 #include "channel.h"
  29 #include "event.h"
  30 #include "kernel.h"
  31 #include "lttng-sessiond.h"
  32 #include "ust-ctl.h"
  33 #include "ust-app.h"
  34 #include "trace-kernel.h"
  35 #include "trace-ust.h"
  36
  37 /*
  38  * Add unique UST event based on the event name, filter bytecode and loglevel.
  39  */
  40 static void add_unique_ust_event(struct lttng_ht *ht,
  41                 struct ltt_ust_event *event)
  42 {
  43         struct cds_lfht_node *node_ptr;
  44         struct ltt_ust_ht_key key;
  45
  46         assert(ht);
  47         assert(ht->ht);
  48         assert(event);
  49
  50         key.name = event->attr.name;
  51         key.filter = (struct lttng_filter_bytecode *) event->filter;
  52         key.loglevel_type = event->attr.loglevel_type;
  53         key.loglevel_value = event->attr.loglevel;
  54         key.exclusion = event->exclusion;
  55
  56         node_ptr = cds_lfht_add_unique(ht->ht,
  57                         ht->hash_fct(event->node.key, lttng_ht_seed),
  58                         trace_ust_ht_match_event, &key, &event->node.node);
  59         assert(node_ptr == &event->node.node);
  60 }
  61
  62 /*
  63  * Disable kernel tracepoint event for a channel from the kernel session.
  64  */
  65 int event_kernel_disable_event(struct ltt_kernel_channel *kchan,
  66                 char *event_name)
  67 {
  68         int ret;
  69         struct ltt_kernel_event *kevent;
  70
  71         assert(kchan);
  72
  73         kevent = trace_kernel_get_event_by_name(event_name, kchan,
  74                         LTTNG_EVENT_ALL);
  75         if (kevent == NULL) {
  76                 ret = LTTNG_ERR_NO_EVENT;
  77                 goto error;
  78         }
  79
  80         ret = kernel_disable_event(kevent);
  81         if (ret < 0) {
  82                 ret = LTTNG_ERR_KERN_DISABLE_FAIL;
  83                 goto error;
  84         }
  85
  86         DBG("Kernel event %s disable for channel %s.",
  87                         kevent->event->name, kchan->channel->name);
  88
  89         ret = LTTNG_OK;
  90
  91 error:
  92         return ret;
  93 }
  94
  95 /*
  96  * Disable kernel tracepoint events for a channel from the kernel session.
  97  */
  98 int event_kernel_disable_event_type(struct ltt_kernel_channel *kchan,
  99                 enum lttng_event_type type)
 100 {
 101         int ret;
 102         struct ltt_kernel_event *kevent;
 103
 104         assert(kchan);
 105
 106         /* For each event in the kernel session */
 107         cds_list_for_each_entry(kevent, &kchan->events_list.head, list) {
 108                 if (type != LTTNG_EVENT_ALL && kevent->type != type)
 109                         continue;
 110                 ret = kernel_disable_event(kevent);
 111                 if (ret < 0) {
 112                         /* We continue disabling the rest */
 113                         continue;
 114                 }
 115         }
 116         ret = LTTNG_OK;
 117         return ret;
 118 }
 119
 120 /*
 121  * Disable all kernel event for a channel from the kernel session.
 122  */
 123 int event_kernel_disable_event_all(struct ltt_kernel_channel *kchan)
 124 {
 125         return event_kernel_disable_event_type(kchan, LTTNG_EVENT_ALL);
 126 }
 127
 128 /*
 129  * Enable kernel tracepoint event for a channel from the kernel session.
 130  * We own filter_expression and filter.
 131  */
 132 int event_kernel_enable_event(struct ltt_kernel_channel *kchan,
 133                 struct lttng_event *event, char *filter_expression,
 134                 struct lttng_filter_bytecode *filter)
 135 {
 136         int ret;
 137         struct ltt_kernel_event *kevent;
 138
 139         assert(kchan);
 140         assert(event);
 141
 142         kevent = trace_kernel_find_event(event->name, kchan,
 143                         event->type, filter);
 144         if (kevent == NULL) {
 145                 ret = kernel_create_event(event, kchan,
 146                         filter_expression, filter);
 147                 /* We have passed ownership */
 148                 filter_expression = NULL;
 149                 filter = NULL;
 150                 if (ret < 0) {
 151                         switch (-ret) {
 152                         case EEXIST:
 153                                 ret = LTTNG_ERR_KERN_EVENT_EXIST;
 154                                 break;
 155                         case ENOSYS:
 156                                 ret = LTTNG_ERR_KERN_EVENT_ENOSYS;
 157                                 break;
 158                         default:
 159                                 ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 160                                 break;
 161                         }
 162                         goto end;
 163                 }
 164         } else if (kevent->enabled == 0) {
 165                 ret = kernel_enable_event(kevent);
 166                 if (ret < 0) {
 167                         ret = LTTNG_ERR_KERN_ENABLE_FAIL;
 168                         goto end;
 169                 }
 170         } else {
 171                 /* At this point, the event is considered enabled */
 172                 ret = LTTNG_ERR_KERN_EVENT_EXIST;
 173                 goto end;
 174         }
 175
 176         ret = LTTNG_OK;
 177 end:
 178         free(filter_expression);
 179         free(filter);
 180         return ret;
 181 }
 182
 183 /*
 184  * ============================
 185  * UST : The Ultimate Frontier!
 186  * ============================
 187  */
 188
 189 /*
 190  * Enable UST tracepoint event for a channel from a UST session.
 191  * We own filter_expression, filter, and exclusion.
 192  */
 193 int event_ust_enable_tracepoint(struct ltt_ust_session *usess,
 194                 struct ltt_ust_channel *uchan, struct lttng_event *event,
 195                 char *filter_expression,
 196                 struct lttng_filter_bytecode *filter,
 197                 struct lttng_event_exclusion *exclusion,
 198                 bool internal_event)
 199 {
 200         int ret = LTTNG_OK, to_create = 0;
 201         struct ltt_ust_event *uevent;
 202
 203         assert(usess);
 204         assert(uchan);
 205         assert(event);
 206
 207         rcu_read_lock();
 208
 209         uevent = trace_ust_find_event(uchan->events, event->name, filter,
 210                         event->loglevel_type, event->loglevel, exclusion);
 211         if (!uevent) {
 212                 uevent = trace_ust_create_event(event, filter_expression,
 213                                 filter, exclusion, internal_event);
 214                 /* We have passed ownership */
 215                 filter_expression = NULL;
 216                 filter = NULL;
 217                 exclusion = NULL;
 218                 if (uevent == NULL) {
 219                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 220                         goto error;
 221                 }
 222
 223                 /* Valid to set it after the goto error since uevent is still NULL */
 224                 to_create = 1;
 225         }
 226
 227         if (uevent->enabled) {
 228                 /* It's already enabled so everything is OK */
 229                 ret = LTTNG_ERR_UST_EVENT_ENABLED;
 230                 goto end;
 231         }
 232
 233         uevent->enabled = 1;
 234
 235         if (to_create) {
 236                 /* Create event on all UST registered apps for session */
 237                 ret = ust_app_create_event_glb(usess, uchan, uevent);
 238         } else {
 239                 /* Enable event on all UST registered apps for session */
 240                 ret = ust_app_enable_event_glb(usess, uchan, uevent);
 241         }
 242
 243         if (ret < 0) {
 244                 if (ret == -LTTNG_UST_ERR_EXIST) {
 245                         ret = LTTNG_ERR_UST_EVENT_EXIST;
 246                         goto end;
 247                 } else {
 248                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 249                         goto error;
 250                 }
 251         }
 252
 253         if (to_create) {
 254                 /* Add ltt ust event to channel */
 255                 add_unique_ust_event(uchan->events, uevent);
 256         }
 257
 258         DBG("Event UST %s %s in channel %s", uevent->attr.name,
 259                         to_create ? "created" : "enabled", uchan->name);
 260
 261         ret = LTTNG_OK;
 262
 263 end:
 264         rcu_read_unlock();
 265         free(filter_expression);
 266         free(filter);
 267         free(exclusion);
 268         return ret;
 269
 270 error:
 271         /*
 272          * Only destroy event on creation time (not enabling time) because if the
 273          * event is found in the channel (to_create == 0), it means that at some
 274          * point the enable_event worked and it's thus valid to keep it alive.
 275          * Destroying it also implies that we also destroy it's shadow copy to sync
 276          * everyone up.
 277          */
 278         if (to_create) {
 279                 /* In this code path, the uevent was not added to the hash table */
 280                 trace_ust_destroy_event(uevent);
 281         }
 282         rcu_read_unlock();
 283         free(filter_expression);
 284         free(filter);
 285         free(exclusion);
 286         return ret;
 287 }
 288
 289 /*
 290  * Disable UST tracepoint of a channel from a UST session.
 291  */
 292 int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
 293                 struct ltt_ust_channel *uchan, char *event_name)
 294 {
 295         int ret;
 296         struct ltt_ust_event *uevent;
 297         struct lttng_ht_node_str *node;
 298         struct lttng_ht_iter iter;
 299         struct lttng_ht *ht;
 300
 301         assert(usess);
 302         assert(uchan);
 303         assert(event_name);
 304
 305         ht = uchan->events;
 306
 307         rcu_read_lock();
 308
 309         /*
 310          * We use a custom lookup since we need the iterator for the next_duplicate
 311          * call in the do while loop below.
 312          */
 313         cds_lfht_lookup(ht->ht, ht->hash_fct((void *) event_name, lttng_ht_seed),
 314                         trace_ust_ht_match_event_by_name, event_name, &iter.iter);
 315         node = lttng_ht_iter_get_node_str(&iter);
 316         if (node == NULL) {
 317                 DBG2("Trace UST event NOT found by name %s", event_name);
 318                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 319                 goto error;
 320         }
 321
 322         do {
 323                 uevent = caa_container_of(node, struct ltt_ust_event, node);
 324                 assert(uevent);
 325
 326                 if (uevent->enabled == 0) {
 327                         /* It's already disabled so everything is OK */
 328                         goto next;
 329                 }
 330
 331                 ret = ust_app_disable_event_glb(usess, uchan, uevent);
 332                 if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 333                         ret = LTTNG_ERR_UST_DISABLE_FAIL;
 334                         goto error;
 335                 }
 336                 uevent->enabled = 0;
 337
 338                 DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
 339                                 uchan->name);
 340
 341 next:
 342                 /* Get next duplicate event by name. */
 343                 cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name,
 344                                 event_name, &iter.iter);
 345                 node = lttng_ht_iter_get_node_str(&iter);
 346         } while (node);
 347
 348         ret = LTTNG_OK;
 349
 350 error:
 351         rcu_read_unlock();
 352         return ret;
 353 }
 354
 355 /*
 356  * Disable all UST tracepoints for a channel from a UST session.
 357  */
 358 int event_ust_disable_all_tracepoints(struct ltt_ust_session *usess,
 359                 struct ltt_ust_channel *uchan)
 360 {
 361         int ret, i, size, error = 0;
 362         struct lttng_ht_iter iter;
 363         struct ltt_ust_event *uevent = NULL;
 364         struct lttng_event *events = NULL;
 365
 366         assert(usess);
 367         assert(uchan);
 368
 369         rcu_read_lock();
 370
 371         /* Disabling existing events */
 372         cds_lfht_for_each_entry(uchan->events->ht, &iter.iter, uevent,
 373                         node.node) {
 374                 if (uevent->enabled == 1) {
 375                         ret = event_ust_disable_tracepoint(usess, uchan,
 376                                         uevent->attr.name);
 377                         if (ret < 0) {
 378                                 error = LTTNG_ERR_UST_DISABLE_FAIL;
 379                                 continue;
 380                         }
 381                 }
 382         }
 383
 384         /* Get all UST available events */
 385         size = ust_app_list_events(&events);
 386         if (size < 0) {
 387                 ret = LTTNG_ERR_UST_LIST_FAIL;
 388                 goto error;
 389         }
 390
 391         for (i = 0; i < size; i++) {
 392                 ret = event_ust_disable_tracepoint(usess, uchan,
 393                                 events[i].name);
 394                 if (ret < 0) {
 395                         /* Continue to disable the rest... */
 396                         error = LTTNG_ERR_UST_DISABLE_FAIL;
 397                         continue;
 398                 }
 399         }
 400
 401         ret = error ? error : LTTNG_OK;
 402 error:
 403         rcu_read_unlock();
 404         free(events);
 405         return ret;
 406 }
 407
 408 /*
 409  * Enable all agent event for a given UST session.
 410  *
 411  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 412  */
 413 int event_agent_enable_all(struct ltt_ust_session *usess,
 414                 struct agent *agt, struct lttng_event *event,
 415                 struct lttng_filter_bytecode *filter ,char *filter_expression)
 416 {
 417         int ret;
 418         struct agent_event *aevent;
 419         struct lttng_ht_iter iter;
 420
 421         assert(usess);
 422
 423         DBG("Event agent enabling ALL events for session %" PRIu64, usess->id);
 424
 425         /* Enable event on agent application through TCP socket. */
 426         ret = event_agent_enable(usess, agt, event, filter, filter_expression);
 427         if (ret != LTTNG_OK) {
 428                 goto error;
 429         }
 430
 431         /* Flag every event that they are now enabled. */
 432         rcu_read_lock();
 433         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 434                         node.node) {
 435                 aevent->enabled = 1;
 436         }
 437         rcu_read_unlock();
 438
 439         ret = LTTNG_OK;
 440
 441 error:
 442         return ret;
 443 }
 444
 445 /*
 446  * Enable a single agent event for a given UST session.
 447  *
 448  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 449  */
 450 int event_agent_enable(struct ltt_ust_session *usess,
 451                 struct agent *agt, struct lttng_event *event,
 452                 struct lttng_filter_bytecode *filter,
 453                 char *filter_expression)
 454 {
 455         int ret, created = 0;
 456         struct agent_event *aevent;
 457
 458         assert(usess);
 459         assert(event);
 460         assert(agt);
 461
 462         DBG("Event agent enabling %s for session %" PRIu64 " with loglevel type %d "
 463                         ", loglevel %d and filter \"%s\"", event->name,
 464                         usess->id, event->loglevel_type, event->loglevel,
 465                         filter_expression ? filter_expression : "NULL");
 466
 467         aevent = agent_find_event(event->name, event->loglevel_type,
 468                 event->loglevel, agt);
 469         if (!aevent) {
 470                 aevent = agent_create_event(event->name, event->loglevel_type,
 471                                 event->loglevel, filter,
 472                                 filter_expression);
 473                 if (!aevent) {
 474                         ret = LTTNG_ERR_NOMEM;
 475                         goto error;
 476                 }
 477                 created = 1;
 478         }
 479
 480         /* Already enabled? */
 481         if (aevent->enabled) {
 482                 goto end;
 483         }
 484
 485         ret = agent_enable_event(aevent, agt->domain);
 486         if (ret != LTTNG_OK) {
 487                 goto error;
 488         }
 489
 490         /* If the event was created prior to the enable, add it to the domain. */
 491         if (created) {
 492                 agent_add_event(aevent, agt);
 493         }
 494
 495 end:
 496         return LTTNG_OK;
 497
 498 error:
 499         if (created) {
 500                 agent_destroy_event(aevent);
 501         }
 502         return ret;
 503 }
 504
 505 /*
 506  * Return the agent default event name to use by testing if the process is root
 507  * or not. Return NULL on error.
 508  */
 509 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain)
 510 {
 511         const char *default_event_name = NULL;
 512
 513         switch (domain) {
 514         case LTTNG_DOMAIN_LOG4J:
 515                 if (is_root) {
 516                         default_event_name = DEFAULT_SYS_LOG4J_EVENT_NAME;
 517                 } else {
 518                         default_event_name = DEFAULT_USER_LOG4J_EVENT_NAME;
 519                 }
 520                 break;
 521         case LTTNG_DOMAIN_JUL:
 522                 if (is_root) {
 523                         default_event_name = DEFAULT_SYS_JUL_EVENT_NAME;
 524                 } else {
 525                         default_event_name = DEFAULT_USER_JUL_EVENT_NAME;
 526                 }
 527                 break;
 528         case LTTNG_DOMAIN_PYTHON:
 529                 default_event_name = DEFAULT_PYTHON_EVENT_NAME;
 530                 break;
 531         default:
 532                 assert(0);
 533         }
 534
 535         return default_event_name;
 536 }
 537
 538 /*
 539  * Disable a given agent event for a given UST session.
 540  *
 541  * Must be called with the RCU read lock held.
 542  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 543  */
 544 static int event_agent_disable_one(struct ltt_ust_session *usess,
 545                 struct agent *agt, struct agent_event *aevent)
 546 {
 547         int ret;
 548         struct ltt_ust_event *uevent = NULL;
 549         struct ltt_ust_channel *uchan = NULL;
 550         const char *ust_event_name, *ust_channel_name;
 551
 552         assert(agt);
 553         assert(usess);
 554         assert(aevent);
 555
 556         DBG("Event agent disabling %s (loglevel type %d, loglevel value %d) for session %" PRIu64,
 557                 aevent->name, aevent->loglevel_type, aevent->loglevel_value,
 558                 usess->id);
 559
 560         /* Already disabled? */
 561         if (!aevent->enabled) {
 562                 goto end;
 563         }
 564
 565         if (agt->domain == LTTNG_DOMAIN_JUL) {
 566                 ust_channel_name = DEFAULT_JUL_CHANNEL_NAME;
 567         } else if (agt->domain == LTTNG_DOMAIN_LOG4J) {
 568                 ust_channel_name = DEFAULT_LOG4J_CHANNEL_NAME;
 569         } else if (agt->domain == LTTNG_DOMAIN_PYTHON) {
 570                 ust_channel_name = DEFAULT_PYTHON_CHANNEL_NAME;
 571         } else {
 572                 ret = LTTNG_ERR_INVALID;
 573                 goto error;
 574         }
 575
 576         /*
 577          * Disable it on the UST side. First get the channel reference then find
 578          * the event and finally disable it.
 579          */
 580         uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 581                         (char *) ust_channel_name);
 582         if (!uchan) {
 583                 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 584                 goto error;
 585         }
 586
 587         ust_event_name = event_get_default_agent_ust_name(agt->domain);
 588         if (!ust_event_name) {
 589                 ret = LTTNG_ERR_FATAL;
 590                 goto error;
 591         }
 592
 593         /*
 594          * Agent UST event has its loglevel type forced to
 595          * LTTNG_UST_LOGLEVEL_ALL. The actual loglevel type/value filtering
 596          * happens thanks to an UST filter. The following -1 is actually
 597          * ignored since the type is LTTNG_UST_LOGLEVEL_ALL.
 598          */
 599         uevent = trace_ust_find_event(uchan->events, (char *) ust_event_name,
 600                         aevent->filter, LTTNG_UST_LOGLEVEL_ALL, -1, NULL);
 601         /* If the agent event exists, it must be available on the UST side. */
 602         assert(uevent);
 603
 604         ret = ust_app_disable_event_glb(usess, uchan, uevent);
 605         if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 606                 ret = LTTNG_ERR_UST_DISABLE_FAIL;
 607                 goto error;
 608         }
 609
 610         /*
 611          * Flag event that it's disabled so the shadow copy on the ust app side
 612          * will disable it if an application shows up.
 613          */
 614         uevent->enabled = 0;
 615
 616         ret = agent_disable_event(aevent, agt->domain);
 617         if (ret != LTTNG_OK) {
 618                 goto error;
 619         }
 620
 621 end:
 622         return LTTNG_OK;
 623
 624 error:
 625         return ret;
 626 }
 627
 628 /*
 629  * Disable all agent events matching a given name for a given UST session.
 630  *
 631  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 632  */
 633 int event_agent_disable(struct ltt_ust_session *usess, struct agent *agt,
 634                 char *event_name)
 635 {
 636         int ret = LTTNG_OK;
 637         struct agent_event *aevent;
 638         struct lttng_ht_iter iter;
 639         struct lttng_ht_node_str *node;
 640
 641         assert(agt);
 642         assert(usess);
 643         assert(event_name);
 644
 645         DBG("Event agent disabling %s (all loglevels) for session %" PRIu64, event_name, usess->id);
 646
 647         rcu_read_lock();
 648         agent_find_events_by_name(event_name, agt, &iter);
 649         node = lttng_ht_iter_get_node_str(&iter);
 650
 651         if (node == NULL) {
 652                 DBG2("Event agent NOT found by name %s", event_name);
 653                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 654                 goto end;
 655         }
 656
 657         do {
 658                 aevent = caa_container_of(node, struct agent_event, node);
 659                 ret = event_agent_disable_one(usess, agt, aevent);
 660
 661                 if (ret != LTTNG_OK) {
 662                         goto end;
 663                 }
 664
 665                 /* Get next duplicate agent event by name. */
 666                 agent_event_next_duplicate(event_name, agt, &iter);
 667                 node = lttng_ht_iter_get_node_str(&iter);
 668         } while (node);
 669 end:
 670         rcu_read_unlock();
 671         return ret;
 672 }
 673 /*
 674  * Disable all agent event for a given UST session.
 675  *
 676  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 677  */
 678 int event_agent_disable_all(struct ltt_ust_session *usess,
 679                 struct agent *agt)
 680 {
 681         int ret;
 682         struct agent_event *aevent;
 683         struct lttng_ht_iter iter;
 684
 685         assert(agt);
 686         assert(usess);
 687
 688         /*
 689          * Disable event on agent application. Continue to disable all other events
 690          * if the * event is not found.
 691          */
 692         ret = event_agent_disable(usess, agt, "*");
 693         if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_NOT_FOUND) {
 694                 goto error;
 695         }
 696
 697         /* Disable every event. */
 698         rcu_read_lock();
 699         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 700                         node.node) {
 701                 if (!aevent->enabled) {
 702                         continue;
 703                 }
 704
 705                 ret = event_agent_disable(usess, agt, aevent->name);
 706                 if (ret != LTTNG_OK) {
 707                         goto error_unlock;
 708                 }
 709         }
 710         ret = LTTNG_OK;
 711
 712 error_unlock:
 713         rcu_read_unlock();
 714 error:
 715         return ret;
 716 }