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

Commit c3ae1f33 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: (34 commits)
  md: Fix some bugs in recovery_disabled handling.
  md/raid5: fix bug that could result in reads from a failed device.
  lib/raid6: Fix filename emitted in generated code
  md.c: trivial comment fix
  MD: Allow restarting an interrupted incremental recovery.
  md: clear In_sync bit on devices added to an active array.
  md: add proper write-congestion reporting to RAID1 and RAID10.
  md: rename "mdk_personality" to "md_personality"
  md/bitmap remove fault injection options.
  md/raid5: typedef removal: raid5_conf_t -> struct r5conf
  md/raid1: typedef removal: conf_t -> struct r1conf
  md/raid10: typedef removal: conf_t -> struct r10conf
  md/raid0: typedef removal: raid0_conf_t -> struct r0conf
  md/multipath: typedef removal: multipath_conf_t -> struct mpconf
  md/linear: typedef removal: linear_conf_t -> struct linear_conf
  md/faulty: remove typedef: conf_t -> struct faulty_conf
  md/linear: remove typedefs: dev_info_t -> struct dev_info
  md: remove typedefs: mirror_info_t -> struct mirror_info
  md: remove typedefs: r10bio_t -> struct r10bio and r1bio_t -> struct r1bio
  md: remove typedefs: mdk_thread_t -> struct md_thread
  ...
parents c28cfd60 d890fa2b

drivers/md/bitmap.c

+77 −111
Original line number Diff line number Diff line
@@ -29,35 +29,6 @@ 
#include "md.h"

#include "bitmap.h"



/* debug macros */



#define DEBUG 0



#if DEBUG

/* these are for debugging purposes only! */



/* define one and only one of these */

#define INJECT_FAULTS_1 0 /* cause bitmap_alloc_page to fail always */

#define INJECT_FAULTS_2 0 /* cause bitmap file to be kicked when first bit set*/

#define INJECT_FAULTS_3 0 /* treat bitmap file as kicked at init time */

#define INJECT_FAULTS_4 0 /* undef */

#define INJECT_FAULTS_5 0 /* undef */

#define INJECT_FAULTS_6 0



/* if these are defined, the driver will fail! debug only */

#define INJECT_FATAL_FAULT_1 0 /* fail kmalloc, causing bitmap_create to fail */

#define INJECT_FATAL_FAULT_2 0 /* undef */

#define INJECT_FATAL_FAULT_3 0 /* undef */

#endif



#ifndef PRINTK

#  if DEBUG > 0

#    define PRINTK(x...) printk(KERN_DEBUG x)

#  else

#    define PRINTK(x...)

#  endif

#endif



static inline char *bmname(struct bitmap *bitmap)

