1 /*
2 * XenBSD block device driver
3 *
4 * Copyright (c) 2010-2013 Spectra Logic Corporation
5 * Copyright (c) 2009 Scott Long, Yahoo!
6 * Copyright (c) 2009 Frank Suchomel, Citrix
7 * Copyright (c) 2009 Doug F. Rabson, Citrix
8 * Copyright (c) 2005 Kip Macy
9 * Copyright (c) 2003-2004, Keir Fraser & Steve Hand
10 * Modifications by Mark A. Williamson are (c) Intel Research Cambridge
11 *
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a copy
14 * of this software and associated documentation files (the "Software"), to
15 * deal in the Software without restriction, including without limitation the
16 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
17 * sell copies of the Software, and to permit persons to whom the Software is
18 * furnished to do so, subject to the following conditions:
19 *
20 * The above copyright notice and this permission notice shall be included in
21 * all copies or substantial portions of the Software.
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
28 * DEALINGS IN THE SOFTWARE.
29 */
30
31 #ifndef __XEN_BLKFRONT_BLOCK_H__
32 #define __XEN_BLKFRONT_BLOCK_H__
33 #include <xen/blkif.h>
34
35 /**
36 * Given a number of blkif segments, compute the maximum I/O size supported.
37 *
38 * \note This calculation assumes that all but the first and last segments
39 * of the I/O are fully utilized.
40 *
41 * \note We reserve a segment from the maximum supported by the transport to
42 * guarantee we can handle an unaligned transfer without the need to
43 * use a bounce buffer.
44 */
45 #define XBD_SEGS_TO_SIZE(segs) \
46 (((segs) - 1) * PAGE_SIZE)
47
48 /**
49 * Compute the maximum number of blkif segments requried to represent
50 * an I/O of the given size.
51 *
52 * \note This calculation assumes that all but the first and last segments
53 * of the I/O are fully utilized.
54 *
55 * \note We reserve a segment to guarantee we can handle an unaligned
56 * transfer without the need to use a bounce buffer.
57 */
58 #define XBD_SIZE_TO_SEGS(size) \
59 ((size / PAGE_SIZE) + 1)
60
61 /**
62 * The maximum number of shared memory ring pages we will allow in a
63 * negotiated block-front/back communication channel. Allow enough
64 * ring space for all requests to be XBD_MAX_REQUEST_SIZE'd.
65 */
66 #define XBD_MAX_RING_PAGES 32
67
68 /**
69 * The maximum number of outstanding requests we will allow in a negotiated
70 * block-front/back communication channel.
71 */
72 #define XBD_MAX_REQUESTS \
73 __CONST_RING_SIZE(blkif, PAGE_SIZE * XBD_MAX_RING_PAGES)
74
75 /**
76 * The maximum number of blkif segments which can be provided per indirect
77 * page in an indirect request.
78 */
79 #define XBD_MAX_SEGMENTS_PER_PAGE \
80 (PAGE_SIZE / sizeof(struct blkif_request_segment))
81
82 /**
83 * The maximum number of blkif segments which can be provided in an indirect
84 * request.
85 */
86 #define XBD_MAX_INDIRECT_SEGMENTS \
87 (BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST * XBD_MAX_SEGMENTS_PER_PAGE)
88
89 /**
90 * Compute the number of indirect segment pages required for an I/O with the
91 * specified number of indirect segments.
92 */
93 #define XBD_INDIRECT_SEGS_TO_PAGES(segs) \
94 ((segs + XBD_MAX_SEGMENTS_PER_PAGE - 1) / XBD_MAX_SEGMENTS_PER_PAGE)
95
96 typedef enum {
97 XBDCF_Q_MASK = 0xFF,
98 /* This command has contributed to xbd_qfrozen_cnt. */
99 XBDCF_FROZEN = 1<<8,
100 /* Freeze the command queue on dispatch (i.e. single step command). */
101 XBDCF_Q_FREEZE = 1<<9,
102 /* Bus DMA returned EINPROGRESS for this command. */
103 XBDCF_ASYNC_MAPPING = 1<<10,
104 XBDCF_INITIALIZER = XBDCF_Q_MASK
105 } xbdc_flag_t;
106
107 struct xbd_command;
108 typedef void xbd_cbcf_t(struct xbd_command *);
109
110 struct xbd_command {
111 TAILQ_ENTRY(xbd_command) cm_link;
112 struct xbd_softc *cm_sc;
113 xbdc_flag_t cm_flags;
114 bus_dmamap_t cm_map;
115 uint64_t cm_id;
116 grant_ref_t *cm_sg_refs;
117 struct bio *cm_bp;
118 grant_ref_t cm_gref_head;
119 void *cm_data;
120 size_t cm_datalen;
121 u_int cm_nseg;
122 int cm_operation;
123 blkif_sector_t cm_sector_number;
124 int cm_status;
125 xbd_cbcf_t *cm_complete;
126 void *cm_indirectionpages;
127 grant_ref_t cm_indirectionrefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST];
128 };
129
130 typedef enum {
131 XBD_Q_FREE,
132 XBD_Q_READY,
133 XBD_Q_BUSY,
134 XBD_Q_COMPLETE,
135 XBD_Q_BIO,
136 XBD_Q_COUNT,
137 XBD_Q_NONE = XBDCF_Q_MASK
138 } xbd_q_index_t;
139
140 typedef struct xbd_cm_q {
141 TAILQ_HEAD(, xbd_command) q_tailq;
142 uint32_t q_length;
143 uint32_t q_max;
144 } xbd_cm_q_t;
145
146 typedef enum {
147 XBD_STATE_DISCONNECTED,
148 XBD_STATE_CONNECTED,
149 XBD_STATE_SUSPENDED
150 } xbd_state_t;
151
152 typedef enum {
153 XBDF_NONE = 0,
154 XBDF_OPEN = 1 << 0, /* drive is open (can't shut down) */
155 XBDF_BARRIER = 1 << 1, /* backend supports barriers */
156 XBDF_FLUSH = 1 << 2, /* backend supports flush */
157 XBDF_READY = 1 << 3, /* Is ready */
158 XBDF_CM_SHORTAGE = 1 << 4, /* Free cm resource shortage active. */
159 XBDF_GNT_SHORTAGE = 1 << 5, /* Grant ref resource shortage active */
160 XBDF_WAIT_IDLE = 1 << 6, /*
161 * No new work until outstanding work
162 * completes.
163 */
164 XBDF_DISCARD = 1 << 7, /* backend supports discard */
165 XBDF_PERSISTENT = 1 << 8 /* backend supports persistent grants */
166 } xbd_flag_t;
167
168 /*
169 * We have one of these per vbd, whether ide, scsi or 'other'.
170 */
171 struct xbd_softc {
172 device_t xbd_dev;
173 struct disk *xbd_disk; /* disk params */
174 struct bio_queue_head xbd_bioq; /* sort queue */
175 int xbd_unit;
176 xbd_flag_t xbd_flags;
177 int xbd_qfrozen_cnt;
178 int xbd_vdevice;
179 xbd_state_t xbd_state;
180 u_int xbd_ring_pages;
181 uint32_t xbd_max_requests;
182 uint32_t xbd_max_request_segments;
183 uint32_t xbd_max_request_size;
184 uint32_t xbd_max_request_indirectpages;
185 grant_ref_t xbd_ring_ref[XBD_MAX_RING_PAGES];
186 blkif_front_ring_t xbd_ring;
187 xen_intr_handle_t xen_intr_handle;
188 struct gnttab_free_callback xbd_callback;
189 xbd_cm_q_t xbd_cm_q[XBD_Q_COUNT];
190 bus_dma_tag_t xbd_io_dmat;
191
192 /**
193 * The number of people holding this device open. We won't allow a
194 * hot-unplug unless this is 0.
195 */
196 int xbd_users;
197 struct mtx xbd_io_lock;
198
199 struct xbd_command *xbd_shadow;
200 };
201
202 int xbd_instance_create(struct xbd_softc *, blkif_sector_t sectors, int device,
203 uint16_t vdisk_info, unsigned long sector_size,
204 unsigned long phys_sector_size);
205
206 static inline void
xbd_added_qentry(struct xbd_softc * sc,xbd_q_index_t index)207 xbd_added_qentry(struct xbd_softc *sc, xbd_q_index_t index)
208 {
209 struct xbd_cm_q *cmq;
210
211 cmq = &sc->xbd_cm_q[index];
212 cmq->q_length++;
213 if (cmq->q_length > cmq->q_max)
214 cmq->q_max = cmq->q_length;
215 }
216
217 static inline void
xbd_removed_qentry(struct xbd_softc * sc,xbd_q_index_t index)218 xbd_removed_qentry(struct xbd_softc *sc, xbd_q_index_t index)
219 {
220 sc->xbd_cm_q[index].q_length--;
221 }
222
223 static inline uint32_t
xbd_queue_length(struct xbd_softc * sc,xbd_q_index_t index)224 xbd_queue_length(struct xbd_softc *sc, xbd_q_index_t index)
225 {
226 return (sc->xbd_cm_q[index].q_length);
227 }
228
229 static inline void
xbd_initq_cm(struct xbd_softc * sc,xbd_q_index_t index)230 xbd_initq_cm(struct xbd_softc *sc, xbd_q_index_t index)
231 {
232 struct xbd_cm_q *cmq;
233
234 cmq = &sc->xbd_cm_q[index];
235 TAILQ_INIT(&cmq->q_tailq);
236 cmq->q_length = 0;
237 cmq->q_max = 0;
238 }
239
240 static inline void
xbd_enqueue_cm(struct xbd_command * cm,xbd_q_index_t index)241 xbd_enqueue_cm(struct xbd_command *cm, xbd_q_index_t index)
242 {
243 KASSERT(index != XBD_Q_BIO,
244 ("%s: Commands cannot access the bio queue.", __func__));
245 if ((cm->cm_flags & XBDCF_Q_MASK) != XBD_Q_NONE)
246 panic("%s: command %p is already on queue %d.",
247 __func__, cm, cm->cm_flags & XBDCF_Q_MASK);
248 TAILQ_INSERT_TAIL(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
249 cm->cm_flags &= ~XBDCF_Q_MASK;
250 cm->cm_flags |= index;
251 xbd_added_qentry(cm->cm_sc, index);
252 }
253
254 static inline void
xbd_requeue_cm(struct xbd_command * cm,xbd_q_index_t index)255 xbd_requeue_cm(struct xbd_command *cm, xbd_q_index_t index)
256 {
257 KASSERT(index != XBD_Q_BIO,
258 ("%s: Commands cannot access the bio queue.", __func__));
259 if ((cm->cm_flags & XBDCF_Q_MASK) != XBD_Q_NONE)
260 panic("%s: command %p is already on queue %d.",
261 __func__, cm, cm->cm_flags & XBDCF_Q_MASK);
262 TAILQ_INSERT_HEAD(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
263 cm->cm_flags &= ~XBDCF_Q_MASK;
264 cm->cm_flags |= index;
265 xbd_added_qentry(cm->cm_sc, index);
266 }
267
268 static inline struct xbd_command *
xbd_dequeue_cm(struct xbd_softc * sc,xbd_q_index_t index)269 xbd_dequeue_cm(struct xbd_softc *sc, xbd_q_index_t index)
270 {
271 struct xbd_command *cm;
272
273 KASSERT(index != XBD_Q_BIO,
274 ("%s: Commands cannot access the bio queue.", __func__));
275
276 if ((cm = TAILQ_FIRST(&sc->xbd_cm_q[index].q_tailq)) != NULL) {
277 if ((cm->cm_flags & XBDCF_Q_MASK) != index) {
278 panic("%s: command %p is on queue %d, "
279 "not specified queue %d",
280 __func__, cm,
281 cm->cm_flags & XBDCF_Q_MASK,
282 index);
283 }
284 TAILQ_REMOVE(&sc->xbd_cm_q[index].q_tailq, cm, cm_link);
285 cm->cm_flags &= ~XBDCF_Q_MASK;
286 cm->cm_flags |= XBD_Q_NONE;
287 xbd_removed_qentry(cm->cm_sc, index);
288 }
289 return (cm);
290 }
291
292 static inline void
xbd_remove_cm(struct xbd_command * cm,xbd_q_index_t expected_index)293 xbd_remove_cm(struct xbd_command *cm, xbd_q_index_t expected_index)
294 {
295 xbd_q_index_t index;
296
297 index = cm->cm_flags & XBDCF_Q_MASK;
298
299 KASSERT(index != XBD_Q_BIO,
300 ("%s: Commands cannot access the bio queue.", __func__));
301
302 if (index != expected_index) {
303 panic("%s: command %p is on queue %d, not specified queue %d",
304 __func__, cm, index, expected_index);
305 }
306 TAILQ_REMOVE(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
307 cm->cm_flags &= ~XBDCF_Q_MASK;
308 cm->cm_flags |= XBD_Q_NONE;
309 xbd_removed_qentry(cm->cm_sc, index);
310 }
311
312 static inline void
xbd_initq_bio(struct xbd_softc * sc)313 xbd_initq_bio(struct xbd_softc *sc)
314 {
315 bioq_init(&sc->xbd_bioq);
316 }
317
318 static inline void
xbd_enqueue_bio(struct xbd_softc * sc,struct bio * bp)319 xbd_enqueue_bio(struct xbd_softc *sc, struct bio *bp)
320 {
321 bioq_insert_tail(&sc->xbd_bioq, bp);
322 xbd_added_qentry(sc, XBD_Q_BIO);
323 }
324
325 static inline void
xbd_requeue_bio(struct xbd_softc * sc,struct bio * bp)326 xbd_requeue_bio(struct xbd_softc *sc, struct bio *bp)
327 {
328 bioq_insert_head(&sc->xbd_bioq, bp);
329 xbd_added_qentry(sc, XBD_Q_BIO);
330 }
331
332 static inline struct bio *
xbd_dequeue_bio(struct xbd_softc * sc)333 xbd_dequeue_bio(struct xbd_softc *sc)
334 {
335 struct bio *bp;
336
337 if ((bp = bioq_first(&sc->xbd_bioq)) != NULL) {
338 bioq_remove(&sc->xbd_bioq, bp);
339 xbd_removed_qentry(sc, XBD_Q_BIO);
340 }
341 return (bp);
342 }
343
344 static inline void
xbd_initqs(struct xbd_softc * sc)345 xbd_initqs(struct xbd_softc *sc)
346 {
347 u_int index;
348
349 for (index = 0; index < XBD_Q_COUNT; index++)
350 xbd_initq_cm(sc, index);
351
352 xbd_initq_bio(sc);
353 }
354
355 #endif /* __XEN_BLKFRONT_BLOCK_H__ */
356