← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to chardev/char.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
chardev/char.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-common.h"
 
26
#include "qemu/cutils.h"
 
27
#include "monitor/monitor.h"
 
28
#include "sysemu/sysemu.h"
 
29
#include "qemu/config-file.h"
 
30
#include "qemu/error-report.h"
 
31
#include "sysemu/char.h"
 
32
#include "qmp-commands.h"
 
33
#include "qapi-visit.h"
 
34
#include "sysemu/replay.h"
 
35
#include "qemu/help_option.h"
 
36
 
 
37
#include "char-mux.h"
 
38
#include "char-io.h"
 
39
#include "char-parallel.h"
 
40
#include "char-serial.h"
 
41
 
 
42
/***********************************************************/
 
43
/* character device */
 
44
 
 
45
static QTAILQ_HEAD(ChardevHead, Chardev) chardevs =
 
46
    QTAILQ_HEAD_INITIALIZER(chardevs);
 
47
 
 
48
void qemu_chr_be_event(Chardev *s, int event)
 
49
{
 
50
    CharBackend *be = s->be;
 
51
 
 
52
    /* Keep track if the char device is open */
 
53
    switch (event) {
 
54
        case CHR_EVENT_OPENED:
 
55
            s->be_open = 1;
 
56
            break;
 
57
        case CHR_EVENT_CLOSED:
 
58
            s->be_open = 0;
 
59
            break;
 
60
    }
 
61
 
 
62
    if (!be || !be->chr_event) {
 
63
        return;
 
64
    }
 
65
 
 
66
    be->chr_event(be->opaque, event);
 
67
}
 
68
 
 
69
void qemu_chr_be_generic_open(Chardev *s)
 
70
{
 
71
    qemu_chr_be_event(s, CHR_EVENT_OPENED);
 
72
}
 
73
 
 
74
 
 
75
/* Not reporting errors from writing to logfile, as logs are
 
76
 * defined to be "best effort" only */
 
77
static void qemu_chr_fe_write_log(Chardev *s,
 
78
                                  const uint8_t *buf, size_t len)
 
79
{
 
80
    size_t done = 0;
 
81
    ssize_t ret;
 
82
 
 
83
    if (s->logfd < 0) {
 
84
        return;
 
85
    }
 
86
 
 
87
    while (done < len) {
 
88
    retry:
 
89
        ret = write(s->logfd, buf + done, len - done);
 
90
        if (ret == -1 && errno == EAGAIN) {
 
91
            g_usleep(100);
 
92
            goto retry;
 
93
        }
 
94
 
 
95
        if (ret <= 0) {
 
96
            return;
 
97
        }
 
98
        done += ret;
 
99
    }
 
100
}
 
101
 
 
102
static int qemu_chr_fe_write_buffer(Chardev *s,
 
103
                                    const uint8_t *buf, int len, int *offset)
 
104
{
 
105
    ChardevClass *cc = CHARDEV_GET_CLASS(s);
 
106
    int res = 0;
 
107
    *offset = 0;
 
108
 
 
109
    qemu_mutex_lock(&s->chr_write_lock);
 
110
    while (*offset < len) {
 
111
    retry:
 
112
        res = cc->chr_write(s, buf + *offset, len - *offset);
 
113
        if (res < 0 && errno == EAGAIN) {
 
114
            g_usleep(100);
 
115
            goto retry;
 
116
        }
 
117
 
 
118
        if (res <= 0) {
 
119
            break;
 
120
        }
 
121
 
 
122
        *offset += res;
 
123
    }
 
124
    if (*offset > 0) {
 
125
        qemu_chr_fe_write_log(s, buf, *offset);
 
126
    }
 
127
    qemu_mutex_unlock(&s->chr_write_lock);
 
128
 
 
129
    return res;
 
130
}
 
131
 
 
132
static bool qemu_chr_replay(Chardev *chr)
 
133
{
 
134
    return qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
 
135
}
 
136
 
 
137
int qemu_chr_fe_write(CharBackend *be, const uint8_t *buf, int len)
 
138
{
 
139
    Chardev *s = be->chr;
 
140
    ChardevClass *cc;
 
141
    int ret;
 
142
 
 
143
    if (!s) {
 
144
        return 0;
 
145
    }
 
146
 
 
147
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 
148
        int offset;
 
149
        replay_char_write_event_load(&ret, &offset);
 
150
        assert(offset <= len);
 
151
        qemu_chr_fe_write_buffer(s, buf, offset, &offset);
 
152
        return ret;
 
153
    }
 
154
 
 
155
    cc = CHARDEV_GET_CLASS(s);
 
156
    qemu_mutex_lock(&s->chr_write_lock);
 
157
    ret = cc->chr_write(s, buf, len);
 
158
 
 
159
    if (ret > 0) {
 
160
        qemu_chr_fe_write_log(s, buf, ret);
 
161
    }
 
162
 
 
163
    qemu_mutex_unlock(&s->chr_write_lock);
 
164
    
 
165
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 
166
        replay_char_write_event_save(ret, ret < 0 ? 0 : ret);
 
167
    }
 
168
    
 
169
    return ret;
 
170
}
 
171
 
 
172
int qemu_chr_write_all(Chardev *s, const uint8_t *buf, int len)
 
173
{
 
174
    int offset;
 
175
    int res;
 
176
 
 
177
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 
178
        replay_char_write_event_load(&res, &offset);
 
179
        assert(offset <= len);
 
180
        qemu_chr_fe_write_buffer(s, buf, offset, &offset);
 
181
        return res;
 
182
    }
 
183
 
 
184
    res = qemu_chr_fe_write_buffer(s, buf, len, &offset);
 
185
 
 
186
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 
187
        replay_char_write_event_save(res, offset);
 
188
    }
 
189
 
 
190
    if (res < 0) {
 
191
        return res;
 
192
    }
 
193
    return offset;
 
194
}
 
195
 
 
196
int qemu_chr_fe_write_all(CharBackend *be, const uint8_t *buf, int len)
 
197
{
 
198
    Chardev *s = be->chr;
 
199
 
 
200
    if (!s) {
 
201
        return 0;
 
202
    }
 
203
 
 
204
    return qemu_chr_write_all(s, buf, len);
 
205
}
 
206
 
 
207
int qemu_chr_fe_read_all(CharBackend *be, uint8_t *buf, int len)
 
