[qemu.git] / chardev / char-fe.c

/*
 * 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/qmp/qerror.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;
    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 (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)
{
    /* this is unsafe for the users that support chardev hotswap */
    assert(be->chr_be_change == NULL);
    return be->chr;
}

bool qemu_chr_fe_backend_connected(CharBackend *be)
{
    return !!be->chr;
}

bool qemu_chr_fe_backend_open(CharBackend *be)
{
    return be->chr && be->chr->be_open;
}

bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
{
    int tag = 0;

    if (s) {
        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, bool del)
{
    assert(b);

    if (b->chr) {
        qemu_chr_fe_set_handlers(b, NULL, 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;
        }
        if (del) {
            Object *obj = OBJECT(b->chr);
            if (obj->parent) {
                object_unparent(obj);
            } else {
                object_unref(obj);
            }
        }
        b->chr = NULL;
    }
}

void qemu_chr_fe_set_handlers(CharBackend *b,
                              IOCanReadHandler *fd_can_read,
                              IOReadHandler *fd_read,
                              IOEventHandler *fd_event,
                              BackendChangeHandler *be_change,
                              void *opaque,
                              GMainContext *context,
                              bool set_open)
{
    Chardev *s;
    int fe_open;

    s = b->chr;
    if (!s) {
        return;
    }

    if (!opaque && !fd_can_read && !fd_read && !fd_event) {
        fe_open = 0;
        remove_fd_in_watch(s);
    } else {
        fe_open = 1;
    }
    b->chr_can_read = fd_can_read;
    b->chr_read = fd_read;
    b->chr_event = fd_event;
    b->chr_be_change = be_change;
    b->opaque = opaque;

    qemu_chr_be_update_read_handlers(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, s->gcontext);
    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);
    }
}
Commit	Line	Data
4d43a603 MAL	1	/*
	2	* QEMU System Emulator
	3	*
	4	* Copyright (c) 2003-2008 Fabrice Bellard
	5	*
	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:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	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
	22	* THE SOFTWARE.
	23	*/
	24	#include "qemu/osdep.h"
	25	#include "qemu/error-report.h"
	26	#include "qapi/error.h"
0dd13589	27	#include "qapi/qmp/qerror.h"
4d43a603 MAL	28	#include "sysemu/replay.h"
	29
	30	#include "chardev/char-fe.h"
	31	#include "chardev/char-io.h"
	32	#include "chardev/char-mux.h"
	33
	34	int qemu_chr_fe_write(CharBackend be, const uint8_t buf, int len)
	35	{
	36	Chardev *s = be->chr;
	37
	38	if (!s) {
	39	return 0;
	40	}
	41
	42	return qemu_chr_write(s, buf, len, false);
	43	}
	44
	45	int qemu_chr_fe_write_all(CharBackend be, const uint8_t buf, int len)
	46	{
	47	Chardev *s = be->chr;
	48
	49	if (!s) {
	50	return 0;
	51	}
	52
	53	return qemu_chr_write(s, buf, len, true);
	54	}
	55
	56	int qemu_chr_fe_read_all(CharBackend be, uint8_t buf, int len)
	57	{
	58	Chardev *s = be->chr;
43182856	59	int offset = 0;
4d43a603 MAL	60	int res;
	61
	62	if (!s \|\| !CHARDEV_GET_CLASS(s)->chr_sync_read) {
	63	return 0;
	64	}
	65
	66	if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
	67	return replay_char_read_all_load(buf);
	68	}
	69
	70	while (offset < len) {
	71	retry:
	72	res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
	73	len - offset);
	74	if (res == -1 && errno == EAGAIN) {
	75	g_usleep(100);
	76	goto retry;
	77	}
	78
	79	if (res == 0) {
	80	break;
	81	}
	82
	83	if (res < 0) {
	84	if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
	85	replay_char_read_all_save_error(res);
	86	}
	87	return res;
	88	}
	89
	90	offset += res;
