11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * Generic address resolution entity 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Authors: 51da177e4SLinus Torvalds * Pedro Roque <roque@di.fc.ul.pt> 61da177e4SLinus Torvalds * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 91da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 101da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 111da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * Fixes: 141da177e4SLinus Torvalds * Vitaly E. Lavrov releasing NULL neighbor in neigh_add. 151da177e4SLinus Torvalds * Harald Welte Add neighbour cache statistics like rtstat 161da177e4SLinus Torvalds */ 171da177e4SLinus Torvalds 18e005d193SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 19e005d193SJoe Perches 205a0e3ad6STejun Heo #include <linux/slab.h> 211da177e4SLinus Torvalds #include <linux/types.h> 221da177e4SLinus Torvalds #include <linux/kernel.h> 231da177e4SLinus Torvalds #include <linux/module.h> 241da177e4SLinus Torvalds #include <linux/socket.h> 251da177e4SLinus Torvalds #include <linux/netdevice.h> 261da177e4SLinus Torvalds #include <linux/proc_fs.h> 271da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 281da177e4SLinus Torvalds #include <linux/sysctl.h> 291da177e4SLinus Torvalds #endif 301da177e4SLinus Torvalds #include <linux/times.h> 31457c4cbcSEric W. Biederman #include <net/net_namespace.h> 321da177e4SLinus Torvalds #include <net/neighbour.h> 331da177e4SLinus Torvalds #include <net/dst.h> 341da177e4SLinus Torvalds #include <net/sock.h> 358d71740cSTom Tucker #include <net/netevent.h> 36a14a49d2SThomas Graf #include <net/netlink.h> 371da177e4SLinus Torvalds #include <linux/rtnetlink.h> 381da177e4SLinus Torvalds #include <linux/random.h> 39543537bdSPaulo Marques #include <linux/string.h> 40c3609d51Svignesh babu #include <linux/log2.h> 411d4c8c29SJiri Pirko #include <linux/inetdevice.h> 42bba24896SJiri Pirko #include <net/addrconf.h> 431da177e4SLinus Torvalds 44d5d427cdSJoe Perches #define DEBUG 451da177e4SLinus Torvalds #define NEIGH_DEBUG 1 46d5d427cdSJoe Perches #define neigh_dbg(level, fmt, ...) \ 47d5d427cdSJoe Perches do { \ 48d5d427cdSJoe Perches if (level <= NEIGH_DEBUG) \ 49d5d427cdSJoe Perches pr_debug(fmt, ##__VA_ARGS__); \ 50d5d427cdSJoe Perches } while (0) 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds #define PNEIGH_HASHMASK 0xF 531da177e4SLinus Torvalds 541da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg); 55d961db35SThomas Graf static void __neigh_notify(struct neighbour *n, int type, int flags); 56d961db35SThomas Graf static void neigh_update_notify(struct neighbour *neigh); 571da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev); 581da177e4SLinus Torvalds 5945fc3b11SAmos Waterland #ifdef CONFIG_PROC_FS 609a32144eSArjan van de Ven static const struct file_operations neigh_stat_seq_fops; 6145fc3b11SAmos Waterland #endif 621da177e4SLinus Torvalds 631da177e4SLinus Torvalds /* 641da177e4SLinus Torvalds Neighbour hash table buckets are protected with rwlock tbl->lock. 651da177e4SLinus Torvalds 661da177e4SLinus Torvalds - All the scans/updates to hash buckets MUST be made under this lock. 671da177e4SLinus Torvalds - NOTHING clever should be made under this lock: no callbacks 681da177e4SLinus Torvalds to protocol backends, no attempts to send something to network. 691da177e4SLinus Torvalds It will result in deadlocks, if backend/driver wants to use neighbour 701da177e4SLinus Torvalds cache. 711da177e4SLinus Torvalds - If the entry requires some non-trivial actions, increase 721da177e4SLinus Torvalds its reference count and release table lock. 731da177e4SLinus Torvalds 741da177e4SLinus Torvalds Neighbour entries are protected: 751da177e4SLinus Torvalds - with reference count. 761da177e4SLinus Torvalds - with rwlock neigh->lock 771da177e4SLinus Torvalds 781da177e4SLinus Torvalds Reference count prevents destruction. 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds neigh->lock mainly serializes ll address data and its validity state. 811da177e4SLinus Torvalds However, the same lock is used to protect another entry fields: 821da177e4SLinus Torvalds - timer 831da177e4SLinus Torvalds - resolution queue 841da177e4SLinus Torvalds 851da177e4SLinus Torvalds Again, nothing clever shall be made under neigh->lock, 861da177e4SLinus Torvalds the most complicated procedure, which we allow is dev->hard_header. 871da177e4SLinus Torvalds It is supposed, that dev->hard_header is simplistic and does 881da177e4SLinus Torvalds not make callbacks to neighbour tables. 891da177e4SLinus Torvalds */ 901da177e4SLinus Torvalds 918f40b161SDavid S. Miller static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb) 921da177e4SLinus Torvalds { 931da177e4SLinus Torvalds kfree_skb(skb); 941da177e4SLinus Torvalds return -ENETDOWN; 951da177e4SLinus Torvalds } 961da177e4SLinus Torvalds 974f494554SThomas Graf static void neigh_cleanup_and_release(struct neighbour *neigh) 984f494554SThomas Graf { 994f494554SThomas Graf if (neigh->parms->neigh_cleanup) 1004f494554SThomas Graf neigh->parms->neigh_cleanup(neigh); 1014f494554SThomas Graf 102d961db35SThomas Graf __neigh_notify(neigh, RTM_DELNEIGH, 0); 1034f494554SThomas Graf neigh_release(neigh); 1044f494554SThomas Graf } 1054f494554SThomas Graf 1061da177e4SLinus Torvalds /* 1071da177e4SLinus Torvalds * It is random distribution in the interval (1/2)*base...(3/2)*base. 1081da177e4SLinus Torvalds * It corresponds to default IPv6 settings and is not overridable, 1091da177e4SLinus Torvalds * because it is really reasonable choice. 1101da177e4SLinus Torvalds */ 1111da177e4SLinus Torvalds 1121da177e4SLinus Torvalds unsigned long neigh_rand_reach_time(unsigned long base) 1131da177e4SLinus Torvalds { 11463862b5bSAruna-Hewapathirane return base ? (prandom_u32() % base) + (base >> 1) : 0; 1151da177e4SLinus Torvalds } 1160a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_rand_reach_time); 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds static int neigh_forced_gc(struct neigh_table *tbl) 1201da177e4SLinus Torvalds { 1211da177e4SLinus Torvalds int shrunk = 0; 1221da177e4SLinus Torvalds int i; 123d6bf7817SEric Dumazet struct neigh_hash_table *nht; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 128d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 129d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 130cd089336SDavid S. Miller for (i = 0; i < (1 << nht->hash_shift); i++) { 131767e97e1SEric Dumazet struct neighbour *n; 132767e97e1SEric Dumazet struct neighbour __rcu **np; 1331da177e4SLinus Torvalds 134d6bf7817SEric Dumazet np = &nht->hash_buckets[i]; 135767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 136767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 1371da177e4SLinus Torvalds /* Neighbour record may be discarded if: 1381da177e4SLinus Torvalds * - nobody refers to it. 1391da177e4SLinus Torvalds * - it is not permanent 1401da177e4SLinus Torvalds */ 1411da177e4SLinus Torvalds write_lock(&n->lock); 1421da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 1431da177e4SLinus Torvalds !(n->nud_state & NUD_PERMANENT)) { 144767e97e1SEric Dumazet rcu_assign_pointer(*np, 145767e97e1SEric Dumazet rcu_dereference_protected(n->next, 146767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 1471da177e4SLinus Torvalds n->dead = 1; 1481da177e4SLinus Torvalds shrunk = 1; 1491da177e4SLinus Torvalds write_unlock(&n->lock); 1504f494554SThomas Graf neigh_cleanup_and_release(n); 1511da177e4SLinus Torvalds continue; 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds write_unlock(&n->lock); 1541da177e4SLinus Torvalds np = &n->next; 1551da177e4SLinus Torvalds } 1561da177e4SLinus Torvalds } 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds tbl->last_flush = jiffies; 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds return shrunk; 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds 165a43d8994SPavel Emelyanov static void neigh_add_timer(struct neighbour *n, unsigned long when) 166a43d8994SPavel Emelyanov { 167a43d8994SPavel Emelyanov neigh_hold(n); 168a43d8994SPavel Emelyanov if (unlikely(mod_timer(&n->timer, when))) { 169a43d8994SPavel Emelyanov printk("NEIGH: BUG, double timer add, state is %x\n", 170a43d8994SPavel Emelyanov n->nud_state); 171a43d8994SPavel Emelyanov dump_stack(); 172a43d8994SPavel Emelyanov } 173a43d8994SPavel Emelyanov } 174a43d8994SPavel Emelyanov 1751da177e4SLinus Torvalds static int neigh_del_timer(struct neighbour *n) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds if ((n->nud_state & NUD_IN_TIMER) && 1781da177e4SLinus Torvalds del_timer(&n->timer)) { 1791da177e4SLinus Torvalds neigh_release(n); 1801da177e4SLinus Torvalds return 1; 1811da177e4SLinus Torvalds } 1821da177e4SLinus Torvalds return 0; 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds static void pneigh_queue_purge(struct sk_buff_head *list) 1861da177e4SLinus Torvalds { 1871da177e4SLinus Torvalds struct sk_buff *skb; 1881da177e4SLinus Torvalds 1891da177e4SLinus Torvalds while ((skb = skb_dequeue(list)) != NULL) { 1901da177e4SLinus Torvalds dev_put(skb->dev); 1911da177e4SLinus Torvalds kfree_skb(skb); 1921da177e4SLinus Torvalds } 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 19549636bb1SHerbert Xu static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev) 1961da177e4SLinus Torvalds { 1971da177e4SLinus Torvalds int i; 198d6bf7817SEric Dumazet struct neigh_hash_table *nht; 1991da177e4SLinus Torvalds 200d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 201d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 202d6bf7817SEric Dumazet 203cd089336SDavid S. Miller for (i = 0; i < (1 << nht->hash_shift); i++) { 204767e97e1SEric Dumazet struct neighbour *n; 205767e97e1SEric Dumazet struct neighbour __rcu **np = &nht->hash_buckets[i]; 2061da177e4SLinus Torvalds 207767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 208767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 2091da177e4SLinus Torvalds if (dev && n->dev != dev) { 2101da177e4SLinus Torvalds np = &n->next; 2111da177e4SLinus Torvalds continue; 2121da177e4SLinus Torvalds } 213767e97e1SEric Dumazet rcu_assign_pointer(*np, 214767e97e1SEric Dumazet rcu_dereference_protected(n->next, 215767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 2161da177e4SLinus Torvalds write_lock(&n->lock); 2171da177e4SLinus Torvalds neigh_del_timer(n); 2181da177e4SLinus Torvalds n->dead = 1; 2191da177e4SLinus Torvalds 2201da177e4SLinus Torvalds if (atomic_read(&n->refcnt) != 1) { 2211da177e4SLinus Torvalds /* The most unpleasant situation. 2221da177e4SLinus Torvalds We must destroy neighbour entry, 2231da177e4SLinus Torvalds but someone still uses it. 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds The destroy will be delayed until 2261da177e4SLinus Torvalds the last user releases us, but 2271da177e4SLinus Torvalds we must kill timers etc. and move 2281da177e4SLinus Torvalds it to safe state. 2291da177e4SLinus Torvalds */ 230c9ab4d85SEric Dumazet __skb_queue_purge(&n->arp_queue); 2318b5c171bSEric Dumazet n->arp_queue_len_bytes = 0; 2321da177e4SLinus Torvalds n->output = neigh_blackhole; 2331da177e4SLinus Torvalds if (n->nud_state & NUD_VALID) 2341da177e4SLinus Torvalds n->nud_state = NUD_NOARP; 2351da177e4SLinus Torvalds else 2361da177e4SLinus Torvalds n->nud_state = NUD_NONE; 237d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is stray\n", n); 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds write_unlock(&n->lock); 2404f494554SThomas Graf neigh_cleanup_and_release(n); 2411da177e4SLinus Torvalds } 2421da177e4SLinus Torvalds } 24349636bb1SHerbert Xu } 2441da177e4SLinus Torvalds 24549636bb1SHerbert Xu void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 24649636bb1SHerbert Xu { 24749636bb1SHerbert Xu write_lock_bh(&tbl->lock); 24849636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 24949636bb1SHerbert Xu write_unlock_bh(&tbl->lock); 25049636bb1SHerbert Xu } 2510a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_changeaddr); 25249636bb1SHerbert Xu 25349636bb1SHerbert Xu int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 25449636bb1SHerbert Xu { 25549636bb1SHerbert Xu write_lock_bh(&tbl->lock); 25649636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 2571da177e4SLinus Torvalds pneigh_ifdown(tbl, dev); 2581da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 2611da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 2621da177e4SLinus Torvalds return 0; 2631da177e4SLinus Torvalds } 2640a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_ifdown); 2651da177e4SLinus Torvalds 266596b9b68SDavid Miller static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev) 2671da177e4SLinus Torvalds { 2681da177e4SLinus Torvalds struct neighbour *n = NULL; 2691da177e4SLinus Torvalds unsigned long now = jiffies; 2701da177e4SLinus Torvalds int entries; 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds entries = atomic_inc_return(&tbl->entries) - 1; 2731da177e4SLinus Torvalds if (entries >= tbl->gc_thresh3 || 2741da177e4SLinus Torvalds (entries >= tbl->gc_thresh2 && 2751da177e4SLinus Torvalds time_after(now, tbl->last_flush + 5 * HZ))) { 2761da177e4SLinus Torvalds if (!neigh_forced_gc(tbl) && 2771da177e4SLinus Torvalds entries >= tbl->gc_thresh3) 2781da177e4SLinus Torvalds goto out_entries; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 28108433effSYOSHIFUJI Hideaki / 吉藤英明 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC); 2821da177e4SLinus Torvalds if (!n) 2831da177e4SLinus Torvalds goto out_entries; 2841da177e4SLinus Torvalds 285c9ab4d85SEric Dumazet __skb_queue_head_init(&n->arp_queue); 2861da177e4SLinus Torvalds rwlock_init(&n->lock); 2870ed8ddf4SEric Dumazet seqlock_init(&n->ha_lock); 2881da177e4SLinus Torvalds n->updated = n->used = now; 2891da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2901da177e4SLinus Torvalds n->output = neigh_blackhole; 291f6b72b62SDavid S. Miller seqlock_init(&n->hh.hh_lock); 2921da177e4SLinus Torvalds n->parms = neigh_parms_clone(&tbl->parms); 293b24b8a24SPavel Emelyanov setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n); 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, allocs); 2961da177e4SLinus Torvalds n->tbl = tbl; 2971da177e4SLinus Torvalds atomic_set(&n->refcnt, 1); 2981da177e4SLinus Torvalds n->dead = 1; 2991da177e4SLinus Torvalds out: 3001da177e4SLinus Torvalds return n; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds out_entries: 3031da177e4SLinus Torvalds atomic_dec(&tbl->entries); 3041da177e4SLinus Torvalds goto out; 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds 3072c2aba6cSDavid S. Miller static void neigh_get_hash_rnd(u32 *x) 3082c2aba6cSDavid S. Miller { 3092c2aba6cSDavid S. Miller get_random_bytes(x, sizeof(*x)); 3102c2aba6cSDavid S. Miller *x |= 1; 3112c2aba6cSDavid S. Miller } 3122c2aba6cSDavid S. Miller 313cd089336SDavid S. Miller static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift) 3141da177e4SLinus Torvalds { 315cd089336SDavid S. Miller size_t size = (1 << shift) * sizeof(struct neighbour *); 316d6bf7817SEric Dumazet struct neigh_hash_table *ret; 3176193d2beSEric Dumazet struct neighbour __rcu **buckets; 3182c2aba6cSDavid S. Miller int i; 3191da177e4SLinus Torvalds 320d6bf7817SEric Dumazet ret = kmalloc(sizeof(*ret), GFP_ATOMIC); 321d6bf7817SEric Dumazet if (!ret) 322d6bf7817SEric Dumazet return NULL; 323d6bf7817SEric Dumazet if (size <= PAGE_SIZE) 324d6bf7817SEric Dumazet buckets = kzalloc(size, GFP_ATOMIC); 325d6bf7817SEric Dumazet else 3266193d2beSEric Dumazet buckets = (struct neighbour __rcu **) 327d6bf7817SEric Dumazet __get_free_pages(GFP_ATOMIC | __GFP_ZERO, 328d6bf7817SEric Dumazet get_order(size)); 329d6bf7817SEric Dumazet if (!buckets) { 330d6bf7817SEric Dumazet kfree(ret); 331d6bf7817SEric Dumazet return NULL; 3321da177e4SLinus Torvalds } 3336193d2beSEric Dumazet ret->hash_buckets = buckets; 334cd089336SDavid S. Miller ret->hash_shift = shift; 3352c2aba6cSDavid S. Miller for (i = 0; i < NEIGH_NUM_HASH_RND; i++) 3362c2aba6cSDavid S. Miller neigh_get_hash_rnd(&ret->hash_rnd[i]); 3371da177e4SLinus Torvalds return ret; 3381da177e4SLinus Torvalds } 3391da177e4SLinus Torvalds 340d6bf7817SEric Dumazet static void neigh_hash_free_rcu(struct rcu_head *head) 3411da177e4SLinus Torvalds { 342d6bf7817SEric Dumazet struct neigh_hash_table *nht = container_of(head, 343d6bf7817SEric Dumazet struct neigh_hash_table, 344d6bf7817SEric Dumazet rcu); 345cd089336SDavid S. Miller size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *); 3466193d2beSEric Dumazet struct neighbour __rcu **buckets = nht->hash_buckets; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds if (size <= PAGE_SIZE) 349d6bf7817SEric Dumazet kfree(buckets); 3501da177e4SLinus Torvalds else 351d6bf7817SEric Dumazet free_pages((unsigned long)buckets, get_order(size)); 352d6bf7817SEric Dumazet kfree(nht); 3531da177e4SLinus Torvalds } 3541da177e4SLinus Torvalds 355d6bf7817SEric Dumazet static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl, 356cd089336SDavid S. Miller unsigned long new_shift) 3571da177e4SLinus Torvalds { 358d6bf7817SEric Dumazet unsigned int i, hash; 359d6bf7817SEric Dumazet struct neigh_hash_table *new_nht, *old_nht; 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hash_grows); 3621da177e4SLinus Torvalds 363d6bf7817SEric Dumazet old_nht = rcu_dereference_protected(tbl->nht, 364d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 365cd089336SDavid S. Miller new_nht = neigh_hash_alloc(new_shift); 366d6bf7817SEric Dumazet if (!new_nht) 367d6bf7817SEric Dumazet return old_nht; 3681da177e4SLinus Torvalds 369cd089336SDavid S. Miller for (i = 0; i < (1 << old_nht->hash_shift); i++) { 3701da177e4SLinus Torvalds struct neighbour *n, *next; 3711da177e4SLinus Torvalds 372767e97e1SEric Dumazet for (n = rcu_dereference_protected(old_nht->hash_buckets[i], 373767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 374d6bf7817SEric Dumazet n != NULL; 375d6bf7817SEric Dumazet n = next) { 376d6bf7817SEric Dumazet hash = tbl->hash(n->primary_key, n->dev, 377d6bf7817SEric Dumazet new_nht->hash_rnd); 3781da177e4SLinus Torvalds 379cd089336SDavid S. Miller hash >>= (32 - new_nht->hash_shift); 380767e97e1SEric Dumazet next = rcu_dereference_protected(n->next, 381767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 3821da177e4SLinus Torvalds 383767e97e1SEric Dumazet rcu_assign_pointer(n->next, 384767e97e1SEric Dumazet rcu_dereference_protected( 385767e97e1SEric Dumazet new_nht->hash_buckets[hash], 386767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 387767e97e1SEric Dumazet rcu_assign_pointer(new_nht->hash_buckets[hash], n); 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds } 3901da177e4SLinus Torvalds 391d6bf7817SEric Dumazet rcu_assign_pointer(tbl->nht, new_nht); 392d6bf7817SEric Dumazet call_rcu(&old_nht->rcu, neigh_hash_free_rcu); 393d6bf7817SEric Dumazet return new_nht; 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 3971da177e4SLinus Torvalds struct net_device *dev) 3981da177e4SLinus Torvalds { 3991da177e4SLinus Torvalds struct neighbour *n; 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 4021da177e4SLinus Torvalds 403d6bf7817SEric Dumazet rcu_read_lock_bh(); 40460395a20SEric W. Biederman n = __neigh_lookup_noref(tbl, pkey, dev); 40560395a20SEric W. Biederman if (n) { 406767e97e1SEric Dumazet if (!atomic_inc_not_zero(&n->refcnt)) 407767e97e1SEric Dumazet n = NULL; 4081da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 4091da177e4SLinus Torvalds } 410767e97e1SEric Dumazet 411d6bf7817SEric Dumazet rcu_read_unlock_bh(); 4121da177e4SLinus Torvalds return n; 4131da177e4SLinus Torvalds } 4140a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_lookup); 4151da177e4SLinus Torvalds 416426b5303SEric W. Biederman struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net, 417426b5303SEric W. Biederman const void *pkey) 4181da177e4SLinus Torvalds { 4191da177e4SLinus Torvalds struct neighbour *n; 4201da177e4SLinus Torvalds int key_len = tbl->key_len; 421bc4bf5f3SPavel Emelyanov u32 hash_val; 422d6bf7817SEric Dumazet struct neigh_hash_table *nht; 4231da177e4SLinus Torvalds 4241da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 4251da177e4SLinus Torvalds 426d6bf7817SEric Dumazet rcu_read_lock_bh(); 427d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 428cd089336SDavid S. Miller hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); 429767e97e1SEric Dumazet 430767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); 431767e97e1SEric Dumazet n != NULL; 432767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) { 433426b5303SEric W. Biederman if (!memcmp(n->primary_key, pkey, key_len) && 434878628fbSYOSHIFUJI Hideaki net_eq(dev_net(n->dev), net)) { 435767e97e1SEric Dumazet if (!atomic_inc_not_zero(&n->refcnt)) 436767e97e1SEric Dumazet n = NULL; 4371da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 4381da177e4SLinus Torvalds break; 4391da177e4SLinus Torvalds } 4401da177e4SLinus Torvalds } 441767e97e1SEric Dumazet 442d6bf7817SEric Dumazet rcu_read_unlock_bh(); 4431da177e4SLinus Torvalds return n; 4441da177e4SLinus Torvalds } 4450a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_lookup_nodev); 4461da177e4SLinus Torvalds 447a263b309SDavid S. Miller struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey, 448a263b309SDavid S. Miller struct net_device *dev, bool want_ref) 4491da177e4SLinus Torvalds { 4501da177e4SLinus Torvalds u32 hash_val; 4511da177e4SLinus Torvalds int key_len = tbl->key_len; 4521da177e4SLinus Torvalds int error; 453596b9b68SDavid Miller struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev); 454d6bf7817SEric Dumazet struct neigh_hash_table *nht; 4551da177e4SLinus Torvalds 4561da177e4SLinus Torvalds if (!n) { 4571da177e4SLinus Torvalds rc = ERR_PTR(-ENOBUFS); 4581da177e4SLinus Torvalds goto out; 4591da177e4SLinus Torvalds } 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds memcpy(n->primary_key, pkey, key_len); 4621da177e4SLinus Torvalds n->dev = dev; 4631da177e4SLinus Torvalds dev_hold(dev); 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds /* Protocol specific setup. */ 4661da177e4SLinus Torvalds if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 4671da177e4SLinus Torvalds rc = ERR_PTR(error); 4681da177e4SLinus Torvalds goto out_neigh_release; 4691da177e4SLinus Torvalds } 4701da177e4SLinus Torvalds 471da6a8fa0SDavid Miller if (dev->netdev_ops->ndo_neigh_construct) { 472da6a8fa0SDavid Miller error = dev->netdev_ops->ndo_neigh_construct(n); 473da6a8fa0SDavid Miller if (error < 0) { 474da6a8fa0SDavid Miller rc = ERR_PTR(error); 475da6a8fa0SDavid Miller goto out_neigh_release; 476da6a8fa0SDavid Miller } 477da6a8fa0SDavid Miller } 478da6a8fa0SDavid Miller 479447f2191SDavid S. Miller /* Device specific setup. */ 480447f2191SDavid S. Miller if (n->parms->neigh_setup && 481447f2191SDavid S. Miller (error = n->parms->neigh_setup(n)) < 0) { 482447f2191SDavid S. Miller rc = ERR_PTR(error); 483447f2191SDavid S. Miller goto out_neigh_release; 484447f2191SDavid S. Miller } 485447f2191SDavid S. Miller 4861f9248e5SJiri Pirko n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1); 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 489d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 490d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 4911da177e4SLinus Torvalds 492cd089336SDavid S. Miller if (atomic_read(&tbl->entries) > (1 << nht->hash_shift)) 493cd089336SDavid S. Miller nht = neigh_hash_grow(tbl, nht->hash_shift + 1); 4941da177e4SLinus Torvalds 495cd089336SDavid S. Miller hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds if (n->parms->dead) { 4981da177e4SLinus Torvalds rc = ERR_PTR(-EINVAL); 4991da177e4SLinus Torvalds goto out_tbl_unlock; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 502767e97e1SEric Dumazet for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val], 503767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 504767e97e1SEric Dumazet n1 != NULL; 505767e97e1SEric Dumazet n1 = rcu_dereference_protected(n1->next, 506767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) { 5071da177e4SLinus Torvalds if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 508a263b309SDavid S. Miller if (want_ref) 5091da177e4SLinus Torvalds neigh_hold(n1); 5101da177e4SLinus Torvalds rc = n1; 5111da177e4SLinus Torvalds goto out_tbl_unlock; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds n->dead = 0; 516a263b309SDavid S. Miller if (want_ref) 5171da177e4SLinus Torvalds neigh_hold(n); 518767e97e1SEric Dumazet rcu_assign_pointer(n->next, 519767e97e1SEric Dumazet rcu_dereference_protected(nht->hash_buckets[hash_val], 520767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 521767e97e1SEric Dumazet rcu_assign_pointer(nht->hash_buckets[hash_val], n); 5221da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 523d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is created\n", n); 5241da177e4SLinus Torvalds rc = n; 5251da177e4SLinus Torvalds out: 5261da177e4SLinus Torvalds return rc; 5271da177e4SLinus Torvalds out_tbl_unlock: 5281da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5291da177e4SLinus Torvalds out_neigh_release: 5301da177e4SLinus Torvalds neigh_release(n); 5311da177e4SLinus Torvalds goto out; 5321da177e4SLinus Torvalds } 533a263b309SDavid S. Miller EXPORT_SYMBOL(__neigh_create); 5341da177e4SLinus Torvalds 535be01d655SYOSHIFUJI Hideaki static u32 pneigh_hash(const void *pkey, int key_len) 536fa86d322SPavel Emelyanov { 537fa86d322SPavel Emelyanov u32 hash_val = *(u32 *)(pkey + key_len - 4); 538fa86d322SPavel Emelyanov hash_val ^= (hash_val >> 16); 539fa86d322SPavel Emelyanov hash_val ^= hash_val >> 8; 540fa86d322SPavel Emelyanov hash_val ^= hash_val >> 4; 541fa86d322SPavel Emelyanov hash_val &= PNEIGH_HASHMASK; 542be01d655SYOSHIFUJI Hideaki return hash_val; 543fa86d322SPavel Emelyanov } 544fa86d322SPavel Emelyanov 545be01d655SYOSHIFUJI Hideaki static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n, 546be01d655SYOSHIFUJI Hideaki struct net *net, 547be01d655SYOSHIFUJI Hideaki const void *pkey, 548be01d655SYOSHIFUJI Hideaki int key_len, 549be01d655SYOSHIFUJI Hideaki struct net_device *dev) 550be01d655SYOSHIFUJI Hideaki { 551be01d655SYOSHIFUJI Hideaki while (n) { 552be01d655SYOSHIFUJI Hideaki if (!memcmp(n->key, pkey, key_len) && 553be01d655SYOSHIFUJI Hideaki net_eq(pneigh_net(n), net) && 554be01d655SYOSHIFUJI Hideaki (n->dev == dev || !n->dev)) 555fa86d322SPavel Emelyanov return n; 556be01d655SYOSHIFUJI Hideaki n = n->next; 557be01d655SYOSHIFUJI Hideaki } 558be01d655SYOSHIFUJI Hideaki return NULL; 559be01d655SYOSHIFUJI Hideaki } 560be01d655SYOSHIFUJI Hideaki 561be01d655SYOSHIFUJI Hideaki struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, 562be01d655SYOSHIFUJI Hideaki struct net *net, const void *pkey, struct net_device *dev) 563be01d655SYOSHIFUJI Hideaki { 564be01d655SYOSHIFUJI Hideaki int key_len = tbl->key_len; 565be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 566be01d655SYOSHIFUJI Hideaki 567be01d655SYOSHIFUJI Hideaki return __pneigh_lookup_1(tbl->phash_buckets[hash_val], 568be01d655SYOSHIFUJI Hideaki net, pkey, key_len, dev); 569fa86d322SPavel Emelyanov } 5700a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL_GPL(__pneigh_lookup); 571fa86d322SPavel Emelyanov 572426b5303SEric W. Biederman struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, 573426b5303SEric W. Biederman struct net *net, const void *pkey, 5741da177e4SLinus Torvalds struct net_device *dev, int creat) 5751da177e4SLinus Torvalds { 5761da177e4SLinus Torvalds struct pneigh_entry *n; 5771da177e4SLinus Torvalds int key_len = tbl->key_len; 578be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 581be01d655SYOSHIFUJI Hideaki n = __pneigh_lookup_1(tbl->phash_buckets[hash_val], 582be01d655SYOSHIFUJI Hideaki net, pkey, key_len, dev); 583be01d655SYOSHIFUJI Hideaki read_unlock_bh(&tbl->lock); 5841da177e4SLinus Torvalds 585be01d655SYOSHIFUJI Hideaki if (n || !creat) 5861da177e4SLinus Torvalds goto out; 5871da177e4SLinus Torvalds 5884ae28944SPavel Emelyanov ASSERT_RTNL(); 5894ae28944SPavel Emelyanov 5901da177e4SLinus Torvalds n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 5911da177e4SLinus Torvalds if (!n) 5921da177e4SLinus Torvalds goto out; 5931da177e4SLinus Torvalds 594e42ea986SEric Dumazet write_pnet(&n->net, hold_net(net)); 5951da177e4SLinus Torvalds memcpy(n->key, pkey, key_len); 5961da177e4SLinus Torvalds n->dev = dev; 5971da177e4SLinus Torvalds if (dev) 5981da177e4SLinus Torvalds dev_hold(dev); 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds if (tbl->pconstructor && tbl->pconstructor(n)) { 6011da177e4SLinus Torvalds if (dev) 6021da177e4SLinus Torvalds dev_put(dev); 603da12f735SDenis V. Lunev release_net(net); 6041da177e4SLinus Torvalds kfree(n); 6051da177e4SLinus Torvalds n = NULL; 6061da177e4SLinus Torvalds goto out; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 6101da177e4SLinus Torvalds n->next = tbl->phash_buckets[hash_val]; 6111da177e4SLinus Torvalds tbl->phash_buckets[hash_val] = n; 6121da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6131da177e4SLinus Torvalds out: 6141da177e4SLinus Torvalds return n; 6151da177e4SLinus Torvalds } 6160a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(pneigh_lookup); 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds 619426b5303SEric W. Biederman int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey, 6201da177e4SLinus Torvalds struct net_device *dev) 6211da177e4SLinus Torvalds { 6221da177e4SLinus Torvalds struct pneigh_entry *n, **np; 6231da177e4SLinus Torvalds int key_len = tbl->key_len; 624be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 6271da177e4SLinus Torvalds for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 6281da177e4SLinus Torvalds np = &n->next) { 629426b5303SEric W. Biederman if (!memcmp(n->key, pkey, key_len) && n->dev == dev && 630878628fbSYOSHIFUJI Hideaki net_eq(pneigh_net(n), net)) { 6311da177e4SLinus Torvalds *np = n->next; 6321da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6331da177e4SLinus Torvalds if (tbl->pdestructor) 6341da177e4SLinus Torvalds tbl->pdestructor(n); 6351da177e4SLinus Torvalds if (n->dev) 6361da177e4SLinus Torvalds dev_put(n->dev); 63757da52c1SYOSHIFUJI Hideaki release_net(pneigh_net(n)); 6381da177e4SLinus Torvalds kfree(n); 6391da177e4SLinus Torvalds return 0; 6401da177e4SLinus Torvalds } 6411da177e4SLinus Torvalds } 6421da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6431da177e4SLinus Torvalds return -ENOENT; 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 6471da177e4SLinus Torvalds { 6481da177e4SLinus Torvalds struct pneigh_entry *n, **np; 6491da177e4SLinus Torvalds u32 h; 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds for (h = 0; h <= PNEIGH_HASHMASK; h++) { 6521da177e4SLinus Torvalds np = &tbl->phash_buckets[h]; 6531da177e4SLinus Torvalds while ((n = *np) != NULL) { 6541da177e4SLinus Torvalds if (!dev || n->dev == dev) { 6551da177e4SLinus Torvalds *np = n->next; 6561da177e4SLinus Torvalds if (tbl->pdestructor) 6571da177e4SLinus Torvalds tbl->pdestructor(n); 6581da177e4SLinus Torvalds if (n->dev) 6591da177e4SLinus Torvalds dev_put(n->dev); 66057da52c1SYOSHIFUJI Hideaki release_net(pneigh_net(n)); 6611da177e4SLinus Torvalds kfree(n); 6621da177e4SLinus Torvalds continue; 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds np = &n->next; 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds return -ENOENT; 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 67006f0511dSDenis V. Lunev static void neigh_parms_destroy(struct neigh_parms *parms); 67106f0511dSDenis V. Lunev 67206f0511dSDenis V. Lunev static inline void neigh_parms_put(struct neigh_parms *parms) 67306f0511dSDenis V. Lunev { 67406f0511dSDenis V. Lunev if (atomic_dec_and_test(&parms->refcnt)) 67506f0511dSDenis V. Lunev neigh_parms_destroy(parms); 67606f0511dSDenis V. Lunev } 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds /* 6791da177e4SLinus Torvalds * neighbour must already be out of the table; 6801da177e4SLinus Torvalds * 6811da177e4SLinus Torvalds */ 6821da177e4SLinus Torvalds void neigh_destroy(struct neighbour *neigh) 6831da177e4SLinus Torvalds { 684da6a8fa0SDavid Miller struct net_device *dev = neigh->dev; 685da6a8fa0SDavid Miller 6861da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds if (!neigh->dead) { 689e005d193SJoe Perches pr_warn("Destroying alive neighbour %p\n", neigh); 6901da177e4SLinus Torvalds dump_stack(); 6911da177e4SLinus Torvalds return; 6921da177e4SLinus Torvalds } 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds if (neigh_del_timer(neigh)) 695e005d193SJoe Perches pr_warn("Impossible event\n"); 6961da177e4SLinus Torvalds 697c9ab4d85SEric Dumazet write_lock_bh(&neigh->lock); 698c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 699c9ab4d85SEric Dumazet write_unlock_bh(&neigh->lock); 7008b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 7011da177e4SLinus Torvalds 702447f2191SDavid S. Miller if (dev->netdev_ops->ndo_neigh_destroy) 703447f2191SDavid S. Miller dev->netdev_ops->ndo_neigh_destroy(neigh); 704447f2191SDavid S. Miller 705da6a8fa0SDavid Miller dev_put(dev); 7061da177e4SLinus Torvalds neigh_parms_put(neigh->parms); 7071da177e4SLinus Torvalds 708d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is destroyed\n", neigh); 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds atomic_dec(&neigh->tbl->entries); 7115b8b0060SDavid Miller kfree_rcu(neigh, rcu); 7121da177e4SLinus Torvalds } 7130a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_destroy); 7141da177e4SLinus Torvalds 7151da177e4SLinus Torvalds /* Neighbour state is suspicious; 7161da177e4SLinus Torvalds disable fast path. 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds Called with write_locked neigh. 7191da177e4SLinus Torvalds */ 7201da177e4SLinus Torvalds static void neigh_suspect(struct neighbour *neigh) 7211da177e4SLinus Torvalds { 722d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is suspected\n", neigh); 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds neigh->output = neigh->ops->output; 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds /* Neighbour state is OK; 7281da177e4SLinus Torvalds enable fast path. 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds Called with write_locked neigh. 7311da177e4SLinus Torvalds */ 7321da177e4SLinus Torvalds static void neigh_connect(struct neighbour *neigh) 7331da177e4SLinus Torvalds { 734d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is connected\n", neigh); 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds neigh->output = neigh->ops->connected_output; 7371da177e4SLinus Torvalds } 7381da177e4SLinus Torvalds 739e4c4e448SEric Dumazet static void neigh_periodic_work(struct work_struct *work) 7401da177e4SLinus Torvalds { 741e4c4e448SEric Dumazet struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work); 742767e97e1SEric Dumazet struct neighbour *n; 743767e97e1SEric Dumazet struct neighbour __rcu **np; 744e4c4e448SEric Dumazet unsigned int i; 745d6bf7817SEric Dumazet struct neigh_hash_table *nht; 7461da177e4SLinus Torvalds 7471da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 7481da177e4SLinus Torvalds 749e4c4e448SEric Dumazet write_lock_bh(&tbl->lock); 750d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 751d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 7521da177e4SLinus Torvalds 7531da177e4SLinus Torvalds /* 7541da177e4SLinus Torvalds * periodically recompute ReachableTime from random function 7551da177e4SLinus Torvalds */ 7561da177e4SLinus Torvalds 757e4c4e448SEric Dumazet if (time_after(jiffies, tbl->last_rand + 300 * HZ)) { 7581da177e4SLinus Torvalds struct neigh_parms *p; 759e4c4e448SEric Dumazet tbl->last_rand = jiffies; 76075fbfd33SNicolas Dichtel list_for_each_entry(p, &tbl->parms_list, list) 7611da177e4SLinus Torvalds p->reachable_time = 7621f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds 765feff9ab2SDuan Jiong if (atomic_read(&tbl->entries) < tbl->gc_thresh1) 766feff9ab2SDuan Jiong goto out; 767feff9ab2SDuan Jiong 768cd089336SDavid S. Miller for (i = 0 ; i < (1 << nht->hash_shift); i++) { 769d6bf7817SEric Dumazet np = &nht->hash_buckets[i]; 7701da177e4SLinus Torvalds 771767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 772767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 7731da177e4SLinus Torvalds unsigned int state; 7741da177e4SLinus Torvalds 7751da177e4SLinus Torvalds write_lock(&n->lock); 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds state = n->nud_state; 7781da177e4SLinus Torvalds if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 7791da177e4SLinus Torvalds write_unlock(&n->lock); 7801da177e4SLinus Torvalds goto next_elt; 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds if (time_before(n->used, n->confirmed)) 7841da177e4SLinus Torvalds n->used = n->confirmed; 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 7871da177e4SLinus Torvalds (state == NUD_FAILED || 7881f9248e5SJiri Pirko time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) { 7891da177e4SLinus Torvalds *np = n->next; 7901da177e4SLinus Torvalds n->dead = 1; 7911da177e4SLinus Torvalds write_unlock(&n->lock); 7924f494554SThomas Graf neigh_cleanup_and_release(n); 7931da177e4SLinus Torvalds continue; 7941da177e4SLinus Torvalds } 7951da177e4SLinus Torvalds write_unlock(&n->lock); 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds next_elt: 7981da177e4SLinus Torvalds np = &n->next; 7991da177e4SLinus Torvalds } 800e4c4e448SEric Dumazet /* 801e4c4e448SEric Dumazet * It's fine to release lock here, even if hash table 802e4c4e448SEric Dumazet * grows while we are preempted. 803e4c4e448SEric Dumazet */ 804e4c4e448SEric Dumazet write_unlock_bh(&tbl->lock); 805e4c4e448SEric Dumazet cond_resched(); 806e4c4e448SEric Dumazet write_lock_bh(&tbl->lock); 80784338a6cSMichel Machado nht = rcu_dereference_protected(tbl->nht, 80884338a6cSMichel Machado lockdep_is_held(&tbl->lock)); 809e4c4e448SEric Dumazet } 8102724680bSYOSHIFUJI Hideaki / 吉藤英明 out: 8111f9248e5SJiri Pirko /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks. 8121f9248e5SJiri Pirko * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2 8131f9248e5SJiri Pirko * BASE_REACHABLE_TIME. 8141da177e4SLinus Torvalds */ 815f618002bSviresh kumar queue_delayed_work(system_power_efficient_wq, &tbl->gc_work, 8161f9248e5SJiri Pirko NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1); 817e4c4e448SEric Dumazet write_unlock_bh(&tbl->lock); 8181da177e4SLinus Torvalds } 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds static __inline__ int neigh_max_probes(struct neighbour *n) 8211da177e4SLinus Torvalds { 8221da177e4SLinus Torvalds struct neigh_parms *p = n->parms; 823a960ff81STimo Teräs int max_probes = NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES); 824a960ff81STimo Teräs if (!(n->nud_state & NUD_PROBE)) 825a960ff81STimo Teräs max_probes += NEIGH_VAR(p, MCAST_PROBES); 826a960ff81STimo Teräs return max_probes; 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds 8295ef12d98STimo Teras static void neigh_invalidate(struct neighbour *neigh) 8300a141509SEric Dumazet __releases(neigh->lock) 8310a141509SEric Dumazet __acquires(neigh->lock) 8325ef12d98STimo Teras { 8335ef12d98STimo Teras struct sk_buff *skb; 8345ef12d98STimo Teras 8355ef12d98STimo Teras NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 836d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is failed\n", neigh); 8375ef12d98STimo Teras neigh->updated = jiffies; 8385ef12d98STimo Teras 8395ef12d98STimo Teras /* It is very thin place. report_unreachable is very complicated 8405ef12d98STimo Teras routine. Particularly, it can hit the same neighbour entry! 8415ef12d98STimo Teras 8425ef12d98STimo Teras So that, we try to be accurate and avoid dead loop. --ANK 8435ef12d98STimo Teras */ 8445ef12d98STimo Teras while (neigh->nud_state == NUD_FAILED && 8455ef12d98STimo Teras (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 8465ef12d98STimo Teras write_unlock(&neigh->lock); 8475ef12d98STimo Teras neigh->ops->error_report(neigh, skb); 8485ef12d98STimo Teras write_lock(&neigh->lock); 8495ef12d98STimo Teras } 850c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 8518b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 8525ef12d98STimo Teras } 8535ef12d98STimo Teras 854cd28ca0aSEric Dumazet static void neigh_probe(struct neighbour *neigh) 855cd28ca0aSEric Dumazet __releases(neigh->lock) 856cd28ca0aSEric Dumazet { 8574ed377e3SHannes Frederic Sowa struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue); 858cd28ca0aSEric Dumazet /* keep skb alive even if arp_queue overflows */ 859cd28ca0aSEric Dumazet if (skb) 860cd28ca0aSEric Dumazet skb = skb_copy(skb, GFP_ATOMIC); 861cd28ca0aSEric Dumazet write_unlock(&neigh->lock); 862cd28ca0aSEric Dumazet neigh->ops->solicit(neigh, skb); 863cd28ca0aSEric Dumazet atomic_inc(&neigh->probes); 864cd28ca0aSEric Dumazet kfree_skb(skb); 865cd28ca0aSEric Dumazet } 866cd28ca0aSEric Dumazet 8671da177e4SLinus Torvalds /* Called when a timer expires for a neighbour entry. */ 8681da177e4SLinus Torvalds 8691da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg) 8701da177e4SLinus Torvalds { 8711da177e4SLinus Torvalds unsigned long now, next; 8721da177e4SLinus Torvalds struct neighbour *neigh = (struct neighbour *)arg; 87395c96174SEric Dumazet unsigned int state; 8741da177e4SLinus Torvalds int notify = 0; 8751da177e4SLinus Torvalds 8761da177e4SLinus Torvalds write_lock(&neigh->lock); 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds state = neigh->nud_state; 8791da177e4SLinus Torvalds now = jiffies; 8801da177e4SLinus Torvalds next = now + HZ; 8811da177e4SLinus Torvalds 882045f7b3bSDavid S. Miller if (!(state & NUD_IN_TIMER)) 8831da177e4SLinus Torvalds goto out; 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds if (state & NUD_REACHABLE) { 8861da177e4SLinus Torvalds if (time_before_eq(now, 8871da177e4SLinus Torvalds neigh->confirmed + neigh->parms->reachable_time)) { 888d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is still alive\n", neigh); 8891da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 8901da177e4SLinus Torvalds } else if (time_before_eq(now, 8911f9248e5SJiri Pirko neigh->used + 8921f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 893d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is delayed\n", neigh); 8941da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 895955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 8961da177e4SLinus Torvalds neigh_suspect(neigh); 8971f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); 8981da177e4SLinus Torvalds } else { 899d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is suspected\n", neigh); 9001da177e4SLinus Torvalds neigh->nud_state = NUD_STALE; 901955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9021da177e4SLinus Torvalds neigh_suspect(neigh); 9038d71740cSTom Tucker notify = 1; 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds } else if (state & NUD_DELAY) { 9061da177e4SLinus Torvalds if (time_before_eq(now, 9071f9248e5SJiri Pirko neigh->confirmed + 9081f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 909d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is now reachable\n", neigh); 9101da177e4SLinus Torvalds neigh->nud_state = NUD_REACHABLE; 911955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9121da177e4SLinus Torvalds neigh_connect(neigh); 9138d71740cSTom Tucker notify = 1; 9141da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 9151da177e4SLinus Torvalds } else { 916d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is probed\n", neigh); 9171da177e4SLinus Torvalds neigh->nud_state = NUD_PROBE; 918955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9191da177e4SLinus Torvalds atomic_set(&neigh->probes, 0); 9201f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 9211da177e4SLinus Torvalds } 9221da177e4SLinus Torvalds } else { 9231da177e4SLinus Torvalds /* NUD_PROBE|NUD_INCOMPLETE */ 9241f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 9281da177e4SLinus Torvalds atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 9291da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 9301da177e4SLinus Torvalds notify = 1; 9315ef12d98STimo Teras neigh_invalidate(neigh); 9325e2c21dcSDuan Jiong goto out; 9331da177e4SLinus Torvalds } 9341da177e4SLinus Torvalds 9351da177e4SLinus Torvalds if (neigh->nud_state & NUD_IN_TIMER) { 9361da177e4SLinus Torvalds if (time_before(next, jiffies + HZ/2)) 9371da177e4SLinus Torvalds next = jiffies + HZ/2; 9386fb9974fSHerbert Xu if (!mod_timer(&neigh->timer, next)) 9396fb9974fSHerbert Xu neigh_hold(neigh); 9401da177e4SLinus Torvalds } 9411da177e4SLinus Torvalds if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 942cd28ca0aSEric Dumazet neigh_probe(neigh); 9439ff56607SDavid S. Miller } else { 9441da177e4SLinus Torvalds out: 9451da177e4SLinus Torvalds write_unlock(&neigh->lock); 9469ff56607SDavid S. Miller } 9471da177e4SLinus Torvalds 948d961db35SThomas Graf if (notify) 949d961db35SThomas Graf neigh_update_notify(neigh); 950d961db35SThomas Graf 9511da177e4SLinus Torvalds neigh_release(neigh); 9521da177e4SLinus Torvalds } 9531da177e4SLinus Torvalds 9541da177e4SLinus Torvalds int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 9551da177e4SLinus Torvalds { 9561da177e4SLinus Torvalds int rc; 957cd28ca0aSEric Dumazet bool immediate_probe = false; 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds rc = 0; 9621da177e4SLinus Torvalds if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 9631da177e4SLinus Torvalds goto out_unlock_bh; 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 9661f9248e5SJiri Pirko if (NEIGH_VAR(neigh->parms, MCAST_PROBES) + 9671f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, APP_PROBES)) { 968cd28ca0aSEric Dumazet unsigned long next, now = jiffies; 969cd28ca0aSEric Dumazet 9701f9248e5SJiri Pirko atomic_set(&neigh->probes, 9711f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, UCAST_PROBES)); 9721da177e4SLinus Torvalds neigh->nud_state = NUD_INCOMPLETE; 973cd28ca0aSEric Dumazet neigh->updated = now; 9741f9248e5SJiri Pirko next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME), 9751f9248e5SJiri Pirko HZ/2); 976cd28ca0aSEric Dumazet neigh_add_timer(neigh, next); 977cd28ca0aSEric Dumazet immediate_probe = true; 9781da177e4SLinus Torvalds } else { 9791da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 980955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9811da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds kfree_skb(skb); 9841da177e4SLinus Torvalds return 1; 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds } else if (neigh->nud_state & NUD_STALE) { 987d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is delayed\n", neigh); 9881da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 989955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9901f9248e5SJiri Pirko neigh_add_timer(neigh, jiffies + 9911f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME)); 9921da177e4SLinus Torvalds } 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds if (neigh->nud_state == NUD_INCOMPLETE) { 9951da177e4SLinus Torvalds if (skb) { 9968b5c171bSEric Dumazet while (neigh->arp_queue_len_bytes + skb->truesize > 9971f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) { 9981da177e4SLinus Torvalds struct sk_buff *buff; 9998b5c171bSEric Dumazet 1000f72051b0SDavid S. Miller buff = __skb_dequeue(&neigh->arp_queue); 10018b5c171bSEric Dumazet if (!buff) 10028b5c171bSEric Dumazet break; 10038b5c171bSEric Dumazet neigh->arp_queue_len_bytes -= buff->truesize; 10041da177e4SLinus Torvalds kfree_skb(buff); 10059a6d276eSNeil Horman NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards); 10061da177e4SLinus Torvalds } 1007a4731138SEric Dumazet skb_dst_force(skb); 10081da177e4SLinus Torvalds __skb_queue_tail(&neigh->arp_queue, skb); 10098b5c171bSEric Dumazet neigh->arp_queue_len_bytes += skb->truesize; 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds rc = 1; 10121da177e4SLinus Torvalds } 10131da177e4SLinus Torvalds out_unlock_bh: 1014cd28ca0aSEric Dumazet if (immediate_probe) 1015cd28ca0aSEric Dumazet neigh_probe(neigh); 1016cd28ca0aSEric Dumazet else 1017cd28ca0aSEric Dumazet write_unlock(&neigh->lock); 1018cd28ca0aSEric Dumazet local_bh_enable(); 10191da177e4SLinus Torvalds return rc; 10201da177e4SLinus Torvalds } 10210a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(__neigh_event_send); 10221da177e4SLinus Torvalds 1023f6b72b62SDavid S. Miller static void neigh_update_hhs(struct neighbour *neigh) 10241da177e4SLinus Torvalds { 10251da177e4SLinus Torvalds struct hh_cache *hh; 10263b04dddeSStephen Hemminger void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *) 102791a72a70SDoug Kehn = NULL; 102891a72a70SDoug Kehn 102991a72a70SDoug Kehn if (neigh->dev->header_ops) 103091a72a70SDoug Kehn update = neigh->dev->header_ops->cache_update; 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds if (update) { 1033f6b72b62SDavid S. Miller hh = &neigh->hh; 1034f6b72b62SDavid S. Miller if (hh->hh_len) { 10353644f0ceSStephen Hemminger write_seqlock_bh(&hh->hh_lock); 10361da177e4SLinus Torvalds update(hh, neigh->dev, neigh->ha); 10373644f0ceSStephen Hemminger write_sequnlock_bh(&hh->hh_lock); 10381da177e4SLinus Torvalds } 10391da177e4SLinus Torvalds } 10401da177e4SLinus Torvalds } 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds /* Generic update routine. 10451da177e4SLinus Torvalds -- lladdr is new lladdr or NULL, if it is not supplied. 10461da177e4SLinus Torvalds -- new is new state. 10471da177e4SLinus Torvalds -- flags 10481da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 10491da177e4SLinus Torvalds if it is different. 10501da177e4SLinus Torvalds NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 10511da177e4SLinus Torvalds lladdr instead of overriding it 10521da177e4SLinus Torvalds if it is different. 10531da177e4SLinus Torvalds It also allows to retain current state 10541da177e4SLinus Torvalds if lladdr is unchanged. 10551da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN means that the change is administrative. 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 10581da177e4SLinus Torvalds NTF_ROUTER flag. 10591da177e4SLinus Torvalds NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 10601da177e4SLinus Torvalds a router. 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds Caller MUST hold reference count on the entry. 10631da177e4SLinus Torvalds */ 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 10661da177e4SLinus Torvalds u32 flags) 10671da177e4SLinus Torvalds { 10681da177e4SLinus Torvalds u8 old; 10691da177e4SLinus Torvalds int err; 10701da177e4SLinus Torvalds int notify = 0; 10711da177e4SLinus Torvalds struct net_device *dev; 10721da177e4SLinus Torvalds int update_isrouter = 0; 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 10751da177e4SLinus Torvalds 10761da177e4SLinus Torvalds dev = neigh->dev; 10771da177e4SLinus Torvalds old = neigh->nud_state; 10781da177e4SLinus Torvalds err = -EPERM; 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds if (!(flags & NEIGH_UPDATE_F_ADMIN) && 10811da177e4SLinus Torvalds (old & (NUD_NOARP | NUD_PERMANENT))) 10821da177e4SLinus Torvalds goto out; 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds if (!(new & NUD_VALID)) { 10851da177e4SLinus Torvalds neigh_del_timer(neigh); 10861da177e4SLinus Torvalds if (old & NUD_CONNECTED) 10871da177e4SLinus Torvalds neigh_suspect(neigh); 10881da177e4SLinus Torvalds neigh->nud_state = new; 10891da177e4SLinus Torvalds err = 0; 10901da177e4SLinus Torvalds notify = old & NUD_VALID; 10915ef12d98STimo Teras if ((old & (NUD_INCOMPLETE | NUD_PROBE)) && 10925ef12d98STimo Teras (new & NUD_FAILED)) { 10935ef12d98STimo Teras neigh_invalidate(neigh); 10945ef12d98STimo Teras notify = 1; 10955ef12d98STimo Teras } 10961da177e4SLinus Torvalds goto out; 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds /* Compare new lladdr with cached one */ 11001da177e4SLinus Torvalds if (!dev->addr_len) { 11011da177e4SLinus Torvalds /* First case: device needs no address. */ 11021da177e4SLinus Torvalds lladdr = neigh->ha; 11031da177e4SLinus Torvalds } else if (lladdr) { 11041da177e4SLinus Torvalds /* The second case: if something is already cached 11051da177e4SLinus Torvalds and a new address is proposed: 11061da177e4SLinus Torvalds - compare new & old 11071da177e4SLinus Torvalds - if they are different, check override flag 11081da177e4SLinus Torvalds */ 11091da177e4SLinus Torvalds if ((old & NUD_VALID) && 11101da177e4SLinus Torvalds !memcmp(lladdr, neigh->ha, dev->addr_len)) 11111da177e4SLinus Torvalds lladdr = neigh->ha; 11121da177e4SLinus Torvalds } else { 11131da177e4SLinus Torvalds /* No address is supplied; if we know something, 11141da177e4SLinus Torvalds use it, otherwise discard the request. 11151da177e4SLinus Torvalds */ 11161da177e4SLinus Torvalds err = -EINVAL; 11171da177e4SLinus Torvalds if (!(old & NUD_VALID)) 11181da177e4SLinus Torvalds goto out; 11191da177e4SLinus Torvalds lladdr = neigh->ha; 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds if (new & NUD_CONNECTED) 11231da177e4SLinus Torvalds neigh->confirmed = jiffies; 11241da177e4SLinus Torvalds neigh->updated = jiffies; 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds /* If entry was valid and address is not changed, 11271da177e4SLinus Torvalds do not change entry state, if new one is STALE. 11281da177e4SLinus Torvalds */ 11291da177e4SLinus Torvalds err = 0; 11301da177e4SLinus Torvalds update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 11311da177e4SLinus Torvalds if (old & NUD_VALID) { 11321da177e4SLinus Torvalds if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 11331da177e4SLinus Torvalds update_isrouter = 0; 11341da177e4SLinus Torvalds if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 11351da177e4SLinus Torvalds (old & NUD_CONNECTED)) { 11361da177e4SLinus Torvalds lladdr = neigh->ha; 11371da177e4SLinus Torvalds new = NUD_STALE; 11381da177e4SLinus Torvalds } else 11391da177e4SLinus Torvalds goto out; 11401da177e4SLinus Torvalds } else { 11411da177e4SLinus Torvalds if (lladdr == neigh->ha && new == NUD_STALE && 11421da177e4SLinus Torvalds ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 11431da177e4SLinus Torvalds (old & NUD_CONNECTED)) 11441da177e4SLinus Torvalds ) 11451da177e4SLinus Torvalds new = old; 11461da177e4SLinus Torvalds } 11471da177e4SLinus Torvalds } 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds if (new != old) { 11501da177e4SLinus Torvalds neigh_del_timer(neigh); 1151a43d8994SPavel Emelyanov if (new & NUD_IN_TIMER) 1152667347f1SDavid S. Miller neigh_add_timer(neigh, (jiffies + 11531da177e4SLinus Torvalds ((new & NUD_REACHABLE) ? 1154667347f1SDavid S. Miller neigh->parms->reachable_time : 1155667347f1SDavid S. Miller 0))); 11561da177e4SLinus Torvalds neigh->nud_state = new; 115753385d2dSBob Gilligan notify = 1; 11581da177e4SLinus Torvalds } 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds if (lladdr != neigh->ha) { 11610ed8ddf4SEric Dumazet write_seqlock(&neigh->ha_lock); 11621da177e4SLinus Torvalds memcpy(&neigh->ha, lladdr, dev->addr_len); 11630ed8ddf4SEric Dumazet write_sequnlock(&neigh->ha_lock); 11641da177e4SLinus Torvalds neigh_update_hhs(neigh); 11651da177e4SLinus Torvalds if (!(new & NUD_CONNECTED)) 11661da177e4SLinus Torvalds neigh->confirmed = jiffies - 11671f9248e5SJiri Pirko (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1); 11681da177e4SLinus Torvalds notify = 1; 11691da177e4SLinus Torvalds } 11701da177e4SLinus Torvalds if (new == old) 11711da177e4SLinus Torvalds goto out; 11721da177e4SLinus Torvalds if (new & NUD_CONNECTED) 11731da177e4SLinus Torvalds neigh_connect(neigh); 11741da177e4SLinus Torvalds else 11751da177e4SLinus Torvalds neigh_suspect(neigh); 11761da177e4SLinus Torvalds if (!(old & NUD_VALID)) { 11771da177e4SLinus Torvalds struct sk_buff *skb; 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds /* Again: avoid dead loop if something went wrong */ 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds while (neigh->nud_state & NUD_VALID && 11821da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 118369cce1d1SDavid S. Miller struct dst_entry *dst = skb_dst(skb); 118469cce1d1SDavid S. Miller struct neighbour *n2, *n1 = neigh; 11851da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 1186e049f288Sroy.qing.li@gmail.com 1187e049f288Sroy.qing.li@gmail.com rcu_read_lock(); 118813a43d94SDavid S. Miller 118913a43d94SDavid S. Miller /* Why not just use 'neigh' as-is? The problem is that 119013a43d94SDavid S. Miller * things such as shaper, eql, and sch_teql can end up 119113a43d94SDavid S. Miller * using alternative, different, neigh objects to output 119213a43d94SDavid S. Miller * the packet in the output path. So what we need to do 119313a43d94SDavid S. Miller * here is re-lookup the top-level neigh in the path so 119413a43d94SDavid S. Miller * we can reinject the packet there. 119513a43d94SDavid S. Miller */ 119613a43d94SDavid S. Miller n2 = NULL; 119713a43d94SDavid S. Miller if (dst) { 119813a43d94SDavid S. Miller n2 = dst_neigh_lookup_skb(dst, skb); 119913a43d94SDavid S. Miller if (n2) 120069cce1d1SDavid S. Miller n1 = n2; 120113a43d94SDavid S. Miller } 12028f40b161SDavid S. Miller n1->output(n1, skb); 120313a43d94SDavid S. Miller if (n2) 120413a43d94SDavid S. Miller neigh_release(n2); 1205e049f288Sroy.qing.li@gmail.com rcu_read_unlock(); 1206e049f288Sroy.qing.li@gmail.com 12071da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 12081da177e4SLinus Torvalds } 1209c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 12108b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 12111da177e4SLinus Torvalds } 12121da177e4SLinus Torvalds out: 12131da177e4SLinus Torvalds if (update_isrouter) { 12141da177e4SLinus Torvalds neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 12151da177e4SLinus Torvalds (neigh->flags | NTF_ROUTER) : 12161da177e4SLinus Torvalds (neigh->flags & ~NTF_ROUTER); 12171da177e4SLinus Torvalds } 12181da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 12198d71740cSTom Tucker 12208d71740cSTom Tucker if (notify) 1221d961db35SThomas Graf neigh_update_notify(neigh); 1222d961db35SThomas Graf 12231da177e4SLinus Torvalds return err; 12241da177e4SLinus Torvalds } 12250a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_update); 12261da177e4SLinus Torvalds 12277e980569SJiri Benc /* Update the neigh to listen temporarily for probe responses, even if it is 12287e980569SJiri Benc * in a NUD_FAILED state. The caller has to hold neigh->lock for writing. 12297e980569SJiri Benc */ 12307e980569SJiri Benc void __neigh_set_probe_once(struct neighbour *neigh) 12317e980569SJiri Benc { 12327e980569SJiri Benc neigh->updated = jiffies; 12337e980569SJiri Benc if (!(neigh->nud_state & NUD_FAILED)) 12347e980569SJiri Benc return; 12352176d5d4SDuan Jiong neigh->nud_state = NUD_INCOMPLETE; 12362176d5d4SDuan Jiong atomic_set(&neigh->probes, neigh_max_probes(neigh)); 12377e980569SJiri Benc neigh_add_timer(neigh, 12387e980569SJiri Benc jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME)); 12397e980569SJiri Benc } 12407e980569SJiri Benc EXPORT_SYMBOL(__neigh_set_probe_once); 12417e980569SJiri Benc 12421da177e4SLinus Torvalds struct neighbour *neigh_event_ns(struct neigh_table *tbl, 12431da177e4SLinus Torvalds u8 *lladdr, void *saddr, 12441da177e4SLinus Torvalds struct net_device *dev) 12451da177e4SLinus Torvalds { 12461da177e4SLinus Torvalds struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 12471da177e4SLinus Torvalds lladdr || !dev->addr_len); 12481da177e4SLinus Torvalds if (neigh) 12491da177e4SLinus Torvalds neigh_update(neigh, lladdr, NUD_STALE, 12501da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE); 12511da177e4SLinus Torvalds return neigh; 12521da177e4SLinus Torvalds } 12530a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_event_ns); 12541da177e4SLinus Torvalds 125534d101ddSEric Dumazet /* called with read_lock_bh(&n->lock); */ 1256bdf53c58SEric W. Biederman static void neigh_hh_init(struct neighbour *n) 12571da177e4SLinus Torvalds { 1258bdf53c58SEric W. Biederman struct net_device *dev = n->dev; 1259bdf53c58SEric W. Biederman __be16 prot = n->tbl->protocol; 1260f6b72b62SDavid S. Miller struct hh_cache *hh = &n->hh; 12610ed8ddf4SEric Dumazet 12620ed8ddf4SEric Dumazet write_lock_bh(&n->lock); 126334d101ddSEric Dumazet 1264f6b72b62SDavid S. Miller /* Only one thread can come in here and initialize the 1265f6b72b62SDavid S. Miller * hh_cache entry. 1266f6b72b62SDavid S. Miller */ 1267b23b5455SDavid S. Miller if (!hh->hh_len) 1268b23b5455SDavid S. Miller dev->header_ops->cache(n, hh, prot); 1269f6b72b62SDavid S. Miller 12700ed8ddf4SEric Dumazet write_unlock_bh(&n->lock); 12711da177e4SLinus Torvalds } 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds /* Slow and careful. */ 12741da177e4SLinus Torvalds 12758f40b161SDavid S. Miller int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb) 12761da177e4SLinus Torvalds { 12771da177e4SLinus Torvalds int rc = 0; 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds if (!neigh_event_send(neigh, skb)) { 12801da177e4SLinus Torvalds int err; 12811da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 12820ed8ddf4SEric Dumazet unsigned int seq; 128334d101ddSEric Dumazet 1284f6b72b62SDavid S. Miller if (dev->header_ops->cache && !neigh->hh.hh_len) 1285bdf53c58SEric W. Biederman neigh_hh_init(neigh); 128634d101ddSEric Dumazet 12870ed8ddf4SEric Dumazet do { 1288e1f16503Sramesh.nagappa@gmail.com __skb_pull(skb, skb_network_offset(skb)); 12890ed8ddf4SEric Dumazet seq = read_seqbegin(&neigh->ha_lock); 12900c4e8581SStephen Hemminger err = dev_hard_header(skb, dev, ntohs(skb->protocol), 12911da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 12920ed8ddf4SEric Dumazet } while (read_seqretry(&neigh->ha_lock, seq)); 129334d101ddSEric Dumazet 12941da177e4SLinus Torvalds if (err >= 0) 1295542d4d68SDavid S. Miller rc = dev_queue_xmit(skb); 12961da177e4SLinus Torvalds else 12971da177e4SLinus Torvalds goto out_kfree_skb; 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds out: 13001da177e4SLinus Torvalds return rc; 13011da177e4SLinus Torvalds out_kfree_skb: 13021da177e4SLinus Torvalds rc = -EINVAL; 13031da177e4SLinus Torvalds kfree_skb(skb); 13041da177e4SLinus Torvalds goto out; 13051da177e4SLinus Torvalds } 13060a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_resolve_output); 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds /* As fast as possible without hh cache */ 13091da177e4SLinus Torvalds 13108f40b161SDavid S. Miller int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb) 13111da177e4SLinus Torvalds { 13121da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 13130ed8ddf4SEric Dumazet unsigned int seq; 13148f40b161SDavid S. Miller int err; 13151da177e4SLinus Torvalds 13160ed8ddf4SEric Dumazet do { 1317e1f16503Sramesh.nagappa@gmail.com __skb_pull(skb, skb_network_offset(skb)); 13180ed8ddf4SEric Dumazet seq = read_seqbegin(&neigh->ha_lock); 13190c4e8581SStephen Hemminger err = dev_hard_header(skb, dev, ntohs(skb->protocol), 13201da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 13210ed8ddf4SEric Dumazet } while (read_seqretry(&neigh->ha_lock, seq)); 13220ed8ddf4SEric Dumazet 13231da177e4SLinus Torvalds if (err >= 0) 1324542d4d68SDavid S. Miller err = dev_queue_xmit(skb); 13251da177e4SLinus Torvalds else { 13261da177e4SLinus Torvalds err = -EINVAL; 13271da177e4SLinus Torvalds kfree_skb(skb); 13281da177e4SLinus Torvalds } 13291da177e4SLinus Torvalds return err; 13301da177e4SLinus Torvalds } 13310a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_connected_output); 13321da177e4SLinus Torvalds 13338f40b161SDavid S. Miller int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb) 13348f40b161SDavid S. Miller { 13358f40b161SDavid S. Miller return dev_queue_xmit(skb); 13368f40b161SDavid S. Miller } 13378f40b161SDavid S. Miller EXPORT_SYMBOL(neigh_direct_output); 13388f40b161SDavid S. Miller 13391da177e4SLinus Torvalds static void neigh_proxy_process(unsigned long arg) 13401da177e4SLinus Torvalds { 13411da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 13421da177e4SLinus Torvalds long sched_next = 0; 13431da177e4SLinus Torvalds unsigned long now = jiffies; 1344f72051b0SDavid S. Miller struct sk_buff *skb, *n; 13451da177e4SLinus Torvalds 13461da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 13471da177e4SLinus Torvalds 1348f72051b0SDavid S. Miller skb_queue_walk_safe(&tbl->proxy_queue, skb, n) { 1349f72051b0SDavid S. Miller long tdif = NEIGH_CB(skb)->sched_next - now; 13501da177e4SLinus Torvalds 13511da177e4SLinus Torvalds if (tdif <= 0) { 1352f72051b0SDavid S. Miller struct net_device *dev = skb->dev; 135320e6074eSEric Dumazet 1354f72051b0SDavid S. Miller __skb_unlink(skb, &tbl->proxy_queue); 135520e6074eSEric Dumazet if (tbl->proxy_redo && netif_running(dev)) { 135620e6074eSEric Dumazet rcu_read_lock(); 1357f72051b0SDavid S. Miller tbl->proxy_redo(skb); 135820e6074eSEric Dumazet rcu_read_unlock(); 135920e6074eSEric Dumazet } else { 1360f72051b0SDavid S. Miller kfree_skb(skb); 136120e6074eSEric Dumazet } 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds dev_put(dev); 13641da177e4SLinus Torvalds } else if (!sched_next || tdif < sched_next) 13651da177e4SLinus Torvalds sched_next = tdif; 13661da177e4SLinus Torvalds } 13671da177e4SLinus Torvalds del_timer(&tbl->proxy_timer); 13681da177e4SLinus Torvalds if (sched_next) 13691da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, jiffies + sched_next); 13701da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 13711da177e4SLinus Torvalds } 13721da177e4SLinus Torvalds 13731da177e4SLinus Torvalds void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 13741da177e4SLinus Torvalds struct sk_buff *skb) 13751da177e4SLinus Torvalds { 13761da177e4SLinus Torvalds unsigned long now = jiffies; 137763862b5bSAruna-Hewapathirane 137863862b5bSAruna-Hewapathirane unsigned long sched_next = now + (prandom_u32() % 13791f9248e5SJiri Pirko NEIGH_VAR(p, PROXY_DELAY)); 13801da177e4SLinus Torvalds 13811f9248e5SJiri Pirko if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) { 13821da177e4SLinus Torvalds kfree_skb(skb); 13831da177e4SLinus Torvalds return; 13841da177e4SLinus Torvalds } 1385a61bbcf2SPatrick McHardy 1386a61bbcf2SPatrick McHardy NEIGH_CB(skb)->sched_next = sched_next; 1387a61bbcf2SPatrick McHardy NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 13901da177e4SLinus Torvalds if (del_timer(&tbl->proxy_timer)) { 13911da177e4SLinus Torvalds if (time_before(tbl->proxy_timer.expires, sched_next)) 13921da177e4SLinus Torvalds sched_next = tbl->proxy_timer.expires; 13931da177e4SLinus Torvalds } 1394adf30907SEric Dumazet skb_dst_drop(skb); 13951da177e4SLinus Torvalds dev_hold(skb->dev); 13961da177e4SLinus Torvalds __skb_queue_tail(&tbl->proxy_queue, skb); 13971da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, sched_next); 13981da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 13991da177e4SLinus Torvalds } 14000a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(pneigh_enqueue); 14011da177e4SLinus Torvalds 140297fd5bc7STobias Klauser static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl, 1403426b5303SEric W. Biederman struct net *net, int ifindex) 1404426b5303SEric W. Biederman { 1405426b5303SEric W. Biederman struct neigh_parms *p; 1406426b5303SEric W. Biederman 140775fbfd33SNicolas Dichtel list_for_each_entry(p, &tbl->parms_list, list) { 1408878628fbSYOSHIFUJI Hideaki if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) || 1409170d6f99SGao feng (!p->dev && !ifindex && net_eq(net, &init_net))) 1410426b5303SEric W. Biederman return p; 1411426b5303SEric W. Biederman } 1412426b5303SEric W. Biederman 1413426b5303SEric W. Biederman return NULL; 1414426b5303SEric W. Biederman } 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 14171da177e4SLinus Torvalds struct neigh_table *tbl) 14181da177e4SLinus Torvalds { 1419cf89d6b2SGao feng struct neigh_parms *p; 142000829823SStephen Hemminger struct net *net = dev_net(dev); 142100829823SStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 14221da177e4SLinus Torvalds 1423cf89d6b2SGao feng p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL); 14241da177e4SLinus Torvalds if (p) { 14251da177e4SLinus Torvalds p->tbl = tbl; 14261da177e4SLinus Torvalds atomic_set(&p->refcnt, 1); 14271da177e4SLinus Torvalds p->reachable_time = 14281f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 1429c7fb64dbSThomas Graf dev_hold(dev); 1430c7fb64dbSThomas Graf p->dev = dev; 1431e42ea986SEric Dumazet write_pnet(&p->net, hold_net(net)); 14321da177e4SLinus Torvalds p->sysctl_table = NULL; 143363134803SVeaceslav Falico 143463134803SVeaceslav Falico if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) { 143563134803SVeaceslav Falico release_net(net); 143663134803SVeaceslav Falico dev_put(dev); 143763134803SVeaceslav Falico kfree(p); 143863134803SVeaceslav Falico return NULL; 143963134803SVeaceslav Falico } 144063134803SVeaceslav Falico 14411da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 144275fbfd33SNicolas Dichtel list_add(&p->list, &tbl->parms.list); 14431da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 14441d4c8c29SJiri Pirko 14451d4c8c29SJiri Pirko neigh_parms_data_state_cleanall(p); 14461da177e4SLinus Torvalds } 14471da177e4SLinus Torvalds return p; 14481da177e4SLinus Torvalds } 14490a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_parms_alloc); 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds static void neigh_rcu_free_parms(struct rcu_head *head) 14521da177e4SLinus Torvalds { 14531da177e4SLinus Torvalds struct neigh_parms *parms = 14541da177e4SLinus Torvalds container_of(head, struct neigh_parms, rcu_head); 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds neigh_parms_put(parms); 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 14601da177e4SLinus Torvalds { 14611da177e4SLinus Torvalds if (!parms || parms == &tbl->parms) 14621da177e4SLinus Torvalds return; 14631da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 146475fbfd33SNicolas Dichtel list_del(&parms->list); 14651da177e4SLinus Torvalds parms->dead = 1; 14661da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1467cecbb639SDavid S. Miller if (parms->dev) 1468cecbb639SDavid S. Miller dev_put(parms->dev); 14691da177e4SLinus Torvalds call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 14701da177e4SLinus Torvalds } 14710a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_parms_release); 14721da177e4SLinus Torvalds 147306f0511dSDenis V. Lunev static void neigh_parms_destroy(struct neigh_parms *parms) 14741da177e4SLinus Torvalds { 147557da52c1SYOSHIFUJI Hideaki release_net(neigh_parms_net(parms)); 14761da177e4SLinus Torvalds kfree(parms); 14771da177e4SLinus Torvalds } 14781da177e4SLinus Torvalds 1479c2ecba71SPavel Emelianov static struct lock_class_key neigh_table_proxy_queue_class; 1480c2ecba71SPavel Emelianov 1481d7480fd3SWANG Cong static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly; 1482d7480fd3SWANG Cong 1483d7480fd3SWANG Cong void neigh_table_init(int index, struct neigh_table *tbl) 14841da177e4SLinus Torvalds { 14851da177e4SLinus Torvalds unsigned long now = jiffies; 14861da177e4SLinus Torvalds unsigned long phsize; 14871da177e4SLinus Torvalds 148875fbfd33SNicolas Dichtel INIT_LIST_HEAD(&tbl->parms_list); 148975fbfd33SNicolas Dichtel list_add(&tbl->parms.list, &tbl->parms_list); 1490e42ea986SEric Dumazet write_pnet(&tbl->parms.net, &init_net); 14911da177e4SLinus Torvalds atomic_set(&tbl->parms.refcnt, 1); 14921da177e4SLinus Torvalds tbl->parms.reachable_time = 14931f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME)); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds tbl->stats = alloc_percpu(struct neigh_statistics); 14961da177e4SLinus Torvalds if (!tbl->stats) 14971da177e4SLinus Torvalds panic("cannot create neighbour cache statistics"); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 15009b739ba5SAlexey Dobriyan if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat, 15019b739ba5SAlexey Dobriyan &neigh_stat_seq_fops, tbl)) 15021da177e4SLinus Torvalds panic("cannot create neighbour proc dir entry"); 15031da177e4SLinus Torvalds #endif 15041da177e4SLinus Torvalds 1505cd089336SDavid S. Miller RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3)); 15061da177e4SLinus Torvalds 15071da177e4SLinus Torvalds phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 150877d04bd9SAndrew Morton tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 15091da177e4SLinus Torvalds 1510d6bf7817SEric Dumazet if (!tbl->nht || !tbl->phash_buckets) 15111da177e4SLinus Torvalds panic("cannot allocate neighbour cache hashes"); 15121da177e4SLinus Torvalds 151308433effSYOSHIFUJI Hideaki / 吉藤英明 if (!tbl->entry_size) 151408433effSYOSHIFUJI Hideaki / 吉藤英明 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) + 151508433effSYOSHIFUJI Hideaki / 吉藤英明 tbl->key_len, NEIGH_PRIV_ALIGN); 151608433effSYOSHIFUJI Hideaki / 吉藤英明 else 151708433effSYOSHIFUJI Hideaki / 吉藤英明 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN); 151808433effSYOSHIFUJI Hideaki / 吉藤英明 15191da177e4SLinus Torvalds rwlock_init(&tbl->lock); 1520203b42f7STejun Heo INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work); 1521f618002bSviresh kumar queue_delayed_work(system_power_efficient_wq, &tbl->gc_work, 1522f618002bSviresh kumar tbl->parms.reachable_time); 1523b24b8a24SPavel Emelyanov setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl); 1524c2ecba71SPavel Emelianov skb_queue_head_init_class(&tbl->proxy_queue, 1525c2ecba71SPavel Emelianov &neigh_table_proxy_queue_class); 15261da177e4SLinus Torvalds 15271da177e4SLinus Torvalds tbl->last_flush = now; 15281da177e4SLinus Torvalds tbl->last_rand = now + tbl->parms.reachable_time * 20; 1529bd89efc5SSimon Kelley 1530d7480fd3SWANG Cong neigh_tables[index] = tbl; 15311da177e4SLinus Torvalds } 15320a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_table_init); 15331da177e4SLinus Torvalds 1534d7480fd3SWANG Cong int neigh_table_clear(int index, struct neigh_table *tbl) 15351da177e4SLinus Torvalds { 1536d7480fd3SWANG Cong neigh_tables[index] = NULL; 15371da177e4SLinus Torvalds /* It is not clean... Fix it to unload IPv6 module safely */ 1538a5c30b34STejun Heo cancel_delayed_work_sync(&tbl->gc_work); 15391da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 15401da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 15411da177e4SLinus Torvalds neigh_ifdown(tbl, NULL); 15421da177e4SLinus Torvalds if (atomic_read(&tbl->entries)) 1543e005d193SJoe Perches pr_crit("neighbour leakage\n"); 15441da177e4SLinus Torvalds 15456193d2beSEric Dumazet call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu, 15466193d2beSEric Dumazet neigh_hash_free_rcu); 1547d6bf7817SEric Dumazet tbl->nht = NULL; 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds kfree(tbl->phash_buckets); 15501da177e4SLinus Torvalds tbl->phash_buckets = NULL; 15511da177e4SLinus Torvalds 15523f192b5cSAlexey Dobriyan remove_proc_entry(tbl->id, init_net.proc_net_stat); 15533f192b5cSAlexey Dobriyan 15543fcde74bSKirill Korotaev free_percpu(tbl->stats); 15553fcde74bSKirill Korotaev tbl->stats = NULL; 15563fcde74bSKirill Korotaev 15571da177e4SLinus Torvalds return 0; 15581da177e4SLinus Torvalds } 15590a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_table_clear); 15601da177e4SLinus Torvalds 1561d7480fd3SWANG Cong static struct neigh_table *neigh_find_table(int family) 1562d7480fd3SWANG Cong { 1563d7480fd3SWANG Cong struct neigh_table *tbl = NULL; 1564d7480fd3SWANG Cong 1565d7480fd3SWANG Cong switch (family) { 1566d7480fd3SWANG Cong case AF_INET: 1567d7480fd3SWANG Cong tbl = neigh_tables[NEIGH_ARP_TABLE]; 1568d7480fd3SWANG Cong break; 1569d7480fd3SWANG Cong case AF_INET6: 1570d7480fd3SWANG Cong tbl = neigh_tables[NEIGH_ND_TABLE]; 1571d7480fd3SWANG Cong break; 1572d7480fd3SWANG Cong case AF_DECnet: 1573d7480fd3SWANG Cong tbl = neigh_tables[NEIGH_DN_TABLE]; 1574d7480fd3SWANG Cong break; 1575d7480fd3SWANG Cong } 1576d7480fd3SWANG Cong 1577d7480fd3SWANG Cong return tbl; 1578d7480fd3SWANG Cong } 1579d7480fd3SWANG Cong 1580661d2967SThomas Graf static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh) 15811da177e4SLinus Torvalds { 15823b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1583a14a49d2SThomas Graf struct ndmsg *ndm; 1584a14a49d2SThomas Graf struct nlattr *dst_attr; 15851da177e4SLinus Torvalds struct neigh_table *tbl; 1586d7480fd3SWANG Cong struct neighbour *neigh; 15871da177e4SLinus Torvalds struct net_device *dev = NULL; 1588a14a49d2SThomas Graf int err = -EINVAL; 15891da177e4SLinus Torvalds 1590110b2499SEric Dumazet ASSERT_RTNL(); 1591a14a49d2SThomas Graf if (nlmsg_len(nlh) < sizeof(*ndm)) 15921da177e4SLinus Torvalds goto out; 15931da177e4SLinus Torvalds 1594a14a49d2SThomas Graf dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST); 1595a14a49d2SThomas Graf if (dst_attr == NULL) 1596a14a49d2SThomas Graf goto out; 1597a14a49d2SThomas Graf 1598a14a49d2SThomas Graf ndm = nlmsg_data(nlh); 1599a14a49d2SThomas Graf if (ndm->ndm_ifindex) { 1600110b2499SEric Dumazet dev = __dev_get_by_index(net, ndm->ndm_ifindex); 1601a14a49d2SThomas Graf if (dev == NULL) { 1602a14a49d2SThomas Graf err = -ENODEV; 1603a14a49d2SThomas Graf goto out; 1604a14a49d2SThomas Graf } 1605a14a49d2SThomas Graf } 1606a14a49d2SThomas Graf 1607d7480fd3SWANG Cong tbl = neigh_find_table(ndm->ndm_family); 1608d7480fd3SWANG Cong if (tbl == NULL) 1609d7480fd3SWANG Cong return -EAFNOSUPPORT; 16101da177e4SLinus Torvalds 1611a14a49d2SThomas Graf if (nla_len(dst_attr) < tbl->key_len) 1612110b2499SEric Dumazet goto out; 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 1615426b5303SEric W. Biederman err = pneigh_delete(tbl, net, nla_data(dst_attr), dev); 1616110b2499SEric Dumazet goto out; 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds 1619a14a49d2SThomas Graf if (dev == NULL) 1620110b2499SEric Dumazet goto out; 16211da177e4SLinus Torvalds 1622a14a49d2SThomas Graf neigh = neigh_lookup(tbl, nla_data(dst_attr), dev); 1623a14a49d2SThomas Graf if (neigh == NULL) { 1624a14a49d2SThomas Graf err = -ENOENT; 1625110b2499SEric Dumazet goto out; 1626a14a49d2SThomas Graf } 1627a14a49d2SThomas Graf 1628a14a49d2SThomas Graf err = neigh_update(neigh, NULL, NUD_FAILED, 16291da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE | 16301da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN); 1631a14a49d2SThomas Graf neigh_release(neigh); 1632a14a49d2SThomas Graf 16331da177e4SLinus Torvalds out: 16341da177e4SLinus Torvalds return err; 16351da177e4SLinus Torvalds } 16361da177e4SLinus Torvalds 1637661d2967SThomas Graf static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh) 16381da177e4SLinus Torvalds { 1639d7480fd3SWANG Cong int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE; 16403b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 16415208debdSThomas Graf struct ndmsg *ndm; 16425208debdSThomas Graf struct nlattr *tb[NDA_MAX+1]; 16431da177e4SLinus Torvalds struct neigh_table *tbl; 16441da177e4SLinus Torvalds struct net_device *dev = NULL; 1645d7480fd3SWANG Cong struct neighbour *neigh; 1646d7480fd3SWANG Cong void *dst, *lladdr; 16475208debdSThomas Graf int err; 16481da177e4SLinus Torvalds 1649110b2499SEric Dumazet ASSERT_RTNL(); 16505208debdSThomas Graf err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 16515208debdSThomas Graf if (err < 0) 16521da177e4SLinus Torvalds goto out; 16531da177e4SLinus Torvalds 16545208debdSThomas Graf err = -EINVAL; 16555208debdSThomas Graf if (tb[NDA_DST] == NULL) 16565208debdSThomas Graf goto out; 16575208debdSThomas Graf 16585208debdSThomas Graf ndm = nlmsg_data(nlh); 16595208debdSThomas Graf if (ndm->ndm_ifindex) { 1660110b2499SEric Dumazet dev = __dev_get_by_index(net, ndm->ndm_ifindex); 16615208debdSThomas Graf if (dev == NULL) { 16625208debdSThomas Graf err = -ENODEV; 16635208debdSThomas Graf goto out; 16645208debdSThomas Graf } 16655208debdSThomas Graf 16665208debdSThomas Graf if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) 1667110b2499SEric Dumazet goto out; 16685208debdSThomas Graf } 16695208debdSThomas Graf 1670d7480fd3SWANG Cong tbl = neigh_find_table(ndm->ndm_family); 1671d7480fd3SWANG Cong if (tbl == NULL) 1672d7480fd3SWANG Cong return -EAFNOSUPPORT; 16731da177e4SLinus Torvalds 16745208debdSThomas Graf if (nla_len(tb[NDA_DST]) < tbl->key_len) 1675110b2499SEric Dumazet goto out; 16765208debdSThomas Graf dst = nla_data(tb[NDA_DST]); 16775208debdSThomas Graf lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 168062dd9318SVille Nuorvala struct pneigh_entry *pn; 168162dd9318SVille Nuorvala 16825208debdSThomas Graf err = -ENOBUFS; 1683426b5303SEric W. Biederman pn = pneigh_lookup(tbl, net, dst, dev, 1); 168462dd9318SVille Nuorvala if (pn) { 168562dd9318SVille Nuorvala pn->flags = ndm->ndm_flags; 168662dd9318SVille Nuorvala err = 0; 168762dd9318SVille Nuorvala } 1688110b2499SEric Dumazet goto out; 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds 16915208debdSThomas Graf if (dev == NULL) 1692110b2499SEric Dumazet goto out; 16931da177e4SLinus Torvalds 16945208debdSThomas Graf neigh = neigh_lookup(tbl, dst, dev); 16955208debdSThomas Graf if (neigh == NULL) { 16965208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 16971da177e4SLinus Torvalds err = -ENOENT; 1698110b2499SEric Dumazet goto out; 16995208debdSThomas Graf } 17005208debdSThomas Graf 17015208debdSThomas Graf neigh = __neigh_lookup_errno(tbl, dst, dev); 17025208debdSThomas Graf if (IS_ERR(neigh)) { 17035208debdSThomas Graf err = PTR_ERR(neigh); 1704110b2499SEric Dumazet goto out; 17051da177e4SLinus Torvalds } 17065208debdSThomas Graf } else { 17075208debdSThomas Graf if (nlh->nlmsg_flags & NLM_F_EXCL) { 17085208debdSThomas Graf err = -EEXIST; 17095208debdSThomas Graf neigh_release(neigh); 1710110b2499SEric Dumazet goto out; 17111da177e4SLinus Torvalds } 17121da177e4SLinus Torvalds 17135208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) 17145208debdSThomas Graf flags &= ~NEIGH_UPDATE_F_OVERRIDE; 17155208debdSThomas Graf } 17161da177e4SLinus Torvalds 17170c5c2d30SEric Biederman if (ndm->ndm_flags & NTF_USE) { 17180c5c2d30SEric Biederman neigh_event_send(neigh, NULL); 17190c5c2d30SEric Biederman err = 0; 17200c5c2d30SEric Biederman } else 17215208debdSThomas Graf err = neigh_update(neigh, lladdr, ndm->ndm_state, flags); 17225208debdSThomas Graf neigh_release(neigh); 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds out: 17251da177e4SLinus Torvalds return err; 17261da177e4SLinus Torvalds } 17271da177e4SLinus Torvalds 1728c7fb64dbSThomas Graf static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1729c7fb64dbSThomas Graf { 1730ca860fb3SThomas Graf struct nlattr *nest; 1731e386c6ebSThomas Graf 1732ca860fb3SThomas Graf nest = nla_nest_start(skb, NDTA_PARMS); 1733ca860fb3SThomas Graf if (nest == NULL) 1734ca860fb3SThomas Graf return -ENOBUFS; 1735c7fb64dbSThomas Graf 17369a6308d7SDavid S. Miller if ((parms->dev && 17379a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) || 17389a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) || 17391f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_QUEUE_LENBYTES, 17401f9248e5SJiri Pirko NEIGH_VAR(parms, QUEUE_LEN_BYTES)) || 17418b5c171bSEric Dumazet /* approximative value for deprecated QUEUE_LEN (in packets) */ 17429a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_QUEUE_LEN, 17431f9248e5SJiri Pirko NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) || 17441f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) || 17451f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) || 17461f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_UCAST_PROBES, 17471f9248e5SJiri Pirko NEIGH_VAR(parms, UCAST_PROBES)) || 17481f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_MCAST_PROBES, 17491f9248e5SJiri Pirko NEIGH_VAR(parms, MCAST_PROBES)) || 17509a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) || 17519a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME, 17521f9248e5SJiri Pirko NEIGH_VAR(parms, BASE_REACHABLE_TIME)) || 17531f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_GC_STALETIME, 17541f9248e5SJiri Pirko NEIGH_VAR(parms, GC_STALETIME)) || 17559a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME, 17561f9248e5SJiri Pirko NEIGH_VAR(parms, DELAY_PROBE_TIME)) || 17571f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_RETRANS_TIME, 17581f9248e5SJiri Pirko NEIGH_VAR(parms, RETRANS_TIME)) || 17591f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_ANYCAST_DELAY, 17601f9248e5SJiri Pirko NEIGH_VAR(parms, ANYCAST_DELAY)) || 17611f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_PROXY_DELAY, 17621f9248e5SJiri Pirko NEIGH_VAR(parms, PROXY_DELAY)) || 17631f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_LOCKTIME, 17641f9248e5SJiri Pirko NEIGH_VAR(parms, LOCKTIME))) 17659a6308d7SDavid S. Miller goto nla_put_failure; 1766ca860fb3SThomas Graf return nla_nest_end(skb, nest); 1767c7fb64dbSThomas Graf 1768ca860fb3SThomas Graf nla_put_failure: 1769bc3ed28cSThomas Graf nla_nest_cancel(skb, nest); 1770bc3ed28cSThomas Graf return -EMSGSIZE; 1771c7fb64dbSThomas Graf } 1772c7fb64dbSThomas Graf 1773ca860fb3SThomas Graf static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl, 1774ca860fb3SThomas Graf u32 pid, u32 seq, int type, int flags) 1775c7fb64dbSThomas Graf { 1776c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1777c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1778c7fb64dbSThomas Graf 1779ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1780ca860fb3SThomas Graf if (nlh == NULL) 178126932566SPatrick McHardy return -EMSGSIZE; 1782c7fb64dbSThomas Graf 1783ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1784c7fb64dbSThomas Graf 1785c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1786c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 17879ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 17889ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1789c7fb64dbSThomas Graf 17909a6308d7SDavid S. Miller if (nla_put_string(skb, NDTA_NAME, tbl->id) || 17919a6308d7SDavid S. Miller nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) || 17929a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) || 17939a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) || 17949a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3)) 17959a6308d7SDavid S. Miller goto nla_put_failure; 1796c7fb64dbSThomas Graf { 1797c7fb64dbSThomas Graf unsigned long now = jiffies; 1798c7fb64dbSThomas Graf unsigned int flush_delta = now - tbl->last_flush; 1799c7fb64dbSThomas Graf unsigned int rand_delta = now - tbl->last_rand; 1800d6bf7817SEric Dumazet struct neigh_hash_table *nht; 1801c7fb64dbSThomas Graf struct ndt_config ndc = { 1802c7fb64dbSThomas Graf .ndtc_key_len = tbl->key_len, 1803c7fb64dbSThomas Graf .ndtc_entry_size = tbl->entry_size, 1804c7fb64dbSThomas Graf .ndtc_entries = atomic_read(&tbl->entries), 1805c7fb64dbSThomas Graf .ndtc_last_flush = jiffies_to_msecs(flush_delta), 1806c7fb64dbSThomas Graf .ndtc_last_rand = jiffies_to_msecs(rand_delta), 1807c7fb64dbSThomas Graf .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 1808c7fb64dbSThomas Graf }; 1809c7fb64dbSThomas Graf 1810d6bf7817SEric Dumazet rcu_read_lock_bh(); 1811d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 18122c2aba6cSDavid S. Miller ndc.ndtc_hash_rnd = nht->hash_rnd[0]; 1813cd089336SDavid S. Miller ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); 1814d6bf7817SEric Dumazet rcu_read_unlock_bh(); 1815d6bf7817SEric Dumazet 18169a6308d7SDavid S. Miller if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc)) 18179a6308d7SDavid S. Miller goto nla_put_failure; 1818c7fb64dbSThomas Graf } 1819c7fb64dbSThomas Graf 1820c7fb64dbSThomas Graf { 1821c7fb64dbSThomas Graf int cpu; 1822c7fb64dbSThomas Graf struct ndt_stats ndst; 1823c7fb64dbSThomas Graf 1824c7fb64dbSThomas Graf memset(&ndst, 0, sizeof(ndst)); 1825c7fb64dbSThomas Graf 18266f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) { 1827c7fb64dbSThomas Graf struct neigh_statistics *st; 1828c7fb64dbSThomas Graf 1829c7fb64dbSThomas Graf st = per_cpu_ptr(tbl->stats, cpu); 1830c7fb64dbSThomas Graf ndst.ndts_allocs += st->allocs; 1831c7fb64dbSThomas Graf ndst.ndts_destroys += st->destroys; 1832c7fb64dbSThomas Graf ndst.ndts_hash_grows += st->hash_grows; 1833c7fb64dbSThomas Graf ndst.ndts_res_failed += st->res_failed; 1834c7fb64dbSThomas Graf ndst.ndts_lookups += st->lookups; 1835c7fb64dbSThomas Graf ndst.ndts_hits += st->hits; 1836c7fb64dbSThomas Graf ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 1837c7fb64dbSThomas Graf ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 1838c7fb64dbSThomas Graf ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 1839c7fb64dbSThomas Graf ndst.ndts_forced_gc_runs += st->forced_gc_runs; 1840c7fb64dbSThomas Graf } 1841c7fb64dbSThomas Graf 18429a6308d7SDavid S. Miller if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst)) 18439a6308d7SDavid S. Miller goto nla_put_failure; 1844c7fb64dbSThomas Graf } 1845c7fb64dbSThomas Graf 1846c7fb64dbSThomas Graf BUG_ON(tbl->parms.dev); 1847c7fb64dbSThomas Graf if (neightbl_fill_parms(skb, &tbl->parms) < 0) 1848ca860fb3SThomas Graf goto nla_put_failure; 1849c7fb64dbSThomas Graf 1850c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1851053c095aSJohannes Berg nlmsg_end(skb, nlh); 1852053c095aSJohannes Berg return 0; 1853c7fb64dbSThomas Graf 1854ca860fb3SThomas Graf nla_put_failure: 1855c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 185626932566SPatrick McHardy nlmsg_cancel(skb, nlh); 185726932566SPatrick McHardy return -EMSGSIZE; 1858c7fb64dbSThomas Graf } 1859c7fb64dbSThomas Graf 1860ca860fb3SThomas Graf static int neightbl_fill_param_info(struct sk_buff *skb, 1861ca860fb3SThomas Graf struct neigh_table *tbl, 1862c7fb64dbSThomas Graf struct neigh_parms *parms, 1863ca860fb3SThomas Graf u32 pid, u32 seq, int type, 1864ca860fb3SThomas Graf unsigned int flags) 1865c7fb64dbSThomas Graf { 1866c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1867c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1868c7fb64dbSThomas Graf 1869ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1870ca860fb3SThomas Graf if (nlh == NULL) 187126932566SPatrick McHardy return -EMSGSIZE; 1872c7fb64dbSThomas Graf 1873ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1874c7fb64dbSThomas Graf 1875c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1876c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 18779ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 18789ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1879c7fb64dbSThomas Graf 1880ca860fb3SThomas Graf if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 || 1881ca860fb3SThomas Graf neightbl_fill_parms(skb, parms) < 0) 1882ca860fb3SThomas Graf goto errout; 1883c7fb64dbSThomas Graf 1884c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1885053c095aSJohannes Berg nlmsg_end(skb, nlh); 1886053c095aSJohannes Berg return 0; 1887ca860fb3SThomas Graf errout: 1888c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 188926932566SPatrick McHardy nlmsg_cancel(skb, nlh); 189026932566SPatrick McHardy return -EMSGSIZE; 1891c7fb64dbSThomas Graf } 1892c7fb64dbSThomas Graf 1893ef7c79edSPatrick McHardy static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = { 18946b3f8674SThomas Graf [NDTA_NAME] = { .type = NLA_STRING }, 18956b3f8674SThomas Graf [NDTA_THRESH1] = { .type = NLA_U32 }, 18966b3f8674SThomas Graf [NDTA_THRESH2] = { .type = NLA_U32 }, 18976b3f8674SThomas Graf [NDTA_THRESH3] = { .type = NLA_U32 }, 18986b3f8674SThomas Graf [NDTA_GC_INTERVAL] = { .type = NLA_U64 }, 18996b3f8674SThomas Graf [NDTA_PARMS] = { .type = NLA_NESTED }, 19006b3f8674SThomas Graf }; 19016b3f8674SThomas Graf 1902ef7c79edSPatrick McHardy static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = { 19036b3f8674SThomas Graf [NDTPA_IFINDEX] = { .type = NLA_U32 }, 19046b3f8674SThomas Graf [NDTPA_QUEUE_LEN] = { .type = NLA_U32 }, 19056b3f8674SThomas Graf [NDTPA_PROXY_QLEN] = { .type = NLA_U32 }, 19066b3f8674SThomas Graf [NDTPA_APP_PROBES] = { .type = NLA_U32 }, 19076b3f8674SThomas Graf [NDTPA_UCAST_PROBES] = { .type = NLA_U32 }, 19086b3f8674SThomas Graf [NDTPA_MCAST_PROBES] = { .type = NLA_U32 }, 19096b3f8674SThomas Graf [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 }, 19106b3f8674SThomas Graf [NDTPA_GC_STALETIME] = { .type = NLA_U64 }, 19116b3f8674SThomas Graf [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 }, 19126b3f8674SThomas Graf [NDTPA_RETRANS_TIME] = { .type = NLA_U64 }, 19136b3f8674SThomas Graf [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 }, 19146b3f8674SThomas Graf [NDTPA_PROXY_DELAY] = { .type = NLA_U64 }, 19156b3f8674SThomas Graf [NDTPA_LOCKTIME] = { .type = NLA_U64 }, 19166b3f8674SThomas Graf }; 19176b3f8674SThomas Graf 1918661d2967SThomas Graf static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh) 1919c7fb64dbSThomas Graf { 19203b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1921c7fb64dbSThomas Graf struct neigh_table *tbl; 19226b3f8674SThomas Graf struct ndtmsg *ndtmsg; 19236b3f8674SThomas Graf struct nlattr *tb[NDTA_MAX+1]; 1924d7480fd3SWANG Cong bool found = false; 1925d7480fd3SWANG Cong int err, tidx; 1926c7fb64dbSThomas Graf 19276b3f8674SThomas Graf err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX, 19286b3f8674SThomas Graf nl_neightbl_policy); 19296b3f8674SThomas Graf if (err < 0) 19306b3f8674SThomas Graf goto errout; 1931c7fb64dbSThomas Graf 19326b3f8674SThomas Graf if (tb[NDTA_NAME] == NULL) { 19336b3f8674SThomas Graf err = -EINVAL; 19346b3f8674SThomas Graf goto errout; 19356b3f8674SThomas Graf } 19366b3f8674SThomas Graf 19376b3f8674SThomas Graf ndtmsg = nlmsg_data(nlh); 1938d7480fd3SWANG Cong 1939d7480fd3SWANG Cong for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) { 1940d7480fd3SWANG Cong tbl = neigh_tables[tidx]; 1941d7480fd3SWANG Cong if (!tbl) 1942d7480fd3SWANG Cong continue; 1943c7fb64dbSThomas Graf if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 1944c7fb64dbSThomas Graf continue; 1945d7480fd3SWANG Cong if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) { 1946d7480fd3SWANG Cong found = true; 1947c7fb64dbSThomas Graf break; 1948c7fb64dbSThomas Graf } 1949c7fb64dbSThomas Graf } 1950c7fb64dbSThomas Graf 1951d7480fd3SWANG Cong if (!found) 1952d7480fd3SWANG Cong return -ENOENT; 1953d7480fd3SWANG Cong 1954c7fb64dbSThomas Graf /* 1955c7fb64dbSThomas Graf * We acquire tbl->lock to be nice to the periodic timers and 1956c7fb64dbSThomas Graf * make sure they always see a consistent set of values. 1957c7fb64dbSThomas Graf */ 1958c7fb64dbSThomas Graf write_lock_bh(&tbl->lock); 1959c7fb64dbSThomas Graf 19606b3f8674SThomas Graf if (tb[NDTA_PARMS]) { 19616b3f8674SThomas Graf struct nlattr *tbp[NDTPA_MAX+1]; 1962c7fb64dbSThomas Graf struct neigh_parms *p; 19636b3f8674SThomas Graf int i, ifindex = 0; 1964c7fb64dbSThomas Graf 19656b3f8674SThomas Graf err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS], 19666b3f8674SThomas Graf nl_ntbl_parm_policy); 19676b3f8674SThomas Graf if (err < 0) 19686b3f8674SThomas Graf goto errout_tbl_lock; 1969c7fb64dbSThomas Graf 19706b3f8674SThomas Graf if (tbp[NDTPA_IFINDEX]) 19716b3f8674SThomas Graf ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]); 1972c7fb64dbSThomas Graf 197397fd5bc7STobias Klauser p = lookup_neigh_parms(tbl, net, ifindex); 1974c7fb64dbSThomas Graf if (p == NULL) { 1975c7fb64dbSThomas Graf err = -ENOENT; 19766b3f8674SThomas Graf goto errout_tbl_lock; 1977c7fb64dbSThomas Graf } 1978c7fb64dbSThomas Graf 19796b3f8674SThomas Graf for (i = 1; i <= NDTPA_MAX; i++) { 19806b3f8674SThomas Graf if (tbp[i] == NULL) 19816b3f8674SThomas Graf continue; 1982c7fb64dbSThomas Graf 19836b3f8674SThomas Graf switch (i) { 19846b3f8674SThomas Graf case NDTPA_QUEUE_LEN: 19851f9248e5SJiri Pirko NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 19861f9248e5SJiri Pirko nla_get_u32(tbp[i]) * 19871f9248e5SJiri Pirko SKB_TRUESIZE(ETH_FRAME_LEN)); 19888b5c171bSEric Dumazet break; 19898b5c171bSEric Dumazet case NDTPA_QUEUE_LENBYTES: 19901f9248e5SJiri Pirko NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 19911f9248e5SJiri Pirko nla_get_u32(tbp[i])); 19926b3f8674SThomas Graf break; 19936b3f8674SThomas Graf case NDTPA_PROXY_QLEN: 19941f9248e5SJiri Pirko NEIGH_VAR_SET(p, PROXY_QLEN, 19951f9248e5SJiri Pirko nla_get_u32(tbp[i])); 19966b3f8674SThomas Graf break; 19976b3f8674SThomas Graf case NDTPA_APP_PROBES: 19981f9248e5SJiri Pirko NEIGH_VAR_SET(p, APP_PROBES, 19991f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20006b3f8674SThomas Graf break; 20016b3f8674SThomas Graf case NDTPA_UCAST_PROBES: 20021f9248e5SJiri Pirko NEIGH_VAR_SET(p, UCAST_PROBES, 20031f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20046b3f8674SThomas Graf break; 20056b3f8674SThomas Graf case NDTPA_MCAST_PROBES: 20061f9248e5SJiri Pirko NEIGH_VAR_SET(p, MCAST_PROBES, 20071f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20086b3f8674SThomas Graf break; 20096b3f8674SThomas Graf case NDTPA_BASE_REACHABLE_TIME: 20101f9248e5SJiri Pirko NEIGH_VAR_SET(p, BASE_REACHABLE_TIME, 20111f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20124bf6980dSJean-Francois Remy /* update reachable_time as well, otherwise, the change will 20134bf6980dSJean-Francois Remy * only be effective after the next time neigh_periodic_work 20144bf6980dSJean-Francois Remy * decides to recompute it (can be multiple minutes) 20154bf6980dSJean-Francois Remy */ 20164bf6980dSJean-Francois Remy p->reachable_time = 20174bf6980dSJean-Francois Remy neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 20186b3f8674SThomas Graf break; 20196b3f8674SThomas Graf case NDTPA_GC_STALETIME: 20201f9248e5SJiri Pirko NEIGH_VAR_SET(p, GC_STALETIME, 20211f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20226b3f8674SThomas Graf break; 20236b3f8674SThomas Graf case NDTPA_DELAY_PROBE_TIME: 20241f9248e5SJiri Pirko NEIGH_VAR_SET(p, DELAY_PROBE_TIME, 20251f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20266b3f8674SThomas Graf break; 20276b3f8674SThomas Graf case NDTPA_RETRANS_TIME: 20281f9248e5SJiri Pirko NEIGH_VAR_SET(p, RETRANS_TIME, 20291f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20306b3f8674SThomas Graf break; 20316b3f8674SThomas Graf case NDTPA_ANYCAST_DELAY: 20323977458cSJiri Pirko NEIGH_VAR_SET(p, ANYCAST_DELAY, 20333977458cSJiri Pirko nla_get_msecs(tbp[i])); 20346b3f8674SThomas Graf break; 20356b3f8674SThomas Graf case NDTPA_PROXY_DELAY: 20363977458cSJiri Pirko NEIGH_VAR_SET(p, PROXY_DELAY, 20373977458cSJiri Pirko nla_get_msecs(tbp[i])); 20386b3f8674SThomas Graf break; 20396b3f8674SThomas Graf case NDTPA_LOCKTIME: 20403977458cSJiri Pirko NEIGH_VAR_SET(p, LOCKTIME, 20413977458cSJiri Pirko nla_get_msecs(tbp[i])); 20426b3f8674SThomas Graf break; 2043c7fb64dbSThomas Graf } 20446b3f8674SThomas Graf } 20456b3f8674SThomas Graf } 20466b3f8674SThomas Graf 2047dc25c676SGao feng err = -ENOENT; 2048dc25c676SGao feng if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] || 2049dc25c676SGao feng tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) && 2050dc25c676SGao feng !net_eq(net, &init_net)) 2051dc25c676SGao feng goto errout_tbl_lock; 2052dc25c676SGao feng 20536b3f8674SThomas Graf if (tb[NDTA_THRESH1]) 20546b3f8674SThomas Graf tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 20556b3f8674SThomas Graf 20566b3f8674SThomas Graf if (tb[NDTA_THRESH2]) 20576b3f8674SThomas Graf tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 20586b3f8674SThomas Graf 20596b3f8674SThomas Graf if (tb[NDTA_THRESH3]) 20606b3f8674SThomas Graf tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 20616b3f8674SThomas Graf 20626b3f8674SThomas Graf if (tb[NDTA_GC_INTERVAL]) 20636b3f8674SThomas Graf tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]); 2064c7fb64dbSThomas Graf 2065c7fb64dbSThomas Graf err = 0; 2066c7fb64dbSThomas Graf 20676b3f8674SThomas Graf errout_tbl_lock: 2068c7fb64dbSThomas Graf write_unlock_bh(&tbl->lock); 20696b3f8674SThomas Graf errout: 2070c7fb64dbSThomas Graf return err; 2071c7fb64dbSThomas Graf } 2072c7fb64dbSThomas Graf 2073c8822a4eSThomas Graf static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 2074c7fb64dbSThomas Graf { 20753b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 2076ca860fb3SThomas Graf int family, tidx, nidx = 0; 2077ca860fb3SThomas Graf int tbl_skip = cb->args[0]; 2078ca860fb3SThomas Graf int neigh_skip = cb->args[1]; 2079c7fb64dbSThomas Graf struct neigh_table *tbl; 2080c7fb64dbSThomas Graf 2081ca860fb3SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 2082c7fb64dbSThomas Graf 2083d7480fd3SWANG Cong for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) { 2084c7fb64dbSThomas Graf struct neigh_parms *p; 2085c7fb64dbSThomas Graf 2086d7480fd3SWANG Cong tbl = neigh_tables[tidx]; 2087d7480fd3SWANG Cong if (!tbl) 2088d7480fd3SWANG Cong continue; 2089d7480fd3SWANG Cong 2090ca860fb3SThomas Graf if (tidx < tbl_skip || (family && tbl->family != family)) 2091c7fb64dbSThomas Graf continue; 2092c7fb64dbSThomas Graf 209315e47304SEric W. Biederman if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid, 2094ca860fb3SThomas Graf cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL, 20957b46a644SDavid S. Miller NLM_F_MULTI) < 0) 2096c7fb64dbSThomas Graf break; 2097c7fb64dbSThomas Graf 209875fbfd33SNicolas Dichtel nidx = 0; 209975fbfd33SNicolas Dichtel p = list_next_entry(&tbl->parms, list); 210075fbfd33SNicolas Dichtel list_for_each_entry_from(p, &tbl->parms_list, list) { 2101878628fbSYOSHIFUJI Hideaki if (!net_eq(neigh_parms_net(p), net)) 2102426b5303SEric W. Biederman continue; 2103426b5303SEric W. Biederman 2104efc683fcSGautam Kachroo if (nidx < neigh_skip) 2105efc683fcSGautam Kachroo goto next; 2106c7fb64dbSThomas Graf 2107ca860fb3SThomas Graf if (neightbl_fill_param_info(skb, tbl, p, 210815e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 2109ca860fb3SThomas Graf cb->nlh->nlmsg_seq, 2110ca860fb3SThomas Graf RTM_NEWNEIGHTBL, 21117b46a644SDavid S. Miller NLM_F_MULTI) < 0) 2112c7fb64dbSThomas Graf goto out; 2113efc683fcSGautam Kachroo next: 2114efc683fcSGautam Kachroo nidx++; 2115c7fb64dbSThomas Graf } 2116c7fb64dbSThomas Graf 2117ca860fb3SThomas Graf neigh_skip = 0; 2118c7fb64dbSThomas Graf } 2119c7fb64dbSThomas Graf out: 2120ca860fb3SThomas Graf cb->args[0] = tidx; 2121ca860fb3SThomas Graf cb->args[1] = nidx; 2122c7fb64dbSThomas Graf 2123c7fb64dbSThomas Graf return skb->len; 2124c7fb64dbSThomas Graf } 21251da177e4SLinus Torvalds 21268b8aec50SThomas Graf static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh, 21278b8aec50SThomas Graf u32 pid, u32 seq, int type, unsigned int flags) 21281da177e4SLinus Torvalds { 21291da177e4SLinus Torvalds unsigned long now = jiffies; 21301da177e4SLinus Torvalds struct nda_cacheinfo ci; 21318b8aec50SThomas Graf struct nlmsghdr *nlh; 21328b8aec50SThomas Graf struct ndmsg *ndm; 21331da177e4SLinus Torvalds 21348b8aec50SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 21358b8aec50SThomas Graf if (nlh == NULL) 213626932566SPatrick McHardy return -EMSGSIZE; 21378b8aec50SThomas Graf 21388b8aec50SThomas Graf ndm = nlmsg_data(nlh); 21398b8aec50SThomas Graf ndm->ndm_family = neigh->ops->family; 21409ef1d4c7SPatrick McHardy ndm->ndm_pad1 = 0; 21419ef1d4c7SPatrick McHardy ndm->ndm_pad2 = 0; 21428b8aec50SThomas Graf ndm->ndm_flags = neigh->flags; 21438b8aec50SThomas Graf ndm->ndm_type = neigh->type; 21448b8aec50SThomas Graf ndm->ndm_ifindex = neigh->dev->ifindex; 21451da177e4SLinus Torvalds 21469a6308d7SDavid S. Miller if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key)) 21479a6308d7SDavid S. Miller goto nla_put_failure; 21488b8aec50SThomas Graf 21498b8aec50SThomas Graf read_lock_bh(&neigh->lock); 21508b8aec50SThomas Graf ndm->ndm_state = neigh->nud_state; 21510ed8ddf4SEric Dumazet if (neigh->nud_state & NUD_VALID) { 21520ed8ddf4SEric Dumazet char haddr[MAX_ADDR_LEN]; 21530ed8ddf4SEric Dumazet 21540ed8ddf4SEric Dumazet neigh_ha_snapshot(haddr, neigh, neigh->dev); 21550ed8ddf4SEric Dumazet if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) { 21568b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 21578b8aec50SThomas Graf goto nla_put_failure; 21588b8aec50SThomas Graf } 21590ed8ddf4SEric Dumazet } 21608b8aec50SThomas Graf 2161b9f5f52cSStephen Hemminger ci.ndm_used = jiffies_to_clock_t(now - neigh->used); 2162b9f5f52cSStephen Hemminger ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed); 2163b9f5f52cSStephen Hemminger ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated); 21648b8aec50SThomas Graf ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1; 21658b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 21668b8aec50SThomas Graf 21679a6308d7SDavid S. Miller if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) || 21689a6308d7SDavid S. Miller nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci)) 21699a6308d7SDavid S. Miller goto nla_put_failure; 21708b8aec50SThomas Graf 2171053c095aSJohannes Berg nlmsg_end(skb, nlh); 2172053c095aSJohannes Berg return 0; 21738b8aec50SThomas Graf 21748b8aec50SThomas Graf nla_put_failure: 217526932566SPatrick McHardy nlmsg_cancel(skb, nlh); 217626932566SPatrick McHardy return -EMSGSIZE; 21771da177e4SLinus Torvalds } 21781da177e4SLinus Torvalds 217984920c14STony Zelenoff static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn, 218084920c14STony Zelenoff u32 pid, u32 seq, int type, unsigned int flags, 218184920c14STony Zelenoff struct neigh_table *tbl) 218284920c14STony Zelenoff { 218384920c14STony Zelenoff struct nlmsghdr *nlh; 218484920c14STony Zelenoff struct ndmsg *ndm; 218584920c14STony Zelenoff 218684920c14STony Zelenoff nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 218784920c14STony Zelenoff if (nlh == NULL) 218884920c14STony Zelenoff return -EMSGSIZE; 218984920c14STony Zelenoff 219084920c14STony Zelenoff ndm = nlmsg_data(nlh); 219184920c14STony Zelenoff ndm->ndm_family = tbl->family; 219284920c14STony Zelenoff ndm->ndm_pad1 = 0; 219384920c14STony Zelenoff ndm->ndm_pad2 = 0; 219484920c14STony Zelenoff ndm->ndm_flags = pn->flags | NTF_PROXY; 2195545469f7SJun Zhao ndm->ndm_type = RTN_UNICAST; 219684920c14STony Zelenoff ndm->ndm_ifindex = pn->dev->ifindex; 219784920c14STony Zelenoff ndm->ndm_state = NUD_NONE; 219884920c14STony Zelenoff 21999a6308d7SDavid S. Miller if (nla_put(skb, NDA_DST, tbl->key_len, pn->key)) 22009a6308d7SDavid S. Miller goto nla_put_failure; 220184920c14STony Zelenoff 2202053c095aSJohannes Berg nlmsg_end(skb, nlh); 2203053c095aSJohannes Berg return 0; 220484920c14STony Zelenoff 220584920c14STony Zelenoff nla_put_failure: 220684920c14STony Zelenoff nlmsg_cancel(skb, nlh); 220784920c14STony Zelenoff return -EMSGSIZE; 220884920c14STony Zelenoff } 220984920c14STony Zelenoff 2210d961db35SThomas Graf static void neigh_update_notify(struct neighbour *neigh) 2211d961db35SThomas Graf { 2212d961db35SThomas Graf call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 2213d961db35SThomas Graf __neigh_notify(neigh, RTM_NEWNEIGH, 0); 2214d961db35SThomas Graf } 22151da177e4SLinus Torvalds 22161da177e4SLinus Torvalds static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 22171da177e4SLinus Torvalds struct netlink_callback *cb) 22181da177e4SLinus Torvalds { 22193b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 22201da177e4SLinus Torvalds struct neighbour *n; 22211da177e4SLinus Torvalds int rc, h, s_h = cb->args[1]; 22221da177e4SLinus Torvalds int idx, s_idx = idx = cb->args[2]; 2223d6bf7817SEric Dumazet struct neigh_hash_table *nht; 22241da177e4SLinus Torvalds 2225d6bf7817SEric Dumazet rcu_read_lock_bh(); 2226d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 2227d6bf7817SEric Dumazet 22284bd6683bSEric Dumazet for (h = s_h; h < (1 << nht->hash_shift); h++) { 22291da177e4SLinus Torvalds if (h > s_h) 22301da177e4SLinus Torvalds s_idx = 0; 2231767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; 2232767e97e1SEric Dumazet n != NULL; 2233767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) { 223409ad9bc7SOctavian Purdila if (!net_eq(dev_net(n->dev), net)) 2235426b5303SEric W. Biederman continue; 2236efc683fcSGautam Kachroo if (idx < s_idx) 2237efc683fcSGautam Kachroo goto next; 223815e47304SEric W. Biederman if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 22391da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 2240b6544c0bSJamal Hadi Salim RTM_NEWNEIGH, 22417b46a644SDavid S. Miller NLM_F_MULTI) < 0) { 22421da177e4SLinus Torvalds rc = -1; 22431da177e4SLinus Torvalds goto out; 22441da177e4SLinus Torvalds } 2245efc683fcSGautam Kachroo next: 2246efc683fcSGautam Kachroo idx++; 22471da177e4SLinus Torvalds } 22481da177e4SLinus Torvalds } 22491da177e4SLinus Torvalds rc = skb->len; 22501da177e4SLinus Torvalds out: 2251d6bf7817SEric Dumazet rcu_read_unlock_bh(); 22521da177e4SLinus Torvalds cb->args[1] = h; 22531da177e4SLinus Torvalds cb->args[2] = idx; 22541da177e4SLinus Torvalds return rc; 22551da177e4SLinus Torvalds } 22561da177e4SLinus Torvalds 225784920c14STony Zelenoff static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 225884920c14STony Zelenoff struct netlink_callback *cb) 225984920c14STony Zelenoff { 226084920c14STony Zelenoff struct pneigh_entry *n; 226184920c14STony Zelenoff struct net *net = sock_net(skb->sk); 226284920c14STony Zelenoff int rc, h, s_h = cb->args[3]; 226384920c14STony Zelenoff int idx, s_idx = idx = cb->args[4]; 226484920c14STony Zelenoff 226584920c14STony Zelenoff read_lock_bh(&tbl->lock); 226684920c14STony Zelenoff 22674bd6683bSEric Dumazet for (h = s_h; h <= PNEIGH_HASHMASK; h++) { 226884920c14STony Zelenoff if (h > s_h) 226984920c14STony Zelenoff s_idx = 0; 227084920c14STony Zelenoff for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) { 227184920c14STony Zelenoff if (dev_net(n->dev) != net) 227284920c14STony Zelenoff continue; 227384920c14STony Zelenoff if (idx < s_idx) 227484920c14STony Zelenoff goto next; 227515e47304SEric W. Biederman if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 227684920c14STony Zelenoff cb->nlh->nlmsg_seq, 227784920c14STony Zelenoff RTM_NEWNEIGH, 22787b46a644SDavid S. Miller NLM_F_MULTI, tbl) < 0) { 227984920c14STony Zelenoff read_unlock_bh(&tbl->lock); 228084920c14STony Zelenoff rc = -1; 228184920c14STony Zelenoff goto out; 228284920c14STony Zelenoff } 228384920c14STony Zelenoff next: 228484920c14STony Zelenoff idx++; 228584920c14STony Zelenoff } 228684920c14STony Zelenoff } 228784920c14STony Zelenoff 228884920c14STony Zelenoff read_unlock_bh(&tbl->lock); 228984920c14STony Zelenoff rc = skb->len; 229084920c14STony Zelenoff out: 229184920c14STony Zelenoff cb->args[3] = h; 229284920c14STony Zelenoff cb->args[4] = idx; 229384920c14STony Zelenoff return rc; 229484920c14STony Zelenoff 229584920c14STony Zelenoff } 229684920c14STony Zelenoff 2297c8822a4eSThomas Graf static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 22981da177e4SLinus Torvalds { 22991da177e4SLinus Torvalds struct neigh_table *tbl; 23001da177e4SLinus Torvalds int t, family, s_t; 230184920c14STony Zelenoff int proxy = 0; 23024bd6683bSEric Dumazet int err; 23031da177e4SLinus Torvalds 23048b8aec50SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 230584920c14STony Zelenoff 230684920c14STony Zelenoff /* check for full ndmsg structure presence, family member is 230784920c14STony Zelenoff * the same for both structures 230884920c14STony Zelenoff */ 230984920c14STony Zelenoff if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) && 231084920c14STony Zelenoff ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY) 231184920c14STony Zelenoff proxy = 1; 231284920c14STony Zelenoff 23131da177e4SLinus Torvalds s_t = cb->args[0]; 23141da177e4SLinus Torvalds 2315d7480fd3SWANG Cong for (t = 0; t < NEIGH_NR_TABLES; t++) { 2316d7480fd3SWANG Cong tbl = neigh_tables[t]; 2317d7480fd3SWANG Cong 2318d7480fd3SWANG Cong if (!tbl) 2319d7480fd3SWANG Cong continue; 23201da177e4SLinus Torvalds if (t < s_t || (family && tbl->family != family)) 23211da177e4SLinus Torvalds continue; 23221da177e4SLinus Torvalds if (t > s_t) 23231da177e4SLinus Torvalds memset(&cb->args[1], 0, sizeof(cb->args) - 23241da177e4SLinus Torvalds sizeof(cb->args[0])); 232584920c14STony Zelenoff if (proxy) 232684920c14STony Zelenoff err = pneigh_dump_table(tbl, skb, cb); 232784920c14STony Zelenoff else 232884920c14STony Zelenoff err = neigh_dump_table(tbl, skb, cb); 23294bd6683bSEric Dumazet if (err < 0) 23304bd6683bSEric Dumazet break; 23311da177e4SLinus Torvalds } 23321da177e4SLinus Torvalds 23331da177e4SLinus Torvalds cb->args[0] = t; 23341da177e4SLinus Torvalds return skb->len; 23351da177e4SLinus Torvalds } 23361da177e4SLinus Torvalds 23371da177e4SLinus Torvalds void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 23381da177e4SLinus Torvalds { 23391da177e4SLinus Torvalds int chain; 2340d6bf7817SEric Dumazet struct neigh_hash_table *nht; 23411da177e4SLinus Torvalds 2342d6bf7817SEric Dumazet rcu_read_lock_bh(); 2343d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 2344d6bf7817SEric Dumazet 2345767e97e1SEric Dumazet read_lock(&tbl->lock); /* avoid resizes */ 2346cd089336SDavid S. Miller for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 23471da177e4SLinus Torvalds struct neighbour *n; 23481da177e4SLinus Torvalds 2349767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[chain]); 2350767e97e1SEric Dumazet n != NULL; 2351767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) 23521da177e4SLinus Torvalds cb(n, cookie); 23531da177e4SLinus Torvalds } 2354d6bf7817SEric Dumazet read_unlock(&tbl->lock); 2355d6bf7817SEric Dumazet rcu_read_unlock_bh(); 23561da177e4SLinus Torvalds } 23571da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_for_each); 23581da177e4SLinus Torvalds 23591da177e4SLinus Torvalds /* The tbl->lock must be held as a writer and BH disabled. */ 23601da177e4SLinus Torvalds void __neigh_for_each_release(struct neigh_table *tbl, 23611da177e4SLinus Torvalds int (*cb)(struct neighbour *)) 23621da177e4SLinus Torvalds { 23631da177e4SLinus Torvalds int chain; 2364d6bf7817SEric Dumazet struct neigh_hash_table *nht; 23651da177e4SLinus Torvalds 2366d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 2367d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 2368cd089336SDavid S. Miller for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 2369767e97e1SEric Dumazet struct neighbour *n; 2370767e97e1SEric Dumazet struct neighbour __rcu **np; 23711da177e4SLinus Torvalds 2372d6bf7817SEric Dumazet np = &nht->hash_buckets[chain]; 2373767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 2374767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 23751da177e4SLinus Torvalds int release; 23761da177e4SLinus Torvalds 23771da177e4SLinus Torvalds write_lock(&n->lock); 23781da177e4SLinus Torvalds release = cb(n); 23791da177e4SLinus Torvalds if (release) { 2380767e97e1SEric Dumazet rcu_assign_pointer(*np, 2381767e97e1SEric Dumazet rcu_dereference_protected(n->next, 2382767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 23831da177e4SLinus Torvalds n->dead = 1; 23841da177e4SLinus Torvalds } else 23851da177e4SLinus Torvalds np = &n->next; 23861da177e4SLinus Torvalds write_unlock(&n->lock); 23874f494554SThomas Graf if (release) 23884f494554SThomas Graf neigh_cleanup_and_release(n); 23891da177e4SLinus Torvalds } 23901da177e4SLinus Torvalds } 2391ecbb4169SAlexey Kuznetsov } 23921da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_for_each_release); 23931da177e4SLinus Torvalds 2394b79bda3dSEric W. Biederman int neigh_xmit(int index, struct net_device *dev, 23954fd3d7d9SEric W. Biederman const void *addr, struct sk_buff *skb) 23964fd3d7d9SEric W. Biederman { 2397b79bda3dSEric W. Biederman int err = -EAFNOSUPPORT; 2398b79bda3dSEric W. Biederman if (likely(index < NEIGH_NR_TABLES)) { 23994fd3d7d9SEric W. Biederman struct neigh_table *tbl; 24004fd3d7d9SEric W. Biederman struct neighbour *neigh; 24014fd3d7d9SEric W. Biederman 2402b79bda3dSEric W. Biederman tbl = neigh_tables[index]; 24034fd3d7d9SEric W. Biederman if (!tbl) 24044fd3d7d9SEric W. Biederman goto out; 24054fd3d7d9SEric W. Biederman neigh = __neigh_lookup_noref(tbl, addr, dev); 24064fd3d7d9SEric W. Biederman if (!neigh) 24074fd3d7d9SEric W. Biederman neigh = __neigh_create(tbl, addr, dev, false); 24084fd3d7d9SEric W. Biederman err = PTR_ERR(neigh); 24094fd3d7d9SEric W. Biederman if (IS_ERR(neigh)) 24104fd3d7d9SEric W. Biederman goto out_kfree_skb; 24114fd3d7d9SEric W. Biederman err = neigh->output(neigh, skb); 24124fd3d7d9SEric W. Biederman } 2413b79bda3dSEric W. Biederman else if (index == NEIGH_LINK_TABLE) { 2414b79bda3dSEric W. Biederman err = dev_hard_header(skb, dev, ntohs(skb->protocol), 2415b79bda3dSEric W. Biederman addr, NULL, skb->len); 2416b79bda3dSEric W. Biederman if (err < 0) 2417b79bda3dSEric W. Biederman goto out_kfree_skb; 2418b79bda3dSEric W. Biederman err = dev_queue_xmit(skb); 2419b79bda3dSEric W. Biederman } 24204fd3d7d9SEric W. Biederman out: 24214fd3d7d9SEric W. Biederman return err; 24224fd3d7d9SEric W. Biederman out_kfree_skb: 24234fd3d7d9SEric W. Biederman kfree_skb(skb); 24244fd3d7d9SEric W. Biederman goto out; 24254fd3d7d9SEric W. Biederman } 24264fd3d7d9SEric W. Biederman EXPORT_SYMBOL(neigh_xmit); 24274fd3d7d9SEric W. Biederman 24281da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 24291da177e4SLinus Torvalds 24301da177e4SLinus Torvalds static struct neighbour *neigh_get_first(struct seq_file *seq) 24311da177e4SLinus Torvalds { 24321da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 24331218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 2434d6bf7817SEric Dumazet struct neigh_hash_table *nht = state->nht; 24351da177e4SLinus Torvalds struct neighbour *n = NULL; 24361da177e4SLinus Torvalds int bucket = state->bucket; 24371da177e4SLinus Torvalds 24381da177e4SLinus Torvalds state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 2439cd089336SDavid S. Miller for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { 2440767e97e1SEric Dumazet n = rcu_dereference_bh(nht->hash_buckets[bucket]); 24411da177e4SLinus Torvalds 24421da177e4SLinus Torvalds while (n) { 2443878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(n->dev), net)) 2444426b5303SEric W. Biederman goto next; 24451da177e4SLinus Torvalds if (state->neigh_sub_iter) { 24461da177e4SLinus Torvalds loff_t fakep = 0; 24471da177e4SLinus Torvalds void *v; 24481da177e4SLinus Torvalds 24491da177e4SLinus Torvalds v = state->neigh_sub_iter(state, n, &fakep); 24501da177e4SLinus Torvalds if (!v) 24511da177e4SLinus Torvalds goto next; 24521da177e4SLinus Torvalds } 24531da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 24541da177e4SLinus Torvalds break; 24551da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 24561da177e4SLinus Torvalds break; 24571da177e4SLinus Torvalds next: 2458767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 24591da177e4SLinus Torvalds } 24601da177e4SLinus Torvalds 24611da177e4SLinus Torvalds if (n) 24621da177e4SLinus Torvalds break; 24631da177e4SLinus Torvalds } 24641da177e4SLinus Torvalds state->bucket = bucket; 24651da177e4SLinus Torvalds 24661da177e4SLinus Torvalds return n; 24671da177e4SLinus Torvalds } 24681da177e4SLinus Torvalds 24691da177e4SLinus Torvalds static struct neighbour *neigh_get_next(struct seq_file *seq, 24701da177e4SLinus Torvalds struct neighbour *n, 24711da177e4SLinus Torvalds loff_t *pos) 24721da177e4SLinus Torvalds { 24731da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 24741218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 2475d6bf7817SEric Dumazet struct neigh_hash_table *nht = state->nht; 24761da177e4SLinus Torvalds 24771da177e4SLinus Torvalds if (state->neigh_sub_iter) { 24781da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 24791da177e4SLinus Torvalds if (v) 24801da177e4SLinus Torvalds return n; 24811da177e4SLinus Torvalds } 2482767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 24831da177e4SLinus Torvalds 24841da177e4SLinus Torvalds while (1) { 24851da177e4SLinus Torvalds while (n) { 2486878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(n->dev), net)) 2487426b5303SEric W. Biederman goto next; 24881da177e4SLinus Torvalds if (state->neigh_sub_iter) { 24891da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 24901da177e4SLinus Torvalds if (v) 24911da177e4SLinus Torvalds return n; 24921da177e4SLinus Torvalds goto next; 24931da177e4SLinus Torvalds } 24941da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 24951da177e4SLinus Torvalds break; 24961da177e4SLinus Torvalds 24971da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 24981da177e4SLinus Torvalds break; 24991da177e4SLinus Torvalds next: 2500767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 25011da177e4SLinus Torvalds } 25021da177e4SLinus Torvalds 25031da177e4SLinus Torvalds if (n) 25041da177e4SLinus Torvalds break; 25051da177e4SLinus Torvalds 2506cd089336SDavid S. Miller if (++state->bucket >= (1 << nht->hash_shift)) 25071da177e4SLinus Torvalds break; 25081da177e4SLinus Torvalds 2509767e97e1SEric Dumazet n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); 25101da177e4SLinus Torvalds } 25111da177e4SLinus Torvalds 25121da177e4SLinus Torvalds if (n && pos) 25131da177e4SLinus Torvalds --(*pos); 25141da177e4SLinus Torvalds return n; 25151da177e4SLinus Torvalds } 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 25181da177e4SLinus Torvalds { 25191da177e4SLinus Torvalds struct neighbour *n = neigh_get_first(seq); 25201da177e4SLinus Torvalds 25211da177e4SLinus Torvalds if (n) { 2522745e2031SChris Larson --(*pos); 25231da177e4SLinus Torvalds while (*pos) { 25241da177e4SLinus Torvalds n = neigh_get_next(seq, n, pos); 25251da177e4SLinus Torvalds if (!n) 25261da177e4SLinus Torvalds break; 25271da177e4SLinus Torvalds } 25281da177e4SLinus Torvalds } 25291da177e4SLinus Torvalds return *pos ? NULL : n; 25301da177e4SLinus Torvalds } 25311da177e4SLinus Torvalds 25321da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 25331da177e4SLinus Torvalds { 25341da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 25351218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 25361da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 25371da177e4SLinus Torvalds struct pneigh_entry *pn = NULL; 25381da177e4SLinus Torvalds int bucket = state->bucket; 25391da177e4SLinus Torvalds 25401da177e4SLinus Torvalds state->flags |= NEIGH_SEQ_IS_PNEIGH; 25411da177e4SLinus Torvalds for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 25421da177e4SLinus Torvalds pn = tbl->phash_buckets[bucket]; 2543878628fbSYOSHIFUJI Hideaki while (pn && !net_eq(pneigh_net(pn), net)) 2544426b5303SEric W. Biederman pn = pn->next; 25451da177e4SLinus Torvalds if (pn) 25461da177e4SLinus Torvalds break; 25471da177e4SLinus Torvalds } 25481da177e4SLinus Torvalds state->bucket = bucket; 25491da177e4SLinus Torvalds 25501da177e4SLinus Torvalds return pn; 25511da177e4SLinus Torvalds } 25521da177e4SLinus Torvalds 25531da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 25541da177e4SLinus Torvalds struct pneigh_entry *pn, 25551da177e4SLinus Torvalds loff_t *pos) 25561da177e4SLinus Torvalds { 25571da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 25581218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 25591da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 25601da177e4SLinus Torvalds 2561df07a94cSJorge Boncompte [DTI2] do { 25621da177e4SLinus Torvalds pn = pn->next; 2563df07a94cSJorge Boncompte [DTI2] } while (pn && !net_eq(pneigh_net(pn), net)); 2564df07a94cSJorge Boncompte [DTI2] 25651da177e4SLinus Torvalds while (!pn) { 25661da177e4SLinus Torvalds if (++state->bucket > PNEIGH_HASHMASK) 25671da177e4SLinus Torvalds break; 25681da177e4SLinus Torvalds pn = tbl->phash_buckets[state->bucket]; 2569878628fbSYOSHIFUJI Hideaki while (pn && !net_eq(pneigh_net(pn), net)) 2570426b5303SEric W. Biederman pn = pn->next; 25711da177e4SLinus Torvalds if (pn) 25721da177e4SLinus Torvalds break; 25731da177e4SLinus Torvalds } 25741da177e4SLinus Torvalds 25751da177e4SLinus Torvalds if (pn && pos) 25761da177e4SLinus Torvalds --(*pos); 25771da177e4SLinus Torvalds 25781da177e4SLinus Torvalds return pn; 25791da177e4SLinus Torvalds } 25801da177e4SLinus Torvalds 25811da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 25821da177e4SLinus Torvalds { 25831da177e4SLinus Torvalds struct pneigh_entry *pn = pneigh_get_first(seq); 25841da177e4SLinus Torvalds 25851da177e4SLinus Torvalds if (pn) { 2586745e2031SChris Larson --(*pos); 25871da177e4SLinus Torvalds while (*pos) { 25881da177e4SLinus Torvalds pn = pneigh_get_next(seq, pn, pos); 25891da177e4SLinus Torvalds if (!pn) 25901da177e4SLinus Torvalds break; 25911da177e4SLinus Torvalds } 25921da177e4SLinus Torvalds } 25931da177e4SLinus Torvalds return *pos ? NULL : pn; 25941da177e4SLinus Torvalds } 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 25971da177e4SLinus Torvalds { 25981da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 25991da177e4SLinus Torvalds void *rc; 2600745e2031SChris Larson loff_t idxpos = *pos; 26011da177e4SLinus Torvalds 2602745e2031SChris Larson rc = neigh_get_idx(seq, &idxpos); 26031da177e4SLinus Torvalds if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2604745e2031SChris Larson rc = pneigh_get_idx(seq, &idxpos); 26051da177e4SLinus Torvalds 26061da177e4SLinus Torvalds return rc; 26071da177e4SLinus Torvalds } 26081da177e4SLinus Torvalds 26091da177e4SLinus Torvalds void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 2610d6bf7817SEric Dumazet __acquires(rcu_bh) 26111da177e4SLinus Torvalds { 26121da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 26131da177e4SLinus Torvalds 26141da177e4SLinus Torvalds state->tbl = tbl; 26151da177e4SLinus Torvalds state->bucket = 0; 26161da177e4SLinus Torvalds state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 26171da177e4SLinus Torvalds 2618d6bf7817SEric Dumazet rcu_read_lock_bh(); 2619d6bf7817SEric Dumazet state->nht = rcu_dereference_bh(tbl->nht); 2620767e97e1SEric Dumazet 2621745e2031SChris Larson return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; 26221da177e4SLinus Torvalds } 26231da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_start); 26241da177e4SLinus Torvalds 26251da177e4SLinus Torvalds void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 26261da177e4SLinus Torvalds { 26271da177e4SLinus Torvalds struct neigh_seq_state *state; 26281da177e4SLinus Torvalds void *rc; 26291da177e4SLinus Torvalds 26301da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 2631bff69732SChris Larson rc = neigh_get_first(seq); 26321da177e4SLinus Torvalds goto out; 26331da177e4SLinus Torvalds } 26341da177e4SLinus Torvalds 26351da177e4SLinus Torvalds state = seq->private; 26361da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 26371da177e4SLinus Torvalds rc = neigh_get_next(seq, v, NULL); 26381da177e4SLinus Torvalds if (rc) 26391da177e4SLinus Torvalds goto out; 26401da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 26411da177e4SLinus Torvalds rc = pneigh_get_first(seq); 26421da177e4SLinus Torvalds } else { 26431da177e4SLinus Torvalds BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 26441da177e4SLinus Torvalds rc = pneigh_get_next(seq, v, NULL); 26451da177e4SLinus Torvalds } 26461da177e4SLinus Torvalds out: 26471da177e4SLinus Torvalds ++(*pos); 26481da177e4SLinus Torvalds return rc; 26491da177e4SLinus Torvalds } 26501da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_next); 26511da177e4SLinus Torvalds 26521da177e4SLinus Torvalds void neigh_seq_stop(struct seq_file *seq, void *v) 2653d6bf7817SEric Dumazet __releases(rcu_bh) 26541da177e4SLinus Torvalds { 2655d6bf7817SEric Dumazet rcu_read_unlock_bh(); 26561da177e4SLinus Torvalds } 26571da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_stop); 26581da177e4SLinus Torvalds 26591da177e4SLinus Torvalds /* statistics via seq_file */ 26601da177e4SLinus Torvalds 26611da177e4SLinus Torvalds static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 26621da177e4SLinus Torvalds { 266381c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 26641da177e4SLinus Torvalds int cpu; 26651da177e4SLinus Torvalds 26661da177e4SLinus Torvalds if (*pos == 0) 26671da177e4SLinus Torvalds return SEQ_START_TOKEN; 26681da177e4SLinus Torvalds 26690f23174aSRusty Russell for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) { 26701da177e4SLinus Torvalds if (!cpu_possible(cpu)) 26711da177e4SLinus Torvalds continue; 26721da177e4SLinus Torvalds *pos = cpu+1; 26731da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 26741da177e4SLinus Torvalds } 26751da177e4SLinus Torvalds return NULL; 26761da177e4SLinus Torvalds } 26771da177e4SLinus Torvalds 26781da177e4SLinus Torvalds static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 26791da177e4SLinus Torvalds { 268081c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 26811da177e4SLinus Torvalds int cpu; 26821da177e4SLinus Torvalds 26830f23174aSRusty Russell for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) { 26841da177e4SLinus Torvalds if (!cpu_possible(cpu)) 26851da177e4SLinus Torvalds continue; 26861da177e4SLinus Torvalds *pos = cpu+1; 26871da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 26881da177e4SLinus Torvalds } 26891da177e4SLinus Torvalds return NULL; 26901da177e4SLinus Torvalds } 26911da177e4SLinus Torvalds 26921da177e4SLinus Torvalds static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 26931da177e4SLinus Torvalds { 26941da177e4SLinus Torvalds 26951da177e4SLinus Torvalds } 26961da177e4SLinus Torvalds 26971da177e4SLinus Torvalds static int neigh_stat_seq_show(struct seq_file *seq, void *v) 26981da177e4SLinus Torvalds { 269981c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 27001da177e4SLinus Torvalds struct neigh_statistics *st = v; 27011da177e4SLinus Torvalds 27021da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 27039a6d276eSNeil Horman seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards\n"); 27041da177e4SLinus Torvalds return 0; 27051da177e4SLinus Torvalds } 27061da177e4SLinus Torvalds 27071da177e4SLinus Torvalds seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 27089a6d276eSNeil Horman "%08lx %08lx %08lx %08lx %08lx\n", 27091da177e4SLinus Torvalds atomic_read(&tbl->entries), 27101da177e4SLinus Torvalds 27111da177e4SLinus Torvalds st->allocs, 27121da177e4SLinus Torvalds st->destroys, 27131da177e4SLinus Torvalds st->hash_grows, 27141da177e4SLinus Torvalds 27151da177e4SLinus Torvalds st->lookups, 27161da177e4SLinus Torvalds st->hits, 27171da177e4SLinus Torvalds 27181da177e4SLinus Torvalds st->res_failed, 27191da177e4SLinus Torvalds 27201da177e4SLinus Torvalds st->rcv_probes_mcast, 27211da177e4SLinus Torvalds st->rcv_probes_ucast, 27221da177e4SLinus Torvalds 27231da177e4SLinus Torvalds st->periodic_gc_runs, 27249a6d276eSNeil Horman st->forced_gc_runs, 27259a6d276eSNeil Horman st->unres_discards 27261da177e4SLinus Torvalds ); 27271da177e4SLinus Torvalds 27281da177e4SLinus Torvalds return 0; 27291da177e4SLinus Torvalds } 27301da177e4SLinus Torvalds 2731f690808eSStephen Hemminger static const struct seq_operations neigh_stat_seq_ops = { 27321da177e4SLinus Torvalds .start = neigh_stat_seq_start, 27331da177e4SLinus Torvalds .next = neigh_stat_seq_next, 27341da177e4SLinus Torvalds .stop = neigh_stat_seq_stop, 27351da177e4SLinus Torvalds .show = neigh_stat_seq_show, 27361da177e4SLinus Torvalds }; 27371da177e4SLinus Torvalds 27381da177e4SLinus Torvalds static int neigh_stat_seq_open(struct inode *inode, struct file *file) 27391da177e4SLinus Torvalds { 27401da177e4SLinus Torvalds int ret = seq_open(file, &neigh_stat_seq_ops); 27411da177e4SLinus Torvalds 27421da177e4SLinus Torvalds if (!ret) { 27431da177e4SLinus Torvalds struct seq_file *sf = file->private_data; 2744d9dda78bSAl Viro sf->private = PDE_DATA(inode); 27451da177e4SLinus Torvalds } 27461da177e4SLinus Torvalds return ret; 27471da177e4SLinus Torvalds }; 27481da177e4SLinus Torvalds 27499a32144eSArjan van de Ven static const struct file_operations neigh_stat_seq_fops = { 27501da177e4SLinus Torvalds .owner = THIS_MODULE, 27511da177e4SLinus Torvalds .open = neigh_stat_seq_open, 27521da177e4SLinus Torvalds .read = seq_read, 27531da177e4SLinus Torvalds .llseek = seq_lseek, 27541da177e4SLinus Torvalds .release = seq_release, 27551da177e4SLinus Torvalds }; 27561da177e4SLinus Torvalds 27571da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 27581da177e4SLinus Torvalds 2759339bf98fSThomas Graf static inline size_t neigh_nlmsg_size(void) 2760339bf98fSThomas Graf { 2761339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ndmsg)) 2762339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2763339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2764339bf98fSThomas Graf + nla_total_size(sizeof(struct nda_cacheinfo)) 2765339bf98fSThomas Graf + nla_total_size(4); /* NDA_PROBES */ 2766339bf98fSThomas Graf } 2767339bf98fSThomas Graf 2768b8673311SThomas Graf static void __neigh_notify(struct neighbour *n, int type, int flags) 27691da177e4SLinus Torvalds { 2770c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(n->dev); 27718b8aec50SThomas Graf struct sk_buff *skb; 2772b8673311SThomas Graf int err = -ENOBUFS; 27731da177e4SLinus Torvalds 2774339bf98fSThomas Graf skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 27758b8aec50SThomas Graf if (skb == NULL) 2776b8673311SThomas Graf goto errout; 27771da177e4SLinus Torvalds 2778b8673311SThomas Graf err = neigh_fill_info(skb, n, 0, 0, type, flags); 277926932566SPatrick McHardy if (err < 0) { 278026932566SPatrick McHardy /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */ 278126932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 278226932566SPatrick McHardy kfree_skb(skb); 278326932566SPatrick McHardy goto errout; 278426932566SPatrick McHardy } 27851ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 27861ce85fe4SPablo Neira Ayuso return; 2787b8673311SThomas Graf errout: 2788b8673311SThomas Graf if (err < 0) 2789426b5303SEric W. Biederman rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 2790b8673311SThomas Graf } 2791b8673311SThomas Graf 2792b8673311SThomas Graf void neigh_app_ns(struct neighbour *n) 2793b8673311SThomas Graf { 2794b8673311SThomas Graf __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST); 27958b8aec50SThomas Graf } 27960a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_app_ns); 27971da177e4SLinus Torvalds 27981da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2799b93196dcSCong Wang static int zero; 2800555445cdSFrancesco Fusco static int int_max = INT_MAX; 2801b93196dcSCong Wang static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN); 28021da177e4SLinus Torvalds 2803fe2c6338SJoe Perches static int proc_unres_qlen(struct ctl_table *ctl, int write, 2804fe2c6338SJoe Perches void __user *buffer, size_t *lenp, loff_t *ppos) 28058b5c171bSEric Dumazet { 28068b5c171bSEric Dumazet int size, ret; 2807fe2c6338SJoe Perches struct ctl_table tmp = *ctl; 28088b5c171bSEric Dumazet 2809ce46cc64SShan Wei tmp.extra1 = &zero; 2810ce46cc64SShan Wei tmp.extra2 = &unres_qlen_max; 28118b5c171bSEric Dumazet tmp.data = &size; 2812ce46cc64SShan Wei 2813ce46cc64SShan Wei size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN); 2814ce46cc64SShan Wei ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 2815ce46cc64SShan Wei 28168b5c171bSEric Dumazet if (write && !ret) 28178b5c171bSEric Dumazet *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN); 28188b5c171bSEric Dumazet return ret; 28198b5c171bSEric Dumazet } 28208b5c171bSEric Dumazet 28211d4c8c29SJiri Pirko static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev, 28221d4c8c29SJiri Pirko int family) 28231d4c8c29SJiri Pirko { 2824bba24896SJiri Pirko switch (family) { 2825bba24896SJiri Pirko case AF_INET: 28261d4c8c29SJiri Pirko return __in_dev_arp_parms_get_rcu(dev); 2827bba24896SJiri Pirko case AF_INET6: 2828bba24896SJiri Pirko return __in6_dev_nd_parms_get_rcu(dev); 2829bba24896SJiri Pirko } 28301d4c8c29SJiri Pirko return NULL; 28311d4c8c29SJiri Pirko } 28321d4c8c29SJiri Pirko 28331d4c8c29SJiri Pirko static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p, 28341d4c8c29SJiri Pirko int index) 28351d4c8c29SJiri Pirko { 28361d4c8c29SJiri Pirko struct net_device *dev; 28371d4c8c29SJiri Pirko int family = neigh_parms_family(p); 28381d4c8c29SJiri Pirko 28391d4c8c29SJiri Pirko rcu_read_lock(); 28401d4c8c29SJiri Pirko for_each_netdev_rcu(net, dev) { 28411d4c8c29SJiri Pirko struct neigh_parms *dst_p = 28421d4c8c29SJiri Pirko neigh_get_dev_parms_rcu(dev, family); 28431d4c8c29SJiri Pirko 28441d4c8c29SJiri Pirko if (dst_p && !test_bit(index, dst_p->data_state)) 28451d4c8c29SJiri Pirko dst_p->data[index] = p->data[index]; 28461d4c8c29SJiri Pirko } 28471d4c8c29SJiri Pirko rcu_read_unlock(); 28481d4c8c29SJiri Pirko } 28491d4c8c29SJiri Pirko 28501d4c8c29SJiri Pirko static void neigh_proc_update(struct ctl_table *ctl, int write) 28511d4c8c29SJiri Pirko { 28521d4c8c29SJiri Pirko struct net_device *dev = ctl->extra1; 28531d4c8c29SJiri Pirko struct neigh_parms *p = ctl->extra2; 285477d47afbSJiri Pirko struct net *net = neigh_parms_net(p); 28551d4c8c29SJiri Pirko int index = (int *) ctl->data - p->data; 28561d4c8c29SJiri Pirko 28571d4c8c29SJiri Pirko if (!write) 28581d4c8c29SJiri Pirko return; 28591d4c8c29SJiri Pirko 28601d4c8c29SJiri Pirko set_bit(index, p->data_state); 28611d4c8c29SJiri Pirko if (!dev) /* NULL dev means this is default value */ 28621d4c8c29SJiri Pirko neigh_copy_dflt_parms(net, p, index); 28631d4c8c29SJiri Pirko } 28641d4c8c29SJiri Pirko 28651f9248e5SJiri Pirko static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write, 28661f9248e5SJiri Pirko void __user *buffer, 28671f9248e5SJiri Pirko size_t *lenp, loff_t *ppos) 28681f9248e5SJiri Pirko { 28691f9248e5SJiri Pirko struct ctl_table tmp = *ctl; 28701d4c8c29SJiri Pirko int ret; 28711f9248e5SJiri Pirko 28721f9248e5SJiri Pirko tmp.extra1 = &zero; 28731f9248e5SJiri Pirko tmp.extra2 = &int_max; 28741f9248e5SJiri Pirko 28751d4c8c29SJiri Pirko ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 28761d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 28771d4c8c29SJiri Pirko return ret; 28781f9248e5SJiri Pirko } 28791f9248e5SJiri Pirko 2880cb5b09c1SJiri Pirko int neigh_proc_dointvec(struct ctl_table *ctl, int write, 2881cb5b09c1SJiri Pirko void __user *buffer, size_t *lenp, loff_t *ppos) 2882cb5b09c1SJiri Pirko { 28831d4c8c29SJiri Pirko int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 28841d4c8c29SJiri Pirko 28851d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 28861d4c8c29SJiri Pirko return ret; 2887cb5b09c1SJiri Pirko } 2888cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec); 2889cb5b09c1SJiri Pirko 2890cb5b09c1SJiri Pirko int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, 2891cb5b09c1SJiri Pirko void __user *buffer, 2892cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2893cb5b09c1SJiri Pirko { 28941d4c8c29SJiri Pirko int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 28951d4c8c29SJiri Pirko 28961d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 28971d4c8c29SJiri Pirko return ret; 2898cb5b09c1SJiri Pirko } 2899cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec_jiffies); 2900cb5b09c1SJiri Pirko 2901cb5b09c1SJiri Pirko static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write, 2902cb5b09c1SJiri Pirko void __user *buffer, 2903cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2904cb5b09c1SJiri Pirko { 29051d4c8c29SJiri Pirko int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos); 29061d4c8c29SJiri Pirko 29071d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29081d4c8c29SJiri Pirko return ret; 2909cb5b09c1SJiri Pirko } 2910cb5b09c1SJiri Pirko 2911cb5b09c1SJiri Pirko int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, 2912cb5b09c1SJiri Pirko void __user *buffer, 2913cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2914cb5b09c1SJiri Pirko { 29151d4c8c29SJiri Pirko int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); 29161d4c8c29SJiri Pirko 29171d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29181d4c8c29SJiri Pirko return ret; 2919cb5b09c1SJiri Pirko } 2920cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies); 2921cb5b09c1SJiri Pirko 2922cb5b09c1SJiri Pirko static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write, 2923cb5b09c1SJiri Pirko void __user *buffer, 2924cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2925cb5b09c1SJiri Pirko { 29261d4c8c29SJiri Pirko int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos); 29271d4c8c29SJiri Pirko 29281d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29291d4c8c29SJiri Pirko return ret; 2930cb5b09c1SJiri Pirko } 2931cb5b09c1SJiri Pirko 29324bf6980dSJean-Francois Remy static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write, 29334bf6980dSJean-Francois Remy void __user *buffer, 29344bf6980dSJean-Francois Remy size_t *lenp, loff_t *ppos) 29354bf6980dSJean-Francois Remy { 29364bf6980dSJean-Francois Remy struct neigh_parms *p = ctl->extra2; 29374bf6980dSJean-Francois Remy int ret; 29384bf6980dSJean-Francois Remy 29394bf6980dSJean-Francois Remy if (strcmp(ctl->procname, "base_reachable_time") == 0) 29404bf6980dSJean-Francois Remy ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 29414bf6980dSJean-Francois Remy else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0) 29424bf6980dSJean-Francois Remy ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); 29434bf6980dSJean-Francois Remy else 29444bf6980dSJean-Francois Remy ret = -1; 29454bf6980dSJean-Francois Remy 29464bf6980dSJean-Francois Remy if (write && ret == 0) { 29474bf6980dSJean-Francois Remy /* update reachable_time as well, otherwise, the change will 29484bf6980dSJean-Francois Remy * only be effective after the next time neigh_periodic_work 29494bf6980dSJean-Francois Remy * decides to recompute it 29504bf6980dSJean-Francois Remy */ 29514bf6980dSJean-Francois Remy p->reachable_time = 29524bf6980dSJean-Francois Remy neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 29534bf6980dSJean-Francois Remy } 29544bf6980dSJean-Francois Remy return ret; 29554bf6980dSJean-Francois Remy } 29564bf6980dSJean-Francois Remy 29571f9248e5SJiri Pirko #define NEIGH_PARMS_DATA_OFFSET(index) \ 29581f9248e5SJiri Pirko (&((struct neigh_parms *) 0)->data[index]) 29591f9248e5SJiri Pirko 29601f9248e5SJiri Pirko #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \ 29611f9248e5SJiri Pirko [NEIGH_VAR_ ## attr] = { \ 29621f9248e5SJiri Pirko .procname = name, \ 29631f9248e5SJiri Pirko .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \ 29641f9248e5SJiri Pirko .maxlen = sizeof(int), \ 29651f9248e5SJiri Pirko .mode = mval, \ 29661f9248e5SJiri Pirko .proc_handler = proc, \ 29671f9248e5SJiri Pirko } 29681f9248e5SJiri Pirko 29691f9248e5SJiri Pirko #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \ 29701f9248e5SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax) 29711f9248e5SJiri Pirko 29721f9248e5SJiri Pirko #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \ 2973cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies) 29741f9248e5SJiri Pirko 29751f9248e5SJiri Pirko #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \ 2976cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies) 29771f9248e5SJiri Pirko 29781f9248e5SJiri Pirko #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \ 2979cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 29801f9248e5SJiri Pirko 29811f9248e5SJiri Pirko #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \ 2982cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 29831f9248e5SJiri Pirko 29841f9248e5SJiri Pirko #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \ 2985cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen) 298654716e3bSEric W. Biederman 29871da177e4SLinus Torvalds static struct neigh_sysctl_table { 29881da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 29898b5c171bSEric Dumazet struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1]; 2990ab32ea5dSBrian Haley } neigh_sysctl_template __read_mostly = { 29911da177e4SLinus Torvalds .neigh_vars = { 29921f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"), 29931f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"), 29941f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"), 29951f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"), 29961f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"), 29971f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"), 29981f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"), 29991f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"), 30001f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"), 30011f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"), 30021f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"), 30031f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"), 30041f9248e5SJiri Pirko NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"), 30051f9248e5SJiri Pirko NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"), 30061f9248e5SJiri Pirko NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"), 30078b5c171bSEric Dumazet [NEIGH_VAR_GC_INTERVAL] = { 30081da177e4SLinus Torvalds .procname = "gc_interval", 30091da177e4SLinus Torvalds .maxlen = sizeof(int), 30101da177e4SLinus Torvalds .mode = 0644, 30116d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 30121da177e4SLinus Torvalds }, 30138b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH1] = { 30141da177e4SLinus Torvalds .procname = "gc_thresh1", 30151da177e4SLinus Torvalds .maxlen = sizeof(int), 30161da177e4SLinus Torvalds .mode = 0644, 3017555445cdSFrancesco Fusco .extra1 = &zero, 3018555445cdSFrancesco Fusco .extra2 = &int_max, 3019555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30201da177e4SLinus Torvalds }, 30218b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH2] = { 30221da177e4SLinus Torvalds .procname = "gc_thresh2", 30231da177e4SLinus Torvalds .maxlen = sizeof(int), 30241da177e4SLinus Torvalds .mode = 0644, 3025555445cdSFrancesco Fusco .extra1 = &zero, 3026555445cdSFrancesco Fusco .extra2 = &int_max, 3027555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30281da177e4SLinus Torvalds }, 30298b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH3] = { 30301da177e4SLinus Torvalds .procname = "gc_thresh3", 30311da177e4SLinus Torvalds .maxlen = sizeof(int), 30321da177e4SLinus Torvalds .mode = 0644, 3033555445cdSFrancesco Fusco .extra1 = &zero, 3034555445cdSFrancesco Fusco .extra2 = &int_max, 3035555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30361da177e4SLinus Torvalds }, 3037c3bac5a7SPavel Emelyanov {}, 30381da177e4SLinus Torvalds }, 30391da177e4SLinus Torvalds }; 30401da177e4SLinus Torvalds 30411da177e4SLinus Torvalds int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 304273af614aSJiri Pirko proc_handler *handler) 30431da177e4SLinus Torvalds { 30441f9248e5SJiri Pirko int i; 30453c607bbbSPavel Emelyanov struct neigh_sysctl_table *t; 30461f9248e5SJiri Pirko const char *dev_name_source; 30478f40a1f9SEric W. Biederman char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ]; 304873af614aSJiri Pirko char *p_name; 30491da177e4SLinus Torvalds 30503c607bbbSPavel Emelyanov t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL); 30511da177e4SLinus Torvalds if (!t) 30523c607bbbSPavel Emelyanov goto err; 30533c607bbbSPavel Emelyanov 3054b194c1f1SJiri Pirko for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) { 30551f9248e5SJiri Pirko t->neigh_vars[i].data += (long) p; 3056cb5b09c1SJiri Pirko t->neigh_vars[i].extra1 = dev; 30571d4c8c29SJiri Pirko t->neigh_vars[i].extra2 = p; 3058cb5b09c1SJiri Pirko } 30591da177e4SLinus Torvalds 30601da177e4SLinus Torvalds if (dev) { 30611da177e4SLinus Torvalds dev_name_source = dev->name; 3062d12af679SEric W. Biederman /* Terminate the table early */ 30638b5c171bSEric Dumazet memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0, 30648b5c171bSEric Dumazet sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL])); 30651da177e4SLinus Torvalds } else { 30669ecf07a1SMathias Krause struct neigh_table *tbl = p->tbl; 30678f40a1f9SEric W. Biederman dev_name_source = "default"; 30689ecf07a1SMathias Krause t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval; 30699ecf07a1SMathias Krause t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1; 30709ecf07a1SMathias Krause t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2; 30719ecf07a1SMathias Krause t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3; 30721da177e4SLinus Torvalds } 30731da177e4SLinus Torvalds 3074f8572d8fSEric W. Biederman if (handler) { 30751da177e4SLinus Torvalds /* RetransTime */ 30768b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler; 30771da177e4SLinus Torvalds /* ReachableTime */ 30788b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler; 30791da177e4SLinus Torvalds /* RetransTime (in milliseconds)*/ 30808b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler; 30811da177e4SLinus Torvalds /* ReachableTime (in milliseconds) */ 30828b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler; 30834bf6980dSJean-Francois Remy } else { 30844bf6980dSJean-Francois Remy /* Those handlers will update p->reachable_time after 30854bf6980dSJean-Francois Remy * base_reachable_time(_ms) is set to ensure the new timer starts being 30864bf6980dSJean-Francois Remy * applied after the next neighbour update instead of waiting for 30874bf6980dSJean-Francois Remy * neigh_periodic_work to update its value (can be multiple minutes) 30884bf6980dSJean-Francois Remy * So any handler that replaces them should do this as well 30894bf6980dSJean-Francois Remy */ 30904bf6980dSJean-Francois Remy /* ReachableTime */ 30914bf6980dSJean-Francois Remy t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = 30924bf6980dSJean-Francois Remy neigh_proc_base_reachable_time; 30934bf6980dSJean-Francois Remy /* ReachableTime (in milliseconds) */ 30944bf6980dSJean-Francois Remy t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = 30954bf6980dSJean-Francois Remy neigh_proc_base_reachable_time; 30961da177e4SLinus Torvalds } 30971da177e4SLinus Torvalds 3098464dc801SEric W. Biederman /* Don't export sysctls to unprivileged users */ 3099464dc801SEric W. Biederman if (neigh_parms_net(p)->user_ns != &init_user_ns) 3100464dc801SEric W. Biederman t->neigh_vars[0].procname = NULL; 3101464dc801SEric W. Biederman 310273af614aSJiri Pirko switch (neigh_parms_family(p)) { 310373af614aSJiri Pirko case AF_INET: 310473af614aSJiri Pirko p_name = "ipv4"; 310573af614aSJiri Pirko break; 310673af614aSJiri Pirko case AF_INET6: 310773af614aSJiri Pirko p_name = "ipv6"; 310873af614aSJiri Pirko break; 310973af614aSJiri Pirko default: 311073af614aSJiri Pirko BUG(); 311173af614aSJiri Pirko } 311273af614aSJiri Pirko 31138f40a1f9SEric W. Biederman snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s", 31148f40a1f9SEric W. Biederman p_name, dev_name_source); 31154ab438fcSDenis V. Lunev t->sysctl_header = 31168f40a1f9SEric W. Biederman register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars); 31173c607bbbSPavel Emelyanov if (!t->sysctl_header) 31188f40a1f9SEric W. Biederman goto free; 31193c607bbbSPavel Emelyanov 31201da177e4SLinus Torvalds p->sysctl_table = t; 31211da177e4SLinus Torvalds return 0; 31221da177e4SLinus Torvalds 31231da177e4SLinus Torvalds free: 31241da177e4SLinus Torvalds kfree(t); 31253c607bbbSPavel Emelyanov err: 31263c607bbbSPavel Emelyanov return -ENOBUFS; 31271da177e4SLinus Torvalds } 31280a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_sysctl_register); 31291da177e4SLinus Torvalds 31301da177e4SLinus Torvalds void neigh_sysctl_unregister(struct neigh_parms *p) 31311da177e4SLinus Torvalds { 31321da177e4SLinus Torvalds if (p->sysctl_table) { 31331da177e4SLinus Torvalds struct neigh_sysctl_table *t = p->sysctl_table; 31341da177e4SLinus Torvalds p->sysctl_table = NULL; 31355dd3df10SEric W. Biederman unregister_net_sysctl_table(t->sysctl_header); 31361da177e4SLinus Torvalds kfree(t); 31371da177e4SLinus Torvalds } 31381da177e4SLinus Torvalds } 31390a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_sysctl_unregister); 31401da177e4SLinus Torvalds 31411da177e4SLinus Torvalds #endif /* CONFIG_SYSCTL */ 31421da177e4SLinus Torvalds 3143c8822a4eSThomas Graf static int __init neigh_init(void) 3144c8822a4eSThomas Graf { 3145c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL); 3146c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL); 3147c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL); 3148c8822a4eSThomas Graf 3149c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info, 3150c7ac8679SGreg Rose NULL); 3151c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL); 3152c8822a4eSThomas Graf 3153c8822a4eSThomas Graf return 0; 3154c8822a4eSThomas Graf } 3155c8822a4eSThomas Graf 3156c8822a4eSThomas Graf subsys_initcall(neigh_init); 3157c8822a4eSThomas Graf 3158