mac80211: mesh: move some code to make it static

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>

diff --git a/net/mac80211/mesh.c b/net/mac80211/mesh.c
index 75378e852f00081fb5b818d7526dd8abfacc8eaf..29e9980c8e60c6b704c99ec213308d64c6864a8b 100644 (file)
--- a/net/mac80211/mesh.c
+++ b/net/mac80211/mesh.c
@@ -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)
 {

diff --git a/net/mac80211/mesh.h b/net/mac80211/mesh.h
index 10acf1cc80824b0aa1165c20cab1bdbc7b1a0d38..5c0c20389a1ada5733e19e264d55a50ec3ae2f9a 100644 (file)
--- a/net/mac80211/mesh.h
+++ b/net/mac80211/mesh.h
@@ -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);

diff --git a/net/mac80211/mesh_pathtbl.c b/net/mac80211/mesh_pathtbl.c
index c7cb3cc083dfe1801093bb7d6a066a4da963b3fa..0aa96cd6bd273b78bf32275e9d1a3a3975c29202 100644 (file)
--- a/net/mac80211/mesh_pathtbl.c
+++ b/net/mac80211/mesh_pathtbl.c
@@ -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);
 
 /**
  *