SoW-2019-0002: Dynamic Snapshot
[lttng-tools.git] / src / bin / lttng-sessiond / ust-ctl-internal.h
1 /*
2 * Copyright (C) 2011 Julien Desfossez <julien.desfossez@polymtl.ca>
3 * Copyright (C) 2011-2013 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
4 *
5 * SPDX-License-Identifier: GPL-2.0-only
6 *
7 */
8
9 #ifndef LTTNG_UST_CTL_INTERNAL_H
10 #define LTTNG_UST_CTL_INTERNAL_H
11
12 #include <sys/types.h>
13 #include <limits.h>
14
15 #include "lttng-ust-abi.h"
16
17 #ifndef LTTNG_UST_UUID_LEN
18 #define LTTNG_UST_UUID_LEN 16
19 #endif
20
21 /* Default unix socket path */
22 #define LTTNG_UST_SOCK_FILENAME \
23 "lttng-ust-sock-" \
24 __ust_stringify(LTTNG_UST_ABI_MAJOR_VERSION)
25
26 /*
27 * Shared memory files path are automatically related to shm root, e.g.
28 * /dev/shm under linux.
29 */
30 #define LTTNG_UST_WAIT_FILENAME \
31 "lttng-ust-wait-" \
32 __ust_stringify(LTTNG_UST_ABI_MAJOR_VERSION)
33
34 struct lttng_ust_shm_handle;
35 struct lttng_ust_lib_ring_buffer;
36
37 struct ustctl_consumer_channel_attr {
38 enum lttng_ust_chan_type type;
39 uint64_t subbuf_size; /* bytes */
40 uint64_t num_subbuf; /* power of 2 */
41 int overwrite; /* 1: overwrite, 0: discard */
42 unsigned int switch_timer_interval; /* usec */
43 unsigned int read_timer_interval; /* usec */
44 enum lttng_ust_output output; /* splice, mmap */
45 uint32_t chan_id; /* channel ID */
46 unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */
47 int64_t blocking_timeout; /* Blocking timeout (usec) */
48 } LTTNG_PACKED;
49
50 /*
51 * API used by sessiond.
52 */
53
54 struct lttng_ust_context_attr {
55 enum lttng_ust_context_type ctx;
56 union {
57 struct lttng_ust_perf_counter_ctx perf_counter;
58 struct {
59 char *provider_name;
60 char *ctx_name;
61 } app_ctx;
62 } u;
63 };
64
65 /*
66 * Error values: all the following functions return:
67 * >= 0: Success (LTTNG_UST_OK)
68 * < 0: error code.
69 */
70 int ustctl_register_done(int sock);
71 int ustctl_create_session(int sock);
72 int ustctl_create_event(int sock, struct lttng_ust_event *ev,
73 struct lttng_ust_object_data *channel_data,
74 struct lttng_ust_object_data **event_data);
75 int ustctl_add_context(int sock, struct lttng_ust_context_attr *ctx,
76 struct lttng_ust_object_data *obj_data,
77 struct lttng_ust_object_data **context_data);
78 int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode,
79 struct lttng_ust_object_data *obj_data);
80 int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion,
81 struct lttng_ust_object_data *obj_data);
82
83 int ustctl_enable(int sock, struct lttng_ust_object_data *object);
84 int ustctl_disable(int sock, struct lttng_ust_object_data *object);
85 int ustctl_start_session(int sock, int handle);
86 int ustctl_stop_session(int sock, int handle);
87
88 int ustctl_create_trigger_group(int sock,
89 int pipe_fd,
90 struct lttng_ust_object_data **trigger_group_handle);
91 int ustctl_create_trigger(int sock,
92 struct lttng_ust_trigger *trigger,
93 struct lttng_ust_object_data *trigger_group_handle,
94 struct lttng_ust_object_data **trigger_data);
95
96 /*
97 * ustctl_tracepoint_list returns a tracepoint list handle, or negative
98 * error value.
99 */
100 int ustctl_tracepoint_list(int sock);
101
102 /*
103 * ustctl_tracepoint_list_get is used to iterate on the tp list
104 * handle. End is iteration is reached when -LTTNG_UST_ERR_NOENT is
105 * returned.
106 */
107 int ustctl_tracepoint_list_get(int sock, int tp_list_handle,
108 struct lttng_ust_tracepoint_iter *iter);
109
110 /*
111 * ustctl_tracepoint_field_list returns a tracepoint field list handle,
112 * or negative error value.
113 */
114 int ustctl_tracepoint_field_list(int sock);
115
116 /*
117 * ustctl_tracepoint_field_list_get is used to iterate on the tp field
118 * list handle. End is iteration is reached when -LTTNG_UST_ERR_NOENT is
119 * returned.
120 */
121 int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle,
122 struct lttng_ust_field_iter *iter);
123
124 int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v);
125 int ustctl_wait_quiescent(int sock);
126
127 int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object);
128
129 int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate);
130
131 /* Release object created by members of this API. */
132 int ustctl_release_object(int sock, struct lttng_ust_object_data *data);
133 /* Release handle returned by create session. */
134 int ustctl_release_handle(int sock, int handle);
135
136 int ustctl_recv_channel_from_consumer(int sock,
137 struct lttng_ust_object_data **channel_data);
138 int ustctl_recv_stream_from_consumer(int sock,
139 struct lttng_ust_object_data **stream_data);
140 int ustctl_send_channel_to_ust(int sock, int session_handle,
141 struct lttng_ust_object_data *channel_data);
142 int ustctl_send_stream_to_ust(int sock,
143 struct lttng_ust_object_data *channel_data,
144 struct lttng_ust_object_data *stream_data);
145
146 /*
147 * ustctl_duplicate_ust_object_data allocated a new object in "dest" if
148 * it succeeds (returns 0). It must be released using
149 * ustctl_release_object() and then freed with free().
150 */
151 int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest,
152 struct lttng_ust_object_data *src);
153
154 /*
155 * API used by consumer.
156 */
157
158 struct ustctl_consumer_channel;
159 struct ustctl_consumer_stream;
160 struct ustctl_consumer_channel_attr;
161
162 int ustctl_get_nr_stream_per_channel(void);
163
164 struct ustctl_consumer_channel *
165 ustctl_create_channel(struct ustctl_consumer_channel_attr *attr,
166 const int *stream_fds, int nr_stream_fds);
167 /*
168 * Each stream created needs to be destroyed before calling
169 * ustctl_destroy_channel().
170 */
171 void ustctl_destroy_channel(struct ustctl_consumer_channel *chan);
172
173 int ustctl_send_channel_to_sessiond(int sock,
174 struct ustctl_consumer_channel *channel);
175 int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan);
176 int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan);
177 int ustctl_channel_get_wait_fd(struct ustctl_consumer_channel *consumer_chan);
178 int ustctl_channel_get_wakeup_fd(struct ustctl_consumer_channel *consumer_chan);
179
180 int ustctl_write_metadata_to_channel(
181 struct ustctl_consumer_channel *channel,
182 const char *metadata_str, /* NOT null-terminated */
183 size_t len); /* metadata length */
184 ssize_t ustctl_write_one_packet_to_channel(
185 struct ustctl_consumer_channel *channel,
186 const char *metadata_str, /* NOT null-terminated */
187 size_t len); /* metadata length */
188
189 /*
190 * Send a NULL stream to finish iteration over all streams of a given
191 * channel.
192 */
193 int ustctl_send_stream_to_sessiond(int sock,
194 struct ustctl_consumer_stream *stream);
195 int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream);
196 int ustctl_stream_close_wakeup_fd(struct ustctl_consumer_stream *stream);
197 int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream);
198 int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream);
199
200 /* Create/destroy stream buffers for read */
201 struct ustctl_consumer_stream *
202 ustctl_create_stream(struct ustctl_consumer_channel *channel,
203 int cpu);
204 void ustctl_destroy_stream(struct ustctl_consumer_stream *stream);
205
206 /* For mmap mode, readable without "get" operation */
207 int ustctl_get_mmap_len(struct ustctl_consumer_stream *stream,
208 unsigned long *len);
209 int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream,
210 unsigned long *len);
211
212 /*
213 * For mmap mode, operate on the current packet (between get/put or
214 * get_next/put_next).
215 */
216 void *ustctl_get_mmap_base(struct ustctl_consumer_stream *stream);
217 int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream,
218 unsigned long *off);
219 int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream,
220 unsigned long *len);
221 int ustctl_get_padded_subbuf_size(struct ustctl_consumer_stream *stream,
222 unsigned long *len);
223 int ustctl_get_next_subbuf(struct ustctl_consumer_stream *stream);
224 int ustctl_put_next_subbuf(struct ustctl_consumer_stream *stream);
225
226 /* snapshot */
227
228 int ustctl_snapshot(struct ustctl_consumer_stream *stream);
229 int ustctl_snapshot_sample_positions(struct ustctl_consumer_stream *stream);
230 int ustctl_snapshot_get_consumed(struct ustctl_consumer_stream *stream,
231 unsigned long *pos);
232 int ustctl_snapshot_get_produced(struct ustctl_consumer_stream *stream,
233 unsigned long *pos);
234 int ustctl_get_subbuf(struct ustctl_consumer_stream *stream,
235 unsigned long *pos);
236 int ustctl_put_subbuf(struct ustctl_consumer_stream *stream);
237
238 void ustctl_flush_buffer(struct ustctl_consumer_stream *stream,
239 int producer_active);
240
241 /* index */
242 int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream,
243 uint64_t *timestamp_begin);
244 int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream,
245 uint64_t *timestamp_end);
246 int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream,
247 uint64_t *events_discarded);
248 int ustctl_get_content_size(struct ustctl_consumer_stream *stream,
249 uint64_t *content_size);
250 int ustctl_get_packet_size(struct ustctl_consumer_stream *stream,
251 uint64_t *packet_size);
252 int ustctl_get_stream_id(struct ustctl_consumer_stream *stream,
253 uint64_t *stream_id);
254 int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream,
255 uint64_t *ts);
256 int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream,
257 uint64_t *seq);
258 int ustctl_get_instance_id(struct ustctl_consumer_stream *stream,
259 uint64_t *id);
260
261 /* returns whether UST has perf counters support. */
262 int ustctl_has_perf_counters(void);
263
264 /* Regenerate the statedump. */
265 int ustctl_regenerate_statedump(int sock, int handle);
266
267 /* event registry management */
268
269 enum ustctl_socket_type {
270 USTCTL_SOCKET_CMD = 0,
271 USTCTL_SOCKET_NOTIFY = 1,
272 };
273
274 enum ustctl_notify_cmd {
275 USTCTL_NOTIFY_CMD_EVENT = 0,
276 USTCTL_NOTIFY_CMD_CHANNEL = 1,
277 USTCTL_NOTIFY_CMD_ENUM = 2,
278 };
279
280 enum ustctl_channel_header {
281 USTCTL_CHANNEL_HEADER_UNKNOWN = 0,
282 USTCTL_CHANNEL_HEADER_COMPACT = 1,
283 USTCTL_CHANNEL_HEADER_LARGE = 2,
284 };
285
286 /* event type structures */
287
288 enum ustctl_abstract_types {
289 ustctl_atype_integer,
290 ustctl_atype_enum,
291 ustctl_atype_array,
292 ustctl_atype_sequence,
293 ustctl_atype_string,
294 ustctl_atype_float,
295 ustctl_atype_variant,
296 ustctl_atype_struct,
297 NR_USTCTL_ABSTRACT_TYPES,
298 };
299
300 enum ustctl_string_encodings {
301 ustctl_encode_none = 0,
302 ustctl_encode_UTF8 = 1,
303 ustctl_encode_ASCII = 2,
304 NR_USTCTL_STRING_ENCODINGS,
305 };
306
307 #define USTCTL_UST_INTEGER_TYPE_PADDING 24
308 struct ustctl_integer_type {
309 uint32_t size; /* in bits */
310 uint32_t signedness;
311 uint32_t reverse_byte_order;
312 uint32_t base; /* 2, 8, 10, 16, for pretty print */
313 int32_t encoding; /* enum ustctl_string_encodings */
314 uint16_t alignment; /* in bits */
315 char padding[USTCTL_UST_INTEGER_TYPE_PADDING];
316 } LTTNG_PACKED;
317
318 #define USTCTL_UST_FLOAT_TYPE_PADDING 24
319 struct ustctl_float_type {
320 uint32_t exp_dig; /* exponent digits, in bits */
321 uint32_t mant_dig; /* mantissa digits, in bits */
322 uint32_t reverse_byte_order;
323 uint16_t alignment; /* in bits */
324 char padding[USTCTL_UST_FLOAT_TYPE_PADDING];
325 } LTTNG_PACKED;
326
327 #define USTCTL_UST_ENUM_VALUE_PADDING 15
328 struct ustctl_enum_value {
329 uint64_t value;
330 uint8_t signedness;
331 char padding[USTCTL_UST_ENUM_VALUE_PADDING];
332 } LTTNG_PACKED;
333
334 enum ustctl_ust_enum_entry_options {
335 USTCTL_UST_ENUM_ENTRY_OPTION_IS_AUTO = 1U << 0,
336 };
337
338 #define USTCTL_UST_ENUM_ENTRY_PADDING 32
339 struct ustctl_enum_entry {
340 struct ustctl_enum_value start, end; /* start and end are inclusive */
341 char string[LTTNG_UST_SYM_NAME_LEN];
342 union {
343 struct {
344 uint32_t options;
345 } LTTNG_PACKED extra;
346 char padding[USTCTL_UST_ENUM_ENTRY_PADDING];
347 } u;
348 } LTTNG_PACKED;
349
350 #define USTCTL_UST_BASIC_TYPE_PADDING 296
351 union _ustctl_basic_type {
352 struct ustctl_integer_type integer;
353 struct {
354 char name[LTTNG_UST_SYM_NAME_LEN];
355 struct ustctl_integer_type container_type;
356 uint64_t id; /* enum ID in sessiond. */
357 } enumeration;
358 struct {
359 int32_t encoding; /* enum ustctl_string_encodings */
360 } string;
361 struct ustctl_float_type _float;
362 char padding[USTCTL_UST_BASIC_TYPE_PADDING];
363 } LTTNG_PACKED;
364
365 struct ustctl_basic_type {
366 enum ustctl_abstract_types atype;
367 union {
368 union _ustctl_basic_type basic;
369 } u;
370 } LTTNG_PACKED;
371
372 #define USTCTL_UST_TYPE_PADDING 128
373 struct ustctl_type {
374 enum ustctl_abstract_types atype;
375 union {
376 union _ustctl_basic_type basic;
377 struct {
378 struct ustctl_basic_type elem_type;
379 uint32_t length; /* num. elems. */
380 } array;
381 struct {
382 struct ustctl_basic_type length_type;
383 struct ustctl_basic_type elem_type;
384 } sequence;
385 struct {
386 uint32_t nr_choices;
387 char tag_name[LTTNG_UST_SYM_NAME_LEN];
388 /* Followed by nr_choices struct ustctl_field. */
389 } variant;
390 struct {
391 uint32_t nr_fields;
392 /* Followed by nr_fields struct ustctl_field. */
393 } _struct;
394 char padding[USTCTL_UST_TYPE_PADDING];
395 } u;
396 } LTTNG_PACKED;
397
398 #define USTCTL_UST_FIELD_PADDING 28
399 struct ustctl_field {
400 char name[LTTNG_UST_SYM_NAME_LEN];
401 struct ustctl_type type;
402 char padding[USTCTL_UST_FIELD_PADDING];
403 } LTTNG_PACKED;
404
405 /*
406 * Returns 0 on success, negative error value on error.
407 * If an error other than -LTTNG_UST_ERR_UNSUP_MAJOR is returned,
408 * the output fields are not populated.
409 */
410 int ustctl_recv_reg_msg(int sock,
411 enum ustctl_socket_type *type,
412 uint32_t *major,
413 uint32_t *minor,
414 uint32_t *pid,
415 uint32_t *ppid,
416 uint32_t *uid,
417 uint32_t *gid,
418 uint32_t *bits_per_long,
419 uint32_t *uint8_t_alignment,
420 uint32_t *uint16_t_alignment,
421 uint32_t *uint32_t_alignment,
422 uint32_t *uint64_t_alignment,
423 uint32_t *long_alignment,
424 int *byte_order,
425 char *name); /* size LTTNG_UST_ABI_PROCNAME_LEN */
426
427 /*
428 * Returns 0 on success, negative UST or system error value on error.
429 * Receive the notification command. The "notify_cmd" can then be used
430 * by the caller to find out which ustctl_recv_* function should be
431 * called to receive the notification, and which ustctl_reply_* is
432 * appropriate.
433 */
434 int ustctl_recv_notify(int sock, enum ustctl_notify_cmd *notify_cmd);
435
436 /*
437 * Returns 0 on success, negative UST or system error value on error.
438 */
439 int ustctl_recv_register_event(int sock,
440 int *session_objd, /* session descriptor (output) */
441 int *channel_objd, /* channel descriptor (output) */
442 char *event_name, /*
443 * event name (output,
444 * size LTTNG_UST_SYM_NAME_LEN)
445 */
446 int *loglevel,
447 char **signature, /*
448 * event signature
449 * (output, dynamically
450 * allocated, must be free(3)'d
451 * by the caller if function
452 * returns success.)
453 */
454 size_t *nr_fields,
455 struct ustctl_field **fields,
456 char **model_emf_uri);
457
458 /*
459 * Returns 0 on success, negative error value on error.
460 */
461 int ustctl_reply_register_event(int sock,
462 uint32_t id, /* event id (input) */
463 int ret_code); /* return code. 0 ok, negative error */
464
465 /*
466 * Returns 0 on success, negative UST or system error value on error.
467 */
468 int ustctl_recv_register_enum(int sock,
469 int *session_objd,
470 char *enum_name,
471 struct ustctl_enum_entry **entries,
472 size_t *nr_entries);
473
474 /*
475 * Returns 0 on success, negative error value on error.
476 */
477 int ustctl_reply_register_enum(int sock,
478 uint64_t id, /* enum id (input) */
479 int ret_code);
480
481 /*
482 * Returns 0 on success, negative UST or system error value on error.
483 */
484 int ustctl_recv_register_channel(int sock,
485 int *session_objd, /* session descriptor (output) */
486 int *channel_objd, /* channel descriptor (output) */
487 size_t *nr_fields, /* context fields */
488 struct ustctl_field **fields);
489
490 /*
491 * Returns 0 on success, negative error value on error.
492 */
493 int ustctl_reply_register_channel(int sock,
494 uint32_t chan_id,
495 enum ustctl_channel_header header_type,
496 int ret_code); /* return code. 0 ok, negative error */
497
498 #endif /* LTTNG_UST_CTL_INTERNAL_H */
This page took 0.0632239999999999 seconds and 5 git commands to generate.