208
{
 
209
    Chardev *s = be->chr;
 
210
    int offset = 0, counter = 10;
 
211
    int res;
 
212
 
 
213
    if (!s || !CHARDEV_GET_CLASS(s)->chr_sync_read) {
 
214
        return 0;
 
215
    }
 
216
 
 
217
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_PLAY) {
 
218
        return replay_char_read_all_load(buf);
 
219
    }
 
220
 
 
221
    while (offset < len) {
 
222
    retry:
 
223
        res = CHARDEV_GET_CLASS(s)->chr_sync_read(s, buf + offset,
 
224
                                                  len - offset);
 
225
        if (res == -1 && errno == EAGAIN) {
 
226
            g_usleep(100);
 
227
            goto retry;
 
228
        }
 
229
 
 
230
        if (res == 0) {
 
231
            break;
 
232
        }
 
233
 
 
234
        if (res < 0) {
 
235
            if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 
236
                replay_char_read_all_save_error(res);
 
237
            }
 
238
            return res;
 
239
        }
 
240
 
 
241
        offset += res;
 
242
 
 
243
        if (!counter--) {
 
244
            break;
 
245
        }
 
246
    }
 
247
 
 
248
    if (qemu_chr_replay(s) && replay_mode == REPLAY_MODE_RECORD) {
 
249
        replay_char_read_all_save_buf(buf, offset);
 
250
    }
 
251
    return offset;
 
252
}
 
253
 
 
254
int qemu_chr_fe_ioctl(CharBackend *be, int cmd, void *arg)
 
255
{
 
256
    Chardev *s = be->chr;
 
257
    int res;
 
258
 
 
259
    if (!s || !CHARDEV_GET_CLASS(s)->chr_ioctl || qemu_chr_replay(s)) {
 
260
        res = -ENOTSUP;
 
261
    } else {
 
262
        res = CHARDEV_GET_CLASS(s)->chr_ioctl(s, cmd, arg);
 
263
    }
 
264
 
 
265
    return res;
 
266
}
 
267
 
 
268
int qemu_chr_be_can_write(Chardev *s)
 
269
{
 
270
    CharBackend *be = s->be;
 
271
 
 
272
    if (!be || !be->chr_can_read) {
 
273
        return 0;
 
274
    }
 
275
 
 
276
    return be->chr_can_read(be->opaque);
 
277
}
 
278
 
 
279
void qemu_chr_be_write_impl(Chardev *s, uint8_t *buf, int len)
 
280
{
 
281
    CharBackend *be = s->be;
 
282
 
 
283
    if (be && be->chr_read) {
 
284
        be->chr_read(be->opaque, buf, len);
 
285
    }
 
286
}
 
287
 
 
288
void qemu_chr_be_write(Chardev *s, uint8_t *buf, int len)
 
289
{
 
290
    if (qemu_chr_replay(s)) {
 
291
        if (replay_mode == REPLAY_MODE_PLAY) {
 
292
            return;
 
293
        }
 
294
        replay_chr_be_write(s, buf, len);
 
295
    } else {
 
296
        qemu_chr_be_write_impl(s, buf, len);
 
297
    }
 
298
}
 
299
 
 
300
int qemu_chr_fe_get_msgfd(CharBackend *be)
 
301
{
 
302
    Chardev *s = be->chr;
 
303
    int fd;
 
304
    int res = (qemu_chr_fe_get_msgfds(be, &fd, 1) == 1) ? fd : -1;
 
305
    if (s && qemu_chr_replay(s)) {
 
306
        error_report("Replay: get msgfd is not supported "
 
307
                     "for serial devices yet");
 
308
        exit(1);
 
309
    }
 
310
    return res;
 
311
}
 
312
 
 
313
int qemu_chr_fe_get_msgfds(CharBackend *be, int *fds, int len)
 
314
{
 
315
    Chardev *s = be->chr;
 
316
 
 
317
    if (!s) {
 
318
        return -1;
 
319
    }
 
320
 
 
321
    return CHARDEV_GET_CLASS(s)->get_msgfds ?
 
322
        CHARDEV_GET_CLASS(s)->get_msgfds(s, fds, len) : -1;
 
323
}
 
324
 
 
325
int qemu_chr_fe_set_msgfds(CharBackend *be, int *fds, int num)
 
326
{
 
327
    Chardev *s = be->chr;
 
328
 
 
329
    if (!s) {
 
330
        return -1;
 
331
    }
 
332
 
 
333
    return CHARDEV_GET_CLASS(s)->set_msgfds ?
 
334
        CHARDEV_GET_CLASS(s)->set_msgfds(s, fds, num) : -1;
 
335
}
 
336
 
 
337
int qemu_chr_add_client(Chardev *s, int fd)
 
338
{
 
339
    return CHARDEV_GET_CLASS(s)->chr_add_client ?
 
340
        CHARDEV_GET_CLASS(s)->chr_add_client(s, fd) : -1;
 
341
}
 
342
 
 
343
void qemu_chr_fe_accept_input(CharBackend *be)
 
344
{
 
345
    Chardev *s = be->chr;
 
346
 
 
347
    if (!s) {
 
348
        return;
 
349
    }
 
350
 
 
351
    if (CHARDEV_GET_CLASS(s)->chr_accept_input) {
 
352
        CHARDEV_GET_CLASS(s)->chr_accept_input(s);
 
353
    }
 
354
    qemu_notify_event();
 
355
}
 
356
 
 
357
void qemu_chr_fe_printf(CharBackend *be, const char *fmt, ...)
 
358
{
 
359
    char buf[CHR_READ_BUF_LEN];
 
360
    va_list ap;
 
361
    va_start(ap, fmt);
 
362
    vsnprintf(buf, sizeof(buf), fmt, ap);
 
363
    /* XXX this blocks entire thread. Rewrite to use
 
364
     * qemu_chr_fe_write and background I/O callbacks */
 
365
    qemu_chr_fe_write_all(be, (uint8_t *)buf, strlen(buf));
 
366
    va_end(ap);
 
367
}
 
368
 
 
369
static void qemu_char_open(Chardev *chr, ChardevBackend *backend,
 
370
                           bool *be_opened, Error **errp)
 
