sys/dev/xen/blkfront/block.h

   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  * $FreeBSD$
  31  */
  32
  33 #ifndef __XEN_BLKFRONT_BLOCK_H__
  34 #define __XEN_BLKFRONT_BLOCK_H__
  35 #include <xen/blkif.h>
  36
  37 /**
  38  * Given a number of blkif segments, compute the maximum I/O size supported.
  39  *
  40  * \note This calculation assumes that all but the first and last segments
  41  *       of the I/O are fully utilized.
  42  *
  43  * \note We reserve a segement from the maximum supported by the transport to
  44  *       guarantee we can handle an unaligned transfer without the need to
  45  *       use a bounce buffer.
  46  */
  47 #define XBD_SEGS_TO_SIZE(segs)                                          \
  48         (((segs) - 1) * PAGE_SIZE)
  49
  50 /**
  51  * Compute the maximum number of blkif segments requried to represent
  52  * an I/O of the given size.
  53  *
  54  * \note This calculation assumes that all but the first and last segments
  55  *       of the I/O are fully utilized.
  56  *
  57  * \note We reserve a segement to guarantee we can handle an unaligned
  58  *       transfer without the need to use a bounce buffer.
  59  */
  60 #define XBD_SIZE_TO_SEGS(size)                                          \
  61         ((size / PAGE_SIZE) + 1)
  62
  63 /**
  64  * The maximum number of outstanding requests blocks (request headers plus
  65  * additional segment blocks) we will allow in a negotiated block-front/back
  66  * communication channel.
  67  */
  68 #define XBD_MAX_REQUESTS                256
  69
  70 /**
  71  * The maximum mapped region size per request we will allow in a negotiated
  72  * block-front/back communication channel.
  73  */
  74 #define XBD_MAX_REQUEST_SIZE                                            \
  75         MIN(MAXPHYS, XBD_SEGS_TO_SIZE(BLKIF_MAX_SEGMENTS_PER_REQUEST))
  76
  77 /**
  78  * The maximum number of segments (within a request header and accompanying
  79  * segment blocks) per request we will allow in a negotiated block-front/back
  80  * communication channel.
  81  */
  82 #define XBD_MAX_SEGMENTS_PER_REQUEST                                    \
  83         (MIN(BLKIF_MAX_SEGMENTS_PER_REQUEST,                            \
  84              XBD_SIZE_TO_SEGS(XBD_MAX_REQUEST_SIZE)))
  85
  86 /**
  87  * The maximum number of shared memory ring pages we will allow in a
  88  * negotiated block-front/back communication channel.  Allow enough
  89  * ring space for all requests to be  XBD_MAX_REQUEST_SIZE'd.
  90  */
  91 #define XBD_MAX_RING_PAGES                                                  \
  92         BLKIF_RING_PAGES(BLKIF_SEGS_TO_BLOCKS(XBD_MAX_SEGMENTS_PER_REQUEST) \
  93                        * XBD_MAX_REQUESTS)
  94
  95 typedef enum {
  96         XBDCF_Q_MASK            = 0xFF,
  97         /* This command has contributed to xbd_qfrozen_cnt. */
  98         XBDCF_FROZEN            = 1<<8,
  99         /* Freeze the command queue on dispatch (i.e. single step command). */
 100         XBDCF_Q_FREEZE          = 1<<9,
 101         /* Bus DMA returned EINPROGRESS for this command. */
 102         XBDCF_ASYNC_MAPPING     = 1<<10,
 103         XBDCF_INITIALIZER       = XBDCF_Q_MASK
 104 } xbdc_flag_t;
 105
 106 struct xbd_command;
 107 typedef void xbd_cbcf_t(struct xbd_command *);
 108
 109 struct xbd_command {
 110         TAILQ_ENTRY(xbd_command) cm_link;
 111         struct xbd_softc        *cm_sc;
 112         xbdc_flag_t              cm_flags;
 113         bus_dmamap_t             cm_map;
 114         uint64_t                 cm_id;
 115         grant_ref_t             *cm_sg_refs;
 116         struct bio              *cm_bp;
 117         grant_ref_t              cm_gref_head;
 118         void                    *cm_data;
 119         size_t                   cm_datalen;
 120         u_int                    cm_nseg;
 121         int                      cm_operation;
 122         blkif_sector_t           cm_sector_number;
 123         int                      cm_status;
 124         xbd_cbcf_t              *cm_complete;
 125 };
 126
 127 typedef enum {
 128         XBD_Q_FREE,
 129         XBD_Q_READY,
 130         XBD_Q_BUSY,
 131         XBD_Q_COMPLETE,
 132         XBD_Q_BIO,
 133         XBD_Q_COUNT,
 134         XBD_Q_NONE = XBDCF_Q_MASK
 135 } xbd_q_index_t;
 136
 137 typedef struct xbd_cm_q {
 138         TAILQ_HEAD(, xbd_command) q_tailq;
 139         uint32_t                  q_length;
 140         uint32_t                  q_max;
 141 } xbd_cm_q_t;
 142
 143 typedef enum {
 144         XBD_STATE_DISCONNECTED,
 145         XBD_STATE_CONNECTED,
 146         XBD_STATE_SUSPENDED
 147 } xbd_state_t;
 148
 149 typedef enum {
 150         XBDF_NONE         = 0,
 151         XBDF_OPEN         = 1 << 0, /* drive is open (can't shut down) */
 152         XBDF_BARRIER      = 1 << 1, /* backend supports barriers */
 153         XBDF_FLUSH        = 1 << 2, /* backend supports flush */
 154         XBDF_READY        = 1 << 3, /* Is ready */
 155         XBDF_CM_SHORTAGE  = 1 << 4, /* Free cm resource shortage active. */
 156         XBDF_GNT_SHORTAGE = 1 << 5, /* Grant ref resource shortage active */
 157         XBDF_WAIT_IDLE    = 1 << 6  /*
 158                                      * No new work until oustanding work
 159                                      * completes.
 160                                      */
 161 } xbd_flag_t;
 162
 163 /*
 164  * We have one of these per vbd, whether ide, scsi or 'other'.
 165  */
 166 struct xbd_softc {
 167         device_t                         xbd_dev;
 168         struct disk                     *xbd_disk;      /* disk params */
 169         struct bio_queue_head            xbd_bioq;      /* sort queue */
 170         int                              xbd_unit;
 171         xbd_flag_t                       xbd_flags;
 172         int                              xbd_qfrozen_cnt;
 173         int                              xbd_vdevice;
 174         xbd_state_t                      xbd_state;
 175         u_int                            xbd_ring_pages;
 176         uint32_t                         xbd_max_requests;
 177         uint32_t                         xbd_max_request_segments;
 178         uint32_t                         xbd_max_request_blocks;
 179         uint32_t                         xbd_max_request_size;
 180         grant_ref_t                      xbd_ring_ref[XBD_MAX_RING_PAGES];
 181         blkif_front_ring_t               xbd_ring;
 182         xen_intr_handle_t                xen_intr_handle;
 183         struct gnttab_free_callback      xbd_callback;
 184         xbd_cm_q_t                       xbd_cm_q[XBD_Q_COUNT];
 185         bus_dma_tag_t                    xbd_io_dmat;
 186
 187         /**
 188          * The number of people holding this device open.  We won't allow a
 189          * hot-unplug unless this is 0.
 190          */
 191         int                              xbd_users;
 192         struct mtx                       xbd_io_lock;
 193
 194         struct xbd_command              *xbd_shadow;
 195 };
 196
 197 int xbd_instance_create(struct xbd_softc *, blkif_sector_t sectors, int device,
 198                         uint16_t vdisk_info, unsigned long sector_size);
 199
 200 static inline void
 201 xbd_added_qentry(struct xbd_softc *sc, xbd_q_index_t index)
 202 {
 203         struct xbd_cm_q *cmq;
 204
 205         cmq = &sc->xbd_cm_q[index];
 206         cmq->q_length++;
 207         if (cmq->q_length > cmq->q_max)
 208                 cmq->q_max = cmq->q_length;
 209 }
 210
 211 static inline void
 212 xbd_removed_qentry(struct xbd_softc *sc, xbd_q_index_t index)
 213 {
 214         sc->xbd_cm_q[index].q_length--;
 215 }
 216
 217 static inline uint32_t
 218 xbd_queue_length(struct xbd_softc *sc, xbd_q_index_t index)
 219 {
 220         return (sc->xbd_cm_q[index].q_length);
 221 }
 222
 223 static inline void
 224 xbd_initq_cm(struct xbd_softc *sc, xbd_q_index_t index)
 225 {
 226         struct xbd_cm_q *cmq;
 227
 228         cmq = &sc->xbd_cm_q[index];
 229         TAILQ_INIT(&cmq->q_tailq);
 230         cmq->q_length = 0;
 231         cmq->q_max = 0;
 232 }
 233
 234 static inline void
 235 xbd_enqueue_cm(struct xbd_command *cm, xbd_q_index_t index)
 236 {
 237         KASSERT(index != XBD_Q_BIO,
 238             ("%s: Commands cannot access the bio queue.", __func__));
 239         if ((cm->cm_flags & XBDCF_Q_MASK) != XBD_Q_NONE)
 240                 panic("%s: command %p is already on queue %d.",
 241                     __func__, cm, cm->cm_flags & XBDCF_Q_MASK);
 242         TAILQ_INSERT_TAIL(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
 243         cm->cm_flags &= ~XBDCF_Q_MASK;
 244         cm->cm_flags |= index;
 245         xbd_added_qentry(cm->cm_sc, index);
 246 }
 247
 248 static inline void
 249 xbd_requeue_cm(struct xbd_command *cm, xbd_q_index_t index)
 250 {
 251         KASSERT(index != XBD_Q_BIO,
 252             ("%s: Commands cannot access the bio queue.", __func__));
 253         if ((cm->cm_flags & XBDCF_Q_MASK) != XBD_Q_NONE)
 254                 panic("%s: command %p is already on queue %d.",
 255                     __func__, cm, cm->cm_flags & XBDCF_Q_MASK);
 256         TAILQ_INSERT_HEAD(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
 257         cm->cm_flags &= ~XBDCF_Q_MASK;
 258         cm->cm_flags |= index;
 259         xbd_added_qentry(cm->cm_sc, index);
 260 }
 261
 262 static inline struct xbd_command *
 263 xbd_dequeue_cm(struct xbd_softc *sc, xbd_q_index_t index)
 264 {
 265         struct xbd_command *cm;
 266
 267         KASSERT(index != XBD_Q_BIO,
 268             ("%s: Commands cannot access the bio queue.", __func__));
 269
 270         if ((cm = TAILQ_FIRST(&sc->xbd_cm_q[index].q_tailq)) != NULL) {
 271                 if ((cm->cm_flags & XBDCF_Q_MASK) != index) {
 272                         panic("%s: command %p is on queue %d, "
 273                             "not specified queue %d",
 274                             __func__, cm,
 275                             cm->cm_flags & XBDCF_Q_MASK,
 276                             index);
 277                 }
 278                 TAILQ_REMOVE(&sc->xbd_cm_q[index].q_tailq, cm, cm_link);
 279                 cm->cm_flags &= ~XBDCF_Q_MASK;
 280                 cm->cm_flags |= XBD_Q_NONE;
 281                 xbd_removed_qentry(cm->cm_sc, index);
 282         }
 283         return (cm);
 284 }
 285
 286 static inline void
 287 xbd_remove_cm(struct xbd_command *cm, xbd_q_index_t expected_index)
 288 {
 289         xbd_q_index_t index;
 290
 291         index = cm->cm_flags & XBDCF_Q_MASK;
 292
 293         KASSERT(index != XBD_Q_BIO,
 294             ("%s: Commands cannot access the bio queue.", __func__));
 295
 296         if (index != expected_index) {
 297                 panic("%s: command %p is on queue %d, not specified queue %d",
 298                     __func__, cm, index, expected_index);
 299         }
 300         TAILQ_REMOVE(&cm->cm_sc->xbd_cm_q[index].q_tailq, cm, cm_link);
 301         cm->cm_flags &= ~XBDCF_Q_MASK;
 302         cm->cm_flags |= XBD_Q_NONE;
 303         xbd_removed_qentry(cm->cm_sc, index);
 304 }
 305
 306 static inline void
 307 xbd_initq_bio(struct xbd_softc *sc)
 308 {
 309         bioq_init(&sc->xbd_bioq);
 310 }
 311
 312 static inline void
 313 xbd_enqueue_bio(struct xbd_softc *sc, struct bio *bp)
 314 {
 315         bioq_insert_tail(&sc->xbd_bioq, bp);
 316         xbd_added_qentry(sc, XBD_Q_BIO);
 317 }
 318
 319 static inline void
 320 xbd_requeue_bio(struct xbd_softc *sc, struct bio *bp)
 321 {
 322         bioq_insert_head(&sc->xbd_bioq, bp);
 323         xbd_added_qentry(sc, XBD_Q_BIO);
 324 }
 325
 326 static inline struct bio *
 327 xbd_dequeue_bio(struct xbd_softc *sc)
 328 {
 329         struct bio *bp;
 330
 331         if ((bp = bioq_first(&sc->xbd_bioq)) != NULL) {
 332                 bioq_remove(&sc->xbd_bioq, bp);
 333                 xbd_removed_qentry(sc, XBD_Q_BIO);
 334         }
 335         return (bp);
 336 }
 337
 338 static inline void
 339 xbd_initqs(struct xbd_softc *sc)
 340 {
 341         u_int index;
 342
 343         for (index = 0; index < XBD_Q_COUNT; index++)
 344                 xbd_initq_cm(sc, index);
 345
 346         xbd_initq_bio(sc);
 347 }
 348
 349 #endif /* __XEN_BLKFRONT_BLOCK_H__ */