[linux-2.6-block.git] / block / blk-lib.c

/*
 * Functions related to generic helpers functions
 */
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/bio.h>
#include <linux/blkdev.h>
#include <linux/scatterlist.h>

#include "blk.h"

struct bio_batch {
	atomic_t		done;
	unsigned long		flags;
	struct completion	*wait;
};

static void bio_batch_end_io(struct bio *bio, int err)
{
	struct bio_batch *bb = bio->bi_private;

	if (err && (err != -EOPNOTSUPP))
		clear_bit(BIO_UPTODATE, &bb->flags);
	if (atomic_dec_and_test(&bb->done))
		complete(bb->wait);
	bio_put(bio);
}

/**
 * blkdev_issue_discard - queue a discard
 * @bdev:	blockdev to issue discard for
 * @sector:	start sector
 * @nr_sects:	number of sectors to discard
 * @gfp_mask:	memory allocation flags (for bio_alloc)
 * @flags:	BLKDEV_IFL_* flags to control behaviour
 *
 * Description:
 *    Issue a discard request for the sectors in question.
 */
int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
		sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)
{
	DECLARE_COMPLETION_ONSTACK(wait);
	struct request_queue *q = bdev_get_queue(bdev);
	int type = REQ_WRITE | REQ_DISCARD;
	unsigned int max_discard_sectors;
	unsigned int granularity, alignment, mask;
	struct bio_batch bb;
	struct bio *bio;
	int ret = 0;

	if (!q)
		return -ENXIO;

	if (!blk_queue_discard(q))
		return -EOPNOTSUPP;

	/* Zero-sector (unknown) and one-sector granularities are the same.  */
	granularity = max(q->limits.discard_granularity >> 9, 1U);
	mask = granularity - 1;
	alignment = (bdev_discard_alignment(bdev) >> 9) & mask;

	/*
	 * Ensure that max_discard_sectors is of the proper
	 * granularity, so that requests stay aligned after a split.
	 */
	max_discard_sectors = min(q->limits.max_discard_sectors, UINT_MAX >> 9);
	max_discard_sectors = round_down(max_discard_sectors, granularity);
	if (unlikely(!max_discard_sectors)) {
		/* Avoid infinite loop below. Being cautious never hurts. */
		return -EOPNOTSUPP;
	}

	if (flags & BLKDEV_DISCARD_SECURE) {
		if (!blk_queue_secdiscard(q))
			return -EOPNOTSUPP;
		type |= REQ_SECURE;
	}

	atomic_set(&bb.done, 1);
	bb.flags = 1 << BIO_UPTODATE;
	bb.wait = &wait;

	while (nr_sects) {
		unsigned int req_sects;
		sector_t end_sect;

		bio = bio_alloc(gfp_mask, 1);
		if (!bio) {
			ret = -ENOMEM;
			break;
		}

		req_sects = min_t(sector_t, nr_sects, max_discard_sectors);

		/*
		 * If splitting a request, and the next starting sector would be
		 * misaligned, stop the discard at the previous aligned sector.
		 */
		end_sect = sector + req_sects;
		if (req_sects < nr_sects && (end_sect & mask) != alignment) {
			end_sect =
				round_down(end_sect - alignment, granularity)
				+ alignment;
			req_sects = end_sect - sector;
		}

		bio->bi_sector = sector;
		bio->bi_end_io = bio_batch_end_io;
		bio->bi_bdev = bdev;
		bio->bi_private = &bb;

		bio->bi_size = req_sects << 9;
		nr_sects -= req_sects;
		sector = end_sect;

		atomic_inc(&bb.done);
		submit_bio(type, bio);
	}

	/* Wait for bios in-flight */
	if (!atomic_dec_and_test(&bb.done))
		wait_for_completion(&wait);

	if (!test_bit(BIO_UPTODATE, &bb.flags))
		ret = -EIO;

	return ret;
}
EXPORT_SYMBOL(blkdev_issue_discard);

