[mirror_qemu.git] / util / oslib-win32.c

/*
 * os-win32.c
 *
 * Copyright (c) 2003-2008 Fabrice Bellard
 * Copyright (c) 2010-2016 Red Hat, Inc.
 *
 * QEMU library functions for win32 which are shared between QEMU and
 * the QEMU tools.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"
#include <windows.h>
#include "qapi/error.h"
#include "qemu/main-loop.h"
#include "trace.h"
#include "qemu/sockets.h"
#include "qemu/cutils.h"
#include "qemu/error-report.h"
#include <malloc.h>

static int get_allocation_granularity(void)
{
    SYSTEM_INFO system_info;

    GetSystemInfo(&system_info);
    return system_info.dwAllocationGranularity;
}

void *qemu_anon_ram_alloc(size_t size, uint64_t *align, bool shared,
                          bool noreserve)
{
    void *ptr;

    if (noreserve) {
        /*
         * We need a MEM_COMMIT before accessing any memory in a MEM_RESERVE
         * area; we cannot easily mimic POSIX MAP_NORESERVE semantics.
         */
        error_report("Skipping reservation of swap space is not supported.");
        return NULL;
    }

    ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
    trace_qemu_anon_ram_alloc(size, ptr);

    if (ptr && align) {
        *align = MAX(get_allocation_granularity(), getpagesize());
    }
    return ptr;
}

void qemu_anon_ram_free(void *ptr, size_t size)
{
    trace_qemu_anon_ram_free(ptr, size);
    if (ptr) {
        VirtualFree(ptr, 0, MEM_RELEASE);
    }
}

#ifndef _POSIX_THREAD_SAFE_FUNCTIONS
/* FIXME: add proper locking */
struct tm *gmtime_r(const time_t *timep, struct tm *result)
{
    struct tm *p = gmtime(timep);
    memset(result, 0, sizeof(*result));
    if (p) {
        *result = *p;
        p = result;
    }
    return p;
}

/* FIXME: add proper locking */
struct tm *localtime_r(const time_t *timep, struct tm *result)
{
    struct tm *p = localtime(timep);
    memset(result, 0, sizeof(*result));
    if (p) {
        *result = *p;
        p = result;
    }
    return p;
}
#endif /* _POSIX_THREAD_SAFE_FUNCTIONS */

static int socket_error(void)
{
    switch (WSAGetLastError()) {
    case 0:
        return 0;
    case WSAEINTR:
        return EINTR;
    case WSAEINVAL:
        return EINVAL;
    case WSA_INVALID_HANDLE:
        return EBADF;
    case WSA_NOT_ENOUGH_MEMORY:
        return ENOMEM;
    case WSA_INVALID_PARAMETER:
        return EINVAL;
    case WSAENAMETOOLONG:
        return ENAMETOOLONG;
    case WSAENOTEMPTY:
        return ENOTEMPTY;
    case WSAEWOULDBLOCK:
         /* not using EWOULDBLOCK as we don't want code to have
          * to check both EWOULDBLOCK and EAGAIN */
        return EAGAIN;
    case WSAEINPROGRESS:
        return EINPROGRESS;
    case WSAEALREADY:
        return EALREADY;
    case WSAENOTSOCK:
        return ENOTSOCK;
    case WSAEDESTADDRREQ:
        return EDESTADDRREQ;
    case WSAEMSGSIZE:
        return EMSGSIZE;
    case WSAEPROTOTYPE:
        return EPROTOTYPE;
    case WSAENOPROTOOPT:
        return ENOPROTOOPT;
    case WSAEPROTONOSUPPORT:
        return EPROTONOSUPPORT;
    case WSAEOPNOTSUPP:
        return EOPNOTSUPP;
    case WSAEAFNOSUPPORT:
        return EAFNOSUPPORT;
    case WSAEADDRINUSE:
        return EADDRINUSE;
    case WSAEADDRNOTAVAIL:
        return EADDRNOTAVAIL;
    case WSAENETDOWN:
        return ENETDOWN;
    case WSAENETUNREACH:
        return ENETUNREACH;
    case WSAENETRESET:
        return ENETRESET;
    case WSAECONNABORTED:
        return ECONNABORTED;
    case WSAECONNRESET:
        return ECONNRESET;
    case WSAENOBUFS:
        return ENOBUFS;
    case WSAEISCONN:
        return EISCONN;
    case WSAENOTCONN:
        return ENOTCONN;
    case WSAETIMEDOUT:
        return ETIMEDOUT;
    case WSAECONNREFUSED:
        return ECONNREFUSED;
    case WSAELOOP:
        return ELOOP;
    case WSAEHOSTUNREACH:
        return EHOSTUNREACH;
    default:
        return EIO;
    }
}

void qemu_socket_set_block(int fd)
{
    unsigned long opt = 0;
    qemu_socket_unselect(fd, NULL);
    ioctlsocket(fd, FIONBIO, &opt);
}

int qemu_socket_try_set_nonblock(int fd)
{
    unsigned long opt = 1;
    if (ioctlsocket(fd, FIONBIO, &opt) != NO_ERROR) {
        return -socket_error();
    }
    return 0;
}

void qemu_socket_set_nonblock(int fd)
{
    (void)qemu_socket_try_set_nonblock(fd);
}

int socket_set_fast_reuse(int fd)
{
    /* Enabling the reuse of an endpoint that was used by a socket still in
     * TIME_WAIT state is usually performed by setting SO_REUSEADDR. On Windows
     * fast reuse is the default and SO_REUSEADDR does strange things. So we
     * don't have to do anything here. More info can be found at:
     * http://msdn.microsoft.com/en-us/library/windows/desktop/ms740621.aspx */
    return 0;
}

