spice-qemu-char.c

   1 #include "qemu/osdep.h"
   2 #include "trace.h"
   3 #include "ui/qemu-spice.h"
   4 #include "sysemu/char.h"
   5 #include "qemu/error-report.h"
   6 #include <spice.h>
   7 #include <spice/protocol.h>
   8
   9
  10 typedef struct SpiceChardev {
  11     Chardev               parent;
  12
  13     SpiceCharDeviceInstance sin;
  14     bool                  active;
  15     bool                  blocked;
  16     const uint8_t         *datapos;
  17     int                   datalen;
  18     QLIST_ENTRY(SpiceChardev) next;
  19 } SpiceChardev;
  20
  21 #define TYPE_CHARDEV_SPICE "chardev-spice"
  22 #define TYPE_CHARDEV_SPICEVMC "chardev-spicevmc"
  23 #define TYPE_CHARDEV_SPICEPORT "chardev-spiceport"
  24
  25 #define SPICE_CHARDEV(obj) OBJECT_CHECK(SpiceChardev, (obj), TYPE_CHARDEV_SPICE)
  26
  27 typedef struct SpiceCharSource {
  28     GSource               source;
  29     SpiceChardev       *scd;
  30 } SpiceCharSource;
  31
  32 static QLIST_HEAD(, SpiceChardev) spice_chars =
  33     QLIST_HEAD_INITIALIZER(spice_chars);
  34
  35 static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
  36 {
  37     SpiceChardev *scd = container_of(sin, SpiceChardev, sin);
  38     Chardev *chr = CHARDEV(scd);
  39     ssize_t out = 0;
  40     ssize_t last_out;
  41     uint8_t* p = (uint8_t*)buf;
  42
  43     while (len > 0) {
  44         int can_write = qemu_chr_be_can_write(chr);
  45         last_out = MIN(len, can_write);
  46         if (last_out <= 0) {
  47             break;
  48         }
  49         qemu_chr_be_write(chr, p, last_out);
  50         out += last_out;
  51         len -= last_out;
  52         p += last_out;
  53     }
  54
  55     trace_spice_vmc_write(out, len + out);
  56     return out;
  57 }
  58
  59 static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len)
  60 {
  61     SpiceChardev *scd = container_of(sin, SpiceChardev, sin);
  62     int bytes = MIN(len, scd->datalen);
  63
  64     if (bytes > 0) {
  65         memcpy(buf, scd->datapos, bytes);
  66         scd->datapos += bytes;
  67         scd->datalen -= bytes;
  68         assert(scd->datalen >= 0);
  69     }
  70     if (scd->datalen == 0) {
  71         scd->datapos = 0;
  72         scd->blocked = false;
  73     }
  74     trace_spice_vmc_read(bytes, len);
  75     return bytes;
  76 }
  77
  78 #if SPICE_SERVER_VERSION >= 0x000c02
  79 static void vmc_event(SpiceCharDeviceInstance *sin, uint8_t event)
  80 {
  81     SpiceChardev *scd = container_of(sin, SpiceChardev, sin);
  82     Chardev *chr = CHARDEV(scd);
  83     int chr_event;
  84
  85     switch (event) {
  86     case SPICE_PORT_EVENT_BREAK:
  87         chr_event = CHR_EVENT_BREAK;
  88         break;
  89     default:
  90         return;
  91     }
  92
  93     trace_spice_vmc_event(chr_event);
  94     qemu_chr_be_event(chr, chr_event);
  95 }
  96 #endif
  97
  98 static void vmc_state(SpiceCharDeviceInstance *sin, int connected)
  99 {
 100     SpiceChardev *scd = container_of(sin, SpiceChardev, sin);
 101     Chardev *chr = CHARDEV(scd);
 102
 103     if ((chr->be_open && connected) ||
 104         (!chr->be_open && !connected)) {
 105         return;
 106     }
 107
 108     qemu_chr_be_event(chr,
 109                       connected ? CHR_EVENT_OPENED : CHR_EVENT_CLOSED);
 110 }
 111
 112 static SpiceCharDeviceInterface vmc_interface = {
 113     .base.type          = SPICE_INTERFACE_CHAR_DEVICE,
 114     .base.description   = "spice virtual channel char device",
 115     .base.major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
 116     .base.minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
 117     .state              = vmc_state,
 118     .write              = vmc_write,
 119     .read               = vmc_read,
 120 #if SPICE_SERVER_VERSION >= 0x000c02
 121     .event              = vmc_event,
 122 #endif
 123 #if SPICE_SERVER_VERSION >= 0x000c06
 124     .flags              = SPICE_CHAR_DEVICE_NOTIFY_WRITABLE,
 125 #endif
 126 };
 127
 128
 129 static void vmc_register_interface(SpiceChardev *scd)
 130 {
 131     if (scd->active) {
 132         return;
 133     }
 134     scd->sin.base.sif = &vmc_interface.base;
 135     qemu_spice_add_interface(&scd->sin.base);
 136     scd->active = true;
 137     trace_spice_vmc_register_interface(scd);
 138 }
 139
 140 static void vmc_unregister_interface(SpiceChardev *scd)
 141 {
 142     if (!scd->active) {
 143         return;
 144     }
 145     spice_server_remove_interface(&scd->sin.base);
 146     scd->active = false;
 147     trace_spice_vmc_unregister_interface(scd);
 148 }
 149
 150 static gboolean spice_char_source_prepare(GSource *source, gint *timeout)
 151 {
 152     SpiceCharSource *src = (SpiceCharSource *)source;
 153
 154     *timeout = -1;
 155
 156     return !src->scd->blocked;
 157 }
 158
 159 static gboolean spice_char_source_check(GSource *source)
 160 {
 161     SpiceCharSource *src = (SpiceCharSource *)source;
 162
 163     return !src->scd->blocked;
 164 }
 165
 166 static gboolean spice_char_source_dispatch(GSource *source,
 167     GSourceFunc callback, gpointer user_data)
 168 {
 169     GIOFunc func = (GIOFunc)callback;
 170
 171     return func(NULL, G_IO_OUT, user_data);
 172 }
 173
 174 static GSourceFuncs SpiceCharSourceFuncs = {
 175     .prepare  = spice_char_source_prepare,
 176     .check    = spice_char_source_check,
 177     .dispatch = spice_char_source_dispatch,
 178 };
 179
 180 static GSource *spice_chr_add_watch(Chardev *chr, GIOCondition cond)
 181 {
 182     SpiceChardev *scd = SPICE_CHARDEV(chr);
 183     SpiceCharSource *src;
 184
 185     assert(cond & G_IO_OUT);
 186
 187     src = (SpiceCharSource *)g_source_new(&SpiceCharSourceFuncs,
 188                                           sizeof(SpiceCharSource));
 189     src->scd = scd;
 190
 191     return (GSource *)src;
 192 }
 193
 194 static int spice_chr_write(Chardev *chr, const uint8_t *buf, int len)
 195 {
 196     SpiceChardev *s = SPICE_CHARDEV(chr);
 197     int read_bytes;
 198
 199     assert(s->datalen == 0);
 200     s->datapos = buf;
 201     s->datalen = len;
 202     spice_server_char_device_wakeup(&s->sin);
 203     read_bytes = len - s->datalen;
 204     if (read_bytes != len) {
 205         /* We'll get passed in the unconsumed data with the next call */
 206         s->datalen = 0;
 207         s->datapos = NULL;
 208         s->blocked = true;
 209     }
 210     return read_bytes;
 211 }
 212
 213 static void spice_chr_free(struct Chardev *chr)
 214 {
 215     SpiceChardev *s = SPICE_CHARDEV(chr);
 216
 217     vmc_unregister_interface(s);
 218     QLIST_REMOVE(s, next);
 219
 220     g_free((char *)s->sin.subtype);
 221 #if SPICE_SERVER_VERSION >= 0x000c02
 222     g_free((char *)s->sin.portname);
 223 #endif
 224 }
 225
 226 static void spice_vmc_set_fe_open(struct Chardev *chr, int fe_open)
 227 {
 228     SpiceChardev *s = SPICE_CHARDEV(chr);
 229     if (fe_open) {
 230         vmc_register_interface(s);
 231     } else {
 232         vmc_unregister_interface(s);
 233     }
 234 }
 235
 236 static void spice_port_set_fe_open(struct Chardev *chr, int fe_open)
 237 {
 238 #if SPICE_SERVER_VERSION >= 0x000c02
 239     SpiceChardev *s = SPICE_CHARDEV(chr);
 240
 241     if (fe_open) {
 242         spice_server_port_event(&s->sin, SPICE_PORT_EVENT_OPENED);
 243     } else {
 244         spice_server_port_event(&s->sin, SPICE_PORT_EVENT_CLOSED);
 245     }
 246 #endif
 247 }
 248
 249 static void spice_chr_accept_input(struct Chardev *chr)
 250 {
 251     SpiceChardev *s = SPICE_CHARDEV(chr);
 252
 253     spice_server_char_device_wakeup(&s->sin);
 254 }
 255
 256 static void chr_open(Chardev *chr, const char *subtype)
 257 {
 258     SpiceChardev *s = SPICE_CHARDEV(chr);
 259
 260     s->active = false;
 261     s->sin.subtype = g_strdup(subtype);
 262
 263     QLIST_INSERT_HEAD(&spice_chars, s, next);
 264 }
 265
 266 static void qemu_chr_open_spice_vmc(Chardev *chr,
 267                                     ChardevBackend *backend,
 268                                     bool *be_opened,
 269                                     Error **errp)
 270 {
 271     ChardevSpiceChannel *spicevmc = backend->u.spicevmc.data;
 272     const char *type = spicevmc->type;
 273     const char **psubtype = spice_server_char_device_recognized_subtypes();
 274
 275     for (; *psubtype != NULL; ++psubtype) {
 276         if (strcmp(type, *psubtype) == 0) {
 277             break;
 278         }
 279     }
 280     if (*psubtype == NULL) {
 281         char *subtypes = g_strjoinv(", ",
 282             (gchar **)spice_server_char_device_recognized_subtypes());
 283
 284         error_setg(errp, "unsupported type name: %s", type);
 285         error_append_hint(errp, "allowed spice char type names: %s\n",
 286                           subtypes);
 287
 288         g_free(subtypes);
 289         return;
 290     }
 291
 292     *be_opened = false;
 293     chr_open(chr, type);
 294 }
 295
 296 #if SPICE_SERVER_VERSION >= 0x000c02
 297 static void qemu_chr_open_spice_port(Chardev *chr,
 298                                      ChardevBackend *backend,
 299                                      bool *be_opened,
 300                                      Error **errp)
 301 {
 302     ChardevSpicePort *spiceport = backend->u.spiceport.data;
 303     const char *name = spiceport->fqdn;
 304     SpiceChardev *s;
 305
 306     if (name == NULL) {
 307         error_setg(errp, "missing name parameter");
 308         return;
 309     }
 310
 311     chr_open(chr, "port");
 312
 313     *be_opened = false;
 314     s = SPICE_CHARDEV(chr);
 315     s->sin.portname = g_strdup(name);
 316 }
 317
 318 void qemu_spice_register_ports(void)
 319 {
 320     SpiceChardev *s;
 321
 322     QLIST_FOREACH(s, &spice_chars, next) {
 323         if (s->sin.portname == NULL) {
 324             continue;
 325         }
 326         vmc_register_interface(s);
 327     }
 328 }
 329 #endif
 330
 331 static void qemu_chr_parse_spice_vmc(QemuOpts *opts, ChardevBackend *backend,
 332                                      Error **errp)
 333 {
 334     const char *name = qemu_opt_get(opts, "name");
 335     ChardevSpiceChannel *spicevmc;
 336
 337     if (name == NULL) {
 338         error_setg(errp, "chardev: spice channel: no name given");
 339         return;
 340     }
 341     spicevmc = backend->u.spicevmc.data = g_new0(ChardevSpiceChannel, 1);
 342     qemu_chr_parse_common(opts, qapi_ChardevSpiceChannel_base(spicevmc));
 343     spicevmc->type = g_strdup(name);
 344 }
 345
 346 static void qemu_chr_parse_spice_port(QemuOpts *opts, ChardevBackend *backend,
 347                                       Error **errp)
 348 {
 349     const char *name = qemu_opt_get(opts, "name");
 350     ChardevSpicePort *spiceport;
 351
 352     if (name == NULL) {
 353         error_setg(errp, "chardev: spice port: no name given");
 354         return;
 355     }
 356     spiceport = backend->u.spiceport.data = g_new0(ChardevSpicePort, 1);
 357     qemu_chr_parse_common(opts, qapi_ChardevSpicePort_base(spiceport));
 358     spiceport->fqdn = g_strdup(name);
 359 }
 360
 361 static void char_spice_class_init(ObjectClass *oc, void *data)
 362 {
 363     ChardevClass *cc = CHARDEV_CLASS(oc);
 364
 365     cc->chr_write = spice_chr_write;
 366     cc->chr_add_watch = spice_chr_add_watch;
 367     cc->chr_accept_input = spice_chr_accept_input;
 368     cc->chr_free = spice_chr_free;
 369 }
 370
 371 static const TypeInfo char_spice_type_info = {
 372     .name = TYPE_CHARDEV_SPICE,
 373     .parent = TYPE_CHARDEV,
 374     .instance_size = sizeof(SpiceChardev),
 375     .class_init = char_spice_class_init,
 376     .abstract = true,
 377 };
 378
 379 static void char_spicevmc_class_init(ObjectClass *oc, void *data)
 380 {
 381     ChardevClass *cc = CHARDEV_CLASS(oc);
 382
 383     cc->open = qemu_chr_open_spice_vmc;
 384     cc->chr_set_fe_open = spice_vmc_set_fe_open;
 385 }
 386
 387 static const TypeInfo char_spicevmc_type_info = {
 388     .name = TYPE_CHARDEV_SPICEVMC,
 389     .parent = TYPE_CHARDEV_SPICE,
 390     .class_init = char_spicevmc_class_init,
 391 };
 392
 393 static void char_spiceport_class_init(ObjectClass *oc, void *data)
 394 {
 395     ChardevClass *cc = CHARDEV_CLASS(oc);
 396
 397     cc->open = qemu_chr_open_spice_port;
 398     cc->chr_set_fe_open = spice_port_set_fe_open;
 399 }
 400
 401 static const TypeInfo char_spiceport_type_info = {
 402     .name = TYPE_CHARDEV_SPICEPORT,
 403     .parent = TYPE_CHARDEV_SPICE,
 404     .class_init = char_spiceport_class_init,
 405 };
 406
 407 static void register_types(void)
 408 {
 409     static const CharDriver vmc_driver = {
 410         .kind = CHARDEV_BACKEND_KIND_SPICEVMC,
 411         .parse = qemu_chr_parse_spice_vmc,
 412     };
 413     static const CharDriver port_driver = {
 414         .kind = CHARDEV_BACKEND_KIND_SPICEPORT,
 415         .parse = qemu_chr_parse_spice_port,
 416     };
 417     register_char_driver(&vmc_driver);
 418     register_char_driver(&port_driver);
 419
 420     type_register_static(&char_spice_type_info);
 421     type_register_static(&char_spicevmc_type_info);
 422     type_register_static(&char_spiceport_type_info);
 423 }
 424
 425 type_init(register_types);