Techwizz/kernel-fxtec-pro1x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

blkdev: generalize flags for blkdev_issue_fn functions

Browse source 
The patch just convert all blkdev_issue_xxx function to common
set of flags. Wait/allocation semantics preserved.

Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Dmitry Monakhov 2010-04-28 17:55:06 +04:00 committed by Jens Axboe
parent 6b4517a791
commit fbd9b09a17
15 changed files with 55 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
block/blk-barrier.c
View file

@ -293,19 +293,22 @@ static void bio_end_empty_barrier(struct bio *bio, int err)
/** /**
* blkdev_issue_flush - queue a flush * blkdev_issue_flush - queue a flush
* @bdev: blockdev to issue flush for * @bdev: blockdev to issue flush for
* @gfp_mask: memory allocation flags (for bio_alloc)
* @error_sector: error sector * @error_sector: error sector
* @flags: BLKDEV_IFL_* flags to control behaviour
* *
* Description: * Description:
* Issue a flush for the block device in question. Caller can supply * Issue a flush for the block device in question. Caller can supply
* room for storing the error offset in case of a flush error, if they * room for storing the error offset in case of a flush error, if they
* wish to. * wish to.
*/ */
int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector) int blkdev_issue_flush(struct block_device *bdev, gfp_t gfp_mask,
sector_t *error_sector, unsigned long flags)
{ {
DECLARE_COMPLETION_ONSTACK(wait); DECLARE_COMPLETION_ONSTACK(wait);
struct request_queue *q; struct request_queue *q;
struct bio *bio; struct bio *bio;
int ret; int ret = 0;
if (bdev->bd_disk == NULL) if (bdev->bd_disk == NULL)
return -ENXIO; return -ENXIO;
@ -314,7 +317,7 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
if (!q) if (!q)
return -ENXIO; return -ENXIO;
bio = bio_alloc(GFP_KERNEL, 0); bio = bio_alloc(gfp_mask, 0);
bio->bi_end_io = bio_end_empty_barrier; bio->bi_end_io = bio_end_empty_barrier;
bio->bi_private = &wait; bio->bi_private = &wait;
bio->bi_bdev = bdev; bio->bi_bdev = bdev;
@ -330,7 +333,6 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
if (error_sector) if (error_sector)
*error_sector = bio->bi_sector; *error_sector = bio->bi_sector;
ret = 0;
if (bio_flagged(bio, BIO_EOPNOTSUPP)) if (bio_flagged(bio, BIO_EOPNOTSUPP))
ret = -EOPNOTSUPP; ret = -EOPNOTSUPP;
else if (!bio_flagged(bio, BIO_UPTODATE)) else if (!bio_flagged(bio, BIO_UPTODATE))
@ -362,17 +364,17 @@ static void blkdev_discard_end_io(struct bio *bio, int err)
* @sector: start sector * @sector: start sector
* @nr_sects: number of sectors to discard * @nr_sects: number of sectors to discard
* @gfp_mask: memory allocation flags (for bio_alloc) * @gfp_mask: memory allocation flags (for bio_alloc)
* @flags: DISCARD_FL_* flags to control behaviour * @flags: BLKDEV_IFL_* flags to control behaviour
* *
* Description: * Description:
* Issue a discard request for the sectors in question. * Issue a discard request for the sectors in question.
*/ */
int blkdev_issue_discard(struct block_device *bdev, sector_t sector, int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
sector_t nr_sects, gfp_t gfp_mask, int flags) sector_t nr_sects, gfp_t gfp_mask, unsigned long flags)
{ {
DECLARE_COMPLETION_ONSTACK(wait); DECLARE_COMPLETION_ONSTACK(wait);
struct request_queue *q = bdev_get_queue(bdev); struct request_queue *q = bdev_get_queue(bdev);
int type = flags & DISCARD_FL_BARRIER ? int type = flags & BLKDEV_IFL_BARRIER ?
DISCARD_BARRIER : DISCARD_NOBARRIER; DISCARD_BARRIER : DISCARD_NOBARRIER;
struct bio *bio; struct bio *bio;
struct page *page; struct page *page;
@ -395,7 +397,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
bio->bi_sector = sector; bio->bi_sector = sector;
bio->bi_end_io = blkdev_discard_end_io; bio->bi_end_io = blkdev_discard_end_io;
bio->bi_bdev = bdev; bio->bi_bdev = bdev;
if (flags & DISCARD_FL_WAIT) if (flags & BLKDEV_IFL_WAIT)
bio->bi_private = &wait; bio->bi_private = &wait;
/* /*
@ -426,7 +428,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
bio_get(bio); bio_get(bio);
submit_bio(type, bio); submit_bio(type, bio);
if (flags & DISCARD_FL_WAIT) if (flags & BLKDEV_IFL_WAIT)
wait_for_completion(&wait); wait_for_completion(&wait);
if (bio_flagged(bio, BIO_EOPNOTSUPP)) if (bio_flagged(bio, BIO_EOPNOTSUPP))

2
block/ioctl.c
View file

@ -126,7 +126,7 @@ static int blk_ioctl_discard(struct block_device *bdev, uint64_t start,
if (start + len > (bdev->bd_inode->i_size >> 9)) if (start + len > (bdev->bd_inode->i_size >> 9))
return -EINVAL; return -EINVAL;
return blkdev_issue_discard(bdev, start, len, GFP_KERNEL, return blkdev_issue_discard(bdev, start, len, GFP_KERNEL,
DISCARD_FL_WAIT); BLKDEV_IFL_WAIT);
} }
static int put_ushort(unsigned long arg, unsigned short val) static int put_ushort(unsigned long arg, unsigned short val)

3
drivers/block/drbd/drbd_int.h
View file

@ -2251,7 +2251,8 @@ static inline void drbd_md_flush(struct drbd_conf *mdev)
if (test_bit(MD_NO_BARRIER, &mdev->flags)) if (test_bit(MD_NO_BARRIER, &mdev->flags))
return; return;
r = blkdev_issue_flush(mdev->ldev->md_bdev, NULL); r = blkdev_issue_flush(mdev->ldev->md_bdev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
if (r) { if (r) {
set_bit(MD_NO_BARRIER, &mdev->flags); set_bit(MD_NO_BARRIER, &mdev->flags);
dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r); dev_err(DEV, "meta data flush failed with status %d, disabling md-flushes\n", r);

3
drivers/block/drbd/drbd_receiver.c
View file

@ -945,7 +945,8 @@ static enum finish_epoch drbd_flush_after_epoch(struct drbd_conf *mdev, struct d
int rv; int rv;
if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) { if (mdev->write_ordering >= WO_bdev_flush && get_ldev(mdev)) {
rv = blkdev_issue_flush(mdev->ldev->backing_bdev, NULL); rv = blkdev_issue_flush(mdev->ldev->backing_bdev, GFP_KERNEL,
NULL, BLKDEV_IFL_WAIT);
if (rv) { if (rv) {
dev_err(DEV, "local disk flush failed with status %d\n", rv); dev_err(DEV, "local disk flush failed with status %d\n", rv);
/* would rather check on EOPNOTSUPP, but that is not reliable. /* would rather check on EOPNOTSUPP, but that is not reliable.

3
fs/block_dev.c
View file

@ -413,7 +413,8 @@ int blkdev_fsync(struct file *filp, struct dentry *dentry, int datasync)
if (error) if (error)
return error; return error;
error = blkdev_issue_flush(bdev, NULL); error = blkdev_issue_flush(bdev, GFP_KERNEL, NULL,
(BLKDEV_IFL_WAIT));
if (error == -EOPNOTSUPP) if (error == -EOPNOTSUPP)
error = 0; error = 0;
return error; return error;

2
fs/btrfs/extent-tree.c
View file

@ -1589,7 +1589,7 @@ static void btrfs_issue_discard(struct block_device *bdev,
u64 start, u64 len) u64 start, u64 len)
{ {
blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL, blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL,
DISCARD_FL_BARRIER); BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
} }
static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr, static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,

3
fs/ext3/fsync.c
View file

@ -91,7 +91,8 @@ int ext3_sync_file(struct file * file, struct dentry *dentry, int datasync)
* storage * storage
*/ */
if (test_opt(inode->i_sb, BARRIER)) if (test_opt(inode->i_sb, BARRIER))
blkdev_issue_flush(inode->i_sb->s_bdev, NULL); blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
out: out:
return ret; return ret;
} }

6
fs/ext4/fsync.c
View file

@ -100,9 +100,11 @@ int ext4_sync_file(struct file *file, struct dentry *dentry, int datasync)
if (ext4_should_writeback_data(inode) && if (ext4_should_writeback_data(inode) &&
(journal->j_fs_dev != journal->j_dev) && (journal->j_fs_dev != journal->j_dev) &&
(journal->j_flags & JBD2_BARRIER)) (journal->j_flags & JBD2_BARRIER))
blkdev_issue_flush(inode->i_sb->s_bdev, NULL); blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL,
NULL, BLKDEV_IFL_WAIT);
jbd2_log_wait_commit(journal, commit_tid); jbd2_log_wait_commit(journal, commit_tid);
} else if (journal->j_flags & JBD2_BARRIER) } else if (journal->j_flags & JBD2_BARRIER)
blkdev_issue_flush(inode->i_sb->s_bdev, NULL); blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
return ret; return ret;
} }

