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