qemu

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 "user/guest-base.h"
42
#include "exec/exec-all.h"
43
#include "exec/gdbstub.h"
44
#include "gdbstub/user.h"
45
#include "tcg/startup.h"
46
#include "qemu/timer.h"
47
#include "qemu/envlist.h"
48
#include "qemu/guest-random.h"
49
#include "elf.h"
50
#include "trace/control.h"
51
#include "target_elf.h"
52
#include "cpu_loop-common.h"
53
#include "crypto/init.h"
54
#include "fd-trans.h"
55
#include "signal-common.h"
56
#include "loader.h"
57
#include "user-mmap.h"
58
#include "tcg/perf.h"
59
#include "exec/page-vary.h"
60

61
#ifdef CONFIG_SEMIHOSTING
62
#include "semihosting/semihost.h"
63
#endif
64

65
#ifndef AT_FLAGS_PRESERVE_ARGV0
66
#define AT_FLAGS_PRESERVE_ARGV0_BIT 0
67
#define AT_FLAGS_PRESERVE_ARGV0 (1 << AT_FLAGS_PRESERVE_ARGV0_BIT)
68
#endif
69

70
char *exec_path;
71
char real_exec_path[PATH_MAX];
72

73
static bool opt_one_insn_per_tb;
74
static const char *argv0;
75
static const char *gdbstub;
76
static envlist_t *envlist;
77
static const char *cpu_model;
78
static const char *cpu_type;
79
static const char *seed_optarg;
80
unsigned long mmap_min_addr;
81
uintptr_t guest_base;
82
bool have_guest_base;
83

84
/*
85
 * Used to implement backwards-compatibility for the `-strace`, and
86
 * QEMU_STRACE options. Without this, the QEMU_LOG can be overwritten by
87
 * -strace, or vice versa.
88
 */
89
static bool enable_strace;
90

91
/*
92
 * The last log mask given by the user in an environment variable or argument.
93
 * Used to support command line arguments overriding environment variables.
94
 */
95
static int last_log_mask;
96
static const char *last_log_filename;
97

98
/*
99
 * When running 32-on-64 we should make sure we can fit all of the possible
100
 * guest address space into a contiguous chunk of virtual host memory.
101
 *
102
 * This way we will never overlap with our own libraries or binaries or stack
103
 * or anything else that QEMU maps.
104
 *
105
 * Many cpus reserve the high bit (or more than one for some 64-bit cpus)
106
 * of the address for the kernel.  Some cpus rely on this and user space
107
 * uses the high bit(s) for pointer tagging and the like.  For them, we
108
 * must preserve the expected address space.
109
 */
110
#ifndef MAX_RESERVED_VA
111
# if HOST_LONG_BITS > TARGET_VIRT_ADDR_SPACE_BITS
112
#  if TARGET_VIRT_ADDR_SPACE_BITS == 32 && \
113
      (TARGET_LONG_BITS == 32 || defined(TARGET_ABI32))
114
#   define MAX_RESERVED_VA(CPU)  0xfffffffful
115
#  else
116
#   define MAX_RESERVED_VA(CPU)  ((1ul << TARGET_VIRT_ADDR_SPACE_BITS) - 1)
117
#  endif
118
# else
119
#  define MAX_RESERVED_VA(CPU)  0
120
# endif
121
#endif
122

123
unsigned long reserved_va;
124

125
static void usage(int exitcode);
126

127
static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
128
const char *qemu_uname_release;
129

130
#if !defined(TARGET_DEFAULT_STACK_SIZE)
131
/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
132
   we allocate a bigger stack. Need a better solution, for example
133
   by remapping the process stack directly at the right place */
134
#define TARGET_DEFAULT_STACK_SIZE	8 * 1024 * 1024UL
135
#endif
136

137
unsigned long guest_stack_size = TARGET_DEFAULT_STACK_SIZE;
138

139
/***********************************************************/
140
/* Helper routines for implementing atomic operations.  */
141

142
/* Make sure everything is in a consistent state for calling fork().  */
143
void fork_start(void)
144
{
145
    start_exclusive();
146
    mmap_fork_start();
147
    cpu_list_lock();
148
    qemu_plugin_user_prefork_lock();
149
    gdbserver_fork_start();
150
}
151

