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

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

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

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