{

	return bitmap->mddev ? mdname(bitmap->mddev) : "mdX";
@@ -70,15 +41,11 @@ static unsigned char *bitmap_alloc_page(struct bitmap *bitmap) 
{

	unsigned char *page;



#ifdef INJECT_FAULTS_1

	page = NULL;

#else

	page = kzalloc(PAGE_SIZE, GFP_NOIO);

#endif

	if (!page)

		printk("%s: bitmap_alloc_page FAILED\n", bmname(bitmap));

	else

		PRINTK("%s: bitmap_alloc_page: allocated page at %p\n",

		pr_debug("%s: bitmap_alloc_page: allocated page at %p\n",

			 bmname(bitmap), page);

	return page;

}
@@ -88,7 +55,7 @@ static unsigned char *bitmap_alloc_page(struct bitmap *bitmap) 
 */

static void bitmap_free_page(struct bitmap *bitmap, unsigned char *page)

{

	PRINTK("%s: bitmap_free_page: free page %p\n", bmname(bitmap), page);

	pr_debug("%s: bitmap_free_page: free page %p\n", bmname(bitmap), page);

	kfree(page);

}
@@ -133,7 +100,7 @@ __acquires(bitmap->lock) 
	spin_lock_irq(&bitmap->lock);



	if (mappage == NULL) {

		PRINTK("%s: bitmap map page allocation failed, hijacking\n",

		pr_debug("%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 */
@@ -187,13 +154,13 @@ static void bitmap_checkfree(struct bitmap *bitmap, unsigned long page) 
 */



/* IO operations when bitmap is stored near all superblocks */

static struct page *read_sb_page(mddev_t *mddev, loff_t offset,

static struct page *read_sb_page(struct mddev *mddev, loff_t offset,

				 struct page *page,

				 unsigned long index, int size)

{

	/* choose a good rdev and read the page from there */



	mdk_rdev_t *rdev;

	struct md_rdev *rdev;

	sector_t target;

	int did_alloc = 0;
@@ -226,7 +193,7 @@ static struct page *read_sb_page(mddev_t *mddev, loff_t offset, 


}



static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev)

static struct md_rdev *next_active_rdev(struct md_rdev *rdev, struct mddev *mddev)

{

	/* Iterate the disks of an mddev, using rcu to protect access to the

	 * linked list, and raising the refcount of devices we return to ensure
@@ -247,7 +214,7 @@ static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 
		pos = &rdev->same_set;

	}

	list_for_each_continue_rcu(pos, &mddev->disks) {

		rdev = list_entry(pos, mdk_rdev_t, same_set);

		rdev = list_entry(pos, struct md_rdev, same_set);

		if (rdev->raid_disk >= 0 &&

		    !test_bit(Faulty, &rdev->flags)) {

			/* this is a usable devices */
@@ -262,9 +229,9 @@ static mdk_rdev_t *next_active_rdev(mdk_rdev_t *rdev, mddev_t *mddev) 


static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)

{

	mdk_rdev_t *rdev = NULL;

	struct md_rdev *rdev = NULL;

	struct block_device *bdev;

	mddev_t *mddev = bitmap->mddev;

	struct mddev *mddev = bitmap->mddev;



	while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {

		int size = PAGE_SIZE;
@@ -409,7 +376,7 @@ static struct page *read_page(struct file *file, unsigned long index, 
	struct buffer_head *bh;

	sector_t block;



	PRINTK("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,

	pr_debug("read bitmap file (%dB @ %llu)\n", (int)PAGE_SIZE,

		 (unsigned long long)index << PAGE_SHIFT);



	page = alloc_page(GFP_KERNEL);
@@ -868,7 +835,8 @@ 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_PENDING = 1,   /* there are bits that are being cleaned.

				    * i.e. counter is 1 or 2. */

	BITMAP_PAGE_NEEDWRITE = 2, /* there are cleared bits that need to be synced */

};
@@ -919,7 +887,7 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) 
	else

		__set_bit_le(bit, kaddr);

	kunmap_atomic(kaddr, KM_USER0);

	PRINTK("set file bit %lu page %lu\n", bit, page->index);

	pr_debug("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);

}
@@ -997,11 +965,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 


	BUG_ON(!file && !bitmap->mddev->bitmap_info.offset);



#ifdef INJECT_FAULTS_3

	outofdate = 1;

#else

	outofdate = bitmap->flags & BITMAP_STALE;

#endif

	if (outofdate)

		printk(KERN_INFO "%s: bitmap file is out of date, doing full "

			"recovery\n", bmname(bitmap));
@@ -1111,7 +1075,6 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
					       (sector_t)i << CHUNK_BLOCK_SHIFT(bitmap),

					       needed);

			bit_cnt++;

			set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);

		}

	}
@@ -1146,6 +1109,7 @@ void bitmap_write_all(struct bitmap *bitmap) 
	for (i = 0; i < bitmap->file_pages; i++)

		set_page_attr(bitmap, bitmap->filemap[i],

			      BITMAP_PAGE_NEEDWRITE);

	bitmap->allclean = 0;

}



static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)
@@ -1164,7 +1128,7 @@ static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap, 
 *			out to disk

 */



void bitmap_daemon_work(mddev_t *mddev)

void bitmap_daemon_work(struct mddev *mddev)

{

	struct bitmap *bitmap;

	unsigned long j;
@@ -1204,17 +1168,15 @@ void bitmap_daemon_work(mddev_t *mddev) 


		if (page != lastpage) {

			/* skip this page unless it's marked as needing cleaning */

			if (!test_page_attr(bitmap, page, BITMAP_PAGE_CLEAN)) {

			if (!test_page_attr(bitmap, page, BITMAP_PAGE_PENDING)) {

				int need_write = test_page_attr(bitmap, page,

								BITMAP_PAGE_NEEDWRITE);

				if (need_write)

					clear_page_attr(bitmap, page, BITMAP_PAGE_NEEDWRITE);



				spin_unlock_irqrestore(&bitmap->lock, flags);

				if (need_write) {

				if (need_write)

					write_page(bitmap, page, 0);

					bitmap->allclean = 0;

				}

				spin_lock_irqsave(&bitmap->lock, flags);

				j |= (PAGE_BITS - 1);

				continue;
@@ -1222,12 +1184,16 @@ void bitmap_daemon_work(mddev_t *mddev) 


			/* grab the new page, sync and release the old */

			if (lastpage != NULL) {

				if (test_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE)) {

					clear_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);

				if (test_page_attr(bitmap, lastpage,

						   BITMAP_PAGE_NEEDWRITE)) {

					clear_page_attr(bitmap, lastpage,

							BITMAP_PAGE_NEEDWRITE);

					spin_unlock_irqrestore(&bitmap->lock, flags);

					write_page(bitmap, lastpage, 0);

				} else {

					set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);

					set_page_attr(bitmap, lastpage,

						      BITMAP_PAGE_NEEDWRITE);

					bitmap->allclean = 0;

					spin_unlock_irqrestore(&bitmap->lock, flags);

				}

			} else
@@ -1249,19 +1215,17 @@ void bitmap_daemon_work(mddev_t *mddev) 
			}

			spin_lock_irqsave(&bitmap->lock, flags);

			if (!bitmap->need_sync)

				clear_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);

				clear_page_attr(bitmap, page, BITMAP_PAGE_PENDING);

			else

				bitmap->allclean = 0;

		}

		bmc = bitmap_get_counter(bitmap,

					 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),

					 &blocks, 0);

		if (bmc) {

			if (*bmc)

				bitmap->allclean = 0;



			if (*bmc == 2) {

				*bmc = 1; /* maybe clear the bit next time */

				set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);

			} else if (*bmc == 1 && !bitmap->need_sync) {

		if (!bmc)

			j |= PAGE_COUNTER_MASK;

		else if (*bmc) {

			if (*bmc == 1 && !bitmap->need_sync) {

				/* we can clear the bit */

				*bmc = 0;

				bitmap_count_page(bitmap,
@@ -1279,9 +1243,12 @@ void bitmap_daemon_work(mddev_t *mddev) 
								 j),

						paddr);

				kunmap_atomic(paddr, KM_USER0);

			} else if (*bmc <= 2) {

				*bmc = 1; /* maybe clear the bit next time */

				set_page_attr(bitmap, page, BITMAP_PAGE_PENDING);

				bitmap->allclean = 0;

			}

		}

		} else

			j |= PAGE_COUNTER_MASK;

	}

	spin_unlock_irqrestore(&bitmap->lock, flags);
