2 #include <linux/spinlock.h>
3 #include <linux/slab.h>
4 #include <linux/blkdev.h>
5 #include <linux/smp_lock.h>
6 #include <linux/hdreg.h>
7 #include <linux/virtio.h>
8 #include <linux/virtio_blk.h>
9 #include <linux/scatterlist.h>
13 static int major
, index
;
19 struct virtio_device
*vdev
;
22 /* The disk structure for the kernel. */
25 /* Request tracking. */
26 struct list_head reqs
;
30 /* What host tells us, plus 2 for header & tailer. */
31 unsigned int sg_elems
;
33 /* Scatterlist: can be too big for stack. */
34 struct scatterlist sg
[/*sg_elems*/];
39 struct list_head list
;
41 struct virtio_blk_outhdr out_hdr
;
42 struct virtio_scsi_inhdr in_hdr
;
46 static void blk_done(struct virtqueue
*vq
)
48 struct virtio_blk
*vblk
= vq
->vdev
->priv
;
49 struct virtblk_req
*vbr
;
53 spin_lock_irqsave(&vblk
->lock
, flags
);
54 while ((vbr
= virtqueue_get_buf(vblk
->vq
, &len
)) != NULL
) {
57 switch (vbr
->status
) {
61 case VIRTIO_BLK_S_UNSUPP
:
69 switch (vbr
->req
->cmd_type
) {
70 case REQ_TYPE_BLOCK_PC
:
71 vbr
->req
->resid_len
= vbr
->in_hdr
.residual
;
72 vbr
->req
->sense_len
= vbr
->in_hdr
.sense_len
;
73 vbr
->req
->errors
= vbr
->in_hdr
.errors
;
75 case REQ_TYPE_SPECIAL
:
76 vbr
->req
->errors
= (error
!= 0);
82 __blk_end_request_all(vbr
->req
, error
);
84 mempool_free(vbr
, vblk
->pool
);
86 /* In case queue is stopped waiting for more buffers. */
87 blk_start_queue(vblk
->disk
->queue
);
88 spin_unlock_irqrestore(&vblk
->lock
, flags
);
91 static bool do_req(struct request_queue
*q
, struct virtio_blk
*vblk
,
94 unsigned long num
, out
= 0, in
= 0;
95 struct virtblk_req
*vbr
;
97 vbr
= mempool_alloc(vblk
->pool
, GFP_ATOMIC
);
99 /* When another request finishes we'll try again. */
104 if (req
->cmd_flags
& REQ_FLUSH
) {
105 vbr
->out_hdr
.type
= VIRTIO_BLK_T_FLUSH
;
106 vbr
->out_hdr
.sector
= 0;
107 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
109 switch (req
->cmd_type
) {
111 vbr
->out_hdr
.type
= 0;
112 vbr
->out_hdr
.sector
= blk_rq_pos(vbr
->req
);
113 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
115 case REQ_TYPE_BLOCK_PC
:
116 vbr
->out_hdr
.type
= VIRTIO_BLK_T_SCSI_CMD
;
117 vbr
->out_hdr
.sector
= 0;
118 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
120 case REQ_TYPE_SPECIAL
:
121 vbr
->out_hdr
.type
= VIRTIO_BLK_T_GET_ID
;
122 vbr
->out_hdr
.sector
= 0;
123 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
126 /* We don't put anything else in the queue. */
131 if (vbr
->req
->cmd_flags
& REQ_HARDBARRIER
)
132 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_BARRIER
;
134 sg_set_buf(&vblk
->sg
[out
++], &vbr
->out_hdr
, sizeof(vbr
->out_hdr
));
137 * If this is a packet command we need a couple of additional headers.
138 * Behind the normal outhdr we put a segment with the scsi command
139 * block, and before the normal inhdr we put the sense data and the
140 * inhdr with additional status information before the normal inhdr.
142 if (vbr
->req
->cmd_type
== REQ_TYPE_BLOCK_PC
)
143 sg_set_buf(&vblk
->sg
[out
++], vbr
->req
->cmd
, vbr
->req
->cmd_len
);
145 num
= blk_rq_map_sg(q
, vbr
->req
, vblk
->sg
+ out
);
147 if (vbr
->req
->cmd_type
== REQ_TYPE_BLOCK_PC
) {
148 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], vbr
->req
->sense
, 96);
149 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], &vbr
->in_hdr
,
150 sizeof(vbr
->in_hdr
));
153 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], &vbr
->status
,
154 sizeof(vbr
->status
));
157 if (rq_data_dir(vbr
->req
) == WRITE
) {
158 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_OUT
;
161 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_IN
;
166 if (virtqueue_add_buf(vblk
->vq
, vblk
->sg
, out
, in
, vbr
) < 0) {
167 mempool_free(vbr
, vblk
->pool
);
171 list_add_tail(&vbr
->list
, &vblk
->reqs
);
175 static void do_virtblk_request(struct request_queue
*q
)
177 struct virtio_blk
*vblk
= q
->queuedata
;
179 unsigned int issued
= 0;
181 while ((req
= blk_peek_request(q
)) != NULL
) {
182 BUG_ON(req
->nr_phys_segments
+ 2 > vblk
->sg_elems
);
184 /* If this request fails, stop queue and wait for something to
185 finish to restart it. */
186 if (!do_req(q
, vblk
, req
)) {
190 blk_start_request(req
);
195 virtqueue_kick(vblk
->vq
);
198 /* return id (s/n) string for *disk to *id_str
200 static int virtblk_get_id(struct gendisk
*disk
, char *id_str
)
202 struct virtio_blk
*vblk
= disk
->private_data
;
207 bio
= bio_map_kern(vblk
->disk
->queue
, id_str
, VIRTIO_BLK_ID_BYTES
,
212 req
= blk_make_request(vblk
->disk
->queue
, bio
, GFP_KERNEL
);
218 req
->cmd_type
= REQ_TYPE_SPECIAL
;
219 err
= blk_execute_rq(vblk
->disk
->queue
, vblk
->disk
, req
, false);
220 blk_put_request(req
);
225 static int virtblk_locked_ioctl(struct block_device
*bdev
, fmode_t mode
,
226 unsigned cmd
, unsigned long data
)
228 struct gendisk
*disk
= bdev
->bd_disk
;
229 struct virtio_blk
*vblk
= disk
->private_data
;
232 * Only allow the generic SCSI ioctls if the host can support it.
234 if (!virtio_has_feature(vblk
->vdev
, VIRTIO_BLK_F_SCSI
))
237 return scsi_cmd_ioctl(disk
->queue
, disk
, mode
, cmd
,
238 (void __user
*)data
);
241 static int virtblk_ioctl(struct block_device
*bdev
, fmode_t mode
,
242 unsigned int cmd
, unsigned long param
)
247 ret
= virtblk_locked_ioctl(bdev
, mode
, cmd
, param
);
253 /* We provide getgeo only to please some old bootloader/partitioning tools */
254 static int virtblk_getgeo(struct block_device
*bd
, struct hd_geometry
*geo
)
256 struct virtio_blk
*vblk
= bd
->bd_disk
->private_data
;
257 struct virtio_blk_geometry vgeo
;
260 /* see if the host passed in geometry config */
261 err
= virtio_config_val(vblk
->vdev
, VIRTIO_BLK_F_GEOMETRY
,
262 offsetof(struct virtio_blk_config
, geometry
),
266 geo
->heads
= vgeo
.heads
;
267 geo
->sectors
= vgeo
.sectors
;
268 geo
->cylinders
= vgeo
.cylinders
;
270 /* some standard values, similar to sd */
272 geo
->sectors
= 1 << 5;
273 geo
->cylinders
= get_capacity(bd
->bd_disk
) >> 11;
278 static const struct block_device_operations virtblk_fops
= {
279 .ioctl
= virtblk_ioctl
,
280 .owner
= THIS_MODULE
,
281 .getgeo
= virtblk_getgeo
,
284 static int index_to_minor(int index
)
286 return index
<< PART_BITS
;
289 static ssize_t
virtblk_serial_show(struct device
*dev
,
290 struct device_attribute
*attr
, char *buf
)
292 struct gendisk
*disk
= dev_to_disk(dev
);
295 /* sysfs gives us a PAGE_SIZE buffer */
296 BUILD_BUG_ON(PAGE_SIZE
< VIRTIO_BLK_ID_BYTES
);
298 buf
[VIRTIO_BLK_ID_BYTES
] = '\0';
299 err
= virtblk_get_id(disk
, buf
);
303 if (err
== -EIO
) /* Unsupported? Make it empty. */
308 DEVICE_ATTR(serial
, S_IRUGO
, virtblk_serial_show
, NULL
);
310 static int __devinit
virtblk_probe(struct virtio_device
*vdev
)
312 struct virtio_blk
*vblk
;
313 struct request_queue
*q
;
316 u32 v
, blk_size
, sg_elems
, opt_io_size
;
318 u8 physical_block_exp
, alignment_offset
;
320 if (index_to_minor(index
) >= 1 << MINORBITS
)
323 /* We need to know how many segments before we allocate. */
324 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_SEG_MAX
,
325 offsetof(struct virtio_blk_config
, seg_max
),
328 /* We need at least one SG element, whatever they say. */
329 if (err
|| !sg_elems
)
332 /* We need an extra sg elements at head and tail. */
334 vdev
->priv
= vblk
= kmalloc(sizeof(*vblk
) +
335 sizeof(vblk
->sg
[0]) * sg_elems
, GFP_KERNEL
);
341 INIT_LIST_HEAD(&vblk
->reqs
);
342 spin_lock_init(&vblk
->lock
);
344 vblk
->sg_elems
= sg_elems
;
345 sg_init_table(vblk
->sg
, vblk
->sg_elems
);
347 /* We expect one virtqueue, for output. */
348 vblk
->vq
= virtio_find_single_vq(vdev
, blk_done
, "requests");
349 if (IS_ERR(vblk
->vq
)) {
350 err
= PTR_ERR(vblk
->vq
);
354 vblk
->pool
= mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req
));
360 /* FIXME: How many partitions? How long is a piece of string? */
361 vblk
->disk
= alloc_disk(1 << PART_BITS
);
367 q
= vblk
->disk
->queue
= blk_init_queue(do_virtblk_request
, &vblk
->lock
);
376 sprintf(vblk
->disk
->disk_name
, "vd%c", 'a' + index
% 26);
377 } else if (index
< (26 + 1) * 26) {
378 sprintf(vblk
->disk
->disk_name
, "vd%c%c",
379 'a' + index
/ 26 - 1, 'a' + index
% 26);
381 const unsigned int m1
= (index
/ 26 - 1) / 26 - 1;
382 const unsigned int m2
= (index
/ 26 - 1) % 26;
383 const unsigned int m3
= index
% 26;
384 sprintf(vblk
->disk
->disk_name
, "vd%c%c%c",
385 'a' + m1
, 'a' + m2
, 'a' + m3
);
388 vblk
->disk
->major
= major
;
389 vblk
->disk
->first_minor
= index_to_minor(index
);
390 vblk
->disk
->private_data
= vblk
;
391 vblk
->disk
->fops
= &virtblk_fops
;
392 vblk
->disk
->driverfs_dev
= &vdev
->dev
;
395 if (virtio_has_feature(vdev
, VIRTIO_BLK_F_FLUSH
)) {
397 * If the FLUSH feature is supported we do have support for
398 * flushing a volatile write cache on the host. Use that
399 * to implement write barrier support.
401 blk_queue_ordered(q
, QUEUE_ORDERED_DRAIN_FLUSH
);
402 } else if (virtio_has_feature(vdev
, VIRTIO_BLK_F_BARRIER
)) {
404 * If the BARRIER feature is supported the host expects us
405 * to order request by tags. This implies there is not
406 * volatile write cache on the host, and that the host
407 * never re-orders outstanding I/O. This feature is not
408 * useful for real life scenarious and deprecated.
410 blk_queue_ordered(q
, QUEUE_ORDERED_TAG
);
413 * If the FLUSH feature is not supported we must assume that
414 * the host does not perform any kind of volatile write
415 * caching. We still need to drain the queue to provider
416 * proper barrier semantics.
418 blk_queue_ordered(q
, QUEUE_ORDERED_DRAIN
);
421 /* If disk is read-only in the host, the guest should obey */
422 if (virtio_has_feature(vdev
, VIRTIO_BLK_F_RO
))
423 set_disk_ro(vblk
->disk
, 1);
425 /* Host must always specify the capacity. */
426 vdev
->config
->get(vdev
, offsetof(struct virtio_blk_config
, capacity
),
429 /* If capacity is too big, truncate with warning. */
430 if ((sector_t
)cap
!= cap
) {
431 dev_warn(&vdev
->dev
, "Capacity %llu too large: truncating\n",
432 (unsigned long long)cap
);
435 set_capacity(vblk
->disk
, cap
);
437 /* We can handle whatever the host told us to handle. */
438 blk_queue_max_segments(q
, vblk
->sg_elems
-2);
440 /* No need to bounce any requests */
441 blk_queue_bounce_limit(q
, BLK_BOUNCE_ANY
);
443 /* No real sector limit. */
444 blk_queue_max_hw_sectors(q
, -1U);
446 /* Host can optionally specify maximum segment size and number of
448 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_SIZE_MAX
,
449 offsetof(struct virtio_blk_config
, size_max
),
452 blk_queue_max_segment_size(q
, v
);
454 blk_queue_max_segment_size(q
, -1U);
456 /* Host can optionally specify the block size of the device */
457 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_BLK_SIZE
,
458 offsetof(struct virtio_blk_config
, blk_size
),
461 blk_queue_logical_block_size(q
, blk_size
);
463 blk_size
= queue_logical_block_size(q
);
465 /* Use topology information if available */
466 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_TOPOLOGY
,
467 offsetof(struct virtio_blk_config
, physical_block_exp
),
468 &physical_block_exp
);
469 if (!err
&& physical_block_exp
)
470 blk_queue_physical_block_size(q
,
471 blk_size
* (1 << physical_block_exp
));
473 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_TOPOLOGY
,
474 offsetof(struct virtio_blk_config
, alignment_offset
),
476 if (!err
&& alignment_offset
)
477 blk_queue_alignment_offset(q
, blk_size
* alignment_offset
);
479 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_TOPOLOGY
,
480 offsetof(struct virtio_blk_config
, min_io_size
),
482 if (!err
&& min_io_size
)
483 blk_queue_io_min(q
, blk_size
* min_io_size
);
485 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_TOPOLOGY
,
486 offsetof(struct virtio_blk_config
, opt_io_size
),
488 if (!err
&& opt_io_size
)
489 blk_queue_io_opt(q
, blk_size
* opt_io_size
);
492 add_disk(vblk
->disk
);
493 err
= device_create_file(disk_to_dev(vblk
->disk
), &dev_attr_serial
);
500 del_gendisk(vblk
->disk
);
501 blk_cleanup_queue(vblk
->disk
->queue
);
503 put_disk(vblk
->disk
);
505 mempool_destroy(vblk
->pool
);
507 vdev
->config
->del_vqs(vdev
);
514 static void __devexit
virtblk_remove(struct virtio_device
*vdev
)
516 struct virtio_blk
*vblk
= vdev
->priv
;
518 /* Nothing should be pending. */
519 BUG_ON(!list_empty(&vblk
->reqs
));
521 /* Stop all the virtqueues. */
522 vdev
->config
->reset(vdev
);
524 del_gendisk(vblk
->disk
);
525 blk_cleanup_queue(vblk
->disk
->queue
);
526 put_disk(vblk
->disk
);
527 mempool_destroy(vblk
->pool
);
528 vdev
->config
->del_vqs(vdev
);
532 static const struct virtio_device_id id_table
[] = {
533 { VIRTIO_ID_BLOCK
, VIRTIO_DEV_ANY_ID
},
537 static unsigned int features
[] = {
538 VIRTIO_BLK_F_BARRIER
, VIRTIO_BLK_F_SEG_MAX
, VIRTIO_BLK_F_SIZE_MAX
,
539 VIRTIO_BLK_F_GEOMETRY
, VIRTIO_BLK_F_RO
, VIRTIO_BLK_F_BLK_SIZE
,
540 VIRTIO_BLK_F_SCSI
, VIRTIO_BLK_F_FLUSH
, VIRTIO_BLK_F_TOPOLOGY
544 * virtio_blk causes spurious section mismatch warning by
545 * simultaneously referring to a __devinit and a __devexit function.
546 * Use __refdata to avoid this warning.
548 static struct virtio_driver __refdata virtio_blk
= {
549 .feature_table
= features
,
550 .feature_table_size
= ARRAY_SIZE(features
),
551 .driver
.name
= KBUILD_MODNAME
,
552 .driver
.owner
= THIS_MODULE
,
553 .id_table
= id_table
,
554 .probe
= virtblk_probe
,
555 .remove
= __devexit_p(virtblk_remove
),
558 static int __init
init(void)
560 major
= register_blkdev(0, "virtblk");
563 return register_virtio_driver(&virtio_blk
);
566 static void __exit
fini(void)
568 unregister_blkdev(major
, "virtblk");
569 unregister_virtio_driver(&virtio_blk
);
574 MODULE_DEVICE_TABLE(virtio
, id_table
);
575 MODULE_DESCRIPTION("Virtio block driver");
576 MODULE_LICENSE("GPL");