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/sockets.h"
39 #include <sys/signal.h>
40 #include "qemu/cutils.h"
43 #include <sys/syscall.h>
47 #include <sys/sysctl.h>
52 #include "qemu/mmap-alloc.h"
54 #ifdef CONFIG_DEBUG_STACK_USAGE
55 #include "qemu/error-report.h"
58 #define MAX_MEM_PREALLOC_THREAD_COUNT (MIN(sysconf(_SC_NPROCESSORS_ONLN), 16))
67 typedef struct MemsetThread MemsetThread
;
69 static MemsetThread
*memset_thread
;
70 static int memset_num_threads
;
71 static bool memset_thread_failed
;
73 int qemu_get_thread_id(void)
75 #if defined(__linux__)
76 return syscall(SYS_gettid
);
82 int qemu_daemon(int nochdir
, int noclose
)
84 return daemon(nochdir
, noclose
);
87 void *qemu_oom_check(void *ptr
)
90 fprintf(stderr
, "Failed to allocate memory: %s\n", strerror(errno
));
96 void *qemu_try_memalign(size_t alignment
, size_t size
)
100 if (alignment
< sizeof(void*)) {
101 alignment
= sizeof(void*);
104 #if defined(_POSIX_C_SOURCE) && !defined(__sun__)
106 ret
= posix_memalign(&ptr
, alignment
, size
);
111 #elif defined(CONFIG_BSD)
114 ptr
= memalign(alignment
, size
);
116 trace_qemu_memalign(alignment
, size
, ptr
);
120 void *qemu_memalign(size_t alignment
, size_t size
)
122 return qemu_oom_check(qemu_try_memalign(alignment
, size
));
125 /* alloc shared memory pages */
126 void *qemu_anon_ram_alloc(size_t size
, uint64_t *alignment
)
128 size_t align
= QEMU_VMALLOC_ALIGN
;
129 void *ptr
= qemu_ram_mmap(-1, size
, align
, false);
131 if (ptr
== MAP_FAILED
) {
139 trace_qemu_anon_ram_alloc(size
, ptr
);
143 void qemu_vfree(void *ptr
)
145 trace_qemu_vfree(ptr
);
149 void qemu_anon_ram_free(void *ptr
, size_t size
)
151 trace_qemu_anon_ram_free(ptr
, size
);
152 qemu_ram_munmap(ptr
, size
);
155 void qemu_set_block(int fd
)
158 f
= fcntl(fd
, F_GETFL
);
159 fcntl(fd
, F_SETFL
, f
& ~O_NONBLOCK
);
162 void qemu_set_nonblock(int fd
)
165 f
= fcntl(fd
, F_GETFL
);
166 fcntl(fd
, F_SETFL
, f
| O_NONBLOCK
);
169 int socket_set_fast_reuse(int fd
)
173 ret
= setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
174 (const char *)&val
, sizeof(val
));
181 void qemu_set_cloexec(int fd
)
184 f
= fcntl(fd
, F_GETFD
);
185 fcntl(fd
, F_SETFD
, f
| FD_CLOEXEC
);
189 * Creates a pipe with FD_CLOEXEC set on both file descriptors
191 int qemu_pipe(int pipefd
[2])
196 ret
= pipe2(pipefd
, O_CLOEXEC
);
197 if (ret
!= -1 || errno
!= ENOSYS
) {
203 qemu_set_cloexec(pipefd
[0]);
204 qemu_set_cloexec(pipefd
[1]);
210 int qemu_utimens(const char *path
, const struct timespec
*times
)
212 struct timeval tv
[2], tv_now
;
215 #ifdef CONFIG_UTIMENSAT
218 ret
= utimensat(AT_FDCWD
, path
, times
, AT_SYMLINK_NOFOLLOW
);
219 if (ret
!= -1 || errno
!= ENOSYS
) {
223 /* Fallback: use utimes() instead of utimensat() */
225 /* happy if special cases */
226 if (times
[0].tv_nsec
== UTIME_OMIT
&& times
[1].tv_nsec
== UTIME_OMIT
) {
229 if (times
[0].tv_nsec
== UTIME_NOW
&& times
[1].tv_nsec
== UTIME_NOW
) {
230 return utimes(path
, NULL
);
233 /* prepare for hard cases */
234 if (times
[0].tv_nsec
== UTIME_NOW
|| times
[1].tv_nsec
== UTIME_NOW
) {
235 gettimeofday(&tv_now
, NULL
);
237 if (times
[0].tv_nsec
== UTIME_OMIT
|| times
[1].tv_nsec
== UTIME_OMIT
) {
241 for (i
= 0; i
< 2; i
++) {
242 if (times
[i
].tv_nsec
== UTIME_NOW
) {
243 tv
[i
].tv_sec
= tv_now
.tv_sec
;
244 tv
[i
].tv_usec
= tv_now
.tv_usec
;
245 } else if (times
[i
].tv_nsec
== UTIME_OMIT
) {
246 tv
[i
].tv_sec
= (i
== 0) ? st
.st_atime
: st
.st_mtime
;
249 tv
[i
].tv_sec
= times
[i
].tv_sec
;
250 tv
[i
].tv_usec
= times
[i
].tv_nsec
/ 1000;
254 return utimes(path
, &tv
[0]);
258 qemu_get_local_state_pathname(const char *relative_pathname
)
260 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR
,
264 void qemu_set_tty_echo(int fd
, bool echo
)
271 tty
.c_lflag
|= ECHO
| ECHONL
| ICANON
| IEXTEN
;
273 tty
.c_lflag
&= ~(ECHO
| ECHONL
| ICANON
| IEXTEN
);
276 tcsetattr(fd
, TCSANOW
, &tty
);
279 static char exec_dir
[PATH_MAX
];
281 void qemu_init_exec_dir(const char *argv0
)
287 assert(!exec_dir
[0]);
289 #if defined(__linux__)
292 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
298 #elif defined(__FreeBSD__)
300 static int mib
[4] = {CTL_KERN
, KERN_PROC
, KERN_PROC_PATHNAME
, -1};
301 size_t len
= sizeof(buf
) - 1;
304 if (!sysctl(mib
, ARRAY_SIZE(mib
), buf
, &len
, NULL
, 0) &&
306 buf
[sizeof(buf
) - 1] = '\0';
311 /* If we don't have any way of figuring out the actual executable
312 location then try argv[0]. */
317 p
= realpath(argv0
, buf
);
322 dir
= g_path_get_dirname(p
);
324 pstrcpy(exec_dir
, sizeof(exec_dir
), dir
);
329 char *qemu_get_exec_dir(void)
331 return g_strdup(exec_dir
);
334 static void sigbus_handler(int signal
)
338 for (i
= 0; i
< memset_num_threads
; i
++) {
339 if (qemu_thread_is_self(&memset_thread
[i
].pgthread
)) {
340 siglongjmp(memset_thread
[i
].env
, 1);
346 static void *do_touch_pages(void *arg
)
348 MemsetThread
*memset_args
= (MemsetThread
*)arg
;
349 char *addr
= memset_args
->addr
;
350 uint64_t numpages
= memset_args
->numpages
;
351 uint64_t hpagesize
= memset_args
->hpagesize
;
352 sigset_t set
, oldset
;
357 sigaddset(&set
, SIGBUS
);
358 pthread_sigmask(SIG_UNBLOCK
, &set
, &oldset
);
360 if (sigsetjmp(memset_args
->env
, 1)) {
361 memset_thread_failed
= true;
363 for (i
= 0; i
< numpages
; i
++) {
368 pthread_sigmask(SIG_SETMASK
, &oldset
, NULL
);
372 static bool touch_all_pages(char *area
, size_t hpagesize
, size_t numpages
,
375 uint64_t numpages_per_thread
, size_per_thread
;
379 memset_thread_failed
= false;
380 memset_num_threads
= MIN(smp_cpus
, MAX_MEM_PREALLOC_THREAD_COUNT
);
381 memset_thread
= g_new0(MemsetThread
, memset_num_threads
);
382 numpages_per_thread
= (numpages
/ memset_num_threads
);
383 size_per_thread
= (hpagesize
* numpages_per_thread
);
384 for (i
= 0; i
< memset_num_threads
; i
++) {
385 memset_thread
[i
].addr
= addr
;
386 memset_thread
[i
].numpages
= (i
== (memset_num_threads
- 1)) ?
387 numpages
: numpages_per_thread
;
388 memset_thread
[i
].hpagesize
= hpagesize
;
389 qemu_thread_create(&memset_thread
[i
].pgthread
, "touch_pages",
390 do_touch_pages
, &memset_thread
[i
],
391 QEMU_THREAD_JOINABLE
);
392 addr
+= size_per_thread
;
393 numpages
-= numpages_per_thread
;
395 for (i
= 0; i
< memset_num_threads
; i
++) {
396 qemu_thread_join(&memset_thread
[i
].pgthread
);
398 g_free(memset_thread
);
399 memset_thread
= NULL
;
401 return memset_thread_failed
;
404 void os_mem_prealloc(int fd
, char *area
, size_t memory
, int smp_cpus
,
408 struct sigaction act
, oldact
;
409 size_t hpagesize
= qemu_fd_getpagesize(fd
);
410 size_t numpages
= DIV_ROUND_UP(memory
, hpagesize
);
412 memset(&act
, 0, sizeof(act
));
413 act
.sa_handler
= &sigbus_handler
;
416 ret
= sigaction(SIGBUS
, &act
, &oldact
);
418 error_setg_errno(errp
, errno
,
419 "os_mem_prealloc: failed to install signal handler");
423 /* touch pages simultaneously */
424 if (touch_all_pages(area
, hpagesize
, numpages
, smp_cpus
)) {
425 error_setg(errp
, "os_mem_prealloc: Insufficient free host memory "
426 "pages available to allocate guest RAM\n");
429 ret
= sigaction(SIGBUS
, &oldact
, NULL
);
431 /* Terminate QEMU since it can't recover from error */
432 perror("os_mem_prealloc: failed to reinstall signal handler");
438 static struct termios oldtty
;
440 static void term_exit(void)
442 tcsetattr(0, TCSANOW
, &oldtty
);
445 static void term_init(void)
452 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
453 |INLCR
|IGNCR
|ICRNL
|IXON
);
454 tty
.c_oflag
|= OPOST
;
455 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
456 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
461 tcsetattr(0, TCSANOW
, &tty
);
466 int qemu_read_password(char *buf
, int buf_size
)
471 printf("password: ");
476 ret
= read(0, &ch
, 1);
478 if (errno
== EAGAIN
|| errno
== EINTR
) {
483 } else if (ret
== 0) {
492 if (i
< (buf_size
- 1)) {
504 char *qemu_get_pid_name(pid_t pid
)
508 #if defined(__FreeBSD__)
509 /* BSDs don't have /proc, but they provide a nice substitute */
510 struct kinfo_proc
*proc
= kinfo_getproc(pid
);
513 name
= g_strdup(proc
->ki_comm
);
517 /* Assume a system with reasonable procfs */
521 pid_path
= g_strdup_printf("/proc/%d/cmdline", pid
);
522 g_file_get_contents(pid_path
, &name
, &len
, NULL
);
530 pid_t
qemu_fork(Error
**errp
)
532 sigset_t oldmask
, newmask
;
533 struct sigaction sig_action
;
538 * Need to block signals now, so that child process can safely
539 * kill off caller's signal handlers without a race.
541 sigfillset(&newmask
);
542 if (pthread_sigmask(SIG_SETMASK
, &newmask
, &oldmask
) != 0) {
543 error_setg_errno(errp
, errno
,
544 "cannot block signals");
552 /* attempt to restore signal mask, but ignore failure, to
553 * avoid obscuring the fork failure */
554 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
555 error_setg_errno(errp
, saved_errno
,
556 "cannot fork child process");
562 /* Restore our original signal mask now that the child is
563 * safely running. Only documented failures are EFAULT (not
564 * possible, since we are using just-grabbed mask) or EINVAL
565 * (not possible, since we are using correct arguments). */
566 (void)pthread_sigmask(SIG_SETMASK
, &oldmask
, NULL
);
571 /* Clear out all signal handlers from parent so nothing
572 * unexpected can happen in our child once we unblock
574 sig_action
.sa_handler
= SIG_DFL
;
575 sig_action
.sa_flags
= 0;
576 sigemptyset(&sig_action
.sa_mask
);
578 for (i
= 1; i
< NSIG
; i
++) {
579 /* Only possible errors are EFAULT or EINVAL The former
580 * won't happen, the latter we expect, so no need to check
582 (void)sigaction(i
, &sig_action
, NULL
);
585 /* Unmask all signals in child, since we've no idea what the
586 * caller's done with their signal mask and don't want to
587 * propagate that to children */
588 sigemptyset(&newmask
);
589 if (pthread_sigmask(SIG_SETMASK
, &newmask
, NULL
) != 0) {
590 Error
*local_err
= NULL
;
591 error_setg_errno(&local_err
, errno
,
592 "cannot unblock signals");
593 error_report_err(local_err
);
600 void *qemu_alloc_stack(size_t *sz
)
602 void *ptr
, *guardpage
;
603 #ifdef CONFIG_DEBUG_STACK_USAGE
606 size_t pagesz
= getpagesize();
607 #ifdef _SC_THREAD_STACK_MIN
608 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
609 long min_stack_sz
= sysconf(_SC_THREAD_STACK_MIN
);
610 *sz
= MAX(MAX(min_stack_sz
, 0), *sz
);
612 /* adjust stack size to a multiple of the page size */
613 *sz
= ROUND_UP(*sz
, pagesz
);
614 /* allocate one extra page for the guard page */
617 ptr
= mmap(NULL
, *sz
, PROT_READ
| PROT_WRITE
,
618 MAP_PRIVATE
| MAP_ANONYMOUS
, -1, 0);
619 if (ptr
== MAP_FAILED
) {
623 #if defined(HOST_IA64)
624 /* separate register stack */
625 guardpage
= ptr
+ (((*sz
- pagesz
) / 2) & ~pagesz
);
626 #elif defined(HOST_HPPA)
628 guardpage
= ptr
+ *sz
- pagesz
;
630 /* stack grows down */
633 if (mprotect(guardpage
, pagesz
, PROT_NONE
) != 0) {
637 #ifdef CONFIG_DEBUG_STACK_USAGE
638 for (ptr2
= ptr
+ pagesz
; ptr2
< ptr
+ *sz
; ptr2
+= sizeof(uint32_t)) {
639 *(uint32_t *)ptr2
= 0xdeadbeaf;
646 #ifdef CONFIG_DEBUG_STACK_USAGE
647 static __thread
unsigned int max_stack_usage
;
650 void qemu_free_stack(void *stack
, size_t sz
)
652 #ifdef CONFIG_DEBUG_STACK_USAGE
656 for (ptr
= stack
+ getpagesize(); ptr
< stack
+ sz
;
657 ptr
+= sizeof(uint32_t)) {
658 if (*(uint32_t *)ptr
!= 0xdeadbeaf) {
662 usage
= sz
- (uintptr_t) (ptr
- stack
);
663 if (usage
> max_stack_usage
) {
664 error_report("thread %d max stack usage increased from %u to %u",
665 qemu_get_thread_id(), max_stack_usage
, usage
);
666 max_stack_usage
= usage
;
673 void sigaction_invoke(struct sigaction
*action
,
674 struct qemu_signalfd_siginfo
*info
)
676 siginfo_t si
= { 0 };
677 si
.si_signo
= info
->ssi_signo
;
678 si
.si_errno
= info
->ssi_errno
;
679 si
.si_code
= info
->ssi_code
;
681 /* Convert the minimal set of fields defined by POSIX.
682 * Positive si_code values are reserved for kernel-generated
683 * signals, where the valid siginfo fields are determined by
684 * the signal number. But according to POSIX, it is unspecified
685 * whether SI_USER and SI_QUEUE have values less than or equal to
688 if (info
->ssi_code
== SI_USER
|| info
->ssi_code
== SI_QUEUE
||
689 info
->ssi_code
<= 0) {
691 si
.si_pid
= info
->ssi_pid
;
692 si
.si_uid
= info
->ssi_uid
;
693 } else if (info
->ssi_signo
== SIGILL
|| info
->ssi_signo
== SIGFPE
||
694 info
->ssi_signo
== SIGSEGV
|| info
->ssi_signo
== SIGBUS
) {
695 si
.si_addr
= (void *)(uintptr_t)info
->ssi_addr
;
696 } else if (info
->ssi_signo
== SIGCHLD
) {
697 si
.si_pid
= info
->ssi_pid
;
698 si
.si_status
= info
->ssi_status
;
699 si
.si_uid
= info
->ssi_uid
;
700 } else if (info
->ssi_signo
== SIGIO
) {
701 si
.si_band
= info
->ssi_band
;
703 action
->sa_sigaction(info
->ssi_signo
, &si
, NULL
);