mac80211: mesh: move some code to make it static
authorJohannes Berg <johannes.berg@intel.com>
Thu, 12 May 2011 11:38:50 +0000 (13:38 +0200)
committerJohn W. Linville <linville@tuxdriver.com>
Thu, 12 May 2011 18:10:55 +0000 (14:10 -0400)
There's no need to have table functions in one
file and all users in another, move the functions
to the right file and make them static. Also move
a static variable to the beginning of the file to
make it easier to find.

Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
net/mac80211/mesh.c
net/mac80211/mesh.h
net/mac80211/mesh_pathtbl.c

index 75378e8..29e9980 100644 (file)
@@ -287,49 +287,6 @@ void mesh_mgmt_ies_add(struct sk_buff *skb, struct ieee80211_sub_if_data *sdata)
        }
 }
 
-u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata, struct mesh_table *tbl)
-{
-       /* Use last four bytes of hw addr and interface index as hash index */
-       return jhash_2words(*(u32 *)(addr+2), sdata->dev->ifindex, tbl->hash_rnd)
-               & tbl->hash_mask;
-}
-
-struct mesh_table *mesh_table_alloc(int size_order)
-{
-       int i;
-       struct mesh_table *newtbl;
-
-       newtbl = kmalloc(sizeof(struct mesh_table), GFP_KERNEL);
-       if (!newtbl)
-               return NULL;
-
-       newtbl->hash_buckets = kzalloc(sizeof(struct hlist_head) *
-                       (1 << size_order), GFP_KERNEL);
-
-       if (!newtbl->hash_buckets) {
-               kfree(newtbl);
-               return NULL;
-       }
-
-       newtbl->hashwlock = kmalloc(sizeof(spinlock_t) *
-                       (1 << size_order), GFP_KERNEL);
-       if (!newtbl->hashwlock) {
-               kfree(newtbl->hash_buckets);
-               kfree(newtbl);
-               return NULL;
-       }
-
-       newtbl->size_order = size_order;
-       newtbl->hash_mask = (1 << size_order) - 1;
-       atomic_set(&newtbl->entries,  0);
-       get_random_bytes(&newtbl->hash_rnd,
-                       sizeof(newtbl->hash_rnd));
-       for (i = 0; i <= newtbl->hash_mask; i++)
-               spin_lock_init(&newtbl->hashwlock[i]);
-
-       return newtbl;
-}
-
 
 static void ieee80211_mesh_path_timer(unsigned long data)
 {
index 10acf1c..5c0c203 100644 (file)
@@ -240,12 +240,8 @@ void mesh_rx_plink_frame(struct ieee80211_sub_if_data *sdata,
 
 /* Private interfaces */
 /* Mesh tables */
-struct mesh_table *mesh_table_alloc(int size_order);
-void mesh_table_free(struct mesh_table *tbl, bool free_leafs);
 void mesh_mpath_table_grow(void);
 void mesh_mpp_table_grow(void);
-u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata,
-               struct mesh_table *tbl);
 /* Mesh paths */
 int mesh_path_error_tx(u8 ttl, u8 *target, __le32 target_sn, __le16 target_rcode,
                       const u8 *ra, struct ieee80211_sub_if_data *sdata);
index c7cb3cc..0aa96cd 100644 (file)
@@ -40,6 +40,50 @@ static struct mesh_table *mesh_paths;
 static struct mesh_table *mpp_paths; /* Store paths for MPP&MAP */
 
 int mesh_paths_generation;
+
+/* This lock will have the grow table function as writer and add / delete nodes
+ * as readers. When reading the table (i.e. doing lookups) we are well protected
+ * by RCU
+ */
+static DEFINE_RWLOCK(pathtbl_resize_lock);
+
+
+static struct mesh_table *mesh_table_alloc(int size_order)
+{
+       int i;
+       struct mesh_table *newtbl;
+
+       newtbl = kmalloc(sizeof(struct mesh_table), GFP_KERNEL);
+       if (!newtbl)
+               return NULL;
+
+       newtbl->hash_buckets = kzalloc(sizeof(struct hlist_head) *
+                       (1 << size_order), GFP_KERNEL);
+
+       if (!newtbl->hash_buckets) {
+               kfree(newtbl);
+               return NULL;
+       }
+
+       newtbl->hashwlock = kmalloc(sizeof(spinlock_t) *
+                       (1 << size_order), GFP_KERNEL);
+       if (!newtbl->hashwlock) {
+               kfree(newtbl->hash_buckets);
+               kfree(newtbl);
+               return NULL;
+       }
+
+       newtbl->size_order = size_order;
+       newtbl->hash_mask = (1 << size_order) - 1;
+       atomic_set(&newtbl->entries,  0);
+       get_random_bytes(&newtbl->hash_rnd,
+                       sizeof(newtbl->hash_rnd));
+       for (i = 0; i <= newtbl->hash_mask; i++)
+               spin_lock_init(&newtbl->hashwlock[i]);
+
+       return newtbl;
+}
+
 static void __mesh_table_free(struct mesh_table *tbl)
 {
        kfree(tbl->hash_buckets);
@@ -47,7 +91,7 @@ static void __mesh_table_free(struct mesh_table *tbl)
        kfree(tbl);
 }
 
-void mesh_table_free(struct mesh_table *tbl, bool free_leafs)
+static void mesh_table_free(struct mesh_table *tbl, bool free_leafs)
 {
        struct hlist_head *mesh_hash;
        struct hlist_node *p, *q;
@@ -66,7 +110,7 @@ void mesh_table_free(struct mesh_table *tbl, bool free_leafs)
 }
 
 static int mesh_table_grow(struct mesh_table *oldtbl,
-               struct mesh_table *newtbl)
+                          struct mesh_table *newtbl)
 {
        struct hlist_head *oldhash;
        struct hlist_node *p, *q;
@@ -97,12 +141,14 @@ errcopy:
        return -ENOMEM;
 }
 
+static u32 mesh_table_hash(u8 *addr, struct ieee80211_sub_if_data *sdata,
+                          struct mesh_table *tbl)
+{
+       /* Use last four bytes of hw addr and interface index as hash index */
+       return jhash_2words(*(u32 *)(addr+2), sdata->dev->ifindex, tbl->hash_rnd)
+               & tbl->hash_mask;
+}
 
-/* This lock will have the grow table function as writer and add / delete nodes
- * as readers. When reading the table (i.e. doing lookups) we are well protected
- * by RCU
- */
-static DEFINE_RWLOCK(pathtbl_resize_lock);
 
 /**
  *