X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=liblttng-ust-ctl%2Fustctl.c;h=e1c9ac7dbd3e269c884c90461e0e863577d32b75;hb=c589eca21586907ffd057fa614e7e2715086b5c7;hp=14299b23fd344613dd707d0aedd709b51cce909a;hpb=bb7ad29d1e8a78e4f0f5f9c7f121fd5545c90acb;p=lttng-ust.git diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c index 14299b23..e1c9ac7d 100644 --- a/liblttng-ust-ctl/ustctl.c +++ b/liblttng-ust-ctl/ustctl.c @@ -30,6 +30,7 @@ #include "../liblttng-ust/clock.h" #include "../liblttng-ust/getenv.h" #include "../liblttng-ust/lttng-tracer-core.h" +#include "../liblttng-ust/lttng-counter-client.h" #include "../libcounter/shm.h" #include "../libcounter/smp.h" @@ -45,7 +46,7 @@ * Channel representation within consumer. */ struct ustctl_consumer_channel { - struct lttng_channel *chan; /* lttng channel buffers */ + struct lttng_ust_channel_buffer *chan; /* lttng channel buffers */ /* initial attributes */ struct ustctl_consumer_channel_attr attr; @@ -57,7 +58,6 @@ struct ustctl_consumer_channel { * Stream representation within consumer. */ struct ustctl_consumer_stream { - struct lttng_ust_shm_handle *handle; /* shared-memory handle */ struct lttng_ust_lib_ring_buffer *buf; struct ustctl_consumer_channel *chan; int shm_fd, wait_fd, wakeup_fd; @@ -72,6 +72,7 @@ struct ustctl_counter_attr { uint32_t nr_dimensions; int64_t global_sum_step; struct ustctl_counter_dimension dimensions[USTCTL_COUNTER_ATTR_DIMENSION_MAX]; + bool coalesce_hits; }; /* @@ -83,25 +84,6 @@ struct ustctl_daemon_counter { struct ustctl_counter_attr *attr; /* initial attributes */ }; -extern void lttng_ring_buffer_client_overwrite_init(void); -extern void lttng_ring_buffer_client_overwrite_rt_init(void); -extern void lttng_ring_buffer_client_discard_init(void); -extern void lttng_ring_buffer_client_discard_rt_init(void); -extern void lttng_ring_buffer_metadata_client_init(void); -extern void lttng_ring_buffer_client_overwrite_exit(void); -extern void lttng_ring_buffer_client_overwrite_rt_exit(void); -extern void lttng_ring_buffer_client_discard_exit(void); -extern void lttng_ring_buffer_client_discard_rt_exit(void); -extern void lttng_ring_buffer_metadata_client_exit(void); -LTTNG_HIDDEN -extern void lttng_counter_client_percpu_32_modular_init(void); -LTTNG_HIDDEN -extern void lttng_counter_client_percpu_32_modular_exit(void); -LTTNG_HIDDEN -extern void lttng_counter_client_percpu_64_modular_init(void); -LTTNG_HIDDEN -extern void lttng_counter_client_percpu_64_modular_exit(void); - int ustctl_release_handle(int sock, int handle) { struct ustcomm_ust_msg lum; @@ -111,7 +93,7 @@ int ustctl_release_handle(int sock, int handle) return 0; memset(&lum, 0, sizeof(lum)); lum.handle = handle; - lum.cmd = LTTNG_UST_RELEASE; + lum.cmd = LTTNG_UST_ABI_RELEASE; return ustcomm_send_app_cmd(sock, &lum, &lur); } @@ -119,7 +101,7 @@ int ustctl_release_handle(int sock, int handle) * If sock is negative, it means we don't have to notify the other side * (e.g. application has already vanished). */ -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) { int ret; @@ -127,7 +109,7 @@ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) return -EINVAL; switch (data->type) { - case LTTNG_UST_OBJECT_TYPE_CHANNEL: + case LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL: if (data->u.channel.wakeup_fd >= 0) { ret = close(data->u.channel.wakeup_fd); if (ret < 0) { @@ -139,7 +121,7 @@ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) free(data->u.channel.data); data->u.channel.data = NULL; break; - case LTTNG_UST_OBJECT_TYPE_STREAM: + case LTTNG_UST_ABI_OBJECT_TYPE_STREAM: if (data->u.stream.shm_fd >= 0) { ret = close(data->u.stream.shm_fd); if (ret < 0) { @@ -157,16 +139,16 @@ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) data->u.stream.wakeup_fd = -1; } break; - case LTTNG_UST_OBJECT_TYPE_EVENT: - case LTTNG_UST_OBJECT_TYPE_CONTEXT: - case LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER_GROUP: - case LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER: + case LTTNG_UST_ABI_OBJECT_TYPE_EVENT: + case LTTNG_UST_ABI_OBJECT_TYPE_CONTEXT: + case LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER_GROUP: + case LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER: break; - case LTTNG_UST_OBJECT_TYPE_COUNTER: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER: free(data->u.counter.data); data->u.counter.data = NULL; break; - case LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL: if (data->u.counter_global.shm_fd >= 0) { ret = close(data->u.counter_global.shm_fd); if (ret < 0) { @@ -176,7 +158,7 @@ int ustctl_release_object(int sock, struct lttng_ust_object_data *data) data->u.counter_global.shm_fd = -1; } break; - case LTTNG_UST_OBJECT_TYPE_COUNTER_CPU: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU: if (data->u.counter_cpu.shm_fd >= 0) { ret = close(data->u.counter_cpu.shm_fd); if (ret < 0) { @@ -203,8 +185,8 @@ int ustctl_register_done(int sock) DBG("Sending register done command to %d", sock); memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_REGISTER_DONE; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_REGISTER_DONE; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -222,8 +204,8 @@ int ustctl_create_session(int sock) /* Create session */ memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_SESSION; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_SESSION; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -232,13 +214,13 @@ int ustctl_create_session(int sock) return session_handle; } -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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; - struct lttng_ust_object_data *event_data; + struct lttng_ust_abi_object_data *event_data; int ret; if (!channel_data || !_event_data) @@ -247,12 +229,12 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev, event_data = zmalloc(sizeof(*event_data)); if (!event_data) return -ENOMEM; - event_data->type = LTTNG_UST_OBJECT_TYPE_EVENT; + event_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT; memset(&lum, 0, sizeof(lum)); lum.handle = channel_data->handle; - lum.cmd = LTTNG_UST_EVENT; + lum.cmd = LTTNG_UST_ABI_EVENT; strncpy(lum.u.event.name, ev->name, - LTTNG_UST_SYM_NAME_LEN); + LTTNG_UST_ABI_SYM_NAME_LEN); lum.u.event.instrumentation = ev->instrumentation; lum.u.event.loglevel_type = ev->loglevel_type; lum.u.event.loglevel = ev->loglevel; @@ -268,12 +250,12 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev, } 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) + struct lttng_ust_abi_object_data *obj_data, + struct lttng_ust_abi_object_data **_context_data) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; - struct lttng_ust_object_data *context_data = NULL; + struct lttng_ust_abi_object_data *context_data = NULL; char *buf = NULL; size_t len; int ret; @@ -288,17 +270,17 @@ int ustctl_add_context(int sock, struct lttng_ust_context_attr *ctx, ret = -ENOMEM; goto end; } - context_data->type = LTTNG_UST_OBJECT_TYPE_CONTEXT; + context_data->type = LTTNG_UST_ABI_OBJECT_TYPE_CONTEXT; memset(&lum, 0, sizeof(lum)); lum.handle = obj_data->handle; - lum.cmd = LTTNG_UST_CONTEXT; + lum.cmd = LTTNG_UST_ABI_CONTEXT; lum.u.context.ctx = ctx->ctx; switch (ctx->ctx) { - case LTTNG_UST_CONTEXT_PERF_THREAD_COUNTER: + case LTTNG_UST_ABI_CONTEXT_PERF_THREAD_COUNTER: lum.u.context.u.perf_counter = ctx->u.perf_counter; break; - case LTTNG_UST_CONTEXT_APP_CONTEXT: + case LTTNG_UST_ABI_CONTEXT_APP_CONTEXT: { size_t provider_name_len = strlen( ctx->u.app_ctx.provider_name) + 1; @@ -350,8 +332,8 @@ end: return ret; } -int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode, - struct lttng_ust_object_data *obj_data) +int ustctl_set_filter(int sock, struct lttng_ust_abi_filter_bytecode *bytecode, + struct lttng_ust_abi_object_data *obj_data) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -362,7 +344,7 @@ int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode, memset(&lum, 0, sizeof(lum)); lum.handle = obj_data->handle; - lum.cmd = LTTNG_UST_FILTER; + lum.cmd = LTTNG_UST_ABI_FILTER; lum.u.filter.data_size = bytecode->len; lum.u.filter.reloc_offset = bytecode->reloc_offset; lum.u.filter.seqnum = bytecode->seqnum; @@ -381,8 +363,8 @@ int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode, return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd); } -int ustctl_set_capture(int sock, struct lttng_ust_capture_bytecode *bytecode, - struct lttng_ust_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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -393,7 +375,7 @@ int ustctl_set_capture(int sock, struct lttng_ust_capture_bytecode *bytecode, memset(&lum, 0, sizeof(lum)); lum.handle = obj_data->handle; - lum.cmd = LTTNG_UST_CAPTURE; + lum.cmd = LTTNG_UST_ABI_CAPTURE; lum.u.capture.data_size = bytecode->len; lum.u.capture.reloc_offset = bytecode->reloc_offset; lum.u.capture.seqnum = bytecode->seqnum; @@ -412,8 +394,8 @@ int ustctl_set_capture(int sock, struct lttng_ust_capture_bytecode *bytecode, return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd); } -int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion, - struct lttng_ust_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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -425,7 +407,7 @@ int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion, memset(&lum, 0, sizeof(lum)); lum.handle = obj_data->handle; - lum.cmd = LTTNG_UST_EXCLUSION; + lum.cmd = LTTNG_UST_ABI_EXCLUSION; lum.u.exclusion.count = exclusion->count; ret = ustcomm_send_app_msg(sock, &lum); @@ -436,18 +418,18 @@ int ustctl_set_exclusion(int sock, struct lttng_ust_event_exclusion *exclusion, /* send var len exclusion names */ ret = ustcomm_send_unix_sock(sock, exclusion->names, - exclusion->count * LTTNG_UST_SYM_NAME_LEN); + exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN); if (ret < 0) { return ret; } - if (ret != exclusion->count * LTTNG_UST_SYM_NAME_LEN) { + if (ret != exclusion->count * LTTNG_UST_ABI_SYM_NAME_LEN) { return -EINVAL; } return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd); } /* Enable event, channel and session ioctl */ -int ustctl_enable(int sock, struct lttng_ust_object_data *object) +int ustctl_enable(int sock, struct lttng_ust_abi_object_data *object) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -458,7 +440,7 @@ int ustctl_enable(int sock, struct lttng_ust_object_data *object) memset(&lum, 0, sizeof(lum)); lum.handle = object->handle; - lum.cmd = LTTNG_UST_ENABLE; + lum.cmd = LTTNG_UST_ABI_ENABLE; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -467,7 +449,7 @@ int ustctl_enable(int sock, struct lttng_ust_object_data *object) } /* Disable event, channel and session ioctl */ -int ustctl_disable(int sock, struct lttng_ust_object_data *object) +int ustctl_disable(int sock, struct lttng_ust_abi_object_data *object) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -478,7 +460,7 @@ int ustctl_disable(int sock, struct lttng_ust_object_data *object) memset(&lum, 0, sizeof(lum)); lum.handle = object->handle; - lum.cmd = LTTNG_UST_DISABLE; + lum.cmd = LTTNG_UST_ABI_DISABLE; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -488,7 +470,7 @@ int ustctl_disable(int sock, struct lttng_ust_object_data *object) int ustctl_start_session(int sock, int handle) { - struct lttng_ust_object_data obj; + struct lttng_ust_abi_object_data obj; obj.handle = handle; return ustctl_enable(sock, &obj); @@ -496,16 +478,16 @@ int ustctl_start_session(int sock, int handle) int ustctl_stop_session(int sock, int handle) { - struct lttng_ust_object_data obj; + struct lttng_ust_abi_object_data obj; obj.handle = handle; return ustctl_disable(sock, &obj); } int ustctl_create_event_notifier_group(int sock, int pipe_fd, - struct lttng_ust_object_data **_event_notifier_group_data) + struct lttng_ust_abi_object_data **_event_notifier_group_data) { - struct lttng_ust_object_data *event_notifier_group_data; + struct lttng_ust_abi_object_data *event_notifier_group_data; struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; ssize_t len; @@ -518,11 +500,11 @@ int ustctl_create_event_notifier_group(int sock, int pipe_fd, if (!event_notifier_group_data) return -ENOMEM; - event_notifier_group_data->type = LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER_GROUP; + event_notifier_group_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER_GROUP; memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_EVENT_NOTIFIER_GROUP_CREATE; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_EVENT_NOTIFIER_GROUP_CREATE; ret = ustcomm_send_app_msg(sock, &lum); if (ret) @@ -553,13 +535,13 @@ end: return ret; } -int ustctl_create_event_notifier(int sock, struct lttng_ust_event_notifier *event_notifier, - struct lttng_ust_object_data *event_notifier_group, - struct lttng_ust_object_data **_event_notifier_data) +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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; - struct lttng_ust_object_data *event_notifier_data; + struct lttng_ust_abi_object_data *event_notifier_data; ssize_t len; int ret; @@ -570,11 +552,11 @@ int ustctl_create_event_notifier(int sock, struct lttng_ust_event_notifier *even if (!event_notifier_data) return -ENOMEM; - event_notifier_data->type = LTTNG_UST_OBJECT_TYPE_EVENT_NOTIFIER; + event_notifier_data->type = LTTNG_UST_ABI_OBJECT_TYPE_EVENT_NOTIFIER; memset(&lum, 0, sizeof(lum)); lum.handle = event_notifier_group->handle; - lum.cmd = LTTNG_UST_EVENT_NOTIFIER_CREATE; + lum.cmd = LTTNG_UST_ABI_EVENT_NOTIFIER_CREATE; lum.u.event_notifier.len = sizeof(*event_notifier); ret = ustcomm_send_app_msg(sock, &lum); @@ -582,9 +564,10 @@ int ustctl_create_event_notifier(int sock, struct lttng_ust_event_notifier *even free(event_notifier_data); return ret; } - /* Send struct lttng_ust_event_notifier */ + /* Send struct lttng_ust_abi_event_notifier */ len = ustcomm_send_unix_sock(sock, event_notifier, sizeof(*event_notifier)); if (len != sizeof(*event_notifier)) { + free(event_notifier_data); if (len < 0) return len; else @@ -609,8 +592,8 @@ int ustctl_tracepoint_list(int sock) int ret, tp_list_handle; memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_TRACEPOINT_LIST; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_TRACEPOINT_LIST; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -620,7 +603,7 @@ int ustctl_tracepoint_list(int sock) } int ustctl_tracepoint_list_get(int sock, int tp_list_handle, - struct lttng_ust_tracepoint_iter *iter) + struct lttng_ust_abi_tracepoint_iter *iter) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -631,7 +614,7 @@ int ustctl_tracepoint_list_get(int sock, int tp_list_handle, memset(&lum, 0, sizeof(lum)); lum.handle = tp_list_handle; - lum.cmd = LTTNG_UST_TRACEPOINT_LIST_GET; + lum.cmd = LTTNG_UST_ABI_TRACEPOINT_LIST_GET; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -649,8 +632,8 @@ int ustctl_tracepoint_field_list(int sock) int ret, tp_field_list_handle; memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -660,7 +643,7 @@ int ustctl_tracepoint_field_list(int sock) } 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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -672,7 +655,7 @@ int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle, memset(&lum, 0, sizeof(lum)); lum.handle = tp_field_list_handle; - lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST_GET; + lum.cmd = LTTNG_UST_ABI_TRACEPOINT_FIELD_LIST_GET; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -688,7 +671,7 @@ int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle, return 0; } -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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -698,8 +681,8 @@ int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v) return -EINVAL; memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_TRACER_VERSION; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_TRACER_VERSION; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -715,8 +698,8 @@ int ustctl_wait_quiescent(int sock) int ret; memset(&lum, 0, sizeof(lum)); - lum.handle = LTTNG_UST_ROOT_HANDLE; - lum.cmd = LTTNG_UST_WAIT_QUIESCENT; + lum.handle = LTTNG_UST_ABI_ROOT_HANDLE; + lum.cmd = LTTNG_UST_ABI_WAIT_QUIESCENT; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -724,7 +707,7 @@ int ustctl_wait_quiescent(int sock) return 0; } -int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate) +int ustctl_calibrate(int sock, struct lttng_ust_abi_calibrate *calibrate) { if (!calibrate) return -EINVAL; @@ -732,7 +715,7 @@ int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate) return -ENOSYS; } -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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -743,7 +726,7 @@ int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object) memset(&lum, 0, sizeof(lum)); lum.handle = object->handle; - lum.cmd = LTTNG_UST_FLUSH_BUFFER; + lum.cmd = LTTNG_UST_ABI_FLUSH_BUFFER; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -753,7 +736,7 @@ int ustctl_sock_flush_buffer(int sock, struct lttng_ust_object_data *object) static int ustctl_send_channel(int sock, - enum lttng_ust_chan_type type, + enum lttng_ust_abi_chan_type type, void *data, uint64_t size, int wakeup_fd, @@ -861,9 +844,9 @@ int ustctl_send_stream(int sock, } int ustctl_recv_channel_from_consumer(int sock, - struct lttng_ust_object_data **_channel_data) + struct lttng_ust_abi_object_data **_channel_data) { - struct lttng_ust_object_data *channel_data; + struct lttng_ust_abi_object_data *channel_data; ssize_t len; int wakeup_fd; int ret; @@ -873,7 +856,7 @@ int ustctl_recv_channel_from_consumer(int sock, ret = -ENOMEM; goto error_alloc; } - channel_data->type = LTTNG_UST_OBJECT_TYPE_CHANNEL; + channel_data->type = LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL; channel_data->handle = -1; /* recv mmap size */ @@ -937,9 +920,9 @@ error_alloc: } int ustctl_recv_stream_from_consumer(int sock, - struct lttng_ust_object_data **_stream_data) + struct lttng_ust_abi_object_data **_stream_data) { - struct lttng_ust_object_data *stream_data; + struct lttng_ust_abi_object_data *stream_data; ssize_t len; int ret; int fds[2]; @@ -950,7 +933,7 @@ int ustctl_recv_stream_from_consumer(int sock, goto error_alloc; } - stream_data->type = LTTNG_UST_OBJECT_TYPE_STREAM; + stream_data->type = LTTNG_UST_ABI_OBJECT_TYPE_STREAM; stream_data->handle = -1; /* recv mmap size */ @@ -1002,7 +985,7 @@ error_alloc: } 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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -1013,7 +996,7 @@ int ustctl_send_channel_to_ust(int sock, int session_handle, memset(&lum, 0, sizeof(lum)); lum.handle = session_handle; - lum.cmd = LTTNG_UST_CHANNEL; + lum.cmd = LTTNG_UST_ABI_CHANNEL; lum.u.channel.len = channel_data->size; lum.u.channel.type = channel_data->u.channel.type; ret = ustcomm_send_app_msg(sock, &lum); @@ -1036,8 +1019,8 @@ int ustctl_send_channel_to_ust(int sock, int session_handle, } 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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -1045,7 +1028,7 @@ int ustctl_send_stream_to_ust(int sock, memset(&lum, 0, sizeof(lum)); lum.handle = channel_data->handle; - lum.cmd = LTTNG_UST_STREAM; + lum.cmd = LTTNG_UST_ABI_STREAM; lum.u.stream.len = stream_data->size; lum.u.stream.stream_nr = stream_data->u.stream.stream_nr; ret = ustcomm_send_app_msg(sock, &lum); @@ -1053,7 +1036,7 @@ int ustctl_send_stream_to_ust(int sock, return ret; assert(stream_data); - assert(stream_data->type == LTTNG_UST_OBJECT_TYPE_STREAM); + assert(stream_data->type == LTTNG_UST_ABI_OBJECT_TYPE_STREAM); ret = ustctl_send_stream(sock, stream_data->u.stream.stream_nr, @@ -1065,10 +1048,10 @@ int ustctl_send_stream_to_ust(int sock, return ustcomm_recv_app_reply(sock, &lur, lum.handle, lum.cmd); } -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) { - struct lttng_ust_object_data *obj; + struct lttng_ust_abi_object_data *obj; int ret; if (src->handle != -1) { @@ -1087,7 +1070,7 @@ int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, obj->size = src->size; switch (obj->type) { - case LTTNG_UST_OBJECT_TYPE_CHANNEL: + case LTTNG_UST_ABI_OBJECT_TYPE_CHANNEL: { obj->u.channel.type = src->u.channel.type; if (src->u.channel.wakeup_fd >= 0) { @@ -1123,7 +1106,7 @@ int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, } - case LTTNG_UST_OBJECT_TYPE_STREAM: + case LTTNG_UST_ABI_OBJECT_TYPE_STREAM: { obj->u.stream.stream_nr = src->u.stream.stream_nr; if (src->u.stream.wakeup_fd >= 0) { @@ -1164,7 +1147,7 @@ int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, goto error_type; } - case LTTNG_UST_OBJECT_TYPE_COUNTER: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER: { obj->u.counter.data = zmalloc(obj->size); if (!obj->u.counter.data) { @@ -1175,7 +1158,7 @@ int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, break; } - case LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL: { if (src->u.counter_global.shm_fd >= 0) { obj->u.counter_global.shm_fd = @@ -1188,7 +1171,7 @@ int ustctl_duplicate_ust_object_data(struct lttng_ust_object_data **dest, break; } - case LTTNG_UST_OBJECT_TYPE_COUNTER_CPU: + case LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU: { obj->u.counter_cpu.cpu_nr = src->u.counter_cpu.cpu_nr; if (src->u.counter_cpu.shm_fd >= 0) { @@ -1233,8 +1216,8 @@ struct ustctl_consumer_channel * struct lttng_transport *transport; switch (attr->type) { - case LTTNG_UST_CHAN_PER_CPU: - if (attr->output == LTTNG_UST_MMAP) { + case LTTNG_UST_ABI_CHAN_PER_CPU: + if (attr->output == LTTNG_UST_ABI_MMAP) { if (attr->overwrite) { if (attr->read_timer_interval == 0) { transport_name = "relay-overwrite-mmap"; @@ -1252,8 +1235,8 @@ struct ustctl_consumer_channel * return NULL; } break; - case LTTNG_UST_CHAN_METADATA: - if (attr->output == LTTNG_UST_MMAP) + case LTTNG_UST_ABI_CHAN_METADATA: + if (attr->output == LTTNG_UST_ABI_MMAP) transport_name = "relay-metadata-mmap"; else return NULL; @@ -1263,7 +1246,7 @@ struct ustctl_consumer_channel * return NULL; } - transport = lttng_transport_find(transport_name); + transport = lttng_ust_transport_find(transport_name); if (!transport) { DBG("LTTng transport %s not found\n", transport_name); @@ -1274,7 +1257,7 @@ struct ustctl_consumer_channel * if (!chan) return NULL; - chan->chan = transport->ops.channel_create(transport_name, NULL, + chan->chan = transport->ops.priv->channel_create(transport_name, NULL, attr->subbuf_size, attr->num_subbuf, attr->switch_timer_interval, attr->read_timer_interval, @@ -1299,7 +1282,7 @@ void ustctl_destroy_channel(struct ustctl_consumer_channel *chan) { (void) ustctl_channel_close_wait_fd(chan); (void) ustctl_channel_close_wakeup_fd(chan); - chan->chan->ops->channel_destroy(chan->chan); + chan->chan->ops->priv->channel_destroy(chan->chan); free(chan); } @@ -1308,7 +1291,7 @@ int ustctl_send_channel_to_sessiond(int sock, { struct shm_object_table *table; - table = channel->chan->handle->table; + table = channel->chan->priv->rb_chan->handle->table; if (table->size <= 0) return -EINVAL; return ustctl_send_channel(sock, @@ -1338,17 +1321,17 @@ int ustctl_write_metadata_to_channel( size_t len) /* metadata length */ { struct lttng_ust_lib_ring_buffer_ctx ctx; - struct lttng_channel *chan = channel->chan; + struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan; const char *str = metadata_str; int ret = 0, waitret; size_t reserve_len, pos; for (pos = 0; pos < len; pos += reserve_len) { reserve_len = min_t(size_t, - chan->ops->packet_avail_size(chan->chan, chan->handle), + lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf), len - pos); - lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, - sizeof(char), -1, chan->handle, NULL); + lttng_ust_lib_ring_buffer_ctx_init(&ctx, rb_chan, reserve_len, sizeof(char), NULL); /* * We don't care about metadata buffer's records lost * count, because we always retry here. Report error if @@ -1357,7 +1340,7 @@ int ustctl_write_metadata_to_channel( */ waitret = wait_cond_interruptible_timeout( ({ - ret = chan->ops->event_reserve(&ctx, 0); + ret = lttng_chan_buf->ops->event_reserve(&ctx); ret != -ENOBUFS || !ret; }), LTTNG_METADATA_TIMEOUT_MSEC); @@ -1369,8 +1352,8 @@ int ustctl_write_metadata_to_channel( ret = waitret; goto end; } - chan->ops->event_write(&ctx, &str[pos], reserve_len); - chan->ops->event_commit(&ctx); + lttng_chan_buf->ops->event_write(&ctx, &str[pos], reserve_len, 1); + lttng_chan_buf->ops->event_commit(&ctx); } end: return ret; @@ -1386,25 +1369,25 @@ ssize_t ustctl_write_one_packet_to_channel( size_t len) /* metadata length */ { struct lttng_ust_lib_ring_buffer_ctx ctx; - struct lttng_channel *chan = channel->chan; + struct lttng_ust_channel_buffer *lttng_chan_buf = channel->chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan = lttng_chan_buf->priv->rb_chan; const char *str = metadata_str; ssize_t reserve_len; int ret; reserve_len = min_t(ssize_t, - chan->ops->packet_avail_size(chan->chan, chan->handle), + lttng_chan_buf->ops->priv->packet_avail_size(lttng_chan_buf), len); - lib_ring_buffer_ctx_init(&ctx, chan->chan, NULL, reserve_len, - sizeof(char), -1, chan->handle, NULL); - ret = chan->ops->event_reserve(&ctx, 0); + lttng_ust_lib_ring_buffer_ctx_init(&ctx, rb_chan, reserve_len, sizeof(char), NULL); + ret = lttng_chan_buf->ops->event_reserve(&ctx); if (ret != 0) { DBG("LTTng: event reservation failed"); assert(ret < 0); reserve_len = ret; goto end; } - chan->ops->event_write(&ctx, str, reserve_len); - chan->ops->event_commit(&ctx); + lttng_chan_buf->ops->event_write(&ctx, str, reserve_len, 1); + lttng_chan_buf->ops->event_commit(&ctx); end: return reserve_len; @@ -1412,10 +1395,10 @@ end: int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan) { - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *chan; int ret; - chan = consumer_chan->chan->chan; + chan = consumer_chan->chan->priv->rb_chan; ret = ring_buffer_channel_close_wait_fd(&chan->backend.config, chan, chan->handle); if (!ret) @@ -1425,10 +1408,10 @@ int ustctl_channel_close_wait_fd(struct ustctl_consumer_channel *consumer_chan) int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan) { - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *chan; int ret; - chan = consumer_chan->chan->chan; + chan = consumer_chan->chan->priv->rb_chan; ret = ring_buffer_channel_close_wakeup_fd(&chan->backend.config, chan, chan->handle); if (!ret) @@ -1438,20 +1421,20 @@ int ustctl_channel_close_wakeup_fd(struct ustctl_consumer_channel *consumer_chan int ustctl_stream_close_wait_fd(struct ustctl_consumer_stream *stream) { - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *chan; - chan = stream->chan->chan->chan; + chan = stream->chan->chan->priv->rb_chan; return ring_buffer_stream_close_wait_fd(&chan->backend.config, - chan, stream->handle, stream->cpu); + chan, chan->handle, stream->cpu); } int ustctl_stream_close_wakeup_fd(struct ustctl_consumer_stream *stream) { - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *chan; - chan = stream->chan->chan->chan; + chan = stream->chan->chan->priv->rb_chan; return ring_buffer_stream_close_wakeup_fd(&chan->backend.config, - chan, stream->handle, stream->cpu); + chan, chan->handle, stream->cpu); } struct ustctl_consumer_stream * @@ -1460,7 +1443,7 @@ struct ustctl_consumer_stream * { struct ustctl_consumer_stream *stream; struct lttng_ust_shm_handle *handle; - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; int shm_fd, wait_fd, wakeup_fd; uint64_t memory_map_size; struct lttng_ust_lib_ring_buffer *buf; @@ -1468,13 +1451,13 @@ struct ustctl_consumer_stream * if (!channel) return NULL; - handle = channel->chan->handle; + rb_chan = channel->chan->priv->rb_chan; + handle = rb_chan->handle; if (!handle) return NULL; - chan = channel->chan->chan; - buf = channel_get_ring_buffer(&chan->backend.config, - chan, cpu, handle, &shm_fd, &wait_fd, + buf = channel_get_ring_buffer(&rb_chan->backend.config, + rb_chan, cpu, handle, &shm_fd, &wait_fd, &wakeup_fd, &memory_map_size); if (!buf) return NULL; @@ -1485,7 +1468,6 @@ struct ustctl_consumer_stream * stream = zmalloc(sizeof(*stream)); if (!stream) goto alloc_error; - stream->handle = handle; stream->buf = buf; stream->chan = channel; stream->shm_fd = shm_fd; @@ -1509,7 +1491,7 @@ void ustctl_destroy_stream(struct ustctl_consumer_stream *stream) consumer_chan = stream->chan; (void) ustctl_stream_close_wait_fd(stream); (void) ustctl_stream_close_wakeup_fd(stream); - lib_ring_buffer_release_read(buf, consumer_chan->chan->handle); + lib_ring_buffer_release_read(buf, consumer_chan->chan->priv->rb_chan->handle); free(stream); } @@ -1517,16 +1499,16 @@ int ustctl_channel_get_wait_fd(struct ustctl_consumer_channel *chan) { if (!chan) return -EINVAL; - return shm_get_wait_fd(chan->chan->handle, - &chan->chan->handle->chan._ref); + return shm_get_wait_fd(chan->chan->priv->rb_chan->handle, + &chan->chan->priv->rb_chan->handle->chan._ref); } int ustctl_channel_get_wakeup_fd(struct ustctl_consumer_channel *chan) { if (!chan) return -EINVAL; - return shm_get_wakeup_fd(chan->chan->handle, - &chan->chan->handle->chan._ref); + return shm_get_wakeup_fd(chan->chan->priv->rb_chan->handle, + &chan->chan->priv->rb_chan->handle->chan._ref); } int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream) @@ -1538,7 +1520,7 @@ int ustctl_stream_get_wait_fd(struct ustctl_consumer_stream *stream) return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - return shm_get_wait_fd(consumer_chan->chan->handle, &buf->self._ref); + return shm_get_wait_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref); } int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream) @@ -1550,7 +1532,7 @@ int ustctl_stream_get_wakeup_fd(struct ustctl_consumer_stream *stream) return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - return shm_get_wakeup_fd(consumer_chan->chan->handle, &buf->self._ref); + return shm_get_wakeup_fd(consumer_chan->chan->priv->rb_chan->handle, &buf->self._ref); } /* For mmap mode, readable without "get" operation */ @@ -1564,7 +1546,7 @@ void *ustctl_get_mmap_base(struct ustctl_consumer_stream *stream) return NULL; buf = stream->buf; consumer_chan = stream->chan; - return shmp(consumer_chan->chan->handle, buf->backend.memory_map); + return shmp(consumer_chan->chan->priv->rb_chan->handle, buf->backend.memory_map); } /* returns the length to mmap. */ @@ -1573,17 +1555,17 @@ int ustctl_get_mmap_len(struct ustctl_consumer_stream *stream, { struct ustctl_consumer_channel *consumer_chan; unsigned long mmap_buf_len; - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; if (!stream) return -EINVAL; consumer_chan = stream->chan; - chan = consumer_chan->chan->chan; - if (chan->backend.config.output != RING_BUFFER_MMAP) + rb_chan = consumer_chan->chan->priv->rb_chan; + if (rb_chan->backend.config.output != RING_BUFFER_MMAP) return -EINVAL; - mmap_buf_len = chan->backend.buf_size; - if (chan->backend.extra_reader_sb) - mmap_buf_len += chan->backend.subbuf_size; + mmap_buf_len = rb_chan->backend.buf_size; + if (rb_chan->backend.extra_reader_sb) + mmap_buf_len += rb_chan->backend.subbuf_size; if (mmap_buf_len > INT_MAX) return -EFBIG; *len = mmap_buf_len; @@ -1595,13 +1577,13 @@ int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream, unsigned long *len) { struct ustctl_consumer_channel *consumer_chan; - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; if (!stream) return -EINVAL; consumer_chan = stream->chan; - chan = consumer_chan->chan->chan; - *len = chan->backend.subbuf_size; + rb_chan = consumer_chan->chan->priv->rb_chan; + *len = rb_chan->backend.subbuf_size; return 0; } @@ -1614,7 +1596,7 @@ int ustctl_get_max_subbuf_size(struct ustctl_consumer_stream *stream, int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream, unsigned long *off) { - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; unsigned long sb_bindex; struct lttng_ust_lib_ring_buffer *buf; struct ustctl_consumer_channel *consumer_chan; @@ -1625,16 +1607,16 @@ int ustctl_get_mmap_read_offset(struct ustctl_consumer_stream *stream, return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - chan = consumer_chan->chan->chan; - if (chan->backend.config.output != RING_BUFFER_MMAP) + rb_chan = consumer_chan->chan->priv->rb_chan; + if (rb_chan->backend.config.output != RING_BUFFER_MMAP) return -EINVAL; - sb_bindex = subbuffer_id_get_index(&chan->backend.config, + sb_bindex = subbuffer_id_get_index(&rb_chan->backend.config, buf->backend.buf_rsb.id); - barray_idx = shmp_index(consumer_chan->chan->handle, buf->backend.array, + barray_idx = shmp_index(rb_chan->handle, buf->backend.array, sb_bindex); if (!barray_idx) return -EINVAL; - pages = shmp(consumer_chan->chan->handle, barray_idx->shmp); + pages = shmp(rb_chan->handle, barray_idx->shmp); if (!pages) return -EINVAL; *off = pages->mmap_offset; @@ -1646,7 +1628,7 @@ int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream, unsigned long *len) { struct ustctl_consumer_channel *consumer_chan; - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; struct lttng_ust_lib_ring_buffer *buf; if (!stream) @@ -1654,9 +1636,9 @@ int ustctl_get_subbuf_size(struct ustctl_consumer_stream *stream, buf = stream->buf; consumer_chan = stream->chan; - chan = consumer_chan->chan->chan; - *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf, - consumer_chan->chan->handle); + rb_chan = consumer_chan->chan->priv->rb_chan; + *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf, + rb_chan->handle); return 0; } @@ -1665,16 +1647,16 @@ int ustctl_get_padded_subbuf_size(struct ustctl_consumer_stream *stream, unsigned long *len) { struct ustctl_consumer_channel *consumer_chan; - struct channel *chan; + struct lttng_ust_lib_ring_buffer_channel *rb_chan; struct lttng_ust_lib_ring_buffer *buf; if (!stream) return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - chan = consumer_chan->chan->chan; - *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf, - consumer_chan->chan->handle); + rb_chan = consumer_chan->chan->priv->rb_chan; + *len = lib_ring_buffer_get_read_data_size(&rb_chan->backend.config, buf, + rb_chan->handle); *len = LTTNG_UST_PAGE_ALIGN(*len); return 0; } @@ -1690,7 +1672,7 @@ int ustctl_get_next_subbuf(struct ustctl_consumer_stream *stream) buf = stream->buf; consumer_chan = stream->chan; return lib_ring_buffer_get_next_subbuf(buf, - consumer_chan->chan->handle); + consumer_chan->chan->priv->rb_chan->handle); } @@ -1704,7 +1686,7 @@ int ustctl_put_next_subbuf(struct ustctl_consumer_stream *stream) return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->handle); + lib_ring_buffer_put_next_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle); return 0; } @@ -1721,7 +1703,7 @@ int ustctl_snapshot(struct ustctl_consumer_stream *stream) buf = stream->buf; consumer_chan = stream->chan; return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot, - &buf->prod_snapshot, consumer_chan->chan->handle); + &buf->prod_snapshot, consumer_chan->chan->priv->rb_chan->handle); } /* @@ -1740,7 +1722,7 @@ int ustctl_snapshot_sample_positions(struct ustctl_consumer_stream *stream) consumer_chan = stream->chan; return lib_ring_buffer_snapshot_sample_positions(buf, &buf->cons_snapshot, &buf->prod_snapshot, - consumer_chan->chan->handle); + consumer_chan->chan->priv->rb_chan->handle); } /* Get the consumer position (iteration start) */ @@ -1781,7 +1763,7 @@ int ustctl_get_subbuf(struct ustctl_consumer_stream *stream, buf = stream->buf; consumer_chan = stream->chan; return lib_ring_buffer_get_subbuf(buf, *pos, - consumer_chan->chan->handle); + consumer_chan->chan->priv->rb_chan->handle); } /* Release exclusive sub-buffer access */ @@ -1794,7 +1776,7 @@ int ustctl_put_subbuf(struct ustctl_consumer_stream *stream) return -EINVAL; buf = stream->buf; consumer_chan = stream->chan; - lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->handle); + lib_ring_buffer_put_subbuf(buf, consumer_chan->chan->priv->rb_chan->handle); return 0; } @@ -1809,7 +1791,7 @@ void ustctl_flush_buffer(struct ustctl_consumer_stream *stream, consumer_chan = stream->chan; lib_ring_buffer_switch_slow(buf, producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH, - consumer_chan->chan->handle); + consumer_chan->chan->priv->rb_chan->handle); } void ustctl_clear_buffer(struct ustctl_consumer_stream *stream) @@ -1821,22 +1803,18 @@ void ustctl_clear_buffer(struct ustctl_consumer_stream *stream) buf = stream->buf; consumer_chan = stream->chan; lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, - consumer_chan->chan->handle); - lib_ring_buffer_clear_reader(buf, consumer_chan->chan->handle); + consumer_chan->chan->priv->rb_chan->handle); + lib_ring_buffer_clear_reader(buf, consumer_chan->chan->priv->rb_chan->handle); } static struct lttng_ust_client_lib_ring_buffer_client_cb *get_client_cb( struct lttng_ust_lib_ring_buffer *buf, - struct lttng_ust_shm_handle *handle) + struct lttng_ust_lib_ring_buffer_channel *chan) { - struct channel *chan; const struct lttng_ust_lib_ring_buffer_config *config; struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; - chan = shmp(handle, buf->backend.chan); - if (!chan) - return NULL; config = &chan->backend.config; if (!config->cb_ptr) return NULL; @@ -1850,156 +1828,156 @@ int ustctl_get_timestamp_begin(struct ustctl_consumer_stream *stream, uint64_t *timestamp_begin) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !timestamp_begin) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->timestamp_begin(buf, handle, timestamp_begin); + return client_cb->timestamp_begin(buf, chan, timestamp_begin); } int ustctl_get_timestamp_end(struct ustctl_consumer_stream *stream, uint64_t *timestamp_end) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !timestamp_end) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->timestamp_end(buf, handle, timestamp_end); + return client_cb->timestamp_end(buf, chan, timestamp_end); } int ustctl_get_events_discarded(struct ustctl_consumer_stream *stream, uint64_t *events_discarded) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !events_discarded) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->events_discarded(buf, handle, events_discarded); + return client_cb->events_discarded(buf, chan, events_discarded); } int ustctl_get_content_size(struct ustctl_consumer_stream *stream, uint64_t *content_size) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !content_size) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->content_size(buf, handle, content_size); + return client_cb->content_size(buf, chan, content_size); } int ustctl_get_packet_size(struct ustctl_consumer_stream *stream, uint64_t *packet_size) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !packet_size) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->packet_size(buf, handle, packet_size); + return client_cb->packet_size(buf, chan, packet_size); } int ustctl_get_stream_id(struct ustctl_consumer_stream *stream, uint64_t *stream_id) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !stream_id) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->stream_id(buf, handle, stream_id); + return client_cb->stream_id(buf, chan, stream_id); } int ustctl_get_current_timestamp(struct ustctl_consumer_stream *stream, uint64_t *ts) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !ts) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb || !client_cb->current_timestamp) return -ENOSYS; - return client_cb->current_timestamp(buf, handle, ts); + return client_cb->current_timestamp(buf, chan, ts); } int ustctl_get_sequence_number(struct ustctl_consumer_stream *stream, uint64_t *seq) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !seq) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb || !client_cb->sequence_number) return -ENOSYS; - return client_cb->sequence_number(buf, handle, seq); + return client_cb->sequence_number(buf, chan, seq); } int ustctl_get_instance_id(struct ustctl_consumer_stream *stream, uint64_t *id) { struct lttng_ust_client_lib_ring_buffer_client_cb *client_cb; + struct lttng_ust_lib_ring_buffer_channel *chan; struct lttng_ust_lib_ring_buffer *buf; - struct lttng_ust_shm_handle *handle; if (!stream || !id) return -EINVAL; buf = stream->buf; - handle = stream->chan->chan->handle; - client_cb = get_client_cb(buf, handle); + chan = stream->chan->chan->priv->rb_chan; + client_cb = get_client_cb(buf, chan); if (!client_cb) return -ENOSYS; - return client_cb->instance_id(buf, handle, id); + return client_cb->instance_id(buf, chan, id); } -#ifdef HAVE_PERF_EVENT +#ifdef HAVE_LINUX_PERF_EVENT_H int ustctl_has_perf_counters(void) { @@ -2145,10 +2123,10 @@ int ustctl_recv_reg_msg(int sock, if (len < 0) return len; - if (reg_msg.magic == LTTNG_UST_COMM_MAGIC) { + if (reg_msg.magic == LTTNG_UST_ABI_COMM_MAGIC) { *byte_order = BYTE_ORDER == BIG_ENDIAN ? BIG_ENDIAN : LITTLE_ENDIAN; - } else if (reg_msg.magic == bswap_32(LTTNG_UST_COMM_MAGIC)) { + } else if (reg_msg.magic == bswap_32(LTTNG_UST_ABI_COMM_MAGIC)) { *byte_order = BYTE_ORDER == BIG_ENDIAN ? LITTLE_ENDIAN : BIG_ENDIAN; } else { @@ -2235,8 +2213,8 @@ int ustctl_recv_register_event(int sock, *session_objd = msg.session_objd; *channel_objd = msg.channel_objd; - strncpy(event_name, msg.event_name, LTTNG_UST_SYM_NAME_LEN); - event_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + strncpy(event_name, msg.event_name, LTTNG_UST_ABI_SYM_NAME_LEN); + event_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0'; *loglevel = msg.loglevel; signature_len = msg.signature_len; fields_len = msg.fields_len; @@ -2375,8 +2353,8 @@ int ustctl_recv_register_enum(int sock, return len; *session_objd = msg.session_objd; - strncpy(enum_name, msg.enum_name, LTTNG_UST_SYM_NAME_LEN); - enum_name[LTTNG_UST_SYM_NAME_LEN - 1] = '\0'; + strncpy(enum_name, msg.enum_name, LTTNG_UST_ABI_SYM_NAME_LEN); + enum_name[LTTNG_UST_ABI_SYM_NAME_LEN - 1] = '\0'; entries_len = msg.entries_len; if (entries_len % sizeof(*a_entries) != 0) { @@ -2544,7 +2522,7 @@ int ustctl_regenerate_statedump(int sock, int handle) memset(&lum, 0, sizeof(lum)); lum.handle = handle; - lum.cmd = LTTNG_UST_SESSION_STATEDUMP; + lum.cmd = LTTNG_UST_ABI_SESSION_STATEDUMP; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; @@ -2568,7 +2546,8 @@ struct ustctl_daemon_counter * const int *counter_cpu_fds, enum ustctl_counter_bitness bitness, enum ustctl_counter_arithmetic arithmetic, - uint32_t alloc_flags) + uint32_t alloc_flags, + bool coalesce_hits) { const char *transport_name; struct ustctl_daemon_counter *counter; @@ -2634,6 +2613,7 @@ struct ustctl_daemon_counter * counter->attr->arithmetic = arithmetic; counter->attr->nr_dimensions = nr_dimensions; counter->attr->global_sum_step = global_sum_step; + counter->attr->coalesce_hits = coalesce_hits; for (i = 0; i < nr_dimensions; i++) counter->attr->dimensions[i] = dimensions[i]; @@ -2660,35 +2640,36 @@ free_counter: } int ustctl_create_counter_data(struct ustctl_daemon_counter *counter, - struct lttng_ust_object_data **_counter_data) + struct lttng_ust_abi_object_data **_counter_data) { - struct lttng_ust_object_data *counter_data; - struct lttng_ust_counter_conf counter_conf = {0}; + struct lttng_ust_abi_object_data *counter_data; + struct lttng_ust_abi_counter_conf counter_conf = {0}; size_t i; int ret; switch (counter->attr->arithmetic) { case USTCTL_COUNTER_ARITHMETIC_MODULAR: - counter_conf.arithmetic = LTTNG_UST_COUNTER_ARITHMETIC_MODULAR; + counter_conf.arithmetic = LTTNG_UST_ABI_COUNTER_ARITHMETIC_MODULAR; break; case USTCTL_COUNTER_ARITHMETIC_SATURATION: - counter_conf.arithmetic = LTTNG_UST_COUNTER_ARITHMETIC_SATURATION; + counter_conf.arithmetic = LTTNG_UST_ABI_COUNTER_ARITHMETIC_SATURATION; break; default: return -EINVAL; } switch (counter->attr->bitness) { case USTCTL_COUNTER_BITNESS_32: - counter_conf.bitness = LTTNG_UST_COUNTER_BITNESS_32; + counter_conf.bitness = LTTNG_UST_ABI_COUNTER_BITNESS_32; break; case USTCTL_COUNTER_BITNESS_64: - counter_conf.bitness = LTTNG_UST_COUNTER_BITNESS_64; + counter_conf.bitness = LTTNG_UST_ABI_COUNTER_BITNESS_64; break; default: return -EINVAL; } counter_conf.number_dimensions = counter->attr->nr_dimensions; counter_conf.global_sum_step = counter->attr->global_sum_step; + counter_conf.coalesce_hits = counter->attr->coalesce_hits; for (i = 0; i < counter->attr->nr_dimensions; i++) { counter_conf.dimensions[i].size = counter->attr->dimensions[i].size; counter_conf.dimensions[i].underflow_index = counter->attr->dimensions[i].underflow_index; @@ -2702,7 +2683,7 @@ int ustctl_create_counter_data(struct ustctl_daemon_counter *counter, ret = -ENOMEM; goto error_alloc; } - counter_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER; + counter_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER; counter_data->handle = -1; counter_data->size = sizeof(counter_conf); @@ -2724,9 +2705,9 @@ error_alloc: } int ustctl_create_counter_global_data(struct ustctl_daemon_counter *counter, - struct lttng_ust_object_data **_counter_global_data) + struct lttng_ust_abi_object_data **_counter_global_data) { - struct lttng_ust_object_data *counter_global_data; + struct lttng_ust_abi_object_data *counter_global_data; int ret, fd; size_t len; @@ -2737,7 +2718,7 @@ int ustctl_create_counter_global_data(struct ustctl_daemon_counter *counter, ret = -ENOMEM; goto error_alloc; } - counter_global_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER_GLOBAL; + counter_global_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_GLOBAL; counter_global_data->handle = -1; counter_global_data->size = len; counter_global_data->u.counter_global.shm_fd = fd; @@ -2749,9 +2730,9 @@ error_alloc: } int ustctl_create_counter_cpu_data(struct ustctl_daemon_counter *counter, int cpu, - struct lttng_ust_object_data **_counter_cpu_data) + struct lttng_ust_abi_object_data **_counter_cpu_data) { - struct lttng_ust_object_data *counter_cpu_data; + struct lttng_ust_abi_object_data *counter_cpu_data; int ret, fd; size_t len; @@ -2762,7 +2743,7 @@ int ustctl_create_counter_cpu_data(struct ustctl_daemon_counter *counter, int cp ret = -ENOMEM; goto error_alloc; } - counter_cpu_data->type = LTTNG_UST_OBJECT_TYPE_COUNTER_CPU; + counter_cpu_data->type = LTTNG_UST_ABI_OBJECT_TYPE_COUNTER_CPU; counter_cpu_data->handle = -1; counter_cpu_data->size = len; counter_cpu_data->u.counter_cpu.shm_fd = fd; @@ -2782,7 +2763,7 @@ void ustctl_destroy_counter(struct ustctl_daemon_counter *counter) } int ustctl_send_counter_data_to_ust(int sock, int parent_handle, - struct lttng_ust_object_data *counter_data) + struct lttng_ust_abi_object_data *counter_data) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -2796,7 +2777,7 @@ int ustctl_send_counter_data_to_ust(int sock, int parent_handle, size = counter_data->size; memset(&lum, 0, sizeof(lum)); lum.handle = parent_handle; - lum.cmd = LTTNG_UST_COUNTER; + lum.cmd = LTTNG_UST_ABI_COUNTER; lum.u.counter.len = size; ret = ustcomm_send_app_msg(sock, &lum); if (ret) @@ -2819,8 +2800,8 @@ int ustctl_send_counter_data_to_ust(int sock, int parent_handle, } int ustctl_send_counter_global_data_to_ust(int sock, - struct lttng_ust_object_data *counter_data, - struct lttng_ust_object_data *counter_global_data) + struct lttng_ust_abi_object_data *counter_data, + struct lttng_ust_abi_object_data *counter_global_data) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -2834,7 +2815,7 @@ int ustctl_send_counter_global_data_to_ust(int sock, size = counter_global_data->size; memset(&lum, 0, sizeof(lum)); lum.handle = counter_data->handle; /* parent handle */ - lum.cmd = LTTNG_UST_COUNTER_GLOBAL; + lum.cmd = LTTNG_UST_ABI_COUNTER_GLOBAL; lum.u.counter_global.len = size; ret = ustcomm_send_app_msg(sock, &lum); if (ret) @@ -2857,8 +2838,8 @@ int ustctl_send_counter_global_data_to_ust(int sock, } int ustctl_send_counter_cpu_data_to_ust(int sock, - struct lttng_ust_object_data *counter_data, - struct lttng_ust_object_data *counter_cpu_data) + struct lttng_ust_abi_object_data *counter_data, + struct lttng_ust_abi_object_data *counter_cpu_data) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; @@ -2872,7 +2853,7 @@ int ustctl_send_counter_cpu_data_to_ust(int sock, size = counter_cpu_data->size; memset(&lum, 0, sizeof(lum)); lum.handle = counter_data->handle; /* parent handle */ - lum.cmd = LTTNG_UST_COUNTER_CPU; + lum.cmd = LTTNG_UST_ABI_COUNTER_CPU; lum.u.counter_cpu.len = size; lum.u.counter_cpu.cpu_nr = counter_cpu_data->u.counter_cpu.cpu_nr; ret = ustcomm_send_app_msg(sock, &lum); @@ -2919,30 +2900,26 @@ int ustctl_counter_clear(struct ustctl_daemon_counter *counter, return counter->ops->counter_clear(counter->counter, dimension_indexes); } -static __attribute__((constructor)) +static +void ustctl_init(void) + __attribute__((constructor)); +static void ustctl_init(void) { ust_err_init(); lttng_ust_getenv_init(); /* Needs ust_err_init() to be completed. */ lttng_ust_clock_init(); - lttng_ring_buffer_metadata_client_init(); - lttng_ring_buffer_client_overwrite_init(); - lttng_ring_buffer_client_overwrite_rt_init(); - lttng_ring_buffer_client_discard_init(); - lttng_ring_buffer_client_discard_rt_init(); - lttng_counter_client_percpu_32_modular_init(); - lttng_counter_client_percpu_64_modular_init(); + lttng_ust_ring_buffer_clients_init(); + lttng_ust_counter_clients_init(); lib_ringbuffer_signal_init(); } -static __attribute__((destructor)) +static +void ustctl_exit(void) + __attribute__((destructor)); +static void ustctl_exit(void) { - lttng_ring_buffer_client_discard_rt_exit(); - lttng_ring_buffer_client_discard_exit(); - lttng_ring_buffer_client_overwrite_rt_exit(); - lttng_ring_buffer_client_overwrite_exit(); - lttng_ring_buffer_metadata_client_exit(); - lttng_counter_client_percpu_32_modular_exit(); - lttng_counter_client_percpu_64_modular_exit(); + lttng_ust_counter_clients_exit(); + lttng_ust_ring_buffer_clients_exit(); }