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#include "qemu/osdep.h"
33#include <windows.h>
34#include "qapi/error.h"
35#include "sysemu/sysemu.h"
36#include "qemu/main-loop.h"
37#include "trace.h"
38#include "qemu/sockets.h"
39#include "qemu/cutils.h"
40
41
42#include <shlobj.h>
43
44void *qemu_oom_check(void *ptr)
45{
46 if (ptr == NULL) {
47 fprintf(stderr, "Failed to allocate memory: %lu\n", GetLastError());
48 abort();
49 }
50 return ptr;
51}
52
53void *qemu_try_memalign(size_t alignment, size_t size)
54{
55 void *ptr;
56
57 if (!size) {
58 abort();
59 }
60 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
61 trace_qemu_memalign(alignment, size, ptr);
62 return ptr;
63}
64
65void *qemu_memalign(size_t alignment, size_t size)
66{
67 return qemu_oom_check(qemu_try_memalign(alignment, size));
68}
69
70void *qemu_anon_ram_alloc(size_t size, uint64_t *align, bool shared)
71{
72 void *ptr;
73
74
75
76
77 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
78 trace_qemu_anon_ram_alloc(size, ptr);
79 return ptr;
80}
81
82void qemu_vfree(void *ptr)
83{
84 trace_qemu_vfree(ptr);
85 if (ptr) {
86 VirtualFree(ptr, 0, MEM_RELEASE);
87 }
88}
89
90void qemu_anon_ram_free(void *ptr, size_t size)
91{
92 trace_qemu_anon_ram_free(ptr, size);
93 if (ptr) {
94 VirtualFree(ptr, 0, MEM_RELEASE);
95 }
96}
97
98#ifndef CONFIG_LOCALTIME_R
99
100struct tm *gmtime_r(const time_t *timep, struct tm *result)
101{
102 struct tm *p = gmtime(timep);
103 memset(result, 0, sizeof(*result));
104 if (p) {
105 *result = *p;
106 p = result;
107 }
108 return p;
109}
110
111
112struct tm *localtime_r(const time_t *timep, struct tm *result)
113{
114 struct tm *p = localtime(timep);
115 memset(result, 0, sizeof(*result));
116 if (p) {
117 *result = *p;
118 p = result;
119 }
120 return p;
121}
122#endif
123
124void qemu_set_block(int fd)
125{
126 unsigned long opt = 0;
127 WSAEventSelect(fd, NULL, 0);
128 ioctlsocket(fd, FIONBIO, &opt);
129}
130
131void qemu_set_nonblock(int fd)
132{
133 unsigned long opt = 1;
134 ioctlsocket(fd, FIONBIO, &opt);
135 qemu_fd_register(fd);
136}
137
138int socket_set_fast_reuse(int fd)
139{
140
141
142
143
144
145 return 0;
146}
147
148
149static int socket_error(void)
150{
151 switch (WSAGetLastError()) {
152 case 0:
153 return 0;
154 case WSAEINTR:
155 return EINTR;
156 case WSAEINVAL:
157 return EINVAL;
158 case WSA_INVALID_HANDLE:
159 return EBADF;
160 case WSA_NOT_ENOUGH_MEMORY:
161 return ENOMEM;
162 case WSA_INVALID_PARAMETER:
163 return EINVAL;
164 case WSAENAMETOOLONG:
165 return ENAMETOOLONG;
166 case WSAENOTEMPTY:
167 return ENOTEMPTY;
168 case WSAEWOULDBLOCK:
169
170
171 return EAGAIN;
172 case WSAEINPROGRESS:
173 return EINPROGRESS;
174 case WSAEALREADY:
175 return EALREADY;
176 case WSAENOTSOCK:
177 return ENOTSOCK;
178 case WSAEDESTADDRREQ:
179 return EDESTADDRREQ;
180 case WSAEMSGSIZE:
181 return EMSGSIZE;
182 case WSAEPROTOTYPE:
183 return EPROTOTYPE;
184 case WSAENOPROTOOPT:
185 return ENOPROTOOPT;
186 case WSAEPROTONOSUPPORT:
187 return EPROTONOSUPPORT;
188 case WSAEOPNOTSUPP:
189 return EOPNOTSUPP;
190 case WSAEAFNOSUPPORT:
191 return EAFNOSUPPORT;
192 case WSAEADDRINUSE:
193 return EADDRINUSE;
194 case WSAEADDRNOTAVAIL:
195 return EADDRNOTAVAIL;
196 case WSAENETDOWN:
197 return ENETDOWN;
198 case WSAENETUNREACH:
199 return ENETUNREACH;
200 case WSAENETRESET:
201 return ENETRESET;
202 case WSAECONNABORTED:
203 return ECONNABORTED;
204 case WSAECONNRESET:
205 return ECONNRESET;
206 case WSAENOBUFS:
207 return ENOBUFS;
208 case WSAEISCONN:
209 return EISCONN;
210 case WSAENOTCONN:
211 return ENOTCONN;
212 case WSAETIMEDOUT:
213 return ETIMEDOUT;
214 case WSAECONNREFUSED:
215 return ECONNREFUSED;
216 case WSAELOOP:
217 return ELOOP;
218 case WSAEHOSTUNREACH:
219 return EHOSTUNREACH;
220 default:
221 return EIO;
222 }
223}
224
225int inet_aton(const char *cp, struct in_addr *ia)
226{
227 uint32_t addr = inet_addr(cp);
228 if (addr == 0xffffffff) {
229 return 0;
230 }
231 ia->s_addr = addr;
232 return 1;
233}
234
235void qemu_set_cloexec(int fd)
236{
237}
238
239
240#define _W32_FT_OFFSET (116444736000000000ULL)
241
242int qemu_gettimeofday(qemu_timeval *tp)
243{
244 union {
245 unsigned long long ns100;
246 FILETIME ft;
247 } _now;
248
249 if(tp) {
250 GetSystemTimeAsFileTime (&_now.ft);
251 tp->tv_usec=(long)((_now.ns100 / 10ULL) % 1000000ULL );
252 tp->tv_sec= (long)((_now.ns100 - _W32_FT_OFFSET) / 10000000ULL);
253 }
254
255
256 return 0;
257}
258
259int qemu_get_thread_id(void)
260{
261 return GetCurrentThreadId();
262}
263
264char *
265qemu_get_local_state_pathname(const char *relative_pathname)
266{
267 HRESULT result;
268 char base_path[MAX_PATH+1] = "";
269
270 result = SHGetFolderPath(NULL, CSIDL_COMMON_APPDATA, NULL,
271 0, base_path);
272 if (result != S_OK) {
273
274 g_critical("CSIDL_COMMON_APPDATA unavailable: %ld", (long)result);
275 abort();
276 }
277 return g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", base_path,
278 relative_pathname);
279}
280
281void qemu_set_tty_echo(int fd, bool echo)
282{
283 HANDLE handle = (HANDLE)_get_osfhandle(fd);
284 DWORD dwMode = 0;
285
286 if (handle == INVALID_HANDLE_VALUE) {
287 return;
288 }
289
290 GetConsoleMode(handle, &dwMode);
291
292 if (echo) {
293 SetConsoleMode(handle, dwMode | ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT);
294 } else {
295 SetConsoleMode(handle,
296 dwMode & ~(ENABLE_ECHO_INPUT | ENABLE_LINE_INPUT));
297 }
298}
299
300static char exec_dir[PATH_MAX];
301
302void qemu_init_exec_dir(const char *argv0)
303{
304
305 char *p;
306 char buf[MAX_PATH];
307 DWORD len;
308
309 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
310 if (len == 0) {
311 return;
312 }
313
314 buf[len] = 0;
315 p = buf + len - 1;
316 while (p != buf && *p != '\\') {
317 p--;
318 }
319 *p = 0;
320 if (access(buf, R_OK) == 0) {
321 pstrcpy(exec_dir, sizeof(exec_dir), buf);
322 }
323}
324
325char *qemu_get_exec_dir(void)
326{
327 return g_strdup(exec_dir);
328}
329
330#if !GLIB_CHECK_VERSION(2, 50, 0)
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363static int poll_rest(gboolean poll_msgs, HANDLE *handles, gint nhandles,
364 GPollFD *fds, guint nfds, gint timeout)
365{
366 DWORD ready;
367 GPollFD *f;
368 int recursed_result;
369
370 if (poll_msgs) {
371
372
373
374 ready = MsgWaitForMultipleObjectsEx(nhandles, handles, timeout,
375 QS_ALLINPUT, MWMO_ALERTABLE);
376
377 if (ready == WAIT_FAILED) {
378 gchar *emsg = g_win32_error_message(GetLastError());
379 g_warning("MsgWaitForMultipleObjectsEx failed: %s", emsg);
380 g_free(emsg);
381 }
382 } else if (nhandles == 0) {
383
384 if (timeout == INFINITE) {
385 ready = WAIT_FAILED;
386 } else {
387 SleepEx(timeout, TRUE);
388 ready = WAIT_TIMEOUT;
389 }
390 } else {
391
392
393
394 ready =
395 WaitForMultipleObjectsEx(nhandles, handles, FALSE, timeout, TRUE);
396 if (ready == WAIT_FAILED) {
397 gchar *emsg = g_win32_error_message(GetLastError());
398 g_warning("WaitForMultipleObjectsEx failed: %s", emsg);
399 g_free(emsg);
400 }
401 }
402
403 if (ready == WAIT_FAILED) {
404 return -1;
405 } else if (ready == WAIT_TIMEOUT || ready == WAIT_IO_COMPLETION) {
406 return 0;
407 } else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles) {
408 for (f = fds; f < &fds[nfds]; ++f) {
409 if (f->fd == G_WIN32_MSG_HANDLE && f->events & G_IO_IN) {
410 f->revents |= G_IO_IN;
411 }
412 }
413
414
415
416
417 if (timeout != 0 || nhandles == 0) {
418 return 1;
419 }
420
421
422
423
424 recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0);
425 return (recursed_result == -1) ? -1 : 1 + recursed_result;
426 } else if (
427
428 ready < WAIT_OBJECT_0 + nhandles) {
429 for (f = fds; f < &fds[nfds]; ++f) {
430 if ((HANDLE) f->fd == handles[ready - WAIT_OBJECT_0]) {
431 f->revents = f->events;
432 }
433 }
434
435
436
437
438 if (timeout == 0 && nhandles > 1) {
439
440 int i;
441 for (i = ready - WAIT_OBJECT_0 + 1; i < nhandles; i++) {
442 handles[i-1] = handles[i];
443 }
444 nhandles--;
445 recursed_result = poll_rest(FALSE, handles, nhandles, fds, nfds, 0);
446 return (recursed_result == -1) ? -1 : 1 + recursed_result;
447 }
448 return 1;
449 }
450
451 return 0;
452}
453
454gint g_poll(GPollFD *fds, guint nfds, gint timeout)
455{
456 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
457 gboolean poll_msgs = FALSE;
458 GPollFD *f;
459 gint nhandles = 0;
460 int retval;
461
462 for (f = fds; f < &fds[nfds]; ++f) {
463 if (f->fd == G_WIN32_MSG_HANDLE && (f->events & G_IO_IN)) {
464 poll_msgs = TRUE;
465 } else if (f->fd > 0) {
466
467
468
469
470 gint i;
471
472 for (i = 0; i < nhandles; i++) {
473 if (handles[i] == (HANDLE) f->fd) {
474 break;
475 }
476 }
477
478 if (i == nhandles) {
479 if (nhandles == MAXIMUM_WAIT_OBJECTS) {
480 g_warning("Too many handles to wait for!\n");
481 break;
482 } else {
483 handles[nhandles++] = (HANDLE) f->fd;
484 }
485 }
486 }
487 }
488
489 for (f = fds; f < &fds[nfds]; ++f) {
490 f->revents = 0;
491 }
492
493 if (timeout == -1) {
494 timeout = INFINITE;
495 }
496
497
498 if (nhandles > 1 || (nhandles > 0 && poll_msgs)) {
499
500
501
502 retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, 0);
503
504
505
506
507
508
509
510
511
512
513 if (retval == 0 && (timeout == INFINITE || timeout > 0)) {
514 retval = poll_rest(poll_msgs, handles, nhandles,
515 fds, nfds, timeout);
516 }
517 } else {
518
519
520
521 retval = poll_rest(poll_msgs, handles, nhandles, fds, nfds, timeout);
522 }
523
524 if (retval == -1) {
525 for (f = fds; f < &fds[nfds]; ++f) {
526 f->revents = 0;
527 }
528 }
529
530 return retval;
531}
532#endif
533
534int getpagesize(void)
535{
536 SYSTEM_INFO system_info;
537
538 GetSystemInfo(&system_info);
539 return system_info.dwPageSize;
540}
541
542void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus,
543 Error **errp)
544{
545 int i;
546 size_t pagesize = getpagesize();
547
548 memory = (memory + pagesize - 1) & -pagesize;
549 for (i = 0; i < memory / pagesize; i++) {
550 memset(area + pagesize * i, 0, 1);
551 }
552}
553
554
555char *qemu_get_pid_name(pid_t pid)
556{
557
558 abort();
559}
560
561
562pid_t qemu_fork(Error **errp)
563{
564 errno = ENOSYS;
565 error_setg_errno(errp, errno,
566 "cannot fork child process");
567 return -1;
568}
569
570
571#undef connect
572int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
573 socklen_t addrlen)
574{
575 int ret;
576 ret = connect(sockfd, addr, addrlen);
577 if (ret < 0) {
578 errno = socket_error();
579 }
580 return ret;
581}
582
583
584#undef listen
585int qemu_listen_wrap(int sockfd, int backlog)
586{
587 int ret;
588 ret = listen(sockfd, backlog);
589 if (ret < 0) {
590 errno = socket_error();
591 }
592 return ret;
593}
594
595
596#undef bind
597int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
598 socklen_t addrlen)
599{
600 int ret;
601 ret = bind(sockfd, addr, addrlen);
602 if (ret < 0) {
603 errno = socket_error();
604 }
605 return ret;
606}
607
608
609#undef socket
610int qemu_socket_wrap(int domain, int type, int protocol)
611{
612 int ret;
613 ret = socket(domain, type, protocol);
614 if (ret < 0) {
615 errno = socket_error();
616 }
617 return ret;
618}
619
620
621#undef accept
622int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
623 socklen_t *addrlen)
624{
625 int ret;
626 ret = accept(sockfd, addr, addrlen);
627 if (ret < 0) {
628 errno = socket_error();
629 }
630 return ret;
631}
632
633
634#undef shutdown
635int qemu_shutdown_wrap(int sockfd, int how)
636{
637 int ret;
638 ret = shutdown(sockfd, how);
639 if (ret < 0) {
640 errno = socket_error();
641 }
642 return ret;
643}
644
645
646#undef ioctlsocket
647int qemu_ioctlsocket_wrap(int fd, int req, void *val)
648{
649 int ret;
650 ret = ioctlsocket(fd, req, val);
651 if (ret < 0) {
652 errno = socket_error();
653 }
654 return ret;
655}
656
657
658#undef closesocket
659int qemu_closesocket_wrap(int fd)
660{
661 int ret;
662 ret = closesocket(fd);
663 if (ret < 0) {
664 errno = socket_error();
665 }
666 return ret;
667}
668
669
670#undef getsockopt
671int qemu_getsockopt_wrap(int sockfd, int level, int optname,
672 void *optval, socklen_t *optlen)
673{
674 int ret;
675 ret = getsockopt(sockfd, level, optname, optval, optlen);
676 if (ret < 0) {
677 errno = socket_error();
678 }
679 return ret;
680}
681
682
683#undef setsockopt
684int qemu_setsockopt_wrap(int sockfd, int level, int optname,
685 const void *optval, socklen_t optlen)
686{
687 int ret;
688 ret = setsockopt(sockfd, level, optname, optval, optlen);
689 if (ret < 0) {
690 errno = socket_error();
691 }
692 return ret;
693}
694
695
696#undef getpeername
697int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
698 socklen_t *addrlen)
699{
700 int ret;
701 ret = getpeername(sockfd, addr, addrlen);
702 if (ret < 0) {
703 errno = socket_error();
704 }
705 return ret;
706}
707
708
709#undef getsockname
710int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
711 socklen_t *addrlen)
712{
713 int ret;
714 ret = getsockname(sockfd, addr, addrlen);
715 if (ret < 0) {
716 errno = socket_error();
717 }
718 return ret;
719}
720
721
722#undef send
723ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
724{
725 int ret;
726 ret = send(sockfd, buf, len, flags);
727 if (ret < 0) {
728 errno = socket_error();
729 }
730 return ret;
731}
732
733
734#undef sendto
735ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
736 const struct sockaddr *addr, socklen_t addrlen)
737{
738 int ret;
739 ret = sendto(sockfd, buf, len, flags, addr, addrlen);
740 if (ret < 0) {
741 errno = socket_error();
742 }
743 return ret;
744}
745
746
747#undef recv
748ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
749{
750 int ret;
751 ret = recv(sockfd, buf, len, flags);
752 if (ret < 0) {
753 errno = socket_error();
754 }
755 return ret;
756}
757
758
759#undef recvfrom
760ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
761 struct sockaddr *addr, socklen_t *addrlen)
762{
763 int ret;
764 ret = recvfrom(sockfd, buf, len, flags, addr, addrlen);
765 if (ret < 0) {
766 errno = socket_error();
767 }
768 return ret;
769}
770