target-i386: tcg: Accept clwb instruction
[qemu/ar7.git] / util / osdep.c
blob80c6bfeeb2ed99586d882b3a28bd1eeec711a89f
1 /*
2 * QEMU low level functions
4 * Copyright (c) 2003 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 <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>
33 /* Needed early for CONFIG_BSD etc. */
34 #include "config-host.h"
36 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
37 #include <sys/mman.h>
38 #endif
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
48 #include "qemu-common.h"
49 #include "qemu/sockets.h"
50 #include "qemu/error-report.h"
51 #include "monitor/monitor.h"
53 static bool fips_enabled = false;
55 static const char *hw_version = QEMU_VERSION;
57 int socket_set_cork(int fd, int v)
59 #if defined(SOL_TCP) && defined(TCP_CORK)
60 return qemu_setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
61 #else
62 return 0;
63 #endif
66 int socket_set_nodelay(int fd)
68 int v = 1;
69 return qemu_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &v, sizeof(v));
72 int qemu_madvise(void *addr, size_t len, int advice)
74 if (advice == QEMU_MADV_INVALID) {
75 errno = EINVAL;
76 return -1;
78 #if defined(CONFIG_MADVISE)
79 return madvise(addr, len, advice);
80 #elif defined(CONFIG_POSIX_MADVISE)
81 return posix_madvise(addr, len, advice);
82 #else
83 errno = EINVAL;
84 return -1;
85 #endif
88 #ifndef _WIN32
90 * Dups an fd and sets the flags
92 static int qemu_dup_flags(int fd, int flags)
94 int ret;
95 int serrno;
96 int dup_flags;
98 #ifdef F_DUPFD_CLOEXEC
99 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0);
100 #else
101 ret = dup(fd);
102 if (ret != -1) {
103 qemu_set_cloexec(ret);
105 #endif
106 if (ret == -1) {
107 goto fail;
110 dup_flags = fcntl(ret, F_GETFL);
111 if (dup_flags == -1) {
112 goto fail;
115 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) {
116 errno = EINVAL;
117 goto fail;
120 /* Set/unset flags that we can with fcntl */
121 if (fcntl(ret, F_SETFL, flags) == -1) {
122 goto fail;
125 /* Truncate the file in the cases that open() would truncate it */
126 if (flags & O_TRUNC ||
127 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) {
128 if (ftruncate(ret, 0) == -1) {
129 goto fail;
133 return ret;
135 fail:
136 serrno = errno;
137 if (ret != -1) {
138 close(ret);
140 errno = serrno;
141 return -1;
144 static int qemu_parse_fdset(const char *param)
146 return qemu_parse_fd(param);
148 #endif
151 * Opens a file with FD_CLOEXEC set
153 int qemu_open(const char *name, int flags, ...)
155 int ret;
156 int mode = 0;
158 #ifndef _WIN32
159 const char *fdset_id_str;
161 /* Attempt dup of fd from fd set */
162 if (strstart(name, "/dev/fdset/", &fdset_id_str)) {
163 int64_t fdset_id;
164 int fd, dupfd;
166 fdset_id = qemu_parse_fdset(fdset_id_str);
167 if (fdset_id == -1) {
168 errno = EINVAL;
169 return -1;
172 fd = monitor_fdset_get_fd(fdset_id, flags);
173 if (fd == -1) {
174 return -1;
177 dupfd = qemu_dup_flags(fd, flags);
178 if (dupfd == -1) {
179 return -1;
182 ret = monitor_fdset_dup_fd_add(fdset_id, dupfd);
183 if (ret == -1) {
184 close(dupfd);
185 errno = EINVAL;
186 return -1;
189 return dupfd;
191 #endif
193 if (flags & O_CREAT) {
194 va_list ap;
196 va_start(ap, flags);
197 mode = va_arg(ap, int);
198 va_end(ap);
201 #ifdef O_CLOEXEC
202 ret = open(name, flags | O_CLOEXEC, mode);
203 #else
204 ret = open(name, flags, mode);
205 if (ret >= 0) {
206 qemu_set_cloexec(ret);
208 #endif
210 #ifdef O_DIRECT
211 if (ret == -1 && errno == EINVAL && (flags & O_DIRECT)) {
212 error_report("file system may not support O_DIRECT");
213 errno = EINVAL; /* in case it was clobbered */
215 #endif /* O_DIRECT */
217 return ret;
220 int qemu_close(int fd)
222 int64_t fdset_id;
224 /* Close fd that was dup'd from an fdset */
225 fdset_id = monitor_fdset_dup_fd_find(fd);
226 if (fdset_id != -1) {
227 int ret;
229 ret = close(fd);
230 if (ret == 0) {
231 monitor_fdset_dup_fd_remove(fd);
234 return ret;
237 return close(fd);
241 * A variant of write(2) which handles partial write.
243 * Return the number of bytes transferred.
244 * Set errno if fewer than `count' bytes are written.
246 * This function don't work with non-blocking fd's.
247 * Any of the possibilities with non-bloking fd's is bad:
248 * - return a short write (then name is wrong)
249 * - busy wait adding (errno == EAGAIN) to the loop
251 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
253 ssize_t ret = 0;
254 ssize_t total = 0;
256 while (count) {
257 ret = write(fd, buf, count);
258 if (ret < 0) {
259 if (errno == EINTR)
260 continue;
261 break;
264 count -= ret;
265 buf += ret;
266 total += ret;
269 return total;
273 * Opens a socket with FD_CLOEXEC set
275 int qemu_socket(int domain, int type, int protocol)
277 int ret;
279 #ifdef SOCK_CLOEXEC
280 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
281 if (ret != -1 || errno != EINVAL) {
282 return ret;
284 #endif
285 ret = socket(domain, type, protocol);
286 if (ret >= 0) {
287 qemu_set_cloexec(ret);
290 return ret;
294 * Accept a connection and set FD_CLOEXEC
296 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
298 int ret;
300 #ifdef CONFIG_ACCEPT4
301 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
302 if (ret != -1 || errno != ENOSYS) {
303 return ret;
305 #endif
306 ret = accept(s, addr, addrlen);
307 if (ret >= 0) {
308 qemu_set_cloexec(ret);
311 return ret;
314 void qemu_set_hw_version(const char *version)
316 hw_version = version;
319 const char *qemu_hw_version(void)
321 return hw_version;
324 void fips_set_state(bool requested)
326 #ifdef __linux__
327 if (requested) {
328 FILE *fds = fopen("/proc/sys/crypto/fips_enabled", "r");
329 if (fds != NULL) {
330 fips_enabled = (fgetc(fds) == '1');
331 fclose(fds);
334 #else
335 fips_enabled = false;
336 #endif /* __linux__ */
338 #ifdef _FIPS_DEBUG
339 fprintf(stderr, "FIPS mode %s (requested %s)\n",
340 (fips_enabled ? "enabled" : "disabled"),
341 (requested ? "enabled" : "disabled"));
342 #endif
345 bool fips_get_state(void)
347 return fips_enabled;
350 #ifdef _WIN32
351 static void socket_cleanup(void)
353 WSACleanup();
355 #endif
357 int socket_init(void)
359 #ifdef _WIN32
360 WSADATA Data;
361 int ret, err;
363 ret = WSAStartup(MAKEWORD(2, 2), &Data);
364 if (ret != 0) {
365 err = WSAGetLastError();
366 fprintf(stderr, "WSAStartup: %d\n", err);
367 return -1;
369 atexit(socket_cleanup);
370 #endif
371 return 0;
374 #if !GLIB_CHECK_VERSION(2, 31, 0)
375 /* Ensure that glib is running in multi-threaded mode
376 * Old versions of glib require explicit initialization. Failure to do
377 * this results in the single-threaded code paths being taken inside
378 * glib. For example, the g_slice allocator will not be thread-safe
379 * and cause crashes.
381 static void __attribute__((constructor)) thread_init(void)
383 if (!g_thread_supported()) {
384 g_thread_init(NULL);
387 #endif
389 #ifndef CONFIG_IOVEC
390 /* helper function for iov_send_recv() */
391 static ssize_t
392 readv_writev(int fd, const struct iovec *iov, int iov_cnt, bool do_write)
394 unsigned i = 0;
395 ssize_t ret = 0;
396 while (i < iov_cnt) {
397 ssize_t r = do_write
398 ? write(fd, iov[i].iov_base, iov[i].iov_len)
399 : read(fd, iov[i].iov_base, iov[i].iov_len);
400 if (r > 0) {
401 ret += r;
402 } else if (!r) {
403 break;
404 } else if (errno == EINTR) {
405 continue;
406 } else {
407 /* else it is some "other" error,
408 * only return if there was no data processed. */
409 if (ret == 0) {
410 ret = -1;
412 break;
414 i++;
416 return ret;
419 ssize_t
420 readv(int fd, const struct iovec *iov, int iov_cnt)
422 return readv_writev(fd, iov, iov_cnt, false);
425 ssize_t
426 writev(int fd, const struct iovec *iov, int iov_cnt)
428 return readv_writev(fd, iov, iov_cnt, true);
430 #endif