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