OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

-----BEGIN PGP SIGNATURE----- 

iQIcBAABAgAGBQJZMbiwAAoJENro4Ql1lpzlEm0P/RViCB92pz62wdcsjpXvqwBO
 ddhfQqPaGE+BD1tRcrOxDFKTWEnxFN4Oj9zNQ+/FgLcckZ5qAy6PkuCnesG2eJjG
 c43y07e+u89G8L+7zLoAw+fYt8tnb5+ood6Q6WWH9rbNHLaIlMvwzomm3Rkf+1L/
 PKVixcnFBxulTTftLgVUqpFSRrDDlywrmK9gjoDRHeIp7fZTxUib5T720ShszZe5
 C2iym5Ucb5ohEoq4LfY+mPWVGkTdMtsX3Vz5eHsTqoYYY1akTg5CwgGQuqbS/kXN
 7/4nkX6otkxTlU1+ydWEQCpD3orWEUJUeKUlLA48rAckqJyX3mfx94AeIOYseILM
 vMdxQo549ofcann1RtHyPkgfwyl8rrFRZ2xdkYGeSJ2zyv6Ekcxs0r5NXX7DMZBY
 oyjH38UTpHBhZp5l/0KAff0y0FNnDz6JJttgkcqHz8Qd4chE6JP9X9gx+9xkakst
 ytbiFP5NuG9RTwWjFSXObgZl9QU/n+JuJ/kr/LMMTgmPYwONW3NglBGgAoRDu/gC
 4YAmdSWf2UYlQg1IxTn2KT4U4Dn56DEmcaL9yDBH+UJLhWpxle9+D2MVruJN7MPS
 H0/8ytXvmb99DMWOhIdRmOzWCmQ/YAg/CAXmUZPX7sul0b3TNhSDqEi2qnLR84GT
 GSOh5aGbQ2H8DGQioGLV
 =5eL6
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/elmarco/tags/chrfe-pull-request' into staging

# gpg: Signature made Fri 02 Jun 2017 20:12:48 BST
# gpg:                using RSA key 0xDAE8E10975969CE5
# gpg: Good signature from "Marc-André Lureau <marcandre.lureau@redhat.com>"
# gpg:                 aka "Marc-André Lureau <marcandre.lureau@gmail.com>"
# gpg: WARNING: This key is not certified with sufficiently trusted signatures!
# gpg:          It is not certain that the signature belongs to the owner.
# Primary key fingerprint: 87A9 BD93 3F87 C606 D276  F62D DAE8 E109 7596 9CE5

* remotes/elmarco/tags/chrfe-pull-request:
  char: move char devices to chardev/
  char: make chr_fe_deinit() optionaly delete backend
  char: rename functions that are not part of fe
  char: move CharBackend handling in char-fe unit
  char: generalize qemu_chr_write_all()
  be-hci: use backend functions
  chardev: serial & parallel declaration to own headers
  chardev: move headers to include/chardev
  Remove/replace sysemu/char.h inclusion
  char-win: close file handle except with console
  char-win: rename hcom->file
  char-win: rename win_chr_init/poll win_chr_serial_init/poll
  char-win: remove WinChardev.len
  char-win: simplify win_chr_read()
  char: cast ARRAY_SIZE() as signed to silent warning on empty array

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2017-06-05 10:09:14 +01:00
parent c6e84fbd44 6b10e573d1
commit cb8b8ef457
120 changed files with 1126 additions and 1158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
MAINTAINERS
View File

@ -1238,13 +1238,12 @@ M: Paolo Bonzini <pbonzini@redhat.com>
M: Marc-André Lureau <marcandre.lureau@redhat.com>
S: Maintained
F: chardev/
F: backends/msmouse.c
F: backends/testdev.c
F: include/chardev/
Character Devices (Braille)
M: Samuel Thibault <samuel.thibault@ens-lyon.org>
S: Maintained
F: backends/baum.c
F: chardev/baum.c
Command line option argument parsing
M: Markus Armbruster <armbru@redhat.com>

4
Makefile.objs
View File

@ -50,8 +50,6 @@ common-obj-$(CONFIG_LINUX) += fsdev/
common-obj-y += migration/
common-obj-$(CONFIG_SPICE) += spice-qemu-char.o
common-obj-y += audio/
common-obj-y += hw/
common-obj-y += accel.o
@ -70,6 +68,7 @@ common-obj-y += tpm.o
common-obj-$(CONFIG_SLIRP) += slirp/
common-obj-y += backends/
common-obj-y += chardev/
common-obj-$(CONFIG_SECCOMP) += qemu-seccomp.o
@ -121,6 +120,7 @@ trace-events-subdirs += io
trace-events-subdirs += migration
trace-events-subdirs += block
trace-events-subdirs += backends
trace-events-subdirs += chardev
trace-events-subdirs += hw/block
trace-events-subdirs += hw/block/dataplane
trace-events-subdirs += hw/char

4
backends/Makefile.objs
View File

@ -1,10 +1,6 @@
common-obj-y += rng.o rng-egd.o
common-obj-$(CONFIG_POSIX) += rng-random.o
common-obj-y += msmouse.o wctablet.o testdev.o
common-obj-$(CONFIG_BRLAPI) += baum.o
baum.o-cflags := $(SDL_CFLAGS)
common-obj-$(CONFIG_TPM) += tpm.o
common-obj-y += hostmem.o hostmem-ram.o

4
backends/rng-egd.c
View File

@ -12,7 +12,7 @@
#include "qemu/osdep.h"
#include "sysemu/rng.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qapi/error.h"
#include "qapi/qmp/qerror.h"
@ -145,7 +145,7 @@ static void rng_egd_finalize(Object *obj)
{
RngEgd *s = RNG_EGD(obj);
qemu_chr_fe_deinit(&s->chr);
qemu_chr_fe_deinit(&s->chr, false);
g_free(s->chr_name);
}

10
backends/trace-events
View File

@ -1,10 +0,0 @@
# See docs/tracing.txt for syntax documentation.
# backends/wctablet.c
wct_init(void) ""
wct_cmd_re(void) ""
wct_cmd_st(void) ""
wct_cmd_sp(void) ""
wct_cmd_ts(int input) "0x%02x"
wct_cmd_other(const char *cmd) "%s"
wct_speed(int speed) "%d"

7
chardev/Makefile.objs
View File

@ -1,6 +1,7 @@
chardev-obj-y += char.o
chardev-obj-$(CONFIG_WIN32) += char-console.o
chardev-obj-$(CONFIG_POSIX) += char-fd.o
chardev-obj-y += char-fe.o
chardev-obj-y += char-file.o
chardev-obj-y += char-io.o
chardev-obj-y += char-mux.o
@ -15,3 +16,9 @@ chardev-obj-y += char-stdio.o
chardev-obj-y += char-udp.o
chardev-obj-$(CONFIG_WIN32) += char-win.o
chardev-obj-$(CONFIG_WIN32) += char-win-stdio.o
common-obj-y += msmouse.o wctablet.o testdev.o
common-obj-$(CONFIG_BRLAPI) += baum.o
baum.o-cflags := $(SDL_CFLAGS)
common-obj-$(CONFIG_SPICE) += spice.o

2
backends/baum.c → chardev/baum.c
View File

@ -24,7 +24,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qemu/timer.h"
#include "hw/usb.h"
#include "ui/console.h"

4
chardev/char-console.c
View File

@ -22,14 +22,14 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "char-win.h"
#include "chardev/char-win.h"
static void qemu_chr_open_win_con(Chardev *chr,
ChardevBackend *backend,
bool *be_opened,
Error **errp)
{
qemu_chr_open_win_file(chr, GetStdHandle(STD_OUTPUT_HANDLE));
win_chr_set_file(chr, GetStdHandle(STD_OUTPUT_HANDLE), true);
}
static void char_console_class_init(ObjectClass *oc, void *data)

6
chardev/char-fd.c
View File

@ -25,11 +25,11 @@
#include "qemu/sockets.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "io/channel-file.h"
#include "char-fd.h"
#include "char-io.h"
#include "chardev/char-fd.h"
#include "chardev/char-io.h"
/* Called with chr_write_lock held. */
static int fd_chr_write(Chardev *chr, const uint8_t *buf, int len)

361
chardev/char-fe.c Normal file
View File

