qdev-properties-system.c 30 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141
  1. /*
  2. * qdev property parsing
  3. * (parts specific for qemu-system-*)
  4. *
  5. * This file is based on code from hw/qdev-properties.c from
  6. * commit 074a86fccd185616469dfcdc0e157f438aebba18,
  7. * Copyright (c) Gerd Hoffmann <kraxel@redhat.com> and other contributors.
  8. *
  9. * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10. * See the COPYING file in the top-level directory.
  11. */
  12. #include "qemu/osdep.h"
  13. #include "hw/qdev-properties.h"
  14. #include "hw/qdev-properties-system.h"
  15. #include "qapi/error.h"
  16. #include "qapi/visitor.h"
  17. #include "qapi/qapi-types-block.h"
  18. #include "qapi/qapi-types-machine.h"
  19. #include "qapi/qapi-types-migration.h"
  20. #include "qapi/qmp/qerror.h"
  21. #include "qemu/ctype.h"
  22. #include "qemu/cutils.h"
  23. #include "qemu/units.h"
  24. #include "qemu/uuid.h"
  25. #include "qemu/error-report.h"
  26. #include "qdev-prop-internal.h"
  27. #include "audio/audio.h"
  28. #include "chardev/char-fe.h"
  29. #include "sysemu/block-backend.h"
  30. #include "sysemu/blockdev.h"
  31. #include "net/net.h"
  32. #include "hw/pci/pci.h"
  33. #include "hw/pci/pcie.h"
  34. #include "hw/i386/x86.h"
  35. #include "util/block-helpers.h"
  36. static bool check_prop_still_unset(Object *obj, const char *name,
  37. const void *old_val, const char *new_val,
  38. bool allow_override, Error **errp)
  39. {
  40. const GlobalProperty *prop = qdev_find_global_prop(obj, name);
  41. if (!old_val || (!prop && allow_override)) {
  42. return true;
  43. }
  44. if (prop) {
  45. error_setg(errp, "-global %s.%s=... conflicts with %s=%s",
  46. prop->driver, prop->property, name, new_val);
  47. } else {
  48. /* Error message is vague, but a better one would be hard */
  49. error_setg(errp, "%s=%s conflicts, and override is not implemented",
  50. name, new_val);
  51. }
  52. return false;
  53. }
  54. /* --- drive --- */
  55. static void get_drive(Object *obj, Visitor *v, const char *name, void *opaque,
  56. Error **errp)
  57. {
  58. Property *prop = opaque;
  59. void **ptr = object_field_prop_ptr(obj, prop);
  60. const char *value;
  61. char *p;
  62. if (*ptr) {
  63. value = blk_name(*ptr);
  64. if (!*value) {
  65. BlockDriverState *bs = blk_bs(*ptr);
  66. if (bs) {
  67. value = bdrv_get_node_name(bs);
  68. }
  69. }
  70. } else {
  71. value = "";
  72. }
  73. p = g_strdup(value);
  74. visit_type_str(v, name, &p, errp);
  75. g_free(p);
  76. }
  77. static void set_drive_helper(Object *obj, Visitor *v, const char *name,
  78. void *opaque, bool iothread, Error **errp)
  79. {
  80. DeviceState *dev = DEVICE(obj);
  81. Property *prop = opaque;
  82. void **ptr = object_field_prop_ptr(obj, prop);
  83. char *str;
  84. BlockBackend *blk;
  85. bool blk_created = false;
  86. int ret;
  87. BlockDriverState *bs;
  88. AioContext *ctx;
  89. if (!visit_type_str(v, name, &str, errp)) {
  90. return;
  91. }
  92. if (!check_prop_still_unset(obj, name, *ptr, str, true, errp)) {
  93. return;
  94. }
  95. if (*ptr) {
  96. /* BlockBackend already exists. So, we want to change attached node */
  97. blk = *ptr;
  98. ctx = blk_get_aio_context(blk);
  99. bs = bdrv_lookup_bs(NULL, str, errp);
  100. if (!bs) {
  101. return;
  102. }
  103. if (ctx != bdrv_get_aio_context(bs)) {
  104. error_setg(errp, "Different aio context is not supported for new "
  105. "node");
  106. }
  107. aio_context_acquire(ctx);
  108. blk_replace_bs(blk, bs, errp);
  109. aio_context_release(ctx);
  110. return;
  111. }
  112. if (!*str) {
  113. g_free(str);
  114. *ptr = NULL;
  115. return;
  116. }
  117. blk = blk_by_name(str);
  118. if (!blk) {
  119. bs = bdrv_lookup_bs(NULL, str, NULL);
  120. if (bs) {
  121. /*
  122. * If the device supports iothreads, it will make sure to move the
  123. * block node to the right AioContext if necessary (or fail if this
  124. * isn't possible because of other users). Devices that are not
  125. * aware of iothreads require their BlockBackends to be in the main
  126. * AioContext.
  127. */
  128. ctx = bdrv_get_aio_context(bs);
  129. blk = blk_new(iothread ? ctx : qemu_get_aio_context(),
  130. 0, BLK_PERM_ALL);
  131. blk_created = true;
  132. aio_context_acquire(ctx);
  133. ret = blk_insert_bs(blk, bs, errp);
  134. aio_context_release(ctx);
  135. if (ret < 0) {
  136. goto fail;
  137. }
  138. }
  139. }
  140. if (!blk) {
  141. error_setg(errp, "Property '%s.%s' can't find value '%s'",
  142. object_get_typename(OBJECT(dev)), name, str);
  143. goto fail;
  144. }
  145. if (blk_attach_dev(blk, dev) < 0) {
  146. DriveInfo *dinfo = blk_legacy_dinfo(blk);
  147. if (dinfo && dinfo->type != IF_NONE) {
  148. error_setg(errp, "Drive '%s' is already in use because "
  149. "it has been automatically connected to another "
  150. "device (did you need 'if=none' in the drive options?)",
  151. str);
  152. } else {
  153. error_setg(errp, "Drive '%s' is already in use by another device",
  154. str);
  155. }
  156. goto fail;
  157. }
  158. *ptr = blk;
  159. fail:
  160. if (blk_created) {
  161. /* If we need to keep a reference, blk_attach_dev() took it */
  162. blk_unref(blk);
  163. }
  164. g_free(str);
  165. }
  166. static void set_drive(Object *obj, Visitor *v, const char *name, void *opaque,
  167. Error **errp)
  168. {
  169. set_drive_helper(obj, v, name, opaque, false, errp);
  170. }
  171. static void set_drive_iothread(Object *obj, Visitor *v, const char *name,
  172. void *opaque, Error **errp)
  173. {
  174. set_drive_helper(obj, v, name, opaque, true, errp);
  175. }
  176. static void release_drive(Object *obj, const char *name, void *opaque)
  177. {
  178. DeviceState *dev = DEVICE(obj);
  179. Property *prop = opaque;
  180. BlockBackend **ptr = object_field_prop_ptr(obj, prop);
  181. if (*ptr) {
  182. AioContext *ctx = blk_get_aio_context(*ptr);
  183. aio_context_acquire(ctx);
  184. blockdev_auto_del(*ptr);
  185. blk_detach_dev(*ptr, dev);
  186. aio_context_release(ctx);
  187. }
  188. }
  189. const PropertyInfo qdev_prop_drive = {
  190. .name = "str",
  191. .description = "Node name or ID of a block device to use as a backend",
  192. .realized_set_allowed = true,
  193. .get = get_drive,
  194. .set = set_drive,
  195. .release = release_drive,
  196. };
  197. const PropertyInfo qdev_prop_drive_iothread = {
  198. .name = "str",
  199. .description = "Node name or ID of a block device to use as a backend",
  200. .realized_set_allowed = true,
  201. .get = get_drive,
  202. .set = set_drive_iothread,
  203. .release = release_drive,
  204. };
  205. /* --- character device --- */
  206. static void get_chr(Object *obj, Visitor *v, const char *name, void *opaque,
  207. Error **errp)
  208. {
  209. CharBackend *be = object_field_prop_ptr(obj, opaque);
  210. char *p;
  211. p = g_strdup(be->chr && be->chr->label ? be->chr->label : "");
  212. visit_type_str(v, name, &p, errp);
  213. g_free(p);
  214. }
  215. static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,
  216. Error **errp)
  217. {
  218. Property *prop = opaque;
  219. CharBackend *be = object_field_prop_ptr(obj, prop);
  220. Chardev *s;
  221. char *str;
  222. if (!visit_type_str(v, name, &str, errp)) {
  223. return;
  224. }
  225. /*
  226. * TODO Should this really be an error? If no, the old value
  227. * needs to be released before we store the new one.
  228. */
  229. if (!check_prop_still_unset(obj, name, be->chr, str, false, errp)) {
  230. return;
  231. }
  232. if (!*str) {
  233. g_free(str);
  234. be->chr = NULL;
  235. return;
  236. }
  237. s = qemu_chr_find(str);
  238. if (s == NULL) {
  239. error_setg(errp, "Property '%s.%s' can't find value '%s'",
  240. object_get_typename(obj), name, str);
  241. } else if (!qemu_chr_fe_init(be, s, errp)) {
  242. error_prepend(errp, "Property '%s.%s' can't take value '%s': ",
  243. object_get_typename(obj), name, str);
  244. }
  245. g_free(str);
  246. }
  247. static void release_chr(Object *obj, const char *name, void *opaque)
  248. {
  249. Property *prop = opaque;
  250. CharBackend *be = object_field_prop_ptr(obj, prop);
  251. qemu_chr_fe_deinit(be, false);
  252. }
  253. const PropertyInfo qdev_prop_chr = {
  254. .name = "str",
  255. .description = "ID of a chardev to use as a backend",
  256. .get = get_chr,
  257. .set = set_chr,
  258. .release = release_chr,
  259. };
  260. /* --- mac address --- */
  261. /*
  262. * accepted syntax versions:
  263. * 01:02:03:04:05:06
  264. * 01-02-03-04-05-06
  265. */
  266. static void get_mac(Object *obj, Visitor *v, const char *name, void *opaque,
  267. Error **errp)
  268. {
  269. Property *prop = opaque;
  270. MACAddr *mac = object_field_prop_ptr(obj, prop);
  271. char buffer[2 * 6 + 5 + 1];
  272. char *p = buffer;
  273. snprintf(buffer, sizeof(buffer), "%02x:%02x:%02x:%02x:%02x:%02x",
  274. mac->a[0], mac->a[1], mac->a[2],
  275. mac->a[3], mac->a[4], mac->a[5]);
  276. visit_type_str(v, name, &p, errp);
  277. }
  278. static void set_mac(Object *obj, Visitor *v, const char *name, void *opaque,
  279. Error **errp)
  280. {
  281. Property *prop = opaque;
  282. MACAddr *mac = object_field_prop_ptr(obj, prop);
  283. int i, pos;
  284. char *str;
  285. const char *p;
  286. if (!visit_type_str(v, name, &str, errp)) {
  287. return;
  288. }
  289. for (i = 0, pos = 0; i < 6; i++, pos += 3) {
  290. long val;
  291. if (!qemu_isxdigit(str[pos])) {
  292. goto inval;
  293. }
  294. if (!qemu_isxdigit(str[pos + 1])) {
  295. goto inval;
  296. }
  297. if (i == 5) {
  298. if (str[pos + 2] != '\0') {
  299. goto inval;
  300. }
  301. } else {
  302. if (str[pos + 2] != ':' && str[pos + 2] != '-') {
  303. goto inval;
  304. }
  305. }
  306. if (qemu_strtol(str + pos, &p, 16, &val) < 0 || val > 0xff) {
  307. goto inval;
  308. }
  309. mac->a[i] = val;
  310. }
  311. g_free(str);
  312. return;
  313. inval:
  314. error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
  315. g_free(str);
  316. }
  317. const PropertyInfo qdev_prop_macaddr = {
  318. .name = "str",
  319. .description = "Ethernet 6-byte MAC Address, example: 52:54:00:12:34:56",
  320. .get = get_mac,
  321. .set = set_mac,
  322. };
  323. void qdev_prop_set_macaddr(DeviceState *dev, const char *name,
  324. const uint8_t *value)
  325. {
  326. char str[2 * 6 + 5 + 1];
  327. snprintf(str, sizeof(str), "%02x:%02x:%02x:%02x:%02x:%02x",
  328. value[0], value[1], value[2], value[3], value[4], value[5]);
  329. object_property_set_str(OBJECT(dev), name, str, &error_abort);
  330. }
  331. /* --- netdev device --- */
  332. static void get_netdev(Object *obj, Visitor *v, const char *name,
  333. void *opaque, Error **errp)
  334. {
  335. Property *prop = opaque;
  336. NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
  337. char *p = g_strdup(peers_ptr->ncs[0] ? peers_ptr->ncs[0]->name : "");
  338. visit_type_str(v, name, &p, errp);
  339. g_free(p);
  340. }
  341. static void set_netdev(Object *obj, Visitor *v, const char *name,
  342. void *opaque, Error **errp)
  343. {
  344. Property *prop = opaque;
  345. NICPeers *peers_ptr = object_field_prop_ptr(obj, prop);
  346. NetClientState **ncs = peers_ptr->ncs;
  347. NetClientState *peers[MAX_QUEUE_NUM];
  348. int queues, err = 0, i = 0;
  349. char *str;
  350. if (!visit_type_str(v, name, &str, errp)) {
  351. return;
  352. }
  353. queues = qemu_find_net_clients_except(str, peers,
  354. NET_CLIENT_DRIVER_NIC,
  355. MAX_QUEUE_NUM);
  356. if (queues == 0) {
  357. err = -ENOENT;
  358. goto out;
  359. }
  360. if (queues > MAX_QUEUE_NUM) {
  361. error_setg(errp, "queues of backend '%s'(%d) exceeds QEMU limitation(%d)",
  362. str, queues, MAX_QUEUE_NUM);
  363. goto out;
  364. }
  365. for (i = 0; i < queues; i++) {
  366. if (peers[i]->peer) {
  367. err = -EEXIST;
  368. goto out;
  369. }
  370. /*
  371. * TODO Should this really be an error? If no, the old value
  372. * needs to be released before we store the new one.
  373. */
  374. if (!check_prop_still_unset(obj, name, ncs[i], str, false, errp)) {
  375. goto out;
  376. }
  377. if (peers[i]->info->check_peer_type) {
  378. if (!peers[i]->info->check_peer_type(peers[i], obj->class, errp)) {
  379. goto out;
  380. }
  381. }
  382. ncs[i] = peers[i];
  383. ncs[i]->queue_index = i;
  384. }
  385. peers_ptr->queues = queues;
  386. out:
  387. error_set_from_qdev_prop_error(errp, err, obj, name, str);
  388. g_free(str);
  389. }
  390. const PropertyInfo qdev_prop_netdev = {
  391. .name = "str",
  392. .description = "ID of a netdev to use as a backend",
  393. .get = get_netdev,
  394. .set = set_netdev,
  395. };
  396. /* --- audiodev --- */
  397. static void get_audiodev(Object *obj, Visitor *v, const char* name,
  398. void *opaque, Error **errp)
  399. {
  400. Property *prop = opaque;
  401. QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
  402. char *p = g_strdup(audio_get_id(card));
  403. visit_type_str(v, name, &p, errp);
  404. g_free(p);
  405. }
  406. static void set_audiodev(Object *obj, Visitor *v, const char* name,
  407. void *opaque, Error **errp)
  408. {
  409. Property *prop = opaque;
  410. QEMUSoundCard *card = object_field_prop_ptr(obj, prop);
  411. AudioState *state;
  412. g_autofree char *str = NULL;
  413. if (!visit_type_str(v, name, &str, errp)) {
  414. return;
  415. }
  416. state = audio_state_by_name(str, errp);
  417. if (state) {
  418. card->state = state;
  419. }
  420. }
  421. const PropertyInfo qdev_prop_audiodev = {
  422. .name = "str",
  423. .description = "ID of an audiodev to use as a backend",
  424. /* release done on shutdown */
  425. .get = get_audiodev,
  426. .set = set_audiodev,
  427. };
  428. bool qdev_prop_set_drive_err(DeviceState *dev, const char *name,
  429. BlockBackend *value, Error **errp)
  430. {
  431. const char *ref = "";
  432. if (value) {
  433. ref = blk_name(value);
  434. if (!*ref) {
  435. const BlockDriverState *bs = blk_bs(value);
  436. if (bs) {
  437. ref = bdrv_get_node_name(bs);
  438. }
  439. }
  440. }
  441. return object_property_set_str(OBJECT(dev), name, ref, errp);
  442. }
  443. void qdev_prop_set_drive(DeviceState *dev, const char *name,
  444. BlockBackend *value)
  445. {
  446. qdev_prop_set_drive_err(dev, name, value, &error_abort);
  447. }
  448. void qdev_prop_set_chr(DeviceState *dev, const char *name,
  449. Chardev *value)
  450. {
  451. assert(!value || value->label);
  452. object_property_set_str(OBJECT(dev), name, value ? value->label : "",
  453. &error_abort);
  454. }
  455. void qdev_prop_set_netdev(DeviceState *dev, const char *name,
  456. NetClientState *value)
  457. {
  458. assert(!value || value->name);
  459. object_property_set_str(OBJECT(dev), name, value ? value->name : "",
  460. &error_abort);
  461. }
  462. void qdev_set_nic_properties(DeviceState *dev, NICInfo *nd)
  463. {
  464. qdev_prop_set_macaddr(dev, "mac", nd->macaddr.a);
  465. if (nd->netdev) {
  466. qdev_prop_set_netdev(dev, "netdev", nd->netdev);
  467. }
  468. if (nd->nvectors != DEV_NVECTORS_UNSPECIFIED &&
  469. object_property_find(OBJECT(dev), "vectors")) {
  470. qdev_prop_set_uint32(dev, "vectors", nd->nvectors);
  471. }
  472. nd->instantiated = 1;
  473. }
  474. /* --- lost tick policy --- */
  475. static void qdev_propinfo_set_losttickpolicy(Object *obj, Visitor *v,
  476. const char *name, void *opaque,
  477. Error **errp)
  478. {
  479. Property *prop = opaque;
  480. int *ptr = object_field_prop_ptr(obj, prop);
  481. int value;
  482. if (!visit_type_enum(v, name, &value, prop->info->enum_table, errp)) {
  483. return;
  484. }
  485. if (value == LOST_TICK_POLICY_SLEW) {
  486. MachineState *ms = MACHINE(qdev_get_machine());
  487. if (!object_dynamic_cast(OBJECT(ms), TYPE_X86_MACHINE)) {
  488. error_setg(errp,
  489. "the 'slew' policy is only available for x86 machines");
  490. return;
  491. }
  492. }
  493. *ptr = value;
  494. }
  495. QEMU_BUILD_BUG_ON(sizeof(LostTickPolicy) != sizeof(int));
  496. const PropertyInfo qdev_prop_losttickpolicy = {
  497. .name = "LostTickPolicy",
  498. .enum_table = &LostTickPolicy_lookup,
  499. .get = qdev_propinfo_get_enum,
  500. .set = qdev_propinfo_set_losttickpolicy,
  501. .set_default_value = qdev_propinfo_set_default_value_enum,
  502. };
  503. /* --- blocksize --- */
  504. static void set_blocksize(Object *obj, Visitor *v, const char *name,
  505. void *opaque, Error **errp)
  506. {
  507. DeviceState *dev = DEVICE(obj);
  508. Property *prop = opaque;
  509. uint32_t *ptr = object_field_prop_ptr(obj, prop);
  510. uint64_t value;
  511. Error *local_err = NULL;
  512. if (!visit_type_size(v, name, &value, errp)) {
  513. return;
  514. }
  515. check_block_size(dev->id ? : "", name, value, &local_err);
  516. if (local_err) {
  517. error_propagate(errp, local_err);
  518. return;
  519. }
  520. *ptr = value;
  521. }
  522. const PropertyInfo qdev_prop_blocksize = {
  523. .name = "size",
  524. .description = "A power of two between " MIN_BLOCK_SIZE_STR
  525. " and " MAX_BLOCK_SIZE_STR,
  526. .get = qdev_propinfo_get_size32,
  527. .set = set_blocksize,
  528. .set_default_value = qdev_propinfo_set_default_value_uint,
  529. };
  530. /* --- Block device error handling policy --- */
  531. QEMU_BUILD_BUG_ON(sizeof(BlockdevOnError) != sizeof(int));
  532. const PropertyInfo qdev_prop_blockdev_on_error = {
  533. .name = "BlockdevOnError",
  534. .description = "Error handling policy, "
  535. "report/ignore/enospc/stop/auto",
  536. .enum_table = &BlockdevOnError_lookup,
  537. .get = qdev_propinfo_get_enum,
  538. .set = qdev_propinfo_set_enum,
  539. .set_default_value = qdev_propinfo_set_default_value_enum,
  540. };
  541. /* --- BIOS CHS translation */
  542. QEMU_BUILD_BUG_ON(sizeof(BiosAtaTranslation) != sizeof(int));
  543. const PropertyInfo qdev_prop_bios_chs_trans = {
  544. .name = "BiosAtaTranslation",
  545. .description = "Logical CHS translation algorithm, "
  546. "auto/none/lba/large/rechs",
  547. .enum_table = &BiosAtaTranslation_lookup,
  548. .get = qdev_propinfo_get_enum,
  549. .set = qdev_propinfo_set_enum,
  550. .set_default_value = qdev_propinfo_set_default_value_enum,
  551. };
  552. /* --- FDC default drive types */
  553. const PropertyInfo qdev_prop_fdc_drive_type = {
  554. .name = "FdcDriveType",
  555. .description = "FDC drive type, "
  556. "144/288/120/none/auto",
  557. .enum_table = &FloppyDriveType_lookup,
  558. .get = qdev_propinfo_get_enum,
  559. .set = qdev_propinfo_set_enum,
  560. .set_default_value = qdev_propinfo_set_default_value_enum,
  561. };
  562. /* --- MultiFDCompression --- */
  563. const PropertyInfo qdev_prop_multifd_compression = {
  564. .name = "MultiFDCompression",
  565. .description = "multifd_compression values, "
  566. "none/zlib/zstd",
  567. .enum_table = &MultiFDCompression_lookup,
  568. .get = qdev_propinfo_get_enum,
  569. .set = qdev_propinfo_set_enum,
  570. .set_default_value = qdev_propinfo_set_default_value_enum,
  571. };
  572. /* --- Reserved Region --- */
  573. /*
  574. * Accepted syntax:
  575. * <low address>:<high address>:<type>
  576. * where low/high addresses are uint64_t in hexadecimal
  577. * and type is a non-negative decimal integer
  578. */
  579. static void get_reserved_region(Object *obj, Visitor *v, const char *name,
  580. void *opaque, Error **errp)
  581. {
  582. Property *prop = opaque;
  583. ReservedRegion *rr = object_field_prop_ptr(obj, prop);
  584. char buffer[64];
  585. char *p = buffer;
  586. int rc;
  587. rc = snprintf(buffer, sizeof(buffer), "0x%"PRIx64":0x%"PRIx64":%u",
  588. rr->low, rr->high, rr->type);
  589. assert(rc < sizeof(buffer));
  590. visit_type_str(v, name, &p, errp);
  591. }
  592. static void set_reserved_region(Object *obj, Visitor *v, const char *name,
  593. void *opaque, Error **errp)
  594. {
  595. Property *prop = opaque;
  596. ReservedRegion *rr = object_field_prop_ptr(obj, prop);
  597. const char *endptr;
  598. char *str;
  599. int ret;
  600. if (!visit_type_str(v, name, &str, errp)) {
  601. return;
  602. }
  603. ret = qemu_strtou64(str, &endptr, 16, &rr->low);
  604. if (ret) {
  605. error_setg(errp, "start address of '%s'"
  606. " must be a hexadecimal integer", name);
  607. goto out;
  608. }
  609. if (*endptr != ':') {
  610. goto separator_error;
  611. }
  612. ret = qemu_strtou64(endptr + 1, &endptr, 16, &rr->high);
  613. if (ret) {
  614. error_setg(errp, "end address of '%s'"
  615. " must be a hexadecimal integer", name);
  616. goto out;
  617. }
  618. if (*endptr != ':') {
  619. goto separator_error;
  620. }
  621. ret = qemu_strtoui(endptr + 1, &endptr, 10, &rr->type);
  622. if (ret) {
  623. error_setg(errp, "type of '%s'"
  624. " must be a non-negative decimal integer", name);
  625. }
  626. goto out;
  627. separator_error:
  628. error_setg(errp, "reserved region fields must be separated with ':'");
  629. out:
  630. g_free(str);
  631. return;
  632. }
  633. const PropertyInfo qdev_prop_reserved_region = {
  634. .name = "reserved_region",
  635. .description = "Reserved Region, example: 0xFEE00000:0xFEEFFFFF:0",
  636. .get = get_reserved_region,
  637. .set = set_reserved_region,
  638. };
  639. /* --- pci address --- */
  640. /*
  641. * bus-local address, i.e. "$slot" or "$slot.$fn"
  642. */
  643. static void set_pci_devfn(Object *obj, Visitor *v, const char *name,
  644. void *opaque, Error **errp)
  645. {
  646. Property *prop = opaque;
  647. int32_t value, *ptr = object_field_prop_ptr(obj, prop);
  648. unsigned int slot, fn, n;
  649. char *str;
  650. if (!visit_type_str(v, name, &str, NULL)) {
  651. if (!visit_type_int32(v, name, &value, errp)) {
  652. return;
  653. }
  654. if (value < -1 || value > 255) {
  655. error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
  656. name ? name : "null", "a value between -1 and 255");
  657. return;
  658. }
  659. *ptr = value;
  660. return;
  661. }
  662. if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
  663. fn = 0;
  664. if (sscanf(str, "%x%n", &slot, &n) != 1) {
  665. goto invalid;
  666. }
  667. }
  668. if (str[n] != '\0' || fn > 7 || slot > 31) {
  669. goto invalid;
  670. }
  671. *ptr = slot << 3 | fn;
  672. g_free(str);
  673. return;
  674. invalid:
  675. error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
  676. g_free(str);
  677. }
  678. static int print_pci_devfn(Object *obj, Property *prop, char *dest,
  679. size_t len)
  680. {
  681. int32_t *ptr = object_field_prop_ptr(obj, prop);
  682. if (*ptr == -1) {
  683. return snprintf(dest, len, "<unset>");
  684. } else {
  685. return snprintf(dest, len, "%02x.%x", *ptr >> 3, *ptr & 7);
  686. }
  687. }
  688. const PropertyInfo qdev_prop_pci_devfn = {
  689. .name = "int32",
  690. .description = "Slot and optional function number, example: 06.0 or 06",
  691. .print = print_pci_devfn,
  692. .get = qdev_propinfo_get_int32,
  693. .set = set_pci_devfn,
  694. .set_default_value = qdev_propinfo_set_default_value_int,
  695. };
  696. /* --- pci host address --- */
  697. static void get_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
  698. void *opaque, Error **errp)
  699. {
  700. Property *prop = opaque;
  701. PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
  702. char buffer[] = "ffff:ff:ff.f";
  703. char *p = buffer;
  704. int rc = 0;
  705. /*
  706. * Catch "invalid" device reference from vfio-pci and allow the
  707. * default buffer representing the non-existent device to be used.
  708. */
  709. if (~addr->domain || ~addr->bus || ~addr->slot || ~addr->function) {
  710. rc = snprintf(buffer, sizeof(buffer), "%04x:%02x:%02x.%0d",
  711. addr->domain, addr->bus, addr->slot, addr->function);
  712. assert(rc == sizeof(buffer) - 1);
  713. }
  714. visit_type_str(v, name, &p, errp);
  715. }
  716. /*
  717. * Parse [<domain>:]<bus>:<slot>.<func>
  718. * if <domain> is not supplied, it's assumed to be 0.
  719. */
  720. static void set_pci_host_devaddr(Object *obj, Visitor *v, const char *name,
  721. void *opaque, Error **errp)
  722. {
  723. Property *prop = opaque;
  724. PCIHostDeviceAddress *addr = object_field_prop_ptr(obj, prop);
  725. char *str, *p;
  726. char *e;
  727. unsigned long val;
  728. unsigned long dom = 0, bus = 0;
  729. unsigned int slot = 0, func = 0;
  730. if (!visit_type_str(v, name, &str, errp)) {
  731. return;
  732. }
  733. p = str;
  734. val = strtoul(p, &e, 16);
  735. if (e == p || *e != ':') {
  736. goto inval;
  737. }
  738. bus = val;
  739. p = e + 1;
  740. val = strtoul(p, &e, 16);
  741. if (e == p) {
  742. goto inval;
  743. }
  744. if (*e == ':') {
  745. dom = bus;
  746. bus = val;
  747. p = e + 1;
  748. val = strtoul(p, &e, 16);
  749. if (e == p) {
  750. goto inval;
  751. }
  752. }
  753. slot = val;
  754. if (*e != '.') {
  755. goto inval;
  756. }
  757. p = e + 1;
  758. val = strtoul(p, &e, 10);
  759. if (e == p) {
  760. goto inval;
  761. }
  762. func = val;
  763. if (dom > 0xffff || bus > 0xff || slot > 0x1f || func > 7) {
  764. goto inval;
  765. }
  766. if (*e) {
  767. goto inval;
  768. }
  769. addr->domain = dom;
  770. addr->bus = bus;
  771. addr->slot = slot;
  772. addr->function = func;
  773. g_free(str);
  774. return;
  775. inval:
  776. error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
  777. g_free(str);
  778. }
  779. const PropertyInfo qdev_prop_pci_host_devaddr = {
  780. .name = "str",
  781. .description = "Address (bus/device/function) of "
  782. "the host device, example: 04:10.0",
  783. .get = get_pci_host_devaddr,
  784. .set = set_pci_host_devaddr,
  785. };
  786. /* --- OffAutoPCIBAR off/auto/bar0/bar1/bar2/bar3/bar4/bar5 --- */
  787. const PropertyInfo qdev_prop_off_auto_pcibar = {
  788. .name = "OffAutoPCIBAR",
  789. .description = "off/auto/bar0/bar1/bar2/bar3/bar4/bar5",
  790. .enum_table = &OffAutoPCIBAR_lookup,
  791. .get = qdev_propinfo_get_enum,
  792. .set = qdev_propinfo_set_enum,
  793. .set_default_value = qdev_propinfo_set_default_value_enum,
  794. };
  795. /* --- PCIELinkSpeed 2_5/5/8/16 -- */
  796. static void get_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
  797. void *opaque, Error **errp)
  798. {
  799. Property *prop = opaque;
  800. PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
  801. int speed;
  802. switch (*p) {
  803. case QEMU_PCI_EXP_LNK_2_5GT:
  804. speed = PCIE_LINK_SPEED_2_5;
  805. break;
  806. case QEMU_PCI_EXP_LNK_5GT:
  807. speed = PCIE_LINK_SPEED_5;
  808. break;
  809. case QEMU_PCI_EXP_LNK_8GT:
  810. speed = PCIE_LINK_SPEED_8;
  811. break;
  812. case QEMU_PCI_EXP_LNK_16GT:
  813. speed = PCIE_LINK_SPEED_16;
  814. break;
  815. default:
  816. /* Unreachable */
  817. abort();
  818. }
  819. visit_type_enum(v, name, &speed, prop->info->enum_table, errp);
  820. }
  821. static void set_prop_pcielinkspeed(Object *obj, Visitor *v, const char *name,
  822. void *opaque, Error **errp)
  823. {
  824. Property *prop = opaque;
  825. PCIExpLinkSpeed *p = object_field_prop_ptr(obj, prop);
  826. int speed;
  827. if (!visit_type_enum(v, name, &speed, prop->info->enum_table,
  828. errp)) {
  829. return;
  830. }
  831. switch (speed) {
  832. case PCIE_LINK_SPEED_2_5:
  833. *p = QEMU_PCI_EXP_LNK_2_5GT;
  834. break;
  835. case PCIE_LINK_SPEED_5:
  836. *p = QEMU_PCI_EXP_LNK_5GT;
  837. break;
  838. case PCIE_LINK_SPEED_8:
  839. *p = QEMU_PCI_EXP_LNK_8GT;
  840. break;
  841. case PCIE_LINK_SPEED_16:
  842. *p = QEMU_PCI_EXP_LNK_16GT;
  843. break;
  844. default:
  845. /* Unreachable */
  846. abort();
  847. }
  848. }
  849. const PropertyInfo qdev_prop_pcie_link_speed = {
  850. .name = "PCIELinkSpeed",
  851. .description = "2_5/5/8/16",
  852. .enum_table = &PCIELinkSpeed_lookup,
  853. .get = get_prop_pcielinkspeed,
  854. .set = set_prop_pcielinkspeed,
  855. .set_default_value = qdev_propinfo_set_default_value_enum,
  856. };
  857. /* --- PCIELinkWidth 1/2/4/8/12/16/32 -- */
  858. static void get_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
  859. void *opaque, Error **errp)
  860. {
  861. Property *prop = opaque;
  862. PCIExpLinkWidth *p = object_field_prop_ptr(obj, prop);
  863. int width;
  864. switch (*p) {
  865. case QEMU_PCI_EXP_LNK_X1:
  866. width = PCIE_LINK_WIDTH_1;
  867. break;
  868. case QEMU_PCI_EXP_LNK_X2:
  869. width = PCIE_LINK_WIDTH_2;
  870. break;
  871. case QEMU_PCI_EXP_LNK_X4:
  872. width = PCIE_LINK_WIDTH_4;
  873. break;
  874. case QEMU_PCI_EXP_LNK_X8:
  875. width = PCIE_LINK_WIDTH_8;
  876. break;
  877. case QEMU_PCI_EXP_LNK_X12:
  878. width = PCIE_LINK_WIDTH_12;
  879. break;
  880. case QEMU_PCI_EXP_LNK_X16:
  881. width = PCIE_LINK_WIDTH_16;
  882. break;
  883. case QEMU_PCI_EXP_LNK_X32:
  884. width = PCIE_LINK_WIDTH_32;
  885. break;
  886. default:
  887. /* Unreachable */
  888. abort();
  889. }
  890. visit_type_enum(v, name, &width, prop->info->enum_table, errp);
  891. }
  892. static void set_prop_pcielinkwidth(Object *obj, Visitor *v, const char *name,
  893. void *opaque, Error **errp)
  894. {
  895. Property *prop = opaque;
  896. PCIExpLinkWidth *p = object_field_prop_ptr(obj, prop);
  897. int width;
  898. if (!visit_type_enum(v, name, &width, prop->info->enum_table,
  899. errp)) {
  900. return;
  901. }
  902. switch (width) {
  903. case PCIE_LINK_WIDTH_1:
  904. *p = QEMU_PCI_EXP_LNK_X1;
  905. break;
  906. case PCIE_LINK_WIDTH_2:
  907. *p = QEMU_PCI_EXP_LNK_X2;
  908. break;
  909. case PCIE_LINK_WIDTH_4:
  910. *p = QEMU_PCI_EXP_LNK_X4;
  911. break;
  912. case PCIE_LINK_WIDTH_8:
  913. *p = QEMU_PCI_EXP_LNK_X8;
  914. break;
  915. case PCIE_LINK_WIDTH_12:
  916. *p = QEMU_PCI_EXP_LNK_X12;
  917. break;
  918. case PCIE_LINK_WIDTH_16:
  919. *p = QEMU_PCI_EXP_LNK_X16;
  920. break;
  921. case PCIE_LINK_WIDTH_32:
  922. *p = QEMU_PCI_EXP_LNK_X32;
  923. break;
  924. default:
  925. /* Unreachable */
  926. abort();
  927. }
  928. }
  929. const PropertyInfo qdev_prop_pcie_link_width = {
  930. .name = "PCIELinkWidth",
  931. .description = "1/2/4/8/12/16/32",
  932. .enum_table = &PCIELinkWidth_lookup,
  933. .get = get_prop_pcielinkwidth,
  934. .set = set_prop_pcielinkwidth,
  935. .set_default_value = qdev_propinfo_set_default_value_enum,
  936. };
  937. /* --- UUID --- */
  938. static void get_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
  939. Error **errp)
  940. {
  941. Property *prop = opaque;
  942. QemuUUID *uuid = object_field_prop_ptr(obj, prop);
  943. char buffer[UUID_FMT_LEN + 1];
  944. char *p = buffer;
  945. qemu_uuid_unparse(uuid, buffer);
  946. visit_type_str(v, name, &p, errp);
  947. }
  948. #define UUID_VALUE_AUTO "auto"
  949. static void set_uuid(Object *obj, Visitor *v, const char *name, void *opaque,
  950. Error **errp)
  951. {
  952. Property *prop = opaque;
  953. QemuUUID *uuid = object_field_prop_ptr(obj, prop);
  954. char *str;
  955. if (!visit_type_str(v, name, &str, errp)) {
  956. return;
  957. }
  958. if (!strcmp(str, UUID_VALUE_AUTO)) {
  959. qemu_uuid_generate(uuid);
  960. } else if (qemu_uuid_parse(str, uuid) < 0) {
  961. error_set_from_qdev_prop_error(errp, EINVAL, obj, name, str);
  962. }
  963. g_free(str);
  964. }
  965. static void set_default_uuid_auto(ObjectProperty *op, const Property *prop)
  966. {
  967. object_property_set_default_str(op, UUID_VALUE_AUTO);
  968. }
  969. const PropertyInfo qdev_prop_uuid = {
  970. .name = "str",
  971. .description = "UUID (aka GUID) or \"" UUID_VALUE_AUTO
  972. "\" for random value (default)",
  973. .get = get_uuid,
  974. .set = set_uuid,
  975. .set_default_value = set_default_uuid_auto,
  976. };