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