int inet_aton(const char *cp, struct in_addr *ia)
{
    uint32_t addr = inet_addr(cp);
    if (addr == 0xffffffff) {
        return 0;
    }
    ia->s_addr = addr;
    return 1;
}

void qemu_set_cloexec(int fd)
{
}

int qemu_get_thread_id(void)
{
    return GetCurrentThreadId();
}

char *
qemu_get_local_state_dir(void)
{
    const char * const *data_dirs = g_get_system_data_dirs();

    g_assert(data_dirs && data_dirs[0]);

    return g_strdup(data_dirs[0]);
}

void qemu_set_tty_echo(int fd, bool echo)
{
    HANDLE handle = (HANDLE)_get_osfhandle(fd);
    DWORD dwMode = 0;

    if (handle == INVALID_HANDLE_VALUE) {
        return;
    }

    GetConsoleMode(handle, &dwMode);

    if (echo) {
        SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);
    } else {
        SetConsoleMode(handle,
                       dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT));
    }
}

int getpagesize(void)
{
    SYSTEM_INFO system_info;

    GetSystemInfo(&system_info);
    return system_info.dwPageSize;
}

bool qemu_prealloc_mem(int fd, char *area, size_t sz, int max_threads,
                       ThreadContext *tc, bool async, Error **errp)
{
    int i;
    size_t pagesize = qemu_real_host_page_size();

    sz = (sz + pagesize - 1) & -pagesize;
    for (i = 0; i < sz / pagesize; i++) {
        memset(area + pagesize * i, 0, 1);
    }

    return true;
}

bool qemu_finish_async_prealloc_mem(Error **errp)
{
    /* async prealloc not supported, there is nothing to finish */
    return true;
}

char *qemu_get_pid_name(pid_t pid)
{
    /* XXX Implement me */
    abort();
}


bool qemu_socket_select(int sockfd, WSAEVENT hEventObject,
                        long lNetworkEvents, Error **errp)
{
    SOCKET s = _get_osfhandle(sockfd);

    if (errp == NULL) {
        errp = &error_warn;
    }

    if (s == INVALID_SOCKET) {
        error_setg(errp, "invalid socket fd=%d", sockfd);
        return false;
    }

    if (WSAEventSelect(s, hEventObject, lNetworkEvents) != 0) {
        error_setg_win32(errp, WSAGetLastError(), "failed to WSAEventSelect()");
        return false;
    }

    return true;
}

bool qemu_socket_unselect(int sockfd, Error **errp)
{
    return qemu_socket_select(sockfd, NULL, 0, errp);
}

int qemu_socketpair(int domain, int type, int protocol, int sv[2])
{
    struct sockaddr_un addr = {
        0,
    };
    socklen_t socklen;
    int listener = -1;
    int client = -1;
    int server = -1;
    g_autofree char *path = NULL;
    int tmpfd;
    u_long arg;
    int ret = -1;

    g_return_val_if_fail(sv != NULL, -1);

    addr.sun_family = AF_UNIX;
    socklen = sizeof(addr);

    tmpfd = g_file_open_tmp(NULL, &path, NULL);
    if (tmpfd == -1 || !path) {
        errno = EACCES;
        goto out;
    }

    close(tmpfd);

    if (strlen(path) >= sizeof(addr.sun_path)) {
        errno = EINVAL;
        goto out;
    }

    strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);

    listener = socket(domain, type, protocol);
    if (listener == -1) {
        goto out;
    }

    if (DeleteFile(path) == 0 && GetLastError() != ERROR_FILE_NOT_FOUND) {
        errno = EACCES;
        goto out;
    }
    g_clear_pointer(&path, g_free);

    if (bind(listener, (struct sockaddr *)&addr, socklen) == -1) {
        goto out;
    }

    if (listen(listener, 1) == -1) {
        goto out;
    }

    client = socket(domain, type, protocol);
    if (client == -1) {
        goto out;
    }

    arg = 1;
    if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
        goto out;
    }

    if (connect(client, (struct sockaddr *)&addr, socklen) == -1 &&
        WSAGetLastError() != WSAEWOULDBLOCK) {
        goto out;
    }

    server = accept(listener, NULL, NULL);
    if (server == -1) {
        goto out;
    }

    arg = 0;
    if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
        goto out;
    }

    arg = 0;
    if (ioctlsocket(client, SIO_AF_UNIX_GETPEERPID, &arg) != NO_ERROR) {
        goto out;
    }

    if (arg != GetCurrentProcessId()) {
        errno = EPERM;
        goto out;
    }

    sv[0] = server;
    server = -1;
    sv[1] = client;
    client = -1;
    ret = 0;

out:
    if (listener != -1) {
        close(listener);
    }
    if (client != -1) {
        close(client);
    }
    if (server != -1) {
        close(server);
    }
    if (path) {
        DeleteFile(path);
    }
    return ret;
}

#undef connect
int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
                      socklen_t addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = connect(s, addr, addrlen);
    if (ret < 0) {
        if (WSAGetLastError() == WSAEWOULDBLOCK) {
            errno = EINPROGRESS;
        } else {
            errno = socket_error();
        }
    }
    return ret;
}


#undef listen
int qemu_listen_wrap(int sockfd, int backlog)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = listen(s, backlog);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef bind
int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = bind(s, addr, addrlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}

QEMU_USED EXCEPTION_DISPOSITION
win32_close_exception_handler(struct _EXCEPTION_RECORD *exception_record,
                              void *registration, struct _CONTEXT *context,
                              void *dispatcher)
{
    return EXCEPTION_EXECUTE_HANDLER;
}

