Merge commit 'v2.6.38-rc1' into kbuild/packaging

1 files changed, 340 insertions, 257 deletions

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 26ac8aad0b19..9a35320fb59f 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -13,7 +13,6 @@
  * Still to do:
  *
  * flush after percent set rather than just time based. (maybe both).
- * wait if count gets too high, wake when it drops to half.
  */
 
 #include <linux/blkdev.h>
@@ -30,6 +29,7 @@
 #include "md.h"
 #include "bitmap.h"
 
+#include <linux/dm-dirty-log.h>
 /* debug macros */
 
 #define DEBUG 0
@@ -51,9 +51,6 @@
 #define INJECT_FATAL_FAULT_3 0 /* undef */
 #endif
 
-//#define DPRINTK PRINTK /* set this NULL to avoid verbose debug output */
-#define DPRINTK(x...) do { } while(0)
-
 #ifndef PRINTK
 #  if DEBUG > 0
 #    define PRINTK(x...) printk(KERN_DEBUG x)
@@ -62,12 +59,11 @@
 #  endif
 #endif
 
-static inline char * bmname(struct bitmap *bitmap)
+static inline char *bmname(struct bitmap *bitmap)
 {
         return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";
 }
 
-
 /*
  * just a placeholder - calls kmalloc for bitmap pages
  */
@@ -78,7 +74,7 @@ static unsigned char *bitmap_alloc_page(struct bitmap *bitmap)
 #ifdef INJECT_FAULTS_1
         page = NULL;
 #else
-        page = kmalloc(PAGE_SIZE, GFP_NOIO);
+        page = kzalloc(PAGE_SIZE, GFP_NOIO);
 #endif
         if (!page)
                 printk("%s: bitmap_alloc_page FAILED\n", bmname(bitmap));
@@ -107,7 +103,8 @@ static void bitmap_free_page(struct bitmap *bitmap, unsigned char *page)
  * if we find our page, we increment the page's refcount so that it stays
  * allocated while we're using it
  */
-static int bitmap_checkpage(struct bitmap *bitmap, unsigned long page, int create)
+static int bitmap_checkpage(struct bitmap *bitmap,
+                            unsigned long page, int create)
 __releases(bitmap->lock)
 __acquires(bitmap->lock)
 {
@@ -121,7 +118,6 @@ __acquires(bitmap->lock)
                 return -EINVAL;
         }
 
-
         if (bitmap->bp[page].hijacked) /* it's hijacked, don't try to alloc */
                 return 0;
 
@@ -131,43 +127,34 @@ __acquires(bitmap->lock)
         if (!create)
                 return -ENOENT;
 
-        spin_unlock_irq(&bitmap->lock);
-
         /* this page has not been allocated yet */
 
-        if ((mappage = bitmap_alloc_page(bitmap)) == NULL) {
+        spin_unlock_irq(&bitmap->lock);
+        mappage = bitmap_alloc_page(bitmap);
+        spin_lock_irq(&bitmap->lock);
+
+        if (mappage == NULL) {
                 PRINTK("%s: bitmap map page allocation failed, hijacking\n",
                         bmname(bitmap));
                 /* failed - set the hijacked flag so that we can use the
                  * pointer as a counter */
-                spin_lock_irq(&bitmap->lock);
                 if (!bitmap->bp[page].map)
                         bitmap->bp[page].hijacked = 1;
-                goto out;
-        }
-
-        /* got a page */
-
-        spin_lock_irq(&bitmap->lock);
-
-        /* recheck the page */
-
-        if (bitmap->bp[page].map || bitmap->bp[page].hijacked) {
+        } else if (bitmap->bp[page].map ||
+                   bitmap->bp[page].hijacked) {
                 /* somebody beat us to getting the page */
                 bitmap_free_page(bitmap, mappage);
                 return 0;
-        }
+        } else {
 
-        /* no page was in place and we have one, so install it */
+                /* no page was in place and we have one, so install it */
 
-        memset(mappage, 0, PAGE_SIZE);
-        bitmap->bp[page].map = mappage;
-        bitmap->missing_pages--;
-out:
+                bitmap->bp[page].map = mappage;
+                bitmap->missing_pages--;
+        }
         return 0;
 }
 
-
 /* if page is completely empty, put it back on the free list, or dealloc it */
 /* if page was hijacked, unmark the flag so it might get alloced next time */
 /* Note: lock should be held when calling this */
@@ -183,26 +170,15 @@ static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page)
         if (bitmap->bp[page].hijacked) { /* page was hijacked, undo this now */
                 bitmap->bp[page].hijacked = 0;
                 bitmap->bp[page].map = NULL;
-                return;
+        } else {
+                /* normal case, free the page */
+                ptr = bitmap->bp[page].map;
+                bitmap->bp[page].map = NULL;
+                bitmap->missing_pages++;
+                bitmap_free_page(bitmap, ptr);
         }
-
-        /* normal case, free the page */
-
-#if 0
-/* actually ... let's not.  We will probably need the page again exactly when
- * memory is tight and we are flusing to disk
- */
-        return;
-#else
-        ptr = bitmap->bp[page].map;
-        bitmap->bp[page].map = NULL;
-        bitmap->missing_pages++;
-        bitmap_free_page(bitmap, ptr);
-        return;
-#endif
 }
 
