devices/plug.c

   1 #include "qemu/plug.h"
   2 #include "qerror.h"
   3 #include "string-visitor.h"
   4
   5 #define MAX_NAME (32 + 1)
   6 #define MAX_TYPENAME (32 + 1)
   7
   8 struct PlugProperty
   9 {
  10     char name[MAX_NAME];
  11     char typename[MAX_TYPENAME];
  12
  13
  14     PlugPropertyAccessor *getter;
  15     void *getter_opaque;
  16
  17     PlugPropertyAccessor *setter;
  18     void *setter_opaque;
  19
  20     int flags;
  21
  22     PlugProperty *next;
  23 };
  24
  25 void plug_add_property_full(Plug *plug, const char *name,
  26                             PlugPropertyAccessor *getter, void *getter_opaque,
  27                             PlugPropertyAccessor *setter, void *setter_opaque,
  28                             const char *typename, int flags)
  29 {
  30     PlugProperty *prop = qemu_mallocz(sizeof(*prop));
  31
  32     snprintf(prop->name, sizeof(prop->name), "%s", name);
  33     snprintf(prop->typename, sizeof(prop->typename), "%s", typename);
  34
  35     prop->getter = getter;
  36     prop->getter_opaque = getter_opaque;
  37
  38     prop->setter = setter;
  39     prop->setter_opaque = setter_opaque;
  40
  41     prop->flags = flags;
  42
  43     prop->next = plug->first_prop;
  44     plug->first_prop = prop;
  45 }
  46
  47 static PlugProperty *plug_find_property(Plug *plug, const char *name)
  48 {
  49     PlugProperty *prop;
  50
  51     for (prop = plug->first_prop; prop; prop = prop->next) {
  52         if (strcmp(prop->name, name) == 0) {
  53             return prop;
  54         }
  55     }
  56
  57     return NULL;
  58 }
  59
  60 void plug_set_property(Plug *plug, const char *name, Visitor *v, Error **errp)
  61 {
  62     PlugProperty *prop = plug_find_property(plug, name);
  63
  64     if (!prop) {
  65         error_set(errp, QERR_PROPERTY_NOT_FOUND, type_get_id(TYPE_INSTANCE(plug)), name);
  66         return;
  67     }
  68
  69     if (!(prop->flags & PROP_F_WRITE) || (prop->flags & PROP_F_LOCKED)) {
  70         error_set(errp, QERR_PROPERTY_READ_ONLY, type_get_id(TYPE_INSTANCE(plug)), name);
  71         return;
  72     }
  73
  74     prop->setter(plug, name, v, prop->setter_opaque, errp);
  75 }
  76
  77 void plug_get_property(Plug *plug, const char *name, Visitor *v, Error **errp)
  78 {
  79     PlugProperty *prop = plug_find_property(plug, name);
  80
  81     if (!prop) {
  82         error_set(errp, QERR_PROPERTY_NOT_FOUND, type_get_id(TYPE_INSTANCE(plug)), name);
  83         printf("property not found\n");
  84         return;
  85     }
  86
  87     if (!(prop->flags & PROP_F_READ)) {
  88         error_set(errp, QERR_PROPERTY_READ_ONLY, type_get_id(TYPE_INSTANCE(plug)), name);
  89         printf("property read only\n");
  90         return;
  91     }
  92
  93
  94     prop->getter(plug, name, v, prop->getter_opaque, errp);
  95 }
  96
  97 void plug_lock_property(Plug *plug, const char *name)
  98 {
  99     PlugProperty *prop = plug_find_property(plug, name);
 100
 101     assert(prop != NULL);
 102
 103     prop->flags |= PROP_F_LOCKED;
 104 }
 105
 106 void plug_unlock_property(Plug *plug, const char *name)
 107 {
 108     PlugProperty *prop = plug_find_property(plug, name);
 109
 110     assert(prop != NULL);
 111
 112     prop->flags &= ~PROP_F_LOCKED;
 113 }
 114
 115 void plug_lock_all_properties(Plug *plug)
 116 {
 117     PlugProperty *prop;
 118
 119     for (prop = plug->first_prop; prop; prop = prop->next) {
 120         prop->flags |= PROP_F_LOCKED;
 121     }
 122 }
 123
 124 void plug_unlock_all_properties(Plug *plug)
 125 {
 126     PlugProperty *prop;
 127
 128     for (prop = plug->first_prop; prop; prop = prop->next) {
 129         prop->flags &= ~PROP_F_LOCKED;
 130     }
 131 }
 132
 133 void plug_foreach_property(Plug *plug, PropertyEnumerator *enumfn, void *opaque)
 134 {
 135     PlugProperty *prop;
 136
 137     for (prop = plug->first_prop; prop; prop = prop->next) {
 138         enumfn(plug, prop->name, prop->typename, prop->flags, opaque);
 139     }
 140 }
 141
 142 void plug_set_realized(Plug *plug, bool realized)
 143 {
 144     PlugClass *class = PLUG_GET_CLASS(plug);
 145     bool old_value = plug->realized;
 146
 147     plug->realized = realized;
 148
 149     if (plug->realized && !old_value) {
 150         if (class->realize) {
 151             class->realize(plug);
 152         }
 153     } else if (!plug->realized && old_value) {
 154         if (class->unrealize) {
 155             class->unrealize(plug);
 156         }
 157     }
 158 }
 159
 160 bool plug_get_realized(Plug *plug)
 161 {
 162     return plug->realized;
 163 }
 164
 165 char *plug_get_property_str(Plug *plug, const char *name, Error **errp)
 166 {
 167     StringOutputVisitor sov;
 168
 169     string_output_visitor_init(&sov);
 170     plug_get_property(plug, name, &sov.parent, errp);
 171
 172     return qemu_strdup(sov.value);
 173 }
 174
 175 static void plug_propagate_realized(Plug *plug, const char *name,
 176                                     const char *typename, int flags,
 177                                     void *opaque)
 178 {
 179     if (strstart(typename, "plug<", NULL)) {
 180         char *child_name;
 181         Plug *child_plug;
 182
 183         child_name = plug_get_property_str(plug, name, NULL);
 184         child_plug = PLUG(type_find_by_id(child_name));
 185
 186         plug_set_realized(child_plug, plug_get_realized(plug));
 187
 188         qemu_free(child_name);
 189     }
 190 }
 191
 192 void plug_realize_all(Plug *plug)
 193 {
 194     /* This doesn't loop infinitely because the callbacks are only called when
 195      * the state changes. */
 196     plug_set_realized(plug, true);
 197     plug_lock_all_properties(plug);
 198     plug_foreach_property(plug, plug_propagate_realized, NULL);
 199 }
 200
 201 void plug_unrealize_all(Plug *plug)
 202 {
 203     /* This doesn't loop infinitely because the callbacks are only called when
 204      * the state changes. */
 205     plug_set_realized(plug, false);
 206     plug_unlock_all_properties(plug);
 207     plug_foreach_property(plug, plug_propagate_realized, NULL);
 208 }
 209
 210 static void plug_class_initfn(TypeClass *base_class)
 211 {
 212     PlugClass *class = PLUG_CLASS(base_class);
 213
 214     class->realize = plug_realize_all;
 215     class->unrealize = plug_unrealize_all;
 216 }
 217
 218 void plug_initialize(Plug *plug, const char *id)
 219 {
 220     type_initialize(plug, TYPE_PLUG, id);
 221 }
 222
 223 void plug_finalize(Plug *plug)
 224 {
 225     type_finalize(plug);
 226 }
 227
 228 static void plug_initfn(TypeInstance *inst)
 229 {
 230     Plug *obj = PLUG(inst);
 231
 232     plug_add_property_bool(obj, "realized",
 233                            plug_get_realized,
 234                            plug_set_realized,
 235                            PROP_F_READWRITE);
 236 }
 237
 238 static const TypeInfo plug_type_info = {
 239     .name = TYPE_PLUG,
 240     .instance_size = sizeof(Plug),
 241     .class_size = sizeof(PlugClass),
 242     .instance_init = plug_initfn,
 243     .class_init = plug_class_initfn,
 244 };
 245
 246 static void register_devices(void)
 247 {
 248     type_register_static(&plug_type_info);
 249 }
 250
 251 device_init(register_devices);