#undef close
int qemu_close_socket_osfhandle(int fd)
{
    SOCKET s = _get_osfhandle(fd);
    DWORD flags = 0;

    /*
     * If we were to just call _close on the descriptor, it would close the
     * HANDLE, but it wouldn't free any of the resources associated to the
     * SOCKET, and we can't call _close after calling closesocket, because
     * closesocket has already closed the HANDLE, and _close would attempt to
     * close the HANDLE again, resulting in a double free. We can however
     * protect the HANDLE from actually being closed long enough to close the
     * file descriptor, then close the socket itself.
     */
    if (!GetHandleInformation((HANDLE)s, &flags)) {
        errno = EACCES;
        return -1;
    }

    if (!SetHandleInformation((HANDLE)s, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE)) {
        errno = EACCES;
        return -1;
    }

    __try1(win32_close_exception_handler) {
        /*
         * close() returns EBADF since we PROTECT_FROM_CLOSE the underlying
         * handle, but the FD is actually freed
         */
        if (close(fd) < 0 && errno != EBADF) {
            return -1;
        }
    }
    __except1 {
    }

    if (!SetHandleInformation((HANDLE)s, flags, flags)) {
        errno = EACCES;
        return -1;
    }

    return 0;
}

int qemu_close_wrap(int fd)
{
    SOCKET s = INVALID_SOCKET;
    int ret = -1;

    if (!fd_is_socket(fd)) {
        return close(fd);
    }

    s = _get_osfhandle(fd);
    qemu_close_socket_osfhandle(fd);

    ret = closesocket(s);
    if (ret < 0) {
        errno = socket_error();
    }

    return ret;
}


#undef socket
int qemu_socket_wrap(int domain, int type, int protocol)
{
    SOCKET s;
    int fd;

    s = socket(domain, type, protocol);
    if (s == -1) {
        errno = socket_error();
        return -1;
    }

    fd = _open_osfhandle(s, _O_BINARY);
    if (fd < 0) {
        closesocket(s);
        /* _open_osfhandle may not set errno, and closesocket() may override it */
        errno = ENOMEM;
    }

    return fd;
}


#undef accept
int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
                     socklen_t *addrlen)
{
    int fd;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    s = accept(s, addr, addrlen);
    if (s == -1) {
        errno = socket_error();
        return -1;
    }

    fd = _open_osfhandle(s, _O_BINARY);
    if (fd < 0) {
        closesocket(s);
        /* _open_osfhandle may not set errno, and closesocket() may override it */
        errno = ENOMEM;
    }

    return fd;
}