152
void fork_end(pid_t pid)
153
{
154
    bool child = pid == 0;
155

156
    qemu_plugin_user_postfork(child);
157
    mmap_fork_end(child);
158
    if (child) {
159
        CPUState *cpu, *next_cpu;
160
        /* Child processes created by fork() only have a single thread.
161
           Discard information about the parent threads.  */
162
        CPU_FOREACH_SAFE(cpu, next_cpu) {
163
            if (cpu != thread_cpu) {
164
                QTAILQ_REMOVE_RCU(&cpus_queue, cpu, node);
165
            }
166
        }
167
        qemu_init_cpu_list();
168
        get_task_state(thread_cpu)->ts_tid = qemu_get_thread_id();
169
    } else {
170
        cpu_list_unlock();
171
    }
172
    gdbserver_fork_end(thread_cpu, pid);
173
    /*
174
     * qemu_init_cpu_list() reinitialized the child exclusive state, but we
175
     * also need to keep current_cpu consistent, so call end_exclusive() for
176
     * both child and parent.
177
     */
178
    end_exclusive();
179
}
180

181
__thread CPUState *thread_cpu;
182

183
bool qemu_cpu_is_self(CPUState *cpu)
184
{
185
    return thread_cpu == cpu;
186
}
187

188
void qemu_cpu_kick(CPUState *cpu)
189
{
190
    cpu_exit(cpu);
191
}
192

193
void task_settid(TaskState *ts)
194
{
195
    if (ts->ts_tid == 0) {
196
        ts->ts_tid = (pid_t)syscall(SYS_gettid);
197
    }
198
}
199

200
void stop_all_tasks(void)
201
{
202
    /*
203
     * We trust that when using NPTL, start_exclusive()
204
     * handles thread stopping correctly.
205
     */
206
    start_exclusive();
207
}
208

209
/* Assumes contents are already zeroed.  */
210
void init_task_state(TaskState *ts)
211
{
212
    long ticks_per_sec;
213
    struct timespec bt;
214

215
    ts->used = 1;
216
    ts->sigaltstack_used = (struct target_sigaltstack) {
217
        .ss_sp = 0,
218
        .ss_size = 0,
219
        .ss_flags = TARGET_SS_DISABLE,
220
    };
221

222
    /* Capture task start time relative to system boot */
223

224
    ticks_per_sec = sysconf(_SC_CLK_TCK);
225

226
    if ((ticks_per_sec > 0) && !clock_gettime(CLOCK_BOOTTIME, &bt)) {
227
        /* start_boottime is expressed in clock ticks */
228
        ts->start_boottime = bt.tv_sec * (uint64_t) ticks_per_sec;
229
        ts->start_boottime += bt.tv_nsec * (uint64_t) ticks_per_sec /
230
                              NANOSECONDS_PER_SECOND;
231
    }
232
}
233

