mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-09 12:04:15 +08:00
0778286a13
When the complete device is marked as out of sync, we can disable updates of the on disk AL. Currently AL updates are only disabled if one uses the "invalidate-remote" command on an unconnected, primary device, or when at attach time all bits in the bitmap are set. As of now, AL updated do not get disabled when a all bits becomes set due to application writes to an unconnected DRBD device. While this is a missing feature, it is not considered important, and might get added later. BTW, after initializing a "one legged" DRBD device drbdadm create-md resX drbdadm -- --force primary resX AL updates also get disabled, until the first connect. Signed-off-by: Philipp Reisner <philipp.reisner@linbit.com> Signed-off-by: Lars Ellenberg <lars.ellenberg@linbit.com>
1336 lines
35 KiB
C
1336 lines
35 KiB
C
/*
|
|
drbd_bitmap.c
|
|
|
|
This file is part of DRBD by Philipp Reisner and Lars Ellenberg.
|
|
|
|
Copyright (C) 2004-2008, LINBIT Information Technologies GmbH.
|
|
Copyright (C) 2004-2008, Philipp Reisner <philipp.reisner@linbit.com>.
|
|
Copyright (C) 2004-2008, Lars Ellenberg <lars.ellenberg@linbit.com>.
|
|
|
|
drbd is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
drbd is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with drbd; see the file COPYING. If not, write to
|
|
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#include <linux/bitops.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/string.h>
|
|
#include <linux/drbd.h>
|
|
#include <linux/slab.h>
|
|
#include <asm/kmap_types.h>
|
|
#include "drbd_int.h"
|
|
|
|
/* OPAQUE outside this file!
|
|
* interface defined in drbd_int.h
|
|
|
|
* convention:
|
|
* function name drbd_bm_... => used elsewhere, "public".
|
|
* function name bm_... => internal to implementation, "private".
|
|
|
|
* Note that since find_first_bit returns int, at the current granularity of
|
|
* the bitmap (4KB per byte), this implementation "only" supports up to
|
|
* 1<<(32+12) == 16 TB...
|
|
*/
|
|
|
|
/*
|
|
* NOTE
|
|
* Access to the *bm_pages is protected by bm_lock.
|
|
* It is safe to read the other members within the lock.
|
|
*
|
|
* drbd_bm_set_bits is called from bio_endio callbacks,
|
|
* We may be called with irq already disabled,
|
|
* so we need spin_lock_irqsave().
|
|
* And we need the kmap_atomic.
|
|
*/
|
|
struct drbd_bitmap {
|
|
struct page **bm_pages;
|
|
spinlock_t bm_lock;
|
|
/* WARNING unsigned long bm_*:
|
|
* 32bit number of bit offset is just enough for 512 MB bitmap.
|
|
* it will blow up if we make the bitmap bigger...
|
|
* not that it makes much sense to have a bitmap that large,
|
|
* rather change the granularity to 16k or 64k or something.
|
|
* (that implies other problems, however...)
|
|
*/
|
|
unsigned long bm_set; /* nr of set bits; THINK maybe atomic_t? */
|
|
unsigned long bm_bits;
|
|
size_t bm_words;
|
|
size_t bm_number_of_pages;
|
|
sector_t bm_dev_capacity;
|
|
struct mutex bm_change; /* serializes resize operations */
|
|
|
|
atomic_t bm_async_io;
|
|
wait_queue_head_t bm_io_wait;
|
|
|
|
unsigned long bm_flags;
|
|
|
|
/* debugging aid, in case we are still racy somewhere */
|
|
char *bm_why;
|
|
struct task_struct *bm_task;
|
|
};
|
|
|
|
/* definition of bits in bm_flags */
|
|
#define BM_LOCKED 0
|
|
#define BM_MD_IO_ERROR 1
|
|
#define BM_P_VMALLOCED 2
|
|
|
|
static int __bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
|
|
unsigned long e, int val, const enum km_type km);
|
|
|
|
static int bm_is_locked(struct drbd_bitmap *b)
|
|
{
|
|
return test_bit(BM_LOCKED, &b->bm_flags);
|
|
}
|
|
|
|
#define bm_print_lock_info(m) __bm_print_lock_info(m, __func__)
|
|
static void __bm_print_lock_info(struct drbd_conf *mdev, const char *func)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
if (!__ratelimit(&drbd_ratelimit_state))
|
|
return;
|
|
dev_err(DEV, "FIXME %s in %s, bitmap locked for '%s' by %s\n",
|
|
current == mdev->receiver.task ? "receiver" :
|
|
current == mdev->asender.task ? "asender" :
|
|
current == mdev->worker.task ? "worker" : current->comm,
|
|
func, b->bm_why ?: "?",
|
|
b->bm_task == mdev->receiver.task ? "receiver" :
|
|
b->bm_task == mdev->asender.task ? "asender" :
|
|
b->bm_task == mdev->worker.task ? "worker" : "?");
|
|
}
|
|
|
|
void drbd_bm_lock(struct drbd_conf *mdev, char *why)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
int trylock_failed;
|
|
|
|
if (!b) {
|
|
dev_err(DEV, "FIXME no bitmap in drbd_bm_lock!?\n");
|
|
return;
|
|
}
|
|
|
|
trylock_failed = !mutex_trylock(&b->bm_change);
|
|
|
|
if (trylock_failed) {
|
|
dev_warn(DEV, "%s going to '%s' but bitmap already locked for '%s' by %s\n",
|
|
current == mdev->receiver.task ? "receiver" :
|
|
current == mdev->asender.task ? "asender" :
|
|
current == mdev->worker.task ? "worker" : current->comm,
|
|
why, b->bm_why ?: "?",
|
|
b->bm_task == mdev->receiver.task ? "receiver" :
|
|
b->bm_task == mdev->asender.task ? "asender" :
|
|
b->bm_task == mdev->worker.task ? "worker" : "?");
|
|
mutex_lock(&b->bm_change);
|
|
}
|
|
if (__test_and_set_bit(BM_LOCKED, &b->bm_flags))
|
|
dev_err(DEV, "FIXME bitmap already locked in bm_lock\n");
|
|
|
|
b->bm_why = why;
|
|
b->bm_task = current;
|
|
}
|
|
|
|
void drbd_bm_unlock(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
if (!b) {
|
|
dev_err(DEV, "FIXME no bitmap in drbd_bm_unlock!?\n");
|
|
return;
|
|
}
|
|
|
|
if (!__test_and_clear_bit(BM_LOCKED, &mdev->bitmap->bm_flags))
|
|
dev_err(DEV, "FIXME bitmap not locked in bm_unlock\n");
|
|
|
|
b->bm_why = NULL;
|
|
b->bm_task = NULL;
|
|
mutex_unlock(&b->bm_change);
|
|
}
|
|
|
|
/* word offset to long pointer */
|
|
static unsigned long *__bm_map_paddr(struct drbd_bitmap *b, unsigned long offset, const enum km_type km)
|
|
{
|
|
struct page *page;
|
|
unsigned long page_nr;
|
|
|
|
/* page_nr = (word*sizeof(long)) >> PAGE_SHIFT; */
|
|
page_nr = offset >> (PAGE_SHIFT - LN2_BPL + 3);
|
|
BUG_ON(page_nr >= b->bm_number_of_pages);
|
|
page = b->bm_pages[page_nr];
|
|
|
|
return (unsigned long *) kmap_atomic(page, km);
|
|
}
|
|
|
|
static unsigned long * bm_map_paddr(struct drbd_bitmap *b, unsigned long offset)
|
|
{
|
|
return __bm_map_paddr(b, offset, KM_IRQ1);
|
|
}
|
|
|
|
static void __bm_unmap(unsigned long *p_addr, const enum km_type km)
|
|
{
|
|
kunmap_atomic(p_addr, km);
|
|
};
|
|
|
|
static void bm_unmap(unsigned long *p_addr)
|
|
{
|
|
return __bm_unmap(p_addr, KM_IRQ1);
|
|
}
|
|
|
|
/* long word offset of _bitmap_ sector */
|
|
#define S2W(s) ((s)<<(BM_EXT_SHIFT-BM_BLOCK_SHIFT-LN2_BPL))
|
|
/* word offset from start of bitmap to word number _in_page_
|
|
* modulo longs per page
|
|
#define MLPP(X) ((X) % (PAGE_SIZE/sizeof(long))
|
|
hm, well, Philipp thinks gcc might not optimze the % into & (... - 1)
|
|
so do it explicitly:
|
|
*/
|
|
#define MLPP(X) ((X) & ((PAGE_SIZE/sizeof(long))-1))
|
|
|
|
/* Long words per page */
|
|
#define LWPP (PAGE_SIZE/sizeof(long))
|
|
|
|
/*
|
|
* actually most functions herein should take a struct drbd_bitmap*, not a
|
|
* struct drbd_conf*, but for the debug macros I like to have the mdev around
|
|
* to be able to report device specific.
|
|
*/
|
|
|
|
static void bm_free_pages(struct page **pages, unsigned long number)
|
|
{
|
|
unsigned long i;
|
|
if (!pages)
|
|
return;
|
|
|
|
for (i = 0; i < number; i++) {
|
|
if (!pages[i]) {
|
|
printk(KERN_ALERT "drbd: bm_free_pages tried to free "
|
|
"a NULL pointer; i=%lu n=%lu\n",
|
|
i, number);
|
|
continue;
|
|
}
|
|
__free_page(pages[i]);
|
|
pages[i] = NULL;
|
|
}
|
|
}
|
|
|
|
static void bm_vk_free(void *ptr, int v)
|
|
{
|
|
if (v)
|
|
vfree(ptr);
|
|
else
|
|
kfree(ptr);
|
|
}
|
|
|
|
/*
|
|
* "have" and "want" are NUMBER OF PAGES.
|
|
*/
|
|
static struct page **bm_realloc_pages(struct drbd_bitmap *b, unsigned long want)
|
|
{
|
|
struct page **old_pages = b->bm_pages;
|
|
struct page **new_pages, *page;
|
|
unsigned int i, bytes, vmalloced = 0;
|
|
unsigned long have = b->bm_number_of_pages;
|
|
|
|
BUG_ON(have == 0 && old_pages != NULL);
|
|
BUG_ON(have != 0 && old_pages == NULL);
|
|
|
|
if (have == want)
|
|
return old_pages;
|
|
|
|
/* Trying kmalloc first, falling back to vmalloc.
|
|
* GFP_KERNEL is ok, as this is done when a lower level disk is
|
|
* "attached" to the drbd. Context is receiver thread or cqueue
|
|
* thread. As we have no disk yet, we are not in the IO path,
|
|
* not even the IO path of the peer. */
|
|
bytes = sizeof(struct page *)*want;
|
|
new_pages = kmalloc(bytes, GFP_KERNEL);
|
|
if (!new_pages) {
|
|
new_pages = vmalloc(bytes);
|
|
if (!new_pages)
|
|
return NULL;
|
|
vmalloced = 1;
|
|
}
|
|
|
|
memset(new_pages, 0, bytes);
|
|
if (want >= have) {
|
|
for (i = 0; i < have; i++)
|
|
new_pages[i] = old_pages[i];
|
|
for (; i < want; i++) {
|
|
page = alloc_page(GFP_HIGHUSER);
|
|
if (!page) {
|
|
bm_free_pages(new_pages + have, i - have);
|
|
bm_vk_free(new_pages, vmalloced);
|
|
return NULL;
|
|
}
|
|
new_pages[i] = page;
|
|
}
|
|
} else {
|
|
for (i = 0; i < want; i++)
|
|
new_pages[i] = old_pages[i];
|
|
/* NOT HERE, we are outside the spinlock!
|
|
bm_free_pages(old_pages + want, have - want);
|
|
*/
|
|
}
|
|
|
|
if (vmalloced)
|
|
set_bit(BM_P_VMALLOCED, &b->bm_flags);
|
|
else
|
|
clear_bit(BM_P_VMALLOCED, &b->bm_flags);
|
|
|
|
return new_pages;
|
|
}
|
|
|
|
/*
|
|
* called on driver init only. TODO call when a device is created.
|
|
* allocates the drbd_bitmap, and stores it in mdev->bitmap.
|
|
*/
|
|
int drbd_bm_init(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
WARN_ON(b != NULL);
|
|
b = kzalloc(sizeof(struct drbd_bitmap), GFP_KERNEL);
|
|
if (!b)
|
|
return -ENOMEM;
|
|
spin_lock_init(&b->bm_lock);
|
|
mutex_init(&b->bm_change);
|
|
init_waitqueue_head(&b->bm_io_wait);
|
|
|
|
mdev->bitmap = b;
|
|
|
|
return 0;
|
|
}
|
|
|
|
sector_t drbd_bm_capacity(struct drbd_conf *mdev)
|
|
{
|
|
ERR_IF(!mdev->bitmap) return 0;
|
|
return mdev->bitmap->bm_dev_capacity;
|
|
}
|
|
|
|
/* called on driver unload. TODO: call when a device is destroyed.
|
|
*/
|
|
void drbd_bm_cleanup(struct drbd_conf *mdev)
|
|
{
|
|
ERR_IF (!mdev->bitmap) return;
|
|
bm_free_pages(mdev->bitmap->bm_pages, mdev->bitmap->bm_number_of_pages);
|
|
bm_vk_free(mdev->bitmap->bm_pages, test_bit(BM_P_VMALLOCED, &mdev->bitmap->bm_flags));
|
|
kfree(mdev->bitmap);
|
|
mdev->bitmap = NULL;
|
|
}
|
|
|
|
/*
|
|
* since (b->bm_bits % BITS_PER_LONG) != 0,
|
|
* this masks out the remaining bits.
|
|
* Returns the number of bits cleared.
|
|
*/
|
|
static int bm_clear_surplus(struct drbd_bitmap *b)
|
|
{
|
|
const unsigned long mask = (1UL << (b->bm_bits & (BITS_PER_LONG-1))) - 1;
|
|
size_t w = b->bm_bits >> LN2_BPL;
|
|
int cleared = 0;
|
|
unsigned long *p_addr, *bm;
|
|
|
|
p_addr = bm_map_paddr(b, w);
|
|
bm = p_addr + MLPP(w);
|
|
if (w < b->bm_words) {
|
|
cleared = hweight_long(*bm & ~mask);
|
|
*bm &= mask;
|
|
w++; bm++;
|
|
}
|
|
|
|
if (w < b->bm_words) {
|
|
cleared += hweight_long(*bm);
|
|
*bm = 0;
|
|
}
|
|
bm_unmap(p_addr);
|
|
return cleared;
|
|
}
|
|
|
|
static void bm_set_surplus(struct drbd_bitmap *b)
|
|
{
|
|
const unsigned long mask = (1UL << (b->bm_bits & (BITS_PER_LONG-1))) - 1;
|
|
size_t w = b->bm_bits >> LN2_BPL;
|
|
unsigned long *p_addr, *bm;
|
|
|
|
p_addr = bm_map_paddr(b, w);
|
|
bm = p_addr + MLPP(w);
|
|
if (w < b->bm_words) {
|
|
*bm |= ~mask;
|
|
bm++; w++;
|
|
}
|
|
|
|
if (w < b->bm_words) {
|
|
*bm = ~(0UL);
|
|
}
|
|
bm_unmap(p_addr);
|
|
}
|
|
|
|
static unsigned long __bm_count_bits(struct drbd_bitmap *b, const int swap_endian)
|
|
{
|
|
unsigned long *p_addr, *bm, offset = 0;
|
|
unsigned long bits = 0;
|
|
unsigned long i, do_now;
|
|
|
|
while (offset < b->bm_words) {
|
|
i = do_now = min_t(size_t, b->bm_words-offset, LWPP);
|
|
p_addr = __bm_map_paddr(b, offset, KM_USER0);
|
|
bm = p_addr + MLPP(offset);
|
|
while (i--) {
|
|
#ifndef __LITTLE_ENDIAN
|
|
if (swap_endian)
|
|
*bm = lel_to_cpu(*bm);
|
|
#endif
|
|
bits += hweight_long(*bm++);
|
|
}
|
|
__bm_unmap(p_addr, KM_USER0);
|
|
offset += do_now;
|
|
cond_resched();
|
|
}
|
|
|
|
return bits;
|
|
}
|
|
|
|
static unsigned long bm_count_bits(struct drbd_bitmap *b)
|
|
{
|
|
return __bm_count_bits(b, 0);
|
|
}
|
|
|
|
static unsigned long bm_count_bits_swap_endian(struct drbd_bitmap *b)
|
|
{
|
|
return __bm_count_bits(b, 1);
|
|
}
|
|
|
|
/* offset and len in long words.*/
|
|
static void bm_memset(struct drbd_bitmap *b, size_t offset, int c, size_t len)
|
|
{
|
|
unsigned long *p_addr, *bm;
|
|
size_t do_now, end;
|
|
|
|
#define BM_SECTORS_PER_BIT (BM_BLOCK_SIZE/512)
|
|
|
|
end = offset + len;
|
|
|
|
if (end > b->bm_words) {
|
|
printk(KERN_ALERT "drbd: bm_memset end > bm_words\n");
|
|
return;
|
|
}
|
|
|
|
while (offset < end) {
|
|
do_now = min_t(size_t, ALIGN(offset + 1, LWPP), end) - offset;
|
|
p_addr = bm_map_paddr(b, offset);
|
|
bm = p_addr + MLPP(offset);
|
|
if (bm+do_now > p_addr + LWPP) {
|
|
printk(KERN_ALERT "drbd: BUG BUG BUG! p_addr:%p bm:%p do_now:%d\n",
|
|
p_addr, bm, (int)do_now);
|
|
break; /* breaks to after catch_oob_access_end() only! */
|
|
}
|
|
memset(bm, c, do_now * sizeof(long));
|
|
bm_unmap(p_addr);
|
|
offset += do_now;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* make sure the bitmap has enough room for the attached storage,
|
|
* if necessary, resize.
|
|
* called whenever we may have changed the device size.
|
|
* returns -ENOMEM if we could not allocate enough memory, 0 on success.
|
|
* In case this is actually a resize, we copy the old bitmap into the new one.
|
|
* Otherwise, the bitmap is initialized to all bits set.
|
|
*/
|
|
int drbd_bm_resize(struct drbd_conf *mdev, sector_t capacity, int set_new_bits)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long bits, words, owords, obits, *p_addr, *bm;
|
|
unsigned long want, have, onpages; /* number of pages */
|
|
struct page **npages, **opages = NULL;
|
|
int err = 0, growing;
|
|
int opages_vmalloced;
|
|
|
|
ERR_IF(!b) return -ENOMEM;
|
|
|
|
drbd_bm_lock(mdev, "resize");
|
|
|
|
dev_info(DEV, "drbd_bm_resize called with capacity == %llu\n",
|
|
(unsigned long long)capacity);
|
|
|
|
if (capacity == b->bm_dev_capacity)
|
|
goto out;
|
|
|
|
opages_vmalloced = test_bit(BM_P_VMALLOCED, &b->bm_flags);
|
|
|
|
if (capacity == 0) {
|
|
spin_lock_irq(&b->bm_lock);
|
|
opages = b->bm_pages;
|
|
onpages = b->bm_number_of_pages;
|
|
owords = b->bm_words;
|
|
b->bm_pages = NULL;
|
|
b->bm_number_of_pages =
|
|
b->bm_set =
|
|
b->bm_bits =
|
|
b->bm_words =
|
|
b->bm_dev_capacity = 0;
|
|
spin_unlock_irq(&b->bm_lock);
|
|
bm_free_pages(opages, onpages);
|
|
bm_vk_free(opages, opages_vmalloced);
|
|
goto out;
|
|
}
|
|
bits = BM_SECT_TO_BIT(ALIGN(capacity, BM_SECT_PER_BIT));
|
|
|
|
/* if we would use
|
|
words = ALIGN(bits,BITS_PER_LONG) >> LN2_BPL;
|
|
a 32bit host could present the wrong number of words
|
|
to a 64bit host.
|
|
*/
|
|
words = ALIGN(bits, 64) >> LN2_BPL;
|
|
|
|
if (get_ldev(mdev)) {
|
|
D_ASSERT((u64)bits <= (((u64)mdev->ldev->md.md_size_sect-MD_BM_OFFSET) << 12));
|
|
put_ldev(mdev);
|
|
}
|
|
|
|
/* one extra long to catch off by one errors */
|
|
want = ALIGN((words+1)*sizeof(long), PAGE_SIZE) >> PAGE_SHIFT;
|
|
have = b->bm_number_of_pages;
|
|
if (want == have) {
|
|
D_ASSERT(b->bm_pages != NULL);
|
|
npages = b->bm_pages;
|
|
} else {
|
|
if (FAULT_ACTIVE(mdev, DRBD_FAULT_BM_ALLOC))
|
|
npages = NULL;
|
|
else
|
|
npages = bm_realloc_pages(b, want);
|
|
}
|
|
|
|
if (!npages) {
|
|
err = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
opages = b->bm_pages;
|
|
owords = b->bm_words;
|
|
obits = b->bm_bits;
|
|
|
|
growing = bits > obits;
|
|
if (opages && growing && set_new_bits)
|
|
bm_set_surplus(b);
|
|
|
|
b->bm_pages = npages;
|
|
b->bm_number_of_pages = want;
|
|
b->bm_bits = bits;
|
|
b->bm_words = words;
|
|
b->bm_dev_capacity = capacity;
|
|
|
|
if (growing) {
|
|
if (set_new_bits) {
|
|
bm_memset(b, owords, 0xff, words-owords);
|
|
b->bm_set += bits - obits;
|
|
} else
|
|
bm_memset(b, owords, 0x00, words-owords);
|
|
|
|
}
|
|
|
|
if (want < have) {
|
|
/* implicit: (opages != NULL) && (opages != npages) */
|
|
bm_free_pages(opages + want, have - want);
|
|
}
|
|
|
|
p_addr = bm_map_paddr(b, words);
|
|
bm = p_addr + MLPP(words);
|
|
*bm = DRBD_MAGIC;
|
|
bm_unmap(p_addr);
|
|
|
|
(void)bm_clear_surplus(b);
|
|
|
|
spin_unlock_irq(&b->bm_lock);
|
|
if (opages != npages)
|
|
bm_vk_free(opages, opages_vmalloced);
|
|
if (!growing)
|
|
b->bm_set = bm_count_bits(b);
|
|
dev_info(DEV, "resync bitmap: bits=%lu words=%lu\n", bits, words);
|
|
|
|
out:
|
|
drbd_bm_unlock(mdev);
|
|
return err;
|
|
}
|
|
|
|
/* inherently racy:
|
|
* if not protected by other means, return value may be out of date when
|
|
* leaving this function...
|
|
* we still need to lock it, since it is important that this returns
|
|
* bm_set == 0 precisely.
|
|
*
|
|
* maybe bm_set should be atomic_t ?
|
|
*/
|
|
unsigned long _drbd_bm_total_weight(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long s;
|
|
unsigned long flags;
|
|
|
|
ERR_IF(!b) return 0;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
spin_lock_irqsave(&b->bm_lock, flags);
|
|
s = b->bm_set;
|
|
spin_unlock_irqrestore(&b->bm_lock, flags);
|
|
|
|
return s;
|
|
}
|
|
|
|
unsigned long drbd_bm_total_weight(struct drbd_conf *mdev)
|
|
{
|
|
unsigned long s;
|
|
/* if I don't have a disk, I don't know about out-of-sync status */
|
|
if (!get_ldev_if_state(mdev, D_NEGOTIATING))
|
|
return 0;
|
|
s = _drbd_bm_total_weight(mdev);
|
|
put_ldev(mdev);
|
|
return s;
|
|
}
|
|
|
|
size_t drbd_bm_words(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
ERR_IF(!b) return 0;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
return b->bm_words;
|
|
}
|
|
|
|
unsigned long drbd_bm_bits(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
ERR_IF(!b) return 0;
|
|
|
|
return b->bm_bits;
|
|
}
|
|
|
|
/* merge number words from buffer into the bitmap starting at offset.
|
|
* buffer[i] is expected to be little endian unsigned long.
|
|
* bitmap must be locked by drbd_bm_lock.
|
|
* currently only used from receive_bitmap.
|
|
*/
|
|
void drbd_bm_merge_lel(struct drbd_conf *mdev, size_t offset, size_t number,
|
|
unsigned long *buffer)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr, *bm;
|
|
unsigned long word, bits;
|
|
size_t end, do_now;
|
|
|
|
end = offset + number;
|
|
|
|
ERR_IF(!b) return;
|
|
ERR_IF(!b->bm_pages) return;
|
|
if (number == 0)
|
|
return;
|
|
WARN_ON(offset >= b->bm_words);
|
|
WARN_ON(end > b->bm_words);
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
while (offset < end) {
|
|
do_now = min_t(size_t, ALIGN(offset+1, LWPP), end) - offset;
|
|
p_addr = bm_map_paddr(b, offset);
|
|
bm = p_addr + MLPP(offset);
|
|
offset += do_now;
|
|
while (do_now--) {
|
|
bits = hweight_long(*bm);
|
|
word = *bm | lel_to_cpu(*buffer++);
|
|
*bm++ = word;
|
|
b->bm_set += hweight_long(word) - bits;
|
|
}
|
|
bm_unmap(p_addr);
|
|
}
|
|
/* with 32bit <-> 64bit cross-platform connect
|
|
* this is only correct for current usage,
|
|
* where we _know_ that we are 64 bit aligned,
|
|
* and know that this function is used in this way, too...
|
|
*/
|
|
if (end == b->bm_words)
|
|
b->bm_set -= bm_clear_surplus(b);
|
|
|
|
spin_unlock_irq(&b->bm_lock);
|
|
}
|
|
|
|
/* copy number words from the bitmap starting at offset into the buffer.
|
|
* buffer[i] will be little endian unsigned long.
|
|
*/
|
|
void drbd_bm_get_lel(struct drbd_conf *mdev, size_t offset, size_t number,
|
|
unsigned long *buffer)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr, *bm;
|
|
size_t end, do_now;
|
|
|
|
end = offset + number;
|
|
|
|
ERR_IF(!b) return;
|
|
ERR_IF(!b->bm_pages) return;
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
if ((offset >= b->bm_words) ||
|
|
(end > b->bm_words) ||
|
|
(number <= 0))
|
|
dev_err(DEV, "offset=%lu number=%lu bm_words=%lu\n",
|
|
(unsigned long) offset,
|
|
(unsigned long) number,
|
|
(unsigned long) b->bm_words);
|
|
else {
|
|
while (offset < end) {
|
|
do_now = min_t(size_t, ALIGN(offset+1, LWPP), end) - offset;
|
|
p_addr = bm_map_paddr(b, offset);
|
|
bm = p_addr + MLPP(offset);
|
|
offset += do_now;
|
|
while (do_now--)
|
|
*buffer++ = cpu_to_lel(*bm++);
|
|
bm_unmap(p_addr);
|
|
}
|
|
}
|
|
spin_unlock_irq(&b->bm_lock);
|
|
}
|
|
|
|
/* set all bits in the bitmap */
|
|
void drbd_bm_set_all(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
ERR_IF(!b) return;
|
|
ERR_IF(!b->bm_pages) return;
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
bm_memset(b, 0, 0xff, b->bm_words);
|
|
(void)bm_clear_surplus(b);
|
|
b->bm_set = b->bm_bits;
|
|
spin_unlock_irq(&b->bm_lock);
|
|
}
|
|
|
|
/* clear all bits in the bitmap */
|
|
void drbd_bm_clear_all(struct drbd_conf *mdev)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
ERR_IF(!b) return;
|
|
ERR_IF(!b->bm_pages) return;
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
bm_memset(b, 0, 0, b->bm_words);
|
|
b->bm_set = 0;
|
|
spin_unlock_irq(&b->bm_lock);
|
|
}
|
|
|
|
static void bm_async_io_complete(struct bio *bio, int error)
|
|
{
|
|
struct drbd_bitmap *b = bio->bi_private;
|
|
int uptodate = bio_flagged(bio, BIO_UPTODATE);
|
|
|
|
|
|
/* strange behavior of some lower level drivers...
|
|
* fail the request by clearing the uptodate flag,
|
|
* but do not return any error?!
|
|
* do we want to WARN() on this? */
|
|
if (!error && !uptodate)
|
|
error = -EIO;
|
|
|
|
if (error) {
|
|
/* doh. what now?
|
|
* for now, set all bits, and flag MD_IO_ERROR */
|
|
__set_bit(BM_MD_IO_ERROR, &b->bm_flags);
|
|
}
|
|
if (atomic_dec_and_test(&b->bm_async_io))
|
|
wake_up(&b->bm_io_wait);
|
|
|
|
bio_put(bio);
|
|
}
|
|
|
|
static void bm_page_io_async(struct drbd_conf *mdev, struct drbd_bitmap *b, int page_nr, int rw) __must_hold(local)
|
|
{
|
|
/* we are process context. we always get a bio */
|
|
struct bio *bio = bio_alloc(GFP_KERNEL, 1);
|
|
unsigned int len;
|
|
sector_t on_disk_sector =
|
|
mdev->ldev->md.md_offset + mdev->ldev->md.bm_offset;
|
|
on_disk_sector += ((sector_t)page_nr) << (PAGE_SHIFT-9);
|
|
|
|
/* this might happen with very small
|
|
* flexible external meta data device */
|
|
len = min_t(unsigned int, PAGE_SIZE,
|
|
(drbd_md_last_sector(mdev->ldev) - on_disk_sector + 1)<<9);
|
|
|
|
bio->bi_bdev = mdev->ldev->md_bdev;
|
|
bio->bi_sector = on_disk_sector;
|
|
bio_add_page(bio, b->bm_pages[page_nr], len, 0);
|
|
bio->bi_private = b;
|
|
bio->bi_end_io = bm_async_io_complete;
|
|
|
|
if (FAULT_ACTIVE(mdev, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD)) {
|
|
bio->bi_rw |= rw;
|
|
bio_endio(bio, -EIO);
|
|
} else {
|
|
submit_bio(rw, bio);
|
|
}
|
|
}
|
|
|
|
# if defined(__LITTLE_ENDIAN)
|
|
/* nothing to do, on disk == in memory */
|
|
# define bm_cpu_to_lel(x) ((void)0)
|
|
# else
|
|
static void bm_cpu_to_lel(struct drbd_bitmap *b)
|
|
{
|
|
/* need to cpu_to_lel all the pages ...
|
|
* this may be optimized by using
|
|
* cpu_to_lel(-1) == -1 and cpu_to_lel(0) == 0;
|
|
* the following is still not optimal, but better than nothing */
|
|
unsigned int i;
|
|
unsigned long *p_addr, *bm;
|
|
if (b->bm_set == 0) {
|
|
/* no page at all; avoid swap if all is 0 */
|
|
i = b->bm_number_of_pages;
|
|
} else if (b->bm_set == b->bm_bits) {
|
|
/* only the last page */
|
|
i = b->bm_number_of_pages - 1;
|
|
} else {
|
|
/* all pages */
|
|
i = 0;
|
|
}
|
|
for (; i < b->bm_number_of_pages; i++) {
|
|
p_addr = kmap_atomic(b->bm_pages[i], KM_USER0);
|
|
for (bm = p_addr; bm < p_addr + PAGE_SIZE/sizeof(long); bm++)
|
|
*bm = cpu_to_lel(*bm);
|
|
kunmap_atomic(p_addr, KM_USER0);
|
|
}
|
|
}
|
|
# endif
|
|
/* lel_to_cpu == cpu_to_lel */
|
|
# define bm_lel_to_cpu(x) bm_cpu_to_lel(x)
|
|
|
|
/*
|
|
* bm_rw: read/write the whole bitmap from/to its on disk location.
|
|
*/
|
|
static int bm_rw(struct drbd_conf *mdev, int rw) __must_hold(local)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
/* sector_t sector; */
|
|
int bm_words, num_pages, i;
|
|
unsigned long now;
|
|
char ppb[10];
|
|
int err = 0;
|
|
|
|
WARN_ON(!bm_is_locked(b));
|
|
|
|
/* no spinlock here, the drbd_bm_lock should be enough! */
|
|
|
|
bm_words = drbd_bm_words(mdev);
|
|
num_pages = (bm_words*sizeof(long) + PAGE_SIZE-1) >> PAGE_SHIFT;
|
|
|
|
/* on disk bitmap is little endian */
|
|
if (rw == WRITE)
|
|
bm_cpu_to_lel(b);
|
|
|
|
now = jiffies;
|
|
atomic_set(&b->bm_async_io, num_pages);
|
|
__clear_bit(BM_MD_IO_ERROR, &b->bm_flags);
|
|
|
|
/* let the layers below us try to merge these bios... */
|
|
for (i = 0; i < num_pages; i++)
|
|
bm_page_io_async(mdev, b, i, rw);
|
|
|
|
drbd_blk_run_queue(bdev_get_queue(mdev->ldev->md_bdev));
|
|
wait_event(b->bm_io_wait, atomic_read(&b->bm_async_io) == 0);
|
|
|
|
if (test_bit(BM_MD_IO_ERROR, &b->bm_flags)) {
|
|
dev_alert(DEV, "we had at least one MD IO ERROR during bitmap IO\n");
|
|
drbd_chk_io_error(mdev, 1, TRUE);
|
|
err = -EIO;
|
|
}
|
|
|
|
now = jiffies;
|
|
if (rw == WRITE) {
|
|
/* swap back endianness */
|
|
bm_lel_to_cpu(b);
|
|
/* flush bitmap to stable storage */
|
|
drbd_md_flush(mdev);
|
|
} else /* rw == READ */ {
|
|
/* just read, if necessary adjust endianness */
|
|
b->bm_set = bm_count_bits_swap_endian(b);
|
|
dev_info(DEV, "recounting of set bits took additional %lu jiffies\n",
|
|
jiffies - now);
|
|
}
|
|
now = b->bm_set;
|
|
|
|
dev_info(DEV, "%s (%lu bits) marked out-of-sync by on disk bit-map.\n",
|
|
ppsize(ppb, now << (BM_BLOCK_SHIFT-10)), now);
|
|
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* drbd_bm_read() - Read the whole bitmap from its on disk location.
|
|
* @mdev: DRBD device.
|
|
*/
|
|
int drbd_bm_read(struct drbd_conf *mdev) __must_hold(local)
|
|
{
|
|
return bm_rw(mdev, READ);
|
|
}
|
|
|
|
/**
|
|
* drbd_bm_write() - Write the whole bitmap to its on disk location.
|
|
* @mdev: DRBD device.
|
|
*/
|
|
int drbd_bm_write(struct drbd_conf *mdev) __must_hold(local)
|
|
{
|
|
return bm_rw(mdev, WRITE);
|
|
}
|
|
|
|
/**
|
|
* drbd_bm_write_sect: Writes a 512 (MD_SECTOR_SIZE) byte piece of the bitmap
|
|
* @mdev: DRBD device.
|
|
* @enr: Extent number in the resync lru (happens to be sector offset)
|
|
*
|
|
* The BM_EXT_SIZE is on purpose exactly the amount of the bitmap covered
|
|
* by a single sector write. Therefore enr == sector offset from the
|
|
* start of the bitmap.
|
|
*/
|
|
int drbd_bm_write_sect(struct drbd_conf *mdev, unsigned long enr) __must_hold(local)
|
|
{
|
|
sector_t on_disk_sector = enr + mdev->ldev->md.md_offset
|
|
+ mdev->ldev->md.bm_offset;
|
|
int bm_words, num_words, offset;
|
|
int err = 0;
|
|
|
|
mutex_lock(&mdev->md_io_mutex);
|
|
bm_words = drbd_bm_words(mdev);
|
|
offset = S2W(enr); /* word offset into bitmap */
|
|
num_words = min(S2W(1), bm_words - offset);
|
|
if (num_words < S2W(1))
|
|
memset(page_address(mdev->md_io_page), 0, MD_SECTOR_SIZE);
|
|
drbd_bm_get_lel(mdev, offset, num_words,
|
|
page_address(mdev->md_io_page));
|
|
if (!drbd_md_sync_page_io(mdev, mdev->ldev, on_disk_sector, WRITE)) {
|
|
int i;
|
|
err = -EIO;
|
|
dev_err(DEV, "IO ERROR writing bitmap sector %lu "
|
|
"(meta-disk sector %llus)\n",
|
|
enr, (unsigned long long)on_disk_sector);
|
|
drbd_chk_io_error(mdev, 1, TRUE);
|
|
for (i = 0; i < AL_EXT_PER_BM_SECT; i++)
|
|
drbd_bm_ALe_set_all(mdev, enr*AL_EXT_PER_BM_SECT+i);
|
|
}
|
|
mdev->bm_writ_cnt++;
|
|
mutex_unlock(&mdev->md_io_mutex);
|
|
return err;
|
|
}
|
|
|
|
/* NOTE
|
|
* find_first_bit returns int, we return unsigned long.
|
|
* should not make much difference anyways, but ...
|
|
*
|
|
* this returns a bit number, NOT a sector!
|
|
*/
|
|
#define BPP_MASK ((1UL << (PAGE_SHIFT+3)) - 1)
|
|
static unsigned long __bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo,
|
|
const int find_zero_bit, const enum km_type km)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long i = -1UL;
|
|
unsigned long *p_addr;
|
|
unsigned long bit_offset; /* bit offset of the mapped page. */
|
|
|
|
if (bm_fo > b->bm_bits) {
|
|
dev_err(DEV, "bm_fo=%lu bm_bits=%lu\n", bm_fo, b->bm_bits);
|
|
} else {
|
|
while (bm_fo < b->bm_bits) {
|
|
unsigned long offset;
|
|
bit_offset = bm_fo & ~BPP_MASK; /* bit offset of the page */
|
|
offset = bit_offset >> LN2_BPL; /* word offset of the page */
|
|
p_addr = __bm_map_paddr(b, offset, km);
|
|
|
|
if (find_zero_bit)
|
|
i = find_next_zero_bit(p_addr, PAGE_SIZE*8, bm_fo & BPP_MASK);
|
|
else
|
|
i = find_next_bit(p_addr, PAGE_SIZE*8, bm_fo & BPP_MASK);
|
|
|
|
__bm_unmap(p_addr, km);
|
|
if (i < PAGE_SIZE*8) {
|
|
i = bit_offset + i;
|
|
if (i >= b->bm_bits)
|
|
break;
|
|
goto found;
|
|
}
|
|
bm_fo = bit_offset + PAGE_SIZE*8;
|
|
}
|
|
i = -1UL;
|
|
}
|
|
found:
|
|
return i;
|
|
}
|
|
|
|
static unsigned long bm_find_next(struct drbd_conf *mdev,
|
|
unsigned long bm_fo, const int find_zero_bit)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long i = -1UL;
|
|
|
|
ERR_IF(!b) return i;
|
|
ERR_IF(!b->bm_pages) return i;
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
|
|
i = __bm_find_next(mdev, bm_fo, find_zero_bit, KM_IRQ1);
|
|
|
|
spin_unlock_irq(&b->bm_lock);
|
|
return i;
|
|
}
|
|
|
|
unsigned long drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo)
|
|
{
|
|
return bm_find_next(mdev, bm_fo, 0);
|
|
}
|
|
|
|
#if 0
|
|
/* not yet needed for anything. */
|
|
unsigned long drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo)
|
|
{
|
|
return bm_find_next(mdev, bm_fo, 1);
|
|
}
|
|
#endif
|
|
|
|
/* does not spin_lock_irqsave.
|
|
* you must take drbd_bm_lock() first */
|
|
unsigned long _drbd_bm_find_next(struct drbd_conf *mdev, unsigned long bm_fo)
|
|
{
|
|
/* WARN_ON(!bm_is_locked(mdev)); */
|
|
return __bm_find_next(mdev, bm_fo, 0, KM_USER1);
|
|
}
|
|
|
|
unsigned long _drbd_bm_find_next_zero(struct drbd_conf *mdev, unsigned long bm_fo)
|
|
{
|
|
/* WARN_ON(!bm_is_locked(mdev)); */
|
|
return __bm_find_next(mdev, bm_fo, 1, KM_USER1);
|
|
}
|
|
|
|
/* returns number of bits actually changed.
|
|
* for val != 0, we change 0 -> 1, return code positive
|
|
* for val == 0, we change 1 -> 0, return code negative
|
|
* wants bitnr, not sector.
|
|
* expected to be called for only a few bits (e - s about BITS_PER_LONG).
|
|
* Must hold bitmap lock already. */
|
|
static int __bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
|
|
unsigned long e, int val, const enum km_type km)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr = NULL;
|
|
unsigned long bitnr;
|
|
unsigned long last_page_nr = -1UL;
|
|
int c = 0;
|
|
|
|
if (e >= b->bm_bits) {
|
|
dev_err(DEV, "ASSERT FAILED: bit_s=%lu bit_e=%lu bm_bits=%lu\n",
|
|
s, e, b->bm_bits);
|
|
e = b->bm_bits ? b->bm_bits -1 : 0;
|
|
}
|
|
for (bitnr = s; bitnr <= e; bitnr++) {
|
|
unsigned long offset = bitnr>>LN2_BPL;
|
|
unsigned long page_nr = offset >> (PAGE_SHIFT - LN2_BPL + 3);
|
|
if (page_nr != last_page_nr) {
|
|
if (p_addr)
|
|
__bm_unmap(p_addr, km);
|
|
p_addr = __bm_map_paddr(b, offset, km);
|
|
last_page_nr = page_nr;
|
|
}
|
|
if (val)
|
|
c += (0 == __test_and_set_bit(bitnr & BPP_MASK, p_addr));
|
|
else
|
|
c -= (0 != __test_and_clear_bit(bitnr & BPP_MASK, p_addr));
|
|
}
|
|
if (p_addr)
|
|
__bm_unmap(p_addr, km);
|
|
b->bm_set += c;
|
|
return c;
|
|
}
|
|
|
|
/* returns number of bits actually changed.
|
|
* for val != 0, we change 0 -> 1, return code positive
|
|
* for val == 0, we change 1 -> 0, return code negative
|
|
* wants bitnr, not sector */
|
|
static int bm_change_bits_to(struct drbd_conf *mdev, const unsigned long s,
|
|
const unsigned long e, int val)
|
|
{
|
|
unsigned long flags;
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
int c = 0;
|
|
|
|
ERR_IF(!b) return 1;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
spin_lock_irqsave(&b->bm_lock, flags);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
|
|
c = __bm_change_bits_to(mdev, s, e, val, KM_IRQ1);
|
|
|
|
spin_unlock_irqrestore(&b->bm_lock, flags);
|
|
return c;
|
|
}
|
|
|
|
/* returns number of bits changed 0 -> 1 */
|
|
int drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
|
|
{
|
|
return bm_change_bits_to(mdev, s, e, 1);
|
|
}
|
|
|
|
/* returns number of bits changed 1 -> 0 */
|
|
int drbd_bm_clear_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
|
|
{
|
|
return -bm_change_bits_to(mdev, s, e, 0);
|
|
}
|
|
|
|
/* sets all bits in full words,
|
|
* from first_word up to, but not including, last_word */
|
|
static inline void bm_set_full_words_within_one_page(struct drbd_bitmap *b,
|
|
int page_nr, int first_word, int last_word)
|
|
{
|
|
int i;
|
|
int bits;
|
|
unsigned long *paddr = kmap_atomic(b->bm_pages[page_nr], KM_USER0);
|
|
for (i = first_word; i < last_word; i++) {
|
|
bits = hweight_long(paddr[i]);
|
|
paddr[i] = ~0UL;
|
|
b->bm_set += BITS_PER_LONG - bits;
|
|
}
|
|
kunmap_atomic(paddr, KM_USER0);
|
|
}
|
|
|
|
/* Same thing as drbd_bm_set_bits, but without taking the spin_lock_irqsave.
|
|
* You must first drbd_bm_lock().
|
|
* Can be called to set the whole bitmap in one go.
|
|
* Sets bits from s to e _inclusive_. */
|
|
void _drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
|
|
{
|
|
/* First set_bit from the first bit (s)
|
|
* up to the next long boundary (sl),
|
|
* then assign full words up to the last long boundary (el),
|
|
* then set_bit up to and including the last bit (e).
|
|
*
|
|
* Do not use memset, because we must account for changes,
|
|
* so we need to loop over the words with hweight() anyways.
|
|
*/
|
|
unsigned long sl = ALIGN(s,BITS_PER_LONG);
|
|
unsigned long el = (e+1) & ~((unsigned long)BITS_PER_LONG-1);
|
|
int first_page;
|
|
int last_page;
|
|
int page_nr;
|
|
int first_word;
|
|
int last_word;
|
|
|
|
if (e - s <= 3*BITS_PER_LONG) {
|
|
/* don't bother; el and sl may even be wrong. */
|
|
__bm_change_bits_to(mdev, s, e, 1, KM_USER0);
|
|
return;
|
|
}
|
|
|
|
/* difference is large enough that we can trust sl and el */
|
|
|
|
/* bits filling the current long */
|
|
if (sl)
|
|
__bm_change_bits_to(mdev, s, sl-1, 1, KM_USER0);
|
|
|
|
first_page = sl >> (3 + PAGE_SHIFT);
|
|
last_page = el >> (3 + PAGE_SHIFT);
|
|
|
|
/* MLPP: modulo longs per page */
|
|
/* LWPP: long words per page */
|
|
first_word = MLPP(sl >> LN2_BPL);
|
|
last_word = LWPP;
|
|
|
|
/* first and full pages, unless first page == last page */
|
|
for (page_nr = first_page; page_nr < last_page; page_nr++) {
|
|
bm_set_full_words_within_one_page(mdev->bitmap, page_nr, first_word, last_word);
|
|
cond_resched();
|
|
first_word = 0;
|
|
}
|
|
|
|
/* last page (respectively only page, for first page == last page) */
|
|
last_word = MLPP(el >> LN2_BPL);
|
|
bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
|
|
|
|
/* possibly trailing bits.
|
|
* example: (e & 63) == 63, el will be e+1.
|
|
* if that even was the very last bit,
|
|
* it would trigger an assert in __bm_change_bits_to()
|
|
*/
|
|
if (el <= e)
|
|
__bm_change_bits_to(mdev, el, e, 1, KM_USER0);
|
|
}
|
|
|
|
/* returns bit state
|
|
* wants bitnr, NOT sector.
|
|
* inherently racy... area needs to be locked by means of {al,rs}_lru
|
|
* 1 ... bit set
|
|
* 0 ... bit not set
|
|
* -1 ... first out of bounds access, stop testing for bits!
|
|
*/
|
|
int drbd_bm_test_bit(struct drbd_conf *mdev, const unsigned long bitnr)
|
|
{
|
|
unsigned long flags;
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr;
|
|
int i;
|
|
|
|
ERR_IF(!b) return 0;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
spin_lock_irqsave(&b->bm_lock, flags);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
if (bitnr < b->bm_bits) {
|
|
unsigned long offset = bitnr>>LN2_BPL;
|
|
p_addr = bm_map_paddr(b, offset);
|
|
i = test_bit(bitnr & BPP_MASK, p_addr) ? 1 : 0;
|
|
bm_unmap(p_addr);
|
|
} else if (bitnr == b->bm_bits) {
|
|
i = -1;
|
|
} else { /* (bitnr > b->bm_bits) */
|
|
dev_err(DEV, "bitnr=%lu > bm_bits=%lu\n", bitnr, b->bm_bits);
|
|
i = 0;
|
|
}
|
|
|
|
spin_unlock_irqrestore(&b->bm_lock, flags);
|
|
return i;
|
|
}
|
|
|
|
/* returns number of bits set in the range [s, e] */
|
|
int drbd_bm_count_bits(struct drbd_conf *mdev, const unsigned long s, const unsigned long e)
|
|
{
|
|
unsigned long flags;
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr = NULL, page_nr = -1;
|
|
unsigned long bitnr;
|
|
int c = 0;
|
|
size_t w;
|
|
|
|
/* If this is called without a bitmap, that is a bug. But just to be
|
|
* robust in case we screwed up elsewhere, in that case pretend there
|
|
* was one dirty bit in the requested area, so we won't try to do a
|
|
* local read there (no bitmap probably implies no disk) */
|
|
ERR_IF(!b) return 1;
|
|
ERR_IF(!b->bm_pages) return 1;
|
|
|
|
spin_lock_irqsave(&b->bm_lock, flags);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
for (bitnr = s; bitnr <= e; bitnr++) {
|
|
w = bitnr >> LN2_BPL;
|
|
if (page_nr != w >> (PAGE_SHIFT - LN2_BPL + 3)) {
|
|
page_nr = w >> (PAGE_SHIFT - LN2_BPL + 3);
|
|
if (p_addr)
|
|
bm_unmap(p_addr);
|
|
p_addr = bm_map_paddr(b, w);
|
|
}
|
|
ERR_IF (bitnr >= b->bm_bits) {
|
|
dev_err(DEV, "bitnr=%lu bm_bits=%lu\n", bitnr, b->bm_bits);
|
|
} else {
|
|
c += (0 != test_bit(bitnr - (page_nr << (PAGE_SHIFT+3)), p_addr));
|
|
}
|
|
}
|
|
if (p_addr)
|
|
bm_unmap(p_addr);
|
|
spin_unlock_irqrestore(&b->bm_lock, flags);
|
|
return c;
|
|
}
|
|
|
|
|
|
/* inherently racy...
|
|
* return value may be already out-of-date when this function returns.
|
|
* but the general usage is that this is only use during a cstate when bits are
|
|
* only cleared, not set, and typically only care for the case when the return
|
|
* value is zero, or we already "locked" this "bitmap extent" by other means.
|
|
*
|
|
* enr is bm-extent number, since we chose to name one sector (512 bytes)
|
|
* worth of the bitmap a "bitmap extent".
|
|
*
|
|
* TODO
|
|
* I think since we use it like a reference count, we should use the real
|
|
* reference count of some bitmap extent element from some lru instead...
|
|
*
|
|
*/
|
|
int drbd_bm_e_weight(struct drbd_conf *mdev, unsigned long enr)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
int count, s, e;
|
|
unsigned long flags;
|
|
unsigned long *p_addr, *bm;
|
|
|
|
ERR_IF(!b) return 0;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
spin_lock_irqsave(&b->bm_lock, flags);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
|
|
s = S2W(enr);
|
|
e = min((size_t)S2W(enr+1), b->bm_words);
|
|
count = 0;
|
|
if (s < b->bm_words) {
|
|
int n = e-s;
|
|
p_addr = bm_map_paddr(b, s);
|
|
bm = p_addr + MLPP(s);
|
|
while (n--)
|
|
count += hweight_long(*bm++);
|
|
bm_unmap(p_addr);
|
|
} else {
|
|
dev_err(DEV, "start offset (%d) too large in drbd_bm_e_weight\n", s);
|
|
}
|
|
spin_unlock_irqrestore(&b->bm_lock, flags);
|
|
return count;
|
|
}
|
|
|
|
/* set all bits covered by the AL-extent al_enr */
|
|
unsigned long drbd_bm_ALe_set_all(struct drbd_conf *mdev, unsigned long al_enr)
|
|
{
|
|
struct drbd_bitmap *b = mdev->bitmap;
|
|
unsigned long *p_addr, *bm;
|
|
unsigned long weight;
|
|
int count, s, e, i, do_now;
|
|
ERR_IF(!b) return 0;
|
|
ERR_IF(!b->bm_pages) return 0;
|
|
|
|
spin_lock_irq(&b->bm_lock);
|
|
if (bm_is_locked(b))
|
|
bm_print_lock_info(mdev);
|
|
weight = b->bm_set;
|
|
|
|
s = al_enr * BM_WORDS_PER_AL_EXT;
|
|
e = min_t(size_t, s + BM_WORDS_PER_AL_EXT, b->bm_words);
|
|
/* assert that s and e are on the same page */
|
|
D_ASSERT((e-1) >> (PAGE_SHIFT - LN2_BPL + 3)
|
|
== s >> (PAGE_SHIFT - LN2_BPL + 3));
|
|
count = 0;
|
|
if (s < b->bm_words) {
|
|
i = do_now = e-s;
|
|
p_addr = bm_map_paddr(b, s);
|
|
bm = p_addr + MLPP(s);
|
|
while (i--) {
|
|
count += hweight_long(*bm);
|
|
*bm = -1UL;
|
|
bm++;
|
|
}
|
|
bm_unmap(p_addr);
|
|
b->bm_set += do_now*BITS_PER_LONG - count;
|
|
if (e == b->bm_words)
|
|
b->bm_set -= bm_clear_surplus(b);
|
|
} else {
|
|
dev_err(DEV, "start offset (%d) too large in drbd_bm_ALe_set_all\n", s);
|
|
}
|
|
weight = b->bm_set - weight;
|
|
spin_unlock_irq(&b->bm_lock);
|
|
return weight;
|
|
}
|