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

Commit 42a04b50 authored by NeilBrown's avatar NeilBrown
Browse files

md: move offset, daemon_sleep and chunksize out of bitmap structure 



... and into bitmap_info.  These are all configuration parameters
that need to be set before the bitmap is created.

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

drivers/md/bitmap.c

+28 −23
Original line number Diff line number Diff line
@@ -287,27 +287,28 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait) 


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

			int size = PAGE_SIZE;

			long offset = mddev->bitmap_info.offset;

			if (page->index == bitmap->file_pages-1)

				size = roundup(bitmap->last_page_size,

					       bdev_logical_block_size(rdev->bdev));

			/* Just make sure we aren't corrupting data or

			 * metadata

			 */

			if (bitmap->offset < 0) {

			if (offset < 0) {

				/* DATA  BITMAP METADATA  */

				if (bitmap->offset

				if (offset

				    + (long)(page->index * (PAGE_SIZE/512))

				    + size/512 > 0)

					/* bitmap runs in to metadata */

					goto bad_alignment;

				if (rdev->data_offset + mddev->dev_sectors

				    > rdev->sb_start + bitmap->offset)

				    > rdev->sb_start + offset)

					/* data runs in to bitmap */

					goto bad_alignment;

			} else if (rdev->sb_start < rdev->data_offset) {

				/* METADATA BITMAP DATA */

				if (rdev->sb_start

				    + bitmap->offset

				    + offset

				    + page->index*(PAGE_SIZE/512) + size/512

				    > rdev->data_offset)

					/* bitmap runs in to data */
@@ -316,7 +317,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait) 
				/* DATA METADATA BITMAP - no problems */

			}

			md_super_write(mddev, rdev,

				       rdev->sb_start + bitmap->offset

				       rdev->sb_start + offset

				       + page->index * (PAGE_SIZE/512),

				       size,

				       page);
@@ -550,7 +551,8 @@ static int bitmap_read_sb(struct bitmap *bitmap) 


		bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);

	} else {

		bitmap->sb_page = read_sb_page(bitmap->mddev, bitmap->offset,

		bitmap->sb_page = read_sb_page(bitmap->mddev,

					       bitmap->mddev->bitmap_info.offset,

					       NULL,

					       0, sizeof(bitmap_super_t));

	}
@@ -610,10 +612,10 @@ static int bitmap_read_sb(struct bitmap *bitmap) 
	}

success:

	/* assign fields using values from superblock */

	bitmap->chunksize = chunksize;

	bitmap->daemon_sleep = daemon_sleep;

	bitmap->mddev->bitmap_info.chunksize = chunksize;

	bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;

	bitmap->daemon_lastrun = jiffies;

	bitmap->max_write_behind = write_behind;

	bitmap->mddev->bitmap_info.max_write_behind = write_behind;

	bitmap->flags |= le32_to_cpu(sb->state);

	if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)

		bitmap->flags |= BITMAP_HOSTENDIAN;
@@ -907,7 +909,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
	chunks = bitmap->chunks;

	file = bitmap->file;



	BUG_ON(!file && !bitmap->offset);

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



#ifdef INJECT_FAULTS_3

	outofdate = 1;
@@ -967,14 +969,15 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start) 
				offset = sizeof(bitmap_super_t);

				if (!file)

					read_sb_page(bitmap->mddev,

						     bitmap->offset,

						     bitmap->mddev->bitmap_info.offset,

						     page,

						     index, count);

			} else if (file) {

				page = read_page(file, index, bitmap, count);

				offset = 0;

			} else {

				page = read_sb_page(bitmap->mddev, bitmap->offset,

				page = read_sb_page(bitmap->mddev,

						    bitmap->mddev->bitmap_info.offset,

						    NULL,

						    index, count);

				offset = 0;
@@ -1096,7 +1099,8 @@ void bitmap_daemon_work(mddev_t *mddev) 
		mutex_unlock(&mddev->bitmap_info.mutex);

		return;

	}

	if (time_before(jiffies, bitmap->daemon_lastrun + bitmap->daemon_sleep*HZ))

	if (time_before(jiffies, bitmap->daemon_lastrun

			+ bitmap->mddev->bitmap_info.daemon_sleep*HZ))

		goto done;



	bitmap->daemon_lastrun = jiffies;
@@ -1210,7 +1214,8 @@ void bitmap_daemon_work(mddev_t *mddev) 


 done:

	if (bitmap->allclean == 0)

		bitmap->mddev->thread->timeout = bitmap->daemon_sleep * HZ;

		bitmap->mddev->thread->timeout = 

			bitmap->mddev->bitmap_info.daemon_sleep * HZ;

	mutex_unlock(&mddev->bitmap_info.mutex);

}
@@ -1479,7 +1484,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector) 
		return;

	}

	if (time_before(jiffies, (bitmap->last_end_sync

				  + bitmap->daemon_sleep * HZ)))

				  + bitmap->mddev->bitmap_info.daemon_sleep * HZ)))

		return;

	wait_event(bitmap->mddev->recovery_wait,

		   atomic_read(&bitmap->mddev->recovery_active) == 0);
@@ -1540,7 +1545,7 @@ void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e) 
void bitmap_flush(mddev_t *mddev)

