hw/arm/virt-acpi - reserve ECAM space as PNP0C02 device

[qemu.git] / qemu-char.c

diff --git a/qemu-char.c b/qemu-char.c
index 650943d27426d9642742cee93a5bf1f9666a1aaa..2c9940cea463b9593faf9f36a11492361a7d1176 100644 (file)
--- a/qemu-char.c
+++ b/qemu-char.c
@@ -89,6 +89,8 @@
 #define READ_RETRIES 10
 #define TCP_MAX_FDS 16
 
 #define READ_RETRIES 10
 #define TCP_MAX_FDS 16
 

+typedef struct MuxDriver MuxDriver;
+

 /***********************************************************/
 /* Socket address helpers */
 
 /***********************************************************/
 /* Socket address helpers */
 


@@ -190,6 +192,8 @@ CharDriverState *qemu_chr_alloc(ChardevCommon *backend, Error **errp)
 
 void qemu_chr_be_event(CharDriverState *s, int event)
 {
 
 void qemu_chr_be_event(CharDriverState *s, int event)
 {

+    CharBackend *be = s->be;
+

     /* Keep track if the char device is open */
     switch (event) {
         case CHR_EVENT_OPENED:
     /* Keep track if the char device is open */
     switch (event) {
         case CHR_EVENT_OPENED:


@@ -200,9 +204,11 @@ void qemu_chr_be_event(CharDriverState *s, int event)
             break;
     }
 
             break;
     }
 

-    if (!s->chr_event)
+    if (!be || !be->chr_event) {

         return;
         return;

-    s->chr_event(s->handler_opaque, event);
+    }
+
+    be->chr_event(be->opaque, event);

 }
 
 void qemu_chr_be_generic_open(CharDriverState *s)
 }
 
 void qemu_chr_be_generic_open(CharDriverState *s)


@@ -266,10 +272,15 @@ static int qemu_chr_fe_write_buffer(CharDriverState *s, const uint8_t *buf, int
     return res;
 }
 
     return res;
 }
 

-int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
+int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)

 {
 {

+    CharDriverState *s = be->chr;

     int ret;
 
     int ret;
 

+    if (!s) {
+        return 0;
+    }
+

     if (s->replay && replay_mode == REPLAY_MODE_PLAY) {
         int offset;
         replay_char_write_event_load(&ret, &offset);
     if (s->replay && replay_mode == REPLAY_MODE_PLAY) {
         int offset;
         replay_char_write_event_load(&ret, &offset);


@@ -294,7 +305,7 @@ int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
     return ret;
 }
 
     return ret;
 }
 

-int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len)
+static int qemu_chr_write_all(CharDriverState *s, const uint8_t *buf, int len)

 {
     int offset;
     int res;
 {
     int offset;
     int res;


@@ -318,15 +329,27 @@ int qemu_chr_fe_write_all(CharDriverState *s, const uint8_t *buf, int len)
     return offset;
 }
 
     return offset;
 }
 

-int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len)
+int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
+{
+    CharDriverState *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)

 {
 {

+    CharDriverState *s = be->chr;

     int offset = 0, counter = 10;
     int res;
 
     int offset = 0, counter = 10;
     int res;
 

-    if (!s->chr_sync_read) {
+    if (!s || !s->chr_sync_read) {

         return 0;
     }
         return 0;
     }

-    
+

     if (s->replay && replay_mode == REPLAY_MODE_PLAY) {
         return replay_char_read_all_load(buf);
     }
     if (s->replay && replay_mode == REPLAY_MODE_PLAY) {
         return replay_char_read_all_load(buf);
     }


@@ -363,10 +386,12 @@ int qemu_chr_fe_read_all(CharDriverState *s, uint8_t *buf, int len)
     return offset;
 }
 
     return offset;
 }
 

-int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
+int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)

 {
 {

+    CharDriverState *s = be->chr;

     int res;
     int res;

-    if (!s->chr_ioctl || s->replay) {
+
+    if (!s || !s->chr_ioctl || s->replay) {

         res = -ENOTSUP;
     } else {
         res = s->chr_ioctl(s, cmd, arg);
         res = -ENOTSUP;
     } else {
         res = s->chr_ioctl(s, cmd, arg);


@@ -377,15 +402,21 @@ int qemu_chr_fe_ioctl(CharDriverState *s, int cmd, void *arg)
 
 int qemu_chr_be_can_write(CharDriverState *s)
 {
 
 int qemu_chr_be_can_write(CharDriverState *s)
 {

-    if (!s->chr_can_read)
+    CharBackend *be = s->be;
+
+    if (!be || !be->chr_can_read) {

         return 0;
         return 0;

-    return s->chr_can_read(s->handler_opaque);
+    }
+
+    return be->chr_can_read(be->opaque);

 }
 
 void qemu_chr_be_write_impl(CharDriverState *s, uint8_t *buf, int len)
 {
 }
 
 void qemu_chr_be_write_impl(CharDriverState *s, uint8_t *buf, int len)
 {

-    if (s->chr_read) {
-        s->chr_read(s->handler_opaque, buf, len);
+    CharBackend *be = s->be;
+
+    if (be && be->chr_read) {
+        be->chr_read(be->opaque, buf, len);

     }
 }
 
     }
 }
 


@@ -401,11 +432,12 @@ void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
     }
 }
 
     }
 }
 

-int qemu_chr_fe_get_msgfd(CharDriverState *s)
+int qemu_chr_fe_get_msgfd(CharBackend *be)

 {
 {

+    CharDriverState *s = be->chr;

     int fd;
     int fd;

-    int res = (qemu_chr_fe_get_msgfds(s, &fd, 1) == 1) ? fd : -1;
-    if (s->replay) {
+    int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
+    if (s && s->replay) {

         fprintf(stderr,
                 "Replay: get msgfd is not supported for serial devices yet\n");
         exit(1);
         fprintf(stderr,
                 "Replay: get msgfd is not supported for serial devices yet\n");
         exit(1);


@@ -413,13 +445,25 @@ int qemu_chr_fe_get_msgfd(CharDriverState *s)
     return res;
 }
 
     return res;
 }
 

-int qemu_chr_fe_get_msgfds(CharDriverState *s, int *fds, int len)
+int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)

 {
 {

+    CharDriverState *s = be->chr;
+
+    if (!s) {
+        return -1;
+    }
+

     return s->get_msgfds ? s->get_msgfds(s, fds, len) : -1;
 }
 
     return s->get_msgfds ? s->get_msgfds(s, fds, len) : -1;
 }
 

-int qemu_chr_fe_set_msgfds(CharDriverState *s, int *fds, int num)
+int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)

 {
 {

+    CharDriverState *s = be->chr;
+
+    if (!s) {
+        return -1;
+    }
+

     return s->set_msgfds ? s->set_msgfds(s, fds, num) : -1;
 }
 
     return s->set_msgfds ? s->set_msgfds(s, fds, num) : -1;
 }
 


@@ -428,14 +472,20 @@ int qemu_chr_add_client(CharDriverState *s, int fd)
     return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
 }
 
     return s->chr_add_client ? s->chr_add_client(s, fd) : -1;
 }
 

-void qemu_chr_accept_input(CharDriverState *s)
+void qemu_chr_fe_accept_input(CharBackend *be)

 {
 {

+    CharDriverState *s = be->chr;
+
+    if (!s) {
+        return;
+    }
+

     if (s->chr_accept_input)
         s->chr_accept_input(s);
     qemu_notify_event();
 }
 
     if (s->chr_accept_input)
         s->chr_accept_input(s);
     qemu_notify_event();
 }
 

-void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
+void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)

 {
     char buf[READ_BUF_LEN];
     va_list ap;
 {
     char buf[READ_BUF_LEN];
     va_list ap;


@@ -443,55 +493,13 @@ void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
     vsnprintf(buf, sizeof(buf), fmt, ap);
     /* XXX this blocks entire thread. Rewrite to use
      * qemu_chr_fe_write and background I/O callbacks */
     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(s, (uint8_t *)buf, strlen(buf));
+    qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));

     va_end(ap);
 }
 
 static void remove_fd_in_watch(CharDriverState *chr);
     va_end(ap);
 }
 
 static void remove_fd_in_watch(CharDriverState *chr);

