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