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 "qemu-common.h"
35 #include "sysemu/sysemu.h"
37 #include "qapi/error.h"
38 #include "qemu/sockets.h"
39 #include "qemu/thread.h"
41 #include "qemu/cutils.h"
42 #include "qemu/compiler.h"
45 #include <sys/syscall.h>
49 #include <sys/sysctl.h>
56 #include <sys/sysctl.h>
61 #include <mach-o/dyld.h>
65 #include <kernel/image.h>
68 #include "qemu/mmap-alloc.h"
70 #ifdef CONFIG_DEBUG_STACK_USAGE
71 #include "qemu/error-report.h"
74 #define MAX_MEM_PREALLOC_THREAD_COUNT 16
83 typedef struct MemsetThread MemsetThread
;
85 static MemsetThread
*memset_thread
;
86 static int memset_num_threads
;
88 static QemuMutex page_mutex
;
89 static QemuCond page_cond
;
90 static bool threads_created_flag
;
92 int qemu_get_thread_id(void)
94 #if defined(__linux__)
95 return syscall(SYS_gettid
);
96 #elif defined(__FreeBSD__)
97 /* thread id is up to INT_MAX */
101 #elif defined(__NetBSD__)
103 #elif defined(__OpenBSD__)
110 int qemu_daemon(int nochdir
, int noclose
)
112 return daemon(nochdir
, noclose
);
115 bool qemu_write_pidfile(const char *path
, Error
**errp
)
122 struct flock lock
= {
124 .l_whence
= SEEK_SET
,
128 fd
= qemu_open_old(path
, O_CREAT
| O_WRONLY
, S_IRUSR
| S_IWUSR
);
130 error_setg_errno(errp
, errno
, "Cannot open pid file");
134 if (fstat(fd
, &b
) < 0) {
135 error_setg_errno(errp
, errno
, "Cannot stat file");
139 if (fcntl(fd
, F_SETLK
, &lock
)) {
140 error_setg_errno(errp
, errno
, "Cannot lock pid file");
145 * Now make sure the path we locked is the same one that now
146 * exists on the filesystem.
148 if (stat(path
, &a
) < 0) {
150 * PID file disappeared, someone else must be racing with
157 if (a
.st_ino
== b
.st_ino
) {
162 * PID file was recreated, someone else must be racing with
168 if (ftruncate(fd
, 0) < 0) {
169 error_setg_errno(errp
, errno
, "Failed to truncate pid file");
173 snprintf(pidstr
, sizeof(pidstr
), FMT_pid
"\n", getpid());
174 if (write(fd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
175 error_setg(errp
, "Failed to write pid file");
188 void *qemu_oom_check(void *ptr
)
191 fprintf(stderr
, "Failed to allocate memory: %s\n", strerror(errno
));
197 void *qemu_try_memalign(size_t alignment
, size_t size
)
201 if (alignment
< sizeof(void*)) {
202 alignment
= sizeof(void*);
204 g_assert(is_power_of_2(alignment
));
207 #if defined(CONFIG_POSIX_MEMALIGN)
209 ret
= posix_memalign(&ptr
, alignment
, size
);
214 #elif defined(CONFIG_BSD)
217 ptr
= memalign(alignment
, size
);
219 trace_qemu_memalign(alignment
, size
, ptr
);
223 void *qemu_memalign(size_t alignment
, size_t size
)
225 return qemu_oom_check(qemu_try_memalign(alignment
, size
));
228 /* alloc shared memory pages */
229 void *qemu_anon_ram_alloc(size_t size
, uint64_t *alignment
, bool shared
,
232 const uint32_t qemu_map_flags
= (shared
? QEMU_MAP_SHARED
: 0) |
233 (noreserve
? QEMU_MAP_NORESERVE
: 0);
234 size_t align
= QEMU_VMALLOC_ALIGN
;
235 void *ptr
= qemu_ram_mmap(-1, size
, align
, qemu_map_flags
, 0);
237 if (ptr
== MAP_FAILED
) {
245 trace_qemu_anon_ram_alloc(size
, ptr
);
249 void qemu_vfree(void *ptr
)
251 trace_qemu_vfree(ptr
);
255 void qemu_anon_ram_free(void *ptr
, size_t size
)
257 trace_qemu_anon_ram_free(ptr
, size
);
258 qemu_ram_munmap(-1, ptr
, size
);
261 void qemu_set_block(int fd
)
264 f
= fcntl(fd
, F_GETFL
);
266 f
= fcntl(fd
, F_SETFL
, f
& ~O_NONBLOCK
);
270 int qemu_try_set_nonblock(int fd
)
273 f
= fcntl(fd
, F_GETFL
);
277 if (fcntl(fd
, F_SETFL
, f
| O_NONBLOCK
) == -1) {
283 void qemu_set_nonblock(int fd
)
286 f
= qemu_try_set_nonblock(fd
);
290 int socket_set_fast_reuse(int fd
)
294 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
295 (const char *)&val
, sizeof(val
));
302 void qemu_set_cloexec(int fd
)
305 f
= fcntl(fd
, F_GETFD
);
307 f
= fcntl(fd
, F_SETFD
, f
| FD_CLOEXEC
);
312 * Creates a pipe with FD_CLOEXEC set on both file descriptors
314 int qemu_pipe(int pipefd
[2])
319 ret
= pipe2(pipefd
, O_CLOEXEC
);
320 if (ret
!= -1 || errno
!= ENOSYS
) {
326 qemu_set_cloexec(pipefd
[0]);
327 qemu_set_cloexec(pipefd
[1]);
334 qemu_get_local_state_pathname(const char *relative_pathname
)
336 g_autofree
char *dir
= g_strdup_printf("%s/%s",
337 CONFIG_QEMU_LOCALSTATEDIR
,
339 return get_relocated_path(dir
);
342 void qemu_set_tty_echo(int fd
, bool echo
)
349 tty
.c_lflag
|= ECHO
| ECHONL
| ICANON
| IEXTEN
;
351 tty
.c_lflag
&= ~(ECHO
| ECHONL
| ICANON
| IEXTEN
);
354 tcsetattr(fd
, TCSANOW
, &tty
);
357 static const char *exec_dir
;
359 void qemu_init_exec_dir(const char *argv0
)
368 #if defined(__linux__)
371 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
377 #elif defined(__FreeBSD__) \
378 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME))
380 #if defined(__FreeBSD__)
381 static int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1};
383 static int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, -1, KERN_PROC_PATHNAME
};
385 size_t len
= sizeof(buf
) - 1;
388 if (!sysctl(mib
, ARRAY_SIZE(mib
), buf
, &len
, NULL
, 0) &&
390 buf
[sizeof(buf
) - 1] = '\0';
394 #elif defined(__APPLE__)
396 char fpath
[PATH_MAX
];
397 uint32_t len
= sizeof(fpath
);
398 if (_NSGetExecutablePath(fpath
, &len
) == 0) {
399 p
= realpath(fpath
, buf
);
405 #elif defined(__HAIKU__)
411 while (get_next_image_info(0, &c
, &ii
) == B_OK
) {
412 if (ii
.type
== B_APP_IMAGE
) {
413 strncpy(buf
, ii
.name
, sizeof(buf
));
414 buf
[sizeof(buf
) - 1] = 0;
421 /* If we don't have any way of figuring out the actual executable
422 location then try argv[0]. */
424 p
= realpath(argv0
, buf
);
427 exec_dir
= g_path_get_dirname(p
);
429 exec_dir
= CONFIG_BINDIR
;
433 const char *qemu_get_exec_dir(void)
438 static void sigbus_handler(int signal
)
442 for (i
= 0; i
< memset_num_threads
; i
++) {
443 if (qemu_thread_is_self(&memset_thread
[i
].pgthread
)) {
444 siglongjmp(memset_thread
[i
].env
, 1);
450 static void *do_touch_pages(void *arg
)
452 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
453 sigset_t set
, oldset
;
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.
461 qemu_mutex_lock(&page_mutex
);
462 while(!threads_created_flag
){
463 qemu_cond_wait(&page_cond
, &page_mutex
);
465 qemu_mutex_unlock(&page_mutex
);
469 sigaddset(&set
, SIGBUS
);
470 pthread_sigmask(SIG_UNBLOCK
, &set
, &oldset
);
472 if (sigsetjmp(memset_args
->env
, 1)) {
475 char *addr
= memset_args
->addr
;
476 size_t numpages
= memset_args
->numpages
;
477 size_t hpagesize
= memset_args
->hpagesize
;
479 for (i
= 0; i
< numpages
; i
++) {
481 * Read & write back the same value, so we don't
482 * corrupt existing user/app data that might be
485 * 'volatile' to stop compiler optimizing this away
488 *(volatile char *)addr
= *addr
;
492 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
493 return (void *)(uintptr_t)ret
;
496 static void *do_madv_populate_write_pages(void *arg
)
498 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
499 const size_t size
= memset_args
->numpages
* memset_args
->hpagesize
;
500 char * const addr
= memset_args
->addr
;
503 /* See do_touch_pages(). */
504 qemu_mutex_lock(&page_mutex
);
505 while (!threads_created_flag
) {
506 qemu_cond_wait(&page_cond
, &page_mutex
);
508 qemu_mutex_unlock(&page_mutex
);
510 if (size
&& qemu_madvise(addr
, size
, QEMU_MADV_POPULATE_WRITE
)) {
513 return (void *)(uintptr_t)ret
;
516 static inline int get_memset_num_threads(int smp_cpus
)
518 long host_procs
= sysconf(_SC_NPROCESSORS_ONLN
);
521 if (host_procs
> 0) {
522 ret
= MIN(MIN(host_procs
, MAX_MEM_PREALLOC_THREAD_COUNT
), smp_cpus
);
524 /* In case sysconf() fails, we fall back to single threaded */
528 static int touch_all_pages(char *area
, size_t hpagesize
, size_t numpages
,
529 int smp_cpus
, bool use_madv_populate_write
)
531 static gsize initialized
= 0;
532 size_t numpages_per_thread
, leftover
;
533 void *(*touch_fn
)(void *);
537 if (g_once_init_enter(&initialized
)) {
538 qemu_mutex_init(&page_mutex
);
539 qemu_cond_init(&page_cond
);
540 g_once_init_leave(&initialized
, 1);
543 if (use_madv_populate_write
) {
544 touch_fn
= do_madv_populate_write_pages
;
546 touch_fn
= do_touch_pages
;
549 threads_created_flag
= false;
550 memset_num_threads
= get_memset_num_threads(smp_cpus
);
551 memset_thread
= g_new0(MemsetThread
, memset_num_threads
);
552 numpages_per_thread
= numpages
/ memset_num_threads
;
553 leftover
= numpages
% memset_num_threads
;
554 for (i
= 0; i
< memset_num_threads
; i
++) {
555 memset_thread
[i
].addr
= addr
;
556 memset_thread
[i
].numpages
= numpages_per_thread
+ (i
< leftover
);
557 memset_thread
[i
].hpagesize
= hpagesize
;
558 qemu_thread_create(&memset_thread
[i
].pgthread
, "touch_pages",
559 touch_fn
, &memset_thread
[i
],
560 QEMU_THREAD_JOINABLE
);
561 addr
+= memset_thread
[i
].numpages
* hpagesize
;
564 qemu_mutex_lock(&page_mutex
);
565 threads_created_flag
= true;
566 qemu_cond_broadcast(&page_cond
);
567 qemu_mutex_unlock(&page_mutex
);
569 for (i
= 0; i
< memset_num_threads
; i
++) {
570 int tmp
= (uintptr_t)qemu_thread_join(&memset_thread
[i
].pgthread
);
576 g_free(memset_thread
);
577 memset_thread
= NULL
;
582 static bool madv_populate_write_possible(char *area
, size_t pagesize
)
584 return !qemu_madvise(area
, pagesize
, QEMU_MADV_POPULATE_WRITE
) ||
588 void os_mem_prealloc(int fd
, char *area
, size_t memory
, int smp_cpus
,
592 struct sigaction act
, oldact
;
593 size_t hpagesize
= qemu_fd_getpagesize(fd
);
594 size_t numpages
= DIV_ROUND_UP(memory
, hpagesize
);
595 bool use_madv_populate_write
;
598 * Sense on every invocation, as MADV_POPULATE_WRITE cannot be used for
599 * some special mappings, such as mapping /dev/mem.
601 use_madv_populate_write
= madv_populate_write_possible(area
, hpagesize
);
603 if (!use_madv_populate_write
) {
604 memset(&act
, 0, sizeof(act
));
605 act
.sa_handler
= &sigbus_handler
;
608 ret
= sigaction(SIGBUS
, &act
, &oldact
);
610 error_setg_errno(errp
, errno
,
611 "os_mem_prealloc: failed to install signal handler");
616 /* touch pages simultaneously */
617 ret
= touch_all_pages(area
, hpagesize
, numpages
, smp_cpus
,
618 use_madv_populate_write
);
620 error_setg_errno(errp
, -ret
,
621 "os_mem_prealloc: preallocating memory failed");
624 if (!use_madv_populate_write
) {
625 ret
= sigaction(SIGBUS
, &oldact
, NULL
);
627 /* Terminate QEMU since it can't recover from error */
628 perror("os_mem_prealloc: failed to reinstall signal handler");
634 char *qemu_get_pid_name(pid_t pid
)
638 #if defined(__FreeBSD__)
639 /* BSDs don't have /proc, but they provide a nice substitute */
640 struct kinfo_proc
*proc
= kinfo_getproc(pid
);
643 name
= g_strdup(proc
->ki_comm
);
647 /* Assume a system with reasonable procfs */
651 pid_path
= g_strdup_printf("/proc/%d/cmdline", pid
);
652 g_file_get_contents(pid_path
, &name
, &len
, NULL
);
660 pid_t
qemu_fork(Error
**errp
)
662 sigset_t oldmask
, newmask
;
663 struct sigaction sig_action
;
668 * Need to block signals now, so that child process can safely
669 * kill off caller's signal handlers without a race.
671 sigfillset(&newmask
);
672 if (pthread_sigmask(SIG_SETMASK
, &newmask
, &oldmask
) != 0) {
673 error_setg_errno(errp
, errno
,
674 "cannot block signals");
682 /* attempt to restore signal mask, but ignore failure, to
683 * avoid obscuring the fork failure */
684 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
685 error_setg_errno(errp
, saved_errno
,
686 "cannot fork child process");
692 /* Restore our original signal mask now that the child is
693 * safely running. Only documented failures are EFAULT (not
694 * possible, since we are using just-grabbed mask) or EINVAL
695 * (not possible, since we are using correct arguments). */
696 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
701 /* Clear out all signal handlers from parent so nothing
702 * unexpected can happen in our child once we unblock
704 sig_action
.sa_handler
= SIG_DFL
;
705 sig_action
.sa_flags
= 0;
706 sigemptyset(&sig_action
.sa_mask
);
708 for (i
= 1; i
< NSIG
; i
++) {
709 /* Only possible errors are EFAULT or EINVAL The former
710 * won't happen, the latter we expect, so no need to check
712 (void)sigaction(i
, &sig_action
, NULL
);
715 /* Unmask all signals in child, since we've no idea what the
716 * caller's done with their signal mask and don't want to
717 * propagate that to children */
718 sigemptyset(&newmask
);
719 if (pthread_sigmask(SIG_SETMASK
, &newmask
, NULL
) != 0) {
720 Error
*local_err
= NULL
;
721 error_setg_errno(&local_err
, errno
,
722 "cannot unblock signals");
723 error_report_err(local_err
);
730 void *qemu_alloc_stack(size_t *sz
)
732 void *ptr
, *guardpage
;
734 #ifdef CONFIG_DEBUG_STACK_USAGE
737 size_t pagesz
= qemu_real_host_page_size
;
738 #ifdef _SC_THREAD_STACK_MIN
739 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
740 long min_stack_sz
= sysconf(_SC_THREAD_STACK_MIN
);
741 *sz
= MAX(MAX(min_stack_sz
, 0), *sz
);
743 /* adjust stack size to a multiple of the page size */
744 *sz
= ROUND_UP(*sz
, pagesz
);
745 /* allocate one extra page for the guard page */
748 flags
= MAP_PRIVATE
| MAP_ANONYMOUS
;
749 #if defined(MAP_STACK) && defined(__OpenBSD__)
750 /* Only enable MAP_STACK on OpenBSD. Other OS's such as
751 * Linux/FreeBSD/NetBSD have a flag with the same name
752 * but have differing functionality. OpenBSD will SEGV
753 * if it spots execution with a stack pointer pointing
754 * at memory that was not allocated with MAP_STACK.
759 ptr
= mmap(NULL
, *sz
, PROT_READ
| PROT_WRITE
, flags
, -1, 0);
760 if (ptr
== MAP_FAILED
) {
761 perror("failed to allocate memory for stack");
765 #if defined(HOST_IA64)
766 /* separate register stack */
767 guardpage
= ptr
+ (((*sz
- pagesz
) / 2) & ~pagesz
);
768 #elif defined(HOST_HPPA)
770 guardpage
= ptr
+ *sz
- pagesz
;
772 /* stack grows down */
775 if (mprotect(guardpage
, pagesz
, PROT_NONE
) != 0) {
776 perror("failed to set up stack guard page");
780 #ifdef CONFIG_DEBUG_STACK_USAGE
781 for (ptr2
= ptr
+ pagesz
; ptr2
< ptr
+ *sz
; ptr2
+= sizeof(uint32_t)) {
782 *(uint32_t *)ptr2
= 0xdeadbeaf;
789 #ifdef CONFIG_DEBUG_STACK_USAGE
790 static __thread
unsigned int max_stack_usage
;
793 void qemu_free_stack(void *stack
, size_t sz
)
795 #ifdef CONFIG_DEBUG_STACK_USAGE
799 for (ptr
= stack
+ qemu_real_host_page_size
; ptr
< stack
+ sz
;
800 ptr
+= sizeof(uint32_t)) {
801 if (*(uint32_t *)ptr
!= 0xdeadbeaf) {
805 usage
= sz
- (uintptr_t) (ptr
- stack
);
806 if (usage
> max_stack_usage
) {
807 error_report("thread %d max stack usage increased from %u to %u",
808 qemu_get_thread_id(), max_stack_usage
, usage
);
809 max_stack_usage
= usage
;
817 * Disable CFI checks.
818 * We are going to call a signal hander directly. Such handler may or may not
819 * have been defined in our binary, so there's no guarantee that the pointer
820 * used to set the handler is a cfi-valid pointer. Since the handlers are
821 * stored in kernel memory, changing the handler to an attacker-defined
822 * function requires being able to call a sigaction() syscall,
823 * which is not as easy as overwriting a pointer in memory.
826 void sigaction_invoke(struct sigaction
*action
,
827 struct qemu_signalfd_siginfo
*info
)
830 si
.si_signo
= info
->ssi_signo
;
831 si
.si_errno
= info
->ssi_errno
;
832 si
.si_code
= info
->ssi_code
;
834 /* Convert the minimal set of fields defined by POSIX.
835 * Positive si_code values are reserved for kernel-generated
836 * signals, where the valid siginfo fields are determined by
837 * the signal number. But according to POSIX, it is unspecified
838 * whether SI_USER and SI_QUEUE have values less than or equal to
841 if (info
->ssi_code
== SI_USER
|| info
->ssi_code
== SI_QUEUE
||
842 info
->ssi_code
<= 0) {
844 si
.si_pid
= info
->ssi_pid
;
845 si
.si_uid
= info
->ssi_uid
;
846 } else if (info
->ssi_signo
== SIGILL
|| info
->ssi_signo
== SIGFPE
||
847 info
->ssi_signo
== SIGSEGV
|| info
->ssi_signo
== SIGBUS
) {
848 si
.si_addr
= (void *)(uintptr_t)info
->ssi_addr
;
849 } else if (info
->ssi_signo
== SIGCHLD
) {
850 si
.si_pid
= info
->ssi_pid
;
851 si
.si_status
= info
->ssi_status
;
852 si
.si_uid
= info
->ssi_uid
;
854 action
->sa_sigaction(info
->ssi_signo
, &si
, NULL
);
857 #ifndef HOST_NAME_MAX
858 # ifdef _POSIX_HOST_NAME_MAX
859 # define HOST_NAME_MAX _POSIX_HOST_NAME_MAX
861 # define HOST_NAME_MAX 255
865 char *qemu_get_host_name(Error
**errp
)
868 g_autofree
char *hostname
= NULL
;
870 #ifdef _SC_HOST_NAME_MAX
871 len
= sysconf(_SC_HOST_NAME_MAX
);
872 #endif /* _SC_HOST_NAME_MAX */
878 /* Unfortunately, gethostname() below does not guarantee a
879 * NULL terminated string. Therefore, allocate one byte more
881 hostname
= g_new0(char, len
+ 1);
883 if (gethostname(hostname
, len
) < 0) {
884 error_setg_errno(errp
, errno
,
885 "cannot get hostname");
889 return g_steal_pointer(&hostname
);
892 size_t qemu_get_host_physmem(void)
894 #ifdef _SC_PHYS_PAGES
895 long pages
= sysconf(_SC_PHYS_PAGES
);
897 if (pages
> SIZE_MAX
/ qemu_real_host_page_size
) {
900 return pages
* qemu_real_host_page_size
;