Merge remote-tracking branch 'wireless/master' into mac80211

1 files changed, 73 insertions, 71 deletions

diff --git a/net/batman-adv/vis.c b/net/batman-adv/vis.c
index 2a2ea0681469..5abd1454fb07 100644
--- a/net/batman-adv/vis.c
+++ b/net/batman-adv/vis.c
@@ -41,13 +41,13 @@ static void batadv_free_info(struct kref *ref)
         bat_priv = info->bat_priv;
 
         list_del_init(&info->send_list);
-        spin_lock_bh(&bat_priv->vis_list_lock);
+        spin_lock_bh(&bat_priv->vis.list_lock);
         list_for_each_entry_safe(entry, tmp, &info->recv_list, list) {
                 list_del(&entry->list);
                 kfree(entry);
         }
 
-        spin_unlock_bh(&bat_priv->vis_list_lock);
+        spin_unlock_bh(&bat_priv->vis.list_lock);
         kfree_skb(info->skb_packet);
         kfree(info);
 }
@@ -94,7 +94,7 @@ static uint32_t batadv_vis_info_choose(const void *data, uint32_t size)
 static struct batadv_vis_info *
 batadv_vis_hash_find(struct batadv_priv *bat_priv, const void *data)
 {
-        struct batadv_hashtable *hash = bat_priv->vis_hash;
+        struct batadv_hashtable *hash = bat_priv->vis.hash;
         struct hlist_head *head;
         struct hlist_node *node;
         struct batadv_vis_info *vis_info, *vis_info_tmp = NULL;
@@ -252,7 +252,7 @@ int batadv_vis_seq_print_text(struct seq_file *seq, void *offset)
         struct hlist_head *head;
         struct net_device *net_dev = (struct net_device *)seq->private;
         struct batadv_priv *bat_priv = netdev_priv(net_dev);
-        struct batadv_hashtable *hash = bat_priv->vis_hash;
+        struct batadv_hashtable *hash = bat_priv->vis.hash;
         uint32_t i;
         int ret = 0;
         int vis_server = atomic_read(&bat_priv->vis_mode);
@@ -264,12 +264,12 @@ int batadv_vis_seq_print_text(struct seq_file *seq, void *offset)
         if (vis_server == BATADV_VIS_TYPE_CLIENT_UPDATE)
                 goto out;
 
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
                 batadv_vis_seq_print_text_bucket(seq, head);
         }
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
 
 out:
         if (primary_if)
