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