234
CPUArchState *cpu_copy(CPUArchState *env)
235
{
236
    CPUState *cpu = env_cpu(env);
237
    CPUState *new_cpu = cpu_create(cpu_type);
238
    CPUArchState *new_env = cpu_env(new_cpu);
239
    CPUBreakpoint *bp;
240

241
    /* Reset non arch specific state */
242
    cpu_reset(new_cpu);
243

244
    new_cpu->tcg_cflags = cpu->tcg_cflags;
245
    memcpy(new_env, env, sizeof(CPUArchState));
246
#if defined(TARGET_I386) || defined(TARGET_X86_64)
247
    new_env->gdt.base = target_mmap(0, sizeof(uint64_t) * TARGET_GDT_ENTRIES,
248
                                    PROT_READ | PROT_WRITE,
249
                                    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
250
    memcpy(g2h_untagged(new_env->gdt.base), g2h_untagged(env->gdt.base),
251
           sizeof(uint64_t) * TARGET_GDT_ENTRIES);
252
    OBJECT(new_cpu)->free = OBJECT(cpu)->free;
253
#endif
254

255
    /* Clone all break/watchpoints.
256
       Note: Once we support ptrace with hw-debug register access, make sure
257
       BP_CPU break/watchpoints are handled correctly on clone. */
258
    QTAILQ_INIT(&new_cpu->breakpoints);
259
    QTAILQ_FOREACH(bp, &cpu->breakpoints, entry) {
260
        cpu_breakpoint_insert(new_cpu, bp->pc, bp->flags, NULL);
261
    }
262

263
    return new_env;
264
}
265

266
static void handle_arg_help(const char *arg)
267
{
268
    usage(EXIT_SUCCESS);
269
}
270

271
static void handle_arg_log(const char *arg)
272
{
273
    last_log_mask = qemu_str_to_log_mask(arg);
274
    if (!last_log_mask) {
275
        qemu_print_log_usage(stdout);
276
        exit(EXIT_FAILURE);
277
    }
278
}
279

280
static void handle_arg_dfilter(const char *arg)
281
{
282
    qemu_set_dfilter_ranges(arg, &error_fatal);
283
}
284

285
static void handle_arg_log_filename(const char *arg)
286
{
287
    last_log_filename = arg;
288
}
289

290
static void handle_arg_set_env(const char *arg)
291
{
292
    char *r, *p, *token;
293
    r = p = strdup(arg);
294
    while ((token = strsep(&p, ",")) != NULL) {
295
        if (envlist_setenv(envlist, token) != 0) {
296
            usage(EXIT_FAILURE);
297
        }
298
    }
299
    free(r);
300
}
301

302
static void handle_arg_unset_env(const char *arg)
303
{
304
    char *r, *p, *token;
305
    r = p = strdup(arg);
306
    while ((token = strsep(&p, ",")) != NULL) {
307
        if (envlist_unsetenv(envlist, token) != 0) {
308
            usage(EXIT_FAILURE);
309
        }
310
    }
311
    free(r);
312
}
313

314
static void handle_arg_argv0(const char *arg)
315
{
316
    argv0 = strdup(arg);
317
}
318

319
static void handle_arg_stack_size(const char *arg)
320
{
321
    char *p;
322
    guest_stack_size = strtoul(arg, &p, 0);
323
    if (guest_stack_size == 0) {
324
        usage(EXIT_FAILURE);
325
    }
326

327
    if (*p == 'M') {
328
        guest_stack_size *= MiB;
329
    } else if (*p == 'k' || *p == 'K') {
330
        guest_stack_size *= KiB;
331
    }
332
}
333

334
static void handle_arg_ld_prefix(const char *arg)
335
{
336
    interp_prefix = strdup(arg);
337
}
338

339
static void handle_arg_pagesize(const char *arg)
340
{
341
    unsigned size, want = qemu_real_host_page_size();
342

343
    if (qemu_strtoui(arg, NULL, 10, &size) || size != want) {
344
        warn_report("Deprecated page size option cannot "
345
                    "change host page size (%u)", want);
346
    }
347
}
348

349
static void handle_arg_seed(const char *arg)
350
{
351
    seed_optarg = arg;
352
}
353

354
static void handle_arg_gdb(const char *arg)
355
{
356
    gdbstub = g_strdup(arg);
357
}
358

359
static void handle_arg_uname(const char *arg)
360
{
361
    qemu_uname_release = strdup(arg);
362
}
363

364
static void handle_arg_cpu(const char *arg)
365
{
366
    cpu_model = strdup(arg);
367
    if (cpu_model == NULL || is_help_option(cpu_model)) {
368
        list_cpus();
369
        exit(EXIT_FAILURE);
370
    }
371
}
372

373
static void handle_arg_guest_base(const char *arg)
374
{
375
    guest_base = strtol(arg, NULL, 0);
376
    have_guest_base = true;
377
}
378

379
static void handle_arg_reserved_va(const char *arg)
380
{
381
    char *p;
382
    int shift = 0;
383
    unsigned long val;
384

385
    val = strtoul(arg, &p, 0);
386
    switch (*p) {
387
    case 'k':
388
    case 'K':
389
        shift = 10;
390
        break;
391
    case 'M':
392
        shift = 20;
393
        break;
394
    case 'G':
395
        shift = 30;
396
        break;
397
    }
398
    if (shift) {
399
        unsigned long unshifted = val;
400
        p++;
401
        val <<= shift;
402
        if (val >> shift != unshifted) {
403
            fprintf(stderr, "Reserved virtual address too big\n");
404
            exit(EXIT_FAILURE);
405
        }
406
    }
407
    if (*p) {
408
        fprintf(stderr, "Unrecognised -R size suffix '%s'\n", p);
409
        exit(EXIT_FAILURE);
410
    }
411
    /* The representation is size - 1, with 0 remaining "default". */
412
    reserved_va = val ? val - 1 : 0;
413
}
414

415
static void handle_arg_one_insn_per_tb(const char *arg)
416
{
417
    opt_one_insn_per_tb = true;
418
}
419

420
static void handle_arg_strace(const char *arg)
421
{
422
    enable_strace = true;
423
}
424

425
static void handle_arg_version(const char *arg)
426
{
427
    printf("qemu-" TARGET_NAME " version " QEMU_FULL_VERSION
428
           "\n" QEMU_COPYRIGHT "\n");
429
    exit(EXIT_SUCCESS);
430
}
431

432
static void handle_arg_trace(const char *arg)
433
{
434
    trace_opt_parse(arg);
435
}
436

437
#if defined(TARGET_XTENSA)
438
static void handle_arg_abi_call0(const char *arg)
439
{
440
    xtensa_set_abi_call0();
441
}
442
#endif
443

444
static void handle_arg_perfmap(const char *arg)
445
{
446
    perf_enable_perfmap();
447
}
448

449
static void handle_arg_jitdump(const char *arg)
450
{
451
    perf_enable_jitdump();
452
}
453

454
static QemuPluginList plugins = QTAILQ_HEAD_INITIALIZER(plugins);
455

456
#ifdef CONFIG_PLUGIN
457
static void handle_arg_plugin(const char *arg)
458
{
459
    qemu_plugin_opt_parse(arg, &plugins);
460
}
461
#endif
462

463
struct qemu_argument {
464
    const char *argv;
465
    const char *env;
466
    bool has_arg;
467
    void (*handle_opt)(const char *arg);
468
    const char *example;
469
    const char *help;
470
};
471

472
static const struct qemu_argument arg_table[] = {
473
    {"h",          "",                 false, handle_arg_help,
474
     "",           "print this help"},
475
    {"help",       "",                 false, handle_arg_help,
476
     "",           ""},
477
    {"g",          "QEMU_GDB",         true,  handle_arg_gdb,
478
     "port",       "wait gdb connection to 'port'"},
479
    {"L",          "QEMU_LD_PREFIX",   true,  handle_arg_ld_prefix,
480
     "path",       "set the elf interpreter prefix to 'path'"},
481
    {"s",          "QEMU_STACK_SIZE",  true,  handle_arg_stack_size,
482
     "size",       "set the stack size to 'size' bytes"},
483
    {"cpu",        "QEMU_CPU",         true,  handle_arg_cpu,
484
     "model",      "select CPU (-cpu help for list)"},
485
    {"E",          "QEMU_SET_ENV",     true,  handle_arg_set_env,
486
     "var=value",  "sets targets environment variable (see below)"},
487
    {"U",          "QEMU_UNSET_ENV",   true,  handle_arg_unset_env,
488
     "var",        "unsets targets environment variable (see below)"},
489
    {"0",          "QEMU_ARGV0",       true,  handle_arg_argv0,
490
     "argv0",      "forces target process argv[0] to be 'argv0'"},
491
    {"r",          "QEMU_UNAME",       true,  handle_arg_uname,
492
     "uname",      "set qemu uname release string to 'uname'"},
493
    {"B",          "QEMU_GUEST_BASE",  true,  handle_arg_guest_base,
494
     "address",    "set guest_base address to 'address'"},
495
    {"R",          "QEMU_RESERVED_VA", true,  handle_arg_reserved_va,
496
     "size",       "reserve 'size' bytes for guest virtual address space"},
497
    {"d",          "QEMU_LOG",         true,  handle_arg_log,
498
     "item[,...]", "enable logging of specified items "
499
     "(use '-d help' for a list of items)"},
500
    {"dfilter",    "QEMU_DFILTER",     true,  handle_arg_dfilter,
501
     "range[,...]","filter logging based on address range"},
502
    {"D",          "QEMU_LOG_FILENAME", true, handle_arg_log_filename,
503
     "logfile",     "write logs to 'logfile' (default stderr)"},
504
    {"p",          "QEMU_PAGESIZE",    true,  handle_arg_pagesize,
505
     "pagesize",   "deprecated change to host page size"},
506
    {"one-insn-per-tb",
507
                   "QEMU_ONE_INSN_PER_TB",  false, handle_arg_one_insn_per_tb,
508
     "",           "run with one guest instruction per emulated TB"},
509
    {"strace",     "QEMU_STRACE",      false, handle_arg_strace,
510
     "",           "log system calls"},
511
    {"seed",       "QEMU_RAND_SEED",   true,  handle_arg_seed,
512
     "",           "Seed for pseudo-random number generator"},
513
    {"trace",      "QEMU_TRACE",       true,  handle_arg_trace,
514
     "",           "[[enable=]<pattern>][,events=<file>][,file=<file>]"},
515
#ifdef CONFIG_PLUGIN
516
    {"plugin",     "QEMU_PLUGIN",      true,  handle_arg_plugin,
517
     "",           "[file=]<file>[,<argname>=<argvalue>]"},
518
#endif
519
    {"version",    "QEMU_VERSION",     false, handle_arg_version,
520
     "",           "display version information and exit"},
521
#if defined(TARGET_XTENSA)
522
    {"xtensa-abi-call0", "QEMU_XTENSA_ABI_CALL0", false, handle_arg_abi_call0,
523
     "",           "assume CALL0 Xtensa ABI"},
524
#endif
525
    {"perfmap",    "QEMU_PERFMAP",     false, handle_arg_perfmap,
526
     "",           "Generate a /tmp/perf-${pid}.map file for perf"},
527
    {"jitdump",    "QEMU_JITDUMP",     false, handle_arg_jitdump,
528
     "",           "Generate a jit-${pid}.dump file for perf"},
529
    {NULL, NULL, false, NULL, NULL, NULL}
530
};
531

532
static void usage(int exitcode)
533
{
534
    const struct qemu_argument *arginfo;
535
    int maxarglen;
536
    int maxenvlen;
537

538
    printf("usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
539
           "Linux CPU emulator (compiled for " TARGET_NAME " emulation)\n"
540
           "\n"
541
           "Options and associated environment variables:\n"
542
           "\n");
543

544
    /* Calculate column widths. We must always have at least enough space
545
     * for the column header.
546
     */
547
    maxarglen = strlen("Argument");
548
    maxenvlen = strlen("Env-variable");
549

550
    for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
551
        int arglen = strlen(arginfo->argv);
552
        if (arginfo->has_arg) {
553
            arglen += strlen(arginfo->example) + 1;
554
        }
555
        if (strlen(arginfo->env) > maxenvlen) {
556
            maxenvlen = strlen(arginfo->env);
557
        }
558
        if (arglen > maxarglen) {
559
            maxarglen = arglen;
560
        }
561
    }
562

563
    printf("%-*s %-*s Description\n", maxarglen+1, "Argument",
564
            maxenvlen, "Env-variable");
565

566
    for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
567
        if (arginfo->has_arg) {
568
            printf("-%s %-*s %-*s %s\n", arginfo->argv,
569
                   (int)(maxarglen - strlen(arginfo->argv) - 1),
570
                   arginfo->example, maxenvlen, arginfo->env, arginfo->help);
571
        } else {
572
            printf("-%-*s %-*s %s\n", maxarglen, arginfo->argv,
573
                    maxenvlen, arginfo->env,
574
                    arginfo->help);
575
        }
576
    }
