2 #include <linux/spinlock.h>
3 #include <linux/blkdev.h>
4 #include <linux/hdreg.h>
5 #include <linux/virtio.h>
6 #include <linux/virtio_blk.h>
7 #include <linux/scatterlist.h>
11 static int major
, index
;
17 struct virtio_device
*vdev
;
20 /* The disk structure for the kernel. */
23 /* Request tracking. */
24 struct list_head reqs
;
28 /* What host tells us, plus 2 for header & tailer. */
29 unsigned int sg_elems
;
31 /* Scatterlist: can be too big for stack. */
32 struct scatterlist sg
[/*sg_elems*/];
37 struct list_head list
;
39 struct virtio_blk_outhdr out_hdr
;
40 struct virtio_scsi_inhdr in_hdr
;
44 static void blk_done(struct virtqueue
*vq
)
46 struct virtio_blk
*vblk
= vq
->vdev
->priv
;
47 struct virtblk_req
*vbr
;
51 spin_lock_irqsave(&vblk
->lock
, flags
);
52 while ((vbr
= vblk
->vq
->vq_ops
->get_buf(vblk
->vq
, &len
)) != NULL
) {
53 unsigned int nr_bytes
;
56 switch (vbr
->status
) {
60 case VIRTIO_BLK_S_UNSUPP
:
68 if (blk_pc_request(vbr
->req
)) {
69 vbr
->req
->resid_len
= vbr
->in_hdr
.residual
;
70 vbr
->req
->sense_len
= vbr
->in_hdr
.sense_len
;
71 vbr
->req
->errors
= vbr
->in_hdr
.errors
;
74 __blk_end_request_all(vbr
->req
, error
);
76 mempool_free(vbr
, vblk
->pool
);
78 /* In case queue is stopped waiting for more buffers. */
79 blk_start_queue(vblk
->disk
->queue
);
80 spin_unlock_irqrestore(&vblk
->lock
, flags
);
83 static bool do_req(struct request_queue
*q
, struct virtio_blk
*vblk
,
86 unsigned long num
, out
= 0, in
= 0;
87 struct virtblk_req
*vbr
;
89 vbr
= mempool_alloc(vblk
->pool
, GFP_ATOMIC
);
91 /* When another request finishes we'll try again. */
95 if (blk_fs_request(vbr
->req
)) {
96 vbr
->out_hdr
.type
= 0;
97 vbr
->out_hdr
.sector
= blk_rq_pos(vbr
->req
);
98 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
99 } else if (blk_pc_request(vbr
->req
)) {
100 vbr
->out_hdr
.type
= VIRTIO_BLK_T_SCSI_CMD
;
101 vbr
->out_hdr
.sector
= 0;
102 vbr
->out_hdr
.ioprio
= req_get_ioprio(vbr
->req
);
104 /* We don't put anything else in the queue. */
108 if (blk_barrier_rq(vbr
->req
))
109 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_BARRIER
;
111 sg_set_buf(&vblk
->sg
[out
++], &vbr
->out_hdr
, sizeof(vbr
->out_hdr
));
114 * If this is a packet command we need a couple of additional headers.
115 * Behind the normal outhdr we put a segment with the scsi command
116 * block, and before the normal inhdr we put the sense data and the
117 * inhdr with additional status information before the normal inhdr.
119 if (blk_pc_request(vbr
->req
))
120 sg_set_buf(&vblk
->sg
[out
++], vbr
->req
->cmd
, vbr
->req
->cmd_len
);
122 num
= blk_rq_map_sg(q
, vbr
->req
, vblk
->sg
+ out
);
124 if (blk_pc_request(vbr
->req
)) {
125 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], vbr
->req
->sense
, 96);
126 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], &vbr
->in_hdr
,
127 sizeof(vbr
->in_hdr
));
130 sg_set_buf(&vblk
->sg
[num
+ out
+ in
++], &vbr
->status
,
131 sizeof(vbr
->status
));
134 if (rq_data_dir(vbr
->req
) == WRITE
) {
135 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_OUT
;
138 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_IN
;
143 if (vblk
->vq
->vq_ops
->add_buf(vblk
->vq
, vblk
->sg
, out
, in
, vbr
)) {
144 mempool_free(vbr
, vblk
->pool
);
148 list_add_tail(&vbr
->list
, &vblk
->reqs
);
152 static void do_virtblk_request(struct request_queue
*q
)
154 struct virtio_blk
*vblk
= q
->queuedata
;
156 unsigned int issued
= 0;
158 while ((req
= blk_peek_request(q
)) != NULL
) {
159 BUG_ON(req
->nr_phys_segments
+ 2 > vblk
->sg_elems
);
161 /* If this request fails, stop queue and wait for something to
162 finish to restart it. */
163 if (!do_req(q
, vblk
, req
)) {
167 blk_start_request(req
);
172 vblk
->vq
->vq_ops
->kick(vblk
->vq
);
175 static int virtblk_ioctl(struct block_device
*bdev
, fmode_t mode
,
176 unsigned cmd
, unsigned long data
)
178 struct gendisk
*disk
= bdev
->bd_disk
;
179 struct virtio_blk
*vblk
= disk
->private_data
;
182 * Only allow the generic SCSI ioctls if the host can support it.
184 if (!virtio_has_feature(vblk
->vdev
, VIRTIO_BLK_F_SCSI
))
187 return scsi_cmd_ioctl(disk
->queue
, disk
, mode
, cmd
,
188 (void __user
*)data
);
191 /* We provide getgeo only to please some old bootloader/partitioning tools */
192 static int virtblk_getgeo(struct block_device
*bd
, struct hd_geometry
*geo
)
194 struct virtio_blk
*vblk
= bd
->bd_disk
->private_data
;
195 struct virtio_blk_geometry vgeo
;
198 /* see if the host passed in geometry config */
199 err
= virtio_config_val(vblk
->vdev
, VIRTIO_BLK_F_GEOMETRY
,
200 offsetof(struct virtio_blk_config
, geometry
),
204 geo
->heads
= vgeo
.heads
;
205 geo
->sectors
= vgeo
.sectors
;
206 geo
->cylinders
= vgeo
.cylinders
;
208 /* some standard values, similar to sd */
210 geo
->sectors
= 1 << 5;
211 geo
->cylinders
= get_capacity(bd
->bd_disk
) >> 11;
216 static struct block_device_operations virtblk_fops
= {
217 .locked_ioctl
= virtblk_ioctl
,
218 .owner
= THIS_MODULE
,
219 .getgeo
= virtblk_getgeo
,
222 static int index_to_minor(int index
)
224 return index
<< PART_BITS
;
227 static int virtblk_probe(struct virtio_device
*vdev
)
229 struct virtio_blk
*vblk
;
233 u32 blk_size
, sg_elems
;
235 if (index_to_minor(index
) >= 1 << MINORBITS
)
238 /* We need to know how many segments before we allocate. */
239 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_SEG_MAX
,
240 offsetof(struct virtio_blk_config
, seg_max
),
245 /* We need an extra sg elements at head and tail. */
247 vdev
->priv
= vblk
= kmalloc(sizeof(*vblk
) +
248 sizeof(vblk
->sg
[0]) * sg_elems
, GFP_KERNEL
);
254 INIT_LIST_HEAD(&vblk
->reqs
);
255 spin_lock_init(&vblk
->lock
);
257 vblk
->sg_elems
= sg_elems
;
258 sg_init_table(vblk
->sg
, vblk
->sg_elems
);
260 /* We expect one virtqueue, for output. */
261 vblk
->vq
= vdev
->config
->find_vq(vdev
, 0, blk_done
);
262 if (IS_ERR(vblk
->vq
)) {
263 err
= PTR_ERR(vblk
->vq
);
267 vblk
->pool
= mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req
));
273 /* FIXME: How many partitions? How long is a piece of string? */
274 vblk
->disk
= alloc_disk(1 << PART_BITS
);
280 vblk
->disk
->queue
= blk_init_queue(do_virtblk_request
, &vblk
->lock
);
281 if (!vblk
->disk
->queue
) {
286 vblk
->disk
->queue
->queuedata
= vblk
;
287 queue_flag_set_unlocked(QUEUE_FLAG_VIRT
, vblk
->disk
->queue
);
290 sprintf(vblk
->disk
->disk_name
, "vd%c", 'a' + index
% 26);
291 } else if (index
< (26 + 1) * 26) {
292 sprintf(vblk
->disk
->disk_name
, "vd%c%c",
293 'a' + index
/ 26 - 1, 'a' + index
% 26);
295 const unsigned int m1
= (index
/ 26 - 1) / 26 - 1;
296 const unsigned int m2
= (index
/ 26 - 1) % 26;
297 const unsigned int m3
= index
% 26;
298 sprintf(vblk
->disk
->disk_name
, "vd%c%c%c",
299 'a' + m1
, 'a' + m2
, 'a' + m3
);
302 vblk
->disk
->major
= major
;
303 vblk
->disk
->first_minor
= index_to_minor(index
);
304 vblk
->disk
->private_data
= vblk
;
305 vblk
->disk
->fops
= &virtblk_fops
;
306 vblk
->disk
->driverfs_dev
= &vdev
->dev
;
309 /* If barriers are supported, tell block layer that queue is ordered */
310 if (virtio_has_feature(vdev
, VIRTIO_BLK_F_BARRIER
))
311 blk_queue_ordered(vblk
->disk
->queue
, QUEUE_ORDERED_TAG
, NULL
);
313 /* If disk is read-only in the host, the guest should obey */
314 if (virtio_has_feature(vdev
, VIRTIO_BLK_F_RO
))
315 set_disk_ro(vblk
->disk
, 1);
317 /* Host must always specify the capacity. */
318 vdev
->config
->get(vdev
, offsetof(struct virtio_blk_config
, capacity
),
321 /* If capacity is too big, truncate with warning. */
322 if ((sector_t
)cap
!= cap
) {
323 dev_warn(&vdev
->dev
, "Capacity %llu too large: truncating\n",
324 (unsigned long long)cap
);
327 set_capacity(vblk
->disk
, cap
);
329 /* We can handle whatever the host told us to handle. */
330 blk_queue_max_phys_segments(vblk
->disk
->queue
, vblk
->sg_elems
-2);
331 blk_queue_max_hw_segments(vblk
->disk
->queue
, vblk
->sg_elems
-2);
333 /* No real sector limit. */
334 blk_queue_max_sectors(vblk
->disk
->queue
, -1U);
336 /* Host can optionally specify maximum segment size and number of
338 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_SIZE_MAX
,
339 offsetof(struct virtio_blk_config
, size_max
),
342 blk_queue_max_segment_size(vblk
->disk
->queue
, v
);
344 blk_queue_max_segment_size(vblk
->disk
->queue
, -1U);
346 /* Host can optionally specify the block size of the device */
347 err
= virtio_config_val(vdev
, VIRTIO_BLK_F_BLK_SIZE
,
348 offsetof(struct virtio_blk_config
, blk_size
),
351 blk_queue_hardsect_size(vblk
->disk
->queue
, blk_size
);
353 add_disk(vblk
->disk
);
357 put_disk(vblk
->disk
);
359 mempool_destroy(vblk
->pool
);
361 vdev
->config
->del_vq(vblk
->vq
);
368 static void virtblk_remove(struct virtio_device
*vdev
)
370 struct virtio_blk
*vblk
= vdev
->priv
;
372 /* Nothing should be pending. */
373 BUG_ON(!list_empty(&vblk
->reqs
));
375 /* Stop all the virtqueues. */
376 vdev
->config
->reset(vdev
);
378 del_gendisk(vblk
->disk
);
379 blk_cleanup_queue(vblk
->disk
->queue
);
380 put_disk(vblk
->disk
);
381 mempool_destroy(vblk
->pool
);
382 vdev
->config
->del_vq(vblk
->vq
);
386 static struct virtio_device_id id_table
[] = {
387 { VIRTIO_ID_BLOCK
, VIRTIO_DEV_ANY_ID
},
391 static unsigned int features
[] = {
392 VIRTIO_BLK_F_BARRIER
, VIRTIO_BLK_F_SEG_MAX
, VIRTIO_BLK_F_SIZE_MAX
,
393 VIRTIO_BLK_F_GEOMETRY
, VIRTIO_BLK_F_RO
, VIRTIO_BLK_F_BLK_SIZE
,
397 static struct virtio_driver virtio_blk
= {
398 .feature_table
= features
,
399 .feature_table_size
= ARRAY_SIZE(features
),
400 .driver
.name
= KBUILD_MODNAME
,
401 .driver
.owner
= THIS_MODULE
,
402 .id_table
= id_table
,
403 .probe
= virtblk_probe
,
404 .remove
= __devexit_p(virtblk_remove
),
407 static int __init
init(void)
409 major
= register_blkdev(0, "virtblk");
412 return register_virtio_driver(&virtio_blk
);
415 static void __exit
fini(void)
417 unregister_blkdev(major
, "virtblk");
418 unregister_virtio_driver(&virtio_blk
);
423 MODULE_DEVICE_TABLE(virtio
, id_table
);
424 MODULE_DESCRIPTION("Virtio block driver");
425 MODULE_LICENSE("GPL");