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 591da177e4SLinus Torvalds static struct neigh_table *neigh_tables; 6045fc3b11SAmos Waterland #ifdef CONFIG_PROC_FS 619a32144eSArjan van de Ven static const struct file_operations neigh_stat_seq_fops; 6245fc3b11SAmos Waterland #endif 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds /* 651da177e4SLinus Torvalds Neighbour hash table buckets are protected with rwlock tbl->lock. 661da177e4SLinus Torvalds 671da177e4SLinus Torvalds - All the scans/updates to hash buckets MUST be made under this lock. 681da177e4SLinus Torvalds - NOTHING clever should be made under this lock: no callbacks 691da177e4SLinus Torvalds to protocol backends, no attempts to send something to network. 701da177e4SLinus Torvalds It will result in deadlocks, if backend/driver wants to use neighbour 711da177e4SLinus Torvalds cache. 721da177e4SLinus Torvalds - If the entry requires some non-trivial actions, increase 731da177e4SLinus Torvalds its reference count and release table lock. 741da177e4SLinus Torvalds 751da177e4SLinus Torvalds Neighbour entries are protected: 761da177e4SLinus Torvalds - with reference count. 771da177e4SLinus Torvalds - with rwlock neigh->lock 781da177e4SLinus Torvalds 791da177e4SLinus Torvalds Reference count prevents destruction. 801da177e4SLinus Torvalds 811da177e4SLinus Torvalds neigh->lock mainly serializes ll address data and its validity state. 821da177e4SLinus Torvalds However, the same lock is used to protect another entry fields: 831da177e4SLinus Torvalds - timer 841da177e4SLinus Torvalds - resolution queue 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds Again, nothing clever shall be made under neigh->lock, 871da177e4SLinus Torvalds the most complicated procedure, which we allow is dev->hard_header. 881da177e4SLinus Torvalds It is supposed, that dev->hard_header is simplistic and does 891da177e4SLinus Torvalds not make callbacks to neighbour tables. 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds The last lock is neigh_tbl_lock. It is pure SMP lock, protecting 921da177e4SLinus Torvalds list of neighbour tables. This list is used only in process context, 931da177e4SLinus Torvalds */ 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds static DEFINE_RWLOCK(neigh_tbl_lock); 961da177e4SLinus Torvalds 978f40b161SDavid S. Miller static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb) 981da177e4SLinus Torvalds { 991da177e4SLinus Torvalds kfree_skb(skb); 1001da177e4SLinus Torvalds return -ENETDOWN; 1011da177e4SLinus Torvalds } 1021da177e4SLinus Torvalds 1034f494554SThomas Graf static void neigh_cleanup_and_release(struct neighbour *neigh) 1044f494554SThomas Graf { 1054f494554SThomas Graf if (neigh->parms->neigh_cleanup) 1064f494554SThomas Graf neigh->parms->neigh_cleanup(neigh); 1074f494554SThomas Graf 108d961db35SThomas Graf __neigh_notify(neigh, RTM_DELNEIGH, 0); 1094f494554SThomas Graf neigh_release(neigh); 1104f494554SThomas Graf } 1114f494554SThomas Graf 1121da177e4SLinus Torvalds /* 1131da177e4SLinus Torvalds * It is random distribution in the interval (1/2)*base...(3/2)*base. 1141da177e4SLinus Torvalds * It corresponds to default IPv6 settings and is not overridable, 1151da177e4SLinus Torvalds * because it is really reasonable choice. 1161da177e4SLinus Torvalds */ 1171da177e4SLinus Torvalds 1181da177e4SLinus Torvalds unsigned long neigh_rand_reach_time(unsigned long base) 1191da177e4SLinus Torvalds { 120a02cec21SEric Dumazet return base ? (net_random() % base) + (base >> 1) : 0; 1211da177e4SLinus Torvalds } 1220a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_rand_reach_time); 1231da177e4SLinus Torvalds 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds static int neigh_forced_gc(struct neigh_table *tbl) 1261da177e4SLinus Torvalds { 1271da177e4SLinus Torvalds int shrunk = 0; 1281da177e4SLinus Torvalds int i; 129d6bf7817SEric Dumazet struct neigh_hash_table *nht; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 134d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 135d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 136cd089336SDavid S. Miller for (i = 0; i < (1 << nht->hash_shift); i++) { 137767e97e1SEric Dumazet struct neighbour *n; 138767e97e1SEric Dumazet struct neighbour __rcu **np; 1391da177e4SLinus Torvalds 140d6bf7817SEric Dumazet np = &nht->hash_buckets[i]; 141767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 142767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 1431da177e4SLinus Torvalds /* Neighbour record may be discarded if: 1441da177e4SLinus Torvalds * - nobody refers to it. 1451da177e4SLinus Torvalds * - it is not permanent 1461da177e4SLinus Torvalds */ 1471da177e4SLinus Torvalds write_lock(&n->lock); 1481da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 1491da177e4SLinus Torvalds !(n->nud_state & NUD_PERMANENT)) { 150767e97e1SEric Dumazet rcu_assign_pointer(*np, 151767e97e1SEric Dumazet rcu_dereference_protected(n->next, 152767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 1531da177e4SLinus Torvalds n->dead = 1; 1541da177e4SLinus Torvalds shrunk = 1; 1551da177e4SLinus Torvalds write_unlock(&n->lock); 1564f494554SThomas Graf neigh_cleanup_and_release(n); 1571da177e4SLinus Torvalds continue; 1581da177e4SLinus Torvalds } 1591da177e4SLinus Torvalds write_unlock(&n->lock); 1601da177e4SLinus Torvalds np = &n->next; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds } 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds tbl->last_flush = jiffies; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1671da177e4SLinus Torvalds 1681da177e4SLinus Torvalds return shrunk; 1691da177e4SLinus Torvalds } 1701da177e4SLinus Torvalds 171a43d8994SPavel Emelyanov static void neigh_add_timer(struct neighbour *n, unsigned long when) 172a43d8994SPavel Emelyanov { 173a43d8994SPavel Emelyanov neigh_hold(n); 174a43d8994SPavel Emelyanov if (unlikely(mod_timer(&n->timer, when))) { 175a43d8994SPavel Emelyanov printk("NEIGH: BUG, double timer add, state is %x\n", 176a43d8994SPavel Emelyanov n->nud_state); 177a43d8994SPavel Emelyanov dump_stack(); 178a43d8994SPavel Emelyanov } 179a43d8994SPavel Emelyanov } 180a43d8994SPavel Emelyanov 1811da177e4SLinus Torvalds static int neigh_del_timer(struct neighbour *n) 1821da177e4SLinus Torvalds { 1831da177e4SLinus Torvalds if ((n->nud_state & NUD_IN_TIMER) && 1841da177e4SLinus Torvalds del_timer(&n->timer)) { 1851da177e4SLinus Torvalds neigh_release(n); 1861da177e4SLinus Torvalds return 1; 1871da177e4SLinus Torvalds } 1881da177e4SLinus Torvalds return 0; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds static void pneigh_queue_purge(struct sk_buff_head *list) 1921da177e4SLinus Torvalds { 1931da177e4SLinus Torvalds struct sk_buff *skb; 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds while ((skb = skb_dequeue(list)) != NULL) { 1961da177e4SLinus Torvalds dev_put(skb->dev); 1971da177e4SLinus Torvalds kfree_skb(skb); 1981da177e4SLinus Torvalds } 1991da177e4SLinus Torvalds } 2001da177e4SLinus Torvalds 20149636bb1SHerbert Xu static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev) 2021da177e4SLinus Torvalds { 2031da177e4SLinus Torvalds int i; 204d6bf7817SEric Dumazet struct neigh_hash_table *nht; 2051da177e4SLinus Torvalds 206d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 207d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 208d6bf7817SEric Dumazet 209cd089336SDavid S. Miller for (i = 0; i < (1 << nht->hash_shift); i++) { 210767e97e1SEric Dumazet struct neighbour *n; 211767e97e1SEric Dumazet struct neighbour __rcu **np = &nht->hash_buckets[i]; 2121da177e4SLinus Torvalds 213767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 214767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 2151da177e4SLinus Torvalds if (dev && n->dev != dev) { 2161da177e4SLinus Torvalds np = &n->next; 2171da177e4SLinus Torvalds continue; 2181da177e4SLinus Torvalds } 219767e97e1SEric Dumazet rcu_assign_pointer(*np, 220767e97e1SEric Dumazet rcu_dereference_protected(n->next, 221767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 2221da177e4SLinus Torvalds write_lock(&n->lock); 2231da177e4SLinus Torvalds neigh_del_timer(n); 2241da177e4SLinus Torvalds n->dead = 1; 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds if (atomic_read(&n->refcnt) != 1) { 2271da177e4SLinus Torvalds /* The most unpleasant situation. 2281da177e4SLinus Torvalds We must destroy neighbour entry, 2291da177e4SLinus Torvalds but someone still uses it. 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds The destroy will be delayed until 2321da177e4SLinus Torvalds the last user releases us, but 2331da177e4SLinus Torvalds we must kill timers etc. and move 2341da177e4SLinus Torvalds it to safe state. 2351da177e4SLinus Torvalds */ 236c9ab4d85SEric Dumazet __skb_queue_purge(&n->arp_queue); 2378b5c171bSEric Dumazet n->arp_queue_len_bytes = 0; 2381da177e4SLinus Torvalds n->output = neigh_blackhole; 2391da177e4SLinus Torvalds if (n->nud_state & NUD_VALID) 2401da177e4SLinus Torvalds n->nud_state = NUD_NOARP; 2411da177e4SLinus Torvalds else 2421da177e4SLinus Torvalds n->nud_state = NUD_NONE; 243d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is stray\n", n); 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds write_unlock(&n->lock); 2464f494554SThomas Graf neigh_cleanup_and_release(n); 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds } 24949636bb1SHerbert Xu } 2501da177e4SLinus Torvalds 25149636bb1SHerbert Xu void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 25249636bb1SHerbert Xu { 25349636bb1SHerbert Xu write_lock_bh(&tbl->lock); 25449636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 25549636bb1SHerbert Xu write_unlock_bh(&tbl->lock); 25649636bb1SHerbert Xu } 2570a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_changeaddr); 25849636bb1SHerbert Xu 25949636bb1SHerbert Xu int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 26049636bb1SHerbert Xu { 26149636bb1SHerbert Xu write_lock_bh(&tbl->lock); 26249636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 2631da177e4SLinus Torvalds pneigh_ifdown(tbl, dev); 2641da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 2671da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 2681da177e4SLinus Torvalds return 0; 2691da177e4SLinus Torvalds } 2700a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_ifdown); 2711da177e4SLinus Torvalds 272596b9b68SDavid Miller static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev) 2731da177e4SLinus Torvalds { 2741da177e4SLinus Torvalds struct neighbour *n = NULL; 2751da177e4SLinus Torvalds unsigned long now = jiffies; 2761da177e4SLinus Torvalds int entries; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds entries = atomic_inc_return(&tbl->entries) - 1; 2791da177e4SLinus Torvalds if (entries >= tbl->gc_thresh3 || 2801da177e4SLinus Torvalds (entries >= tbl->gc_thresh2 && 2811da177e4SLinus Torvalds time_after(now, tbl->last_flush + 5 * HZ))) { 2821da177e4SLinus Torvalds if (!neigh_forced_gc(tbl) && 2831da177e4SLinus Torvalds entries >= tbl->gc_thresh3) 2841da177e4SLinus Torvalds goto out_entries; 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 28708433effSYOSHIFUJI Hideaki / 吉藤英明 n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC); 2881da177e4SLinus Torvalds if (!n) 2891da177e4SLinus Torvalds goto out_entries; 2901da177e4SLinus Torvalds 291c9ab4d85SEric Dumazet __skb_queue_head_init(&n->arp_queue); 2921da177e4SLinus Torvalds rwlock_init(&n->lock); 2930ed8ddf4SEric Dumazet seqlock_init(&n->ha_lock); 2941da177e4SLinus Torvalds n->updated = n->used = now; 2951da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2961da177e4SLinus Torvalds n->output = neigh_blackhole; 297f6b72b62SDavid S. Miller seqlock_init(&n->hh.hh_lock); 2981da177e4SLinus Torvalds n->parms = neigh_parms_clone(&tbl->parms); 299b24b8a24SPavel Emelyanov setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n); 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, allocs); 3021da177e4SLinus Torvalds n->tbl = tbl; 3031da177e4SLinus Torvalds atomic_set(&n->refcnt, 1); 3041da177e4SLinus Torvalds n->dead = 1; 3051da177e4SLinus Torvalds out: 3061da177e4SLinus Torvalds return n; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds out_entries: 3091da177e4SLinus Torvalds atomic_dec(&tbl->entries); 3101da177e4SLinus Torvalds goto out; 3111da177e4SLinus Torvalds } 3121da177e4SLinus Torvalds 3132c2aba6cSDavid S. Miller static void neigh_get_hash_rnd(u32 *x) 3142c2aba6cSDavid S. Miller { 3152c2aba6cSDavid S. Miller get_random_bytes(x, sizeof(*x)); 3162c2aba6cSDavid S. Miller *x |= 1; 3172c2aba6cSDavid S. Miller } 3182c2aba6cSDavid S. Miller 319cd089336SDavid S. Miller static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift) 3201da177e4SLinus Torvalds { 321cd089336SDavid S. Miller size_t size = (1 << shift) * sizeof(struct neighbour *); 322d6bf7817SEric Dumazet struct neigh_hash_table *ret; 3236193d2beSEric Dumazet struct neighbour __rcu **buckets; 3242c2aba6cSDavid S. Miller int i; 3251da177e4SLinus Torvalds 326d6bf7817SEric Dumazet ret = kmalloc(sizeof(*ret), GFP_ATOMIC); 327d6bf7817SEric Dumazet if (!ret) 328d6bf7817SEric Dumazet return NULL; 329d6bf7817SEric Dumazet if (size <= PAGE_SIZE) 330d6bf7817SEric Dumazet buckets = kzalloc(size, GFP_ATOMIC); 331d6bf7817SEric Dumazet else 3326193d2beSEric Dumazet buckets = (struct neighbour __rcu **) 333d6bf7817SEric Dumazet __get_free_pages(GFP_ATOMIC | __GFP_ZERO, 334d6bf7817SEric Dumazet get_order(size)); 335d6bf7817SEric Dumazet if (!buckets) { 336d6bf7817SEric Dumazet kfree(ret); 337d6bf7817SEric Dumazet return NULL; 3381da177e4SLinus Torvalds } 3396193d2beSEric Dumazet ret->hash_buckets = buckets; 340cd089336SDavid S. Miller ret->hash_shift = shift; 3412c2aba6cSDavid S. Miller for (i = 0; i < NEIGH_NUM_HASH_RND; i++) 3422c2aba6cSDavid S. Miller neigh_get_hash_rnd(&ret->hash_rnd[i]); 3431da177e4SLinus Torvalds return ret; 3441da177e4SLinus Torvalds } 3451da177e4SLinus Torvalds 346d6bf7817SEric Dumazet static void neigh_hash_free_rcu(struct rcu_head *head) 3471da177e4SLinus Torvalds { 348d6bf7817SEric Dumazet struct neigh_hash_table *nht = container_of(head, 349d6bf7817SEric Dumazet struct neigh_hash_table, 350d6bf7817SEric Dumazet rcu); 351cd089336SDavid S. Miller size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *); 3526193d2beSEric Dumazet struct neighbour __rcu **buckets = nht->hash_buckets; 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds if (size <= PAGE_SIZE) 355d6bf7817SEric Dumazet kfree(buckets); 3561da177e4SLinus Torvalds else 357d6bf7817SEric Dumazet free_pages((unsigned long)buckets, get_order(size)); 358d6bf7817SEric Dumazet kfree(nht); 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 361d6bf7817SEric Dumazet static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl, 362cd089336SDavid S. Miller unsigned long new_shift) 3631da177e4SLinus Torvalds { 364d6bf7817SEric Dumazet unsigned int i, hash; 365d6bf7817SEric Dumazet struct neigh_hash_table *new_nht, *old_nht; 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hash_grows); 3681da177e4SLinus Torvalds 369d6bf7817SEric Dumazet old_nht = rcu_dereference_protected(tbl->nht, 370d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 371cd089336SDavid S. Miller new_nht = neigh_hash_alloc(new_shift); 372d6bf7817SEric Dumazet if (!new_nht) 373d6bf7817SEric Dumazet return old_nht; 3741da177e4SLinus Torvalds 375cd089336SDavid S. Miller for (i = 0; i < (1 << old_nht->hash_shift); i++) { 3761da177e4SLinus Torvalds struct neighbour *n, *next; 3771da177e4SLinus Torvalds 378767e97e1SEric Dumazet for (n = rcu_dereference_protected(old_nht->hash_buckets[i], 379767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 380d6bf7817SEric Dumazet n != NULL; 381d6bf7817SEric Dumazet n = next) { 382d6bf7817SEric Dumazet hash = tbl->hash(n->primary_key, n->dev, 383d6bf7817SEric Dumazet new_nht->hash_rnd); 3841da177e4SLinus Torvalds 385cd089336SDavid S. Miller hash >>= (32 - new_nht->hash_shift); 386767e97e1SEric Dumazet next = rcu_dereference_protected(n->next, 387767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 3881da177e4SLinus Torvalds 389767e97e1SEric Dumazet rcu_assign_pointer(n->next, 390767e97e1SEric Dumazet rcu_dereference_protected( 391767e97e1SEric Dumazet new_nht->hash_buckets[hash], 392767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 393767e97e1SEric Dumazet rcu_assign_pointer(new_nht->hash_buckets[hash], n); 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds } 3961da177e4SLinus Torvalds 397d6bf7817SEric Dumazet rcu_assign_pointer(tbl->nht, new_nht); 398d6bf7817SEric Dumazet call_rcu(&old_nht->rcu, neigh_hash_free_rcu); 399d6bf7817SEric Dumazet return new_nht; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 4031da177e4SLinus Torvalds struct net_device *dev) 4041da177e4SLinus Torvalds { 4051da177e4SLinus Torvalds struct neighbour *n; 4061da177e4SLinus Torvalds int key_len = tbl->key_len; 407bc4bf5f3SPavel Emelyanov u32 hash_val; 408d6bf7817SEric Dumazet struct neigh_hash_table *nht; 4091da177e4SLinus Torvalds 4101da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 4111da177e4SLinus Torvalds 412d6bf7817SEric Dumazet rcu_read_lock_bh(); 413d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 414cd089336SDavid S. Miller hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); 415767e97e1SEric Dumazet 416767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); 417767e97e1SEric Dumazet n != NULL; 418767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) { 4191da177e4SLinus Torvalds if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) { 420767e97e1SEric Dumazet if (!atomic_inc_not_zero(&n->refcnt)) 421767e97e1SEric Dumazet n = NULL; 4221da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 4231da177e4SLinus Torvalds break; 4241da177e4SLinus Torvalds } 4251da177e4SLinus Torvalds } 426767e97e1SEric Dumazet 427d6bf7817SEric Dumazet rcu_read_unlock_bh(); 4281da177e4SLinus Torvalds return n; 4291da177e4SLinus Torvalds } 4300a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_lookup); 4311da177e4SLinus Torvalds 432426b5303SEric W. Biederman struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net, 433426b5303SEric W. Biederman const void *pkey) 4341da177e4SLinus Torvalds { 4351da177e4SLinus Torvalds struct neighbour *n; 4361da177e4SLinus Torvalds int key_len = tbl->key_len; 437bc4bf5f3SPavel Emelyanov u32 hash_val; 438d6bf7817SEric Dumazet struct neigh_hash_table *nht; 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 4411da177e4SLinus Torvalds 442d6bf7817SEric Dumazet rcu_read_lock_bh(); 443d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 444cd089336SDavid S. Miller hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift); 445767e97e1SEric Dumazet 446767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]); 447767e97e1SEric Dumazet n != NULL; 448767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) { 449426b5303SEric W. Biederman if (!memcmp(n->primary_key, pkey, key_len) && 450878628fbSYOSHIFUJI Hideaki net_eq(dev_net(n->dev), net)) { 451767e97e1SEric Dumazet if (!atomic_inc_not_zero(&n->refcnt)) 452767e97e1SEric Dumazet n = NULL; 4531da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 4541da177e4SLinus Torvalds break; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds } 457767e97e1SEric Dumazet 458d6bf7817SEric Dumazet rcu_read_unlock_bh(); 4591da177e4SLinus Torvalds return n; 4601da177e4SLinus Torvalds } 4610a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_lookup_nodev); 4621da177e4SLinus Torvalds 463a263b309SDavid S. Miller struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey, 464a263b309SDavid S. Miller struct net_device *dev, bool want_ref) 4651da177e4SLinus Torvalds { 4661da177e4SLinus Torvalds u32 hash_val; 4671da177e4SLinus Torvalds int key_len = tbl->key_len; 4681da177e4SLinus Torvalds int error; 469596b9b68SDavid Miller struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev); 470d6bf7817SEric Dumazet struct neigh_hash_table *nht; 4711da177e4SLinus Torvalds 4721da177e4SLinus Torvalds if (!n) { 4731da177e4SLinus Torvalds rc = ERR_PTR(-ENOBUFS); 4741da177e4SLinus Torvalds goto out; 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds memcpy(n->primary_key, pkey, key_len); 4781da177e4SLinus Torvalds n->dev = dev; 4791da177e4SLinus Torvalds dev_hold(dev); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds /* Protocol specific setup. */ 4821da177e4SLinus Torvalds if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 4831da177e4SLinus Torvalds rc = ERR_PTR(error); 4841da177e4SLinus Torvalds goto out_neigh_release; 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds 487da6a8fa0SDavid Miller if (dev->netdev_ops->ndo_neigh_construct) { 488da6a8fa0SDavid Miller error = dev->netdev_ops->ndo_neigh_construct(n); 489da6a8fa0SDavid Miller if (error < 0) { 490da6a8fa0SDavid Miller rc = ERR_PTR(error); 491da6a8fa0SDavid Miller goto out_neigh_release; 492da6a8fa0SDavid Miller } 493da6a8fa0SDavid Miller } 494da6a8fa0SDavid Miller 495447f2191SDavid S. Miller /* Device specific setup. */ 496447f2191SDavid S. Miller if (n->parms->neigh_setup && 497447f2191SDavid S. Miller (error = n->parms->neigh_setup(n)) < 0) { 498447f2191SDavid S. Miller rc = ERR_PTR(error); 499447f2191SDavid S. Miller goto out_neigh_release; 500447f2191SDavid S. Miller } 501447f2191SDavid S. Miller 5021f9248e5SJiri Pirko n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1); 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 505d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 506d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 5071da177e4SLinus Torvalds 508cd089336SDavid S. Miller if (atomic_read(&tbl->entries) > (1 << nht->hash_shift)) 509cd089336SDavid S. Miller nht = neigh_hash_grow(tbl, nht->hash_shift + 1); 5101da177e4SLinus Torvalds 511cd089336SDavid S. Miller hash_val = tbl->hash(pkey, dev, nht->hash_rnd) >> (32 - nht->hash_shift); 5121da177e4SLinus Torvalds 5131da177e4SLinus Torvalds if (n->parms->dead) { 5141da177e4SLinus Torvalds rc = ERR_PTR(-EINVAL); 5151da177e4SLinus Torvalds goto out_tbl_unlock; 5161da177e4SLinus Torvalds } 5171da177e4SLinus Torvalds 518767e97e1SEric Dumazet for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val], 519767e97e1SEric Dumazet lockdep_is_held(&tbl->lock)); 520767e97e1SEric Dumazet n1 != NULL; 521767e97e1SEric Dumazet n1 = rcu_dereference_protected(n1->next, 522767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) { 5231da177e4SLinus Torvalds if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 524a263b309SDavid S. Miller if (want_ref) 5251da177e4SLinus Torvalds neigh_hold(n1); 5261da177e4SLinus Torvalds rc = n1; 5271da177e4SLinus Torvalds goto out_tbl_unlock; 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds n->dead = 0; 532a263b309SDavid S. Miller if (want_ref) 5331da177e4SLinus Torvalds neigh_hold(n); 534767e97e1SEric Dumazet rcu_assign_pointer(n->next, 535767e97e1SEric Dumazet rcu_dereference_protected(nht->hash_buckets[hash_val], 536767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 537767e97e1SEric Dumazet rcu_assign_pointer(nht->hash_buckets[hash_val], n); 5381da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 539d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is created\n", n); 5401da177e4SLinus Torvalds rc = n; 5411da177e4SLinus Torvalds out: 5421da177e4SLinus Torvalds return rc; 5431da177e4SLinus Torvalds out_tbl_unlock: 5441da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5451da177e4SLinus Torvalds out_neigh_release: 5461da177e4SLinus Torvalds neigh_release(n); 5471da177e4SLinus Torvalds goto out; 5481da177e4SLinus Torvalds } 549a263b309SDavid S. Miller EXPORT_SYMBOL(__neigh_create); 5501da177e4SLinus Torvalds 551be01d655SYOSHIFUJI Hideaki static u32 pneigh_hash(const void *pkey, int key_len) 552fa86d322SPavel Emelyanov { 553fa86d322SPavel Emelyanov u32 hash_val = *(u32 *)(pkey + key_len - 4); 554fa86d322SPavel Emelyanov hash_val ^= (hash_val >> 16); 555fa86d322SPavel Emelyanov hash_val ^= hash_val >> 8; 556fa86d322SPavel Emelyanov hash_val ^= hash_val >> 4; 557fa86d322SPavel Emelyanov hash_val &= PNEIGH_HASHMASK; 558be01d655SYOSHIFUJI Hideaki return hash_val; 559fa86d322SPavel Emelyanov } 560fa86d322SPavel Emelyanov 561be01d655SYOSHIFUJI Hideaki static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n, 562be01d655SYOSHIFUJI Hideaki struct net *net, 563be01d655SYOSHIFUJI Hideaki const void *pkey, 564be01d655SYOSHIFUJI Hideaki int key_len, 565be01d655SYOSHIFUJI Hideaki struct net_device *dev) 566be01d655SYOSHIFUJI Hideaki { 567be01d655SYOSHIFUJI Hideaki while (n) { 568be01d655SYOSHIFUJI Hideaki if (!memcmp(n->key, pkey, key_len) && 569be01d655SYOSHIFUJI Hideaki net_eq(pneigh_net(n), net) && 570be01d655SYOSHIFUJI Hideaki (n->dev == dev || !n->dev)) 571fa86d322SPavel Emelyanov return n; 572be01d655SYOSHIFUJI Hideaki n = n->next; 573be01d655SYOSHIFUJI Hideaki } 574be01d655SYOSHIFUJI Hideaki return NULL; 575be01d655SYOSHIFUJI Hideaki } 576be01d655SYOSHIFUJI Hideaki 577be01d655SYOSHIFUJI Hideaki struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl, 578be01d655SYOSHIFUJI Hideaki struct net *net, const void *pkey, struct net_device *dev) 579be01d655SYOSHIFUJI Hideaki { 580be01d655SYOSHIFUJI Hideaki int key_len = tbl->key_len; 581be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 582be01d655SYOSHIFUJI Hideaki 583be01d655SYOSHIFUJI Hideaki return __pneigh_lookup_1(tbl->phash_buckets[hash_val], 584be01d655SYOSHIFUJI Hideaki net, pkey, key_len, dev); 585fa86d322SPavel Emelyanov } 5860a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL_GPL(__pneigh_lookup); 587fa86d322SPavel Emelyanov 588426b5303SEric W. Biederman struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, 589426b5303SEric W. Biederman struct net *net, const void *pkey, 5901da177e4SLinus Torvalds struct net_device *dev, int creat) 5911da177e4SLinus Torvalds { 5921da177e4SLinus Torvalds struct pneigh_entry *n; 5931da177e4SLinus Torvalds int key_len = tbl->key_len; 594be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 597be01d655SYOSHIFUJI Hideaki n = __pneigh_lookup_1(tbl->phash_buckets[hash_val], 598be01d655SYOSHIFUJI Hideaki net, pkey, key_len, dev); 599be01d655SYOSHIFUJI Hideaki read_unlock_bh(&tbl->lock); 6001da177e4SLinus Torvalds 601be01d655SYOSHIFUJI Hideaki if (n || !creat) 6021da177e4SLinus Torvalds goto out; 6031da177e4SLinus Torvalds 6044ae28944SPavel Emelyanov ASSERT_RTNL(); 6054ae28944SPavel Emelyanov 6061da177e4SLinus Torvalds n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 6071da177e4SLinus Torvalds if (!n) 6081da177e4SLinus Torvalds goto out; 6091da177e4SLinus Torvalds 610e42ea986SEric Dumazet write_pnet(&n->net, hold_net(net)); 6111da177e4SLinus Torvalds memcpy(n->key, pkey, key_len); 6121da177e4SLinus Torvalds n->dev = dev; 6131da177e4SLinus Torvalds if (dev) 6141da177e4SLinus Torvalds dev_hold(dev); 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds if (tbl->pconstructor && tbl->pconstructor(n)) { 6171da177e4SLinus Torvalds if (dev) 6181da177e4SLinus Torvalds dev_put(dev); 619da12f735SDenis V. Lunev release_net(net); 6201da177e4SLinus Torvalds kfree(n); 6211da177e4SLinus Torvalds n = NULL; 6221da177e4SLinus Torvalds goto out; 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 6261da177e4SLinus Torvalds n->next = tbl->phash_buckets[hash_val]; 6271da177e4SLinus Torvalds tbl->phash_buckets[hash_val] = n; 6281da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6291da177e4SLinus Torvalds out: 6301da177e4SLinus Torvalds return n; 6311da177e4SLinus Torvalds } 6320a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(pneigh_lookup); 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds 635426b5303SEric W. Biederman int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey, 6361da177e4SLinus Torvalds struct net_device *dev) 6371da177e4SLinus Torvalds { 6381da177e4SLinus Torvalds struct pneigh_entry *n, **np; 6391da177e4SLinus Torvalds int key_len = tbl->key_len; 640be01d655SYOSHIFUJI Hideaki u32 hash_val = pneigh_hash(pkey, key_len); 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 6431da177e4SLinus Torvalds for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 6441da177e4SLinus Torvalds np = &n->next) { 645426b5303SEric W. Biederman if (!memcmp(n->key, pkey, key_len) && n->dev == dev && 646878628fbSYOSHIFUJI Hideaki net_eq(pneigh_net(n), net)) { 6471da177e4SLinus Torvalds *np = n->next; 6481da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6491da177e4SLinus Torvalds if (tbl->pdestructor) 6501da177e4SLinus Torvalds tbl->pdestructor(n); 6511da177e4SLinus Torvalds if (n->dev) 6521da177e4SLinus Torvalds dev_put(n->dev); 65357da52c1SYOSHIFUJI Hideaki release_net(pneigh_net(n)); 6541da177e4SLinus Torvalds kfree(n); 6551da177e4SLinus Torvalds return 0; 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 6591da177e4SLinus Torvalds return -ENOENT; 6601da177e4SLinus Torvalds } 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 6631da177e4SLinus Torvalds { 6641da177e4SLinus Torvalds struct pneigh_entry *n, **np; 6651da177e4SLinus Torvalds u32 h; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds for (h = 0; h <= PNEIGH_HASHMASK; h++) { 6681da177e4SLinus Torvalds np = &tbl->phash_buckets[h]; 6691da177e4SLinus Torvalds while ((n = *np) != NULL) { 6701da177e4SLinus Torvalds if (!dev || n->dev == dev) { 6711da177e4SLinus Torvalds *np = n->next; 6721da177e4SLinus Torvalds if (tbl->pdestructor) 6731da177e4SLinus Torvalds tbl->pdestructor(n); 6741da177e4SLinus Torvalds if (n->dev) 6751da177e4SLinus Torvalds dev_put(n->dev); 67657da52c1SYOSHIFUJI Hideaki release_net(pneigh_net(n)); 6771da177e4SLinus Torvalds kfree(n); 6781da177e4SLinus Torvalds continue; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds np = &n->next; 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds return -ENOENT; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds 68606f0511dSDenis V. Lunev static void neigh_parms_destroy(struct neigh_parms *parms); 68706f0511dSDenis V. Lunev 68806f0511dSDenis V. Lunev static inline void neigh_parms_put(struct neigh_parms *parms) 68906f0511dSDenis V. Lunev { 69006f0511dSDenis V. Lunev if (atomic_dec_and_test(&parms->refcnt)) 69106f0511dSDenis V. Lunev neigh_parms_destroy(parms); 69206f0511dSDenis V. Lunev } 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds /* 6951da177e4SLinus Torvalds * neighbour must already be out of the table; 6961da177e4SLinus Torvalds * 6971da177e4SLinus Torvalds */ 6981da177e4SLinus Torvalds void neigh_destroy(struct neighbour *neigh) 6991da177e4SLinus Torvalds { 700da6a8fa0SDavid Miller struct net_device *dev = neigh->dev; 701da6a8fa0SDavid Miller 7021da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 7031da177e4SLinus Torvalds 7041da177e4SLinus Torvalds if (!neigh->dead) { 705e005d193SJoe Perches pr_warn("Destroying alive neighbour %p\n", neigh); 7061da177e4SLinus Torvalds dump_stack(); 7071da177e4SLinus Torvalds return; 7081da177e4SLinus Torvalds } 7091da177e4SLinus Torvalds 7101da177e4SLinus Torvalds if (neigh_del_timer(neigh)) 711e005d193SJoe Perches pr_warn("Impossible event\n"); 7121da177e4SLinus Torvalds 713c9ab4d85SEric Dumazet write_lock_bh(&neigh->lock); 714c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 715c9ab4d85SEric Dumazet write_unlock_bh(&neigh->lock); 7168b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 7171da177e4SLinus Torvalds 718447f2191SDavid S. Miller if (dev->netdev_ops->ndo_neigh_destroy) 719447f2191SDavid S. Miller dev->netdev_ops->ndo_neigh_destroy(neigh); 720447f2191SDavid S. Miller 721da6a8fa0SDavid Miller dev_put(dev); 7221da177e4SLinus Torvalds neigh_parms_put(neigh->parms); 7231da177e4SLinus Torvalds 724d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is destroyed\n", neigh); 7251da177e4SLinus Torvalds 7261da177e4SLinus Torvalds atomic_dec(&neigh->tbl->entries); 7275b8b0060SDavid Miller kfree_rcu(neigh, rcu); 7281da177e4SLinus Torvalds } 7290a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_destroy); 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds /* Neighbour state is suspicious; 7321da177e4SLinus Torvalds disable fast path. 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds Called with write_locked neigh. 7351da177e4SLinus Torvalds */ 7361da177e4SLinus Torvalds static void neigh_suspect(struct neighbour *neigh) 7371da177e4SLinus Torvalds { 738d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is suspected\n", neigh); 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds neigh->output = neigh->ops->output; 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds /* Neighbour state is OK; 7441da177e4SLinus Torvalds enable fast path. 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds Called with write_locked neigh. 7471da177e4SLinus Torvalds */ 7481da177e4SLinus Torvalds static void neigh_connect(struct neighbour *neigh) 7491da177e4SLinus Torvalds { 750d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is connected\n", neigh); 7511da177e4SLinus Torvalds 7521da177e4SLinus Torvalds neigh->output = neigh->ops->connected_output; 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 755e4c4e448SEric Dumazet static void neigh_periodic_work(struct work_struct *work) 7561da177e4SLinus Torvalds { 757e4c4e448SEric Dumazet struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work); 758767e97e1SEric Dumazet struct neighbour *n; 759767e97e1SEric Dumazet struct neighbour __rcu **np; 760e4c4e448SEric Dumazet unsigned int i; 761d6bf7817SEric Dumazet struct neigh_hash_table *nht; 7621da177e4SLinus Torvalds 7631da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 7641da177e4SLinus Torvalds 765e4c4e448SEric Dumazet write_lock_bh(&tbl->lock); 766d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 767d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 7681da177e4SLinus Torvalds 7692724680bSYOSHIFUJI Hideaki / 吉藤英明 if (atomic_read(&tbl->entries) < tbl->gc_thresh1) 7702724680bSYOSHIFUJI Hideaki / 吉藤英明 goto out; 7712724680bSYOSHIFUJI Hideaki / 吉藤英明 7721da177e4SLinus Torvalds /* 7731da177e4SLinus Torvalds * periodically recompute ReachableTime from random function 7741da177e4SLinus Torvalds */ 7751da177e4SLinus Torvalds 776e4c4e448SEric Dumazet if (time_after(jiffies, tbl->last_rand + 300 * HZ)) { 7771da177e4SLinus Torvalds struct neigh_parms *p; 778e4c4e448SEric Dumazet tbl->last_rand = jiffies; 7791da177e4SLinus Torvalds for (p = &tbl->parms; p; p = p->next) 7801da177e4SLinus Torvalds p->reachable_time = 7811f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 784cd089336SDavid S. Miller for (i = 0 ; i < (1 << nht->hash_shift); i++) { 785d6bf7817SEric Dumazet np = &nht->hash_buckets[i]; 7861da177e4SLinus Torvalds 787767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 788767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 7891da177e4SLinus Torvalds unsigned int state; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds write_lock(&n->lock); 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds state = n->nud_state; 7941da177e4SLinus Torvalds if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 7951da177e4SLinus Torvalds write_unlock(&n->lock); 7961da177e4SLinus Torvalds goto next_elt; 7971da177e4SLinus Torvalds } 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds if (time_before(n->used, n->confirmed)) 8001da177e4SLinus Torvalds n->used = n->confirmed; 8011da177e4SLinus Torvalds 8021da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 8031da177e4SLinus Torvalds (state == NUD_FAILED || 8041f9248e5SJiri Pirko time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) { 8051da177e4SLinus Torvalds *np = n->next; 8061da177e4SLinus Torvalds n->dead = 1; 8071da177e4SLinus Torvalds write_unlock(&n->lock); 8084f494554SThomas Graf neigh_cleanup_and_release(n); 8091da177e4SLinus Torvalds continue; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds write_unlock(&n->lock); 8121da177e4SLinus Torvalds 8131da177e4SLinus Torvalds next_elt: 8141da177e4SLinus Torvalds np = &n->next; 8151da177e4SLinus Torvalds } 816e4c4e448SEric Dumazet /* 817e4c4e448SEric Dumazet * It's fine to release lock here, even if hash table 818e4c4e448SEric Dumazet * grows while we are preempted. 819e4c4e448SEric Dumazet */ 820e4c4e448SEric Dumazet write_unlock_bh(&tbl->lock); 821e4c4e448SEric Dumazet cond_resched(); 822e4c4e448SEric Dumazet write_lock_bh(&tbl->lock); 82384338a6cSMichel Machado nht = rcu_dereference_protected(tbl->nht, 82484338a6cSMichel Machado lockdep_is_held(&tbl->lock)); 825e4c4e448SEric Dumazet } 8262724680bSYOSHIFUJI Hideaki / 吉藤英明 out: 8271f9248e5SJiri Pirko /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks. 8281f9248e5SJiri Pirko * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2 8291f9248e5SJiri Pirko * BASE_REACHABLE_TIME. 8301da177e4SLinus Torvalds */ 831e4c4e448SEric Dumazet schedule_delayed_work(&tbl->gc_work, 8321f9248e5SJiri Pirko NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1); 833e4c4e448SEric Dumazet write_unlock_bh(&tbl->lock); 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds static __inline__ int neigh_max_probes(struct neighbour *n) 8371da177e4SLinus Torvalds { 8381da177e4SLinus Torvalds struct neigh_parms *p = n->parms; 839a02cec21SEric Dumazet return (n->nud_state & NUD_PROBE) ? 8401f9248e5SJiri Pirko NEIGH_VAR(p, UCAST_PROBES) : 8411f9248e5SJiri Pirko NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) + 8421f9248e5SJiri Pirko NEIGH_VAR(p, MCAST_PROBES); 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 8455ef12d98STimo Teras static void neigh_invalidate(struct neighbour *neigh) 8460a141509SEric Dumazet __releases(neigh->lock) 8470a141509SEric Dumazet __acquires(neigh->lock) 8485ef12d98STimo Teras { 8495ef12d98STimo Teras struct sk_buff *skb; 8505ef12d98STimo Teras 8515ef12d98STimo Teras NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 852d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is failed\n", neigh); 8535ef12d98STimo Teras neigh->updated = jiffies; 8545ef12d98STimo Teras 8555ef12d98STimo Teras /* It is very thin place. report_unreachable is very complicated 8565ef12d98STimo Teras routine. Particularly, it can hit the same neighbour entry! 8575ef12d98STimo Teras 8585ef12d98STimo Teras So that, we try to be accurate and avoid dead loop. --ANK 8595ef12d98STimo Teras */ 8605ef12d98STimo Teras while (neigh->nud_state == NUD_FAILED && 8615ef12d98STimo Teras (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 8625ef12d98STimo Teras write_unlock(&neigh->lock); 8635ef12d98STimo Teras neigh->ops->error_report(neigh, skb); 8645ef12d98STimo Teras write_lock(&neigh->lock); 8655ef12d98STimo Teras } 866c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 8678b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 8685ef12d98STimo Teras } 8695ef12d98STimo Teras 870cd28ca0aSEric Dumazet static void neigh_probe(struct neighbour *neigh) 871cd28ca0aSEric Dumazet __releases(neigh->lock) 872cd28ca0aSEric Dumazet { 8734ed377e3SHannes Frederic Sowa struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue); 874cd28ca0aSEric Dumazet /* keep skb alive even if arp_queue overflows */ 875cd28ca0aSEric Dumazet if (skb) 876cd28ca0aSEric Dumazet skb = skb_copy(skb, GFP_ATOMIC); 877cd28ca0aSEric Dumazet write_unlock(&neigh->lock); 878cd28ca0aSEric Dumazet neigh->ops->solicit(neigh, skb); 879cd28ca0aSEric Dumazet atomic_inc(&neigh->probes); 880cd28ca0aSEric Dumazet kfree_skb(skb); 881cd28ca0aSEric Dumazet } 882cd28ca0aSEric Dumazet 8831da177e4SLinus Torvalds /* Called when a timer expires for a neighbour entry. */ 8841da177e4SLinus Torvalds 8851da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg) 8861da177e4SLinus Torvalds { 8871da177e4SLinus Torvalds unsigned long now, next; 8881da177e4SLinus Torvalds struct neighbour *neigh = (struct neighbour *)arg; 88995c96174SEric Dumazet unsigned int state; 8901da177e4SLinus Torvalds int notify = 0; 8911da177e4SLinus Torvalds 8921da177e4SLinus Torvalds write_lock(&neigh->lock); 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds state = neigh->nud_state; 8951da177e4SLinus Torvalds now = jiffies; 8961da177e4SLinus Torvalds next = now + HZ; 8971da177e4SLinus Torvalds 898045f7b3bSDavid S. Miller if (!(state & NUD_IN_TIMER)) 8991da177e4SLinus Torvalds goto out; 9001da177e4SLinus Torvalds 9011da177e4SLinus Torvalds if (state & NUD_REACHABLE) { 9021da177e4SLinus Torvalds if (time_before_eq(now, 9031da177e4SLinus Torvalds neigh->confirmed + neigh->parms->reachable_time)) { 904d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is still alive\n", neigh); 9051da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 9061da177e4SLinus Torvalds } else if (time_before_eq(now, 9071f9248e5SJiri Pirko neigh->used + 9081f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 909d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is delayed\n", neigh); 9101da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 911955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9121da177e4SLinus Torvalds neigh_suspect(neigh); 9131f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME); 9141da177e4SLinus Torvalds } else { 915d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is suspected\n", neigh); 9161da177e4SLinus Torvalds neigh->nud_state = NUD_STALE; 917955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9181da177e4SLinus Torvalds neigh_suspect(neigh); 9198d71740cSTom Tucker notify = 1; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds } else if (state & NUD_DELAY) { 9221da177e4SLinus Torvalds if (time_before_eq(now, 9231f9248e5SJiri Pirko neigh->confirmed + 9241f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) { 925d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is now reachable\n", neigh); 9261da177e4SLinus Torvalds neigh->nud_state = NUD_REACHABLE; 927955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9281da177e4SLinus Torvalds neigh_connect(neigh); 9298d71740cSTom Tucker notify = 1; 9301da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 9311da177e4SLinus Torvalds } else { 932d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is probed\n", neigh); 9331da177e4SLinus Torvalds neigh->nud_state = NUD_PROBE; 934955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9351da177e4SLinus Torvalds atomic_set(&neigh->probes, 0); 9361f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 9371da177e4SLinus Torvalds } 9381da177e4SLinus Torvalds } else { 9391da177e4SLinus Torvalds /* NUD_PROBE|NUD_INCOMPLETE */ 9401f9248e5SJiri Pirko next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME); 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 9441da177e4SLinus Torvalds atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 9451da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 9461da177e4SLinus Torvalds notify = 1; 9475ef12d98STimo Teras neigh_invalidate(neigh); 9481da177e4SLinus Torvalds } 9491da177e4SLinus Torvalds 9501da177e4SLinus Torvalds if (neigh->nud_state & NUD_IN_TIMER) { 9511da177e4SLinus Torvalds if (time_before(next, jiffies + HZ/2)) 9521da177e4SLinus Torvalds next = jiffies + HZ/2; 9536fb9974fSHerbert Xu if (!mod_timer(&neigh->timer, next)) 9546fb9974fSHerbert Xu neigh_hold(neigh); 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 957cd28ca0aSEric Dumazet neigh_probe(neigh); 9589ff56607SDavid S. Miller } else { 9591da177e4SLinus Torvalds out: 9601da177e4SLinus Torvalds write_unlock(&neigh->lock); 9619ff56607SDavid S. Miller } 9621da177e4SLinus Torvalds 963d961db35SThomas Graf if (notify) 964d961db35SThomas Graf neigh_update_notify(neigh); 965d961db35SThomas Graf 9661da177e4SLinus Torvalds neigh_release(neigh); 9671da177e4SLinus Torvalds } 9681da177e4SLinus Torvalds 9691da177e4SLinus Torvalds int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 9701da177e4SLinus Torvalds { 9711da177e4SLinus Torvalds int rc; 972cd28ca0aSEric Dumazet bool immediate_probe = false; 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds rc = 0; 9771da177e4SLinus Torvalds if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 9781da177e4SLinus Torvalds goto out_unlock_bh; 9791da177e4SLinus Torvalds 9801da177e4SLinus Torvalds if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 9811f9248e5SJiri Pirko if (NEIGH_VAR(neigh->parms, MCAST_PROBES) + 9821f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, APP_PROBES)) { 983cd28ca0aSEric Dumazet unsigned long next, now = jiffies; 984cd28ca0aSEric Dumazet 9851f9248e5SJiri Pirko atomic_set(&neigh->probes, 9861f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, UCAST_PROBES)); 9871da177e4SLinus Torvalds neigh->nud_state = NUD_INCOMPLETE; 988cd28ca0aSEric Dumazet neigh->updated = now; 9891f9248e5SJiri Pirko next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME), 9901f9248e5SJiri Pirko HZ/2); 991cd28ca0aSEric Dumazet neigh_add_timer(neigh, next); 992cd28ca0aSEric Dumazet immediate_probe = true; 9931da177e4SLinus Torvalds } else { 9941da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 995955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 9961da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds kfree_skb(skb); 9991da177e4SLinus Torvalds return 1; 10001da177e4SLinus Torvalds } 10011da177e4SLinus Torvalds } else if (neigh->nud_state & NUD_STALE) { 1002d5d427cdSJoe Perches neigh_dbg(2, "neigh %p is delayed\n", neigh); 10031da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 1004955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 10051f9248e5SJiri Pirko neigh_add_timer(neigh, jiffies + 10061f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME)); 10071da177e4SLinus Torvalds } 10081da177e4SLinus Torvalds 10091da177e4SLinus Torvalds if (neigh->nud_state == NUD_INCOMPLETE) { 10101da177e4SLinus Torvalds if (skb) { 10118b5c171bSEric Dumazet while (neigh->arp_queue_len_bytes + skb->truesize > 10121f9248e5SJiri Pirko NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) { 10131da177e4SLinus Torvalds struct sk_buff *buff; 10148b5c171bSEric Dumazet 1015f72051b0SDavid S. Miller buff = __skb_dequeue(&neigh->arp_queue); 10168b5c171bSEric Dumazet if (!buff) 10178b5c171bSEric Dumazet break; 10188b5c171bSEric Dumazet neigh->arp_queue_len_bytes -= buff->truesize; 10191da177e4SLinus Torvalds kfree_skb(buff); 10209a6d276eSNeil Horman NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards); 10211da177e4SLinus Torvalds } 1022a4731138SEric Dumazet skb_dst_force(skb); 10231da177e4SLinus Torvalds __skb_queue_tail(&neigh->arp_queue, skb); 10248b5c171bSEric Dumazet neigh->arp_queue_len_bytes += skb->truesize; 10251da177e4SLinus Torvalds } 10261da177e4SLinus Torvalds rc = 1; 10271da177e4SLinus Torvalds } 10281da177e4SLinus Torvalds out_unlock_bh: 1029cd28ca0aSEric Dumazet if (immediate_probe) 1030cd28ca0aSEric Dumazet neigh_probe(neigh); 1031cd28ca0aSEric Dumazet else 1032cd28ca0aSEric Dumazet write_unlock(&neigh->lock); 1033cd28ca0aSEric Dumazet local_bh_enable(); 10341da177e4SLinus Torvalds return rc; 10351da177e4SLinus Torvalds } 10360a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(__neigh_event_send); 10371da177e4SLinus Torvalds 1038f6b72b62SDavid S. Miller static void neigh_update_hhs(struct neighbour *neigh) 10391da177e4SLinus Torvalds { 10401da177e4SLinus Torvalds struct hh_cache *hh; 10413b04dddeSStephen Hemminger void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *) 104291a72a70SDoug Kehn = NULL; 104391a72a70SDoug Kehn 104491a72a70SDoug Kehn if (neigh->dev->header_ops) 104591a72a70SDoug Kehn update = neigh->dev->header_ops->cache_update; 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds if (update) { 1048f6b72b62SDavid S. Miller hh = &neigh->hh; 1049f6b72b62SDavid S. Miller if (hh->hh_len) { 10503644f0ceSStephen Hemminger write_seqlock_bh(&hh->hh_lock); 10511da177e4SLinus Torvalds update(hh, neigh->dev, neigh->ha); 10523644f0ceSStephen Hemminger write_sequnlock_bh(&hh->hh_lock); 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds } 10561da177e4SLinus Torvalds 10571da177e4SLinus Torvalds 10581da177e4SLinus Torvalds 10591da177e4SLinus Torvalds /* Generic update routine. 10601da177e4SLinus Torvalds -- lladdr is new lladdr or NULL, if it is not supplied. 10611da177e4SLinus Torvalds -- new is new state. 10621da177e4SLinus Torvalds -- flags 10631da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 10641da177e4SLinus Torvalds if it is different. 10651da177e4SLinus Torvalds NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 10661da177e4SLinus Torvalds lladdr instead of overriding it 10671da177e4SLinus Torvalds if it is different. 10681da177e4SLinus Torvalds It also allows to retain current state 10691da177e4SLinus Torvalds if lladdr is unchanged. 10701da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN means that the change is administrative. 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 10731da177e4SLinus Torvalds NTF_ROUTER flag. 10741da177e4SLinus Torvalds NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 10751da177e4SLinus Torvalds a router. 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds Caller MUST hold reference count on the entry. 10781da177e4SLinus Torvalds */ 10791da177e4SLinus Torvalds 10801da177e4SLinus Torvalds int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 10811da177e4SLinus Torvalds u32 flags) 10821da177e4SLinus Torvalds { 10831da177e4SLinus Torvalds u8 old; 10841da177e4SLinus Torvalds int err; 10851da177e4SLinus Torvalds int notify = 0; 10861da177e4SLinus Torvalds struct net_device *dev; 10871da177e4SLinus Torvalds int update_isrouter = 0; 10881da177e4SLinus Torvalds 10891da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 10901da177e4SLinus Torvalds 10911da177e4SLinus Torvalds dev = neigh->dev; 10921da177e4SLinus Torvalds old = neigh->nud_state; 10931da177e4SLinus Torvalds err = -EPERM; 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds if (!(flags & NEIGH_UPDATE_F_ADMIN) && 10961da177e4SLinus Torvalds (old & (NUD_NOARP | NUD_PERMANENT))) 10971da177e4SLinus Torvalds goto out; 10981da177e4SLinus Torvalds 10991da177e4SLinus Torvalds if (!(new & NUD_VALID)) { 11001da177e4SLinus Torvalds neigh_del_timer(neigh); 11011da177e4SLinus Torvalds if (old & NUD_CONNECTED) 11021da177e4SLinus Torvalds neigh_suspect(neigh); 11031da177e4SLinus Torvalds neigh->nud_state = new; 11041da177e4SLinus Torvalds err = 0; 11051da177e4SLinus Torvalds notify = old & NUD_VALID; 11065ef12d98STimo Teras if ((old & (NUD_INCOMPLETE | NUD_PROBE)) && 11075ef12d98STimo Teras (new & NUD_FAILED)) { 11085ef12d98STimo Teras neigh_invalidate(neigh); 11095ef12d98STimo Teras notify = 1; 11105ef12d98STimo Teras } 11111da177e4SLinus Torvalds goto out; 11121da177e4SLinus Torvalds } 11131da177e4SLinus Torvalds 11141da177e4SLinus Torvalds /* Compare new lladdr with cached one */ 11151da177e4SLinus Torvalds if (!dev->addr_len) { 11161da177e4SLinus Torvalds /* First case: device needs no address. */ 11171da177e4SLinus Torvalds lladdr = neigh->ha; 11181da177e4SLinus Torvalds } else if (lladdr) { 11191da177e4SLinus Torvalds /* The second case: if something is already cached 11201da177e4SLinus Torvalds and a new address is proposed: 11211da177e4SLinus Torvalds - compare new & old 11221da177e4SLinus Torvalds - if they are different, check override flag 11231da177e4SLinus Torvalds */ 11241da177e4SLinus Torvalds if ((old & NUD_VALID) && 11251da177e4SLinus Torvalds !memcmp(lladdr, neigh->ha, dev->addr_len)) 11261da177e4SLinus Torvalds lladdr = neigh->ha; 11271da177e4SLinus Torvalds } else { 11281da177e4SLinus Torvalds /* No address is supplied; if we know something, 11291da177e4SLinus Torvalds use it, otherwise discard the request. 11301da177e4SLinus Torvalds */ 11311da177e4SLinus Torvalds err = -EINVAL; 11321da177e4SLinus Torvalds if (!(old & NUD_VALID)) 11331da177e4SLinus Torvalds goto out; 11341da177e4SLinus Torvalds lladdr = neigh->ha; 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds if (new & NUD_CONNECTED) 11381da177e4SLinus Torvalds neigh->confirmed = jiffies; 11391da177e4SLinus Torvalds neigh->updated = jiffies; 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds /* If entry was valid and address is not changed, 11421da177e4SLinus Torvalds do not change entry state, if new one is STALE. 11431da177e4SLinus Torvalds */ 11441da177e4SLinus Torvalds err = 0; 11451da177e4SLinus Torvalds update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 11461da177e4SLinus Torvalds if (old & NUD_VALID) { 11471da177e4SLinus Torvalds if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 11481da177e4SLinus Torvalds update_isrouter = 0; 11491da177e4SLinus Torvalds if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 11501da177e4SLinus Torvalds (old & NUD_CONNECTED)) { 11511da177e4SLinus Torvalds lladdr = neigh->ha; 11521da177e4SLinus Torvalds new = NUD_STALE; 11531da177e4SLinus Torvalds } else 11541da177e4SLinus Torvalds goto out; 11551da177e4SLinus Torvalds } else { 11561da177e4SLinus Torvalds if (lladdr == neigh->ha && new == NUD_STALE && 11571da177e4SLinus Torvalds ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 11581da177e4SLinus Torvalds (old & NUD_CONNECTED)) 11591da177e4SLinus Torvalds ) 11601da177e4SLinus Torvalds new = old; 11611da177e4SLinus Torvalds } 11621da177e4SLinus Torvalds } 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds if (new != old) { 11651da177e4SLinus Torvalds neigh_del_timer(neigh); 1166a43d8994SPavel Emelyanov if (new & NUD_IN_TIMER) 1167667347f1SDavid S. Miller neigh_add_timer(neigh, (jiffies + 11681da177e4SLinus Torvalds ((new & NUD_REACHABLE) ? 1169667347f1SDavid S. Miller neigh->parms->reachable_time : 1170667347f1SDavid S. Miller 0))); 11711da177e4SLinus Torvalds neigh->nud_state = new; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds if (lladdr != neigh->ha) { 11750ed8ddf4SEric Dumazet write_seqlock(&neigh->ha_lock); 11761da177e4SLinus Torvalds memcpy(&neigh->ha, lladdr, dev->addr_len); 11770ed8ddf4SEric Dumazet write_sequnlock(&neigh->ha_lock); 11781da177e4SLinus Torvalds neigh_update_hhs(neigh); 11791da177e4SLinus Torvalds if (!(new & NUD_CONNECTED)) 11801da177e4SLinus Torvalds neigh->confirmed = jiffies - 11811f9248e5SJiri Pirko (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1); 11821da177e4SLinus Torvalds notify = 1; 11831da177e4SLinus Torvalds } 11841da177e4SLinus Torvalds if (new == old) 11851da177e4SLinus Torvalds goto out; 11861da177e4SLinus Torvalds if (new & NUD_CONNECTED) 11871da177e4SLinus Torvalds neigh_connect(neigh); 11881da177e4SLinus Torvalds else 11891da177e4SLinus Torvalds neigh_suspect(neigh); 11901da177e4SLinus Torvalds if (!(old & NUD_VALID)) { 11911da177e4SLinus Torvalds struct sk_buff *skb; 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds /* Again: avoid dead loop if something went wrong */ 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds while (neigh->nud_state & NUD_VALID && 11961da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 119769cce1d1SDavid S. Miller struct dst_entry *dst = skb_dst(skb); 119869cce1d1SDavid S. Miller struct neighbour *n2, *n1 = neigh; 11991da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 1200e049f288Sroy.qing.li@gmail.com 1201e049f288Sroy.qing.li@gmail.com rcu_read_lock(); 120213a43d94SDavid S. Miller 120313a43d94SDavid S. Miller /* Why not just use 'neigh' as-is? The problem is that 120413a43d94SDavid S. Miller * things such as shaper, eql, and sch_teql can end up 120513a43d94SDavid S. Miller * using alternative, different, neigh objects to output 120613a43d94SDavid S. Miller * the packet in the output path. So what we need to do 120713a43d94SDavid S. Miller * here is re-lookup the top-level neigh in the path so 120813a43d94SDavid S. Miller * we can reinject the packet there. 120913a43d94SDavid S. Miller */ 121013a43d94SDavid S. Miller n2 = NULL; 121113a43d94SDavid S. Miller if (dst) { 121213a43d94SDavid S. Miller n2 = dst_neigh_lookup_skb(dst, skb); 121313a43d94SDavid S. Miller if (n2) 121469cce1d1SDavid S. Miller n1 = n2; 121513a43d94SDavid S. Miller } 12168f40b161SDavid S. Miller n1->output(n1, skb); 121713a43d94SDavid S. Miller if (n2) 121813a43d94SDavid S. Miller neigh_release(n2); 1219e049f288Sroy.qing.li@gmail.com rcu_read_unlock(); 1220e049f288Sroy.qing.li@gmail.com 12211da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 12221da177e4SLinus Torvalds } 1223c9ab4d85SEric Dumazet __skb_queue_purge(&neigh->arp_queue); 12248b5c171bSEric Dumazet neigh->arp_queue_len_bytes = 0; 12251da177e4SLinus Torvalds } 12261da177e4SLinus Torvalds out: 12271da177e4SLinus Torvalds if (update_isrouter) { 12281da177e4SLinus Torvalds neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 12291da177e4SLinus Torvalds (neigh->flags | NTF_ROUTER) : 12301da177e4SLinus Torvalds (neigh->flags & ~NTF_ROUTER); 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 12338d71740cSTom Tucker 12348d71740cSTom Tucker if (notify) 1235d961db35SThomas Graf neigh_update_notify(neigh); 1236d961db35SThomas Graf 12371da177e4SLinus Torvalds return err; 12381da177e4SLinus Torvalds } 12390a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_update); 12401da177e4SLinus Torvalds 12417e980569SJiri Benc /* Update the neigh to listen temporarily for probe responses, even if it is 12427e980569SJiri Benc * in a NUD_FAILED state. The caller has to hold neigh->lock for writing. 12437e980569SJiri Benc */ 12447e980569SJiri Benc void __neigh_set_probe_once(struct neighbour *neigh) 12457e980569SJiri Benc { 12467e980569SJiri Benc neigh->updated = jiffies; 12477e980569SJiri Benc if (!(neigh->nud_state & NUD_FAILED)) 12487e980569SJiri Benc return; 12497e980569SJiri Benc neigh->nud_state = NUD_PROBE; 12507e980569SJiri Benc atomic_set(&neigh->probes, NEIGH_VAR(neigh->parms, UCAST_PROBES)); 12517e980569SJiri Benc neigh_add_timer(neigh, 12527e980569SJiri Benc jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME)); 12537e980569SJiri Benc } 12547e980569SJiri Benc EXPORT_SYMBOL(__neigh_set_probe_once); 12557e980569SJiri Benc 12561da177e4SLinus Torvalds struct neighbour *neigh_event_ns(struct neigh_table *tbl, 12571da177e4SLinus Torvalds u8 *lladdr, void *saddr, 12581da177e4SLinus Torvalds struct net_device *dev) 12591da177e4SLinus Torvalds { 12601da177e4SLinus Torvalds struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 12611da177e4SLinus Torvalds lladdr || !dev->addr_len); 12621da177e4SLinus Torvalds if (neigh) 12631da177e4SLinus Torvalds neigh_update(neigh, lladdr, NUD_STALE, 12641da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE); 12651da177e4SLinus Torvalds return neigh; 12661da177e4SLinus Torvalds } 12670a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_event_ns); 12681da177e4SLinus Torvalds 126934d101ddSEric Dumazet /* called with read_lock_bh(&n->lock); */ 1270f6b72b62SDavid S. Miller static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst) 12711da177e4SLinus Torvalds { 12721da177e4SLinus Torvalds struct net_device *dev = dst->dev; 1273f6b72b62SDavid S. Miller __be16 prot = dst->ops->protocol; 1274f6b72b62SDavid S. Miller struct hh_cache *hh = &n->hh; 12750ed8ddf4SEric Dumazet 12760ed8ddf4SEric Dumazet write_lock_bh(&n->lock); 127734d101ddSEric Dumazet 1278f6b72b62SDavid S. Miller /* Only one thread can come in here and initialize the 1279f6b72b62SDavid S. Miller * hh_cache entry. 1280f6b72b62SDavid S. Miller */ 1281b23b5455SDavid S. Miller if (!hh->hh_len) 1282b23b5455SDavid S. Miller dev->header_ops->cache(n, hh, prot); 1283f6b72b62SDavid S. Miller 12840ed8ddf4SEric Dumazet write_unlock_bh(&n->lock); 12851da177e4SLinus Torvalds } 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds /* This function can be used in contexts, where only old dev_queue_xmit 1288767e97e1SEric Dumazet * worked, f.e. if you want to override normal output path (eql, shaper), 1289767e97e1SEric Dumazet * but resolution is not made yet. 12901da177e4SLinus Torvalds */ 12911da177e4SLinus Torvalds 12928f40b161SDavid S. Miller int neigh_compat_output(struct neighbour *neigh, struct sk_buff *skb) 12931da177e4SLinus Torvalds { 12941da177e4SLinus Torvalds struct net_device *dev = skb->dev; 12951da177e4SLinus Torvalds 1296bbe735e4SArnaldo Carvalho de Melo __skb_pull(skb, skb_network_offset(skb)); 12971da177e4SLinus Torvalds 12980c4e8581SStephen Hemminger if (dev_hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 12991da177e4SLinus Torvalds skb->len) < 0 && 13003b04dddeSStephen Hemminger dev->header_ops->rebuild(skb)) 13011da177e4SLinus Torvalds return 0; 13021da177e4SLinus Torvalds 13031da177e4SLinus Torvalds return dev_queue_xmit(skb); 13041da177e4SLinus Torvalds } 13050a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_compat_output); 13061da177e4SLinus Torvalds 13071da177e4SLinus Torvalds /* Slow and careful. */ 13081da177e4SLinus Torvalds 13098f40b161SDavid S. Miller int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb) 13101da177e4SLinus Torvalds { 1311adf30907SEric Dumazet struct dst_entry *dst = skb_dst(skb); 13121da177e4SLinus Torvalds int rc = 0; 13131da177e4SLinus Torvalds 13148f40b161SDavid S. Miller if (!dst) 13151da177e4SLinus Torvalds goto discard; 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds if (!neigh_event_send(neigh, skb)) { 13181da177e4SLinus Torvalds int err; 13191da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 13200ed8ddf4SEric Dumazet unsigned int seq; 132134d101ddSEric Dumazet 1322f6b72b62SDavid S. Miller if (dev->header_ops->cache && !neigh->hh.hh_len) 1323f6b72b62SDavid S. Miller neigh_hh_init(neigh, dst); 132434d101ddSEric Dumazet 13250ed8ddf4SEric Dumazet do { 1326e1f16503Sramesh.nagappa@gmail.com __skb_pull(skb, skb_network_offset(skb)); 13270ed8ddf4SEric Dumazet seq = read_seqbegin(&neigh->ha_lock); 13280c4e8581SStephen Hemminger err = dev_hard_header(skb, dev, ntohs(skb->protocol), 13291da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 13300ed8ddf4SEric Dumazet } while (read_seqretry(&neigh->ha_lock, seq)); 133134d101ddSEric Dumazet 13321da177e4SLinus Torvalds if (err >= 0) 1333542d4d68SDavid S. Miller rc = dev_queue_xmit(skb); 13341da177e4SLinus Torvalds else 13351da177e4SLinus Torvalds goto out_kfree_skb; 13361da177e4SLinus Torvalds } 13371da177e4SLinus Torvalds out: 13381da177e4SLinus Torvalds return rc; 13391da177e4SLinus Torvalds discard: 1340d5d427cdSJoe Perches neigh_dbg(1, "%s: dst=%p neigh=%p\n", __func__, dst, neigh); 13411da177e4SLinus Torvalds out_kfree_skb: 13421da177e4SLinus Torvalds rc = -EINVAL; 13431da177e4SLinus Torvalds kfree_skb(skb); 13441da177e4SLinus Torvalds goto out; 13451da177e4SLinus Torvalds } 13460a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_resolve_output); 13471da177e4SLinus Torvalds 13481da177e4SLinus Torvalds /* As fast as possible without hh cache */ 13491da177e4SLinus Torvalds 13508f40b161SDavid S. Miller int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb) 13511da177e4SLinus Torvalds { 13521da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 13530ed8ddf4SEric Dumazet unsigned int seq; 13548f40b161SDavid S. Miller int err; 13551da177e4SLinus Torvalds 13560ed8ddf4SEric Dumazet do { 1357e1f16503Sramesh.nagappa@gmail.com __skb_pull(skb, skb_network_offset(skb)); 13580ed8ddf4SEric Dumazet seq = read_seqbegin(&neigh->ha_lock); 13590c4e8581SStephen Hemminger err = dev_hard_header(skb, dev, ntohs(skb->protocol), 13601da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 13610ed8ddf4SEric Dumazet } while (read_seqretry(&neigh->ha_lock, seq)); 13620ed8ddf4SEric Dumazet 13631da177e4SLinus Torvalds if (err >= 0) 1364542d4d68SDavid S. Miller err = dev_queue_xmit(skb); 13651da177e4SLinus Torvalds else { 13661da177e4SLinus Torvalds err = -EINVAL; 13671da177e4SLinus Torvalds kfree_skb(skb); 13681da177e4SLinus Torvalds } 13691da177e4SLinus Torvalds return err; 13701da177e4SLinus Torvalds } 13710a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_connected_output); 13721da177e4SLinus Torvalds 13738f40b161SDavid S. Miller int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb) 13748f40b161SDavid S. Miller { 13758f40b161SDavid S. Miller return dev_queue_xmit(skb); 13768f40b161SDavid S. Miller } 13778f40b161SDavid S. Miller EXPORT_SYMBOL(neigh_direct_output); 13788f40b161SDavid S. Miller 13791da177e4SLinus Torvalds static void neigh_proxy_process(unsigned long arg) 13801da177e4SLinus Torvalds { 13811da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 13821da177e4SLinus Torvalds long sched_next = 0; 13831da177e4SLinus Torvalds unsigned long now = jiffies; 1384f72051b0SDavid S. Miller struct sk_buff *skb, *n; 13851da177e4SLinus Torvalds 13861da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 13871da177e4SLinus Torvalds 1388f72051b0SDavid S. Miller skb_queue_walk_safe(&tbl->proxy_queue, skb, n) { 1389f72051b0SDavid S. Miller long tdif = NEIGH_CB(skb)->sched_next - now; 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds if (tdif <= 0) { 1392f72051b0SDavid S. Miller struct net_device *dev = skb->dev; 139320e6074eSEric Dumazet 1394f72051b0SDavid S. Miller __skb_unlink(skb, &tbl->proxy_queue); 139520e6074eSEric Dumazet if (tbl->proxy_redo && netif_running(dev)) { 139620e6074eSEric Dumazet rcu_read_lock(); 1397f72051b0SDavid S. Miller tbl->proxy_redo(skb); 139820e6074eSEric Dumazet rcu_read_unlock(); 139920e6074eSEric Dumazet } else { 1400f72051b0SDavid S. Miller kfree_skb(skb); 140120e6074eSEric Dumazet } 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds dev_put(dev); 14041da177e4SLinus Torvalds } else if (!sched_next || tdif < sched_next) 14051da177e4SLinus Torvalds sched_next = tdif; 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds del_timer(&tbl->proxy_timer); 14081da177e4SLinus Torvalds if (sched_next) 14091da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, jiffies + sched_next); 14101da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 14111da177e4SLinus Torvalds } 14121da177e4SLinus Torvalds 14131da177e4SLinus Torvalds void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 14141da177e4SLinus Torvalds struct sk_buff *skb) 14151da177e4SLinus Torvalds { 14161da177e4SLinus Torvalds unsigned long now = jiffies; 14171f9248e5SJiri Pirko unsigned long sched_next = now + (net_random() % 14181f9248e5SJiri Pirko NEIGH_VAR(p, PROXY_DELAY)); 14191da177e4SLinus Torvalds 14201f9248e5SJiri Pirko if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) { 14211da177e4SLinus Torvalds kfree_skb(skb); 14221da177e4SLinus Torvalds return; 14231da177e4SLinus Torvalds } 1424a61bbcf2SPatrick McHardy 1425a61bbcf2SPatrick McHardy NEIGH_CB(skb)->sched_next = sched_next; 1426a61bbcf2SPatrick McHardy NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 14291da177e4SLinus Torvalds if (del_timer(&tbl->proxy_timer)) { 14301da177e4SLinus Torvalds if (time_before(tbl->proxy_timer.expires, sched_next)) 14311da177e4SLinus Torvalds sched_next = tbl->proxy_timer.expires; 14321da177e4SLinus Torvalds } 1433adf30907SEric Dumazet skb_dst_drop(skb); 14341da177e4SLinus Torvalds dev_hold(skb->dev); 14351da177e4SLinus Torvalds __skb_queue_tail(&tbl->proxy_queue, skb); 14361da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, sched_next); 14371da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 14381da177e4SLinus Torvalds } 14390a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(pneigh_enqueue); 14401da177e4SLinus Torvalds 144197fd5bc7STobias Klauser static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl, 1442426b5303SEric W. Biederman struct net *net, int ifindex) 1443426b5303SEric W. Biederman { 1444426b5303SEric W. Biederman struct neigh_parms *p; 1445426b5303SEric W. Biederman 1446426b5303SEric W. Biederman for (p = &tbl->parms; p; p = p->next) { 1447878628fbSYOSHIFUJI Hideaki if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) || 1448170d6f99SGao feng (!p->dev && !ifindex && net_eq(net, &init_net))) 1449426b5303SEric W. Biederman return p; 1450426b5303SEric W. Biederman } 1451426b5303SEric W. Biederman 1452426b5303SEric W. Biederman return NULL; 1453426b5303SEric W. Biederman } 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 14561da177e4SLinus Torvalds struct neigh_table *tbl) 14571da177e4SLinus Torvalds { 1458cf89d6b2SGao feng struct neigh_parms *p; 145900829823SStephen Hemminger struct net *net = dev_net(dev); 146000829823SStephen Hemminger const struct net_device_ops *ops = dev->netdev_ops; 14611da177e4SLinus Torvalds 1462cf89d6b2SGao feng p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL); 14631da177e4SLinus Torvalds if (p) { 14641da177e4SLinus Torvalds p->tbl = tbl; 14651da177e4SLinus Torvalds atomic_set(&p->refcnt, 1); 14661da177e4SLinus Torvalds p->reachable_time = 14671f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME)); 1468c7fb64dbSThomas Graf dev_hold(dev); 1469c7fb64dbSThomas Graf p->dev = dev; 1470e42ea986SEric Dumazet write_pnet(&p->net, hold_net(net)); 14711da177e4SLinus Torvalds p->sysctl_table = NULL; 147263134803SVeaceslav Falico 147363134803SVeaceslav Falico if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) { 147463134803SVeaceslav Falico release_net(net); 147563134803SVeaceslav Falico dev_put(dev); 147663134803SVeaceslav Falico kfree(p); 147763134803SVeaceslav Falico return NULL; 147863134803SVeaceslav Falico } 147963134803SVeaceslav Falico 14801da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 14811da177e4SLinus Torvalds p->next = tbl->parms.next; 14821da177e4SLinus Torvalds tbl->parms.next = p; 14831da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 14841d4c8c29SJiri Pirko 14851d4c8c29SJiri Pirko neigh_parms_data_state_cleanall(p); 14861da177e4SLinus Torvalds } 14871da177e4SLinus Torvalds return p; 14881da177e4SLinus Torvalds } 14890a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_parms_alloc); 14901da177e4SLinus Torvalds 14911da177e4SLinus Torvalds static void neigh_rcu_free_parms(struct rcu_head *head) 14921da177e4SLinus Torvalds { 14931da177e4SLinus Torvalds struct neigh_parms *parms = 14941da177e4SLinus Torvalds container_of(head, struct neigh_parms, rcu_head); 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds neigh_parms_put(parms); 14971da177e4SLinus Torvalds } 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 15001da177e4SLinus Torvalds { 15011da177e4SLinus Torvalds struct neigh_parms **p; 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds if (!parms || parms == &tbl->parms) 15041da177e4SLinus Torvalds return; 15051da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 15061da177e4SLinus Torvalds for (p = &tbl->parms.next; *p; p = &(*p)->next) { 15071da177e4SLinus Torvalds if (*p == parms) { 15081da177e4SLinus Torvalds *p = parms->next; 15091da177e4SLinus Torvalds parms->dead = 1; 15101da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1511cecbb639SDavid S. Miller if (parms->dev) 1512cecbb639SDavid S. Miller dev_put(parms->dev); 15131da177e4SLinus Torvalds call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 15141da177e4SLinus Torvalds return; 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds } 15171da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1518d5d427cdSJoe Perches neigh_dbg(1, "%s: not found\n", __func__); 15191da177e4SLinus Torvalds } 15200a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_parms_release); 15211da177e4SLinus Torvalds 152206f0511dSDenis V. Lunev static void neigh_parms_destroy(struct neigh_parms *parms) 15231da177e4SLinus Torvalds { 152457da52c1SYOSHIFUJI Hideaki release_net(neigh_parms_net(parms)); 15251da177e4SLinus Torvalds kfree(parms); 15261da177e4SLinus Torvalds } 15271da177e4SLinus Torvalds 1528c2ecba71SPavel Emelianov static struct lock_class_key neigh_table_proxy_queue_class; 1529c2ecba71SPavel Emelianov 1530dcd2ba92SHiroaki SHIMODA static void neigh_table_init_no_netlink(struct neigh_table *tbl) 15311da177e4SLinus Torvalds { 15321da177e4SLinus Torvalds unsigned long now = jiffies; 15331da177e4SLinus Torvalds unsigned long phsize; 15341da177e4SLinus Torvalds 1535e42ea986SEric Dumazet write_pnet(&tbl->parms.net, &init_net); 15361da177e4SLinus Torvalds atomic_set(&tbl->parms.refcnt, 1); 15371da177e4SLinus Torvalds tbl->parms.reachable_time = 15381f9248e5SJiri Pirko neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME)); 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds tbl->stats = alloc_percpu(struct neigh_statistics); 15411da177e4SLinus Torvalds if (!tbl->stats) 15421da177e4SLinus Torvalds panic("cannot create neighbour cache statistics"); 15431da177e4SLinus Torvalds 15441da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 15459b739ba5SAlexey Dobriyan if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat, 15469b739ba5SAlexey Dobriyan &neigh_stat_seq_fops, tbl)) 15471da177e4SLinus Torvalds panic("cannot create neighbour proc dir entry"); 15481da177e4SLinus Torvalds #endif 15491da177e4SLinus Torvalds 1550cd089336SDavid S. Miller RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3)); 15511da177e4SLinus Torvalds 15521da177e4SLinus Torvalds phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 155377d04bd9SAndrew Morton tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 15541da177e4SLinus Torvalds 1555d6bf7817SEric Dumazet if (!tbl->nht || !tbl->phash_buckets) 15561da177e4SLinus Torvalds panic("cannot allocate neighbour cache hashes"); 15571da177e4SLinus Torvalds 155808433effSYOSHIFUJI Hideaki / 吉藤英明 if (!tbl->entry_size) 155908433effSYOSHIFUJI Hideaki / 吉藤英明 tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) + 156008433effSYOSHIFUJI Hideaki / 吉藤英明 tbl->key_len, NEIGH_PRIV_ALIGN); 156108433effSYOSHIFUJI Hideaki / 吉藤英明 else 156208433effSYOSHIFUJI Hideaki / 吉藤英明 WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN); 156308433effSYOSHIFUJI Hideaki / 吉藤英明 15641da177e4SLinus Torvalds rwlock_init(&tbl->lock); 1565203b42f7STejun Heo INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work); 1566e4c4e448SEric Dumazet schedule_delayed_work(&tbl->gc_work, tbl->parms.reachable_time); 1567b24b8a24SPavel Emelyanov setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl); 1568c2ecba71SPavel Emelianov skb_queue_head_init_class(&tbl->proxy_queue, 1569c2ecba71SPavel Emelianov &neigh_table_proxy_queue_class); 15701da177e4SLinus Torvalds 15711da177e4SLinus Torvalds tbl->last_flush = now; 15721da177e4SLinus Torvalds tbl->last_rand = now + tbl->parms.reachable_time * 20; 1573bd89efc5SSimon Kelley } 1574bd89efc5SSimon Kelley 1575bd89efc5SSimon Kelley void neigh_table_init(struct neigh_table *tbl) 1576bd89efc5SSimon Kelley { 1577bd89efc5SSimon Kelley struct neigh_table *tmp; 1578bd89efc5SSimon Kelley 1579bd89efc5SSimon Kelley neigh_table_init_no_netlink(tbl); 15801da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 1581bd89efc5SSimon Kelley for (tmp = neigh_tables; tmp; tmp = tmp->next) { 1582bd89efc5SSimon Kelley if (tmp->family == tbl->family) 1583bd89efc5SSimon Kelley break; 1584bd89efc5SSimon Kelley } 15851da177e4SLinus Torvalds tbl->next = neigh_tables; 15861da177e4SLinus Torvalds neigh_tables = tbl; 15871da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 1588bd89efc5SSimon Kelley 1589bd89efc5SSimon Kelley if (unlikely(tmp)) { 1590e005d193SJoe Perches pr_err("Registering multiple tables for family %d\n", 1591e005d193SJoe Perches tbl->family); 1592bd89efc5SSimon Kelley dump_stack(); 1593bd89efc5SSimon Kelley } 15941da177e4SLinus Torvalds } 15950a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_table_init); 15961da177e4SLinus Torvalds 15971da177e4SLinus Torvalds int neigh_table_clear(struct neigh_table *tbl) 15981da177e4SLinus Torvalds { 15991da177e4SLinus Torvalds struct neigh_table **tp; 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds /* It is not clean... Fix it to unload IPv6 module safely */ 1602a5c30b34STejun Heo cancel_delayed_work_sync(&tbl->gc_work); 16031da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 16041da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 16051da177e4SLinus Torvalds neigh_ifdown(tbl, NULL); 16061da177e4SLinus Torvalds if (atomic_read(&tbl->entries)) 1607e005d193SJoe Perches pr_crit("neighbour leakage\n"); 16081da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 16091da177e4SLinus Torvalds for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { 16101da177e4SLinus Torvalds if (*tp == tbl) { 16111da177e4SLinus Torvalds *tp = tbl->next; 16121da177e4SLinus Torvalds break; 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds } 16151da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 16161da177e4SLinus Torvalds 16176193d2beSEric Dumazet call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu, 16186193d2beSEric Dumazet neigh_hash_free_rcu); 1619d6bf7817SEric Dumazet tbl->nht = NULL; 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds kfree(tbl->phash_buckets); 16221da177e4SLinus Torvalds tbl->phash_buckets = NULL; 16231da177e4SLinus Torvalds 16243f192b5cSAlexey Dobriyan remove_proc_entry(tbl->id, init_net.proc_net_stat); 16253f192b5cSAlexey Dobriyan 16263fcde74bSKirill Korotaev free_percpu(tbl->stats); 16273fcde74bSKirill Korotaev tbl->stats = NULL; 16283fcde74bSKirill Korotaev 16291da177e4SLinus Torvalds return 0; 16301da177e4SLinus Torvalds } 16310a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_table_clear); 16321da177e4SLinus Torvalds 1633661d2967SThomas Graf static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh) 16341da177e4SLinus Torvalds { 16353b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1636a14a49d2SThomas Graf struct ndmsg *ndm; 1637a14a49d2SThomas Graf struct nlattr *dst_attr; 16381da177e4SLinus Torvalds struct neigh_table *tbl; 16391da177e4SLinus Torvalds struct net_device *dev = NULL; 1640a14a49d2SThomas Graf int err = -EINVAL; 16411da177e4SLinus Torvalds 1642110b2499SEric Dumazet ASSERT_RTNL(); 1643a14a49d2SThomas Graf if (nlmsg_len(nlh) < sizeof(*ndm)) 16441da177e4SLinus Torvalds goto out; 16451da177e4SLinus Torvalds 1646a14a49d2SThomas Graf dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST); 1647a14a49d2SThomas Graf if (dst_attr == NULL) 1648a14a49d2SThomas Graf goto out; 1649a14a49d2SThomas Graf 1650a14a49d2SThomas Graf ndm = nlmsg_data(nlh); 1651a14a49d2SThomas Graf if (ndm->ndm_ifindex) { 1652110b2499SEric Dumazet dev = __dev_get_by_index(net, ndm->ndm_ifindex); 1653a14a49d2SThomas Graf if (dev == NULL) { 1654a14a49d2SThomas Graf err = -ENODEV; 1655a14a49d2SThomas Graf goto out; 1656a14a49d2SThomas Graf } 1657a14a49d2SThomas Graf } 1658a14a49d2SThomas Graf 16591da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 16601da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1661a14a49d2SThomas Graf struct neighbour *neigh; 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 16641da177e4SLinus Torvalds continue; 16651da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 16661da177e4SLinus Torvalds 1667a14a49d2SThomas Graf if (nla_len(dst_attr) < tbl->key_len) 1668110b2499SEric Dumazet goto out; 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 1671426b5303SEric W. Biederman err = pneigh_delete(tbl, net, nla_data(dst_attr), dev); 1672110b2499SEric Dumazet goto out; 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds 1675a14a49d2SThomas Graf if (dev == NULL) 1676110b2499SEric Dumazet goto out; 16771da177e4SLinus Torvalds 1678a14a49d2SThomas Graf neigh = neigh_lookup(tbl, nla_data(dst_attr), dev); 1679a14a49d2SThomas Graf if (neigh == NULL) { 1680a14a49d2SThomas Graf err = -ENOENT; 1681110b2499SEric Dumazet goto out; 1682a14a49d2SThomas Graf } 1683a14a49d2SThomas Graf 1684a14a49d2SThomas Graf err = neigh_update(neigh, NULL, NUD_FAILED, 16851da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE | 16861da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN); 1687a14a49d2SThomas Graf neigh_release(neigh); 1688110b2499SEric Dumazet goto out; 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 1691a14a49d2SThomas Graf err = -EAFNOSUPPORT; 1692a14a49d2SThomas Graf 16931da177e4SLinus Torvalds out: 16941da177e4SLinus Torvalds return err; 16951da177e4SLinus Torvalds } 16961da177e4SLinus Torvalds 1697661d2967SThomas Graf static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh) 16981da177e4SLinus Torvalds { 16993b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 17005208debdSThomas Graf struct ndmsg *ndm; 17015208debdSThomas Graf struct nlattr *tb[NDA_MAX+1]; 17021da177e4SLinus Torvalds struct neigh_table *tbl; 17031da177e4SLinus Torvalds struct net_device *dev = NULL; 17045208debdSThomas Graf int err; 17051da177e4SLinus Torvalds 1706110b2499SEric Dumazet ASSERT_RTNL(); 17075208debdSThomas Graf err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 17085208debdSThomas Graf if (err < 0) 17091da177e4SLinus Torvalds goto out; 17101da177e4SLinus Torvalds 17115208debdSThomas Graf err = -EINVAL; 17125208debdSThomas Graf if (tb[NDA_DST] == NULL) 17135208debdSThomas Graf goto out; 17145208debdSThomas Graf 17155208debdSThomas Graf ndm = nlmsg_data(nlh); 17165208debdSThomas Graf if (ndm->ndm_ifindex) { 1717110b2499SEric Dumazet dev = __dev_get_by_index(net, ndm->ndm_ifindex); 17185208debdSThomas Graf if (dev == NULL) { 17195208debdSThomas Graf err = -ENODEV; 17205208debdSThomas Graf goto out; 17215208debdSThomas Graf } 17225208debdSThomas Graf 17235208debdSThomas Graf if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) 1724110b2499SEric Dumazet goto out; 17255208debdSThomas Graf } 17265208debdSThomas Graf 17271da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 17281da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 17295208debdSThomas Graf int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE; 17305208debdSThomas Graf struct neighbour *neigh; 17315208debdSThomas Graf void *dst, *lladdr; 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 17341da177e4SLinus Torvalds continue; 17351da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 17361da177e4SLinus Torvalds 17375208debdSThomas Graf if (nla_len(tb[NDA_DST]) < tbl->key_len) 1738110b2499SEric Dumazet goto out; 17395208debdSThomas Graf dst = nla_data(tb[NDA_DST]); 17405208debdSThomas Graf lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL; 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 174362dd9318SVille Nuorvala struct pneigh_entry *pn; 174462dd9318SVille Nuorvala 17455208debdSThomas Graf err = -ENOBUFS; 1746426b5303SEric W. Biederman pn = pneigh_lookup(tbl, net, dst, dev, 1); 174762dd9318SVille Nuorvala if (pn) { 174862dd9318SVille Nuorvala pn->flags = ndm->ndm_flags; 174962dd9318SVille Nuorvala err = 0; 175062dd9318SVille Nuorvala } 1751110b2499SEric Dumazet goto out; 17521da177e4SLinus Torvalds } 17531da177e4SLinus Torvalds 17545208debdSThomas Graf if (dev == NULL) 1755110b2499SEric Dumazet goto out; 17561da177e4SLinus Torvalds 17575208debdSThomas Graf neigh = neigh_lookup(tbl, dst, dev); 17585208debdSThomas Graf if (neigh == NULL) { 17595208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 17601da177e4SLinus Torvalds err = -ENOENT; 1761110b2499SEric Dumazet goto out; 17625208debdSThomas Graf } 17635208debdSThomas Graf 17645208debdSThomas Graf neigh = __neigh_lookup_errno(tbl, dst, dev); 17655208debdSThomas Graf if (IS_ERR(neigh)) { 17665208debdSThomas Graf err = PTR_ERR(neigh); 1767110b2499SEric Dumazet goto out; 17681da177e4SLinus Torvalds } 17695208debdSThomas Graf } else { 17705208debdSThomas Graf if (nlh->nlmsg_flags & NLM_F_EXCL) { 17715208debdSThomas Graf err = -EEXIST; 17725208debdSThomas Graf neigh_release(neigh); 1773110b2499SEric Dumazet goto out; 17741da177e4SLinus Torvalds } 17751da177e4SLinus Torvalds 17765208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) 17775208debdSThomas Graf flags &= ~NEIGH_UPDATE_F_OVERRIDE; 17785208debdSThomas Graf } 17791da177e4SLinus Torvalds 17800c5c2d30SEric Biederman if (ndm->ndm_flags & NTF_USE) { 17810c5c2d30SEric Biederman neigh_event_send(neigh, NULL); 17820c5c2d30SEric Biederman err = 0; 17830c5c2d30SEric Biederman } else 17845208debdSThomas Graf err = neigh_update(neigh, lladdr, ndm->ndm_state, flags); 17855208debdSThomas Graf neigh_release(neigh); 1786110b2499SEric Dumazet goto out; 17871da177e4SLinus Torvalds } 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 17905208debdSThomas Graf err = -EAFNOSUPPORT; 17911da177e4SLinus Torvalds out: 17921da177e4SLinus Torvalds return err; 17931da177e4SLinus Torvalds } 17941da177e4SLinus Torvalds 1795c7fb64dbSThomas Graf static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1796c7fb64dbSThomas Graf { 1797ca860fb3SThomas Graf struct nlattr *nest; 1798e386c6ebSThomas Graf 1799ca860fb3SThomas Graf nest = nla_nest_start(skb, NDTA_PARMS); 1800ca860fb3SThomas Graf if (nest == NULL) 1801ca860fb3SThomas Graf return -ENOBUFS; 1802c7fb64dbSThomas Graf 18039a6308d7SDavid S. Miller if ((parms->dev && 18049a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) || 18059a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) || 18061f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_QUEUE_LENBYTES, 18071f9248e5SJiri Pirko NEIGH_VAR(parms, QUEUE_LEN_BYTES)) || 18088b5c171bSEric Dumazet /* approximative value for deprecated QUEUE_LEN (in packets) */ 18099a6308d7SDavid S. Miller nla_put_u32(skb, NDTPA_QUEUE_LEN, 18101f9248e5SJiri Pirko NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) || 18111f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) || 18121f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) || 18131f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_UCAST_PROBES, 18141f9248e5SJiri Pirko NEIGH_VAR(parms, UCAST_PROBES)) || 18151f9248e5SJiri Pirko nla_put_u32(skb, NDTPA_MCAST_PROBES, 18161f9248e5SJiri Pirko NEIGH_VAR(parms, MCAST_PROBES)) || 18179a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) || 18189a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME, 18191f9248e5SJiri Pirko NEIGH_VAR(parms, BASE_REACHABLE_TIME)) || 18201f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_GC_STALETIME, 18211f9248e5SJiri Pirko NEIGH_VAR(parms, GC_STALETIME)) || 18229a6308d7SDavid S. Miller nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME, 18231f9248e5SJiri Pirko NEIGH_VAR(parms, DELAY_PROBE_TIME)) || 18241f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_RETRANS_TIME, 18251f9248e5SJiri Pirko NEIGH_VAR(parms, RETRANS_TIME)) || 18261f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_ANYCAST_DELAY, 18271f9248e5SJiri Pirko NEIGH_VAR(parms, ANYCAST_DELAY)) || 18281f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_PROXY_DELAY, 18291f9248e5SJiri Pirko NEIGH_VAR(parms, PROXY_DELAY)) || 18301f9248e5SJiri Pirko nla_put_msecs(skb, NDTPA_LOCKTIME, 18311f9248e5SJiri Pirko NEIGH_VAR(parms, LOCKTIME))) 18329a6308d7SDavid S. Miller goto nla_put_failure; 1833ca860fb3SThomas Graf return nla_nest_end(skb, nest); 1834c7fb64dbSThomas Graf 1835ca860fb3SThomas Graf nla_put_failure: 1836bc3ed28cSThomas Graf nla_nest_cancel(skb, nest); 1837bc3ed28cSThomas Graf return -EMSGSIZE; 1838c7fb64dbSThomas Graf } 1839c7fb64dbSThomas Graf 1840ca860fb3SThomas Graf static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl, 1841ca860fb3SThomas Graf u32 pid, u32 seq, int type, int flags) 1842c7fb64dbSThomas Graf { 1843c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1844c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1845c7fb64dbSThomas Graf 1846ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1847ca860fb3SThomas Graf if (nlh == NULL) 184826932566SPatrick McHardy return -EMSGSIZE; 1849c7fb64dbSThomas Graf 1850ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1851c7fb64dbSThomas Graf 1852c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1853c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 18549ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 18559ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1856c7fb64dbSThomas Graf 18579a6308d7SDavid S. Miller if (nla_put_string(skb, NDTA_NAME, tbl->id) || 18589a6308d7SDavid S. Miller nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) || 18599a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) || 18609a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) || 18619a6308d7SDavid S. Miller nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3)) 18629a6308d7SDavid S. Miller goto nla_put_failure; 1863c7fb64dbSThomas Graf { 1864c7fb64dbSThomas Graf unsigned long now = jiffies; 1865c7fb64dbSThomas Graf unsigned int flush_delta = now - tbl->last_flush; 1866c7fb64dbSThomas Graf unsigned int rand_delta = now - tbl->last_rand; 1867d6bf7817SEric Dumazet struct neigh_hash_table *nht; 1868c7fb64dbSThomas Graf struct ndt_config ndc = { 1869c7fb64dbSThomas Graf .ndtc_key_len = tbl->key_len, 1870c7fb64dbSThomas Graf .ndtc_entry_size = tbl->entry_size, 1871c7fb64dbSThomas Graf .ndtc_entries = atomic_read(&tbl->entries), 1872c7fb64dbSThomas Graf .ndtc_last_flush = jiffies_to_msecs(flush_delta), 1873c7fb64dbSThomas Graf .ndtc_last_rand = jiffies_to_msecs(rand_delta), 1874c7fb64dbSThomas Graf .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 1875c7fb64dbSThomas Graf }; 1876c7fb64dbSThomas Graf 1877d6bf7817SEric Dumazet rcu_read_lock_bh(); 1878d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 18792c2aba6cSDavid S. Miller ndc.ndtc_hash_rnd = nht->hash_rnd[0]; 1880cd089336SDavid S. Miller ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1); 1881d6bf7817SEric Dumazet rcu_read_unlock_bh(); 1882d6bf7817SEric Dumazet 18839a6308d7SDavid S. Miller if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc)) 18849a6308d7SDavid S. Miller goto nla_put_failure; 1885c7fb64dbSThomas Graf } 1886c7fb64dbSThomas Graf 1887c7fb64dbSThomas Graf { 1888c7fb64dbSThomas Graf int cpu; 1889c7fb64dbSThomas Graf struct ndt_stats ndst; 1890c7fb64dbSThomas Graf 1891c7fb64dbSThomas Graf memset(&ndst, 0, sizeof(ndst)); 1892c7fb64dbSThomas Graf 18936f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) { 1894c7fb64dbSThomas Graf struct neigh_statistics *st; 1895c7fb64dbSThomas Graf 1896c7fb64dbSThomas Graf st = per_cpu_ptr(tbl->stats, cpu); 1897c7fb64dbSThomas Graf ndst.ndts_allocs += st->allocs; 1898c7fb64dbSThomas Graf ndst.ndts_destroys += st->destroys; 1899c7fb64dbSThomas Graf ndst.ndts_hash_grows += st->hash_grows; 1900c7fb64dbSThomas Graf ndst.ndts_res_failed += st->res_failed; 1901c7fb64dbSThomas Graf ndst.ndts_lookups += st->lookups; 1902c7fb64dbSThomas Graf ndst.ndts_hits += st->hits; 1903c7fb64dbSThomas Graf ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 1904c7fb64dbSThomas Graf ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 1905c7fb64dbSThomas Graf ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 1906c7fb64dbSThomas Graf ndst.ndts_forced_gc_runs += st->forced_gc_runs; 1907c7fb64dbSThomas Graf } 1908c7fb64dbSThomas Graf 19099a6308d7SDavid S. Miller if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst)) 19109a6308d7SDavid S. Miller goto nla_put_failure; 1911c7fb64dbSThomas Graf } 1912c7fb64dbSThomas Graf 1913c7fb64dbSThomas Graf BUG_ON(tbl->parms.dev); 1914c7fb64dbSThomas Graf if (neightbl_fill_parms(skb, &tbl->parms) < 0) 1915ca860fb3SThomas Graf goto nla_put_failure; 1916c7fb64dbSThomas Graf 1917c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1918ca860fb3SThomas Graf return nlmsg_end(skb, nlh); 1919c7fb64dbSThomas Graf 1920ca860fb3SThomas Graf nla_put_failure: 1921c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 192226932566SPatrick McHardy nlmsg_cancel(skb, nlh); 192326932566SPatrick McHardy return -EMSGSIZE; 1924c7fb64dbSThomas Graf } 1925c7fb64dbSThomas Graf 1926ca860fb3SThomas Graf static int neightbl_fill_param_info(struct sk_buff *skb, 1927ca860fb3SThomas Graf struct neigh_table *tbl, 1928c7fb64dbSThomas Graf struct neigh_parms *parms, 1929ca860fb3SThomas Graf u32 pid, u32 seq, int type, 1930ca860fb3SThomas Graf unsigned int flags) 1931c7fb64dbSThomas Graf { 1932c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1933c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1934c7fb64dbSThomas Graf 1935ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1936ca860fb3SThomas Graf if (nlh == NULL) 193726932566SPatrick McHardy return -EMSGSIZE; 1938c7fb64dbSThomas Graf 1939ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1940c7fb64dbSThomas Graf 1941c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1942c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 19439ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 19449ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1945c7fb64dbSThomas Graf 1946ca860fb3SThomas Graf if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 || 1947ca860fb3SThomas Graf neightbl_fill_parms(skb, parms) < 0) 1948ca860fb3SThomas Graf goto errout; 1949c7fb64dbSThomas Graf 1950c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1951ca860fb3SThomas Graf return nlmsg_end(skb, nlh); 1952ca860fb3SThomas Graf errout: 1953c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 195426932566SPatrick McHardy nlmsg_cancel(skb, nlh); 195526932566SPatrick McHardy return -EMSGSIZE; 1956c7fb64dbSThomas Graf } 1957c7fb64dbSThomas Graf 1958ef7c79edSPatrick McHardy static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = { 19596b3f8674SThomas Graf [NDTA_NAME] = { .type = NLA_STRING }, 19606b3f8674SThomas Graf [NDTA_THRESH1] = { .type = NLA_U32 }, 19616b3f8674SThomas Graf [NDTA_THRESH2] = { .type = NLA_U32 }, 19626b3f8674SThomas Graf [NDTA_THRESH3] = { .type = NLA_U32 }, 19636b3f8674SThomas Graf [NDTA_GC_INTERVAL] = { .type = NLA_U64 }, 19646b3f8674SThomas Graf [NDTA_PARMS] = { .type = NLA_NESTED }, 19656b3f8674SThomas Graf }; 19666b3f8674SThomas Graf 1967ef7c79edSPatrick McHardy static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = { 19686b3f8674SThomas Graf [NDTPA_IFINDEX] = { .type = NLA_U32 }, 19696b3f8674SThomas Graf [NDTPA_QUEUE_LEN] = { .type = NLA_U32 }, 19706b3f8674SThomas Graf [NDTPA_PROXY_QLEN] = { .type = NLA_U32 }, 19716b3f8674SThomas Graf [NDTPA_APP_PROBES] = { .type = NLA_U32 }, 19726b3f8674SThomas Graf [NDTPA_UCAST_PROBES] = { .type = NLA_U32 }, 19736b3f8674SThomas Graf [NDTPA_MCAST_PROBES] = { .type = NLA_U32 }, 19746b3f8674SThomas Graf [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 }, 19756b3f8674SThomas Graf [NDTPA_GC_STALETIME] = { .type = NLA_U64 }, 19766b3f8674SThomas Graf [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 }, 19776b3f8674SThomas Graf [NDTPA_RETRANS_TIME] = { .type = NLA_U64 }, 19786b3f8674SThomas Graf [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 }, 19796b3f8674SThomas Graf [NDTPA_PROXY_DELAY] = { .type = NLA_U64 }, 19806b3f8674SThomas Graf [NDTPA_LOCKTIME] = { .type = NLA_U64 }, 19816b3f8674SThomas Graf }; 19826b3f8674SThomas Graf 1983661d2967SThomas Graf static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh) 1984c7fb64dbSThomas Graf { 19853b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 1986c7fb64dbSThomas Graf struct neigh_table *tbl; 19876b3f8674SThomas Graf struct ndtmsg *ndtmsg; 19886b3f8674SThomas Graf struct nlattr *tb[NDTA_MAX+1]; 19896b3f8674SThomas Graf int err; 1990c7fb64dbSThomas Graf 19916b3f8674SThomas Graf err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX, 19926b3f8674SThomas Graf nl_neightbl_policy); 19936b3f8674SThomas Graf if (err < 0) 19946b3f8674SThomas Graf goto errout; 1995c7fb64dbSThomas Graf 19966b3f8674SThomas Graf if (tb[NDTA_NAME] == NULL) { 19976b3f8674SThomas Graf err = -EINVAL; 19986b3f8674SThomas Graf goto errout; 19996b3f8674SThomas Graf } 20006b3f8674SThomas Graf 20016b3f8674SThomas Graf ndtmsg = nlmsg_data(nlh); 2002c7fb64dbSThomas Graf read_lock(&neigh_tbl_lock); 2003c7fb64dbSThomas Graf for (tbl = neigh_tables; tbl; tbl = tbl->next) { 2004c7fb64dbSThomas Graf if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 2005c7fb64dbSThomas Graf continue; 2006c7fb64dbSThomas Graf 20076b3f8674SThomas Graf if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) 2008c7fb64dbSThomas Graf break; 2009c7fb64dbSThomas Graf } 2010c7fb64dbSThomas Graf 2011c7fb64dbSThomas Graf if (tbl == NULL) { 2012c7fb64dbSThomas Graf err = -ENOENT; 20136b3f8674SThomas Graf goto errout_locked; 2014c7fb64dbSThomas Graf } 2015c7fb64dbSThomas Graf 2016c7fb64dbSThomas Graf /* 2017c7fb64dbSThomas Graf * We acquire tbl->lock to be nice to the periodic timers and 2018c7fb64dbSThomas Graf * make sure they always see a consistent set of values. 2019c7fb64dbSThomas Graf */ 2020c7fb64dbSThomas Graf write_lock_bh(&tbl->lock); 2021c7fb64dbSThomas Graf 20226b3f8674SThomas Graf if (tb[NDTA_PARMS]) { 20236b3f8674SThomas Graf struct nlattr *tbp[NDTPA_MAX+1]; 2024c7fb64dbSThomas Graf struct neigh_parms *p; 20256b3f8674SThomas Graf int i, ifindex = 0; 2026c7fb64dbSThomas Graf 20276b3f8674SThomas Graf err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS], 20286b3f8674SThomas Graf nl_ntbl_parm_policy); 20296b3f8674SThomas Graf if (err < 0) 20306b3f8674SThomas Graf goto errout_tbl_lock; 2031c7fb64dbSThomas Graf 20326b3f8674SThomas Graf if (tbp[NDTPA_IFINDEX]) 20336b3f8674SThomas Graf ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]); 2034c7fb64dbSThomas Graf 203597fd5bc7STobias Klauser p = lookup_neigh_parms(tbl, net, ifindex); 2036c7fb64dbSThomas Graf if (p == NULL) { 2037c7fb64dbSThomas Graf err = -ENOENT; 20386b3f8674SThomas Graf goto errout_tbl_lock; 2039c7fb64dbSThomas Graf } 2040c7fb64dbSThomas Graf 20416b3f8674SThomas Graf for (i = 1; i <= NDTPA_MAX; i++) { 20426b3f8674SThomas Graf if (tbp[i] == NULL) 20436b3f8674SThomas Graf continue; 2044c7fb64dbSThomas Graf 20456b3f8674SThomas Graf switch (i) { 20466b3f8674SThomas Graf case NDTPA_QUEUE_LEN: 20471f9248e5SJiri Pirko NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 20481f9248e5SJiri Pirko nla_get_u32(tbp[i]) * 20491f9248e5SJiri Pirko SKB_TRUESIZE(ETH_FRAME_LEN)); 20508b5c171bSEric Dumazet break; 20518b5c171bSEric Dumazet case NDTPA_QUEUE_LENBYTES: 20521f9248e5SJiri Pirko NEIGH_VAR_SET(p, QUEUE_LEN_BYTES, 20531f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20546b3f8674SThomas Graf break; 20556b3f8674SThomas Graf case NDTPA_PROXY_QLEN: 20561f9248e5SJiri Pirko NEIGH_VAR_SET(p, PROXY_QLEN, 20571f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20586b3f8674SThomas Graf break; 20596b3f8674SThomas Graf case NDTPA_APP_PROBES: 20601f9248e5SJiri Pirko NEIGH_VAR_SET(p, APP_PROBES, 20611f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20626b3f8674SThomas Graf break; 20636b3f8674SThomas Graf case NDTPA_UCAST_PROBES: 20641f9248e5SJiri Pirko NEIGH_VAR_SET(p, UCAST_PROBES, 20651f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20666b3f8674SThomas Graf break; 20676b3f8674SThomas Graf case NDTPA_MCAST_PROBES: 20681f9248e5SJiri Pirko NEIGH_VAR_SET(p, MCAST_PROBES, 20691f9248e5SJiri Pirko nla_get_u32(tbp[i])); 20706b3f8674SThomas Graf break; 20716b3f8674SThomas Graf case NDTPA_BASE_REACHABLE_TIME: 20721f9248e5SJiri Pirko NEIGH_VAR_SET(p, BASE_REACHABLE_TIME, 20731f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20746b3f8674SThomas Graf break; 20756b3f8674SThomas Graf case NDTPA_GC_STALETIME: 20761f9248e5SJiri Pirko NEIGH_VAR_SET(p, GC_STALETIME, 20771f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20786b3f8674SThomas Graf break; 20796b3f8674SThomas Graf case NDTPA_DELAY_PROBE_TIME: 20801f9248e5SJiri Pirko NEIGH_VAR_SET(p, DELAY_PROBE_TIME, 20811f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20826b3f8674SThomas Graf break; 20836b3f8674SThomas Graf case NDTPA_RETRANS_TIME: 20841f9248e5SJiri Pirko NEIGH_VAR_SET(p, RETRANS_TIME, 20851f9248e5SJiri Pirko nla_get_msecs(tbp[i])); 20866b3f8674SThomas Graf break; 20876b3f8674SThomas Graf case NDTPA_ANYCAST_DELAY: 20881f9248e5SJiri Pirko NEIGH_VAR_SET(p, ANYCAST_DELAY, nla_get_msecs(tbp[i])); 20896b3f8674SThomas Graf break; 20906b3f8674SThomas Graf case NDTPA_PROXY_DELAY: 20911f9248e5SJiri Pirko NEIGH_VAR_SET(p, PROXY_DELAY, nla_get_msecs(tbp[i])); 20926b3f8674SThomas Graf break; 20936b3f8674SThomas Graf case NDTPA_LOCKTIME: 20941f9248e5SJiri Pirko NEIGH_VAR_SET(p, LOCKTIME, nla_get_msecs(tbp[i])); 20956b3f8674SThomas Graf break; 2096c7fb64dbSThomas Graf } 20976b3f8674SThomas Graf } 20986b3f8674SThomas Graf } 20996b3f8674SThomas Graf 2100dc25c676SGao feng err = -ENOENT; 2101dc25c676SGao feng if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] || 2102dc25c676SGao feng tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) && 2103dc25c676SGao feng !net_eq(net, &init_net)) 2104dc25c676SGao feng goto errout_tbl_lock; 2105dc25c676SGao feng 21066b3f8674SThomas Graf if (tb[NDTA_THRESH1]) 21076b3f8674SThomas Graf tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 21086b3f8674SThomas Graf 21096b3f8674SThomas Graf if (tb[NDTA_THRESH2]) 21106b3f8674SThomas Graf tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 21116b3f8674SThomas Graf 21126b3f8674SThomas Graf if (tb[NDTA_THRESH3]) 21136b3f8674SThomas Graf tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 21146b3f8674SThomas Graf 21156b3f8674SThomas Graf if (tb[NDTA_GC_INTERVAL]) 21166b3f8674SThomas Graf tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]); 2117c7fb64dbSThomas Graf 2118c7fb64dbSThomas Graf err = 0; 2119c7fb64dbSThomas Graf 21206b3f8674SThomas Graf errout_tbl_lock: 2121c7fb64dbSThomas Graf write_unlock_bh(&tbl->lock); 21226b3f8674SThomas Graf errout_locked: 2123c7fb64dbSThomas Graf read_unlock(&neigh_tbl_lock); 21246b3f8674SThomas Graf errout: 2125c7fb64dbSThomas Graf return err; 2126c7fb64dbSThomas Graf } 2127c7fb64dbSThomas Graf 2128c8822a4eSThomas Graf static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 2129c7fb64dbSThomas Graf { 21303b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 2131ca860fb3SThomas Graf int family, tidx, nidx = 0; 2132ca860fb3SThomas Graf int tbl_skip = cb->args[0]; 2133ca860fb3SThomas Graf int neigh_skip = cb->args[1]; 2134c7fb64dbSThomas Graf struct neigh_table *tbl; 2135c7fb64dbSThomas Graf 2136ca860fb3SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 2137c7fb64dbSThomas Graf 2138c7fb64dbSThomas Graf read_lock(&neigh_tbl_lock); 2139ca860fb3SThomas Graf for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) { 2140c7fb64dbSThomas Graf struct neigh_parms *p; 2141c7fb64dbSThomas Graf 2142ca860fb3SThomas Graf if (tidx < tbl_skip || (family && tbl->family != family)) 2143c7fb64dbSThomas Graf continue; 2144c7fb64dbSThomas Graf 214515e47304SEric W. Biederman if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid, 2146ca860fb3SThomas Graf cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL, 2147ca860fb3SThomas Graf NLM_F_MULTI) <= 0) 2148c7fb64dbSThomas Graf break; 2149c7fb64dbSThomas Graf 2150426b5303SEric W. Biederman for (nidx = 0, p = tbl->parms.next; p; p = p->next) { 2151878628fbSYOSHIFUJI Hideaki if (!net_eq(neigh_parms_net(p), net)) 2152426b5303SEric W. Biederman continue; 2153426b5303SEric W. Biederman 2154efc683fcSGautam Kachroo if (nidx < neigh_skip) 2155efc683fcSGautam Kachroo goto next; 2156c7fb64dbSThomas Graf 2157ca860fb3SThomas Graf if (neightbl_fill_param_info(skb, tbl, p, 215815e47304SEric W. Biederman NETLINK_CB(cb->skb).portid, 2159ca860fb3SThomas Graf cb->nlh->nlmsg_seq, 2160ca860fb3SThomas Graf RTM_NEWNEIGHTBL, 2161ca860fb3SThomas Graf NLM_F_MULTI) <= 0) 2162c7fb64dbSThomas Graf goto out; 2163efc683fcSGautam Kachroo next: 2164efc683fcSGautam Kachroo nidx++; 2165c7fb64dbSThomas Graf } 2166c7fb64dbSThomas Graf 2167ca860fb3SThomas Graf neigh_skip = 0; 2168c7fb64dbSThomas Graf } 2169c7fb64dbSThomas Graf out: 2170c7fb64dbSThomas Graf read_unlock(&neigh_tbl_lock); 2171ca860fb3SThomas Graf cb->args[0] = tidx; 2172ca860fb3SThomas Graf cb->args[1] = nidx; 2173c7fb64dbSThomas Graf 2174c7fb64dbSThomas Graf return skb->len; 2175c7fb64dbSThomas Graf } 21761da177e4SLinus Torvalds 21778b8aec50SThomas Graf static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh, 21788b8aec50SThomas Graf u32 pid, u32 seq, int type, unsigned int flags) 21791da177e4SLinus Torvalds { 21801da177e4SLinus Torvalds unsigned long now = jiffies; 21811da177e4SLinus Torvalds struct nda_cacheinfo ci; 21828b8aec50SThomas Graf struct nlmsghdr *nlh; 21838b8aec50SThomas Graf struct ndmsg *ndm; 21841da177e4SLinus Torvalds 21858b8aec50SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 21868b8aec50SThomas Graf if (nlh == NULL) 218726932566SPatrick McHardy return -EMSGSIZE; 21888b8aec50SThomas Graf 21898b8aec50SThomas Graf ndm = nlmsg_data(nlh); 21908b8aec50SThomas Graf ndm->ndm_family = neigh->ops->family; 21919ef1d4c7SPatrick McHardy ndm->ndm_pad1 = 0; 21929ef1d4c7SPatrick McHardy ndm->ndm_pad2 = 0; 21938b8aec50SThomas Graf ndm->ndm_flags = neigh->flags; 21948b8aec50SThomas Graf ndm->ndm_type = neigh->type; 21958b8aec50SThomas Graf ndm->ndm_ifindex = neigh->dev->ifindex; 21961da177e4SLinus Torvalds 21979a6308d7SDavid S. Miller if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key)) 21989a6308d7SDavid S. Miller goto nla_put_failure; 21998b8aec50SThomas Graf 22008b8aec50SThomas Graf read_lock_bh(&neigh->lock); 22018b8aec50SThomas Graf ndm->ndm_state = neigh->nud_state; 22020ed8ddf4SEric Dumazet if (neigh->nud_state & NUD_VALID) { 22030ed8ddf4SEric Dumazet char haddr[MAX_ADDR_LEN]; 22040ed8ddf4SEric Dumazet 22050ed8ddf4SEric Dumazet neigh_ha_snapshot(haddr, neigh, neigh->dev); 22060ed8ddf4SEric Dumazet if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) { 22078b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 22088b8aec50SThomas Graf goto nla_put_failure; 22098b8aec50SThomas Graf } 22100ed8ddf4SEric Dumazet } 22118b8aec50SThomas Graf 2212b9f5f52cSStephen Hemminger ci.ndm_used = jiffies_to_clock_t(now - neigh->used); 2213b9f5f52cSStephen Hemminger ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed); 2214b9f5f52cSStephen Hemminger ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated); 22158b8aec50SThomas Graf ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1; 22168b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 22178b8aec50SThomas Graf 22189a6308d7SDavid S. Miller if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) || 22199a6308d7SDavid S. Miller nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci)) 22209a6308d7SDavid S. Miller goto nla_put_failure; 22218b8aec50SThomas Graf 22228b8aec50SThomas Graf return nlmsg_end(skb, nlh); 22238b8aec50SThomas Graf 22248b8aec50SThomas Graf nla_put_failure: 222526932566SPatrick McHardy nlmsg_cancel(skb, nlh); 222626932566SPatrick McHardy return -EMSGSIZE; 22271da177e4SLinus Torvalds } 22281da177e4SLinus Torvalds 222984920c14STony Zelenoff static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn, 223084920c14STony Zelenoff u32 pid, u32 seq, int type, unsigned int flags, 223184920c14STony Zelenoff struct neigh_table *tbl) 223284920c14STony Zelenoff { 223384920c14STony Zelenoff struct nlmsghdr *nlh; 223484920c14STony Zelenoff struct ndmsg *ndm; 223584920c14STony Zelenoff 223684920c14STony Zelenoff nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 223784920c14STony Zelenoff if (nlh == NULL) 223884920c14STony Zelenoff return -EMSGSIZE; 223984920c14STony Zelenoff 224084920c14STony Zelenoff ndm = nlmsg_data(nlh); 224184920c14STony Zelenoff ndm->ndm_family = tbl->family; 224284920c14STony Zelenoff ndm->ndm_pad1 = 0; 224384920c14STony Zelenoff ndm->ndm_pad2 = 0; 224484920c14STony Zelenoff ndm->ndm_flags = pn->flags | NTF_PROXY; 224584920c14STony Zelenoff ndm->ndm_type = NDA_DST; 224684920c14STony Zelenoff ndm->ndm_ifindex = pn->dev->ifindex; 224784920c14STony Zelenoff ndm->ndm_state = NUD_NONE; 224884920c14STony Zelenoff 22499a6308d7SDavid S. Miller if (nla_put(skb, NDA_DST, tbl->key_len, pn->key)) 22509a6308d7SDavid S. Miller goto nla_put_failure; 225184920c14STony Zelenoff 225284920c14STony Zelenoff return nlmsg_end(skb, nlh); 225384920c14STony Zelenoff 225484920c14STony Zelenoff nla_put_failure: 225584920c14STony Zelenoff nlmsg_cancel(skb, nlh); 225684920c14STony Zelenoff return -EMSGSIZE; 225784920c14STony Zelenoff } 225884920c14STony Zelenoff 2259d961db35SThomas Graf static void neigh_update_notify(struct neighbour *neigh) 2260d961db35SThomas Graf { 2261d961db35SThomas Graf call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 2262d961db35SThomas Graf __neigh_notify(neigh, RTM_NEWNEIGH, 0); 2263d961db35SThomas Graf } 22641da177e4SLinus Torvalds 22651da177e4SLinus Torvalds static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 22661da177e4SLinus Torvalds struct netlink_callback *cb) 22671da177e4SLinus Torvalds { 22683b1e0a65SYOSHIFUJI Hideaki struct net *net = sock_net(skb->sk); 22691da177e4SLinus Torvalds struct neighbour *n; 22701da177e4SLinus Torvalds int rc, h, s_h = cb->args[1]; 22711da177e4SLinus Torvalds int idx, s_idx = idx = cb->args[2]; 2272d6bf7817SEric Dumazet struct neigh_hash_table *nht; 22731da177e4SLinus Torvalds 2274d6bf7817SEric Dumazet rcu_read_lock_bh(); 2275d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 2276d6bf7817SEric Dumazet 22774bd6683bSEric Dumazet for (h = s_h; h < (1 << nht->hash_shift); h++) { 22781da177e4SLinus Torvalds if (h > s_h) 22791da177e4SLinus Torvalds s_idx = 0; 2280767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0; 2281767e97e1SEric Dumazet n != NULL; 2282767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) { 228309ad9bc7SOctavian Purdila if (!net_eq(dev_net(n->dev), net)) 2284426b5303SEric W. Biederman continue; 2285efc683fcSGautam Kachroo if (idx < s_idx) 2286efc683fcSGautam Kachroo goto next; 228715e47304SEric W. Biederman if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 22881da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 2289b6544c0bSJamal Hadi Salim RTM_NEWNEIGH, 2290b6544c0bSJamal Hadi Salim NLM_F_MULTI) <= 0) { 22911da177e4SLinus Torvalds rc = -1; 22921da177e4SLinus Torvalds goto out; 22931da177e4SLinus Torvalds } 2294efc683fcSGautam Kachroo next: 2295efc683fcSGautam Kachroo idx++; 22961da177e4SLinus Torvalds } 22971da177e4SLinus Torvalds } 22981da177e4SLinus Torvalds rc = skb->len; 22991da177e4SLinus Torvalds out: 2300d6bf7817SEric Dumazet rcu_read_unlock_bh(); 23011da177e4SLinus Torvalds cb->args[1] = h; 23021da177e4SLinus Torvalds cb->args[2] = idx; 23031da177e4SLinus Torvalds return rc; 23041da177e4SLinus Torvalds } 23051da177e4SLinus Torvalds 230684920c14STony Zelenoff static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 230784920c14STony Zelenoff struct netlink_callback *cb) 230884920c14STony Zelenoff { 230984920c14STony Zelenoff struct pneigh_entry *n; 231084920c14STony Zelenoff struct net *net = sock_net(skb->sk); 231184920c14STony Zelenoff int rc, h, s_h = cb->args[3]; 231284920c14STony Zelenoff int idx, s_idx = idx = cb->args[4]; 231384920c14STony Zelenoff 231484920c14STony Zelenoff read_lock_bh(&tbl->lock); 231584920c14STony Zelenoff 23164bd6683bSEric Dumazet for (h = s_h; h <= PNEIGH_HASHMASK; h++) { 231784920c14STony Zelenoff if (h > s_h) 231884920c14STony Zelenoff s_idx = 0; 231984920c14STony Zelenoff for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) { 232084920c14STony Zelenoff if (dev_net(n->dev) != net) 232184920c14STony Zelenoff continue; 232284920c14STony Zelenoff if (idx < s_idx) 232384920c14STony Zelenoff goto next; 232415e47304SEric W. Biederman if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid, 232584920c14STony Zelenoff cb->nlh->nlmsg_seq, 232684920c14STony Zelenoff RTM_NEWNEIGH, 232784920c14STony Zelenoff NLM_F_MULTI, tbl) <= 0) { 232884920c14STony Zelenoff read_unlock_bh(&tbl->lock); 232984920c14STony Zelenoff rc = -1; 233084920c14STony Zelenoff goto out; 233184920c14STony Zelenoff } 233284920c14STony Zelenoff next: 233384920c14STony Zelenoff idx++; 233484920c14STony Zelenoff } 233584920c14STony Zelenoff } 233684920c14STony Zelenoff 233784920c14STony Zelenoff read_unlock_bh(&tbl->lock); 233884920c14STony Zelenoff rc = skb->len; 233984920c14STony Zelenoff out: 234084920c14STony Zelenoff cb->args[3] = h; 234184920c14STony Zelenoff cb->args[4] = idx; 234284920c14STony Zelenoff return rc; 234384920c14STony Zelenoff 234484920c14STony Zelenoff } 234584920c14STony Zelenoff 2346c8822a4eSThomas Graf static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 23471da177e4SLinus Torvalds { 23481da177e4SLinus Torvalds struct neigh_table *tbl; 23491da177e4SLinus Torvalds int t, family, s_t; 235084920c14STony Zelenoff int proxy = 0; 23514bd6683bSEric Dumazet int err; 23521da177e4SLinus Torvalds 23531da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 23548b8aec50SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 235584920c14STony Zelenoff 235684920c14STony Zelenoff /* check for full ndmsg structure presence, family member is 235784920c14STony Zelenoff * the same for both structures 235884920c14STony Zelenoff */ 235984920c14STony Zelenoff if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) && 236084920c14STony Zelenoff ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY) 236184920c14STony Zelenoff proxy = 1; 236284920c14STony Zelenoff 23631da177e4SLinus Torvalds s_t = cb->args[0]; 23641da177e4SLinus Torvalds 23654bd6683bSEric Dumazet for (tbl = neigh_tables, t = 0; tbl; 236684920c14STony Zelenoff tbl = tbl->next, t++) { 23671da177e4SLinus Torvalds if (t < s_t || (family && tbl->family != family)) 23681da177e4SLinus Torvalds continue; 23691da177e4SLinus Torvalds if (t > s_t) 23701da177e4SLinus Torvalds memset(&cb->args[1], 0, sizeof(cb->args) - 23711da177e4SLinus Torvalds sizeof(cb->args[0])); 237284920c14STony Zelenoff if (proxy) 237384920c14STony Zelenoff err = pneigh_dump_table(tbl, skb, cb); 237484920c14STony Zelenoff else 237584920c14STony Zelenoff err = neigh_dump_table(tbl, skb, cb); 23764bd6683bSEric Dumazet if (err < 0) 23774bd6683bSEric Dumazet break; 23781da177e4SLinus Torvalds } 23791da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 23801da177e4SLinus Torvalds 23811da177e4SLinus Torvalds cb->args[0] = t; 23821da177e4SLinus Torvalds return skb->len; 23831da177e4SLinus Torvalds } 23841da177e4SLinus Torvalds 23851da177e4SLinus Torvalds void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 23861da177e4SLinus Torvalds { 23871da177e4SLinus Torvalds int chain; 2388d6bf7817SEric Dumazet struct neigh_hash_table *nht; 23891da177e4SLinus Torvalds 2390d6bf7817SEric Dumazet rcu_read_lock_bh(); 2391d6bf7817SEric Dumazet nht = rcu_dereference_bh(tbl->nht); 2392d6bf7817SEric Dumazet 2393767e97e1SEric Dumazet read_lock(&tbl->lock); /* avoid resizes */ 2394cd089336SDavid S. Miller for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 23951da177e4SLinus Torvalds struct neighbour *n; 23961da177e4SLinus Torvalds 2397767e97e1SEric Dumazet for (n = rcu_dereference_bh(nht->hash_buckets[chain]); 2398767e97e1SEric Dumazet n != NULL; 2399767e97e1SEric Dumazet n = rcu_dereference_bh(n->next)) 24001da177e4SLinus Torvalds cb(n, cookie); 24011da177e4SLinus Torvalds } 2402d6bf7817SEric Dumazet read_unlock(&tbl->lock); 2403d6bf7817SEric Dumazet rcu_read_unlock_bh(); 24041da177e4SLinus Torvalds } 24051da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_for_each); 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds /* The tbl->lock must be held as a writer and BH disabled. */ 24081da177e4SLinus Torvalds void __neigh_for_each_release(struct neigh_table *tbl, 24091da177e4SLinus Torvalds int (*cb)(struct neighbour *)) 24101da177e4SLinus Torvalds { 24111da177e4SLinus Torvalds int chain; 2412d6bf7817SEric Dumazet struct neigh_hash_table *nht; 24131da177e4SLinus Torvalds 2414d6bf7817SEric Dumazet nht = rcu_dereference_protected(tbl->nht, 2415d6bf7817SEric Dumazet lockdep_is_held(&tbl->lock)); 2416cd089336SDavid S. Miller for (chain = 0; chain < (1 << nht->hash_shift); chain++) { 2417767e97e1SEric Dumazet struct neighbour *n; 2418767e97e1SEric Dumazet struct neighbour __rcu **np; 24191da177e4SLinus Torvalds 2420d6bf7817SEric Dumazet np = &nht->hash_buckets[chain]; 2421767e97e1SEric Dumazet while ((n = rcu_dereference_protected(*np, 2422767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))) != NULL) { 24231da177e4SLinus Torvalds int release; 24241da177e4SLinus Torvalds 24251da177e4SLinus Torvalds write_lock(&n->lock); 24261da177e4SLinus Torvalds release = cb(n); 24271da177e4SLinus Torvalds if (release) { 2428767e97e1SEric Dumazet rcu_assign_pointer(*np, 2429767e97e1SEric Dumazet rcu_dereference_protected(n->next, 2430767e97e1SEric Dumazet lockdep_is_held(&tbl->lock))); 24311da177e4SLinus Torvalds n->dead = 1; 24321da177e4SLinus Torvalds } else 24331da177e4SLinus Torvalds np = &n->next; 24341da177e4SLinus Torvalds write_unlock(&n->lock); 24354f494554SThomas Graf if (release) 24364f494554SThomas Graf neigh_cleanup_and_release(n); 24371da177e4SLinus Torvalds } 24381da177e4SLinus Torvalds } 2439ecbb4169SAlexey Kuznetsov } 24401da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_for_each_release); 24411da177e4SLinus Torvalds 24421da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 24431da177e4SLinus Torvalds 24441da177e4SLinus Torvalds static struct neighbour *neigh_get_first(struct seq_file *seq) 24451da177e4SLinus Torvalds { 24461da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 24471218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 2448d6bf7817SEric Dumazet struct neigh_hash_table *nht = state->nht; 24491da177e4SLinus Torvalds struct neighbour *n = NULL; 24501da177e4SLinus Torvalds int bucket = state->bucket; 24511da177e4SLinus Torvalds 24521da177e4SLinus Torvalds state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 2453cd089336SDavid S. Miller for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) { 2454767e97e1SEric Dumazet n = rcu_dereference_bh(nht->hash_buckets[bucket]); 24551da177e4SLinus Torvalds 24561da177e4SLinus Torvalds while (n) { 2457878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(n->dev), net)) 2458426b5303SEric W. Biederman goto next; 24591da177e4SLinus Torvalds if (state->neigh_sub_iter) { 24601da177e4SLinus Torvalds loff_t fakep = 0; 24611da177e4SLinus Torvalds void *v; 24621da177e4SLinus Torvalds 24631da177e4SLinus Torvalds v = state->neigh_sub_iter(state, n, &fakep); 24641da177e4SLinus Torvalds if (!v) 24651da177e4SLinus Torvalds goto next; 24661da177e4SLinus Torvalds } 24671da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 24681da177e4SLinus Torvalds break; 24691da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 24701da177e4SLinus Torvalds break; 24711da177e4SLinus Torvalds next: 2472767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 24731da177e4SLinus Torvalds } 24741da177e4SLinus Torvalds 24751da177e4SLinus Torvalds if (n) 24761da177e4SLinus Torvalds break; 24771da177e4SLinus Torvalds } 24781da177e4SLinus Torvalds state->bucket = bucket; 24791da177e4SLinus Torvalds 24801da177e4SLinus Torvalds return n; 24811da177e4SLinus Torvalds } 24821da177e4SLinus Torvalds 24831da177e4SLinus Torvalds static struct neighbour *neigh_get_next(struct seq_file *seq, 24841da177e4SLinus Torvalds struct neighbour *n, 24851da177e4SLinus Torvalds loff_t *pos) 24861da177e4SLinus Torvalds { 24871da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 24881218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 2489d6bf7817SEric Dumazet struct neigh_hash_table *nht = state->nht; 24901da177e4SLinus Torvalds 24911da177e4SLinus Torvalds if (state->neigh_sub_iter) { 24921da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 24931da177e4SLinus Torvalds if (v) 24941da177e4SLinus Torvalds return n; 24951da177e4SLinus Torvalds } 2496767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 24971da177e4SLinus Torvalds 24981da177e4SLinus Torvalds while (1) { 24991da177e4SLinus Torvalds while (n) { 2500878628fbSYOSHIFUJI Hideaki if (!net_eq(dev_net(n->dev), net)) 2501426b5303SEric W. Biederman goto next; 25021da177e4SLinus Torvalds if (state->neigh_sub_iter) { 25031da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 25041da177e4SLinus Torvalds if (v) 25051da177e4SLinus Torvalds return n; 25061da177e4SLinus Torvalds goto next; 25071da177e4SLinus Torvalds } 25081da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 25091da177e4SLinus Torvalds break; 25101da177e4SLinus Torvalds 25111da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 25121da177e4SLinus Torvalds break; 25131da177e4SLinus Torvalds next: 2514767e97e1SEric Dumazet n = rcu_dereference_bh(n->next); 25151da177e4SLinus Torvalds } 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds if (n) 25181da177e4SLinus Torvalds break; 25191da177e4SLinus Torvalds 2520cd089336SDavid S. Miller if (++state->bucket >= (1 << nht->hash_shift)) 25211da177e4SLinus Torvalds break; 25221da177e4SLinus Torvalds 2523767e97e1SEric Dumazet n = rcu_dereference_bh(nht->hash_buckets[state->bucket]); 25241da177e4SLinus Torvalds } 25251da177e4SLinus Torvalds 25261da177e4SLinus Torvalds if (n && pos) 25271da177e4SLinus Torvalds --(*pos); 25281da177e4SLinus Torvalds return n; 25291da177e4SLinus Torvalds } 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 25321da177e4SLinus Torvalds { 25331da177e4SLinus Torvalds struct neighbour *n = neigh_get_first(seq); 25341da177e4SLinus Torvalds 25351da177e4SLinus Torvalds if (n) { 2536745e2031SChris Larson --(*pos); 25371da177e4SLinus Torvalds while (*pos) { 25381da177e4SLinus Torvalds n = neigh_get_next(seq, n, pos); 25391da177e4SLinus Torvalds if (!n) 25401da177e4SLinus Torvalds break; 25411da177e4SLinus Torvalds } 25421da177e4SLinus Torvalds } 25431da177e4SLinus Torvalds return *pos ? NULL : n; 25441da177e4SLinus Torvalds } 25451da177e4SLinus Torvalds 25461da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 25471da177e4SLinus Torvalds { 25481da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 25491218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 25501da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 25511da177e4SLinus Torvalds struct pneigh_entry *pn = NULL; 25521da177e4SLinus Torvalds int bucket = state->bucket; 25531da177e4SLinus Torvalds 25541da177e4SLinus Torvalds state->flags |= NEIGH_SEQ_IS_PNEIGH; 25551da177e4SLinus Torvalds for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 25561da177e4SLinus Torvalds pn = tbl->phash_buckets[bucket]; 2557878628fbSYOSHIFUJI Hideaki while (pn && !net_eq(pneigh_net(pn), net)) 2558426b5303SEric W. Biederman pn = pn->next; 25591da177e4SLinus Torvalds if (pn) 25601da177e4SLinus Torvalds break; 25611da177e4SLinus Torvalds } 25621da177e4SLinus Torvalds state->bucket = bucket; 25631da177e4SLinus Torvalds 25641da177e4SLinus Torvalds return pn; 25651da177e4SLinus Torvalds } 25661da177e4SLinus Torvalds 25671da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 25681da177e4SLinus Torvalds struct pneigh_entry *pn, 25691da177e4SLinus Torvalds loff_t *pos) 25701da177e4SLinus Torvalds { 25711da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 25721218854aSYOSHIFUJI Hideaki struct net *net = seq_file_net(seq); 25731da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 25741da177e4SLinus Torvalds 2575df07a94cSJorge Boncompte [DTI2] do { 25761da177e4SLinus Torvalds pn = pn->next; 2577df07a94cSJorge Boncompte [DTI2] } while (pn && !net_eq(pneigh_net(pn), net)); 2578df07a94cSJorge Boncompte [DTI2] 25791da177e4SLinus Torvalds while (!pn) { 25801da177e4SLinus Torvalds if (++state->bucket > PNEIGH_HASHMASK) 25811da177e4SLinus Torvalds break; 25821da177e4SLinus Torvalds pn = tbl->phash_buckets[state->bucket]; 2583878628fbSYOSHIFUJI Hideaki while (pn && !net_eq(pneigh_net(pn), net)) 2584426b5303SEric W. Biederman pn = pn->next; 25851da177e4SLinus Torvalds if (pn) 25861da177e4SLinus Torvalds break; 25871da177e4SLinus Torvalds } 25881da177e4SLinus Torvalds 25891da177e4SLinus Torvalds if (pn && pos) 25901da177e4SLinus Torvalds --(*pos); 25911da177e4SLinus Torvalds 25921da177e4SLinus Torvalds return pn; 25931da177e4SLinus Torvalds } 25941da177e4SLinus Torvalds 25951da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 25961da177e4SLinus Torvalds { 25971da177e4SLinus Torvalds struct pneigh_entry *pn = pneigh_get_first(seq); 25981da177e4SLinus Torvalds 25991da177e4SLinus Torvalds if (pn) { 2600745e2031SChris Larson --(*pos); 26011da177e4SLinus Torvalds while (*pos) { 26021da177e4SLinus Torvalds pn = pneigh_get_next(seq, pn, pos); 26031da177e4SLinus Torvalds if (!pn) 26041da177e4SLinus Torvalds break; 26051da177e4SLinus Torvalds } 26061da177e4SLinus Torvalds } 26071da177e4SLinus Torvalds return *pos ? NULL : pn; 26081da177e4SLinus Torvalds } 26091da177e4SLinus Torvalds 26101da177e4SLinus Torvalds static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 26111da177e4SLinus Torvalds { 26121da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 26131da177e4SLinus Torvalds void *rc; 2614745e2031SChris Larson loff_t idxpos = *pos; 26151da177e4SLinus Torvalds 2616745e2031SChris Larson rc = neigh_get_idx(seq, &idxpos); 26171da177e4SLinus Torvalds if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 2618745e2031SChris Larson rc = pneigh_get_idx(seq, &idxpos); 26191da177e4SLinus Torvalds 26201da177e4SLinus Torvalds return rc; 26211da177e4SLinus Torvalds } 26221da177e4SLinus Torvalds 26231da177e4SLinus Torvalds void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 2624d6bf7817SEric Dumazet __acquires(rcu_bh) 26251da177e4SLinus Torvalds { 26261da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 26271da177e4SLinus Torvalds 26281da177e4SLinus Torvalds state->tbl = tbl; 26291da177e4SLinus Torvalds state->bucket = 0; 26301da177e4SLinus Torvalds state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 26311da177e4SLinus Torvalds 2632d6bf7817SEric Dumazet rcu_read_lock_bh(); 2633d6bf7817SEric Dumazet state->nht = rcu_dereference_bh(tbl->nht); 2634767e97e1SEric Dumazet 2635745e2031SChris Larson return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN; 26361da177e4SLinus Torvalds } 26371da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_start); 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 26401da177e4SLinus Torvalds { 26411da177e4SLinus Torvalds struct neigh_seq_state *state; 26421da177e4SLinus Torvalds void *rc; 26431da177e4SLinus Torvalds 26441da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 2645bff69732SChris Larson rc = neigh_get_first(seq); 26461da177e4SLinus Torvalds goto out; 26471da177e4SLinus Torvalds } 26481da177e4SLinus Torvalds 26491da177e4SLinus Torvalds state = seq->private; 26501da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 26511da177e4SLinus Torvalds rc = neigh_get_next(seq, v, NULL); 26521da177e4SLinus Torvalds if (rc) 26531da177e4SLinus Torvalds goto out; 26541da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 26551da177e4SLinus Torvalds rc = pneigh_get_first(seq); 26561da177e4SLinus Torvalds } else { 26571da177e4SLinus Torvalds BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 26581da177e4SLinus Torvalds rc = pneigh_get_next(seq, v, NULL); 26591da177e4SLinus Torvalds } 26601da177e4SLinus Torvalds out: 26611da177e4SLinus Torvalds ++(*pos); 26621da177e4SLinus Torvalds return rc; 26631da177e4SLinus Torvalds } 26641da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_next); 26651da177e4SLinus Torvalds 26661da177e4SLinus Torvalds void neigh_seq_stop(struct seq_file *seq, void *v) 2667d6bf7817SEric Dumazet __releases(rcu_bh) 26681da177e4SLinus Torvalds { 2669d6bf7817SEric Dumazet rcu_read_unlock_bh(); 26701da177e4SLinus Torvalds } 26711da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_stop); 26721da177e4SLinus Torvalds 26731da177e4SLinus Torvalds /* statistics via seq_file */ 26741da177e4SLinus Torvalds 26751da177e4SLinus Torvalds static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 26761da177e4SLinus Torvalds { 267781c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 26781da177e4SLinus Torvalds int cpu; 26791da177e4SLinus Torvalds 26801da177e4SLinus Torvalds if (*pos == 0) 26811da177e4SLinus Torvalds return SEQ_START_TOKEN; 26821da177e4SLinus Torvalds 26830f23174aSRusty Russell for (cpu = *pos-1; 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_next(struct seq_file *seq, void *v, loff_t *pos) 26931da177e4SLinus Torvalds { 269481c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 26951da177e4SLinus Torvalds int cpu; 26961da177e4SLinus Torvalds 26970f23174aSRusty Russell for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) { 26981da177e4SLinus Torvalds if (!cpu_possible(cpu)) 26991da177e4SLinus Torvalds continue; 27001da177e4SLinus Torvalds *pos = cpu+1; 27011da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 27021da177e4SLinus Torvalds } 27031da177e4SLinus Torvalds return NULL; 27041da177e4SLinus Torvalds } 27051da177e4SLinus Torvalds 27061da177e4SLinus Torvalds static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 27071da177e4SLinus Torvalds { 27081da177e4SLinus Torvalds 27091da177e4SLinus Torvalds } 27101da177e4SLinus Torvalds 27111da177e4SLinus Torvalds static int neigh_stat_seq_show(struct seq_file *seq, void *v) 27121da177e4SLinus Torvalds { 271381c1ebfcSAlexey Dobriyan struct neigh_table *tbl = seq->private; 27141da177e4SLinus Torvalds struct neigh_statistics *st = v; 27151da177e4SLinus Torvalds 27161da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 27179a6d276eSNeil 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"); 27181da177e4SLinus Torvalds return 0; 27191da177e4SLinus Torvalds } 27201da177e4SLinus Torvalds 27211da177e4SLinus Torvalds seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 27229a6d276eSNeil Horman "%08lx %08lx %08lx %08lx %08lx\n", 27231da177e4SLinus Torvalds atomic_read(&tbl->entries), 27241da177e4SLinus Torvalds 27251da177e4SLinus Torvalds st->allocs, 27261da177e4SLinus Torvalds st->destroys, 27271da177e4SLinus Torvalds st->hash_grows, 27281da177e4SLinus Torvalds 27291da177e4SLinus Torvalds st->lookups, 27301da177e4SLinus Torvalds st->hits, 27311da177e4SLinus Torvalds 27321da177e4SLinus Torvalds st->res_failed, 27331da177e4SLinus Torvalds 27341da177e4SLinus Torvalds st->rcv_probes_mcast, 27351da177e4SLinus Torvalds st->rcv_probes_ucast, 27361da177e4SLinus Torvalds 27371da177e4SLinus Torvalds st->periodic_gc_runs, 27389a6d276eSNeil Horman st->forced_gc_runs, 27399a6d276eSNeil Horman st->unres_discards 27401da177e4SLinus Torvalds ); 27411da177e4SLinus Torvalds 27421da177e4SLinus Torvalds return 0; 27431da177e4SLinus Torvalds } 27441da177e4SLinus Torvalds 2745f690808eSStephen Hemminger static const struct seq_operations neigh_stat_seq_ops = { 27461da177e4SLinus Torvalds .start = neigh_stat_seq_start, 27471da177e4SLinus Torvalds .next = neigh_stat_seq_next, 27481da177e4SLinus Torvalds .stop = neigh_stat_seq_stop, 27491da177e4SLinus Torvalds .show = neigh_stat_seq_show, 27501da177e4SLinus Torvalds }; 27511da177e4SLinus Torvalds 27521da177e4SLinus Torvalds static int neigh_stat_seq_open(struct inode *inode, struct file *file) 27531da177e4SLinus Torvalds { 27541da177e4SLinus Torvalds int ret = seq_open(file, &neigh_stat_seq_ops); 27551da177e4SLinus Torvalds 27561da177e4SLinus Torvalds if (!ret) { 27571da177e4SLinus Torvalds struct seq_file *sf = file->private_data; 2758d9dda78bSAl Viro sf->private = PDE_DATA(inode); 27591da177e4SLinus Torvalds } 27601da177e4SLinus Torvalds return ret; 27611da177e4SLinus Torvalds }; 27621da177e4SLinus Torvalds 27639a32144eSArjan van de Ven static const struct file_operations neigh_stat_seq_fops = { 27641da177e4SLinus Torvalds .owner = THIS_MODULE, 27651da177e4SLinus Torvalds .open = neigh_stat_seq_open, 27661da177e4SLinus Torvalds .read = seq_read, 27671da177e4SLinus Torvalds .llseek = seq_lseek, 27681da177e4SLinus Torvalds .release = seq_release, 27691da177e4SLinus Torvalds }; 27701da177e4SLinus Torvalds 27711da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 27721da177e4SLinus Torvalds 2773339bf98fSThomas Graf static inline size_t neigh_nlmsg_size(void) 2774339bf98fSThomas Graf { 2775339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ndmsg)) 2776339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2777339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2778339bf98fSThomas Graf + nla_total_size(sizeof(struct nda_cacheinfo)) 2779339bf98fSThomas Graf + nla_total_size(4); /* NDA_PROBES */ 2780339bf98fSThomas Graf } 2781339bf98fSThomas Graf 2782b8673311SThomas Graf static void __neigh_notify(struct neighbour *n, int type, int flags) 27831da177e4SLinus Torvalds { 2784c346dca1SYOSHIFUJI Hideaki struct net *net = dev_net(n->dev); 27858b8aec50SThomas Graf struct sk_buff *skb; 2786b8673311SThomas Graf int err = -ENOBUFS; 27871da177e4SLinus Torvalds 2788339bf98fSThomas Graf skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 27898b8aec50SThomas Graf if (skb == NULL) 2790b8673311SThomas Graf goto errout; 27911da177e4SLinus Torvalds 2792b8673311SThomas Graf err = neigh_fill_info(skb, n, 0, 0, type, flags); 279326932566SPatrick McHardy if (err < 0) { 279426932566SPatrick McHardy /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */ 279526932566SPatrick McHardy WARN_ON(err == -EMSGSIZE); 279626932566SPatrick McHardy kfree_skb(skb); 279726932566SPatrick McHardy goto errout; 279826932566SPatrick McHardy } 27991ce85fe4SPablo Neira Ayuso rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 28001ce85fe4SPablo Neira Ayuso return; 2801b8673311SThomas Graf errout: 2802b8673311SThomas Graf if (err < 0) 2803426b5303SEric W. Biederman rtnl_set_sk_err(net, RTNLGRP_NEIGH, err); 2804b8673311SThomas Graf } 2805b8673311SThomas Graf 2806b8673311SThomas Graf void neigh_app_ns(struct neighbour *n) 2807b8673311SThomas Graf { 2808b8673311SThomas Graf __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST); 28098b8aec50SThomas Graf } 28100a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_app_ns); 28111da177e4SLinus Torvalds 28121da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 2813b93196dcSCong Wang static int zero; 2814555445cdSFrancesco Fusco static int int_max = INT_MAX; 2815b93196dcSCong Wang static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN); 28161da177e4SLinus Torvalds 2817fe2c6338SJoe Perches static int proc_unres_qlen(struct ctl_table *ctl, int write, 2818fe2c6338SJoe Perches void __user *buffer, size_t *lenp, loff_t *ppos) 28198b5c171bSEric Dumazet { 28208b5c171bSEric Dumazet int size, ret; 2821fe2c6338SJoe Perches struct ctl_table tmp = *ctl; 28228b5c171bSEric Dumazet 2823ce46cc64SShan Wei tmp.extra1 = &zero; 2824ce46cc64SShan Wei tmp.extra2 = &unres_qlen_max; 28258b5c171bSEric Dumazet tmp.data = &size; 2826ce46cc64SShan Wei 2827ce46cc64SShan Wei size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN); 2828ce46cc64SShan Wei ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 2829ce46cc64SShan Wei 28308b5c171bSEric Dumazet if (write && !ret) 28318b5c171bSEric Dumazet *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN); 28328b5c171bSEric Dumazet return ret; 28338b5c171bSEric Dumazet } 28348b5c171bSEric Dumazet 28351d4c8c29SJiri Pirko static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev, 28361d4c8c29SJiri Pirko int family) 28371d4c8c29SJiri Pirko { 2838bba24896SJiri Pirko switch (family) { 2839bba24896SJiri Pirko case AF_INET: 28401d4c8c29SJiri Pirko return __in_dev_arp_parms_get_rcu(dev); 2841bba24896SJiri Pirko case AF_INET6: 2842bba24896SJiri Pirko return __in6_dev_nd_parms_get_rcu(dev); 2843bba24896SJiri Pirko } 28441d4c8c29SJiri Pirko return NULL; 28451d4c8c29SJiri Pirko } 28461d4c8c29SJiri Pirko 28471d4c8c29SJiri Pirko static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p, 28481d4c8c29SJiri Pirko int index) 28491d4c8c29SJiri Pirko { 28501d4c8c29SJiri Pirko struct net_device *dev; 28511d4c8c29SJiri Pirko int family = neigh_parms_family(p); 28521d4c8c29SJiri Pirko 28531d4c8c29SJiri Pirko rcu_read_lock(); 28541d4c8c29SJiri Pirko for_each_netdev_rcu(net, dev) { 28551d4c8c29SJiri Pirko struct neigh_parms *dst_p = 28561d4c8c29SJiri Pirko neigh_get_dev_parms_rcu(dev, family); 28571d4c8c29SJiri Pirko 28581d4c8c29SJiri Pirko if (dst_p && !test_bit(index, dst_p->data_state)) 28591d4c8c29SJiri Pirko dst_p->data[index] = p->data[index]; 28601d4c8c29SJiri Pirko } 28611d4c8c29SJiri Pirko rcu_read_unlock(); 28621d4c8c29SJiri Pirko } 28631d4c8c29SJiri Pirko 28641d4c8c29SJiri Pirko static void neigh_proc_update(struct ctl_table *ctl, int write) 28651d4c8c29SJiri Pirko { 28661d4c8c29SJiri Pirko struct net_device *dev = ctl->extra1; 28671d4c8c29SJiri Pirko struct neigh_parms *p = ctl->extra2; 286877d47afbSJiri Pirko struct net *net = neigh_parms_net(p); 28691d4c8c29SJiri Pirko int index = (int *) ctl->data - p->data; 28701d4c8c29SJiri Pirko 28711d4c8c29SJiri Pirko if (!write) 28721d4c8c29SJiri Pirko return; 28731d4c8c29SJiri Pirko 28741d4c8c29SJiri Pirko set_bit(index, p->data_state); 28751d4c8c29SJiri Pirko if (!dev) /* NULL dev means this is default value */ 28761d4c8c29SJiri Pirko neigh_copy_dflt_parms(net, p, index); 28771d4c8c29SJiri Pirko } 28781d4c8c29SJiri Pirko 28791f9248e5SJiri Pirko static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write, 28801f9248e5SJiri Pirko void __user *buffer, 28811f9248e5SJiri Pirko size_t *lenp, loff_t *ppos) 28821f9248e5SJiri Pirko { 28831f9248e5SJiri Pirko struct ctl_table tmp = *ctl; 28841d4c8c29SJiri Pirko int ret; 28851f9248e5SJiri Pirko 28861f9248e5SJiri Pirko tmp.extra1 = &zero; 28871f9248e5SJiri Pirko tmp.extra2 = &int_max; 28881f9248e5SJiri Pirko 28891d4c8c29SJiri Pirko ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 28901d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 28911d4c8c29SJiri Pirko return ret; 28921f9248e5SJiri Pirko } 28931f9248e5SJiri Pirko 2894cb5b09c1SJiri Pirko int neigh_proc_dointvec(struct ctl_table *ctl, int write, 2895cb5b09c1SJiri Pirko void __user *buffer, size_t *lenp, loff_t *ppos) 2896cb5b09c1SJiri Pirko { 28971d4c8c29SJiri Pirko int ret = proc_dointvec(ctl, write, buffer, lenp, ppos); 28981d4c8c29SJiri Pirko 28991d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29001d4c8c29SJiri Pirko return ret; 2901cb5b09c1SJiri Pirko } 2902cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec); 2903cb5b09c1SJiri Pirko 2904cb5b09c1SJiri Pirko int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write, 2905cb5b09c1SJiri Pirko void __user *buffer, 2906cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2907cb5b09c1SJiri Pirko { 29081d4c8c29SJiri Pirko int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos); 29091d4c8c29SJiri Pirko 29101d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29111d4c8c29SJiri Pirko return ret; 2912cb5b09c1SJiri Pirko } 2913cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec_jiffies); 2914cb5b09c1SJiri Pirko 2915cb5b09c1SJiri Pirko static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write, 2916cb5b09c1SJiri Pirko void __user *buffer, 2917cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2918cb5b09c1SJiri Pirko { 29191d4c8c29SJiri Pirko int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos); 29201d4c8c29SJiri Pirko 29211d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29221d4c8c29SJiri Pirko return ret; 2923cb5b09c1SJiri Pirko } 2924cb5b09c1SJiri Pirko 2925cb5b09c1SJiri Pirko int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write, 2926cb5b09c1SJiri Pirko void __user *buffer, 2927cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2928cb5b09c1SJiri Pirko { 29291d4c8c29SJiri Pirko int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos); 29301d4c8c29SJiri Pirko 29311d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29321d4c8c29SJiri Pirko return ret; 2933cb5b09c1SJiri Pirko } 2934cb5b09c1SJiri Pirko EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies); 2935cb5b09c1SJiri Pirko 2936cb5b09c1SJiri Pirko static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write, 2937cb5b09c1SJiri Pirko void __user *buffer, 2938cb5b09c1SJiri Pirko size_t *lenp, loff_t *ppos) 2939cb5b09c1SJiri Pirko { 29401d4c8c29SJiri Pirko int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos); 29411d4c8c29SJiri Pirko 29421d4c8c29SJiri Pirko neigh_proc_update(ctl, write); 29431d4c8c29SJiri Pirko return ret; 2944cb5b09c1SJiri Pirko } 2945cb5b09c1SJiri Pirko 29461f9248e5SJiri Pirko #define NEIGH_PARMS_DATA_OFFSET(index) \ 29471f9248e5SJiri Pirko (&((struct neigh_parms *) 0)->data[index]) 29481f9248e5SJiri Pirko 29491f9248e5SJiri Pirko #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \ 29501f9248e5SJiri Pirko [NEIGH_VAR_ ## attr] = { \ 29511f9248e5SJiri Pirko .procname = name, \ 29521f9248e5SJiri Pirko .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \ 29531f9248e5SJiri Pirko .maxlen = sizeof(int), \ 29541f9248e5SJiri Pirko .mode = mval, \ 29551f9248e5SJiri Pirko .proc_handler = proc, \ 29561f9248e5SJiri Pirko } 29571f9248e5SJiri Pirko 29581f9248e5SJiri Pirko #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \ 29591f9248e5SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax) 29601f9248e5SJiri Pirko 29611f9248e5SJiri Pirko #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \ 2962cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies) 29631f9248e5SJiri Pirko 29641f9248e5SJiri Pirko #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \ 2965cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies) 29661f9248e5SJiri Pirko 29671f9248e5SJiri Pirko #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \ 2968cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 29691f9248e5SJiri Pirko 29701f9248e5SJiri Pirko #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \ 2971cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies) 29721f9248e5SJiri Pirko 29731f9248e5SJiri Pirko #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \ 2974cb5b09c1SJiri Pirko NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen) 297554716e3bSEric W. Biederman 29761da177e4SLinus Torvalds static struct neigh_sysctl_table { 29771da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 29788b5c171bSEric Dumazet struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1]; 2979ab32ea5dSBrian Haley } neigh_sysctl_template __read_mostly = { 29801da177e4SLinus Torvalds .neigh_vars = { 29811f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"), 29821f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"), 29831f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"), 29841f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"), 29851f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"), 29861f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"), 29871f9248e5SJiri Pirko NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"), 29881f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"), 29891f9248e5SJiri Pirko NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"), 29901f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"), 29911f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"), 29921f9248e5SJiri Pirko NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"), 29931f9248e5SJiri Pirko NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"), 29941f9248e5SJiri Pirko NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"), 29951f9248e5SJiri Pirko NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"), 29968b5c171bSEric Dumazet [NEIGH_VAR_GC_INTERVAL] = { 29971da177e4SLinus Torvalds .procname = "gc_interval", 29981da177e4SLinus Torvalds .maxlen = sizeof(int), 29991da177e4SLinus Torvalds .mode = 0644, 30006d9f239aSAlexey Dobriyan .proc_handler = proc_dointvec_jiffies, 30011da177e4SLinus Torvalds }, 30028b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH1] = { 30031da177e4SLinus Torvalds .procname = "gc_thresh1", 30041da177e4SLinus Torvalds .maxlen = sizeof(int), 30051da177e4SLinus Torvalds .mode = 0644, 3006555445cdSFrancesco Fusco .extra1 = &zero, 3007555445cdSFrancesco Fusco .extra2 = &int_max, 3008555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30091da177e4SLinus Torvalds }, 30108b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH2] = { 30111da177e4SLinus Torvalds .procname = "gc_thresh2", 30121da177e4SLinus Torvalds .maxlen = sizeof(int), 30131da177e4SLinus Torvalds .mode = 0644, 3014555445cdSFrancesco Fusco .extra1 = &zero, 3015555445cdSFrancesco Fusco .extra2 = &int_max, 3016555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30171da177e4SLinus Torvalds }, 30188b5c171bSEric Dumazet [NEIGH_VAR_GC_THRESH3] = { 30191da177e4SLinus Torvalds .procname = "gc_thresh3", 30201da177e4SLinus Torvalds .maxlen = sizeof(int), 30211da177e4SLinus Torvalds .mode = 0644, 3022555445cdSFrancesco Fusco .extra1 = &zero, 3023555445cdSFrancesco Fusco .extra2 = &int_max, 3024555445cdSFrancesco Fusco .proc_handler = proc_dointvec_minmax, 30251da177e4SLinus Torvalds }, 3026c3bac5a7SPavel Emelyanov {}, 30271da177e4SLinus Torvalds }, 30281da177e4SLinus Torvalds }; 30291da177e4SLinus Torvalds 30301da177e4SLinus Torvalds int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 303173af614aSJiri Pirko proc_handler *handler) 30321da177e4SLinus Torvalds { 30331f9248e5SJiri Pirko int i; 30343c607bbbSPavel Emelyanov struct neigh_sysctl_table *t; 30351f9248e5SJiri Pirko const char *dev_name_source; 30368f40a1f9SEric W. Biederman char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ]; 303773af614aSJiri Pirko char *p_name; 30381da177e4SLinus Torvalds 30393c607bbbSPavel Emelyanov t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL); 30401da177e4SLinus Torvalds if (!t) 30413c607bbbSPavel Emelyanov goto err; 30423c607bbbSPavel Emelyanov 3043cb5b09c1SJiri Pirko for (i = 0; i < ARRAY_SIZE(t->neigh_vars); i++) { 30441f9248e5SJiri Pirko t->neigh_vars[i].data += (long) p; 3045cb5b09c1SJiri Pirko t->neigh_vars[i].extra1 = dev; 30461d4c8c29SJiri Pirko t->neigh_vars[i].extra2 = p; 3047cb5b09c1SJiri Pirko } 30481da177e4SLinus Torvalds 30491da177e4SLinus Torvalds if (dev) { 30501da177e4SLinus Torvalds dev_name_source = dev->name; 3051d12af679SEric W. Biederman /* Terminate the table early */ 30528b5c171bSEric Dumazet memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0, 30538b5c171bSEric Dumazet sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL])); 30541da177e4SLinus Torvalds } else { 30558f40a1f9SEric W. Biederman dev_name_source = "default"; 30568b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = (int *)(p + 1); 30578b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = (int *)(p + 1) + 1; 30588b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = (int *)(p + 1) + 2; 30598b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = (int *)(p + 1) + 3; 30601da177e4SLinus Torvalds } 30611da177e4SLinus Torvalds 3062f8572d8fSEric W. Biederman if (handler) { 30631da177e4SLinus Torvalds /* RetransTime */ 30648b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler; 30651da177e4SLinus Torvalds /* ReachableTime */ 30668b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler; 30671da177e4SLinus Torvalds /* RetransTime (in milliseconds)*/ 30688b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler; 30691da177e4SLinus Torvalds /* ReachableTime (in milliseconds) */ 30708b5c171bSEric Dumazet t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler; 30711da177e4SLinus Torvalds } 30721da177e4SLinus Torvalds 3073464dc801SEric W. Biederman /* Don't export sysctls to unprivileged users */ 3074464dc801SEric W. Biederman if (neigh_parms_net(p)->user_ns != &init_user_ns) 3075464dc801SEric W. Biederman t->neigh_vars[0].procname = NULL; 3076464dc801SEric W. Biederman 307773af614aSJiri Pirko switch (neigh_parms_family(p)) { 307873af614aSJiri Pirko case AF_INET: 307973af614aSJiri Pirko p_name = "ipv4"; 308073af614aSJiri Pirko break; 308173af614aSJiri Pirko case AF_INET6: 308273af614aSJiri Pirko p_name = "ipv6"; 308373af614aSJiri Pirko break; 308473af614aSJiri Pirko default: 308573af614aSJiri Pirko BUG(); 308673af614aSJiri Pirko } 308773af614aSJiri Pirko 30888f40a1f9SEric W. Biederman snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s", 30898f40a1f9SEric W. Biederman p_name, dev_name_source); 30904ab438fcSDenis V. Lunev t->sysctl_header = 30918f40a1f9SEric W. Biederman register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars); 30923c607bbbSPavel Emelyanov if (!t->sysctl_header) 30938f40a1f9SEric W. Biederman goto free; 30943c607bbbSPavel Emelyanov 30951da177e4SLinus Torvalds p->sysctl_table = t; 30961da177e4SLinus Torvalds return 0; 30971da177e4SLinus Torvalds 30981da177e4SLinus Torvalds free: 30991da177e4SLinus Torvalds kfree(t); 31003c607bbbSPavel Emelyanov err: 31013c607bbbSPavel Emelyanov return -ENOBUFS; 31021da177e4SLinus Torvalds } 31030a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_sysctl_register); 31041da177e4SLinus Torvalds 31051da177e4SLinus Torvalds void neigh_sysctl_unregister(struct neigh_parms *p) 31061da177e4SLinus Torvalds { 31071da177e4SLinus Torvalds if (p->sysctl_table) { 31081da177e4SLinus Torvalds struct neigh_sysctl_table *t = p->sysctl_table; 31091da177e4SLinus Torvalds p->sysctl_table = NULL; 31105dd3df10SEric W. Biederman unregister_net_sysctl_table(t->sysctl_header); 31111da177e4SLinus Torvalds kfree(t); 31121da177e4SLinus Torvalds } 31131da177e4SLinus Torvalds } 31140a204500SYOSHIFUJI Hideaki EXPORT_SYMBOL(neigh_sysctl_unregister); 31151da177e4SLinus Torvalds 31161da177e4SLinus Torvalds #endif /* CONFIG_SYSCTL */ 31171da177e4SLinus Torvalds 3118c8822a4eSThomas Graf static int __init neigh_init(void) 3119c8822a4eSThomas Graf { 3120c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL); 3121c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL); 3122c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL); 3123c8822a4eSThomas Graf 3124c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info, 3125c7ac8679SGreg Rose NULL); 3126c7ac8679SGreg Rose rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL); 3127c8822a4eSThomas Graf 3128c8822a4eSThomas Graf return 0; 3129c8822a4eSThomas Graf } 3130c8822a4eSThomas Graf 3131c8822a4eSThomas Graf subsys_initcall(neigh_init); 3132c8822a4eSThomas Graf 3133