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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
#include <mini-os/types.h>
#include <mini-os/wait.h>
#include <mini-os/mm.h>
#include <mini-os/hypervisor.h>
#include <mini-os/events.h>
#include <mini-os/os.h>
#include <mini-os/lib.h>
#include <mini-os/xenbus.h>
#include <xen/io/console.h>
#include <xen/io/protocols.h>
#include <xen/io/ring.h>
#include <mini-os/xmalloc.h>
#include <mini-os/gnttab.h>
#include "console.h"
DECLARE_WAIT_QUEUE_HEAD(console_queue);
static inline void notify_daemon(struct consfront_dev *dev)
{
/* Use evtchn: this is called early, before irq is set up. */
if (!dev)
notify_remote_via_evtchn(start_info.console.domU.evtchn);
else
notify_remote_via_evtchn(dev->evtchn);
}
static inline struct xencons_interface *xencons_interface(void)
{
if (start_info.console.domU.evtchn)
return mfn_to_virt(start_info.console.domU.mfn);
else
return NULL;
}
int xencons_ring_send_no_notify(struct consfront_dev *dev, const char *data, unsigned len)
{
int sent = 0;
struct xencons_interface *intf;
XENCONS_RING_IDX cons, prod;
if (!dev)
intf = xencons_interface();
else
intf = dev->ring;
if (!intf)
return sent;
cons = intf->out_cons;
prod = intf->out_prod;
mb();
BUG_ON((prod - cons) > sizeof(intf->out));
while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
wmb();
intf->out_prod = prod;
return sent;
}
int xencons_ring_send(struct consfront_dev *dev, const char *data, unsigned len)
{
int sent;
sent = xencons_ring_send_no_notify(dev, data, len);
notify_daemon(dev);
return sent;
}
void console_handle_input(evtchn_port_t port, struct pt_regs *regs, void *data)
{
struct consfront_dev *dev = (struct consfront_dev *) data;
#ifdef HAVE_LIBC
int fd = dev ? dev->fd : -1;
if (fd != -1)
files[fd].read = 1;
wake_up(&console_queue);
#else
struct xencons_interface *intf = xencons_interface();
XENCONS_RING_IDX cons, prod;
cons = intf->in_cons;
prod = intf->in_prod;
mb();
BUG_ON((prod - cons) > sizeof(intf->in));
while (cons != prod) {
xencons_rx(intf->in+MASK_XENCONS_IDX(cons,intf->in), 1, regs);
cons++;
}
mb();
intf->in_cons = cons;
notify_daemon(dev);
xencons_tx();
#endif
}
#ifdef HAVE_LIBC
int xencons_ring_avail(struct consfront_dev *dev)
{
struct xencons_interface *intf;
XENCONS_RING_IDX cons, prod;
if (!dev)
intf = xencons_interface();
else
intf = dev->ring;
cons = intf->in_cons;
prod = intf->in_prod;
mb();
BUG_ON((prod - cons) > sizeof(intf->in));
return prod - cons;
}
int xencons_ring_recv(struct consfront_dev *dev, char *data, unsigned len)
{
struct xencons_interface *intf;
XENCONS_RING_IDX cons, prod;
unsigned filled = 0;
if (!dev)
intf = xencons_interface();
else
intf = dev->ring;
cons = intf->in_cons;
prod = intf->in_prod;
mb();
BUG_ON((prod - cons) > sizeof(intf->in));
while (filled < len && cons + filled != prod) {
data[filled] = *(intf->in + MASK_XENCONS_IDX(cons + filled, intf->in));
filled++;
}
mb();
intf->in_cons = cons + filled;
notify_daemon(dev);
return filled;
}
#endif
struct consfront_dev *xencons_ring_init(void)
{
int err;
struct consfront_dev *dev;
if (!start_info.console.domU.evtchn)
return 0;
dev = malloc(sizeof(struct consfront_dev));
memset(dev, 0, sizeof(struct consfront_dev));
dev->nodename = "device/console";
dev->dom = 0;
dev->backend = 0;
dev->ring_ref = 0;
#ifdef HAVE_LIBC
dev->fd = -1;
#endif
dev->evtchn = start_info.console.domU.evtchn;
dev->ring = (struct xencons_interface *) mfn_to_virt(start_info.console.domU.mfn);
err = bind_evtchn(dev->evtchn, console_handle_input, dev);
if (err <= 0) {
printk("XEN console request chn bind failed %i\n", err);
free(dev);
return NULL;
}
unmask_evtchn(dev->evtchn);
/* In case we have in-flight data after save/restore... */
notify_daemon(dev);
return dev;
}
void xencons_resume(void)
{
(void)xencons_ring_init();
}
|