577

578
    printf("\n"
579
           "Defaults:\n"
580
           "QEMU_LD_PREFIX  = %s\n"
581
           "QEMU_STACK_SIZE = %ld byte\n",
582
           interp_prefix,
583
           guest_stack_size);
584

585
    printf("\n"
586
           "You can use -E and -U options or the QEMU_SET_ENV and\n"
587
           "QEMU_UNSET_ENV environment variables to set and unset\n"
588
           "environment variables for the target process.\n"
589
           "It is possible to provide several variables by separating them\n"
590
           "by commas in getsubopt(3) style. Additionally it is possible to\n"
591
           "provide the -E and -U options multiple times.\n"
592
           "The following lines are equivalent:\n"
593
           "    -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
594
           "    -E var1=val2,var2=val2 -U LD_PRELOAD,LD_DEBUG\n"
595
           "    QEMU_SET_ENV=var1=val2,var2=val2 QEMU_UNSET_ENV=LD_PRELOAD,LD_DEBUG\n"
596
           "Note that if you provide several changes to a single variable\n"
597
           "the last change will stay in effect.\n"
598
           "\n"
599
           QEMU_HELP_BOTTOM "\n");
600

601
    exit(exitcode);
602
}
603

604
static int parse_args(int argc, char **argv)
605
{
606
    const char *r;
607
    int optind;
608
    const struct qemu_argument *arginfo;
609

610
    for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
611
        if (arginfo->env == NULL) {
612
            continue;
613
        }
614

615
        r = getenv(arginfo->env);
616
        if (r != NULL) {
617
            arginfo->handle_opt(r);
618
        }
619
    }
