Commit ac2f40be authored by NeilBrown's avatar NeilBrown
Browse files

md/bitmap: white space clean up and similar. 



Fixes some whitespace problems
Fixed some checkpatch.pl complaints.
Replaced kmalloc ... memset(0), with kzalloc
Fixed an unlikely memory leak on an error path.
Reformatted a number of 'if/else' sets, sometimes
replacing goto with an else clause.
Removed some old comments and commented-out code.

Signed-off-by: default avatarNeilBrown <neilb@suse.de>
parent 9f7c2220

drivers/md/bitmap.c

+135 −166
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>
@@ -51,9 +50,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 +63,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 +73,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 +102,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 +117,6 @@ __acquires(bitmap->lock) 
		return -EINVAL;

	}





	if (bitmap->bp[page].hijacked) /* it's hijacked, don't try to alloc */

		return 0;
@@ -131,43 +126,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 +169,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 +195,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 +220,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 +276,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 +346,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 +405,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 +459,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 +645,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 +694,12 @@ 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 (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 +750,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 +768,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,9 +785,9 @@ 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,
@@ -840,12 +822,12 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) 
	void *kaddr;

	unsigned long chunk = block >> CHUNK_BLOCK_SHIFT(bitmap);



	if (!bitmap->filemap) {

	if (!bitmap->filemap)

		return;

	}



	page = filemap_get_page(bitmap, chunk);

	if (!page) return;

	if (!page)

		return;

	bit = file_page_offset(bitmap, chunk);



	/* set the bit */
@@ -859,7 +841,6 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) 


	/* 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
@@ -892,7 +873,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 */
@@ -905,6 +886,7 @@ void bitmap_unplug(struct bitmap *bitmap) 
	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
@@ -947,7 +929,6 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
	if (!bitmap->mddev->bitmap_info.external)

		bytes += sizeof(bitmap_super_t);



	

	num_pages = (bytes + PAGE_SIZE - 1) / PAGE_SIZE;



	if (file && i_size_read(file->f_mapping->host) < bytes) {
@@ -1085,16 +1066,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,
@@ -1197,9 +1173,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;
@@ -1289,7 +1262,8 @@ __acquires(bitmap->lock) 


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;
@@ -1345,16 +1319,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);
@@ -1391,18 +1368,20 @@ 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);

		}



		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 +1434,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 +1450,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 +1483,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)

{
@@ -1537,6 +1514,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)

{
@@ -1775,11 +1753,11 @@ 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;
@@ -2050,12 +2028,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);

drivers/md/md.h

+1 −1
Original line number Diff line number Diff line
@@ -319,7 +319,7 @@ struct mddev_s 
							 */

		struct mutex		mutex;

		unsigned long		chunksize;

		unsigned long		daemon_sleep; /* how many seconds between updates? */

		unsigned long		daemon_sleep; /* how many jiffies between updates? */

		unsigned long		max_write_behind; /* write-behind mode */

		int			external;

	} bitmap_info;

CRA Git | Maintained and supported by SUSTech CRA and CCSE