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