Commit 4d43a603 authored by Marc-André Lureau's avatar Marc-André Lureau
Browse files

char: move CharBackend handling in char-fe unit 



Move all the frontend struct and methods to a seperate unit. This avoids
accidentally mixing backend and frontend calls, and helps with readabilty.

Make qemu_chr_replay() a macro shared by both char and char-fe.

Export qemu_chr_write(), and use a macro for qemu_chr_write_all()

(nb: yes, CharBackend is for char frontend :)

Signed-off-by: default avatarMarc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: default avatarPhilippe Mathieu-Daudé <f4bug@amsat.org>
parent c90e9392

backends/rng-egd.c

+1 −1
Original line number Diff line number Diff line
@@ -12,7 +12,7 @@ 


#include "qemu/osdep.h"

#include "sysemu/rng.h"

#include "chardev/char.h"

#include "chardev/char-fe.h"

#include "qapi/error.h"

#include "qapi/qmp/qerror.h"

chardev/Makefile.objs

+1 −0
Original line number Diff line number Diff line 
chardev-obj-y += char.o

chardev-obj-$(CONFIG_WIN32) += char-console.o

chardev-obj-$(CONFIG_POSIX) += char-fd.o

chardev-obj-y += char-fe.o

chardev-obj-y += char-file.o

chardev-obj-y += char-io.o

chardev-obj-y += char-mux.o

chardev/char-fe.c

0 → 100644
+358 −0
Original line number Diff line number Diff line 
/*

 * QEMU System Emulator

 *

 * Copyright (c) 2003-2008 Fabrice Bellard

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */

#include "qemu/osdep.h"

#include "qemu/error-report.h"

#include "qapi/error.h"

#include "qapi-visit.h"

#include "sysemu/replay.h"



#include "chardev/char-fe.h"

#include "chardev/char-io.h"

#include "chardev/char-mux.h"



int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return 0;

    }



    return qemu_chr_write(s, buf, len, false);

}



int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return 0;

    }



    return qemu_chr_write(s, buf, len, true);

}



int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)

{

    Chardev *s = be->chr;

    int offset = 0, counter = 10;

    int res;



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

        return 0;

    }



    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {

        return replay_char_read_all_load(buf);

    }



    while (offset < len) {

    retry:

        res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,

                                                  len - offset);

        if (res == -1 && errno == EAGAIN) {

            g_usleep(100);

            goto retry;

        }



        if (res == 0) {

            break;

        }



        if (res < 0) {

            if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {

                replay_char_read_all_save_error(res);

            }

            return res;

        }



        offset += res;



        if (!counter--) {

            break;

        }

    }



    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {

        replay_char_read_all_save_buf(buf, offset);

    }

    return offset;

}



int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)

{

    Chardev *s = be->chr;

    int res;



    if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {

        res = -ENOTSUP;

    } else {

        res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);

    }



    return res;

}



int qemu_chr_fe_get_msgfd(CharBackend *be)

{

    Chardev *s = be->chr;

    int fd;

    int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;

    if (s && qemu_chr_replay(s)) {

        error_report("Replay: get msgfd is not supported "

                     "for serial devices yet");

        exit(1);

    }

    return res;

}



int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return -1;

    }



    return CHARDEV_GET_CLASS(s)->get_msgfds ?

        CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;

}



int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)

{

    Chardev *s = be->chr;



    if (!s) {

        return -1;

    }



    return CHARDEV_GET_CLASS(s)->set_msgfds ?

        CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;

}



void qemu_chr_fe_accept_input(CharBackend *be)

{

    Chardev *s = be->chr;



    if (!s) {

        return;

    }



    if (CHARDEV_GET_CLASS(s)->chr_accept_input) {

        CHARDEV_GET_CLASS(s)->chr_accept_input(s);

    }

    qemu_notify_event();

}



void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)

{

    char buf[CHR_READ_BUF_LEN];

    va_list ap;

    va_start(ap, fmt);

    vsnprintf(buf, sizeof(buf), fmt, ap);

    /* XXX this blocks entire thread. Rewrite to use

     * qemu_chr_fe_write and background I/O callbacks */

    qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));

    va_end(ap);

}



Chardev *qemu_chr_fe_get_driver(CharBackend *be)

{

    return be->chr;

}



bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)

{

    int tag = 0;



    if (CHARDEV_IS_MUX(s)) {

        MuxChardev *d = MUX_CHARDEV(s);



        if (d->mux_cnt >= MAX_MUX) {

            goto unavailable;

        }



        d->backends[d->mux_cnt] = b;

        tag = d->mux_cnt++;

    } else if (s->be) {

        goto unavailable;

    } else {

        s->be = b;

    }



    b->fe_open = false;

    b->tag = tag;

    b->chr = s;

    return true;



unavailable:

    error_setg(errp, QERR_DEVICE_IN_USE, s->label);

    return false;

}



void qemu_chr_fe_deinit(CharBackend *b)

{

    assert(b);



    if (b->chr) {

        qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);

        if (b->chr->be == b) {

            b->chr->be = NULL;

        }

        if (CHARDEV_IS_MUX(b->chr)) {

            MuxChardev *d = MUX_CHARDEV(b->chr);

            d->backends[b->tag] = NULL;

        }

        b->chr = NULL;

    }

}



void qemu_chr_fe_set_handlers(CharBackend *b,

                              IOCanReadHandler *fd_can_read,

                              IOReadHandler *fd_read,

                              IOEventHandler *fd_event,

                              void *opaque,

                              GMainContext *context,

                              bool set_open)

{

    Chardev *s;

    ChardevClass *cc;

    int fe_open;



    s = b->chr;

    if (!s) {

        return;

    }



    cc = CHARDEV_GET_CLASS(s);

    if (!opaque && !fd_can_read && !fd_read && !fd_event) {

        fe_open = 0;

        remove_fd_in_watch(s);

    } else {

        fe_open = 1;

    }

    b->chr_can_read = fd_can_read;

    b->chr_read = fd_read;

    b->chr_event = fd_event;

    b->opaque = opaque;

    if (cc->chr_update_read_handler) {

        cc->chr_update_read_handler(s, context);

    }



    if (set_open) {

        qemu_chr_fe_set_open(b, fe_open);

    }



    if (fe_open) {

        qemu_chr_fe_take_focus(b);

        /* We're connecting to an already opened device, so let's make sure we

           also get the open event */

        if (s->be_open) {

            qemu_chr_be_event(s, CHR_EVENT_OPENED);

        }

    }



    if (CHARDEV_IS_MUX(s)) {

        mux_chr_set_handlers(s, context);

    }

}



void qemu_chr_fe_take_focus(CharBackend *b)

{

    if (!b->chr) {

        return;

    }



    if (CHARDEV_IS_MUX(b->chr)) {

        mux_set_focus(b->chr, b->tag);

    }

}



int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)

{

    if (!be->chr) {

        error_setg(errp, "missing associated backend");

        return -1;

    }



    return qemu_chr_wait_connected(be->chr, errp);

}



void qemu_chr_fe_set_echo(CharBackend *be, bool echo)

{

    Chardev *chr = be->chr;



    if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {

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

    }

}



void qemu_chr_fe_set_open(CharBackend *be, int fe_open)

{

    Chardev *chr = be->chr;



    if (!chr) {

        return;

    }



    if (be->fe_open == fe_open) {

        return;

    }

    be->fe_open = fe_open;

    if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {

        CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);

    }

}



guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,

                            GIOFunc func, void *user_data)

{

    Chardev *s = be->chr;

    GSource *src;

    guint tag;



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

        return 0;

    }



    src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);

    if (!src) {

        return 0;

    }



    g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);

    tag = g_source_attach(src, NULL);

    g_source_unref(src);



    return tag;

}



void qemu_chr_fe_disconnect(CharBackend *be)

{

    Chardev *chr = be->chr;



    if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {

        CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);

    }

}

chardev/char.c

+1 −342
Original line number Diff line number Diff line
@@ -22,7 +22,6 @@ 
 * THE SOFTWARE.

 */

#include "qemu/osdep.h"

#include "qemu-common.h"

#include "qemu/cutils.h"

#include "monitor/monitor.h"

#include "sysemu/sysemu.h"
@@ -35,9 +34,6 @@ 
#include "qemu/help_option.h"



#include "chardev/char-mux.h"

#include "chardev/char-io.h"

#include "chardev/char-parallel.h"

