virtio_blk.c revision 2f9e825d3e0e2b407ae8f082de5c00afcf7378fb 
1//#define DEBUG
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>
10
11#define PART_BITS 4
12
13static int major, index;
14
15struct virtio_blk
16{
17	spinlock_t lock;
18
19	struct virtio_device *vdev;
20	struct virtqueue *vq;
21
22	/* The disk structure for the kernel. */
23	struct gendisk *disk;
24
25	/* Request tracking. */
26	struct list_head reqs;
27
28	mempool_t *pool;
29
30	/* What host tells us, plus 2 for header & tailer. */
31	unsigned int sg_elems;
32
33	/* Scatterlist: can be too big for stack. */
34	struct scatterlist sg[/*sg_elems*/];
35};
36
37struct virtblk_req
38{
39	struct list_head list;
40	struct request *req;
41	struct virtio_blk_outhdr out_hdr;
42	struct virtio_scsi_inhdr in_hdr;
43	u8 status;
44};
45
46static void blk_done(struct virtqueue *vq)
47{
48	struct virtio_blk *vblk = vq->vdev->priv;
49	struct virtblk_req *vbr;
50	unsigned int len;
51	unsigned long flags;
52
53	spin_lock_irqsave(&vblk->lock, flags);
54	while ((vbr = virtqueue_get_buf(vblk->vq, &len)) != NULL) {
55		int error;
56
57		switch (vbr->status) {
58		case VIRTIO_BLK_S_OK:
59			error = 0;
60			break;
61		case VIRTIO_BLK_S_UNSUPP:
62			error = -ENOTTY;
63			break;
64		default:
65			error = -EIO;
66			break;
67		}
68
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;
74			break;
75		case REQ_TYPE_SPECIAL:
76			vbr->req->errors = (error != 0);
77			break;
78		default:
79			break;
80		}
81
82		__blk_end_request_all(vbr->req, error);
83		list_del(&vbr->list);
84		mempool_free(vbr, vblk->pool);
85	}
86	/* In case queue is stopped waiting for more buffers. */
87	blk_start_queue(vblk->disk->queue);
88	spin_unlock_irqrestore(&vblk->lock, flags);
89}
90
91static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
92		   struct request *req)
93{
94	unsigned long num, out = 0, in = 0;
95	struct virtblk_req *vbr;
96
97	vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
98	if (!vbr)
99		/* When another request finishes we'll try again. */
100		return false;
101
102	vbr->req = req;
103
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);
108	} else {
109		switch (req->cmd_type) {
110		case REQ_TYPE_FS:
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);
114			break;
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);
119			break;
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);
124			break;
125		default:
126			/* We don't put anything else in the queue. */
127			BUG();
128		}
129	}
130
131	if (vbr->req->cmd_flags & REQ_HARDBARRIER)
132		vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
133
134	sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
135
136	/*
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.
141	 */
142	if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC)
143		sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
144
145	num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
146
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));
151	}
152
153	sg_set_buf(&vblk->sg[num + out + in++], &vbr->status,
154		   sizeof(vbr->status));
155
156	if (num) {
157		if (rq_data_dir(vbr->req) == WRITE) {
158			vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
159			out += num;
160		} else {
161			vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
162			in += num;
163		}
164	}
165
166	if (virtqueue_add_buf(vblk->vq, vblk->sg, out, in, vbr) < 0) {
167		mempool_free(vbr, vblk->pool);
168		return false;
169	}
170
171	list_add_tail(&vbr->list, &vblk->reqs);
172	return true;
173}
174
175static void do_virtblk_request(struct request_queue *q)
176{
177	struct virtio_blk *vblk = q->queuedata;
178	struct request *req;
179	unsigned int issued = 0;
180
181	while ((req = blk_peek_request(q)) != NULL) {
182		BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
183
184		/* If this request fails, stop queue and wait for something to
185		   finish to restart it. */
186		if (!do_req(q, vblk, req)) {
187			blk_stop_queue(q);
188			break;
189		}
190		blk_start_request(req);
191		issued++;
192	}
193
194	if (issued)
195		virtqueue_kick(vblk->vq);
196}
197
198/* return id (s/n) string for *disk to *id_str
199 */
200static int virtblk_get_id(struct gendisk *disk, char *id_str)
201{
202	struct virtio_blk *vblk = disk->private_data;
203	struct request *req;
204	struct bio *bio;
205
206	bio = bio_map_kern(vblk->disk->queue, id_str, VIRTIO_BLK_ID_BYTES,
207			   GFP_KERNEL);
208	if (IS_ERR(bio))
209		return PTR_ERR(bio);
210
211	req = blk_make_request(vblk->disk->queue, bio, GFP_KERNEL);
212	if (IS_ERR(req)) {
213		bio_put(bio);
214		return PTR_ERR(req);
215	}
216
217	req->cmd_type = REQ_TYPE_SPECIAL;
218	return blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
219}
220
221static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
222			 unsigned cmd, unsigned long data)
223{
224	struct gendisk *disk = bdev->bd_disk;
225	struct virtio_blk *vblk = disk->private_data;
226
227	/*
228	 * Only allow the generic SCSI ioctls if the host can support it.
229	 */
230	if (!virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_SCSI))
231		return -ENOTTY;
232
233	return scsi_cmd_ioctl(disk->queue, disk, mode, cmd,
234			      (void __user *)data);
235}
236
237static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
238			     unsigned int cmd, unsigned long param)
239{
240	int ret;
241
242	lock_kernel();
243	ret = virtblk_locked_ioctl(bdev, mode, cmd, param);
244	unlock_kernel();
245
246	return ret;
247}
248
249/* We provide getgeo only to please some old bootloader/partitioning tools */
250static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
251{
252	struct virtio_blk *vblk = bd->bd_disk->private_data;
253	struct virtio_blk_geometry vgeo;
254	int err;
255
256	/* see if the host passed in geometry config */
257	err = virtio_config_val(vblk->vdev, VIRTIO_BLK_F_GEOMETRY,
258				offsetof(struct virtio_blk_config, geometry),
259				&vgeo);
260
261	if (!err) {
262		geo->heads = vgeo.heads;
263		geo->sectors = vgeo.sectors;
264		geo->cylinders = vgeo.cylinders;
265	} else {
266		/* some standard values, similar to sd */
267		geo->heads = 1 << 6;
268		geo->sectors = 1 << 5;
269		geo->cylinders = get_capacity(bd->bd_disk) >> 11;
270	}
271	return 0;
272}
273
274static const struct block_device_operations virtblk_fops = {
275	.ioctl  = virtblk_ioctl,
276	.owner  = THIS_MODULE,
277	.getgeo = virtblk_getgeo,
278};
279
280static int index_to_minor(int index)
281{
282	return index << PART_BITS;
283}
284
285static ssize_t virtblk_serial_show(struct device *dev,
286				struct device_attribute *attr, char *buf)
287{
288	struct gendisk *disk = dev_to_disk(dev);
289	int err;
290
291	/* sysfs gives us a PAGE_SIZE buffer */
292	BUILD_BUG_ON(PAGE_SIZE < VIRTIO_BLK_ID_BYTES);
293
294	buf[VIRTIO_BLK_ID_BYTES] = '\0';
295	err = virtblk_get_id(disk, buf);
296	if (!err)
297		return strlen(buf);
298
299	if (err == -EIO) /* Unsupported? Make it empty. */
300		return 0;
301
302	return err;
303}
304DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
305
306static int __devinit virtblk_probe(struct virtio_device *vdev)
307{
308	struct virtio_blk *vblk;
309	struct request_queue *q;
310	int err;
311	u64 cap;
312	u32 v, blk_size, sg_elems, opt_io_size;
313	u16 min_io_size;
314	u8 physical_block_exp, alignment_offset;
315
316	if (index_to_minor(index) >= 1 << MINORBITS)
317		return -ENOSPC;
318
319	/* We need to know how many segments before we allocate. */
320	err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,
321				offsetof(struct virtio_blk_config, seg_max),
322				&sg_elems);
323
324	/* We need at least one SG element, whatever they say. */
325	if (err || !sg_elems)
326		sg_elems = 1;
327
328	/* We need an extra sg elements at head and tail. */
329	sg_elems += 2;
330	vdev->priv = vblk = kmalloc(sizeof(*vblk) +
331				    sizeof(vblk->sg[0]) * sg_elems, GFP_KERNEL);
332	if (!vblk) {
333		err = -ENOMEM;
334		goto out;
335	}
336
337	INIT_LIST_HEAD(&vblk->reqs);
338	spin_lock_init(&vblk->lock);
339	vblk->vdev = vdev;
340	vblk->sg_elems = sg_elems;
341	sg_init_table(vblk->sg, vblk->sg_elems);
342
343	/* We expect one virtqueue, for output. */
344	vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
345	if (IS_ERR(vblk->vq)) {
346		err = PTR_ERR(vblk->vq);
347		goto out_free_vblk;
348	}
349
350	vblk->pool = mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req));
351	if (!vblk->pool) {
352		err = -ENOMEM;
353		goto out_free_vq;
354	}
355
356	/* FIXME: How many partitions?  How long is a piece of string? */
357	vblk->disk = alloc_disk(1 << PART_BITS);
358	if (!vblk->disk) {
359		err = -ENOMEM;
360		goto out_mempool;
361	}
362
363	q = vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
364	if (!q) {
365		err = -ENOMEM;
366		goto out_put_disk;
367	}
368
369	q->queuedata = vblk;
370
371	if (index < 26) {
372		sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
373	} else if (index < (26 + 1) * 26) {
374		sprintf(vblk->disk->disk_name, "vd%c%c",
375			'a' + index / 26 - 1, 'a' + index % 26);
376	} else {
377		const unsigned int m1 = (index / 26 - 1) / 26 - 1;
378		const unsigned int m2 = (index / 26 - 1) % 26;
379		const unsigned int m3 =  index % 26;
380		sprintf(vblk->disk->disk_name, "vd%c%c%c",
381			'a' + m1, 'a' + m2, 'a' + m3);
382	}
383
384	vblk->disk->major = major;
385	vblk->disk->first_minor = index_to_minor(index);
386	vblk->disk->private_data = vblk;
387	vblk->disk->fops = &virtblk_fops;
388	vblk->disk->driverfs_dev = &vdev->dev;
389	index++;
390
391	if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH)) {
392		/*
393		 * If the FLUSH feature is supported we do have support for
394		 * flushing a volatile write cache on the host.  Use that
395		 * to implement write barrier support.
396		 */
397		blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH);
398	} else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER)) {
399		/*
400		 * If the BARRIER feature is supported the host expects us
401		 * to order request by tags.  This implies there is not
402		 * volatile write cache on the host, and that the host
403		 * never re-orders outstanding I/O.  This feature is not
404		 * useful for real life scenarious and deprecated.
405		 */
406		blk_queue_ordered(q, QUEUE_ORDERED_TAG);
407	} else {
408		/*
409		 * If the FLUSH feature is not supported we must assume that
410		 * the host does not perform any kind of volatile write
411		 * caching. We still need to drain the queue to provider
412		 * proper barrier semantics.
413		 */
414		blk_queue_ordered(q, QUEUE_ORDERED_DRAIN);
415	}
416
417	/* If disk is read-only in the host, the guest should obey */
418	if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
419		set_disk_ro(vblk->disk, 1);
420
421	/* Host must always specify the capacity. */
422	vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
423			  &cap, sizeof(cap));
424
425	/* If capacity is too big, truncate with warning. */
426	if ((sector_t)cap != cap) {
427		dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
428			 (unsigned long long)cap);
429		cap = (sector_t)-1;
430	}
431	set_capacity(vblk->disk, cap);
432
433	/* We can handle whatever the host told us to handle. */
434	blk_queue_max_segments(q, vblk->sg_elems-2);
435
436	/* No need to bounce any requests */
437	blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
438
439	/* No real sector limit. */
440	blk_queue_max_hw_sectors(q, -1U);
441
442	/* Host can optionally specify maximum segment size and number of
443	 * segments. */
444	err = virtio_config_val(vdev, VIRTIO_BLK_F_SIZE_MAX,
445				offsetof(struct virtio_blk_config, size_max),
446				&v);
447	if (!err)
448		blk_queue_max_segment_size(q, v);
449	else
450		blk_queue_max_segment_size(q, -1U);
451
452	/* Host can optionally specify the block size of the device */
453	err = virtio_config_val(vdev, VIRTIO_BLK_F_BLK_SIZE,
454				offsetof(struct virtio_blk_config, blk_size),
455				&blk_size);
456	if (!err)
457		blk_queue_logical_block_size(q, blk_size);
458	else
459		blk_size = queue_logical_block_size(q);
460
461	/* Use topology information if available */
462	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
463			offsetof(struct virtio_blk_config, physical_block_exp),
464			&physical_block_exp);
465	if (!err && physical_block_exp)
466		blk_queue_physical_block_size(q,
467				blk_size * (1 << physical_block_exp));
468
469	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
470			offsetof(struct virtio_blk_config, alignment_offset),
471			&alignment_offset);
472	if (!err && alignment_offset)
473		blk_queue_alignment_offset(q, blk_size * alignment_offset);
474
475	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
476			offsetof(struct virtio_blk_config, min_io_size),
477			&min_io_size);
478	if (!err && min_io_size)
479		blk_queue_io_min(q, blk_size * min_io_size);
480
481	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
482			offsetof(struct virtio_blk_config, opt_io_size),
483			&opt_io_size);
484	if (!err && opt_io_size)
485		blk_queue_io_opt(q, blk_size * opt_io_size);
486
487
488	add_disk(vblk->disk);
489	err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
490	if (err)
491		goto out_del_disk;
492
493	return 0;
494
495out_del_disk:
496	del_gendisk(vblk->disk);
497	blk_cleanup_queue(vblk->disk->queue);
498out_put_disk:
499	put_disk(vblk->disk);
500out_mempool:
501	mempool_destroy(vblk->pool);
502out_free_vq:
503	vdev->config->del_vqs(vdev);
504out_free_vblk:
505	kfree(vblk);
506out:
507	return err;
508}
509
510static void __devexit virtblk_remove(struct virtio_device *vdev)
511{
512	struct virtio_blk *vblk = vdev->priv;
513
514	/* Nothing should be pending. */
515	BUG_ON(!list_empty(&vblk->reqs));
516
517	/* Stop all the virtqueues. */
518	vdev->config->reset(vdev);
519
520	del_gendisk(vblk->disk);
521	blk_cleanup_queue(vblk->disk->queue);
522	put_disk(vblk->disk);
523	mempool_destroy(vblk->pool);
524	vdev->config->del_vqs(vdev);
525	kfree(vblk);
526}
527
528static const struct virtio_device_id id_table[] = {
529	{ VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
530	{ 0 },
531};
532
533static unsigned int features[] = {
534	VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
535	VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
536	VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_TOPOLOGY
537};
538
539/*
540 * virtio_blk causes spurious section mismatch warning by
541 * simultaneously referring to a __devinit and a __devexit function.
542 * Use __refdata to avoid this warning.
543 */
544static struct virtio_driver __refdata virtio_blk = {
545	.feature_table = features,
546	.feature_table_size = ARRAY_SIZE(features),
547	.driver.name =	KBUILD_MODNAME,
548	.driver.owner =	THIS_MODULE,
549	.id_table =	id_table,
550	.probe =	virtblk_probe,
551	.remove =	__devexit_p(virtblk_remove),
552};
553
554static int __init init(void)
555{
556	major = register_blkdev(0, "virtblk");
557	if (major < 0)
558		return major;
559	return register_virtio_driver(&virtio_blk);
560}
561
562static void __exit fini(void)
563{
564	unregister_blkdev(major, "virtblk");
565	unregister_virtio_driver(&virtio_blk);
566}
567module_init(init);
568module_exit(fini);
569
570MODULE_DEVICE_TABLE(virtio, id_table);
571MODULE_DESCRIPTION("Virtio block driver");
572MODULE_LICENSE("GPL");
573