/**
 * blkdev_issue_write_same - queue a write same operation
 * @bdev:	target blockdev
 * @sector:	start sector
 * @nr_sects:	number of sectors to write
 * @gfp_mask:	memory allocation flags (for bio_alloc)
 * @page:	page containing data to write
 *
 * Description:
 *    Issue a write same request for the sectors in question.
 */
int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
			    sector_t nr_sects, gfp_t gfp_mask,
			    struct page *page)
{
	DECLARE_COMPLETION_ONSTACK(wait);
	struct request_queue *q = bdev_get_queue(bdev);
	unsigned int max_write_same_sectors;
	struct bio_batch bb;
	struct bio *bio;
	int ret = 0;

	if (!q)
		return -ENXIO;

	max_write_same_sectors = q->limits.max_write_same_sectors;

	if (max_write_same_sectors == 0)
		return -EOPNOTSUPP;

	atomic_set(&bb.done, 1);
	bb.flags = 1 << BIO_UPTODATE;
	bb.wait = &wait;

	while (nr_sects) {
		bio = bio_alloc(gfp_mask, 1);
		if (!bio) {
			ret = -ENOMEM;
			break;
		}

		bio->bi_sector = sector;
		bio->bi_end_io = bio_batch_end_io;
		bio->bi_bdev = bdev;
		bio->bi_private = &bb;
		bio->bi_vcnt = 1;
		bio->bi_io_vec->bv_page = page;
		bio->bi_io_vec->bv_offset = 0;
		bio->bi_io_vec->bv_len = bdev_logical_block_size(bdev);

		if (nr_sects > max_write_same_sectors) {
			bio->bi_size = max_write_same_sectors << 9;
			nr_sects -= max_write_same_sectors;
			sector += max_write_same_sectors;
		} else {
			bio->bi_size = nr_sects << 9;
			nr_sects = 0;
		}

		atomic_inc(&bb.done);
		submit_bio(REQ_WRITE | REQ_WRITE_SAME, bio);
	}

	/* Wait for bios in-flight */
	if (!atomic_dec_and_test(&bb.done))
		wait_for_completion(&wait);

	if (!test_bit(BIO_UPTODATE, &bb.flags))
		ret = -ENOTSUPP;

	return ret;
}
EXPORT_SYMBOL(blkdev_issue_write_same);

/**
 * blkdev_issue_zeroout - generate number of zero filed write bios
 * @bdev:	blockdev to issue
 * @sector:	start sector
 * @nr_sects:	number of sectors to write
 * @gfp_mask:	memory allocation flags (for bio_alloc)
 *
 * Description:
 *  Generate and issue number of bios with zerofiled pages.
 */

int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
			sector_t nr_sects, gfp_t gfp_mask)
{
	int ret;
	struct bio *bio;
	struct bio_batch bb;
	unsigned int sz;
	DECLARE_COMPLETION_ONSTACK(wait);

	atomic_set(&bb.done, 1);
	bb.flags = 1 << BIO_UPTODATE;
	bb.wait = &wait;

	ret = 0;
	while (nr_sects != 0) {
		bio = bio_alloc(gfp_mask,
				min(nr_sects, (sector_t)BIO_MAX_PAGES));
		if (!bio) {
			ret = -ENOMEM;
			break;
		}

		bio->bi_sector = sector;
		bio->bi_bdev   = bdev;
		bio->bi_end_io = bio_batch_end_io;
		bio->bi_private = &bb;

		while (nr_sects != 0) {
			sz = min((sector_t) PAGE_SIZE >> 9 , nr_sects);
			ret = bio_add_page(bio, ZERO_PAGE(0), sz << 9, 0);
			nr_sects -= ret >> 9;
			sector += ret >> 9;
			if (ret < (sz << 9))
				break;
		}
		ret = 0;
		atomic_inc(&bb.done);
		submit_bio(WRITE, bio);
	}

	/* Wait for bios in-flight */
	if (!atomic_dec_and_test(&bb.done))
		wait_for_completion(&wait);

	if (!test_bit(BIO_UPTODATE, &bb.flags))
		/* One of bios in the batch was completed with error.*/
		ret = -EIO;

	return ret;
}
EXPORT_SYMBOL(blkdev_issue_zeroout);
Commit	Line	Data
f31e7e40 DM	1	/*
	2	* Functions related to generic helpers functions
	3	*/
	4	#include <linux/kernel.h>
	5	#include <linux/module.h>
	6	#include <linux/bio.h>
	7	#include <linux/blkdev.h>
	8	#include <linux/scatterlist.h>
	9
	10	#include "blk.h"
	11