@@ -285,7 +285,7 @@ static void batadv_send_list_add(struct batadv_priv *bat_priv,
 {
         if (list_empty(&info->send_list)) {
                 kref_get(&info->refcount);
-                list_add_tail(&info->send_list, &bat_priv->vis_send_list);
+                list_add_tail(&info->send_list, &bat_priv->vis.send_list);
         }
 }
 
@@ -311,9 +311,9 @@ static void batadv_recv_list_add(struct batadv_priv *bat_priv,
                 return;
 
         memcpy(entry->mac, mac, ETH_ALEN);
-        spin_lock_bh(&bat_priv->vis_list_lock);
+        spin_lock_bh(&bat_priv->vis.list_lock);
         list_add_tail(&entry->list, recv_list);
-        spin_unlock_bh(&bat_priv->vis_list_lock);
+        spin_unlock_bh(&bat_priv->vis.list_lock);
 }
 
 /* returns 1 if this mac is in the recv_list */
@@ -323,14 +323,14 @@ static int batadv_recv_list_is_in(struct batadv_priv *bat_priv,
 {
         const struct batadv_recvlist_node *entry;
 
-        spin_lock_bh(&bat_priv->vis_list_lock);
+        spin_lock_bh(&bat_priv->vis.list_lock);
         list_for_each_entry(entry, recv_list, list) {
                 if (batadv_compare_eth(entry->mac, mac)) {
-                        spin_unlock_bh(&bat_priv->vis_list_lock);
+                        spin_unlock_bh(&bat_priv->vis.list_lock);
                         return 1;
                 }
         }
-        spin_unlock_bh(&bat_priv->vis_list_lock);
+        spin_unlock_bh(&bat_priv->vis.list_lock);
         return 0;
 }
 
@@ -354,7 +354,7 @@ batadv_add_packet(struct batadv_priv *bat_priv,
 
         *is_new = 0;
         /* sanity check */
-        if (!bat_priv->vis_hash)
+        if (!bat_priv->vis.hash)
                 return NULL;
 
         /* see if the packet is already in vis_hash */
@@ -385,7 +385,7 @@ batadv_add_packet(struct batadv_priv *bat_priv,
                         }
                 }
                 /* remove old entry */
-                batadv_hash_remove(bat_priv->vis_hash, batadv_vis_info_cmp,
+                batadv_hash_remove(bat_priv->vis.hash, batadv_vis_info_cmp,
                                    batadv_vis_info_choose, old_info);
                 batadv_send_list_del(old_info);
                 kref_put(&old_info->refcount, batadv_free_info);
@@ -426,7 +426,7 @@ batadv_add_packet(struct batadv_priv *bat_priv,
         batadv_recv_list_add(bat_priv, &info->recv_list, packet->sender_orig);
 
         /* try to add it */
-        hash_added = batadv_hash_add(bat_priv->vis_hash, batadv_vis_info_cmp,
+        hash_added = batadv_hash_add(bat_priv->vis.hash, batadv_vis_info_cmp,
                                      batadv_vis_info_choose, info,
                                      &info->hash_entry);
         if (hash_added != 0) {
@@ -449,7 +449,7 @@ void batadv_receive_server_sync_packet(struct batadv_priv *bat_priv,
 
         make_broadcast = (vis_server == BATADV_VIS_TYPE_SERVER_SYNC);
 
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
         info = batadv_add_packet(bat_priv, vis_packet, vis_info_len,
                                  &is_new, make_broadcast);
         if (!info)
@@ -461,7 +461,7 @@ void batadv_receive_server_sync_packet(struct batadv_priv *bat_priv,
         if (vis_server == BATADV_VIS_TYPE_SERVER_SYNC && is_new)
                 batadv_send_list_add(bat_priv, info);
 end:
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
 }
 
 /* handle an incoming client update packet and schedule forward if needed. */
@@ -484,7 +484,7 @@ void batadv_receive_client_update_packet(struct batadv_priv *bat_priv,
             batadv_is_my_mac(vis_packet->target_orig))
                 are_target = 1;
 
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
         info = batadv_add_packet(bat_priv, vis_packet, vis_info_len,
                                  &is_new, are_target);
 
@@ -505,7 +505,7 @@ void batadv_receive_client_update_packet(struct batadv_priv *bat_priv,
         }
 
 end:
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
 }
 
 /* Walk the originators and find the VIS server with the best tq. Set the packet
@@ -574,10 +574,11 @@ static int batadv_generate_vis_packet(struct batadv_priv *bat_priv)
         struct hlist_head *head;
         struct batadv_orig_node *orig_node;
         struct batadv_neigh_node *router;
-        struct batadv_vis_info *info = bat_priv->my_vis_info;
+        struct batadv_vis_info *info = bat_priv->vis.my_info;
         struct batadv_vis_packet *packet;
         struct batadv_vis_info_entry *entry;
         struct batadv_tt_common_entry *tt_common_entry;
+        uint8_t *packet_pos;
         int best_tq = -1;
         uint32_t i;
 
@@ -618,8 +619,8 @@ static int batadv_generate_vis_packet(struct batadv_priv *bat_priv)
                                 goto next;
 
                         /* fill one entry into buffer. */
-                        entry = (struct batadv_vis_info_entry *)
-                                      skb_put(info->skb_packet, sizeof(*entry));
+                        packet_pos = skb_put(info->skb_packet, sizeof(*entry));
+                        entry = (struct batadv_vis_info_entry *)packet_pos;
                         memcpy(entry->src,
                                router->if_incoming->net_dev->dev_addr,
                                ETH_ALEN);
@@ -636,7 +637,7 @@ next:
                 rcu_read_unlock();
         }
 
-        hash = bat_priv->tt_local_hash;
+        hash = bat_priv->tt.local_hash;
 
         for (i = 0; i < hash->size; i++) {
                 head = &hash->table[i];
@@ -644,9 +645,8 @@ next:
                 rcu_read_lock();
                 hlist_for_each_entry_rcu(tt_common_entry, node, head,
                                          hash_entry) {
-                        entry = (struct batadv_vis_info_entry *)
-                                        skb_put(info->skb_packet,
-                                                sizeof(*entry));
+                        packet_pos = skb_put(info->skb_packet, sizeof(*entry));
+                        entry = (struct batadv_vis_info_entry *)packet_pos;
                         memset(entry->src, 0, ETH_ALEN);
                         memcpy(entry->dest, tt_common_entry->addr, ETH_ALEN);
                         entry->quality = 0; /* 0 means TT */
@@ -671,7 +671,7 @@ unlock:
 static void batadv_purge_vis_packets(struct batadv_priv *bat_priv)
 {
         uint32_t i;
-        struct batadv_hashtable *hash = bat_priv->vis_hash;
+        struct batadv_hashtable *hash = bat_priv->vis.hash;
         struct hlist_node *node, *node_tmp;
         struct hlist_head *head;
         struct batadv_vis_info *info;
@@ -682,7 +682,7 @@ static void batadv_purge_vis_packets(struct batadv_priv *bat_priv)
                 hlist_for_each_entry_safe(info, node, node_tmp,
                                           head, hash_entry) {
                         /* never purge own data. */
-                        if (info == bat_priv->my_vis_info)
+                        if (info == bat_priv->vis.my_info)
                                 continue;
 
                         if (batadv_has_timed_out(info->first_seen,
@@ -814,34 +814,36 @@ out:
 /* called from timer; send (and maybe generate) vis packet. */
 static void batadv_send_vis_packets(struct work_struct *work)
 {
-        struct delayed_work *delayed_work =
-                container_of(work, struct delayed_work, work);
+        struct delayed_work *delayed_work;
         struct batadv_priv *bat_priv;
+        struct batadv_priv_vis *priv_vis;
         struct batadv_vis_info *info;
 
-        bat_priv = container_of(delayed_work, struct batadv_priv, vis_work);
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        delayed_work = container_of(work, struct delayed_work, work);
+        priv_vis = container_of(delayed_work, struct batadv_priv_vis, work);
+        bat_priv = container_of(priv_vis, struct batadv_priv, vis);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
         batadv_purge_vis_packets(bat_priv);
 
         if (batadv_generate_vis_packet(bat_priv) == 0) {
                 /* schedule if generation was successful */
-                batadv_send_list_add(bat_priv, bat_priv->my_vis_info);
+                batadv_send_list_add(bat_priv, bat_priv->vis.my_info);
         }
 
-        while (!list_empty(&bat_priv->vis_send_list)) {
-                info = list_first_entry(&bat_priv->vis_send_list,
+        while (!list_empty(&bat_priv->vis.send_list)) {
+                info = list_first_entry(&bat_priv->vis.send_list,
                                         typeof(*info), send_list);
 
                 kref_get(&info->refcount);
-                spin_unlock_bh(&bat_priv->vis_hash_lock);
+                spin_unlock_bh(&bat_priv->vis.hash_lock);
 
                 batadv_send_vis_packet(bat_priv, info);
 
-                spin_lock_bh(&bat_priv->vis_hash_lock);
+                spin_lock_bh(&bat_priv->vis.hash_lock);
                 batadv_send_list_del(info);
                 kref_put(&info->refcount, batadv_free_info);
         }
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
         batadv_start_vis_timer(bat_priv);
 }
 
@@ -856,37 +858,37 @@ int batadv_vis_init(struct batadv_priv *bat_priv)
         unsigned long first_seen;
         struct sk_buff *tmp_skb;
 
-        if (bat_priv->vis_hash)
+        if (bat_priv->vis.hash)
                 return 0;
 
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
 
-        bat_priv->vis_hash = batadv_hash_new(256);
-        if (!bat_priv->vis_hash) {
+        bat_priv->vis.hash = batadv_hash_new(256);
+        if (!bat_priv->vis.hash) {
                 pr_err("Can't initialize vis_hash\n");
                 goto err;
         }
 
-        bat_priv->my_vis_info = kmalloc(BATADV_MAX_VIS_PACKET_SIZE, GFP_ATOMIC);
-        if (!bat_priv->my_vis_info)
+        bat_priv->vis.my_info = kmalloc(BATADV_MAX_VIS_PACKET_SIZE, GFP_ATOMIC);
+        if (!bat_priv->vis.my_info)
                 goto err;
 
         len = sizeof(*packet) + BATADV_MAX_VIS_PACKET_SIZE + ETH_HLEN;
-        bat_priv->my_vis_info->skb_packet = dev_alloc_skb(len);
-        if (!bat_priv->my_vis_info->skb_packet)
+        bat_priv->vis.my_info->skb_packet = dev_alloc_skb(len);
+        if (!bat_priv->vis.my_info->skb_packet)
                 goto free_info;
 
-        skb_reserve(bat_priv->my_vis_info->skb_packet, ETH_HLEN);
-        tmp_skb = bat_priv->my_vis_info->skb_packet;
+        skb_reserve(bat_priv->vis.my_info->skb_packet, ETH_HLEN);
+        tmp_skb = bat_priv->vis.my_info->skb_packet;
         packet = (struct batadv_vis_packet *)skb_put(tmp_skb, sizeof(*packet));
 
         /* prefill the vis info */
         first_seen = jiffies - msecs_to_jiffies(BATADV_VIS_INTERVAL);
-        bat_priv->my_vis_info->first_seen = first_seen;
-        INIT_LIST_HEAD(&bat_priv->my_vis_info->recv_list);
-        INIT_LIST_HEAD(&bat_priv->my_vis_info->send_list);
-        kref_init(&bat_priv->my_vis_info->refcount);
-        bat_priv->my_vis_info->bat_priv = bat_priv;
+        bat_priv->vis.my_info->first_seen = first_seen;
+        INIT_LIST_HEAD(&bat_priv->vis.my_info->recv_list);
+        INIT_LIST_HEAD(&bat_priv->vis.my_info->send_list);
+        kref_init(&bat_priv->vis.my_info->refcount);
+        bat_priv->vis.my_info->bat_priv = bat_priv;
         packet->header.version = BATADV_COMPAT_VERSION;
         packet->header.packet_type = BATADV_VIS;
         packet->header.ttl = BATADV_TTL;
@@ -894,28 +896,28 @@ int batadv_vis_init(struct batadv_priv *bat_priv)
         packet->reserved = 0;
         packet->entries = 0;
 
-        INIT_LIST_HEAD(&bat_priv->vis_send_list);
+        INIT_LIST_HEAD(&bat_priv->vis.send_list);
 
-        hash_added = batadv_hash_add(bat_priv->vis_hash, batadv_vis_info_cmp,
+        hash_added = batadv_hash_add(bat_priv->vis.hash, batadv_vis_info_cmp,
                                      batadv_vis_info_choose,
-                                     bat_priv->my_vis_info,
-                                     &bat_priv->my_vis_info->hash_entry);
+                                     bat_priv->vis.my_info,
+                                     &bat_priv->vis.my_info->hash_entry);
         if (hash_added != 0) {
                 pr_err("Can't add own vis packet into hash\n");
                 /* not in hash, need to remove it manually. */
-                kref_put(&bat_priv->my_vis_info->refcount, batadv_free_info);
+                kref_put(&bat_priv->vis.my_info->refcount, batadv_free_info);
                 goto err;
         }
 
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
         batadv_start_vis_timer(bat_priv);
         return 0;
 
 free_info:
-        kfree(bat_priv->my_vis_info);
-        bat_priv->my_vis_info = NULL;
+        kfree(bat_priv->vis.my_info);
+        bat_priv->vis.my_info = NULL;
 err:
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
         batadv_vis_quit(bat_priv);
         return -ENOMEM;
 }
@@ -933,23 +935,23 @@ static void batadv_free_info_ref(struct hlist_node *node, void *arg)
 /* shutdown vis-server */
 void batadv_vis_quit(struct batadv_priv *bat_priv)
 {
-        if (!bat_priv->vis_hash)
+        if (!bat_priv->vis.hash)
                 return;
 
-        cancel_delayed_work_sync(&bat_priv->vis_work);
+        cancel_delayed_work_sync(&bat_priv->vis.work);
 
-        spin_lock_bh(&bat_priv->vis_hash_lock);
+        spin_lock_bh(&bat_priv->vis.hash_lock);
         /* properly remove, kill timers ... */
-        batadv_hash_delete(bat_priv->vis_hash, batadv_free_info_ref, NULL);
-        bat_priv->vis_hash = NULL;
-        bat_priv->my_vis_info = NULL;
-        spin_unlock_bh(&bat_priv->vis_hash_lock);
+        batadv_hash_delete(bat_priv->vis.hash, batadv_free_info_ref, NULL);
+        bat_priv->vis.hash = NULL;
+        bat_priv->vis.my_info = NULL;
+        spin_unlock_bh(&bat_priv->vis.hash_lock);
 }
 
 /* schedule packets for (re)transmission */
 static void batadv_start_vis_timer(struct batadv_priv *bat_priv)
 {
-        INIT_DELAYED_WORK(&bat_priv->vis_work, batadv_send_vis_packets);
-        queue_delayed_work(batadv_event_workqueue, &bat_priv->vis_work,
+        INIT_DELAYED_WORK(&bat_priv->vis.work, batadv_send_vis_packets);
+        queue_delayed_work(batadv_event_workqueue, &bat_priv->vis.work,
                            msecs_to_jiffies(BATADV_VIS_INTERVAL));
 }