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