kvm: x86: Rework identity map and TSS setup for larger BIOS sizes
[qemu.git] / cutils.c
blob7984bc1ca4baea8494a15541d0ed37f19547eb97
1 /*
2 * Simple C functions to supplement the C library
4 * Copyright (c) 2006 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include "qemu-common.h"
25 #include "host-utils.h"
26 #include <math.h>
28 void pstrcpy(char *buf, int buf_size, const char *str)
30 int c;
31 char *q = buf;
33 if (buf_size <= 0)
34 return;
36 for(;;) {
37 c = *str++;
38 if (c == 0 || q >= buf + buf_size - 1)
39 break;
40 *q++ = c;
42 *q = '\0';
45 /* strcat and truncate. */
46 char *pstrcat(char *buf, int buf_size, const char *s)
48 int len;
49 len = strlen(buf);
50 if (len < buf_size)
51 pstrcpy(buf + len, buf_size - len, s);
52 return buf;
55 int strstart(const char *str, const char *val, const char **ptr)
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++;
66 if (ptr)
67 *ptr = p;
68 return 1;
71 int stristart(const char *str, const char *val, const char **ptr)
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++;
82 if (ptr)
83 *ptr = p;
84 return 1;
87 /* XXX: use host strnlen if available ? */
88 int qemu_strnlen(const char *s, int max_len)
90 int i;
92 for(i = 0; i < max_len; i++) {
93 if (s[i] == '\0') {
94 break;
97 return i;
100 time_t mktimegm(struct tm *tm)
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--;
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;
114 int qemu_fls(int i)
116 return 32 - clz32(i);
120 * Make sure data goes on disk, but if possible do not bother to
121 * write out the inode just for timestamp updates.
123 * Unfortunately even in 2009 many operating systems do not support
124 * fdatasync and have to fall back to fsync.
126 int qemu_fdatasync(int fd)
128 #ifdef CONFIG_FDATASYNC
129 return fdatasync(fd);
130 #else
131 return fsync(fd);
132 #endif
135 /* io vectors */
137 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint)
139 qiov->iov = qemu_malloc(alloc_hint * sizeof(struct iovec));
140 qiov->niov = 0;
141 qiov->nalloc = alloc_hint;
142 qiov->size = 0;
145 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov)
147 int i;
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;
157 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len)
159 assert(qiov->nalloc != -1);
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));
165 qiov->iov[qiov->niov].iov_base = base;
166 qiov->iov[qiov->niov].iov_len = len;
167 qiov->size += len;
168 ++qiov->niov;
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.
178 void qemu_iovec_copy(QEMUIOVector *dst, QEMUIOVector *src, uint64_t skip,
179 size_t size)
181 int i;
182 size_t done;
183 void *iov_base;
184 uint64_t iov_len;
186 assert(dst->nalloc != -1);
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;
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);
207 done += iov_len;
211 void qemu_iovec_concat(QEMUIOVector *dst, QEMUIOVector *src, size_t size)
213 qemu_iovec_copy(dst, src, 0, size);
216 void qemu_iovec_destroy(QEMUIOVector *qiov)
218 assert(qiov->nalloc != -1);
220 qemu_free(qiov->iov);
223 void qemu_iovec_reset(QEMUIOVector *qiov)
225 assert(qiov->nalloc != -1);
227 qiov->niov = 0;
228 qiov->size = 0;
231 void qemu_iovec_to_buffer(QEMUIOVector *qiov, void *buf)
233 uint8_t *p = (uint8_t *)buf;
234 int i;
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;
242 void qemu_iovec_from_buffer(QEMUIOVector *qiov, const void *buf, size_t count)
244 const uint8_t *p = (const uint8_t *)buf;
245 size_t copy;
246 int i;
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;
258 void qemu_iovec_memset(QEMUIOVector *qiov, int c, size_t count)
260 size_t n;
261 int i;
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;
270 #ifndef _WIN32
271 /* Sets a specific flag */
272 int fcntl_setfl(int fd, int flag)
274 int flags;
276 flags = fcntl(fd, F_GETFL);
277 if (flags == -1)
278 return -errno;
280 if (fcntl(fd, F_SETFL, flags | flag) == -1)
281 return -errno;
283 return 0;
285 #endif
288 * Convert string to bytes, allowing either B/b for bytes, K/k for KB,
289 * M/m for MB, G/g for GB or T/t for TB. Default without any postfix
290 * is MB. End pointer will be returned in *end, if not NULL. A valid
291 * value must be terminated by whitespace, ',' or '\0'. Return -1 on
292 * error.
294 ssize_t strtosz_suffix(const char *nptr, char **end, const char default_suffix)
296 ssize_t retval = -1;
297 char *endptr, c, d;
298 int mul_required = 0;
299 double val, mul, integral, fraction;
301 errno = 0;
302 val = strtod(nptr, &endptr);
303 if (isnan(val) || endptr == nptr || errno != 0) {
304 goto fail;
306 integral = modf(val, &fraction);
307 if (integral != 0) {
308 mul_required = 1;
311 * Any whitespace character is fine for terminating the number,
312 * in addition we accept ',' to handle strings where the size is
313 * part of a multi token argument.
315 c = *endptr;
316 d = c;
317 if (isspace(c) || c == '\0' || c == ',') {
318 c = 0;
319 if (default_suffix) {
320 d = default_suffix;
321 } else {
322 d = c;
325 switch (d) {
326 case 'B':
327 case 'b':
328 mul = 1;
329 if (mul_required) {
330 goto fail;
332 break;
333 case 'K':
334 case 'k':
335 mul = 1 << 10;
336 break;
337 case 0:
338 if (mul_required) {
339 goto fail;
341 case 'M':
342 case 'm':
343 mul = 1ULL << 20;
344 break;
345 case 'G':
346 case 'g':
347 mul = 1ULL << 30;
348 break;
349 case 'T':
350 case 't':
351 mul = 1ULL << 40;
352 break;
353 default:
354 goto fail;
357 * If not terminated by whitespace, ',', or \0, increment endptr
358 * to point to next character, then check that we are terminated
359 * by an appropriate separating character, ie. whitespace, ',', or
360 * \0. If not, we are seeing trailing garbage, thus fail.
362 if (c != 0) {
363 endptr++;
364 if (!isspace(*endptr) && *endptr != ',' && *endptr != 0) {
365 goto fail;
368 if ((val * mul >= ~(size_t)0) || val < 0) {
369 goto fail;
371 retval = val * mul;
373 fail:
374 if (end) {
375 *end = endptr;
378 return retval;
381 ssize_t strtosz(const char *nptr, char **end)
383 return strtosz_suffix(nptr, end, STRTOSZ_DEFSUFFIX_MB);