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 <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> 46 47 #define DRV_PFX "xen-blkback:" 48 #define DPRINTK(fmt, args...) \ 49 pr_debug(DRV_PFX "(%s:%d) " fmt ".\n", \ 50 __func__, __LINE__, ##args) 51 52 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 { 58 char dummy; 59 }; 60 struct blkif_common_response { 61 char dummy; 62 }; 63 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__)); 71 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) */ 77 uint64_t nr_sectors; 78 } __attribute__((__packed__)); 79 80 struct blkif_x86_32_request_other { 81 uint8_t _pad1; 82 blkif_vdev_t _pad2; 83 uint64_t id; /* private guest value, echoed in resp */ 84 } __attribute__((__packed__)); 85 86 struct blkif_x86_32_request { 87 uint8_t operation; /* BLKIF_OP_??? */ 88 union { 89 struct blkif_x86_32_request_rw rw; 90 struct blkif_x86_32_request_discard discard; 91 struct blkif_x86_32_request_other other; 92 } u; 93 } __attribute__((__packed__)); 94 95 /* i386 protocol version */ 96 #pragma pack(push, 4) 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_??? */ 101 }; 102 #pragma pack(pop) 103 /* x86_64 protocol version */ 104 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 */ 109 uint64_t id; 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__)); 113 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 */ 118 uint64_t id; 119 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 120 uint64_t nr_sectors; 121 } __attribute__((__packed__)); 122 123 struct blkif_x86_64_request_other { 124 uint8_t _pad1; 125 blkif_vdev_t _pad2; 126 uint32_t _pad3; /* offsetof(blkif_..,u.discard.id)==8 */ 127 uint64_t id; /* private guest value, echoed in resp */ 128 } __attribute__((__packed__)); 129 130 struct blkif_x86_64_request { 131 uint8_t operation; /* BLKIF_OP_??? */ 132 union { 133 struct blkif_x86_64_request_rw rw; 134 struct blkif_x86_64_request_discard discard; 135 struct blkif_x86_64_request_other other; 136 } u; 137 } __attribute__((__packed__)); 138 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_??? */ 143 }; 144 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); 151 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; 157 }; 158 159 enum blkif_protocol { 160 BLKIF_PROTOCOL_NATIVE = 1, 161 BLKIF_PROTOCOL_X86_32 = 2, 162 BLKIF_PROTOCOL_X86_64 = 3, 163 }; 164 165 struct xen_vbd { 166 /* What the domain refers to this vbd as. */ 167 blkif_vdev_t handle; 168 /* Non-zero -> read-only */ 169 unsigned char readonly; 170 /* VDISK_xxx */ 171 unsigned char type; 172 /* phys device that this vbd maps to. */ 173 u32 pdevice; 174 struct block_device *bdev; 175 /* Cached size parameter. */ 176 sector_t size; 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; 181 }; 182 183 struct backend_info; 184 185 186 struct persistent_gnt { 187 struct page *page; 188 grant_ref_t gnt; 189 grant_handle_t handle; 190 struct rb_node node; 191 }; 192 193 struct xen_blkif { 194 /* Unique identifier for this interface. */ 195 domid_t domid; 196 unsigned int handle; 197 /* Physical parameters of the comms window. */ 198 unsigned int irq; 199 /* Comms information. */ 200 enum blkif_protocol blk_protocol; 201 union blkif_back_rings blk_rings; 202 void *blk_ring; 203 /* The VBD attached to this interface. */ 204 struct xen_vbd vbd; 205 /* Back pointer to the backend_info. */ 206 struct backend_info *be; 207 /* Private fields. */ 208 spinlock_t blk_ring_lock; 209 atomic_t refcnt; 210 211 wait_queue_head_t wq; 212 /* for barrier (drain) requests */ 213 struct completion drain_complete; 214 atomic_t drain; 215 /* One thread per one blkif. */ 216 struct task_struct *xenblkd; 217 unsigned int waiting_reqs; 218 219 /* tree to store persistent grants */ 220 struct rb_root persistent_gnts; 221 unsigned int persistent_gnt_c; 222 223 /* statistics */ 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; 232 233 wait_queue_head_t waiting_to_free; 234 }; 235 236 237 #define vbd_sz(_v) ((_v)->bdev->bd_part ? \ 238 (_v)->bdev->bd_part->nr_sects : \ 239 get_capacity((_v)->bdev->bd_disk)) 240 241 #define xen_blkif_get(_b) (atomic_inc(&(_b)->refcnt)) 242 #define xen_blkif_put(_b) \ 243 do { \ 244 if (atomic_dec_and_test(&(_b)->refcnt)) \ 245 wake_up(&(_b)->waiting_to_free);\ 246 } while (0) 247 248 struct phys_req { 249 unsigned short dev; 250 blkif_sector_t nr_sects; 251 struct block_device *bdev; 252 blkif_sector_t sector_number; 253 }; 254 int xen_blkif_interface_init(void); 255 256 int xen_blkif_xenbus_init(void); 257 258 irqreturn_t xen_blkif_be_int(int irq, void *dev_id); 259 int xen_blkif_schedule(void *arg); 260 261 int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt, 262 struct backend_info *be, int state); 263 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); 267 268 static inline void blkif_get_x86_32_req(struct blkif_request *dst, 269 struct blkif_x86_32_request *src) 270 { 271 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST; 272 dst->operation = src->operation; 273 switch (src->operation) { 274 case BLKIF_OP_READ: 275 case BLKIF_OP_WRITE: 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; 282 barrier(); 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]; 287 break; 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; 293 break; 294 default: 295 /* 296 * Don't know how to translate this op. Only get the 297 * ID so failure can be reported to the frontend. 298 */ 299 dst->u.other.id = src->u.other.id; 300 break; 301 } 302 } 303 304 static inline void blkif_get_x86_64_req(struct blkif_request *dst, 305 struct blkif_x86_64_request *src) 306 { 307 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST; 308 dst->operation = src->operation; 309 switch (src->operation) { 310 case BLKIF_OP_READ: 311 case BLKIF_OP_WRITE: 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; 318 barrier(); 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]; 323 break; 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; 329 break; 330 default: 331 /* 332 * Don't know how to translate this op. Only get the 333 * ID so failure can be reported to the frontend. 334 */ 335 dst->u.other.id = src->u.other.id; 336 break; 337 } 338 } 339 340 #endif /* __XEN_BLKIF__BACKEND__COMMON_H__ */ 341