#include <sys/select.h>
#ifdef CONFIG_BSD
#include <sys/stat.h>
-#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
-#include <libutil.h>
-#include <dev/ppbus/ppi.h>
-#include <dev/ppbus/ppbconf.h>
#if defined(__GLIBC__)
#include <pty.h>
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
+#include <libutil.h>
+#else
+#include <util.h>
#endif
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+#include <dev/ppbus/ppi.h>
+#include <dev/ppbus/ppbconf.h>
#elif defined(__DragonFly__)
-#include <libutil.h>
#include <dev/misc/ppi/ppi.h>
#include <bus/ppbus/ppbconf.h>
-#else
-#include <util.h>
#endif
#else
#ifdef __linux__
static QTAILQ_HEAD(CharDriverStateHead, CharDriverState) chardevs =
QTAILQ_HEAD_INITIALIZER(chardevs);
-static void qemu_chr_event(CharDriverState *s, int event)
+void qemu_chr_be_event(CharDriverState *s, int event)
{
/* Keep track if the char device is open */
switch (event) {
static void qemu_chr_generic_open_bh(void *opaque)
{
CharDriverState *s = opaque;
- qemu_chr_event(s, CHR_EVENT_OPENED);
+ qemu_chr_be_event(s, CHR_EVENT_OPENED);
qemu_bh_delete(s->bh);
s->bh = NULL;
}
void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
{
- s->chr_read(s->handler_opaque, buf, len);
+ if (s->chr_read) {
+ s->chr_read(s->handler_opaque, buf, len);
+ }
}
int qemu_chr_fe_get_msgfd(CharDriverState *s)
{
if (s->chr_accept_input)
s->chr_accept_input(s);
+ qemu_notify_event();
}
void qemu_chr_fe_printf(CharDriverState *s, const char *fmt, ...)
return len;
}
-static int qemu_chr_open_null(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_null(QemuOpts *opts)
{
CharDriverState *chr;
chr = g_malloc0(sizeof(CharDriverState));
chr->chr_write = null_chr_write;
-
- *_chr= chr;
- return 0;
+ return chr;
}
/* MUX driver for serial I/O splitting */
bdrv_commit_all();
break;
case 'b':
- qemu_chr_event(chr, CHR_EVENT_BREAK);
+ qemu_chr_be_event(chr, CHR_EVENT_BREAK);
break;
case 'c':
/* Switch to the next registered device */
if (size == 0) {
/* FD has been closed. Remove it from the active list. */
qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
return;
}
if (size > 0) {
}
g_free(s);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
/* open a character device to a unix fd */
return chr;
}
-static int qemu_chr_open_file_out(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_file_out(QemuOpts *opts)
{
int fd_out;
TFR(fd_out = qemu_open(qemu_opt_get(opts, "path"),
O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
if (fd_out < 0) {
- return -errno;
+ return NULL;
}
-
- *_chr = qemu_chr_open_fd(-1, fd_out);
- return 0;
+ return qemu_chr_open_fd(-1, fd_out);
}
-static int qemu_chr_open_pipe(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_pipe(QemuOpts *opts)
{
int fd_in, fd_out;
char filename_in[256], filename_out[256];
if (filename == NULL) {
fprintf(stderr, "chardev: pipe: no filename given\n");
- return -EINVAL;
+ return NULL;
}
snprintf(filename_in, 256, "%s.in", filename);
close(fd_out);
TFR(fd_in = fd_out = qemu_open(filename, O_RDWR | O_BINARY));
if (fd_in < 0) {
- return -errno;
+ return NULL;
}
}
-
- *_chr = qemu_chr_open_fd(fd_in, fd_out);
- return 0;
+ return qemu_chr_open_fd(fd_in, fd_out);
}
if (size == 0) {
/* stdin has been closed. Remove it from the active list. */
qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
return;
}
if (size > 0) {
fd_chr_close(chr);
}
-static int qemu_chr_open_stdio(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_stdio(QemuOpts *opts)
{
CharDriverState *chr;
if (stdio_nb_clients >= STDIO_MAX_CLIENTS) {
- return -EBUSY;
+ return NULL;
}
-
if (stdio_nb_clients == 0) {
old_fd0_flags = fcntl(0, F_GETFL);
tcgetattr (0, &oldtty);
display_type != DT_NOGRAPHIC);
qemu_chr_fe_set_echo(chr, false);
- *_chr = chr;
- return 0;
+ return chr;
}
#ifdef __sun__
qemu_del_timer(s->timer);
qemu_free_timer(s->timer);
g_free(s);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
-static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
{
CharDriverState *chr;
PtyCharDriver *s;
struct termios tty;
- int slave_fd, len;
+ int master_fd, slave_fd, len;
#if defined(__OpenBSD__) || defined(__DragonFly__)
char pty_name[PATH_MAX];
#define q_ptsname(x) pty_name
#define q_ptsname(x) ptsname(x)
#endif
- chr = g_malloc0(sizeof(CharDriverState));
- s = g_malloc0(sizeof(PtyCharDriver));
-
- if (openpty(&s->fd, &slave_fd, pty_name, NULL, NULL) < 0) {
- return -errno;
+ if (openpty(&master_fd, &slave_fd, pty_name, NULL, NULL) < 0) {
+ return NULL;
}
/* Set raw attributes on the pty. */
tcsetattr(slave_fd, TCSAFLUSH, &tty);
close(slave_fd);
- len = strlen(q_ptsname(s->fd)) + 5;
+ chr = g_malloc0(sizeof(CharDriverState));
+
+ len = strlen(q_ptsname(master_fd)) + 5;
chr->filename = g_malloc(len);
- snprintf(chr->filename, len, "pty:%s", q_ptsname(s->fd));
- qemu_opt_set(opts, "path", q_ptsname(s->fd));
- fprintf(stderr, "char device redirected to %s\n", q_ptsname(s->fd));
+ snprintf(chr->filename, len, "pty:%s", q_ptsname(master_fd));
+ qemu_opt_set(opts, "path", q_ptsname(master_fd));
+ fprintf(stderr, "char device redirected to %s\n", q_ptsname(master_fd));
+ s = g_malloc0(sizeof(PtyCharDriver));
chr->opaque = s;
chr->chr_write = pty_chr_write;
chr->chr_update_read_handler = pty_chr_update_read_handler;
chr->chr_close = pty_chr_close;
+ s->fd = master_fd;
s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
- *_chr = chr;
- return 0;
+ return chr;
}
static void tty_serial_init(int fd, int speed,
}
}
-static int qemu_chr_open_tty(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_tty(QemuOpts *opts)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
TFR(fd = qemu_open(filename, O_RDWR | O_NONBLOCK));
if (fd < 0) {
- return -errno;
+ return NULL;
}
tty_serial_init(fd, 115200, 'N', 8, 1);
chr = qemu_chr_open_fd(fd, fd);
chr->chr_ioctl = tty_serial_ioctl;
chr->chr_close = qemu_chr_close_tty;
-
- *_chr = chr;
- return 0;
+ return chr;
}
#else /* ! __linux__ && ! __sun__ */
-static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
{
- return -ENOTSUP;
+ return NULL;
}
#endif /* __linux__ || __sun__ */
ioctl(fd, PPRELEASE);
close(fd);
g_free(drv);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
-static int qemu_chr_open_pp(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
ParallelCharDriver *drv;
int fd;
- TFR(fd = open(filename, O_RDWR));
+ TFR(fd = qemu_open(filename, O_RDWR));
if (fd < 0) {
- return -errno;
+ return NULL;
}
if (ioctl(fd, PPCLAIM) < 0) {
close(fd);
- return -errno;
+ return NULL;
}
drv = g_malloc0(sizeof(ParallelCharDriver));
qemu_chr_generic_open(chr);
- *_chr = chr;
- return 0;
+ return chr;
}
#endif /* __linux__ */
return 0;
}
-static int qemu_chr_open_pp(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_pp(QemuOpts *opts)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
fd = qemu_open(filename, O_RDWR);
if (fd < 0) {
- return -errno;
+ return NULL;
}
chr = g_malloc0(sizeof(CharDriverState));
chr->opaque = (void *)(intptr_t)fd;
chr->chr_write = null_chr_write;
chr->chr_ioctl = pp_ioctl;
-
- *_chr = chr;
- return 0;
+ return chr;
}
#endif
else
qemu_del_polling_cb(win_chr_poll, chr);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
static int win_chr_init(CharDriverState *chr, const char *filename)
return 0;
}
-static int qemu_chr_open_win(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_win(QemuOpts *opts)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
if (win_chr_init(chr, filename) < 0) {
g_free(s);
g_free(chr);
- return -EIO;
+ return NULL;
}
qemu_chr_generic_open(chr);
-
- *_chr = chr;
- return 0;
+ return chr;
}
static int win_chr_pipe_poll(void *opaque)
}
-static int qemu_chr_open_win_pipe(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_win_pipe(QemuOpts *opts)
{
const char *filename = qemu_opt_get(opts, "path");
CharDriverState *chr;
if (win_chr_pipe_init(chr, filename) < 0) {
g_free(s);
g_free(chr);
- return -EIO;
+ return NULL;
}
qemu_chr_generic_open(chr);
-
- *_chr = chr;
- return 0;
+ return chr;
}
-static int qemu_chr_open_win_file(HANDLE fd_out, CharDriverState **pchr)
+static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
{
CharDriverState *chr;
WinCharState *s;
chr->opaque = s;
chr->chr_write = win_chr_write;
qemu_chr_generic_open(chr);
- *pchr = chr;
- return 0;
+ return chr;
}
-static int qemu_chr_open_win_con(QemuOpts *opts, CharDriverState **chr)
+static CharDriverState *qemu_chr_open_win_con(QemuOpts *opts)
{
- return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE), chr);
+ return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
}
-static int qemu_chr_open_win_file_out(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_win_file_out(QemuOpts *opts)
{
const char *file_out = qemu_opt_get(opts, "path");
HANDLE fd_out;
fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (fd_out == INVALID_HANDLE_VALUE) {
- return -EIO;
+ return NULL;
}
- return qemu_chr_open_win_file(fd_out, _chr);
+ return qemu_chr_open_win_file(fd_out);
}
static int win_stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
stdio_nb_clients--;
}
-static int qemu_chr_open_win_stdio(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_win_stdio(QemuOpts *opts)
{
CharDriverState *chr;
WinStdioCharState *stdio;
if (stdio_nb_clients >= STDIO_MAX_CLIENTS
|| ((display_type != DT_NOGRAPHIC) && (stdio_nb_clients != 0))) {
- return -EIO;
+ return NULL;
}
chr = g_malloc0(sizeof(CharDriverState));
chr->chr_set_echo = qemu_chr_set_echo_win_stdio;
qemu_chr_fe_set_echo(chr, false);
- *_chr = chr;
-
- return 0;
+ return chr;
}
#endif /* !_WIN32 */
closesocket(s->fd);
}
g_free(s);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
-static int qemu_chr_open_udp(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_udp(QemuOpts *opts)
{
CharDriverState *chr = NULL;
NetCharDriver *s = NULL;
int fd = -1;
- int ret;
chr = g_malloc0(sizeof(CharDriverState));
s = g_malloc0(sizeof(NetCharDriver));
fd = inet_dgram_opts(opts);
if (fd < 0) {
fprintf(stderr, "inet_dgram_opts failed\n");
- ret = -errno;
goto return_err;
}
chr->chr_write = udp_chr_write;
chr->chr_update_read_handler = udp_chr_update_read_handler;
chr->chr_close = udp_chr_close;
-
- *_chr = chr;
- return 0;
+ return chr;
return_err:
g_free(chr);
if (fd >= 0) {
closesocket(fd);
}
- return ret;
+ return NULL;
}
/***********************************************************/
} else {
if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
/* Handle IAC break commands by sending a serial break */
- qemu_chr_event(chr, CHR_EVENT_BREAK);
+ qemu_chr_be_event(chr, CHR_EVENT_BREAK);
s->do_telnetopt++;
}
s->do_telnetopt++;
if (fd < 0)
continue;
+#ifndef MSG_CMSG_CLOEXEC
+ qemu_set_cloexec(fd);
+#endif
if (s->msgfd != -1)
close(s->msgfd);
s->msgfd = fd;
struct cmsghdr cmsg;
char control[CMSG_SPACE(sizeof(int))];
} msg_control;
+ int flags = 0;
ssize_t ret;
iov[0].iov_base = buf;
msg.msg_control = &msg_control;
msg.msg_controllen = sizeof(msg_control);
- ret = recvmsg(s->fd, &msg, 0);
- if (ret > 0 && s->is_unix)
+#ifdef MSG_CMSG_CLOEXEC
+ flags |= MSG_CMSG_CLOEXEC;
+#endif
+ ret = recvmsg(s->fd, &msg, flags);
+ if (ret > 0 && s->is_unix) {
unix_process_msgfd(chr, &msg);
+ }
return ret;
}
qemu_set_fd_handler2(s->fd, NULL, NULL, NULL, NULL);
closesocket(s->fd);
s->fd = -1;
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
} else if (size > 0) {
if (s->do_telnetopt)
tcp_chr_process_IAC_bytes(chr, s, buf, &size);
TCPCharDriver *s = chr->opaque;
s->connected = 1;
- qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
- tcp_chr_read, NULL, chr);
+ if (s->fd >= 0) {
+ qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
+ tcp_chr_read, NULL, chr);
+ }
qemu_chr_generic_open(chr);
}
closesocket(s->listen_fd);
}
g_free(s);
- qemu_chr_event(chr, CHR_EVENT_CLOSED);
+ qemu_chr_be_event(chr, CHR_EVENT_CLOSED);
}
-static int qemu_chr_open_socket(QemuOpts *opts, CharDriverState **_chr)
+static CharDriverState *qemu_chr_open_socket(QemuOpts *opts)
{
CharDriverState *chr = NULL;
TCPCharDriver *s = NULL;
int do_nodelay;
int is_unix;
int is_telnet;
- int ret;
is_listen = qemu_opt_get_bool(opts, "server", 0);
is_waitconnect = qemu_opt_get_bool(opts, "wait", 1);
}
} else {
if (is_listen) {
- fd = inet_listen_opts(opts, 0);
+ fd = inet_listen_opts(opts, 0, NULL);
} else {
- fd = inet_connect_opts(opts);
+ fd = inet_connect_opts(opts, NULL, NULL, NULL);
}
}
if (fd < 0) {
- ret = -errno;
goto fail;
}
tcp_chr_accept(chr);
socket_set_nonblock(s->listen_fd);
}
-
- *_chr = chr;
- return 0;
+ return chr;
fail:
if (fd >= 0)
closesocket(fd);
g_free(s);
g_free(chr);
- return ret;
+ return NULL;
}
/***********************************************************/
int pos;
const char *p;
QemuOpts *opts;
+ Error *local_err = NULL;
- opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1);
- if (NULL == opts)
+ opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
+ if (error_is_set(&local_err)) {
+ qerror_report_err(local_err);
+ error_free(local_err);
return NULL;
+ }
if (strstart(filename, "mon:", &p)) {
filename = p;
static const struct {
const char *name;
- int (*open)(QemuOpts *opts, CharDriverState **chr);
+ CharDriverState *(*open)(QemuOpts *opts);
} backend_table[] = {
{ .name = "null", .open = qemu_chr_open_null },
{ .name = "socket", .open = qemu_chr_open_socket },
{
CharDriverState *chr;
int i;
- int ret;
if (qemu_opts_id(opts) == NULL) {
fprintf(stderr, "chardev: no id specified\n");
return NULL;
}
- ret = backend_table[i].open(opts, &chr);
- if (ret < 0) {
- fprintf(stderr, "chardev: opening backend \"%s\" failed: %s\n",
- qemu_opt_get(opts, "backend"), strerror(-ret));
+ chr = backend_table[i].open(opts);
+ if (!chr) {
+ fprintf(stderr, "chardev: opening backend \"%s\" failed\n",
+ qemu_opt_get(opts, "backend"));
return NULL;
}
}
return NULL;
}
+
+/* Get a character (serial) device interface. */
+CharDriverState *qemu_char_get_next_serial(void)
+{
+ static int next_serial;
+
+ /* FIXME: This function needs to go away: use chardev properties! */
+ return serial_hds[next_serial++];
+}
+
projects / qemu.git / blobdiff