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