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