5
fs/gfs2/rgrp.c
View file

@ -854,7 +854,8 @@ static void gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
if ((start + nr_sects) != blk) { if ((start + nr_sects) != blk) {
rv = blkdev_issue_discard(bdev, start, rv = blkdev_issue_discard(bdev, start,
nr_sects, GFP_NOFS, nr_sects, GFP_NOFS,
DISCARD_FL_BARRIER); BLKDEV_IFL_WAIT |
BLKDEV_IFL_BARRIER);
if (rv) if (rv)
goto fail; goto fail;
nr_sects = 0; nr_sects = 0;
@ -869,7 +870,7 @@ static void gfs2_rgrp_send_discards(struct gfs2_sbd *sdp, u64 offset,
} }
if (nr_sects) { if (nr_sects) {
rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS, rv = blkdev_issue_discard(bdev, start, nr_sects, GFP_NOFS,
DISCARD_FL_BARRIER); BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
if (rv) if (rv)
goto fail; goto fail;
} }

3
fs/jbd2/checkpoint.c
View file

@ -530,7 +530,8 @@ int jbd2_cleanup_journal_tail(journal_t *journal)
*/ */
if ((journal->j_fs_dev != journal->j_dev) && if ((journal->j_fs_dev != journal->j_dev) &&
(journal->j_flags & JBD2_BARRIER)) (journal->j_flags & JBD2_BARRIER))
blkdev_issue_flush(journal->j_fs_dev, NULL); blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
if (!(journal->j_flags & JBD2_ABORT)) if (!(journal->j_flags & JBD2_ABORT))
jbd2_journal_update_superblock(journal, 1); jbd2_journal_update_superblock(journal, 1);
return 0; return 0;

6
fs/jbd2/commit.c
View file

@ -717,7 +717,8 @@ void jbd2_journal_commit_transaction(journal_t *journal)
if (commit_transaction->t_flushed_data_blocks && if (commit_transaction->t_flushed_data_blocks &&
(journal->j_fs_dev != journal->j_dev) && (journal->j_fs_dev != journal->j_dev) &&
(journal->j_flags & JBD2_BARRIER)) (journal->j_flags & JBD2_BARRIER))
blkdev_issue_flush(journal->j_fs_dev, NULL); blkdev_issue_flush(journal->j_fs_dev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
/* Done it all: now write the commit record asynchronously. */ /* Done it all: now write the commit record asynchronously. */
if (JBD2_HAS_INCOMPAT_FEATURE(journal, if (JBD2_HAS_INCOMPAT_FEATURE(journal,
@ -727,7 +728,8 @@ void jbd2_journal_commit_transaction(journal_t *journal)
if (err) if (err)
__jbd2_journal_abort_hard(journal); __jbd2_journal_abort_hard(journal);
if (journal->j_flags & JBD2_BARRIER) if (journal->j_flags & JBD2_BARRIER)
blkdev_issue_flush(journal->j_dev, NULL); blkdev_issue_flush(journal->j_dev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
} }
err = journal_finish_inode_data_buffers(journal, commit_transaction); err = journal_finish_inode_data_buffers(journal, commit_transaction);

3
fs/reiserfs/file.c
View file

@ -147,7 +147,8 @@ static int reiserfs_sync_file(struct file *filp,
barrier_done = reiserfs_commit_for_inode(inode); barrier_done = reiserfs_commit_for_inode(inode);
reiserfs_write_unlock(inode->i_sb); reiserfs_write_unlock(inode->i_sb);
if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb)) if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb))
blkdev_issue_flush(inode->i_sb->s_bdev, NULL); blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
if (barrier_done < 0) if (barrier_done < 0)
return barrier_done; return barrier_done;
return (err < 0) ? -EIO : 0; return (err < 0) ? -EIO : 0;

3
fs/xfs/linux-2.6/xfs_super.c
View file

@ -725,7 +725,8 @@ void
xfs_blkdev_issue_flush( xfs_blkdev_issue_flush(
xfs_buftarg_t *buftarg) xfs_buftarg_t *buftarg)
{ {
blkdev_issue_flush(buftarg->bt_bdev, NULL); blkdev_issue_flush(buftarg->bt_bdev, GFP_KERNEL, NULL,
BLKDEV_IFL_WAIT);
} }
STATIC void STATIC void

18
include/linux/blkdev.h
View file

@ -998,12 +998,16 @@ static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
return NULL; return NULL;
return bqt->tag_index[tag]; return bqt->tag_index[tag];
} }
enum{
extern int blkdev_issue_flush(struct block_device *, sector_t *); BLKDEV_WAIT, /* wait for completion */
#define DISCARD_FL_WAIT 0x01 /* wait for completion */ BLKDEV_BARRIER, /*issue request with barrier */
#define DISCARD_FL_BARRIER 0x02 /* issue DISCARD_BARRIER request */ };
extern int blkdev_issue_discard(struct block_device *, sector_t sector, #define BLKDEV_IFL_WAIT (1 << BLKDEV_WAIT)
sector_t nr_sects, gfp_t, int flags); #define BLKDEV_IFL_BARRIER (1 << BLKDEV_BARRIER)
extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *,
unsigned long);
extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
static inline int sb_issue_discard(struct super_block *sb, static inline int sb_issue_discard(struct super_block *sb,
sector_t block, sector_t nr_blocks) sector_t block, sector_t nr_blocks)
@ -1011,7 +1015,7 @@ static inline int sb_issue_discard(struct super_block *sb,
block <<= (sb->s_blocksize_bits - 9); block <<= (sb->s_blocksize_bits - 9);
nr_blocks <<= (sb->s_blocksize_bits - 9); nr_blocks <<= (sb->s_blocksize_bits - 9);
return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL, return blkdev_issue_discard(sb->s_bdev, block, nr_blocks, GFP_KERNEL,
DISCARD_FL_BARRIER); BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
} }
extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm); extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);

