chardev/char-hmp-cmds.c

   1 /*
   2  * HMP commands related to character devices
   3  *
   4  * Copyright IBM, Corp. 2011
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  * Contributions after 2012-01-13 are licensed under the terms of the
  13  * GNU GPL, version 2 or (at your option) any later version.
  14  */
  15
  16 #include "qemu/osdep.h"
  17 #include "chardev/char.h"
  18 #include "monitor/hmp.h"
  19 #include "monitor/monitor.h"
  20 #include "qapi/error.h"
  21 #include "qapi/qapi-commands-char.h"
  22 #include "qapi/qmp/qdict.h"
  23 #include "qemu/config-file.h"
  24 #include "qemu/option.h"
  25
  26 void hmp_info_chardev(Monitor *mon, const QDict *qdict)
  27 {
  28     ChardevInfoList *char_info, *info;
  29
  30     char_info = qmp_query_chardev(NULL);
  31     for (info = char_info; info; info = info->next) {
  32         monitor_printf(mon, "%s: filename=%s\n", info->value->label,
  33                                                  info->value->filename);
  34     }
  35
  36     qapi_free_ChardevInfoList(char_info);
  37 }
  38
  39 void hmp_ringbuf_write(Monitor *mon, const QDict *qdict)
  40 {
  41     const char *chardev = qdict_get_str(qdict, "device");
  42     const char *data = qdict_get_str(qdict, "data");
  43     Error *err = NULL;
  44
  45     qmp_ringbuf_write(chardev, data, false, 0, &err);
  46
  47     hmp_handle_error(mon, err);
  48 }
  49
  50 void hmp_ringbuf_read(Monitor *mon, const QDict *qdict)
  51 {
  52     uint32_t size = qdict_get_int(qdict, "size");
  53     const char *chardev = qdict_get_str(qdict, "device");
  54     char *data;
  55     Error *err = NULL;
  56     int i;
  57
  58     data = qmp_ringbuf_read(chardev, size, false, 0, &err);
  59     if (hmp_handle_error(mon, err)) {
  60         return;
  61     }
  62
  63     for (i = 0; data[i]; i++) {
  64         unsigned char ch = data[i];
  65
  66         if (ch == '\\') {
  67             monitor_printf(mon, "\\\\");
  68         } else if ((ch < 0x20 && ch != '\n' && ch != '\t') || ch == 0x7F) {
  69             monitor_printf(mon, "\\u%04X", ch);
  70         } else {
  71             monitor_printf(mon, "%c", ch);
  72         }
  73
  74     }
  75     monitor_printf(mon, "\n");
  76     g_free(data);
  77 }
  78
  79 void hmp_chardev_add(Monitor *mon, const QDict *qdict)
  80 {
  81     const char *args = qdict_get_str(qdict, "args");
  82     Error *err = NULL;
  83     QemuOpts *opts;
  84
  85     opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args, true);
  86     if (opts == NULL) {
  87         error_setg(&err, "Parsing chardev args failed");
  88     } else {
  89         qemu_chr_new_from_opts(opts, NULL, &err);
  90         qemu_opts_del(opts);
  91     }
  92     hmp_handle_error(mon, err);
  93 }
  94
  95 void hmp_chardev_change(Monitor *mon, const QDict *qdict)
  96 {
  97     const char *args = qdict_get_str(qdict, "args");
  98     const char *id;
  99     Error *err = NULL;
 100     ChardevBackend *backend = NULL;
 101     ChardevReturn *ret = NULL;
 102     QemuOpts *opts = qemu_opts_parse_noisily(qemu_find_opts("chardev"), args,
 103                                              true);
 104     if (!opts) {
 105         error_setg(&err, "Parsing chardev args failed");
 106         goto end;
 107     }
 108
 109     id = qdict_get_str(qdict, "id");
 110     if (qemu_opts_id(opts)) {
 111         error_setg(&err, "Unexpected 'id' parameter");
 112         goto end;
 113     }
 114
 115     backend = qemu_chr_parse_opts(opts, &err);
 116     if (!backend) {
 117         goto end;
 118     }
 119
 120     ret = qmp_chardev_change(id, backend, &err);
 121
 122 end:
 123     qapi_free_ChardevReturn(ret);
 124     qapi_free_ChardevBackend(backend);
 125     qemu_opts_del(opts);
 126     hmp_handle_error(mon, err);
 127 }
 128
 129 void hmp_chardev_remove(Monitor *mon, const QDict *qdict)
 130 {
 131     Error *local_err = NULL;
 132
 133     qmp_chardev_remove(qdict_get_str(qdict, "id"), &local_err);
 134     hmp_handle_error(mon, local_err);
 135 }
 136
 137 void hmp_chardev_send_break(Monitor *mon, const QDict *qdict)
 138 {
 139     Error *local_err = NULL;
 140
 141     qmp_chardev_send_break(qdict_get_str(qdict, "id"), &local_err);
 142     hmp_handle_error(mon, local_err);
 143 }
 144
 145 void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
 146 {
 147     size_t len;
 148     ChardevBackendInfoList *list, *start;
 149
 150     if (nb_args != 2) {
 151         return;
 152     }
 153     len = strlen(str);
 154     readline_set_completion_index(rs, len);
 155
 156     start = list = qmp_query_chardev_backends(NULL);
 157     while (list) {
 158         const char *chr_name = list->value->name;
 159
 160         if (!strncmp(chr_name, str, len)) {
 161             readline_add_completion(rs, chr_name);
 162         }
 163         list = list->next;
 164     }
 165     qapi_free_ChardevBackendInfoList(start);
 166 }
 167
 168 void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
 169 {
 170     size_t len;
 171     ChardevInfoList *list, *start;
 172
 173     if (nb_args != 2) {
 174         return;
 175     }
 176     len = strlen(str);
 177     readline_set_completion_index(rs, len);
 178
 179     start = list = qmp_query_chardev(NULL);
 180     while (list) {
 181         ChardevInfo *chr = list->value;
 182
 183         if (!strncmp(chr->label, str, len)) {
 184             readline_add_completion(rs, chr->label);
 185         }
 186         list = list->next;
 187     }
 188     qapi_free_ChardevInfoList(start);
 189 }
 190
 191 static void ringbuf_completion(ReadLineState *rs, const char *str)
 192 {
 193     size_t len;
 194     ChardevInfoList *list, *start;
 195
 196     len = strlen(str);
 197     readline_set_completion_index(rs, len);
 198
 199     start = list = qmp_query_chardev(NULL);
 200     while (list) {
 201         ChardevInfo *chr_info = list->value;
 202
 203         if (!strncmp(chr_info->label, str, len)) {
 204             Chardev *chr = qemu_chr_find(chr_info->label);
 205             if (chr && CHARDEV_IS_RINGBUF(chr)) {
 206                 readline_add_completion(rs, chr_info->label);
 207             }
 208         }
 209         list = list->next;
 210     }
 211     qapi_free_ChardevInfoList(start);
 212 }
 213
 214 void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
 215 {
 216     if (nb_args != 2) {
 217         return;
 218     }
 219     ringbuf_completion(rs, str);
 220 }