X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fsessiond-comm%2Fsessiond-comm.h;h=c52a6caa0575272788797786b373b85ba286bce9;hp=eb13734a684912b9fc3c11d086c1433b704108e8;hb=783a3b9aa609d6805e1463655d25c7ae176c4859;hpb=44a5e5eb99f1d8b528f83fda5585677a3882f5f5 diff --git a/src/common/sessiond-comm/sessiond-comm.h b/src/common/sessiond-comm/sessiond-comm.h index eb13734a6..c52a6caa0 100644 --- a/src/common/sessiond-comm/sessiond-comm.h +++ b/src/common/sessiond-comm/sessiond-comm.h @@ -28,7 +28,11 @@ #define _GNU_SOURCE #include #include +#include #include +#include +#include +#include #include #include @@ -47,151 +51,81 @@ /* * Get the error code index from 0 since LTTCOMM_OK start at 1000 */ -#define LTTCOMM_ERR_INDEX(code) (code - LTTCOMM_OK) +#define LTTCOMM_ERR_INDEX(code) (code - LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) enum lttcomm_sessiond_command { /* Tracer command */ - LTTNG_ADD_CONTEXT, - LTTNG_CALIBRATE, - LTTNG_DISABLE_CHANNEL, - LTTNG_DISABLE_EVENT, - LTTNG_DISABLE_ALL_EVENT, - LTTNG_ENABLE_CHANNEL, - LTTNG_ENABLE_EVENT, - LTTNG_ENABLE_ALL_EVENT, + LTTNG_ADD_CONTEXT = 0, + LTTNG_CALIBRATE = 1, + LTTNG_DISABLE_CHANNEL = 2, + LTTNG_DISABLE_EVENT = 3, + LTTNG_DISABLE_ALL_EVENT = 4, + LTTNG_ENABLE_CHANNEL = 5, + LTTNG_ENABLE_EVENT = 6, + LTTNG_ENABLE_ALL_EVENT = 7, /* Session daemon command */ - LTTNG_CREATE_SESSION, - LTTNG_CREATE_SESSION_URI, - LTTNG_DESTROY_SESSION, - LTTNG_LIST_CHANNELS, - LTTNG_LIST_DOMAINS, - LTTNG_LIST_EVENTS, - LTTNG_LIST_SESSIONS, - LTTNG_LIST_TRACEPOINTS, - LTTNG_REGISTER_CONSUMER, - LTTNG_START_TRACE, - LTTNG_STOP_TRACE, - LTTNG_LIST_TRACEPOINT_FIELDS, + LTTNG_CREATE_SESSION = 8, + LTTNG_DESTROY_SESSION = 9, + LTTNG_LIST_CHANNELS = 10, + LTTNG_LIST_DOMAINS = 11, + LTTNG_LIST_EVENTS = 12, + LTTNG_LIST_SESSIONS = 13, + LTTNG_LIST_TRACEPOINTS = 14, + LTTNG_REGISTER_CONSUMER = 15, + LTTNG_START_TRACE = 16, + LTTNG_STOP_TRACE = 17, + LTTNG_LIST_TRACEPOINT_FIELDS = 18, /* Consumer */ - LTTNG_DISABLE_CONSUMER, - LTTNG_ENABLE_CONSUMER, - LTTNG_SET_CONSUMER_URI, - /* Relay daemon */ - RELAYD_ADD_STREAM, - RELAYD_CREATE_SESSION, - RELAYD_START_DATA, - RELAYD_UPDATE_SYNC_INFO, - RELAYD_VERSION, - RELAYD_SEND_METADATA, - LTTNG_SET_FILTER, - LTTNG_HEALTH_CHECK, + LTTNG_DISABLE_CONSUMER = 19, + LTTNG_ENABLE_CONSUMER = 20, + LTTNG_SET_CONSUMER_URI = 21, + LTTNG_ENABLE_EVENT_WITH_FILTER = 22, + LTTNG_HEALTH_CHECK = 23, + LTTNG_DATA_PENDING = 24, + LTTNG_SNAPSHOT_ADD_OUTPUT = 25, + LTTNG_SNAPSHOT_DEL_OUTPUT = 26, + LTTNG_SNAPSHOT_LIST_OUTPUT = 27, + LTTNG_SNAPSHOT_RECORD = 28, + LTTNG_CREATE_SESSION_SNAPSHOT = 29, +}; + +enum lttcomm_relayd_command { + RELAYD_ADD_STREAM = 1, + RELAYD_CREATE_SESSION = 2, + RELAYD_START_DATA = 3, + RELAYD_UPDATE_SYNC_INFO = 4, + RELAYD_VERSION = 5, + RELAYD_SEND_METADATA = 6, + RELAYD_CLOSE_STREAM = 7, + RELAYD_DATA_PENDING = 8, + RELAYD_QUIESCENT_CONTROL = 9, + RELAYD_BEGIN_DATA_PENDING = 10, + RELAYD_END_DATA_PENDING = 11, }; /* * lttcomm error code. */ enum lttcomm_return_code { - LTTCOMM_OK = 10, /* Ok */ - LTTCOMM_ERR, /* Unknown Error */ - LTTCOMM_UND, /* Undefine command */ - LTTCOMM_NOT_IMPLEMENTED, /* Command not implemented */ - LTTCOMM_UNKNOWN_DOMAIN, /* Tracing domain not known */ - LTTCOMM_ALLOC_FAIL, /* Trace allocation fail */ - LTTCOMM_NO_SESSION, /* No session found */ - LTTCOMM_CREATE_DIR_FAIL, /* Create directory fail */ - LTTCOMM_SESSION_FAIL, /* Create session fail */ - LTTCOMM_START_FAIL, /* Start tracing fail */ - LTTCOMM_STOP_FAIL, /* Stop tracing fail */ - LTTCOMM_LIST_FAIL, /* Listing apps fail */ - LTTCOMM_NO_APPS, /* No traceable application */ - LTTCOMM_SESS_NOT_FOUND, /* Session name not found */ - LTTCOMM_NO_TRACE, /* No trace exist */ - LTTCOMM_FATAL, /* Session daemon had a fatal error */ - LTTCOMM_NO_TRACEABLE, /* Error for non traceable app */ - LTTCOMM_SELECT_SESS, /* Must select a session */ - LTTCOMM_EXIST_SESS, /* Session name already exist */ - LTTCOMM_NO_EVENT, /* No event found */ - LTTCOMM_CONNECT_FAIL, /* Unable to connect to unix socket */ - LTTCOMM_APP_NOT_FOUND, /* App not found in traceable app list */ - LTTCOMM_EPERM, /* Permission denied */ - LTTCOMM_KERN_NA, /* Kernel tracer unavalable */ - LTTCOMM_KERN_VERSION, /* Kernel tracer version is not compatible */ - LTTCOMM_KERN_EVENT_EXIST, /* Kernel event already exists */ - LTTCOMM_KERN_SESS_FAIL, /* Kernel create session failed */ - LTTCOMM_KERN_CHAN_EXIST, /* Kernel channel already exists */ - LTTCOMM_KERN_CHAN_FAIL, /* Kernel create channel failed */ - LTTCOMM_KERN_CHAN_NOT_FOUND, /* Kernel channel not found */ - LTTCOMM_KERN_CHAN_DISABLE_FAIL, /* Kernel disable channel failed */ - LTTCOMM_KERN_CHAN_ENABLE_FAIL, /* Kernel enable channel failed */ - LTTCOMM_KERN_CONTEXT_FAIL, /* Kernel add context failed */ - LTTCOMM_KERN_ENABLE_FAIL, /* Kernel enable event failed */ - LTTCOMM_KERN_DISABLE_FAIL, /* Kernel disable event failed */ - LTTCOMM_KERN_META_FAIL, /* Kernel open metadata failed */ - LTTCOMM_KERN_START_FAIL, /* Kernel start trace failed */ - LTTCOMM_KERN_STOP_FAIL, /* Kernel stop trace failed */ - LTTCOMM_KERN_CONSUMER_FAIL, /* Kernel consumer start failed */ - LTTCOMM_KERN_STREAM_FAIL, /* Kernel create stream failed */ - LTTCOMM_KERN_DIR_FAIL, /* Kernel trace directory creation failed */ - LTTCOMM_KERN_DIR_EXIST, /* Kernel trace directory exist */ - LTTCOMM_KERN_NO_SESSION, /* No kernel session found */ - LTTCOMM_KERN_LIST_FAIL, /* Kernel listing events failed */ - LTTCOMM_UST_CALIBRATE_FAIL, /* UST calibration failed */ - LTTCOMM_UST_VERSION, /* UST tracer version is not compatible */ - LTTCOMM_UST_SESS_FAIL, /* UST create session failed */ - LTTCOMM_UST_CHAN_EXIST, /* UST channel already exist */ - LTTCOMM_UST_CHAN_FAIL, /* UST create channel failed */ - LTTCOMM_UST_CHAN_NOT_FOUND, /* UST channel not found */ - LTTCOMM_UST_CHAN_DISABLE_FAIL, /* UST disable channel failed */ - LTTCOMM_UST_CHAN_ENABLE_FAIL, /* UST enable channel failed */ - LTTCOMM_UST_CONTEXT_FAIL, /* UST add context failed */ - LTTCOMM_UST_ENABLE_FAIL, /* UST enable event failed */ - LTTCOMM_UST_DISABLE_FAIL, /* UST disable event failed */ - LTTCOMM_UST_META_FAIL, /* UST open metadata failed */ - LTTCOMM_UST_START_FAIL, /* UST start trace failed */ - LTTCOMM_UST_STOP_FAIL, /* UST stop trace failed */ - LTTCOMM_UST_CONSUMER64_FAIL, /* 64-bit UST consumer start failed */ - LTTCOMM_UST_CONSUMER32_FAIL, /* 32-bit UST consumer start failed */ - LTTCOMM_UST_STREAM_FAIL, /* UST create stream failed */ - LTTCOMM_UST_DIR_FAIL, /* UST trace directory creation failed */ - LTTCOMM_UST_DIR_EXIST, /* UST trace directory exist */ - LTTCOMM_UST_NO_SESSION, /* No UST session found */ - LTTCOMM_UST_LIST_FAIL, /* UST listing events failed */ - LTTCOMM_UST_EVENT_EXIST, /* UST event exist */ - LTTCOMM_UST_EVENT_NOT_FOUND, /* UST event not found */ - LTTCOMM_UST_CONTEXT_EXIST, /* UST context exist */ - LTTCOMM_UST_CONTEXT_INVAL, /* UST context invalid */ - LTTCOMM_NEED_ROOT_SESSIOND, /* root sessiond is needed */ - LTTCOMM_TRACE_ALREADY_STARTED, /* Tracing already started */ - LTTCOMM_TRACE_ALREADY_STOPPED, /* Tracing already stopped */ - LTTCOMM_KERN_EVENT_ENOSYS, /* Kernel event type not supported */ - - CONSUMERD_COMMAND_SOCK_READY, /* when consumerd command socket ready */ - CONSUMERD_SUCCESS_RECV_FD, /* success on receiving fds */ - CONSUMERD_ERROR_RECV_FD, /* error on receiving fds */ - CONSUMERD_ERROR_RECV_CMD, /* error on receiving command */ - CONSUMERD_POLL_ERROR, /* Error in polling thread in kconsumerd */ - CONSUMERD_POLL_NVAL, /* Poll on closed fd */ - CONSUMERD_POLL_HUP, /* All fds have hungup */ - CONSUMERD_EXIT_SUCCESS, /* kconsumerd exiting normally */ - CONSUMERD_EXIT_FAILURE, /* kconsumerd exiting on error */ - CONSUMERD_OUTFD_ERROR, /* error opening the tracefile */ - CONSUMERD_SPLICE_EBADF, /* EBADF from splice(2) */ - CONSUMERD_SPLICE_EINVAL, /* EINVAL from splice(2) */ - CONSUMERD_SPLICE_ENOMEM, /* ENOMEM from splice(2) */ - CONSUMERD_SPLICE_ESPIPE, /* ESPIPE from splice(2) */ - LTTCOMM_INVALID, /* Invalid parameter */ - LTTCOMM_NO_USTCONSUMERD, /* No UST consumer detected */ - LTTCOMM_NO_KERNCONSUMERD, /* No Kernel consumer detected */ - LTTCOMM_EVENT_EXIST_LOGLEVEL, /* Event already enabled with different loglevel */ - LTTCOMM_URI_DATA_MISS, /* Missing network data URI */ - LTTCOMM_URI_CTRL_MISS, /* Missing network control URI */ - LTTCOMM_ENABLE_CONSUMER_FAIL, /* Enabling consumer failed */ - LTTCOMM_RELAYD_SESSION_FAIL, /* lttng-relayd create session failed */ - LTTCOMM_RELAYD_VERSION_FAIL, /* lttng-relayd not compatible */ - LTTCOMM_FILTER_INVAL, /* Invalid filter bytecode */ - LTTCOMM_FILTER_NOMEM, /* Lack of memory for filter bytecode */ - LTTCOMM_FILTER_EXIST, /* Filter already exist */ + LTTCOMM_CONSUMERD_COMMAND_SOCK_READY = 1, /* Command socket ready */ + LTTCOMM_CONSUMERD_SUCCESS_RECV_FD, /* Success on receiving fds */ + LTTCOMM_CONSUMERD_ERROR_RECV_FD, /* Error on receiving fds */ + LTTCOMM_CONSUMERD_ERROR_RECV_CMD, /* Error on receiving command */ + LTTCOMM_CONSUMERD_POLL_ERROR, /* Error in polling thread */ + LTTCOMM_CONSUMERD_POLL_NVAL, /* Poll on closed fd */ + LTTCOMM_CONSUMERD_POLL_HUP, /* All fds have hungup */ + LTTCOMM_CONSUMERD_EXIT_SUCCESS, /* Consumerd exiting normally */ + LTTCOMM_CONSUMERD_EXIT_FAILURE, /* Consumerd exiting on error */ + LTTCOMM_CONSUMERD_OUTFD_ERROR, /* Error opening the tracefile */ + LTTCOMM_CONSUMERD_SPLICE_EBADF, /* EBADF from splice(2) */ + LTTCOMM_CONSUMERD_SPLICE_EINVAL, /* EINVAL from splice(2) */ + LTTCOMM_CONSUMERD_SPLICE_ENOMEM, /* ENOMEM from splice(2) */ + LTTCOMM_CONSUMERD_SPLICE_ESPIPE, /* ESPIPE from splice(2) */ + LTTCOMM_CONSUMERD_ENOMEM, /* Consumer is out of memory */ + LTTCOMM_CONSUMERD_ERROR_METADATA, /* Error with metadata. */ + LTTCOMM_CONSUMERD_FATAL, /* Fatal error. */ + LTTCOMM_CONSUMERD_RELAYD_FAIL, /* Error on remote relayd */ /* MUST be last element */ LTTCOMM_NR, /* Last element */ @@ -207,24 +141,53 @@ enum lttcomm_sock_proto { * Index in the net_families array below. Please keep in sync! */ enum lttcomm_sock_domain { - LTTCOMM_INET = 1, - LTTCOMM_INET6 = 2, + LTTCOMM_INET = 0, + LTTCOMM_INET6 = 1, +}; + +enum lttcomm_metadata_command { + LTTCOMM_METADATA_REQUEST = 1, }; +/* + * Commands sent from the consumerd to the sessiond to request if new metadata + * is available. This message is used to find the per UID _or_ per PID registry + * for the channel key. For per UID lookup, the triplet + * bits_per_long/uid/session_id is used. On lookup failure, we search for the + * per PID registry indexed by session id ignoring the other values. + */ +struct lttcomm_metadata_request_msg { + uint64_t session_id; /* Tracing session id */ + uint64_t session_id_per_pid; /* Tracing session id for per-pid */ + uint32_t bits_per_long; /* Consumer ABI */ + uint32_t uid; + uint64_t key; /* Metadata channel key. */ +} LTTNG_PACKED; + struct lttcomm_sockaddr { enum lttcomm_sock_domain type; union { struct sockaddr_in sin; struct sockaddr_in6 sin6; } addr; -}; +} LTTNG_PACKED; struct lttcomm_sock { - int fd; + int32_t fd; enum lttcomm_sock_proto proto; struct lttcomm_sockaddr sockaddr; const struct lttcomm_proto_ops *ops; -}; +} LTTNG_PACKED; + +/* + * Relayd sock. Adds the protocol version to use for the communications with + * the relayd. + */ +struct lttcomm_relayd_sock { + struct lttcomm_sock sock; + uint32_t major; + uint32_t minor; +} LTTNG_PACKED; struct lttcomm_net_family { int family; @@ -247,87 +210,94 @@ struct lttcomm_proto_ops { * Data structure received from lttng client to session daemon. */ struct lttcomm_session_msg { - uint32_t cmd_type; /* enum lttcomm_sessiond_command */ + uint32_t cmd_type; /* enum lttcomm_sessiond_command */ struct lttng_session session; struct lttng_domain domain; union { struct { - char channel_name[NAME_MAX]; + char channel_name[LTTNG_SYMBOL_NAME_LEN]; char name[NAME_MAX]; - } disable; + } LTTNG_PACKED disable; /* Event data */ struct { - char channel_name[NAME_MAX]; + char channel_name[LTTNG_SYMBOL_NAME_LEN]; struct lttng_event event; - } enable; + /* Length of following bytecode for filter. */ + uint32_t bytecode_len; + } LTTNG_PACKED enable; /* Create channel */ struct { struct lttng_channel chan; - } channel; + } LTTNG_PACKED channel; /* Context */ struct { - char channel_name[NAME_MAX]; - char event_name[NAME_MAX]; + char channel_name[LTTNG_SYMBOL_NAME_LEN]; struct lttng_event_context ctx; - } context; + } LTTNG_PACKED context; /* Use by register_consumer */ struct { char path[PATH_MAX]; - } reg; + } LTTNG_PACKED reg; /* List */ struct { - char channel_name[NAME_MAX]; - } list; + char channel_name[LTTNG_SYMBOL_NAME_LEN]; + } LTTNG_PACKED list; struct lttng_calibrate calibrate; - /* Used by the set_consumer_uri call */ - struct lttng_uri uri; + /* Used by the set_consumer_url and used by create_session also call */ struct { - uint32_t enable_consumer; - struct lttng_uri ctrl_uri; - struct lttng_uri data_uri; - } create_uri; + /* Number of lttng_uri following */ + uint32_t size; + } LTTNG_PACKED uri; struct { - char channel_name[NAME_MAX]; - char event_name[NAME_MAX]; - /* Length of following bytecode */ - uint32_t bytecode_len; - } filter; + struct lttng_snapshot_output output; + } LTTNG_PACKED snapshot_output; + struct { + uint32_t wait; + struct lttng_snapshot_output output; + } LTTNG_PACKED snapshot_record; } u; -}; +} LTTNG_PACKED; -#define LTTNG_FILTER_MAX_LEN 65336 +#define LTTNG_FILTER_MAX_LEN 65536 /* * Filter bytecode data. The reloc table is located at the end of the * bytecode. It is made of tuples: (uint16_t, var. len. string). It * starts at reloc_table_offset. */ +#define LTTNG_FILTER_PADDING 32 struct lttng_filter_bytecode { - uint16_t len; /* len of data */ - uint16_t reloc_table_offset; + uint32_t len; /* len of data */ + uint32_t reloc_table_offset; + uint64_t seqnum; + char padding[LTTNG_FILTER_PADDING]; char data[0]; -}; +} LTTNG_PACKED; /* * Data structure for the response from sessiond to the lttng client. */ struct lttcomm_lttng_msg { - uint32_t cmd_type; /* enum lttcomm_sessiond_command */ - uint32_t ret_code; /* enum lttcomm_return_code */ - uint32_t pid; /* pid_t */ + uint32_t cmd_type; /* enum lttcomm_sessiond_command */ + uint32_t ret_code; /* enum lttcomm_return_code */ + uint32_t pid; /* pid_t */ uint32_t data_size; /* Contains: trace_name + data */ char payload[]; -}; +} LTTNG_PACKED; + +struct lttcomm_lttng_output_id { + uint32_t id; +} LTTNG_PACKED; struct lttcomm_health_msg { uint32_t component; uint32_t cmd; -}; +} LTTNG_PACKED; struct lttcomm_health_data { uint32_t ret_code; -}; +} LTTNG_PACKED; /* * lttcomm_consumer_msg is the message sent from sessiond to consumerd @@ -338,34 +308,111 @@ struct lttcomm_consumer_msg { uint32_t cmd_type; /* enum consumerd_command */ union { struct { - int channel_key; - uint64_t max_sb_size; /* the subbuffer size for this channel */ - /* shm_fd and wait_fd are sent as ancillary data */ - uint64_t mmap_len; + uint64_t channel_key; + uint64_t session_id; + char pathname[PATH_MAX]; + uint32_t uid; + uint32_t gid; + uint64_t relayd_id; + /* nb_init_streams is the number of streams open initially. */ + uint32_t nb_init_streams; char name[LTTNG_SYMBOL_NAME_LEN]; - } channel; + /* Use splice or mmap to consume this fd */ + enum lttng_event_output output; + int type; /* Per cpu or metadata. */ + uint64_t tracefile_size; /* bytes */ + uint32_t tracefile_count; /* number of tracefiles */ + /* If the channel's streams have to be monitored or not. */ + uint32_t monitor; + } LTTNG_PACKED channel; /* Only used by Kernel. */ struct { - int channel_key; - int stream_key; - /* shm_fd and wait_fd are sent as ancillary data */ - uint32_t state; /* enum lttcomm_consumer_fd_state */ - enum lttng_event_output output; /* use splice or mmap to consume this fd */ - uint64_t mmap_len; - uid_t uid; /* User ID owning the session */ - gid_t gid; /* Group ID owning the session */ - char path_name[PATH_MAX]; - int net_index; - unsigned int metadata_flag; - char name[LTTNG_SYMBOL_NAME_LEN]; /* Name string of the stream */ - } stream; + uint64_t stream_key; + uint64_t channel_key; + int32_t cpu; /* On which CPU this stream is assigned. */ + /* Tells the consumer if the stream should be or not monitored. */ + uint32_t no_monitor; + } LTTNG_PACKED stream; /* Only used by Kernel. */ struct { - int net_index; + uint64_t net_index; enum lttng_stream_type type; /* Open socket to the relayd */ - struct lttcomm_sock sock; - } relayd_sock; + struct lttcomm_relayd_sock sock; + /* Tracing session id associated to the relayd. */ + uint64_t session_id; + } LTTNG_PACKED relayd_sock; + struct { + uint64_t net_seq_idx; + } LTTNG_PACKED destroy_relayd; + struct { + uint64_t session_id; + } LTTNG_PACKED data_pending; + struct { + uint64_t subbuf_size; /* bytes */ + uint64_t num_subbuf; /* power of 2 */ + int32_t overwrite; /* 1: overwrite, 0: discard */ + uint32_t switch_timer_interval; /* usec */ + uint32_t read_timer_interval; /* usec */ + int32_t output; /* splice, mmap */ + int32_t type; /* metadata or per_cpu */ + uint64_t session_id; /* Tracing session id */ + char pathname[PATH_MAX]; /* Channel file path. */ + char name[LTTNG_SYMBOL_NAME_LEN]; /* Channel name. */ + uint32_t uid; /* User ID of the session */ + uint32_t gid; /* Group ID ot the session */ + uint64_t relayd_id; /* Relayd id if apply. */ + uint64_t key; /* Unique channel key. */ + unsigned char uuid[UUID_LEN]; /* uuid for ust tracer. */ + uint32_t chan_id; /* Channel ID on the tracer side. */ + uint64_t tracefile_size; /* bytes */ + uint32_t tracefile_count; /* number of tracefiles */ + uint64_t session_id_per_pid; /* Per-pid session ID. */ + /* Tells the consumer if the stream should be or not monitored. */ + uint32_t monitor; + } LTTNG_PACKED ask_channel; + struct { + uint64_t key; + } LTTNG_PACKED get_channel; + struct { + uint64_t key; + } LTTNG_PACKED destroy_channel; + struct { + uint64_t key; /* Metadata channel key. */ + uint64_t target_offset; /* Offset in the consumer */ + uint64_t len; /* Length of metadata to be received. */ + } LTTNG_PACKED push_metadata; + struct { + uint64_t key; /* Metadata channel key. */ + } LTTNG_PACKED close_metadata; + struct { + uint64_t key; /* Metadata channel key. */ + } LTTNG_PACKED setup_metadata; + struct { + uint64_t key; /* Channel key. */ + } LTTNG_PACKED flush_channel; + struct { + char pathname[PATH_MAX]; + /* Indicate if the snapshot goes on the relayd or locally. */ + uint32_t use_relayd; + uint32_t metadata; /* This a metadata snapshot. */ + uint64_t relayd_id; /* Relayd id if apply. */ + uint64_t key; + uint64_t max_stream_size; + } LTTNG_PACKED snapshot_channel; } u; -}; +} LTTNG_PACKED; + +/* + * Status message returned to the sessiond after a received command. + */ +struct lttcomm_consumer_status_msg { + enum lttng_error_code ret_code; +} LTTNG_PACKED; + +struct lttcomm_consumer_status_channel { + enum lttng_error_code ret_code; + uint64_t key; + unsigned int stream_count; +} LTTNG_PACKED; #ifdef HAVE_LIBLTTNG_UST_CTL @@ -384,7 +431,7 @@ struct lttcomm_ust_msg { struct lttng_ust_context context; struct lttng_ust_tracer_version version; } u; -}; +} LTTNG_PACKED; /* * Data structure for the response from UST to the session daemon. @@ -398,13 +445,13 @@ struct lttcomm_ust_reply { union { struct { uint64_t memory_map_size; - } channel; + } LTTNG_PACKED channel; struct { uint64_t memory_map_size; - } stream; + } LTTNG_PACKED stream; struct lttng_ust_tracer_version version; } u; -}; +} LTTNG_PACKED; #endif /* HAVE_LIBLTTNG_UST_CTL */ @@ -423,4 +470,15 @@ extern struct lttcomm_sock *lttcomm_alloc_copy_sock(struct lttcomm_sock *src); extern void lttcomm_copy_sock(struct lttcomm_sock *dst, struct lttcomm_sock *src); +/* Relayd socket object. */ +extern struct lttcomm_relayd_sock *lttcomm_alloc_relayd_sock( + struct lttng_uri *uri, uint32_t major, uint32_t minor); + +extern int lttcomm_setsockopt_rcv_timeout(int sock, unsigned int msec); +extern int lttcomm_setsockopt_snd_timeout(int sock, unsigned int msec); + +extern void lttcomm_init(void); +/* Get network timeout, in milliseconds */ +extern unsigned long lttcomm_get_network_timeout(void); + #endif /* _LTTNG_SESSIOND_COMM_H */