* mark python sqlite DEP opt and update .cache

[t2sde.git] / package / kernel / linux / up-next-md-bitmap.patch

# --- T2-COPYRIGHT-NOTE-BEGIN ---
# T2 SDE: package/*/linux/up-next-md-bitmap.patch
# Copyright (C) 2024 The T2 SDE Project
# 
# This Copyright note is generated by scripts/Create-CopyPatch,
# more information can be found in the files COPYING and README.
# 
# This patch file is dual-licensed. It is available under the license the
# patched project is licensed under, as long as it is an OpenSource license
# as defined at http://www.opensource.org/ (e.g. BSD, X11) or under the terms
# of the GNU General Public License version 2 as used by the T2 SDE.
# --- T2-COPYRIGHT-NOTE-END ---

diff --git a/drivers/md/md-bitmap.c b/drivers/md/md-bitmap.c
index 29da10e6f703..349e8421799d 100644
--- a/drivers/md/md-bitmap.c
+++ b/drivers/md/md-bitmap.c
@@ -149,7 +149,18 @@ struct bitmap_page {
 struct bitmap {
 
        struct bitmap_counts {
-               spinlock_t lock;
+               /*
+                * Customize different types of lock structures to manage
+                * data and metadata.
+                * Split the counter table into multiple segments and assigns a
+                * dedicated lock to each segment.  The counters in the counter
+                * table, which map to neighboring stripe blocks, are interleaved
+                * across different segments.
+                * CPU threads that target different segments can acquire the locks
+                * simultaneously, resulting in better thread-level parallelism.
+                */
+               rwlock_t mlock;                         /* lock for metadata */
+       spinlock_t *bmclocks;           /* locks for bmc */
                struct bitmap_page *bp;
                /* total number of pages in the bitmap */
                unsigned long pages;
@@ -246,10 +257,12 @@ static bool bitmap_enabled(struct mddev *mddev)
  * if we find our page, we increment the page's refcount so that it stays
  * allocated while we're using it
  */
-static int md_bitmap_checkpage(struct bitmap_counts *bitmap,
-                              unsigned long page, int create, int no_hijack)
-__releases(bitmap->lock)
-__acquires(bitmap->lock)
+static int md_bitmap_checkpage(struct bitmap_counts *bitmap, unsigned long page,
+                              int create, int no_hijack, spinlock_t *bmclock)
+__releases(bmclock)
+__acquires(bmclock)
+__releases(bitmap->mlock)
+__acquires(bitmap->mlock)
 {
        unsigned char *mappage;
 
@@ -264,8 +277,10 @@ __acquires(bitmap->lock)
                return -ENOENT;
 
        /* this page has not been allocated yet */
-
-       spin_unlock_irq(&bitmap->lock);
+       if (bmclock)
+               spin_unlock_irq(bmclock); /* lock for bmc */
+       else
+               write_unlock_irq(&bitmap->mlock); /* lock for metadata */
        /* It is possible that this is being called inside a
         * prepare_to_wait/finish_wait loop from raid5c:make_request().
         * In general it is not permitted to sleep in that context as it
@@ -280,7 +295,11 @@ __acquires(bitmap->lock)
         */
        sched_annotate_sleep();
        mappage = kzalloc(PAGE_SIZE, GFP_NOIO);
-       spin_lock_irq(&bitmap->lock);
+
+       if (bmclock)
+               spin_lock_irq(bmclock);  /* lock for bmc */
+       else
+               write_lock_irq(&bitmap->mlock); /* lock for metadata */
 
        if (mappage == NULL) {
                pr_debug("md/bitmap: map page allocation failed, hijacking\n");
@@ -1456,16 +1475,35 @@ static void bitmap_write_all(struct mddev *mddev)
 static void md_bitmap_count_page(struct bitmap_counts *bitmap,
                                 sector_t offset, int inc)
 {
-       sector_t chunk = offset >> bitmap->chunkshift;
-       unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
+       /*
+        * The stripe heads are spread across different locations in the
+        * SSDs via a configurable hash function rather than mapping to a
+        * continuous SSD space.
+        * Sequential write requests are shuffled to different counter to
+        * reduce the counter preemption.
+        */
+       sector_t blockno = offset >> (PAGE_SHIFT - SECTOR_SHIFT);
+       sector_t totblocks = bitmap->chunks << (bitmap->chunkshift - (PAGE_SHIFT - SECTOR_SHIFT));
+       unsigned long bits = totblocks ? fls((totblocks - 1)) : 0;
+       unsigned long mask = ULONG_MAX << bits | ~(ULONG_MAX <<
+                                       (bits - (bitmap->chunkshift + SECTOR_SHIFT - PAGE_SHIFT)));
+       unsigned long cntid = blockno & mask;
+       unsigned long page = cntid >> PAGE_COUNTER_SHIFT;
+
        bitmap->bp[page].count += inc;
        md_bitmap_checkfree(bitmap, page);
 }
 
 static void md_bitmap_set_pending(struct bitmap_counts *bitmap, sector_t offset)
 {
-       sector_t chunk = offset >> bitmap->chunkshift;
-       unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
+       sector_t blockno = offset >> (PAGE_SHIFT - SECTOR_SHIFT);
+       sector_t totblocks = bitmap->chunks << (bitmap->chunkshift - (PAGE_SHIFT - SECTOR_SHIFT));
+       unsigned long bits = totblocks ? fls((totblocks - 1)) : 0;
+       unsigned long mask = ULONG_MAX << bits | ~(ULONG_MAX <<
+                                       (bits - (bitmap->chunkshift + SECTOR_SHIFT - PAGE_SHIFT)));
+       unsigned long cntid = blockno & mask;
+       unsigned long page = cntid >> PAGE_COUNTER_SHIFT;
+
        struct bitmap_page *bp = &bitmap->bp[page];
 
        if (!bp->pending)
@@ -1474,7 +1512,7 @@ static void md_bitmap_set_pending(struct bitmap_counts *bitmap, sector_t offset)
 
 static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap,
                                               sector_t offset, sector_t *blocks,
-                                              int create);
+                                              int create, spinlock_t *bmclock);
 
 static void mddev_set_timeout(struct mddev *mddev, unsigned long timeout,
                              bool force)
@@ -1557,7 +1595,7 @@ static void bitmap_daemon_work(struct mddev *mddev)
         * decrement and handle accordingly.
         */
        counts = &bitmap->counts;
-       spin_lock_irq(&counts->lock);
+       write_lock_irq(&counts->mlock);
        nextpage = 0;
        for (j = 0; j < counts->chunks; j++) {
                bitmap_counter_t *bmc;
@@ -1572,7 +1610,7 @@ static void bitmap_daemon_work(struct mddev *mddev)
                        counts->bp[j >> PAGE_COUNTER_SHIFT].pending = 0;
                }
 
-               bmc = md_bitmap_get_counter(counts, block, &blocks, 0);
+               bmc = md_bitmap_get_counter(counts, block, &blocks, 0, NULL);
                if (!bmc) {
                        j |= PAGE_COUNTER_MASK;
                        continue;
@@ -1588,7 +1626,7 @@ static void bitmap_daemon_work(struct mddev *mddev)
                        bitmap->allclean = 0;
                }
        }
-       spin_unlock_irq(&counts->lock);
+       write_unlock_irq(&counts->mlock);
 
        md_bitmap_wait_writes(bitmap);
        /* Now start writeout on any page in NEEDWRITE that isn't DIRTY.
@@ -1621,17 +1659,25 @@ static void bitmap_daemon_work(struct mddev *mddev)
 
 static bitmap_counter_t *md_bitmap_get_counter(struct bitmap_counts *bitmap,
                                               sector_t offset, sector_t *blocks,
-                                              int create)
-__releases(bitmap->lock)
-__acquires(bitmap->lock)
+                                              int create, spinlock_t *bmclock)
+__releases(bmclock)
+__acquires(bmclock)
+__releases(bitmap->mlock)
+__acquires(bitmap->mlock)
 {
        /* If 'create', we might release the lock and reclaim it.
         * The lock must have been taken with interrupts enabled.
         * If !create, we don't release the lock.
         */
-       sector_t chunk = offset >> bitmap->chunkshift;
-       unsigned long page = chunk >> PAGE_COUNTER_SHIFT;
-       unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
+       sector_t blockno = offset >> (PAGE_SHIFT - SECTOR_SHIFT);
+       sector_t totblocks = bitmap->chunks << (bitmap->chunkshift - (PAGE_SHIFT - SECTOR_SHIFT));
+       unsigned long bits = totblocks ? fls((totblocks - 1)) : 0;
+       unsigned long mask = ULONG_MAX << bits | ~(ULONG_MAX <<
+                                       (bits - (bitmap->chunkshift + SECTOR_SHIFT - PAGE_SHIFT)));
+       unsigned long cntid = blockno & mask;
+       unsigned long page = cntid >> PAGE_COUNTER_SHIFT;
+       unsigned long pageoff = (cntid & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;
+
        sector_t csize = ((sector_t)1) << bitmap->chunkshift;
        int err;
 
@@ -1644,7 +1690,7 @@ __acquires(bitmap->lock)
                *blocks = csize - (offset & (csize - 1));
                return NULL;
        }
-       err = md_bitmap_checkpage(bitmap, page, create, 0);
+       err = md_bitmap_checkpage(bitmap, page, create, 0, bmclock);
 
        if (bitmap->bp[page].hijacked ||
            bitmap->bp[page].map == NULL)
@@ -1669,6 +1715,28 @@ __acquires(bitmap->lock)
                        &(bitmap->bp[page].map[pageoff]);
 }
 
+/* set-association */
+static spinlock_t *md_bitmap_get_bmclock(struct bitmap_counts *bitmap, sector_t offset);
+
+static spinlock_t *md_bitmap_get_bmclock(struct bitmap_counts *bitmap, sector_t offset)
+{
+       sector_t blockno = offset >> (PAGE_SHIFT - SECTOR_SHIFT);
+       sector_t totblocks = bitmap->chunks << (bitmap->chunkshift - (PAGE_SHIFT - SECTOR_SHIFT));
+       unsigned long bitscnt = totblocks ? fls((totblocks - 1)) : 0;
+       unsigned long maskcnt = ULONG_MAX << bitscnt | ~(ULONG_MAX << (bitscnt -
+                                       (bitmap->chunkshift + SECTOR_SHIFT - PAGE_SHIFT)));
+       unsigned long cntid = blockno & maskcnt;
+
+       unsigned long totcnts = bitmap->chunks;
+       unsigned long bitslock = totcnts ? fls((totcnts - 1)) : 0;
+       unsigned long masklock = ULONG_MAX << bitslock | ~(ULONG_MAX <<
+                                       (bitslock - BITMAP_COUNTER_LOCK_RATIO_SHIFT));
+       unsigned long lockid = cntid & masklock;
+
+       spinlock_t *bmclock = &(bitmap->bmclocks[lockid]);
+       return bmclock;
+}
+
 static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
                             unsigned long sectors, bool behind)
 {
@@ -1691,11 +1759,15 @@ static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
        while (sectors) {
                sector_t blocks;
                bitmap_counter_t *bmc;
+               spinlock_t *bmclock;
 
-               spin_lock_irq(&bitmap->counts.lock);
-               bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 1);
+               bmclock = md_bitmap_get_bmclock(&bitmap->counts, offset);
+               read_lock(&bitmap->counts.mlock);
+               spin_lock_irq(bmclock);
+               bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 1, bmclock);
                if (!bmc) {
-                       spin_unlock_irq(&bitmap->counts.lock);
+                       spin_unlock_irq(bmclock);
+                       read_unlock(&bitmap->counts.mlock);
                        return 0;
                }
 
@@ -1707,7 +1779,8 @@ static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
                         */
                        prepare_to_wait(&bitmap->overflow_wait, &__wait,
                                        TASK_UNINTERRUPTIBLE);
-                       spin_unlock_irq(&bitmap->counts.lock);
+                       spin_unlock_irq(bmclock);
+                       read_unlock(&bitmap->counts.mlock);
                        schedule();
                        finish_wait(&bitmap->overflow_wait, &__wait);
                        continue;
@@ -1724,7 +1797,8 @@ static int bitmap_startwrite(struct mddev *mddev, sector_t offset,
 
                (*bmc)++;
 
-               spin_unlock_irq(&bitmap->counts.lock);
+               spin_unlock_irq(bmclock);
+               read_unlock(&bitmap->counts.mlock);
 
                offset += blocks;
                if (sectors > blocks)
@@ -1755,11 +1829,15 @@ static void bitmap_endwrite(struct mddev *mddev, sector_t offset,
                sector_t blocks;
                unsigned long flags;
                bitmap_counter_t *bmc;
+               spinlock_t *bmclock;
 
-               spin_lock_irqsave(&bitmap->counts.lock, flags);
-               bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 0);
+               bmclock = md_bitmap_get_bmclock(&bitmap->counts, offset);
+               read_lock(&bitmap->counts.mlock);
+               spin_lock_irqsave(bmclock, flags);
+               bmc = md_bitmap_get_counter(&bitmap->counts, offset, &blocks, 0, bmclock);
                if (!bmc) {
-                       spin_unlock_irqrestore(&bitmap->counts.lock, flags);
+                       spin_unlock_irqrestore(bmclock, flags);
+                       read_unlock(&bitmap->counts.mlock);
                        return;
                }
 
@@ -1781,7 +1859,8 @@ static void bitmap_endwrite(struct mddev *mddev, sector_t offset,
                        md_bitmap_set_pending(&bitmap->counts, offset);
                        bitmap->allclean = 0;
                }
-               spin_unlock_irqrestore(&bitmap->counts.lock, flags);
+               spin_unlock_irqrestore(bmclock, flags);
+               read_unlock(&bitmap->counts.mlock);
                offset += blocks;
                if (sectors > blocks)
                        sectors -= blocks;
@@ -1794,16 +1873,18 @@ static bool __bitmap_start_sync(struct bitmap *bitmap, sector_t offset,
                                sector_t *blocks, bool degraded)
 {
        bitmap_counter_t *bmc;
-       bool rv;
+       spinlock_t *bmclock;
+       bool rv = false;
 
        if (bitmap == NULL) {/* FIXME or bitmap set as 'failed' */
                *blocks = 1024;
                return true; /* always resync if no bitmap */
        }
-       spin_lock_irq(&bitmap->counts.lock);
 
-       rv = false;
-       bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0);
+       bmclock = md_bitmap_get_bmclock(&bitmap->counts, offset);
+       read_lock(&bitmap->counts.mlock);
+       spin_lock_irq(bmclock);
+       bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0, bmclock);
        if (bmc) {
                /* locked */
                if (RESYNC(*bmc)) {
@@ -1816,7 +1897,8 @@ static bool __bitmap_start_sync(struct bitmap *bitmap, sector_t offset,
                        }
                }
        }
-       spin_unlock_irq(&bitmap->counts.lock);
+       spin_unlock_irq(bmclock);
+       read_unlock(&bitmap->counts.mlock);
 
        return rv;
 }
