LU-147 hash code cleanup

Change-Id: I97cc182a9618271e59c4d6a8fbc2e887e1fb1a17
Signed-off-by: Alexey Lyashkov <Alexey_Lyashkov@xyratex.com>
Signed-off-by: Vitaly Fertman <vitaly_fertman@xyratex.com>
Reviewed-on: http://review.whamcloud.com/346
Tested-by: Hudson
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Liang Zhen <liang@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/libcfs/include/libcfs/libcfs_hash.h b/libcfs/include/libcfs/libcfs_hash.h
index 3e28f5d..ceaa570 100644 (file)
--- a/libcfs/include/libcfs/libcfs_hash.h
+++ b/libcfs/include/libcfs/libcfs_hash.h
@@ -351,13 +351,13 @@ typedef struct cfs_hash_hlist_ops {
 
 typedef struct cfs_hash_ops {
         /** return hashed value from @key */
-        unsigned (*hs_hash)(cfs_hash_t *hs, void *key, unsigned mask);
+        unsigned (*hs_hash)(cfs_hash_t *hs, const void *key, unsigned mask);
         /** return key address of @hnode */
         void *   (*hs_key)(cfs_hlist_node_t *hnode);
         /** copy key from @hnode to @key */
         void     (*hs_keycpy)(cfs_hlist_node_t *hnode, void *key);
         /** compare @key with key of @hnode */
-        int      (*hs_keycmp)(void *key, cfs_hlist_node_t *hnode);
+        int      (*hs_keycmp)(const void *key, cfs_hlist_node_t *hnode);
         /** return object address of @hnode, i.e: container_of(...hnode) */
         void *   (*hs_object)(cfs_hlist_node_t *hnode);
         /** get refcount of item, always called with holding bucket-lock */
@@ -507,7 +507,7 @@ cfs_hash_bkt_size(cfs_hash_t *hs)
 #define CFS_HOP(hs, op)           (hs)->hs_ops->hs_ ## op
 
 static inline unsigned
-cfs_hash_id(cfs_hash_t *hs, void *key, unsigned mask)
+cfs_hash_id(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         return CFS_HOP(hs, hash)(hs, key, mask);
 }
@@ -529,7 +529,7 @@ cfs_hash_keycpy(cfs_hash_t *hs, cfs_hlist_node_t *hnode, void *key)
  * Returns 1 on a match,
  */
 static inline int
-cfs_hash_keycmp(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_keycmp(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
 {
         return CFS_HOP(hs, keycmp)(key, hnode);
 }
@@ -602,9 +602,9 @@ static inline void cfs_hash_bd_unlock(cfs_hash_t *hs,
  * operations on cfs_hash bucket (bd: bucket descriptor),
  * they are normally for hash-table without rehash
  */
-void cfs_hash_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bd);
+void cfs_hash_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bd);
 
-static inline void cfs_hash_bd_get_and_lock(cfs_hash_t *hs, void *key,
+static inline void cfs_hash_bd_get_and_lock(cfs_hash_t *hs, const void *key,
                                             cfs_hash_bd_t *bd, int excl)
 {
         cfs_hash_bd_get(hs, key, bd);
@@ -684,24 +684,24 @@ static inline cfs_hlist_head_t *cfs_hash_bd_hhead(cfs_hash_t *hs,
 }
 
 cfs_hlist_node_t *cfs_hash_bd_lookup_locked(cfs_hash_t *hs,
-                                            cfs_hash_bd_t *bd, void *key);
+                                            cfs_hash_bd_t *bd, const void *key);
 cfs_hlist_node_t *cfs_hash_bd_findadd_locked(cfs_hash_t *hs,
-                                             cfs_hash_bd_t *bd, void *key,
+                                             cfs_hash_bd_t *bd, const void *key,
                                              cfs_hlist_node_t *hnode,
                                              int insist_add);
 cfs_hlist_node_t *cfs_hash_bd_finddel_locked(cfs_hash_t *hs,
-                                             cfs_hash_bd_t *bd, void *key,
+                                             cfs_hash_bd_t *bd, const void *key,
                                              cfs_hlist_node_t *hnode);
 
 /**
  * operations on cfs_hash bucket (bd: bucket descriptor),
  * they are safe for hash-table with rehash
  */
-void cfs_hash_dual_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bds);
+void cfs_hash_dual_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bds);
 void cfs_hash_dual_bd_lock(cfs_hash_t *hs, cfs_hash_bd_t *bds, int excl);
 void cfs_hash_dual_bd_unlock(cfs_hash_t *hs, cfs_hash_bd_t *bds, int excl);
 
-static inline void cfs_hash_dual_bd_get_and_lock(cfs_hash_t *hs, void *key,
+static inline void cfs_hash_dual_bd_get_and_lock(cfs_hash_t *hs, const void *key,
                                                  cfs_hash_bd_t *bds, int excl)
 {
         cfs_hash_dual_bd_get(hs, key, bds);
@@ -709,13 +709,16 @@ static inline void cfs_hash_dual_bd_get_and_lock(cfs_hash_t *hs, void *key,
 }
 
 cfs_hlist_node_t *cfs_hash_dual_bd_lookup_locked(cfs_hash_t *hs,
-                                                 cfs_hash_bd_t *bds, void *key);
+                                                 cfs_hash_bd_t *bds,
+                                                 const void *key);
 cfs_hlist_node_t *cfs_hash_dual_bd_findadd_locked(cfs_hash_t *hs,
-                                                  cfs_hash_bd_t *bds, void *key,
+                                                  cfs_hash_bd_t *bds,
+                                                  const void *key,
                                                   cfs_hlist_node_t *hnode,
                                                   int insist_add);
 cfs_hlist_node_t *cfs_hash_dual_bd_finddel_locked(cfs_hash_t *hs,
-                                                  cfs_hash_bd_t *bds, void *key,
+                                                  cfs_hash_bd_t *bds,
+                                                  const void *key,
                                                   cfs_hlist_node_t *hnode);
 
 /* Hash init/cleanup functions */
@@ -728,30 +731,30 @@ cfs_hash_t *cfs_hash_getref(cfs_hash_t *hs);
 void cfs_hash_putref(cfs_hash_t *hs);
 
 /* Hash addition functions */
-void cfs_hash_add(cfs_hash_t *hs, void *key,
+void cfs_hash_add(cfs_hash_t *hs, const void *key,
                   cfs_hlist_node_t *hnode);
-int cfs_hash_add_unique(cfs_hash_t *hs, void *key,
+int cfs_hash_add_unique(cfs_hash_t *hs, const void *key,
                         cfs_hlist_node_t *hnode);
-void *cfs_hash_findadd_unique(cfs_hash_t *hs, void *key,
+void *cfs_hash_findadd_unique(cfs_hash_t *hs, const void *key,
                               cfs_hlist_node_t *hnode);
 
 /* Hash deletion functions */
-void *cfs_hash_del(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode);
-void *cfs_hash_del_key(cfs_hash_t *hs, void *key);
+void *cfs_hash_del(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode);
+void *cfs_hash_del_key(cfs_hash_t *hs, const void *key);
 
 /* Hash lookup/for_each functions */
 #define CFS_HASH_LOOP_HOG       1024
 
 typedef int (*cfs_hash_for_each_cb_t)(cfs_hash_t *hs, cfs_hash_bd_t *bd,
                                       cfs_hlist_node_t *node, void *data);
-void *cfs_hash_lookup(cfs_hash_t *hs, void *key);
+void *cfs_hash_lookup(cfs_hash_t *hs, const void *key);
 void cfs_hash_for_each(cfs_hash_t *hs, cfs_hash_for_each_cb_t, void *data);
 void cfs_hash_for_each_safe(cfs_hash_t *hs, cfs_hash_for_each_cb_t, void *data);
 int  cfs_hash_for_each_nolock(cfs_hash_t *hs,
                               cfs_hash_for_each_cb_t, void *data);
 int  cfs_hash_for_each_empty(cfs_hash_t *hs,
                              cfs_hash_for_each_cb_t, void *data);
-void cfs_hash_for_each_key(cfs_hash_t *hs, void *key,
+void cfs_hash_for_each_key(cfs_hash_t *hs, const void *key,
                            cfs_hash_for_each_cb_t, void *data);
 typedef int (*cfs_hash_cond_opt_cb_t)(void *obj, void *data);
 void cfs_hash_cond_del(cfs_hash_t *hs, cfs_hash_cond_opt_cb_t, void *data);
@@ -768,13 +771,13 @@ __u64 cfs_hash_size_get(cfs_hash_t *hs);
 void cfs_hash_rehash_cancel_locked(cfs_hash_t *hs);
 void cfs_hash_rehash_cancel(cfs_hash_t *hs);
 int  cfs_hash_rehash(cfs_hash_t *hs, int do_rehash);
-void cfs_hash_rehash_key(cfs_hash_t *hs, void *old_key,
+void cfs_hash_rehash_key(cfs_hash_t *hs, const void *old_key,
                          void *new_key, cfs_hlist_node_t *hnode);
 
 #if CFS_HASH_DEBUG_LEVEL > CFS_HASH_DEBUG_1
 /* Validate hnode references the correct key */
 static inline void
-cfs_hash_key_validate(cfs_hash_t *hs, void *key,
+cfs_hash_key_validate(cfs_hash_t *hs, const void *key,
                       cfs_hlist_node_t *hnode)
 {
         LASSERT(cfs_hash_keycmp(hs, key, hnode));
@@ -795,7 +798,7 @@ cfs_hash_bucket_validate(cfs_hash_t *hs, cfs_hash_bd_t *bd,
 #else /* CFS_HASH_DEBUG_LEVEL > CFS_HASH_DEBUG_1 */
 
 static inline void
-cfs_hash_key_validate(cfs_hash_t *hs, void *key,
+cfs_hash_key_validate(cfs_hash_t *hs, const void *key,
                       cfs_hlist_node_t *hnode) {}
 
 static inline void
@@ -842,7 +845,7 @@ int cfs_hash_debug_str(cfs_hash_t *hs, char *str, int size);
  * Generic djb2 hash algorithm for character arrays.
  */
 static inline unsigned
-cfs_hash_djb2_hash(void *key, size_t size, unsigned mask)
+cfs_hash_djb2_hash(const void *key, size_t size, unsigned mask)
 {
         unsigned i, hash = 5381;
 
@@ -858,7 +861,7 @@ cfs_hash_djb2_hash(void *key, size_t size, unsigned mask)
  * Generic u32 hash algorithm.
  */
 static inline unsigned
-cfs_hash_u32_hash(__u32 key, unsigned mask)
+cfs_hash_u32_hash(const __u32 key, unsigned mask)
 {
         return ((key * CFS_GOLDEN_RATIO_PRIME_32) & mask);
 }
@@ -867,7 +870,7 @@ cfs_hash_u32_hash(__u32 key, unsigned mask)
  * Generic u64 hash algorithm.
  */
 static inline unsigned
-cfs_hash_u64_hash(__u64 key, unsigned mask)
+cfs_hash_u64_hash(const __u64 key, unsigned mask)
 {
         return ((unsigned)(key * CFS_GOLDEN_RATIO_PRIME_64) & mask);
 }

diff --git a/libcfs/libcfs/hash.c b/libcfs/libcfs/hash.c
index 5791631..db30f8c 100644 (file)
--- a/libcfs/libcfs/hash.c
+++ b/libcfs/libcfs/hash.c
@@ -467,7 +467,7 @@ cfs_hash_hlist_setup(cfs_hash_t *hs)
 
 static void
 cfs_hash_bd_from_key(cfs_hash_t *hs, cfs_hash_bucket_t **bkts,
-                     unsigned int bits, void *key, cfs_hash_bd_t *bd)
+                     unsigned int bits, const void *key, cfs_hash_bd_t *bd)
 {
         unsigned int index = cfs_hash_id(hs, key, (1U << bits) - 1);
 
@@ -478,7 +478,7 @@ cfs_hash_bd_from_key(cfs_hash_t *hs, cfs_hash_bucket_t **bkts,
 }
 
 void
-cfs_hash_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bd)
+cfs_hash_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bd)
 {
         /* NB: caller should hold hs->hs_rwlock if REHASH is set */
         if (likely(hs->hs_rehash_buckets == NULL)) {
@@ -615,7 +615,7 @@ typedef enum cfs_hash_lookup_intent {
 
 static cfs_hlist_node_t *
 cfs_hash_bd_lookup_intent(cfs_hash_t *hs, cfs_hash_bd_t *bd,
-                          void *key, cfs_hlist_node_t *hnode,
+                          const void *key, cfs_hlist_node_t *hnode,
                           cfs_hash_lookup_intent_t intent)
 
 {
@@ -655,7 +655,7 @@ cfs_hash_bd_lookup_intent(cfs_hash_t *hs, cfs_hash_bd_t *bd,
 }
 
 cfs_hlist_node_t *
-cfs_hash_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd, void *key)
+cfs_hash_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd, const void *key)
 {
         return cfs_hash_bd_lookup_intent(hs, bd, key, NULL,
                                          CFS_HS_LOOKUP_IT_FIND);
@@ -664,7 +664,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_bd_lookup_locked);
 
 cfs_hlist_node_t *
 cfs_hash_bd_findadd_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd,
-                           void *key, cfs_hlist_node_t *hnode,
+                           const void *key, cfs_hlist_node_t *hnode,
                            int noref)
 {
         return cfs_hash_bd_lookup_intent(hs, bd, key, hnode,
@@ -675,7 +675,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_bd_findadd_locked);
 
 cfs_hlist_node_t *
 cfs_hash_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bd,
-                           void *key, cfs_hlist_node_t *hnode)
+                           const void *key, cfs_hlist_node_t *hnode)
 {
         /* hnode can be NULL, we find the first item with @key */
         return cfs_hash_bd_lookup_intent(hs, bd, key, hnode,
@@ -723,7 +723,7 @@ cfs_hash_multi_bd_unlock(cfs_hash_t *hs, cfs_hash_bd_t *bds,
 
 static cfs_hlist_node_t *
 cfs_hash_multi_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
-                                unsigned n, void *key)
+                                unsigned n, const void *key)
 {
         cfs_hlist_node_t  *ehnode;
         unsigned           i;
@@ -739,7 +739,7 @@ cfs_hash_multi_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
 
 static cfs_hlist_node_t *
 cfs_hash_multi_bd_findadd_locked(cfs_hash_t *hs,
-                                 cfs_hash_bd_t *bds, unsigned n, void *key,
+                                 cfs_hash_bd_t *bds, unsigned n, const void *key,
                                  cfs_hlist_node_t *hnode, int noref)
 {
         cfs_hlist_node_t  *ehnode;
@@ -770,7 +770,8 @@ cfs_hash_multi_bd_findadd_locked(cfs_hash_t *hs,
 
 static cfs_hlist_node_t *
 cfs_hash_multi_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
-                                 unsigned n, void *key, cfs_hlist_node_t *hnode)
+                                 unsigned n, const void *key,
+                                 cfs_hlist_node_t *hnode)
 {
         cfs_hlist_node_t  *ehnode;
         unsigned           i;
@@ -812,7 +813,7 @@ cfs_hash_bd_order(cfs_hash_bd_t *bd1, cfs_hash_bd_t *bd2)
 }
 
 void
-cfs_hash_dual_bd_get(cfs_hash_t *hs, void *key, cfs_hash_bd_t *bds)
+cfs_hash_dual_bd_get(cfs_hash_t *hs, const void *key, cfs_hash_bd_t *bds)
 {
         /* NB: caller should hold hs_lock.rw if REHASH is set */
         cfs_hash_bd_from_key(hs, hs->hs_buckets,
@@ -846,7 +847,8 @@ cfs_hash_dual_bd_unlock(cfs_hash_t *hs, cfs_hash_bd_t *bds, int excl)
 CFS_EXPORT_SYMBOL(cfs_hash_dual_bd_unlock);
 
 cfs_hlist_node_t *
-cfs_hash_dual_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds, void *key)
+cfs_hash_dual_bd_lookup_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
+                               const void *key)
 {
         return cfs_hash_multi_bd_lookup_locked(hs, bds, 2, key);
 }
@@ -854,7 +856,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_dual_bd_lookup_locked);
 
 cfs_hlist_node_t *
 cfs_hash_dual_bd_findadd_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
-                                void *key, cfs_hlist_node_t *hnode,
+                                const void *key, cfs_hlist_node_t *hnode,
                                 int noref)
 {
         return cfs_hash_multi_bd_findadd_locked(hs, bds, 2, key,
@@ -864,7 +866,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_dual_bd_findadd_locked);
 
 cfs_hlist_node_t *
 cfs_hash_dual_bd_finddel_locked(cfs_hash_t *hs, cfs_hash_bd_t *bds,
-                                void *key, cfs_hlist_node_t *hnode)
+                                const void *key, cfs_hlist_node_t *hnode)
 {
         return cfs_hash_multi_bd_finddel_locked(hs, bds, 2, key, hnode);
 }
@@ -1209,7 +1211,7 @@ cfs_hash_rehash_inline(cfs_hash_t *hs)
  * ops->hs_get function will be called when the item is added.
  */
 void
-cfs_hash_add(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_add(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
 {
         cfs_hash_bd_t   bd;
         int             bits;
@@ -1232,7 +1234,7 @@ cfs_hash_add(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
 CFS_EXPORT_SYMBOL(cfs_hash_add);
 
 static cfs_hlist_node_t *
-cfs_hash_find_or_add(cfs_hash_t *hs, void *key,
+cfs_hash_find_or_add(cfs_hash_t *hs, const void *key,
                      cfs_hlist_node_t *hnode, int noref)
 {
         cfs_hlist_node_t *ehnode;
@@ -1264,7 +1266,7 @@ cfs_hash_find_or_add(cfs_hash_t *hs, void *key,
  * Returns 0 on success or -EALREADY on key collisions.
  */
 int
-cfs_hash_add_unique(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_add_unique(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
 {
         return cfs_hash_find_or_add(hs, key, hnode, 1) != hnode ?
                -EALREADY : 0;
@@ -1278,7 +1280,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_add_unique);
  * Otherwise ops->hs_get is called on the item which was added.
  */
 void *
-cfs_hash_findadd_unique(cfs_hash_t *hs, void *key,
+cfs_hash_findadd_unique(cfs_hash_t *hs, const void *key,
                         cfs_hlist_node_t *hnode)
 {
         hnode = cfs_hash_find_or_add(hs, key, hnode, 0);
@@ -1295,7 +1297,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_findadd_unique);
  * on the removed object.
  */
 void *
-cfs_hash_del(cfs_hash_t *hs, void *key, cfs_hlist_node_t *hnode)
+cfs_hash_del(cfs_hash_t *hs, const void *key, cfs_hlist_node_t *hnode)
 {
         void           *obj  = NULL;
         int             bits = 0;
@@ -1330,7 +1332,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_del);
  * will be returned and ops->hs_put is called on the removed object.
  */
 void *
-cfs_hash_del_key(cfs_hash_t *hs, void *key)
+cfs_hash_del_key(cfs_hash_t *hs, const void *key)
 {
         return cfs_hash_del(hs, key, NULL);
 }
@@ -1345,7 +1347,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_del_key);
  * in the hash @hs NULL is returned.
  */
 void *
-cfs_hash_lookup(cfs_hash_t *hs, void *key)
+cfs_hash_lookup(cfs_hash_t *hs, const void *key)
 {
         void                 *obj = NULL;
         cfs_hlist_node_t     *hnode;
@@ -1725,7 +1727,7 @@ CFS_EXPORT_SYMBOL(cfs_hash_hlist_for_each);
  * is held so the callback must never sleep.
    */
 void
-cfs_hash_for_each_key(cfs_hash_t *hs, void *key,
+cfs_hash_for_each_key(cfs_hash_t *hs, const void *key,
                       cfs_hash_for_each_cb_t func, void *data)
 {
         cfs_hlist_node_t   *hnode;
@@ -1974,7 +1976,7 @@ cfs_hash_rehash_worker(cfs_workitem_t *wi)
  * the registered cfs_hash_get() and cfs_hash_put() functions will
  * not be called.
  */
-void cfs_hash_rehash_key(cfs_hash_t *hs, void *old_key,
+void cfs_hash_rehash_key(cfs_hash_t *hs, const void *old_key,
                          void *new_key, cfs_hlist_node_t *hnode)
 {
         cfs_hash_bd_t        bds[3];

diff --git a/lustre/include/lustre/lustre_idl.h b/lustre/include/lustre/lustre_idl.h
index c707ede..826dcda 100644 (file)
--- a/lustre/include/lustre/lustre_idl.h
+++ b/lustre/include/lustre/lustre_idl.h
@@ -914,8 +914,8 @@ static inline int lustre_handle_is_used(struct lustre_handle *lh)
         return lh->cookie != 0ull;
 }
 
-static inline int lustre_handle_equal(struct lustre_handle *lh1,
-                                      struct lustre_handle *lh2)
+static inline int lustre_handle_equal(const struct lustre_handle *lh1,
+                                      const struct lustre_handle *lh2)
 {
         return lh1->cookie == lh2->cookie;
 }

diff --git a/lustre/include/lustre/lustre_user.h b/lustre/include/lustre/lustre_user.h
index 14dff87..b127ead 100644 (file)
--- a/lustre/include/lustre/lustre_user.h
+++ b/lustre/include/lustre/lustre_user.h
@@ -241,7 +241,8 @@ struct obd_uuid {
         char uuid[40];
 };
 
-static inline int obd_uuid_equals(struct obd_uuid *u1, struct obd_uuid *u2)
+static inline int obd_uuid_equals(const struct obd_uuid *u1,
+                                  const struct obd_uuid *u2)
 {
         return strcmp((char *)u1->uuid, (char *)u2->uuid) == 0;
 }

diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c
index c72f4b6..6d2795f 100644 (file)
--- a/lustre/ldlm/ldlm_lockd.c
+++ b/lustre/ldlm/ldlm_lockd.c
@@ -2316,7 +2316,7 @@ void ldlm_put_ref(void)
  * Export handle<->lock hash operations.
  */
 static unsigned
-ldlm_export_lock_hash(cfs_hash_t *hs, void *key, unsigned mask)
+ldlm_export_lock_hash(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         return cfs_hash_u64_hash(((struct lustre_handle *)key)->cookie, mask);
 }
@@ -2340,7 +2340,7 @@ ldlm_export_lock_keycpy(cfs_hlist_node_t *hnode, void *key)
 }
 
 static int
-ldlm_export_lock_keycmp(void *key, cfs_hlist_node_t *hnode)
+ldlm_export_lock_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         return lustre_handle_equal(ldlm_export_lock_key(hnode), key);
 }

diff --git a/lustre/ldlm/ldlm_resource.c b/lustre/ldlm/ldlm_resource.c
index e8d90c2..e6eb905 100644 (file)
--- a/lustre/ldlm/ldlm_resource.c
+++ b/lustre/ldlm/ldlm_resource.c
@@ -376,9 +376,10 @@ int ldlm_namespace_proc_register(struct ldlm_namespace *ns)
 
 #endif /* LPROCFS */
 
-static unsigned ldlm_res_hop_hash(cfs_hash_t *hs, void *key, unsigned mask)
+static unsigned ldlm_res_hop_hash(cfs_hash_t *hs,
+                                  const void *key, unsigned mask)
 {
-        struct ldlm_res_id     *id  = key;
+        const struct ldlm_res_id     *id  = key;
         unsigned                val = 0;
         unsigned                i;
 
@@ -387,9 +388,10 @@ static unsigned ldlm_res_hop_hash(cfs_hash_t *hs, void *key, unsigned mask)
         return val & mask;
 }
 
-static unsigned ldlm_res_hop_fid_hash(cfs_hash_t *hs, void *key, unsigned mask)
+static unsigned ldlm_res_hop_fid_hash(cfs_hash_t *hs,
+                                      const void *key, unsigned mask)
 {
-        struct ldlm_res_id *id = key;
+        const struct ldlm_res_id *id = key;
         struct lu_fid       fid;
         __u64               hash;
 
@@ -424,7 +426,7 @@ static int ldlm_res_eq(const struct ldlm_res_id *res0,
         return !memcmp(res0, res1, sizeof(*res0));
 }
 
-static int ldlm_res_hop_keycmp(void *key, cfs_hlist_node_t *hnode)
+static int ldlm_res_hop_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct ldlm_resource   *res;
 

diff --git a/lustre/lov/lov_pool.c b/lustre/lov/lov_pool.c
index bf12521..b6355bb 100644 (file)
--- a/lustre/lov/lov_pool.c
+++ b/lustre/lov/lov_pool.c
@@ -88,7 +88,7 @@ void lov_pool_putref_locked(struct pool_desc *pool)
  * Chapter 6.4.
  * Addison Wesley, 1973
  */
-static __u32 pool_hashfn(cfs_hash_t *hash_body, void *key, unsigned mask)
+static __u32 pool_hashfn(cfs_hash_t *hash_body, const void *key, unsigned mask)
 {
         int i;
         __u32 result;
@@ -112,7 +112,7 @@ static void *pool_key(cfs_hlist_node_t *hnode)
         return (pool->pool_name);
 }
 
-static int pool_hashkey_keycmp(void *key, cfs_hlist_node_t *compared_hnode)
+static int pool_hashkey_keycmp(const void *key, cfs_hlist_node_t *compared_hnode)
 {
         char *pool_name;
         struct pool_desc *pool;

diff --git a/lustre/obdclass/cl_object.c b/lustre/obdclass/cl_object.c
index 739b88d..574ed68 100644 (file)
--- a/lustre/obdclass/cl_object.c
+++ b/lustre/obdclass/cl_object.c
@@ -613,7 +613,8 @@ static void cl_env_init0(struct cl_env *cle, void *debug)
 
 static cfs_hash_t *cl_env_hash;
 
-static unsigned cl_env_hops_hash(cfs_hash_t *lh, void *key, unsigned mask)
+static unsigned cl_env_hops_hash(cfs_hash_t *lh,
+                                 const void *key, unsigned mask)
 {
 #if BITS_PER_LONG == 64
         return cfs_hash_u64_hash((__u64)key, mask);
@@ -629,7 +630,7 @@ static void *cl_env_hops_obj(cfs_hlist_node_t *hn)
         return (void *)cle;
 }
 
-static int cl_env_hops_keycmp(void *key, cfs_hlist_node_t *hn)
+static int cl_env_hops_keycmp(const void *key, cfs_hlist_node_t *hn)
 {
         struct cl_env *cle = cl_env_hops_obj(hn);
 

diff --git a/lustre/obdclass/lu_object.c b/lustre/obdclass/lu_object.c
index 3023736..e430eb1 100644 (file)
--- a/lustre/obdclass/lu_object.c
+++ b/lustre/obdclass/lu_object.c
@@ -789,7 +789,8 @@ static int lu_htable_order(void)
         return bits;
 }
 
-static unsigned lu_obj_hop_hash(cfs_hash_t *hs, void *key, unsigned mask)
+static unsigned lu_obj_hop_hash(cfs_hash_t *hs,
+                                const void *key, unsigned mask)
 {
         struct lu_fid  *fid = (struct lu_fid *)key;
         unsigned        hash;
@@ -812,7 +813,7 @@ static void *lu_obj_hop_key(cfs_hlist_node_t *hnode)
         return &h->loh_fid;
 }
 
-static int lu_obj_hop_keycmp(void *key, cfs_hlist_node_t *hnode)
+static int lu_obj_hop_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct lu_object_header *h;
 

diff --git a/lustre/obdclass/obd_config.c b/lustre/obdclass/obd_config.c
index e595ad7..2799869 100644 (file)
--- a/lustre/obdclass/obd_config.c
+++ b/lustre/obdclass/obd_config.c
@@ -1518,7 +1518,7 @@ out:
  */
 
 static unsigned
-uuid_hash(cfs_hash_t *hs,  void *key, unsigned mask)
+uuid_hash(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         return cfs_hash_djb2_hash(((struct obd_uuid *)key)->uuid,
                                   sizeof(((struct obd_uuid *)key)->uuid), mask);
@@ -1539,14 +1539,14 @@ uuid_key(cfs_hlist_node_t *hnode)
  *       state with this function
  */
 static int
-uuid_keycmp(void *key, cfs_hlist_node_t *hnode)
+uuid_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct obd_export *exp;
 
         LASSERT(key);
         exp = cfs_hlist_entry(hnode, struct obd_export, exp_uuid_hash);
 
-        return obd_uuid_equals((struct obd_uuid *)key,&exp->exp_client_uuid) &&
+        return obd_uuid_equals(key, &exp->exp_client_uuid) &&
                !exp->exp_failed;
 }
 
@@ -1589,7 +1589,7 @@ static cfs_hash_ops_t uuid_hash_ops = {
  */
 
 static unsigned
-nid_hash(cfs_hash_t *hs,  void *key, unsigned mask)
+nid_hash(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         return cfs_hash_djb2_hash(key, sizeof(lnet_nid_t), mask);
 }
@@ -1609,7 +1609,7 @@ nid_key(cfs_hlist_node_t *hnode)
  *       state with this function
  */
 static int
-nid_kepcmp(void *key, cfs_hlist_node_t *hnode)
+nid_kepcmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct obd_export *exp;
 
@@ -1669,7 +1669,7 @@ nidstats_key(cfs_hlist_node_t *hnode)
 }
 
 static int
-nidstats_keycmp(void *key, cfs_hlist_node_t *hnode)
+nidstats_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         return *(lnet_nid_t *)nidstats_key(hnode) == *(lnet_nid_t *)key;
 }

diff --git a/lustre/ptlrpc/connection.c b/lustre/ptlrpc/connection.c
index ab1f0e7..00b37a9 100644 (file)
--- a/lustre/ptlrpc/connection.c
+++ b/lustre/ptlrpc/connection.c
@@ -165,16 +165,16 @@ void ptlrpc_connection_fini(void) {
  * Hash operations for net_peer<->connection
  */
 static unsigned
-conn_hashfn(cfs_hash_t *hs,  void *key, unsigned mask)
+conn_hashfn(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         return cfs_hash_djb2_hash(key, sizeof(lnet_process_id_t), mask);
 }
 
 static int
-conn_keycmp(void *key, cfs_hlist_node_t *hnode)
+conn_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct ptlrpc_connection *conn;
-        lnet_process_id_t *conn_key;
+        const lnet_process_id_t *conn_key;
 
         LASSERT(key != NULL);
         conn_key = (lnet_process_id_t*)key;

diff --git a/lustre/quota/quota_context.c b/lustre/quota/quota_context.c
index 4d56826..af31518 100644 (file)
--- a/lustre/quota/quota_context.c
+++ b/lustre/quota/quota_context.c
@@ -1573,7 +1573,7 @@ void build_lqs(struct obd_device *obd)
  * string hashing using djb2 hash algorithm
  */
 static unsigned
-lqs_hash(cfs_hash_t *hs, void *key, unsigned mask)
+lqs_hash(cfs_hash_t *hs, const void *key, unsigned mask)
 {
         struct quota_adjust_qunit *lqs_key;
         unsigned hash;
@@ -1597,7 +1597,7 @@ lqs_key(cfs_hlist_node_t *hnode)
 }
 
 static int
-lqs_keycmp(void *key, cfs_hlist_node_t *hnode)
+lqs_keycmp(const void *key, cfs_hlist_node_t *hnode)
 {
         struct lustre_qunit_size *q =
                 cfs_hlist_entry(hnode, struct lustre_qunit_size, lqs_hash);