1 /* 2 * os-posix-lib.c 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2010 Red Hat, Inc. 6 * 7 * QEMU library functions on POSIX 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 <termios.h> 31 32 #include <glib/gprintf.h> 33 34 #include "qemu-common.h" 35 #include "sysemu/sysemu.h" 36 #include "trace.h" 37 #include "qapi/error.h" 38 #include "qemu/error-report.h" 39 #include "qemu/madvise.h" 40 #include "qemu/sockets.h" 41 #include "qemu/thread.h" 42 #include <libgen.h> 43 #include "qemu/cutils.h" 44 #include "qemu/compiler.h" 45 #include "qemu/units.h" 46 47 #ifdef CONFIG_LINUX 48 #include <sys/syscall.h> 49 #endif 50 51 #ifdef __FreeBSD__ 52 #include <sys/sysctl.h> 53 #include <sys/user.h> 54 #include <sys/thr.h> 55 #include <libutil.h> 56 #endif 57 58 #ifdef __NetBSD__ 59 #include <sys/sysctl.h> 60 #include <lwp.h> 61 #endif 62 63 #ifdef __APPLE__ 64 #include <mach-o/dyld.h> 65 #endif 66 67 #ifdef __HAIKU__ 68 #include <kernel/image.h> 69 #endif 70 71 #include "qemu/mmap-alloc.h" 72 73 #ifdef CONFIG_DEBUG_STACK_USAGE 74 #include "qemu/error-report.h" 75 #endif 76 77 #define MAX_MEM_PREALLOC_THREAD_COUNT 16 78 79 struct MemsetThread; 80 81 typedef struct MemsetContext { 82 bool all_threads_created; 83 bool any_thread_failed; 84 struct MemsetThread *threads; 85 int num_threads; 86 } MemsetContext; 87 88 struct MemsetThread { 89 char *addr; 90 size_t numpages; 91 size_t hpagesize; 92 QemuThread pgthread; 93 sigjmp_buf env; 94 MemsetContext *context; 95 }; 96 typedef struct MemsetThread MemsetThread; 97 98 /* used by sigbus_handler() */ 99 static MemsetContext *sigbus_memset_context; 100 struct sigaction sigbus_oldact; 101 static QemuMutex sigbus_mutex; 102 103 static QemuMutex page_mutex; 104 static QemuCond page_cond; 105 106 int qemu_get_thread_id(void) 107 { 108 #if defined(__linux__) 109 return syscall(SYS_gettid); 110 #elif defined(__FreeBSD__) 111 /* thread id is up to INT_MAX */ 112 long tid; 113 thr_self(&tid); 114 return (int)tid; 115 #elif defined(__NetBSD__) 116 return _lwp_self(); 117 #elif defined(__OpenBSD__) 118 return getthrid(); 119 #else 120 return getpid(); 121 #endif 122 } 123 124 int qemu_daemon(int nochdir, int noclose) 125 { 126 return daemon(nochdir, noclose); 127 } 128 129 bool qemu_write_pidfile(const char *path, Error **errp) 130 { 131 int fd; 132 char pidstr[32]; 133 134 while (1) { 135 struct stat a, b; 136 struct flock lock = { 137 .l_type = F_WRLCK, 138 .l_whence = SEEK_SET, 139 .l_len = 0, 140 }; 141 142 fd = qemu_open_old(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); 143 if (fd == -1) { 144 error_setg_errno(errp, errno, "Cannot open pid file"); 145 return false; 146 } 147 148 if (fstat(fd, &b) < 0) { 149 error_setg_errno(errp, errno, "Cannot stat file"); 150 goto fail_close; 151 } 152 153 if (fcntl(fd, F_SETLK, &lock)) { 154 error_setg_errno(errp, errno, "Cannot lock pid file"); 155 goto fail_close; 156 } 157 158 /* 159 * Now make sure the path we locked is the same one that now 160 * exists on the filesystem. 161 */ 162 if (stat(path, &a) < 0) { 163 /* 164 * PID file disappeared, someone else must be racing with 165 * us, so try again. 166 */ 167 close(fd); 168 continue; 169 } 170 171 if (a.st_ino == b.st_ino) { 172 break; 173 } 174 175 /* 176 * PID file was recreated, someone else must be racing with 177 * us, so try again. 178 */ 179 close(fd); 180 } 181 182 if (ftruncate(fd, 0) < 0) { 183 error_setg_errno(errp, errno, "Failed to truncate pid file"); 184 goto fail_unlink; 185 } 186 187 snprintf(pidstr, sizeof(pidstr), FMT_pid "\n", getpid()); 188 if (write(fd, pidstr, strlen(pidstr)) != strlen(pidstr)) { 189 error_setg(errp, "Failed to write pid file"); 190 goto fail_unlink; 191 } 192 193 return true; 194 195 fail_unlink: 196 unlink(path); 197 fail_close: 198 close(fd); 199 return false; 200 } 201 202 void *qemu_oom_check(void *ptr) 203 { 204 if (ptr == NULL) { 205 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno)); 206 abort(); 207 } 208 return ptr; 209 } 210 211 void *qemu_try_memalign(size_t alignment, size_t size) 212 { 213 void *ptr; 214 215 if (alignment < sizeof(void*)) { 216 alignment = sizeof(void*); 217 } else { 218 g_assert(is_power_of_2(alignment)); 219 } 220 221 #if defined(CONFIG_POSIX_MEMALIGN) 222 int ret; 223 ret = posix_memalign(&ptr, alignment, size); 224 if (ret != 0) { 225 errno = ret; 226 ptr = NULL; 227 } 228 #elif defined(CONFIG_BSD) 229 ptr = valloc(size); 230 #else 231 ptr = memalign(alignment, size); 232 #endif 233 trace_qemu_memalign(alignment, size, ptr); 234 return ptr; 235 } 236 237 void *qemu_memalign(size_t alignment, size_t size) 238 { 239 return qemu_oom_check(qemu_try_memalign(alignment, size)); 240 } 241 242 /* alloc shared memory pages */ 243 void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment, bool shared, 244 bool noreserve) 245 { 246 const uint32_t qemu_map_flags = (shared ? QEMU_MAP_SHARED : 0) | 247 (noreserve ? QEMU_MAP_NORESERVE : 0); 248 size_t align = QEMU_VMALLOC_ALIGN; 249 void *ptr = qemu_ram_mmap(-1, size, align, qemu_map_flags, 0); 250 251 if (ptr == MAP_FAILED) { 252 return NULL; 253 } 254 255 if (alignment) { 256 *alignment = align; 257 } 258 259 trace_qemu_anon_ram_alloc(size, ptr); 260 return ptr; 261 } 262 263 void qemu_vfree(void *ptr) 264 { 265 trace_qemu_vfree(ptr); 266 free(ptr); 267 } 268 269 void qemu_anon_ram_free(void *ptr, size_t size) 270 { 271 trace_qemu_anon_ram_free(ptr, size); 272 qemu_ram_munmap(-1, ptr, size); 273 } 274 275 void qemu_set_block(int fd) 276 { 277 int f; 278 f = fcntl(fd, F_GETFL); 279 assert(f != -1); 280 f = fcntl(fd, F_SETFL, f & ~O_NONBLOCK); 281 assert(f != -1); 282 } 283 284 int qemu_try_set_nonblock(int fd) 285 { 286 int f; 287 f = fcntl(fd, F_GETFL); 288 if (f == -1) { 289 return -errno; 290 } 291 if (fcntl(fd, F_SETFL, f | O_NONBLOCK) == -1) { 292 return -errno; 293 } 294 return 0; 295 } 296 297 void qemu_set_nonblock(int fd) 298 { 299 int f; 300 f = qemu_try_set_nonblock(fd); 301 assert(f == 0); 302 } 303 304 int socket_set_fast_reuse(int fd) 305 { 306 int val = 1, ret; 307 308 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 309 (const char *)&val, sizeof(val)); 310 311 assert(ret == 0); 312 313 return ret; 314 } 315 316 void qemu_set_cloexec(int fd) 317 { 318 int f; 319 f = fcntl(fd, F_GETFD); 320 assert(f != -1); 321 f = fcntl(fd, F_SETFD, f | FD_CLOEXEC); 322 assert(f != -1); 323 } 324 325 /* 326 * Creates a pipe with FD_CLOEXEC set on both file descriptors 327 */ 328 int qemu_pipe(int pipefd[2]) 329 { 330 int ret; 331 332 #ifdef CONFIG_PIPE2 333 ret = pipe2(pipefd, O_CLOEXEC); 334 if (ret != -1 || errno != ENOSYS) { 335 return ret; 336 } 337 #endif 338 ret = pipe(pipefd); 339 if (ret == 0) { 340 qemu_set_cloexec(pipefd[0]); 341 qemu_set_cloexec(pipefd[1]); 342 } 343 344 return ret; 345 } 346 347 char * 348 qemu_get_local_state_pathname(const char *relative_pathname) 349 { 350 g_autofree char *dir = g_strdup_printf("%s/%s", 351 CONFIG_QEMU_LOCALSTATEDIR, 352 relative_pathname); 353 return get_relocated_path(dir); 354 } 355 356 void qemu_set_tty_echo(int fd, bool echo) 357 { 358 struct termios tty; 359 360 tcgetattr(fd, &tty); 361 362 if (echo) { 363 tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN; 364 } else { 365 tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN); 366 } 367 368 tcsetattr(fd, TCSANOW, &tty); 369 } 370 371 static const char *exec_dir; 372 373 void qemu_init_exec_dir(const char *argv0) 374 { 375 char *p = NULL; 376 char buf[PATH_MAX]; 377 378 if (exec_dir) { 379 return; 380 } 381 382 #if defined(__linux__) 383 { 384 int len; 385 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1); 386 if (len > 0) { 387 buf[len] = 0; 388 p = buf; 389 } 390 } 391 #elif defined(__FreeBSD__) \ 392 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME)) 393 { 394 #if defined(__FreeBSD__) 395 static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1}; 396 #else 397 static int mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME}; 398 #endif 399 size_t len = sizeof(buf) - 1; 400 401 *buf = '\0'; 402 if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) && 403 *buf) { 404 buf[sizeof(buf) - 1] = '\0'; 405 p = buf; 406 } 407 } 408 #elif defined(__APPLE__) 409 { 410 char fpath[PATH_MAX]; 411 uint32_t len = sizeof(fpath); 412 if (_NSGetExecutablePath(fpath, &len) == 0) { 413 p = realpath(fpath, buf); 414 if (!p) { 415 return; 416 } 417 } 418 } 419 #elif defined(__HAIKU__) 420 { 421 image_info ii; 422 int32_t c = 0; 423 424 *buf = '\0'; 425 while (get_next_image_info(0, &c, &ii) == B_OK) { 426 if (ii.type == B_APP_IMAGE) { 427 strncpy(buf, ii.name, sizeof(buf)); 428 buf[sizeof(buf) - 1] = 0; 429 p = buf; 430 break; 431 } 432 } 433 } 434 #endif 435 /* If we don't have any way of figuring out the actual executable 436 location then try argv[0]. */ 437 if (!p && argv0) { 438 p = realpath(argv0, buf); 439 } 440 if (p) { 441 exec_dir = g_path_get_dirname(p); 442 } else { 443 exec_dir = CONFIG_BINDIR; 444 } 445 } 446 447 const char *qemu_get_exec_dir(void) 448 { 449 return exec_dir; 450 } 451 452 #ifdef CONFIG_LINUX 453 static void sigbus_handler(int signal, siginfo_t *siginfo, void *ctx) 454 #else /* CONFIG_LINUX */ 455 static void sigbus_handler(int signal) 456 #endif /* CONFIG_LINUX */ 457 { 458 int i; 459 460 if (sigbus_memset_context) { 461 for (i = 0; i < sigbus_memset_context->num_threads; i++) { 462 MemsetThread *thread = &sigbus_memset_context->threads[i]; 463 464 if (qemu_thread_is_self(&thread->pgthread)) { 465 siglongjmp(thread->env, 1); 466 } 467 } 468 } 469 470 #ifdef CONFIG_LINUX 471 /* 472 * We assume that the MCE SIGBUS handler could have been registered. We 473 * should never receive BUS_MCEERR_AO on any of our threads, but only on 474 * the main thread registered for PR_MCE_KILL_EARLY. Further, we should not 475 * receive BUS_MCEERR_AR triggered by action of other threads on one of 476 * our threads. So, no need to check for unrelated SIGBUS when seeing one 477 * for our threads. 478 * 479 * We will forward to the MCE handler, which will either handle the SIGBUS 480 * or reinstall the default SIGBUS handler and reraise the SIGBUS. The 481 * default SIGBUS handler will crash the process, so we don't care. 482 */ 483 if (sigbus_oldact.sa_flags & SA_SIGINFO) { 484 sigbus_oldact.sa_sigaction(signal, siginfo, ctx); 485 return; 486 } 487 #endif /* CONFIG_LINUX */ 488 warn_report("os_mem_prealloc: unrelated SIGBUS detected and ignored"); 489 } 490 491 static void *do_touch_pages(void *arg) 492 { 493 MemsetThread *memset_args = (MemsetThread *)arg; 494 sigset_t set, oldset; 495 int ret = 0; 496 497 /* 498 * On Linux, the page faults from the loop below can cause mmap_sem 499 * contention with allocation of the thread stacks. Do not start 500 * clearing until all threads have been created. 501 */ 502 qemu_mutex_lock(&page_mutex); 503 while (!memset_args->context->all_threads_created) { 504 qemu_cond_wait(&page_cond, &page_mutex); 505 } 506 qemu_mutex_unlock(&page_mutex); 507 508 /* unblock SIGBUS */ 509 sigemptyset(&set); 510 sigaddset(&set, SIGBUS); 511 pthread_sigmask(SIG_UNBLOCK, &set, &oldset); 512 513 if (sigsetjmp(memset_args->env, 1)) { 514 ret = -EFAULT; 515 } else { 516 char *addr = memset_args->addr; 517 size_t numpages = memset_args->numpages; 518 size_t hpagesize = memset_args->hpagesize; 519 size_t i; 520 for (i = 0; i < numpages; i++) { 521 /* 522 * Read & write back the same value, so we don't 523 * corrupt existing user/app data that might be 524 * stored. 525 * 526 * 'volatile' to stop compiler optimizing this away 527 * to a no-op 528 */ 529 *(volatile char *)addr = *addr; 530 addr += hpagesize; 531 } 532 } 533 pthread_sigmask(SIG_SETMASK, &oldset, NULL); 534 return (void *)(uintptr_t)ret; 535 } 536 537 static void *do_madv_populate_write_pages(void *arg) 538 { 539 MemsetThread *memset_args = (MemsetThread *)arg; 540 const size_t size = memset_args->numpages * memset_args->hpagesize; 541 char * const addr = memset_args->addr; 542 int ret = 0; 543 544 /* See do_touch_pages(). */ 545 qemu_mutex_lock(&page_mutex); 546 while (!memset_args->context->all_threads_created) { 547 qemu_cond_wait(&page_cond, &page_mutex); 548 } 549 qemu_mutex_unlock(&page_mutex); 550 551 if (size && qemu_madvise(addr, size, QEMU_MADV_POPULATE_WRITE)) { 552 ret = -errno; 553 } 554 return (void *)(uintptr_t)ret; 555 } 556 557 static inline int get_memset_num_threads(size_t hpagesize, size_t numpages, 558 int smp_cpus) 559 { 560 long host_procs = sysconf(_SC_NPROCESSORS_ONLN); 561 int ret = 1; 562 563 if (host_procs > 0) { 564 ret = MIN(MIN(host_procs, MAX_MEM_PREALLOC_THREAD_COUNT), smp_cpus); 565 } 566 567 /* Especially with gigantic pages, don't create more threads than pages. */ 568 ret = MIN(ret, numpages); 569 /* Don't start threads to prealloc comparatively little memory. */ 570 ret = MIN(ret, MAX(1, hpagesize * numpages / (64 * MiB))); 571 572 /* In case sysconf() fails, we fall back to single threaded */ 573 return ret; 574 } 575 576 static int touch_all_pages(char *area, size_t hpagesize, size_t numpages, 577 int smp_cpus, bool use_madv_populate_write) 578 { 579 static gsize initialized = 0; 580 MemsetContext context = { 581 .num_threads = get_memset_num_threads(hpagesize, numpages, smp_cpus), 582 }; 583 size_t numpages_per_thread, leftover; 584 void *(*touch_fn)(void *); 585 int ret = 0, i = 0; 586 char *addr = area; 587 588 if (g_once_init_enter(&initialized)) { 589 qemu_mutex_init(&page_mutex); 590 qemu_cond_init(&page_cond); 591 g_once_init_leave(&initialized, 1); 592 } 593 594 if (use_madv_populate_write) { 595 /* Avoid creating a single thread for MADV_POPULATE_WRITE */ 596 if (context.num_threads == 1) { 597 if (qemu_madvise(area, hpagesize * numpages, 598 QEMU_MADV_POPULATE_WRITE)) { 599 return -errno; 600 } 601 return 0; 602 } 603 touch_fn = do_madv_populate_write_pages; 604 } else { 605 touch_fn = do_touch_pages; 606 } 607 608 context.threads = g_new0(MemsetThread, context.num_threads); 609 numpages_per_thread = numpages / context.num_threads; 610 leftover = numpages % context.num_threads; 611 for (i = 0; i < context.num_threads; i++) { 612 context.threads[i].addr = addr; 613 context.threads[i].numpages = numpages_per_thread + (i < leftover); 614 context.threads[i].hpagesize = hpagesize; 615 context.threads[i].context = &context; 616 qemu_thread_create(&context.threads[i].pgthread, "touch_pages", 617 touch_fn, &context.threads[i], 618 QEMU_THREAD_JOINABLE); 619 addr += context.threads[i].numpages * hpagesize; 620 } 621 622 if (!use_madv_populate_write) { 623 sigbus_memset_context = &context; 624 } 625 626 qemu_mutex_lock(&page_mutex); 627 context.all_threads_created = true; 628 qemu_cond_broadcast(&page_cond); 629 qemu_mutex_unlock(&page_mutex); 630 631 for (i = 0; i < context.num_threads; i++) { 632 int tmp = (uintptr_t)qemu_thread_join(&context.threads[i].pgthread); 633 634 if (tmp) { 635 ret = tmp; 636 } 637 } 638 639 if (!use_madv_populate_write) { 640 sigbus_memset_context = NULL; 641 } 642 g_free(context.threads); 643 644 return ret; 645 } 646 647 static bool madv_populate_write_possible(char *area, size_t pagesize) 648 { 649 return !qemu_madvise(area, pagesize, QEMU_MADV_POPULATE_WRITE) || 650 errno != EINVAL; 651 } 652 653 void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus, 654 Error **errp) 655 { 656 static gsize initialized; 657 int ret; 658 size_t hpagesize = qemu_fd_getpagesize(fd); 659 size_t numpages = DIV_ROUND_UP(memory, hpagesize); 660 bool use_madv_populate_write; 661 struct sigaction act; 662 663 /* 664 * Sense on every invocation, as MADV_POPULATE_WRITE cannot be used for 665 * some special mappings, such as mapping /dev/mem. 666 */ 667 use_madv_populate_write = madv_populate_write_possible(area, hpagesize); 668 669 if (!use_madv_populate_write) { 670 if (g_once_init_enter(&initialized)) { 671 qemu_mutex_init(&sigbus_mutex); 672 g_once_init_leave(&initialized, 1); 673 } 674 675 qemu_mutex_lock(&sigbus_mutex); 676 memset(&act, 0, sizeof(act)); 677 #ifdef CONFIG_LINUX 678 act.sa_sigaction = &sigbus_handler; 679 act.sa_flags = SA_SIGINFO; 680 #else /* CONFIG_LINUX */ 681 act.sa_handler = &sigbus_handler; 682 act.sa_flags = 0; 683 #endif /* CONFIG_LINUX */ 684 685 ret = sigaction(SIGBUS, &act, &sigbus_oldact); 686 if (ret) { 687 qemu_mutex_unlock(&sigbus_mutex); 688 error_setg_errno(errp, errno, 689 "os_mem_prealloc: failed to install signal handler"); 690 return; 691 } 692 } 693 694 /* touch pages simultaneously */ 695 ret = touch_all_pages(area, hpagesize, numpages, smp_cpus, 696 use_madv_populate_write); 697 if (ret) { 698 error_setg_errno(errp, -ret, 699 "os_mem_prealloc: preallocating memory failed"); 700 } 701 702 if (!use_madv_populate_write) { 703 ret = sigaction(SIGBUS, &sigbus_oldact, NULL); 704 if (ret) { 705 /* Terminate QEMU since it can't recover from error */ 706 perror("os_mem_prealloc: failed to reinstall signal handler"); 707 exit(1); 708 } 709 qemu_mutex_unlock(&sigbus_mutex); 710 } 711 } 712 713 char *qemu_get_pid_name(pid_t pid) 714 { 715 char *name = NULL; 716 717 #if defined(__FreeBSD__) 718 /* BSDs don't have /proc, but they provide a nice substitute */ 719 struct kinfo_proc *proc = kinfo_getproc(pid); 720 721 if (proc) { 722 name = g_strdup(proc->ki_comm); 723 free(proc); 724 } 725 #else 726 /* Assume a system with reasonable procfs */ 727 char *pid_path; 728 size_t len; 729 730 pid_path = g_strdup_printf("/proc/%d/cmdline", pid); 731 g_file_get_contents(pid_path, &name, &len, NULL); 732 g_free(pid_path); 733 #endif 734 735 return name; 736 } 737 738 739 pid_t qemu_fork(Error **errp) 740 { 741 sigset_t oldmask, newmask; 742 struct sigaction sig_action; 743 int saved_errno; 744 pid_t pid; 745 746 /* 747 * Need to block signals now, so that child process can safely 748 * kill off caller's signal handlers without a race. 749 */ 750 sigfillset(&newmask); 751 if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) { 752 error_setg_errno(errp, errno, 753 "cannot block signals"); 754 return -1; 755 } 756 757 pid = fork(); 758 saved_errno = errno; 759 760 if (pid < 0) { 761 /* attempt to restore signal mask, but ignore failure, to 762 * avoid obscuring the fork failure */ 763 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL); 764 error_setg_errno(errp, saved_errno, 765 "cannot fork child process"); 766 errno = saved_errno; 767 return -1; 768 } else if (pid) { 769 /* parent process */ 770 771 /* Restore our original signal mask now that the child is 772 * safely running. Only documented failures are EFAULT (not 773 * possible, since we are using just-grabbed mask) or EINVAL 774 * (not possible, since we are using correct arguments). */ 775 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL); 776 } else { 777 /* child process */ 778 size_t i; 779 780 /* Clear out all signal handlers from parent so nothing 781 * unexpected can happen in our child once we unblock 782 * signals */ 783 sig_action.sa_handler = SIG_DFL; 784 sig_action.sa_flags = 0; 785 sigemptyset(&sig_action.sa_mask); 786 787 for (i = 1; i < NSIG; i++) { 788 /* Only possible errors are EFAULT or EINVAL The former 789 * won't happen, the latter we expect, so no need to check 790 * return value */ 791 (void)sigaction(i, &sig_action, NULL); 792 } 793 794 /* Unmask all signals in child, since we've no idea what the 795 * caller's done with their signal mask and don't want to 796 * propagate that to children */ 797 sigemptyset(&newmask); 798 if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) { 799 Error *local_err = NULL; 800 error_setg_errno(&local_err, errno, 801 "cannot unblock signals"); 802 error_report_err(local_err); 803 _exit(1); 804 } 805 } 806 return pid; 807 } 808 809 void *qemu_alloc_stack(size_t *sz) 810 { 811 void *ptr, *guardpage; 812 int flags; 813 #ifdef CONFIG_DEBUG_STACK_USAGE 814 void *ptr2; 815 #endif 816 size_t pagesz = qemu_real_host_page_size; 817 #ifdef _SC_THREAD_STACK_MIN 818 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */ 819 long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN); 820 *sz = MAX(MAX(min_stack_sz, 0), *sz); 821 #endif 822 /* adjust stack size to a multiple of the page size */ 823 *sz = ROUND_UP(*sz, pagesz); 824 /* allocate one extra page for the guard page */ 825 *sz += pagesz; 826 827 flags = MAP_PRIVATE | MAP_ANONYMOUS; 828 #if defined(MAP_STACK) && defined(__OpenBSD__) 829 /* Only enable MAP_STACK on OpenBSD. Other OS's such as 830 * Linux/FreeBSD/NetBSD have a flag with the same name 831 * but have differing functionality. OpenBSD will SEGV 832 * if it spots execution with a stack pointer pointing 833 * at memory that was not allocated with MAP_STACK. 834 */ 835 flags |= MAP_STACK; 836 #endif 837 838 ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE, flags, -1, 0); 839 if (ptr == MAP_FAILED) { 840 perror("failed to allocate memory for stack"); 841 abort(); 842 } 843 844 #if defined(HOST_IA64) 845 /* separate register stack */ 846 guardpage = ptr + (((*sz - pagesz) / 2) & ~pagesz); 847 #elif defined(HOST_HPPA) 848 /* stack grows up */ 849 guardpage = ptr + *sz - pagesz; 850 #else 851 /* stack grows down */ 852 guardpage = ptr; 853 #endif 854 if (mprotect(guardpage, pagesz, PROT_NONE) != 0) { 855 perror("failed to set up stack guard page"); 856 abort(); 857 } 858 859 #ifdef CONFIG_DEBUG_STACK_USAGE 860 for (ptr2 = ptr + pagesz; ptr2 < ptr + *sz; ptr2 += sizeof(uint32_t)) { 861 *(uint32_t *)ptr2 = 0xdeadbeaf; 862 } 863 #endif 864 865 return ptr; 866 } 867 868 #ifdef CONFIG_DEBUG_STACK_USAGE 869 static __thread unsigned int max_stack_usage; 870 #endif 871 872 void qemu_free_stack(void *stack, size_t sz) 873 { 874 #ifdef CONFIG_DEBUG_STACK_USAGE 875 unsigned int usage; 876 void *ptr; 877 878 for (ptr = stack + qemu_real_host_page_size; ptr < stack + sz; 879 ptr += sizeof(uint32_t)) { 880 if (*(uint32_t *)ptr != 0xdeadbeaf) { 881 break; 882 } 883 } 884 usage = sz - (uintptr_t) (ptr - stack); 885 if (usage > max_stack_usage) { 886 error_report("thread %d max stack usage increased from %u to %u", 887 qemu_get_thread_id(), max_stack_usage, usage); 888 max_stack_usage = usage; 889 } 890 #endif 891 892 munmap(stack, sz); 893 } 894 895 /* 896 * Disable CFI checks. 897 * We are going to call a signal hander directly. Such handler may or may not 898 * have been defined in our binary, so there's no guarantee that the pointer 899 * used to set the handler is a cfi-valid pointer. Since the handlers are 900 * stored in kernel memory, changing the handler to an attacker-defined 901 * function requires being able to call a sigaction() syscall, 902 * which is not as easy as overwriting a pointer in memory. 903 */ 904 QEMU_DISABLE_CFI 905 void sigaction_invoke(struct sigaction *action, 906 struct qemu_signalfd_siginfo *info) 907 { 908 siginfo_t si = {}; 909 si.si_signo = info->ssi_signo; 910 si.si_errno = info->ssi_errno; 911 si.si_code = info->ssi_code; 912 913 /* Convert the minimal set of fields defined by POSIX. 914 * Positive si_code values are reserved for kernel-generated 915 * signals, where the valid siginfo fields are determined by 916 * the signal number. But according to POSIX, it is unspecified 917 * whether SI_USER and SI_QUEUE have values less than or equal to 918 * zero. 919 */ 920 if (info->ssi_code == SI_USER || info->ssi_code == SI_QUEUE || 921 info->ssi_code <= 0) { 922 /* SIGTERM, etc. */ 923 si.si_pid = info->ssi_pid; 924 si.si_uid = info->ssi_uid; 925 } else if (info->ssi_signo == SIGILL || info->ssi_signo == SIGFPE || 926 info->ssi_signo == SIGSEGV || info->ssi_signo == SIGBUS) { 927 si.si_addr = (void *)(uintptr_t)info->ssi_addr; 928 } else if (info->ssi_signo == SIGCHLD) { 929 si.si_pid = info->ssi_pid; 930 si.si_status = info->ssi_status; 931 si.si_uid = info->ssi_uid; 932 } 933 action->sa_sigaction(info->ssi_signo, &si, NULL); 934 } 935 936 #ifndef HOST_NAME_MAX 937 # ifdef _POSIX_HOST_NAME_MAX 938 # define HOST_NAME_MAX _POSIX_HOST_NAME_MAX 939 # else 940 # define HOST_NAME_MAX 255 941 # endif 942 #endif 943 944 char *qemu_get_host_name(Error **errp) 945 { 946 long len = -1; 947 g_autofree char *hostname = NULL; 948 949 #ifdef _SC_HOST_NAME_MAX 950 len = sysconf(_SC_HOST_NAME_MAX); 951 #endif /* _SC_HOST_NAME_MAX */ 952 953 if (len < 0) { 954 len = HOST_NAME_MAX; 955 } 956 957 /* Unfortunately, gethostname() below does not guarantee a 958 * NULL terminated string. Therefore, allocate one byte more 959 * to be sure. */ 960 hostname = g_new0(char, len + 1); 961 962 if (gethostname(hostname, len) < 0) { 963 error_setg_errno(errp, errno, 964 "cannot get hostname"); 965 return NULL; 966 } 967 968 return g_steal_pointer(&hostname); 969 } 970 971 size_t qemu_get_host_physmem(void) 972 { 973 #ifdef _SC_PHYS_PAGES 974 long pages = sysconf(_SC_PHYS_PAGES); 975 if (pages > 0) { 976 if (pages > SIZE_MAX / qemu_real_host_page_size) { 977 return SIZE_MAX; 978 } else { 979 return pages * qemu_real_host_page_size; 980 } 981 } 982 #endif 983 return 0; 984 } 985