blob: 2aafafca2b1374b11714546fb3c063044ed9200c [file] [log] [blame]
Rusty Russelle467cde2007-10-22 11:03:38 +10001//#define DEBUG
2#include <linux/spinlock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +09003#include <linux/slab.h>
Rusty Russelle467cde2007-10-22 11:03:38 +10004#include <linux/blkdev.h>
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +02005#include <linux/smp_lock.h>
Rusty Russelle467cde2007-10-22 11:03:38 +10006#include <linux/hdreg.h>
7#include <linux/virtio.h>
8#include <linux/virtio_blk.h>
Jens Axboe3d1266c2007-10-24 13:21:21 +02009#include <linux/scatterlist.h>
10
Christian Borntraeger4f3bf192008-01-31 15:53:53 +010011#define PART_BITS 4
Rusty Russelle467cde2007-10-22 11:03:38 +100012
Christian Borntraegerd50ed902008-02-01 09:05:00 +010013static int major, index;
Christian Borntraeger4f3bf192008-01-31 15:53:53 +010014
Rusty Russelle467cde2007-10-22 11:03:38 +100015struct 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
Rusty Russell0864b792008-12-30 09:26:05 -060030 /* What host tells us, plus 2 for header & tailer. */
31 unsigned int sg_elems;
32
Rusty Russelle467cde2007-10-22 11:03:38 +100033 /* Scatterlist: can be too big for stack. */
Rusty Russell0864b792008-12-30 09:26:05 -060034 struct scatterlist sg[/*sg_elems*/];
Rusty Russelle467cde2007-10-22 11:03:38 +100035};
36
37struct virtblk_req
38{
39 struct list_head list;
40 struct request *req;
41 struct virtio_blk_outhdr out_hdr;
Hannes Reinecke1cde26f2009-05-18 14:41:30 +020042 struct virtio_scsi_inhdr in_hdr;
Rusty Russellcb38fa22008-05-02 21:50:45 -050043 u8 status;
Rusty Russelle467cde2007-10-22 11:03:38 +100044};
45
Rusty Russell18445c42008-02-04 23:49:57 -050046static void blk_done(struct virtqueue *vq)
Rusty Russelle467cde2007-10-22 11:03:38 +100047{
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);
Michael S. Tsirkin09ec6b62010-04-12 16:18:36 +030054 while ((vbr = virtqueue_get_buf(vblk->vq, &len)) != NULL) {
Kiyoshi Ueda83169822008-10-01 10:11:20 -040055 int error;
Hannes Reinecke1cde26f2009-05-18 14:41:30 +020056
Rusty Russellcb38fa22008-05-02 21:50:45 -050057 switch (vbr->status) {
Rusty Russelle467cde2007-10-22 11:03:38 +100058 case VIRTIO_BLK_S_OK:
Kiyoshi Ueda83169822008-10-01 10:11:20 -040059 error = 0;
Rusty Russelle467cde2007-10-22 11:03:38 +100060 break;
61 case VIRTIO_BLK_S_UNSUPP:
Kiyoshi Ueda83169822008-10-01 10:11:20 -040062 error = -ENOTTY;
Rusty Russelle467cde2007-10-22 11:03:38 +100063 break;
64 default:
Kiyoshi Ueda83169822008-10-01 10:11:20 -040065 error = -EIO;
Rusty Russelle467cde2007-10-22 11:03:38 +100066 break;
67 }
68
Christoph Hellwig33659eb2010-08-07 18:17:56 +020069 switch (vbr->req->cmd_type) {
70 case REQ_TYPE_BLOCK_PC:
Hannes Reinecke1cde26f2009-05-18 14:41:30 +020071 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;
Christoph Hellwig33659eb2010-08-07 18:17:56 +020074 break;
75 case REQ_TYPE_SPECIAL:
john cooper4cb2ea22010-03-25 01:33:33 -040076 vbr->req->errors = (error != 0);
Christoph Hellwig33659eb2010-08-07 18:17:56 +020077 break;
Jens Axboe15fa6e82010-06-18 12:10:18 +020078 default:
79 break;
Christoph Hellwig33659eb2010-08-07 18:17:56 +020080 }
Hannes Reinecke1cde26f2009-05-18 14:41:30 +020081
Tejun Heo40cbbb72009-04-23 11:05:19 +090082 __blk_end_request_all(vbr->req, error);
Rusty Russelle467cde2007-10-22 11:03:38 +100083 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);
Rusty Russelle467cde2007-10-22 11:03:38 +100089}
90
91static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
92 struct request *req)
93{
Hannes Reinecke1cde26f2009-05-18 14:41:30 +020094 unsigned long num, out = 0, in = 0;
Rusty Russelle467cde2007-10-22 11:03:38 +100095 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;
FUJITA Tomonoridd40e452010-07-03 17:45:38 +0900103
104 if (req->cmd_flags & REQ_FLUSH) {
105 vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;
Rusty Russelle467cde2007-10-22 11:03:38 +1000106 vbr->out_hdr.sector = 0;
Fernando Luis Vázquez Cao766ca442008-08-14 09:59:13 +0200107 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
FUJITA Tomonoridd40e452010-07-03 17:45:38 +0900108 } 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;
Christoph Hellwigf1b0ef062009-09-17 19:57:42 +0200117 vbr->out_hdr.sector = 0;
118 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
119 break;
FUJITA Tomonoridd40e452010-07-03 17:45:38 +0900120 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();
Christoph Hellwigf1b0ef062009-09-17 19:57:42 +0200128 }
Rusty Russelle467cde2007-10-22 11:03:38 +1000129 }
130
Christoph Hellwig33659eb2010-08-07 18:17:56 +0200131 if (vbr->req->cmd_flags & REQ_HARDBARRIER)
Rusty Russelle467cde2007-10-22 11:03:38 +1000132 vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
133
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200134 sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
Rusty Russelle467cde2007-10-22 11:03:38 +1000135
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200136 /*
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 */
Christoph Hellwig33659eb2010-08-07 18:17:56 +0200142 if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC)
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200143 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
Christoph Hellwig33659eb2010-08-07 18:17:56 +0200147 if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC) {
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200148 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 }
Rusty Russelle467cde2007-10-22 11:03:38 +1000164 }
165
Michael S. Tsirkin09ec6b62010-04-12 16:18:36 +0300166 if (virtqueue_add_buf(vblk->vq, vblk->sg, out, in, vbr) < 0) {
Rusty Russelle467cde2007-10-22 11:03:38 +1000167 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{
Christoph Hellwig6c3b46f2009-05-18 14:38:28 +0200177 struct virtio_blk *vblk = q->queuedata;
Rusty Russelle467cde2007-10-22 11:03:38 +1000178 struct request *req;
179 unsigned int issued = 0;
180
Tejun Heo9934c8c2009-05-08 11:54:16 +0900181 while ((req = blk_peek_request(q)) != NULL) {
Rusty Russell0864b792008-12-30 09:26:05 -0600182 BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
Rusty Russelle467cde2007-10-22 11:03:38 +1000183
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 }
Tejun Heo9934c8c2009-05-08 11:54:16 +0900190 blk_start_request(req);
Rusty Russelle467cde2007-10-22 11:03:38 +1000191 issued++;
192 }
193
194 if (issued)
Michael S. Tsirkin09ec6b62010-04-12 16:18:36 +0300195 virtqueue_kick(vblk->vq);
Rusty Russelle467cde2007-10-22 11:03:38 +1000196}
197
john cooper4cb2ea22010-03-25 01:33:33 -0400198/* 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
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +0200221static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
Rusty Russelle467cde2007-10-22 11:03:38 +1000222 unsigned cmd, unsigned long data)
223{
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200224 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))
Christoph Hellwigd9ecdea2009-06-20 21:29:41 +0200231 return -ENOTTY;
Hannes Reinecke1cde26f2009-05-18 14:41:30 +0200232
Rusty Russell3225bea2009-10-22 16:39:28 -0600233 return scsi_cmd_ioctl(disk->queue, disk, mode, cmd,
234 (void __user *)data);
Rusty Russelle467cde2007-10-22 11:03:38 +1000235}
236
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +0200237static 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
Christian Borntraeger135da0b2008-01-23 17:56:50 +0100249/* We provide getgeo only to please some old bootloader/partitioning tools */
250static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
251{
Ryan Harper48e40432008-04-16 13:56:37 -0500252 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 }
Christian Borntraeger135da0b2008-01-23 17:56:50 +0100271 return 0;
272}
273
Alexey Dobriyan83d5cde2009-09-21 17:01:13 -0700274static const struct block_device_operations virtblk_fops = {
Arnd Bergmann8a6cfeb2010-07-08 10:18:46 +0200275 .ioctl = virtblk_ioctl,
Christian Borntraeger135da0b2008-01-23 17:56:50 +0100276 .owner = THIS_MODULE,
277 .getgeo = virtblk_getgeo,
Rusty Russelle467cde2007-10-22 11:03:38 +1000278};
279
Christian Borntraegerd50ed902008-02-01 09:05:00 +0100280static int index_to_minor(int index)
281{
282 return index << PART_BITS;
283}
284
Ryan Harpera5eb9e42010-06-23 22:19:57 -0500285static 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
Mike Frysinger98e94442009-05-18 03:39:09 -0400306static int __devinit virtblk_probe(struct virtio_device *vdev)
Rusty Russelle467cde2007-10-22 11:03:38 +1000307{
308 struct virtio_blk *vblk;
Christoph Hellwig69740c82010-02-24 14:22:25 -0600309 struct request_queue *q;
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100310 int err;
Rusty Russelle467cde2007-10-22 11:03:38 +1000311 u64 cap;
Christoph Hellwig69740c82010-02-24 14:22:25 -0600312 u32 v, blk_size, sg_elems, opt_io_size;
313 u16 min_io_size;
314 u8 physical_block_exp, alignment_offset;
Rusty Russelle467cde2007-10-22 11:03:38 +1000315
Christian Borntraegerd50ed902008-02-01 09:05:00 +0100316 if (index_to_minor(index) >= 1 << MINORBITS)
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100317 return -ENOSPC;
318
Rusty Russell0864b792008-12-30 09:26:05 -0600319 /* 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);
Christoph Hellwiga5b365a2010-05-25 14:17:54 +0200323
324 /* We need at least one SG element, whatever they say. */
325 if (err || !sg_elems)
Rusty Russell0864b792008-12-30 09:26:05 -0600326 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);
Rusty Russelle467cde2007-10-22 11:03:38 +1000332 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;
Rusty Russell0864b792008-12-30 09:26:05 -0600340 vblk->sg_elems = sg_elems;
341 sg_init_table(vblk->sg, vblk->sg_elems);
Rusty Russelle467cde2007-10-22 11:03:38 +1000342
343 /* We expect one virtqueue, for output. */
Michael S. Tsirkind2a7ddd2009-06-12 22:16:36 -0600344 vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
Rusty Russelle467cde2007-10-22 11:03:38 +1000345 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
Rusty Russelle467cde2007-10-22 11:03:38 +1000356 /* FIXME: How many partitions? How long is a piece of string? */
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100357 vblk->disk = alloc_disk(1 << PART_BITS);
Rusty Russelle467cde2007-10-22 11:03:38 +1000358 if (!vblk->disk) {
359 err = -ENOMEM;
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100360 goto out_mempool;
Rusty Russelle467cde2007-10-22 11:03:38 +1000361 }
362
Christoph Hellwig69740c82010-02-24 14:22:25 -0600363 q = vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
364 if (!q) {
Rusty Russelle467cde2007-10-22 11:03:38 +1000365 err = -ENOMEM;
366 goto out_put_disk;
367 }
368
Christoph Hellwig69740c82010-02-24 14:22:25 -0600369 q->queuedata = vblk;
Fernando Luis Vázquez Cao7d116b62008-10-27 18:45:15 +0900370
Christian Borntraegerd50ed902008-02-01 09:05:00 +0100371 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
Rusty Russelle467cde2007-10-22 11:03:38 +1000384 vblk->disk->major = major;
Christian Borntraegerd50ed902008-02-01 09:05:00 +0100385 vblk->disk->first_minor = index_to_minor(index);
Rusty Russelle467cde2007-10-22 11:03:38 +1000386 vblk->disk->private_data = vblk;
387 vblk->disk->fops = &virtblk_fops;
Jeremy Katzc4839342008-03-02 17:00:15 -0500388 vblk->disk->driverfs_dev = &vdev->dev;
Christian Borntraegerd50ed902008-02-01 09:05:00 +0100389 index++;
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100390
Christoph Hellwig10bc3102010-06-15 14:43:48 +0200391 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 */
FUJITA Tomonori00fff262010-07-03 17:45:40 +0900397 blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH);
Christoph Hellwig10bc3102010-06-15 14:43:48 +0200398 } 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 */
FUJITA Tomonori00fff262010-07-03 17:45:40 +0900406 blk_queue_ordered(q, QUEUE_ORDERED_TAG);
Christoph Hellwig10bc3102010-06-15 14:43:48 +0200407 } 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 */
Linus Torvalds2f9e8252010-08-10 15:22:42 -0700414 blk_queue_ordered(q, QUEUE_ORDERED_DRAIN);
Christoph Hellwig10bc3102010-06-15 14:43:48 +0200415 }
Rusty Russelle467cde2007-10-22 11:03:38 +1000416
Christian Borntraeger3ef53602008-05-16 11:17:03 +0200417 /* 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
Rusty Russella586d4f2008-02-04 23:49:56 -0500421 /* Host must always specify the capacity. */
Rusty Russell72e61eb2008-05-02 21:50:49 -0500422 vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
423 &cap, sizeof(cap));
Rusty Russelle467cde2007-10-22 11:03:38 +1000424
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
Rusty Russell0864b792008-12-30 09:26:05 -0600433 /* We can handle whatever the host told us to handle. */
Martin K. Petersenee714f22010-03-10 00:48:32 -0500434 blk_queue_max_segments(q, vblk->sg_elems-2);
Rusty Russell0864b792008-12-30 09:26:05 -0600435
Christoph Hellwig4eff3ca2009-07-17 21:47:45 -0600436 /* No need to bounce any requests */
Christoph Hellwig69740c82010-02-24 14:22:25 -0600437 blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
Christoph Hellwig4eff3ca2009-07-17 21:47:45 -0600438
Rusty Russell4b7f7e22008-12-30 09:26:04 -0600439 /* No real sector limit. */
Martin K. Petersenee714f22010-03-10 00:48:32 -0500440 blk_queue_max_hw_sectors(q, -1U);
Rusty Russell4b7f7e22008-12-30 09:26:04 -0600441
Rusty Russella586d4f2008-02-04 23:49:56 -0500442 /* 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);
Rusty Russelle467cde2007-10-22 11:03:38 +1000447 if (!err)
Christoph Hellwig69740c82010-02-24 14:22:25 -0600448 blk_queue_max_segment_size(q, v);
Rusty Russell4b7f7e22008-12-30 09:26:04 -0600449 else
Christoph Hellwig69740c82010-02-24 14:22:25 -0600450 blk_queue_max_segment_size(q, -1U);
Rusty Russelle467cde2007-10-22 11:03:38 +1000451
Christian Borntraeger066f4d82008-05-29 11:08:26 +0200452 /* 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)
Christoph Hellwig69740c82010-02-24 14:22:25 -0600457 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
Christian Borntraeger066f4d82008-05-29 11:08:26 +0200487
Rusty Russelle467cde2007-10-22 11:03:38 +1000488 add_disk(vblk->disk);
Ryan Harpera5eb9e42010-06-23 22:19:57 -0500489 err = device_create_file(disk_to_dev(vblk->disk), &dev_attr_serial);
490 if (err)
491 goto out_del_disk;
492
Rusty Russelle467cde2007-10-22 11:03:38 +1000493 return 0;
494
Ryan Harpera5eb9e42010-06-23 22:19:57 -0500495out_del_disk:
496 del_gendisk(vblk->disk);
497 blk_cleanup_queue(vblk->disk->queue);
Rusty Russelle467cde2007-10-22 11:03:38 +1000498out_put_disk:
499 put_disk(vblk->disk);
Rusty Russelle467cde2007-10-22 11:03:38 +1000500out_mempool:
501 mempool_destroy(vblk->pool);
502out_free_vq:
Michael S. Tsirkind2a7ddd2009-06-12 22:16:36 -0600503 vdev->config->del_vqs(vdev);
Rusty Russelle467cde2007-10-22 11:03:38 +1000504out_free_vblk:
505 kfree(vblk);
506out:
507 return err;
508}
509
Mike Frysinger98e94442009-05-18 03:39:09 -0400510static void __devexit virtblk_remove(struct virtio_device *vdev)
Rusty Russelle467cde2007-10-22 11:03:38 +1000511{
512 struct virtio_blk *vblk = vdev->priv;
Rusty Russelle467cde2007-10-22 11:03:38 +1000513
Rusty Russell6e5aa7e2008-02-04 23:50:03 -0500514 /* Nothing should be pending. */
Rusty Russelle467cde2007-10-22 11:03:38 +1000515 BUG_ON(!list_empty(&vblk->reqs));
Rusty Russell6e5aa7e2008-02-04 23:50:03 -0500516
517 /* Stop all the virtqueues. */
518 vdev->config->reset(vdev);
519
Chris Lalancetteac9d4632008-05-30 15:09:41 -0500520 del_gendisk(vblk->disk);
Rusty Russelle467cde2007-10-22 11:03:38 +1000521 blk_cleanup_queue(vblk->disk->queue);
522 put_disk(vblk->disk);
Rusty Russelle467cde2007-10-22 11:03:38 +1000523 mempool_destroy(vblk->pool);
Michael S. Tsirkind2a7ddd2009-06-12 22:16:36 -0600524 vdev->config->del_vqs(vdev);
Rusty Russelle467cde2007-10-22 11:03:38 +1000525 kfree(vblk);
526}
527
Márton Németh47483e22010-01-10 13:40:02 +0100528static const struct virtio_device_id id_table[] = {
Rusty Russelle467cde2007-10-22 11:03:38 +1000529 { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
530 { 0 },
531};
532
Rusty Russellc45a6812008-05-02 21:50:50 -0500533static unsigned int features[] = {
534 VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
Christian Borntraeger066f4d82008-05-29 11:08:26 +0200535 VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
Christoph Hellwig69740c82010-02-24 14:22:25 -0600536 VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_TOPOLOGY
Rusty Russellc45a6812008-05-02 21:50:50 -0500537};
538
Rakib Mullick4fbfff762009-07-17 20:13:22 +0600539/*
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 = {
Rusty Russellc45a6812008-05-02 21:50:50 -0500545 .feature_table = features,
546 .feature_table_size = ARRAY_SIZE(features),
Rusty Russelle467cde2007-10-22 11:03:38 +1000547 .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{
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100556 major = register_blkdev(0, "virtblk");
557 if (major < 0)
558 return major;
Rusty Russelle467cde2007-10-22 11:03:38 +1000559 return register_virtio_driver(&virtio_blk);
560}
561
562static void __exit fini(void)
563{
Christian Borntraeger4f3bf192008-01-31 15:53:53 +0100564 unregister_blkdev(major, "virtblk");
Rusty Russelle467cde2007-10-22 11:03:38 +1000565 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");