@@ -1294,6 +1261,7 @@ void bitmap_daemon_work(mddev_t *mddev) 
			write_page(bitmap, lastpage, 0);

		} else {

			set_page_attr(bitmap, lastpage, BITMAP_PAGE_NEEDWRITE);

			bitmap->allclean = 0;

			spin_unlock_irqrestore(&bitmap->lock, flags);

		}

	}
@@ -1359,8 +1327,8 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect 
		if (bw > bitmap->behind_writes_used)

			bitmap->behind_writes_used = bw;



		PRINTK(KERN_DEBUG "inc write-behind count %d/%d\n",

		       bw, bitmap->max_write_behind);

		pr_debug("inc write-behind count %d/%lu\n",

			 bw, bitmap->mddev->bitmap_info.max_write_behind);

	}



	while (sectors) {
@@ -1407,7 +1375,6 @@ int bitmap_startwrite(struct bitmap *bitmap, sector_t offset, unsigned long sect 
		else

			sectors = 0;

	}

	bitmap->allclean = 0;

	return 0;

}

EXPORT_SYMBOL(bitmap_startwrite);
@@ -1420,8 +1387,9 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto 
	if (behind) {

		if (atomic_dec_and_test(&bitmap->behind_writes))

			wake_up(&bitmap->behind_wait);

		PRINTK(KERN_DEBUG "dec write-behind count %d/%d\n",

		  atomic_read(&bitmap->behind_writes), bitmap->max_write_behind);

		pr_debug("dec write-behind count %d/%lu\n",

			 atomic_read(&bitmap->behind_writes),

			 bitmap->mddev->bitmap_info.max_write_behind);

	}

	if (bitmap->mddev->degraded)

		/* Never clear bits or update events_cleared when degraded */
@@ -1453,13 +1421,14 @@ 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)),

				      BITMAP_PAGE_CLEAN);



				      BITMAP_PAGE_PENDING);

			bitmap->allclean = 0;

		}

		spin_unlock_irqrestore(&bitmap->lock, flags);

		offset += blocks;

		if (sectors > blocks)
