X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-ctl-internal.h;h=77292b002793070139400278ffe145db4a799eaa;hb=0efb2ad7fc448283184e43d6fb0915febae45384;hp=96099f8aa08926aee758293f6ccc3e30652780f9;hpb=ab5be9fa2eb5ba9600a82cd18fd3cfcbac69169a;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/ust-ctl-internal.h b/src/bin/lttng-sessiond/ust-ctl-internal.h index 96099f8aa..77292b002 100644 --- a/src/bin/lttng-sessiond/ust-ctl-internal.h +++ b/src/bin/lttng-sessiond/ust-ctl-internal.h @@ -35,13 +35,13 @@ struct lttng_ust_shm_handle; struct lttng_ust_lib_ring_buffer; struct ustctl_consumer_channel_attr { - enum lttng_ust_chan_type type; + enum lttng_ust_abi_chan_type type; uint64_t subbuf_size; /* bytes */ uint64_t num_subbuf; /* power of 2 */ int overwrite; /* 1: overwrite, 0: discard */ unsigned int switch_timer_interval; /* usec */ unsigned int read_timer_interval; /* usec */ - enum lttng_ust_output output; /* splice, mmap */ + enum lttng_ust_abi_output output; /* splice, mmap */ uint32_t chan_id; /* channel ID */ unsigned char uuid[LTTNG_UST_UUID_LEN]; /* Trace session unique ID */ int64_t blocking_timeout; /* Blocking timeout (usec) */ @@ -52,9 +52,9 @@ struct ustctl_consumer_channel_attr { */ struct lttng_ust_context_attr { - enum lttng_ust_context_type ctx; + enum lttng_ust_abi_context_type ctx; union { - struct lttng_ust_perf_counter_ctx perf_counter; + struct lttng_ust_abi_perf_counter_ctx perf_counter; struct { char *provider_name; char *ctx_name; @@ -69,22 +69,46 @@ struct lttng_ust_context_attr { */ int ustctl_register_done(int sock); int ustctl_create_session(int sock); -int ustctl_create_event(int sock, struct lttng_ust_event *ev, - struct lttng_ust_object_data *channel_data, - struct lttng_ust_object_data **event_data); +int ustctl_create_event(int sock, struct lttng_ust_abi_event *ev, + struct lttng_ust_abi_object_data *channel_data, + struct lttng_ust_abi_object_data **event_data); int ustctl_add_context(int sock, struct lttng_ust_context_attr *ctx, - struct lttng_ust_object_data *obj_data, - struct lttng_ust_object_data **context_data); -int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode, - struct lttng_ust_object_data *obj_data); -int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion, - struct lttng_ust_object_data *obj_data); - -int ustctl_enable(int sock, struct lttng_ust_object_data *object); -int ustctl_disable(int sock, struct lttng_ust_object_data *object); + struct lttng_ust_abi_object_data *obj_data, + struct lttng_ust_abi_object_data **context_data); +int ustctl_set_filter(int sock, struct lttng_ust_abi_filter_bytecode *bytecode, + struct lttng_ust_abi_object_data *obj_data); +int ustctl_set_capture(int sock, struct lttng_ust_abi_capture_bytecode *bytecode, + struct lttng_ust_abi_object_data *obj_data); +int ustctl_set_exclusion(int sock, struct lttng_ust_abi_event_exclusion *exclusion, + struct lttng_ust_abi_object_data *obj_data); + +int ustctl_enable(int sock, struct lttng_ust_abi_object_data *object); +int ustctl_disable(int sock, struct lttng_ust_abi_object_data *object); int ustctl_start_session(int sock, int handle); int ustctl_stop_session(int sock, int handle); +/* + * ustctl_create_event notifier_group creates a event notifier group. It + * establishes the connection with the application by providing a file + * descriptor of the pipe to be used by the application when a event notifier + * of that group is fired. It returns a handle to be used when creating event + * notifier in that group. + */ +int ustctl_create_event_notifier_group(int sock, int pipe_fd, + struct lttng_ust_abi_object_data **event_notifier_group); + +/* + * ustctl_create_event notifier creates a event notifier in a event notifier + * group giving a event notifier description and a event notifier group handle. + * It returns a event notifier handle to be used when enabling the event + * notifier, attaching filter, attaching exclusion, and disabling the event + * notifier. + */ +int ustctl_create_event_notifier(int sock, + struct lttng_ust_abi_event_notifier *event_notifier, + struct lttng_ust_abi_object_data *event_notifier_group, + struct lttng_ust_abi_object_data **event_notifier_data); + /* * ustctl_tracepoint_list returns a tracepoint list handle, or negative * error value. @@ -97,7 +121,7 @@ int ustctl_tracepoint_list(int sock); * returned. */ int ustctl_tracepoint_list_get(int sock, int tp_list_handle, - struct lttng_ust_tracepoint_iter *iter); + struct lttng_ust_abi_tracepoint_iter *iter); /* * ustctl_tracepoint_field_list returns a tracepoint field list handle, @@ -111,37 +135,37 @@ int ustctl_tracepoint_field_list(int sock); * returned. */ int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle, - struct lttng_ust_field_iter *iter); + struct lttng_ust_abi_field_iter *iter); -int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v); +int ustctl_tracer_version(int sock, struct lttng_ust_abi_tracer_version *v); int ustctl_wait_quiescent(int sock); -int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object); +int ustctl_sock_flush_buffer(int sock, struct lttng_ust_abi_object_data *object); -int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate); +int ustctl_calibrate(int sock, struct lttng_ust_abi_calibrate *calibrate); /* Release object created by members of this API. */ -int ustctl_release_object(int sock, struct lttng_ust_object_data *data); +int ustctl_release_object(int sock, struct lttng_ust_abi_object_data *data); /* Release handle returned by create session. */ int ustctl_release_handle(int sock, int handle); int ustctl_recv_channel_from_consumer(int sock, - struct lttng_ust_object_data **channel_data); + struct lttng_ust_abi_object_data **channel_data); int ustctl_recv_stream_from_consumer(int sock, - struct lttng_ust_object_data **stream_data); + struct lttng_ust_abi_object_data **stream_data); int ustctl_send_channel_to_ust(int sock, int session_handle, - struct lttng_ust_object_data *channel_data); + struct lttng_ust_abi_object_data *channel_data); int ustctl_send_stream_to_ust(int sock, - struct lttng_ust_object_data *channel_data, - struct lttng_ust_object_data *stream_data); + struct lttng_ust_abi_object_data *channel_data, + struct lttng_ust_abi_object_data *stream_data); /* * ustctl_duplicate_ust_object_data allocated a new object in "dest" if * it succeeds (returns 0). It must be released using * ustctl_release_object() and then freed with free(). */ -int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, - struct lttng_ust_object_data *src); +int ustctl_duplicate_ust_object_data(struct lttng_ust_abi_object_data **dest, + struct lttng_ust_abi_object_data *src); /* * API used by consumer. @@ -229,8 +253,15 @@ int ustctl_put_subbuf(struct ustctl_consumer_stream *stream); void ustctl_flush_buffer(struct ustctl_consumer_stream *stream, int producer_active); +void ustctl_clear_buffer(struct ustctl_consumer_stream *stream); /* index */ + +/* + * Getters which need to be used on the current packet (between get/put + * or get_next/put_next. + */ + int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream, uint64_t *timestamp_begin); int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream, @@ -241,15 +272,26 @@ int ustctl_get_content_size(struct ustctl_consumer_stream *stream, uint64_t *content_size); int ustctl_get_packet_size(struct ustctl_consumer_stream *stream, uint64_t *packet_size); -int ustctl_get_stream_id(struct ustctl_consumer_stream *stream, - uint64_t *stream_id); -int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream, - uint64_t *ts); int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream, uint64_t *seq); + +/* + * Getter returning state invariant for the stream, which can be used + * without "get" operation. + */ + +int ustctl_get_stream_id(struct ustctl_consumer_stream *stream, + uint64_t *stream_id); int ustctl_get_instance_id(struct ustctl_consumer_stream *stream, uint64_t *id); +/* + * Getter returning the current timestamp as perceived from the + * tracer. + */ +int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream, + uint64_t *ts); + /* returns whether UST has perf counters support. */ int ustctl_has_perf_counters(void); @@ -279,13 +321,18 @@ enum ustctl_channel_header { enum ustctl_abstract_types { ustctl_atype_integer, - ustctl_atype_enum, - ustctl_atype_array, - ustctl_atype_sequence, + ustctl_atype_enum, /* legacy */ + ustctl_atype_array, /* legacy */ + ustctl_atype_sequence, /* legacy */ ustctl_atype_string, ustctl_atype_float, - ustctl_atype_variant, - ustctl_atype_struct, + ustctl_atype_variant, /* legacy */ + ustctl_atype_struct, /* legacy */ + ustctl_atype_enum_nestable, + ustctl_atype_array_nestable, + ustctl_atype_sequence_nestable, + ustctl_atype_struct_nestable, + ustctl_atype_variant_nestable, NR_USTCTL_ABSTRACT_TYPES, }; @@ -330,7 +377,7 @@ enum ustctl_ust_enum_entry_options { #define USTCTL_UST_ENUM_ENTRY_PADDING 32 struct ustctl_enum_entry { struct ustctl_enum_value start, end; /* start and end are inclusive */ - char string[LTTNG_UST_SYM_NAME_LEN]; + char string[LTTNG_UST_ABI_SYM_NAME_LEN]; union { struct { uint32_t options; @@ -339,11 +386,12 @@ struct ustctl_enum_entry { } u; } LTTNG_PACKED; +/* legacy */ #define USTCTL_UST_BASIC_TYPE_PADDING 296 union _ustctl_basic_type { struct ustctl_integer_type integer; struct { - char name[LTTNG_UST_SYM_NAME_LEN]; + char name[LTTNG_UST_ABI_SYM_NAME_LEN]; struct ustctl_integer_type container_type; uint64_t id; /* enum ID in sessiond. */ } enumeration; @@ -354,6 +402,7 @@ union _ustctl_basic_type { char padding[USTCTL_UST_BASIC_TYPE_PADDING]; } LTTNG_PACKED; +/* legacy */ struct ustctl_basic_type { enum ustctl_abstract_types atype; union { @@ -361,35 +410,74 @@ struct ustctl_basic_type { } u; } LTTNG_PACKED; -#define USTCTL_UST_TYPE_PADDING 128 +/* + * Padding is derived from largest member: u.legacy.sequence which + * contains two basic types, each with USTCTL_UST_BASIC_TYPE_PADDING. + */ +#define USTCTL_UST_TYPE_PADDING (2 * USTCTL_UST_BASIC_TYPE_PADDING) struct ustctl_type { enum ustctl_abstract_types atype; union { - union _ustctl_basic_type basic; + struct ustctl_integer_type integer; + struct ustctl_float_type _float; struct { - struct ustctl_basic_type elem_type; - uint32_t length; /* num. elems. */ - } array; + int32_t encoding; /* enum ustctl_string_encodings */ + } string; struct { - struct ustctl_basic_type length_type; - struct ustctl_basic_type elem_type; - } sequence; + char name[LTTNG_UST_ABI_SYM_NAME_LEN]; + uint64_t id; /* enum ID in sessiond. */ + /* container_type follows after this struct ustctl_field. */ + } enum_nestable; struct { - uint32_t nr_choices; - char tag_name[LTTNG_UST_SYM_NAME_LEN]; - /* Followed by nr_choices struct ustctl_field. */ - } variant; + uint32_t length; /* num. elems. */ + uint32_t alignment; + /* elem_type follows after this struct ustctl_field. */ + } array_nestable; + struct { + char length_name[LTTNG_UST_ABI_SYM_NAME_LEN]; + uint32_t alignment; /* Alignment before elements. */ + /* elem_type follows after the length_type. */ + } sequence_nestable; struct { uint32_t nr_fields; + uint32_t alignment; /* Followed by nr_fields struct ustctl_field. */ - } _struct; + } struct_nestable; + struct { + uint32_t nr_choices; + char tag_name[LTTNG_UST_ABI_SYM_NAME_LEN]; + uint32_t alignment; + /* Followed by nr_choices struct ustctl_field. */ + } variant_nestable; + + /* Legacy ABI */ + union { + union _ustctl_basic_type basic; + struct { + struct ustctl_basic_type elem_type; + uint32_t length; /* num. elems. */ + } array; + struct { + struct ustctl_basic_type length_type; + struct ustctl_basic_type elem_type; + } sequence; + struct { + uint32_t nr_fields; + /* Followed by nr_fields struct ustctl_field. */ + } _struct; + struct { + uint32_t nr_choices; + char tag_name[LTTNG_UST_ABI_SYM_NAME_LEN]; + /* Followed by nr_choices struct ustctl_field. */ + } variant; + } legacy; char padding[USTCTL_UST_TYPE_PADDING]; } u; } LTTNG_PACKED; #define USTCTL_UST_FIELD_PADDING 28 struct ustctl_field { - char name[LTTNG_UST_SYM_NAME_LEN]; + char name[LTTNG_UST_ABI_SYM_NAME_LEN]; struct ustctl_type type; char padding[USTCTL_UST_FIELD_PADDING]; } LTTNG_PACKED; @@ -433,7 +521,7 @@ int ustctl_recv_register_event(int sock, int *channel_objd, /* channel descriptor (output) */ char *event_name, /* * event name (output, - * size LTTNG_UST_SYM_NAME_LEN) + * size LTTNG_UST_ABI_SYM_NAME_LEN) */ int *loglevel, char **signature, /* @@ -487,4 +575,82 @@ int ustctl_reply_register_channel(int sock, enum ustctl_channel_header header_type, int ret_code); /* return code. 0 ok, negative error */ +/* + * Counter API. + */ + +enum ustctl_counter_bitness { + USTCTL_COUNTER_BITNESS_32 = 0, + USTCTL_COUNTER_BITNESS_64 = 1, +}; + +enum ustctl_counter_arithmetic { + USTCTL_COUNTER_ARITHMETIC_MODULAR = 0, + USTCTL_COUNTER_ARITHMETIC_SATURATION = 1, +}; + +/* Used as alloc flags. */ +enum ustctl_counter_alloc { + USTCTL_COUNTER_ALLOC_PER_CPU = (1 << 0), + USTCTL_COUNTER_ALLOC_GLOBAL = (1 << 1), +}; + +struct ustctl_daemon_counter; + +int ustctl_get_nr_cpu_per_counter(void); + +struct ustctl_counter_dimension { + uint64_t size; + uint64_t underflow_index; + uint64_t overflow_index; + uint8_t has_underflow; + uint8_t has_overflow; +}; + +struct ustctl_daemon_counter * + ustctl_create_counter(size_t nr_dimensions, + const struct ustctl_counter_dimension *dimensions, + int64_t global_sum_step, + int global_counter_fd, + int nr_counter_cpu_fds, + const int *counter_cpu_fds, + enum ustctl_counter_bitness bitness, + enum ustctl_counter_arithmetic arithmetic, + uint32_t alloc_flags, + bool coalesce_hits); + +int ustctl_create_counter_data(struct ustctl_daemon_counter *counter, + struct lttng_ust_abi_object_data **counter_data); + +int ustctl_create_counter_global_data(struct ustctl_daemon_counter *counter, + struct lttng_ust_abi_object_data **counter_global_data); +int ustctl_create_counter_cpu_data(struct ustctl_daemon_counter *counter, int cpu, + struct lttng_ust_abi_object_data **counter_cpu_data); + +/* + * Each counter data and counter cpu data created need to be destroyed + * before calling ustctl_destroy_counter(). + */ +void ustctl_destroy_counter(struct ustctl_daemon_counter *counter); + +int ustctl_send_counter_data_to_ust(int sock, int parent_handle, + struct lttng_ust_abi_object_data *counter_data); +int ustctl_send_counter_global_data_to_ust(int sock, + struct lttng_ust_abi_object_data *counter_data, + struct lttng_ust_abi_object_data *counter_global_data); +int ustctl_send_counter_cpu_data_to_ust(int sock, + struct lttng_ust_abi_object_data *counter_data, + struct lttng_ust_abi_object_data *counter_cpu_data); + +int ustctl_counter_read(struct ustctl_daemon_counter *counter, + const size_t *dimension_indexes, + int cpu, int64_t *value, + bool *overflow, bool *underflow); +int ustctl_counter_aggregate(struct ustctl_daemon_counter *counter, + const size_t *dimension_indexes, + int64_t *value, + bool *overflow, bool *underflow); +int ustctl_counter_clear(struct ustctl_daemon_counter *counter, + const size_t *dimension_indexes); + #endif /* LTTNG_UST_CTL_INTERNAL_H */