xref: /openbmc/linux/drivers/block/xen-blkfront.c (revision d2999e1b)
1 /*
2  * blkfront.c
3  *
4  * XenLinux virtual block device driver.
5  *
6  * Copyright (c) 2003-2004, Keir Fraser & Steve Hand
7  * Modifications by Mark A. Williamson are (c) Intel Research Cambridge
8  * Copyright (c) 2004, Christian Limpach
9  * Copyright (c) 2004, Andrew Warfield
10  * Copyright (c) 2005, Christopher Clark
11  * Copyright (c) 2005, XenSource Ltd
12  *
13  * This program is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU General Public License version 2
15  * as published by the Free Software Foundation; or, when distributed
16  * separately from the Linux kernel or incorporated into other
17  * software packages, subject to the following license:
18  *
19  * Permission is hereby granted, free of charge, to any person obtaining a copy
20  * of this source file (the "Software"), to deal in the Software without
21  * restriction, including without limitation the rights to use, copy, modify,
22  * merge, publish, distribute, sublicense, and/or sell copies of the Software,
23  * and to permit persons to whom the Software is furnished to do so, subject to
24  * the following conditions:
25  *
26  * The above copyright notice and this permission notice shall be included in
27  * all copies or substantial portions of the Software.
28  *
29  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
31  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
32  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
33  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
34  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
35  * IN THE SOFTWARE.
36  */
37 
38 #include <linux/interrupt.h>
39 #include <linux/blkdev.h>
40 #include <linux/hdreg.h>
41 #include <linux/cdrom.h>
42 #include <linux/module.h>
43 #include <linux/slab.h>
44 #include <linux/mutex.h>
45 #include <linux/scatterlist.h>
46 #include <linux/bitmap.h>
47 #include <linux/list.h>
48 
49 #include <xen/xen.h>
50 #include <xen/xenbus.h>
51 #include <xen/grant_table.h>
52 #include <xen/events.h>
53 #include <xen/page.h>
54 #include <xen/platform_pci.h>
55 
56 #include <xen/interface/grant_table.h>
57 #include <xen/interface/io/blkif.h>
58 #include <xen/interface/io/protocols.h>
59 
60 #include <asm/xen/hypervisor.h>
61 
62 enum blkif_state {
63 	BLKIF_STATE_DISCONNECTED,
64 	BLKIF_STATE_CONNECTED,
65 	BLKIF_STATE_SUSPENDED,
66 };
67 
68 struct grant {
69 	grant_ref_t gref;
70 	unsigned long pfn;
71 	struct list_head node;
72 };
73 
74 struct blk_shadow {
75 	struct blkif_request req;
76 	struct request *request;
77 	struct grant **grants_used;
78 	struct grant **indirect_grants;
79 	struct scatterlist *sg;
80 };
81 
82 struct split_bio {
83 	struct bio *bio;
84 	atomic_t pending;
85 	int err;
86 };
87 
88 static DEFINE_MUTEX(blkfront_mutex);
89 static const struct block_device_operations xlvbd_block_fops;
90 
91 /*
92  * Maximum number of segments in indirect requests, the actual value used by
93  * the frontend driver is the minimum of this value and the value provided
94  * by the backend driver.
95  */
96 
97 static unsigned int xen_blkif_max_segments = 32;
98 module_param_named(max, xen_blkif_max_segments, int, S_IRUGO);
99 MODULE_PARM_DESC(max, "Maximum amount of segments in indirect requests (default is 32)");
100 
101 #define BLK_RING_SIZE __CONST_RING_SIZE(blkif, PAGE_SIZE)
102 
103 /*
104  * We have one of these per vbd, whether ide, scsi or 'other'.  They
105  * hang in private_data off the gendisk structure. We may end up
106  * putting all kinds of interesting stuff here :-)
107  */
108 struct blkfront_info
109 {
110 	spinlock_t io_lock;
111 	struct mutex mutex;
112 	struct xenbus_device *xbdev;
113 	struct gendisk *gd;
114 	int vdevice;
115 	blkif_vdev_t handle;
116 	enum blkif_state connected;
117 	int ring_ref;
118 	struct blkif_front_ring ring;
119 	unsigned int evtchn, irq;
120 	struct request_queue *rq;
121 	struct work_struct work;
122 	struct gnttab_free_callback callback;
123 	struct blk_shadow shadow[BLK_RING_SIZE];
124 	struct list_head grants;
125 	struct list_head indirect_pages;
126 	unsigned int persistent_gnts_c;
127 	unsigned long shadow_free;
128 	unsigned int feature_flush;
129 	unsigned int flush_op;
130 	unsigned int feature_discard:1;
131 	unsigned int feature_secdiscard:1;
132 	unsigned int discard_granularity;
133 	unsigned int discard_alignment;
134 	unsigned int feature_persistent:1;
135 	unsigned int max_indirect_segments;
136 	int is_ready;
137 };
138 
139 static unsigned int nr_minors;
140 static unsigned long *minors;
141 static DEFINE_SPINLOCK(minor_lock);
142 
143 #define MAXIMUM_OUTSTANDING_BLOCK_REQS \
144 	(BLKIF_MAX_SEGMENTS_PER_REQUEST * BLK_RING_SIZE)
145 #define GRANT_INVALID_REF	0
146 
147 #define PARTS_PER_DISK		16
148 #define PARTS_PER_EXT_DISK      256
149 
150 #define BLKIF_MAJOR(dev) ((dev)>>8)
151 #define BLKIF_MINOR(dev) ((dev) & 0xff)
152 
153 #define EXT_SHIFT 28
154 #define EXTENDED (1<<EXT_SHIFT)
155 #define VDEV_IS_EXTENDED(dev) ((dev)&(EXTENDED))
156 #define BLKIF_MINOR_EXT(dev) ((dev)&(~EXTENDED))
157 #define EMULATED_HD_DISK_MINOR_OFFSET (0)
158 #define EMULATED_HD_DISK_NAME_OFFSET (EMULATED_HD_DISK_MINOR_OFFSET / 256)
159 #define EMULATED_SD_DISK_MINOR_OFFSET (0)
160 #define EMULATED_SD_DISK_NAME_OFFSET (EMULATED_SD_DISK_MINOR_OFFSET / 256)
161 
162 #define DEV_NAME	"xvd"	/* name in /dev */
163 
164 #define SEGS_PER_INDIRECT_FRAME \
165 	(PAGE_SIZE/sizeof(struct blkif_request_segment))
166 #define INDIRECT_GREFS(_segs) \
167 	((_segs + SEGS_PER_INDIRECT_FRAME - 1)/SEGS_PER_INDIRECT_FRAME)
168 
169 static int blkfront_setup_indirect(struct blkfront_info *info);
170 
171 static int get_id_from_freelist(struct blkfront_info *info)
172 {
173 	unsigned long free = info->shadow_free;
174 	BUG_ON(free >= BLK_RING_SIZE);
175 	info->shadow_free = info->shadow[free].req.u.rw.id;
176 	info->shadow[free].req.u.rw.id = 0x0fffffee; /* debug */
177 	return free;
178 }
179 
180 static int add_id_to_freelist(struct blkfront_info *info,
181 			       unsigned long id)
182 {
183 	if (info->shadow[id].req.u.rw.id != id)
184 		return -EINVAL;
185 	if (info->shadow[id].request == NULL)
186 		return -EINVAL;
187 	info->shadow[id].req.u.rw.id  = info->shadow_free;
188 	info->shadow[id].request = NULL;
189 	info->shadow_free = id;
190 	return 0;
191 }
192 
193 static int fill_grant_buffer(struct blkfront_info *info, int num)
194 {
195 	struct page *granted_page;
196 	struct grant *gnt_list_entry, *n;
197 	int i = 0;
198 
199 	while(i < num) {
200 		gnt_list_entry = kzalloc(sizeof(struct grant), GFP_NOIO);
201 		if (!gnt_list_entry)
202 			goto out_of_memory;
203 
204 		if (info->feature_persistent) {
205 			granted_page = alloc_page(GFP_NOIO);
206 			if (!granted_page) {
207 				kfree(gnt_list_entry);
208 				goto out_of_memory;
209 			}
210 			gnt_list_entry->pfn = page_to_pfn(granted_page);
211 		}
212 
213 		gnt_list_entry->gref = GRANT_INVALID_REF;
214 		list_add(&gnt_list_entry->node, &info->grants);
215 		i++;
216 	}
217 
218 	return 0;
219 
220 out_of_memory:
221 	list_for_each_entry_safe(gnt_list_entry, n,
222 	                         &info->grants, node) {
223 		list_del(&gnt_list_entry->node);
224 		if (info->feature_persistent)
225 			__free_page(pfn_to_page(gnt_list_entry->pfn));
226 		kfree(gnt_list_entry);
227 		i--;
228 	}
229 	BUG_ON(i != 0);
230 	return -ENOMEM;
231 }
232 
233 static struct grant *get_grant(grant_ref_t *gref_head,
234                                unsigned long pfn,
235                                struct blkfront_info *info)
236 {
237 	struct grant *gnt_list_entry;
238 	unsigned long buffer_mfn;
239 
240 	BUG_ON(list_empty(&info->grants));
241 	gnt_list_entry = list_first_entry(&info->grants, struct grant,
242 	                                  node);
243 	list_del(&gnt_list_entry->node);
244 
245 	if (gnt_list_entry->gref != GRANT_INVALID_REF) {
246 		info->persistent_gnts_c--;
247 		return gnt_list_entry;
248 	}
249 
250 	/* Assign a gref to this page */
251 	gnt_list_entry->gref = gnttab_claim_grant_reference(gref_head);
252 	BUG_ON(gnt_list_entry->gref == -ENOSPC);
253 	if (!info->feature_persistent) {
254 		BUG_ON(!pfn);
255 		gnt_list_entry->pfn = pfn;
256 	}
257 	buffer_mfn = pfn_to_mfn(gnt_list_entry->pfn);
258 	gnttab_grant_foreign_access_ref(gnt_list_entry->gref,
259 	                                info->xbdev->otherend_id,
260 	                                buffer_mfn, 0);
261 	return gnt_list_entry;
262 }
263 
264 static const char *op_name(int op)
265 {
266 	static const char *const names[] = {
267 		[BLKIF_OP_READ] = "read",
268 		[BLKIF_OP_WRITE] = "write",
269 		[BLKIF_OP_WRITE_BARRIER] = "barrier",
270 		[BLKIF_OP_FLUSH_DISKCACHE] = "flush",
271 		[BLKIF_OP_DISCARD] = "discard" };
272 
273 	if (op < 0 || op >= ARRAY_SIZE(names))
274 		return "unknown";
275 
276 	if (!names[op])
277 		return "reserved";
278 
279 	return names[op];
280 }
281 static int xlbd_reserve_minors(unsigned int minor, unsigned int nr)
282 {
283 	unsigned int end = minor + nr;
284 	int rc;
285 
286 	if (end > nr_minors) {
287 		unsigned long *bitmap, *old;
288 
289 		bitmap = kcalloc(BITS_TO_LONGS(end), sizeof(*bitmap),
290 				 GFP_KERNEL);
291 		if (bitmap == NULL)
292 			return -ENOMEM;
293 
294 		spin_lock(&minor_lock);
295 		if (end > nr_minors) {
296 			old = minors;
297 			memcpy(bitmap, minors,
298 			       BITS_TO_LONGS(nr_minors) * sizeof(*bitmap));
299 			minors = bitmap;
300 			nr_minors = BITS_TO_LONGS(end) * BITS_PER_LONG;
301 		} else
302 			old = bitmap;
303 		spin_unlock(&minor_lock);
304 		kfree(old);
305 	}
306 
307 	spin_lock(&minor_lock);
308 	if (find_next_bit(minors, end, minor) >= end) {
309 		bitmap_set(minors, minor, nr);
310 		rc = 0;
311 	} else
312 		rc = -EBUSY;
313 	spin_unlock(&minor_lock);
314 
315 	return rc;
316 }
317 
318 static void xlbd_release_minors(unsigned int minor, unsigned int nr)
319 {
320 	unsigned int end = minor + nr;
321 
322 	BUG_ON(end > nr_minors);
323 	spin_lock(&minor_lock);
324 	bitmap_clear(minors,  minor, nr);
325 	spin_unlock(&minor_lock);
326 }
327 
328 static void blkif_restart_queue_callback(void *arg)
329 {
330 	struct blkfront_info *info = (struct blkfront_info *)arg;
331 	schedule_work(&info->work);
332 }
333 
334 static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
335 {
336 	/* We don't have real geometry info, but let's at least return
337 	   values consistent with the size of the device */
338 	sector_t nsect = get_capacity(bd->bd_disk);
339 	sector_t cylinders = nsect;
340 
341 	hg->heads = 0xff;
342 	hg->sectors = 0x3f;
343 	sector_div(cylinders, hg->heads * hg->sectors);
344 	hg->cylinders = cylinders;
345 	if ((sector_t)(hg->cylinders + 1) * hg->heads * hg->sectors < nsect)
346 		hg->cylinders = 0xffff;
347 	return 0;
348 }
349 
350 static int blkif_ioctl(struct block_device *bdev, fmode_t mode,
351 		       unsigned command, unsigned long argument)
352 {
353 	struct blkfront_info *info = bdev->bd_disk->private_data;
354 	int i;
355 
356 	dev_dbg(&info->xbdev->dev, "command: 0x%x, argument: 0x%lx\n",
357 		command, (long)argument);
358 
359 	switch (command) {
360 	case CDROMMULTISESSION:
361 		dev_dbg(&info->xbdev->dev, "FIXME: support multisession CDs later\n");
362 		for (i = 0; i < sizeof(struct cdrom_multisession); i++)
363 			if (put_user(0, (char __user *)(argument + i)))
364 				return -EFAULT;
365 		return 0;
366 
367 	case CDROM_GET_CAPABILITY: {
368 		struct gendisk *gd = info->gd;
369 		if (gd->flags & GENHD_FL_CD)
370 			return 0;
371 		return -EINVAL;
372 	}
373 
374 	default:
375 		/*printk(KERN_ALERT "ioctl %08x not supported by Xen blkdev\n",
376 		  command);*/
377 		return -EINVAL; /* same return as native Linux */
378 	}
379 
380 	return 0;
381 }
382 
383 /*
384  * Generate a Xen blkfront IO request from a blk layer request.  Reads
385  * and writes are handled as expected.
386  *
387  * @req: a request struct
388  */
389 static int blkif_queue_request(struct request *req)
390 {
391 	struct blkfront_info *info = req->rq_disk->private_data;
392 	struct blkif_request *ring_req;
393 	unsigned long id;
394 	unsigned int fsect, lsect;
395 	int i, ref, n;
396 	struct blkif_request_segment *segments = NULL;
397 
398 	/*
399 	 * Used to store if we are able to queue the request by just using
400 	 * existing persistent grants, or if we have to get new grants,
401 	 * as there are not sufficiently many free.
402 	 */
403 	bool new_persistent_gnts;
404 	grant_ref_t gref_head;
405 	struct grant *gnt_list_entry = NULL;
406 	struct scatterlist *sg;
407 	int nseg, max_grefs;
408 
409 	if (unlikely(info->connected != BLKIF_STATE_CONNECTED))
410 		return 1;
411 
412 	max_grefs = req->nr_phys_segments;
413 	if (max_grefs > BLKIF_MAX_SEGMENTS_PER_REQUEST)
414 		/*
415 		 * If we are using indirect segments we need to account
416 		 * for the indirect grefs used in the request.
417 		 */
418 		max_grefs += INDIRECT_GREFS(req->nr_phys_segments);
419 
420 	/* Check if we have enough grants to allocate a requests */
421 	if (info->persistent_gnts_c < max_grefs) {
422 		new_persistent_gnts = 1;
423 		if (gnttab_alloc_grant_references(
424 		    max_grefs - info->persistent_gnts_c,
425 		    &gref_head) < 0) {
426 			gnttab_request_free_callback(
427 				&info->callback,
428 				blkif_restart_queue_callback,
429 				info,
430 				max_grefs);
431 			return 1;
432 		}
433 	} else
434 		new_persistent_gnts = 0;
435 
436 	/* Fill out a communications ring structure. */
437 	ring_req = RING_GET_REQUEST(&info->ring, info->ring.req_prod_pvt);
438 	id = get_id_from_freelist(info);
439 	info->shadow[id].request = req;
440 
441 	if (unlikely(req->cmd_flags & (REQ_DISCARD | REQ_SECURE))) {
442 		ring_req->operation = BLKIF_OP_DISCARD;
443 		ring_req->u.discard.nr_sectors = blk_rq_sectors(req);
444 		ring_req->u.discard.id = id;
445 		ring_req->u.discard.sector_number = (blkif_sector_t)blk_rq_pos(req);
446 		if ((req->cmd_flags & REQ_SECURE) && info->feature_secdiscard)
447 			ring_req->u.discard.flag = BLKIF_DISCARD_SECURE;
448 		else
449 			ring_req->u.discard.flag = 0;
450 	} else {
451 		BUG_ON(info->max_indirect_segments == 0 &&
452 		       req->nr_phys_segments > BLKIF_MAX_SEGMENTS_PER_REQUEST);
453 		BUG_ON(info->max_indirect_segments &&
454 		       req->nr_phys_segments > info->max_indirect_segments);
455 		nseg = blk_rq_map_sg(req->q, req, info->shadow[id].sg);
456 		ring_req->u.rw.id = id;
457 		if (nseg > BLKIF_MAX_SEGMENTS_PER_REQUEST) {
458 			/*
459 			 * The indirect operation can only be a BLKIF_OP_READ or
460 			 * BLKIF_OP_WRITE
461 			 */
462 			BUG_ON(req->cmd_flags & (REQ_FLUSH | REQ_FUA));
463 			ring_req->operation = BLKIF_OP_INDIRECT;
464 			ring_req->u.indirect.indirect_op = rq_data_dir(req) ?
465 				BLKIF_OP_WRITE : BLKIF_OP_READ;
466 			ring_req->u.indirect.sector_number = (blkif_sector_t)blk_rq_pos(req);
467 			ring_req->u.indirect.handle = info->handle;
468 			ring_req->u.indirect.nr_segments = nseg;
469 		} else {
470 			ring_req->u.rw.sector_number = (blkif_sector_t)blk_rq_pos(req);
471 			ring_req->u.rw.handle = info->handle;
472 			ring_req->operation = rq_data_dir(req) ?
473 				BLKIF_OP_WRITE : BLKIF_OP_READ;
474 			if (req->cmd_flags & (REQ_FLUSH | REQ_FUA)) {
475 				/*
476 				 * Ideally we can do an unordered flush-to-disk. In case the
477 				 * backend onlysupports barriers, use that. A barrier request
478 				 * a superset of FUA, so we can implement it the same
479 				 * way.  (It's also a FLUSH+FUA, since it is
480 				 * guaranteed ordered WRT previous writes.)
481 				 */
482 				ring_req->operation = info->flush_op;
483 			}
484 			ring_req->u.rw.nr_segments = nseg;
485 		}
486 		for_each_sg(info->shadow[id].sg, sg, nseg, i) {
487 			fsect = sg->offset >> 9;
488 			lsect = fsect + (sg->length >> 9) - 1;
489 
490 			if ((ring_req->operation == BLKIF_OP_INDIRECT) &&
491 			    (i % SEGS_PER_INDIRECT_FRAME == 0)) {
492 				unsigned long uninitialized_var(pfn);
493 
494 				if (segments)
495 					kunmap_atomic(segments);
496 
497 				n = i / SEGS_PER_INDIRECT_FRAME;
498 				if (!info->feature_persistent) {
499 					struct page *indirect_page;
500 
501 					/* Fetch a pre-allocated page to use for indirect grefs */
502 					BUG_ON(list_empty(&info->indirect_pages));
503 					indirect_page = list_first_entry(&info->indirect_pages,
504 					                                 struct page, lru);
505 					list_del(&indirect_page->lru);
506 					pfn = page_to_pfn(indirect_page);
507 				}
508 				gnt_list_entry = get_grant(&gref_head, pfn, info);
509 				info->shadow[id].indirect_grants[n] = gnt_list_entry;
510 				segments = kmap_atomic(pfn_to_page(gnt_list_entry->pfn));
511 				ring_req->u.indirect.indirect_grefs[n] = gnt_list_entry->gref;
512 			}
513 
514 			gnt_list_entry = get_grant(&gref_head, page_to_pfn(sg_page(sg)), info);
515 			ref = gnt_list_entry->gref;
516 
517 			info->shadow[id].grants_used[i] = gnt_list_entry;
518 
519 			if (rq_data_dir(req) && info->feature_persistent) {
520 				char *bvec_data;
521 				void *shared_data;
522 
523 				BUG_ON(sg->offset + sg->length > PAGE_SIZE);
524 
525 				shared_data = kmap_atomic(pfn_to_page(gnt_list_entry->pfn));
526 				bvec_data = kmap_atomic(sg_page(sg));
527 
528 				/*
529 				 * this does not wipe data stored outside the
530 				 * range sg->offset..sg->offset+sg->length.
531 				 * Therefore, blkback *could* see data from
532 				 * previous requests. This is OK as long as
533 				 * persistent grants are shared with just one
534 				 * domain. It may need refactoring if this
535 				 * changes
536 				 */
537 				memcpy(shared_data + sg->offset,
538 				       bvec_data   + sg->offset,
539 				       sg->length);
540 
541 				kunmap_atomic(bvec_data);
542 				kunmap_atomic(shared_data);
543 			}
544 			if (ring_req->operation != BLKIF_OP_INDIRECT) {
545 				ring_req->u.rw.seg[i] =
546 						(struct blkif_request_segment) {
547 							.gref       = ref,
548 							.first_sect = fsect,
549 							.last_sect  = lsect };
550 			} else {
551 				n = i % SEGS_PER_INDIRECT_FRAME;
552 				segments[n] =
553 					(struct blkif_request_segment) {
554 							.gref       = ref,
555 							.first_sect = fsect,
556 							.last_sect  = lsect };
557 			}
558 		}
559 		if (segments)
560 			kunmap_atomic(segments);
561 	}
562 
563 	info->ring.req_prod_pvt++;
564 
565 	/* Keep a private copy so we can reissue requests when recovering. */
566 	info->shadow[id].req = *ring_req;
567 
568 	if (new_persistent_gnts)
569 		gnttab_free_grant_references(gref_head);
570 
571 	return 0;
572 }
573 
574 
575 static inline void flush_requests(struct blkfront_info *info)
576 {
577 	int notify;
578 
579 	RING_PUSH_REQUESTS_AND_CHECK_NOTIFY(&info->ring, notify);
580 
581 	if (notify)
582 		notify_remote_via_irq(info->irq);
583 }
584 
585 /*
586  * do_blkif_request
587  *  read a block; request is in a request queue
588  */
589 static void do_blkif_request(struct request_queue *rq)
590 {
591 	struct blkfront_info *info = NULL;
592 	struct request *req;
593 	int queued;
594 
595 	pr_debug("Entered do_blkif_request\n");
596 
597 	queued = 0;
598 
599 	while ((req = blk_peek_request(rq)) != NULL) {
600 		info = req->rq_disk->private_data;
601 
602 		if (RING_FULL(&info->ring))
603 			goto wait;
604 
605 		blk_start_request(req);
606 
607 		if ((req->cmd_type != REQ_TYPE_FS) ||
608 		    ((req->cmd_flags & (REQ_FLUSH | REQ_FUA)) &&
609 		    !info->flush_op)) {
610 			__blk_end_request_all(req, -EIO);
611 			continue;
612 		}
613 
614 		pr_debug("do_blk_req %p: cmd %p, sec %lx, "
615 			 "(%u/%u) [%s]\n",
616 			 req, req->cmd, (unsigned long)blk_rq_pos(req),
617 			 blk_rq_cur_sectors(req), blk_rq_sectors(req),
618 			 rq_data_dir(req) ? "write" : "read");
619 
620 		if (blkif_queue_request(req)) {
621 			blk_requeue_request(rq, req);
622 wait:
623 			/* Avoid pointless unplugs. */
624 			blk_stop_queue(rq);
625 			break;
626 		}
627 
628 		queued++;
629 	}
630 
631 	if (queued != 0)
632 		flush_requests(info);
633 }
634 
635 static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size,
636 				unsigned int physical_sector_size,
637 				unsigned int segments)
638 {
639 	struct request_queue *rq;
640 	struct blkfront_info *info = gd->private_data;
641 
642 	rq = blk_init_queue(do_blkif_request, &info->io_lock);
643 	if (rq == NULL)
644 		return -1;
645 
646 	queue_flag_set_unlocked(QUEUE_FLAG_VIRT, rq);
647 
648 	if (info->feature_discard) {
649 		queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, rq);
650 		blk_queue_max_discard_sectors(rq, get_capacity(gd));
651 		rq->limits.discard_granularity = info->discard_granularity;
652 		rq->limits.discard_alignment = info->discard_alignment;
653 		if (info->feature_secdiscard)
654 			queue_flag_set_unlocked(QUEUE_FLAG_SECDISCARD, rq);
655 	}
656 
657 	/* Hard sector size and max sectors impersonate the equiv. hardware. */
658 	blk_queue_logical_block_size(rq, sector_size);
659 	blk_queue_physical_block_size(rq, physical_sector_size);
660 	blk_queue_max_hw_sectors(rq, (segments * PAGE_SIZE) / 512);
661 
662 	/* Each segment in a request is up to an aligned page in size. */
663 	blk_queue_segment_boundary(rq, PAGE_SIZE - 1);
664 	blk_queue_max_segment_size(rq, PAGE_SIZE);
665 
666 	/* Ensure a merged request will fit in a single I/O ring slot. */
667 	blk_queue_max_segments(rq, segments);
668 
669 	/* Make sure buffer addresses are sector-aligned. */
670 	blk_queue_dma_alignment(rq, 511);
671 
672 	/* Make sure we don't use bounce buffers. */
673 	blk_queue_bounce_limit(rq, BLK_BOUNCE_ANY);
674 
675 	gd->queue = rq;
676 
677 	return 0;
678 }
679 
680 
681 static void xlvbd_flush(struct blkfront_info *info)
682 {
683 	blk_queue_flush(info->rq, info->feature_flush);
684 	printk(KERN_INFO "blkfront: %s: %s: %s %s %s %s %s\n",
685 	       info->gd->disk_name,
686 	       info->flush_op == BLKIF_OP_WRITE_BARRIER ?
687 		"barrier" : (info->flush_op == BLKIF_OP_FLUSH_DISKCACHE ?
688 		"flush diskcache" : "barrier or flush"),
689 	       info->feature_flush ? "enabled;" : "disabled;",
690 	       "persistent grants:",
691 	       info->feature_persistent ? "enabled;" : "disabled;",
692 	       "indirect descriptors:",
693 	       info->max_indirect_segments ? "enabled;" : "disabled;");
694 }
695 
696 static int xen_translate_vdev(int vdevice, int *minor, unsigned int *offset)
697 {
698 	int major;
699 	major = BLKIF_MAJOR(vdevice);
700 	*minor = BLKIF_MINOR(vdevice);
701 	switch (major) {
702 		case XEN_IDE0_MAJOR:
703 			*offset = (*minor / 64) + EMULATED_HD_DISK_NAME_OFFSET;
704 			*minor = ((*minor / 64) * PARTS_PER_DISK) +
705 				EMULATED_HD_DISK_MINOR_OFFSET;
706 			break;
707 		case XEN_IDE1_MAJOR:
708 			*offset = (*minor / 64) + 2 + EMULATED_HD_DISK_NAME_OFFSET;
709 			*minor = (((*minor / 64) + 2) * PARTS_PER_DISK) +
710 				EMULATED_HD_DISK_MINOR_OFFSET;
711 			break;
712 		case XEN_SCSI_DISK0_MAJOR:
713 			*offset = (*minor / PARTS_PER_DISK) + EMULATED_SD_DISK_NAME_OFFSET;
714 			*minor = *minor + EMULATED_SD_DISK_MINOR_OFFSET;
715 			break;
716 		case XEN_SCSI_DISK1_MAJOR:
717 		case XEN_SCSI_DISK2_MAJOR:
718 		case XEN_SCSI_DISK3_MAJOR:
719 		case XEN_SCSI_DISK4_MAJOR:
720 		case XEN_SCSI_DISK5_MAJOR:
721 		case XEN_SCSI_DISK6_MAJOR:
722 		case XEN_SCSI_DISK7_MAJOR:
723 			*offset = (*minor / PARTS_PER_DISK) +
724 				((major - XEN_SCSI_DISK1_MAJOR + 1) * 16) +
725 				EMULATED_SD_DISK_NAME_OFFSET;
726 			*minor = *minor +
727 				((major - XEN_SCSI_DISK1_MAJOR + 1) * 16 * PARTS_PER_DISK) +
728 				EMULATED_SD_DISK_MINOR_OFFSET;
729 			break;
730 		case XEN_SCSI_DISK8_MAJOR:
731 		case XEN_SCSI_DISK9_MAJOR:
732 		case XEN_SCSI_DISK10_MAJOR:
733 		case XEN_SCSI_DISK11_MAJOR:
734 		case XEN_SCSI_DISK12_MAJOR:
735 		case XEN_SCSI_DISK13_MAJOR:
736 		case XEN_SCSI_DISK14_MAJOR:
737 		case XEN_SCSI_DISK15_MAJOR:
738 			*offset = (*minor / PARTS_PER_DISK) +
739 				((major - XEN_SCSI_DISK8_MAJOR + 8) * 16) +
740 				EMULATED_SD_DISK_NAME_OFFSET;
741 			*minor = *minor +
742 				((major - XEN_SCSI_DISK8_MAJOR + 8) * 16 * PARTS_PER_DISK) +
743 				EMULATED_SD_DISK_MINOR_OFFSET;
744 			break;
745 		case XENVBD_MAJOR:
746 			*offset = *minor / PARTS_PER_DISK;
747 			break;
748 		default:
749 			printk(KERN_WARNING "blkfront: your disk configuration is "
750 					"incorrect, please use an xvd device instead\n");
751 			return -ENODEV;
752 	}
753 	return 0;
754 }
755 
756 static char *encode_disk_name(char *ptr, unsigned int n)
757 {
758 	if (n >= 26)
759 		ptr = encode_disk_name(ptr, n / 26 - 1);
760 	*ptr = 'a' + n % 26;
761 	return ptr + 1;
762 }
763 
764 static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
765 			       struct blkfront_info *info,
766 			       u16 vdisk_info, u16 sector_size,
767 			       unsigned int physical_sector_size)
768 {
769 	struct gendisk *gd;
770 	int nr_minors = 1;
771 	int err;
772 	unsigned int offset;
773 	int minor;
774 	int nr_parts;
775 	char *ptr;
776 
777 	BUG_ON(info->gd != NULL);
778 	BUG_ON(info->rq != NULL);
779 
780 	if ((info->vdevice>>EXT_SHIFT) > 1) {
781 		/* this is above the extended range; something is wrong */
782 		printk(KERN_WARNING "blkfront: vdevice 0x%x is above the extended range; ignoring\n", info->vdevice);
783 		return -ENODEV;
784 	}
785 
786 	if (!VDEV_IS_EXTENDED(info->vdevice)) {
787 		err = xen_translate_vdev(info->vdevice, &minor, &offset);
788 		if (err)
789 			return err;
790  		nr_parts = PARTS_PER_DISK;
791 	} else {
792 		minor = BLKIF_MINOR_EXT(info->vdevice);
793 		nr_parts = PARTS_PER_EXT_DISK;
794 		offset = minor / nr_parts;
795 		if (xen_hvm_domain() && offset < EMULATED_HD_DISK_NAME_OFFSET + 4)
796 			printk(KERN_WARNING "blkfront: vdevice 0x%x might conflict with "
797 					"emulated IDE disks,\n\t choose an xvd device name"
798 					"from xvde on\n", info->vdevice);
799 	}
800 	if (minor >> MINORBITS) {
801 		pr_warn("blkfront: %#x's minor (%#x) out of range; ignoring\n",
802 			info->vdevice, minor);
803 		return -ENODEV;
804 	}
805 
806 	if ((minor % nr_parts) == 0)
807 		nr_minors = nr_parts;
808 
809 	err = xlbd_reserve_minors(minor, nr_minors);
810 	if (err)
811 		goto out;
812 	err = -ENODEV;
813 
814 	gd = alloc_disk(nr_minors);
815 	if (gd == NULL)
816 		goto release;
817 
818 	strcpy(gd->disk_name, DEV_NAME);
819 	ptr = encode_disk_name(gd->disk_name + sizeof(DEV_NAME) - 1, offset);
820 	BUG_ON(ptr >= gd->disk_name + DISK_NAME_LEN);
821 	if (nr_minors > 1)
822 		*ptr = 0;
823 	else
824 		snprintf(ptr, gd->disk_name + DISK_NAME_LEN - ptr,
825 			 "%d", minor & (nr_parts - 1));
826 
827 	gd->major = XENVBD_MAJOR;
828 	gd->first_minor = minor;
829 	gd->fops = &xlvbd_block_fops;
830 	gd->private_data = info;
831 	gd->driverfs_dev = &(info->xbdev->dev);
832 	set_capacity(gd, capacity);
833 
834 	if (xlvbd_init_blk_queue(gd, sector_size, physical_sector_size,
835 				 info->max_indirect_segments ? :
836 				 BLKIF_MAX_SEGMENTS_PER_REQUEST)) {
837 		del_gendisk(gd);
838 		goto release;
839 	}
840 
841 	info->rq = gd->queue;
842 	info->gd = gd;
843 
844 	xlvbd_flush(info);
845 
846 	if (vdisk_info & VDISK_READONLY)
847 		set_disk_ro(gd, 1);
848 
849 	if (vdisk_info & VDISK_REMOVABLE)
850 		gd->flags |= GENHD_FL_REMOVABLE;
851 
852 	if (vdisk_info & VDISK_CDROM)
853 		gd->flags |= GENHD_FL_CD;
854 
855 	return 0;
856 
857  release:
858 	xlbd_release_minors(minor, nr_minors);
859  out:
860 	return err;
861 }
862 
863 static void xlvbd_release_gendisk(struct blkfront_info *info)
864 {
865 	unsigned int minor, nr_minors;
866 	unsigned long flags;
867 
868 	if (info->rq == NULL)
869 		return;
870 
871 	spin_lock_irqsave(&info->io_lock, flags);
872 
873 	/* No more blkif_request(). */
874 	blk_stop_queue(info->rq);
875 
876 	/* No more gnttab callback work. */
877 	gnttab_cancel_free_callback(&info->callback);
878 	spin_unlock_irqrestore(&info->io_lock, flags);
879 
880 	/* Flush gnttab callback work. Must be done with no locks held. */
881 	flush_work(&info->work);
882 
883 	del_gendisk(info->gd);
884 
885 	minor = info->gd->first_minor;
886 	nr_minors = info->gd->minors;
887 	xlbd_release_minors(minor, nr_minors);
888 
889 	blk_cleanup_queue(info->rq);
890 	info->rq = NULL;
891 
892 	put_disk(info->gd);
893 	info->gd = NULL;
894 }
895 
896 static void kick_pending_request_queues(struct blkfront_info *info)
897 {
898 	if (!RING_FULL(&info->ring)) {
899 		/* Re-enable calldowns. */
900 		blk_start_queue(info->rq);
901 		/* Kick things off immediately. */
902 		do_blkif_request(info->rq);
903 	}
904 }
905 
906 static void blkif_restart_queue(struct work_struct *work)
907 {
908 	struct blkfront_info *info = container_of(work, struct blkfront_info, work);
909 
910 	spin_lock_irq(&info->io_lock);
911 	if (info->connected == BLKIF_STATE_CONNECTED)
912 		kick_pending_request_queues(info);
913 	spin_unlock_irq(&info->io_lock);
914 }
915 
916 static void blkif_free(struct blkfront_info *info, int suspend)
917 {
918 	struct grant *persistent_gnt;
919 	struct grant *n;
920 	int i, j, segs;
921 
922 	/* Prevent new requests being issued until we fix things up. */
923 	spin_lock_irq(&info->io_lock);
924 	info->connected = suspend ?
925 		BLKIF_STATE_SUSPENDED : BLKIF_STATE_DISCONNECTED;
926 	/* No more blkif_request(). */
927 	if (info->rq)
928 		blk_stop_queue(info->rq);
929 
930 	/* Remove all persistent grants */
931 	if (!list_empty(&info->grants)) {
932 		list_for_each_entry_safe(persistent_gnt, n,
933 		                         &info->grants, node) {
934 			list_del(&persistent_gnt->node);
935 			if (persistent_gnt->gref != GRANT_INVALID_REF) {
936 				gnttab_end_foreign_access(persistent_gnt->gref,
937 				                          0, 0UL);
938 				info->persistent_gnts_c--;
939 			}
940 			if (info->feature_persistent)
941 				__free_page(pfn_to_page(persistent_gnt->pfn));
942 			kfree(persistent_gnt);
943 		}
944 	}
945 	BUG_ON(info->persistent_gnts_c != 0);
946 
947 	/*
948 	 * Remove indirect pages, this only happens when using indirect
949 	 * descriptors but not persistent grants
950 	 */
951 	if (!list_empty(&info->indirect_pages)) {
952 		struct page *indirect_page, *n;
953 
954 		BUG_ON(info->feature_persistent);
955 		list_for_each_entry_safe(indirect_page, n, &info->indirect_pages, lru) {
956 			list_del(&indirect_page->lru);
957 			__free_page(indirect_page);
958 		}
959 	}
960 
961 	for (i = 0; i < BLK_RING_SIZE; i++) {
962 		/*
963 		 * Clear persistent grants present in requests already
964 		 * on the shared ring
965 		 */
966 		if (!info->shadow[i].request)
967 			goto free_shadow;
968 
969 		segs = info->shadow[i].req.operation == BLKIF_OP_INDIRECT ?
970 		       info->shadow[i].req.u.indirect.nr_segments :
971 		       info->shadow[i].req.u.rw.nr_segments;
972 		for (j = 0; j < segs; j++) {
973 			persistent_gnt = info->shadow[i].grants_used[j];
974 			gnttab_end_foreign_access(persistent_gnt->gref, 0, 0UL);
975 			if (info->feature_persistent)
976 				__free_page(pfn_to_page(persistent_gnt->pfn));
977 			kfree(persistent_gnt);
978 		}
979 
980 		if (info->shadow[i].req.operation != BLKIF_OP_INDIRECT)
981 			/*
982 			 * If this is not an indirect operation don't try to
983 			 * free indirect segments
984 			 */
985 			goto free_shadow;
986 
987 		for (j = 0; j < INDIRECT_GREFS(segs); j++) {
988 			persistent_gnt = info->shadow[i].indirect_grants[j];
989 			gnttab_end_foreign_access(persistent_gnt->gref, 0, 0UL);
990 			__free_page(pfn_to_page(persistent_gnt->pfn));
991 			kfree(persistent_gnt);
992 		}
993 
994 free_shadow:
995 		kfree(info->shadow[i].grants_used);
996 		info->shadow[i].grants_used = NULL;
997 		kfree(info->shadow[i].indirect_grants);
998 		info->shadow[i].indirect_grants = NULL;
999 		kfree(info->shadow[i].sg);
1000 		info->shadow[i].sg = NULL;
1001 	}
1002 
1003 	/* No more gnttab callback work. */
1004 	gnttab_cancel_free_callback(&info->callback);
1005 	spin_unlock_irq(&info->io_lock);
1006 
1007 	/* Flush gnttab callback work. Must be done with no locks held. */
1008 	flush_work(&info->work);
1009 
1010 	/* Free resources associated with old device channel. */
1011 	if (info->ring_ref != GRANT_INVALID_REF) {
1012 		gnttab_end_foreign_access(info->ring_ref, 0,
1013 					  (unsigned long)info->ring.sring);
1014 		info->ring_ref = GRANT_INVALID_REF;
1015 		info->ring.sring = NULL;
1016 	}
1017 	if (info->irq)
1018 		unbind_from_irqhandler(info->irq, info);
1019 	info->evtchn = info->irq = 0;
1020 
1021 }
1022 
1023 static void blkif_completion(struct blk_shadow *s, struct blkfront_info *info,
1024 			     struct blkif_response *bret)
1025 {
1026 	int i = 0;
1027 	struct scatterlist *sg;
1028 	char *bvec_data;
1029 	void *shared_data;
1030 	int nseg;
1031 
1032 	nseg = s->req.operation == BLKIF_OP_INDIRECT ?
1033 		s->req.u.indirect.nr_segments : s->req.u.rw.nr_segments;
1034 
1035 	if (bret->operation == BLKIF_OP_READ && info->feature_persistent) {
1036 		/*
1037 		 * Copy the data received from the backend into the bvec.
1038 		 * Since bv_offset can be different than 0, and bv_len different
1039 		 * than PAGE_SIZE, we have to keep track of the current offset,
1040 		 * to be sure we are copying the data from the right shared page.
1041 		 */
1042 		for_each_sg(s->sg, sg, nseg, i) {
1043 			BUG_ON(sg->offset + sg->length > PAGE_SIZE);
1044 			shared_data = kmap_atomic(
1045 				pfn_to_page(s->grants_used[i]->pfn));
1046 			bvec_data = kmap_atomic(sg_page(sg));
1047 			memcpy(bvec_data   + sg->offset,
1048 			       shared_data + sg->offset,
1049 			       sg->length);
1050 			kunmap_atomic(bvec_data);
1051 			kunmap_atomic(shared_data);
1052 		}
1053 	}
1054 	/* Add the persistent grant into the list of free grants */
1055 	for (i = 0; i < nseg; i++) {
1056 		if (gnttab_query_foreign_access(s->grants_used[i]->gref)) {
1057 			/*
1058 			 * If the grant is still mapped by the backend (the
1059 			 * backend has chosen to make this grant persistent)
1060 			 * we add it at the head of the list, so it will be
1061 			 * reused first.
1062 			 */
1063 			if (!info->feature_persistent)
1064 				pr_alert_ratelimited("backed has not unmapped grant: %u\n",
1065 						     s->grants_used[i]->gref);
1066 			list_add(&s->grants_used[i]->node, &info->grants);
1067 			info->persistent_gnts_c++;
1068 		} else {
1069 			/*
1070 			 * If the grant is not mapped by the backend we end the
1071 			 * foreign access and add it to the tail of the list,
1072 			 * so it will not be picked again unless we run out of
1073 			 * persistent grants.
1074 			 */
1075 			gnttab_end_foreign_access(s->grants_used[i]->gref, 0, 0UL);
1076 			s->grants_used[i]->gref = GRANT_INVALID_REF;
1077 			list_add_tail(&s->grants_used[i]->node, &info->grants);
1078 		}
1079 	}
1080 	if (s->req.operation == BLKIF_OP_INDIRECT) {
1081 		for (i = 0; i < INDIRECT_GREFS(nseg); i++) {
1082 			if (gnttab_query_foreign_access(s->indirect_grants[i]->gref)) {
1083 				if (!info->feature_persistent)
1084 					pr_alert_ratelimited("backed has not unmapped grant: %u\n",
1085 							     s->indirect_grants[i]->gref);
1086 				list_add(&s->indirect_grants[i]->node, &info->grants);
1087 				info->persistent_gnts_c++;
1088 			} else {
1089 				struct page *indirect_page;
1090 
1091 				gnttab_end_foreign_access(s->indirect_grants[i]->gref, 0, 0UL);
1092 				/*
1093 				 * Add the used indirect page back to the list of
1094 				 * available pages for indirect grefs.
1095 				 */
1096 				indirect_page = pfn_to_page(s->indirect_grants[i]->pfn);
1097 				list_add(&indirect_page->lru, &info->indirect_pages);
1098 				s->indirect_grants[i]->gref = GRANT_INVALID_REF;
1099 				list_add_tail(&s->indirect_grants[i]->node, &info->grants);
1100 			}
1101 		}
1102 	}
1103 }
1104 
1105 static irqreturn_t blkif_interrupt(int irq, void *dev_id)
1106 {
1107 	struct request *req;
1108 	struct blkif_response *bret;
1109 	RING_IDX i, rp;
1110 	unsigned long flags;
1111 	struct blkfront_info *info = (struct blkfront_info *)dev_id;
1112 	int error;
1113 
1114 	spin_lock_irqsave(&info->io_lock, flags);
1115 
1116 	if (unlikely(info->connected != BLKIF_STATE_CONNECTED)) {
1117 		spin_unlock_irqrestore(&info->io_lock, flags);
1118 		return IRQ_HANDLED;
1119 	}
1120 
1121  again:
1122 	rp = info->ring.sring->rsp_prod;
1123 	rmb(); /* Ensure we see queued responses up to 'rp'. */
1124 
1125 	for (i = info->ring.rsp_cons; i != rp; i++) {
1126 		unsigned long id;
1127 
1128 		bret = RING_GET_RESPONSE(&info->ring, i);
1129 		id   = bret->id;
1130 		/*
1131 		 * The backend has messed up and given us an id that we would
1132 		 * never have given to it (we stamp it up to BLK_RING_SIZE -
1133 		 * look in get_id_from_freelist.
1134 		 */
1135 		if (id >= BLK_RING_SIZE) {
1136 			WARN(1, "%s: response to %s has incorrect id (%ld)\n",
1137 			     info->gd->disk_name, op_name(bret->operation), id);
1138 			/* We can't safely get the 'struct request' as
1139 			 * the id is busted. */
1140 			continue;
1141 		}
1142 		req  = info->shadow[id].request;
1143 
1144 		if (bret->operation != BLKIF_OP_DISCARD)
1145 			blkif_completion(&info->shadow[id], info, bret);
1146 
1147 		if (add_id_to_freelist(info, id)) {
1148 			WARN(1, "%s: response to %s (id %ld) couldn't be recycled!\n",
1149 			     info->gd->disk_name, op_name(bret->operation), id);
1150 			continue;
1151 		}
1152 
1153 		error = (bret->status == BLKIF_RSP_OKAY) ? 0 : -EIO;
1154 		switch (bret->operation) {
1155 		case BLKIF_OP_DISCARD:
1156 			if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
1157 				struct request_queue *rq = info->rq;
1158 				printk(KERN_WARNING "blkfront: %s: %s op failed\n",
1159 					   info->gd->disk_name, op_name(bret->operation));
1160 				error = -EOPNOTSUPP;
1161 				info->feature_discard = 0;
1162 				info->feature_secdiscard = 0;
1163 				queue_flag_clear(QUEUE_FLAG_DISCARD, rq);
1164 				queue_flag_clear(QUEUE_FLAG_SECDISCARD, rq);
1165 			}
1166 			__blk_end_request_all(req, error);
1167 			break;
1168 		case BLKIF_OP_FLUSH_DISKCACHE:
1169 		case BLKIF_OP_WRITE_BARRIER:
1170 			if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
1171 				printk(KERN_WARNING "blkfront: %s: %s op failed\n",
1172 				       info->gd->disk_name, op_name(bret->operation));
1173 				error = -EOPNOTSUPP;
1174 			}
1175 			if (unlikely(bret->status == BLKIF_RSP_ERROR &&
1176 				     info->shadow[id].req.u.rw.nr_segments == 0)) {
1177 				printk(KERN_WARNING "blkfront: %s: empty %s op failed\n",
1178 				       info->gd->disk_name, op_name(bret->operation));
1179 				error = -EOPNOTSUPP;
1180 			}
1181 			if (unlikely(error)) {
1182 				if (error == -EOPNOTSUPP)
1183 					error = 0;
1184 				info->feature_flush = 0;
1185 				info->flush_op = 0;
1186 				xlvbd_flush(info);
1187 			}
1188 			/* fall through */
1189 		case BLKIF_OP_READ:
1190 		case BLKIF_OP_WRITE:
1191 			if (unlikely(bret->status != BLKIF_RSP_OKAY))
1192 				dev_dbg(&info->xbdev->dev, "Bad return from blkdev data "
1193 					"request: %x\n", bret->status);
1194 
1195 			__blk_end_request_all(req, error);
1196 			break;
1197 		default:
1198 			BUG();
1199 		}
1200 	}
1201 
1202 	info->ring.rsp_cons = i;
1203 
1204 	if (i != info->ring.req_prod_pvt) {
1205 		int more_to_do;
1206 		RING_FINAL_CHECK_FOR_RESPONSES(&info->ring, more_to_do);
1207 		if (more_to_do)
1208 			goto again;
1209 	} else
1210 		info->ring.sring->rsp_event = i + 1;
1211 
1212 	kick_pending_request_queues(info);
1213 
1214 	spin_unlock_irqrestore(&info->io_lock, flags);
1215 
1216 	return IRQ_HANDLED;
1217 }
1218 
1219 
1220 static int setup_blkring(struct xenbus_device *dev,
1221 			 struct blkfront_info *info)
1222 {
1223 	struct blkif_sring *sring;
1224 	int err;
1225 
1226 	info->ring_ref = GRANT_INVALID_REF;
1227 
1228 	sring = (struct blkif_sring *)__get_free_page(GFP_NOIO | __GFP_HIGH);
1229 	if (!sring) {
1230 		xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring");
1231 		return -ENOMEM;
1232 	}
1233 	SHARED_RING_INIT(sring);
1234 	FRONT_RING_INIT(&info->ring, sring, PAGE_SIZE);
1235 
1236 	err = xenbus_grant_ring(dev, virt_to_mfn(info->ring.sring));
1237 	if (err < 0) {
1238 		free_page((unsigned long)sring);
1239 		info->ring.sring = NULL;
1240 		goto fail;
1241 	}
1242 	info->ring_ref = err;
1243 
1244 	err = xenbus_alloc_evtchn(dev, &info->evtchn);
1245 	if (err)
1246 		goto fail;
1247 
1248 	err = bind_evtchn_to_irqhandler(info->evtchn, blkif_interrupt, 0,
1249 					"blkif", info);
1250 	if (err <= 0) {
1251 		xenbus_dev_fatal(dev, err,
1252 				 "bind_evtchn_to_irqhandler failed");
1253 		goto fail;
1254 	}
1255 	info->irq = err;
1256 
1257 	return 0;
1258 fail:
1259 	blkif_free(info, 0);
1260 	return err;
1261 }
1262 
1263 
1264 /* Common code used when first setting up, and when resuming. */
1265 static int talk_to_blkback(struct xenbus_device *dev,
1266 			   struct blkfront_info *info)
1267 {
1268 	const char *message = NULL;
1269 	struct xenbus_transaction xbt;
1270 	int err;
1271 
1272 	/* Create shared ring, alloc event channel. */
1273 	err = setup_blkring(dev, info);
1274 	if (err)
1275 		goto out;
1276 
1277 again:
1278 	err = xenbus_transaction_start(&xbt);
1279 	if (err) {
1280 		xenbus_dev_fatal(dev, err, "starting transaction");
1281 		goto destroy_blkring;
1282 	}
1283 
1284 	err = xenbus_printf(xbt, dev->nodename,
1285 			    "ring-ref", "%u", info->ring_ref);
1286 	if (err) {
1287 		message = "writing ring-ref";
1288 		goto abort_transaction;
1289 	}
1290 	err = xenbus_printf(xbt, dev->nodename,
1291 			    "event-channel", "%u", info->evtchn);
1292 	if (err) {
1293 		message = "writing event-channel";
1294 		goto abort_transaction;
1295 	}
1296 	err = xenbus_printf(xbt, dev->nodename, "protocol", "%s",
1297 			    XEN_IO_PROTO_ABI_NATIVE);
1298 	if (err) {
1299 		message = "writing protocol";
1300 		goto abort_transaction;
1301 	}
1302 	err = xenbus_printf(xbt, dev->nodename,
1303 			    "feature-persistent", "%u", 1);
1304 	if (err)
1305 		dev_warn(&dev->dev,
1306 			 "writing persistent grants feature to xenbus");
1307 
1308 	err = xenbus_transaction_end(xbt, 0);
1309 	if (err) {
1310 		if (err == -EAGAIN)
1311 			goto again;
1312 		xenbus_dev_fatal(dev, err, "completing transaction");
1313 		goto destroy_blkring;
1314 	}
1315 
1316 	xenbus_switch_state(dev, XenbusStateInitialised);
1317 
1318 	return 0;
1319 
1320  abort_transaction:
1321 	xenbus_transaction_end(xbt, 1);
1322 	if (message)
1323 		xenbus_dev_fatal(dev, err, "%s", message);
1324  destroy_blkring:
1325 	blkif_free(info, 0);
1326  out:
1327 	return err;
1328 }
1329 
1330 /**
1331  * Entry point to this code when a new device is created.  Allocate the basic
1332  * structures and the ring buffer for communication with the backend, and
1333  * inform the backend of the appropriate details for those.  Switch to
1334  * Initialised state.
1335  */
1336 static int blkfront_probe(struct xenbus_device *dev,
1337 			  const struct xenbus_device_id *id)
1338 {
1339 	int err, vdevice, i;
1340 	struct blkfront_info *info;
1341 
1342 	/* FIXME: Use dynamic device id if this is not set. */
1343 	err = xenbus_scanf(XBT_NIL, dev->nodename,
1344 			   "virtual-device", "%i", &vdevice);
1345 	if (err != 1) {
1346 		/* go looking in the extended area instead */
1347 		err = xenbus_scanf(XBT_NIL, dev->nodename, "virtual-device-ext",
1348 				   "%i", &vdevice);
1349 		if (err != 1) {
1350 			xenbus_dev_fatal(dev, err, "reading virtual-device");
1351 			return err;
1352 		}
1353 	}
1354 
1355 	if (xen_hvm_domain()) {
1356 		char *type;
1357 		int len;
1358 		/* no unplug has been done: do not hook devices != xen vbds */
1359 		if (xen_has_pv_and_legacy_disk_devices()) {
1360 			int major;
1361 
1362 			if (!VDEV_IS_EXTENDED(vdevice))
1363 				major = BLKIF_MAJOR(vdevice);
1364 			else
1365 				major = XENVBD_MAJOR;
1366 
1367 			if (major != XENVBD_MAJOR) {
1368 				printk(KERN_INFO
1369 						"%s: HVM does not support vbd %d as xen block device\n",
1370 						__FUNCTION__, vdevice);
1371 				return -ENODEV;
1372 			}
1373 		}
1374 		/* do not create a PV cdrom device if we are an HVM guest */
1375 		type = xenbus_read(XBT_NIL, dev->nodename, "device-type", &len);
1376 		if (IS_ERR(type))
1377 			return -ENODEV;
1378 		if (strncmp(type, "cdrom", 5) == 0) {
1379 			kfree(type);
1380 			return -ENODEV;
1381 		}
1382 		kfree(type);
1383 	}
1384 	info = kzalloc(sizeof(*info), GFP_KERNEL);
1385 	if (!info) {
1386 		xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
1387 		return -ENOMEM;
1388 	}
1389 
1390 	mutex_init(&info->mutex);
1391 	spin_lock_init(&info->io_lock);
1392 	info->xbdev = dev;
1393 	info->vdevice = vdevice;
1394 	INIT_LIST_HEAD(&info->grants);
1395 	INIT_LIST_HEAD(&info->indirect_pages);
1396 	info->persistent_gnts_c = 0;
1397 	info->connected = BLKIF_STATE_DISCONNECTED;
1398 	INIT_WORK(&info->work, blkif_restart_queue);
1399 
1400 	for (i = 0; i < BLK_RING_SIZE; i++)
1401 		info->shadow[i].req.u.rw.id = i+1;
1402 	info->shadow[BLK_RING_SIZE-1].req.u.rw.id = 0x0fffffff;
1403 
1404 	/* Front end dir is a number, which is used as the id. */
1405 	info->handle = simple_strtoul(strrchr(dev->nodename, '/')+1, NULL, 0);
1406 	dev_set_drvdata(&dev->dev, info);
1407 
1408 	err = talk_to_blkback(dev, info);
1409 	if (err) {
1410 		kfree(info);
1411 		dev_set_drvdata(&dev->dev, NULL);
1412 		return err;
1413 	}
1414 
1415 	return 0;
1416 }
1417 
1418 static void split_bio_end(struct bio *bio, int error)
1419 {
1420 	struct split_bio *split_bio = bio->bi_private;
1421 
1422 	if (error)
1423 		split_bio->err = error;
1424 
1425 	if (atomic_dec_and_test(&split_bio->pending)) {
1426 		split_bio->bio->bi_phys_segments = 0;
1427 		bio_endio(split_bio->bio, split_bio->err);
1428 		kfree(split_bio);
1429 	}
1430 	bio_put(bio);
1431 }
1432 
1433 static int blkif_recover(struct blkfront_info *info)
1434 {
1435 	int i;
1436 	struct request *req, *n;
1437 	struct blk_shadow *copy;
1438 	int rc;
1439 	struct bio *bio, *cloned_bio;
1440 	struct bio_list bio_list, merge_bio;
1441 	unsigned int segs, offset;
1442 	int pending, size;
1443 	struct split_bio *split_bio;
1444 	struct list_head requests;
1445 
1446 	/* Stage 1: Make a safe copy of the shadow state. */
1447 	copy = kmemdup(info->shadow, sizeof(info->shadow),
1448 		       GFP_NOIO | __GFP_REPEAT | __GFP_HIGH);
1449 	if (!copy)
1450 		return -ENOMEM;
1451 
1452 	/* Stage 2: Set up free list. */
1453 	memset(&info->shadow, 0, sizeof(info->shadow));
1454 	for (i = 0; i < BLK_RING_SIZE; i++)
1455 		info->shadow[i].req.u.rw.id = i+1;
1456 	info->shadow_free = info->ring.req_prod_pvt;
1457 	info->shadow[BLK_RING_SIZE-1].req.u.rw.id = 0x0fffffff;
1458 
1459 	rc = blkfront_setup_indirect(info);
1460 	if (rc) {
1461 		kfree(copy);
1462 		return rc;
1463 	}
1464 
1465 	segs = info->max_indirect_segments ? : BLKIF_MAX_SEGMENTS_PER_REQUEST;
1466 	blk_queue_max_segments(info->rq, segs);
1467 	bio_list_init(&bio_list);
1468 	INIT_LIST_HEAD(&requests);
1469 	for (i = 0; i < BLK_RING_SIZE; i++) {
1470 		/* Not in use? */
1471 		if (!copy[i].request)
1472 			continue;
1473 
1474 		/*
1475 		 * Get the bios in the request so we can re-queue them.
1476 		 */
1477 		if (copy[i].request->cmd_flags &
1478 		    (REQ_FLUSH | REQ_FUA | REQ_DISCARD | REQ_SECURE)) {
1479 			/*
1480 			 * Flush operations don't contain bios, so
1481 			 * we need to requeue the whole request
1482 			 */
1483 			list_add(&copy[i].request->queuelist, &requests);
1484 			continue;
1485 		}
1486 		merge_bio.head = copy[i].request->bio;
1487 		merge_bio.tail = copy[i].request->biotail;
1488 		bio_list_merge(&bio_list, &merge_bio);
1489 		copy[i].request->bio = NULL;
1490 		blk_put_request(copy[i].request);
1491 	}
1492 
1493 	kfree(copy);
1494 
1495 	/*
1496 	 * Empty the queue, this is important because we might have
1497 	 * requests in the queue with more segments than what we
1498 	 * can handle now.
1499 	 */
1500 	spin_lock_irq(&info->io_lock);
1501 	while ((req = blk_fetch_request(info->rq)) != NULL) {
1502 		if (req->cmd_flags &
1503 		    (REQ_FLUSH | REQ_FUA | REQ_DISCARD | REQ_SECURE)) {
1504 			list_add(&req->queuelist, &requests);
1505 			continue;
1506 		}
1507 		merge_bio.head = req->bio;
1508 		merge_bio.tail = req->biotail;
1509 		bio_list_merge(&bio_list, &merge_bio);
1510 		req->bio = NULL;
1511 		if (req->cmd_flags & (REQ_FLUSH | REQ_FUA))
1512 			pr_alert("diskcache flush request found!\n");
1513 		__blk_put_request(info->rq, req);
1514 	}
1515 	spin_unlock_irq(&info->io_lock);
1516 
1517 	xenbus_switch_state(info->xbdev, XenbusStateConnected);
1518 
1519 	spin_lock_irq(&info->io_lock);
1520 
1521 	/* Now safe for us to use the shared ring */
1522 	info->connected = BLKIF_STATE_CONNECTED;
1523 
1524 	/* Kick any other new requests queued since we resumed */
1525 	kick_pending_request_queues(info);
1526 
1527 	list_for_each_entry_safe(req, n, &requests, queuelist) {
1528 		/* Requeue pending requests (flush or discard) */
1529 		list_del_init(&req->queuelist);
1530 		BUG_ON(req->nr_phys_segments > segs);
1531 		blk_requeue_request(info->rq, req);
1532 	}
1533 	spin_unlock_irq(&info->io_lock);
1534 
1535 	while ((bio = bio_list_pop(&bio_list)) != NULL) {
1536 		/* Traverse the list of pending bios and re-queue them */
1537 		if (bio_segments(bio) > segs) {
1538 			/*
1539 			 * This bio has more segments than what we can
1540 			 * handle, we have to split it.
1541 			 */
1542 			pending = (bio_segments(bio) + segs - 1) / segs;
1543 			split_bio = kzalloc(sizeof(*split_bio), GFP_NOIO);
1544 			BUG_ON(split_bio == NULL);
1545 			atomic_set(&split_bio->pending, pending);
1546 			split_bio->bio = bio;
1547 			for (i = 0; i < pending; i++) {
1548 				offset = (i * segs * PAGE_SIZE) >> 9;
1549 				size = min((unsigned int)(segs * PAGE_SIZE) >> 9,
1550 					   (unsigned int)bio_sectors(bio) - offset);
1551 				cloned_bio = bio_clone(bio, GFP_NOIO);
1552 				BUG_ON(cloned_bio == NULL);
1553 				bio_trim(cloned_bio, offset, size);
1554 				cloned_bio->bi_private = split_bio;
1555 				cloned_bio->bi_end_io = split_bio_end;
1556 				submit_bio(cloned_bio->bi_rw, cloned_bio);
1557 			}
1558 			/*
1559 			 * Now we have to wait for all those smaller bios to
1560 			 * end, so we can also end the "parent" bio.
1561 			 */
1562 			continue;
1563 		}
1564 		/* We don't need to split this bio */
1565 		submit_bio(bio->bi_rw, bio);
1566 	}
1567 
1568 	return 0;
1569 }
1570 
1571 /**
1572  * We are reconnecting to the backend, due to a suspend/resume, or a backend
1573  * driver restart.  We tear down our blkif structure and recreate it, but
1574  * leave the device-layer structures intact so that this is transparent to the
1575  * rest of the kernel.
1576  */
1577 static int blkfront_resume(struct xenbus_device *dev)
1578 {
1579 	struct blkfront_info *info = dev_get_drvdata(&dev->dev);
1580 	int err;
1581 
1582 	dev_dbg(&dev->dev, "blkfront_resume: %s\n", dev->nodename);
1583 
1584 	blkif_free(info, info->connected == BLKIF_STATE_CONNECTED);
1585 
1586 	err = talk_to_blkback(dev, info);
1587 
1588 	/*
1589 	 * We have to wait for the backend to switch to
1590 	 * connected state, since we want to read which
1591 	 * features it supports.
1592 	 */
1593 
1594 	return err;
1595 }
1596 
1597 static void
1598 blkfront_closing(struct blkfront_info *info)
1599 {
1600 	struct xenbus_device *xbdev = info->xbdev;
1601 	struct block_device *bdev = NULL;
1602 
1603 	mutex_lock(&info->mutex);
1604 
1605 	if (xbdev->state == XenbusStateClosing) {
1606 		mutex_unlock(&info->mutex);
1607 		return;
1608 	}
1609 
1610 	if (info->gd)
1611 		bdev = bdget_disk(info->gd, 0);
1612 
1613 	mutex_unlock(&info->mutex);
1614 
1615 	if (!bdev) {
1616 		xenbus_frontend_closed(xbdev);
1617 		return;
1618 	}
1619 
1620 	mutex_lock(&bdev->bd_mutex);
1621 
1622 	if (bdev->bd_openers) {
1623 		xenbus_dev_error(xbdev, -EBUSY,
1624 				 "Device in use; refusing to close");
1625 		xenbus_switch_state(xbdev, XenbusStateClosing);
1626 	} else {
1627 		xlvbd_release_gendisk(info);
1628 		xenbus_frontend_closed(xbdev);
1629 	}
1630 
1631 	mutex_unlock(&bdev->bd_mutex);
1632 	bdput(bdev);
1633 }
1634 
1635 static void blkfront_setup_discard(struct blkfront_info *info)
1636 {
1637 	int err;
1638 	unsigned int discard_granularity;
1639 	unsigned int discard_alignment;
1640 	unsigned int discard_secure;
1641 
1642 	info->feature_discard = 1;
1643 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1644 		"discard-granularity", "%u", &discard_granularity,
1645 		"discard-alignment", "%u", &discard_alignment,
1646 		NULL);
1647 	if (!err) {
1648 		info->discard_granularity = discard_granularity;
1649 		info->discard_alignment = discard_alignment;
1650 	}
1651 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1652 		    "discard-secure", "%d", &discard_secure,
1653 		    NULL);
1654 	if (!err)
1655 		info->feature_secdiscard = !!discard_secure;
1656 }
1657 
1658 static int blkfront_setup_indirect(struct blkfront_info *info)
1659 {
1660 	unsigned int indirect_segments, segs;
1661 	int err, i;
1662 
1663 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1664 			    "feature-max-indirect-segments", "%u", &indirect_segments,
1665 			    NULL);
1666 	if (err) {
1667 		info->max_indirect_segments = 0;
1668 		segs = BLKIF_MAX_SEGMENTS_PER_REQUEST;
1669 	} else {
1670 		info->max_indirect_segments = min(indirect_segments,
1671 						  xen_blkif_max_segments);
1672 		segs = info->max_indirect_segments;
1673 	}
1674 
1675 	err = fill_grant_buffer(info, (segs + INDIRECT_GREFS(segs)) * BLK_RING_SIZE);
1676 	if (err)
1677 		goto out_of_memory;
1678 
1679 	if (!info->feature_persistent && info->max_indirect_segments) {
1680 		/*
1681 		 * We are using indirect descriptors but not persistent
1682 		 * grants, we need to allocate a set of pages that can be
1683 		 * used for mapping indirect grefs
1684 		 */
1685 		int num = INDIRECT_GREFS(segs) * BLK_RING_SIZE;
1686 
1687 		BUG_ON(!list_empty(&info->indirect_pages));
1688 		for (i = 0; i < num; i++) {
1689 			struct page *indirect_page = alloc_page(GFP_NOIO);
1690 			if (!indirect_page)
1691 				goto out_of_memory;
1692 			list_add(&indirect_page->lru, &info->indirect_pages);
1693 		}
1694 	}
1695 
1696 	for (i = 0; i < BLK_RING_SIZE; i++) {
1697 		info->shadow[i].grants_used = kzalloc(
1698 			sizeof(info->shadow[i].grants_used[0]) * segs,
1699 			GFP_NOIO);
1700 		info->shadow[i].sg = kzalloc(sizeof(info->shadow[i].sg[0]) * segs, GFP_NOIO);
1701 		if (info->max_indirect_segments)
1702 			info->shadow[i].indirect_grants = kzalloc(
1703 				sizeof(info->shadow[i].indirect_grants[0]) *
1704 				INDIRECT_GREFS(segs),
1705 				GFP_NOIO);
1706 		if ((info->shadow[i].grants_used == NULL) ||
1707 			(info->shadow[i].sg == NULL) ||
1708 		     (info->max_indirect_segments &&
1709 		     (info->shadow[i].indirect_grants == NULL)))
1710 			goto out_of_memory;
1711 		sg_init_table(info->shadow[i].sg, segs);
1712 	}
1713 
1714 
1715 	return 0;
1716 
1717 out_of_memory:
1718 	for (i = 0; i < BLK_RING_SIZE; i++) {
1719 		kfree(info->shadow[i].grants_used);
1720 		info->shadow[i].grants_used = NULL;
1721 		kfree(info->shadow[i].sg);
1722 		info->shadow[i].sg = NULL;
1723 		kfree(info->shadow[i].indirect_grants);
1724 		info->shadow[i].indirect_grants = NULL;
1725 	}
1726 	if (!list_empty(&info->indirect_pages)) {
1727 		struct page *indirect_page, *n;
1728 		list_for_each_entry_safe(indirect_page, n, &info->indirect_pages, lru) {
1729 			list_del(&indirect_page->lru);
1730 			__free_page(indirect_page);
1731 		}
1732 	}
1733 	return -ENOMEM;
1734 }
1735 
1736 /*
1737  * Invoked when the backend is finally 'ready' (and has told produced
1738  * the details about the physical device - #sectors, size, etc).
1739  */
1740 static void blkfront_connect(struct blkfront_info *info)
1741 {
1742 	unsigned long long sectors;
1743 	unsigned long sector_size;
1744 	unsigned int physical_sector_size;
1745 	unsigned int binfo;
1746 	int err;
1747 	int barrier, flush, discard, persistent;
1748 
1749 	switch (info->connected) {
1750 	case BLKIF_STATE_CONNECTED:
1751 		/*
1752 		 * Potentially, the back-end may be signalling
1753 		 * a capacity change; update the capacity.
1754 		 */
1755 		err = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
1756 				   "sectors", "%Lu", &sectors);
1757 		if (XENBUS_EXIST_ERR(err))
1758 			return;
1759 		printk(KERN_INFO "Setting capacity to %Lu\n",
1760 		       sectors);
1761 		set_capacity(info->gd, sectors);
1762 		revalidate_disk(info->gd);
1763 
1764 		return;
1765 	case BLKIF_STATE_SUSPENDED:
1766 		/*
1767 		 * If we are recovering from suspension, we need to wait
1768 		 * for the backend to announce it's features before
1769 		 * reconnecting, at least we need to know if the backend
1770 		 * supports indirect descriptors, and how many.
1771 		 */
1772 		blkif_recover(info);
1773 		return;
1774 
1775 	default:
1776 		break;
1777 	}
1778 
1779 	dev_dbg(&info->xbdev->dev, "%s:%s.\n",
1780 		__func__, info->xbdev->otherend);
1781 
1782 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1783 			    "sectors", "%llu", &sectors,
1784 			    "info", "%u", &binfo,
1785 			    "sector-size", "%lu", &sector_size,
1786 			    NULL);
1787 	if (err) {
1788 		xenbus_dev_fatal(info->xbdev, err,
1789 				 "reading backend fields at %s",
1790 				 info->xbdev->otherend);
1791 		return;
1792 	}
1793 
1794 	/*
1795 	 * physcial-sector-size is a newer field, so old backends may not
1796 	 * provide this. Assume physical sector size to be the same as
1797 	 * sector_size in that case.
1798 	 */
1799 	err = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
1800 			   "physical-sector-size", "%u", &physical_sector_size);
1801 	if (err != 1)
1802 		physical_sector_size = sector_size;
1803 
1804 	info->feature_flush = 0;
1805 	info->flush_op = 0;
1806 
1807 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1808 			    "feature-barrier", "%d", &barrier,
1809 			    NULL);
1810 
1811 	/*
1812 	 * If there's no "feature-barrier" defined, then it means
1813 	 * we're dealing with a very old backend which writes
1814 	 * synchronously; nothing to do.
1815 	 *
1816 	 * If there are barriers, then we use flush.
1817 	 */
1818 	if (!err && barrier) {
1819 		info->feature_flush = REQ_FLUSH | REQ_FUA;
1820 		info->flush_op = BLKIF_OP_WRITE_BARRIER;
1821 	}
1822 	/*
1823 	 * And if there is "feature-flush-cache" use that above
1824 	 * barriers.
1825 	 */
1826 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1827 			    "feature-flush-cache", "%d", &flush,
1828 			    NULL);
1829 
1830 	if (!err && flush) {
1831 		info->feature_flush = REQ_FLUSH;
1832 		info->flush_op = BLKIF_OP_FLUSH_DISKCACHE;
1833 	}
1834 
1835 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1836 			    "feature-discard", "%d", &discard,
1837 			    NULL);
1838 
1839 	if (!err && discard)
1840 		blkfront_setup_discard(info);
1841 
1842 	err = xenbus_gather(XBT_NIL, info->xbdev->otherend,
1843 			    "feature-persistent", "%u", &persistent,
1844 			    NULL);
1845 	if (err)
1846 		info->feature_persistent = 0;
1847 	else
1848 		info->feature_persistent = persistent;
1849 
1850 	err = blkfront_setup_indirect(info);
1851 	if (err) {
1852 		xenbus_dev_fatal(info->xbdev, err, "setup_indirect at %s",
1853 				 info->xbdev->otherend);
1854 		return;
1855 	}
1856 
1857 	err = xlvbd_alloc_gendisk(sectors, info, binfo, sector_size,
1858 				  physical_sector_size);
1859 	if (err) {
1860 		xenbus_dev_fatal(info->xbdev, err, "xlvbd_add at %s",
1861 				 info->xbdev->otherend);
1862 		return;
1863 	}
1864 
1865 	xenbus_switch_state(info->xbdev, XenbusStateConnected);
1866 
1867 	/* Kick pending requests. */
1868 	spin_lock_irq(&info->io_lock);
1869 	info->connected = BLKIF_STATE_CONNECTED;
1870 	kick_pending_request_queues(info);
1871 	spin_unlock_irq(&info->io_lock);
1872 
1873 	add_disk(info->gd);
1874 
1875 	info->is_ready = 1;
1876 }
1877 
1878 /**
1879  * Callback received when the backend's state changes.
1880  */
1881 static void blkback_changed(struct xenbus_device *dev,
1882 			    enum xenbus_state backend_state)
1883 {
1884 	struct blkfront_info *info = dev_get_drvdata(&dev->dev);
1885 
1886 	dev_dbg(&dev->dev, "blkfront:blkback_changed to state %d.\n", backend_state);
1887 
1888 	switch (backend_state) {
1889 	case XenbusStateInitialising:
1890 	case XenbusStateInitWait:
1891 	case XenbusStateInitialised:
1892 	case XenbusStateReconfiguring:
1893 	case XenbusStateReconfigured:
1894 	case XenbusStateUnknown:
1895 		break;
1896 
1897 	case XenbusStateConnected:
1898 		blkfront_connect(info);
1899 		break;
1900 
1901 	case XenbusStateClosed:
1902 		if (dev->state == XenbusStateClosed)
1903 			break;
1904 		/* Missed the backend's Closing state -- fallthrough */
1905 	case XenbusStateClosing:
1906 		blkfront_closing(info);
1907 		break;
1908 	}
1909 }
1910 
1911 static int blkfront_remove(struct xenbus_device *xbdev)
1912 {
1913 	struct blkfront_info *info = dev_get_drvdata(&xbdev->dev);
1914 	struct block_device *bdev = NULL;
1915 	struct gendisk *disk;
1916 
1917 	dev_dbg(&xbdev->dev, "%s removed", xbdev->nodename);
1918 
1919 	blkif_free(info, 0);
1920 
1921 	mutex_lock(&info->mutex);
1922 
1923 	disk = info->gd;
1924 	if (disk)
1925 		bdev = bdget_disk(disk, 0);
1926 
1927 	info->xbdev = NULL;
1928 	mutex_unlock(&info->mutex);
1929 
1930 	if (!bdev) {
1931 		kfree(info);
1932 		return 0;
1933 	}
1934 
1935 	/*
1936 	 * The xbdev was removed before we reached the Closed
1937 	 * state. See if it's safe to remove the disk. If the bdev
1938 	 * isn't closed yet, we let release take care of it.
1939 	 */
1940 
1941 	mutex_lock(&bdev->bd_mutex);
1942 	info = disk->private_data;
1943 
1944 	dev_warn(disk_to_dev(disk),
1945 		 "%s was hot-unplugged, %d stale handles\n",
1946 		 xbdev->nodename, bdev->bd_openers);
1947 
1948 	if (info && !bdev->bd_openers) {
1949 		xlvbd_release_gendisk(info);
1950 		disk->private_data = NULL;
1951 		kfree(info);
1952 	}
1953 
1954 	mutex_unlock(&bdev->bd_mutex);
1955 	bdput(bdev);
1956 
1957 	return 0;
1958 }
1959 
1960 static int blkfront_is_ready(struct xenbus_device *dev)
1961 {
1962 	struct blkfront_info *info = dev_get_drvdata(&dev->dev);
1963 
1964 	return info->is_ready && info->xbdev;
1965 }
1966 
1967 static int blkif_open(struct block_device *bdev, fmode_t mode)
1968 {
1969 	struct gendisk *disk = bdev->bd_disk;
1970 	struct blkfront_info *info;
1971 	int err = 0;
1972 
1973 	mutex_lock(&blkfront_mutex);
1974 
1975 	info = disk->private_data;
1976 	if (!info) {
1977 		/* xbdev gone */
1978 		err = -ERESTARTSYS;
1979 		goto out;
1980 	}
1981 
1982 	mutex_lock(&info->mutex);
1983 
1984 	if (!info->gd)
1985 		/* xbdev is closed */
1986 		err = -ERESTARTSYS;
1987 
1988 	mutex_unlock(&info->mutex);
1989 
1990 out:
1991 	mutex_unlock(&blkfront_mutex);
1992 	return err;
1993 }
1994 
1995 static void blkif_release(struct gendisk *disk, fmode_t mode)
1996 {
1997 	struct blkfront_info *info = disk->private_data;
1998 	struct block_device *bdev;
1999 	struct xenbus_device *xbdev;
2000 
2001 	mutex_lock(&blkfront_mutex);
2002 
2003 	bdev = bdget_disk(disk, 0);
2004 
2005 	if (!bdev) {
2006 		WARN(1, "Block device %s yanked out from us!\n", disk->disk_name);
2007 		goto out_mutex;
2008 	}
2009 	if (bdev->bd_openers)
2010 		goto out;
2011 
2012 	/*
2013 	 * Check if we have been instructed to close. We will have
2014 	 * deferred this request, because the bdev was still open.
2015 	 */
2016 
2017 	mutex_lock(&info->mutex);
2018 	xbdev = info->xbdev;
2019 
2020 	if (xbdev && xbdev->state == XenbusStateClosing) {
2021 		/* pending switch to state closed */
2022 		dev_info(disk_to_dev(bdev->bd_disk), "releasing disk\n");
2023 		xlvbd_release_gendisk(info);
2024 		xenbus_frontend_closed(info->xbdev);
2025  	}
2026 
2027 	mutex_unlock(&info->mutex);
2028 
2029 	if (!xbdev) {
2030 		/* sudden device removal */
2031 		dev_info(disk_to_dev(bdev->bd_disk), "releasing disk\n");
2032 		xlvbd_release_gendisk(info);
2033 		disk->private_data = NULL;
2034 		kfree(info);
2035 	}
2036 
2037 out:
2038 	bdput(bdev);
2039 out_mutex:
2040 	mutex_unlock(&blkfront_mutex);
2041 }
2042 
2043 static const struct block_device_operations xlvbd_block_fops =
2044 {
2045 	.owner = THIS_MODULE,
2046 	.open = blkif_open,
2047 	.release = blkif_release,
2048 	.getgeo = blkif_getgeo,
2049 	.ioctl = blkif_ioctl,
2050 };
2051 
2052 
2053 static const struct xenbus_device_id blkfront_ids[] = {
2054 	{ "vbd" },
2055 	{ "" }
2056 };
2057 
2058 static DEFINE_XENBUS_DRIVER(blkfront, ,
2059 	.probe = blkfront_probe,
2060 	.remove = blkfront_remove,
2061 	.resume = blkfront_resume,
2062 	.otherend_changed = blkback_changed,
2063 	.is_ready = blkfront_is_ready,
2064 );
2065 
2066 static int __init xlblk_init(void)
2067 {
2068 	int ret;
2069 
2070 	if (!xen_domain())
2071 		return -ENODEV;
2072 
2073 	if (!xen_has_pv_disk_devices())
2074 		return -ENODEV;
2075 
2076 	if (register_blkdev(XENVBD_MAJOR, DEV_NAME)) {
2077 		printk(KERN_WARNING "xen_blk: can't get major %d with name %s\n",
2078 		       XENVBD_MAJOR, DEV_NAME);
2079 		return -ENODEV;
2080 	}
2081 
2082 	ret = xenbus_register_frontend(&blkfront_driver);
2083 	if (ret) {
2084 		unregister_blkdev(XENVBD_MAJOR, DEV_NAME);
2085 		return ret;
2086 	}
2087 
2088 	return 0;
2089 }
2090 module_init(xlblk_init);
2091 
2092 
2093 static void __exit xlblk_exit(void)
2094 {
2095 	xenbus_unregister_driver(&blkfront_driver);
2096 	unregister_blkdev(XENVBD_MAJOR, DEV_NAME);
2097 	kfree(minors);
2098 }
2099 module_exit(xlblk_exit);
2100 
2101 MODULE_DESCRIPTION("Xen virtual block device frontend");
2102 MODULE_LICENSE("GPL");
2103 MODULE_ALIAS_BLOCKDEV_MAJOR(XENVBD_MAJOR);
2104 MODULE_ALIAS("xen:vbd");
2105 MODULE_ALIAS("xenblk");
2106