@ -0,0 +1,361 @@
/*
* QEMU System Emulator
*
* Copyright (c) 2003-2008 Fabrice Bellard
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "qapi-visit.h"
#include "sysemu/replay.h"
#include "chardev/char-fe.h"
#include "chardev/char-io.h"
#include "chardev/char-mux.h"
int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
{
Chardev *s = be->chr;
if (!s) {
return 0;
}
return qemu_chr_write(s, buf, len, false);
}
int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
{
Chardev *s = be->chr;
if (!s) {
return 0;
}
return qemu_chr_write(s, buf, len, true);
}
int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
{
Chardev *s = be->chr;
int offset = 0, counter = 10;
int res;
if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
return 0;
}
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
return replay_char_read_all_load(buf);
}
while (offset < len) {
retry:
res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
len - offset);
if (res == -1 && errno == EAGAIN) {
g_usleep(100);
goto retry;
}
if (res == 0) {
break;
}
if (res < 0) {
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_read_all_save_error(res);
}
return res;
}
offset += res;
if (!counter--) {
break;
}
}
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_read_all_save_buf(buf, offset);
}
return offset;
}
int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
{
Chardev *s = be->chr;
int res;
if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
res = -ENOTSUP;
} else {
res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
}
return res;
}
int qemu_chr_fe_get_msgfd(CharBackend *be)
{
Chardev *s = be->chr;
int fd;
int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
if (s && qemu_chr_replay(s)) {
error_report("Replay: get msgfd is not supported "
"for serial devices yet");
exit(1);
}
return res;
}
int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
{
Chardev *s = be->chr;
if (!s) {
return -1;
}
return CHARDEV_GET_CLASS(s)->get_msgfds ?
CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
}
int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
{
Chardev *s = be->chr;
if (!s) {
return -1;
}
return CHARDEV_GET_CLASS(s)->set_msgfds ?
CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
}
void qemu_chr_fe_accept_input(CharBackend *be)
{
Chardev *s = be->chr;
if (!s) {
return;
}
if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
CHARDEV_GET_CLASS(s)->chr_accept_input(s);
}
qemu_notify_event();
}
void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
{
char buf[CHR_READ_BUF_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
/* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
va_end(ap);
}
Chardev *qemu_chr_fe_get_driver(CharBackend *be)
{
return be->chr;
}
bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
{
int tag = 0;
if (CHARDEV_IS_MUX(s)) {
MuxChardev *d = MUX_CHARDEV(s);
if (d->mux_cnt >= MAX_MUX) {
goto unavailable;
}
d->backends[d->mux_cnt] = b;
tag = d->mux_cnt++;
} else if (s->be) {
goto unavailable;
} else {
s->be = b;
}
b->fe_open = false;
b->tag = tag;
b->chr = s;
return true;
unavailable:
error_setg(errp, QERR_DEVICE_IN_USE, s->label);
return false;
}
void qemu_chr_fe_deinit(CharBackend *b, bool del)
{
assert(b);
if (b->chr) {
qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
if (b->chr->be == b) {
b->chr->be = NULL;
}
if (CHARDEV_IS_MUX(b->chr)) {
MuxChardev *d = MUX_CHARDEV(b->chr);
d->backends[b->tag] = NULL;
}
if (del) {
object_unparent(OBJECT(b->chr));
}
b->chr = NULL;
}
}
void qemu_chr_fe_set_handlers(CharBackend *b,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
void *opaque,
GMainContext *context,
bool set_open)
{
Chardev *s;
ChardevClass *cc;
int fe_open;
s = b->chr;
if (!s) {
return;
}
cc = CHARDEV_GET_CLASS(s);
if (!opaque && !fd_can_read && !fd_read && !fd_event) {
fe_open = 0;
remove_fd_in_watch(s);
} else {
fe_open = 1;
}
b->chr_can_read = fd_can_read;
b->chr_read = fd_read;
b->chr_event = fd_event;
b->opaque = opaque;
if (cc->chr_update_read_handler) {
cc->chr_update_read_handler(s, context);
}
if (set_open) {
qemu_chr_fe_set_open(b, fe_open);
}
if (fe_open) {
qemu_chr_fe_take_focus(b);
/* We're connecting to an already opened device, so let's make sure we
also get the open event */
if (s->be_open) {
qemu_chr_be_event(s, CHR_EVENT_OPENED);
}
}
if (CHARDEV_IS_MUX(s)) {
mux_chr_set_handlers(s, context);
}
}
void qemu_chr_fe_take_focus(CharBackend *b)
{
if (!b->chr) {
return;
}
if (CHARDEV_IS_MUX(b->chr)) {
mux_set_focus(b->chr, b->tag);
}
}
int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
{
if (!be->chr) {
error_setg(errp, "missing associated backend");
return -1;
}
return qemu_chr_wait_connected(be->chr, errp);
}
void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
{
Chardev *chr = be->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
}
}
void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
{
Chardev *chr = be->chr;
if (!chr) {
return;
}
if (be->fe_open == fe_open) {
return;
}
be->fe_open = fe_open;
if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
}
}
guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
GIOFunc func, void *user_data)
{
Chardev *s = be->chr;
GSource *src;
guint tag;
if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
return 0;
}
src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
if (!src) {
return 0;
}
g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
tag = g_source_attach(src, NULL);
g_source_unref(src);
return tag;
}
void qemu_chr_fe_disconnect(CharBackend *be)
{
Chardev *chr = be->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
}
}

8
chardev/char-file.c
View File

@ -24,12 +24,12 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#ifdef _WIN32
#include "char-win.h"
#include "chardev/char-win.h"
#else
#include "char-fd.h"
#include "chardev/char-fd.h"
#endif
static void qmp_chardev_open_file(Chardev *chr,
@ -65,7 +65,7 @@ static void qmp_chardev_open_file(Chardev *chr,
return;
}
qemu_chr_open_win_file(chr, out);
win_chr_set_file(chr, out, false);
#else
int flags, in = -1, out;

2
chardev/char-io.c
View File

@ -22,7 +22,7 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "char-io.h"
#include "chardev/char-io.h"
typedef struct IOWatchPoll {
GSource parent;

6
chardev/char-mux.c
View File

@ -24,9 +24,9 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "sysemu/block-backend.h"
#include "char-mux.h"
#include "chardev/char-mux.h"
/* MUX driver for serial I/O splitting */
@ -266,7 +266,7 @@ static void char_mux_finalize(Object *obj)
be->chr = NULL;
}
}
qemu_chr_fe_deinit(&d->chr);
qemu_chr_fe_deinit(&d->chr, false);
}
void mux_chr_set_handlers(Chardev *chr, GMainContext *context)

2
chardev/char-null.c
View File