-
 /*
  * bitmap file handling - read and write the bitmap file and its superblock
  */
@@ -220,28 +196,33 @@ static struct page *read_sb_page(mddev_t *mddev, loff_t offset,
 
         mdk_rdev_t *rdev;
         sector_t target;
+        int did_alloc = 0;
 
-        if (!page)
+        if (!page) {
                 page = alloc_page(GFP_KERNEL);
-        if (!page)
-                return ERR_PTR(-ENOMEM);
+                if (!page)
+                        return ERR_PTR(-ENOMEM);
+                did_alloc = 1;
+        }
 
         list_for_each_entry(rdev, &mddev->disks, same_set) {
                 if (! test_bit(In_sync, &rdev->flags)
                     || test_bit(Faulty, &rdev->flags))
                         continue;
 
-                target = rdev->sb_start + offset + index * (PAGE_SIZE/512);
+                target = offset + index * (PAGE_SIZE/512);
 
-                if (sync_page_io(rdev->bdev, target,
+                if (sync_page_io(rdev, target,
                                  roundup(size, bdev_logical_block_size(rdev->bdev)),
-                                 page, READ)) {
+                                 page, READ, true)) {
                         page->index = index;
                         attach_page_buffers(page, NULL); /* so that free_buffer will
                                                           * quietly no-op */
                         return page;
                 }
         }
+        if (did_alloc)
+                put_page(page);
         return ERR_PTR(-EIO);
 
 }
@@ -283,52 +264,58 @@ static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev)
 static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
 {
         mdk_rdev_t *rdev = NULL;
+        struct block_device *bdev;
         mddev_t *mddev = bitmap->mddev;
 
         while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
-                        int size = PAGE_SIZE;
-                        loff_t offset = mddev->bitmap_info.offset;
-                        if (page->index == bitmap->file_pages-1)
-                                size = roundup(bitmap->last_page_size,
-                                               bdev_logical_block_size(rdev->bdev));
-                        /* Just make sure we aren't corrupting data or
-                         * metadata
-                         */
-                        if (mddev->external) {
-                                /* Bitmap could be anywhere. */
-                                if (rdev->sb_start + offset + (page->index *(PAGE_SIZE/512)) >
-                                    rdev->data_offset &&
-                                    rdev->sb_start + offset < 
-                                    rdev->data_offset + mddev->dev_sectors +
-                                    (PAGE_SIZE/512))
-                                        goto bad_alignment;
-                        } else if (offset < 0) {
-                                /* DATA  BITMAP METADATA  */
-                                if (offset
-                                    + (long)(page->index * (PAGE_SIZE/512))
-                                    + size/512 > 0)
-                                        /* bitmap runs in to metadata */
-                                        goto bad_alignment;
-                                if (rdev->data_offset + mddev->dev_sectors
-                                    > rdev->sb_start + offset)
-                                        /* data runs in to bitmap */
-                                        goto bad_alignment;
-                        } else if (rdev->sb_start < rdev->data_offset) {
-                                /* METADATA BITMAP DATA */
-                                if (rdev->sb_start
-                                    + offset
-                                    + page->index*(PAGE_SIZE/512) + size/512
-                                    > rdev->data_offset)
-                                        /* bitmap runs in to data */
-                                        goto bad_alignment;
-                        } else {
-                                /* DATA METADATA BITMAP - no problems */
-                        }
-                        md_super_write(mddev, rdev,
-                                       rdev->sb_start + offset
-                                       + page->index * (PAGE_SIZE/512),
-                                       size,
-                                       page);
+                int size = PAGE_SIZE;
+                loff_t offset = mddev->bitmap_info.offset;
+
+                bdev = (rdev->meta_bdev) ? rdev->meta_bdev : rdev->bdev;
+
+                if (page->index == bitmap->file_pages-1)
+                        size = roundup(bitmap->last_page_size,
+                                       bdev_logical_block_size(bdev));
+                /* Just make sure we aren't corrupting data or
+                 * metadata
+                 */
+                if (mddev->external) {
+                        /* Bitmap could be anywhere. */
+                        if (rdev->sb_start + offset + (page->index
+                                                       * (PAGE_SIZE/512))
+                            > rdev->data_offset
+                            &&
+                            rdev->sb_start + offset
+                            < (rdev->data_offset + mddev->dev_sectors
+                             + (PAGE_SIZE/512)))
+                                goto bad_alignment;
+                } else if (offset < 0) {
+                        /* DATA  BITMAP METADATA  */
+                        if (offset
+                            + (long)(page->index * (PAGE_SIZE/512))
+                            + size/512 > 0)
+                                /* bitmap runs in to metadata */
+                                goto bad_alignment;
+                        if (rdev->data_offset + mddev->dev_sectors
+                            > rdev->sb_start + offset)
+                                /* data runs in to bitmap */
+                                goto bad_alignment;
+                } else if (rdev->sb_start < rdev->data_offset) {
+                        /* METADATA BITMAP DATA */
+                        if (rdev->sb_start
+                            + offset
+                            + page->index*(PAGE_SIZE/512) + size/512
+                            > rdev->data_offset)
+                                /* bitmap runs in to data */
+                                goto bad_alignment;
+                } else {
+                        /* DATA METADATA BITMAP - no problems */
+                }
+                md_super_write(mddev, rdev,
+                               rdev->sb_start + offset
+                               + page->index * (PAGE_SIZE/512),
+                               size,
+                               page);
         }
 
         if (wait)
