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