4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 #include "qemu/osdep.h"
25 #include "qemu-common.h"
26 #include "monitor/monitor.h"
27 #include "sysemu/sysemu.h"
28 #include "qemu/error-report.h"
29 #include "qemu/timer.h"
30 #include "sysemu/char.h"
32 #include "qmp-commands.h"
33 #include "qapi/qmp-input-visitor.h"
34 #include "qapi/qmp-output-visitor.h"
35 #include "qapi-visit.h"
36 #include "qemu/base64.h"
37 #include "io/channel-socket.h"
38 #include "io/channel-file.h"
39 #include "io/channel-tls.h"
40 #include "sysemu/replay.h"
45 #include <sys/times.h>
49 #include <sys/ioctl.h>
50 #include <sys/resource.h>
51 #include <sys/socket.h>
52 #include <netinet/in.h>
54 #include <arpa/inet.h>
56 #include <sys/select.h>
58 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
59 #include <dev/ppbus/ppi.h>
60 #include <dev/ppbus/ppbconf.h>
61 #elif defined(__DragonFly__)
62 #include <dev/misc/ppi/ppi.h>
63 #include <bus/ppbus/ppbconf.h>
67 #include <linux/ppdev.h>
68 #include <linux/parport.h>
71 #include <sys/ethernet.h>
72 #include <sys/sockio.h>
73 #include <netinet/arp.h>
74 #include <netinet/in.h>
75 #include <netinet/in_systm.h>
76 #include <netinet/ip.h>
77 #include <netinet/ip_icmp.h> // must come after ip.h
78 #include <netinet/udp.h>
79 #include <netinet/tcp.h>
84 #include "qemu/sockets.h"
85 #include "ui/qemu-spice.h"
87 #define READ_BUF_LEN 4096
88 #define READ_RETRIES 10
89 #define TCP_MAX_FDS 16
91 /***********************************************************/
92 /* Socket address helpers */
94 static char *SocketAddress_to_str(const char *prefix
, SocketAddress
*addr
,
95 bool is_listen
, bool is_telnet
)
98 case SOCKET_ADDRESS_KIND_INET
:
99 return g_strdup_printf("%s%s:%s:%s%s", prefix
,
100 is_telnet
? "telnet" : "tcp", addr
->u
.inet
->host
,
101 addr
->u
.inet
->port
, is_listen
? ",server" : "");
103 case SOCKET_ADDRESS_KIND_UNIX
:
104 return g_strdup_printf("%sunix:%s%s", prefix
,
105 addr
->u
.q_unix
->path
,
106 is_listen
? ",server" : "");
108 case SOCKET_ADDRESS_KIND_FD
:
109 return g_strdup_printf("%sfd:%s%s", prefix
, addr
->u
.fd
->str
,
110 is_listen
? ",server" : "");
117 static char *sockaddr_to_str(struct sockaddr_storage
*ss
, socklen_t ss_len
,
118 struct sockaddr_storage
*ps
, socklen_t ps_len
,
119 bool is_listen
, bool is_telnet
)
121 char shost
[NI_MAXHOST
], sserv
[NI_MAXSERV
];
122 char phost
[NI_MAXHOST
], pserv
[NI_MAXSERV
];
123 const char *left
= "", *right
= "";
125 switch (ss
->ss_family
) {
128 return g_strdup_printf("unix:%s%s",
129 ((struct sockaddr_un
*)(ss
))->sun_path
,
130 is_listen
? ",server" : "");
137 getnameinfo((struct sockaddr
*) ss
, ss_len
, shost
, sizeof(shost
),
138 sserv
, sizeof(sserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
139 getnameinfo((struct sockaddr
*) ps
, ps_len
, phost
, sizeof(phost
),
140 pserv
, sizeof(pserv
), NI_NUMERICHOST
| NI_NUMERICSERV
);
141 return g_strdup_printf("%s:%s%s%s:%s%s <-> %s%s%s:%s",
142 is_telnet
? "telnet" : "tcp",
143 left
, shost
, right
, sserv
,
144 is_listen
? ",server" : "",
145 left
, phost
, right
, pserv
);
148 return g_strdup_printf("unknown");
152 /***********************************************************/
153 /* character device */
155 static QTAILQ_HEAD(CharDriverStateHead
, CharDriverState
) chardevs
=
156 QTAILQ_HEAD_INITIALIZER(chardevs
);
158 static void qemu_chr_free_common(CharDriverState
*chr
);
160 CharDriverState
*qemu_chr_alloc(ChardevCommon
*backend
, Error
**errp
)
162 CharDriverState
*chr
= g_malloc0(sizeof(CharDriverState
));
163 qemu_mutex_init(&chr
->chr_write_lock
);
165 if (backend
->has_logfile
) {
166 int flags
= O_WRONLY
| O_CREAT
;
167 if (backend
->has_logappend
&&
168 backend
->logappend
) {
173 chr
->logfd
= qemu_open(backend
->logfile
, flags
, 0666);
174 if (chr
->logfd
< 0) {
175 error_setg_errno(errp
, errno
,
176 "Unable to open logfile %s",
188 void qemu_chr_be_event(CharDriverState
*s
, int event
)
190 /* Keep track if the char device is open */
192 case CHR_EVENT_OPENED
:
195 case CHR_EVENT_CLOSED
:
202 s
->chr_event(s
->handler_opaque
, event
);
205 void qemu_chr_be_generic_open(CharDriverState
*s
)
207 qemu_chr_be_event(s
, CHR_EVENT_OPENED
);
211 /* Not reporting errors from writing to logfile, as logs are
212 * defined to be "best effort" only */
213 static void qemu_chr_fe_write_log(CharDriverState
*s
,
214 const uint8_t *buf
, size_t len
)
225 ret
= write(s
->logfd
, buf
+ done
, len
- done
);
226 if (ret
== -1 && errno
== EAGAIN
) {
229 } while (ret
== -1 && errno
== EAGAIN
);
238 static int qemu_chr_fe_write_buffer(CharDriverState
*s
, const uint8_t *buf
, int len
, int *offset
)
243 qemu_mutex_lock(&s
->chr_write_lock
);
244 while (*offset
< len
) {
246 res
= s
->chr_write(s
, buf
+ *offset
, len
- *offset
);
247 if (res
== -1 && errno
== EAGAIN
) {
250 } while (res
== -1 && errno
== EAGAIN
);
259 qemu_chr_fe_write_log(s
, buf
, *offset
);
261 qemu_mutex_unlock(&s
->chr_write_lock
);
266 int qemu_chr_fe_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
270 if (s
->replay
&& replay_mode
== REPLAY_MODE_PLAY
) {
272 replay_char_write_event_load(&ret
, &offset
);
273 assert(offset
<= len
);
274 qemu_chr_fe_write_buffer(s
, buf
, offset
, &offset
);
278 qemu_mutex_lock(&s
->chr_write_lock
);
279 ret
= s
->chr_write(s
, buf
, len
);
282 qemu_chr_fe_write_log(s
, buf
, ret
);
285 qemu_mutex_unlock(&s
->chr_write_lock
);
287 if (s
->replay
&& replay_mode
== REPLAY_MODE_RECORD
) {
288 replay_char_write_event_save(ret
, ret
< 0 ? 0 : ret
);
294 int qemu_chr_fe_write_all(CharDriverState
*s
, const uint8_t *buf
, int len
)
299 if (s
->replay
&& replay_mode
== REPLAY_MODE_PLAY
) {
300 replay_char_write_event_load(&res
, &offset
);
301 assert(offset
<= len
);
302 qemu_chr_fe_write_buffer(s
, buf
, offset
, &offset
);
306 res
= qemu_chr_fe_write_buffer(s
, buf
, len
, &offset
);
308 if (s
->replay
&& replay_mode
== REPLAY_MODE_RECORD
) {
309 replay_char_write_event_save(res
, offset
);
318 int qemu_chr_fe_read_all(CharDriverState
*s
, uint8_t *buf
, int len
)
320 int offset
= 0, counter
= 10;
323 if (!s
->chr_sync_read
) {
327 if (s
->replay
&& replay_mode
== REPLAY_MODE_PLAY
) {
328 return replay_char_read_all_load(buf
);
331 while (offset
< len
) {
333 res
= s
->chr_sync_read(s
, buf
+ offset
, len
- offset
);
334 if (res
== -1 && errno
== EAGAIN
) {
337 } while (res
== -1 && errno
== EAGAIN
);
344 if (s
->replay
&& replay_mode
== REPLAY_MODE_RECORD
) {
345 replay_char_read_all_save_error(res
);
357 if (s
->replay
&& replay_mode
== REPLAY_MODE_RECORD
) {
358 replay_char_read_all_save_buf(buf
, offset
);
363 int qemu_chr_fe_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
366 if (!s
->chr_ioctl
|| s
->replay
) {
369 res
= s
->chr_ioctl(s
, cmd
, arg
);
375 int qemu_chr_be_can_write(CharDriverState
*s
)
377 if (!s
->chr_can_read
)
379 return s
->chr_can_read(s
->handler_opaque
);
382 void qemu_chr_be_write_impl(CharDriverState
*s
, uint8_t *buf
, int len
)
385 s
->chr_read(s
->handler_opaque
, buf
, len
);
389 void qemu_chr_be_write(CharDriverState
*s
, uint8_t *buf
, int len
)
392 if (replay_mode
== REPLAY_MODE_PLAY
) {
395 replay_chr_be_write(s
, buf
, len
);
397 qemu_chr_be_write_impl(s
, buf
, len
);
401 int qemu_chr_fe_get_msgfd(CharDriverState
*s
)
404 int res
= (qemu_chr_fe_get_msgfds(s
, &fd
, 1) == 1) ? fd
: -1;
407 "Replay: get msgfd is not supported for serial devices yet\n");
413 int qemu_chr_fe_get_msgfds(CharDriverState
*s
, int *fds
, int len
)
415 return s
->get_msgfds
? s
->get_msgfds(s
, fds
, len
) : -1;
418 int qemu_chr_fe_set_msgfds(CharDriverState
*s
, int *fds
, int num
)
420 return s
->set_msgfds
? s
->set_msgfds(s
, fds
, num
) : -1;
423 int qemu_chr_add_client(CharDriverState
*s
, int fd
)
425 return s
->chr_add_client
? s
->chr_add_client(s
, fd
) : -1;
428 void qemu_chr_accept_input(CharDriverState
*s
)
430 if (s
->chr_accept_input
)
431 s
->chr_accept_input(s
);
435 void qemu_chr_fe_printf(CharDriverState
*s
, const char *fmt
, ...)
437 char buf
[READ_BUF_LEN
];
440 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
441 qemu_chr_fe_write(s
, (uint8_t *)buf
, strlen(buf
));
445 static void remove_fd_in_watch(CharDriverState
*chr
);
447 void qemu_chr_add_handlers(CharDriverState
*s
,
448 IOCanReadHandler
*fd_can_read
,
449 IOReadHandler
*fd_read
,
450 IOEventHandler
*fd_event
,
455 if (!opaque
&& !fd_can_read
&& !fd_read
&& !fd_event
) {
457 remove_fd_in_watch(s
);
461 s
->chr_can_read
= fd_can_read
;
462 s
->chr_read
= fd_read
;
463 s
->chr_event
= fd_event
;
464 s
->handler_opaque
= opaque
;
465 if (fe_open
&& s
->chr_update_read_handler
)
466 s
->chr_update_read_handler(s
);
468 if (!s
->explicit_fe_open
) {
469 qemu_chr_fe_set_open(s
, fe_open
);
472 /* We're connecting to an already opened device, so let's make sure we
473 also get the open event */
474 if (fe_open
&& s
->be_open
) {
475 qemu_chr_be_generic_open(s
);
479 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
484 static CharDriverState
*qemu_chr_open_null(const char *id
,
485 ChardevBackend
*backend
,
489 CharDriverState
*chr
;
490 ChardevCommon
*common
= backend
->u
.null
;
492 chr
= qemu_chr_alloc(common
, errp
);
496 chr
->chr_write
= null_chr_write
;
497 chr
->explicit_be_open
= true;
501 /* MUX driver for serial I/O splitting */
503 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
504 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
506 IOCanReadHandler
*chr_can_read
[MAX_MUX
];
507 IOReadHandler
*chr_read
[MAX_MUX
];
508 IOEventHandler
*chr_event
[MAX_MUX
];
509 void *ext_opaque
[MAX_MUX
];
510 CharDriverState
*drv
;
515 /* Intermediate input buffer allows to catch escape sequences even if the
516 currently active device is not accepting any input - but only until it
518 unsigned char buffer
[MAX_MUX
][MUX_BUFFER_SIZE
];
523 /* Protected by the CharDriverState chr_write_lock. */
525 int64_t timestamps_start
;
529 /* Called with chr_write_lock held. */
530 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
532 MuxDriver
*d
= chr
->opaque
;
534 if (!d
->timestamps
) {
535 ret
= qemu_chr_fe_write(d
->drv
, buf
, len
);
540 for (i
= 0; i
< len
; i
++) {
546 ti
= qemu_clock_get_ms(QEMU_CLOCK_REALTIME
);
547 if (d
->timestamps_start
== -1)
548 d
->timestamps_start
= ti
;
549 ti
-= d
->timestamps_start
;
551 snprintf(buf1
, sizeof(buf1
),
552 "[%02d:%02d:%02d.%03d] ",
557 qemu_chr_fe_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
560 ret
+= qemu_chr_fe_write(d
->drv
, buf
+i
, 1);
561 if (buf
[i
] == '\n') {
569 static const char * const mux_help
[] = {
570 "% h print this help\n\r",
571 "% x exit emulator\n\r",
572 "% s save disk data back to file (if -snapshot)\n\r",
573 "% t toggle console timestamps\n\r",
574 "% b send break (magic sysrq)\n\r",
575 "% c switch between console and monitor\n\r",
580 int term_escape_char
= 0x01; /* ctrl-a is used for escape */
581 static void mux_print_help(CharDriverState
*chr
)
584 char ebuf
[15] = "Escape-Char";
585 char cbuf
[50] = "\n\r";
587 if (term_escape_char
> 0 && term_escape_char
< 26) {
588 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
589 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
591 snprintf(cbuf
, sizeof(cbuf
),
592 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
595 qemu_chr_fe_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
596 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
597 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
598 if (mux_help
[i
][j
] == '%')
599 qemu_chr_fe_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
601 qemu_chr_fe_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
606 static void mux_chr_send_event(MuxDriver
*d
, int mux_nr
, int event
)
608 if (d
->chr_event
[mux_nr
])
609 d
->chr_event
[mux_nr
](d
->ext_opaque
[mux_nr
], event
);
612 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
614 if (d
->term_got_escape
) {
615 d
->term_got_escape
= 0;
616 if (ch
== term_escape_char
)
625 const char *term
= "QEMU: Terminated\n\r";
626 qemu_chr_fe_write(chr
, (uint8_t *)term
, strlen(term
));
634 qemu_chr_be_event(chr
, CHR_EVENT_BREAK
);
637 /* Switch to the next registered device */
638 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_OUT
);
640 if (d
->focus
>= d
->mux_cnt
)
642 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_IN
);
645 d
->timestamps
= !d
->timestamps
;
646 d
->timestamps_start
= -1;
650 } else if (ch
== term_escape_char
) {
651 d
->term_got_escape
= 1;
659 static void mux_chr_accept_input(CharDriverState
*chr
)
661 MuxDriver
*d
= chr
->opaque
;
664 while (d
->prod
[m
] != d
->cons
[m
] &&
665 d
->chr_can_read
[m
] &&
666 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
667 d
->chr_read
[m
](d
->ext_opaque
[m
],
668 &d
->buffer
[m
][d
->cons
[m
]++ & MUX_BUFFER_MASK
], 1);
672 static int mux_chr_can_read(void *opaque
)
674 CharDriverState
*chr
= opaque
;
675 MuxDriver
*d
= chr
->opaque
;
678 if ((d
->prod
[m
] - d
->cons
[m
]) < MUX_BUFFER_SIZE
)
680 if (d
->chr_can_read
[m
])
681 return d
->chr_can_read
[m
](d
->ext_opaque
[m
]);
685 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
687 CharDriverState
*chr
= opaque
;
688 MuxDriver
*d
= chr
->opaque
;
692 mux_chr_accept_input (opaque
);
694 for(i
= 0; i
< size
; i
++)
695 if (mux_proc_byte(chr
, d
, buf
[i
])) {
696 if (d
->prod
[m
] == d
->cons
[m
] &&
697 d
->chr_can_read
[m
] &&
698 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
699 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
701 d
->buffer
[m
][d
->prod
[m
]++ & MUX_BUFFER_MASK
] = buf
[i
];
705 static void mux_chr_event(void *opaque
, int event
)
707 CharDriverState
*chr
= opaque
;
708 MuxDriver
*d
= chr
->opaque
;
711 /* Send the event to all registered listeners */
712 for (i
= 0; i
< d
->mux_cnt
; i
++)
713 mux_chr_send_event(d
, i
, event
);
716 static void mux_chr_update_read_handler(CharDriverState
*chr
)
718 MuxDriver
*d
= chr
->opaque
;
720 if (d
->mux_cnt
>= MAX_MUX
) {
721 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
724 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
725 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
726 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
727 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
728 /* Fix up the real driver with mux routines */
729 if (d
->mux_cnt
== 0) {
730 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
733 if (d
->focus
!= -1) {
734 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_OUT
);
736 d
->focus
= d
->mux_cnt
;
738 mux_chr_send_event(d
, d
->focus
, CHR_EVENT_MUX_IN
);
741 static bool muxes_realized
;
744 * Called after processing of default and command-line-specified
745 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
746 * to a mux chardev. This is done here to ensure that
747 * output/prompts/banners are only displayed for the FE that has
748 * focus when initial command-line processing/machine init is
751 * After this point, any new FE attached to any new or existing
752 * mux will receive CHR_EVENT_OPENED notifications for the BE
755 static void muxes_realize_done(Notifier
*notifier
, void *unused
)
757 CharDriverState
*chr
;
759 QTAILQ_FOREACH(chr
, &chardevs
, next
) {
761 MuxDriver
*d
= chr
->opaque
;
764 /* send OPENED to all already-attached FEs */
765 for (i
= 0; i
< d
->mux_cnt
; i
++) {
766 mux_chr_send_event(d
, i
, CHR_EVENT_OPENED
);
768 /* mark mux as OPENED so any new FEs will immediately receive
771 qemu_chr_be_generic_open(chr
);
774 muxes_realized
= true;
777 static Notifier muxes_realize_notify
= {
778 .notify
= muxes_realize_done
,
781 static GSource
*mux_chr_add_watch(CharDriverState
*s
, GIOCondition cond
)
783 MuxDriver
*d
= s
->opaque
;
784 return d
->drv
->chr_add_watch(d
->drv
, cond
);
787 static CharDriverState
*qemu_chr_open_mux(const char *id
,
788 ChardevBackend
*backend
,
789 ChardevReturn
*ret
, Error
**errp
)
791 ChardevMux
*mux
= backend
->u
.mux
;
792 CharDriverState
*chr
, *drv
;
794 ChardevCommon
*common
= qapi_ChardevMux_base(mux
);
796 drv
= qemu_chr_find(mux
->chardev
);
798 error_setg(errp
, "mux: base chardev %s not found", mux
->chardev
);
802 chr
= qemu_chr_alloc(common
, errp
);
806 d
= g_new0(MuxDriver
, 1);
811 chr
->chr_write
= mux_chr_write
;
812 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
813 chr
->chr_accept_input
= mux_chr_accept_input
;
814 /* Frontend guest-open / -close notification is not support with muxes */
815 chr
->chr_set_fe_open
= NULL
;
816 if (drv
->chr_add_watch
) {
817 chr
->chr_add_watch
= mux_chr_add_watch
;
819 /* only default to opened state if we've realized the initial
822 chr
->explicit_be_open
= muxes_realized
? 0 : 1;
829 typedef struct IOWatchPoll
836 IOCanReadHandler
*fd_can_read
;
841 static IOWatchPoll
*io_watch_poll_from_source(GSource
*source
)
843 return container_of(source
, IOWatchPoll
, parent
);
846 static gboolean
io_watch_poll_prepare(GSource
*source
, gint
*timeout_
)
848 IOWatchPoll
*iwp
= io_watch_poll_from_source(source
);
849 bool now_active
= iwp
->fd_can_read(iwp
->opaque
) > 0;
850 bool was_active
= iwp
->src
!= NULL
;
851 if (was_active
== now_active
) {
856 iwp
->src
= qio_channel_create_watch(
857 iwp
->ioc
, G_IO_IN
| G_IO_ERR
| G_IO_HUP
| G_IO_NVAL
);
858 g_source_set_callback(iwp
->src
, iwp
->fd_read
, iwp
->opaque
, NULL
);
859 g_source_attach(iwp
->src
, NULL
);
861 g_source_destroy(iwp
->src
);
862 g_source_unref(iwp
->src
);
868 static gboolean
io_watch_poll_check(GSource
*source
)
873 static gboolean
io_watch_poll_dispatch(GSource
*source
, GSourceFunc callback
,
879 static void io_watch_poll_finalize(GSource
*source
)
881 /* Due to a glib bug, removing the last reference to a source
882 * inside a finalize callback causes recursive locking (and a
883 * deadlock). This is not a problem inside other callbacks,
884 * including dispatch callbacks, so we call io_remove_watch_poll
885 * to remove this source. At this point, iwp->src must
886 * be NULL, or we would leak it.
888 * This would be solved much more elegantly by child sources,
889 * but we support older glib versions that do not have them.
891 IOWatchPoll
*iwp
= io_watch_poll_from_source(source
);
892 assert(iwp
->src
== NULL
);
895 static GSourceFuncs io_watch_poll_funcs
= {
896 .prepare
= io_watch_poll_prepare
,
897 .check
= io_watch_poll_check
,
898 .dispatch
= io_watch_poll_dispatch
,
899 .finalize
= io_watch_poll_finalize
,
902 /* Can only be used for read */
903 static guint
io_add_watch_poll(QIOChannel
*ioc
,
904 IOCanReadHandler
*fd_can_read
,
905 QIOChannelFunc fd_read
,
911 iwp
= (IOWatchPoll
*) g_source_new(&io_watch_poll_funcs
, sizeof(IOWatchPoll
));
912 iwp
->fd_can_read
= fd_can_read
;
913 iwp
->opaque
= user_data
;
915 iwp
->fd_read
= (GSourceFunc
) fd_read
;
918 tag
= g_source_attach(&iwp
->parent
, NULL
);
919 g_source_unref(&iwp
->parent
);
923 static void io_remove_watch_poll(guint tag
)
928 g_return_if_fail (tag
> 0);
930 source
= g_main_context_find_source_by_id(NULL
, tag
);
931 g_return_if_fail (source
!= NULL
);
933 iwp
= io_watch_poll_from_source(source
);
935 g_source_destroy(iwp
->src
);
936 g_source_unref(iwp
->src
);
939 g_source_destroy(&iwp
->parent
);
942 static void remove_fd_in_watch(CharDriverState
*chr
)
944 if (chr
->fd_in_tag
) {
945 io_remove_watch_poll(chr
->fd_in_tag
);
951 static int io_channel_send_full(QIOChannel
*ioc
,
952 const void *buf
, size_t len
,
953 int *fds
, size_t nfds
)
957 while (offset
< len
) {
959 struct iovec iov
= { .iov_base
= (char *)buf
+ offset
,
960 .iov_len
= len
- offset
};
962 ret
= qio_channel_writev_full(
965 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
972 } else if (ret
< 0) {
985 static int io_channel_send(QIOChannel
*ioc
, const void *buf
, size_t len
)
987 return io_channel_send_full(ioc
, buf
, len
, NULL
, 0);
991 typedef struct FDCharDriver
{
992 CharDriverState
*chr
;
993 QIOChannel
*ioc_in
, *ioc_out
;
997 /* Called with chr_write_lock held. */
998 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1000 FDCharDriver
*s
= chr
->opaque
;
1002 return io_channel_send(s
->ioc_out
, buf
, len
);
1005 static gboolean
fd_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
1007 CharDriverState
*chr
= opaque
;
1008 FDCharDriver
*s
= chr
->opaque
;
1010 uint8_t buf
[READ_BUF_LEN
];
1014 if (len
> s
->max_size
) {
1021 ret
= qio_channel_read(
1022 chan
, (gchar
*)buf
, len
, NULL
);
1024 remove_fd_in_watch(chr
);
1025 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1029 qemu_chr_be_write(chr
, buf
, ret
);
1035 static int fd_chr_read_poll(void *opaque
)
1037 CharDriverState
*chr
= opaque
;
1038 FDCharDriver
*s
= chr
->opaque
;
1040 s
->max_size
= qemu_chr_be_can_write(chr
);
1044 static GSource
*fd_chr_add_watch(CharDriverState
*chr
, GIOCondition cond
)
1046 FDCharDriver
*s
= chr
->opaque
;
1047 return qio_channel_create_watch(s
->ioc_out
, cond
);
1050 static void fd_chr_update_read_handler(CharDriverState
*chr
)
1052 FDCharDriver
*s
= chr
->opaque
;
1054 remove_fd_in_watch(chr
);
1056 chr
->fd_in_tag
= io_add_watch_poll(s
->ioc_in
,
1062 static void fd_chr_close(struct CharDriverState
*chr
)
1064 FDCharDriver
*s
= chr
->opaque
;
1066 remove_fd_in_watch(chr
);
1068 object_unref(OBJECT(s
->ioc_in
));
1071 object_unref(OBJECT(s
->ioc_out
));
1075 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1078 /* open a character device to a unix fd */
1079 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
,
1080 ChardevCommon
*backend
, Error
**errp
)
1082 CharDriverState
*chr
;
1085 chr
= qemu_chr_alloc(backend
, errp
);
1089 s
= g_new0(FDCharDriver
, 1);
1090 s
->ioc_in
= QIO_CHANNEL(qio_channel_file_new_fd(fd_in
));
1091 s
->ioc_out
= QIO_CHANNEL(qio_channel_file_new_fd(fd_out
));
1092 qemu_set_nonblock(fd_out
);
1095 chr
->chr_add_watch
= fd_chr_add_watch
;
1096 chr
->chr_write
= fd_chr_write
;
1097 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
1098 chr
->chr_close
= fd_chr_close
;
1103 static CharDriverState
*qemu_chr_open_pipe(const char *id
,
1104 ChardevBackend
*backend
,
1108 ChardevHostdev
*opts
= backend
->u
.pipe
;
1112 const char *filename
= opts
->device
;
1113 ChardevCommon
*common
= qapi_ChardevHostdev_base(opts
);
1116 filename_in
= g_strdup_printf("%s.in", filename
);
1117 filename_out
= g_strdup_printf("%s.out", filename
);
1118 TFR(fd_in
= qemu_open(filename_in
, O_RDWR
| O_BINARY
));
1119 TFR(fd_out
= qemu_open(filename_out
, O_RDWR
| O_BINARY
));
1120 g_free(filename_in
);
1121 g_free(filename_out
);
1122 if (fd_in
< 0 || fd_out
< 0) {
1127 TFR(fd_in
= fd_out
= qemu_open(filename
, O_RDWR
| O_BINARY
));
1129 error_setg_file_open(errp
, errno
, filename
);
1133 return qemu_chr_open_fd(fd_in
, fd_out
, common
, errp
);
1136 /* init terminal so that we can grab keys */
1137 static struct termios oldtty
;
1138 static int old_fd0_flags
;
1139 static bool stdio_in_use
;
1140 static bool stdio_allow_signal
;
1141 static bool stdio_echo_state
;
1143 static void qemu_chr_set_echo_stdio(CharDriverState
*chr
, bool echo
);
1145 static void term_exit(void)
1147 tcsetattr (0, TCSANOW
, &oldtty
);
1148 fcntl(0, F_SETFL
, old_fd0_flags
);
1151 static void term_stdio_handler(int sig
)
1153 /* restore echo after resume from suspend. */
1154 qemu_chr_set_echo_stdio(NULL
, stdio_echo_state
);
1157 static void qemu_chr_set_echo_stdio(CharDriverState
*chr
, bool echo
)
1161 stdio_echo_state
= echo
;
1164 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
1165 |INLCR
|IGNCR
|ICRNL
|IXON
);
1166 tty
.c_oflag
|= OPOST
;
1167 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
1168 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
1171 tty
.c_cc
[VTIME
] = 0;
1173 if (!stdio_allow_signal
)
1174 tty
.c_lflag
&= ~ISIG
;
1176 tcsetattr (0, TCSANOW
, &tty
);
1179 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
1185 static CharDriverState
*qemu_chr_open_stdio(const char *id
,
1186 ChardevBackend
*backend
,
1190 ChardevStdio
*opts
= backend
->u
.stdio
;
1191 CharDriverState
*chr
;
1192 struct sigaction act
;
1193 ChardevCommon
*common
= qapi_ChardevStdio_base(opts
);
1195 if (is_daemonized()) {
1196 error_setg(errp
, "cannot use stdio with -daemonize");
1201 error_setg(errp
, "cannot use stdio by multiple character devices");
1205 stdio_in_use
= true;
1206 old_fd0_flags
= fcntl(0, F_GETFL
);
1207 tcgetattr(0, &oldtty
);
1208 qemu_set_nonblock(0);
1211 memset(&act
, 0, sizeof(act
));
1212 act
.sa_handler
= term_stdio_handler
;
1213 sigaction(SIGCONT
, &act
, NULL
);
1215 chr
= qemu_chr_open_fd(0, 1, common
, errp
);
1216 chr
->chr_close
= qemu_chr_close_stdio
;
1217 chr
->chr_set_echo
= qemu_chr_set_echo_stdio
;
1218 if (opts
->has_signal
) {
1219 stdio_allow_signal
= opts
->signal
;
1221 qemu_chr_fe_set_echo(chr
, false);
1226 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
1227 || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) \
1228 || defined(__GLIBC__)
1230 #define HAVE_CHARDEV_SERIAL 1
1231 #define HAVE_CHARDEV_PTY 1
1237 /* Protected by the CharDriverState chr_write_lock. */
1243 static void pty_chr_update_read_handler_locked(CharDriverState
*chr
);
1244 static void pty_chr_state(CharDriverState
*chr
, int connected
);
1246 static gboolean
pty_chr_timer(gpointer opaque
)
1248 struct CharDriverState
*chr
= opaque
;
1249 PtyCharDriver
*s
= chr
->opaque
;
1251 qemu_mutex_lock(&chr
->chr_write_lock
);
1254 if (!s
->connected
) {
1256 pty_chr_update_read_handler_locked(chr
);
1258 qemu_mutex_unlock(&chr
->chr_write_lock
);
1262 /* Called with chr_write_lock held. */
1263 static void pty_chr_rearm_timer(CharDriverState
*chr
, int ms
)
1265 PtyCharDriver
*s
= chr
->opaque
;
1268 g_source_remove(s
->timer_tag
);
1273 s
->timer_tag
= g_timeout_add_seconds(1, pty_chr_timer
, chr
);
1275 s
->timer_tag
= g_timeout_add(ms
, pty_chr_timer
, chr
);
1279 /* Called with chr_write_lock held. */
1280 static void pty_chr_update_read_handler_locked(CharDriverState
*chr
)
1282 PtyCharDriver
*s
= chr
->opaque
;
1285 QIOChannelFile
*fioc
= QIO_CHANNEL_FILE(s
->ioc
);
1288 pfd
.events
= G_IO_OUT
;
1291 rc
= g_poll(&pfd
, 1, 0);
1292 } while (rc
== -1 && errno
== EINTR
);
1295 if (pfd
.revents
& G_IO_HUP
) {
1296 pty_chr_state(chr
, 0);
1298 pty_chr_state(chr
, 1);
1302 static void pty_chr_update_read_handler(CharDriverState
*chr
)
1304 qemu_mutex_lock(&chr
->chr_write_lock
);
1305 pty_chr_update_read_handler_locked(chr
);
1306 qemu_mutex_unlock(&chr
->chr_write_lock
);
1309 /* Called with chr_write_lock held. */
1310 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1312 PtyCharDriver
*s
= chr
->opaque
;
1314 if (!s
->connected
) {
1315 /* guest sends data, check for (re-)connect */
1316 pty_chr_update_read_handler_locked(chr
);
1317 if (!s
->connected
) {
1321 return io_channel_send(s
->ioc
, buf
, len
);
1324 static GSource
*pty_chr_add_watch(CharDriverState
*chr
, GIOCondition cond
)
1326 PtyCharDriver
*s
= chr
->opaque
;
1327 if (!s
->connected
) {
1330 return qio_channel_create_watch(s
->ioc
, cond
);
1333 static int pty_chr_read_poll(void *opaque
)
1335 CharDriverState
*chr
= opaque
;
1336 PtyCharDriver
*s
= chr
->opaque
;
1338 s
->read_bytes
= qemu_chr_be_can_write(chr
);
1339 return s
->read_bytes
;
1342 static gboolean
pty_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
1344 CharDriverState
*chr
= opaque
;
1345 PtyCharDriver
*s
= chr
->opaque
;
1347 uint8_t buf
[READ_BUF_LEN
];
1351 if (len
> s
->read_bytes
)
1352 len
= s
->read_bytes
;
1356 ret
= qio_channel_read(s
->ioc
, (char *)buf
, len
, NULL
);
1358 pty_chr_state(chr
, 0);
1361 pty_chr_state(chr
, 1);
1362 qemu_chr_be_write(chr
, buf
, ret
);
1367 static gboolean
qemu_chr_be_generic_open_func(gpointer opaque
)
1369 CharDriverState
*chr
= opaque
;
1370 PtyCharDriver
*s
= chr
->opaque
;
1373 qemu_chr_be_generic_open(chr
);
1377 /* Called with chr_write_lock held. */
1378 static void pty_chr_state(CharDriverState
*chr
, int connected
)
1380 PtyCharDriver
*s
= chr
->opaque
;
1384 g_source_remove(s
->open_tag
);
1387 remove_fd_in_watch(chr
);
1389 /* (re-)connect poll interval for idle guests: once per second.
1390 * We check more frequently in case the guests sends data to
1391 * the virtual device linked to our pty. */
1392 pty_chr_rearm_timer(chr
, 1000);
1395 g_source_remove(s
->timer_tag
);
1398 if (!s
->connected
) {
1399 g_assert(s
->open_tag
== 0);
1401 s
->open_tag
= g_idle_add(qemu_chr_be_generic_open_func
, chr
);
1403 if (!chr
->fd_in_tag
) {
1404 chr
->fd_in_tag
= io_add_watch_poll(s
->ioc
,
1411 static void pty_chr_close(struct CharDriverState
*chr
)
1413 PtyCharDriver
*s
= chr
->opaque
;
1415 qemu_mutex_lock(&chr
->chr_write_lock
);
1416 pty_chr_state(chr
, 0);
1417 object_unref(OBJECT(s
->ioc
));
1419 g_source_remove(s
->timer_tag
);
1422 qemu_mutex_unlock(&chr
->chr_write_lock
);
1424 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1427 static CharDriverState
*qemu_chr_open_pty(const char *id
,
1428 ChardevBackend
*backend
,
1432 CharDriverState
*chr
;
1434 int master_fd
, slave_fd
;
1435 char pty_name
[PATH_MAX
];
1436 ChardevCommon
*common
= backend
->u
.pty
;
1438 master_fd
= qemu_openpty_raw(&slave_fd
, pty_name
);
1439 if (master_fd
< 0) {
1440 error_setg_errno(errp
, errno
, "Failed to create PTY");
1445 qemu_set_nonblock(master_fd
);
1447 chr
= qemu_chr_alloc(common
, errp
);
1453 chr
->filename
= g_strdup_printf("pty:%s", pty_name
);
1454 ret
->pty
= g_strdup(pty_name
);
1455 ret
->has_pty
= true;
1457 fprintf(stderr
, "char device redirected to %s (label %s)\n",
1460 s
= g_new0(PtyCharDriver
, 1);
1462 chr
->chr_write
= pty_chr_write
;
1463 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
1464 chr
->chr_close
= pty_chr_close
;
1465 chr
->chr_add_watch
= pty_chr_add_watch
;
1466 chr
->explicit_be_open
= true;
1468 s
->ioc
= QIO_CHANNEL(qio_channel_file_new_fd(master_fd
));
1474 static void tty_serial_init(int fd
, int speed
,
1475 int parity
, int data_bits
, int stop_bits
)
1481 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1482 speed
, parity
, data_bits
, stop_bits
);
1484 tcgetattr (fd
, &tty
);
1486 #define check_speed(val) if (speed <= val) { spd = B##val; break; }
1487 speed
= speed
* 10 / 11;
1504 /* Non-Posix values follow. They may be unsupported on some systems. */
1506 check_speed(115200);
1508 check_speed(230400);
1511 check_speed(460800);
1514 check_speed(500000);
1517 check_speed(576000);
1520 check_speed(921600);
1523 check_speed(1000000);
1526 check_speed(1152000);
1529 check_speed(1500000);
1532 check_speed(2000000);
1535 check_speed(2500000);
1538 check_speed(3000000);
1541 check_speed(3500000);
1544 check_speed(4000000);
1549 cfsetispeed(&tty
, spd
);
1550 cfsetospeed(&tty
, spd
);
1552 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
1553 |INLCR
|IGNCR
|ICRNL
|IXON
);
1554 tty
.c_oflag
|= OPOST
;
1555 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
1556 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
1577 tty
.c_cflag
|= PARENB
;
1580 tty
.c_cflag
|= PARENB
| PARODD
;
1584 tty
.c_cflag
|= CSTOPB
;
1586 tcsetattr (fd
, TCSANOW
, &tty
);
1589 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1591 FDCharDriver
*s
= chr
->opaque
;
1592 QIOChannelFile
*fioc
= QIO_CHANNEL_FILE(s
->ioc_in
);
1595 case CHR_IOCTL_SERIAL_SET_PARAMS
:
1597 QEMUSerialSetParams
*ssp
= arg
;
1598 tty_serial_init(fioc
->fd
,
1599 ssp
->speed
, ssp
->parity
,
1600 ssp
->data_bits
, ssp
->stop_bits
);
1603 case CHR_IOCTL_SERIAL_SET_BREAK
:
1605 int enable
= *(int *)arg
;
1607 tcsendbreak(fioc
->fd
, 1);
1611 case CHR_IOCTL_SERIAL_GET_TIOCM
:
1614 int *targ
= (int *)arg
;
1615 ioctl(fioc
->fd
, TIOCMGET
, &sarg
);
1617 if (sarg
& TIOCM_CTS
)
1618 *targ
|= CHR_TIOCM_CTS
;
1619 if (sarg
& TIOCM_CAR
)
1620 *targ
|= CHR_TIOCM_CAR
;
1621 if (sarg
& TIOCM_DSR
)
1622 *targ
|= CHR_TIOCM_DSR
;
1623 if (sarg
& TIOCM_RI
)
1624 *targ
|= CHR_TIOCM_RI
;
1625 if (sarg
& TIOCM_DTR
)
1626 *targ
|= CHR_TIOCM_DTR
;
1627 if (sarg
& TIOCM_RTS
)
1628 *targ
|= CHR_TIOCM_RTS
;
1631 case CHR_IOCTL_SERIAL_SET_TIOCM
:
1633 int sarg
= *(int *)arg
;
1635 ioctl(fioc
->fd
, TIOCMGET
, &targ
);
1636 targ
&= ~(CHR_TIOCM_CTS
| CHR_TIOCM_CAR
| CHR_TIOCM_DSR
1637 | CHR_TIOCM_RI
| CHR_TIOCM_DTR
| CHR_TIOCM_RTS
);
1638 if (sarg
& CHR_TIOCM_CTS
)
1640 if (sarg
& CHR_TIOCM_CAR
)
1642 if (sarg
& CHR_TIOCM_DSR
)
1644 if (sarg
& CHR_TIOCM_RI
)
1646 if (sarg
& CHR_TIOCM_DTR
)
1648 if (sarg
& CHR_TIOCM_RTS
)
1650 ioctl(fioc
->fd
, TIOCMSET
, &targ
);
1659 static void qemu_chr_close_tty(CharDriverState
*chr
)
1664 static CharDriverState
*qemu_chr_open_tty_fd(int fd
,
1665 ChardevCommon
*backend
,
1668 CharDriverState
*chr
;
1670 tty_serial_init(fd
, 115200, 'N', 8, 1);
1671 chr
= qemu_chr_open_fd(fd
, fd
, backend
, errp
);
1672 chr
->chr_ioctl
= tty_serial_ioctl
;
1673 chr
->chr_close
= qemu_chr_close_tty
;
1676 #endif /* __linux__ || __sun__ */
1678 #if defined(__linux__)
1680 #define HAVE_CHARDEV_PARPORT 1
1685 } ParallelCharDriver
;
1687 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
1689 if (s
->mode
!= mode
) {
1691 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
1698 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1700 ParallelCharDriver
*drv
= chr
->opaque
;
1705 case CHR_IOCTL_PP_READ_DATA
:
1706 if (ioctl(fd
, PPRDATA
, &b
) < 0)
1708 *(uint8_t *)arg
= b
;
1710 case CHR_IOCTL_PP_WRITE_DATA
:
1711 b
= *(uint8_t *)arg
;
1712 if (ioctl(fd
, PPWDATA
, &b
) < 0)
1715 case CHR_IOCTL_PP_READ_CONTROL
:
1716 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
1718 /* Linux gives only the lowest bits, and no way to know data
1719 direction! For better compatibility set the fixed upper
1721 *(uint8_t *)arg
= b
| 0xc0;
1723 case CHR_IOCTL_PP_WRITE_CONTROL
:
1724 b
= *(uint8_t *)arg
;
1725 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
1728 case CHR_IOCTL_PP_READ_STATUS
:
1729 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
1731 *(uint8_t *)arg
= b
;
1733 case CHR_IOCTL_PP_DATA_DIR
:
1734 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
1737 case CHR_IOCTL_PP_EPP_READ_ADDR
:
1738 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
1739 struct ParallelIOArg
*parg
= arg
;
1740 int n
= read(fd
, parg
->buffer
, parg
->count
);
1741 if (n
!= parg
->count
) {
1746 case CHR_IOCTL_PP_EPP_READ
:
1747 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
1748 struct ParallelIOArg
*parg
= arg
;
1749 int n
= read(fd
, parg
->buffer
, parg
->count
);
1750 if (n
!= parg
->count
) {
1755 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
1756 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
1757 struct ParallelIOArg
*parg
= arg
;
1758 int n
= write(fd
, parg
->buffer
, parg
->count
);
1759 if (n
!= parg
->count
) {
1764 case CHR_IOCTL_PP_EPP_WRITE
:
1765 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
1766 struct ParallelIOArg
*parg
= arg
;
1767 int n
= write(fd
, parg
->buffer
, parg
->count
);
1768 if (n
!= parg
->count
) {
1779 static void pp_close(CharDriverState
*chr
)
1781 ParallelCharDriver
*drv
= chr
->opaque
;
1784 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
1785 ioctl(fd
, PPRELEASE
);
1788 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1791 static CharDriverState
*qemu_chr_open_pp_fd(int fd
,
1792 ChardevCommon
*backend
,
1795 CharDriverState
*chr
;
1796 ParallelCharDriver
*drv
;
1798 if (ioctl(fd
, PPCLAIM
) < 0) {
1799 error_setg_errno(errp
, errno
, "not a parallel port");
1804 chr
= qemu_chr_alloc(backend
, errp
);
1809 drv
= g_new0(ParallelCharDriver
, 1);
1811 chr
->chr_write
= null_chr_write
;
1812 chr
->chr_ioctl
= pp_ioctl
;
1813 chr
->chr_close
= pp_close
;
1816 drv
->mode
= IEEE1284_MODE_COMPAT
;
1820 #endif /* __linux__ */
1822 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
1824 #define HAVE_CHARDEV_PARPORT 1
1826 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
1828 int fd
= (int)(intptr_t)chr
->opaque
;
1832 case CHR_IOCTL_PP_READ_DATA
:
1833 if (ioctl(fd
, PPIGDATA
, &b
) < 0)
1835 *(uint8_t *)arg
= b
;
1837 case CHR_IOCTL_PP_WRITE_DATA
:
1838 b
= *(uint8_t *)arg
;
1839 if (ioctl(fd
, PPISDATA
, &b
) < 0)
1842 case CHR_IOCTL_PP_READ_CONTROL
:
1843 if (ioctl(fd
, PPIGCTRL
, &b
) < 0)
1845 *(uint8_t *)arg
= b
;
1847 case CHR_IOCTL_PP_WRITE_CONTROL
:
1848 b
= *(uint8_t *)arg
;
1849 if (ioctl(fd
, PPISCTRL
, &b
) < 0)
1852 case CHR_IOCTL_PP_READ_STATUS
:
1853 if (ioctl(fd
, PPIGSTATUS
, &b
) < 0)
1855 *(uint8_t *)arg
= b
;
1863 static CharDriverState
*qemu_chr_open_pp_fd(int fd
,
1864 ChardevCommon
*backend
,
1867 CharDriverState
*chr
;
1869 chr
= qemu_chr_alloc(backend
, errp
);
1873 chr
->opaque
= (void *)(intptr_t)fd
;
1874 chr
->chr_write
= null_chr_write
;
1875 chr
->chr_ioctl
= pp_ioctl
;
1876 chr
->explicit_be_open
= true;
1883 #define HAVE_CHARDEV_SERIAL 1
1887 HANDLE hcom
, hrecv
, hsend
;
1892 /* Protected by the CharDriverState chr_write_lock. */
1898 HANDLE hInputReadyEvent
;
1899 HANDLE hInputDoneEvent
;
1900 HANDLE hInputThread
;
1901 uint8_t win_stdio_buf
;
1902 } WinStdioCharState
;
1904 #define NSENDBUF 2048
1905 #define NRECVBUF 2048
1906 #define MAXCONNECT 1
1907 #define NTIMEOUT 5000
1909 static int win_chr_poll(void *opaque
);
1910 static int win_chr_pipe_poll(void *opaque
);
1912 static void win_chr_close(CharDriverState
*chr
)
1914 WinCharState
*s
= chr
->opaque
;
1917 CloseHandle(s
->hsend
);
1921 CloseHandle(s
->hrecv
);
1925 CloseHandle(s
->hcom
);
1929 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
1931 qemu_del_polling_cb(win_chr_poll
, chr
);
1933 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
1936 static int win_chr_init(CharDriverState
*chr
, const char *filename
, Error
**errp
)
1938 WinCharState
*s
= chr
->opaque
;
1940 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
1945 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1947 error_setg(errp
, "Failed CreateEvent");
1950 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
1952 error_setg(errp
, "Failed CreateEvent");
1956 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
1957 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
1958 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
1959 error_setg(errp
, "Failed CreateFile (%lu)", GetLastError());
1964 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
1965 error_setg(errp
, "Failed SetupComm");
1969 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
1970 size
= sizeof(COMMCONFIG
);
1971 GetDefaultCommConfig(filename
, &comcfg
, &size
);
1972 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
1973 CommConfigDialog(filename
, NULL
, &comcfg
);
1975 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
1976 error_setg(errp
, "Failed SetCommState");
1980 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
1981 error_setg(errp
, "Failed SetCommMask");
1985 cto
.ReadIntervalTimeout
= MAXDWORD
;
1986 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
1987 error_setg(errp
, "Failed SetCommTimeouts");
1991 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
1992 error_setg(errp
, "Failed ClearCommError");
1995 qemu_add_polling_cb(win_chr_poll
, chr
);
2003 /* Called with chr_write_lock held. */
2004 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
2006 WinCharState
*s
= chr
->opaque
;
2007 DWORD len
, ret
, size
, err
;
2010 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
2011 s
->osend
.hEvent
= s
->hsend
;
2014 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
2016 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
2018 err
= GetLastError();
2019 if (err
== ERROR_IO_PENDING
) {
2020 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
2038 static int win_chr_read_poll(CharDriverState
*chr
)
2040 WinCharState
*s
= chr
->opaque
;
2042 s
->max_size
= qemu_chr_be_can_write(chr
);
2046 static void win_chr_readfile(CharDriverState
*chr
)
2048 WinCharState
*s
= chr
->opaque
;
2050 uint8_t buf
[READ_BUF_LEN
];
2053 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
2054 s
->orecv
.hEvent
= s
->hrecv
;
2055 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
2057 err
= GetLastError();
2058 if (err
== ERROR_IO_PENDING
) {
2059 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
2064 qemu_chr_be_write(chr
, buf
, size
);
2068 static void win_chr_read(CharDriverState
*chr
)
2070 WinCharState
*s
= chr
->opaque
;
2072 if (s
->len
> s
->max_size
)
2073 s
->len
= s
->max_size
;
2077 win_chr_readfile(chr
);
2080 static int win_chr_poll(void *opaque
)
2082 CharDriverState
*chr
= opaque
;
2083 WinCharState
*s
= chr
->opaque
;
2087 ClearCommError(s
->hcom
, &comerr
, &status
);
2088 if (status
.cbInQue
> 0) {
2089 s
->len
= status
.cbInQue
;
2090 win_chr_read_poll(chr
);
2097 static CharDriverState
*qemu_chr_open_win_path(const char *filename
,
2098 ChardevCommon
*backend
,
2101 CharDriverState
*chr
;
2104 chr
= qemu_chr_alloc(backend
, errp
);
2108 s
= g_new0(WinCharState
, 1);
2110 chr
->chr_write
= win_chr_write
;
2111 chr
->chr_close
= win_chr_close
;
2113 if (win_chr_init(chr
, filename
, errp
) < 0) {
2115 qemu_chr_free_common(chr
);
2121 static int win_chr_pipe_poll(void *opaque
)
2123 CharDriverState
*chr
= opaque
;
2124 WinCharState
*s
= chr
->opaque
;
2127 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
2130 win_chr_read_poll(chr
);
2137 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
,
2140 WinCharState
*s
= chr
->opaque
;
2148 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2150 error_setg(errp
, "Failed CreateEvent");
2153 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2155 error_setg(errp
, "Failed CreateEvent");
2159 openname
= g_strdup_printf("\\\\.\\pipe\\%s", filename
);
2160 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
2161 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
2163 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
2165 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
2166 error_setg(errp
, "Failed CreateNamedPipe (%lu)", GetLastError());
2171 ZeroMemory(&ov
, sizeof(ov
));
2172 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2173 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
2175 error_setg(errp
, "Failed ConnectNamedPipe");
2179 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
2181 error_setg(errp
, "Failed GetOverlappedResult");
2183 CloseHandle(ov
.hEvent
);
2190 CloseHandle(ov
.hEvent
);
2193 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
2202 static CharDriverState
*qemu_chr_open_pipe(const char *id
,
2203 ChardevBackend
*backend
,
2207 ChardevHostdev
*opts
= backend
->u
.pipe
;
2208 const char *filename
= opts
->device
;
2209 CharDriverState
*chr
;
2211 ChardevCommon
*common
= qapi_ChardevHostdev_base(opts
);
2213 chr
= qemu_chr_alloc(common
, errp
);
2217 s
= g_new0(WinCharState
, 1);
2219 chr
->chr_write
= win_chr_write
;
2220 chr
->chr_close
= win_chr_close
;
2222 if (win_chr_pipe_init(chr
, filename
, errp
) < 0) {
2224 qemu_chr_free_common(chr
);
2230 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
,
2231 ChardevCommon
*backend
,
2234 CharDriverState
*chr
;
2237 chr
= qemu_chr_alloc(backend
, errp
);
2241 s
= g_new0(WinCharState
, 1);
2244 chr
->chr_write
= win_chr_write
;
2248 static CharDriverState
*qemu_chr_open_win_con(const char *id
,
2249 ChardevBackend
*backend
,
2253 ChardevCommon
*common
= backend
->u
.console
;
2254 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
),
2258 static int win_stdio_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2260 HANDLE hStdOut
= GetStdHandle(STD_OUTPUT_HANDLE
);
2267 if (!WriteFile(hStdOut
, buf
, len1
, &dwSize
, NULL
)) {
2277 static void win_stdio_wait_func(void *opaque
)
2279 CharDriverState
*chr
= opaque
;
2280 WinStdioCharState
*stdio
= chr
->opaque
;
2281 INPUT_RECORD buf
[4];
2286 ret
= ReadConsoleInput(stdio
->hStdIn
, buf
, ARRAY_SIZE(buf
), &dwSize
);
2289 /* Avoid error storm */
2290 qemu_del_wait_object(stdio
->hStdIn
, NULL
, NULL
);
2294 for (i
= 0; i
< dwSize
; i
++) {
2295 KEY_EVENT_RECORD
*kev
= &buf
[i
].Event
.KeyEvent
;
2297 if (buf
[i
].EventType
== KEY_EVENT
&& kev
->bKeyDown
) {
2299 if (kev
->uChar
.AsciiChar
!= 0) {
2300 for (j
= 0; j
< kev
->wRepeatCount
; j
++) {
2301 if (qemu_chr_be_can_write(chr
)) {
2302 uint8_t c
= kev
->uChar
.AsciiChar
;
2303 qemu_chr_be_write(chr
, &c
, 1);
2311 static DWORD WINAPI
win_stdio_thread(LPVOID param
)
2313 CharDriverState
*chr
= param
;
2314 WinStdioCharState
*stdio
= chr
->opaque
;
2320 /* Wait for one byte */
2321 ret
= ReadFile(stdio
->hStdIn
, &stdio
->win_stdio_buf
, 1, &dwSize
, NULL
);
2323 /* Exit in case of error, continue if nothing read */
2331 /* Some terminal emulator returns \r\n for Enter, just pass \n */
2332 if (stdio
->win_stdio_buf
== '\r') {
2336 /* Signal the main thread and wait until the byte was eaten */
2337 if (!SetEvent(stdio
->hInputReadyEvent
)) {
2340 if (WaitForSingleObject(stdio
->hInputDoneEvent
, INFINITE
)
2346 qemu_del_wait_object(stdio
->hInputReadyEvent
, NULL
, NULL
);
2350 static void win_stdio_thread_wait_func(void *opaque
)
2352 CharDriverState
*chr
= opaque
;
2353 WinStdioCharState
*stdio
= chr
->opaque
;
2355 if (qemu_chr_be_can_write(chr
)) {
2356 qemu_chr_be_write(chr
, &stdio
->win_stdio_buf
, 1);
2359 SetEvent(stdio
->hInputDoneEvent
);
2362 static void qemu_chr_set_echo_win_stdio(CharDriverState
*chr
, bool echo
)
2364 WinStdioCharState
*stdio
= chr
->opaque
;
2367 GetConsoleMode(stdio
->hStdIn
, &dwMode
);
2370 SetConsoleMode(stdio
->hStdIn
, dwMode
| ENABLE_ECHO_INPUT
);
2372 SetConsoleMode(stdio
->hStdIn
, dwMode
& ~ENABLE_ECHO_INPUT
);
2376 static void win_stdio_close(CharDriverState
*chr
)
2378 WinStdioCharState
*stdio
= chr
->opaque
;
2380 if (stdio
->hInputReadyEvent
!= INVALID_HANDLE_VALUE
) {
2381 CloseHandle(stdio
->hInputReadyEvent
);
2383 if (stdio
->hInputDoneEvent
!= INVALID_HANDLE_VALUE
) {
2384 CloseHandle(stdio
->hInputDoneEvent
);
2386 if (stdio
->hInputThread
!= INVALID_HANDLE_VALUE
) {
2387 TerminateThread(stdio
->hInputThread
, 0);
2390 g_free(chr
->opaque
);
2394 static CharDriverState
*qemu_chr_open_stdio(const char *id
,
2395 ChardevBackend
*backend
,
2399 CharDriverState
*chr
;
2400 WinStdioCharState
*stdio
;
2403 ChardevCommon
*common
= qapi_ChardevStdio_base(backend
->u
.stdio
);
2405 chr
= qemu_chr_alloc(common
, errp
);
2409 stdio
= g_new0(WinStdioCharState
, 1);
2411 stdio
->hStdIn
= GetStdHandle(STD_INPUT_HANDLE
);
2412 if (stdio
->hStdIn
== INVALID_HANDLE_VALUE
) {
2413 error_setg(errp
, "cannot open stdio: invalid handle");
2417 is_console
= GetConsoleMode(stdio
->hStdIn
, &dwMode
) != 0;
2419 chr
->opaque
= stdio
;
2420 chr
->chr_write
= win_stdio_write
;
2421 chr
->chr_close
= win_stdio_close
;
2424 if (qemu_add_wait_object(stdio
->hStdIn
,
2425 win_stdio_wait_func
, chr
)) {
2426 error_setg(errp
, "qemu_add_wait_object: failed");
2432 stdio
->hInputReadyEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
2433 stdio
->hInputDoneEvent
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
2434 if (stdio
->hInputReadyEvent
== INVALID_HANDLE_VALUE
2435 || stdio
->hInputDoneEvent
== INVALID_HANDLE_VALUE
) {
2436 error_setg(errp
, "cannot create event");
2439 if (qemu_add_wait_object(stdio
->hInputReadyEvent
,
2440 win_stdio_thread_wait_func
, chr
)) {
2441 error_setg(errp
, "qemu_add_wait_object: failed");
2444 stdio
->hInputThread
= CreateThread(NULL
, 0, win_stdio_thread
,
2447 if (stdio
->hInputThread
== INVALID_HANDLE_VALUE
) {
2448 error_setg(errp
, "cannot create stdio thread");
2453 dwMode
|= ENABLE_LINE_INPUT
;
2456 /* set the terminal in raw mode */
2457 /* ENABLE_QUICK_EDIT_MODE | ENABLE_EXTENDED_FLAGS */
2458 dwMode
|= ENABLE_PROCESSED_INPUT
;
2461 SetConsoleMode(stdio
->hStdIn
, dwMode
);
2463 chr
->chr_set_echo
= qemu_chr_set_echo_win_stdio
;
2464 qemu_chr_fe_set_echo(chr
, false);
2469 qemu_del_wait_object(stdio
->hInputReadyEvent
, NULL
, NULL
);
2471 CloseHandle(stdio
->hInputReadyEvent
);
2472 CloseHandle(stdio
->hInputDoneEvent
);
2474 qemu_del_wait_object(stdio
->hStdIn
, NULL
, NULL
);
2477 #endif /* !_WIN32 */
2480 /***********************************************************/
2481 /* UDP Net console */
2485 uint8_t buf
[READ_BUF_LEN
];
2491 /* Called with chr_write_lock held. */
2492 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2494 NetCharDriver
*s
= chr
->opaque
;
2496 return qio_channel_write(
2497 s
->ioc
, (const char *)buf
, len
, NULL
);
2500 static int udp_chr_read_poll(void *opaque
)
2502 CharDriverState
*chr
= opaque
;
2503 NetCharDriver
*s
= chr
->opaque
;
2505 s
->max_size
= qemu_chr_be_can_write(chr
);
2507 /* If there were any stray characters in the queue process them
2510 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
2511 qemu_chr_be_write(chr
, &s
->buf
[s
->bufptr
], 1);
2513 s
->max_size
= qemu_chr_be_can_write(chr
);
2518 static gboolean
udp_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
2520 CharDriverState
*chr
= opaque
;
2521 NetCharDriver
*s
= chr
->opaque
;
2524 if (s
->max_size
== 0) {
2527 ret
= qio_channel_read(
2528 s
->ioc
, (char *)s
->buf
, sizeof(s
->buf
), NULL
);
2530 remove_fd_in_watch(chr
);
2536 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
2537 qemu_chr_be_write(chr
, &s
->buf
[s
->bufptr
], 1);
2539 s
->max_size
= qemu_chr_be_can_write(chr
);
2545 static void udp_chr_update_read_handler(CharDriverState
*chr
)
2547 NetCharDriver
*s
= chr
->opaque
;
2549 remove_fd_in_watch(chr
);
2551 chr
->fd_in_tag
= io_add_watch_poll(s
->ioc
,
2557 static void udp_chr_close(CharDriverState
*chr
)
2559 NetCharDriver
*s
= chr
->opaque
;
2561 remove_fd_in_watch(chr
);
2563 object_unref(OBJECT(s
->ioc
));
2566 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
2569 static CharDriverState
*qemu_chr_open_udp(QIOChannelSocket
*sioc
,
2570 ChardevCommon
*backend
,
2573 CharDriverState
*chr
= NULL
;
2574 NetCharDriver
*s
= NULL
;
2576 chr
= qemu_chr_alloc(backend
, errp
);
2580 s
= g_new0(NetCharDriver
, 1);
2582 s
->ioc
= QIO_CHANNEL(sioc
);
2586 chr
->chr_write
= udp_chr_write
;
2587 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
2588 chr
->chr_close
= udp_chr_close
;
2589 /* be isn't opened until we get a connection */
2590 chr
->explicit_be_open
= true;
2594 /***********************************************************/
2595 /* TCP Net console */
2598 QIOChannel
*ioc
; /* Client I/O channel */
2599 QIOChannelSocket
*sioc
; /* Client master channel */
2600 QIOChannelSocket
*listen_ioc
;
2602 QCryptoTLSCreds
*tls_creds
;
2609 size_t read_msgfds_num
;
2611 size_t write_msgfds_num
;
2613 SocketAddress
*addr
;
2617 guint reconnect_timer
;
2618 int64_t reconnect_time
;
2619 bool connect_err_reported
;
2622 static gboolean
socket_reconnect_timeout(gpointer opaque
);
2624 static void qemu_chr_socket_restart_timer(CharDriverState
*chr
)
2626 TCPCharDriver
*s
= chr
->opaque
;
2627 assert(s
->connected
== 0);
2628 s
->reconnect_timer
= g_timeout_add_seconds(s
->reconnect_time
,
2629 socket_reconnect_timeout
, chr
);
2632 static void check_report_connect_error(CharDriverState
*chr
,
2635 TCPCharDriver
*s
= chr
->opaque
;
2637 if (!s
->connect_err_reported
) {
2638 error_report("Unable to connect character device %s: %s",
2639 chr
->label
, error_get_pretty(err
));
2640 s
->connect_err_reported
= true;
2642 qemu_chr_socket_restart_timer(chr
);
2645 static gboolean
tcp_chr_accept(QIOChannel
*chan
,
2649 /* Called with chr_write_lock held. */
2650 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2652 TCPCharDriver
*s
= chr
->opaque
;
2654 int ret
= io_channel_send_full(s
->ioc
, buf
, len
,
2656 s
->write_msgfds_num
);
2658 /* free the written msgfds, no matter what */
2659 if (s
->write_msgfds_num
) {
2660 g_free(s
->write_msgfds
);
2661 s
->write_msgfds
= 0;
2662 s
->write_msgfds_num
= 0;
2667 /* XXX: indicate an error ? */
2672 static int tcp_chr_read_poll(void *opaque
)
2674 CharDriverState
*chr
= opaque
;
2675 TCPCharDriver
*s
= chr
->opaque
;
2678 s
->max_size
= qemu_chr_be_can_write(chr
);
2683 #define IAC_BREAK 243
2684 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
2686 uint8_t *buf
, int *size
)
2688 /* Handle any telnet client's basic IAC options to satisfy char by
2689 * char mode with no echo. All IAC options will be removed from
2690 * the buf and the do_telnetopt variable will be used to track the
2691 * state of the width of the IAC information.
2693 * IAC commands come in sets of 3 bytes with the exception of the
2694 * "IAC BREAK" command and the double IAC.
2700 for (i
= 0; i
< *size
; i
++) {
2701 if (s
->do_telnetopt
> 1) {
2702 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
2703 /* Double IAC means send an IAC */
2707 s
->do_telnetopt
= 1;
2709 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
2710 /* Handle IAC break commands by sending a serial break */
2711 qemu_chr_be_event(chr
, CHR_EVENT_BREAK
);
2716 if (s
->do_telnetopt
>= 4) {
2717 s
->do_telnetopt
= 1;
2720 if ((unsigned char)buf
[i
] == IAC
) {
2721 s
->do_telnetopt
= 2;
2732 static int tcp_get_msgfds(CharDriverState
*chr
, int *fds
, int num
)
2734 TCPCharDriver
*s
= chr
->opaque
;
2735 int to_copy
= (s
->read_msgfds_num
< num
) ? s
->read_msgfds_num
: num
;
2737 assert(num
<= TCP_MAX_FDS
);
2742 memcpy(fds
, s
->read_msgfds
, to_copy
* sizeof(int));
2744 /* Close unused fds */
2745 for (i
= to_copy
; i
< s
->read_msgfds_num
; i
++) {
2746 close(s
->read_msgfds
[i
]);
2749 g_free(s
->read_msgfds
);
2751 s
->read_msgfds_num
= 0;
2757 static int tcp_set_msgfds(CharDriverState
*chr
, int *fds
, int num
)
2759 TCPCharDriver
*s
= chr
->opaque
;
2761 if (!qio_channel_has_feature(s
->ioc
,
2762 QIO_CHANNEL_FEATURE_FD_PASS
)) {
2765 /* clear old pending fd array */
2766 g_free(s
->write_msgfds
);
2767 s
->write_msgfds
= NULL
;
2770 s
->write_msgfds
= g_new(int, num
);
2771 memcpy(s
->write_msgfds
, fds
, num
* sizeof(int));
2774 s
->write_msgfds_num
= num
;
2779 static ssize_t
tcp_chr_recv(CharDriverState
*chr
, char *buf
, size_t len
)
2781 TCPCharDriver
*s
= chr
->opaque
;
2782 struct iovec iov
= { .iov_base
= buf
, .iov_len
= len
};
2786 size_t msgfds_num
= 0;
2788 if (qio_channel_has_feature(s
->ioc
, QIO_CHANNEL_FEATURE_FD_PASS
)) {
2789 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
2790 &msgfds
, &msgfds_num
,
2793 ret
= qio_channel_readv_full(s
->ioc
, &iov
, 1,
2799 /* close and clean read_msgfds */
2800 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
2801 close(s
->read_msgfds
[i
]);
2804 if (s
->read_msgfds_num
) {
2805 g_free(s
->read_msgfds
);
2808 s
->read_msgfds
= msgfds
;
2809 s
->read_msgfds_num
= msgfds_num
;
2812 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
2813 int fd
= s
->read_msgfds
[i
];
2818 /* O_NONBLOCK is preserved across SCM_RIGHTS so reset it */
2821 #ifndef MSG_CMSG_CLOEXEC
2822 qemu_set_cloexec(fd
);
2829 static GSource
*tcp_chr_add_watch(CharDriverState
*chr
, GIOCondition cond
)
2831 TCPCharDriver
*s
= chr
->opaque
;
2832 return qio_channel_create_watch(s
->ioc
, cond
);
2835 static void tcp_chr_disconnect(CharDriverState
*chr
)
2837 TCPCharDriver
*s
= chr
->opaque
;
2839 if (!s
->connected
) {
2844 if (s
->listen_ioc
) {
2845 s
->listen_tag
= qio_channel_add_watch(
2846 QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
, tcp_chr_accept
, chr
, NULL
);
2848 tcp_set_msgfds(chr
, NULL
, 0);
2849 remove_fd_in_watch(chr
);
2850 object_unref(OBJECT(s
->sioc
));
2852 object_unref(OBJECT(s
->ioc
));
2854 g_free(chr
->filename
);
2855 chr
->filename
= SocketAddress_to_str("disconnected:", s
->addr
,
2856 s
->is_listen
, s
->is_telnet
);
2857 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
2858 if (s
->reconnect_time
) {
2859 qemu_chr_socket_restart_timer(chr
);
2863 static gboolean
tcp_chr_read(QIOChannel
*chan
, GIOCondition cond
, void *opaque
)
2865 CharDriverState
*chr
= opaque
;
2866 TCPCharDriver
*s
= chr
->opaque
;
2867 uint8_t buf
[READ_BUF_LEN
];
2870 if (!s
->connected
|| s
->max_size
<= 0) {
2874 if (len
> s
->max_size
)
2876 size
= tcp_chr_recv(chr
, (void *)buf
, len
);
2877 if (size
== 0 || size
== -1) {
2878 /* connection closed */
2879 tcp_chr_disconnect(chr
);
2880 } else if (size
> 0) {
2881 if (s
->do_telnetopt
)
2882 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
2884 qemu_chr_be_write(chr
, buf
, size
);
2890 static int tcp_chr_sync_read(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2892 TCPCharDriver
*s
= chr
->opaque
;
2895 if (!s
->connected
) {
2899 size
= tcp_chr_recv(chr
, (void *) buf
, len
);
2901 /* connection closed */
2902 tcp_chr_disconnect(chr
);
2908 static void tcp_chr_connect(void *opaque
)
2910 CharDriverState
*chr
= opaque
;
2911 TCPCharDriver
*s
= chr
->opaque
;
2913 g_free(chr
->filename
);
2914 chr
->filename
= sockaddr_to_str(
2915 &s
->sioc
->localAddr
, s
->sioc
->localAddrLen
,
2916 &s
->sioc
->remoteAddr
, s
->sioc
->remoteAddrLen
,
2917 s
->is_listen
, s
->is_telnet
);
2921 chr
->fd_in_tag
= io_add_watch_poll(s
->ioc
,
2925 qemu_chr_be_generic_open(chr
);
2928 static void tcp_chr_update_read_handler(CharDriverState
*chr
)
2930 TCPCharDriver
*s
= chr
->opaque
;
2932 if (!s
->connected
) {
2936 remove_fd_in_watch(chr
);
2938 chr
->fd_in_tag
= io_add_watch_poll(s
->ioc
,
2945 CharDriverState
*chr
;
2948 } TCPCharDriverTelnetInit
;
2950 static gboolean
tcp_chr_telnet_init_io(QIOChannel
*ioc
,
2951 GIOCondition cond G_GNUC_UNUSED
,
2954 TCPCharDriverTelnetInit
*init
= user_data
;
2957 ret
= qio_channel_write(ioc
, init
->buf
, init
->buflen
, NULL
);
2959 if (ret
== QIO_CHANNEL_ERR_BLOCK
) {
2962 tcp_chr_disconnect(init
->chr
);
2966 init
->buflen
-= ret
;
2968 if (init
->buflen
== 0) {
2969 tcp_chr_connect(init
->chr
);
2973 memmove(init
->buf
, init
->buf
+ ret
, init
->buflen
);
2978 static void tcp_chr_telnet_init(CharDriverState
*chr
)
2980 TCPCharDriver
*s
= chr
->opaque
;
2981 TCPCharDriverTelnetInit
*init
=
2982 g_new0(TCPCharDriverTelnetInit
, 1);
2988 #define IACSET(x, a, b, c) \
2995 /* Prep the telnet negotion to put telnet in binary,
2996 * no echo, single char mode */
2997 IACSET(init
->buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2998 IACSET(init
->buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2999 IACSET(init
->buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3000 IACSET(init
->buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3004 qio_channel_add_watch(
3006 tcp_chr_telnet_init_io
,
3011 static void tcp_chr_tls_handshake(Object
*source
,
3015 CharDriverState
*chr
= user_data
;
3016 TCPCharDriver
*s
= chr
->opaque
;
3019 tcp_chr_disconnect(chr
);
3021 if (s
->do_telnetopt
) {
3022 tcp_chr_telnet_init(chr
);
3024 tcp_chr_connect(chr
);
3030 static void tcp_chr_tls_init(CharDriverState
*chr
)
3032 TCPCharDriver
*s
= chr
->opaque
;
3033 QIOChannelTLS
*tioc
;
3037 tioc
= qio_channel_tls_new_server(
3038 s
->ioc
, s
->tls_creds
,
3039 NULL
, /* XXX Use an ACL */
3042 tioc
= qio_channel_tls_new_client(
3043 s
->ioc
, s
->tls_creds
,
3044 s
->addr
->u
.inet
->host
,
3049 tcp_chr_disconnect(chr
);
3051 object_unref(OBJECT(s
->ioc
));
3052 s
->ioc
= QIO_CHANNEL(tioc
);
3054 qio_channel_tls_handshake(tioc
,
3055 tcp_chr_tls_handshake
,
3061 static int tcp_chr_new_client(CharDriverState
*chr
, QIOChannelSocket
*sioc
)
3063 TCPCharDriver
*s
= chr
->opaque
;
3064 if (s
->ioc
!= NULL
) {
3068 s
->ioc
= QIO_CHANNEL(sioc
);
3069 object_ref(OBJECT(sioc
));
3071 object_ref(OBJECT(sioc
));
3073 if (s
->do_nodelay
) {
3074 qio_channel_set_delay(s
->ioc
, false);
3076 if (s
->listen_tag
) {
3077 g_source_remove(s
->listen_tag
);
3082 tcp_chr_tls_init(chr
);
3084 if (s
->do_telnetopt
) {
3085 tcp_chr_telnet_init(chr
);
3087 tcp_chr_connect(chr
);
3095 static int tcp_chr_add_client(CharDriverState
*chr
, int fd
)
3098 QIOChannelSocket
*sioc
;
3100 sioc
= qio_channel_socket_new_fd(fd
, NULL
);
3104 qio_channel_set_blocking(QIO_CHANNEL(sioc
), false, NULL
);
3105 ret
= tcp_chr_new_client(chr
, sioc
);
3106 object_unref(OBJECT(sioc
));
3110 static gboolean
tcp_chr_accept(QIOChannel
*channel
,
3114 CharDriverState
*chr
= opaque
;
3115 QIOChannelSocket
*sioc
;
3117 sioc
= qio_channel_socket_accept(QIO_CHANNEL_SOCKET(channel
),
3123 tcp_chr_new_client(chr
, sioc
);
3125 object_unref(OBJECT(sioc
));
3130 static void tcp_chr_close(CharDriverState
*chr
)
3132 TCPCharDriver
*s
= chr
->opaque
;
3135 if (s
->reconnect_timer
) {
3136 g_source_remove(s
->reconnect_timer
);
3137 s
->reconnect_timer
= 0;
3139 qapi_free_SocketAddress(s
->addr
);
3140 remove_fd_in_watch(chr
);
3142 object_unref(OBJECT(s
->ioc
));
3144 if (s
->listen_tag
) {
3145 g_source_remove(s
->listen_tag
);
3148 if (s
->listen_ioc
) {
3149 object_unref(OBJECT(s
->listen_ioc
));
3151 if (s
->read_msgfds_num
) {
3152 for (i
= 0; i
< s
->read_msgfds_num
; i
++) {
3153 close(s
->read_msgfds
[i
]);
3155 g_free(s
->read_msgfds
);
3158 object_unref(OBJECT(s
->tls_creds
));
3160 if (s
->write_msgfds_num
) {
3161 g_free(s
->write_msgfds
);
3164 qemu_chr_be_event(chr
, CHR_EVENT_CLOSED
);
3168 static void qemu_chr_socket_connected(Object
*src
, Error
*err
, void *opaque
)
3170 QIOChannelSocket
*sioc
= QIO_CHANNEL_SOCKET(src
);
3171 CharDriverState
*chr
= opaque
;
3172 TCPCharDriver
*s
= chr
->opaque
;
3175 check_report_connect_error(chr
, err
);
3180 s
->connect_err_reported
= false;
3181 tcp_chr_new_client(chr
, sioc
);
3182 object_unref(OBJECT(sioc
));
3186 /*********************************************************/
3187 /* Ring buffer chardev */
3194 } RingBufCharDriver
;
3196 static size_t ringbuf_count(const CharDriverState
*chr
)
3198 const RingBufCharDriver
*d
= chr
->opaque
;
3200 return d
->prod
- d
->cons
;
3203 /* Called with chr_write_lock held. */
3204 static int ringbuf_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3206 RingBufCharDriver
*d
= chr
->opaque
;
3209 if (!buf
|| (len
< 0)) {
3213 for (i
= 0; i
< len
; i
++ ) {
3214 d
->cbuf
[d
->prod
++ & (d
->size
- 1)] = buf
[i
];
3215 if (d
->prod
- d
->cons
> d
->size
) {
3216 d
->cons
= d
->prod
- d
->size
;
3223 static int ringbuf_chr_read(CharDriverState
*chr
, uint8_t *buf
, int len
)
3225 RingBufCharDriver
*d
= chr
->opaque
;
3228 qemu_mutex_lock(&chr
->chr_write_lock
);
3229 for (i
= 0; i
< len
&& d
->cons
!= d
->prod
; i
++) {
3230 buf
[i
] = d
->cbuf
[d
->cons
++ & (d
->size
- 1)];
3232 qemu_mutex_unlock(&chr
->chr_write_lock
);
3237 static void ringbuf_chr_close(struct CharDriverState
*chr
)
3239 RingBufCharDriver
*d
= chr
->opaque
;
3246 static CharDriverState
*qemu_chr_open_ringbuf(const char *id
,
3247 ChardevBackend
*backend
,
3251 ChardevRingbuf
*opts
= backend
->u
.ringbuf
;
3252 ChardevCommon
*common
= qapi_ChardevRingbuf_base(opts
);
3253 CharDriverState
*chr
;
3254 RingBufCharDriver
*d
;
3256 chr
= qemu_chr_alloc(common
, errp
);
3260 d
= g_malloc(sizeof(*d
));
3262 d
->size
= opts
->has_size
? opts
->size
: 65536;
3264 /* The size must be power of 2 */
3265 if (d
->size
& (d
->size
- 1)) {
3266 error_setg(errp
, "size of ringbuf chardev must be power of two");
3272 d
->cbuf
= g_malloc0(d
->size
);
3275 chr
->chr_write
= ringbuf_chr_write
;
3276 chr
->chr_close
= ringbuf_chr_close
;
3282 qemu_chr_free_common(chr
);
3286 bool chr_is_ringbuf(const CharDriverState
*chr
)
3288 return chr
->chr_write
== ringbuf_chr_write
;
3291 void qmp_ringbuf_write(const char *device
, const char *data
,
3292 bool has_format
, enum DataFormat format
,
3295 CharDriverState
*chr
;
3296 const uint8_t *write_data
;
3300 chr
= qemu_chr_find(device
);
3302 error_setg(errp
, "Device '%s' not found", device
);
3306 if (!chr_is_ringbuf(chr
)) {
3307 error_setg(errp
,"%s is not a ringbuf device", device
);
3311 if (has_format
&& (format
== DATA_FORMAT_BASE64
)) {
3312 write_data
= qbase64_decode(data
, -1,
3319 write_data
= (uint8_t *)data
;
3320 write_count
= strlen(data
);
3323 ret
= ringbuf_chr_write(chr
, write_data
, write_count
);
3325 if (write_data
!= (uint8_t *)data
) {
3326 g_free((void *)write_data
);
3330 error_setg(errp
, "Failed to write to device %s", device
);
3335 char *qmp_ringbuf_read(const char *device
, int64_t size
,
3336 bool has_format
, enum DataFormat format
,
3339 CharDriverState
*chr
;
3344 chr
= qemu_chr_find(device
);
3346 error_setg(errp
, "Device '%s' not found", device
);
3350 if (!chr_is_ringbuf(chr
)) {
3351 error_setg(errp
,"%s is not a ringbuf device", device
);
3356 error_setg(errp
, "size must be greater than zero");
3360 count
= ringbuf_count(chr
);
3361 size
= size
> count
? count
: size
;
3362 read_data
= g_malloc(size
+ 1);
3364 ringbuf_chr_read(chr
, read_data
, size
);
3366 if (has_format
&& (format
== DATA_FORMAT_BASE64
)) {
3367 data
= g_base64_encode(read_data
, size
);
3371 * FIXME should read only complete, valid UTF-8 characters up
3372 * to @size bytes. Invalid sequences should be replaced by a
3373 * suitable replacement character. Except when (and only
3374 * when) ring buffer lost characters since last read, initial
3375 * continuation characters should be dropped.
3377 read_data
[size
] = 0;
3378 data
= (char *)read_data
;
3384 QemuOpts
*qemu_chr_parse_compat(const char *label
, const char *filename
)
3386 char host
[65], port
[33], width
[8], height
[8];
3390 Error
*local_err
= NULL
;
3392 opts
= qemu_opts_create(qemu_find_opts("chardev"), label
, 1, &local_err
);
3394 error_report_err(local_err
);
3398 if (strstart(filename
, "mon:", &p
)) {
3400 qemu_opt_set(opts
, "mux", "on", &error_abort
);
3401 if (strcmp(filename
, "stdio") == 0) {
3402 /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
3403 * but pass it to the guest. Handle this only for compat syntax,
3404 * for -chardev syntax we have special option for this.
3405 * This is what -nographic did, redirecting+muxing serial+monitor
3406 * to stdio causing Ctrl+C to be passed to guest. */
3407 qemu_opt_set(opts
, "signal", "off", &error_abort
);
3411 if (strcmp(filename
, "null") == 0 ||
3412 strcmp(filename
, "pty") == 0 ||
3413 strcmp(filename
, "msmouse") == 0 ||
3414 strcmp(filename
, "braille") == 0 ||
3415 strcmp(filename
, "testdev") == 0 ||
3416 strcmp(filename
, "stdio") == 0) {
3417 qemu_opt_set(opts
, "backend", filename
, &error_abort
);
3420 if (strstart(filename
, "vc", &p
)) {
3421 qemu_opt_set(opts
, "backend", "vc", &error_abort
);
3423 if (sscanf(p
+1, "%7[0-9]x%7[0-9]", width
, height
) == 2) {
3425 qemu_opt_set(opts
, "width", width
, &error_abort
);
3426 qemu_opt_set(opts
, "height", height
, &error_abort
);
3427 } else if (sscanf(p
+1, "%7[0-9]Cx%7[0-9]C", width
, height
) == 2) {
3429 qemu_opt_set(opts
, "cols", width
, &error_abort
);
3430 qemu_opt_set(opts
, "rows", height
, &error_abort
);
3437 if (strcmp(filename
, "con:") == 0) {
3438 qemu_opt_set(opts
, "backend", "console", &error_abort
);
3441 if (strstart(filename
, "COM", NULL
)) {
3442 qemu_opt_set(opts
, "backend", "serial", &error_abort
);
3443 qemu_opt_set(opts
, "path", filename
, &error_abort
);
3446 if (strstart(filename
, "file:", &p
)) {
3447 qemu_opt_set(opts
, "backend", "file", &error_abort
);
3448 qemu_opt_set(opts
, "path", p
, &error_abort
);
3451 if (strstart(filename
, "pipe:", &p
)) {
3452 qemu_opt_set(opts
, "backend", "pipe", &error_abort
);
3453 qemu_opt_set(opts
, "path", p
, &error_abort
);
3456 if (strstart(filename
, "tcp:", &p
) ||
3457 strstart(filename
, "telnet:", &p
)) {
3458 if (sscanf(p
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) < 2) {
3460 if (sscanf(p
, ":%32[^,]%n", port
, &pos
) < 1)
3463 qemu_opt_set(opts
, "backend", "socket", &error_abort
);
3464 qemu_opt_set(opts
, "host", host
, &error_abort
);
3465 qemu_opt_set(opts
, "port", port
, &error_abort
);
3466 if (p
[pos
] == ',') {
3467 qemu_opts_do_parse(opts
, p
+pos
+1, NULL
, &local_err
);
3469 error_report_err(local_err
);
3473 if (strstart(filename
, "telnet:", &p
))
3474 qemu_opt_set(opts
, "telnet", "on", &error_abort
);
3477 if (strstart(filename
, "udp:", &p
)) {
3478 qemu_opt_set(opts
, "backend", "udp", &error_abort
);
3479 if (sscanf(p
, "%64[^:]:%32[^@,]%n", host
, port
, &pos
) < 2) {
3481 if (sscanf(p
, ":%32[^@,]%n", port
, &pos
) < 1) {
3485 qemu_opt_set(opts
, "host", host
, &error_abort
);
3486 qemu_opt_set(opts
, "port", port
, &error_abort
);
3487 if (p
[pos
] == '@') {
3489 if (sscanf(p
, "%64[^:]:%32[^,]%n", host
, port
, &pos
) < 2) {
3491 if (sscanf(p
, ":%32[^,]%n", port
, &pos
) < 1) {
3495 qemu_opt_set(opts
, "localaddr", host
, &error_abort
);
3496 qemu_opt_set(opts
, "localport", port
, &error_abort
);
3500 if (strstart(filename
, "unix:", &p
)) {
3501 qemu_opt_set(opts
, "backend", "socket", &error_abort
);
3502 qemu_opts_do_parse(opts
, p
, "path", &local_err
);
3504 error_report_err(local_err
);
3509 if (strstart(filename
, "/dev/parport", NULL
) ||
3510 strstart(filename
, "/dev/ppi", NULL
)) {
3511 qemu_opt_set(opts
, "backend", "parport", &error_abort
);
3512 qemu_opt_set(opts
, "path", filename
, &error_abort
);
3515 if (strstart(filename
, "/dev/", NULL
)) {
3516 qemu_opt_set(opts
, "backend", "tty", &error_abort
);
3517 qemu_opt_set(opts
, "path", filename
, &error_abort
);
3522 qemu_opts_del(opts
);
3526 void qemu_chr_parse_common(QemuOpts
*opts
, ChardevCommon
*backend
)
3528 const char *logfile
= qemu_opt_get(opts
, "logfile");
3530 backend
->has_logfile
= logfile
!= NULL
;
3531 backend
->logfile
= logfile
? g_strdup(logfile
) : NULL
;
3533 backend
->has_logappend
= true;
3534 backend
->logappend
= qemu_opt_get_bool(opts
, "logappend", false);
3538 static void qemu_chr_parse_file_out(QemuOpts
*opts
, ChardevBackend
*backend
,
3541 const char *path
= qemu_opt_get(opts
, "path");
3545 error_setg(errp
, "chardev: file: no filename given");
3548 file
= backend
->u
.file
= g_new0(ChardevFile
, 1);
3549 qemu_chr_parse_common(opts
, qapi_ChardevFile_base(file
));
3550 file
->out
= g_strdup(path
);
3552 file
->has_append
= true;
3553 file
->append
= qemu_opt_get_bool(opts
, "append", false);
3556 static void qemu_chr_parse_stdio(QemuOpts
*opts
, ChardevBackend
*backend
,
3559 ChardevStdio
*stdio
;
3561 stdio
= backend
->u
.stdio
= g_new0(ChardevStdio
, 1);
3562 qemu_chr_parse_common(opts
, qapi_ChardevStdio_base(stdio
));
3563 stdio
->has_signal
= true;
3564 stdio
->signal
= qemu_opt_get_bool(opts
, "signal", true);
3567 #ifdef HAVE_CHARDEV_SERIAL
3568 static void qemu_chr_parse_serial(QemuOpts
*opts
, ChardevBackend
*backend
,
3571 const char *device
= qemu_opt_get(opts
, "path");
3572 ChardevHostdev
*serial
;
3574 if (device
== NULL
) {
3575 error_setg(errp
, "chardev: serial/tty: no device path given");
3578 serial
= backend
->u
.serial
= g_new0(ChardevHostdev
, 1);
3579 qemu_chr_parse_common(opts
, qapi_ChardevHostdev_base(serial
));
3580 serial
->device
= g_strdup(device
);
3584 #ifdef HAVE_CHARDEV_PARPORT
3585 static void qemu_chr_parse_parallel(QemuOpts
*opts
, ChardevBackend
*backend
,
3588 const char *device
= qemu_opt_get(opts
, "path");
3589 ChardevHostdev
*parallel
;
3591 if (device
== NULL
) {
3592 error_setg(errp
, "chardev: parallel: no device path given");
3595 parallel
= backend
->u
.parallel
= g_new0(ChardevHostdev
, 1);
3596 qemu_chr_parse_common(opts
, qapi_ChardevHostdev_base(parallel
));
3597 parallel
->device
= g_strdup(device
);
3601 static void qemu_chr_parse_pipe(QemuOpts
*opts
, ChardevBackend
*backend
,
3604 const char *device
= qemu_opt_get(opts
, "path");
3605 ChardevHostdev
*dev
;
3607 if (device
== NULL
) {
3608 error_setg(errp
, "chardev: pipe: no device path given");
3611 dev
= backend
->u
.pipe
= g_new0(ChardevHostdev
, 1);
3612 qemu_chr_parse_common(opts
, qapi_ChardevHostdev_base(dev
));
3613 dev
->device
= g_strdup(device
);
3616 static void qemu_chr_parse_ringbuf(QemuOpts
*opts
, ChardevBackend
*backend
,
3620 ChardevRingbuf
*ringbuf
;
3622 ringbuf
= backend
->u
.ringbuf
= g_new0(ChardevRingbuf
, 1);
3623 qemu_chr_parse_common(opts
, qapi_ChardevRingbuf_base(ringbuf
));
3625 val
= qemu_opt_get_size(opts
, "size", 0);
3627 ringbuf
->has_size
= true;
3628 ringbuf
->size
= val
;
3632 static void qemu_chr_parse_mux(QemuOpts
*opts
, ChardevBackend
*backend
,
3635 const char *chardev
= qemu_opt_get(opts
, "chardev");
3638 if (chardev
== NULL
) {
3639 error_setg(errp
, "chardev: mux: no chardev given");
3642 mux
= backend
->u
.mux
= g_new0(ChardevMux
, 1);
3643 qemu_chr_parse_common(opts
, qapi_ChardevMux_base(mux
));
3644 mux
->chardev
= g_strdup(chardev
);
3647 static void qemu_chr_parse_socket(QemuOpts
*opts
, ChardevBackend
*backend
,
3650 bool is_listen
= qemu_opt_get_bool(opts
, "server", false);
3651 bool is_waitconnect
= is_listen
&& qemu_opt_get_bool(opts
, "wait", true);
3652 bool is_telnet
= qemu_opt_get_bool(opts
, "telnet", false);
3653 bool do_nodelay
= !qemu_opt_get_bool(opts
, "delay", true);
3654 int64_t reconnect
= qemu_opt_get_number(opts
, "reconnect", 0);
3655 const char *path
= qemu_opt_get(opts
, "path");
3656 const char *host
= qemu_opt_get(opts
, "host");
3657 const char *port
= qemu_opt_get(opts
, "port");
3658 const char *tls_creds
= qemu_opt_get(opts
, "tls-creds");
3659 SocketAddress
*addr
;
3660 ChardevSocket
*sock
;
3664 error_setg(errp
, "chardev: socket: no host given");
3668 error_setg(errp
, "chardev: socket: no port given");
3673 error_setg(errp
, "TLS can only be used over TCP socket");
3678 sock
= backend
->u
.socket
= g_new0(ChardevSocket
, 1);
3679 qemu_chr_parse_common(opts
, qapi_ChardevSocket_base(sock
));
3681 sock
->has_nodelay
= true;
3682 sock
->nodelay
= do_nodelay
;
3683 sock
->has_server
= true;
3684 sock
->server
= is_listen
;
3685 sock
->has_telnet
= true;
3686 sock
->telnet
= is_telnet
;
3687 sock
->has_wait
= true;
3688 sock
->wait
= is_waitconnect
;
3689 sock
->has_reconnect
= true;
3690 sock
->reconnect
= reconnect
;
3691 sock
->tls_creds
= g_strdup(tls_creds
);
3693 addr
= g_new0(SocketAddress
, 1);
3695 UnixSocketAddress
*q_unix
;
3696 addr
->type
= SOCKET_ADDRESS_KIND_UNIX
;
3697 q_unix
= addr
->u
.q_unix
= g_new0(UnixSocketAddress
, 1);
3698 q_unix
->path
= g_strdup(path
);
3700 addr
->type
= SOCKET_ADDRESS_KIND_INET
;
3701 addr
->u
.inet
= g_new(InetSocketAddress
, 1);
3702 *addr
->u
.inet
= (InetSocketAddress
) {
3703 .host
= g_strdup(host
),
3704 .port
= g_strdup(port
),
3705 .has_to
= qemu_opt_get(opts
, "to"),
3706 .to
= qemu_opt_get_number(opts
, "to", 0),
3707 .has_ipv4
= qemu_opt_get(opts
, "ipv4"),
3708 .ipv4
= qemu_opt_get_bool(opts
, "ipv4", 0),
3709 .has_ipv6
= qemu_opt_get(opts
, "ipv6"),
3710 .ipv6
= qemu_opt_get_bool(opts
, "ipv6", 0),
3716 static void qemu_chr_parse_udp(QemuOpts
*opts
, ChardevBackend
*backend
,
3719 const char *host
= qemu_opt_get(opts
, "host");
3720 const char *port
= qemu_opt_get(opts
, "port");
3721 const char *localaddr
= qemu_opt_get(opts
, "localaddr");
3722 const char *localport
= qemu_opt_get(opts
, "localport");
3723 bool has_local
= false;
3724 SocketAddress
*addr
;
3727 if (host
== NULL
|| strlen(host
) == 0) {
3730 if (port
== NULL
|| strlen(port
) == 0) {
3731 error_setg(errp
, "chardev: udp: remote port not specified");
3734 if (localport
== NULL
|| strlen(localport
) == 0) {
3739 if (localaddr
== NULL
|| strlen(localaddr
) == 0) {
3745 udp
= backend
->u
.udp
= g_new0(ChardevUdp
, 1);
3746 qemu_chr_parse_common(opts
, qapi_ChardevUdp_base(udp
));
3748 addr
= g_new0(SocketAddress
, 1);
3749 addr
->type
= SOCKET_ADDRESS_KIND_INET
;
3750 addr
->u
.inet
= g_new(InetSocketAddress
, 1);
3751 *addr
->u
.inet
= (InetSocketAddress
) {
3752 .host
= g_strdup(host
),
3753 .port
= g_strdup(port
),
3754 .has_ipv4
= qemu_opt_get(opts
, "ipv4"),
3755 .ipv4
= qemu_opt_get_bool(opts
, "ipv4", 0),
3756 .has_ipv6
= qemu_opt_get(opts
, "ipv6"),
3757 .ipv6
= qemu_opt_get_bool(opts
, "ipv6", 0),
3762 udp
->has_local
= true;
3763 addr
= g_new0(SocketAddress
, 1);
3764 addr
->type
= SOCKET_ADDRESS_KIND_INET
;
3765 addr
->u
.inet
= g_new(InetSocketAddress
, 1);
3766 *addr
->u
.inet
= (InetSocketAddress
) {
3767 .host
= g_strdup(localaddr
),
3768 .port
= g_strdup(localport
),
3774 typedef struct CharDriver
{
3776 ChardevBackendKind kind
;
3777 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
);
3778 CharDriverState
*(*create
)(const char *id
, ChardevBackend
*backend
,
3779 ChardevReturn
*ret
, Error
**errp
);
3782 static GSList
*backends
;
3784 void register_char_driver(const char *name
, ChardevBackendKind kind
,
3785 void (*parse
)(QemuOpts
*opts
, ChardevBackend
*backend
, Error
**errp
),
3786 CharDriverState
*(*create
)(const char *id
, ChardevBackend
*backend
,
3787 ChardevReturn
*ret
, Error
**errp
))
3791 s
= g_malloc0(sizeof(*s
));
3792 s
->name
= g_strdup(name
);
3797 backends
= g_slist_append(backends
, s
);
3800 CharDriverState
*qemu_chr_new_from_opts(QemuOpts
*opts
,
3801 void (*init
)(struct CharDriverState
*s
),
3804 Error
*local_err
= NULL
;
3806 CharDriverState
*chr
;
3808 ChardevReturn
*ret
= NULL
;
3809 ChardevBackend
*backend
;
3810 const char *id
= qemu_opts_id(opts
);
3814 error_setg(errp
, "chardev: no id specified");
3818 if (qemu_opt_get(opts
, "backend") == NULL
) {
3819 error_setg(errp
, "chardev: \"%s\" missing backend",
3820 qemu_opts_id(opts
));
3823 for (i
= backends
; i
; i
= i
->next
) {
3826 if (strcmp(cd
->name
, qemu_opt_get(opts
, "backend")) == 0) {
3831 error_setg(errp
, "chardev: backend \"%s\" not found",
3832 qemu_opt_get(opts
, "backend"));
3836 backend
= g_new0(ChardevBackend
, 1);
3838 if (qemu_opt_get_bool(opts
, "mux", 0)) {
3839 bid
= g_strdup_printf("%s-base", id
);
3843 backend
->type
= cd
->kind
;
3845 cd
->parse(opts
, backend
, &local_err
);
3847 error_propagate(errp
, local_err
);
3851 ChardevCommon
*cc
= g_new0(ChardevCommon
, 1);
3852 qemu_chr_parse_common(opts
, cc
);
3853 backend
->u
.null
= cc
; /* Any ChardevCommon member would work */
3856 ret
= qmp_chardev_add(bid
? bid
: id
, backend
, errp
);
3862 qapi_free_ChardevBackend(backend
);
3863 qapi_free_ChardevReturn(ret
);
3864 backend
= g_new0(ChardevBackend
, 1);
3865 backend
->u
.mux
= g_new0(ChardevMux
, 1);
3866 backend
->type
= CHARDEV_BACKEND_KIND_MUX
;
3867 backend
->u
.mux
->chardev
= g_strdup(bid
);
3868 ret
= qmp_chardev_add(id
, backend
, errp
);
3870 chr
= qemu_chr_find(bid
);
3871 qemu_chr_delete(chr
);
3877 chr
= qemu_chr_find(id
);
3881 qapi_free_ChardevBackend(backend
);
3882 qapi_free_ChardevReturn(ret
);
3887 qemu_opts_del(opts
);
3891 CharDriverState
*qemu_chr_new_noreplay(const char *label
, const char *filename
,
3892 void (*init
)(struct CharDriverState
*s
))
3895 CharDriverState
*chr
;
3899 if (strstart(filename
, "chardev:", &p
)) {
3900 return qemu_chr_find(p
);
3903 opts
= qemu_chr_parse_compat(label
, filename
);
3907 chr
= qemu_chr_new_from_opts(opts
, init
, &err
);
3909 error_report_err(err
);
3911 if (chr
&& qemu_opt_get_bool(opts
, "mux", 0)) {
3912 qemu_chr_fe_claim_no_fail(chr
);
3913 monitor_init(chr
, MONITOR_USE_READLINE
);
3918 CharDriverState
*qemu_chr_new(const char *label
, const char *filename
, void (*init
)(struct CharDriverState
*s
))
3920 CharDriverState
*chr
;
3921 chr
= qemu_chr_new_noreplay(label
, filename
, init
);
3923 chr
->replay
= replay_mode
!= REPLAY_MODE_NONE
;
3924 if (chr
->replay
&& chr
->chr_ioctl
) {
3926 "Replay: ioctl is not supported for serial devices yet\n");
3928 replay_register_char_driver(chr
);
3933 void qemu_chr_fe_set_echo(struct CharDriverState
*chr
, bool echo
)
3935 if (chr
->chr_set_echo
) {
3936 chr
->chr_set_echo(chr
, echo
);
3940 void qemu_chr_fe_set_open(struct CharDriverState
*chr
, int fe_open
)
3942 if (chr
->fe_open
== fe_open
) {
3945 chr
->fe_open
= fe_open
;
3946 if (chr
->chr_set_fe_open
) {
3947 chr
->chr_set_fe_open(chr
, fe_open
);
3951 void qemu_chr_fe_event(struct CharDriverState
*chr
, int event
)
3953 if (chr
->chr_fe_event
) {
3954 chr
->chr_fe_event(chr
, event
);
3958 int qemu_chr_fe_add_watch(CharDriverState
*s
, GIOCondition cond
,
3959 GIOFunc func
, void *user_data
)
3964 if (s
->chr_add_watch
== NULL
) {
3968 src
= s
->chr_add_watch(s
, cond
);
3973 g_source_set_callback(src
, (GSourceFunc
)func
, user_data
, NULL
);
3974 tag
= g_source_attach(src
, NULL
);
3975 g_source_unref(src
);
3980 int qemu_chr_fe_claim(CharDriverState
*s
)
3982 if (s
->avail_connections
< 1) {
3985 s
->avail_connections
--;
3989 void qemu_chr_fe_claim_no_fail(CharDriverState
*s
)
3991 if (qemu_chr_fe_claim(s
) != 0) {
3992 fprintf(stderr
, "%s: error chardev \"%s\" already used\n",
3993 __func__
, s
->label
);
3998 void qemu_chr_fe_release(CharDriverState
*s
)
4000 s
->avail_connections
++;
4003 static void qemu_chr_free_common(CharDriverState
*chr
)
4005 g_free(chr
->filename
);
4007 qemu_opts_del(chr
->opts
);
4008 if (chr
->logfd
!= -1) {
4011 qemu_mutex_destroy(&chr
->chr_write_lock
);
4015 void qemu_chr_free(CharDriverState
*chr
)
4017 if (chr
->chr_close
) {
4018 chr
->chr_close(chr
);
4020 qemu_chr_free_common(chr
);
4023 void qemu_chr_delete(CharDriverState
*chr
)
4025 QTAILQ_REMOVE(&chardevs
, chr
, next
);
4029 ChardevInfoList
*qmp_query_chardev(Error
**errp
)
4031 ChardevInfoList
*chr_list
= NULL
;
4032 CharDriverState
*chr
;
4034 QTAILQ_FOREACH(chr
, &chardevs
, next
) {
4035 ChardevInfoList
*info
= g_malloc0(sizeof(*info
));
4036 info
->value
= g_malloc0(sizeof(*info
->value
));
4037 info
->value
->label
= g_strdup(chr
->label
);
4038 info
->value
->filename
= g_strdup(chr
->filename
);
4039 info
->value
->frontend_open
= chr
->fe_open
;
4041 info
->next
= chr_list
;
4048 ChardevBackendInfoList
*qmp_query_chardev_backends(Error
**errp
)
4050 ChardevBackendInfoList
*backend_list
= NULL
;
4051 CharDriver
*c
= NULL
;
4054 for (i
= backends
; i
; i
= i
->next
) {
4055 ChardevBackendInfoList
*info
= g_malloc0(sizeof(*info
));
4057 info
->value
= g_malloc0(sizeof(*info
->value
));
4058 info
->value
->name
= g_strdup(c
->name
);
4060 info
->next
= backend_list
;
4061 backend_list
= info
;
4064 return backend_list
;
4067 CharDriverState
*qemu_chr_find(const char *name
)
4069 CharDriverState
*chr
;
4071 QTAILQ_FOREACH(chr
, &chardevs
, next
) {
4072 if (strcmp(chr
->label
, name
) != 0)
4079 /* Get a character (serial) device interface. */
4080 CharDriverState
*qemu_char_get_next_serial(void)
4082 static int next_serial
;
4083 CharDriverState
*chr
;
4085 /* FIXME: This function needs to go away: use chardev properties! */
4087 while (next_serial
< MAX_SERIAL_PORTS
&& serial_hds
[next_serial
]) {
4088 chr
= serial_hds
[next_serial
++];
4089 qemu_chr_fe_claim_no_fail(chr
);
4095 QemuOptsList qemu_chardev_opts
= {
4097 .implied_opt_name
= "backend",
4098 .head
= QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts
.head
),
4102 .type
= QEMU_OPT_STRING
,
4105 .type
= QEMU_OPT_STRING
,
4108 .type
= QEMU_OPT_STRING
,
4111 .type
= QEMU_OPT_STRING
,
4113 .name
= "localaddr",
4114 .type
= QEMU_OPT_STRING
,
4116 .name
= "localport",
4117 .type
= QEMU_OPT_STRING
,
4120 .type
= QEMU_OPT_NUMBER
,
4123 .type
= QEMU_OPT_BOOL
,
4126 .type
= QEMU_OPT_BOOL
,
4129 .type
= QEMU_OPT_BOOL
,
4132 .type
= QEMU_OPT_BOOL
,
4135 .type
= QEMU_OPT_BOOL
,
4137 .name
= "reconnect",
4138 .type
= QEMU_OPT_NUMBER
,
4141 .type
= QEMU_OPT_BOOL
,
4143 .name
= "tls-creds",
4144 .type
= QEMU_OPT_STRING
,
4147 .type
= QEMU_OPT_NUMBER
,
4150 .type
= QEMU_OPT_NUMBER
,
4153 .type
= QEMU_OPT_NUMBER
,
4156 .type
= QEMU_OPT_NUMBER
,
4159 .type
= QEMU_OPT_BOOL
,
4162 .type
= QEMU_OPT_BOOL
,
4165 .type
= QEMU_OPT_STRING
,
4168 .type
= QEMU_OPT_NUMBER
,
4171 .type
= QEMU_OPT_SIZE
,
4174 .type
= QEMU_OPT_STRING
,
4177 .type
= QEMU_OPT_BOOL
,
4180 .type
= QEMU_OPT_STRING
,
4182 .name
= "logappend",
4183 .type
= QEMU_OPT_BOOL
,
4185 { /* end of list */ }
4191 static CharDriverState
*qmp_chardev_open_file(const char *id
,
4192 ChardevBackend
*backend
,
4196 ChardevFile
*file
= backend
->u
.file
;
4197 ChardevCommon
*common
= qapi_ChardevFile_base(file
);
4201 error_setg(errp
, "input file not supported");
4205 out
= CreateFile(file
->out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
4206 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
4207 if (out
== INVALID_HANDLE_VALUE
) {
4208 error_setg(errp
, "open %s failed", file
->out
);
4211 return qemu_chr_open_win_file(out
, common
, errp
);
4214 static CharDriverState
*qmp_chardev_open_serial(const char *id
,
4215 ChardevBackend
*backend
,
4219 ChardevHostdev
*serial
= backend
->u
.serial
;
4220 ChardevCommon
*common
= qapi_ChardevHostdev_base(serial
);
4221 return qemu_chr_open_win_path(serial
->device
, common
, errp
);
4226 static int qmp_chardev_open_file_source(char *src
, int flags
,
4231 TFR(fd
= qemu_open(src
, flags
, 0666));
4233 error_setg_file_open(errp
, errno
, src
);
4238 static CharDriverState
*qmp_chardev_open_file(const char *id
,
4239 ChardevBackend
*backend
,
4243 ChardevFile
*file
= backend
->u
.file
;
4244 ChardevCommon
*common
= qapi_ChardevFile_base(file
);
4245 int flags
, in
= -1, out
;
4247 flags
= O_WRONLY
| O_CREAT
| O_BINARY
;
4248 if (file
->has_append
&& file
->append
) {
4254 out
= qmp_chardev_open_file_source(file
->out
, flags
, errp
);
4261 in
= qmp_chardev_open_file_source(file
->in
, flags
, errp
);
4268 return qemu_chr_open_fd(in
, out
, common
, errp
);
4271 #ifdef HAVE_CHARDEV_SERIAL
4272 static CharDriverState
*qmp_chardev_open_serial(const char *id
,
4273 ChardevBackend
*backend
,
4277 ChardevHostdev
*serial
= backend
->u
.serial
;
4278 ChardevCommon
*common
= qapi_ChardevHostdev_base(serial
);
4281 fd
= qmp_chardev_open_file_source(serial
->device
, O_RDWR
, errp
);
4285 qemu_set_nonblock(fd
);
4286 return qemu_chr_open_tty_fd(fd
, common
, errp
);
4290 #ifdef HAVE_CHARDEV_PARPORT
4291 static CharDriverState
*qmp_chardev_open_parallel(const char *id
,
4292 ChardevBackend
*backend
,
4296 ChardevHostdev
*parallel
= backend
->u
.parallel
;
4297 ChardevCommon
*common
= qapi_ChardevHostdev_base(parallel
);
4300 fd
= qmp_chardev_open_file_source(parallel
->device
, O_RDWR
, errp
);
4304 return qemu_chr_open_pp_fd(fd
, common
, errp
);
4310 static gboolean
socket_reconnect_timeout(gpointer opaque
)
4312 CharDriverState
*chr
= opaque
;
4313 TCPCharDriver
*s
= chr
->opaque
;
4314 QIOChannelSocket
*sioc
;
4316 s
->reconnect_timer
= 0;
4322 sioc
= qio_channel_socket_new();
4323 qio_channel_socket_connect_async(sioc
, s
->addr
,
4324 qemu_chr_socket_connected
,
4330 static CharDriverState
*qmp_chardev_open_socket(const char *id
,
4331 ChardevBackend
*backend
,
4335 CharDriverState
*chr
;
4337 ChardevSocket
*sock
= backend
->u
.socket
;
4338 SocketAddress
*addr
= sock
->addr
;
4339 bool do_nodelay
= sock
->has_nodelay
? sock
->nodelay
: false;
4340 bool is_listen
= sock
->has_server
? sock
->server
: true;
4341 bool is_telnet
= sock
->has_telnet
? sock
->telnet
: false;
4342 bool is_waitconnect
= sock
->has_wait
? sock
->wait
: false;
4343 int64_t reconnect
= sock
->has_reconnect
? sock
->reconnect
: 0;
4344 ChardevCommon
*common
= qapi_ChardevSocket_base(sock
);
4345 QIOChannelSocket
*sioc
= NULL
;
4347 chr
= qemu_chr_alloc(common
, errp
);
4351 s
= g_new0(TCPCharDriver
, 1);
4353 s
->is_unix
= addr
->type
== SOCKET_ADDRESS_KIND_UNIX
;
4354 s
->is_listen
= is_listen
;
4355 s
->is_telnet
= is_telnet
;
4356 s
->do_nodelay
= do_nodelay
;
4357 if (sock
->tls_creds
) {
4359 creds
= object_resolve_path_component(
4360 object_get_objects_root(), sock
->tls_creds
);
4362 error_setg(errp
, "No TLS credentials with id '%s'",
4366 s
->tls_creds
= (QCryptoTLSCreds
*)
4367 object_dynamic_cast(creds
,
4368 TYPE_QCRYPTO_TLS_CREDS
);
4369 if (!s
->tls_creds
) {
4370 error_setg(errp
, "Object with id '%s' is not TLS credentials",
4374 object_ref(OBJECT(s
->tls_creds
));
4376 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_SERVER
) {
4377 error_setg(errp
, "%s",
4378 "Expected TLS credentials for server endpoint");
4382 if (s
->tls_creds
->endpoint
!= QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT
) {
4383 error_setg(errp
, "%s",
4384 "Expected TLS credentials for client endpoint");
4390 qapi_copy_SocketAddress(&s
->addr
, sock
->addr
);
4393 chr
->chr_write
= tcp_chr_write
;
4394 chr
->chr_sync_read
= tcp_chr_sync_read
;
4395 chr
->chr_close
= tcp_chr_close
;
4396 chr
->get_msgfds
= tcp_get_msgfds
;
4397 chr
->set_msgfds
= tcp_set_msgfds
;
4398 chr
->chr_add_client
= tcp_chr_add_client
;
4399 chr
->chr_add_watch
= tcp_chr_add_watch
;
4400 chr
->chr_update_read_handler
= tcp_chr_update_read_handler
;
4401 /* be isn't opened until we get a connection */
4402 chr
->explicit_be_open
= true;
4404 chr
->filename
= SocketAddress_to_str("disconnected:",
4405 addr
, is_listen
, is_telnet
);
4409 s
->do_telnetopt
= 1;
4411 } else if (reconnect
> 0) {
4412 s
->reconnect_time
= reconnect
;
4415 sioc
= qio_channel_socket_new();
4416 if (s
->reconnect_time
) {
4417 qio_channel_socket_connect_async(sioc
, s
->addr
,
4418 qemu_chr_socket_connected
,
4420 } else if (s
->is_listen
) {
4421 if (qio_channel_socket_listen_sync(sioc
, s
->addr
, errp
) < 0) {
4424 s
->listen_ioc
= sioc
;
4425 if (is_waitconnect
) {
4426 fprintf(stderr
, "QEMU waiting for connection on: %s\n",
4428 tcp_chr_accept(QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
, chr
);
4430 qio_channel_set_blocking(QIO_CHANNEL(s
->listen_ioc
), false, NULL
);
4432 s
->listen_tag
= qio_channel_add_watch(
4433 QIO_CHANNEL(s
->listen_ioc
), G_IO_IN
, tcp_chr_accept
, chr
, NULL
);
4436 if (qio_channel_socket_connect_sync(sioc
, s
->addr
, errp
) < 0) {
4439 tcp_chr_new_client(chr
, sioc
);
4440 object_unref(OBJECT(sioc
));
4447 object_unref(OBJECT(sioc
));
4450 object_unref(OBJECT(s
->tls_creds
));
4453 qemu_chr_free_common(chr
);
4457 static CharDriverState
*qmp_chardev_open_udp(const char *id
,
4458 ChardevBackend
*backend
,
4462 ChardevUdp
*udp
= backend
->u
.udp
;
4463 ChardevCommon
*common
= qapi_ChardevUdp_base(udp
);
4464 QIOChannelSocket
*sioc
= qio_channel_socket_new();
4466 if (qio_channel_socket_dgram_sync(sioc
,
4467 udp
->local
, udp
->remote
,
4469 object_unref(OBJECT(sioc
));
4472 return qemu_chr_open_udp(sioc
, common
, errp
);
4475 ChardevReturn
*qmp_chardev_add(const char *id
, ChardevBackend
*backend
,
4478 ChardevReturn
*ret
= g_new0(ChardevReturn
, 1);
4479 CharDriverState
*chr
= NULL
;
4480 Error
*local_err
= NULL
;
4484 chr
= qemu_chr_find(id
);
4486 error_setg(errp
, "Chardev '%s' already exists", id
);
4491 for (i
= backends
; i
; i
= i
->next
) {
4494 if (cd
->kind
== backend
->type
) {
4495 chr
= cd
->create(id
, backend
, ret
, &local_err
);
4497 error_propagate(errp
, local_err
);
4506 error_setg(errp
, "chardev backend not available");
4510 chr
->label
= g_strdup(id
);
4511 chr
->avail_connections
=
4512 (backend
->type
== CHARDEV_BACKEND_KIND_MUX
) ? MAX_MUX
: 1;
4513 if (!chr
->filename
) {
4514 chr
->filename
= g_strdup(ChardevBackendKind_lookup
[backend
->type
]);
4516 if (!chr
->explicit_be_open
) {
4517 qemu_chr_be_event(chr
, CHR_EVENT_OPENED
);
4519 QTAILQ_INSERT_TAIL(&chardevs
, chr
, next
);
4527 void qmp_chardev_remove(const char *id
, Error
**errp
)
4529 CharDriverState
*chr
;
4531 chr
= qemu_chr_find(id
);
4533 error_setg(errp
, "Chardev '%s' not found", id
);
4536 if (chr
->chr_can_read
|| chr
->chr_read
||
4537 chr
->chr_event
|| chr
->handler_opaque
) {
4538 error_setg(errp
, "Chardev '%s' is busy", id
);
4543 "Chardev '%s' cannot be unplugged in record/replay mode", id
);
4546 qemu_chr_delete(chr
);
4549 static void register_types(void)
4551 register_char_driver("null", CHARDEV_BACKEND_KIND_NULL
, NULL
,
4552 qemu_chr_open_null
);
4553 register_char_driver("socket", CHARDEV_BACKEND_KIND_SOCKET
,
4554 qemu_chr_parse_socket
, qmp_chardev_open_socket
);
4555 register_char_driver("udp", CHARDEV_BACKEND_KIND_UDP
, qemu_chr_parse_udp
,
4556 qmp_chardev_open_udp
);
4557 register_char_driver("ringbuf", CHARDEV_BACKEND_KIND_RINGBUF
,
4558 qemu_chr_parse_ringbuf
, qemu_chr_open_ringbuf
);
4559 register_char_driver("file", CHARDEV_BACKEND_KIND_FILE
,
4560 qemu_chr_parse_file_out
, qmp_chardev_open_file
);
4561 register_char_driver("stdio", CHARDEV_BACKEND_KIND_STDIO
,
4562 qemu_chr_parse_stdio
, qemu_chr_open_stdio
);
4563 #if defined HAVE_CHARDEV_SERIAL
4564 register_char_driver("serial", CHARDEV_BACKEND_KIND_SERIAL
,
4565 qemu_chr_parse_serial
, qmp_chardev_open_serial
);
4566 register_char_driver("tty", CHARDEV_BACKEND_KIND_SERIAL
,
4567 qemu_chr_parse_serial
, qmp_chardev_open_serial
);
4569 #ifdef HAVE_CHARDEV_PARPORT
4570 register_char_driver("parallel", CHARDEV_BACKEND_KIND_PARALLEL
,
4571 qemu_chr_parse_parallel
, qmp_chardev_open_parallel
);
4572 register_char_driver("parport", CHARDEV_BACKEND_KIND_PARALLEL
,
4573 qemu_chr_parse_parallel
, qmp_chardev_open_parallel
);
4575 #ifdef HAVE_CHARDEV_PTY
4576 register_char_driver("pty", CHARDEV_BACKEND_KIND_PTY
, NULL
,
4580 register_char_driver("console", CHARDEV_BACKEND_KIND_CONSOLE
, NULL
,
4581 qemu_chr_open_win_con
);
4583 register_char_driver("pipe", CHARDEV_BACKEND_KIND_PIPE
,
4584 qemu_chr_parse_pipe
, qemu_chr_open_pipe
);
4585 register_char_driver("mux", CHARDEV_BACKEND_KIND_MUX
, qemu_chr_parse_mux
,
4587 /* Bug-compatibility: */
4588 register_char_driver("memory", CHARDEV_BACKEND_KIND_MEMORY
,
4589 qemu_chr_parse_ringbuf
, qemu_chr_open_ringbuf
);
4590 /* this must be done after machine init, since we register FEs with muxes
4591 * as part of realize functions like serial_isa_realizefn when -nographic
4594 qemu_add_machine_init_done_notifier(&muxes_realize_notify
);
4597 type_init(register_types
);