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

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

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

~ [ 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