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
96typedef 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
107struct xbd_command;
108typedef void xbd_cbcf_t(struct xbd_command *);
109
110struct 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
130typedef 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
140typedef 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
146typedef enum {
147	XBD_STATE_DISCONNECTED,
148	XBD_STATE_CONNECTED,
149	XBD_STATE_SUSPENDED
150} xbd_state_t;
151
152typedef 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 */
171struct 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
202int 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
206static inline void
207xbd_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
217static inline void
218xbd_removed_qentry(struct xbd_softc *sc, xbd_q_index_t index)
219{
220	sc->xbd_cm_q[index].q_length--;
221}
222
223static inline uint32_t
224xbd_queue_length(struct xbd_softc *sc, xbd_q_index_t index)
225{
226	return (sc->xbd_cm_q[index].q_length);
227}
228
229static inline void
230xbd_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
240static inline void
241xbd_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
254static inline void
255xbd_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
268static inline struct xbd_command *
269xbd_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
292static inline void
293xbd_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
312static inline void
313xbd_initq_bio(struct xbd_softc *sc)
314{
315	bioq_init(&sc->xbd_bioq);
316}
317
318static inline void
319xbd_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
325static inline void
326xbd_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
332static inline struct bio *
333xbd_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
344static inline void
345xbd_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