include/sysemu/os-win32.h

   1 /*
   2  * win32 specific declarations
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  * Copyright (c) 2010 Jes Sorensen <Jes.Sorensen@redhat.com>
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #ifndef QEMU_OS_WIN32_H
  27 #define QEMU_OS_WIN32_H
  28
  29 #include <winsock2.h>
  30 #include <windows.h>
  31 #include <ws2tcpip.h>
  32 #include "qemu/typedefs.h"
  33
  34 #ifdef HAVE_AFUNIX_H
  35 #include <afunix.h>
  36 #else
  37 /*
  38  * Fallback definitions of things we need in afunix.h, if not available from
  39  * the used Windows SDK or MinGW headers.
  40  */
  41 #define UNIX_PATH_MAX 108
  42
  43 typedef struct sockaddr_un {
  44     ADDRESS_FAMILY sun_family;
  45     char sun_path[UNIX_PATH_MAX];
  46 } SOCKADDR_UN, *PSOCKADDR_UN;
  47
  48 #define SIO_AF_UNIX_GETPEERPID _WSAIOR(IOC_VENDOR, 256)
  49 #endif
  50
  51 #ifdef __cplusplus
  52 extern "C" {
  53 #endif
  54
  55 #if defined(__aarch64__)
  56 /*
  57  * On windows-arm64, setjmp is available in only one variant, and longjmp always
  58  * does stack unwinding. This crash with generated code.
  59  * Thus, we use another implementation of setjmp (not windows one), coming from
  60  * mingw, which never performs stack unwinding.
  61  */
  62 #undef setjmp
  63 #undef longjmp
  64 /*
  65  * These functions are not declared in setjmp.h because __aarch64__ defines
  66  * setjmp to _setjmpex instead. However, they are still defined in libmingwex.a,
  67  * which gets linked automatically.
  68  */
  69 int __mingw_setjmp(jmp_buf);
  70 void __attribute__((noreturn)) __mingw_longjmp(jmp_buf, int);
  71 #define setjmp(env) __mingw_setjmp(env)
  72 #define longjmp(env, val) __mingw_longjmp(env, val)
  73 #elif defined(_WIN64)
  74 /*
  75  * On windows-x64, setjmp is implemented by _setjmp which needs a second parameter.
  76  * If this parameter is NULL, longjump does no stack unwinding.
  77  * That is what we need for QEMU. Passing the value of register rsp (default)
  78  * lets longjmp try a stack unwinding which will crash with generated code.
  79  */
  80 # undef setjmp
  81 # define setjmp(env) _setjmp(env, NULL)
  82 #endif /* __aarch64__ */
  83 /* QEMU uses sigsetjmp()/siglongjmp() as the portable way to specify
  84  * "longjmp and don't touch the signal masks". Since we know that the
  85  * savemask parameter will always be zero we can safely define these
  86  * in terms of setjmp/longjmp on Win32.
  87  */
  88 #define sigjmp_buf jmp_buf
  89 #define sigsetjmp(env, savemask) setjmp(env)
  90 #define siglongjmp(env, val) longjmp(env, val)
  91
  92 /* Missing POSIX functions. Don't use MinGW-w64 macros. */
  93 #ifndef _POSIX_THREAD_SAFE_FUNCTIONS
  94 #undef gmtime_r
  95 struct tm *gmtime_r(const time_t *timep, struct tm *result);
  96 #undef localtime_r
  97 struct tm *localtime_r(const time_t *timep, struct tm *result);
  98 #endif /* _POSIX_THREAD_SAFE_FUNCTIONS */
  99
 100 static inline void os_setup_signal_handling(void) {}
 101 static inline void os_daemonize(void) {}
 102 static inline void os_setup_post(void) {}
 103 static inline void os_set_proc_name(const char *dummy) {}
 104 void os_set_line_buffering(void);
 105 void os_setup_early_signal_handling(void);
 106
 107 int getpagesize(void);
 108
 109 #if !defined(EPROTONOSUPPORT)
 110 # define EPROTONOSUPPORT EINVAL
 111 #endif
 112
 113 static inline int os_set_daemonize(bool d)
 114 {
 115     if (d) {
 116         return -ENOTSUP;
 117     }
 118     return 0;
 119 }
 120
 121 static inline bool is_daemonized(void)
 122 {
 123     return false;
 124 }
 125
 126 static inline int os_mlock(void)
 127 {
 128     return -ENOSYS;
 129 }
 130
 131 static inline void os_setup_limits(void)
 132 {
 133     return;
 134 }
 135
 136 #define fsync _commit
 137
 138 #if !defined(lseek)
 139 # define lseek _lseeki64
 140 #endif
 141
 142 int qemu_ftruncate64(int, int64_t);
 143
 144 #if !defined(ftruncate)
 145 # define ftruncate qemu_ftruncate64
 146 #endif
 147
 148 static inline char *realpath(const char *path, char *resolved_path)
 149 {
 150     _fullpath(resolved_path, path, _MAX_PATH);
 151     return resolved_path;
 152 }
 153
 154 /*
 155  * Older versions of MinGW do not import _lock_file and _unlock_file properly.
 156  * This was fixed for v6.0.0 with commit b48e3ac8969d.
 157  */
 158 static inline void qemu_flockfile(FILE *f)
 159 {
 160 #ifdef HAVE__LOCK_FILE
 161     _lock_file(f);
 162 #endif
 163 }
 164
 165 static inline void qemu_funlockfile(FILE *f)
 166 {
 167 #ifdef HAVE__LOCK_FILE
 168     _unlock_file(f);
 169 #endif
 170 }
 171
 172 /* Helper for WSAEventSelect, to report errors */
 173 bool qemu_socket_select(int sockfd, WSAEVENT hEventObject,
 174                         long lNetworkEvents, Error **errp);
 175
 176 bool qemu_socket_unselect(int sockfd, Error **errp);
 177
 178 /* We wrap all the sockets functions so that we can set errno based on
 179  * WSAGetLastError(), and use file-descriptors instead of SOCKET.
 180  */
 181
 182 /*
 183  * qemu_close_socket_osfhandle:
 184  * @fd: a file descriptor associated with a SOCKET
 185  *
 186  * Close only the C run-time file descriptor, leave the SOCKET opened.
 187  *
 188  * Returns zero on success. On error, -1 is returned, and errno is set to
 189  * indicate the error.
 190  */
 191 int qemu_close_socket_osfhandle(int fd);
 192
 193 #undef close
 194 #define close qemu_close_wrap
 195 int qemu_close_wrap(int fd);
 196
 197 #undef connect
 198 #define connect qemu_connect_wrap
 199 int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
 200                       socklen_t addrlen);
 201
 202 #undef listen
 203 #define listen qemu_listen_wrap
 204 int qemu_listen_wrap(int sockfd, int backlog);
 205
 206 #undef bind
 207 #define bind qemu_bind_wrap
 208 int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
 209                    socklen_t addrlen);
 210
 211 #undef socket
 212 #define socket qemu_socket_wrap
 213 int qemu_socket_wrap(int domain, int type, int protocol);
 214
 215 #undef accept
 216 #define accept qemu_accept_wrap
 217 int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
 218                      socklen_t *addrlen);
 219
 220 #undef shutdown
 221 #define shutdown qemu_shutdown_wrap
 222 int qemu_shutdown_wrap(int sockfd, int how);
 223
 224 #undef ioctlsocket
 225 #define ioctlsocket qemu_ioctlsocket_wrap
 226 int qemu_ioctlsocket_wrap(int fd, int req, void *val);
 227
 228 #undef getsockopt
 229 #define getsockopt qemu_getsockopt_wrap
 230 int qemu_getsockopt_wrap(int sockfd, int level, int optname,
 231                          void *optval, socklen_t *optlen);
 232
 233 #undef setsockopt
 234 #define setsockopt qemu_setsockopt_wrap
 235 int qemu_setsockopt_wrap(int sockfd, int level, int optname,
 236                          const void *optval, socklen_t optlen);
 237
 238 #undef getpeername
 239 #define getpeername qemu_getpeername_wrap
 240 int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
 241                           socklen_t *addrlen);
 242
 243 #undef getsockname
 244 #define getsockname qemu_getsockname_wrap
 245 int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
 246                           socklen_t *addrlen);
 247
 248 #undef send
 249 #define send qemu_send_wrap
 250 ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags);
 251
 252 #undef sendto
 253 #define sendto qemu_sendto_wrap
 254 ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
 255                          const struct sockaddr *addr, socklen_t addrlen);
 256
 257 #undef recv
 258 #define recv qemu_recv_wrap
 259 ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags);
 260
 261 #undef recvfrom
 262 #define recvfrom qemu_recvfrom_wrap
 263 ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
 264                            struct sockaddr *addr, socklen_t *addrlen);
 265
 266 EXCEPTION_DISPOSITION
 267 win32_close_exception_handler(struct _EXCEPTION_RECORD*, void*,
 268                               struct _CONTEXT*, void*);
 269
 270 void *qemu_win32_map_alloc(size_t size, HANDLE *h, Error **errp);
 271 void qemu_win32_map_free(void *ptr, HANDLE h, Error **errp);
 272
 273 #ifdef __cplusplus
 274 }
 275 #endif
 276
 277 #endif