]> git.proxmox.com Git - qemu.git/blob - hw/qdev-properties.c
projects / qemu.git / blob
? search:


002c7f9726b7de5ac63780a9e88dacfd61e8430d
[qemu.git] / hw / qdev-properties.c
1 #include "net.h"
2 #include "qdev.h"
3 #include "qerror.h"
4 #include "blockdev.h"
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
13 static void get_pointer(Object *obj, Visitor *v, Property *prop,
14 const char *(*print)(void *ptr),
15 const char *name, Error **errp)
16 {
17 DeviceState *dev = DEVICE(obj);
18 void **ptr = qdev_get_prop_ptr(dev, prop);
19 char *p;
20
21 p = (char *) (*ptr ? print(*ptr) : "");
22 visit_type_str(v, &p, name, errp);
23 }
24
25 static void set_pointer(Object *obj, Visitor *v, Property *prop,
26 int (*parse)(DeviceState *dev, const char *str,
27 void **ptr),
28 const char *name, Error **errp)
29 {
30 DeviceState *dev = DEVICE(obj);
31 Error *local_err = NULL;
32 void **ptr = qdev_get_prop_ptr(dev, prop);
33 char *str;
34 int ret;
35
36 if (dev->state != DEV_STATE_CREATED) {
37 error_set(errp, QERR_PERMISSION_DENIED);
38 return;
39 }
40
41 visit_type_str(v, &str, name, &local_err);
42 if (local_err) {
43 error_propagate(errp, local_err);
44 return;
45 }
46 if (!*str) {
47 g_free(str);
48 *ptr = NULL;
49 return;
50 }
51 ret = parse(dev, str, ptr);
52 error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
53 g_free(str);
54 }
55
56 static void get_enum(Object *obj, Visitor *v, void *opaque,
57 const char *name, Error **errp)
58 {
59 DeviceState *dev = DEVICE(obj);
60 Property *prop = opaque;
61 int *ptr = qdev_get_prop_ptr(dev, prop);
62
63 visit_type_enum(v, ptr, prop->info->enum_table,
64 prop->info->name, prop->name, errp);
65 }
66
67 static void set_enum(Object *obj, Visitor *v, void *opaque,
68 const char *name, Error **errp)
69 {
70 DeviceState *dev = DEVICE(obj);
71 Property *prop = opaque;
72 int *ptr = qdev_get_prop_ptr(dev, prop);
73
74 if (dev->state != DEV_STATE_CREATED) {
75 error_set(errp, QERR_PERMISSION_DENIED);
76 return;
77 }
78
79 visit_type_enum(v, ptr, prop->info->enum_table,
80 prop->info->name, prop->name, errp);
81 }
82
83 /* Bit */
84
85 static uint32_t qdev_get_prop_mask(Property *prop)
86 {
87 assert(prop->info == &qdev_prop_bit);
88 return 0x1 << prop->bitnr;
89 }
90
91 static void bit_prop_set(DeviceState *dev, Property *props, bool val)
92 {
93 uint32_t *p = qdev_get_prop_ptr(dev, props);
94 uint32_t mask = qdev_get_prop_mask(props);
95 if (val)
96 *p |= mask;
97 else
98 *p &= ~mask;
99 }
100
101 static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len)
102 {
103 uint32_t *p = qdev_get_prop_ptr(dev, prop);
104 return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");
105 }
106
107 static void get_bit(Object *obj, Visitor *v, void *opaque,
108 const char *name, Error **errp)
109 {
110 DeviceState *dev = DEVICE(obj);
111 Property *prop = opaque;
112 uint32_t *p = qdev_get_prop_ptr(dev, prop);
113 bool value = (*p & qdev_get_prop_mask(prop)) != 0;
114
115 visit_type_bool(v, &value, name, errp);
116 }
117
118 static void set_bit(Object *obj, Visitor *v, void *opaque,
119 const char *name, Error **errp)
120 {
121 DeviceState *dev = DEVICE(obj);
122 Property *prop = opaque;
123 Error *local_err = NULL;
124 bool value;
125
126 if (dev->state != DEV_STATE_CREATED) {
127 error_set(errp, QERR_PERMISSION_DENIED);
128 return;
129 }
130
131 visit_type_bool(v, &value, name, &local_err);
132 if (local_err) {
133 error_propagate(errp, local_err);
134 return;
135 }
136 bit_prop_set(dev, prop, value);
137 }
138
139 PropertyInfo qdev_prop_bit = {
140 .name = "boolean",
141 .legacy_name = "on/off",
142 .print = print_bit,
143 .get = get_bit,
144 .set = set_bit,
145 };
146
147 /* --- 8bit integer --- */
148
149 static void get_uint8(Object *obj, Visitor *v, void *opaque,
150 const char *name, Error **errp)
151 {
152 DeviceState *dev = DEVICE(obj);
153 Property *prop = opaque;
154 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
155
156 visit_type_uint8(v, ptr, name, errp);
157 }
158
159 static void set_uint8(Object *obj, Visitor *v, void *opaque,
160 const char *name, Error **errp)
161 {
162 DeviceState *dev = DEVICE(obj);
163 Property *prop = opaque;
164 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
165
166 if (dev->state != DEV_STATE_CREATED) {
167 error_set(errp, QERR_PERMISSION_DENIED);
168 return;
169 }
170
171 visit_type_uint8(v, ptr, name, errp);
172 }
173
174 PropertyInfo qdev_prop_uint8 = {
175 .name = "uint8",
176 .get = get_uint8,
177 .set = set_uint8,
178 };
179
180 /* --- 8bit hex value --- */
181
182 static int parse_hex8(DeviceState *dev, Property *prop, const char *str)
183 {
184 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
185 char *end;
186
187 if (str[0] != '0' || str[1] != 'x') {
188 return -EINVAL;
189 }
190
191 *ptr = strtoul(str, &end, 16);
192 if ((*end != '\0') || (end == str)) {
193 return -EINVAL;
194 }
195
196 return 0;
197 }
198
199 static int print_hex8(DeviceState *dev, Property *prop, char *dest, size_t len)
200 {
201 uint8_t *ptr = qdev_get_prop_ptr(dev, prop);
202 return snprintf(dest, len, "0x%" PRIx8, *ptr);
203 }
204
205 PropertyInfo qdev_prop_hex8 = {
206 .name = "uint8",
207 .legacy_name = "hex8",
208 .parse = parse_hex8,
209 .print = print_hex8,
210 .get = get_uint8,
211 .set = set_uint8,
212 };
213
214 /* --- 16bit integer --- */
215
216 static void get_uint16(Object *obj, Visitor *v, void *opaque,
217 const char *name, Error **errp)
218 {
219 DeviceState *dev = DEVICE(obj);
220 Property *prop = opaque;
221 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
222
223 visit_type_uint16(v, ptr, name, errp);
224 }
225
226 static void set_uint16(Object *obj, Visitor *v, void *opaque,
227 const char *name, Error **errp)
228 {
229 DeviceState *dev = DEVICE(obj);
230 Property *prop = opaque;
231 uint16_t *ptr = qdev_get_prop_ptr(dev, prop);
232
233 if (dev->state != DEV_STATE_CREATED) {
234 error_set(errp, QERR_PERMISSION_DENIED);
235 return;
236 }
237
238 visit_type_uint16(v, ptr, name, errp);
239 }
240
241 PropertyInfo qdev_prop_uint16 = {
242 .name = "uint16",
243 .get = get_uint16,
244 .set = set_uint16,
245 };
246
247 /* --- 32bit integer --- */
248
249 static void get_uint32(Object *obj, Visitor *v, void *opaque,
250 const char *name, Error **errp)
251 {
252 DeviceState *dev = DEVICE(obj);
253 Property *prop = opaque;
254 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
255
256 visit_type_uint32(v, ptr, name, errp);
257 }
258
259 static void set_uint32(Object *obj, Visitor *v, void *opaque,
260 const char *name, Error **errp)
261 {
262 DeviceState *dev = DEVICE(obj);
263 Property *prop = opaque;
264 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
265
266 if (dev->state != DEV_STATE_CREATED) {
267 error_set(errp, QERR_PERMISSION_DENIED);
268 return;
269 }
270
271 visit_type_uint32(v, ptr, name, errp);
272 }
273
274 static void get_int32(Object *obj, Visitor *v, void *opaque,
275 const char *name, Error **errp)
276 {
277 DeviceState *dev = DEVICE(obj);
278 Property *prop = opaque;
279 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
280
281 visit_type_int32(v, ptr, name, errp);
282 }
283
284 static void set_int32(Object *obj, Visitor *v, void *opaque,
285 const char *name, Error **errp)
286 {
287 DeviceState *dev = DEVICE(obj);
288 Property *prop = opaque;
289 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
290
291 if (dev->state != DEV_STATE_CREATED) {
292 error_set(errp, QERR_PERMISSION_DENIED);
293 return;
294 }
295
296 visit_type_int32(v, ptr, name, errp);
297 }
298
299 PropertyInfo qdev_prop_uint32 = {
300 .name = "uint32",
301 .get = get_uint32,
302 .set = set_uint32,
303 };
304
305 PropertyInfo qdev_prop_int32 = {
306 .name = "int32",
307 .get = get_int32,
308 .set = set_int32,
309 };
310
311 /* --- 32bit hex value --- */
312
313 static int parse_hex32(DeviceState *dev, Property *prop, const char *str)
314 {
315 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
316 char *end;
317
318 if (str[0] != '0' || str[1] != 'x') {
319 return -EINVAL;
320 }
321
322 *ptr = strtoul(str, &end, 16);
323 if ((*end != '\0') || (end == str)) {
324 return -EINVAL;
325 }
326
327 return 0;
328 }
329
330 static int print_hex32(DeviceState *dev, Property *prop, char *dest, size_t len)
331 {
332 uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
333 return snprintf(dest, len, "0x%" PRIx32, *ptr);
334 }
335
336 PropertyInfo qdev_prop_hex32 = {
337 .name = "uint32",
338 .legacy_name = "hex32",
339 .parse = parse_hex32,
340 .print = print_hex32,
341 .get = get_uint32,
342 .set = set_uint32,
343 };
344
345 /* --- 64bit integer --- */
346
347 static void get_uint64(Object *obj, Visitor *v, void *opaque,
348 const char *name, Error **errp)
349 {
350 DeviceState *dev = DEVICE(obj);
351 Property *prop = opaque;
352 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
353
354 visit_type_uint64(v, ptr, name, errp);
355 }
356
357 static void set_uint64(Object *obj, Visitor *v, void *opaque,
358 const char *name, Error **errp)
359 {
360 DeviceState *dev = DEVICE(obj);
361 Property *prop = opaque;
362 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
363
364 if (dev->state != DEV_STATE_CREATED) {
365 error_set(errp, QERR_PERMISSION_DENIED);
366 return;
367 }
368
369 visit_type_uint64(v, ptr, name, errp);
370 }
371
372 PropertyInfo qdev_prop_uint64 = {
373 .name = "uint64",
374 .get = get_uint64,
375 .set = set_uint64,
376 };
377
378 /* --- 64bit hex value --- */
379
380 static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
381 {
382 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
383 char *end;
384
385 if (str[0] != '0' || str[1] != 'x') {
386 return -EINVAL;
387 }
388
389 *ptr = strtoull(str, &end, 16);
390 if ((*end != '\0') || (end == str)) {
391 return -EINVAL;
392 }
393
394 return 0;
395 }
396
397 static int print_hex64(DeviceState *dev, Property *prop, char *dest, size_t len)
398 {
399 uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
400 return snprintf(dest, len, "0x%" PRIx64, *ptr);
401 }
402
403 PropertyInfo qdev_prop_hex64 = {
404 .name = "uint64",
405 .legacy_name = "hex64",
406 .parse = parse_hex64,
407 .print = print_hex64,
408 .get = get_uint64,
409 .set = set_uint64,
410 };
411
412 /* --- string --- */
413
414 static void release_string(Object *obj, const char *name, void *opaque)
415 {
416 Property *prop = opaque;
417 g_free(*(char **)qdev_get_prop_ptr(DEVICE(obj), prop));
418 }
419
420 static int print_string(DeviceState *dev, Property *prop, char *dest, size_t len)
421 {
422 char **ptr = qdev_get_prop_ptr(dev, prop);
423 if (!*ptr)
424 return snprintf(dest, len, "<null>");
425 return snprintf(dest, len, "\"%s\"", *ptr);
426 }
427
428 static void get_string(Object *obj, Visitor *v, void *opaque,
429 const char *name, Error **errp)
430 {
431 DeviceState *dev = DEVICE(obj);
432 Property *prop = opaque;
433 char **ptr = qdev_get_prop_ptr(dev, prop);
434
435 if (!*ptr) {
436 char *str = (char *)"";
437 visit_type_str(v, &str, name, errp);
438 } else {
439 visit_type_str(v, ptr, name, errp);
440 }
441 }
442
443 static void set_string(Object *obj, Visitor *v, void *opaque,
444 const char *name, Error **errp)
445 {
446 DeviceState *dev = DEVICE(obj);
447 Property *prop = opaque;
448 char **ptr = qdev_get_prop_ptr(dev, prop);
449 Error *local_err = NULL;
450 char *str;
451
452 if (dev->state != DEV_STATE_CREATED) {
453 error_set(errp, QERR_PERMISSION_DENIED);
454 return;
455 }
456
457 visit_type_str(v, &str, name, &local_err);
458 if (local_err) {
459 error_propagate(errp, local_err);
460 return;
461 }
462 if (*ptr) {
463 g_free(*ptr);
464 }
465 *ptr = str;
466 }
467
468 PropertyInfo qdev_prop_string = {
469 .name = "string",
470 .print = print_string,
471 .release = release_string,
472 .get = get_string,
473 .set = set_string,
474 };
475
476 /* --- drive --- */
477
478 static int parse_drive(DeviceState *dev, const char *str, void **ptr)
479 {
480 BlockDriverState *bs;
481
482 bs = bdrv_find(str);
483 if (bs == NULL)
484 return -ENOENT;
485 if (bdrv_attach_dev(bs, dev) < 0)
486 return -EEXIST;
487 *ptr = bs;
488 return 0;
489 }
490
491 static void release_drive(Object *obj, const char *name, void *opaque)
492 {
493 DeviceState *dev = DEVICE(obj);
494 Property *prop = opaque;
495 BlockDriverState **ptr = qdev_get_prop_ptr(dev, prop);
496
497 if (*ptr) {
498 bdrv_detach_dev(*ptr, dev);
499 blockdev_auto_del(*ptr);
500 }
501 }
502
503 static const char *print_drive(void *ptr)
504 {
505 return bdrv_get_device_name(ptr);
506 }
507
508 static void get_drive(Object *obj, Visitor *v, void *opaque,
509 const char *name, Error **errp)
510 {
511 get_pointer(obj, v, opaque, print_drive, name, errp);
512 }
513
514 static void set_drive(Object *obj, Visitor *v, void *opaque,
515 const char *name, Error **errp)
516 {
517 set_pointer(obj, v, opaque, parse_drive, name, errp);
518 }
519
520 PropertyInfo qdev_prop_drive = {
521 .name = "drive",
522 .get = get_drive,
523 .set = set_drive,
524 .release = release_drive,
525 };
526
527 /* --- character device --- */
528
529 static int parse_chr(DeviceState *dev, const char *str, void **ptr)
530 {
531 CharDriverState *chr = qemu_chr_find(str);
532 if (chr == NULL) {
533 return -ENOENT;
534 }
535 if (chr->avail_connections < 1) {
536 return -EEXIST;
537 }
538 *ptr = chr;
539 --chr->avail_connections;
540 return 0;
541 }
542
543 static void release_chr(Object *obj, const char *name, void *opaque)
544 {
545 DeviceState *dev = DEVICE(obj);
546 Property *prop = opaque;
547 CharDriverState **ptr = qdev_get_prop_ptr(dev, prop);
548
549 if (*ptr) {
550 qemu_chr_add_handlers(*ptr, NULL, NULL, NULL, NULL);
551 }
552 }
553
554
555 static const char *print_chr(void *ptr)
556 {
557 CharDriverState *chr = ptr;
558
559 return chr->label ? chr->label : "";
560 }
561
562 static void get_chr(Object *obj, Visitor *v, void *opaque,
563 const char *name, Error **errp)
564 {
565 get_pointer(obj, v, opaque, print_chr, name, errp);
566 }
567
568 static void set_chr(Object *obj, Visitor *v, void *opaque,
569 const char *name, Error **errp)
570 {
571 set_pointer(obj, v, opaque, parse_chr, name, errp);
572 }
573
574 PropertyInfo qdev_prop_chr = {
575 .name = "chr",
576 .get = get_chr,
577 .set = set_chr,
578 .release = release_chr,
579 };
580
581 /* --- netdev device --- */
582
583 static int parse_netdev(DeviceState *dev, const char *str, void **ptr)
584 {
585 VLANClientState *netdev = qemu_find_netdev(str);
586
587 if (netdev == NULL) {
588 return -ENOENT;
589 }
590 if (netdev->peer) {
591 return -EEXIST;
592 }
593 *ptr = netdev;
594 return 0;
595 }
596
597 static const char *print_netdev(void *ptr)
598 {
599 VLANClientState *netdev = ptr;
600
601 return netdev->name ? netdev->name : "";
602 }
603
604 static void get_netdev(Object *obj, Visitor *v, void *opaque,
605 const char *name, Error **errp)
606 {
607 get_pointer(obj, v, opaque, print_netdev, name, errp);
608 }
609
610 static void set_netdev(Object *obj, Visitor *v, void *opaque,
611 const char *name, Error **errp)
612 {
613 set_pointer(obj, v, opaque, parse_netdev, name, errp);
614 }
615
616 PropertyInfo qdev_prop_netdev = {
617 .name = "netdev",
618 .get = get_netdev,
619 .set = set_netdev,
620 };
621
622 /* --- vlan --- */
623
624 static int print_vlan(DeviceState *dev, Property *prop, char *dest, size_t len)
625 {
626 VLANState **ptr = qdev_get_prop_ptr(dev, prop);
627
628 if (*ptr) {
629 return snprintf(dest, len, "%d", (*ptr)->id);
630 } else {
631 return snprintf(dest, len, "<null>");
632 }
633 }
634
635 static void get_vlan(Object *obj, Visitor *v, void *opaque,
636 const char *name, Error **errp)
637 {
638 DeviceState *dev = DEVICE(obj);
639 Property *prop = opaque;
640 VLANState **ptr = qdev_get_prop_ptr(dev, prop);
641 int64_t id;
642
643 id = *ptr ? (*ptr)->id : -1;
644 visit_type_int64(v, &id, name, errp);
645 }
646
647 static void set_vlan(Object *obj, Visitor *v, void *opaque,
648 const char *name, Error **errp)
649 {
650 DeviceState *dev = DEVICE(obj);
651 Property *prop = opaque;
652 VLANState **ptr = qdev_get_prop_ptr(dev, prop);
653 Error *local_err = NULL;
654 int64_t id;
655 VLANState *vlan;
656
657 if (dev->state != DEV_STATE_CREATED) {
658 error_set(errp, QERR_PERMISSION_DENIED);
659 return;
660 }
661
662 visit_type_int64(v, &id, name, &local_err);
663 if (local_err) {
664 error_propagate(errp, local_err);
665 return;
666 }
667 if (id == -1) {
668 *ptr = NULL;
669 return;
670 }
671 vlan = qemu_find_vlan(id, 1);
672 if (!vlan) {
673 error_set(errp, QERR_INVALID_PARAMETER_VALUE,
674 name, prop->info->name);
675 return;
676 }
677 *ptr = vlan;
678 }
679
680 PropertyInfo qdev_prop_vlan = {
681 .name = "vlan",
682 .print = print_vlan,
683 .get = get_vlan,
684 .set = set_vlan,
685 };
686
687 /* --- pointer --- */
688
689 /* Not a proper property, just for dirty hacks. TODO Remove it! */
690 PropertyInfo qdev_prop_ptr = {
691 .name = "ptr",
692 };
693
694 /* --- mac address --- */
695
696 /*
697 * accepted syntax versions:
698 * 01:02:03:04:05:06
699 * 01-02-03-04-05-06
700 */
701 static void get_mac(Object *obj, Visitor *v, void *opaque,
702 const char *name, Error **errp)
703 {
704 DeviceState *dev = DEVICE(obj);
705 Property *prop = opaque;
706 MACAddr *mac = qdev_get_prop_ptr(dev, prop);
707 char buffer[2 * 6 + 5 + 1];
708 char *p = buffer;
709
710 snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
711 mac->a[0], mac->a[1], mac->a[2],
712 mac->a[3], mac->a[4], mac->a[5]);
713
714 visit_type_str(v, &p, name, errp);
715 }
716
717 static void set_mac(Object *obj, Visitor *v, void *opaque,
718 const char *name, Error **errp)
719 {
720 DeviceState *dev = DEVICE(obj);
721 Property *prop = opaque;
722 MACAddr *mac = qdev_get_prop_ptr(dev, prop);
723 Error *local_err = NULL;
724 int i, pos;
725 char *str, *p;
726
727 if (dev->state != DEV_STATE_CREATED) {
728 error_set(errp, QERR_PERMISSION_DENIED);
729 return;
730 }
731
732 visit_type_str(v, &str, name, &local_err);
733 if (local_err) {
734 error_propagate(errp, local_err);
735 return;
736 }
737
738 for (i = 0, pos = 0; i < 6; i++, pos += 3) {
739 if (!qemu_isxdigit(str[pos]))
740 goto inval;
741 if (!qemu_isxdigit(str[pos+1]))
742 goto inval;
743 if (i == 5) {
744 if (str[pos+2] != '\0')
745 goto inval;
746 } else {
747 if (str[pos+2] != ':' && str[pos+2] != '-')
748 goto inval;
749 }
750 mac->a[i] = strtol(str+pos, &p, 16);
751 }
752 g_free(str);
753 return;
754
755 inval:
756 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
757 g_free(str);
758 }
759
760 PropertyInfo qdev_prop_macaddr = {
761 .name = "macaddr",
762 .get = get_mac,
763 .set = set_mac,
764 };
765
766 /* --- lost tick policy --- */
767
768 static const char *lost_tick_policy_table[LOST_TICK_MAX+1] = {
769 [LOST_TICK_DISCARD] = "discard",
770 [LOST_TICK_DELAY] = "delay",
771 [LOST_TICK_MERGE] = "merge",
772 [LOST_TICK_SLEW] = "slew",
773 [LOST_TICK_MAX] = NULL,
774 };
775
776 QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
777
778 PropertyInfo qdev_prop_losttickpolicy = {
779 .name = "LostTickPolicy",
780 .enum_table = lost_tick_policy_table,
781 .get = get_enum,
782 .set = set_enum,
783 };
784
785 /* --- pci address --- */
786
787 /*
788 * bus-local address, i.e. "$slot" or "$slot.$fn"
789 */
790 static void set_pci_devfn(Object *obj, Visitor *v, void *opaque,
791 const char *name, Error **errp)
792 {
793 DeviceState *dev = DEVICE(obj);
794 Property *prop = opaque;
795 int32_t value, *ptr = qdev_get_prop_ptr(dev, prop);
796 unsigned int slot, fn, n;
797 Error *local_err = NULL;
798 char *str;
799
800 if (dev->state != DEV_STATE_CREATED) {
801 error_set(errp, QERR_PERMISSION_DENIED);
802 return;
803 }
804
805 visit_type_str(v, &str, name, &local_err);
806 if (local_err) {
807 error_free(local_err);
808 local_err = NULL;
809 visit_type_int32(v, &value, name, &local_err);
810 if (local_err) {
811 error_propagate(errp, local_err);
812 } else if (value < -1 || value > 255) {
813 error_set(errp, QERR_INVALID_PARAMETER_VALUE, name ? name : "null",
814 "pci_devfn");
815 } else {
816 *ptr = value;
817 }
818 return;
819 }
820
821 if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
822 fn = 0;
823 if (sscanf(str, "%x%n", &slot, &n) != 1) {
824 goto invalid;
825 }
826 }
827 if (str[n] != '\0' || fn > 7 || slot > 31) {
828 goto invalid;
829 }
830 *ptr = slot << 3 | fn;
831 g_free(str);
832 return;
833
834 invalid:
835 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
836 g_free(str);
837 }
838
839 static int print_pci_devfn(DeviceState *dev, Property *prop, char *dest, size_t len)
840 {
841 int32_t *ptr = qdev_get_prop_ptr(dev, prop);
842
843 if (*ptr == -1) {
844 return snprintf(dest, len, "<unset>");
845 } else {
846 return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
847 }
848 }
849
850 PropertyInfo qdev_prop_pci_devfn = {
851 .name = "int32",
852 .legacy_name = "pci-devfn",
853 .print = print_pci_devfn,
854 .get = get_int32,
855 .set = set_pci_devfn,
856 };
857
858 /* --- blocksize --- */
859
860 static void set_blocksize(Object *obj, Visitor *v, void *opaque,
861 const char *name, Error **errp)
862 {
863 DeviceState *dev = DEVICE(obj);
864 Property *prop = opaque;
865 uint16_t value, *ptr = qdev_get_prop_ptr(dev, prop);
866 Error *local_err = NULL;
867 const int64_t min = 512;
868 const int64_t max = 32768;
869
870 if (dev->state != DEV_STATE_CREATED) {
871 error_set(errp, QERR_PERMISSION_DENIED);
872 return;
873 }
874
875 visit_type_uint16(v, &value, name, &local_err);
876 if (local_err) {
877 error_propagate(errp, local_err);
878 return;
879 }
880 if (value < min || value > max) {
881 error_set(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
882 dev->id?:"", name, (int64_t)value, min, max);
883 return;
884 }
885
886 /* We rely on power-of-2 blocksizes for bitmasks */
887 if ((value & (value - 1)) != 0) {
888 error_set(errp, QERR_PROPERTY_VALUE_NOT_POWER_OF_2,
889 dev->id?:"", name, (int64_t)value);
890 return;
891 }
892
893 *ptr = value;
894 }
895
896 PropertyInfo qdev_prop_blocksize = {
897 .name = "blocksize",
898 .get = get_uint16,
899 .set = set_blocksize,
900 };
901
902 /* --- pci host address --- */
903
904 static void get_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
905 const char *name, Error **errp)
906 {
907 DeviceState *dev = DEVICE(obj);
908 Property *prop = opaque;
909 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
910 char buffer[] = "xxxx:xx:xx.x";
911 char *p = buffer;
912 int rc = 0;
913
914 rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%d",
915 addr->domain, addr->bus, addr->slot, addr->function);
916 assert(rc == sizeof(buffer) - 1);
917
918 visit_type_str(v, &p, name, errp);
919 }
920
921 /*
922 * Parse [<domain>:]<bus>:<slot>.<func>
923 * if <domain> is not supplied, it's assumed to be 0.
924 */
925 static void set_pci_host_devaddr(Object *obj, Visitor *v, void *opaque,
926 const char *name, Error **errp)
927 {
928 DeviceState *dev = DEVICE(obj);
929 Property *prop = opaque;
930 PCIHostDeviceAddress *addr = qdev_get_prop_ptr(dev, prop);
931 Error *local_err = NULL;
932 char *str, *p;
933 char *e;
934 unsigned long val;
935 unsigned long dom = 0, bus = 0;
936 unsigned int slot = 0, func = 0;
937
938 if (dev->state != DEV_STATE_CREATED) {
939 error_set(errp, QERR_PERMISSION_DENIED);
940 return;
941 }
942
943 visit_type_str(v, &str, name, &local_err);
944 if (local_err) {
945 error_propagate(errp, local_err);
946 return;
947 }
948
949 p = str;
950 val = strtoul(p, &e, 16);
951 if (e == p || *e != ':') {
952 goto inval;
953 }
954 bus = val;
955
956 p = e + 1;
957 val = strtoul(p, &e, 16);
958 if (e == p) {
959 goto inval;
960 }
961 if (*e == ':') {
962 dom = bus;
963 bus = val;
964 p = e + 1;
965 val = strtoul(p, &e, 16);
966 if (e == p) {
967 goto inval;
968 }
969 }
970 slot = val;
971
972 if (*e != '.') {
973 goto inval;
974 }
975 p = e + 1;
976 val = strtoul(p, &e, 10);
977 if (e == p) {
978 goto inval;
979 }
980 func = val;
981
982 if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
983 goto inval;
984 }
985
986 if (*e) {
987 goto inval;
988 }
989
990 addr->domain = dom;
991 addr->bus = bus;
992 addr->slot = slot;
993 addr->function = func;
994
995 g_free(str);
996 return;
997
998 inval:
999 error_set_from_qdev_prop_error(errp, EINVAL, dev, prop, str);
1000 g_free(str);
1001 }
1002
1003 PropertyInfo qdev_prop_pci_host_devaddr = {
1004 .name = "pci-host-devaddr",
1005 .get = get_pci_host_devaddr,
1006 .set = set_pci_host_devaddr,
1007 };
1008
1009 /* --- public helpers --- */
1010
1011 static Property *qdev_prop_walk(Property *props, const char *name)
1012 {
1013 if (!props)
1014 return NULL;
1015 while (props->name) {
1016 if (strcmp(props->name, name) == 0)
1017 return props;
1018 props++;
1019 }
1020 return NULL;
1021 }
1022
1023 static Property *qdev_prop_find(DeviceState *dev, const char *name)
1024 {
1025 ObjectClass *class;
1026 Property *prop;
1027
1028 /* device properties */
1029 class = object_get_class(OBJECT(dev));
1030 do {
1031 prop = qdev_prop_walk(DEVICE_CLASS(class)->props, name);
1032 if (prop) {
1033 return prop;
1034 }
1035 class = object_class_get_parent(class);
1036 } while (class != object_class_by_name(TYPE_DEVICE));
1037
1038 return NULL;
1039 }
1040
1041 void error_set_from_qdev_prop_error(Error **errp, int ret, DeviceState *dev,
1042 Property *prop, const char *value)
1043 {
1044 switch (ret) {
1045 case -EEXIST:
1046 error_set(errp, QERR_PROPERTY_VALUE_IN_USE,
1047 object_get_typename(OBJECT(dev)), prop->name, value);
1048 break;
1049 default:
1050 case -EINVAL:
1051 error_set(errp, QERR_PROPERTY_VALUE_BAD,
1052 object_get_typename(OBJECT(dev)), prop->name, value);
1053 break;
1054 case -ENOENT:
1055 error_set(errp, QERR_PROPERTY_VALUE_NOT_FOUND,
1056 object_get_typename(OBJECT(dev)), prop->name, value);
1057 break;
1058 case 0:
1059 break;
1060 }
1061 }
1062
1063 int qdev_prop_parse(DeviceState *dev, const char *name, const char *value)
1064 {
1065 char *legacy_name;
1066 Error *err = NULL;
1067
1068 legacy_name = g_strdup_printf("legacy-%s", name);
1069 if (object_property_get_type(OBJECT(dev), legacy_name, NULL)) {
1070 object_property_parse(OBJECT(dev), value, legacy_name, &err);
1071 } else {
1072 object_property_parse(OBJECT(dev), value, name, &err);
1073 }
1074 g_free(legacy_name);
1075
1076 if (err) {
1077 qerror_report_err(err);
1078 error_free(err);
1079 return -1;
1080 }
1081 return 0;
1082 }
1083
1084 void qdev_prop_set_bit(DeviceState *dev, const char *name, bool value)
1085 {
1086 Error *errp = NULL;
1087 object_property_set_bool(OBJECT(dev), value, name, &errp);
1088 assert_no_error(errp);
1089 }
1090
1091 void qdev_prop_set_uint8(DeviceState *dev, const char *name, uint8_t value)
1092 {
1093 Error *errp = NULL;
1094 object_property_set_int(OBJECT(dev), value, name, &errp);
1095 assert_no_error(errp);
1096 }
1097
1098 void qdev_prop_set_uint16(DeviceState *dev, const char *name, uint16_t value)
1099 {
1100 Error *errp = NULL;
1101 object_property_set_int(OBJECT(dev), value, name, &errp);
1102 assert_no_error(errp);
1103 }
1104
1105 void qdev_prop_set_uint32(DeviceState *dev, const char *name, uint32_t value)
1106 {
1107 Error *errp = NULL;
1108 object_property_set_int(OBJECT(dev), value, name, &errp);
1109 assert_no_error(errp);
1110 }
1111
1112 void qdev_prop_set_int32(DeviceState *dev, const char *name, int32_t value)
1113 {
1114 Error *errp = NULL;
1115 object_property_set_int(OBJECT(dev), value, name, &errp);
1116 assert_no_error(errp);
1117 }
1118
1119 void qdev_prop_set_uint64(DeviceState *dev, const char *name, uint64_t value)
1120 {
1121 Error *errp = NULL;
1122 object_property_set_int(OBJECT(dev), value, name, &errp);
1123 assert_no_error(errp);
1124 }
1125
1126 void qdev_prop_set_string(DeviceState *dev, const char *name, char *value)
1127 {
1128 Error *errp = NULL;
1129 object_property_set_str(OBJECT(dev), value, name, &errp);
1130 assert_no_error(errp);
1131 }
1132
1133 int qdev_prop_set_drive(DeviceState *dev, const char *name, BlockDriverState *value)
1134 {
1135 Error *errp = NULL;
1136 const char *bdrv_name = value ? bdrv_get_device_name(value) : "";
1137 object_property_set_str(OBJECT(dev), bdrv_name,
1138 name, &errp);
1139 if (errp) {
1140 qerror_report_err(errp);
1141 error_free(errp);
1142 return -1;
1143 }
1144 return 0;
1145 }
1146
1147 void qdev_prop_set_drive_nofail(DeviceState *dev, const char *name, BlockDriverState *value)
1148 {
1149 if (qdev_prop_set_drive(dev, name, value) < 0) {
1150 exit(1);
1151 }
1152 }
1153 void qdev_prop_set_chr(DeviceState *dev, const char *name, CharDriverState *value)
1154 {
1155 Error *errp = NULL;
1156 assert(!value || value->label);
1157 object_property_set_str(OBJECT(dev),
1158 value ? value->label : "", name, &errp);
1159 assert_no_error(errp);
1160 }
1161
1162 void qdev_prop_set_netdev(DeviceState *dev, const char *name, VLANClientState *value)
1163 {
1164 Error *errp = NULL;
1165 assert(!value || value->name);
1166 object_property_set_str(OBJECT(dev),
1167 value ? value->name : "", name, &errp);
1168 assert_no_error(errp);
1169 }
1170
1171 void qdev_prop_set_vlan(DeviceState *dev, const char *name, VLANState *value)
1172 {
1173 Error *errp = NULL;
1174 object_property_set_int(OBJECT(dev), value ? value->id : -1, name, &errp);
1175 assert_no_error(errp);
1176 }
1177
1178 void qdev_prop_set_macaddr(DeviceState *dev, const char *name, uint8_t *value)
1179 {
1180 Error *errp = NULL;
1181 char str[2 * 6 + 5 + 1];
1182 snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
1183 value[0], value[1], value[2], value[3], value[4], value[5]);
1184
1185 object_property_set_str(OBJECT(dev), str, name, &errp);
1186 assert_no_error(errp);
1187 }
1188
1189 void qdev_prop_set_enum(DeviceState *dev, const char *name, int value)
1190 {
1191 Property *prop;
1192 Error *errp = NULL;
1193
1194 prop = qdev_prop_find(dev, name);
1195 object_property_set_str(OBJECT(dev), prop->info->enum_table[value],
1196 name, &errp);
1197 assert_no_error(errp);
1198 }
1199
1200 void qdev_prop_set_ptr(DeviceState *dev, const char *name, void *value)
1201 {
1202 Property *prop;
1203 void **ptr;
1204
1205 prop = qdev_prop_find(dev, name);
1206 assert(prop && prop->info == &qdev_prop_ptr);
1207 ptr = qdev_get_prop_ptr(dev, prop);
1208 *ptr = value;
1209 }
1210
1211 static QTAILQ_HEAD(, GlobalProperty) global_props = QTAILQ_HEAD_INITIALIZER(global_props);
1212
1213 static void qdev_prop_register_global(GlobalProperty *prop)
1214 {
1215 QTAILQ_INSERT_TAIL(&global_props, prop, next);
1216 }
1217
1218 void qdev_prop_register_global_list(GlobalProperty *props)
1219 {
1220 int i;
1221
1222 for (i = 0; props[i].driver != NULL; i++) {
1223 qdev_prop_register_global(props+i);
1224 }
1225 }
1226
1227 void qdev_prop_set_globals(DeviceState *dev)
1228 {
1229 ObjectClass *class = object_get_class(OBJECT(dev));
1230
1231 do {
1232 GlobalProperty *prop;
1233 QTAILQ_FOREACH(prop, &global_props, next) {
1234 if (strcmp(object_class_get_name(class), prop->driver) != 0) {
1235 continue;
1236 }
1237 if (qdev_prop_parse(dev, prop->property, prop->value) != 0) {
1238 exit(1);
1239 }
1240 }
1241 class = object_class_get_parent(class);
1242 } while (class);
1243 }
1244
1245 static int qdev_add_one_global(QemuOpts *opts, void *opaque)
1246 {
1247 GlobalProperty *g;
1248
1249 g = g_malloc0(sizeof(*g));
1250 g->driver = qemu_opt_get(opts, "driver");
1251 g->property = qemu_opt_get(opts, "property");
1252 g->value = qemu_opt_get(opts, "value");
1253 qdev_prop_register_global(g);
1254 return 0;
1255 }
1256
1257 void qemu_add_globals(void)
1258 {
1259 qemu_opts_foreach(qemu_find_opts("global"), qdev_add_one_global, NULL, 0);
1260 }
Qemu copy for testing