| 1 | /* |
| 2 | * Copyright (C) 2013 David Goulet <dgoulet@efficios.com> |
| 3 | * Copyright (C) 2022 Jérémie Galarneau <jeremie.galarneau@efficios.com> |
| 4 | * |
| 5 | * SPDX-License-Identifier: GPL-2.0-only |
| 6 | * |
| 7 | */ |
| 8 | |
| 9 | #ifndef LTTNG_UST_REGISTRY_H |
| 10 | #define LTTNG_UST_REGISTRY_H |
| 11 | |
| 12 | #include <pthread.h> |
| 13 | #include <stdint.h> |
| 14 | #include <ctime> |
| 15 | #include <string> |
| 16 | #include <memory> |
| 17 | |
| 18 | #include <common/hashtable/hashtable.hpp> |
| 19 | #include <common/uuid.hpp> |
| 20 | |
| 21 | #include <lttng/domain.h> |
| 22 | |
| 23 | #include "lttng-ust-ctl.hpp" |
| 24 | |
| 25 | #define CTF_SPEC_MAJOR 1 |
| 26 | #define CTF_SPEC_MINOR 8 |
| 27 | |
| 28 | struct ust_app; |
| 29 | |
| 30 | class ust_registry_session { |
| 31 | public: |
| 32 | virtual lttng_buffer_type get_buffering_scheme() const = 0; |
| 33 | virtual ~ust_registry_session(); |
| 34 | |
| 35 | protected: |
| 36 | /* Prevent instanciation of this base class. */ |
| 37 | ust_registry_session(unsigned int bits_per_long, |
| 38 | unsigned int uint8_t_alignment, |
| 39 | unsigned int uint16_t_alignment, |
| 40 | unsigned int uint32_t_alignment, |
| 41 | unsigned int uint64_t_alignment, |
| 42 | unsigned int long_alignment, |
| 43 | int byte_order, |
| 44 | unsigned int app_tracer_version_major, |
| 45 | unsigned int app_tracer_version_minor, |
| 46 | const char *root_shm_path, |
| 47 | const char *shm_path, |
| 48 | uid_t euid, |
| 49 | gid_t egid, |
| 50 | uint64_t tracing_id); |
| 51 | |
| 52 | void statedump(); |
| 53 | |
| 54 | public: |
| 55 | /* |
| 56 | * With multiple writers and readers, use this lock to access |
| 57 | * the registry. Can nest within the ust app session lock. |
| 58 | * Also acts as a registry serialization lock. Used by registry |
| 59 | * readers to serialize the registry information sent from the |
| 60 | * sessiond to the consumerd. |
| 61 | * The consumer socket lock nests within this lock. |
| 62 | */ |
| 63 | pthread_mutex_t _lock; |
| 64 | /* Next channel ID available for a newly registered channel. */ |
| 65 | uint32_t _next_channel_id = 0; |
| 66 | /* Once this value reaches UINT32_MAX, no more id can be allocated. */ |
| 67 | uint32_t _used_channel_id = 0; |
| 68 | /* Next enumeration ID available. */ |
| 69 | uint64_t _next_enum_id = 0; |
| 70 | /* Universal unique identifier used by the tracer. */ |
| 71 | lttng_uuid _uuid = {}; |
| 72 | |
| 73 | /* session ABI description */ |
| 74 | |
| 75 | /* Size of long, in bits */ |
| 76 | unsigned int _bits_per_long; |
| 77 | /* Alignment, in bits */ |
| 78 | unsigned int _uint8_t_alignment, _uint16_t_alignment, _uint32_t_alignment, |
| 79 | _uint64_t_alignment, _long_alignment; |
| 80 | /* endianness: BIG_ENDIAN or LITTLE_ENDIAN */ |
| 81 | int _byte_order; |
| 82 | |
| 83 | /* Generated metadata. */ |
| 84 | char *_metadata = nullptr; /* NOT null-terminated ! Use memcpy. */ |
| 85 | size_t _metadata_len = 0, _metadata_alloc_len = 0; |
| 86 | /* Length of bytes sent to the consumer. */ |
| 87 | size_t _metadata_len_sent = 0; |
| 88 | /* Current version of the metadata. */ |
| 89 | uint64_t _metadata_version = 0; |
| 90 | |
| 91 | /* |
| 92 | * Those fields are only used when a session is created with |
| 93 | * the --shm-path option. In this case, the metadata is output |
| 94 | * twice: once to the consumer, as ususal, but a second time |
| 95 | * also in the shm path directly. This is done so that a copy |
| 96 | * of the metadata that is as fresh as possible is available |
| 97 | * on the event of a crash. |
| 98 | * |
| 99 | * root_shm_path contains the shm-path provided by the user, along with |
| 100 | * the session's name and timestamp: |
| 101 | * e.g. /tmp/my_shm/my_session-20180612-135822 |
| 102 | * |
| 103 | * shm_path contains the full path of the memory buffers: |
| 104 | * e.g. /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit |
| 105 | * |
| 106 | * metadata_path contains the full path to the metadata file that |
| 107 | * is kept for the "crash buffer" extraction: |
| 108 | * e.g. |
| 109 | * /tmp/my_shm/my_session-20180612-135822/ust/uid/1000/64-bit/metadata |
| 110 | * |
| 111 | * Note that this is not the trace's final metadata file. It is |
| 112 | * only meant to be used to read the contents of the ring buffers |
| 113 | * in the event of a crash. |
| 114 | * |
| 115 | * metadata_fd is a file descriptor that points to the file at |
| 116 | * 'metadata_path'. |
| 117 | */ |
| 118 | char _root_shm_path[PATH_MAX] = {}; |
| 119 | char _shm_path[PATH_MAX] = {}; |
| 120 | char _metadata_path[PATH_MAX] = {}; |
| 121 | /* File-backed metadata FD */ |
| 122 | int _metadata_fd = -1; |
| 123 | |
| 124 | /* |
| 125 | * Hash table containing channels sent by the UST tracer. MUST |
| 126 | * be accessed with a RCU read side lock acquired. |
| 127 | */ |
| 128 | lttng_ht::uptr _channels; |
| 129 | |
| 130 | /* |
| 131 | * Unique key to identify the metadata on the consumer side. |
| 132 | */ |
| 133 | uint64_t _metadata_key = 0; |
| 134 | /* |
| 135 | * Indicates if the metadata is closed on the consumer side. This is to |
| 136 | * avoid double close of metadata when an application unregisters AND |
| 137 | * deletes its sessions. |
| 138 | */ |
| 139 | bool _metadata_closed = false; |
| 140 | |
| 141 | /* User and group owning the session. */ |
| 142 | uid_t _uid = -1; |
| 143 | gid_t _gid = -1; |
| 144 | |
| 145 | /* Enumerations table. */ |
| 146 | lttng_ht::uptr _enums; |
| 147 | |
| 148 | /* |
| 149 | * Copy of the tracer version when the first app is registered. |
| 150 | * It is used if we need to regenerate the metadata. |
| 151 | */ |
| 152 | uint32_t _app_tracer_version_major = 0; |
| 153 | uint32_t _app_tracer_version_minor = 0; |
| 154 | |
| 155 | /* The id of the parent session */ |
| 156 | uint64_t _tracing_id = -1ULL; |
| 157 | }; |
| 158 | |
| 159 | class ust_registry_session_per_uid : public ust_registry_session { |
| 160 | public: |
| 161 | ust_registry_session_per_uid(uint32_t bits_per_long, |
| 162 | uint32_t uint8_t_alignment, |
| 163 | uint32_t uint16_t_alignment, |
| 164 | uint32_t uint32_t_alignment, |
| 165 | uint32_t uint64_t_alignment, |
| 166 | uint32_t long_alignment, |
| 167 | int byte_order, |
| 168 | uint32_t major, |
| 169 | uint32_t minor, |
| 170 | const char *root_shm_path, |
| 171 | const char *shm_path, |
| 172 | uid_t euid, |
| 173 | gid_t egid, |
| 174 | uint64_t tracing_id, |
| 175 | uid_t tracing_uid); |
| 176 | |
| 177 | virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; |
| 178 | |
| 179 | const uid_t _tracing_uid; |
| 180 | }; |
| 181 | |
| 182 | class ust_registry_session_per_pid : public ust_registry_session { |
| 183 | public: |
| 184 | ust_registry_session_per_pid(const struct ust_app &app, |
| 185 | uint32_t bits_per_long, |
| 186 | uint32_t uint8_t_alignment, |
| 187 | uint32_t uint16_t_alignment, |
| 188 | uint32_t uint32_t_alignment, |
| 189 | uint32_t uint64_t_alignment, |
| 190 | uint32_t long_alignment, |
| 191 | int byte_order, |
| 192 | uint32_t major, |
| 193 | uint32_t minor, |
| 194 | const char *root_shm_path, |
| 195 | const char *shm_path, |
| 196 | uid_t euid, |
| 197 | gid_t egid, |
| 198 | uint64_t tracing_id); |
| 199 | |
| 200 | virtual lttng_buffer_type get_buffering_scheme() const noexcept override final; |
| 201 | |
| 202 | pid_t get_vpid() const |
| 203 | { |
| 204 | return _vpid; |
| 205 | } |
| 206 | |
| 207 | const unsigned int _tracer_patch_level_version; |
| 208 | const pid_t _vpid; |
| 209 | const std::string _procname; |
| 210 | const std::time_t _app_creation_time; |
| 211 | }; |
| 212 | |
| 213 | struct ust_registry_channel { |
| 214 | uint64_t key; |
| 215 | uint64_t consumer_key; |
| 216 | /* Id set when replying to a register channel. */ |
| 217 | uint32_t chan_id; |
| 218 | enum lttng_ust_ctl_channel_header header_type; |
| 219 | |
| 220 | /* |
| 221 | * Flag for this channel if the metadata was dumped once during |
| 222 | * registration. 0 means no, 1 yes. |
| 223 | */ |
| 224 | unsigned int metadata_dumped; |
| 225 | /* Indicates if this channel registry has already been registered. */ |
| 226 | unsigned int register_done; |
| 227 | |
| 228 | /* |
| 229 | * Hash table containing events sent by the UST tracer. MUST be accessed |
| 230 | * with a RCU read side lock acquired. |
| 231 | */ |
| 232 | struct lttng_ht *events; |
| 233 | /* Next event ID available for a newly registered event. */ |
| 234 | uint32_t next_event_id; |
| 235 | /* Once this value reaches UINT32_MAX, no more id can be allocated. */ |
| 236 | uint32_t used_event_id; |
| 237 | /* |
| 238 | * Context fields of the registry. Context are per channel. Allocated by a |
| 239 | * register channel notification from the UST tracer. |
| 240 | */ |
| 241 | size_t nr_ctx_fields; |
| 242 | struct lttng_ust_ctl_field *ctx_fields; |
| 243 | struct lttng_ht_node_u64 node; |
| 244 | /* For delayed reclaim */ |
| 245 | struct rcu_head rcu_head; |
| 246 | }; |
| 247 | |
| 248 | /* |
| 249 | * Event registered from a UST tracer sent to the session daemon. This is |
| 250 | * indexed and matched by <event_name/signature>. |
| 251 | */ |
| 252 | struct ust_registry_event { |
| 253 | int id; |
| 254 | /* Both objd are set by the tracer. */ |
| 255 | int session_objd; |
| 256 | int channel_objd; |
| 257 | /* Name of the event returned by the tracer. */ |
| 258 | char name[LTTNG_UST_ABI_SYM_NAME_LEN]; |
| 259 | char *signature; |
| 260 | int loglevel_value; |
| 261 | size_t nr_fields; |
| 262 | struct lttng_ust_ctl_field *fields; |
| 263 | char *model_emf_uri; |
| 264 | /* |
| 265 | * Flag for this channel if the metadata was dumped once during |
| 266 | * registration. 0 means no, 1 yes. |
| 267 | */ |
| 268 | unsigned int metadata_dumped; |
| 269 | /* |
| 270 | * Node in the ust-registry hash table. The event name is used to |
| 271 | * initialize the node and the event_name/signature for the match function. |
| 272 | */ |
| 273 | struct lttng_ht_node_u64 node; |
| 274 | }; |
| 275 | |
| 276 | struct ust_registry_enum { |
| 277 | char name[LTTNG_UST_ABI_SYM_NAME_LEN]; |
| 278 | struct lttng_ust_ctl_enum_entry *entries; |
| 279 | size_t nr_entries; |
| 280 | uint64_t id; /* enum id in session */ |
| 281 | /* Enumeration node in session hash table. */ |
| 282 | struct lttng_ht_node_str node; |
| 283 | /* For delayed reclaim. */ |
| 284 | struct rcu_head rcu_head; |
| 285 | }; |
| 286 | |
| 287 | /* |
| 288 | * Validate that the id has reached the maximum allowed or not. |
| 289 | * |
| 290 | * Return 0 if NOT else 1. |
| 291 | */ |
| 292 | static inline int ust_registry_is_max_id(uint32_t id) |
| 293 | { |
| 294 | return (id == UINT32_MAX) ? 1 : 0; |
| 295 | } |
| 296 | |
| 297 | /* |
| 298 | * Return next available event id and increment the used counter. The |
| 299 | * ust_registry_is_max_id function MUST be called before in order to validate |
| 300 | * if the maximum number of IDs have been reached. If not, it is safe to call |
| 301 | * this function. |
| 302 | * |
| 303 | * Return a unique channel ID. If max is reached, the used_event_id counter is |
| 304 | * returned. |
| 305 | */ |
| 306 | static inline uint32_t ust_registry_get_next_event_id( |
| 307 | struct ust_registry_channel *r) |
| 308 | { |
| 309 | if (ust_registry_is_max_id(r->used_event_id)) { |
| 310 | return r->used_event_id; |
| 311 | } |
| 312 | |
| 313 | r->used_event_id++; |
| 314 | return r->next_event_id++; |
| 315 | } |
| 316 | |
| 317 | /* |
| 318 | * Return next available channel id and increment the used counter. The |
| 319 | * ust_registry_is_max_id function MUST be called before in order to validate |
| 320 | * if the maximum number of IDs have been reached. If not, it is safe to call |
| 321 | * this function. |
| 322 | * |
| 323 | * Return a unique channel ID. If max is reached, the used_channel_id counter |
| 324 | * is returned. |
| 325 | */ |
| 326 | static inline uint32_t ust_registry_get_next_chan_id( |
| 327 | ust_registry_session *r) |
| 328 | { |
| 329 | if (ust_registry_is_max_id(r->_used_channel_id)) { |
| 330 | return r->_used_channel_id; |
| 331 | } |
| 332 | |
| 333 | r->_used_channel_id++; |
| 334 | return r->_next_channel_id++; |
| 335 | } |
| 336 | |
| 337 | /* |
| 338 | * Return registry event count. This is read atomically. |
| 339 | */ |
| 340 | static inline uint32_t ust_registry_get_event_count( |
| 341 | struct ust_registry_channel *r) |
| 342 | { |
| 343 | return (uint32_t) uatomic_read(&r->used_event_id); |
| 344 | } |
| 345 | |
| 346 | #ifdef HAVE_LIBLTTNG_UST_CTL |
| 347 | |
| 348 | void ust_registry_channel_destroy(ust_registry_session *session, |
| 349 | struct ust_registry_channel *chan); |
| 350 | struct ust_registry_channel *ust_registry_channel_find( |
| 351 | ust_registry_session *session, uint64_t key); |
| 352 | int ust_registry_channel_add(ust_registry_session *session, |
| 353 | uint64_t key); |
| 354 | void ust_registry_channel_del_free(ust_registry_session *session, |
| 355 | uint64_t key, bool notif); |
| 356 | void ust_registry_channel_destroy(struct ust_registry_channel *chan, bool notify); |
| 357 | |
| 358 | /* |
| 359 | * Create per-uid registry with default values. |
| 360 | * |
| 361 | * Return new instance on success, nullptr on error. |
| 362 | */ |
| 363 | ust_registry_session *ust_registry_session_per_uid_create( |
| 364 | uint32_t bits_per_long, |
| 365 | uint32_t uint8_t_alignment, |
| 366 | uint32_t uint16_t_alignment, |
| 367 | uint32_t uint32_t_alignment, |
| 368 | uint32_t uint64_t_alignment, |
| 369 | uint32_t long_alignment, |
| 370 | int byte_order, |
| 371 | uint32_t major, |
| 372 | uint32_t minor, |
| 373 | const char *root_shm_path, |
| 374 | const char *shm_path, |
| 375 | uid_t euid, |
| 376 | gid_t egid, |
| 377 | uint64_t tracing_id, |
| 378 | uid_t tracing_uid); |
| 379 | |
| 380 | /* |
| 381 | * Create per-pid registry with default values. |
| 382 | * |
| 383 | * Return new instance on success, nullptr on error. |
| 384 | */ |
| 385 | ust_registry_session *ust_registry_session_per_pid_create(struct ust_app *app, |
| 386 | uint32_t bits_per_long, |
| 387 | uint32_t uint8_t_alignment, |
| 388 | uint32_t uint16_t_alignment, |
| 389 | uint32_t uint32_t_alignment, |
| 390 | uint32_t uint64_t_alignment, |
| 391 | uint32_t long_alignment, |
| 392 | int byte_order, |
| 393 | uint32_t major, |
| 394 | uint32_t minor, |
| 395 | const char *root_shm_path, |
| 396 | const char *shm_path, |
| 397 | uid_t euid, |
| 398 | gid_t egid, |
| 399 | uint64_t tracing_id); |
| 400 | void ust_registry_session_destroy(ust_registry_session *session); |
| 401 | |
| 402 | int ust_registry_create_event(ust_registry_session *session, |
| 403 | uint64_t chan_key, int session_objd, int channel_objd, char *name, |
| 404 | char *sig, size_t nr_fields, struct lttng_ust_ctl_field *fields, |
| 405 | int loglevel_value, char *model_emf_uri, int buffer_type, |
| 406 | uint32_t *event_id_p, struct ust_app *app); |
| 407 | struct ust_registry_event *ust_registry_find_event( |
| 408 | struct ust_registry_channel *chan, char *name, char *sig); |
| 409 | void ust_registry_destroy_event(struct ust_registry_channel *chan, |
| 410 | struct ust_registry_event *event); |
| 411 | |
| 412 | /* app can be NULL for registry shared across applications. */ |
| 413 | int ust_metadata_session_statedump(ust_registry_session *session); |
| 414 | int ust_metadata_channel_statedump(ust_registry_session *session, |
| 415 | struct ust_registry_channel *chan); |
| 416 | int ust_metadata_event_statedump(ust_registry_session *session, |
| 417 | struct ust_registry_channel *chan, |
| 418 | struct ust_registry_event *event); |
| 419 | int ust_registry_create_or_find_enum(ust_registry_session *session, |
| 420 | int session_objd, char *name, |
| 421 | struct lttng_ust_ctl_enum_entry *entries, size_t nr_entries, |
| 422 | uint64_t *enum_id); |
| 423 | struct ust_registry_enum * |
| 424 | ust_registry_lookup_enum_by_id(ust_registry_session *session, |
| 425 | const char *name, uint64_t id); |
| 426 | void ust_registry_destroy_enum(ust_registry_session *reg_session, |
| 427 | struct ust_registry_enum *reg_enum); |
| 428 | |
| 429 | #else /* HAVE_LIBLTTNG_UST_CTL */ |
| 430 | |
| 431 | static inline void ust_registry_channel_destroy( |
| 432 | struct ust_registry_channel *chan __attribute__((unused)), |
| 433 | bool notify __attribute__((unused))) |
| 434 | { |
| 435 | } |
| 436 | |
| 437 | static inline |
| 438 | struct ust_registry_channel *ust_registry_channel_find( |
| 439 | ust_registry_session *session __attribute__((unused)), |
| 440 | uint64_t key __attribute__((unused))) |
| 441 | { |
| 442 | return NULL; |
| 443 | } |
| 444 | |
| 445 | static inline |
| 446 | int ust_registry_channel_add( |
| 447 | ust_registry_session *session __attribute__((unused)), |
| 448 | uint64_t key __attribute__((unused))) |
| 449 | { |
| 450 | return 0; |
| 451 | } |
| 452 | |
| 453 | static inline |
| 454 | void ust_registry_channel_del_free( |
| 455 | ust_registry_session *session __attribute__((unused)), |
| 456 | uint64_t key __attribute__((unused)), |
| 457 | bool notif __attribute__((unused))) |
| 458 | {} |
| 459 | |
| 460 | static inline |
| 461 | ust_registry_session *ust_registry_session_per_uid_create( |
| 462 | uint32_t bits_per_long __attribute__((unused)), |
| 463 | uint32_t uint8_t_alignment __attribute__((unused)), |
| 464 | uint32_t uint16_t_alignment __attribute__((unused)), |
| 465 | uint32_t uint32_t_alignment __attribute__((unused)), |
| 466 | uint32_t uint64_t_alignment __attribute__((unused)), |
| 467 | uint32_t long_alignment __attribute__((unused)), |
| 468 | int byte_order __attribute__((unused)), |
| 469 | uint32_t major __attribute__((unused)), |
| 470 | uint32_t minor __attribute__((unused)), |
| 471 | const char *root_shm_path __attribute__((unused)), |
| 472 | const char *shm_path __attribute__((unused)), |
| 473 | uid_t euid __attribute__((unused)), |
| 474 | gid_t egid __attribute__((unused)), |
| 475 | uint64_t tracing_id __attribute__((unused)), |
| 476 | uid_t tracing_uid __attribute__((unused))) |
| 477 | { |
| 478 | return nullptr; |
| 479 | } |
| 480 | |
| 481 | static inline |
| 482 | ust_registry_session *ust_registry_session_per_pid_create( |
| 483 | struct ust_app *app __attribute__((unused)), |
| 484 | uint32_t bits_per_long __attribute__((unused)), |
| 485 | uint32_t uint8_t_alignment __attribute__((unused)), |
| 486 | uint32_t uint16_t_alignment __attribute__((unused)), |
| 487 | uint32_t uint32_t_alignment __attribute__((unused)), |
| 488 | uint32_t uint64_t_alignment __attribute__((unused)), |
| 489 | uint32_t long_alignment __attribute__((unused)), |
| 490 | int byte_order __attribute__((unused)), |
| 491 | uint32_t major __attribute__((unused)), |
| 492 | uint32_t minor __attribute__((unused)), |
| 493 | const char *root_shm_path __attribute__((unused)), |
| 494 | const char *shm_path __attribute__((unused)), |
| 495 | uid_t euid __attribute__((unused)), |
| 496 | gid_t egid __attribute__((unused)), |
| 497 | uint64_t tracing_id __attribute__((unused))) |
| 498 | { |
| 499 | return nullptr; |
| 500 | } |
| 501 | |
| 502 | static inline |
| 503 | void ust_registry_session_destroy( |
| 504 | ust_registry_session *session __attribute__((unused))) |
| 505 | {} |
| 506 | |
| 507 | static inline |
| 508 | int ust_registry_create_event( |
| 509 | ust_registry_session *session __attribute__((unused)), |
| 510 | uint64_t chan_key __attribute__((unused)), |
| 511 | int session_objd __attribute__((unused)), |
| 512 | int channel_objd __attribute__((unused)), |
| 513 | char *name __attribute__((unused)), |
| 514 | char *sig __attribute__((unused)), |
| 515 | size_t nr_fields __attribute__((unused)), |
| 516 | struct lttng_ust_ctl_field *fields __attribute__((unused)), |
| 517 | int loglevel_value __attribute__((unused)), |
| 518 | char *model_emf_uri __attribute__((unused)), |
| 519 | int buffer_type __attribute__((unused)), |
| 520 | uint32_t *event_id_p __attribute__((unused))) |
| 521 | { |
| 522 | return 0; |
| 523 | } |
| 524 | static inline |
| 525 | struct ust_registry_event *ust_registry_find_event( |
| 526 | struct ust_registry_channel *chan __attribute__((unused)), |
| 527 | char *name __attribute__((unused)), |
| 528 | char *sig __attribute__((unused))) |
| 529 | { |
| 530 | return NULL; |
| 531 | } |
| 532 | |
| 533 | static inline |
| 534 | void ust_registry_destroy_event( |
| 535 | struct ust_registry_channel *chan __attribute__((unused)), |
| 536 | struct ust_registry_event *event __attribute__((unused))) |
| 537 | {} |
| 538 | |
| 539 | /* The app object can be NULL for registry shared across applications. */ |
| 540 | static inline |
| 541 | int ust_metadata_session_statedump( |
| 542 | ust_registry_session *session __attribute__((unused))) |
| 543 | { |
| 544 | return 0; |
| 545 | } |
| 546 | |
| 547 | static inline |
| 548 | int ust_metadata_channel_statedump( |
| 549 | ust_registry_session *session __attribute__((unused)), |
| 550 | struct ust_registry_channel *chan __attribute__((unused))) |
| 551 | { |
| 552 | return 0; |
| 553 | } |
| 554 | |
| 555 | static inline |
| 556 | int ust_metadata_event_statedump( |
| 557 | ust_registry_session *session __attribute__((unused)), |
| 558 | struct ust_registry_channel *chan __attribute__((unused)), |
| 559 | struct ust_registry_event *event __attribute__((unused))) |
| 560 | { |
| 561 | return 0; |
| 562 | } |
| 563 | |
| 564 | static inline |
| 565 | int ust_registry_create_or_find_enum( |
| 566 | ust_registry_session *session __attribute__((unused)), |
| 567 | int session_objd __attribute__((unused)), |
| 568 | char *name __attribute__((unused)), |
| 569 | struct lttng_ust_ctl_enum_entry *entries __attribute__((unused)), |
| 570 | size_t nr_entries __attribute__((unused)), |
| 571 | uint64_t *enum_id __attribute__((unused))) |
| 572 | { |
| 573 | return 0; |
| 574 | } |
| 575 | |
| 576 | static inline |
| 577 | struct ust_registry_enum * |
| 578 | ust_registry_lookup_enum_by_id( |
| 579 | ust_registry_session *session __attribute__((unused)), |
| 580 | const char *name __attribute__((unused)), |
| 581 | uint64_t id __attribute__((unused))) |
| 582 | { |
| 583 | return NULL; |
| 584 | } |
| 585 | |
| 586 | static inline |
| 587 | void ust_registry_destroy_enum(ust_registry_session *reg_session __attribute__((unused)), |
| 588 | struct ust_registry_enum *reg_enum __attribute__((unused))) |
| 589 | {} |
| 590 | |
| 591 | #endif /* HAVE_LIBLTTNG_UST_CTL */ |
| 592 | |
| 593 | #endif /* LTTNG_UST_REGISTRY_H */ |