#include "chardev/char-serial.h"



/***********************************************************/

/* character device */
@@ -129,13 +125,7 @@ static int qemu_chr_fe_write_buffer(Chardev *s, 
    return res;

}



static bool qemu_chr_replay(Chardev *chr)

{

    return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY);

}



static int qemu_chr_write(Chardev *s, const uint8_t *buf, int len,

                          bool write_all)

int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, bool write_all)

{

    int offset = 0;

    int res;
@@ -159,94 +149,6 @@ static int qemu_chr_write(Chardev *s, const uint8_t *buf, int len, 
    return offset;

}



int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)

{

    return qemu_chr_write(s, buf, len, true);

}



int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return 0;

    }



    return qemu_chr_write(s, buf, len, false);

}



int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return 0;

    }



    return qemu_chr_write(s, buf, len, true);

}



int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)

{

    Chardev *s = be->chr;

    int offset = 0, counter = 10;

    int res;



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

        return 0;

    }



    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {

        return replay_char_read_all_load(buf);

    }



    while (offset < len) {

    retry:

        res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,

                                                  len - offset);

        if (res == -1 && errno == EAGAIN) {

            g_usleep(100);

            goto retry;

        }



        if (res == 0) {

            break;

        }



        if (res < 0) {

            if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {

                replay_char_read_all_save_error(res);

            }

            return res;

        }



        offset += res;



        if (!counter--) {

            break;

        }

    }



    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {

        replay_char_read_all_save_buf(buf, offset);

    }

    return offset;

}



int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)

{

    Chardev *s = be->chr;

    int res;



    if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {

        res = -ENOTSUP;

    } else {

        res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);

    }



    return res;

}



int qemu_chr_be_can_write(Chardev *s)

{

    CharBackend *be = s->be;
@@ -279,75 +181,12 @@ void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len) 
    }

}



int qemu_chr_fe_get_msgfd(CharBackend *be)

{

    Chardev *s = be->chr;

    int fd;

    int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;

    if (s && qemu_chr_replay(s)) {

        error_report("Replay: get msgfd is not supported "

                     "for serial devices yet");

        exit(1);

    }

    return res;

}



int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)

{

    Chardev *s = be->chr;



    if (!s) {

        return -1;

    }



    return CHARDEV_GET_CLASS(s)->get_msgfds ?

        CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;

}



int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)

{

    Chardev *s = be->chr;



    if (!s) {

        return -1;

    }



    return CHARDEV_GET_CLASS(s)->set_msgfds ?

        CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;

}



int qemu_chr_add_client(Chardev *s, int fd)

{

    return CHARDEV_GET_CLASS(s)->chr_add_client ?

        CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;

}



void qemu_chr_fe_accept_input(CharBackend *be)

{

    Chardev *s = be->chr;



    if (!s) {

        return;

    }



    if (CHARDEV_GET_CLASS(s)->chr_accept_input) {

        CHARDEV_GET_CLASS(s)->chr_accept_input(s);

    }

    qemu_notify_event();

}



void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)

{

    char buf[CHR_READ_BUF_LEN];

    va_list ap;

    va_start(ap, fmt);

    vsnprintf(buf, sizeof(buf), fmt, ap);

    /* XXX this blocks entire thread. Rewrite to use

     * qemu_chr_fe_write and background I/O callbacks */

    qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));

    va_end(ap);

}



static void qemu_char_open(Chardev *chr, ChardevBackend *backend,

                           bool *be_opened, Error **errp)

{
@@ -459,40 +298,6 @@ static Notifier muxes_realize_notify = { 
    .notify = muxes_realize_done,

};



Chardev *qemu_chr_fe_get_driver(CharBackend *be)

{

    return be->chr;

}



bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)

{

    int tag = 0;



    if (CHARDEV_IS_MUX(s)) {

        MuxChardev *d = MUX_CHARDEV(s);



        if (d->mux_cnt >= MAX_MUX) {

            goto unavailable;

        }



        d->backends[d->mux_cnt] = b;

        tag = d->mux_cnt++;

    } else if (s->be) {

        goto unavailable;

    } else {

        s->be = b;

    }



    b->fe_open = false;

    b->tag = tag;

    b->chr = s;

    return true;



unavailable:

    error_setg(errp, QERR_DEVICE_IN_USE, s->label);

    return false;

}



