qapi/qapi-clone-visitor.c

   1 /*
   2  * Copy one QAPI object to another
   3  *
   4  * Copyright (C) 2016 Red Hat, Inc.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12 #include "qapi/clone-visitor.h"
  13 #include "qapi/visitor-impl.h"
  14 #include "qapi/error.h"
  15 #include "qapi/qmp/qnull.h"
  16
  17 struct QapiCloneVisitor {
  18     Visitor visitor;
  19     size_t depth;
  20 };
  21
  22 static QapiCloneVisitor *to_qcv(Visitor *v)
  23 {
  24     return container_of(v, QapiCloneVisitor, visitor);
  25 }
  26
  27 static bool qapi_clone_start_struct(Visitor *v, const char *name, void **obj,
  28                                     size_t size, Error **errp)
  29 {
  30     QapiCloneVisitor *qcv = to_qcv(v);
  31
  32     if (!obj) {
  33         assert(qcv->depth);
  34         /* Only possible when visiting an alternate's object
  35          * branch. Nothing further to do here, since the earlier
  36          * visit_start_alternate() already copied memory. */
  37         return true;
  38     }
  39
  40     *obj = g_memdup(*obj, size);
  41     qcv->depth++;
  42     return true;
  43 }
  44
  45 static void qapi_clone_end(Visitor *v, void **obj)
  46 {
  47     QapiCloneVisitor *qcv = to_qcv(v);
  48
  49     assert(qcv->depth);
  50     if (obj) {
  51         qcv->depth--;
  52     }
  53 }
  54
  55 static bool qapi_clone_start_list(Visitor *v, const char *name,
  56                                   GenericList **listp, size_t size,
  57                                   Error **errp)
  58 {
  59     return qapi_clone_start_struct(v, name, (void **)listp, size, errp);
  60 }
  61
  62 static GenericList *qapi_clone_next_list(Visitor *v, GenericList *tail,
  63                                          size_t size)
  64 {
  65     QapiCloneVisitor *qcv = to_qcv(v);
  66
  67     assert(qcv->depth);
  68     /* Unshare the tail of the list cloned by g_memdup() */
  69     tail->next = g_memdup(tail->next, size);
  70     return tail->next;
  71 }
  72
  73 static bool qapi_clone_start_alternate(Visitor *v, const char *name,
  74                                        GenericAlternate **obj, size_t size,
  75                                        Error **errp)
  76 {
  77     return qapi_clone_start_struct(v, name, (void **)obj, size, errp);
  78 }
  79
  80 static bool qapi_clone_type_int64(Visitor *v, const char *name, int64_t *obj,
  81                                   Error **errp)
  82 {
  83     QapiCloneVisitor *qcv = to_qcv(v);
  84
  85     assert(qcv->depth);
  86     /* Value was already cloned by g_memdup() */
  87     return true;
  88 }
  89
  90 static bool qapi_clone_type_uint64(Visitor *v, const char *name,
  91                                    uint64_t *obj, Error **errp)
  92 {
  93     QapiCloneVisitor *qcv = to_qcv(v);
  94
  95     assert(qcv->depth);
  96     /* Value was already cloned by g_memdup() */
  97     return true;
  98 }
  99
 100 static bool qapi_clone_type_bool(Visitor *v, const char *name, bool *obj,
 101                                  Error **errp)
 102 {
 103     QapiCloneVisitor *qcv = to_qcv(v);
 104
 105     assert(qcv->depth);
 106     /* Value was already cloned by g_memdup() */
 107     return true;
 108 }
 109
 110 static bool qapi_clone_type_str(Visitor *v, const char *name, char **obj,
 111                                 Error **errp)
 112 {
 113     QapiCloneVisitor *qcv = to_qcv(v);
 114
 115     assert(qcv->depth);
 116     /*
 117      * Pointer was already cloned by g_memdup; create fresh copy.
 118      * Note that as long as qobject-output-visitor accepts NULL instead of
 119      * "", then we must do likewise. However, we want to obey the
 120      * input visitor semantics of never producing NULL when the empty
 121      * string is intended.
 122      */
 123     *obj = g_strdup(*obj ?: "");
 124     return true;
 125 }
 126
 127 static bool qapi_clone_type_number(Visitor *v, const char *name, double *obj,
 128                                    Error **errp)
 129 {
 130     QapiCloneVisitor *qcv = to_qcv(v);
 131
 132     assert(qcv->depth);
 133     /* Value was already cloned by g_memdup() */
 134     return true;
 135 }
 136
 137 static bool qapi_clone_type_null(Visitor *v, const char *name, QNull **obj,
 138                                  Error **errp)
 139 {
 140     QapiCloneVisitor *qcv = to_qcv(v);
 141
 142     assert(qcv->depth);
 143     *obj = qnull();
 144     return true;
 145 }
 146
 147 static void qapi_clone_free(Visitor *v)
 148 {
 149     g_free(v);
 150 }
 151
 152 Visitor *qapi_clone_visitor_new(void)
 153 {
 154     QapiCloneVisitor *v;
 155
 156     v = g_malloc0(sizeof(*v));
 157
 158     v->visitor.type = VISITOR_CLONE;
 159     v->visitor.start_struct = qapi_clone_start_struct;
 160     v->visitor.end_struct = qapi_clone_end;
 161     v->visitor.start_list = qapi_clone_start_list;
 162     v->visitor.next_list = qapi_clone_next_list;
 163     v->visitor.end_list = qapi_clone_end;
 164     v->visitor.start_alternate = qapi_clone_start_alternate;
 165     v->visitor.end_alternate = qapi_clone_end;
 166     v->visitor.type_int64 = qapi_clone_type_int64;
 167     v->visitor.type_uint64 = qapi_clone_type_uint64;
 168     v->visitor.type_bool = qapi_clone_type_bool;
 169     v->visitor.type_str = qapi_clone_type_str;
 170     v->visitor.type_number = qapi_clone_type_number;
 171     v->visitor.type_null = qapi_clone_type_null;
 172     v->visitor.free = qapi_clone_free;
 173
 174     return &v->visitor;
 175 }
 176
 177 Visitor *qapi_clone_members_visitor_new(void)
 178 {
 179     Visitor *v = qapi_clone_visitor_new();
 180     to_qcv(v)->depth++;
 181     return v;
 182 }