4 * Copyright (c) 2003-2008 Fabrice Bellard
5 * Copyright (c) 2013-14 Stacey Son
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "qemu/osdep.h"
22 #include <sys/resource.h>
23 #include <sys/sysctl.h>
25 #include "qemu/help-texts.h"
26 #include "qemu/units.h"
27 #include "qemu/accel.h"
28 #include "qemu-version.h"
29 #include <machine/trap.h>
31 #include "qapi/error.h"
33 #include "qemu/config-file.h"
34 #include "qemu/error-report.h"
35 #include "qemu/path.h"
36 #include "qemu/help_option.h"
37 #include "qemu/module.h"
38 #include "exec/exec-all.h"
39 #include "tcg/startup.h"
40 #include "qemu/timer.h"
41 #include "qemu/envlist.h"
42 #include "qemu/cutils.h"
44 #include "trace/control.h"
45 #include "crypto/init.h"
46 #include "qemu/guest-random.h"
47 #include "gdbstub/user.h"
50 #include "target_arch_cpu.h"
54 * TODO: Remove these and rely only on qemu_real_host_page_size().
56 uintptr_t qemu_host_page_size
;
57 intptr_t qemu_host_page_mask
;
59 static bool opt_one_insn_per_tb
;
63 * When running 32-on-64 we should make sure we can fit all of the possible
64 * guest address space into a contiguous chunk of virtual host memory.
66 * This way we will never overlap with our own libraries or binaries or stack
67 * or anything else that QEMU maps.
69 * Many cpus reserve the high bit (or more than one for some 64-bit cpus)
70 * of the address for the kernel. Some cpus rely on this and user space
71 * uses the high bit(s) for pointer tagging and the like. For them, we
72 * must preserve the expected address space.
74 #ifndef MAX_RESERVED_VA
75 # if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
76 # if TARGET_VIRT_ADDR_SPACE_BITS == 32 && \
77 (TARGET_LONG_BITS == 32 || defined(TARGET_ABI32))
78 # define MAX_RESERVED_VA 0xfffffffful
80 # define MAX_RESERVED_VA ((1ul << TARGET_VIRT_ADDR_SPACE_BITS) - 1)
83 # define MAX_RESERVED_VA 0
88 * That said, reserving *too* much vm space via mmap can run into problems
89 * with rlimits, oom due to page table creation, etc. We will still try it,
90 * if directed by the command-line option, but not by default.
92 #if HOST_LONG_BITS == 64 && TARGET_VIRT_ADDR_SPACE_BITS <= 32
93 unsigned long reserved_va
= MAX_RESERVED_VA
;
95 unsigned long reserved_va
;
98 const char *interp_prefix
= CONFIG_QEMU_INTERP_PREFIX
;
99 const char *qemu_uname_release
;
100 char qemu_proc_pathname
[PATH_MAX
]; /* full path to exeutable */
102 unsigned long target_maxtsiz
= TARGET_MAXTSIZ
; /* max text size */
103 unsigned long target_dfldsiz
= TARGET_DFLDSIZ
; /* initial data size limit */
104 unsigned long target_maxdsiz
= TARGET_MAXDSIZ
; /* max data size */
105 unsigned long target_dflssiz
= TARGET_DFLSSIZ
; /* initial data size limit */
106 unsigned long target_maxssiz
= TARGET_MAXSSIZ
; /* max stack size */
107 unsigned long target_sgrowsiz
= TARGET_SGROWSIZ
; /* amount to grow stack */
109 /* Helper routines for implementing atomic operations. */
111 void fork_start(void)
116 gdbserver_fork_start();
119 void fork_end(pid_t pid
)
121 bool child
= pid
== 0;
124 CPUState
*cpu
, *next_cpu
;
126 * Child processes created by fork() only have a single thread. Discard
127 * information about the parent threads.
129 CPU_FOREACH_SAFE(cpu
, next_cpu
) {
130 if (cpu
!= thread_cpu
) {
131 QTAILQ_REMOVE_RCU(&cpus_queue
, cpu
, node
);
134 mmap_fork_end(child
);
136 * qemu_init_cpu_list() takes care of reinitializing the exclusive
137 * state, so we don't need to end_exclusive() here.
139 qemu_init_cpu_list();
140 get_task_state(thread_cpu
)->ts_tid
= qemu_get_thread_id();
141 gdbserver_fork(thread_cpu
);
143 mmap_fork_end(child
);
149 void cpu_loop(CPUArchState
*env
)
151 target_cpu_loop(env
);
154 static void usage(void)
156 printf("qemu-" TARGET_NAME
" version " QEMU_FULL_VERSION
157 "\n" QEMU_COPYRIGHT
"\n"
158 "usage: qemu-" TARGET_NAME
" [options] program [arguments...]\n"
159 "BSD CPU emulator (compiled for %s emulation)\n"
161 "Standard options:\n"
162 "-h print this help\n"
163 "-g port wait gdb connection to port\n"
164 "-L path set the elf interpreter prefix (default=%s)\n"
165 "-s size set the stack size in bytes (default=%ld)\n"
166 "-cpu model select CPU (-cpu help for list)\n"
167 "-drop-ld-preload drop LD_PRELOAD for target process\n"
168 "-E var=value sets/modifies targets environment variable(s)\n"
169 "-U var unsets targets environment variable(s)\n"
170 "-B address set guest_base address to address\n"
173 "-d item1[,...] enable logging of specified items\n"
174 " (use '-d help' for a list of log items)\n"
175 "-D logfile write logs to 'logfile' (default stderr)\n"
176 "-one-insn-per-tb run with one guest instruction per emulated TB\n"
177 "-strace log system calls\n"
178 "-trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
179 " specify tracing options\n"
181 "Environment variables:\n"
182 "QEMU_STRACE Print system calls and arguments similar to the\n"
183 " 'strace' program. Enable by setting to any value.\n"
184 "You can use -E and -U options to set/unset environment variables\n"
185 "for target process. It is possible to provide several variables\n"
186 "by repeating the option. For example:\n"
187 " -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
188 "Note that if you provide several changes to single variable\n"
189 "last change will stay in effect.\n"
191 QEMU_HELP_BOTTOM
"\n"
199 __thread CPUState
*thread_cpu
;
201 void stop_all_tasks(void)
204 * We trust when using NPTL (pthreads) start_exclusive() handles thread
205 * stopping correctly.
210 bool qemu_cpu_is_self(CPUState
*cpu
)
212 return thread_cpu
== cpu
;
215 void qemu_cpu_kick(CPUState
*cpu
)
220 /* Assumes contents are already zeroed. */
221 static void init_task_state(TaskState
*ts
)
223 ts
->sigaltstack_used
= (struct target_sigaltstack
) {
226 .ss_flags
= TARGET_SS_DISABLE
,
230 void gemu_log(const char *fmt
, ...)
235 vfprintf(stderr
, fmt
, ap
);
244 if (getrlimit(RLIMIT_STACK
, &rl
) != 0) {
248 target_maxssiz
= MIN(target_maxssiz
, rl
.rlim_max
);
249 target_dflssiz
= MIN(MAX(target_dflssiz
, rl
.rlim_cur
), target_maxssiz
);
251 rl
.rlim_max
= target_maxssiz
;
252 rl
.rlim_cur
= target_dflssiz
;
253 setrlimit(RLIMIT_STACK
, &rl
);
256 static void save_proc_pathname(char *argv0
)
263 mib
[2] = KERN_PROC_PATHNAME
;
266 len
= sizeof(qemu_proc_pathname
);
267 if (sysctl(mib
, 4, qemu_proc_pathname
, &len
, NULL
, 0)) {
272 int main(int argc
, char **argv
)
274 const char *filename
;
275 const char *cpu_model
;
276 const char *cpu_type
;
277 const char *log_file
= NULL
;
278 const char *log_mask
= NULL
;
279 const char *seed_optarg
= NULL
;
280 struct target_pt_regs regs1
, *regs
= ®s1
;
281 struct image_info info1
, *info
= &info1
;
282 struct bsd_binprm bprm
;
288 const char *gdbstub
= NULL
;
289 char **target_environ
, **wrk
;
290 envlist_t
*envlist
= NULL
;
299 save_proc_pathname(argv
[0]);
302 module_call_init(MODULE_INIT_TRACE
);
303 qemu_init_cpu_list();
304 module_call_init(MODULE_INIT_QOM
);
306 envlist
= envlist_create();
309 * add current environment into the list
310 * envlist_setenv adds to the front of the list; to preserve environ
311 * order add from back to front
313 for (wrk
= environ
; *wrk
!= NULL
; wrk
++) {
316 while (wrk
!= environ
) {
318 (void) envlist_setenv(envlist
, *wrk
);
321 qemu_host_page_size
= getpagesize();
322 qemu_host_page_size
= MAX(qemu_host_page_size
, TARGET_PAGE_SIZE
);
326 qemu_add_opts(&qemu_trace_opts
);
330 if (optind
>= argc
) {
339 if (!strcmp(r
, "-")) {
341 } else if (!strcmp(r
, "d")) {
342 if (optind
>= argc
) {
345 log_mask
= argv
[optind
++];
346 } else if (!strcmp(r
, "D")) {
347 if (optind
>= argc
) {
350 log_file
= argv
[optind
++];
351 } else if (!strcmp(r
, "E")) {
353 if (envlist_setenv(envlist
, r
) != 0) {
356 } else if (!strcmp(r
, "ignore-environment")) {
357 envlist_free(envlist
);
358 envlist
= envlist_create();
359 } else if (!strcmp(r
, "U")) {
361 if (envlist_unsetenv(envlist
, r
) != 0) {
364 } else if (!strcmp(r
, "s")) {
366 rv
= qemu_strtoul(r
, &r
, 0, &target_dflssiz
);
367 if (rv
< 0 || target_dflssiz
<= 0) {
371 target_dflssiz
*= 1024 * 1024;
372 } else if (*r
== 'k' || *r
== 'K') {
373 target_dflssiz
*= 1024;
375 if (target_dflssiz
> target_maxssiz
) {
378 } else if (!strcmp(r
, "L")) {
379 interp_prefix
= argv
[optind
++];
380 } else if (!strcmp(r
, "p")) {
381 unsigned size
, want
= qemu_real_host_page_size();
384 if (qemu_strtoui(r
, NULL
, 10, &size
) || size
!= want
) {
385 warn_report("Deprecated page size option cannot "
386 "change host page size (%u)", want
);
388 } else if (!strcmp(r
, "g")) {
389 gdbstub
= g_strdup(argv
[optind
++]);
390 } else if (!strcmp(r
, "r")) {
391 qemu_uname_release
= argv
[optind
++];
392 } else if (!strcmp(r
, "cpu")) {
393 cpu_model
= argv
[optind
++];
394 if (is_help_option(cpu_model
)) {
398 } else if (!strcmp(r
, "B")) {
399 rv
= qemu_strtoul(argv
[optind
++], NULL
, 0, &guest_base
);
403 have_guest_base
= true;
404 } else if (!strcmp(r
, "drop-ld-preload")) {
405 (void) envlist_unsetenv(envlist
, "LD_PRELOAD");
406 } else if (!strcmp(r
, "seed")) {
407 seed_optarg
= optarg
;
408 } else if (!strcmp(r
, "one-insn-per-tb")) {
409 opt_one_insn_per_tb
= true;
410 } else if (!strcmp(r
, "strace")) {
412 } else if (!strcmp(r
, "trace")) {
413 trace_opt_parse(optarg
);
414 } else if (!strcmp(r
, "0")) {
415 argv0
= argv
[optind
++];
421 qemu_host_page_mask
= -qemu_host_page_size
;
427 mask
= qemu_str_to_log_mask(log_mask
);
429 qemu_print_log_usage(stdout
);
433 qemu_set_log_filename_flags(log_file
, mask
, &error_fatal
);
436 if (optind
>= argc
) {
439 filename
= argv
[optind
];
441 argv
[optind
] = argv0
;
444 if (!trace_init_backends()) {
450 memset(regs
, 0, sizeof(struct target_pt_regs
));
452 /* Zero bsd params */
453 memset(&bprm
, 0, sizeof(bprm
));
455 /* Zero out image_info */
456 memset(info
, 0, sizeof(struct image_info
));
458 /* Scan interp_prefix dir for replacement files. */
459 init_paths(interp_prefix
);
461 if (cpu_model
== NULL
) {
462 cpu_model
= TARGET_DEFAULT_CPU_MODEL
;
465 cpu_type
= parse_cpu_option(cpu_model
);
467 /* init tcg before creating CPUs and to get qemu_host_page_size */
469 AccelState
*accel
= current_accel();
470 AccelClass
*ac
= ACCEL_GET_CLASS(accel
);
472 accel_init_interfaces(ac
);
473 object_property_set_bool(OBJECT(accel
), "one-insn-per-tb",
474 opt_one_insn_per_tb
, &error_abort
);
475 ac
->init_machine(NULL
);
477 cpu
= cpu_create(cpu_type
);
482 if (getenv("QEMU_STRACE")) {
486 target_environ
= envlist_to_environ(envlist
, NULL
);
487 envlist_free(envlist
);
491 if (seed_optarg
!= NULL
) {
492 qemu_guest_random_seed_main(seed_optarg
, &err
);
497 error_reportf_err(err
, "cannot initialize crypto: ");
503 * Now that page sizes are configured we can do
504 * proper page alignment for guest_base.
506 if (have_guest_base
) {
507 if (guest_base
& ~qemu_host_page_mask
) {
508 error_report("Selected guest base not host page aligned");
514 * If reserving host virtual address space, do so now.
515 * Combined with '-B', ensure that the chosen range is free.
520 if (have_guest_base
) {
521 p
= mmap((void *)guest_base
, reserved_va
+ 1, PROT_NONE
,
522 MAP_ANON
| MAP_PRIVATE
| MAP_FIXED
| MAP_EXCL
, -1, 0);
524 p
= mmap(NULL
, reserved_va
+ 1, PROT_NONE
,
525 MAP_ANON
| MAP_PRIVATE
, -1, 0);
527 if (p
== MAP_FAILED
) {
528 const char *err
= strerror(errno
);
529 char *sz
= size_to_str(reserved_va
+ 1);
531 if (have_guest_base
) {
532 error_report("Cannot allocate %s bytes at -B %p for guest "
533 "address space: %s", sz
, (void *)guest_base
, err
);
535 error_report("Cannot allocate %s bytes for guest "
536 "address space: %s", sz
, err
);
540 guest_base
= (uintptr_t)p
;
541 have_guest_base
= true;
543 /* Ensure that mmap_next_start is within range. */
544 if (reserved_va
<= mmap_next_start
) {
545 mmap_next_start
= (reserved_va
/ 4 * 3)
546 & TARGET_PAGE_MASK
& qemu_host_page_mask
;
550 if (loader_exec(filename
, argv
+ optind
, target_environ
, regs
, info
,
552 printf("Error loading %s\n", filename
);
556 for (wrk
= target_environ
; *wrk
; wrk
++) {
560 g_free(target_environ
);
562 if (qemu_loglevel_mask(CPU_LOG_PAGE
)) {
563 FILE *f
= qemu_log_trylock();
565 fprintf(f
, "guest_base %p\n", (void *)guest_base
);
566 fprintf(f
, "page layout changed following binary load\n");
569 fprintf(f
, "end_code 0x" TARGET_ABI_FMT_lx
"\n",
571 fprintf(f
, "start_code 0x" TARGET_ABI_FMT_lx
"\n",
573 fprintf(f
, "start_data 0x" TARGET_ABI_FMT_lx
"\n",
575 fprintf(f
, "end_data 0x" TARGET_ABI_FMT_lx
"\n",
577 fprintf(f
, "start_stack 0x" TARGET_ABI_FMT_lx
"\n",
579 fprintf(f
, "brk 0x" TARGET_ABI_FMT_lx
"\n", info
->brk
);
580 fprintf(f
, "entry 0x" TARGET_ABI_FMT_lx
"\n", info
->entry
);
586 /* build Task State */
587 ts
= g_new0(TaskState
, 1);
593 target_set_brk(info
->brk
);
598 * Now that we've loaded the binary, GUEST_BASE is fixed. Delay
599 * generating the prologue until now so that the prologue can take
600 * the real value of GUEST_BASE into account.
604 target_cpu_init(env
, regs
);
607 gdbserver_start(gdbstub
);
608 gdb_handlesig(cpu
, 0);