1 files changed, 64 insertions, 127 deletions

diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 799f06e03a22..8fab9b0bb203 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -98,7 +98,7 @@ static const struct file_operations neigh_stat_seq_fops;
 
 static DEFINE_RWLOCK(neigh_tbl_lock);
 
-static int neigh_blackhole(struct sk_buff *skb)
+static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
 {
         kfree_skb(skb);
         return -ENETDOWN;
@@ -137,7 +137,7 @@ static int neigh_forced_gc(struct neigh_table *tbl)
         write_lock_bh(&tbl->lock);
         nht = rcu_dereference_protected(tbl->nht,
                                         lockdep_is_held(&tbl->lock));
-        for (i = 0; i <= nht->hash_mask; i++) {
+        for (i = 0; i < (1 << nht->hash_shift); i++) {
                 struct neighbour *n;
                 struct neighbour __rcu **np;
 
@@ -210,7 +210,7 @@ static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
         nht = rcu_dereference_protected(tbl->nht,
                                         lockdep_is_held(&tbl->lock));
 
-        for (i = 0; i <= nht->hash_mask; i++) {
+        for (i = 0; i < (1 << nht->hash_shift); i++) {
                 struct neighbour *n;
                 struct neighbour __rcu **np = &nht->hash_buckets[i];
 
@@ -297,6 +297,7 @@ static struct neighbour *neigh_alloc(struct neigh_table *tbl)
         n->updated        = n->used = now;
         n->nud_state      = NUD_NONE;
         n->output         = neigh_blackhole;
+        seqlock_init(&n->hh.hh_lock);
         n->parms          = neigh_parms_clone(&tbl->parms);
         setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
 
@@ -312,9 +313,9 @@ out_entries:
         goto out;
 }
 
-static struct neigh_hash_table *neigh_hash_alloc(unsigned int entries)
+static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
 {
-        size_t size = entries * sizeof(struct neighbour *);
+        size_t size = (1 << shift) * sizeof(struct neighbour *);
         struct neigh_hash_table *ret;
         struct neighbour __rcu **buckets;
 
@@ -332,8 +333,9 @@ static struct neigh_hash_table *neigh_hash_alloc(unsigned int entries)
                 return NULL;
         }
         ret->hash_buckets = buckets;
-        ret->hash_mask = entries - 1;
+        ret->hash_shift = shift;
         get_random_bytes(&ret->hash_rnd, sizeof(ret->hash_rnd));
+        ret->hash_rnd |= 1;
         return ret;
 }
 
@@ -342,7 +344,7 @@ static void neigh_hash_free_rcu(struct rcu_head *head)
         struct neigh_hash_table *nht = container_of(head,
                                                     struct neigh_hash_table,
                                                     rcu);
-        size_t size = (nht->hash_mask + 1) * sizeof(struct neighbour *);
+        size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
         struct neighbour __rcu **buckets = nht->hash_buckets;
 
         if (size <= PAGE_SIZE)
@@ -353,21 +355,20 @@ static void neigh_hash_free_rcu(struct rcu_head *head)
 }
 
 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
-                                                unsigned long new_entries)
+                                                unsigned long new_shift)
 {
         unsigned int i, hash;
         struct neigh_hash_table *new_nht, *old_nht;
 
         NEIGH_CACHE_STAT_INC(tbl, hash_grows);
 
-        BUG_ON(!is_power_of_2(new_entries));
         old_nht = rcu_dereference_protected(tbl->nht,
                                             lockdep_is_held(&tbl->lock));
-        new_nht = neigh_hash_alloc(new_entries);
+        new_nht = neigh_hash_alloc(new_shift);
         if (!new_nht)
                 return old_nht;
 
-        for (i = 0; i <= old_nht->hash_mask; i++) {
+        for (i = 0; i < (1 << old_nht->hash_shift); i++) {
                 struct neighbour *n, *next;
 
                 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
@@ -377,7 +378,7 @@ static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
                         hash = tbl->hash(n->primary_key, n->dev,
                                          new_nht->hash_rnd);
 
-                        hash &= new_nht->hash_mask;
+                        hash >>= (32 - new_nht->hash_shift);
                         next = rcu_dereference_protected(n->next,
                                                 lockdep_is_held(&tbl->lock));
 
@@ -406,7 +407,7 @@ struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
 
         rcu_read_lock_bh();
         nht = rcu_dereference_bh(tbl->nht);
-        hash_val = tbl->hash(pkey, dev, nht->hash_rnd) & nht->hash_mask;
+        hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
 
         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
              n != NULL;
@@ -436,7 +437,7 @@ struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
 
         rcu_read_lock_bh();
         nht = rcu_dereference_bh(tbl->nht);
-        hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) & nht->hash_mask;
+        hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
 
         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
              n != NULL;
@@ -492,10 +493,10 @@ struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
         nht = rcu_dereference_protected(tbl->nht,
                                         lockdep_is_held(&tbl->lock));
 
-        if (atomic_read(&tbl->entries) > (nht->hash_mask + 1))
-                nht = neigh_hash_grow(tbl, (nht->hash_mask + 1) << 1);
+        if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
+                nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
 
-        hash_val = tbl->hash(pkey, dev, nht->hash_rnd) & nht->hash_mask;
+        hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
 
         if (n->parms->dead) {
                 rc = ERR_PTR(-EINVAL);
@@ -688,8 +689,6 @@ static void neigh_destroy_rcu(struct rcu_head *head)
  */
 void neigh_destroy(struct neighbour *neigh)
 {
-        struct hh_cache *hh;
-
         NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
 
         if (!neigh->dead) {
@@ -702,16 +701,6 @@ void neigh_destroy(struct neighbour *neigh)
         if (neigh_del_timer(neigh))
                 printk(KERN_WARNING "Impossible event.\n");
 
-        while ((hh = neigh->hh) != NULL) {
-                neigh->hh = hh->hh_next;
-                hh->hh_next = NULL;
-
-                write_seqlock_bh(&hh->hh_lock);
-                hh->hh_output = neigh_blackhole;
-                write_sequnlock_bh(&hh->hh_lock);
-                hh_cache_put(hh);
-        }
-
         skb_queue_purge(&neigh->arp_queue);
 
         dev_put(neigh->dev);
@@ -731,14 +720,9 @@ EXPORT_SYMBOL(neigh_destroy);
  */
 static void neigh_suspect(struct neighbour *neigh)
 {
-        struct hh_cache *hh;
-
         NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
 
         neigh->output = neigh->ops->output;
-
-        for (hh = neigh->hh; hh; hh = hh->hh_next)
-                hh->hh_output = neigh->ops->output;
 }
 
 /* Neighbour state is OK;
@@ -748,14 +732,9 @@ static void neigh_suspect(struct neighbour *neigh)
  */
 static void neigh_connect(struct neighbour *neigh)
 {
-        struct hh_cache *hh;
-
         NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
 
         neigh->output = neigh->ops->connected_output;
-
-        for (hh = neigh->hh; hh; hh = hh->hh_next)
-                hh->hh_output = neigh->ops->hh_output;
 }
 
 static void neigh_periodic_work(struct work_struct *work)
@@ -784,7 +763,7 @@ static void neigh_periodic_work(struct work_struct *work)
                                 neigh_rand_reach_time(p->base_reachable_time);
         }
 
-        for (i = 0 ; i <= nht->hash_mask; i++) {
+        for (i = 0 ; i < (1 << nht->hash_shift); i++) {
                 np = &nht->hash_buckets[i];
 
                 while ((n = rcu_dereference_protected(*np,
@@ -1015,7 +994,7 @@ out_unlock_bh:
 }
 EXPORT_SYMBOL(__neigh_event_send);
 
-static void neigh_update_hhs(const struct neighbour *neigh)
+static void neigh_update_hhs(struct neighbour *neigh)
 {
         struct hh_cache *hh;
         void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
@@ -1025,7 +1004,8 @@ static void neigh_update_hhs(const struct neighbour *neigh)
                 update = neigh->dev->header_ops->cache_update;
 
         if (update) {
-                for (hh = neigh->hh; hh; hh = hh->hh_next) {
+                hh = &neigh->hh;
+                if (hh->hh_len) {
                         write_seqlock_bh(&hh->hh_lock);
                         update(hh, neigh->dev, neigh->ha);
                         write_sequnlock_bh(&hh->hh_lock);
@@ -1173,12 +1153,13 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
 
                 while (neigh->nud_state & NUD_VALID &&
                        (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
-                        struct neighbour *n1 = neigh;
+                        struct dst_entry *dst = skb_dst(skb);
+                        struct neighbour *n2, *n1 = neigh;
                         write_unlock_bh(&neigh->lock);
                         /* On shaper/eql skb->dst->neighbour != neigh :( */
-                        if (skb_dst(skb) && skb_dst(skb)->neighbour)
-                                n1 = skb_dst(skb)->neighbour;
-                        n1->output(skb);
+                        if (dst && (n2 = dst_get_neighbour(dst)) != NULL)
+                                n1 = n2;
+                        n1->output(n1, skb);
                         write_lock_bh(&neigh->lock);
                 }
                 skb_queue_purge(&neigh->arp_queue);
@@ -1211,67 +1192,21 @@ struct neighbour *neigh_event_ns(struct neigh_table *tbl,
 }
 EXPORT_SYMBOL(neigh_event_ns);
 
-static inline bool neigh_hh_lookup(struct neighbour *n, struct dst_entry *dst,
-                                   __be16 protocol)
-{
-        struct hh_cache *hh;
-
-        smp_rmb(); /* paired with smp_wmb() in neigh_hh_init() */
-        for (hh = n->hh; hh; hh = hh->hh_next) {
-                if (hh->hh_type == protocol) {
-                        atomic_inc(&hh->hh_refcnt);
-                        if (unlikely(cmpxchg(&dst->hh, NULL, hh) != NULL))
-                                hh_cache_put(hh);
-                        return true;
-                }
-        }
-        return false;
-}
-
 /* called with read_lock_bh(&n->lock); */
-static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst,
-                          __be16 protocol)
+static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst)
 {
-        struct hh_cache *hh;
         struct net_device *dev = dst->dev;
-
-        if (likely(neigh_hh_lookup(n, dst, protocol)))
-                return;
-
-        /* slow path */
-        hh = kzalloc(sizeof(*hh), GFP_ATOMIC);
-        if (!hh)
-                return;
-
-        seqlock_init(&hh->hh_lock);
-        hh->hh_type = protocol;
-        atomic_set(&hh->hh_refcnt, 2);
-
-        if (dev->header_ops->cache(n, hh)) {
-                kfree(hh);
-                return;
-        }
+        __be16 prot = dst->ops->protocol;
+        struct hh_cache *hh = &n->hh;
 
         write_lock_bh(&n->lock);
 
-        /* must check if another thread already did the insert */
-        if (neigh_hh_lookup(n, dst, protocol)) {
-                kfree(hh);
-                goto end;
-        }
-
-        if (n->nud_state & NUD_CONNECTED)
-                hh->hh_output = n->ops->hh_output;
-        else
-                hh->hh_output = n->ops->output;
-
-        hh->hh_next = n->hh;
-        smp_wmb(); /* paired with smp_rmb() in neigh_hh_lookup() */
-        n->hh       = hh;
+        /* Only one thread can come in here and initialize the
+         * hh_cache entry.
+         */
+        if (!hh->hh_len)
+                dev->header_ops->cache(n, hh, prot);
 
-        if (unlikely(cmpxchg(&dst->hh, NULL, hh) != NULL))
-                hh_cache_put(hh);
-end:
         write_unlock_bh(&n->lock);
 }
 
@@ -1280,7 +1215,7 @@ end:
  * but resolution is not made yet.
  */
 
-int neigh_compat_output(struct sk_buff *skb)
+int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb)
 {
         struct net_device *dev = skb->dev;
 
@@ -1297,13 +1232,12 @@ EXPORT_SYMBOL(neigh_compat_output);
 
 /* Slow and careful. */
 
-int neigh_resolve_output(struct sk_buff *skb)
+int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
 {
         struct dst_entry *dst = skb_dst(skb);
-        struct neighbour *neigh;
         int rc = 0;
 
-        if (!dst || !(neigh = dst->neighbour))
+        if (!dst)
                 goto discard;
 
         __skb_pull(skb, skb_network_offset(skb));
@@ -1313,10 +1247,8 @@ int neigh_resolve_output(struct sk_buff *skb)
                 struct net_device *dev = neigh->dev;
                 unsigned int seq;
 
-                if (dev->header_ops->cache &&
-                    !dst->hh &&
-                    !(dst->flags & DST_NOCACHE))
-                        neigh_hh_init(neigh, dst, dst->ops->protocol);
+                if (dev->header_ops->cache && !neigh->hh.hh_len)
+                        neigh_hh_init(neigh, dst);
 
                 do {
                         seq = read_seqbegin(&neigh->ha_lock);
@@ -1325,7 +1257,7 @@ int neigh_resolve_output(struct sk_buff *skb)
                 } while (read_seqretry(&neigh->ha_lock, seq));
 
                 if (err >= 0)
-                        rc = neigh->ops->queue_xmit(skb);
+                        rc = dev_queue_xmit(skb);
                 else
                         goto out_kfree_skb;
         }
@@ -1333,7 +1265,7 @@ out:
         return rc;
 discard:
         NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n",
-                      dst, dst ? dst->neighbour : NULL);
+                      dst, neigh);
 out_kfree_skb:
         rc = -EINVAL;
         kfree_skb(skb);
@@ -1343,13 +1275,11 @@ EXPORT_SYMBOL(neigh_resolve_output);
 
 /* As fast as possible without hh cache */
 
-int neigh_connected_output(struct sk_buff *skb)
+int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
 {
-        int err;
-        struct dst_entry *dst = skb_dst(skb);
-        struct neighbour *neigh = dst->neighbour;
         struct net_device *dev = neigh->dev;
         unsigned int seq;
+        int err;
 
         __skb_pull(skb, skb_network_offset(skb));
 
@@ -1360,7 +1290,7 @@ int neigh_connected_output(struct sk_buff *skb)
         } while (read_seqretry(&neigh->ha_lock, seq));
 
         if (err >= 0)
-                err = neigh->ops->queue_xmit(skb);
+                err = dev_queue_xmit(skb);
         else {
                 err = -EINVAL;
                 kfree_skb(skb);
@@ -1369,6 +1299,12 @@ int neigh_connected_output(struct sk_buff *skb)
 }
 EXPORT_SYMBOL(neigh_connected_output);
 
+int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
+{
+        return dev_queue_xmit(skb);
+}
+EXPORT_SYMBOL(neigh_direct_output);
+
 static void neigh_proxy_process(unsigned long arg)
 {
         struct neigh_table *tbl = (struct neigh_table *)arg;
@@ -1540,7 +1476,7 @@ void neigh_table_init_no_netlink(struct neigh_table *tbl)
                 panic("cannot create neighbour proc dir entry");
 #endif
 
-        RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(8));
+        RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
 
         phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
         tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
@@ -1857,7 +1793,7 @@ static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
                 rcu_read_lock_bh();
                 nht = rcu_dereference_bh(tbl->nht);
                 ndc.ndtc_hash_rnd = nht->hash_rnd;
-                ndc.ndtc_hash_mask = nht->hash_mask;
+                ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
                 rcu_read_unlock_bh();
 
                 NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc);
@@ -2200,7 +2136,7 @@ static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
         rcu_read_lock_bh();
         nht = rcu_dereference_bh(tbl->nht);
 
-        for (h = 0; h <= nht->hash_mask; h++) {
+        for (h = 0; h < (1 << nht->hash_shift); h++) {
                 if (h < s_h)
                         continue;
                 if (h > s_h)
@@ -2264,7 +2200,7 @@ void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void
         nht = rcu_dereference_bh(tbl->nht);
 
         read_lock(&tbl->lock); /* avoid resizes */
-        for (chain = 0; chain <= nht->hash_mask; chain++) {
+        for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
                 struct neighbour *n;
 
                 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
@@ -2286,7 +2222,7 @@ void __neigh_for_each_release(struct neigh_table *tbl,
 
         nht = rcu_dereference_protected(tbl->nht,
                                         lockdep_is_held(&tbl->lock));
-        for (chain = 0; chain <= nht->hash_mask; chain++) {
+        for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
                 struct neighbour *n;
                 struct neighbour __rcu **np;
 
@@ -2323,7 +2259,7 @@ static struct neighbour *neigh_get_first(struct seq_file *seq)
         int bucket = state->bucket;
 
         state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
-        for (bucket = 0; bucket <= nht->hash_mask; bucket++) {
+        for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
                 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
 
                 while (n) {
@@ -2390,7 +2326,7 @@ next:
                 if (n)
                         break;
 
-                if (++state->bucket > nht->hash_mask)
+                if (++state->bucket >= (1 << nht->hash_shift))
                         break;
 
                 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
@@ -2909,12 +2845,13 @@ EXPORT_SYMBOL(neigh_sysctl_unregister);
 
 static int __init neigh_init(void)
 {
-        rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL);
-        rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL);
-        rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info);
+        rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
+        rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
+        rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
 
-        rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info);
-        rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL);
+        rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
+                      NULL);
+        rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
 
         return 0;
 }