X-Git-Url: http://git.efficios.com/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Fdynamic-buffer.c;h=4e87c58ac1b43778cee695bbe2f78596b99d3f8d;hp=f34ae8c492d6bba76818c7e47c004c6f72894bff;hb=427d84693052f551da11a175d9a0f74bb6e169b3;hpb=830630679a7fb4bc9b3c7679b5168ee6c03104f1 diff --git a/src/common/dynamic-buffer.c b/src/common/dynamic-buffer.c index f34ae8c49..4e87c58ac 100644 --- a/src/common/dynamic-buffer.c +++ b/src/common/dynamic-buffer.c @@ -1,32 +1,25 @@ /* - * Copyright (C) 2017 - Jérémie Galarneau + * Copyright (C) 2017 Jérémie Galarneau * - * This program is free software; you can redistribute it and/or modify it - * under the terms of the GNU Lesser General Public License, version 2.1 only, - * as published by the Free Software Foundation. + * SPDX-License-Identifier: LGPL-2.1-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 Lesser General Public License - * for more details. - * - * You should have received a copy of the GNU Lesser 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 */ #include -#include +#include #include #include +/* + * Round to (upper) power of two, val is returned if it already is a power of + * two. + */ static size_t round_to_power_of_2(size_t val) { - int order; size_t rounded; + const int order = utils_get_count_order_u64(val); - order = utils_get_count_order_u64(val); assert(order >= 0); rounded = (1ULL << order); assert(rounded >= val); @@ -34,12 +27,14 @@ size_t round_to_power_of_2(size_t val) return rounded; } +LTTNG_HIDDEN void lttng_dynamic_buffer_init(struct lttng_dynamic_buffer *buffer) { assert(buffer); memset(buffer, 0, sizeof(*buffer)); } +LTTNG_HIDDEN int lttng_dynamic_buffer_append(struct lttng_dynamic_buffer *buffer, const void *buf, size_t len) { @@ -55,10 +50,11 @@ int lttng_dynamic_buffer_append(struct lttng_dynamic_buffer *buffer, goto end; } - if (buffer->capacity < (len + buffer->size)) { + assert(buffer->_capacity >= buffer->size); + if (buffer->_capacity < (len + buffer->size)) { ret = lttng_dynamic_buffer_set_capacity(buffer, - buffer->capacity + - (len - (buffer->capacity - buffer->size))); + buffer->_capacity + + (len - (buffer->_capacity - buffer->size))); if (ret) { goto end; } @@ -70,8 +66,9 @@ end: return ret; } +LTTNG_HIDDEN int lttng_dynamic_buffer_append_buffer(struct lttng_dynamic_buffer *dst_buffer, - struct lttng_dynamic_buffer *src_buffer) + const struct lttng_dynamic_buffer *src_buffer) { int ret; @@ -86,6 +83,24 @@ end: return ret; } +LTTNG_HIDDEN +int lttng_dynamic_buffer_append_view(struct lttng_dynamic_buffer *buffer, + const struct lttng_buffer_view *src) +{ + int ret; + + if (!buffer || !src) { + ret = -1; + goto end; + } + + ret = lttng_dynamic_buffer_append(buffer, src->data, + src->size); +end: + return ret; +} + +LTTNG_HIDDEN int lttng_dynamic_buffer_set_size(struct lttng_dynamic_buffer *buffer, size_t new_size) { @@ -99,11 +114,13 @@ int lttng_dynamic_buffer_set_size(struct lttng_dynamic_buffer *buffer, goto end; } - if (new_size > buffer->capacity) { + if (new_size > buffer->_capacity) { ret = lttng_dynamic_buffer_set_capacity(buffer, new_size); if (ret) { goto end; } + + memset(buffer->data + buffer->size, 0, new_size - buffer->size); } else if (new_size > buffer->size) { memset(buffer->data + buffer->size, 0, new_size - buffer->size); } else { @@ -117,65 +134,68 @@ int lttng_dynamic_buffer_set_size(struct lttng_dynamic_buffer *buffer, * size _before_ making such calls. */ } + buffer->size = new_size; end: return ret; } +LTTNG_HIDDEN int lttng_dynamic_buffer_set_capacity(struct lttng_dynamic_buffer *buffer, - size_t new_capacity) + size_t demanded_capacity) { int ret = 0; - size_t rounded_capacity = round_to_power_of_2(new_capacity); + void *new_buf; + size_t new_capacity = demanded_capacity ? + round_to_power_of_2(demanded_capacity) : 0; - if (!buffer || new_capacity < buffer->size) { + if (!buffer || demanded_capacity < buffer->size) { + /* + * Shrinking a buffer's size by changing its capacity is + * unsupported. + */ ret = -1; goto end; } - if (rounded_capacity == buffer->capacity) { + if (new_capacity == buffer->_capacity) { goto end; } - if (!buffer->data) { - buffer->data = zmalloc(rounded_capacity); - if (!buffer->data) { - ret = -1; - goto end; - } - } else { - void *new_buf; - - new_buf = realloc(buffer->data, rounded_capacity); - if (new_buf) { - if (rounded_capacity > buffer->capacity) { - memset(new_buf + buffer->capacity, 0, - rounded_capacity - buffer->capacity); - } - } else { - /* Realloc failed, try to acquire a new block. */ - new_buf = zmalloc(rounded_capacity); - if (!new_buf) { - ret = -1; - goto end; - } - memcpy(new_buf, buffer->data, buffer->size); - free(buffer->data); - } - buffer->data = new_buf; + /* Memory is initialized by the size increases. */ + new_buf = realloc(buffer->data, new_capacity); + if (!new_buf) { + ret = -1; + goto end; } - buffer->capacity = rounded_capacity; + + buffer->data = new_buf; + buffer->_capacity = new_capacity; end: return ret; } /* Release any memory used by the dynamic buffer. */ +LTTNG_HIDDEN void lttng_dynamic_buffer_reset(struct lttng_dynamic_buffer *buffer) { if (!buffer) { return; } + buffer->size = 0; - buffer->capacity = 0; + buffer->_capacity = 0; free(buffer->data); + buffer->data = NULL; +} + +LTTNG_HIDDEN +size_t lttng_dynamic_buffer_get_capacity_left( + struct lttng_dynamic_buffer *buffer) +{ + if (!buffer) { + return 0; + } + + return buffer->_capacity - buffer->size; }