9
mm/swapfile.c
View file

@ -139,7 +139,8 @@ static int discard_swap(struct swap_info_struct *si)
nr_blocks = ((sector_t)se->nr_pages - 1) << (PAGE_SHIFT - 9); nr_blocks = ((sector_t)se->nr_pages - 1) << (PAGE_SHIFT - 9);
if (nr_blocks) { if (nr_blocks) {
err = blkdev_issue_discard(si->bdev, start_block, err = blkdev_issue_discard(si->bdev, start_block,
nr_blocks, GFP_KERNEL, DISCARD_FL_BARRIER); nr_blocks, GFP_KERNEL,
BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
if (err) if (err)
return err; return err;
cond_resched(); cond_resched();
@ -150,7 +151,8 @@ static int discard_swap(struct swap_info_struct *si)
nr_blocks = (sector_t)se->nr_pages << (PAGE_SHIFT - 9); nr_blocks = (sector_t)se->nr_pages << (PAGE_SHIFT - 9);
err = blkdev_issue_discard(si->bdev, start_block, err = blkdev_issue_discard(si->bdev, start_block,
nr_blocks, GFP_KERNEL, DISCARD_FL_BARRIER); nr_blocks, GFP_KERNEL,
BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
if (err) if (err)
break; break;
@ -189,7 +191,8 @@ static void discard_swap_cluster(struct swap_info_struct *si,
start_block <<= PAGE_SHIFT - 9; start_block <<= PAGE_SHIFT - 9;
nr_blocks <<= PAGE_SHIFT - 9; nr_blocks <<= PAGE_SHIFT - 9;
if (blkdev_issue_discard(si->bdev, start_block, if (blkdev_issue_discard(si->bdev, start_block,
nr_blocks, GFP_NOIO, DISCARD_FL_BARRIER)) nr_blocks, GFP_NOIO, BLKDEV_IFL_WAIT |
BLKDEV_IFL_BARRIER))
break; break;
} }