Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3d30701b authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://neil.brown.name/md 

* 'for-linus' of git://neil.brown.name/md: (24 commits)
  md: clean up do_md_stop
  md: fix another deadlock with removing sysfs attributes.
  md: move revalidate_disk() back outside open_mutex
  md/raid10: fix deadlock with unaligned read during resync
  md/bitmap:  separate out loading a bitmap from initialising the structures.
  md/bitmap: prepare for storing write-intent-bitmap via dm-dirty-log.
  md/bitmap: optimise scanning of empty bitmaps.
  md/bitmap: clean up plugging calls.
  md/bitmap: reduce dependence on sysfs.
  md/bitmap: white space clean up and similar.
  md/raid5: export raid5 unplugging interface.
  md/plug: optionally use plugger to unplug an array during resync/recovery.
  md/raid5: add simple plugging infrastructure.
  md/raid5: export is_congested test
  raid5: Don't set read-ahead when there is no queue
  md: add support for raising dm events.
  md: export various start/stop interfaces
  md: split out md_rdev_init
  md: be more careful setting MD_CHANGE_CLEAN
  md/raid5: ensure we create a unique name for kmem_cache when mddev has no gendisk
  ...
parents 8cbd84f2 fd8aa2c1

crypto/async_tx/Kconfig

+14 −0
Original line number Diff line number Diff line
@@ -22,6 +22,20 @@ config ASYNC_RAID6_RECOV 
	tristate

	select ASYNC_CORE

	select ASYNC_PQ

	select ASYNC_XOR



config ASYNC_RAID6_TEST

	tristate "Self test for hardware accelerated raid6 recovery"

	depends on ASYNC_RAID6_RECOV

	select ASYNC_MEMCPY

	---help---

	  This is a one-shot self test that permutes through the

	  recovery of all the possible two disk failure scenarios for a

	  N-disk array.  Recovery is performed with the asynchronous

	  raid6 recovery routines, and will optionally use an offload

	  engine if one is available.



	  If unsure, say N.



config ASYNC_TX_DISABLE_PQ_VAL_DMA

	bool

drivers/md/Kconfig

+1 −17
Original line number Diff line number Diff line
@@ -121,7 +121,7 @@ config MD_RAID10 
config MD_RAID456

	tristate "RAID-4/RAID-5/RAID-6 mode"

	depends on BLK_DEV_MD

	select MD_RAID6_PQ

	select RAID6_PQ

	select ASYNC_MEMCPY

	select ASYNC_XOR

	select ASYNC_PQ
@@ -165,22 +165,6 @@ config MULTICORE_RAID456 


	  If unsure, say N.



config MD_RAID6_PQ

	tristate



config ASYNC_RAID6_TEST

	tristate "Self test for hardware accelerated raid6 recovery"

	depends on MD_RAID6_PQ

	select ASYNC_RAID6_RECOV

	---help---

	  This is a one-shot self test that permutes through the

	  recovery of all the possible two disk failure scenarios for a

	  N-disk array.  Recovery is performed with the asynchronous

	  raid6 recovery routines, and will optionally use an offload

	  engine if one is available.



	  If unsure, say N.



config MD_MULTIPATH

	tristate "Multipath I/O support"

	depends on BLK_DEV_MD

drivers/md/Makefile

+0 −77
Original line number Diff line number Diff line
@@ -12,13 +12,6 @@ dm-log-userspace-y \ 
		+= dm-log-userspace-base.o dm-log-userspace-transfer.o

md-mod-y	+= md.o bitmap.o

raid456-y	+= raid5.o

raid6_pq-y	+= raid6algos.o raid6recov.o raid6tables.o \

		   raid6int1.o raid6int2.o raid6int4.o \

		   raid6int8.o raid6int16.o raid6int32.o \

		   raid6altivec1.o raid6altivec2.o raid6altivec4.o \

		   raid6altivec8.o \

		   raid6mmx.o raid6sse1.o raid6sse2.o

hostprogs-y	+= mktables



# Note: link order is important.  All raid personalities

# and must come before md.o, as they each initialise
@@ -29,7 +22,6 @@ obj-$(CONFIG_MD_LINEAR) += linear.o 
obj-$(CONFIG_MD_RAID0)		+= raid0.o

obj-$(CONFIG_MD_RAID1)		+= raid1.o

obj-$(CONFIG_MD_RAID10)		+= raid10.o

obj-$(CONFIG_MD_RAID6_PQ)	+= raid6_pq.o

obj-$(CONFIG_MD_RAID456)	+= raid456.o

obj-$(CONFIG_MD_MULTIPATH)	+= multipath.o

