xref: /illumos-kvm-cmd/spice-qemu-char.c (revision 68396ea9)
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 
vmc_write(SpiceCharDeviceInstance * sin,const uint8_t * buf,int len)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 
vmc_read(SpiceCharDeviceInstance * sin,uint8_t * buf,int len)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 
vmc_register_interface(SpiceCharDriver * scd)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 
vmc_unregister_interface(SpiceCharDriver * scd)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 
spice_chr_write(CharDriverState * chr,const uint8_t * buf,int len)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 
spice_chr_close(struct CharDriverState * chr)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 
print_allowed_subtypes(void)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 
qemu_chr_open_spice(QemuOpts * opts)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 }
191