@@ -360,14 +347,13 @@ static void write_page(struct bitmap *bitmap, struct page *page, int wait)
                         atomic_inc(&bitmap->pending_writes);
                         set_buffer_locked(bh);
                         set_buffer_mapped(bh);
-                        submit_bh(WRITE, bh);
+                        submit_bh(WRITE | REQ_UNPLUG | REQ_SYNC, bh);
                         bh = bh->b_this_page;
                 }
 
-                if (wait) {
+                if (wait)
                         wait_event(bitmap->write_wait,
                                    atomic_read(&bitmap->pending_writes)==0);
-                }
         }
         if (bitmap->flags & BITMAP_WRITE_ERROR)
                 bitmap_file_kick(bitmap);
@@ -424,7 +410,7 @@ static struct page *read_page(struct file *file, unsigned long index,
         struct buffer_head *bh;
         sector_t block;
 
-        PRINTK("read bitmap file (%dB @ %Lu)\n", (int)PAGE_SIZE,
+        PRINTK("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,
                         (unsigned long long)index << PAGE_SHIFT);
 
         page = alloc_page(GFP_KERNEL);
@@ -478,7 +464,7 @@ static struct page *read_page(struct file *file, unsigned long index,
         }
 out:
         if (IS_ERR(page))
-                printk(KERN_ALERT "md: bitmap read error: (%dB @ %Lu): %ld\n",
+                printk(KERN_ALERT "md: bitmap read error: (%dB @ %llu): %ld\n",
                         (int)PAGE_SIZE,
                         (unsigned long long)index << PAGE_SHIFT,
                         PTR_ERR(page));
@@ -505,7 +491,7 @@ void bitmap_update_sb(struct bitmap *bitmap)
                 return;
         }
         spin_unlock_irqrestore(&bitmap->lock, flags);
-        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
         sb->events = cpu_to_le64(bitmap->mddev->events);
         if (bitmap->mddev->events < bitmap->events_cleared) {
                 /* rocking back to read-only */
@@ -526,7 +512,7 @@ void bitmap_print_sb(struct bitmap *bitmap)
 
         if (!bitmap || !bitmap->sb_page)
                 return;
-        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
         printk(KERN_DEBUG "%s: bitmap file superblock:\n", bmname(bitmap));
         printk(KERN_DEBUG "         magic: %08x\n", le32_to_cpu(sb->magic));
         printk(KERN_DEBUG "       version: %d\n", le32_to_cpu(sb->version));
@@ -575,7 +561,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
                 return err;
         }
 
-        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
 
         chunksize = le32_to_cpu(sb->chunksize);
         daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
@@ -661,14 +647,17 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits,
                 return 0;
         }
         spin_unlock_irqrestore(&bitmap->lock, flags);
-        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
+        sb = kmap_atomic(bitmap->sb_page, KM_USER0);
         old = le32_to_cpu(sb->state) & bits;
         switch (op) {
-                case MASK_SET: sb->state |= cpu_to_le32(bits);
-                                break;
-                case MASK_UNSET: sb->state &= cpu_to_le32(~bits);
-                                break;
-                default: BUG();
+        case MASK_SET:
+                sb->state |= cpu_to_le32(bits);
+                break;
+        case MASK_UNSET:
+                sb->state &= cpu_to_le32(~bits);
+                break;
+        default:
+                BUG();
         }
         kunmap_atomic(sb, KM_USER0);
         return old;
@@ -710,12 +699,14 @@ static inline unsigned long file_page_offset(struct bitmap *bitmap, unsigned lon
 static inline struct page *filemap_get_page(struct bitmap *bitmap,
                                         unsigned long chunk)
 {
-        if (file_page_index(bitmap, chunk) >= bitmap->file_pages) return NULL;
+        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)
                                - file_page_index(bitmap, 0)];
 }
 
-
 static void bitmap_file_unmap(struct bitmap *bitmap)
 {
         struct page **map, *sb_page;
@@ -766,7 +757,6 @@ static void bitmap_file_put(struct bitmap *bitmap)
         }
 }
 
