4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
26 #include "chardev/char.h"
27 #include "qmp-commands.h"
28 #include "qapi/error.h"
29 #include "qemu/base64.h"
31 /* Ring buffer chardev */
41 #define RINGBUF_CHARDEV(obj) \
42 OBJECT_CHECK(RingBufChardev, (obj), TYPE_CHARDEV_RINGBUF)
44 static size_t ringbuf_count(const Chardev
*chr
)
46 const RingBufChardev
*d
= RINGBUF_CHARDEV(chr
);
48 return d
->prod
- d
->cons
;
51 static int ringbuf_chr_write(Chardev
*chr
, const uint8_t *buf
, int len
)
53 RingBufChardev
*d
= RINGBUF_CHARDEV(chr
);
56 if (!buf
|| (len
< 0)) {
60 for (i
= 0; i
< len
; i
++) {
61 d
->cbuf
[d
->prod
++ & (d
->size
- 1)] = buf
[i
];
62 if (d
->prod
- d
->cons
> d
->size
) {
63 d
->cons
= d
->prod
- d
->size
;
70 static int ringbuf_chr_read(Chardev
*chr
, uint8_t *buf
, int len
)
72 RingBufChardev
*d
= RINGBUF_CHARDEV(chr
);
75 qemu_mutex_lock(&chr
->chr_write_lock
);
76 for (i
= 0; i
< len
&& d
->cons
!= d
->prod
; i
++) {
77 buf
[i
] = d
->cbuf
[d
->cons
++ & (d
->size
- 1)];
79 qemu_mutex_unlock(&chr
->chr_write_lock
);
84 static void char_ringbuf_finalize(Object
*obj
)
86 RingBufChardev
*d
= RINGBUF_CHARDEV(obj
);
91 static void qemu_chr_open_ringbuf(Chardev
*chr
,
92 ChardevBackend
*backend
,
96 ChardevRingbuf
*opts
= backend
->u
.ringbuf
.data
;
97 RingBufChardev
*d
= RINGBUF_CHARDEV(chr
);
99 d
->size
= opts
->has_size
? opts
->size
: 65536;
101 /* The size must be power of 2 */
102 if (d
->size
& (d
->size
- 1)) {
103 error_setg(errp
, "size of ringbuf chardev must be power of two");
109 d
->cbuf
= g_malloc0(d
->size
);
112 void qmp_ringbuf_write(const char *device
, const char *data
,
113 bool has_format
, enum DataFormat format
,
117 const uint8_t *write_data
;
121 chr
= qemu_chr_find(device
);
123 error_setg(errp
, "Device '%s' not found", device
);
127 if (!CHARDEV_IS_RINGBUF(chr
)) {
128 error_setg(errp
, "%s is not a ringbuf device", device
);
132 if (has_format
&& (format
== DATA_FORMAT_BASE64
)) {
133 write_data
= qbase64_decode(data
, -1,
140 write_data
= (uint8_t *)data
;
141 write_count
= strlen(data
);
144 ret
= ringbuf_chr_write(chr
, write_data
, write_count
);
146 if (write_data
!= (uint8_t *)data
) {
147 g_free((void *)write_data
);
151 error_setg(errp
, "Failed to write to device %s", device
);
156 char *qmp_ringbuf_read(const char *device
, int64_t size
,
157 bool has_format
, enum DataFormat format
,
165 chr
= qemu_chr_find(device
);
167 error_setg(errp
, "Device '%s' not found", device
);
171 if (!CHARDEV_IS_RINGBUF(chr
)) {
172 error_setg(errp
, "%s is not a ringbuf device", device
);
177 error_setg(errp
, "size must be greater than zero");
181 count
= ringbuf_count(chr
);
182 size
= size
> count
? count
: size
;
183 read_data
= g_malloc(size
+ 1);
185 ringbuf_chr_read(chr
, read_data
, size
);
187 if (has_format
&& (format
== DATA_FORMAT_BASE64
)) {
188 data
= g_base64_encode(read_data
, size
);
192 * FIXME should read only complete, valid UTF-8 characters up
193 * to @size bytes. Invalid sequences should be replaced by a
194 * suitable replacement character. Except when (and only
195 * when) ring buffer lost characters since last read, initial
196 * continuation characters should be dropped.
199 data
= (char *)read_data
;
205 static void qemu_chr_parse_ringbuf(QemuOpts
*opts
, ChardevBackend
*backend
,
209 ChardevRingbuf
*ringbuf
;
211 backend
->type
= CHARDEV_BACKEND_KIND_RINGBUF
;
212 ringbuf
= backend
->u
.ringbuf
.data
= g_new0(ChardevRingbuf
, 1);
213 qemu_chr_parse_common(opts
, qapi_ChardevRingbuf_base(ringbuf
));
215 val
= qemu_opt_get_size(opts
, "size", 0);
217 ringbuf
->has_size
= true;
222 static void char_ringbuf_class_init(ObjectClass
*oc
, void *data
)
224 ChardevClass
*cc
= CHARDEV_CLASS(oc
);
226 cc
->parse
= qemu_chr_parse_ringbuf
;
227 cc
->open
= qemu_chr_open_ringbuf
;
228 cc
->chr_write
= ringbuf_chr_write
;
231 static const TypeInfo char_ringbuf_type_info
= {
232 .name
= TYPE_CHARDEV_RINGBUF
,
233 .parent
= TYPE_CHARDEV
,
234 .class_init
= char_ringbuf_class_init
,
235 .instance_size
= sizeof(RingBufChardev
),
236 .instance_finalize
= char_ringbuf_finalize
,
239 /* Bug-compatibility: */
240 static const TypeInfo char_memory_type_info
= {
241 .name
= TYPE_CHARDEV_MEMORY
,
242 .parent
= TYPE_CHARDEV_RINGBUF
,
245 static void register_types(void)
247 type_register_static(&char_ringbuf_type_info
);
248 type_register_static(&char_memory_type_info
);
251 type_init(register_types
);