1
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 PART_BITS 4
10
11static int major, index;
12
13struct virtio_blk
14{
15 spinlock_t lock;
16
17 struct virtio_device *vdev;
18 struct virtqueue *vq;
19
20
21 struct gendisk *disk;
22
23
24 struct list_head reqs;
25
26 mempool_t *pool;
27
28
29 unsigned int sg_elems;
30
31
32 struct scatterlist sg[];
33};
34
35struct virtblk_req
36{
37 struct list_head list;
38 struct request *req;
39 struct virtio_blk_outhdr out_hdr;
40 struct virtio_scsi_inhdr in_hdr;
41 u8 status;
42};
43
44static void blk_done(struct virtqueue *vq)
45{
46 struct virtio_blk *vblk = vq->vdev->priv;
47 struct virtblk_req *vbr;
48 unsigned int len;
49 unsigned long flags;
50
51 spin_lock_irqsave(&vblk->lock, flags);
52 while ((vbr = vblk->vq->vq_ops->get_buf(vblk->vq, &len)) != NULL) {
53 int error;
54
55 switch (vbr->status) {
56 case VIRTIO_BLK_S_OK:
57 error = 0;
58 break;
59 case VIRTIO_BLK_S_UNSUPP:
60 error = -ENOTTY;
61 break;
62 default:
63 error = -EIO;
64 break;
65 }
66
67 if (blk_pc_request(vbr->req)) {
68 vbr->req->resid_len = vbr->in_hdr.residual;
69 vbr->req->sense_len = vbr->in_hdr.sense_len;
70 vbr->req->errors = vbr->in_hdr.errors;
71 }
72
73 __blk_end_request_all(vbr->req, error);
74 list_del(&vbr->list);
75 mempool_free(vbr, vblk->pool);
76 }
77
78 blk_start_queue(vblk->disk->queue);
79 spin_unlock_irqrestore(&vblk->lock, flags);
80}
81
82static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
83 struct request *req)
84{
85 unsigned long num, out = 0, in = 0;
86 struct virtblk_req *vbr;
87
88 vbr = mempool_alloc(vblk->pool, GFP_ATOMIC);
89 if (!vbr)
90
91 return false;
92
93 vbr->req = req;
94 switch (req->cmd_type) {
95 case REQ_TYPE_FS:
96 vbr->out_hdr.type = 0;
97 vbr->out_hdr.sector = blk_rq_pos(vbr->req);
98 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
99 break;
100 case REQ_TYPE_BLOCK_PC:
101 vbr->out_hdr.type = VIRTIO_BLK_T_SCSI_CMD;
102 vbr->out_hdr.sector = 0;
103 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
104 break;
105 case REQ_TYPE_LINUX_BLOCK:
106 if (req->cmd[0] == REQ_LB_OP_FLUSH) {
107 vbr->out_hdr.type = VIRTIO_BLK_T_FLUSH;
108 vbr->out_hdr.sector = 0;
109 vbr->out_hdr.ioprio = req_get_ioprio(vbr->req);
110 break;
111 }
112
113 default:
114
115 BUG();
116 }
117
118 if (blk_barrier_rq(vbr->req))
119 vbr->out_hdr.type |= VIRTIO_BLK_T_BARRIER;
120
121 sg_set_buf(&vblk->sg[out++], &vbr->out_hdr, sizeof(vbr->out_hdr));
122
123
124
125
126
127
128
129 if (blk_pc_request(vbr->req))
130 sg_set_buf(&vblk->sg[out++], vbr->req->cmd, vbr->req->cmd_len);
131
132 num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
133
134 if (blk_pc_request(vbr->req)) {
135 sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
136 sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
137 sizeof(vbr->in_hdr));
138 }
139
140 sg_set_buf(&vblk->sg[num + out + in++], &vbr->status,
141 sizeof(vbr->status));
142
143 if (num) {
144 if (rq_data_dir(vbr->req) == WRITE) {
145 vbr->out_hdr.type |= VIRTIO_BLK_T_OUT;
146 out += num;
147 } else {
148 vbr->out_hdr.type |= VIRTIO_BLK_T_IN;
149 in += num;
150 }
151 }
152
153 if (vblk->vq->vq_ops->add_buf(vblk->vq, vblk->sg, out, in, vbr) < 0) {
154 mempool_free(vbr, vblk->pool);
155 return false;
156 }
157
158 list_add_tail(&vbr->list, &vblk->reqs);
159 return true;
160}
161
162static void do_virtblk_request(struct request_queue *q)
163{
164 struct virtio_blk *vblk = q->queuedata;
165 struct request *req;
166 unsigned int issued = 0;
167
168 while ((req = blk_peek_request(q)) != NULL) {
169 BUG_ON(req->nr_phys_segments + 2 > vblk->sg_elems);
170
171
172
173 if (!do_req(q, vblk, req)) {
174 blk_stop_queue(q);
175 break;
176 }
177 blk_start_request(req);
178 issued++;
179 }
180
181 if (issued)
182 vblk->vq->vq_ops->kick(vblk->vq);
183}
184
185static void virtblk_prepare_flush(struct request_queue *q, struct request *req)
186{
187 req->cmd_type = REQ_TYPE_LINUX_BLOCK;
188 req->cmd[0] = REQ_LB_OP_FLUSH;
189}
190
191static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
192 unsigned cmd, unsigned long data)
193{
194 struct gendisk *disk = bdev->bd_disk;
195 struct virtio_blk *vblk = disk->private_data;
196
197
198
199
200 if (!virtio_has_feature(vblk->vdev, VIRTIO_BLK_F_SCSI))
201 return -ENOTTY;
202
203 return scsi_cmd_ioctl(disk->queue, disk, mode, cmd,
204 (void __user *)data);
205}
206
207
208static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
209{
210 struct virtio_blk *vblk = bd->bd_disk->private_data;
211 struct virtio_blk_geometry vgeo;
212 int err;
213
214
215 err = virtio_config_val(vblk->vdev, VIRTIO_BLK_F_GEOMETRY,
216 offsetof(struct virtio_blk_config, geometry),
217 &vgeo);
218
219 if (!err) {
220 geo->heads = vgeo.heads;
221 geo->sectors = vgeo.sectors;
222 geo->cylinders = vgeo.cylinders;
223 } else {
224
225 geo->heads = 1 << 6;
226 geo->sectors = 1 << 5;
227 geo->cylinders = get_capacity(bd->bd_disk) >> 11;
228 }
229 return 0;
230}
231
232static const struct block_device_operations virtblk_fops = {
233 .locked_ioctl = virtblk_ioctl,
234 .owner = THIS_MODULE,
235 .getgeo = virtblk_getgeo,
236};
237
238static int index_to_minor(int index)
239{
240 return index << PART_BITS;
241}
242
243static int __devinit virtblk_probe(struct virtio_device *vdev)
244{
245 struct virtio_blk *vblk;
246 int err;
247 u64 cap;
248 u32 v;
249 u32 blk_size, sg_elems;
250
251 if (index_to_minor(index) >= 1 << MINORBITS)
252 return -ENOSPC;
253
254
255 err = virtio_config_val(vdev, VIRTIO_BLK_F_SEG_MAX,
256 offsetof(struct virtio_blk_config, seg_max),
257 &sg_elems);
258 if (err)
259 sg_elems = 1;
260
261
262 sg_elems += 2;
263 vdev->priv = vblk = kmalloc(sizeof(*vblk) +
264 sizeof(vblk->sg[0]) * sg_elems, GFP_KERNEL);
265 if (!vblk) {
266 err = -ENOMEM;
267 goto out;
268 }
269
270 INIT_LIST_HEAD(&vblk->reqs);
271 spin_lock_init(&vblk->lock);
272 vblk->vdev = vdev;
273 vblk->sg_elems = sg_elems;
274 sg_init_table(vblk->sg, vblk->sg_elems);
275
276
277 vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
278 if (IS_ERR(vblk->vq)) {
279 err = PTR_ERR(vblk->vq);
280 goto out_free_vblk;
281 }
282
283 vblk->pool = mempool_create_kmalloc_pool(1,sizeof(struct virtblk_req));
284 if (!vblk->pool) {
285 err = -ENOMEM;
286 goto out_free_vq;
287 }
288
289
290 vblk->disk = alloc_disk(1 << PART_BITS);
291 if (!vblk->disk) {
292 err = -ENOMEM;
293 goto out_mempool;
294 }
295
296 vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
297 if (!vblk->disk->queue) {
298 err = -ENOMEM;
299 goto out_put_disk;
300 }
301
302 vblk->disk->queue->queuedata = vblk;
303
304 if (index < 26) {
305 sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
306 } else if (index < (26 + 1) * 26) {
307 sprintf(vblk->disk->disk_name, "vd%c%c",
308 'a' + index / 26 - 1, 'a' + index % 26);
309 } else {
310 const unsigned int m1 = (index / 26 - 1) / 26 - 1;
311 const unsigned int m2 = (index / 26 - 1) % 26;
312 const unsigned int m3 = index % 26;
313 sprintf(vblk->disk->disk_name, "vd%c%c%c",
314 'a' + m1, 'a' + m2, 'a' + m3);
315 }
316
317 vblk->disk->major = major;
318 vblk->disk->first_minor = index_to_minor(index);
319 vblk->disk->private_data = vblk;
320 vblk->disk->fops = &virtblk_fops;
321 vblk->disk->driverfs_dev = &vdev->dev;
322 index++;
323
324
325 if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
326 blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_DRAIN_FLUSH,
327 virtblk_prepare_flush);
328 else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))
329 blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_TAG, NULL);
330
331
332 if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
333 set_disk_ro(vblk->disk, 1);
334
335
336 vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
337 &cap, sizeof(cap));
338
339
340 if ((sector_t)cap != cap) {
341 dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
342 (unsigned long long)cap);
343 cap = (sector_t)-1;
344 }
345 set_capacity(vblk->disk, cap);
346
347
348 blk_queue_max_phys_segments(vblk->disk->queue, vblk->sg_elems-2);
349 blk_queue_max_hw_segments(vblk->disk->queue, vblk->sg_elems-2);
350
351
352 blk_queue_bounce_limit(vblk->disk->queue, BLK_BOUNCE_ANY);
353
354
355 blk_queue_max_sectors(vblk->disk->queue, -1U);
356
357
358
359 err = virtio_config_val(vdev, VIRTIO_BLK_F_SIZE_MAX,
360 offsetof(struct virtio_blk_config, size_max),
361 &v);
362 if (!err)
363 blk_queue_max_segment_size(vblk->disk->queue, v);
364 else
365 blk_queue_max_segment_size(vblk->disk->queue, -1U);
366
367
368 err = virtio_config_val(vdev, VIRTIO_BLK_F_BLK_SIZE,
369 offsetof(struct virtio_blk_config, blk_size),
370 &blk_size);
371 if (!err)
372 blk_queue_logical_block_size(vblk->disk->queue, blk_size);
373
374 add_disk(vblk->disk);
375 return 0;
376
377out_put_disk:
378 put_disk(vblk->disk);
379out_mempool:
380 mempool_destroy(vblk->pool);
381out_free_vq:
382 vdev->config->del_vqs(vdev);
383out_free_vblk:
384 kfree(vblk);
385out:
386 return err;
387}
388
389static void __devexit virtblk_remove(struct virtio_device *vdev)
390{
391 struct virtio_blk *vblk = vdev->priv;
392
393
394 BUG_ON(!list_empty(&vblk->reqs));
395
396
397 vdev->config->reset(vdev);
398
399 del_gendisk(vblk->disk);
400 blk_cleanup_queue(vblk->disk->queue);
401 put_disk(vblk->disk);
402 mempool_destroy(vblk->pool);
403 vdev->config->del_vqs(vdev);
404 kfree(vblk);
405}
406
407static struct virtio_device_id id_table[] = {
408 { VIRTIO_ID_BLOCK, VIRTIO_DEV_ANY_ID },
409 { 0 },
410};
411
412static unsigned int features[] = {
413 VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
414 VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
415 VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_FLUSH
416};
417
418
419
420
421
422
423static struct virtio_driver __refdata virtio_blk = {
424 .feature_table = features,
425 .feature_table_size = ARRAY_SIZE(features),
426 .driver.name = KBUILD_MODNAME,
427 .driver.owner = THIS_MODULE,
428 .id_table = id_table,
429 .probe = virtblk_probe,
430 .remove = __devexit_p(virtblk_remove),
431};
432
433static int __init init(void)
434{
435 major = register_blkdev(0, "virtblk");
436 if (major < 0)
437 return major;
438 return register_virtio_driver(&virtio_blk);
439}
440
441static void __exit fini(void)
442{
443 unregister_blkdev(major, "virtblk");
444 unregister_virtio_driver(&virtio_blk);
445}
446module_init(init);
447module_exit(fini);
448
449MODULE_DEVICE_TABLE(virtio, id_table);
450MODULE_DESCRIPTION("Virtio block driver");
451MODULE_LICENSE("GPL");
452