]>
Commit | Line | Data |
---|---|---|
18c86e2b | 1 | #include "qemu/osdep.h" |
1422e32d | 2 | #include "net/net.h" |
83c9f4ca | 3 | #include "hw/qdev.h" |
da34e65c | 4 | #include "qapi/error.h" |
a7c4d9c7 | 5 | #include "hw/pci/pci.h" |
7b1b5d19 | 6 | #include "qapi/qmp/qerror.h" |
d49b6836 | 7 | #include "qemu/error-report.h" |
4be74634 | 8 | #include "sysemu/block-backend.h" |
0d09e41a | 9 | #include "hw/block/block.h" |
606c10e2 | 10 | #include "net/hub.h" |
7b1b5d19 | 11 | #include "qapi/visitor.h" |
8228e353 | 12 | #include "chardev/char.h" |
ee6847d1 | 13 | |
b000dfbd PM |
14 | void qdev_prop_set_after_realize(DeviceState *dev, const char *name, |
15 | Error **errp) | |
16 | { | |
17 | if (dev->id) { | |
18 | error_setg(errp, "Attempt to set property '%s' on device '%s' " | |
19 | "(type '%s') after it was realized", name, dev->id, | |
20 | object_get_typename(OBJECT(dev))); | |
21 | } else { | |
22 | error_setg(errp, "Attempt to set property '%s' on anonymous device " | |
23 | "(type '%s') after it was realized", name, | |
24 | object_get_typename(OBJECT(dev))); | |
25 | } | |
26 | } | |
27 | ||
8f5d58ef IM |
28 | void qdev_prop_allow_set_link_before_realize(const Object *obj, |
29 | const char *name, | |
39f72ef9 SH |
30 | Object *val, Error **errp) |
31 | { | |
32 | DeviceState *dev = DEVICE(obj); | |
33 | ||
34 | if (dev->realized) { | |
35 | error_setg(errp, "Attempt to set link property '%s' on device '%s' " | |
36 | "(type '%s') after it was realized", | |
37 | name, dev->id, object_get_typename(obj)); | |
38 | } | |
39 | } | |
40 | ||
ee6847d1 GH |
41 | void *qdev_get_prop_ptr(DeviceState *dev, Property *prop) |
42 | { | |
43 | void *ptr = dev; | |
44 | ptr += prop->offset; | |
45 | return ptr; | |
46 | } | |
47 | ||
d7bce999 EB |
48 | static void get_enum(Object *obj, Visitor *v, const char *name, void *opaque, |
49 | Error **errp) | |
d4d34b0d MA |
50 | { |
51 | DeviceState *dev = DEVICE(obj); | |
52 | Property *prop = opaque; | |
53 | int *ptr = qdev_get_prop_ptr(dev, prop); | |
54 | ||
337283df | 55 | visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp); |
d4d34b0d MA |
56 | } |
57 | ||
d7bce999 EB |
58 | static void set_enum(Object *obj, Visitor *v, const char *name, void *opaque, |
59 | Error **errp) | |
d4d34b0d MA |
60 | { |
61 | DeviceState *dev = DEVICE(obj); | |
62 | Property *prop = opaque; | |
63 | int *ptr = qdev_get_prop_ptr(dev, prop); | |
64 | ||
7983c8a3 | 65 | if (dev->realized) { |
b000dfbd | 66 | qdev_prop_set_after_realize(dev, name, errp); |
d4d34b0d MA |
67 | return; |
68 | } | |
69 | ||
337283df | 70 | visit_type_enum(v, prop->name, ptr, prop->info->enum_table, errp); |
d4d34b0d MA |
71 | } |
72 | ||
a2740ad5 MAL |
73 | static void set_default_value_enum(Object *obj, const Property *prop) |
74 | { | |
76318657 | 75 | object_property_set_str(obj, prop->info->enum_table[prop->defval.i], |
a2740ad5 MAL |
76 | prop->name, &error_abort); |
77 | } | |
78 | ||
d4d34b0d MA |
79 | /* Bit */ |
80 | ||
d2364ee4 MT |
81 | static uint32_t qdev_get_prop_mask(Property *prop) |
82 | { | |
a3d4a1b0 | 83 | assert(prop->info == &qdev_prop_bit); |
d2364ee4 MT |
84 | return 0x1 << prop->bitnr; |
85 | } | |
86 | ||
87 | static void bit_prop_set(DeviceState *dev, Property *props, bool val) | |
88 | { | |
89 | uint32_t *p = qdev_get_prop_ptr(dev, props); | |
90 | uint32_t mask = qdev_get_prop_mask(props); | |
04a2d61e | 91 | if (val) { |
dbd48324 | 92 | *p |= mask; |
04a2d61e | 93 | } else { |
d2364ee4 | 94 | *p &= ~mask; |
04a2d61e | 95 | } |
d2364ee4 MT |
96 | } |
97 | ||
d7bce999 EB |
98 | static void prop_get_bit(Object *obj, Visitor *v, const char *name, |
99 | void *opaque, Error **errp) | |
80e555c2 | 100 | { |
57c9fafe | 101 | DeviceState *dev = DEVICE(obj); |
80e555c2 PB |
102 | Property *prop = opaque; |
103 | uint32_t *p = qdev_get_prop_ptr(dev, prop); | |
104 | bool value = (*p & qdev_get_prop_mask(prop)) != 0; | |
105 | ||
51e72bc1 | 106 | visit_type_bool(v, name, &value, errp); |
80e555c2 PB |
107 | } |
108 | ||
d7bce999 EB |
109 | static void prop_set_bit(Object *obj, Visitor *v, const char *name, |
110 | void *opaque, Error **errp) | |
80e555c2 | 111 | { |
57c9fafe | 112 | DeviceState *dev = DEVICE(obj); |
80e555c2 PB |
113 | Property *prop = opaque; |
114 | Error *local_err = NULL; | |
115 | bool value; | |
116 | ||
7983c8a3 | 117 | if (dev->realized) { |
b000dfbd | 118 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
119 | return; |
120 | } | |
121 | ||
51e72bc1 | 122 | visit_type_bool(v, name, &value, &local_err); |
80e555c2 PB |
123 | if (local_err) { |
124 | error_propagate(errp, local_err); | |
125 | return; | |
126 | } | |
127 | bit_prop_set(dev, prop, value); | |
128 | } | |
129 | ||
a2740ad5 MAL |
130 | static void set_default_value_bool(Object *obj, const Property *prop) |
131 | { | |
3fb2111f | 132 | object_property_set_bool(obj, prop->defval.u, prop->name, &error_abort); |
a2740ad5 MAL |
133 | } |
134 | ||
d2364ee4 | 135 | PropertyInfo qdev_prop_bit = { |
85ca1202 | 136 | .name = "bool", |
51b2e8c3 | 137 | .description = "on/off", |
949fc823 MA |
138 | .get = prop_get_bit, |
139 | .set = prop_set_bit, | |
a2740ad5 | 140 | .set_default_value = set_default_value_bool, |
d2364ee4 MT |
141 | }; |
142 | ||
fdba6d96 GH |
143 | /* Bit64 */ |
144 | ||
145 | static uint64_t qdev_get_prop_mask64(Property *prop) | |
146 | { | |
8aedc369 | 147 | assert(prop->info == &qdev_prop_bit64); |
1fa795a8 | 148 | return 0x1ull << prop->bitnr; |
fdba6d96 GH |
149 | } |
150 | ||
151 | static void bit64_prop_set(DeviceState *dev, Property *props, bool val) | |
152 | { | |
153 | uint64_t *p = qdev_get_prop_ptr(dev, props); | |
154 | uint64_t mask = qdev_get_prop_mask64(props); | |
155 | if (val) { | |
156 | *p |= mask; | |
157 | } else { | |
158 | *p &= ~mask; | |
159 | } | |
160 | } | |
161 | ||
d7bce999 EB |
162 | static void prop_get_bit64(Object *obj, Visitor *v, const char *name, |
163 | void *opaque, Error **errp) | |
fdba6d96 GH |
164 | { |
165 | DeviceState *dev = DEVICE(obj); | |
166 | Property *prop = opaque; | |
167 | uint64_t *p = qdev_get_prop_ptr(dev, prop); | |
168 | bool value = (*p & qdev_get_prop_mask64(prop)) != 0; | |
169 | ||
51e72bc1 | 170 | visit_type_bool(v, name, &value, errp); |
fdba6d96 GH |
171 | } |
172 | ||
d7bce999 EB |
173 | static void prop_set_bit64(Object *obj, Visitor *v, const char *name, |
174 | void *opaque, Error **errp) | |
fdba6d96 GH |
175 | { |
176 | DeviceState *dev = DEVICE(obj); | |
177 | Property *prop = opaque; | |
178 | Error *local_err = NULL; | |
179 | bool value; | |
180 | ||
181 | if (dev->realized) { | |
182 | qdev_prop_set_after_realize(dev, name, errp); | |
183 | return; | |
184 | } | |
185 | ||
51e72bc1 | 186 | visit_type_bool(v, name, &value, &local_err); |
fdba6d96 GH |
187 | if (local_err) { |
188 | error_propagate(errp, local_err); | |
189 | return; | |
190 | } | |
191 | bit64_prop_set(dev, prop, value); | |
192 | } | |
193 | ||
194 | PropertyInfo qdev_prop_bit64 = { | |
195 | .name = "bool", | |
196 | .description = "on/off", | |
197 | .get = prop_get_bit64, | |
198 | .set = prop_set_bit64, | |
a2740ad5 | 199 | .set_default_value = set_default_value_bool, |
fdba6d96 GH |
200 | }; |
201 | ||
72cc5137 IM |
202 | /* --- bool --- */ |
203 | ||
d7bce999 EB |
204 | static void get_bool(Object *obj, Visitor *v, const char *name, void *opaque, |
205 | Error **errp) | |
72cc5137 IM |
206 | { |
207 | DeviceState *dev = DEVICE(obj); | |
208 | Property *prop = opaque; | |
209 | bool *ptr = qdev_get_prop_ptr(dev, prop); | |
210 | ||
51e72bc1 | 211 | visit_type_bool(v, name, ptr, errp); |
72cc5137 IM |
212 | } |
213 | ||
d7bce999 EB |
214 | static void set_bool(Object *obj, Visitor *v, const char *name, void *opaque, |
215 | Error **errp) | |
72cc5137 IM |
216 | { |
217 | DeviceState *dev = DEVICE(obj); | |
218 | Property *prop = opaque; | |
219 | bool *ptr = qdev_get_prop_ptr(dev, prop); | |
220 | ||
221 | if (dev->realized) { | |
222 | qdev_prop_set_after_realize(dev, name, errp); | |
223 | return; | |
224 | } | |
225 | ||
51e72bc1 | 226 | visit_type_bool(v, name, ptr, errp); |
72cc5137 IM |
227 | } |
228 | ||
229 | PropertyInfo qdev_prop_bool = { | |
85ca1202 | 230 | .name = "bool", |
72cc5137 IM |
231 | .get = get_bool, |
232 | .set = set_bool, | |
a2740ad5 | 233 | .set_default_value = set_default_value_bool, |
72cc5137 IM |
234 | }; |
235 | ||
c7cc172d JQ |
236 | /* --- 8bit integer --- */ |
237 | ||
d7bce999 EB |
238 | static void get_uint8(Object *obj, Visitor *v, const char *name, void *opaque, |
239 | Error **errp) | |
80e555c2 | 240 | { |
57c9fafe | 241 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 242 | Property *prop = opaque; |
c08fb2ac | 243 | uint8_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 244 | |
51e72bc1 | 245 | visit_type_uint8(v, name, ptr, errp); |
80e555c2 PB |
246 | } |
247 | ||
d7bce999 EB |
248 | static void set_uint8(Object *obj, Visitor *v, const char *name, void *opaque, |
249 | Error **errp) | |
80e555c2 | 250 | { |
57c9fafe | 251 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 252 | Property *prop = opaque; |
27712df9 | 253 | uint8_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 254 | |
7983c8a3 | 255 | if (dev->realized) { |
b000dfbd | 256 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
257 | return; |
258 | } | |
259 | ||
51e72bc1 | 260 | visit_type_uint8(v, name, ptr, errp); |
80e555c2 PB |
261 | } |
262 | ||
a2740ad5 MAL |
263 | static void set_default_value_int(Object *obj, const Property *prop) |
264 | { | |
76318657 | 265 | object_property_set_int(obj, prop->defval.i, prop->name, &error_abort); |
a2740ad5 MAL |
266 | } |
267 | ||
3fb2111f MAL |
268 | static void set_default_value_uint(Object *obj, const Property *prop) |
269 | { | |
270 | object_property_set_uint(obj, prop->defval.u, prop->name, &error_abort); | |
271 | } | |
272 | ||
c7cc172d JQ |
273 | PropertyInfo qdev_prop_uint8 = { |
274 | .name = "uint8", | |
c08fb2ac MR |
275 | .get = get_uint8, |
276 | .set = set_uint8, | |
3fb2111f | 277 | .set_default_value = set_default_value_uint, |
c7cc172d JQ |
278 | }; |
279 | ||
ee6847d1 GH |
280 | /* --- 16bit integer --- */ |
281 | ||
d7bce999 EB |
282 | static void get_uint16(Object *obj, Visitor *v, const char *name, |
283 | void *opaque, Error **errp) | |
80e555c2 | 284 | { |
57c9fafe | 285 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 286 | Property *prop = opaque; |
c08fb2ac | 287 | uint16_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 288 | |
51e72bc1 | 289 | visit_type_uint16(v, name, ptr, errp); |
80e555c2 PB |
290 | } |
291 | ||
d7bce999 EB |
292 | static void set_uint16(Object *obj, Visitor *v, const char *name, |
293 | void *opaque, Error **errp) | |
80e555c2 | 294 | { |
57c9fafe | 295 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 296 | Property *prop = opaque; |
27712df9 | 297 | uint16_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 298 | |
7983c8a3 | 299 | if (dev->realized) { |
b000dfbd | 300 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
301 | return; |
302 | } | |
303 | ||
51e72bc1 | 304 | visit_type_uint16(v, name, ptr, errp); |
80e555c2 PB |
305 | } |
306 | ||
ee6847d1 GH |
307 | PropertyInfo qdev_prop_uint16 = { |
308 | .name = "uint16", | |
c08fb2ac MR |
309 | .get = get_uint16, |
310 | .set = set_uint16, | |
3fb2111f | 311 | .set_default_value = set_default_value_uint, |
ee6847d1 GH |
312 | }; |
313 | ||
314 | /* --- 32bit integer --- */ | |
315 | ||
d7bce999 EB |
316 | static void get_uint32(Object *obj, Visitor *v, const char *name, |
317 | void *opaque, Error **errp) | |
c08fb2ac MR |
318 | { |
319 | DeviceState *dev = DEVICE(obj); | |
320 | Property *prop = opaque; | |
27712df9 | 321 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); |
c08fb2ac | 322 | |
51e72bc1 | 323 | visit_type_uint32(v, name, ptr, errp); |
c08fb2ac MR |
324 | } |
325 | ||
d7bce999 EB |
326 | static void set_uint32(Object *obj, Visitor *v, const char *name, |
327 | void *opaque, Error **errp) | |
c08fb2ac MR |
328 | { |
329 | DeviceState *dev = DEVICE(obj); | |
330 | Property *prop = opaque; | |
27712df9 | 331 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); |
c08fb2ac | 332 | |
7983c8a3 | 333 | if (dev->realized) { |
b000dfbd | 334 | qdev_prop_set_after_realize(dev, name, errp); |
c08fb2ac MR |
335 | return; |
336 | } | |
337 | ||
51e72bc1 | 338 | visit_type_uint32(v, name, ptr, errp); |
c08fb2ac MR |
339 | } |
340 | ||
d7bce999 EB |
341 | static void get_int32(Object *obj, Visitor *v, const char *name, void *opaque, |
342 | Error **errp) | |
80e555c2 | 343 | { |
57c9fafe | 344 | DeviceState *dev = DEVICE(obj); |
80e555c2 PB |
345 | Property *prop = opaque; |
346 | int32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
80e555c2 | 347 | |
51e72bc1 | 348 | visit_type_int32(v, name, ptr, errp); |
80e555c2 PB |
349 | } |
350 | ||
d7bce999 EB |
351 | static void set_int32(Object *obj, Visitor *v, const char *name, void *opaque, |
352 | Error **errp) | |
80e555c2 | 353 | { |
57c9fafe | 354 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 355 | Property *prop = opaque; |
27712df9 | 356 | int32_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 357 | |
7983c8a3 | 358 | if (dev->realized) { |
b000dfbd | 359 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
360 | return; |
361 | } | |
362 | ||
51e72bc1 | 363 | visit_type_int32(v, name, ptr, errp); |
80e555c2 PB |
364 | } |
365 | ||
ee6847d1 GH |
366 | PropertyInfo qdev_prop_uint32 = { |
367 | .name = "uint32", | |
c08fb2ac MR |
368 | .get = get_uint32, |
369 | .set = set_uint32, | |
3fb2111f | 370 | .set_default_value = set_default_value_uint, |
ee6847d1 GH |
371 | }; |
372 | ||
316940b0 GH |
373 | PropertyInfo qdev_prop_int32 = { |
374 | .name = "int32", | |
80e555c2 PB |
375 | .get = get_int32, |
376 | .set = set_int32, | |
a2740ad5 | 377 | .set_default_value = set_default_value_int, |
316940b0 GH |
378 | }; |
379 | ||
5a053d1f BS |
380 | /* --- 64bit integer --- */ |
381 | ||
d7bce999 EB |
382 | static void get_uint64(Object *obj, Visitor *v, const char *name, |
383 | void *opaque, Error **errp) | |
80e555c2 | 384 | { |
57c9fafe | 385 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 386 | Property *prop = opaque; |
c08fb2ac | 387 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 388 | |
51e72bc1 | 389 | visit_type_uint64(v, name, ptr, errp); |
80e555c2 PB |
390 | } |
391 | ||
d7bce999 EB |
392 | static void set_uint64(Object *obj, Visitor *v, const char *name, |
393 | void *opaque, Error **errp) | |
80e555c2 | 394 | { |
57c9fafe | 395 | DeviceState *dev = DEVICE(obj); |
80e555c2 | 396 | Property *prop = opaque; |
c08fb2ac | 397 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); |
80e555c2 | 398 | |
7983c8a3 | 399 | if (dev->realized) { |
b000dfbd | 400 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
401 | return; |
402 | } | |
403 | ||
51e72bc1 | 404 | visit_type_uint64(v, name, ptr, errp); |
80e555c2 PB |
405 | } |
406 | ||
5a053d1f BS |
407 | PropertyInfo qdev_prop_uint64 = { |
408 | .name = "uint64", | |
c08fb2ac MR |
409 | .get = get_uint64, |
410 | .set = set_uint64, | |
3fb2111f | 411 | .set_default_value = set_default_value_uint, |
5a053d1f BS |
412 | }; |
413 | ||
59419663 GH |
414 | /* --- string --- */ |
415 | ||
dd0ba250 | 416 | static void release_string(Object *obj, const char *name, void *opaque) |
d21357df | 417 | { |
dd0ba250 PB |
418 | Property *prop = opaque; |
419 | g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop)); | |
d21357df MA |
420 | } |
421 | ||
d7bce999 EB |
422 | static void get_string(Object *obj, Visitor *v, const char *name, |
423 | void *opaque, Error **errp) | |
80e555c2 | 424 | { |
57c9fafe | 425 | DeviceState *dev = DEVICE(obj); |
80e555c2 PB |
426 | Property *prop = opaque; |
427 | char **ptr = qdev_get_prop_ptr(dev, prop); | |
428 | ||
429 | if (!*ptr) { | |
430 | char *str = (char *)""; | |
51e72bc1 | 431 | visit_type_str(v, name, &str, errp); |
80e555c2 | 432 | } else { |
51e72bc1 | 433 | visit_type_str(v, name, ptr, errp); |
80e555c2 PB |
434 | } |
435 | } | |
436 | ||
d7bce999 EB |
437 | static void set_string(Object *obj, Visitor *v, const char *name, |
438 | void *opaque, Error **errp) | |
80e555c2 | 439 | { |
57c9fafe | 440 | DeviceState *dev = DEVICE(obj); |
80e555c2 PB |
441 | Property *prop = opaque; |
442 | char **ptr = qdev_get_prop_ptr(dev, prop); | |
443 | Error *local_err = NULL; | |
444 | char *str; | |
445 | ||
7983c8a3 | 446 | if (dev->realized) { |
b000dfbd | 447 | qdev_prop_set_after_realize(dev, name, errp); |
80e555c2 PB |
448 | return; |
449 | } | |
450 | ||
51e72bc1 | 451 | visit_type_str(v, name, &str, &local_err); |
80e555c2 PB |
452 | if (local_err) { |
453 | error_propagate(errp, local_err); | |
454 | return; | |
455 | } | |
ef1e1e07 | 456 | g_free(*ptr); |
80e555c2 PB |
457 | *ptr = str; |
458 | } | |
459 | ||
59419663 | 460 | PropertyInfo qdev_prop_string = { |
85ca1202 | 461 | .name = "str", |
dd0ba250 | 462 | .release = release_string, |
80e555c2 PB |
463 | .get = get_string, |
464 | .set = set_string, | |
59419663 GH |
465 | }; |
466 | ||
ee6847d1 GH |
467 | /* --- pointer --- */ |
468 | ||
036f7166 | 469 | /* Not a proper property, just for dirty hacks. TODO Remove it! */ |
ee6847d1 GH |
470 | PropertyInfo qdev_prop_ptr = { |
471 | .name = "ptr", | |
ee6847d1 GH |
472 | }; |
473 | ||
474 | /* --- mac address --- */ | |
475 | ||
476 | /* | |
477 | * accepted syntax versions: | |
478 | * 01:02:03:04:05:06 | |
479 | * 01-02-03-04-05-06 | |
480 | */ | |
d7bce999 EB |
481 | static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque, |
482 | Error **errp) | |
ee6847d1 | 483 | { |
e39e5d60 PB |
484 | DeviceState *dev = DEVICE(obj); |
485 | Property *prop = opaque; | |
1503fff3 | 486 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); |
e39e5d60 PB |
487 | char buffer[2 * 6 + 5 + 1]; |
488 | char *p = buffer; | |
489 | ||
490 | snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x", | |
491 | mac->a[0], mac->a[1], mac->a[2], | |
492 | mac->a[3], mac->a[4], mac->a[5]); | |
493 | ||
51e72bc1 | 494 | visit_type_str(v, name, &p, errp); |
e39e5d60 PB |
495 | } |
496 | ||
d7bce999 EB |
497 | static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque, |
498 | Error **errp) | |
e39e5d60 PB |
499 | { |
500 | DeviceState *dev = DEVICE(obj); | |
501 | Property *prop = opaque; | |
502 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); | |
503 | Error *local_err = NULL; | |
ee6847d1 | 504 | int i, pos; |
e39e5d60 PB |
505 | char *str, *p; |
506 | ||
7983c8a3 | 507 | if (dev->realized) { |
b000dfbd | 508 | qdev_prop_set_after_realize(dev, name, errp); |
e39e5d60 PB |
509 | return; |
510 | } | |
511 | ||
51e72bc1 | 512 | visit_type_str(v, name, &str, &local_err); |
e39e5d60 PB |
513 | if (local_err) { |
514 | error_propagate(errp, local_err); | |
515 | return; | |
516 | } | |
ee6847d1 GH |
517 | |
518 | for (i = 0, pos = 0; i < 6; i++, pos += 3) { | |
04a2d61e | 519 | if (!qemu_isxdigit(str[pos])) { |
e39e5d60 | 520 | goto inval; |
04a2d61e EH |
521 | } |
522 | if (!qemu_isxdigit(str[pos+1])) { | |
e39e5d60 | 523 | goto inval; |
04a2d61e | 524 | } |
1503fff3 | 525 | if (i == 5) { |
04a2d61e | 526 | if (str[pos+2] != '\0') { |
e39e5d60 | 527 | goto inval; |
04a2d61e | 528 | } |
1503fff3 | 529 | } else { |
04a2d61e | 530 | if (str[pos+2] != ':' && str[pos+2] != '-') { |
e39e5d60 | 531 | goto inval; |
04a2d61e | 532 | } |
1503fff3 GH |
533 | } |
534 | mac->a[i] = strtol(str+pos, &p, 16); | |
ee6847d1 | 535 | } |
a3400466 | 536 | g_free(str); |
e39e5d60 | 537 | return; |
1503fff3 | 538 | |
e39e5d60 PB |
539 | inval: |
540 | error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); | |
a3400466 | 541 | g_free(str); |
ee6847d1 GH |
542 | } |
543 | ||
544 | PropertyInfo qdev_prop_macaddr = { | |
85ca1202 | 545 | .name = "str", |
51b2e8c3 | 546 | .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56", |
e39e5d60 PB |
547 | .get = get_mac, |
548 | .set = set_mac, | |
ee6847d1 GH |
549 | }; |
550 | ||
55e8a154 MA |
551 | /* --- on/off/auto --- */ |
552 | ||
553 | PropertyInfo qdev_prop_on_off_auto = { | |
554 | .name = "OnOffAuto", | |
555 | .description = "on/off/auto", | |
556 | .enum_table = OnOffAuto_lookup, | |
557 | .get = get_enum, | |
558 | .set = set_enum, | |
a2740ad5 | 559 | .set_default_value = set_default_value_enum, |
55e8a154 MA |
560 | }; |
561 | ||
4e4fa398 JK |
562 | /* --- lost tick policy --- */ |
563 | ||
1ce05125 PB |
564 | QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int)); |
565 | ||
4e4fa398 | 566 | PropertyInfo qdev_prop_losttickpolicy = { |
1ce05125 | 567 | .name = "LostTickPolicy", |
104059da | 568 | .enum_table = LostTickPolicy_lookup, |
1ce05125 PB |
569 | .get = get_enum, |
570 | .set = set_enum, | |
a2740ad5 | 571 | .set_default_value = set_default_value_enum, |
4e4fa398 JK |
572 | }; |
573 | ||
8c398252 KW |
574 | /* --- Block device error handling policy --- */ |
575 | ||
576 | QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int)); | |
577 | ||
578 | PropertyInfo qdev_prop_blockdev_on_error = { | |
579 | .name = "BlockdevOnError", | |
580 | .description = "Error handling policy, " | |
581 | "report/ignore/enospc/stop/auto", | |
582 | .enum_table = BlockdevOnError_lookup, | |
583 | .get = get_enum, | |
584 | .set = set_enum, | |
a2740ad5 | 585 | .set_default_value = set_default_value_enum, |
8c398252 KW |
586 | }; |
587 | ||
8cd41745 MA |
588 | /* --- BIOS CHS translation */ |
589 | ||
104059da | 590 | QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int)); |
8cd41745 MA |
591 | |
592 | PropertyInfo qdev_prop_bios_chs_trans = { | |
85ca1202 | 593 | .name = "BiosAtaTranslation", |
51b2e8c3 GA |
594 | .description = "Logical CHS translation algorithm, " |
595 | "auto/none/lba/large/rechs", | |
104059da | 596 | .enum_table = BiosAtaTranslation_lookup, |
8cd41745 MA |
597 | .get = get_enum, |
598 | .set = set_enum, | |
a2740ad5 | 599 | .set_default_value = set_default_value_enum, |
8cd41745 MA |
600 | }; |
601 | ||
a73275dd JS |
602 | /* --- FDC default drive types */ |
603 | ||
604 | PropertyInfo qdev_prop_fdc_drive_type = { | |
605 | .name = "FdcDriveType", | |
606 | .description = "FDC drive type, " | |
607 | "144/288/120/none/auto", | |
608 | .enum_table = FloppyDriveType_lookup, | |
609 | .get = get_enum, | |
a2740ad5 MAL |
610 | .set = set_enum, |
611 | .set_default_value = set_default_value_enum, | |
a73275dd JS |
612 | }; |
613 | ||
05cb5fe4 GH |
614 | /* --- pci address --- */ |
615 | ||
616 | /* | |
617 | * bus-local address, i.e. "$slot" or "$slot.$fn" | |
618 | */ | |
d7bce999 EB |
619 | static void set_pci_devfn(Object *obj, Visitor *v, const char *name, |
620 | void *opaque, Error **errp) | |
05cb5fe4 | 621 | { |
768a9ebe PB |
622 | DeviceState *dev = DEVICE(obj); |
623 | Property *prop = opaque; | |
27712df9 | 624 | int32_t value, *ptr = qdev_get_prop_ptr(dev, prop); |
05cb5fe4 | 625 | unsigned int slot, fn, n; |
768a9ebe | 626 | Error *local_err = NULL; |
a3400466 | 627 | char *str; |
768a9ebe | 628 | |
7983c8a3 | 629 | if (dev->realized) { |
b000dfbd | 630 | qdev_prop_set_after_realize(dev, name, errp); |
768a9ebe PB |
631 | return; |
632 | } | |
633 | ||
51e72bc1 | 634 | visit_type_str(v, name, &str, &local_err); |
768a9ebe | 635 | if (local_err) { |
5c878008 | 636 | error_free(local_err); |
27712df9 | 637 | local_err = NULL; |
51e72bc1 | 638 | visit_type_int32(v, name, &value, &local_err); |
27712df9 PB |
639 | if (local_err) { |
640 | error_propagate(errp, local_err); | |
641 | } else if (value < -1 || value > 255) { | |
c6bd8c70 MA |
642 | error_setg(errp, QERR_INVALID_PARAMETER_VALUE, |
643 | name ? name : "null", "pci_devfn"); | |
27712df9 PB |
644 | } else { |
645 | *ptr = value; | |
646 | } | |
647 | return; | |
768a9ebe | 648 | } |
05cb5fe4 GH |
649 | |
650 | if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) { | |
651 | fn = 0; | |
652 | if (sscanf(str, "%x%n", &slot, &n) != 1) { | |
768a9ebe | 653 | goto invalid; |
05cb5fe4 GH |
654 | } |
655 | } | |
768a9ebe PB |
656 | if (str[n] != '\0' || fn > 7 || slot > 31) { |
657 | goto invalid; | |
658 | } | |
05cb5fe4 | 659 | *ptr = slot << 3 | fn; |
a3400466 | 660 | g_free(str); |
768a9ebe PB |
661 | return; |
662 | ||
663 | invalid: | |
664 | error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); | |
a3400466 | 665 | g_free(str); |
05cb5fe4 GH |
666 | } |
667 | ||
04a2d61e EH |
668 | static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, |
669 | size_t len) | |
05cb5fe4 | 670 | { |
09f1bbcd | 671 | int32_t *ptr = qdev_get_prop_ptr(dev, prop); |
05cb5fe4 | 672 | |
73538c31 | 673 | if (*ptr == -1) { |
05cb5fe4 GH |
674 | return snprintf(dest, len, "<unset>"); |
675 | } else { | |
676 | return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7); | |
677 | } | |
678 | } | |
679 | ||
680 | PropertyInfo qdev_prop_pci_devfn = { | |
b403298a | 681 | .name = "int32", |
51b2e8c3 | 682 | .description = "Slot and optional function number, example: 06.0 or 06", |
05cb5fe4 | 683 | .print = print_pci_devfn, |
b403298a | 684 | .get = get_int32, |
768a9ebe | 685 | .set = set_pci_devfn, |
a2740ad5 | 686 | .set_default_value = set_default_value_int, |
05cb5fe4 GH |
687 | }; |
688 | ||
02fda01c SH |
689 | /* --- blocksize --- */ |
690 | ||
d7bce999 EB |
691 | static void set_blocksize(Object *obj, Visitor *v, const char *name, |
692 | void *opaque, Error **errp) | |
02fda01c SH |
693 | { |
694 | DeviceState *dev = DEVICE(obj); | |
695 | Property *prop = opaque; | |
c08fb2ac | 696 | uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop); |
02fda01c | 697 | Error *local_err = NULL; |
27712df9 PB |
698 | const int64_t min = 512; |
699 | const int64_t max = 32768; | |
02fda01c | 700 | |
7983c8a3 | 701 | if (dev->realized) { |
b000dfbd | 702 | qdev_prop_set_after_realize(dev, name, errp); |
02fda01c SH |
703 | return; |
704 | } | |
705 | ||
51e72bc1 | 706 | visit_type_uint16(v, name, &value, &local_err); |
02fda01c SH |
707 | if (local_err) { |
708 | error_propagate(errp, local_err); | |
709 | return; | |
710 | } | |
0eb28a42 ET |
711 | /* value of 0 means "unset" */ |
712 | if (value && (value < min || value > max)) { | |
c6bd8c70 MA |
713 | error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE, |
714 | dev->id ? : "", name, (int64_t)value, min, max); | |
02fda01c SH |
715 | return; |
716 | } | |
717 | ||
718 | /* We rely on power-of-2 blocksizes for bitmasks */ | |
719 | if ((value & (value - 1)) != 0) { | |
f231b88d CR |
720 | error_setg(errp, |
721 | "Property %s.%s doesn't take value '%" PRId64 "', it's not a power of 2", | |
722 | dev->id ?: "", name, (int64_t)value); | |
02fda01c SH |
723 | return; |
724 | } | |
725 | ||
726 | *ptr = value; | |
727 | } | |
728 | ||
729 | PropertyInfo qdev_prop_blocksize = { | |
85ca1202 | 730 | .name = "uint16", |
51b2e8c3 | 731 | .description = "A power of two between 512 and 32768", |
c08fb2ac | 732 | .get = get_uint16, |
02fda01c | 733 | .set = set_blocksize, |
3fb2111f | 734 | .set_default_value = set_default_value_uint, |
02fda01c SH |
735 | }; |
736 | ||
679042f0 AP |
737 | /* --- pci host address --- */ |
738 | ||
d7bce999 EB |
739 | static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name, |
740 | void *opaque, Error **errp) | |
679042f0 AP |
741 | { |
742 | DeviceState *dev = DEVICE(obj); | |
743 | Property *prop = opaque; | |
744 | PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); | |
00b87025 | 745 | char buffer[] = "ffff:ff:ff.f"; |
679042f0 AP |
746 | char *p = buffer; |
747 | int rc = 0; | |
748 | ||
00b87025 DO |
749 | /* |
750 | * Catch "invalid" device reference from vfio-pci and allow the | |
b12227af | 751 | * default buffer representing the non-existent device to be used. |
00b87025 DO |
752 | */ |
753 | if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) { | |
754 | rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d", | |
755 | addr->domain, addr->bus, addr->slot, addr->function); | |
756 | assert(rc == sizeof(buffer) - 1); | |
757 | } | |
679042f0 | 758 | |
51e72bc1 | 759 | visit_type_str(v, name, &p, errp); |
679042f0 AP |
760 | } |
761 | ||
762 | /* | |
763 | * Parse [<domain>:]<bus>:<slot>.<func> | |
764 | * if <domain> is not supplied, it's assumed to be 0. | |
765 | */ | |
d7bce999 EB |
766 | static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name, |
767 | void *opaque, Error **errp) | |
679042f0 AP |
768 | { |
769 | DeviceState *dev = DEVICE(obj); | |
770 | Property *prop = opaque; | |
771 | PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop); | |
772 | Error *local_err = NULL; | |
773 | char *str, *p; | |
774 | char *e; | |
775 | unsigned long val; | |
776 | unsigned long dom = 0, bus = 0; | |
777 | unsigned int slot = 0, func = 0; | |
778 | ||
7983c8a3 | 779 | if (dev->realized) { |
b000dfbd | 780 | qdev_prop_set_after_realize(dev, name, errp); |
679042f0 AP |
781 | return; |
782 | } | |
783 | ||
51e72bc1 | 784 | visit_type_str(v, name, &str, &local_err); |
679042f0 AP |
785 | if (local_err) { |
786 | error_propagate(errp, local_err); | |
787 | return; | |
788 | } | |
789 | ||
790 | p = str; | |
791 | val = strtoul(p, &e, 16); | |
792 | if (e == p || *e != ':') { | |
793 | goto inval; | |
794 | } | |
795 | bus = val; | |
796 | ||
797 | p = e + 1; | |
798 | val = strtoul(p, &e, 16); | |
799 | if (e == p) { | |
800 | goto inval; | |
801 | } | |
802 | if (*e == ':') { | |
803 | dom = bus; | |
804 | bus = val; | |
805 | p = e + 1; | |
806 | val = strtoul(p, &e, 16); | |
807 | if (e == p) { | |
808 | goto inval; | |
809 | } | |
810 | } | |
811 | slot = val; | |
812 | ||
813 | if (*e != '.') { | |
814 | goto inval; | |
815 | } | |
816 | p = e + 1; | |
817 | val = strtoul(p, &e, 10); | |
818 | if (e == p) { | |
819 | goto inval; | |
820 | } | |
821 | func = val; | |
822 | ||
823 | if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) { | |
824 | goto inval; | |
825 | } | |
826 | ||
827 | if (*e) { | |
828 | goto inval; | |
829 | } | |
830 | ||
831 | addr->domain = dom; | |
832 | addr->bus = bus; | |
833 | addr->slot = slot; | |
834 | addr->function = func; | |
835 | ||
836 | g_free(str); | |
837 | return; | |
838 | ||
839 | inval: | |
840 | error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str); | |
841 | g_free(str); | |
842 | } | |
843 | ||
844 | PropertyInfo qdev_prop_pci_host_devaddr = { | |
85ca1202 | 845 | .name = "str", |
51b2e8c3 GA |
846 | .description = "Address (bus/device/function) of " |
847 | "the host device, example: 04:10.0", | |
679042f0 AP |
848 | .get = get_pci_host_devaddr, |
849 | .set = set_pci_host_devaddr, | |
850 | }; | |
851 | ||
0be6bfac PM |
852 | /* --- support for array properties --- */ |
853 | ||
854 | /* Used as an opaque for the object properties we add for each | |
855 | * array element. Note that the struct Property must be first | |
856 | * in the struct so that a pointer to this works as the opaque | |
857 | * for the underlying element's property hooks as well as for | |
858 | * our own release callback. | |
859 | */ | |
860 | typedef struct { | |
861 | struct Property prop; | |
862 | char *propname; | |
863 | ObjectPropertyRelease *release; | |
864 | } ArrayElementProperty; | |
865 | ||
866 | /* object property release callback for array element properties: | |
867 | * we call the underlying element's property release hook, and | |
868 | * then free the memory we allocated when we added the property. | |
869 | */ | |
870 | static void array_element_release(Object *obj, const char *name, void *opaque) | |
871 | { | |
872 | ArrayElementProperty *p = opaque; | |
873 | if (p->release) { | |
874 | p->release(obj, name, opaque); | |
875 | } | |
876 | g_free(p->propname); | |
877 | g_free(p); | |
878 | } | |
879 | ||
d7bce999 EB |
880 | static void set_prop_arraylen(Object *obj, Visitor *v, const char *name, |
881 | void *opaque, Error **errp) | |
0be6bfac PM |
882 | { |
883 | /* Setter for the property which defines the length of a | |
884 | * variable-sized property array. As well as actually setting the | |
885 | * array-length field in the device struct, we have to create the | |
886 | * array itself and dynamically add the corresponding properties. | |
887 | */ | |
888 | DeviceState *dev = DEVICE(obj); | |
889 | Property *prop = opaque; | |
890 | uint32_t *alenptr = qdev_get_prop_ptr(dev, prop); | |
891 | void **arrayptr = (void *)dev + prop->arrayoffset; | |
65cd9064 | 892 | Error *local_err = NULL; |
0be6bfac PM |
893 | void *eltptr; |
894 | const char *arrayname; | |
895 | int i; | |
896 | ||
897 | if (dev->realized) { | |
b000dfbd | 898 | qdev_prop_set_after_realize(dev, name, errp); |
0be6bfac PM |
899 | return; |
900 | } | |
901 | if (*alenptr) { | |
902 | error_setg(errp, "array size property %s may not be set more than once", | |
903 | name); | |
904 | return; | |
905 | } | |
51e72bc1 | 906 | visit_type_uint32(v, name, alenptr, &local_err); |
65cd9064 MA |
907 | if (local_err) { |
908 | error_propagate(errp, local_err); | |
0be6bfac PM |
909 | return; |
910 | } | |
911 | if (!*alenptr) { | |
912 | return; | |
913 | } | |
914 | ||
915 | /* DEFINE_PROP_ARRAY guarantees that name should start with this prefix; | |
916 | * strip it off so we can get the name of the array itself. | |
917 | */ | |
918 | assert(strncmp(name, PROP_ARRAY_LEN_PREFIX, | |
919 | strlen(PROP_ARRAY_LEN_PREFIX)) == 0); | |
920 | arrayname = name + strlen(PROP_ARRAY_LEN_PREFIX); | |
921 | ||
922 | /* Note that it is the responsibility of the individual device's deinit | |
923 | * to free the array proper. | |
924 | */ | |
925 | *arrayptr = eltptr = g_malloc0(*alenptr * prop->arrayfieldsize); | |
926 | for (i = 0; i < *alenptr; i++, eltptr += prop->arrayfieldsize) { | |
927 | char *propname = g_strdup_printf("%s[%d]", arrayname, i); | |
928 | ArrayElementProperty *arrayprop = g_new0(ArrayElementProperty, 1); | |
929 | arrayprop->release = prop->arrayinfo->release; | |
930 | arrayprop->propname = propname; | |
931 | arrayprop->prop.info = prop->arrayinfo; | |
932 | arrayprop->prop.name = propname; | |
933 | /* This ugly piece of pointer arithmetic sets up the offset so | |
934 | * that when the underlying get/set hooks call qdev_get_prop_ptr | |
935 | * they get the right answer despite the array element not actually | |
936 | * being inside the device struct. | |
937 | */ | |
938 | arrayprop->prop.offset = eltptr - (void *)dev; | |
939 | assert(qdev_get_prop_ptr(dev, &arrayprop->prop) == eltptr); | |
940 | object_property_add(obj, propname, | |
941 | arrayprop->prop.info->name, | |
942 | arrayprop->prop.info->get, | |
943 | arrayprop->prop.info->set, | |
944 | array_element_release, | |
65cd9064 MA |
945 | arrayprop, &local_err); |
946 | if (local_err) { | |
947 | error_propagate(errp, local_err); | |
0be6bfac PM |
948 | return; |
949 | } | |
950 | } | |
951 | } | |
952 | ||
953 | PropertyInfo qdev_prop_arraylen = { | |
954 | .name = "uint32", | |
955 | .get = get_uint32, | |
956 | .set = set_prop_arraylen, | |
3fb2111f | 957 | .set_default_value = set_default_value_uint, |
0be6bfac PM |
958 | }; |
959 | ||
ee6847d1 GH |
960 | /* --- public helpers --- */ |
961 | ||
962 | static Property *qdev_prop_walk(Property *props, const char *name) | |
963 | { | |
04a2d61e | 964 | if (!props) { |
ee6847d1 | 965 | return NULL; |
04a2d61e | 966 | } |
ee6847d1 | 967 | while (props->name) { |
04a2d61e | 968 | if (strcmp(props->name, name) == 0) { |
ee6847d1 | 969 | return props; |
04a2d61e | 970 | } |
ee6847d1 GH |
971 | props++; |
972 | } | |
973 | return NULL; | |
974 | } | |
975 | ||
976 | static Property *qdev_prop_find(DeviceState *dev, const char *name) | |
977 | { | |
bce54474 | 978 | ObjectClass *class; |
ee6847d1 GH |
979 | Property *prop; |
980 | ||
981 | /* device properties */ | |
bce54474 PB |
982 | class = object_get_class(OBJECT(dev)); |
983 | do { | |
984 | prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name); | |
985 | if (prop) { | |
986 | return prop; | |
987 | } | |
988 | class = object_class_get_parent(class); | |
989 | } while (class != object_class_by_name(TYPE_DEVICE)); | |
ee6847d1 GH |
990 | |
991 | return NULL; | |
992 | } | |
993 | ||
7db4c4e8 PB |
994 | void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev, |
995 | Property *prop, const char *value) | |
996 | { | |
997 | switch (ret) { | |
998 | case -EEXIST: | |
f231b88d | 999 | error_setg(errp, "Property '%s.%s' can't take value '%s', it's in use", |
f79f2bfc | 1000 | object_get_typename(OBJECT(dev)), prop->name, value); |
7db4c4e8 PB |
1001 | break; |
1002 | default: | |
1003 | case -EINVAL: | |
c6bd8c70 MA |
1004 | error_setg(errp, QERR_PROPERTY_VALUE_BAD, |
1005 | object_get_typename(OBJECT(dev)), prop->name, value); | |
7db4c4e8 PB |
1006 | break; |
1007 | case -ENOENT: | |
f231b88d | 1008 | error_setg(errp, "Property '%s.%s' can't find value '%s'", |
f79f2bfc | 1009 | object_get_typename(OBJECT(dev)), prop->name, value); |
7db4c4e8 PB |
1010 | break; |
1011 | case 0: | |
1012 | break; | |
1013 | } | |
1014 | } | |
1015 | ||
f4594a3b IY |
1016 | void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value) |
1017 | { | |
5433a0a8 | 1018 | object_property_set_bool(OBJECT(dev), value, name, &error_abort); |
f4594a3b IY |
1019 | } |
1020 | ||
c7cc172d JQ |
1021 | void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value) |
1022 | { | |
5433a0a8 | 1023 | object_property_set_int(OBJECT(dev), value, name, &error_abort); |
c7cc172d JQ |
1024 | } |
1025 | ||
ee6847d1 GH |
1026 | void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value) |
1027 | { | |
5433a0a8 | 1028 | object_property_set_int(OBJECT(dev), value, name, &error_abort); |
ee6847d1 GH |
1029 | } |
1030 | ||
1031 | void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value) | |
1032 | { | |
5433a0a8 | 1033 | object_property_set_int(OBJECT(dev), value, name, &error_abort); |
ee6847d1 GH |
1034 | } |
1035 | ||
316940b0 GH |
1036 | void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value) |
1037 | { | |
5433a0a8 | 1038 | object_property_set_int(OBJECT(dev), value, name, &error_abort); |
316940b0 GH |
1039 | } |
1040 | ||
5a053d1f BS |
1041 | void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value) |
1042 | { | |
5433a0a8 | 1043 | object_property_set_int(OBJECT(dev), value, name, &error_abort); |
5a053d1f BS |
1044 | } |
1045 | ||
3b25597b | 1046 | void qdev_prop_set_string(DeviceState *dev, const char *name, const char *value) |
cc984673 | 1047 | { |
5433a0a8 | 1048 | object_property_set_str(OBJECT(dev), value, name, &error_abort); |
cc984673 MA |
1049 | } |
1050 | ||
606fd0e2 KK |
1051 | void qdev_prop_set_macaddr(DeviceState *dev, const char *name, |
1052 | const uint8_t *value) | |
1503fff3 | 1053 | { |
9b170e60 PB |
1054 | char str[2 * 6 + 5 + 1]; |
1055 | snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x", | |
1056 | value[0], value[1], value[2], value[3], value[4], value[5]); | |
1057 | ||
5433a0a8 | 1058 | object_property_set_str(OBJECT(dev), str, name, &error_abort); |
1503fff3 GH |
1059 | } |
1060 | ||
9b170e60 | 1061 | void qdev_prop_set_enum(DeviceState *dev, const char *name, int value) |
4e4fa398 | 1062 | { |
9b170e60 | 1063 | Property *prop; |
9b170e60 PB |
1064 | |
1065 | prop = qdev_prop_find(dev, name); | |
1066 | object_property_set_str(OBJECT(dev), prop->info->enum_table[value], | |
5433a0a8 | 1067 | name, &error_abort); |
4e4fa398 JK |
1068 | } |
1069 | ||
ee6847d1 GH |
1070 | void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value) |
1071 | { | |
7a7aae21 PB |
1072 | Property *prop; |
1073 | void **ptr; | |
1074 | ||
1075 | prop = qdev_prop_find(dev, name); | |
1076 | assert(prop && prop->info == &qdev_prop_ptr); | |
1077 | ptr = qdev_get_prop_ptr(dev, prop); | |
1078 | *ptr = value; | |
ee6847d1 GH |
1079 | } |
1080 | ||
f9a8b553 | 1081 | static GList *global_props; |
b6b61144 | 1082 | |
a404b612 | 1083 | void qdev_prop_register_global(GlobalProperty *prop) |
b6b61144 | 1084 | { |
f9a8b553 | 1085 | global_props = g_list_append(global_props, prop); |
b6b61144 GH |
1086 | } |
1087 | ||
60d7caca PX |
1088 | void register_compat_prop(const char *driver, |
1089 | const char *property, | |
1090 | const char *value) | |
1091 | { | |
1092 | GlobalProperty *p = g_new0(GlobalProperty, 1); | |
1093 | ||
1094 | /* Any compat_props must never cause error */ | |
1095 | p->errp = &error_abort; | |
1096 | p->driver = driver; | |
1097 | p->property = property; | |
1098 | p->value = value; | |
1099 | qdev_prop_register_global(p); | |
1100 | } | |
1101 | ||
9ffea096 PX |
1102 | void register_compat_props_array(GlobalProperty *prop) |
1103 | { | |
1104 | for (; prop && prop->driver; prop++) { | |
1105 | register_compat_prop(prop->driver, prop->property, prop->value); | |
1106 | } | |
1107 | } | |
1108 | ||
458fb679 | 1109 | void qdev_prop_register_global_list(GlobalProperty *props) |
b6b61144 | 1110 | { |
458fb679 | 1111 | int i; |
b6b61144 | 1112 | |
458fb679 GH |
1113 | for (i = 0; props[i].driver != NULL; i++) { |
1114 | qdev_prop_register_global(props+i); | |
b6b61144 | 1115 | } |
458fb679 GH |
1116 | } |
1117 | ||
d828c430 | 1118 | int qdev_prop_check_globals(void) |
9f9260a3 | 1119 | { |
f9a8b553 | 1120 | GList *l; |
9f9260a3 DS |
1121 | int ret = 0; |
1122 | ||
f9a8b553 EH |
1123 | for (l = global_props; l; l = l->next) { |
1124 | GlobalProperty *prop = l->data; | |
b3ce84fe EH |
1125 | ObjectClass *oc; |
1126 | DeviceClass *dc; | |
1127 | if (prop->used) { | |
1128 | continue; | |
1129 | } | |
1130 | if (!prop->user_provided) { | |
1131 | continue; | |
1132 | } | |
1133 | oc = object_class_by_name(prop->driver); | |
1134 | oc = object_class_dynamic_cast(oc, TYPE_DEVICE); | |
1135 | if (!oc) { | |
1136 | error_report("Warning: global %s.%s has invalid class name", | |
1137 | prop->driver, prop->property); | |
1138 | ret = 1; | |
1139 | continue; | |
1140 | } | |
1141 | dc = DEVICE_CLASS(oc); | |
1142 | if (!dc->hotpluggable && !prop->used) { | |
1143 | error_report("Warning: global %s.%s=%s not used", | |
1144 | prop->driver, prop->property, prop->value); | |
1145 | ret = 1; | |
9f9260a3 DS |
1146 | continue; |
1147 | } | |
9f9260a3 DS |
1148 | } |
1149 | return ret; | |
1150 | } | |
1151 | ||
25f8dd96 | 1152 | static void qdev_prop_set_globals_for_type(DeviceState *dev, |
b3443f43 | 1153 | const char *typename) |
868d378b | 1154 | { |
f9a8b553 | 1155 | GList *l; |
868d378b | 1156 | |
f9a8b553 EH |
1157 | for (l = global_props; l; l = l->next) { |
1158 | GlobalProperty *prop = l->data; | |
868d378b AF |
1159 | Error *err = NULL; |
1160 | ||
1161 | if (strcmp(typename, prop->driver) != 0) { | |
1162 | continue; | |
1163 | } | |
b3ce84fe | 1164 | prop->used = true; |
98a65284 | 1165 | object_property_parse(OBJECT(dev), prop->value, prop->property, &err); |
868d378b | 1166 | if (err != NULL) { |
77280adb EH |
1167 | error_prepend(&err, "can't apply global %s.%s=%s: ", |
1168 | prop->driver, prop->property, prop->value); | |
b3443f43 | 1169 | if (!dev->hotplugged && prop->errp) { |
77280adb EH |
1170 | error_propagate(prop->errp, err); |
1171 | } else { | |
1172 | assert(prop->user_provided); | |
1173 | error_reportf_err(err, "Warning: "); | |
1174 | } | |
868d378b AF |
1175 | } |
1176 | } | |
1177 | } | |
1178 | ||
25f8dd96 | 1179 | void qdev_prop_set_globals(DeviceState *dev) |
458fb679 | 1180 | { |
bce54474 PB |
1181 | ObjectClass *class = object_get_class(OBJECT(dev)); |
1182 | ||
1183 | do { | |
25f8dd96 | 1184 | qdev_prop_set_globals_for_type(dev, object_class_get_name(class)); |
bce54474 PB |
1185 | class = object_class_get_parent(class); |
1186 | } while (class); | |
b6b61144 | 1187 | } |
e8cd45c7 VL |
1188 | |
1189 | /* --- 64bit unsigned int 'size' type --- */ | |
1190 | ||
d7bce999 EB |
1191 | static void get_size(Object *obj, Visitor *v, const char *name, void *opaque, |
1192 | Error **errp) | |
e8cd45c7 VL |
1193 | { |
1194 | DeviceState *dev = DEVICE(obj); | |
1195 | Property *prop = opaque; | |
1196 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
1197 | ||
51e72bc1 | 1198 | visit_type_size(v, name, ptr, errp); |
e8cd45c7 VL |
1199 | } |
1200 | ||
d7bce999 EB |
1201 | static void set_size(Object *obj, Visitor *v, const char *name, void *opaque, |
1202 | Error **errp) | |
e8cd45c7 VL |
1203 | { |
1204 | DeviceState *dev = DEVICE(obj); | |
1205 | Property *prop = opaque; | |
1206 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
1207 | ||
51e72bc1 | 1208 | visit_type_size(v, name, ptr, errp); |
e8cd45c7 VL |
1209 | } |
1210 | ||
e8cd45c7 VL |
1211 | PropertyInfo qdev_prop_size = { |
1212 | .name = "size", | |
e8cd45c7 VL |
1213 | .get = get_size, |
1214 | .set = set_size, | |
3fb2111f | 1215 | .set_default_value = set_default_value_uint, |
e8cd45c7 | 1216 | }; |