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 <sys/signal.h>
42 #include "qemu/cutils.h"
45 #include <sys/syscall.h>
49 #include <sys/sysctl.h>
56 #include <sys/sysctl.h>
60 #include "qemu/mmap-alloc.h"
62 #ifdef CONFIG_DEBUG_STACK_USAGE
63 #include "qemu/error-report.h"
66 #define MAX_MEM_PREALLOC_THREAD_COUNT 16
75 typedef struct MemsetThread MemsetThread
;
77 static MemsetThread
*memset_thread
;
78 static int memset_num_threads
;
79 static bool memset_thread_failed
;
81 static QemuMutex page_mutex
;
82 static QemuCond page_cond
;
83 static bool threads_created_flag
;
85 int qemu_get_thread_id(void)
87 #if defined(__linux__)
88 return syscall(SYS_gettid
);
89 #elif defined(__FreeBSD__)
90 /* thread id is up to INT_MAX */
94 #elif defined(__NetBSD__)
101 int qemu_daemon(int nochdir
, int noclose
)
103 return daemon(nochdir
, noclose
);
106 bool qemu_write_pidfile(const char *path
, Error
**errp
)
113 struct flock lock
= {
115 .l_whence
= SEEK_SET
,
119 fd
= qemu_open(path
, O_CREAT
| O_WRONLY
, S_IRUSR
| S_IWUSR
);
121 error_setg_errno(errp
, errno
, "Cannot open pid file");
125 if (fstat(fd
, &b
) < 0) {
126 error_setg_errno(errp
, errno
, "Cannot stat file");
130 if (fcntl(fd
, F_SETLK
, &lock
)) {
131 error_setg_errno(errp
, errno
, "Cannot lock pid file");
136 * Now make sure the path we locked is the same one that now
137 * exists on the filesystem.
139 if (stat(path
, &a
) < 0) {
141 * PID file disappeared, someone else must be racing with
148 if (a
.st_ino
== b
.st_ino
) {
153 * PID file was recreated, someone else must be racing with
159 if (ftruncate(fd
, 0) < 0) {
160 error_setg_errno(errp
, errno
, "Failed to truncate pid file");
164 snprintf(pidstr
, sizeof(pidstr
), FMT_pid
"\n", getpid());
165 if (write(fd
, pidstr
, strlen(pidstr
)) != strlen(pidstr
)) {
166 error_setg(errp
, "Failed to write pid file");
179 void *qemu_oom_check(void *ptr
)
182 fprintf(stderr
, "Failed to allocate memory: %s\n", strerror(errno
));
188 void *qemu_try_memalign(size_t alignment
, size_t size
)
192 if (alignment
< sizeof(void*)) {
193 alignment
= sizeof(void*);
196 #if defined(CONFIG_POSIX_MEMALIGN)
198 ret
= posix_memalign(&ptr
, alignment
, size
);
203 #elif defined(CONFIG_BSD)
206 ptr
= memalign(alignment
, size
);
208 trace_qemu_memalign(alignment
, size
, ptr
);
212 void *qemu_memalign(size_t alignment
, size_t size
)
214 return qemu_oom_check(qemu_try_memalign(alignment
, size
));
217 /* alloc shared memory pages */
218 void *qemu_anon_ram_alloc(size_t size
, uint64_t *alignment
, bool shared
)
220 size_t align
= QEMU_VMALLOC_ALIGN
;
221 void *ptr
= qemu_ram_mmap(-1, size
, align
, shared
, false);
223 if (ptr
== MAP_FAILED
) {
231 trace_qemu_anon_ram_alloc(size
, ptr
);
235 void qemu_vfree(void *ptr
)
237 trace_qemu_vfree(ptr
);
241 void qemu_anon_ram_free(void *ptr
, size_t size
)
243 trace_qemu_anon_ram_free(ptr
, size
);
244 qemu_ram_munmap(-1, ptr
, size
);
247 void qemu_set_block(int fd
)
250 f
= fcntl(fd
, F_GETFL
);
252 f
= fcntl(fd
, F_SETFL
, f
& ~O_NONBLOCK
);
256 void qemu_set_nonblock(int fd
)
259 f
= fcntl(fd
, F_GETFL
);
261 f
= fcntl(fd
, F_SETFL
, f
| O_NONBLOCK
);
265 * Previous to OpenBSD 6.3, fcntl(F_SETFL) is not permitted on
266 * memory devices and sets errno to ENODEV.
267 * It's OK if we fail to set O_NONBLOCK on devices like /dev/null,
268 * because they will never block anyway.
270 assert(errno
== ENODEV
);
277 int socket_set_fast_reuse(int fd
)
281 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
282 (const char *)&val
, sizeof(val
));
289 void qemu_set_cloexec(int fd
)
292 f
= fcntl(fd
, F_GETFD
);
294 f
= fcntl(fd
, F_SETFD
, f
| FD_CLOEXEC
);
299 * Creates a pipe with FD_CLOEXEC set on both file descriptors
301 int qemu_pipe(int pipefd
[2])
306 ret
= pipe2(pipefd
, O_CLOEXEC
);
307 if (ret
!= -1 || errno
!= ENOSYS
) {
313 qemu_set_cloexec(pipefd
[0]);
314 qemu_set_cloexec(pipefd
[1]);
321 qemu_get_local_state_pathname(const char *relative_pathname
)
323 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR
,
327 void qemu_set_tty_echo(int fd
, bool echo
)
334 tty
.c_lflag
|= ECHO
| ECHONL
| ICANON
| IEXTEN
;
336 tty
.c_lflag
&= ~(ECHO
| ECHONL
| ICANON
| IEXTEN
);
339 tcsetattr(fd
, TCSANOW
, &tty
);
342 static char exec_dir
[PATH_MAX
];
344 void qemu_init_exec_dir(const char *argv0
)
350 assert(!exec_dir
[0]);
352 #if defined(__linux__)
355 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
361 #elif defined(__FreeBSD__) \
362 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME))
364 #if defined(__FreeBSD__)
365 static int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1};
367 static int mib
[4] = {CTL_KERN
, KERN_PROC_ARGS
, -1, KERN_PROC_PATHNAME
};
369 size_t len
= sizeof(buf
) - 1;
372 if (!sysctl(mib
, ARRAY_SIZE(mib
), buf
, &len
, NULL
, 0) &&
374 buf
[sizeof(buf
) - 1] = '\0';
379 /* If we don't have any way of figuring out the actual executable
380 location then try argv[0]. */
385 p
= realpath(argv0
, buf
);
390 dir
= g_path_get_dirname(p
);
392 pstrcpy(exec_dir
, sizeof(exec_dir
), dir
);
397 char *qemu_get_exec_dir(void)
399 return g_strdup(exec_dir
);
402 static void sigbus_handler(int signal
)
406 for (i
= 0; i
< memset_num_threads
; i
++) {
407 if (qemu_thread_is_self(&memset_thread
[i
].pgthread
)) {
408 siglongjmp(memset_thread
[i
].env
, 1);
414 static void *do_touch_pages(void *arg
)
416 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
417 sigset_t set
, oldset
;
420 * On Linux, the page faults from the loop below can cause mmap_sem
421 * contention with allocation of the thread stacks. Do not start
422 * clearing until all threads have been created.
424 qemu_mutex_lock(&page_mutex
);
425 while(!threads_created_flag
){
426 qemu_cond_wait(&page_cond
, &page_mutex
);
428 qemu_mutex_unlock(&page_mutex
);
432 sigaddset(&set
, SIGBUS
);
433 pthread_sigmask(SIG_UNBLOCK
, &set
, &oldset
);
435 if (sigsetjmp(memset_args
->env
, 1)) {
436 memset_thread_failed
= true;
438 char *addr
= memset_args
->addr
;
439 size_t numpages
= memset_args
->numpages
;
440 size_t hpagesize
= memset_args
->hpagesize
;
442 for (i
= 0; i
< numpages
; i
++) {
444 * Read & write back the same value, so we don't
445 * corrupt existing user/app data that might be
448 * 'volatile' to stop compiler optimizing this away
451 * TODO: get a better solution from kernel so we
452 * don't need to write at all so we don't cause
453 * wear on the storage backing the region...
455 *(volatile char *)addr
= *addr
;
459 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
463 static inline int get_memset_num_threads(int smp_cpus
)
465 long host_procs
= sysconf(_SC_NPROCESSORS_ONLN
);
468 if (host_procs
> 0) {
469 ret
= MIN(MIN(host_procs
, MAX_MEM_PREALLOC_THREAD_COUNT
), smp_cpus
);
471 /* In case sysconf() fails, we fall back to single threaded */
475 static bool touch_all_pages(char *area
, size_t hpagesize
, size_t numpages
,
478 static gsize initialized
= 0;
479 size_t numpages_per_thread
, leftover
;
483 if (g_once_init_enter(&initialized
)) {
484 qemu_mutex_init(&page_mutex
);
485 qemu_cond_init(&page_cond
);
486 g_once_init_leave(&initialized
, 1);
489 memset_thread_failed
= false;
490 threads_created_flag
= false;
491 memset_num_threads
= get_memset_num_threads(smp_cpus
);
492 memset_thread
= g_new0(MemsetThread
, memset_num_threads
);
493 numpages_per_thread
= numpages
/ memset_num_threads
;
494 leftover
= numpages
% memset_num_threads
;
495 for (i
= 0; i
< memset_num_threads
; i
++) {
496 memset_thread
[i
].addr
= addr
;
497 memset_thread
[i
].numpages
= numpages_per_thread
+ (i
< leftover
);
498 memset_thread
[i
].hpagesize
= hpagesize
;
499 qemu_thread_create(&memset_thread
[i
].pgthread
, "touch_pages",
500 do_touch_pages
, &memset_thread
[i
],
501 QEMU_THREAD_JOINABLE
);
502 addr
+= memset_thread
[i
].numpages
* hpagesize
;
505 qemu_mutex_lock(&page_mutex
);
506 threads_created_flag
= true;
507 qemu_cond_broadcast(&page_cond
);
508 qemu_mutex_unlock(&page_mutex
);
510 for (i
= 0; i
< memset_num_threads
; i
++) {
511 qemu_thread_join(&memset_thread
[i
].pgthread
);
513 g_free(memset_thread
);
514 memset_thread
= NULL
;
516 return memset_thread_failed
;
519 void os_mem_prealloc(int fd
, char *area
, size_t memory
, int smp_cpus
,
523 struct sigaction act
, oldact
;
524 size_t hpagesize
= qemu_fd_getpagesize(fd
);
525 size_t numpages
= DIV_ROUND_UP(memory
, hpagesize
);
527 memset(&act
, 0, sizeof(act
));
528 act
.sa_handler
= &sigbus_handler
;
531 ret
= sigaction(SIGBUS
, &act
, &oldact
);
533 error_setg_errno(errp
, errno
,
534 "os_mem_prealloc: failed to install signal handler");
538 /* touch pages simultaneously */
539 if (touch_all_pages(area
, hpagesize
, numpages
, smp_cpus
)) {
540 error_setg(errp
, "os_mem_prealloc: Insufficient free host memory "
541 "pages available to allocate guest RAM");
544 ret
= sigaction(SIGBUS
, &oldact
, NULL
);
546 /* Terminate QEMU since it can't recover from error */
547 perror("os_mem_prealloc: failed to reinstall signal handler");
552 char *qemu_get_pid_name(pid_t pid
)
556 #if defined(__FreeBSD__)
557 /* BSDs don't have /proc, but they provide a nice substitute */
558 struct kinfo_proc
*proc
= kinfo_getproc(pid
);
561 name
= g_strdup(proc
->ki_comm
);
565 /* Assume a system with reasonable procfs */
569 pid_path
= g_strdup_printf("/proc/%d/cmdline", pid
);
570 g_file_get_contents(pid_path
, &name
, &len
, NULL
);
578 pid_t
qemu_fork(Error
**errp
)
580 sigset_t oldmask
, newmask
;
581 struct sigaction sig_action
;
586 * Need to block signals now, so that child process can safely
587 * kill off caller's signal handlers without a race.
589 sigfillset(&newmask
);
590 if (pthread_sigmask(SIG_SETMASK
, &newmask
, &oldmask
) != 0) {
591 error_setg_errno(errp
, errno
,
592 "cannot block signals");
600 /* attempt to restore signal mask, but ignore failure, to
601 * avoid obscuring the fork failure */
602 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
603 error_setg_errno(errp
, saved_errno
,
604 "cannot fork child process");
610 /* Restore our original signal mask now that the child is
611 * safely running. Only documented failures are EFAULT (not
612 * possible, since we are using just-grabbed mask) or EINVAL
613 * (not possible, since we are using correct arguments). */
614 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
619 /* Clear out all signal handlers from parent so nothing
620 * unexpected can happen in our child once we unblock
622 sig_action
.sa_handler
= SIG_DFL
;
623 sig_action
.sa_flags
= 0;
624 sigemptyset(&sig_action
.sa_mask
);
626 for (i
= 1; i
< NSIG
; i
++) {
627 /* Only possible errors are EFAULT or EINVAL The former
628 * won't happen, the latter we expect, so no need to check
630 (void)sigaction(i
, &sig_action
, NULL
);
633 /* Unmask all signals in child, since we've no idea what the
634 * caller's done with their signal mask and don't want to
635 * propagate that to children */
636 sigemptyset(&newmask
);
637 if (pthread_sigmask(SIG_SETMASK
, &newmask
, NULL
) != 0) {
638 Error
*local_err
= NULL
;
639 error_setg_errno(&local_err
, errno
,
640 "cannot unblock signals");
641 error_report_err(local_err
);
648 void *qemu_alloc_stack(size_t *sz
)
650 void *ptr
, *guardpage
;
652 #ifdef CONFIG_DEBUG_STACK_USAGE
655 size_t pagesz
= qemu_real_host_page_size
;
656 #ifdef _SC_THREAD_STACK_MIN
657 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
658 long min_stack_sz
= sysconf(_SC_THREAD_STACK_MIN
);
659 *sz
= MAX(MAX(min_stack_sz
, 0), *sz
);
661 /* adjust stack size to a multiple of the page size */
662 *sz
= ROUND_UP(*sz
, pagesz
);
663 /* allocate one extra page for the guard page */
666 flags
= MAP_PRIVATE
| MAP_ANONYMOUS
;
667 #if defined(MAP_STACK) && defined(__OpenBSD__)
668 /* Only enable MAP_STACK on OpenBSD. Other OS's such as
669 * Linux/FreeBSD/NetBSD have a flag with the same name
670 * but have differing functionality. OpenBSD will SEGV
671 * if it spots execution with a stack pointer pointing
672 * at memory that was not allocated with MAP_STACK.
677 ptr
= mmap(NULL
, *sz
, PROT_READ
| PROT_WRITE
, flags
, -1, 0);
678 if (ptr
== MAP_FAILED
) {
679 perror("failed to allocate memory for stack");
683 #if defined(HOST_IA64)
684 /* separate register stack */
685 guardpage
= ptr
+ (((*sz
- pagesz
) / 2) & ~pagesz
);
686 #elif defined(HOST_HPPA)
688 guardpage
= ptr
+ *sz
- pagesz
;
690 /* stack grows down */
693 if (mprotect(guardpage
, pagesz
, PROT_NONE
) != 0) {
694 perror("failed to set up stack guard page");
698 #ifdef CONFIG_DEBUG_STACK_USAGE
699 for (ptr2
= ptr
+ pagesz
; ptr2
< ptr
+ *sz
; ptr2
+= sizeof(uint32_t)) {
700 *(uint32_t *)ptr2
= 0xdeadbeaf;
707 #ifdef CONFIG_DEBUG_STACK_USAGE
708 static __thread
unsigned int max_stack_usage
;
711 void qemu_free_stack(void *stack
, size_t sz
)
713 #ifdef CONFIG_DEBUG_STACK_USAGE
717 for (ptr
= stack
+ qemu_real_host_page_size
; ptr
< stack
+ sz
;
718 ptr
+= sizeof(uint32_t)) {
719 if (*(uint32_t *)ptr
!= 0xdeadbeaf) {
723 usage
= sz
- (uintptr_t) (ptr
- stack
);
724 if (usage
> max_stack_usage
) {
725 error_report("thread %d max stack usage increased from %u to %u",
726 qemu_get_thread_id(), max_stack_usage
, usage
);
727 max_stack_usage
= usage
;
734 void sigaction_invoke(struct sigaction
*action
,
735 struct qemu_signalfd_siginfo
*info
)
738 si
.si_signo
= info
->ssi_signo
;
739 si
.si_errno
= info
->ssi_errno
;
740 si
.si_code
= info
->ssi_code
;
742 /* Convert the minimal set of fields defined by POSIX.
743 * Positive si_code values are reserved for kernel-generated
744 * signals, where the valid siginfo fields are determined by
745 * the signal number. But according to POSIX, it is unspecified
746 * whether SI_USER and SI_QUEUE have values less than or equal to
749 if (info
->ssi_code
== SI_USER
|| info
->ssi_code
== SI_QUEUE
||
750 info
->ssi_code
<= 0) {
752 si
.si_pid
= info
->ssi_pid
;
753 si
.si_uid
= info
->ssi_uid
;
754 } else if (info
->ssi_signo
== SIGILL
|| info
->ssi_signo
== SIGFPE
||
755 info
->ssi_signo
== SIGSEGV
|| info
->ssi_signo
== SIGBUS
) {
756 si
.si_addr
= (void *)(uintptr_t)info
->ssi_addr
;
757 } else if (info
->ssi_signo
== SIGCHLD
) {
758 si
.si_pid
= info
->ssi_pid
;
759 si
.si_status
= info
->ssi_status
;
760 si
.si_uid
= info
->ssi_uid
;
762 action
->sa_sigaction(info
->ssi_signo
, &si
, NULL
);