2 * This program is free software; you can redistribute it and/or
3 * modify it under the terms of the GNU General Public License version 2
4 * as published by the Free Software Foundation; or, when distributed
5 * separately from the Linux kernel or incorporated into other
6 * software packages, subject to the following license:
8 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this source file (the "Software"), to deal in the Software without
10 * restriction, including without limitation the rights to use, copy, modify,
11 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
12 * and to permit persons to whom the Software is furnished to do so, subject to
13 * the following conditions:
15 * The above copyright notice and this permission notice shall be included in
16 * all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
23 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
27 #ifndef __XEN_BLKIF__BACKEND__COMMON_H__
28 #define __XEN_BLKIF__BACKEND__COMMON_H__
30 #include <linux/module.h>
31 #include <linux/interrupt.h>
32 #include <linux/slab.h>
33 #include <linux/blkdev.h>
34 #include <linux/vmalloc.h>
35 #include <linux/wait.h>
37 #include <linux/rbtree.h>
38 #include <asm/setup.h>
39 #include <asm/pgalloc.h>
40 #include <asm/hypervisor.h>
41 #include <xen/grant_table.h>
42 #include <xen/xenbus.h>
43 #include <xen/interface/io/ring.h>
44 #include <xen/interface/io/blkif.h>
45 #include <xen/interface/io/protocols.h>
47 #define DRV_PFX "xen-blkback:"
48 #define DPRINTK(fmt, args...) \
49 pr_debug(DRV_PFX "(%s:%d) " fmt ".\n", \
50 __func__, __LINE__, ##args)
53 /* Not a real protocol. Used to generate ring structs which contain
54 * the elements common to all protocols only. This way we get a
55 * compiler-checkable way to use common struct elements, so we can
56 * avoid using switch(protocol) in a number of places. */
57 struct blkif_common_request
{
60 struct blkif_common_response
{
64 struct blkif_x86_32_request_rw
{
65 uint8_t nr_segments
; /* number of segments */
66 blkif_vdev_t handle
; /* only for read/write requests */
67 uint64_t id
; /* private guest value, echoed in resp */
68 blkif_sector_t sector_number
;/* start sector idx on disk (r/w only) */
69 struct blkif_request_segment seg
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
70 } __attribute__((__packed__
));
72 struct blkif_x86_32_request_discard
{
73 uint8_t flag
; /* BLKIF_DISCARD_SECURE or zero */
74 blkif_vdev_t _pad1
; /* was "handle" for read/write requests */
75 uint64_t id
; /* private guest value, echoed in resp */
76 blkif_sector_t sector_number
;/* start sector idx on disk (r/w only) */
78 } __attribute__((__packed__
));
80 struct blkif_x86_32_request_other
{
83 uint64_t id
; /* private guest value, echoed in resp */
84 } __attribute__((__packed__
));
86 struct blkif_x86_32_request
{
87 uint8_t operation
; /* BLKIF_OP_??? */
89 struct blkif_x86_32_request_rw rw
;
90 struct blkif_x86_32_request_discard discard
;
91 struct blkif_x86_32_request_other other
;
93 } __attribute__((__packed__
));
95 /* i386 protocol version */
97 struct blkif_x86_32_response
{
98 uint64_t id
; /* copied from request */
99 uint8_t operation
; /* copied from request */
100 int16_t status
; /* BLKIF_RSP_??? */
103 /* x86_64 protocol version */
105 struct blkif_x86_64_request_rw
{
106 uint8_t nr_segments
; /* number of segments */
107 blkif_vdev_t handle
; /* only for read/write requests */
108 uint32_t _pad1
; /* offsetof(blkif_reqest..,u.rw.id)==8 */
110 blkif_sector_t sector_number
;/* start sector idx on disk (r/w only) */
111 struct blkif_request_segment seg
[BLKIF_MAX_SEGMENTS_PER_REQUEST
];
112 } __attribute__((__packed__
));
114 struct blkif_x86_64_request_discard
{
115 uint8_t flag
; /* BLKIF_DISCARD_SECURE or zero */
116 blkif_vdev_t _pad1
; /* was "handle" for read/write requests */
117 uint32_t _pad2
; /* offsetof(blkif_..,u.discard.id)==8 */
119 blkif_sector_t sector_number
;/* start sector idx on disk (r/w only) */
121 } __attribute__((__packed__
));
123 struct blkif_x86_64_request_other
{
126 uint32_t _pad3
; /* offsetof(blkif_..,u.discard.id)==8 */
127 uint64_t id
; /* private guest value, echoed in resp */
128 } __attribute__((__packed__
));
130 struct blkif_x86_64_request
{
131 uint8_t operation
; /* BLKIF_OP_??? */
133 struct blkif_x86_64_request_rw rw
;
134 struct blkif_x86_64_request_discard discard
;
135 struct blkif_x86_64_request_other other
;
137 } __attribute__((__packed__
));
139 struct blkif_x86_64_response
{
140 uint64_t __attribute__((__aligned__(8))) id
;
141 uint8_t operation
; /* copied from request */
142 int16_t status
; /* BLKIF_RSP_??? */
145 DEFINE_RING_TYPES(blkif_common
, struct blkif_common_request
,
146 struct blkif_common_response
);
147 DEFINE_RING_TYPES(blkif_x86_32
, struct blkif_x86_32_request
,
148 struct blkif_x86_32_response
);
149 DEFINE_RING_TYPES(blkif_x86_64
, struct blkif_x86_64_request
,
150 struct blkif_x86_64_response
);
152 union blkif_back_rings
{
153 struct blkif_back_ring native
;
154 struct blkif_common_back_ring common
;
155 struct blkif_x86_32_back_ring x86_32
;
156 struct blkif_x86_64_back_ring x86_64
;
159 enum blkif_protocol
{
160 BLKIF_PROTOCOL_NATIVE
= 1,
161 BLKIF_PROTOCOL_X86_32
= 2,
162 BLKIF_PROTOCOL_X86_64
= 3,
166 /* What the domain refers to this vbd as. */
168 /* Non-zero -> read-only */
169 unsigned char readonly
;
172 /* phys device that this vbd maps to. */
174 struct block_device
*bdev
;
175 /* Cached size parameter. */
177 unsigned int flush_support
:1;
178 unsigned int discard_secure
:1;
179 unsigned int feature_gnt_persistent
:1;
180 unsigned int overflow_max_grants
:1;
186 struct persistent_gnt
{
189 grant_handle_t handle
;
194 /* Unique identifier for this interface. */
197 /* Physical parameters of the comms window. */
199 /* Comms information. */
200 enum blkif_protocol blk_protocol
;
201 union blkif_back_rings blk_rings
;
203 /* The VBD attached to this interface. */
205 /* Back pointer to the backend_info. */
206 struct backend_info
*be
;
207 /* Private fields. */
208 spinlock_t blk_ring_lock
;
211 wait_queue_head_t wq
;
212 /* for barrier (drain) requests */
213 struct completion drain_complete
;
215 /* One thread per one blkif. */
216 struct task_struct
*xenblkd
;
217 unsigned int waiting_reqs
;
219 /* tree to store persistent grants */
220 struct rb_root persistent_gnts
;
221 unsigned int persistent_gnt_c
;
224 unsigned long st_print
;
225 unsigned long long st_rd_req
;
226 unsigned long long st_wr_req
;
227 unsigned long long st_oo_req
;
228 unsigned long long st_f_req
;
229 unsigned long long st_ds_req
;
230 unsigned long long st_rd_sect
;
231 unsigned long long st_wr_sect
;
233 wait_queue_head_t waiting_to_free
;
237 #define vbd_sz(_v) ((_v)->bdev->bd_part ? \
238 (_v)->bdev->bd_part->nr_sects : \
239 get_capacity((_v)->bdev->bd_disk))
241 #define xen_blkif_get(_b) (atomic_inc(&(_b)->refcnt))
242 #define xen_blkif_put(_b) \
244 if (atomic_dec_and_test(&(_b)->refcnt)) \
245 wake_up(&(_b)->waiting_to_free);\
250 blkif_sector_t nr_sects
;
251 struct block_device
*bdev
;
252 blkif_sector_t sector_number
;
254 int xen_blkif_interface_init(void);
256 int xen_blkif_xenbus_init(void);
258 irqreturn_t
xen_blkif_be_int(int irq
, void *dev_id
);
259 int xen_blkif_schedule(void *arg
);
261 int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt
,
262 struct backend_info
*be
, int state
);
264 int xen_blkbk_barrier(struct xenbus_transaction xbt
,
265 struct backend_info
*be
, int state
);
266 struct xenbus_device
*xen_blkbk_xenbus(struct backend_info
*be
);
268 static inline void blkif_get_x86_32_req(struct blkif_request
*dst
,
269 struct blkif_x86_32_request
*src
)
271 int i
, n
= BLKIF_MAX_SEGMENTS_PER_REQUEST
;
272 dst
->operation
= src
->operation
;
273 switch (src
->operation
) {
276 case BLKIF_OP_WRITE_BARRIER
:
277 case BLKIF_OP_FLUSH_DISKCACHE
:
278 dst
->u
.rw
.nr_segments
= src
->u
.rw
.nr_segments
;
279 dst
->u
.rw
.handle
= src
->u
.rw
.handle
;
280 dst
->u
.rw
.id
= src
->u
.rw
.id
;
281 dst
->u
.rw
.sector_number
= src
->u
.rw
.sector_number
;
283 if (n
> dst
->u
.rw
.nr_segments
)
284 n
= dst
->u
.rw
.nr_segments
;
285 for (i
= 0; i
< n
; i
++)
286 dst
->u
.rw
.seg
[i
] = src
->u
.rw
.seg
[i
];
288 case BLKIF_OP_DISCARD
:
289 dst
->u
.discard
.flag
= src
->u
.discard
.flag
;
290 dst
->u
.discard
.id
= src
->u
.discard
.id
;
291 dst
->u
.discard
.sector_number
= src
->u
.discard
.sector_number
;
292 dst
->u
.discard
.nr_sectors
= src
->u
.discard
.nr_sectors
;
296 * Don't know how to translate this op. Only get the
297 * ID so failure can be reported to the frontend.
299 dst
->u
.other
.id
= src
->u
.other
.id
;
304 static inline void blkif_get_x86_64_req(struct blkif_request
*dst
,
305 struct blkif_x86_64_request
*src
)
307 int i
, n
= BLKIF_MAX_SEGMENTS_PER_REQUEST
;
308 dst
->operation
= src
->operation
;
309 switch (src
->operation
) {
312 case BLKIF_OP_WRITE_BARRIER
:
313 case BLKIF_OP_FLUSH_DISKCACHE
:
314 dst
->u
.rw
.nr_segments
= src
->u
.rw
.nr_segments
;
315 dst
->u
.rw
.handle
= src
->u
.rw
.handle
;
316 dst
->u
.rw
.id
= src
->u
.rw
.id
;
317 dst
->u
.rw
.sector_number
= src
->u
.rw
.sector_number
;
319 if (n
> dst
->u
.rw
.nr_segments
)
320 n
= dst
->u
.rw
.nr_segments
;
321 for (i
= 0; i
< n
; i
++)
322 dst
->u
.rw
.seg
[i
] = src
->u
.rw
.seg
[i
];
324 case BLKIF_OP_DISCARD
:
325 dst
->u
.discard
.flag
= src
->u
.discard
.flag
;
326 dst
->u
.discard
.id
= src
->u
.discard
.id
;
327 dst
->u
.discard
.sector_number
= src
->u
.discard
.sector_number
;
328 dst
->u
.discard
.nr_sectors
= src
->u
.discard
.nr_sectors
;
332 * Don't know how to translate this op. Only get the
333 * ID so failure can be reported to the frontend.
335 dst
->u
.other
.id
= src
->u
.other
.id
;
340 #endif /* __XEN_BLKIF__BACKEND__COMMON_H__ */