virtio_blk.c revision fa251f89903d73989e2f63e13d0eaed1e07ce0da 
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	sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
132
133	/*
134	 * If this is a packet command we need a couple of additional headers.
135	 * Behind the normal outhdr we put a segment with the scsi command
136	 * block, and before the normal inhdr we put the sense data and the
137	 * inhdr with additional status information before the normal inhdr.
138	 */
139	if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC)
140		sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
141
142	num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
143
144	if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC) {
145		sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
146		sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
147			   sizeof(vbr->in_hdr));
148	}
149
150	sg_set_buf(&vblk->sg[num + out + in++], &vbr->status,
151		   sizeof(vbr->status));
152
153	if (num) {
154		if (rq_data_dir(vbr->req) == WRITE) {
155			vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
156			out += num;
157		} else {
158			vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
159			in += num;
160		}
161	}
162
163	if (virtqueue_add_buf(vblk->vq, vblk->sg, out, in, vbr) < 0) {
164		mempool_free(vbr, vblk->pool);
165		return false;
166	}
167
168	list_add_tail(&vbr->list, &vblk->reqs);
169	return true;
170}
171
172static void do_virtblk_request(struct request_queue *q)
173{
174	struct virtio_blk *vblk = q->queuedata;
175	struct request *req;
176	unsigned int issued = 0;
177
178	while ((req = blk_peek_request(q)) != NULL) {
179		BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
180
181		/* If this request fails, stop queue and wait for something to
182		   finish to restart it. */
183		if (!do_req(q, vblk, req)) {
184			blk_stop_queue(q);
185			break;
186		}
187		blk_start_request(req);
188		issued++;
189	}
190
191	if (issued)
192		virtqueue_kick(vblk->vq);
193}
194
195/* return id (s/n) string for *disk to *id_str
196 */
197static int virtblk_get_id(struct gendisk *disk, char *id_str)
198{
199	struct virtio_blk *vblk = disk->private_data;
200	struct request *req;
201	struct bio *bio;
202	int err;
203
204	bio = bio_map_kern(vblk->disk->queue, id_str, VIRTIO_BLK_ID_BYTES,
205			   GFP_KERNEL);
206	if (IS_ERR(bio))
207		return PTR_ERR(bio);
208
209	req = blk_make_request(vblk->disk->queue, bio, GFP_KERNEL);
210	if (IS_ERR(req)) {
211		bio_put(bio);
212		return PTR_ERR(req);
213	}
214
215	req->cmd_type = REQ_TYPE_SPECIAL;
216	err = blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
217	blk_put_request(req);
218
219	return err;
220}
221
222static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
223			 unsigned cmd, unsigned long data)
224{
225	struct gendisk *disk = bdev->bd_disk;
226	struct virtio_blk *vblk = disk->private_data;
227
228	/*
229	 * Only allow the generic SCSI ioctls if the host can support it.
230	 */
231	if (!virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_SCSI))
232		return -ENOTTY;
233
234	return scsi_cmd_ioctl(disk->queue, disk, mode, cmd,
235			      (void __user *)data);
236}
237
238static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
239			     unsigned int cmd, unsigned long param)
240{
241	int ret;
242
243	lock_kernel();
244	ret = virtblk_locked_ioctl(bdev, mode, cmd, param);
245	unlock_kernel();
246
247	return ret;
248}
249
250/* We provide getgeo only to please some old bootloader/partitioning tools */
251static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
252{
253	struct virtio_blk *vblk = bd->bd_disk->private_data;
254	struct virtio_blk_geometry vgeo;
255	int err;
256
257	/* see if the host passed in geometry config */
258	err = virtio_config_val(vblk->vdev, VIRTIO_BLK_F_GEOMETRY,
259				offsetof(struct virtio_blk_config, geometry),
260				&vgeo);
261
262	if (!err) {
263		geo->heads = vgeo.heads;
264		geo->sectors = vgeo.sectors;
265		geo->cylinders = vgeo.cylinders;
266	} else {
267		/* some standard values, similar to sd */
268		geo->heads = 1 << 6;
269		geo->sectors = 1 << 5;
270		geo->cylinders = get_capacity(bd->bd_disk) >> 11;
271	}
272	return 0;
273}
274
275static const struct block_device_operations virtblk_fops = {
276	.ioctl  = virtblk_ioctl,
277	.owner  = THIS_MODULE,
278	.getgeo = virtblk_getgeo,
279};
280
281static int index_to_minor(int index)
282{
283	return index << PART_BITS;
284}
285
286static ssize_t virtblk_serial_show(struct device *dev,
287				struct device_attribute *attr, char *buf)
288{
289	struct gendisk *disk = dev_to_disk(dev);
290	int err;
291
292	/* sysfs gives us a PAGE_SIZE buffer */
293	BUILD_BUG_ON(PAGE_SIZE < VIRTIO_BLK_ID_BYTES);
294
295	buf[VIRTIO_BLK_ID_BYTES] = '\0';
296	err = virtblk_get_id(disk, buf);
297	if (!err)
298		return strlen(buf);
299
300	if (err == -EIO) /* Unsupported? Make it empty. */
301		return 0;
302
303	return err;
304}
305DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
306
307static int __devinit virtblk_probe(struct virtio_device *vdev)
308{
309	struct virtio_blk *vblk;
310	struct request_queue *q;
311	int err;
312	u64 cap;
313	u32 v, blk_size, sg_elems, opt_io_size;
314	u16 min_io_size;
315	u8 physical_block_exp, alignment_offset;
316
317	if (index_to_minor(index) >= 1 << MINORBITS)
318		return -ENOSPC;
319
320	/* We need to know how many segments before we allocate. */
321	err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,
322				offsetof(struct virtio_blk_config, seg_max),
323				&sg_elems);
324
325	/* We need at least one SG element, whatever they say. */
326	if (err || !sg_elems)
327		sg_elems = 1;
328
329	/* We need an extra sg elements at head and tail. */
330	sg_elems += 2;
331	vdev->priv = vblk = kmalloc(sizeof(*vblk) +
332				    sizeof(vblk->sg[0]) * sg_elems, GFP_KERNEL);
333	if (!vblk) {
334		err = -ENOMEM;
335		goto out;
336	}
337
338	INIT_LIST_HEAD(&vblk->reqs);
339	spin_lock_init(&vblk->lock);
340	vblk->vdev = vdev;
341	vblk->sg_elems = sg_elems;
342	sg_init_table(vblk->sg, vblk->sg_elems);
343
344	/* We expect one virtqueue, for output. */
345	vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
346	if (IS_ERR(vblk->vq)) {
347		err = PTR_ERR(vblk->vq);
348		goto out_free_vblk;
349	}
350
351	vblk->pool = mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req));
352	if (!vblk->pool) {
353		err = -ENOMEM;
354		goto out_free_vq;
355	}
356
357	/* FIXME: How many partitions?  How long is a piece of string? */
358	vblk->disk = alloc_disk(1 << PART_BITS);
359	if (!vblk->disk) {
360		err = -ENOMEM;
361		goto out_mempool;
362	}
363
364	q = vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
365	if (!q) {
366		err = -ENOMEM;
367		goto out_put_disk;
368	}
369
370	q->queuedata = vblk;
371
372	if (index < 26) {
373		sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
374	} else if (index < (26 + 1) * 26) {
375		sprintf(vblk->disk->disk_name, "vd%c%c",
376			'a' + index / 26 - 1, 'a' + index % 26);
377	} else {
378		const unsigned int m1 = (index / 26 - 1) / 26 - 1;
379		const unsigned int m2 = (index / 26 - 1) % 26;
380		const unsigned int m3 =  index % 26;
381		sprintf(vblk->disk->disk_name, "vd%c%c%c",
382			'a' + m1, 'a' + m2, 'a' + m3);
383	}
384
385	vblk->disk->major = major;
386	vblk->disk->first_minor = index_to_minor(index);
387	vblk->disk->private_data = vblk;
388	vblk->disk->fops = &virtblk_fops;
389	vblk->disk->driverfs_dev = &vdev->dev;
390	index++;
391
392	/* configure queue flush support */
393	if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
394		blk_queue_flush(q, REQ_FLUSH);
395
396	/* If disk is read-only in the host, the guest should obey */
397	if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
398		set_disk_ro(vblk->disk, 1);
399
400	/* Host must always specify the capacity. */
401	vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
402			  &cap, sizeof(cap));
403
404	/* If capacity is too big, truncate with warning. */
405	if ((sector_t)cap != cap) {
406		dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
407			 (unsigned long long)cap);
408		cap = (sector_t)-1;
409	}
410	set_capacity(vblk->disk, cap);
411
412	/* We can handle whatever the host told us to handle. */
413	blk_queue_max_segments(q, vblk->sg_elems-2);
414
415	/* No need to bounce any requests */
416	blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
417
418	/* No real sector limit. */
419	blk_queue_max_hw_sectors(q, -1U);
420
421	/* Host can optionally specify maximum segment size and number of
422	 * segments. */
423	err = virtio_config_val(vdev, VIRTIO_BLK_F_SIZE_MAX,
424				offsetof(struct virtio_blk_config, size_max),
425				&v);
426	if (!err)
427		blk_queue_max_segment_size(q, v);
428	else
429		blk_queue_max_segment_size(q, -1U);
430
431	/* Host can optionally specify the block size of the device */
432	err = virtio_config_val(vdev, VIRTIO_BLK_F_BLK_SIZE,
433				offsetof(struct virtio_blk_config, blk_size),
434				&blk_size);
435	if (!err)
436		blk_queue_logical_block_size(q, blk_size);
437	else
438		blk_size = queue_logical_block_size(q);
439
440	/* Use topology information if available */
441	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
442			offsetof(struct virtio_blk_config, physical_block_exp),
443			&physical_block_exp);
444	if (!err && physical_block_exp)
445		blk_queue_physical_block_size(q,
446				blk_size * (1 << physical_block_exp));
447
448	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
449			offsetof(struct virtio_blk_config, alignment_offset),
450			&alignment_offset);
451	if (!err && alignment_offset)
452		blk_queue_alignment_offset(q, blk_size * alignment_offset);
453
454	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
455			offsetof(struct virtio_blk_config, min_io_size),
456			&min_io_size);
457	if (!err && min_io_size)
458		blk_queue_io_min(q, blk_size * min_io_size);
459
460	err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
461			offsetof(struct virtio_blk_config, opt_io_size),
462			&opt_io_size);
463	if (!err && opt_io_size)
464		blk_queue_io_opt(q, blk_size * opt_io_size);
465
466
467	add_disk(vblk->disk);
468	err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
469	if (err)
470		goto out_del_disk;
471
472	return 0;
473
474out_del_disk:
475	del_gendisk(vblk->disk);
476	blk_cleanup_queue(vblk->disk->queue);
477out_put_disk:
478	put_disk(vblk->disk);
479out_mempool:
480	mempool_destroy(vblk->pool);
481out_free_vq:
482	vdev->config->del_vqs(vdev);
483out_free_vblk:
484	kfree(vblk);
485out:
486	return err;
487}
488
489static void __devexit virtblk_remove(struct virtio_device *vdev)
490{
491	struct virtio_blk *vblk = vdev->priv;
492
493	/* Nothing should be pending. */
494	BUG_ON(!list_empty(&vblk->reqs));
495
496	/* Stop all the virtqueues. */
497	vdev->config->reset(vdev);
498
499	del_gendisk(vblk->disk);
500	blk_cleanup_queue(vblk->disk->queue);
501	put_disk(vblk->disk);
502	mempool_destroy(vblk->pool);
503	vdev->config->del_vqs(vdev);
504	kfree(vblk);
505}
506
507static const struct virtio_device_id id_table[] = {
508	{ VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
509	{ 0 },
510};
511
512static unsigned int features[] = {
513	VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX, VIRTIO_BLK_F_GEOMETRY,
514	VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE, VIRTIO_BLK_F_SCSI,
515	VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_TOPOLOGY
516};
517
518/*
519 * virtio_blk causes spurious section mismatch warning by
520 * simultaneously referring to a __devinit and a __devexit function.
521 * Use __refdata to avoid this warning.
522 */
523static struct virtio_driver __refdata virtio_blk = {
524	.feature_table = features,
525	.feature_table_size = ARRAY_SIZE(features),
526	.driver.name =	KBUILD_MODNAME,
527	.driver.owner =	THIS_MODULE,
528	.id_table =	id_table,
529	.probe =	virtblk_probe,
530	.remove =	__devexit_p(virtblk_remove),
531};
532
533static int __init init(void)
534{
535	major = register_blkdev(0, "virtblk");
536	if (major < 0)
537		return major;
538	return register_virtio_driver(&virtio_blk);
539}
540
541static void __exit fini(void)
542{
543	unregister_blkdev(major, "virtblk");
544	unregister_virtio_driver(&virtio_blk);
545}
546module_init(init);
547module_exit(fini);
548
549MODULE_DEVICE_TABLE(virtio, id_table);
550MODULE_DESCRIPTION("Virtio block driver");
551MODULE_LICENSE("GPL");
552