MD bitmap: Revert DM dirty log hooks

Revert most of commit e384e58549a2e9a83071ad80280c1a9053cfd84c
  md/bitmap: prepare for storing write-intent-bitmap via dm-dirty-log.

MD should not need to use DM's dirty log - we decided to use md's
bitmaps instead.

Keeping the DIV_ROUND_UP clean-ups that were part of commit
e384e58549a2e9a83071ad80280c1a9053cfd84c, however.

Signed-off-by: Jonathan Brassow <jbrassow@redhat.com>
Signed-off-by: NeilBrown <neilb@suse.de>

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 39ff0ef8b76e786e2ff44826e97fa0bbc5432d5d..0dc6546b77a8765301b1cdf9003214ced5945ad9 100644 (file)
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -29,7 +29,6 @@
 #include "md.h"
 #include "bitmap.h"
 
-#include <linux/dm-dirty-log.h>
 /* debug macros */
 
 #define DEBUG 0
@@ -775,10 +774,8 @@ static inline unsigned long file_page_offset(struct bitmap *bitmap, unsigned lon
  * 0 or page 1
  */
 static inline struct page *filemap_get_page(struct bitmap *bitmap,
-                                       unsigned long chunk)
+                                           unsigned long chunk)
 {
-       if (bitmap->filemap == NULL)
-               return NULL;
        if (file_page_index(bitmap, chunk) >= bitmap->file_pages)
                return NULL;
        return bitmap->filemap[file_page_index(bitmap, chunk)
@@ -878,28 +875,19 @@ enum bitmap_page_attr {
 static inline void set_page_attr(struct bitmap *bitmap, struct page *page,
                                enum bitmap_page_attr attr)
 {
-       if (page)
-               __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
-       else
-               __set_bit(attr, &bitmap->logattrs);
+       __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
 }
 
 static inline void clear_page_attr(struct bitmap *bitmap, struct page *page,
                                enum bitmap_page_attr attr)
 {
-       if (page)
-               __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
-       else
-               __clear_bit(attr, &bitmap->logattrs);
+       __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
 }
 
 static inline unsigned long test_page_attr(struct bitmap *bitmap, struct page *page,
                                           enum bitmap_page_attr attr)
 {
-       if (page)
-               return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
-       else
-               return test_bit(attr, &bitmap->logattrs);
+       return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
 }
 
 /*
@@ -912,30 +900,26 @@ static inline unsigned long test_page_attr(struct bitmap *bitmap, struct page *p
 static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block)
 {
        unsigned long bit;
-       struct page *page = NULL;
+       struct page *page;
        void *kaddr;
        unsigned long chunk = block >> CHUNK_BLOCK_SHIFT(bitmap);
 
-       if (!bitmap->filemap) {
-               struct dm_dirty_log *log = bitmap->mddev->bitmap_info.log;
-               if (log)
-                       log->type->mark_region(log, chunk);
-       } else {
+       if (!bitmap->filemap)
+               return;
 
-               page = filemap_get_page(bitmap, chunk);
-               if (!page)
-                       return;
-               bit = file_page_offset(bitmap, chunk);
+       page = filemap_get_page(bitmap, chunk);
+       if (!page)
+               return;
+       bit = file_page_offset(bitmap, chunk);
 
-               /* set the bit */
-               kaddr = kmap_atomic(page, KM_USER0);
-               if (bitmap->flags & BITMAP_HOSTENDIAN)
-                       set_bit(bit, kaddr);
-               else
-                       __set_bit_le(bit, kaddr);
-               kunmap_atomic(kaddr, KM_USER0);
-               PRINTK("set file bit %lu page %lu\n", bit, page->index);
-       }
+       /* set the bit */
+       kaddr = kmap_atomic(page, KM_USER0);
+       if (bitmap->flags & BITMAP_HOSTENDIAN)
+               set_bit(bit, kaddr);
+       else
+               __set_bit_le(bit, kaddr);
+       kunmap_atomic(kaddr, KM_USER0);
+       PRINTK("set file bit %lu page %lu\n", bit, page->index);
        /* record page number so it gets flushed to disk when unplug occurs */
        set_page_attr(bitmap, page, BITMAP_PAGE_DIRTY);
 }
@@ -952,16 +936,6 @@ void bitmap_unplug(struct bitmap *bitmap)
 
        if (!bitmap)
                return;
-       if (!bitmap->filemap) {
-               /* Must be using a dirty_log */
-               struct dm_dirty_log *log = bitmap->mddev->bitmap_info.log;
-               dirty = test_and_clear_bit(BITMAP_PAGE_DIRTY, &bitmap->logattrs);
-               need_write = test_and_clear_bit(BITMAP_PAGE_NEEDWRITE, &bitmap->logattrs);
-               if (dirty || need_write)
-                       if (log->type->flush(log))
-                               bitmap->flags |= BITMAP_WRITE_ERROR;
-               goto out;
-       }
 
        /* look at each page to see if there are any set bits that need to be
         * flushed out to disk */
@@ -990,7 +964,6 @@ void bitmap_unplug(struct bitmap *bitmap)
                else
                        md_super_wait(bitmap->mddev);
        }
