LXR qemu/os-posix.c

   1/*
   2 * os-posix.c
   3 *
   4 * Copyright (c) 2003-2008 Fabrice Bellard
   5 * Copyright (c) 2010 Red Hat, Inc.
   6 *
   7 * Permission is hereby granted, free of charge, to any person obtaining a copy
   8 * of this software and associated documentation files (the "Software"), to deal
   9 * in the Software without restriction, including without limitation the rights
  10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11 * copies of the Software, and to permit persons to whom the Software is
  12 * furnished to do so, subject to the following conditions:
  13 *
  14 * The above copyright notice and this permission notice shall be included in
  15 * all copies or substantial portions of the Software.
  16 *
  17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23 * THE SOFTWARE.
  24 */
  25
  26#include "qemu/osdep.h"
  27#include <sys/wait.h>
  28#include <pwd.h>
  29#include <grp.h>
  30#include <libgen.h>
  31
  32#include "qemu-common.h"
  33/* Needed early for CONFIG_BSD etc. */
  34#include "sysemu/sysemu.h"
  35#include "net/slirp.h"
  36#include "qemu-options.h"
  37#include "qemu/error-report.h"
  38#include "qemu/log.h"
  39#include "qemu/cutils.h"
  40
  41#ifdef CONFIG_LINUX
  42#include <sys/prctl.h>
  43#endif
  44
  45/*
  46 * Must set all three of these at once.
  47 * Legal combinations are              unset   by name   by uid
  48 */
  49static struct passwd *user_pwd;    /*   NULL   non-NULL   NULL   */
  50static uid_t user_uid = (uid_t)-1; /*   -1      -1        >=0    */
  51static gid_t user_gid = (gid_t)-1; /*   -1      -1        >=0    */
  52
  53static const char *chroot_dir;
  54static int daemonize;
  55static int daemon_pipe;
  56
  57void os_setup_early_signal_handling(void)
  58{
  59    struct sigaction act;
  60    sigfillset(&act.sa_mask);
  61    act.sa_flags = 0;
  62    act.sa_handler = SIG_IGN;
  63    sigaction(SIGPIPE, &act, NULL);
  64}
  65
  66static void termsig_handler(int signal, siginfo_t *info, void *c)
  67{
  68    qemu_system_killed(info->si_signo, info->si_pid);
  69}
  70
  71void os_setup_signal_handling(void)
  72{
  73    struct sigaction act;
  74
  75    memset(&act, 0, sizeof(act));
  76    act.sa_sigaction = termsig_handler;
  77    act.sa_flags = SA_SIGINFO;
  78    sigaction(SIGINT,  &act, NULL);
  79    sigaction(SIGHUP,  &act, NULL);
  80    sigaction(SIGTERM, &act, NULL);
  81}
  82
  83/* Find a likely location for support files using the location of the binary.
  84   For installed binaries this will be "$bindir/../share/qemu".  When
  85   running from the build tree this will be "$bindir/../pc-bios".  */
  86#define SHARE_SUFFIX "/share/qemu"
  87#define BUILD_SUFFIX "/pc-bios"
  88char *os_find_datadir(void)
  89{
  90    char *dir, *exec_dir;
  91    char *res;
  92    size_t max_len;
  93
  94    exec_dir = qemu_get_exec_dir();
  95    if (exec_dir == NULL) {
  96        return NULL;
  97    }
  98    dir = g_path_get_dirname(exec_dir);
  99
 100    max_len = strlen(dir) +
 101        MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
 102    res = g_malloc0(max_len);
 103    snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
 104    if (access(res, R_OK)) {
 105        snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
 106        if (access(res, R_OK)) {
 107            g_free(res);
 108            res = NULL;
 109        }
 110    }
 111
 112    g_free(dir);
 113    g_free(exec_dir);
 114    return res;
 115}
 116#undef SHARE_SUFFIX
 117#undef BUILD_SUFFIX
 118
 119void os_set_proc_name(const char *s)
 120{
 121#if defined(PR_SET_NAME)
 122    char name[16];
 123    if (!s)
 124        return;
 125    pstrcpy(name, sizeof(name), s);
 126    /* Could rewrite argv[0] too, but that's a bit more complicated.
 127       This simple way is enough for `top'. */
 128    if (prctl(PR_SET_NAME, name)) {
 129        error_report("unable to change process name: %s", strerror(errno));
 130        exit(1);
 131    }
 132#else
 133    error_report("Change of process name not supported by your OS");
 134    exit(1);
 135#endif
 136}
 137
 138
 139static bool os_parse_runas_uid_gid(const char *optarg)
 140{
 141    unsigned long lv;
 142    const char *ep;
 143    uid_t got_uid;
 144    gid_t got_gid;
 145    int rc;
 146
 147    rc = qemu_strtoul(optarg, &ep, 0, &lv);
 148    got_uid = lv; /* overflow here is ID in C99 */
 149    if (rc || *ep != ':' || got_uid != lv || got_uid == (uid_t)-1) {
 150        return false;
 151    }
 152
 153    rc = qemu_strtoul(ep + 1, 0, 0, &lv);
 154    got_gid = lv; /* overflow here is ID in C99 */
 155    if (rc || got_gid != lv || got_gid == (gid_t)-1) {
 156        return false;
 157    }
 158
 159    user_pwd = NULL;
 160    user_uid = got_uid;
 161    user_gid = got_gid;
 162    return true;
 163}
 164
 165/*
 166 * Parse OS specific command line options.
 167 * return 0 if option handled, -1 otherwise
 168 */
 169int os_parse_cmd_args(int index, const char *optarg)
 170{
 171    switch (index) {
 172    case QEMU_OPTION_runas:
 173        user_pwd = getpwnam(optarg);
 174        if (user_pwd) {
 175            user_uid = -1;
 176            user_gid = -1;
 177        } else if (!os_parse_runas_uid_gid(optarg)) {
 178            error_report("User \"%s\" doesn't exist"
 179                         " (and is not <uid>:<gid>)",
 180                         optarg);
 181            exit(1);
 182        }
 183        break;
 184    case QEMU_OPTION_chroot:
 185        chroot_dir = optarg;
 186        break;
 187    case QEMU_OPTION_daemonize:
 188        daemonize = 1;
 189        break;
 190#if defined(CONFIG_LINUX)
 191    case QEMU_OPTION_enablefips:
 192        fips_set_state(true);
 193        break;
 194#endif
 195    default:
 196        return -1;
 197    }
 198
 199    return 0;
 200}
 201
 202static void change_process_uid(void)
 203{
 204    assert((user_uid == (uid_t)-1) || user_pwd == NULL);
 205    assert((user_uid == (uid_t)-1) ==
 206           (user_gid == (gid_t)-1));
 207
 208    if (user_pwd || user_uid != (uid_t)-1) {
 209        gid_t intended_gid = user_pwd ? user_pwd->pw_gid : user_gid;
 210        uid_t intended_uid = user_pwd ? user_pwd->pw_uid : user_uid;
 211        if (setgid(intended_gid) < 0) {
 212            error_report("Failed to setgid(%d)", intended_gid);
 213            exit(1);
 214        }
 215        if (user_pwd) {
 216            if (initgroups(user_pwd->pw_name, user_pwd->pw_gid) < 0) {
 217                error_report("Failed to initgroups(\"%s\", %d)",
 218                        user_pwd->pw_name, user_pwd->pw_gid);
 219                exit(1);
 220            }
 221        } else {
 222            if (setgroups(1, &user_gid) < 0) {
 223                error_report("Failed to setgroups(1, [%d])",
 224                        user_gid);
 225                exit(1);
 226            }
 227        }
 228        if (setuid(intended_uid) < 0) {
 229            error_report("Failed to setuid(%d)", intended_uid);
 230            exit(1);
 231        }
 232        if (setuid(0) != -1) {
 233            error_report("Dropping privileges failed");
 234            exit(1);
 235        }
 236    }
 237}
 238
 239static void change_root(void)
 240{
 241    if (chroot_dir) {
 242        if (chroot(chroot_dir) < 0) {
 243            error_report("chroot failed");
 244            exit(1);
 245        }
 246        if (chdir("/")) {
 247            error_report("not able to chdir to /: %s", strerror(errno));
 248            exit(1);
 249        }
 250    }
 251
 252}
 253
 254void os_daemonize(void)
 255{
 256    if (daemonize) {
 257        pid_t pid;
 258        int fds[2];
 259
 260        if (pipe(fds) == -1) {
 261            exit(1);
 262        }
 263
 264        pid = fork();
 265        if (pid > 0) {
 266            uint8_t status;
 267            ssize_t len;
 268
 269            close(fds[1]);
 270
 271            do {
 272                len = read(fds[0], &status, 1);
 273            } while (len < 0 && errno == EINTR);
 274
 275            /* only exit successfully if our child actually wrote
 276             * a one-byte zero to our pipe, upon successful init */
 277            exit(len == 1 && status == 0 ? 0 : 1);
 278
 279        } else if (pid < 0) {
 280            exit(1);
 281        }
 282
 283        close(fds[0]);
 284        daemon_pipe = fds[1];
 285        qemu_set_cloexec(daemon_pipe);
 286
 287        setsid();
 288
 289        pid = fork();
 290        if (pid > 0) {
 291            exit(0);
 292        } else if (pid < 0) {
 293            exit(1);
 294        }
 295        umask(027);
 296
 297        signal(SIGTSTP, SIG_IGN);
 298        signal(SIGTTOU, SIG_IGN);
 299        signal(SIGTTIN, SIG_IGN);
 300    }
 301}
 302
 303void os_setup_post(void)
 304{
 305    int fd = 0;
 306
 307    if (daemonize) {
 308        if (chdir("/")) {
 309            error_report("not able to chdir to /: %s", strerror(errno));
 310            exit(1);
 311        }
 312        TFR(fd = qemu_open("/dev/null", O_RDWR));
 313        if (fd == -1) {
 314            exit(1);
 315        }
 316    }
 317
 318    change_root();
 319    change_process_uid();
 320
 321    if (daemonize) {
 322        uint8_t status = 0;
 323        ssize_t len;
 324
 325        dup2(fd, 0);
 326        dup2(fd, 1);
 327        /* In case -D is given do not redirect stderr to /dev/null */
 328        if (!qemu_logfile) {
 329            dup2(fd, 2);
 330        }
 331
 332        close(fd);
 333
 334        do {        
 335            len = write(daemon_pipe, &status, 1);
 336        } while (len < 0 && errno == EINTR);
 337        if (len != 1) {
 338            exit(1);
 339        }
 340    }
 341}
 342
 343void os_set_line_buffering(void)
 344{
 345    setvbuf(stdout, NULL, _IOLBF, 0);
 346}
 347
 348bool is_daemonized(void)
 349{
 350    return daemonize;
 351}
 352
 353int os_mlock(void)
 354{
 355    int ret = 0;
 356
 357    ret = mlockall(MCL_CURRENT | MCL_FUTURE);
 358    if (ret < 0) {
 359        error_report("mlockall: %s", strerror(errno));
 360    }
 361
 362    return ret;
 363}
 364