Commit a29753f8 authored by Anthony Liguori's avatar Anthony Liguori
Browse files

qemu-char: convert fd_chr to use a GIOChannel 



This uses the newly introduced IOWatchPoll source.

Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
Signed-off-by: default avatarAmit Shah <amit.shah@redhat.com>
Message-id: 0cb5d14510ee835a0ebc23676d10a2cce9280da5.1362505276.git.amit.shah@redhat.com
Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
parent 96c63847

qemu-char.c

+62 −41
Original line number Diff line number Diff line
@@ -541,7 +541,6 @@ int send_all(int fd, const void *_buf, int len1) 


#ifndef _WIN32



#if 0

typedef struct IOWatchPoll

{

    GSource *src;
@@ -679,60 +678,71 @@ static int io_channel_send_all(GIOChannel *fd, const void *_buf, int len1) 
    }

    return len1 - len;

}

#endif



typedef struct {

    int fd_in, fd_out;

typedef struct FDCharDriver {

    CharDriverState *chr;

    GIOChannel *fd_in, *fd_out;

    guint fd_in_tag;

    int max_size;

    QTAILQ_ENTRY(FDCharDriver) node;

} FDCharDriver;





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

{

    FDCharDriver *s = chr->opaque;

    return send_all(s->fd_out, buf, len);

}



static int fd_chr_read_poll(void *opaque)

{

    CharDriverState *chr = opaque;

    FDCharDriver *s = chr->opaque;

    

    s->max_size = qemu_chr_be_can_write(chr);

    return s->max_size;

    return io_channel_send_all(s->fd_out, buf, len);

}



static void fd_chr_read(void *opaque)

static gboolean fd_chr_read(GIOChannel *chan, GIOCondition cond, void *opaque)

{

    CharDriverState *chr = opaque;

    FDCharDriver *s = chr->opaque;

    int size, len;

    int len;

    uint8_t buf[READ_BUF_LEN];

    GIOStatus status;

    gsize bytes_read;



    len = sizeof(buf);

    if (len > s->max_size)

    if (len > s->max_size) {

        len = s->max_size;

    if (len == 0)

        return;

    size = read(s->fd_in, buf, len);

    if (size == 0) {

        /* FD has been closed. Remove it from the active list.  */

        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);

    }

    if (len == 0) {

        return FALSE;

    }



    status = g_io_channel_read_chars(chan, (gchar *)buf,

                                     len, &bytes_read, NULL);

    if (status == G_IO_STATUS_EOF) {

        qemu_chr_be_event(chr, CHR_EVENT_CLOSED);

        return;

        return FALSE;

    }

    if (size > 0) {

        qemu_chr_be_write(chr, buf, size);

    if (status == G_IO_STATUS_NORMAL) {

        qemu_chr_be_write(chr, buf, bytes_read);

    }



    return TRUE;

}



static int fd_chr_read_poll(void *opaque)

{

    CharDriverState *chr = opaque;

    FDCharDriver *s = chr->opaque;



    s->max_size = qemu_chr_be_can_write(chr);

    return s->max_size;

}



static void fd_chr_update_read_handler(CharDriverState *chr)

{

    FDCharDriver *s = chr->opaque;



    if (s->fd_in >= 0) {

        qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,

                             fd_chr_read, NULL, chr);

    if (s->fd_in_tag) {

        g_source_remove(s->fd_in_tag);

    }



    if (s->fd_in) {

        s->fd_in_tag = io_add_watch_poll(s->fd_in, fd_chr_read_poll, fd_chr_read, chr);

    }

}
@@ -740,8 +750,16 @@ static void fd_chr_close(struct CharDriverState *chr) 
{

    FDCharDriver *s = chr->opaque;



    if (s->fd_in >= 0) {

        qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);

    if (s->fd_in_tag) {

        g_source_remove(s->fd_in_tag);

        s->fd_in_tag = 0;

    }



    if (s->fd_in) {

        g_io_channel_unref(s->fd_in);

    }

    if (s->fd_out) {

        g_io_channel_unref(s->fd_out);

    }



    g_free(s);
@@ -756,8 +774,9 @@ static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out) 


    chr = g_malloc0(sizeof(CharDriverState));

    s = g_malloc0(sizeof(FDCharDriver));

    s->fd_in = fd_in;

    s->fd_out = fd_out;

    s->fd_in = io_channel_from_fd(fd_in);

    s->fd_out = io_channel_from_fd(fd_out);

    s->chr = chr;

    chr->opaque = s;

    chr->chr_write = fd_chr_write;

    chr->chr_update_read_handler = fd_chr_update_read_handler;
@@ -1230,22 +1249,24 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) 
    case CHR_IOCTL_SERIAL_SET_PARAMS:

        {

            QEMUSerialSetParams *ssp = arg;

            tty_serial_init(s->fd_in, ssp->speed, ssp->parity,

            tty_serial_init(g_io_channel_unix_get_fd(s->fd_in),

                            ssp->speed, ssp->parity,

                            ssp->data_bits, ssp->stop_bits);

        }

        break;

    case CHR_IOCTL_SERIAL_SET_BREAK:

        {

            int enable = *(int *)arg;

            if (enable)

                tcsendbreak(s->fd_in, 1);

            if (enable) {

                tcsendbreak(g_io_channel_unix_get_fd(s->fd_in), 1);

            }

        }

        break;

    case CHR_IOCTL_SERIAL_GET_TIOCM:

        {

            int sarg = 0;

            int *targ = (int *)arg;

            ioctl(s->fd_in, TIOCMGET, &sarg);

            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &sarg);

            *targ = 0;

            if (sarg & TIOCM_CTS)

                *targ |= CHR_TIOCM_CTS;
@@ -1265,7 +1286,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) 
        {

            int sarg = *(int *)arg;

            int targ = 0;

            ioctl(s->fd_in, TIOCMGET, &targ);

            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMGET, &targ);

            targ &= ~(CHR_TIOCM_CTS | CHR_TIOCM_CAR | CHR_TIOCM_DSR

                     | CHR_TIOCM_RI | CHR_TIOCM_DTR | CHR_TIOCM_RTS);

            if (sarg & CHR_TIOCM_CTS)
@@ -1280,7 +1301,7 @@ static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg) 
                targ |= TIOCM_DTR;

            if (sarg & CHR_TIOCM_RTS)

                targ |= TIOCM_RTS;

            ioctl(s->fd_in, TIOCMSET, &targ);

            ioctl(g_io_channel_unix_get_fd(s->fd_in), TIOCMSET, &targ);

        }

        break;

    default:
@@ -1295,7 +1316,7 @@ static void qemu_chr_close_tty(CharDriverState *chr) 
    int fd = -1;



    if (s) {

        fd = s->fd_in;

        fd = g_io_channel_unix_get_fd(s->fd_in);

    }



    fd_chr_close(chr);