spapr_vscsi: Fix REPORT_LUNS handling

[qemu.git] / qemu-char.c

diff --git a/qemu-char.c b/qemu-char.c
index 13474def3338d816c33cac68a5f74ba79eef6f77..4d50838b3b88f61460c1753a3300c99ddc8c4b37 100644 (file)
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -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,
                            IOCanReadHandler *fd_can_read,
                            IOReadHandler *fd_read,
 void qemu_chr_add_handlers(CharDriverState *s,
                            IOCanReadHandler *fd_can_read,
                            IOReadHandler *fd_read,


@@ -203,6 +205,7 @@ void qemu_chr_add_handlers(CharDriverState *s,
 
     if (!opaque && !fd_can_read && !fd_read && !fd_event) {
         fe_open = 0;
 
     if (!opaque && !fd_can_read && !fd_read && !fd_event) {
         fe_open = 0;

+        remove_fd_in_watch(s);

     } else {
         fe_open = 1;
     }
     } else {
         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
 static GIOChannel *io_channel_from_fd(int fd)
 {
 #ifndef _WIN32
 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 {
     CharDriverState *chr;
     GIOChannel *fd_in, *fd_out;
 typedef struct FDCharDriver {
     CharDriverState *chr;
     GIOChannel *fd_in, *fd_out;

-    guint fd_in_tag;

     int max_size;
     QTAILQ_ENTRY(FDCharDriver) node;
 } FDCharDriver;
     int max_size;
     QTAILQ_ENTRY(FDCharDriver) node;
 } 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,
                                      len, &bytes_read, NULL);
     if (status == G_IO_STATUS_EOF) {
     status = g_io_channel_read_chars(chan, (gchar *)buf,
                                      len, &bytes_read, NULL);
     if (status == G_IO_STATUS_EOF) {

-        if (s->fd_in_tag) {
-            io_remove_watch_poll(s->fd_in_tag);
-            s->fd_in_tag = 0;
-        }
+        remove_fd_in_watch(chr);

         qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
         return FALSE;
     }
         qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
         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) {
-        io_remove_watch_poll(s->fd_in_tag);
-        s->fd_in_tag = 0;
-    }
-
+    remove_fd_in_watch(chr);

     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) {
-        io_remove_watch_poll(s->fd_in_tag);
-        s->fd_in_tag = 0;
-    }
-
+    remove_fd_in_watch(chr);

     if (s->fd_in) {
         g_io_channel_unref(s->fd_in);
     }
     if (s->fd_in) {
         g_io_channel_unref(s->fd_in);
     }


@@ -1012,7 +1012,6 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
 
 typedef struct {
     GIOChannel *fd;
 
 typedef struct {
     GIOChannel *fd;

-    guint fd_tag;

     int connected;
     int read_bytes;
     guint timer_tag;
     int connected;
     int read_bytes;
     guint timer_tag;


@@ -1123,10 +1122,7 @@ static void pty_chr_state(CharDriverState *chr, int connected)
     PtyCharDriver *s = chr->opaque;
 
     if (!connected) {
     PtyCharDriver *s = chr->opaque;
 
     if (!connected) {

-        if (s->fd_tag) {
-            io_remove_watch_poll(s->fd_tag);
-            s->fd_tag = 0;
-        }
+        remove_fd_in_watch(chr);

         s->connected = 0;
         /* (re-)connect poll interval for idle guests: once per second.
          * We check more frequently in case the guests sends data to
         s->connected = 0;
         /* (re-)connect poll interval for idle guests: once per second.
          * 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) {
             s->connected = 1;
             qemu_chr_be_generic_open(chr);
         if (!s->connected) {
             s->connected = 1;
             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;
     int fd;
 
     PtyCharDriver *s = chr->opaque;
     int fd;
 

-    if (s->fd_tag) {
-        io_remove_watch_poll(s->fd_tag);
-        s->fd_tag = 0;
-    }
+    remove_fd_in_watch(chr);

     fd = g_io_channel_unix_get_fd(s->fd);
     g_io_channel_unref(s->fd);
     close(fd);
     fd = g_io_channel_unix_get_fd(s->fd);
     g_io_channel_unref(s->fd);
     close(fd);


@@ -1981,8 +1975,7 @@ static void win_stdio_wait_func(void *opaque)
     DWORD              dwSize;
     int                i;
 
     DWORD              dwSize;
     int                i;
 

-    ret = ReadConsoleInput(stdio->hStdIn, buf, sizeof(buf) / sizeof(*buf),
-                           &dwSize);
+    ret = ReadConsoleInput(stdio->hStdIn, buf, ARRAY_SIZE(buf), &dwSize);

 
     if (!ret) {
         /* Avoid error storm */
 
     if (!ret) {
         /* Avoid error storm */


@@ -2161,7 +2154,6 @@ static CharDriverState *qemu_chr_open_stdio(ChardevStdio *opts)
 typedef struct {
     int fd;
     GIOChannel *chan;
 typedef struct {
     int fd;
     GIOChannel *chan;

-    guint tag;

     uint8_t buf[READ_BUF_LEN];
     int bufcnt;
     int bufptr;
     uint8_t buf[READ_BUF_LEN];
     int bufcnt;
     int bufptr;


@@ -2217,10 +2209,7 @@ static gboolean udp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
     s->bufcnt = bytes_read;
     s->bufptr = s->bufcnt;
     if (status != G_IO_STATUS_NORMAL) {
     s->bufcnt = bytes_read;
     s->bufptr = s->bufcnt;
     if (status != G_IO_STATUS_NORMAL) {

-        if (s->tag) {
-            io_remove_watch_poll(s->tag);
-            s->tag = 0;
-        }
+        remove_fd_in_watch(chr);

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -2238,23 +2227,18 @@ static void udp_chr_update_read_handler(CharDriverState *chr)
 {
     NetCharDriver *s = chr->opaque;
 
 {
     NetCharDriver *s = chr->opaque;
 

-    if (s->tag) {
-        io_remove_watch_poll(s->tag);
-        s->tag = 0;
-    }
-
+    remove_fd_in_watch(chr);

     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)
 {
     NetCharDriver *s = chr->opaque;
     }
 }
 
 static void udp_chr_close(CharDriverState *chr)
 {
     NetCharDriver *s = chr->opaque;

-    if (s->tag) {
-        io_remove_watch_poll(s->tag);
-        s->tag = 0;
-    }
+
+    remove_fd_in_watch(chr);

     if (s->chan) {
         g_io_channel_unref(s->chan);
         closesocket(s->fd);
     if (s->chan) {
         g_io_channel_unref(s->chan);
         closesocket(s->fd);


@@ -2304,7 +2288,7 @@ static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
 typedef struct {
 
     GIOChannel *chan, *listen_chan;
 typedef struct {
 
     GIOChannel *chan, *listen_chan;

-    guint tag, listen_tag;
+    guint listen_tag;

     int fd, listen_fd;
     int connected;
     int max_size;
     int fd, listen_fd;
     int connected;
     int max_size;


@@ -2489,10 +2473,7 @@ static gboolean tcp_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)
         if (s->listen_chan) {
             s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);
         }
         if (s->listen_chan) {
             s->listen_tag = g_io_add_watch(s->listen_chan, G_IO_IN, tcp_chr_accept, chr);
         }

-        if (s->tag) {
-            io_remove_watch_poll(s->tag);
-            s->tag = 0;
-        }
+        remove_fd_in_watch(chr);

         g_io_channel_unref(s->chan);
         s->chan = NULL;
         closesocket(s->fd);
         g_io_channel_unref(s->chan);
         s->chan = NULL;
         closesocket(s->fd);


@@ -2522,7 +2503,8 @@ static void tcp_chr_connect(void *opaque)
 
     s->connected = 1;
     if (s->chan) {
 
     s->connected = 1;
     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 +2587,7 @@ static void tcp_chr_close(CharDriverState *chr)
 {
     TCPCharDriver *s = chr->opaque;
     if (s->fd >= 0) {
 {
     TCPCharDriver *s = chr->opaque;
     if (s->fd >= 0) {

-        if (s->tag) {
-            io_remove_watch_poll(s->tag);
-            s->tag = 0;
-        }
+        remove_fd_in_watch(chr);

         if (s->chan) {
             g_io_channel_unref(s->chan);
         }
         if (s->chan) {
             g_io_channel_unref(s->chan);
         }


@@ -2746,7 +2725,7 @@ static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
 
     chr = qemu_chr_open_socket_fd(fd, do_nodelay, is_listen, is_telnet,
                                   is_waitconnect, &local_err);
 
     chr = qemu_chr_open_socket_fd(fd, do_nodelay, is_listen, is_telnet,
                                   is_waitconnect, &local_err);

-    if (error_is_set(&local_err)) {
+    if (local_err) {

         goto fail;
     }
     return chr;
         goto fail;
     }
     return chr;


@@ -2959,7 +2938,7 @@ QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
     Error *local_err = NULL;
 
     opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
     Error *local_err = NULL;
 
     opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);

-    if (error_is_set(&local_err)) {
+    if (local_err) {

         qerror_report_err(local_err);
         error_free(local_err);
         return NULL;
         qerror_report_err(local_err);
         error_free(local_err);
         return NULL;


@@ -3344,7 +3323,7 @@ CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*in
         return NULL;
 
     chr = qemu_chr_new_from_opts(opts, init, &err);
         return NULL;
 
     chr = qemu_chr_new_from_opts(opts, init, &err);

-    if (error_is_set(&err)) {
+    if (err) {

         error_report("%s", error_get_pretty(err));
         error_free(err);
     }
         error_report("%s", error_get_pretty(err));
         error_free(err);
     }


@@ -3373,6 +3352,13 @@ void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open)
     }
 }
 
     }
 }
 

+void qemu_chr_fe_event(struct CharDriverState *chr, int event)
+{
+    if (chr->chr_fe_event) {
+        chr->chr_fe_event(chr, event);
+    }
+}
+

 int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
                           GIOFunc func, void *user_data)
 {
 int qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
                           GIOFunc func, void *user_data)
 {


@@ -3446,6 +3432,25 @@ ChardevInfoList *qmp_query_chardev(Error **errp)
     return chr_list;
 }
 
     return chr_list;
 }
 

+ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
+{
+    ChardevBackendInfoList *backend_list = NULL;
+    CharDriver *c = NULL;
+    GSList *i = NULL;
+
+    for (i = backends; i; i = i->next) {
+        ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
+        c = i->data;
+        info->value = g_malloc0(sizeof(*info->value));
+        info->value->name = g_strdup(c->name);
+
+        info->next = backend_list;
+        backend_list = info;
+    }
+
+    return backend_list;
+}
+

 CharDriverState *qemu_chr_find(const char *name)
 {
     CharDriverState *chr;
 CharDriverState *qemu_chr_find(const char *name)
 {
     CharDriverState *chr;