@@ -1850,13 +1932,16 @@ static void __bitmap_end_sync(struct bitmap *bitmap, sector_t offset,
 {
        bitmap_counter_t *bmc;
        unsigned long flags;
+       spinlock_t *bmclock;
 
        if (bitmap == NULL) {
                *blocks = 1024;
                return;
        }
-       spin_lock_irqsave(&bitmap->counts.lock, flags);
-       bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0);
+       bmclock = md_bitmap_get_bmclock(&bitmap->counts, offset);
+       read_lock(&bitmap->counts.mlock);
+       spin_lock_irqsave(bmclock, flags);
+       bmc = md_bitmap_get_counter(&bitmap->counts, offset, blocks, 0, bmclock);
        if (bmc == NULL)
                goto unlock;
        /* locked */
@@ -1873,7 +1958,8 @@ static void __bitmap_end_sync(struct bitmap *bitmap, sector_t offset,
                }
        }
  unlock:
-       spin_unlock_irqrestore(&bitmap->counts.lock, flags);
+       spin_unlock_irqrestore(bmclock, flags);
+       read_unlock(&bitmap->counts.mlock);
 }
 
 static void bitmap_end_sync(struct mddev *mddev, sector_t offset,
@@ -1961,10 +2047,15 @@ static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, in
 
        sector_t secs;
        bitmap_counter_t *bmc;
-       spin_lock_irq(&bitmap->counts.lock);
-       bmc = md_bitmap_get_counter(&bitmap->counts, offset, &secs, 1);
+       spinlock_t *bmclock;
+
+       bmclock = md_bitmap_get_bmclock(&bitmap->counts, offset);
+       read_lock(&bitmap->counts.mlock);
+       spin_lock_irq(bmclock);
+       bmc = md_bitmap_get_counter(&bitmap->counts, offset, &secs, 1, bmclock);
        if (!bmc) {
-               spin_unlock_irq(&bitmap->counts.lock);
+               spin_unlock_irq(bmclock);
+               read_unlock(&bitmap->counts.mlock);
                return;
        }
        if (!*bmc) {
@@ -1975,7 +2066,8 @@ static void md_bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, in
        }
        if (needed)
                *bmc |= NEEDED_MASK;
-       spin_unlock_irq(&bitmap->counts.lock);
+       spin_unlock_irq(bmclock);
+       read_unlock(&bitmap->counts.mlock);
 }
 
 /* dirty the memory and file bits for bitmap chunks "s" to "e" */