@ -22,7 +22,7 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
static void null_chr_open(Chardev *chr,
ChardevBackend *backend,

6
chardev/char-parallel.c
View File

@ -22,7 +22,7 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qapi/error.h"
#include <sys/ioctl.h>
@ -41,8 +41,8 @@
#endif
#endif
#include "char-fd.h"
#include "char-parallel.h"
#include "chardev/char-fd.h"
#include "chardev/char-parallel.h"
#if defined(__linux__)

16
chardev/char-pipe.c
View File

@ -23,12 +23,12 @@
*/
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#ifdef _WIN32
#include "char-win.h"
#include "chardev/char-win.h"
#else
#include "char-fd.h"
#include "chardev/char-fd.h"
#endif
#ifdef _WIN32
@ -58,27 +58,27 @@ static int win_chr_pipe_init(Chardev *chr, const char *filename,
}
openname = g_strdup_printf("\\\\.\\pipe\\%s", filename);
s->hcom = CreateNamedPipe(openname,
s->file = CreateNamedPipe(openname,
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
PIPE_WAIT,
MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
g_free(openname);
if (s->hcom == INVALID_HANDLE_VALUE) {
if (s->file == INVALID_HANDLE_VALUE) {
error_setg(errp, "Failed CreateNamedPipe (%lu)", GetLastError());
s->hcom = NULL;
s->file = NULL;
goto fail;
}
ZeroMemory(&ov, sizeof(ov));
ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
ret = ConnectNamedPipe(s->hcom, &ov);
ret = ConnectNamedPipe(s->file, &ov);
if (ret) {
error_setg(errp, "Failed ConnectNamedPipe");
goto fail;
}
ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
ret = GetOverlappedResult(s->file, &ov, &size, TRUE);
if (!ret) {
error_setg(errp, "Failed GetOverlappedResult");
if (ov.hEvent) {

4
chardev/char-pty.c
View File

@ -24,12 +24,12 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "io/channel-file.h"
#include "qemu/sockets.h"
#include "qemu/error-report.h"
#include "char-io.h"
#include "chardev/char-io.h"
#if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
|| defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \

2
chardev/char-ringbuf.c
View File

@ -22,7 +22,7 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qmp-commands.h"
#include "qemu/base64.h"

8
chardev/char-serial.c
View File

@ -27,14 +27,14 @@
#include "qapi/error.h"
#ifdef _WIN32
#include "char-win.h"
#include "chardev/char-win.h"
#else
#include <sys/ioctl.h>
#include <termios.h>
#include "char-fd.h"
#include "chardev/char-fd.h"
#endif
#include "char-serial.h"
#include "chardev/char-serial.h"
#ifdef _WIN32
@ -45,7 +45,7 @@ static void qmp_chardev_open_serial(Chardev *chr,
{
ChardevHostdev *serial = backend->u.serial.data;
win_chr_init(chr, serial->device, errp);
win_chr_serial_init(chr, serial->device, errp);
}
#elif defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \

4
chardev/char-socket.c
View File

@ -22,14 +22,14 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "io/channel-socket.h"
#include "io/channel-tls.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "qapi/clone-visitor.h"
#include "char-io.h"
#include "chardev/char-io.h"
/***********************************************************/
/* TCP Net console */

8
chardev/char-stdio.c
View File

@ -25,14 +25,14 @@
#include "qemu/sockets.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#ifdef _WIN32
#include "char-win.h"
#include "char-win-stdio.h"
#include "chardev/char-win.h"
#include "chardev/char-win-stdio.h"
#else
#include <termios.h>
#include "char-fd.h"
#include "chardev/char-fd.h"
#endif
#ifndef _WIN32

4
chardev/char-udp.c
View File

@ -22,11 +22,11 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "io/channel-socket.h"
#include "qapi/error.h"
#include "char-io.h"
#include "chardev/char-io.h"
/***********************************************************/
/* UDP Net console */

4
chardev/char-win-stdio.c
View File

@ -23,8 +23,8 @@
*/
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "char-win.h"
#include "char-win-stdio.h"
#include "chardev/char-win.h"
#include "chardev/char-win-stdio.h"
typedef struct {
Chardev parent;

95
chardev/char-win.c
View File

@ -24,23 +24,30 @@
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "qapi/error.h"
#include "char-win.h"
#include "chardev/char-win.h"
static void win_chr_readfile(Chardev *chr)
static void win_chr_read(Chardev *chr, DWORD len)
{
WinChardev *s = WIN_CHARDEV(chr);
int max_size = qemu_chr_be_can_write(chr);
int ret, err;
uint8_t buf[CHR_READ_BUF_LEN];
DWORD size;
if (len > max_size) {
len = max_size;
}
if (len == 0) {
return;
}
ZeroMemory(&s->orecv, sizeof(s->orecv));
s->orecv.hEvent = s->hrecv;
ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
ret = ReadFile(s->file, buf, len, &size, &s->orecv);
if (!ret) {
err = GetLastError();
if (err == ERROR_IO_PENDING) {
ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
ret = GetOverlappedResult(s->file, &s->orecv, &size, TRUE);
}
}
@ -49,46 +56,22 @@ static void win_chr_readfile(Chardev *chr)
}
}
static void win_chr_read(Chardev *chr)
{
WinChardev *s = WIN_CHARDEV(chr);
if (s->len > s->max_size) {
s->len = s->max_size;
}
if (s->len == 0) {
return;
}
win_chr_readfile(chr);
}
static int win_chr_read_poll(Chardev *chr)
{
WinChardev *s = WIN_CHARDEV(chr);
s->max_size = qemu_chr_be_can_write(chr);
return s->max_size;
}
static int win_chr_poll(void *opaque)
static int win_chr_serial_poll(void *opaque)
{
Chardev *chr = CHARDEV(opaque);
WinChardev *s = WIN_CHARDEV(opaque);
COMSTAT status;
DWORD comerr;
ClearCommError(s->hcom, &comerr, &status);
ClearCommError(s->file, &comerr, &status);
if (status.cbInQue > 0) {
s->len = status.cbInQue;
win_chr_read_poll(chr);
win_chr_read(chr);
win_chr_read(chr, status.cbInQue);
return 1;
}
return 0;
}
int win_chr_init(Chardev *chr, const char *filename, Error **errp)
int win_chr_serial_init(Chardev *chr, const char *filename, Error **errp)
{
WinChardev *s = WIN_CHARDEV(chr);
COMMCONFIG comcfg;
@ -108,15 +91,15 @@ int win_chr_init(Chardev *chr, const char *filename, Error **errp)
goto fail;
}
s->hcom = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
s->file = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, 0, NULL,
OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
if (s->hcom == INVALID_HANDLE_VALUE) {
if (s->file == INVALID_HANDLE_VALUE) {
error_setg(errp, "Failed CreateFile (%lu)", GetLastError());
s->hcom = NULL;
s->file = NULL;
goto fail;
}
if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
if (!SetupComm(s->file, NRECVBUF, NSENDBUF)) {
error_setg(errp, "Failed SetupComm");
goto fail;
}
@ -127,27 +110,27 @@ int win_chr_init(Chardev *chr, const char *filename, Error **errp)
comcfg.dcb.DCBlength = sizeof(DCB);
CommConfigDialog(filename, NULL, &comcfg);
if (!SetCommState(s->hcom, &comcfg.dcb)) {
if (!SetCommState(s->file, &comcfg.dcb)) {
error_setg(errp, "Failed SetCommState");
goto fail;
}
if (!SetCommMask(s->hcom, EV_ERR)) {
if (!SetCommMask(s->file, EV_ERR)) {
error_setg(errp, "Failed SetCommMask");
goto fail;
}
cto.ReadIntervalTimeout = MAXDWORD;
if (!SetCommTimeouts(s->hcom, &cto)) {
if (!SetCommTimeouts(s->file, &cto)) {
error_setg(errp, "Failed SetCommTimeouts");
goto fail;
}
if (!ClearCommError(s->hcom, &err, &comstat)) {
if (!ClearCommError(s->file, &err, &comstat)) {
error_setg(errp, "Failed ClearCommError");
goto fail;
}
qemu_add_polling_cb(win_chr_poll, chr);
qemu_add_polling_cb(win_chr_serial_poll, chr);
return 0;
fail:
@ -160,11 +143,9 @@ int win_chr_pipe_poll(void *opaque)
WinChardev *s = WIN_CHARDEV(opaque);
DWORD size;
PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
PeekNamedPipe(s->file, NULL, 0, NULL, &size, NULL);
if (size > 0) {
s->len = size;
win_chr_read_poll(chr);
win_chr_read(chr);
win_chr_read(chr, size);
return 1;
}
return 0;
@ -181,14 +162,14 @@ static int win_chr_write(Chardev *chr, const uint8_t *buf, int len1)
s->osend.hEvent = s->hsend;
while (len > 0) {
if (s->hsend) {
ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
ret = WriteFile(s->file, buf, len, &size, &s->osend);
} else {
ret = WriteFile(s->hcom, buf, len, &size, NULL);
ret = WriteFile(s->file, buf, len, &size, NULL);
}
if (!ret) {
err = GetLastError();
if (err == ERROR_IO_PENDING) {
ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
ret = GetOverlappedResult(s->file, &s->osend, &size, TRUE);
if (ret) {
buf += size;
len -= size;
@ -211,34 +192,30 @@ static void char_win_finalize(Object *obj)
Chardev *chr = CHARDEV(obj);
WinChardev *s = WIN_CHARDEV(chr);
if (s->skip_free) {
return;
}
if (s->hsend) {
CloseHandle(s->hsend);
}
if (s->hrecv) {
CloseHandle(s->hrecv);
}
if (s->hcom) {
CloseHandle(s->hcom);
if (!s->keep_open && s->file) {
CloseHandle(s->file);
}
if (s->fpipe) {
qemu_del_polling_cb(win_chr_pipe_poll, chr);
} else {
qemu_del_polling_cb(win_chr_poll, chr);
qemu_del_polling_cb(win_chr_serial_poll, chr);
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
void qemu_chr_open_win_file(Chardev *chr, HANDLE fd_out)
void win_chr_set_file(Chardev *chr, HANDLE file, bool keep_open)
{
WinChardev *s = WIN_CHARDEV(chr);
s->skip_free = true;
s->hcom = fd_out;
s->keep_open = keep_open;
s->file = file;
}
static void char_win_class_init(ObjectClass *oc, void *data)

390
chardev/char.c
View File

@ -22,22 +22,18 @@
* THE SOFTWARE.
*/
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "qemu/cutils.h"
#include "monitor/monitor.h"
#include "sysemu/sysemu.h"
#include "qemu/config-file.h"
#include "qemu/error-report.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qmp-commands.h"
#include "qapi-visit.h"
#include "sysemu/replay.h"
#include "qemu/help_option.h"
#include "char-mux.h"
#include "char-io.h"
#include "char-parallel.h"
#include "char-serial.h"
#include "chardev/char-mux.h"
/***********************************************************/
/* character device */
@ -70,8 +66,7 @@ void qemu_chr_be_event(Chardev *s, int event)
/* Not reporting errors from writing to logfile, as logs are
* defined to be "best effort" only */
static void qemu_chr_fe_write_log(Chardev *s,
const uint8_t *buf, size_t len)
static void qemu_chr_write_log(Chardev *s, const uint8_t *buf, size_t len)
{
size_t done = 0;
ssize_t ret;
@ -95,8 +90,9 @@ static void qemu_chr_fe_write_log(Chardev *s,
}
}
static int qemu_chr_fe_write_buffer(Chardev *s,
const uint8_t *buf, int len, int *offset)
static int qemu_chr_write_buffer(Chardev *s,
const uint8_t *buf, int len,
int *offset, bool write_all)
{
ChardevClass *cc = CHARDEV_GET_CLASS(s);
int res = 0;
@ -106,7 +102,7 @@ static int qemu_chr_fe_write_buffer(Chardev *s,
while (*offset < len) {
retry:
res = cc->chr_write(s, buf + *offset, len - *offset);
if (res < 0 && errno == EAGAIN) {
if (res < 0 && errno == EAGAIN && write_all) {
g_usleep(100);
goto retry;
}
@ -116,68 +112,31 @@ static int qemu_chr_fe_write_buffer(Chardev *s,
}
*offset += res;
if (!write_all) {
break;
}
}
if (*offset > 0) {
qemu_chr_fe_write_log(s, buf, *offset);
qemu_chr_write_log(s, buf, *offset);
}
qemu_mutex_unlock(&s->chr_write_lock);
return res;
}
static bool qemu_chr_replay(Chardev *chr)
int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all)
{
return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
}
int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
{
Chardev *s = be->chr;
ChardevClass *cc;
int ret;
if (!s) {
return 0;
}
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
int offset;
replay_char_write_event_load(&ret, &offset);
assert(offset <= len);
qemu_chr_fe_write_buffer(s, buf, offset, &offset);
return ret;
}
cc = CHARDEV_GET_CLASS(s);
qemu_mutex_lock(&s->chr_write_lock);
ret = cc->chr_write(s, buf, len);
if (ret > 0) {
qemu_chr_fe_write_log(s, buf, ret);
}
qemu_mutex_unlock(&s->chr_write_lock);
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_write_event_save(ret, ret < 0 ? 0 : ret);
}
return ret;
}
int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)
{
int offset;
int offset = 0;
int res;
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
replay_char_write_event_load(&res, &offset);
assert(offset <= len);
qemu_chr_fe_write_buffer(s, buf, offset, &offset);
qemu_chr_write_buffer(s, buf, offset, &offset, true);
return res;
}
res = qemu_chr_fe_write_buffer(s, buf, len, &offset);
res = qemu_chr_write_buffer(s, buf, len, &offset, write_all);
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_write_event_save(res, offset);
@ -189,78 +148,6 @@ int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)
return offset;
}
int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
{
Chardev *s = be->chr;
if (!s) {
return 0;
}
return qemu_chr_write_all(s, buf, len);
}
int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
{
Chardev *s = be->chr;
int offset = 0, counter = 10;
int res;
if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
return 0;
}
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
return replay_char_read_all_load(buf);
}
while (offset < len) {
retry:
res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
len - offset);
if (res == -1 && errno == EAGAIN) {
g_usleep(100);
goto retry;
}
if (res == 0) {
break;
}
if (res < 0) {
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_read_all_save_error(res);
}
return res;
}
offset += res;
if (!counter--) {
break;
}
}
if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
replay_char_read_all_save_buf(buf, offset);
}
return offset;
}
int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
{
Chardev *s = be->chr;
int res;
if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
res = -ENOTSUP;
} else {
res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
}
return res;
}
int qemu_chr_be_can_write(Chardev *s)
{
CharBackend *be = s->be;
@ -293,75 +180,12 @@ void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len)
}
}
int qemu_chr_fe_get_msgfd(CharBackend *be)
{
Chardev *s = be->chr;
int fd;
int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
if (s && qemu_chr_replay(s)) {
error_report("Replay: get msgfd is not supported "
"for serial devices yet");
exit(1);
}
return res;
}
int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
{
Chardev *s = be->chr;
if (!s) {
return -1;
}
return CHARDEV_GET_CLASS(s)->get_msgfds ?
CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
}
int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
{
Chardev *s = be->chr;
if (!s) {
return -1;
}
return CHARDEV_GET_CLASS(s)->set_msgfds ?
CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
}
int qemu_chr_add_client(Chardev *s, int fd)
{
return CHARDEV_GET_CLASS(s)->chr_add_client ?
CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
}
void qemu_chr_fe_accept_input(CharBackend *be)
{
Chardev *s = be->chr;
if (!s) {
return;
}
if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
CHARDEV_GET_CLASS(s)->chr_accept_input(s);
}
qemu_notify_event();
}
void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
{
char buf[CHR_READ_BUF_LEN];
va_list ap;
va_start(ap, fmt);
vsnprintf(buf, sizeof(buf), fmt, ap);
/* XXX this blocks entire thread. Rewrite to use
* qemu_chr_fe_write and background I/O callbacks */
qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
va_end(ap);
}
static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
bool *be_opened, Error **errp)
{
@ -473,40 +297,6 @@ static Notifier muxes_realize_notify = {
.notify = muxes_realize_done,
};
Chardev *qemu_chr_fe_get_driver(CharBackend *be)
{
return be->chr;
}
bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
{
int tag = 0;
if (CHARDEV_IS_MUX(s)) {
MuxChardev *d = MUX_CHARDEV(s);
if (d->mux_cnt >= MAX_MUX) {
goto unavailable;
}
d->backends[d->mux_cnt] = b;
tag = d->mux_cnt++;
} else if (s->be) {
goto unavailable;
} else {
s->be = b;
}
b->fe_open = false;
b->tag = tag;
b->chr = s;
return true;
unavailable:
error_setg(errp, QERR_DEVICE_IN_USE, s->label);
return false;
}
static bool qemu_chr_is_busy(Chardev *s)
{
if (CHARDEV_IS_MUX(s)) {
@ -517,84 +307,6 @@ static bool qemu_chr_is_busy(Chardev *s)
}
}
void qemu_chr_fe_deinit(CharBackend *b)
{
assert(b);
if (b->chr) {
qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
if (b->chr->be == b) {
b->chr->be = NULL;
}
if (CHARDEV_IS_MUX(b->chr)) {
MuxChardev *d = MUX_CHARDEV(b->chr);
d->backends[b->tag] = NULL;
}
b->chr = NULL;
}
}
void qemu_chr_fe_set_handlers(CharBackend *b,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
void *opaque,
GMainContext *context,
bool set_open)
{
Chardev *s;
ChardevClass *cc;
int fe_open;
s = b->chr;
if (!s) {
return;
}
cc = CHARDEV_GET_CLASS(s);
if (!opaque && !fd_can_read && !fd_read && !fd_event) {
fe_open = 0;
remove_fd_in_watch(s);
} else {
fe_open = 1;
}
b->chr_can_read = fd_can_read;
b->chr_read = fd_read;
b->chr_event = fd_event;
b->opaque = opaque;
if (cc->chr_update_read_handler) {
cc->chr_update_read_handler(s, context);
}
if (set_open) {
qemu_chr_fe_set_open(b, fe_open);
}
if (fe_open) {
qemu_chr_fe_take_focus(b);
/* We're connecting to an already opened device, so let's make sure we
also get the open event */
if (s->be_open) {
qemu_chr_be_event(s, CHR_EVENT_OPENED);
}
}
if (CHARDEV_IS_MUX(s)) {
mux_chr_set_handlers(s, context);
}
}
void qemu_chr_fe_take_focus(CharBackend *b)
{
if (!b->chr) {
return;
}
if (CHARDEV_IS_MUX(b->chr)) {
mux_set_focus(b->chr, b->tag);
}
}
int qemu_chr_wait_connected(Chardev *chr, Error **errp)
{
ChardevClass *cc = CHARDEV_GET_CLASS(chr);
@ -606,16 +318,6 @@ int qemu_chr_wait_connected(Chardev *chr, Error **errp)
return 0;
}
int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
{
if (!be->chr) {
error_setg(errp, "missing associated backend");
return -1;
}
return qemu_chr_wait_connected(be->chr, errp);
}
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
{
char host[65], port[33], width[8], height[8];
@ -841,7 +543,7 @@ chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) {
fn(chardev_alias_table[i].alias, opaque);
}
}
@ -887,7 +589,7 @@ Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
return NULL;
}
for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
for (i = 0; i < (int)ARRAY_SIZE(chardev_alias_table); i++) {
if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
name = chardev_alias_table[i].typename;
break;
@ -992,64 +694,6 @@ Chardev *qemu_chr_new(const char *label, const char *filename)
return chr;
}
void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
{
Chardev *chr = be->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
}
}
void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
{
Chardev *chr = be->chr;
if (!chr) {
return;
}
if (be->fe_open == fe_open) {
return;
}
be->fe_open = fe_open;
if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
}
}
guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
GIOFunc func, void *user_data)
{
Chardev *s = be->chr;
GSource *src;
guint tag;
if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
return 0;
}
src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
if (!src) {
return 0;
}
g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
tag = g_source_attach(src, NULL);
g_source_unref(src);
return tag;
}
void qemu_chr_fe_disconnect(CharBackend *be)
{
Chardev *chr = be->chr;
if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
}
}
static int qmp_query_chardev_foreach(Object *obj, void *data)
{
Chardev *chr = CHARDEV(obj);

2
backends/msmouse.c → chardev/msmouse.c
View File

@ -23,7 +23,7 @@
*/
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "ui/console.h"
#include "ui/input.h"

4
spice-qemu-char.c → chardev/spice.c
View File

@ -1,7 +1,7 @@
#include "qemu/osdep.h"
#include "trace-root.h"
#include "trace.h"
#include "ui/qemu-spice.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qemu/error-report.h"
#include <spice.h>
#include <spice/protocol.h>

2
backends/testdev.c → chardev/testdev.c
View File

@ -25,7 +25,7 @@
*/
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#define BUF_SIZE 32

18
chardev/trace-events Normal file
View File

@ -0,0 +1,18 @@
# See docs/tracing.txt for syntax documentation.
# chardev/wctablet.c
wct_init(void) ""
wct_cmd_re(void) ""
wct_cmd_st(void) ""
wct_cmd_sp(void) ""
wct_cmd_ts(int input) "0x%02x"
wct_cmd_other(const char *cmd) "%s"
wct_speed(int speed) "%d"
# chardev/spice.c
spice_vmc_write(ssize_t out, int len) "spice wrote %zd of requested %d"
spice_vmc_read(int bytes, int len) "spice read %d of requested %d"
spice_vmc_register_interface(void *scd) "spice vmc registered interface %p"
spice_vmc_unregister_interface(void *scd) "spice vmc unregistered interface %p"
spice_vmc_event(int event) "spice vmc event %d"

2
backends/wctablet.c → chardev/wctablet.c
View File

@ -32,7 +32,7 @@
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char-serial.h"
#include "ui/console.h"
#include "ui/input.h"
#include "trace.h"

18
gdbstub.c
View File

@ -25,7 +25,8 @@
#include "qemu.h"
#else
#include "monitor/monitor.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "chardev/char-fe.h"
#include "sysemu/sysemu.h"
#include "exec/gdbstub.h"
#endif
@ -1677,9 +1678,6 @@ void gdb_exit(CPUArchState *env, int code)
{
GDBState *s;
char buf[4];
#ifndef CONFIG_USER_ONLY
Chardev *chr;
#endif
s = gdbserver_state;
if (!s) {
@ -1689,19 +1687,13 @@ void gdb_exit(CPUArchState *env, int code)
if (gdbserver_fd < 0 || s->fd < 0) {
return;
}
#else
chr = qemu_chr_fe_get_driver(&s->chr);
if (!chr) {
return;
}
#endif
snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
put_packet(s, buf);
#ifndef CONFIG_USER_ONLY
qemu_chr_fe_deinit(&s->chr);
object_unparent(OBJECT(chr));
qemu_chr_fe_deinit(&s->chr, true);
#endif
}
@ -2001,9 +1993,7 @@ int gdbserver_start(const char *device)
NULL, &error_abort);
monitor_init(mon_chr, 0);
} else {
if (qemu_chr_fe_get_driver(&s->chr)) {
object_unparent(OBJECT(qemu_chr_fe_get_driver(&s->chr)));
}
qemu_chr_fe_deinit(&s->chr, true);
mon_chr = s->mon_chr;
memset(s, 0, sizeof(GDBState));
s->mon_chr = mon_chr;

2
hmp.c
View File

@ -17,7 +17,7 @@
#include "hmp.h"
#include "net/net.h"
#include "net/eth.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "sysemu/block-backend.h"
#include "sysemu/sysemu.h"
#include "qemu/config-file.h"

1
hw/arm/bcm2835_peripherals.c
View File

@ -13,7 +13,6 @@
#include "hw/arm/bcm2835_peripherals.h"
#include "hw/misc/bcm2835_mbox_defs.h"
#include "hw/arm/raspi_platform.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"
/* Peripheral base address on the VC (GPU) system bus */

2
hw/arm/fsl-imx25.c
View File

@ -30,7 +30,7 @@
#include "sysemu/sysemu.h"
#include "exec/address-spaces.h"
#include "hw/boards.h"
#include "sysemu/char.h"
#include "chardev/char.h"
static void fsl_imx25_init(Object *obj)
{

2
hw/arm/fsl-imx31.c
View File

@ -27,7 +27,7 @@
#include "sysemu/sysemu.h"
#include "exec/address-spaces.h"
#include "hw/boards.h"
#include "sysemu/char.h"
#include "chardev/char.h"
static void fsl_imx31_init(Object *obj)
{

2
hw/arm/fsl-imx6.c
View File

@ -24,7 +24,7 @@
#include "qemu-common.h"
#include "hw/arm/fsl-imx6.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "qemu/error-report.h"
#define NAME_SIZE 20

2
hw/arm/omap2.c
View File

@ -30,7 +30,7 @@
#include "hw/arm/omap.h"
#include "sysemu/sysemu.h"
#include "qemu/timer.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/block/flash.h"
#include "hw/arm/soc_dma.h"
#include "hw/sysbus.h"

2
hw/arm/pxa2xx.c
View File

@ -17,7 +17,7 @@
#include "hw/char/serial.h"
#include "hw/i2c/i2c.h"
#include "hw/ssi/ssi.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h"
#include "qemu/cutils.h"

3
hw/arm/strongarm.c
View File

@ -34,7 +34,8 @@
#include "strongarm.h"
#include "qemu/error-report.h"
#include "hw/arm/arm.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "chardev/char-serial.h"
#include "sysemu/sysemu.h"
#include "hw/ssi/ssi.h"
#include "qemu/cutils.h"

11
hw/bt/hci-csr.c
View File

@ -20,7 +20,7 @@
#include "qemu/osdep.h"
#include "qemu-common.h"
#include "sysemu/char.h"
#include "chardev/char-serial.h"
#include "qemu/timer.h"
#include "qemu/bswap.h"
#include "hw/irq.h"
@ -82,17 +82,14 @@ enum {
static inline void csrhci_fifo_wake(struct csrhci_s *s)
{
Chardev *chr = (Chardev *)s;
CharBackend *be = chr->be;
Chardev *chr = CHARDEV(s);
if (!s->enable || !s->out_len)
return;
/* XXX: Should wait for s->modem_state & CHR_TIOCM_RTS? */
if (be && be->chr_can_read && be->chr_can_read(be->opaque) &&
be->chr_read) {
be->chr_read(be->opaque,
s->outfifo + s->out_start++, 1);
if (qemu_chr_be_can_write(chr)) {
qemu_chr_be_write(chr, s->outfifo + s->out_start++, 1);
s->out_len--;
if (s->out_start >= s->out_size) {
s->out_start = 0;

3
hw/char/cadence_uart.c
View File

@ -23,7 +23,8 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "chardev/char-serial.h"
#include "qemu/timer.h"
#include "qemu/log.h"
#include "hw/char/cadence_uart.h"

2
hw/char/debugcon.c
View File

@ -27,7 +27,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "hw/hw.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/isa/isa.h"
#include "hw/i386/pc.h"

2
hw/char/digic-uart.c
View File

@ -29,7 +29,7 @@
#include "qemu/osdep.h"
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/log.h"
#include "hw/char/digic-uart.h"

3
hw/char/escc.c
View File

@ -26,7 +26,8 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "hw/char/escc.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "chardev/char-serial.h"
#include "ui/console.h"
#include "ui/input.h"
#include "trace.h"

2
hw/char/etraxfs_ser.c
View File

@ -24,7 +24,7 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/log.h"
#define D(x)

3
hw/char/exynos4210_uart.c
View File

@ -23,7 +23,8 @@
#include "hw/sysbus.h"
#include "qemu/error-report.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "chardev/char-serial.h"
#include "hw/arm/exynos4210.h"

2
hw/char/grlib_apbuart.c
View File

@ -24,7 +24,7 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "trace.h"

1
hw/char/imx_serial.c
View File

@ -21,7 +21,6 @@
#include "qemu/osdep.h"
#include "hw/char/imx_serial.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "qemu/log.h"
#ifndef DEBUG_IMX_UART

2
hw/char/ipoctal232.c
View File

@ -11,7 +11,7 @@
#include "qemu/osdep.h"
#include "hw/ipack/ipack.h"
#include "qemu/bitops.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
/* #define DEBUG_IPOCTAL */

2
hw/char/lm32_juart.c
View File

@ -21,7 +21,7 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "trace.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/char/lm32_juart.h"

2
hw/char/lm32_uart.c
View File

@ -26,7 +26,7 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "trace.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/error-report.h"
enum {

2
hw/char/mcf_uart.c
View File

@ -9,7 +9,7 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "hw/m68k/mcf.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "exec/address-spaces.h"
#include "qapi/error.h"

2
hw/char/milkymist-uart.c
View File

@ -25,7 +25,7 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "trace.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/error-report.h"
enum {

2
hw/char/omap_uart.c
View File

@ -18,7 +18,7 @@
* with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "hw/hw.h"
#include "hw/arm/omap.h"
#include "hw/char/serial.h"

3
hw/char/parallel.c
View File

@ -25,7 +25,8 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "hw/hw.h"
#include "sysemu/char.h"
#include "chardev/char-parallel.h"
#include "chardev/char-fe.h"
#include "hw/isa/isa.h"
#include "hw/i386/pc.h"
#include "sysemu/sysemu.h"

2
hw/char/pl011.c
View File

@ -9,7 +9,7 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/log.h"
#include "trace.h"

2
hw/char/sclpconsole-lm.c
View File

@ -17,7 +17,7 @@
#include "hw/qdev.h"
#include "qemu/thread.h"
#include "qemu/error-report.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/s390x/sclp.h"
#include "hw/s390x/event-facility.h"

2
hw/char/sclpconsole.c
View File

@ -19,7 +19,7 @@
#include "hw/s390x/sclp.h"
#include "hw/s390x/event-facility.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
typedef struct ASCIIConsoleData {
EventBufferHeader ebh;

4
hw/char/serial.c
View File

@ -25,7 +25,7 @@
#include "qemu/osdep.h"
#include "hw/char/serial.h"
#include "sysemu/char.h"
#include "chardev/char-serial.h"
#include "qapi/error.h"
#include "qemu/timer.h"
#include "exec/address-spaces.h"
@ -905,7 +905,7 @@ void serial_realize_core(SerialState *s, Error **errp)
void serial_exit_core(SerialState *s)
{
qemu_chr_fe_deinit(&s->chr);
qemu_chr_fe_deinit(&s->chr, false);
timer_del(s->modem_status_poll);
timer_free(s->modem_status_poll);

2
hw/char/sh_serial.c
View File

@ -27,7 +27,7 @@
#include "qemu/osdep.h"
#include "hw/hw.h"
#include "hw/sh4/sh.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "exec/address-spaces.h"
#include "qapi/error.h"

2
hw/char/spapr_vty.c
View File

@ -4,7 +4,7 @@
#include "qemu-common.h"
#include "cpu.h"
#include "hw/qdev.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/ppc/spapr.h"
#include "hw/ppc/spapr_vio.h"

2
hw/char/terminal3270.c
View File

@ -13,7 +13,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/s390x/3270-ccw.h"
/* Enough spaces for different window sizes. */

2
hw/char/virtio-console.c
View File

@ -11,7 +11,7 @@
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/error-report.h"
#include "trace.h"
#include "hw/virtio/virtio-serial.h"

4
hw/char/xen_console.c
View File

@ -25,7 +25,7 @@
#include "qapi/error.h"
#include "hw/hw.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "hw/xen/xen_backend.h"
#include "qapi/error.h"
@ -261,7 +261,7 @@ static void con_disconnect(struct XenDevice *xendev)
{
struct XenConsole *con = container_of(xendev, struct XenConsole, xendev);
qemu_chr_fe_deinit(&con->chr);
qemu_chr_fe_deinit(&con->chr, false);
xen_pv_unbind_evtchn(&con->xendev);
if (con->sring) {

2
hw/char/xilinx_uartlite.c
View File

@ -24,7 +24,7 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#define DUART(x)

4
hw/core/qdev-properties-system.c
View File

@ -20,7 +20,7 @@
#include "hw/block/block.h"
#include "net/hub.h"
#include "qapi/visitor.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "sysemu/iothread.h"
static void get_pointer(Object *obj, Visitor *v, Property *prop,
@ -225,7 +225,7 @@ static void release_chr(Object *obj, const char *name, void *opaque)
Property *prop = opaque;
CharBackend *be = qdev_get_prop_ptr(dev, prop);
qemu_chr_fe_deinit(be);
qemu_chr_fe_deinit(be, false);
}
PropertyInfo qdev_prop_chr = {

2
hw/core/qdev-properties.c
View File

@ -9,7 +9,7 @@
#include "hw/block/block.h"
#include "net/hub.h"
#include "qapi/visitor.h"
#include "sysemu/char.h"
#include "chardev/char.h"
void qdev_prop_set_after_realize(DeviceState *dev, const char *name,
Error **errp)

1
hw/display/xenfb.c
View File

@ -28,7 +28,6 @@
#include "hw/hw.h"
#include "ui/console.h"
#include "sysemu/char.h"
#include "hw/xen/xen_backend.h"
#include <xen/event_channel.h>

1
hw/i386/xen/xen-hvm.c
View File

@ -18,7 +18,6 @@
#include "hw/xen/xen_backend.h"
#include "qmp-commands.h"
#include "sysemu/char.h"
#include "qemu/error-report.h"
#include "qemu/range.h"
#include "sysemu/xen-mapcache.h"

2
hw/ipmi/ipmi_bmc_extern.c
View File

@ -30,7 +30,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu/timer.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "sysemu/sysemu.h"
#include "hw/ipmi/ipmi.h"

2
hw/isa/pc87312.c
View File

@ -30,7 +30,7 @@
#include "sysemu/block-backend.h"
#include "sysemu/blockdev.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "trace.h"

2
hw/mips/boston.c
View File

@ -35,7 +35,7 @@
#include "qemu/cutils.h"
#include "qemu/error-report.h"
#include "qemu/log.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "sysemu/device_tree.h"
#include "sysemu/sysemu.h"
#include "sysemu/qtest.h"

1
hw/mips/mips_fulong2e.c
View File

@ -32,7 +32,6 @@
#include "hw/mips/mips.h"
#include "hw/mips/cpudevs.h"
#include "hw/pci/pci.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"
#include "audio/audio.h"
#include "qemu/log.h"

1
hw/mips/mips_malta.c
View File

@ -37,7 +37,6 @@
#include "hw/mips/mips.h"
#include "hw/mips/cpudevs.h"
#include "hw/pci/pci.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"
#include "sysemu/arch_init.h"
#include "qemu/log.h"

2
hw/misc/ivshmem.c
View File

@ -29,7 +29,7 @@
#include "qemu/error-report.h"
#include "qemu/event_notifier.h"
#include "qom/object_interfaces.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "sysemu/hostmem.h"
#include "sysemu/qtest.h"
#include "qapi/visitor.h"

1
hw/net/xgmac.c
View File

@ -26,7 +26,6 @@
#include "qemu/osdep.h"
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "qemu/log.h"
#include "net/net.h"
#include "net/checksum.h"

1
hw/ppc/spapr_events.c
View File

@ -28,7 +28,6 @@
#include "qapi/error.h"
#include "cpu.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "hw/qdev.h"
#include "sysemu/device_tree.h"

1
hw/ppc/spapr_rtas.c
View File

@ -29,7 +29,6 @@
#include "qemu/log.h"
#include "qemu/error-report.h"
#include "sysemu/sysemu.h"
#include "sysemu/char.h"
#include "hw/qdev.h"
#include "sysemu/device_tree.h"
#include "sysemu/cpus.h"

1
hw/sparc/leon3.c
View File

@ -28,7 +28,6 @@
#include "hw/hw.h"
#include "qemu/timer.h"
#include "hw/ptimer.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"
#include "sysemu/qtest.h"
#include "hw/boards.h"

2
hw/usb/ccid-card-emulated.c
View File

@ -33,7 +33,7 @@
#include <vcard_emul.h>
#include "qemu/thread.h"
#include "sysemu/char.h"
#include "qemu/main-loop.h"
#include "ccid.h"
#define DPRINTF(card, lvl, fmt, ...) \

7
hw/usb/ccid-card-passthru.c
View File

@ -9,7 +9,7 @@
*/
#include "qemu/osdep.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/error-report.h"
#include "qemu/sockets.h"
#include "ccid.h"
@ -264,10 +264,7 @@ static void ccid_card_vscard_handle_message(PassthruState *card,
static void ccid_card_vscard_drop_connection(PassthruState *card)
{
Chardev *chr = qemu_chr_fe_get_driver(&card->cs);
qemu_chr_fe_deinit(&card->cs);
object_unparent(OBJECT(chr));
qemu_chr_fe_deinit(&card->cs, true);
card->vscard_in_pos = card->vscard_in_hdr = 0;
}

3
hw/usb/dev-serial.c
View File

@ -15,7 +15,8 @@
#include "qemu/error-report.h"
#include "hw/usb.h"
#include "hw/usb/desc.h"
#include "sysemu/char.h"
#include "chardev/char-serial.h"
#include "chardev/char-fe.h"
//#define DEBUG_Serial

6
hw/usb/redirect.c
View File

@ -33,7 +33,7 @@
#include "qapi/qmp/qerror.h"
#include "qemu/error-report.h"
#include "qemu/iov.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include <usbredirparser.h>
#include <usbredirfilter.h>
@ -1419,10 +1419,8 @@ static void usbredir_cleanup_device_queues(USBRedirDevice *dev)
static void usbredir_unrealize(USBDevice *udev, Error **errp)
{
USBRedirDevice *dev = USB_REDIRECT(udev);
Chardev *chr = qemu_chr_fe_get_driver(&dev->cs);
qemu_chr_fe_deinit(&dev->cs);
object_unparent(OBJECT(chr));
qemu_chr_fe_deinit(&dev->cs, true);
/* Note must be done after qemu_chr_close, as that causes a close event */
qemu_bh_delete(dev->chardev_close_bh);

2
hw/virtio/vhost-user.c
View File

@ -13,7 +13,7 @@
#include "hw/virtio/vhost.h"
#include "hw/virtio/vhost-backend.h"
#include "hw/virtio/virtio-net.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "sysemu/kvm.h"
#include "qemu/error-report.h"
#include "qemu/sockets.h"

2
hw/xen/xen-common.c
View File

@ -11,7 +11,7 @@
#include "qemu/osdep.h"
#include "hw/xen/xen_backend.h"
#include "qmp-commands.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "sysemu/accel.h"
#include "migration/migration.h"

1
hw/xen/xen_backend.c
View File

@ -28,7 +28,6 @@
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "hw/boards.h"
#include "sysemu/char.h"
#include "qemu/log.h"
#include "qapi/error.h"
#include "hw/xen/xen_backend.h"

2
hw/xtensa/xtfpga.c
View File

@ -40,7 +40,7 @@
#include "hw/sysbus.h"
#include "hw/block/flash.h"
#include "sysemu/block-backend.h"
#include "sysemu/char.h"
#include "chardev/char.h"
#include "sysemu/device_tree.h"
#include "qemu/error-report.h"
#include "bootparam.h"

2
chardev/char-fd.h → include/chardev/char-fd.h
View File

@ -25,7 +25,7 @@
#define CHAR_FD_H
#include "io/channel.h"
#include "sysemu/char.h"
#include "chardev/char.h"
typedef struct FDChardev {
Chardev parent;

251
include/chardev/char-fe.h Normal file
View File

@ -0,0 +1,251 @@
#ifndef QEMU_CHAR_FE_H
#define QEMU_CHAR_FE_H
#include "chardev/char.h"
typedef void IOEventHandler(void *opaque, int event);
/* This is the backend as seen by frontend, the actual backend is
* Chardev */
struct CharBackend {
Chardev *chr;
IOEventHandler *chr_event;
IOCanReadHandler *chr_can_read;
IOReadHandler *chr_read;
void *opaque;
int tag;
int fe_open;
};
/**
* @qemu_chr_fe_init:
*
* Initializes a front end for the given CharBackend and
* Chardev. Call qemu_chr_fe_deinit() to remove the association and
* release the driver.
*
* Returns: false on error.
*/
bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp);
/**
* @qemu_chr_fe_deinit:
* @b: a CharBackend
* @del: if true, delete the chardev backend
*
* Dissociate the CharBackend from the Chardev.
*
* Safe to call without associated Chardev.
*/
void qemu_chr_fe_deinit(CharBackend *b, bool del);
/**
* @qemu_chr_fe_get_driver:
*
* Returns the driver associated with a CharBackend or NULL if no
* associated Chardev.
*/
Chardev *qemu_chr_fe_get_driver(CharBackend *be);
/**
* @qemu_chr_fe_set_handlers:
* @b: a CharBackend
* @fd_can_read: callback to get the amount of data the frontend may
* receive
* @fd_read: callback to receive data from char
* @fd_event: event callback
* @opaque: an opaque pointer for the callbacks
* @context: a main loop context or NULL for the default
* @set_open: whether to call qemu_chr_fe_set_open() implicitely when
* any of the handler is non-NULL
*
* Set the front end char handlers. The front end takes the focus if
* any of the handler is non-NULL.
*
* Without associated Chardev, nothing is changed.
*/
void qemu_chr_fe_set_handlers(CharBackend *b,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
void *opaque,
GMainContext *context,
bool set_open);
/**
* @qemu_chr_fe_take_focus:
*
* Take the focus (if the front end is muxed).
*
* Without associated Chardev, nothing is changed.
*/
void qemu_chr_fe_take_focus(CharBackend *b);
/**
* @qemu_chr_fe_accept_input:
*
* Notify that the frontend is ready to receive data
*/
void qemu_chr_fe_accept_input(CharBackend *be);
/**
* @qemu_chr_fe_disconnect:
*
* Close a fd accpeted by character backend.
* Without associated Chardev, do nothing.
*/
void qemu_chr_fe_disconnect(CharBackend *be);
/**
* @qemu_chr_fe_wait_connected:
*
* Wait for characted backend to be connected, return < 0 on error or
* if no assicated Chardev.
*/
int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp);
/**
* @qemu_chr_fe_set_echo:
*
* Ask the backend to override its normal echo setting. This only really
* applies to the stdio backend and is used by the QMP server such that you
* can see what you type if you try to type QMP commands.
* Without associated Chardev, do nothing.
*
* @echo true to enable echo, false to disable echo
*/
void qemu_chr_fe_set_echo(CharBackend *be, bool echo);
/**
* @qemu_chr_fe_set_open:
*
* Set character frontend open status. This is an indication that the
* front end is ready (or not) to begin doing I/O.
* Without associated Chardev, do nothing.
*/
void qemu_chr_fe_set_open(CharBackend *be, int fe_open);
/**
* @qemu_chr_fe_printf:
*
* Write to a character backend using a printf style interface. This
* function is thread-safe. It does nothing without associated
* Chardev.
*
* @fmt see #printf
*/
void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
GCC_FMT_ATTR(2, 3);
/**
* @qemu_chr_fe_add_watch:
*
* If the backend is connected, create and add a #GSource that fires
* when the given condition (typically G_IO_OUT|G_IO_HUP or G_IO_HUP)
* is active; return the #GSource's tag. If it is disconnected,
* or without associated Chardev, return 0.
*
* @cond the condition to poll for
* @func the function to call when the condition happens
* @user_data the opaque pointer to pass to @func
*
* Returns: the source tag
*/
guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
GIOFunc func, void *user_data);
/**
* @qemu_chr_fe_write:
*
* Write data to a character backend from the front end. This function
* will send data from the front end to the back end. This function
* is thread-safe.
*
* @buf the data
* @len the number of bytes to send
*
* Returns: the number of bytes consumed (0 if no assicated Chardev)
*/
int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len);
/**
* @qemu_chr_fe_write_all:
*
* Write data to a character backend from the front end. This function will
* send data from the front end to the back end. Unlike @qemu_chr_fe_write,
* this function will block if the back end cannot consume all of the data
* attempted to be written. This function is thread-safe.
*
* @buf the data
* @len the number of bytes to send
*
* Returns: the number of bytes consumed (0 if no assicated Chardev)
*/
int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len);
/**
* @qemu_chr_fe_read_all:
*
* Read data to a buffer from the back end.
*
* @buf the data buffer
* @len the number of bytes to read
*
* Returns: the number of bytes read (0 if no assicated Chardev)
*/
int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len);
/**
* @qemu_chr_fe_ioctl:
*
* Issue a device specific ioctl to a backend. This function is thread-safe.
*
* @cmd see CHR_IOCTL_*
* @arg the data associated with @cmd
*
* Returns: if @cmd is not supported by the backend or there is no
* associated Chardev, -ENOTSUP, otherwise the return
* value depends on the semantics of @cmd
*/
int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg);
/**
* @qemu_chr_fe_get_msgfd:
*
* For backends capable of fd passing, return the latest file descriptor passed
* by a client.
*
* Returns: -1 if fd passing isn't supported or there is no pending file
* descriptor. If a file descriptor is returned, subsequent calls to
* this function will return -1 until a client sends a new file
* descriptor.
*/
int qemu_chr_fe_get_msgfd(CharBackend *be);
/**
* @qemu_chr_fe_get_msgfds:
*
* For backends capable of fd passing, return the number of file received
* descriptors and fills the fds array up to num elements
*
* Returns: -1 if fd passing isn't supported or there are no pending file
* descriptors. If file descriptors are returned, subsequent calls to
* this function will return -1 until a client sends a new set of file
* descriptors.
*/
int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int num);
/**
* @qemu_chr_fe_set_msgfds:
*
* For backends capable of fd passing, set an array of fds to be passed with
* the next send operation.
* A subsequent call to this function before calling a write function will
* result in overwriting the fd array with the new value without being send.
* Upon writing the message the fd array is freed.
*
* Returns: -1 if fd passing isn't supported or no associated Chardev.
*/
int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num);
#endif /* QEMU_CHAR_FE_H */

2
chardev/char-io.h → include/chardev/char-io.h
View File

@ -26,7 +26,7 @@
#include "qemu-common.h"
#include "io/channel.h"
#include "sysemu/char.h"
#include "chardev/char.h"
/* Can only be used for read */
GSource *io_add_watch_poll(Chardev *chr,

3
chardev/char-mux.h → include/chardev/char-mux.h
View File

@ -24,7 +24,8 @@
#ifndef CHAR_MUX_H
#define CHAR_MUX_H
#include "sysemu/char.h"
#include "chardev/char.h"
#include "chardev/char-fe.h"
extern bool muxes_realized;

20
chardev/char-parallel.h → include/chardev/char-parallel.h
View File

@ -24,9 +24,27 @@
#ifndef CHAR_PARALLEL_H
#define CHAR_PARALLEL_H
#if defined(__linux__) || defined(__FreeBSD__) || \
#include "chardev/char.h"
#if defined(__linux__) || defined(__FreeBSD__) || \
defined(__FreeBSD_kernel__) || defined(__DragonFly__)
#define HAVE_CHARDEV_PARPORT 1
#endif
#define CHR_IOCTL_PP_READ_DATA 3
#define CHR_IOCTL_PP_WRITE_DATA 4
#define CHR_IOCTL_PP_READ_CONTROL 5
#define CHR_IOCTL_PP_WRITE_CONTROL 6
#define CHR_IOCTL_PP_READ_STATUS 7
#define CHR_IOCTL_PP_EPP_READ_ADDR 8
#define CHR_IOCTL_PP_EPP_READ 9
#define CHR_IOCTL_PP_EPP_WRITE_ADDR 10
#define CHR_IOCTL_PP_EPP_WRITE 11
#define CHR_IOCTL_PP_DATA_DIR 12
struct ParallelIOArg {
void *buffer;
int count;
};
#endif /* CHAR_PARALLEL_H */

22
chardev/char-serial.h → include/chardev/char-serial.h
View File

@ -24,6 +24,8 @@
#ifndef CHAR_SERIAL_H
#define CHAR_SERIAL_H
#include "chardev/char.h"
#ifdef _WIN32
#define HAVE_CHARDEV_SERIAL 1
#elif defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
@ -32,4 +34,24 @@
#define HAVE_CHARDEV_SERIAL 1
#endif
#define CHR_IOCTL_SERIAL_SET_PARAMS 1
typedef struct {
int speed;
int parity;
int data_bits;
int stop_bits;
} QEMUSerialSetParams;
#define CHR_IOCTL_SERIAL_SET_BREAK 2
#define CHR_IOCTL_SERIAL_SET_TIOCM 13
#define CHR_IOCTL_SERIAL_GET_TIOCM 14
#define CHR_TIOCM_CTS 0x020
#define CHR_TIOCM_CAR 0x040
#define CHR_TIOCM_DSR 0x100
#define CHR_TIOCM_RI 0x080
#define CHR_TIOCM_DTR 0x002
#define CHR_TIOCM_RTS 0x004
#endif

0
chardev/char-win-stdio.h → include/chardev/char-win-stdio.h
View File

14
chardev/char-win.h → include/chardev/char-win.h
View File

@ -24,20 +24,18 @@
#ifndef CHAR_WIN_H
#define CHAR_WIN_H
#include "sysemu/char.h"
#include "chardev/char.h"
typedef struct {
Chardev parent;
int max_size;
HANDLE hcom, hrecv, hsend;
bool keep_open; /* console do not close file */
HANDLE file, hrecv, hsend;
OVERLAPPED orecv;
BOOL fpipe;
DWORD len;
/* Protected by the Chardev chr_write_lock. */
OVERLAPPED osend;
/* FIXME: file/console do not finalize */
bool skip_free;
} WinChardev;
#define NSENDBUF 2048
@ -46,8 +44,8 @@ typedef struct {
#define TYPE_CHARDEV_WIN "chardev-win"
#define WIN_CHARDEV(obj) OBJECT_CHECK(WinChardev, (obj), TYPE_CHARDEV_WIN)
void qemu_chr_open_win_file(Chardev *chr, HANDLE fd_out);
int win_chr_init(Chardev *chr, const char *filename, Error **errp);
void win_chr_set_file(Chardev *chr, HANDLE file, bool keep_open);
int win_chr_serial_init(Chardev *chr, const char *filename, Error **errp);
int win_chr_pipe_poll(void *opaque);
#endif /* CHAR_WIN_H */

229
include/chardev/char.h Normal file
View File

@ -0,0 +1,229 @@
#ifndef QEMU_CHAR_H
#define QEMU_CHAR_H
#include "qemu-common.h"
#include "qemu/option.h"
#include "qemu/main-loop.h"
#include "qemu/bitmap.h"
#include "qom/object.h"
#define IAC_EOR 239
#define IAC_SE 240
#define IAC_NOP 241
#define IAC_BREAK 243
#define IAC_IP 244
#define IAC_SB 250
#define IAC 255
/* character device */
typedef struct CharBackend CharBackend;
typedef enum {
CHR_EVENT_BREAK, /* serial break char */
CHR_EVENT_OPENED, /* new connection established */
CHR_EVENT_MUX_IN, /* mux-focus was set to this terminal */
CHR_EVENT_MUX_OUT, /* mux-focus will move on */
CHR_EVENT_CLOSED /* connection closed */
} QEMUChrEvent;
#define CHR_READ_BUF_LEN 4096
typedef enum {
/* Whether the chardev peer is able to close and
* reopen the data channel, thus requiring support
* for qemu_chr_wait_connected() to wait for a
* valid connection */
QEMU_CHAR_FEATURE_RECONNECTABLE,
/* Whether it is possible to send/recv file descriptors
* over the data channel */
QEMU_CHAR_FEATURE_FD_PASS,
/* Whether replay or record mode is enabled */
QEMU_CHAR_FEATURE_REPLAY,
QEMU_CHAR_FEATURE_LAST,
} ChardevFeature;
#define qemu_chr_replay(chr) qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY)
struct Chardev {
Object parent_obj;
QemuMutex chr_write_lock;
CharBackend *be;
char *label;
char *filename;
int logfd;
int be_open;
GSource *gsource;
DECLARE_BITMAP(features, QEMU_CHAR_FEATURE_LAST);
};
/**
* @qemu_chr_new_from_opts:
*
* Create a new character backend from a QemuOpts list.
*
* @opts see qemu-config.c for a list of valid options
*
* Returns: a new character backend
*/
Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
Error **errp);
/**
* @qemu_chr_parse_common:
*
* Parse the common options available to all character backends.
*
* @opts the options that still need parsing
* @backend a new backend
*/
void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend);
/**
* @qemu_chr_new:
*
* Create a new character backend from a URI.
*
* @label the name of the backend
* @filename the URI
*
* Returns: a new character backend
*/
Chardev *qemu_chr_new(const char *label, const char *filename);
/**
* @qemu_chr_cleanup:
*
* Delete all chardevs (when leaving qemu)
*/
void qemu_chr_cleanup(void);
/**
* @qemu_chr_new_noreplay:
*
* Create a new character backend from a URI.
* Character device communications are not written
* into the replay log.
*
* @label the name of the backend
* @filename the URI
*
* Returns: a new character backend
*/
Chardev *qemu_chr_new_noreplay(const char *label, const char *filename);
/**
* @qemu_chr_be_can_write:
*
* Determine how much data the front end can currently accept. This function
* returns the number of bytes the front end can accept. If it returns 0, the
* front end cannot receive data at the moment. The function must be polled
* to determine when data can be received.
*
* Returns: the number of bytes the front end can receive via @qemu_chr_be_write
*/
int qemu_chr_be_can_write(Chardev *s);
/**
* @qemu_chr_be_write:
*
* Write data from the back end to the front end. Before issuing this call,
* the caller should call @qemu_chr_be_can_write to determine how much data
* the front end can currently accept.
*
* @buf a buffer to receive data from the front end
* @len the number of bytes to receive from the front end
*/
void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len);
/**
* @qemu_chr_be_write_impl:
*
* Implementation of back end writing. Used by replay module.
*
* @buf a buffer to receive data from the front end
* @len the number of bytes to receive from the front end
*/
void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len);
/**
* @qemu_chr_be_event:
*
* Send an event from the back end to the front end.
*
* @event the event to send
*/
void qemu_chr_be_event(Chardev *s, int event);
int qemu_chr_add_client(Chardev *s, int fd);
Chardev *qemu_chr_find(const char *name);
bool qemu_chr_has_feature(Chardev *chr,
ChardevFeature feature);
void qemu_chr_set_feature(Chardev *chr,
ChardevFeature feature);
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename);
int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all);
#define qemu_chr_write_all(s, buf, len) qemu_chr_write(s, buf, len, true)
int qemu_chr_wait_connected(Chardev *chr, Error **errp);
#define TYPE_CHARDEV "chardev"
#define CHARDEV(obj) OBJECT_CHECK(Chardev, (obj), TYPE_CHARDEV)
#define CHARDEV_CLASS(klass) \
OBJECT_CLASS_CHECK(ChardevClass, (klass), TYPE_CHARDEV)
#define CHARDEV_GET_CLASS(obj) \
OBJECT_GET_CLASS(ChardevClass, (obj), TYPE_CHARDEV)
#define TYPE_CHARDEV_NULL "chardev-null"
#define TYPE_CHARDEV_MUX "chardev-mux"
#define TYPE_CHARDEV_RINGBUF "chardev-ringbuf"
#define TYPE_CHARDEV_PTY "chardev-pty"
#define TYPE_CHARDEV_CONSOLE "chardev-console"
#define TYPE_CHARDEV_STDIO "chardev-stdio"
#define TYPE_CHARDEV_PIPE "chardev-pipe"
#define TYPE_CHARDEV_MEMORY "chardev-memory"
#define TYPE_CHARDEV_PARALLEL "chardev-parallel"
#define TYPE_CHARDEV_FILE "chardev-file"
#define TYPE_CHARDEV_SERIAL "chardev-serial"
#define TYPE_CHARDEV_SOCKET "chardev-socket"
#define TYPE_CHARDEV_UDP "chardev-udp"
#define CHARDEV_IS_RINGBUF(chr) \
object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_RINGBUF)
#define CHARDEV_IS_PTY(chr) \
object_dynamic_cast(OBJECT(chr), TYPE_CHARDEV_PTY)
typedef struct ChardevClass {
ObjectClass parent_class;
bool internal; /* TODO: eventually use TYPE_USER_CREATABLE */
void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp);
void (*open)(Chardev *chr, ChardevBackend *backend,
bool *be_opened, Error **errp);
int (*chr_write)(Chardev *s, const uint8_t *buf, int len);
int (*chr_sync_read)(Chardev *s, const uint8_t *buf, int len);
GSource *(*chr_add_watch)(Chardev *s, GIOCondition cond);
void (*chr_update_read_handler)(Chardev *s, GMainContext *context);
int (*chr_ioctl)(Chardev *s, int cmd, void *arg);
int (*get_msgfds)(Chardev *s, int* fds, int num);
int (*set_msgfds)(Chardev *s, int *fds, int num);
int (*chr_add_client)(Chardev *chr, int fd);
int (*chr_wait_connected)(Chardev *chr, Error **errp);
void (*chr_disconnect)(Chardev *chr);
void (*chr_accept_input)(Chardev *chr);
void (*chr_set_echo)(Chardev *chr, bool echo);
void (*chr_set_fe_open)(Chardev *chr, int fe_open);
} ChardevClass;
Chardev *qemu_chardev_new(const char *id, const char *typename,
ChardevBackend *backend, Error **errp);
extern int term_escape_char;
/* console.c */
void qemu_chr_parse_vc(QemuOpts *opts, ChardevBackend *backend, Error **errp);
#endif

2
include/hw/char/bcm2835_aux.h
View File

@ -9,7 +9,7 @@
#define BCM2835_AUX_H
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#define TYPE_BCM2835_AUX "bcm2835-aux"
#define BCM2835_AUX(obj) OBJECT_CHECK(BCM2835AuxState, (obj), TYPE_BCM2835_AUX)

2
include/hw/char/cadence_uart.h
View File

@ -19,7 +19,7 @@
#ifndef CADENCE_UART_H
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#include "qemu/timer.h"
#define CADENCE_UART_RX_FIFO_SIZE 16

2
include/hw/char/digic-uart.h
View File

@ -19,7 +19,7 @@
#define HW_CHAR_DIGIC_UART_H
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#define TYPE_DIGIC_UART "digic-uart"
#define DIGIC_UART(obj) \

2
include/hw/char/imx_serial.h
View File

@ -19,7 +19,7 @@
#define IMX_SERIAL_H
#include "hw/sysbus.h"
#include "sysemu/char.h"
#include "chardev/char-fe.h"
#define TYPE_IMX_SERIAL "imx.serial"
#define IMX_SERIAL(obj) OBJECT_CHECK(IMXSerialState, (obj), TYPE_IMX_SERIAL)

Some files were not shown because too many files have changed in this diff Show More