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