mem-prealloc: optimize large guest startup
[qemu.git] / util / oslib-posix.c
1 /*
2 * os-posix-lib.c
3 *
4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2010 Red Hat, Inc.
6 *
7 * QEMU library functions on POSIX which are shared between QEMU and
8 * the QEMU tools.
9 *
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:
16 *
17 * The above copyright notice and this permission notice shall be included in
18 * all copies or substantial portions of the Software.
19 *
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
26 * THE SOFTWARE.
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
66 struct MemsetThread {
67 char *addr;
68 size_t numpages;
69 size_t hpagesize;
70 QemuThread pgthread;
71 sigjmp_buf env;
72 };
73 typedef struct MemsetThread MemsetThread;
74
75 static MemsetThread *memset_thread;
76 static int memset_num_threads;
77 static bool memset_thread_failed;
78
79 static QemuMutex page_mutex;
80 static QemuCond page_cond;
81 static bool threads_created_flag;
82
83 int qemu_get_thread_id(void)
84 {
85 #if defined(__linux__)
86 return syscall(SYS_gettid);
87 #else
88 return getpid();
89 #endif
90 }
91
92 int qemu_daemon(int nochdir, int noclose)
93 {
94 return daemon(nochdir, noclose);
95 }
96
97 bool qemu_write_pidfile(const char *path, Error **errp)
98 {
99 int fd;
100 char pidstr[32];
101
102 while (1) {
103 struct stat a, b;
104 struct flock lock = {
105 .l_type = F_WRLCK,
106 .l_whence = SEEK_SET,
107 .l_len = 0,
108 };
109
110 fd = qemu_open(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
111 if (fd == -1) {
112 error_setg_errno(errp, errno, "Cannot open pid file");
113 return false;
114 }
115
116 if (fstat(fd, &b) < 0) {
117 error_setg_errno(errp, errno, "Cannot stat file");
118 goto fail_close;
119 }
120
121 if (fcntl(fd, F_SETLK, &lock)) {
122 error_setg_errno(errp, errno, "Cannot lock pid file");
123 goto fail_close;
124 }
125
126 /*
127 * Now make sure the path we locked is the same one that now
128 * exists on the filesystem.
129 */
130 if (stat(path, &a) < 0) {
131 /*
132 * PID file disappeared, someone else must be racing with
133 * us, so try again.
134 */
135 close(fd);
136 continue;
137 }
138
139 if (a.st_ino == b.st_ino) {
140 break;
141 }
142
143 /*
144 * PID file was recreated, someone else must be racing with
145 * us, so try again.
146 */
147 close(fd);
148 }
149
150 if (ftruncate(fd, 0) < 0) {
151 error_setg_errno(errp, errno, "Failed to truncate pid file");
152 goto fail_unlink;
153 }
154
155 snprintf(pidstr, sizeof(pidstr), FMT_pid "\n", getpid());
156 if (write(fd, pidstr, strlen(pidstr)) != strlen(pidstr)) {
157 error_setg(errp, "Failed to write pid file");
158 goto fail_unlink;
159 }
160
161 return true;
162
163 fail_unlink:
164 unlink(path);
165 fail_close:
166 close(fd);
167 return false;
168 }
169
170 void *qemu_oom_check(void *ptr)
171 {
172 if (ptr == NULL) {
173 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
174 abort();
175 }
176 return ptr;
177 }
178
179 void *qemu_try_memalign(size_t alignment, size_t size)
180 {
181 void *ptr;
182
183 if (alignment < sizeof(void*)) {
184 alignment = sizeof(void*);
185 }
186
187 #if defined(CONFIG_POSIX_MEMALIGN)
188 int ret;
189 ret = posix_memalign(&ptr, alignment, size);
190 if (ret != 0) {
191 errno = ret;
192 ptr = NULL;
193 }
194 #elif defined(CONFIG_BSD)
195 ptr = valloc(size);
196 #else
197 ptr = memalign(alignment, size);
198 #endif
199 trace_qemu_memalign(alignment, size, ptr);
200 return ptr;
201 }
202
203 void *qemu_memalign(size_t alignment, size_t size)
204 {
205 return qemu_oom_check(qemu_try_memalign(alignment, size));
206 }
207
208 /* alloc shared memory pages */
209 void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment, bool shared)
210 {
211 size_t align = QEMU_VMALLOC_ALIGN;
212 void *ptr = qemu_ram_mmap(-1, size, align, shared, false);
213
214 if (ptr == MAP_FAILED) {
215 return NULL;
216 }
217
218 if (alignment) {
219 *alignment = align;
220 }
221
222 trace_qemu_anon_ram_alloc(size, ptr);
223 return ptr;
224 }
225
226 void qemu_vfree(void *ptr)
227 {
228 trace_qemu_vfree(ptr);
229 free(ptr);
230 }
231
232 void qemu_anon_ram_free(void *ptr, size_t size)
233 {
234 trace_qemu_anon_ram_free(ptr, size);
235 qemu_ram_munmap(-1, ptr, size);
236 }
237
238 void qemu_set_block(int fd)
239 {
240 int f;
241 f = fcntl(fd, F_GETFL);
242 assert(f != -1);
243 f = fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
244 assert(f != -1);
245 }
246
247 void qemu_set_nonblock(int fd)
248 {
249 int f;
250 f = fcntl(fd, F_GETFL);
251 assert(f != -1);
252 f = fcntl(fd, F_SETFL, f | O_NONBLOCK);
253 #ifdef __OpenBSD__
254 if (f == -1) {
255 /*
256 * Previous to OpenBSD 6.3, fcntl(F_SETFL) is not permitted on
257 * memory devices and sets errno to ENODEV.
258 * It's OK if we fail to set O_NONBLOCK on devices like /dev/null,
259 * because they will never block anyway.
260 */
261 assert(errno == ENODEV);
262 }
263 #else
264 assert(f != -1);
265 #endif
266 }
267
268 int socket_set_fast_reuse(int fd)
269 {
270 int val = 1, ret;
271
272 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
273 (const char *)&val, sizeof(val));
274
275 assert(ret == 0);
276
277 return ret;
278 }
279
280 void qemu_set_cloexec(int fd)
281 {
282 int f;
283 f = fcntl(fd, F_GETFD);
284 assert(f != -1);
285 f = fcntl(fd, F_SETFD, f | FD_CLOEXEC);
286 assert(f != -1);
287 }
288
289 /*
290 * Creates a pipe with FD_CLOEXEC set on both file descriptors
291 */
292 int qemu_pipe(int pipefd[2])
293 {
294 int ret;
295
296 #ifdef CONFIG_PIPE2
297 ret = pipe2(pipefd, O_CLOEXEC);
298 if (ret != -1 || errno != ENOSYS) {
299 return ret;
300 }
301 #endif
302 ret = pipe(pipefd);
303 if (ret == 0) {
304 qemu_set_cloexec(pipefd[0]);
305 qemu_set_cloexec(pipefd[1]);
306 }
307
308 return ret;
309 }
310
311 char *
312 qemu_get_local_state_pathname(const char *relative_pathname)
313 {
314 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR,
315 relative_pathname);
316 }
317
318 void qemu_set_tty_echo(int fd, bool echo)
319 {
320 struct termios tty;
321
322 tcgetattr(fd, &tty);
323
324 if (echo) {
325 tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN;
326 } else {
327 tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
328 }
329
330 tcsetattr(fd, TCSANOW, &tty);
331 }
332
333 static char exec_dir[PATH_MAX];
334
335 void qemu_init_exec_dir(const char *argv0)
336 {
337 char *dir;
338 char *p = NULL;
339 char buf[PATH_MAX];
340
341 assert(!exec_dir[0]);
342
343 #if defined(__linux__)
344 {
345 int len;
346 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
347 if (len > 0) {
348 buf[len] = 0;
349 p = buf;
350 }
351 }
352 #elif defined(__FreeBSD__) \
353 || (defined(__NetBSD__) && defined(KERN_PROC_PATHNAME))
354 {
355 #if defined(__FreeBSD__)
356 static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
357 #else
358 static int mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
359 #endif
360 size_t len = sizeof(buf) - 1;
361
362 *buf = '\0';
363 if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) &&
364 *buf) {
365 buf[sizeof(buf) - 1] = '\0';
366 p = buf;
367 }
368 }
369 #endif
370 /* If we don't have any way of figuring out the actual executable
371 location then try argv[0]. */
372 if (!p) {
373 if (!argv0) {
374 return;
375 }
376 p = realpath(argv0, buf);
377 if (!p) {
378 return;
379 }
380 }
381 dir = g_path_get_dirname(p);
382
383 pstrcpy(exec_dir, sizeof(exec_dir), dir);
384
385 g_free(dir);
386 }
387
388 char *qemu_get_exec_dir(void)
389 {
390 return g_strdup(exec_dir);
391 }
392
393 static void sigbus_handler(int signal)
394 {
395 int i;
396 if (memset_thread) {
397 for (i = 0; i < memset_num_threads; i++) {
398 if (qemu_thread_is_self(&memset_thread[i].pgthread)) {
399 siglongjmp(memset_thread[i].env, 1);
400 }
401 }
402 }
403 }
404
405 static void *do_touch_pages(void *arg)
406 {
407 MemsetThread *memset_args = (MemsetThread *)arg;
408 sigset_t set, oldset;
409
410 /*
411 * On Linux, the page faults from the loop below can cause mmap_sem
412 * contention with allocation of the thread stacks. Do not start
413 * clearing until all threads have been created.
414 */
415 qemu_mutex_lock(&page_mutex);
416 while(!threads_created_flag){
417 qemu_cond_wait(&page_cond, &page_mutex);
418 }
419 qemu_mutex_unlock(&page_mutex);
420
421 /* unblock SIGBUS */
422 sigemptyset(&set);
423 sigaddset(&set, SIGBUS);
424 pthread_sigmask(SIG_UNBLOCK, &set, &oldset);
425
426 if (sigsetjmp(memset_args->env, 1)) {
427 memset_thread_failed = true;
428 } else {
429 char *addr = memset_args->addr;
430 size_t numpages = memset_args->numpages;
431 size_t hpagesize = memset_args->hpagesize;
432 size_t i;
433 for (i = 0; i < numpages; i++) {
434 /*
435 * Read & write back the same value, so we don't
436 * corrupt existing user/app data that might be
437 * stored.
438 *
439 * 'volatile' to stop compiler optimizing this away
440 * to a no-op
441 *
442 * TODO: get a better solution from kernel so we
443 * don't need to write at all so we don't cause
444 * wear on the storage backing the region...
445 */
446 *(volatile char *)addr = *addr;
447 addr += hpagesize;
448 }
449 }
450 pthread_sigmask(SIG_SETMASK, &oldset, NULL);
451 return NULL;
452 }
453
454 static inline int get_memset_num_threads(int smp_cpus)
455 {
456 long host_procs = sysconf(_SC_NPROCESSORS_ONLN);
457 int ret = 1;
458
459 if (host_procs > 0) {
460 ret = MIN(MIN(host_procs, MAX_MEM_PREALLOC_THREAD_COUNT), smp_cpus);
461 }
462 /* In case sysconf() fails, we fall back to single threaded */
463 return ret;
464 }
465
466 static bool touch_all_pages(char *area, size_t hpagesize, size_t numpages,
467 int smp_cpus)
468 {
469 size_t numpages_per_thread, leftover;
470 char *addr = area;
471 int i = 0;
472
473 memset_thread_failed = false;
474 threads_created_flag = false;
475 memset_num_threads = get_memset_num_threads(smp_cpus);
476 memset_thread = g_new0(MemsetThread, memset_num_threads);
477 numpages_per_thread = numpages / memset_num_threads;
478 leftover = numpages % memset_num_threads;
479 for (i = 0; i < memset_num_threads; i++) {
480 memset_thread[i].addr = addr;
481 memset_thread[i].numpages = numpages_per_thread + (i < leftover);
482 memset_thread[i].hpagesize = hpagesize;
483 qemu_thread_create(&memset_thread[i].pgthread, "touch_pages",
484 do_touch_pages, &memset_thread[i],
485 QEMU_THREAD_JOINABLE);
486 addr += memset_thread[i].numpages * hpagesize;
487 }
488 threads_created_flag = true;
489 qemu_cond_broadcast(&page_cond);
490
491 for (i = 0; i < memset_num_threads; i++) {
492 qemu_thread_join(&memset_thread[i].pgthread);
493 }
494 g_free(memset_thread);
495 memset_thread = NULL;
496
497 return memset_thread_failed;
498 }
499
500 void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus,
501 Error **errp)
502 {
503 int ret;
504 struct sigaction act, oldact;
505 size_t hpagesize = qemu_fd_getpagesize(fd);
506 size_t numpages = DIV_ROUND_UP(memory, hpagesize);
507
508 memset(&act, 0, sizeof(act));
509 act.sa_handler = &sigbus_handler;
510 act.sa_flags = 0;
511
512 ret = sigaction(SIGBUS, &act, &oldact);
513 if (ret) {
514 error_setg_errno(errp, errno,
515 "os_mem_prealloc: failed to install signal handler");
516 return;
517 }
518
519 /* touch pages simultaneously */
520 if (touch_all_pages(area, hpagesize, numpages, smp_cpus)) {
521 error_setg(errp, "os_mem_prealloc: Insufficient free host memory "
522 "pages available to allocate guest RAM");
523 }
524
525 ret = sigaction(SIGBUS, &oldact, NULL);
526 if (ret) {
527 /* Terminate QEMU since it can't recover from error */
528 perror("os_mem_prealloc: failed to reinstall signal handler");
529 exit(1);
530 }
531 }
532
533 char *qemu_get_pid_name(pid_t pid)
534 {
535 char *name = NULL;
536
537 #if defined(__FreeBSD__)
538 /* BSDs don't have /proc, but they provide a nice substitute */
539 struct kinfo_proc *proc = kinfo_getproc(pid);
540
541 if (proc) {
542 name = g_strdup(proc->ki_comm);
543 free(proc);
544 }
545 #else
546 /* Assume a system with reasonable procfs */
547 char *pid_path;
548 size_t len;
549
550 pid_path = g_strdup_printf("/proc/%d/cmdline", pid);
551 g_file_get_contents(pid_path, &name, &len, NULL);
552 g_free(pid_path);
553 #endif
554
555 return name;
556 }
557
558
559 pid_t qemu_fork(Error **errp)
560 {
561 sigset_t oldmask, newmask;
562 struct sigaction sig_action;
563 int saved_errno;
564 pid_t pid;
565
566 /*
567 * Need to block signals now, so that child process can safely
568 * kill off caller's signal handlers without a race.
569 */
570 sigfillset(&newmask);
571 if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) {
572 error_setg_errno(errp, errno,
573 "cannot block signals");
574 return -1;
575 }
576
577 pid = fork();
578 saved_errno = errno;
579
580 if (pid < 0) {
581 /* attempt to restore signal mask, but ignore failure, to
582 * avoid obscuring the fork failure */
583 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
584 error_setg_errno(errp, saved_errno,
585 "cannot fork child process");
586 errno = saved_errno;
587 return -1;
588 } else if (pid) {
589 /* parent process */
590
591 /* Restore our original signal mask now that the child is
592 * safely running. Only documented failures are EFAULT (not
593 * possible, since we are using just-grabbed mask) or EINVAL
594 * (not possible, since we are using correct arguments). */
595 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
596 } else {
597 /* child process */
598 size_t i;
599
600 /* Clear out all signal handlers from parent so nothing
601 * unexpected can happen in our child once we unblock
602 * signals */
603 sig_action.sa_handler = SIG_DFL;
604 sig_action.sa_flags = 0;
605 sigemptyset(&sig_action.sa_mask);
606
607 for (i = 1; i < NSIG; i++) {
608 /* Only possible errors are EFAULT or EINVAL The former
609 * won't happen, the latter we expect, so no need to check
610 * return value */
611 (void)sigaction(i, &sig_action, NULL);
612 }
613
614 /* Unmask all signals in child, since we've no idea what the
615 * caller's done with their signal mask and don't want to
616 * propagate that to children */
617 sigemptyset(&newmask);
618 if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) {
619 Error *local_err = NULL;
620 error_setg_errno(&local_err, errno,
621 "cannot unblock signals");
622 error_report_err(local_err);
623 _exit(1);
624 }
625 }
626 return pid;
627 }
628
629 void *qemu_alloc_stack(size_t *sz)
630 {
631 void *ptr, *guardpage;
632 int flags;
633 #ifdef CONFIG_DEBUG_STACK_USAGE
634 void *ptr2;
635 #endif
636 size_t pagesz = qemu_real_host_page_size;
637 #ifdef _SC_THREAD_STACK_MIN
638 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
639 long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN);
640 *sz = MAX(MAX(min_stack_sz, 0), *sz);
641 #endif
642 /* adjust stack size to a multiple of the page size */
643 *sz = ROUND_UP(*sz, pagesz);
644 /* allocate one extra page for the guard page */
645 *sz += pagesz;
646
647 flags = MAP_PRIVATE | MAP_ANONYMOUS;
648 #if defined(MAP_STACK) && defined(__OpenBSD__)
649 /* Only enable MAP_STACK on OpenBSD. Other OS's such as
650 * Linux/FreeBSD/NetBSD have a flag with the same name
651 * but have differing functionality. OpenBSD will SEGV
652 * if it spots execution with a stack pointer pointing
653 * at memory that was not allocated with MAP_STACK.
654 */
655 flags |= MAP_STACK;
656 #endif
657
658 ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE, flags, -1, 0);
659 if (ptr == MAP_FAILED) {
660 perror("failed to allocate memory for stack");
661 abort();
662 }
663
664 #if defined(HOST_IA64)
665 /* separate register stack */
666 guardpage = ptr + (((*sz - pagesz) / 2) & ~pagesz);
667 #elif defined(HOST_HPPA)
668 /* stack grows up */
669 guardpage = ptr + *sz - pagesz;
670 #else
671 /* stack grows down */
672 guardpage = ptr;
673 #endif
674 if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
675 perror("failed to set up stack guard page");
676 abort();
677 }
678
679 #ifdef CONFIG_DEBUG_STACK_USAGE
680 for (ptr2 = ptr + pagesz; ptr2 < ptr + *sz; ptr2 += sizeof(uint32_t)) {
681 *(uint32_t *)ptr2 = 0xdeadbeaf;
682 }
683 #endif
684
685 return ptr;
686 }
687
688 #ifdef CONFIG_DEBUG_STACK_USAGE
689 static __thread unsigned int max_stack_usage;
690 #endif
691
692 void qemu_free_stack(void *stack, size_t sz)
693 {
694 #ifdef CONFIG_DEBUG_STACK_USAGE
695 unsigned int usage;
696 void *ptr;
697
698 for (ptr = stack + qemu_real_host_page_size; ptr < stack + sz;
699 ptr += sizeof(uint32_t)) {
700 if (*(uint32_t *)ptr != 0xdeadbeaf) {
701 break;
702 }
703 }
704 usage = sz - (uintptr_t) (ptr - stack);
705 if (usage > max_stack_usage) {
706 error_report("thread %d max stack usage increased from %u to %u",
707 qemu_get_thread_id(), max_stack_usage, usage);
708 max_stack_usage = usage;
709 }
710 #endif
711
712 munmap(stack, sz);
713 }
714
715 void sigaction_invoke(struct sigaction *action,
716 struct qemu_signalfd_siginfo *info)
717 {
718 siginfo_t si = {};
719 si.si_signo = info->ssi_signo;
720 si.si_errno = info->ssi_errno;
721 si.si_code = info->ssi_code;
722
723 /* Convert the minimal set of fields defined by POSIX.
724 * Positive si_code values are reserved for kernel-generated
725 * signals, where the valid siginfo fields are determined by
726 * the signal number. But according to POSIX, it is unspecified
727 * whether SI_USER and SI_QUEUE have values less than or equal to
728 * zero.
729 */
730 if (info->ssi_code == SI_USER || info->ssi_code == SI_QUEUE ||
731 info->ssi_code <= 0) {
732 /* SIGTERM, etc. */
733 si.si_pid = info->ssi_pid;
734 si.si_uid = info->ssi_uid;
735 } else if (info->ssi_signo == SIGILL || info->ssi_signo == SIGFPE ||
736 info->ssi_signo == SIGSEGV || info->ssi_signo == SIGBUS) {
737 si.si_addr = (void *)(uintptr_t)info->ssi_addr;
738 } else if (info->ssi_signo == SIGCHLD) {
739 si.si_pid = info->ssi_pid;
740 si.si_status = info->ssi_status;
741 si.si_uid = info->ssi_uid;
742 }
743 action->sa_sigaction(info->ssi_signo, &si, NULL);
744 }