4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2010-2016 Red Hat, Inc.
7 * QEMU library functions for win32 which are shared between QEMU and
10 * Permission is hereby granted, free of charge, to any person obtaining a copy
11 * of this software and associated documentation files (the "Software"), to deal
12 * in the Software without restriction, including without limitation the rights
13 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 * copies of the Software, and to permit persons to whom the Software is
15 * furnished to do so, subject to the following conditions:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
29 #include "qemu/osdep.h"
31 #include "qapi/error.h"
32 #include "qemu/main-loop.h"
34 #include "qemu/sockets.h"
35 #include "qemu/cutils.h"
36 #include "qemu/error-report.h"
39 static int get_allocation_granularity(void)
41 SYSTEM_INFO system_info;
43 GetSystemInfo(&system_info);
44 return system_info.dwAllocationGranularity;
47 void *qemu_anon_ram_alloc(size_t size, uint64_t *align, bool shared,
54 * We need a MEM_COMMIT before accessing any memory in a MEM_RESERVE
55 * area; we cannot easily mimic POSIX MAP_NORESERVE semantics.
57 error_report("Skipping reservation of swap space is not supported.");
61 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
62 trace_qemu_anon_ram_alloc(size, ptr);
65 *align = MAX(get_allocation_granularity(), getpagesize());
70 void qemu_anon_ram_free(void *ptr, size_t size)
72 trace_qemu_anon_ram_free(ptr, size);
74 VirtualFree(ptr, 0, MEM_RELEASE);
78 #ifndef _POSIX_THREAD_SAFE_FUNCTIONS
79 /* FIXME: add proper locking */
80 struct tm *gmtime_r(const time_t *timep, struct tm *result)
82 struct tm *p = gmtime(timep);
83 memset(result, 0, sizeof(*result));
91 /* FIXME: add proper locking */
92 struct tm *localtime_r(const time_t *timep, struct tm *result)
94 struct tm *p = localtime(timep);
95 memset(result, 0, sizeof(*result));
102 #endif /* _POSIX_THREAD_SAFE_FUNCTIONS */
104 static int socket_error(void)
106 switch (WSAGetLastError()) {
113 case WSA_INVALID_HANDLE:
115 case WSA_NOT_ENOUGH_MEMORY:
117 case WSA_INVALID_PARAMETER:
119 case WSAENAMETOOLONG:
124 /* not using EWOULDBLOCK as we don't want code to have
125 * to check both EWOULDBLOCK and EAGAIN */
133 case WSAEDESTADDRREQ:
141 case WSAEPROTONOSUPPORT:
142 return EPROTONOSUPPORT;
145 case WSAEAFNOSUPPORT:
149 case WSAEADDRNOTAVAIL:
150 return EADDRNOTAVAIL;
157 case WSAECONNABORTED:
169 case WSAECONNREFUSED:
173 case WSAEHOSTUNREACH:
180 void qemu_socket_set_block(int fd)
182 unsigned long opt = 0;
183 qemu_socket_unselect(fd, NULL);
184 ioctlsocket(fd, FIONBIO, &opt);
187 int qemu_socket_try_set_nonblock(int fd)
189 unsigned long opt = 1;
190 if (ioctlsocket(fd, FIONBIO, &opt) != NO_ERROR) {
191 return -socket_error();
196 void qemu_socket_set_nonblock(int fd)
198 (void)qemu_socket_try_set_nonblock(fd);
201 int socket_set_fast_reuse(int fd)
203 /* Enabling the reuse of an endpoint that was used by a socket still in
204 * TIME_WAIT state is usually performed by setting SO_REUSEADDR. On Windows
205 * fast reuse is the default and SO_REUSEADDR does strange things. So we
206 * don't have to do anything here. More info can be found at:
207 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms740621.aspx */
211 int inet_aton(const char *cp, struct in_addr *ia)
213 uint32_t addr = inet_addr(cp);
214 if (addr == 0xffffffff) {
221 void qemu_set_cloexec(int fd)
225 int qemu_get_thread_id(void)
227 return GetCurrentThreadId();
231 qemu_get_local_state_dir(void)
233 const char * const *data_dirs = g_get_system_data_dirs();
235 g_assert(data_dirs && data_dirs[0]);
237 return g_strdup(data_dirs[0]);
240 void qemu_set_tty_echo(int fd, bool echo)
242 HANDLE handle = (HANDLE)_get_osfhandle(fd);
245 if (handle == INVALID_HANDLE_VALUE) {
249 GetConsoleMode(handle, &dwMode);
252 SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);
254 SetConsoleMode(handle,
255 dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT));
259 int getpagesize(void)
261 SYSTEM_INFO system_info;
263 GetSystemInfo(&system_info);
264 return system_info.dwPageSize;
267 void qemu_prealloc_mem(int fd, char *area, size_t sz, int max_threads,
268 ThreadContext *tc, Error **errp)
271 size_t pagesize = qemu_real_host_page_size();
273 sz = (sz + pagesize - 1) & -pagesize;
274 for (i = 0; i < sz / pagesize; i++) {
275 memset(area + pagesize * i, 0, 1);
279 char *qemu_get_pid_name(pid_t pid)
281 /* XXX Implement me */
286 bool qemu_socket_select(int sockfd, WSAEVENT hEventObject,
287 long lNetworkEvents, Error **errp)
289 SOCKET s = _get_osfhandle(sockfd);
295 if (s == INVALID_SOCKET) {
296 error_setg(errp, "invalid socket fd=%d", sockfd);
300 if (WSAEventSelect(s, hEventObject, lNetworkEvents) != 0) {
301 error_setg_win32(errp, WSAGetLastError(), "failed to WSAEventSelect()");
308 bool qemu_socket_unselect(int sockfd, Error **errp)
310 return qemu_socket_select(sockfd, NULL, 0, errp);
313 int qemu_socketpair(int domain, int type, int protocol, int sv[2])
315 struct sockaddr_un addr = {
322 g_autofree char *path = NULL;
327 g_return_val_if_fail(sv != NULL, -1);
329 addr.sun_family = AF_UNIX;
330 socklen = sizeof(addr);
332 tmpfd = g_file_open_tmp(NULL, &path, NULL);
333 if (tmpfd == -1 || !path) {
340 if (strlen(path) >= sizeof(addr.sun_path)) {
345 strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
347 listener = socket(domain, type, protocol);
348 if (listener == -1) {
352 if (DeleteFile(path) == 0 && GetLastError() != ERROR_FILE_NOT_FOUND) {
356 g_clear_pointer(&path, g_free);
358 if (bind(listener, (struct sockaddr *)&addr, socklen) == -1) {
362 if (listen(listener, 1) == -1) {
366 client = socket(domain, type, protocol);
372 if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
376 if (connect(client, (struct sockaddr *)&addr, socklen) == -1 &&
377 WSAGetLastError() != WSAEWOULDBLOCK) {
381 server = accept(listener, NULL, NULL);
387 if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
392 if (ioctlsocket(client, SIO_AF_UNIX_GETPEERPID, &arg) != NO_ERROR) {
396 if (arg != GetCurrentProcessId()) {
408 if (listener != -1) {
424 int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
428 SOCKET s = _get_osfhandle(sockfd);
430 if (s == INVALID_SOCKET) {
434 ret = connect(s, addr, addrlen);
436 if (WSAGetLastError() == WSAEWOULDBLOCK) {
439 errno = socket_error();
447 int qemu_listen_wrap(int sockfd, int backlog)
450 SOCKET s = _get_osfhandle(sockfd);
452 if (s == INVALID_SOCKET) {
456 ret = listen(s, backlog);
458 errno = socket_error();
465 int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
469 SOCKET s = _get_osfhandle(sockfd);
471 if (s == INVALID_SOCKET) {
475 ret = bind(s, addr, addrlen);
477 errno = socket_error();
482 QEMU_USED EXCEPTION_DISPOSITION
483 win32_close_exception_handler(struct _EXCEPTION_RECORD *exception_record,
484 void *registration, struct _CONTEXT *context,
487 return EXCEPTION_EXECUTE_HANDLER;
491 int qemu_close_socket_osfhandle(int fd)
493 SOCKET s = _get_osfhandle(fd);
497 * If we were to just call _close on the descriptor, it would close the
498 * HANDLE, but it wouldn't free any of the resources associated to the
499 * SOCKET, and we can't call _close after calling closesocket, because
500 * closesocket has already closed the HANDLE, and _close would attempt to
501 * close the HANDLE again, resulting in a double free. We can however
502 * protect the HANDLE from actually being closed long enough to close the
503 * file descriptor, then close the socket itself.
505 if (!GetHandleInformation((HANDLE)s, &flags)) {
510 if (!SetHandleInformation((HANDLE)s, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE)) {
515 __try1(win32_close_exception_handler) {
517 * close() returns EBADF since we PROTECT_FROM_CLOSE the underlying
518 * handle, but the FD is actually freed
520 if (close(fd) < 0 && errno != EBADF) {
527 if (!SetHandleInformation((HANDLE)s, flags, flags)) {
535 int qemu_close_wrap(int fd)
537 SOCKET s = INVALID_SOCKET;
540 if (!fd_is_socket(fd)) {
544 s = _get_osfhandle(fd);
545 qemu_close_socket_osfhandle(fd);
547 ret = closesocket(s);
549 errno = socket_error();
557 int qemu_socket_wrap(int domain, int type, int protocol)
562 s = socket(domain, type, protocol);
564 errno = socket_error();
568 fd = _open_osfhandle(s, _O_BINARY);
571 /* _open_osfhandle may not set errno, and closesocket() may override it */
580 int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
584 SOCKET s = _get_osfhandle(sockfd);
586 if (s == INVALID_SOCKET) {
590 s = accept(s, addr, addrlen);
592 errno = socket_error();
596 fd = _open_osfhandle(s, _O_BINARY);
599 /* _open_osfhandle may not set errno, and closesocket() may override it */
608 int qemu_shutdown_wrap(int sockfd, int how)
611 SOCKET s = _get_osfhandle(sockfd);
613 if (s == INVALID_SOCKET) {
617 ret = shutdown(s, how);
619 errno = socket_error();
626 int qemu_ioctlsocket_wrap(int fd, int req, void *val)
629 SOCKET s = _get_osfhandle(fd);
631 if (s == INVALID_SOCKET) {
635 ret = ioctlsocket(s, req, val);
637 errno = socket_error();
644 int qemu_getsockopt_wrap(int sockfd, int level, int optname,
645 void *optval, socklen_t *optlen)
648 SOCKET s = _get_osfhandle(sockfd);
650 if (s == INVALID_SOCKET) {
654 ret = getsockopt(s, level, optname, optval, optlen);
656 errno = socket_error();
663 int qemu_setsockopt_wrap(int sockfd, int level, int optname,
664 const void *optval, socklen_t optlen)
667 SOCKET s = _get_osfhandle(sockfd);
669 if (s == INVALID_SOCKET) {
673 ret = setsockopt(s, level, optname, optval, optlen);
675 errno = socket_error();
682 int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
686 SOCKET s = _get_osfhandle(sockfd);
688 if (s == INVALID_SOCKET) {
692 ret = getpeername(s, addr, addrlen);
694 errno = socket_error();
701 int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
705 SOCKET s = _get_osfhandle(sockfd);
707 if (s == INVALID_SOCKET) {
711 ret = getsockname(s, addr, addrlen);
713 errno = socket_error();
720 ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
723 SOCKET s = _get_osfhandle(sockfd);
725 if (s == INVALID_SOCKET) {
729 ret = send(s, buf, len, flags);
731 errno = socket_error();
738 ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
739 const struct sockaddr *addr, socklen_t addrlen)
742 SOCKET s = _get_osfhandle(sockfd);
744 if (s == INVALID_SOCKET) {
748 ret = sendto(s, buf, len, flags, addr, addrlen);
750 errno = socket_error();
757 ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
760 SOCKET s = _get_osfhandle(sockfd);
762 if (s == INVALID_SOCKET) {
766 ret = recv(s, buf, len, flags);
768 errno = socket_error();
775 ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
776 struct sockaddr *addr, socklen_t *addrlen)
779 SOCKET s = _get_osfhandle(sockfd);
781 if (s == INVALID_SOCKET) {
785 ret = recvfrom(s, buf, len, flags, addr, addrlen);
787 errno = socket_error();
792 bool qemu_write_pidfile(const char *filename, Error **errp)
799 memset(&overlap, 0, sizeof(overlap));
801 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
802 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
804 if (file == INVALID_HANDLE_VALUE) {
805 error_setg(errp, "Failed to create PID file");
808 len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid());
809 ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len,
813 error_setg(errp, "Failed to write PID file");
819 size_t qemu_get_host_physmem(void)
821 MEMORYSTATUSEX statex;
822 statex.dwLength = sizeof(statex);
824 if (GlobalMemoryStatusEx(&statex)) {
825 return statex.ullTotalPhys;
830 int qemu_msync(void *addr, size_t length, int fd)
833 * Perform the sync based on the file descriptor
834 * The sync range will most probably be wider than the one
835 * requested - but it will still get the job done
837 return qemu_fdatasync(fd);
840 void *qemu_win32_map_alloc(size_t size, HANDLE *h, Error **errp)
844 trace_win32_map_alloc(size);
846 *h = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
849 error_setg_win32(errp, GetLastError(), "Failed to CreateFileMapping");
853 bits = MapViewOfFile(*h, FILE_MAP_ALL_ACCESS, 0, 0, size);
855 error_setg_win32(errp, GetLastError(), "Failed to MapViewOfFile");
863 void qemu_win32_map_free(void *ptr, HANDLE h, Error **errp)
865 trace_win32_map_free(ptr, h);
867 if (UnmapViewOfFile(ptr) == 0) {
868 error_setg_win32(errp, GetLastError(), "Failed to UnmapViewOfFile");