static bool qemu_chr_is_busy(Chardev *s)

{

    if (CHARDEV_IS_MUX(s)) {
@@ -503,84 +308,6 @@ static bool qemu_chr_is_busy(Chardev *s) 
    }

}



void qemu_chr_fe_deinit(CharBackend *b)

{

    assert(b);



    if (b->chr) {

        qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);

        if (b->chr->be == b) {

            b->chr->be = NULL;

        }

        if (CHARDEV_IS_MUX(b->chr)) {

            MuxChardev *d = MUX_CHARDEV(b->chr);

            d->backends[b->tag] = NULL;

        }

        b->chr = NULL;

    }

}



void qemu_chr_fe_set_handlers(CharBackend *b,

                              IOCanReadHandler *fd_can_read,

                              IOReadHandler *fd_read,

                              IOEventHandler *fd_event,

                              void *opaque,

                              GMainContext *context,

                              bool set_open)

{

    Chardev *s;

    ChardevClass *cc;

    int fe_open;



    s = b->chr;

    if (!s) {

        return;

    }



    cc = CHARDEV_GET_CLASS(s);

    if (!opaque && !fd_can_read && !fd_read && !fd_event) {

        fe_open = 0;

        remove_fd_in_watch(s);

    } else {

        fe_open = 1;

    }

    b->chr_can_read = fd_can_read;

    b->chr_read = fd_read;

    b->chr_event = fd_event;

    b->opaque = opaque;

    if (cc->chr_update_read_handler) {

        cc->chr_update_read_handler(s, context);

    }



    if (set_open) {

        qemu_chr_fe_set_open(b, fe_open);

    }



    if (fe_open) {

        qemu_chr_fe_take_focus(b);

        /* We're connecting to an already opened device, so let's make sure we

           also get the open event */

        if (s->be_open) {

            qemu_chr_be_event(s, CHR_EVENT_OPENED);

        }

    }



    if (CHARDEV_IS_MUX(s)) {

        mux_chr_set_handlers(s, context);

    }

}



void qemu_chr_fe_take_focus(CharBackend *b)

{

    if (!b->chr) {

        return;

    }



    if (CHARDEV_IS_MUX(b->chr)) {

        mux_set_focus(b->chr, b->tag);

    }

}



int qemu_chr_wait_connected(Chardev *chr, Error **errp)

{

    ChardevClass *cc = CHARDEV_GET_CLASS(chr);
@@ -592,16 +319,6 @@ int qemu_chr_wait_connected(Chardev *chr, Error **errp) 
    return 0;

}



int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)

{

    if (!be->chr) {

        error_setg(errp, "missing associated backend");

        return -1;

    }



    return qemu_chr_wait_connected(be->chr, errp);

}



QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)

{

    char host[65], port[33], width[8], height[8];
@@ -978,64 +695,6 @@ Chardev *qemu_chr_new(const char *label, const char *filename) 
    return chr;

}



void qemu_chr_fe_set_echo(CharBackend *be, bool echo)

{

    Chardev *chr = be->chr;



    if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {

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

    }

}



void qemu_chr_fe_set_open(CharBackend *be, int fe_open)

{

    Chardev *chr = be->chr;



    if (!chr) {

        return;

    }



    if (be->fe_open == fe_open) {

        return;

    }

    be->fe_open = fe_open;

    if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {

        CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);

    }

}



guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,

                            GIOFunc func, void *user_data)

{

    Chardev *s = be->chr;

    GSource *src;

    guint tag;



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

        return 0;

    }



    src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);

    if (!src) {

        return 0;

    }



    g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);

    tag = g_source_attach(src, NULL);

    g_source_unref(src);



    return tag;

}



void qemu_chr_fe_disconnect(CharBackend *be)

{

    Chardev *chr = be->chr;



    if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {

        CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);

    }

}



static int qmp_query_chardev_foreach(Object *obj, void *data)

{

    Chardev *chr = CHARDEV(obj);

gdbstub.c

+1 −0
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#else

#include "monitor/monitor.h"

#include "chardev/char.h"

#include "chardev/char-fe.h"

#include "sysemu/sysemu.h"

#include "exec/gdbstub.h"

#endif