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 /* 54 * This is the maximum number of segments that would be allowed in indirect 55 * requests. This value will also be passed to the frontend. 56 */ 57 #define MAX_INDIRECT_SEGMENTS 256 58 59 #define SEGS_PER_INDIRECT_FRAME \ 60 (PAGE_SIZE/sizeof(struct blkif_request_segment)) 61 #define MAX_INDIRECT_PAGES \ 62 ((MAX_INDIRECT_SEGMENTS + SEGS_PER_INDIRECT_FRAME - 1)/SEGS_PER_INDIRECT_FRAME) 63 #define INDIRECT_PAGES(_segs) \ 64 ((_segs + SEGS_PER_INDIRECT_FRAME - 1)/SEGS_PER_INDIRECT_FRAME) 65 66 /* Not a real protocol. Used to generate ring structs which contain 67 * the elements common to all protocols only. This way we get a 68 * compiler-checkable way to use common struct elements, so we can 69 * avoid using switch(protocol) in a number of places. */ 70 struct blkif_common_request { 71 char dummy; 72 }; 73 struct blkif_common_response { 74 char dummy; 75 }; 76 77 struct blkif_x86_32_request_rw { 78 uint8_t nr_segments; /* number of segments */ 79 blkif_vdev_t handle; /* only for read/write requests */ 80 uint64_t id; /* private guest value, echoed in resp */ 81 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 82 struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 83 } __attribute__((__packed__)); 84 85 struct blkif_x86_32_request_discard { 86 uint8_t flag; /* BLKIF_DISCARD_SECURE or zero */ 87 blkif_vdev_t _pad1; /* was "handle" for read/write requests */ 88 uint64_t id; /* private guest value, echoed in resp */ 89 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 90 uint64_t nr_sectors; 91 } __attribute__((__packed__)); 92 93 struct blkif_x86_32_request_other { 94 uint8_t _pad1; 95 blkif_vdev_t _pad2; 96 uint64_t id; /* private guest value, echoed in resp */ 97 } __attribute__((__packed__)); 98 99 struct blkif_x86_32_request_indirect { 100 uint8_t indirect_op; 101 uint16_t nr_segments; 102 uint64_t id; 103 blkif_sector_t sector_number; 104 blkif_vdev_t handle; 105 uint16_t _pad1; 106 grant_ref_t indirect_grefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST]; 107 /* 108 * The maximum number of indirect segments (and pages) that will 109 * be used is determined by MAX_INDIRECT_SEGMENTS, this value 110 * is also exported to the guest (via xenstore 111 * feature-max-indirect-segments entry), so the frontend knows how 112 * many indirect segments the backend supports. 113 */ 114 uint64_t _pad2; /* make it 64 byte aligned */ 115 } __attribute__((__packed__)); 116 117 struct blkif_x86_32_request { 118 uint8_t operation; /* BLKIF_OP_??? */ 119 union { 120 struct blkif_x86_32_request_rw rw; 121 struct blkif_x86_32_request_discard discard; 122 struct blkif_x86_32_request_other other; 123 struct blkif_x86_32_request_indirect indirect; 124 } u; 125 } __attribute__((__packed__)); 126 127 /* i386 protocol version */ 128 #pragma pack(push, 4) 129 struct blkif_x86_32_response { 130 uint64_t id; /* copied from request */ 131 uint8_t operation; /* copied from request */ 132 int16_t status; /* BLKIF_RSP_??? */ 133 }; 134 #pragma pack(pop) 135 /* x86_64 protocol version */ 136 137 struct blkif_x86_64_request_rw { 138 uint8_t nr_segments; /* number of segments */ 139 blkif_vdev_t handle; /* only for read/write requests */ 140 uint32_t _pad1; /* offsetof(blkif_reqest..,u.rw.id)==8 */ 141 uint64_t id; 142 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 143 struct blkif_request_segment seg[BLKIF_MAX_SEGMENTS_PER_REQUEST]; 144 } __attribute__((__packed__)); 145 146 struct blkif_x86_64_request_discard { 147 uint8_t flag; /* BLKIF_DISCARD_SECURE or zero */ 148 blkif_vdev_t _pad1; /* was "handle" for read/write requests */ 149 uint32_t _pad2; /* offsetof(blkif_..,u.discard.id)==8 */ 150 uint64_t id; 151 blkif_sector_t sector_number;/* start sector idx on disk (r/w only) */ 152 uint64_t nr_sectors; 153 } __attribute__((__packed__)); 154 155 struct blkif_x86_64_request_other { 156 uint8_t _pad1; 157 blkif_vdev_t _pad2; 158 uint32_t _pad3; /* offsetof(blkif_..,u.discard.id)==8 */ 159 uint64_t id; /* private guest value, echoed in resp */ 160 } __attribute__((__packed__)); 161 162 struct blkif_x86_64_request_indirect { 163 uint8_t indirect_op; 164 uint16_t nr_segments; 165 uint32_t _pad1; /* offsetof(blkif_..,u.indirect.id)==8 */ 166 uint64_t id; 167 blkif_sector_t sector_number; 168 blkif_vdev_t handle; 169 uint16_t _pad2; 170 grant_ref_t indirect_grefs[BLKIF_MAX_INDIRECT_PAGES_PER_REQUEST]; 171 /* 172 * The maximum number of indirect segments (and pages) that will 173 * be used is determined by MAX_INDIRECT_SEGMENTS, this value 174 * is also exported to the guest (via xenstore 175 * feature-max-indirect-segments entry), so the frontend knows how 176 * many indirect segments the backend supports. 177 */ 178 uint32_t _pad3; /* make it 64 byte aligned */ 179 } __attribute__((__packed__)); 180 181 struct blkif_x86_64_request { 182 uint8_t operation; /* BLKIF_OP_??? */ 183 union { 184 struct blkif_x86_64_request_rw rw; 185 struct blkif_x86_64_request_discard discard; 186 struct blkif_x86_64_request_other other; 187 struct blkif_x86_64_request_indirect indirect; 188 } u; 189 } __attribute__((__packed__)); 190 191 struct blkif_x86_64_response { 192 uint64_t __attribute__((__aligned__(8))) id; 193 uint8_t operation; /* copied from request */ 194 int16_t status; /* BLKIF_RSP_??? */ 195 }; 196 197 DEFINE_RING_TYPES(blkif_common, struct blkif_common_request, 198 struct blkif_common_response); 199 DEFINE_RING_TYPES(blkif_x86_32, struct blkif_x86_32_request, 200 struct blkif_x86_32_response); 201 DEFINE_RING_TYPES(blkif_x86_64, struct blkif_x86_64_request, 202 struct blkif_x86_64_response); 203 204 union blkif_back_rings { 205 struct blkif_back_ring native; 206 struct blkif_common_back_ring common; 207 struct blkif_x86_32_back_ring x86_32; 208 struct blkif_x86_64_back_ring x86_64; 209 }; 210 211 enum blkif_protocol { 212 BLKIF_PROTOCOL_NATIVE = 1, 213 BLKIF_PROTOCOL_X86_32 = 2, 214 BLKIF_PROTOCOL_X86_64 = 3, 215 }; 216 217 /* 218 * Default protocol if the frontend doesn't specify one. 219 */ 220 #ifdef CONFIG_X86 221 # define BLKIF_PROTOCOL_DEFAULT BLKIF_PROTOCOL_X86_32 222 #else 223 # define BLKIF_PROTOCOL_DEFAULT BLKIF_PROTOCOL_NATIVE 224 #endif 225 226 struct xen_vbd { 227 /* What the domain refers to this vbd as. */ 228 blkif_vdev_t handle; 229 /* Non-zero -> read-only */ 230 unsigned char readonly; 231 /* VDISK_xxx */ 232 unsigned char type; 233 /* phys device that this vbd maps to. */ 234 u32 pdevice; 235 struct block_device *bdev; 236 /* Cached size parameter. */ 237 sector_t size; 238 unsigned int flush_support:1; 239 unsigned int discard_secure:1; 240 unsigned int feature_gnt_persistent:1; 241 unsigned int overflow_max_grants:1; 242 }; 243 244 struct backend_info; 245 246 /* Number of available flags */ 247 #define PERSISTENT_GNT_FLAGS_SIZE 2 248 /* This persistent grant is currently in use */ 249 #define PERSISTENT_GNT_ACTIVE 0 250 /* 251 * This persistent grant has been used, this flag is set when we remove the 252 * PERSISTENT_GNT_ACTIVE, to know that this grant has been used recently. 253 */ 254 #define PERSISTENT_GNT_WAS_ACTIVE 1 255 256 /* Number of requests that we can fit in a ring */ 257 #define XEN_BLKIF_REQS 32 258 259 struct persistent_gnt { 260 struct page *page; 261 grant_ref_t gnt; 262 grant_handle_t handle; 263 DECLARE_BITMAP(flags, PERSISTENT_GNT_FLAGS_SIZE); 264 struct rb_node node; 265 struct list_head remove_node; 266 }; 267 268 struct xen_blkif { 269 /* Unique identifier for this interface. */ 270 domid_t domid; 271 unsigned int handle; 272 /* Physical parameters of the comms window. */ 273 unsigned int irq; 274 /* Comms information. */ 275 enum blkif_protocol blk_protocol; 276 union blkif_back_rings blk_rings; 277 void *blk_ring; 278 /* The VBD attached to this interface. */ 279 struct xen_vbd vbd; 280 /* Back pointer to the backend_info. */ 281 struct backend_info *be; 282 /* Private fields. */ 283 spinlock_t blk_ring_lock; 284 atomic_t refcnt; 285 286 wait_queue_head_t wq; 287 /* for barrier (drain) requests */ 288 struct completion drain_complete; 289 atomic_t drain; 290 atomic_t inflight; 291 /* One thread per one blkif. */ 292 struct task_struct *xenblkd; 293 unsigned int waiting_reqs; 294 295 /* tree to store persistent grants */ 296 struct rb_root persistent_gnts; 297 unsigned int persistent_gnt_c; 298 atomic_t persistent_gnt_in_use; 299 unsigned long next_lru; 300 301 /* used by the kworker that offload work from the persistent purge */ 302 struct list_head persistent_purge_list; 303 struct work_struct persistent_purge_work; 304 305 /* buffer of free pages to map grant refs */ 306 spinlock_t free_pages_lock; 307 int free_pages_num; 308 struct list_head free_pages; 309 310 /* List of all 'pending_req' available */ 311 struct list_head pending_free; 312 /* And its spinlock. */ 313 spinlock_t pending_free_lock; 314 wait_queue_head_t pending_free_wq; 315 316 /* statistics */ 317 unsigned long st_print; 318 unsigned long long st_rd_req; 319 unsigned long long st_wr_req; 320 unsigned long long st_oo_req; 321 unsigned long long st_f_req; 322 unsigned long long st_ds_req; 323 unsigned long long st_rd_sect; 324 unsigned long long st_wr_sect; 325 326 struct work_struct free_work; 327 /* Thread shutdown wait queue. */ 328 wait_queue_head_t shutdown_wq; 329 }; 330 331 struct seg_buf { 332 unsigned long offset; 333 unsigned int nsec; 334 }; 335 336 struct grant_page { 337 struct page *page; 338 struct persistent_gnt *persistent_gnt; 339 grant_handle_t handle; 340 grant_ref_t gref; 341 }; 342 343 /* 344 * Each outstanding request that we've passed to the lower device layers has a 345 * 'pending_req' allocated to it. Each buffer_head that completes decrements 346 * the pendcnt towards zero. When it hits zero, the specified domain has a 347 * response queued for it, with the saved 'id' passed back. 348 */ 349 struct pending_req { 350 struct xen_blkif *blkif; 351 u64 id; 352 int nr_pages; 353 atomic_t pendcnt; 354 unsigned short operation; 355 int status; 356 struct list_head free_list; 357 struct grant_page *segments[MAX_INDIRECT_SEGMENTS]; 358 /* Indirect descriptors */ 359 struct grant_page *indirect_pages[MAX_INDIRECT_PAGES]; 360 struct seg_buf seg[MAX_INDIRECT_SEGMENTS]; 361 struct bio *biolist[MAX_INDIRECT_SEGMENTS]; 362 struct gnttab_unmap_grant_ref unmap[MAX_INDIRECT_SEGMENTS]; 363 struct page *unmap_pages[MAX_INDIRECT_SEGMENTS]; 364 struct gntab_unmap_queue_data gnttab_unmap_data; 365 }; 366 367 368 #define vbd_sz(_v) ((_v)->bdev->bd_part ? \ 369 (_v)->bdev->bd_part->nr_sects : \ 370 get_capacity((_v)->bdev->bd_disk)) 371 372 #define xen_blkif_get(_b) (atomic_inc(&(_b)->refcnt)) 373 #define xen_blkif_put(_b) \ 374 do { \ 375 if (atomic_dec_and_test(&(_b)->refcnt)) \ 376 schedule_work(&(_b)->free_work);\ 377 } while (0) 378 379 struct phys_req { 380 unsigned short dev; 381 blkif_sector_t nr_sects; 382 struct block_device *bdev; 383 blkif_sector_t sector_number; 384 }; 385 int xen_blkif_interface_init(void); 386 387 int xen_blkif_xenbus_init(void); 388 389 irqreturn_t xen_blkif_be_int(int irq, void *dev_id); 390 int xen_blkif_schedule(void *arg); 391 int xen_blkif_purge_persistent(void *arg); 392 void xen_blkbk_free_caches(struct xen_blkif *blkif); 393 394 int xen_blkbk_flush_diskcache(struct xenbus_transaction xbt, 395 struct backend_info *be, int state); 396 397 int xen_blkbk_barrier(struct xenbus_transaction xbt, 398 struct backend_info *be, int state); 399 struct xenbus_device *xen_blkbk_xenbus(struct backend_info *be); 400 void xen_blkbk_unmap_purged_grants(struct work_struct *work); 401 402 static inline void blkif_get_x86_32_req(struct blkif_request *dst, 403 struct blkif_x86_32_request *src) 404 { 405 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST, j; 406 dst->operation = src->operation; 407 switch (src->operation) { 408 case BLKIF_OP_READ: 409 case BLKIF_OP_WRITE: 410 case BLKIF_OP_WRITE_BARRIER: 411 case BLKIF_OP_FLUSH_DISKCACHE: 412 dst->u.rw.nr_segments = src->u.rw.nr_segments; 413 dst->u.rw.handle = src->u.rw.handle; 414 dst->u.rw.id = src->u.rw.id; 415 dst->u.rw.sector_number = src->u.rw.sector_number; 416 barrier(); 417 if (n > dst->u.rw.nr_segments) 418 n = dst->u.rw.nr_segments; 419 for (i = 0; i < n; i++) 420 dst->u.rw.seg[i] = src->u.rw.seg[i]; 421 break; 422 case BLKIF_OP_DISCARD: 423 dst->u.discard.flag = src->u.discard.flag; 424 dst->u.discard.id = src->u.discard.id; 425 dst->u.discard.sector_number = src->u.discard.sector_number; 426 dst->u.discard.nr_sectors = src->u.discard.nr_sectors; 427 break; 428 case BLKIF_OP_INDIRECT: 429 dst->u.indirect.indirect_op = src->u.indirect.indirect_op; 430 dst->u.indirect.nr_segments = src->u.indirect.nr_segments; 431 dst->u.indirect.handle = src->u.indirect.handle; 432 dst->u.indirect.id = src->u.indirect.id; 433 dst->u.indirect.sector_number = src->u.indirect.sector_number; 434 barrier(); 435 j = min(MAX_INDIRECT_PAGES, INDIRECT_PAGES(dst->u.indirect.nr_segments)); 436 for (i = 0; i < j; i++) 437 dst->u.indirect.indirect_grefs[i] = 438 src->u.indirect.indirect_grefs[i]; 439 break; 440 default: 441 /* 442 * Don't know how to translate this op. Only get the 443 * ID so failure can be reported to the frontend. 444 */ 445 dst->u.other.id = src->u.other.id; 446 break; 447 } 448 } 449 450 static inline void blkif_get_x86_64_req(struct blkif_request *dst, 451 struct blkif_x86_64_request *src) 452 { 453 int i, n = BLKIF_MAX_SEGMENTS_PER_REQUEST, j; 454 dst->operation = src->operation; 455 switch (src->operation) { 456 case BLKIF_OP_READ: 457 case BLKIF_OP_WRITE: 458 case BLKIF_OP_WRITE_BARRIER: 459 case BLKIF_OP_FLUSH_DISKCACHE: 460 dst->u.rw.nr_segments = src->u.rw.nr_segments; 461 dst->u.rw.handle = src->u.rw.handle; 462 dst->u.rw.id = src->u.rw.id; 463 dst->u.rw.sector_number = src->u.rw.sector_number; 464 barrier(); 465 if (n > dst->u.rw.nr_segments) 466 n = dst->u.rw.nr_segments; 467 for (i = 0; i < n; i++) 468 dst->u.rw.seg[i] = src->u.rw.seg[i]; 469 break; 470 case BLKIF_OP_DISCARD: 471 dst->u.discard.flag = src->u.discard.flag; 472 dst->u.discard.id = src->u.discard.id; 473 dst->u.discard.sector_number = src->u.discard.sector_number; 474 dst->u.discard.nr_sectors = src->u.discard.nr_sectors; 475 break; 476 case BLKIF_OP_INDIRECT: 477 dst->u.indirect.indirect_op = src->u.indirect.indirect_op; 478 dst->u.indirect.nr_segments = src->u.indirect.nr_segments; 479 dst->u.indirect.handle = src->u.indirect.handle; 480 dst->u.indirect.id = src->u.indirect.id; 481 dst->u.indirect.sector_number = src->u.indirect.sector_number; 482 barrier(); 483 j = min(MAX_INDIRECT_PAGES, INDIRECT_PAGES(dst->u.indirect.nr_segments)); 484 for (i = 0; i < j; i++) 485 dst->u.indirect.indirect_grefs[i] = 486 src->u.indirect.indirect_grefs[i]; 487 break; 488 default: 489 /* 490 * Don't know how to translate this op. Only get the 491 * ID so failure can be reported to the frontend. 492 */ 493 dst->u.other.id = src->u.other.id; 494 break; 495 } 496 } 497 498 #endif /* __XEN_BLKIF__BACKEND__COMMON_H__ */ 499