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
|
/* tapdisk.h
*
* Generic disk interface for blktap-based image adapters.
*
* (c) 2006 Andrew Warfield and Julian Chesterfield
*
* Some notes on the tap_disk interface:
*
* tap_disk aims to provide a generic interface to easily implement new
* types of image accessors. The structure-of-function-calls is similar
* to disk interfaces used in qemu/denali/etc, with the significant
* difference being the expectation of asynchronous rather than synchronous
* I/O. The asynchronous interface is intended to allow lots of requests to
* be pipelined through a disk, without the disk requiring any of its own
* threads of control. As such, a batch of requests is delivered to the disk
* using:
*
* td_queue_[read,write]()
*
* and passing in a completion callback, which the disk is responsible for
* tracking. The end of a back is marked with a call to:
*
* td_submit()
*
* The disk implementation must provide a file handle, which is used to
* indicate that it needs to do work. tapdisk will add this file handle
* (returned from td_get_fd()) to it's poll set, and will call into the disk
* using td_do_callbacks() whenever there is data pending.
*
* Two disk implementations demonstrate how this interface may be used to
* implement disks with both asynchronous and synchronous calls. block-aio.c
* maps this interface down onto the linux libaio calls, while block-sync uses
* normal posix read/write.
*
* A few things to realize about the sync case, which doesn't need to defer
* io completions:
*
* - td_queue_[read,write]() call read/write directly, and then call the
* callback immediately. The MUST then return a value greater than 0
* in order to tell tapdisk that requests have finished early, and to
* force responses to be kicked to the clents.
*
* - The fd used for poll is an otherwise unused pipe, which allows poll to
* be safely called without ever returning anything.
*
* NOTE: tapdisk uses the number of sectors submitted per request as a
* ref count. Plugins must use the callback function to communicate the
* completion--or error--of every sector submitted to them.
*
* td_get_parent_id returns:
* 0 if parent id successfully retrieved
* TD_NO_PARENT if no parent exists
* -errno on error
*/
#ifndef TAPDISK_H_
#define TAPDISK_H_
#include <stdint.h>
#include <syslog.h>
#include <stdio.h>
#include "blktaplib.h"
/*If enabled, log all debug messages to syslog*/
#if 1
#define DPRINTF(_f, _a...) syslog( LOG_DEBUG, __FILE__ ":%d: " _f , __LINE__, ## _a )
#else
#define DPRINTF(_f, _a...) ((void)0)
#endif
/* Things disks need to know about, these should probably be in a higher-level
* header. */
#define MAX_SEGMENTS_PER_REQ 11
#define SECTOR_SHIFT 9
#define DEFAULT_SECTOR_SIZE 512
#define MAX_IOFD 2
#define BLK_NOT_ALLOCATED 99
#define TD_NO_PARENT 1
typedef uint32_t td_flag_t;
#define TD_RDONLY 1
struct td_state;
struct tap_disk;
struct disk_id {
char *name;
int drivertype;
};
struct disk_driver {
int early;
char *name;
void *private;
td_flag_t flags;
int io_fd[MAX_IOFD];
struct tap_disk *drv;
struct td_state *td_state;
struct disk_driver *next;
};
/* This structure represents the state of an active virtual disk. */
struct td_state {
struct disk_driver *disks;
void *blkif;
void *image;
void *ring_info;
void *fd_entry;
uint64_t sector_size;
uint64_t size;
unsigned int info;
};
/* Prototype of the callback to activate as requests complete. */
typedef int (*td_callback_t)(struct disk_driver *dd, int res, uint64_t sector,
int nb_sectors, int id, void *private);
/* Structure describing the interface to a virtual disk implementation. */
/* See note at the top of this file describing this interface. */
struct tap_disk {
const char *disk_type;
int private_data_size;
int (*td_open) (struct disk_driver *dd,
const char *name, td_flag_t flags);
int (*td_queue_read) (struct disk_driver *dd, uint64_t sector,
int nb_sectors, char *buf, td_callback_t cb,
int id, void *prv);
int (*td_queue_write) (struct disk_driver *dd, uint64_t sector,
int nb_sectors, char *buf, td_callback_t cb,
int id, void *prv);
int (*td_submit) (struct disk_driver *dd);
int (*td_close) (struct disk_driver *dd);
int (*td_do_callbacks) (struct disk_driver *dd, int sid);
int (*td_get_parent_id) (struct disk_driver *dd, struct disk_id *id);
int (*td_validate_parent)(struct disk_driver *dd,
struct disk_driver *p, td_flag_t flags);
};
typedef struct disk_info {
int idnum;
char name[50]; /* e.g. "RAMDISK" */
char handle[10]; /* xend handle, e.g. 'ram' */
int single_handler; /* is there a single controller for all */
/* instances of disk type? */
int use_ioemu; /* backend provider: 0 = tapdisk; 1 = ioemu */
#ifdef TAPDISK
struct tap_disk *drv;
#endif
} disk_info_t;
void debug_fe_ring(struct td_state *s);
extern struct tap_disk tapdisk_aio;
extern struct tap_disk tapdisk_sync;
extern struct tap_disk tapdisk_vmdk;
extern struct tap_disk tapdisk_ram;
extern struct tap_disk tapdisk_qcow;
extern struct tap_disk tapdisk_qcow2;
#define MAX_DISK_TYPES 20
#define DISK_TYPE_AIO 0
#define DISK_TYPE_SYNC 1
#define DISK_TYPE_VMDK 2
#define DISK_TYPE_RAM 3
#define DISK_TYPE_QCOW 4
#define DISK_TYPE_QCOW2 5
/*Define Individual Disk Parameters here */
static disk_info_t aio_disk = {
DISK_TYPE_AIO,
"raw image (aio)",
"aio",
0,
0,
#ifdef TAPDISK
&tapdisk_aio,
#endif
};
static disk_info_t sync_disk = {
DISK_TYPE_SYNC,
"raw image (sync)",
"sync",
0,
0,
#ifdef TAPDISK
&tapdisk_sync,
#endif
};
static disk_info_t vmdk_disk = {
DISK_TYPE_VMDK,
"vmware image (vmdk)",
"vmdk",
1,
0,
#ifdef TAPDISK
&tapdisk_vmdk,
#endif
};
static disk_info_t ram_disk = {
DISK_TYPE_RAM,
"ramdisk image (ram)",
"ram",
1,
0,
#ifdef TAPDISK
&tapdisk_ram,
#endif
};
static disk_info_t qcow_disk = {
DISK_TYPE_QCOW,
"qcow disk (qcow)",
"qcow",
0,
0,
#ifdef TAPDISK
&tapdisk_qcow,
#endif
};
static disk_info_t qcow2_disk = {
DISK_TYPE_QCOW2,
"qcow2 disk (qcow2)",
"qcow2",
0,
0,
#ifdef TAPDISK
&tapdisk_qcow2,
#endif
};
/*Main disk info array */
static disk_info_t *dtypes[] = {
&aio_disk,
&sync_disk,
&vmdk_disk,
&ram_disk,
&qcow_disk,
&qcow2_disk,
};
typedef struct driver_list_entry {
struct blkif *blkif;
struct driver_list_entry **pprev, *next;
} driver_list_entry_t;
typedef struct fd_list_entry {
int cookie;
int tap_fd;
struct td_state *s;
struct fd_list_entry **pprev, *next;
} fd_list_entry_t;
int qcow_create(const char *filename, uint64_t total_size,
const char *backing_file, int flags);
int qcow2_create(const char *filename, uint64_t total_size,
const char *backing_file, int flags);
#endif /*TAPDISK_H_*/
|
