4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2010 Red Hat, Inc.
7 * QEMU library functions on POSIX which are shared between QEMU and
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:
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
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
29 #include "qemu/osdep.h"
32 #include <glib/gprintf.h>
34 #include "sysemu/sysemu.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"
42 #include "qemu/cutils.h"
43 #include "qemu/compiler.h"
44 #include "qemu/units.h"
47 #include <sys/syscall.h>
51 #include <sys/sysctl.h>
58 #include <sys/sysctl.h>
63 #include <mach-o/dyld.h>
67 #include <kernel/image.h>
70 #include "qemu/mmap-alloc.h"
72 #ifdef CONFIG_DEBUG_STACK_USAGE
73 #include "qemu/error-report.h"
76 #define MAX_MEM_PREALLOC_THREAD_COUNT 16
80 typedef struct MemsetContext
{
81 bool all_threads_created
;
82 bool any_thread_failed
;
83 struct MemsetThread
*threads
;
93 MemsetContext
*context
;
95 typedef struct MemsetThread MemsetThread
;
97 /* used by sigbus_handler() */
98 static MemsetContext
*sigbus_memset_context
;
99 struct sigaction sigbus_oldact
;
100 static QemuMutex sigbus_mutex
;
102 static QemuMutex page_mutex
;
103 static QemuCond page_cond
;
105 int qemu_get_thread_id(void)
107 #if defined(__linux__)
108 return syscall(SYS_gettid
);
109 #elif defined(__FreeBSD__)
110 /* thread id is up to INT_MAX */
114 #elif defined(__NetBSD__)
116 #elif defined(__OpenBSD__)
123 int qemu_daemon(int nochdir
, int noclose
)
125 return daemon(nochdir
, noclose
);
128 bool qemu_write_pidfile(const char *path
, Error
**errp
)
135 struct flock lock
= {
137 .l_whence
= SEEK_SET
,
141 fd
= qemu_create(path
, O_WRONLY
, S_IRUSR
| S_IWUSR
, errp
);
146 if (fstat(fd
, &b
) < 0) {
147 error_setg_errno(errp
, errno
, "Cannot stat file");
151 if (fcntl(fd
, F_SETLK
, &lock
)) {
152 error_setg_errno(errp
, errno
, "Cannot lock pid file");
157 * Now make sure the path we locked is the same one that now
158 * exists on the filesystem.
160 if (stat(path
, &a
) < 0) {
162 * PID file disappeared, someone else must be racing with
169 if (a
.st_ino
== b
.st_ino
) {
174 * PID file was recreated, someone else must be racing with
180 if (ftruncate(fd
, 0) < 0) {
181 error_setg_errno(errp
, errno
, "Failed to truncate pid file");
185 snprintf(pidstr
, sizeof(pidstr
), FMT_pid
"\n", getpid());
186 if (qemu_write_full(fd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
187 error_setg(errp
, "Failed to write pid file");
200 /* alloc shared memory pages */
201 void *qemu_anon_ram_alloc(size_t size
, uint64_t *alignment
, bool shared
,
204 const uint32_t qemu_map_flags
= (shared
? QEMU_MAP_SHARED
: 0) |
205 (noreserve
? QEMU_MAP_NORESERVE
: 0);
206 size_t align
= QEMU_VMALLOC_ALIGN
;
207 void *ptr
= qemu_ram_mmap(-1, size
, align
, qemu_map_flags
, 0);
209 if (ptr
== MAP_FAILED
) {
217 trace_qemu_anon_ram_alloc(size
, ptr
);
221 void qemu_anon_ram_free(void *ptr
, size_t size
)
223 trace_qemu_anon_ram_free(ptr
, size
);
224 qemu_ram_munmap(-1, ptr
, size
);
227 void qemu_socket_set_block(int fd
)
229 g_unix_set_fd_nonblocking(fd
, false, NULL
);
232 int qemu_socket_try_set_nonblock(int fd
)
234 return g_unix_set_fd_nonblocking(fd
, true, NULL
) ? 0 : -errno
;
237 void qemu_socket_set_nonblock(int fd
)
240 f
= qemu_socket_try_set_nonblock(fd
);
244 int socket_set_fast_reuse(int fd
)
248 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
249 (const char *)&val
, sizeof(val
));
256 void qemu_set_cloexec(int fd
)
259 f
= fcntl(fd
, F_GETFD
);
261 f
= fcntl(fd
, F_SETFD
, f
| FD_CLOEXEC
);
266 qemu_get_local_state_dir(void)
268 return get_relocated_path(CONFIG_QEMU_LOCALSTATEDIR
);
271 void qemu_set_tty_echo(int fd
, bool echo
)
278 tty
.c_lflag
|= ECHO
| ECHONL
| ICANON
| IEXTEN
;
280 tty
.c_lflag
&= ~(ECHO
| ECHONL
| ICANON
| IEXTEN
);
283 tcsetattr(fd
, TCSANOW
, &tty
);
286 static const char *exec_dir
;
288 void qemu_init_exec_dir(const char *argv0
)
297 #if defined(__linux__)
300 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
306 #elif defined(__FreeBSD__) \
307 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME))
309 #if defined(__FreeBSD__)
310 static int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1};
312 static int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, -1, KERN_PROC_PATHNAME
};
314 size_t len
= sizeof(buf
) - 1;
317 if (!sysctl(mib
, ARRAY_SIZE(mib
), buf
, &len
, NULL
, 0) &&
319 buf
[sizeof(buf
) - 1] = '\0';
323 #elif defined(__APPLE__)
325 char fpath
[PATH_MAX
];
326 uint32_t len
= sizeof(fpath
);
327 if (_NSGetExecutablePath(fpath
, &len
) == 0) {
328 p
= realpath(fpath
, buf
);
334 #elif defined(__HAIKU__)
340 while (get_next_image_info(0, &c
, &ii
) == B_OK
) {
341 if (ii
.type
== B_APP_IMAGE
) {
342 strncpy(buf
, ii
.name
, sizeof(buf
));
343 buf
[sizeof(buf
) - 1] = 0;
350 /* If we don't have any way of figuring out the actual executable
351 location then try argv[0]. */
353 p
= realpath(argv0
, buf
);
356 exec_dir
= g_path_get_dirname(p
);
358 exec_dir
= CONFIG_BINDIR
;
362 const char *qemu_get_exec_dir(void)
368 static void sigbus_handler(int signal
, siginfo_t
*siginfo
, void *ctx
)
369 #else /* CONFIG_LINUX */
370 static void sigbus_handler(int signal
)
371 #endif /* CONFIG_LINUX */
375 if (sigbus_memset_context
) {
376 for (i
= 0; i
< sigbus_memset_context
->num_threads
; i
++) {
377 MemsetThread
*thread
= &sigbus_memset_context
->threads
[i
];
379 if (qemu_thread_is_self(&thread
->pgthread
)) {
380 siglongjmp(thread
->env
, 1);
387 * We assume that the MCE SIGBUS handler could have been registered. We
388 * should never receive BUS_MCEERR_AO on any of our threads, but only on
389 * the main thread registered for PR_MCE_KILL_EARLY. Further, we should not
390 * receive BUS_MCEERR_AR triggered by action of other threads on one of
391 * our threads. So, no need to check for unrelated SIGBUS when seeing one
394 * We will forward to the MCE handler, which will either handle the SIGBUS
395 * or reinstall the default SIGBUS handler and reraise the SIGBUS. The
396 * default SIGBUS handler will crash the process, so we don't care.
398 if (sigbus_oldact
.sa_flags
& SA_SIGINFO
) {
399 sigbus_oldact
.sa_sigaction(signal
, siginfo
, ctx
);
402 #endif /* CONFIG_LINUX */
403 warn_report("os_mem_prealloc: unrelated SIGBUS detected and ignored");
406 static void *do_touch_pages(void *arg
)
408 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
409 sigset_t set
, oldset
;
413 * On Linux, the page faults from the loop below can cause mmap_sem
414 * contention with allocation of the thread stacks. Do not start
415 * clearing until all threads have been created.
417 qemu_mutex_lock(&page_mutex
);
418 while (!memset_args
->context
->all_threads_created
) {
419 qemu_cond_wait(&page_cond
, &page_mutex
);
421 qemu_mutex_unlock(&page_mutex
);
425 sigaddset(&set
, SIGBUS
);
426 pthread_sigmask(SIG_UNBLOCK
, &set
, &oldset
);
428 if (sigsetjmp(memset_args
->env
, 1)) {
431 char *addr
= memset_args
->addr
;
432 size_t numpages
= memset_args
->numpages
;
433 size_t hpagesize
= memset_args
->hpagesize
;
435 for (i
= 0; i
< numpages
; i
++) {
437 * Read & write back the same value, so we don't
438 * corrupt existing user/app data that might be
441 * 'volatile' to stop compiler optimizing this away
444 *(volatile char *)addr
= *addr
;
448 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
449 return (void *)(uintptr_t)ret
;
452 static void *do_madv_populate_write_pages(void *arg
)
454 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
455 const size_t size
= memset_args
->numpages
* memset_args
->hpagesize
;
456 char * const addr
= memset_args
->addr
;
459 /* See do_touch_pages(). */
460 qemu_mutex_lock(&page_mutex
);
461 while (!memset_args
->context
->all_threads_created
) {
462 qemu_cond_wait(&page_cond
, &page_mutex
);
464 qemu_mutex_unlock(&page_mutex
);
466 if (size
&& qemu_madvise(addr
, size
, QEMU_MADV_POPULATE_WRITE
)) {
469 return (void *)(uintptr_t)ret
;
472 static inline int get_memset_num_threads(size_t hpagesize
, size_t numpages
,
475 long host_procs
= sysconf(_SC_NPROCESSORS_ONLN
);
478 if (host_procs
> 0) {
479 ret
= MIN(MIN(host_procs
, MAX_MEM_PREALLOC_THREAD_COUNT
), smp_cpus
);
482 /* Especially with gigantic pages, don't create more threads than pages. */
483 ret
= MIN(ret
, numpages
);
484 /* Don't start threads to prealloc comparatively little memory. */
485 ret
= MIN(ret
, MAX(1, hpagesize
* numpages
/ (64 * MiB
)));
487 /* In case sysconf() fails, we fall back to single threaded */
491 static int touch_all_pages(char *area
, size_t hpagesize
, size_t numpages
,
492 int smp_cpus
, bool use_madv_populate_write
)
494 static gsize initialized
= 0;
495 MemsetContext context
= {
496 .num_threads
= get_memset_num_threads(hpagesize
, numpages
, smp_cpus
),
498 size_t numpages_per_thread
, leftover
;
499 void *(*touch_fn
)(void *);
503 if (g_once_init_enter(&initialized
)) {
504 qemu_mutex_init(&page_mutex
);
505 qemu_cond_init(&page_cond
);
506 g_once_init_leave(&initialized
, 1);
509 if (use_madv_populate_write
) {
510 /* Avoid creating a single thread for MADV_POPULATE_WRITE */
511 if (context
.num_threads
== 1) {
512 if (qemu_madvise(area
, hpagesize
* numpages
,
513 QEMU_MADV_POPULATE_WRITE
)) {
518 touch_fn
= do_madv_populate_write_pages
;
520 touch_fn
= do_touch_pages
;
523 context
.threads
= g_new0(MemsetThread
, context
.num_threads
);
524 numpages_per_thread
= numpages
/ context
.num_threads
;
525 leftover
= numpages
% context
.num_threads
;
526 for (i
= 0; i
< context
.num_threads
; i
++) {
527 context
.threads
[i
].addr
= addr
;
528 context
.threads
[i
].numpages
= numpages_per_thread
+ (i
< leftover
);
529 context
.threads
[i
].hpagesize
= hpagesize
;
530 context
.threads
[i
].context
= &context
;
531 qemu_thread_create(&context
.threads
[i
].pgthread
, "touch_pages",
532 touch_fn
, &context
.threads
[i
],
533 QEMU_THREAD_JOINABLE
);
534 addr
+= context
.threads
[i
].numpages
* hpagesize
;
537 if (!use_madv_populate_write
) {
538 sigbus_memset_context
= &context
;
541 qemu_mutex_lock(&page_mutex
);
542 context
.all_threads_created
= true;
543 qemu_cond_broadcast(&page_cond
);
544 qemu_mutex_unlock(&page_mutex
);
546 for (i
= 0; i
< context
.num_threads
; i
++) {
547 int tmp
= (uintptr_t)qemu_thread_join(&context
.threads
[i
].pgthread
);
554 if (!use_madv_populate_write
) {
555 sigbus_memset_context
= NULL
;
557 g_free(context
.threads
);
562 static bool madv_populate_write_possible(char *area
, size_t pagesize
)
564 return !qemu_madvise(area
, pagesize
, QEMU_MADV_POPULATE_WRITE
) ||
568 void os_mem_prealloc(int fd
, char *area
, size_t memory
, int smp_cpus
,
571 static gsize initialized
;
573 size_t hpagesize
= qemu_fd_getpagesize(fd
);
574 size_t numpages
= DIV_ROUND_UP(memory
, hpagesize
);
575 bool use_madv_populate_write
;
576 struct sigaction act
;
579 * Sense on every invocation, as MADV_POPULATE_WRITE cannot be used for
580 * some special mappings, such as mapping /dev/mem.
582 use_madv_populate_write
= madv_populate_write_possible(area
, hpagesize
);
584 if (!use_madv_populate_write
) {
585 if (g_once_init_enter(&initialized
)) {
586 qemu_mutex_init(&sigbus_mutex
);
587 g_once_init_leave(&initialized
, 1);
590 qemu_mutex_lock(&sigbus_mutex
);
591 memset(&act
, 0, sizeof(act
));
593 act
.sa_sigaction
= &sigbus_handler
;
594 act
.sa_flags
= SA_SIGINFO
;
595 #else /* CONFIG_LINUX */
596 act
.sa_handler
= &sigbus_handler
;
598 #endif /* CONFIG_LINUX */
600 ret
= sigaction(SIGBUS
, &act
, &sigbus_oldact
);
602 qemu_mutex_unlock(&sigbus_mutex
);
603 error_setg_errno(errp
, errno
,
604 "os_mem_prealloc: failed to install signal handler");
609 /* touch pages simultaneously */
610 ret
= touch_all_pages(area
, hpagesize
, numpages
, smp_cpus
,
611 use_madv_populate_write
);
613 error_setg_errno(errp
, -ret
,
614 "os_mem_prealloc: preallocating memory failed");
617 if (!use_madv_populate_write
) {
618 ret
= sigaction(SIGBUS
, &sigbus_oldact
, NULL
);
620 /* Terminate QEMU since it can't recover from error */
621 perror("os_mem_prealloc: failed to reinstall signal handler");
624 qemu_mutex_unlock(&sigbus_mutex
);
628 char *qemu_get_pid_name(pid_t pid
)
632 #if defined(__FreeBSD__)
633 /* BSDs don't have /proc, but they provide a nice substitute */
634 struct kinfo_proc
*proc
= kinfo_getproc(pid
);
637 name
= g_strdup(proc
->ki_comm
);
641 /* Assume a system with reasonable procfs */
645 pid_path
= g_strdup_printf("/proc/%d/cmdline", pid
);
646 g_file_get_contents(pid_path
, &name
, &len
, NULL
);
654 pid_t
qemu_fork(Error
**errp
)
656 sigset_t oldmask
, newmask
;
657 struct sigaction sig_action
;
662 * Need to block signals now, so that child process can safely
663 * kill off caller's signal handlers without a race.
665 sigfillset(&newmask
);
666 if (pthread_sigmask(SIG_SETMASK
, &newmask
, &oldmask
) != 0) {
667 error_setg_errno(errp
, errno
,
668 "cannot block signals");
676 /* attempt to restore signal mask, but ignore failure, to
677 * avoid obscuring the fork failure */
678 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
679 error_setg_errno(errp
, saved_errno
,
680 "cannot fork child process");
686 /* Restore our original signal mask now that the child is
687 * safely running. Only documented failures are EFAULT (not
688 * possible, since we are using just-grabbed mask) or EINVAL
689 * (not possible, since we are using correct arguments). */
690 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
695 /* Clear out all signal handlers from parent so nothing
696 * unexpected can happen in our child once we unblock
698 sig_action
.sa_handler
= SIG_DFL
;
699 sig_action
.sa_flags
= 0;
700 sigemptyset(&sig_action
.sa_mask
);
702 for (i
= 1; i
< NSIG
; i
++) {
703 /* Only possible errors are EFAULT or EINVAL The former
704 * won't happen, the latter we expect, so no need to check
706 (void)sigaction(i
, &sig_action
, NULL
);
709 /* Unmask all signals in child, since we've no idea what the
710 * caller's done with their signal mask and don't want to
711 * propagate that to children */
712 sigemptyset(&newmask
);
713 if (pthread_sigmask(SIG_SETMASK
, &newmask
, NULL
) != 0) {
714 Error
*local_err
= NULL
;
715 error_setg_errno(&local_err
, errno
,
716 "cannot unblock signals");
717 error_report_err(local_err
);
724 void *qemu_alloc_stack(size_t *sz
)
726 void *ptr
, *guardpage
;
728 #ifdef CONFIG_DEBUG_STACK_USAGE
731 size_t pagesz
= qemu_real_host_page_size();
732 #ifdef _SC_THREAD_STACK_MIN
733 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
734 long min_stack_sz
= sysconf(_SC_THREAD_STACK_MIN
);
735 *sz
= MAX(MAX(min_stack_sz
, 0), *sz
);
737 /* adjust stack size to a multiple of the page size */
738 *sz
= ROUND_UP(*sz
, pagesz
);
739 /* allocate one extra page for the guard page */
742 flags
= MAP_PRIVATE
| MAP_ANONYMOUS
;
743 #if defined(MAP_STACK) && defined(__OpenBSD__)
744 /* Only enable MAP_STACK on OpenBSD. Other OS's such as
745 * Linux/FreeBSD/NetBSD have a flag with the same name
746 * but have differing functionality. OpenBSD will SEGV
747 * if it spots execution with a stack pointer pointing
748 * at memory that was not allocated with MAP_STACK.
753 ptr
= mmap(NULL
, *sz
, PROT_READ
| PROT_WRITE
, flags
, -1, 0);
754 if (ptr
== MAP_FAILED
) {
755 perror("failed to allocate memory for stack");
759 #if defined(HOST_IA64)
760 /* separate register stack */
761 guardpage
= ptr
+ (((*sz
- pagesz
) / 2) & ~pagesz
);
762 #elif defined(HOST_HPPA)
764 guardpage
= ptr
+ *sz
- pagesz
;
766 /* stack grows down */
769 if (mprotect(guardpage
, pagesz
, PROT_NONE
) != 0) {
770 perror("failed to set up stack guard page");
774 #ifdef CONFIG_DEBUG_STACK_USAGE
775 for (ptr2
= ptr
+ pagesz
; ptr2
< ptr
+ *sz
; ptr2
+= sizeof(uint32_t)) {
776 *(uint32_t *)ptr2
= 0xdeadbeaf;
783 #ifdef CONFIG_DEBUG_STACK_USAGE
784 static __thread
unsigned int max_stack_usage
;
787 void qemu_free_stack(void *stack
, size_t sz
)
789 #ifdef CONFIG_DEBUG_STACK_USAGE
793 for (ptr
= stack
+ qemu_real_host_page_size(); ptr
< stack
+ sz
;
794 ptr
+= sizeof(uint32_t)) {
795 if (*(uint32_t *)ptr
!= 0xdeadbeaf) {
799 usage
= sz
- (uintptr_t) (ptr
- stack
);
800 if (usage
> max_stack_usage
) {
801 error_report("thread %d max stack usage increased from %u to %u",
802 qemu_get_thread_id(), max_stack_usage
, usage
);
803 max_stack_usage
= usage
;
811 * Disable CFI checks.
812 * We are going to call a signal hander directly. Such handler may or may not
813 * have been defined in our binary, so there's no guarantee that the pointer
814 * used to set the handler is a cfi-valid pointer. Since the handlers are
815 * stored in kernel memory, changing the handler to an attacker-defined
816 * function requires being able to call a sigaction() syscall,
817 * which is not as easy as overwriting a pointer in memory.
820 void sigaction_invoke(struct sigaction
*action
,
821 struct qemu_signalfd_siginfo
*info
)
824 si
.si_signo
= info
->ssi_signo
;
825 si
.si_errno
= info
->ssi_errno
;
826 si
.si_code
= info
->ssi_code
;
828 /* Convert the minimal set of fields defined by POSIX.
829 * Positive si_code values are reserved for kernel-generated
830 * signals, where the valid siginfo fields are determined by
831 * the signal number. But according to POSIX, it is unspecified
832 * whether SI_USER and SI_QUEUE have values less than or equal to
835 if (info
->ssi_code
== SI_USER
|| info
->ssi_code
== SI_QUEUE
||
836 info
->ssi_code
<= 0) {
838 si
.si_pid
= info
->ssi_pid
;
839 si
.si_uid
= info
->ssi_uid
;
840 } else if (info
->ssi_signo
== SIGILL
|| info
->ssi_signo
== SIGFPE
||
841 info
->ssi_signo
== SIGSEGV
|| info
->ssi_signo
== SIGBUS
) {
842 si
.si_addr
= (void *)(uintptr_t)info
->ssi_addr
;
843 } else if (info
->ssi_signo
== SIGCHLD
) {
844 si
.si_pid
= info
->ssi_pid
;
845 si
.si_status
= info
->ssi_status
;
846 si
.si_uid
= info
->ssi_uid
;
848 action
->sa_sigaction(info
->ssi_signo
, &si
, NULL
);
851 size_t qemu_get_host_physmem(void)
853 #ifdef _SC_PHYS_PAGES
854 long pages
= sysconf(_SC_PHYS_PAGES
);
856 if (pages
> SIZE_MAX
/ qemu_real_host_page_size()) {
859 return pages
* qemu_real_host_page_size();
866 int qemu_msync(void *addr
, size_t length
, int fd
)
868 size_t align_mask
= ~(qemu_real_host_page_size() - 1);
871 * There are no strict reqs as per the length of mapping
872 * to be synced. Still the length needs to follow the address
873 * alignment changes. Additionally - round the size to the multiple
876 length
+= ((uintptr_t)addr
& (qemu_real_host_page_size() - 1));
877 length
= (length
+ ~align_mask
) & align_mask
;
879 addr
= (void *)((uintptr_t)addr
& align_mask
);
881 return msync(addr
, length
, MS_SYNC
);