Commit 5d81a787 authored by Dmitry Torokhov's avatar Dmitry Torokhov
Browse files

Merge branch 'ib/4.17-bitmap' into next 

Bring in bitmap API improvements.
parents 955c594e c42b65e3

drivers/md/dm-raid.c

+3 −3
Original line number Diff line number Diff line
@@ -3859,7 +3859,7 @@ static int __load_dirty_region_bitmap(struct raid_set *rs) 
	/* Try loading the bitmap unless "raid0", which does not have one */

	if (!rs_is_raid0(rs) &&

	    !test_and_set_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags)) {

		r = bitmap_load(&rs->md);

		r = md_bitmap_load(&rs->md);

		if (r)

			DMERR("Failed to load bitmap");

	}
@@ -3987,7 +3987,7 @@ static int raid_preresume(struct dm_target *ti) 
	/* Resize bitmap to adjust to changed region size (aka MD bitmap chunksize) */

	if (test_bit(RT_FLAG_RS_BITMAP_LOADED, &rs->runtime_flags) && mddev->bitmap &&

	    mddev->bitmap_info.chunksize != to_bytes(rs->requested_bitmap_chunk_sectors)) {

		r = bitmap_resize(mddev->bitmap, mddev->dev_sectors,

		r = md_bitmap_resize(mddev->bitmap, mddev->dev_sectors,

				     to_bytes(rs->requested_bitmap_chunk_sectors), 0);

		if (r)

			DMERR("Failed to resize bitmap");

drivers/md/md-bitmap.c

+148 −157

File changed.

Preview size limit exceeded, changes collapsed.

drivers/md/md-bitmap.h

+30 −30
Original line number Diff line number Diff line
@@ -236,43 +236,43 @@ struct bitmap { 
/* the bitmap API */



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

struct bitmap *bitmap_create(struct mddev *mddev, int slot);

int bitmap_load(struct mddev *mddev);

void bitmap_flush(struct mddev *mddev);

void bitmap_destroy(struct mddev *mddev);

struct bitmap *md_bitmap_create(struct mddev *mddev, int slot);

int md_bitmap_load(struct mddev *mddev);

void md_bitmap_flush(struct mddev *mddev);

void md_bitmap_destroy(struct mddev *mddev);



void bitmap_print_sb(struct bitmap *bitmap);

void bitmap_update_sb(struct bitmap *bitmap);

void bitmap_status(struct seq_file *seq, struct bitmap *bitmap);

void md_bitmap_print_sb(struct bitmap *bitmap);

void md_bitmap_update_sb(struct bitmap *bitmap);

void md_bitmap_status(struct seq_file *seq, struct bitmap *bitmap);



int  bitmap_setallbits(struct bitmap *bitmap);

void bitmap_write_all(struct bitmap *bitmap);

int  md_bitmap_setallbits(struct bitmap *bitmap);

void md_bitmap_write_all(struct bitmap *bitmap);



void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e);

void md_bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e);



/* these are exported */

int bitmap_startwrite(struct bitmap *bitmap, sector_t offset,

int md_bitmap_startwrite(struct bitmap *bitmap, sector_t offset,

			 unsigned long sectors, int behind);

void bitmap_endwrite(struct bitmap *bitmap, sector_t offset,

void md_bitmap_endwrite(struct bitmap *bitmap, sector_t offset,

			unsigned long sectors, int success, int behind);

int bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded);

void bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted);

void bitmap_close_sync(struct bitmap *bitmap);

void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force);

void bitmap_sync_with_cluster(struct mddev *mddev,

int md_bitmap_start_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int degraded);

void md_bitmap_end_sync(struct bitmap *bitmap, sector_t offset, sector_t *blocks, int aborted);

void md_bitmap_close_sync(struct bitmap *bitmap);

void md_bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector, bool force);

void md_bitmap_sync_with_cluster(struct mddev *mddev,

				 sector_t old_lo, sector_t old_hi,

				 sector_t new_lo, sector_t new_hi);



void bitmap_unplug(struct bitmap *bitmap);

void bitmap_daemon_work(struct mddev *mddev);

void md_bitmap_unplug(struct bitmap *bitmap);

void md_bitmap_daemon_work(struct mddev *mddev);



int bitmap_resize(struct bitmap *bitmap, sector_t blocks,

int md_bitmap_resize(struct bitmap *bitmap, sector_t blocks,

		     int chunksize, int init);

struct bitmap *get_bitmap_from_slot(struct mddev *mddev, int slot);

int bitmap_copy_from_slot(struct mddev *mddev, int slot,

int md_bitmap_copy_from_slot(struct mddev *mddev, int slot,

			     sector_t *lo, sector_t *hi, bool clear_bits);

void bitmap_free(struct bitmap *bitmap);

void bitmap_wait_behind_writes(struct mddev *mddev);

void md_bitmap_free(struct bitmap *bitmap);

void md_bitmap_wait_behind_writes(struct mddev *mddev);

#endif



#endif

drivers/md/md-cluster.c

+8 −10
Original line number Diff line number Diff line
@@ -326,7 +326,7 @@ static void recover_bitmaps(struct md_thread *thread) 
					str, ret);

			goto clear_bit;

		}

		ret = bitmap_copy_from_slot(mddev, slot, &lo, &hi, true);

		ret = md_bitmap_copy_from_slot(mddev, slot, &lo, &hi, true);

		if (ret) {

			pr_err("md-cluster: Could not copy data from bitmap %d\n", slot);

			goto clear_bit;
@@ -480,9 +480,7 @@ static void process_suspend_info(struct mddev *mddev, 
	 * resync thread is running in another node,

	 * so we don't need to do the resync again

	 * with the same section */

	bitmap_sync_with_cluster(mddev, cinfo->sync_low,

					cinfo->sync_hi,

					lo, hi);

	md_bitmap_sync_with_cluster(mddev, cinfo->sync_low, cinfo->sync_hi, lo, hi);

	cinfo->sync_low = lo;

	cinfo->sync_hi = hi;
@@ -829,7 +827,7 @@ static int gather_all_resync_info(struct mddev *mddev, int total_slots) 
		}



		/* Read the disk bitmap sb and check if it needs recovery */

		ret = bitmap_copy_from_slot(mddev, i, &lo, &hi, false);

		ret = md_bitmap_copy_from_slot(mddev, i, &lo, &hi, false);

		if (ret) {

			pr_warn("md-cluster: Could not gather bitmaps from slot %d", i);

			lockres_free(bm_lockres);
@@ -1127,13 +1125,13 @@ static int cluster_check_sync_size(struct mddev *mddev) 
		bm_lockres = lockres_init(mddev, str, NULL, 1);

		if (!bm_lockres) {

			pr_err("md-cluster: Cannot initialize %s\n", str);

			bitmap_free(bitmap);

			md_bitmap_free(bitmap);

			return -1;

		}

		bm_lockres->flags |= DLM_LKF_NOQUEUE;

		rv = dlm_lock_sync(bm_lockres, DLM_LOCK_PW);

		if (!rv)

			bitmap_update_sb(bitmap);

			md_bitmap_update_sb(bitmap);

		lockres_free(bm_lockres);



		sb = kmap_atomic(bitmap->storage.sb_page);
@@ -1141,11 +1139,11 @@ static int cluster_check_sync_size(struct mddev *mddev) 
			sync_size = sb->sync_size;

		else if (sync_size != sb->sync_size) {

			kunmap_atomic(sb);

			bitmap_free(bitmap);

			md_bitmap_free(bitmap);

			return -1;

		}

		kunmap_atomic(sb);

		bitmap_free(bitmap);

		md_bitmap_free(bitmap);

	}



	return (my_sync_size == sync_size) ? 0 : -1;
@@ -1442,7 +1440,7 @@ static int gather_bitmaps(struct md_rdev *rdev) 
	for (sn = 0; sn < mddev->bitmap_info.nodes; sn++) {

		if (sn == (cinfo->slot_number - 1))

			continue;

		err = bitmap_copy_from_slot(mddev, sn, &lo, &hi, false);

		err = md_bitmap_copy_from_slot(mddev, sn, &lo, &hi, false);

		if (err) {

			pr_warn("md-cluster: Could not gather bitmaps from slot %d", sn);

			goto out;

drivers/md/md.c

+22 −22
Original line number Diff line number Diff line
@@ -2560,7 +2560,7 @@ void md_update_sb(struct mddev *mddev, int force_change) 
	if (mddev->queue)

		blk_add_trace_msg(mddev->queue, "md md_update_sb");

rewrite:

	bitmap_update_sb(mddev->bitmap);

	md_bitmap_update_sb(mddev->bitmap);

	rdev_for_each(rdev, mddev) {

		char b[BDEVNAME_SIZE];
@@ -4372,10 +4372,10 @@ bitmap_store(struct mddev *mddev, const char *buf, size_t len) 
			if (buf == end) break;

		}

		if (*end && !isspace(*end)) break;

		bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);

		md_bitmap_dirty_bits(mddev->bitmap, chunk, end_chunk);

		buf = skip_spaces(end);

	}

	bitmap_unplug(mddev->bitmap); /* flush the bits to disk */

	md_bitmap_unplug(mddev->bitmap); /* flush the bits to disk */

out:

	mddev_unlock(mddev);

	return len;
@@ -5588,7 +5588,7 @@ int md_run(struct mddev *mddev) 
	    (mddev->bitmap_info.file || mddev->bitmap_info.offset)) {

		struct bitmap *bitmap;



		bitmap = bitmap_create(mddev, -1);

		bitmap = md_bitmap_create(mddev, -1);

		if (IS_ERR(bitmap)) {

			err = PTR_ERR(bitmap);

			pr_warn("%s: failed to create bitmap (%d)\n",
@@ -5603,7 +5603,7 @@ int md_run(struct mddev *mddev) 
			pers->free(mddev, mddev->private);

		mddev->private = NULL;

		module_put(pers->owner);

		bitmap_destroy(mddev);

		md_bitmap_destroy(mddev);

		goto abort;

	}

	if (mddev->queue) {
@@ -5688,9 +5688,9 @@ static int do_md_run(struct mddev *mddev) 
	err = md_run(mddev);

	if (err)

		goto out;

	err = bitmap_load(mddev);

	err = md_bitmap_load(mddev);

	if (err) {

		bitmap_destroy(mddev);

		md_bitmap_destroy(mddev);

		goto out;

	}
@@ -5832,7 +5832,7 @@ static void __md_stop_writes(struct mddev *mddev) 
		mddev->pers->quiesce(mddev, 1);

		mddev->pers->quiesce(mddev, 0);

	}

	bitmap_flush(mddev);

	md_bitmap_flush(mddev);



	if (mddev->ro == 0 &&

	    ((!mddev->in_sync && !mddev_is_clustered(mddev)) ||
@@ -5854,7 +5854,7 @@ EXPORT_SYMBOL_GPL(md_stop_writes); 


static void mddev_detach(struct mddev *mddev)

{

	bitmap_wait_behind_writes(mddev);

	md_bitmap_wait_behind_writes(mddev);

	if (mddev->pers && mddev->pers->quiesce) {

		mddev->pers->quiesce(mddev, 1);

		mddev->pers->quiesce(mddev, 0);
@@ -5867,7 +5867,7 @@ static void mddev_detach(struct mddev *mddev) 
static void __md_stop(struct mddev *mddev)

{

	struct md_personality *pers = mddev->pers;

	bitmap_destroy(mddev);

	md_bitmap_destroy(mddev);

	mddev_detach(mddev);

	/* Ensure ->event_work is done */

	flush_workqueue(md_misc_wq);
@@ -6681,21 +6681,21 @@ static int set_bitmap_file(struct mddev *mddev, int fd) 
		if (fd >= 0) {

			struct bitmap *bitmap;



			bitmap = bitmap_create(mddev, -1);

			bitmap = md_bitmap_create(mddev, -1);

			mddev_suspend(mddev);

			if (!IS_ERR(bitmap)) {

				mddev->bitmap = bitmap;

				err = bitmap_load(mddev);

				err = md_bitmap_load(mddev);

			} else

				err = PTR_ERR(bitmap);

			if (err) {

				bitmap_destroy(mddev);

				md_bitmap_destroy(mddev);

				fd = -1;

			}

			mddev_resume(mddev);

		} else if (fd < 0) {

			mddev_suspend(mddev);

			bitmap_destroy(mddev);

			md_bitmap_destroy(mddev);

			mddev_resume(mddev);

		}

	}
@@ -6981,15 +6981,15 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info) 
				mddev->bitmap_info.default_offset;

			mddev->bitmap_info.space =

				mddev->bitmap_info.default_space;

			bitmap = bitmap_create(mddev, -1);

			bitmap = md_bitmap_create(mddev, -1);

			mddev_suspend(mddev);

			if (!IS_ERR(bitmap)) {

				mddev->bitmap = bitmap;

				rv = bitmap_load(mddev);

				rv = md_bitmap_load(mddev);

			} else

				rv = PTR_ERR(bitmap);

			if (rv)

				bitmap_destroy(mddev);

				md_bitmap_destroy(mddev);

			mddev_resume(mddev);

		} else {

			/* remove the bitmap */
@@ -7014,7 +7014,7 @@ static int update_array_info(struct mddev *mddev, mdu_array_info_t *info) 
				md_cluster_ops->leave(mddev);

			}

			mddev_suspend(mddev);

			bitmap_destroy(mddev);

			md_bitmap_destroy(mddev);

			mddev_resume(mddev);

			mddev->bitmap_info.offset = 0;

		}
@@ -7877,7 +7877,7 @@ static int md_seq_show(struct seq_file *seq, void *v) 
		} else

			seq_printf(seq, "\n       ");



		bitmap_status(seq, mddev->bitmap);

		md_bitmap_status(seq, mddev->bitmap);



		seq_printf(seq, "\n");

	}
@@ -8748,7 +8748,7 @@ void md_check_recovery(struct mddev *mddev) 
		return;



	if (mddev->bitmap)

		bitmap_daemon_work(mddev);

		md_bitmap_daemon_work(mddev);



	if (signal_pending(current)) {

		if (mddev->pers->sync_request && !mddev->external) {
@@ -8885,7 +8885,7 @@ void md_check_recovery(struct mddev *mddev) 
				 * which has the bitmap stored on all devices.

				 * So make sure all bitmap pages get written

				 */

				bitmap_write_all(mddev->bitmap);

				md_bitmap_write_all(mddev->bitmap);

			}

			INIT_WORK(&mddev->del_work, md_start_sync);

			queue_work(md_misc_wq, &mddev->del_work);
@@ -9133,7 +9133,7 @@ static void check_sb_changes(struct mddev *mddev, struct md_rdev *rdev) 
		if (ret)

			pr_info("md-cluster: resize failed\n");

		else

			bitmap_update_sb(mddev->bitmap);

			md_bitmap_update_sb(mddev->bitmap);

	}



	/* Check for change of roles in the active devices */