1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Virtio Console Device
*
* Copyright IBM, Corp. 2008
*
* Authors:
* Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2. See
* the COPYING file in the top-level directory.
*
*/
#include "hw.h"
#include "qemu-char.h"
#include "virtio.h"
#include "virtio-console.h"
typedef struct VirtIOConsole
{
VirtIODevice vdev;
VirtQueue *ivq, *dvq;
CharDriverState *chr;
} VirtIOConsole;
static VirtIOConsole *to_virtio_console(VirtIODevice *vdev)
{
return (VirtIOConsole *)vdev;
}
static void virtio_console_handle_output(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOConsole *s = to_virtio_console(vdev);
VirtQueueElement elem;
while (virtqueue_pop(vq, &elem)) {
ssize_t len = 0;
int d;
for (d = 0; d < elem.out_num; d++) {
len += qemu_chr_write(s->chr, (uint8_t *)elem.out_sg[d].iov_base,
elem.out_sg[d].iov_len);
}
virtqueue_push(vq, &elem, len);
virtio_notify(vdev, vq);
}
}
static void virtio_console_handle_input(VirtIODevice *vdev, VirtQueue *vq)
{
}
static uint32_t virtio_console_get_features(VirtIODevice *vdev)
{
return 0;
}
static int vcon_can_read(void *opaque)
{
VirtIOConsole *s = (VirtIOConsole *) opaque;
if (!virtio_queue_ready(s->ivq) ||
!(s->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK) ||
virtio_queue_empty(s->ivq))
return 0;
/* current implementations have a page sized buffer.
* We fall back to a one byte per read if there is not enough room.
* It would be cool to have a function that returns the available byte
* instead of checking for a limit */
if (virtqueue_avail_bytes(s->ivq, TARGET_PAGE_SIZE, 0))
return TARGET_PAGE_SIZE;
if (virtqueue_avail_bytes(s->ivq, 1, 0))
return 1;
return 0;
}
static void vcon_read(void *opaque, const uint8_t *buf, int size)
{
VirtIOConsole *s = (VirtIOConsole *) opaque;
VirtQueueElement elem;
int offset = 0;
/* The current kernel implementation has only one outstanding input
* buffer of PAGE_SIZE. Nevertheless, this function is prepared to
* handle multiple buffers with multiple sg element for input */
while (offset < size) {
int i = 0;
if (!virtqueue_pop(s->ivq, &elem))
break;
while (offset < size && i < elem.in_num) {
int len = MIN(elem.in_sg[i].iov_len, size - offset);
memcpy(elem.in_sg[i].iov_base, buf + offset, len);
offset += len;
i++;
}
virtqueue_push(s->ivq, &elem, size);
}
virtio_notify(&s->vdev, s->ivq);
}
static void vcon_event(void *opaque, int event)
{
/* we will ignore any event for the time being */
}
static void virtio_console_save(QEMUFile *f, void *opaque)
{
VirtIOConsole *s = opaque;
virtio_save(&s->vdev, f);
}
static int virtio_console_load(QEMUFile *f, void *opaque, int version_id)
{
VirtIOConsole *s = opaque;
if (version_id != 1)
return -EINVAL;
virtio_load(&s->vdev, f);
return 0;
}
void *virtio_console_init(PCIBus *bus, CharDriverState *chr)
{
VirtIOConsole *s;
PCIDevice *d;
d = pci_register_device(bus, "virtio-console", sizeof(VirtIOConsole),
-1, NULL, NULL);
if (!d)
return NULL;
s = (VirtIOConsole *)virtio_init_pci(d, "virtio-console",
PCI_VENDOR_ID_REDHAT_QUMRANET,
PCI_DEVICE_ID_VIRTIO_CONSOLE,
PCI_VENDOR_ID_REDHAT_QUMRANET,
VIRTIO_ID_CONSOLE,
PCI_CLASS_DISPLAY_OTHER, 0x00,
0);
if (s == NULL)
return NULL;
s->vdev.get_features = virtio_console_get_features;
s->ivq = virtio_add_queue(&s->vdev, 128, virtio_console_handle_input);
s->dvq = virtio_add_queue(&s->vdev, 128, virtio_console_handle_output);
s->chr = chr;
qemu_chr_add_handlers(chr, vcon_can_read, vcon_read, vcon_event, s);
register_savevm("virtio-console", -1, 1, virtio_console_save, virtio_console_load, s);
return &s->vdev;
}
|
