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
|
/*
* Copyright (c) 2019 Arm ltd.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along with
* this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include <xen/dm.h>
#include <xen/guest_access.h>
#include <xen/hypercall.h>
#include <xen/ioreq.h>
#include <xen/nospec.h>
#include <asm/vgic.h>
int dm_op(const struct dmop_args *op_args)
{
struct domain *d;
struct xen_dm_op op;
bool const_op = true;
long rc;
size_t offset;
static const uint8_t op_size[] = {
[XEN_DMOP_create_ioreq_server] = sizeof(struct xen_dm_op_create_ioreq_server),
[XEN_DMOP_get_ioreq_server_info] = sizeof(struct xen_dm_op_get_ioreq_server_info),
[XEN_DMOP_map_io_range_to_ioreq_server] = sizeof(struct xen_dm_op_ioreq_server_range),
[XEN_DMOP_unmap_io_range_from_ioreq_server] = sizeof(struct xen_dm_op_ioreq_server_range),
[XEN_DMOP_set_ioreq_server_state] = sizeof(struct xen_dm_op_set_ioreq_server_state),
[XEN_DMOP_destroy_ioreq_server] = sizeof(struct xen_dm_op_destroy_ioreq_server),
[XEN_DMOP_set_irq_level] = sizeof(struct xen_dm_op_set_irq_level),
[XEN_DMOP_nr_vcpus] = sizeof(struct xen_dm_op_nr_vcpus),
};
rc = rcu_lock_remote_domain_by_id(op_args->domid, &d);
if ( rc )
return rc;
rc = xsm_dm_op(XSM_DM_PRIV, d);
if ( rc )
goto out;
offset = offsetof(struct xen_dm_op, u);
rc = -EFAULT;
if ( op_args->buf[0].size < offset )
goto out;
if ( copy_from_guest_offset((void *)&op, op_args->buf[0].h, 0, offset) )
goto out;
if ( op.op >= ARRAY_SIZE(op_size) )
{
rc = -EOPNOTSUPP;
goto out;
}
op.op = array_index_nospec(op.op, ARRAY_SIZE(op_size));
if ( op_args->buf[0].size < offset + op_size[op.op] )
goto out;
if ( copy_from_guest_offset((void *)&op.u, op_args->buf[0].h, offset,
op_size[op.op]) )
goto out;
rc = -EINVAL;
if ( op.pad )
goto out;
switch ( op.op )
{
case XEN_DMOP_set_irq_level:
{
const struct xen_dm_op_set_irq_level *data =
&op.u.set_irq_level;
unsigned int i;
/* Only SPIs are supported */
if ( (data->irq < NR_LOCAL_IRQS) || (data->irq >= vgic_num_irqs(d)) )
{
rc = -EINVAL;
break;
}
if ( data->level != 0 && data->level != 1 )
{
rc = -EINVAL;
break;
}
/* Check that padding is always 0 */
for ( i = 0; i < sizeof(data->pad); i++ )
{
if ( data->pad[i] )
{
rc = -EINVAL;
break;
}
}
/*
* Allow to set the logical level of a line for non-allocated
* interrupts only.
*/
if ( test_bit(data->irq, d->arch.vgic.allocated_irqs) )
{
rc = -EINVAL;
break;
}
vgic_inject_irq(d, NULL, data->irq, data->level);
rc = 0;
break;
}
case XEN_DMOP_nr_vcpus:
{
struct xen_dm_op_nr_vcpus *data = &op.u.nr_vcpus;
data->vcpus = d->max_vcpus;
const_op = false;
rc = 0;
break;
}
default:
rc = ioreq_server_dm_op(&op, d, &const_op);
break;
}
if ( (!rc || rc == -ERESTART) &&
!const_op && copy_to_guest_offset(op_args->buf[0].h, offset,
(void *)&op.u, op_size[op.op]) )
rc = -EFAULT;
out:
rcu_unlock_domain(d);
return rc;
}
/*
* Local variables:
* mode: C
* c-file-style: "BSD"
* c-basic-offset: 4
* tab-width: 4
* indent-tabs-mode: nil
* End:
*/
|
