LU-9859 lfsck: use Linux bitmap API

Replace the use of the libcfs specific bitmap API used by lfsck
with the standard Linux bitmap API.

Change-Id: Icc0d9d2ceb9ca7b4b94dd728d9b9c499cf4d2414
Signed-off-by: James Simmons <jsimmons@infradead.org>
Reviewed-on: https://review.whamcloud.com/47579
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Lai Siyao <lai.siyao@whamcloud.com>
Reviewed-by: Alex Zhuravlev <bzzz@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/lfsck/lfsck_engine.c b/lustre/lfsck/lfsck_engine.c
index 7487ea4..49e1303 100644 (file)
--- a/lustre/lfsck/lfsck_engine.c
+++ b/lustre/lfsck/lfsck_engine.c
@@ -1268,20 +1268,20 @@ static int lfsck_assistant_notify_others(const struct lu_env *env,
                                         struct lfsck_component *com,
                                         struct lfsck_request *lr)
 {
                                         struct lfsck_component *com,
                                         struct lfsck_request *lr)
 {

-       struct lfsck_thread_info          *info  = lfsck_env_info(env);
-       struct lfsck_async_interpret_args *laia  = &info->lti_laia;
-       struct lfsck_instance             *lfsck = com->lc_lfsck;
-       struct lfsck_assistant_data       *lad   = com->lc_data;
-       struct lfsck_bookmark             *bk    = &lfsck->li_bookmark_ram;
-       struct ptlrpc_request_set         *set;
-       struct lfsck_tgt_descs            *ltds;
-       struct lfsck_tgt_desc             *ltd;
-       struct lfsck_tgt_desc             *next;
-       __u32                              idx;
-       int                                rc    = 0;
-       int                                rc1   = 0;
-       ENTRY;
+       struct lfsck_thread_info *info = lfsck_env_info(env);
+       struct lfsck_async_interpret_args *laia = &info->lti_laia;
+       struct lfsck_instance *lfsck = com->lc_lfsck;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+       struct ptlrpc_request_set *set;
+       struct lfsck_tgt_descs *ltds;
+       struct lfsck_tgt_desc *ltd;
+       struct lfsck_tgt_desc *next;
+       int idx;
+       int rc = 0;
+       int rc1 = 0;

 
 

+       ENTRY;

        set = ptlrpc_prep_set();
        if (set == NULL)
                RETURN(-ENOMEM);
        set = ptlrpc_prep_set();
        if (set == NULL)
                RETURN(-ENOMEM);


@@ -1309,7 +1309,8 @@ static int lfsck_assistant_notify_others(const struct lu_env *env,
                ltds = &lfsck->li_ost_descs;
                laia->laia_ltds = ltds;
                down_read(&ltds->ltd_rw_sem);
                ltds = &lfsck->li_ost_descs;
                laia->laia_ltds = ltds;
                down_read(&ltds->ltd_rw_sem);

-               cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+               for_each_set_bit(idx, ltds->ltd_tgts_bitmap,
+                                ltds->ltd_tgts_mask_len) {

                        ltd = lfsck_tgt_get(ltds, idx);
                        LASSERT(ltd != NULL);
 
                        ltd = lfsck_tgt_get(ltds, idx);
                        LASSERT(ltd != NULL);
 


@@ -1343,7 +1344,8 @@ next:
                ltds = &lfsck->li_mdt_descs;
                spin_lock(&ltds->ltd_lock);
                if (com->lc_type == LFSCK_TYPE_LAYOUT) {
                ltds = &lfsck->li_mdt_descs;
                spin_lock(&ltds->ltd_lock);
                if (com->lc_type == LFSCK_TYPE_LAYOUT) {

-                       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+                       for_each_set_bit(idx, ltds->ltd_tgts_bitmap,
+                                        ltds->ltd_tgts_mask_len) {

                                ltd = lfsck_ltd2tgt(ltds, idx);
                                LASSERT(ltd != NULL);
 
                                ltd = lfsck_ltd2tgt(ltds, idx);
                                LASSERT(ltd != NULL);
 


@@ -1356,7 +1358,8 @@ next:
                                              &lad->lad_mdt_phase1_list);
                        }
                } else {
                                              &lad->lad_mdt_phase1_list);
                        }
                } else {

-                       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+                       for_each_set_bit(idx, ltds->ltd_tgts_bitmap,
+                                        ltds->ltd_tgts_mask_len) {

                                ltd = lfsck_ltd2tgt(ltds, idx);
                                LASSERT(ltd != NULL);
 
                                ltd = lfsck_ltd2tgt(ltds, idx);
                                LASSERT(ltd != NULL);
 

diff --git a/lustre/lfsck/lfsck_internal.h b/lustre/lfsck/lfsck_internal.h
index e6a8a48..cffe2c7 100644 (file)
--- a/lustre/lfsck/lfsck_internal.h
+++ b/lustre/lfsck/lfsck_internal.h
@@ -489,7 +489,8 @@ struct lfsck_tgt_descs {
        struct lfsck_tgt_desc_idx       *ltd_tgts_idx[TGT_PTRS];
 
        /* bitmap of TGTs available */
        struct lfsck_tgt_desc_idx       *ltd_tgts_idx[TGT_PTRS];
 
        /* bitmap of TGTs available */

-       struct cfs_bitmap                       *ltd_tgts_bitmap;
+       unsigned long                   *ltd_tgts_bitmap;
+       u32                              ltd_tgts_mask_len;

 
        /* for lfsck_tgt_desc::ltd_xxx_list */
        spinlock_t                       ltd_lock;
 
        /* for lfsck_tgt_desc::ltd_xxx_list */
        spinlock_t                       ltd_lock;


@@ -851,7 +852,8 @@ struct lfsck_assistant_data {
 
        const struct lfsck_assistant_operations *lad_ops;
 
 
        const struct lfsck_assistant_operations *lad_ops;
 

-       struct cfs_bitmap                               *lad_bitmap;
+       unsigned long                           *lad_bitmap;
+       unsigned int                             lad_bitmap_count;

 
        __u32                                    lad_touch_gen;
        int                                      lad_prefetched;
 
        __u32                                    lad_touch_gen;
        int                                      lad_prefetched;


@@ -1436,14 +1438,14 @@ static inline void lfsck_lad_set_bitmap(const struct lu_env *env,
                                        struct lfsck_component *com,
                                        __u32 index)
 {
                                        struct lfsck_component *com,
                                        __u32 index)
 {

-       struct lfsck_assistant_data     *lad    = com->lc_data;
-       struct cfs_bitmap               *bitmap = lad->lad_bitmap;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       unsigned long *bitmap = lad->lad_bitmap;

 
        LASSERT(com->lc_lfsck->li_master);
 
        LASSERT(com->lc_lfsck->li_master);

-       LASSERT(bitmap != NULL);
+       LASSERT(bitmap);

 
 

-       if (likely(bitmap->size > index)) {
-               cfs_bitmap_set(bitmap, index);
+       if (likely(lad->lad_bitmap_count > index)) {
+               set_bit(index, bitmap);

                set_bit(LAD_INCOMPLETE, &lad->lad_flags);
        } else if (com->lc_type == LFSCK_TYPE_NAMESPACE) {
                struct lfsck_namespace *ns = com->lc_file_ram;
                set_bit(LAD_INCOMPLETE, &lad->lad_flags);
        } else if (com->lc_type == LFSCK_TYPE_NAMESPACE) {
                struct lfsck_namespace *ns = com->lc_file_ram;


@@ -1453,7 +1455,7 @@ static inline void lfsck_lad_set_bitmap(const struct lu_env *env,
 
        CDEBUG(D_LFSCK, "%s: %s LFSCK set bitmap (%p/%u) for idx %u\n",
               lfsck_lfsck2name(com->lc_lfsck), lad->lad_name, bitmap,
 
        CDEBUG(D_LFSCK, "%s: %s LFSCK set bitmap (%p/%u) for idx %u\n",
               lfsck_lfsck2name(com->lc_lfsck), lad->lad_name, bitmap,

-              bitmap->size, index);
+              lad->lad_bitmap_count, index);

 }
 
 static inline int lfsck_links_read(const struct lu_env *env,
 }
 
 static inline int lfsck_links_read(const struct lu_env *env,

diff --git a/lustre/lfsck/lfsck_layout.c b/lustre/lfsck/lfsck_layout.c
index 034f63a..70d5452 100644 (file)
--- a/lustre/lfsck/lfsck_layout.c
+++ b/lustre/lfsck/lfsck_layout.c
@@ -285,7 +285,7 @@ static void lfsck_layout_assistant_sync_failures(const struct lu_env *env,
                GOTO(out, rc = -ENOMEM);
 
        down_read(&ltds->ltd_rw_sem);
                GOTO(out, rc = -ENOMEM);
 
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(lad->lad_bitmap, idx) {
+       for_each_set_bit(idx, lad->lad_bitmap, lad->lad_bitmap_count) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                if (unlikely(!ltd))
                        continue;
                ltd = lfsck_ltd2tgt(ltds, idx);
                if (unlikely(!ltd))
                        continue;


@@ -946,54 +946,53 @@ static void lfsck_layout_cpu_to_le(struct lfsck_layout *des,
 static int lfsck_layout_load_bitmap(const struct lu_env *env,
                                    struct lfsck_component *com)
 {
 static int lfsck_layout_load_bitmap(const struct lu_env *env,
                                    struct lfsck_component *com)
 {

-       struct dt_object                *obj    = com->lc_obj;
-       struct lfsck_assistant_data     *lad    = com->lc_data;
-       struct lfsck_layout             *lo     = com->lc_file_ram;
-       struct cfs_bitmap                       *bitmap = lad->lad_bitmap;
-       loff_t                           pos    = com->lc_file_size;
-       ssize_t                          size;
-       __u32                            nbits;
-       int                              rc;
-       ENTRY;
+       struct dt_object *obj = com->lc_obj;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       struct lfsck_layout *lo = com->lc_file_ram;
+       unsigned long *bitmap = lad->lad_bitmap;
+       loff_t pos = com->lc_file_size;
+       ssize_t size;
+       __u32 nbits;
+       int rc;

 
 

-       if (com->lc_lfsck->li_ost_descs.ltd_tgts_bitmap->size >
-           lo->ll_bitmap_size)
-               nbits = com->lc_lfsck->li_ost_descs.ltd_tgts_bitmap->size;
+       ENTRY;
+       if (com->lc_lfsck->li_ost_descs.ltd_tgts_mask_len > lo->ll_bitmap_size)
+               nbits = com->lc_lfsck->li_ost_descs.ltd_tgts_mask_len;

        else
                nbits = lo->ll_bitmap_size;
 
        if (unlikely(nbits < BITS_PER_LONG))
                nbits = BITS_PER_LONG;
 
        else
                nbits = lo->ll_bitmap_size;
 
        if (unlikely(nbits < BITS_PER_LONG))
                nbits = BITS_PER_LONG;
 

-       if (nbits > bitmap->size) {
-               __u32 new_bits = bitmap->size;
-               struct cfs_bitmap *new_bitmap;
+       if (nbits > lad->lad_bitmap_count) {
+               u32 new_bits = lad->lad_bitmap_count;
+               unsigned long *new_bitmap;

 
                while (new_bits < nbits)
                        new_bits <<= 1;
 
 
                while (new_bits < nbits)
                        new_bits <<= 1;
 

-               new_bitmap = CFS_ALLOCATE_BITMAP(new_bits);
+               new_bitmap = bitmap_zalloc(new_bits, GFP_KERNEL);

                if (new_bitmap == NULL)
                        RETURN(-ENOMEM);
 
                lad->lad_bitmap = new_bitmap;
                if (new_bitmap == NULL)
                        RETURN(-ENOMEM);
 
                lad->lad_bitmap = new_bitmap;

-               CFS_FREE_BITMAP(bitmap);
+               lad->lad_bitmap_count = new_bits;
+               bitmap_free(bitmap);

                bitmap = new_bitmap;
        }
 
        if (lo->ll_bitmap_size == 0) {
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
                bitmap = new_bitmap;
        }
 
        if (lo->ll_bitmap_size == 0) {
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);

-               CFS_RESET_BITMAP(bitmap);
-
+               bitmap_zero(bitmap, lad->lad_bitmap_count);

                RETURN(0);
        }
 
        size = (lo->ll_bitmap_size + 7) >> 3;
                RETURN(0);
        }
 
        size = (lo->ll_bitmap_size + 7) >> 3;

-       rc = dt_read(env, obj, lfsck_buf_get(env, bitmap->data, size), &pos);
+       rc = dt_read(env, obj, lfsck_buf_get(env, bitmap, size), &pos);

        if (rc != size)
                RETURN(rc >= 0 ? -EINVAL : rc);
 
        if (rc != size)
                RETURN(rc >= 0 ? -EINVAL : rc);
 

-       if (cfs_bitmap_check_empty(bitmap))
+       if (bitmap_empty(bitmap, lad->lad_bitmap_count))

                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
        else
                set_bit(LAD_INCOMPLETE, &lad->lad_flags);
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
        else
                set_bit(LAD_INCOMPLETE, &lad->lad_flags);


@@ -1069,24 +1068,24 @@ static int lfsck_layout_load(const struct lu_env *env,
 static int lfsck_layout_store(const struct lu_env *env,
                              struct lfsck_component *com)
 {
 static int lfsck_layout_store(const struct lu_env *env,
                              struct lfsck_component *com)
 {

-       struct dt_object        *obj    = com->lc_obj;
-       struct lfsck_instance   *lfsck  = com->lc_lfsck;
-       struct lfsck_layout     *lo_ram = com->lc_file_ram;
-       struct lfsck_layout     *lo     = com->lc_file_disk;
-       struct thandle          *th;
-       struct dt_device        *dev    = lfsck_obj2dev(obj);
-       struct cfs_bitmap       *bitmap = NULL;
-       loff_t                   pos;
-       ssize_t                  size   = com->lc_file_size;
-       __u32                    nbits  = 0;
-       int                      rc;
-       ENTRY;
+       struct dt_object *obj = com->lc_obj;
+       struct lfsck_instance *lfsck = com->lc_lfsck;
+       struct lfsck_layout *lo_ram = com->lc_file_ram;
+       struct lfsck_layout *lo = com->lc_file_disk;
+       struct thandle *th;
+       struct dt_device *dev = lfsck_obj2dev(obj);
+       unsigned long *bitmap = NULL;
+       loff_t pos;
+       ssize_t size = com->lc_file_size;
+       __u32 nbits = 0;
+       int rc;

 
 

+       ENTRY;

        if (lfsck->li_master) {
                struct lfsck_assistant_data *lad = com->lc_data;
 
                bitmap = lad->lad_bitmap;
        if (lfsck->li_master) {
                struct lfsck_assistant_data *lad = com->lc_data;
 
                bitmap = lad->lad_bitmap;

-               nbits = bitmap->size;
+               nbits = lad->lad_bitmap_count;

 
                LASSERT(nbits > 0);
                LASSERTF((nbits & 7) == 0, "Invalid nbits %u\n", nbits);
 
                LASSERT(nbits > 0);
                LASSERTF((nbits & 7) == 0, "Invalid nbits %u\n", nbits);


@@ -1105,7 +1104,7 @@ static int lfsck_layout_store(const struct lu_env *env,
 
        if (bitmap != NULL) {
                rc = dt_declare_record_write(env, obj,
 
        if (bitmap != NULL) {
                rc = dt_declare_record_write(env, obj,

-                               lfsck_buf_get(env, bitmap->data, nbits >> 3),
+                               lfsck_buf_get(env, bitmap, nbits >> 3),

                                (loff_t)size, th);
                if (rc != 0)
                        GOTO(out, rc);
                                (loff_t)size, th);
                if (rc != 0)
                        GOTO(out, rc);


@@ -1123,7 +1122,7 @@ static int lfsck_layout_store(const struct lu_env *env,
        if (bitmap != NULL) {
                pos = size;
                rc = dt_record_write(env, obj,
        if (bitmap != NULL) {
                pos = size;
                rc = dt_record_write(env, obj,

-                               lfsck_buf_get(env, bitmap->data, nbits >> 3),
+                               lfsck_buf_get(env, bitmap, nbits >> 3),

                                &pos, th);
        }
 
                                &pos, th);
        }
 


@@ -3306,7 +3305,7 @@ static int lfsck_layout_scan_orphan(const struct lu_env *env,
               "scanning for OST%04x\n",
               lfsck_lfsck2name(lfsck), ltd->ltd_index);
 
               "scanning for OST%04x\n",
               lfsck_lfsck2name(lfsck), ltd->ltd_index);
 

-       if (cfs_bitmap_check(lad->lad_bitmap, ltd->ltd_index)) {
+       if (test_bit(ltd->ltd_index, lad->lad_bitmap)) {

                CDEBUG(D_LFSCK, "%s: layout LFSCK assistant skip the orphan "
                       "scanning for OST%04x\n",
                       lfsck_lfsck2name(lfsck), ltd->ltd_index);
                CDEBUG(D_LFSCK, "%s: layout LFSCK assistant skip the orphan "
                       "scanning for OST%04x\n",
                       lfsck_lfsck2name(lfsck), ltd->ltd_index);


@@ -5223,7 +5222,7 @@ static int lfsck_layout_reset(const struct lu_env *env,
                struct lfsck_assistant_data *lad = com->lc_data;
 
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
                struct lfsck_assistant_data *lad = com->lc_data;
 
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);

-               CFS_RESET_BITMAP(lad->lad_bitmap);
+               bitmap_zero(lad->lad_bitmap, lad->lad_bitmap_count);

        }
 
        rc = lfsck_layout_store(env, com);
        }
 
        rc = lfsck_layout_store(env, com);


@@ -6413,8 +6412,7 @@ static void lfsck_layout_master_data_release(const struct lu_env *env,
        }
        spin_unlock(&ltds->ltd_lock);
 
        }
        spin_unlock(&ltds->ltd_lock);
 

-       if (likely(lad->lad_bitmap != NULL))
-               CFS_FREE_BITMAP(lad->lad_bitmap);
+       bitmap_free(lad->lad_bitmap);

 
        OBD_FREE_PTR(lad);
 }
 
        OBD_FREE_PTR(lad);
 }


@@ -6762,7 +6760,7 @@ static int lfsck_layout_query_all(const struct lu_env *env,
 
        ltds = &com->lc_lfsck->li_mdt_descs;
        down_read(&ltds->ltd_rw_sem);
 
        ltds = &com->lc_lfsck->li_mdt_descs;
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -6773,7 +6771,7 @@ static int lfsck_layout_query_all(const struct lu_env *env,
 
        ltds = &com->lc_lfsck->li_ost_descs;
        down_read(&ltds->ltd_rw_sem);
 
        ltds = &com->lc_lfsck->li_ost_descs;
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 

diff --git a/lustre/lfsck/lfsck_lib.c b/lustre/lfsck/lfsck_lib.c
index 64da238..2830920 100644 (file)
--- a/lustre/lfsck/lfsck_lib.c
+++ b/lustre/lfsck/lfsck_lib.c
@@ -113,8 +113,8 @@ static int lfsck_tgt_descs_init(struct lfsck_tgt_descs *ltds)
        spin_lock_init(&ltds->ltd_lock);
        init_rwsem(&ltds->ltd_rw_sem);
        INIT_LIST_HEAD(&ltds->ltd_orphan);
        spin_lock_init(&ltds->ltd_lock);
        init_rwsem(&ltds->ltd_rw_sem);
        INIT_LIST_HEAD(&ltds->ltd_orphan);

-       ltds->ltd_tgts_bitmap = CFS_ALLOCATE_BITMAP(BITS_PER_LONG);
-       if (ltds->ltd_tgts_bitmap == NULL)
+       ltds->ltd_tgts_bitmap = bitmap_zalloc(BITS_PER_LONG, GFP_KERNEL);
+       if (!ltds->ltd_tgts_bitmap)

                return -ENOMEM;
 
        return 0;
                return -ENOMEM;
 
        return 0;


@@ -122,9 +122,9 @@ static int lfsck_tgt_descs_init(struct lfsck_tgt_descs *ltds)
 
 static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
 {
 
 static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
 {

-       struct lfsck_tgt_desc   *ltd;
-       struct lfsck_tgt_desc   *next;
-       int                      idx;
+       struct lfsck_tgt_desc *ltd;
+       struct lfsck_tgt_desc *next;
+       int idx;

 
        down_write(&ltds->ltd_rw_sem);
 
 
        down_write(&ltds->ltd_rw_sem);
 


@@ -134,13 +134,13 @@ static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
                lfsck_tgt_put(ltd);
        }
 
                lfsck_tgt_put(ltd);
        }
 

-       if (unlikely(ltds->ltd_tgts_bitmap == NULL)) {
+       if (unlikely(!ltds->ltd_tgts_bitmap)) {

                up_write(&ltds->ltd_rw_sem);
 
                return;
        }
 
                up_write(&ltds->ltd_rw_sem);
 
                return;
        }
 

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                if (likely(ltd != NULL)) {
                        LASSERT(list_empty(&ltd->ltd_layout_list));
                ltd = lfsck_ltd2tgt(ltds, idx);
                if (likely(ltd != NULL)) {
                        LASSERT(list_empty(&ltd->ltd_layout_list));


@@ -149,7 +149,7 @@ static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
                        LASSERT(list_empty(&ltd->ltd_namespace_phase_list));
 
                        ltds->ltd_tgtnr--;
                        LASSERT(list_empty(&ltd->ltd_namespace_phase_list));
 
                        ltds->ltd_tgtnr--;

-                       cfs_bitmap_clear(ltds->ltd_tgts_bitmap, idx);
+                       clear_bit(idx, ltds->ltd_tgts_bitmap);

                        lfsck_assign_tgt(ltds, NULL, idx);
                        lfsck_tgt_put(ltd);
                }
                        lfsck_assign_tgt(ltds, NULL, idx);
                        lfsck_tgt_put(ltd);
                }


@@ -165,7 +165,7 @@ static void lfsck_tgt_descs_fini(struct lfsck_tgt_descs *ltds)
                }
        }
 
                }
        }
 

-       CFS_FREE_BITMAP(ltds->ltd_tgts_bitmap);
+       bitmap_free(ltds->ltd_tgts_bitmap);

        ltds->ltd_tgts_bitmap = NULL;
        up_write(&ltds->ltd_rw_sem);
 }
        ltds->ltd_tgts_bitmap = NULL;
        up_write(&ltds->ltd_rw_sem);
 }


@@ -188,28 +188,31 @@ static int __lfsck_add_target(const struct lu_env *env,
        if (!locked)
                down_write(&ltds->ltd_rw_sem);
 
        if (!locked)
                down_write(&ltds->ltd_rw_sem);
 

-       LASSERT(ltds->ltd_tgts_bitmap != NULL);
+       LASSERT(ltds->ltd_tgts_bitmap);

 
 

-       if (index >= ltds->ltd_tgts_bitmap->size) {
-               __u32 newsize = max((__u32)ltds->ltd_tgts_bitmap->size,
-                                   (__u32)BITS_PER_LONG);
-               struct cfs_bitmap *old_bitmap = ltds->ltd_tgts_bitmap;
-               struct cfs_bitmap *new_bitmap;
+       if (index >= ltds->ltd_tgts_mask_len) {
+               u32 newsize = max_t(u32, ltds->ltd_tgts_mask_len,
+                                   BITS_PER_LONG);
+               unsigned long *old_bitmap = ltds->ltd_tgts_bitmap;
+               unsigned long *new_bitmap;

 
                while (newsize < index + 1)
                        newsize <<= 1;
 
 
                while (newsize < index + 1)
                        newsize <<= 1;
 

-               new_bitmap = CFS_ALLOCATE_BITMAP(newsize);
-               if (new_bitmap == NULL)
+               new_bitmap = bitmap_zalloc(newsize, GFP_KERNEL);
+               if (!new_bitmap)

                        GOTO(unlock, rc = -ENOMEM);
 
                        GOTO(unlock, rc = -ENOMEM);
 

-               if (ltds->ltd_tgtnr > 0)
-                       cfs_bitmap_copy(new_bitmap, old_bitmap);
+               if (ltds->ltd_tgtnr > 0) {
+                       bitmap_copy(new_bitmap, old_bitmap,
+                                   ltds->ltd_tgts_mask_len);
+               }

                ltds->ltd_tgts_bitmap = new_bitmap;
                ltds->ltd_tgts_bitmap = new_bitmap;

-               CFS_FREE_BITMAP(old_bitmap);
+               ltds->ltd_tgts_mask_len = newsize;
+               bitmap_free(old_bitmap);

        }
 
        }
 

-       if (cfs_bitmap_check(ltds->ltd_tgts_bitmap, index)) {
+       if (test_bit(index, ltds->ltd_tgts_bitmap)) {

                CERROR("%s: the device %s (%u) is registered already\n",
                       lfsck_lfsck2name(lfsck),
                       ltd->ltd_tgt->dd_lu_dev.ld_obd->obd_name, index);
                CERROR("%s: the device %s (%u) is registered already\n",
                       lfsck_lfsck2name(lfsck),
                       ltd->ltd_tgt->dd_lu_dev.ld_obd->obd_name, index);


@@ -223,7 +226,7 @@ static int __lfsck_add_target(const struct lu_env *env,
        }
 
        lfsck_assign_tgt(ltds, ltd, index);
        }
 
        lfsck_assign_tgt(ltds, ltd, index);

-       cfs_bitmap_set(ltds->ltd_tgts_bitmap, index);
+       set_bit(index, ltds->ltd_tgts_bitmap);

        ltds->ltd_tgtnr++;
 
        GOTO(unlock, rc = 0);
        ltds->ltd_tgtnr++;
 
        GOTO(unlock, rc = 0);


@@ -1952,11 +1955,12 @@ lfsck_assistant_data_init(const struct lfsck_assistant_operations *lao,
 
        OBD_ALLOC_PTR(lad);
        if (lad != NULL) {
 
        OBD_ALLOC_PTR(lad);
        if (lad != NULL) {

-               lad->lad_bitmap = CFS_ALLOCATE_BITMAP(BITS_PER_LONG);
+               lad->lad_bitmap = bitmap_zalloc(BITS_PER_LONG, GFP_KERNEL);

                if (lad->lad_bitmap == NULL) {
                        OBD_FREE_PTR(lad);
                        return NULL;
                }
                if (lad->lad_bitmap == NULL) {
                        OBD_FREE_PTR(lad);
                        return NULL;
                }

+               lad->lad_bitmap_count = BITS_PER_LONG;

 
                INIT_LIST_HEAD(&lad->lad_req_list);
                spin_lock_init(&lad->lad_lock);
 
                INIT_LIST_HEAD(&lad->lad_req_list);
                spin_lock_init(&lad->lad_lock);


@@ -2444,17 +2448,17 @@ int lfsck_async_request(const struct lu_env *env, struct obd_export *exp,
 
 int lfsck_query_all(const struct lu_env *env, struct lfsck_component *com)
 {
 
 int lfsck_query_all(const struct lu_env *env, struct lfsck_component *com)
 {

-       struct lfsck_thread_info          *info  = lfsck_env_info(env);
-       struct lfsck_request              *lr    = &info->lti_lr;
-       struct lfsck_async_interpret_args *laia  = &info->lti_laia;
-       struct lfsck_instance             *lfsck = com->lc_lfsck;
-       struct lfsck_tgt_descs            *ltds  = &lfsck->li_mdt_descs;
-       struct lfsck_tgt_desc             *ltd;
-       struct ptlrpc_request_set         *set;
-       int                                idx;
-       int                                rc;
-       ENTRY;
+       struct lfsck_thread_info *info = lfsck_env_info(env);
+       struct lfsck_request *lr = &info->lti_lr;
+       struct lfsck_async_interpret_args *laia = &info->lti_laia;
+       struct lfsck_instance *lfsck = com->lc_lfsck;
+       struct lfsck_tgt_descs *ltds = &lfsck->li_mdt_descs;
+       struct lfsck_tgt_desc *ltd;
+       struct ptlrpc_request_set *set;
+       int idx;
+       int rc;

 
 

+       ENTRY;

        memset(lr, 0, sizeof(*lr));
        lr->lr_event = LE_QUERY;
        lr->lr_active = com->lc_type;
        memset(lr, 0, sizeof(*lr));
        lr->lr_event = LE_QUERY;
        lr->lr_active = com->lc_type;


@@ -2471,7 +2475,7 @@ int lfsck_query_all(const struct lu_env *env, struct lfsck_component *com)
 again:
        laia->laia_ltds = ltds;
        down_read(&ltds->ltd_rw_sem);
 again:
        laia->laia_ltds = ltds;
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -2894,18 +2898,18 @@ static int lfsck_stop_all(const struct lu_env *env,
                          struct lfsck_instance *lfsck,
                          struct lfsck_stop *stop)
 {
                          struct lfsck_instance *lfsck,
                          struct lfsck_stop *stop)
 {

-       struct lfsck_thread_info          *info   = lfsck_env_info(env);
-       struct lfsck_request              *lr     = &info->lti_lr;
-       struct lfsck_async_interpret_args *laia   = &info->lti_laia;
-       struct ptlrpc_request_set         *set;
-       struct lfsck_tgt_descs            *ltds   = &lfsck->li_mdt_descs;
-       struct lfsck_tgt_desc             *ltd;
-       struct lfsck_bookmark             *bk     = &lfsck->li_bookmark_ram;
-       __u32                              idx;
-       int                                rc     = 0;
-       int                                rc1    = 0;
-       ENTRY;
+       struct lfsck_thread_info *info = lfsck_env_info(env);
+       struct lfsck_request *lr = &info->lti_lr;
+       struct lfsck_async_interpret_args *laia = &info->lti_laia;
+       struct ptlrpc_request_set *set;
+       struct lfsck_tgt_descs *ltds = &lfsck->li_mdt_descs;
+       struct lfsck_tgt_desc *ltd;
+       struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+       int idx;
+       int rc = 0;
+       int rc1 = 0;

 
 

+       ENTRY;

        LASSERT(stop->ls_flags & LPF_BROADCAST);
 
        set = ptlrpc_prep_set();
        LASSERT(stop->ls_flags & LPF_BROADCAST);
 
        set = ptlrpc_prep_set();


@@ -2926,7 +2930,7 @@ static int lfsck_stop_all(const struct lu_env *env,
        laia->laia_shared = 1;
 
        down_read(&ltds->ltd_rw_sem);
        laia->laia_shared = 1;
 
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -2964,15 +2968,15 @@ static int lfsck_start_all(const struct lu_env *env,
                           struct lfsck_instance *lfsck,
                           struct lfsck_start *start)
 {
                           struct lfsck_instance *lfsck,
                           struct lfsck_start *start)
 {

-       struct lfsck_thread_info          *info   = lfsck_env_info(env);
-       struct lfsck_request              *lr     = &info->lti_lr;
-       struct lfsck_async_interpret_args *laia   = &info->lti_laia;
-       struct ptlrpc_request_set         *set;
-       struct lfsck_tgt_descs            *ltds   = &lfsck->li_mdt_descs;
-       struct lfsck_tgt_desc             *ltd;
-       struct lfsck_bookmark             *bk     = &lfsck->li_bookmark_ram;
-       __u32                              idx;
-       int                                rc     = 0;
+       struct lfsck_thread_info *info = lfsck_env_info(env);
+       struct lfsck_request *lr = &info->lti_lr;
+       struct lfsck_async_interpret_args *laia = &info->lti_laia;
+       struct ptlrpc_request_set *set;
+       struct lfsck_tgt_descs *ltds = &lfsck->li_mdt_descs;
+       struct lfsck_tgt_desc *ltd;
+       struct lfsck_bookmark *bk = &lfsck->li_bookmark_ram;
+       int idx;
+       int rc = 0;

        bool retry = false;
        ENTRY;
 
        bool retry = false;
        ENTRY;
 


@@ -3001,7 +3005,7 @@ again:
                RETURN(-ENOMEM);
 
        down_read(&ltds->ltd_rw_sem);
                RETURN(-ENOMEM);
 
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_tgt_get(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -3071,22 +3075,22 @@ again:
 int lfsck_start(const struct lu_env *env, struct dt_device *key,
                struct lfsck_start_param *lsp)
 {
 int lfsck_start(const struct lu_env *env, struct dt_device *key,
                struct lfsck_start_param *lsp)
 {

-       struct lfsck_start              *start  = lsp->lsp_start;
-       struct lfsck_instance           *lfsck;
-       struct lfsck_bookmark           *bk;
-       struct ptlrpc_thread            *thread;
-       struct lfsck_component          *com;
-       struct lfsck_thread_args        *lta;
-       struct task_struct              *task;
-       struct lfsck_tgt_descs          *ltds;
-       struct lfsck_tgt_desc           *ltd;
-       __u32                            idx;
-       int                              rc     = 0;
-       __u16                            valid  = 0;
-       __u16                            flags  = 0;
-       __u16                            type   = 1;
-       ENTRY;
+       struct lfsck_start *start = lsp->lsp_start;
+       struct lfsck_instance *lfsck;
+       struct lfsck_bookmark *bk;
+       struct ptlrpc_thread *thread;
+       struct lfsck_component *com;
+       struct lfsck_thread_args *lta;
+       struct task_struct *task;
+       struct lfsck_tgt_descs *ltds;
+       struct lfsck_tgt_desc *ltd;
+       int idx;
+       int rc = 0;
+       __u16 valid  = 0;
+       __u16 flags  = 0;
+       __u16 type   = 1;

 
 

+       ENTRY;

        if (key->dd_rdonly)
                RETURN(-EROFS);
 
        if (key->dd_rdonly)
                RETURN(-EROFS);
 


@@ -3241,7 +3245,7 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
 
        ltds = &lfsck->li_mdt_descs;
        down_read(&ltds->ltd_rw_sem);
 
        ltds = &lfsck->li_mdt_descs;
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -3259,7 +3263,7 @@ int lfsck_start(const struct lu_env *env, struct dt_device *key,
 
        ltds = &lfsck->li_ost_descs;
        down_read(&ltds->ltd_rw_sem);
 
        ltds = &lfsck->li_ost_descs;
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -3901,9 +3905,9 @@ void lfsck_del_target(const struct lu_env *env, struct dt_device *key,
                ltds = &lfsck->li_mdt_descs;
 
        down_write(&ltds->ltd_rw_sem);
                ltds = &lfsck->li_mdt_descs;
 
        down_write(&ltds->ltd_rw_sem);

-       LASSERT(ltds->ltd_tgts_bitmap != NULL);
+       LASSERT(ltds->ltd_tgts_bitmap);

 
 

-       if (unlikely(index >= ltds->ltd_tgts_bitmap->size))
+       if (unlikely(index >= ltds->ltd_tgts_mask_len))

                goto unlock;
 
        ltd = lfsck_ltd2tgt(ltds, index);
                goto unlock;
 
        ltd = lfsck_ltd2tgt(ltds, index);


@@ -3913,7 +3917,7 @@ void lfsck_del_target(const struct lu_env *env, struct dt_device *key,
        LASSERT(ltds->ltd_tgtnr > 0);
 
        ltds->ltd_tgtnr--;
        LASSERT(ltds->ltd_tgtnr > 0);
 
        ltds->ltd_tgtnr--;

-       cfs_bitmap_clear(ltds->ltd_tgts_bitmap, index);
+       set_bit(index, ltds->ltd_tgts_bitmap);

        lfsck_assign_tgt(ltds, NULL, index);
 
 unlock:
        lfsck_assign_tgt(ltds, NULL, index);
 
 unlock:

diff --git a/lustre/lfsck/lfsck_namespace.c b/lustre/lfsck/lfsck_namespace.c
index 3bdcbe6..0929245 100644 (file)
--- a/lustre/lfsck/lfsck_namespace.c
+++ b/lustre/lfsck/lfsck_namespace.c
@@ -277,55 +277,55 @@ static void lfsck_namespace_record_failure(const struct lu_env *env,
 static int lfsck_namespace_load_bitmap(const struct lu_env *env,
                                       struct lfsck_component *com)
 {
 static int lfsck_namespace_load_bitmap(const struct lu_env *env,
                                       struct lfsck_component *com)
 {

-       struct dt_object                *obj    = com->lc_obj;
-       struct lfsck_assistant_data     *lad    = com->lc_data;
-       struct lfsck_namespace          *ns     = com->lc_file_ram;
-       struct cfs_bitmap                       *bitmap = lad->lad_bitmap;
-       ssize_t                          size;
-       __u32                            nbits;
-       int                              rc;
-       ENTRY;
+       struct dt_object *obj = com->lc_obj;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       struct lfsck_namespace *ns = com->lc_file_ram;
+       unsigned long *bitmap = lad->lad_bitmap;
+       ssize_t size;
+       __u32 nbits;
+       int rc;

 
 

-       if (com->lc_lfsck->li_mdt_descs.ltd_tgts_bitmap->size >
+       ENTRY;
+       if (com->lc_lfsck->li_mdt_descs.ltd_tgts_mask_len >

            ns->ln_bitmap_size)
            ns->ln_bitmap_size)

-               nbits = com->lc_lfsck->li_mdt_descs.ltd_tgts_bitmap->size;
+               nbits = com->lc_lfsck->li_mdt_descs.ltd_tgts_mask_len;

        else
                nbits = ns->ln_bitmap_size;
 
        if (unlikely(nbits < BITS_PER_LONG))
                nbits = BITS_PER_LONG;
 
        else
                nbits = ns->ln_bitmap_size;
 
        if (unlikely(nbits < BITS_PER_LONG))
                nbits = BITS_PER_LONG;
 

-       if (nbits > bitmap->size) {
-               __u32 new_bits = bitmap->size;
-               struct cfs_bitmap *new_bitmap;
+       if (nbits > lad->lad_bitmap_count) {
+               u32 new_bits = lad->lad_bitmap_count;
+               unsigned long *new_bitmap;

 
                while (new_bits < nbits)
                        new_bits <<= 1;
 
 
                while (new_bits < nbits)
                        new_bits <<= 1;
 

-               new_bitmap = CFS_ALLOCATE_BITMAP(new_bits);
+               new_bitmap = bitmap_zalloc(new_bits, GFP_KERNEL);

                if (new_bitmap == NULL)
                        RETURN(-ENOMEM);
 
                lad->lad_bitmap = new_bitmap;
                if (new_bitmap == NULL)
                        RETURN(-ENOMEM);
 
                lad->lad_bitmap = new_bitmap;

-               CFS_FREE_BITMAP(bitmap);
+               lad->lad_bitmap_count = new_bits;
+               bitmap_free(bitmap);

                bitmap = new_bitmap;
        }
 
        if (ns->ln_bitmap_size == 0) {
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
                bitmap = new_bitmap;
        }
 
        if (ns->ln_bitmap_size == 0) {
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);

-               CFS_RESET_BITMAP(bitmap);
-
+               bitmap_zero(bitmap, lad->lad_bitmap_count);

                RETURN(0);
        }
 
        size = (ns->ln_bitmap_size + 7) >> 3;
        rc = dt_xattr_get(env, obj,
                RETURN(0);
        }
 
        size = (ns->ln_bitmap_size + 7) >> 3;
        rc = dt_xattr_get(env, obj,

-                         lfsck_buf_get(env, bitmap->data, size),
+                         lfsck_buf_get(env, bitmap, size),

                          XATTR_NAME_LFSCK_BITMAP);
        if (rc != size)
                RETURN(rc >= 0 ? -EINVAL : rc);
 
                          XATTR_NAME_LFSCK_BITMAP);
        if (rc != size)
                RETURN(rc >= 0 ? -EINVAL : rc);
 

-       if (cfs_bitmap_check_empty(bitmap))
+       if (bitmap_empty(bitmap, lad->lad_bitmap_count))

                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
        else
                set_bit(LAD_INCOMPLETE, &lad->lad_flags);
                clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
        else
                set_bit(LAD_INCOMPLETE, &lad->lad_flags);


@@ -378,21 +378,21 @@ static int lfsck_namespace_load(const struct lu_env *env,
 static int lfsck_namespace_store(const struct lu_env *env,
                                 struct lfsck_component *com)
 {
 static int lfsck_namespace_store(const struct lu_env *env,
                                 struct lfsck_component *com)
 {

-       struct dt_object                *obj    = com->lc_obj;
-       struct lfsck_instance           *lfsck  = com->lc_lfsck;
-       struct lfsck_namespace          *ns     = com->lc_file_ram;
-       struct lfsck_assistant_data     *lad    = com->lc_data;
-       struct dt_device                *dev    = lfsck_obj2dev(obj);
-       struct cfs_bitmap               *bitmap = NULL;
-       struct thandle                  *handle;
-       __u32                            nbits  = 0;
-       int                              len    = com->lc_file_size;
-       int                              rc;
-       ENTRY;
+       struct dt_object *obj = com->lc_obj;
+       struct lfsck_instance *lfsck = com->lc_lfsck;
+       struct lfsck_namespace *ns = com->lc_file_ram;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       struct dt_device *dev = lfsck_obj2dev(obj);
+       unsigned long *bitmap = NULL;
+       struct thandle *handle;
+       __u32 nbits = 0;
+       int len = com->lc_file_size;
+       int rc;

 
 

+       ENTRY;

        if (lad != NULL) {
                bitmap = lad->lad_bitmap;
        if (lad != NULL) {
                bitmap = lad->lad_bitmap;

-               nbits = bitmap->size;
+               nbits = lad->lad_bitmap_count;

 
                LASSERT(nbits > 0);
                LASSERTF((nbits & 7) == 0, "Invalid nbits %u\n", nbits);
 
                LASSERT(nbits > 0);
                LASSERTF((nbits & 7) == 0, "Invalid nbits %u\n", nbits);


@@ -413,7 +413,7 @@ static int lfsck_namespace_store(const struct lu_env *env,
 
        if (bitmap != NULL) {
                rc = dt_declare_xattr_set(env, obj,
 
        if (bitmap != NULL) {
                rc = dt_declare_xattr_set(env, obj,

-                               lfsck_buf_get(env, bitmap->data, nbits >> 3),
+                               lfsck_buf_get(env, bitmap, nbits >> 3),

                                XATTR_NAME_LFSCK_BITMAP, 0, handle);
                if (rc != 0)
                        GOTO(out, rc);
                                XATTR_NAME_LFSCK_BITMAP, 0, handle);
                if (rc != 0)
                        GOTO(out, rc);


@@ -428,7 +428,7 @@ static int lfsck_namespace_store(const struct lu_env *env,
                          XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
        if (rc == 0 && bitmap != NULL)
                rc = dt_xattr_set(env, obj,
                          XATTR_NAME_LFSCK_NAMESPACE, 0, handle);
        if (rc == 0 && bitmap != NULL)
                rc = dt_xattr_set(env, obj,

-                                 lfsck_buf_get(env, bitmap->data, nbits >> 3),
+                                 lfsck_buf_get(env, bitmap, nbits >> 3),

                                  XATTR_NAME_LFSCK_BITMAP, 0, handle);
 
        GOTO(out, rc);
                                  XATTR_NAME_LFSCK_BITMAP, 0, handle);
 
        GOTO(out, rc);


@@ -4267,7 +4267,7 @@ static int lfsck_namespace_reset(const struct lu_env *env,
                GOTO(out, rc);
 
        clear_bit(LAD_INCOMPLETE, &lad->lad_flags);
                GOTO(out, rc);
 
        clear_bit(LAD_INCOMPLETE, &lad->lad_flags);

-       CFS_RESET_BITMAP(lad->lad_bitmap);
+       bitmap_zero(lad->lad_bitmap, lad->lad_bitmap_count);

 
        rc = lfsck_namespace_store(env, com);
 
 
        rc = lfsck_namespace_store(env, com);
 


@@ -5005,7 +5005,7 @@ static void lfsck_namespace_data_release(const struct lu_env *env,
        spin_unlock(&ltds->ltd_lock);
 
        if (likely(lad->lad_bitmap != NULL))
        spin_unlock(&ltds->ltd_lock);
 
        if (likely(lad->lad_bitmap != NULL))

-               CFS_FREE_BITMAP(lad->lad_bitmap);
+               bitmap_free(lad->lad_bitmap);

 
        OBD_FREE_PTR(lad);
 }
 
        OBD_FREE_PTR(lad);
 }


@@ -5190,7 +5190,7 @@ static int lfsck_namespace_query_all(const struct lu_env *env,
                RETURN(rc);
 
        down_read(&ltds->ltd_rw_sem);
                RETURN(rc);
 
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(ltds->ltd_tgts_bitmap, idx) {
+       for_each_set_bit(idx, ltds->ltd_tgts_bitmap, ltds->ltd_tgts_mask_len) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 
                ltd = lfsck_ltd2tgt(ltds, idx);
                LASSERT(ltd != NULL);
 


@@ -6809,16 +6809,16 @@ static void lfsck_namespace_assistant_sync_failures(const struct lu_env *env,
 {
        struct lfsck_async_interpret_args *laia  =
                                &lfsck_env_info(env)->lti_laia2;
 {
        struct lfsck_async_interpret_args *laia  =
                                &lfsck_env_info(env)->lti_laia2;

-       struct lfsck_assistant_data       *lad   = com->lc_data;
-       struct lfsck_namespace            *ns    = com->lc_file_ram;
-       struct lfsck_instance             *lfsck = com->lc_lfsck;
-       struct lfsck_tgt_descs            *ltds  = &lfsck->li_mdt_descs;
-       struct lfsck_tgt_desc             *ltd;
-       struct ptlrpc_request_set         *set;
-       __u32                              idx;
-       int                                rc    = 0;
-       ENTRY;
+       struct lfsck_assistant_data *lad = com->lc_data;
+       struct lfsck_namespace *ns = com->lc_file_ram;
+       struct lfsck_instance *lfsck = com->lc_lfsck;
+       struct lfsck_tgt_descs *ltds = &lfsck->li_mdt_descs;
+       struct lfsck_tgt_desc *ltd;
+       struct ptlrpc_request_set *set;
+       int idx;
+       int rc = 0;

 
 

+       ENTRY;

        if (!test_bit(LAD_INCOMPLETE, &lad->lad_flags))
                RETURN_EXIT;
 
        if (!test_bit(LAD_INCOMPLETE, &lad->lad_flags))
                RETURN_EXIT;
 


@@ -6831,7 +6831,7 @@ static void lfsck_namespace_assistant_sync_failures(const struct lu_env *env,
        lad->lad_touch_gen++;
 
        down_read(&ltds->ltd_rw_sem);
        lad->lad_touch_gen++;
 
        down_read(&ltds->ltd_rw_sem);

-       cfs_foreach_bit(lad->lad_bitmap, idx) {
+       for_each_set_bit(idx, lad->lad_bitmap, lad->lad_bitmap_count) {

                ltd = lfsck_ltd2tgt(ltds, idx);
                if (unlikely(!ltd))
                        continue;
                ltd = lfsck_ltd2tgt(ltds, idx);
                if (unlikely(!ltd))
                        continue;