1 /* 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: 7 * 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: 14 * 15 * The above copyright notice and this permission notice shall be included in 16 * all copies or substantial portions of the Software. 17 * 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 24 * IN THE SOFTWARE. 25 */ 26 27 #ifndef __XEN_BLKIF__BACKEND__COMMON_H__ 28 #define __XEN_BLKIF__BACKEND__COMMON_H__ 29 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> 36 #include <linux/io.h> 37 #include <asm/setup.h> 38 #include <asm/pgalloc.h> 39 #include <asm/hypervisor.h> 40 #include <xen/grant_table.h> 41 #include <xen/xenbus.h> 42 #include <xen/interface/io/ring.h> 43 #include <xen/interface/io/blkif.h> 44 #include <xen/interface/io/protocols.h> 45 46 #define DRV_PFX "xen-blkback:" 47 #define DPRINTK(fmt, args...) \ 48 pr_debug(DRV_PFX "(%s:%d) " fmt ".\n", \ 49 __func__, __LINE__, ##args) 50 51 52 /* Not a real protocol. Used to generate ring structs which contain 53 * the elements common to all protocols only. This way we get a 54 * compiler-checkable way to use common struct elements, so we can 55 * avoid using switch(protocol) in a number of places. */ 56 struct blkif_common_request { 57 char dummy; 58 }; 59 struct blkif_common_response { 60 char dummy; 61 }; 62 63 struct blkif_x86_32_request_rw { 64 uint8_t nr_segments; /* number of segments */ 65 blkif_vdev_t handle; /* only for read/write requests */ 66 uint64_t id; /* private guest value, echoed in resp */ 67 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 68 struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 69 } __attribute__((__packed__)); 70 71 struct blkif_x86_32_request_discard { 72 uint8_t flag; /* BLKIF_DISCARD_SECURE or zero */ 73 blkif_vdev_t _pad1; /* was "handle" for read/write requests */ 74 uint64_t id; /* private guest value, echoed in resp */ 75 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 76 uint64_t nr_sectors; 77 } __attribute__((__packed__)); 78 79 struct blkif_x86_32_request { 80 uint8_t operation; /* BLKIF_OP_??? */ 81 union { 82 struct blkif_x86_32_request_rw rw; 83 struct blkif_x86_32_request_discard discard; 84 } u; 85 } __attribute__((__packed__)); 86 87 /* i386 protocol version */ 88 #pragma pack(push, 4) 89 struct blkif_x86_32_response { 90 uint64_t id; /* copied from request */ 91 uint8_t operation; /* copied from request */ 92 int16_t status; /* BLKIF_RSP_??? */ 93 }; 94 #pragma pack(pop) 95 /* x86_64 protocol version */ 96 97 struct blkif_x86_64_request_rw { 98 uint8_t nr_segments; /* number of segments */ 99 blkif_vdev_t handle; /* only for read/write requests */ 100 uint32_t _pad1; /* offsetof(blkif_reqest..,u.rw.id)==8 */ 101 uint64_t id; 102 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 103 struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 104 } __attribute__((__packed__)); 105 106 struct blkif_x86_64_request_discard { 107 uint8_t flag; /* BLKIF_DISCARD_SECURE or zero */ 108 blkif_vdev_t _pad1; /* was "handle" for read/write requests */ 109 uint32_t _pad2; /* offsetof(blkif_..,u.discard.id)==8 */ 110 uint64_t id; 111 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 112 uint64_t nr_sectors; 113 } __attribute__((__packed__)); 114 115 struct blkif_x86_64_request { 116 uint8_t operation; /* BLKIF_OP_??? */ 117 union { 118 struct blkif_x86_64_request_rw rw; 119 struct blkif_x86_64_request_discard discard; 120 } u; 121 } __attribute__((__packed__)); 122 123 struct blkif_x86_64_response { 124 uint64_t __attribute__((__aligned__(8))) id; 125 uint8_t operation; /* copied from request */ 126 int16_t status; /* BLKIF_RSP_??? */ 127 }; 128 129 DEFINE_RING_TYPES(blkif_common, struct blkif_common_request, 130 struct blkif_common_response); 131 DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, 132 struct blkif_x86_32_response); 133 DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request, 134 struct blkif_x86_64_response); 135 136 union blkif_back_rings { 137 struct blkif_back_ring native; 138 struct blkif_common_back_ring common; 139 struct blkif_x86_32_back_ring x86_32; 140 struct blkif_x86_64_back_ring x86_64; 141 }; 142 143 enum blkif_protocol { 144 BLKIF_PROTOCOL_NATIVE = 1, 145 BLKIF_PROTOCOL_X86_32 = 2, 146 BLKIF_PROTOCOL_X86_64 = 3, 147 }; 148 149 enum blkif_backend_type { 150 BLKIF_BACKEND_PHY = 1, 151 BLKIF_BACKEND_FILE = 2, 152 }; 153 154 struct xen_vbd { 155 /* What the domain refers to this vbd as. */ 156 blkif_vdev_t handle; 157 /* Non-zero -> read-only */ 158 unsigned char readonly; 159 /* VDISK_xxx */ 160 unsigned char type; 161 /* phys device that this vbd maps to. */ 162 u32 pdevice; 163 struct block_device *bdev; 164 /* Cached size parameter. */ 165 sector_t size; 166 bool flush_support; 167 bool discard_secure; 168 }; 169 170 struct backend_info; 171 172 struct xen_blkif { 173 /* Unique identifier for this interface. */ 174 domid_t domid; 175 unsigned int handle; 176 /* Physical parameters of the comms window. */ 177 unsigned int irq; 178 /* Comms information. */ 179 enum blkif_protocol blk_protocol; 180 enum blkif_backend_type blk_backend_type; 181 union blkif_back_rings blk_rings; 182 void *blk_ring; 183 /* The VBD attached to this interface. */ 184 struct xen_vbd vbd; 185 /* Back pointer to the backend_info. */ 186 struct backend_info *be; 187 /* Private fields. */ 188 spinlock_t blk_ring_lock; 189 atomic_t refcnt; 190 191 wait_queue_head_t wq; 192 /* for barrier (drain) requests */ 193 struct completion drain_complete; 194 atomic_t drain; 195 /* One thread per one blkif. */ 196 struct task_struct *xenblkd; 197 unsigned int waiting_reqs; 198 199 /* statistics */ 200 unsigned long st_print; 201 int st_rd_req; 202 int st_wr_req; 203 int st_oo_req; 204 int st_f_req; 205 int st_ds_req; 206 int st_rd_sect; 207 int st_wr_sect; 208 209 wait_queue_head_t waiting_to_free; 210 }; 211 212 213 #define vbd_sz(_v) ((_v)->bdev->bd_part ? \ 214 (_v)->bdev->bd_part->nr_sects : \ 215 get_capacity((_v)->bdev->bd_disk)) 216 217 #define xen_blkif_get(_b) (atomic_inc(&(_b)->refcnt)) 218 #define xen_blkif_put(_b) \ 219 do { \ 220 if (atomic_dec_and_test(&(_b)->refcnt)) \ 221 wake_up(&(_b)->waiting_to_free);\ 222 } while (0) 223 224 struct phys_req { 225 unsigned short dev; 226 blkif_sector_t nr_sects; 227 struct block_device *bdev; 228 blkif_sector_t sector_number; 229 }; 230 int xen_blkif_interface_init(void); 231 232 int xen_blkif_xenbus_init(void); 233 234 irqreturn_t xen_blkif_be_int(int irq, void *dev_id); 235 int xen_blkif_schedule(void *arg); 236 237 int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt, 238 struct backend_info *be, int state); 239 240 int xen_blkbk_barrier(struct xenbus_transaction xbt, 241 struct backend_info *be, int state); 242 struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be); 243 244 static inline void blkif_get_x86_32_req(struct blkif_request *dst, 245 struct blkif_x86_32_request *src) 246 { 247 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST; 248 dst->operation = src->operation; 249 switch (src->operation) { 250 case BLKIF_OP_READ: 251 case BLKIF_OP_WRITE: 252 case BLKIF_OP_WRITE_BARRIER: 253 case BLKIF_OP_FLUSH_DISKCACHE: 254 dst->u.rw.nr_segments = src->u.rw.nr_segments; 255 dst->u.rw.handle = src->u.rw.handle; 256 dst->u.rw.id = src->u.rw.id; 257 dst->u.rw.sector_number = src->u.rw.sector_number; 258 barrier(); 259 if (n > dst->u.rw.nr_segments) 260 n = dst->u.rw.nr_segments; 261 for (i = 0; i < n; i++) 262 dst->u.rw.seg[i] = src->u.rw.seg[i]; 263 break; 264 case BLKIF_OP_DISCARD: 265 dst->u.discard.flag = src->u.discard.flag; 266 dst->u.discard.sector_number = src->u.discard.sector_number; 267 dst->u.discard.nr_sectors = src->u.discard.nr_sectors; 268 break; 269 default: 270 break; 271 } 272 } 273 274 static inline void blkif_get_x86_64_req(struct blkif_request *dst, 275 struct blkif_x86_64_request *src) 276 { 277 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST; 278 dst->operation = src->operation; 279 switch (src->operation) { 280 case BLKIF_OP_READ: 281 case BLKIF_OP_WRITE: 282 case BLKIF_OP_WRITE_BARRIER: 283 case BLKIF_OP_FLUSH_DISKCACHE: 284 dst->u.rw.nr_segments = src->u.rw.nr_segments; 285 dst->u.rw.handle = src->u.rw.handle; 286 dst->u.rw.id = src->u.rw.id; 287 dst->u.rw.sector_number = src->u.rw.sector_number; 288 barrier(); 289 if (n > dst->u.rw.nr_segments) 290 n = dst->u.rw.nr_segments; 291 for (i = 0; i < n; i++) 292 dst->u.rw.seg[i] = src->u.rw.seg[i]; 293 break; 294 case BLKIF_OP_DISCARD: 295 dst->u.discard.flag = src->u.discard.flag; 296 dst->u.discard.sector_number = src->u.discard.sector_number; 297 dst->u.discard.nr_sectors = src->u.discard.nr_sectors; 298 break; 299 default: 300 break; 301 } 302 } 303 304 #endif /* __XEN_BLKIF__BACKEND__COMMON_H__ */ 305