@@ -2030,6 +2122,7 @@ static void md_bitmap_free(void *data)
        unsigned long k, pages;
        struct bitmap_page *bp;
        struct bitmap *bitmap = data;
+       spinlock_t *bmclocks;
 
        if (!bitmap) /* there was no bitmap */
                return;
@@ -2050,6 +2143,7 @@ static void md_bitmap_free(void *data)
 
        bp = bitmap->counts.bp;
        pages = bitmap->counts.pages;
+       bmclocks = bitmap->counts.bmclocks;
 
        /* free all allocated memory */
 
@@ -2058,6 +2152,7 @@ static void md_bitmap_free(void *data)
                        if (bp[k].map && !bp[k].hijacked)
                                kfree(bp[k].map);
        kfree(bp);
+       kfree(bmclocks);
        kfree(bitmap);
 }
 
@@ -2123,7 +2218,9 @@ static struct bitmap *__bitmap_create(struct mddev *mddev, int slot)
        if (!bitmap)
                return ERR_PTR(-ENOMEM);
 
-       spin_lock_init(&bitmap->counts.lock);
+       /* initialize metadata lock */
+       rwlock_init(&bitmap->counts.mlock);
+
        atomic_set(&bitmap->pending_writes, 0);
        init_waitqueue_head(&bitmap->write_wait);
        init_waitqueue_head(&bitmap->overflow_wait);
