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/help-texts.h"
  22 #include "qemu/units.h"
  23 #include "qemu/accel.h"
  24 #include "qemu-version.h"
  25 #include <sys/syscall.h>
  26 #include <sys/resource.h>
  27 #include <sys/shm.h>
  28 #include <linux/binfmts.h>
  29
  30 #include "qapi/error.h"
  31 #include "qemu.h"
  32 #include "user-internals.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 "exec/gdbstub.h"
  43 #include "gdbstub/user.h"
  44 #include "tcg/startup.h"
  45 #include "qemu/timer.h"
  46 #include "qemu/envlist.h"
  47 #include "qemu/guest-random.h"
  48 #include "elf.h"
  49 #include "trace/control.h"
  50 #include "target_elf.h"
  51 #include "cpu_loop-common.h"
  52 #include "crypto/init.h"
  53 #include "fd-trans.h"
  54 #include "signal-common.h"
  55 #include "loader.h"
  56 #include "user-mmap.h"
  57 #include "tcg/perf.h"
  58 #include "exec/page-vary.h"
  59
  60 #ifdef CONFIG_SEMIHOSTING
  61 #include "semihosting/semihost.h"
  62 #endif
  63
  64 #ifndef AT_FLAGS_PRESERVE_ARGV0
  65 #define AT_FLAGS_PRESERVE_ARGV0_BIT 0
  66 #define AT_FLAGS_PRESERVE_ARGV0 (1 << AT_FLAGS_PRESERVE_ARGV0_BIT)
  67 #endif
  68
  69 char *exec_path;
  70 char real_exec_path[PATH_MAX];
  71
  72 static bool opt_one_insn_per_tb;
  73 static const char *argv0;
  74 static const char *gdbstub;
  75 static envlist_t *envlist;
  76 static const char *cpu_model;
  77 static const char *cpu_type;
  78 static const char *seed_optarg;
  79 unsigned long mmap_min_addr;
  80 uintptr_t guest_base;
  81 bool have_guest_base;
  82
  83 /*
  84  * Used to implement backwards-compatibility for the `-strace`, and
  85  * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
  86  * -strace, or vice versa.
  87  */
  88 static bool enable_strace;
  89
  90 /*
  91  * The last log mask given by the user in an environment variable or argument.
  92  * Used to support command line arguments overriding environment variables.
  93  */
  94 static int last_log_mask;
  95 static const char *last_log_filename;
  96
  97 /*
  98  * When running 32-on-64 we should make sure we can fit all of the possible
  99  * guest address space into a contiguous chunk of virtual host memory.
 100  *
 101  * This way we will never overlap with our own libraries or binaries or stack
 102  * or anything else that QEMU maps.
 103  *
 104  * Many cpus reserve the high bit (or more than one for some 64-bit cpus)
 105  * of the address for the kernel.  Some cpus rely on this and user space
 106  * uses the high bit(s) for pointer tagging and the like.  For them, we
 107  * must preserve the expected address space.
 108  */
 109 #ifndef MAX_RESERVED_VA
 110 # if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
 111 #  if TARGET_VIRT_ADDR_SPACE_BITS == 32 && \
 112       (TARGET_LONG_BITS == 32 || defined(TARGET_ABI32))
 113 #   define MAX_RESERVED_VA(CPU)  0xfffffffful
 114 #  else
 115 #   define MAX_RESERVED_VA(CPU)  ((1ul << TARGET_VIRT_ADDR_SPACE_BITS) - 1)
 116 #  endif
 117 # else
 118 #  define MAX_RESERVED_VA(CPU)  0
 119 # endif
 120 #endif
 121
 122 unsigned long reserved_va;
 123
 124 static void usage(int exitcode);
 125
 126 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
 127 const char *qemu_uname_release;
 128
 129 #if !defined(TARGET_DEFAULT_STACK_SIZE)
 130 /* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
 131    we allocate a bigger stack. Need a better solution, for example
 132    by remapping the process stack directly at the right place */
 133 #define TARGET_DEFAULT_STACK_SIZE       8 * 1024 * 1024UL
 134 #endif
 135
 136 unsigned long guest_stack_size = TARGET_DEFAULT_STACK_SIZE;
 137
 138 /***********************************************************/
 139 /* Helper routines for implementing atomic operations.  */
 140
 141 /* Make sure everything is in a consistent state for calling fork().  */
 142 void fork_start(void)
 143 {
 144     start_exclusive();
 145     mmap_fork_start();
 146     cpu_list_lock();
 147     qemu_plugin_user_prefork_lock();
 148     gdbserver_fork_start();
 149 }
 150
 151 void fork_end(pid_t pid)
 152 {
 153     bool child = pid == 0;
 154
 155     qemu_plugin_user_postfork(child);
 156     mmap_fork_end(child);
 157     if (child) {
 158         CPUState *cpu, *next_cpu;
 159         /* Child processes created by fork() only have a single thread.
 160            Discard information about the parent threads.  */
 161         CPU_FOREACH_SAFE(cpu, next_cpu) {
 162             if (cpu != thread_cpu) {
 163                 QTAILQ_REMOVE_RCU(&cpus_queue, cpu, node);
 164             }
 165         }
 166         qemu_init_cpu_list();
 167         get_task_state(thread_cpu)->ts_tid = qemu_get_thread_id();
 168     } else {
 169         cpu_list_unlock();
 170     }
 171     gdbserver_fork_end(thread_cpu, pid);
 172     /*
 173      * qemu_init_cpu_list() reinitialized the child exclusive state, but we
 174      * also need to keep current_cpu consistent, so call end_exclusive() for
 175      * both child and parent.
 176      */
 177     end_exclusive();
 178 }
 179
 180 __thread CPUState *thread_cpu;
 181
 182 bool qemu_cpu_is_self(CPUState *cpu)
 183 {
 184     return thread_cpu == cpu;
 185 }
 186
 187 void qemu_cpu_kick(CPUState *cpu)
 188 {
 189     cpu_exit(cpu);
 190 }
 191
 192 void task_settid(TaskState *ts)
 193 {
 194     if (ts->ts_tid == 0) {
 195         ts->ts_tid = (pid_t)syscall(SYS_gettid);
 196     }
 197 }
 198
 199 void stop_all_tasks(void)
 200 {
 201     /*
 202      * We trust that when using NPTL, start_exclusive()
 203      * handles thread stopping correctly.
 204      */
 205     start_exclusive();
 206 }
 207
 208 /* Assumes contents are already zeroed.  */
 209 void init_task_state(TaskState *ts)
 210 {
 211     long ticks_per_sec;
 212     struct timespec bt;
 213
 214     ts->used = 1;
 215     ts->sigaltstack_used = (struct target_sigaltstack) {
 216         .ss_sp = 0,
 217         .ss_size = 0,
 218         .ss_flags = TARGET_SS_DISABLE,
 219     };
 220
 221     /* Capture task start time relative to system boot */
 222
 223     ticks_per_sec = sysconf(_SC_CLK_TCK);
 224
 225     if ((ticks_per_sec > 0) && !clock_gettime(CLOCK_BOOTTIME, &bt)) {
 226         /* start_boottime is expressed in clock ticks */
 227         ts->start_boottime = bt.tv_sec * (uint64_t) ticks_per_sec;
 228         ts->start_boottime += bt.tv_nsec * (uint64_t) ticks_per_sec /
 229                               NANOSECONDS_PER_SECOND;
 230     }
 231 }
 232
 233 CPUArchState *cpu_copy(CPUArchState *env)
 234 {
 235     CPUState *cpu = env_cpu(env);
 236     CPUState *new_cpu = cpu_create(cpu_type);
 237     CPUArchState *new_env = cpu_env(new_cpu);
 238     CPUBreakpoint *bp;
 239
 240     /* Reset non arch specific state */
 241     cpu_reset(new_cpu);
 242
 243     new_cpu->tcg_cflags = cpu->tcg_cflags;
 244     memcpy(new_env, env, sizeof(CPUArchState));
 245 #if defined(TARGET_I386) || defined(TARGET_X86_64)
 246     new_env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES,
 247                                     PROT_READ | PROT_WRITE,
 248                                     MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
 249     memcpy(g2h_untagged(new_env->gdt.base), g2h_untagged(env->gdt.base),
 250            sizeof(uint64_t) * TARGET_GDT_ENTRIES);
 251     OBJECT(new_cpu)->free = OBJECT(cpu)->free;
 252 #endif
 253
 254     /* Clone all break/watchpoints.
 255        Note: Once we support ptrace with hw-debug register access, make sure
 256        BP_CPU break/watchpoints are handled correctly on clone. */
 257     QTAILQ_INIT(&new_cpu->breakpoints);
 258     QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
 259         cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL);
 260     }
 261
 262     return new_env;
 263 }
 264
 265 static void handle_arg_help(const char *arg)
 266 {
 267     usage(EXIT_SUCCESS);
 268 }
 269
 270 static void handle_arg_log(const char *arg)
 271 {
 272     last_log_mask = qemu_str_to_log_mask(arg);
 273     if (!last_log_mask) {
 274         qemu_print_log_usage(stdout);
 275         exit(EXIT_FAILURE);
 276     }
 277 }
 278
 279 static void handle_arg_dfilter(const char *arg)
 280 {
 281     qemu_set_dfilter_ranges(arg, &error_fatal);
 282 }
 283
 284 static void handle_arg_log_filename(const char *arg)
 285 {
 286     last_log_filename = arg;
 287 }
 288
 289 static void handle_arg_set_env(const char *arg)
 290 {
 291     char *r, *p, *token;
 292     r = p = strdup(arg);
 293     while ((token = strsep(&p, ",")) != NULL) {
 294         if (envlist_setenv(envlist, token) != 0) {
 295             usage(EXIT_FAILURE);
 296         }
 297     }
 298     free(r);
 299 }
 300
 301 static void handle_arg_unset_env(const char *arg)
 302 {
 303     char *r, *p, *token;
 304     r = p = strdup(arg);
 305     while ((token = strsep(&p, ",")) != NULL) {
 306         if (envlist_unsetenv(envlist, token) != 0) {
 307             usage(EXIT_FAILURE);
 308         }
 309     }
 310     free(r);
 311 }
 312
 313 static void handle_arg_argv0(const char *arg)
 314 {
 315     argv0 = strdup(arg);
 316 }
 317
 318 static void handle_arg_stack_size(const char *arg)
 319 {
 320     char *p;
 321     guest_stack_size = strtoul(arg, &p, 0);
 322     if (guest_stack_size == 0) {
 323         usage(EXIT_FAILURE);
 324     }
 325
 326     if (*p == 'M') {
 327         guest_stack_size *= MiB;
 328     } else if (*p == 'k' || *p == 'K') {
 329         guest_stack_size *= KiB;
 330     }
 331 }
 332
 333 static void handle_arg_ld_prefix(const char *arg)
 334 {
 335     interp_prefix = strdup(arg);
 336 }
 337
 338 static void handle_arg_pagesize(const char *arg)
 339 {
 340     unsigned size, want = qemu_real_host_page_size();
 341
 342     if (qemu_strtoui(arg, NULL, 10, &size) || size != want) {
 343         warn_report("Deprecated page size option cannot "
 344                     "change host page size (%u)", want);
 345     }
 346 }
 347
 348 static void handle_arg_seed(const char *arg)
 349 {
 350     seed_optarg = arg;
 351 }
 352
 353 static void handle_arg_gdb(const char *arg)
 354 {
 355     gdbstub = g_strdup(arg);
 356 }
 357
 358 static void handle_arg_uname(const char *arg)
 359 {
 360     qemu_uname_release = strdup(arg);
 361 }
 362
 363 static void handle_arg_cpu(const char *arg)
 364 {
 365     cpu_model = strdup(arg);
 366     if (cpu_model == NULL || is_help_option(cpu_model)) {
 367         list_cpus();
 368         exit(EXIT_FAILURE);
 369     }
 370 }
 371
 372 static void handle_arg_guest_base(const char *arg)
 373 {
 374     guest_base = strtol(arg, NULL, 0);
 375     have_guest_base = true;
 376 }
 377
 378 static void handle_arg_reserved_va(const char *arg)
 379 {
 380     char *p;
 381     int shift = 0;
 382     unsigned long val;
 383
 384     val = strtoul(arg, &p, 0);
 385     switch (*p) {
 386     case 'k':
 387     case 'K':
 388         shift = 10;
 389         break;
 390     case 'M':
 391         shift = 20;
 392         break;
 393     case 'G':
 394         shift = 30;
 395         break;
 396     }
 397     if (shift) {
 398         unsigned long unshifted = val;
 399         p++;
 400         val <<= shift;
 401         if (val >> shift != unshifted) {
 402             fprintf(stderr, "Reserved virtual address too big\n");
 403             exit(EXIT_FAILURE);
 404         }
 405     }
 406     if (*p) {
 407         fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
 408         exit(EXIT_FAILURE);
 409     }
 410     /* The representation is size - 1, with 0 remaining "default". */
 411     reserved_va = val ? val - 1 : 0;
 412 }
 413
 414 static void handle_arg_one_insn_per_tb(const char *arg)
 415 {
 416     opt_one_insn_per_tb = true;
 417 }
 418
 419 static void handle_arg_strace(const char *arg)
 420 {
 421     enable_strace = true;
 422 }
 423
 424 static void handle_arg_version(const char *arg)
 425 {
 426     printf("qemu-" TARGET_NAME " version " QEMU_FULL_VERSION
 427            "\n" QEMU_COPYRIGHT "\n");
 428     exit(EXIT_SUCCESS);
 429 }
 430
 431 static void handle_arg_trace(const char *arg)
 432 {
 433     trace_opt_parse(arg);
 434 }
 435
 436 #if defined(TARGET_XTENSA)
 437 static void handle_arg_abi_call0(const char *arg)
 438 {
 439     xtensa_set_abi_call0();
 440 }
 441 #endif
 442
 443 static void handle_arg_perfmap(const char *arg)
 444 {
 445     perf_enable_perfmap();
 446 }
 447
 448 static void handle_arg_jitdump(const char *arg)
 449 {
 450     perf_enable_jitdump();
 451 }
 452
 453 static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
 454
 455 #ifdef CONFIG_PLUGIN
 456 static void handle_arg_plugin(const char *arg)
 457 {
 458     qemu_plugin_opt_parse(arg, &plugins);
 459 }
 460 #endif
 461
 462 struct qemu_argument {
 463     const char *argv;
 464     const char *env;
 465     bool has_arg;
 466     void (*handle_opt)(const char *arg);
 467     const char *example;
 468     const char *help;
 469 };
 470
 471 static const struct qemu_argument arg_table[] = {
 472     {"h",          "",                 false, handle_arg_help,
 473      "",           "print this help"},
 474     {"help",       "",                 false, handle_arg_help,
 475      "",           ""},
 476     {"g",          "QEMU_GDB",         true,  handle_arg_gdb,
 477      "port",       "wait gdb connection to 'port'"},
 478     {"L",          "QEMU_LD_PREFIX",   true,  handle_arg_ld_prefix,
 479      "path",       "set the elf interpreter prefix to 'path'"},
 480     {"s",          "QEMU_STACK_SIZE",  true,  handle_arg_stack_size,
 481      "size",       "set the stack size to 'size' bytes"},
 482     {"cpu",        "QEMU_CPU",         true,  handle_arg_cpu,
 483      "model",      "select CPU (-cpu help for list)"},
 484     {"E",          "QEMU_SET_ENV",     true,  handle_arg_set_env,
 485      "var=value",  "sets targets environment variable (see below)"},
 486     {"U",          "QEMU_UNSET_ENV",   true,  handle_arg_unset_env,
 487      "var",        "unsets targets environment variable (see below)"},
 488     {"0",          "QEMU_ARGV0",       true,  handle_arg_argv0,
 489      "argv0",      "forces target process argv[0] to be 'argv0'"},
 490     {"r",          "QEMU_UNAME",       true,  handle_arg_uname,
 491      "uname",      "set qemu uname release string to 'uname'"},
 492     {"B",          "QEMU_GUEST_BASE",  true,  handle_arg_guest_base,
 493      "address",    "set guest_base address to 'address'"},
 494     {"R",          "QEMU_RESERVED_VA", true,  handle_arg_reserved_va,
 495      "size",       "reserve 'size' bytes for guest virtual address space"},
 496     {"d",          "QEMU_LOG",         true,  handle_arg_log,
 497      "item[,...]", "enable logging of specified items "
 498      "(use '-d help' for a list of items)"},
 499     {"dfilter",    "QEMU_DFILTER",     true,  handle_arg_dfilter,
 500      "range[,...]","filter logging based on address range"},
 501     {"D",          "QEMU_LOG_FILENAME", true, handle_arg_log_filename,
 502      "logfile",     "write logs to 'logfile' (default stderr)"},
 503     {"p",          "QEMU_PAGESIZE",    true,  handle_arg_pagesize,
 504      "pagesize",   "deprecated change to host page size"},
 505     {"one-insn-per-tb",
 506                    "QEMU_ONE_INSN_PER_TB",  false, handle_arg_one_insn_per_tb,
 507      "",           "run with one guest instruction per emulated TB"},
 508     {"strace",     "QEMU_STRACE",      false, handle_arg_strace,
 509      "",           "log system calls"},
 510     {"seed",       "QEMU_RAND_SEED",   true,  handle_arg_seed,
 511      "",           "Seed for pseudo-random number generator"},
 512     {"trace",      "QEMU_TRACE",       true,  handle_arg_trace,
 513      "",           "[[enable=]<pattern>][,events=<file>][,file=<file>]"},
 514 #ifdef CONFIG_PLUGIN
 515     {"plugin",     "QEMU_PLUGIN",      true,  handle_arg_plugin,
 516      "",           "[file=]<file>[,<argname>=<argvalue>]"},
 517 #endif
 518     {"version",    "QEMU_VERSION",     false, handle_arg_version,
 519      "",           "display version information and exit"},
 520 #if defined(TARGET_XTENSA)
 521     {"xtensa-abi-call0", "QEMU_XTENSA_ABI_CALL0", false, handle_arg_abi_call0,
 522      "",           "assume CALL0 Xtensa ABI"},
 523 #endif
 524     {"perfmap",    "QEMU_PERFMAP",     false, handle_arg_perfmap,
 525      "",           "Generate a /tmp/perf-${pid}.map file for perf"},
 526     {"jitdump",    "QEMU_JITDUMP",     false, handle_arg_jitdump,
 527      "",           "Generate a jit-${pid}.dump file for perf"},
 528     {NULL, NULL, false, NULL, NULL, NULL}
 529 };
 530
 531 static void usage(int exitcode)
 532 {
 533     const struct qemu_argument *arginfo;
 534     int maxarglen;
 535     int maxenvlen;
 536
 537     printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
 538            "Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n"
 539            "\n"
 540            "Options and associated environment variables:\n"
 541            "\n");
 542
 543     /* Calculate column widths. We must always have at least enough space
 544      * for the column header.
 545      */
 546     maxarglen = strlen("Argument");
 547     maxenvlen = strlen("Env-variable");
 548
 549     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 550         int arglen = strlen(arginfo->argv);
 551         if (arginfo->has_arg) {
 552             arglen += strlen(arginfo->example) + 1;
 553         }
 554         if (strlen(arginfo->env) > maxenvlen) {
 555             maxenvlen = strlen(arginfo->env);
 556         }
 557         if (arglen > maxarglen) {
 558             maxarglen = arglen;
 559         }
 560     }
 561
 562     printf("%-*s %-*s Description\n", maxarglen+1, "Argument",
 563             maxenvlen, "Env-variable");
 564
 565     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 566         if (arginfo->has_arg) {
 567             printf("-%s %-*s %-*s %s\n", arginfo->argv,
 568                    (int)(maxarglen - strlen(arginfo->argv) - 1),
 569                    arginfo->example, maxenvlen, arginfo->env, arginfo->help);
 570         } else {
 571             printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv,
 572                     maxenvlen, arginfo->env,
 573                     arginfo->help);
 574         }
 575     }
 576
 577     printf("\n"
 578            "Defaults:\n"
 579            "QEMU_LD_PREFIX  = %s\n"
 580            "QEMU_STACK_SIZE = %ld byte\n",
 581            interp_prefix,
 582            guest_stack_size);
 583
 584     printf("\n"
 585            "You can use -E and -U options or the QEMU_SET_ENV and\n"
 586            "QEMU_UNSET_ENV environment variables to set and unset\n"
 587            "environment variables for the target process.\n"
 588            "It is possible to provide several variables by separating them\n"
 589            "by commas in getsubopt(3) style. Additionally it is possible to\n"
 590            "provide the -E and -U options multiple times.\n"
 591            "The following lines are equivalent:\n"
 592            "    -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
 593            "    -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
 594            "    QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
 595            "Note that if you provide several changes to a single variable\n"
 596            "the last change will stay in effect.\n"
 597            "\n"
 598            QEMU_HELP_BOTTOM "\n");
 599
 600     exit(exitcode);
 601 }
 602
 603 static int parse_args(int argc, char **argv)
 604 {
 605     const char *r;
 606     int optind;
 607     const struct qemu_argument *arginfo;
 608
 609     for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 610         if (arginfo->env == NULL) {
 611             continue;
 612         }
 613
 614         r = getenv(arginfo->env);
 615         if (r != NULL) {
 616             arginfo->handle_opt(r);
 617         }
 618     }
 619
 620     optind = 1;
 621     for (;;) {
 622         if (optind >= argc) {
 623             break;
 624         }
 625         r = argv[optind];
 626         if (r[0] != '-') {
 627             break;
 628         }
 629         optind++;
 630         r++;
 631         if (!strcmp(r, "-")) {
 632             break;
 633         }
 634         /* Treat --foo the same as -foo.  */
 635         if (r[0] == '-') {
 636             r++;
 637         }
 638
 639         for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
 640             if (!strcmp(r, arginfo->argv)) {
 641                 if (arginfo->has_arg) {
 642                     if (optind >= argc) {
 643                         (void) fprintf(stderr,
 644                             "qemu: missing argument for option '%s'\n", r);
 645                         exit(EXIT_FAILURE);
 646                     }
 647                     arginfo->handle_opt(argv[optind]);
 648                     optind++;
 649                 } else {
 650                     arginfo->handle_opt(NULL);
 651                 }
 652                 break;
 653             }
 654         }
 655
 656         /* no option matched the current argv */
 657         if (arginfo->handle_opt == NULL) {
 658             (void) fprintf(stderr, "qemu: unknown option '%s'\n", r);
 659             exit(EXIT_FAILURE);
 660         }
 661     }
 662
 663     if (optind >= argc) {
 664         (void) fprintf(stderr, "qemu: no user program specified\n");
 665         exit(EXIT_FAILURE);
 666     }
 667
 668     exec_path = argv[optind];
 669
 670     return optind;
 671 }
 672
 673 int main(int argc, char **argv, char **envp)
 674 {
 675     struct target_pt_regs regs1, *regs = &regs1;
 676     struct image_info info1, *info = &info1;
 677     struct linux_binprm bprm;
 678     TaskState *ts;
 679     CPUArchState *env;
 680     CPUState *cpu;
 681     int optind;
 682     char **target_environ, **wrk;
 683     char **target_argv;
 684     int target_argc;
 685     int i;
 686     int ret;
 687     int execfd;
 688     int host_page_size;
 689     unsigned long max_reserved_va;
 690     bool preserve_argv0;
 691
 692     error_init(argv[0]);
 693     module_call_init(MODULE_INIT_TRACE);
 694     qemu_init_cpu_list();
 695     module_call_init(MODULE_INIT_QOM);
 696
 697     envlist = envlist_create();
 698
 699     /*
 700      * add current environment into the list
 701      * envlist_setenv adds to the front of the list; to preserve environ
 702      * order add from back to front
 703      */
 704     for (wrk = environ; *wrk != NULL; wrk++) {
 705         continue;
 706     }
 707     while (wrk != environ) {
 708         wrk--;
 709         (void) envlist_setenv(envlist, *wrk);
 710     }
 711
 712     /* Read the stack limit from the kernel.  If it's "unlimited",
 713        then we can do little else besides use the default.  */
 714     {
 715         struct rlimit lim;
 716         if (getrlimit(RLIMIT_STACK, &lim) == 0
 717             && lim.rlim_cur != RLIM_INFINITY
 718             && lim.rlim_cur == (target_long)lim.rlim_cur
 719             && lim.rlim_cur > guest_stack_size) {
 720             guest_stack_size = lim.rlim_cur;
 721         }
 722     }
 723
 724     cpu_model = NULL;
 725
 726     qemu_add_opts(&qemu_trace_opts);
 727     qemu_plugin_add_opts();
 728
 729     optind = parse_args(argc, argv);
 730
 731     qemu_set_log_filename_flags(last_log_filename,
 732                                 last_log_mask | (enable_strace * LOG_STRACE),
 733                                 &error_fatal);
 734
 735     if (!trace_init_backends()) {
 736         exit(1);
 737     }
 738     trace_init_file();
 739     qemu_plugin_load_list(&plugins, &error_fatal);
 740
 741     /* Zero out regs */
 742     memset(regs, 0, sizeof(struct target_pt_regs));
 743
 744     /* Zero out image_info */
 745     memset(info, 0, sizeof(struct image_info));
 746
 747     memset(&bprm, 0, sizeof (bprm));
 748
 749     /* Scan interp_prefix dir for replacement files. */
 750     init_paths(interp_prefix);
 751
 752     init_qemu_uname_release();
 753
 754     /*
 755      * Manage binfmt-misc open-binary flag
 756      */
 757     execfd = qemu_getauxval(AT_EXECFD);
 758     if (execfd == 0) {
 759         execfd = open(exec_path, O_RDONLY);
 760         if (execfd < 0) {
 761             printf("Error while loading %s: %s\n", exec_path, strerror(errno));
 762             _exit(EXIT_FAILURE);
 763         }
 764     }
 765
 766     /* Resolve executable file name to full path name */
 767     if (realpath(exec_path, real_exec_path)) {
 768         exec_path = real_exec_path;
 769     }
 770
 771     /*
 772      * get binfmt_misc flags
 773      */
 774     preserve_argv0 = !!(qemu_getauxval(AT_FLAGS) & AT_FLAGS_PRESERVE_ARGV0);
 775
 776     /*
 777      * Manage binfmt-misc preserve-arg[0] flag
 778      *    argv[optind]     full path to the binary
 779      *    argv[optind + 1] original argv[0]
 780      */
 781     if (optind + 1 < argc && preserve_argv0) {
 782         optind++;
 783     }
 784
 785     if (cpu_model == NULL) {
 786         cpu_model = cpu_get_model(get_elf_eflags(execfd));
 787     }
 788     cpu_type = parse_cpu_option(cpu_model);
 789
 790     /* init tcg before creating CPUs */
 791     {
 792         AccelState *accel = current_accel();
 793         AccelClass *ac = ACCEL_GET_CLASS(accel);
 794
 795         accel_init_interfaces(ac);
 796         object_property_set_bool(OBJECT(accel), "one-insn-per-tb",
 797                                  opt_one_insn_per_tb, &error_abort);
 798         ac->init_machine(NULL);
 799     }
 800
 801     /*
 802      * Finalize page size before creating CPUs.
 803      * This will do nothing if !TARGET_PAGE_BITS_VARY.
 804      * The most efficient setting is to match the host.
 805      */
 806     host_page_size = qemu_real_host_page_size();
 807     set_preferred_target_page_bits(ctz32(host_page_size));
 808     finalize_target_page_bits();
 809
 810     cpu = cpu_create(cpu_type);
 811     env = cpu_env(cpu);
 812     cpu_reset(cpu);
 813     thread_cpu = cpu;
 814
 815     /*
 816      * Reserving too much vm space via mmap can run into problems
 817      * with rlimits, oom due to page table creation, etc.  We will
 818      * still try it, if directed by the command-line option, but
 819      * not by default.
 820      */
 821     max_reserved_va = MAX_RESERVED_VA(cpu);
 822     if (reserved_va != 0) {
 823         if ((reserved_va + 1) % host_page_size) {
 824             char *s = size_to_str(host_page_size);
 825             fprintf(stderr, "Reserved virtual address not aligned mod %s\n", s);
 826             g_free(s);
 827             exit(EXIT_FAILURE);
 828         }
 829         if (max_reserved_va && reserved_va > max_reserved_va) {
 830             fprintf(stderr, "Reserved virtual address too big\n");
 831             exit(EXIT_FAILURE);
 832         }
 833     } else if (HOST_LONG_BITS == 64 && TARGET_VIRT_ADDR_SPACE_BITS <= 32) {
 834         /* MAX_RESERVED_VA + 1 is a large power of 2, so is aligned. */
 835         reserved_va = max_reserved_va;
 836     }
 837
 838     /*
 839      * Temporarily disable
 840      *   "comparison is always false due to limited range of data type"
 841      * due to comparison between (possible) uint64_t and uintptr_t.
 842      */
 843 #pragma GCC diagnostic push
 844 #pragma GCC diagnostic ignored "-Wtype-limits"
 845
 846     /*
 847      * Select an initial value for task_unmapped_base that is in range.
 848      */
 849     if (reserved_va) {
 850         if (TASK_UNMAPPED_BASE < reserved_va) {
 851             task_unmapped_base = TASK_UNMAPPED_BASE;
 852         } else {
 853             /* The most common default formula is TASK_SIZE / 3. */
 854             task_unmapped_base = TARGET_PAGE_ALIGN(reserved_va / 3);
 855         }
 856     } else if (TASK_UNMAPPED_BASE < UINTPTR_MAX) {
 857         task_unmapped_base = TASK_UNMAPPED_BASE;
 858     } else {
 859         /* 32-bit host: pick something medium size. */
 860         task_unmapped_base = 0x10000000;
 861     }
 862     mmap_next_start = task_unmapped_base;
 863
 864     /* Similarly for elf_et_dyn_base. */
 865     if (reserved_va) {
 866         if (ELF_ET_DYN_BASE < reserved_va) {
 867             elf_et_dyn_base = ELF_ET_DYN_BASE;
 868         } else {
 869             /* The most common default formula is TASK_SIZE / 3 * 2. */
 870             elf_et_dyn_base = TARGET_PAGE_ALIGN(reserved_va / 3) * 2;
 871         }
 872     } else if (ELF_ET_DYN_BASE < UINTPTR_MAX) {
 873         elf_et_dyn_base = ELF_ET_DYN_BASE;
 874     } else {
 875         /* 32-bit host: pick something medium size. */
 876         elf_et_dyn_base = 0x18000000;
 877     }
 878
 879 #pragma GCC diagnostic pop
 880
 881     {
 882         Error *err = NULL;
 883         if (seed_optarg != NULL) {
 884             qemu_guest_random_seed_main(seed_optarg, &err);
 885         } else {
 886             qcrypto_init(&err);
 887         }
 888         if (err) {
 889             error_reportf_err(err, "cannot initialize crypto: ");
 890             exit(1);
 891         }
 892     }
 893
 894     target_environ = envlist_to_environ(envlist, NULL);
 895     envlist_free(envlist);
 896
 897     /*
 898      * Read in mmap_min_addr kernel parameter.  This value is used
 899      * When loading the ELF image to determine whether guest_base
 900      * is needed.  It is also used in mmap_find_vma.
 901      */
 902     {
 903         FILE *fp;
 904
 905         if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
 906             unsigned long tmp;
 907             if (fscanf(fp, "%lu", &tmp) == 1 && tmp != 0) {
 908                 mmap_min_addr = MAX(tmp, host_page_size);
 909                 qemu_log_mask(CPU_LOG_PAGE, "host mmap_min_addr=0x%lx\n",
 910                               mmap_min_addr);
 911             }
 912             fclose(fp);
 913         }
 914     }
 915
 916     /*
 917      * We prefer to not make NULL pointers accessible to QEMU.
 918      * If we're in a chroot with no /proc, fall back to 1 page.
 919      */
 920     if (mmap_min_addr == 0) {
 921         mmap_min_addr = host_page_size;
 922         qemu_log_mask(CPU_LOG_PAGE,
 923                       "host mmap_min_addr=0x%lx (fallback)\n",
 924                       mmap_min_addr);
 925     }
 926
 927     /*
 928      * Prepare copy of argv vector for target.
 929      */
 930     target_argc = argc - optind;
 931     target_argv = calloc(target_argc + 1, sizeof (char *));
 932     if (target_argv == NULL) {
 933         (void) fprintf(stderr, "Unable to allocate memory for target_argv\n");
 934         exit(EXIT_FAILURE);
 935     }
 936
 937     /*
 938      * If argv0 is specified (using '-0' switch) we replace
 939      * argv[0] pointer with the given one.
 940      */
 941     i = 0;
 942     if (argv0 != NULL) {
 943         target_argv[i++] = strdup(argv0);
 944     }
 945     for (; i < target_argc; i++) {
 946         target_argv[i] = strdup(argv[optind + i]);
 947     }
 948     target_argv[target_argc] = NULL;
 949
 950     ts = g_new0(TaskState, 1);
 951     init_task_state(ts);
 952     /* build Task State */
 953     ts->info = info;
 954     ts->bprm = &bprm;
 955     cpu->opaque = ts;
 956     task_settid(ts);
 957
 958     fd_trans_init();
 959
 960     ret = loader_exec(execfd, exec_path, target_argv, target_environ, regs,
 961         info, &bprm);
 962     if (ret != 0) {
 963         printf("Error while loading %s: %s\n", exec_path, strerror(-ret));
 964         _exit(EXIT_FAILURE);
 965     }
 966
 967     for (wrk = target_environ; *wrk; wrk++) {
 968         g_free(*wrk);
 969     }
 970
 971     g_free(target_environ);
 972
 973     if (qemu_loglevel_mask(CPU_LOG_PAGE)) {
 974         FILE *f = qemu_log_trylock();
 975         if (f) {
 976             fprintf(f, "guest_base  %p\n", (void *)guest_base);
 977             fprintf(f, "page layout changed following binary load\n");
 978             page_dump(f);
 979
 980             fprintf(f, "end_code    0x" TARGET_ABI_FMT_lx "\n",
 981                     info->end_code);
 982             fprintf(f, "start_code  0x" TARGET_ABI_FMT_lx "\n",
 983                     info->start_code);
 984             fprintf(f, "start_data  0x" TARGET_ABI_FMT_lx "\n",
 985                     info->start_data);
 986             fprintf(f, "end_data    0x" TARGET_ABI_FMT_lx "\n",
 987                     info->end_data);
 988             fprintf(f, "start_stack 0x" TARGET_ABI_FMT_lx "\n",
 989                     info->start_stack);
 990             fprintf(f, "brk         0x" TARGET_ABI_FMT_lx "\n",
 991                     info->brk);
 992             fprintf(f, "entry       0x" TARGET_ABI_FMT_lx "\n",
 993                     info->entry);
 994             fprintf(f, "argv_start  0x" TARGET_ABI_FMT_lx "\n",
 995                     info->argv);
 996             fprintf(f, "env_start   0x" TARGET_ABI_FMT_lx "\n",
 997                     info->envp);
 998             fprintf(f, "auxv_start  0x" TARGET_ABI_FMT_lx "\n",
 999                     info->saved_auxv);
1000             qemu_log_unlock(f);
1001         }
1002     }
1003
1004     target_set_brk(info->brk);
1005     syscall_init();
1006     signal_init();
1007
1008     /* Now that we've loaded the binary, GUEST_BASE is fixed.  Delay
1009        generating the prologue until now so that the prologue can take
1010        the real value of GUEST_BASE into account.  */
1011     tcg_prologue_init();
1012
1013     target_cpu_copy_regs(env, regs);
1014
1015     if (gdbstub) {
1016         if (gdbserver_start(gdbstub) < 0) {
1017             fprintf(stderr, "qemu: could not open gdbserver on %s\n",
1018                     gdbstub);
1019             exit(EXIT_FAILURE);
1020         }
1021         gdb_handlesig(cpu, 0);
1022     }
1023
1024 #ifdef CONFIG_SEMIHOSTING
1025     qemu_semihosting_guestfd_init();
1026 #endif
1027
1028     cpu_loop(env);
1029     /* never exits */
1030     return 0;
1031 }