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