371
{
 
372
    ChardevClass *cc = CHARDEV_GET_CLASS(chr);
 
373
    /* Any ChardevCommon member would work */
 
374
    ChardevCommon *common = backend ? backend->u.null.data : NULL;
 
375
 
 
376
    if (common && common->has_logfile) {
 
377
        int flags = O_WRONLY | O_CREAT;
 
378
        if (common->has_logappend &&
 
379
            common->logappend) {
 
380
            flags |= O_APPEND;
 
381
        } else {
 
382
            flags |= O_TRUNC;
 
383
        }
 
384
        chr->logfd = qemu_open(common->logfile, flags, 0666);
 
385
        if (chr->logfd < 0) {
 
386
            error_setg_errno(errp, errno,
 
387
                             "Unable to open logfile %s",
 
388
                             common->logfile);
 
389
            return;
 
390
        }
 
391
    }
 
392
 
 
393
    if (cc->open) {
 
394
        cc->open(chr, backend, be_opened, errp);
 
395
    }
 
396
}
 
397
 
 
398
static void char_init(Object *obj)
 
399
{
 
400
    Chardev *chr = CHARDEV(obj);
 
401
 
 
402
    chr->logfd = -1;
 
403
    qemu_mutex_init(&chr->chr_write_lock);
 
404
}
 
405
 
 
406
static int null_chr_write(Chardev *chr, const uint8_t *buf, int len)
 
407
{
 
408
    return len;
 
409
}
 
410
 
 
411
static void char_class_init(ObjectClass *oc, void *data)
 
412
{
 
413
    ChardevClass *cc = CHARDEV_CLASS(oc);
 
414
 
 
415
    cc->chr_write = null_chr_write;
 
416
}
 
417
 
 
418
static void char_finalize(Object *obj)
 
419
{
 
420
    Chardev *chr = CHARDEV(obj);
 
421
 
 
422
    if (chr->be) {
 
423
        chr->be->chr = NULL;
 
424
    }
 
425
    g_free(chr->filename);
 
426
    g_free(chr->label);
 
427
    if (chr->logfd != -1) {
 
428
        close(chr->logfd);
 
429
    }
 
430
    qemu_mutex_destroy(&chr->chr_write_lock);
 
431
}
 
432
 
 
433
static const TypeInfo char_type_info = {
 
434
    .name = TYPE_CHARDEV,
 
435
    .parent = TYPE_OBJECT,
 
436
    .instance_size = sizeof(Chardev),
 
437
    .instance_init = char_init,
 
438
    .instance_finalize = char_finalize,
 
439
    .abstract = true,
 
440
    .class_size = sizeof(ChardevClass),
 
441
    .class_init = char_class_init,
 
442
};
 
443
 
 
444
/**
 
445
 * Called after processing of default and command-line-specified
 
446
 * chardevs to deliver CHR_EVENT_OPENED events to any FEs attached
 
447
 * to a mux chardev. This is done here to ensure that
 
448
 * output/prompts/banners are only displayed for the FE that has
 
449
 * focus when initial command-line processing/machine init is
 
450
 * completed.
 
451
 *
 
452
 * After this point, any new FE attached to any new or existing
 
453
 * mux will receive CHR_EVENT_OPENED notifications for the BE
 
454
 * immediately.
 
455
 */
 
456
static void muxes_realize_done(Notifier *notifier, void *unused)
 
457
{
 
458
    Chardev *chr;
 
459
 
 
460
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
461
        if (CHARDEV_IS_MUX(chr)) {
 
462
            MuxChardev *d = MUX_CHARDEV(chr);
 
463
            int i;
 
464
 
 
465
            /* send OPENED to all already-attached FEs */
 
466
            for (i = 0; i < d->mux_cnt; i++) {
 
467
                mux_chr_send_event(d, i, CHR_EVENT_OPENED);
 
468
            }
 
469
            /* mark mux as OPENED so any new FEs will immediately receive
 
470
             * OPENED event
 
471
             */
 
472
            qemu_chr_be_generic_open(chr);
 
473
        }
 
474
    }
 
475
    muxes_realized = true;
 
476
}
 
477
 
 
478
static Notifier muxes_realize_notify = {
 
479
    .notify = muxes_realize_done,
 
480
};
 
481
 
 
482
Chardev *qemu_chr_fe_get_driver(CharBackend *be)
 
483
{
 
484
    return be->chr;
 
485
}
 
486
 
 
487
bool qemu_chr_fe_init(CharBackend *b, Chardev *s, Error **errp)
 
488
{
 
489
    int tag = 0;
 
490
 
 
491
    if (CHARDEV_IS_MUX(s)) {
 
492
        MuxChardev *d = MUX_CHARDEV(s);
 
493
 
 
494
        if (d->mux_cnt >= MAX_MUX) {
 
495
            goto unavailable;
 
496
        }
 
497
 
 
498
        d->backends[d->mux_cnt] = b;
 
499
        tag = d->mux_cnt++;
 
500
    } else if (s->be) {
 
501
        goto unavailable;
 
502
    } else {
 
503
        s->be = b;
 
504
    }
 
505
 
 
506
    b->fe_open = false;
 
507
    b->tag = tag;
 
508
    b->chr = s;
 
509
    return true;
 
510
 
 
511
unavailable:
 
512
    error_setg(errp, QERR_DEVICE_IN_USE, s->label);
 
513
    return false;
 
514
}
 
515
 
 
516
static bool qemu_chr_is_busy(Chardev *s)
 
517
{
 
518
    if (CHARDEV_IS_MUX(s)) {
 
519
        MuxChardev *d = MUX_CHARDEV(s);
 
520
        return d->mux_cnt >= 0;
 
521
    } else {
 
522
        return s->be != NULL;
 
523
    }
 
524
}
 
525
 
 
526
void qemu_chr_fe_deinit(CharBackend *b)
 
527
{
 
528
    assert(b);
 
529
 
 
530
    if (b->chr) {
 
531
        qemu_chr_fe_set_handlers(b, NULL, NULL, NULL, NULL, NULL, true);
 
532
        if (b->chr->be == b) {
 
533
            b->chr->be = NULL;
 
534
        }
 
535
        if (CHARDEV_IS_MUX(b->chr)) {
 
536
            MuxChardev *d = MUX_CHARDEV(b->chr);
 
537
            d->backends[b->tag] = NULL;
 
538
        }
 
539
        b->chr = NULL;
 
540
    }
 
541
}
 
542
 
 
543
void qemu_chr_fe_set_handlers(CharBackend *b,
 
544
                              IOCanReadHandler *fd_can_read,
 
545
                              IOReadHandler *fd_read,
 
546
                              IOEventHandler *fd_event,
 
547
                              void *opaque,
 
548
                              GMainContext *context,
 
549
                              bool set_open)
 
