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