620

621
    optind = 1;
622
    for (;;) {
623
        if (optind >= argc) {
624
            break;
625
        }
626
        r = argv[optind];
627
        if (r[0] != '-') {
628
            break;
629
        }
630
        optind++;
631
        r++;
632
        if (!strcmp(r, "-")) {
633
            break;
634
        }
635
        /* Treat --foo the same as -foo.  */
636
        if (r[0] == '-') {
637
            r++;
638
        }
639

640
        for (arginfo = arg_table; arginfo->handle_opt != NULL; arginfo++) {
641
            if (!strcmp(r, arginfo->argv)) {
642
                if (arginfo->has_arg) {
643
                    if (optind >= argc) {
644
                        (void) fprintf(stderr,
645
                            "qemu: missing argument for option '%s'\n", r);
646
                        exit(EXIT_FAILURE);
647
                    }
648
                    arginfo->handle_opt(argv[optind]);
649
                    optind++;
650
                } else {
651
                    arginfo->handle_opt(NULL);
652
                }
653
                break;
654
            }
655
        }
656

657
        /* no option matched the current argv */
658
        if (arginfo->handle_opt == NULL) {
659
            (void) fprintf(stderr, "qemu: unknown option '%s'\n", r);
660
            exit(EXIT_FAILURE);
661
        }
662
    }
663

664
    if (optind >= argc) {
665
        (void) fprintf(stderr, "qemu: no user program specified\n");
666
        exit(EXIT_FAILURE);
667
    }
