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

Commit e64e4018 authored by Andy Shevchenko's avatar Andy Shevchenko Committed by Dmitry Torokhov
Browse files

md: Avoid namespace collision with bitmap API 



bitmap API (include/linux/bitmap.h) has 'bitmap' prefix for its methods.

On the other hand MD bitmap API is special case.
Adding 'md' prefix to it to avoid name space collision.

No functional changes intended.

Signed-off-by: default avatarAndy Shevchenko <andriy.shevchenko@linux.intel.com>
Acked-by: default avatarShaohua Li <shli@kernel.org>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
parent 5cc9cdf6

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 */