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
24 #include "qemu/osdep.h"
25 #include "qapi/error.h"
27 /* Needed early for CONFIG_BSD etc. */
30 #include <sys/statvfs.h>
31 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
32 discussion about Solaris header problems */
33 extern int madvise(char *, size_t, int);
37 #include "qemu-common.h"
38 #include "qemu/cutils.h"
39 #include "qemu/sockets.h"
40 #include "qemu/error-report.h"
41 #include "qemu/madvise.h"
42 #include "qemu/mprotect.h"
43 #include "qemu/hw-version.h"
44 #include "monitor/monitor.h"
46 static bool fips_enabled
= false;
48 static const char *hw_version
= QEMU_HW_VERSION
;
50 int socket_set_cork(int fd
, int v
)
52 #if defined(SOL_TCP) && defined(TCP_CORK)
53 return qemu_setsockopt(fd
, SOL_TCP
, TCP_CORK
, &v
, sizeof(v
));
59 int socket_set_nodelay(int fd
)
62 return qemu_setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, &v
, sizeof(v
));
65 int qemu_madvise(void *addr
, size_t len
, int advice
)
67 if (advice
== QEMU_MADV_INVALID
) {
71 #if defined(CONFIG_MADVISE)
72 return madvise(addr
, len
, advice
);
73 #elif defined(CONFIG_POSIX_MADVISE)
74 return posix_madvise(addr
, len
, advice
);
81 static int qemu_mprotect__osdep(void *addr
, size_t size
, int prot
)
83 g_assert(!((uintptr_t)addr
& ~qemu_real_host_page_mask
));
84 g_assert(!(size
& ~qemu_real_host_page_mask
));
89 if (!VirtualProtect(addr
, size
, prot
, &old_protect
)) {
90 g_autofree gchar
*emsg
= g_win32_error_message(GetLastError());
91 error_report("%s: VirtualProtect failed: %s", __func__
, emsg
);
96 if (mprotect(addr
, size
, prot
)) {
97 error_report("%s: mprotect failed: %s", __func__
, strerror(errno
));
104 int qemu_mprotect_rw(void *addr
, size_t size
)
107 return qemu_mprotect__osdep(addr
, size
, PAGE_READWRITE
);
109 return qemu_mprotect__osdep(addr
, size
, PROT_READ
| PROT_WRITE
);
113 int qemu_mprotect_rwx(void *addr
, size_t size
)
116 return qemu_mprotect__osdep(addr
, size
, PAGE_EXECUTE_READWRITE
);
118 return qemu_mprotect__osdep(addr
, size
, PROT_READ
| PROT_WRITE
| PROT_EXEC
);
122 int qemu_mprotect_none(void *addr
, size_t size
)
125 return qemu_mprotect__osdep(addr
, size
, PAGE_NOACCESS
);
127 return qemu_mprotect__osdep(addr
, size
, PROT_NONE
);
133 static int fcntl_op_setlk
= -1;
134 static int fcntl_op_getlk
= -1;
137 * Dups an fd and sets the flags
139 int qemu_dup_flags(int fd
, int flags
)
150 dup_flags
= fcntl(ret
, F_GETFL
);
151 if (dup_flags
== -1) {
155 if ((flags
& O_SYNC
) != (dup_flags
& O_SYNC
)) {
160 /* Set/unset flags that we can with fcntl */
161 if (fcntl(ret
, F_SETFL
, flags
) == -1) {
165 /* Truncate the file in the cases that open() would truncate it */
166 if (flags
& O_TRUNC
||
167 ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))) {
168 if (ftruncate(ret
, 0) == -1) {
187 #ifdef F_DUPFD_CLOEXEC
188 ret
= fcntl(fd
, F_DUPFD_CLOEXEC
, 0);
192 qemu_set_cloexec(ret
);
198 static int qemu_parse_fdset(const char *param
)
200 return qemu_parse_fd(param
);
203 static void qemu_probe_lock_ops(void)
205 if (fcntl_op_setlk
== -1) {
210 .l_whence
= SEEK_SET
,
216 fd
= open("/dev/null", O_RDWR
);
219 "Failed to open /dev/null for OFD lock probing: %s\n",
221 fcntl_op_setlk
= F_SETLK
;
222 fcntl_op_getlk
= F_GETLK
;
225 ret
= fcntl(fd
, F_OFD_GETLK
, &fl
);
228 fcntl_op_setlk
= F_OFD_SETLK
;
229 fcntl_op_getlk
= F_OFD_GETLK
;
231 fcntl_op_setlk
= F_SETLK
;
232 fcntl_op_getlk
= F_GETLK
;
235 fcntl_op_setlk
= F_SETLK
;
236 fcntl_op_getlk
= F_GETLK
;
241 bool qemu_has_ofd_lock(void)
243 qemu_probe_lock_ops();
245 return fcntl_op_setlk
== F_OFD_SETLK
;
251 static int qemu_lock_fcntl(int fd
, int64_t start
, int64_t len
, int fl_type
)
255 .l_whence
= SEEK_SET
,
260 qemu_probe_lock_ops();
262 ret
= fcntl(fd
, fcntl_op_setlk
, &fl
);
263 } while (ret
== -1 && errno
== EINTR
);
264 return ret
== -1 ? -errno
: 0;
267 int qemu_lock_fd(int fd
, int64_t start
, int64_t len
, bool exclusive
)
269 return qemu_lock_fcntl(fd
, start
, len
, exclusive
? F_WRLCK
: F_RDLCK
);
272 int qemu_unlock_fd(int fd
, int64_t start
, int64_t len
)
274 return qemu_lock_fcntl(fd
, start
, len
, F_UNLCK
);
277 int qemu_lock_fd_test(int fd
, int64_t start
, int64_t len
, bool exclusive
)
281 .l_whence
= SEEK_SET
,
284 .l_type
= exclusive
? F_WRLCK
: F_RDLCK
,
286 qemu_probe_lock_ops();
287 ret
= fcntl(fd
, fcntl_op_getlk
, &fl
);
291 return fl
.l_type
== F_UNLCK
? 0 : -EAGAIN
;
296 static int qemu_open_cloexec(const char *name
, int flags
, mode_t mode
)
300 ret
= open(name
, flags
| O_CLOEXEC
, mode
);
302 ret
= open(name
, flags
, mode
);
304 qemu_set_cloexec(ret
);
311 * Opens a file with FD_CLOEXEC set
314 qemu_open_internal(const char *name
, int flags
, mode_t mode
, Error
**errp
)
319 const char *fdset_id_str
;
321 /* Attempt dup of fd from fd set */
322 if (strstart(name
, "/dev/fdset/", &fdset_id_str
)) {
326 fdset_id
= qemu_parse_fdset(fdset_id_str
);
327 if (fdset_id
== -1) {
328 error_setg(errp
, "Could not parse fdset %s", name
);
333 dupfd
= monitor_fdset_dup_fd_add(fdset_id
, flags
);
335 error_setg_errno(errp
, errno
, "Could not dup FD for %s flags %x",
344 ret
= qemu_open_cloexec(name
, flags
, mode
);
347 const char *action
= flags
& O_CREAT
? "create" : "open";
349 /* Give more helpful error message for O_DIRECT */
350 if (errno
== EINVAL
&& (flags
& O_DIRECT
)) {
351 ret
= open(name
, flags
& ~O_DIRECT
, mode
);
354 error_setg(errp
, "Could not %s '%s': "
355 "filesystem does not support O_DIRECT",
357 errno
= EINVAL
; /* restore first open()'s errno */
361 #endif /* O_DIRECT */
362 error_setg_errno(errp
, errno
, "Could not %s '%s'",
370 int qemu_open(const char *name
, int flags
, Error
**errp
)
372 assert(!(flags
& O_CREAT
));
374 return qemu_open_internal(name
, flags
, 0, errp
);
378 int qemu_create(const char *name
, int flags
, mode_t mode
, Error
**errp
)
380 assert(!(flags
& O_CREAT
));
382 return qemu_open_internal(name
, flags
| O_CREAT
, mode
, errp
);
386 int qemu_open_old(const char *name
, int flags
, ...)
393 if (flags
& O_CREAT
) {
394 mode
= va_arg(ap
, int);
398 ret
= qemu_open_internal(name
, flags
, mode
, NULL
);
401 if (ret
== -1 && errno
== EINVAL
&& (flags
& O_DIRECT
)) {
402 error_report("file system may not support O_DIRECT");
403 errno
= EINVAL
; /* in case it was clobbered */
405 #endif /* O_DIRECT */
410 int qemu_close(int fd
)
414 /* Close fd that was dup'd from an fdset */
415 fdset_id
= monitor_fdset_dup_fd_find(fd
);
416 if (fdset_id
!= -1) {
421 monitor_fdset_dup_fd_remove(fd
);
431 * Delete a file from the filesystem, unless the filename is /dev/fdset/...
433 * Returns: On success, zero is returned. On error, -1 is returned,
434 * and errno is set appropriately.
436 int qemu_unlink(const char *name
)
438 if (g_str_has_prefix(name
, "/dev/fdset/")) {
446 * A variant of write(2) which handles partial write.
448 * Return the number of bytes transferred.
449 * Set errno if fewer than `count' bytes are written.
451 * This function don't work with non-blocking fd's.
452 * Any of the possibilities with non-blocking fd's is bad:
453 * - return a short write (then name is wrong)
454 * - busy wait adding (errno == EAGAIN) to the loop
456 ssize_t
qemu_write_full(int fd
, const void *buf
, size_t count
)
462 ret
= write(fd
, buf
, count
);
478 * Opens a socket with FD_CLOEXEC set
480 int qemu_socket(int domain
, int type
, int protocol
)
485 ret
= socket(domain
, type
| SOCK_CLOEXEC
, protocol
);
486 if (ret
!= -1 || errno
!= EINVAL
) {
490 ret
= socket(domain
, type
, protocol
);
492 qemu_set_cloexec(ret
);
499 * Accept a connection and set FD_CLOEXEC
501 int qemu_accept(int s
, struct sockaddr
*addr
, socklen_t
*addrlen
)
505 #ifdef CONFIG_ACCEPT4
506 ret
= accept4(s
, addr
, addrlen
, SOCK_CLOEXEC
);
507 if (ret
!= -1 || errno
!= ENOSYS
) {
511 ret
= accept(s
, addr
, addrlen
);
513 qemu_set_cloexec(ret
);
519 void qemu_set_hw_version(const char *version
)
521 hw_version
= version
;
524 const char *qemu_hw_version(void)
529 void fips_set_state(bool requested
)
533 FILE *fds
= fopen("/proc/sys/crypto/fips_enabled", "r");
535 fips_enabled
= (fgetc(fds
) == '1');
540 fips_enabled
= false;
541 #endif /* __linux__ */
544 fprintf(stderr
, "FIPS mode %s (requested %s)\n",
545 (fips_enabled
? "enabled" : "disabled"),
546 (requested
? "enabled" : "disabled"));
550 bool fips_get_state(void)
556 static void socket_cleanup(void)
562 int socket_init(void)
568 ret
= WSAStartup(MAKEWORD(2, 2), &Data
);
570 err
= WSAGetLastError();
571 fprintf(stderr
, "WSAStartup: %d\n", err
);
574 atexit(socket_cleanup
);
581 /* helper function for iov_send_recv() */
583 readv_writev(int fd
, const struct iovec
*iov
, int iov_cnt
, bool do_write
)
587 while (i
< iov_cnt
) {
589 ? write(fd
, iov
[i
].iov_base
, iov
[i
].iov_len
)
590 : read(fd
, iov
[i
].iov_base
, iov
[i
].iov_len
);
595 } else if (errno
== EINTR
) {
598 /* else it is some "other" error,
599 * only return if there was no data processed. */
611 readv(int fd
, const struct iovec
*iov
, int iov_cnt
)
613 return readv_writev(fd
, iov
, iov_cnt
, false);
617 writev(int fd
, const struct iovec
*iov
, int iov_cnt
)
619 return readv_writev(fd
, iov
, iov_cnt
, true);
624 qemu_dirent_dup(struct dirent
*dent
)
627 #if defined _DIRENT_HAVE_D_RECLEN
628 /* Avoid use of strlen() if platform supports d_reclen. */
632 * Test sz for zero even if d_reclen is available
633 * because some drivers may set d_reclen to zero.
636 /* Fallback to the most portable way. */
637 sz
= offsetof(struct dirent
, d_name
) +
638 strlen(dent
->d_name
) + 1;
640 return g_memdup(dent
, sz
);