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

Commit 61a0d80c authored by NeilBrown's avatar NeilBrown
Browse files

md/bitmap: discard CHUNK_BLOCK_SHIFT macro 



Be redefining ->chunkshift as the shift from sectors to chunks rather
than bytes to chunks, we can just use "bitmap->chunkshift" which is
shorter than the macro call, and less indirect.

Signed-off-by: default avatarNeilBrown <neilb@suse.de>
parent 792a1d4b

drivers/md/bitmap.c

+18 −17
Original line number Diff line number Diff line
@@ -838,7 +838,7 @@ static void bitmap_file_set_bit(struct bitmap *bitmap, sector_t block) 
	unsigned long bit;

	struct page *page;

	void *kaddr;

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

	unsigned long chunk = block >> bitmap->chunkshift;



	if (!bitmap->filemap)

		return;
@@ -1037,10 +1037,10 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
		kunmap_atomic(paddr, KM_USER0);

		if (b) {

			/* if the disk bit is set, set the memory bit */

			int needed = ((sector_t)(i+1) << (CHUNK_BLOCK_SHIFT(bitmap))

			int needed = ((sector_t)(i+1) << bitmap->chunkshift

				      >= start);

			bitmap_set_memory_bits(bitmap,

					       (sector_t)i << CHUNK_BLOCK_SHIFT(bitmap),

					       (sector_t)i << bitmap->chunkshift,

					       needed);

			bit_cnt++;

		}
@@ -1084,7 +1084,7 @@ void bitmap_write_all(struct bitmap *bitmap) 


static void bitmap_count_page(struct bitmap *bitmap, sector_t offset, int inc)

{

	sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);

	sector_t chunk = offset >> bitmap->chunkshift;

	unsigned long page = chunk >> PAGE_COUNTER_SHIFT;

	bitmap->bp[page].count += inc;

	bitmap_checkfree(bitmap, page);
@@ -1190,7 +1190,7 @@ void bitmap_daemon_work(struct mddev *mddev) 
				bitmap->allclean = 0;

		}

		bmc = bitmap_get_counter(bitmap,

					 (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),

					 (sector_t)j << bitmap->chunkshift,

					 &blocks, 0);

		if (!bmc)

			j |= PAGE_COUNTER_MASK;
@@ -1199,7 +1199,7 @@ void bitmap_daemon_work(struct mddev *mddev) 
				/* we can clear the bit */

				*bmc = 0;

				bitmap_count_page(bitmap,

						  (sector_t)j << CHUNK_BLOCK_SHIFT(bitmap),

						  (sector_t)j << bitmap->chunkshift,

						  -1);



				/* clear the bit */
@@ -1253,7 +1253,7 @@ __acquires(bitmap->lock) 
	 * The lock must have been taken with interrupts enabled.

	 * If !create, we don't release the lock.

	 */

	sector_t chunk = offset >> CHUNK_BLOCK_SHIFT(bitmap);

	sector_t chunk = offset >> bitmap->chunkshift;

	unsigned long page = chunk >> PAGE_COUNTER_SHIFT;

	unsigned long pageoff = (chunk & PAGE_COUNTER_MASK) << COUNTER_BYTE_SHIFT;

	sector_t csize;
@@ -1263,10 +1263,10 @@ __acquires(bitmap->lock) 


	if (bitmap->bp[page].hijacked ||

	    bitmap->bp[page].map == NULL)

		csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap) +

		csize = ((sector_t)1) << (bitmap->chunkshift +

					  PAGE_COUNTER_SHIFT - 1);

	else

		csize = ((sector_t)1) << (CHUNK_BLOCK_SHIFT(bitmap));

		csize = ((sector_t)1) << bitmap->chunkshift;

	*blocks = csize - (offset & (csize - 1));



	if (err < 0)
@@ -1392,7 +1392,7 @@ void bitmap_endwrite(struct bitmap *bitmap, sector_t offset, unsigned long secto 
			set_page_attr(bitmap,

				      filemap_get_page(

					      bitmap,

					      offset >> CHUNK_BLOCK_SHIFT(bitmap)),

					      offset >> bitmap->chunkshift),

				      BITMAP_PAGE_PENDING);

			bitmap->allclean = 0;

		}
@@ -1480,7 +1480,7 @@ void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, i 
		else {

			if (*bmc <= 2) {

				set_page_attr(bitmap,

					      filemap_get_page(bitmap, offset >> CHUNK_BLOCK_SHIFT(bitmap)),

					      filemap_get_page(bitmap, offset >> bitmap->chunkshift),

					      BITMAP_PAGE_PENDING);

				bitmap->allclean = 0;

			}
@@ -1527,7 +1527,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector) 


	bitmap->mddev->curr_resync_completed = sector;

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

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

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

	s = 0;

	while (s < sector && s < bitmap->mddev->resync_max_sectors) {

		bitmap_end_sync(bitmap, s, &blocks, 0);
@@ -1557,7 +1557,7 @@ static void bitmap_set_memory_bits(struct bitmap *bitmap, sector_t offset, int n 
		struct page *page;

		*bmc = 2 | (needed ? NEEDED_MASK : 0);

		bitmap_count_page(bitmap, offset, 1);

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

		page = filemap_get_page(bitmap, offset >> bitmap->chunkshift);

		set_page_attr(bitmap, page, BITMAP_PAGE_PENDING);

		bitmap->allclean = 0;

	}
@@ -1570,7 +1570,7 @@ void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e) 
	unsigned long chunk;



	for (chunk = s; chunk <= e; chunk++) {

		sector_t sec = (sector_t)chunk << CHUNK_BLOCK_SHIFT(bitmap);

		sector_t sec = (sector_t)chunk << bitmap->chunkshift;

		bitmap_set_memory_bits(bitmap, sec, 1);

		spin_lock_irq(&bitmap->lock);

		bitmap_file_set_bit(bitmap, sec);
@@ -1727,11 +1727,12 @@ int bitmap_create(struct mddev *mddev) 
		goto error;



	bitmap->daemon_lastrun = jiffies;

	bitmap->chunkshift = ffz(~mddev->bitmap_info.chunksize);

	bitmap->chunkshift = (ffz(~mddev->bitmap_info.chunksize)

			      - BITMAP_BLOCK_SHIFT);



	/* now that chunksize and chunkshift are set, we can use these macros */

	chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>

			CHUNK_BLOCK_SHIFT(bitmap);

	chunks = (blocks + bitmap->chunkshift - 1) >>

			bitmap->chunkshift;

	pages = (chunks + PAGE_COUNTER_RATIO - 1) / PAGE_COUNTER_RATIO;



	BUG_ON(!pages);

drivers/md/bitmap.h

+1 −2
Original line number Diff line number Diff line
@@ -103,7 +103,6 @@ typedef __u16 bitmap_counter_t; 


/* how many blocks per chunk? (this is variable) */

#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->mddev->bitmap_info.chunksize >> BITMAP_BLOCK_SHIFT)

#define CHUNK_BLOCK_SHIFT(bitmap) ((bitmap)->chunkshift - BITMAP_BLOCK_SHIFT)



#endif
@@ -178,7 +177,7 @@ struct bitmap { 
	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) */

	unsigned long chunkshift; /* chunksize = 2^(chunkshift+9) (for bitops) */

	unsigned long chunks; /* total number of data chunks for the array */



	__u64	events_cleared;