550
{
 
551
    Chardev *s;
 
552
    ChardevClass *cc;
 
553
    int fe_open;
 
554
 
 
555
    s = b->chr;
 
556
    if (!s) {
 
557
        return;
 
558
    }
 
559
 
 
560
    cc = CHARDEV_GET_CLASS(s);
 
561
    if (!opaque && !fd_can_read && !fd_read && !fd_event) {
 
562
        fe_open = 0;
 
563
        remove_fd_in_watch(s, context);
 
564
    } else {
 
565
        fe_open = 1;
 
566
    }
 
567
    b->chr_can_read = fd_can_read;
 
568
    b->chr_read = fd_read;
 
569
    b->chr_event = fd_event;
 
570
    b->opaque = opaque;
 
571
    if (cc->chr_update_read_handler) {
 
572
        cc->chr_update_read_handler(s, context);
 
573
    }
 
574
 
 
575
    if (set_open) {
 
576
        qemu_chr_fe_set_open(b, fe_open);
 
577
    }
 
578
 
 
579
    if (fe_open) {
 
580
        qemu_chr_fe_take_focus(b);
 
581
        /* We're connecting to an already opened device, so let's make sure we
 
582
           also get the open event */
 
583
        if (s->be_open) {
 
584
            qemu_chr_be_generic_open(s);
 
585
        }
 
586
    }
 
587
 
 
588
    if (CHARDEV_IS_MUX(s)) {
 
589
        mux_chr_set_handlers(s, context);
 
590
    }
 
591
}
 
592
 
 
593
void qemu_chr_fe_take_focus(CharBackend *b)
 
594
{
 
595
    if (!b->chr) {
 
596
        return;
 
597
    }
 
598
 
 
599
    if (CHARDEV_IS_MUX(b->chr)) {
 
600
        mux_set_focus(b->chr, b->tag);
 
601
    }
 
602
}
 
603
 
 
604
int qemu_chr_wait_connected(Chardev *chr, Error **errp)
 
605
{
 
606
    ChardevClass *cc = CHARDEV_GET_CLASS(chr);
 
607
 
 
608
    if (cc->chr_wait_connected) {
 
609
        return cc->chr_wait_connected(chr, errp);
 
610
    }
 
611
 
 
612
    return 0;
 
613
}
 
614
 
 
615
int qemu_chr_fe_wait_connected(CharBackend *be, Error **errp)
 
616
{
 
617
    if (!be->chr) {
 
618
        error_setg(errp, "missing associated backend");
 
619
        return -1;
 
620
    }
 
621
 
 
622
    return qemu_chr_wait_connected(be->chr, errp);
 
623
}
 
624
 
 
625
QemuOpts *qemu_chr_parse_compat(const char *label, const char *filename)
 
626
{
 
627
    char host[65], port[33], width[8], height[8];
 
628
    int pos;
 
629
    const char *p;
 
630
    QemuOpts *opts;
 
631
    Error *local_err = NULL;
 
632
 
 
633
    opts = qemu_opts_create(qemu_find_opts("chardev"), label, 1, &local_err);
 
634
    if (local_err) {
 
635
        error_report_err(local_err);
 
636
        return NULL;
 
637
    }
 
638
 
 
639
    if (strstart(filename, "mon:", &p)) {
 
640
        filename = p;
 
641
        qemu_opt_set(opts, "mux", "on", &error_abort);
 
642
        if (strcmp(filename, "stdio") == 0) {
 
643
            /* Monitor is muxed to stdio: do not exit on Ctrl+C by default
 
644
             * but pass it to the guest.  Handle this only for compat syntax,
 
645
             * for -chardev syntax we have special option for this.
 
646
             * This is what -nographic did, redirecting+muxing serial+monitor
 
647
             * to stdio causing Ctrl+C to be passed to guest. */
 
648
            qemu_opt_set(opts, "signal", "off", &error_abort);
 
649
        }
 
650
    }
 
651
 
 
652
    if (strcmp(filename, "null")    == 0 ||
 
653
        strcmp(filename, "pty")     == 0 ||
 
654
        strcmp(filename, "msmouse") == 0 ||
 
655
        strcmp(filename, "wctablet") == 0 ||
 
656
        strcmp(filename, "braille") == 0 ||
 
657
        strcmp(filename, "testdev") == 0 ||
 
658
        strcmp(filename, "stdio")   == 0) {
 
659
        qemu_opt_set(opts, "backend", filename, &error_abort);
 
660
        return opts;
 
661
    }
 
662
    if (strstart(filename, "vc", &p)) {
 
663
        qemu_opt_set(opts, "backend", "vc", &error_abort);
 
664
        if (*p == ':') {
 
665
            if (sscanf(p+1, "%7[0-9]x%7[0-9]", width, height) == 2) {
 
666
                /* pixels */
 
667
                qemu_opt_set(opts, "width", width, &error_abort);
 
668
                qemu_opt_set(opts, "height", height, &error_abort);
 
669
            } else if (sscanf(p+1, "%7[0-9]Cx%7[0-9]C", width, height) == 2) {
 
670
                /* chars */
 
671
                qemu_opt_set(opts, "cols", width, &error_abort);
 
672
                qemu_opt_set(opts, "rows", height, &error_abort);
 
673
            } else {
 
674
                goto fail;
 
675
            }
 
676
        }
 
677
        return opts;
 
678
    }
 
679
    if (strcmp(filename, "con:") == 0) {
 
680
        qemu_opt_set(opts, "backend", "console", &error_abort);
 
681
        return opts;
 
682
    }
 
683
    if (strstart(filename, "COM", NULL)) {
 
684
        qemu_opt_set(opts, "backend", "serial", &error_abort);
 
685
        qemu_opt_set(opts, "path", filename, &error_abort);
 
686
        return opts;
 
687
    }
 
688
    if (strstart(filename, "file:", &p)) {
 
689
        qemu_opt_set(opts, "backend", "file", &error_abort);
 
690
        qemu_opt_set(opts, "path", p, &error_abort);
 
691
        return opts;
 
692
    }
 
693
    if (strstart(filename, "pipe:", &p)) {
 
694
        qemu_opt_set(opts, "backend", "pipe", &error_abort);
 
695
        qemu_opt_set(opts, "path", p, &error_abort);
 
696
        return opts;
 
697
    }
 
698
    if (strstart(filename, "tcp:", &p) ||
 
699
        strstart(filename, "telnet:", &p)) {
 
700
        if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 
701
            host[0] = 0;
 
702
            if (sscanf(p, ":%32[^,]%n", port, &pos) < 1)
 
703
                goto fail;
 
704
        }
 
705
        qemu_opt_set(opts, "backend", "socket", &error_abort);
 
706
        qemu_opt_set(opts, "host", host, &error_abort);
 
707
        qemu_opt_set(opts, "port", port, &error_abort);
 
708
        if (p[pos] == ',') {
 
709
            qemu_opts_do_parse(opts, p+pos+1, NULL, &local_err);
 
710
            if (local_err) {
 
711
                error_report_err(local_err);
 
712
                goto fail;
 
713
            }
 
714
        }
 
715
        if (strstart(filename, "telnet:", &p))
 
716
            qemu_opt_set(opts, "telnet", "on", &error_abort);
 
717
        return opts;
 
718
    }
 