-
-void qemu_chr_add_handlers_full(CharDriverState *s,
-                                IOCanReadHandler *fd_can_read,
-                                IOReadHandler *fd_read,
-                                IOEventHandler *fd_event,
-                                void *opaque,
-                                GMainContext *context)
-{
-    int fe_open;
-
-    if (!opaque && !fd_can_read && !fd_read && !fd_event) {
-        fe_open = 0;
-        remove_fd_in_watch(s);
-    } else {
-        fe_open = 1;
-    }
-    s->chr_can_read = fd_can_read;
-    s->chr_read = fd_read;
-    s->chr_event = fd_event;
-    s->handler_opaque = opaque;
-    if (s->chr_update_read_handler) {
-        s->chr_update_read_handler(s, context);
-    }
-
-    if (!s->explicit_fe_open) {
-        qemu_chr_fe_set_open(s, fe_open);
-    }
-
-    /* We're connecting to an already opened device, so let's make sure we
-       also get the open event */
-    if (fe_open && s->be_open) {
-        qemu_chr_be_generic_open(s);
-    }
-}
-
-void qemu_chr_add_handlers(CharDriverState *s,
-                           IOCanReadHandler *fd_can_read,
-                           IOReadHandler *fd_read,
-                           IOEventHandler *fd_event,
-                           void *opaque)
-{
-    qemu_chr_add_handlers_full(s, fd_can_read, fd_read,
-                               fd_event, opaque, NULL);
-}
+static void mux_chr_set_handlers(CharDriverState *chr, GMainContext *context);
+static void mux_set_focus(MuxDriver *d, int focus);

 
 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 {
 
 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 {


@@ -501,6 +509,7 @@ static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 static CharDriverState *qemu_chr_open_null(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_null(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,

+                                           bool *be_opened,

                                            Error **errp)
 {
     CharDriverState *chr;
                                            Error **errp)
 {
     CharDriverState *chr;


@@ -511,7 +520,7 @@ static CharDriverState *qemu_chr_open_null(const char *id,
         return NULL;
     }
     chr->chr_write = null_chr_write;
         return NULL;
     }
     chr->chr_write = null_chr_write;

-    chr->explicit_be_open = true;
+    *be_opened = false;

     return chr;
 }
 
     return chr;
 }
 


@@ -519,12 +528,9 @@ static CharDriverState *qemu_chr_open_null(const char *id,
 #define MAX_MUX 4
 #define MUX_BUFFER_SIZE 32     /* Must be a power of 2.  */
 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
 #define MAX_MUX 4
 #define MUX_BUFFER_SIZE 32     /* Must be a power of 2.  */
 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)

-typedef struct {
-    IOCanReadHandler *chr_can_read[MAX_MUX];
-    IOReadHandler *chr_read[MAX_MUX];
-    IOEventHandler *chr_event[MAX_MUX];
-    void *ext_opaque[MAX_MUX];
-    CharDriverState *drv;
+struct MuxDriver {
+    CharBackend *backends[MAX_MUX];
+    CharBackend chr;

     int focus;
     int mux_cnt;
     int term_got_escape;
     int focus;
     int mux_cnt;
     int term_got_escape;


@@ -540,8 +546,7 @@ typedef struct {
     /* Protected by the CharDriverState chr_write_lock.  */
     int linestart;
     int64_t timestamps_start;
     /* Protected by the CharDriverState chr_write_lock.  */
     int linestart;
     int64_t timestamps_start;

-} MuxDriver;
-
+};

 
 /* Called with chr_write_lock held.  */
 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
 
 /* Called with chr_write_lock held.  */
 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)


@@ -549,7 +554,7 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
     MuxDriver *d = chr->opaque;
     int ret;
     if (!d->timestamps) {
     MuxDriver *d = chr->opaque;
     int ret;
     if (!d->timestamps) {

-        ret = qemu_chr_fe_write(d->drv, buf, len);
+        ret = qemu_chr_fe_write(&d->chr, buf, len);

     } else {
         int i;
 
     } else {
         int i;
 


@@ -573,10 +578,11 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
                          (int)(ti % 1000));
                 /* XXX this blocks entire thread. Rewrite to use
                  * qemu_chr_fe_write and background I/O callbacks */
                          (int)(ti % 1000));
                 /* XXX this blocks entire thread. Rewrite to use
                  * qemu_chr_fe_write and background I/O callbacks */

-                qemu_chr_fe_write_all(d->drv, (uint8_t *)buf1, strlen(buf1));
+                qemu_chr_fe_write_all(&d->chr,
+                                      (uint8_t *)buf1, strlen(buf1));

                 d->linestart = 0;
             }
                 d->linestart = 0;
             }

-            ret += qemu_chr_fe_write(d->drv, buf+i, 1);
+            ret += qemu_chr_fe_write(&d->chr, buf + i, 1);

             if (buf[i] == '\n') {
                 d->linestart = 1;
             }
             if (buf[i] == '\n') {
                 d->linestart = 1;
             }


@@ -613,21 +619,24 @@ static void mux_print_help(CharDriverState *chr)
     }
     /* XXX this blocks entire thread. Rewrite to use
      * qemu_chr_fe_write and background I/O callbacks */
     }
     /* XXX this blocks entire thread. Rewrite to use
      * qemu_chr_fe_write and background I/O callbacks */

-    qemu_chr_fe_write_all(chr, (uint8_t *)cbuf, strlen(cbuf));
+    qemu_chr_write_all(chr, (uint8_t *)cbuf, strlen(cbuf));

     for (i = 0; mux_help[i] != NULL; i++) {
         for (j=0; mux_help[i][j] != '\0'; j++) {
             if (mux_help[i][j] == '%')
     for (i = 0; mux_help[i] != NULL; i++) {
         for (j=0; mux_help[i][j] != '\0'; j++) {
             if (mux_help[i][j] == '%')

-                qemu_chr_fe_write_all(chr, (uint8_t *)ebuf, strlen(ebuf));
+                qemu_chr_write_all(chr, (uint8_t *)ebuf, strlen(ebuf));

             else
             else

-                qemu_chr_fe_write_all(chr, (uint8_t *)&mux_help[i][j], 1);
+                qemu_chr_write_all(chr, (uint8_t *)&mux_help[i][j], 1);

         }
     }
 }
 
 static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
 {
         }
     }
 }
 
 static void mux_chr_send_event(MuxDriver *d, int mux_nr, int event)
 {

-    if (d->chr_event[mux_nr])
-        d->chr_event[mux_nr](d->ext_opaque[mux_nr], event);
+    CharBackend *be = d->backends[mux_nr];
+
+    if (be && be->chr_event) {
+        be->chr_event(be->opaque, event);
+    }

 }
 
 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
 }
 
 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)


@@ -644,7 +653,7 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
         case 'x':
             {
                  const char *term =  "QEMU: Terminated\n\r";
         case 'x':
             {
                  const char *term =  "QEMU: Terminated\n\r";

-                 qemu_chr_fe_write_all(chr, (uint8_t *)term, strlen(term));
+                 qemu_chr_write_all(chr, (uint8_t *)term, strlen(term));

                  exit(0);
                  break;
             }
                  exit(0);
                  break;
             }


@@ -655,12 +664,9 @@ static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
             qemu_chr_be_event(chr, CHR_EVENT_BREAK);
             break;
         case 'c':
             qemu_chr_be_event(chr, CHR_EVENT_BREAK);
             break;
         case 'c':

+            assert(d->mux_cnt > 0); /* handler registered with first fe */

             /* Switch to the next registered device */
             /* Switch to the next registered device */

-            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
-            d->focus++;
-            if (d->focus >= d->mux_cnt)
-                d->focus = 0;
-            mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
+            mux_set_focus(d, (d->focus + 1) % d->mux_cnt);

             break;
         case 't':
             d->timestamps = !d->timestamps;
             break;
         case 't':
             d->timestamps = !d->timestamps;


@@ -681,12 +687,12 @@ static void mux_chr_accept_input(CharDriverState *chr)
 {
     MuxDriver *d = chr->opaque;
     int m = d->focus;
 {
     MuxDriver *d = chr->opaque;
     int m = d->focus;

+    CharBackend *be = d->backends[m];

 
 

-    while (d->prod[m] != d->cons[m] &&
-           d->chr_can_read[m] &&
-           d->chr_can_read[m](d->ext_opaque[m])) {
-        d->chr_read[m](d->ext_opaque[m],
-                       &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);
+    while (be && d->prod[m] != d->cons[m] &&
+           be->chr_can_read && be->chr_can_read(be->opaque)) {
+        be->chr_read(be->opaque,
+                     &d->buffer[m][d->cons[m]++ & MUX_BUFFER_MASK], 1);

     }
 }
 
     }
 }
 


@@ -695,11 +701,16 @@ static int mux_chr_can_read(void *opaque)
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int m = d->focus;
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int m = d->focus;

+    CharBackend *be = d->backends[m];

 
 

-    if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE)
+    if ((d->prod[m] - d->cons[m]) < MUX_BUFFER_SIZE) {

         return 1;
         return 1;

-    if (d->chr_can_read[m])
-        return d->chr_can_read[m](d->ext_opaque[m]);
+    }
+
+    if (be && be->chr_can_read) {
+        return be->chr_can_read(be->opaque);
+    }
+

     return 0;
 }
 
     return 0;
 }
 


@@ -708,62 +719,39 @@ static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int m = d->focus;
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int m = d->focus;

+    CharBackend *be = d->backends[m];

     int i;
 
     int i;
 

-    mux_chr_accept_input (opaque);
+    mux_chr_accept_input(opaque);

 
 

-    for(i = 0; i < size; i++)
+    for (i = 0; i < size; i++)

         if (mux_proc_byte(chr, d, buf[i])) {
             if (d->prod[m] == d->cons[m] &&
         if (mux_proc_byte(chr, d, buf[i])) {
             if (d->prod[m] == d->cons[m] &&

-                d->chr_can_read[m] &&
-                d->chr_can_read[m](d->ext_opaque[m]))
-                d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
+                be && be->chr_can_read &&
+                be->chr_can_read(be->opaque))
+                be->chr_read(be->opaque, &buf[i], 1);

             else
                 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
         }
 }
 
             else
                 d->buffer[m][d->prod[m]++ & MUX_BUFFER_MASK] = buf[i];
         }
 }
 

