src/common/sessiond-comm/sessiond-comm.hpp

   1 /*
   2  * Copyright (C) 2011 EfficiOS Inc.
   3  * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   4  *
   5  * SPDX-License-Identifier: GPL-2.0-only
   6  *
   7  */
   8
   9 /*
  10  * This header is meant for liblttng and libust internal use ONLY. These
  11  * declarations should NOT be considered stable API.
  12  */
  13
  14 #ifndef _LTTNG_SESSIOND_COMM_H
  15 #define _LTTNG_SESSIOND_COMM_H
  16
  17 #include "inet.hpp"
  18 #include "inet6.hpp"
  19
  20 #include <common/compat/socket.hpp>
  21 #include <common/compiler.hpp>
  22 #include <common/defaults.hpp>
  23 #include <common/macros.hpp>
  24 #include <common/optional.hpp>
  25 #include <common/unix.hpp>
  26 #include <common/uri.hpp>
  27 #include <common/uuid.hpp>
  28
  29 #include <lttng/channel-internal.hpp>
  30 #include <lttng/lttng.h>
  31 #include <lttng/rotate-internal.hpp>
  32 #include <lttng/save-internal.hpp>
  33 #include <lttng/snapshot-internal.hpp>
  34 #include <lttng/trigger/trigger-internal.hpp>
  35
  36 #include <arpa/inet.h>
  37 #include <limits.h>
  38 #include <netinet/in.h>
  39 #include <stdint.h>
  40 #include <sys/un.h>
  41
  42 /* Queue size of listen(2) */
  43 #define LTTNG_SESSIOND_COMM_MAX_LISTEN 64
  44
  45 /* Maximum number of FDs that can be sent over a Unix socket */
  46 #if defined(__linux__)
  47 /* Based on the kernel's SCM_MAX_FD which is 253 since 2.6.38 (255 before) */
  48 #define LTTCOMM_MAX_SEND_FDS 253
  49 #else
  50 #define LTTCOMM_MAX_SEND_FDS 16
  51 #endif
  52
  53 enum lttcomm_sessiond_command {
  54         LTTCOMM_SESSIOND_COMMAND_MIN,
  55         LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT,
  56         LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL,
  57         LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT,
  58         LTTCOMM_SESSIOND_COMMAND_LIST_SYSCALLS,
  59         LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL,
  60         LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT,
  61         LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION,
  62         LTTCOMM_SESSIOND_COMMAND_LIST_CHANNELS,
  63         LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS,
  64         LTTCOMM_SESSIOND_COMMAND_LIST_EVENTS,
  65         LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS,
  66         LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS,
  67         LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER,
  68         LTTCOMM_SESSIOND_COMMAND_START_TRACE,
  69         LTTCOMM_SESSIOND_COMMAND_STOP_TRACE,
  70         LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS,
  71         LTTCOMM_SESSIOND_COMMAND_DISABLE_CONSUMER,
  72         LTTCOMM_SESSIOND_COMMAND_ENABLE_CONSUMER,
  73         LTTCOMM_SESSIOND_COMMAND_SET_CONSUMER_URI,
  74         LTTCOMM_SESSIOND_COMMAND_DATA_PENDING,
  75         LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_ADD_OUTPUT,
  76         LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT,
  77         LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT,
  78         LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD,
  79         LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION,
  80         LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE,
  81         LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE,
  82         LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY,
  83         LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY,
  84         LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET,
  85         LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH,
  86         LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA,
  87         LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP,
  88         LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER,
  89         LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER,
  90         LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION,
  91         LTTCOMM_SESSIOND_COMMAND_ROTATION_GET_INFO,
  92         LTTCOMM_SESSIOND_COMMAND_ROTATION_SET_SCHEDULE,
  93         LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES,
  94         LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT,
  95         LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION,
  96         LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS,
  97         LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY,
  98         LTTCOMM_SESSIOND_COMMAND_MAX,
  99 };
 100
 101 static inline bool lttcomm_sessiond_command_is_valid(enum lttcomm_sessiond_command cmd)
 102 {
 103         return cmd > LTTCOMM_SESSIOND_COMMAND_MIN && cmd < LTTCOMM_SESSIOND_COMMAND_MAX;
 104 }
 105
 106 static inline const char *lttcomm_sessiond_command_str(enum lttcomm_sessiond_command cmd)
 107 {
 108         switch (cmd) {
 109         case LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT:
 110                 return "ADD_CONTEXT";
 111         case LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL:
 112                 return "DISABLE_CHANNEL";
 113         case LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT:
 114                 return "DISABLE_EVENT";
 115         case LTTCOMM_SESSIOND_COMMAND_LIST_SYSCALLS:
 116                 return "LIST_SYSCALLS";
 117         case LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL:
 118                 return "ENABLE_CHANNEL";
 119         case LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT:
 120                 return "ENABLE_EVENT";
 121         case LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION:
 122                 return "DESTROY_SESSION";
 123         case LTTCOMM_SESSIOND_COMMAND_LIST_CHANNELS:
 124                 return "LIST_CHANNELS";
 125         case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS:
 126                 return "LIST_DOMAINS";
 127         case LTTCOMM_SESSIOND_COMMAND_LIST_EVENTS:
 128                 return "LIST_EVENTS";
 129         case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS:
 130                 return "LIST_SESSIONS";
 131         case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS:
 132                 return "LIST_TRACEPOINTS";
 133         case LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER:
 134                 return "REGISTER_CONSUMER";
 135         case LTTCOMM_SESSIOND_COMMAND_START_TRACE:
 136                 return "START_TRACE";
 137         case LTTCOMM_SESSIOND_COMMAND_STOP_TRACE:
 138                 return "STOP_TRACE";
 139         case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS:
 140                 return "LIST_TRACEPOINT_FIELDS";
 141         case LTTCOMM_SESSIOND_COMMAND_DISABLE_CONSUMER:
 142                 return "DISABLE_CONSUMER";
 143         case LTTCOMM_SESSIOND_COMMAND_ENABLE_CONSUMER:
 144                 return "ENABLE_CONSUMER";
 145         case LTTCOMM_SESSIOND_COMMAND_SET_CONSUMER_URI:
 146                 return "SET_CONSUMER_URI";
 147         case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING:
 148                 return "DATA_PENDING";
 149         case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_ADD_OUTPUT:
 150                 return "SNAPSHOT_ADD_OUTPUT";
 151         case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT:
 152                 return "SNAPSHOT_DEL_OUTPUT";
 153         case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT:
 154                 return "SNAPSHOT_LIST_OUTPUT";
 155         case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD:
 156                 return "SNAPSHOT_RECORD";
 157         case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION:
 158                 return "SAVE_SESSION";
 159         case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE:
 160                 return "PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE";
 161         case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE:
 162                 return "PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE";
 163         case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY:
 164                 return "PROCESS_ATTR_TRACKER_GET_POLICY";
 165         case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY:
 166                 return "PROCESS_ATTR_TRACKER_SET_POLICY";
 167         case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET:
 168                 return "PROCESS_ATTR_TRACKER_GET_INCLUSION_SET";
 169         case LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH:
 170                 return "SET_SESSION_SHM_PATH";
 171         case LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA:
 172                 return "REGENERATE_METADATA";
 173         case LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP:
 174                 return "REGENERATE_STATEDUMP";
 175         case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER:
 176                 return "REGISTER_TRIGGER";
 177         case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER:
 178                 return "UNREGISTER_TRIGGER";
 179         case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION:
 180                 return "ROTATE_SESSION";
 181         case LTTCOMM_SESSIOND_COMMAND_ROTATION_GET_INFO:
 182                 return "ROTATION_GET_INFO";
 183         case LTTCOMM_SESSIOND_COMMAND_ROTATION_SET_SCHEDULE:
 184                 return "ROTATION_SET_SCHEDULE";
 185         case LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES:
 186                 return "SESSION_LIST_ROTATION_SCHEDULES";
 187         case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT:
 188                 return "CREATE_SESSION_EXT";
 189         case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION:
 190                 return "CLEAR_SESSION";
 191         case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS:
 192                 return "LIST_TRIGGERS";
 193         case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY:
 194                 return "EXECUTE_ERROR_QUERY";
 195         default:
 196                 abort();
 197         }
 198 }
 199
 200 enum lttcomm_relayd_command {
 201         RELAYD_ADD_STREAM = 1,
 202         RELAYD_CREATE_SESSION = 2,
 203         RELAYD_START_DATA = 3,
 204         RELAYD_UPDATE_SYNC_INFO = 4,
 205         RELAYD_VERSION = 5,
 206         RELAYD_SEND_METADATA = 6,
 207         RELAYD_CLOSE_STREAM = 7,
 208         RELAYD_DATA_PENDING = 8,
 209         RELAYD_QUIESCENT_CONTROL = 9,
 210         RELAYD_BEGIN_DATA_PENDING = 10,
 211         RELAYD_END_DATA_PENDING = 11,
 212         RELAYD_ADD_INDEX = 12,
 213         RELAYD_SEND_INDEX = 13,
 214         RELAYD_CLOSE_INDEX = 14,
 215         /* Live-reading commands (2.4+). */
 216         RELAYD_LIST_SESSIONS = 15,
 217         /* All streams of the channel have been sent to the relayd (2.4+). */
 218         RELAYD_STREAMS_SENT = 16,
 219         /* Ask the relay to reset the metadata trace file (2.8+) */
 220         RELAYD_RESET_METADATA = 17,
 221         /* Ask the relay to rotate a set of stream files (2.11+) */
 222         RELAYD_ROTATE_STREAMS = 18,
 223         /* Ask the relay to create a trace chunk (2.11+) */
 224         RELAYD_CREATE_TRACE_CHUNK = 19,
 225         /* Ask the relay to close a trace chunk (2.11+) */
 226         RELAYD_CLOSE_TRACE_CHUNK = 20,
 227         /* Ask the relay whether a trace chunk exists (2.11+) */
 228         RELAYD_TRACE_CHUNK_EXISTS = 21,
 229         /* Get the current configuration of a relayd peer (2.12+) */
 230         RELAYD_GET_CONFIGURATION = 22,
 231
 232         /* Feature branch specific commands start at 10000. */
 233 };
 234
 235 static inline const char *lttcomm_relayd_command_str(lttcomm_relayd_command cmd)
 236 {
 237         switch (cmd) {
 238         case RELAYD_ADD_STREAM:
 239                 return "RELAYD_ADD_STREAM";
 240         case RELAYD_CREATE_SESSION:
 241                 return "RELAYD_CREATE_SESSION";
 242         case RELAYD_START_DATA:
 243                 return "RELAYD_START_DATA";
 244         case RELAYD_UPDATE_SYNC_INFO:
 245                 return "RELAYD_UPDATE_SYNC_INFO";
 246         case RELAYD_VERSION:
 247                 return "RELAYD_VERSION";
 248         case RELAYD_SEND_METADATA:
 249                 return "RELAYD_SEND_METADATA";
 250         case RELAYD_CLOSE_STREAM:
 251                 return "RELAYD_CLOSE_STREAM";
 252         case RELAYD_DATA_PENDING:
 253                 return "RELAYD_DATA_PENDING";
 254         case RELAYD_QUIESCENT_CONTROL:
 255                 return "RELAYD_QUIESCENT_CONTROL";
 256         case RELAYD_BEGIN_DATA_PENDING:
 257                 return "RELAYD_BEGIN_DATA_PENDING";
 258         case RELAYD_END_DATA_PENDING:
 259                 return "RELAYD_END_DATA_PENDING";
 260         case RELAYD_ADD_INDEX:
 261                 return "RELAYD_ADD_INDEX";
 262         case RELAYD_SEND_INDEX:
 263                 return "RELAYD_SEND_INDEX";
 264         case RELAYD_CLOSE_INDEX:
 265                 return "RELAYD_CLOSE_INDEX";
 266         case RELAYD_LIST_SESSIONS:
 267                 return "RELAYD_LIST_SESSIONS";
 268         case RELAYD_STREAMS_SENT:
 269                 return "RELAYD_STREAMS_SENT";
 270         case RELAYD_RESET_METADATA:
 271                 return "RELAYD_RESET_METADATA";
 272         case RELAYD_ROTATE_STREAMS:
 273                 return "RELAYD_ROTATE_STREAMS";
 274         case RELAYD_CREATE_TRACE_CHUNK:
 275                 return "RELAYD_CREATE_TRACE_CHUNK";
 276         case RELAYD_CLOSE_TRACE_CHUNK:
 277                 return "RELAYD_CLOSE_TRACE_CHUNK";
 278         case RELAYD_TRACE_CHUNK_EXISTS:
 279                 return "RELAYD_TRACE_CHUNK_EXISTS";
 280         case RELAYD_GET_CONFIGURATION:
 281                 return "RELAYD_GET_CONFIGURATION";
 282         default:
 283                 abort();
 284         }
 285 }
 286
 287 /*
 288  * lttcomm error code.
 289  */
 290 enum lttcomm_return_code {
 291         LTTCOMM_CONSUMERD_SUCCESS = 0, /* Everything went fine. */
 292         /*
 293          * Some code paths use -1 to express an error, others
 294          * negate this consumer return code. Starting codes at
 295          * 100 ensures there is no mix-up between this error value
 296          * and legitimate status codes.
 297          */
 298         LTTCOMM_CONSUMERD_COMMAND_SOCK_READY = 100, /* Command socket ready */
 299         LTTCOMM_CONSUMERD_SUCCESS_RECV_FD, /* Success on receiving fds */
 300         LTTCOMM_CONSUMERD_ERROR_RECV_FD, /* Error on receiving fds */
 301         LTTCOMM_CONSUMERD_ERROR_RECV_CMD, /* Error on receiving command */
 302         LTTCOMM_CONSUMERD_POLL_ERROR, /* Error in polling thread */
 303         LTTCOMM_CONSUMERD_POLL_NVAL, /* Poll on closed fd */
 304         LTTCOMM_CONSUMERD_POLL_HUP, /* All fds have hungup */
 305         LTTCOMM_CONSUMERD_EXIT_SUCCESS, /* Consumerd exiting normally */
 306         LTTCOMM_CONSUMERD_EXIT_FAILURE, /* Consumerd exiting on error */
 307         LTTCOMM_CONSUMERD_OUTFD_ERROR, /* Error opening the tracefile */
 308         LTTCOMM_CONSUMERD_SPLICE_EBADF, /* EBADF from splice(2) */
 309         LTTCOMM_CONSUMERD_SPLICE_EINVAL, /* EINVAL from splice(2) */
 310         LTTCOMM_CONSUMERD_SPLICE_ENOMEM, /* ENOMEM from splice(2) */
 311         LTTCOMM_CONSUMERD_SPLICE_ESPIPE, /* ESPIPE from splice(2) */
 312         LTTCOMM_CONSUMERD_ENOMEM, /* Consumer is out of memory */
 313         LTTCOMM_CONSUMERD_ERROR_METADATA, /* Error with metadata. */
 314         LTTCOMM_CONSUMERD_FATAL, /* Fatal error. */
 315         LTTCOMM_CONSUMERD_RELAYD_FAIL, /* Error on remote relayd */
 316         LTTCOMM_CONSUMERD_CHANNEL_FAIL, /* Channel creation failed. */
 317         LTTCOMM_CONSUMERD_CHAN_NOT_FOUND, /* Channel not found. */
 318         LTTCOMM_CONSUMERD_ALREADY_SET, /* Resource already set. */
 319         LTTCOMM_CONSUMERD_ROTATION_FAIL, /* Rotation has failed. */
 320         LTTCOMM_CONSUMERD_SNAPSHOT_FAILED, /* snapshot has failed. */
 321         LTTCOMM_CONSUMERD_CREATE_TRACE_CHUNK_FAILED, /* Trace chunk creation failed. */
 322         LTTCOMM_CONSUMERD_CLOSE_TRACE_CHUNK_FAILED, /* Trace chunk close failed. */
 323         LTTCOMM_CONSUMERD_INVALID_PARAMETERS, /* Invalid parameters. */
 324         LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_LOCAL, /* Trace chunk exists on consumer daemon. */
 325         LTTCOMM_CONSUMERD_TRACE_CHUNK_EXISTS_REMOTE, /* Trace chunk exists on relay daemon. */
 326         LTTCOMM_CONSUMERD_UNKNOWN_TRACE_CHUNK, /* Unknown trace chunk. */
 327         LTTCOMM_CONSUMERD_RELAYD_CLEAR_DISALLOWED, /* Relayd does not accept clear command. */
 328         LTTCOMM_CONSUMERD_UNKNOWN_ERROR, /* Unknown error. */
 329
 330         /* MUST be last element */
 331         LTTCOMM_NR, /* Last element */
 332 };
 333
 334 /* lttng socket protocol. */
 335 enum lttcomm_sock_proto {
 336         LTTCOMM_SOCK_UDP,
 337         LTTCOMM_SOCK_TCP,
 338 };
 339
 340 /*
 341  * Index in the net_families array below. Please keep in sync!
 342  */
 343 enum lttcomm_sock_domain {
 344         LTTCOMM_INET = 0,
 345         LTTCOMM_INET6 = 1,
 346 };
 347
 348 enum lttcomm_metadata_command {
 349         LTTCOMM_METADATA_REQUEST = 1,
 350 };
 351
 352 /*
 353  * Commands sent from the consumerd to the sessiond to request if new metadata
 354  * is available. This message is used to find the per UID _or_ per PID registry
 355  * for the channel key. For per UID lookup, the triplet
 356  * bits_per_long/uid/session_id is used. On lookup failure, we search for the
 357  * per PID registry indexed by session id ignoring the other values.
 358  */
 359 struct lttcomm_metadata_request_msg {
 360         uint64_t session_id; /* Tracing session id */
 361         uint64_t session_id_per_pid; /* Tracing session id for per-pid */
 362         uint32_t bits_per_long; /* Consumer ABI */
 363         uint32_t uid;
 364         uint64_t key; /* Metadata channel key. */
 365 } LTTNG_PACKED;
 366
 367 struct lttcomm_sockaddr {
 368         enum lttcomm_sock_domain type;
 369         union {
 370                 struct sockaddr_in sin;
 371                 struct sockaddr_in6 sin6;
 372         } addr;
 373 };
 374
 375 struct lttcomm_sock {
 376         int32_t fd;
 377         enum lttcomm_sock_proto proto;
 378         struct lttcomm_sockaddr sockaddr;
 379         const struct lttcomm_proto_ops *ops;
 380 };
 381
 382 /*
 383  * Relayd sock. Adds the protocol version to use for the communications with
 384  * the relayd.
 385  */
 386 struct lttcomm_relayd_sock {
 387         struct lttcomm_sock sock;
 388         uint32_t major;
 389         uint32_t minor;
 390 };
 391
 392 struct lttcomm_net_family {
 393         int family;
 394         int (*create)(struct lttcomm_sock *sock, int type, int proto);
 395 };
 396
 397 struct lttcomm_proto_ops {
 398         int (*bind)(struct lttcomm_sock *sock);
 399         int (*close)(struct lttcomm_sock *sock);
 400         int (*connect)(struct lttcomm_sock *sock);
 401         struct lttcomm_sock *(*accept)(struct lttcomm_sock *sock);
 402         int (*listen)(struct lttcomm_sock *sock, int backlog);
 403         ssize_t (*recvmsg)(struct lttcomm_sock *sock, void *buf, size_t len, int flags);
 404         ssize_t (*sendmsg)(struct lttcomm_sock *sock, const void *buf, size_t len, int flags);
 405 };
 406
 407 struct process_attr_integral_value_comm {
 408         union {
 409                 int64_t _signed;
 410                 uint64_t _unsigned;
 411         } u;
 412 } LTTNG_PACKED;
 413
 414 /*
 415  * Data structure received from lttng client to session daemon.
 416  */
 417 struct lttcomm_session_msg {
 418         uint32_t cmd_type; /* enum lttcomm_sessiond_command */
 419         struct lttng_session session;
 420         struct lttng_domain domain;
 421         union {
 422                 /* Event data */
 423                 struct {
 424                         char channel_name[LTTNG_SYMBOL_NAME_LEN];
 425                         uint32_t length;
 426                 } LTTNG_PACKED enable;
 427                 struct {
 428                         char channel_name[LTTNG_SYMBOL_NAME_LEN];
 429                         uint32_t length;
 430                 } LTTNG_PACKED disable;
 431                 /* Create channel */
 432                 struct {
 433                         uint32_t length;
 434                 } LTTNG_PACKED channel;
 435                 /* Context */
 436                 struct {
 437                         char channel_name[LTTNG_SYMBOL_NAME_LEN];
 438                         uint32_t length;
 439                 } LTTNG_PACKED context;
 440                 /* Use by register_consumer */
 441                 struct {
 442                         char path[PATH_MAX];
 443                 } LTTNG_PACKED reg;
 444                 /* List */
 445                 struct {
 446                         char channel_name[LTTNG_SYMBOL_NAME_LEN];
 447                 } LTTNG_PACKED list;
 448                 struct lttng_calibrate calibrate;
 449                 /* Used by the set_consumer_url and used by create_session also call */
 450                 struct {
 451                         /* Number of lttng_uri following */
 452                         uint32_t size;
 453                 } LTTNG_PACKED uri;
 454                 struct {
 455                         struct lttng_snapshot_output output;
 456                 } LTTNG_PACKED snapshot_output;
 457                 struct {
 458                         uint32_t wait;
 459                         struct lttng_snapshot_output output;
 460                 } LTTNG_PACKED snapshot_record;
 461                 struct {
 462                         uint32_t nb_uri;
 463                         unsigned int timer_interval; /* usec */
 464                 } LTTNG_PACKED session_live;
 465                 struct {
 466                         struct lttng_save_session_attr attr;
 467                 } LTTNG_PACKED save_session;
 468                 struct {
 469                         char shm_path[PATH_MAX];
 470                 } LTTNG_PACKED set_shm_path;
 471                 struct {
 472                         /* enum lttng_process_attr */
 473                         int32_t process_attr;
 474                         /* enum lttng_process_attr_value_type */
 475                         int32_t value_type;
 476
 477                         struct process_attr_integral_value_comm integral_value;
 478                         /*
 479                          * For user/group names, a variable length,
 480                          * zero-terminated, string of length 'name_len'
 481                          * (including the terminator) follows.
 482                          *
 483                          * integral_value should not be used in those cases.
 484                          */
 485                         uint32_t name_len;
 486                 } LTTNG_PACKED process_attr_tracker_add_remove_include_value;
 487                 struct {
 488                         /* enum lttng_process_attr */
 489                         int32_t process_attr;
 490                 } LTTNG_PACKED process_attr_tracker_get_inclusion_set;
 491                 struct {
 492                         /* enum lttng_process_attr */
 493                         int32_t process_attr;
 494                 } LTTNG_PACKED process_attr_tracker_get_tracking_policy;
 495                 struct {
 496                         /* enum lttng_process_attr */
 497                         int32_t process_attr;
 498                         /* enum lttng_tracking_policy */
 499                         int32_t tracking_policy;
 500                 } LTTNG_PACKED process_attr_tracker_set_tracking_policy;
 501                 struct {
 502                         uint32_t length;
 503                         uint8_t is_trigger_anonymous;
 504                 } LTTNG_PACKED trigger;
 505                 struct {
 506                         uint32_t length;
 507                 } LTTNG_PACKED error_query;
 508                 struct {
 509                         uint64_t rotation_id;
 510                 } LTTNG_PACKED get_rotation_info;
 511                 struct {
 512                         /* enum lttng_rotation_schedule_type */
 513                         uint8_t type;
 514                         /*
 515                          * If set == 1, set schedule to value, if set == 0,
 516                          * clear this schedule type.
 517                          */
 518                         uint8_t set;
 519                         uint64_t value;
 520                 } LTTNG_PACKED rotation_set_schedule;
 521                 struct {
 522                         /*
 523                          * Includes the null-terminator.
 524                          * Must be an absolute path.
 525                          *
 526                          * Size bounded by LTTNG_PATH_MAX.
 527                          */
 528                         uint16_t home_dir_size;
 529                         uint64_t session_descriptor_size;
 530                         /* An lttng_session_descriptor follows. */
 531                 } LTTNG_PACKED create_session;
 532         } u;
 533         /* Count of fds sent. */
 534         uint32_t fd_count;
 535 } LTTNG_PACKED;
 536
 537 #define LTTNG_FILTER_MAX_LEN             65536
 538 #define LTTNG_SESSION_DESCRIPTOR_MAX_LEN 65536
 539
 540 /*
 541  * Filter bytecode data. The reloc table is located at the end of the
 542  * bytecode. It is made of tuples: (uint16_t, var. len. string). It
 543  * starts at reloc_table_offset.
 544  */
 545 #define LTTNG_FILTER_PADDING 32
 546 struct lttng_bytecode {
 547         uint32_t len; /* len of data */
 548         uint32_t reloc_table_offset;
 549         uint64_t seqnum;
 550         char padding[LTTNG_FILTER_PADDING];
 551         char data[0];
 552 } LTTNG_PACKED;
 553
 554 /*
 555  * Event exclusion data. At the end of the structure, there will actually
 556  * by zero or more names, where the actual number of names is given by
 557  * the 'count' item of the structure.
 558  */
 559 #define LTTNG_EVENT_EXCLUSION_PADDING 32
 560 struct lttng_event_exclusion {
 561         uint32_t count;
 562         char padding[LTTNG_EVENT_EXCLUSION_PADDING];
 563         char names[LTTNG_FLEXIBLE_ARRAY_MEMBER_LENGTH][LTTNG_SYMBOL_NAME_LEN];
 564 } LTTNG_PACKED;
 565
 566 #define LTTNG_EVENT_EXCLUSION_NAME_AT(_exclusion, _i) ((_exclusion)->names[_i])
 567
 568 /*
 569  * Listing command header.
 570  */
 571 struct lttcomm_list_command_header {
 572         /* Number of elements */
 573         uint32_t count;
 574 } LTTNG_PACKED;
 575
 576 /*
 577  * Event extended info header. This is the structure preceding each
 578  * extended info data.
 579  */
 580 struct lttcomm_event_extended_header {
 581         /*
 582          * Size of filter string immediately following this header.
 583          * This size includes the terminal null character.
 584          */
 585         uint32_t filter_len;
 586
 587         /*
 588          * Number of exclusion names, immediately following the filter
 589          * string. Each exclusion name has a fixed length of
 590          * LTTNG_SYMBOL_NAME_LEN bytes, including the terminal null
 591          * character.
 592          */
 593         uint32_t nb_exclusions;
 594
 595         /*
 596          * Size of the event's userspace probe location (if applicable).
 597          */
 598         uint32_t userspace_probe_location_len;
 599 } LTTNG_PACKED;
 600
 601 /*
 602  * Command header of the reply to an LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION command.
 603  */
 604 struct lttcomm_session_destroy_command_header {
 605         /* enum lttng_session */
 606         int32_t rotation_state;
 607 };
 608
 609 /*
 610  * tracker command header.
 611  */
 612 struct lttcomm_tracker_command_header {
 613         uint32_t nb_tracker_id;
 614 } LTTNG_PACKED;
 615
 616 /*
 617  * Data structure for the response from sessiond to the lttng client.
 618  */
 619 struct lttcomm_lttng_msg {
 620         uint32_t cmd_type; /* enum lttcomm_sessiond_command */
 621         uint32_t ret_code; /* enum lttcomm_return_code */
 622         uint32_t pid; /* pid_t */
 623         uint32_t cmd_header_size;
 624         uint32_t data_size;
 625         uint32_t fd_count;
 626 } LTTNG_PACKED;
 627
 628 struct lttcomm_lttng_output_id {
 629         uint32_t id;
 630 } LTTNG_PACKED;
 631
 632 /*
 633  * lttcomm_consumer_msg is the message sent from sessiond to consumerd
 634  * to either add a channel, add a stream, update a stream, or stop
 635  * operation.
 636  */
 637 struct lttcomm_consumer_msg {
 638         uint32_t cmd_type; /* enum lttng_consumer_command */
 639         union {
 640                 struct {
 641                         uint64_t channel_key;
 642                         uint64_t session_id;
 643                         /* ID of the session's current trace chunk. */
 644                         LTTNG_OPTIONAL_COMM(uint64_t) LTTNG_PACKED chunk_id;
 645                         char pathname[PATH_MAX];
 646                         uint64_t relayd_id;
 647                         /* nb_init_streams is the number of streams open initially. */
 648                         uint32_t nb_init_streams;
 649                         char name[LTTNG_SYMBOL_NAME_LEN];
 650                         /* Use splice or mmap to consume this fd */
 651                         enum lttng_event_output output;
 652                         int type; /* Per cpu or metadata. */
 653                         uint64_t tracefile_size; /* bytes */
 654                         uint32_t tracefile_count; /* number of tracefiles */
 655                         /* If the channel's streams have to be monitored or not. */
 656                         uint32_t monitor;
 657                         /* timer to check the streams usage in live mode (usec). */
 658                         unsigned int live_timer_interval;
 659                         /* is part of a live session */
 660                         uint8_t is_live;
 661                         /* timer to sample a channel's positions (usec). */
 662                         unsigned int monitor_timer_interval;
 663                 } LTTNG_PACKED channel; /* Only used by Kernel. */
 664                 struct {
 665                         uint64_t stream_key;
 666                         uint64_t channel_key;
 667                         int32_t cpu; /* On which CPU this stream is assigned. */
 668                         /* Tells the consumer if the stream should be or not monitored. */
 669                         uint32_t no_monitor;
 670                 } LTTNG_PACKED stream; /* Only used by Kernel. */
 671                 struct {
 672                         uint64_t net_index;
 673                         enum lttng_stream_type type;
 674                         uint32_t major;
 675                         uint32_t minor;
 676                         uint8_t relayd_socket_protocol;
 677                         /* Tracing session id associated to the relayd. */
 678                         uint64_t session_id;
 679                         /* Relayd session id, only used with control socket. */
 680                         uint64_t relayd_session_id;
 681                 } LTTNG_PACKED relayd_sock;
 682                 struct {
 683                         uint64_t net_seq_idx;
 684                 } LTTNG_PACKED destroy_relayd;
 685                 struct {
 686                         uint64_t session_id;
 687                 } LTTNG_PACKED data_pending;
 688                 struct {
 689                         uint64_t subbuf_size; /* bytes */
 690                         uint64_t num_subbuf; /* power of 2 */
 691                         int32_t overwrite; /* 1: overwrite, 0: discard */
 692                         uint32_t switch_timer_interval; /* usec */
 693                         uint32_t read_timer_interval; /* usec */
 694                         unsigned int live_timer_interval; /* usec */
 695                         uint8_t is_live; /* is part of a live session */
 696                         uint32_t monitor_timer_interval; /* usec */
 697                         int32_t output; /* splice, mmap */
 698                         int32_t type; /* metadata or per_cpu */
 699                         uint64_t session_id; /* Tracing session id */
 700                         char pathname[PATH_MAX]; /* Channel file path. */
 701                         char name[LTTNG_SYMBOL_NAME_LEN]; /* Channel name. */
 702                         /* Credentials used to open the UST buffer shared mappings. */
 703                         struct {
 704                                 uint32_t uid;
 705                                 uint32_t gid;
 706                         } LTTNG_PACKED buffer_credentials;
 707                         uint64_t relayd_id; /* Relayd id if apply. */
 708                         uint64_t key; /* Unique channel key. */
 709                         /* ID of the session's current trace chunk. */
 710                         LTTNG_OPTIONAL_COMM(uint64_t) LTTNG_PACKED chunk_id;
 711                         unsigned char uuid[LTTNG_UUID_LEN]; /* uuid for ust tracer. */
 712                         uint32_t chan_id; /* Channel ID on the tracer side. */
 713                         uint64_t tracefile_size; /* bytes */
 714                         uint32_t tracefile_count; /* number of tracefiles */
 715                         uint64_t session_id_per_pid; /* Per-pid session ID. */
 716                         /* Tells the consumer if the stream should be or not monitored. */
 717                         uint32_t monitor;
 718                         /*
 719                          * For UST per UID buffers, this is the application UID of the
 720                          * channel.  This can be different from the user UID requesting the
 721                          * channel creation and used for the rights on the stream file
 722                          * because the application can be in the tracing for instance.
 723                          */
 724                         uint32_t ust_app_uid;
 725                         int64_t blocking_timeout;
 726                         char root_shm_path[PATH_MAX];
 727                         char shm_path[PATH_MAX];
 728                 } LTTNG_PACKED ask_channel;
 729                 struct {
 730                         uint64_t key;
 731                 } LTTNG_PACKED get_channel;
 732                 struct {
 733                         uint64_t key;
 734                 } LTTNG_PACKED destroy_channel;
 735                 struct {
 736                         uint64_t key; /* Metadata channel key. */
 737                         uint64_t target_offset; /* Offset in the consumer */
 738                         uint64_t len; /* Length of metadata to be received. */
 739                         uint64_t version; /* Version of the metadata. */
 740                 } LTTNG_PACKED push_metadata;
 741                 struct {
 742                         uint64_t key; /* Metadata channel key. */
 743                 } LTTNG_PACKED close_metadata;
 744                 struct {
 745                         uint64_t key; /* Metadata channel key. */
 746                 } LTTNG_PACKED setup_metadata;
 747                 struct {
 748                         uint64_t key; /* Channel key. */
 749                 } LTTNG_PACKED flush_channel;
 750                 struct {
 751                         uint64_t key; /* Channel key. */
 752                 } LTTNG_PACKED clear_quiescent_channel;
 753                 struct {
 754                         char pathname[PATH_MAX];
 755                         /* Indicate if the snapshot goes on the relayd or locally. */
 756                         uint32_t use_relayd;
 757                         uint32_t metadata; /* This a metadata snapshot. */
 758                         uint64_t relayd_id; /* Relayd id if apply. */
 759                         uint64_t key;
 760                         uint64_t nb_packets_per_stream;
 761                 } LTTNG_PACKED snapshot_channel;
 762                 struct {
 763                         uint64_t channel_key;
 764                         uint64_t net_seq_idx;
 765                 } LTTNG_PACKED sent_streams;
 766                 struct {
 767                         uint64_t session_id;
 768                         uint64_t channel_key;
 769                 } LTTNG_PACKED discarded_events;
 770                 struct {
 771                         uint64_t session_id;
 772                         uint64_t channel_key;
 773                 } LTTNG_PACKED lost_packets;
 774                 struct {
 775                         uint64_t session_id;
 776                 } LTTNG_PACKED regenerate_metadata;
 777                 struct {
 778                         uint32_t metadata; /* This is a metadata channel. */
 779                         uint64_t relayd_id; /* Relayd id if apply. */
 780                         uint64_t key;
 781                 } LTTNG_PACKED rotate_channel;
 782                 struct {
 783                         uint64_t session_id;
 784                         uint64_t chunk_id;
 785                 } LTTNG_PACKED check_rotation_pending_local;
 786                 struct {
 787                         uint64_t relayd_id;
 788                         uint64_t session_id;
 789                         uint64_t chunk_id;
 790                 } LTTNG_PACKED check_rotation_pending_relay;
 791                 struct {
 792                         /*
 793                          * Relayd id, if applicable (remote).
 794                          *
 795                          * A directory file descriptor referring to the chunk's
 796                          * output folder is transmitted if the chunk is local
 797                          * (relayd_id unset).
 798                          *
 799                          * `override_name` is left NULL (all-zeroes) if the
 800                          * chunk's name is not overridden.
 801                          */
 802                         LTTNG_OPTIONAL_COMM(uint64_t) LTTNG_PACKED relayd_id;
 803                         char override_name[LTTNG_NAME_MAX];
 804                         uint64_t session_id;
 805                         uint64_t chunk_id;
 806                         uint64_t creation_timestamp;
 807                         LTTNG_OPTIONAL_COMM(struct {
 808                                 uint32_t uid;
 809                                 uint32_t gid;
 810                         } LTTNG_PACKED)
 811                         LTTNG_PACKED credentials;
 812                 } LTTNG_PACKED create_trace_chunk;
 813                 struct {
 814                         LTTNG_OPTIONAL_COMM(uint64_t) LTTNG_PACKED relayd_id;
 815                         uint64_t session_id;
 816                         uint64_t chunk_id;
 817                         uint64_t close_timestamp;
 818                         /* enum lttng_trace_chunk_command_type */
 819                         LTTNG_OPTIONAL_COMM(uint32_t) LTTNG_PACKED close_command;
 820                 } LTTNG_PACKED close_trace_chunk;
 821                 struct {
 822                         LTTNG_OPTIONAL_COMM(uint64_t) LTTNG_PACKED relayd_id;
 823                         uint64_t session_id;
 824                         uint64_t chunk_id;
 825                 } LTTNG_PACKED trace_chunk_exists;
 826                 struct {
 827                         uint8_t sessiond_uuid[LTTNG_UUID_LEN];
 828                 } LTTNG_PACKED init;
 829                 struct {
 830                         uint64_t key;
 831                 } LTTNG_PACKED clear_channel;
 832                 struct {
 833                         uint64_t key;
 834                 } LTTNG_PACKED open_channel_packets;
 835         } u;
 836 } LTTNG_PACKED;
 837
 838 /*
 839  * Channel monitoring message returned to the session daemon on every
 840  * monitor timer expiration.
 841  */
 842 struct lttcomm_consumer_channel_monitor_msg {
 843         /* Key of the sampled channel. */
 844         uint64_t key;
 845         /* Id of the sampled channel's session. */
 846         uint64_t session_id;
 847         /*
 848          * Lowest and highest usage (bytes) at the moment the sample was taken.
 849          */
 850         uint64_t lowest, highest;
 851         /*
 852          * Sum of all the consumed positions for a channel.
 853          */
 854         uint64_t consumed_since_last_sample;
 855 } LTTNG_PACKED;
 856
 857 /*
 858  * Status message returned to the sessiond after a received command.
 859  */
 860 struct lttcomm_consumer_status_msg {
 861         enum lttcomm_return_code ret_code;
 862 } LTTNG_PACKED;
 863
 864 struct lttcomm_consumer_status_channel {
 865         enum lttcomm_return_code ret_code;
 866         uint64_t key;
 867         unsigned int stream_count;
 868 } LTTNG_PACKED;
 869
 870 struct lttcomm_consumer_close_trace_chunk_reply {
 871         enum lttcomm_return_code ret_code;
 872         uint32_t path_length;
 873         char path[];
 874 };
 875
 876 #ifdef HAVE_LIBLTTNG_UST_CTL
 877
 878 #include <lttng/ust-abi.h>
 879
 880 /*
 881  * Data structure for the commands sent from sessiond to UST.
 882  */
 883 struct lttcomm_ust_msg {
 884         uint32_t handle;
 885         uint32_t cmd;
 886         union {
 887                 struct lttng_ust_abi_channel channel;
 888                 struct lttng_ust_abi_stream stream;
 889                 struct lttng_ust_abi_event event;
 890                 struct lttng_ust_abi_context context;
 891                 struct lttng_ust_abi_tracer_version version;
 892         } u;
 893 } LTTNG_PACKED;
 894
 895 /*
 896  * Data structure for the response from UST to the session daemon.
 897  * cmd_type is sent back in the reply for validation.
 898  */
 899 struct lttcomm_ust_reply {
 900         uint32_t handle;
 901         uint32_t cmd;
 902         uint32_t ret_code; /* enum lttcomm_return_code */
 903         uint32_t ret_val; /* return value */
 904         union {
 905                 struct {
 906                         uint64_t memory_map_size;
 907                 } LTTNG_PACKED channel;
 908                 struct {
 909                         uint64_t memory_map_size;
 910                 } LTTNG_PACKED stream;
 911                 struct lttng_ust_abi_tracer_version version;
 912         } u;
 913 } LTTNG_PACKED;
 914
 915 #endif /* HAVE_LIBLTTNG_UST_CTL */
 916
 917 const char *lttcomm_get_readable_code(enum lttcomm_return_code code);
 918
 919 int lttcomm_init_inet_sockaddr(struct lttcomm_sockaddr *sockaddr,
 920                                const char *ip,
 921                                unsigned int port);
 922 int lttcomm_init_inet6_sockaddr(struct lttcomm_sockaddr *sockaddr,
 923                                 const char *ip,
 924                                 unsigned int port);
 925
 926 struct lttcomm_sock *lttcomm_alloc_sock(enum lttcomm_sock_proto proto);
 927 int lttcomm_populate_sock_from_open_socket(struct lttcomm_sock *sock,
 928                                            int fd,
 929                                            enum lttcomm_sock_proto protocol);
 930 int lttcomm_create_sock(struct lttcomm_sock *sock);
 931 struct lttcomm_sock *lttcomm_alloc_sock_from_uri(struct lttng_uri *uri);
 932 void lttcomm_destroy_sock(struct lttcomm_sock *sock);
 933 struct lttcomm_sock *lttcomm_alloc_copy_sock(struct lttcomm_sock *src);
 934 void lttcomm_copy_sock(struct lttcomm_sock *dst, struct lttcomm_sock *src);
 935
 936 /* Relayd socket object. */
 937 struct lttcomm_relayd_sock *
 938 lttcomm_alloc_relayd_sock(struct lttng_uri *uri, uint32_t major, uint32_t minor);
 939
 940 int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec);
 941 int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec);
 942
 943 int lttcomm_sock_get_port(const struct lttcomm_sock *sock, uint16_t *port);
 944 /*
 945  * Set a port to an lttcomm_sock. This will have no effect is the socket is
 946  * already bound.
 947  */
 948 int lttcomm_sock_set_port(struct lttcomm_sock *sock, uint16_t port);
 949
 950 void lttcomm_init();
 951 /* Get network timeout, in milliseconds */
 952 unsigned long lttcomm_get_network_timeout();
 953
 954 #endif /* _LTTNG_SESSIOND_COMM_H */