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