#undef shutdown
int qemu_shutdown_wrap(int sockfd, int how)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = shutdown(s, how);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef ioctlsocket
int qemu_ioctlsocket_wrap(int fd, int req, void *val)
{
    int ret;
    SOCKET s = _get_osfhandle(fd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = ioctlsocket(s, req, val);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef getsockopt
int qemu_getsockopt_wrap(int sockfd, int level, int optname,
                         void *optval, socklen_t *optlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = getsockopt(s, level, optname, optval, optlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef setsockopt
int qemu_setsockopt_wrap(int sockfd, int level, int optname,
                         const void *optval, socklen_t optlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = setsockopt(s, level, optname, optval, optlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef getpeername
int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
                          socklen_t *addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = getpeername(s, addr, addrlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef getsockname
int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
                          socklen_t *addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = getsockname(s, addr, addrlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef send
ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = send(s, buf, len, flags);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef sendto
ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
                         const struct sockaddr *addr, socklen_t addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = sendto(s, buf, len, flags, addr, addrlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef recv
ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = recv(s, buf, len, flags);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}


#undef recvfrom
ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
                           struct sockaddr *addr, socklen_t *addrlen)
{
    int ret;
    SOCKET s = _get_osfhandle(sockfd);

    if (s == INVALID_SOCKET) {
        return -1;
    }

    ret = recvfrom(s, buf, len, flags, addr, addrlen);
    if (ret < 0) {
        errno = socket_error();
    }
    return ret;
}

bool qemu_write_pidfile(const char *filename, Error **errp)
{
    char buffer[128];
    int len;
    HANDLE file;
    OVERLAPPED overlap;
    BOOL ret;
    memset(&overlap, 0, sizeof(overlap));

    file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
                      OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

    if (file == INVALID_HANDLE_VALUE) {
        error_setg(errp, "Failed to create PID file");
        return false;
    }
    len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid());
    ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len,
                    NULL, &overlap);
    CloseHandle(file);
    if (ret == 0) {
        error_setg(errp, "Failed to write PID file");
        return false;
    }
    return true;
}

size_t qemu_get_host_physmem(void)
{
    MEMORYSTATUSEX statex;
    statex.dwLength = sizeof(statex);

    if (GlobalMemoryStatusEx(&statex)) {
        return statex.ullTotalPhys;
    }
    return 0;
}

int qemu_msync(void *addr, size_t length, int fd)
{
    /**
     * Perform the sync based on the file descriptor
     * The sync range will most probably be wider than the one
     * requested - but it will still get the job done
     */
    return qemu_fdatasync(fd);
}

void *qemu_win32_map_alloc(size_t size, HANDLE *h, Error **errp)
{
    void *bits;

    trace_win32_map_alloc(size);

    *h = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
                          size, NULL);
    if (*h == NULL) {
        error_setg_win32(errp, GetLastError(), "Failed to CreateFileMapping");
        return NULL;
    }

    bits = MapViewOfFile(*h, FILE_MAP_ALL_ACCESS, 0, 0, size);
    if (bits == NULL) {
        error_setg_win32(errp, GetLastError(), "Failed to MapViewOfFile");
        CloseHandle(*h);
        return NULL;
    }

    return bits;
}

void qemu_win32_map_free(void *ptr, HANDLE h, Error **errp)
{
    trace_win32_map_free(ptr, h);

    if (UnmapViewOfFile(ptr) == 0) {
        error_setg_win32(errp, GetLastError(), "Failed to UnmapViewOfFile");
    }
    CloseHandle(h);
}
Commit	Line	Data
c1b0b93b JS	1	/*
	2	* os-win32.c
	3	*
	4	* Copyright (c) 2003-2008 Fabrice Bellard
c6196440	5	* Copyright (c) 2010-2016 Red Hat, Inc.
c1b0b93b JS	6	*
	7	* QEMU library functions for win32 which are shared between QEMU and
	8	* the QEMU tools.
	9	*
	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:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	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
	26	* THE SOFTWARE.
	27	*/
a8d25326	28
aafd7584	29	#include "qemu/osdep.h"
c1b0b93b	30	#include <windows.h>
da34e65c	31	#include "qapi/error.h"
1de7afc9	32	#include "qemu/main-loop.h"
c1b0b93b	33	#include "trace.h"
1de7afc9	34	#include "qemu/sockets.h"
f348b6d1	35	#include "qemu/cutils.h"
8dbe22c6	36	#include "qemu/error-report.h"
dfbd0b87	37	#include <malloc.h>
c1b0b93b	38
714efd54 DH	39	static int get_allocation_granularity(void)
	40	{
	41	SYSTEM_INFO system_info;
	42
	43	GetSystemInfo(&system_info);
	44	return system_info.dwAllocationGranularity;
	45	}
	46
8dbe22c6 DH	47	void qemu_anon_ram_alloc(size_t size, uint64_t align, bool shared,
8dbe22c6 DH	48	bool noreserve)
c1b0b93b JS	49	{
	50	void *ptr;
	51
8dbe22c6 DH	52	if (noreserve) {
	53	/*
	54	* We need a MEM_COMMIT before accessing any memory in a MEM_RESERVE
	55	* area; we cannot easily mimic POSIX MAP_NORESERVE semantics.
	56	*/
	57	error_report("Skipping reservation of swap space is not supported.");
	58	return NULL;
	59	}
	60
39228250	61	ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
6eebf958	62	trace_qemu_anon_ram_alloc(size, ptr);
714efd54 DH	63
	64	if (ptr && align) {
	65	*align = MAX(get_allocation_granularity(), getpagesize());
	66	}
c1b0b93b JS	67	return ptr;
	68	}
	69
e7a09b92 PB	70	void qemu_anon_ram_free(void *ptr, size_t size)
	71	{
	72	trace_qemu_anon_ram_free(ptr, size);
	73	if (ptr) {
	74	VirtualFree(ptr, 0, MEM_RELEASE);
	75	}
	76	}
	77
7c3afc85	78	#ifndef _POSIX_THREAD_SAFE_FUNCTIONS
d3e8f957 SW	79	/* FIXME: add proper locking */
	80	struct tm gmtime_r(const time_t timep, struct tm *result)
	81	{
	82	struct tm *p = gmtime(timep);
	83	memset(result, 0, sizeof(*result));
	84	if (p) {
	85	result = p;
	86	p = result;
	87	}
	88	return p;
	89	}
	90
	91	/* FIXME: add proper locking */
	92	struct tm localtime_r(const time_t timep, struct tm *result)
	93	{
	94	struct tm *p = localtime(timep);
	95	memset(result, 0, sizeof(*result));
	96	if (p) {
	97	result = p;
	98	p = result;
	99	}
	100	return p;
	101	}
7c3afc85	102	#endif /* _POSIX_THREAD_SAFE_FUNCTIONS */
d3e8f957	103
b16a44e1	104	static int socket_error(void)
c6196440 DB	105	{
	106	switch (WSAGetLastError()) {
	107	case 0:
	108	return 0;
	109	case WSAEINTR:
	110	return EINTR;
	111	case WSAEINVAL:
	112	return EINVAL;
	113	case WSA_INVALID_HANDLE:
	114	return EBADF;
	115	case WSA_NOT_ENOUGH_MEMORY:
	116	return ENOMEM;
	117	case WSA_INVALID_PARAMETER:
	118	return EINVAL;
	119	case WSAENAMETOOLONG:
	120	return ENAMETOOLONG;
	121	case WSAENOTEMPTY:
	122	return ENOTEMPTY;
	123	case WSAEWOULDBLOCK:
	124	/* not using EWOULDBLOCK as we don't want code to have
	125	* to check both EWOULDBLOCK and EAGAIN */
	126	return EAGAIN;
	127	case WSAEINPROGRESS:
	128	return EINPROGRESS;
	129	case WSAEALREADY:
	130	return EALREADY;
	131	case WSAENOTSOCK:
	132	return ENOTSOCK;
	133	case WSAEDESTADDRREQ:
	134	return EDESTADDRREQ;
	135	case WSAEMSGSIZE:
	136	return EMSGSIZE;
	137	case WSAEPROTOTYPE:
	138	return EPROTOTYPE;
	139	case WSAENOPROTOOPT:
	140	return ENOPROTOOPT;
	141	case WSAEPROTONOSUPPORT:
	142	return EPROTONOSUPPORT;
	143	case WSAEOPNOTSUPP:
	144	return EOPNOTSUPP;
	145	case WSAEAFNOSUPPORT:
	146	return EAFNOSUPPORT;
	147	case WSAEADDRINUSE:
	148	return EADDRINUSE;
	149	case WSAEADDRNOTAVAIL:
	150	return EADDRNOTAVAIL;
	151	case WSAENETDOWN:
	152	return ENETDOWN;
	153	case WSAENETUNREACH:
	154	return ENETUNREACH;
	155	case WSAENETRESET:
	156	return ENETRESET;
	157	case WSAECONNABORTED:
	158	return ECONNABORTED;
	159	case WSAECONNRESET:
	160	return ECONNRESET;
	161	case WSAENOBUFS:
	162	return ENOBUFS;
	163	case WSAEISCONN:
	164	return EISCONN;
	165	case WSAENOTCONN:
	166	return ENOTCONN;
	167	case WSAETIMEDOUT:
	168	return ETIMEDOUT;
169	case WSAECONNREFUSED:
170	return ECONNREFUSED;
171	case WSAELOOP:
172	return ELOOP;
173	case WSAEHOSTUNREACH:
174	return EHOSTUNREACH;
175	default:
176	return EIO;
177	}
178	}
179
ff5927ba	180	void qemu_socket_set_block(int fd)
894022e6 LV	181	{
894022e6 LV	182	unsigned long opt = 0;
a4aafea2	183	qemu_socket_unselect(fd, NULL);
894022e6 LV	184	ioctlsocket(fd, FIONBIO, &opt);
	185	}
	186
ff5927ba	187	int qemu_socket_try_set_nonblock(int fd)
894022e6 LV	188	{
	189	unsigned long opt = 1;
	190	if (ioctlsocket(fd, FIONBIO, &opt) != NO_ERROR) {
	191	return -socket_error();
	192	}
894022e6 LV	193	return 0;
	194	}
	195
ff5927ba	196	void qemu_socket_set_nonblock(int fd)
894022e6	197	{
ff5927ba	198	(void)qemu_socket_try_set_nonblock(fd);
894022e6 LV	199	}
	200
	201	int socket_set_fast_reuse(int fd)
	202	{
	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 */
	208	return 0;
	209	}
	210
9549e764 JS	211	int inet_aton(const char cp, struct in_addr ia)
	212	{
	213	uint32_t addr = inet_addr(cp);
	214	if (addr == 0xffffffff) {
e637aa66	215	return 0;
9549e764 JS	216	}
	217	ia->s_addr = addr;
	218	return 1;
	219	}
	220
	221	void qemu_set_cloexec(int fd)
	222	{
	223	}
dc786bc9	224
cbcfa041 PB	225	int qemu_get_thread_id(void)
	226	{
	227	return GetCurrentThreadId();
	228	}
e2ea3515 LE	229
e2ea3515 LE	230	char *
1fbf2665	231	qemu_get_local_state_dir(void)
e2ea3515	232	{
49e0128c	233	const char * const *data_dirs = g_get_system_data_dirs();
e2ea3515	234
49e0128c MAL	235	g_assert(data_dirs && data_dirs[0]);
	236
	237	return g_strdup(data_dirs[0]);
e2ea3515	238	}
13401ba0 SH	239
	240	void qemu_set_tty_echo(int fd, bool echo)
	241	{
	242	HANDLE handle = (HANDLE)_get_osfhandle(fd);
	243	DWORD dwMode = 0;
	244
	245	if (handle == INVALID_HANDLE_VALUE) {
	246	return;
	247	}
	248
	249	GetConsoleMode(handle, &dwMode);
	250
	251	if (echo) {
	252	SetConsoleMode(handle, dwMode \| ENABLE_ECHO_INPUT \| ENABLE_LINE_INPUT);
	253	} else {
	254	SetConsoleMode(handle,
	255	dwMode & ~(ENABLE_ECHO_INPUT \| ENABLE_LINE_INPUT));
	256	}
	257	}
10f5bff6	258
a28c2f2d	259	int getpagesize(void)
38183310 PB	260	{
	261	SYSTEM_INFO system_info;
	262
	263	GetSystemInfo(&system_info);
	264	return system_info.dwPageSize;
	265	}
	266
b622ee98	267	bool qemu_prealloc_mem(int fd, char *area, size_t sz, int max_threads,
04accf43	268	ThreadContext tc, bool async, Error *errp)
38183310 PB	269	{
38183310 PB	270	int i;
8e3b0cbb	271	size_t pagesize = qemu_real_host_page_size();
38183310	272
6556aadc DH	273	sz = (sz + pagesize - 1) & -pagesize;
6556aadc DH	274	for (i = 0; i < sz / pagesize; i++) {
38183310 PB	275	memset(area + pagesize * i, 0, 1);
38183310 PB	276	}
b622ee98 PMD	277
b622ee98 PMD	278	return true;
38183310	279	}
d57e4e48	280
04accf43 MK	281	bool qemu_finish_async_prealloc_mem(Error **errp)
	282	{
	283	/* async prealloc not supported, there is nothing to finish */
	284	return true;
	285	}
	286
7dc9ae43 MP	287	char *qemu_get_pid_name(pid_t pid)
	288	{
	289	/* XXX Implement me */
	290	abort();
	291	}
	292
	293
abe34282	294	bool qemu_socket_select(int sockfd, WSAEVENT hEventObject,
f5fd677a MAL	295	long lNetworkEvents, Error **errp)
f5fd677a MAL	296	{
abe34282 MAL	297	SOCKET s = _get_osfhandle(sockfd);
abe34282 MAL	298
f5fd677a MAL	299	if (errp == NULL) {
	300	errp = &error_warn;
	301	}
	302
abe34282 MAL	303	if (s == INVALID_SOCKET) {
	304	error_setg(errp, "invalid socket fd=%d", sockfd);
	305	return false;
	306	}
	307
f5fd677a MAL	308	if (WSAEventSelect(s, hEventObject, lNetworkEvents) != 0) {
	309	error_setg_win32(errp, WSAGetLastError(), "failed to WSAEventSelect()");
	310	return false;
	311	}
	312
	313	return true;
	314	}
	315
abe34282	316	bool qemu_socket_unselect(int sockfd, Error **errp)
a4aafea2	317	{
abe34282	318	return qemu_socket_select(sockfd, NULL, 0, errp);
a4aafea2 MAL	319	}
a4aafea2 MAL	320
0a237f4d MAL	321	int qemu_socketpair(int domain, int type, int protocol, int sv[2])
	322	{
	323	struct sockaddr_un addr = {
	324	0,
	325	};
	326	socklen_t socklen;
	327	int listener = -1;
	328	int client = -1;
	329	int server = -1;
	330	g_autofree char *path = NULL;
	331	int tmpfd;
	332	u_long arg;
	333	int ret = -1;
	334
	335	g_return_val_if_fail(sv != NULL, -1);
	336
	337	addr.sun_family = AF_UNIX;
	338	socklen = sizeof(addr);
	339
	340	tmpfd = g_file_open_tmp(NULL, &path, NULL);
	341	if (tmpfd == -1 \|\| !path) {
	342	errno = EACCES;
	343	goto out;
	344	}
	345
	346	close(tmpfd);
	347
	348	if (strlen(path) >= sizeof(addr.sun_path)) {
	349	errno = EINVAL;
	350	goto out;
	351	}
	352
	353	strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
	354
	355	listener = socket(domain, type, protocol);
	356	if (listener == -1) {
	357	goto out;
	358	}
	359
	360	if (DeleteFile(path) == 0 && GetLastError() != ERROR_FILE_NOT_FOUND) {
	361	errno = EACCES;
	362	goto out;
	363	}
	364	g_clear_pointer(&path, g_free);
	365
	366	if (bind(listener, (struct sockaddr *)&addr, socklen) == -1) {
	367	goto out;
	368	}
	369
	370	if (listen(listener, 1) == -1) {
	371	goto out;
	372	}
	373
	374	client = socket(domain, type, protocol);
	375	if (client == -1) {
	376	goto out;
	377	}
	378
	379	arg = 1;
	380	if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
	381	goto out;
	382	}
	383
	384	if (connect(client, (struct sockaddr *)&addr, socklen) == -1 &&
385	WSAGetLastError() != WSAEWOULDBLOCK) {
386	goto out;
387	}
388
389	server = accept(listener, NULL, NULL);
390	if (server == -1) {
391	goto out;
392	}
393
394	arg = 0;
395	if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
396	goto out;
397	}
398
399	arg = 0;
400	if (ioctlsocket(client, SIO_AF_UNIX_GETPEERPID, &arg) != NO_ERROR) {
401	goto out;
402	}
403
404	if (arg != GetCurrentProcessId()) {
405	errno = EPERM;
406	goto out;
407	}
408
409	sv[0] = server;
410	server = -1;
411	sv[1] = client;
412	client = -1;
413	ret = 0;
414
415	out:
416	if (listener != -1) {
417	close(listener);
418	}
419	if (client != -1) {
420	close(client);
421	}
422	if (server != -1) {
423	close(server);
424	}
425	if (path) {
426	DeleteFile(path);
427	}
428	return ret;
429	}
430
a2d96af4 DB	431	#undef connect
	432	int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
	433	socklen_t addrlen)
	434	{
	435	int ret;
abe34282 MAL	436	SOCKET s = _get_osfhandle(sockfd);
	437
	438	if (s == INVALID_SOCKET) {
	439	return -1;
	440	}
	441
	442	ret = connect(s, addr, addrlen);
a2d96af4	443	if (ret < 0) {
f1cd5d41 MAL	444	if (WSAGetLastError() == WSAEWOULDBLOCK) {
	445	errno = EINPROGRESS;
	446	} else {
	447	errno = socket_error();
	448	}
a2d96af4 DB	449	}
	450	return ret;
	451	}
	452
	453
	454	#undef listen
	455	int qemu_listen_wrap(int sockfd, int backlog)
	456	{
	457	int ret;
abe34282 MAL	458	SOCKET s = _get_osfhandle(sockfd);
	459
	460	if (s == INVALID_SOCKET) {
	461	return -1;
	462	}
	463
	464	ret = listen(s, backlog);
a2d96af4 DB	465	if (ret < 0) {
	466	errno = socket_error();
	467	}
	468	return ret;
	469	}
	470
	471
	472	#undef bind
	473	int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
	474	socklen_t addrlen)
	475	{
	476	int ret;
abe34282 MAL	477	SOCKET s = _get_osfhandle(sockfd);
	478
	479	if (s == INVALID_SOCKET) {
	480	return -1;
	481	}
	482
	483	ret = bind(s, addr, addrlen);
a2d96af4 DB	484	if (ret < 0) {
	485	errno = socket_error();
	486	}
	487	return ret;
	488	}
	489