-
 /*
  * bitmap_file_kick - if an error occurs while manipulating the bitmap file
  * then it is no longer reliable, so we stop using it and we mark the file
@@ -785,7 +775,6 @@ static void bitmap_file_kick(struct bitmap *bitmap)
                                 ptr = d_path(&bitmap->file->f_path, path,
                                              PAGE_SIZE);
 
-
                         printk(KERN_ALERT
                               "%s: kicking failed bitmap file %s from array!\n",
                               bmname(bitmap), IS_ERR(ptr) ? "" : ptr);
@@ -803,27 +792,36 @@ static void bitmap_file_kick(struct bitmap *bitmap)
 }
 
 enum bitmap_page_attr {
-        BITMAP_PAGE_DIRTY = 0, // there are set bits that need to be synced
-        BITMAP_PAGE_CLEAN = 1, // there are bits that might need to be cleared
-        BITMAP_PAGE_NEEDWRITE=2, // there are cleared bits that need to be synced
+        BITMAP_PAGE_DIRTY = 0,     /* there are set bits that need to be synced */
+        BITMAP_PAGE_CLEAN = 1,     /* there are bits that might need to be cleared */
+        BITMAP_PAGE_NEEDWRITE = 2, /* there are cleared bits that need to be synced */
 };
 
 static inline void set_page_attr(struct bitmap *bitmap, struct page *page,
                                 enum bitmap_page_attr attr)
 {
-        __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        if (page)
+                __set_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        else
+                __set_bit(attr, &bitmap->logattrs);
 }
 
 static inline void clear_page_attr(struct bitmap *bitmap, struct page *page,
                                 enum bitmap_page_attr attr)
 {
-        __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        if (page)
+                __clear_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        else
+                __clear_bit(attr, &bitmap->logattrs);
 }
 
 static inline unsigned long test_page_attr(struct bitmap *bitmap, struct page *page,
                                            enum bitmap_page_attr attr)
 {
-        return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        if (page)
+                return test_bit((page->index<<2) + attr, bitmap->filemap_attr);
+        else
+                return test_bit(attr, &bitmap->logattrs);
 }
 
 /*
@@ -836,30 +834,32 @@ 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;
+        struct page *page = NULL;
         void *kaddr;
         unsigned long chunk = block >> CHUNK_BLOCK_SHIFT(bitmap);
 
         if (!bitmap->filemap) {
-                return;
-        }
-
-        page = filemap_get_page(bitmap, chunk);
-        if (!page) return;
-        bit = file_page_offset(bitmap, chunk);
+                struct dm_dirty_log *log = bitmap->mddev->bitmap_info.log;
+                if (log)
+                        log->type->mark_region(log, chunk);
+        } else {
 
-        /* set the bit */
-        kaddr = kmap_atomic(page, KM_USER0);
-        if (bitmap->flags & BITMAP_HOSTENDIAN)
-                set_bit(bit, kaddr);
-        else
-                ext2_set_bit(bit, kaddr);
-        kunmap_atomic(kaddr, KM_USER0);
-        PRINTK("set file bit %lu page %lu\n", bit, page->index);
+                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
+                        ext2_set_bit(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);
-
 }
 
 /* this gets called when the md device is ready to unplug its underlying
@@ -874,6 +874,16 @@ 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 */
@@ -892,7 +902,7 @@ void bitmap_unplug(struct bitmap *bitmap)
                         wait = 1;
                 spin_unlock_irqrestore(&bitmap->lock, flags);
 
-                if (dirty | need_write)
+                if (dirty || need_write)
                         write_page(bitmap, page, 0);
         }
         if (wait) { /* if any writes were performed, we need to wait on them */
@@ -902,9 +912,11 @@ void bitmap_unplug(struct bitmap *bitmap)
                 else
                         md_super_wait(bitmap->mddev);
         }
+out:
         if (bitmap->flags & BITMAP_WRITE_ERROR)
                 bitmap_file_kick(bitmap);
 }
+EXPORT_SYMBOL(bitmap_unplug);
 
 static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed);
 /* * bitmap_init_from_disk -- called at bitmap_create time to initialize
@@ -943,12 +955,11 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                 printk(KERN_INFO "%s: bitmap file is out of date, doing full "
                         "recovery\n", bmname(bitmap));
 
-        bytes = (chunks + 7) / 8;
+        bytes = DIV_ROUND_UP(bitmap->chunks, 8);
         if (!bitmap->mddev->bitmap_info.external)
                 bytes += sizeof(bitmap_super_t);
 
-        
-        num_pages = (bytes + PAGE_SIZE - 1) / PAGE_SIZE;
+        num_pages = DIV_ROUND_UP(bytes, PAGE_SIZE);
 
         if (file && i_size_read(file->f_mapping->host) < bytes) {
                 printk(KERN_INFO "%s: bitmap file too short %lu < %lu\n",
@@ -966,7 +977,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
 
         /* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned long) */
         bitmap->filemap_attr = kzalloc(
-                roundup( DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
+                roundup(DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
                 GFP_KERNEL);
         if (!bitmap->filemap_attr)
                 goto err;
@@ -993,10 +1004,11 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                                 page = bitmap->sb_page;
                                 offset = sizeof(bitmap_super_t);
                                 if (!file)
-                                        read_sb_page(bitmap->mddev,
-                                                     bitmap->mddev->bitmap_info.offset,
-                                                     page,
-                                                     index, count);
+                                        page = read_sb_page(
+                                                bitmap->mddev,
+                                                bitmap->mddev->bitmap_info.offset,
+                                                page,
+                                                index, count);
                         } else if (file) {
                                 page = read_page(file, index, bitmap, count);
                                 offset = 0;
@@ -1021,7 +1033,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                         if (outofdate) {
                                 /*
                                  * if bitmap is out of date, dirty the
-                                 * whole page and write it out
+                                 * whole page and write it out
                                  */
                                 paddr = kmap_atomic(page, KM_USER0);
                                 memset(paddr + offset, 0xff,
@@ -1052,7 +1064,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                 }
         }
 
-        /* everything went OK */
+        /* everything went OK */
         ret = 0;
         bitmap_mask_state(bitmap, BITMAP_STALE, MASK_UNSET);
 
@@ -1080,25 +1092,20 @@ void bitmap_write_all(struct bitmap *bitmap)
          */
         int i;
 
-        for (i=0; i < bitmap->file_pages; i++)
+        for (i = 0; i < bitmap->file_pages; i++)
                 set_page_attr(bitmap, bitmap->filemap[i],
                               BITMAP_PAGE_NEEDWRITE);
 }
 
-
 static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)
 {
         sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);
         unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
         bitmap->bp[page].count += inc;
