2019-05-01 02:42:39 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2016-06-10 00:00:58 +08:00
|
|
|
/*
|
|
|
|
* bvec iterator
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001 Ming Lei <ming.lei@canonical.com>
|
|
|
|
*/
|
|
|
|
#ifndef __LINUX_BVEC_ITER_H
|
|
|
|
#define __LINUX_BVEC_ITER_H
|
|
|
|
|
2016-05-30 21:34:30 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/bug.h>
|
2017-06-30 02:31:13 +08:00
|
|
|
#include <linux/errno.h>
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
#include <linux/mm.h>
|
2016-05-30 21:34:30 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* was unsigned short, but we might as well be ready for > 64kB I/O pages
|
|
|
|
*/
|
|
|
|
struct bio_vec {
|
|
|
|
struct page *bv_page;
|
|
|
|
unsigned int bv_len;
|
|
|
|
unsigned int bv_offset;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct bvec_iter {
|
|
|
|
sector_t bi_sector; /* device address in 512 byte
|
|
|
|
sectors */
|
|
|
|
unsigned int bi_size; /* residual I/O count */
|
|
|
|
|
|
|
|
unsigned int bi_idx; /* current index into bvl_vec */
|
|
|
|
|
|
|
|
unsigned int bi_bvec_done; /* number of bytes completed in
|
|
|
|
current bvec */
|
|
|
|
};
|
2016-06-10 00:00:58 +08:00
|
|
|
|
2019-02-15 19:13:19 +08:00
|
|
|
struct bvec_iter_all {
|
|
|
|
struct bio_vec bv;
|
|
|
|
int idx;
|
|
|
|
unsigned done;
|
|
|
|
};
|
|
|
|
|
2016-06-10 00:00:58 +08:00
|
|
|
/*
|
|
|
|
* various member access, note that bio_data should of course not be used
|
|
|
|
* on highmem page vectors
|
|
|
|
*/
|
|
|
|
#define __bvec_iter_bvec(bvec, iter) (&(bvec)[(iter).bi_idx])
|
|
|
|
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
/* multi-page (mp_bvec) helpers */
|
|
|
|
#define mp_bvec_iter_page(bvec, iter) \
|
2016-06-10 00:00:58 +08:00
|
|
|
(__bvec_iter_bvec((bvec), (iter))->bv_page)
|
|
|
|
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
#define mp_bvec_iter_len(bvec, iter) \
|
2016-06-10 00:00:58 +08:00
|
|
|
min((iter).bi_size, \
|
|
|
|
__bvec_iter_bvec((bvec), (iter))->bv_len - (iter).bi_bvec_done)
|
|
|
|
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
#define mp_bvec_iter_offset(bvec, iter) \
|
2016-06-10 00:00:58 +08:00
|
|
|
(__bvec_iter_bvec((bvec), (iter))->bv_offset + (iter).bi_bvec_done)
|
|
|
|
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
#define mp_bvec_iter_page_idx(bvec, iter) \
|
|
|
|
(mp_bvec_iter_offset((bvec), (iter)) / PAGE_SIZE)
|
|
|
|
|
|
|
|
#define mp_bvec_iter_bvec(bvec, iter) \
|
|
|
|
((struct bio_vec) { \
|
|
|
|
.bv_page = mp_bvec_iter_page((bvec), (iter)), \
|
|
|
|
.bv_len = mp_bvec_iter_len((bvec), (iter)), \
|
|
|
|
.bv_offset = mp_bvec_iter_offset((bvec), (iter)), \
|
|
|
|
})
|
|
|
|
|
|
|
|
/* For building single-page bvec in flight */
|
|
|
|
#define bvec_iter_offset(bvec, iter) \
|
|
|
|
(mp_bvec_iter_offset((bvec), (iter)) % PAGE_SIZE)
|
|
|
|
|
|
|
|
#define bvec_iter_len(bvec, iter) \
|
|
|
|
min_t(unsigned, mp_bvec_iter_len((bvec), (iter)), \
|
|
|
|
PAGE_SIZE - bvec_iter_offset((bvec), (iter)))
|
|
|
|
|
|
|
|
#define bvec_iter_page(bvec, iter) \
|
2019-04-11 14:23:31 +08:00
|
|
|
(mp_bvec_iter_page((bvec), (iter)) + \
|
|
|
|
mp_bvec_iter_page_idx((bvec), (iter)))
|
block: introduce multi-page bvec helpers
This patch introduces helpers of 'mp_bvec_iter_*' for multi-page bvec
support.
The introduced helpers treate one bvec as real multi-page segment,
which may include more than one pages.
The existed helpers of bvec_iter_* are interfaces for supporting current
bvec iterator which is thought as single-page by drivers, fs, dm and
etc. These introduced helpers will build single-page bvec in flight, so
this way won't break current bio/bvec users, which needn't any change.
Follows some multi-page bvec background:
- bvecs stored in bio->bi_io_vec is always multi-page style
- bvec(struct bio_vec) represents one physically contiguous I/O
buffer, now the buffer may include more than one page after
multi-page bvec is supported, and all these pages represented
by one bvec is physically contiguous. Before multi-page bvec
support, at most one page is included in one bvec, we call it
single-page bvec.
- .bv_page of the bvec points to the 1st page in the multi-page bvec
- .bv_offset of the bvec is the offset of the buffer in the bvec
The effect on the current drivers/filesystem/dm/bcache/...:
- almost everyone supposes that one bvec only includes one single
page, so we keep the sp interface not changed, for example,
bio_for_each_segment() still returns single-page bvec
- bio_for_each_segment_all() will return single-page bvec too
- during iterating, iterator variable(struct bvec_iter) is always
updated in multi-page bvec style, and bvec_iter_advance() is kept
not changed
- returned(copied) single-page bvec is built in flight by bvec
helpers from the stored multi-page bvec
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Omar Sandoval <osandov@fb.com>
Signed-off-by: Ming Lei <ming.lei@redhat.com>
Signed-off-by: Jens Axboe <axboe@kernel.dk>
2019-02-15 19:13:10 +08:00
|
|
|
|
2016-06-10 00:00:58 +08:00
|
|
|
#define bvec_iter_bvec(bvec, iter) \
|
|
|
|
((struct bio_vec) { \
|
|
|
|
.bv_page = bvec_iter_page((bvec), (iter)), \
|
|
|
|
.bv_len = bvec_iter_len((bvec), (iter)), \
|
|
|
|
.bv_offset = bvec_iter_offset((bvec), (iter)), \
|
|
|
|
})
|
|
|
|
|
2017-06-30 02:31:13 +08:00
|
|
|
static inline bool bvec_iter_advance(const struct bio_vec *bv,
|
|
|
|
struct bvec_iter *iter, unsigned bytes)
|
2016-06-10 00:00:58 +08:00
|
|
|
{
|
2019-12-01 04:23:52 +08:00
|
|
|
unsigned int idx = iter->bi_idx;
|
|
|
|
|
2017-06-30 02:31:13 +08:00
|
|
|
if (WARN_ONCE(bytes > iter->bi_size,
|
|
|
|
"Attempted to advance past end of bvec iter\n")) {
|
|
|
|
iter->bi_size = 0;
|
|
|
|
return false;
|
|
|
|
}
|
2016-06-10 00:00:58 +08:00
|
|
|
|
2019-12-01 04:23:52 +08:00
|
|
|
iter->bi_size -= bytes;
|
|
|
|
bytes += iter->bi_bvec_done;
|
2016-06-10 00:00:58 +08:00
|
|
|
|
2019-12-01 04:23:52 +08:00
|
|
|
while (bytes && bytes >= bv[idx].bv_len) {
|
|
|
|
bytes -= bv[idx].bv_len;
|
|
|
|
idx++;
|
2016-06-10 00:00:58 +08:00
|
|
|
}
|
2019-12-01 04:23:52 +08:00
|
|
|
|
|
|
|
iter->bi_idx = idx;
|
|
|
|
iter->bi_bvec_done = bytes;
|
2017-06-30 02:31:13 +08:00
|
|
|
return true;
|
2016-06-10 00:00:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
#define for_each_bvec(bvl, bio_vec, iter, start) \
|
|
|
|
for (iter = (start); \
|
|
|
|
(iter).bi_size && \
|
|
|
|
((bvl = bvec_iter_bvec((bio_vec), (iter))), 1); \
|
|
|
|
bvec_iter_advance((bio_vec), &(iter), (bvl).bv_len))
|
|
|
|
|
2017-12-18 20:22:07 +08:00
|
|
|
/* for iterating one bio from start to end */
|
|
|
|
#define BVEC_ITER_ALL_INIT (struct bvec_iter) \
|
|
|
|
{ \
|
|
|
|
.bi_sector = 0, \
|
|
|
|
.bi_size = UINT_MAX, \
|
|
|
|
.bi_idx = 0, \
|
|
|
|
.bi_bvec_done = 0, \
|
|
|
|
}
|
|
|
|
|
2019-02-15 19:13:19 +08:00
|
|
|
static inline struct bio_vec *bvec_init_iter_all(struct bvec_iter_all *iter_all)
|
|
|
|
{
|
|
|
|
iter_all->done = 0;
|
2019-04-08 19:02:38 +08:00
|
|
|
iter_all->idx = 0;
|
2019-02-15 19:13:19 +08:00
|
|
|
|
|
|
|
return &iter_all->bv;
|
|
|
|
}
|
|
|
|
|
2019-04-08 19:02:38 +08:00
|
|
|
static inline void bvec_advance(const struct bio_vec *bvec,
|
|
|
|
struct bvec_iter_all *iter_all)
|
2019-02-15 19:13:19 +08:00
|
|
|
{
|
|
|
|
struct bio_vec *bv = &iter_all->bv;
|
|
|
|
|
2019-04-08 19:02:38 +08:00
|
|
|
if (iter_all->done) {
|
2019-04-11 14:23:31 +08:00
|
|
|
bv->bv_page++;
|
2019-02-15 19:13:19 +08:00
|
|
|
bv->bv_offset = 0;
|
|
|
|
} else {
|
2019-05-07 14:53:35 +08:00
|
|
|
bv->bv_page = bvec->bv_page + (bvec->bv_offset >> PAGE_SHIFT);
|
2019-04-17 09:11:26 +08:00
|
|
|
bv->bv_offset = bvec->bv_offset & ~PAGE_MASK;
|
2019-02-15 19:13:19 +08:00
|
|
|
}
|
|
|
|
bv->bv_len = min_t(unsigned int, PAGE_SIZE - bv->bv_offset,
|
|
|
|
bvec->bv_len - iter_all->done);
|
2019-04-08 19:02:38 +08:00
|
|
|
iter_all->done += bv->bv_len;
|
|
|
|
|
|
|
|
if (iter_all->done == bvec->bv_len) {
|
|
|
|
iter_all->idx++;
|
|
|
|
iter_all->done = 0;
|
|
|
|
}
|
2019-02-15 19:13:19 +08:00
|
|
|
}
|
|
|
|
|
2019-02-15 19:13:14 +08:00
|
|
|
/*
|
|
|
|
* Get the last single-page segment from the multi-page bvec and store it
|
|
|
|
* in @seg
|
|
|
|
*/
|
|
|
|
static inline void mp_bvec_last_segment(const struct bio_vec *bvec,
|
|
|
|
struct bio_vec *seg)
|
|
|
|
{
|
|
|
|
unsigned total = bvec->bv_offset + bvec->bv_len;
|
|
|
|
unsigned last_page = (total - 1) / PAGE_SIZE;
|
|
|
|
|
2019-04-11 14:23:31 +08:00
|
|
|
seg->bv_page = bvec->bv_page + last_page;
|
2019-02-15 19:13:14 +08:00
|
|
|
|
|
|
|
/* the whole segment is inside the last page */
|
|
|
|
if (bvec->bv_offset >= last_page * PAGE_SIZE) {
|
|
|
|
seg->bv_offset = bvec->bv_offset % PAGE_SIZE;
|
|
|
|
seg->bv_len = bvec->bv_len;
|
|
|
|
} else {
|
|
|
|
seg->bv_offset = 0;
|
|
|
|
seg->bv_len = total - last_page * PAGE_SIZE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-10 00:00:58 +08:00
|
|
|
#endif /* __LINUX_BVEC_ITER_H */
|