virtio_blk.c revision 4b7f7e2049956f6e946ad56c1ee093e7bab74da9 
1//#define DEBUG
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>
8
9#define VIRTIO_MAX_SG	(3+MAX_PHYS_SEGMENTS)
10#define PART_BITS 4
11
12static int major, index;
13
14struct virtio_blk
15{
16	spinlock_t lock;
17
18	struct virtio_device *vdev;
19	struct virtqueue *vq;
20
21	/* The disk structure for the kernel. */
22	struct gendisk *disk;
23
24	/* Request tracking. */
25	struct list_head reqs;
26
27	mempool_t *pool;
28
29	/* Scatterlist: can be too big for stack. */
30	struct scatterlist sg[VIRTIO_MAX_SG];
31};
32
33struct virtblk_req
34{
35	struct list_head list;
36	struct request *req;
37	struct virtio_blk_outhdr out_hdr;
38	u8 status;
39};
40
41static void blk_done(struct virtqueue *vq)
42{
43	struct virtio_blk *vblk = vq->vdev->priv;
44	struct virtblk_req *vbr;
45	unsigned int len;
46	unsigned long flags;
47
48	spin_lock_irqsave(&vblk->lock, flags);
49	while ((vbr = vblk->vq->vq_ops->get_buf(vblk->vq, &len)) != NULL) {
50		int error;
51		switch (vbr->status) {
52		case VIRTIO_BLK_S_OK:
53			error = 0;
54			break;
55		case VIRTIO_BLK_S_UNSUPP:
56			error = -ENOTTY;
57			break;
58		default:
59			error = -EIO;
60			break;
61		}
62
63		__blk_end_request(vbr->req, error, blk_rq_bytes(vbr->req));
64		list_del(&vbr->list);
65		mempool_free(vbr, vblk->pool);
66	}
67	/* In case queue is stopped waiting for more buffers. */
68	blk_start_queue(vblk->disk->queue);
69	spin_unlock_irqrestore(&vblk->lock, flags);
70}
71
72static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
73		   struct request *req)
74{
75	unsigned long num, out, in;
76	struct virtblk_req *vbr;
77
78	vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
79	if (!vbr)
80		/* When another request finishes we'll try again. */
81		return false;
82
83	vbr->req = req;
84	if (blk_fs_request(vbr->req)) {
85		vbr->out_hdr.type = 0;
86		vbr->out_hdr.sector = vbr->req->sector;
87		vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
88	} else if (blk_pc_request(vbr->req)) {
89		vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
90		vbr->out_hdr.sector = 0;
91		vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
92	} else {
93		/* We don't put anything else in the queue. */
94		BUG();
95	}
96
97	if (blk_barrier_rq(vbr->req))
98		vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
99
100	/* This init could be done at vblk creation time */
101	sg_init_table(vblk->sg, VIRTIO_MAX_SG);
102	sg_set_buf(&vblk->sg[0], &vbr->out_hdr, sizeof(vbr->out_hdr));
103	num = blk_rq_map_sg(q, vbr->req, vblk->sg+1);
104	sg_set_buf(&vblk->sg[num+1], &vbr->status, sizeof(vbr->status));
105
106	if (rq_data_dir(vbr->req) == WRITE) {
107		vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
108		out = 1 + num;
109		in = 1;
110	} else {
111		vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
112		out = 1;
113		in = 1 + num;
114	}
115
116	if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr)) {
117		mempool_free(vbr, vblk->pool);
118		return false;
119	}
120
121	list_add_tail(&vbr->list, &vblk->reqs);
122	return true;
123}
124
125static void do_virtblk_request(struct request_queue *q)
126{
127	struct virtio_blk *vblk = NULL;
128	struct request *req;
129	unsigned int issued = 0;
130
131	while ((req = elv_next_request(q)) != NULL) {
132		vblk = req->rq_disk->private_data;
133		BUG_ON(req->nr_phys_segments > ARRAY_SIZE(vblk->sg));
134
135		/* If this request fails, stop queue and wait for something to
136		   finish to restart it. */
137		if (!do_req(q, vblk, req)) {
138			blk_stop_queue(q);
139			break;
140		}
141		blkdev_dequeue_request(req);
142		issued++;
143	}
144
145	if (issued)
146		vblk->vq->vq_ops->kick(vblk->vq);
147}
148
149static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
150			 unsigned cmd, unsigned long data)
151{
152	return scsi_cmd_ioctl(bdev->bd_disk->queue,
153			      bdev->bd_disk, mode, cmd,
154			      (void __user *)data);
155}
156
157/* We provide getgeo only to please some old bootloader/partitioning tools */
158static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
159{
160	struct virtio_blk *vblk = bd->bd_disk->private_data;
161	struct virtio_blk_geometry vgeo;
162	int err;
163
164	/* see if the host passed in geometry config */
165	err = virtio_config_val(vblk->vdev, VIRTIO_BLK_F_GEOMETRY,
166				offsetof(struct virtio_blk_config, geometry),
167				&vgeo);
168
169	if (!err) {
170		geo->heads = vgeo.heads;
171		geo->sectors = vgeo.sectors;
172		geo->cylinders = vgeo.cylinders;
173	} else {
174		/* some standard values, similar to sd */
175		geo->heads = 1 << 6;
176		geo->sectors = 1 << 5;
177		geo->cylinders = get_capacity(bd->bd_disk) >> 11;
178	}
179	return 0;
180}
181
182static struct block_device_operations virtblk_fops = {
183	.locked_ioctl = virtblk_ioctl,
184	.owner  = THIS_MODULE,
185	.getgeo = virtblk_getgeo,
186};
187
188static int index_to_minor(int index)
189{
190	return index << PART_BITS;
191}
192
193static int virtblk_probe(struct virtio_device *vdev)
194{
195	struct virtio_blk *vblk;
196	int err;
197	u64 cap;
198	u32 v;
199	u32 blk_size;
200
201	if (index_to_minor(index) >= 1 << MINORBITS)
202		return -ENOSPC;
203
204	vdev->priv = vblk = kmalloc(sizeof(*vblk), GFP_KERNEL);
205	if (!vblk) {
206		err = -ENOMEM;
207		goto out;
208	}
209
210	INIT_LIST_HEAD(&vblk->reqs);
211	spin_lock_init(&vblk->lock);
212	vblk->vdev = vdev;
213
214	/* We expect one virtqueue, for output. */
215	vblk->vq = vdev->config->find_vq(vdev, 0, blk_done);
216	if (IS_ERR(vblk->vq)) {
217		err = PTR_ERR(vblk->vq);
218		goto out_free_vblk;
219	}
220
221	vblk->pool = mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req));
222	if (!vblk->pool) {
223		err = -ENOMEM;
224		goto out_free_vq;
225	}
226
227	/* FIXME: How many partitions?  How long is a piece of string? */
228	vblk->disk = alloc_disk(1 << PART_BITS);
229	if (!vblk->disk) {
230		err = -ENOMEM;
231		goto out_mempool;
232	}
233
234	vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
235	if (!vblk->disk->queue) {
236		err = -ENOMEM;
237		goto out_put_disk;
238	}
239
240	if (index < 26) {
241		sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
242	} else if (index < (26 + 1) * 26) {
243		sprintf(vblk->disk->disk_name, "vd%c%c",
244			'a' + index / 26 - 1, 'a' + index % 26);
245	} else {
246		const unsigned int m1 = (index / 26 - 1) / 26 - 1;
247		const unsigned int m2 = (index / 26 - 1) % 26;
248		const unsigned int m3 =  index % 26;
249		sprintf(vblk->disk->disk_name, "vd%c%c%c",
250			'a' + m1, 'a' + m2, 'a' + m3);
251	}
252
253	vblk->disk->major = major;
254	vblk->disk->first_minor = index_to_minor(index);
255	vblk->disk->private_data = vblk;
256	vblk->disk->fops = &virtblk_fops;
257	vblk->disk->driverfs_dev = &vdev->dev;
258	index++;
259
260	/* If barriers are supported, tell block layer that queue is ordered */
261	if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))
262		blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_TAG, NULL);
263
264	/* If disk is read-only in the host, the guest should obey */
265	if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
266		set_disk_ro(vblk->disk, 1);
267
268	/* Host must always specify the capacity. */
269	vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
270			  &cap, sizeof(cap));
271
272	/* If capacity is too big, truncate with warning. */
273	if ((sector_t)cap != cap) {
274		dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
275			 (unsigned long long)cap);
276		cap = (sector_t)-1;
277	}
278	set_capacity(vblk->disk, cap);
279
280	/* No real sector limit. */
281	blk_queue_max_sectors(vblk->disk->queue, -1U);
282
283	/* Host can optionally specify maximum segment size and number of
284	 * segments. */
285	err = virtio_config_val(vdev, VIRTIO_BLK_F_SIZE_MAX,
286				offsetof(struct virtio_blk_config, size_max),
287				&v);
288	if (!err)
289		blk_queue_max_segment_size(vblk->disk->queue, v);
290	else
291		blk_queue_max_segment_size(vblk->disk->queue, -1UL);
292
293	err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,
294				offsetof(struct virtio_blk_config, seg_max),
295				&v);
296	if (!err)
297		blk_queue_max_hw_segments(vblk->disk->queue, v);
298
299	/* Host can optionally specify the block size of the device */
300	err = virtio_config_val(vdev, VIRTIO_BLK_F_BLK_SIZE,
301				offsetof(struct virtio_blk_config, blk_size),
302				&blk_size);
303	if (!err)
304		blk_queue_hardsect_size(vblk->disk->queue, blk_size);
305
306	add_disk(vblk->disk);
307	return 0;
308
309out_put_disk:
310	put_disk(vblk->disk);
311out_mempool:
312	mempool_destroy(vblk->pool);
313out_free_vq:
314	vdev->config->del_vq(vblk->vq);
315out_free_vblk:
316	kfree(vblk);
317out:
318	return err;
319}
320
321static void virtblk_remove(struct virtio_device *vdev)
322{
323	struct virtio_blk *vblk = vdev->priv;
324
325	/* Nothing should be pending. */
326	BUG_ON(!list_empty(&vblk->reqs));
327
328	/* Stop all the virtqueues. */
329	vdev->config->reset(vdev);
330
331	del_gendisk(vblk->disk);
332	blk_cleanup_queue(vblk->disk->queue);
333	put_disk(vblk->disk);
334	mempool_destroy(vblk->pool);
335	vdev->config->del_vq(vblk->vq);
336	kfree(vblk);
337}
338
339static struct virtio_device_id id_table[] = {
340	{ VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
341	{ 0 },
342};
343
344static unsigned int features[] = {
345	VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
346	VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
347};
348
349static struct virtio_driver virtio_blk = {
350	.feature_table = features,
351	.feature_table_size = ARRAY_SIZE(features),
352	.driver.name =	KBUILD_MODNAME,
353	.driver.owner =	THIS_MODULE,
354	.id_table =	id_table,
355	.probe =	virtblk_probe,
356	.remove =	__devexit_p(virtblk_remove),
357};
358
359static int __init init(void)
360{
361	major = register_blkdev(0, "virtblk");
362	if (major < 0)
363		return major;
364	return register_virtio_driver(&virtio_blk);
365}
366
367static void __exit fini(void)
368{
369	unregister_blkdev(major, "virtblk");
370	unregister_virtio_driver(&virtio_blk);
371}
372module_init(init);
373module_exit(fini);
374
375MODULE_DEVICE_TABLE(virtio, id_table);
376MODULE_DESCRIPTION("Virtio block driver");
377MODULE_LICENSE("GPL");
378