719
    if (strstart(filename, "udp:", &p)) {
 
720
        qemu_opt_set(opts, "backend", "udp", &error_abort);
 
721
        if (sscanf(p, "%64[^:]:%32[^@,]%n", host, port, &pos) < 2) {
 
722
            host[0] = 0;
 
723
            if (sscanf(p, ":%32[^@,]%n", port, &pos) < 1) {
 
724
                goto fail;
 
725
            }
 
726
        }
 
727
        qemu_opt_set(opts, "host", host, &error_abort);
 
728
        qemu_opt_set(opts, "port", port, &error_abort);
 
729
        if (p[pos] == '@') {
 
730
            p += pos + 1;
 
731
            if (sscanf(p, "%64[^:]:%32[^,]%n", host, port, &pos) < 2) {
 
732
                host[0] = 0;
 
733
                if (sscanf(p, ":%32[^,]%n", port, &pos) < 1) {
 
734
                    goto fail;
 
735
                }
 
736
            }
 
737
            qemu_opt_set(opts, "localaddr", host, &error_abort);
 
738
            qemu_opt_set(opts, "localport", port, &error_abort);
 
739
        }
 
740
        return opts;
 
741
    }
 
742
    if (strstart(filename, "unix:", &p)) {
 
743
        qemu_opt_set(opts, "backend", "socket", &error_abort);
 
744
        qemu_opts_do_parse(opts, p, "path", &local_err);
 
745
        if (local_err) {
 
746
            error_report_err(local_err);
 
747
            goto fail;
 
748
        }
 
749
        return opts;
 
750
    }
 
751
    if (strstart(filename, "/dev/parport", NULL) ||
 
752
        strstart(filename, "/dev/ppi", NULL)) {
 
753
        qemu_opt_set(opts, "backend", "parport", &error_abort);
 
754
        qemu_opt_set(opts, "path", filename, &error_abort);
 
755
        return opts;
 
756
    }
 
757
    if (strstart(filename, "/dev/", NULL)) {
 
758
        qemu_opt_set(opts, "backend", "tty", &error_abort);
 
759
        qemu_opt_set(opts, "path", filename, &error_abort);
 
760
        return opts;
 
761
    }
 
762
 
 
763
fail:
 
764
    qemu_opts_del(opts);
 
765
    return NULL;
 
766
}
 
767
 
 
768
void qemu_chr_parse_common(QemuOpts *opts, ChardevCommon *backend)
 
769
{
 
770
    const char *logfile = qemu_opt_get(opts, "logfile");
 
771
 
 
772
    backend->has_logfile = logfile != NULL;
 
773
    backend->logfile = logfile ? g_strdup(logfile) : NULL;
 
774
 
 
775
    backend->has_logappend = true;
 
776
    backend->logappend = qemu_opt_get_bool(opts, "logappend", false);
 
777
}
 
778
 
 
779
static const ChardevClass *char_get_class(const char *driver, Error **errp)
 
780
{
 
781
    ObjectClass *oc;
 
782
    const ChardevClass *cc;
 
783
    char *typename = g_strdup_printf("chardev-%s", driver);
 
784
 
 
785
    oc = object_class_by_name(typename);
 
786
    g_free(typename);
 
787
 
 
788
    if (!object_class_dynamic_cast(oc, TYPE_CHARDEV)) {
 
789
        error_setg(errp, "'%s' is not a valid char driver name", driver);
 
790
        return NULL;
 
791
    }
 
792
 
 
793
    if (object_class_is_abstract(oc)) {
 
794
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "driver",
 
795
                   "abstract device type");
 
796
        return NULL;
 
797
    }
 
798
 
 
799
    cc = CHARDEV_CLASS(oc);
 
800
    if (cc->internal) {
 
801
        error_setg(errp, "'%s' is not a valid char driver name", driver);
 
802
        return NULL;
 
803
    }
 
804
 
 
805
    return cc;
 
806
}
 
807
 
 
808
static Chardev *qemu_chardev_add(const char *id, const char *typename,
 
809
                                 ChardevBackend *backend, Error **errp)
 
810
{
 
811
    Chardev *chr;
 
812
 
 
813
    chr = qemu_chr_find(id);
 
814
    if (chr) {
 
815
        error_setg(errp, "Chardev '%s' already exists", id);
 
816
        return NULL;
 
817
    }
 
818
 
 
819
    chr = qemu_chardev_new(id, typename, backend, errp);
 
820
    if (!chr) {
 
821
        return NULL;
 
822
    }
 
823
 
 
824
    QTAILQ_INSERT_TAIL(&chardevs, chr, next);
 
825
    return chr;
 
826
}
 
827
 
 
828
static const struct ChardevAlias {
 
829
    const char *typename;
 
830
    const char *alias;
 
831
} chardev_alias_table[] = {
 
832
#ifdef HAVE_CHARDEV_PARPORT
 
833
    { "parallel", "parport" },
 
834
#endif
 
835
#ifdef HAVE_CHARDEV_SERIAL
 
836
    { "serial", "tty" },
 
837
#endif
 
838
};
 
839
 
 
840
typedef struct ChadevClassFE {
 
841
    void (*fn)(const char *name, void *opaque);
 
842
    void *opaque;
 
843
} ChadevClassFE;
 
844
 
 
845
static void
 
846
chardev_class_foreach(ObjectClass *klass, void *opaque)
 
