X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust-ctl%2Fustctl.c;h=d443a2978db76d67d96fcb21b0e0353e60c2b0c2;hb=refs%2Fheads%2Fstable-2.1;hp=2d915260c8c522a2ac919b58a1222d48ec0c072c;hpb=b52190f262330b5ffbbdd49f1190114e68004069;p=lttng-ust.git diff --git a/liblttng-ust-ctl/ustctl.c b/liblttng-ust-ctl/ustctl.c index 2d915260..d443a297 100644 --- a/liblttng-ust-ctl/ustctl.c +++ b/liblttng-ust-ctl/ustctl.c @@ -2,26 +2,29 @@ * Copyright (C) 2011 - Julien Desfossez * Mathieu Desnoyers * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; only version 2 - * of the License. + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License only. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ +#define _GNU_SOURCE #include #include #include -#include -#include +#include +#include + +#include +#include #include "../libringbuffer/backend.h" #include "../libringbuffer/frontend.h" @@ -37,22 +40,48 @@ void init_object(struct lttng_ust_object_data *data) data->memory_map_size = 0; } -void ustctl_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) + 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) + return -EINVAL; + + if (data->shm_fd >= 0) { + ret = close(data->shm_fd); + if (ret < 0) { + ret = -errno; + return ret; + } + } + if (data->wait_fd >= 0) { + ret = close(data->wait_fd); + if (ret < 0) { + ret = -errno; + return ret; + } + } + return ustctl_release_handle(sock, data->handle); } /* @@ -71,14 +100,7 @@ int ustctl_register_done(int sock) ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) return ret; - if (lur.ret_code != USTCOMM_OK) { - DBG("Return code: %s", ustcomm_get_readable_code(lur.ret_code)); - goto error; - } return 0; - -error: - return -1; } /* @@ -110,7 +132,10 @@ int ustctl_open_metadata(int sock, int session_handle, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *metadata_data; - int ret; + int ret, err = 0; + + if (!chops || !_metadata_data) + return -EINVAL; metadata_data = malloc(sizeof(*metadata_data)); if (!metadata_data) @@ -131,29 +156,34 @@ int ustctl_open_metadata(int sock, int session_handle, free(metadata_data); return ret; } - if (lur.ret_code != USTCOMM_OK) { - free(metadata_data); - return lur.ret_code; - } metadata_data->handle = lur.ret_val; DBG("received metadata handle %u", metadata_data->handle); metadata_data->memory_map_size = lur.u.channel.memory_map_size; /* get shm fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) - goto error; - metadata_data->shm_fd = ret; + err = ret; + else + metadata_data->shm_fd = ret; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) + err = ret; + else + metadata_data->wait_fd = ret; + if (err) goto error; - metadata_data->wait_fd = ret; *_metadata_data = metadata_data; return 0; error: - ustctl_release_object(sock, metadata_data); - return -EINVAL; + (void) ustctl_release_object(sock, metadata_data); + free(metadata_data); + return err; } int ustctl_create_channel(int sock, int session_handle, @@ -163,7 +193,10 @@ int ustctl_create_channel(int sock, int session_handle, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *channel_data; - int ret; + int ret, err = 0; + + if (!chops || !_channel_data) + return -EINVAL; channel_data = malloc(sizeof(*channel_data)); if (!channel_data) @@ -184,35 +217,41 @@ int ustctl_create_channel(int sock, int session_handle, free(channel_data); return ret; } - if (lur.ret_code != USTCOMM_OK) { - free(channel_data); - return lur.ret_code; - } channel_data->handle = lur.ret_val; DBG("received channel handle %u", channel_data->handle); channel_data->memory_map_size = lur.u.channel.memory_map_size; /* get shm fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) - goto error; - channel_data->shm_fd = ret; + err = ret; + else + channel_data->shm_fd = ret; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ ret = ustcomm_recv_fd(sock); if (ret < 0) + err = ret; + else + channel_data->wait_fd = ret; + if (err) goto error; - channel_data->wait_fd = ret; *_channel_data = channel_data; return 0; error: - ustctl_release_object(sock, channel_data); - return -EINVAL; + (void) ustctl_release_object(sock, channel_data); + free(channel_data); + return err; } /* - * Return -ENOENT if no more stream is available for creation. + * Return -LTTNG_UST_ERR_NOENT if no more stream is available for creation. * Return 0 on success. - * Return negative error value on error. + * Return negative error value on system error. + * Return positive error value on UST error. */ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, struct lttng_ust_object_data **_stream_data) @@ -220,7 +259,10 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, struct ustcomm_ust_msg lum; struct ustcomm_ust_reply lur; struct lttng_ust_object_data *stream_data; - int ret, fd; + int ret, fd, err = 0; + + if (!channel_data || !_stream_data) + return -EINVAL; stream_data = malloc(sizeof(*stream_data)); if (!stream_data) @@ -234,30 +276,34 @@ int ustctl_create_stream(int sock, struct lttng_ust_object_data *channel_data, free(stream_data); return ret; } - if (lur.ret_code != USTCOMM_OK) { - free(stream_data); - return lur.ret_code; - } - stream_data->handle = lur.ret_val; DBG("received stream handle %u", stream_data->handle); stream_data->memory_map_size = lur.u.stream.memory_map_size; /* get shm fd */ fd = ustcomm_recv_fd(sock); if (fd < 0) - goto error; - stream_data->shm_fd = fd; + err = fd; + else + stream_data->shm_fd = fd; + /* + * We need to get the second FD even if the first fails, because + * libust expects us to read the two FDs. + */ /* get wait fd */ fd = ustcomm_recv_fd(sock); if (fd < 0) + err = fd; + else + stream_data->wait_fd = fd; + if (err) goto error; - stream_data->wait_fd = fd; *_stream_data = stream_data; return ret; error: - ustctl_release_object(sock, stream_data); - return -EINVAL; + (void) ustctl_release_object(sock, stream_data); + free(stream_data); + return err; } int ustctl_create_event(int sock, struct lttng_ust_event *ev, @@ -269,6 +315,9 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev, struct lttng_ust_object_data *event_data; int ret; + if (!channel_data || !_event_data) + return -EINVAL; + event_data = malloc(sizeof(*event_data)); if (!event_data) return -ENOMEM; @@ -279,6 +328,8 @@ int ustctl_create_event(int sock, struct lttng_ust_event *ev, strncpy(lum.u.event.name, ev->name, LTTNG_UST_SYM_NAME_LEN); lum.u.event.instrumentation = ev->instrumentation; + lum.u.event.loglevel_type = ev->loglevel_type; + lum.u.event.loglevel = ev->loglevel; ret = ustcomm_send_app_cmd(sock, &lum, &lur); if (ret) { free(event_data); @@ -299,6 +350,9 @@ int ustctl_add_context(int sock, struct lttng_ust_context *ctx, struct lttng_ust_object_data *context_data; int ret; + if (!obj_data || !_context_data) + return -EINVAL; + context_data = malloc(sizeof(*context_data)); if (!context_data) return -ENOMEM; @@ -318,6 +372,39 @@ int ustctl_add_context(int sock, struct lttng_ust_context *ctx, return ret; } +int ustctl_set_filter(int sock, struct lttng_ust_filter_bytecode *bytecode, + struct lttng_ust_object_data *obj_data) +{ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret; + + if (!obj_data) + return -EINVAL; + + memset(&lum, 0, sizeof(lum)); + lum.handle = obj_data->handle; + lum.cmd = LTTNG_UST_FILTER; + lum.u.filter.data_size = bytecode->len; + lum.u.filter.reloc_offset = bytecode->reloc_offset; + lum.u.filter.seqnum = bytecode->seqnum; + + ret = ustcomm_send_app_msg(sock, &lum); + if (ret) + return ret; + /* send var len bytecode */ + ret = ustcomm_send_unix_sock(sock, bytecode->data, + bytecode->len); + if (ret < 0) { + if (ret == -ECONNRESET) + fprintf(stderr, "remote end closed connection\n"); + return ret; + } + if (ret != bytecode->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) { @@ -325,6 +412,9 @@ int ustctl_enable(int sock, struct lttng_ust_object_data *object) struct ustcomm_ust_reply lur; int ret; + if (!object) + return -EINVAL; + memset(&lum, 0, sizeof(lum)); lum.handle = object->handle; lum.cmd = LTTNG_UST_ENABLE; @@ -342,6 +432,9 @@ int ustctl_disable(int sock, struct lttng_ust_object_data *object) struct ustcomm_ust_reply lur; int ret; + if (!object) + return -EINVAL; + memset(&lum, 0, sizeof(lum)); lum.handle = object->handle; lum.cmd = LTTNG_UST_DISABLE; @@ -368,10 +461,90 @@ 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; + + if (!iter) + return -EINVAL; + + 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 %d", + lur.u.tracepoint.name, + lur.u.tracepoint.loglevel); + memcpy(iter, &lur.u.tracepoint, sizeof(*iter)); + return 0; +} + +int ustctl_tracepoint_field_list(int sock) +{ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret, tp_field_list_handle; + + memset(&lum, 0, sizeof(lum)); + lum.handle = LTTNG_UST_ROOT_HANDLE; + lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + tp_field_list_handle = lur.ret_val; + DBG("received tracepoint field list handle %u", tp_field_list_handle); + return tp_field_list_handle; +} + +int ustctl_tracepoint_field_list_get(int sock, int tp_field_list_handle, + struct lttng_ust_field_iter *iter) +{ + struct ustcomm_ust_msg lum; + struct ustcomm_ust_reply lur; + int ret; + ssize_t len; + + if (!iter) + return -EINVAL; + + memset(&lum, 0, sizeof(lum)); + lum.handle = tp_field_list_handle; + lum.cmd = LTTNG_UST_TRACEPOINT_FIELD_LIST_GET; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + len = ustcomm_recv_unix_sock(sock, iter, sizeof(*iter)); + if (len != sizeof(*iter)) { + return -EINVAL; + } + DBG("received tracepoint field list entry event_name %s event_loglevel %d field_name %s field_type %d", + iter->event_name, + iter->loglevel, + iter->field_name, + iter->type); + return 0; } int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v) @@ -380,6 +553,9 @@ int ustctl_tracer_version(int sock, struct lttng_ust_tracer_version *v) struct ustcomm_ust_reply lur; int ret; + if (!v) + return -EINVAL; + memset(&lum, 0, sizeof(lum)); lum.handle = LTTNG_UST_ROOT_HANDLE; lum.cmd = LTTNG_UST_TRACER_VERSION; @@ -409,9 +585,31 @@ int ustctl_wait_quiescent(int sock) int ustctl_calibrate(int sock, struct lttng_ust_calibrate *calibrate) { + if (!calibrate) + return -EINVAL; + 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; + + if (!object) + return -EINVAL; + + memset(&lum, 0, sizeof(lum)); + lum.handle = object->handle; + lum.cmd = LTTNG_UST_FLUSH_BUFFER; + ret = ustcomm_send_app_cmd(sock, &lum, &lur); + if (ret) + return ret; + DBG("flushed buffer handle %u", object->handle); + return 0; +} + /* Buffer operations */ /* Map channel shm into process memory */ @@ -420,6 +618,11 @@ 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; + + if (!chan_data) + return NULL; handle = channel_handle_create(chan_data->shm_fd, chan_data->wait_fd, @@ -429,12 +632,24 @@ struct lttng_ust_shm_handle *ustctl_map_channel(struct lttng_ust_object_data *ch return NULL; } /* - * Set to -1 because the lttng_ust_shm_handle destruction will take care - * of closing shm_fd and wait_fd. + * Set to -1, and then close the shm fd, and set the handle shm + * fd to -1 too. We don't need the shm fds after they have been + * mapped. + * The wait_fd is set to -1 in chan_data because it is now owned + * by the handle. */ chan_data->shm_fd = -1; chan_data->wait_fd = -1; + /* chan is object 0. This is hardcoded. */ + if (handle->table->objects[0].shm_fd >= 0) { + ret = close(handle->table->objects[0].shm_fd); + if (ret) { + perror("Error closing shm_fd"); + } + handle->table->objects[0].shm_fd = -1; + } + /* * TODO: add consistency checks to be resilient if the * application try to feed us with incoherent channel structure @@ -449,6 +664,39 @@ 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); + free(handle->shadow_chan); + 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; } @@ -458,6 +706,9 @@ int ustctl_add_stream(struct lttng_ust_shm_handle *handle, { int ret; + if (!handle || !stream_data) + return -EINVAL; + if (!stream_data->handle) return -ENOENT; /* map stream */ @@ -482,19 +733,28 @@ void ustctl_unmap_channel(struct lttng_ust_shm_handle *handle) { struct channel *chan; + assert(handle); chan = shmp(handle, handle->chan); channel_destroy(chan, handle, 1); + free(handle->shadow_chan); } +/* + * ustctl closes the shm_fd fds after mapping it. + */ struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_handle *handle, int cpu) { - struct channel *chan = handle->shadow_chan; - int shm_fd, wait_fd; - uint64_t memory_map_size; + struct channel *chan; + int *shm_fd, *wait_fd; + uint64_t *memory_map_size; struct lttng_ust_lib_ring_buffer *buf; int ret; + if (!handle) + return NULL; + + chan = handle->shadow_chan; buf = channel_get_ring_buffer(&chan->backend.config, chan, cpu, handle, &shm_fd, &wait_fd, &memory_map_size); if (!buf) @@ -502,12 +762,23 @@ struct lttng_ust_lib_ring_buffer *ustctl_open_stream_read(struct lttng_ust_shm_h ret = lib_ring_buffer_open_read(buf, handle, 1); if (ret) return NULL; + /* + * We can close shm_fd early, right after is has been mapped. + */ + if (*shm_fd >= 0) { + ret = close(*shm_fd); + if (ret) { + perror("Error closing shm_fd"); + } + *shm_fd = -1; + } return buf; } void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + assert(handle && buf); lib_ring_buffer_release_read(buf, handle, 1); } @@ -516,6 +787,8 @@ void ustctl_close_stream_read(struct lttng_ust_shm_handle *handle, void *ustctl_get_mmap_base(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + if (!handle || !buf) + return NULL; return shmp(handle, buf->backend.memory_map); } @@ -525,8 +798,12 @@ int ustctl_get_mmap_len(struct lttng_ust_shm_handle *handle, unsigned long *len) { unsigned long mmap_buf_len; - struct channel *chan = handle->shadow_chan; + struct channel *chan; + + if (!handle || !buf || !len) + return -EINVAL; + chan = handle->shadow_chan; if (chan->backend.config.output != RING_BUFFER_MMAP) return -EINVAL; mmap_buf_len = chan->backend.buf_size; @@ -543,8 +820,12 @@ int ustctl_get_max_subbuf_size(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *len) { - struct channel *chan = handle->shadow_chan; + struct channel *chan; + + if (!handle || !buf || !len) + return -EINVAL; + chan = handle->shadow_chan; *len = chan->backend.subbuf_size; return 0; } @@ -558,9 +839,13 @@ int ustctl_get_max_subbuf_size(struct lttng_ust_shm_handle *handle, int ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *off) { - struct channel *chan = handle->shadow_chan; + struct channel *chan; unsigned long sb_bindex; + if (!handle || !buf || !off) + return -EINVAL; + + chan = handle->shadow_chan; if (chan->backend.config.output != RING_BUFFER_MMAP) return -EINVAL; sb_bindex = subbuffer_id_get_index(&chan->backend.config, @@ -573,8 +858,12 @@ int ustctl_get_mmap_read_offset(struct lttng_ust_shm_handle *handle, int ustctl_get_subbuf_size(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *len) { - struct channel *chan = handle->shadow_chan; + struct channel *chan; + + if (!handle || !buf || !len) + return -EINVAL; + chan = handle->shadow_chan; *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf, handle); return 0; @@ -584,8 +873,12 @@ int ustctl_get_subbuf_size(struct lttng_ust_shm_handle *handle, int ustctl_get_padded_subbuf_size(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *len) { - struct channel *chan = handle->shadow_chan; + struct channel *chan; + + if (!handle || !buf || !len) + return -EINVAL; + chan = handle->shadow_chan; *len = lib_ring_buffer_get_read_data_size(&chan->backend.config, buf, handle); *len = PAGE_ALIGN(*len); @@ -596,6 +889,9 @@ int ustctl_get_padded_subbuf_size(struct lttng_ust_shm_handle *handle, int ustctl_get_next_subbuf(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + if (!handle || !buf) + return -EINVAL; + return lib_ring_buffer_get_next_subbuf(buf, handle); } @@ -604,6 +900,9 @@ int ustctl_get_next_subbuf(struct lttng_ust_shm_handle *handle, int ustctl_put_next_subbuf(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + if (!handle || !buf) + return -EINVAL; + lib_ring_buffer_put_next_subbuf(buf, handle); return 0; } @@ -614,6 +913,9 @@ int ustctl_put_next_subbuf(struct lttng_ust_shm_handle *handle, int ustctl_snapshot(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + if (!handle || !buf) + return -EINVAL; + return lib_ring_buffer_snapshot(buf, &buf->cons_snapshot, &buf->prod_snapshot, handle); } @@ -622,6 +924,9 @@ int ustctl_snapshot(struct lttng_ust_shm_handle *handle, int ustctl_snapshot_get_consumed(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos) { + if (!handle || !buf || !pos) + return -EINVAL; + *pos = buf->cons_snapshot; return 0; } @@ -630,6 +935,9 @@ int ustctl_snapshot_get_consumed(struct lttng_ust_shm_handle *handle, int ustctl_snapshot_get_produced(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos) { + if (!handle || !buf || !pos) + return -EINVAL; + *pos = buf->prod_snapshot; return 0; } @@ -638,6 +946,9 @@ int ustctl_snapshot_get_produced(struct lttng_ust_shm_handle *handle, int ustctl_get_subbuf(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, unsigned long *pos) { + if (!handle || !buf || !pos) + return -EINVAL; + return lib_ring_buffer_get_subbuf(buf, *pos, handle); } @@ -645,16 +956,19 @@ int ustctl_get_subbuf(struct lttng_ust_shm_handle *handle, int ustctl_put_subbuf(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf) { + if (!handle || !buf) + return -EINVAL; + lib_ring_buffer_put_subbuf(buf, handle); return 0; } -int ustctl_flush_buffer(struct lttng_ust_shm_handle *handle, +void ustctl_flush_buffer(struct lttng_ust_shm_handle *handle, struct lttng_ust_lib_ring_buffer *buf, int producer_active) { + assert(handle && buf); lib_ring_buffer_switch_slow(buf, producer_active ? SWITCH_ACTIVE : SWITCH_FLUSH, handle); - return 0; }