2010-04-28 17:55:08 +04:00
/*
* 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"
2016-06-05 22:31:41 +03:00
static struct bio * next_bio ( struct bio * bio , unsigned int nr_pages ,
2016-04-16 21:55:27 +03:00
gfp_t gfp )
2010-04-28 17:55:08 +04:00
{
2016-04-16 21:55:27 +03:00
struct bio * new = bio_alloc ( gfp , nr_pages ) ;
if ( bio ) {
bio_chain ( bio , new ) ;
2016-06-05 22:31:41 +03:00
submit_bio ( bio ) ;
2016-04-16 21:55:27 +03:00
}
2011-05-07 05:26:27 +04:00
2016-04-16 21:55:27 +03:00
return new ;
2010-04-28 17:55:08 +04:00
}
2016-04-16 21:55:28 +03:00
int __blkdev_issue_discard ( struct block_device * bdev , sector_t sector ,
2016-06-09 17:00:36 +03:00
sector_t nr_sects , gfp_t gfp_mask , int flags ,
2016-06-05 22:31:49 +03:00
struct bio * * biop )
2010-04-28 17:55:08 +04:00
{
struct request_queue * q = bdev_get_queue ( bdev ) ;
2016-04-16 21:55:28 +03:00
struct bio * bio = * biop ;
2015-10-22 19:59:42 +03:00
unsigned int granularity ;
2016-10-28 17:48:16 +03:00
unsigned int op ;
2015-10-22 19:59:42 +03:00
int alignment ;
2016-10-11 23:51:08 +03:00
sector_t bs_mask ;
2010-04-28 17:55:08 +04:00
if ( ! q )
return - ENXIO ;
2016-06-09 17:00:36 +03:00
if ( flags & BLKDEV_DISCARD_SECURE ) {
2016-07-19 12:23:33 +03:00
if ( flags & BLKDEV_DISCARD_ZERO )
return - EOPNOTSUPP ;
2016-06-09 17:00:36 +03:00
if ( ! blk_queue_secure_erase ( q ) )
return - EOPNOTSUPP ;
op = REQ_OP_SECURE_ERASE ;
} else {
if ( ! blk_queue_discard ( q ) )
return - EOPNOTSUPP ;
2016-07-19 12:23:33 +03:00
if ( ( flags & BLKDEV_DISCARD_ZERO ) & &
! q - > limits . discard_zeroes_data )
return - EOPNOTSUPP ;
2016-06-09 17:00:36 +03:00
op = REQ_OP_DISCARD ;
}
2010-04-28 17:55:08 +04:00
2016-10-11 23:51:08 +03:00
bs_mask = ( bdev_logical_block_size ( bdev ) > > 9 ) - 1 ;
if ( ( sector | nr_sects ) & bs_mask )
return - EINVAL ;
2015-10-22 19:59:42 +03:00
/* Zero-sector (unknown) and one-sector granularities are the same. */
granularity = max ( q - > limits . discard_granularity > > 9 , 1U ) ;
alignment = ( bdev_discard_alignment ( bdev ) > > 9 ) % granularity ;
2011-05-07 05:26:27 +04:00
while ( nr_sects ) {
block: split discard into aligned requests
When a disk has large discard_granularity and small max_discard_sectors,
discards are not split with optimal alignment. In the limit case of
discard_granularity == max_discard_sectors, no request could be aligned
correctly, so in fact you might end up with no discarded logical blocks
at all.
Another example that helps showing the condition in the patch is with
discard_granularity == 64, max_discard_sectors == 128. A request that is
submitted for 256 sectors 2..257 will be split in two: 2..129, 130..257.
However, only 2 aligned blocks out of 3 are included in the request;
128..191 may be left intact and not discarded. With this patch, the
first request will be truncated to ensure good alignment of what's left,
and the split will be 2..127, 128..255, 256..257. The patch will also
take into account the discard_alignment.
At most one extra request will be introduced, because the first request
will be reduced by at most granularity-1 sectors, and granularity
must be less than max_discard_sectors. Subsequent requests will run
on round_down(max_discard_sectors, granularity) sectors, as in the
current code.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-08-02 11:48:50 +04:00
unsigned int req_sects ;
2015-10-22 19:59:42 +03:00
sector_t end_sect , tmp ;
block: split discard into aligned requests
When a disk has large discard_granularity and small max_discard_sectors,
discards are not split with optimal alignment. In the limit case of
discard_granularity == max_discard_sectors, no request could be aligned
correctly, so in fact you might end up with no discarded logical blocks
at all.
Another example that helps showing the condition in the patch is with
discard_granularity == 64, max_discard_sectors == 128. A request that is
submitted for 256 sectors 2..257 will be split in two: 2..129, 130..257.
However, only 2 aligned blocks out of 3 are included in the request;
128..191 may be left intact and not discarded. With this patch, the
first request will be truncated to ensure good alignment of what's left,
and the split will be 2..127, 128..255, 256..257. The patch will also
take into account the discard_alignment.
At most one extra request will be introduced, because the first request
will be reduced by at most granularity-1 sectors, and granularity
must be less than max_discard_sectors. Subsequent requests will run
on round_down(max_discard_sectors, granularity) sectors, as in the
current code.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-08-02 11:48:50 +04:00
2015-10-22 19:59:42 +03:00
/* Make sure bi_size doesn't overflow */
req_sects = min_t ( sector_t , nr_sects , UINT_MAX > > 9 ) ;
2016-04-16 21:55:27 +03:00
/**
2015-10-22 19:59:42 +03:00
* If splitting a request , and the next starting sector would be
* misaligned , stop the discard at the previous aligned sector .
*/
block: split discard into aligned requests
When a disk has large discard_granularity and small max_discard_sectors,
discards are not split with optimal alignment. In the limit case of
discard_granularity == max_discard_sectors, no request could be aligned
correctly, so in fact you might end up with no discarded logical blocks
at all.
Another example that helps showing the condition in the patch is with
discard_granularity == 64, max_discard_sectors == 128. A request that is
submitted for 256 sectors 2..257 will be split in two: 2..129, 130..257.
However, only 2 aligned blocks out of 3 are included in the request;
128..191 may be left intact and not discarded. With this patch, the
first request will be truncated to ensure good alignment of what's left,
and the split will be 2..127, 128..255, 256..257. The patch will also
take into account the discard_alignment.
At most one extra request will be introduced, because the first request
will be reduced by at most granularity-1 sectors, and granularity
must be less than max_discard_sectors. Subsequent requests will run
on round_down(max_discard_sectors, granularity) sectors, as in the
current code.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-08-02 11:48:50 +04:00
end_sect = sector + req_sects ;
2015-10-22 19:59:42 +03:00
tmp = end_sect ;
if ( req_sects < nr_sects & &
sector_div ( tmp , granularity ) ! = alignment ) {
end_sect = end_sect - alignment ;
sector_div ( end_sect , granularity ) ;
end_sect = end_sect * granularity + alignment ;
req_sects = end_sect - sector ;
}
block: split discard into aligned requests
When a disk has large discard_granularity and small max_discard_sectors,
discards are not split with optimal alignment. In the limit case of
discard_granularity == max_discard_sectors, no request could be aligned
correctly, so in fact you might end up with no discarded logical blocks
at all.
Another example that helps showing the condition in the patch is with
discard_granularity == 64, max_discard_sectors == 128. A request that is
submitted for 256 sectors 2..257 will be split in two: 2..129, 130..257.
However, only 2 aligned blocks out of 3 are included in the request;
128..191 may be left intact and not discarded. With this patch, the
first request will be truncated to ensure good alignment of what's left,
and the split will be 2..127, 128..255, 256..257. The patch will also
take into account the discard_alignment.
At most one extra request will be introduced, because the first request
will be reduced by at most granularity-1 sectors, and granularity
must be less than max_discard_sectors. Subsequent requests will run
on round_down(max_discard_sectors, granularity) sectors, as in the
current code.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-08-02 11:48:50 +04:00
2016-06-05 22:31:41 +03:00
bio = next_bio ( bio , 1 , gfp_mask ) ;
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_sector = sector ;
2010-04-28 17:55:08 +04:00
bio - > bi_bdev = bdev ;
2016-06-09 17:00:36 +03:00
bio_set_op_attrs ( bio , op , 0 ) ;
2010-04-28 17:55:08 +04:00
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_size = req_sects < < 9 ;
block: split discard into aligned requests
When a disk has large discard_granularity and small max_discard_sectors,
discards are not split with optimal alignment. In the limit case of
discard_granularity == max_discard_sectors, no request could be aligned
correctly, so in fact you might end up with no discarded logical blocks
at all.
Another example that helps showing the condition in the patch is with
discard_granularity == 64, max_discard_sectors == 128. A request that is
submitted for 256 sectors 2..257 will be split in two: 2..129, 130..257.
However, only 2 aligned blocks out of 3 are included in the request;
128..191 may be left intact and not discarded. With this patch, the
first request will be truncated to ensure good alignment of what's left,
and the split will be 2..127, 128..255, 256..257. The patch will also
take into account the discard_alignment.
At most one extra request will be introduced, because the first request
will be reduced by at most granularity-1 sectors, and granularity
must be less than max_discard_sectors. Subsequent requests will run
on round_down(max_discard_sectors, granularity) sectors, as in the
current code.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Acked-by: Vivek Goyal <vgoyal@redhat.com>
Tested-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2012-08-02 11:48:50 +04:00
nr_sects - = req_sects ;
sector = end_sect ;
2010-04-28 17:55:08 +04:00
2014-02-12 20:34:01 +04:00
/*
* We can loop for a long time in here , if someone does
* full device discards ( like mkfs ) . Be nice and allow
* us to schedule out to avoid softlocking if preempt
* is disabled .
*/
cond_resched ( ) ;
2011-05-07 05:26:27 +04:00
}
2016-04-16 21:55:28 +03:00
* biop = bio ;
return 0 ;
}
EXPORT_SYMBOL ( __blkdev_issue_discard ) ;
/**
* 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 )
{
struct bio * bio = NULL ;
struct blk_plug plug ;
int ret ;
blk_start_plug ( & plug ) ;
2016-06-09 17:00:36 +03:00
ret = __blkdev_issue_discard ( bdev , sector , nr_sects , gfp_mask , flags ,
2016-04-16 21:55:28 +03:00
& bio ) ;
2016-05-05 18:54:21 +03:00
if ( ! ret & & bio ) {
2016-06-05 22:31:41 +03:00
ret = submit_bio_wait ( bio ) ;
2016-07-19 12:23:33 +03:00
if ( ret = = - EOPNOTSUPP & & ! ( flags & BLKDEV_DISCARD_ZERO ) )
2016-05-05 18:54:21 +03:00
ret = 0 ;
2016-06-07 19:32:13 +03:00
bio_put ( bio ) ;
2016-05-05 18:54:21 +03:00
}
2012-12-14 07:15:51 +04:00
blk_finish_plug ( & plug ) ;
2010-04-28 17:55:08 +04:00
2016-05-05 18:54:21 +03:00
return ret ;
2010-04-28 17:55:08 +04:00
}
EXPORT_SYMBOL ( blkdev_issue_discard ) ;
2010-04-28 17:55:09 +04:00
2012-09-18 20:19:27 +04:00
/**
2016-11-30 23:28:58 +03:00
* __blkdev_issue_write_same - generate number of bios with same page
2012-09-18 20:19:27 +04:00
* @ 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
2016-11-30 23:28:58 +03:00
* @ biop : pointer to anchor bio
2012-09-18 20:19:27 +04:00
*
* Description :
2016-11-30 23:28:58 +03:00
* Generate and issue number of bios ( REQ_OP_WRITE_SAME ) with same page .
2012-09-18 20:19:27 +04:00
*/
2016-11-30 23:28:58 +03:00
static int __blkdev_issue_write_same ( struct block_device * bdev , sector_t sector ,
sector_t nr_sects , gfp_t gfp_mask , struct page * page ,
struct bio * * biop )
2012-09-18 20:19:27 +04:00
{
struct request_queue * q = bdev_get_queue ( bdev ) ;
unsigned int max_write_same_sectors ;
2016-11-30 23:28:58 +03:00
struct bio * bio = * biop ;
2016-10-11 23:51:08 +03:00
sector_t bs_mask ;
2012-09-18 20:19:27 +04:00
if ( ! q )
return - ENXIO ;
2016-10-11 23:51:08 +03:00
bs_mask = ( bdev_logical_block_size ( bdev ) > > 9 ) - 1 ;
if ( ( sector | nr_sects ) & bs_mask )
return - EINVAL ;
2016-11-30 23:28:58 +03:00
if ( ! bdev_write_same ( bdev ) )
return - EOPNOTSUPP ;
2015-05-22 10:46:56 +03:00
/* Ensure that max_write_same_sectors doesn't overflow bi_size */
max_write_same_sectors = UINT_MAX > > 9 ;
2012-09-18 20:19:27 +04:00
while ( nr_sects ) {
2016-06-05 22:31:41 +03:00
bio = next_bio ( bio , 1 , gfp_mask ) ;
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_sector = sector ;
2012-09-18 20:19:27 +04:00
bio - > bi_bdev = bdev ;
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 ) ;
2016-06-05 22:31:48 +03:00
bio_set_op_attrs ( bio , REQ_OP_WRITE_SAME , 0 ) ;
2012-09-18 20:19:27 +04:00
if ( nr_sects > max_write_same_sectors ) {
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_size = max_write_same_sectors < < 9 ;
2012-09-18 20:19:27 +04:00
nr_sects - = max_write_same_sectors ;
sector + = max_write_same_sectors ;
} else {
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_size = nr_sects < < 9 ;
2012-09-18 20:19:27 +04:00
nr_sects = 0 ;
}
2016-11-30 23:28:58 +03:00
cond_resched ( ) ;
2012-09-18 20:19:27 +04:00
}
2016-11-30 23:28:58 +03:00
* biop = bio ;
return 0 ;
}
/**
* 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
*
* 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 )
{
struct bio * bio = NULL ;
struct blk_plug plug ;
int ret ;
blk_start_plug ( & plug ) ;
ret = __blkdev_issue_write_same ( bdev , sector , nr_sects , gfp_mask , page ,
& bio ) ;
if ( ret = = 0 & & bio ) {
2016-06-05 22:31:41 +03:00
ret = submit_bio_wait ( bio ) ;
2016-06-07 19:32:13 +03:00
bio_put ( bio ) ;
}
2016-11-30 23:28:58 +03:00
blk_finish_plug ( & plug ) ;
2016-07-19 12:23:34 +03:00
return ret ;
2012-09-18 20:19:27 +04:00
}
EXPORT_SYMBOL ( blkdev_issue_write_same ) ;
2016-11-30 23:28:59 +03:00
/**
* __blkdev_issue_write_zeroes - generate number of bios with WRITE ZEROES
* @ bdev : blockdev to issue
* @ sector : start sector
* @ nr_sects : number of sectors to write
* @ gfp_mask : memory allocation flags ( for bio_alloc )
* @ biop : pointer to anchor bio
*
* Description :
* Generate and issue number of bios ( REQ_OP_WRITE_ZEROES ) with zerofiled pages .
*/
static int __blkdev_issue_write_zeroes ( struct block_device * bdev ,
sector_t sector , sector_t nr_sects , gfp_t gfp_mask ,
struct bio * * biop )
{
struct bio * bio = * biop ;
unsigned int max_write_zeroes_sectors ;
struct request_queue * q = bdev_get_queue ( bdev ) ;
if ( ! q )
return - ENXIO ;
/* Ensure that max_write_zeroes_sectors doesn't overflow bi_size */
max_write_zeroes_sectors = bdev_write_zeroes_sectors ( bdev ) ;
if ( max_write_zeroes_sectors = = 0 )
return - EOPNOTSUPP ;
while ( nr_sects ) {
bio = next_bio ( bio , 0 , gfp_mask ) ;
bio - > bi_iter . bi_sector = sector ;
bio - > bi_bdev = bdev ;
bio_set_op_attrs ( bio , REQ_OP_WRITE_ZEROES , 0 ) ;
if ( nr_sects > max_write_zeroes_sectors ) {
bio - > bi_iter . bi_size = max_write_zeroes_sectors < < 9 ;
nr_sects - = max_write_zeroes_sectors ;
sector + = max_write_zeroes_sectors ;
} else {
bio - > bi_iter . bi_size = nr_sects < < 9 ;
nr_sects = 0 ;
}
cond_resched ( ) ;
}
* biop = bio ;
return 0 ;
}
2010-04-28 17:55:09 +04:00
/**
2016-11-30 23:28:58 +03:00
* __blkdev_issue_zeroout - generate number of zero filed write bios
2010-04-28 17:55:09 +04:00
* @ bdev : blockdev to issue
* @ sector : start sector
* @ nr_sects : number of sectors to write
* @ gfp_mask : memory allocation flags ( for bio_alloc )
2016-11-30 23:28:58 +03:00
* @ biop : pointer to anchor bio
* @ discard : discard flag
2010-04-28 17:55:09 +04:00
*
* Description :
* Generate and issue number of bios with zerofiled pages .
*/
2016-11-30 23:28:58 +03:00
int __blkdev_issue_zeroout ( struct block_device * bdev , sector_t sector ,
sector_t nr_sects , gfp_t gfp_mask , struct bio * * biop ,
bool discard )
2010-04-28 17:55:09 +04:00
{
2010-08-06 15:23:25 +04:00
int ret ;
2016-11-30 23:28:58 +03:00
int bi_size = 0 ;
struct bio * bio = * biop ;
2011-03-11 12:23:53 +03:00
unsigned int sz ;
2016-10-11 23:51:08 +03:00
sector_t bs_mask ;
bs_mask = ( bdev_logical_block_size ( bdev ) > > 9 ) - 1 ;
if ( ( sector | nr_sects ) & bs_mask )
return - EINVAL ;
2010-04-28 17:55:09 +04:00
2016-11-30 23:28:58 +03:00
if ( discard ) {
ret = __blkdev_issue_discard ( bdev , sector , nr_sects , gfp_mask ,
BLKDEV_DISCARD_ZERO , biop ) ;
if ( ret = = 0 | | ( ret & & ret ! = - EOPNOTSUPP ) )
goto out ;
}
2016-11-30 23:28:59 +03:00
ret = __blkdev_issue_write_zeroes ( bdev , sector , nr_sects , gfp_mask ,
biop ) ;
if ( ret = = 0 | | ( ret & & ret ! = - EOPNOTSUPP ) )
goto out ;
2016-11-30 23:28:58 +03:00
ret = __blkdev_issue_write_same ( bdev , sector , nr_sects , gfp_mask ,
ZERO_PAGE ( 0 ) , biop ) ;
if ( ret = = 0 | | ( ret & & ret ! = - EOPNOTSUPP ) )
goto out ;
ret = 0 ;
2010-04-28 17:55:09 +04:00
while ( nr_sects ! = 0 ) {
2016-06-05 22:31:41 +03:00
bio = next_bio ( bio , min ( nr_sects , ( sector_t ) BIO_MAX_PAGES ) ,
2016-04-16 21:55:27 +03:00
gfp_mask ) ;
2013-10-12 02:44:27 +04:00
bio - > bi_iter . bi_sector = sector ;
2010-04-28 17:55:09 +04:00
bio - > bi_bdev = bdev ;
2016-06-05 22:31:48 +03:00
bio_set_op_attrs ( bio , REQ_OP_WRITE , 0 ) ;
2010-04-28 17:55:09 +04:00
2010-04-29 11:28:21 +04:00
while ( nr_sects ! = 0 ) {
sz = min ( ( sector_t ) PAGE_SIZE > > 9 , nr_sects ) ;
2016-11-30 23:28:58 +03:00
bi_size = bio_add_page ( bio , ZERO_PAGE ( 0 ) , sz < < 9 , 0 ) ;
nr_sects - = bi_size > > 9 ;
sector + = bi_size > > 9 ;
if ( bi_size < ( sz < < 9 ) )
2010-04-28 17:55:09 +04:00
break ;
}
2016-11-30 23:28:58 +03:00
cond_resched ( ) ;
2010-04-28 17:55:09 +04:00
}
2016-11-30 23:28:58 +03:00
* biop = bio ;
out :
return ret ;
2010-04-28 17:55:09 +04:00
}
2016-11-30 23:28:58 +03:00
EXPORT_SYMBOL ( __blkdev_issue_zeroout ) ;
2012-09-18 20:19:28 +04:00
/**
* blkdev_issue_zeroout - zero - fill a block range
* @ bdev : blockdev to write
* @ sector : start sector
* @ nr_sects : number of sectors to write
* @ gfp_mask : memory allocation flags ( for bio_alloc )
2015-01-21 04:06:30 +03:00
* @ discard : whether to discard the block range
2012-09-18 20:19:28 +04:00
*
* Description :
2015-01-21 04:06:30 +03:00
* Zero - fill a block range . If the discard flag is set and the block
* device guarantees that subsequent READ operations to the block range
* in question will return zeroes , the blocks will be discarded . Should
* the discard request fail , if the discard flag is not set , or if
* discard_zeroes_data is not supported , this function will resort to
* zeroing the blocks manually , thus provisioning ( allocating ,
2016-11-30 23:28:59 +03:00
* anchoring ) them . If the block device supports WRITE ZEROES or WRITE SAME
* command ( s ) , blkdev_issue_zeroout ( ) will use it to optimize the process of
2015-01-21 04:06:30 +03:00
* clearing the block range . Otherwise the zeroing will be performed
* using regular WRITE calls .
2012-09-18 20:19:28 +04:00
*/
int blkdev_issue_zeroout ( struct block_device * bdev , sector_t sector ,
2015-01-21 04:06:30 +03:00
sector_t nr_sects , gfp_t gfp_mask , bool discard )
2012-09-18 20:19:28 +04:00
{
2016-11-30 23:28:58 +03:00
int ret ;
struct bio * bio = NULL ;
struct blk_plug plug ;
2015-01-21 04:06:30 +03:00
2016-11-30 23:28:58 +03:00
blk_start_plug ( & plug ) ;
ret = __blkdev_issue_zeroout ( bdev , sector , nr_sects , gfp_mask ,
& bio , discard ) ;
if ( ret = = 0 & & bio ) {
ret = submit_bio_wait ( bio ) ;
bio_put ( bio ) ;
}
blk_finish_plug ( & plug ) ;
2012-09-18 20:19:28 +04:00
2016-11-30 23:28:58 +03:00
return ret ;
2012-09-18 20:19:28 +04:00
}
2010-04-28 17:55:09 +04:00
EXPORT_SYMBOL ( blkdev_issue_zeroout ) ;