xref: /openbmc/qemu/bsd-user/main.c (revision f0f7f9dca986bebf2a0b88dd83f84f5e39a61462)
1 /*
2  *  qemu bsd user main
3  *
4  *  Copyright (c) 2003-2008 Fabrice Bellard
5  *  Copyright (c) 2013-14 Stacey Son
6  *
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.
11  *
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.
16  *
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/>.
19  */
20 
21 #include <sys/types.h>
22 #include <sys/time.h>
23 #include <sys/resource.h>
24 #include <sys/sysctl.h>
25 
26 #include "qemu/osdep.h"
27 #include "qemu-common.h"
28 #include "qemu/units.h"
29 #include "qemu/accel.h"
30 #include "sysemu/tcg.h"
31 #include "qemu-version.h"
32 #include <machine/trap.h>
33 
34 #include "qapi/error.h"
35 #include "qemu.h"
36 #include "qemu/config-file.h"
37 #include "qemu/error-report.h"
38 #include "qemu/path.h"
39 #include "qemu/help_option.h"
40 #include "qemu/module.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/cutils.h"
46 #include "exec/log.h"
47 #include "trace/control.h"
48 #include "crypto/init.h"
49 #include "qemu/guest-random.h"
50 
51 #include "host-os.h"
52 #include "target_arch_cpu.h"
53 
54 int singlestep;
55 unsigned long mmap_min_addr;
56 uintptr_t guest_base;
57 bool have_guest_base;
58 unsigned long reserved_va;
59 
60 static const char *interp_prefix = CONFIG_QEMU_INTERP_PREFIX;
61 const char *qemu_uname_release;
62 enum BSDType bsd_type;
63 char qemu_proc_pathname[PATH_MAX];  /* full path to exeutable */
64 
65 unsigned long target_maxtsiz = TARGET_MAXTSIZ;   /* max text size */
66 unsigned long target_dfldsiz = TARGET_DFLDSIZ;   /* initial data size limit */
67 unsigned long target_maxdsiz = TARGET_MAXDSIZ;   /* max data size */
68 unsigned long target_dflssiz = TARGET_DFLSSIZ;   /* initial data size limit */
69 unsigned long target_maxssiz = TARGET_MAXSSIZ;   /* max stack size */
70 unsigned long target_sgrowsiz = TARGET_SGROWSIZ; /* amount to grow stack */
71 
72 
73 void fork_start(void)
74 {
75 }
76 
77 void fork_end(int child)
78 {
79     if (child) {
80         gdbserver_fork(thread_cpu);
81     }
82 }
83 
84 void cpu_loop(CPUArchState *env)
85 {
86     target_cpu_loop(env);
87 }
88 
89 static void usage(void)
90 {
91     printf("qemu-" TARGET_NAME " version " QEMU_FULL_VERSION
92            "\n" QEMU_COPYRIGHT "\n"
93            "usage: qemu-" TARGET_NAME " [options] program [arguments...]\n"
94            "BSD CPU emulator (compiled for %s emulation)\n"
95            "\n"
96            "Standard options:\n"
97            "-h                print this help\n"
98            "-g port           wait gdb connection to port\n"
99            "-L path           set the elf interpreter prefix (default=%s)\n"
100            "-s size           set the stack size in bytes (default=%ld)\n"
101            "-cpu model        select CPU (-cpu help for list)\n"
102            "-drop-ld-preload  drop LD_PRELOAD for target process\n"
103            "-E var=value      sets/modifies targets environment variable(s)\n"
104            "-U var            unsets targets environment variable(s)\n"
105            "-B address        set guest_base address to address\n"
106            "-bsd type         select emulated BSD type FreeBSD/NetBSD/OpenBSD (default)\n"
107            "\n"
108            "Debug options:\n"
109            "-d item1[,...]    enable logging of specified items\n"
110            "                  (use '-d help' for a list of log items)\n"
111            "-D logfile        write logs to 'logfile' (default stderr)\n"
112            "-singlestep       always run in singlestep mode\n"
113            "-strace           log system calls\n"
114            "-trace            [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
115            "                  specify tracing options\n"
116            "\n"
117            "Environment variables:\n"
118            "QEMU_STRACE       Print system calls and arguments similar to the\n"
119            "                  'strace' program.  Enable by setting to any value.\n"
120            "You can use -E and -U options to set/unset environment variables\n"
121            "for target process.  It is possible to provide several variables\n"
122            "by repeating the option.  For example:\n"
123            "    -E var1=val2 -E var2=val2 -U LD_PRELOAD -U LD_DEBUG\n"
124            "Note that if you provide several changes to single variable\n"
125            "last change will stay in effect.\n"
126            "\n"
127            QEMU_HELP_BOTTOM "\n"
128            ,
129            TARGET_NAME,
130            interp_prefix,
131            target_dflssiz);
132     exit(1);
133 }
134 
135 __thread CPUState *thread_cpu;
136 
137 bool qemu_cpu_is_self(CPUState *cpu)
138 {
139     return thread_cpu == cpu;
140 }
141 
142 void qemu_cpu_kick(CPUState *cpu)
143 {
144     cpu_exit(cpu);
145 }
146 
147 /* Assumes contents are already zeroed.  */
148 void init_task_state(TaskState *ts)
149 {
150     int i;
151 
152     ts->used = 1;
153     ts->first_free = ts->sigqueue_table;
154     for (i = 0; i < MAX_SIGQUEUE_SIZE - 1; i++) {
155         ts->sigqueue_table[i].next = &ts->sigqueue_table[i + 1];
156     }
157     ts->sigqueue_table[i].next = NULL;
158 }
159 
160 void gemu_log(const char *fmt, ...)
161 {
162     va_list ap;
163 
164     va_start(ap, fmt);
165     vfprintf(stderr, fmt, ap);
166     va_end(ap);
167 }
168 
169 static void
170 adjust_ssize(void)
171 {
172     struct rlimit rl;
173 
174     if (getrlimit(RLIMIT_STACK, &rl) != 0) {
175         return;
176     }
177 
178     target_maxssiz = MIN(target_maxssiz, rl.rlim_max);
179     target_dflssiz = MIN(MAX(target_dflssiz, rl.rlim_cur), target_maxssiz);
180 
181     rl.rlim_max = target_maxssiz;
182     rl.rlim_cur = target_dflssiz;
183     setrlimit(RLIMIT_STACK, &rl);
184 }
185 
186 static void save_proc_pathname(char *argv0)
187 {
188     int mib[4];
189     size_t len;
190 
191     mib[0] = CTL_KERN;
192     mib[1] = KERN_PROC;
193     mib[2] = KERN_PROC_PATHNAME;
194     mib[3] = -1;
195 
196     len = sizeof(qemu_proc_pathname);
197     if (sysctl(mib, 4, qemu_proc_pathname, &len, NULL, 0)) {
198         perror("sysctl");
199     }
200 }
201 
202 int main(int argc, char **argv)
203 {
204     const char *filename;
205     const char *cpu_model;
206     const char *cpu_type;
207     const char *log_file = NULL;
208     const char *log_mask = NULL;
209     const char *seed_optarg = NULL;
210     struct target_pt_regs regs1, *regs = &regs1;
211     struct image_info info1, *info = &info1;
212     struct bsd_binprm bprm;
213     TaskState *ts;
214     CPUArchState *env;
215     CPUState *cpu;
216     int optind, rv;
217     const char *r;
218     const char *gdbstub = NULL;
219     char **target_environ, **wrk;
220     envlist_t *envlist = NULL;
221     bsd_type = HOST_DEFAULT_BSD_TYPE;
222 
223     adjust_ssize();
224 
225     if (argc <= 1) {
226         usage();
227     }
228 
229     save_proc_pathname(argv[0]);
230 
231     error_init(argv[0]);
232     module_call_init(MODULE_INIT_TRACE);
233     qemu_init_cpu_list();
234     module_call_init(MODULE_INIT_QOM);
235 
236     envlist = envlist_create();
237 
238     /* add current environment into the list */
239     for (wrk = environ; *wrk != NULL; wrk++) {
240         (void) envlist_setenv(envlist, *wrk);
241     }
242 
243     cpu_model = NULL;
244 
245     qemu_add_opts(&qemu_trace_opts);
246 
247     optind = 1;
248     for (;;) {
249         if (optind >= argc) {
250             break;
251         }
252         r = argv[optind];
253         if (r[0] != '-') {
254             break;
255         }
256         optind++;
257         r++;
258         if (!strcmp(r, "-")) {
259             break;
260         } else if (!strcmp(r, "d")) {
261             if (optind >= argc) {
262                 break;
263             }
264             log_mask = argv[optind++];
265         } else if (!strcmp(r, "D")) {
266             if (optind >= argc) {
267                 break;
268             }
269             log_file = argv[optind++];
270         } else if (!strcmp(r, "E")) {
271             r = argv[optind++];
272             if (envlist_setenv(envlist, r) != 0) {
273                 usage();
274             }
275         } else if (!strcmp(r, "ignore-environment")) {
276             envlist_free(envlist);
277             envlist = envlist_create();
278         } else if (!strcmp(r, "U")) {
279             r = argv[optind++];
280             if (envlist_unsetenv(envlist, r) != 0) {
281                 usage();
282             }
283         } else if (!strcmp(r, "s")) {
284             r = argv[optind++];
285             rv = qemu_strtoul(r, &r, 0, &target_dflssiz);
286             if (rv < 0 || target_dflssiz <= 0) {
287                 usage();
288             }
289             if (*r == 'M') {
290                 target_dflssiz *= 1024 * 1024;
291             } else if (*r == 'k' || *r == 'K') {
292                 target_dflssiz *= 1024;
293             }
294             if (target_dflssiz > target_maxssiz) {
295                 usage();
296             }
297         } else if (!strcmp(r, "L")) {
298             interp_prefix = argv[optind++];
299         } else if (!strcmp(r, "p")) {
300             qemu_host_page_size = atoi(argv[optind++]);
301             if (qemu_host_page_size == 0 ||
302                 (qemu_host_page_size & (qemu_host_page_size - 1)) != 0) {
303                 fprintf(stderr, "page size must be a power of two\n");
304                 exit(1);
305             }
306         } else if (!strcmp(r, "g")) {
307             gdbstub = g_strdup(argv[optind++]);
308         } else if (!strcmp(r, "r")) {
309             qemu_uname_release = argv[optind++];
310         } else if (!strcmp(r, "cpu")) {
311             cpu_model = argv[optind++];
312             if (is_help_option(cpu_model)) {
313                 /* XXX: implement xxx_cpu_list for targets that still miss it */
314 #if defined(cpu_list)
315                 cpu_list();
316 #endif
317                 exit(1);
318             }
319         } else if (!strcmp(r, "B")) {
320             rv = qemu_strtoul(argv[optind++], NULL, 0, &guest_base);
321             if (rv < 0) {
322                 usage();
323             }
324             have_guest_base = true;
325         } else if (!strcmp(r, "drop-ld-preload")) {
326             (void) envlist_unsetenv(envlist, "LD_PRELOAD");
327         } else if (!strcmp(r, "bsd")) {
328             if (!strcasecmp(argv[optind], "freebsd")) {
329                 bsd_type = target_freebsd;
330             } else if (!strcasecmp(argv[optind], "netbsd")) {
331                 bsd_type = target_netbsd;
332             } else if (!strcasecmp(argv[optind], "openbsd")) {
333                 bsd_type = target_openbsd;
334             } else {
335                 usage();
336             }
337             optind++;
338         } else if (!strcmp(r, "seed")) {
339             seed_optarg = optarg;
340         } else if (!strcmp(r, "singlestep")) {
341             singlestep = 1;
342         } else if (!strcmp(r, "strace")) {
343             do_strace = 1;
344         } else if (!strcmp(r, "trace")) {
345             trace_opt_parse(optarg);
346         } else {
347             usage();
348         }
349     }
350 
351     /* init debug */
352     qemu_log_needs_buffers();
353     qemu_set_log_filename(log_file, &error_fatal);
354     if (log_mask) {
355         int mask;
356 
357         mask = qemu_str_to_log_mask(log_mask);
358         if (!mask) {
359             qemu_print_log_usage(stdout);
360             exit(1);
361         }
362         qemu_set_log(mask);
363     }
364 
365     if (optind >= argc) {
366         usage();
367     }
368     filename = argv[optind];
369 
370     if (!trace_init_backends()) {
371         exit(1);
372     }
373     trace_init_file();
374 
375     /* Zero out regs */
376     memset(regs, 0, sizeof(struct target_pt_regs));
377 
378     /* Zero bsd params */
379     memset(&bprm, 0, sizeof(bprm));
380 
381     /* Zero out image_info */
382     memset(info, 0, sizeof(struct image_info));
383 
384     /* Scan interp_prefix dir for replacement files. */
385     init_paths(interp_prefix);
386 
387     if (cpu_model == NULL) {
388         cpu_model = TARGET_DEFAULT_CPU_MODEL;
389     }
390 
391     cpu_type = parse_cpu_option(cpu_model);
392 
393     /* init tcg before creating CPUs and to get qemu_host_page_size */
394     {
395         AccelClass *ac = ACCEL_GET_CLASS(current_accel());
396 
397         accel_init_interfaces(ac);
398         ac->init_machine(NULL);
399     }
400     cpu = cpu_create(cpu_type);
401     env = cpu->env_ptr;
402     cpu_reset(cpu);
403     thread_cpu = cpu;
404 
405     if (getenv("QEMU_STRACE")) {
406         do_strace = 1;
407     }
408 
409     target_environ = envlist_to_environ(envlist, NULL);
410     envlist_free(envlist);
411 
412     {
413         Error *err = NULL;
414         if (seed_optarg != NULL) {
415             qemu_guest_random_seed_main(seed_optarg, &err);
416         } else {
417             qcrypto_init(&err);
418         }
419         if (err) {
420             error_reportf_err(err, "cannot initialize crypto: ");
421             exit(1);
422         }
423     }
424 
425     /*
426      * Now that page sizes are configured we can do
427      * proper page alignment for guest_base.
428      */
429     guest_base = HOST_PAGE_ALIGN(guest_base);
430 
431     if (loader_exec(filename, argv + optind, target_environ, regs, info,
432                     &bprm) != 0) {
433         printf("Error loading %s\n", filename);
434         _exit(1);
435     }
436 
437     for (wrk = target_environ; *wrk; wrk++) {
438         g_free(*wrk);
439     }
440 
441     g_free(target_environ);
442 
443     if (qemu_loglevel_mask(CPU_LOG_PAGE)) {
444         qemu_log("guest_base  %p\n", (void *)guest_base);
445         log_page_dump("binary load");
446 
447         qemu_log("start_brk   0x" TARGET_ABI_FMT_lx "\n", info->start_brk);
448         qemu_log("end_code    0x" TARGET_ABI_FMT_lx "\n", info->end_code);
449         qemu_log("start_code  0x" TARGET_ABI_FMT_lx "\n",
450                  info->start_code);
451         qemu_log("start_data  0x" TARGET_ABI_FMT_lx "\n",
452                  info->start_data);
453         qemu_log("end_data    0x" TARGET_ABI_FMT_lx "\n", info->end_data);
454         qemu_log("start_stack 0x" TARGET_ABI_FMT_lx "\n",
455                  info->start_stack);
456         qemu_log("brk         0x" TARGET_ABI_FMT_lx "\n", info->brk);
457         qemu_log("entry       0x" TARGET_ABI_FMT_lx "\n", info->entry);
458     }
459 
460     /* build Task State */
461     ts = g_new0(TaskState, 1);
462     init_task_state(ts);
463     ts->info = info;
464     ts->bprm = &bprm;
465     cpu->opaque = ts;
466 
467     target_set_brk(info->brk);
468     syscall_init();
469     signal_init();
470 
471     /*
472      * Now that we've loaded the binary, GUEST_BASE is fixed.  Delay
473      * generating the prologue until now so that the prologue can take
474      * the real value of GUEST_BASE into account.
475      */
476     tcg_prologue_init(tcg_ctx);
477 
478     target_cpu_init(env, regs);
479 
480     if (gdbstub) {
481         gdbserver_start(gdbstub);
482         gdb_handlesig(cpu, 0);
483     }
484     cpu_loop(env);
485     /* never exits */
486     return 0;
487 }
488