{

	struct bitmap *bitmap = mddev->bitmap;

	int sleep;

	long sleep;



	if (!bitmap) /* there was no bitmap */

		return;
@@ -1548,12 +1553,13 @@ void bitmap_flush(mddev_t *mddev) 
	/* run the daemon_work three time to ensure everything is flushed

	 * that can be

	 */

	sleep = bitmap->daemon_sleep;

	bitmap->daemon_sleep = 0;

	sleep = mddev->bitmap_info.daemon_sleep * HZ * 2;

	bitmap->daemon_lastrun -= sleep;

	bitmap_daemon_work(mddev);

	bitmap->daemon_lastrun -= sleep;

	bitmap_daemon_work(mddev);

	bitmap->daemon_lastrun -= sleep;

	bitmap_daemon_work(mddev);

	bitmap->daemon_sleep = sleep;

	bitmap_update_sb(bitmap);

}
@@ -1633,7 +1639,6 @@ int bitmap_create(mddev_t *mddev) 
	bitmap->mddev = mddev;



	bitmap->file = file;

	bitmap->offset = mddev->bitmap_info.offset;

	if (file) {

		get_file(file);

		/* As future accesses to this file will use bmap,
@@ -1642,12 +1647,12 @@ int bitmap_create(mddev_t *mddev) 
		 */

		vfs_fsync(file, file->f_dentry, 1);

	}

	/* read superblock from bitmap file (this sets bitmap->chunksize) */

	/* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */

	err = bitmap_read_sb(bitmap);

	if (err)

		goto error;



	bitmap->chunkshift = ffz(~bitmap->chunksize);

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



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

 	chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
@@ -1689,7 +1694,7 @@ int bitmap_create(mddev_t *mddev) 


	mddev->bitmap = bitmap;



	mddev->thread->timeout = bitmap->daemon_sleep * HZ;

	mddev->thread->timeout = mddev->bitmap_info.daemon_sleep * HZ;



	bitmap_update_sb(bitmap);

drivers/md/bitmap.h

+1 −5
Original line number Diff line number Diff line
@@ -106,7 +106,7 @@ typedef __u16 bitmap_counter_t; 
#define BITMAP_BLOCK_SHIFT 9



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

#define CHUNK_BLOCK_RATIO(bitmap) ((bitmap)->chunksize >> BITMAP_BLOCK_SHIFT)

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

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

#define CHUNK_BLOCK_MASK(bitmap) (CHUNK_BLOCK_RATIO(bitmap) - 1)
@@ -209,7 +209,6 @@ struct bitmap { 
	int counter_bits; /* how many bits per block counter */



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

	unsigned long chunksize;

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

	unsigned long chunks; /* total number of data chunks for the array */
@@ -226,7 +225,6 @@ struct bitmap { 
	/* bitmap spinlock */

	spinlock_t lock;



	long offset; /* offset from superblock if file is NULL */

	struct file *file; /* backing disk file */

	struct page *sb_page; /* cached copy of the bitmap file superblock */

	struct page **filemap; /* list of cache pages for the file */
@@ -238,7 +236,6 @@ struct bitmap { 


	int allclean;



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

	atomic_t behind_writes;



	/*
@@ -246,7 +243,6 @@ struct bitmap { 
	 * file, cleaning up bits and flushing out pages to disk as necessary

	 */

	unsigned long daemon_lastrun; /* jiffies of last run */

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

	unsigned long last_end_sync; /* when we lasted called end_sync to

				      * update bitmap with resync progress */

drivers/md/md.c

+5 −2
Original line number Diff line number Diff line
@@ -4557,6 +4557,9 @@ out: 
		mddev->safemode = 0;

		mddev->bitmap_info.offset = 0;

		mddev->bitmap_info.default_offset = 0;

		mddev->bitmap_info.chunksize = 0;

		mddev->bitmap_info.daemon_sleep = 0;

		mddev->bitmap_info.max_write_behind = 0;

		kobject_uevent(&disk_to_dev(mddev->gendisk)->kobj, KOBJ_CHANGE);

		if (mddev->hold_active == UNTIL_STOP)

			mddev->hold_active = 0;
@@ -6089,14 +6092,14 @@ static int md_seq_show(struct seq_file *seq, void *v) 
			unsigned long chunk_kb;

			unsigned long flags;

			spin_lock_irqsave(&bitmap->lock, flags);

			chunk_kb = bitmap->chunksize >> 10;

			chunk_kb = mddev->bitmap_info.chunksize >> 10;

			seq_printf(seq, "bitmap: %lu/%lu pages [%luKB], "

				"%lu%s chunk",

				bitmap->pages - bitmap->missing_pages,

				bitmap->pages,

				(bitmap->pages - bitmap->missing_pages)

					<< (PAGE_SHIFT - 10),

				chunk_kb ? chunk_kb : bitmap->chunksize,

				chunk_kb ? chunk_kb : mddev->bitmap_info.chunksize,

				chunk_kb ? "KB" : "B");

			if (bitmap->file) {

				seq_printf(seq, ", file: ");

drivers/md/md.h

+3 −0
Original line number Diff line number Diff line
@@ -291,6 +291,9 @@ struct mddev_s 
							 * eventually be settable by sysfs.

							 */

		struct mutex		mutex;

		unsigned long		chunksize;

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

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

	} bitmap_info;



	struct list_head		all_mddevs;

drivers/md/raid1.c

+2 −1
Original line number Diff line number Diff line
@@ -943,7 +943,8 @@ static int make_request(struct request_queue *q, struct bio * bio) 


	/* do behind I/O ? */

	if (bitmap &&

	    atomic_read(&bitmap->behind_writes) < bitmap->max_write_behind &&

	    (atomic_read(&bitmap->behind_writes)

	     < mddev->bitmap_info.max_write_behind) &&

	    (behind_pages = alloc_behind_pages(bio)) != NULL)

		set_bit(R1BIO_BehindIO, &r1_bio->state);