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 181da177e4SLinus Torvalds #include <linux/types.h> 191da177e4SLinus Torvalds #include <linux/kernel.h> 201da177e4SLinus Torvalds #include <linux/module.h> 211da177e4SLinus Torvalds #include <linux/socket.h> 221da177e4SLinus Torvalds #include <linux/sched.h> 231da177e4SLinus Torvalds #include <linux/netdevice.h> 241da177e4SLinus Torvalds #include <linux/proc_fs.h> 251da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 261da177e4SLinus Torvalds #include <linux/sysctl.h> 271da177e4SLinus Torvalds #endif 281da177e4SLinus Torvalds #include <linux/times.h> 291da177e4SLinus Torvalds #include <net/neighbour.h> 301da177e4SLinus Torvalds #include <net/dst.h> 311da177e4SLinus Torvalds #include <net/sock.h> 328d71740cSTom Tucker #include <net/netevent.h> 33a14a49d2SThomas Graf #include <net/netlink.h> 341da177e4SLinus Torvalds #include <linux/rtnetlink.h> 351da177e4SLinus Torvalds #include <linux/random.h> 36543537bdSPaulo Marques #include <linux/string.h> 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds #define NEIGH_DEBUG 1 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds #define NEIGH_PRINTK(x...) printk(x) 411da177e4SLinus Torvalds #define NEIGH_NOPRINTK(x...) do { ; } while(0) 421da177e4SLinus Torvalds #define NEIGH_PRINTK0 NEIGH_PRINTK 431da177e4SLinus Torvalds #define NEIGH_PRINTK1 NEIGH_NOPRINTK 441da177e4SLinus Torvalds #define NEIGH_PRINTK2 NEIGH_NOPRINTK 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds #if NEIGH_DEBUG >= 1 471da177e4SLinus Torvalds #undef NEIGH_PRINTK1 481da177e4SLinus Torvalds #define NEIGH_PRINTK1 NEIGH_PRINTK 491da177e4SLinus Torvalds #endif 501da177e4SLinus Torvalds #if NEIGH_DEBUG >= 2 511da177e4SLinus Torvalds #undef NEIGH_PRINTK2 521da177e4SLinus Torvalds #define NEIGH_PRINTK2 NEIGH_PRINTK 531da177e4SLinus Torvalds #endif 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds #define PNEIGH_HASHMASK 0xF 561da177e4SLinus Torvalds 571da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg); 581da177e4SLinus Torvalds #ifdef CONFIG_ARPD 591da177e4SLinus Torvalds static void neigh_app_notify(struct neighbour *n); 601da177e4SLinus Torvalds #endif 611da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev); 621da177e4SLinus Torvalds void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); 631da177e4SLinus Torvalds 641da177e4SLinus Torvalds static struct neigh_table *neigh_tables; 6545fc3b11SAmos Waterland #ifdef CONFIG_PROC_FS 661da177e4SLinus Torvalds static struct file_operations neigh_stat_seq_fops; 6745fc3b11SAmos Waterland #endif 681da177e4SLinus Torvalds 691da177e4SLinus Torvalds /* 701da177e4SLinus Torvalds Neighbour hash table buckets are protected with rwlock tbl->lock. 711da177e4SLinus Torvalds 721da177e4SLinus Torvalds - All the scans/updates to hash buckets MUST be made under this lock. 731da177e4SLinus Torvalds - NOTHING clever should be made under this lock: no callbacks 741da177e4SLinus Torvalds to protocol backends, no attempts to send something to network. 751da177e4SLinus Torvalds It will result in deadlocks, if backend/driver wants to use neighbour 761da177e4SLinus Torvalds cache. 771da177e4SLinus Torvalds - If the entry requires some non-trivial actions, increase 781da177e4SLinus Torvalds its reference count and release table lock. 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds Neighbour entries are protected: 811da177e4SLinus Torvalds - with reference count. 821da177e4SLinus Torvalds - with rwlock neigh->lock 831da177e4SLinus Torvalds 841da177e4SLinus Torvalds Reference count prevents destruction. 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds neigh->lock mainly serializes ll address data and its validity state. 871da177e4SLinus Torvalds However, the same lock is used to protect another entry fields: 881da177e4SLinus Torvalds - timer 891da177e4SLinus Torvalds - resolution queue 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds Again, nothing clever shall be made under neigh->lock, 921da177e4SLinus Torvalds the most complicated procedure, which we allow is dev->hard_header. 931da177e4SLinus Torvalds It is supposed, that dev->hard_header is simplistic and does 941da177e4SLinus Torvalds not make callbacks to neighbour tables. 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds The last lock is neigh_tbl_lock. It is pure SMP lock, protecting 971da177e4SLinus Torvalds list of neighbour tables. This list is used only in process context, 981da177e4SLinus Torvalds */ 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds static DEFINE_RWLOCK(neigh_tbl_lock); 1011da177e4SLinus Torvalds 1021da177e4SLinus Torvalds static int neigh_blackhole(struct sk_buff *skb) 1031da177e4SLinus Torvalds { 1041da177e4SLinus Torvalds kfree_skb(skb); 1051da177e4SLinus Torvalds return -ENETDOWN; 1061da177e4SLinus Torvalds } 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds /* 1091da177e4SLinus Torvalds * It is random distribution in the interval (1/2)*base...(3/2)*base. 1101da177e4SLinus Torvalds * It corresponds to default IPv6 settings and is not overridable, 1111da177e4SLinus Torvalds * because it is really reasonable choice. 1121da177e4SLinus Torvalds */ 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds unsigned long neigh_rand_reach_time(unsigned long base) 1151da177e4SLinus Torvalds { 1161da177e4SLinus Torvalds return (base ? (net_random() % base) + (base >> 1) : 0); 1171da177e4SLinus Torvalds } 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds static int neigh_forced_gc(struct neigh_table *tbl) 1211da177e4SLinus Torvalds { 1221da177e4SLinus Torvalds int shrunk = 0; 1231da177e4SLinus Torvalds int i; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 1281da177e4SLinus Torvalds for (i = 0; i <= tbl->hash_mask; i++) { 1291da177e4SLinus Torvalds struct neighbour *n, **np; 1301da177e4SLinus Torvalds 1311da177e4SLinus Torvalds np = &tbl->hash_buckets[i]; 1321da177e4SLinus Torvalds while ((n = *np) != NULL) { 1331da177e4SLinus Torvalds /* Neighbour record may be discarded if: 1341da177e4SLinus Torvalds * - nobody refers to it. 1351da177e4SLinus Torvalds * - it is not permanent 1361da177e4SLinus Torvalds */ 1371da177e4SLinus Torvalds write_lock(&n->lock); 1381da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 1391da177e4SLinus Torvalds !(n->nud_state & NUD_PERMANENT)) { 1401da177e4SLinus Torvalds *np = n->next; 1411da177e4SLinus Torvalds n->dead = 1; 1421da177e4SLinus Torvalds shrunk = 1; 1431da177e4SLinus Torvalds write_unlock(&n->lock); 1441da177e4SLinus Torvalds neigh_release(n); 1451da177e4SLinus Torvalds continue; 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds write_unlock(&n->lock); 1481da177e4SLinus Torvalds np = &n->next; 1491da177e4SLinus Torvalds } 1501da177e4SLinus Torvalds } 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds tbl->last_flush = jiffies; 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds return shrunk; 1571da177e4SLinus Torvalds } 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds static int neigh_del_timer(struct neighbour *n) 1601da177e4SLinus Torvalds { 1611da177e4SLinus Torvalds if ((n->nud_state & NUD_IN_TIMER) && 1621da177e4SLinus Torvalds del_timer(&n->timer)) { 1631da177e4SLinus Torvalds neigh_release(n); 1641da177e4SLinus Torvalds return 1; 1651da177e4SLinus Torvalds } 1661da177e4SLinus Torvalds return 0; 1671da177e4SLinus Torvalds } 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds static void pneigh_queue_purge(struct sk_buff_head *list) 1701da177e4SLinus Torvalds { 1711da177e4SLinus Torvalds struct sk_buff *skb; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds while ((skb = skb_dequeue(list)) != NULL) { 1741da177e4SLinus Torvalds dev_put(skb->dev); 1751da177e4SLinus Torvalds kfree_skb(skb); 1761da177e4SLinus Torvalds } 1771da177e4SLinus Torvalds } 1781da177e4SLinus Torvalds 17949636bb1SHerbert Xu static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev) 1801da177e4SLinus Torvalds { 1811da177e4SLinus Torvalds int i; 1821da177e4SLinus Torvalds 1831da177e4SLinus Torvalds for (i = 0; i <= tbl->hash_mask; i++) { 1841da177e4SLinus Torvalds struct neighbour *n, **np = &tbl->hash_buckets[i]; 1851da177e4SLinus Torvalds 1861da177e4SLinus Torvalds while ((n = *np) != NULL) { 1871da177e4SLinus Torvalds if (dev && n->dev != dev) { 1881da177e4SLinus Torvalds np = &n->next; 1891da177e4SLinus Torvalds continue; 1901da177e4SLinus Torvalds } 1911da177e4SLinus Torvalds *np = n->next; 1921da177e4SLinus Torvalds write_lock(&n->lock); 1931da177e4SLinus Torvalds neigh_del_timer(n); 1941da177e4SLinus Torvalds n->dead = 1; 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds if (atomic_read(&n->refcnt) != 1) { 1971da177e4SLinus Torvalds /* The most unpleasant situation. 1981da177e4SLinus Torvalds We must destroy neighbour entry, 1991da177e4SLinus Torvalds but someone still uses it. 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds The destroy will be delayed until 2021da177e4SLinus Torvalds the last user releases us, but 2031da177e4SLinus Torvalds we must kill timers etc. and move 2041da177e4SLinus Torvalds it to safe state. 2051da177e4SLinus Torvalds */ 2061da177e4SLinus Torvalds skb_queue_purge(&n->arp_queue); 2071da177e4SLinus Torvalds n->output = neigh_blackhole; 2081da177e4SLinus Torvalds if (n->nud_state & NUD_VALID) 2091da177e4SLinus Torvalds n->nud_state = NUD_NOARP; 2101da177e4SLinus Torvalds else 2111da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2121da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is stray.\n", n); 2131da177e4SLinus Torvalds } 2141da177e4SLinus Torvalds write_unlock(&n->lock); 2151da177e4SLinus Torvalds neigh_release(n); 2161da177e4SLinus Torvalds } 2171da177e4SLinus Torvalds } 21849636bb1SHerbert Xu } 2191da177e4SLinus Torvalds 22049636bb1SHerbert Xu void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 22149636bb1SHerbert Xu { 22249636bb1SHerbert Xu write_lock_bh(&tbl->lock); 22349636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 22449636bb1SHerbert Xu write_unlock_bh(&tbl->lock); 22549636bb1SHerbert Xu } 22649636bb1SHerbert Xu 22749636bb1SHerbert Xu int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 22849636bb1SHerbert Xu { 22949636bb1SHerbert Xu write_lock_bh(&tbl->lock); 23049636bb1SHerbert Xu neigh_flush_dev(tbl, dev); 2311da177e4SLinus Torvalds pneigh_ifdown(tbl, dev); 2321da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 2351da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 2361da177e4SLinus Torvalds return 0; 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds static struct neighbour *neigh_alloc(struct neigh_table *tbl) 2401da177e4SLinus Torvalds { 2411da177e4SLinus Torvalds struct neighbour *n = NULL; 2421da177e4SLinus Torvalds unsigned long now = jiffies; 2431da177e4SLinus Torvalds int entries; 2441da177e4SLinus Torvalds 2451da177e4SLinus Torvalds entries = atomic_inc_return(&tbl->entries) - 1; 2461da177e4SLinus Torvalds if (entries >= tbl->gc_thresh3 || 2471da177e4SLinus Torvalds (entries >= tbl->gc_thresh2 && 2481da177e4SLinus Torvalds time_after(now, tbl->last_flush + 5 * HZ))) { 2491da177e4SLinus Torvalds if (!neigh_forced_gc(tbl) && 2501da177e4SLinus Torvalds entries >= tbl->gc_thresh3) 2511da177e4SLinus Torvalds goto out_entries; 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds n = kmem_cache_alloc(tbl->kmem_cachep, SLAB_ATOMIC); 2551da177e4SLinus Torvalds if (!n) 2561da177e4SLinus Torvalds goto out_entries; 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds memset(n, 0, tbl->entry_size); 2591da177e4SLinus Torvalds 2601da177e4SLinus Torvalds skb_queue_head_init(&n->arp_queue); 2611da177e4SLinus Torvalds rwlock_init(&n->lock); 2621da177e4SLinus Torvalds n->updated = n->used = now; 2631da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2641da177e4SLinus Torvalds n->output = neigh_blackhole; 2651da177e4SLinus Torvalds n->parms = neigh_parms_clone(&tbl->parms); 2661da177e4SLinus Torvalds init_timer(&n->timer); 2671da177e4SLinus Torvalds n->timer.function = neigh_timer_handler; 2681da177e4SLinus Torvalds n->timer.data = (unsigned long)n; 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, allocs); 2711da177e4SLinus Torvalds n->tbl = tbl; 2721da177e4SLinus Torvalds atomic_set(&n->refcnt, 1); 2731da177e4SLinus Torvalds n->dead = 1; 2741da177e4SLinus Torvalds out: 2751da177e4SLinus Torvalds return n; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds out_entries: 2781da177e4SLinus Torvalds atomic_dec(&tbl->entries); 2791da177e4SLinus Torvalds goto out; 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds static struct neighbour **neigh_hash_alloc(unsigned int entries) 2831da177e4SLinus Torvalds { 2841da177e4SLinus Torvalds unsigned long size = entries * sizeof(struct neighbour *); 2851da177e4SLinus Torvalds struct neighbour **ret; 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds if (size <= PAGE_SIZE) { 28877d04bd9SAndrew Morton ret = kzalloc(size, GFP_ATOMIC); 2891da177e4SLinus Torvalds } else { 2901da177e4SLinus Torvalds ret = (struct neighbour **) 29177d04bd9SAndrew Morton __get_free_pages(GFP_ATOMIC|__GFP_ZERO, get_order(size)); 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds return ret; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds static void neigh_hash_free(struct neighbour **hash, unsigned int entries) 2971da177e4SLinus Torvalds { 2981da177e4SLinus Torvalds unsigned long size = entries * sizeof(struct neighbour *); 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds if (size <= PAGE_SIZE) 3011da177e4SLinus Torvalds kfree(hash); 3021da177e4SLinus Torvalds else 3031da177e4SLinus Torvalds free_pages((unsigned long)hash, get_order(size)); 3041da177e4SLinus Torvalds } 3051da177e4SLinus Torvalds 3061da177e4SLinus Torvalds static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries) 3071da177e4SLinus Torvalds { 3081da177e4SLinus Torvalds struct neighbour **new_hash, **old_hash; 3091da177e4SLinus Torvalds unsigned int i, new_hash_mask, old_entries; 3101da177e4SLinus Torvalds 3111da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hash_grows); 3121da177e4SLinus Torvalds 3131da177e4SLinus Torvalds BUG_ON(new_entries & (new_entries - 1)); 3141da177e4SLinus Torvalds new_hash = neigh_hash_alloc(new_entries); 3151da177e4SLinus Torvalds if (!new_hash) 3161da177e4SLinus Torvalds return; 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds old_entries = tbl->hash_mask + 1; 3191da177e4SLinus Torvalds new_hash_mask = new_entries - 1; 3201da177e4SLinus Torvalds old_hash = tbl->hash_buckets; 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 3231da177e4SLinus Torvalds for (i = 0; i < old_entries; i++) { 3241da177e4SLinus Torvalds struct neighbour *n, *next; 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds for (n = old_hash[i]; n; n = next) { 3271da177e4SLinus Torvalds unsigned int hash_val = tbl->hash(n->primary_key, n->dev); 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds hash_val &= new_hash_mask; 3301da177e4SLinus Torvalds next = n->next; 3311da177e4SLinus Torvalds 3321da177e4SLinus Torvalds n->next = new_hash[hash_val]; 3331da177e4SLinus Torvalds new_hash[hash_val] = n; 3341da177e4SLinus Torvalds } 3351da177e4SLinus Torvalds } 3361da177e4SLinus Torvalds tbl->hash_buckets = new_hash; 3371da177e4SLinus Torvalds tbl->hash_mask = new_hash_mask; 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds neigh_hash_free(old_hash, old_entries); 3401da177e4SLinus Torvalds } 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 3431da177e4SLinus Torvalds struct net_device *dev) 3441da177e4SLinus Torvalds { 3451da177e4SLinus Torvalds struct neighbour *n; 3461da177e4SLinus Torvalds int key_len = tbl->key_len; 347c5e29460SJulian Anastasov u32 hash_val = tbl->hash(pkey, dev); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 3501da177e4SLinus Torvalds 3511da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 352c5e29460SJulian Anastasov for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) { 3531da177e4SLinus Torvalds if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) { 3541da177e4SLinus Torvalds neigh_hold(n); 3551da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 3561da177e4SLinus Torvalds break; 3571da177e4SLinus Torvalds } 3581da177e4SLinus Torvalds } 3591da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 3601da177e4SLinus Torvalds return n; 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey) 3641da177e4SLinus Torvalds { 3651da177e4SLinus Torvalds struct neighbour *n; 3661da177e4SLinus Torvalds int key_len = tbl->key_len; 367c5e29460SJulian Anastasov u32 hash_val = tbl->hash(pkey, NULL); 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 372c5e29460SJulian Anastasov for (n = tbl->hash_buckets[hash_val & tbl->hash_mask]; n; n = n->next) { 3731da177e4SLinus Torvalds if (!memcmp(n->primary_key, pkey, key_len)) { 3741da177e4SLinus Torvalds neigh_hold(n); 3751da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 3761da177e4SLinus Torvalds break; 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 3801da177e4SLinus Torvalds return n; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey, 3841da177e4SLinus Torvalds struct net_device *dev) 3851da177e4SLinus Torvalds { 3861da177e4SLinus Torvalds u32 hash_val; 3871da177e4SLinus Torvalds int key_len = tbl->key_len; 3881da177e4SLinus Torvalds int error; 3891da177e4SLinus Torvalds struct neighbour *n1, *rc, *n = neigh_alloc(tbl); 3901da177e4SLinus Torvalds 3911da177e4SLinus Torvalds if (!n) { 3921da177e4SLinus Torvalds rc = ERR_PTR(-ENOBUFS); 3931da177e4SLinus Torvalds goto out; 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds 3961da177e4SLinus Torvalds memcpy(n->primary_key, pkey, key_len); 3971da177e4SLinus Torvalds n->dev = dev; 3981da177e4SLinus Torvalds dev_hold(dev); 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds /* Protocol specific setup. */ 4011da177e4SLinus Torvalds if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 4021da177e4SLinus Torvalds rc = ERR_PTR(error); 4031da177e4SLinus Torvalds goto out_neigh_release; 4041da177e4SLinus Torvalds } 4051da177e4SLinus Torvalds 4061da177e4SLinus Torvalds /* Device specific setup. */ 4071da177e4SLinus Torvalds if (n->parms->neigh_setup && 4081da177e4SLinus Torvalds (error = n->parms->neigh_setup(n)) < 0) { 4091da177e4SLinus Torvalds rc = ERR_PTR(error); 4101da177e4SLinus Torvalds goto out_neigh_release; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds n->confirmed = jiffies - (n->parms->base_reachable_time << 1); 4141da177e4SLinus Torvalds 4151da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 4161da177e4SLinus Torvalds 4171da177e4SLinus Torvalds if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1)) 4181da177e4SLinus Torvalds neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1); 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds if (n->parms->dead) { 4231da177e4SLinus Torvalds rc = ERR_PTR(-EINVAL); 4241da177e4SLinus Torvalds goto out_tbl_unlock; 4251da177e4SLinus Torvalds } 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) { 4281da177e4SLinus Torvalds if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 4291da177e4SLinus Torvalds neigh_hold(n1); 4301da177e4SLinus Torvalds rc = n1; 4311da177e4SLinus Torvalds goto out_tbl_unlock; 4321da177e4SLinus Torvalds } 4331da177e4SLinus Torvalds } 4341da177e4SLinus Torvalds 4351da177e4SLinus Torvalds n->next = tbl->hash_buckets[hash_val]; 4361da177e4SLinus Torvalds tbl->hash_buckets[hash_val] = n; 4371da177e4SLinus Torvalds n->dead = 0; 4381da177e4SLinus Torvalds neigh_hold(n); 4391da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 4401da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is created.\n", n); 4411da177e4SLinus Torvalds rc = n; 4421da177e4SLinus Torvalds out: 4431da177e4SLinus Torvalds return rc; 4441da177e4SLinus Torvalds out_tbl_unlock: 4451da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 4461da177e4SLinus Torvalds out_neigh_release: 4471da177e4SLinus Torvalds neigh_release(n); 4481da177e4SLinus Torvalds goto out; 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey, 4521da177e4SLinus Torvalds struct net_device *dev, int creat) 4531da177e4SLinus Torvalds { 4541da177e4SLinus Torvalds struct pneigh_entry *n; 4551da177e4SLinus Torvalds int key_len = tbl->key_len; 4561da177e4SLinus Torvalds u32 hash_val = *(u32 *)(pkey + key_len - 4); 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds hash_val ^= (hash_val >> 16); 4591da177e4SLinus Torvalds hash_val ^= hash_val >> 8; 4601da177e4SLinus Torvalds hash_val ^= hash_val >> 4; 4611da177e4SLinus Torvalds hash_val &= PNEIGH_HASHMASK; 4621da177e4SLinus Torvalds 4631da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 4641da177e4SLinus Torvalds 4651da177e4SLinus Torvalds for (n = tbl->phash_buckets[hash_val]; n; n = n->next) { 4661da177e4SLinus Torvalds if (!memcmp(n->key, pkey, key_len) && 4671da177e4SLinus Torvalds (n->dev == dev || !n->dev)) { 4681da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 4691da177e4SLinus Torvalds goto out; 4701da177e4SLinus Torvalds } 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 4731da177e4SLinus Torvalds n = NULL; 4741da177e4SLinus Torvalds if (!creat) 4751da177e4SLinus Torvalds goto out; 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 4781da177e4SLinus Torvalds if (!n) 4791da177e4SLinus Torvalds goto out; 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds memcpy(n->key, pkey, key_len); 4821da177e4SLinus Torvalds n->dev = dev; 4831da177e4SLinus Torvalds if (dev) 4841da177e4SLinus Torvalds dev_hold(dev); 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds if (tbl->pconstructor && tbl->pconstructor(n)) { 4871da177e4SLinus Torvalds if (dev) 4881da177e4SLinus Torvalds dev_put(dev); 4891da177e4SLinus Torvalds kfree(n); 4901da177e4SLinus Torvalds n = NULL; 4911da177e4SLinus Torvalds goto out; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 4951da177e4SLinus Torvalds n->next = tbl->phash_buckets[hash_val]; 4961da177e4SLinus Torvalds tbl->phash_buckets[hash_val] = n; 4971da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 4981da177e4SLinus Torvalds out: 4991da177e4SLinus Torvalds return n; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds int pneigh_delete(struct neigh_table *tbl, const void *pkey, 5041da177e4SLinus Torvalds struct net_device *dev) 5051da177e4SLinus Torvalds { 5061da177e4SLinus Torvalds struct pneigh_entry *n, **np; 5071da177e4SLinus Torvalds int key_len = tbl->key_len; 5081da177e4SLinus Torvalds u32 hash_val = *(u32 *)(pkey + key_len - 4); 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds hash_val ^= (hash_val >> 16); 5111da177e4SLinus Torvalds hash_val ^= hash_val >> 8; 5121da177e4SLinus Torvalds hash_val ^= hash_val >> 4; 5131da177e4SLinus Torvalds hash_val &= PNEIGH_HASHMASK; 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 5161da177e4SLinus Torvalds for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 5171da177e4SLinus Torvalds np = &n->next) { 5181da177e4SLinus Torvalds if (!memcmp(n->key, pkey, key_len) && n->dev == dev) { 5191da177e4SLinus Torvalds *np = n->next; 5201da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5211da177e4SLinus Torvalds if (tbl->pdestructor) 5221da177e4SLinus Torvalds tbl->pdestructor(n); 5231da177e4SLinus Torvalds if (n->dev) 5241da177e4SLinus Torvalds dev_put(n->dev); 5251da177e4SLinus Torvalds kfree(n); 5261da177e4SLinus Torvalds return 0; 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds } 5291da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5301da177e4SLinus Torvalds return -ENOENT; 5311da177e4SLinus Torvalds } 5321da177e4SLinus Torvalds 5331da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 5341da177e4SLinus Torvalds { 5351da177e4SLinus Torvalds struct pneigh_entry *n, **np; 5361da177e4SLinus Torvalds u32 h; 5371da177e4SLinus Torvalds 5381da177e4SLinus Torvalds for (h = 0; h <= PNEIGH_HASHMASK; h++) { 5391da177e4SLinus Torvalds np = &tbl->phash_buckets[h]; 5401da177e4SLinus Torvalds while ((n = *np) != NULL) { 5411da177e4SLinus Torvalds if (!dev || n->dev == dev) { 5421da177e4SLinus Torvalds *np = n->next; 5431da177e4SLinus Torvalds if (tbl->pdestructor) 5441da177e4SLinus Torvalds tbl->pdestructor(n); 5451da177e4SLinus Torvalds if (n->dev) 5461da177e4SLinus Torvalds dev_put(n->dev); 5471da177e4SLinus Torvalds kfree(n); 5481da177e4SLinus Torvalds continue; 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds np = &n->next; 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds } 5531da177e4SLinus Torvalds return -ENOENT; 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds /* 5581da177e4SLinus Torvalds * neighbour must already be out of the table; 5591da177e4SLinus Torvalds * 5601da177e4SLinus Torvalds */ 5611da177e4SLinus Torvalds void neigh_destroy(struct neighbour *neigh) 5621da177e4SLinus Torvalds { 5631da177e4SLinus Torvalds struct hh_cache *hh; 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds if (!neigh->dead) { 5681da177e4SLinus Torvalds printk(KERN_WARNING 5691da177e4SLinus Torvalds "Destroying alive neighbour %p\n", neigh); 5701da177e4SLinus Torvalds dump_stack(); 5711da177e4SLinus Torvalds return; 5721da177e4SLinus Torvalds } 5731da177e4SLinus Torvalds 5741da177e4SLinus Torvalds if (neigh_del_timer(neigh)) 5751da177e4SLinus Torvalds printk(KERN_WARNING "Impossible event.\n"); 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds while ((hh = neigh->hh) != NULL) { 5781da177e4SLinus Torvalds neigh->hh = hh->hh_next; 5791da177e4SLinus Torvalds hh->hh_next = NULL; 5801da177e4SLinus Torvalds write_lock_bh(&hh->hh_lock); 5811da177e4SLinus Torvalds hh->hh_output = neigh_blackhole; 5821da177e4SLinus Torvalds write_unlock_bh(&hh->hh_lock); 5831da177e4SLinus Torvalds if (atomic_dec_and_test(&hh->hh_refcnt)) 5841da177e4SLinus Torvalds kfree(hh); 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds 587c5ecd62cSMichael S. Tsirkin if (neigh->parms->neigh_destructor) 588c5ecd62cSMichael S. Tsirkin (neigh->parms->neigh_destructor)(neigh); 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 5911da177e4SLinus Torvalds 5921da177e4SLinus Torvalds dev_put(neigh->dev); 5931da177e4SLinus Torvalds neigh_parms_put(neigh->parms); 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh); 5961da177e4SLinus Torvalds 5971da177e4SLinus Torvalds atomic_dec(&neigh->tbl->entries); 5981da177e4SLinus Torvalds kmem_cache_free(neigh->tbl->kmem_cachep, neigh); 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds /* Neighbour state is suspicious; 6021da177e4SLinus Torvalds disable fast path. 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds Called with write_locked neigh. 6051da177e4SLinus Torvalds */ 6061da177e4SLinus Torvalds static void neigh_suspect(struct neighbour *neigh) 6071da177e4SLinus Torvalds { 6081da177e4SLinus Torvalds struct hh_cache *hh; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds neigh->output = neigh->ops->output; 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) 6151da177e4SLinus Torvalds hh->hh_output = neigh->ops->output; 6161da177e4SLinus Torvalds } 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds /* Neighbour state is OK; 6191da177e4SLinus Torvalds enable fast path. 6201da177e4SLinus Torvalds 6211da177e4SLinus Torvalds Called with write_locked neigh. 6221da177e4SLinus Torvalds */ 6231da177e4SLinus Torvalds static void neigh_connect(struct neighbour *neigh) 6241da177e4SLinus Torvalds { 6251da177e4SLinus Torvalds struct hh_cache *hh; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is connected.\n", neigh); 6281da177e4SLinus Torvalds 6291da177e4SLinus Torvalds neigh->output = neigh->ops->connected_output; 6301da177e4SLinus Torvalds 6311da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) 6321da177e4SLinus Torvalds hh->hh_output = neigh->ops->hh_output; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds static void neigh_periodic_timer(unsigned long arg) 6361da177e4SLinus Torvalds { 6371da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 6381da177e4SLinus Torvalds struct neighbour *n, **np; 6391da177e4SLinus Torvalds unsigned long expire, now = jiffies; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds write_lock(&tbl->lock); 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds /* 6461da177e4SLinus Torvalds * periodically recompute ReachableTime from random function 6471da177e4SLinus Torvalds */ 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds if (time_after(now, tbl->last_rand + 300 * HZ)) { 6501da177e4SLinus Torvalds struct neigh_parms *p; 6511da177e4SLinus Torvalds tbl->last_rand = now; 6521da177e4SLinus Torvalds for (p = &tbl->parms; p; p = p->next) 6531da177e4SLinus Torvalds p->reachable_time = 6541da177e4SLinus Torvalds neigh_rand_reach_time(p->base_reachable_time); 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds np = &tbl->hash_buckets[tbl->hash_chain_gc]; 6581da177e4SLinus Torvalds tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask); 6591da177e4SLinus Torvalds 6601da177e4SLinus Torvalds while ((n = *np) != NULL) { 6611da177e4SLinus Torvalds unsigned int state; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds write_lock(&n->lock); 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds state = n->nud_state; 6661da177e4SLinus Torvalds if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 6671da177e4SLinus Torvalds write_unlock(&n->lock); 6681da177e4SLinus Torvalds goto next_elt; 6691da177e4SLinus Torvalds } 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds if (time_before(n->used, n->confirmed)) 6721da177e4SLinus Torvalds n->used = n->confirmed; 6731da177e4SLinus Torvalds 6741da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 6751da177e4SLinus Torvalds (state == NUD_FAILED || 6761da177e4SLinus Torvalds time_after(now, n->used + n->parms->gc_staletime))) { 6771da177e4SLinus Torvalds *np = n->next; 6781da177e4SLinus Torvalds n->dead = 1; 6791da177e4SLinus Torvalds write_unlock(&n->lock); 6801da177e4SLinus Torvalds neigh_release(n); 6811da177e4SLinus Torvalds continue; 6821da177e4SLinus Torvalds } 6831da177e4SLinus Torvalds write_unlock(&n->lock); 6841da177e4SLinus Torvalds 6851da177e4SLinus Torvalds next_elt: 6861da177e4SLinus Torvalds np = &n->next; 6871da177e4SLinus Torvalds } 6881da177e4SLinus Torvalds 6891da177e4SLinus Torvalds /* Cycle through all hash buckets every base_reachable_time/2 ticks. 6901da177e4SLinus Torvalds * ARP entry timeouts range from 1/2 base_reachable_time to 3/2 6911da177e4SLinus Torvalds * base_reachable_time. 6921da177e4SLinus Torvalds */ 6931da177e4SLinus Torvalds expire = tbl->parms.base_reachable_time >> 1; 6941da177e4SLinus Torvalds expire /= (tbl->hash_mask + 1); 6951da177e4SLinus Torvalds if (!expire) 6961da177e4SLinus Torvalds expire = 1; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds mod_timer(&tbl->gc_timer, now + expire); 6991da177e4SLinus Torvalds 7001da177e4SLinus Torvalds write_unlock(&tbl->lock); 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds static __inline__ int neigh_max_probes(struct neighbour *n) 7041da177e4SLinus Torvalds { 7051da177e4SLinus Torvalds struct neigh_parms *p = n->parms; 7061da177e4SLinus Torvalds return (n->nud_state & NUD_PROBE ? 7071da177e4SLinus Torvalds p->ucast_probes : 7081da177e4SLinus Torvalds p->ucast_probes + p->app_probes + p->mcast_probes); 7091da177e4SLinus Torvalds } 7101da177e4SLinus Torvalds 711667347f1SDavid S. Miller static inline void neigh_add_timer(struct neighbour *n, unsigned long when) 712667347f1SDavid S. Miller { 713667347f1SDavid S. Miller if (unlikely(mod_timer(&n->timer, when))) { 714667347f1SDavid S. Miller printk("NEIGH: BUG, double timer add, state is %x\n", 715667347f1SDavid S. Miller n->nud_state); 71620375502SHerbert Xu dump_stack(); 717667347f1SDavid S. Miller } 718667347f1SDavid S. Miller } 7191da177e4SLinus Torvalds 7201da177e4SLinus Torvalds /* Called when a timer expires for a neighbour entry. */ 7211da177e4SLinus Torvalds 7221da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg) 7231da177e4SLinus Torvalds { 7241da177e4SLinus Torvalds unsigned long now, next; 7251da177e4SLinus Torvalds struct neighbour *neigh = (struct neighbour *)arg; 7261da177e4SLinus Torvalds unsigned state; 7271da177e4SLinus Torvalds int notify = 0; 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds write_lock(&neigh->lock); 7301da177e4SLinus Torvalds 7311da177e4SLinus Torvalds state = neigh->nud_state; 7321da177e4SLinus Torvalds now = jiffies; 7331da177e4SLinus Torvalds next = now + HZ; 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds if (!(state & NUD_IN_TIMER)) { 7361da177e4SLinus Torvalds #ifndef CONFIG_SMP 7371da177e4SLinus Torvalds printk(KERN_WARNING "neigh: timer & !nud_in_timer\n"); 7381da177e4SLinus Torvalds #endif 7391da177e4SLinus Torvalds goto out; 7401da177e4SLinus Torvalds } 7411da177e4SLinus Torvalds 7421da177e4SLinus Torvalds if (state & NUD_REACHABLE) { 7431da177e4SLinus Torvalds if (time_before_eq(now, 7441da177e4SLinus Torvalds neigh->confirmed + neigh->parms->reachable_time)) { 7451da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is still alive.\n", neigh); 7461da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 7471da177e4SLinus Torvalds } else if (time_before_eq(now, 7481da177e4SLinus Torvalds neigh->used + neigh->parms->delay_probe_time)) { 7491da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 7501da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 751955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 7521da177e4SLinus Torvalds neigh_suspect(neigh); 7531da177e4SLinus Torvalds next = now + neigh->parms->delay_probe_time; 7541da177e4SLinus Torvalds } else { 7551da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 7561da177e4SLinus Torvalds neigh->nud_state = NUD_STALE; 757955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 7581da177e4SLinus Torvalds neigh_suspect(neigh); 7598d71740cSTom Tucker notify = 1; 7601da177e4SLinus Torvalds } 7611da177e4SLinus Torvalds } else if (state & NUD_DELAY) { 7621da177e4SLinus Torvalds if (time_before_eq(now, 7631da177e4SLinus Torvalds neigh->confirmed + neigh->parms->delay_probe_time)) { 7641da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh); 7651da177e4SLinus Torvalds neigh->nud_state = NUD_REACHABLE; 766955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 7671da177e4SLinus Torvalds neigh_connect(neigh); 7688d71740cSTom Tucker notify = 1; 7691da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 7701da177e4SLinus Torvalds } else { 7711da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is probed.\n", neigh); 7721da177e4SLinus Torvalds neigh->nud_state = NUD_PROBE; 773955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 7741da177e4SLinus Torvalds atomic_set(&neigh->probes, 0); 7751da177e4SLinus Torvalds next = now + neigh->parms->retrans_time; 7761da177e4SLinus Torvalds } 7771da177e4SLinus Torvalds } else { 7781da177e4SLinus Torvalds /* NUD_PROBE|NUD_INCOMPLETE */ 7791da177e4SLinus Torvalds next = now + neigh->parms->retrans_time; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 7831da177e4SLinus Torvalds atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 7841da177e4SLinus Torvalds struct sk_buff *skb; 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 787955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 7881da177e4SLinus Torvalds notify = 1; 7891da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 7901da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is failed.\n", neigh); 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds /* It is very thin place. report_unreachable is very complicated 7931da177e4SLinus Torvalds routine. Particularly, it can hit the same neighbour entry! 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds So that, we try to be accurate and avoid dead loop. --ANK 7961da177e4SLinus Torvalds */ 7971da177e4SLinus Torvalds while (neigh->nud_state == NUD_FAILED && 7981da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 7991da177e4SLinus Torvalds write_unlock(&neigh->lock); 8001da177e4SLinus Torvalds neigh->ops->error_report(neigh, skb); 8011da177e4SLinus Torvalds write_lock(&neigh->lock); 8021da177e4SLinus Torvalds } 8031da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds if (neigh->nud_state & NUD_IN_TIMER) { 8071da177e4SLinus Torvalds if (time_before(next, jiffies + HZ/2)) 8081da177e4SLinus Torvalds next = jiffies + HZ/2; 8096fb9974fSHerbert Xu if (!mod_timer(&neigh->timer, next)) 8106fb9974fSHerbert Xu neigh_hold(neigh); 8111da177e4SLinus Torvalds } 8121da177e4SLinus Torvalds if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 8131da177e4SLinus Torvalds struct sk_buff *skb = skb_peek(&neigh->arp_queue); 8141da177e4SLinus Torvalds /* keep skb alive even if arp_queue overflows */ 8151da177e4SLinus Torvalds if (skb) 8161da177e4SLinus Torvalds skb_get(skb); 8171da177e4SLinus Torvalds write_unlock(&neigh->lock); 8181da177e4SLinus Torvalds neigh->ops->solicit(neigh, skb); 8191da177e4SLinus Torvalds atomic_inc(&neigh->probes); 8201da177e4SLinus Torvalds if (skb) 8211da177e4SLinus Torvalds kfree_skb(skb); 8221da177e4SLinus Torvalds } else { 8231da177e4SLinus Torvalds out: 8241da177e4SLinus Torvalds write_unlock(&neigh->lock); 8251da177e4SLinus Torvalds } 8268d71740cSTom Tucker if (notify) 8278d71740cSTom Tucker call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds #ifdef CONFIG_ARPD 8301da177e4SLinus Torvalds if (notify && neigh->parms->app_probes) 8311da177e4SLinus Torvalds neigh_app_notify(neigh); 8321da177e4SLinus Torvalds #endif 8331da177e4SLinus Torvalds neigh_release(neigh); 8341da177e4SLinus Torvalds } 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) 8371da177e4SLinus Torvalds { 8381da177e4SLinus Torvalds int rc; 8391da177e4SLinus Torvalds unsigned long now; 8401da177e4SLinus Torvalds 8411da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds rc = 0; 8441da177e4SLinus Torvalds if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE)) 8451da177e4SLinus Torvalds goto out_unlock_bh; 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds now = jiffies; 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) { 8501da177e4SLinus Torvalds if (neigh->parms->mcast_probes + neigh->parms->app_probes) { 8511da177e4SLinus Torvalds atomic_set(&neigh->probes, neigh->parms->ucast_probes); 8521da177e4SLinus Torvalds neigh->nud_state = NUD_INCOMPLETE; 853955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 8541da177e4SLinus Torvalds neigh_hold(neigh); 855667347f1SDavid S. Miller neigh_add_timer(neigh, now + 1); 8561da177e4SLinus Torvalds } else { 8571da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 858955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 8591da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds if (skb) 8621da177e4SLinus Torvalds kfree_skb(skb); 8631da177e4SLinus Torvalds return 1; 8641da177e4SLinus Torvalds } 8651da177e4SLinus Torvalds } else if (neigh->nud_state & NUD_STALE) { 8661da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 8671da177e4SLinus Torvalds neigh_hold(neigh); 8681da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 869955aaa2fSYOSHIFUJI Hideaki neigh->updated = jiffies; 870667347f1SDavid S. Miller neigh_add_timer(neigh, 871667347f1SDavid S. Miller jiffies + neigh->parms->delay_probe_time); 8721da177e4SLinus Torvalds } 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds if (neigh->nud_state == NUD_INCOMPLETE) { 8751da177e4SLinus Torvalds if (skb) { 8761da177e4SLinus Torvalds if (skb_queue_len(&neigh->arp_queue) >= 8771da177e4SLinus Torvalds neigh->parms->queue_len) { 8781da177e4SLinus Torvalds struct sk_buff *buff; 8791da177e4SLinus Torvalds buff = neigh->arp_queue.next; 8801da177e4SLinus Torvalds __skb_unlink(buff, &neigh->arp_queue); 8811da177e4SLinus Torvalds kfree_skb(buff); 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds __skb_queue_tail(&neigh->arp_queue, skb); 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds rc = 1; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds out_unlock_bh: 8881da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 8891da177e4SLinus Torvalds return rc; 8901da177e4SLinus Torvalds } 8911da177e4SLinus Torvalds 892e92b43a3SStephen Hemminger static void neigh_update_hhs(struct neighbour *neigh) 8931da177e4SLinus Torvalds { 8941da177e4SLinus Torvalds struct hh_cache *hh; 8951da177e4SLinus Torvalds void (*update)(struct hh_cache*, struct net_device*, unsigned char *) = 8961da177e4SLinus Torvalds neigh->dev->header_cache_update; 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds if (update) { 8991da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) { 9001da177e4SLinus Torvalds write_lock_bh(&hh->hh_lock); 9011da177e4SLinus Torvalds update(hh, neigh->dev, neigh->ha); 9021da177e4SLinus Torvalds write_unlock_bh(&hh->hh_lock); 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds } 9051da177e4SLinus Torvalds } 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds /* Generic update routine. 9101da177e4SLinus Torvalds -- lladdr is new lladdr or NULL, if it is not supplied. 9111da177e4SLinus Torvalds -- new is new state. 9121da177e4SLinus Torvalds -- flags 9131da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 9141da177e4SLinus Torvalds if it is different. 9151da177e4SLinus Torvalds NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 9161da177e4SLinus Torvalds lladdr instead of overriding it 9171da177e4SLinus Torvalds if it is different. 9181da177e4SLinus Torvalds It also allows to retain current state 9191da177e4SLinus Torvalds if lladdr is unchanged. 9201da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN means that the change is administrative. 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 9231da177e4SLinus Torvalds NTF_ROUTER flag. 9241da177e4SLinus Torvalds NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 9251da177e4SLinus Torvalds a router. 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds Caller MUST hold reference count on the entry. 9281da177e4SLinus Torvalds */ 9291da177e4SLinus Torvalds 9301da177e4SLinus Torvalds int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 9311da177e4SLinus Torvalds u32 flags) 9321da177e4SLinus Torvalds { 9331da177e4SLinus Torvalds u8 old; 9341da177e4SLinus Torvalds int err; 9351da177e4SLinus Torvalds int notify = 0; 9361da177e4SLinus Torvalds struct net_device *dev; 9371da177e4SLinus Torvalds int update_isrouter = 0; 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds dev = neigh->dev; 9421da177e4SLinus Torvalds old = neigh->nud_state; 9431da177e4SLinus Torvalds err = -EPERM; 9441da177e4SLinus Torvalds 9451da177e4SLinus Torvalds if (!(flags & NEIGH_UPDATE_F_ADMIN) && 9461da177e4SLinus Torvalds (old & (NUD_NOARP | NUD_PERMANENT))) 9471da177e4SLinus Torvalds goto out; 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds if (!(new & NUD_VALID)) { 9501da177e4SLinus Torvalds neigh_del_timer(neigh); 9511da177e4SLinus Torvalds if (old & NUD_CONNECTED) 9521da177e4SLinus Torvalds neigh_suspect(neigh); 9531da177e4SLinus Torvalds neigh->nud_state = new; 9541da177e4SLinus Torvalds err = 0; 9551da177e4SLinus Torvalds notify = old & NUD_VALID; 9561da177e4SLinus Torvalds goto out; 9571da177e4SLinus Torvalds } 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds /* Compare new lladdr with cached one */ 9601da177e4SLinus Torvalds if (!dev->addr_len) { 9611da177e4SLinus Torvalds /* First case: device needs no address. */ 9621da177e4SLinus Torvalds lladdr = neigh->ha; 9631da177e4SLinus Torvalds } else if (lladdr) { 9641da177e4SLinus Torvalds /* The second case: if something is already cached 9651da177e4SLinus Torvalds and a new address is proposed: 9661da177e4SLinus Torvalds - compare new & old 9671da177e4SLinus Torvalds - if they are different, check override flag 9681da177e4SLinus Torvalds */ 9691da177e4SLinus Torvalds if ((old & NUD_VALID) && 9701da177e4SLinus Torvalds !memcmp(lladdr, neigh->ha, dev->addr_len)) 9711da177e4SLinus Torvalds lladdr = neigh->ha; 9721da177e4SLinus Torvalds } else { 9731da177e4SLinus Torvalds /* No address is supplied; if we know something, 9741da177e4SLinus Torvalds use it, otherwise discard the request. 9751da177e4SLinus Torvalds */ 9761da177e4SLinus Torvalds err = -EINVAL; 9771da177e4SLinus Torvalds if (!(old & NUD_VALID)) 9781da177e4SLinus Torvalds goto out; 9791da177e4SLinus Torvalds lladdr = neigh->ha; 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds if (new & NUD_CONNECTED) 9831da177e4SLinus Torvalds neigh->confirmed = jiffies; 9841da177e4SLinus Torvalds neigh->updated = jiffies; 9851da177e4SLinus Torvalds 9861da177e4SLinus Torvalds /* If entry was valid and address is not changed, 9871da177e4SLinus Torvalds do not change entry state, if new one is STALE. 9881da177e4SLinus Torvalds */ 9891da177e4SLinus Torvalds err = 0; 9901da177e4SLinus Torvalds update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 9911da177e4SLinus Torvalds if (old & NUD_VALID) { 9921da177e4SLinus Torvalds if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 9931da177e4SLinus Torvalds update_isrouter = 0; 9941da177e4SLinus Torvalds if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 9951da177e4SLinus Torvalds (old & NUD_CONNECTED)) { 9961da177e4SLinus Torvalds lladdr = neigh->ha; 9971da177e4SLinus Torvalds new = NUD_STALE; 9981da177e4SLinus Torvalds } else 9991da177e4SLinus Torvalds goto out; 10001da177e4SLinus Torvalds } else { 10011da177e4SLinus Torvalds if (lladdr == neigh->ha && new == NUD_STALE && 10021da177e4SLinus Torvalds ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 10031da177e4SLinus Torvalds (old & NUD_CONNECTED)) 10041da177e4SLinus Torvalds ) 10051da177e4SLinus Torvalds new = old; 10061da177e4SLinus Torvalds } 10071da177e4SLinus Torvalds } 10081da177e4SLinus Torvalds 10091da177e4SLinus Torvalds if (new != old) { 10101da177e4SLinus Torvalds neigh_del_timer(neigh); 10111da177e4SLinus Torvalds if (new & NUD_IN_TIMER) { 10121da177e4SLinus Torvalds neigh_hold(neigh); 1013667347f1SDavid S. Miller neigh_add_timer(neigh, (jiffies + 10141da177e4SLinus Torvalds ((new & NUD_REACHABLE) ? 1015667347f1SDavid S. Miller neigh->parms->reachable_time : 1016667347f1SDavid S. Miller 0))); 10171da177e4SLinus Torvalds } 10181da177e4SLinus Torvalds neigh->nud_state = new; 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds 10211da177e4SLinus Torvalds if (lladdr != neigh->ha) { 10221da177e4SLinus Torvalds memcpy(&neigh->ha, lladdr, dev->addr_len); 10231da177e4SLinus Torvalds neigh_update_hhs(neigh); 10241da177e4SLinus Torvalds if (!(new & NUD_CONNECTED)) 10251da177e4SLinus Torvalds neigh->confirmed = jiffies - 10261da177e4SLinus Torvalds (neigh->parms->base_reachable_time << 1); 10271da177e4SLinus Torvalds notify = 1; 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds if (new == old) 10301da177e4SLinus Torvalds goto out; 10311da177e4SLinus Torvalds if (new & NUD_CONNECTED) 10321da177e4SLinus Torvalds neigh_connect(neigh); 10331da177e4SLinus Torvalds else 10341da177e4SLinus Torvalds neigh_suspect(neigh); 10351da177e4SLinus Torvalds if (!(old & NUD_VALID)) { 10361da177e4SLinus Torvalds struct sk_buff *skb; 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds /* Again: avoid dead loop if something went wrong */ 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds while (neigh->nud_state & NUD_VALID && 10411da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 10421da177e4SLinus Torvalds struct neighbour *n1 = neigh; 10431da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 10441da177e4SLinus Torvalds /* On shaper/eql skb->dst->neighbour != neigh :( */ 10451da177e4SLinus Torvalds if (skb->dst && skb->dst->neighbour) 10461da177e4SLinus Torvalds n1 = skb->dst->neighbour; 10471da177e4SLinus Torvalds n1->output(skb); 10481da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 10511da177e4SLinus Torvalds } 10521da177e4SLinus Torvalds out: 10531da177e4SLinus Torvalds if (update_isrouter) { 10541da177e4SLinus Torvalds neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 10551da177e4SLinus Torvalds (neigh->flags | NTF_ROUTER) : 10561da177e4SLinus Torvalds (neigh->flags & ~NTF_ROUTER); 10571da177e4SLinus Torvalds } 10581da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 10598d71740cSTom Tucker 10608d71740cSTom Tucker if (notify) 10618d71740cSTom Tucker call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh); 10621da177e4SLinus Torvalds #ifdef CONFIG_ARPD 10631da177e4SLinus Torvalds if (notify && neigh->parms->app_probes) 10641da177e4SLinus Torvalds neigh_app_notify(neigh); 10651da177e4SLinus Torvalds #endif 10661da177e4SLinus Torvalds return err; 10671da177e4SLinus Torvalds } 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds struct neighbour *neigh_event_ns(struct neigh_table *tbl, 10701da177e4SLinus Torvalds u8 *lladdr, void *saddr, 10711da177e4SLinus Torvalds struct net_device *dev) 10721da177e4SLinus Torvalds { 10731da177e4SLinus Torvalds struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 10741da177e4SLinus Torvalds lladdr || !dev->addr_len); 10751da177e4SLinus Torvalds if (neigh) 10761da177e4SLinus Torvalds neigh_update(neigh, lladdr, NUD_STALE, 10771da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE); 10781da177e4SLinus Torvalds return neigh; 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst, 1082d77072ecSAl Viro __be16 protocol) 10831da177e4SLinus Torvalds { 10841da177e4SLinus Torvalds struct hh_cache *hh; 10851da177e4SLinus Torvalds struct net_device *dev = dst->dev; 10861da177e4SLinus Torvalds 10871da177e4SLinus Torvalds for (hh = n->hh; hh; hh = hh->hh_next) 10881da177e4SLinus Torvalds if (hh->hh_type == protocol) 10891da177e4SLinus Torvalds break; 10901da177e4SLinus Torvalds 109177d04bd9SAndrew Morton if (!hh && (hh = kzalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) { 10921da177e4SLinus Torvalds rwlock_init(&hh->hh_lock); 10931da177e4SLinus Torvalds hh->hh_type = protocol; 10941da177e4SLinus Torvalds atomic_set(&hh->hh_refcnt, 0); 10951da177e4SLinus Torvalds hh->hh_next = NULL; 10961da177e4SLinus Torvalds if (dev->hard_header_cache(n, hh)) { 10971da177e4SLinus Torvalds kfree(hh); 10981da177e4SLinus Torvalds hh = NULL; 10991da177e4SLinus Torvalds } else { 11001da177e4SLinus Torvalds atomic_inc(&hh->hh_refcnt); 11011da177e4SLinus Torvalds hh->hh_next = n->hh; 11021da177e4SLinus Torvalds n->hh = hh; 11031da177e4SLinus Torvalds if (n->nud_state & NUD_CONNECTED) 11041da177e4SLinus Torvalds hh->hh_output = n->ops->hh_output; 11051da177e4SLinus Torvalds else 11061da177e4SLinus Torvalds hh->hh_output = n->ops->output; 11071da177e4SLinus Torvalds } 11081da177e4SLinus Torvalds } 11091da177e4SLinus Torvalds if (hh) { 11101da177e4SLinus Torvalds atomic_inc(&hh->hh_refcnt); 11111da177e4SLinus Torvalds dst->hh = hh; 11121da177e4SLinus Torvalds } 11131da177e4SLinus Torvalds } 11141da177e4SLinus Torvalds 11151da177e4SLinus Torvalds /* This function can be used in contexts, where only old dev_queue_xmit 11161da177e4SLinus Torvalds worked, f.e. if you want to override normal output path (eql, shaper), 11171da177e4SLinus Torvalds but resolution is not made yet. 11181da177e4SLinus Torvalds */ 11191da177e4SLinus Torvalds 11201da177e4SLinus Torvalds int neigh_compat_output(struct sk_buff *skb) 11211da177e4SLinus Torvalds { 11221da177e4SLinus Torvalds struct net_device *dev = skb->dev; 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds if (dev->hard_header && 11271da177e4SLinus Torvalds dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 11281da177e4SLinus Torvalds skb->len) < 0 && 11291da177e4SLinus Torvalds dev->rebuild_header(skb)) 11301da177e4SLinus Torvalds return 0; 11311da177e4SLinus Torvalds 11321da177e4SLinus Torvalds return dev_queue_xmit(skb); 11331da177e4SLinus Torvalds } 11341da177e4SLinus Torvalds 11351da177e4SLinus Torvalds /* Slow and careful. */ 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds int neigh_resolve_output(struct sk_buff *skb) 11381da177e4SLinus Torvalds { 11391da177e4SLinus Torvalds struct dst_entry *dst = skb->dst; 11401da177e4SLinus Torvalds struct neighbour *neigh; 11411da177e4SLinus Torvalds int rc = 0; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds if (!dst || !(neigh = dst->neighbour)) 11441da177e4SLinus Torvalds goto discard; 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds if (!neigh_event_send(neigh, skb)) { 11491da177e4SLinus Torvalds int err; 11501da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 11511da177e4SLinus Torvalds if (dev->hard_header_cache && !dst->hh) { 11521da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 11531da177e4SLinus Torvalds if (!dst->hh) 11541da177e4SLinus Torvalds neigh_hh_init(neigh, dst, dst->ops->protocol); 11551da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11561da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11571da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 11581da177e4SLinus Torvalds } else { 11591da177e4SLinus Torvalds read_lock_bh(&neigh->lock); 11601da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11611da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11621da177e4SLinus Torvalds read_unlock_bh(&neigh->lock); 11631da177e4SLinus Torvalds } 11641da177e4SLinus Torvalds if (err >= 0) 11651da177e4SLinus Torvalds rc = neigh->ops->queue_xmit(skb); 11661da177e4SLinus Torvalds else 11671da177e4SLinus Torvalds goto out_kfree_skb; 11681da177e4SLinus Torvalds } 11691da177e4SLinus Torvalds out: 11701da177e4SLinus Torvalds return rc; 11711da177e4SLinus Torvalds discard: 11721da177e4SLinus Torvalds NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n", 11731da177e4SLinus Torvalds dst, dst ? dst->neighbour : NULL); 11741da177e4SLinus Torvalds out_kfree_skb: 11751da177e4SLinus Torvalds rc = -EINVAL; 11761da177e4SLinus Torvalds kfree_skb(skb); 11771da177e4SLinus Torvalds goto out; 11781da177e4SLinus Torvalds } 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds /* As fast as possible without hh cache */ 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds int neigh_connected_output(struct sk_buff *skb) 11831da177e4SLinus Torvalds { 11841da177e4SLinus Torvalds int err; 11851da177e4SLinus Torvalds struct dst_entry *dst = skb->dst; 11861da177e4SLinus Torvalds struct neighbour *neigh = dst->neighbour; 11871da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds read_lock_bh(&neigh->lock); 11921da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11931da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11941da177e4SLinus Torvalds read_unlock_bh(&neigh->lock); 11951da177e4SLinus Torvalds if (err >= 0) 11961da177e4SLinus Torvalds err = neigh->ops->queue_xmit(skb); 11971da177e4SLinus Torvalds else { 11981da177e4SLinus Torvalds err = -EINVAL; 11991da177e4SLinus Torvalds kfree_skb(skb); 12001da177e4SLinus Torvalds } 12011da177e4SLinus Torvalds return err; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 12041da177e4SLinus Torvalds static void neigh_proxy_process(unsigned long arg) 12051da177e4SLinus Torvalds { 12061da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 12071da177e4SLinus Torvalds long sched_next = 0; 12081da177e4SLinus Torvalds unsigned long now = jiffies; 12091da177e4SLinus Torvalds struct sk_buff *skb; 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds skb = tbl->proxy_queue.next; 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds while (skb != (struct sk_buff *)&tbl->proxy_queue) { 12161da177e4SLinus Torvalds struct sk_buff *back = skb; 1217a61bbcf2SPatrick McHardy long tdif = NEIGH_CB(back)->sched_next - now; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds skb = skb->next; 12201da177e4SLinus Torvalds if (tdif <= 0) { 12211da177e4SLinus Torvalds struct net_device *dev = back->dev; 12221da177e4SLinus Torvalds __skb_unlink(back, &tbl->proxy_queue); 12231da177e4SLinus Torvalds if (tbl->proxy_redo && netif_running(dev)) 12241da177e4SLinus Torvalds tbl->proxy_redo(back); 12251da177e4SLinus Torvalds else 12261da177e4SLinus Torvalds kfree_skb(back); 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds dev_put(dev); 12291da177e4SLinus Torvalds } else if (!sched_next || tdif < sched_next) 12301da177e4SLinus Torvalds sched_next = tdif; 12311da177e4SLinus Torvalds } 12321da177e4SLinus Torvalds del_timer(&tbl->proxy_timer); 12331da177e4SLinus Torvalds if (sched_next) 12341da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, jiffies + sched_next); 12351da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 12391da177e4SLinus Torvalds struct sk_buff *skb) 12401da177e4SLinus Torvalds { 12411da177e4SLinus Torvalds unsigned long now = jiffies; 12421da177e4SLinus Torvalds unsigned long sched_next = now + (net_random() % p->proxy_delay); 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds if (tbl->proxy_queue.qlen > p->proxy_qlen) { 12451da177e4SLinus Torvalds kfree_skb(skb); 12461da177e4SLinus Torvalds return; 12471da177e4SLinus Torvalds } 1248a61bbcf2SPatrick McHardy 1249a61bbcf2SPatrick McHardy NEIGH_CB(skb)->sched_next = sched_next; 1250a61bbcf2SPatrick McHardy NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED; 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 12531da177e4SLinus Torvalds if (del_timer(&tbl->proxy_timer)) { 12541da177e4SLinus Torvalds if (time_before(tbl->proxy_timer.expires, sched_next)) 12551da177e4SLinus Torvalds sched_next = tbl->proxy_timer.expires; 12561da177e4SLinus Torvalds } 12571da177e4SLinus Torvalds dst_release(skb->dst); 12581da177e4SLinus Torvalds skb->dst = NULL; 12591da177e4SLinus Torvalds dev_hold(skb->dev); 12601da177e4SLinus Torvalds __skb_queue_tail(&tbl->proxy_queue, skb); 12611da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, sched_next); 12621da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 12631da177e4SLinus Torvalds } 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 12671da177e4SLinus Torvalds struct neigh_table *tbl) 12681da177e4SLinus Torvalds { 12691da177e4SLinus Torvalds struct neigh_parms *p = kmalloc(sizeof(*p), GFP_KERNEL); 12701da177e4SLinus Torvalds 12711da177e4SLinus Torvalds if (p) { 12721da177e4SLinus Torvalds memcpy(p, &tbl->parms, sizeof(*p)); 12731da177e4SLinus Torvalds p->tbl = tbl; 12741da177e4SLinus Torvalds atomic_set(&p->refcnt, 1); 12751da177e4SLinus Torvalds INIT_RCU_HEAD(&p->rcu_head); 12761da177e4SLinus Torvalds p->reachable_time = 12771da177e4SLinus Torvalds neigh_rand_reach_time(p->base_reachable_time); 1278c7fb64dbSThomas Graf if (dev) { 1279c7fb64dbSThomas Graf if (dev->neigh_setup && dev->neigh_setup(dev, p)) { 12801da177e4SLinus Torvalds kfree(p); 12811da177e4SLinus Torvalds return NULL; 12821da177e4SLinus Torvalds } 1283c7fb64dbSThomas Graf 1284c7fb64dbSThomas Graf dev_hold(dev); 1285c7fb64dbSThomas Graf p->dev = dev; 1286c7fb64dbSThomas Graf } 12871da177e4SLinus Torvalds p->sysctl_table = NULL; 12881da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 12891da177e4SLinus Torvalds p->next = tbl->parms.next; 12901da177e4SLinus Torvalds tbl->parms.next = p; 12911da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 12921da177e4SLinus Torvalds } 12931da177e4SLinus Torvalds return p; 12941da177e4SLinus Torvalds } 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds static void neigh_rcu_free_parms(struct rcu_head *head) 12971da177e4SLinus Torvalds { 12981da177e4SLinus Torvalds struct neigh_parms *parms = 12991da177e4SLinus Torvalds container_of(head, struct neigh_parms, rcu_head); 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds neigh_parms_put(parms); 13021da177e4SLinus Torvalds } 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 13051da177e4SLinus Torvalds { 13061da177e4SLinus Torvalds struct neigh_parms **p; 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds if (!parms || parms == &tbl->parms) 13091da177e4SLinus Torvalds return; 13101da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 13111da177e4SLinus Torvalds for (p = &tbl->parms.next; *p; p = &(*p)->next) { 13121da177e4SLinus Torvalds if (*p == parms) { 13131da177e4SLinus Torvalds *p = parms->next; 13141da177e4SLinus Torvalds parms->dead = 1; 13151da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1316c7fb64dbSThomas Graf if (parms->dev) 1317c7fb64dbSThomas Graf dev_put(parms->dev); 13181da177e4SLinus Torvalds call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 13191da177e4SLinus Torvalds return; 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds } 13221da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 13231da177e4SLinus Torvalds NEIGH_PRINTK1("neigh_parms_release: not found\n"); 13241da177e4SLinus Torvalds } 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds void neigh_parms_destroy(struct neigh_parms *parms) 13271da177e4SLinus Torvalds { 13281da177e4SLinus Torvalds kfree(parms); 13291da177e4SLinus Torvalds } 13301da177e4SLinus Torvalds 1331bd89efc5SSimon Kelley void neigh_table_init_no_netlink(struct neigh_table *tbl) 13321da177e4SLinus Torvalds { 13331da177e4SLinus Torvalds unsigned long now = jiffies; 13341da177e4SLinus Torvalds unsigned long phsize; 13351da177e4SLinus Torvalds 13361da177e4SLinus Torvalds atomic_set(&tbl->parms.refcnt, 1); 13371da177e4SLinus Torvalds INIT_RCU_HEAD(&tbl->parms.rcu_head); 13381da177e4SLinus Torvalds tbl->parms.reachable_time = 13391da177e4SLinus Torvalds neigh_rand_reach_time(tbl->parms.base_reachable_time); 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds if (!tbl->kmem_cachep) 1342e5d679f3SAlexey Dobriyan tbl->kmem_cachep = 1343e5d679f3SAlexey Dobriyan kmem_cache_create(tbl->id, tbl->entry_size, 0, 1344e5d679f3SAlexey Dobriyan SLAB_HWCACHE_ALIGN|SLAB_PANIC, 13451da177e4SLinus Torvalds NULL, NULL); 13461da177e4SLinus Torvalds tbl->stats = alloc_percpu(struct neigh_statistics); 13471da177e4SLinus Torvalds if (!tbl->stats) 13481da177e4SLinus Torvalds panic("cannot create neighbour cache statistics"); 13491da177e4SLinus Torvalds 13501da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 13511da177e4SLinus Torvalds tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat); 13521da177e4SLinus Torvalds if (!tbl->pde) 13531da177e4SLinus Torvalds panic("cannot create neighbour proc dir entry"); 13541da177e4SLinus Torvalds tbl->pde->proc_fops = &neigh_stat_seq_fops; 13551da177e4SLinus Torvalds tbl->pde->data = tbl; 13561da177e4SLinus Torvalds #endif 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds tbl->hash_mask = 1; 13591da177e4SLinus Torvalds tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1); 13601da177e4SLinus Torvalds 13611da177e4SLinus Torvalds phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 136277d04bd9SAndrew Morton tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL); 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds if (!tbl->hash_buckets || !tbl->phash_buckets) 13651da177e4SLinus Torvalds panic("cannot allocate neighbour cache hashes"); 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds rwlock_init(&tbl->lock); 13701da177e4SLinus Torvalds init_timer(&tbl->gc_timer); 13711da177e4SLinus Torvalds tbl->gc_timer.data = (unsigned long)tbl; 13721da177e4SLinus Torvalds tbl->gc_timer.function = neigh_periodic_timer; 13731da177e4SLinus Torvalds tbl->gc_timer.expires = now + 1; 13741da177e4SLinus Torvalds add_timer(&tbl->gc_timer); 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds init_timer(&tbl->proxy_timer); 13771da177e4SLinus Torvalds tbl->proxy_timer.data = (unsigned long)tbl; 13781da177e4SLinus Torvalds tbl->proxy_timer.function = neigh_proxy_process; 13791da177e4SLinus Torvalds skb_queue_head_init(&tbl->proxy_queue); 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds tbl->last_flush = now; 13821da177e4SLinus Torvalds tbl->last_rand = now + tbl->parms.reachable_time * 20; 1383bd89efc5SSimon Kelley } 1384bd89efc5SSimon Kelley 1385bd89efc5SSimon Kelley void neigh_table_init(struct neigh_table *tbl) 1386bd89efc5SSimon Kelley { 1387bd89efc5SSimon Kelley struct neigh_table *tmp; 1388bd89efc5SSimon Kelley 1389bd89efc5SSimon Kelley neigh_table_init_no_netlink(tbl); 13901da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 1391bd89efc5SSimon Kelley for (tmp = neigh_tables; tmp; tmp = tmp->next) { 1392bd89efc5SSimon Kelley if (tmp->family == tbl->family) 1393bd89efc5SSimon Kelley break; 1394bd89efc5SSimon Kelley } 13951da177e4SLinus Torvalds tbl->next = neigh_tables; 13961da177e4SLinus Torvalds neigh_tables = tbl; 13971da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 1398bd89efc5SSimon Kelley 1399bd89efc5SSimon Kelley if (unlikely(tmp)) { 1400bd89efc5SSimon Kelley printk(KERN_ERR "NEIGH: Registering multiple tables for " 1401bd89efc5SSimon Kelley "family %d\n", tbl->family); 1402bd89efc5SSimon Kelley dump_stack(); 1403bd89efc5SSimon Kelley } 14041da177e4SLinus Torvalds } 14051da177e4SLinus Torvalds 14061da177e4SLinus Torvalds int neigh_table_clear(struct neigh_table *tbl) 14071da177e4SLinus Torvalds { 14081da177e4SLinus Torvalds struct neigh_table **tp; 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds /* It is not clean... Fix it to unload IPv6 module safely */ 14111da177e4SLinus Torvalds del_timer_sync(&tbl->gc_timer); 14121da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 14131da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 14141da177e4SLinus Torvalds neigh_ifdown(tbl, NULL); 14151da177e4SLinus Torvalds if (atomic_read(&tbl->entries)) 14161da177e4SLinus Torvalds printk(KERN_CRIT "neighbour leakage\n"); 14171da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 14181da177e4SLinus Torvalds for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { 14191da177e4SLinus Torvalds if (*tp == tbl) { 14201da177e4SLinus Torvalds *tp = tbl->next; 14211da177e4SLinus Torvalds break; 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1); 14271da177e4SLinus Torvalds tbl->hash_buckets = NULL; 14281da177e4SLinus Torvalds 14291da177e4SLinus Torvalds kfree(tbl->phash_buckets); 14301da177e4SLinus Torvalds tbl->phash_buckets = NULL; 14311da177e4SLinus Torvalds 14323fcde74bSKirill Korotaev free_percpu(tbl->stats); 14333fcde74bSKirill Korotaev tbl->stats = NULL; 14343fcde74bSKirill Korotaev 14351da177e4SLinus Torvalds return 0; 14361da177e4SLinus Torvalds } 14371da177e4SLinus Torvalds 14381da177e4SLinus Torvalds int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 14391da177e4SLinus Torvalds { 1440a14a49d2SThomas Graf struct ndmsg *ndm; 1441a14a49d2SThomas Graf struct nlattr *dst_attr; 14421da177e4SLinus Torvalds struct neigh_table *tbl; 14431da177e4SLinus Torvalds struct net_device *dev = NULL; 1444a14a49d2SThomas Graf int err = -EINVAL; 14451da177e4SLinus Torvalds 1446a14a49d2SThomas Graf if (nlmsg_len(nlh) < sizeof(*ndm)) 14471da177e4SLinus Torvalds goto out; 14481da177e4SLinus Torvalds 1449a14a49d2SThomas Graf dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST); 1450a14a49d2SThomas Graf if (dst_attr == NULL) 1451a14a49d2SThomas Graf goto out; 1452a14a49d2SThomas Graf 1453a14a49d2SThomas Graf ndm = nlmsg_data(nlh); 1454a14a49d2SThomas Graf if (ndm->ndm_ifindex) { 1455a14a49d2SThomas Graf dev = dev_get_by_index(ndm->ndm_ifindex); 1456a14a49d2SThomas Graf if (dev == NULL) { 1457a14a49d2SThomas Graf err = -ENODEV; 1458a14a49d2SThomas Graf goto out; 1459a14a49d2SThomas Graf } 1460a14a49d2SThomas Graf } 1461a14a49d2SThomas Graf 14621da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 14631da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1464a14a49d2SThomas Graf struct neighbour *neigh; 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 14671da177e4SLinus Torvalds continue; 14681da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 14691da177e4SLinus Torvalds 1470a14a49d2SThomas Graf if (nla_len(dst_attr) < tbl->key_len) 14711da177e4SLinus Torvalds goto out_dev_put; 14721da177e4SLinus Torvalds 14731da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 1474a14a49d2SThomas Graf err = pneigh_delete(tbl, nla_data(dst_attr), dev); 14751da177e4SLinus Torvalds goto out_dev_put; 14761da177e4SLinus Torvalds } 14771da177e4SLinus Torvalds 1478a14a49d2SThomas Graf if (dev == NULL) 1479a14a49d2SThomas Graf goto out_dev_put; 14801da177e4SLinus Torvalds 1481a14a49d2SThomas Graf neigh = neigh_lookup(tbl, nla_data(dst_attr), dev); 1482a14a49d2SThomas Graf if (neigh == NULL) { 1483a14a49d2SThomas Graf err = -ENOENT; 1484a14a49d2SThomas Graf goto out_dev_put; 1485a14a49d2SThomas Graf } 1486a14a49d2SThomas Graf 1487a14a49d2SThomas Graf err = neigh_update(neigh, NULL, NUD_FAILED, 14881da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE | 14891da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN); 1490a14a49d2SThomas Graf neigh_release(neigh); 14911da177e4SLinus Torvalds goto out_dev_put; 14921da177e4SLinus Torvalds } 14931da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 1494a14a49d2SThomas Graf err = -EAFNOSUPPORT; 1495a14a49d2SThomas Graf 14961da177e4SLinus Torvalds out_dev_put: 14971da177e4SLinus Torvalds if (dev) 14981da177e4SLinus Torvalds dev_put(dev); 14991da177e4SLinus Torvalds out: 15001da177e4SLinus Torvalds return err; 15011da177e4SLinus Torvalds } 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 15041da177e4SLinus Torvalds { 15055208debdSThomas Graf struct ndmsg *ndm; 15065208debdSThomas Graf struct nlattr *tb[NDA_MAX+1]; 15071da177e4SLinus Torvalds struct neigh_table *tbl; 15081da177e4SLinus Torvalds struct net_device *dev = NULL; 15095208debdSThomas Graf int err; 15101da177e4SLinus Torvalds 15115208debdSThomas Graf err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL); 15125208debdSThomas Graf if (err < 0) 15131da177e4SLinus Torvalds goto out; 15141da177e4SLinus Torvalds 15155208debdSThomas Graf err = -EINVAL; 15165208debdSThomas Graf if (tb[NDA_DST] == NULL) 15175208debdSThomas Graf goto out; 15185208debdSThomas Graf 15195208debdSThomas Graf ndm = nlmsg_data(nlh); 15205208debdSThomas Graf if (ndm->ndm_ifindex) { 15215208debdSThomas Graf dev = dev_get_by_index(ndm->ndm_ifindex); 15225208debdSThomas Graf if (dev == NULL) { 15235208debdSThomas Graf err = -ENODEV; 15245208debdSThomas Graf goto out; 15255208debdSThomas Graf } 15265208debdSThomas Graf 15275208debdSThomas Graf if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len) 15285208debdSThomas Graf goto out_dev_put; 15295208debdSThomas Graf } 15305208debdSThomas Graf 15311da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 15321da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 15335208debdSThomas Graf int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE; 15345208debdSThomas Graf struct neighbour *neigh; 15355208debdSThomas Graf void *dst, *lladdr; 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 15381da177e4SLinus Torvalds continue; 15391da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 15401da177e4SLinus Torvalds 15415208debdSThomas Graf if (nla_len(tb[NDA_DST]) < tbl->key_len) 15421da177e4SLinus Torvalds goto out_dev_put; 15435208debdSThomas Graf dst = nla_data(tb[NDA_DST]); 15445208debdSThomas Graf lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL; 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 154762dd9318SVille Nuorvala struct pneigh_entry *pn; 154862dd9318SVille Nuorvala 15495208debdSThomas Graf err = -ENOBUFS; 155062dd9318SVille Nuorvala pn = pneigh_lookup(tbl, dst, dev, 1); 155162dd9318SVille Nuorvala if (pn) { 155262dd9318SVille Nuorvala pn->flags = ndm->ndm_flags; 155362dd9318SVille Nuorvala err = 0; 155462dd9318SVille Nuorvala } 15551da177e4SLinus Torvalds goto out_dev_put; 15561da177e4SLinus Torvalds } 15571da177e4SLinus Torvalds 15585208debdSThomas Graf if (dev == NULL) 15591da177e4SLinus Torvalds goto out_dev_put; 15601da177e4SLinus Torvalds 15615208debdSThomas Graf neigh = neigh_lookup(tbl, dst, dev); 15625208debdSThomas Graf if (neigh == NULL) { 15635208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 15641da177e4SLinus Torvalds err = -ENOENT; 15651da177e4SLinus Torvalds goto out_dev_put; 15665208debdSThomas Graf } 15675208debdSThomas Graf 15685208debdSThomas Graf neigh = __neigh_lookup_errno(tbl, dst, dev); 15695208debdSThomas Graf if (IS_ERR(neigh)) { 15705208debdSThomas Graf err = PTR_ERR(neigh); 15711da177e4SLinus Torvalds goto out_dev_put; 15721da177e4SLinus Torvalds } 15735208debdSThomas Graf } else { 15745208debdSThomas Graf if (nlh->nlmsg_flags & NLM_F_EXCL) { 15755208debdSThomas Graf err = -EEXIST; 15765208debdSThomas Graf neigh_release(neigh); 15775208debdSThomas Graf goto out_dev_put; 15781da177e4SLinus Torvalds } 15791da177e4SLinus Torvalds 15805208debdSThomas Graf if (!(nlh->nlmsg_flags & NLM_F_REPLACE)) 15815208debdSThomas Graf flags &= ~NEIGH_UPDATE_F_OVERRIDE; 15825208debdSThomas Graf } 15831da177e4SLinus Torvalds 15845208debdSThomas Graf err = neigh_update(neigh, lladdr, ndm->ndm_state, flags); 15855208debdSThomas Graf neigh_release(neigh); 15861da177e4SLinus Torvalds goto out_dev_put; 15871da177e4SLinus Torvalds } 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 15905208debdSThomas Graf err = -EAFNOSUPPORT; 15915208debdSThomas Graf 15921da177e4SLinus Torvalds out_dev_put: 15931da177e4SLinus Torvalds if (dev) 15941da177e4SLinus Torvalds dev_put(dev); 15951da177e4SLinus Torvalds out: 15961da177e4SLinus Torvalds return err; 15971da177e4SLinus Torvalds } 15981da177e4SLinus Torvalds 1599c7fb64dbSThomas Graf static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms) 1600c7fb64dbSThomas Graf { 1601ca860fb3SThomas Graf struct nlattr *nest; 1602e386c6ebSThomas Graf 1603ca860fb3SThomas Graf nest = nla_nest_start(skb, NDTA_PARMS); 1604ca860fb3SThomas Graf if (nest == NULL) 1605ca860fb3SThomas Graf return -ENOBUFS; 1606c7fb64dbSThomas Graf 1607c7fb64dbSThomas Graf if (parms->dev) 1608ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_IFINDEX, parms->dev->ifindex); 1609c7fb64dbSThomas Graf 1610ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)); 1611ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_QUEUE_LEN, parms->queue_len); 1612ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_PROXY_QLEN, parms->proxy_qlen); 1613ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_APP_PROBES, parms->app_probes); 1614ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_UCAST_PROBES, parms->ucast_probes); 1615ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTPA_MCAST_PROBES, parms->mcast_probes); 1616ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_REACHABLE_TIME, parms->reachable_time); 1617ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_BASE_REACHABLE_TIME, 1618c7fb64dbSThomas Graf parms->base_reachable_time); 1619ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_GC_STALETIME, parms->gc_staletime); 1620ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_DELAY_PROBE_TIME, parms->delay_probe_time); 1621ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_RETRANS_TIME, parms->retrans_time); 1622ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_ANYCAST_DELAY, parms->anycast_delay); 1623ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_PROXY_DELAY, parms->proxy_delay); 1624ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTPA_LOCKTIME, parms->locktime); 1625c7fb64dbSThomas Graf 1626ca860fb3SThomas Graf return nla_nest_end(skb, nest); 1627c7fb64dbSThomas Graf 1628ca860fb3SThomas Graf nla_put_failure: 1629ca860fb3SThomas Graf return nla_nest_cancel(skb, nest); 1630c7fb64dbSThomas Graf } 1631c7fb64dbSThomas Graf 1632ca860fb3SThomas Graf static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl, 1633ca860fb3SThomas Graf u32 pid, u32 seq, int type, int flags) 1634c7fb64dbSThomas Graf { 1635c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1636c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1637c7fb64dbSThomas Graf 1638ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1639ca860fb3SThomas Graf if (nlh == NULL) 1640ca860fb3SThomas Graf return -ENOBUFS; 1641c7fb64dbSThomas Graf 1642ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1643c7fb64dbSThomas Graf 1644c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1645c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 16469ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 16479ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1648c7fb64dbSThomas Graf 1649ca860fb3SThomas Graf NLA_PUT_STRING(skb, NDTA_NAME, tbl->id); 1650ca860fb3SThomas Graf NLA_PUT_MSECS(skb, NDTA_GC_INTERVAL, tbl->gc_interval); 1651ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTA_THRESH1, tbl->gc_thresh1); 1652ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTA_THRESH2, tbl->gc_thresh2); 1653ca860fb3SThomas Graf NLA_PUT_U32(skb, NDTA_THRESH3, tbl->gc_thresh3); 1654c7fb64dbSThomas Graf 1655c7fb64dbSThomas Graf { 1656c7fb64dbSThomas Graf unsigned long now = jiffies; 1657c7fb64dbSThomas Graf unsigned int flush_delta = now - tbl->last_flush; 1658c7fb64dbSThomas Graf unsigned int rand_delta = now - tbl->last_rand; 1659c7fb64dbSThomas Graf 1660c7fb64dbSThomas Graf struct ndt_config ndc = { 1661c7fb64dbSThomas Graf .ndtc_key_len = tbl->key_len, 1662c7fb64dbSThomas Graf .ndtc_entry_size = tbl->entry_size, 1663c7fb64dbSThomas Graf .ndtc_entries = atomic_read(&tbl->entries), 1664c7fb64dbSThomas Graf .ndtc_last_flush = jiffies_to_msecs(flush_delta), 1665c7fb64dbSThomas Graf .ndtc_last_rand = jiffies_to_msecs(rand_delta), 1666c7fb64dbSThomas Graf .ndtc_hash_rnd = tbl->hash_rnd, 1667c7fb64dbSThomas Graf .ndtc_hash_mask = tbl->hash_mask, 1668c7fb64dbSThomas Graf .ndtc_hash_chain_gc = tbl->hash_chain_gc, 1669c7fb64dbSThomas Graf .ndtc_proxy_qlen = tbl->proxy_queue.qlen, 1670c7fb64dbSThomas Graf }; 1671c7fb64dbSThomas Graf 1672ca860fb3SThomas Graf NLA_PUT(skb, NDTA_CONFIG, sizeof(ndc), &ndc); 1673c7fb64dbSThomas Graf } 1674c7fb64dbSThomas Graf 1675c7fb64dbSThomas Graf { 1676c7fb64dbSThomas Graf int cpu; 1677c7fb64dbSThomas Graf struct ndt_stats ndst; 1678c7fb64dbSThomas Graf 1679c7fb64dbSThomas Graf memset(&ndst, 0, sizeof(ndst)); 1680c7fb64dbSThomas Graf 16816f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) { 1682c7fb64dbSThomas Graf struct neigh_statistics *st; 1683c7fb64dbSThomas Graf 1684c7fb64dbSThomas Graf st = per_cpu_ptr(tbl->stats, cpu); 1685c7fb64dbSThomas Graf ndst.ndts_allocs += st->allocs; 1686c7fb64dbSThomas Graf ndst.ndts_destroys += st->destroys; 1687c7fb64dbSThomas Graf ndst.ndts_hash_grows += st->hash_grows; 1688c7fb64dbSThomas Graf ndst.ndts_res_failed += st->res_failed; 1689c7fb64dbSThomas Graf ndst.ndts_lookups += st->lookups; 1690c7fb64dbSThomas Graf ndst.ndts_hits += st->hits; 1691c7fb64dbSThomas Graf ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast; 1692c7fb64dbSThomas Graf ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast; 1693c7fb64dbSThomas Graf ndst.ndts_periodic_gc_runs += st->periodic_gc_runs; 1694c7fb64dbSThomas Graf ndst.ndts_forced_gc_runs += st->forced_gc_runs; 1695c7fb64dbSThomas Graf } 1696c7fb64dbSThomas Graf 1697ca860fb3SThomas Graf NLA_PUT(skb, NDTA_STATS, sizeof(ndst), &ndst); 1698c7fb64dbSThomas Graf } 1699c7fb64dbSThomas Graf 1700c7fb64dbSThomas Graf BUG_ON(tbl->parms.dev); 1701c7fb64dbSThomas Graf if (neightbl_fill_parms(skb, &tbl->parms) < 0) 1702ca860fb3SThomas Graf goto nla_put_failure; 1703c7fb64dbSThomas Graf 1704c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1705ca860fb3SThomas Graf return nlmsg_end(skb, nlh); 1706c7fb64dbSThomas Graf 1707ca860fb3SThomas Graf nla_put_failure: 1708c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1709ca860fb3SThomas Graf return nlmsg_cancel(skb, nlh); 1710c7fb64dbSThomas Graf } 1711c7fb64dbSThomas Graf 1712ca860fb3SThomas Graf static int neightbl_fill_param_info(struct sk_buff *skb, 1713ca860fb3SThomas Graf struct neigh_table *tbl, 1714c7fb64dbSThomas Graf struct neigh_parms *parms, 1715ca860fb3SThomas Graf u32 pid, u32 seq, int type, 1716ca860fb3SThomas Graf unsigned int flags) 1717c7fb64dbSThomas Graf { 1718c7fb64dbSThomas Graf struct ndtmsg *ndtmsg; 1719c7fb64dbSThomas Graf struct nlmsghdr *nlh; 1720c7fb64dbSThomas Graf 1721ca860fb3SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags); 1722ca860fb3SThomas Graf if (nlh == NULL) 1723ca860fb3SThomas Graf return -ENOBUFS; 1724c7fb64dbSThomas Graf 1725ca860fb3SThomas Graf ndtmsg = nlmsg_data(nlh); 1726c7fb64dbSThomas Graf 1727c7fb64dbSThomas Graf read_lock_bh(&tbl->lock); 1728c7fb64dbSThomas Graf ndtmsg->ndtm_family = tbl->family; 17299ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad1 = 0; 17309ef1d4c7SPatrick McHardy ndtmsg->ndtm_pad2 = 0; 1731c7fb64dbSThomas Graf 1732ca860fb3SThomas Graf if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 || 1733ca860fb3SThomas Graf neightbl_fill_parms(skb, parms) < 0) 1734ca860fb3SThomas Graf goto errout; 1735c7fb64dbSThomas Graf 1736c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1737ca860fb3SThomas Graf return nlmsg_end(skb, nlh); 1738ca860fb3SThomas Graf errout: 1739c7fb64dbSThomas Graf read_unlock_bh(&tbl->lock); 1740ca860fb3SThomas Graf return nlmsg_cancel(skb, nlh); 1741c7fb64dbSThomas Graf } 1742c7fb64dbSThomas Graf 1743c7fb64dbSThomas Graf static inline struct neigh_parms *lookup_neigh_params(struct neigh_table *tbl, 1744c7fb64dbSThomas Graf int ifindex) 1745c7fb64dbSThomas Graf { 1746c7fb64dbSThomas Graf struct neigh_parms *p; 1747c7fb64dbSThomas Graf 1748c7fb64dbSThomas Graf for (p = &tbl->parms; p; p = p->next) 1749c7fb64dbSThomas Graf if ((p->dev && p->dev->ifindex == ifindex) || 1750c7fb64dbSThomas Graf (!p->dev && !ifindex)) 1751c7fb64dbSThomas Graf return p; 1752c7fb64dbSThomas Graf 1753c7fb64dbSThomas Graf return NULL; 1754c7fb64dbSThomas Graf } 1755c7fb64dbSThomas Graf 17566b3f8674SThomas Graf static struct nla_policy nl_neightbl_policy[NDTA_MAX+1] __read_mostly = { 17576b3f8674SThomas Graf [NDTA_NAME] = { .type = NLA_STRING }, 17586b3f8674SThomas Graf [NDTA_THRESH1] = { .type = NLA_U32 }, 17596b3f8674SThomas Graf [NDTA_THRESH2] = { .type = NLA_U32 }, 17606b3f8674SThomas Graf [NDTA_THRESH3] = { .type = NLA_U32 }, 17616b3f8674SThomas Graf [NDTA_GC_INTERVAL] = { .type = NLA_U64 }, 17626b3f8674SThomas Graf [NDTA_PARMS] = { .type = NLA_NESTED }, 17636b3f8674SThomas Graf }; 17646b3f8674SThomas Graf 17656b3f8674SThomas Graf static struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] __read_mostly = { 17666b3f8674SThomas Graf [NDTPA_IFINDEX] = { .type = NLA_U32 }, 17676b3f8674SThomas Graf [NDTPA_QUEUE_LEN] = { .type = NLA_U32 }, 17686b3f8674SThomas Graf [NDTPA_PROXY_QLEN] = { .type = NLA_U32 }, 17696b3f8674SThomas Graf [NDTPA_APP_PROBES] = { .type = NLA_U32 }, 17706b3f8674SThomas Graf [NDTPA_UCAST_PROBES] = { .type = NLA_U32 }, 17716b3f8674SThomas Graf [NDTPA_MCAST_PROBES] = { .type = NLA_U32 }, 17726b3f8674SThomas Graf [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 }, 17736b3f8674SThomas Graf [NDTPA_GC_STALETIME] = { .type = NLA_U64 }, 17746b3f8674SThomas Graf [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 }, 17756b3f8674SThomas Graf [NDTPA_RETRANS_TIME] = { .type = NLA_U64 }, 17766b3f8674SThomas Graf [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 }, 17776b3f8674SThomas Graf [NDTPA_PROXY_DELAY] = { .type = NLA_U64 }, 17786b3f8674SThomas Graf [NDTPA_LOCKTIME] = { .type = NLA_U64 }, 17796b3f8674SThomas Graf }; 17806b3f8674SThomas Graf 1781c7fb64dbSThomas Graf int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 1782c7fb64dbSThomas Graf { 1783c7fb64dbSThomas Graf struct neigh_table *tbl; 17846b3f8674SThomas Graf struct ndtmsg *ndtmsg; 17856b3f8674SThomas Graf struct nlattr *tb[NDTA_MAX+1]; 17866b3f8674SThomas Graf int err; 1787c7fb64dbSThomas Graf 17886b3f8674SThomas Graf err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX, 17896b3f8674SThomas Graf nl_neightbl_policy); 17906b3f8674SThomas Graf if (err < 0) 17916b3f8674SThomas Graf goto errout; 1792c7fb64dbSThomas Graf 17936b3f8674SThomas Graf if (tb[NDTA_NAME] == NULL) { 17946b3f8674SThomas Graf err = -EINVAL; 17956b3f8674SThomas Graf goto errout; 17966b3f8674SThomas Graf } 17976b3f8674SThomas Graf 17986b3f8674SThomas Graf ndtmsg = nlmsg_data(nlh); 1799c7fb64dbSThomas Graf read_lock(&neigh_tbl_lock); 1800c7fb64dbSThomas Graf for (tbl = neigh_tables; tbl; tbl = tbl->next) { 1801c7fb64dbSThomas Graf if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family) 1802c7fb64dbSThomas Graf continue; 1803c7fb64dbSThomas Graf 18046b3f8674SThomas Graf if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) 1805c7fb64dbSThomas Graf break; 1806c7fb64dbSThomas Graf } 1807c7fb64dbSThomas Graf 1808c7fb64dbSThomas Graf if (tbl == NULL) { 1809c7fb64dbSThomas Graf err = -ENOENT; 18106b3f8674SThomas Graf goto errout_locked; 1811c7fb64dbSThomas Graf } 1812c7fb64dbSThomas Graf 1813c7fb64dbSThomas Graf /* 1814c7fb64dbSThomas Graf * We acquire tbl->lock to be nice to the periodic timers and 1815c7fb64dbSThomas Graf * make sure they always see a consistent set of values. 1816c7fb64dbSThomas Graf */ 1817c7fb64dbSThomas Graf write_lock_bh(&tbl->lock); 1818c7fb64dbSThomas Graf 18196b3f8674SThomas Graf if (tb[NDTA_PARMS]) { 18206b3f8674SThomas Graf struct nlattr *tbp[NDTPA_MAX+1]; 1821c7fb64dbSThomas Graf struct neigh_parms *p; 18226b3f8674SThomas Graf int i, ifindex = 0; 1823c7fb64dbSThomas Graf 18246b3f8674SThomas Graf err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS], 18256b3f8674SThomas Graf nl_ntbl_parm_policy); 18266b3f8674SThomas Graf if (err < 0) 18276b3f8674SThomas Graf goto errout_tbl_lock; 1828c7fb64dbSThomas Graf 18296b3f8674SThomas Graf if (tbp[NDTPA_IFINDEX]) 18306b3f8674SThomas Graf ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]); 1831c7fb64dbSThomas Graf 1832c7fb64dbSThomas Graf p = lookup_neigh_params(tbl, ifindex); 1833c7fb64dbSThomas Graf if (p == NULL) { 1834c7fb64dbSThomas Graf err = -ENOENT; 18356b3f8674SThomas Graf goto errout_tbl_lock; 1836c7fb64dbSThomas Graf } 1837c7fb64dbSThomas Graf 18386b3f8674SThomas Graf for (i = 1; i <= NDTPA_MAX; i++) { 18396b3f8674SThomas Graf if (tbp[i] == NULL) 18406b3f8674SThomas Graf continue; 1841c7fb64dbSThomas Graf 18426b3f8674SThomas Graf switch (i) { 18436b3f8674SThomas Graf case NDTPA_QUEUE_LEN: 18446b3f8674SThomas Graf p->queue_len = nla_get_u32(tbp[i]); 18456b3f8674SThomas Graf break; 18466b3f8674SThomas Graf case NDTPA_PROXY_QLEN: 18476b3f8674SThomas Graf p->proxy_qlen = nla_get_u32(tbp[i]); 18486b3f8674SThomas Graf break; 18496b3f8674SThomas Graf case NDTPA_APP_PROBES: 18506b3f8674SThomas Graf p->app_probes = nla_get_u32(tbp[i]); 18516b3f8674SThomas Graf break; 18526b3f8674SThomas Graf case NDTPA_UCAST_PROBES: 18536b3f8674SThomas Graf p->ucast_probes = nla_get_u32(tbp[i]); 18546b3f8674SThomas Graf break; 18556b3f8674SThomas Graf case NDTPA_MCAST_PROBES: 18566b3f8674SThomas Graf p->mcast_probes = nla_get_u32(tbp[i]); 18576b3f8674SThomas Graf break; 18586b3f8674SThomas Graf case NDTPA_BASE_REACHABLE_TIME: 18596b3f8674SThomas Graf p->base_reachable_time = nla_get_msecs(tbp[i]); 18606b3f8674SThomas Graf break; 18616b3f8674SThomas Graf case NDTPA_GC_STALETIME: 18626b3f8674SThomas Graf p->gc_staletime = nla_get_msecs(tbp[i]); 18636b3f8674SThomas Graf break; 18646b3f8674SThomas Graf case NDTPA_DELAY_PROBE_TIME: 18656b3f8674SThomas Graf p->delay_probe_time = nla_get_msecs(tbp[i]); 18666b3f8674SThomas Graf break; 18676b3f8674SThomas Graf case NDTPA_RETRANS_TIME: 18686b3f8674SThomas Graf p->retrans_time = nla_get_msecs(tbp[i]); 18696b3f8674SThomas Graf break; 18706b3f8674SThomas Graf case NDTPA_ANYCAST_DELAY: 18716b3f8674SThomas Graf p->anycast_delay = nla_get_msecs(tbp[i]); 18726b3f8674SThomas Graf break; 18736b3f8674SThomas Graf case NDTPA_PROXY_DELAY: 18746b3f8674SThomas Graf p->proxy_delay = nla_get_msecs(tbp[i]); 18756b3f8674SThomas Graf break; 18766b3f8674SThomas Graf case NDTPA_LOCKTIME: 18776b3f8674SThomas Graf p->locktime = nla_get_msecs(tbp[i]); 18786b3f8674SThomas Graf break; 1879c7fb64dbSThomas Graf } 18806b3f8674SThomas Graf } 18816b3f8674SThomas Graf } 18826b3f8674SThomas Graf 18836b3f8674SThomas Graf if (tb[NDTA_THRESH1]) 18846b3f8674SThomas Graf tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]); 18856b3f8674SThomas Graf 18866b3f8674SThomas Graf if (tb[NDTA_THRESH2]) 18876b3f8674SThomas Graf tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]); 18886b3f8674SThomas Graf 18896b3f8674SThomas Graf if (tb[NDTA_THRESH3]) 18906b3f8674SThomas Graf tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]); 18916b3f8674SThomas Graf 18926b3f8674SThomas Graf if (tb[NDTA_GC_INTERVAL]) 18936b3f8674SThomas Graf tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]); 1894c7fb64dbSThomas Graf 1895c7fb64dbSThomas Graf err = 0; 1896c7fb64dbSThomas Graf 18976b3f8674SThomas Graf errout_tbl_lock: 1898c7fb64dbSThomas Graf write_unlock_bh(&tbl->lock); 18996b3f8674SThomas Graf errout_locked: 1900c7fb64dbSThomas Graf read_unlock(&neigh_tbl_lock); 19016b3f8674SThomas Graf errout: 1902c7fb64dbSThomas Graf return err; 1903c7fb64dbSThomas Graf } 1904c7fb64dbSThomas Graf 1905c7fb64dbSThomas Graf int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 1906c7fb64dbSThomas Graf { 1907ca860fb3SThomas Graf int family, tidx, nidx = 0; 1908ca860fb3SThomas Graf int tbl_skip = cb->args[0]; 1909ca860fb3SThomas Graf int neigh_skip = cb->args[1]; 1910c7fb64dbSThomas Graf struct neigh_table *tbl; 1911c7fb64dbSThomas Graf 1912ca860fb3SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 1913c7fb64dbSThomas Graf 1914c7fb64dbSThomas Graf read_lock(&neigh_tbl_lock); 1915ca860fb3SThomas Graf for (tbl = neigh_tables, tidx = 0; tbl; tbl = tbl->next, tidx++) { 1916c7fb64dbSThomas Graf struct neigh_parms *p; 1917c7fb64dbSThomas Graf 1918ca860fb3SThomas Graf if (tidx < tbl_skip || (family && tbl->family != family)) 1919c7fb64dbSThomas Graf continue; 1920c7fb64dbSThomas Graf 1921ca860fb3SThomas Graf if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).pid, 1922ca860fb3SThomas Graf cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL, 1923ca860fb3SThomas Graf NLM_F_MULTI) <= 0) 1924c7fb64dbSThomas Graf break; 1925c7fb64dbSThomas Graf 1926ca860fb3SThomas Graf for (nidx = 0, p = tbl->parms.next; p; p = p->next, nidx++) { 1927ca860fb3SThomas Graf if (nidx < neigh_skip) 1928c7fb64dbSThomas Graf continue; 1929c7fb64dbSThomas Graf 1930ca860fb3SThomas Graf if (neightbl_fill_param_info(skb, tbl, p, 1931ca860fb3SThomas Graf NETLINK_CB(cb->skb).pid, 1932ca860fb3SThomas Graf cb->nlh->nlmsg_seq, 1933ca860fb3SThomas Graf RTM_NEWNEIGHTBL, 1934ca860fb3SThomas Graf NLM_F_MULTI) <= 0) 1935c7fb64dbSThomas Graf goto out; 1936c7fb64dbSThomas Graf } 1937c7fb64dbSThomas Graf 1938ca860fb3SThomas Graf neigh_skip = 0; 1939c7fb64dbSThomas Graf } 1940c7fb64dbSThomas Graf out: 1941c7fb64dbSThomas Graf read_unlock(&neigh_tbl_lock); 1942ca860fb3SThomas Graf cb->args[0] = tidx; 1943ca860fb3SThomas Graf cb->args[1] = nidx; 1944c7fb64dbSThomas Graf 1945c7fb64dbSThomas Graf return skb->len; 1946c7fb64dbSThomas Graf } 19471da177e4SLinus Torvalds 19488b8aec50SThomas Graf static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh, 19498b8aec50SThomas Graf u32 pid, u32 seq, int type, unsigned int flags) 19501da177e4SLinus Torvalds { 19511da177e4SLinus Torvalds unsigned long now = jiffies; 19521da177e4SLinus Torvalds struct nda_cacheinfo ci; 19538b8aec50SThomas Graf struct nlmsghdr *nlh; 19548b8aec50SThomas Graf struct ndmsg *ndm; 19551da177e4SLinus Torvalds 19568b8aec50SThomas Graf nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags); 19578b8aec50SThomas Graf if (nlh == NULL) 19588b8aec50SThomas Graf return -ENOBUFS; 19598b8aec50SThomas Graf 19608b8aec50SThomas Graf ndm = nlmsg_data(nlh); 19618b8aec50SThomas Graf ndm->ndm_family = neigh->ops->family; 19629ef1d4c7SPatrick McHardy ndm->ndm_pad1 = 0; 19639ef1d4c7SPatrick McHardy ndm->ndm_pad2 = 0; 19648b8aec50SThomas Graf ndm->ndm_flags = neigh->flags; 19658b8aec50SThomas Graf ndm->ndm_type = neigh->type; 19668b8aec50SThomas Graf ndm->ndm_ifindex = neigh->dev->ifindex; 19671da177e4SLinus Torvalds 19688b8aec50SThomas Graf NLA_PUT(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key); 19698b8aec50SThomas Graf 19708b8aec50SThomas Graf read_lock_bh(&neigh->lock); 19718b8aec50SThomas Graf ndm->ndm_state = neigh->nud_state; 19728b8aec50SThomas Graf if ((neigh->nud_state & NUD_VALID) && 19738b8aec50SThomas Graf nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, neigh->ha) < 0) { 19748b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 19758b8aec50SThomas Graf goto nla_put_failure; 19768b8aec50SThomas Graf } 19778b8aec50SThomas Graf 19788b8aec50SThomas Graf ci.ndm_used = now - neigh->used; 19798b8aec50SThomas Graf ci.ndm_confirmed = now - neigh->confirmed; 19808b8aec50SThomas Graf ci.ndm_updated = now - neigh->updated; 19818b8aec50SThomas Graf ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1; 19828b8aec50SThomas Graf read_unlock_bh(&neigh->lock); 19838b8aec50SThomas Graf 19848b8aec50SThomas Graf NLA_PUT_U32(skb, NDA_PROBES, atomic_read(&neigh->probes)); 19858b8aec50SThomas Graf NLA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci); 19868b8aec50SThomas Graf 19878b8aec50SThomas Graf return nlmsg_end(skb, nlh); 19888b8aec50SThomas Graf 19898b8aec50SThomas Graf nla_put_failure: 19908b8aec50SThomas Graf return nlmsg_cancel(skb, nlh); 19911da177e4SLinus Torvalds } 19921da177e4SLinus Torvalds 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 19951da177e4SLinus Torvalds struct netlink_callback *cb) 19961da177e4SLinus Torvalds { 19971da177e4SLinus Torvalds struct neighbour *n; 19981da177e4SLinus Torvalds int rc, h, s_h = cb->args[1]; 19991da177e4SLinus Torvalds int idx, s_idx = idx = cb->args[2]; 20001da177e4SLinus Torvalds 2001c5e29460SJulian Anastasov read_lock_bh(&tbl->lock); 20021da177e4SLinus Torvalds for (h = 0; h <= tbl->hash_mask; h++) { 20031da177e4SLinus Torvalds if (h < s_h) 20041da177e4SLinus Torvalds continue; 20051da177e4SLinus Torvalds if (h > s_h) 20061da177e4SLinus Torvalds s_idx = 0; 20071da177e4SLinus Torvalds for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) { 20081da177e4SLinus Torvalds if (idx < s_idx) 20091da177e4SLinus Torvalds continue; 20101da177e4SLinus Torvalds if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid, 20111da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 2012b6544c0bSJamal Hadi Salim RTM_NEWNEIGH, 2013b6544c0bSJamal Hadi Salim NLM_F_MULTI) <= 0) { 20141da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 20151da177e4SLinus Torvalds rc = -1; 20161da177e4SLinus Torvalds goto out; 20171da177e4SLinus Torvalds } 20181da177e4SLinus Torvalds } 20191da177e4SLinus Torvalds } 2020c5e29460SJulian Anastasov read_unlock_bh(&tbl->lock); 20211da177e4SLinus Torvalds rc = skb->len; 20221da177e4SLinus Torvalds out: 20231da177e4SLinus Torvalds cb->args[1] = h; 20241da177e4SLinus Torvalds cb->args[2] = idx; 20251da177e4SLinus Torvalds return rc; 20261da177e4SLinus Torvalds } 20271da177e4SLinus Torvalds 20281da177e4SLinus Torvalds int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 20291da177e4SLinus Torvalds { 20301da177e4SLinus Torvalds struct neigh_table *tbl; 20311da177e4SLinus Torvalds int t, family, s_t; 20321da177e4SLinus Torvalds 20331da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 20348b8aec50SThomas Graf family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family; 20351da177e4SLinus Torvalds s_t = cb->args[0]; 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) { 20381da177e4SLinus Torvalds if (t < s_t || (family && tbl->family != family)) 20391da177e4SLinus Torvalds continue; 20401da177e4SLinus Torvalds if (t > s_t) 20411da177e4SLinus Torvalds memset(&cb->args[1], 0, sizeof(cb->args) - 20421da177e4SLinus Torvalds sizeof(cb->args[0])); 20431da177e4SLinus Torvalds if (neigh_dump_table(tbl, skb, cb) < 0) 20441da177e4SLinus Torvalds break; 20451da177e4SLinus Torvalds } 20461da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 20471da177e4SLinus Torvalds 20481da177e4SLinus Torvalds cb->args[0] = t; 20491da177e4SLinus Torvalds return skb->len; 20501da177e4SLinus Torvalds } 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 20531da177e4SLinus Torvalds { 20541da177e4SLinus Torvalds int chain; 20551da177e4SLinus Torvalds 20561da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 20571da177e4SLinus Torvalds for (chain = 0; chain <= tbl->hash_mask; chain++) { 20581da177e4SLinus Torvalds struct neighbour *n; 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds for (n = tbl->hash_buckets[chain]; n; n = n->next) 20611da177e4SLinus Torvalds cb(n, cookie); 20621da177e4SLinus Torvalds } 20631da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 20641da177e4SLinus Torvalds } 20651da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_for_each); 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds /* The tbl->lock must be held as a writer and BH disabled. */ 20681da177e4SLinus Torvalds void __neigh_for_each_release(struct neigh_table *tbl, 20691da177e4SLinus Torvalds int (*cb)(struct neighbour *)) 20701da177e4SLinus Torvalds { 20711da177e4SLinus Torvalds int chain; 20721da177e4SLinus Torvalds 20731da177e4SLinus Torvalds for (chain = 0; chain <= tbl->hash_mask; chain++) { 20741da177e4SLinus Torvalds struct neighbour *n, **np; 20751da177e4SLinus Torvalds 20761da177e4SLinus Torvalds np = &tbl->hash_buckets[chain]; 20771da177e4SLinus Torvalds while ((n = *np) != NULL) { 20781da177e4SLinus Torvalds int release; 20791da177e4SLinus Torvalds 20801da177e4SLinus Torvalds write_lock(&n->lock); 20811da177e4SLinus Torvalds release = cb(n); 20821da177e4SLinus Torvalds if (release) { 20831da177e4SLinus Torvalds *np = n->next; 20841da177e4SLinus Torvalds n->dead = 1; 20851da177e4SLinus Torvalds } else 20861da177e4SLinus Torvalds np = &n->next; 20871da177e4SLinus Torvalds write_unlock(&n->lock); 20881da177e4SLinus Torvalds if (release) 20891da177e4SLinus Torvalds neigh_release(n); 20901da177e4SLinus Torvalds } 20911da177e4SLinus Torvalds } 20921da177e4SLinus Torvalds } 20931da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_for_each_release); 20941da177e4SLinus Torvalds 20951da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds static struct neighbour *neigh_get_first(struct seq_file *seq) 20981da177e4SLinus Torvalds { 20991da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 21001da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 21011da177e4SLinus Torvalds struct neighbour *n = NULL; 21021da177e4SLinus Torvalds int bucket = state->bucket; 21031da177e4SLinus Torvalds 21041da177e4SLinus Torvalds state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 21051da177e4SLinus Torvalds for (bucket = 0; bucket <= tbl->hash_mask; bucket++) { 21061da177e4SLinus Torvalds n = tbl->hash_buckets[bucket]; 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds while (n) { 21091da177e4SLinus Torvalds if (state->neigh_sub_iter) { 21101da177e4SLinus Torvalds loff_t fakep = 0; 21111da177e4SLinus Torvalds void *v; 21121da177e4SLinus Torvalds 21131da177e4SLinus Torvalds v = state->neigh_sub_iter(state, n, &fakep); 21141da177e4SLinus Torvalds if (!v) 21151da177e4SLinus Torvalds goto next; 21161da177e4SLinus Torvalds } 21171da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 21181da177e4SLinus Torvalds break; 21191da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 21201da177e4SLinus Torvalds break; 21211da177e4SLinus Torvalds next: 21221da177e4SLinus Torvalds n = n->next; 21231da177e4SLinus Torvalds } 21241da177e4SLinus Torvalds 21251da177e4SLinus Torvalds if (n) 21261da177e4SLinus Torvalds break; 21271da177e4SLinus Torvalds } 21281da177e4SLinus Torvalds state->bucket = bucket; 21291da177e4SLinus Torvalds 21301da177e4SLinus Torvalds return n; 21311da177e4SLinus Torvalds } 21321da177e4SLinus Torvalds 21331da177e4SLinus Torvalds static struct neighbour *neigh_get_next(struct seq_file *seq, 21341da177e4SLinus Torvalds struct neighbour *n, 21351da177e4SLinus Torvalds loff_t *pos) 21361da177e4SLinus Torvalds { 21371da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 21381da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds if (state->neigh_sub_iter) { 21411da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 21421da177e4SLinus Torvalds if (v) 21431da177e4SLinus Torvalds return n; 21441da177e4SLinus Torvalds } 21451da177e4SLinus Torvalds n = n->next; 21461da177e4SLinus Torvalds 21471da177e4SLinus Torvalds while (1) { 21481da177e4SLinus Torvalds while (n) { 21491da177e4SLinus Torvalds if (state->neigh_sub_iter) { 21501da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 21511da177e4SLinus Torvalds if (v) 21521da177e4SLinus Torvalds return n; 21531da177e4SLinus Torvalds goto next; 21541da177e4SLinus Torvalds } 21551da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 21561da177e4SLinus Torvalds break; 21571da177e4SLinus Torvalds 21581da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 21591da177e4SLinus Torvalds break; 21601da177e4SLinus Torvalds next: 21611da177e4SLinus Torvalds n = n->next; 21621da177e4SLinus Torvalds } 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds if (n) 21651da177e4SLinus Torvalds break; 21661da177e4SLinus Torvalds 21671da177e4SLinus Torvalds if (++state->bucket > tbl->hash_mask) 21681da177e4SLinus Torvalds break; 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds n = tbl->hash_buckets[state->bucket]; 21711da177e4SLinus Torvalds } 21721da177e4SLinus Torvalds 21731da177e4SLinus Torvalds if (n && pos) 21741da177e4SLinus Torvalds --(*pos); 21751da177e4SLinus Torvalds return n; 21761da177e4SLinus Torvalds } 21771da177e4SLinus Torvalds 21781da177e4SLinus Torvalds static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 21791da177e4SLinus Torvalds { 21801da177e4SLinus Torvalds struct neighbour *n = neigh_get_first(seq); 21811da177e4SLinus Torvalds 21821da177e4SLinus Torvalds if (n) { 21831da177e4SLinus Torvalds while (*pos) { 21841da177e4SLinus Torvalds n = neigh_get_next(seq, n, pos); 21851da177e4SLinus Torvalds if (!n) 21861da177e4SLinus Torvalds break; 21871da177e4SLinus Torvalds } 21881da177e4SLinus Torvalds } 21891da177e4SLinus Torvalds return *pos ? NULL : n; 21901da177e4SLinus Torvalds } 21911da177e4SLinus Torvalds 21921da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 21931da177e4SLinus Torvalds { 21941da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 21951da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 21961da177e4SLinus Torvalds struct pneigh_entry *pn = NULL; 21971da177e4SLinus Torvalds int bucket = state->bucket; 21981da177e4SLinus Torvalds 21991da177e4SLinus Torvalds state->flags |= NEIGH_SEQ_IS_PNEIGH; 22001da177e4SLinus Torvalds for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 22011da177e4SLinus Torvalds pn = tbl->phash_buckets[bucket]; 22021da177e4SLinus Torvalds if (pn) 22031da177e4SLinus Torvalds break; 22041da177e4SLinus Torvalds } 22051da177e4SLinus Torvalds state->bucket = bucket; 22061da177e4SLinus Torvalds 22071da177e4SLinus Torvalds return pn; 22081da177e4SLinus Torvalds } 22091da177e4SLinus Torvalds 22101da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 22111da177e4SLinus Torvalds struct pneigh_entry *pn, 22121da177e4SLinus Torvalds loff_t *pos) 22131da177e4SLinus Torvalds { 22141da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 22151da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 22161da177e4SLinus Torvalds 22171da177e4SLinus Torvalds pn = pn->next; 22181da177e4SLinus Torvalds while (!pn) { 22191da177e4SLinus Torvalds if (++state->bucket > PNEIGH_HASHMASK) 22201da177e4SLinus Torvalds break; 22211da177e4SLinus Torvalds pn = tbl->phash_buckets[state->bucket]; 22221da177e4SLinus Torvalds if (pn) 22231da177e4SLinus Torvalds break; 22241da177e4SLinus Torvalds } 22251da177e4SLinus Torvalds 22261da177e4SLinus Torvalds if (pn && pos) 22271da177e4SLinus Torvalds --(*pos); 22281da177e4SLinus Torvalds 22291da177e4SLinus Torvalds return pn; 22301da177e4SLinus Torvalds } 22311da177e4SLinus Torvalds 22321da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 22331da177e4SLinus Torvalds { 22341da177e4SLinus Torvalds struct pneigh_entry *pn = pneigh_get_first(seq); 22351da177e4SLinus Torvalds 22361da177e4SLinus Torvalds if (pn) { 22371da177e4SLinus Torvalds while (*pos) { 22381da177e4SLinus Torvalds pn = pneigh_get_next(seq, pn, pos); 22391da177e4SLinus Torvalds if (!pn) 22401da177e4SLinus Torvalds break; 22411da177e4SLinus Torvalds } 22421da177e4SLinus Torvalds } 22431da177e4SLinus Torvalds return *pos ? NULL : pn; 22441da177e4SLinus Torvalds } 22451da177e4SLinus Torvalds 22461da177e4SLinus Torvalds static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 22471da177e4SLinus Torvalds { 22481da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 22491da177e4SLinus Torvalds void *rc; 22501da177e4SLinus Torvalds 22511da177e4SLinus Torvalds rc = neigh_get_idx(seq, pos); 22521da177e4SLinus Torvalds if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 22531da177e4SLinus Torvalds rc = pneigh_get_idx(seq, pos); 22541da177e4SLinus Torvalds 22551da177e4SLinus Torvalds return rc; 22561da177e4SLinus Torvalds } 22571da177e4SLinus Torvalds 22581da177e4SLinus Torvalds void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 22591da177e4SLinus Torvalds { 22601da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 22611da177e4SLinus Torvalds loff_t pos_minus_one; 22621da177e4SLinus Torvalds 22631da177e4SLinus Torvalds state->tbl = tbl; 22641da177e4SLinus Torvalds state->bucket = 0; 22651da177e4SLinus Torvalds state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 22661da177e4SLinus Torvalds 22671da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 22681da177e4SLinus Torvalds 22691da177e4SLinus Torvalds pos_minus_one = *pos - 1; 22701da177e4SLinus Torvalds return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN; 22711da177e4SLinus Torvalds } 22721da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_start); 22731da177e4SLinus Torvalds 22741da177e4SLinus Torvalds void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 22751da177e4SLinus Torvalds { 22761da177e4SLinus Torvalds struct neigh_seq_state *state; 22771da177e4SLinus Torvalds void *rc; 22781da177e4SLinus Torvalds 22791da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 22801da177e4SLinus Torvalds rc = neigh_get_idx(seq, pos); 22811da177e4SLinus Torvalds goto out; 22821da177e4SLinus Torvalds } 22831da177e4SLinus Torvalds 22841da177e4SLinus Torvalds state = seq->private; 22851da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 22861da177e4SLinus Torvalds rc = neigh_get_next(seq, v, NULL); 22871da177e4SLinus Torvalds if (rc) 22881da177e4SLinus Torvalds goto out; 22891da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 22901da177e4SLinus Torvalds rc = pneigh_get_first(seq); 22911da177e4SLinus Torvalds } else { 22921da177e4SLinus Torvalds BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 22931da177e4SLinus Torvalds rc = pneigh_get_next(seq, v, NULL); 22941da177e4SLinus Torvalds } 22951da177e4SLinus Torvalds out: 22961da177e4SLinus Torvalds ++(*pos); 22971da177e4SLinus Torvalds return rc; 22981da177e4SLinus Torvalds } 22991da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_next); 23001da177e4SLinus Torvalds 23011da177e4SLinus Torvalds void neigh_seq_stop(struct seq_file *seq, void *v) 23021da177e4SLinus Torvalds { 23031da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 23041da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 23051da177e4SLinus Torvalds 23061da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 23071da177e4SLinus Torvalds } 23081da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_stop); 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds /* statistics via seq_file */ 23111da177e4SLinus Torvalds 23121da177e4SLinus Torvalds static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 23131da177e4SLinus Torvalds { 23141da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 23151da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 23161da177e4SLinus Torvalds int cpu; 23171da177e4SLinus Torvalds 23181da177e4SLinus Torvalds if (*pos == 0) 23191da177e4SLinus Torvalds return SEQ_START_TOKEN; 23201da177e4SLinus Torvalds 23211da177e4SLinus Torvalds for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 23221da177e4SLinus Torvalds if (!cpu_possible(cpu)) 23231da177e4SLinus Torvalds continue; 23241da177e4SLinus Torvalds *pos = cpu+1; 23251da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 23261da177e4SLinus Torvalds } 23271da177e4SLinus Torvalds return NULL; 23281da177e4SLinus Torvalds } 23291da177e4SLinus Torvalds 23301da177e4SLinus Torvalds static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 23311da177e4SLinus Torvalds { 23321da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 23331da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 23341da177e4SLinus Torvalds int cpu; 23351da177e4SLinus Torvalds 23361da177e4SLinus Torvalds for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 23371da177e4SLinus Torvalds if (!cpu_possible(cpu)) 23381da177e4SLinus Torvalds continue; 23391da177e4SLinus Torvalds *pos = cpu+1; 23401da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 23411da177e4SLinus Torvalds } 23421da177e4SLinus Torvalds return NULL; 23431da177e4SLinus Torvalds } 23441da177e4SLinus Torvalds 23451da177e4SLinus Torvalds static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 23461da177e4SLinus Torvalds { 23471da177e4SLinus Torvalds 23481da177e4SLinus Torvalds } 23491da177e4SLinus Torvalds 23501da177e4SLinus Torvalds static int neigh_stat_seq_show(struct seq_file *seq, void *v) 23511da177e4SLinus Torvalds { 23521da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 23531da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 23541da177e4SLinus Torvalds struct neigh_statistics *st = v; 23551da177e4SLinus Torvalds 23561da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 23575bec0039SOlaf Rempel seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs\n"); 23581da177e4SLinus Torvalds return 0; 23591da177e4SLinus Torvalds } 23601da177e4SLinus Torvalds 23611da177e4SLinus Torvalds seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 23621da177e4SLinus Torvalds "%08lx %08lx %08lx %08lx\n", 23631da177e4SLinus Torvalds atomic_read(&tbl->entries), 23641da177e4SLinus Torvalds 23651da177e4SLinus Torvalds st->allocs, 23661da177e4SLinus Torvalds st->destroys, 23671da177e4SLinus Torvalds st->hash_grows, 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds st->lookups, 23701da177e4SLinus Torvalds st->hits, 23711da177e4SLinus Torvalds 23721da177e4SLinus Torvalds st->res_failed, 23731da177e4SLinus Torvalds 23741da177e4SLinus Torvalds st->rcv_probes_mcast, 23751da177e4SLinus Torvalds st->rcv_probes_ucast, 23761da177e4SLinus Torvalds 23771da177e4SLinus Torvalds st->periodic_gc_runs, 23781da177e4SLinus Torvalds st->forced_gc_runs 23791da177e4SLinus Torvalds ); 23801da177e4SLinus Torvalds 23811da177e4SLinus Torvalds return 0; 23821da177e4SLinus Torvalds } 23831da177e4SLinus Torvalds 23841da177e4SLinus Torvalds static struct seq_operations neigh_stat_seq_ops = { 23851da177e4SLinus Torvalds .start = neigh_stat_seq_start, 23861da177e4SLinus Torvalds .next = neigh_stat_seq_next, 23871da177e4SLinus Torvalds .stop = neigh_stat_seq_stop, 23881da177e4SLinus Torvalds .show = neigh_stat_seq_show, 23891da177e4SLinus Torvalds }; 23901da177e4SLinus Torvalds 23911da177e4SLinus Torvalds static int neigh_stat_seq_open(struct inode *inode, struct file *file) 23921da177e4SLinus Torvalds { 23931da177e4SLinus Torvalds int ret = seq_open(file, &neigh_stat_seq_ops); 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds if (!ret) { 23961da177e4SLinus Torvalds struct seq_file *sf = file->private_data; 23971da177e4SLinus Torvalds sf->private = PDE(inode); 23981da177e4SLinus Torvalds } 23991da177e4SLinus Torvalds return ret; 24001da177e4SLinus Torvalds }; 24011da177e4SLinus Torvalds 24021da177e4SLinus Torvalds static struct file_operations neigh_stat_seq_fops = { 24031da177e4SLinus Torvalds .owner = THIS_MODULE, 24041da177e4SLinus Torvalds .open = neigh_stat_seq_open, 24051da177e4SLinus Torvalds .read = seq_read, 24061da177e4SLinus Torvalds .llseek = seq_lseek, 24071da177e4SLinus Torvalds .release = seq_release, 24081da177e4SLinus Torvalds }; 24091da177e4SLinus Torvalds 24101da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 24111da177e4SLinus Torvalds 24121da177e4SLinus Torvalds #ifdef CONFIG_ARPD 2413339bf98fSThomas Graf static inline size_t neigh_nlmsg_size(void) 2414339bf98fSThomas Graf { 2415339bf98fSThomas Graf return NLMSG_ALIGN(sizeof(struct ndmsg)) 2416339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */ 2417339bf98fSThomas Graf + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */ 2418339bf98fSThomas Graf + nla_total_size(sizeof(struct nda_cacheinfo)) 2419339bf98fSThomas Graf + nla_total_size(4); /* NDA_PROBES */ 2420339bf98fSThomas Graf } 2421339bf98fSThomas Graf 2422b8673311SThomas Graf static void __neigh_notify(struct neighbour *n, int type, int flags) 24231da177e4SLinus Torvalds { 24248b8aec50SThomas Graf struct sk_buff *skb; 2425b8673311SThomas Graf int err = -ENOBUFS; 24261da177e4SLinus Torvalds 2427339bf98fSThomas Graf skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC); 24288b8aec50SThomas Graf if (skb == NULL) 2429b8673311SThomas Graf goto errout; 24301da177e4SLinus Torvalds 2431b8673311SThomas Graf err = neigh_fill_info(skb, n, 0, 0, type, flags); 2432339bf98fSThomas Graf /* failure implies BUG in neigh_nlmsg_size() */ 2433339bf98fSThomas Graf BUG_ON(err < 0); 2434b8673311SThomas Graf 2435b8673311SThomas Graf err = rtnl_notify(skb, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC); 2436b8673311SThomas Graf errout: 2437b8673311SThomas Graf if (err < 0) 2438b8673311SThomas Graf rtnl_set_sk_err(RTNLGRP_NEIGH, err); 2439b8673311SThomas Graf } 2440b8673311SThomas Graf 2441b8673311SThomas Graf void neigh_app_ns(struct neighbour *n) 2442b8673311SThomas Graf { 2443b8673311SThomas Graf __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST); 24448b8aec50SThomas Graf } 24451da177e4SLinus Torvalds 24461da177e4SLinus Torvalds static void neigh_app_notify(struct neighbour *n) 24471da177e4SLinus Torvalds { 2448b8673311SThomas Graf __neigh_notify(n, RTM_NEWNEIGH, 0); 24498b8aec50SThomas Graf } 24501da177e4SLinus Torvalds 24511da177e4SLinus Torvalds #endif /* CONFIG_ARPD */ 24521da177e4SLinus Torvalds 24531da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 24541da177e4SLinus Torvalds 24551da177e4SLinus Torvalds static struct neigh_sysctl_table { 24561da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 24571da177e4SLinus Torvalds ctl_table neigh_vars[__NET_NEIGH_MAX]; 24581da177e4SLinus Torvalds ctl_table neigh_dev[2]; 24591da177e4SLinus Torvalds ctl_table neigh_neigh_dir[2]; 24601da177e4SLinus Torvalds ctl_table neigh_proto_dir[2]; 24611da177e4SLinus Torvalds ctl_table neigh_root_dir[2]; 2462ab32ea5dSBrian Haley } neigh_sysctl_template __read_mostly = { 24631da177e4SLinus Torvalds .neigh_vars = { 24641da177e4SLinus Torvalds { 24651da177e4SLinus Torvalds .ctl_name = NET_NEIGH_MCAST_SOLICIT, 24661da177e4SLinus Torvalds .procname = "mcast_solicit", 24671da177e4SLinus Torvalds .maxlen = sizeof(int), 24681da177e4SLinus Torvalds .mode = 0644, 24691da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 24701da177e4SLinus Torvalds }, 24711da177e4SLinus Torvalds { 24721da177e4SLinus Torvalds .ctl_name = NET_NEIGH_UCAST_SOLICIT, 24731da177e4SLinus Torvalds .procname = "ucast_solicit", 24741da177e4SLinus Torvalds .maxlen = sizeof(int), 24751da177e4SLinus Torvalds .mode = 0644, 24761da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 24771da177e4SLinus Torvalds }, 24781da177e4SLinus Torvalds { 24791da177e4SLinus Torvalds .ctl_name = NET_NEIGH_APP_SOLICIT, 24801da177e4SLinus Torvalds .procname = "app_solicit", 24811da177e4SLinus Torvalds .maxlen = sizeof(int), 24821da177e4SLinus Torvalds .mode = 0644, 24831da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 24841da177e4SLinus Torvalds }, 24851da177e4SLinus Torvalds { 24861da177e4SLinus Torvalds .ctl_name = NET_NEIGH_RETRANS_TIME, 24871da177e4SLinus Torvalds .procname = "retrans_time", 24881da177e4SLinus Torvalds .maxlen = sizeof(int), 24891da177e4SLinus Torvalds .mode = 0644, 24901da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 24911da177e4SLinus Torvalds }, 24921da177e4SLinus Torvalds { 24931da177e4SLinus Torvalds .ctl_name = NET_NEIGH_REACHABLE_TIME, 24941da177e4SLinus Torvalds .procname = "base_reachable_time", 24951da177e4SLinus Torvalds .maxlen = sizeof(int), 24961da177e4SLinus Torvalds .mode = 0644, 24971da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 24981da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 24991da177e4SLinus Torvalds }, 25001da177e4SLinus Torvalds { 25011da177e4SLinus Torvalds .ctl_name = NET_NEIGH_DELAY_PROBE_TIME, 25021da177e4SLinus Torvalds .procname = "delay_first_probe_time", 25031da177e4SLinus Torvalds .maxlen = sizeof(int), 25041da177e4SLinus Torvalds .mode = 0644, 25051da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 25061da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 25071da177e4SLinus Torvalds }, 25081da177e4SLinus Torvalds { 25091da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_STALE_TIME, 25101da177e4SLinus Torvalds .procname = "gc_stale_time", 25111da177e4SLinus Torvalds .maxlen = sizeof(int), 25121da177e4SLinus Torvalds .mode = 0644, 25131da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 25141da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 25151da177e4SLinus Torvalds }, 25161da177e4SLinus Torvalds { 25171da177e4SLinus Torvalds .ctl_name = NET_NEIGH_UNRES_QLEN, 25181da177e4SLinus Torvalds .procname = "unres_qlen", 25191da177e4SLinus Torvalds .maxlen = sizeof(int), 25201da177e4SLinus Torvalds .mode = 0644, 25211da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 25221da177e4SLinus Torvalds }, 25231da177e4SLinus Torvalds { 25241da177e4SLinus Torvalds .ctl_name = NET_NEIGH_PROXY_QLEN, 25251da177e4SLinus Torvalds .procname = "proxy_qlen", 25261da177e4SLinus Torvalds .maxlen = sizeof(int), 25271da177e4SLinus Torvalds .mode = 0644, 25281da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 25291da177e4SLinus Torvalds }, 25301da177e4SLinus Torvalds { 25311da177e4SLinus Torvalds .ctl_name = NET_NEIGH_ANYCAST_DELAY, 25321da177e4SLinus Torvalds .procname = "anycast_delay", 25331da177e4SLinus Torvalds .maxlen = sizeof(int), 25341da177e4SLinus Torvalds .mode = 0644, 25351da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 25361da177e4SLinus Torvalds }, 25371da177e4SLinus Torvalds { 25381da177e4SLinus Torvalds .ctl_name = NET_NEIGH_PROXY_DELAY, 25391da177e4SLinus Torvalds .procname = "proxy_delay", 25401da177e4SLinus Torvalds .maxlen = sizeof(int), 25411da177e4SLinus Torvalds .mode = 0644, 25421da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 25431da177e4SLinus Torvalds }, 25441da177e4SLinus Torvalds { 25451da177e4SLinus Torvalds .ctl_name = NET_NEIGH_LOCKTIME, 25461da177e4SLinus Torvalds .procname = "locktime", 25471da177e4SLinus Torvalds .maxlen = sizeof(int), 25481da177e4SLinus Torvalds .mode = 0644, 25491da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 25501da177e4SLinus Torvalds }, 25511da177e4SLinus Torvalds { 25521da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_INTERVAL, 25531da177e4SLinus Torvalds .procname = "gc_interval", 25541da177e4SLinus Torvalds .maxlen = sizeof(int), 25551da177e4SLinus Torvalds .mode = 0644, 25561da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 25571da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 25581da177e4SLinus Torvalds }, 25591da177e4SLinus Torvalds { 25601da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH1, 25611da177e4SLinus Torvalds .procname = "gc_thresh1", 25621da177e4SLinus Torvalds .maxlen = sizeof(int), 25631da177e4SLinus Torvalds .mode = 0644, 25641da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 25651da177e4SLinus Torvalds }, 25661da177e4SLinus Torvalds { 25671da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH2, 25681da177e4SLinus Torvalds .procname = "gc_thresh2", 25691da177e4SLinus Torvalds .maxlen = sizeof(int), 25701da177e4SLinus Torvalds .mode = 0644, 25711da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 25721da177e4SLinus Torvalds }, 25731da177e4SLinus Torvalds { 25741da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH3, 25751da177e4SLinus Torvalds .procname = "gc_thresh3", 25761da177e4SLinus Torvalds .maxlen = sizeof(int), 25771da177e4SLinus Torvalds .mode = 0644, 25781da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 25791da177e4SLinus Torvalds }, 25801da177e4SLinus Torvalds { 25811da177e4SLinus Torvalds .ctl_name = NET_NEIGH_RETRANS_TIME_MS, 25821da177e4SLinus Torvalds .procname = "retrans_time_ms", 25831da177e4SLinus Torvalds .maxlen = sizeof(int), 25841da177e4SLinus Torvalds .mode = 0644, 25851da177e4SLinus Torvalds .proc_handler = &proc_dointvec_ms_jiffies, 25861da177e4SLinus Torvalds .strategy = &sysctl_ms_jiffies, 25871da177e4SLinus Torvalds }, 25881da177e4SLinus Torvalds { 25891da177e4SLinus Torvalds .ctl_name = NET_NEIGH_REACHABLE_TIME_MS, 25901da177e4SLinus Torvalds .procname = "base_reachable_time_ms", 25911da177e4SLinus Torvalds .maxlen = sizeof(int), 25921da177e4SLinus Torvalds .mode = 0644, 25931da177e4SLinus Torvalds .proc_handler = &proc_dointvec_ms_jiffies, 25941da177e4SLinus Torvalds .strategy = &sysctl_ms_jiffies, 25951da177e4SLinus Torvalds }, 25961da177e4SLinus Torvalds }, 25971da177e4SLinus Torvalds .neigh_dev = { 25981da177e4SLinus Torvalds { 25991da177e4SLinus Torvalds .ctl_name = NET_PROTO_CONF_DEFAULT, 26001da177e4SLinus Torvalds .procname = "default", 26011da177e4SLinus Torvalds .mode = 0555, 26021da177e4SLinus Torvalds }, 26031da177e4SLinus Torvalds }, 26041da177e4SLinus Torvalds .neigh_neigh_dir = { 26051da177e4SLinus Torvalds { 26061da177e4SLinus Torvalds .procname = "neigh", 26071da177e4SLinus Torvalds .mode = 0555, 26081da177e4SLinus Torvalds }, 26091da177e4SLinus Torvalds }, 26101da177e4SLinus Torvalds .neigh_proto_dir = { 26111da177e4SLinus Torvalds { 26121da177e4SLinus Torvalds .mode = 0555, 26131da177e4SLinus Torvalds }, 26141da177e4SLinus Torvalds }, 26151da177e4SLinus Torvalds .neigh_root_dir = { 26161da177e4SLinus Torvalds { 26171da177e4SLinus Torvalds .ctl_name = CTL_NET, 26181da177e4SLinus Torvalds .procname = "net", 26191da177e4SLinus Torvalds .mode = 0555, 26201da177e4SLinus Torvalds }, 26211da177e4SLinus Torvalds }, 26221da177e4SLinus Torvalds }; 26231da177e4SLinus Torvalds 26241da177e4SLinus Torvalds int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 26251da177e4SLinus Torvalds int p_id, int pdev_id, char *p_name, 26261da177e4SLinus Torvalds proc_handler *handler, ctl_handler *strategy) 26271da177e4SLinus Torvalds { 26281da177e4SLinus Torvalds struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 26291da177e4SLinus Torvalds const char *dev_name_source = NULL; 26301da177e4SLinus Torvalds char *dev_name = NULL; 26311da177e4SLinus Torvalds int err = 0; 26321da177e4SLinus Torvalds 26331da177e4SLinus Torvalds if (!t) 26341da177e4SLinus Torvalds return -ENOBUFS; 26351da177e4SLinus Torvalds memcpy(t, &neigh_sysctl_template, sizeof(*t)); 26361da177e4SLinus Torvalds t->neigh_vars[0].data = &p->mcast_probes; 26371da177e4SLinus Torvalds t->neigh_vars[1].data = &p->ucast_probes; 26381da177e4SLinus Torvalds t->neigh_vars[2].data = &p->app_probes; 26391da177e4SLinus Torvalds t->neigh_vars[3].data = &p->retrans_time; 26401da177e4SLinus Torvalds t->neigh_vars[4].data = &p->base_reachable_time; 26411da177e4SLinus Torvalds t->neigh_vars[5].data = &p->delay_probe_time; 26421da177e4SLinus Torvalds t->neigh_vars[6].data = &p->gc_staletime; 26431da177e4SLinus Torvalds t->neigh_vars[7].data = &p->queue_len; 26441da177e4SLinus Torvalds t->neigh_vars[8].data = &p->proxy_qlen; 26451da177e4SLinus Torvalds t->neigh_vars[9].data = &p->anycast_delay; 26461da177e4SLinus Torvalds t->neigh_vars[10].data = &p->proxy_delay; 26471da177e4SLinus Torvalds t->neigh_vars[11].data = &p->locktime; 26481da177e4SLinus Torvalds 26491da177e4SLinus Torvalds if (dev) { 26501da177e4SLinus Torvalds dev_name_source = dev->name; 26511da177e4SLinus Torvalds t->neigh_dev[0].ctl_name = dev->ifindex; 26521da177e4SLinus Torvalds t->neigh_vars[12].procname = NULL; 26531da177e4SLinus Torvalds t->neigh_vars[13].procname = NULL; 26541da177e4SLinus Torvalds t->neigh_vars[14].procname = NULL; 26551da177e4SLinus Torvalds t->neigh_vars[15].procname = NULL; 26561da177e4SLinus Torvalds } else { 26571da177e4SLinus Torvalds dev_name_source = t->neigh_dev[0].procname; 26581da177e4SLinus Torvalds t->neigh_vars[12].data = (int *)(p + 1); 26591da177e4SLinus Torvalds t->neigh_vars[13].data = (int *)(p + 1) + 1; 26601da177e4SLinus Torvalds t->neigh_vars[14].data = (int *)(p + 1) + 2; 26611da177e4SLinus Torvalds t->neigh_vars[15].data = (int *)(p + 1) + 3; 26621da177e4SLinus Torvalds } 26631da177e4SLinus Torvalds 26641da177e4SLinus Torvalds t->neigh_vars[16].data = &p->retrans_time; 26651da177e4SLinus Torvalds t->neigh_vars[17].data = &p->base_reachable_time; 26661da177e4SLinus Torvalds 26671da177e4SLinus Torvalds if (handler || strategy) { 26681da177e4SLinus Torvalds /* RetransTime */ 26691da177e4SLinus Torvalds t->neigh_vars[3].proc_handler = handler; 26701da177e4SLinus Torvalds t->neigh_vars[3].strategy = strategy; 26711da177e4SLinus Torvalds t->neigh_vars[3].extra1 = dev; 26721da177e4SLinus Torvalds /* ReachableTime */ 26731da177e4SLinus Torvalds t->neigh_vars[4].proc_handler = handler; 26741da177e4SLinus Torvalds t->neigh_vars[4].strategy = strategy; 26751da177e4SLinus Torvalds t->neigh_vars[4].extra1 = dev; 26761da177e4SLinus Torvalds /* RetransTime (in milliseconds)*/ 26771da177e4SLinus Torvalds t->neigh_vars[16].proc_handler = handler; 26781da177e4SLinus Torvalds t->neigh_vars[16].strategy = strategy; 26791da177e4SLinus Torvalds t->neigh_vars[16].extra1 = dev; 26801da177e4SLinus Torvalds /* ReachableTime (in milliseconds) */ 26811da177e4SLinus Torvalds t->neigh_vars[17].proc_handler = handler; 26821da177e4SLinus Torvalds t->neigh_vars[17].strategy = strategy; 26831da177e4SLinus Torvalds t->neigh_vars[17].extra1 = dev; 26841da177e4SLinus Torvalds } 26851da177e4SLinus Torvalds 2686543537bdSPaulo Marques dev_name = kstrdup(dev_name_source, GFP_KERNEL); 26871da177e4SLinus Torvalds if (!dev_name) { 26881da177e4SLinus Torvalds err = -ENOBUFS; 26891da177e4SLinus Torvalds goto free; 26901da177e4SLinus Torvalds } 26911da177e4SLinus Torvalds 26921da177e4SLinus Torvalds t->neigh_dev[0].procname = dev_name; 26931da177e4SLinus Torvalds 26941da177e4SLinus Torvalds t->neigh_neigh_dir[0].ctl_name = pdev_id; 26951da177e4SLinus Torvalds 26961da177e4SLinus Torvalds t->neigh_proto_dir[0].procname = p_name; 26971da177e4SLinus Torvalds t->neigh_proto_dir[0].ctl_name = p_id; 26981da177e4SLinus Torvalds 26991da177e4SLinus Torvalds t->neigh_dev[0].child = t->neigh_vars; 27001da177e4SLinus Torvalds t->neigh_neigh_dir[0].child = t->neigh_dev; 27011da177e4SLinus Torvalds t->neigh_proto_dir[0].child = t->neigh_neigh_dir; 27021da177e4SLinus Torvalds t->neigh_root_dir[0].child = t->neigh_proto_dir; 27031da177e4SLinus Torvalds 27041da177e4SLinus Torvalds t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0); 27051da177e4SLinus Torvalds if (!t->sysctl_header) { 27061da177e4SLinus Torvalds err = -ENOBUFS; 27071da177e4SLinus Torvalds goto free_procname; 27081da177e4SLinus Torvalds } 27091da177e4SLinus Torvalds p->sysctl_table = t; 27101da177e4SLinus Torvalds return 0; 27111da177e4SLinus Torvalds 27121da177e4SLinus Torvalds /* error path */ 27131da177e4SLinus Torvalds free_procname: 27141da177e4SLinus Torvalds kfree(dev_name); 27151da177e4SLinus Torvalds free: 27161da177e4SLinus Torvalds kfree(t); 27171da177e4SLinus Torvalds 27181da177e4SLinus Torvalds return err; 27191da177e4SLinus Torvalds } 27201da177e4SLinus Torvalds 27211da177e4SLinus Torvalds void neigh_sysctl_unregister(struct neigh_parms *p) 27221da177e4SLinus Torvalds { 27231da177e4SLinus Torvalds if (p->sysctl_table) { 27241da177e4SLinus Torvalds struct neigh_sysctl_table *t = p->sysctl_table; 27251da177e4SLinus Torvalds p->sysctl_table = NULL; 27261da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 27271da177e4SLinus Torvalds kfree(t->neigh_dev[0].procname); 27281da177e4SLinus Torvalds kfree(t); 27291da177e4SLinus Torvalds } 27301da177e4SLinus Torvalds } 27311da177e4SLinus Torvalds 27321da177e4SLinus Torvalds #endif /* CONFIG_SYSCTL */ 27331da177e4SLinus Torvalds 27341da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_event_send); 27351da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_changeaddr); 27361da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_compat_output); 27371da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_connected_output); 27381da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_create); 27391da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_delete); 27401da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_destroy); 27411da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_dump_info); 27421da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_event_ns); 27431da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_ifdown); 27441da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_lookup); 27451da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_lookup_nodev); 27461da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_parms_alloc); 27471da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_parms_release); 27481da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_rand_reach_time); 27491da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_resolve_output); 27501da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_table_clear); 27511da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_table_init); 2752bd89efc5SSimon Kelley EXPORT_SYMBOL(neigh_table_init_no_netlink); 27531da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_update); 27541da177e4SLinus Torvalds EXPORT_SYMBOL(pneigh_enqueue); 27551da177e4SLinus Torvalds EXPORT_SYMBOL(pneigh_lookup); 27561da177e4SLinus Torvalds 27571da177e4SLinus Torvalds #ifdef CONFIG_ARPD 27581da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_app_ns); 27591da177e4SLinus Torvalds #endif 27601da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 27611da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_sysctl_register); 27621da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_sysctl_unregister); 27631da177e4SLinus Torvalds #endif 2764