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