75b773d8	490	QEMU_USED EXCEPTION_DISPOSITION
c5b5288c TH	491	win32_close_exception_handler(struct _EXCEPTION_RECORD *exception_record,
	492	void registration, struct _CONTEXT context,
	493	void *dispatcher)
d89f30b4 MAL	494	{
	495	return EXCEPTION_EXECUTE_HANDLER;
	496	}
	497
25657fc6	498	#undef close
f3ab43ac	499	int qemu_close_socket_osfhandle(int fd)
a2d96af4	500	{
f3ab43ac	501	SOCKET s = _get_osfhandle(fd);
abe34282	502	DWORD flags = 0;
abe34282	503
f3ab43ac MAL	504	/*
	505	* If we were to just call _close on the descriptor, it would close the
	506	* HANDLE, but it wouldn't free any of the resources associated to the
	507	* SOCKET, and we can't call _close after calling closesocket, because
	508	* closesocket has already closed the HANDLE, and _close would attempt to
	509	* close the HANDLE again, resulting in a double free. We can however
	510	* protect the HANDLE from actually being closed long enough to close the
	511	* file descriptor, then close the socket itself.
	512	*/
	513	if (!GetHandleInformation((HANDLE)s, &flags)) {
	514	errno = EACCES;
	515	return -1;
abe34282 MAL	516	}
abe34282 MAL	517
f3ab43ac	518	if (!SetHandleInformation((HANDLE)s, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE)) {
abe34282 MAL	519	errno = EACCES;
	520	return -1;
	521	}
	522
d89f30b4 MAL	523	__try1(win32_close_exception_handler) {
	524	/*
	525	* close() returns EBADF since we PROTECT_FROM_CLOSE the underlying
	526	* handle, but the FD is actually freed
	527	*/
	528	if (close(fd) < 0 && errno != EBADF) {
	529	return -1;
	530	}
	531	}
	532	__except1 {
abe34282 MAL	533	}
abe34282 MAL	534
f3ab43ac MAL	535	if (!SetHandleInformation((HANDLE)s, flags, flags)) {
	536	errno = EACCES;
	537	return -1;
	538	}
	539
	540	return 0;
	541	}
	542
	543	int qemu_close_wrap(int fd)
	544	{
	545	SOCKET s = INVALID_SOCKET;
	546	int ret = -1;
	547
	548	if (!fd_is_socket(fd)) {
	549	return close(fd);
	550	}
	551
	552	s = _get_osfhandle(fd);
	553	qemu_close_socket_osfhandle(fd);
	554
	555	ret = closesocket(s);
	556	if (ret < 0) {
	557	errno = socket_error();
a2d96af4	558	}
abe34282	559
a2d96af4 DB	560	return ret;
	561	}
	562
	563
