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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
|
/*
* Copyright (c) 2020 Nutanix Inc. All rights reserved.
*
* Derived from Intel's vfio-user.h:
* Copyright (c) 2020 Intel Corporation. All rights reserved.
*
* Authors: Changpeng Liu <changpeng.liu@intel.com>
* Thanos Makatos <thanos@nutanix.com>
* Swapnil Ingle <swapnil.ingle@nutanix.com>
* John Levon <john.levon@nutanix.com>
*
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Nutanix nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*
*/
#ifndef VFIO_USER_H
#define VFIO_USER_H
/*
* Shared definitions for the vfio-user protocol.
*/
#include <inttypes.h>
#include <linux/vfio.h>
#include <linux/version.h>
#ifdef __cplusplus
extern "C" {
#endif
#define VFIO_USER_DEFAULT_MAX_DATA_XFER_SIZE (1024 * 1024)
enum vfio_user_command {
VFIO_USER_VERSION = 1,
VFIO_USER_DMA_MAP = 2,
VFIO_USER_DMA_UNMAP = 3,
VFIO_USER_DEVICE_GET_INFO = 4,
VFIO_USER_DEVICE_GET_REGION_INFO = 5,
VFIO_USER_DEVICE_GET_REGION_IO_FDS = 6,
VFIO_USER_DEVICE_GET_IRQ_INFO = 7,
VFIO_USER_DEVICE_SET_IRQS = 8,
VFIO_USER_REGION_READ = 9,
VFIO_USER_REGION_WRITE = 10,
VFIO_USER_DMA_READ = 11,
VFIO_USER_DMA_WRITE = 12,
VFIO_USER_DEVICE_RESET = 13,
VFIO_USER_DIRTY_PAGES = 14, // TODO remove
VFIO_USER_REGION_WRITE_MULTI = 15, // TODO implement
VFIO_USER_DEVICE_FEATURE = 16,
VFIO_USER_MIG_DATA_READ = 17,
VFIO_USER_MIG_DATA_WRITE = 18,
VFIO_USER_MAX,
};
enum vfio_user_message_type {
VFIO_USER_MESSAGE_COMMAND = 0,
VFIO_USER_MESSAGE_REPLY = 1,
};
#define VFIO_USER_FLAGS_NO_REPLY (0x1)
struct vfio_user_header {
uint16_t msg_id;
uint16_t cmd;
uint32_t msg_size;
struct {
uint32_t type : 4;
#define VFIO_USER_F_TYPE_COMMAND 0
#define VFIO_USER_F_TYPE_REPLY 1
uint32_t no_reply : 1;
uint32_t error : 1;
uint32_t resvd : 26;
} flags;
uint32_t error_no;
} __attribute__((packed));
struct vfio_user_version {
uint16_t major;
uint16_t minor;
uint8_t data[];
} __attribute__((packed));
/*
* Similar to vfio_device_info, but without caps (yet).
*/
struct vfio_user_device_info {
uint32_t argsz;
/* VFIO_DEVICE_FLAGS_* */
uint32_t flags;
uint32_t num_regions;
uint32_t num_irqs;
} __attribute__((packed));
/* based on struct vfio_bitmap */
struct vfio_user_bitmap {
uint64_t pgsize;
uint64_t size;
char data[];
} __attribute__((packed));
/* based on struct vfio_iommu_type1_dma_map */
struct vfio_user_dma_map {
uint32_t argsz;
#define VFIO_USER_F_DMA_REGION_READ (1 << 0)
#define VFIO_USER_F_DMA_REGION_WRITE (1 << 1)
uint32_t flags;
uint64_t offset;
uint64_t addr;
uint64_t size;
} __attribute__((packed));
/* based on struct vfio_iommu_type1_dma_unmap */
struct vfio_user_dma_unmap {
uint32_t argsz;
#ifndef VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP
#define VFIO_DMA_UNMAP_FLAG_GET_DIRTY_BITMAP (1 << 0)
#endif
#ifndef VFIO_DMA_UNMAP_FLAG_ALL
#define VFIO_DMA_UNMAP_FLAG_ALL (1 << 1)
#endif
uint32_t flags;
uint64_t addr;
uint64_t size;
struct vfio_user_bitmap bitmap[];
};
struct vfio_user_region_access {
uint64_t offset;
uint32_t region;
uint32_t count;
uint8_t data[];
} __attribute__((packed));
struct vfio_user_dma_region_access {
uint64_t addr;
uint64_t count;
uint8_t data[];
} __attribute__((packed));
struct vfio_user_irq_info {
uint32_t subindex;
} __attribute__((packed));
typedef struct vfio_user_region_io_fds_request {
uint32_t argsz;
uint32_t flags;
uint32_t index;
uint32_t count;
} __attribute__((packed)) vfio_user_region_io_fds_request_t;
#define VFIO_USER_IO_FD_TYPE_IOEVENTFD 0
#define VFIO_USER_IO_FD_TYPE_IOREGIONFD 1
#define VFIO_USER_IO_FD_TYPE_IOEVENTFD_SHADOW 2
typedef struct vfio_user_sub_region_ioeventfd {
uint64_t gpa_offset;
uint64_t size;
uint32_t fd_index;
uint32_t type;
uint32_t flags;
uint32_t shadow_mem_fd_index;
uint64_t shadow_offset;
uint64_t datamatch;
} __attribute__((packed)) vfio_user_sub_region_ioeventfd_t;
typedef struct vfio_user_sub_region_ioregionfd {
uint64_t offset;
uint64_t size;
uint32_t fd_index;
uint32_t type;
uint32_t flags;
uint32_t padding;
uint64_t user_data;
} __attribute__((packed)) vfio_user_sub_region_ioregionfd_t;
typedef struct vfio_user_region_io_fds_reply {
uint32_t argsz;
uint32_t flags;
uint32_t index;
uint32_t count;
union sub_region {
struct vfio_user_sub_region_ioeventfd ioeventfd;
struct vfio_user_sub_region_ioregionfd ioregionfd;
} sub_regions[];
} __attribute__((packed)) vfio_user_region_io_fds_reply_t;
struct vfio_user_device_feature_dma_logging_range {
uint64_t iova;
uint64_t length;
} __attribute__((packed));
struct vfio_user_device_feature_dma_logging_control {
uint64_t page_size;
uint32_t num_ranges;
uint32_t reserved;
struct vfio_user_device_feature_dma_logging_range ranges[];
} __attribute__((packed));
struct vfio_user_device_feature_dma_logging_report {
uint64_t iova;
uint64_t length;
uint64_t page_size;
uint8_t bitmap[];
} __attribute__((packed));
#ifndef VFIO_DEVICE_FEATURE_DMA_LOGGING_START
#define VFIO_DEVICE_FEATURE_DMA_LOGGING_START 6
#define VFIO_DEVICE_FEATURE_DMA_LOGGING_STOP 7
#define VFIO_DEVICE_FEATURE_DMA_LOGGING_REPORT 8
#endif
/* Analogous to vfio_device_feature */
struct vfio_user_device_feature {
uint32_t argsz;
uint32_t flags;
#ifndef VFIO_REGION_TYPE_MIGRATION_DEPRECATED
#define VFIO_DEVICE_FEATURE_MASK (0xffff) /* 16-bit feature index */
#define VFIO_DEVICE_FEATURE_GET (1 << 16) /* Get feature into data[] */
#define VFIO_DEVICE_FEATURE_SET (1 << 17) /* Set feature from data[] */
#define VFIO_DEVICE_FEATURE_PROBE (1 << 18) /* Probe feature support */
#endif
uint8_t data[];
} __attribute__((packed));
/* Analogous to vfio_device_feature_migration */
struct vfio_user_device_feature_migration {
uint64_t flags;
#ifndef VFIO_REGION_TYPE_MIGRATION_DEPRECATED
#define VFIO_MIGRATION_STOP_COPY (1 << 0)
#define VFIO_MIGRATION_P2P (1 << 1)
#endif
#ifndef VFIO_MIGRATION_PRE_COPY
#define VFIO_MIGRATION_PRE_COPY (1 << 2)
#endif
} __attribute__((packed));
#ifndef VFIO_REGION_TYPE_MIGRATION_DEPRECATED
#define VFIO_DEVICE_FEATURE_MIGRATION 1
#endif
_Static_assert(sizeof(struct vfio_user_device_feature_migration) == 8,
"bad vfio_user_device_feature_migration size");
/* Analogous to vfio_device_feature_mig_state */
struct vfio_user_device_feature_mig_state {
uint32_t device_state;
uint32_t data_fd;
} __attribute__((packed));
#ifndef VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE
#define VFIO_DEVICE_FEATURE_MIG_DEVICE_STATE 2
#endif
_Static_assert(sizeof(struct vfio_user_device_feature_migration) == 8,
"bad vfio_user_device_feature_mig_state size");
/* Analogous to vfio_device_mig_state */
enum vfio_user_device_mig_state {
VFIO_USER_DEVICE_STATE_ERROR = 0,
VFIO_USER_DEVICE_STATE_STOP = 1,
VFIO_USER_DEVICE_STATE_RUNNING = 2,
VFIO_USER_DEVICE_STATE_STOP_COPY = 3,
VFIO_USER_DEVICE_STATE_RESUMING = 4,
VFIO_USER_DEVICE_STATE_RUNNING_P2P = 5,
VFIO_USER_DEVICE_STATE_PRE_COPY = 6,
VFIO_USER_DEVICE_STATE_PRE_COPY_P2P = 7,
};
#define VFIO_USER_DEVICE_NUM_STATES 8
struct vfio_user_mig_data {
uint32_t argsz;
uint32_t size;
uint8_t data[];
} __attribute__((packed));
#ifdef __cplusplus
}
#endif
#endif /* VFIO_USER_H */
/* ex: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: */
|