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