]>
Commit | Line | Data |
---|---|---|
1503fff3 | 1 | #include "net.h" |
ee6847d1 | 2 | #include "qdev.h" |
9f59b566 | 3 | #include "qerror.h" |
2446333c | 4 | #include "blockdev.h" |
ee6847d1 GH |
5 | |
6 | void *qdev_get_prop_ptr(DeviceState *dev, Property *prop) | |
7 | { | |
8 | void *ptr = dev; | |
9 | ptr += prop->offset; | |
10 | return ptr; | |
11 | } | |
12 | ||
d2364ee4 MT |
13 | static uint32_t qdev_get_prop_mask(Property *prop) |
14 | { | |
15 | assert(prop->info->type == PROP_TYPE_BIT); | |
16 | return 0x1 << prop->bitnr; | |
17 | } | |
18 | ||
19 | static void bit_prop_set(DeviceState *dev, Property *props, bool val) | |
20 | { | |
21 | uint32_t *p = qdev_get_prop_ptr(dev, props); | |
22 | uint32_t mask = qdev_get_prop_mask(props); | |
23 | if (val) | |
dbd48324 | 24 | *p |= mask; |
d2364ee4 MT |
25 | else |
26 | *p &= ~mask; | |
27 | } | |
28 | ||
29 | static void qdev_prop_cpy(DeviceState *dev, Property *props, void *src) | |
30 | { | |
31 | if (props->info->type == PROP_TYPE_BIT) { | |
32 | bool *defval = src; | |
33 | bit_prop_set(dev, props, *defval); | |
34 | } else { | |
35 | char *dst = qdev_get_prop_ptr(dev, props); | |
36 | memcpy(dst, src, props->info->size); | |
37 | } | |
38 | } | |
39 | ||
40 | /* Bit */ | |
41 | static int parse_bit(DeviceState *dev, Property *prop, const char *str) | |
42 | { | |
43 | if (!strncasecmp(str, "on", 2)) | |
44 | bit_prop_set(dev, prop, true); | |
45 | else if (!strncasecmp(str, "off", 3)) | |
46 | bit_prop_set(dev, prop, false); | |
47 | else | |
6bf38816 | 48 | return -EINVAL; |
d2364ee4 MT |
49 | return 0; |
50 | } | |
51 | ||
52 | static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len) | |
53 | { | |
54 | uint8_t *p = qdev_get_prop_ptr(dev, prop); | |
55 | return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off"); | |
56 | } | |
57 | ||
58 | PropertyInfo qdev_prop_bit = { | |
59 | .name = "on/off", | |
60 | .type = PROP_TYPE_BIT, | |
61 | .size = sizeof(uint32_t), | |
62 | .parse = parse_bit, | |
63 | .print = print_bit, | |
64 | }; | |
65 | ||
c7cc172d JQ |
66 | /* --- 8bit integer --- */ |
67 | ||
68 | static int parse_uint8(DeviceState *dev, Property *prop, const char *str) | |
69 | { | |
70 | uint8_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 71 | char *end; |
c7cc172d JQ |
72 | |
73 | /* accept both hex and decimal */ | |
449041d4 KW |
74 | *ptr = strtoul(str, &end, 0); |
75 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 76 | return -EINVAL; |
449041d4 KW |
77 | } |
78 | ||
c7cc172d JQ |
79 | return 0; |
80 | } | |
81 | ||
82 | static int print_uint8(DeviceState *dev, Property *prop, char *dest, size_t len) | |
83 | { | |
84 | uint8_t *ptr = qdev_get_prop_ptr(dev, prop); | |
85 | return snprintf(dest, len, "%" PRIu8, *ptr); | |
86 | } | |
87 | ||
88 | PropertyInfo qdev_prop_uint8 = { | |
89 | .name = "uint8", | |
90 | .type = PROP_TYPE_UINT8, | |
91 | .size = sizeof(uint8_t), | |
92 | .parse = parse_uint8, | |
93 | .print = print_uint8, | |
94 | }; | |
95 | ||
ee6847d1 GH |
96 | /* --- 16bit integer --- */ |
97 | ||
98 | static int parse_uint16(DeviceState *dev, Property *prop, const char *str) | |
99 | { | |
100 | uint16_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 101 | char *end; |
ee6847d1 GH |
102 | |
103 | /* accept both hex and decimal */ | |
449041d4 KW |
104 | *ptr = strtoul(str, &end, 0); |
105 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 106 | return -EINVAL; |
449041d4 KW |
107 | } |
108 | ||
ee6847d1 GH |
109 | return 0; |
110 | } | |
111 | ||
112 | static int print_uint16(DeviceState *dev, Property *prop, char *dest, size_t len) | |
113 | { | |
114 | uint16_t *ptr = qdev_get_prop_ptr(dev, prop); | |
115 | return snprintf(dest, len, "%" PRIu16, *ptr); | |
116 | } | |
117 | ||
118 | PropertyInfo qdev_prop_uint16 = { | |
119 | .name = "uint16", | |
120 | .type = PROP_TYPE_UINT16, | |
121 | .size = sizeof(uint16_t), | |
122 | .parse = parse_uint16, | |
123 | .print = print_uint16, | |
124 | }; | |
125 | ||
126 | /* --- 32bit integer --- */ | |
127 | ||
128 | static int parse_uint32(DeviceState *dev, Property *prop, const char *str) | |
129 | { | |
130 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 131 | char *end; |
ee6847d1 GH |
132 | |
133 | /* accept both hex and decimal */ | |
449041d4 KW |
134 | *ptr = strtoul(str, &end, 0); |
135 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 136 | return -EINVAL; |
449041d4 KW |
137 | } |
138 | ||
ee6847d1 GH |
139 | return 0; |
140 | } | |
141 | ||
142 | static int print_uint32(DeviceState *dev, Property *prop, char *dest, size_t len) | |
143 | { | |
144 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
145 | return snprintf(dest, len, "%" PRIu32, *ptr); | |
146 | } | |
147 | ||
148 | PropertyInfo qdev_prop_uint32 = { | |
149 | .name = "uint32", | |
150 | .type = PROP_TYPE_UINT32, | |
151 | .size = sizeof(uint32_t), | |
152 | .parse = parse_uint32, | |
153 | .print = print_uint32, | |
154 | }; | |
155 | ||
316940b0 GH |
156 | static int parse_int32(DeviceState *dev, Property *prop, const char *str) |
157 | { | |
158 | int32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 159 | char *end; |
316940b0 | 160 | |
449041d4 KW |
161 | *ptr = strtol(str, &end, 10); |
162 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 163 | return -EINVAL; |
449041d4 KW |
164 | } |
165 | ||
316940b0 GH |
166 | return 0; |
167 | } | |
168 | ||
169 | static int print_int32(DeviceState *dev, Property *prop, char *dest, size_t len) | |
170 | { | |
171 | int32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
172 | return snprintf(dest, len, "%" PRId32, *ptr); | |
173 | } | |
174 | ||
175 | PropertyInfo qdev_prop_int32 = { | |
176 | .name = "int32", | |
177 | .type = PROP_TYPE_INT32, | |
178 | .size = sizeof(int32_t), | |
179 | .parse = parse_int32, | |
180 | .print = print_int32, | |
181 | }; | |
182 | ||
ee6847d1 GH |
183 | /* --- 32bit hex value --- */ |
184 | ||
185 | static int parse_hex32(DeviceState *dev, Property *prop, const char *str) | |
186 | { | |
187 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 188 | char *end; |
ee6847d1 | 189 | |
449041d4 KW |
190 | *ptr = strtoul(str, &end, 16); |
191 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 192 | return -EINVAL; |
449041d4 KW |
193 | } |
194 | ||
ee6847d1 GH |
195 | return 0; |
196 | } | |
197 | ||
198 | static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len) | |
199 | { | |
200 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
201 | return snprintf(dest, len, "0x%" PRIx32, *ptr); | |
202 | } | |
203 | ||
204 | PropertyInfo qdev_prop_hex32 = { | |
205 | .name = "hex32", | |
206 | .type = PROP_TYPE_UINT32, | |
207 | .size = sizeof(uint32_t), | |
208 | .parse = parse_hex32, | |
209 | .print = print_hex32, | |
210 | }; | |
211 | ||
5a053d1f BS |
212 | /* --- 64bit integer --- */ |
213 | ||
214 | static int parse_uint64(DeviceState *dev, Property *prop, const char *str) | |
215 | { | |
216 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 217 | char *end; |
5a053d1f BS |
218 | |
219 | /* accept both hex and decimal */ | |
449041d4 KW |
220 | *ptr = strtoull(str, &end, 0); |
221 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 222 | return -EINVAL; |
449041d4 KW |
223 | } |
224 | ||
5a053d1f BS |
225 | return 0; |
226 | } | |
227 | ||
228 | static int print_uint64(DeviceState *dev, Property *prop, char *dest, size_t len) | |
229 | { | |
230 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
231 | return snprintf(dest, len, "%" PRIu64, *ptr); | |
232 | } | |
233 | ||
234 | PropertyInfo qdev_prop_uint64 = { | |
235 | .name = "uint64", | |
236 | .type = PROP_TYPE_UINT64, | |
237 | .size = sizeof(uint64_t), | |
238 | .parse = parse_uint64, | |
239 | .print = print_uint64, | |
240 | }; | |
241 | ||
242 | /* --- 64bit hex value --- */ | |
243 | ||
244 | static int parse_hex64(DeviceState *dev, Property *prop, const char *str) | |
245 | { | |
246 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
449041d4 | 247 | char *end; |
5a053d1f | 248 | |
449041d4 KW |
249 | *ptr = strtoull(str, &end, 16); |
250 | if ((*end != '\0') || (end == str)) { | |
6bf38816 | 251 | return -EINVAL; |
449041d4 KW |
252 | } |
253 | ||
5a053d1f BS |
254 | return 0; |
255 | } | |
256 | ||
257 | static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len) | |
258 | { | |
259 | uint64_t *ptr = qdev_get_prop_ptr(dev, prop); | |
260 | return snprintf(dest, len, "0x%" PRIx64, *ptr); | |
261 | } | |
262 | ||
263 | PropertyInfo qdev_prop_hex64 = { | |
264 | .name = "hex64", | |
265 | .type = PROP_TYPE_UINT64, | |
266 | .size = sizeof(uint64_t), | |
267 | .parse = parse_hex64, | |
268 | .print = print_hex64, | |
269 | }; | |
270 | ||
59419663 GH |
271 | /* --- string --- */ |
272 | ||
273 | static int parse_string(DeviceState *dev, Property *prop, const char *str) | |
274 | { | |
275 | char **ptr = qdev_get_prop_ptr(dev, prop); | |
276 | ||
277 | if (*ptr) | |
278 | qemu_free(*ptr); | |
279 | *ptr = qemu_strdup(str); | |
280 | return 0; | |
281 | } | |
282 | ||
d21357df MA |
283 | static void free_string(DeviceState *dev, Property *prop) |
284 | { | |
285 | qemu_free(*(char **)qdev_get_prop_ptr(dev, prop)); | |
286 | } | |
287 | ||
59419663 GH |
288 | static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len) |
289 | { | |
290 | char **ptr = qdev_get_prop_ptr(dev, prop); | |
291 | if (!*ptr) | |
292 | return snprintf(dest, len, "<null>"); | |
293 | return snprintf(dest, len, "\"%s\"", *ptr); | |
294 | } | |
295 | ||
296 | PropertyInfo qdev_prop_string = { | |
297 | .name = "string", | |
298 | .type = PROP_TYPE_STRING, | |
299 | .size = sizeof(char*), | |
300 | .parse = parse_string, | |
301 | .print = print_string, | |
d21357df | 302 | .free = free_string, |
59419663 GH |
303 | }; |
304 | ||
14b41872 GH |
305 | /* --- drive --- */ |
306 | ||
307 | static int parse_drive(DeviceState *dev, Property *prop, const char *str) | |
308 | { | |
f8b6cc00 MA |
309 | BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); |
310 | BlockDriverState *bs; | |
14b41872 | 311 | |
f8b6cc00 MA |
312 | bs = bdrv_find(str); |
313 | if (bs == NULL) | |
6bf38816 | 314 | return -ENOENT; |
18846dee MA |
315 | if (bdrv_attach(bs, dev) < 0) |
316 | return -EEXIST; | |
f8b6cc00 | 317 | *ptr = bs; |
14b41872 GH |
318 | return 0; |
319 | } | |
320 | ||
14bafc54 MA |
321 | static void free_drive(DeviceState *dev, Property *prop) |
322 | { | |
f8b6cc00 | 323 | BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); |
14bafc54 MA |
324 | |
325 | if (*ptr) { | |
18846dee | 326 | bdrv_detach(*ptr, dev); |
f8b6cc00 | 327 | blockdev_auto_del(*ptr); |
14bafc54 MA |
328 | } |
329 | } | |
330 | ||
14b41872 GH |
331 | static int print_drive(DeviceState *dev, Property *prop, char *dest, size_t len) |
332 | { | |
f8b6cc00 MA |
333 | BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop); |
334 | return snprintf(dest, len, "%s", | |
335 | *ptr ? bdrv_get_device_name(*ptr) : "<null>"); | |
14b41872 GH |
336 | } |
337 | ||
338 | PropertyInfo qdev_prop_drive = { | |
339 | .name = "drive", | |
340 | .type = PROP_TYPE_DRIVE, | |
f8b6cc00 | 341 | .size = sizeof(BlockDriverState *), |
14b41872 GH |
342 | .parse = parse_drive, |
343 | .print = print_drive, | |
14bafc54 | 344 | .free = free_drive, |
14b41872 GH |
345 | }; |
346 | ||
313feaab GH |
347 | /* --- character device --- */ |
348 | ||
06113719 GH |
349 | static int parse_chr(DeviceState *dev, Property *prop, const char *str) |
350 | { | |
351 | CharDriverState **ptr = qdev_get_prop_ptr(dev, prop); | |
352 | ||
353 | *ptr = qemu_chr_find(str); | |
354 | if (*ptr == NULL) | |
6bf38816 | 355 | return -ENOENT; |
06113719 GH |
356 | return 0; |
357 | } | |
358 | ||
313feaab GH |
359 | static int print_chr(DeviceState *dev, Property *prop, char *dest, size_t len) |
360 | { | |
361 | CharDriverState **ptr = qdev_get_prop_ptr(dev, prop); | |
bc19fcaa BS |
362 | |
363 | if (*ptr && (*ptr)->label) { | |
364 | return snprintf(dest, len, "%s", (*ptr)->label); | |
365 | } else { | |
366 | return snprintf(dest, len, "<null>"); | |
367 | } | |
313feaab GH |
368 | } |
369 | ||
370 | PropertyInfo qdev_prop_chr = { | |
371 | .name = "chr", | |
372 | .type = PROP_TYPE_CHR, | |
373 | .size = sizeof(CharDriverState*), | |
06113719 | 374 | .parse = parse_chr, |
313feaab GH |
375 | .print = print_chr, |
376 | }; | |
377 | ||
2ef924b4 GH |
378 | /* --- netdev device --- */ |
379 | ||
380 | static int parse_netdev(DeviceState *dev, Property *prop, const char *str) | |
381 | { | |
382 | VLANClientState **ptr = qdev_get_prop_ptr(dev, prop); | |
383 | ||
384 | *ptr = qemu_find_netdev(str); | |
385 | if (*ptr == NULL) | |
6bf38816 | 386 | return -ENOENT; |
27f3f8a3 MA |
387 | if ((*ptr)->peer) { |
388 | return -EEXIST; | |
389 | } | |
2ef924b4 GH |
390 | return 0; |
391 | } | |
392 | ||
393 | static int print_netdev(DeviceState *dev, Property *prop, char *dest, size_t len) | |
394 | { | |
395 | VLANClientState **ptr = qdev_get_prop_ptr(dev, prop); | |
396 | ||
397 | if (*ptr && (*ptr)->name) { | |
398 | return snprintf(dest, len, "%s", (*ptr)->name); | |
399 | } else { | |
400 | return snprintf(dest, len, "<null>"); | |
401 | } | |
402 | } | |
403 | ||
404 | PropertyInfo qdev_prop_netdev = { | |
405 | .name = "netdev", | |
406 | .type = PROP_TYPE_NETDEV, | |
407 | .size = sizeof(VLANClientState*), | |
408 | .parse = parse_netdev, | |
409 | .print = print_netdev, | |
410 | }; | |
411 | ||
851bec09 GH |
412 | /* --- vlan --- */ |
413 | ||
414 | static int parse_vlan(DeviceState *dev, Property *prop, const char *str) | |
415 | { | |
416 | VLANState **ptr = qdev_get_prop_ptr(dev, prop); | |
417 | int id; | |
418 | ||
419 | if (sscanf(str, "%d", &id) != 1) | |
6bf38816 | 420 | return -EINVAL; |
851bec09 GH |
421 | *ptr = qemu_find_vlan(id, 1); |
422 | if (*ptr == NULL) | |
6bf38816 | 423 | return -ENOENT; |
851bec09 GH |
424 | return 0; |
425 | } | |
426 | ||
427 | static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len) | |
428 | { | |
429 | VLANState **ptr = qdev_get_prop_ptr(dev, prop); | |
430 | ||
431 | if (*ptr) { | |
432 | return snprintf(dest, len, "%d", (*ptr)->id); | |
433 | } else { | |
434 | return snprintf(dest, len, "<null>"); | |
435 | } | |
436 | } | |
437 | ||
438 | PropertyInfo qdev_prop_vlan = { | |
439 | .name = "vlan", | |
440 | .type = PROP_TYPE_VLAN, | |
441 | .size = sizeof(VLANClientState*), | |
442 | .parse = parse_vlan, | |
443 | .print = print_vlan, | |
444 | }; | |
445 | ||
ee6847d1 GH |
446 | /* --- pointer --- */ |
447 | ||
036f7166 | 448 | /* Not a proper property, just for dirty hacks. TODO Remove it! */ |
ee6847d1 GH |
449 | PropertyInfo qdev_prop_ptr = { |
450 | .name = "ptr", | |
451 | .type = PROP_TYPE_PTR, | |
452 | .size = sizeof(void*), | |
ee6847d1 GH |
453 | }; |
454 | ||
455 | /* --- mac address --- */ | |
456 | ||
457 | /* | |
458 | * accepted syntax versions: | |
459 | * 01:02:03:04:05:06 | |
460 | * 01-02-03-04-05-06 | |
461 | */ | |
462 | static int parse_mac(DeviceState *dev, Property *prop, const char *str) | |
463 | { | |
1503fff3 | 464 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); |
ee6847d1 GH |
465 | int i, pos; |
466 | char *p; | |
467 | ||
468 | for (i = 0, pos = 0; i < 6; i++, pos += 3) { | |
88e150a5 | 469 | if (!qemu_isxdigit(str[pos])) |
6bf38816 | 470 | return -EINVAL; |
88e150a5 | 471 | if (!qemu_isxdigit(str[pos+1])) |
6bf38816 | 472 | return -EINVAL; |
1503fff3 GH |
473 | if (i == 5) { |
474 | if (str[pos+2] != '\0') | |
6bf38816 | 475 | return -EINVAL; |
1503fff3 GH |
476 | } else { |
477 | if (str[pos+2] != ':' && str[pos+2] != '-') | |
6bf38816 | 478 | return -EINVAL; |
1503fff3 GH |
479 | } |
480 | mac->a[i] = strtol(str+pos, &p, 16); | |
ee6847d1 GH |
481 | } |
482 | return 0; | |
483 | } | |
484 | ||
485 | static int print_mac(DeviceState *dev, Property *prop, char *dest, size_t len) | |
486 | { | |
1503fff3 GH |
487 | MACAddr *mac = qdev_get_prop_ptr(dev, prop); |
488 | ||
ee6847d1 | 489 | return snprintf(dest, len, "%02x:%02x:%02x:%02x:%02x:%02x", |
1503fff3 GH |
490 | mac->a[0], mac->a[1], mac->a[2], |
491 | mac->a[3], mac->a[4], mac->a[5]); | |
ee6847d1 GH |
492 | } |
493 | ||
494 | PropertyInfo qdev_prop_macaddr = { | |
1503fff3 | 495 | .name = "macaddr", |
ee6847d1 | 496 | .type = PROP_TYPE_MACADDR, |
1503fff3 | 497 | .size = sizeof(MACAddr), |
ee6847d1 GH |
498 | .parse = parse_mac, |
499 | .print = print_mac, | |
500 | }; | |
501 | ||
05cb5fe4 GH |
502 | /* --- pci address --- */ |
503 | ||
504 | /* | |
505 | * bus-local address, i.e. "$slot" or "$slot.$fn" | |
506 | */ | |
507 | static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str) | |
508 | { | |
509 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
510 | unsigned int slot, fn, n; | |
511 | ||
512 | if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) { | |
513 | fn = 0; | |
514 | if (sscanf(str, "%x%n", &slot, &n) != 1) { | |
6bf38816 | 515 | return -EINVAL; |
05cb5fe4 GH |
516 | } |
517 | } | |
518 | if (str[n] != '\0') | |
6bf38816 | 519 | return -EINVAL; |
05cb5fe4 | 520 | if (fn > 7) |
6bf38816 | 521 | return -EINVAL; |
05cb5fe4 GH |
522 | *ptr = slot << 3 | fn; |
523 | return 0; | |
524 | } | |
525 | ||
526 | static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len) | |
527 | { | |
528 | uint32_t *ptr = qdev_get_prop_ptr(dev, prop); | |
529 | ||
73538c31 | 530 | if (*ptr == -1) { |
05cb5fe4 GH |
531 | return snprintf(dest, len, "<unset>"); |
532 | } else { | |
533 | return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7); | |
534 | } | |
535 | } | |
536 | ||
537 | PropertyInfo qdev_prop_pci_devfn = { | |
538 | .name = "pci-devfn", | |
539 | .type = PROP_TYPE_UINT32, | |
540 | .size = sizeof(uint32_t), | |
541 | .parse = parse_pci_devfn, | |
542 | .print = print_pci_devfn, | |
543 | }; | |
544 | ||
ee6847d1 GH |
545 | /* --- public helpers --- */ |
546 | ||
547 | static Property *qdev_prop_walk(Property *props, const char *name) | |
548 | { | |
549 | if (!props) | |
550 | return NULL; | |
551 | while (props->name) { | |
552 | if (strcmp(props->name, name) == 0) | |
553 | return props; | |
554 | props++; | |
555 | } | |
556 | return NULL; | |
557 | } | |
558 | ||
559 | static Property *qdev_prop_find(DeviceState *dev, const char *name) | |
560 | { | |
561 | Property *prop; | |
562 | ||
563 | /* device properties */ | |
564 | prop = qdev_prop_walk(dev->info->props, name); | |
565 | if (prop) | |
566 | return prop; | |
567 | ||
568 | /* bus properties */ | |
569 | prop = qdev_prop_walk(dev->parent_bus->info->props, name); | |
570 | if (prop) | |
571 | return prop; | |
572 | ||
573 | return NULL; | |
574 | } | |
575 | ||
d8ed79ae GH |
576 | int qdev_prop_exists(DeviceState *dev, const char *name) |
577 | { | |
578 | return qdev_prop_find(dev, name) ? true : false; | |
579 | } | |
580 | ||
ee6847d1 GH |
581 | int qdev_prop_parse(DeviceState *dev, const char *name, const char *value) |
582 | { | |
583 | Property *prop; | |
6bf38816 | 584 | int ret; |
ee6847d1 GH |
585 | |
586 | prop = qdev_prop_find(dev, name); | |
036f7166 MA |
587 | /* |
588 | * TODO Properties without a parse method are just for dirty | |
589 | * hacks. qdev_prop_ptr is the only such PropertyInfo. It's | |
590 | * marked for removal. The test !prop->info->parse should be | |
591 | * removed along with it. | |
592 | */ | |
593 | if (!prop || !prop->info->parse) { | |
fdcfa190 | 594 | qerror_report(QERR_PROPERTY_NOT_FOUND, dev->info->name, name); |
ee6847d1 GH |
595 | return -1; |
596 | } | |
6bf38816 MA |
597 | ret = prop->info->parse(dev, prop, value); |
598 | if (ret < 0) { | |
599 | switch (ret) { | |
27f3f8a3 | 600 | case -EEXIST: |
fdcfa190 MA |
601 | qerror_report(QERR_PROPERTY_VALUE_IN_USE, |
602 | dev->info->name, name, value); | |
27f3f8a3 | 603 | break; |
6bf38816 MA |
604 | default: |
605 | case -EINVAL: | |
fdcfa190 MA |
606 | qerror_report(QERR_PROPERTY_VALUE_BAD, |
607 | dev->info->name, name, value); | |
6bf38816 MA |
608 | break; |
609 | case -ENOENT: | |
fdcfa190 MA |
610 | qerror_report(QERR_PROPERTY_VALUE_NOT_FOUND, |
611 | dev->info->name, name, value); | |
6bf38816 MA |
612 | break; |
613 | } | |
9ef5c4bf GH |
614 | return -1; |
615 | } | |
616 | return 0; | |
ee6847d1 GH |
617 | } |
618 | ||
619 | void qdev_prop_set(DeviceState *dev, const char *name, void *src, enum PropertyType type) | |
620 | { | |
621 | Property *prop; | |
ee6847d1 GH |
622 | |
623 | prop = qdev_prop_find(dev, name); | |
624 | if (!prop) { | |
625 | fprintf(stderr, "%s: property \"%s.%s\" not found\n", | |
626 | __FUNCTION__, dev->info->name, name); | |
627 | abort(); | |
628 | } | |
629 | if (prop->info->type != type) { | |
630 | fprintf(stderr, "%s: property \"%s.%s\" type mismatch\n", | |
631 | __FUNCTION__, dev->info->name, name); | |
632 | abort(); | |
633 | } | |
d2364ee4 | 634 | qdev_prop_cpy(dev, prop, src); |
ee6847d1 GH |
635 | } |
636 | ||
f4594a3b IY |
637 | void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value) |
638 | { | |
639 | qdev_prop_set(dev, name, &value, PROP_TYPE_BIT); | |
640 | } | |
641 | ||
c7cc172d JQ |
642 | void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value) |
643 | { | |
644 | qdev_prop_set(dev, name, &value, PROP_TYPE_UINT8); | |
645 | } | |
646 | ||
ee6847d1 GH |
647 | void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value) |
648 | { | |
649 | qdev_prop_set(dev, name, &value, PROP_TYPE_UINT16); | |
650 | } | |
651 | ||
652 | void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value) | |
653 | { | |
654 | qdev_prop_set(dev, name, &value, PROP_TYPE_UINT32); | |
655 | } | |
656 | ||
316940b0 GH |
657 | void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value) |
658 | { | |
659 | qdev_prop_set(dev, name, &value, PROP_TYPE_INT32); | |
660 | } | |
661 | ||
5a053d1f BS |
662 | void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value) |
663 | { | |
664 | qdev_prop_set(dev, name, &value, PROP_TYPE_UINT64); | |
665 | } | |
666 | ||
cc984673 MA |
667 | void qdev_prop_set_string(DeviceState *dev, const char *name, char *value) |
668 | { | |
669 | qdev_prop_set(dev, name, &value, PROP_TYPE_STRING); | |
670 | } | |
671 | ||
18846dee | 672 | int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value) |
14b41872 | 673 | { |
18846dee MA |
674 | int res; |
675 | ||
676 | res = bdrv_attach(value, dev); | |
677 | if (res < 0) { | |
678 | error_report("Can't attach drive %s to %s.%s: %s", | |
679 | bdrv_get_device_name(value), | |
680 | dev->id ? dev->id : dev->info->name, | |
681 | name, strerror(-res)); | |
682 | return -1; | |
683 | } | |
14b41872 | 684 | qdev_prop_set(dev, name, &value, PROP_TYPE_DRIVE); |
18846dee | 685 | return 0; |
14b41872 GH |
686 | } |
687 | ||
18846dee MA |
688 | void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value) |
689 | { | |
690 | if (qdev_prop_set_drive(dev, name, value) < 0) { | |
691 | exit(1); | |
692 | } | |
693 | } | |
313feaab GH |
694 | void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value) |
695 | { | |
696 | qdev_prop_set(dev, name, &value, PROP_TYPE_CHR); | |
697 | } | |
698 | ||
2ef924b4 GH |
699 | void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value) |
700 | { | |
701 | qdev_prop_set(dev, name, &value, PROP_TYPE_NETDEV); | |
702 | } | |
703 | ||
851bec09 GH |
704 | void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value) |
705 | { | |
706 | qdev_prop_set(dev, name, &value, PROP_TYPE_VLAN); | |
707 | } | |
708 | ||
1503fff3 GH |
709 | void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value) |
710 | { | |
711 | qdev_prop_set(dev, name, value, PROP_TYPE_MACADDR); | |
712 | } | |
713 | ||
ee6847d1 GH |
714 | void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value) |
715 | { | |
716 | qdev_prop_set(dev, name, &value, PROP_TYPE_PTR); | |
717 | } | |
718 | ||
719 | void qdev_prop_set_defaults(DeviceState *dev, Property *props) | |
720 | { | |
ee6847d1 GH |
721 | if (!props) |
722 | return; | |
723 | while (props->name) { | |
724 | if (props->defval) { | |
d2364ee4 | 725 | qdev_prop_cpy(dev, props, props->defval); |
ee6847d1 GH |
726 | } |
727 | props++; | |
728 | } | |
729 | } | |
730 | ||
458fb679 | 731 | static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props); |
b6b61144 | 732 | |
25920d6a | 733 | static void qdev_prop_register_global(GlobalProperty *prop) |
b6b61144 | 734 | { |
458fb679 | 735 | QTAILQ_INSERT_TAIL(&global_props, prop, next); |
b6b61144 GH |
736 | } |
737 | ||
458fb679 | 738 | void qdev_prop_register_global_list(GlobalProperty *props) |
b6b61144 | 739 | { |
458fb679 | 740 | int i; |
b6b61144 | 741 | |
458fb679 GH |
742 | for (i = 0; props[i].driver != NULL; i++) { |
743 | qdev_prop_register_global(props+i); | |
b6b61144 | 744 | } |
458fb679 GH |
745 | } |
746 | ||
747 | void qdev_prop_set_globals(DeviceState *dev) | |
748 | { | |
749 | GlobalProperty *prop; | |
750 | ||
751 | QTAILQ_FOREACH(prop, &global_props, next) { | |
07a8de35 GH |
752 | if (strcmp(dev->info->name, prop->driver) != 0 && |
753 | strcmp(dev->info->bus_info->name, prop->driver) != 0) { | |
b6b61144 GH |
754 | continue; |
755 | } | |
756 | if (qdev_prop_parse(dev, prop->property, prop->value) != 0) { | |
9ef5c4bf | 757 | exit(1); |
b6b61144 GH |
758 | } |
759 | } | |
760 | } | |
25920d6a KW |
761 | |
762 | static int qdev_add_one_global(QemuOpts *opts, void *opaque) | |
763 | { | |
764 | GlobalProperty *g; | |
765 | ||
766 | g = qemu_mallocz(sizeof(*g)); | |
767 | g->driver = qemu_opt_get(opts, "driver"); | |
768 | g->property = qemu_opt_get(opts, "property"); | |
769 | g->value = qemu_opt_get(opts, "value"); | |
770 | qdev_prop_register_global(g); | |
771 | return 0; | |
772 | } | |
773 | ||
774 | void qemu_add_globals(void) | |
775 | { | |
3329f07b | 776 | qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0); |
25920d6a | 777 | } |