-/*
-        if (page == 0) printk("count page 0, offset %llu: %d gives %d\n",
-                              (unsigned long long)offset, inc, bitmap->bp[page].count);
-*/
         bitmap_checkfree(bitmap, page);
 }
 static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
-                                            sector_t offset, int *blocks,
+                                            sector_t offset, sector_t *blocks,
                                             int create);
 
 /*
@@ -1112,8 +1119,9 @@ void bitmap_daemon_work(mddev_t *mddev)
         unsigned long j;
         unsigned long flags;
         struct page *page = NULL, *lastpage = NULL;
-        int blocks;
+        sector_t blocks;
         void *paddr;
+        struct dm_dirty_log *log = mddev->bitmap_info.log;
 
         /* Use a mutex to guard daemon_work against
          * bitmap_destroy.
@@ -1138,11 +1146,12 @@ 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)
-                        /* error or shutdown */
-                        break;
-
-                page = filemap_get_page(bitmap, j);
+                if (!bitmap->filemap) {
+                        if (!log)
+                                /* error or shutdown */
+                                break;
+                } else
+                        page = filemap_get_page(bitmap, j);
 
                 if (page != lastpage) {
                         /* skip this page unless it's marked as needing cleaning */
@@ -1197,14 +1206,11 @@ void bitmap_daemon_work(mddev_t *mddev)
                                          (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),
                                          &blocks, 0);
                 if (bmc) {
-/*
-  if (j < 100) printk("bitmap: j=%lu, *bmc = 0x%x\n", j, *bmc);
-*/
                         if (*bmc)
                                 bitmap->allclean = 0;
 
                         if (*bmc == 2) {
-                                *bmc=1; /* maybe clear the bit next time */
+                                *bmc = 1; /* maybe clear the bit next time */
                                 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
                         } else if (*bmc == 1 && !bitmap->need_sync) {
                                 /* we can clear the bit */
@@ -1214,14 +1220,17 @@ void bitmap_daemon_work(mddev_t *mddev)
                                                   -1);
 
                                 /* clear the bit */
-                                paddr = kmap_atomic(page, KM_USER0);
-                                if (bitmap->flags & BITMAP_HOSTENDIAN)
-                                        clear_bit(file_page_offset(bitmap, j),
-                                                  paddr);
-                                else
-                                        ext2_clear_bit(file_page_offset(bitmap, j),
-                                                       paddr);
-                                kunmap_atomic(paddr, KM_USER0);
+                                if (page) {
+                                        paddr = kmap_atomic(page, KM_USER0);
+                                        if (bitmap->flags & BITMAP_HOSTENDIAN)
+                                                clear_bit(file_page_offset(bitmap, j),
+                                                          paddr);
+                                        else
+                                                ext2_clear_bit(file_page_offset(bitmap, j),
+                                                               paddr);
+                                        kunmap_atomic(paddr, KM_USER0);
+                                } else
+                                        log->type->clear_region(log, j);
                         }
                 } else
                         j |= PAGE_COUNTER_MASK;
@@ -1229,12 +1238,16 @@ void bitmap_daemon_work(mddev_t *mddev)
         spin_unlock_irqrestore(&bitmap->lock, flags);
 
         /* now sync the final page */
-        if (lastpage != NULL) {
+        if (lastpage != NULL || log != 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);
-                        write_page(bitmap, lastpage, 0);
+                        if (lastpage)
+                                write_page(bitmap, lastpage, 0);
+                        else
+                                if (log->type->flush(log))
+                                        bitmap->flags |= BITMAP_WRITE_ERROR;
                 } else {
                         set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);
                         spin_unlock_irqrestore(&bitmap->lock, flags);
@@ -1243,13 +1256,13 @@ void bitmap_daemon_work(mddev_t *mddev)
 
  done:
         if (bitmap->allclean == 0)
-                bitmap->mddev->thread->timeout = 
+                bitmap->mddev->thread->timeout =
                         bitmap->mddev->bitmap_info.daemon_sleep;
         mutex_unlock(&mddev->bitmap_info.mutex);
 }
 
 static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
-                                            sector_t offset, int *blocks,
+                                            sector_t offset, sector_t *blocks,
                                             int create)
 __releases(bitmap->lock)
 __acquires(bitmap->lock)
@@ -1262,43 +1275,52 @@ __acquires(bitmap->lock)
         unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
         unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
         sector_t csize;
+        int err;
+
+        err = bitmap_checkpage(bitmap, page, create);
 
-        if (bitmap_checkpage(bitmap, page, create) < 0) {
+        if (bitmap->bp[page].hijacked ||
+            bitmap->bp[page].map == NULL)
+                csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap) +
+                                          PAGE_COUNTER_SHIFT - 1);
+        else
                 csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));
