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