5dba3089 LC	12	struct bio_batch {
	13	atomic_t done;
	14	unsigned long flags;
	15	struct completion *wait;
	16	};
	17
	18	static void bio_batch_end_io(struct bio *bio, int err)
f31e7e40	19	{
5dba3089 LC	20	struct bio_batch *bb = bio->bi_private;
5dba3089 LC	21
8af1954d	22	if (err && (err != -EOPNOTSUPP))
5dba3089	23	clear_bit(BIO_UPTODATE, &bb->flags);
5dba3089 LC	24	if (atomic_dec_and_test(&bb->done))
5dba3089 LC	25	complete(bb->wait);
f31e7e40 DM	26	bio_put(bio);
	27	}
	28
	29	/**
	30	* blkdev_issue_discard - queue a discard
	31	* @bdev: blockdev to issue discard for
	32	* @sector: start sector
	33	* @nr_sects: number of sectors to discard
	34	* @gfp_mask: memory allocation flags (for bio_alloc)
	35	* @flags: BLKDEV_IFL_* flags to control behaviour
	36	*
	37	* Description:
	38	* Issue a discard request for the sectors in question.
	39	*/
	40	int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
	41	sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)
	42	{
	43	DECLARE_COMPLETION_ONSTACK(wait);
	44	struct request_queue *q = bdev_get_queue(bdev);
8c555367	45	int type = REQ_WRITE \| REQ_DISCARD;
10d1f9e2	46	unsigned int max_discard_sectors;
c6e66634	47	unsigned int granularity, alignment, mask;
5dba3089	48	struct bio_batch bb;
f31e7e40	49	struct bio *bio;
f31e7e40 DM	50	int ret = 0;
	51
	52	if (!q)
	53	return -ENXIO;
	54
	55	if (!blk_queue_discard(q))
	56	return -EOPNOTSUPP;
	57
f6ff53d3 PB	58	/* Zero-sector (unknown) and one-sector granularities are the same. */
f6ff53d3 PB	59	granularity = max(q->limits.discard_granularity >> 9, 1U);
c6e66634 PB	60	mask = granularity - 1;
c6e66634 PB	61	alignment = (bdev_discard_alignment(bdev) >> 9) & mask;
f6ff53d3	62
10d1f9e2 JA	63	/*
10d1f9e2 JA	64	* Ensure that max_discard_sectors is of the proper
c6e66634	65	* granularity, so that requests stay aligned after a split.
10d1f9e2 JA	66	*/
10d1f9e2 JA	67	max_discard_sectors = min(q->limits.max_discard_sectors, UINT_MAX >> 9);
f6ff53d3	68	max_discard_sectors = round_down(max_discard_sectors, granularity);
4c64500e	69	if (unlikely(!max_discard_sectors)) {
0f799603 MS	70	/* Avoid infinite loop below. Being cautious never hurts. */
0f799603 MS	71	return -EOPNOTSUPP;
10d1f9e2	72	}
f31e7e40	73
dd3932ed	74	if (flags & BLKDEV_DISCARD_SECURE) {
8d57a98c AH	75	if (!blk_queue_secdiscard(q))
8d57a98c AH	76	return -EOPNOTSUPP;
8c555367	77	type \|= REQ_SECURE;
8d57a98c AH	78	}
8d57a98c AH	79
5dba3089 LC	80	atomic_set(&bb.done, 1);
	81	bb.flags = 1 << BIO_UPTODATE;
	82	bb.wait = &wait;
	83
	84	while (nr_sects) {
c6e66634 PB	85	unsigned int req_sects;
	86	sector_t end_sect;
	87
f31e7e40	88	bio = bio_alloc(gfp_mask, 1);
66ac0280 CH	89	if (!bio) {
	90	ret = -ENOMEM;
	91	break;
	92	}
	93
c6e66634 PB	94	req_sects = min_t(sector_t, nr_sects, max_discard_sectors);
	95
	96	/*
	97	* If splitting a request, and the next starting sector would be
	98	* misaligned, stop the discard at the previous aligned sector.
	99	*/
	100	end_sect = sector + req_sects;
	101	if (req_sects < nr_sects && (end_sect & mask) != alignment) {
	102	end_sect =
	103	round_down(end_sect - alignment, granularity)
	104	+ alignment;
	105	req_sects = end_sect - sector;
	106	}
	107
f31e7e40	108	bio->bi_sector = sector;
5dba3089	109	bio->bi_end_io = bio_batch_end_io;
f31e7e40	110	bio->bi_bdev = bdev;
5dba3089	111	bio->bi_private = &bb;
f31e7e40	112
c6e66634 PB	113	bio->bi_size = req_sects << 9;
	114	nr_sects -= req_sects;
	115	sector = end_sect;
f31e7e40	116
5dba3089	117	atomic_inc(&bb.done);
f31e7e40	118	submit_bio(type, bio);
5dba3089	119	}
f31e7e40	120
5dba3089 LC	121	/* Wait for bios in-flight */
5dba3089 LC	122	if (!atomic_dec_and_test(&bb.done))
dd3932ed	123	wait_for_completion(&wait);
f31e7e40	124
8af1954d	125	if (!test_bit(BIO_UPTODATE, &bb.flags))
5dba3089	126	ret = -EIO;
66ac0280	127
f31e7e40	128	return ret;
f31e7e40 DM	129	}
f31e7e40 DM	130	EXPORT_SYMBOL(blkdev_issue_discard);
3f14d792	131
4363ac7c MP	132	/**
	133	* blkdev_issue_write_same - queue a write same operation
	134	* @bdev: target blockdev
	135	* @sector: start sector
	136	* @nr_sects: number of sectors to write
	137	* @gfp_mask: memory allocation flags (for bio_alloc)
	138	* @page: page containing data to write
	139	*
	140	* Description:
	141	* Issue a write same request for the sectors in question.
	142	*/
	143	int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
	144	sector_t nr_sects, gfp_t gfp_mask,
	145	struct page *page)
	146	{
	147	DECLARE_COMPLETION_ONSTACK(wait);
	148	struct request_queue *q = bdev_get_queue(bdev);
	149	unsigned int max_write_same_sectors;
	150	struct bio_batch bb;
	151	struct bio *bio;
	152	int ret = 0;
	153
	154	if (!q)
	155	return -ENXIO;
	156
	157	max_write_same_sectors = q->limits.max_write_same_sectors;
	158
	159	if (max_write_same_sectors == 0)
	160	return -EOPNOTSUPP;
	161
	162	atomic_set(&bb.done, 1);
	163	bb.flags = 1 << BIO_UPTODATE;
	164	bb.wait = &wait;
	165
	166	while (nr_sects) {
	167	bio = bio_alloc(gfp_mask, 1);
	168	if (!bio) {
	169	ret = -ENOMEM;
	170	break;
	171	}
	172
	173	bio->bi_sector = sector;
	174	bio->bi_end_io = bio_batch_end_io;
	175	bio->bi_bdev = bdev;
	176	bio->bi_private = &bb;
	177	bio->bi_vcnt = 1;
	178	bio->bi_io_vec->bv_page = page;
	179	bio->bi_io_vec->bv_offset = 0;
	180	bio->bi_io_vec->bv_len = bdev_logical_block_size(bdev);
	181
	182	if (nr_sects > max_write_same_sectors) {
	183	bio->bi_size = max_write_same_sectors << 9;
	184	nr_sects -= max_write_same_sectors;
	185	sector += max_write_same_sectors;
	186	} else {
	187	bio->bi_size = nr_sects << 9;
	188	nr_sects = 0;
	189	}
	190
	191	atomic_inc(&bb.done);
	192	submit_bio(REQ_WRITE \| REQ_WRITE_SAME, bio);
	193	}
	194
	195	/* Wait for bios in-flight */
196	if (!atomic_dec_and_test(&bb.done))
197	wait_for_completion(&wait);
198
199	if (!test_bit(BIO_UPTODATE, &bb.flags))
200	ret = -ENOTSUPP;
201
202	return ret;
203	}
204	EXPORT_SYMBOL(blkdev_issue_write_same);
205
3f14d792	206	/**
291d24f6	207	* blkdev_issue_zeroout - generate number of zero filed write bios
3f14d792 DM	208	* @bdev: blockdev to issue
	209	* @sector: start sector
	210	* @nr_sects: number of sectors to write
	211	* @gfp_mask: memory allocation flags (for bio_alloc)
3f14d792 DM	212	*
	213	* Description:
	214	* Generate and issue number of bios with zerofiled pages.
3f14d792 DM	215	*/
	216
	217	int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
