1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include "qemu/osdep.h"
30#include <termios.h>
31
32#include <glib/gprintf.h>
33
34#include "qemu-common.h"
35#include "sysemu/sysemu.h"
36#include "trace.h"
37#include "qapi/error.h"
38#include "qemu/sockets.h"
39#include "qemu/thread.h"
40#include <libgen.h>
41#include <sys/signal.h>
42#include "qemu/cutils.h"
43
44#ifdef CONFIG_LINUX
45#include <sys/syscall.h>
46#endif
47
48#ifdef __FreeBSD__
49#include <sys/sysctl.h>
50#include <sys/user.h>
51#include <libutil.h>
52#endif
53
54#ifdef __NetBSD__
55#include <sys/sysctl.h>
56#endif
57
58#include "qemu/mmap-alloc.h"
59
60#ifdef CONFIG_DEBUG_STACK_USAGE
61#include "qemu/error-report.h"
62#endif
63
64#define MAX_MEM_PREALLOC_THREAD_COUNT 16
65
66struct MemsetThread {
67 char *addr;
68 size_t numpages;
69 size_t hpagesize;
70 QemuThread pgthread;
71 sigjmp_buf env;
72};
73typedef struct MemsetThread MemsetThread;
74
75static MemsetThread *memset_thread;
76static int memset_num_threads;
77static bool memset_thread_failed;
78
79int qemu_get_thread_id(void)
80{
81#if defined(__linux__)
82 return syscall(SYS_gettid);
83#else
84 return getpid();
85#endif
86}
87
88int qemu_daemon(int nochdir, int noclose)
89{
90 return daemon(nochdir, noclose);
91}
92
93bool qemu_write_pidfile(const char *path, Error **errp)
94{
95 int fd;
96 char pidstr[32];
97
98 while (1) {
99 struct stat a, b;
100 struct flock lock = {
101 .l_type = F_WRLCK,
102 .l_whence = SEEK_SET,
103 .l_len = 0,
104 };
105
106 fd = qemu_open(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
107 if (fd == -1) {
108 error_setg_errno(errp, errno, "Cannot open pid file");
109 return false;
110 }
111
112 if (fstat(fd, &b) < 0) {
113 error_setg_errno(errp, errno, "Cannot stat file");
114 goto fail_close;
115 }
116
117 if (fcntl(fd, F_SETLK, &lock)) {
118 error_setg_errno(errp, errno, "Cannot lock pid file");
119 goto fail_close;
120 }
121
122
123
124
125
126 if (stat(path, &a) < 0) {
127
128
129
130
131 close(fd);
132 continue;
133 }
134
135 if (a.st_ino == b.st_ino) {
136 break;
137 }
138
139
140
141
142
143 close(fd);
144 }
145
146 if (ftruncate(fd, 0) < 0) {
147 error_setg_errno(errp, errno, "Failed to truncate pid file");
148 goto fail_unlink;
149 }
150
151 snprintf(pidstr, sizeof(pidstr), FMT_pid "\n", getpid());
152 if (write(fd, pidstr, strlen(pidstr)) != strlen(pidstr)) {
153 error_setg(errp, "Failed to write pid file");
154 goto fail_unlink;
155 }
156
157 return true;
158
159fail_unlink:
160 unlink(path);
161fail_close:
162 close(fd);
163 return false;
164}
165
166void *qemu_oom_check(void *ptr)
167{
168 if (ptr == NULL) {
169 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
170 abort();
171 }
172 return ptr;
173}
174
175void *qemu_try_memalign(size_t alignment, size_t size)
176{
177 void *ptr;
178
179 if (alignment < sizeof(void*)) {
180 alignment = sizeof(void*);
181 }
182
183#if defined(CONFIG_POSIX_MEMALIGN)
184 int ret;
185 ret = posix_memalign(&ptr, alignment, size);
186 if (ret != 0) {
187 errno = ret;
188 ptr = NULL;
189 }
190#elif defined(CONFIG_BSD)
191 ptr = valloc(size);
192#else
193 ptr = memalign(alignment, size);
194#endif
195 trace_qemu_memalign(alignment, size, ptr);
196 return ptr;
197}
198
199void *qemu_memalign(size_t alignment, size_t size)
200{
201 return qemu_oom_check(qemu_try_memalign(alignment, size));
202}
203
204
205void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment, bool shared)
206{
207 size_t align = QEMU_VMALLOC_ALIGN;
208 void *ptr = qemu_ram_mmap(-1, size, align, shared, false);
209
210 if (ptr == MAP_FAILED) {
211 return NULL;
212 }
213
214 if (alignment) {
215 *alignment = align;
216 }
217
218 trace_qemu_anon_ram_alloc(size, ptr);
219 return ptr;
220}
221
222void qemu_vfree(void *ptr)
223{
224 trace_qemu_vfree(ptr);
225 free(ptr);
226}
227
228void qemu_anon_ram_free(void *ptr, size_t size)
229{
230 trace_qemu_anon_ram_free(ptr, size);
231 qemu_ram_munmap(-1, ptr, size);
232}
233
234void qemu_set_block(int fd)
235{
236 int f;
237 f = fcntl(fd, F_GETFL);
238 assert(f != -1);
239 f = fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
240 assert(f != -1);
241}
242
243void qemu_set_nonblock(int fd)
244{
245 int f;
246 f = fcntl(fd, F_GETFL);
247 assert(f != -1);
248 f = fcntl(fd, F_SETFL, f | O_NONBLOCK);
249#ifdef __OpenBSD__
250 if (f == -1) {
251
252
253
254
255
256
257 assert(errno == ENODEV);
258 }
259#else
260 assert(f != -1);
261#endif
262}
263
264int socket_set_fast_reuse(int fd)
265{
266 int val = 1, ret;
267
268 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
269 (const char *)&val, sizeof(val));
270
271 assert(ret == 0);
272
273 return ret;
274}
275
276void qemu_set_cloexec(int fd)
277{
278 int f;
279 f = fcntl(fd, F_GETFD);
280 assert(f != -1);
281 f = fcntl(fd, F_SETFD, f | FD_CLOEXEC);
282 assert(f != -1);
283}
284
285
286
287
288int qemu_pipe(int pipefd[2])
289{
290 int ret;
291
292#ifdef CONFIG_PIPE2
293 ret = pipe2(pipefd, O_CLOEXEC);
294 if (ret != -1 || errno != ENOSYS) {
295 return ret;
296 }
297#endif
298 ret = pipe(pipefd);
299 if (ret == 0) {
300 qemu_set_cloexec(pipefd[0]);
301 qemu_set_cloexec(pipefd[1]);
302 }
303
304 return ret;
305}
306
307char *
308qemu_get_local_state_pathname(const char *relative_pathname)
309{
310 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR,
311 relative_pathname);
312}
313
314void qemu_set_tty_echo(int fd, bool echo)
315{
316 struct termios tty;
317
318 tcgetattr(fd, &tty);
319
320 if (echo) {
321 tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN;
322 } else {
323 tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
324 }
325
326 tcsetattr(fd, TCSANOW, &tty);
327}
328
329static char exec_dir[PATH_MAX];
330
331void qemu_init_exec_dir(const char *argv0)
332{
333 char *dir;
334 char *p = NULL;
335 char buf[PATH_MAX];
336
337 assert(!exec_dir[0]);
338
339#if defined(__linux__)
340 {
341 int len;
342 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
343 if (len > 0) {
344 buf[len] = 0;
345 p = buf;
346 }
347 }
348#elif defined(__FreeBSD__) \
349 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME))
350 {
351#if defined(__FreeBSD__)
352 static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
353#else
354 static int mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
355#endif
356 size_t len = sizeof(buf) - 1;
357
358 *buf = '\0';
359 if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) &&
360 *buf) {
361 buf[sizeof(buf) - 1] = '\0';
362 p = buf;
363 }
364 }
365#endif
366
367
368 if (!p) {
369 if (!argv0) {
370 return;
371 }
372 p = realpath(argv0, buf);
373 if (!p) {
374 return;
375 }
376 }
377 dir = g_path_get_dirname(p);
378
379 pstrcpy(exec_dir, sizeof(exec_dir), dir);
380
381 g_free(dir);
382}
383
384char *qemu_get_exec_dir(void)
385{
386 return g_strdup(exec_dir);
387}
388
389static void sigbus_handler(int signal)
390{
391 int i;
392 if (memset_thread) {
393 for (i = 0; i < memset_num_threads; i++) {
394 if (qemu_thread_is_self(&memset_thread[i].pgthread)) {
395 siglongjmp(memset_thread[i].env, 1);
396 }
397 }
398 }
399}
400
401static void *do_touch_pages(void *arg)
402{
403 MemsetThread *memset_args = (MemsetThread *)arg;
404 sigset_t set, oldset;
405
406
407 sigemptyset(&set);
408 sigaddset(&set, SIGBUS);
409 pthread_sigmask(SIG_UNBLOCK, &set, &oldset);
410
411 if (sigsetjmp(memset_args->env, 1)) {
412 memset_thread_failed = true;
413 } else {
414 char *addr = memset_args->addr;
415 size_t numpages = memset_args->numpages;
416 size_t hpagesize = memset_args->hpagesize;
417 size_t i;
418 for (i = 0; i < numpages; i++) {
419
420
421
422
423
424
425
426
427
428
429
430
431 *(volatile char *)addr = *addr;
432 addr += hpagesize;
433 }
434 }
435 pthread_sigmask(SIG_SETMASK, &oldset, NULL);
436 return NULL;
437}
438
439static inline int get_memset_num_threads(int smp_cpus)
440{
441 long host_procs = sysconf(_SC_NPROCESSORS_ONLN);
442 int ret = 1;
443
444 if (host_procs > 0) {
445 ret = MIN(MIN(host_procs, MAX_MEM_PREALLOC_THREAD_COUNT), smp_cpus);
446 }
447
448 return ret;
449}
450
451static bool touch_all_pages(char *area, size_t hpagesize, size_t numpages,
452 int smp_cpus)
453{
454 size_t numpages_per_thread;
455 size_t size_per_thread;
456 char *addr = area;
457 int i = 0;
458
459 memset_thread_failed = false;
460 memset_num_threads = get_memset_num_threads(smp_cpus);
461 memset_thread = g_new0(MemsetThread, memset_num_threads);
462 numpages_per_thread = (numpages / memset_num_threads);
463 size_per_thread = (hpagesize * numpages_per_thread);
464 for (i = 0; i < memset_num_threads; i++) {
465 memset_thread[i].addr = addr;
466 memset_thread[i].numpages = (i == (memset_num_threads - 1)) ?
467 numpages : numpages_per_thread;
468 memset_thread[i].hpagesize = hpagesize;
469 qemu_thread_create(&memset_thread[i].pgthread, "touch_pages",
470 do_touch_pages, &memset_thread[i],
471 QEMU_THREAD_JOINABLE);
472 addr += size_per_thread;
473 numpages -= numpages_per_thread;
474 }
475 for (i = 0; i < memset_num_threads; i++) {
476 qemu_thread_join(&memset_thread[i].pgthread);
477 }
478 g_free(memset_thread);
479 memset_thread = NULL;
480
481 return memset_thread_failed;
482}
483
484void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus,
485 Error **errp)
486{
487 int ret;
488 struct sigaction act, oldact;
489 size_t hpagesize = qemu_fd_getpagesize(fd);
490 size_t numpages = DIV_ROUND_UP(memory, hpagesize);
491
492 memset(&act, 0, sizeof(act));
493 act.sa_handler = &sigbus_handler;
494 act.sa_flags = 0;
495
496 ret = sigaction(SIGBUS, &act, &oldact);
497 if (ret) {
498 error_setg_errno(errp, errno,
499 "os_mem_prealloc: failed to install signal handler");
500 return;
501 }
502
503
504 if (touch_all_pages(area, hpagesize, numpages, smp_cpus)) {
505 error_setg(errp, "os_mem_prealloc: Insufficient free host memory "
506 "pages available to allocate guest RAM");
507 }
508
509 ret = sigaction(SIGBUS, &oldact, NULL);
510 if (ret) {
511
512 perror("os_mem_prealloc: failed to reinstall signal handler");
513 exit(1);
514 }
515}
516
517char *qemu_get_pid_name(pid_t pid)
518{
519 char *name = NULL;
520
521#if defined(__FreeBSD__)
522
523 struct kinfo_proc *proc = kinfo_getproc(pid);
524
525 if (proc) {
526 name = g_strdup(proc->ki_comm);
527 free(proc);
528 }
529#else
530
531 char *pid_path;
532 size_t len;
533
534 pid_path = g_strdup_printf("/proc/%d/cmdline", pid);
535 g_file_get_contents(pid_path, &name, &len, NULL);
536 g_free(pid_path);
537#endif
538
539 return name;
540}
541
542
543pid_t qemu_fork(Error **errp)
544{
545 sigset_t oldmask, newmask;
546 struct sigaction sig_action;
547 int saved_errno;
548 pid_t pid;
549
550
551
552
553
554 sigfillset(&newmask);
555 if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) {
556 error_setg_errno(errp, errno,
557 "cannot block signals");
558 return -1;
559 }
560
561 pid = fork();
562 saved_errno = errno;
563
564 if (pid < 0) {
565
566
567 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
568 error_setg_errno(errp, saved_errno,
569 "cannot fork child process");
570 errno = saved_errno;
571 return -1;
572 } else if (pid) {
573
574
575
576
577
578
579 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
580 } else {
581
582 size_t i;
583
584
585
586
587 sig_action.sa_handler = SIG_DFL;
588 sig_action.sa_flags = 0;
589 sigemptyset(&sig_action.sa_mask);
590
591 for (i = 1; i < NSIG; i++) {
592
593
594
595 (void)sigaction(i, &sig_action, NULL);
596 }
597
598
599
600
601 sigemptyset(&newmask);
602 if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) {
603 Error *local_err = NULL;
604 error_setg_errno(&local_err, errno,
605 "cannot unblock signals");
606 error_report_err(local_err);
607 _exit(1);
608 }
609 }
610 return pid;
611}
612
613void *qemu_alloc_stack(size_t *sz)
614{
615 void *ptr, *guardpage;
616 int flags;
617#ifdef CONFIG_DEBUG_STACK_USAGE
618 void *ptr2;
619#endif
620 size_t pagesz = qemu_real_host_page_size;
621#ifdef _SC_THREAD_STACK_MIN
622
623 long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN);
624 *sz = MAX(MAX(min_stack_sz, 0), *sz);
625#endif
626
627 *sz = ROUND_UP(*sz, pagesz);
628
629 *sz += pagesz;
630
631 flags = MAP_PRIVATE | MAP_ANONYMOUS;
632#if defined(MAP_STACK) && defined(__OpenBSD__)
633
634
635
636
637
638
639 flags |= MAP_STACK;
640#endif
641
642 ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE, flags, -1, 0);
643 if (ptr == MAP_FAILED) {
644 perror("failed to allocate memory for stack");
645 abort();
646 }
647
648#if defined(HOST_IA64)
649
650 guardpage = ptr + (((*sz - pagesz) / 2) & ~pagesz);
651#elif defined(HOST_HPPA)
652
653 guardpage = ptr + *sz - pagesz;
654#else
655
656 guardpage = ptr;
657#endif
658 if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
659 perror("failed to set up stack guard page");
660 abort();
661 }
662
663#ifdef CONFIG_DEBUG_STACK_USAGE
664 for (ptr2 = ptr + pagesz; ptr2 < ptr + *sz; ptr2 += sizeof(uint32_t)) {
665 *(uint32_t *)ptr2 = 0xdeadbeaf;
666 }
667#endif
668
669 return ptr;
670}
671
672#ifdef CONFIG_DEBUG_STACK_USAGE
673static __thread unsigned int max_stack_usage;
674#endif
675
676void qemu_free_stack(void *stack, size_t sz)
677{
678#ifdef CONFIG_DEBUG_STACK_USAGE
679 unsigned int usage;
680 void *ptr;
681
682 for (ptr = stack + qemu_real_host_page_size; ptr < stack + sz;
683 ptr += sizeof(uint32_t)) {
684 if (*(uint32_t *)ptr != 0xdeadbeaf) {
685 break;
686 }
687 }
688 usage = sz - (uintptr_t) (ptr - stack);
689 if (usage > max_stack_usage) {
690 error_report("thread %d max stack usage increased from %u to %u",
691 qemu_get_thread_id(), max_stack_usage, usage);
692 max_stack_usage = usage;
693 }
694#endif
695
696 munmap(stack, sz);
697}
698
699void sigaction_invoke(struct sigaction *action,
700 struct qemu_signalfd_siginfo *info)
701{
702 siginfo_t si = {};
703 si.si_signo = info->ssi_signo;
704 si.si_errno = info->ssi_errno;
705 si.si_code = info->ssi_code;
706
707
708
709
710
711
712
713
714 if (info->ssi_code == SI_USER || info->ssi_code == SI_QUEUE ||
715 info->ssi_code <= 0) {
716
717 si.si_pid = info->ssi_pid;
718 si.si_uid = info->ssi_uid;
719 } else if (info->ssi_signo == SIGILL || info->ssi_signo == SIGFPE ||
720 info->ssi_signo == SIGSEGV || info->ssi_signo == SIGBUS) {
721 si.si_addr = (void *)(uintptr_t)info->ssi_addr;
722 } else if (info->ssi_signo == SIGCHLD) {
723 si.si_pid = info->ssi_pid;
724 si.si_status = info->ssi_status;
725 si.si_uid = info->ssi_uid;
726 }
727 action->sa_sigaction(info->ssi_signo, &si, NULL);
728}
729