-                *blocks = csize - (offset & (csize- 1));
+        *blocks = csize - (offset & (csize - 1));
+
+        if (err < 0)
                 return NULL;
-        }
+
         /* now locked ... */
 
         if (bitmap->bp[page].hijacked) { /* hijacked pointer */
                 /* should we use the first or second counter field
                  * of the hijacked pointer? */
                 int hi = (pageoff > PAGE_COUNTER_MASK);
-                csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap) +
-                                          PAGE_COUNTER_SHIFT - 1);
-                *blocks = csize - (offset & (csize- 1));
                 return  &((bitmap_counter_t *)
                           &bitmap->bp[page].map)[hi];
-        } else { /* page is allocated */
-                csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));
-                *blocks = csize - (offset & (csize- 1));
+        } else /* page is allocated */
                 return (bitmap_counter_t *)
                         &(bitmap->bp[page].map[pageoff]);
-        }
 }
 
 int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors, int behind)
 {
-        if (!bitmap) return 0;
+        if (!bitmap)
+                return 0;
 
         if (behind) {
+                int bw;
                 atomic_inc(&bitmap->behind_writes);
+                bw = atomic_read(&bitmap->behind_writes);
+                if (bw > bitmap->behind_writes_used)
+                        bitmap->behind_writes_used = bw;
+
                 PRINTK(KERN_DEBUG "inc write-behind count %d/%d\n",
-                  atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);
+                       bw, bitmap->max_write_behind);
         }
 
         while (sectors) {
-                int blocks;
+                sector_t blocks;
                 bitmap_counter_t *bmc;
 
                 spin_lock_irq(&bitmap->lock);
@@ -1317,17 +1339,16 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect
                         prepare_to_wait(&bitmap->overflow_wait, &__wait,
                                         TASK_UNINTERRUPTIBLE);
                         spin_unlock_irq(&bitmap->lock);
-                        blk_unplug(bitmap->mddev->queue);
+                        md_unplug(bitmap->mddev);
                         schedule();
                         finish_wait(&bitmap->overflow_wait, &__wait);
                         continue;
                 }
 
-                switch(*bmc) {
+                switch (*bmc) {
                 case 0:
                         bitmap_file_set_bit(bitmap, offset);
-                        bitmap_count_page(bitmap,offset, 1);
-                        blk_plug_device_unlocked(bitmap->mddev->queue);
+                        bitmap_count_page(bitmap, offset, 1);
                         /* fall through */
                 case 1:
                         *bmc = 2;
@@ -1340,18 +1361,22 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect
                 offset += blocks;
                 if (sectors > blocks)
                         sectors -= blocks;
-                else sectors = 0;
+                else
+                        sectors = 0;
         }
         bitmap->allclean = 0;
         return 0;
 }
+EXPORT_SYMBOL(bitmap_startwrite);
 
 void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long sectors,
                      int success, int behind)
 {
-        if (!bitmap) return;
+        if (!bitmap)
+                return;
         if (behind) {
-                atomic_dec(&bitmap->behind_writes);
+                if (atomic_dec_and_test(&bitmap->behind_writes))
+                        wake_up(&bitmap->behind_wait);
                 PRINTK(KERN_DEBUG "dec write-behind count %d/%d\n",
                   atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);
         }
@@ -1360,7 +1385,7 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto
                 success = 0;
 
         while (sectors) {
-                int blocks;
+                sector_t blocks;
                 unsigned long flags;
                 bitmap_counter_t *bmc;
 
@@ -1375,7 +1400,7 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto
                     bitmap->events_cleared < bitmap->mddev->events) {
                         bitmap->events_cleared = bitmap->mddev->events;
                         bitmap->need_sync = 1;
-                        sysfs_notify_dirent(bitmap->sysfs_can_clear);
+                        sysfs_notify_dirent_safe(bitmap->sysfs_can_clear);
                 }
 
                 if (!success && ! (*bmc & NEEDED_MASK))
@@ -1385,20 +1410,24 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto
                         wake_up(&bitmap->overflow_wait);
 
                 (*bmc)--;
-                if (*bmc <= 2) {
+                if (*bmc <= 2)
                         set_page_attr(bitmap,
-                                      filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),
+                                      filemap_get_page(
+                                              bitmap,
+                                              offset >> CHUNK_BLOCK_SHIFT(bitmap)),
                                       BITMAP_PAGE_CLEAN);
-                }
+
                 spin_unlock_irqrestore(&bitmap->lock, flags);
                 offset += blocks;
                 if (sectors > blocks)
                         sectors -= blocks;
-                else sectors = 0;
+                else
+                        sectors = 0;
         }
 }
+EXPORT_SYMBOL(bitmap_endwrite);
 
-static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
+static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
                                int degraded)
 {
         bitmap_counter_t *bmc;
@@ -1427,7 +1456,7 @@ static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *bloc
         return rv;
 }
 
-int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
+int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks,
                       int degraded)
 {
         /* bitmap_start_sync must always report on multiples of whole
@@ -1438,7 +1467,7 @@ int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
          * Return the 'or' of the result.
          */
         int rv = 0;
-        int blocks1;
+        sector_t blocks1;
 
         *blocks = 0;
         while (*blocks < (PAGE_SIZE>>9)) {
@@ -1449,14 +1478,14 @@ int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, int *blocks,
         }
         return rv;
 }
