1 /*
2 * Simple C functions to supplement the C library
3 *
4 * Copyright (c) 2006 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "qemu-common.h"
25 #include "host-utils.h"
26 #include <math.h>
27
pstrcpy(char * buf,int buf_size,const char * str)28 void pstrcpy(char *buf, int buf_size, const char *str)
29 {
30 int c;
31 char *q = buf;
32
33 if (buf_size <= 0)
34 return;
35
36 for(;;) {
37 c = *str++;
38 if (c == 0 || q >= buf + buf_size - 1)
39 break;
40 *q++ = c;
41 }
42 *q = '\0';
43 }
44
45 /* strcat and truncate. */
pstrcat(char * buf,int buf_size,const char * s)46 char *pstrcat(char *buf, int buf_size, const char *s)
47 {
48 int len;
49 len = strlen(buf);
50 if (len < buf_size)
51 pstrcpy(buf + len, buf_size - len, s);
52 return buf;
53 }
54
strstart(const char * str,const char * val,const char ** ptr)55 int strstart(const char *str, const char *val, const char **ptr)
56 {
57 const char *p, *q;
58 p = str;
59 q = val;
60 while (*q != '\0') {
61 if (*p != *q)
62 return 0;
63 p++;
64 q++;
65 }
66 if (ptr)
67 *ptr = p;
68 return 1;
69 }
70
stristart(const char * str,const char * val,const char ** ptr)71 int stristart(const char *str, const char *val, const char **ptr)
72 {
73 const char *p, *q;
74 p = str;
75 q = val;
76 while (*q != '\0') {
77 if (qemu_toupper(*p) != qemu_toupper(*q))
78 return 0;
79 p++;
80 q++;
81 }
82 if (ptr)
83 *ptr = p;
84 return 1;
85 }
86
87 /* XXX: use host strnlen if available ? */
qemu_strnlen(const char * s,int max_len)88 int qemu_strnlen(const char *s, int max_len)
89 {
90 int i;
91
92 for(i = 0; i < max_len; i++) {
93 if (s[i] == '\0') {
94 break;
95 }
96 }
97 return i;
98 }
99
mktimegm(struct tm * tm)100 time_t mktimegm(struct tm *tm)
101 {
102 time_t t;
103 int y = tm->tm_year + 1900, m = tm->tm_mon + 1, d = tm->tm_mday;
104 if (m < 3) {
105 m += 12;
106 y--;
107 }
108 t = 86400 * (d + (153 * m - 457) / 5 + 365 * y + y / 4 - y / 100 +
109 y / 400 - 719469);
110 t += 3600 * tm->tm_hour + 60 * tm->tm_min + tm->tm_sec;
111 return t;
112 }
113
qemu_fls(int i)114 int qemu_fls(int i)
115 {
116 return 32 - clz32(i);
117 }
118
119 /*
120 * Make sure data goes on disk, but if possible do not bother to
121 * write out the inode just for timestamp updates.
122 *
123 * Unfortunately even in 2009 many operating systems do not support
124 * fdatasync and have to fall back to fsync.
125 */
qemu_fdatasync(int fd)126 int qemu_fdatasync(int fd)
127 {
128 #ifdef CONFIG_FDATASYNC
129 return fdatasync(fd);
130 #else
131 return fsync(fd);
132 #endif
133 }
134
135 /* io vectors */
136
qemu_iovec_init(QEMUIOVector * qiov,int alloc_hint)137 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
138 {
139 qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
140 qiov->niov = 0;
141 qiov->nalloc = alloc_hint;
142 qiov->size = 0;
143 }
144
qemu_iovec_init_external(QEMUIOVector * qiov,struct iovec * iov,int niov)145 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
146 {
147 int i;
148
149 qiov->iov = iov;
150 qiov->niov = niov;
151 qiov->nalloc = -1;
152 qiov->size = 0;
153 for (i = 0; i < niov; i++)
154 qiov->size += iov[i].iov_len;
155 }
156
qemu_iovec_add(QEMUIOVector * qiov,void * base,size_t len)157 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
158 {
159 assert(qiov->nalloc != -1);
160
161 if (qiov->niov == qiov->nalloc) {
162 qiov->nalloc = 2 * qiov->nalloc + 1;
163 qiov->iov = qemu_realloc(qiov->iov, qiov->nalloc * sizeof(struct iovec));
164 }
165 qiov->iov[qiov->niov].iov_base = base;
166 qiov->iov[qiov->niov].iov_len = len;
167 qiov->size += len;
168 ++qiov->niov;
169 }
170
171 /*
172 * Copies iovecs from src to the end of dst. It starts copying after skipping
173 * the given number of bytes in src and copies until src is completely copied
174 * or the total size of the copied iovec reaches size.The size of the last
175 * copied iovec is changed in order to fit the specified total size if it isn't
176 * a perfect fit already.
177 */
qemu_iovec_copy(QEMUIOVector * dst,QEMUIOVector * src,uint64_t skip,size_t size)178 void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
179 size_t size)
180 {
181 int i;
182 size_t done;
183 void *iov_base;
184 uint64_t iov_len;
185
186 assert(dst->nalloc != -1);
187
188 done = 0;
189 for (i = 0; (i < src->niov) && (done != size); i++) {
190 if (skip >= src->iov[i].iov_len) {
191 /* Skip the whole iov */
192 skip -= src->iov[i].iov_len;
193 continue;
194 } else {
195 /* Skip only part (or nothing) of the iov */
196 iov_base = (uint8_t*) src->iov[i].iov_base + skip;
197 iov_len = src->iov[i].iov_len - skip;
198 skip = 0;
199 }
200
201 if (done + iov_len > size) {
202 qemu_iovec_add(dst, iov_base, size - done);
203 break;
204 } else {
205 qemu_iovec_add(dst, iov_base, iov_len);
206 }
207 done += iov_len;
208 }
209 }
210
qemu_iovec_concat(QEMUIOVector * dst,QEMUIOVector * src,size_t size)211 void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size)
212 {
213 qemu_iovec_copy(dst, src, 0, size);
214 }
215
qemu_iovec_destroy(QEMUIOVector * qiov)216 void qemu_iovec_destroy(QEMUIOVector *qiov)
217 {
218 assert(qiov->nalloc != -1);
219
220 qemu_free(qiov->iov);
221 }
222
qemu_iovec_reset(QEMUIOVector * qiov)223 void qemu_iovec_reset(QEMUIOVector *qiov)
224 {
225 assert(qiov->nalloc != -1);
226
227 qiov->niov = 0;
228 qiov->size = 0;
229 }
230
qemu_iovec_to_buffer(QEMUIOVector * qiov,void * buf)231 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
232 {
233 uint8_t *p = (uint8_t *)buf;
234 int i;
235
236 for (i = 0; i < qiov->niov; ++i) {
237 memcpy(p, qiov->iov[i].iov_base, qiov->iov[i].iov_len);
238 p += qiov->iov[i].iov_len;
239 }
240 }
241
qemu_iovec_from_buffer(QEMUIOVector * qiov,const void * buf,size_t count)242 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
243 {
244 const uint8_t *p = (const uint8_t *)buf;
245 size_t copy;
246 int i;
247
248 for (i = 0; i < qiov->niov && count; ++i) {
249 copy = count;
250 if (copy > qiov->iov[i].iov_len)
251 copy = qiov->iov[i].iov_len;
252 memcpy(qiov->iov[i].iov_base, p, copy);
253 p += copy;
254 count -= copy;
255 }
256 }
257
qemu_iovec_memset(QEMUIOVector * qiov,int c,size_t count)258 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count)
259 {
260 size_t n;
261 int i;
262
263 for (i = 0; i < qiov->niov && count; ++i) {
264 n = MIN(count, qiov->iov[i].iov_len);
265 memset(qiov->iov[i].iov_base, c, n);
266 count -= n;
267 }
268 }
269
qemu_iovec_memset_skip(QEMUIOVector * qiov,int c,size_t count,size_t skip)270 void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
271 size_t skip)
272 {
273 int i;
274 size_t done;
275 void *iov_base;
276 uint64_t iov_len;
277
278 done = 0;
279 for (i = 0; (i < qiov->niov) && (done != count); i++) {
280 if (skip >= qiov->iov[i].iov_len) {
281 /* Skip the whole iov */
282 skip -= qiov->iov[i].iov_len;
283 continue;
284 } else {
285 /* Skip only part (or nothing) of the iov */
286 iov_base = (uint8_t*) qiov->iov[i].iov_base + skip;
287 iov_len = qiov->iov[i].iov_len - skip;
288 skip = 0;
289 }
290
291 if (done + iov_len > count) {
292 memset(iov_base, c, count - done);
293 break;
294 } else {
295 memset(iov_base, c, iov_len);
296 }
297 done += iov_len;
298 }
299 }
300
301 #ifndef _WIN32
302 /* Sets a specific flag */
fcntl_setfl(int fd,int flag)303 int fcntl_setfl(int fd, int flag)
304 {
305 int flags;
306
307 flags = fcntl(fd, F_GETFL);
308 if (flags == -1)
309 return -errno;
310
311 if (fcntl(fd, F_SETFL, flags | flag) == -1)
312 return -errno;
313
314 return 0;
315 }
316 #endif
317
318 /*
319 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
320 * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
321 * is MB. End pointer will be returned in *end, if not NULL. A valid
322 * value must be terminated by whitespace, ',' or '\0'. Return -1 on
323 * error.
324 */
strtosz_suffix(const char * nptr,char ** end,const char default_suffix)325 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
326 {
327 int64_t retval = -1;
328 char *endptr;
329 unsigned char c, d;
330 int mul_required = 0;
331 double val, mul, integral, fraction;
332
333 errno = 0;
334 val = strtod(nptr, &endptr);
335 if (isnan(val) || endptr == nptr || errno != 0) {
336 goto fail;
337 }
338 fraction = modf(val, &integral);
339 if (fraction != 0) {
340 mul_required = 1;
341 }
342 /*
343 * Any whitespace character is fine for terminating the number,
344 * in addition we accept ',' to handle strings where the size is
345 * part of a multi token argument.
346 */
347 c = *endptr;
348 d = c;
349 if (qemu_isspace(c) || c == '\0' || c == ',') {
350 c = 0;
351 if (default_suffix) {
352 d = default_suffix;
353 } else {
354 d = c;
355 }
356 }
357 switch (qemu_toupper(d)) {
358 case STRTOSZ_DEFSUFFIX_B:
359 mul = 1;
360 if (mul_required) {
361 goto fail;
362 }
363 break;
364 case STRTOSZ_DEFSUFFIX_KB:
365 mul = 1 << 10;
366 break;
367 case 0:
368 if (mul_required) {
369 goto fail;
370 }
371 case STRTOSZ_DEFSUFFIX_MB:
372 mul = 1ULL << 20;
373 break;
374 case STRTOSZ_DEFSUFFIX_GB:
375 mul = 1ULL << 30;
376 break;
377 case STRTOSZ_DEFSUFFIX_TB:
378 mul = 1ULL << 40;
379 break;
380 default:
381 goto fail;
382 }
383 /*
384 * If not terminated by whitespace, ',', or \0, increment endptr
385 * to point to next character, then check that we are terminated
386 * by an appropriate separating character, ie. whitespace, ',', or
387 * \0. If not, we are seeing trailing garbage, thus fail.
388 */
389 if (c != 0) {
390 endptr++;
391 if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) {
392 goto fail;
393 }
394 }
395 if ((val * mul >= INT64_MAX) || val < 0) {
396 goto fail;
397 }
398 retval = val * mul;
399
400 fail:
401 if (end) {
402 *end = endptr;
403 }
404
405 return retval;
406 }
407
strtosz(const char * nptr,char ** end)408 int64_t strtosz(const char *nptr, char **end)
409 {
410 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
411 }
412