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
|
/* -*- Mode:C; c-basic-offset:4; tab-width:4 -*-
****************************************************************************
* (C) 2003 - Rolf Neugebauer - Intel Research Cambridge
* (C) 2005 - Grzegorz Milos - Intel Research Cambridge
****************************************************************************
*
* File: events.c
* Author: Rolf Neugebauer (neugebar@dcs.gla.ac.uk)
* Changes: Grzegorz Milos (gm281@cam.ac.uk)
*
* Date: Jul 2003, changes Jun 2005
*
* Environment: Xen Minimal OS
* Description: Deals with events recieved on event channels
*
****************************************************************************
*/
#include <os.h>
#include <mm.h>
#include <hypervisor.h>
#include <events.h>
#include <lib.h>
#define NR_EVS 1024
/* this represents a event handler. Chaining or sharing is not allowed */
typedef struct _ev_action_t {
evtchn_handler_t handler;
void *data;
u32 count;
} ev_action_t;
static ev_action_t ev_actions[NR_EVS];
void default_handler(evtchn_port_t port, struct pt_regs *regs, void *data);
static unsigned long bound_ports[NR_EVS/(8*sizeof(unsigned long))];
void unbind_all_ports(void)
{
int i;
for (i = 0; i < NR_EVS; i++)
{
if (test_and_clear_bit(i, bound_ports))
{
struct evtchn_close close;
mask_evtchn(i);
close.port = i;
HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
}
}
}
/*
* Demux events to different handlers.
*/
int do_event(evtchn_port_t port, struct pt_regs *regs)
{
ev_action_t *action;
if (port >= NR_EVS) {
printk("Port number too large: %d\n", port);
goto out;
}
action = &ev_actions[port];
action->count++;
/* call the handler */
action->handler(port, regs, action->data);
out:
clear_evtchn(port);
return 1;
}
evtchn_port_t bind_evtchn(evtchn_port_t port, evtchn_handler_t handler,
void *data)
{
if(ev_actions[port].handler != default_handler)
printk("WARN: Handler for port %d already registered, replacing\n",
port);
ev_actions[port].data = data;
wmb();
ev_actions[port].handler = handler;
return port;
}
void unbind_evtchn(evtchn_port_t port )
{
if (ev_actions[port].handler == default_handler)
printk("WARN: No handler for port %d when unbinding\n", port);
ev_actions[port].handler = default_handler;
wmb();
ev_actions[port].data = NULL;
}
evtchn_port_t bind_virq(uint32_t virq, evtchn_handler_t handler, void *data)
{
evtchn_bind_virq_t op;
/* Try to bind the virq to a port */
op.virq = virq;
op.vcpu = smp_processor_id();
if ( HYPERVISOR_event_channel_op(EVTCHNOP_bind_virq, &op) != 0 )
{
printk("Failed to bind virtual IRQ %d\n", virq);
return -1;
}
set_bit(op.port,bound_ports);
bind_evtchn(op.port, handler, data);
return op.port;
}
#if defined(__x86_64__)
char irqstack[2 * STACK_SIZE];
static struct pda
{
int irqcount; /* offset 0 (used in x86_64.S) */
char *irqstackptr; /* 8 */
} cpu0_pda;
#endif
/*
* Initially all events are without a handler and disabled
*/
void init_events(void)
{
int i;
#if defined(__x86_64__)
asm volatile("movl %0,%%fs ; movl %0,%%gs" :: "r" (0));
wrmsrl(0xc0000101, &cpu0_pda); /* 0xc0000101 is MSR_GS_BASE */
cpu0_pda.irqcount = -1;
cpu0_pda.irqstackptr = (void*) (((unsigned long)irqstack + 2 * STACK_SIZE) & ~(STACK_SIZE - 1));
#endif
/* initialize event handler */
for ( i = 0; i < NR_EVS; i++ )
{
ev_actions[i].handler = default_handler;
mask_evtchn(i);
}
}
void default_handler(evtchn_port_t port, struct pt_regs *regs, void *ignore)
{
printk("[Port %d] - event received\n", port);
}
/* Create a port available to the pal for exchanging notifications.
Returns the result of the hypervisor call. */
/* Unfortunate confusion of terminology: the port is unbound as far
as Xen is concerned, but we automatically bind a handler to it
from inside mini-os. */
int evtchn_alloc_unbound(domid_t pal, evtchn_handler_t handler,
void *data, evtchn_port_t *port)
{
evtchn_alloc_unbound_t op;
op.dom = DOMID_SELF;
op.remote_dom = pal;
int err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, &op);
if (err)
return err;
*port = bind_evtchn(op.port, handler, data);
return err;
}
/* Connect to a port so as to allow the exchange of notifications with
the pal. Returns the result of the hypervisor call. */
int evtchn_bind_interdomain(domid_t pal, evtchn_port_t remote_port,
evtchn_handler_t handler, void *data,
evtchn_port_t *local_port)
{
evtchn_bind_interdomain_t op;
op.remote_dom = pal;
op.remote_port = remote_port;
int err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain, &op);
if (err)
return err;
set_bit(op.local_port,bound_ports);
evtchn_port_t port = op.local_port;
*local_port = bind_evtchn(port, handler, data);
return err;
}
|