@@ -1495,7 +1464,6 @@ static int __bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t 
		}

	}

	spin_unlock_irq(&bitmap->lock);

	bitmap->allclean = 0;

	return rv;

}
@@ -1543,15 +1511,16 @@ void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, i 
		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);

					      BITMAP_PAGE_PENDING);

				bitmap->allclean = 0;

			}

		}

	}

 unlock:

	spin_unlock_irqrestore(&bitmap->lock, flags);

	bitmap->allclean = 0;

}

EXPORT_SYMBOL(bitmap_end_sync);
@@ -1622,10 +1591,10 @@ static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int n 
		*bmc = 1 | (needed ? NEEDED_MASK : 0);

		bitmap_count_page(bitmap, offset, 1);

		page = filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap));

		set_page_attr(bitmap, page, BITMAP_PAGE_CLEAN);

		set_page_attr(bitmap, page, BITMAP_PAGE_PENDING);

		bitmap->allclean = 0;

	}

	spin_unlock_irq(&bitmap->lock);

	bitmap->allclean = 0;

}



/* dirty the memory and file bits for bitmap chunks "s" to "e" */
@@ -1649,7 +1618,7 @@ void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e) 
/*

 * flush out any pending updates

 */

void bitmap_flush(mddev_t *mddev)

void bitmap_flush(struct mddev *mddev)

{

	struct bitmap *bitmap = mddev->bitmap;

	long sleep;
@@ -1697,7 +1666,7 @@ static void bitmap_free(struct bitmap *bitmap) 
	kfree(bitmap);

}



void bitmap_destroy(mddev_t *mddev)

void bitmap_destroy(struct mddev *mddev)