abe34282 MAL	564	#undef socket
	565	int qemu_socket_wrap(int domain, int type, int protocol)
	566	{
	567	SOCKET s;
	568	int fd;
	569
	570	s = socket(domain, type, protocol);
	571	if (s == -1) {
	572	errno = socket_error();
	573	return -1;
	574	}
	575
	576	fd = _open_osfhandle(s, _O_BINARY);
	577	if (fd < 0) {
	578	closesocket(s);
	579	/* _open_osfhandle may not set errno, and closesocket() may override it */
	580	errno = ENOMEM;
	581	}
	582
	583	return fd;
	584	}
	585
	586
a2d96af4 DB	587	#undef accept
	588	int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
	589	socklen_t *addrlen)
	590	{
abe34282 MAL	591	int fd;
	592	SOCKET s = _get_osfhandle(sockfd);
	593
	594	if (s == INVALID_SOCKET) {
	595	return -1;
	596	}
	597
	598	s = accept(s, addr, addrlen);
	599	if (s == -1) {
a2d96af4	600	errno = socket_error();
abe34282	601	return -1;
a2d96af4	602	}
abe34282 MAL	603
	604	fd = _open_osfhandle(s, _O_BINARY);
	605	if (fd < 0) {
	606	closesocket(s);
	607	/* _open_osfhandle may not set errno, and closesocket() may override it */
	608	errno = ENOMEM;
	609	}
	610
	611	return fd;
a2d96af4 DB	612	}
	613
	614
	615	#undef shutdown
	616	int qemu_shutdown_wrap(int sockfd, int how)
	617	{
	618	int ret;
abe34282 MAL	619	SOCKET s = _get_osfhandle(sockfd);
	620
	621	if (s == INVALID_SOCKET) {
	622	return -1;
	623	}
	624
	625	ret = shutdown(s, how);
a2d96af4 DB	626	if (ret < 0) {
	627	errno = socket_error();
	628	}
	629	return ret;
	630	}
	631
	632
	633	#undef ioctlsocket
	634	int qemu_ioctlsocket_wrap(int fd, int req, void *val)
	635	{
	636	int ret;
abe34282	637	SOCKET s = _get_osfhandle(fd);
a2d96af4	638
abe34282 MAL	639	if (s == INVALID_SOCKET) {
	640	return -1;
	641	}
a2d96af4	642
abe34282	643	ret = ioctlsocket(s, req, val);
a2d96af4 DB	644	if (ret < 0) {
	645	errno = socket_error();
	646	}
	647	return ret;
	648	}
	649
	650
	651	#undef getsockopt
	652	int qemu_getsockopt_wrap(int sockfd, int level, int optname,
	653	void optval, socklen_t optlen)
	654	{
	655	int ret;
abe34282 MAL	656	SOCKET s = _get_osfhandle(sockfd);
	657
	658	if (s == INVALID_SOCKET) {
	659	return -1;
	660	}
	661
	662	ret = getsockopt(s, level, optname, optval, optlen);
a2d96af4 DB	663	if (ret < 0) {
	664	errno = socket_error();
	665	}
	666	return ret;
	667	}
	668
	669
	670	#undef setsockopt
	671	int qemu_setsockopt_wrap(int sockfd, int level, int optname,
	672	const void *optval, socklen_t optlen)
	673	{
	674	int ret;
abe34282 MAL	675	SOCKET s = _get_osfhandle(sockfd);
	676
	677	if (s == INVALID_SOCKET) {
	678	return -1;
	679	}
	680
	681	ret = setsockopt(s, level, optname, optval, optlen);
a2d96af4 DB	682	if (ret < 0) {
	683	errno = socket_error();
	684	}
	685	return ret;
	686	}
	687
	688
	689	#undef getpeername
	690	int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
	691	socklen_t *addrlen)
	692	{
	693	int ret;
abe34282 MAL	694	SOCKET s = _get_osfhandle(sockfd);
	695
	696	if (s == INVALID_SOCKET) {
	697	return -1;
	698	}
	699
	700	ret = getpeername(s, addr, addrlen);
a2d96af4 DB	701	if (ret < 0) {
	702	errno = socket_error();
	703	}
	704	return ret;
	705	}
	706
	707
	708	#undef getsockname
	709	int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
	710	socklen_t *addrlen)
	711	{
	712	int ret;
abe34282 MAL	713	SOCKET s = _get_osfhandle(sockfd);
	714
	715	if (s == INVALID_SOCKET) {
	716	return -1;
	717	}
	718
	719	ret = getsockname(s, addr, addrlen);
a2d96af4 DB	720	if (ret < 0) {
	721	errno = socket_error();
	722	}
	723	return ret;
	724	}
	725
	726
	727	#undef send
	728	ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
	729	{
	730	int ret;
abe34282 MAL	731	SOCKET s = _get_osfhandle(sockfd);
	732
	733	if (s == INVALID_SOCKET) {
	734	return -1;
	735	}
	736
	737	ret = send(s, buf, len, flags);
a2d96af4 DB	738	if (ret < 0) {
	739	errno = socket_error();
	740	}
	741	return ret;
	742	}
	743
	744
	745	#undef sendto
	746	ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
	747	const struct sockaddr *addr, socklen_t addrlen)
	748	{
	749	int ret;
abe34282 MAL	750	SOCKET s = _get_osfhandle(sockfd);
	751
	752	if (s == INVALID_SOCKET) {
	753	return -1;
	754	}
	755
	756	ret = sendto(s, buf, len, flags, addr, addrlen);
a2d96af4 DB	757	if (ret < 0) {
	758	errno = socket_error();
	759	}
	760	return ret;
	761	}
	762
	763
	764	#undef recv
	765	ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
	766	{
	767	int ret;
abe34282 MAL	768	SOCKET s = _get_osfhandle(sockfd);
	769
	770	if (s == INVALID_SOCKET) {
	771	return -1;
	772	}
	773
	774	ret = recv(s, buf, len, flags);
a2d96af4 DB	775	if (ret < 0) {
	776	errno = socket_error();
	777	}
	778	return ret;
	779	}
	780
	781
	782	#undef recvfrom
	783	ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
	784	struct sockaddr addr, socklen_t addrlen)
	785	{
	786	int ret;
abe34282 MAL	787	SOCKET s = _get_osfhandle(sockfd);
	788
	789	if (s == INVALID_SOCKET) {
	790	return -1;
	791	}
	792
	793	ret = recvfrom(s, buf, len, flags, addr, addrlen);
a2d96af4 DB	794	if (ret < 0) {
	795	errno = socket_error();
	796	}
	797	return ret;
	798	}
