[Devel] [PATCH RHEL9 COMMIT] dm-ploop: sync when suspended or stopping

[Konstantin Khorenko]

The commit is pushed to "branch-rh9-5.14.0-427.44.1.vz9.80.x-ovz" and will appear at git at bitbucket.org:openvz/vzkernel.git
after rh9-5.14.0-427.44.1.vz9.80.6
------>
commit 086db838740e51609a13d4e2b71ed80e8af359d3
Author: Alexander Atanasov <alexander.atanasov at virtuozzo.com>
Date:   Fri Jan 24 17:36:28 2025 +0200

    dm-ploop: sync when suspended or stopping
    
    On suspended or stopped sync delta.
    
    Enable use of per cpu pool cache for bio allocated from kaio.
    
    https://virtuozzo.atlassian.net/browse/VSTOR-91821
    Signed-off-by: Alexander Atanasov <alexander.atanasov at virtuozzo.com>
    
    ======
    Patchset description:
    ploop: optimistations and scalling
    
    Ploop processes requsts in a different threads in parallel
    where possible which results in significant improvement in
    performance and makes further optimistations possible.
    
    Known bugs:
      - delayed metadata writeback is not working and is missing error handling
         - patch to disable it until fixed
      - fast path is not working - causes rcu lockups - patch to disable it
    
    Further improvements:
      - optimize md pages lookups
    
    Alexander Atanasov (50):
      dm-ploop: md_pages map all pages at creation time
      dm-ploop: Use READ_ONCE/WRITE_ONCE to access md page data
      dm-ploop: fsync after all pios are sent
      dm-ploop: move md status to use proper bitops
      dm-ploop: convert wait_list and wb_batch_llist to use lockless lists
      dm-ploop: convert enospc handling to use lockless lists
      dm-ploop: convert suspended_pios list to use lockless list
      dm-ploop: convert the rest of the lists to use llist variant
      dm-ploop: combine processing of pios thru prepare list and remove
        fsync worker
      dm-ploop: move from wq to kthread
      dm-ploop: move preparations of pios into the caller from worker
      dm-ploop: fast path execution for reads
      dm-ploop: do not use a wrapper for set_bit to make a page writeback
      dm-ploop: BAT use only one list for writeback
      dm-ploop: make md writeback timeout to be per page
      dm-ploop: add interface to disable bat writeback delay
      dm-ploop: convert wb_batch_list to lockless variant
      dm-ploop: convert high_prio to status
      dm-ploop: split cow processing into two functions
      dm-ploop: convert md page rw lock to spin lock
      dm-ploop: convert bat_rwlock to bat_lock spinlock
      dm-ploop: prepare bat updates under bat_lock
      dm-ploop: make ploop_bat_write_complete ready for parallel pio
        completion
      dm-ploop: make ploop_submit_metadata_writeback return number of
        requests sent
      dm-ploop: introduce pio runner threads
      dm-ploop: add pio list ids to be used when passing pios to runners
      dm-ploop: process pios via runners
      dm-ploop: disable metadata writeback delay
      dm-ploop: disable fast path
      dm-ploop: use lockless lists for chained cow updates list
      dm-ploop: use lockless lists for data ready pios
      dm-ploop: give runner threads better name
      dm-ploop: resize operation - add holes bitmap locking
      dm-ploop: remove unnecessary operations
      dm-ploop: use filp per thread
      dm-ploop: catch if we try to advance pio past bio end
      dm-ploop: support REQ_FUA for data pios
      dm-ploop: proplerly access nr_bat_entries
      dm-ploop: fix locking and improve error handling when submitting pios
      dm-ploop: fix how ENOTBLK is handled
      dm-ploop: sync when suspended or stopping
      dm-ploop: rework bat completion logic
      dm-ploop: rework logic in pio processing
      dm-ploop: end fsync pios in parallel
      dm-ploop: make filespace preallocations async
      dm-ploop: resubmit enospc pios from dispatcher thread
      dm-ploop: dm-ploop: simplify discard completion
      dm-ploop: use GFP_ATOMIC instead of GFP_NOIO
      dm-ploop: fix locks used in mixed context
      dm-ploop: fix how current flags are managed inside threads
    
    Andrey Zhadchenko (13):
      dm-ploop: do not flush after metadata writes
      dm-ploop: set IOCB_DSYNC on all FUA requests
      dm-ploop: remove extra ploop_cluster_is_in_top_delta()
      dm-ploop: introduce per-md page locking
      dm-ploop: reduce BAT accesses on discard completion
      dm-ploop: simplify llseek
      dm-ploop: speed up ploop_prepare_bat_update()
      dm-ploop: make new allocations immediately visible in BAT
      dm-ploop: drop ploop_cluster_is_in_top_delta()
      dm-ploop: do not wait for BAT update for non-FUA requests
      dm-ploop: add delay for metadata writeback
      dm-ploop: submit all postponed metadata on REQ_OP_FLUSH
      dm-ploop: handle REQ_PREFLUSH
    
    Feature: dm-ploop: ploop target driver
