1 /* 2 * os-win32.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010-2016 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 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 39 static int get_allocation_granularity(void) 40 { 41 SYSTEM_INFO system_info; 42 43 GetSystemInfo(&system_info); 44 return system_info.dwAllocationGranularity; 45 } 46 47 void *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 * We need a MEM_COMMIT before accessing any memory in a MEM_RESERVE 55 * area; we cannot easily mimic POSIX MAP_NORESERVE semantics. 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 70 void 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 /* FIXME: add proper locking */ 80 struct 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 /* FIXME: add proper locking */ 92 struct 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 /* _POSIX_THREAD_SAFE_FUNCTIONS */ 103 104 static 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 /* not using EWOULDBLOCK as we don't want code to have 125 * to check both EWOULDBLOCK and EAGAIN */ 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 180 void 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 187 int 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 196 void qemu_socket_set_nonblock(int fd) 197 { 198 (void)qemu_socket_try_set_nonblock(fd); 199 } 200 201 int socket_set_fast_reuse(int fd) 202 { 203 /* Enabling the reuse of an endpoint that was used by a socket still in 204 * TIME_WAIT state is usually performed by setting SO_REUSEADDR. On Windows 205 * fast reuse is the default and SO_REUSEADDR does strange things. So we 206 * don't have to do anything here. More info can be found at: 207 * http://msdn.microsoft.com/en-us/library/windows/desktop/ms740621.aspx */ 208 return 0; 209 } 210 211 int 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 221 void qemu_set_cloexec(int fd) 222 { 223 } 224 225 int qemu_get_thread_id(void) 226 { 227 return GetCurrentThreadId(); 228 } 229 230 char * 231 qemu_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 240 void 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 259 int getpagesize(void) 260 { 261 SYSTEM_INFO system_info; 262 263 GetSystemInfo(&system_info); 264 return system_info.dwPageSize; 265 } 266 267 void 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 279 char *qemu_get_pid_name(pid_t pid) 280 { 281 /* XXX Implement me */ 282 abort(); 283 } 284 285 286 bool 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 308 bool qemu_socket_unselect(int sockfd, Error **errp) 309 { 310 return qemu_socket_select(sockfd, NULL, 0, errp); 311 } 312 313 #undef connect 314 int qemu_connect_wrap(int sockfd, const struct sockaddr *addr, 315 socklen_t addrlen) 316 { 317 int ret; 318 SOCKET s = _get_osfhandle(sockfd); 319 320 if (s == INVALID_SOCKET) { 321 return -1; 322 } 323 324 ret = connect(s, addr, addrlen); 325 if (ret < 0) { 326 if (WSAGetLastError() == WSAEWOULDBLOCK) { 327 errno = EINPROGRESS; 328 } else { 329 errno = socket_error(); 330 } 331 } 332 return ret; 333 } 334 335 336 #undef listen 337 int qemu_listen_wrap(int sockfd, int backlog) 338 { 339 int ret; 340 SOCKET s = _get_osfhandle(sockfd); 341 342 if (s == INVALID_SOCKET) { 343 return -1; 344 } 345 346 ret = listen(s, backlog); 347 if (ret < 0) { 348 errno = socket_error(); 349 } 350 return ret; 351 } 352 353 354 #undef bind 355 int qemu_bind_wrap(int sockfd, const struct sockaddr *addr, 356 socklen_t addrlen) 357 { 358 int ret; 359 SOCKET s = _get_osfhandle(sockfd); 360 361 if (s == INVALID_SOCKET) { 362 return -1; 363 } 364 365 ret = bind(s, addr, addrlen); 366 if (ret < 0) { 367 errno = socket_error(); 368 } 369 return ret; 370 } 371 372 373 #undef close 374 int qemu_close_wrap(int fd) 375 { 376 int ret; 377 DWORD flags = 0; 378 SOCKET s = INVALID_SOCKET; 379 380 if (fd_is_socket(fd)) { 381 s = _get_osfhandle(fd); 382 383 /* 384 * If we were to just call _close on the descriptor, it would close the 385 * HANDLE, but it wouldn't free any of the resources associated to the 386 * SOCKET, and we can't call _close after calling closesocket, because 387 * closesocket has already closed the HANDLE, and _close would attempt to 388 * close the HANDLE again, resulting in a double free. We can however 389 * protect the HANDLE from actually being closed long enough to close the 390 * file descriptor, then close the socket itself. 391 */ 392 if (!GetHandleInformation((HANDLE)s, &flags)) { 393 errno = EACCES; 394 return -1; 395 } 396 397 if (!SetHandleInformation((HANDLE)s, HANDLE_FLAG_PROTECT_FROM_CLOSE, HANDLE_FLAG_PROTECT_FROM_CLOSE)) { 398 errno = EACCES; 399 return -1; 400 } 401 } 402 403 ret = close(fd); 404 405 if (s != INVALID_SOCKET && !SetHandleInformation((HANDLE)s, flags, flags)) { 406 errno = EACCES; 407 return -1; 408 } 409 410 /* 411 * close() returns EBADF since we PROTECT_FROM_CLOSE the underlying handle, 412 * but the FD is actually freed 413 */ 414 if (ret < 0 && (s == INVALID_SOCKET || errno != EBADF)) { 415 return ret; 416 } 417 418 if (s != INVALID_SOCKET) { 419 ret = closesocket(s); 420 if (ret < 0) { 421 errno = socket_error(); 422 } 423 } 424 425 return ret; 426 } 427 428 429 #undef socket 430 int qemu_socket_wrap(int domain, int type, int protocol) 431 { 432 SOCKET s; 433 int fd; 434 435 s = socket(domain, type, protocol); 436 if (s == -1) { 437 errno = socket_error(); 438 return -1; 439 } 440 441 fd = _open_osfhandle(s, _O_BINARY); 442 if (fd < 0) { 443 closesocket(s); 444 /* _open_osfhandle may not set errno, and closesocket() may override it */ 445 errno = ENOMEM; 446 } 447 448 return fd; 449 } 450 451 452 #undef accept 453 int qemu_accept_wrap(int sockfd, struct sockaddr *addr, 454 socklen_t *addrlen) 455 { 456 int fd; 457 SOCKET s = _get_osfhandle(sockfd); 458 459 if (s == INVALID_SOCKET) { 460 return -1; 461 } 462 463 s = accept(s, addr, addrlen); 464 if (s == -1) { 465 errno = socket_error(); 466 return -1; 467 } 468 469 fd = _open_osfhandle(s, _O_BINARY); 470 if (fd < 0) { 471 closesocket(s); 472 /* _open_osfhandle may not set errno, and closesocket() may override it */ 473 errno = ENOMEM; 474 } 475 476 return fd; 477 } 478 479 480 #undef shutdown 481 int qemu_shutdown_wrap(int sockfd, int how) 482 { 483 int ret; 484 SOCKET s = _get_osfhandle(sockfd); 485 486 if (s == INVALID_SOCKET) { 487 return -1; 488 } 489 490 ret = shutdown(s, how); 491 if (ret < 0) { 492 errno = socket_error(); 493 } 494 return ret; 495 } 496 497 498 #undef ioctlsocket 499 int qemu_ioctlsocket_wrap(int fd, int req, void *val) 500 { 501 int ret; 502 SOCKET s = _get_osfhandle(fd); 503 504 if (s == INVALID_SOCKET) { 505 return -1; 506 } 507 508 ret = ioctlsocket(s, req, val); 509 if (ret < 0) { 510 errno = socket_error(); 511 } 512 return ret; 513 } 514 515 516 #undef getsockopt 517 int qemu_getsockopt_wrap(int sockfd, int level, int optname, 518 void *optval, socklen_t *optlen) 519 { 520 int ret; 521 SOCKET s = _get_osfhandle(sockfd); 522 523 if (s == INVALID_SOCKET) { 524 return -1; 525 } 526 527 ret = getsockopt(s, level, optname, optval, optlen); 528 if (ret < 0) { 529 errno = socket_error(); 530 } 531 return ret; 532 } 533 534 535 #undef setsockopt 536 int qemu_setsockopt_wrap(int sockfd, int level, int optname, 537 const void *optval, socklen_t optlen) 538 { 539 int ret; 540 SOCKET s = _get_osfhandle(sockfd); 541 542 if (s == INVALID_SOCKET) { 543 return -1; 544 } 545 546 ret = setsockopt(s, level, optname, optval, optlen); 547 if (ret < 0) { 548 errno = socket_error(); 549 } 550 return ret; 551 } 552 553 554 #undef getpeername 555 int qemu_getpeername_wrap(int sockfd, struct sockaddr *addr, 556 socklen_t *addrlen) 557 { 558 int ret; 559 SOCKET s = _get_osfhandle(sockfd); 560 561 if (s == INVALID_SOCKET) { 562 return -1; 563 } 564 565 ret = getpeername(s, addr, addrlen); 566 if (ret < 0) { 567 errno = socket_error(); 568 } 569 return ret; 570 } 571 572 573 #undef getsockname 574 int qemu_getsockname_wrap(int sockfd, struct sockaddr *addr, 575 socklen_t *addrlen) 576 { 577 int ret; 578 SOCKET s = _get_osfhandle(sockfd); 579 580 if (s == INVALID_SOCKET) { 581 return -1; 582 } 583 584 ret = getsockname(s, addr, addrlen); 585 if (ret < 0) { 586 errno = socket_error(); 587 } 588 return ret; 589 } 590 591 592 #undef send 593 ssize_t qemu_send_wrap(int sockfd, const void *buf, size_t len, int flags) 594 { 595 int ret; 596 SOCKET s = _get_osfhandle(sockfd); 597 598 if (s == INVALID_SOCKET) { 599 return -1; 600 } 601 602 ret = send(s, buf, len, flags); 603 if (ret < 0) { 604 errno = socket_error(); 605 } 606 return ret; 607 } 608 609 610 #undef sendto 611 ssize_t qemu_sendto_wrap(int sockfd, const void *buf, size_t len, int flags, 612 const struct sockaddr *addr, socklen_t addrlen) 613 { 614 int ret; 615 SOCKET s = _get_osfhandle(sockfd); 616 617 if (s == INVALID_SOCKET) { 618 return -1; 619 } 620 621 ret = sendto(s, buf, len, flags, addr, addrlen); 622 if (ret < 0) { 623 errno = socket_error(); 624 } 625 return ret; 626 } 627 628 629 #undef recv 630 ssize_t qemu_recv_wrap(int sockfd, void *buf, size_t len, int flags) 631 { 632 int ret; 633 SOCKET s = _get_osfhandle(sockfd); 634 635 if (s == INVALID_SOCKET) { 636 return -1; 637 } 638 639 ret = recv(s, buf, len, flags); 640 if (ret < 0) { 641 errno = socket_error(); 642 } 643 return ret; 644 } 645 646 647 #undef recvfrom 648 ssize_t qemu_recvfrom_wrap(int sockfd, void *buf, size_t len, int flags, 649 struct sockaddr *addr, socklen_t *addrlen) 650 { 651 int ret; 652 SOCKET s = _get_osfhandle(sockfd); 653 654 if (s == INVALID_SOCKET) { 655 return -1; 656 } 657 658 ret = recvfrom(s, buf, len, flags, addr, addrlen); 659 if (ret < 0) { 660 errno = socket_error(); 661 } 662 return ret; 663 } 664 665 bool qemu_write_pidfile(const char *filename, Error **errp) 666 { 667 char buffer[128]; 668 int len; 669 HANDLE file; 670 OVERLAPPED overlap; 671 BOOL ret; 672 memset(&overlap, 0, sizeof(overlap)); 673 674 file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, 675 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 676 677 if (file == INVALID_HANDLE_VALUE) { 678 error_setg(errp, "Failed to create PID file"); 679 return false; 680 } 681 len = snprintf(buffer, sizeof(buffer), FMT_pid "\n", (pid_t)getpid()); 682 ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len, 683 NULL, &overlap); 684 CloseHandle(file); 685 if (ret == 0) { 686 error_setg(errp, "Failed to write PID file"); 687 return false; 688 } 689 return true; 690 } 691 692 size_t qemu_get_host_physmem(void) 693 { 694 MEMORYSTATUSEX statex; 695 statex.dwLength = sizeof(statex); 696 697 if (GlobalMemoryStatusEx(&statex)) { 698 return statex.ullTotalPhys; 699 } 700 return 0; 701 } 702 703 int qemu_msync(void *addr, size_t length, int fd) 704 { 705 /** 706 * Perform the sync based on the file descriptor 707 * The sync range will most probably be wider than the one 708 * requested - but it will still get the job done 709 */ 710 return qemu_fdatasync(fd); 711 } 712