[Devel] [PATCH rh7] ploop: io_direct: delay f_op->fsync() until FLUSH|FUA
Maxim Patlasov
mpatlasov at virtuozzo.com
Wed May 25 17:04:34 PDT 2016
Once we converted extent to initialized it can be part of uncompleted
journal transaction, so we have to force transaction commit at some point.
Instead of forcing transaction commit immediately, the patch delays it
until an incoming bio with FLUSH|FUA arrives. Then, as the very first
step of processing such a bio, we sends corresponding preq to fsync_thread
to perform f_op->fsync().
As a very unlikely case, it is also possible that processing a FLUSH|FUA
bio itself results in converting extents. Then, the patch calls f_op->fsync()
immediately after conversion to preserve FUA semantics.
https://jira.sw.ru/browse/PSBM-47026
Signed-off-by: Maxim Patlasov <mpatlasov at virtuozzo.com>
---
drivers/block/ploop/dev.c | 70 ++++++++++++++++++++++++---------------
drivers/block/ploop/io_direct.c | 28 +++++++++++++++-
include/linux/ploop/ploop.h | 6 +++
3 files changed, 76 insertions(+), 28 deletions(-)
diff --git a/drivers/block/ploop/dev.c b/drivers/block/ploop/dev.c
index 654b60b..03fc289 100644
--- a/drivers/block/ploop/dev.c
+++ b/drivers/block/ploop/dev.c
@@ -1942,46 +1942,62 @@ err:
/* Main preq state machine */
+static inline bool preq_is_special(struct ploop_request * preq)
+{
+ return test_bit(PLOOP_REQ_MERGE, &preq->state) ||
+ test_bit(PLOOP_REQ_RELOC_A, &preq->state) ||
+ test_bit(PLOOP_REQ_RELOC_S, &preq->state) ||
+ test_bit(PLOOP_REQ_DISCARD, &preq->state) ||
+ test_bit(PLOOP_REQ_ZERO, &preq->state);
+}
+
static void
ploop_entry_request(struct ploop_request * preq)
{
struct ploop_device * plo = preq->plo;
struct ploop_delta * top_delta = ploop_top_delta(plo);
+ struct ploop_io * top_io = &top_delta->io;
struct ploop_delta * delta;
int level;
int err;
iblock_t iblk;
- /* Control request. */
- if (unlikely(preq->bl.head == NULL &&
- !test_bit(PLOOP_REQ_MERGE, &preq->state) &&
- !test_bit(PLOOP_REQ_RELOC_A, &preq->state) &&
- !test_bit(PLOOP_REQ_RELOC_S, &preq->state) &&
- !test_bit(PLOOP_REQ_DISCARD, &preq->state) &&
- !test_bit(PLOOP_REQ_ZERO, &preq->state))) {
- complete(plo->quiesce_comp);
- wait_for_completion(&plo->relax_comp);
- ploop_complete_request(preq);
- complete(&plo->relaxed_comp);
- return;
- }
+ if (!preq_is_special(preq)) {
+ /* Control request */
+ if (unlikely(preq->bl.head == NULL)) {
+ complete(plo->quiesce_comp);
+ wait_for_completion(&plo->relax_comp);
+ ploop_complete_request(preq);
+ complete(&plo->relaxed_comp);
+ return;
+ }
- /* Empty flush. */
- if (unlikely(preq->req_size == 0 &&
- !test_bit(PLOOP_REQ_MERGE, &preq->state) &&
- !test_bit(PLOOP_REQ_RELOC_A, &preq->state) &&
- !test_bit(PLOOP_REQ_RELOC_S, &preq->state) &&
- !test_bit(PLOOP_REQ_ZERO, &preq->state))) {
- if (preq->req_rw & REQ_FLUSH) {
- if (top_delta->io.ops->issue_flush) {
- top_delta->io.ops->issue_flush(&top_delta->io, preq);
- return;
- }
+ /* Need to fsync before start handling FLUSH */
+ if ((preq->req_rw & REQ_FLUSH) &&
+ test_bit(PLOOP_IO_FSYNC_DELAYED, &top_io->io_state) &&
+ !test_bit(PLOOP_REQ_FSYNC_DONE, &preq->state)) {
+ spin_lock_irq(&plo->lock);
+ list_add_tail(&preq->list, &top_io->fsync_queue);
+ if (waitqueue_active(&top_io->fsync_waitq))
+ wake_up_interruptible(&top_io->fsync_waitq);
+ spin_unlock_irq(&plo->lock);
+ return;
}
- preq->eng_state = PLOOP_E_COMPLETE;
- ploop_complete_request(preq);
- return;
+ /* Empty flush or unknown zero-size request */
+ if (preq->req_size == 0) {
+ if (preq->req_rw & REQ_FLUSH &&
+ !test_bit(PLOOP_REQ_FSYNC_DONE, &preq->state)) {
+ if (top_io->ops->issue_flush) {
+ top_io->ops->issue_flush(top_io, preq);
+ return;
+ }
+ }
+
+ preq->eng_state = PLOOP_E_COMPLETE;
+ ploop_complete_request(preq);
+ return;
+ }
}
if (unlikely(test_bit(PLOOP_REQ_SYNC, &preq->state) &&
diff --git a/drivers/block/ploop/io_direct.c b/drivers/block/ploop/io_direct.c
index 8096110..a0b7a4e 100644
--- a/drivers/block/ploop/io_direct.c
+++ b/drivers/block/ploop/io_direct.c
@@ -514,17 +514,32 @@ end_write:
static void
dio_post_submit(struct ploop_io *io, struct ploop_request * preq)
{
+ struct ploop_device *plo = preq->plo;
sector_t sec = (sector_t)preq->iblock << preq->plo->cluster_log;
loff_t clu_siz = 1 << (preq->plo->cluster_log + 9);
int err;
file_start_write(io->files.file);
+
+ /* Here io->io_count is even ... */
+ spin_lock_irq(&plo->lock);
+ io->io_count++;
+ set_bit(PLOOP_IO_FSYNC_DELAYED, &io->io_state);
+ spin_unlock_irq(&plo->lock);
+
err = io->files.file->f_op->fallocate(io->files.file,
FALLOC_FL_CONVERT_UNWRITTEN,
(loff_t)sec << 9, clu_siz);
- if (!err)
+
+ /* highly unlikely case: FUA coming to a block not provisioned yet */
+ if (!err && (preq->req_rw & REQ_FUA))
err = io->ops->sync(io);
+ spin_lock_irq(&plo->lock);
+ io->io_count++;
+ spin_unlock_irq(&plo->lock);
+ /* and here io->io_count is even (+2) again. */
+
file_end_write(io->files.file);
if (err) {
PLOOP_REQ_SET_ERROR(preq, err);
@@ -782,6 +797,7 @@ static int dio_fsync_thread(void * data)
{
struct ploop_io * io = data;
struct ploop_device * plo = io->plo;
+ u64 io_count;
set_user_nice(current, -20);
@@ -808,6 +824,7 @@ static int dio_fsync_thread(void * data)
INIT_LIST_HEAD(&list);
list_splice_init(&io->fsync_queue, &list);
+ io_count = io->io_count;
spin_unlock_irq(&plo->lock);
/* filemap_fdatawrite() has been made already */
@@ -824,12 +841,17 @@ static int dio_fsync_thread(void * data)
spin_lock_irq(&plo->lock);
+ if (io_count == io->io_count && !(io_count & 1))
+ clear_bit(PLOOP_IO_FSYNC_DELAYED, &io->io_state);
+
while (!list_empty(&list)) {
struct ploop_request * preq;
preq = list_entry(list.next, struct ploop_request, list);
list_del(&preq->list);
if (err)
PLOOP_REQ_SET_ERROR(preq, err);
+
+ __set_bit(PLOOP_REQ_FSYNC_DONE, &preq->state);
list_add_tail(&preq->list, &plo->ready_queue);
io->fsync_qlen--;
}
@@ -1522,6 +1544,10 @@ dio_fastmap(struct ploop_io * io, struct bio * orig_bio,
struct extent_map * em;
int i;
+ if (unlikely((orig_bio->bi_rw & REQ_FLUSH) &&
+ test_bit(PLOOP_IO_FSYNC_DELAYED, &io->io_state)))
+ return 1;
+
if (orig_bio->bi_size == 0) {
bio->bi_vcnt = 0;
bio->bi_sector = 0;
diff --git a/include/linux/ploop/ploop.h b/include/linux/ploop/ploop.h
index ad36a91..49f3cda 100644
--- a/include/linux/ploop/ploop.h
+++ b/include/linux/ploop/ploop.h
@@ -87,6 +87,9 @@ struct ploop_file
* This struct describes how we do real IO on particular backing file.
*/
+enum {
+ PLOOP_IO_FSYNC_DELAYED, /* Must f_op->fsync before FLUSH|FUA */
+};
struct ploop_io
{
@@ -108,6 +111,8 @@ struct ploop_io
struct timer_list fsync_timer;
struct ploop_io_ops *ops;
+ unsigned long io_state;
+ u64 io_count;
};
struct ploop_io_ops
@@ -466,6 +471,7 @@ enum
PLOOP_REQ_POST_SUBMIT, /* preq needs post_submit processing */
PLOOP_REQ_PUSH_BACKUP, /* preq was ACKed by userspace push_backup */
PLOOP_REQ_ALLOW_READS, /* READs are allowed for given req_cluster */
+ PLOOP_REQ_FSYNC_DONE, /* fsync_thread() performed f_op->fsync() */
};
enum
More information about the Devel
mailing list