mips: Ensure PC update with MTC0 single-stepping
[qemu.git] / util / osdep.c
1 /*
2 * QEMU low level functions
3 *
4 * Copyright (c) 2003 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 <stdlib.h>
25 #include <stdio.h>
26 #include <stdarg.h>
27 #include <stdbool.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32
33 /* Needed early for CONFIG_BSD etc. */
34 #include "config-host.h"
35
36 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
37 #include <sys/mman.h>
38 #endif
39
40 #ifdef CONFIG_SOLARIS
41 #include <sys/types.h>
42 #include <sys/statvfs.h>
43 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
44 discussion about Solaris header problems */
45 extern int madvise(caddr_t, size_t, int);
46 #endif
47
48 #include "qemu-common.h"
49 #include "qemu/sockets.h"
50 #include "monitor/monitor.h"
51
52 static bool fips_enabled = false;
53
54 static const char *qemu_version = QEMU_VERSION;
55
56 int socket_set_cork(int fd, int v)
57 {
58 #if defined(SOL_TCP) && defined(TCP_CORK)
59 return qemu_setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
60 #else
61 return 0;
62 #endif
63 }
64
65 int socket_set_nodelay(int fd)
66 {
67 int v = 1;
68 return qemu_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &v, sizeof(v));
69 }
70
71 int qemu_madvise(void *addr, size_t len, int advice)
72 {
73 if (advice == QEMU_MADV_INVALID) {
74 errno = EINVAL;
75 return -1;
76 }
77 #if defined(CONFIG_MADVISE)
78 return madvise(addr, len, advice);
79 #elif defined(CONFIG_POSIX_MADVISE)
80 return posix_madvise(addr, len, advice);
81 #else
82 errno = EINVAL;
83 return -1;
84 #endif
85 }
86
87 #ifndef _WIN32
88 /*
89 * Dups an fd and sets the flags
90 */
91 static int qemu_dup_flags(int fd, int flags)
92 {
93 int ret;
94 int serrno;
95 int dup_flags;
96
97 #ifdef F_DUPFD_CLOEXEC
98 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0);
99 #else
100 ret = dup(fd);
101 if (ret != -1) {
102 qemu_set_cloexec(ret);
103 }
104 #endif
105 if (ret == -1) {
106 goto fail;
107 }
108
109 dup_flags = fcntl(ret, F_GETFL);
110 if (dup_flags == -1) {
111 goto fail;
112 }
113
114 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) {
115 errno = EINVAL;
116 goto fail;
117 }
118
119 /* Set/unset flags that we can with fcntl */
120 if (fcntl(ret, F_SETFL, flags) == -1) {
121 goto fail;
122 }
123
124 /* Truncate the file in the cases that open() would truncate it */
125 if (flags & O_TRUNC ||
126 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) {
127 if (ftruncate(ret, 0) == -1) {
128 goto fail;
129 }
130 }
131
132 return ret;
133
134 fail:
135 serrno = errno;
136 if (ret != -1) {
137 close(ret);
138 }
139 errno = serrno;
140 return -1;
141 }
142
143 static int qemu_parse_fdset(const char *param)
144 {
145 return qemu_parse_fd(param);
146 }
147 #endif
148
149 /*
150 * Opens a file with FD_CLOEXEC set
151 */
152 int qemu_open(const char *name, int flags, ...)
153 {
154 int ret;
155 int mode = 0;
156
157 #ifndef _WIN32
158 const char *fdset_id_str;
159
160 /* Attempt dup of fd from fd set */
161 if (strstart(name, "/dev/fdset/", &fdset_id_str)) {
162 int64_t fdset_id;
163 int fd, dupfd;
164
165 fdset_id = qemu_parse_fdset(fdset_id_str);
166 if (fdset_id == -1) {
167 errno = EINVAL;
168 return -1;
169 }
170
171 fd = monitor_fdset_get_fd(fdset_id, flags);
172 if (fd == -1) {
173 return -1;
174 }
175
176 dupfd = qemu_dup_flags(fd, flags);
177 if (dupfd == -1) {
178 return -1;
179 }
180
181 ret = monitor_fdset_dup_fd_add(fdset_id, dupfd);
182 if (ret == -1) {
183 close(dupfd);
184 errno = EINVAL;
185 return -1;
186 }
187
188 return dupfd;
189 }
190 #endif
191
192 if (flags & O_CREAT) {
193 va_list ap;
194
195 va_start(ap, flags);
196 mode = va_arg(ap, int);
197 va_end(ap);
198 }
199
200 #ifdef O_CLOEXEC
201 ret = open(name, flags | O_CLOEXEC, mode);
202 #else
203 ret = open(name, flags, mode);
204 if (ret >= 0) {
205 qemu_set_cloexec(ret);
206 }
207 #endif
208
209 #ifdef O_DIRECT
210 if (ret == -1 && errno == EINVAL && (flags & O_DIRECT)) {
211 error_report("file system may not support O_DIRECT");
212 errno = EINVAL; /* in case it was clobbered */
213 }
214 #endif /* O_DIRECT */
215
216 return ret;
217 }
218
219 int qemu_close(int fd)
220 {
221 int64_t fdset_id;
222
223 /* Close fd that was dup'd from an fdset */
224 fdset_id = monitor_fdset_dup_fd_find(fd);
225 if (fdset_id != -1) {
226 int ret;
227
228 ret = close(fd);
229 if (ret == 0) {
230 monitor_fdset_dup_fd_remove(fd);
231 }
232
233 return ret;
234 }
235
236 return close(fd);
237 }
238
239 /*
240 * A variant of write(2) which handles partial write.
241 *
242 * Return the number of bytes transferred.
243 * Set errno if fewer than `count' bytes are written.
244 *
245 * This function don't work with non-blocking fd's.
246 * Any of the possibilities with non-bloking fd's is bad:
247 * - return a short write (then name is wrong)
248 * - busy wait adding (errno == EAGAIN) to the loop
249 */
250 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
251 {
252 ssize_t ret = 0;
253 ssize_t total = 0;
254
255 while (count) {
256 ret = write(fd, buf, count);
257 if (ret < 0) {
258 if (errno == EINTR)
259 continue;
260 break;
261 }
262
263 count -= ret;
264 buf += ret;
265 total += ret;
266 }
267
268 return total;
269 }
270
271 /*
272 * Opens a socket with FD_CLOEXEC set
273 */
274 int qemu_socket(int domain, int type, int protocol)
275 {
276 int ret;
277
278 #ifdef SOCK_CLOEXEC
279 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
280 if (ret != -1 || errno != EINVAL) {
281 return ret;
282 }
283 #endif
284 ret = socket(domain, type, protocol);
285 if (ret >= 0) {
286 qemu_set_cloexec(ret);
287 }
288
289 return ret;
290 }
291
292 /*
293 * Accept a connection and set FD_CLOEXEC
294 */
295 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
296 {
297 int ret;
298
299 #ifdef CONFIG_ACCEPT4
300 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
301 if (ret != -1 || errno != ENOSYS) {
302 return ret;
303 }
304 #endif
305 ret = accept(s, addr, addrlen);
306 if (ret >= 0) {
307 qemu_set_cloexec(ret);
308 }
309
310 return ret;
311 }
312
313 /*
314 * A variant of send(2) which handles partial write.
315 *
316 * Return the number of bytes transferred, which is only
317 * smaller than `count' if there is an error.
318 *
319 * This function won't work with non-blocking fd's.
320 * Any of the possibilities with non-bloking fd's is bad:
321 * - return a short write (then name is wrong)
322 * - busy wait adding (errno == EAGAIN) to the loop
323 */
324 ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
325 {
326 ssize_t ret = 0;
327 ssize_t total = 0;
328
329 while (count) {
330 ret = send(fd, buf, count, flags);
331 if (ret < 0) {
332 if (errno == EINTR) {
333 continue;
334 }
335 break;
336 }
337
338 count -= ret;
339 buf += ret;
340 total += ret;
341 }
342
343 return total;
344 }
345
346 /*
347 * A variant of recv(2) which handles partial write.
348 *
349 * Return the number of bytes transferred, which is only
350 * smaller than `count' if there is an error.
351 *
352 * This function won't work with non-blocking fd's.
353 * Any of the possibilities with non-bloking fd's is bad:
354 * - return a short write (then name is wrong)
355 * - busy wait adding (errno == EAGAIN) to the loop
356 */
357 ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
358 {
359 ssize_t ret = 0;
360 ssize_t total = 0;
361
362 while (count) {
363 ret = qemu_recv(fd, buf, count, flags);
364 if (ret <= 0) {
365 if (ret < 0 && errno == EINTR) {
366 continue;
367 }
368 break;
369 }
370
371 count -= ret;
372 buf += ret;
373 total += ret;
374 }
375
376 return total;
377 }
378
379 void qemu_set_version(const char *version)
380 {
381 qemu_version = version;
382 }
383
384 const char *qemu_get_version(void)
385 {
386 return qemu_version;
387 }
388
389 void fips_set_state(bool requested)
390 {
391 #ifdef __linux__
392 if (requested) {
393 FILE *fds = fopen("/proc/sys/crypto/fips_enabled", "r");
394 if (fds != NULL) {
395 fips_enabled = (fgetc(fds) == '1');
396 fclose(fds);
397 }
398 }
399 #else
400 fips_enabled = false;
401 #endif /* __linux__ */
402
403 #ifdef _FIPS_DEBUG
404 fprintf(stderr, "FIPS mode %s (requested %s)\n",
405 (fips_enabled ? "enabled" : "disabled"),
406 (requested ? "enabled" : "disabled"));
407 #endif
408 }
409
410 bool fips_get_state(void)
411 {
412 return fips_enabled;
413 }
414
415 #ifdef _WIN32
416 static void socket_cleanup(void)
417 {
418 WSACleanup();
419 }
420 #endif
421
422 int socket_init(void)
423 {
424 #ifdef _WIN32
425 WSADATA Data;
426 int ret, err;
427
428 ret = WSAStartup(MAKEWORD(2, 2), &Data);
429 if (ret != 0) {
430 err = WSAGetLastError();
431 fprintf(stderr, "WSAStartup: %d\n", err);
432 return -1;
433 }
434 atexit(socket_cleanup);
435 #endif
436 return 0;
437 }
438
439 #if !GLIB_CHECK_VERSION(2, 31, 0)
440 /* Ensure that glib is running in multi-threaded mode
441 * Old versions of glib require explicit initialization. Failure to do
442 * this results in the single-threaded code paths being taken inside
443 * glib. For example, the g_slice allocator will not be thread-safe
444 * and cause crashes.
445 */
446 static void __attribute__((constructor)) thread_init(void)
447 {
448 if (!g_thread_supported()) {
449 g_thread_init(NULL);
450 }
451 }
452 #endif
453
454 #ifndef CONFIG_IOVEC
455 /* helper function for iov_send_recv() */
456 static ssize_t
457 readv_writev(int fd, const struct iovec *iov, int iov_cnt, bool do_write)
458 {
459 unsigned i = 0;
460 ssize_t ret = 0;
461 while (i < iov_cnt) {
462 ssize_t r = do_write
463 ? write(fd, iov[i].iov_base, iov[i].iov_len)
464 : read(fd, iov[i].iov_base, iov[i].iov_len);
465 if (r > 0) {
466 ret += r;
467 } else if (!r) {
468 break;
469 } else if (errno == EINTR) {
470 continue;
471 } else {
472 /* else it is some "other" error,
473 * only return if there was no data processed. */
474 if (ret == 0) {
475 ret = -1;
476 }
477 break;
478 }
479 i++;
480 }
481 return ret;
482 }
483
484 ssize_t
485 readv(int fd, const struct iovec *iov, int iov_cnt)
486 {
487 return readv_writev(fd, iov, iov_cnt, false);
488 }
489
490 ssize_t
491 writev(int fd, const struct iovec *iov, int iov_cnt)
492 {
493 return readv_writev(fd, iov, iov_cnt, true);
494 }
495 #endif