-out:
        if (bitmap->flags & BITMAP_WRITE_ERROR)
                bitmap_file_kick(bitmap);
 }
@@ -1199,7 +1172,6 @@ void bitmap_daemon_work(mddev_t *mddev)
        struct page *page = NULL, *lastpage = NULL;
        sector_t blocks;
        void *paddr;
-       struct dm_dirty_log *log = mddev->bitmap_info.log;
 
        /* Use a mutex to guard daemon_work against
         * bitmap_destroy.
@@ -1224,12 +1196,11 @@ void bitmap_daemon_work(mddev_t *mddev)
        spin_lock_irqsave(&bitmap->lock, flags);
        for (j = 0; j < bitmap->chunks; j++) {
                bitmap_counter_t *bmc;
-               if (!bitmap->filemap) {
-                       if (!log)
-                               /* error or shutdown */
-                               break;
-               } else
-                       page = filemap_get_page(bitmap, j);
+               if (!bitmap->filemap)
+                       /* error or shutdown */
+                       break;
+
+               page = filemap_get_page(bitmap, j);
 
                if (page != lastpage) {
                        /* skip this page unless it's marked as needing cleaning */
@@ -1298,19 +1269,16 @@ void bitmap_daemon_work(mddev_t *mddev)
                                                  -1);
 
                                /* clear the bit */
-                               if (page) {
-                                       paddr = kmap_atomic(page, KM_USER0);
-                                       if (bitmap->flags & BITMAP_HOSTENDIAN)
-                                               clear_bit(file_page_offset(bitmap, j),
-                                                         paddr);
-                                       else
-                                               __clear_bit_le(
+                               paddr = kmap_atomic(page, KM_USER0);
+                               if (bitmap->flags & BITMAP_HOSTENDIAN)
+                                       clear_bit(file_page_offset(bitmap, j),
+                                                 paddr);
+                               else
+                                       __clear_bit_le(
                                                        file_page_offset(bitmap,
                                                                         j),
                                                        paddr);
-                                       kunmap_atomic(paddr, KM_USER0);
-                               } else
-                                       log->type->clear_region(log, j);
+                               kunmap_atomic(paddr, KM_USER0);
                        }
                } else
                        j |= PAGE_COUNTER_MASK;
@@ -1318,16 +1286,12 @@ void bitmap_daemon_work(mddev_t *mddev)
        spin_unlock_irqrestore(&bitmap->lock, flags);
 
        /* now sync the final page */
