chardev/spice.c

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