---
 drivers/md/dm-ploop-target.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/drivers/md/dm-ploop-target.c b/drivers/md/dm-ploop-target.c
index e8beacc5841b..8b0d2b7ae85b 100644
--- a/drivers/md/dm-ploop-target.c
+++ b/drivers/md/dm-ploop-target.c
@@ -61,7 +61,8 @@ void ploop_call_rw_iter(struct file *file, loff_t pos, unsigned rw,
 	init_sync_kiocb(iocb, file);
 	iocb->ki_pos = pos;
 	iocb->ki_complete = ploop_aio_complete;
-	if (pio->bi_op & REQ_FUA)
+	iocb->ki_flags |= IOCB_ALLOC_CACHE;
+	if (rw == WRITE && pio->bi_op & REQ_FUA)
 		iocb->ki_flags |= IOCB_DSYNC;
 
 	atomic_set(&pio->aio_ref, 2);
@@ -186,7 +187,8 @@ static void ploop_destroy(struct ploop *ploop)
 			}
 		}
 
-		kthread_stop(ploop->kt_worker->task);	/* waits for the thread to stop */
+		/* waits for the thread to stop */
+		kthread_stop(ploop->kt_worker->task);
 
 		WARN_ON(!llist_empty(&ploop->pios[PLOOP_LIST_PREPARE]));
 		WARN_ON(!llist_empty(&ploop->llresubmit_pios));
@@ -199,6 +201,8 @@ static void ploop_destroy(struct ploop *ploop)
 		percpu_ref_exit(&ploop->inflight_bios_ref[i]);
 	/* Nobody uses it after destroy_workqueue() */
 	while (ploop->nr_deltas-- > 0) {
+		vfs_fsync(ploop->deltas[ploop->nr_deltas].file, 1);
+
 		if (ploop->deltas[ploop->nr_deltas].file)
 			fput(ploop->deltas[ploop->nr_deltas].file);
 		for (i = 0; i < ploop->nkt_runners; i++) {
@@ -279,10 +283,15 @@ static int ploop_check_top_delta(struct ploop *ploop, struct file *file)
 	if (!page)
 		goto out;
 
+
 	ret = ploop_rw_page_sync(READ, file, 0, page);
 	if (ret < 0)
 		goto out;
 
+
+	/* flush dirty pages before changing direct IO */
+	vfs_fsync(file, 1);
+
 	ret = ploop_setup_metadata(ploop, page);
 	if (ret)
 		goto out;
@@ -344,6 +353,9 @@ static int ploop_add_deltas_stack(struct ploop *ploop, char **argv, int argc)
 				goto err_fput;
 		}
 
+		/* switch to direct io here */
+		vfs_fsync(file, 0);
+
 		ret = ploop_add_delta(ploop, i, file, is_raw);
 		if (ret < 0)
 			goto err_fput;
@@ -662,11 +674,16 @@ static void ploop_presuspend(struct dm_target *ti)
 	 * For pending enospc requests. Otherwise,
 	 * we may never be able to suspend this target.
 	 */
+	/* All flushes are done as one */
 	ploop_set_wants_suspend(ti, true);
 	flush_work(&ploop->event_work);
 	del_timer_sync(&ploop->enospc_timer);
+	wait_event_interruptible(ploop->dispatcher_wq_data,
+			(!atomic_read(&ploop->kt_worker->inflight_pios)));
+	vfs_fsync(ploop_top_delta(ploop)->file, 0);
 	ploop_enospc_timer(&ploop->enospc_timer);
 }
+
 static void ploop_presuspend_undo(struct dm_target *ti)
 {
 	ploop_set_wants_suspend(ti, false);