4d43a603 MAL	91	}
	92
	93	if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
	94	replay_char_read_all_save_buf(buf, offset);
	95	}
	96	return offset;
	97	}
	98
	99	int qemu_chr_fe_ioctl(CharBackend be, int cmd, void arg)
	100	{
	101	Chardev *s = be->chr;
	102	int res;
	103
	104	if (!s \|\| !CHARDEV_GET_CLASS(s)->chr_ioctl \|\| qemu_chr_replay(s)) {
	105	res = -ENOTSUP;
	106	} else {
	107	res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
	108	}
	109
	110	return res;
	111	}
	112
	113	int qemu_chr_fe_get_msgfd(CharBackend *be)
	114	{
	115	Chardev *s = be->chr;
	116	int fd;
	117	int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
	118	if (s && qemu_chr_replay(s)) {
	119	error_report("Replay: get msgfd is not supported "
	120	"for serial devices yet");
	121	exit(1);
	122	}
	123	return res;
	124	}
	125
	126	int qemu_chr_fe_get_msgfds(CharBackend be, int fds, int len)
	127	{
	128	Chardev *s = be->chr;
	129
	130	if (!s) {
	131	return -1;
	132	}
	133
	134	return CHARDEV_GET_CLASS(s)->get_msgfds ?
	135	CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
	136	}
	137
	138	int qemu_chr_fe_set_msgfds(CharBackend be, int fds, int num)
	139	{
	140	Chardev *s = be->chr;
	141
	142	if (!s) {
	143	return -1;
	144	}
	145
	146	return CHARDEV_GET_CLASS(s)->set_msgfds ?
	147	CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
	148	}
	149
	150	void qemu_chr_fe_accept_input(CharBackend *be)
	151	{
	152	Chardev *s = be->chr;
	153
	154	if (!s) {
155	return;
156	}
157
158	if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
159	CHARDEV_GET_CLASS(s)->chr_accept_input(s);
160	}
161	qemu_notify_event();
162	}
163
164	void qemu_chr_fe_printf(CharBackend be, const char fmt, ...)
165	{
166	char buf[CHR_READ_BUF_LEN];
167	va_list ap;
168	va_start(ap, fmt);
169	vsnprintf(buf, sizeof(buf), fmt, ap);
170	/* XXX this blocks entire thread. Rewrite to use
171	* qemu_chr_fe_write and background I/O callbacks */
172	qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
173	va_end(ap);
174	}
175
176	Chardev qemu_chr_fe_get_driver(CharBackend be)
177	{
7c44a2a9 AN	178	/* this is unsafe for the users that support chardev hotswap */
7c44a2a9 AN	179	assert(be->chr_be_change == NULL);
4d43a603 MAL	180	return be->chr;
	181	}
	182
7c44a2a9 AN	183	bool qemu_chr_fe_backend_connected(CharBackend *be)
	184	{
	185	return !!be->chr;
	186	}
	187
30650701 AN	188	bool qemu_chr_fe_backend_open(CharBackend *be)
	189	{
	190	return be->chr && be->chr->be_open;
	191	}
	192
4d43a603 MAL	193	bool qemu_chr_fe_init(CharBackend b, Chardev s, Error **errp)
	194	{
	195	int tag = 0;
	196
12051d82 PM	197	if (s) {
	198	if (CHARDEV_IS_MUX(s)) {
	199	MuxChardev *d = MUX_CHARDEV(s);
4d43a603	200
12051d82 PM	201	if (d->mux_cnt >= MAX_MUX) {
	202	goto unavailable;
	203	}
	204
	205	d->backends[d->mux_cnt] = b;
	206	tag = d->mux_cnt++;
	207	} else if (s->be) {
4d43a603	208	goto unavailable;
12051d82 PM	209	} else {
12051d82 PM	210	s->be = b;
4d43a603	211	}
4d43a603 MAL	212	}
	213
	214	b->fe_open = false;
	215	b->tag = tag;
	216	b->chr = s;
	217	return true;
	218
	219	unavailable:
	220	error_setg(errp, QERR_DEVICE_IN_USE, s->label);
	221	return false;
	222	}
	223
