linux-user/main.c

   1 /*
   2  *  qemu user main
   3  *
   4  *  Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "qemu/osdep.h"
  21 #include "qemu-common.h"
  22 #include "qemu/units.h"
  23 #include "qemu/accel.h"
  24 #include "sysemu/tcg.h"
  25 #include "qemu-version.h"
  26 #include <sys/syscall.h>
  27 #include <sys/resource.h>
  28 #include <sys/shm.h>
  29 #include <linux/binfmts.h>
  30
  31 #include "qapi/error.h"
  32 #include "qemu.h"
  33 #include "qemu/path.h"
  34 #include "qemu/queue.h"
  35 #include "qemu/config-file.h"
  36 #include "qemu/cutils.h"
  37 #include "qemu/error-report.h"
  38 #include "qemu/help_option.h"
  39 #include "qemu/module.h"
  40 #include "qemu/plugin.h"
  41 #include "exec/exec-all.h"
  42 #include "tcg/tcg.h"
  43 #include "qemu/timer.h"
  44 #include "qemu/envlist.h"
  45 #include "qemu/guest-random.h"
  46 #include "elf.h"
  47 #include "trace/control.h"
  48 #include "target_elf.h"
  49 #include "cpu_loop-common.h"
  50 #include "crypto/init.h"
  51 #include "fd-trans.h"
  52
  53 #ifndef AT_FLAGS_PRESERVE_ARGV0
  54 #define AT_FLAGS_PRESERVE_ARGV0_BIT 0
  55 #define AT_FLAGS_PRESERVE_ARGV0 (1 << AT_FLAGS_PRESERVE_ARGV0_BIT)
  56 #endif
  57
  58 char *exec_path;
  59
  60 int singlestep;
  61 static const char *argv0;
  62 static const char *gdbstub;
  63 static envlist_t *envlist;
  64 static const char *cpu_model;
  65 static const char *cpu_type;
  66 static const char *seed_optarg;
  67 unsigned long mmap_min_addr;
  68 uintptr_t guest_base;
  69 bool have_guest_base;
  70
  71 /*
  72  * Used to implement backwards-compatibility for the `-strace`, and
  73  * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
  74  * -strace, or vice versa.
  75  */
  76 static bool enable_strace;
  77
  78 /*
  79  * The last log mask given by the user in an environment variable or argument.
  80  * Used to support command line arguments overriding environment variables.
  81  */
  82 static int last_log_mask;
  83
  84 /*
  85  * When running 32-on-64 we should make sure we can fit all of the possible
  86  * guest address space into a contiguous chunk of virtual host memory.
  87  *
  88  * This way we will never overlap with our own libraries or binaries or stack
  89  * or anything else that QEMU maps.
  90  *
  91  * Many cpus reserve the high bit (or more than one for some 64-bit cpus)
  92  * of the address for the kernel.  Some cpus rely on this and user space
  93  * uses the high bit(s) for pointer tagging and the like.  For them, we
  94  * must preserve the expected address space.
  95  */
  96 #ifndef MAX_RESERVED_VA
  97 # if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
  98 #  if TARGET_VIRT_ADDR_SPACE_BITS == 32 && \
  99       (TARGET_LONG_BITS == 32 || defined(TARGET_ABI32))
 100 /* There are a number of places where we assign reserved_va to a variable
 101    of type abi_ulong and expect it to fit.  Avoid the last page.  */
 102 #   define MAX_RESERVED_VA(CPU)  (0xfffffffful & TARGET_PAGE_MASK)
 103 #  else
 104 #   define MAX_RESERVED_VA(CPU)  (1ul << TARGET_VIRT_ADDR_SPACE_BITS)
 105 #  endif
 106 # else
 107 #  define MAX_RESERVED_VA(CPU)  0
 108 # endif
 109 #endif
 110
 111 unsigned long reserved_va;
 112
 113 static void usage(int exitcode);
 114
 115 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
 116 const char *qemu_uname_release;
 117
 118 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
 119    we allocate a bigger stack. Need a better solution, for example
 120    by remapping the process stack directly at the right place */
 121 unsigned long guest_stack_size = 8 * 1024 * 1024UL;
 122
 123 #if defined(TARGET_I386)
 124 int cpu_get_pic_interrupt(CPUX86State *env)
 125 {
 126     return -1;
 127 }
 128 #endif
 129
 130 /***********************************************************/
 131 /* Helper routines for implementing atomic operations.  */
 132
 133 /* Make sure everything is in a consistent state for calling fork().  */
 134 void fork_start(void)
 135 {
 136     start_exclusive();
 137     mmap_fork_start();
 138     cpu_list_lock();
 139 }
 140
 141 void fork_end(int child)
 142 {
 143     mmap_fork_end(child);
 144     if (child) {
 145         CPUState *cpu, *next_cpu;
 146         /* Child processes created by fork() only have a single thread.
 147            Discard information about the parent threads.  */
 148         CPU_FOREACH_SAFE(cpu, next_cpu) {
 149             if (cpu != thread_cpu) {
 150                 QTAILQ_REMOVE_RCU(&cpus, cpu, node);
 151             }
 152         }
 153         qemu_init_cpu_list();
 154         gdbserver_fork(thread_cpu);
 155         /* qemu_init_cpu_list() takes care of reinitializing the
 156          * exclusive state, so we don't need to end_exclusive() here.
 157          */
 158     } else {
 159         cpu_list_unlock();
 160         end_exclusive();
 161     }
 162 }
 163
 164 __thread CPUState *thread_cpu;
 165
 166 bool qemu_cpu_is_self(CPUState *cpu)
 167 {
 168     return thread_cpu == cpu;
 169 }
 170
 171 void qemu_cpu_kick(CPUState *cpu)
 172 {
 173     cpu_exit(cpu);
 174 }
 175
 176 void task_settid(TaskState *ts)
 177 {
 178     if (ts->ts_tid == 0) {
 179         ts->ts_tid = (pid_t)syscall(SYS_gettid);
 180     }
 181 }
 182
 183 void stop_all_tasks(void)
 184 {
 185     /*
 186      * We trust that when using NPTL, start_exclusive()
 187      * handles thread stopping correctly.
 188      */
 189     start_exclusive();
 190 }
 191
 192 /* Assumes contents are already zeroed.  */
 193 void init_task_state(TaskState *ts)
 194 {
 195     ts->used = 1;
 196     ts->sigaltstack_used = (struct target_sigaltstack) {
 197         .ss_sp = 0,
 198         .ss_size = 0,
 199         .ss_flags = TARGET_SS_DISABLE,
 200     };
 201 }
 202
 203 CPUArchState *cpu_copy(CPUArchState *env)
 204 {
 205     CPUState *cpu = env_cpu(env);
 206     CPUState *new_cpu = cpu_create(cpu_type);
 207     CPUArchState *new_env = new_cpu->env_ptr;
 208     CPUBreakpoint *bp;
 209
 210     /* Reset non arch specific state */
 211     cpu_reset(new_cpu);
 212
 213     new_cpu->tcg_cflags = cpu->tcg_cflags;
 214     memcpy(new_env, env, sizeof(CPUArchState));
 215
 216     /* Clone all break/watchpoints.
 217        Note: Once we support ptrace with hw-debug register access, make sure
 218        BP_CPU break/watchpoints are handled correctly on clone. */
 219     QTAILQ_INIT(&new_cpu->breakpoints);
 220     QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
 221         cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL);
 222     }
 223
 224     return new_env;
 225 }
 226
 227 static void handle_arg_help(const char *arg)
 228 {
 229     usage(EXIT_SUCCESS);
 230 }
 231
 232 static void handle_arg_log(const char *arg)
 233 {
 234     last_log_mask = qemu_str_to_log_mask(arg);
 235     if (!last_log_mask) {
 236         qemu_print_log_usage(stdout);
 237         exit(EXIT_FAILURE);
 238     }
 239 }
 240
 241 static void handle_arg_dfilter(const char *arg)
 242 {
 243     qemu_set_dfilter_ranges(arg, &error_fatal);
 244 }
 245
 246 static void handle_arg_log_filename(const char *arg)
 247 {
 248     qemu_set_log_filename(arg, &error_fatal);
 249 }
 250
 251 static void handle_arg_set_env(const char *arg)
 252 {
 253     char *r, *p, *token;
 254     r = p = strdup(arg);
 255     while ((token = strsep(&p, ",")) != NULL) {
 256         if (envlist_setenv(envlist, token) != 0) {
 257             usage(EXIT_FAILURE);
 258         }
 259     }
 260     free(r);
 261 }
 262
 263 static void handle_arg_unset_env(const char *arg)
 264 {
 265     char *r, *p, *token;
 266     r = p = strdup(arg);
 267     while ((token = strsep(&p, ",")) != NULL) {
 268         if (envlist_unsetenv(envlist, token) != 0) {
 269             usage(EXIT_FAILURE);
 270         }
 271     }
 272     free(r);
 273 }
 274
 275 static void handle_arg_argv0(const char *arg)
 276 {
 277     argv0 = strdup(arg);
 278 }
 279
 280 static void handle_arg_stack_size(const char *arg)
 281 {
 282     char *p;
 283     guest_stack_size = strtoul(arg, &p, 0);
 284     if (guest_stack_size == 0) {
 285         usage(EXIT_FAILURE);
 286     }
 287
 288     if (*p == 'M') {
 289         guest_stack_size *= MiB;
 290     } else if (*p == 'k' || *p == 'K') {
 291         guest_stack_size *= KiB;
 292     }
 293 }
 294
 295 static void handle_arg_ld_prefix(const char *arg)
 296 {
 297     interp_prefix = strdup(arg);
 298 }
 299
 300 static void handle_arg_pagesize(const char *arg)
 301 {
 302     qemu_host_page_size = atoi(arg);
 303     if (qemu_host_page_size == 0 ||
 304         (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
 305         fprintf(stderr, "page size must be a power of two\n");
 306         exit(EXIT_FAILURE);
 307     }
 308 }
 309
 310 static void handle_arg_seed(const char *arg)
 311 {
 312     seed_optarg = arg;
 313 }
 314
 315 static void handle_arg_gdb(const char *arg)
 316 {
 317     gdbstub = g_strdup(arg);
 318 }
 319
 320 static void handle_arg_uname(const char *arg)
 321 {
 322     qemu_uname_release = strdup(arg);
 323 }
 324
 325 static void handle_arg_cpu(const char *arg)
 326 {
 327     cpu_model = strdup(arg);
 328     if (cpu_model == NULL || is_help_option(cpu_model)) {
 329         /* XXX: implement xxx_cpu_list for targets that still miss it */
 330 #if defined(cpu_list)
 331         cpu_list();
 332 #endif
 333         exit(EXIT_FAILURE);
 334     }
 335 }
 336
 337 static void handle_arg_guest_base(const char *arg)
 338 {
 339     guest_base = strtol(arg, NULL, 0);
 340     have_guest_base = true;
 341 }
 342
 343 static void handle_arg_reserved_va(const char *arg)
 344 {
 345     char *p;
 346     int shift = 0;
 347     reserved_va = strtoul(arg, &p, 0);
 348     switch (*p) {
 349     case 'k':
 350     case 'K':
 351         shift = 10;
 352         break;
 353     case 'M':
 354         shift = 20;
 355         break;
 356     case 'G':
 357         shift = 30;
 358         break;
 359     }
 360     if (shift) {
 361         unsigned long unshifted = reserved_va;
 362         p++;
 363         reserved_va <<= shift;
 364         if (reserved_va >> shift != unshifted) {
 365             fprintf(stderr, "Reserved virtual address too big\n");
 366             exit(EXIT_FAILURE);
 367         }
 368     }
 369     if (*p) {
 370         fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
 371         exit(EXIT_FAILURE);
 372     }
 373 }
 374
 375 static void handle_arg_singlestep(const char *arg)
 376 {
 377     singlestep = 1;
 378 }
 379
 380 static void handle_arg_strace(const char *arg)
 381 {
 382     enable_strace = true;
 383 }
 384
 385 static void handle_arg_version(const char *arg)
 386 {
 387     printf("qemu-" TARGET_NAME " version " QEMU_FULL_VERSION
 388            "\n" QEMU_COPYRIGHT "\n");
 389     exit(EXIT_SUCCESS);
 390 }
 391
 392 static void handle_arg_trace(const char *arg)
 393 {
 394     trace_opt_parse(arg);
 395 }
 396
 397 #if defined(TARGET_XTENSA)
 398 static void handle_arg_abi_call0(const char *arg)
 399 {
 400     xtensa_set_abi_call0();
 401 }
 402 #endif
 403
 404 static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
 405
 406 #ifdef CONFIG_PLUGIN
 407 static void handle_arg_plugin(const char *arg)
 408 {
 409     qemu_plugin_opt_parse(arg, &plugins);
 410 }
 411 #endif
 412
 413 struct qemu_argument {
 414     const char *argv;
 415     const char *env;
 416     bool has_arg;
 417     void (*handle_opt)(const char *arg);
 418     const char *example;
 419     const char *help;
 420 };
 421
 422 static const struct qemu_argument arg_table[] = {
 423     {"h",          "",                 false, handle_arg_help,
 424      "",           "print this help"},
 425     {"help",       "",                 false, handle_arg_help,
 426      "",           ""},
 427     {"g",          "QEMU_GDB",         true,  handle_arg_gdb,
 428      "port",       "wait gdb connection to 'port'"},
 429     {"L",          "QEMU_LD_PREFIX",   true,  handle_arg_ld_prefix,
 430      "path",       "set the elf interpreter prefix to 'path'"},
 431     {"s",          "QEMU_STACK_SIZE",  true,  handle_arg_stack_size,
 432      "size",       "set the stack size to 'size' bytes"},
 433     {"cpu",        "QEMU_CPU",         true,  handle_arg_cpu,
 434      "model",      "select CPU (-cpu help for list)"},
 435     {"E",          "QEMU_SET_ENV",     true,  handle_arg_set_env,
 436      "var=value",  "sets targets environment variable (see below)"},
 437     {"U",          "QEMU_UNSET_ENV",   true,  handle_arg_unset_env,
 438      "var",        "unsets targets environment variable (see below)"},
 439     {"0",          "QEMU_ARGV0",       true,  handle_arg_argv0,
 440      "argv0",      "forces target process argv[0] to be 'argv0'"},
 441     {"r",          "QEMU_UNAME",       true,  handle_arg_uname,
 442      "uname",      "set qemu uname release string to 'uname'"},
 443     {"B",          "QEMU_GUEST_BASE",  true,  handle_arg_guest_base,
 444      "address",    "set guest_base address to 'address'"},
 445     {"R",          "QEMU_RESERVED_VA", true,  handle_arg_reserved_va,
 446      "size",       "reserve 'size' bytes for guest virtual address space"},
 447     {"d",          "QEMU_LOG",         true,  handle_arg_log,
 448      "item[,...]", "enable logging of specified items "
 449      "(use '-d help' for a list of items)"},
 450     {"dfilter",    "QEMU_DFILTER",     true,  handle_arg_dfilter,
 451      "range[,...]","filter logging based on address range"},
 452     {"D",          "QEMU_LOG_FILENAME", true, handle_arg_log_filename,
 453      "logfile",     "write logs to 'logfile' (default stderr)"},
 454     {"p",          "QEMU_PAGESIZE",    true,  handle_arg_pagesize,
 455      "pagesize",   "set the host page size to 'pagesize'"},
 456     {"singlestep", "QEMU_SINGLESTEP",  false, handle_arg_singlestep,
 457      "",           "run in singlestep mode"},
 458     {"strace",     "QEMU_STRACE",      false, handle_arg_strace,
 459      "",           "log system calls"},
 460     {"seed",       "QEMU_RAND_SEED",   true,  handle_arg_seed,
 461      "",           "Seed for pseudo-random number generator"},
 462     {"trace",      "QEMU_TRACE",       true,  handle_arg_trace,
 463      "",           "[[enable=]<pattern>][,events=<file>][,file=<file>]"},
 464 #ifdef CONFIG_PLUGIN
 465     {"plugin",     "QEMU_PLUGIN",      true,  handle_arg_plugin,
 466      "",           "[file=]<file>[,arg=<string>]"},
 467 #endif
 468     {"version",    "QEMU_VERSION",     false, handle_arg_version,
 469      "",           "display version information and exit"},
 470 #if defined(TARGET_XTENSA)
 471     {"xtensa-abi-call0", "QEMU_XTENSA_ABI_CALL0", false, handle_arg_abi_call0,
 472      "",           "assume CALL0 Xtensa ABI"},
 473 #endif
 474     {NULL, NULL, false, NULL, NULL, NULL}
 475 };
 476
 477 static void usage(int exitcode)
 478 {
 479     const struct qemu_argument *arginfo;
 480     int maxarglen;
 481     int maxenvlen;
 482
 483     printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
 484            "Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n"
 485            "\n"
 486            "Options and associated environment variables:\n"
 487            "\n");
 488
 489     /* Calculate column widths. We must always have at least enough space
 490      * for the column header.
 491      */
 492     maxarglen = strlen("Argument");
 493     maxenvlen = strlen("Env-variable");
 494
 495     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 496         int arglen = strlen(arginfo->argv);
 497         if (arginfo->has_arg) {
 498             arglen += strlen(arginfo->example) + 1;
 499         }
 500         if (strlen(arginfo->env) > maxenvlen) {
 501             maxenvlen = strlen(arginfo->env);
 502         }
 503         if (arglen > maxarglen) {
 504             maxarglen = arglen;
 505         }
 506     }
 507
 508     printf("%-*s %-*s Description\n", maxarglen+1, "Argument",
 509             maxenvlen, "Env-variable");
 510
 511     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 512         if (arginfo->has_arg) {
 513             printf("-%s %-*s %-*s %s\n", arginfo->argv,
 514                    (int)(maxarglen - strlen(arginfo->argv) - 1),
 515                    arginfo->example, maxenvlen, arginfo->env, arginfo->help);
 516         } else {
 517             printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv,
 518                     maxenvlen, arginfo->env,
 519                     arginfo->help);
 520         }
 521     }
 522
 523     printf("\n"
 524            "Defaults:\n"
 525            "QEMU_LD_PREFIX  = %s\n"
 526            "QEMU_STACK_SIZE = %ld byte\n",
 527            interp_prefix,
 528            guest_stack_size);
 529
 530     printf("\n"
 531            "You can use -E and -U options or the QEMU_SET_ENV and\n"
 532            "QEMU_UNSET_ENV environment variables to set and unset\n"
 533            "environment variables for the target process.\n"
 534            "It is possible to provide several variables by separating them\n"
 535            "by commas in getsubopt(3) style. Additionally it is possible to\n"
 536            "provide the -E and -U options multiple times.\n"
 537            "The following lines are equivalent:\n"
 538            "    -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
 539            "    -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
 540            "    QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
 541            "Note that if you provide several changes to a single variable\n"
 542            "the last change will stay in effect.\n"
 543            "\n"
 544            QEMU_HELP_BOTTOM "\n");
 545
 546     exit(exitcode);
 547 }
 548
 549 static int parse_args(int argc, char **argv)
 550 {
 551     const char *r;
 552     int optind;
 553     const struct qemu_argument *arginfo;
 554
 555     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 556         if (arginfo->env == NULL) {
 557             continue;
 558         }
 559
 560         r = getenv(arginfo->env);
 561         if (r != NULL) {
 562             arginfo->handle_opt(r);
 563         }
 564     }
 565
 566     optind = 1;
 567     for (;;) {
 568         if (optind >= argc) {
 569             break;
 570         }
 571         r = argv[optind];
 572         if (r[0] != '-') {
 573             break;
 574         }
 575         optind++;
 576         r++;
 577         if (!strcmp(r, "-")) {
 578             break;
 579         }
 580         /* Treat --foo the same as -foo.  */
 581         if (r[0] == '-') {
 582             r++;
 583         }
 584
 585         for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 586             if (!strcmp(r, arginfo->argv)) {
 587                 if (arginfo->has_arg) {
 588                     if (optind >= argc) {
 589                         (void) fprintf(stderr,
 590                             "qemu: missing argument for option '%s'\n", r);
 591                         exit(EXIT_FAILURE);
 592                     }
 593                     arginfo->handle_opt(argv[optind]);
 594                     optind++;
 595                 } else {
 596                     arginfo->handle_opt(NULL);
 597                 }
 598                 break;
 599             }
 600         }
 601
 602         /* no option matched the current argv */
 603         if (arginfo->handle_opt == NULL) {
 604             (void) fprintf(stderr, "qemu: unknown option '%s'\n", r);
 605             exit(EXIT_FAILURE);
 606         }
 607     }
 608
 609     if (optind >= argc) {
 610         (void) fprintf(stderr, "qemu: no user program specified\n");
 611         exit(EXIT_FAILURE);
 612     }
 613
 614     exec_path = argv[optind];
 615
 616     return optind;
 617 }
 618
 619 int main(int argc, char **argv, char **envp)
 620 {
 621     struct target_pt_regs regs1, *regs = &regs1;
 622     struct image_info info1, *info = &info1;
 623     struct linux_binprm bprm;
 624     TaskState *ts;
 625     CPUArchState *env;
 626     CPUState *cpu;
 627     int optind;
 628     char **target_environ, **wrk;
 629     char **target_argv;
 630     int target_argc;
 631     int i;
 632     int ret;
 633     int execfd;
 634     int log_mask;
 635     unsigned long max_reserved_va;
 636     bool preserve_argv0;
 637
 638     error_init(argv[0]);
 639     module_call_init(MODULE_INIT_TRACE);
 640     qemu_init_cpu_list();
 641     module_call_init(MODULE_INIT_QOM);
 642
 643     envlist = envlist_create();
 644
 645     /* add current environment into the list */
 646     for (wrk = environ; *wrk != NULL; wrk++) {
 647         (void) envlist_setenv(envlist, *wrk);
 648     }
 649
 650     /* Read the stack limit from the kernel.  If it's "unlimited",
 651        then we can do little else besides use the default.  */
 652     {
 653         struct rlimit lim;
 654         if (getrlimit(RLIMIT_STACK, &lim) == 0
 655             && lim.rlim_cur != RLIM_INFINITY
 656             && lim.rlim_cur == (target_long)lim.rlim_cur) {
 657             guest_stack_size = lim.rlim_cur;
 658         }
 659     }
 660
 661     cpu_model = NULL;
 662
 663     qemu_add_opts(&qemu_trace_opts);
 664     qemu_plugin_add_opts();
 665
 666     optind = parse_args(argc, argv);
 667
 668     log_mask = last_log_mask | (enable_strace ? LOG_STRACE : 0);
 669     if (log_mask) {
 670         qemu_log_needs_buffers();
 671         qemu_set_log(log_mask);
 672     }
 673
 674     if (!trace_init_backends()) {
 675         exit(1);
 676     }
 677     trace_init_file();
 678     qemu_plugin_load_list(&plugins, &error_fatal);
 679
 680     /* Zero out regs */
 681     memset(regs, 0, sizeof(struct target_pt_regs));
 682
 683     /* Zero out image_info */
 684     memset(info, 0, sizeof(struct image_info));
 685
 686     memset(&bprm, 0, sizeof (bprm));
 687
 688     /* Scan interp_prefix dir for replacement files. */
 689     init_paths(interp_prefix);
 690
 691     init_qemu_uname_release();
 692
 693     /*
 694      * Manage binfmt-misc open-binary flag
 695      */
 696     execfd = qemu_getauxval(AT_EXECFD);
 697     if (execfd == 0) {
 698         execfd = open(exec_path, O_RDONLY);
 699         if (execfd < 0) {
 700             printf("Error while loading %s: %s\n", exec_path, strerror(errno));
 701             _exit(EXIT_FAILURE);
 702         }
 703     }
 704
 705     /*
 706      * get binfmt_misc flags
 707      */
 708     preserve_argv0 = !!(qemu_getauxval(AT_FLAGS) & AT_FLAGS_PRESERVE_ARGV0);
 709
 710     /*
 711      * Manage binfmt-misc preserve-arg[0] flag
 712      *    argv[optind]     full path to the binary
 713      *    argv[optind + 1] original argv[0]
 714      */
 715     if (optind + 1 < argc && preserve_argv0) {
 716         optind++;
 717     }
 718
 719     if (cpu_model == NULL) {
 720         cpu_model = cpu_get_model(get_elf_eflags(execfd));
 721     }
 722     cpu_type = parse_cpu_option(cpu_model);
 723
 724     /* init tcg before creating CPUs and to get qemu_host_page_size */
 725     {
 726         AccelClass *ac = ACCEL_GET_CLASS(current_accel());
 727
 728         accel_init_interfaces(ac);
 729         ac->init_machine(NULL);
 730     }
 731     cpu = cpu_create(cpu_type);
 732     env = cpu->env_ptr;
 733     cpu_reset(cpu);
 734     thread_cpu = cpu;
 735
 736     /*
 737      * Reserving too much vm space via mmap can run into problems
 738      * with rlimits, oom due to page table creation, etc.  We will
 739      * still try it, if directed by the command-line option, but
 740      * not by default.
 741      */
 742     max_reserved_va = MAX_RESERVED_VA(cpu);
 743     if (reserved_va != 0) {
 744         if (max_reserved_va && reserved_va > max_reserved_va) {
 745             fprintf(stderr, "Reserved virtual address too big\n");
 746             exit(EXIT_FAILURE);
 747         }
 748     } else if (HOST_LONG_BITS == 64 && TARGET_VIRT_ADDR_SPACE_BITS <= 32) {
 749         /*
 750          * reserved_va must be aligned with the host page size
 751          * as it is used with mmap()
 752          */
 753         reserved_va = max_reserved_va & qemu_host_page_mask;
 754     }
 755
 756     {
 757         Error *err = NULL;
 758         if (seed_optarg != NULL) {
 759             qemu_guest_random_seed_main(seed_optarg, &err);
 760         } else {
 761             qcrypto_init(&err);
 762         }
 763         if (err) {
 764             error_reportf_err(err, "cannot initialize crypto: ");
 765             exit(1);
 766         }
 767     }
 768
 769     target_environ = envlist_to_environ(envlist, NULL);
 770     envlist_free(envlist);
 771
 772     /*
 773      * Read in mmap_min_addr kernel parameter.  This value is used
 774      * When loading the ELF image to determine whether guest_base
 775      * is needed.  It is also used in mmap_find_vma.
 776      */
 777     {
 778         FILE *fp;
 779
 780         if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
 781             unsigned long tmp;
 782             if (fscanf(fp, "%lu", &tmp) == 1 && tmp != 0) {
 783                 mmap_min_addr = tmp;
 784                 qemu_log_mask(CPU_LOG_PAGE, "host mmap_min_addr=0x%lx\n",
 785                               mmap_min_addr);
 786             }
 787             fclose(fp);
 788         }
 789     }
 790
 791     /*
 792      * We prefer to not make NULL pointers accessible to QEMU.
 793      * If we're in a chroot with no /proc, fall back to 1 page.
 794      */
 795     if (mmap_min_addr == 0) {
 796         mmap_min_addr = qemu_host_page_size;
 797         qemu_log_mask(CPU_LOG_PAGE,
 798                       "host mmap_min_addr=0x%lx (fallback)\n",
 799                       mmap_min_addr);
 800     }
 801
 802     /*
 803      * Prepare copy of argv vector for target.
 804      */
 805     target_argc = argc - optind;
 806     target_argv = calloc(target_argc + 1, sizeof (char *));
 807     if (target_argv == NULL) {
 808         (void) fprintf(stderr, "Unable to allocate memory for target_argv\n");
 809         exit(EXIT_FAILURE);
 810     }
 811
 812     /*
 813      * If argv0 is specified (using '-0' switch) we replace
 814      * argv[0] pointer with the given one.
 815      */
 816     i = 0;
 817     if (argv0 != NULL) {
 818         target_argv[i++] = strdup(argv0);
 819     }
 820     for (; i < target_argc; i++) {
 821         target_argv[i] = strdup(argv[optind + i]);
 822     }
 823     target_argv[target_argc] = NULL;
 824
 825     ts = g_new0(TaskState, 1);
 826     init_task_state(ts);
 827     /* build Task State */
 828     ts->info = info;
 829     ts->bprm = &bprm;
 830     cpu->opaque = ts;
 831     task_settid(ts);
 832
 833     fd_trans_init();
 834
 835     ret = loader_exec(execfd, exec_path, target_argv, target_environ, regs,
 836         info, &bprm);
 837     if (ret != 0) {
 838         printf("Error while loading %s: %s\n", exec_path, strerror(-ret));
 839         _exit(EXIT_FAILURE);
 840     }
 841
 842     for (wrk = target_environ; *wrk; wrk++) {
 843         g_free(*wrk);
 844     }
 845
 846     g_free(target_environ);
 847
 848     if (qemu_loglevel_mask(CPU_LOG_PAGE)) {
 849         qemu_log("guest_base  %p\n", (void *)guest_base);
 850         log_page_dump("binary load");
 851
 852         qemu_log("start_brk   0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
 853         qemu_log("end_code    0x" TARGET_ABI_FMT_lx "\n", info->end_code);
 854         qemu_log("start_code  0x" TARGET_ABI_FMT_lx "\n", info->start_code);
 855         qemu_log("start_data  0x" TARGET_ABI_FMT_lx "\n", info->start_data);
 856         qemu_log("end_data    0x" TARGET_ABI_FMT_lx "\n", info->end_data);
 857         qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n", info->start_stack);
 858         qemu_log("brk         0x" TARGET_ABI_FMT_lx "\n", info->brk);
 859         qemu_log("entry       0x" TARGET_ABI_FMT_lx "\n", info->entry);
 860         qemu_log("argv_start  0x" TARGET_ABI_FMT_lx "\n", info->arg_start);
 861         qemu_log("env_start   0x" TARGET_ABI_FMT_lx "\n",
 862                  info->arg_end + (abi_ulong)sizeof(abi_ulong));
 863         qemu_log("auxv_start  0x" TARGET_ABI_FMT_lx "\n", info->saved_auxv);
 864     }
 865
 866     target_set_brk(info->brk);
 867     syscall_init();
 868     signal_init();
 869
 870     /* Now that we've loaded the binary, GUEST_BASE is fixed.  Delay
 871        generating the prologue until now so that the prologue can take
 872        the real value of GUEST_BASE into account.  */
 873     tcg_prologue_init(tcg_ctx);
 874
 875     target_cpu_copy_regs(env, regs);
 876
 877     if (gdbstub) {
 878         if (gdbserver_start(gdbstub) < 0) {
 879             fprintf(stderr, "qemu: could not open gdbserver on %s\n",
 880                     gdbstub);
 881             exit(EXIT_FAILURE);
 882         }
 883         gdb_handlesig(cpu, 0);
 884     }
 885     cpu_loop(env);
 886     /* never exits */
 887     return 0;
 888 }