847
{
 
848
    ChadevClassFE *fe = opaque;
 
849
 
 
850
    assert(g_str_has_prefix(object_class_get_name(klass), "chardev-"));
 
851
    if (CHARDEV_CLASS(klass)->internal) {
 
852
        return;
 
853
    }
 
854
 
 
855
    fe->fn(object_class_get_name(klass) + 8, fe->opaque);
 
856
}
 
857
 
 
858
static void
 
859
chardev_name_foreach(void (*fn)(const char *name, void *opaque), void *opaque)
 
860
{
 
861
    ChadevClassFE fe = { .fn = fn, .opaque = opaque };
 
862
    int i;
 
863
 
 
864
    object_class_foreach(chardev_class_foreach, TYPE_CHARDEV, false, &fe);
 
865
 
 
866
    for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
 
867
        fn(chardev_alias_table[i].alias, opaque);
 
868
    }
 
869
}
 
870
 
 
871
static void
 
872
help_string_append(const char *name, void *opaque)
 
873
{
 
874
    GString *str = opaque;
 
875
 
 
876
    g_string_append_printf(str, "\n%s", name);
 
877
}
 
878
 
 
879
Chardev *qemu_chr_new_from_opts(QemuOpts *opts,
 
880
                                Error **errp)
 
881
{
 
882
    Error *local_err = NULL;
 
883
    const ChardevClass *cc;
 
884
    Chardev *chr;
 
885
    int i;
 
886
    ChardevBackend *backend = NULL;
 
887
    const char *name = qemu_opt_get(opts, "backend");
 
888
    const char *id = qemu_opts_id(opts);
 
889
    char *bid = NULL;
 
890
 
 
891
    if (name == NULL) {
 
892
        error_setg(errp, "chardev: \"%s\" missing backend",
 
893
                   qemu_opts_id(opts));
 
894
        return NULL;
 
895
    }
 
896
 
 
897
    if (is_help_option(name)) {
 
898
        GString *str = g_string_new("");
 
899
 
 
900
        chardev_name_foreach(help_string_append, str);
 
901
 
 
902
        error_report("Available chardev backend types: %s", str->str);
 
903
        g_string_free(str, true);
 
904
        exit(0);
 
905
    }
 
906
 
 
907
    if (id == NULL) {
 
908
        error_setg(errp, "chardev: no id specified");
 
909
        return NULL;
 
910
    }
 
911
 
 
912
    for (i = 0; i < ARRAY_SIZE(chardev_alias_table); i++) {
 
913
        if (g_strcmp0(chardev_alias_table[i].alias, name) == 0) {
 
914
            name = chardev_alias_table[i].typename;
 
915
            break;
 
916
        }
 
917
    }
 
918
 
 
919
    cc = char_get_class(name, errp);
 
920
    if (cc == NULL) {
 
921
        return NULL;
 
922
    }
 
923
 
 
924
    backend = g_new0(ChardevBackend, 1);
 
925
    backend->type = CHARDEV_BACKEND_KIND_NULL;
 
926
 
 
927
    if (qemu_opt_get_bool(opts, "mux", 0)) {
 
928
        bid = g_strdup_printf("%s-base", id);
 
929
    }
 
930
 
 
931
    chr = NULL;
 
932
    if (cc->parse) {
 
933
        cc->parse(opts, backend, &local_err);
 
934
        if (local_err) {
 
935
            error_propagate(errp, local_err);
 
936
            goto out;
 
937
        }
 
938
    } else {
 
939
        ChardevCommon *ccom = g_new0(ChardevCommon, 1);
 
940
        qemu_chr_parse_common(opts, ccom);
 
941
        backend->u.null.data = ccom; /* Any ChardevCommon member would work */
 
942
    }
 
943
 
 
944
    chr = qemu_chardev_add(bid ? bid : id,
 
945
                           object_class_get_name(OBJECT_CLASS(cc)),
 
946
                           backend, errp);
 
947
    if (chr == NULL) {
 
948
        goto out;
 
949
    }
 
950
 
 
951
    if (bid) {
 
952
        Chardev *mux;
 
953
        qapi_free_ChardevBackend(backend);
 
954
        backend = g_new0(ChardevBackend, 1);
 
955
        backend->type = CHARDEV_BACKEND_KIND_MUX;
 
956
        backend->u.mux.data = g_new0(ChardevMux, 1);
 
957
        backend->u.mux.data->chardev = g_strdup(bid);
 
958
        mux = qemu_chardev_add(id, TYPE_CHARDEV_MUX, backend, errp);
 
959
        if (mux == NULL) {
 
960
            qemu_chr_delete(chr);
 
961
            chr = NULL;
 
962
            goto out;
 
963
        }
 
964
        chr = mux;
 
965
    }
 
966
 
 
967
out:
 
968
    qapi_free_ChardevBackend(backend);
 
969
    g_free(bid);
 
970
    return chr;
 
971
}
 
972
 
 
973
Chardev *qemu_chr_new_noreplay(const char *label, const char *filename)
 
974
{
 
975
    const char *p;
 
976
    Chardev *chr;
 
977
    QemuOpts *opts;
 
978
    Error *err = NULL;
 
979
 
 
980
    if (strstart(filename, "chardev:", &p)) {
 
981
        return qemu_chr_find(p);
 
982
    }
 
983
 
 
984
    opts = qemu_chr_parse_compat(label, filename);
 
985
    if (!opts)
 
986
        return NULL;
 
987
 
 
988
    chr = qemu_chr_new_from_opts(opts, &err);
 
989
    if (err) {
 
990
        error_report_err(err);
 
991
    }
 
992
    if (chr && qemu_opt_get_bool(opts, "mux", 0)) {
 
993
        monitor_init(chr, MONITOR_USE_READLINE);
 
994
    }
 
995
    qemu_opts_del(opts);
 
996
    return chr;
 
997
}
 
998
 
 
999
Chardev *qemu_chr_new(const char *label, const char *filename)
 
1000
{
 
1001
    Chardev *chr;
 
1002
    chr = qemu_chr_new_noreplay(label, filename);
 
1003
    if (chr) {
 
1004
        if (replay_mode != REPLAY_MODE_NONE) {
 
1005
            qemu_chr_set_feature(chr, QEMU_CHAR_FEATURE_REPLAY);
 
1006
        }
 
1007
        if (qemu_chr_replay(chr) && CHARDEV_GET_CLASS(chr)->chr_ioctl) {
 
1008
            error_report("Replay: ioctl is not supported "
 
1009
                         "for serial devices yet");
 
1010
        }
 
1011
        replay_register_char_driver(chr);
 
1012
    }
 
1013
    return chr;
 
1014
}
 
