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#include "qemu/osdep.h"
30#include <windows.h>
31#include "qapi/error.h"
32#include "qemu/main-loop.h"
33#include "trace.h"
34#include "qemu/sockets.h"
35#include "qemu/cutils.h"
36#include "qemu/error-report.h"
37#include <malloc.h>
38
39static int get_allocation_granularity(void)
40{
41 SYSTEM_INFO system_info;
42
43 GetSystemInfo(&system_info);
44 return system_info.dwAllocationGranularity;
45}
46
47void *qemu_anon_ram_alloc(size_t size, uint64_t *align, bool shared,
48 bool noreserve)
49{
50 void *ptr;
51
52 if (noreserve) {
53
54
55
56
57 error_report("Skipping reservation of swap space is not supported.");
58 return NULL;
59 }
60
61 ptr = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
62 trace_qemu_anon_ram_alloc(size, ptr);
63
64 if (ptr && align) {
65 *align = MAX(get_allocation_granularity(), getpagesize());
66 }
67 return ptr;
68}
69
70void 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
78#ifndef _POSIX_THREAD_SAFE_FUNCTIONS
79
80struct 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
92struct 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}
102#endif
103
104static int socket_error(void)
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
125
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
180void qemu_socket_set_block(int fd)
181{
182 unsigned long opt = 0;
183 qemu_socket_unselect(fd, NULL);
184 ioctlsocket(fd, FIONBIO, &opt);
185}
186
187int qemu_socket_try_set_nonblock(int fd)
188{
189 unsigned long opt = 1;
190 if (ioctlsocket(fd, FIONBIO, &opt) != NO_ERROR) {
191 return -socket_error();
192 }
193 return 0;
194}
195
196void qemu_socket_set_nonblock(int fd)
197{
198 (void)qemu_socket_try_set_nonblock(fd);
199}
200
201int socket_set_fast_reuse(int fd)
202{
203
204
205
206
207
208 return 0;
209}
210
211int inet_aton(const char *cp, struct in_addr *ia)
212{
213 uint32_t addr = inet_addr(cp);
214 if (addr == 0xffffffff) {
215 return 0;
216 }
217 ia->s_addr = addr;
218 return 1;
219}
220
221void qemu_set_cloexec(int fd)
222{
223}
224
225int qemu_get_thread_id(void)
226{
227 return GetCurrentThreadId();
228}
229
230char *
231qemu_get_local_state_dir(void)
232{
233 const char * const *data_dirs = g_get_system_data_dirs();
234
235 g_assert(data_dirs && data_dirs[0]);
236
237 return g_strdup(data_dirs[0]);
238}
239
240void 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}
258
259int getpagesize(void)
260{
261 SYSTEM_INFO system_info;
262
263 GetSystemInfo(&system_info);
264 return system_info.dwPageSize;
265}
266
267void qemu_prealloc_mem(int fd, char *area, size_t sz, int max_threads,
268 ThreadContext *tc, Error **errp)
269{
270 int i;
271 size_t pagesize = qemu_real_host_page_size();
272
273 sz = (sz + pagesize - 1) & -pagesize;
274 for (i = 0; i < sz / pagesize; i++) {
275 memset(area + pagesize * i, 0, 1);
276 }
277}
278
279char *qemu_get_pid_name(pid_t pid)
280{
281
282 abort();
283}
284
285
286bool qemu_socket_select(int sockfd, WSAEVENT hEventObject,
287 long lNetworkEvents, Error **errp)
288{
289 SOCKET s = _get_osfhandle(sockfd);
290
291 if (errp == NULL) {
292 errp = &error_warn;
293 }
294
295 if (s == INVALID_SOCKET) {
296 error_setg(errp, "invalid socket fd=%d", sockfd);
297 return false;
298 }
299
300 if (WSAEventSelect(s, hEventObject, lNetworkEvents) != 0) {
301 error_setg_win32(errp, WSAGetLastError(), "failed to WSAEventSelect()");
302 return false;
303 }
304
305 return true;
306}
307
308bool qemu_socket_unselect(int sockfd, Error **errp)
309{
310 return qemu_socket_select(sockfd, NULL, 0, errp);
311}
312
313int qemu_socketpair(int domain, int type, int protocol, int sv[2])
314{
315 struct sockaddr_un addr = {
316 0,
317 };
318 socklen_t socklen;
319 int listener = -1;
320 int client = -1;
321 int server = -1;
322 g_autofree char *path = NULL;
323 int tmpfd;
324 u_long arg;
325 int ret = -1;
326
327 g_return_val_if_fail(sv != NULL, -1);
328
329 addr.sun_family = AF_UNIX;
330 socklen = sizeof(addr);
331
332 tmpfd = g_file_open_tmp(NULL, &path, NULL);
333 if (tmpfd == -1 || !path) {
334 errno = EACCES;
335 goto out;
336 }
337
338 close(tmpfd);
339
340 if (strlen(path) >= sizeof(addr.sun_path)) {
341 errno = EINVAL;
342 goto out;
343 }
344
345 strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
346
347 listener = socket(domain, type, protocol);
348 if (listener == -1) {
349 goto out;
350 }
351
352 if (DeleteFile(path) == 0 && GetLastError() != ERROR_FILE_NOT_FOUND) {
353 errno = EACCES;
354 goto out;
355 }
356 g_clear_pointer(&path, g_free);
357
358 if (bind(listener, (struct sockaddr *)&addr, socklen) == -1) {
359 goto out;
360 }
361
362 if (listen(listener, 1) == -1) {
363 goto out;
364 }
365
366 client = socket(domain, type, protocol);
367 if (client == -1) {
368 goto out;
369 }
370
371 arg = 1;
372 if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
373 goto out;
374 }
375
376 if (connect(client, (struct sockaddr *)&addr, socklen) == -1 &&
377 WSAGetLastError() != WSAEWOULDBLOCK) {
378 goto out;
379 }
380
381 server = accept(listener, NULL, NULL);
382 if (server == -1) {
383 goto out;
384 }
385
386 arg = 0;
387 if (ioctlsocket(client, FIONBIO, &arg) != NO_ERROR) {
388 goto out;
389 }
390
391 arg = 0;
392 if (ioctlsocket(client, SIO_AF_UNIX_GETPEERPID, &arg) != NO_ERROR) {
393 goto out;
394 }
395
396 if (arg != GetCurrentProcessId()) {
397 errno = EPERM;
398 goto out;
399 }
400
401 sv[0] = server;
402 server = -1;
403 sv[1] = client;
404 client = -1;
405 ret = 0;
406
407out:
408 if (listener != -1) {
409 close(listener);
410 }
411 if (client != -1) {
412 close(client);
413 }
414 if (server != -1) {
415 close(server);
416 }
417 if (path) {
418 DeleteFile(path);
419 }
420 return ret;
421}
422
423#undef connect
424int qemu_connect_wrap(int sockfd, const struct sockaddr *addr,
425 socklen_t addrlen)
426{
427 int ret;
428 SOCKET s = _get_osfhandle(sockfd);
429
430 if (s == INVALID_SOCKET) {
431 return -1;
432 }
433
434 ret = connect(s, addr, addrlen);
435 if (ret < 0) {
436 if (WSAGetLastError() == WSAEWOULDBLOCK) {
437 errno = EINPROGRESS;
438 } else {
439 errno = socket_error();
440 }
441 }
442 return ret;
443}
444
445
446#undef listen
447int qemu_listen_wrap(int sockfd, int backlog)
448{
449 int ret;
450 SOCKET s = _get_osfhandle(sockfd);
451
452 if (s == INVALID_SOCKET) {
453 return -1;
454 }
455
456 ret = listen(s, backlog);
457 if (ret < 0) {
458 errno = socket_error();
459 }
460 return ret;
461}
462
463
464#undef bind
465int qemu_bind_wrap(int sockfd, const struct sockaddr *addr,
466 socklen_t addrlen)
467{
468 int ret;
469 SOCKET s = _get_osfhandle(sockfd);
470
471 if (s == INVALID_SOCKET) {
472 return -1;
473 }
474
475 ret = bind(s, addr, addrlen);
476 if (ret < 0) {
477 errno = socket_error();
478 }
479 return ret;
480}
481
482EXCEPTION_DISPOSITION
483win32_close_exception_handler(struct _EXCEPTION_RECORD *exception_record,
484 void *registration, struct _CONTEXT *context,
485 void *dispatcher)
486{
487 return EXCEPTION_EXECUTE_HANDLER;
488}
489
490#undef close
491int qemu_close_socket_osfhandle(int fd)
492{
493 SOCKET s = _get_osfhandle(fd);
494 DWORD flags = 0;
495
496
497
498
499
500
501
502
503
504
505 if (!GetHandleInformation((HANDLE)s, &flags)) {
506 errno = EACCES;
507 return -1;
508 }
509
510 if (!SetHandleInformation((HANDLE)s, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE)) {
511 errno = EACCES;
512 return -1;
513 }
514
515 __try1(win32_close_exception_handler) {
516
517
518
519
520 if (close(fd) < 0 && errno != EBADF) {
521 return -1;
522 }
523 }
524 __except1 {
525 }
526
527 if (!SetHandleInformation((HANDLE)s, flags, flags)) {
528 errno = EACCES;
529 return -1;
530 }
531
532 return 0;
533}
534
535int qemu_close_wrap(int fd)
536{
537 SOCKET s = INVALID_SOCKET;
538 int ret = -1;
539
540 if (!fd_is_socket(fd)) {
541 return close(fd);
542 }
543
544 s = _get_osfhandle(fd);
545 qemu_close_socket_osfhandle(fd);
546
547 ret = closesocket(s);
548 if (ret < 0) {
549 errno = socket_error();
550 }
551
552 return ret;
553}
554
555
556#undef socket
557int qemu_socket_wrap(int domain, int type, int protocol)
558{
559 SOCKET s;
560 int fd;
561
562 s = socket(domain, type, protocol);
563 if (s == -1) {
564 errno = socket_error();
565 return -1;
566 }
567
568 fd = _open_osfhandle(s, _O_BINARY);
569 if (fd < 0) {
570 closesocket(s);
571
572 errno = ENOMEM;
573 }
574
575 return fd;
576}
577
578
579#undef accept
580int qemu_accept_wrap(int sockfd, struct sockaddr *addr,
581 socklen_t *addrlen)
582{
583 int fd;
584 SOCKET s = _get_osfhandle(sockfd);
585
586 if (s == INVALID_SOCKET) {
587 return -1;
588 }
589
590 s = accept(s, addr, addrlen);
591 if (s == -1) {
592 errno = socket_error();
593 return -1;
594 }
595
596 fd = _open_osfhandle(s, _O_BINARY);
597 if (fd < 0) {
598 closesocket(s);
599
600 errno = ENOMEM;
601 }
602
603 return fd;
604}
605
606
607#undef shutdown
608int qemu_shutdown_wrap(int sockfd, int how)
609{
610 int ret;
611 SOCKET s = _get_osfhandle(sockfd);
612
613 if (s == INVALID_SOCKET) {
614 return -1;
615 }
616
617 ret = shutdown(s, how);
618 if (ret < 0) {
619 errno = socket_error();
620 }
621 return ret;
622}
623
624
625#undef ioctlsocket
626int qemu_ioctlsocket_wrap(int fd, int req, void *val)
627{
628 int ret;
629 SOCKET s = _get_osfhandle(fd);
630
631 if (s == INVALID_SOCKET) {
632 return -1;
633 }
634
635 ret = ioctlsocket(s, req, val);
636 if (ret < 0) {
637 errno = socket_error();
638 }
639 return ret;
640}
641
642
643#undef getsockopt
644int qemu_getsockopt_wrap(int sockfd, int level, int optname,
645 void *optval, socklen_t *optlen)
646{
647 int ret;
648 SOCKET s = _get_osfhandle(sockfd);
649
650 if (s == INVALID_SOCKET) {
651 return -1;
652 }
653
654 ret = getsockopt(s, level, optname, optval, optlen);
655 if (ret < 0) {
656 errno = socket_error();
657 }
658 return ret;
659}
660
661
662#undef setsockopt
663int qemu_setsockopt_wrap(int sockfd, int level, int optname,
664 const void *optval, socklen_t optlen)
665{
666 int ret;
667 SOCKET s = _get_osfhandle(sockfd);
668
669 if (s == INVALID_SOCKET) {
670 return -1;
671 }
672
673 ret = setsockopt(s, level, optname, optval, optlen);
674 if (ret < 0) {
675 errno = socket_error();
676 }
677 return ret;
678}
679
680
681#undef getpeername
682int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr,
683 socklen_t *addrlen)
684{
685 int ret;
686 SOCKET s = _get_osfhandle(sockfd);
687
688 if (s == INVALID_SOCKET) {
689 return -1;
690 }
691
692 ret = getpeername(s, addr, addrlen);
693 if (ret < 0) {
694 errno = socket_error();
695 }
696 return ret;
697}
698
699
700#undef getsockname
701int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr,
702 socklen_t *addrlen)
703{
704 int ret;
705 SOCKET s = _get_osfhandle(sockfd);
706
707 if (s == INVALID_SOCKET) {
708 return -1;
709 }
710
711 ret = getsockname(s, addr, addrlen);
712 if (ret < 0) {
713 errno = socket_error();
714 }
715 return ret;
716}
717
718
719#undef send
720ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags)
721{
722 int ret;
723 SOCKET s = _get_osfhandle(sockfd);
724
725 if (s == INVALID_SOCKET) {
726 return -1;
727 }
728
729 ret = send(s, buf, len, flags);
730 if (ret < 0) {
731 errno = socket_error();
732 }
733 return ret;
734}
735
736
737#undef sendto
738ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags,
739 const struct sockaddr *addr, socklen_t addrlen)
740{
741 int ret;
742 SOCKET s = _get_osfhandle(sockfd);
743
744 if (s == INVALID_SOCKET) {
745 return -1;
746 }
747
748 ret = sendto(s, buf, len, flags, addr, addrlen);
749 if (ret < 0) {
750 errno = socket_error();
751 }
752 return ret;
753}
754
755
756#undef recv
757ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags)
758{
759 int ret;
760 SOCKET s = _get_osfhandle(sockfd);
761
762 if (s == INVALID_SOCKET) {
763 return -1;
764 }
765
766 ret = recv(s, buf, len, flags);
767 if (ret < 0) {
768 errno = socket_error();
769 }
770 return ret;
771}
772
773
774#undef recvfrom
775ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags,
776 struct sockaddr *addr, socklen_t *addrlen)
777{
778 int ret;
779 SOCKET s = _get_osfhandle(sockfd);
780
781 if (s == INVALID_SOCKET) {
782 return -1;
783 }
784
785 ret = recvfrom(s, buf, len, flags, addr, addrlen);
786 if (ret < 0) {
787 errno = socket_error();
788 }
789 return ret;
790}
791
792bool qemu_write_pidfile(const char *filename, Error **errp)
793{
794 char buffer[128];
795 int len;
796 HANDLE file;
797 OVERLAPPED overlap;
798 BOOL ret;
799 memset(&overlap, 0, sizeof(overlap));
800
801 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL,
802 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
803
804 if (file == INVALID_HANDLE_VALUE) {
805 error_setg(errp, "Failed to create PID file");
806 return false;
807 }
808 len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid());
809 ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len,
810 NULL, &overlap);
811 CloseHandle(file);
812 if (ret == 0) {
813 error_setg(errp, "Failed to write PID file");
814 return false;
815 }
816 return true;
817}
818
819size_t qemu_get_host_physmem(void)
820{
821 MEMORYSTATUSEX statex;
822 statex.dwLength = sizeof(statex);
823
824 if (GlobalMemoryStatusEx(&statex)) {
825 return statex.ullTotalPhys;
826 }
827 return 0;
828}
829
830int qemu_msync(void *addr, size_t length, int fd)
831{
832
833
834
835
836
837 return qemu_fdatasync(fd);
838}
839
840void *qemu_win32_map_alloc(size_t size, HANDLE *h, Error **errp)
841{
842 void *bits;
843
844 trace_win32_map_alloc(size);
845
846 *h = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
847 size, NULL);
848 if (*h == NULL) {
849 error_setg_win32(errp, GetLastError(), "Failed to CreateFileMapping");
850 return NULL;
851 }
852
853 bits = MapViewOfFile(*h, FILE_MAP_ALL_ACCESS, 0, 0, size);
854 if (bits == NULL) {
855 error_setg_win32(errp, GetLastError(), "Failed to MapViewOfFile");
856 CloseHandle(*h);
857 return NULL;
858 }
859
860 return bits;
861}
862
863void qemu_win32_map_free(void *ptr, HANDLE h, Error **errp)
864{
865 trace_win32_map_free(ptr, h);
866
867 if (UnmapViewOfFile(ptr) == 0) {
868 error_setg_win32(errp, GetLastError(), "Failed to UnmapViewOfFile");
869 }
870 CloseHandle(h);
871}
872