File:  [Qemu by Fabrice Bellard] / qemu / spice-qemu-char.c
Revision 1.1.1.1 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:33:27 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu0150, qemu0141, qemu0140, HEAD
qemu 0.14.0

    1: #include "config-host.h"
    2: #include "trace.h"
    3: #include "ui/qemu-spice.h"
    4: #include <spice.h>
    5: #include <spice-experimental.h>
    6: 
    7: #include "osdep.h"
    8: 
    9: #define dprintf(_scd, _level, _fmt, ...)                                \
   10:     do {                                                                \
   11:         static unsigned __dprintf_counter = 0;                          \
   12:         if (_scd->debug >= _level) {                                    \
   13:             fprintf(stderr, "scd: %3d: " _fmt, ++__dprintf_counter, ## __VA_ARGS__);\
   14:         }                                                               \
   15:     } while (0)
   16: 
   17: #define VMC_MAX_HOST_WRITE    2048
   18: 
   19: typedef struct SpiceCharDriver {
   20:     CharDriverState*      chr;
   21:     SpiceCharDeviceInstance     sin;
   22:     char                  *subtype;
   23:     bool                  active;
   24:     uint8_t               *buffer;
   25:     uint8_t               *datapos;
   26:     ssize_t               bufsize, datalen;
   27:     uint32_t              debug;
   28: } SpiceCharDriver;
   29: 
   30: static int vmc_write(SpiceCharDeviceInstance *sin, const uint8_t *buf, int len)
   31: {
   32:     SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
   33:     ssize_t out = 0;
   34:     ssize_t last_out;
   35:     uint8_t* p = (uint8_t*)buf;
   36: 
   37:     while (len > 0) {
   38:         last_out = MIN(len, VMC_MAX_HOST_WRITE);
   39:         qemu_chr_read(scd->chr, p, last_out);
   40:         if (last_out > 0) {
   41:             out += last_out;
   42:             len -= last_out;
   43:             p += last_out;
   44:         } else {
   45:             break;
   46:         }
   47:     }
   48: 
   49:     dprintf(scd, 3, "%s: %lu/%zd\n", __func__, out, len + out);
   50:     trace_spice_vmc_write(out, len + out);
   51:     return out;
   52: }
   53: 
   54: static int vmc_read(SpiceCharDeviceInstance *sin, uint8_t *buf, int len)
   55: {
   56:     SpiceCharDriver *scd = container_of(sin, SpiceCharDriver, sin);
   57:     int bytes = MIN(len, scd->datalen);
   58: 
   59:     dprintf(scd, 2, "%s: %p %d/%d/%zd\n", __func__, scd->datapos, len, bytes, scd->datalen);
   60:     if (bytes > 0) {
   61:         memcpy(buf, scd->datapos, bytes);
   62:         scd->datapos += bytes;
   63:         scd->datalen -= bytes;
   64:         assert(scd->datalen >= 0);
   65:         if (scd->datalen == 0) {
   66:             scd->datapos = 0;
   67:         }
   68:     }
   69:     trace_spice_vmc_read(bytes, len);
   70:     return bytes;
   71: }
   72: 
   73: static SpiceCharDeviceInterface vmc_interface = {
   74:     .base.type          = SPICE_INTERFACE_CHAR_DEVICE,
   75:     .base.description   = "spice virtual channel char device",
   76:     .base.major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
   77:     .base.minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
   78:     .write              = vmc_write,
   79:     .read               = vmc_read,
   80: };
   81: 
   82: 
   83: static void vmc_register_interface(SpiceCharDriver *scd)
   84: {
   85:     if (scd->active) {
   86:         return;
   87:     }
   88:     dprintf(scd, 1, "%s\n", __func__);
   89:     scd->sin.base.sif = &vmc_interface.base;
   90:     qemu_spice_add_interface(&scd->sin.base);
   91:     scd->active = true;
   92:     trace_spice_vmc_register_interface(scd);
   93: }
   94: 
   95: static void vmc_unregister_interface(SpiceCharDriver *scd)
   96: {
   97:     if (!scd->active) {
   98:         return;
   99:     }
  100:     dprintf(scd, 1, "%s\n", __func__);
  101:     spice_server_remove_interface(&scd->sin.base);
  102:     scd->active = false;
  103:     trace_spice_vmc_unregister_interface(scd);
  104: }
  105: 
  106: 
  107: static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
  108: {
  109:     SpiceCharDriver *s = chr->opaque;
  110: 
  111:     dprintf(s, 2, "%s: %d\n", __func__, len);
  112:     vmc_register_interface(s);
  113:     assert(s->datalen == 0);
  114:     if (s->bufsize < len) {
  115:         s->bufsize = len;
  116:         s->buffer = qemu_realloc(s->buffer, s->bufsize);
  117:     }
  118:     memcpy(s->buffer, buf, len);
  119:     s->datapos = s->buffer;
  120:     s->datalen = len;
  121:     spice_server_char_device_wakeup(&s->sin);
  122:     return len;
  123: }
  124: 
  125: static void spice_chr_close(struct CharDriverState *chr)
  126: {
  127:     SpiceCharDriver *s = chr->opaque;
  128: 
  129:     printf("%s\n", __func__);
  130:     vmc_unregister_interface(s);
  131:     qemu_free(s);
  132: }
  133: 
  134: static void print_allowed_subtypes(void)
  135: {
  136:     const char** psubtype;
  137:     int i;
  138: 
  139:     fprintf(stderr, "allowed names: ");
  140:     for(i=0, psubtype = spice_server_char_device_recognized_subtypes();
  141:         *psubtype != NULL; ++psubtype, ++i) {
  142:         if (i == 0) {
  143:             fprintf(stderr, "%s", *psubtype);
  144:         } else {
  145:             fprintf(stderr, ", %s", *psubtype);
  146:         }
  147:     }
  148:     fprintf(stderr, "\n");
  149: }
  150: 
  151: CharDriverState *qemu_chr_open_spice(QemuOpts *opts)
  152: {
  153:     CharDriverState *chr;
  154:     SpiceCharDriver *s;
  155:     const char* name = qemu_opt_get(opts, "name");
  156:     uint32_t debug = qemu_opt_get_number(opts, "debug", 0);
  157:     const char** psubtype = spice_server_char_device_recognized_subtypes();
  158:     const char *subtype = NULL;
  159: 
  160:     if (name == NULL) {
  161:         fprintf(stderr, "spice-qemu-char: missing name parameter\n");
  162:         print_allowed_subtypes();
  163:         return NULL;
  164:     }
  165:     for(;*psubtype != NULL; ++psubtype) {
  166:         if (strcmp(name, *psubtype) == 0) {
  167:             subtype = *psubtype;
  168:             break;
  169:         }
  170:     }
  171:     if (subtype == NULL) {
  172:         fprintf(stderr, "spice-qemu-char: unsupported name\n");
  173:         print_allowed_subtypes();
  174:         return NULL;
  175:     }
  176: 
  177:     chr = qemu_mallocz(sizeof(CharDriverState));
  178:     s = qemu_mallocz(sizeof(SpiceCharDriver));
  179:     s->chr = chr;
  180:     s->debug = debug;
  181:     s->active = false;
  182:     s->sin.subtype = subtype;
  183:     chr->opaque = s;
  184:     chr->chr_write = spice_chr_write;
  185:     chr->chr_close = spice_chr_close;
  186: 
  187:     qemu_chr_generic_open(chr);
  188: 
  189:     return chr;
  190: }

unix.superglobalmegacorp.com