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

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