1ce2610c	224	void qemu_chr_fe_deinit(CharBackend *b, bool del)
4d43a603 MAL	225	{
	226	assert(b);
	227
	228	if (b->chr) {
81517ba3	229	qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, NULL, true);
4d43a603 MAL	230	if (b->chr->be == b) {
	231	b->chr->be = NULL;
	232	}
	233	if (CHARDEV_IS_MUX(b->chr)) {
	234	MuxChardev *d = MUX_CHARDEV(b->chr);
	235	d->backends[b->tag] = NULL;
	236	}
1ce2610c	237	if (del) {
425d8a4e MAL	238	Object *obj = OBJECT(b->chr);
	239	if (obj->parent) {
	240	object_unparent(obj);
	241	} else {
	242	object_unref(obj);
	243	}
1ce2610c	244	}
4d43a603 MAL	245	b->chr = NULL;
	246	}
	247	}
	248
	249	void qemu_chr_fe_set_handlers(CharBackend *b,
	250	IOCanReadHandler *fd_can_read,
	251	IOReadHandler *fd_read,
	252	IOEventHandler *fd_event,
81517ba3	253	BackendChangeHandler *be_change,
4d43a603 MAL	254	void *opaque,
	255	GMainContext *context,
	256	bool set_open)
	257	{
	258	Chardev *s;
4d43a603 MAL	259	int fe_open;
	260
	261	s = b->chr;
	262	if (!s) {
	263	return;
	264	}
	265
4d43a603 MAL	266	if (!opaque && !fd_can_read && !fd_read && !fd_event) {
	267	fe_open = 0;
	268	remove_fd_in_watch(s);
	269	} else {
	270	fe_open = 1;
	271	}
	272	b->chr_can_read = fd_can_read;
	273	b->chr_read = fd_read;
	274	b->chr_event = fd_event;
81517ba3	275	b->chr_be_change = be_change;
4d43a603	276	b->opaque = opaque;
07241c20 PX	277
07241c20 PX	278	qemu_chr_be_update_read_handlers(s, context);
4d43a603 MAL	279
	280	if (set_open) {
	281	qemu_chr_fe_set_open(b, fe_open);
	282	}
	283
	284	if (fe_open) {
	285	qemu_chr_fe_take_focus(b);
	286	/* We're connecting to an already opened device, so let's make sure we
	287	also get the open event */
	288	if (s->be_open) {
	289	qemu_chr_be_event(s, CHR_EVENT_OPENED);
	290	}
	291	}
	292
	293	if (CHARDEV_IS_MUX(s)) {
	294	mux_chr_set_handlers(s, context);
	295	}
	296	}
	297
	298	void qemu_chr_fe_take_focus(CharBackend *b)
	299	{
	300	if (!b->chr) {
	301	return;
	302	}
	303
	304	if (CHARDEV_IS_MUX(b->chr)) {
	305	mux_set_focus(b->chr, b->tag);
	306	}
	307	}
	308
	309	int qemu_chr_fe_wait_connected(CharBackend be, Error *errp)
	310	{
	311	if (!be->chr) {
	312	error_setg(errp, "missing associated backend");
	313	return -1;
	314	}
	315
	316	return qemu_chr_wait_connected(be->chr, errp);
	317	}
	318
	319	void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
	320	{
	321	Chardev *chr = be->chr;
	322
	323	if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
	324	CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
	325	}
	326	}
	327
	328	void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
	329	{
	330	Chardev *chr = be->chr;
	331
	332	if (!chr) {
	333	return;
	334	}
	335
	336	if (be->fe_open == fe_open) {
	337	return;
	338	}
	339	be->fe_open = fe_open;
	340	if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
	341	CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
	342	}
343	}
344
345	guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
346	GIOFunc func, void *user_data)
347	{
348	Chardev *s = be->chr;
349	GSource *src;
350	guint tag;
351
352	if (!s \|\| CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
353	return 0;
354	}
355
356	src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
357	if (!src) {
358	return 0;
359	}
360
361	g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
91e14fb8	362	tag = g_source_attach(src, s->gcontext);
4d43a603 MAL	363	g_source_unref(src);
	364
	365	return tag;
	366	}
	367
	368	void qemu_chr_fe_disconnect(CharBackend *be)
	369	{
	370	Chardev *chr = be->chr;
	371
	372	if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
	373	CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
	374	}
	375	}