2 * QEMU Random Number Generator Backend
4 * Copyright IBM, Corp. 2012
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
14 #include "qemu-char.h"
16 #include "hw/qdev.h" /* just for DEFINE_PROP_CHR */
18 #define TYPE_RNG_EGD "rng-egd"
19 #define RNG_EGD(obj) OBJECT_CHECK(RngEgd, (obj), TYPE_RNG_EGD)
31 typedef struct RngRequest
33 EntropyReceiveFunc
*receive_entropy
;
40 static void rng_egd_request_entropy(RngBackend
*b
, size_t size
,
41 EntropyReceiveFunc
*receive_entropy
,
44 RngEgd
*s
= RNG_EGD(b
);
47 req
= g_malloc(sizeof(*req
));
51 req
->receive_entropy
= receive_entropy
;
53 req
->data
= g_malloc(req
->size
);
57 uint8_t len
= MIN(size
, 255);
59 /* synchronous entropy request */
63 qemu_chr_fe_write(s
->chr
, header
, sizeof(header
));
68 s
->requests
= g_slist_append(s
->requests
, req
);
71 static void rng_egd_free_request(RngRequest
*req
)
77 static int rng_egd_chr_can_read(void *opaque
)
79 RngEgd
*s
= RNG_EGD(opaque
);
83 for (i
= s
->requests
; i
; i
= i
->next
) {
84 RngRequest
*req
= i
->data
;
85 size
+= req
->size
- req
->offset
;
91 static void rng_egd_chr_read(void *opaque
, const uint8_t *buf
, int size
)
93 RngEgd
*s
= RNG_EGD(opaque
);
95 while (size
> 0 && s
->requests
) {
96 RngRequest
*req
= s
->requests
->data
;
97 int len
= MIN(size
, req
->size
- req
->offset
);
99 memcpy(req
->data
+ req
->offset
, buf
, len
);
103 if (req
->offset
== req
->size
) {
104 s
->requests
= g_slist_remove_link(s
->requests
, s
->requests
);
106 req
->receive_entropy(req
->opaque
, req
->data
, req
->size
);
108 rng_egd_free_request(req
);
113 static void rng_egd_cancel_requests(RngBackend
*b
)
115 RngEgd
*s
= RNG_EGD(b
);
117 /* We simply delete the list of pending requests. If there is data in the
118 * queue waiting to be read, this is okay, because there will always be
119 * more data than we requested originally
121 g_slist_free_full(s
->requests
,
122 (GDestroyNotify
)rng_egd_free_request
);
126 static void rng_egd_opened(RngBackend
*b
, Error
**errp
)
128 RngEgd
*s
= RNG_EGD(b
);
130 if (s
->chr_name
== NULL
) {
131 error_set(errp
, QERR_INVALID_PARAMETER_VALUE
,
132 "chardev", "a valid character device");
136 s
->chr
= qemu_chr_find(s
->chr_name
);
137 if (s
->chr
== NULL
) {
138 error_set(errp
, QERR_DEVICE_NOT_FOUND
, s
->chr_name
);
142 /* FIXME we should resubmit pending requests when the CDS reconnects. */
143 qemu_chr_add_handlers(s
->chr
, rng_egd_chr_can_read
, rng_egd_chr_read
,
147 static void rng_egd_set_chardev(Object
*obj
, const char *value
, Error
**errp
)
149 RngBackend
*b
= RNG_BACKEND(obj
);
150 RngEgd
*s
= RNG_EGD(b
);
153 error_set(errp
, QERR_PERMISSION_DENIED
);
156 s
->chr_name
= g_strdup(value
);
160 static char *rng_egd_get_chardev(Object
*obj
, Error
**errp
)
162 RngEgd
*s
= RNG_EGD(obj
);
164 if (s
->chr
&& s
->chr
->label
) {
165 return g_strdup(s
->chr
->label
);
171 static void rng_egd_init(Object
*obj
)
173 object_property_add_str(obj
, "chardev",
174 rng_egd_get_chardev
, rng_egd_set_chardev
,
178 static void rng_egd_finalize(Object
*obj
)
180 RngEgd
*s
= RNG_EGD(obj
);
183 qemu_chr_add_handlers(s
->chr
, NULL
, NULL
, NULL
, NULL
);
188 g_slist_free_full(s
->requests
, (GDestroyNotify
)rng_egd_free_request
);
192 static void rng_egd_class_init(ObjectClass
*klass
, void *data
)
194 RngBackendClass
*rbc
= RNG_BACKEND_CLASS(klass
);
196 rbc
->request_entropy
= rng_egd_request_entropy
;
197 rbc
->cancel_requests
= rng_egd_cancel_requests
;
198 rbc
->opened
= rng_egd_opened
;
201 static TypeInfo rng_egd_info
= {
202 .name
= TYPE_RNG_EGD
,
203 .parent
= TYPE_RNG_BACKEND
,
204 .instance_size
= sizeof(RngEgd
),
205 .class_init
= rng_egd_class_init
,
206 .instance_init
= rng_egd_init
,
207 .instance_finalize
= rng_egd_finalize
,
210 static void register_types(void)
212 type_register_static(&rng_egd_info
);
215 type_init(register_types
);