proxmox-mirrors/qemu
1
0
Fork 0
mirror of https://git.proxmox.com/git/qemu synced 2025-07-27 07:50:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'amit/char-remove-watch-on-unplug' into staging

Browse Source 
# By Amit Shah
# Via Amit Shah
* amit/char-remove-watch-on-unplug:
  char: remove watch callback on chardev detach from frontend
  char: use common function to disable callbacks on chardev close
  char: move backends' io watch tag to CharDriverState

Message-id: 20131004154802.GA25646@grmbl.mre
Signed-off-by: Anthony Liguori <aliguori@amazon.com>
This commit is contained in:
Anthony Liguori 2013-10-10 13:16:02 -07:00
commit e8f2f59aaf
2 changed files with 32 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/sysemu/char.h
View File

@ -78,6 +78,7 @@ struct CharDriverState {
int explicit_be_open; int explicit_be_open;
int avail_connections; int avail_connections;
int is_mux; int is_mux;
guint fd_in_tag;
QemuOpts *opts; QemuOpts *opts;
QTAILQ_ENTRY(CharDriverState) next; QTAILQ_ENTRY(CharDriverState) next;
}; };

82
qemu-char.c
View File

@ -193,6 +193,8 @@ void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
va_end(ap); va_end(ap);
} }
static void remove_fd_in_watch(CharDriverState *chr);
void qemu_chr_add_handlers(CharDriverState *s, void qemu_chr_add_handlers(CharDriverState *s,
IOCanReadHandler *fd_can_read, IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read, IOReadHandler *fd_read,
@ -203,6 +205,7 @@ void qemu_chr_add_handlers(CharDriverState *s,
if (!opaque && !fd_can_read && !fd_read && !fd_event) { if (!opaque && !fd_can_read && !fd_read && !fd_event) {
fe_open = 0; fe_open = 0;
remove_fd_in_watch(s);
} else { } else {
fe_open = 1; fe_open = 1;
} }
@ -725,6 +728,14 @@ static void io_remove_watch_poll(guint tag)
g_source_destroy(&iwp->parent); g_source_destroy(&iwp->parent);
} }
static void remove_fd_in_watch(CharDriverState *chr)
{
if (chr->fd_in_tag) {
io_remove_watch_poll(chr->fd_in_tag);
chr->fd_in_tag = 0;
}
}
#ifndef _WIN32 #ifndef _WIN32
static GIOChannel *io_channel_from_fd(int fd) static GIOChannel *io_channel_from_fd(int fd)
{ {
@ -798,7 +809,6 @@ static int io_channel_send(GIOChannel *fd, const void *buf, size_t len)
typedef struct FDCharDriver { typedef struct FDCharDriver {
CharDriverState *chr; CharDriverState *chr;
GIOChannel *fd_in, *fd_out; GIOChannel *fd_in, *fd_out;
guint fd_in_tag;
int max_size; int max_size;
QTAILQ_ENTRY(FDCharDriver) node; QTAILQ_ENTRY(FDCharDriver) node;
} FDCharDriver; } FDCharDriver;
@ -830,10 +840,7 @@ static gboolean fd_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
status = g_io_channel_read_chars(chan, (gchar *)buf, status = g_io_channel_read_chars(chan, (gchar *)buf,
len, &bytes_read, NULL); len, &bytes_read, NULL);
if (status == G_IO_STATUS_EOF) { if (status == G_IO_STATUS_EOF) {
if (s->fd_in_tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->fd_in_tag);
s->fd_in_tag = 0;
}
qemu_chr_be_event(chr, CHR_EVENT_CLOSED); qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
return FALSE; return FALSE;
} }
@ -863,13 +870,10 @@ static void fd_chr_update_read_handler(CharDriverState *chr)
{ {
FDCharDriver *s = chr->opaque; FDCharDriver *s = chr->opaque;
if (s->fd_in_tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->fd_in_tag);
s->fd_in_tag = 0;
}
if (s->fd_in) { if (s->fd_in) {
s->fd_in_tag = io_add_watch_poll(s->fd_in, fd_chr_read_poll, fd_chr_read, chr); chr->fd_in_tag = io_add_watch_poll(s->fd_in, fd_chr_read_poll,
fd_chr_read, chr);
} }
} }
@ -877,11 +881,7 @@ static void fd_chr_close(struct CharDriverState *chr)
{ {
FDCharDriver *s = chr->opaque; FDCharDriver *s = chr->opaque;
if (s->fd_in_tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->fd_in_tag);
s->fd_in_tag = 0;
}
if (s->fd_in) { if (s->fd_in) {
g_io_channel_unref(s->fd_in); g_io_channel_unref(s->fd_in);
} }
@ -1012,7 +1012,6 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
typedef struct { typedef struct {
GIOChannel *fd; GIOChannel *fd;
guint fd_tag;
int connected; int connected;
int read_bytes; int read_bytes;
guint timer_tag; guint timer_tag;
@ -1123,10 +1122,7 @@ static void pty_chr_state(CharDriverState *chr, int connected)
PtyCharDriver *s = chr->opaque; PtyCharDriver *s = chr->opaque;
if (!connected) { if (!connected) {
if (s->fd_tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->fd_tag);
s->fd_tag = 0;
}
s->connected = 0; s->connected = 0;
/* (re-)connect poll interval for idle guests: once per second. /* (re-)connect poll interval for idle guests: once per second.
* We check more frequently in case the guests sends data to * We check more frequently in case the guests sends data to
@ -1140,7 +1136,8 @@ static void pty_chr_state(CharDriverState *chr, int connected)
if (!s->connected) { if (!s->connected) {
s->connected = 1; s->connected = 1;
qemu_chr_be_generic_open(chr); qemu_chr_be_generic_open(chr);
s->fd_tag = io_add_watch_poll(s->fd, pty_chr_read_poll, pty_chr_read, chr); chr->fd_in_tag = io_add_watch_poll(s->fd, pty_chr_read_poll,
pty_chr_read, chr);
} }
} }
} }
@ -1151,10 +1148,7 @@ static void pty_chr_close(struct CharDriverState *chr)
PtyCharDriver *s = chr->opaque; PtyCharDriver *s = chr->opaque;
int fd; int fd;
if (s->fd_tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->fd_tag);
s->fd_tag = 0;
}
fd = g_io_channel_unix_get_fd(s->fd); fd = g_io_channel_unix_get_fd(s->fd);
g_io_channel_unref(s->fd); g_io_channel_unref(s->fd);
close(fd); close(fd);
@ -2161,7 +2155,6 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
typedef struct { typedef struct {
int fd; int fd;
GIOChannel *chan; GIOChannel *chan;
guint tag;
uint8_t buf[READ_BUF_LEN]; uint8_t buf[READ_BUF_LEN];
int bufcnt; int bufcnt;
int bufptr; int bufptr;
@ -2217,10 +2210,7 @@ static gboolean udp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
s->bufcnt = bytes_read; s->bufcnt = bytes_read;
s->bufptr = s->bufcnt; s->bufptr = s->bufcnt;
if (status != G_IO_STATUS_NORMAL) { if (status != G_IO_STATUS_NORMAL) {
if (s->tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->tag);
s->tag = 0;
}
return FALSE; return FALSE;
} }
@ -2238,23 +2228,18 @@ static void udp_chr_update_read_handler(CharDriverState *chr)
{ {
NetCharDriver *s = chr->opaque; NetCharDriver *s = chr->opaque;
if (s->tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->tag);
s->tag = 0;
}
if (s->chan) { if (s->chan) {
s->tag = io_add_watch_poll(s->chan, udp_chr_read_poll, udp_chr_read, chr); chr->fd_in_tag = io_add_watch_poll(s->chan, udp_chr_read_poll,
udp_chr_read, chr);
} }
} }
static void udp_chr_close(CharDriverState *chr) static void udp_chr_close(CharDriverState *chr)
{ {
NetCharDriver *s = chr->opaque; NetCharDriver *s = chr->opaque;
if (s->tag) {
io_remove_watch_poll(s->tag); remove_fd_in_watch(chr);
s->tag = 0;
}
if (s->chan) { if (s->chan) {
g_io_channel_unref(s->chan); g_io_channel_unref(s->chan);
closesocket(s->fd); closesocket(s->fd);
@ -2304,7 +2289,7 @@ static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
typedef struct { typedef struct {
GIOChannel *chan, *listen_chan; GIOChannel *chan, *listen_chan;
guint tag, listen_tag; guint listen_tag;
int fd, listen_fd; int fd, listen_fd;
int connected; int connected;
int max_size; int max_size;
@ -2489,10 +2474,7 @@ static gboolean tcp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
if (s->listen_chan) { if (s->listen_chan) {
s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr); s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);
} }
if (s->tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->tag);
s->tag = 0;
}
g_io_channel_unref(s->chan); g_io_channel_unref(s->chan);
s->chan = NULL; s->chan = NULL;
closesocket(s->fd); closesocket(s->fd);
@ -2522,7 +2504,8 @@ static void tcp_chr_connect(void *opaque)
s->connected = 1; s->connected = 1;
if (s->chan) { if (s->chan) {
s->tag = io_add_watch_poll(s->chan, tcp_chr_read_poll, tcp_chr_read, chr); chr->fd_in_tag = io_add_watch_poll(s->chan, tcp_chr_read_poll,
tcp_chr_read, chr);
} }
qemu_chr_be_generic_open(chr); qemu_chr_be_generic_open(chr);
} }
@ -2605,10 +2588,7 @@ static void tcp_chr_close(CharDriverState *chr)
{ {
TCPCharDriver *s = chr->opaque; TCPCharDriver *s = chr->opaque;
if (s->fd >= 0) { if (s->fd >= 0) {
if (s->tag) { remove_fd_in_watch(chr);
io_remove_watch_poll(s->tag);
s->tag = 0;
}
if (s->chan) { if (s->chan) {
g_io_channel_unref(s->chan); g_io_channel_unref(s->chan);
} }