+EXPORT_SYMBOL(bitmap_start_sync);
 
-void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int aborted)
+void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted)
 {
         bitmap_counter_t *bmc;
         unsigned long flags;
-/*
-        if (offset == 0) printk("bitmap_end_sync 0 (%d)\n", aborted);
-*/      if (bitmap == NULL) {
+
+        if (bitmap == NULL) {
                 *blocks = 1024;
                 return;
         }
@@ -1465,26 +1494,23 @@ void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, int *blocks, int ab
         if (bmc == NULL)
                 goto unlock;
         /* locked */
-/*
-        if (offset == 0) printk("bitmap_end sync found 0x%x, blocks %d\n", *bmc, *blocks);
-*/
         if (RESYNC(*bmc)) {
                 *bmc &= ~RESYNC_MASK;
 
                 if (!NEEDED(*bmc) && aborted)
                         *bmc |= NEEDED_MASK;
                 else {
-                        if (*bmc <= 2) {
+                        if (*bmc <= 2)
                                 set_page_attr(bitmap,
                                               filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),
                                               BITMAP_PAGE_CLEAN);
-                        }
                 }
         }
  unlock:
         spin_unlock_irqrestore(&bitmap->lock, flags);
         bitmap->allclean = 0;
 }
+EXPORT_SYMBOL(bitmap_end_sync);
 
 void bitmap_close_sync(struct bitmap *bitmap)
 {
@@ -1493,7 +1519,7 @@ void bitmap_close_sync(struct bitmap *bitmap)
          * RESYNC bit wherever it is still on
          */
         sector_t sector = 0;
-        int blocks;
+        sector_t blocks;
         if (!bitmap)
                 return;
         while (sector < bitmap->mddev->resync_max_sectors) {
@@ -1501,11 +1527,12 @@ void bitmap_close_sync(struct bitmap *bitmap)
                 sector += blocks;
         }
 }
+EXPORT_SYMBOL(bitmap_close_sync);
 
 void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
 {
         sector_t s = 0;
-        int blocks;
+        sector_t blocks;
 
         if (!bitmap)
                 return;
@@ -1519,7 +1546,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
         wait_event(bitmap->mddev->recovery_wait,
                    atomic_read(&bitmap->mddev->recovery_active) == 0);
 
-        bitmap->mddev->curr_resync_completed = bitmap->mddev->curr_resync;
+        bitmap->mddev->curr_resync_completed = sector;
         set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);
         sector &= ~((1ULL << CHUNK_BLOCK_SHIFT(bitmap)) - 1);
         s = 0;
@@ -1530,6 +1557,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
         bitmap->last_end_sync = jiffies;
         sysfs_notify(&bitmap->mddev->kobj, NULL, "sync_completed");
 }
+EXPORT_SYMBOL(bitmap_cond_end_sync);
 
 static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int needed)
 {
@@ -1538,7 +1566,7 @@ static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int n
          * be 0 at this point
          */
 
-        int secs;
+        sector_t secs;
         bitmap_counter_t *bmc;
         spin_lock_irq(&bitmap->lock);
         bmc = bitmap_get_counter(bitmap, offset, &secs, 1);
@@ -1546,9 +1574,9 @@ static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int n
                 spin_unlock_irq(&bitmap->lock);
                 return;
         }
-        if (! *bmc) {
+        if (!*bmc) {
                 struct page *page;
-                *bmc = 1 | (needed?NEEDED_MASK:0);
+                *bmc = 1 | (needed ? NEEDED_MASK : 0);
                 bitmap_count_page(bitmap, offset, 1);
                 page = filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap));
                 set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);
@@ -1657,15 +1685,17 @@ int bitmap_create(mddev_t *mddev)
         unsigned long pages;
         struct file *file = mddev->bitmap_info.file;
         int err;
-        sector_t start;
-        struct sysfs_dirent *bm;
+        struct sysfs_dirent *bm = NULL;
 
         BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
 
-        if (!file && !mddev->bitmap_info.offset) /* bitmap disabled, nothing to do */
+        if (!file
+            && !mddev->bitmap_info.offset
+            && !mddev->bitmap_info.log) /* 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)
@@ -1675,12 +1705,14 @@ int bitmap_create(mddev_t *mddev)
         atomic_set(&bitmap->pending_writes, 0);
         init_waitqueue_head(&bitmap->write_wait);
         init_waitqueue_head(&bitmap->overflow_wait);
+        init_waitqueue_head(&bitmap->behind_wait);
 
         bitmap->mddev = mddev;
 
-        bm = sysfs_get_dirent(mddev->kobj.sd, "bitmap");
+        if (mddev->kobj.sd)
+                bm = sysfs_get_dirent(mddev->kobj.sd, NULL, "bitmap");
         if (bm) {
-                bitmap->sysfs_can_clear = sysfs_get_dirent(bm, "can_clear");
+                bitmap->sysfs_can_clear = sysfs_get_dirent(bm, NULL, "can_clear");
                 sysfs_put(bm);
         } else
                 bitmap->sysfs_can_clear = NULL;
@@ -1692,7 +1724,7 @@ int bitmap_create(mddev_t *mddev)
                  * and bypass the page cache, we must sync the file
                  * first.
                  */
