xref: /illumos-kvm-cmd/cutils.c (revision 68396ea9)
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 
242 /*
243  * No dma flushing needed here, as the aio code will call dma_bdrv_cb()
244  * on completion as well, which will result in a call to
245  * dma_bdrv_unmap() which will do the flushing ....
246  */
qemu_iovec_from_buffer(QEMUIOVector * qiov,const void * buf,size_t count)247 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
248 {
249     const uint8_t *p = (const uint8_t *)buf;
250     size_t copy;
251     int i;
252 
253     for (i = 0; i < qiov->niov && count; ++i) {
254         copy = count;
255         if (copy > qiov->iov[i].iov_len)
256             copy = qiov->iov[i].iov_len;
257         memcpy(qiov->iov[i].iov_base, p, copy);
258         p     += copy;
259         count -= copy;
260     }
261 }
262 
qemu_iovec_memset(QEMUIOVector * qiov,int c,size_t count)263 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count)
264 {
265     size_t n;
266     int i;
267 
268     for (i = 0; i < qiov->niov && count; ++i) {
269         n = MIN(count, qiov->iov[i].iov_len);
270         memset(qiov->iov[i].iov_base, c, n);
271         count -= n;
272     }
273 }
274 
qemu_iovec_memset_skip(QEMUIOVector * qiov,int c,size_t count,size_t skip)275 void qemu_iovec_memset_skip(QEMUIOVector *qiov, int c, size_t count,
276                             size_t skip)
277 {
278     int i;
279     size_t done;
280     void *iov_base;
281     uint64_t iov_len;
282 
283     done = 0;
284     for (i = 0; (i < qiov->niov) && (done != count); i++) {
285         if (skip >= qiov->iov[i].iov_len) {
286             /* Skip the whole iov */
287             skip -= qiov->iov[i].iov_len;
288             continue;
289         } else {
290             /* Skip only part (or nothing) of the iov */
291             iov_base = (uint8_t*) qiov->iov[i].iov_base + skip;
292             iov_len = qiov->iov[i].iov_len - skip;
293             skip = 0;
294         }
295 
296         if (done + iov_len > count) {
297             memset(iov_base, c, count - done);
298             break;
299         } else {
300             memset(iov_base, c, iov_len);
301         }
302         done += iov_len;
303     }
304 }
305 
306 #ifndef _WIN32
307 /* Sets a specific flag */
fcntl_setfl(int fd,int flag)308 int fcntl_setfl(int fd, int flag)
309 {
310     int flags;
311 
312     flags = fcntl(fd, F_GETFL);
313     if (flags == -1)
314         return -errno;
315 
316     if (fcntl(fd, F_SETFL, flags | flag) == -1)
317         return -errno;
318 
319     return 0;
320 }
321 #endif
322 
323 /*
324  * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
325  * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
326  * is MB. End pointer will be returned in *end, if not NULL. A valid
327  * value must be terminated by whitespace, ',' or '\0'. Return -1 on
328  * error.
329  */
strtosz_suffix(const char * nptr,char ** end,const char default_suffix)330 int64_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
331 {
332     int64_t retval = -1;
333     char *endptr;
334     unsigned char c, d;
335     int mul_required = 0;
336     double val, mul, integral, fraction;
337 
338     errno = 0;
339     val = strtod(nptr, &endptr);
340     if (isnan(val) || endptr == nptr || errno != 0) {
341         goto fail;
342     }
343     fraction = modf(val, &integral);
344     if (fraction != 0) {
345         mul_required = 1;
346     }
347     /*
348      * Any whitespace character is fine for terminating the number,
349      * in addition we accept ',' to handle strings where the size is
350      * part of a multi token argument.
351      */
352     c = *endptr;
353     d = c;
354     if (qemu_isspace(c) || c == '\0' || c == ',') {
355         c = 0;
356         if (default_suffix) {
357             d = default_suffix;
358         } else {
359             d = c;
360         }
361     }
362     switch (qemu_toupper(d)) {
363     case STRTOSZ_DEFSUFFIX_B:
364         mul = 1;
365         if (mul_required) {
366             goto fail;
367         }
368         break;
369     case STRTOSZ_DEFSUFFIX_KB:
370         mul = 1 << 10;
371         break;
372     case 0:
373         if (mul_required) {
374             goto fail;
375         }
376     case STRTOSZ_DEFSUFFIX_MB:
377         mul = 1ULL << 20;
378         break;
379     case STRTOSZ_DEFSUFFIX_GB:
380         mul = 1ULL << 30;
381         break;
382     case STRTOSZ_DEFSUFFIX_TB:
383         mul = 1ULL << 40;
384         break;
385     default:
386         goto fail;
387     }
388     /*
389      * If not terminated by whitespace, ',', or \0, increment endptr
390      * to point to next character, then check that we are terminated
391      * by an appropriate separating character, ie. whitespace, ',', or
392      * \0. If not, we are seeing trailing garbage, thus fail.
393      */
394     if (c != 0) {
395         endptr++;
396         if (!qemu_isspace(*endptr) && *endptr != ',' && *endptr != 0) {
397             goto fail;
398         }
399     }
400     if ((val * mul >= INT64_MAX) || val < 0) {
401         goto fail;
402     }
403     retval = val * mul;
404 
405 fail:
406     if (end) {
407         *end = endptr;
408     }
409 
410     return retval;
411 }
412 
strtosz(const char * nptr,char ** end)413 int64_t strtosz(const char *nptr, char **end)
414 {
415     return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);
416 }
417