1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33#include "qemu/osdep.h"
34#include <windows.h>
35#include "qapi/error.h"
36#include "qemu/main-loop.h"
37#include "trace.h"
38#include "qemu/sockets.h"
39#include "qemu/cutils.h"
40#include "qemu/error-report.h"
41#include <malloc.h>
42
43static int get_allocation_granularity(void)
44{
45 SYSTEM_INFO system_info;
46
47 GetSystemInfo(&system_info);
48 return system_info.dwAllocationGranularity;
49}
50
51void *qemu_anon_ram_alloc(size_t size, uint64_t *align, bool shared,
52 bool noreserve)
53{
54 void *ptr;
55
56 if (noreserve) {
57
58
59
60
61 error_report("Skipping reservation of swap space is not supported.");
62 return NULL;
63 }
64
65 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
66 trace_qemu_anon_ram_alloc(size, ptr);
67
68 if (ptr && align) {
69 *align = MAX(get_allocation_granularity(), getpagesize());
70 }
71 return ptr;
72}
73
74void qemu_anon_ram_free(void *ptr, size_t size)
75{
76 trace_qemu_anon_ram_free(ptr, size);
77 if (ptr) {
78 VirtualFree(ptr, 0, MEM_RELEASE);
79 }
80}
81
82#ifndef _POSIX_THREAD_SAFE_FUNCTIONS
83
84struct tm *gmtime_r(const time_t *timep, struct tm *result)
85{
86 struct tm *p = gmtime(timep);
87 memset(result, 0, sizeof(*result));
88 if (p) {
89 *result = *p;
90 p = result;
91 }
92 return p;
93}
94
95
96struct tm *localtime_r(const time_t *timep, struct tm *result)
97{
98 struct tm *p = localtime(timep);
99 memset(result, 0, sizeof(*result));
100 if (p) {
101 *result = *p;
102 p = result;
103 }
104 return p;
105}
106#endif
107
108static int socket_error(void)
109{
110 switch (WSAGetLastError()) {
111 case 0:
112 return 0;
113 case WSAEINTR:
114 return EINTR;
115 case WSAEINVAL:
116 return EINVAL;
117 case WSA_INVALID_HANDLE:
118 return EBADF;
119 case WSA_NOT_ENOUGH_MEMORY:
120 return ENOMEM;
121 case WSA_INVALID_PARAMETER:
122 return EINVAL;
123 case WSAENAMETOOLONG:
124 return ENAMETOOLONG;
125 case WSAENOTEMPTY:
126 return ENOTEMPTY;
127 case WSAEWOULDBLOCK:
128
129
130 return EAGAIN;
131 case WSAEINPROGRESS:
132 return EINPROGRESS;
133 case WSAEALREADY:
134 return EALREADY;
135 case WSAENOTSOCK:
136 return ENOTSOCK;
137 case WSAEDESTADDRREQ:
138 return EDESTADDRREQ;
139 case WSAEMSGSIZE:
140 return EMSGSIZE;
141 case WSAEPROTOTYPE:
142 return EPROTOTYPE;
143 case WSAENOPROTOOPT:
144 return ENOPROTOOPT;
145 case WSAEPROTONOSUPPORT:
146 return EPROTONOSUPPORT;
147 case WSAEOPNOTSUPP:
148 return EOPNOTSUPP;
149 case WSAEAFNOSUPPORT:
150 return EAFNOSUPPORT;
151 case WSAEADDRINUSE:
152 return EADDRINUSE;
153 case WSAEADDRNOTAVAIL:
154 return EADDRNOTAVAIL;
155 case WSAENETDOWN:
156 return ENETDOWN;
157 case WSAENETUNREACH:
158 return ENETUNREACH;
159 case WSAENETRESET:
160 return ENETRESET;
161 case WSAECONNABORTED:
162 return ECONNABORTED;
163 case WSAECONNRESET:
164 return ECONNRESET;
165 case WSAENOBUFS:
166 return ENOBUFS;
167 case WSAEISCONN:
168 return EISCONN;
169 case WSAENOTCONN:
170 return ENOTCONN;
171 case WSAETIMEDOUT:
172 return ETIMEDOUT;
173 case WSAECONNREFUSED:
174 return ECONNREFUSED;
175 case WSAELOOP:
176 return ELOOP;
177 case WSAEHOSTUNREACH:
178 return EHOSTUNREACH;
179 default:
180 return EIO;
181 }
182}
183
184void qemu_socket_set_block(int fd)
185{
186 unsigned long opt = 0;
187 WSAEventSelect(fd, NULL, 0);
188 ioctlsocket(fd, FIONBIO, &opt);
189}
190
191int qemu_socket_try_set_nonblock(int fd)
192{
193 unsigned long opt = 1;
194 if (ioctlsocket(fd, FIONBIO, &opt) != NO_ERROR) {
195 return -socket_error();
196 }
197 return 0;
198}
199
200void qemu_socket_set_nonblock(int fd)
201{
202 (void)qemu_socket_try_set_nonblock(fd);
203}
204
205int socket_set_fast_reuse(int fd)
206{
207
208
209
210
211
212 return 0;
213}
214
215int inet_aton(const char *cp, struct in_addr *ia)
216{
217 uint32_t addr = inet_addr(cp);
218 if (addr == 0xffffffff) {
219 return 0;
220 }
221 ia->s_addr = addr;
222 return 1;
223}
224
225void qemu_set_cloexec(int fd)
226{
227}
228
229int qemu_get_thread_id(void)
230{
231 return GetCurrentThreadId();
232}
233
234char *
235qemu_get_local_state_dir(void)
236{
237 const char * const *data_dirs = g_get_system_data_dirs();
238
239 g_assert(data_dirs && data_dirs[0]);
240
241 return g_strdup(data_dirs[0]);
242}
243
244void qemu_set_tty_echo(int fd, bool echo)
245{
246 HANDLE handle = (HANDLE)_get_osfhandle(fd);
247 DWORD dwMode = 0;
248
249 if (handle == INVALID_HANDLE_VALUE) {
250 return;
251 }
252
253 GetConsoleMode(handle, &dwMode);
254
255 if (echo) {
256 SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);
257 } else {
258 SetConsoleMode(handle,
259 dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT));
260 }
261}
262
263int getpagesize(void)
264{
265 SYSTEM_INFO system_info;
266
267 GetSystemInfo(&system_info);
268 return system_info.dwPageSize;
269}
270
271void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus,
272 Error **errp)
273{
274 int i;
275 size_t pagesize = qemu_real_host_page_size();
276
277 memory = (memory + pagesize - 1) & -pagesize;
278 for (i = 0; i < memory / pagesize; i++) {
279 memset(area + pagesize * i, 0, 1);
280 }
281}
282
283char *qemu_get_pid_name(pid_t pid)
284{
285
286 abort();
287}
288
289
290pid_t qemu_fork(Error **errp)
291{
292 errno = ENOSYS;
293 error_setg_errno(errp, errno,
294 "cannot fork child process");
295 return -1;
296}
297
298
299#undef connect
300int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
301 socklen_t addrlen)
302{
303 int ret;
304 ret = connect(sockfd, addr, addrlen);
305 if (ret < 0) {
306 if (WSAGetLastError() == WSAEWOULDBLOCK) {
307 errno = EINPROGRESS;
308 } else {
309 errno = socket_error();
310 }
311 }
312 return ret;
313}
314
315
316#undef listen
317int qemu_listen_wrap(int sockfd, int backlog)
318{
319 int ret;
320 ret = listen(sockfd, backlog);
321 if (ret < 0) {
322 errno = socket_error();
323 }
324 return ret;
325}
326
327
328#undef bind
329int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
330 socklen_t addrlen)
331{
332 int ret;
333 ret = bind(sockfd, addr, addrlen);
334 if (ret < 0) {
335 errno = socket_error();
336 }
337 return ret;
338}
339
340
341#undef socket
342int qemu_socket_wrap(int domain, int type, int protocol)
343{
344 int ret;
345 ret = socket(domain, type, protocol);
346 if (ret < 0) {
347 errno = socket_error();
348 }
349 return ret;
350}
351
352
353#undef accept
354int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
355 socklen_t *addrlen)
356{
357 int ret;
358 ret = accept(sockfd, addr, addrlen);
359 if (ret < 0) {
360 errno = socket_error();
361 }
362 return ret;
363}
364
365
366#undef shutdown
367int qemu_shutdown_wrap(int sockfd, int how)
368{
369 int ret;
370 ret = shutdown(sockfd, how);
371 if (ret < 0) {
372 errno = socket_error();
373 }
374 return ret;
375}
376
377
378#undef ioctlsocket
379int qemu_ioctlsocket_wrap(int fd, int req, void *val)
380{
381 int ret;
382 ret = ioctlsocket(fd, req, val);
383 if (ret < 0) {
384 errno = socket_error();
385 }
386 return ret;
387}
388
389
390#undef closesocket
391int qemu_closesocket_wrap(int fd)
392{
393 int ret;
394 ret = closesocket(fd);
395 if (ret < 0) {
396 errno = socket_error();
397 }
398 return ret;
399}
400
401
402#undef getsockopt
403int qemu_getsockopt_wrap(int sockfd, int level, int optname,
404 void *optval, socklen_t *optlen)
405{
406 int ret;
407 ret = getsockopt(sockfd, level, optname, optval, optlen);
408 if (ret < 0) {
409 errno = socket_error();
410 }
411 return ret;
412}
413
414
415#undef setsockopt
416int qemu_setsockopt_wrap(int sockfd, int level, int optname,
417 const void *optval, socklen_t optlen)
418{
419 int ret;
420 ret = setsockopt(sockfd, level, optname, optval, optlen);
421 if (ret < 0) {
422 errno = socket_error();
423 }
424 return ret;
425}
426
427
428#undef getpeername
429int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
430 socklen_t *addrlen)
431{
432 int ret;
433 ret = getpeername(sockfd, addr, addrlen);
434 if (ret < 0) {
435 errno = socket_error();
436 }
437 return ret;
438}
439
440
441#undef getsockname
442int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
443 socklen_t *addrlen)
444{
445 int ret;
446 ret = getsockname(sockfd, addr, addrlen);
447 if (ret < 0) {
448 errno = socket_error();
449 }
450 return ret;
451}
452
453
454#undef send
455ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
456{
457 int ret;
458 ret = send(sockfd, buf, len, flags);
459 if (ret < 0) {
460 errno = socket_error();
461 }
462 return ret;
463}
464
465
466#undef sendto
467ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
468 const struct sockaddr *addr, socklen_t addrlen)
469{
470 int ret;
471 ret = sendto(sockfd, buf, len, flags, addr, addrlen);
472 if (ret < 0) {
473 errno = socket_error();
474 }
475 return ret;
476}
477
478
479#undef recv
480ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
481{
482 int ret;
483 ret = recv(sockfd, buf, len, flags);
484 if (ret < 0) {
485 errno = socket_error();
486 }
487 return ret;
488}
489
490
491#undef recvfrom
492ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
493 struct sockaddr *addr, socklen_t *addrlen)
494{
495 int ret;
496 ret = recvfrom(sockfd, buf, len, flags, addr, addrlen);
497 if (ret < 0) {
498 errno = socket_error();
499 }
500 return ret;
501}
502
503bool qemu_write_pidfile(const char *filename, Error **errp)
504{
505 char buffer[128];
506 int len;
507 HANDLE file;
508 OVERLAPPED overlap;
509 BOOL ret;
510 memset(&overlap, 0, sizeof(overlap));
511
512 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
513 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
514
515 if (file == INVALID_HANDLE_VALUE) {
516 error_setg(errp, "Failed to create PID file");
517 return false;
518 }
519 len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid());
520 ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len,
521 NULL, &overlap);
522 CloseHandle(file);
523 if (ret == 0) {
524 error_setg(errp, "Failed to write PID file");
525 return false;
526 }
527 return true;
528}
529
530size_t qemu_get_host_physmem(void)
531{
532 MEMORYSTATUSEX statex;
533 statex.dwLength = sizeof(statex);
534
535 if (GlobalMemoryStatusEx(&statex)) {
536 return statex.ullTotalPhys;
537 }
538 return 0;
539}
540
541int qemu_msync(void *addr, size_t length, int fd)
542{
543
544
545
546
547
548 return qemu_fdatasync(fd);
549}
550