qapi-visit-core.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401
  1. /*
  2. * Core Definitions for QAPI Visitor Classes
  3. *
  4. * Copyright (C) 2012-2016 Red Hat, Inc.
  5. * Copyright IBM, Corp. 2011
  6. *
  7. * Authors:
  8. * Anthony Liguori <aliguori@us.ibm.com>
  9. *
  10. * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
  11. * See the COPYING.LIB file in the top-level directory.
  12. *
  13. */
  14. #include "qemu/osdep.h"
  15. #include "qapi/error.h"
  16. #include "qemu-common.h"
  17. #include "qapi/qmp/qobject.h"
  18. #include "qapi/qmp/qerror.h"
  19. #include "qapi/visitor.h"
  20. #include "qapi/visitor-impl.h"
  21. #include "trace.h"
  22. void visit_complete(Visitor *v, void *opaque)
  23. {
  24. assert(v->type != VISITOR_OUTPUT || v->complete);
  25. trace_visit_complete(v, opaque);
  26. if (v->complete) {
  27. v->complete(v, opaque);
  28. }
  29. }
  30. void visit_free(Visitor *v)
  31. {
  32. trace_visit_free(v);
  33. if (v) {
  34. v->free(v);
  35. }
  36. }
  37. void visit_start_struct(Visitor *v, const char *name, void **obj,
  38. size_t size, Error **errp)
  39. {
  40. Error *err = NULL;
  41. trace_visit_start_struct(v, name, obj, size);
  42. if (obj) {
  43. assert(size);
  44. assert(!(v->type & VISITOR_OUTPUT) || *obj);
  45. }
  46. v->start_struct(v, name, obj, size, &err);
  47. if (obj && (v->type & VISITOR_INPUT)) {
  48. assert(!err != !*obj);
  49. }
  50. error_propagate(errp, err);
  51. }
  52. void visit_check_struct(Visitor *v, Error **errp)
  53. {
  54. trace_visit_check_struct(v);
  55. if (v->check_struct) {
  56. v->check_struct(v, errp);
  57. }
  58. }
  59. void visit_end_struct(Visitor *v, void **obj)
  60. {
  61. trace_visit_end_struct(v, obj);
  62. v->end_struct(v, obj);
  63. }
  64. void visit_start_list(Visitor *v, const char *name, GenericList **list,
  65. size_t size, Error **errp)
  66. {
  67. Error *err = NULL;
  68. assert(!list || size >= sizeof(GenericList));
  69. trace_visit_start_list(v, name, list, size);
  70. v->start_list(v, name, list, size, &err);
  71. if (list && (v->type & VISITOR_INPUT)) {
  72. assert(!(err && *list));
  73. }
  74. error_propagate(errp, err);
  75. }
  76. GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
  77. {
  78. assert(tail && size >= sizeof(GenericList));
  79. trace_visit_next_list(v, tail, size);
  80. return v->next_list(v, tail, size);
  81. }
  82. void visit_check_list(Visitor *v, Error **errp)
  83. {
  84. trace_visit_check_list(v);
  85. if (v->check_list) {
  86. v->check_list(v, errp);
  87. }
  88. }
  89. void visit_end_list(Visitor *v, void **obj)
  90. {
  91. trace_visit_end_list(v, obj);
  92. v->end_list(v, obj);
  93. }
  94. void visit_start_alternate(Visitor *v, const char *name,
  95. GenericAlternate **obj, size_t size,
  96. bool promote_int, Error **errp)
  97. {
  98. Error *err = NULL;
  99. assert(obj && size >= sizeof(GenericAlternate));
  100. assert(!(v->type & VISITOR_OUTPUT) || *obj);
  101. trace_visit_start_alternate(v, name, obj, size, promote_int);
  102. if (v->start_alternate) {
  103. v->start_alternate(v, name, obj, size, promote_int, &err);
  104. }
  105. if (v->type & VISITOR_INPUT) {
  106. assert(v->start_alternate && !err != !*obj);
  107. }
  108. error_propagate(errp, err);
  109. }
  110. void visit_end_alternate(Visitor *v, void **obj)
  111. {
  112. trace_visit_end_alternate(v, obj);
  113. if (v->end_alternate) {
  114. v->end_alternate(v, obj);
  115. }
  116. }
  117. bool visit_optional(Visitor *v, const char *name, bool *present)
  118. {
  119. trace_visit_optional(v, name, present);
  120. if (v->optional) {
  121. v->optional(v, name, present);
  122. }
  123. return *present;
  124. }
  125. bool visit_is_input(Visitor *v)
  126. {
  127. return v->type == VISITOR_INPUT;
  128. }
  129. void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
  130. {
  131. assert(obj);
  132. trace_visit_type_int(v, name, obj);
  133. v->type_int64(v, name, obj, errp);
  134. }
  135. static void visit_type_uintN(Visitor *v, uint64_t *obj, const char *name,
  136. uint64_t max, const char *type, Error **errp)
  137. {
  138. Error *err = NULL;
  139. uint64_t value = *obj;
  140. v->type_uint64(v, name, &value, &err);
  141. if (err) {
  142. error_propagate(errp, err);
  143. } else if (value > max) {
  144. error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
  145. name ? name : "null", type);
  146. } else {
  147. *obj = value;
  148. }
  149. }
  150. void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
  151. Error **errp)
  152. {
  153. uint64_t value;
  154. trace_visit_type_uint8(v, name, obj);
  155. value = *obj;
  156. visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
  157. *obj = value;
  158. }
  159. void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
  160. Error **errp)
  161. {
  162. uint64_t value;
  163. trace_visit_type_uint16(v, name, obj);
  164. value = *obj;
  165. visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
  166. *obj = value;
  167. }
  168. void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
  169. Error **errp)
  170. {
  171. uint64_t value;
  172. trace_visit_type_uint32(v, name, obj);
  173. value = *obj;
  174. visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
  175. *obj = value;
  176. }
  177. void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
  178. Error **errp)
  179. {
  180. assert(obj);
  181. trace_visit_type_uint64(v, name, obj);
  182. v->type_uint64(v, name, obj, errp);
  183. }
  184. static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
  185. int64_t min, int64_t max, const char *type,
  186. Error **errp)
  187. {
  188. Error *err = NULL;
  189. int64_t value = *obj;
  190. v->type_int64(v, name, &value, &err);
  191. if (err) {
  192. error_propagate(errp, err);
  193. } else if (value < min || value > max) {
  194. error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
  195. name ? name : "null", type);
  196. } else {
  197. *obj = value;
  198. }
  199. }
  200. void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
  201. {
  202. int64_t value;
  203. trace_visit_type_int8(v, name, obj);
  204. value = *obj;
  205. visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
  206. *obj = value;
  207. }
  208. void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
  209. Error **errp)
  210. {
  211. int64_t value;
  212. trace_visit_type_int16(v, name, obj);
  213. value = *obj;
  214. visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
  215. *obj = value;
  216. }
  217. void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
  218. Error **errp)
  219. {
  220. int64_t value;
  221. trace_visit_type_int32(v, name, obj);
  222. value = *obj;
  223. visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
  224. *obj = value;
  225. }
  226. void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
  227. Error **errp)
  228. {
  229. assert(obj);
  230. trace_visit_type_int64(v, name, obj);
  231. v->type_int64(v, name, obj, errp);
  232. }
  233. void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
  234. Error **errp)
  235. {
  236. assert(obj);
  237. trace_visit_type_size(v, name, obj);
  238. if (v->type_size) {
  239. v->type_size(v, name, obj, errp);
  240. } else {
  241. v->type_uint64(v, name, obj, errp);
  242. }
  243. }
  244. void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
  245. {
  246. assert(obj);
  247. trace_visit_type_bool(v, name, obj);
  248. v->type_bool(v, name, obj, errp);
  249. }
  250. void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
  251. {
  252. Error *err = NULL;
  253. assert(obj);
  254. /* TODO: Fix callers to not pass NULL when they mean "", so that we
  255. * can enable:
  256. assert(!(v->type & VISITOR_OUTPUT) || *obj);
  257. */
  258. trace_visit_type_str(v, name, obj);
  259. v->type_str(v, name, obj, &err);
  260. if (v->type & VISITOR_INPUT) {
  261. assert(!err != !*obj);
  262. }
  263. error_propagate(errp, err);
  264. }
  265. void visit_type_number(Visitor *v, const char *name, double *obj,
  266. Error **errp)
  267. {
  268. assert(obj);
  269. trace_visit_type_number(v, name, obj);
  270. v->type_number(v, name, obj, errp);
  271. }
  272. void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
  273. {
  274. Error *err = NULL;
  275. assert(obj);
  276. assert(v->type != VISITOR_OUTPUT || *obj);
  277. trace_visit_type_any(v, name, obj);
  278. v->type_any(v, name, obj, &err);
  279. if (v->type == VISITOR_INPUT) {
  280. assert(!err != !*obj);
  281. }
  282. error_propagate(errp, err);
  283. }
  284. void visit_type_null(Visitor *v, const char *name, Error **errp)
  285. {
  286. trace_visit_type_null(v, name);
  287. v->type_null(v, name, errp);
  288. }
  289. static void output_type_enum(Visitor *v, const char *name, int *obj,
  290. const char *const strings[], Error **errp)
  291. {
  292. int i = 0;
  293. int value = *obj;
  294. char *enum_str;
  295. while (strings[i++] != NULL);
  296. if (value < 0 || value >= i - 1) {
  297. error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
  298. return;
  299. }
  300. enum_str = (char *)strings[value];
  301. visit_type_str(v, name, &enum_str, errp);
  302. }
  303. static void input_type_enum(Visitor *v, const char *name, int *obj,
  304. const char *const strings[], Error **errp)
  305. {
  306. Error *local_err = NULL;
  307. int64_t value = 0;
  308. char *enum_str;
  309. visit_type_str(v, name, &enum_str, &local_err);
  310. if (local_err) {
  311. error_propagate(errp, local_err);
  312. return;
  313. }
  314. while (strings[value] != NULL) {
  315. if (strcmp(strings[value], enum_str) == 0) {
  316. break;
  317. }
  318. value++;
  319. }
  320. if (strings[value] == NULL) {
  321. error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
  322. g_free(enum_str);
  323. return;
  324. }
  325. g_free(enum_str);
  326. *obj = value;
  327. }
  328. void visit_type_enum(Visitor *v, const char *name, int *obj,
  329. const char *const strings[], Error **errp)
  330. {
  331. assert(obj && strings);
  332. trace_visit_type_enum(v, name, obj);
  333. switch (v->type) {
  334. case VISITOR_INPUT:
  335. input_type_enum(v, name, obj, strings, errp);
  336. break;
  337. case VISITOR_OUTPUT:
  338. output_type_enum(v, name, obj, strings, errp);
  339. break;
  340. case VISITOR_CLONE:
  341. /* nothing further to do, scalar value was already copied by
  342. * g_memdup() during visit_start_*() */
  343. break;
  344. case VISITOR_DEALLOC:
  345. /* nothing to deallocate for a scalar */
  346. break;
  347. }
  348. }