]>
Commit | Line | Data |
---|---|---|
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 | } |