1015
 
 
1016
void qemu_chr_fe_set_echo(CharBackend *be, bool echo)
 
1017
{
 
1018
    Chardev *chr = be->chr;
 
1019
 
 
1020
    if (chr && CHARDEV_GET_CLASS(chr)->chr_set_echo) {
 
1021
        CHARDEV_GET_CLASS(chr)->chr_set_echo(chr, echo);
 
1022
    }
 
1023
}
 
1024
 
 
1025
void qemu_chr_fe_set_open(CharBackend *be, int fe_open)
 
1026
{
 
1027
    Chardev *chr = be->chr;
 
1028
 
 
1029
    if (!chr) {
 
1030
        return;
 
1031
    }
 
1032
 
 
1033
    if (be->fe_open == fe_open) {
 
1034
        return;
 
1035
    }
 
1036
    be->fe_open = fe_open;
 
1037
    if (CHARDEV_GET_CLASS(chr)->chr_set_fe_open) {
 
1038
        CHARDEV_GET_CLASS(chr)->chr_set_fe_open(chr, fe_open);
 
1039
    }
 
1040
}
 
1041
 
 
1042
guint qemu_chr_fe_add_watch(CharBackend *be, GIOCondition cond,
 
1043
                            GIOFunc func, void *user_data)
 
1044
{
 
1045
    Chardev *s = be->chr;
 
1046
    GSource *src;
 
1047
    guint tag;
 
1048
 
 
1049
    if (!s || CHARDEV_GET_CLASS(s)->chr_add_watch == NULL) {
 
1050
        return 0;
 
1051
    }
 
1052
 
 
1053
    src = CHARDEV_GET_CLASS(s)->chr_add_watch(s, cond);
 
1054
    if (!src) {
 
1055
        return 0;
 
1056
    }
 
1057
 
 
1058
    g_source_set_callback(src, (GSourceFunc)func, user_data, NULL);
 
1059
    tag = g_source_attach(src, NULL);
 
1060
    g_source_unref(src);
 
1061
 
 
1062
    return tag;
 
1063
}
 
1064
 
 
1065
void qemu_chr_fe_disconnect(CharBackend *be)
 
1066
{
 
1067
    Chardev *chr = be->chr;
 
1068
 
 
1069
    if (chr && CHARDEV_GET_CLASS(chr)->chr_disconnect) {
 
1070
        CHARDEV_GET_CLASS(chr)->chr_disconnect(chr);
 
1071
    }
 
1072
}
 
1073
 
 
1074
void qemu_chr_delete(Chardev *chr)
 
1075
{
 
1076
    QTAILQ_REMOVE(&chardevs, chr, next);
 
1077
    object_unref(OBJECT(chr));
 
1078
}
 
1079
 
 
1080
ChardevInfoList *qmp_query_chardev(Error **errp)
 
1081
{
 
1082
    ChardevInfoList *chr_list = NULL;
 
1083
    Chardev *chr;
 
1084
 
 
1085
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
1086
        ChardevInfoList *info = g_malloc0(sizeof(*info));
 
1087
        info->value = g_malloc0(sizeof(*info->value));
 
1088
        info->value->label = g_strdup(chr->label);
 
1089
        info->value->filename = g_strdup(chr->filename);
 
1090
        info->value->frontend_open = chr->be && chr->be->fe_open;
 
1091
 
 
1092
        info->next = chr_list;
 
1093
        chr_list = info;
 
1094
    }
 
1095
 
 
1096
    return chr_list;
 
1097
}
 
1098
 
 
1099
static void
 
1100
qmp_prepend_backend(const char *name, void *opaque)
 
1101
{
 
1102
    ChardevBackendInfoList **list = opaque;
 
1103
    ChardevBackendInfoList *info = g_malloc0(sizeof(*info));
 
1104
 
 
1105
    info->value = g_malloc0(sizeof(*info->value));
 
1106
    info->value->name = g_strdup(name);
 
1107
    info->next = *list;
 
1108
    *list = info;
 
1109
}
 
1110
 
 
1111
ChardevBackendInfoList *qmp_query_chardev_backends(Error **errp)
 
1112
{
 
1113
    ChardevBackendInfoList *backend_list = NULL;
 
1114
 
 
1115
    chardev_name_foreach(qmp_prepend_backend, &backend_list);
 
1116
 
 
1117
    return backend_list;
 
1118
}
 
1119
 
 
1120
Chardev *qemu_chr_find(const char *name)
 
1121
{
 
1122
    Chardev *chr;
 
1123
 
 
1124
    QTAILQ_FOREACH(chr, &chardevs, next) {
 
1125
        if (strcmp(chr->label, name) != 0)
 
1126
            continue;
 
1127
        return chr;
 
1128
    }
 
1129
    return NULL;
 
1130
}
 
