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

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