X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=liblttng-ust-ctl%2Fustctl.c;h=656aeac51e44720f12f2406de382758e9bb8afb0;hb=a5a11240d566ae02795c1c6f23e65af88fb5ca08;hp=6f3d1ed97c6c983b52a631ab95cbdc358cfd0497;hpb=69400ac4a4e6575f749c6326df7c2a2c8ac3bdc5;p=lttng-ust.git diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c index 6f3d1ed9..656aeac5 100644 --- a/liblttng-ust-ctl/ustctl.c +++ b/liblttng-ust-ctl/ustctl.c @@ -20,8 +20,11 @@ #include #include #include -#include -#include +#include +#include + +#include +#include #include "../libringbuffer/backend.h" #include "../libringbuffer/frontend.h" @@ -37,22 +40,44 @@ void init_object(struct lttng_ust_object_data *data) data->memory_map_size = 0; } -void release_object(int sock, struct lttng_ust_object_data *data) +int ustctl_release_handle(int sock, int handle) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; int ret; - if (data->shm_fd >= 0) - close(data->shm_fd); - if (data->wait_fd >= 0) - close(data->wait_fd); - memset(&lum, 0, sizeof(lum)); - lum.handle = data->handle; - lum.cmd = LTTNG_UST_RELEASE; - ret = ustcomm_send_app_cmd(sock, &lum, &lur); - assert(!ret); - free(data); + if (sock >= 0) { + memset(&lum, 0, sizeof(lum)); + lum.handle = handle; + lum.cmd = LTTNG_UST_RELEASE; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret < 0) { + return ret; + } + } + return 0; +} +/* + * 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 ret; + + if (data->shm_fd >= 0) { + ret = close(data->shm_fd); + if (ret < 0) { + return ret; + } + } + if (data->wait_fd >= 0) { + ret = close(data->wait_fd); + if (ret < 0) { + return ret; + } + } + return ustctl_release_handle(sock, data->handle); } /* @@ -152,7 +177,8 @@ int ustctl_open_metadata(int sock, int session_handle, return 0; error: - release_object(sock, metadata_data); + (void) ustctl_release_object(sock, metadata_data); + free(metadata_data); return -EINVAL; } @@ -205,7 +231,8 @@ int ustctl_create_channel(int sock, int session_handle, return 0; error: - release_object(sock, channel_data); + (void) ustctl_release_object(sock, channel_data); + free(channel_data); return -EINVAL; } @@ -256,7 +283,8 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, return ret; error: - release_object(sock, stream_data); + (void) ustctl_release_object(sock, stream_data); + free(stream_data); return -EINVAL; } @@ -368,10 +396,42 @@ int ustctl_stop_session(int sock, int handle) return ustctl_disable(sock, &obj); } - int ustctl_tracepoint_list(int sock) { - return -ENOSYS; /* not implemented */ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret, tp_list_handle; + + memset(&lum, 0, sizeof(lum)); + lum.handle = LTTNG_UST_ROOT_HANDLE; + lum.cmd = LTTNG_UST_TRACEPOINT_LIST; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + tp_list_handle = lur.ret_val; + DBG("received tracepoint list handle %u", tp_list_handle); + return tp_list_handle; +} + +int ustctl_tracepoint_list_get(int sock, int tp_list_handle, + struct lttng_ust_tracepoint_iter *iter) +{ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret; + + memset(&lum, 0, sizeof(lum)); + lum.handle = tp_list_handle; + lum.cmd = LTTNG_UST_TRACEPOINT_LIST_GET; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + DBG("received tracepoint list entry name %s loglevel %s loglevel_value %lld", + lur.u.tracepoint.name, + lur.u.tracepoint.loglevel, + (unsigned long long) lur.u.tracepoint.loglevel_value); + memcpy(iter, &lur.u.tracepoint, sizeof(*iter)); + return 0; } int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v) @@ -407,20 +467,25 @@ int ustctl_wait_quiescent(int sock) return 0; } -int ustctl_flush_buffer(int sock, struct lttng_ust_object_data *channel_data) +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) { struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; + int ret; memset(&lum, 0, sizeof(lum)); - lum.handle = channel_data->handle; + lum.handle = object->handle; lum.cmd = LTTNG_UST_FLUSH_BUFFER; - return ustcomm_send_app_cmd(sock, &lum, &lur); -} - -int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate) -{ - return -ENOSYS; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + DBG("flushed buffer handle %u", object->handle); + return 0; } /* Buffer operations */ @@ -431,6 +496,8 @@ struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *ch struct lttng_ust_shm_handle *handle; struct channel *chan; size_t chan_size; + struct lttng_ust_lib_ring_buffer_config *config; + int ret; handle = channel_handle_create(chan_data->shm_fd, chan_data->wait_fd, @@ -460,6 +527,38 @@ struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *ch return NULL; } memcpy(handle->shadow_chan, chan, chan_size); + /* + * The callback pointers in the producer are invalid in the + * consumer. We need to look them up here. + */ + config = &handle->shadow_chan->backend.config; + switch (config->client_type) { + case LTTNG_CLIENT_METADATA: + memcpy(&config->cb, lttng_client_callbacks_metadata, + sizeof(config->cb)); + break; + case LTTNG_CLIENT_DISCARD: + memcpy(&config->cb, lttng_client_callbacks_discard, + sizeof(config->cb)); + break; + case LTTNG_CLIENT_OVERWRITE: + memcpy(&config->cb, lttng_client_callbacks_overwrite, + sizeof(config->cb)); + break; + default: + ERR("Unknown client type %d", config->client_type); + channel_destroy(chan, handle, 1); + return NULL; + } + /* Replace the object table pointer. */ + ret = munmap(handle->table->objects[0].memory_map, + handle->table->objects[0].memory_map_size); + if (ret) { + perror("munmap"); + assert(0); + } + handle->table->objects[0].memory_map = (char *) handle->shadow_chan; + handle->table->objects[0].is_shadow = 1; return handle; } @@ -660,9 +759,11 @@ int ustctl_put_subbuf(struct lttng_ust_shm_handle *handle, return 0; } -int ustctl_buffer_flush(struct lttng_ust_shm_handle *handle, - struct lttng_ust_lib_ring_buffer *buf) +void ustctl_flush_buffer(struct lttng_ust_shm_handle *handle, + struct lttng_ust_lib_ring_buffer *buf, + int producer_active) { - lib_ring_buffer_switch_slow(buf, SWITCH_ACTIVE, handle); - return 0; + lib_ring_buffer_switch_slow(buf, + producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH, + handle); }