semihosting/config.c

   1 /*
   2  * Semihosting configuration
   3  *
   4  * Copyright (c) 2015 Imagination Technologies
   5  * Copyright (c) 2019 Linaro Ltd
   6  *
   7  * This controls the configuration of semihosting for all guest
   8  * targets that support it. Architecture specific handling is handled
   9  * in target/HW/HW-semi.c
  10  *
  11  * Semihosting is sightly strange in that it is also supported by some
  12  * linux-user targets. However in that use case no configuration of
  13  * the outputs and command lines is supported.
  14  *
  15  * The config module is common to all softmmu targets however as vl.c
  16  * needs to link against the helpers.
  17  *
  18  * SPDX-License-Identifier: GPL-2.0-or-later
  19  */
  20
  21 #include "qemu/osdep.h"
  22 #include "qemu/option.h"
  23 #include "qemu/config-file.h"
  24 #include "qemu/error-report.h"
  25 #include "semihosting/semihost.h"
  26 #include "chardev/char.h"
  27
  28 QemuOptsList qemu_semihosting_config_opts = {
  29     .name = "semihosting-config",
  30     .merge_lists = true,
  31     .implied_opt_name = "enable",
  32     .head = QTAILQ_HEAD_INITIALIZER(qemu_semihosting_config_opts.head),
  33     .desc = {
  34         {
  35             .name = "enable",
  36             .type = QEMU_OPT_BOOL,
  37         }, {
  38             .name = "target",
  39             .type = QEMU_OPT_STRING,
  40         }, {
  41             .name = "chardev",
  42             .type = QEMU_OPT_STRING,
  43         }, {
  44             .name = "arg",
  45             .type = QEMU_OPT_STRING,
  46         },
  47         { /* end of list */ }
  48     },
  49 };
  50
  51 typedef struct SemihostingConfig {
  52     bool enabled;
  53     SemihostingTarget target;
  54     char **argv;
  55     int argc;
  56     const char *cmdline; /* concatenated argv */
  57 } SemihostingConfig;
  58
  59 static SemihostingConfig semihosting;
  60 static const char *semihost_chardev;
  61
  62 bool semihosting_enabled(void)
  63 {
  64     return semihosting.enabled;
  65 }
  66
  67 SemihostingTarget semihosting_get_target(void)
  68 {
  69     return semihosting.target;
  70 }
  71
  72 const char *semihosting_get_arg(int i)
  73 {
  74     if (i >= semihosting.argc) {
  75         return NULL;
  76     }
  77     return semihosting.argv[i];
  78 }
  79
  80 int semihosting_get_argc(void)
  81 {
  82     return semihosting.argc;
  83 }
  84
  85 const char *semihosting_get_cmdline(void)
  86 {
  87     if (semihosting.cmdline == NULL && semihosting.argc > 0) {
  88         semihosting.cmdline = g_strjoinv(" ", (gchar **)semihosting.argv);
  89     }
  90     return semihosting.cmdline;
  91 }
  92
  93 static int add_semihosting_arg(void *opaque,
  94                                const char *name, const char *val,
  95                                Error **errp)
  96 {
  97     SemihostingConfig *s = opaque;
  98     if (strcmp(name, "arg") == 0) {
  99         s->argc++;
 100         /* one extra element as g_strjoinv() expects NULL-terminated array */
 101         s->argv = g_renew(char *, s->argv, s->argc + 1);
 102         s->argv[s->argc - 1] = g_strdup(val);
 103         s->argv[s->argc] = NULL;
 104     }
 105     return 0;
 106 }
 107
 108 /* Use strings passed via -kernel/-append to initialize semihosting.argv[] */
 109 void semihosting_arg_fallback(const char *file, const char *cmd)
 110 {
 111     char *cmd_token;
 112
 113     /* argv[0] */
 114     add_semihosting_arg(&semihosting, "arg", file, NULL);
 115
 116     /* split -append and initialize argv[1..n] */
 117     cmd_token = strtok(g_strdup(cmd), " ");
 118     while (cmd_token) {
 119         add_semihosting_arg(&semihosting, "arg", cmd_token, NULL);
 120         cmd_token = strtok(NULL, " ");
 121     }
 122 }
 123
 124 void qemu_semihosting_enable(void)
 125 {
 126     semihosting.enabled = true;
 127     semihosting.target = SEMIHOSTING_TARGET_AUTO;
 128 }
 129
 130 int qemu_semihosting_config_options(const char *optarg)
 131 {
 132     QemuOptsList *opt_list = qemu_find_opts("semihosting-config");
 133     QemuOpts *opts = qemu_opts_parse_noisily(opt_list, optarg, false);
 134
 135     semihosting.enabled = true;
 136
 137     if (opts != NULL) {
 138         semihosting.enabled = qemu_opt_get_bool(opts, "enable",
 139                                                 true);
 140         const char *target = qemu_opt_get(opts, "target");
 141         /* setup of chardev is deferred until they are initialised */
 142         semihost_chardev = qemu_opt_get(opts, "chardev");
 143         if (target != NULL) {
 144             if (strcmp("native", target) == 0) {
 145                 semihosting.target = SEMIHOSTING_TARGET_NATIVE;
 146             } else if (strcmp("gdb", target) == 0) {
 147                 semihosting.target = SEMIHOSTING_TARGET_GDB;
 148             } else  if (strcmp("auto", target) == 0) {
 149                 semihosting.target = SEMIHOSTING_TARGET_AUTO;
 150             } else {
 151                 error_report("unsupported semihosting-config %s",
 152                              optarg);
 153                 return 1;
 154             }
 155         } else {
 156             semihosting.target = SEMIHOSTING_TARGET_AUTO;
 157         }
 158         /* Set semihosting argument count and vector */
 159         qemu_opt_foreach(opts, add_semihosting_arg,
 160                          &semihosting, NULL);
 161     } else {
 162         error_report("unsupported semihosting-config %s", optarg);
 163         return 1;
 164     }
 165
 166     return 0;
 167 }
 168
 169 /* We had to defer this until chardevs were created */
 170 void qemu_semihosting_chardev_init(void)
 171 {
 172     Chardev *chr = NULL;
 173
 174     if (semihost_chardev) {
 175         chr = qemu_chr_find(semihost_chardev);
 176         if (chr == NULL) {
 177             error_report("semihosting chardev '%s' not found",
 178                          semihost_chardev);
 179             exit(1);
 180         }
 181     }
 182
 183     qemu_semihosting_console_init(chr);
 184 }