-       if (lastpage != NULL || log != NULL) {
+       if (lastpage != NULL) {
                spin_lock_irqsave(&bitmap->lock, flags);
                if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {
                        clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
                        spin_unlock_irqrestore(&bitmap->lock, flags);
-                       if (lastpage)
-                               write_page(bitmap, lastpage, 0);
-                       else
-                               if (log->type->flush(log))
-                                       bitmap->flags |= BITMAP_WRITE_ERROR;
+                       write_page(bitmap, lastpage, 0);
                } else {
                        set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
                        spin_unlock_irqrestore(&bitmap->lock, flags);
@@ -1769,12 +1733,10 @@ int bitmap_create(mddev_t *mddev)
        BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
 
        if (!file
-           && !mddev->bitmap_info.offset
-           && !mddev->bitmap_info.log) /* bitmap disabled, nothing to do */
+           && !mddev->bitmap_info.offset) /* bitmap disabled, nothing to do */
                return 0;
 
        BUG_ON(file && mddev->bitmap_info.offset);
-       BUG_ON(mddev->bitmap_info.offset && mddev->bitmap_info.log);
 
        bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
        if (!bitmap)
@@ -1865,6 +1827,7 @@ int bitmap_create(mddev_t *mddev)
 int bitmap_load(mddev_t *mddev)
 {
        int err = 0;
+       sector_t start = 0;
        sector_t sector = 0;
        struct bitmap *bitmap = mddev->bitmap;
 
@@ -1883,24 +1846,14 @@ int bitmap_load(mddev_t *mddev)
        }
        bitmap_close_sync(bitmap);
 
-       if (mddev->bitmap_info.log) {
-               unsigned long i;
-               struct dm_dirty_log *log = mddev->bitmap_info.log;
-               for (i = 0; i < bitmap->chunks; i++)
-                       if (!log->type->in_sync(log, i, 1))
-                               bitmap_set_memory_bits(bitmap,
-                                                      (sector_t)i << CHUNK_BLOCK_SHIFT(bitmap),
-                                                      1);
-       } else {
-               sector_t start = 0;
-               if (mddev->degraded == 0
-                   || bitmap->events_cleared == mddev->events)
-                       /* no need to keep dirty bits to optimise a
-                        * re-add of a missing device */
-                       start = mddev->recovery_cp;
-
-               err = bitmap_init_from_disk(bitmap, start);
-       }
+       if (mddev->degraded == 0
+           || bitmap->events_cleared == mddev->events)
+               /* no need to keep dirty bits to optimise a
+                * re-add of a missing device */
+               start = mddev->recovery_cp;
+
+       err = bitmap_init_from_disk(bitmap, start);
+
        if (err)
                goto out;
 

diff --git a/drivers/md/bitmap.h b/drivers/md/bitmap.h
index b2a127e891acedc9843ff4b61e1e8c62b2456a48..a28f2e5588c6f222f747f4cb7810cf4c48210be1 100644 (file)
--- a/drivers/md/bitmap.h
+++ b/drivers/md/bitmap.h
@@ -212,10 +212,6 @@ struct bitmap {
        unsigned long file_pages; /* number of pages in the file */
        int last_page_size; /* bytes in the last page */
 
-       unsigned long logattrs; /* used when filemap_attr doesn't exist
-                                * because we are working with a dirty_log
-                                */
-
        unsigned long flags;
 
        int allclean;
@@ -237,7 +233,6 @@ struct bitmap {
        wait_queue_head_t behind_wait;
 
        struct sysfs_dirent *sysfs_can_clear;
-
 };
 
 /* the bitmap API */

diff --git a/drivers/md/md.h b/drivers/md/md.h
index de5455d30d41171855c6be41b95ceab0917f52d7..7d906a96477af7b9631532cbdbe225fef6b8d341 100644 (file)
--- a/drivers/md/md.h
+++ b/drivers/md/md.h
@@ -307,11 +307,6 @@ struct mddev_s
                                                         * hot-adding a bitmap.  It should
                                                         * eventually be settable by sysfs.
                                                         */
-               /* When md is serving under dm, it might use a
-                * dirty_log to store the bits.
-                */
-               struct dm_dirty_log *log;
-
                struct mutex            mutex;
                unsigned long           chunksize;
                unsigned long           daemon_sleep; /* how many jiffies between updates? */