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 #if defined(__linux__) && (defined(__x86_64__) || defined(__arm__))
  30    /* Use 2 MiB alignment so transparent hugepages can be used by KVM.
  31       Valgrind does not support alignments larger than 1 MiB,
  32       therefore we need special code which handles running on Valgrind. */
  33 #  define QEMU_VMALLOC_ALIGN (512 * 4096)
  34 #elif defined(__linux__) && defined(__s390x__)
  35    /* Use 1 MiB (segment size) alignment so gmap can be used by KVM. */
  36 #  define QEMU_VMALLOC_ALIGN (256 * 4096)
  37 #else
  38 #  define QEMU_VMALLOC_ALIGN getpagesize()
  39 #endif
  40
  41 #include "qemu/osdep.h"
  42 #include <termios.h>
  43 #include <termios.h>
  44
  45 #include <glib/gprintf.h>
  46
  47 #include "sysemu/sysemu.h"
  48 #include "trace.h"
  49 #include "qemu/sockets.h"
  50 #include <sys/mman.h>
  51 #include <libgen.h>
  52 #include <sys/signal.h>
  53
  54 #ifdef CONFIG_LINUX
  55 #include <sys/syscall.h>
  56 #endif
  57
  58 #ifdef __FreeBSD__
  59 #include <sys/sysctl.h>
  60 #endif
  61
  62 #include <qemu/mmap-alloc.h>
  63
  64 int qemu_get_thread_id(void)
  65 {
  66 #if defined(__linux__)
  67     return syscall(SYS_gettid);
  68 #else
  69     return getpid();
  70 #endif
  71 }
  72
  73 int qemu_daemon(int nochdir, int noclose)
  74 {
  75     return daemon(nochdir, noclose);
  76 }
  77
  78 void *qemu_oom_check(void *ptr)
  79 {
  80     if (ptr == NULL) {
  81         fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
  82         abort();
  83     }
  84     return ptr;
  85 }
  86
  87 void *qemu_try_memalign(size_t alignment, size_t size)
  88 {
  89     void *ptr;
  90
  91     if (alignment < sizeof(void*)) {
  92         alignment = sizeof(void*);
  93     }
  94
  95 #if defined(_POSIX_C_SOURCE) && !defined(__sun__)
  96     int ret;
  97     ret = posix_memalign(&ptr, alignment, size);
  98     if (ret != 0) {
  99         errno = ret;
 100         ptr = NULL;
 101     }
 102 #elif defined(CONFIG_BSD)
 103     ptr = valloc(size);
 104 #else
 105     ptr = memalign(alignment, size);
 106 #endif
 107     trace_qemu_memalign(alignment, size, ptr);
 108     return ptr;
 109 }
 110
 111 void *qemu_memalign(size_t alignment, size_t size)
 112 {
 113     return qemu_oom_check(qemu_try_memalign(alignment, size));
 114 }
 115
 116 /* alloc shared memory pages */
 117 void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment)
 118 {
 119     size_t align = QEMU_VMALLOC_ALIGN;
 120     void *ptr = qemu_ram_mmap(-1, size, align, false);
 121
 122     if (ptr == MAP_FAILED) {
 123         return NULL;
 124     }
 125
 126     if (alignment) {
 127         *alignment = align;
 128     }
 129
 130     trace_qemu_anon_ram_alloc(size, ptr);
 131     return ptr;
 132 }
 133
 134 void qemu_vfree(void *ptr)
 135 {
 136     trace_qemu_vfree(ptr);
 137     free(ptr);
 138 }
 139
 140 void qemu_anon_ram_free(void *ptr, size_t size)
 141 {
 142     trace_qemu_anon_ram_free(ptr, size);
 143     qemu_ram_munmap(ptr, size);
 144 }
 145
 146 void qemu_set_block(int fd)
 147 {
 148     int f;
 149     f = fcntl(fd, F_GETFL);
 150     fcntl(fd, F_SETFL, f & ~O_NONBLOCK);
 151 }
 152
 153 void qemu_set_nonblock(int fd)
 154 {
 155     int f;
 156     f = fcntl(fd, F_GETFL);
 157     fcntl(fd, F_SETFL, f | O_NONBLOCK);
 158 }
 159
 160 int socket_set_fast_reuse(int fd)
 161 {
 162     int val = 1, ret;
 163
 164     ret = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
 165                      (const char *)&val, sizeof(val));
 166
 167     assert(ret == 0);
 168
 169     return ret;
 170 }
 171
 172 void qemu_set_cloexec(int fd)
 173 {
 174     int f;
 175     f = fcntl(fd, F_GETFD);
 176     fcntl(fd, F_SETFD, f | FD_CLOEXEC);
 177 }
 178
 179 /*
 180  * Creates a pipe with FD_CLOEXEC set on both file descriptors
 181  */
 182 int qemu_pipe(int pipefd[2])
 183 {
 184     int ret;
 185
 186 #ifdef CONFIG_PIPE2
 187     ret = pipe2(pipefd, O_CLOEXEC);
 188     if (ret != -1 || errno != ENOSYS) {
 189         return ret;
 190     }
 191 #endif
 192     ret = pipe(pipefd);
 193     if (ret == 0) {
 194         qemu_set_cloexec(pipefd[0]);
 195         qemu_set_cloexec(pipefd[1]);
 196     }
 197
 198     return ret;
 199 }
 200
 201 int qemu_utimens(const char *path, const struct timespec *times)
 202 {
 203     struct timeval tv[2], tv_now;
 204     struct stat st;
 205     int i;
 206 #ifdef CONFIG_UTIMENSAT
 207     int ret;
 208
 209     ret = utimensat(AT_FDCWD, path, times, AT_SYMLINK_NOFOLLOW);
 210     if (ret != -1 || errno != ENOSYS) {
 211         return ret;
 212     }
 213 #endif
 214     /* Fallback: use utimes() instead of utimensat() */
 215
 216     /* happy if special cases */
 217     if (times[0].tv_nsec == UTIME_OMIT && times[1].tv_nsec == UTIME_OMIT) {
 218         return 0;
 219     }
 220     if (times[0].tv_nsec == UTIME_NOW && times[1].tv_nsec == UTIME_NOW) {
 221         return utimes(path, NULL);
 222     }
 223
 224     /* prepare for hard cases */
 225     if (times[0].tv_nsec == UTIME_NOW || times[1].tv_nsec == UTIME_NOW) {
 226         gettimeofday(&tv_now, NULL);
 227     }
 228     if (times[0].tv_nsec == UTIME_OMIT || times[1].tv_nsec == UTIME_OMIT) {
 229         stat(path, &st);
 230     }
 231
 232     for (i = 0; i < 2; i++) {
 233         if (times[i].tv_nsec == UTIME_NOW) {
 234             tv[i].tv_sec = tv_now.tv_sec;
 235             tv[i].tv_usec = tv_now.tv_usec;
 236         } else if (times[i].tv_nsec == UTIME_OMIT) {
 237             tv[i].tv_sec = (i == 0) ? st.st_atime : st.st_mtime;
 238             tv[i].tv_usec = 0;
 239         } else {
 240             tv[i].tv_sec = times[i].tv_sec;
 241             tv[i].tv_usec = times[i].tv_nsec / 1000;
 242         }
 243     }
 244
 245     return utimes(path, &tv[0]);
 246 }
 247
 248 char *
 249 qemu_get_local_state_pathname(const char *relative_pathname)
 250 {
 251     return g_strdup_printf("%s/%s", CONFIG_QEMU_LOCALSTATEDIR,
 252                            relative_pathname);
 253 }
 254
 255 void qemu_set_tty_echo(int fd, bool echo)
 256 {
 257     struct termios tty;
 258
 259     tcgetattr(fd, &tty);
 260
 261     if (echo) {
 262         tty.c_lflag |= ECHO | ECHONL | ICANON | IEXTEN;
 263     } else {
 264         tty.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN);
 265     }
 266
 267     tcsetattr(fd, TCSANOW, &tty);
 268 }
 269
 270 static char exec_dir[PATH_MAX];
 271
 272 void qemu_init_exec_dir(const char *argv0)
 273 {
 274     char *dir;
 275     char *p = NULL;
 276     char buf[PATH_MAX];
 277
 278     assert(!exec_dir[0]);
 279
 280 #if defined(__linux__)
 281     {
 282         int len;
 283         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
 284         if (len > 0) {
 285             buf[len] = 0;
 286             p = buf;
 287         }
 288     }
 289 #elif defined(__FreeBSD__)
 290     {
 291         static int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
 292         size_t len = sizeof(buf) - 1;
 293
 294         *buf = '\0';
 295         if (!sysctl(mib, ARRAY_SIZE(mib), buf, &len, NULL, 0) &&
 296             *buf) {
 297             buf[sizeof(buf) - 1] = '\0';
 298             p = buf;
 299         }
 300     }
 301 #endif
 302     /* If we don't have any way of figuring out the actual executable
 303        location then try argv[0].  */
 304     if (!p) {
 305         if (!argv0) {
 306             return;
 307         }
 308         p = realpath(argv0, buf);
 309         if (!p) {
 310             return;
 311         }
 312     }
 313     dir = dirname(p);
 314
 315     pstrcpy(exec_dir, sizeof(exec_dir), dir);
 316 }
 317
 318 char *qemu_get_exec_dir(void)
 319 {
 320     return g_strdup(exec_dir);
 321 }
 322
 323 static sigjmp_buf sigjump;
 324
 325 static void sigbus_handler(int signal)
 326 {
 327     siglongjmp(sigjump, 1);
 328 }
 329
 330 void os_mem_prealloc(int fd, char *area, size_t memory)
 331 {
 332     int ret;
 333     struct sigaction act, oldact;
 334     sigset_t set, oldset;
 335
 336     memset(&act, 0, sizeof(act));
 337     act.sa_handler = &sigbus_handler;
 338     act.sa_flags = 0;
 339
 340     ret = sigaction(SIGBUS, &act, &oldact);
 341     if (ret) {
 342         perror("os_mem_prealloc: failed to install signal handler");
 343         exit(1);
 344     }
 345
 346     /* unblock SIGBUS */
 347     sigemptyset(&set);
 348     sigaddset(&set, SIGBUS);
 349     pthread_sigmask(SIG_UNBLOCK, &set, &oldset);
 350
 351     if (sigsetjmp(sigjump, 1)) {
 352         fprintf(stderr, "os_mem_prealloc: Insufficient free host memory "
 353                         "pages available to allocate guest RAM\n");
 354         exit(1);
 355     } else {
 356         int i;
 357         size_t hpagesize = qemu_fd_getpagesize(fd);
 358         size_t numpages = DIV_ROUND_UP(memory, hpagesize);
 359
 360         /* MAP_POPULATE silently ignores failures */
 361         for (i = 0; i < numpages; i++) {
 362             memset(area + (hpagesize * i), 0, 1);
 363         }
 364
 365         ret = sigaction(SIGBUS, &oldact, NULL);
 366         if (ret) {
 367             perror("os_mem_prealloc: failed to reinstall signal handler");
 368             exit(1);
 369         }
 370
 371         pthread_sigmask(SIG_SETMASK, &oldset, NULL);
 372     }
 373 }
 374
 375
 376 static struct termios oldtty;
 377
 378 static void term_exit(void)
 379 {
 380     tcsetattr(0, TCSANOW, &oldtty);
 381 }
 382
 383 static void term_init(void)
 384 {
 385     struct termios tty;
 386
 387     tcgetattr(0, &tty);
 388     oldtty = tty;
 389
 390     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 391                           |INLCR|IGNCR|ICRNL|IXON);
 392     tty.c_oflag |= OPOST;
 393     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 394     tty.c_cflag &= ~(CSIZE|PARENB);
 395     tty.c_cflag |= CS8;
 396     tty.c_cc[VMIN] = 1;
 397     tty.c_cc[VTIME] = 0;
 398
 399     tcsetattr(0, TCSANOW, &tty);
 400
 401     atexit(term_exit);
 402 }
 403
 404 int qemu_read_password(char *buf, int buf_size)
 405 {
 406     uint8_t ch;
 407     int i, ret;
 408
 409     printf("password: ");
 410     fflush(stdout);
 411     term_init();
 412     i = 0;
 413     for (;;) {
 414         ret = read(0, &ch, 1);
 415         if (ret == -1) {
 416             if (errno == EAGAIN || errno == EINTR) {
 417                 continue;
 418             } else {
 419                 break;
 420             }
 421         } else if (ret == 0) {
 422             ret = -1;
 423             break;
 424         } else {
 425             if (ch == '\r' ||
 426                 ch == '\n') {
 427                 ret = 0;
 428                 break;
 429             }
 430             if (i < (buf_size - 1)) {
 431                 buf[i++] = ch;
 432             }
 433         }
 434     }
 435     term_exit();
 436     buf[i] = '\0';
 437     printf("\n");
 438     return ret;
 439 }
 440
 441
 442 pid_t qemu_fork(Error **errp)
 443 {
 444     sigset_t oldmask, newmask;
 445     struct sigaction sig_action;
 446     int saved_errno;
 447     pid_t pid;
 448
 449     /*
 450      * Need to block signals now, so that child process can safely
 451      * kill off caller's signal handlers without a race.
 452      */
 453     sigfillset(&newmask);
 454     if (pthread_sigmask(SIG_SETMASK, &newmask, &oldmask) != 0) {
 455         error_setg_errno(errp, errno,
 456                          "cannot block signals");
 457         return -1;
 458     }
 459
 460     pid = fork();
 461     saved_errno = errno;
 462
 463     if (pid < 0) {
 464         /* attempt to restore signal mask, but ignore failure, to
 465          * avoid obscuring the fork failure */
 466         (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
 467         error_setg_errno(errp, saved_errno,
 468                          "cannot fork child process");
 469         errno = saved_errno;
 470         return -1;
 471     } else if (pid) {
 472         /* parent process */
 473
 474         /* Restore our original signal mask now that the child is
 475          * safely running. Only documented failures are EFAULT (not
 476          * possible, since we are using just-grabbed mask) or EINVAL
 477          * (not possible, since we are using correct arguments).  */
 478         (void)pthread_sigmask(SIG_SETMASK, &oldmask, NULL);
 479     } else {
 480         /* child process */
 481         size_t i;
 482
 483         /* Clear out all signal handlers from parent so nothing
 484          * unexpected can happen in our child once we unblock
 485          * signals */
 486         sig_action.sa_handler = SIG_DFL;
 487         sig_action.sa_flags = 0;
 488         sigemptyset(&sig_action.sa_mask);
 489
 490         for (i = 1; i < NSIG; i++) {
 491             /* Only possible errors are EFAULT or EINVAL The former
 492              * won't happen, the latter we expect, so no need to check
 493              * return value */
 494             (void)sigaction(i, &sig_action, NULL);
 495         }
 496
 497         /* Unmask all signals in child, since we've no idea what the
 498          * caller's done with their signal mask and don't want to
 499          * propagate that to children */
 500         sigemptyset(&newmask);
 501         if (pthread_sigmask(SIG_SETMASK, &newmask, NULL) != 0) {
 502             Error *local_err = NULL;
 503             error_setg_errno(&local_err, errno,
 504                              "cannot unblock signals");
 505             error_report_err(local_err);
 506             _exit(1);
 507         }
 508     }
 509     return pid;
 510 }