1131
 
 
1132
QemuOptsList qemu_chardev_opts = {
 
1133
    .name = "chardev",
 
1134
    .implied_opt_name = "backend",
 
1135
    .head = QTAILQ_HEAD_INITIALIZER(qemu_chardev_opts.head),
 
1136
    .desc = {
 
1137
        {
 
1138
            .name = "backend",
 
1139
            .type = QEMU_OPT_STRING,
 
1140
        },{
 
1141
            .name = "path",
 
1142
            .type = QEMU_OPT_STRING,
 
1143
        },{
 
1144
            .name = "host",
 
1145
            .type = QEMU_OPT_STRING,
 
1146
        },{
 
1147
            .name = "port",
 
1148
            .type = QEMU_OPT_STRING,
 
1149
        },{
 
1150
            .name = "localaddr",
 
1151
            .type = QEMU_OPT_STRING,
 
1152
        },{
 
1153
            .name = "localport",
 
1154
            .type = QEMU_OPT_STRING,
 
1155
        },{
 
1156
            .name = "to",
 
1157
            .type = QEMU_OPT_NUMBER,
 
1158
        },{
 
1159
            .name = "ipv4",
 
1160
            .type = QEMU_OPT_BOOL,
 
1161
        },{
 
1162
            .name = "ipv6",
 
1163
            .type = QEMU_OPT_BOOL,
 
1164
        },{
 
1165
            .name = "wait",
 
1166
            .type = QEMU_OPT_BOOL,
 
1167
        },{
 
1168
            .name = "server",
 
1169
            .type = QEMU_OPT_BOOL,
 
1170
        },{
 
1171
            .name = "delay",
 
1172
            .type = QEMU_OPT_BOOL,
 
1173
        },{
 
1174
            .name = "reconnect",
 
1175
            .type = QEMU_OPT_NUMBER,
 
1176
        },{
 
1177
            .name = "telnet",
 
1178
            .type = QEMU_OPT_BOOL,
 
1179
        },{
 
1180
            .name = "tls-creds",
 
1181
            .type = QEMU_OPT_STRING,
 
1182
        },{
 
1183
            .name = "width",
 
1184
            .type = QEMU_OPT_NUMBER,
 
1185
        },{
 
1186
            .name = "height",
 
1187
            .type = QEMU_OPT_NUMBER,
 
1188
        },{
 
1189
            .name = "cols",
 
1190
            .type = QEMU_OPT_NUMBER,
 
1191
        },{
 
1192
            .name = "rows",
 
1193
            .type = QEMU_OPT_NUMBER,
 
1194
        },{
 
1195
            .name = "mux",
 
1196
            .type = QEMU_OPT_BOOL,
 
1197
        },{
 
1198
            .name = "signal",
 
1199
            .type = QEMU_OPT_BOOL,
 
1200
        },{
 
1201
            .name = "name",
 
1202
            .type = QEMU_OPT_STRING,
 
1203
        },{
 
1204
            .name = "debug",
 
1205
            .type = QEMU_OPT_NUMBER,
 
1206
        },{
 
1207
            .name = "size",
 
1208
            .type = QEMU_OPT_SIZE,
 
1209
        },{
 
1210
            .name = "chardev",
 
1211
            .type = QEMU_OPT_STRING,
 
1212
        },{
 
1213
            .name = "append",
 
1214
            .type = QEMU_OPT_BOOL,
 
1215
        },{
 
1216
            .name = "logfile",
 
1217
            .type = QEMU_OPT_STRING,
 
1218
        },{
 
1219
            .name = "logappend",
 
1220
            .type = QEMU_OPT_BOOL,
 
1221
        },
 
1222
        { /* end of list */ }
 
1223
    },
 
1224
};
 
1225
 
 
1226
bool qemu_chr_has_feature(Chardev *chr,
 
1227
                          ChardevFeature feature)
 
1228
{
 
1229
    return test_bit(feature, chr->features);
 
1230
}
 
1231
 
 
1232
void qemu_chr_set_feature(Chardev *chr,
 
1233
                           ChardevFeature feature)
 
1234
{
 
1235
    return set_bit(feature, chr->features);
 
1236
}
 
1237
 
 
1238
Chardev *qemu_chardev_new(const char *id, const char *typename,
 
1239
                          ChardevBackend *backend, Error **errp)
 
1240
{
 
1241
    Chardev *chr = NULL;
 
1242
    Error *local_err = NULL;
 
1243
    bool be_opened = true;
 
1244
 
 
1245
    assert(g_str_has_prefix(typename, "chardev-"));
 
1246
 
 
1247
    chr = CHARDEV(object_new(typename));
 
1248
    chr->label = g_strdup(id);
 
1249
 
 
1250
    qemu_char_open(chr, backend, &be_opened, &local_err);
 
1251
    if (local_err) {
 
1252
        error_propagate(errp, local_err);
 
1253
        object_unref(OBJECT(chr));
 
1254
        return NULL;
 
1255
    }
 
1256
 
 
1257
    if (!chr->filename) {
 
1258
        chr->filename = g_strdup(typename + 8);
 
1259
    }
 
1260
    if (be_opened) {
 
1261
        qemu_chr_be_event(chr, CHR_EVENT_OPENED);
 
1262
    }
 
1263
 
 
1264
    return chr;
 
1265
}
 
1266
 
 
1267
ChardevReturn *qmp_chardev_add(const char *id, ChardevBackend *backend,
 
1268
                               Error **errp)
 
1269
{
 
1270
    const ChardevClass *cc;
 
1271
    ChardevReturn *ret;
 
1272
    Chardev *chr;
 
1273
 
 
1274
    cc = char_get_class(ChardevBackendKind_lookup[backend->type], errp);
 
1275
    if (!cc) {
 
1276
        return NULL;
 
1277
    }
 
1278
 
 
1279
    chr = qemu_chardev_add(id, object_class_get_name(OBJECT_CLASS(cc)),
 
1280
                           backend, errp);
 
1281
    if (!chr) {
 
1282
        return NULL;
 
1283
    }
 
1284
 
 
1285
    ret = g_new0(ChardevReturn, 1);
 
1286
    if (CHARDEV_IS_PTY(chr)) {
 
1287
        ret->pty = g_strdup(chr->filename + 4);
 
1288
        ret->has_pty = true;
 
1289
    }
 
1290
 
 
1291
    return ret;
 
1292
}
 
1293
 
 
1294
void qmp_chardev_remove(const char *id, Error **errp)
 
1295
{
 
1296
    Chardev *chr;
 
1297
 
 
1298
    chr = qemu_chr_find(id);
 
1299
    if (chr == NULL) {
 
1300
        error_setg(errp, "Chardev '%s' not found", id);
 
1301
        return;
 
1302
    }
 
1303
    if (qemu_chr_is_busy(chr)) {
 
1304
        error_setg(errp, "Chardev '%s' is busy", id);
 
1305
        return;
 
1306
    }
 
1307
    if (qemu_chr_replay(chr)) {
 
1308
        error_setg(errp,
 
1309
            "Chardev '%s' cannot be unplugged in record/replay mode", id);
 
1310
        return;
 
1311
    }
 
1312
    qemu_chr_delete(chr);
 
1313
}
 
1314
 
 
1315
void qemu_chr_cleanup(void)
 
1316
{
 
1317
    Chardev *chr, *tmp;
 
1318
 
 
1319
    QTAILQ_FOREACH_SAFE(chr, &chardevs, next, tmp) {
 
1320
        qemu_chr_delete(chr);
 
1321
    }
 
1322
}
 
1323
 
 
1324
static void register_types(void)
 
1325
{
 
1326
    type_register_static(&char_type_info);
 
1327
 
 
1328
    /* this must be done after machine init, since we register FEs with muxes
 
1329
     * as part of realize functions like serial_isa_realizefn when -nographic
 
1330
     * is specified
 
1331
     */
 
1332
    qemu_add_machine_init_done_notifier(&muxes_realize_notify);
 
1333
}
 
1334
 
 
1335
type_init(register_types);