ppc/pnv: Add support for POWER8+ LPC Controller
[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 "sysemu/sysemu.h"
35 #include "trace.h"
36 #include "qapi/error.h"
37 #include "qemu/sockets.h"
38 #include <libgen.h>
39 #include <sys/signal.h>
40 #include "qemu/cutils.h"
41
42 #ifdef CONFIG_LINUX
43 #include <sys/syscall.h>
44 #endif
45
46 #ifdef __FreeBSD__
47 #include <sys/sysctl.h>
48 #include <sys/user.h>
49 #include <libutil.h>
50 #endif
51
52 #include "qemu/mmap-alloc.h"
53
54 #ifdef CONFIG_DEBUG_STACK_USAGE
55 #include "qemu/error-report.h"
56 #endif
57
58 #define MAX_MEM_PREALLOC_THREAD_COUNT 16
59
60 struct MemsetThread {
61 char *addr;
62 uint64_t numpages;
63 uint64_t hpagesize;
64 QemuThread pgthread;
65 sigjmp_buf env;
66 };
67 typedef struct MemsetThread MemsetThread;
68
69 static MemsetThread *memset_thread;
70 static int memset_num_threads;
71 static bool memset_thread_failed;
72
73 int qemu_get_thread_id(void)
74 {
75 #if defined(__linux__)
76 return syscall(SYS_gettid);
77 #else
78 return getpid();
79 #endif
80 }
81
82 int qemu_daemon(int nochdir, int noclose)
83 {
84 return daemon(nochdir, noclose);
85 }
86
87 void *qemu_oom_check(void *ptr)
88 {
89 if (ptr == NULL) {
90 fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
91 abort();
92 }
93 return ptr;
94 }
95
96 void *qemu_try_memalign(size_t alignment, size_t size)
97 {
98 void *ptr;
99
100 if (alignment < sizeof(void*)) {
101 alignment = sizeof(void*);
102 }
103
104 #if defined(_POSIX_C_SOURCE) && !defined(__sun__)
105 int ret;
106 ret = posix_memalign(&ptr, alignment, size);
107 if (ret != 0) {
108 errno = ret;
109 ptr = NULL;
110 }
111 #elif defined(CONFIG_BSD)
112 ptr = valloc(size);
113 #else
114 ptr = memalign(alignment, size);
115 #endif
116 trace_qemu_memalign(alignment, size, ptr);
117 return ptr;
118 }
119
120 void *qemu_memalign(size_t alignment, size_t size)
121 {
122 return qemu_oom_check(qemu_try_memalign(alignment, size));
123 }
124
125 /* alloc shared memory pages */
126 void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment)
127 {
128 size_t align = QEMU_VMALLOC_ALIGN;
129 void *ptr = qemu_ram_mmap(-1, size, align, false);
130
131 if (ptr == MAP_FAILED) {
132 return NULL;
133 }
134
135 if (alignment) {
136 *alignment = align;
137 }
138
139 trace_qemu_anon_ram_alloc(size, ptr);
140 return ptr;
141 }
142
143 void qemu_vfree(void *ptr)
144 {
145 trace_qemu_vfree(ptr);
146 free(ptr);
147 }
148
149 void qemu_anon_ram_free(void *ptr, size_t size)
150 {
151 trace_qemu_anon_ram_free(ptr, size);
152 qemu_ram_munmap(ptr, size);
153 }
154
155 void qemu_set_block(int fd)
156 {
157 int f;
158 f = fcntl(fd, F_GETFL);
159 fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
160 }
161
162 void qemu_set_nonblock(int fd)
163 {
164 int f;
165 f = fcntl(fd, F_GETFL);
166 fcntl(fd, F_SETFL, f | O_NONBLOCK);
167 }
168
169 int socket_set_fast_reuse(int fd)
170 {
171 int val = 1, ret;
172
173 ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
174 (const char *)&val, sizeof(val));
175
176 assert(ret == 0);
177
178 return ret;
179 }
180
181 void qemu_set_cloexec(int fd)
182 {
183 int f;
184 f = fcntl(fd, F_GETFD);
185 fcntl(fd, F_SETFD, f | FD_CLOEXEC);
186 }
187
188 /*
189 * Creates a pipe with FD_CLOEXEC set on both file descriptors
190 */
191 int qemu_pipe(int pipefd[2])
192 {
193 int ret;
194
195 #ifdef CONFIG_PIPE2
196 ret = pipe2(pipefd, O_CLOEXEC);
197 if (ret != -1 || errno != ENOSYS) {
198 return ret;
199 }
200 #endif
201 ret = pipe(pipefd);
202 if (ret == 0) {
203 qemu_set_cloexec(pipefd[0]);
204 qemu_set_cloexec(pipefd[1]);
205 }
206
207 return ret;
208 }
209
210 int qemu_utimens(const char *path, const struct timespec *times)
211 {
212 struct timeval tv[2], tv_now;
213 struct stat st;
214 int i;
215 #ifdef CONFIG_UTIMENSAT
216 int ret;
217
218 ret = utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW);
219 if (ret != -1 || errno != ENOSYS) {
220 return ret;
221 }
222 #endif
223 /* Fallback: use utimes() instead of utimensat() */
224
225 /* happy if special cases */
226 if (times[0].tv_nsec == UTIME_OMIT && times[1].tv_nsec == UTIME_OMIT) {
227 return 0;
228 }
229 if (times[0].tv_nsec == UTIME_NOW && times[1].tv_nsec == UTIME_NOW) {
230 return utimes(path, NULL);
231 }
232
233 /* prepare for hard cases */
234 if (times[0].tv_nsec == UTIME_NOW || times[1].tv_nsec == UTIME_NOW) {
235 gettimeofday(&tv_now, NULL);
236 }
237 if (times[0].tv_nsec == UTIME_OMIT || times[1].tv_nsec == UTIME_OMIT) {
238 stat(path, &st);
239 }
240
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;
247 tv[i].tv_usec = 0;
248 } else {
249 tv[i].tv_sec = times[i].tv_sec;
250 tv[i].tv_usec = times[i].tv_nsec / 1000;
251 }
252 }
253
254 return utimes(path, &tv[0]);
255 }
256
257 char *
258 qemu_get_local_state_pathname(const char *relative_pathname)
259 {
260 return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR,
261 relative_pathname);
262 }
263
264 void qemu_set_tty_echo(int fd, bool echo)
265 {
266 struct termios tty;
267
268 tcgetattr(fd, &tty);
269
270 if (echo) {
271 tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN;
272 } else {
273 tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
274 }
275
276 tcsetattr(fd, TCSANOW, &tty);
277 }
278
279 static char exec_dir[PATH_MAX];
280
281 void qemu_init_exec_dir(const char *argv0)
282 {
283 char *dir;
284 char *p = NULL;
285 char buf[PATH_MAX];
286
287 assert(!exec_dir[0]);
288
289 #if defined(__linux__)
290 {
291 int len;
292 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
293 if (len > 0) {
294 buf[len] = 0;
295 p = buf;
296 }
297 }
298 #elif defined(__FreeBSD__)
299 {
300 static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
301 size_t len = sizeof(buf) - 1;
302
303 *buf = '\0';
304 if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) &&
305 *buf) {
306 buf[sizeof(buf) - 1] = '\0';
307 p = buf;
308 }
309 }
310 #endif
311 /* If we don't have any way of figuring out the actual executable
312 location then try argv[0]. */
313 if (!p) {
314 if (!argv0) {
315 return;
316 }
317 p = realpath(argv0, buf);
318 if (!p) {
319 return;
320 }
321 }
322 dir = g_path_get_dirname(p);
323
324 pstrcpy(exec_dir, sizeof(exec_dir), dir);
325
326 g_free(dir);
327 }
328
329 char *qemu_get_exec_dir(void)
330 {
331 return g_strdup(exec_dir);
332 }
333
334 static void sigbus_handler(int signal)
335 {
336 int i;
337 if (memset_thread) {
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);
341 }
342 }
343 }
344 }
345
346 static void *do_touch_pages(void *arg)
347 {
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;
353 int i = 0;
354
355 /* unblock SIGBUS */
356 sigemptyset(&set);
357 sigaddset(&set, SIGBUS);
358 pthread_sigmask(SIG_UNBLOCK, &set, &oldset);
359
360 if (sigsetjmp(memset_args->env, 1)) {
361 memset_thread_failed = true;
362 } else {
363 for (i = 0; i < numpages; i++) {
364 /*
365 * Read & write back the same value, so we don't
366 * corrupt existing user/app data that might be
367 * stored.
368 *
369 * 'volatile' to stop compiler optimizing this away
370 * to a no-op
371 *
372 * TODO: get a better solution from kernel so we
373 * don't need to write at all so we don't cause
374 * wear on the storage backing the region...
375 */
376 *(volatile char *)addr = *addr;
377 addr += hpagesize;
378 }
379 }
380 pthread_sigmask(SIG_SETMASK, &oldset, NULL);
381 return NULL;
382 }
383
384 static inline int get_memset_num_threads(int smp_cpus)
385 {
386 long host_procs = sysconf(_SC_NPROCESSORS_ONLN);
387 int ret = 1;
388
389 if (host_procs > 0) {
390 ret = MIN(MIN(host_procs, MAX_MEM_PREALLOC_THREAD_COUNT), smp_cpus);
391 }
392 /* In case sysconf() fails, we fall back to single threaded */
393 return ret;
394 }
395
396 static bool touch_all_pages(char *area, size_t hpagesize, size_t numpages,
397 int smp_cpus)
398 {
399 uint64_t numpages_per_thread, size_per_thread;
400 char *addr = area;
401 int i = 0;
402
403 memset_thread_failed = false;
404 memset_num_threads = get_memset_num_threads(smp_cpus);
405 memset_thread = g_new0(MemsetThread, memset_num_threads);
406 numpages_per_thread = (numpages / memset_num_threads);
407 size_per_thread = (hpagesize * numpages_per_thread);
408 for (i = 0; i < memset_num_threads; i++) {
409 memset_thread[i].addr = addr;
410 memset_thread[i].numpages = (i == (memset_num_threads - 1)) ?
411 numpages : numpages_per_thread;
412 memset_thread[i].hpagesize = hpagesize;
413 qemu_thread_create(&memset_thread[i].pgthread, "touch_pages",
414 do_touch_pages, &memset_thread[i],
415 QEMU_THREAD_JOINABLE);
416 addr += size_per_thread;
417 numpages -= numpages_per_thread;
418 }
419 for (i = 0; i < memset_num_threads; i++) {
420 qemu_thread_join(&memset_thread[i].pgthread);
421 }
422 g_free(memset_thread);
423 memset_thread = NULL;
424
425 return memset_thread_failed;
426 }
427
428 void os_mem_prealloc(int fd, char *area, size_t memory, int smp_cpus,
429 Error **errp)
430 {
431 int ret;
432 struct sigaction act, oldact;
433 size_t hpagesize = qemu_fd_getpagesize(fd);
434 size_t numpages = DIV_ROUND_UP(memory, hpagesize);
435
436 memset(&act, 0, sizeof(act));
437 act.sa_handler = &sigbus_handler;
438 act.sa_flags = 0;
439
440 ret = sigaction(SIGBUS, &act, &oldact);
441 if (ret) {
442 error_setg_errno(errp, errno,
443 "os_mem_prealloc: failed to install signal handler");
444 return;
445 }
446
447 /* touch pages simultaneously */
448 if (touch_all_pages(area, hpagesize, numpages, smp_cpus)) {
449 error_setg(errp, "os_mem_prealloc: Insufficient free host memory "
450 "pages available to allocate guest RAM\n");
451 }
452
453 ret = sigaction(SIGBUS, &oldact, NULL);
454 if (ret) {
455 /* Terminate QEMU since it can't recover from error */
456 perror("os_mem_prealloc: failed to reinstall signal handler");
457 exit(1);
458 }
459 }
460
461
462 static struct termios oldtty;
463
464 static void term_exit(void)
465 {
466 tcsetattr(0, TCSANOW, &oldtty);
467 }
468
469 static void term_init(void)
470 {
471 struct termios tty;
472
473 tcgetattr(0, &tty);
474 oldtty = tty;
475
476 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
477 |INLCR|IGNCR|ICRNL|IXON);
478 tty.c_oflag |= OPOST;
479 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
480 tty.c_cflag &= ~(CSIZE|PARENB);
481 tty.c_cflag |= CS8;
482 tty.c_cc[VMIN] = 1;
483 tty.c_cc[VTIME] = 0;
484
485 tcsetattr(0, TCSANOW, &tty);
486
487 atexit(term_exit);
488 }
489
490 int qemu_read_password(char *buf, int buf_size)
491 {
492 uint8_t ch;
493 int i, ret;
494
495 printf("password: ");
496 fflush(stdout);
497 term_init();
498 i = 0;
499 for (;;) {
500 ret = read(0, &ch, 1);
501 if (ret == -1) {
502 if (errno == EAGAIN || errno == EINTR) {
503 continue;
504 } else {
505 break;
506 }
507 } else if (ret == 0) {
508 ret = -1;
509 break;
510 } else {
511 if (ch == '\r' ||
512 ch == '\n') {
513 ret = 0;
514 break;
515 }
516 if (i < (buf_size - 1)) {
517 buf[i++] = ch;
518 }
519 }
520 }
521 term_exit();
522 buf[i] = '\0';
523 printf("\n");
524 return ret;
525 }
526
527
528 char *qemu_get_pid_name(pid_t pid)
529 {
530 char *name = NULL;
531
532 #if defined(__FreeBSD__)
533 /* BSDs don't have /proc, but they provide a nice substitute */
534 struct kinfo_proc *proc = kinfo_getproc(pid);
535
536 if (proc) {
537 name = g_strdup(proc->ki_comm);
538 free(proc);
539 }
540 #else
541 /* Assume a system with reasonable procfs */
542 char *pid_path;
543 size_t len;
544
545 pid_path = g_strdup_printf("/proc/%d/cmdline", pid);
546 g_file_get_contents(pid_path, &name, &len, NULL);
547 g_free(pid_path);
548 #endif
549
550 return name;
551 }
552
553
554 pid_t qemu_fork(Error **errp)
555 {
556 sigset_t oldmask, newmask;
557 struct sigaction sig_action;
558 int saved_errno;
559 pid_t pid;
560
561 /*
562 * Need to block signals now, so that child process can safely
563 * kill off caller's signal handlers without a race.
564 */
565 sigfillset(&newmask);
566 if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) {
567 error_setg_errno(errp, errno,
568 "cannot block signals");
569 return -1;
570 }
571
572 pid = fork();
573 saved_errno = errno;
574
575 if (pid < 0) {
576 /* attempt to restore signal mask, but ignore failure, to
577 * avoid obscuring the fork failure */
578 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
579 error_setg_errno(errp, saved_errno,
580 "cannot fork child process");
581 errno = saved_errno;
582 return -1;
583 } else if (pid) {
584 /* parent process */
585
586 /* Restore our original signal mask now that the child is
587 * safely running. Only documented failures are EFAULT (not
588 * possible, since we are using just-grabbed mask) or EINVAL
589 * (not possible, since we are using correct arguments). */
590 (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
591 } else {
592 /* child process */
593 size_t i;
594
595 /* Clear out all signal handlers from parent so nothing
596 * unexpected can happen in our child once we unblock
597 * signals */
598 sig_action.sa_handler = SIG_DFL;
599 sig_action.sa_flags = 0;
600 sigemptyset(&sig_action.sa_mask);
601
602 for (i = 1; i < NSIG; i++) {
603 /* Only possible errors are EFAULT or EINVAL The former
604 * won't happen, the latter we expect, so no need to check
605 * return value */
606 (void)sigaction(i, &sig_action, NULL);
607 }
608
609 /* Unmask all signals in child, since we've no idea what the
610 * caller's done with their signal mask and don't want to
611 * propagate that to children */
612 sigemptyset(&newmask);
613 if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) {
614 Error *local_err = NULL;
615 error_setg_errno(&local_err, errno,
616 "cannot unblock signals");
617 error_report_err(local_err);
618 _exit(1);
619 }
620 }
621 return pid;
622 }
623
624 void *qemu_alloc_stack(size_t *sz)
625 {
626 void *ptr, *guardpage;
627 #ifdef CONFIG_DEBUG_STACK_USAGE
628 void *ptr2;
629 #endif
630 size_t pagesz = getpagesize();
631 #ifdef _SC_THREAD_STACK_MIN
632 /* avoid stacks smaller than _SC_THREAD_STACK_MIN */
633 long min_stack_sz = sysconf(_SC_THREAD_STACK_MIN);
634 *sz = MAX(MAX(min_stack_sz, 0), *sz);
635 #endif
636 /* adjust stack size to a multiple of the page size */
637 *sz = ROUND_UP(*sz, pagesz);
638 /* allocate one extra page for the guard page */
639 *sz += pagesz;
640
641 ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
642 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
643 if (ptr == MAP_FAILED) {
644 abort();
645 }
646
647 #if defined(HOST_IA64)
648 /* separate register stack */
649 guardpage = ptr + (((*sz - pagesz) / 2) & ~pagesz);
650 #elif defined(HOST_HPPA)
651 /* stack grows up */
652 guardpage = ptr + *sz - pagesz;
653 #else
654 /* stack grows down */
655 guardpage = ptr;
656 #endif
657 if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
658 abort();
659 }
660
661 #ifdef CONFIG_DEBUG_STACK_USAGE
662 for (ptr2 = ptr + pagesz; ptr2 < ptr + *sz; ptr2 += sizeof(uint32_t)) {
663 *(uint32_t *)ptr2 = 0xdeadbeaf;
664 }
665 #endif
666
667 return ptr;
668 }
669
670 #ifdef CONFIG_DEBUG_STACK_USAGE
671 static __thread unsigned int max_stack_usage;
672 #endif
673
674 void qemu_free_stack(void *stack, size_t sz)
675 {
676 #ifdef CONFIG_DEBUG_STACK_USAGE
677 unsigned int usage;
678 void *ptr;
679
680 for (ptr = stack + getpagesize(); ptr < stack + sz;
681 ptr += sizeof(uint32_t)) {
682 if (*(uint32_t *)ptr != 0xdeadbeaf) {
683 break;
684 }
685 }
686 usage = sz - (uintptr_t) (ptr - stack);
687 if (usage > max_stack_usage) {
688 error_report("thread %d max stack usage increased from %u to %u",
689 qemu_get_thread_id(), max_stack_usage, usage);
690 max_stack_usage = usage;
691 }
692 #endif
693
694 munmap(stack, sz);
695 }
696
697 void sigaction_invoke(struct sigaction *action,
698 struct qemu_signalfd_siginfo *info)
699 {
700 siginfo_t si = { 0 };
701 si.si_signo = info->ssi_signo;
702 si.si_errno = info->ssi_errno;
703 si.si_code = info->ssi_code;
704
705 /* Convert the minimal set of fields defined by POSIX.
706 * Positive si_code values are reserved for kernel-generated
707 * signals, where the valid siginfo fields are determined by
708 * the signal number. But according to POSIX, it is unspecified
709 * whether SI_USER and SI_QUEUE have values less than or equal to
710 * zero.
711 */
712 if (info->ssi_code == SI_USER || info->ssi_code == SI_QUEUE ||
713 info->ssi_code <= 0) {
714 /* SIGTERM, etc. */
715 si.si_pid = info->ssi_pid;
716 si.si_uid = info->ssi_uid;
717 } else if (info->ssi_signo == SIGILL || info->ssi_signo == SIGFPE ||
718 info->ssi_signo == SIGSEGV || info->ssi_signo == SIGBUS) {
719 si.si_addr = (void *)(uintptr_t)info->ssi_addr;
720 } else if (info->ssi_signo == SIGCHLD) {
721 si.si_pid = info->ssi_pid;
722 si.si_status = info->ssi_status;
723 si.si_uid = info->ssi_uid;
724 }
725 action->sa_sigaction(info->ssi_signo, &si, NULL);
726 }