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