Fix: relayd control socket mutex is not destroyed
[lttng-tools.git] / src / common / dynamic-buffer.c
1 /*
2 * Copyright (C) 2017 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU Lesser General Public License, version 2.1 only,
6 * as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope that it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
11 * for more details.
12 *
13 * You should have received a copy of the GNU Lesser General Public License
14 * along with this program; if not, write to the Free Software Foundation,
15 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16 */
17
18 #include <common/dynamic-buffer.h>
19 #include <common/utils.h>
20 #include <assert.h>
21
22 /*
23 * Round to (upper) power of two, val is returned if it already is a power of
24 * two.
25 */
26 static
27 size_t round_to_power_of_2(size_t val)
28 {
29 int order;
30 size_t rounded;
31
32 order = utils_get_count_order_u64(val);
33 assert(order >= 0);
34 rounded = (1ULL << order);
35 assert(rounded >= val);
36
37 return rounded;
38 }
39
40 LTTNG_HIDDEN
41 void lttng_dynamic_buffer_init(struct lttng_dynamic_buffer *buffer)
42 {
43 assert(buffer);
44 memset(buffer, 0, sizeof(*buffer));
45 }
46
47 LTTNG_HIDDEN
48 int lttng_dynamic_buffer_append(struct lttng_dynamic_buffer *buffer,
49 const void *buf, size_t len)
50 {
51 int ret = 0;
52
53 if (!buffer || (!buf && len)) {
54 ret = -1;
55 goto end;
56 }
57
58 if (len == 0) {
59 /* Not an error, no-op. */
60 goto end;
61 }
62
63 assert(buffer->_capacity >= buffer->size);
64 if (buffer->_capacity < (len + buffer->size)) {
65 ret = lttng_dynamic_buffer_set_capacity(buffer,
66 buffer->_capacity +
67 (len - (buffer->_capacity - buffer->size)));
68 if (ret) {
69 goto end;
70 }
71 }
72
73 memcpy(buffer->data + buffer->size, buf, len);
74 buffer->size += len;
75 end:
76 return ret;
77 }
78
79 LTTNG_HIDDEN
80 int lttng_dynamic_buffer_append_buffer(struct lttng_dynamic_buffer *dst_buffer,
81 struct lttng_dynamic_buffer *src_buffer)
82 {
83 int ret;
84
85 if (!dst_buffer || !src_buffer) {
86 ret = -1;
87 goto end;
88 }
89
90 ret = lttng_dynamic_buffer_append(dst_buffer, src_buffer->data,
91 src_buffer->size);
92 end:
93 return ret;
94 }
95
96 LTTNG_HIDDEN
97 int lttng_dynamic_buffer_set_size(struct lttng_dynamic_buffer *buffer,
98 size_t new_size)
99 {
100 int ret = 0;
101
102 if (!buffer) {
103 goto end;
104 }
105
106 if (new_size == buffer->size) {
107 goto end;
108 }
109
110 if (new_size > buffer->_capacity) {
111 ret = lttng_dynamic_buffer_set_capacity(buffer, new_size);
112 if (ret) {
113 goto end;
114 }
115
116 memset(buffer->data + buffer->size, 0, new_size - buffer->size);
117 } else if (new_size > buffer->size) {
118 memset(buffer->data + buffer->size, 0, new_size - buffer->size);
119 } else {
120 /*
121 * Shrinking size. There is no need to zero-out the newly
122 * released memory as it will either be:
123 * - overwritten by lttng_dynamic_buffer_append,
124 * - expanded later, which will zero-out the memory
125 *
126 * Users of external APIs are encouraged to set the buffer's
127 * size _before_ making such calls.
128 */
129 }
130 buffer->size = new_size;
131 end:
132 return ret;
133 }
134
135 LTTNG_HIDDEN
136 int lttng_dynamic_buffer_set_capacity(struct lttng_dynamic_buffer *buffer,
137 size_t demanded_capacity)
138 {
139 int ret = 0;
140 void *new_buf;
141 size_t new_capacity = demanded_capacity ?
142 round_to_power_of_2(demanded_capacity) : 0;
143
144 if (!buffer || demanded_capacity < buffer->size) {
145 /*
146 * Shrinking a buffer's size by changing its capacity is
147 * unsupported.
148 */
149 ret = -1;
150 goto end;
151 }
152
153 if (new_capacity == buffer->_capacity) {
154 goto end;
155 }
156
157 /* Memory is initialized by the size increases. */
158 new_buf = realloc(buffer->data, new_capacity);
159 if (!new_buf) {
160 ret = -1;
161 goto end;
162 }
163 buffer->data = new_buf;
164 buffer->_capacity = new_capacity;
165 end:
166 return ret;
167 }
168
169 /* Release any memory used by the dynamic buffer. */
170 LTTNG_HIDDEN
171 void lttng_dynamic_buffer_reset(struct lttng_dynamic_buffer *buffer)
172 {
173 if (!buffer) {
174 return;
175 }
176 buffer->size = 0;
177 buffer->_capacity = 0;
178 free(buffer->data);
179 }
180
181 LTTNG_HIDDEN
182 size_t lttng_dynamic_buffer_get_capacity_left(
183 struct lttng_dynamic_buffer *buffer)
184 {
185 if (!buffer) {
186 return 0;
187 }
188 return buffer->_capacity - buffer->size;
189 }
This page took 0.034478 seconds and 4 git commands to generate.