blob: d17b1350d4a66094930c3723d935e10a05cac45f (
plain)
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
|
/*
* Virtio driver bits
*
* Copyright (c) 2013 Alexander Graf <agraf@suse.de>
*
* This work is licensed under the terms of the GNU GPL, version 2 or (at
* your option) any later version. See the COPYING file in the top-level
* directory.
*/
#ifndef VIRTIO_H
#define VIRTIO_H
#include "s390-ccw.h"
/* Status byte for guest to report progress, and synchronize features. */
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
/* We have found a driver for the device. */
#define VIRTIO_CONFIG_S_DRIVER 2
/* Driver has used its parts of the config, and is happy */
#define VIRTIO_CONFIG_S_DRIVER_OK 4
/* We've given up on this device. */
#define VIRTIO_CONFIG_S_FAILED 0x80
enum VirtioDevType {
VIRTIO_ID_NET = 1,
VIRTIO_ID_BLOCK = 2,
VIRTIO_ID_CONSOLE = 3,
VIRTIO_ID_BALLOON = 5,
};
typedef enum VirtioDevType VirtioDevType;
struct VirtioDevHeader {
VirtioDevType type:8;
uint8_t num_vq;
uint8_t feature_len;
uint8_t config_len;
uint8_t status;
uint8_t vqconfig[];
} __attribute__((packed));
typedef struct VirtioDevHeader VirtioDevHeader;
struct VirtioVqConfig {
uint64_t token;
uint64_t address;
uint16_t num;
uint8_t pad[6];
} __attribute__((packed));
typedef struct VirtioVqConfig VirtioVqConfig;
struct VqInfo {
uint64_t queue;
uint32_t align;
uint16_t index;
uint16_t num;
} __attribute__((packed));
typedef struct VqInfo VqInfo;
struct VqConfig {
uint16_t index;
uint16_t num;
} __attribute__((packed));
typedef struct VqConfig VqConfig;
struct VirtioDev {
VirtioDevHeader *header;
VirtioVqConfig *vqconfig;
char *host_features;
char *guest_features;
char *config;
};
typedef struct VirtioDev VirtioDev;
#define VIRTIO_RING_SIZE (PAGE_SIZE * 8)
#define VIRTIO_MAX_VQS 3
#define KVM_S390_VIRTIO_RING_ALIGN 4096
#define VRING_USED_F_NO_NOTIFY 1
/* This marks a buffer as continuing via the next field. */
#define VRING_DESC_F_NEXT 1
/* This marks a buffer as write-only (otherwise read-only). */
#define VRING_DESC_F_WRITE 2
/* This means the buffer contains a list of buffer descriptors. */
#define VRING_DESC_F_INDIRECT 4
/* Internal flag to mark follow-up segments as such */
#define VRING_HIDDEN_IS_CHAIN 256
/* Virtio ring descriptors: 16 bytes. These can chain together via "next". */
struct VRingDesc {
/* Address (guest-physical). */
uint64_t addr;
/* Length. */
uint32_t len;
/* The flags as indicated above. */
uint16_t flags;
/* We chain unused descriptors via this, too */
uint16_t next;
} __attribute__((packed));
typedef struct VRingDesc VRingDesc;
struct VRingAvail {
uint16_t flags;
uint16_t idx;
uint16_t ring[];
} __attribute__((packed));
typedef struct VRingAvail VRingAvail;
/* uint32_t is used here for ids for padding reasons. */
struct VRingUsedElem {
/* Index of start of used descriptor chain. */
uint32_t id;
/* Total length of the descriptor chain which was used (written to) */
uint32_t len;
} __attribute__((packed));
typedef struct VRingUsedElem VRingUsedElem;
struct VRingUsed {
uint16_t flags;
uint16_t idx;
VRingUsedElem ring[];
} __attribute__((packed));
typedef struct VRingUsed VRingUsed;
struct VRing {
unsigned int num;
int next_idx;
int used_idx;
VRingDesc *desc;
VRingAvail *avail;
VRingUsed *used;
SubChannelId schid;
long cookie;
int id;
};
typedef struct VRing VRing;
/***********************************************
* Virtio block *
***********************************************/
/*
* Command types
*
* Usage is a bit tricky as some bits are used as flags and some are not.
*
* Rules:
* VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
* VIRTIO_BLK_T_BARRIER. VIRTIO_BLK_T_FLUSH is a command of its own
* and may not be combined with any of the other flags.
*/
/* These two define direction. */
#define VIRTIO_BLK_T_IN 0
#define VIRTIO_BLK_T_OUT 1
/* This bit says it's a scsi command, not an actual read or write. */
#define VIRTIO_BLK_T_SCSI_CMD 2
/* Cache flush command */
#define VIRTIO_BLK_T_FLUSH 4
/* Barrier before this op. */
#define VIRTIO_BLK_T_BARRIER 0x80000000
/* This is the first element of the read scatter-gather list. */
struct VirtioBlkOuthdr {
/* VIRTIO_BLK_T* */
uint32_t type;
/* io priority. */
uint32_t ioprio;
/* Sector (ie. 512 byte offset) */
uint64_t sector;
};
typedef struct VirtioBlkOuthdr VirtioBlkOuthdr;
struct VirtioBlkConfig {
uint64_t capacity; /* in 512-byte sectors */
uint32_t size_max; /* max segment size (if VIRTIO_BLK_F_SIZE_MAX) */
uint32_t seg_max; /* max number of segments (if VIRTIO_BLK_F_SEG_MAX) */
struct VirtioBlkGeometry {
uint16_t cylinders;
uint8_t heads;
uint8_t sectors;
} geometry; /* (if VIRTIO_BLK_F_GEOMETRY) */
uint32_t blk_size; /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
/* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY */
uint8_t physical_block_exp; /* exponent for physical blk per logical blk */
uint8_t alignment_offset; /* alignment offset in logical blocks */
uint16_t min_io_size; /* min I/O size without performance penalty
in logical blocks */
uint32_t opt_io_size; /* optimal sustained I/O size in logical blks */
uint8_t wce; /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
} __attribute__((packed));
typedef struct VirtioBlkConfig VirtioBlkConfig;
bool virtio_guessed_disk_nature(void);
void virtio_assume_scsi(void);
void virtio_assume_eckd(void);
void virtio_assume_iso9660(void);
extern bool virtio_disk_is_scsi(void);
extern bool virtio_disk_is_eckd(void);
extern bool virtio_ipl_disk_is_valid(void);
extern int virtio_get_block_size(void);
extern uint8_t virtio_get_heads(void);
extern uint8_t virtio_get_sectors(void);
extern uint64_t virtio_get_blocks(void);
extern int virtio_read_many(ulong sector, void *load_addr, int sec_num);
#define VIRTIO_SECTOR_SIZE 512
static inline ulong virtio_sector_adjust(ulong sector)
{
return sector * (virtio_get_block_size() / VIRTIO_SECTOR_SIZE);
}
#endif /* VIRTIO_H */
|