668

669
    exec_path = argv[optind];
670

671
    return optind;
672
}
673

674
int main(int argc, char **argv, char **envp)
675
{
676
    struct target_pt_regs regs1, *regs = &regs1;
677
    struct image_info info1, *info = &info1;
678
    struct linux_binprm bprm;
679
    TaskState *ts;
680
    CPUArchState *env;
681
    CPUState *cpu;
682
    int optind;
683
    char **target_environ, **wrk;
684
    char **target_argv;
685
    int target_argc;
686
    int i;
687
    int ret;
688
    int execfd;
689
    int host_page_size;
690
    unsigned long max_reserved_va;
691
    bool preserve_argv0;
692

693
    error_init(argv[0]);
694
    module_call_init(MODULE_INIT_TRACE);
695
    qemu_init_cpu_list();
696
    module_call_init(MODULE_INIT_QOM);
697

698
    envlist = envlist_create();
699

700
    /*
701
     * add current environment into the list
702
     * envlist_setenv adds to the front of the list; to preserve environ
703
     * order add from back to front
704
     */
705
    for (wrk = environ; *wrk != NULL; wrk++) {
706
        continue;
707
    }
708
    while (wrk != environ) {
709
        wrk--;
710
        (void) envlist_setenv(envlist, *wrk);
711
    }
712

713
    /* Read the stack limit from the kernel.  If it's "unlimited",
714
       then we can do little else besides use the default.  */
715
    {
716
        struct rlimit lim;
717
        if (getrlimit(RLIMIT_STACK, &lim) == 0
718
            && lim.rlim_cur != RLIM_INFINITY
719
            && lim.rlim_cur == (target_long)lim.rlim_cur
720
            && lim.rlim_cur > guest_stack_size) {
721
            guest_stack_size = lim.rlim_cur;
722
        }
723
    }
724

725
    cpu_model = NULL;
726

727
    qemu_add_opts(&qemu_trace_opts);
728
    qemu_plugin_add_opts();
729

730
    optind = parse_args(argc, argv);
731

732
    qemu_set_log_filename_flags(last_log_filename,
733
                                last_log_mask | (enable_strace * LOG_STRACE),
734
                                &error_fatal);
735

736
    if (!trace_init_backends()) {
737
        exit(1);
738
    }
739
    trace_init_file();
740
    qemu_plugin_load_list(&plugins, &error_fatal);
741

742
    /* Zero out regs */
743
    memset(regs, 0, sizeof(struct target_pt_regs));
744

745
    /* Zero out image_info */
746
    memset(info, 0, sizeof(struct image_info));
747

748
    memset(&bprm, 0, sizeof (bprm));
749

750
    /* Scan interp_prefix dir for replacement files. */
751
    init_paths(interp_prefix);
752

753
    init_qemu_uname_release();
754

755
    /*
756
     * Manage binfmt-misc open-binary flag
757
     */
758
    errno = 0;
759
    execfd = qemu_getauxval(AT_EXECFD);
760
    if (errno != 0) {
761
        execfd = open(exec_path, O_RDONLY);
762
        if (execfd < 0) {
763
            printf("Error while loading %s: %s\n", exec_path, strerror(errno));
764
            _exit(EXIT_FAILURE);
765
        }
766
    }
767

768
    /* Resolve executable file name to full path name */
769
    if (realpath(exec_path, real_exec_path)) {
770
        exec_path = real_exec_path;
771
    }
772

773
    /*
774
     * get binfmt_misc flags
775
     */
776
    preserve_argv0 = !!(qemu_getauxval(AT_FLAGS) & AT_FLAGS_PRESERVE_ARGV0);
777

778
    /*
779
     * Manage binfmt-misc preserve-arg[0] flag
780
     *    argv[optind]     full path to the binary
781
     *    argv[optind + 1] original argv[0]
782
     */
783
    if (optind + 1 < argc && preserve_argv0) {
784
        optind++;
785
    }
786

787
    if (cpu_model == NULL) {
788
        cpu_model = cpu_get_model(get_elf_eflags(execfd));
789
    }
790
    cpu_type = parse_cpu_option(cpu_model);
791

792
    /* init tcg before creating CPUs */
793
    {
794
        AccelState *accel = current_accel();
795
        AccelClass *ac = ACCEL_GET_CLASS(accel);
796

797
        accel_init_interfaces(ac);
798
        object_property_set_bool(OBJECT(accel), "one-insn-per-tb",
799
                                 opt_one_insn_per_tb, &error_abort);
800
        ac->init_machine(NULL);
801
    }
802

803
    /*
804
     * Finalize page size before creating CPUs.
805
     * This will do nothing if !TARGET_PAGE_BITS_VARY.
806
     * The most efficient setting is to match the host.
807
     */
808
    host_page_size = qemu_real_host_page_size();
809
    set_preferred_target_page_bits(ctz32(host_page_size));
810
    finalize_target_page_bits();
811

812
    cpu = cpu_create(cpu_type);
813
    env = cpu_env(cpu);
814
    cpu_reset(cpu);
815
    thread_cpu = cpu;
816

817
    /*
818
     * Reserving too much vm space via mmap can run into problems with rlimits,
819
     * oom due to page table creation, etc.  We will still try it, if directed
820
     * by the command-line option, but not by default. Unless we're running a
821
     * target address space of 32 or fewer bits on a host with 64 bits.
822
     */
823
    max_reserved_va = MAX_RESERVED_VA(cpu);
824
    if (reserved_va != 0) {
825
        if ((reserved_va + 1) % host_page_size) {
826
            char *s = size_to_str(host_page_size);
827
            fprintf(stderr, "Reserved virtual address not aligned mod %s\n", s);
828
            g_free(s);
829
            exit(EXIT_FAILURE);
830
        }
831
        if (max_reserved_va && reserved_va > max_reserved_va) {
832
            fprintf(stderr, "Reserved virtual address too big\n");
833
            exit(EXIT_FAILURE);
834
        }
835
    } else if (HOST_LONG_BITS == 64 && TARGET_VIRT_ADDR_SPACE_BITS <= 32) {
836
        /* MAX_RESERVED_VA + 1 is a large power of 2, so is aligned. */
837
        reserved_va = max_reserved_va;
838
    }
839

840
    /*
841
     * Temporarily disable
842
     *   "comparison is always false due to limited range of data type"
843
     * due to comparison between (possible) uint64_t and uintptr_t.
844
     */
845
#pragma GCC diagnostic push
846
#pragma GCC diagnostic ignored "-Wtype-limits"
847
#pragma GCC diagnostic ignored "-Wtautological-compare"
848

849
    /*
850
     * Select an initial value for task_unmapped_base that is in range.
851
     */
852
    if (reserved_va) {
853
        if (TASK_UNMAPPED_BASE < reserved_va) {
854
            task_unmapped_base = TASK_UNMAPPED_BASE;
855
        } else {
856
            /* The most common default formula is TASK_SIZE / 3. */
857
            task_unmapped_base = TARGET_PAGE_ALIGN(reserved_va / 3);
858
        }
859
    } else if (TASK_UNMAPPED_BASE < UINTPTR_MAX) {
860
        task_unmapped_base = TASK_UNMAPPED_BASE;
861
    } else {
862
        /* 32-bit host: pick something medium size. */
863
        task_unmapped_base = 0x10000000;
864
    }
865
    mmap_next_start = task_unmapped_base;
866

867
    /* Similarly for elf_et_dyn_base. */
868
    if (reserved_va) {
869
        if (ELF_ET_DYN_BASE < reserved_va) {
870
            elf_et_dyn_base = ELF_ET_DYN_BASE;
871
        } else {
872
            /* The most common default formula is TASK_SIZE / 3 * 2. */
873
            elf_et_dyn_base = TARGET_PAGE_ALIGN(reserved_va / 3) * 2;
874
        }
875
    } else if (ELF_ET_DYN_BASE < UINTPTR_MAX) {
876
        elf_et_dyn_base = ELF_ET_DYN_BASE;
877
    } else {
878
        /* 32-bit host: pick something medium size. */
879
        elf_et_dyn_base = 0x18000000;
880
    }
881

882
#pragma GCC diagnostic pop
883

884
    {
885
        Error *err = NULL;
886
        if (seed_optarg != NULL) {
887
            qemu_guest_random_seed_main(seed_optarg, &err);
888
        } else {
889
            qcrypto_init(&err);
890
        }
891
        if (err) {
892
            error_reportf_err(err, "cannot initialize crypto: ");
893
            exit(1);
894
        }
895
    }
896

897
    target_environ = envlist_to_environ(envlist, NULL);
898
    envlist_free(envlist);
899

900
    /*
901
     * Read in mmap_min_addr kernel parameter.  This value is used
902
     * When loading the ELF image to determine whether guest_base
903
     * is needed.  It is also used in mmap_find_vma.
904
     */
905
    {
906
        FILE *fp;
907

908
        if ((fp = fopen("/proc/sys/vm/mmap_min_addr", "r")) != NULL) {
909
            unsigned long tmp;
910
            if (fscanf(fp, "%lu", &tmp) == 1 && tmp != 0) {
911
                mmap_min_addr = MAX(tmp, host_page_size);
912
                qemu_log_mask(CPU_LOG_PAGE, "host mmap_min_addr=0x%lx\n",
913
                              mmap_min_addr);
914
            }
915
            fclose(fp);
916
        }
917
    }
918

919
    /*
920
     * We prefer to not make NULL pointers accessible to QEMU.
921
     * If we're in a chroot with no /proc, fall back to 1 page.
922
     */
923
    if (mmap_min_addr == 0) {
924
        mmap_min_addr = host_page_size;
925
        qemu_log_mask(CPU_LOG_PAGE,
926
                      "host mmap_min_addr=0x%lx (fallback)\n",
927
                      mmap_min_addr);
928
    }
929

930
    /*
931
     * Prepare copy of argv vector for target.
932
     */
933
    target_argc = argc - optind;
934
    target_argv = g_new0(char *, target_argc + 1);
935

936
    /*
937
     * If argv0 is specified (using '-0' switch) we replace
938
     * argv[0] pointer with the given one.
939
     */
940
    i = 0;
941
    if (argv0 != NULL) {
942
        target_argv[i++] = strdup(argv0);
943
    }
944
    for (; i < target_argc; i++) {
945
        target_argv[i] = strdup(argv[optind + i]);
946
    }
947
    target_argv[target_argc] = NULL;
948

949
    ts = g_new0(TaskState, 1);
950
    init_task_state(ts);
951
    /* build Task State */
952
    ts->info = info;
953
    ts->bprm = &bprm;
954
    cpu->opaque = ts;
955
    task_settid(ts);
956

957
    fd_trans_init();
958

959
    ret = loader_exec(execfd, exec_path, target_argv, target_environ, regs,
960
        info, &bprm);
961
    if (ret != 0) {
962
        printf("Error while loading %s: %s\n", exec_path, strerror(-ret));
963
        _exit(EXIT_FAILURE);
964
    }
965

966
    for (wrk = target_environ; *wrk; wrk++) {
967
        g_free(*wrk);
968
    }
969

970
    g_free(target_environ);
971

972
    if (qemu_loglevel_mask(CPU_LOG_PAGE)) {
973
        FILE *f = qemu_log_trylock();
974
        if (f) {
975
            fprintf(f, "guest_base  %p\n", (void *)guest_base);
976
            fprintf(f, "page layout changed following binary load\n");
977
            page_dump(f);
978

979
            fprintf(f, "end_code    0x" TARGET_ABI_FMT_lx "\n",
980
                    info->end_code);
981
            fprintf(f, "start_code  0x" TARGET_ABI_FMT_lx "\n",
982
                    info->start_code);
983
            fprintf(f, "start_data  0x" TARGET_ABI_FMT_lx "\n",
984
                    info->start_data);
985
            fprintf(f, "end_data    0x" TARGET_ABI_FMT_lx "\n",
986
                    info->end_data);
987
            fprintf(f, "start_stack 0x" TARGET_ABI_FMT_lx "\n",
988
                    info->start_stack);
989
            fprintf(f, "brk         0x" TARGET_ABI_FMT_lx "\n",
990
                    info->brk);
991
            fprintf(f, "entry       0x" TARGET_ABI_FMT_lx "\n",
992
                    info->entry);
993
            fprintf(f, "argv_start  0x" TARGET_ABI_FMT_lx "\n",
994
                    info->argv);
995
            fprintf(f, "env_start   0x" TARGET_ABI_FMT_lx "\n",
996
                    info->envp);
997
            fprintf(f, "auxv_start  0x" TARGET_ABI_FMT_lx "\n",
998
                    info->saved_auxv);
999
            qemu_log_unlock(f);
1000
        }
1001
    }
1002

1003
    target_set_brk(info->brk);
1004
    syscall_init();
1005
    signal_init();
1006

1007
    /* Now that we've loaded the binary, GUEST_BASE is fixed.  Delay
1008
       generating the prologue until now so that the prologue can take
1009
       the real value of GUEST_BASE into account.  */
1010
    tcg_prologue_init();
1011

1012
    target_cpu_copy_regs(env, regs);
1013

1014
    if (gdbstub) {
1015
        if (gdbserver_start(gdbstub) < 0) {
1016
            fprintf(stderr, "qemu: could not open gdbserver on %s\n",
1017
                    gdbstub);
1018
            exit(EXIT_FAILURE);
1019
        }
1020
        gdb_handlesig(cpu, 0, NULL, NULL, 0);
1021
    }
1022

1023
#ifdef CONFIG_SEMIHOSTING
1024
    qemu_semihosting_guestfd_init();
1025
#endif
1026

1027
    cpu_loop(env);
1028
    /* never exits */
1029
    return 0;
1030
}
1031