{

	struct bitmap *bitmap = mddev->bitmap;
@@ -1720,7 +1689,7 @@ void bitmap_destroy(mddev_t *mddev) 
 * initialize the bitmap structure

 * if this returns an error, bitmap_destroy must be called to do clean up

 */

int bitmap_create(mddev_t *mddev)

int bitmap_create(struct mddev *mddev)

{

	struct bitmap *bitmap;

	sector_t blocks = mddev->resync_max_sectors;
@@ -1802,11 +1771,8 @@ int bitmap_create(mddev_t *mddev) 
	bitmap->pages = pages;

	bitmap->missing_pages = pages;



#ifdef INJECT_FATAL_FAULT_1

	bitmap->bp = NULL;

#else

	bitmap->bp = kzalloc(pages * sizeof(*bitmap->bp), GFP_KERNEL);

#endif



	err = -ENOMEM;

	if (!bitmap->bp)

		goto error;
@@ -1824,7 +1790,7 @@ int bitmap_create(mddev_t *mddev) 
	return err;

}



int bitmap_load(mddev_t *mddev)

int bitmap_load(struct mddev *mddev)

{

	int err = 0;

	sector_t start = 0;
@@ -1870,7 +1836,7 @@ out: 
EXPORT_SYMBOL_GPL(bitmap_load);



static ssize_t

location_show(mddev_t *mddev, char *page)

location_show(struct mddev *mddev, char *page)

{

	ssize_t len;

	if (mddev->bitmap_info.file)
@@ -1884,7 +1850,7 @@ location_show(mddev_t *mddev, char *page) 
}



static ssize_t

location_store(mddev_t *mddev, const char *buf, size_t len)

location_store(struct mddev *mddev, const char *buf, size_t len)

{



	if (mddev->pers) {
@@ -1961,7 +1927,7 @@ static struct md_sysfs_entry bitmap_location = 
__ATTR(location, S_IRUGO|S_IWUSR, location_show, location_store);



static ssize_t

timeout_show(mddev_t *mddev, char *page)

timeout_show(struct mddev *mddev, char *page)

{

	ssize_t len;

	unsigned long secs = mddev->bitmap_info.daemon_sleep / HZ;
@@ -1975,7 +1941,7 @@ timeout_show(mddev_t *mddev, char *page) 
}



static ssize_t

timeout_store(mddev_t *mddev, const char *buf, size_t len)

timeout_store(struct mddev *mddev, const char *buf, size_t len)

{

	/* timeout can be set at any time */

	unsigned long timeout;
@@ -2011,13 +1977,13 @@ static struct md_sysfs_entry bitmap_timeout = 
__ATTR(time_base, S_IRUGO|S_IWUSR, timeout_show, timeout_store);



static ssize_t

backlog_show(mddev_t *mddev, char *page)

backlog_show(struct mddev *mddev, char *page)

{

	return sprintf(page, "%lu\n", mddev->bitmap_info.max_write_behind);

}



static ssize_t

backlog_store(mddev_t *mddev, const char *buf, size_t len)

backlog_store(struct mddev *mddev, const char *buf, size_t len)

{

	unsigned long backlog;

	int rv = strict_strtoul(buf, 10, &backlog);
@@ -2033,13 +1999,13 @@ static struct md_sysfs_entry bitmap_backlog = 
__ATTR(backlog, S_IRUGO|S_IWUSR, backlog_show, backlog_store);



static ssize_t

chunksize_show(mddev_t *mddev, char *page)

chunksize_show(struct mddev *mddev, char *page)

{

	return sprintf(page, "%lu\n", mddev->bitmap_info.chunksize);

}



static ssize_t

chunksize_store(mddev_t *mddev, const char *buf, size_t len)

chunksize_store(struct mddev *mddev, const char *buf, size_t len)

{

	/* Can only be changed when no bitmap is active */

	int rv;
@@ -2059,13 +2025,13 @@ chunksize_store(mddev_t *mddev, const char *buf, size_t len) 
static struct md_sysfs_entry bitmap_chunksize =

__ATTR(chunksize, S_IRUGO|S_IWUSR, chunksize_show, chunksize_store);



static ssize_t metadata_show(mddev_t *mddev, char *page)

static ssize_t metadata_show(struct mddev *mddev, char *page)

{

	return sprintf(page, "%s\n", (mddev->bitmap_info.external

				      ? "external" : "internal"));

}



static ssize_t metadata_store(mddev_t *mddev, const char *buf, size_t len)

static ssize_t metadata_store(struct mddev *mddev, const char *buf, size_t len)

{

	if (mddev->bitmap ||

	    mddev->bitmap_info.file ||
@@ -2083,7 +2049,7 @@ static ssize_t metadata_store(mddev_t *mddev, const char *buf, size_t len) 
static struct md_sysfs_entry bitmap_metadata =

__ATTR(metadata, S_IRUGO|S_IWUSR, metadata_show, metadata_store);



static ssize_t can_clear_show(mddev_t *mddev, char *page)

static ssize_t can_clear_show(struct mddev *mddev, char *page)

{

	int len;

	if (mddev->bitmap)
@@ -2094,7 +2060,7 @@ static ssize_t can_clear_show(mddev_t *mddev, char *page) 
	return len;

}



static ssize_t can_clear_store(mddev_t *mddev, const char *buf, size_t len)

static ssize_t can_clear_store(struct mddev *mddev, const char *buf, size_t len)

{

	if (mddev->bitmap == NULL)

		return -ENOENT;
@@ -2113,7 +2079,7 @@ static struct md_sysfs_entry bitmap_can_clear = 
__ATTR(can_clear, S_IRUGO|S_IWUSR, can_clear_show, can_clear_store);



static ssize_t

behind_writes_used_show(mddev_t *mddev, char *page)

behind_writes_used_show(struct mddev *mddev, char *page)

{

	if (mddev->bitmap == NULL)

		return sprintf(page, "0\n");
@@ -2122,7 +2088,7 @@ behind_writes_used_show(mddev_t *mddev, char *page) 
}



static ssize_t

behind_writes_used_reset(mddev_t *mddev, const char *buf, size_t len)

behind_writes_used_reset(struct mddev *mddev, const char *buf, size_t len)

{

	if (mddev->bitmap)

		mddev->bitmap->behind_writes_used = 0;

drivers/md/bitmap.h

+6 −6
Original line number Diff line number Diff line
@@ -193,7 +193,7 @@ struct bitmap { 
	unsigned long pages; /* total number of pages in the bitmap */

	unsigned long missing_pages; /* number of pages not yet allocated */



	mddev_t *mddev; /* the md device that the bitmap is for */

	struct mddev *mddev; /* the md device that the bitmap is for */



	/* bitmap chunksize -- how much data does each bit represent? */

	unsigned long chunkshift; /* chunksize = 2^chunkshift (for bitops) */
@@ -238,10 +238,10 @@ struct bitmap { 
/* the bitmap API */



/* these are used only by md/bitmap */

int  bitmap_create(mddev_t *mddev);

int bitmap_load(mddev_t *mddev);

void bitmap_flush(mddev_t *mddev);

void bitmap_destroy(mddev_t *mddev);

int  bitmap_create(struct mddev *mddev);

int bitmap_load(struct mddev *mddev);

void bitmap_flush(struct mddev *mddev);

void bitmap_destroy(struct mddev *mddev);



void bitmap_print_sb(struct bitmap *bitmap);

void bitmap_update_sb(struct bitmap *bitmap);
@@ -262,7 +262,7 @@ void bitmap_close_sync(struct bitmap *bitmap); 
void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector);



void bitmap_unplug(struct bitmap *bitmap);

void bitmap_daemon_work(mddev_t *mddev);

void bitmap_daemon_work(struct mddev *mddev);

#endif



#endif

drivers/md/dm-raid.c

+14 −14
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ struct raid_dev { 
	 */

	struct dm_dev *meta_dev;

	struct dm_dev *data_dev;

	struct mdk_rdev_s rdev;

	struct md_rdev rdev;

};



/*
@@ -57,7 +57,7 @@ struct raid_set { 


	uint64_t print_flags;



	struct mddev_s md;

	struct mddev md;

	struct raid_type *raid_type;

	struct dm_target_callbacks callbacks;
@@ -594,7 +594,7 @@ struct dm_raid_superblock { 
				/* Always set to 0 when writing. */

} __packed;



static int read_disk_sb(mdk_rdev_t *rdev, int size)

static int read_disk_sb(struct md_rdev *rdev, int size)

{

	BUG_ON(!rdev->sb_page);
@@ -611,9 +611,9 @@ static int read_disk_sb(mdk_rdev_t *rdev, int size) 
	return 0;

}



static void super_sync(mddev_t *mddev, mdk_rdev_t *rdev)

static void super_sync(struct mddev *mddev, struct md_rdev *rdev)

{

	mdk_rdev_t *r, *t;

	struct md_rdev *r, *t;

	uint64_t failed_devices;

	struct dm_raid_superblock *sb;
@@ -651,7 +651,7 @@ static void super_sync(mddev_t *mddev, mdk_rdev_t *rdev) 
 *

 * Return: 1 if use rdev, 0 if use refdev, -Exxx otherwise

 */

static int super_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev)

static int super_load(struct md_rdev *rdev, struct md_rdev *refdev)

{

	int ret;

	struct dm_raid_superblock *sb;
@@ -689,7 +689,7 @@ static int super_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev) 
	return (events_sb > events_refsb) ? 1 : 0;

}



static int super_init_validation(mddev_t *mddev, mdk_rdev_t *rdev)

static int super_init_validation(struct mddev *mddev, struct md_rdev *rdev)

{

	int role;

	struct raid_set *rs = container_of(mddev, struct raid_set, md);
@@ -698,7 +698,7 @@ static int super_init_validation(mddev_t *mddev, mdk_rdev_t *rdev) 
	struct dm_raid_superblock *sb;

	uint32_t new_devs = 0;

	uint32_t rebuilds = 0;

	mdk_rdev_t *r, *t;

	struct md_rdev *r, *t;

	struct dm_raid_superblock *sb2;



	sb = page_address(rdev->sb_page);
@@ -809,7 +809,7 @@ static int super_init_validation(mddev_t *mddev, mdk_rdev_t *rdev) 
	return 0;

}



static int super_validate(mddev_t *mddev, mdk_rdev_t *rdev)

static int super_validate(struct mddev *mddev, struct md_rdev *rdev)

{

	struct dm_raid_superblock *sb = page_address(rdev->sb_page);
@@ -849,8 +849,8 @@ static int super_validate(mddev_t *mddev, mdk_rdev_t *rdev) 
static int analyse_superblocks(struct dm_target *ti, struct raid_set *rs)

{

	int ret;

	mdk_rdev_t *rdev, *freshest, *tmp;

	mddev_t *mddev = &rs->md;

	struct md_rdev *rdev, *freshest, *tmp;

	struct mddev *mddev = &rs->md;



	freshest = NULL;

	rdev_for_each(rdev, tmp, mddev) {
@@ -1004,7 +1004,7 @@ static void raid_dtr(struct dm_target *ti) 
static int raid_map(struct dm_target *ti, struct bio *bio, union map_info *map_context)

{

	struct raid_set *rs = ti->private;

	mddev_t *mddev = &rs->md;

	struct mddev *mddev = &rs->md;



	mddev->pers->make_request(mddev, bio);
@@ -1097,7 +1097,7 @@ static int raid_status(struct dm_target *ti, status_type_t type, 
			       rs->md.bitmap_info.max_write_behind);



		if (rs->print_flags & DMPF_STRIPE_CACHE) {

			raid5_conf_t *conf = rs->md.private;

			struct r5conf *conf = rs->md.private;



			/* convert from kiB to sectors */

			DMEMIT(" stripe_cache %d",
@@ -1146,7 +1146,7 @@ static void raid_io_hints(struct dm_target *ti, struct queue_limits *limits) 
{

	struct raid_set *rs = ti->private;

	unsigned chunk_size = rs->md.chunk_sectors << 9;

	raid5_conf_t *conf = rs->md.private;

	struct r5conf *conf = rs->md.private;



	blk_limits_io_min(limits, chunk_size);

	blk_limits_io_opt(limits, chunk_size * (conf->raid_disks - conf->max_degraded));

drivers/md/faulty.c

+19 −19
Original line number Diff line number Diff line
@@ -81,16 +81,16 @@ static void faulty_fail(struct bio *bio, int error) 
	bio_io_error(b);

}



typedef struct faulty_conf {

struct faulty_conf {

	int period[Modes];

	atomic_t counters[Modes];

	sector_t faults[MaxFault];

	int	modes[MaxFault];

	int nfaults;

	mdk_rdev_t *rdev;

} conf_t;

	struct md_rdev *rdev;

};



static int check_mode(conf_t *conf, int mode)

static int check_mode(struct faulty_conf *conf, int mode)

{

	if (conf->period[mode] == 0 &&

	    atomic_read(&conf->counters[mode]) <= 0)
@@ -105,7 +105,7 @@ static int check_mode(conf_t *conf, int mode) 
	return 0;

}



static int check_sector(conf_t *conf, sector_t start, sector_t end, int dir)

static int check_sector(struct faulty_conf *conf, sector_t start, sector_t end, int dir)

{

	/* If we find a ReadFixable sector, we fix it ... */

	int i;
@@ -129,7 +129,7 @@ static int check_sector(conf_t *conf, sector_t start, sector_t end, int dir) 
	return 0;

}



static void add_sector(conf_t *conf, sector_t start, int mode)

static void add_sector(struct faulty_conf *conf, sector_t start, int mode)

{

	int i;

	int n = conf->nfaults;
@@ -169,9 +169,9 @@ static void add_sector(conf_t *conf, sector_t start, int mode) 
		conf->nfaults = n+1;

}



static int make_request(mddev_t *mddev, struct bio *bio)

static int make_request(struct mddev *mddev, struct bio *bio)

{

	conf_t *conf = mddev->private;

	struct faulty_conf *conf = mddev->private;

	int failit = 0;



	if (bio_data_dir(bio) == WRITE) {
@@ -222,9 +222,9 @@ static int make_request(mddev_t *mddev, struct bio *bio) 
	}

}



static void status(struct seq_file *seq, mddev_t *mddev)

static void status(struct seq_file *seq, struct mddev *mddev)

{

	conf_t *conf = mddev->private;

	struct faulty_conf *conf = mddev->private;

	int n;



	if ((n=atomic_read(&conf->counters[WriteTransient])) != 0)
@@ -255,11 +255,11 @@ static void status(struct seq_file *seq, mddev_t *mddev) 
}





static int reshape(mddev_t *mddev)

static int reshape(struct mddev *mddev)

{

	int mode = mddev->new_layout & ModeMask;

	int count = mddev->new_layout >> ModeShift;

	conf_t *conf = mddev->private;

	struct faulty_conf *conf = mddev->private;



	if (mddev->new_layout < 0)

		return 0;
@@ -284,7 +284,7 @@ static int reshape(mddev_t *mddev) 
	return 0;

}



static sector_t faulty_size(mddev_t *mddev, sector_t sectors, int raid_disks)

static sector_t faulty_size(struct mddev *mddev, sector_t sectors, int raid_disks)

{

	WARN_ONCE(raid_disks,

		  "%s does not support generic reshape\n", __func__);
@@ -295,11 +295,11 @@ static sector_t faulty_size(mddev_t *mddev, sector_t sectors, int raid_disks) 
	return sectors;

}



static int run(mddev_t *mddev)

static int run(struct mddev *mddev)

{

	mdk_rdev_t *rdev;

	struct md_rdev *rdev;

	int i;

	conf_t *conf;

	struct faulty_conf *conf;



	if (md_check_no_bitmap(mddev))

		return -EINVAL;
@@ -325,16 +325,16 @@ static int run(mddev_t *mddev) 
	return 0;

}



static int stop(mddev_t *mddev)

static int stop(struct mddev *mddev)

{

	conf_t *conf = mddev->private;

	struct faulty_conf *conf = mddev->private;



	kfree(conf);

	mddev->private = NULL;

	return 0;

}



static struct mdk_personality faulty_personality =

static struct md_personality faulty_personality =

{

	.name		= "faulty",

	.level		= LEVEL_FAULTY,

drivers/md/linear.c

+23 −23
Original line number Diff line number Diff line
@@ -26,10 +26,10 @@ 
/*

 * find which device holds a particular offset 

 */

static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector)

static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector)

{

	int lo, mid, hi;

	linear_conf_t *conf;

	struct linear_conf *conf;



	lo = 0;

	hi = mddev->raid_disks - 1;
@@ -63,8 +63,8 @@ static int linear_mergeable_bvec(struct request_queue *q, 
				 struct bvec_merge_data *bvm,

				 struct bio_vec *biovec)

{

	mddev_t *mddev = q->queuedata;

	dev_info_t *dev0;

	struct mddev *mddev = q->queuedata;

	struct dev_info *dev0;

	unsigned long maxsectors, bio_sectors = bvm->bi_size >> 9;

	sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
@@ -89,8 +89,8 @@ static int linear_mergeable_bvec(struct request_queue *q, 


static int linear_congested(void *data, int bits)

{

	mddev_t *mddev = data;

	linear_conf_t *conf;

	struct mddev *mddev = data;

	struct linear_conf *conf;

	int i, ret = 0;



	if (mddev_congested(mddev, bits))
@@ -108,9 +108,9 @@ static int linear_congested(void *data, int bits) 
	return ret;

}



static sector_t linear_size(mddev_t *mddev, sector_t sectors, int raid_disks)

static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)

{

	linear_conf_t *conf;

	struct linear_conf *conf;

	sector_t array_sectors;



	rcu_read_lock();
@@ -123,13 +123,13 @@ static sector_t linear_size(mddev_t *mddev, sector_t sectors, int raid_disks) 
	return array_sectors;

}



static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)

static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)

{

	linear_conf_t *conf;

	mdk_rdev_t *rdev;

	struct linear_conf *conf;

	struct md_rdev *rdev;

	int i, cnt;



	conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(dev_info_t),

	conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(struct dev_info),

			GFP_KERNEL);

	if (!conf)

		return NULL;
@@ -139,7 +139,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 


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

		int j = rdev->raid_disk;

		dev_info_t *disk = conf->disks + j;

		struct dev_info *disk = conf->disks + j;

		sector_t sectors;



		if (j < 0 || j >= raid_disks || disk->rdev) {
@@ -194,9 +194,9 @@ out: 
	return NULL;

}



static int linear_run (mddev_t *mddev)

static int linear_run (struct mddev *mddev)

{

	linear_conf_t *conf;

	struct linear_conf *conf;



	if (md_check_no_bitmap(mddev))

		return -EINVAL;
@@ -213,7 +213,7 @@ static int linear_run (mddev_t *mddev) 
	return md_integrity_register(mddev);

}



static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev)

static int linear_add(struct mddev *mddev, struct md_rdev *rdev)

{

	/* Adding a drive to a linear array allows the array to grow.

	 * It is permitted if the new drive has a matching superblock
@@ -223,7 +223,7 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev) 
	 * The current one is never freed until the array is stopped.

	 * This avoids races.

	 */

	linear_conf_t *newconf, *oldconf;

	struct linear_conf *newconf, *oldconf;



	if (rdev->saved_raid_disk != mddev->raid_disks)

		return -EINVAL;
@@ -245,9 +245,9 @@ static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev) 
	return 0;

}



static int linear_stop (mddev_t *mddev)

static int linear_stop (struct mddev *mddev)

{

	linear_conf_t *conf = mddev->private;

	struct linear_conf *conf = mddev->private;



	/*

	 * We do not require rcu protection here since
@@ -264,9 +264,9 @@ static int linear_stop (mddev_t *mddev) 
	return 0;

}



static int linear_make_request (mddev_t *mddev, struct bio *bio)

static int linear_make_request (struct mddev *mddev, struct bio *bio)

{

	dev_info_t *tmp_dev;

	struct dev_info *tmp_dev;

	sector_t start_sector;



	if (unlikely(bio->bi_rw & REQ_FLUSH)) {
@@ -323,14 +323,14 @@ static int linear_make_request (mddev_t *mddev, struct bio *bio) 
	return 1;

}



static void linear_status (struct seq_file *seq, mddev_t *mddev)

static void linear_status (struct seq_file *seq, struct mddev *mddev)

{



	seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);

}





static struct mdk_personality linear_personality =

static struct md_personality linear_personality =

{

	.name		= "linear",

	.level		= LEVEL_LINEAR,