From 2c5f488293c7d0cd095635c74157c2526e2c4947 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 11:39:12 +0100 Subject: [PATCH 01/20] chardev: add support for qapi-based chardev initialization This patch add support for a new way to initialize chardev devices. Instead of calling a initialization function with a QemuOpts we will now create a (qapi) ChardevBackend, optionally call a function to fill ChardevBackend from QemuOpts, then go create the chardev using the new qapi code path which is also used by chardev-add. Signed-off-by: Gerd Hoffmann --- include/char/char.h | 2 ++ qemu-char.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 45 insertions(+) diff --git a/include/char/char.h b/include/char/char.h index 2e24270895..afe002498e 100644 --- a/include/char/char.h +++ b/include/char/char.h @@ -245,6 +245,8 @@ CharDriverState *qemu_chr_find(const char *name); QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename); void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *)); +void register_char_driver_qapi(const char *name, int kind, + void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp)); /* add an eventfd to the qemu devices that are polled */ CharDriverState *qemu_chr_open_eventfd(int eventfd); diff --git a/qemu-char.c b/qemu-char.c index 83787c74c4..c2e198e858 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3204,7 +3204,11 @@ static CharDriverState *qemu_chr_open_pp(QemuOpts *opts) typedef struct CharDriver { const char *name; + /* old, pre qapi */ CharDriverState *(*open)(QemuOpts *opts); + /* new, qapi-based */ + int kind; + void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp); } CharDriver; static GSList *backends; @@ -3220,6 +3224,19 @@ void register_char_driver(const char *name, CharDriverState *(*open)(QemuOpts *) backends = g_slist_append(backends, s); } +void register_char_driver_qapi(const char *name, int kind, + void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp)) +{ + CharDriver *s; + + s = g_malloc0(sizeof(*s)); + s->name = g_strdup(name); + s->kind = kind; + s->parse = parse; + + backends = g_slist_append(backends, s); +} + CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, void (*init)(struct CharDriverState *s), Error **errp) @@ -3251,6 +3268,32 @@ CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, return NULL; } + if (!cd->open) { + /* using new, qapi init */ + ChardevBackend *backend = g_new0(ChardevBackend, 1); + ChardevReturn *ret = NULL; + const char *id = qemu_opts_id(opts); + + chr = NULL; + backend->kind = cd->kind; + if (cd->parse) { + cd->parse(opts, backend, errp); + if (error_is_set(errp)) { + goto qapi_out; + } + } + ret = qmp_chardev_add(qemu_opts_id(opts), backend, errp); + if (error_is_set(errp)) { + goto qapi_out; + } + chr = qemu_chr_find(id); + + qapi_out: + qapi_free_ChardevBackend(backend); + qapi_free_ChardevReturn(ret); + return chr; + } + chr = cd->open(opts); if (!chr) { error_setg(errp, "chardev: opening backend \"%s\" failed", From edb2fb3cc8b85ab956f366fc036ac12853984dae Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 16:16:42 +0100 Subject: [PATCH 02/20] chardev: add mux chardev support to qapi This adds mux chardev support to the qapi and also makes the qapi-based chardev creation path handle the "mux=on" option correctly. --- qapi-schema.json | 14 +++++++++++++- qemu-char.c | 35 ++++++++++++++++++++++++++++++++--- 2 files changed, 45 insertions(+), 4 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 4494e53693..4ad92b07f1 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3184,6 +3184,17 @@ '*nodelay' : 'bool', '*telnet' : 'bool' } } +## +# @ChardevMux: +# +# Configuration info for mux chardevs. +# +# @chardev: name of the base chardev. +# +# Since: 1.5 +## +{ 'type': 'ChardevMux', 'data': { 'chardev' : 'str' } } + ## # @ChardevBackend: # @@ -3198,7 +3209,8 @@ 'parallel': 'ChardevHostdev', 'socket' : 'ChardevSocket', 'pty' : 'ChardevDummy', - 'null' : 'ChardevDummy' } } + 'null' : 'ChardevDummy', + 'mux' : 'ChardevMux' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index c2e198e858..0dc380280a 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3273,6 +3273,11 @@ CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, ChardevBackend *backend = g_new0(ChardevBackend, 1); ChardevReturn *ret = NULL; const char *id = qemu_opts_id(opts); + const char *bid = NULL; + + if (qemu_opt_get_bool(opts, "mux", 0)) { + bid = g_strdup_printf("%s-base", id); + } chr = NULL; backend->kind = cd->kind; @@ -3282,10 +3287,24 @@ CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, goto qapi_out; } } - ret = qmp_chardev_add(qemu_opts_id(opts), backend, errp); + ret = qmp_chardev_add(bid ? bid : id, backend, errp); if (error_is_set(errp)) { goto qapi_out; } + + if (bid) { + qapi_free_ChardevBackend(backend); + qapi_free_ChardevReturn(ret); + backend = g_new0(ChardevBackend, 1); + backend->mux = g_new0(ChardevMux, 1); + backend->kind = CHARDEV_BACKEND_KIND_MUX; + backend->mux->chardev = g_strdup(bid); + ret = qmp_chardev_add(id, backend, errp); + if (error_is_set(errp)) { + goto qapi_out; + } + } + chr = qemu_chr_find(id); qapi_out: @@ -3653,7 +3672,7 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, Error **errp) { ChardevReturn *ret = g_new0(ChardevReturn, 1); - CharDriverState *chr = NULL; + CharDriverState *base, *chr = NULL; chr = qemu_chr_find(id); if (chr) { @@ -3691,6 +3710,15 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_NULL: chr = qemu_chr_open_null(NULL); break; + case CHARDEV_BACKEND_KIND_MUX: + base = qemu_chr_find(backend->mux->chardev); + if (base == NULL) { + error_setg(errp, "mux: base chardev %s not found", + backend->mux->chardev); + break; + } + chr = qemu_chr_open_mux(base); + break; default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; @@ -3701,7 +3729,8 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, } if (chr) { chr->label = g_strdup(id); - chr->avail_connections = 1; + chr->avail_connections = + (backend->kind == CHARDEV_BACKEND_KIND_MUX) ? MAX_MUX : 1; QTAILQ_INSERT_TAIL(&chardevs, chr, next); return ret; } else { From 80dca9e643d11b54f1b9bafbaefeadfb1099e023 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 11:41:26 +0100 Subject: [PATCH 03/20] chardev: switch null init to qapi This patch switches over the 'null' chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qemu-char.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/qemu-char.c b/qemu-char.c index 0dc380280a..e6f67d8c5d 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -217,7 +217,7 @@ static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len) return len; } -static CharDriverState *qemu_chr_open_null(QemuOpts *opts) +static CharDriverState *qemu_chr_open_null(void) { CharDriverState *chr; @@ -3708,7 +3708,7 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, } #endif case CHARDEV_BACKEND_KIND_NULL: - chr = qemu_chr_open_null(NULL); + chr = qemu_chr_open_null(); break; case CHARDEV_BACKEND_KIND_MUX: base = qemu_chr_find(backend->mux->chardev); @@ -3758,7 +3758,7 @@ void qmp_chardev_remove(const char *id, Error **errp) static void register_types(void) { - register_char_driver("null", qemu_chr_open_null); + register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL); register_char_driver("socket", qemu_chr_open_socket); register_char_driver("udp", qemu_chr_open_udp); register_char_driver("memory", qemu_chr_open_ringbuf); From f5a51cab2afd1124f0988081207d506fbec629b4 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 11:58:44 +0100 Subject: [PATCH 04/20] chardev: add msmouse support to qapi This patch adds 'msmouse' support to qapi and also switches over the msmouse chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- backends/msmouse.c | 4 ++-- include/char/char.h | 3 +++ qapi-schema.json | 3 ++- qemu-char.c | 3 +++ 4 files changed, 10 insertions(+), 3 deletions(-) diff --git a/backends/msmouse.c b/backends/msmouse.c index 407ec87784..61052fe783 100644 --- a/backends/msmouse.c +++ b/backends/msmouse.c @@ -63,7 +63,7 @@ static void msmouse_chr_close (struct CharDriverState *chr) g_free (chr); } -static CharDriverState *qemu_chr_open_msmouse(QemuOpts *opts) +CharDriverState *qemu_chr_open_msmouse(void) { CharDriverState *chr; @@ -78,7 +78,7 @@ static CharDriverState *qemu_chr_open_msmouse(QemuOpts *opts) static void register_types(void) { - register_char_driver("msmouse", qemu_chr_open_msmouse); + register_char_driver_qapi("msmouse", CHARDEV_BACKEND_KIND_MSMOUSE, NULL); } type_init(register_types); diff --git a/include/char/char.h b/include/char/char.h index afe002498e..80e8e30e15 100644 --- a/include/char/char.h +++ b/include/char/char.h @@ -261,4 +261,7 @@ size_t qemu_chr_mem_osize(const CharDriverState *chr); CharDriverState *qemu_char_get_next_serial(void); +/* msmouse */ +CharDriverState *qemu_chr_open_msmouse(void); + #endif diff --git a/qapi-schema.json b/qapi-schema.json index 4ad92b07f1..86c04dc9ff 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3210,7 +3210,8 @@ 'socket' : 'ChardevSocket', 'pty' : 'ChardevDummy', 'null' : 'ChardevDummy', - 'mux' : 'ChardevMux' } } + 'mux' : 'ChardevMux', + 'msmouse': 'ChardevDummy' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index e6f67d8c5d..e860ba30aa 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3719,6 +3719,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, } chr = qemu_chr_open_mux(base); break; + case CHARDEV_BACKEND_KIND_MSMOUSE: + chr = qemu_chr_open_msmouse(); + break; default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; From 2d57286da6e57aacf3b2d0d3354d543ed100a485 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 12:56:10 +0100 Subject: [PATCH 05/20] chardev: add braille support to qapi This patch adds 'braille' support to qapi and also switches over the braille chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- backends/baum.c | 4 ++-- include/char/char.h | 3 +++ qapi-schema.json | 3 ++- qemu-char.c | 5 +++++ 4 files changed, 12 insertions(+), 3 deletions(-) diff --git a/backends/baum.c b/backends/baum.c index 9063aea2cf..d7d658c224 100644 --- a/backends/baum.c +++ b/backends/baum.c @@ -561,7 +561,7 @@ static void baum_close(struct CharDriverState *chr) g_free(baum); } -static CharDriverState *chr_baum_init(QemuOpts *opts) +CharDriverState *chr_baum_init(void) { BaumDriverState *baum; CharDriverState *chr; @@ -627,7 +627,7 @@ fail_handle: static void register_types(void) { - register_char_driver("braille", chr_baum_init); + register_char_driver_qapi("braille", CHARDEV_BACKEND_KIND_BRAILLE, NULL); } type_init(register_types); diff --git a/include/char/char.h b/include/char/char.h index 80e8e30e15..d6a03513bf 100644 --- a/include/char/char.h +++ b/include/char/char.h @@ -264,4 +264,7 @@ CharDriverState *qemu_char_get_next_serial(void); /* msmouse */ CharDriverState *qemu_chr_open_msmouse(void); +/* baum.c */ +CharDriverState *chr_baum_init(void); + #endif diff --git a/qapi-schema.json b/qapi-schema.json index 86c04dc9ff..3c5c0fbc27 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3211,7 +3211,8 @@ 'pty' : 'ChardevDummy', 'null' : 'ChardevDummy', 'mux' : 'ChardevMux', - 'msmouse': 'ChardevDummy' } } + 'msmouse': 'ChardevDummy', + 'braille': 'ChardevDummy' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index e860ba30aa..1692aa8367 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3722,6 +3722,11 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_MSMOUSE: chr = qemu_chr_open_msmouse(); break; +#ifdef CONFIG_BRLAPI + case CHARDEV_BACKEND_KIND_BRAILLE: + chr = chr_baum_init(); + break; +#endif default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; From 846e2e49388aa42e030af3d5dd60a6009b80a369 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 12:07:14 +0100 Subject: [PATCH 06/20] chardev: switch file init to qapi This patch switches over the 'file' chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qemu-char.c | 43 +++++++++++++++---------------------------- 1 file changed, 15 insertions(+), 28 deletions(-) diff --git a/qemu-char.c b/qemu-char.c index 1692aa8367..4b9caca920 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -841,18 +841,6 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out) return chr; } -static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts) -{ - int fd_out; - - TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"), - O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666)); - if (fd_out < 0) { - return NULL; - } - return qemu_chr_open_fd(-1, fd_out); -} - static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts) { int fd_in, fd_out; @@ -1989,20 +1977,6 @@ static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts) return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE)); } -static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts) -{ - const char *file_out = qemu_opt_get(opts, "path"); - HANDLE fd_out; - - fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL, - OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); - if (fd_out == INVALID_HANDLE_VALUE) { - return NULL; - } - - return qemu_chr_open_win_file(fd_out); -} - static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len) { HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE); @@ -3202,6 +3176,19 @@ static CharDriverState *qemu_chr_open_pp(QemuOpts *opts) #endif +static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *path = qemu_opt_get(opts, "path"); + + if (path == NULL) { + error_setg(errp, "chardev: file: no filename given"); + return; + } + backend->file = g_new0(ChardevFile, 1); + backend->file->out = g_strdup(path); +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3770,14 +3757,14 @@ static void register_types(void) register_char_driver("socket", qemu_chr_open_socket); register_char_driver("udp", qemu_chr_open_udp); register_char_driver("memory", qemu_chr_open_ringbuf); + register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE, + qemu_chr_parse_file_out); #ifdef _WIN32 - register_char_driver("file", qemu_chr_open_win_file_out); register_char_driver("pipe", qemu_chr_open_win_pipe); register_char_driver("console", qemu_chr_open_win_con); register_char_driver("serial", qemu_chr_open_win); register_char_driver("stdio", qemu_chr_open_win_stdio); #else - register_char_driver("file", qemu_chr_open_file_out); register_char_driver("pipe", qemu_chr_open_pipe); register_char_driver("stdio", qemu_chr_open_stdio); #endif From 7c358031eac9a41c215900020acf8600d33138aa Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 21 Feb 2013 12:34:58 +0100 Subject: [PATCH 07/20] chardev: add stdio support to qapi This patch adds 'stdio' support to qapi and also switches over the stdio chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qapi-schema.json | 16 +++++++++++++++- qemu-char.c | 26 ++++++++++++++++++++------ 2 files changed, 35 insertions(+), 7 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 3c5c0fbc27..68150b7f17 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3195,6 +3195,19 @@ ## { 'type': 'ChardevMux', 'data': { 'chardev' : 'str' } } +## +# @ChardevStdio: +# +# Configuration info for stdio chardevs. +# +# @signal: #optional Allow signals (such as SIGINT triggered by ^C) +# be delivered to qemu. Default: true in -nographic mode, +# false otherwise. +# +# Since: 1.5 +## +{ 'type': 'ChardevStdio', 'data': { '*signal' : 'bool' } } + ## # @ChardevBackend: # @@ -3212,7 +3225,8 @@ 'null' : 'ChardevDummy', 'mux' : 'ChardevMux', 'msmouse': 'ChardevDummy', - 'braille': 'ChardevDummy' } } + 'braille': 'ChardevDummy', + 'stdio' : 'ChardevStdio' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index 4b9caca920..85ffd8e909 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -908,7 +908,7 @@ static void qemu_chr_close_stdio(struct CharDriverState *chr) fd_chr_close(chr); } -static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts) +static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts) { CharDriverState *chr; @@ -924,8 +924,10 @@ static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts) chr = qemu_chr_open_fd(0, 1); chr->chr_close = qemu_chr_close_stdio; chr->chr_set_echo = qemu_chr_set_echo_stdio; - stdio_allow_signal = qemu_opt_get_bool(opts, "signal", - display_type != DT_NOGRAPHIC); + stdio_allow_signal = display_type != DT_NOGRAPHIC; + if (opts->has_signal) { + stdio_allow_signal = opts->signal; + } qemu_chr_fe_set_echo(chr, false); return chr; @@ -2114,7 +2116,7 @@ static void win_stdio_close(CharDriverState *chr) g_free(chr); } -static CharDriverState *qemu_chr_open_win_stdio(QemuOpts *opts) +static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts) { CharDriverState *chr; WinStdioCharState *stdio; @@ -3189,6 +3191,15 @@ static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend, backend->file->out = g_strdup(path); } +static void qemu_chr_parse_stdio(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + backend->stdio = g_new0(ChardevStdio, 1); + backend->stdio->has_signal = true; + backend->stdio->signal = + qemu_opt_get_bool(opts, "signal", display_type != DT_NOGRAPHIC); +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3714,6 +3725,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, chr = chr_baum_init(); break; #endif + case CHARDEV_BACKEND_KIND_STDIO: + chr = qemu_chr_open_stdio(backend->stdio); + break; default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; @@ -3759,14 +3773,14 @@ static void register_types(void) register_char_driver("memory", qemu_chr_open_ringbuf); register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE, qemu_chr_parse_file_out); + register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO, + qemu_chr_parse_stdio); #ifdef _WIN32 register_char_driver("pipe", qemu_chr_open_win_pipe); register_char_driver("console", qemu_chr_open_win_con); register_char_driver("serial", qemu_chr_open_win); - register_char_driver("stdio", qemu_chr_open_win_stdio); #else register_char_driver("pipe", qemu_chr_open_pipe); - register_char_driver("stdio", qemu_chr_open_stdio); #endif #ifdef HAVE_CHARDEV_TTY register_char_driver("tty", qemu_chr_open_tty); From 0f1cb51da7112fa62c6cde62f546714a2c672f54 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Fri, 22 Feb 2013 15:48:05 +0100 Subject: [PATCH 08/20] chardev: switch serial/tty init to qapi This patch switches over the serial chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qemu-char.c | 37 +++++++++++++++++-------------------- 1 file changed, 17 insertions(+), 20 deletions(-) diff --git a/qemu-char.c b/qemu-char.c index 85ffd8e909..3033c2dffc 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -1419,18 +1419,6 @@ static CharDriverState *qemu_chr_open_tty_fd(int fd) chr->chr_close = qemu_chr_close_tty; return chr; } - -static CharDriverState *qemu_chr_open_tty(QemuOpts *opts) -{ - const char *filename = qemu_opt_get(opts, "path"); - int fd; - - TFR(fd = qemu_open(filename, O_RDWR | O_NONBLOCK)); - if (fd < 0) { - return NULL; - } - return qemu_chr_open_tty_fd(fd); -} #endif /* __linux__ || __sun__ */ #if defined(__linux__) @@ -1855,11 +1843,6 @@ static CharDriverState *qemu_chr_open_win_path(const char *filename) return chr; } -static CharDriverState *qemu_chr_open_win(QemuOpts *opts) -{ - return qemu_chr_open_win_path(qemu_opt_get(opts, "path")); -} - static int win_chr_pipe_poll(void *opaque) { CharDriverState *chr = opaque; @@ -3200,6 +3183,19 @@ static void qemu_chr_parse_stdio(QemuOpts *opts, ChardevBackend *backend, qemu_opt_get_bool(opts, "signal", display_type != DT_NOGRAPHIC); } +static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *device = qemu_opt_get(opts, "path"); + + if (device == NULL) { + error_setg(errp, "chardev: serial/tty: no device path given"); + return; + } + backend->serial = g_new0(ChardevHostdev, 1); + backend->serial->device = g_strdup(device); +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3775,16 +3771,17 @@ static void register_types(void) qemu_chr_parse_file_out); register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO, qemu_chr_parse_stdio); + register_char_driver_qapi("serial", CHARDEV_BACKEND_KIND_SERIAL, + qemu_chr_parse_serial); + register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL, + qemu_chr_parse_serial); #ifdef _WIN32 register_char_driver("pipe", qemu_chr_open_win_pipe); register_char_driver("console", qemu_chr_open_win_con); - register_char_driver("serial", qemu_chr_open_win); #else register_char_driver("pipe", qemu_chr_open_pipe); #endif #ifdef HAVE_CHARDEV_TTY - register_char_driver("tty", qemu_chr_open_tty); - register_char_driver("serial", qemu_chr_open_tty); register_char_driver("pty", qemu_chr_open_pty); #endif #ifdef HAVE_CHARDEV_PARPORT From dc3750976914b0900446e6a5434919a0fa2ba028 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Fri, 22 Feb 2013 16:17:01 +0100 Subject: [PATCH 09/20] chardev: switch parallel init to qapi This patch switches over the parallel chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qemu-char.c | 37 +++++++++++++++++-------------------- 1 file changed, 17 insertions(+), 20 deletions(-) diff --git a/qemu-char.c b/qemu-char.c index 3033c2dffc..d8ac86b9f8 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3145,22 +3145,6 @@ fail: return NULL; } -#ifdef HAVE_CHARDEV_PARPORT - -static CharDriverState *qemu_chr_open_pp(QemuOpts *opts) -{ - const char *filename = qemu_opt_get(opts, "path"); - int fd; - - fd = qemu_open(filename, O_RDWR); - if (fd < 0) { - return NULL; - } - return qemu_chr_open_pp_fd(fd); -} - -#endif - static void qemu_chr_parse_file_out(QemuOpts *opts, ChardevBackend *backend, Error **errp) { @@ -3196,6 +3180,19 @@ static void qemu_chr_parse_serial(QemuOpts *opts, ChardevBackend *backend, backend->serial->device = g_strdup(device); } +static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *device = qemu_opt_get(opts, "path"); + + if (device == NULL) { + error_setg(errp, "chardev: parallel: no device path given"); + return; + } + backend->parallel = g_new0(ChardevHostdev, 1); + backend->parallel->device = g_strdup(device); +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3775,6 +3772,10 @@ static void register_types(void) qemu_chr_parse_serial); register_char_driver_qapi("tty", CHARDEV_BACKEND_KIND_SERIAL, qemu_chr_parse_serial); + register_char_driver_qapi("parallel", CHARDEV_BACKEND_KIND_PARALLEL, + qemu_chr_parse_parallel); + register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL, + qemu_chr_parse_parallel); #ifdef _WIN32 register_char_driver("pipe", qemu_chr_open_win_pipe); register_char_driver("console", qemu_chr_open_win_con); @@ -3784,10 +3785,6 @@ static void register_types(void) #ifdef HAVE_CHARDEV_TTY register_char_driver("pty", qemu_chr_open_pty); #endif -#ifdef HAVE_CHARDEV_PARPORT - register_char_driver("parallel", qemu_chr_open_pp); - register_char_driver("parport", qemu_chr_open_pp); -#endif } type_init(register_types); From e68c5958668596a5023e30ddf8368410878f7682 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Mon, 25 Feb 2013 10:16:46 +0100 Subject: [PATCH 10/20] chardev: switch pty init to qapi This patch switches over the pty chardev initialization to the new qapi code path. Bonus: Taking QemuOpts out of the loop allows some nice cleanups along the way. Signed-off-by: Gerd Hoffmann --- qemu-char.c | 35 ++++++++++------------------------- 1 file changed, 10 insertions(+), 25 deletions(-) diff --git a/qemu-char.c b/qemu-char.c index d8ac86b9f8..158b81edef 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -1157,13 +1157,13 @@ static void pty_chr_close(struct CharDriverState *chr) qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } -static CharDriverState *qemu_chr_open_pty(QemuOpts *opts) +static CharDriverState *qemu_chr_open_pty(const char *id, + ChardevReturn *ret) { CharDriverState *chr; PtyCharDriver *s; struct termios tty; - const char *label; - int master_fd, slave_fd, len; + int master_fd, slave_fd; #if defined(__OpenBSD__) || defined(__DragonFly__) char pty_name[PATH_MAX]; #define q_ptsname(x) pty_name @@ -1184,17 +1184,12 @@ static CharDriverState *qemu_chr_open_pty(QemuOpts *opts) chr = g_malloc0(sizeof(CharDriverState)); - len = strlen(q_ptsname(master_fd)) + 5; - chr->filename = g_malloc(len); - snprintf(chr->filename, len, "pty:%s", q_ptsname(master_fd)); - qemu_opt_set(opts, "path", q_ptsname(master_fd)); + chr->filename = g_strdup_printf("pty:%s", q_ptsname(master_fd)); + ret->pty = g_strdup(q_ptsname(master_fd)); + ret->has_pty = true; - label = qemu_opts_id(opts); - fprintf(stderr, "char device redirected to %s%s%s%s\n", - q_ptsname(master_fd), - label ? " (label " : "", - label ? label : "", - label ? ")" : ""); + fprintf(stderr, "char device redirected to %s (label %s)\n", + q_ptsname(master_fd), id); s = g_malloc0(sizeof(PtyCharDriver)); chr->opaque = s; @@ -3687,16 +3682,8 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, break; #ifdef HAVE_CHARDEV_TTY case CHARDEV_BACKEND_KIND_PTY: - { - /* qemu_chr_open_pty sets "path" in opts */ - QemuOpts *opts; - opts = qemu_opts_create_nofail(qemu_find_opts("chardev")); - chr = qemu_chr_open_pty(opts); - ret->pty = g_strdup(qemu_opt_get(opts, "path")); - ret->has_pty = true; - qemu_opts_del(opts); + chr = qemu_chr_open_pty(id, ret); break; - } #endif case CHARDEV_BACKEND_KIND_NULL: chr = qemu_chr_open_null(); @@ -3776,15 +3763,13 @@ static void register_types(void) qemu_chr_parse_parallel); register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL, qemu_chr_parse_parallel); + register_char_driver_qapi("pty", CHARDEV_BACKEND_KIND_PTY, NULL); #ifdef _WIN32 register_char_driver("pipe", qemu_chr_open_win_pipe); register_char_driver("console", qemu_chr_open_win_con); #else register_char_driver("pipe", qemu_chr_open_pipe); #endif -#ifdef HAVE_CHARDEV_TTY - register_char_driver("pty", qemu_chr_open_pty); -#endif } type_init(register_types); From d9ac374f0def9a65340c1768c08e3271f4d7798d Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Mon, 25 Feb 2013 11:48:06 +0100 Subject: [PATCH 11/20] chardev: add console support to qapi This patch adds 'console' support to qapi and also switches over the console chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qapi-schema.json | 3 ++- qemu-char.c | 9 +++++++-- 2 files changed, 9 insertions(+), 3 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 68150b7f17..70c2c07f4c 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3226,7 +3226,8 @@ 'mux' : 'ChardevMux', 'msmouse': 'ChardevDummy', 'braille': 'ChardevDummy', - 'stdio' : 'ChardevStdio' } } + 'stdio' : 'ChardevStdio', + 'console': 'ChardevDummy' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index 158b81edef..c3d44207da 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -1952,7 +1952,7 @@ static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out) return chr; } -static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts) +static CharDriverState *qemu_chr_open_win_con(void) { return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE)); } @@ -3708,6 +3708,11 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_STDIO: chr = qemu_chr_open_stdio(backend->stdio); break; +#ifdef _WIN32 + case CHARDEV_BACKEND_KIND_CONSOLE: + chr = qemu_chr_open_win_con(); + break; +#endif default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; @@ -3764,9 +3769,9 @@ static void register_types(void) register_char_driver_qapi("parport", CHARDEV_BACKEND_KIND_PARALLEL, qemu_chr_parse_parallel); register_char_driver_qapi("pty", CHARDEV_BACKEND_KIND_PTY, NULL); + register_char_driver_qapi("console", CHARDEV_BACKEND_KIND_CONSOLE, NULL); #ifdef _WIN32 register_char_driver("pipe", qemu_chr_open_win_pipe); - register_char_driver("console", qemu_chr_open_win_con); #else register_char_driver("pipe", qemu_chr_open_pipe); #endif From 548cbb36f415d6086f5252309ab5aa7634497ab5 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Mon, 25 Feb 2013 11:50:55 +0100 Subject: [PATCH 12/20] chardev: add pipe support to qapi This patch adds 'pipe' support to qapi and also switches over the pipe chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qapi-schema.json | 3 ++- qemu-char.c | 31 ++++++++++++++++++++++--------- 2 files changed, 24 insertions(+), 10 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 70c2c07f4c..7ea32ed415 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3153,7 +3153,7 @@ ## # @ChardevHostdev: # -# Configuration info for device chardevs. +# Configuration info for device and pipe chardevs. # # @device: The name of the special file for the device, # i.e. /dev/ttyS0 on Unix or COM1: on Windows @@ -3220,6 +3220,7 @@ { 'union': 'ChardevBackend', 'data': { 'file' : 'ChardevFile', 'serial' : 'ChardevHostdev', 'parallel': 'ChardevHostdev', + 'pipe' : 'ChardevHostdev', 'socket' : 'ChardevSocket', 'pty' : 'ChardevDummy', 'null' : 'ChardevDummy', diff --git a/qemu-char.c b/qemu-char.c index c3d44207da..427901c0c5 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -841,11 +841,11 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out) return chr; } -static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts) +static CharDriverState *qemu_chr_open_pipe(ChardevHostdev *opts) { int fd_in, fd_out; char filename_in[256], filename_out[256]; - const char *filename = qemu_opt_get(opts, "path"); + const char *filename = opts->device; if (filename == NULL) { fprintf(stderr, "chardev: pipe: no filename given\n"); @@ -1917,9 +1917,9 @@ static int win_chr_pipe_init(CharDriverState *chr, const char *filename) } -static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts) +static CharDriverState *qemu_chr_open_pipe(ChardevHostdev *opts) { - const char *filename = qemu_opt_get(opts, "path"); + const char *filename = opts->device; CharDriverState *chr; WinCharState *s; @@ -3188,6 +3188,19 @@ static void qemu_chr_parse_parallel(QemuOpts *opts, ChardevBackend *backend, backend->parallel->device = g_strdup(device); } +static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *device = qemu_opt_get(opts, "path"); + + if (device == NULL) { + error_setg(errp, "chardev: pipe: no device path given"); + return; + } + backend->pipe = g_new0(ChardevHostdev, 1); + backend->pipe->device = g_strdup(device); +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3677,6 +3690,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_PARALLEL: chr = qmp_chardev_open_parallel(backend->parallel, errp); break; + case CHARDEV_BACKEND_KIND_PIPE: + chr = qemu_chr_open_pipe(backend->pipe); + break; case CHARDEV_BACKEND_KIND_SOCKET: chr = qmp_chardev_open_socket(backend->socket, errp); break; @@ -3770,11 +3786,8 @@ static void register_types(void) qemu_chr_parse_parallel); register_char_driver_qapi("pty", CHARDEV_BACKEND_KIND_PTY, NULL); register_char_driver_qapi("console", CHARDEV_BACKEND_KIND_CONSOLE, NULL); -#ifdef _WIN32 - register_char_driver("pipe", qemu_chr_open_win_pipe); -#else - register_char_driver("pipe", qemu_chr_open_pipe); -#endif + register_char_driver_qapi("pipe", CHARDEV_BACKEND_KIND_PIPE, + qemu_chr_parse_pipe); } type_init(register_types); From cd153e2aa2f0ec39c04c2b732ebebfc6d4766986 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Mon, 25 Feb 2013 12:39:06 +0100 Subject: [PATCH 13/20] chardev: add spice support to qapi This patch adds 'spicevmc' and 'spiceport' support to qapi and also switches over the spice chardev initialization to the new qapi code path. --- include/ui/qemu-spice.h | 7 +++-- qapi-schema.json | 26 ++++++++++++++++- qemu-char.c | 8 ++++++ spice-qemu-char.c | 62 +++++++++++++++++++++++++++-------------- 4 files changed, 79 insertions(+), 24 deletions(-) diff --git a/include/ui/qemu-spice.h b/include/ui/qemu-spice.h index 5a78fd764d..eba6d77d1d 100644 --- a/include/ui/qemu-spice.h +++ b/include/ui/qemu-spice.h @@ -44,10 +44,13 @@ int qemu_spice_migrate_info(const char *hostname, int port, int tls_port, void do_info_spice_print(Monitor *mon, const QObject *data); void do_info_spice(Monitor *mon, QObject **ret_data); -CharDriverState *qemu_chr_open_spice(QemuOpts *opts); +CharDriverState *qemu_chr_open_spice_vmc(const char *type); #if SPICE_SERVER_VERSION >= 0x000c02 -CharDriverState *qemu_chr_open_spice_port(QemuOpts *opts); +CharDriverState *qemu_chr_open_spice_port(const char *name); void qemu_spice_register_ports(void); +#else +static inline CharDriverState *qemu_chr_open_spice_port(const char *name) +{ return NULL; } #endif #else /* CONFIG_SPICE */ diff --git a/qapi-schema.json b/qapi-schema.json index 7ea32ed415..dad4d4aed1 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3208,6 +3208,28 @@ ## { 'type': 'ChardevStdio', 'data': { '*signal' : 'bool' } } +## +# @ChardevSpiceChannel: +# +# Configuration info for spice vm channel chardevs. +# +# @type: kind of channel (for example vdagent). +# +# Since: 1.5 +## +{ 'type': 'ChardevSpiceChannel', 'data': { 'type' : 'str' } } + +## +# @ChardevSpicePort: +# +# Configuration info for spice port chardevs. +# +# @fqdn: name of the channel (see docs/spice-port-fqdn.txt) +# +# Since: 1.5 +## +{ 'type': 'ChardevSpicePort', 'data': { 'fqdn' : 'str' } } + ## # @ChardevBackend: # @@ -3228,7 +3250,9 @@ 'msmouse': 'ChardevDummy', 'braille': 'ChardevDummy', 'stdio' : 'ChardevStdio', - 'console': 'ChardevDummy' } } + 'console': 'ChardevDummy', + 'spicevmc' : 'ChardevSpiceChannel', + 'spiceport' : 'ChardevSpicePort' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index 427901c0c5..f13374770a 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3728,6 +3728,14 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_CONSOLE: chr = qemu_chr_open_win_con(); break; +#endif +#ifdef CONFIG_SPICE + case CHARDEV_BACKEND_KIND_SPICEVMC: + chr = qemu_chr_open_spice_vmc(backend->spicevmc->type); + break; + case CHARDEV_BACKEND_KIND_SPICEPORT: + chr = qemu_chr_open_spice_port(backend->spiceport->fqdn); + break; #endif default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); diff --git a/spice-qemu-char.c b/spice-qemu-char.c index aea3d24e7d..0c92ca850b 100644 --- a/spice-qemu-char.c +++ b/spice-qemu-char.c @@ -217,16 +217,14 @@ static void print_allowed_subtypes(void) fprintf(stderr, "\n"); } -static CharDriverState *chr_open(QemuOpts *opts, const char *subtype) +static CharDriverState *chr_open(const char *subtype) { CharDriverState *chr; SpiceCharDriver *s; - uint32_t debug = qemu_opt_get_number(opts, "debug", 0); chr = g_malloc0(sizeof(CharDriverState)); s = g_malloc0(sizeof(SpiceCharDriver)); s->chr = chr; - s->debug = debug; s->active = false; s->sin.subtype = subtype; chr->opaque = s; @@ -240,35 +238,32 @@ static CharDriverState *chr_open(QemuOpts *opts, const char *subtype) return chr; } -CharDriverState *qemu_chr_open_spice(QemuOpts *opts) +CharDriverState *qemu_chr_open_spice_vmc(const char *type) { CharDriverState *chr; - const char *name = qemu_opt_get(opts, "name"); const char **psubtype = spice_server_char_device_recognized_subtypes(); - const char *subtype = NULL; - if (name == NULL) { + if (type == NULL) { fprintf(stderr, "spice-qemu-char: missing name parameter\n"); print_allowed_subtypes(); return NULL; } - for(;*psubtype != NULL; ++psubtype) { - if (strcmp(name, *psubtype) == 0) { - subtype = *psubtype; + for (; *psubtype != NULL; ++psubtype) { + if (strcmp(type, *psubtype) == 0) { break; } } - if (subtype == NULL) { - fprintf(stderr, "spice-qemu-char: unsupported name: %s\n", name); + if (*psubtype == NULL) { + fprintf(stderr, "spice-qemu-char: unsupported type: %s\n", type); print_allowed_subtypes(); return NULL; } - chr = chr_open(opts, subtype); + chr = chr_open(type); #if SPICE_SERVER_VERSION < 0x000901 /* See comment in vmc_state() */ - if (strcmp(subtype, "vdagent") == 0) { + if (strcmp(type, "vdagent") == 0) { qemu_chr_generic_open(chr); } #endif @@ -277,18 +272,17 @@ CharDriverState *qemu_chr_open_spice(QemuOpts *opts) } #if SPICE_SERVER_VERSION >= 0x000c02 -CharDriverState *qemu_chr_open_spice_port(QemuOpts *opts) +CharDriverState *qemu_chr_open_spice_port(const char *name) { CharDriverState *chr; SpiceCharDriver *s; - const char *name = qemu_opt_get(opts, "name"); if (name == NULL) { fprintf(stderr, "spice-qemu-char: missing name parameter\n"); return NULL; } - chr = chr_open(opts, "port"); + chr = chr_open("port"); s = chr->opaque; s->sin.portname = name; @@ -308,12 +302,38 @@ void qemu_spice_register_ports(void) } #endif +static void qemu_chr_parse_spice_vmc(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *name = qemu_opt_get(opts, "name"); + + if (name == NULL) { + error_setg(errp, "chardev: spice channel: no name given"); + return; + } + backend->spicevmc = g_new0(ChardevSpiceChannel, 1); + backend->spicevmc->type = g_strdup(name); +} + +static void qemu_chr_parse_spice_port(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + const char *name = qemu_opt_get(opts, "name"); + + if (name == NULL) { + error_setg(errp, "chardev: spice port: no name given"); + return; + } + backend->spiceport = g_new0(ChardevSpicePort, 1); + backend->spiceport->fqdn = g_strdup(name); +} + static void register_types(void) { - register_char_driver("spicevmc", qemu_chr_open_spice); -#if SPICE_SERVER_VERSION >= 0x000c02 - register_char_driver("spiceport", qemu_chr_open_spice_port); -#endif + register_char_driver_qapi("spicevmc", CHARDEV_BACKEND_KIND_SPICEVMC, + qemu_chr_parse_spice_vmc); + register_char_driver_qapi("spiceport", CHARDEV_BACKEND_KIND_SPICEPORT, + qemu_chr_parse_spice_port); } type_init(register_types); From 702ec69cc1aa87a1e53d1b066a38a9eb0fa7845b Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Mon, 25 Feb 2013 15:52:32 +0100 Subject: [PATCH 14/20] chardev: add vc support to qapi This patch adds 'vc' support to qapi and also switches over the vc chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- include/ui/console.h | 4 +-- qapi-schema.json | 20 ++++++++++++++- qemu-char.c | 3 +++ ui/console.c | 61 +++++++++++++++++++++++++++++++++++--------- ui/gtk.c | 2 +- 5 files changed, 74 insertions(+), 16 deletions(-) diff --git a/include/ui/console.h b/include/ui/console.h index c42bca6efe..a37cf65602 100644 --- a/include/ui/console.h +++ b/include/ui/console.h @@ -450,9 +450,9 @@ void qemu_console_resize(DisplayState *ds, int width, int height); void qemu_console_copy(DisplayState *ds, int src_x, int src_y, int dst_x, int dst_y, int w, int h); -typedef CharDriverState *(VcHandler)(QemuOpts *); +typedef CharDriverState *(VcHandler)(ChardevVC *vc); -CharDriverState *vc_init(QemuOpts *opts); +CharDriverState *vc_init(ChardevVC *vc); void register_vc_handler(VcHandler *handler); /* sdl.c */ diff --git a/qapi-schema.json b/qapi-schema.json index dad4d4aed1..4ee5650293 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3230,6 +3230,23 @@ ## { 'type': 'ChardevSpicePort', 'data': { 'fqdn' : 'str' } } +## +# @ChardevVC: +# +# Configuration info for virtual console chardevs. +# +# @width: console width, in pixels +# @height: console height, in pixels +# @cols: console width, in chars +# @rows: console height, in chars +# +# Since: 1.5 +## +{ 'type': 'ChardevVC', 'data': { '*width' : 'int', + '*height' : 'int', + '*cols' : 'int', + '*rows' : 'int' } } + ## # @ChardevBackend: # @@ -3252,7 +3269,8 @@ 'stdio' : 'ChardevStdio', 'console': 'ChardevDummy', 'spicevmc' : 'ChardevSpiceChannel', - 'spiceport' : 'ChardevSpicePort' } } + 'spiceport' : 'ChardevSpicePort', + 'vc' : 'ChardevVC' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index f13374770a..2d62ee9e26 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -3737,6 +3737,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, chr = qemu_chr_open_spice_port(backend->spiceport->fqdn); break; #endif + case CHARDEV_BACKEND_KIND_VC: + chr = vc_init(backend->vc); + break; default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; diff --git a/ui/console.c b/ui/console.c index 83a6fa3969..27e87f8879 100644 --- a/ui/console.c +++ b/ui/console.c @@ -1537,22 +1537,26 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds) chr->init(chr); } -static CharDriverState *text_console_init(QemuOpts *opts) +static CharDriverState *text_console_init(ChardevVC *vc) { CharDriverState *chr; QemuConsole *s; - unsigned width; - unsigned height; + unsigned width = 0; + unsigned height = 0; chr = g_malloc0(sizeof(CharDriverState)); - width = qemu_opt_get_number(opts, "width", 0); - if (width == 0) - width = qemu_opt_get_number(opts, "cols", 0) * FONT_WIDTH; + if (vc->has_width) { + width = vc->width; + } else if (vc->has_cols) { + width = vc->cols * FONT_WIDTH; + } - height = qemu_opt_get_number(opts, "height", 0); - if (height == 0) - height = qemu_opt_get_number(opts, "rows", 0) * FONT_HEIGHT; + if (vc->has_height) { + height = vc->height; + } else if (vc->has_rows) { + height = vc->rows * FONT_HEIGHT; + } if (width == 0 || height == 0) { s = new_console(NULL, TEXT_CONSOLE); @@ -1575,9 +1579,9 @@ static CharDriverState *text_console_init(QemuOpts *opts) static VcHandler *vc_handler = text_console_init; -CharDriverState *vc_init(QemuOpts *opts) +CharDriverState *vc_init(ChardevVC *vc) { - return vc_handler(opts); + return vc_handler(vc); } void register_vc_handler(VcHandler *handler) @@ -1740,9 +1744,42 @@ PixelFormat qemu_default_pixelformat(int bpp) return pf; } +static void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + int val; + + backend->vc = g_new0(ChardevVC, 1); + + val = qemu_opt_get_number(opts, "width", 0); + if (val != 0) { + backend->vc->has_width = true; + backend->vc->width = val; + } + + val = qemu_opt_get_number(opts, "height", 0); + if (val != 0) { + backend->vc->has_height = true; + backend->vc->height = val; + } + + val = qemu_opt_get_number(opts, "cols", 0); + if (val != 0) { + backend->vc->has_cols = true; + backend->vc->cols = val; + } + + val = qemu_opt_get_number(opts, "rows", 0); + if (val != 0) { + backend->vc->has_rows = true; + backend->vc->rows = val; + } +} + static void register_types(void) { - register_char_driver("vc", text_console_init); + register_char_driver_qapi("vc", CHARDEV_BACKEND_KIND_VC, + qemu_chr_parse_vc); } type_init(register_types); diff --git a/ui/gtk.c b/ui/gtk.c index 544593e90d..794dab15b1 100644 --- a/ui/gtk.c +++ b/ui/gtk.c @@ -991,7 +991,7 @@ static int gd_vc_chr_write(CharDriverState *chr, const uint8_t *buf, int len) static int nb_vcs; static CharDriverState *vcs[MAX_VCS]; -static CharDriverState *gd_vc_handler(QemuOpts *opts) +static CharDriverState *gd_vc_handler(ChardevVC *unused) { CharDriverState *chr; From 1da48c658a26d0c1444d05d8d3a545d311e01026 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Tue, 26 Feb 2013 16:21:11 +0100 Subject: [PATCH 15/20] chardev: add memory (ringbuf) support to qapi This patch adds 'memory' support to qapi and also switches over the memory chardev initialization to the new qapi code path. Signed-off-by: Gerd Hoffmann --- qapi-schema.json | 14 +++++++++++++- qemu-char.c | 30 +++++++++++++++++++++++------- 2 files changed, 36 insertions(+), 8 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 4ee5650293..8d371f178d 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3247,6 +3247,17 @@ '*cols' : 'int', '*rows' : 'int' } } +## +# @ChardevRingbuf: +# +# Configuration info for memory chardevs +# +# @size: #optional Ringbuffer size, must be power of two, default is 65536 +# +# Since: 1.5 +## +{ 'type': 'ChardevRingbuf', 'data': { '*size' : 'int' } } + ## # @ChardevBackend: # @@ -3270,7 +3281,8 @@ 'console': 'ChardevDummy', 'spicevmc' : 'ChardevSpiceChannel', 'spiceport' : 'ChardevSpicePort', - 'vc' : 'ChardevVC' } } + 'vc' : 'ChardevVC', + 'memory' : 'ChardevRingbuf' } } ## # @ChardevReturn: diff --git a/qemu-char.c b/qemu-char.c index 2d62ee9e26..eb2045a5da 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -2884,7 +2884,8 @@ static void ringbuf_chr_close(struct CharDriverState *chr) chr->opaque = NULL; } -static CharDriverState *qemu_chr_open_ringbuf(QemuOpts *opts) +static CharDriverState *qemu_chr_open_ringbuf(ChardevRingbuf *opts, + Error **errp) { CharDriverState *chr; RingBufCharDriver *d; @@ -2892,14 +2893,11 @@ static CharDriverState *qemu_chr_open_ringbuf(QemuOpts *opts) chr = g_malloc0(sizeof(CharDriverState)); d = g_malloc(sizeof(*d)); - d->size = qemu_opt_get_size(opts, "size", 0); - if (d->size == 0) { - d->size = 65536; - } + d->size = opts->has_size ? opts->size : 65536; /* The size must be power of 2 */ if (d->size & (d->size - 1)) { - error_report("size of ringbuf device must be power of two"); + error_setg(errp, "size of ringbuf chardev must be power of two"); goto fail; } @@ -3201,6 +3199,20 @@ static void qemu_chr_parse_pipe(QemuOpts *opts, ChardevBackend *backend, backend->pipe->device = g_strdup(device); } +static void qemu_chr_parse_ringbuf(QemuOpts *opts, ChardevBackend *backend, + Error **errp) +{ + int val; + + backend->memory = g_new0(ChardevRingbuf, 1); + + val = qemu_opt_get_number(opts, "size", 0); + if (val != 0) { + backend->memory->has_size = true; + backend->memory->size = val; + } +} + typedef struct CharDriver { const char *name; /* old, pre qapi */ @@ -3740,6 +3752,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_VC: chr = vc_init(backend->vc); break; + case CHARDEV_BACKEND_KIND_MEMORY: + chr = qemu_chr_open_ringbuf(backend->memory, errp); + break; default: error_setg(errp, "unknown chardev backend (%d)", backend->kind); break; @@ -3782,7 +3797,8 @@ static void register_types(void) register_char_driver_qapi("null", CHARDEV_BACKEND_KIND_NULL, NULL); register_char_driver("socket", qemu_chr_open_socket); register_char_driver("udp", qemu_chr_open_udp); - register_char_driver("memory", qemu_chr_open_ringbuf); + register_char_driver_qapi("memory", CHARDEV_BACKEND_KIND_MEMORY, + qemu_chr_parse_ringbuf); register_char_driver_qapi("file", CHARDEV_BACKEND_KIND_FILE, qemu_chr_parse_file_out); register_char_driver_qapi("stdio", CHARDEV_BACKEND_KIND_STDIO, From 3ecc059dcd06a79495d1bf171ef7f193eff79e98 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Wed, 27 Feb 2013 14:10:47 +0100 Subject: [PATCH 16/20] chardev: add udp support to qapi This patch adds 'udp' support to qapi. Signed-off-by: Gerd Hoffmann --- include/qemu/sockets.h | 1 + qapi-schema.json | 16 ++++++++++++++- qemu-char.c | 44 +++++++++++++++++++++++++----------------- util/qemu-sockets.c | 25 ++++++++++++++++++++++++ 4 files changed, 67 insertions(+), 19 deletions(-) diff --git a/include/qemu/sockets.h b/include/qemu/sockets.h index c5cee4bf2f..ae5c21cba3 100644 --- a/include/qemu/sockets.h +++ b/include/qemu/sockets.h @@ -71,6 +71,7 @@ SocketAddress *socket_parse(const char *str, Error **errp); int socket_connect(SocketAddress *addr, Error **errp, NonBlockingConnectHandler *callback, void *opaque); int socket_listen(SocketAddress *addr, Error **errp); +int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp); /* Old, ipv4 only bits. Don't use for new code. */ int parse_host_port(struct sockaddr_in *saddr, const char *str); diff --git a/qapi-schema.json b/qapi-schema.json index 8d371f178d..fdaa9da133 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -3166,7 +3166,7 @@ ## # @ChardevSocket: # -# Configuration info for socket chardevs. +# Configuration info for (stream) socket chardevs. # # @addr: socket address to listen on (server=true) # or connect to (server=false) @@ -3184,6 +3184,19 @@ '*nodelay' : 'bool', '*telnet' : 'bool' } } +## +# @ChardevDgram: +# +# Configuration info for datagram socket chardevs. +# +# @remote: remote address +# @local: #optional local address +# +# Since: 1.5 +## +{ 'type': 'ChardevDgram', 'data': { 'remote' : 'SocketAddress', + '*local' : 'SocketAddress' } } + ## # @ChardevMux: # @@ -3272,6 +3285,7 @@ 'parallel': 'ChardevHostdev', 'pipe' : 'ChardevHostdev', 'socket' : 'ChardevSocket', + 'dgram' : 'ChardevDgram', 'pty' : 'ChardevDummy', 'null' : 'ChardevDummy', 'mux' : 'ChardevMux', diff --git a/qemu-char.c b/qemu-char.c index eb2045a5da..7e13757af6 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -2261,21 +2261,14 @@ static void udp_chr_close(CharDriverState *chr) qemu_chr_be_event(chr, CHR_EVENT_CLOSED); } -static CharDriverState *qemu_chr_open_udp(QemuOpts *opts) +static CharDriverState *qemu_chr_open_udp_fd(int fd) { CharDriverState *chr = NULL; NetCharDriver *s = NULL; - Error *local_err = NULL; - int fd = -1; chr = g_malloc0(sizeof(CharDriverState)); s = g_malloc0(sizeof(NetCharDriver)); - fd = inet_dgram_opts(opts, &local_err); - if (fd < 0) { - goto return_err; - } - s->fd = fd; s->chan = io_channel_from_socket(s->fd); s->bufcnt = 0; @@ -2285,18 +2278,18 @@ static CharDriverState *qemu_chr_open_udp(QemuOpts *opts) chr->chr_update_read_handler = udp_chr_update_read_handler; chr->chr_close = udp_chr_close; return chr; +} -return_err: - if (local_err) { - qerror_report_err(local_err); - error_free(local_err); +static CharDriverState *qemu_chr_open_udp(QemuOpts *opts) +{ + Error *local_err = NULL; + int fd = -1; + + fd = inet_dgram_opts(opts, &local_err); + if (fd < 0) { + return NULL; } - g_free(chr); - g_free(s); - if (fd >= 0) { - closesocket(fd); - } - return NULL; + return qemu_chr_open_udp_fd(fd); } /***********************************************************/ @@ -3679,6 +3672,18 @@ static CharDriverState *qmp_chardev_open_socket(ChardevSocket *sock, is_telnet, is_waitconnect, errp); } +static CharDriverState *qmp_chardev_open_dgram(ChardevDgram *dgram, + Error **errp) +{ + int fd; + + fd = socket_dgram(dgram->remote, dgram->local, errp); + if (error_is_set(errp)) { + return NULL; + } + return qemu_chr_open_udp_fd(fd); +} + ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, Error **errp) { @@ -3708,6 +3713,9 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend, case CHARDEV_BACKEND_KIND_SOCKET: chr = qmp_chardev_open_socket(backend->socket, errp); break; + case CHARDEV_BACKEND_KIND_DGRAM: + chr = qmp_chardev_open_dgram(backend->dgram, errp); + break; #ifdef HAVE_CHARDEV_TTY case CHARDEV_BACKEND_KIND_PTY: chr = qemu_chr_open_pty(id, ret); diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c index 3f122965ad..83e4e08e85 100644 --- a/util/qemu-sockets.c +++ b/util/qemu-sockets.c @@ -949,6 +949,31 @@ int socket_listen(SocketAddress *addr, Error **errp) return fd; } +int socket_dgram(SocketAddress *remote, SocketAddress *local, Error **errp) +{ + QemuOpts *opts; + int fd; + + opts = qemu_opts_create_nofail(&dummy_opts); + switch (remote->kind) { + case SOCKET_ADDRESS_KIND_INET: + qemu_opt_set(opts, "host", remote->inet->host); + qemu_opt_set(opts, "port", remote->inet->port); + if (local) { + qemu_opt_set(opts, "localaddr", local->inet->host); + qemu_opt_set(opts, "localport", local->inet->port); + } + fd = inet_dgram_opts(opts, errp); + break; + + default: + error_setg(errp, "socket type unsupported for datagram"); + return -1; + } + qemu_opts_del(opts); + return fd; +} + #ifdef _WIN32 static void socket_cleanup(void) { From 46920825402d38a4111cca8099d1261f8f80c03c Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Thu, 28 Feb 2013 08:46:10 +0100 Subject: [PATCH 17/20] Revert "hmp: Disable chardev-add and chardev-remove" This reverts commit 8a14952c9d2f5fa2b3caa6dc286b62ed5d26bca7. --- hmp-commands.hx | 63 ++++++++++++++++++++++++------------------------- 1 file changed, 31 insertions(+), 32 deletions(-) diff --git a/hmp-commands.hx b/hmp-commands.hx index 4bda3fea0e..df44906ef9 100644 --- a/hmp-commands.hx +++ b/hmp-commands.hx @@ -1522,38 +1522,37 @@ passed since 1970, i.e. unix epoch. @end table ETEXI -HXCOMM Disabled for now, because it isn't built on top of QMP's chardev-add -HXCOMM { -HXCOMM .name = "chardev-add", -HXCOMM .args_type = "args:s", -HXCOMM .params = "args", -HXCOMM .help = "add chardev", -HXCOMM .mhandler.cmd = hmp_chardev_add, -HXCOMM }, -HXCOMM -HXCOMM STEXI -HXCOMM @item chardev_add args -HXCOMM @findex chardev_add -HXCOMM -HXCOMM chardev_add accepts the same parameters as the -chardev command line switch. -HXCOMM -HXCOMM ETEXI -HXCOMM -HXCOMM { -HXCOMM .name = "chardev-remove", -HXCOMM .args_type = "id:s", -HXCOMM .params = "id", -HXCOMM .help = "remove chardev", -HXCOMM .mhandler.cmd = hmp_chardev_remove, -HXCOMM }, -HXCOMM -HXCOMM STEXI -HXCOMM @item chardev_remove id -HXCOMM @findex chardev_remove -HXCOMM -HXCOMM Removes the chardev @var{id}. -HXCOMM -HXCOMM ETEXI + { + .name = "chardev-add", + .args_type = "args:s", + .params = "args", + .help = "add chardev", + .mhandler.cmd = hmp_chardev_add, + }, + +STEXI +@item chardev_add args +@findex chardev_add + +chardev_add accepts the same parameters as the -chardev command line switch. + +ETEXI + + { + .name = "chardev-remove", + .args_type = "id:s", + .params = "id", + .help = "remove chardev", + .mhandler.cmd = hmp_chardev_remove, + }, + +STEXI +@item chardev_remove id +@findex chardev_remove + +Removes the chardev @var{id}. + +ETEXI { .name = "info", From e5545854dd1e2e3507b210ac0c1cbfca69ff0fcb Mon Sep 17 00:00:00 2001 From: Igor Mitsyanko Date: Sun, 10 Mar 2013 17:58:05 +0400 Subject: [PATCH 18/20] qemu-char.c: fix waiting for telnet connection message Current colon position in "waiting for telnet connection" message template produces messages like: QEMU waiting for connection on: telnet::127.0.0.16666,server After moving a colon to the right, we will get a correct messages like: QEMU waiting for connection on: telnet:127.0.0.1:6666,server Signed-off-by: Igor Mitsyanko Signed-off-by: Gerd Hoffmann --- qemu-char.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qemu-char.c b/qemu-char.c index 7e13757af6..e6337971a5 100644 --- a/qemu-char.c +++ b/qemu-char.c @@ -2656,7 +2656,7 @@ static CharDriverState *qemu_chr_open_socket_fd(int fd, bool do_nodelay, s->do_nodelay = do_nodelay; getnameinfo((struct sockaddr *) &ss, ss_len, host, sizeof(host), serv, sizeof(serv), NI_NUMERICHOST | NI_NUMERICSERV); - snprintf(chr->filename, 256, "%s:%s:%s%s%s%s", + snprintf(chr->filename, 256, "%s:%s%s%s:%s%s", is_telnet ? "telnet" : "tcp", left, host, right, serv, is_listen ? ",server" : ""); From 5e9b473a3d7fbb915df4b3f5487e5056762087f8 Mon Sep 17 00:00:00 2001 From: Hans de Goede Date: Wed, 13 Mar 2013 10:41:31 +0100 Subject: [PATCH 19/20] spice-qemu-char: Fix name parameter issues after qapi-ifying The strings passed in through the qapi calls are dynamic memory, since we want to have them stick around longer then just the call to qemu_chr_open_spice_* we need to strdup them. Signed-off-by: Hans de Goede Signed-off-by: Gerd Hoffmann --- spice-qemu-char.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/spice-qemu-char.c b/spice-qemu-char.c index 0c92ca850b..a94f76ba2a 100644 --- a/spice-qemu-char.c +++ b/spice-qemu-char.c @@ -185,6 +185,11 @@ static void spice_chr_close(struct CharDriverState *chr) printf("%s\n", __func__); vmc_unregister_interface(s); QLIST_REMOVE(s, next); + + g_free((char *)s->sin.subtype); +#if SPICE_SERVER_VERSION >= 0x000c02 + g_free((char *)s->sin.portname); +#endif g_free(s); } @@ -226,7 +231,7 @@ static CharDriverState *chr_open(const char *subtype) s = g_malloc0(sizeof(SpiceCharDriver)); s->chr = chr; s->active = false; - s->sin.subtype = subtype; + s->sin.subtype = g_strdup(subtype); chr->opaque = s; chr->chr_write = spice_chr_write; chr->chr_close = spice_chr_close; @@ -284,7 +289,7 @@ CharDriverState *qemu_chr_open_spice_port(const char *name) chr = chr_open("port"); s = chr->opaque; - s->sin.portname = name; + s->sin.portname = g_strdup(name); return chr; } From 344bf1e935163d8a4c3cce3ec4c636e1ebd035ce Mon Sep 17 00:00:00 2001 From: Hans de Goede Date: Wed, 13 Mar 2013 14:59:44 +0100 Subject: [PATCH 20/20] spice-qemu-char: Remove dead debugging code Since commit d62e5f7036a018b2ad09f17ebd481bd28953d783 "chardev: add spice support to qapi" It is impossible to set the debug parameter, so all the dprintf calls are essentially nops. Since we've not needed the debug parameter in ages this is not a problem, if it later turns out we do need some more debugging options we can add more trace-points. Signed-off-by: Hans de Goede Signed-off-by: Gerd Hoffmann --- spice-qemu-char.c | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/spice-qemu-char.c b/spice-qemu-char.c index a94f76ba2a..8a9236d0a8 100644 --- a/spice-qemu-char.c +++ b/spice-qemu-char.c @@ -8,14 +8,6 @@ #include "qemu/osdep.h" -#define dprintf(_scd, _level, _fmt, ...) \ - do { \ - static unsigned __dprintf_counter = 0; \ - if (_scd->debug >= _level) { \ - fprintf(stderr, "scd: %3d: " _fmt, ++__dprintf_counter, ## __VA_ARGS__);\ - } \ - } while (0) - typedef struct SpiceCharDriver { CharDriverState* chr; SpiceCharDeviceInstance sin; @@ -24,7 +16,6 @@ typedef struct SpiceCharDriver { uint8_t *buffer; uint8_t *datapos; ssize_t bufsize, datalen; - uint32_t debug; QLIST_ENTRY(SpiceCharDriver) next; } SpiceCharDriver; @@ -49,7 +40,6 @@ static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len) p += last_out; } - dprintf(scd, 3, "%s: %zu/%zd\n", __func__, out, len + out); trace_spice_vmc_write(out, len + out); return out; } @@ -59,7 +49,6 @@ static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len) SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin); int bytes = MIN(len, scd->datalen); - dprintf(scd, 2, "%s: %p %d/%d/%zd\n", __func__, scd->datapos, len, bytes, scd->datalen); if (bytes > 0) { memcpy(buf, scd->datapos, bytes); scd->datapos += bytes; @@ -84,11 +73,9 @@ static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event) chr_event = CHR_EVENT_BREAK; break; default: - dprintf(scd, 2, "%s: unknown %d\n", __func__, event); return; } - dprintf(scd, 2, "%s: %d\n", __func__, event); trace_spice_vmc_event(chr_event); qemu_chr_be_event(scd->chr, chr_event); } @@ -141,7 +128,6 @@ static void vmc_register_interface(SpiceCharDriver *scd) if (scd->active) { return; } - dprintf(scd, 1, "%s\n", __func__); scd->sin.base.sif = &vmc_interface.base; qemu_spice_add_interface(&scd->sin.base); scd->active = true; @@ -153,7 +139,6 @@ static void vmc_unregister_interface(SpiceCharDriver *scd) if (!scd->active) { return; } - dprintf(scd, 1, "%s\n", __func__); spice_server_remove_interface(&scd->sin.base); scd->active = false; trace_spice_vmc_unregister_interface(scd); @@ -164,7 +149,6 @@ static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { SpiceCharDriver *s = chr->opaque; - dprintf(s, 2, "%s: %d\n", __func__, len); vmc_register_interface(s); assert(s->datalen == 0); if (s->bufsize < len) { @@ -182,7 +166,6 @@ static void spice_chr_close(struct CharDriverState *chr) { SpiceCharDriver *s = chr->opaque; - printf("%s\n", __func__); vmc_unregister_interface(s); QLIST_REMOVE(s, next);