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
33 /* Needed early for CONFIG_BSD etc. */
34 #include "config-host.h"
36 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
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);
48 #include "qemu-common.h"
49 #include "qemu/sockets.h"
50 #include "monitor/monitor.h"
52 static bool fips_enabled
= false;
54 static const char *qemu_version
= QEMU_VERSION
;
56 int socket_set_cork(int fd
, int v
)
58 #if defined(SOL_TCP) && defined(TCP_CORK)
59 return qemu_setsockopt(fd
, SOL_TCP
, TCP_CORK
, &v
, sizeof(v
));
65 int socket_set_nodelay(int fd
)
68 return qemu_setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, &v
, sizeof(v
));
71 int qemu_madvise(void *addr
, size_t len
, int advice
)
73 if (advice
== QEMU_MADV_INVALID
) {
77 #if defined(CONFIG_MADVISE)
78 return madvise(addr
, len
, advice
);
79 #elif defined(CONFIG_POSIX_MADVISE)
80 return posix_madvise(addr
, len
, advice
);
89 * Dups an fd and sets the flags
91 static int qemu_dup_flags(int fd
, int flags
)
97 #ifdef F_DUPFD_CLOEXEC
98 ret
= fcntl(fd
, F_DUPFD_CLOEXEC
, 0);
102 qemu_set_cloexec(ret
);
109 dup_flags
= fcntl(ret
, F_GETFL
);
110 if (dup_flags
== -1) {
114 if ((flags
& O_SYNC
) != (dup_flags
& O_SYNC
)) {
119 /* Set/unset flags that we can with fcntl */
120 if (fcntl(ret
, F_SETFL
, flags
) == -1) {
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) {
143 static int qemu_parse_fdset(const char *param
)
145 return qemu_parse_fd(param
);
150 * Opens a file with FD_CLOEXEC set
152 int qemu_open(const char *name
, int flags
, ...)
158 const char *fdset_id_str
;
160 /* Attempt dup of fd from fd set */
161 if (strstart(name
, "/dev/fdset/", &fdset_id_str
)) {
165 fdset_id
= qemu_parse_fdset(fdset_id_str
);
166 if (fdset_id
== -1) {
171 fd
= monitor_fdset_get_fd(fdset_id
, flags
);
176 dupfd
= qemu_dup_flags(fd
, flags
);
181 ret
= monitor_fdset_dup_fd_add(fdset_id
, dupfd
);
192 if (flags
& O_CREAT
) {
196 mode
= va_arg(ap
, int);
201 ret
= open(name
, flags
| O_CLOEXEC
, mode
);
203 ret
= open(name
, flags
, mode
);
205 qemu_set_cloexec(ret
);
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 */
214 #endif /* O_DIRECT */
219 int qemu_close(int fd
)
223 /* Close fd that was dup'd from an fdset */
224 fdset_id
= monitor_fdset_dup_fd_find(fd
);
225 if (fdset_id
!= -1) {
230 monitor_fdset_dup_fd_remove(fd
);
240 * A variant of write(2) which handles partial write.
242 * Return the number of bytes transferred.
243 * Set errno if fewer than `count' bytes are written.
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
250 ssize_t
qemu_write_full(int fd
, const void *buf
, size_t count
)
256 ret
= write(fd
, buf
, count
);
272 * Opens a socket with FD_CLOEXEC set
274 int qemu_socket(int domain
, int type
, int protocol
)
279 ret
= socket(domain
, type
| SOCK_CLOEXEC
, protocol
);
280 if (ret
!= -1 || errno
!= EINVAL
) {
284 ret
= socket(domain
, type
, protocol
);
286 qemu_set_cloexec(ret
);
293 * Accept a connection and set FD_CLOEXEC
295 int qemu_accept(int s
, struct sockaddr
*addr
, socklen_t
*addrlen
)
299 #ifdef CONFIG_ACCEPT4
300 ret
= accept4(s
, addr
, addrlen
, SOCK_CLOEXEC
);
301 if (ret
!= -1 || errno
!= ENOSYS
) {
305 ret
= accept(s
, addr
, addrlen
);
307 qemu_set_cloexec(ret
);
314 * A variant of send(2) which handles partial write.
316 * Return the number of bytes transferred, which is only
317 * smaller than `count' if there is an error.
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
324 ssize_t
qemu_send_full(int fd
, const void *buf
, size_t count
, int flags
)
330 ret
= send(fd
, buf
, count
, flags
);
332 if (errno
== EINTR
) {
347 * A variant of recv(2) which handles partial write.
349 * Return the number of bytes transferred, which is only
350 * smaller than `count' if there is an error.
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
357 ssize_t
qemu_recv_full(int fd
, void *buf
, size_t count
, int flags
)
363 ret
= qemu_recv(fd
, buf
, count
, flags
);
365 if (ret
< 0 && errno
== EINTR
) {
379 void qemu_set_version(const char *version
)
381 qemu_version
= version
;
384 const char *qemu_get_version(void)
389 void fips_set_state(bool requested
)
393 FILE *fds
= fopen("/proc/sys/crypto/fips_enabled", "r");
395 fips_enabled
= (fgetc(fds
) == '1');
400 fips_enabled
= false;
401 #endif /* __linux__ */
404 fprintf(stderr
, "FIPS mode %s (requested %s)\n",
405 (fips_enabled
? "enabled" : "disabled"),
406 (requested
? "enabled" : "disabled"));
410 bool fips_get_state(void)
416 static void socket_cleanup(void)
422 int socket_init(void)
428 ret
= WSAStartup(MAKEWORD(2, 2), &Data
);
430 err
= WSAGetLastError();
431 fprintf(stderr
, "WSAStartup: %d\n", err
);
434 atexit(socket_cleanup
);
439 /* Ensure that glib is running in multi-threaded mode */
440 static void __attribute__((constructor
)) thread_init(void)
442 if (!g_thread_supported()) {
443 #if !GLIB_CHECK_VERSION(2, 31, 0)
444 /* Old versions of glib require explicit initialization. Failure to do
445 * this results in the single-threaded code paths being taken inside
446 * glib. For example, the g_slice allocator will not be thread-safe
451 fprintf(stderr
, "glib threading failed to initialize.\n");
458 /* helper function for iov_send_recv() */
460 readv_writev(int fd
, const struct iovec
*iov
, int iov_cnt
, bool do_write
)
464 while (i
< iov_cnt
) {
466 ? write(fd
, iov
[i
].iov_base
, iov
[i
].iov_len
)
467 : read(fd
, iov
[i
].iov_base
, iov
[i
].iov_len
);
472 } else if (errno
== EINTR
) {
475 /* else it is some "other" error,
476 * only return if there was no data processed. */
488 readv(int fd
, const struct iovec
*iov
, int iov_cnt
)
490 return readv_writev(fd
, iov
, iov_cnt
, false);
494 writev(int fd
, const struct iovec
*iov
, int iov_cnt
)
496 return readv_writev(fd
, iov
, iov_cnt
, true);