+static bool muxes_realized;
+

 static void mux_chr_event(void *opaque, int event)
 {
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int i;
 
 static void mux_chr_event(void *opaque, int event)
 {
     CharDriverState *chr = opaque;
     MuxDriver *d = chr->opaque;
     int i;
 

+    if (!muxes_realized) {
+        return;
+    }
+

     /* Send the event to all registered listeners */
     for (i = 0; i < d->mux_cnt; i++)
         mux_chr_send_event(d, i, event);
 }
 
     /* Send the event to all registered listeners */
     for (i = 0; i < d->mux_cnt; i++)
         mux_chr_send_event(d, i, event);
 }
 

-static void mux_chr_update_read_handler(CharDriverState *chr,
-                                        GMainContext *context)
-{
-    MuxDriver *d = chr->opaque;
-
-    if (d->mux_cnt >= MAX_MUX) {
-        fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
-        return;
-    }
-    d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
-    d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
-    d->chr_read[d->mux_cnt] = chr->chr_read;
-    d->chr_event[d->mux_cnt] = chr->chr_event;
-    /* Fix up the real driver with mux routines */
-    if (d->mux_cnt == 0) {
-        qemu_chr_add_handlers_full(d->drv, mux_chr_can_read,
-                                   mux_chr_read,
-                                   mux_chr_event,
-                                   chr, context);
-    }
-    if (d->focus != -1) {
-        mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
-    }
-    d->focus = d->mux_cnt;
-    d->mux_cnt++;
-    mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
-}
-
-static bool muxes_realized;
-

 /**
  * Called after processing of default and command-line-specified
  * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
 /**
  * Called after processing of default and command-line-specified
  * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached


@@ -805,19 +793,57 @@ static Notifier muxes_realize_notify = {
 static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond)
 {
     MuxDriver *d = s->opaque;
 static GSource *mux_chr_add_watch(CharDriverState *s, GIOCondition cond)
 {
     MuxDriver *d = s->opaque;

-    return d->drv->chr_add_watch(d->drv, cond);
+    CharDriverState *chr = qemu_chr_fe_get_driver(&d->chr);
+
+    return chr->chr_add_watch(chr, cond);

 }
 
 }
 

-static void mux_chr_close(struct CharDriverState *chr)
+static void mux_chr_free(struct CharDriverState *chr)

 {
     MuxDriver *d = chr->opaque;
 {
     MuxDriver *d = chr->opaque;

+    int i;

 
 

+    for (i = 0; i < d->mux_cnt; i++) {
+        CharBackend *be = d->backends[i];
+        if (be) {
+            be->chr = NULL;
+        }
+    }
+    qemu_chr_fe_deinit(&d->chr);

     g_free(d);
 }
 
     g_free(d);
 }
 

+static void mux_chr_set_handlers(CharDriverState *chr, GMainContext *context)
+{
+    MuxDriver *d = chr->opaque;
+
+    /* Fix up the real driver with mux routines */
+    qemu_chr_fe_set_handlers(&d->chr,
+                             mux_chr_can_read,
+                             mux_chr_read,
+                             mux_chr_event,
+                             chr,
+                             context, true);
+}
+
+static void mux_set_focus(MuxDriver *d, int focus)
+{
+    assert(focus >= 0);
+    assert(focus < d->mux_cnt);
+
+    if (d->focus != -1) {
+        mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_OUT);
+    }
+
+    d->focus = focus;
+    mux_chr_send_event(d, d->focus, CHR_EVENT_MUX_IN);
+}
+

 static CharDriverState *qemu_chr_open_mux(const char *id,
                                           ChardevBackend *backend,
 static CharDriverState *qemu_chr_open_mux(const char *id,
                                           ChardevBackend *backend,

-                                          ChardevReturn *ret, Error **errp)
+                                          ChardevReturn *ret,
+                                          bool *be_opened,
+                                          Error **errp)

 {
     ChardevMux *mux = backend->u.mux.data;
     CharDriverState *chr, *drv;
 {
     ChardevMux *mux = backend->u.mux.data;
     CharDriverState *chr, *drv;


@@ -837,11 +863,9 @@ static CharDriverState *qemu_chr_open_mux(const char *id,
     d = g_new0(MuxDriver, 1);
 
     chr->opaque = d;
     d = g_new0(MuxDriver, 1);
 
     chr->opaque = d;

-    d->drv = drv;

     d->focus = -1;
     d->focus = -1;

-    chr->chr_close = mux_chr_close;
+    chr->chr_free = mux_chr_free;

     chr->chr_write = mux_chr_write;
     chr->chr_write = mux_chr_write;

-    chr->chr_update_read_handler = mux_chr_update_read_handler;

     chr->chr_accept_input = mux_chr_accept_input;
     /* Frontend guest-open / -close notification is not support with muxes */
     chr->chr_set_fe_open = NULL;
     chr->chr_accept_input = mux_chr_accept_input;
     /* Frontend guest-open / -close notification is not support with muxes */
     chr->chr_set_fe_open = NULL;


@@ -851,12 +875,133 @@ static CharDriverState *qemu_chr_open_mux(const char *id,
     /* only default to opened state if we've realized the initial
      * set of muxes
      */
     /* only default to opened state if we've realized the initial
      * set of muxes
      */

-    chr->explicit_be_open = muxes_realized ? 0 : 1;
+    *be_opened = muxes_realized;

     chr->is_mux = 1;
     chr->is_mux = 1;

+    if (!qemu_chr_fe_init(&d->chr, drv, errp)) {
+        qemu_chr_free(chr);
+        return NULL;
+    }

 
     return chr;
 }
 
 
     return chr;
 }
 

+CharDriverState *qemu_chr_fe_get_driver(CharBackend *be)
+{
+    return be->chr;
+}
+
+bool qemu_chr_fe_init(CharBackend *b, CharDriverState *s, Error **errp)
+{
+    int tag = 0;
+
+    if (s->is_mux) {
+        MuxDriver *d = s->opaque;
+
+        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(CharDriverState *s)
+{
+    if (s->is_mux) {
+        MuxDriver *d = s->opaque;
+        return d->mux_cnt >= 0;
+    } else {
+        return s->be != NULL;
+    }
+}
+
+void qemu_chr_fe_deinit(CharBackend *b)
+{
+    assert(b);
+
+    if (b->chr) {
+        qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
+        b->chr->be = NULL;
+        if (b->chr->is_mux) {
+            MuxDriver *d = b->chr->opaque;
+            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)
+{
+    CharDriverState *s;
+    int fe_open;
+
+    s = b->chr;
+    if (!s) {
+        return;
+    }
+
+    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 (s->chr_update_read_handler) {
+        s->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_generic_open(s);
+        }
+    }
+
+    if (s->is_mux) {
+        mux_chr_set_handlers(s, context);
+    }
+}
+
+void qemu_chr_fe_take_focus(CharBackend *b)
+{
+    if (!b->chr) {
+        return;
+    }
+
+    if (b->chr->is_mux) {
+        mux_set_focus(b->chr->opaque, b->tag);
+    }
+}

 
 typedef struct IOWatchPoll
 {
 
 typedef struct IOWatchPoll
 {


@@ -934,7 +1079,8 @@ static GSourceFuncs io_watch_poll_funcs = {
 };
 
 /* Can only be used for read */
 };
 
 /* Can only be used for read */

-static guint io_add_watch_poll(QIOChannel *ioc,
+static guint io_add_watch_poll(CharDriverState *chr,
+                               QIOChannel *ioc,

                                IOCanReadHandler *fd_can_read,
                                QIOChannelFunc fd_read,
                                gpointer user_data,
                                IOCanReadHandler *fd_can_read,
                                QIOChannelFunc fd_read,
                                gpointer user_data,


@@ -942,6 +1088,7 @@ static guint io_add_watch_poll(QIOChannel *ioc,
 {
     IOWatchPoll *iwp;
     int tag;
 {
     IOWatchPoll *iwp;
     int tag;

+    char *name;

 
     iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
                                        sizeof(IOWatchPoll));
 
     iwp = (IOWatchPoll *) g_source_new(&io_watch_poll_funcs,
                                        sizeof(IOWatchPoll));


@@ -952,6 +1099,10 @@ static guint io_add_watch_poll(QIOChannel *ioc,
     iwp->src = NULL;
     iwp->context = context;
 
     iwp->src = NULL;
     iwp->context = context;
 

+    name = g_strdup_printf("chardev-iowatch-%s", chr->label);
+    g_source_set_name((GSource *)iwp, name);
+    g_free(name);
+

     tag = g_source_attach(&iwp->parent, context);
     g_source_unref(&iwp->parent);
     return tag;
     tag = g_source_attach(&iwp->parent, context);
     g_source_unref(&iwp->parent);
     return tag;


@@ -1091,14 +1242,14 @@ static void fd_chr_update_read_handler(CharDriverState *chr,
 
     remove_fd_in_watch(chr);
     if (s->ioc_in) {
 
     remove_fd_in_watch(chr);
     if (s->ioc_in) {

-        chr->fd_in_tag = io_add_watch_poll(s->ioc_in,
+        chr->fd_in_tag = io_add_watch_poll(chr, s->ioc_in,

                                            fd_chr_read_poll,
                                            fd_chr_read, chr,
                                            context);
     }
 }
 
                                            fd_chr_read_poll,
                                            fd_chr_read, chr,
                                            context);
     }
 }
 

-static void fd_chr_close(struct CharDriverState *chr)
+static void fd_chr_free(struct CharDriverState *chr)

 {
     FDCharDriver *s = chr->opaque;
 
 {
     FDCharDriver *s = chr->opaque;
 


@@ -1120,6 +1271,7 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out,
 {
     CharDriverState *chr;
     FDCharDriver *s;
 {
     CharDriverState *chr;
     FDCharDriver *s;

+    char *name;

 
     chr = qemu_chr_alloc(backend, errp);
     if (!chr) {
 
     chr = qemu_chr_alloc(backend, errp);
     if (!chr) {


@@ -1127,14 +1279,20 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out,
     }
     s = g_new0(FDCharDriver, 1);
     s->ioc_in = QIO_CHANNEL(qio_channel_file_new_fd(fd_in));
     }
     s = g_new0(FDCharDriver, 1);
     s->ioc_in = QIO_CHANNEL(qio_channel_file_new_fd(fd_in));

+    name = g_strdup_printf("chardev-file-in-%s", chr->label);
+    qio_channel_set_name(QIO_CHANNEL(s->ioc_in), name);
+    g_free(name);

     s->ioc_out = QIO_CHANNEL(qio_channel_file_new_fd(fd_out));
     s->ioc_out = QIO_CHANNEL(qio_channel_file_new_fd(fd_out));

+    name = g_strdup_printf("chardev-file-out-%s", chr->label);
+    qio_channel_set_name(QIO_CHANNEL(s->ioc_out), name);
+    g_free(name);

     qemu_set_nonblock(fd_out);
     s->chr = chr;
     chr->opaque = s;
     chr->chr_add_watch = fd_chr_add_watch;
     chr->chr_write = fd_chr_write;
     chr->chr_update_read_handler = fd_chr_update_read_handler;
     qemu_set_nonblock(fd_out);
     s->chr = chr;
     chr->opaque = s;
     chr->chr_add_watch = fd_chr_add_watch;
     chr->chr_write = fd_chr_write;
     chr->chr_update_read_handler = fd_chr_update_read_handler;

-    chr->chr_close = fd_chr_close;
+    chr->chr_free = fd_chr_free;

 
     return chr;
 }
 
     return chr;
 }


@@ -1142,6 +1300,7 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out,
 static CharDriverState *qemu_chr_open_pipe(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_pipe(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,

+                                           bool *be_opened,

                                            Error **errp)
 {
     ChardevHostdev *opts = backend->u.pipe.data;
                                            Error **errp)
 {
     ChardevHostdev *opts = backend->u.pipe.data;


@@ -1215,15 +1374,16 @@ static void qemu_chr_set_echo_stdio(CharDriverState *chr, bool echo)
     tcsetattr (0, TCSANOW, &tty);
 }
 
     tcsetattr (0, TCSANOW, &tty);
 }
 

-static void qemu_chr_close_stdio(struct CharDriverState *chr)
+static void qemu_chr_free_stdio(struct CharDriverState *chr)

 {
     term_exit();
 {
     term_exit();

-    fd_chr_close(chr);
+    fd_chr_free(chr);

 }
 
 static CharDriverState *qemu_chr_open_stdio(const char *id,
                                             ChardevBackend *backend,
                                             ChardevReturn *ret,
 }
 
 static CharDriverState *qemu_chr_open_stdio(const char *id,
                                             ChardevBackend *backend,
                                             ChardevReturn *ret,

+                                            bool *be_opened,

                                             Error **errp)
 {
     ChardevStdio *opts = backend->u.stdio.data;
                                             Error **errp)
 {
     ChardevStdio *opts = backend->u.stdio.data;


@@ -1255,12 +1415,12 @@ static CharDriverState *qemu_chr_open_stdio(const char *id,
     if (!chr) {
         return NULL;
     }
     if (!chr) {
         return NULL;
     }

-    chr->chr_close = qemu_chr_close_stdio;
+    chr->chr_free = qemu_chr_free_stdio;

     chr->chr_set_echo = qemu_chr_set_echo_stdio;
     if (opts->has_signal) {
         stdio_allow_signal = opts->signal;
     }
     chr->chr_set_echo = qemu_chr_set_echo_stdio;
     if (opts->has_signal) {
         stdio_allow_signal = opts->signal;
     }

-    qemu_chr_fe_set_echo(chr, false);
+    qemu_chr_set_echo_stdio(chr, false);

 
     return chr;
 }
 
     return chr;
 }


@@ -1305,6 +1465,7 @@ static gboolean pty_chr_timer(gpointer opaque)
 static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
 {
     PtyCharDriver *s = chr->opaque;
 static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
 {
     PtyCharDriver *s = chr->opaque;

+    char *name;

 
     if (s->timer_tag) {
         g_source_remove(s->timer_tag);
 
     if (s->timer_tag) {
         g_source_remove(s->timer_tag);


@@ -1312,10 +1473,14 @@ static void pty_chr_rearm_timer(CharDriverState *chr, int ms)
     }
 
     if (ms == 1000) {
     }
 
     if (ms == 1000) {

+        name = g_strdup_printf("pty-timer-secs-%s", chr->label);

         s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr);
     } else {
         s->timer_tag = g_timeout_add_seconds(1, pty_chr_timer, chr);
     } else {

+        name = g_strdup_printf("pty-timer-ms-%s", chr->label);

         s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr);
     }
         s->timer_tag = g_timeout_add(ms, pty_chr_timer, chr);
     }

+    g_source_set_name_by_id(s->timer_tag, name);
+    g_free(name);

 }
 
 /* Called with chr_write_lock held.  */
 }
 
 /* Called with chr_write_lock held.  */


@@ -1444,7 +1609,7 @@ static void pty_chr_state(CharDriverState *chr, int connected)
             s->open_tag = g_idle_add(qemu_chr_be_generic_open_func, chr);
         }
         if (!chr->fd_in_tag) {
             s->open_tag = g_idle_add(qemu_chr_be_generic_open_func, chr);
         }
         if (!chr->fd_in_tag) {

-            chr->fd_in_tag = io_add_watch_poll(s->ioc,
+            chr->fd_in_tag = io_add_watch_poll(chr, s->ioc,

                                                pty_chr_read_poll,
                                                pty_chr_read,
                                                chr, NULL);
                                                pty_chr_read_poll,
                                                pty_chr_read,
                                                chr, NULL);


@@ -1452,7 +1617,7 @@ static void pty_chr_state(CharDriverState *chr, int connected)
     }
 }
 
     }
 }
 

-static void pty_chr_close(struct CharDriverState *chr)
+static void pty_chr_free(struct CharDriverState *chr)

 {
     PtyCharDriver *s = chr->opaque;
 
 {
     PtyCharDriver *s = chr->opaque;
 


@@ -1471,6 +1636,7 @@ static void pty_chr_close(struct CharDriverState *chr)
 static CharDriverState *qemu_chr_open_pty(const char *id,
                                           ChardevBackend *backend,
                                           ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_pty(const char *id,
                                           ChardevBackend *backend,
                                           ChardevReturn *ret,

+                                          bool *be_opened,

                                           Error **errp)
 {
     CharDriverState *chr;
                                           Error **errp)
 {
     CharDriverState *chr;


@@ -1478,6 +1644,7 @@ static CharDriverState *qemu_chr_open_pty(const char *id,
     int master_fd, slave_fd;
     char pty_name[PATH_MAX];
     ChardevCommon *common = backend->u.pty.data;
     int master_fd, slave_fd;
     char pty_name[PATH_MAX];
     ChardevCommon *common = backend->u.pty.data;

+    char *name;

 
     master_fd = qemu_openpty_raw(&slave_fd, pty_name);
     if (master_fd < 0) {
 
     master_fd = qemu_openpty_raw(&slave_fd, pty_name);
     if (master_fd < 0) {


@@ -1505,11 +1672,14 @@ static CharDriverState *qemu_chr_open_pty(const char *id,
     chr->opaque = s;
     chr->chr_write = pty_chr_write;
     chr->chr_update_read_handler = pty_chr_update_read_handler;
     chr->opaque = s;
     chr->chr_write = pty_chr_write;
     chr->chr_update_read_handler = pty_chr_update_read_handler;

-    chr->chr_close = pty_chr_close;
+    chr->chr_free = pty_chr_free;

     chr->chr_add_watch = pty_chr_add_watch;
     chr->chr_add_watch = pty_chr_add_watch;

-    chr->explicit_be_open = true;
+    *be_opened = false;

 
     s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd));
 
     s->ioc = QIO_CHANNEL(qio_channel_file_new_fd(master_fd));

+    name = g_strdup_printf("chardev-pty-%s", chr->label);
+    qio_channel_set_name(QIO_CHANNEL(s->ioc), name);
+    g_free(name);

     s->timer_tag = 0;
 
     return chr;
     s->timer_tag = 0;
 
     return chr;


@@ -1700,13 +1870,14 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
     return 0;
 }
 
     return 0;
 }
 

-static void qemu_chr_close_tty(CharDriverState *chr)
+static void qemu_chr_free_tty(CharDriverState *chr)

 {
 {

-    fd_chr_close(chr);
+    fd_chr_free(chr);

 }
 
 static CharDriverState *qemu_chr_open_tty_fd(int fd,
                                              ChardevCommon *backend,
 }
 
 static CharDriverState *qemu_chr_open_tty_fd(int fd,
                                              ChardevCommon *backend,

+                                             bool *be_opened,

                                              Error **errp)
 {
     CharDriverState *chr;
                                              Error **errp)
 {
     CharDriverState *chr;


@@ -1717,7 +1888,7 @@ static CharDriverState *qemu_chr_open_tty_fd(int fd,
         return NULL;
     }
     chr->chr_ioctl = tty_serial_ioctl;
         return NULL;
     }
     chr->chr_ioctl = tty_serial_ioctl;

-    chr->chr_close = qemu_chr_close_tty;
+    chr->chr_free = qemu_chr_free_tty;

     return chr;
 }
 #endif /* __linux__ || __sun__ */
     return chr;
 }
 #endif /* __linux__ || __sun__ */


@@ -1823,7 +1994,7 @@ static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
     return 0;
 }
 
     return 0;
 }
 

-static void pp_close(CharDriverState *chr)
+static void pp_free(CharDriverState *chr)

 {
     ParallelCharDriver *drv = chr->opaque;
     int fd = drv->fd;
 {
     ParallelCharDriver *drv = chr->opaque;
     int fd = drv->fd;


@@ -1837,6 +2008,7 @@ static void pp_close(CharDriverState *chr)
 
 static CharDriverState *qemu_chr_open_pp_fd(int fd,
                                             ChardevCommon *backend,
 
 static CharDriverState *qemu_chr_open_pp_fd(int fd,
                                             ChardevCommon *backend,

+                                            bool *be_opened,

                                             Error **errp)
 {
     CharDriverState *chr;
                                             Error **errp)
 {
     CharDriverState *chr;


@@ -1857,7 +2029,7 @@ static CharDriverState *qemu_chr_open_pp_fd(int fd,
     chr->opaque = drv;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;
     chr->opaque = drv;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;

-    chr->chr_close = pp_close;
+    chr->chr_free = pp_free;

 
     drv->fd = fd;
     drv->mode = IEEE1284_MODE_COMPAT;
 
     drv->fd = fd;
     drv->mode = IEEE1284_MODE_COMPAT;


@@ -1909,6 +2081,7 @@ static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
 
 static CharDriverState *qemu_chr_open_pp_fd(int fd,
                                             ChardevCommon *backend,
 
 static CharDriverState *qemu_chr_open_pp_fd(int fd,
                                             ChardevCommon *backend,

+                                            bool *be_opened,

                                             Error **errp)
 {
     CharDriverState *chr;
                                             Error **errp)
 {
     CharDriverState *chr;


@@ -1920,7 +2093,7 @@ static CharDriverState *qemu_chr_open_pp_fd(int fd,
     chr->opaque = (void *)(intptr_t)fd;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;
     chr->opaque = (void *)(intptr_t)fd;
     chr->chr_write = null_chr_write;
     chr->chr_ioctl = pp_ioctl;

-    chr->explicit_be_open = true;
+    *be_opened = false;

     return chr;
 }
 #endif
     return chr;
 }
 #endif


@@ -1956,7 +2129,7 @@ typedef struct {
 static int win_chr_poll(void *opaque);
 static int win_chr_pipe_poll(void *opaque);
 
 static int win_chr_poll(void *opaque);
 static int win_chr_pipe_poll(void *opaque);
 

-static void win_chr_close(CharDriverState *chr)
+static void win_chr_free(CharDriverState *chr)

 {
     WinCharState *s = chr->opaque;
 
 {
     WinCharState *s = chr->opaque;
 


@@ -2043,7 +2216,7 @@ static int win_chr_init(CharDriverState *chr, const char *filename, Error **errp
     return 0;
 
  fail:
     return 0;
 
  fail:

-    win_chr_close(chr);
+    win_chr_free(chr);

     return -1;
 }
 
     return -1;
 }
 


@@ -2155,7 +2328,7 @@ static CharDriverState *qemu_chr_open_win_path(const char *filename,
     s = g_new0(WinCharState, 1);
     chr->opaque = s;
     chr->chr_write = win_chr_write;
     s = g_new0(WinCharState, 1);
     chr->opaque = s;
     chr->chr_write = win_chr_write;

-    chr->chr_close = win_chr_close;
+    chr->chr_free = win_chr_free;

 
     if (win_chr_init(chr, filename, errp) < 0) {
         g_free(s);
 
     if (win_chr_init(chr, filename, errp) < 0) {
         g_free(s);


@@ -2241,7 +2414,7 @@ static int win_chr_pipe_init(CharDriverState *chr, const char *filename,
     return 0;
 
  fail:
     return 0;
 
  fail:

-    win_chr_close(chr);
+    win_chr_free(chr);

     return -1;
 }
 
     return -1;
 }
 


@@ -2249,6 +2422,7 @@ static int win_chr_pipe_init(CharDriverState *chr, const char *filename,
 static CharDriverState *qemu_chr_open_pipe(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_pipe(const char *id,
                                            ChardevBackend *backend,
                                            ChardevReturn *ret,

+                                           bool *be_opened,

                                            Error **errp)
 {
     ChardevHostdev *opts = backend->u.pipe.data;
                                            Error **errp)
 {
     ChardevHostdev *opts = backend->u.pipe.data;


@@ -2264,7 +2438,7 @@ static CharDriverState *qemu_chr_open_pipe(const char *id,
     s = g_new0(WinCharState, 1);
     chr->opaque = s;
     chr->chr_write = win_chr_write;
     s = g_new0(WinCharState, 1);
     chr->opaque = s;
     chr->chr_write = win_chr_write;

-    chr->chr_close = win_chr_close;
+    chr->chr_free = win_chr_free;

 
     if (win_chr_pipe_init(chr, filename, errp) < 0) {
         g_free(s);
 
     if (win_chr_pipe_init(chr, filename, errp) < 0) {
         g_free(s);


@@ -2295,6 +2469,7 @@ static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out,
 static CharDriverState *qemu_chr_open_win_con(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_win_con(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,

+                                              bool *be_opened,

                                               Error **errp)
 {
     ChardevCommon *common = backend->u.console.data;
                                               Error **errp)
 {
     ChardevCommon *common = backend->u.console.data;


@@ -2420,7 +2595,7 @@ static void qemu_chr_set_echo_win_stdio(CharDriverState *chr, bool echo)
     }
 }
 
     }
 }
 

-static void win_stdio_close(CharDriverState *chr)
+static void win_stdio_free(CharDriverState *chr)

 {
     WinStdioCharState *stdio = chr->opaque;
 
 {
     WinStdioCharState *stdio = chr->opaque;
 


@@ -2440,6 +2615,7 @@ static void win_stdio_close(CharDriverState *chr)
 static CharDriverState *qemu_chr_open_stdio(const char *id,
                                             ChardevBackend *backend,
                                             ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_stdio(const char *id,
                                             ChardevBackend *backend,
                                             ChardevReturn *ret,

+                                            bool *be_opened,

                                             Error **errp)
 {
     CharDriverState   *chr;
                                             Error **errp)
 {
     CharDriverState   *chr;


@@ -2464,7 +2640,7 @@ static CharDriverState *qemu_chr_open_stdio(const char *id,
 
     chr->opaque    = stdio;
     chr->chr_write = win_stdio_write;
 
     chr->opaque    = stdio;
     chr->chr_write = win_stdio_write;

-    chr->chr_close = win_stdio_close;
+    chr->chr_free = win_stdio_free;

 
     if (is_console) {
         if (qemu_add_wait_object(stdio->hStdIn,
 
     if (is_console) {
         if (qemu_add_wait_object(stdio->hStdIn,


@@ -2507,7 +2683,7 @@ static CharDriverState *qemu_chr_open_stdio(const char *id,
     SetConsoleMode(stdio->hStdIn, dwMode);
 
     chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
     SetConsoleMode(stdio->hStdIn, dwMode);
 
     chr->chr_set_echo = qemu_chr_set_echo_win_stdio;

-    qemu_chr_fe_set_echo(chr, false);
+    qemu_chr_set_echo_win_stdio(chr, false);

 
     return chr;
 
 
     return chr;
 


@@ -2522,7 +2698,6 @@ err1:
 }
 #endif /* !_WIN32 */
 
 }
 #endif /* !_WIN32 */
 

-

 /***********************************************************/
 /* UDP Net console */
 
 /***********************************************************/
 /* UDP Net console */
 


@@ -2595,14 +2770,14 @@ static void udp_chr_update_read_handler(CharDriverState *chr,
 
     remove_fd_in_watch(chr);
     if (s->ioc) {
 
     remove_fd_in_watch(chr);
     if (s->ioc) {

-        chr->fd_in_tag = io_add_watch_poll(s->ioc,
+        chr->fd_in_tag = io_add_watch_poll(chr, s->ioc,

                                            udp_chr_read_poll,
                                            udp_chr_read, chr,
                                            context);
     }
 }
 
                                            udp_chr_read_poll,
                                            udp_chr_read, chr,
                                            context);
     }
 }
 

-static void udp_chr_close(CharDriverState *chr)
+static void udp_chr_free(CharDriverState *chr)

 {
     NetCharDriver *s = chr->opaque;
 
 {
     NetCharDriver *s = chr->opaque;
 


@@ -2616,6 +2791,7 @@ static void udp_chr_close(CharDriverState *chr)
 
 static CharDriverState *qemu_chr_open_udp(QIOChannelSocket *sioc,
                                           ChardevCommon *backend,
 
 static CharDriverState *qemu_chr_open_udp(QIOChannelSocket *sioc,
                                           ChardevCommon *backend,

+                                          bool *be_opened,

                                           Error **errp)
 {
     CharDriverState *chr = NULL;
                                           Error **errp)
 {
     CharDriverState *chr = NULL;


@@ -2633,9 +2809,9 @@ static CharDriverState *qemu_chr_open_udp(QIOChannelSocket *sioc,
     chr->opaque = s;
     chr->chr_write = udp_chr_write;
     chr->chr_update_read_handler = udp_chr_update_read_handler;
     chr->opaque = s;
     chr->chr_write = udp_chr_write;
     chr->chr_update_read_handler = udp_chr_update_read_handler;

-    chr->chr_close = udp_chr_close;
+    chr->chr_free = udp_chr_free;

     /* be isn't opened until we get a connection */
     /* be isn't opened until we get a connection */

-    chr->explicit_be_open = true;
+    *be_opened = false;

     return chr;
 }
 
     return chr;
 }
 


@@ -2672,9 +2848,13 @@ static gboolean socket_reconnect_timeout(gpointer opaque);
 static void qemu_chr_socket_restart_timer(CharDriverState *chr)
 {
     TCPCharDriver *s = chr->opaque;
 static void qemu_chr_socket_restart_timer(CharDriverState *chr)
 {
     TCPCharDriver *s = chr->opaque;

+    char *name;

     assert(s->connected == 0);
     s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time,
                                                socket_reconnect_timeout, chr);
     assert(s->connected == 0);
     s->reconnect_timer = g_timeout_add_seconds(s->reconnect_time,
                                                socket_reconnect_timeout, chr);

+    name = g_strdup_printf("chardev-socket-reconnect-%s", chr->label);
+    g_source_set_name_by_id(s->reconnect_timer, name);
+    g_free(name);

 }
 
 static void check_report_connect_error(CharDriverState *chr,
 }
 
 static void check_report_connect_error(CharDriverState *chr,


@@ -2999,7 +3179,7 @@ static void tcp_chr_connect(void *opaque)
 
     s->connected = 1;
     if (s->ioc) {
 
     s->connected = 1;
     if (s->ioc) {

-        chr->fd_in_tag = io_add_watch_poll(s->ioc,
+        chr->fd_in_tag = io_add_watch_poll(chr, s->ioc,

                                            tcp_chr_read_poll,
                                            tcp_chr_read,
                                            chr, NULL);
                                            tcp_chr_read_poll,
                                            tcp_chr_read,
                                            chr, NULL);


@@ -3018,7 +3198,7 @@ static void tcp_chr_update_read_handler(CharDriverState *chr,
 
     remove_fd_in_watch(chr);
     if (s->ioc) {
 
     remove_fd_in_watch(chr);
     if (s->ioc) {

-        chr->fd_in_tag = io_add_watch_poll(s->ioc,
+        chr->fd_in_tag = io_add_watch_poll(chr, s->ioc,

                                            tcp_chr_read_poll,
                                            tcp_chr_read, chr,
                                            context);
                                            tcp_chr_read_poll,
                                            tcp_chr_read, chr,
                                            context);


@@ -3116,6 +3296,7 @@ static void tcp_chr_tls_init(CharDriverState *chr)
     TCPCharDriver *s = chr->opaque;
     QIOChannelTLS *tioc;
     Error *err = NULL;
     TCPCharDriver *s = chr->opaque;
     QIOChannelTLS *tioc;
     Error *err = NULL;

+    gchar *name;

 
     if (s->is_listen) {
         tioc = qio_channel_tls_new_server(
 
     if (s->is_listen) {
         tioc = qio_channel_tls_new_server(


@@ -3133,6 +3314,11 @@ static void tcp_chr_tls_init(CharDriverState *chr)
         tcp_chr_disconnect(chr);
         return;
     }
         tcp_chr_disconnect(chr);
         return;
     }

+    name = g_strdup_printf("chardev-tls-%s-%s",
+                           s->is_listen ? "server" : "client",
+                           chr->label);
+    qio_channel_set_name(QIO_CHANNEL(tioc), name);
+    g_free(name);

     object_unref(OBJECT(s->ioc));
     s->ioc = QIO_CHANNEL(tioc);
 
     object_unref(OBJECT(s->ioc));
     s->ioc = QIO_CHANNEL(tioc);
 


@@ -3143,6 +3329,19 @@ static void tcp_chr_tls_init(CharDriverState *chr)
 }
 
 
 }
 
 

+static void tcp_chr_set_client_ioc_name(CharDriverState *chr,
+                                        QIOChannelSocket *sioc)
+{
+    TCPCharDriver *s = chr->opaque;
+    char *name;
+    name = g_strdup_printf("chardev-tcp-%s-%s",
+                           s->is_listen ? "server" : "client",
+                           chr->label);
+    qio_channel_set_name(QIO_CHANNEL(sioc), name);
+    g_free(name);
+
+}
+

 static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)
 {
     TCPCharDriver *s = chr->opaque;
 static int tcp_chr_new_client(CharDriverState *chr, QIOChannelSocket *sioc)
 {
     TCPCharDriver *s = chr->opaque;


@@ -3188,6 +3387,7 @@ static int tcp_chr_add_client(CharDriverState *chr, int fd)
     if (!sioc) {
         return -1;
     }
     if (!sioc) {
         return -1;
     }

+    tcp_chr_set_client_ioc_name(chr, sioc);

     ret = tcp_chr_new_client(chr, sioc);
     object_unref(OBJECT(sioc));
     return ret;
     ret = tcp_chr_new_client(chr, sioc);
     object_unref(OBJECT(sioc));
     return ret;


@@ -3229,6 +3429,7 @@ static int tcp_chr_wait_connected(CharDriverState *chr, Error **errp)
             qio_channel_set_blocking(QIO_CHANNEL(s->listen_ioc), false, NULL);
         } else {
             sioc = qio_channel_socket_new();
             qio_channel_set_blocking(QIO_CHANNEL(s->listen_ioc), false, NULL);
         } else {
             sioc = qio_channel_socket_new();

+            tcp_chr_set_client_ioc_name(chr, sioc);

             if (qio_channel_socket_connect_sync(sioc, s->addr, errp) < 0) {
                 object_unref(OBJECT(sioc));
                 return -1;
             if (qio_channel_socket_connect_sync(sioc, s->addr, errp) < 0) {
                 object_unref(OBJECT(sioc));
                 return -1;


@@ -3241,7 +3442,7 @@ static int tcp_chr_wait_connected(CharDriverState *chr, Error **errp)
     return 0;
 }
 
     return 0;
 }
 

-int qemu_chr_wait_connected(CharDriverState *chr, Error **errp)
+static int qemu_chr_wait_connected(CharDriverState *chr, Error **errp)

 {
     if (chr->chr_wait_connected) {
         return chr->chr_wait_connected(chr, errp);
 {
     if (chr->chr_wait_connected) {
         return chr->chr_wait_connected(chr, errp);


@@ -3250,7 +3451,17 @@ int qemu_chr_wait_connected(CharDriverState *chr, Error **errp)
     return 0;
 }
 
     return 0;
 }
 

-static void tcp_chr_close(CharDriverState *chr)
+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);
+}
+
+static void tcp_chr_free(CharDriverState *chr)

 {
     TCPCharDriver *s = chr->opaque;
 
 {
     TCPCharDriver *s = chr->opaque;
 


@@ -3345,7 +3556,7 @@ static int ringbuf_chr_read(CharDriverState *chr, uint8_t *buf, int len)
     return i;
 }
 
     return i;
 }
 

-static void ringbuf_chr_close(struct CharDriverState *chr)
+static void ringbuf_chr_free(struct CharDriverState *chr)

 {
     RingBufCharDriver *d = chr->opaque;
 
 {
     RingBufCharDriver *d = chr->opaque;
 


@@ -3357,6 +3568,7 @@ static void ringbuf_chr_close(struct CharDriverState *chr)
 static CharDriverState *qemu_chr_open_ringbuf(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,
 static CharDriverState *qemu_chr_open_ringbuf(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,

+                                              bool *be_opened,

                                               Error **errp)
 {
     ChardevRingbuf *opts = backend->u.ringbuf.data;
                                               Error **errp)
 {
     ChardevRingbuf *opts = backend->u.ringbuf.data;


@@ -3384,7 +3596,7 @@ static CharDriverState *qemu_chr_open_ringbuf(const char *id,
 
     chr->opaque = d;
     chr->chr_write = ringbuf_chr_write;
 
     chr->opaque = d;
     chr->chr_write = ringbuf_chr_write;

-    chr->chr_close = ringbuf_chr_close;
+    chr->chr_free = ringbuf_chr_free;

 
     return chr;
 
 
     return chr;
 


@@ -3885,17 +4097,14 @@ static void qemu_chr_parse_udp(QemuOpts *opts, ChardevBackend *backend,
 typedef struct CharDriver {
     const char *name;
     ChardevBackendKind kind;
 typedef struct CharDriver {
     const char *name;
     ChardevBackendKind kind;

-    void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp);
-    CharDriverState *(*create)(const char *id, ChardevBackend *backend,
-                               ChardevReturn *ret, Error **errp);
+    CharDriverParse *parse;
+    CharDriverCreate *create;

 } CharDriver;
 
 static GSList *backends;
 
 void register_char_driver(const char *name, ChardevBackendKind kind,
 } CharDriver;
 
 static GSList *backends;
 
 void register_char_driver(const char *name, ChardevBackendKind kind,

-        void (*parse)(QemuOpts *opts, ChardevBackend *backend, Error **errp),
-        CharDriverState *(*create)(const char *id, ChardevBackend *backend,
-                                   ChardevReturn *ret, Error **errp))
+                          CharDriverParse *parse, CharDriverCreate *create)

 {
     CharDriver *s;
 
 {
     CharDriver *s;
 


@@ -3909,8 +4118,7 @@ void register_char_driver(const char *name, ChardevBackendKind kind,
 }
 
 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,
 }
 
 CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts,

-                                    void (*init)(struct CharDriverState *s),
-                                    Error **errp)
+                                        Error **errp)

 {
     Error *local_err = NULL;
     CharDriver *cd;
 {
     Error *local_err = NULL;
     CharDriver *cd;


@@ -4007,8 +4215,7 @@ err:
     return NULL;
 }
 
     return NULL;
 }
 

-CharDriverState *qemu_chr_new_noreplay(const char *label, const char *filename,
-                                       void (*init)(struct CharDriverState *s))
+CharDriverState *qemu_chr_new_noreplay(const char *label, const char *filename)

 {
     const char *p;
     CharDriverState *chr;
 {
     const char *p;
     CharDriverState *chr;


@@ -4023,22 +4230,21 @@ CharDriverState *qemu_chr_new_noreplay(const char *label, const char *filename,
     if (!opts)
         return NULL;
 
     if (!opts)
         return NULL;
 

-    chr = qemu_chr_new_from_opts(opts, init, &err);
+    chr = qemu_chr_new_from_opts(opts, &err);

     if (err) {
         error_report_err(err);
     }
     if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
     if (err) {
         error_report_err(err);
     }
     if (chr && qemu_opt_get_bool(opts, "mux", 0)) {

-        qemu_chr_fe_claim_no_fail(chr);

         monitor_init(chr, MONITOR_USE_READLINE);
     }
     qemu_opts_del(opts);
     return chr;
 }
 
         monitor_init(chr, MONITOR_USE_READLINE);
     }
     qemu_opts_del(opts);
     return chr;
 }
 

-CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*init)(struct CharDriverState *s))
+CharDriverState *qemu_chr_new(const char *label, const char *filename)

 {
     CharDriverState *chr;
 {
     CharDriverState *chr;

-    chr = qemu_chr_new_noreplay(label, filename, init);
+    chr = qemu_chr_new_noreplay(label, filename);

     if (chr) {
         chr->replay = replay_mode != REPLAY_MODE_NONE;
         if (chr->replay && chr->chr_ioctl) {
     if (chr) {
         chr->replay = replay_mode != REPLAY_MODE_NONE;
         if (chr->replay && chr->chr_ioctl) {


@@ -4050,38 +4256,40 @@ CharDriverState *qemu_chr_new(const char *label, const char *filename, void (*in
     return chr;
 }
 
     return chr;
 }
 

-void qemu_chr_fe_set_echo(struct CharDriverState *chr, bool echo)
+void qemu_chr_fe_set_echo(CharBackend *be, bool echo)

 {
 {

-    if (chr->chr_set_echo) {
+    CharDriverState *chr = be->chr;
+
+    if (chr && chr->chr_set_echo) {

         chr->chr_set_echo(chr, echo);
     }
 }
 
         chr->chr_set_echo(chr, echo);
     }
 }
 

-void qemu_chr_fe_set_open(struct CharDriverState *chr, int fe_open)
+void qemu_chr_fe_set_open(CharBackend *be, int fe_open)

 {
 {

-    if (chr->fe_open == fe_open) {
+    CharDriverState *chr = be->chr;
+
+    if (!chr) {
+        return;
+    }
+
+    if (be->fe_open == fe_open) {

         return;
     }
         return;
     }

-    chr->fe_open = fe_open;
+    be->fe_open = fe_open;

     if (chr->chr_set_fe_open) {
         chr->chr_set_fe_open(chr, fe_open);
     }
 }
 
     if (chr->chr_set_fe_open) {
         chr->chr_set_fe_open(chr, fe_open);
     }
 }
 

-void qemu_chr_fe_event(struct CharDriverState *chr, int event)
-{
-    if (chr->chr_fe_event) {
-        chr->chr_fe_event(chr, event);
-    }
-}
-
-guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
+guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,

                             GIOFunc func, void *user_data)
 {
                             GIOFunc func, void *user_data)
 {

+    CharDriverState *s = be->chr;

     GSource *src;
     guint tag;
 
     GSource *src;
     guint tag;
 

-    if (s->chr_add_watch == NULL) {
+    if (!s || s->chr_add_watch == NULL) {

         return 0;
     }
 
         return 0;
     }
 


@@ -4097,38 +4305,20 @@ guint qemu_chr_fe_add_watch(CharDriverState *s, GIOCondition cond,
     return tag;
 }
 
     return tag;
 }
 

-int qemu_chr_fe_claim(CharDriverState *s)
-{
-    if (s->avail_connections < 1) {
-        return -1;
-    }
-    s->avail_connections--;
-    return 0;
-}
-
-void qemu_chr_fe_claim_no_fail(CharDriverState *s)
-{
-    if (qemu_chr_fe_claim(s) != 0) {
-        fprintf(stderr, "%s: error chardev \"%s\" already used\n",
-                __func__, s->label);
-        exit(1);
-    }
-}
-
-void qemu_chr_fe_release(CharDriverState *s)
+void qemu_chr_fe_disconnect(CharBackend *be)

 {
 {

-    s->avail_connections++;
-}
+    CharDriverState *chr = be->chr;

 
 

-void qemu_chr_disconnect(CharDriverState *chr)
-{
-    if (chr->chr_disconnect) {
+    if (chr && chr->chr_disconnect) {

         chr->chr_disconnect(chr);
     }
 }
 
 static void qemu_chr_free_common(CharDriverState *chr)
 {
         chr->chr_disconnect(chr);
     }
 }
 
 static void qemu_chr_free_common(CharDriverState *chr)
 {

+    if (chr->be) {
+        chr->be->chr = NULL;
+    }

     g_free(chr->filename);
     g_free(chr->label);
     if (chr->logfd != -1) {
     g_free(chr->filename);
     g_free(chr->label);
     if (chr->logfd != -1) {


@@ -4140,8 +4330,8 @@ static void qemu_chr_free_common(CharDriverState *chr)
 
 void qemu_chr_free(CharDriverState *chr)
 {
 
 void qemu_chr_free(CharDriverState *chr)
 {

-    if (chr->chr_close) {
-        chr->chr_close(chr);
+    if (chr->chr_free) {
+        chr->chr_free(chr);

     }
     qemu_chr_free_common(chr);
 }
     }
     qemu_chr_free_common(chr);
 }


@@ -4162,7 +4352,7 @@ ChardevInfoList *qmp_query_chardev(Error **errp)
         info->value = g_malloc0(sizeof(*info->value));
         info->value->label = g_strdup(chr->label);
         info->value->filename = g_strdup(chr->filename);
         info->value = g_malloc0(sizeof(*info->value));
         info->value->label = g_strdup(chr->label);
         info->value->filename = g_strdup(chr->filename);

-        info->value->frontend_open = chr->fe_open;
+        info->value->frontend_open = chr->be && chr->be->fe_open;

 
         info->next = chr_list;
         chr_list = info;
 
         info->next = chr_list;
         chr_list = info;


@@ -4301,6 +4491,7 @@ QemuOptsList qemu_chardev_opts = {
 static CharDriverState *qmp_chardev_open_file(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_file(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,

+                                              bool *be_opened,

                                               Error **errp)
 {
     ChardevFile *file = backend->u.file.data;
                                               Error **errp)
 {
     ChardevFile *file = backend->u.file.data;


@@ -4336,6 +4527,7 @@ static CharDriverState *qmp_chardev_open_file(const char *id,
 static CharDriverState *qmp_chardev_open_serial(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_serial(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,

+                                                bool *be_opened,

                                                 Error **errp)
 {
     ChardevHostdev *serial = backend->u.serial.data;
                                                 Error **errp)
 {
     ChardevHostdev *serial = backend->u.serial.data;


@@ -4360,6 +4552,7 @@ static int qmp_chardev_open_file_source(char *src, int flags,
 static CharDriverState *qmp_chardev_open_file(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_file(const char *id,
                                               ChardevBackend *backend,
                                               ChardevReturn *ret,

+                                              bool *be_opened,

                                               Error **errp)
 {
     ChardevFile *file = backend->u.file.data;
                                               Error **errp)
 {
     ChardevFile *file = backend->u.file.data;


@@ -4394,6 +4587,7 @@ static CharDriverState *qmp_chardev_open_file(const char *id,
 static CharDriverState *qmp_chardev_open_serial(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_serial(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,

+                                                bool *be_opened,

                                                 Error **errp)
 {
     ChardevHostdev *serial = backend->u.serial.data;
                                                 Error **errp)
 {
     ChardevHostdev *serial = backend->u.serial.data;


@@ -4405,7 +4599,7 @@ static CharDriverState *qmp_chardev_open_serial(const char *id,
         return NULL;
     }
     qemu_set_nonblock(fd);
         return NULL;
     }
     qemu_set_nonblock(fd);

-    return qemu_chr_open_tty_fd(fd, common, errp);
+    return qemu_chr_open_tty_fd(fd, common, be_opened, errp);

 }
 #endif
 
 }
 #endif
 


@@ -4413,6 +4607,7 @@ static CharDriverState *qmp_chardev_open_serial(const char *id,
 static CharDriverState *qmp_chardev_open_parallel(const char *id,
                                                   ChardevBackend *backend,
                                                   ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_parallel(const char *id,
                                                   ChardevBackend *backend,
                                                   ChardevReturn *ret,

+                                                  bool *be_opened,

                                                   Error **errp)
 {
     ChardevHostdev *parallel = backend->u.parallel.data;
                                                   Error **errp)
 {
     ChardevHostdev *parallel = backend->u.parallel.data;


@@ -4423,7 +4618,7 @@ static CharDriverState *qmp_chardev_open_parallel(const char *id,
     if (fd < 0) {
         return NULL;
     }
     if (fd < 0) {
         return NULL;
     }

-    return qemu_chr_open_pp_fd(fd, common, errp);
+    return qemu_chr_open_pp_fd(fd, common, be_opened, errp);

 }
 #endif
 
 }
 #endif
 


@@ -4442,6 +4637,7 @@ static gboolean socket_reconnect_timeout(gpointer opaque)
     }
 
     sioc = qio_channel_socket_new();
     }
 
     sioc = qio_channel_socket_new();

+    tcp_chr_set_client_ioc_name(chr, sioc);

     qio_channel_socket_connect_async(sioc, s->addr,
                                      qemu_chr_socket_connected,
                                      chr, NULL);
     qio_channel_socket_connect_async(sioc, s->addr,
                                      qemu_chr_socket_connected,
                                      chr, NULL);


@@ -4452,6 +4648,7 @@ static gboolean socket_reconnect_timeout(gpointer opaque)
 static CharDriverState *qmp_chardev_open_socket(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_socket(const char *id,
                                                 ChardevBackend *backend,
                                                 ChardevReturn *ret,

+                                                bool *be_opened,

                                                 Error **errp)
 {
     CharDriverState *chr;
                                                 Error **errp)
 {
     CharDriverState *chr;


@@ -4520,7 +4717,7 @@ static CharDriverState *qmp_chardev_open_socket(const char *id,
     chr->chr_wait_connected = tcp_chr_wait_connected;
     chr->chr_write = tcp_chr_write;
     chr->chr_sync_read = tcp_chr_sync_read;
     chr->chr_wait_connected = tcp_chr_wait_connected;
     chr->chr_write = tcp_chr_write;
     chr->chr_sync_read = tcp_chr_sync_read;

-    chr->chr_close = tcp_chr_close;
+    chr->chr_free = tcp_chr_free;

     chr->chr_disconnect = tcp_chr_disconnect;
     chr->get_msgfds = tcp_get_msgfds;
     chr->set_msgfds = tcp_set_msgfds;
     chr->chr_disconnect = tcp_chr_disconnect;
     chr->get_msgfds = tcp_get_msgfds;
     chr->set_msgfds = tcp_set_msgfds;


@@ -4528,7 +4725,7 @@ static CharDriverState *qmp_chardev_open_socket(const char *id,
     chr->chr_add_watch = tcp_chr_add_watch;
     chr->chr_update_read_handler = tcp_chr_update_read_handler;
     /* be isn't opened until we get a connection */
     chr->chr_add_watch = tcp_chr_add_watch;
     chr->chr_update_read_handler = tcp_chr_update_read_handler;
     /* be isn't opened until we get a connection */

-    chr->explicit_be_open = true;
+    *be_opened = false;

 
     chr->filename = SocketAddress_to_str("disconnected:",
                                          addr, is_listen, is_telnet);
 
     chr->filename = SocketAddress_to_str("disconnected:",
                                          addr, is_listen, is_telnet);


@@ -4543,12 +4740,19 @@ static CharDriverState *qmp_chardev_open_socket(const char *id,
 
     if (s->reconnect_time) {
         sioc = qio_channel_socket_new();
 
     if (s->reconnect_time) {
         sioc = qio_channel_socket_new();

+        tcp_chr_set_client_ioc_name(chr, sioc);

         qio_channel_socket_connect_async(sioc, s->addr,
                                          qemu_chr_socket_connected,
                                          chr, NULL);
     } else {
         if (s->is_listen) {
         qio_channel_socket_connect_async(sioc, s->addr,
                                          qemu_chr_socket_connected,
                                          chr, NULL);
     } else {
         if (s->is_listen) {

+            char *name;

             sioc = qio_channel_socket_new();
             sioc = qio_channel_socket_new();

+
+            name = g_strdup_printf("chardev-tcp-listener-%s", chr->label);
+            qio_channel_set_name(QIO_CHANNEL(sioc), name);
+            g_free(name);
+

             if (qio_channel_socket_listen_sync(sioc, s->addr, errp) < 0) {
                 goto error;
             }
             if (qio_channel_socket_listen_sync(sioc, s->addr, errp) < 0) {
                 goto error;
             }


@@ -4584,11 +4788,14 @@ static CharDriverState *qmp_chardev_open_socket(const char *id,
 static CharDriverState *qmp_chardev_open_udp(const char *id,
                                              ChardevBackend *backend,
                                              ChardevReturn *ret,
 static CharDriverState *qmp_chardev_open_udp(const char *id,
                                              ChardevBackend *backend,
                                              ChardevReturn *ret,

+                                             bool *be_opened,

                                              Error **errp)
 {
     ChardevUdp *udp = backend->u.udp.data;
     ChardevCommon *common = qapi_ChardevUdp_base(udp);
     QIOChannelSocket *sioc = qio_channel_socket_new();
                                              Error **errp)
 {
     ChardevUdp *udp = backend->u.udp.data;
     ChardevCommon *common = qapi_ChardevUdp_base(udp);
     QIOChannelSocket *sioc = qio_channel_socket_new();

+    char *name;
+    CharDriverState *chr;

 
     if (qio_channel_socket_dgram_sync(sioc,
                                       udp->local, udp->remote,
 
     if (qio_channel_socket_dgram_sync(sioc,
                                       udp->local, udp->remote,


@@ -4596,7 +4803,13 @@ static CharDriverState *qmp_chardev_open_udp(const char *id,
         object_unref(OBJECT(sioc));
         return NULL;
     }
         object_unref(OBJECT(sioc));
         return NULL;
     }

-    return qemu_chr_open_udp(sioc, common, errp);
+    chr = qemu_chr_open_udp(sioc, common, be_opened, errp);
+
+    name = g_strdup_printf("chardev-udp-%s", chr->label);
+    qio_channel_set_name(QIO_CHANNEL(sioc), name);
+    g_free(name);
+
+    return chr;

 }
 
 
 }
 
 


@@ -4620,19 +4833,19 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
     Error *local_err = NULL;
     GSList *i;
     CharDriver *cd;
     Error *local_err = NULL;
     GSList *i;
     CharDriver *cd;

+    bool be_opened = true;

 
     chr = qemu_chr_find(id);
     if (chr) {
         error_setg(errp, "Chardev '%s' already exists", id);
 
     chr = qemu_chr_find(id);
     if (chr) {
         error_setg(errp, "Chardev '%s' already exists", id);

-        g_free(ret);
-        return NULL;
+        goto out_error;

     }
 
     for (i = backends; i; i = i->next) {
         cd = i->data;
 
         if (cd->kind == backend->type) {
     }
 
     for (i = backends; i; i = i->next) {
         cd = i->data;
 
         if (cd->kind == backend->type) {

-            chr = cd->create(id, backend, ret, &local_err);
+            chr = cd->create(id, backend, ret, &be_opened, &local_err);

             if (local_err) {
                 error_propagate(errp, local_err);
                 goto out_error;
             if (local_err) {
                 error_propagate(errp, local_err);
                 goto out_error;


@@ -4648,12 +4861,10 @@ ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
     }
 
     chr->label = g_strdup(id);
     }
 
     chr->label = g_strdup(id);

-    chr->avail_connections =
-        (backend->type == CHARDEV_BACKEND_KIND_MUX) ? MAX_MUX : 1;

     if (!chr->filename) {
         chr->filename = g_strdup(ChardevBackendKind_lookup[backend->type]);
     }
     if (!chr->filename) {
         chr->filename = g_strdup(ChardevBackendKind_lookup[backend->type]);
     }

-    if (!chr->explicit_be_open) {
+    if (be_opened) {

         qemu_chr_be_event(chr, CHR_EVENT_OPENED);
     }
     QTAILQ_INSERT_TAIL(&chardevs, chr, next);
         qemu_chr_be_event(chr, CHR_EVENT_OPENED);
     }
     QTAILQ_INSERT_TAIL(&chardevs, chr, next);


@@ -4673,8 +4884,7 @@ void qmp_chardev_remove(const char *id, Error **errp)
         error_setg(errp, "Chardev '%s' not found", id);
         return;
     }
         error_setg(errp, "Chardev '%s' not found", id);
         return;
     }

-    if (chr->chr_can_read || chr->chr_read ||
-        chr->chr_event || chr->handler_opaque) {
+    if (qemu_chr_is_busy(chr)) {

         error_setg(errp, "Chardev '%s' is busy", id);
         return;
     }
         error_setg(errp, "Chardev '%s' is busy", id);
         return;
     }