obj-$(CONFIG_MD_FAULTY)		+= faulty.o
@@ -45,75 +37,6 @@ obj-$(CONFIG_DM_MIRROR) += dm-mirror.o dm-log.o dm-region-hash.o 
obj-$(CONFIG_DM_LOG_USERSPACE)	+= dm-log-userspace.o

obj-$(CONFIG_DM_ZERO)		+= dm-zero.o



quiet_cmd_unroll = UNROLL  $@

      cmd_unroll = $(AWK) -f$(srctree)/$(src)/unroll.awk -vN=$(UNROLL) \

                   < $< > $@ || ( rm -f $@ && exit 1 )



ifeq ($(CONFIG_ALTIVEC),y)

altivec_flags := -maltivec -mabi=altivec

endif



ifeq ($(CONFIG_DM_UEVENT),y)

dm-mod-objs			+= dm-uevent.o

endif
 


targets += raid6int1.c

$(obj)/raid6int1.c:   UNROLL := 1

$(obj)/raid6int1.c:   $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



targets += raid6int2.c

$(obj)/raid6int2.c:   UNROLL := 2

$(obj)/raid6int2.c:   $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



targets += raid6int4.c

$(obj)/raid6int4.c:   UNROLL := 4

$(obj)/raid6int4.c:   $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



targets += raid6int8.c

$(obj)/raid6int8.c:   UNROLL := 8

$(obj)/raid6int8.c:   $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



targets += raid6int16.c

$(obj)/raid6int16.c:  UNROLL := 16

$(obj)/raid6int16.c:  $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



targets += raid6int32.c

$(obj)/raid6int32.c:  UNROLL := 32

$(obj)/raid6int32.c:  $(src)/raid6int.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



CFLAGS_raid6altivec1.o += $(altivec_flags)

targets += raid6altivec1.c

$(obj)/raid6altivec1.c:   UNROLL := 1

$(obj)/raid6altivec1.c:   $(src)/raid6altivec.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



CFLAGS_raid6altivec2.o += $(altivec_flags)

targets += raid6altivec2.c

$(obj)/raid6altivec2.c:   UNROLL := 2

$(obj)/raid6altivec2.c:   $(src)/raid6altivec.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



CFLAGS_raid6altivec4.o += $(altivec_flags)

targets += raid6altivec4.c

$(obj)/raid6altivec4.c:   UNROLL := 4

$(obj)/raid6altivec4.c:   $(src)/raid6altivec.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



CFLAGS_raid6altivec8.o += $(altivec_flags)

targets += raid6altivec8.c

$(obj)/raid6altivec8.c:   UNROLL := 8

$(obj)/raid6altivec8.c:   $(src)/raid6altivec.uc $(src)/unroll.awk FORCE

	$(call if_changed,unroll)



quiet_cmd_mktable = TABLE   $@

      cmd_mktable = $(obj)/mktables > $@ || ( rm -f $@ && exit 1 )



targets += raid6tables.c

$(obj)/raid6tables.c: $(obj)/mktables FORCE

	$(call if_changed,mktable)

drivers/md/bitmap.c

+279 −229
Original line number Diff line number Diff line
@@ -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)
@@ -67,7 +64,6 @@ 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 */



	memset(mappage, 0, PAGE_SIZE);

		bitmap->bp[page].map = mappage;

		bitmap->missing_pages--;

out:

	}

	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,25 +170,14 @@ 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 */



#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,11 +196,14 @@ 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);

		did_alloc = 1;

	}



	list_for_each_entry(rdev, &mddev->disks, same_set) {

		if (! test_bit(In_sync, &rdev->flags)
@@ -242,6 +221,8 @@ static struct page *read_sb_page(mddev_t *mddev, loff_t offset, 
			return page;

		}

	}

	if (did_alloc)

		put_page(page);

	return ERR_PTR(-EIO);



}
@@ -296,11 +277,13 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait) 
		 */

		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))

			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  */
@@ -364,11 +347,10 @@ static void write_page(struct bitmap *bitmap, struct page *page, int wait) 
			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 +406,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 +460,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));
@@ -664,11 +646,14 @@ static int bitmap_mask_state(struct bitmap *bitmap, enum bitmap_state bits, 
	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);

	case MASK_SET:

		sb->state |= cpu_to_le32(bits);

		break;

		case MASK_UNSET: sb->state &= cpu_to_le32(~bits);

	case MASK_UNSET:

		sb->state &= cpu_to_le32(~bits);

		break;

		default: BUG();

	default:

		BUG();

	}

	kunmap_atomic(sb, KM_USER0);

	return old;
