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 = 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 {
 199         int ret = LTTNG_OK, to_create = 0;
 200         struct ltt_ust_event *uevent;
 201
 202         assert(usess);
 203         assert(uchan);
 204         assert(event);
 205
 206         rcu_read_lock();
 207
 208         uevent = trace_ust_find_event(uchan->events, event->name, filter,
 209                         event->loglevel, exclusion);
 210         if (uevent == NULL) {
 211                 uevent = trace_ust_create_event(event, filter_expression,
 212                         filter, exclusion);
 213                 /* We have passed ownership */
 214                 filter_expression = NULL;
 215                 filter = NULL;
 216                 exclusion = NULL;
 217                 if (uevent == NULL) {
 218                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 219                         goto error;
 220                 }
 221
 222                 /* Valid to set it after the goto error since uevent is still NULL */
 223                 to_create = 1;
 224         }
 225
 226         if (uevent->enabled) {
 227                 /* It's already enabled so everything is OK */
 228                 ret = LTTNG_ERR_UST_EVENT_ENABLED;
 229                 goto end;
 230         }
 231
 232         uevent->enabled = 1;
 233
 234         if (to_create) {
 235                 /* Create event on all UST registered apps for session */
 236                 ret = ust_app_create_event_glb(usess, uchan, uevent);
 237         } else {
 238                 /* Enable event on all UST registered apps for session */
 239                 ret = ust_app_enable_event_glb(usess, uchan, uevent);
 240         }
 241
 242         if (ret < 0) {
 243                 if (ret == -LTTNG_UST_ERR_EXIST) {
 244                         ret = LTTNG_ERR_UST_EVENT_EXIST;
 245                         goto end;
 246                 } else {
 247                         ret = LTTNG_ERR_UST_ENABLE_FAIL;
 248                         goto error;
 249                 }
 250         }
 251
 252         if (to_create) {
 253                 /* Add ltt ust event to channel */
 254                 add_unique_ust_event(uchan->events, uevent);
 255         }
 256
 257         DBG("Event UST %s %s in channel %s", uevent->attr.name,
 258                         to_create ? "created" : "enabled", uchan->name);
 259
 260         ret = LTTNG_OK;
 261
 262 end:
 263         rcu_read_unlock();
 264         free(filter_expression);
 265         free(filter);
 266         free(exclusion);
 267         return ret;
 268
 269 error:
 270         /*
 271          * Only destroy event on creation time (not enabling time) because if the
 272          * event is found in the channel (to_create == 0), it means that at some
 273          * point the enable_event worked and it's thus valid to keep it alive.
 274          * Destroying it also implies that we also destroy it's shadow copy to sync
 275          * everyone up.
 276          */
 277         if (to_create) {
 278                 /* In this code path, the uevent was not added to the hash table */
 279                 trace_ust_destroy_event(uevent);
 280         }
 281         rcu_read_unlock();
 282         free(filter_expression);
 283         free(filter);
 284         free(exclusion);
 285         return ret;
 286 }
 287
 288 /*
 289  * Disable UST tracepoint of a channel from a UST session.
 290  */
 291 int event_ust_disable_tracepoint(struct ltt_ust_session *usess,
 292                 struct ltt_ust_channel *uchan, char *event_name)
 293 {
 294         int ret;
 295         struct ltt_ust_event *uevent;
 296         struct lttng_ht_node_str *node;
 297         struct lttng_ht_iter iter;
 298         struct lttng_ht *ht;
 299
 300         assert(usess);
 301         assert(uchan);
 302         assert(event_name);
 303
 304         ht = uchan->events;
 305
 306         rcu_read_lock();
 307
 308         /*
 309          * We use a custom lookup since we need the iterator for the next_duplicate
 310          * call in the do while loop below.
 311          */
 312         cds_lfht_lookup(ht->ht, ht->hash_fct((void *) event_name, lttng_ht_seed),
 313                         trace_ust_ht_match_event_by_name, event_name, &iter.iter);
 314         node = lttng_ht_iter_get_node_str(&iter);
 315         if (node == NULL) {
 316                 DBG2("Trace UST event NOT found by name %s", event_name);
 317                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 318                 goto error;
 319         }
 320
 321         do {
 322                 uevent = caa_container_of(node, struct ltt_ust_event, node);
 323                 assert(uevent);
 324
 325                 if (uevent->enabled == 0) {
 326                         /* It's already disabled so everything is OK */
 327                         goto next;
 328                 }
 329
 330                 ret = ust_app_disable_event_glb(usess, uchan, uevent);
 331                 if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 332                         ret = LTTNG_ERR_UST_DISABLE_FAIL;
 333                         goto error;
 334                 }
 335                 uevent->enabled = 0;
 336
 337                 DBG2("Event UST %s disabled in channel %s", uevent->attr.name,
 338                                 uchan->name);
 339
 340 next:
 341                 /* Get next duplicate event by name. */
 342                 cds_lfht_next_duplicate(ht->ht, trace_ust_ht_match_event_by_name,
 343                                 event_name, &iter.iter);
 344                 node = lttng_ht_iter_get_node_str(&iter);
 345         } while (node);
 346
 347         ret = LTTNG_OK;
 348
 349 error:
 350         rcu_read_unlock();
 351         return ret;
 352 }
 353
 354 /*
 355  * Enable all agent event for a given UST session.
 356  *
 357  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 358  */
 359 int event_agent_enable_all(struct ltt_ust_session *usess,
 360                 struct agent *agt, struct lttng_event *event,
 361                 struct lttng_filter_bytecode *filter)
 362 {
 363         int ret;
 364         struct agent_event *aevent;
 365         struct lttng_ht_iter iter;
 366
 367         assert(usess);
 368
 369         DBG("Event agent enabling ALL events for session %" PRIu64, usess->id);
 370
 371         /* Enable event on agent application through TCP socket. */
 372         ret = event_agent_enable(usess, agt, event, filter);
 373         if (ret != LTTNG_OK) {
 374                 goto error;
 375         }
 376
 377         /* Flag every event that they are now enabled. */
 378         rcu_read_lock();
 379         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 380                         node.node) {
 381                 aevent->enabled = 1;
 382         }
 383         rcu_read_unlock();
 384
 385         ret = LTTNG_OK;
 386
 387 error:
 388         return ret;
 389 }
 390
 391 /*
 392  * Enable a single agent event for a given UST session.
 393  *
 394  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 395  */
 396 int event_agent_enable(struct ltt_ust_session *usess,
 397                 struct agent *agt, struct lttng_event *event,
 398                 struct lttng_filter_bytecode *filter)
 399 {
 400         int ret, created = 0;
 401         struct agent_event *aevent;
 402
 403         assert(usess);
 404         assert(event);
 405         assert(agt);
 406
 407         DBG("Event agent enabling %s for session %" PRIu64 " with loglevel type %d "
 408                         "and loglevel %d", event->name, usess->id, event->loglevel_type,
 409                         event->loglevel);
 410
 411         aevent = agent_find_event(event->name, event->loglevel, agt);
 412         if (!aevent) {
 413                 aevent = agent_create_event(event->name, filter);
 414                 if (!aevent) {
 415                         ret = LTTNG_ERR_NOMEM;
 416                         goto error;
 417                 }
 418                 aevent->loglevel = event->loglevel;
 419                 aevent->loglevel_type = event->loglevel_type;
 420                 created = 1;
 421         }
 422
 423         /* Already enabled? */
 424         if (aevent->enabled) {
 425                 goto end;
 426         }
 427
 428         ret = agent_enable_event(aevent, agt->domain);
 429         if (ret != LTTNG_OK) {
 430                 goto error;
 431         }
 432
 433         /* If the event was created prior to the enable, add it to the domain. */
 434         if (created) {
 435                 agent_add_event(aevent, agt);
 436         }
 437
 438 end:
 439         return LTTNG_OK;
 440
 441 error:
 442         if (created) {
 443                 agent_destroy_event(aevent);
 444         }
 445         return ret;
 446 }
 447
 448 /*
 449  * Return the default event name associated with the provided UST domain. Return
 450  * NULL on error.
 451  */
 452 const char *event_get_default_agent_ust_name(enum lttng_domain_type domain)
 453 {
 454         const char *default_event_name = NULL;
 455
 456         switch (domain) {
 457         case LTTNG_DOMAIN_LOG4J:
 458                 default_event_name = DEFAULT_LOG4J_EVENT_NAME;
 459                 break;
 460         case LTTNG_DOMAIN_JUL:
 461                 default_event_name = DEFAULT_JUL_EVENT_NAME;
 462                 break;
 463         case LTTNG_DOMAIN_PYTHON:
 464                 default_event_name = DEFAULT_PYTHON_EVENT_NAME;
 465                 break;
 466         default:
 467                 assert(0);
 468         }
 469
 470         return default_event_name;
 471 }
 472
 473 /*
 474  * Disable a single agent event for a given UST session.
 475  *
 476  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 477  */
 478 int event_agent_disable(struct ltt_ust_session *usess, struct agent *agt,
 479                 char *event_name)
 480 {
 481         int ret;
 482         struct agent_event *aevent;
 483         struct ltt_ust_event *uevent = NULL;
 484         struct ltt_ust_channel *uchan = NULL;
 485         const char *ust_event_name, *ust_channel_name;
 486
 487         assert(agt);
 488         assert(usess);
 489         assert(event_name);
 490
 491         DBG("Event agent disabling %s for session %" PRIu64, event_name, usess->id);
 492
 493         aevent = agent_find_event_by_name(event_name, agt);
 494         if (!aevent) {
 495                 ret = LTTNG_ERR_UST_EVENT_NOT_FOUND;
 496                 goto error;
 497         }
 498
 499         /* Already disabled? */
 500         if (!aevent->enabled) {
 501                 goto end;
 502         }
 503
 504         if (agt->domain == LTTNG_DOMAIN_JUL) {
 505                 ust_channel_name = DEFAULT_JUL_CHANNEL_NAME;
 506         } else if (agt->domain == LTTNG_DOMAIN_LOG4J) {
 507                 ust_channel_name = DEFAULT_LOG4J_CHANNEL_NAME;
 508         } else if (agt->domain == LTTNG_DOMAIN_PYTHON) {
 509                 ust_channel_name = DEFAULT_PYTHON_CHANNEL_NAME;
 510         } else {
 511                 ret = LTTNG_ERR_INVALID;
 512                 goto error;
 513         }
 514
 515         /*
 516          * Disable it on the UST side. First get the channel reference then find
 517          * the event and finally disable it.
 518          */
 519         uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
 520                         (char *) ust_channel_name);
 521         if (!uchan) {
 522                 ret = LTTNG_ERR_UST_CHAN_NOT_FOUND;
 523                 goto error;
 524         }
 525
 526         ust_event_name = event_get_default_agent_ust_name(agt->domain);
 527         if (!ust_event_name) {
 528                 ret = LTTNG_ERR_FATAL;
 529                 goto error;
 530         }
 531
 532         /*
 533          * The loglevel is hardcoded with 0 here since the agent ust event is set
 534          * with the loglevel type to ALL thus the loglevel stays 0. The event's
 535          * filter is the one handling the loglevel for agent.
 536          */
 537         uevent = trace_ust_find_event(uchan->events, (char *) ust_event_name,
 538                         aevent->filter, 0, NULL);
 539         /* If the agent event exists, it must be available on the UST side. */
 540         assert(uevent);
 541
 542         ret = ust_app_disable_event_glb(usess, uchan, uevent);
 543         if (ret < 0 && ret != -LTTNG_UST_ERR_EXIST) {
 544                 ret = LTTNG_ERR_UST_DISABLE_FAIL;
 545                 goto error;
 546         }
 547
 548         /*
 549          * Flag event that it's disabled so the shadow copy on the ust app side
 550          * will disable it if an application shows up.
 551          */
 552         uevent->enabled = 0;
 553
 554         ret = agent_disable_event(aevent, agt->domain);
 555         if (ret != LTTNG_OK) {
 556                 goto error;
 557         }
 558
 559 end:
 560         return LTTNG_OK;
 561
 562 error:
 563         return ret;
 564 }
 565 /*
 566  * Disable all agent event for a given UST session.
 567  *
 568  * Return LTTNG_OK on success or else a LTTNG_ERR* code.
 569  */
 570 int event_agent_disable_all(struct ltt_ust_session *usess,
 571                 struct agent *agt)
 572 {
 573         int ret;
 574         struct agent_event *aevent;
 575         struct lttng_ht_iter iter;
 576
 577         assert(agt);
 578         assert(usess);
 579
 580         /*
 581          * Disable event on agent application. Continue to disable all other events
 582          * if the * event is not found.
 583          */
 584         ret = event_agent_disable(usess, agt, "*");
 585         if (ret != LTTNG_OK && ret != LTTNG_ERR_UST_EVENT_NOT_FOUND) {
 586                 goto error;
 587         }
 588
 589         /* Flag every event that they are now enabled. */
 590         rcu_read_lock();
 591         cds_lfht_for_each_entry(agt->events->ht, &iter.iter, aevent,
 592                         node.node) {
 593                 if (!aevent->enabled) {
 594                         continue;
 595                 }
 596
 597                 ret = event_agent_disable(usess, agt, aevent->name);
 598                 if (ret != LTTNG_OK) {
 599                         rcu_read_unlock();
 600                         goto error;
 601                 }
 602         }
 603         rcu_read_unlock();
 604
 605         ret = LTTNG_OK;
 606
 607 error:
 608         return ret;
 609 }