9e6bdef2 MAL	799
	800	bool qemu_write_pidfile(const char filename, Error *errp)
	801	{
	802	char buffer[128];
	803	int len;
	804	HANDLE file;
	805	OVERLAPPED overlap;
	806	BOOL ret;
	807	memset(&overlap, 0, sizeof(overlap));
	808
	809	file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
	810	OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
	811
	812	if (file == INVALID_HANDLE_VALUE) {
	813	error_setg(errp, "Failed to create PID file");
	814	return false;
	815	}
	816	len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid());
	817	ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len,
	818	NULL, &overlap);
	819	CloseHandle(file);
	820	if (ret == 0) {
	821	error_setg(errp, "Failed to write PID file");
	822	return false;
	823	}
	824	return true;
	825	}
e47f4765	826
ad06ef0e AB	827	size_t qemu_get_host_physmem(void)
ad06ef0e AB	828	{
986babaa AB	829	MEMORYSTATUSEX statex;
	830	statex.dwLength = sizeof(statex);
	831
	832	if (GlobalMemoryStatusEx(&statex)) {
	833	return statex.ullTotalPhys;
	834	}
ad06ef0e AB	835	return 0;
ad06ef0e AB	836	}
73991a92 MAL	837
	838	int qemu_msync(void *addr, size_t length, int fd)
	839	{
	840	/**
	841	* Perform the sync based on the file descriptor
	842	* The sync range will most probably be wider than the one
	843	* requested - but it will still get the job done
	844	*/
	845	return qemu_fdatasync(fd);
	846	}
09b4c198 MAL	847
	848	void qemu_win32_map_alloc(size_t size, HANDLE h, Error **errp)
	849	{
	850	void *bits;
	851
	852	trace_win32_map_alloc(size);
	853
	854	*h = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
	855	size, NULL);
	856	if (*h == NULL) {
	857	error_setg_win32(errp, GetLastError(), "Failed to CreateFileMapping");
	858	return NULL;
	859	}
	860
	861	bits = MapViewOfFile(*h, FILE_MAP_ALL_ACCESS, 0, 0, size);
	862	if (bits == NULL) {
	863	error_setg_win32(errp, GetLastError(), "Failed to MapViewOfFile");
	864	CloseHandle(*h);
	865	return NULL;
	866	}
	867
	868	return bits;
	869	}
	870
	871	void qemu_win32_map_free(void ptr, HANDLE h, Error *errp)
	872	{
	873	trace_win32_map_free(ptr, h);
	874
	875	if (UnmapViewOfFile(ptr) == 0) {
	876	error_setg_win32(errp, GetLastError(), "Failed to UnmapViewOfFile");
	877	}
	878	CloseHandle(h);
	879	}