~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/core/neighbour.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *      Generic address resolution entity
  3  *
  4  *      Authors:
  5  *      Pedro Roque             <roque@di.fc.ul.pt>
  6  *      Alexey Kuznetsov        <kuznet@ms2.inr.ac.ru>
  7  *
  8  *      This program is free software; you can redistribute it and/or
  9  *      modify it under the terms of the GNU General Public License
 10  *      as published by the Free Software Foundation; either version
 11  *      2 of the License, or (at your option) any later version.
 12  *
 13  *      Fixes:
 14  *      Vitaly E. Lavrov        releasing NULL neighbor in neigh_add.
 15  *      Harald Welte            Add neighbour cache statistics like rtstat
 16  */
 17 
 18 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 19 
 20 #include <linux/slab.h>
 21 #include <linux/types.h>
 22 #include <linux/kernel.h>
 23 #include <linux/module.h>
 24 #include <linux/socket.h>
 25 #include <linux/netdevice.h>
 26 #include <linux/proc_fs.h>
 27 #ifdef CONFIG_SYSCTL
 28 #include <linux/sysctl.h>
 29 #endif
 30 #include <linux/times.h>
 31 #include <net/net_namespace.h>
 32 #include <net/neighbour.h>
 33 #include <net/dst.h>
 34 #include <net/sock.h>
 35 #include <net/netevent.h>
 36 #include <net/netlink.h>
 37 #include <linux/rtnetlink.h>
 38 #include <linux/random.h>
 39 #include <linux/string.h>
 40 #include <linux/log2.h>
 41 #include <linux/inetdevice.h>
 42 #include <net/addrconf.h>
 43 
 44 #define DEBUG
 45 #define NEIGH_DEBUG 1
 46 #define neigh_dbg(level, fmt, ...)              \
 47 do {                                            \
 48         if (level <= NEIGH_DEBUG)               \
 49                 pr_debug(fmt, ##__VA_ARGS__);   \
 50 } while (0)
 51 
 52 #define PNEIGH_HASHMASK         0xF
 53 
 54 static void neigh_timer_handler(unsigned long arg);
 55 static void __neigh_notify(struct neighbour *n, int type, int flags);
 56 static void neigh_update_notify(struct neighbour *neigh);
 57 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
 58 
 59 #ifdef CONFIG_PROC_FS
 60 static const struct file_operations neigh_stat_seq_fops;
 61 #endif
 62 
 63 /*
 64    Neighbour hash table buckets are protected with rwlock tbl->lock.
 65 
 66    - All the scans/updates to hash buckets MUST be made under this lock.
 67    - NOTHING clever should be made under this lock: no callbacks
 68      to protocol backends, no attempts to send something to network.
 69      It will result in deadlocks, if backend/driver wants to use neighbour
 70      cache.
 71    - If the entry requires some non-trivial actions, increase
 72      its reference count and release table lock.
 73 
 74    Neighbour entries are protected:
 75    - with reference count.
 76    - with rwlock neigh->lock
 77 
 78    Reference count prevents destruction.
 79 
 80    neigh->lock mainly serializes ll address data and its validity state.
 81    However, the same lock is used to protect another entry fields:
 82     - timer
 83     - resolution queue
 84 
 85    Again, nothing clever shall be made under neigh->lock,
 86    the most complicated procedure, which we allow is dev->hard_header.
 87    It is supposed, that dev->hard_header is simplistic and does
 88    not make callbacks to neighbour tables.
 89  */
 90 
 91 static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
 92 {
 93         kfree_skb(skb);
 94         return -ENETDOWN;
 95 }
 96 
 97 static void neigh_cleanup_and_release(struct neighbour *neigh)
 98 {
 99         if (neigh->parms->neigh_cleanup)
100                 neigh->parms->neigh_cleanup(neigh);
101 
102         __neigh_notify(neigh, RTM_DELNEIGH, 0);
103         neigh_release(neigh);
104 }
105 
106 /*
107  * It is random distribution in the interval (1/2)*base...(3/2)*base.
108  * It corresponds to default IPv6 settings and is not overridable,
109  * because it is really reasonable choice.
110  */
111 
112 unsigned long neigh_rand_reach_time(unsigned long base)
113 {
114         return base ? (prandom_u32() % base) + (base >> 1) : 0;
115 }
116 EXPORT_SYMBOL(neigh_rand_reach_time);
117 
118 
119 static int neigh_forced_gc(struct neigh_table *tbl)
120 {
121         int shrunk = 0;
122         int i;
123         struct neigh_hash_table *nht;
124 
125         NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
126 
127         write_lock_bh(&tbl->lock);
128         nht = rcu_dereference_protected(tbl->nht,
129                                         lockdep_is_held(&tbl->lock));
130         for (i = 0; i < (1 << nht->hash_shift); i++) {
131                 struct neighbour *n;
132                 struct neighbour __rcu **np;
133 
134                 np = &nht->hash_buckets[i];
135                 while ((n = rcu_dereference_protected(*np,
136                                         lockdep_is_held(&tbl->lock))) != NULL) {
137                         /* Neighbour record may be discarded if:
138                          * - nobody refers to it.
139                          * - it is not permanent
140                          */
141                         write_lock(&n->lock);
142                         if (atomic_read(&n->refcnt) == 1 &&
143                             !(n->nud_state & NUD_PERMANENT)) {
144                                 rcu_assign_pointer(*np,
145                                         rcu_dereference_protected(n->next,
146                                                   lockdep_is_held(&tbl->lock)));
147                                 n->dead = 1;
148                                 shrunk  = 1;
149                                 write_unlock(&n->lock);
150                                 neigh_cleanup_and_release(n);
151                                 continue;
152                         }
153                         write_unlock(&n->lock);
154                         np = &n->next;
155                 }
156         }
157 
158         tbl->last_flush = jiffies;
159 
160         write_unlock_bh(&tbl->lock);
161 
162         return shrunk;
163 }
164 
165 static void neigh_add_timer(struct neighbour *n, unsigned long when)
166 {
167         neigh_hold(n);
168         if (unlikely(mod_timer(&n->timer, when))) {
169                 printk("NEIGH: BUG, double timer add, state is %x\n",
170                        n->nud_state);
171                 dump_stack();
172         }
173 }
174 
175 static int neigh_del_timer(struct neighbour *n)
176 {
177         if ((n->nud_state & NUD_IN_TIMER) &&
178             del_timer(&n->timer)) {
179                 neigh_release(n);
180                 return 1;
181         }
182         return 0;
183 }
184 
185 static void pneigh_queue_purge(struct sk_buff_head *list)
186 {
187         struct sk_buff *skb;
188 
189         while ((skb = skb_dequeue(list)) != NULL) {
190                 dev_put(skb->dev);
191                 kfree_skb(skb);
192         }
193 }
194 
195 static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
196 {
197         int i;
198         struct neigh_hash_table *nht;
199 
200         nht = rcu_dereference_protected(tbl->nht,
201                                         lockdep_is_held(&tbl->lock));
202 
203         for (i = 0; i < (1 << nht->hash_shift); i++) {
204                 struct neighbour *n;
205                 struct neighbour __rcu **np = &nht->hash_buckets[i];
206 
207                 while ((n = rcu_dereference_protected(*np,
208                                         lockdep_is_held(&tbl->lock))) != NULL) {
209                         if (dev && n->dev != dev) {
210                                 np = &n->next;
211                                 continue;
212                         }
213                         rcu_assign_pointer(*np,
214                                    rcu_dereference_protected(n->next,
215                                                 lockdep_is_held(&tbl->lock)));
216                         write_lock(&n->lock);
217                         neigh_del_timer(n);
218                         n->dead = 1;
219 
220                         if (atomic_read(&n->refcnt) != 1) {
221                                 /* The most unpleasant situation.
222                                    We must destroy neighbour entry,
223                                    but someone still uses it.
224 
225                                    The destroy will be delayed until
226                                    the last user releases us, but
227                                    we must kill timers etc. and move
228                                    it to safe state.
229                                  */
230                                 __skb_queue_purge(&n->arp_queue);
231                                 n->arp_queue_len_bytes = 0;
232                                 n->output = neigh_blackhole;
233                                 if (n->nud_state & NUD_VALID)
234                                         n->nud_state = NUD_NOARP;
235                                 else
236                                         n->nud_state = NUD_NONE;
237                                 neigh_dbg(2, "neigh %p is stray\n", n);
238                         }
239                         write_unlock(&n->lock);
240                         neigh_cleanup_and_release(n);
241                 }
242         }
243 }
244 
245 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
246 {
247         write_lock_bh(&tbl->lock);
248         neigh_flush_dev(tbl, dev);
249         write_unlock_bh(&tbl->lock);
250 }
251 EXPORT_SYMBOL(neigh_changeaddr);
252 
253 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
254 {
255         write_lock_bh(&tbl->lock);
256         neigh_flush_dev(tbl, dev);
257         pneigh_ifdown(tbl, dev);
258         write_unlock_bh(&tbl->lock);
259 
260         del_timer_sync(&tbl->proxy_timer);
261         pneigh_queue_purge(&tbl->proxy_queue);
262         return 0;
263 }
264 EXPORT_SYMBOL(neigh_ifdown);
265 
266 static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev)
267 {
268         struct neighbour *n = NULL;
269         unsigned long now = jiffies;
270         int entries;
271 
272         entries = atomic_inc_return(&tbl->entries) - 1;
273         if (entries >= tbl->gc_thresh3 ||
274             (entries >= tbl->gc_thresh2 &&
275              time_after(now, tbl->last_flush + 5 * HZ))) {
276                 if (!neigh_forced_gc(tbl) &&
277                     entries >= tbl->gc_thresh3)
278                         goto out_entries;
279         }
280 
281         n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
282         if (!n)
283                 goto out_entries;
284 
285         __skb_queue_head_init(&n->arp_queue);
286         rwlock_init(&n->lock);
287         seqlock_init(&n->ha_lock);
288         n->updated        = n->used = now;
289         n->nud_state      = NUD_NONE;
290         n->output         = neigh_blackhole;
291         seqlock_init(&n->hh.hh_lock);
292         n->parms          = neigh_parms_clone(&tbl->parms);
293         setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
294 
295         NEIGH_CACHE_STAT_INC(tbl, allocs);
296         n->tbl            = tbl;
297         atomic_set(&n->refcnt, 1);
298         n->dead           = 1;
299 out:
300         return n;
301 
302 out_entries:
303         atomic_dec(&tbl->entries);
304         goto out;
305 }
306 
307 static void neigh_get_hash_rnd(u32 *x)
308 {
309         get_random_bytes(x, sizeof(*x));
310         *x |= 1;
311 }
312 
313 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
314 {
315         size_t size = (1 << shift) * sizeof(struct neighbour *);
316         struct neigh_hash_table *ret;
317         struct neighbour __rcu **buckets;
318         int i;
319 
320         ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
321         if (!ret)
322                 return NULL;
323         if (size <= PAGE_SIZE)
324                 buckets = kzalloc(size, GFP_ATOMIC);
325         else
326                 buckets = (struct neighbour __rcu **)
327                           __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
328                                            get_order(size));
329         if (!buckets) {
330                 kfree(ret);
331                 return NULL;
332         }
333         ret->hash_buckets = buckets;
334         ret->hash_shift = shift;
335         for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
336                 neigh_get_hash_rnd(&ret->hash_rnd[i]);
337         return ret;
338 }
339 
340 static void neigh_hash_free_rcu(struct rcu_head *head)
341 {
342         struct neigh_hash_table *nht = container_of(head,
343                                                     struct neigh_hash_table,
344                                                     rcu);
345         size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
346         struct neighbour __rcu **buckets = nht->hash_buckets;
347 
348         if (size <= PAGE_SIZE)
349                 kfree(buckets);
350         else
351                 free_pages((unsigned long)buckets, get_order(size));
352         kfree(nht);
353 }
354 
355 static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
356                                                 unsigned long new_shift)
357 {
358         unsigned int i, hash;
359         struct neigh_hash_table *new_nht, *old_nht;
360 
361         NEIGH_CACHE_STAT_INC(tbl, hash_grows);
362 
363         old_nht = rcu_dereference_protected(tbl->nht,
364                                             lockdep_is_held(&tbl->lock));
365         new_nht = neigh_hash_alloc(new_shift);
366         if (!new_nht)
367                 return old_nht;
368 
369         for (i = 0; i < (1 << old_nht->hash_shift); i++) {
370                 struct neighbour *n, *next;
371 
372                 for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
373                                                    lockdep_is_held(&tbl->lock));
374                      n != NULL;
375                      n = next) {
376                         hash = tbl->hash(n->primary_key, n->dev,
377                                          new_nht->hash_rnd);
378 
379                         hash >>= (32 - new_nht->hash_shift);
380                         next = rcu_dereference_protected(n->next,
381                                                 lockdep_is_held(&tbl->lock));
382 
383                         rcu_assign_pointer(n->next,
384                                            rcu_dereference_protected(
385                                                 new_nht->hash_buckets[hash],
386                                                 lockdep_is_held(&tbl->lock)));
387                         rcu_assign_pointer(new_nht->hash_buckets[hash], n);
388                 }
389         }
390 
391         rcu_assign_pointer(tbl->nht, new_nht);
392         call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
393         return new_nht;
394 }
395 
396 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
397                                struct net_device *dev)
398 {
399         struct neighbour *n;
400         int key_len = tbl->key_len;
401         u32 hash_val;
402         struct neigh_hash_table *nht;
403 
404         NEIGH_CACHE_STAT_INC(tbl, lookups);
405 
406         rcu_read_lock_bh();
407         nht = rcu_dereference_bh(tbl->nht);
408         hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
409 
410         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
411              n != NULL;
412              n = rcu_dereference_bh(n->next)) {
413                 if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
414                         if (!atomic_inc_not_zero(&n->refcnt))
415                                 n = NULL;
416                         NEIGH_CACHE_STAT_INC(tbl, hits);
417                         break;
418                 }
419         }
420 
421         rcu_read_unlock_bh();
422         return n;
423 }
424 EXPORT_SYMBOL(neigh_lookup);
425 
426 struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
427                                      const void *pkey)
428 {
429         struct neighbour *n;
430         int key_len = tbl->key_len;
431         u32 hash_val;
432         struct neigh_hash_table *nht;
433 
434         NEIGH_CACHE_STAT_INC(tbl, lookups);
435 
436         rcu_read_lock_bh();
437         nht = rcu_dereference_bh(tbl->nht);
438         hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
439 
440         for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
441              n != NULL;
442              n = rcu_dereference_bh(n->next)) {
443                 if (!memcmp(n->primary_key, pkey, key_len) &&
444                     net_eq(dev_net(n->dev), net)) {
445                         if (!atomic_inc_not_zero(&n->refcnt))
446                                 n = NULL;
447                         NEIGH_CACHE_STAT_INC(tbl, hits);
448                         break;
449                 }
450         }
451 
452         rcu_read_unlock_bh();
453         return n;
454 }
455 EXPORT_SYMBOL(neigh_lookup_nodev);
456 
457 struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
458                                  struct net_device *dev, bool want_ref)
459 {
460         u32 hash_val;
461         int key_len = tbl->key_len;
462         int error;
463         struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev);
464         struct neigh_hash_table *nht;
465 
466         if (!n) {
467                 rc = ERR_PTR(-ENOBUFS);
468                 goto out;
469         }
470 
471         memcpy(n->primary_key, pkey, key_len);
472         n->dev = dev;
473         dev_hold(dev);
474 
475         /* Protocol specific setup. */
476         if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
477                 rc = ERR_PTR(error);
478                 goto out_neigh_release;
479         }
480 
481         if (dev->netdev_ops->ndo_neigh_construct) {
482                 error = dev->netdev_ops->ndo_neigh_construct(n);
483                 if (error < 0) {
484                         rc = ERR_PTR(error);
485                         goto out_neigh_release;
486                 }
487         }
488 
489         /* Device specific setup. */
490         if (n->parms->neigh_setup &&
491             (error = n->parms->neigh_setup(n)) < 0) {
492                 rc = ERR_PTR(error);
493                 goto out_neigh_release;
494         }
495 
496         n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1);
497 
498         write_lock_bh(&tbl->lock);
499         nht = rcu_dereference_protected(tbl->nht,
500                                         lockdep_is_held(&tbl->lock));
501 
502         if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
503                 nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
504 
505         hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
506 
507         if (n->parms->dead) {
508                 rc = ERR_PTR(-EINVAL);
509                 goto out_tbl_unlock;
510         }
511 
512         for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
513                                             lockdep_is_held(&tbl->lock));
514              n1 != NULL;
515              n1 = rcu_dereference_protected(n1->next,
516                         lockdep_is_held(&tbl->lock))) {
517                 if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
518                         if (want_ref)
519                                 neigh_hold(n1);
520                         rc = n1;
521                         goto out_tbl_unlock;
522                 }
523         }
524 
525         n->dead = 0;
526         if (want_ref)
527                 neigh_hold(n);
528         rcu_assign_pointer(n->next,
529                            rcu_dereference_protected(nht->hash_buckets[hash_val],
530                                                      lockdep_is_held(&tbl->lock)));
531         rcu_assign_pointer(nht->hash_buckets[hash_val], n);
532         write_unlock_bh(&tbl->lock);
533         neigh_dbg(2, "neigh %p is created\n", n);
534         rc = n;
535 out:
536         return rc;
537 out_tbl_unlock:
538         write_unlock_bh(&tbl->lock);
539 out_neigh_release:
540         neigh_release(n);
541         goto out;
542 }
543 EXPORT_SYMBOL(__neigh_create);
544 
545 static u32 pneigh_hash(const void *pkey, int key_len)
546 {
547         u32 hash_val = *(u32 *)(pkey + key_len - 4);
548         hash_val ^= (hash_val >> 16);
549         hash_val ^= hash_val >> 8;
550         hash_val ^= hash_val >> 4;
551         hash_val &= PNEIGH_HASHMASK;
552         return hash_val;
553 }
554 
555 static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
556                                               struct net *net,
557                                               const void *pkey,
558                                               int key_len,
559                                               struct net_device *dev)
560 {
561         while (n) {
562                 if (!memcmp(n->key, pkey, key_len) &&
563                     net_eq(pneigh_net(n), net) &&
564                     (n->dev == dev || !n->dev))
565                         return n;
566                 n = n->next;
567         }
568         return NULL;
569 }
570 
571 struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
572                 struct net *net, const void *pkey, struct net_device *dev)
573 {
574         int key_len = tbl->key_len;
575         u32 hash_val = pneigh_hash(pkey, key_len);
576 
577         return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
578                                  net, pkey, key_len, dev);
579 }
580 EXPORT_SYMBOL_GPL(__pneigh_lookup);
581 
582 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
583                                     struct net *net, const void *pkey,
584                                     struct net_device *dev, int creat)
585 {
586         struct pneigh_entry *n;
587         int key_len = tbl->key_len;
588         u32 hash_val = pneigh_hash(pkey, key_len);
589 
590         read_lock_bh(&tbl->lock);
591         n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
592                               net, pkey, key_len, dev);
593         read_unlock_bh(&tbl->lock);
594 
595         if (n || !creat)
596                 goto out;
597 
598         ASSERT_RTNL();
599 
600         n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
601         if (!n)
602                 goto out;
603 
604         write_pnet(&n->net, hold_net(net));
605         memcpy(n->key, pkey, key_len);
606         n->dev = dev;
607         if (dev)
608                 dev_hold(dev);
609 
610         if (tbl->pconstructor && tbl->pconstructor(n)) {
611                 if (dev)
612                         dev_put(dev);
613                 release_net(net);
614                 kfree(n);
615                 n = NULL;
616                 goto out;
617         }
618 
619         write_lock_bh(&tbl->lock);
620         n->next = tbl->phash_buckets[hash_val];
621         tbl->phash_buckets[hash_val] = n;
622         write_unlock_bh(&tbl->lock);
623 out:
624         return n;
625 }
626 EXPORT_SYMBOL(pneigh_lookup);
627 
628 
629 int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
630                   struct net_device *dev)
631 {
632         struct pneigh_entry *n, **np;
633         int key_len = tbl->key_len;
634         u32 hash_val = pneigh_hash(pkey, key_len);
635 
636         write_lock_bh(&tbl->lock);
637         for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
638              np = &n->next) {
639                 if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
640                     net_eq(pneigh_net(n), net)) {
641                         *np = n->next;
642                         write_unlock_bh(&tbl->lock);
643                         if (tbl->pdestructor)
644                                 tbl->pdestructor(n);
645                         if (n->dev)
646                                 dev_put(n->dev);
647                         release_net(pneigh_net(n));
648                         kfree(n);
649                         return 0;
650                 }
651         }
652         write_unlock_bh(&tbl->lock);
653         return -ENOENT;
654 }
655 
656 static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
657 {
658         struct pneigh_entry *n, **np;
659         u32 h;
660 
661         for (h = 0; h <= PNEIGH_HASHMASK; h++) {
662                 np = &tbl->phash_buckets[h];
663                 while ((n = *np) != NULL) {
664                         if (!dev || n->dev == dev) {
665                                 *np = n->next;
666                                 if (tbl->pdestructor)
667                                         tbl->pdestructor(n);
668                                 if (n->dev)
669                                         dev_put(n->dev);
670                                 release_net(pneigh_net(n));
671                                 kfree(n);
672                                 continue;
673                         }
674                         np = &n->next;
675                 }
676         }
677         return -ENOENT;
678 }
679 
680 static void neigh_parms_destroy(struct neigh_parms *parms);
681 
682 static inline void neigh_parms_put(struct neigh_parms *parms)
683 {
684         if (atomic_dec_and_test(&parms->refcnt))
685                 neigh_parms_destroy(parms);
686 }
687 
688 /*
689  *      neighbour must already be out of the table;
690  *
691  */
692 void neigh_destroy(struct neighbour *neigh)
693 {
694         struct net_device *dev = neigh->dev;
695 
696         NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
697 
698         if (!neigh->dead) {
699                 pr_warn("Destroying alive neighbour %p\n", neigh);
700                 dump_stack();
701                 return;
702         }
703 
704         if (neigh_del_timer(neigh))
705                 pr_warn("Impossible event\n");
706 
707         write_lock_bh(&neigh->lock);
708         __skb_queue_purge(&neigh->arp_queue);
709         write_unlock_bh(&neigh->lock);
710         neigh->arp_queue_len_bytes = 0;
711 
712         if (dev->netdev_ops->ndo_neigh_destroy)
713                 dev->netdev_ops->ndo_neigh_destroy(neigh);
714 
715         dev_put(dev);
716         neigh_parms_put(neigh->parms);
717 
718         neigh_dbg(2, "neigh %p is destroyed\n", neigh);
719 
720         atomic_dec(&neigh->tbl->entries);
721         kfree_rcu(neigh, rcu);
722 }
723 EXPORT_SYMBOL(neigh_destroy);
724 
725 /* Neighbour state is suspicious;
726    disable fast path.
727 
728    Called with write_locked neigh.
729  */
730 static void neigh_suspect(struct neighbour *neigh)
731 {
732         neigh_dbg(2, "neigh %p is suspected\n", neigh);
733 
734         neigh->output = neigh->ops->output;
735 }
736 
737 /* Neighbour state is OK;
738    enable fast path.
739 
740    Called with write_locked neigh.
741  */
742 static void neigh_connect(struct neighbour *neigh)
743 {
744         neigh_dbg(2, "neigh %p is connected\n", neigh);
745 
746         neigh->output = neigh->ops->connected_output;
747 }
748 
749 static void neigh_periodic_work(struct work_struct *work)
750 {
751         struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
752         struct neighbour *n;
753         struct neighbour __rcu **np;
754         unsigned int i;
755         struct neigh_hash_table *nht;
756 
757         NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
758 
759         write_lock_bh(&tbl->lock);
760         nht = rcu_dereference_protected(tbl->nht,
761                                         lockdep_is_held(&tbl->lock));
762 
763         /*
764          *      periodically recompute ReachableTime from random function
765          */
766 
767         if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
768                 struct neigh_parms *p;
769                 tbl->last_rand = jiffies;
770                 list_for_each_entry(p, &tbl->parms_list, list)
771                         p->reachable_time =
772                                 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
773         }
774 
775         if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
776                 goto out;
777 
778         for (i = 0 ; i < (1 << nht->hash_shift); i++) {
779                 np = &nht->hash_buckets[i];
780 
781                 while ((n = rcu_dereference_protected(*np,
782                                 lockdep_is_held(&tbl->lock))) != NULL) {
783                         unsigned int state;
784 
785                         write_lock(&n->lock);
786 
787                         state = n->nud_state;
788                         if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
789                                 write_unlock(&n->lock);
790                                 goto next_elt;
791                         }
792 
793                         if (time_before(n->used, n->confirmed))
794                                 n->used = n->confirmed;
795 
796                         if (atomic_read(&n->refcnt) == 1 &&
797                             (state == NUD_FAILED ||
798                              time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
799                                 *np = n->next;
800                                 n->dead = 1;
801                                 write_unlock(&n->lock);
802                                 neigh_cleanup_and_release(n);
803                                 continue;
804                         }
805                         write_unlock(&n->lock);
806 
807 next_elt:
808                         np = &n->next;
809                 }
810                 /*
811                  * It's fine to release lock here, even if hash table
812                  * grows while we are preempted.
813                  */
814                 write_unlock_bh(&tbl->lock);
815                 cond_resched();
816                 write_lock_bh(&tbl->lock);
817                 nht = rcu_dereference_protected(tbl->nht,
818                                                 lockdep_is_held(&tbl->lock));
819         }
820 out:
821         /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
822          * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
823          * BASE_REACHABLE_TIME.
824          */
825         queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
826                               NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1);
827         write_unlock_bh(&tbl->lock);
828 }
829 
830 static __inline__ int neigh_max_probes(struct neighbour *n)
831 {
832         struct neigh_parms *p = n->parms;
833         int max_probes = NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES);
834         if (!(n->nud_state & NUD_PROBE))
835                 max_probes += NEIGH_VAR(p, MCAST_PROBES);
836         return max_probes;
837 }
838 
839 static void neigh_invalidate(struct neighbour *neigh)
840         __releases(neigh->lock)
841         __acquires(neigh->lock)
842 {
843         struct sk_buff *skb;
844 
845         NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
846         neigh_dbg(2, "neigh %p is failed\n", neigh);
847         neigh->updated = jiffies;
848 
849         /* It is very thin place. report_unreachable is very complicated
850            routine. Particularly, it can hit the same neighbour entry!
851 
852            So that, we try to be accurate and avoid dead loop. --ANK
853          */
854         while (neigh->nud_state == NUD_FAILED &&
855                (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
856                 write_unlock(&neigh->lock);
857                 neigh->ops->error_report(neigh, skb);
858                 write_lock(&neigh->lock);
859         }
860         __skb_queue_purge(&neigh->arp_queue);
861         neigh->arp_queue_len_bytes = 0;
862 }
863 
864 static void neigh_probe(struct neighbour *neigh)
865         __releases(neigh->lock)
866 {
867         struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue);
868         /* keep skb alive even if arp_queue overflows */
869         if (skb)
870                 skb = skb_copy(skb, GFP_ATOMIC);
871         write_unlock(&neigh->lock);
872         neigh->ops->solicit(neigh, skb);
873         atomic_inc(&neigh->probes);
874         kfree_skb(skb);
875 }
876 
877 /* Called when a timer expires for a neighbour entry. */
878 
879 static void neigh_timer_handler(unsigned long arg)
880 {
881         unsigned long now, next;
882         struct neighbour *neigh = (struct neighbour *)arg;
883         unsigned int state;
884         int notify = 0;
885 
886         write_lock(&neigh->lock);
887 
888         state = neigh->nud_state;
889         now = jiffies;
890         next = now + HZ;
891 
892         if (!(state & NUD_IN_TIMER))
893                 goto out;
894 
895         if (state & NUD_REACHABLE) {
896                 if (time_before_eq(now,
897                                    neigh->confirmed + neigh->parms->reachable_time)) {
898                         neigh_dbg(2, "neigh %p is still alive\n", neigh);
899                         next = neigh->confirmed + neigh->parms->reachable_time;
900                 } else if (time_before_eq(now,
901                                           neigh->used +
902                                           NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
903                         neigh_dbg(2, "neigh %p is delayed\n", neigh);
904                         neigh->nud_state = NUD_DELAY;
905                         neigh->updated = jiffies;
906                         neigh_suspect(neigh);
907                         next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
908                 } else {
909                         neigh_dbg(2, "neigh %p is suspected\n", neigh);
910                         neigh->nud_state = NUD_STALE;
911                         neigh->updated = jiffies;
912                         neigh_suspect(neigh);
913                         notify = 1;
914                 }
915         } else if (state & NUD_DELAY) {
916                 if (time_before_eq(now,
917                                    neigh->confirmed +
918                                    NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
919                         neigh_dbg(2, "neigh %p is now reachable\n", neigh);
920                         neigh->nud_state = NUD_REACHABLE;
921                         neigh->updated = jiffies;
922                         neigh_connect(neigh);
923                         notify = 1;
924                         next = neigh->confirmed + neigh->parms->reachable_time;
925                 } else {
926                         neigh_dbg(2, "neigh %p is probed\n", neigh);
927                         neigh->nud_state = NUD_PROBE;
928                         neigh->updated = jiffies;
929                         atomic_set(&neigh->probes, 0);
930                         next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
931                 }
932         } else {
933                 /* NUD_PROBE|NUD_INCOMPLETE */
934                 next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
935         }
936 
937         if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
938             atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
939                 neigh->nud_state = NUD_FAILED;
940                 notify = 1;
941                 neigh_invalidate(neigh);
942                 goto out;
943         }
944 
945         if (neigh->nud_state & NUD_IN_TIMER) {
946                 if (time_before(next, jiffies + HZ/2))
947                         next = jiffies + HZ/2;
948                 if (!mod_timer(&neigh->timer, next))
949                         neigh_hold(neigh);
950         }
951         if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
952                 neigh_probe(neigh);
953         } else {
954 out:
955                 write_unlock(&neigh->lock);
956         }
957 
958         if (notify)
959                 neigh_update_notify(neigh);
960 
961         neigh_release(neigh);
962 }
963 
964 int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
965 {
966         int rc;
967         bool immediate_probe = false;
968 
969         write_lock_bh(&neigh->lock);
970 
971         rc = 0;
972         if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
973                 goto out_unlock_bh;
974         if (neigh->dead)
975                 goto out_dead;
976 
977         if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
978                 if (NEIGH_VAR(neigh->parms, MCAST_PROBES) +
979                     NEIGH_VAR(neigh->parms, APP_PROBES)) {
980                         unsigned long next, now = jiffies;
981 
982                         atomic_set(&neigh->probes,
983                                    NEIGH_VAR(neigh->parms, UCAST_PROBES));
984                         neigh->nud_state     = NUD_INCOMPLETE;
985                         neigh->updated = now;
986                         next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
987                                          HZ/2);
988                         neigh_add_timer(neigh, next);
989                         immediate_probe = true;
990                 } else {
991                         neigh->nud_state = NUD_FAILED;
992                         neigh->updated = jiffies;
993                         write_unlock_bh(&neigh->lock);
994 
995                         kfree_skb(skb);
996                         return 1;
997                 }
998         } else if (neigh->nud_state & NUD_STALE) {
999                 neigh_dbg(2, "neigh %p is delayed\n", neigh);
1000                 neigh->nud_state = NUD_DELAY;
1001                 neigh->updated = jiffies;
1002                 neigh_add_timer(neigh, jiffies +
1003                                 NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME));
1004         }
1005 
1006         if (neigh->nud_state == NUD_INCOMPLETE) {
1007                 if (skb) {
1008                         while (neigh->arp_queue_len_bytes + skb->truesize >
1009                                NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) {
1010                                 struct sk_buff *buff;
1011 
1012                                 buff = __skb_dequeue(&neigh->arp_queue);
1013                                 if (!buff)
1014                                         break;
1015                                 neigh->arp_queue_len_bytes -= buff->truesize;
1016                                 kfree_skb(buff);
1017                                 NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
1018                         }
1019                         skb_dst_force(skb);
1020                         __skb_queue_tail(&neigh->arp_queue, skb);
1021                         neigh->arp_queue_len_bytes += skb->truesize;
1022                 }
1023                 rc = 1;
1024         }
1025 out_unlock_bh:
1026         if (immediate_probe)
1027                 neigh_probe(neigh);
1028         else
1029                 write_unlock(&neigh->lock);
1030         local_bh_enable();
1031         return rc;
1032 
1033 out_dead:
1034         if (neigh->nud_state & NUD_STALE)
1035                 goto out_unlock_bh;
1036         write_unlock_bh(&neigh->lock);
1037         kfree_skb(skb);
1038         return 1;
1039 }
1040 EXPORT_SYMBOL(__neigh_event_send);
1041 
1042 static void neigh_update_hhs(struct neighbour *neigh)
1043 {
1044         struct hh_cache *hh;
1045         void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
1046                 = NULL;
1047 
1048         if (neigh->dev->header_ops)
1049                 update = neigh->dev->header_ops->cache_update;
1050 
1051         if (update) {
1052                 hh = &neigh->hh;
1053                 if (hh->hh_len) {
1054                         write_seqlock_bh(&hh->hh_lock);
1055                         update(hh, neigh->dev, neigh->ha);
1056                         write_sequnlock_bh(&hh->hh_lock);
1057                 }
1058         }
1059 }
1060 
1061 
1062 
1063 /* Generic update routine.
1064    -- lladdr is new lladdr or NULL, if it is not supplied.
1065    -- new    is new state.
1066    -- flags
1067         NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
1068                                 if it is different.
1069         NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
1070                                 lladdr instead of overriding it
1071                                 if it is different.
1072                                 It also allows to retain current state
1073                                 if lladdr is unchanged.
1074         NEIGH_UPDATE_F_ADMIN    means that the change is administrative.
1075 
1076         NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
1077                                 NTF_ROUTER flag.
1078         NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
1079                                 a router.
1080 
1081    Caller MUST hold reference count on the entry.
1082  */
1083 
1084 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
1085                  u32 flags)
1086 {
1087         u8 old;
1088         int err;
1089         int notify = 0;
1090         struct net_device *dev;
1091         int update_isrouter = 0;
1092 
1093         write_lock_bh(&neigh->lock);
1094 
1095         dev    = neigh->dev;
1096         old    = neigh->nud_state;
1097         err    = -EPERM;
1098 
1099         if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
1100             (old & (NUD_NOARP | NUD_PERMANENT)))
1101                 goto out;
1102         if (neigh->dead)
1103                 goto out;
1104 
1105         if (!(new & NUD_VALID)) {
1106                 neigh_del_timer(neigh);
1107                 if (old & NUD_CONNECTED)
1108                         neigh_suspect(neigh);
1109                 neigh->nud_state = new;
1110                 err = 0;
1111                 notify = old & NUD_VALID;
1112                 if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
1113                     (new & NUD_FAILED)) {
1114                         neigh_invalidate(neigh);
1115                         notify = 1;
1116                 }
1117                 goto out;
1118         }
1119 
1120         /* Compare new lladdr with cached one */
1121         if (!dev->addr_len) {
1122                 /* First case: device needs no address. */
1123                 lladdr = neigh->ha;
1124         } else if (lladdr) {
1125                 /* The second case: if something is already cached
1126                    and a new address is proposed:
1127                    - compare new & old
1128                    - if they are different, check override flag
1129                  */
1130                 if ((old & NUD_VALID) &&
1131                     !memcmp(lladdr, neigh->ha, dev->addr_len))
1132                         lladdr = neigh->ha;
1133         } else {
1134                 /* No address is supplied; if we know something,
1135                    use it, otherwise discard the request.
1136                  */
1137                 err = -EINVAL;
1138                 if (!(old & NUD_VALID))
1139                         goto out;
1140                 lladdr = neigh->ha;
1141         }
1142 
1143         if (new & NUD_CONNECTED)
1144                 neigh->confirmed = jiffies;
1145         neigh->updated = jiffies;
1146 
1147         /* If entry was valid and address is not changed,
1148            do not change entry state, if new one is STALE.
1149          */
1150         err = 0;
1151         update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
1152         if (old & NUD_VALID) {
1153                 if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
1154                         update_isrouter = 0;
1155                         if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
1156                             (old & NUD_CONNECTED)) {
1157                                 lladdr = neigh->ha;
1158                                 new = NUD_STALE;
1159                         } else
1160                                 goto out;
1161                 } else {
1162                         if (lladdr == neigh->ha && new == NUD_STALE &&
1163                             ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
1164                              (old & NUD_CONNECTED))
1165                             )
1166                                 new = old;
1167                 }
1168         }
1169 
1170         if (new != old) {
1171                 neigh_del_timer(neigh);
1172                 if (new & NUD_IN_TIMER)
1173                         neigh_add_timer(neigh, (jiffies +
1174                                                 ((new & NUD_REACHABLE) ?
1175                                                  neigh->parms->reachable_time :
1176                                                  0)));
1177                 neigh->nud_state = new;
1178                 notify = 1;
1179         }
1180 
1181         if (lladdr != neigh->ha) {
1182                 write_seqlock(&neigh->ha_lock);
1183                 memcpy(&neigh->ha, lladdr, dev->addr_len);
1184                 write_sequnlock(&neigh->ha_lock);
1185                 neigh_update_hhs(neigh);
1186                 if (!(new & NUD_CONNECTED))
1187                         neigh->confirmed = jiffies -
1188                                       (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1);
1189                 notify = 1;
1190         }
1191         if (new == old)
1192                 goto out;
1193         if (new & NUD_CONNECTED)
1194                 neigh_connect(neigh);
1195         else
1196                 neigh_suspect(neigh);
1197         if (!(old & NUD_VALID)) {
1198                 struct sk_buff *skb;
1199 
1200                 /* Again: avoid dead loop if something went wrong */
1201 
1202                 while (neigh->nud_state & NUD_VALID &&
1203                        (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
1204                         struct dst_entry *dst = skb_dst(skb);
1205                         struct neighbour *n2, *n1 = neigh;
1206                         write_unlock_bh(&neigh->lock);
1207 
1208                         rcu_read_lock();
1209 
1210                         /* Why not just use 'neigh' as-is?  The problem is that
1211                          * things such as shaper, eql, and sch_teql can end up
1212                          * using alternative, different, neigh objects to output
1213                          * the packet in the output path.  So what we need to do
1214                          * here is re-lookup the top-level neigh in the path so
1215                          * we can reinject the packet there.
1216                          */
1217                         n2 = NULL;
1218                         if (dst) {
1219                                 n2 = dst_neigh_lookup_skb(dst, skb);
1220                                 if (n2)
1221                                         n1 = n2;
1222                         }
1223                         n1->output(n1, skb);
1224                         if (n2)
1225                                 neigh_release(n2);
1226                         rcu_read_unlock();
1227 
1228                         write_lock_bh(&neigh->lock);
1229                 }
1230                 __skb_queue_purge(&neigh->arp_queue);
1231                 neigh->arp_queue_len_bytes = 0;
1232         }
1233 out:
1234         if (update_isrouter) {
1235                 neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
1236                         (neigh->flags | NTF_ROUTER) :
1237                         (neigh->flags & ~NTF_ROUTER);
1238         }
1239         write_unlock_bh(&neigh->lock);
1240 
1241         if (notify)
1242                 neigh_update_notify(neigh);
1243 
1244         return err;
1245 }
1246 EXPORT_SYMBOL(neigh_update);
1247 
1248 /* Update the neigh to listen temporarily for probe responses, even if it is
1249  * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
1250  */
1251 void __neigh_set_probe_once(struct neighbour *neigh)
1252 {
1253         if (neigh->dead)
1254                 return;
1255         neigh->updated = jiffies;
1256         if (!(neigh->nud_state & NUD_FAILED))
1257                 return;
1258         neigh->nud_state = NUD_INCOMPLETE;
1259         atomic_set(&neigh->probes, neigh_max_probes(neigh));
1260         neigh_add_timer(neigh,
1261                         jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME));
1262 }
1263 EXPORT_SYMBOL(__neigh_set_probe_once);
1264 
1265 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
1266                                  u8 *lladdr, void *saddr,
1267                                  struct net_device *dev)
1268 {
1269         struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
1270                                                  lladdr || !dev->addr_len);
1271         if (neigh)
1272                 neigh_update(neigh, lladdr, NUD_STALE,
1273                              NEIGH_UPDATE_F_OVERRIDE);
1274         return neigh;
1275 }
1276 EXPORT_SYMBOL(neigh_event_ns);
1277 
1278 /* called with read_lock_bh(&n->lock); */
1279 static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst)
1280 {
1281         struct net_device *dev = dst->dev;
1282         __be16 prot = dst->ops->protocol;
1283         struct hh_cache *hh = &n->hh;
1284 
1285         write_lock_bh(&n->lock);
1286 
1287         /* Only one thread can come in here and initialize the
1288          * hh_cache entry.
1289          */
1290         if (!hh->hh_len)
1291                 dev->header_ops->cache(n, hh, prot);
1292 
1293         write_unlock_bh(&n->lock);
1294 }
1295 
1296 /* This function can be used in contexts, where only old dev_queue_xmit
1297  * worked, f.e. if you want to override normal output path (eql, shaper),
1298  * but resolution is not made yet.
1299  */
1300 
1301 int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb)
1302 {
1303         struct net_device *dev = skb->dev;
1304 
1305         __skb_pull(skb, skb_network_offset(skb));
1306 
1307         if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL,
1308                             skb->len) < 0 &&
1309             dev_rebuild_header(skb))
1310                 return 0;
1311 
1312         return dev_queue_xmit(skb);
1313 }
1314 EXPORT_SYMBOL(neigh_compat_output);
1315 
1316 /* Slow and careful. */
1317 
1318 int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
1319 {
1320         struct dst_entry *dst = skb_dst(skb);
1321         int rc = 0;
1322 
1323         if (!dst)
1324                 goto discard;
1325 
1326         if (!neigh_event_send(neigh, skb)) {
1327                 int err;
1328                 struct net_device *dev = neigh->dev;
1329                 unsigned int seq;
1330 
1331                 if (dev->header_ops->cache && !neigh->hh.hh_len)
1332                         neigh_hh_init(neigh, dst);
1333 
1334                 do {
1335                         __skb_pull(skb, skb_network_offset(skb));
1336                         seq = read_seqbegin(&neigh->ha_lock);
1337                         err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1338                                               neigh->ha, NULL, skb->len);
1339                 } while (read_seqretry(&neigh->ha_lock, seq));
1340 
1341                 if (err >= 0)
1342                         rc = dev_queue_xmit(skb);
1343                 else
1344                         goto out_kfree_skb;
1345         }
1346 out:
1347         return rc;
1348 discard:
1349         neigh_dbg(1, "%s: dst=%p neigh=%p\n", __func__, dst, neigh);
1350 out_kfree_skb:
1351         rc = -EINVAL;
1352         kfree_skb(skb);
1353         goto out;
1354 }
1355 EXPORT_SYMBOL(neigh_resolve_output);
1356 
1357 /* As fast as possible without hh cache */
1358 
1359 int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
1360 {
1361         struct net_device *dev = neigh->dev;
1362         unsigned int seq;
1363         int err;
1364 
1365         do {
1366                 __skb_pull(skb, skb_network_offset(skb));
1367                 seq = read_seqbegin(&neigh->ha_lock);
1368                 err = dev_hard_header(skb, dev, ntohs(skb->protocol),
1369                                       neigh->ha, NULL, skb->len);
1370         } while (read_seqretry(&neigh->ha_lock, seq));
1371 
1372         if (err >= 0)
1373                 err = dev_queue_xmit(skb);
1374         else {
1375                 err = -EINVAL;
1376                 kfree_skb(skb);
1377         }
1378         return err;
1379 }
1380 EXPORT_SYMBOL(neigh_connected_output);
1381 
1382 int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
1383 {
1384         return dev_queue_xmit(skb);
1385 }
1386 EXPORT_SYMBOL(neigh_direct_output);
1387 
1388 static void neigh_proxy_process(unsigned long arg)
1389 {
1390         struct neigh_table *tbl = (struct neigh_table *)arg;
1391         long sched_next = 0;
1392         unsigned long now = jiffies;
1393         struct sk_buff *skb, *n;
1394 
1395         spin_lock(&tbl->proxy_queue.lock);
1396 
1397         skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
1398                 long tdif = NEIGH_CB(skb)->sched_next - now;
1399 
1400                 if (tdif <= 0) {
1401                         struct net_device *dev = skb->dev;
1402 
1403                         __skb_unlink(skb, &tbl->proxy_queue);
1404                         if (tbl->proxy_redo && netif_running(dev)) {
1405                                 rcu_read_lock();
1406                                 tbl->proxy_redo(skb);
1407                                 rcu_read_unlock();
1408                         } else {
1409                                 kfree_skb(skb);
1410                         }
1411 
1412                         dev_put(dev);
1413                 } else if (!sched_next || tdif < sched_next)
1414                         sched_next = tdif;
1415         }
1416         del_timer(&tbl->proxy_timer);
1417         if (sched_next)
1418                 mod_timer(&tbl->proxy_timer, jiffies + sched_next);
1419         spin_unlock(&tbl->proxy_queue.lock);
1420 }
1421 
1422 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
1423                     struct sk_buff *skb)
1424 {
1425         unsigned long now = jiffies;
1426 
1427         unsigned long sched_next = now + (prandom_u32() %
1428                                           NEIGH_VAR(p, PROXY_DELAY));
1429 
1430         if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) {
1431                 kfree_skb(skb);
1432                 return;
1433         }
1434 
1435         NEIGH_CB(skb)->sched_next = sched_next;
1436         NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
1437 
1438         spin_lock(&tbl->proxy_queue.lock);
1439         if (del_timer(&tbl->proxy_timer)) {
1440                 if (time_before(tbl->proxy_timer.expires, sched_next))
1441                         sched_next = tbl->proxy_timer.expires;
1442         }
1443         skb_dst_drop(skb);
1444         dev_hold(skb->dev);
1445         __skb_queue_tail(&tbl->proxy_queue, skb);
1446         mod_timer(&tbl->proxy_timer, sched_next);
1447         spin_unlock(&tbl->proxy_queue.lock);
1448 }
1449 EXPORT_SYMBOL(pneigh_enqueue);
1450 
1451 static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
1452                                                       struct net *net, int ifindex)
1453 {
1454         struct neigh_parms *p;
1455 
1456         list_for_each_entry(p, &tbl->parms_list, list) {
1457                 if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
1458                     (!p->dev && !ifindex && net_eq(net, &init_net)))
1459                         return p;
1460         }
1461 
1462         return NULL;
1463 }
1464 
1465 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
1466                                       struct neigh_table *tbl)
1467 {
1468         struct neigh_parms *p;
1469         struct net *net = dev_net(dev);
1470         const struct net_device_ops *ops = dev->netdev_ops;
1471 
1472         p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
1473         if (p) {
1474                 p->tbl            = tbl;
1475                 atomic_set(&p->refcnt, 1);
1476                 p->reachable_time =
1477                                 neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
1478                 dev_hold(dev);
1479                 p->dev = dev;
1480                 write_pnet(&p->net, hold_net(net));
1481                 p->sysctl_table = NULL;
1482 
1483                 if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
1484                         release_net(net);
1485                         dev_put(dev);
1486                         kfree(p);
1487                         return NULL;
1488                 }
1489 
1490                 write_lock_bh(&tbl->lock);
1491                 list_add(&p->list, &tbl->parms.list);
1492                 write_unlock_bh(&tbl->lock);
1493 
1494                 neigh_parms_data_state_cleanall(p);
1495         }
1496         return p;
1497 }
1498 EXPORT_SYMBOL(neigh_parms_alloc);
1499 
1500 static void neigh_rcu_free_parms(struct rcu_head *head)
1501 {
1502         struct neigh_parms *parms =
1503                 container_of(head, struct neigh_parms, rcu_head);
1504 
1505         neigh_parms_put(parms);
1506 }
1507 
1508 void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
1509 {
1510         if (!parms || parms == &tbl->parms)
1511                 return;
1512         write_lock_bh(&tbl->lock);
1513         list_del(&parms->list);
1514         parms->dead = 1;
1515         write_unlock_bh(&tbl->lock);
1516         if (parms->dev)
1517                 dev_put(parms->dev);
1518         call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
1519 }
1520 EXPORT_SYMBOL(neigh_parms_release);
1521 
1522 static void neigh_parms_destroy(struct neigh_parms *parms)
1523 {
1524         release_net(neigh_parms_net(parms));
1525         kfree(parms);
1526 }
1527 
1528 static struct lock_class_key neigh_table_proxy_queue_class;
1529 
1530 static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly;
1531 
1532 void neigh_table_init(int index, struct neigh_table *tbl)
1533 {
1534         unsigned long now = jiffies;
1535         unsigned long phsize;
1536 
1537         INIT_LIST_HEAD(&tbl->parms_list);
1538         list_add(&tbl->parms.list, &tbl->parms_list);
1539         write_pnet(&tbl->parms.net, &init_net);
1540         atomic_set(&tbl->parms.refcnt, 1);
1541         tbl->parms.reachable_time =
1542                           neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME));
1543 
1544         tbl->stats = alloc_percpu(struct neigh_statistics);
1545         if (!tbl->stats)
1546                 panic("cannot create neighbour cache statistics");
1547 
1548 #ifdef CONFIG_PROC_FS
1549         if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
1550                               &neigh_stat_seq_fops, tbl))
1551                 panic("cannot create neighbour proc dir entry");
1552 #endif
1553 
1554         RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
1555 
1556         phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
1557         tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
1558 
1559         if (!tbl->nht || !tbl->phash_buckets)
1560                 panic("cannot allocate neighbour cache hashes");
1561 
1562         if (!tbl->entry_size)
1563                 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
1564                                         tbl->key_len, NEIGH_PRIV_ALIGN);
1565         else
1566                 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
1567 
1568         rwlock_init(&tbl->lock);
1569         INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
1570         queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
1571                         tbl->parms.reachable_time);
1572         setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
1573         skb_queue_head_init_class(&tbl->proxy_queue,
1574                         &neigh_table_proxy_queue_class);
1575 
1576         tbl->last_flush = now;
1577         tbl->last_rand  = now + tbl->parms.reachable_time * 20;
1578 
1579         neigh_tables[index] = tbl;
1580 }
1581 EXPORT_SYMBOL(neigh_table_init);
1582 
1583 int neigh_table_clear(int index, struct neigh_table *tbl)
1584 {
1585         neigh_tables[index] = NULL;
1586         /* It is not clean... Fix it to unload IPv6 module safely */
1587         cancel_delayed_work_sync(&tbl->gc_work);
1588         del_timer_sync(&tbl->proxy_timer);
1589         pneigh_queue_purge(&tbl->proxy_queue);
1590         neigh_ifdown(tbl, NULL);
1591         if (atomic_read(&tbl->entries))
1592                 pr_crit("neighbour leakage\n");
1593 
1594         call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
1595                  neigh_hash_free_rcu);
1596         tbl->nht = NULL;
1597 
1598         kfree(tbl->phash_buckets);
1599         tbl->phash_buckets = NULL;
1600 
1601         remove_proc_entry(tbl->id, init_net.proc_net_stat);
1602 
1603         free_percpu(tbl->stats);
1604         tbl->stats = NULL;
1605 
1606         return 0;
1607 }
1608 EXPORT_SYMBOL(neigh_table_clear);
1609 
1610 static struct neigh_table *neigh_find_table(int family)
1611 {
1612         struct neigh_table *tbl = NULL;
1613 
1614         switch (family) {
1615         case AF_INET:
1616                 tbl = neigh_tables[NEIGH_ARP_TABLE];
1617                 break;
1618         case AF_INET6:
1619                 tbl = neigh_tables[NEIGH_ND_TABLE];
1620                 break;
1621         case AF_DECnet:
1622                 tbl = neigh_tables[NEIGH_DN_TABLE];
1623                 break;
1624         }
1625 
1626         return tbl;
1627 }
1628 
1629 static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh)
1630 {
1631         struct net *net = sock_net(skb->sk);
1632         struct ndmsg *ndm;
1633         struct nlattr *dst_attr;
1634         struct neigh_table *tbl;
1635         struct neighbour *neigh;
1636         struct net_device *dev = NULL;
1637         int err = -EINVAL;
1638 
1639         ASSERT_RTNL();
1640         if (nlmsg_len(nlh) < sizeof(*ndm))
1641                 goto out;
1642 
1643         dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
1644         if (dst_attr == NULL)
1645                 goto out;
1646 
1647         ndm = nlmsg_data(nlh);
1648         if (ndm->ndm_ifindex) {
1649                 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
1650                 if (dev == NULL) {
1651                         err = -ENODEV;
1652                         goto out;
1653                 }
1654         }
1655 
1656         tbl = neigh_find_table(ndm->ndm_family);
1657         if (tbl == NULL)
1658                 return -EAFNOSUPPORT;
1659 
1660         if (nla_len(dst_attr) < tbl->key_len)
1661                 goto out;
1662 
1663         if (ndm->ndm_flags & NTF_PROXY) {
1664                 err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
1665                 goto out;
1666         }
1667 
1668         if (dev == NULL)
1669                 goto out;
1670 
1671         neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
1672         if (neigh == NULL) {
1673                 err = -ENOENT;
1674                 goto out;
1675         }
1676 
1677         err = neigh_update(neigh, NULL, NUD_FAILED,
1678                            NEIGH_UPDATE_F_OVERRIDE |
1679                            NEIGH_UPDATE_F_ADMIN);
1680         neigh_release(neigh);
1681 
1682 out:
1683         return err;
1684 }
1685 
1686 static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh)
1687 {
1688         int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
1689         struct net *net = sock_net(skb->sk);
1690         struct ndmsg *ndm;
1691         struct nlattr *tb[NDA_MAX+1];
1692         struct neigh_table *tbl;
1693         struct net_device *dev = NULL;
1694         struct neighbour *neigh;
1695         void *dst, *lladdr;
1696         int err;
1697 
1698         ASSERT_RTNL();
1699         err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
1700         if (err < 0)
1701                 goto out;
1702 
1703         err = -EINVAL;
1704         if (tb[NDA_DST] == NULL)
1705                 goto out;
1706 
1707         ndm = nlmsg_data(nlh);
1708         if (ndm->ndm_ifindex) {
1709                 dev = __dev_get_by_index(net, ndm->ndm_ifindex);
1710                 if (dev == NULL) {
1711                         err = -ENODEV;
1712                         goto out;
1713                 }
1714 
1715                 if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
1716                         goto out;
1717         }
1718 
1719         tbl = neigh_find_table(ndm->ndm_family);
1720         if (tbl == NULL)
1721                 return -EAFNOSUPPORT;
1722 
1723         if (nla_len(tb[NDA_DST]) < tbl->key_len)
1724                 goto out;
1725         dst = nla_data(tb[NDA_DST]);
1726         lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
1727 
1728         if (ndm->ndm_flags & NTF_PROXY) {
1729                 struct pneigh_entry *pn;
1730 
1731                 err = -ENOBUFS;
1732                 pn = pneigh_lookup(tbl, net, dst, dev, 1);
1733                 if (pn) {
1734                         pn->flags = ndm->ndm_flags;
1735                         err = 0;
1736                 }
1737                 goto out;
1738         }
1739 
1740         if (dev == NULL)
1741                 goto out;
1742 
1743         neigh = neigh_lookup(tbl, dst, dev);
1744         if (neigh == NULL) {
1745                 if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
1746                         err = -ENOENT;
1747                         goto out;
1748                 }
1749 
1750                 neigh = __neigh_lookup_errno(tbl, dst, dev);
1751                 if (IS_ERR(neigh)) {
1752                         err = PTR_ERR(neigh);
1753                         goto out;
1754                 }
1755         } else {
1756                 if (nlh->nlmsg_flags & NLM_F_EXCL) {
1757                         err = -EEXIST;
1758                         neigh_release(neigh);
1759                         goto out;
1760                 }
1761 
1762                 if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
1763                         flags &= ~NEIGH_UPDATE_F_OVERRIDE;
1764         }
1765 
1766         if (ndm->ndm_flags & NTF_USE) {
1767                 neigh_event_send(neigh, NULL);
1768                 err = 0;
1769         } else
1770                 err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
1771         neigh_release(neigh);
1772 
1773 out:
1774         return err;
1775 }
1776 
1777 static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
1778 {
1779         struct nlattr *nest;
1780 
1781         nest = nla_nest_start(skb, NDTA_PARMS);
1782         if (nest == NULL)
1783                 return -ENOBUFS;
1784 
1785         if ((parms->dev &&
1786              nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
1787             nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) ||
1788             nla_put_u32(skb, NDTPA_QUEUE_LENBYTES,
1789                         NEIGH_VAR(parms, QUEUE_LEN_BYTES)) ||
1790             /* approximative value for deprecated QUEUE_LEN (in packets) */
1791             nla_put_u32(skb, NDTPA_QUEUE_LEN,
1792                         NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
1793             nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) ||
1794             nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) ||
1795             nla_put_u32(skb, NDTPA_UCAST_PROBES,
1796                         NEIGH_VAR(parms, UCAST_PROBES)) ||
1797             nla_put_u32(skb, NDTPA_MCAST_PROBES,
1798                         NEIGH_VAR(parms, MCAST_PROBES)) ||
1799             nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) ||
1800             nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
1801                           NEIGH_VAR(parms, BASE_REACHABLE_TIME)) ||
1802             nla_put_msecs(skb, NDTPA_GC_STALETIME,
1803                           NEIGH_VAR(parms, GC_STALETIME)) ||
1804             nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
1805                           NEIGH_VAR(parms, DELAY_PROBE_TIME)) ||
1806             nla_put_msecs(skb, NDTPA_RETRANS_TIME,
1807                           NEIGH_VAR(parms, RETRANS_TIME)) ||
1808             nla_put_msecs(skb, NDTPA_ANYCAST_DELAY,
1809                           NEIGH_VAR(parms, ANYCAST_DELAY)) ||
1810             nla_put_msecs(skb, NDTPA_PROXY_DELAY,
1811                           NEIGH_VAR(parms, PROXY_DELAY)) ||
1812             nla_put_msecs(skb, NDTPA_LOCKTIME,
1813                           NEIGH_VAR(parms, LOCKTIME)))
1814                 goto nla_put_failure;
1815         return nla_nest_end(skb, nest);
1816 
1817 nla_put_failure:
1818         nla_nest_cancel(skb, nest);
1819         return -EMSGSIZE;
1820 }
1821 
1822 static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
1823                               u32 pid, u32 seq, int type, int flags)
1824 {
1825         struct nlmsghdr *nlh;
1826         struct ndtmsg *ndtmsg;
1827 
1828         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1829         if (nlh == NULL)
1830                 return -EMSGSIZE;
1831 
1832         ndtmsg = nlmsg_data(nlh);
1833 
1834         read_lock_bh(&tbl->lock);
1835         ndtmsg->ndtm_family = tbl->family;
1836         ndtmsg->ndtm_pad1   = 0;
1837         ndtmsg->ndtm_pad2   = 0;
1838 
1839         if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
1840             nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) ||
1841             nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
1842             nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
1843             nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
1844                 goto nla_put_failure;
1845         {
1846                 unsigned long now = jiffies;
1847                 unsigned int flush_delta = now - tbl->last_flush;
1848                 unsigned int rand_delta = now - tbl->last_rand;
1849                 struct neigh_hash_table *nht;
1850                 struct ndt_config ndc = {
1851                         .ndtc_key_len           = tbl->key_len,
1852                         .ndtc_entry_size        = tbl->entry_size,
1853                         .ndtc_entries           = atomic_read(&tbl->entries),
1854                         .ndtc_last_flush        = jiffies_to_msecs(flush_delta),
1855                         .ndtc_last_rand         = jiffies_to_msecs(rand_delta),
1856                         .ndtc_proxy_qlen        = tbl->proxy_queue.qlen,
1857                 };
1858 
1859                 rcu_read_lock_bh();
1860                 nht = rcu_dereference_bh(tbl->nht);
1861                 ndc.ndtc_hash_rnd = nht->hash_rnd[0];
1862                 ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
1863                 rcu_read_unlock_bh();
1864 
1865                 if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
1866                         goto nla_put_failure;
1867         }
1868 
1869         {
1870                 int cpu;
1871                 struct ndt_stats ndst;
1872 
1873                 memset(&ndst, 0, sizeof(ndst));
1874 
1875                 for_each_possible_cpu(cpu) {
1876                         struct neigh_statistics *st;
1877 
1878                         st = per_cpu_ptr(tbl->stats, cpu);
1879                         ndst.ndts_allocs                += st->allocs;
1880                         ndst.ndts_destroys              += st->destroys;
1881                         ndst.ndts_hash_grows            += st->hash_grows;
1882                         ndst.ndts_res_failed            += st->res_failed;
1883                         ndst.ndts_lookups               += st->lookups;
1884                         ndst.ndts_hits                  += st->hits;
1885                         ndst.ndts_rcv_probes_mcast      += st->rcv_probes_mcast;
1886                         ndst.ndts_rcv_probes_ucast      += st->rcv_probes_ucast;
1887                         ndst.ndts_periodic_gc_runs      += st->periodic_gc_runs;
1888                         ndst.ndts_forced_gc_runs        += st->forced_gc_runs;
1889                 }
1890 
1891                 if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst))
1892                         goto nla_put_failure;
1893         }
1894 
1895         BUG_ON(tbl->parms.dev);
1896         if (neightbl_fill_parms(skb, &tbl->parms) < 0)
1897                 goto nla_put_failure;
1898 
1899         read_unlock_bh(&tbl->lock);
1900         nlmsg_end(skb, nlh);
1901         return 0;
1902 
1903 nla_put_failure:
1904         read_unlock_bh(&tbl->lock);
1905         nlmsg_cancel(skb, nlh);
1906         return -EMSGSIZE;
1907 }
1908 
1909 static int neightbl_fill_param_info(struct sk_buff *skb,
1910                                     struct neigh_table *tbl,
1911                                     struct neigh_parms *parms,
1912                                     u32 pid, u32 seq, int type,
1913                                     unsigned int flags)
1914 {
1915         struct ndtmsg *ndtmsg;
1916         struct nlmsghdr *nlh;
1917 
1918         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
1919         if (nlh == NULL)
1920                 return -EMSGSIZE;
1921 
1922         ndtmsg = nlmsg_data(nlh);
1923 
1924         read_lock_bh(&tbl->lock);
1925         ndtmsg->ndtm_family = tbl->family;
1926         ndtmsg->ndtm_pad1   = 0;
1927         ndtmsg->ndtm_pad2   = 0;
1928 
1929         if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
1930             neightbl_fill_parms(skb, parms) < 0)
1931                 goto errout;
1932 
1933         read_unlock_bh(&tbl->lock);
1934         nlmsg_end(skb, nlh);
1935         return 0;
1936 errout:
1937         read_unlock_bh(&tbl->lock);
1938         nlmsg_cancel(skb, nlh);
1939         return -EMSGSIZE;
1940 }
1941 
1942 static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
1943         [NDTA_NAME]             = { .type = NLA_STRING },
1944         [NDTA_THRESH1]          = { .type = NLA_U32 },
1945         [NDTA_THRESH2]          = { .type = NLA_U32 },
1946         [NDTA_THRESH3]          = { .type = NLA_U32 },
1947         [NDTA_GC_INTERVAL]      = { .type = NLA_U64 },
1948         [NDTA_PARMS]            = { .type = NLA_NESTED },
1949 };
1950 
1951 static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
1952         [NDTPA_IFINDEX]                 = { .type = NLA_U32 },
1953         [NDTPA_QUEUE_LEN]               = { .type = NLA_U32 },
1954         [NDTPA_PROXY_QLEN]              = { .type = NLA_U32 },
1955         [NDTPA_APP_PROBES]              = { .type = NLA_U32 },
1956         [NDTPA_UCAST_PROBES]            = { .type = NLA_U32 },
1957         [NDTPA_MCAST_PROBES]            = { .type = NLA_U32 },
1958         [NDTPA_BASE_REACHABLE_TIME]     = { .type = NLA_U64 },
1959         [NDTPA_GC_STALETIME]            = { .type = NLA_U64 },
1960         [NDTPA_DELAY_PROBE_TIME]        = { .type = NLA_U64 },
1961         [NDTPA_RETRANS_TIME]            = { .type = NLA_U64 },
1962         [NDTPA_ANYCAST_DELAY]           = { .type = NLA_U64 },
1963         [NDTPA_PROXY_DELAY]             = { .type = NLA_U64 },
1964         [NDTPA_LOCKTIME]                = { .type = NLA_U64 },
1965 };
1966 
1967 static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh)
1968 {
1969         struct net *net = sock_net(skb->sk);
1970         struct neigh_table *tbl;
1971         struct ndtmsg *ndtmsg;
1972         struct nlattr *tb[NDTA_MAX+1];
1973         bool found = false;
1974         int err, tidx;
1975 
1976         err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
1977                           nl_neightbl_policy);
1978         if (err < 0)
1979                 goto errout;
1980 
1981         if (tb[NDTA_NAME] == NULL) {
1982                 err = -EINVAL;
1983                 goto errout;
1984         }
1985 
1986         ndtmsg = nlmsg_data(nlh);
1987 
1988         for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
1989                 tbl = neigh_tables[tidx];
1990                 if (!tbl)
1991                         continue;
1992                 if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
1993                         continue;
1994                 if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) {
1995                         found = true;
1996                         break;
1997                 }
1998         }
1999 
2000         if (!found)
2001                 return -ENOENT;
2002 
2003         /*
2004          * We acquire tbl->lock to be nice to the periodic timers and
2005          * make sure they always see a consistent set of values.
2006          */
2007         write_lock_bh(&tbl->lock);
2008 
2009         if (tb[NDTA_PARMS]) {
2010                 struct nlattr *tbp[NDTPA_MAX+1];
2011                 struct neigh_parms *p;
2012                 int i, ifindex = 0;
2013 
2014                 err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
2015                                        nl_ntbl_parm_policy);
2016                 if (err < 0)
2017                         goto errout_tbl_lock;
2018 
2019                 if (tbp[NDTPA_IFINDEX])
2020                         ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
2021 
2022                 p = lookup_neigh_parms(tbl, net, ifindex);
2023                 if (p == NULL) {
2024                         err = -ENOENT;
2025                         goto errout_tbl_lock;
2026                 }
2027 
2028                 for (i = 1; i <= NDTPA_MAX; i++) {
2029                         if (tbp[i] == NULL)
2030                                 continue;
2031 
2032                         switch (i) {
2033                         case NDTPA_QUEUE_LEN:
2034                                 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2035                                               nla_get_u32(tbp[i]) *
2036                                               SKB_TRUESIZE(ETH_FRAME_LEN));
2037                                 break;
2038                         case NDTPA_QUEUE_LENBYTES:
2039                                 NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
2040                                               nla_get_u32(tbp[i]));
2041                                 break;
2042                         case NDTPA_PROXY_QLEN:
2043                                 NEIGH_VAR_SET(p, PROXY_QLEN,
2044                                               nla_get_u32(tbp[i]));
2045                                 break;
2046                         case NDTPA_APP_PROBES:
2047                                 NEIGH_VAR_SET(p, APP_PROBES,
2048                                               nla_get_u32(tbp[i]));
2049                                 break;
2050                         case NDTPA_UCAST_PROBES:
2051                                 NEIGH_VAR_SET(p, UCAST_PROBES,
2052                                               nla_get_u32(tbp[i]));
2053                                 break;
2054                         case NDTPA_MCAST_PROBES:
2055                                 NEIGH_VAR_SET(p, MCAST_PROBES,
2056                                               nla_get_u32(tbp[i]));
2057                                 break;
2058                         case NDTPA_BASE_REACHABLE_TIME:
2059                                 NEIGH_VAR_SET(p, BASE_REACHABLE_TIME,
2060                                               nla_get_msecs(tbp[i]));
2061                                 /* update reachable_time as well, otherwise, the change will
2062                                  * only be effective after the next time neigh_periodic_work
2063                                  * decides to recompute it (can be multiple minutes)
2064                                  */
2065                                 p->reachable_time =
2066                                         neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
2067                                 break;
2068                         case NDTPA_GC_STALETIME:
2069                                 NEIGH_VAR_SET(p, GC_STALETIME,
2070                                               nla_get_msecs(tbp[i]));
2071                                 break;
2072                         case NDTPA_DELAY_PROBE_TIME:
2073                                 NEIGH_VAR_SET(p, DELAY_PROBE_TIME,
2074                                               nla_get_msecs(tbp[i]));
2075                                 break;
2076                         case NDTPA_RETRANS_TIME:
2077                                 NEIGH_VAR_SET(p, RETRANS_TIME,
2078                                               nla_get_msecs(tbp[i]));
2079                                 break;
2080                         case NDTPA_ANYCAST_DELAY:
2081                                 NEIGH_VAR_SET(p, ANYCAST_DELAY,
2082                                               nla_get_msecs(tbp[i]));
2083                                 break;
2084                         case NDTPA_PROXY_DELAY:
2085                                 NEIGH_VAR_SET(p, PROXY_DELAY,
2086                                               nla_get_msecs(tbp[i]));
2087                                 break;
2088                         case NDTPA_LOCKTIME:
2089                                 NEIGH_VAR_SET(p, LOCKTIME,
2090                                               nla_get_msecs(tbp[i]));
2091                                 break;
2092                         }
2093                 }
2094         }
2095 
2096         err = -ENOENT;
2097         if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
2098              tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
2099             !net_eq(net, &init_net))
2100                 goto errout_tbl_lock;
2101 
2102         if (tb[NDTA_THRESH1])
2103                 tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
2104 
2105         if (tb[NDTA_THRESH2])
2106                 tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
2107 
2108         if (tb[NDTA_THRESH3])
2109                 tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
2110 
2111         if (tb[NDTA_GC_INTERVAL])
2112                 tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
2113 
2114         err = 0;
2115 
2116 errout_tbl_lock:
2117         write_unlock_bh(&tbl->lock);
2118 errout:
2119         return err;
2120 }
2121 
2122 static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2123 {
2124         struct net *net = sock_net(skb->sk);
2125         int family, tidx, nidx = 0;
2126         int tbl_skip = cb->args[0];
2127         int neigh_skip = cb->args[1];
2128         struct neigh_table *tbl;
2129 
2130         family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2131 
2132         for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
2133                 struct neigh_parms *p;
2134 
2135                 tbl = neigh_tables[tidx];
2136                 if (!tbl)
2137                         continue;
2138 
2139                 if (tidx < tbl_skip || (family && tbl->family != family))
2140                         continue;
2141 
2142                 if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
2143                                        cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
2144                                        NLM_F_MULTI) < 0)
2145                         break;
2146 
2147                 nidx = 0;
2148                 p = list_next_entry(&tbl->parms, list);
2149                 list_for_each_entry_from(p, &tbl->parms_list, list) {
2150                         if (!net_eq(neigh_parms_net(p), net))
2151                                 continue;
2152 
2153                         if (nidx < neigh_skip)
2154                                 goto next;
2155 
2156                         if (neightbl_fill_param_info(skb, tbl, p,
2157                                                      NETLINK_CB(cb->skb).portid,
2158                                                      cb->nlh->nlmsg_seq,
2159                                                      RTM_NEWNEIGHTBL,
2160                                                      NLM_F_MULTI) < 0)
2161                                 goto out;
2162                 next:
2163                         nidx++;
2164                 }
2165 
2166                 neigh_skip = 0;
2167         }
2168 out:
2169         cb->args[0] = tidx;
2170         cb->args[1] = nidx;
2171 
2172         return skb->len;
2173 }
2174 
2175 static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
2176                            u32 pid, u32 seq, int type, unsigned int flags)
2177 {
2178         unsigned long now = jiffies;
2179         struct nda_cacheinfo ci;
2180         struct nlmsghdr *nlh;
2181         struct ndmsg *ndm;
2182 
2183         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2184         if (nlh == NULL)
2185                 return -EMSGSIZE;
2186 
2187         ndm = nlmsg_data(nlh);
2188         ndm->ndm_family  = neigh->ops->family;
2189         ndm->ndm_pad1    = 0;
2190         ndm->ndm_pad2    = 0;
2191         ndm->ndm_flags   = neigh->flags;
2192         ndm->ndm_type    = neigh->type;
2193         ndm->ndm_ifindex = neigh->dev->ifindex;
2194 
2195         if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
2196                 goto nla_put_failure;
2197 
2198         read_lock_bh(&neigh->lock);
2199         ndm->ndm_state   = neigh->nud_state;
2200         if (neigh->nud_state & NUD_VALID) {
2201                 char haddr[MAX_ADDR_LEN];
2202 
2203                 neigh_ha_snapshot(haddr, neigh, neigh->dev);
2204                 if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
2205                         read_unlock_bh(&neigh->lock);
2206                         goto nla_put_failure;
2207                 }
2208         }
2209 
2210         ci.ndm_used      = jiffies_to_clock_t(now - neigh->used);
2211         ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
2212         ci.ndm_updated   = jiffies_to_clock_t(now - neigh->updated);
2213         ci.ndm_refcnt    = atomic_read(&neigh->refcnt) - 1;
2214         read_unlock_bh(&neigh->lock);
2215 
2216         if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
2217             nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
2218                 goto nla_put_failure;
2219 
2220         nlmsg_end(skb, nlh);
2221         return 0;
2222 
2223 nla_put_failure:
2224         nlmsg_cancel(skb, nlh);
2225         return -EMSGSIZE;
2226 }
2227 
2228 static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
2229                             u32 pid, u32 seq, int type, unsigned int flags,
2230                             struct neigh_table *tbl)
2231 {
2232         struct nlmsghdr *nlh;
2233         struct ndmsg *ndm;
2234 
2235         nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
2236         if (nlh == NULL)
2237                 return -EMSGSIZE;
2238 
2239         ndm = nlmsg_data(nlh);
2240         ndm->ndm_family  = tbl->family;
2241         ndm->ndm_pad1    = 0;
2242         ndm->ndm_pad2    = 0;
2243         ndm->ndm_flags   = pn->flags | NTF_PROXY;
2244         ndm->ndm_type    = RTN_UNICAST;
2245         ndm->ndm_ifindex = pn->dev->ifindex;
2246         ndm->ndm_state   = NUD_NONE;
2247 
2248         if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
2249                 goto nla_put_failure;
2250 
2251         nlmsg_end(skb, nlh);
2252         return 0;
2253 
2254 nla_put_failure:
2255         nlmsg_cancel(skb, nlh);
2256         return -EMSGSIZE;
2257 }
2258 
2259 static void neigh_update_notify(struct neighbour *neigh)
2260 {
2261         call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
2262         __neigh_notify(neigh, RTM_NEWNEIGH, 0);
2263 }
2264 
2265 static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2266                             struct netlink_callback *cb)
2267 {
2268         struct net *net = sock_net(skb->sk);
2269         struct neighbour *n;
2270         int rc, h, s_h = cb->args[1];
2271         int idx, s_idx = idx = cb->args[2];
2272         struct neigh_hash_table *nht;
2273 
2274         rcu_read_lock_bh();
2275         nht = rcu_dereference_bh(tbl->nht);
2276 
2277         for (h = s_h; h < (1 << nht->hash_shift); h++) {
2278                 if (h > s_h)
2279                         s_idx = 0;
2280                 for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
2281                      n != NULL;
2282                      n = rcu_dereference_bh(n->next)) {
2283                         if (!net_eq(dev_net(n->dev), net))
2284                                 continue;
2285                         if (idx < s_idx)
2286                                 goto next;
2287                         if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2288                                             cb->nlh->nlmsg_seq,
2289                                             RTM_NEWNEIGH,
2290                                             NLM_F_MULTI) < 0) {
2291                                 rc = -1;
2292                                 goto out;
2293                         }
2294 next:
2295                         idx++;
2296                 }
2297         }
2298         rc = skb->len;
2299 out:
2300         rcu_read_unlock_bh();
2301         cb->args[1] = h;
2302         cb->args[2] = idx;
2303         return rc;
2304 }
2305 
2306 static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
2307                              struct netlink_callback *cb)
2308 {
2309         struct pneigh_entry *n;
2310         struct net *net = sock_net(skb->sk);
2311         int rc, h, s_h = cb->args[3];
2312         int idx, s_idx = idx = cb->args[4];
2313 
2314         read_lock_bh(&tbl->lock);
2315 
2316         for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
2317                 if (h > s_h)
2318                         s_idx = 0;
2319                 for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
2320                         if (dev_net(n->dev) != net)
2321                                 continue;
2322                         if (idx < s_idx)
2323                                 goto next;
2324                         if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
2325                                             cb->nlh->nlmsg_seq,
2326                                             RTM_NEWNEIGH,
2327                                             NLM_F_MULTI, tbl) < 0) {
2328                                 read_unlock_bh(&tbl->lock);
2329                                 rc = -1;
2330                                 goto out;
2331                         }
2332                 next:
2333                         idx++;
2334                 }
2335         }
2336 
2337         read_unlock_bh(&tbl->lock);
2338         rc = skb->len;
2339 out:
2340         cb->args[3] = h;
2341         cb->args[4] = idx;
2342         return rc;
2343 
2344 }
2345 
2346 static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
2347 {
2348         struct neigh_table *tbl;
2349         int t, family, s_t;
2350         int proxy = 0;
2351         int err;
2352 
2353         family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
2354 
2355         /* check for full ndmsg structure presence, family member is
2356          * the same for both structures
2357          */
2358         if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) &&
2359             ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY)
2360                 proxy = 1;
2361 
2362         s_t = cb->args[0];
2363 
2364         for (t = 0; t < NEIGH_NR_TABLES; t++) {
2365                 tbl = neigh_tables[t];
2366 
2367                 if (!tbl)
2368                         continue;
2369                 if (t < s_t || (family && tbl->family != family))
2370                         continue;
2371                 if (t > s_t)
2372                         memset(&cb->args[1], 0, sizeof(cb->args) -
2373                                                 sizeof(cb->args[0]));
2374                 if (proxy)
2375                         err = pneigh_dump_table(tbl, skb, cb);
2376                 else
2377                         err = neigh_dump_table(tbl, skb, cb);
2378                 if (err < 0)
2379                         break;
2380         }
2381 
2382         cb->args[0] = t;
2383         return skb->len;
2384 }
2385 
2386 void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
2387 {
2388         int chain;
2389         struct neigh_hash_table *nht;
2390 
2391         rcu_read_lock_bh();
2392         nht = rcu_dereference_bh(tbl->nht);
2393 
2394         read_lock(&tbl->lock); /* avoid resizes */
2395         for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2396                 struct neighbour *n;
2397 
2398                 for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
2399                      n != NULL;
2400                      n = rcu_dereference_bh(n->next))
2401                         cb(n, cookie);
2402         }
2403         read_unlock(&tbl->lock);
2404         rcu_read_unlock_bh();
2405 }
2406 EXPORT_SYMBOL(neigh_for_each);
2407 
2408 /* The tbl->lock must be held as a writer and BH disabled. */
2409 void __neigh_for_each_release(struct neigh_table *tbl,
2410                               int (*cb)(struct neighbour *))
2411 {
2412         int chain;
2413         struct neigh_hash_table *nht;
2414 
2415         nht = rcu_dereference_protected(tbl->nht,
2416                                         lockdep_is_held(&tbl->lock));
2417         for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
2418                 struct neighbour *n;
2419                 struct neighbour __rcu **np;
2420 
2421                 np = &nht->hash_buckets[chain];
2422                 while ((n = rcu_dereference_protected(*np,
2423                                         lockdep_is_held(&tbl->lock))) != NULL) {
2424                         int release;
2425 
2426                         write_lock(&n->lock);
2427                         release = cb(n);
2428                         if (release) {
2429                                 rcu_assign_pointer(*np,
2430                                         rcu_dereference_protected(n->next,
2431                                                 lockdep_is_held(&tbl->lock)));
2432                                 n->dead = 1;
2433                         } else
2434                                 np = &n->next;
2435                         write_unlock(&n->lock);
2436                         if (release)
2437                                 neigh_cleanup_and_release(n);
2438                 }
2439         }
2440 }
2441 EXPORT_SYMBOL(__neigh_for_each_release);
2442 
2443 #ifdef CONFIG_PROC_FS
2444 
2445 static struct neighbour *neigh_get_first(struct seq_file *seq)
2446 {
2447         struct neigh_seq_state *state = seq->private;
2448         struct net *net = seq_file_net(seq);
2449         struct neigh_hash_table *nht = state->nht;
2450         struct neighbour *n = NULL;
2451         int bucket = state->bucket;
2452 
2453         state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
2454         for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
2455                 n = rcu_dereference_bh(nht->hash_buckets[bucket]);
2456 
2457                 while (n) {
2458                         if (!net_eq(dev_net(n->dev), net))
2459                                 goto next;
2460                         if (state->neigh_sub_iter) {
2461                                 loff_t fakep = 0;
2462                                 void *v;
2463 
2464                                 v = state->neigh_sub_iter(state, n, &fakep);
2465                                 if (!v)
2466                                         goto next;
2467                         }
2468                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2469                                 break;
2470                         if (n->nud_state & ~NUD_NOARP)
2471                                 break;
2472 next:
2473                         n = rcu_dereference_bh(n->next);
2474                 }
2475 
2476                 if (n)
2477                         break;
2478         }
2479         state->bucket = bucket;
2480 
2481         return n;
2482 }
2483 
2484 static struct neighbour *neigh_get_next(struct seq_file *seq,
2485                                         struct neighbour *n,
2486                                         loff_t *pos)
2487 {
2488         struct neigh_seq_state *state = seq->private;
2489         struct net *net = seq_file_net(seq);
2490         struct neigh_hash_table *nht = state->nht;
2491 
2492         if (state->neigh_sub_iter) {
2493                 void *v = state->neigh_sub_iter(state, n, pos);
2494                 if (v)
2495                         return n;
2496         }
2497         n = rcu_dereference_bh(n->next);
2498 
2499         while (1) {
2500                 while (n) {
2501                         if (!net_eq(dev_net(n->dev), net))
2502                                 goto next;
2503                         if (state->neigh_sub_iter) {
2504                                 void *v = state->neigh_sub_iter(state, n, pos);
2505                                 if (v)
2506                                         return n;
2507                                 goto next;
2508                         }
2509                         if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
2510                                 break;
2511 
2512                         if (n->nud_state & ~NUD_NOARP)
2513                                 break;
2514 next:
2515                         n = rcu_dereference_bh(n->next);
2516                 }
2517 
2518                 if (n)
2519                         break;
2520 
2521                 if (++state->bucket >= (1 << nht->hash_shift))
2522                         break;
2523 
2524                 n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
2525         }
2526 
2527         if (n && pos)
2528                 --(*pos);
2529         return n;
2530 }
2531 
2532 static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
2533 {
2534         struct neighbour *n = neigh_get_first(seq);
2535 
2536         if (n) {
2537                 --(*pos);
2538                 while (*pos) {
2539                         n = neigh_get_next(seq, n, pos);
2540                         if (!n)
2541                                 break;
2542                 }
2543         }
2544         return *pos ? NULL : n;
2545 }
2546 
2547 static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
2548 {
2549         struct neigh_seq_state *state = seq->private;
2550         struct net *net = seq_file_net(seq);
2551         struct neigh_table *tbl = state->tbl;
2552         struct pneigh_entry *pn = NULL;
2553         int bucket = state->bucket;
2554 
2555         state->flags |= NEIGH_SEQ_IS_PNEIGH;
2556         for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
2557                 pn = tbl->phash_buckets[bucket];
2558                 while (pn && !net_eq(pneigh_net(pn), net))
2559                         pn = pn->next;
2560                 if (pn)
2561                         break;
2562         }
2563         state->bucket = bucket;
2564 
2565         return pn;
2566 }
2567 
2568 static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
2569                                             struct pneigh_entry *pn,
2570                                             loff_t *pos)
2571 {
2572         struct neigh_seq_state *state = seq->private;
2573         struct net *net = seq_file_net(seq);
2574         struct neigh_table *tbl = state->tbl;
2575 
2576         do {
2577                 pn = pn->next;
2578         } while (pn && !net_eq(pneigh_net(pn), net));
2579 
2580         while (!pn) {
2581                 if (++state->bucket > PNEIGH_HASHMASK)
2582                         break;
2583                 pn = tbl->phash_buckets[state->bucket];
2584                 while (pn && !net_eq(pneigh_net(pn), net))
2585                         pn = pn->next;
2586                 if (pn)
2587                         break;
2588         }
2589 
2590         if (pn && pos)
2591                 --(*pos);
2592 
2593         return pn;
2594 }
2595 
2596 static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
2597 {
2598         struct pneigh_entry *pn = pneigh_get_first(seq);
2599 
2600         if (pn) {
2601                 --(*pos);
2602                 while (*pos) {
2603                         pn = pneigh_get_next(seq, pn, pos);
2604                         if (!pn)
2605                                 break;
2606                 }
2607         }
2608         return *pos ? NULL : pn;
2609 }
2610 
2611 static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
2612 {
2613         struct neigh_seq_state *state = seq->private;
2614         void *rc;
2615         loff_t idxpos = *pos;
2616 
2617         rc = neigh_get_idx(seq, &idxpos);
2618         if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2619                 rc = pneigh_get_idx(seq, &idxpos);
2620 
2621         return rc;
2622 }
2623 
2624 void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
2625         __acquires(rcu_bh)
2626 {
2627         struct neigh_seq_state *state = seq->private;
2628 
2629         state->tbl = tbl;
2630         state->bucket = 0;
2631         state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
2632 
2633         rcu_read_lock_bh();
2634         state->nht = rcu_dereference_bh(tbl->nht);
2635 
2636         return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
2637 }
2638 EXPORT_SYMBOL(neigh_seq_start);
2639 
2640 void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2641 {
2642         struct neigh_seq_state *state;
2643         void *rc;
2644 
2645         if (v == SEQ_START_TOKEN) {
2646                 rc = neigh_get_first(seq);
2647                 goto out;
2648         }
2649 
2650         state = seq->private;
2651         if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
2652                 rc = neigh_get_next(seq, v, NULL);
2653                 if (rc)
2654                         goto out;
2655                 if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
2656                         rc = pneigh_get_first(seq);
2657         } else {
2658                 BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
2659                 rc = pneigh_get_next(seq, v, NULL);
2660         }
2661 out:
2662         ++(*pos);
2663         return rc;
2664 }
2665 EXPORT_SYMBOL(neigh_seq_next);
2666 
2667 void neigh_seq_stop(struct seq_file *seq, void *v)
2668         __releases(rcu_bh)
2669 {
2670         rcu_read_unlock_bh();
2671 }
2672 EXPORT_SYMBOL(neigh_seq_stop);
2673 
2674 /* statistics via seq_file */
2675 
2676 static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
2677 {
2678         struct neigh_table *tbl = seq->private;
2679         int cpu;
2680 
2681         if (*pos == 0)
2682                 return SEQ_START_TOKEN;
2683 
2684         for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
2685                 if (!cpu_possible(cpu))
2686                         continue;
2687                 *pos = cpu+1;
2688                 return per_cpu_ptr(tbl->stats, cpu);
2689         }
2690         return NULL;
2691 }
2692 
2693 static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2694 {
2695         struct neigh_table *tbl = seq->private;
2696         int cpu;
2697 
2698         for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
2699                 if (!cpu_possible(cpu))
2700                         continue;
2701                 *pos = cpu+1;
2702                 return per_cpu_ptr(tbl->stats, cpu);
2703         }
2704         return NULL;
2705 }
2706 
2707 static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
2708 {
2709 
2710 }
2711 
2712 static int neigh_stat_seq_show(struct seq_file *seq, void *v)
2713 {
2714         struct neigh_table *tbl = seq->private;
2715         struct neigh_statistics *st = v;
2716 
2717         if (v == SEQ_START_TOKEN) {
2718                 seq_printf(seq, "entries  allocs destroys hash_grows  lookups hits  res_failed  rcv_probes_mcast rcv_probes_ucast  periodic_gc_runs forced_gc_runs unresolved_discards\n");
2719                 return 0;
2720         }
2721 
2722         seq_printf(seq, "%08x  %08lx %08lx %08lx  %08lx %08lx  %08lx  "
2723                         "%08lx %08lx  %08lx %08lx %08lx\n",
2724                    atomic_read(&tbl->entries),
2725 
2726                    st->allocs,
2727                    st->destroys,
2728                    st->hash_grows,
2729 
2730                    st->lookups,
2731                    st->hits,
2732 
2733                    st->res_failed,
2734 
2735                    st->rcv_probes_mcast,
2736                    st->rcv_probes_ucast,
2737 
2738                    st->periodic_gc_runs,
2739                    st->forced_gc_runs,
2740                    st->unres_discards
2741                    );
2742 
2743         return 0;
2744 }
2745 
2746 static const struct seq_operations neigh_stat_seq_ops = {
2747         .start  = neigh_stat_seq_start,
2748         .next   = neigh_stat_seq_next,
2749         .stop   = neigh_stat_seq_stop,
2750         .show   = neigh_stat_seq_show,
2751 };
2752 
2753 static int neigh_stat_seq_open(struct inode *inode, struct file *file)
2754 {
2755         int ret = seq_open(file, &neigh_stat_seq_ops);
2756 
2757         if (!ret) {
2758                 struct seq_file *sf = file->private_data;
2759                 sf->private = PDE_DATA(inode);
2760         }
2761         return ret;
2762 };
2763 
2764 static const struct file_operations neigh_stat_seq_fops = {
2765         .owner   = THIS_MODULE,
2766         .open    = neigh_stat_seq_open,
2767         .read    = seq_read,
2768         .llseek  = seq_lseek,
2769         .release = seq_release,
2770 };
2771 
2772 #endif /* CONFIG_PROC_FS */
2773 
2774 static inline size_t neigh_nlmsg_size(void)
2775 {
2776         return NLMSG_ALIGN(sizeof(struct ndmsg))
2777                + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
2778                + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
2779                + nla_total_size(sizeof(struct nda_cacheinfo))
2780                + nla_total_size(4); /* NDA_PROBES */
2781 }
2782 
2783 static void __neigh_notify(struct neighbour *n, int type, int flags)
2784 {
2785         struct net *net = dev_net(n->dev);
2786         struct sk_buff *skb;
2787         int err = -ENOBUFS;
2788 
2789         skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
2790         if (skb == NULL)
2791                 goto errout;
2792 
2793         err = neigh_fill_info(skb, n, 0, 0, type, flags);
2794         if (err < 0) {
2795                 /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
2796                 WARN_ON(err == -EMSGSIZE);
2797                 kfree_skb(skb);
2798                 goto errout;
2799         }
2800         rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
2801         return;
2802 errout:
2803         if (err < 0)
2804                 rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
2805 }
2806 
2807 void neigh_app_ns(struct neighbour *n)
2808 {
2809         __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
2810 }
2811 EXPORT_SYMBOL(neigh_app_ns);
2812 
2813 #ifdef CONFIG_SYSCTL
2814 static int zero;
2815 static int int_max = INT_MAX;
2816 static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
2817 
2818 static int proc_unres_qlen(struct ctl_table *ctl, int write,
2819                            void __user *buffer, size_t *lenp, loff_t *ppos)
2820 {
2821         int size, ret;
2822         struct ctl_table tmp = *ctl;
2823 
2824         tmp.extra1 = &zero;
2825         tmp.extra2 = &unres_qlen_max;
2826         tmp.data = &size;
2827 
2828         size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
2829         ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2830 
2831         if (write && !ret)
2832                 *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
2833         return ret;
2834 }
2835 
2836 static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev,
2837                                                    int family)
2838 {
2839         switch (family) {
2840         case AF_INET:
2841                 return __in_dev_arp_parms_get_rcu(dev);
2842         case AF_INET6:
2843                 return __in6_dev_nd_parms_get_rcu(dev);
2844         }
2845         return NULL;
2846 }
2847 
2848 static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p,
2849                                   int index)
2850 {
2851         struct net_device *dev;
2852         int family = neigh_parms_family(p);
2853 
2854         rcu_read_lock();
2855         for_each_netdev_rcu(net, dev) {
2856                 struct neigh_parms *dst_p =
2857                                 neigh_get_dev_parms_rcu(dev, family);
2858 
2859                 if (dst_p && !test_bit(index, dst_p->data_state))
2860                         dst_p->data[index] = p->data[index];
2861         }
2862         rcu_read_unlock();
2863 }
2864 
2865 static void neigh_proc_update(struct ctl_table *ctl, int write)
2866 {
2867         struct net_device *dev = ctl->extra1;
2868         struct neigh_parms *p = ctl->extra2;
2869         struct net *net = neigh_parms_net(p);
2870         int index = (int *) ctl->data - p->data;
2871 
2872         if (!write)
2873                 return;
2874 
2875         set_bit(index, p->data_state);
2876         if (!dev) /* NULL dev means this is default value */
2877                 neigh_copy_dflt_parms(net, p, index);
2878 }
2879 
2880 static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
2881                                            void __user *buffer,
2882                                            size_t *lenp, loff_t *ppos)
2883 {
2884         struct ctl_table tmp = *ctl;
2885         int ret;
2886 
2887         tmp.extra1 = &zero;
2888         tmp.extra2 = &int_max;
2889 
2890         ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
2891         neigh_proc_update(ctl, write);
2892         return ret;
2893 }
2894 
2895 int neigh_proc_dointvec(struct ctl_table *ctl, int write,
2896                         void __user *buffer, size_t *lenp, loff_t *ppos)
2897 {
2898         int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
2899 
2900         neigh_proc_update(ctl, write);
2901         return ret;
2902 }
2903 EXPORT_SYMBOL(neigh_proc_dointvec);
2904 
2905 int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
2906                                 void __user *buffer,
2907                                 size_t *lenp, loff_t *ppos)
2908 {
2909         int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
2910 
2911         neigh_proc_update(ctl, write);
2912         return ret;
2913 }
2914 EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
2915 
2916 static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
2917                                               void __user *buffer,
2918                                               size_t *lenp, loff_t *ppos)
2919 {
2920         int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos);
2921 
2922         neigh_proc_update(ctl, write);
2923         return ret;
2924 }
2925 
2926 int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
2927                                    void __user *buffer,
2928                                    size_t *lenp, loff_t *ppos)
2929 {
2930         int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
2931 
2932         neigh_proc_update(ctl, write);
2933         return ret;
2934 }
2935 EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
2936 
2937 static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
2938                                           void __user *buffer,
2939                                           size_t *lenp, loff_t *ppos)
2940 {
2941         int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos);
2942 
2943         neigh_proc_update(ctl, write);
2944         return ret;
2945 }
2946 
2947 static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write,
2948                                           void __user *buffer,
2949                                           size_t *lenp, loff_t *ppos)
2950 {
2951         struct neigh_parms *p = ctl->extra2;
2952         int ret;
2953 
2954         if (strcmp(ctl->procname, "base_reachable_time") == 0)
2955                 ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
2956         else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0)
2957                 ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
2958         else
2959                 ret = -1;
2960 
2961         if (write && ret == 0) {
2962                 /* update reachable_time as well, otherwise, the change will
2963                  * only be effective after the next time neigh_periodic_work
2964                  * decides to recompute it
2965                  */
2966                 p->reachable_time =
2967                         neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
2968         }
2969         return ret;
2970 }
2971 
2972 #define NEIGH_PARMS_DATA_OFFSET(index)  \
2973         (&((struct neigh_parms *) 0)->data[index])
2974 
2975 #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
2976         [NEIGH_VAR_ ## attr] = { \
2977                 .procname       = name, \
2978                 .data           = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
2979                 .maxlen         = sizeof(int), \
2980                 .mode           = mval, \
2981                 .proc_handler   = proc, \
2982         }
2983 
2984 #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
2985         NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
2986 
2987 #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
2988         NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
2989 
2990 #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
2991         NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
2992 
2993 #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
2994         NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2995 
2996 #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
2997         NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
2998 
2999 #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
3000         NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
3001 
3002 static struct neigh_sysctl_table {
3003         struct ctl_table_header *sysctl_header;
3004         struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
3005 } neigh_sysctl_template __read_mostly = {
3006         .neigh_vars = {
3007                 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"),
3008                 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"),
3009                 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"),
3010                 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"),
3011                 NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"),
3012                 NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"),
3013                 NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"),
3014                 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"),
3015                 NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"),
3016                 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"),
3017                 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"),
3018                 NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"),
3019                 NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"),
3020                 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"),
3021                 NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"),
3022                 [NEIGH_VAR_GC_INTERVAL] = {
3023                         .procname       = "gc_interval",
3024                         .maxlen         = sizeof(int),
3025                         .mode           = 0644,
3026                         .proc_handler   = proc_dointvec_jiffies,
3027                 },
3028                 [NEIGH_VAR_GC_THRESH1] = {
3029                         .procname       = "gc_thresh1",
3030                         .maxlen         = sizeof(int),
3031                         .mode           = 0644,
3032                         .extra1         = &zero,
3033                         .extra2         = &int_max,
3034                         .proc_handler   = proc_dointvec_minmax,
3035                 },
3036                 [NEIGH_VAR_GC_THRESH2] = {
3037                         .procname       = "gc_thresh2",
3038                         .maxlen         = sizeof(int),
3039                         .mode           = 0644,
3040                         .extra1         = &zero,
3041                         .extra2         = &int_max,
3042                         .proc_handler   = proc_dointvec_minmax,
3043                 },
3044                 [NEIGH_VAR_GC_THRESH3] = {
3045                         .procname       = "gc_thresh3",
3046                         .maxlen         = sizeof(int),
3047                         .mode           = 0644,
3048                         .extra1         = &zero,
3049                         .extra2         = &int_max,
3050                         .proc_handler   = proc_dointvec_minmax,
3051                 },
3052                 {},
3053         },
3054 };
3055 
3056 int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
3057                           proc_handler *handler)
3058 {
3059         int i;
3060         struct neigh_sysctl_table *t;
3061         const char *dev_name_source;
3062         char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
3063         char *p_name;
3064 
3065         t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
3066         if (!t)
3067                 goto err;
3068 
3069         for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) {
3070                 t->neigh_vars[i].data += (long) p;
3071                 t->neigh_vars[i].extra1 = dev;
3072                 t->neigh_vars[i].extra2 = p;
3073         }
3074 
3075         if (dev) {
3076                 dev_name_source = dev->name;
3077                 /* Terminate the table early */
3078                 memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
3079                        sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
3080         } else {
3081                 struct neigh_table *tbl = p->tbl;
3082                 dev_name_source = "default";
3083                 t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval;
3084                 t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1;
3085                 t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2;
3086                 t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3;
3087         }
3088 
3089         if (handler) {
3090                 /* RetransTime */
3091                 t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
3092                 /* ReachableTime */
3093                 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
3094                 /* RetransTime (in milliseconds)*/
3095                 t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
3096                 /* ReachableTime (in milliseconds) */
3097                 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
3098         } else {
3099                 /* Those handlers will update p->reachable_time after
3100                  * base_reachable_time(_ms) is set to ensure the new timer starts being
3101                  * applied after the next neighbour update instead of waiting for
3102                  * neigh_periodic_work to update its value (can be multiple minutes)
3103                  * So any handler that replaces them should do this as well
3104                  */
3105                 /* ReachableTime */
3106                 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler =
3107                         neigh_proc_base_reachable_time;
3108                 /* ReachableTime (in milliseconds) */
3109                 t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler =
3110                         neigh_proc_base_reachable_time;
3111         }
3112 
3113         /* Don't export sysctls to unprivileged users */
3114         if (neigh_parms_net(p)->user_ns != &init_user_ns)
3115                 t->neigh_vars[0].procname = NULL;
3116 
3117         switch (neigh_parms_family(p)) {
3118         case AF_INET:
3119               p_name = "ipv4";
3120               break;
3121         case AF_INET6:
3122               p_name = "ipv6";
3123               break;
3124         default:
3125               BUG();
3126         }
3127 
3128         snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
3129                 p_name, dev_name_source);
3130         t->sysctl_header =
3131                 register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
3132         if (!t->sysctl_header)
3133                 goto free;
3134 
3135         p->sysctl_table = t;
3136         return 0;
3137 
3138 free:
3139         kfree(t);
3140 err:
3141         return -ENOBUFS;
3142 }
3143 EXPORT_SYMBOL(neigh_sysctl_register);
3144 
3145 void neigh_sysctl_unregister(struct neigh_parms *p)
3146 {
3147         if (p->sysctl_table) {
3148                 struct neigh_sysctl_table *t = p->sysctl_table;
3149                 p->sysctl_table = NULL;
3150                 unregister_net_sysctl_table(t->sysctl_header);
3151                 kfree(t);
3152         }
3153 }
3154 EXPORT_SYMBOL(neigh_sysctl_unregister);
3155 
3156 #endif  /* CONFIG_SYSCTL */
3157 
3158 static int __init neigh_init(void)
3159 {
3160         rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
3161         rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
3162         rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
3163 
3164         rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
3165                       NULL);
3166         rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
3167 
3168         return 0;
3169 }
3170 
3171 subsys_initcall(neigh_init);
3172 
3173 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp