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: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Acked-by: Shaohua Li <shli@kernel.org>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>

1 files changed, 16 insertions, 19 deletions

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index e9e3308cb0a7..136294139d05 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -385,10 +385,10 @@ static void close_write(struct r1bio *r1_bio)
                 r1_bio->behind_master_bio = NULL;
         }
         /* clear the bitmap if all writes complete successfully */
-        bitmap_endwrite(r1_bio->mddev->bitmap, r1_bio->sector,
-                        r1_bio->sectors,
-                        !test_bit(R1BIO_Degraded, &r1_bio->state),
-                        test_bit(R1BIO_BehindIO, &r1_bio->state));
+        md_bitmap_endwrite(r1_bio->mddev->bitmap, r1_bio->sector,
+                           r1_bio->sectors,
+                           !test_bit(R1BIO_Degraded, &r1_bio->state),
+                           test_bit(R1BIO_BehindIO, &r1_bio->state));
         md_write_end(r1_bio->mddev);
 }
 
@@ -781,7 +781,7 @@ static int raid1_congested(struct mddev *mddev, int bits)
 static void flush_bio_list(struct r1conf *conf, struct bio *bio)
 {
         /* flush any pending bitmap writes to disk before proceeding w/ I/O */
-        bitmap_unplug(conf->mddev->bitmap);
+        md_bitmap_unplug(conf->mddev->bitmap);
         wake_up(&conf->wait_barrier);
 
         while (bio) { /* submit pending writes */
@@ -1470,10 +1470,8 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
                                 alloc_behind_master_bio(r1_bio, bio);
                         }
 
-                        bitmap_startwrite(bitmap, r1_bio->sector,
-                                          r1_bio->sectors,
-                                          test_bit(R1BIO_BehindIO,
-                                                   &r1_bio->state));
+                        md_bitmap_startwrite(bitmap, r1_bio->sector, r1_bio->sectors,
+                                             test_bit(R1BIO_BehindIO, &r1_bio->state));
                         first_clone = 0;
                 }
 
@@ -1881,8 +1879,7 @@ static void end_sync_write(struct bio *bio)
                 long sectors_to_go = r1_bio->sectors;
                 /* make sure these bits doesn't get cleared. */
                 do {
-                        bitmap_end_sync(mddev->bitmap, s,
-                                        &sync_blocks, 1);
+                        md_bitmap_end_sync(mddev->bitmap, s, &sync_blocks, 1);
                         s += sync_blocks;
                         sectors_to_go -= sync_blocks;
                 } while (sectors_to_go > 0);
@@ -2629,12 +2626,12 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
                  * We can find the current addess in mddev->curr_resync
                  */
                 if (mddev->curr_resync < max_sector) /* aborted */
-                        bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
-                                                &sync_blocks, 1);
+                        md_bitmap_end_sync(mddev->bitmap, mddev->curr_resync,
+                                           &sync_blocks, 1);
                 else /* completed sync */
                         conf->fullsync = 0;
 
-                bitmap_close_sync(mddev->bitmap);
+                md_bitmap_close_sync(mddev->bitmap);
                 close_sync(conf);
 
                 if (mddev_is_clustered(mddev)) {
@@ -2654,7 +2651,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
         /* before building a request, check if we can skip these blocks..
          * This call the bitmap_start_sync doesn't actually record anything
          */
-        if (!bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 1) &&
+        if (!md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, 1) &&
             !conf->fullsync && !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
                 /* We can skip this block, and probably several more */
                 *skipped = 1;
@@ -2672,7 +2669,7 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
          * sector_nr + two times RESYNC_SECTORS
          */
 
-        bitmap_cond_end_sync(mddev->bitmap, sector_nr,
+        md_bitmap_cond_end_sync(mddev->bitmap, sector_nr,
                 mddev_is_clustered(mddev) && (sector_nr + 2 * RESYNC_SECTORS > conf->cluster_sync_high));
 
 
@@ -2831,8 +2828,8 @@ static sector_t raid1_sync_request(struct mddev *mddev, sector_t sector_nr,
                 if (len == 0)
                         break;
                 if (sync_blocks == 0) {
-                        if (!bitmap_start_sync(mddev->bitmap, sector_nr,
-                                               &sync_blocks, still_degraded) &&
+                        if (!md_bitmap_start_sync(mddev->bitmap, sector_nr,
+                                                  &sync_blocks, still_degraded) &&
                             !conf->fullsync &&
                             !test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
                                 break;
@@ -3171,7 +3168,7 @@ static int raid1_resize(struct mddev *mddev, sector_t sectors)
             mddev->array_sectors > newsize)
                 return -EINVAL;
         if (mddev->bitmap) {
-                int ret = bitmap_resize(mddev->bitmap, newsize, 0, 0);
+                int ret = md_bitmap_resize(mddev->bitmap, newsize, 0, 0);
                 if (ret)
                         return ret;
         }