From: Heinz Mauelshagen <hei...@redhat.com>

Signed-off-by: Heinz Mauelshagen <hei...@redhat.com>
Signed-off-by: Mike Snitzer <snit...@kernel.org>
---
 drivers/md/dm-flakey.c          |  3 +-
 drivers/md/dm-integrity.c       | 54 +++++++++++++++++----------------
 drivers/md/dm-io.c              | 26 ++++++++--------
 drivers/md/dm-snap-persistent.c | 20 ++++++------
 drivers/md/dm-snap.c            |  3 +-
 drivers/md/dm-table.c           |  3 +-
 drivers/md/dm-verity-target.c   |  6 ++--
 drivers/md/dm-writecache.c      | 12 +++++---
 8 files changed, 66 insertions(+), 61 deletions(-)

diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c
index e4464b37732a..26ef181ac4dd 100644
--- a/drivers/md/dm-flakey.c
+++ b/drivers/md/dm-flakey.c
@@ -357,8 +357,7 @@ static int flakey_map(struct dm_target *ti, struct bio *bio)
                if (test_bit(DROP_WRITES, &fc->flags)) {
                        bio_endio(bio);
                        return DM_MAPIO_SUBMITTED;
-               }
-               else if (test_bit(ERROR_WRITES, &fc->flags)) {
+               } else if (test_bit(ERROR_WRITES, &fc->flags)) {
                        bio_io_error(bio);
                        return DM_MAPIO_SUBMITTED;
                }
diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c
index ed6515411e85..f650e540a09e 100644
--- a/drivers/md/dm-integrity.c
+++ b/drivers/md/dm-integrity.c
@@ -679,16 +679,18 @@ static bool block_bitmap_op(struct dm_integrity_c *ic, 
struct page_list *bitmap,
        } else if (mode == BITMAP_OP_CLEAR) {
                if (!bit && this_end_bit == PAGE_SIZE * 8 - 1)
                        clear_page(data);
-               else while (bit <= this_end_bit) {
-                       if (!(bit % BITS_PER_LONG) && this_end_bit >= bit + 
BITS_PER_LONG - 1) {
-                               do {
-                                       data[bit / BITS_PER_LONG] = 0;
-                                       bit += BITS_PER_LONG;
-                               } while (this_end_bit >= bit + BITS_PER_LONG - 
1);
-                               continue;
+               else {
+                       while (bit <= this_end_bit) {
+                               if (!(bit % BITS_PER_LONG) && this_end_bit >= 
bit + BITS_PER_LONG - 1) {
+                                       do {
+                                               data[bit / BITS_PER_LONG] = 0;
+                                               bit += BITS_PER_LONG;
+                                       } while (this_end_bit >= bit + 
BITS_PER_LONG - 1);
+                                       continue;
+                               }
+                               __clear_bit(bit, data);
+                               bit++;
                        }
-                       __clear_bit(bit, data);
-                       bit++;
                }
        } else {
                BUG();
@@ -2010,23 +2012,23 @@ static bool __journal_read_write(struct dm_integrity_io 
*dio, struct bio *bio,
                                unsigned int tag_todo = ic->tag_size;
                                char *tag_ptr = journal_entry_tag(ic, je);
 
-                               if (bip) do {
-                                       struct bio_vec biv = 
bvec_iter_bvec(bip->bip_vec, bip->bip_iter);
-                                       unsigned int tag_now = min(biv.bv_len, 
tag_todo);
-                                       char *tag_addr;
-                                       BUG_ON(PageHighMem(biv.bv_page));
-                                       tag_addr = bvec_virt(&biv);
-                                       if (likely(dio->op == REQ_OP_WRITE))
-                                               memcpy(tag_ptr, tag_addr, 
tag_now);
-                                       else
-                                               memcpy(tag_addr, tag_ptr, 
tag_now);
-                                       bvec_iter_advance(bip->bip_vec, 
&bip->bip_iter, tag_now);
-                                       tag_ptr += tag_now;
-                                       tag_todo -= tag_now;
-                               } while (unlikely(tag_todo)); else {
-                                       if (likely(dio->op == REQ_OP_WRITE))
-                                               memset(tag_ptr, 0, tag_todo);
-                               }
+                               if (bip) {
+                                       do {
+                                               struct bio_vec biv = 
bvec_iter_bvec(bip->bip_vec, bip->bip_iter);
+                                               unsigned int tag_now = 
min(biv.bv_len, tag_todo);
+                                               char *tag_addr;
+                                               
BUG_ON(PageHighMem(biv.bv_page));
+                                               tag_addr = bvec_virt(&biv);
+                                               if (likely(dio->op == 
REQ_OP_WRITE))
+                                                       memcpy(tag_ptr, 
tag_addr, tag_now);
+                                               else
+                                                       memcpy(tag_addr, 
tag_ptr, tag_now);
+                                               bvec_iter_advance(bip->bip_vec, 
&bip->bip_iter, tag_now);
+                                               tag_ptr += tag_now;
+                                               tag_todo -= tag_now;
+                                       } while (unlikely(tag_todo));
+                               } else if (likely(dio->op == REQ_OP_WRITE))
+                                       memset(tag_ptr, 0, tag_todo);
                        }
 
                        if (likely(dio->op == REQ_OP_WRITE)) {
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 9e0ef8bbd7e9..1c04cc9787d1 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -359,18 +359,20 @@ static void do_region(const blk_opf_t opf, unsigned int 
region,
                        num_sectors = min_t(sector_t, special_cmd_max_sectors, 
remaining);
                        bio->bi_iter.bi_size = num_sectors << SECTOR_SHIFT;
                        remaining -= num_sectors;
-               } else while (remaining) {
-                       /*
-                        * Try and add as many pages as possible.
-                        */
-                       dp->get_page(dp, &page, &len, &offset);
-                       len = min(len, to_bytes(remaining));
-                       if (!bio_add_page(bio, page, len, offset))
-                               break;
-
-                       offset = 0;
-                       remaining -= to_sector(len);
-                       dp->next_page(dp);
+               } else {
+                       while (remaining) {
+                               /*
+                                * Try and add as many pages as possible.
+                                */
+                               dp->get_page(dp, &page, &len, &offset);
+                               len = min(len, to_bytes(remaining));
+                               if (!bio_add_page(bio, page, len, offset))
+                                       break;
+
+                               offset = 0;
+                               remaining -= to_sector(len);
+                               dp->next_page(dp);
+                       }
                }
 
                atomic_inc(&io->count);
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index c05e398d43d7..0877285a0514 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -518,15 +518,17 @@ static int read_exceptions(struct pstore *ps,
                if (unlikely(prefetch_area < ps->current_area))
                        prefetch_area = ps->current_area;
 
-               if (DM_PREFETCH_CHUNKS) do {
-                       chunk_t pf_chunk = area_location(ps, prefetch_area);
-                       if (unlikely(pf_chunk >= 
dm_bufio_get_device_size(client)))
-                               break;
-                       dm_bufio_prefetch(client, pf_chunk, 1);
-                       prefetch_area++;
-                       if (unlikely(!prefetch_area))
-                               break;
-               } while (prefetch_area <= ps->current_area + 
DM_PREFETCH_CHUNKS);
+               if (DM_PREFETCH_CHUNKS) {
+                       do {
+                               chunk_t pf_chunk = area_location(ps, 
prefetch_area);
+                               if (unlikely(pf_chunk >= 
dm_bufio_get_device_size(client)))
+                                       break;
+                               dm_bufio_prefetch(client, pf_chunk, 1);
+                               prefetch_area++;
+                               if (unlikely(!prefetch_area))
+                                       break;
+                       } while (prefetch_area <= ps->current_area + 
DM_PREFETCH_CHUNKS);
+               }
 
                chunk = area_location(ps, ps->current_area);
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index 35c648ef2162..3357731c9db8 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -2345,8 +2345,7 @@ static void snapshot_status(struct dm_target *ti, 
status_type_t type,
                                       (unsigned long long)sectors_allocated,
                                       (unsigned long long)total_sectors,
                                       (unsigned long long)metadata_sectors);
-                       }
-                       else
+                       } else
                                DMEMIT("Unknown");
                }
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 6cb7c2afd2d3..58b9198b1c78 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1974,8 +1974,7 @@ int dm_table_set_restrictions(struct dm_table *t, struct 
request_queue *q,
                blk_queue_flag_set(QUEUE_FLAG_DAX, q);
                if (dm_table_supports_dax(t, 
device_not_dax_synchronous_capable))
                        set_dax_synchronous(t->md->dax_dev);
-       }
-       else
+       } else
                blk_queue_flag_clear(QUEUE_FLAG_DAX, q);
 
        if (dm_table_any_dev_attr(t, device_dax_write_cache_enabled, NULL))
diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c
index c9d937053910..99a5b0dc99af 100644
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -332,10 +332,8 @@ static int verity_verify_level(struct dm_verity *v, struct 
dm_verity_io *io,
                         */
                        r = -EAGAIN;
                        goto release_ret_r;
-               }
-               else if (verity_fec_decode(v, io,
-                                          DM_VERITY_BLOCK_TYPE_METADATA,
-                                          hash_block, data, NULL) == 0)
+               } else if (verity_fec_decode(v, io, 
DM_VERITY_BLOCK_TYPE_METADATA,
+                                            hash_block, data, NULL) == 0)
                        aux->hash_verified = 1;
                else if (verity_handle_err(v,
                                           DM_VERITY_BLOCK_TYPE_METADATA,
diff --git a/drivers/md/dm-writecache.c b/drivers/md/dm-writecache.c
index 78c55fbb660f..973e0464fc67 100644
--- a/drivers/md/dm-writecache.c
+++ b/drivers/md/dm-writecache.c
@@ -941,7 +941,8 @@ static void writecache_suspend(struct dm_target *ti)
        wc_lock(wc);
        if (flush_on_suspend)
                wc->writeback_all--;
-       while (writecache_wait_for_writeback(wc));
+       while (writecache_wait_for_writeback(wc))
+               ;
 
        if (WC_MODE_PMEM(wc))
                persistent_memory_flush_cache(wc->memory_map, 
wc->memory_map_size);
@@ -2090,7 +2091,8 @@ static void writecache_writeback(struct work_struct *work)
 
        if (unlikely(wc->writeback_all)) {
                wc_lock(wc);
-               while (writecache_wait_for_writeback(wc));
+               while (writecache_wait_for_writeback(wc))
+                       ;
                wc_unlock(wc);
        }
 }
@@ -2448,12 +2450,14 @@ static int writecache_ctr(struct dm_target *ti, 
unsigned int argc, char **argv)
                        if (WC_MODE_PMEM(wc)) {
                                wc->writeback_fua = true;
                                wc->writeback_fua_set = true;
-                       } else goto invalid_optional;
+                       } else
+                               goto invalid_optional;
                } else if (!strcasecmp(string, "nofua")) {
                        if (WC_MODE_PMEM(wc)) {
                                wc->writeback_fua = false;
                                wc->writeback_fua_set = true;
-                       } else goto invalid_optional;
+                       } else
+                               goto invalid_optional;
                } else if (!strcasecmp(string, "metadata_only")) {
                        wc->metadata_only = true;
                } else if (!strcasecmp(string, "pause_writeback") && opt_params 
>= 1) {
-- 
2.37.0 (Apple Git-136)

--
dm-devel mailing list
dm-devel@redhat.com
https://listman.redhat.com/mailman/listinfo/dm-devel

Reply via email to