@@ -710,12 +695,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 +753,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 +771,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 +788,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)

{

	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)

{

	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)

{

	if (page)

		return test_bit((page->index<<2) + attr, bitmap->filemap_attr);

	else

		return test_bit(attr, &bitmap->logattrs);

}



/*
@@ -836,16 +830,19 @@ 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;

	}

		struct dm_dirty_log *log = bitmap->mddev->bitmap_info.log;

		if (log)

			log->type->mark_region(log, chunk);

	} else {



		page = filemap_get_page(bitmap, chunk);

	if (!page) return;

		if (!page)

			return;

		bit = file_page_offset(bitmap, chunk);



		/* set the bit */
@@ -856,10 +853,9 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) 
			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 +870,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 +898,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 +908,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 +951,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",
@@ -1085,16 +1092,11 @@ void bitmap_write_all(struct bitmap *bitmap) 
			      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,
@@ -1114,6 +1116,7 @@ void bitmap_daemon_work(mddev_t *mddev) 
	struct page *page = NULL, *lastpage = NULL;

	int blocks;

	void *paddr;

	struct dm_dirty_log *log = mddev->bitmap_info.log;



	/* Use a mutex to guard daemon_work against

	 * bitmap_destroy.
@@ -1138,10 +1141,11 @@ void bitmap_daemon_work(mddev_t *mddev) 
	spin_lock_irqsave(&bitmap->lock, flags);

	for (j = 0; j < bitmap->chunks; j++) {

		bitmap_counter_t *bmc;

		if (!bitmap->filemap)

		if (!bitmap->filemap) {

			if (!log)

				/* error or shutdown */

				break;



		} else

			page = filemap_get_page(bitmap, j);



		if (page != lastpage) {
@@ -1197,9 +1201,6 @@ 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;
@@ -1214,6 +1215,7 @@ void bitmap_daemon_work(mddev_t *mddev) 
						  -1);



				/* clear the bit */

				if (page) {

					paddr = kmap_atomic(page, KM_USER0);

					if (bitmap->flags & BITMAP_HOSTENDIAN)

						clear_bit(file_page_offset(bitmap, j),
@@ -1222,6 +1224,8 @@ void bitmap_daemon_work(mddev_t *mddev) 
						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 +1233,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);

			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);
@@ -1262,34 +1270,38 @@ __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));



	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;
@@ -1322,7 +1334,7 @@ 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;
@@ -1332,7 +1344,6 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect 
		case 0:

			bitmap_file_set_bit(bitmap, offset);

			bitmap_count_page(bitmap, offset, 1);

			blk_plug_device_unlocked(bitmap->mddev->queue);

			/* fall through */

		case 1:

			*bmc = 2;
@@ -1345,16 +1356,19 @@ 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) {

		if (atomic_dec_and_test(&bitmap->behind_writes))

			wake_up(&bitmap->behind_wait);
@@ -1381,7 +1395,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))
@@ -1391,18 +1405,22 @@ 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,

			       int degraded)
@@ -1455,14 +1473,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)

{

	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;

	}
@@ -1471,26 +1489,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)

{
@@ -1507,6 +1522,7 @@ 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)

{
@@ -1526,6 +1542,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector) 
		   atomic_read(&bitmap->mddev->recovery_active) == 0);



	bitmap->mddev->curr_resync_completed = bitmap->mddev->curr_resync;

	if (bitmap->mddev->persistent)

		set_bit(MD_CHANGE_CLEAN, &bitmap->mddev->flags);

	sector &= ~((1ULL << CHUNK_BLOCK_SHIFT(bitmap)) - 1);

	s = 0;
@@ -1536,6 +1553,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)

{
@@ -1663,15 +1681,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)
@@ -1685,6 +1705,7 @@ int bitmap_create(mddev_t *mddev) 


	bitmap->mddev = mddev;



	if (mddev->kobj.sd)

		bm = sysfs_get_dirent(mddev->kobj.sd, NULL, "bitmap");

	if (bm) {

		bitmap->sysfs_can_clear = sysfs_get_dirent(bm, NULL, "can_clear");
@@ -1741,44 +1762,82 @@ 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;

	printk(KERN_INFO "created bitmap (%lu pages) for device %s\n",

		pages, bmname(bitmap));



	mddev->bitmap = bitmap;





	return (bitmap->flags & BITMAP_WRITE_ERROR) ? -EIO : 0;



 error:

	bitmap_free(bitmap);

	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) {

		int 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 */

			/* 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);



		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;

		goto out;



	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;



 error:

	bitmap_free(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;
@@ -2049,12 +2108,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);