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/virtio_blk.h>
9 static unsigned char virtblk_index
= 'a';
14 struct virtio_device
*vdev
;
17 /* The disk structure for the kernel. */
20 /* Request tracking. */
21 struct list_head reqs
;
25 /* Scatterlist: can be too big for stack. */
26 struct scatterlist sg
[3+MAX_PHYS_SEGMENTS
];
31 struct list_head list
;
33 struct virtio_blk_outhdr out_hdr
;
34 struct virtio_blk_inhdr in_hdr
;
37 static bool blk_done(struct virtqueue
*vq
)
39 struct virtio_blk
*vblk
= vq
->vdev
->priv
;
40 struct virtblk_req
*vbr
;
44 spin_lock_irqsave(&vblk
->lock
, flags
);
45 while ((vbr
= vblk
->vq
->vq_ops
->get_buf(vblk
->vq
, &len
)) != NULL
) {
47 switch (vbr
->in_hdr
.status
) {
51 case VIRTIO_BLK_S_UNSUPP
:
59 end_dequeued_request(vbr
->req
, uptodate
);
61 mempool_free(vbr
, vblk
->pool
);
63 /* In case queue is stopped waiting for more buffers. */
64 blk_start_queue(vblk
->disk
->queue
);
65 spin_unlock_irqrestore(&vblk
->lock
, flags
);
69 static bool do_req(struct request_queue
*q
, struct virtio_blk
*vblk
,
72 unsigned long num
, out
, in
;
73 struct virtblk_req
*vbr
;
75 vbr
= mempool_alloc(vblk
->pool
, GFP_ATOMIC
);
77 /* When another request finishes we'll try again. */
81 if (blk_fs_request(vbr
->req
)) {
82 vbr
->out_hdr
.type
= 0;
83 vbr
->out_hdr
.sector
= vbr
->req
->sector
;
84 vbr
->out_hdr
.ioprio
= vbr
->req
->ioprio
;
85 } else if (blk_pc_request(vbr
->req
)) {
86 vbr
->out_hdr
.type
= VIRTIO_BLK_T_SCSI_CMD
;
87 vbr
->out_hdr
.sector
= 0;
88 vbr
->out_hdr
.ioprio
= vbr
->req
->ioprio
;
90 /* We don't put anything else in the queue. */
94 if (blk_barrier_rq(vbr
->req
))
95 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_BARRIER
;
97 /* We have to zero this, otherwise blk_rq_map_sg gets upset. */
98 memset(vblk
->sg
, 0, sizeof(vblk
->sg
));
99 sg_set_buf(&vblk
->sg
[0], &vbr
->out_hdr
, sizeof(vbr
->out_hdr
));
100 num
= blk_rq_map_sg(q
, vbr
->req
, vblk
->sg
+1);
101 sg_set_buf(&vblk
->sg
[num
+1], &vbr
->in_hdr
, sizeof(vbr
->in_hdr
));
103 if (rq_data_dir(vbr
->req
) == WRITE
) {
104 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_OUT
;
108 vbr
->out_hdr
.type
|= VIRTIO_BLK_T_IN
;
113 if (vblk
->vq
->vq_ops
->add_buf(vblk
->vq
, vblk
->sg
, out
, in
, vbr
)) {
114 mempool_free(vbr
, vblk
->pool
);
118 list_add_tail(&vbr
->list
, &vblk
->reqs
);
122 static void do_virtblk_request(struct request_queue
*q
)
124 struct virtio_blk
*vblk
= NULL
;
126 unsigned int issued
= 0;
128 while ((req
= elv_next_request(q
)) != NULL
) {
129 vblk
= req
->rq_disk
->private_data
;
130 BUG_ON(req
->nr_phys_segments
> ARRAY_SIZE(vblk
->sg
));
132 /* If this request fails, stop queue and wait for something to
133 finish to restart it. */
134 if (!do_req(q
, vblk
, req
)) {
138 blkdev_dequeue_request(req
);
143 vblk
->vq
->vq_ops
->kick(vblk
->vq
);
146 static int virtblk_ioctl(struct inode
*inode
, struct file
*filp
,
147 unsigned cmd
, unsigned long data
)
149 return scsi_cmd_ioctl(filp
, inode
->i_bdev
->bd_disk
->queue
,
150 inode
->i_bdev
->bd_disk
, cmd
,
151 (void __user
*)data
);
154 static struct block_device_operations virtblk_fops
= {
155 .ioctl
= virtblk_ioctl
,
156 .owner
= THIS_MODULE
,
159 static int virtblk_probe(struct virtio_device
*vdev
)
161 struct virtio_blk
*vblk
;
168 vdev
->priv
= vblk
= kmalloc(sizeof(*vblk
), GFP_KERNEL
);
174 INIT_LIST_HEAD(&vblk
->reqs
);
175 spin_lock_init(&vblk
->lock
);
178 /* We expect one virtqueue, for output. */
179 vblk
->vq
= vdev
->config
->find_vq(vdev
, blk_done
);
180 if (IS_ERR(vblk
->vq
)) {
181 err
= PTR_ERR(vblk
->vq
);
185 vblk
->pool
= mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req
));
191 major
= register_blkdev(0, "virtblk");
197 /* FIXME: How many partitions? How long is a piece of string? */
198 vblk
->disk
= alloc_disk(1 << 4);
201 goto out_unregister_blkdev
;
204 vblk
->disk
->queue
= blk_init_queue(do_virtblk_request
, &vblk
->lock
);
205 if (!vblk
->disk
->queue
) {
210 sprintf(vblk
->disk
->disk_name
, "vd%c", virtblk_index
++);
211 vblk
->disk
->major
= major
;
212 vblk
->disk
->first_minor
= 0;
213 vblk
->disk
->private_data
= vblk
;
214 vblk
->disk
->fops
= &virtblk_fops
;
216 /* If barriers are supported, tell block layer that queue is ordered */
217 token
= vdev
->config
->find(vdev
, VIRTIO_CONFIG_BLK_F
, &len
);
218 if (virtio_use_bit(vdev
, token
, len
, VIRTIO_BLK_F_BARRIER
))
219 blk_queue_ordered(vblk
->disk
->queue
, QUEUE_ORDERED_TAG
, NULL
);
221 err
= virtio_config_val(vdev
, VIRTIO_CONFIG_BLK_F_CAPACITY
, &cap
);
223 dev_err(&vdev
->dev
, "Bad/missing capacity in config\n");
227 /* If capacity is too big, truncate with warning. */
228 if ((sector_t
)cap
!= cap
) {
229 dev_warn(&vdev
->dev
, "Capacity %llu too large: truncating\n",
230 (unsigned long long)cap
);
233 set_capacity(vblk
->disk
, cap
);
235 err
= virtio_config_val(vdev
, VIRTIO_CONFIG_BLK_F_SIZE_MAX
, &v
);
237 blk_queue_max_segment_size(vblk
->disk
->queue
, v
);
238 else if (err
!= -ENOENT
) {
239 dev_err(&vdev
->dev
, "Bad SIZE_MAX in config\n");
243 err
= virtio_config_val(vdev
, VIRTIO_CONFIG_BLK_F_SEG_MAX
, &v
);
245 blk_queue_max_hw_segments(vblk
->disk
->queue
, v
);
246 else if (err
!= -ENOENT
) {
247 dev_err(&vdev
->dev
, "Bad SEG_MAX in config\n");
251 add_disk(vblk
->disk
);
255 put_disk(vblk
->disk
);
256 out_unregister_blkdev
:
257 unregister_blkdev(major
, "virtblk");
259 mempool_destroy(vblk
->pool
);
261 vdev
->config
->del_vq(vblk
->vq
);
268 static void virtblk_remove(struct virtio_device
*vdev
)
270 struct virtio_blk
*vblk
= vdev
->priv
;
271 int major
= vblk
->disk
->major
;
273 BUG_ON(!list_empty(&vblk
->reqs
));
274 blk_cleanup_queue(vblk
->disk
->queue
);
275 put_disk(vblk
->disk
);
276 unregister_blkdev(major
, "virtblk");
277 mempool_destroy(vblk
->pool
);
281 static struct virtio_device_id id_table
[] = {
282 { VIRTIO_ID_BLOCK
, VIRTIO_DEV_ANY_ID
},
286 static struct virtio_driver virtio_blk
= {
287 .driver
.name
= KBUILD_MODNAME
,
288 .driver
.owner
= THIS_MODULE
,
289 .id_table
= id_table
,
290 .probe
= virtblk_probe
,
291 .remove
= __devexit_p(virtblk_remove
),
294 static int __init
init(void)
296 return register_virtio_driver(&virtio_blk
);
299 static void __exit
fini(void)
301 unregister_virtio_driver(&virtio_blk
);
306 MODULE_DEVICE_TABLE(virtio
, id_table
);
307 MODULE_DESCRIPTION("Virtio block driver");
308 MODULE_LICENSE("GPL");