1 /* 2 * os-win32.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010 Red Hat, Inc. 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 */ 28 #include <windows.h> 29 #include "config-host.h" 30 #include "sysemu/sysemu.h" 31 #include "qemu/main-loop.h" 32 #include "trace.h" 33 #include "qemu/sockets.h" 34 35 void *qemu_oom_check(void *ptr) 36 { 37 if (ptr == NULL) { 38 fprintf(stderr, "Failed to allocate memory: %lu\n", GetLastError()); 39 abort(); 40 } 41 return ptr; 42 } 43 44 void *qemu_memalign(size_t alignment, size_t size) 45 { 46 void *ptr; 47 48 if (!size) { 49 abort(); 50 } 51 ptr = qemu_oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE)); 52 trace_qemu_memalign(alignment, size, ptr); 53 return ptr; 54 } 55 56 void *qemu_anon_ram_alloc(size_t size) 57 { 58 void *ptr; 59 60 /* FIXME: this is not exactly optimal solution since VirtualAlloc 61 has 64Kb granularity, but at least it guarantees us that the 62 memory is page aligned. */ 63 if (!size) { 64 abort(); 65 } 66 ptr = qemu_oom_check(VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE)); 67 trace_qemu_anon_ram_alloc(size, ptr); 68 return ptr; 69 } 70 71 void qemu_vfree(void *ptr) 72 { 73 trace_qemu_vfree(ptr); 74 if (ptr) { 75 VirtualFree(ptr, 0, MEM_RELEASE); 76 } 77 } 78 79 void qemu_anon_ram_free(void *ptr, size_t size) 80 { 81 trace_qemu_anon_ram_free(ptr, size); 82 if (ptr) { 83 VirtualFree(ptr, 0, MEM_RELEASE); 84 } 85 } 86 87 /* FIXME: add proper locking */ 88 struct tm *gmtime_r(const time_t *timep, struct tm *result) 89 { 90 struct tm *p = gmtime(timep); 91 memset(result, 0, sizeof(*result)); 92 if (p) { 93 *result = *p; 94 p = result; 95 } 96 return p; 97 } 98 99 /* FIXME: add proper locking */ 100 struct tm *localtime_r(const time_t *timep, struct tm *result) 101 { 102 struct tm *p = localtime(timep); 103 memset(result, 0, sizeof(*result)); 104 if (p) { 105 *result = *p; 106 p = result; 107 } 108 return p; 109 } 110 111 void qemu_set_block(int fd) 112 { 113 unsigned long opt = 0; 114 WSAEventSelect(fd, NULL, 0); 115 ioctlsocket(fd, FIONBIO, &opt); 116 } 117 118 void qemu_set_nonblock(int fd) 119 { 120 unsigned long opt = 1; 121 ioctlsocket(fd, FIONBIO, &opt); 122 qemu_fd_register(fd); 123 } 124 125 int inet_aton(const char *cp, struct in_addr *ia) 126 { 127 uint32_t addr = inet_addr(cp); 128 if (addr == 0xffffffff) { 129 return 0; 130 } 131 ia->s_addr = addr; 132 return 1; 133 } 134 135 void qemu_set_cloexec(int fd) 136 { 137 } 138 139 /* Offset between 1/1/1601 and 1/1/1970 in 100 nanosec units */ 140 #define _W32_FT_OFFSET (116444736000000000ULL) 141 142 int qemu_gettimeofday(qemu_timeval *tp) 143 { 144 union { 145 unsigned long long ns100; /*time since 1 Jan 1601 in 100ns units */ 146 FILETIME ft; 147 } _now; 148 149 if(tp) { 150 GetSystemTimeAsFileTime (&_now.ft); 151 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL ); 152 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL); 153 } 154 /* Always return 0 as per Open Group Base Specifications Issue 6. 155 Do not set errno on error. */ 156 return 0; 157 } 158 159 int qemu_get_thread_id(void) 160 { 161 return GetCurrentThreadId(); 162 } 163