Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2021-01-25-1' into...
[qemu.git] / chardev / char-fe.c
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 "qapi/qmp/qerror.h"
28 #include "sysemu/replay.h"
29
30 #include "chardev/char-fe.h"
31 #include "chardev/char-io.h"
32 #include "chardev-internal.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;
59 int offset = 0;
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;
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 {
178 /* this is unsafe for the users that support chardev hotswap */
179 assert(be->chr_be_change == NULL);
180 return be->chr;
181 }
182
183 bool qemu_chr_fe_backend_connected(CharBackend *be)
184 {
185 return !!be->chr;
186 }
187
188 bool qemu_chr_fe_backend_open(CharBackend *be)
189 {
190 return be->chr && be->chr->be_open;
191 }
192
193 bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
194 {
195 int tag = 0;
196
197 if (s) {
198 if (CHARDEV_IS_MUX(s)) {
199 MuxChardev *d = MUX_CHARDEV(s);
200
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) {
208 goto unavailable;
209 } else {
210 s->be = b;
211 }
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
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 int 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 = 0;
269 remove_fd_in_watch(s);
270 } else {
271 fe_open = 1;
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, int fe_open)
340 {
341 Chardev *chr = be->chr;
342
343 if (!chr) {
344 return;
345 }
346
347 if (be->fe_open == fe_open) {
348 return;
349 }
350 be->fe_open = fe_open;
351 if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
352 CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
353 }
354 }
355
356 guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
357 GIOFunc 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 }