-                vfs_fsync(file, file->f_dentry, 1);
+                vfs_fsync(file, 1);
         }
         /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
         if (!mddev->bitmap_info.external)
@@ -1712,9 +1744,9 @@ int bitmap_create(mddev_t *mddev)
         bitmap->chunkshift = ffz(~mddev->bitmap_info.chunksize);
 
         /* now that chunksize and chunkshift are set, we can use these macros */
-        chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
+        chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
                         CHUNK_BLOCK_SHIFT(bitmap);
-        pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
+        pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;
 
         BUG_ON(!pages);
 
@@ -1734,27 +1766,11 @@ int bitmap_create(mddev_t *mddev)
         if (!bitmap->bp)
                 goto error;
 
-        /* now that we have some pages available, initialize the in-memory
-         * bitmap from the on-disk bitmap */
-        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 (err)
-                goto error;
-
         printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",
                 pages, bmname(bitmap));
 
         mddev->bitmap = bitmap;
 
-        mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
-        md_wakeup_thread(mddev->thread);
-
-        bitmap_update_sb(bitmap);
 
         return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;
 
@@ -1763,15 +1779,69 @@ int bitmap_create(mddev_t *mddev)
         return err;
 }
 
+int bitmap_load(mddev_t *mddev)
+{
+        int err = 0;
+        sector_t sector = 0;
+        struct bitmap *bitmap = mddev->bitmap;
+
+        if (!bitmap)
+                goto out;
+
+        /* Clear out old bitmap info first:  Either there is none, or we
+         * are resuming after someone else has possibly changed things,
+         * so we should forget old cached info.
+         * All chunks should be clean, but some might need_sync.
+         */
+        while (sector < mddev->resync_max_sectors) {
+                sector_t blocks;
+                bitmap_start_sync(bitmap, sector, &blocks, 0);
+                sector += blocks;
+        }
+        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 (err)
+                goto out;
+
+        mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
+        md_wakeup_thread(mddev->thread);
+
+        bitmap_update_sb(bitmap);
+
+        if (bitmap->flags & BITMAP_WRITE_ERROR)
+                err = -EIO;
+out:
+        return err;
+}
+EXPORT_SYMBOL_GPL(bitmap_load);
+
 static ssize_t
 location_show(mddev_t *mddev, char *page)
 {
         ssize_t len;
-        if (mddev->bitmap_info.file) {
+        if (mddev->bitmap_info.file)
                 len = sprintf(page, "file");
-        } else if (mddev->bitmap_info.offset) {
+        else if (mddev->bitmap_info.offset)
                 len = sprintf(page, "%+lld", (long long)mddev->bitmap_info.offset);
-        } else
+        else
                 len = sprintf(page, "none");
         len += sprintf(page+len, "\n");
         return len;
@@ -1860,7 +1930,7 @@ timeout_show(mddev_t *mddev, char *page)
         ssize_t len;
         unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;
         unsigned long jifs = mddev->bitmap_info.daemon_sleep % HZ;
-        
+
         len = sprintf(page, "%lu", secs);
         if (jifs)
                 len += sprintf(page+len, ".%03u", jiffies_to_msecs(jifs));
@@ -2006,6 +2076,27 @@ static ssize_t can_clear_store(mddev_t *mddev, const char *buf, size_t len)
 static struct md_sysfs_entry bitmap_can_clear =
 __ATTR(can_clear, S_IRUGO|S_IWUSR, can_clear_show, can_clear_store);
 
+static ssize_t
+behind_writes_used_show(mddev_t *mddev, char *page)
+{
+        if (mddev->bitmap == NULL)
+                return sprintf(page, "0\n");
+        return sprintf(page, "%lu\n",
+                       mddev->bitmap->behind_writes_used);
+}
+
+static ssize_t
+behind_writes_used_reset(mddev_t *mddev, const char *buf, size_t len)
+{
+        if (mddev->bitmap)
+                mddev->bitmap->behind_writes_used = 0;
+        return len;
+}
+
+static struct md_sysfs_entry max_backlog_used =
+__ATTR(max_backlog_used, S_IRUGO | S_IWUSR,
+       behind_writes_used_show, behind_writes_used_reset);
+
 static struct attribute *md_bitmap_attrs[] = {
         &bitmap_location.attr,
         &bitmap_timeout.attr,
@@ -2013,6 +2104,7 @@ static struct attribute *md_bitmap_attrs[] = {
         &bitmap_chunksize.attr,
         &bitmap_metadata.attr,
         &bitmap_can_clear.attr,
+        &max_backlog_used.attr,
         NULL
 };
 struct attribute_group md_bitmap_group = {
@@ -2020,12 +2112,3 @@ struct attribute_group md_bitmap_group = {
         .attrs = md_bitmap_attrs,
 };
 
-
-/* the bitmap API -- for raid personalities */
-EXPORT_SYMBOL(bitmap_startwrite);
-EXPORT_SYMBOL(bitmap_endwrite);
-EXPORT_SYMBOL(bitmap_start_sync);
-EXPORT_SYMBOL(bitmap_end_sync);
-EXPORT_SYMBOL(bitmap_unplug);
-EXPORT_SYMBOL(bitmap_close_sync);
-EXPORT_SYMBOL(bitmap_cond_end_sync);