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>
52 #include <sys/types.h>
62 #include <mach-o/dyld.h>
66 #include <kernel/image.h>
69 #include "qemu/mmap-alloc.h"
71 #ifdef CONFIG_DEBUG_STACK_USAGE
72 #include "qemu/error-report.h"
75 #define MAX_MEM_PREALLOC_THREAD_COUNT 16
79 typedef struct MemsetContext
{
80 bool all_threads_created
;
81 bool any_thread_failed
;
82 struct MemsetThread
*threads
;
92 MemsetContext
*context
;
94 typedef struct MemsetThread MemsetThread
;
96 /* used by sigbus_handler() */
97 static MemsetContext
*sigbus_memset_context
;
98 struct sigaction sigbus_oldact
;
99 static QemuMutex sigbus_mutex
;
101 static QemuMutex page_mutex
;
102 static QemuCond page_cond
;
104 int qemu_get_thread_id(void)
106 #if defined(__linux__)
107 return syscall(SYS_gettid
);
108 #elif defined(__FreeBSD__)
109 /* thread id is up to INT_MAX */
113 #elif defined(__NetBSD__)
115 #elif defined(__OpenBSD__)
122 int qemu_daemon(int nochdir
, int noclose
)
124 return daemon(nochdir
, noclose
);
127 bool qemu_write_pidfile(const char *path
, Error
**errp
)
134 struct flock lock
= {
136 .l_whence
= SEEK_SET
,
140 fd
= qemu_create(path
, O_WRONLY
, S_IRUSR
| S_IWUSR
, errp
);
145 if (fstat(fd
, &b
) < 0) {
146 error_setg_errno(errp
, errno
, "Cannot stat file");
150 if (fcntl(fd
, F_SETLK
, &lock
)) {
151 error_setg_errno(errp
, errno
, "Cannot lock pid file");
156 * Now make sure the path we locked is the same one that now
157 * exists on the filesystem.
159 if (stat(path
, &a
) < 0) {
161 * PID file disappeared, someone else must be racing with
168 if (a
.st_ino
== b
.st_ino
) {
173 * PID file was recreated, someone else must be racing with
179 if (ftruncate(fd
, 0) < 0) {
180 error_setg_errno(errp
, errno
, "Failed to truncate pid file");
184 snprintf(pidstr
, sizeof(pidstr
), FMT_pid
"\n", getpid());
185 if (qemu_write_full(fd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
186 error_setg(errp
, "Failed to write pid file");
199 /* alloc shared memory pages */
200 void *qemu_anon_ram_alloc(size_t size
, uint64_t *alignment
, bool shared
,
203 const uint32_t qemu_map_flags
= (shared
? QEMU_MAP_SHARED
: 0) |
204 (noreserve
? QEMU_MAP_NORESERVE
: 0);
205 size_t align
= QEMU_VMALLOC_ALIGN
;
206 void *ptr
= qemu_ram_mmap(-1, size
, align
, qemu_map_flags
, 0);
208 if (ptr
== MAP_FAILED
) {
216 trace_qemu_anon_ram_alloc(size
, ptr
);
220 void qemu_anon_ram_free(void *ptr
, size_t size
)
222 trace_qemu_anon_ram_free(ptr
, size
);
223 qemu_ram_munmap(-1, ptr
, size
);
226 void qemu_socket_set_block(int fd
)
228 g_unix_set_fd_nonblocking(fd
, false, NULL
);
231 int qemu_socket_try_set_nonblock(int fd
)
233 return g_unix_set_fd_nonblocking(fd
, true, NULL
) ? 0 : -errno
;
236 void qemu_socket_set_nonblock(int fd
)
239 f
= qemu_socket_try_set_nonblock(fd
);
243 int socket_set_fast_reuse(int fd
)
247 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
248 (const char *)&val
, sizeof(val
));
255 void qemu_set_cloexec(int fd
)
258 f
= fcntl(fd
, F_GETFD
);
260 f
= fcntl(fd
, F_SETFD
, f
| FD_CLOEXEC
);
265 qemu_get_local_state_dir(void)
267 return get_relocated_path(CONFIG_QEMU_LOCALSTATEDIR
);
270 void qemu_set_tty_echo(int fd
, bool echo
)
277 tty
.c_lflag
|= ECHO
| ECHONL
| ICANON
| IEXTEN
;
279 tty
.c_lflag
&= ~(ECHO
| ECHONL
| ICANON
| IEXTEN
);
282 tcsetattr(fd
, TCSANOW
, &tty
);
286 static void sigbus_handler(int signal
, siginfo_t
*siginfo
, void *ctx
)
287 #else /* CONFIG_LINUX */
288 static void sigbus_handler(int signal
)
289 #endif /* CONFIG_LINUX */
293 if (sigbus_memset_context
) {
294 for (i
= 0; i
< sigbus_memset_context
->num_threads
; i
++) {
295 MemsetThread
*thread
= &sigbus_memset_context
->threads
[i
];
297 if (qemu_thread_is_self(&thread
->pgthread
)) {
298 siglongjmp(thread
->env
, 1);
305 * We assume that the MCE SIGBUS handler could have been registered. We
306 * should never receive BUS_MCEERR_AO on any of our threads, but only on
307 * the main thread registered for PR_MCE_KILL_EARLY. Further, we should not
308 * receive BUS_MCEERR_AR triggered by action of other threads on one of
309 * our threads. So, no need to check for unrelated SIGBUS when seeing one
312 * We will forward to the MCE handler, which will either handle the SIGBUS
313 * or reinstall the default SIGBUS handler and reraise the SIGBUS. The
314 * default SIGBUS handler will crash the process, so we don't care.
316 if (sigbus_oldact
.sa_flags
& SA_SIGINFO
) {
317 sigbus_oldact
.sa_sigaction(signal
, siginfo
, ctx
);
320 #endif /* CONFIG_LINUX */
321 warn_report("os_mem_prealloc: unrelated SIGBUS detected and ignored");
324 static void *do_touch_pages(void *arg
)
326 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
327 sigset_t set
, oldset
;
331 * On Linux, the page faults from the loop below can cause mmap_sem
332 * contention with allocation of the thread stacks. Do not start
333 * clearing until all threads have been created.
335 qemu_mutex_lock(&page_mutex
);
336 while (!memset_args
->context
->all_threads_created
) {
337 qemu_cond_wait(&page_cond
, &page_mutex
);
339 qemu_mutex_unlock(&page_mutex
);
343 sigaddset(&set
, SIGBUS
);
344 pthread_sigmask(SIG_UNBLOCK
, &set
, &oldset
);
346 if (sigsetjmp(memset_args
->env
, 1)) {
349 char *addr
= memset_args
->addr
;
350 size_t numpages
= memset_args
->numpages
;
351 size_t hpagesize
= memset_args
->hpagesize
;
353 for (i
= 0; i
< numpages
; i
++) {
355 * Read & write back the same value, so we don't
356 * corrupt existing user/app data that might be
359 * 'volatile' to stop compiler optimizing this away
362 *(volatile char *)addr
= *addr
;
366 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
367 return (void *)(uintptr_t)ret
;
370 static void *do_madv_populate_write_pages(void *arg
)
372 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
373 const size_t size
= memset_args
->numpages
* memset_args
->hpagesize
;
374 char * const addr
= memset_args
->addr
;
377 /* See do_touch_pages(). */
378 qemu_mutex_lock(&page_mutex
);
379 while (!memset_args
->context
->all_threads_created
) {
380 qemu_cond_wait(&page_cond
, &page_mutex
);
382 qemu_mutex_unlock(&page_mutex
);
384 if (size
&& qemu_madvise(addr
, size
, QEMU_MADV_POPULATE_WRITE
)) {
387 return (void *)(uintptr_t)ret
;
390 static inline int get_memset_num_threads(size_t hpagesize
, size_t numpages
,
393 long host_procs
= sysconf(_SC_NPROCESSORS_ONLN
);
396 if (host_procs
> 0) {
397 ret
= MIN(MIN(host_procs
, MAX_MEM_PREALLOC_THREAD_COUNT
), smp_cpus
);
400 /* Especially with gigantic pages, don't create more threads than pages. */
401 ret
= MIN(ret
, numpages
);
402 /* Don't start threads to prealloc comparatively little memory. */
403 ret
= MIN(ret
, MAX(1, hpagesize
* numpages
/ (64 * MiB
)));
405 /* In case sysconf() fails, we fall back to single threaded */
409 static int touch_all_pages(char *area
, size_t hpagesize
, size_t numpages
,
410 int smp_cpus
, bool use_madv_populate_write
)
412 static gsize initialized
= 0;
413 MemsetContext context
= {
414 .num_threads
= get_memset_num_threads(hpagesize
, numpages
, smp_cpus
),
416 size_t numpages_per_thread
, leftover
;
417 void *(*touch_fn
)(void *);
421 if (g_once_init_enter(&initialized
)) {
422 qemu_mutex_init(&page_mutex
);
423 qemu_cond_init(&page_cond
);
424 g_once_init_leave(&initialized
, 1);
427 if (use_madv_populate_write
) {
428 /* Avoid creating a single thread for MADV_POPULATE_WRITE */
429 if (context
.num_threads
== 1) {
430 if (qemu_madvise(area
, hpagesize
* numpages
,
431 QEMU_MADV_POPULATE_WRITE
)) {
436 touch_fn
= do_madv_populate_write_pages
;
438 touch_fn
= do_touch_pages
;
441 context
.threads
= g_new0(MemsetThread
, context
.num_threads
);
442 numpages_per_thread
= numpages
/ context
.num_threads
;
443 leftover
= numpages
% context
.num_threads
;
444 for (i
= 0; i
< context
.num_threads
; i
++) {
445 context
.threads
[i
].addr
= addr
;
446 context
.threads
[i
].numpages
= numpages_per_thread
+ (i
< leftover
);
447 context
.threads
[i
].hpagesize
= hpagesize
;
448 context
.threads
[i
].context
= &context
;
449 qemu_thread_create(&context
.threads
[i
].pgthread
, "touch_pages",
450 touch_fn
, &context
.threads
[i
],
451 QEMU_THREAD_JOINABLE
);
452 addr
+= context
.threads
[i
].numpages
* hpagesize
;
455 if (!use_madv_populate_write
) {
456 sigbus_memset_context
= &context
;
459 qemu_mutex_lock(&page_mutex
);
460 context
.all_threads_created
= true;
461 qemu_cond_broadcast(&page_cond
);
462 qemu_mutex_unlock(&page_mutex
);
464 for (i
= 0; i
< context
.num_threads
; i
++) {
465 int tmp
= (uintptr_t)qemu_thread_join(&context
.threads
[i
].pgthread
);
472 if (!use_madv_populate_write
) {
473 sigbus_memset_context
= NULL
;
475 g_free(context
.threads
);
480 static bool madv_populate_write_possible(char *area
, size_t pagesize
)
482 return !qemu_madvise(area
, pagesize
, QEMU_MADV_POPULATE_WRITE
) ||
486 void os_mem_prealloc(int fd
, char *area
, size_t memory
, int smp_cpus
,
489 static gsize initialized
;
491 size_t hpagesize
= qemu_fd_getpagesize(fd
);
492 size_t numpages
= DIV_ROUND_UP(memory
, hpagesize
);
493 bool use_madv_populate_write
;
494 struct sigaction act
;
497 * Sense on every invocation, as MADV_POPULATE_WRITE cannot be used for
498 * some special mappings, such as mapping /dev/mem.
500 use_madv_populate_write
= madv_populate_write_possible(area
, hpagesize
);
502 if (!use_madv_populate_write
) {
503 if (g_once_init_enter(&initialized
)) {
504 qemu_mutex_init(&sigbus_mutex
);
505 g_once_init_leave(&initialized
, 1);
508 qemu_mutex_lock(&sigbus_mutex
);
509 memset(&act
, 0, sizeof(act
));
511 act
.sa_sigaction
= &sigbus_handler
;
512 act
.sa_flags
= SA_SIGINFO
;
513 #else /* CONFIG_LINUX */
514 act
.sa_handler
= &sigbus_handler
;
516 #endif /* CONFIG_LINUX */
518 ret
= sigaction(SIGBUS
, &act
, &sigbus_oldact
);
520 qemu_mutex_unlock(&sigbus_mutex
);
521 error_setg_errno(errp
, errno
,
522 "os_mem_prealloc: failed to install signal handler");
527 /* touch pages simultaneously */
528 ret
= touch_all_pages(area
, hpagesize
, numpages
, smp_cpus
,
529 use_madv_populate_write
);
531 error_setg_errno(errp
, -ret
,
532 "os_mem_prealloc: preallocating memory failed");
535 if (!use_madv_populate_write
) {
536 ret
= sigaction(SIGBUS
, &sigbus_oldact
, NULL
);
538 /* Terminate QEMU since it can't recover from error */
539 perror("os_mem_prealloc: failed to reinstall signal handler");
542 qemu_mutex_unlock(&sigbus_mutex
);
546 char *qemu_get_pid_name(pid_t pid
)
550 #if defined(__FreeBSD__)
551 /* BSDs don't have /proc, but they provide a nice substitute */
552 struct kinfo_proc
*proc
= kinfo_getproc(pid
);
555 name
= g_strdup(proc
->ki_comm
);
559 /* Assume a system with reasonable procfs */
563 pid_path
= g_strdup_printf("/proc/%d/cmdline", pid
);
564 g_file_get_contents(pid_path
, &name
, &len
, NULL
);
572 pid_t
qemu_fork(Error
**errp
)
574 sigset_t oldmask
, newmask
;
575 struct sigaction sig_action
;
580 * Need to block signals now, so that child process can safely
581 * kill off caller's signal handlers without a race.
583 sigfillset(&newmask
);
584 if (pthread_sigmask(SIG_SETMASK
, &newmask
, &oldmask
) != 0) {
585 error_setg_errno(errp
, errno
,
586 "cannot block signals");
594 /* attempt to restore signal mask, but ignore failure, to
595 * avoid obscuring the fork failure */
596 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
597 error_setg_errno(errp
, saved_errno
,
598 "cannot fork child process");
604 /* Restore our original signal mask now that the child is
605 * safely running. Only documented failures are EFAULT (not
606 * possible, since we are using just-grabbed mask) or EINVAL
607 * (not possible, since we are using correct arguments). */
608 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
613 /* Clear out all signal handlers from parent so nothing
614 * unexpected can happen in our child once we unblock
616 sig_action
.sa_handler
= SIG_DFL
;
617 sig_action
.sa_flags
= 0;
618 sigemptyset(&sig_action
.sa_mask
);
620 for (i
= 1; i
< NSIG
; i
++) {
621 /* Only possible errors are EFAULT or EINVAL The former
622 * won't happen, the latter we expect, so no need to check
624 (void)sigaction(i
, &sig_action
, NULL
);
627 /* Unmask all signals in child, since we've no idea what the
628 * caller's done with their signal mask and don't want to
629 * propagate that to children */
630 sigemptyset(&newmask
);
631 if (pthread_sigmask(SIG_SETMASK
, &newmask
, NULL
) != 0) {
632 Error
*local_err
= NULL
;
633 error_setg_errno(&local_err
, errno
,
634 "cannot unblock signals");
635 error_report_err(local_err
);
642 void *qemu_alloc_stack(size_t *sz
)
644 void *ptr
, *guardpage
;
646 #ifdef CONFIG_DEBUG_STACK_USAGE
649 size_t pagesz
= qemu_real_host_page_size();
650 #ifdef _SC_THREAD_STACK_MIN
651 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
652 long min_stack_sz
= sysconf(_SC_THREAD_STACK_MIN
);
653 *sz
= MAX(MAX(min_stack_sz
, 0), *sz
);
655 /* adjust stack size to a multiple of the page size */
656 *sz
= ROUND_UP(*sz
, pagesz
);
657 /* allocate one extra page for the guard page */
660 flags
= MAP_PRIVATE
| MAP_ANONYMOUS
;
661 #if defined(MAP_STACK) && defined(__OpenBSD__)
662 /* Only enable MAP_STACK on OpenBSD. Other OS's such as
663 * Linux/FreeBSD/NetBSD have a flag with the same name
664 * but have differing functionality. OpenBSD will SEGV
665 * if it spots execution with a stack pointer pointing
666 * at memory that was not allocated with MAP_STACK.
671 ptr
= mmap(NULL
, *sz
, PROT_READ
| PROT_WRITE
, flags
, -1, 0);
672 if (ptr
== MAP_FAILED
) {
673 perror("failed to allocate memory for stack");
677 #if defined(HOST_IA64)
678 /* separate register stack */
679 guardpage
= ptr
+ (((*sz
- pagesz
) / 2) & ~pagesz
);
680 #elif defined(HOST_HPPA)
682 guardpage
= ptr
+ *sz
- pagesz
;
684 /* stack grows down */
687 if (mprotect(guardpage
, pagesz
, PROT_NONE
) != 0) {
688 perror("failed to set up stack guard page");
692 #ifdef CONFIG_DEBUG_STACK_USAGE
693 for (ptr2
= ptr
+ pagesz
; ptr2
< ptr
+ *sz
; ptr2
+= sizeof(uint32_t)) {
694 *(uint32_t *)ptr2
= 0xdeadbeaf;
701 #ifdef CONFIG_DEBUG_STACK_USAGE
702 static __thread
unsigned int max_stack_usage
;
705 void qemu_free_stack(void *stack
, size_t sz
)
707 #ifdef CONFIG_DEBUG_STACK_USAGE
711 for (ptr
= stack
+ qemu_real_host_page_size(); ptr
< stack
+ sz
;
712 ptr
+= sizeof(uint32_t)) {
713 if (*(uint32_t *)ptr
!= 0xdeadbeaf) {
717 usage
= sz
- (uintptr_t) (ptr
- stack
);
718 if (usage
> max_stack_usage
) {
719 error_report("thread %d max stack usage increased from %u to %u",
720 qemu_get_thread_id(), max_stack_usage
, usage
);
721 max_stack_usage
= usage
;
729 * Disable CFI checks.
730 * We are going to call a signal hander directly. Such handler may or may not
731 * have been defined in our binary, so there's no guarantee that the pointer
732 * used to set the handler is a cfi-valid pointer. Since the handlers are
733 * stored in kernel memory, changing the handler to an attacker-defined
734 * function requires being able to call a sigaction() syscall,
735 * which is not as easy as overwriting a pointer in memory.
738 void sigaction_invoke(struct sigaction
*action
,
739 struct qemu_signalfd_siginfo
*info
)
742 si
.si_signo
= info
->ssi_signo
;
743 si
.si_errno
= info
->ssi_errno
;
744 si
.si_code
= info
->ssi_code
;
746 /* Convert the minimal set of fields defined by POSIX.
747 * Positive si_code values are reserved for kernel-generated
748 * signals, where the valid siginfo fields are determined by
749 * the signal number. But according to POSIX, it is unspecified
750 * whether SI_USER and SI_QUEUE have values less than or equal to
753 if (info
->ssi_code
== SI_USER
|| info
->ssi_code
== SI_QUEUE
||
754 info
->ssi_code
<= 0) {
756 si
.si_pid
= info
->ssi_pid
;
757 si
.si_uid
= info
->ssi_uid
;
758 } else if (info
->ssi_signo
== SIGILL
|| info
->ssi_signo
== SIGFPE
||
759 info
->ssi_signo
== SIGSEGV
|| info
->ssi_signo
== SIGBUS
) {
760 si
.si_addr
= (void *)(uintptr_t)info
->ssi_addr
;
761 } else if (info
->ssi_signo
== SIGCHLD
) {
762 si
.si_pid
= info
->ssi_pid
;
763 si
.si_status
= info
->ssi_status
;
764 si
.si_uid
= info
->ssi_uid
;
766 action
->sa_sigaction(info
->ssi_signo
, &si
, NULL
);
769 size_t qemu_get_host_physmem(void)
771 #ifdef _SC_PHYS_PAGES
772 long pages
= sysconf(_SC_PHYS_PAGES
);
774 if (pages
> SIZE_MAX
/ qemu_real_host_page_size()) {
777 return pages
* qemu_real_host_page_size();
784 int qemu_msync(void *addr
, size_t length
, int fd
)
786 size_t align_mask
= ~(qemu_real_host_page_size() - 1);
789 * There are no strict reqs as per the length of mapping
790 * to be synced. Still the length needs to follow the address
791 * alignment changes. Additionally - round the size to the multiple
794 length
+= ((uintptr_t)addr
& (qemu_real_host_page_size() - 1));
795 length
= (length
+ ~align_mask
) & align_mask
;
797 addr
= (void *)((uintptr_t)addr
& align_mask
);
799 return msync(addr
, length
, MS_SYNC
);