@@ -2382,6 +2479,8 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
        int ret = 0;
        long pages;
        struct bitmap_page *new_bp;
+       spinlock_t *new_bmclocks;
+       int num_bmclocks, i;
 
        if (bitmap->storage.file && !init) {
                pr_info("md: cannot resize file-based bitmap\n");
@@ -2450,7 +2549,7 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
                memcpy(page_address(store.sb_page),
                       page_address(bitmap->storage.sb_page),
                       sizeof(bitmap_super_t));
-       spin_lock_irq(&bitmap->counts.lock);
+       write_lock_irq(&bitmap->counts.mlock);
        md_bitmap_file_unmap(&bitmap->storage);
        bitmap->storage = store;
 
@@ -2466,11 +2565,23 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
        blocks = min(old_counts.chunks << old_counts.chunkshift,
                     chunks << chunkshift);
 
+       /* initialize bmc locks */
+       num_bmclocks = DIV_ROUND_UP(chunks, BITMAP_COUNTER_LOCK_RATIO);
+       num_bmclocks = min(num_bmclocks, BITMAP_COUNTER_LOCK_MAX);
+
+       new_bmclocks = kvcalloc(num_bmclocks, sizeof(*new_bmclocks), GFP_KERNEL);
+       bitmap->counts.bmclocks = new_bmclocks;
+       for (i = 0; i < num_bmclocks; ++i) {
+               spinlock_t *bmclock = &(bitmap->counts.bmclocks)[i];
+
+               spin_lock_init(bmclock);
+       }
+
        /* For cluster raid, need to pre-allocate bitmap */
        if (mddev_is_clustered(bitmap->mddev)) {
                unsigned long page;
                for (page = 0; page < pages; page++) {
-                       ret = md_bitmap_checkpage(&bitmap->counts, page, 1, 1);
+                       ret = md_bitmap_checkpage(&bitmap->counts, page, 1, 1, NULL);
                        if (ret) {
                                unsigned long k;
 
@@ -2500,11 +2611,12 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
                bitmap_counter_t *bmc_old, *bmc_new;
                int set;
 
-               bmc_old = md_bitmap_get_counter(&old_counts, block, &old_blocks, 0);
+               bmc_old = md_bitmap_get_counter(&old_counts, block, &old_blocks, 0, NULL);
                set = bmc_old && NEEDED(*bmc_old);
 
                if (set) {
-                       bmc_new = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks, 1);
+                       bmc_new = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks,
+                                                                               1, NULL);
                        if (bmc_new) {
                                if (*bmc_new == 0) {
                                        /* need to set on-disk bits too. */
@@ -2540,7 +2652,7 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
                int i;
                while (block < (chunks << chunkshift)) {
                        bitmap_counter_t *bmc;
-                       bmc = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks, 1);
+                       bmc = md_bitmap_get_counter(&bitmap->counts, block, &new_blocks, 1, NULL);
                        if (bmc) {
                                /* new space.  It needs to be resynced, so
                                 * we set NEEDED_MASK.
@@ -2556,7 +2668,7 @@ static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks,
                for (i = 0; i < bitmap->storage.file_pages; i++)
                        set_page_attr(bitmap, i, BITMAP_PAGE_DIRTY);
        }
-       spin_unlock_irq(&bitmap->counts.lock);
+       write_unlock_irq(&bitmap->counts.mlock);
 
        if (!init) {
                __bitmap_unplug(bitmap);
diff --git a/drivers/md/md-bitmap.h b/drivers/md/md-bitmap.h
index 662e6fc141a7..74dce7f5b34e 100644
--- a/drivers/md/md-bitmap.h
+++ b/drivers/md/md-bitmap.h
@@ -2,7 +2,9 @@
 /*
  * bitmap.h: Copyright (C) Peter T. Breuer (ptb@ot.uc3m.es) 2003
  *
- * additions: Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
+ * additions:
+ *             Copyright (C) 2003-2004, Paul Clements, SteelEye Technology, Inc.
+ *             Copyright (C) 2022-2023, Shushu Yi (firnyee@gmail.com)
  */
 #ifndef BITMAP_H
 #define BITMAP_H 1
@@ -13,6 +15,10 @@ typedef __u16 bitmap_counter_t;
 #define COUNTER_BITS 16
 #define COUNTER_BIT_SHIFT 4
 #define COUNTER_BYTE_SHIFT (COUNTER_BIT_SHIFT - 3)
+/* how many counters share the same bmclock? */
+#define BITMAP_COUNTER_LOCK_RATIO_SHIFT 0
+#define BITMAP_COUNTER_LOCK_RATIO (1 << BITMAP_COUNTER_LOCK_RATIO_SHIFT)
+#define BITMAP_COUNTER_LOCK_MAX 65536
 
 #define NEEDED_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 1)))
 #define RESYNC_MASK ((bitmap_counter_t) (1 << (COUNTER_BITS - 2)))