UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

block: remove the i argument to bio_for_each_segment_all 

We only have two callers that need the integer loop iterator, and they
can easily maintain it themselves.

Suggested-by: Matthew Wilcox <willy@infradead.org>
Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Acked-by: David Sterba <dsterba@suse.com>
Reviewed-by: Hannes Reinecke <hare@suse.com>
Acked-by: Coly Li <colyli@suse.de>
Reviewed-by: Matthew Wilcox <willy@infradead.org>
Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
This commit is contained in:
Christoph Hellwig 2019-04-25 09:03:00 +02:00 committed by Jens Axboe
parent f936b06ae5
commit 2b070cfe58
24 changed files with 47 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
block/bio.c
View File

@ -874,9 +874,8 @@ static void bio_get_pages(struct bio *bio)
{ {
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
get_page(bvec->bv_page); get_page(bvec->bv_page);
} }
@ -884,9 +883,8 @@ static void bio_release_pages(struct bio *bio)
{ {
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
put_page(bvec->bv_page); put_page(bvec->bv_page);
} }
@ -1166,11 +1164,10 @@ static struct bio_map_data *bio_alloc_map_data(struct iov_iter *data,
*/ */
static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter) static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)
{ {
int i;
struct bio_vec *bvec; struct bio_vec *bvec;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
ssize_t ret; ssize_t ret;
ret = copy_page_from_iter(bvec->bv_page, ret = copy_page_from_iter(bvec->bv_page,
@ -1198,11 +1195,10 @@ static int bio_copy_from_iter(struct bio *bio, struct iov_iter *iter)
*/ */
static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter) static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
{ {
int i;
struct bio_vec *bvec; struct bio_vec *bvec;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
ssize_t ret; ssize_t ret;
ret = copy_page_to_iter(bvec->bv_page, ret = copy_page_to_iter(bvec->bv_page,
@ -1223,10 +1219,9 @@ static int bio_copy_to_iter(struct bio *bio, struct iov_iter iter)
void bio_free_pages(struct bio *bio) void bio_free_pages(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
__free_page(bvec->bv_page); __free_page(bvec->bv_page);
} }
EXPORT_SYMBOL(bio_free_pages); EXPORT_SYMBOL(bio_free_pages);
@ -1464,7 +1459,7 @@ struct bio *bio_map_user_iov(struct request_queue *q,
return bio; return bio;
out_unmap: out_unmap:
bio_for_each_segment_all(bvec, bio, j, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
put_page(bvec->bv_page); put_page(bvec->bv_page);
} }
bio_put(bio); bio_put(bio);
@ -1474,13 +1469,12 @@ struct bio *bio_map_user_iov(struct request_queue *q,
static void __bio_unmap_user(struct bio *bio) static void __bio_unmap_user(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
/* /*
* make sure we dirty pages we wrote to * make sure we dirty pages we wrote to
*/ */
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
if (bio_data_dir(bio) == READ) if (bio_data_dir(bio) == READ)
set_page_dirty_lock(bvec->bv_page); set_page_dirty_lock(bvec->bv_page);
@ -1571,10 +1565,9 @@ static void bio_copy_kern_endio_read(struct bio *bio)
{ {
char *p = bio->bi_private; char *p = bio->bi_private;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
memcpy(p, page_address(bvec->bv_page), bvec->bv_len); memcpy(p, page_address(bvec->bv_page), bvec->bv_len);
p += bvec->bv_len; p += bvec->bv_len;
} }
@ -1682,10 +1675,9 @@ cleanup:
void bio_set_pages_dirty(struct bio *bio) void bio_set_pages_dirty(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
if (!PageCompound(bvec->bv_page)) if (!PageCompound(bvec->bv_page))
set_page_dirty_lock(bvec->bv_page); set_page_dirty_lock(bvec->bv_page);
} }
@ -1734,10 +1726,9 @@ void bio_check_pages_dirty(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
unsigned long flags; unsigned long flags;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
if (!PageDirty(bvec->bv_page) && !PageCompound(bvec->bv_page)) if (!PageDirty(bvec->bv_page) && !PageCompound(bvec->bv_page))
goto defer; goto defer;
} }

3
block/bounce.c
View File

@ -163,14 +163,13 @@ static void bounce_end_io(struct bio *bio, mempool_t *pool)
{ {
struct bio *bio_orig = bio->bi_private; struct bio *bio_orig = bio->bi_private;
struct bio_vec *bvec, orig_vec; struct bio_vec *bvec, orig_vec;
int i;
struct bvec_iter orig_iter = bio_orig->bi_iter; struct bvec_iter orig_iter = bio_orig->bi_iter;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
/* /*
* free up bounce indirect pages used * free up bounce indirect pages used
*/ */
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
orig_vec = bio_iter_iovec(bio_orig, orig_iter); orig_vec = bio_iter_iovec(bio_orig, orig_iter);
if (bvec->bv_page != orig_vec.bv_page) { if (bvec->bv_page != orig_vec.bv_page) {
dec_zone_page_state(bvec->bv_page, NR_BOUNCE); dec_zone_page_state(bvec->bv_page, NR_BOUNCE);

3
drivers/md/bcache/btree.c
View File

@ -429,12 +429,11 @@ static void do_btree_node_write(struct btree *b)
bset_sector_offset(&b->keys, i)); bset_sector_offset(&b->keys, i));
if (!bch_bio_alloc_pages(b->bio, __GFP_NOWARN|GFP_NOWAIT)) { if (!bch_bio_alloc_pages(b->bio, __GFP_NOWARN|GFP_NOWAIT)) {
int j;
struct bio_vec *bv; struct bio_vec *bv;
void *addr = (void *) ((unsigned long) i & ~(PAGE_SIZE - 1)); void *addr = (void *) ((unsigned long) i & ~(PAGE_SIZE - 1));
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bv, b->bio, j, iter_all) { bio_for_each_segment_all(bv, b->bio, iter_all) {
memcpy(page_address(bv->bv_page), addr, PAGE_SIZE); memcpy(page_address(bv->bv_page), addr, PAGE_SIZE);
addr += PAGE_SIZE; addr += PAGE_SIZE;
} }

3
drivers/md/dm-crypt.c
View File

@ -1445,11 +1445,10 @@ out:
static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone) static void crypt_free_buffer_pages(struct crypt_config *cc, struct bio *clone)
{ {
unsigned int i;
struct bio_vec *bv; struct bio_vec *bv;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bv, clone, i, iter_all) { bio_for_each_segment_all(bv, clone, iter_all) {
BUG_ON(!bv->bv_page); BUG_ON(!bv->bv_page);
mempool_free(bv->bv_page, &cc->page_pool); mempool_free(bv->bv_page, &cc->page_pool);
} }

6
drivers/md/raid1.c
View File

@ -2110,7 +2110,7 @@ static void process_checks(struct r1bio *r1_bio)
} }
r1_bio->read_disk = primary; r1_bio->read_disk = primary;
for (i = 0; i < conf->raid_disks * 2; i++) { for (i = 0; i < conf->raid_disks * 2; i++) {
int j; int j = 0;
struct bio *pbio = r1_bio->bios[primary]; struct bio *pbio = r1_bio->bios[primary];
struct bio *sbio = r1_bio->bios[i]; struct bio *sbio = r1_bio->bios[i];
blk_status_t status = sbio->bi_status; blk_status_t status = sbio->bi_status;
@ -2125,8 +2125,8 @@ static void process_checks(struct r1bio *r1_bio)
/* Now we can 'fixup' the error value */ /* Now we can 'fixup' the error value */
sbio->bi_status = 0; sbio->bi_status = 0;
bio_for_each_segment_all(bi, sbio, j, iter_all) bio_for_each_segment_all(bi, sbio, iter_all)
page_len[j] = bi->bv_len; page_len[j++] = bi->bv_len;
if (!status) { if (!status) {
for (j = vcnt; j-- ; ) { for (j = vcnt; j-- ; ) {

3
drivers/staging/erofs/data.c
View File

@ -17,12 +17,11 @@
static inline void read_endio(struct bio *bio) static inline void read_endio(struct bio *bio)
{ {
int i;
struct bio_vec *bvec; struct bio_vec *bvec;
const blk_status_t err = bio->bi_status; const blk_status_t err = bio->bi_status;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
/* page is already locked */ /* page is already locked */

3
drivers/staging/erofs/unzip_vle.c
View File

@ -844,14 +844,13 @@ static void z_erofs_vle_unzip_kickoff(void *ptr, int bios)
static inline void z_erofs_vle_read_endio(struct bio *bio) static inline void z_erofs_vle_read_endio(struct bio *bio)
{ {
const blk_status_t err = bio->bi_status; const blk_status_t err = bio->bi_status;
unsigned int i;
struct bio_vec *bvec; struct bio_vec *bvec;
#ifdef EROFS_FS_HAS_MANAGED_CACHE #ifdef EROFS_FS_HAS_MANAGED_CACHE
struct address_space *mc = NULL; struct address_space *mc = NULL;
#endif #endif
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
bool cachemngd = false; bool cachemngd = false;

6
fs/block_dev.c
View File

@ -210,7 +210,6 @@ __blkdev_direct_IO_simple(struct kiocb *iocb, struct iov_iter *iter,
struct bio bio; struct bio bio;
ssize_t ret; ssize_t ret;
blk_qc_t qc; blk_qc_t qc;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if ((pos | iov_iter_alignment(iter)) & if ((pos | iov_iter_alignment(iter)) &
@ -261,7 +260,7 @@ __blkdev_direct_IO_simple(struct kiocb *iocb, struct iov_iter *iter,
} }
__set_current_state(TASK_RUNNING); __set_current_state(TASK_RUNNING);
bio_for_each_segment_all(bvec, &bio, i, iter_all) { bio_for_each_segment_all(bvec, &bio, iter_all) {
if (should_dirty && !PageCompound(bvec->bv_page)) if (should_dirty && !PageCompound(bvec->bv_page))
set_page_dirty_lock(bvec->bv_page); set_page_dirty_lock(bvec->bv_page);
put_page(bvec->bv_page); put_page(bvec->bv_page);
@ -339,9 +338,8 @@ static void blkdev_bio_end_io(struct bio *bio)
if (!bio_flagged(bio, BIO_NO_PAGE_REF)) { if (!bio_flagged(bio, BIO_NO_PAGE_REF)) {
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
put_page(bvec->bv_page); put_page(bvec->bv_page);
} }
bio_put(bio); bio_put(bio);

3
fs/btrfs/compression.c
View File

@ -160,7 +160,6 @@ csum_failed:
if (cb->errors) { if (cb->errors) {
bio_io_error(cb->orig_bio); bio_io_error(cb->orig_bio);
} else { } else {
int i;
struct bio_vec *bvec; struct bio_vec *bvec;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
@ -169,7 +168,7 @@ csum_failed:
* checked so the end_io handlers know about it * checked so the end_io handlers know about it
*/ */
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, cb->orig_bio, i, iter_all) bio_for_each_segment_all(bvec, cb->orig_bio, iter_all)
SetPageChecked(bvec->bv_page); SetPageChecked(bvec->bv_page);
bio_endio(cb->orig_bio); bio_endio(cb->orig_bio);

4
fs/btrfs/disk-io.c
View File

@ -832,11 +832,11 @@ static blk_status_t btree_csum_one_bio(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
struct btrfs_root *root; struct btrfs_root *root;
int i, ret = 0; int ret = 0;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
root = BTRFS_I(bvec->bv_page->mapping->host)->root; root = BTRFS_I(bvec->bv_page->mapping->host)->root;
ret = csum_dirty_buffer(root->fs_info, bvec->bv_page); ret = csum_dirty_buffer(root->fs_info, bvec->bv_page);
if (ret) if (ret)

10
fs/btrfs/extent_io.c
View File

@ -2451,11 +2451,10 @@ static void end_bio_extent_writepage(struct bio *bio)
struct bio_vec *bvec; struct bio_vec *bvec;
u64 start; u64 start;
u64 end; u64 end;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@ -2523,11 +2522,10 @@ static void end_bio_extent_readpage(struct bio *bio)
u64 extent_len = 0; u64 extent_len = 0;
int mirror; int mirror;
int ret; int ret;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
struct inode *inode = page->mapping->host; struct inode *inode = page->mapping->host;
struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@ -3643,11 +3641,11 @@ static void end_bio_extent_buffer_writepage(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
struct extent_buffer *eb; struct extent_buffer *eb;
int i, done; int done;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
eb = (struct extent_buffer *)page->private; eb = (struct extent_buffer *)page->private;

8
fs/btrfs/inode.c
View File

@ -7828,7 +7828,6 @@ static void btrfs_retry_endio_nocsum(struct bio *bio)
struct inode *inode = done->inode; struct inode *inode = done->inode;
struct bio_vec *bvec; struct bio_vec *bvec;
struct extent_io_tree *io_tree, *failure_tree; struct extent_io_tree *io_tree, *failure_tree;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (bio->bi_status) if (bio->bi_status)
@ -7841,7 +7840,7 @@ static void btrfs_retry_endio_nocsum(struct bio *bio)
done->uptodate = 1; done->uptodate = 1;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
clean_io_failure(BTRFS_I(inode)->root->fs_info, failure_tree, clean_io_failure(BTRFS_I(inode)->root->fs_info, failure_tree,
io_tree, done->start, bvec->bv_page, io_tree, done->start, bvec->bv_page,
btrfs_ino(BTRFS_I(inode)), 0); btrfs_ino(BTRFS_I(inode)), 0);
@ -7919,7 +7918,7 @@ static void btrfs_retry_endio(struct bio *bio)
struct bio_vec *bvec; struct bio_vec *bvec;
int uptodate; int uptodate;
int ret; int ret;
int i; int i = 0;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (bio->bi_status) if (bio->bi_status)
@ -7934,7 +7933,7 @@ static void btrfs_retry_endio(struct bio *bio)
failure_tree = &BTRFS_I(inode)->io_failure_tree; failure_tree = &BTRFS_I(inode)->io_failure_tree;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
ret = __readpage_endio_check(inode, io_bio, i, bvec->bv_page, ret = __readpage_endio_check(inode, io_bio, i, bvec->bv_page,
bvec->bv_offset, done->start, bvec->bv_offset, done->start,
bvec->bv_len); bvec->bv_len);
@ -7946,6 +7945,7 @@ static void btrfs_retry_endio(struct bio *bio)
bvec->bv_offset); bvec->bv_offset);
else else
uptodate = 0; uptodate = 0;
i++;
} }
done->uptodate = uptodate; done->uptodate = uptodate;

3
fs/btrfs/raid56.c
View File

@ -1442,12 +1442,11 @@ static int fail_bio_stripe(struct btrfs_raid_bio *rbio,
static void set_bio_pages_uptodate(struct bio *bio) static void set_bio_pages_uptodate(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
ASSERT(!bio_flagged(bio, BIO_CLONED)); ASSERT(!bio_flagged(bio, BIO_CLONED));
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
SetPageUptodate(bvec->bv_page); SetPageUptodate(bvec->bv_page);
} }

3
fs/crypto/bio.c
View File

@ -29,10 +29,9 @@
static void __fscrypt_decrypt_bio(struct bio *bio, bool done) static void __fscrypt_decrypt_bio(struct bio *bio, bool done)
{ {
struct bio_vec *bv; struct bio_vec *bv;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bv, bio, i, iter_all) { bio_for_each_segment_all(bv, bio, iter_all) {
struct page *page = bv->bv_page; struct page *page = bv->bv_page;
int ret = fscrypt_decrypt_page(page->mapping->host, page, int ret = fscrypt_decrypt_page(page->mapping->host, page,
PAGE_SIZE, 0, page->index); PAGE_SIZE, 0, page->index);

3
fs/direct-io.c
View File

@ -538,7 +538,6 @@ static struct bio *dio_await_one(struct dio *dio)
static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio) static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
unsigned i;
blk_status_t err = bio->bi_status; blk_status_t err = bio->bi_status;
if (err) { if (err) {
@ -553,7 +552,7 @@ static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio)
} else { } else {
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
if (dio->op == REQ_OP_READ && !PageCompound(page) && if (dio->op == REQ_OP_READ && !PageCompound(page) &&

3
fs/ext4/page-io.c
View File

@ -61,11 +61,10 @@ static void buffer_io_error(struct buffer_head *bh)
static void ext4_finish_bio(struct bio *bio) static void ext4_finish_bio(struct bio *bio)
{ {
int i;
struct bio_vec *bvec; struct bio_vec *bvec;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
#ifdef CONFIG_FS_ENCRYPTION #ifdef CONFIG_FS_ENCRYPTION
struct page *data_page = NULL; struct page *data_page = NULL;

3
fs/ext4/readpage.c
View File

@ -71,7 +71,6 @@ static inline bool ext4_bio_encrypted(struct bio *bio)
static void mpage_end_io(struct bio *bio) static void mpage_end_io(struct bio *bio)
{ {
struct bio_vec *bv; struct bio_vec *bv;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (ext4_bio_encrypted(bio)) { if (ext4_bio_encrypted(bio)) {
@ -82,7 +81,7 @@ static void mpage_end_io(struct bio *bio)
return; return;
} }
} }
bio_for_each_segment_all(bv, bio, i, iter_all) { bio_for_each_segment_all(bv, bio, iter_all) {
struct page *page = bv->bv_page; struct page *page = bv->bv_page;
if (!bio->bi_status) { if (!bio->bi_status) {

9
fs/f2fs/data.c
View File

@ -86,10 +86,9 @@ static void __read_end_io(struct bio *bio)
{ {
struct page *page; struct page *page;
struct bio_vec *bv; struct bio_vec *bv;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bv, bio, i, iter_all) { bio_for_each_segment_all(bv, bio, iter_all) {
page = bv->bv_page; page = bv->bv_page;
/* PG_error was set if any post_read step failed */ /* PG_error was set if any post_read step failed */
@ -164,7 +163,6 @@ static void f2fs_write_end_io(struct bio *bio)
{ {
struct f2fs_sb_info *sbi = bio->bi_private; struct f2fs_sb_info *sbi = bio->bi_private;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (time_to_inject(sbi, FAULT_WRITE_IO)) { if (time_to_inject(sbi, FAULT_WRITE_IO)) {
@ -172,7 +170,7 @@ static void f2fs_write_end_io(struct bio *bio)
bio->bi_status = BLK_STS_IOERR; bio->bi_status = BLK_STS_IOERR;
} }
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
enum count_type type = WB_DATA_TYPE(page); enum count_type type = WB_DATA_TYPE(page);
@ -349,7 +347,6 @@ static bool __has_merged_page(struct f2fs_bio_info *io, struct inode *inode,
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
struct page *target; struct page *target;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (!io->bio) if (!io->bio)
@ -358,7 +355,7 @@ static bool __has_merged_page(struct f2fs_bio_info *io, struct inode *inode,
if (!inode && !page && !ino) if (!inode && !page && !ino)
return true; return true;
bio_for_each_segment_all(bvec, io->bio, i, iter_all) { bio_for_each_segment_all(bvec, io->bio, iter_all) {
if (bvec->bv_page->mapping) if (bvec->bv_page->mapping)
target = bvec->bv_page; target = bvec->bv_page;

3
fs/gfs2/lops.c
View File

@ -207,7 +207,6 @@ static void gfs2_end_log_write(struct bio *bio)
struct gfs2_sbd *sdp = bio->bi_private; struct gfs2_sbd *sdp = bio->bi_private;
struct bio_vec *bvec; struct bio_vec *bvec;
struct page *page; struct page *page;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
if (bio->bi_status) { if (bio->bi_status) {
@ -216,7 +215,7 @@ static void gfs2_end_log_write(struct bio *bio)
wake_up(&sdp->sd_logd_waitq); wake_up(&sdp->sd_logd_waitq);
} }
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
page = bvec->bv_page; page = bvec->bv_page;
if (page_has_buffers(page)) if (page_has_buffers(page))
gfs2_end_log_write_bh(sdp, bvec, bio->bi_status); gfs2_end_log_write_bh(sdp, bvec, bio->bi_status);

3
fs/gfs2/meta_io.c
View File

@ -189,10 +189,9 @@ struct buffer_head *gfs2_meta_new(struct gfs2_glock *gl, u64 blkno)
static void gfs2_meta_read_endio(struct bio *bio) static void gfs2_meta_read_endio(struct bio *bio)
{ {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) { bio_for_each_segment_all(bvec, bio, iter_all) {
struct page *page = bvec->bv_page; struct page *page = bvec->bv_page;
struct buffer_head *bh = page_buffers(page); struct buffer_head *bh = page_buffers(page);
unsigned int len = bvec->bv_len; unsigned int len = bvec->bv_len;

6
fs/iomap.c
View File

@ -273,10 +273,9 @@ iomap_read_end_io(struct bio *bio)
{ {
int error = blk_status_to_errno(bio->bi_status); int error = blk_status_to_errno(bio->bi_status);
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
iomap_read_page_end_io(bvec, error); iomap_read_page_end_io(bvec, error);
bio_put(bio); bio_put(bio);
} }
@ -1592,9 +1591,8 @@ static void iomap_dio_bio_end_io(struct bio *bio)
if (!bio_flagged(bio, BIO_NO_PAGE_REF)) { if (!bio_flagged(bio, BIO_NO_PAGE_REF)) {
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
put_page(bvec->bv_page); put_page(bvec->bv_page);
} }
bio_put(bio); bio_put(bio);

3
fs/mpage.c
View File

@ -47,10 +47,9 @@
static void mpage_end_io(struct bio *bio) static void mpage_end_io(struct bio *bio)
{ {
struct bio_vec *bv; struct bio_vec *bv;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
bio_for_each_segment_all(bv, bio, i, iter_all) { bio_for_each_segment_all(bv, bio, iter_all) {
struct page *page = bv->bv_page; struct page *page = bv->bv_page;
page_endio(page, bio_op(bio), page_endio(page, bio_op(bio),
blk_status_to_errno(bio->bi_status)); blk_status_to_errno(bio->bi_status));

3
fs/xfs/xfs_aops.c
View File

@ -98,7 +98,6 @@ xfs_destroy_ioend(
for (bio = &ioend->io_inline_bio; bio; bio = next) { for (bio = &ioend->io_inline_bio; bio; bio = next) {
struct bio_vec *bvec; struct bio_vec *bvec;
int i;
struct bvec_iter_all iter_all; struct bvec_iter_all iter_all;
/* /*
@ -111,7 +110,7 @@ xfs_destroy_ioend(
next = bio->bi_private; next = bio->bi_private;
/* walk each page on bio, ending page IO on them */ /* walk each page on bio, ending page IO on them */
bio_for_each_segment_all(bvec, bio, i, iter_all) bio_for_each_segment_all(bvec, bio, iter_all)
xfs_finish_page_writeback(inode, bvec, error); xfs_finish_page_writeback(inode, bvec, error);
bio_put(bio); bio_put(bio);
} }

5
include/linux/bio.h
View File

@ -134,9 +134,8 @@ static inline bool bio_next_segment(const struct bio *bio,
* drivers should _never_ use the all version - the bio may have been split * drivers should _never_ use the all version - the bio may have been split
* before it got to the driver and the driver won't own all of it * before it got to the driver and the driver won't own all of it
*/ */
#define bio_for_each_segment_all(bvl, bio, i, iter) \ #define bio_for_each_segment_all(bvl, bio, iter) \
for (i = 0, bvl = bvec_init_iter_all(&iter); \ for (bvl = bvec_init_iter_all(&iter); bio_next_segment((bio), &iter); )
bio_next_segment((bio), &iter); i++)
static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter, static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
unsigned bytes) unsigned bytes)