dd3932ed	218	sector_t nr_sects, gfp_t gfp_mask)
3f14d792	219	{
18edc8ea	220	int ret;
3f14d792 DM	221	struct bio *bio;
3f14d792 DM	222	struct bio_batch bb;
0aeea189	223	unsigned int sz;
3f14d792 DM	224	DECLARE_COMPLETION_ONSTACK(wait);
3f14d792 DM	225
0aeea189	226	atomic_set(&bb.done, 1);
3f14d792 DM	227	bb.flags = 1 << BIO_UPTODATE;
3f14d792 DM	228	bb.wait = &wait;
3f14d792	229
18edc8ea	230	ret = 0;
3f14d792 DM	231	while (nr_sects != 0) {
	232	bio = bio_alloc(gfp_mask,
	233	min(nr_sects, (sector_t)BIO_MAX_PAGES));
18edc8ea DM	234	if (!bio) {
18edc8ea DM	235	ret = -ENOMEM;
3f14d792	236	break;
18edc8ea	237	}
3f14d792 DM	238
	239	bio->bi_sector = sector;
	240	bio->bi_bdev = bdev;
	241	bio->bi_end_io = bio_batch_end_io;
dd3932ed	242	bio->bi_private = &bb;
3f14d792	243
0341aafb JA	244	while (nr_sects != 0) {
0341aafb JA	245	sz = min((sector_t) PAGE_SIZE >> 9 , nr_sects);
3f14d792 DM	246	ret = bio_add_page(bio, ZERO_PAGE(0), sz << 9, 0);
	247	nr_sects -= ret >> 9;
	248	sector += ret >> 9;
	249	if (ret < (sz << 9))
	250	break;
	251	}
18edc8ea	252	ret = 0;
0aeea189	253	atomic_inc(&bb.done);
3f14d792 DM	254	submit_bio(WRITE, bio);
3f14d792 DM	255	}
3f14d792	256
dd3932ed	257	/* Wait for bios in-flight */
0aeea189	258	if (!atomic_dec_and_test(&bb.done))
dd3932ed	259	wait_for_completion(&wait);
3f14d792 DM	260
	261	if (!test_bit(BIO_UPTODATE, &bb.flags))
	262	/* One of bios in the batch was completed with error.*/
	263	ret = -EIO;
	264
3f14d792 DM	265	return ret;
	266	}
	267	EXPORT_SYMBOL(blkdev_issue_zeroout);