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