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