src/bin/lttng-sessiond/ust-app.h

   1 /*
   2  * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
   3  * Copyright (C) 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 #ifndef _LTT_UST_APP_H
  10 #define _LTT_UST_APP_H
  11
  12 #include <stdint.h>
  13
  14 #include <common/index-allocator.h>
  15 #include <common/uuid.h>
  16
  17 #include "trace-ust.h"
  18 #include "ust-registry.h"
  19 #include "session.h"
  20
  21 #define UST_APP_EVENT_LIST_SIZE 32
  22
  23 /* Process name (short). */
  24 #define UST_APP_PROCNAME_LEN    16
  25
  26 struct lttng_bytecode;
  27 struct lttng_ust_filter_bytecode;
  28
  29 extern int ust_consumerd64_fd, ust_consumerd32_fd;
  30
  31 /*
  32  * Object used to close the notify socket in a call_rcu(). Since the
  33  * application might not be found, we need an independant object containing the
  34  * notify socket fd.
  35  */
  36 struct ust_app_notify_sock_obj {
  37         int fd;
  38         struct rcu_head head;
  39 };
  40
  41 struct ust_app_ht_key {
  42         const char *name;
  43         const struct lttng_bytecode *filter;
  44         enum lttng_ust_loglevel_type loglevel_type;
  45         const struct lttng_event_exclusion *exclusion;
  46 };
  47
  48 /*
  49  * Application registration data structure.
  50  */
  51 struct ust_register_msg {
  52         enum ustctl_socket_type type;
  53         uint32_t major;
  54         uint32_t minor;
  55         uint32_t abi_major;
  56         uint32_t abi_minor;
  57         pid_t pid;
  58         pid_t ppid;
  59         uid_t uid;
  60         gid_t gid;
  61         uint32_t bits_per_long;
  62         uint32_t uint8_t_alignment;
  63         uint32_t uint16_t_alignment;
  64         uint32_t uint32_t_alignment;
  65         uint32_t uint64_t_alignment;
  66         uint32_t long_alignment;
  67         int byte_order;         /* BIG_ENDIAN or LITTLE_ENDIAN */
  68         char name[LTTNG_UST_ABI_PROCNAME_LEN];
  69 };
  70
  71 /*
  72  * Global applications HT used by the session daemon. This table is indexed by
  73  * PID using the pid_n node and pid value of an ust_app.
  74  */
  75 extern struct lttng_ht *ust_app_ht;
  76
  77 /*
  78  * Global applications HT used by the session daemon. This table is indexed by
  79  * socket using the sock_n node and sock value of an ust_app.
  80  *
  81  * The 'sock' in question here is the 'command' socket.
  82  */
  83 extern struct lttng_ht *ust_app_ht_by_sock;
  84
  85 /*
  86  * Global applications HT used by the session daemon. This table is indexed by
  87  * socket using the notify_sock_n node and notify_sock value of an ust_app.
  88  */
  89 extern struct lttng_ht *ust_app_ht_by_notify_sock;
  90
  91 /* Stream list containing ust_app_stream. */
  92 struct ust_app_stream_list {
  93         unsigned int count;
  94         struct cds_list_head head;
  95 };
  96
  97 struct ust_app_ctx {
  98         int handle;
  99         struct lttng_ust_context_attr ctx;
 100         struct lttng_ust_object_data *obj;
 101         struct lttng_ht_node_ulong node;
 102         struct cds_list_head list;
 103 };
 104
 105 struct ust_app_event {
 106         int enabled;
 107         int handle;
 108         struct lttng_ust_object_data *obj;
 109         struct lttng_ust_event attr;
 110         char name[LTTNG_UST_SYM_NAME_LEN];
 111         struct lttng_ht_node_str node;
 112         struct lttng_bytecode *filter;
 113         struct lttng_event_exclusion *exclusion;
 114 };
 115
 116 struct ust_app_token_event_rule {
 117         int enabled;
 118         uint64_t error_counter_index;
 119         int handle;
 120         struct lttng_ust_object_data *obj;
 121         struct lttng_trigger *trigger;
 122         uint64_t token;
 123         struct lttng_ht_node_u64 node;
 124         /* The event_rule object own this pointer */
 125         const struct lttng_bytecode *filter;
 126         /* The event_rule object own this pointer */
 127         struct lttng_event_exclusion *exclusion;
 128 };
 129
 130 struct ust_app_stream {
 131         int handle;
 132         char pathname[PATH_MAX];
 133         /* Format is %s_%d respectively channel name and CPU number. */
 134         char name[DEFAULT_STREAM_NAME_LEN];
 135         struct lttng_ust_object_data *obj;
 136         /* Using a list of streams to keep order. */
 137         struct cds_list_head list;
 138 };
 139
 140 struct ust_app_channel {
 141         int enabled;
 142         int handle;
 143         /* Channel and streams were sent to the UST tracer. */
 144         int is_sent;
 145         /*
 146          * Unique key used to identify the channel on the consumer side.
 147          * 0 is a reserved 'invalid' value used to indicate that the consumer
 148          * does not know about this channel (i.e. an error occurred).
 149          */
 150         uint64_t key;
 151         /* Id of the tracing channel set on creation. */
 152         uint64_t tracing_channel_id;
 153         /* Number of stream that this channel is expected to receive. */
 154         unsigned int expected_stream_count;
 155         char name[LTTNG_UST_SYM_NAME_LEN];
 156         struct lttng_ust_object_data *obj;
 157         struct ustctl_consumer_channel_attr attr;
 158         struct ust_app_stream_list streams;
 159         /* Session pointer that owns this object. */
 160         struct ust_app_session *session;
 161         /*
 162          * Contexts are kept in a hash table for fast lookup and in an ordered list
 163          * so we are able to enable them on the tracer side in the same order the
 164          * user added them.
 165          */
 166         struct lttng_ht *ctx;
 167         struct cds_list_head ctx_list;
 168
 169         struct lttng_ht *events;
 170         uint64_t tracefile_size;
 171         uint64_t tracefile_count;
 172         uint64_t monitor_timer_interval;
 173         /*
 174          * Node indexed by channel name in the channels' hash table of a session.
 175          */
 176         struct lttng_ht_node_str node;
 177         /*
 178          * Node indexed by UST channel object descriptor (handle). Stored in the
 179          * ust_objd hash table in the ust_app object.
 180          */
 181         struct lttng_ht_node_ulong ust_objd_node;
 182         /* For delayed reclaim */
 183         struct rcu_head rcu_head;
 184 };
 185
 186 struct ust_app_session {
 187         /*
 188          * Lock protecting this session's ust app interaction. Held
 189          * across command send/recv to/from app. Never nests within the
 190          * session registry lock.
 191          */
 192         pthread_mutex_t lock;
 193
 194         int enabled;
 195         /* started: has the session been in started state at any time ? */
 196         int started;  /* allows detection of start vs restart. */
 197         int handle;   /* used has unique identifier for app session */
 198
 199         bool deleted;   /* Session deleted flag. Check with lock held. */
 200
 201         /*
 202          * Tracing session ID. Multiple ust app session can have the same tracing
 203          * session id making this value NOT unique to the object.
 204          */
 205         uint64_t tracing_id;
 206         uint64_t id;    /* Unique session identifier */
 207         struct lttng_ht *channels; /* Registered channels */
 208         struct lttng_ht_node_u64 node;
 209         /*
 210          * Node indexed by UST session object descriptor (handle). Stored in the
 211          * ust_sessions_objd hash table in the ust_app object.
 212          */
 213         struct lttng_ht_node_ulong ust_objd_node;
 214         /* Starts with 'ust'; no leading slash. */
 215         char path[PATH_MAX];
 216         /* UID/GID of the application owning the session */
 217         struct lttng_credentials real_credentials;
 218         /* Effective UID and GID. Same as the tracing session. */
 219         struct lttng_credentials effective_credentials;
 220         struct cds_list_head teardown_node;
 221         /*
 222          * Once at least *one* session is created onto the application, the
 223          * corresponding consumer is set so we can use it on unregistration.
 224          */
 225         struct consumer_output *consumer;
 226         enum lttng_buffer_type buffer_type;
 227         /* ABI of the session. Same value as the application. */
 228         uint32_t bits_per_long;
 229         /* For delayed reclaim */
 230         struct rcu_head rcu_head;
 231         /* If the channel's streams have to be outputed or not. */
 232         unsigned int output_traces;
 233         unsigned int live_timer_interval;       /* usec */
 234
 235         /* Metadata channel attributes. */
 236         struct ustctl_consumer_channel_attr metadata_attr;
 237
 238         char root_shm_path[PATH_MAX];
 239         char shm_path[PATH_MAX];
 240 };
 241
 242 /*
 243  * Registered traceable applications. Libust registers to the session daemon
 244  * and a linked list is kept of all running traceable app.
 245  */
 246 struct ust_app {
 247         int sock;
 248         pthread_mutex_t sock_lock;      /* Protects sock protocol. */
 249
 250         int notify_sock;
 251         pid_t pid;
 252         pid_t ppid;
 253         uid_t uid;           /* User ID that owns the apps */
 254         gid_t gid;           /* Group ID that owns the apps */
 255
 256         /* App ABI */
 257         uint32_t bits_per_long;
 258         uint32_t uint8_t_alignment;
 259         uint32_t uint16_t_alignment;
 260         uint32_t uint32_t_alignment;
 261         uint32_t uint64_t_alignment;
 262         uint32_t long_alignment;
 263         int byte_order;         /* BIG_ENDIAN or LITTLE_ENDIAN */
 264
 265         int compatible; /* If the lttng-ust tracer version does not match the
 266                                            supported version of the session daemon, this flag is
 267                                            set to 0 (NOT compatible) else 1. */
 268         struct lttng_ust_tracer_version version;
 269         uint32_t v_major;    /* Version major number */
 270         uint32_t v_minor;    /* Version minor number */
 271         /* Extra for the NULL byte. */
 272         char name[UST_APP_PROCNAME_LEN + 1];
 273         /* Type of buffer this application uses. */
 274         enum lttng_buffer_type buffer_type;
 275         struct lttng_ht *sessions;
 276         struct lttng_ht_node_ulong pid_n;
 277         struct lttng_ht_node_ulong sock_n;
 278         struct lttng_ht_node_ulong notify_sock_n;
 279         /*
 280          * This is a list of ust app session that, once the app is going into
 281          * teardown mode, in the RCU call, each node in this list is removed and
 282          * deleted.
 283          *
 284          * Element of the list are added when an application unregisters after each
 285          * ht_del of ust_app_session associated to this app. This list is NOT used
 286          * when a session is destroyed.
 287          */
 288         struct cds_list_head teardown_head;
 289         /*
 290          * Hash table containing ust_app_channel indexed by channel objd.
 291          */
 292         struct lttng_ht *ust_objd;
 293         /*
 294          * Hash table containing ust_app_session indexed by objd.
 295          */
 296         struct lttng_ht *ust_sessions_objd;
 297
 298         /*
 299          * If this application is of the agent domain and this is non negative then
 300          * a lookup MUST be done to acquire a read side reference to the
 301          * corresponding agent app object. If the lookup fails, this should be set
 302          * to a negative value indicating that the agent application is gone.
 303          */
 304         int agent_app_sock;
 305         /*
 306          * Time at which the app is registred.
 307          * Used for path creation
 308          */
 309         time_t registration_time;
 310         /*
 311          * Trigger
 312          */
 313         struct {
 314                 struct lttng_ust_object_data *handle;
 315                 struct lttng_pipe *trigger_event_pipe;
 316         } token_communication;
 317         struct lttng_ht *tokens_ht;
 318 };
 319
 320 #ifdef HAVE_LIBLTTNG_UST_CTL
 321
 322 int ust_app_register(struct ust_register_msg *msg, int sock);
 323 int ust_app_register_done(struct ust_app *app);
 324 int ust_app_version(struct ust_app *app);
 325 void ust_app_unregister(int sock);
 326 int ust_app_start_trace_all(struct ltt_ust_session *usess);
 327 int ust_app_stop_trace_all(struct ltt_ust_session *usess);
 328 int ust_app_destroy_trace_all(struct ltt_ust_session *usess);
 329 int ust_app_list_events(struct lttng_event **events);
 330 int ust_app_list_event_fields(struct lttng_event_field **fields);
 331 int ust_app_create_event_glb(struct ltt_ust_session *usess,
 332                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent);
 333 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
 334                 struct ltt_ust_channel *uchan);
 335 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
 336                 struct ltt_ust_channel *uchan);
 337 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
 338                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent);
 339 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
 340                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent);
 341 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
 342                 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx);
 343 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app);
 344 void ust_app_global_update_all(struct ltt_ust_session *usess);
 345 void ust_app_global_update_tokens(struct ust_app *app);
 346 void ust_app_global_update_all_tokens(void);
 347
 348 void ust_app_update_trigger_error_count(struct lttng_trigger *trigger);
 349
 350 void ust_app_clean_list(void);
 351 int ust_app_ht_alloc(void);
 352 struct ust_app *ust_app_find_by_pid(pid_t pid);
 353 struct ust_app_stream *ust_app_alloc_stream(void);
 354 int ust_app_recv_registration(int sock, struct ust_register_msg *msg);
 355 int ust_app_recv_notify(int sock);
 356 void ust_app_add(struct ust_app *app);
 357 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock);
 358 void ust_app_notify_sock_unregister(int sock);
 359 ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
 360                 struct consumer_socket *socket, int send_zero_data);
 361 void ust_app_destroy(struct ust_app *app);
 362 enum lttng_error_code ust_app_snapshot_record(
 363                 const struct ltt_ust_session *usess,
 364                 const struct consumer_output *output, int wait,
 365                 uint64_t nb_packets_per_stream);
 366 uint64_t ust_app_get_size_one_more_packet_per_stream(
 367                 const struct ltt_ust_session *usess, uint64_t cur_nr_packets);
 368 struct ust_app *ust_app_find_by_sock(int sock);
 369 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
 370                 struct cds_list_head *buffer_reg_uid_list,
 371                 struct consumer_output *consumer, uint64_t uchan_id,
 372                 int overwrite, uint64_t *discarded, uint64_t *lost);
 373 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
 374                 struct ltt_ust_channel *uchan,
 375                 struct consumer_output *consumer,
 376                 int overwrite, uint64_t *discarded, uint64_t *lost);
 377 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess);
 378 enum lttng_error_code ust_app_rotate_session(struct ltt_session *session);
 379 enum lttng_error_code ust_app_create_channel_subdirectories(
 380                 const struct ltt_ust_session *session);
 381 int ust_app_release_object(struct ust_app *app,
 382                 struct lttng_ust_object_data *data);
 383 enum lttng_error_code ust_app_clear_session(struct ltt_session *session);
 384 enum lttng_error_code ust_app_open_packets(struct ltt_session *session);
 385
 386 int ust_app_setup_trigger_group(struct ust_app *app);
 387
 388 static inline
 389 int ust_app_supported(void)
 390 {
 391         return 1;
 392 }
 393
 394 #else /* HAVE_LIBLTTNG_UST_CTL */
 395
 396 static inline
 397 int ust_app_destroy_trace_all(struct ltt_ust_session *usess)
 398 {
 399         return 0;
 400 }
 401 static inline
 402 int ust_app_start_trace(struct ltt_ust_session *usess, struct ust_app *app)
 403 {
 404         return 0;
 405 }
 406 static inline
 407 int ust_app_start_trace_all(struct ltt_ust_session *usess)
 408 {
 409         return 0;
 410 }
 411 static inline
 412 int ust_app_stop_trace_all(struct ltt_ust_session *usess)
 413 {
 414         return 0;
 415 }
 416 static inline
 417 int ust_app_list_events(struct lttng_event **events)
 418 {
 419         return -ENOSYS;
 420 }
 421 static inline
 422 int ust_app_list_event_fields(struct lttng_event_field **fields)
 423 {
 424         return -ENOSYS;
 425 }
 426 static inline
 427 int ust_app_register(struct ust_register_msg *msg, int sock)
 428 {
 429         return -ENOSYS;
 430 }
 431 static inline
 432 int ust_app_register_done(struct ust_app *app)
 433 {
 434         return -ENOSYS;
 435 }
 436 static inline
 437 int ust_app_version(struct ust_app *app)
 438 {
 439         return -ENOSYS;
 440 }
 441 static inline
 442 void ust_app_unregister(int sock)
 443 {
 444 }
 445 static inline
 446 void ust_app_lock_list(void)
 447 {
 448 }
 449 static inline
 450 void ust_app_unlock_list(void)
 451 {
 452 }
 453 static inline
 454 void ust_app_clean_list(void)
 455 {
 456 }
 457 static inline
 458 struct ust_app_list *ust_app_get_list(void)
 459 {
 460         return NULL;
 461 }
 462 static inline
 463 struct ust_app *ust_app_get_by_pid(pid_t pid)
 464 {
 465         return NULL;
 466 }
 467 static inline
 468 int ust_app_ht_alloc(void)
 469 {
 470         return 0;
 471 }
 472 static inline
 473 void ust_app_global_update(struct ltt_ust_session *usess, struct ust_app *app)
 474 {}
 475 static inline
 476 void ust_app_global_update_tokens(struct ust_app *app)
 477 {}
 478 static inline
 479 void ust_app_global_update_all_tokens(void)
 480 {}
 481 static inline
 482 int ust_app_setup_trigger_group(struct ust_app *app)
 483 {
 484         return 0;
 485 }
 486 static inline
 487 int ust_app_disable_channel_glb(struct ltt_ust_session *usess,
 488                 struct ltt_ust_channel *uchan)
 489 {
 490         return 0;
 491 }
 492 static inline
 493 int ust_app_enable_channel_glb(struct ltt_ust_session *usess,
 494                 struct ltt_ust_channel *uchan)
 495 {
 496         return 0;
 497 }
 498 static inline
 499 int ust_app_create_event_glb(struct ltt_ust_session *usess,
 500                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 501 {
 502         return 0;
 503 }
 504 static inline
 505 int ust_app_disable_event_glb(struct ltt_ust_session *usess,
 506                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 507 {
 508         return 0;
 509 }
 510 static inline
 511 int ust_app_enable_event_glb(struct ltt_ust_session *usess,
 512                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent)
 513 {
 514         return 0;
 515 }
 516 static inline
 517 int ust_app_add_ctx_channel_glb(struct ltt_ust_session *usess,
 518                 struct ltt_ust_channel *uchan, struct ltt_ust_context *uctx)
 519 {
 520         return 0;
 521 }
 522 static inline
 523 int ust_app_enable_event_pid(struct ltt_ust_session *usess,
 524                 struct ltt_ust_channel *uchan, struct ltt_ust_event *uevent,
 525                 pid_t pid)
 526 {
 527         return 0;
 528 }
 529 static inline
 530 int ust_app_recv_registration(int sock, struct ust_register_msg *msg)
 531 {
 532         return 0;
 533 }
 534 static inline
 535 int ust_app_recv_notify(int sock)
 536 {
 537         return 0;
 538 }
 539 static inline
 540 struct ust_app *ust_app_create(struct ust_register_msg *msg, int sock)
 541 {
 542         return NULL;
 543 }
 544 static inline
 545 void ust_app_add(struct ust_app *app)
 546 {
 547 }
 548 static inline
 549 void ust_app_notify_sock_unregister(int sock)
 550 {
 551 }
 552 static inline
 553 ssize_t ust_app_push_metadata(struct ust_registry_session *registry,
 554                 struct consumer_socket *socket, int send_zero_data)
 555 {
 556         return 0;
 557 }
 558 static inline
 559 void ust_app_destroy(struct ust_app *app)
 560 {
 561         return;
 562 }
 563 static inline
 564 enum lttng_error_code ust_app_snapshot_record(struct ltt_ust_session *usess,
 565                 const struct consumer_output *output, int wait, uint64_t max_stream_size)
 566 {
 567         return 0;
 568 }
 569 static inline
 570 unsigned int ust_app_get_nb_stream(struct ltt_ust_session *usess)
 571 {
 572         return 0;
 573 }
 574 static inline
 575 void ust_app_update_trigger_error_count(struct lttng_trigger *trigger)
 576 {
 577         return;
 578 }
 579 static inline
 580 int ust_app_supported(void)
 581 {
 582         return 0;
 583 }
 584 static inline
 585 struct ust_app *ust_app_find_by_sock(int sock)
 586 {
 587         return NULL;
 588 }
 589 static inline
 590 struct ust_app *ust_app_find_by_pid(pid_t pid)
 591 {
 592         return NULL;
 593 }
 594 static inline
 595 uint64_t ust_app_get_size_one_more_packet_per_stream(
 596                 const struct ltt_ust_session *usess, uint64_t cur_nr_packets) {
 597         return 0;
 598 }
 599 static inline
 600 int ust_app_uid_get_channel_runtime_stats(uint64_t ust_session_id,
 601                 struct cds_list_head *buffer_reg_uid_list,
 602                 struct consumer_output *consumer, int overwrite,
 603                 uint64_t uchan_id, uint64_t *discarded, uint64_t *lost)
 604 {
 605         return 0;
 606 }
 607
 608 static inline
 609 int ust_app_pid_get_channel_runtime_stats(struct ltt_ust_session *usess,
 610                 struct ltt_ust_channel *uchan,
 611                 struct consumer_output *consumer,
 612                 int overwrite, uint64_t *discarded, uint64_t *lost)
 613 {
 614         return 0;
 615 }
 616
 617 static inline
 618 int ust_app_regenerate_statedump_all(struct ltt_ust_session *usess)
 619 {
 620         return 0;
 621 }
 622
 623 static inline
 624 enum lttng_error_code ust_app_rotate_session(struct ltt_session *session)
 625 {
 626         return 0;
 627 }
 628
 629 static inline
 630 enum lttng_error_code ust_app_create_channel_subdirectories(
 631                 const struct ltt_ust_session *session)
 632 {
 633         return 0;
 634 }
 635
 636 static inline
 637 int ust_app_release_object(struct ust_app *app, struct lttng_ust_object_data *data)
 638 {
 639         return 0;
 640 }
 641
 642 static inline
 643 enum lttng_error_code ust_app_clear_session(struct ltt_session *session)
 644 {
 645         return 0;
 646 }
 647
 648 static inline
 649 enum lttng_error_code ust_app_open_packets(struct ltt_session *session)
 650 {
 651         return 0;
 652 }
 653
 654 #endif /* HAVE_LIBLTTNG_UST_CTL */
 655
 656 #endif /* _LTT_UST_APP_H */