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/config.h> 191da177e4SLinus Torvalds #include <linux/types.h> 201da177e4SLinus Torvalds #include <linux/kernel.h> 211da177e4SLinus Torvalds #include <linux/module.h> 221da177e4SLinus Torvalds #include <linux/socket.h> 231da177e4SLinus Torvalds #include <linux/sched.h> 241da177e4SLinus Torvalds #include <linux/netdevice.h> 251da177e4SLinus Torvalds #include <linux/proc_fs.h> 261da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 271da177e4SLinus Torvalds #include <linux/sysctl.h> 281da177e4SLinus Torvalds #endif 291da177e4SLinus Torvalds #include <linux/times.h> 301da177e4SLinus Torvalds #include <net/neighbour.h> 311da177e4SLinus Torvalds #include <net/dst.h> 321da177e4SLinus Torvalds #include <net/sock.h> 331da177e4SLinus Torvalds #include <linux/rtnetlink.h> 341da177e4SLinus Torvalds #include <linux/random.h> 351da177e4SLinus Torvalds 361da177e4SLinus Torvalds #define NEIGH_DEBUG 1 371da177e4SLinus Torvalds 381da177e4SLinus Torvalds #define NEIGH_PRINTK(x...) printk(x) 391da177e4SLinus Torvalds #define NEIGH_NOPRINTK(x...) do { ; } while(0) 401da177e4SLinus Torvalds #define NEIGH_PRINTK0 NEIGH_PRINTK 411da177e4SLinus Torvalds #define NEIGH_PRINTK1 NEIGH_NOPRINTK 421da177e4SLinus Torvalds #define NEIGH_PRINTK2 NEIGH_NOPRINTK 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds #if NEIGH_DEBUG >= 1 451da177e4SLinus Torvalds #undef NEIGH_PRINTK1 461da177e4SLinus Torvalds #define NEIGH_PRINTK1 NEIGH_PRINTK 471da177e4SLinus Torvalds #endif 481da177e4SLinus Torvalds #if NEIGH_DEBUG >= 2 491da177e4SLinus Torvalds #undef NEIGH_PRINTK2 501da177e4SLinus Torvalds #define NEIGH_PRINTK2 NEIGH_PRINTK 511da177e4SLinus Torvalds #endif 521da177e4SLinus Torvalds 531da177e4SLinus Torvalds #define PNEIGH_HASHMASK 0xF 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg); 561da177e4SLinus Torvalds #ifdef CONFIG_ARPD 571da177e4SLinus Torvalds static void neigh_app_notify(struct neighbour *n); 581da177e4SLinus Torvalds #endif 591da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev); 601da177e4SLinus Torvalds void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev); 611da177e4SLinus Torvalds 621da177e4SLinus Torvalds static struct neigh_table *neigh_tables; 631da177e4SLinus Torvalds static struct file_operations neigh_stat_seq_fops; 641da177e4SLinus Torvalds 651da177e4SLinus Torvalds /* 661da177e4SLinus Torvalds Neighbour hash table buckets are protected with rwlock tbl->lock. 671da177e4SLinus Torvalds 681da177e4SLinus Torvalds - All the scans/updates to hash buckets MUST be made under this lock. 691da177e4SLinus Torvalds - NOTHING clever should be made under this lock: no callbacks 701da177e4SLinus Torvalds to protocol backends, no attempts to send something to network. 711da177e4SLinus Torvalds It will result in deadlocks, if backend/driver wants to use neighbour 721da177e4SLinus Torvalds cache. 731da177e4SLinus Torvalds - If the entry requires some non-trivial actions, increase 741da177e4SLinus Torvalds its reference count and release table lock. 751da177e4SLinus Torvalds 761da177e4SLinus Torvalds Neighbour entries are protected: 771da177e4SLinus Torvalds - with reference count. 781da177e4SLinus Torvalds - with rwlock neigh->lock 791da177e4SLinus Torvalds 801da177e4SLinus Torvalds Reference count prevents destruction. 811da177e4SLinus Torvalds 821da177e4SLinus Torvalds neigh->lock mainly serializes ll address data and its validity state. 831da177e4SLinus Torvalds However, the same lock is used to protect another entry fields: 841da177e4SLinus Torvalds - timer 851da177e4SLinus Torvalds - resolution queue 861da177e4SLinus Torvalds 871da177e4SLinus Torvalds Again, nothing clever shall be made under neigh->lock, 881da177e4SLinus Torvalds the most complicated procedure, which we allow is dev->hard_header. 891da177e4SLinus Torvalds It is supposed, that dev->hard_header is simplistic and does 901da177e4SLinus Torvalds not make callbacks to neighbour tables. 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds The last lock is neigh_tbl_lock. It is pure SMP lock, protecting 931da177e4SLinus Torvalds list of neighbour tables. This list is used only in process context, 941da177e4SLinus Torvalds */ 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds static DEFINE_RWLOCK(neigh_tbl_lock); 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds static int neigh_blackhole(struct sk_buff *skb) 991da177e4SLinus Torvalds { 1001da177e4SLinus Torvalds kfree_skb(skb); 1011da177e4SLinus Torvalds return -ENETDOWN; 1021da177e4SLinus Torvalds } 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds /* 1051da177e4SLinus Torvalds * It is random distribution in the interval (1/2)*base...(3/2)*base. 1061da177e4SLinus Torvalds * It corresponds to default IPv6 settings and is not overridable, 1071da177e4SLinus Torvalds * because it is really reasonable choice. 1081da177e4SLinus Torvalds */ 1091da177e4SLinus Torvalds 1101da177e4SLinus Torvalds unsigned long neigh_rand_reach_time(unsigned long base) 1111da177e4SLinus Torvalds { 1121da177e4SLinus Torvalds return (base ? (net_random() % base) + (base >> 1) : 0); 1131da177e4SLinus Torvalds } 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds 1161da177e4SLinus Torvalds static int neigh_forced_gc(struct neigh_table *tbl) 1171da177e4SLinus Torvalds { 1181da177e4SLinus Torvalds int shrunk = 0; 1191da177e4SLinus Torvalds int i; 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs); 1221da177e4SLinus Torvalds 1231da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 1241da177e4SLinus Torvalds for (i = 0; i <= tbl->hash_mask; i++) { 1251da177e4SLinus Torvalds struct neighbour *n, **np; 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds np = &tbl->hash_buckets[i]; 1281da177e4SLinus Torvalds while ((n = *np) != NULL) { 1291da177e4SLinus Torvalds /* Neighbour record may be discarded if: 1301da177e4SLinus Torvalds * - nobody refers to it. 1311da177e4SLinus Torvalds * - it is not permanent 1321da177e4SLinus Torvalds */ 1331da177e4SLinus Torvalds write_lock(&n->lock); 1341da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 1351da177e4SLinus Torvalds !(n->nud_state & NUD_PERMANENT)) { 1361da177e4SLinus Torvalds *np = n->next; 1371da177e4SLinus Torvalds n->dead = 1; 1381da177e4SLinus Torvalds shrunk = 1; 1391da177e4SLinus Torvalds write_unlock(&n->lock); 1401da177e4SLinus Torvalds neigh_release(n); 1411da177e4SLinus Torvalds continue; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds write_unlock(&n->lock); 1441da177e4SLinus Torvalds np = &n->next; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds } 1471da177e4SLinus Torvalds 1481da177e4SLinus Torvalds tbl->last_flush = jiffies; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds return shrunk; 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds static int neigh_del_timer(struct neighbour *n) 1561da177e4SLinus Torvalds { 1571da177e4SLinus Torvalds if ((n->nud_state & NUD_IN_TIMER) && 1581da177e4SLinus Torvalds del_timer(&n->timer)) { 1591da177e4SLinus Torvalds neigh_release(n); 1601da177e4SLinus Torvalds return 1; 1611da177e4SLinus Torvalds } 1621da177e4SLinus Torvalds return 0; 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds static void pneigh_queue_purge(struct sk_buff_head *list) 1661da177e4SLinus Torvalds { 1671da177e4SLinus Torvalds struct sk_buff *skb; 1681da177e4SLinus Torvalds 1691da177e4SLinus Torvalds while ((skb = skb_dequeue(list)) != NULL) { 1701da177e4SLinus Torvalds dev_put(skb->dev); 1711da177e4SLinus Torvalds kfree_skb(skb); 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds } 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev) 1761da177e4SLinus Torvalds { 1771da177e4SLinus Torvalds int i; 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds for (i=0; i <= tbl->hash_mask; i++) { 1821da177e4SLinus Torvalds struct neighbour *n, **np; 1831da177e4SLinus Torvalds 1841da177e4SLinus Torvalds np = &tbl->hash_buckets[i]; 1851da177e4SLinus Torvalds while ((n = *np) != NULL) { 1861da177e4SLinus Torvalds if (dev && n->dev != dev) { 1871da177e4SLinus Torvalds np = &n->next; 1881da177e4SLinus Torvalds continue; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds *np = n->next; 1911da177e4SLinus Torvalds write_lock_bh(&n->lock); 1921da177e4SLinus Torvalds n->dead = 1; 1931da177e4SLinus Torvalds neigh_del_timer(n); 1941da177e4SLinus Torvalds write_unlock_bh(&n->lock); 1951da177e4SLinus Torvalds neigh_release(n); 1961da177e4SLinus Torvalds } 1971da177e4SLinus Torvalds } 1981da177e4SLinus Torvalds 1991da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 2001da177e4SLinus Torvalds } 2011da177e4SLinus Torvalds 2021da177e4SLinus Torvalds int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 2031da177e4SLinus Torvalds { 2041da177e4SLinus Torvalds int i; 2051da177e4SLinus Torvalds 2061da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 2071da177e4SLinus Torvalds 2081da177e4SLinus Torvalds for (i = 0; i <= tbl->hash_mask; i++) { 2091da177e4SLinus Torvalds struct neighbour *n, **np = &tbl->hash_buckets[i]; 2101da177e4SLinus Torvalds 2111da177e4SLinus Torvalds while ((n = *np) != NULL) { 2121da177e4SLinus Torvalds if (dev && n->dev != dev) { 2131da177e4SLinus Torvalds np = &n->next; 2141da177e4SLinus Torvalds continue; 2151da177e4SLinus Torvalds } 2161da177e4SLinus Torvalds *np = n->next; 2171da177e4SLinus Torvalds write_lock(&n->lock); 2181da177e4SLinus Torvalds neigh_del_timer(n); 2191da177e4SLinus Torvalds n->dead = 1; 2201da177e4SLinus Torvalds 2211da177e4SLinus Torvalds if (atomic_read(&n->refcnt) != 1) { 2221da177e4SLinus Torvalds /* The most unpleasant situation. 2231da177e4SLinus Torvalds We must destroy neighbour entry, 2241da177e4SLinus Torvalds but someone still uses it. 2251da177e4SLinus Torvalds 2261da177e4SLinus Torvalds The destroy will be delayed until 2271da177e4SLinus Torvalds the last user releases us, but 2281da177e4SLinus Torvalds we must kill timers etc. and move 2291da177e4SLinus Torvalds it to safe state. 2301da177e4SLinus Torvalds */ 2311da177e4SLinus Torvalds skb_queue_purge(&n->arp_queue); 2321da177e4SLinus Torvalds n->output = neigh_blackhole; 2331da177e4SLinus Torvalds if (n->nud_state & NUD_VALID) 2341da177e4SLinus Torvalds n->nud_state = NUD_NOARP; 2351da177e4SLinus Torvalds else 2361da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2371da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is stray.\n", n); 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds write_unlock(&n->lock); 2401da177e4SLinus Torvalds neigh_release(n); 2411da177e4SLinus Torvalds } 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds pneigh_ifdown(tbl, dev); 2451da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 2481da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 2491da177e4SLinus Torvalds return 0; 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds static struct neighbour *neigh_alloc(struct neigh_table *tbl) 2531da177e4SLinus Torvalds { 2541da177e4SLinus Torvalds struct neighbour *n = NULL; 2551da177e4SLinus Torvalds unsigned long now = jiffies; 2561da177e4SLinus Torvalds int entries; 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds entries = atomic_inc_return(&tbl->entries) - 1; 2591da177e4SLinus Torvalds if (entries >= tbl->gc_thresh3 || 2601da177e4SLinus Torvalds (entries >= tbl->gc_thresh2 && 2611da177e4SLinus Torvalds time_after(now, tbl->last_flush + 5 * HZ))) { 2621da177e4SLinus Torvalds if (!neigh_forced_gc(tbl) && 2631da177e4SLinus Torvalds entries >= tbl->gc_thresh3) 2641da177e4SLinus Torvalds goto out_entries; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds n = kmem_cache_alloc(tbl->kmem_cachep, SLAB_ATOMIC); 2681da177e4SLinus Torvalds if (!n) 2691da177e4SLinus Torvalds goto out_entries; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds memset(n, 0, tbl->entry_size); 2721da177e4SLinus Torvalds 2731da177e4SLinus Torvalds skb_queue_head_init(&n->arp_queue); 2741da177e4SLinus Torvalds rwlock_init(&n->lock); 2751da177e4SLinus Torvalds n->updated = n->used = now; 2761da177e4SLinus Torvalds n->nud_state = NUD_NONE; 2771da177e4SLinus Torvalds n->output = neigh_blackhole; 2781da177e4SLinus Torvalds n->parms = neigh_parms_clone(&tbl->parms); 2791da177e4SLinus Torvalds init_timer(&n->timer); 2801da177e4SLinus Torvalds n->timer.function = neigh_timer_handler; 2811da177e4SLinus Torvalds n->timer.data = (unsigned long)n; 2821da177e4SLinus Torvalds 2831da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, allocs); 2841da177e4SLinus Torvalds n->tbl = tbl; 2851da177e4SLinus Torvalds atomic_set(&n->refcnt, 1); 2861da177e4SLinus Torvalds n->dead = 1; 2871da177e4SLinus Torvalds out: 2881da177e4SLinus Torvalds return n; 2891da177e4SLinus Torvalds 2901da177e4SLinus Torvalds out_entries: 2911da177e4SLinus Torvalds atomic_dec(&tbl->entries); 2921da177e4SLinus Torvalds goto out; 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds static struct neighbour **neigh_hash_alloc(unsigned int entries) 2961da177e4SLinus Torvalds { 2971da177e4SLinus Torvalds unsigned long size = entries * sizeof(struct neighbour *); 2981da177e4SLinus Torvalds struct neighbour **ret; 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds if (size <= PAGE_SIZE) { 3011da177e4SLinus Torvalds ret = kmalloc(size, GFP_ATOMIC); 3021da177e4SLinus Torvalds } else { 3031da177e4SLinus Torvalds ret = (struct neighbour **) 3041da177e4SLinus Torvalds __get_free_pages(GFP_ATOMIC, get_order(size)); 3051da177e4SLinus Torvalds } 3061da177e4SLinus Torvalds if (ret) 3071da177e4SLinus Torvalds memset(ret, 0, size); 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds return ret; 3101da177e4SLinus Torvalds } 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds static void neigh_hash_free(struct neighbour **hash, unsigned int entries) 3131da177e4SLinus Torvalds { 3141da177e4SLinus Torvalds unsigned long size = entries * sizeof(struct neighbour *); 3151da177e4SLinus Torvalds 3161da177e4SLinus Torvalds if (size <= PAGE_SIZE) 3171da177e4SLinus Torvalds kfree(hash); 3181da177e4SLinus Torvalds else 3191da177e4SLinus Torvalds free_pages((unsigned long)hash, get_order(size)); 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds static void neigh_hash_grow(struct neigh_table *tbl, unsigned long new_entries) 3231da177e4SLinus Torvalds { 3241da177e4SLinus Torvalds struct neighbour **new_hash, **old_hash; 3251da177e4SLinus Torvalds unsigned int i, new_hash_mask, old_entries; 3261da177e4SLinus Torvalds 3271da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hash_grows); 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds BUG_ON(new_entries & (new_entries - 1)); 3301da177e4SLinus Torvalds new_hash = neigh_hash_alloc(new_entries); 3311da177e4SLinus Torvalds if (!new_hash) 3321da177e4SLinus Torvalds return; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds old_entries = tbl->hash_mask + 1; 3351da177e4SLinus Torvalds new_hash_mask = new_entries - 1; 3361da177e4SLinus Torvalds old_hash = tbl->hash_buckets; 3371da177e4SLinus Torvalds 3381da177e4SLinus Torvalds get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 3391da177e4SLinus Torvalds for (i = 0; i < old_entries; i++) { 3401da177e4SLinus Torvalds struct neighbour *n, *next; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds for (n = old_hash[i]; n; n = next) { 3431da177e4SLinus Torvalds unsigned int hash_val = tbl->hash(n->primary_key, n->dev); 3441da177e4SLinus Torvalds 3451da177e4SLinus Torvalds hash_val &= new_hash_mask; 3461da177e4SLinus Torvalds next = n->next; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds n->next = new_hash[hash_val]; 3491da177e4SLinus Torvalds new_hash[hash_val] = n; 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds } 3521da177e4SLinus Torvalds tbl->hash_buckets = new_hash; 3531da177e4SLinus Torvalds tbl->hash_mask = new_hash_mask; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds neigh_hash_free(old_hash, old_entries); 3561da177e4SLinus Torvalds } 3571da177e4SLinus Torvalds 3581da177e4SLinus Torvalds struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey, 3591da177e4SLinus Torvalds struct net_device *dev) 3601da177e4SLinus Torvalds { 3611da177e4SLinus Torvalds struct neighbour *n; 3621da177e4SLinus Torvalds int key_len = tbl->key_len; 3631da177e4SLinus Torvalds u32 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 3641da177e4SLinus Torvalds 3651da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 3681da177e4SLinus Torvalds for (n = tbl->hash_buckets[hash_val]; n; n = n->next) { 3691da177e4SLinus Torvalds if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) { 3701da177e4SLinus Torvalds neigh_hold(n); 3711da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 3721da177e4SLinus Torvalds break; 3731da177e4SLinus Torvalds } 3741da177e4SLinus Torvalds } 3751da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 3761da177e4SLinus Torvalds return n; 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds 3791da177e4SLinus Torvalds struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, const void *pkey) 3801da177e4SLinus Torvalds { 3811da177e4SLinus Torvalds struct neighbour *n; 3821da177e4SLinus Torvalds int key_len = tbl->key_len; 3831da177e4SLinus Torvalds u32 hash_val = tbl->hash(pkey, NULL) & tbl->hash_mask; 3841da177e4SLinus Torvalds 3851da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, lookups); 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 3881da177e4SLinus Torvalds for (n = tbl->hash_buckets[hash_val]; n; n = n->next) { 3891da177e4SLinus Torvalds if (!memcmp(n->primary_key, pkey, key_len)) { 3901da177e4SLinus Torvalds neigh_hold(n); 3911da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, hits); 3921da177e4SLinus Torvalds break; 3931da177e4SLinus Torvalds } 3941da177e4SLinus Torvalds } 3951da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 3961da177e4SLinus Torvalds return n; 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey, 4001da177e4SLinus Torvalds struct net_device *dev) 4011da177e4SLinus Torvalds { 4021da177e4SLinus Torvalds u32 hash_val; 4031da177e4SLinus Torvalds int key_len = tbl->key_len; 4041da177e4SLinus Torvalds int error; 4051da177e4SLinus Torvalds struct neighbour *n1, *rc, *n = neigh_alloc(tbl); 4061da177e4SLinus Torvalds 4071da177e4SLinus Torvalds if (!n) { 4081da177e4SLinus Torvalds rc = ERR_PTR(-ENOBUFS); 4091da177e4SLinus Torvalds goto out; 4101da177e4SLinus Torvalds } 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds memcpy(n->primary_key, pkey, key_len); 4131da177e4SLinus Torvalds n->dev = dev; 4141da177e4SLinus Torvalds dev_hold(dev); 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds /* Protocol specific setup. */ 4171da177e4SLinus Torvalds if (tbl->constructor && (error = tbl->constructor(n)) < 0) { 4181da177e4SLinus Torvalds rc = ERR_PTR(error); 4191da177e4SLinus Torvalds goto out_neigh_release; 4201da177e4SLinus Torvalds } 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds /* Device specific setup. */ 4231da177e4SLinus Torvalds if (n->parms->neigh_setup && 4241da177e4SLinus Torvalds (error = n->parms->neigh_setup(n)) < 0) { 4251da177e4SLinus Torvalds rc = ERR_PTR(error); 4261da177e4SLinus Torvalds goto out_neigh_release; 4271da177e4SLinus Torvalds } 4281da177e4SLinus Torvalds 4291da177e4SLinus Torvalds n->confirmed = jiffies - (n->parms->base_reachable_time << 1); 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1)) 4341da177e4SLinus Torvalds neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1); 4351da177e4SLinus Torvalds 4361da177e4SLinus Torvalds hash_val = tbl->hash(pkey, dev) & tbl->hash_mask; 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds if (n->parms->dead) { 4391da177e4SLinus Torvalds rc = ERR_PTR(-EINVAL); 4401da177e4SLinus Torvalds goto out_tbl_unlock; 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) { 4441da177e4SLinus Torvalds if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) { 4451da177e4SLinus Torvalds neigh_hold(n1); 4461da177e4SLinus Torvalds rc = n1; 4471da177e4SLinus Torvalds goto out_tbl_unlock; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds } 4501da177e4SLinus Torvalds 4511da177e4SLinus Torvalds n->next = tbl->hash_buckets[hash_val]; 4521da177e4SLinus Torvalds tbl->hash_buckets[hash_val] = n; 4531da177e4SLinus Torvalds n->dead = 0; 4541da177e4SLinus Torvalds neigh_hold(n); 4551da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 4561da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is created.\n", n); 4571da177e4SLinus Torvalds rc = n; 4581da177e4SLinus Torvalds out: 4591da177e4SLinus Torvalds return rc; 4601da177e4SLinus Torvalds out_tbl_unlock: 4611da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 4621da177e4SLinus Torvalds out_neigh_release: 4631da177e4SLinus Torvalds neigh_release(n); 4641da177e4SLinus Torvalds goto out; 4651da177e4SLinus Torvalds } 4661da177e4SLinus Torvalds 4671da177e4SLinus Torvalds struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey, 4681da177e4SLinus Torvalds struct net_device *dev, int creat) 4691da177e4SLinus Torvalds { 4701da177e4SLinus Torvalds struct pneigh_entry *n; 4711da177e4SLinus Torvalds int key_len = tbl->key_len; 4721da177e4SLinus Torvalds u32 hash_val = *(u32 *)(pkey + key_len - 4); 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds hash_val ^= (hash_val >> 16); 4751da177e4SLinus Torvalds hash_val ^= hash_val >> 8; 4761da177e4SLinus Torvalds hash_val ^= hash_val >> 4; 4771da177e4SLinus Torvalds hash_val &= PNEIGH_HASHMASK; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds for (n = tbl->phash_buckets[hash_val]; n; n = n->next) { 4821da177e4SLinus Torvalds if (!memcmp(n->key, pkey, key_len) && 4831da177e4SLinus Torvalds (n->dev == dev || !n->dev)) { 4841da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 4851da177e4SLinus Torvalds goto out; 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds } 4881da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 4891da177e4SLinus Torvalds n = NULL; 4901da177e4SLinus Torvalds if (!creat) 4911da177e4SLinus Torvalds goto out; 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL); 4941da177e4SLinus Torvalds if (!n) 4951da177e4SLinus Torvalds goto out; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds memcpy(n->key, pkey, key_len); 4981da177e4SLinus Torvalds n->dev = dev; 4991da177e4SLinus Torvalds if (dev) 5001da177e4SLinus Torvalds dev_hold(dev); 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds if (tbl->pconstructor && tbl->pconstructor(n)) { 5031da177e4SLinus Torvalds if (dev) 5041da177e4SLinus Torvalds dev_put(dev); 5051da177e4SLinus Torvalds kfree(n); 5061da177e4SLinus Torvalds n = NULL; 5071da177e4SLinus Torvalds goto out; 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 5111da177e4SLinus Torvalds n->next = tbl->phash_buckets[hash_val]; 5121da177e4SLinus Torvalds tbl->phash_buckets[hash_val] = n; 5131da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5141da177e4SLinus Torvalds out: 5151da177e4SLinus Torvalds return n; 5161da177e4SLinus Torvalds } 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds int pneigh_delete(struct neigh_table *tbl, const void *pkey, 5201da177e4SLinus Torvalds struct net_device *dev) 5211da177e4SLinus Torvalds { 5221da177e4SLinus Torvalds struct pneigh_entry *n, **np; 5231da177e4SLinus Torvalds int key_len = tbl->key_len; 5241da177e4SLinus Torvalds u32 hash_val = *(u32 *)(pkey + key_len - 4); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds hash_val ^= (hash_val >> 16); 5271da177e4SLinus Torvalds hash_val ^= hash_val >> 8; 5281da177e4SLinus Torvalds hash_val ^= hash_val >> 4; 5291da177e4SLinus Torvalds hash_val &= PNEIGH_HASHMASK; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 5321da177e4SLinus Torvalds for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL; 5331da177e4SLinus Torvalds np = &n->next) { 5341da177e4SLinus Torvalds if (!memcmp(n->key, pkey, key_len) && n->dev == dev) { 5351da177e4SLinus Torvalds *np = n->next; 5361da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5371da177e4SLinus Torvalds if (tbl->pdestructor) 5381da177e4SLinus Torvalds tbl->pdestructor(n); 5391da177e4SLinus Torvalds if (n->dev) 5401da177e4SLinus Torvalds dev_put(n->dev); 5411da177e4SLinus Torvalds kfree(n); 5421da177e4SLinus Torvalds return 0; 5431da177e4SLinus Torvalds } 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 5461da177e4SLinus Torvalds return -ENOENT; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds static int pneigh_ifdown(struct neigh_table *tbl, struct net_device *dev) 5501da177e4SLinus Torvalds { 5511da177e4SLinus Torvalds struct pneigh_entry *n, **np; 5521da177e4SLinus Torvalds u32 h; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds for (h = 0; h <= PNEIGH_HASHMASK; h++) { 5551da177e4SLinus Torvalds np = &tbl->phash_buckets[h]; 5561da177e4SLinus Torvalds while ((n = *np) != NULL) { 5571da177e4SLinus Torvalds if (!dev || n->dev == dev) { 5581da177e4SLinus Torvalds *np = n->next; 5591da177e4SLinus Torvalds if (tbl->pdestructor) 5601da177e4SLinus Torvalds tbl->pdestructor(n); 5611da177e4SLinus Torvalds if (n->dev) 5621da177e4SLinus Torvalds dev_put(n->dev); 5631da177e4SLinus Torvalds kfree(n); 5641da177e4SLinus Torvalds continue; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds np = &n->next; 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds } 5691da177e4SLinus Torvalds return -ENOENT; 5701da177e4SLinus Torvalds } 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds /* 5741da177e4SLinus Torvalds * neighbour must already be out of the table; 5751da177e4SLinus Torvalds * 5761da177e4SLinus Torvalds */ 5771da177e4SLinus Torvalds void neigh_destroy(struct neighbour *neigh) 5781da177e4SLinus Torvalds { 5791da177e4SLinus Torvalds struct hh_cache *hh; 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, destroys); 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds if (!neigh->dead) { 5841da177e4SLinus Torvalds printk(KERN_WARNING 5851da177e4SLinus Torvalds "Destroying alive neighbour %p\n", neigh); 5861da177e4SLinus Torvalds dump_stack(); 5871da177e4SLinus Torvalds return; 5881da177e4SLinus Torvalds } 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds if (neigh_del_timer(neigh)) 5911da177e4SLinus Torvalds printk(KERN_WARNING "Impossible event.\n"); 5921da177e4SLinus Torvalds 5931da177e4SLinus Torvalds while ((hh = neigh->hh) != NULL) { 5941da177e4SLinus Torvalds neigh->hh = hh->hh_next; 5951da177e4SLinus Torvalds hh->hh_next = NULL; 5961da177e4SLinus Torvalds write_lock_bh(&hh->hh_lock); 5971da177e4SLinus Torvalds hh->hh_output = neigh_blackhole; 5981da177e4SLinus Torvalds write_unlock_bh(&hh->hh_lock); 5991da177e4SLinus Torvalds if (atomic_dec_and_test(&hh->hh_refcnt)) 6001da177e4SLinus Torvalds kfree(hh); 6011da177e4SLinus Torvalds } 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds if (neigh->ops && neigh->ops->destructor) 6041da177e4SLinus Torvalds (neigh->ops->destructor)(neigh); 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 6071da177e4SLinus Torvalds 6081da177e4SLinus Torvalds dev_put(neigh->dev); 6091da177e4SLinus Torvalds neigh_parms_put(neigh->parms); 6101da177e4SLinus Torvalds 6111da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh); 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds atomic_dec(&neigh->tbl->entries); 6141da177e4SLinus Torvalds kmem_cache_free(neigh->tbl->kmem_cachep, neigh); 6151da177e4SLinus Torvalds } 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds /* Neighbour state is suspicious; 6181da177e4SLinus Torvalds disable fast path. 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds Called with write_locked neigh. 6211da177e4SLinus Torvalds */ 6221da177e4SLinus Torvalds static void neigh_suspect(struct neighbour *neigh) 6231da177e4SLinus Torvalds { 6241da177e4SLinus Torvalds struct hh_cache *hh; 6251da177e4SLinus Torvalds 6261da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds neigh->output = neigh->ops->output; 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) 6311da177e4SLinus Torvalds hh->hh_output = neigh->ops->output; 6321da177e4SLinus Torvalds } 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds /* Neighbour state is OK; 6351da177e4SLinus Torvalds enable fast path. 6361da177e4SLinus Torvalds 6371da177e4SLinus Torvalds Called with write_locked neigh. 6381da177e4SLinus Torvalds */ 6391da177e4SLinus Torvalds static void neigh_connect(struct neighbour *neigh) 6401da177e4SLinus Torvalds { 6411da177e4SLinus Torvalds struct hh_cache *hh; 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is connected.\n", neigh); 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds neigh->output = neigh->ops->connected_output; 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) 6481da177e4SLinus Torvalds hh->hh_output = neigh->ops->hh_output; 6491da177e4SLinus Torvalds } 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds static void neigh_periodic_timer(unsigned long arg) 6521da177e4SLinus Torvalds { 6531da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 6541da177e4SLinus Torvalds struct neighbour *n, **np; 6551da177e4SLinus Torvalds unsigned long expire, now = jiffies; 6561da177e4SLinus Torvalds 6571da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs); 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds write_lock(&tbl->lock); 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds /* 6621da177e4SLinus Torvalds * periodically recompute ReachableTime from random function 6631da177e4SLinus Torvalds */ 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds if (time_after(now, tbl->last_rand + 300 * HZ)) { 6661da177e4SLinus Torvalds struct neigh_parms *p; 6671da177e4SLinus Torvalds tbl->last_rand = now; 6681da177e4SLinus Torvalds for (p = &tbl->parms; p; p = p->next) 6691da177e4SLinus Torvalds p->reachable_time = 6701da177e4SLinus Torvalds neigh_rand_reach_time(p->base_reachable_time); 6711da177e4SLinus Torvalds } 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds np = &tbl->hash_buckets[tbl->hash_chain_gc]; 6741da177e4SLinus Torvalds tbl->hash_chain_gc = ((tbl->hash_chain_gc + 1) & tbl->hash_mask); 6751da177e4SLinus Torvalds 6761da177e4SLinus Torvalds while ((n = *np) != NULL) { 6771da177e4SLinus Torvalds unsigned int state; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds write_lock(&n->lock); 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds state = n->nud_state; 6821da177e4SLinus Torvalds if (state & (NUD_PERMANENT | NUD_IN_TIMER)) { 6831da177e4SLinus Torvalds write_unlock(&n->lock); 6841da177e4SLinus Torvalds goto next_elt; 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds if (time_before(n->used, n->confirmed)) 6881da177e4SLinus Torvalds n->used = n->confirmed; 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds if (atomic_read(&n->refcnt) == 1 && 6911da177e4SLinus Torvalds (state == NUD_FAILED || 6921da177e4SLinus Torvalds time_after(now, n->used + n->parms->gc_staletime))) { 6931da177e4SLinus Torvalds *np = n->next; 6941da177e4SLinus Torvalds n->dead = 1; 6951da177e4SLinus Torvalds write_unlock(&n->lock); 6961da177e4SLinus Torvalds neigh_release(n); 6971da177e4SLinus Torvalds continue; 6981da177e4SLinus Torvalds } 6991da177e4SLinus Torvalds write_unlock(&n->lock); 7001da177e4SLinus Torvalds 7011da177e4SLinus Torvalds next_elt: 7021da177e4SLinus Torvalds np = &n->next; 7031da177e4SLinus Torvalds } 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds /* Cycle through all hash buckets every base_reachable_time/2 ticks. 7061da177e4SLinus Torvalds * ARP entry timeouts range from 1/2 base_reachable_time to 3/2 7071da177e4SLinus Torvalds * base_reachable_time. 7081da177e4SLinus Torvalds */ 7091da177e4SLinus Torvalds expire = tbl->parms.base_reachable_time >> 1; 7101da177e4SLinus Torvalds expire /= (tbl->hash_mask + 1); 7111da177e4SLinus Torvalds if (!expire) 7121da177e4SLinus Torvalds expire = 1; 7131da177e4SLinus Torvalds 7141da177e4SLinus Torvalds mod_timer(&tbl->gc_timer, now + expire); 7151da177e4SLinus Torvalds 7161da177e4SLinus Torvalds write_unlock(&tbl->lock); 7171da177e4SLinus Torvalds } 7181da177e4SLinus Torvalds 7191da177e4SLinus Torvalds static __inline__ int neigh_max_probes(struct neighbour *n) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds struct neigh_parms *p = n->parms; 7221da177e4SLinus Torvalds return (n->nud_state & NUD_PROBE ? 7231da177e4SLinus Torvalds p->ucast_probes : 7241da177e4SLinus Torvalds p->ucast_probes + p->app_probes + p->mcast_probes); 7251da177e4SLinus Torvalds } 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds 7281da177e4SLinus Torvalds /* Called when a timer expires for a neighbour entry. */ 7291da177e4SLinus Torvalds 7301da177e4SLinus Torvalds static void neigh_timer_handler(unsigned long arg) 7311da177e4SLinus Torvalds { 7321da177e4SLinus Torvalds unsigned long now, next; 7331da177e4SLinus Torvalds struct neighbour *neigh = (struct neighbour *)arg; 7341da177e4SLinus Torvalds unsigned state; 7351da177e4SLinus Torvalds int notify = 0; 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds write_lock(&neigh->lock); 7381da177e4SLinus Torvalds 7391da177e4SLinus Torvalds state = neigh->nud_state; 7401da177e4SLinus Torvalds now = jiffies; 7411da177e4SLinus Torvalds next = now + HZ; 7421da177e4SLinus Torvalds 7431da177e4SLinus Torvalds if (!(state & NUD_IN_TIMER)) { 7441da177e4SLinus Torvalds #ifndef CONFIG_SMP 7451da177e4SLinus Torvalds printk(KERN_WARNING "neigh: timer & !nud_in_timer\n"); 7461da177e4SLinus Torvalds #endif 7471da177e4SLinus Torvalds goto out; 7481da177e4SLinus Torvalds } 7491da177e4SLinus Torvalds 7501da177e4SLinus Torvalds if (state & NUD_REACHABLE) { 7511da177e4SLinus Torvalds if (time_before_eq(now, 7521da177e4SLinus Torvalds neigh->confirmed + neigh->parms->reachable_time)) { 7531da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is still alive.\n", neigh); 7541da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 7551da177e4SLinus Torvalds } else if (time_before_eq(now, 7561da177e4SLinus Torvalds neigh->used + neigh->parms->delay_probe_time)) { 7571da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 7581da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 7591da177e4SLinus Torvalds neigh_suspect(neigh); 7601da177e4SLinus Torvalds next = now + neigh->parms->delay_probe_time; 7611da177e4SLinus Torvalds } else { 7621da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is suspected.\n", neigh); 7631da177e4SLinus Torvalds neigh->nud_state = NUD_STALE; 7641da177e4SLinus Torvalds neigh_suspect(neigh); 7651da177e4SLinus Torvalds } 7661da177e4SLinus Torvalds } else if (state & NUD_DELAY) { 7671da177e4SLinus Torvalds if (time_before_eq(now, 7681da177e4SLinus Torvalds neigh->confirmed + neigh->parms->delay_probe_time)) { 7691da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is now reachable.\n", neigh); 7701da177e4SLinus Torvalds neigh->nud_state = NUD_REACHABLE; 7711da177e4SLinus Torvalds neigh_connect(neigh); 7721da177e4SLinus Torvalds next = neigh->confirmed + neigh->parms->reachable_time; 7731da177e4SLinus Torvalds } else { 7741da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is probed.\n", neigh); 7751da177e4SLinus Torvalds neigh->nud_state = NUD_PROBE; 7761da177e4SLinus Torvalds atomic_set(&neigh->probes, 0); 7771da177e4SLinus Torvalds next = now + neigh->parms->retrans_time; 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds } else { 7801da177e4SLinus Torvalds /* NUD_PROBE|NUD_INCOMPLETE */ 7811da177e4SLinus Torvalds next = now + neigh->parms->retrans_time; 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) && 7851da177e4SLinus Torvalds atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) { 7861da177e4SLinus Torvalds struct sk_buff *skb; 7871da177e4SLinus Torvalds 7881da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 7891da177e4SLinus Torvalds notify = 1; 7901da177e4SLinus Torvalds NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed); 7911da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is failed.\n", neigh); 7921da177e4SLinus Torvalds 7931da177e4SLinus Torvalds /* It is very thin place. report_unreachable is very complicated 7941da177e4SLinus Torvalds routine. Particularly, it can hit the same neighbour entry! 7951da177e4SLinus Torvalds 7961da177e4SLinus Torvalds So that, we try to be accurate and avoid dead loop. --ANK 7971da177e4SLinus Torvalds */ 7981da177e4SLinus Torvalds while (neigh->nud_state == NUD_FAILED && 7991da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 8001da177e4SLinus Torvalds write_unlock(&neigh->lock); 8011da177e4SLinus Torvalds neigh->ops->error_report(neigh, skb); 8021da177e4SLinus Torvalds write_lock(&neigh->lock); 8031da177e4SLinus Torvalds } 8041da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 8051da177e4SLinus Torvalds } 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds if (neigh->nud_state & NUD_IN_TIMER) { 8081da177e4SLinus Torvalds neigh_hold(neigh); 8091da177e4SLinus Torvalds if (time_before(next, jiffies + HZ/2)) 8101da177e4SLinus Torvalds next = jiffies + HZ/2; 8111da177e4SLinus Torvalds neigh->timer.expires = next; 8121da177e4SLinus Torvalds add_timer(&neigh->timer); 8131da177e4SLinus Torvalds } 8141da177e4SLinus Torvalds if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) { 8151da177e4SLinus Torvalds struct sk_buff *skb = skb_peek(&neigh->arp_queue); 8161da177e4SLinus Torvalds /* keep skb alive even if arp_queue overflows */ 8171da177e4SLinus Torvalds if (skb) 8181da177e4SLinus Torvalds skb_get(skb); 8191da177e4SLinus Torvalds write_unlock(&neigh->lock); 8201da177e4SLinus Torvalds neigh->ops->solicit(neigh, skb); 8211da177e4SLinus Torvalds atomic_inc(&neigh->probes); 8221da177e4SLinus Torvalds if (skb) 8231da177e4SLinus Torvalds kfree_skb(skb); 8241da177e4SLinus Torvalds } else { 8251da177e4SLinus Torvalds out: 8261da177e4SLinus Torvalds write_unlock(&neigh->lock); 8271da177e4SLinus Torvalds } 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; 8531da177e4SLinus Torvalds neigh_hold(neigh); 8541da177e4SLinus Torvalds neigh->timer.expires = now + 1; 8551da177e4SLinus Torvalds add_timer(&neigh->timer); 8561da177e4SLinus Torvalds } else { 8571da177e4SLinus Torvalds neigh->nud_state = NUD_FAILED; 8581da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds if (skb) 8611da177e4SLinus Torvalds kfree_skb(skb); 8621da177e4SLinus Torvalds return 1; 8631da177e4SLinus Torvalds } 8641da177e4SLinus Torvalds } else if (neigh->nud_state & NUD_STALE) { 8651da177e4SLinus Torvalds NEIGH_PRINTK2("neigh %p is delayed.\n", neigh); 8661da177e4SLinus Torvalds neigh_hold(neigh); 8671da177e4SLinus Torvalds neigh->nud_state = NUD_DELAY; 8681da177e4SLinus Torvalds neigh->timer.expires = jiffies + neigh->parms->delay_probe_time; 8691da177e4SLinus Torvalds add_timer(&neigh->timer); 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 8721da177e4SLinus Torvalds if (neigh->nud_state == NUD_INCOMPLETE) { 8731da177e4SLinus Torvalds if (skb) { 8741da177e4SLinus Torvalds if (skb_queue_len(&neigh->arp_queue) >= 8751da177e4SLinus Torvalds neigh->parms->queue_len) { 8761da177e4SLinus Torvalds struct sk_buff *buff; 8771da177e4SLinus Torvalds buff = neigh->arp_queue.next; 8781da177e4SLinus Torvalds __skb_unlink(buff, &neigh->arp_queue); 8791da177e4SLinus Torvalds kfree_skb(buff); 8801da177e4SLinus Torvalds } 8811da177e4SLinus Torvalds __skb_queue_tail(&neigh->arp_queue, skb); 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds rc = 1; 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds out_unlock_bh: 8861da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 8871da177e4SLinus Torvalds return rc; 8881da177e4SLinus Torvalds } 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds static __inline__ void neigh_update_hhs(struct neighbour *neigh) 8911da177e4SLinus Torvalds { 8921da177e4SLinus Torvalds struct hh_cache *hh; 8931da177e4SLinus Torvalds void (*update)(struct hh_cache*, struct net_device*, unsigned char *) = 8941da177e4SLinus Torvalds neigh->dev->header_cache_update; 8951da177e4SLinus Torvalds 8961da177e4SLinus Torvalds if (update) { 8971da177e4SLinus Torvalds for (hh = neigh->hh; hh; hh = hh->hh_next) { 8981da177e4SLinus Torvalds write_lock_bh(&hh->hh_lock); 8991da177e4SLinus Torvalds update(hh, neigh->dev, neigh->ha); 9001da177e4SLinus Torvalds write_unlock_bh(&hh->hh_lock); 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds 9051da177e4SLinus Torvalds 9061da177e4SLinus Torvalds 9071da177e4SLinus Torvalds /* Generic update routine. 9081da177e4SLinus Torvalds -- lladdr is new lladdr or NULL, if it is not supplied. 9091da177e4SLinus Torvalds -- new is new state. 9101da177e4SLinus Torvalds -- flags 9111da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr, 9121da177e4SLinus Torvalds if it is different. 9131da177e4SLinus Torvalds NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected" 9141da177e4SLinus Torvalds lladdr instead of overriding it 9151da177e4SLinus Torvalds if it is different. 9161da177e4SLinus Torvalds It also allows to retain current state 9171da177e4SLinus Torvalds if lladdr is unchanged. 9181da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN means that the change is administrative. 9191da177e4SLinus Torvalds 9201da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 9211da177e4SLinus Torvalds NTF_ROUTER flag. 9221da177e4SLinus Torvalds NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as 9231da177e4SLinus Torvalds a router. 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds Caller MUST hold reference count on the entry. 9261da177e4SLinus Torvalds */ 9271da177e4SLinus Torvalds 9281da177e4SLinus Torvalds int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, 9291da177e4SLinus Torvalds u32 flags) 9301da177e4SLinus Torvalds { 9311da177e4SLinus Torvalds u8 old; 9321da177e4SLinus Torvalds int err; 9331da177e4SLinus Torvalds #ifdef CONFIG_ARPD 9341da177e4SLinus Torvalds int notify = 0; 9351da177e4SLinus Torvalds #endif 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 #ifdef CONFIG_ARPD 9561da177e4SLinus Torvalds notify = old & NUD_VALID; 9571da177e4SLinus Torvalds #endif 9581da177e4SLinus Torvalds goto out; 9591da177e4SLinus Torvalds } 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds /* Compare new lladdr with cached one */ 9621da177e4SLinus Torvalds if (!dev->addr_len) { 9631da177e4SLinus Torvalds /* First case: device needs no address. */ 9641da177e4SLinus Torvalds lladdr = neigh->ha; 9651da177e4SLinus Torvalds } else if (lladdr) { 9661da177e4SLinus Torvalds /* The second case: if something is already cached 9671da177e4SLinus Torvalds and a new address is proposed: 9681da177e4SLinus Torvalds - compare new & old 9691da177e4SLinus Torvalds - if they are different, check override flag 9701da177e4SLinus Torvalds */ 9711da177e4SLinus Torvalds if ((old & NUD_VALID) && 9721da177e4SLinus Torvalds !memcmp(lladdr, neigh->ha, dev->addr_len)) 9731da177e4SLinus Torvalds lladdr = neigh->ha; 9741da177e4SLinus Torvalds } else { 9751da177e4SLinus Torvalds /* No address is supplied; if we know something, 9761da177e4SLinus Torvalds use it, otherwise discard the request. 9771da177e4SLinus Torvalds */ 9781da177e4SLinus Torvalds err = -EINVAL; 9791da177e4SLinus Torvalds if (!(old & NUD_VALID)) 9801da177e4SLinus Torvalds goto out; 9811da177e4SLinus Torvalds lladdr = neigh->ha; 9821da177e4SLinus Torvalds } 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds if (new & NUD_CONNECTED) 9851da177e4SLinus Torvalds neigh->confirmed = jiffies; 9861da177e4SLinus Torvalds neigh->updated = jiffies; 9871da177e4SLinus Torvalds 9881da177e4SLinus Torvalds /* If entry was valid and address is not changed, 9891da177e4SLinus Torvalds do not change entry state, if new one is STALE. 9901da177e4SLinus Torvalds */ 9911da177e4SLinus Torvalds err = 0; 9921da177e4SLinus Torvalds update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER; 9931da177e4SLinus Torvalds if (old & NUD_VALID) { 9941da177e4SLinus Torvalds if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) { 9951da177e4SLinus Torvalds update_isrouter = 0; 9961da177e4SLinus Torvalds if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) && 9971da177e4SLinus Torvalds (old & NUD_CONNECTED)) { 9981da177e4SLinus Torvalds lladdr = neigh->ha; 9991da177e4SLinus Torvalds new = NUD_STALE; 10001da177e4SLinus Torvalds } else 10011da177e4SLinus Torvalds goto out; 10021da177e4SLinus Torvalds } else { 10031da177e4SLinus Torvalds if (lladdr == neigh->ha && new == NUD_STALE && 10041da177e4SLinus Torvalds ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) || 10051da177e4SLinus Torvalds (old & NUD_CONNECTED)) 10061da177e4SLinus Torvalds ) 10071da177e4SLinus Torvalds new = old; 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds 10111da177e4SLinus Torvalds if (new != old) { 10121da177e4SLinus Torvalds neigh_del_timer(neigh); 10131da177e4SLinus Torvalds if (new & NUD_IN_TIMER) { 10141da177e4SLinus Torvalds neigh_hold(neigh); 10151da177e4SLinus Torvalds neigh->timer.expires = jiffies + 10161da177e4SLinus Torvalds ((new & NUD_REACHABLE) ? 10171da177e4SLinus Torvalds neigh->parms->reachable_time : 0); 10181da177e4SLinus Torvalds add_timer(&neigh->timer); 10191da177e4SLinus Torvalds } 10201da177e4SLinus Torvalds neigh->nud_state = new; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds 10231da177e4SLinus Torvalds if (lladdr != neigh->ha) { 10241da177e4SLinus Torvalds memcpy(&neigh->ha, lladdr, dev->addr_len); 10251da177e4SLinus Torvalds neigh_update_hhs(neigh); 10261da177e4SLinus Torvalds if (!(new & NUD_CONNECTED)) 10271da177e4SLinus Torvalds neigh->confirmed = jiffies - 10281da177e4SLinus Torvalds (neigh->parms->base_reachable_time << 1); 10291da177e4SLinus Torvalds #ifdef CONFIG_ARPD 10301da177e4SLinus Torvalds notify = 1; 10311da177e4SLinus Torvalds #endif 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds if (new == old) 10341da177e4SLinus Torvalds goto out; 10351da177e4SLinus Torvalds if (new & NUD_CONNECTED) 10361da177e4SLinus Torvalds neigh_connect(neigh); 10371da177e4SLinus Torvalds else 10381da177e4SLinus Torvalds neigh_suspect(neigh); 10391da177e4SLinus Torvalds if (!(old & NUD_VALID)) { 10401da177e4SLinus Torvalds struct sk_buff *skb; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* Again: avoid dead loop if something went wrong */ 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds while (neigh->nud_state & NUD_VALID && 10451da177e4SLinus Torvalds (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) { 10461da177e4SLinus Torvalds struct neighbour *n1 = neigh; 10471da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 10481da177e4SLinus Torvalds /* On shaper/eql skb->dst->neighbour != neigh :( */ 10491da177e4SLinus Torvalds if (skb->dst && skb->dst->neighbour) 10501da177e4SLinus Torvalds n1 = skb->dst->neighbour; 10511da177e4SLinus Torvalds n1->output(skb); 10521da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds skb_queue_purge(&neigh->arp_queue); 10551da177e4SLinus Torvalds } 10561da177e4SLinus Torvalds out: 10571da177e4SLinus Torvalds if (update_isrouter) { 10581da177e4SLinus Torvalds neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ? 10591da177e4SLinus Torvalds (neigh->flags | NTF_ROUTER) : 10601da177e4SLinus Torvalds (neigh->flags & ~NTF_ROUTER); 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 10631da177e4SLinus Torvalds #ifdef CONFIG_ARPD 10641da177e4SLinus Torvalds if (notify && neigh->parms->app_probes) 10651da177e4SLinus Torvalds neigh_app_notify(neigh); 10661da177e4SLinus Torvalds #endif 10671da177e4SLinus Torvalds return err; 10681da177e4SLinus Torvalds } 10691da177e4SLinus Torvalds 10701da177e4SLinus Torvalds struct neighbour *neigh_event_ns(struct neigh_table *tbl, 10711da177e4SLinus Torvalds u8 *lladdr, void *saddr, 10721da177e4SLinus Torvalds struct net_device *dev) 10731da177e4SLinus Torvalds { 10741da177e4SLinus Torvalds struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev, 10751da177e4SLinus Torvalds lladdr || !dev->addr_len); 10761da177e4SLinus Torvalds if (neigh) 10771da177e4SLinus Torvalds neigh_update(neigh, lladdr, NUD_STALE, 10781da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE); 10791da177e4SLinus Torvalds return neigh; 10801da177e4SLinus Torvalds } 10811da177e4SLinus Torvalds 10821da177e4SLinus Torvalds static void neigh_hh_init(struct neighbour *n, struct dst_entry *dst, 10831da177e4SLinus Torvalds u16 protocol) 10841da177e4SLinus Torvalds { 10851da177e4SLinus Torvalds struct hh_cache *hh; 10861da177e4SLinus Torvalds struct net_device *dev = dst->dev; 10871da177e4SLinus Torvalds 10881da177e4SLinus Torvalds for (hh = n->hh; hh; hh = hh->hh_next) 10891da177e4SLinus Torvalds if (hh->hh_type == protocol) 10901da177e4SLinus Torvalds break; 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds if (!hh && (hh = kmalloc(sizeof(*hh), GFP_ATOMIC)) != NULL) { 10931da177e4SLinus Torvalds memset(hh, 0, sizeof(struct hh_cache)); 10941da177e4SLinus Torvalds rwlock_init(&hh->hh_lock); 10951da177e4SLinus Torvalds hh->hh_type = protocol; 10961da177e4SLinus Torvalds atomic_set(&hh->hh_refcnt, 0); 10971da177e4SLinus Torvalds hh->hh_next = NULL; 10981da177e4SLinus Torvalds if (dev->hard_header_cache(n, hh)) { 10991da177e4SLinus Torvalds kfree(hh); 11001da177e4SLinus Torvalds hh = NULL; 11011da177e4SLinus Torvalds } else { 11021da177e4SLinus Torvalds atomic_inc(&hh->hh_refcnt); 11031da177e4SLinus Torvalds hh->hh_next = n->hh; 11041da177e4SLinus Torvalds n->hh = hh; 11051da177e4SLinus Torvalds if (n->nud_state & NUD_CONNECTED) 11061da177e4SLinus Torvalds hh->hh_output = n->ops->hh_output; 11071da177e4SLinus Torvalds else 11081da177e4SLinus Torvalds hh->hh_output = n->ops->output; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds } 11111da177e4SLinus Torvalds if (hh) { 11121da177e4SLinus Torvalds atomic_inc(&hh->hh_refcnt); 11131da177e4SLinus Torvalds dst->hh = hh; 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds } 11161da177e4SLinus Torvalds 11171da177e4SLinus Torvalds /* This function can be used in contexts, where only old dev_queue_xmit 11181da177e4SLinus Torvalds worked, f.e. if you want to override normal output path (eql, shaper), 11191da177e4SLinus Torvalds but resolution is not made yet. 11201da177e4SLinus Torvalds */ 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds int neigh_compat_output(struct sk_buff *skb) 11231da177e4SLinus Torvalds { 11241da177e4SLinus Torvalds struct net_device *dev = skb->dev; 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11271da177e4SLinus Torvalds 11281da177e4SLinus Torvalds if (dev->hard_header && 11291da177e4SLinus Torvalds dev->hard_header(skb, dev, ntohs(skb->protocol), NULL, NULL, 11301da177e4SLinus Torvalds skb->len) < 0 && 11311da177e4SLinus Torvalds dev->rebuild_header(skb)) 11321da177e4SLinus Torvalds return 0; 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds return dev_queue_xmit(skb); 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds 11371da177e4SLinus Torvalds /* Slow and careful. */ 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds int neigh_resolve_output(struct sk_buff *skb) 11401da177e4SLinus Torvalds { 11411da177e4SLinus Torvalds struct dst_entry *dst = skb->dst; 11421da177e4SLinus Torvalds struct neighbour *neigh; 11431da177e4SLinus Torvalds int rc = 0; 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds if (!dst || !(neigh = dst->neighbour)) 11461da177e4SLinus Torvalds goto discard; 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds if (!neigh_event_send(neigh, skb)) { 11511da177e4SLinus Torvalds int err; 11521da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 11531da177e4SLinus Torvalds if (dev->hard_header_cache && !dst->hh) { 11541da177e4SLinus Torvalds write_lock_bh(&neigh->lock); 11551da177e4SLinus Torvalds if (!dst->hh) 11561da177e4SLinus Torvalds neigh_hh_init(neigh, dst, dst->ops->protocol); 11571da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11581da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11591da177e4SLinus Torvalds write_unlock_bh(&neigh->lock); 11601da177e4SLinus Torvalds } else { 11611da177e4SLinus Torvalds read_lock_bh(&neigh->lock); 11621da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11631da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11641da177e4SLinus Torvalds read_unlock_bh(&neigh->lock); 11651da177e4SLinus Torvalds } 11661da177e4SLinus Torvalds if (err >= 0) 11671da177e4SLinus Torvalds rc = neigh->ops->queue_xmit(skb); 11681da177e4SLinus Torvalds else 11691da177e4SLinus Torvalds goto out_kfree_skb; 11701da177e4SLinus Torvalds } 11711da177e4SLinus Torvalds out: 11721da177e4SLinus Torvalds return rc; 11731da177e4SLinus Torvalds discard: 11741da177e4SLinus Torvalds NEIGH_PRINTK1("neigh_resolve_output: dst=%p neigh=%p\n", 11751da177e4SLinus Torvalds dst, dst ? dst->neighbour : NULL); 11761da177e4SLinus Torvalds out_kfree_skb: 11771da177e4SLinus Torvalds rc = -EINVAL; 11781da177e4SLinus Torvalds kfree_skb(skb); 11791da177e4SLinus Torvalds goto out; 11801da177e4SLinus Torvalds } 11811da177e4SLinus Torvalds 11821da177e4SLinus Torvalds /* As fast as possible without hh cache */ 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds int neigh_connected_output(struct sk_buff *skb) 11851da177e4SLinus Torvalds { 11861da177e4SLinus Torvalds int err; 11871da177e4SLinus Torvalds struct dst_entry *dst = skb->dst; 11881da177e4SLinus Torvalds struct neighbour *neigh = dst->neighbour; 11891da177e4SLinus Torvalds struct net_device *dev = neigh->dev; 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds __skb_pull(skb, skb->nh.raw - skb->data); 11921da177e4SLinus Torvalds 11931da177e4SLinus Torvalds read_lock_bh(&neigh->lock); 11941da177e4SLinus Torvalds err = dev->hard_header(skb, dev, ntohs(skb->protocol), 11951da177e4SLinus Torvalds neigh->ha, NULL, skb->len); 11961da177e4SLinus Torvalds read_unlock_bh(&neigh->lock); 11971da177e4SLinus Torvalds if (err >= 0) 11981da177e4SLinus Torvalds err = neigh->ops->queue_xmit(skb); 11991da177e4SLinus Torvalds else { 12001da177e4SLinus Torvalds err = -EINVAL; 12011da177e4SLinus Torvalds kfree_skb(skb); 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds return err; 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds static void neigh_proxy_process(unsigned long arg) 12071da177e4SLinus Torvalds { 12081da177e4SLinus Torvalds struct neigh_table *tbl = (struct neigh_table *)arg; 12091da177e4SLinus Torvalds long sched_next = 0; 12101da177e4SLinus Torvalds unsigned long now = jiffies; 12111da177e4SLinus Torvalds struct sk_buff *skb; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds skb = tbl->proxy_queue.next; 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds while (skb != (struct sk_buff *)&tbl->proxy_queue) { 12181da177e4SLinus Torvalds struct sk_buff *back = skb; 12191da177e4SLinus Torvalds long tdif = back->stamp.tv_usec - now; 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds skb = skb->next; 12221da177e4SLinus Torvalds if (tdif <= 0) { 12231da177e4SLinus Torvalds struct net_device *dev = back->dev; 12241da177e4SLinus Torvalds __skb_unlink(back, &tbl->proxy_queue); 12251da177e4SLinus Torvalds if (tbl->proxy_redo && netif_running(dev)) 12261da177e4SLinus Torvalds tbl->proxy_redo(back); 12271da177e4SLinus Torvalds else 12281da177e4SLinus Torvalds kfree_skb(back); 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds dev_put(dev); 12311da177e4SLinus Torvalds } else if (!sched_next || tdif < sched_next) 12321da177e4SLinus Torvalds sched_next = tdif; 12331da177e4SLinus Torvalds } 12341da177e4SLinus Torvalds del_timer(&tbl->proxy_timer); 12351da177e4SLinus Torvalds if (sched_next) 12361da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, jiffies + sched_next); 12371da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 12381da177e4SLinus Torvalds } 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, 12411da177e4SLinus Torvalds struct sk_buff *skb) 12421da177e4SLinus Torvalds { 12431da177e4SLinus Torvalds unsigned long now = jiffies; 12441da177e4SLinus Torvalds unsigned long sched_next = now + (net_random() % p->proxy_delay); 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds if (tbl->proxy_queue.qlen > p->proxy_qlen) { 12471da177e4SLinus Torvalds kfree_skb(skb); 12481da177e4SLinus Torvalds return; 12491da177e4SLinus Torvalds } 12501da177e4SLinus Torvalds skb->stamp.tv_sec = LOCALLY_ENQUEUED; 12511da177e4SLinus Torvalds skb->stamp.tv_usec = sched_next; 12521da177e4SLinus Torvalds 12531da177e4SLinus Torvalds spin_lock(&tbl->proxy_queue.lock); 12541da177e4SLinus Torvalds if (del_timer(&tbl->proxy_timer)) { 12551da177e4SLinus Torvalds if (time_before(tbl->proxy_timer.expires, sched_next)) 12561da177e4SLinus Torvalds sched_next = tbl->proxy_timer.expires; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds dst_release(skb->dst); 12591da177e4SLinus Torvalds skb->dst = NULL; 12601da177e4SLinus Torvalds dev_hold(skb->dev); 12611da177e4SLinus Torvalds __skb_queue_tail(&tbl->proxy_queue, skb); 12621da177e4SLinus Torvalds mod_timer(&tbl->proxy_timer, sched_next); 12631da177e4SLinus Torvalds spin_unlock(&tbl->proxy_queue.lock); 12641da177e4SLinus Torvalds } 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds struct neigh_parms *neigh_parms_alloc(struct net_device *dev, 12681da177e4SLinus Torvalds struct neigh_table *tbl) 12691da177e4SLinus Torvalds { 12701da177e4SLinus Torvalds struct neigh_parms *p = kmalloc(sizeof(*p), GFP_KERNEL); 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds if (p) { 12731da177e4SLinus Torvalds memcpy(p, &tbl->parms, sizeof(*p)); 12741da177e4SLinus Torvalds p->tbl = tbl; 12751da177e4SLinus Torvalds atomic_set(&p->refcnt, 1); 12761da177e4SLinus Torvalds INIT_RCU_HEAD(&p->rcu_head); 12771da177e4SLinus Torvalds p->reachable_time = 12781da177e4SLinus Torvalds neigh_rand_reach_time(p->base_reachable_time); 12791da177e4SLinus Torvalds if (dev && dev->neigh_setup && dev->neigh_setup(dev, p)) { 12801da177e4SLinus Torvalds kfree(p); 12811da177e4SLinus Torvalds return NULL; 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds p->sysctl_table = NULL; 12841da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 12851da177e4SLinus Torvalds p->next = tbl->parms.next; 12861da177e4SLinus Torvalds tbl->parms.next = p; 12871da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 12881da177e4SLinus Torvalds } 12891da177e4SLinus Torvalds return p; 12901da177e4SLinus Torvalds } 12911da177e4SLinus Torvalds 12921da177e4SLinus Torvalds static void neigh_rcu_free_parms(struct rcu_head *head) 12931da177e4SLinus Torvalds { 12941da177e4SLinus Torvalds struct neigh_parms *parms = 12951da177e4SLinus Torvalds container_of(head, struct neigh_parms, rcu_head); 12961da177e4SLinus Torvalds 12971da177e4SLinus Torvalds neigh_parms_put(parms); 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 13001da177e4SLinus Torvalds void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms) 13011da177e4SLinus Torvalds { 13021da177e4SLinus Torvalds struct neigh_parms **p; 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds if (!parms || parms == &tbl->parms) 13051da177e4SLinus Torvalds return; 13061da177e4SLinus Torvalds write_lock_bh(&tbl->lock); 13071da177e4SLinus Torvalds for (p = &tbl->parms.next; *p; p = &(*p)->next) { 13081da177e4SLinus Torvalds if (*p == parms) { 13091da177e4SLinus Torvalds *p = parms->next; 13101da177e4SLinus Torvalds parms->dead = 1; 13111da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 13121da177e4SLinus Torvalds call_rcu(&parms->rcu_head, neigh_rcu_free_parms); 13131da177e4SLinus Torvalds return; 13141da177e4SLinus Torvalds } 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds write_unlock_bh(&tbl->lock); 13171da177e4SLinus Torvalds NEIGH_PRINTK1("neigh_parms_release: not found\n"); 13181da177e4SLinus Torvalds } 13191da177e4SLinus Torvalds 13201da177e4SLinus Torvalds void neigh_parms_destroy(struct neigh_parms *parms) 13211da177e4SLinus Torvalds { 13221da177e4SLinus Torvalds kfree(parms); 13231da177e4SLinus Torvalds } 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds void neigh_table_init(struct neigh_table *tbl) 13271da177e4SLinus Torvalds { 13281da177e4SLinus Torvalds unsigned long now = jiffies; 13291da177e4SLinus Torvalds unsigned long phsize; 13301da177e4SLinus Torvalds 13311da177e4SLinus Torvalds atomic_set(&tbl->parms.refcnt, 1); 13321da177e4SLinus Torvalds INIT_RCU_HEAD(&tbl->parms.rcu_head); 13331da177e4SLinus Torvalds tbl->parms.reachable_time = 13341da177e4SLinus Torvalds neigh_rand_reach_time(tbl->parms.base_reachable_time); 13351da177e4SLinus Torvalds 13361da177e4SLinus Torvalds if (!tbl->kmem_cachep) 13371da177e4SLinus Torvalds tbl->kmem_cachep = kmem_cache_create(tbl->id, 13381da177e4SLinus Torvalds tbl->entry_size, 13391da177e4SLinus Torvalds 0, SLAB_HWCACHE_ALIGN, 13401da177e4SLinus Torvalds NULL, NULL); 13411da177e4SLinus Torvalds 13421da177e4SLinus Torvalds if (!tbl->kmem_cachep) 13431da177e4SLinus Torvalds panic("cannot create neighbour cache"); 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds tbl->stats = alloc_percpu(struct neigh_statistics); 13461da177e4SLinus Torvalds if (!tbl->stats) 13471da177e4SLinus Torvalds panic("cannot create neighbour cache statistics"); 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 13501da177e4SLinus Torvalds tbl->pde = create_proc_entry(tbl->id, 0, proc_net_stat); 13511da177e4SLinus Torvalds if (!tbl->pde) 13521da177e4SLinus Torvalds panic("cannot create neighbour proc dir entry"); 13531da177e4SLinus Torvalds tbl->pde->proc_fops = &neigh_stat_seq_fops; 13541da177e4SLinus Torvalds tbl->pde->data = tbl; 13551da177e4SLinus Torvalds #endif 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds tbl->hash_mask = 1; 13581da177e4SLinus Torvalds tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1); 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *); 13611da177e4SLinus Torvalds tbl->phash_buckets = kmalloc(phsize, GFP_KERNEL); 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds if (!tbl->hash_buckets || !tbl->phash_buckets) 13641da177e4SLinus Torvalds panic("cannot allocate neighbour cache hashes"); 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds memset(tbl->phash_buckets, 0, phsize); 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd)); 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds rwlock_init(&tbl->lock); 13711da177e4SLinus Torvalds init_timer(&tbl->gc_timer); 13721da177e4SLinus Torvalds tbl->gc_timer.data = (unsigned long)tbl; 13731da177e4SLinus Torvalds tbl->gc_timer.function = neigh_periodic_timer; 13741da177e4SLinus Torvalds tbl->gc_timer.expires = now + 1; 13751da177e4SLinus Torvalds add_timer(&tbl->gc_timer); 13761da177e4SLinus Torvalds 13771da177e4SLinus Torvalds init_timer(&tbl->proxy_timer); 13781da177e4SLinus Torvalds tbl->proxy_timer.data = (unsigned long)tbl; 13791da177e4SLinus Torvalds tbl->proxy_timer.function = neigh_proxy_process; 13801da177e4SLinus Torvalds skb_queue_head_init(&tbl->proxy_queue); 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds tbl->last_flush = now; 13831da177e4SLinus Torvalds tbl->last_rand = now + tbl->parms.reachable_time * 20; 13841da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 13851da177e4SLinus Torvalds tbl->next = neigh_tables; 13861da177e4SLinus Torvalds neigh_tables = tbl; 13871da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 13881da177e4SLinus Torvalds } 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds int neigh_table_clear(struct neigh_table *tbl) 13911da177e4SLinus Torvalds { 13921da177e4SLinus Torvalds struct neigh_table **tp; 13931da177e4SLinus Torvalds 13941da177e4SLinus Torvalds /* It is not clean... Fix it to unload IPv6 module safely */ 13951da177e4SLinus Torvalds del_timer_sync(&tbl->gc_timer); 13961da177e4SLinus Torvalds del_timer_sync(&tbl->proxy_timer); 13971da177e4SLinus Torvalds pneigh_queue_purge(&tbl->proxy_queue); 13981da177e4SLinus Torvalds neigh_ifdown(tbl, NULL); 13991da177e4SLinus Torvalds if (atomic_read(&tbl->entries)) 14001da177e4SLinus Torvalds printk(KERN_CRIT "neighbour leakage\n"); 14011da177e4SLinus Torvalds write_lock(&neigh_tbl_lock); 14021da177e4SLinus Torvalds for (tp = &neigh_tables; *tp; tp = &(*tp)->next) { 14031da177e4SLinus Torvalds if (*tp == tbl) { 14041da177e4SLinus Torvalds *tp = tbl->next; 14051da177e4SLinus Torvalds break; 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds } 14081da177e4SLinus Torvalds write_unlock(&neigh_tbl_lock); 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds neigh_hash_free(tbl->hash_buckets, tbl->hash_mask + 1); 14111da177e4SLinus Torvalds tbl->hash_buckets = NULL; 14121da177e4SLinus Torvalds 14131da177e4SLinus Torvalds kfree(tbl->phash_buckets); 14141da177e4SLinus Torvalds tbl->phash_buckets = NULL; 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds return 0; 14171da177e4SLinus Torvalds } 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 14201da177e4SLinus Torvalds { 14211da177e4SLinus Torvalds struct ndmsg *ndm = NLMSG_DATA(nlh); 14221da177e4SLinus Torvalds struct rtattr **nda = arg; 14231da177e4SLinus Torvalds struct neigh_table *tbl; 14241da177e4SLinus Torvalds struct net_device *dev = NULL; 14251da177e4SLinus Torvalds int err = -ENODEV; 14261da177e4SLinus Torvalds 14271da177e4SLinus Torvalds if (ndm->ndm_ifindex && 14281da177e4SLinus Torvalds (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) 14291da177e4SLinus Torvalds goto out; 14301da177e4SLinus Torvalds 14311da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 14321da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 14331da177e4SLinus Torvalds struct rtattr *dst_attr = nda[NDA_DST - 1]; 14341da177e4SLinus Torvalds struct neighbour *n; 14351da177e4SLinus Torvalds 14361da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 14371da177e4SLinus Torvalds continue; 14381da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds err = -EINVAL; 14411da177e4SLinus Torvalds if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len) 14421da177e4SLinus Torvalds goto out_dev_put; 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 14451da177e4SLinus Torvalds err = pneigh_delete(tbl, RTA_DATA(dst_attr), dev); 14461da177e4SLinus Torvalds goto out_dev_put; 14471da177e4SLinus Torvalds } 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds if (!dev) 14501da177e4SLinus Torvalds goto out; 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev); 14531da177e4SLinus Torvalds if (n) { 14541da177e4SLinus Torvalds err = neigh_update(n, NULL, NUD_FAILED, 14551da177e4SLinus Torvalds NEIGH_UPDATE_F_OVERRIDE| 14561da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN); 14571da177e4SLinus Torvalds neigh_release(n); 14581da177e4SLinus Torvalds } 14591da177e4SLinus Torvalds goto out_dev_put; 14601da177e4SLinus Torvalds } 14611da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 14621da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 14631da177e4SLinus Torvalds out_dev_put: 14641da177e4SLinus Torvalds if (dev) 14651da177e4SLinus Torvalds dev_put(dev); 14661da177e4SLinus Torvalds out: 14671da177e4SLinus Torvalds return err; 14681da177e4SLinus Torvalds } 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 14711da177e4SLinus Torvalds { 14721da177e4SLinus Torvalds struct ndmsg *ndm = NLMSG_DATA(nlh); 14731da177e4SLinus Torvalds struct rtattr **nda = arg; 14741da177e4SLinus Torvalds struct neigh_table *tbl; 14751da177e4SLinus Torvalds struct net_device *dev = NULL; 14761da177e4SLinus Torvalds int err = -ENODEV; 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds if (ndm->ndm_ifindex && 14791da177e4SLinus Torvalds (dev = dev_get_by_index(ndm->ndm_ifindex)) == NULL) 14801da177e4SLinus Torvalds goto out; 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 14831da177e4SLinus Torvalds for (tbl = neigh_tables; tbl; tbl = tbl->next) { 14841da177e4SLinus Torvalds struct rtattr *lladdr_attr = nda[NDA_LLADDR - 1]; 14851da177e4SLinus Torvalds struct rtattr *dst_attr = nda[NDA_DST - 1]; 14861da177e4SLinus Torvalds int override = 1; 14871da177e4SLinus Torvalds struct neighbour *n; 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds if (tbl->family != ndm->ndm_family) 14901da177e4SLinus Torvalds continue; 14911da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds err = -EINVAL; 14941da177e4SLinus Torvalds if (!dst_attr || RTA_PAYLOAD(dst_attr) < tbl->key_len) 14951da177e4SLinus Torvalds goto out_dev_put; 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds if (ndm->ndm_flags & NTF_PROXY) { 14981da177e4SLinus Torvalds err = -ENOBUFS; 14991da177e4SLinus Torvalds if (pneigh_lookup(tbl, RTA_DATA(dst_attr), dev, 1)) 15001da177e4SLinus Torvalds err = 0; 15011da177e4SLinus Torvalds goto out_dev_put; 15021da177e4SLinus Torvalds } 15031da177e4SLinus Torvalds 15041da177e4SLinus Torvalds err = -EINVAL; 15051da177e4SLinus Torvalds if (!dev) 15061da177e4SLinus Torvalds goto out; 15071da177e4SLinus Torvalds if (lladdr_attr && RTA_PAYLOAD(lladdr_attr) < dev->addr_len) 15081da177e4SLinus Torvalds goto out_dev_put; 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds n = neigh_lookup(tbl, RTA_DATA(dst_attr), dev); 15111da177e4SLinus Torvalds if (n) { 15121da177e4SLinus Torvalds if (nlh->nlmsg_flags & NLM_F_EXCL) { 15131da177e4SLinus Torvalds err = -EEXIST; 15141da177e4SLinus Torvalds neigh_release(n); 15151da177e4SLinus Torvalds goto out_dev_put; 15161da177e4SLinus Torvalds } 15171da177e4SLinus Torvalds 15181da177e4SLinus Torvalds override = nlh->nlmsg_flags & NLM_F_REPLACE; 15191da177e4SLinus Torvalds } else if (!(nlh->nlmsg_flags & NLM_F_CREATE)) { 15201da177e4SLinus Torvalds err = -ENOENT; 15211da177e4SLinus Torvalds goto out_dev_put; 15221da177e4SLinus Torvalds } else { 15231da177e4SLinus Torvalds n = __neigh_lookup_errno(tbl, RTA_DATA(dst_attr), dev); 15241da177e4SLinus Torvalds if (IS_ERR(n)) { 15251da177e4SLinus Torvalds err = PTR_ERR(n); 15261da177e4SLinus Torvalds goto out_dev_put; 15271da177e4SLinus Torvalds } 15281da177e4SLinus Torvalds } 15291da177e4SLinus Torvalds 15301da177e4SLinus Torvalds err = neigh_update(n, 15311da177e4SLinus Torvalds lladdr_attr ? RTA_DATA(lladdr_attr) : NULL, 15321da177e4SLinus Torvalds ndm->ndm_state, 15331da177e4SLinus Torvalds (override ? NEIGH_UPDATE_F_OVERRIDE : 0) | 15341da177e4SLinus Torvalds NEIGH_UPDATE_F_ADMIN); 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds neigh_release(n); 15371da177e4SLinus Torvalds goto out_dev_put; 15381da177e4SLinus Torvalds } 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 15411da177e4SLinus Torvalds err = -EADDRNOTAVAIL; 15421da177e4SLinus Torvalds out_dev_put: 15431da177e4SLinus Torvalds if (dev) 15441da177e4SLinus Torvalds dev_put(dev); 15451da177e4SLinus Torvalds out: 15461da177e4SLinus Torvalds return err; 15471da177e4SLinus Torvalds } 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds 15501da177e4SLinus Torvalds static int neigh_fill_info(struct sk_buff *skb, struct neighbour *n, 15511da177e4SLinus Torvalds u32 pid, u32 seq, int event) 15521da177e4SLinus Torvalds { 15531da177e4SLinus Torvalds unsigned long now = jiffies; 15541da177e4SLinus Torvalds unsigned char *b = skb->tail; 15551da177e4SLinus Torvalds struct nda_cacheinfo ci; 15561da177e4SLinus Torvalds int locked = 0; 15571da177e4SLinus Torvalds u32 probes; 15581da177e4SLinus Torvalds struct nlmsghdr *nlh = NLMSG_PUT(skb, pid, seq, event, 15591da177e4SLinus Torvalds sizeof(struct ndmsg)); 15601da177e4SLinus Torvalds struct ndmsg *ndm = NLMSG_DATA(nlh); 15611da177e4SLinus Torvalds 15621da177e4SLinus Torvalds nlh->nlmsg_flags = pid ? NLM_F_MULTI : 0; 15631da177e4SLinus Torvalds ndm->ndm_family = n->ops->family; 15641da177e4SLinus Torvalds ndm->ndm_flags = n->flags; 15651da177e4SLinus Torvalds ndm->ndm_type = n->type; 15661da177e4SLinus Torvalds ndm->ndm_ifindex = n->dev->ifindex; 15671da177e4SLinus Torvalds RTA_PUT(skb, NDA_DST, n->tbl->key_len, n->primary_key); 15681da177e4SLinus Torvalds read_lock_bh(&n->lock); 15691da177e4SLinus Torvalds locked = 1; 15701da177e4SLinus Torvalds ndm->ndm_state = n->nud_state; 15711da177e4SLinus Torvalds if (n->nud_state & NUD_VALID) 15721da177e4SLinus Torvalds RTA_PUT(skb, NDA_LLADDR, n->dev->addr_len, n->ha); 15731da177e4SLinus Torvalds ci.ndm_used = now - n->used; 15741da177e4SLinus Torvalds ci.ndm_confirmed = now - n->confirmed; 15751da177e4SLinus Torvalds ci.ndm_updated = now - n->updated; 15761da177e4SLinus Torvalds ci.ndm_refcnt = atomic_read(&n->refcnt) - 1; 15771da177e4SLinus Torvalds probes = atomic_read(&n->probes); 15781da177e4SLinus Torvalds read_unlock_bh(&n->lock); 15791da177e4SLinus Torvalds locked = 0; 15801da177e4SLinus Torvalds RTA_PUT(skb, NDA_CACHEINFO, sizeof(ci), &ci); 15811da177e4SLinus Torvalds RTA_PUT(skb, NDA_PROBES, sizeof(probes), &probes); 15821da177e4SLinus Torvalds nlh->nlmsg_len = skb->tail - b; 15831da177e4SLinus Torvalds return skb->len; 15841da177e4SLinus Torvalds 15851da177e4SLinus Torvalds nlmsg_failure: 15861da177e4SLinus Torvalds rtattr_failure: 15871da177e4SLinus Torvalds if (locked) 15881da177e4SLinus Torvalds read_unlock_bh(&n->lock); 15891da177e4SLinus Torvalds skb_trim(skb, b - skb->data); 15901da177e4SLinus Torvalds return -1; 15911da177e4SLinus Torvalds } 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds 15941da177e4SLinus Torvalds static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb, 15951da177e4SLinus Torvalds struct netlink_callback *cb) 15961da177e4SLinus Torvalds { 15971da177e4SLinus Torvalds struct neighbour *n; 15981da177e4SLinus Torvalds int rc, h, s_h = cb->args[1]; 15991da177e4SLinus Torvalds int idx, s_idx = idx = cb->args[2]; 16001da177e4SLinus Torvalds 16011da177e4SLinus Torvalds for (h = 0; h <= tbl->hash_mask; h++) { 16021da177e4SLinus Torvalds if (h < s_h) 16031da177e4SLinus Torvalds continue; 16041da177e4SLinus Torvalds if (h > s_h) 16051da177e4SLinus Torvalds s_idx = 0; 16061da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 16071da177e4SLinus Torvalds for (n = tbl->hash_buckets[h], idx = 0; n; n = n->next, idx++) { 16081da177e4SLinus Torvalds if (idx < s_idx) 16091da177e4SLinus Torvalds continue; 16101da177e4SLinus Torvalds if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).pid, 16111da177e4SLinus Torvalds cb->nlh->nlmsg_seq, 16121da177e4SLinus Torvalds RTM_NEWNEIGH) <= 0) { 16131da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 16141da177e4SLinus Torvalds rc = -1; 16151da177e4SLinus Torvalds goto out; 16161da177e4SLinus Torvalds } 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 16191da177e4SLinus Torvalds } 16201da177e4SLinus Torvalds rc = skb->len; 16211da177e4SLinus Torvalds out: 16221da177e4SLinus Torvalds cb->args[1] = h; 16231da177e4SLinus Torvalds cb->args[2] = idx; 16241da177e4SLinus Torvalds return rc; 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds 16271da177e4SLinus Torvalds int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb) 16281da177e4SLinus Torvalds { 16291da177e4SLinus Torvalds struct neigh_table *tbl; 16301da177e4SLinus Torvalds int t, family, s_t; 16311da177e4SLinus Torvalds 16321da177e4SLinus Torvalds read_lock(&neigh_tbl_lock); 16331da177e4SLinus Torvalds family = ((struct rtgenmsg *)NLMSG_DATA(cb->nlh))->rtgen_family; 16341da177e4SLinus Torvalds s_t = cb->args[0]; 16351da177e4SLinus Torvalds 16361da177e4SLinus Torvalds for (tbl = neigh_tables, t = 0; tbl; tbl = tbl->next, t++) { 16371da177e4SLinus Torvalds if (t < s_t || (family && tbl->family != family)) 16381da177e4SLinus Torvalds continue; 16391da177e4SLinus Torvalds if (t > s_t) 16401da177e4SLinus Torvalds memset(&cb->args[1], 0, sizeof(cb->args) - 16411da177e4SLinus Torvalds sizeof(cb->args[0])); 16421da177e4SLinus Torvalds if (neigh_dump_table(tbl, skb, cb) < 0) 16431da177e4SLinus Torvalds break; 16441da177e4SLinus Torvalds } 16451da177e4SLinus Torvalds read_unlock(&neigh_tbl_lock); 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds cb->args[0] = t; 16481da177e4SLinus Torvalds return skb->len; 16491da177e4SLinus Torvalds } 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie) 16521da177e4SLinus Torvalds { 16531da177e4SLinus Torvalds int chain; 16541da177e4SLinus Torvalds 16551da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 16561da177e4SLinus Torvalds for (chain = 0; chain <= tbl->hash_mask; chain++) { 16571da177e4SLinus Torvalds struct neighbour *n; 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds for (n = tbl->hash_buckets[chain]; n; n = n->next) 16601da177e4SLinus Torvalds cb(n, cookie); 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 16631da177e4SLinus Torvalds } 16641da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_for_each); 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds /* The tbl->lock must be held as a writer and BH disabled. */ 16671da177e4SLinus Torvalds void __neigh_for_each_release(struct neigh_table *tbl, 16681da177e4SLinus Torvalds int (*cb)(struct neighbour *)) 16691da177e4SLinus Torvalds { 16701da177e4SLinus Torvalds int chain; 16711da177e4SLinus Torvalds 16721da177e4SLinus Torvalds for (chain = 0; chain <= tbl->hash_mask; chain++) { 16731da177e4SLinus Torvalds struct neighbour *n, **np; 16741da177e4SLinus Torvalds 16751da177e4SLinus Torvalds np = &tbl->hash_buckets[chain]; 16761da177e4SLinus Torvalds while ((n = *np) != NULL) { 16771da177e4SLinus Torvalds int release; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds write_lock(&n->lock); 16801da177e4SLinus Torvalds release = cb(n); 16811da177e4SLinus Torvalds if (release) { 16821da177e4SLinus Torvalds *np = n->next; 16831da177e4SLinus Torvalds n->dead = 1; 16841da177e4SLinus Torvalds } else 16851da177e4SLinus Torvalds np = &n->next; 16861da177e4SLinus Torvalds write_unlock(&n->lock); 16871da177e4SLinus Torvalds if (release) 16881da177e4SLinus Torvalds neigh_release(n); 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds } 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_for_each_release); 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 16951da177e4SLinus Torvalds 16961da177e4SLinus Torvalds static struct neighbour *neigh_get_first(struct seq_file *seq) 16971da177e4SLinus Torvalds { 16981da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 16991da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 17001da177e4SLinus Torvalds struct neighbour *n = NULL; 17011da177e4SLinus Torvalds int bucket = state->bucket; 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds state->flags &= ~NEIGH_SEQ_IS_PNEIGH; 17041da177e4SLinus Torvalds for (bucket = 0; bucket <= tbl->hash_mask; bucket++) { 17051da177e4SLinus Torvalds n = tbl->hash_buckets[bucket]; 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds while (n) { 17081da177e4SLinus Torvalds if (state->neigh_sub_iter) { 17091da177e4SLinus Torvalds loff_t fakep = 0; 17101da177e4SLinus Torvalds void *v; 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds v = state->neigh_sub_iter(state, n, &fakep); 17131da177e4SLinus Torvalds if (!v) 17141da177e4SLinus Torvalds goto next; 17151da177e4SLinus Torvalds } 17161da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 17171da177e4SLinus Torvalds break; 17181da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 17191da177e4SLinus Torvalds break; 17201da177e4SLinus Torvalds next: 17211da177e4SLinus Torvalds n = n->next; 17221da177e4SLinus Torvalds } 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds if (n) 17251da177e4SLinus Torvalds break; 17261da177e4SLinus Torvalds } 17271da177e4SLinus Torvalds state->bucket = bucket; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds return n; 17301da177e4SLinus Torvalds } 17311da177e4SLinus Torvalds 17321da177e4SLinus Torvalds static struct neighbour *neigh_get_next(struct seq_file *seq, 17331da177e4SLinus Torvalds struct neighbour *n, 17341da177e4SLinus Torvalds loff_t *pos) 17351da177e4SLinus Torvalds { 17361da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 17371da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 17381da177e4SLinus Torvalds 17391da177e4SLinus Torvalds if (state->neigh_sub_iter) { 17401da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 17411da177e4SLinus Torvalds if (v) 17421da177e4SLinus Torvalds return n; 17431da177e4SLinus Torvalds } 17441da177e4SLinus Torvalds n = n->next; 17451da177e4SLinus Torvalds 17461da177e4SLinus Torvalds while (1) { 17471da177e4SLinus Torvalds while (n) { 17481da177e4SLinus Torvalds if (state->neigh_sub_iter) { 17491da177e4SLinus Torvalds void *v = state->neigh_sub_iter(state, n, pos); 17501da177e4SLinus Torvalds if (v) 17511da177e4SLinus Torvalds return n; 17521da177e4SLinus Torvalds goto next; 17531da177e4SLinus Torvalds } 17541da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_SKIP_NOARP)) 17551da177e4SLinus Torvalds break; 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds if (n->nud_state & ~NUD_NOARP) 17581da177e4SLinus Torvalds break; 17591da177e4SLinus Torvalds next: 17601da177e4SLinus Torvalds n = n->next; 17611da177e4SLinus Torvalds } 17621da177e4SLinus Torvalds 17631da177e4SLinus Torvalds if (n) 17641da177e4SLinus Torvalds break; 17651da177e4SLinus Torvalds 17661da177e4SLinus Torvalds if (++state->bucket > tbl->hash_mask) 17671da177e4SLinus Torvalds break; 17681da177e4SLinus Torvalds 17691da177e4SLinus Torvalds n = tbl->hash_buckets[state->bucket]; 17701da177e4SLinus Torvalds } 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds if (n && pos) 17731da177e4SLinus Torvalds --(*pos); 17741da177e4SLinus Torvalds return n; 17751da177e4SLinus Torvalds } 17761da177e4SLinus Torvalds 17771da177e4SLinus Torvalds static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos) 17781da177e4SLinus Torvalds { 17791da177e4SLinus Torvalds struct neighbour *n = neigh_get_first(seq); 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds if (n) { 17821da177e4SLinus Torvalds while (*pos) { 17831da177e4SLinus Torvalds n = neigh_get_next(seq, n, pos); 17841da177e4SLinus Torvalds if (!n) 17851da177e4SLinus Torvalds break; 17861da177e4SLinus Torvalds } 17871da177e4SLinus Torvalds } 17881da177e4SLinus Torvalds return *pos ? NULL : n; 17891da177e4SLinus Torvalds } 17901da177e4SLinus Torvalds 17911da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_first(struct seq_file *seq) 17921da177e4SLinus Torvalds { 17931da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 17941da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 17951da177e4SLinus Torvalds struct pneigh_entry *pn = NULL; 17961da177e4SLinus Torvalds int bucket = state->bucket; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds state->flags |= NEIGH_SEQ_IS_PNEIGH; 17991da177e4SLinus Torvalds for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) { 18001da177e4SLinus Torvalds pn = tbl->phash_buckets[bucket]; 18011da177e4SLinus Torvalds if (pn) 18021da177e4SLinus Torvalds break; 18031da177e4SLinus Torvalds } 18041da177e4SLinus Torvalds state->bucket = bucket; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds return pn; 18071da177e4SLinus Torvalds } 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_next(struct seq_file *seq, 18101da177e4SLinus Torvalds struct pneigh_entry *pn, 18111da177e4SLinus Torvalds loff_t *pos) 18121da177e4SLinus Torvalds { 18131da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 18141da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 18151da177e4SLinus Torvalds 18161da177e4SLinus Torvalds pn = pn->next; 18171da177e4SLinus Torvalds while (!pn) { 18181da177e4SLinus Torvalds if (++state->bucket > PNEIGH_HASHMASK) 18191da177e4SLinus Torvalds break; 18201da177e4SLinus Torvalds pn = tbl->phash_buckets[state->bucket]; 18211da177e4SLinus Torvalds if (pn) 18221da177e4SLinus Torvalds break; 18231da177e4SLinus Torvalds } 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds if (pn && pos) 18261da177e4SLinus Torvalds --(*pos); 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds return pn; 18291da177e4SLinus Torvalds } 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos) 18321da177e4SLinus Torvalds { 18331da177e4SLinus Torvalds struct pneigh_entry *pn = pneigh_get_first(seq); 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds if (pn) { 18361da177e4SLinus Torvalds while (*pos) { 18371da177e4SLinus Torvalds pn = pneigh_get_next(seq, pn, pos); 18381da177e4SLinus Torvalds if (!pn) 18391da177e4SLinus Torvalds break; 18401da177e4SLinus Torvalds } 18411da177e4SLinus Torvalds } 18421da177e4SLinus Torvalds return *pos ? NULL : pn; 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos) 18461da177e4SLinus Torvalds { 18471da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 18481da177e4SLinus Torvalds void *rc; 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds rc = neigh_get_idx(seq, pos); 18511da177e4SLinus Torvalds if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 18521da177e4SLinus Torvalds rc = pneigh_get_idx(seq, pos); 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds return rc; 18551da177e4SLinus Torvalds } 18561da177e4SLinus Torvalds 18571da177e4SLinus Torvalds void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags) 18581da177e4SLinus Torvalds { 18591da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 18601da177e4SLinus Torvalds loff_t pos_minus_one; 18611da177e4SLinus Torvalds 18621da177e4SLinus Torvalds state->tbl = tbl; 18631da177e4SLinus Torvalds state->bucket = 0; 18641da177e4SLinus Torvalds state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH); 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds read_lock_bh(&tbl->lock); 18671da177e4SLinus Torvalds 18681da177e4SLinus Torvalds pos_minus_one = *pos - 1; 18691da177e4SLinus Torvalds return *pos ? neigh_get_idx_any(seq, &pos_minus_one) : SEQ_START_TOKEN; 18701da177e4SLinus Torvalds } 18711da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_start); 18721da177e4SLinus Torvalds 18731da177e4SLinus Torvalds void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos) 18741da177e4SLinus Torvalds { 18751da177e4SLinus Torvalds struct neigh_seq_state *state; 18761da177e4SLinus Torvalds void *rc; 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 18791da177e4SLinus Torvalds rc = neigh_get_idx(seq, pos); 18801da177e4SLinus Torvalds goto out; 18811da177e4SLinus Torvalds } 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds state = seq->private; 18841da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) { 18851da177e4SLinus Torvalds rc = neigh_get_next(seq, v, NULL); 18861da177e4SLinus Torvalds if (rc) 18871da177e4SLinus Torvalds goto out; 18881da177e4SLinus Torvalds if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY)) 18891da177e4SLinus Torvalds rc = pneigh_get_first(seq); 18901da177e4SLinus Torvalds } else { 18911da177e4SLinus Torvalds BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY); 18921da177e4SLinus Torvalds rc = pneigh_get_next(seq, v, NULL); 18931da177e4SLinus Torvalds } 18941da177e4SLinus Torvalds out: 18951da177e4SLinus Torvalds ++(*pos); 18961da177e4SLinus Torvalds return rc; 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_next); 18991da177e4SLinus Torvalds 19001da177e4SLinus Torvalds void neigh_seq_stop(struct seq_file *seq, void *v) 19011da177e4SLinus Torvalds { 19021da177e4SLinus Torvalds struct neigh_seq_state *state = seq->private; 19031da177e4SLinus Torvalds struct neigh_table *tbl = state->tbl; 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds read_unlock_bh(&tbl->lock); 19061da177e4SLinus Torvalds } 19071da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_seq_stop); 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds /* statistics via seq_file */ 19101da177e4SLinus Torvalds 19111da177e4SLinus Torvalds static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos) 19121da177e4SLinus Torvalds { 19131da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 19141da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 19151da177e4SLinus Torvalds int cpu; 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds if (*pos == 0) 19181da177e4SLinus Torvalds return SEQ_START_TOKEN; 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds for (cpu = *pos-1; cpu < NR_CPUS; ++cpu) { 19211da177e4SLinus Torvalds if (!cpu_possible(cpu)) 19221da177e4SLinus Torvalds continue; 19231da177e4SLinus Torvalds *pos = cpu+1; 19241da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 19251da177e4SLinus Torvalds } 19261da177e4SLinus Torvalds return NULL; 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos) 19301da177e4SLinus Torvalds { 19311da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 19321da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 19331da177e4SLinus Torvalds int cpu; 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds for (cpu = *pos; cpu < NR_CPUS; ++cpu) { 19361da177e4SLinus Torvalds if (!cpu_possible(cpu)) 19371da177e4SLinus Torvalds continue; 19381da177e4SLinus Torvalds *pos = cpu+1; 19391da177e4SLinus Torvalds return per_cpu_ptr(tbl->stats, cpu); 19401da177e4SLinus Torvalds } 19411da177e4SLinus Torvalds return NULL; 19421da177e4SLinus Torvalds } 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds static void neigh_stat_seq_stop(struct seq_file *seq, void *v) 19451da177e4SLinus Torvalds { 19461da177e4SLinus Torvalds 19471da177e4SLinus Torvalds } 19481da177e4SLinus Torvalds 19491da177e4SLinus Torvalds static int neigh_stat_seq_show(struct seq_file *seq, void *v) 19501da177e4SLinus Torvalds { 19511da177e4SLinus Torvalds struct proc_dir_entry *pde = seq->private; 19521da177e4SLinus Torvalds struct neigh_table *tbl = pde->data; 19531da177e4SLinus Torvalds struct neigh_statistics *st = v; 19541da177e4SLinus Torvalds 19551da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) { 19561da177e4SLinus Torvalds seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs forced_gc_goal_miss\n"); 19571da177e4SLinus Torvalds return 0; 19581da177e4SLinus Torvalds } 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx " 19611da177e4SLinus Torvalds "%08lx %08lx %08lx %08lx\n", 19621da177e4SLinus Torvalds atomic_read(&tbl->entries), 19631da177e4SLinus Torvalds 19641da177e4SLinus Torvalds st->allocs, 19651da177e4SLinus Torvalds st->destroys, 19661da177e4SLinus Torvalds st->hash_grows, 19671da177e4SLinus Torvalds 19681da177e4SLinus Torvalds st->lookups, 19691da177e4SLinus Torvalds st->hits, 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds st->res_failed, 19721da177e4SLinus Torvalds 19731da177e4SLinus Torvalds st->rcv_probes_mcast, 19741da177e4SLinus Torvalds st->rcv_probes_ucast, 19751da177e4SLinus Torvalds 19761da177e4SLinus Torvalds st->periodic_gc_runs, 19771da177e4SLinus Torvalds st->forced_gc_runs 19781da177e4SLinus Torvalds ); 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds return 0; 19811da177e4SLinus Torvalds } 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds static struct seq_operations neigh_stat_seq_ops = { 19841da177e4SLinus Torvalds .start = neigh_stat_seq_start, 19851da177e4SLinus Torvalds .next = neigh_stat_seq_next, 19861da177e4SLinus Torvalds .stop = neigh_stat_seq_stop, 19871da177e4SLinus Torvalds .show = neigh_stat_seq_show, 19881da177e4SLinus Torvalds }; 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds static int neigh_stat_seq_open(struct inode *inode, struct file *file) 19911da177e4SLinus Torvalds { 19921da177e4SLinus Torvalds int ret = seq_open(file, &neigh_stat_seq_ops); 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds if (!ret) { 19951da177e4SLinus Torvalds struct seq_file *sf = file->private_data; 19961da177e4SLinus Torvalds sf->private = PDE(inode); 19971da177e4SLinus Torvalds } 19981da177e4SLinus Torvalds return ret; 19991da177e4SLinus Torvalds }; 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds static struct file_operations neigh_stat_seq_fops = { 20021da177e4SLinus Torvalds .owner = THIS_MODULE, 20031da177e4SLinus Torvalds .open = neigh_stat_seq_open, 20041da177e4SLinus Torvalds .read = seq_read, 20051da177e4SLinus Torvalds .llseek = seq_lseek, 20061da177e4SLinus Torvalds .release = seq_release, 20071da177e4SLinus Torvalds }; 20081da177e4SLinus Torvalds 20091da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds #ifdef CONFIG_ARPD 20121da177e4SLinus Torvalds void neigh_app_ns(struct neighbour *n) 20131da177e4SLinus Torvalds { 20141da177e4SLinus Torvalds struct nlmsghdr *nlh; 20151da177e4SLinus Torvalds int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256); 20161da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC); 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds if (!skb) 20191da177e4SLinus Torvalds return; 20201da177e4SLinus Torvalds 20211da177e4SLinus Torvalds if (neigh_fill_info(skb, n, 0, 0, RTM_GETNEIGH) < 0) { 20221da177e4SLinus Torvalds kfree_skb(skb); 20231da177e4SLinus Torvalds return; 20241da177e4SLinus Torvalds } 20251da177e4SLinus Torvalds nlh = (struct nlmsghdr *)skb->data; 20261da177e4SLinus Torvalds nlh->nlmsg_flags = NLM_F_REQUEST; 20271da177e4SLinus Torvalds NETLINK_CB(skb).dst_groups = RTMGRP_NEIGH; 20281da177e4SLinus Torvalds netlink_broadcast(rtnl, skb, 0, RTMGRP_NEIGH, GFP_ATOMIC); 20291da177e4SLinus Torvalds } 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds static void neigh_app_notify(struct neighbour *n) 20321da177e4SLinus Torvalds { 20331da177e4SLinus Torvalds struct nlmsghdr *nlh; 20341da177e4SLinus Torvalds int size = NLMSG_SPACE(sizeof(struct ndmsg) + 256); 20351da177e4SLinus Torvalds struct sk_buff *skb = alloc_skb(size, GFP_ATOMIC); 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds if (!skb) 20381da177e4SLinus Torvalds return; 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds if (neigh_fill_info(skb, n, 0, 0, RTM_NEWNEIGH) < 0) { 20411da177e4SLinus Torvalds kfree_skb(skb); 20421da177e4SLinus Torvalds return; 20431da177e4SLinus Torvalds } 20441da177e4SLinus Torvalds nlh = (struct nlmsghdr *)skb->data; 20451da177e4SLinus Torvalds NETLINK_CB(skb).dst_groups = RTMGRP_NEIGH; 20461da177e4SLinus Torvalds netlink_broadcast(rtnl, skb, 0, RTMGRP_NEIGH, GFP_ATOMIC); 20471da177e4SLinus Torvalds } 20481da177e4SLinus Torvalds 20491da177e4SLinus Torvalds #endif /* CONFIG_ARPD */ 20501da177e4SLinus Torvalds 20511da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds static struct neigh_sysctl_table { 20541da177e4SLinus Torvalds struct ctl_table_header *sysctl_header; 20551da177e4SLinus Torvalds ctl_table neigh_vars[__NET_NEIGH_MAX]; 20561da177e4SLinus Torvalds ctl_table neigh_dev[2]; 20571da177e4SLinus Torvalds ctl_table neigh_neigh_dir[2]; 20581da177e4SLinus Torvalds ctl_table neigh_proto_dir[2]; 20591da177e4SLinus Torvalds ctl_table neigh_root_dir[2]; 20601da177e4SLinus Torvalds } neigh_sysctl_template = { 20611da177e4SLinus Torvalds .neigh_vars = { 20621da177e4SLinus Torvalds { 20631da177e4SLinus Torvalds .ctl_name = NET_NEIGH_MCAST_SOLICIT, 20641da177e4SLinus Torvalds .procname = "mcast_solicit", 20651da177e4SLinus Torvalds .maxlen = sizeof(int), 20661da177e4SLinus Torvalds .mode = 0644, 20671da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 20681da177e4SLinus Torvalds }, 20691da177e4SLinus Torvalds { 20701da177e4SLinus Torvalds .ctl_name = NET_NEIGH_UCAST_SOLICIT, 20711da177e4SLinus Torvalds .procname = "ucast_solicit", 20721da177e4SLinus Torvalds .maxlen = sizeof(int), 20731da177e4SLinus Torvalds .mode = 0644, 20741da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 20751da177e4SLinus Torvalds }, 20761da177e4SLinus Torvalds { 20771da177e4SLinus Torvalds .ctl_name = NET_NEIGH_APP_SOLICIT, 20781da177e4SLinus Torvalds .procname = "app_solicit", 20791da177e4SLinus Torvalds .maxlen = sizeof(int), 20801da177e4SLinus Torvalds .mode = 0644, 20811da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 20821da177e4SLinus Torvalds }, 20831da177e4SLinus Torvalds { 20841da177e4SLinus Torvalds .ctl_name = NET_NEIGH_RETRANS_TIME, 20851da177e4SLinus Torvalds .procname = "retrans_time", 20861da177e4SLinus Torvalds .maxlen = sizeof(int), 20871da177e4SLinus Torvalds .mode = 0644, 20881da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 20891da177e4SLinus Torvalds }, 20901da177e4SLinus Torvalds { 20911da177e4SLinus Torvalds .ctl_name = NET_NEIGH_REACHABLE_TIME, 20921da177e4SLinus Torvalds .procname = "base_reachable_time", 20931da177e4SLinus Torvalds .maxlen = sizeof(int), 20941da177e4SLinus Torvalds .mode = 0644, 20951da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 20961da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 20971da177e4SLinus Torvalds }, 20981da177e4SLinus Torvalds { 20991da177e4SLinus Torvalds .ctl_name = NET_NEIGH_DELAY_PROBE_TIME, 21001da177e4SLinus Torvalds .procname = "delay_first_probe_time", 21011da177e4SLinus Torvalds .maxlen = sizeof(int), 21021da177e4SLinus Torvalds .mode = 0644, 21031da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 21041da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 21051da177e4SLinus Torvalds }, 21061da177e4SLinus Torvalds { 21071da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_STALE_TIME, 21081da177e4SLinus Torvalds .procname = "gc_stale_time", 21091da177e4SLinus Torvalds .maxlen = sizeof(int), 21101da177e4SLinus Torvalds .mode = 0644, 21111da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 21121da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 21131da177e4SLinus Torvalds }, 21141da177e4SLinus Torvalds { 21151da177e4SLinus Torvalds .ctl_name = NET_NEIGH_UNRES_QLEN, 21161da177e4SLinus Torvalds .procname = "unres_qlen", 21171da177e4SLinus Torvalds .maxlen = sizeof(int), 21181da177e4SLinus Torvalds .mode = 0644, 21191da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 21201da177e4SLinus Torvalds }, 21211da177e4SLinus Torvalds { 21221da177e4SLinus Torvalds .ctl_name = NET_NEIGH_PROXY_QLEN, 21231da177e4SLinus Torvalds .procname = "proxy_qlen", 21241da177e4SLinus Torvalds .maxlen = sizeof(int), 21251da177e4SLinus Torvalds .mode = 0644, 21261da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 21271da177e4SLinus Torvalds }, 21281da177e4SLinus Torvalds { 21291da177e4SLinus Torvalds .ctl_name = NET_NEIGH_ANYCAST_DELAY, 21301da177e4SLinus Torvalds .procname = "anycast_delay", 21311da177e4SLinus Torvalds .maxlen = sizeof(int), 21321da177e4SLinus Torvalds .mode = 0644, 21331da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 21341da177e4SLinus Torvalds }, 21351da177e4SLinus Torvalds { 21361da177e4SLinus Torvalds .ctl_name = NET_NEIGH_PROXY_DELAY, 21371da177e4SLinus Torvalds .procname = "proxy_delay", 21381da177e4SLinus Torvalds .maxlen = sizeof(int), 21391da177e4SLinus Torvalds .mode = 0644, 21401da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 21411da177e4SLinus Torvalds }, 21421da177e4SLinus Torvalds { 21431da177e4SLinus Torvalds .ctl_name = NET_NEIGH_LOCKTIME, 21441da177e4SLinus Torvalds .procname = "locktime", 21451da177e4SLinus Torvalds .maxlen = sizeof(int), 21461da177e4SLinus Torvalds .mode = 0644, 21471da177e4SLinus Torvalds .proc_handler = &proc_dointvec_userhz_jiffies, 21481da177e4SLinus Torvalds }, 21491da177e4SLinus Torvalds { 21501da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_INTERVAL, 21511da177e4SLinus Torvalds .procname = "gc_interval", 21521da177e4SLinus Torvalds .maxlen = sizeof(int), 21531da177e4SLinus Torvalds .mode = 0644, 21541da177e4SLinus Torvalds .proc_handler = &proc_dointvec_jiffies, 21551da177e4SLinus Torvalds .strategy = &sysctl_jiffies, 21561da177e4SLinus Torvalds }, 21571da177e4SLinus Torvalds { 21581da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH1, 21591da177e4SLinus Torvalds .procname = "gc_thresh1", 21601da177e4SLinus Torvalds .maxlen = sizeof(int), 21611da177e4SLinus Torvalds .mode = 0644, 21621da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 21631da177e4SLinus Torvalds }, 21641da177e4SLinus Torvalds { 21651da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH2, 21661da177e4SLinus Torvalds .procname = "gc_thresh2", 21671da177e4SLinus Torvalds .maxlen = sizeof(int), 21681da177e4SLinus Torvalds .mode = 0644, 21691da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 21701da177e4SLinus Torvalds }, 21711da177e4SLinus Torvalds { 21721da177e4SLinus Torvalds .ctl_name = NET_NEIGH_GC_THRESH3, 21731da177e4SLinus Torvalds .procname = "gc_thresh3", 21741da177e4SLinus Torvalds .maxlen = sizeof(int), 21751da177e4SLinus Torvalds .mode = 0644, 21761da177e4SLinus Torvalds .proc_handler = &proc_dointvec, 21771da177e4SLinus Torvalds }, 21781da177e4SLinus Torvalds { 21791da177e4SLinus Torvalds .ctl_name = NET_NEIGH_RETRANS_TIME_MS, 21801da177e4SLinus Torvalds .procname = "retrans_time_ms", 21811da177e4SLinus Torvalds .maxlen = sizeof(int), 21821da177e4SLinus Torvalds .mode = 0644, 21831da177e4SLinus Torvalds .proc_handler = &proc_dointvec_ms_jiffies, 21841da177e4SLinus Torvalds .strategy = &sysctl_ms_jiffies, 21851da177e4SLinus Torvalds }, 21861da177e4SLinus Torvalds { 21871da177e4SLinus Torvalds .ctl_name = NET_NEIGH_REACHABLE_TIME_MS, 21881da177e4SLinus Torvalds .procname = "base_reachable_time_ms", 21891da177e4SLinus Torvalds .maxlen = sizeof(int), 21901da177e4SLinus Torvalds .mode = 0644, 21911da177e4SLinus Torvalds .proc_handler = &proc_dointvec_ms_jiffies, 21921da177e4SLinus Torvalds .strategy = &sysctl_ms_jiffies, 21931da177e4SLinus Torvalds }, 21941da177e4SLinus Torvalds }, 21951da177e4SLinus Torvalds .neigh_dev = { 21961da177e4SLinus Torvalds { 21971da177e4SLinus Torvalds .ctl_name = NET_PROTO_CONF_DEFAULT, 21981da177e4SLinus Torvalds .procname = "default", 21991da177e4SLinus Torvalds .mode = 0555, 22001da177e4SLinus Torvalds }, 22011da177e4SLinus Torvalds }, 22021da177e4SLinus Torvalds .neigh_neigh_dir = { 22031da177e4SLinus Torvalds { 22041da177e4SLinus Torvalds .procname = "neigh", 22051da177e4SLinus Torvalds .mode = 0555, 22061da177e4SLinus Torvalds }, 22071da177e4SLinus Torvalds }, 22081da177e4SLinus Torvalds .neigh_proto_dir = { 22091da177e4SLinus Torvalds { 22101da177e4SLinus Torvalds .mode = 0555, 22111da177e4SLinus Torvalds }, 22121da177e4SLinus Torvalds }, 22131da177e4SLinus Torvalds .neigh_root_dir = { 22141da177e4SLinus Torvalds { 22151da177e4SLinus Torvalds .ctl_name = CTL_NET, 22161da177e4SLinus Torvalds .procname = "net", 22171da177e4SLinus Torvalds .mode = 0555, 22181da177e4SLinus Torvalds }, 22191da177e4SLinus Torvalds }, 22201da177e4SLinus Torvalds }; 22211da177e4SLinus Torvalds 22221da177e4SLinus Torvalds int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p, 22231da177e4SLinus Torvalds int p_id, int pdev_id, char *p_name, 22241da177e4SLinus Torvalds proc_handler *handler, ctl_handler *strategy) 22251da177e4SLinus Torvalds { 22261da177e4SLinus Torvalds struct neigh_sysctl_table *t = kmalloc(sizeof(*t), GFP_KERNEL); 22271da177e4SLinus Torvalds const char *dev_name_source = NULL; 22281da177e4SLinus Torvalds char *dev_name = NULL; 22291da177e4SLinus Torvalds int err = 0; 22301da177e4SLinus Torvalds 22311da177e4SLinus Torvalds if (!t) 22321da177e4SLinus Torvalds return -ENOBUFS; 22331da177e4SLinus Torvalds memcpy(t, &neigh_sysctl_template, sizeof(*t)); 22341da177e4SLinus Torvalds t->neigh_vars[0].data = &p->mcast_probes; 22351da177e4SLinus Torvalds t->neigh_vars[1].data = &p->ucast_probes; 22361da177e4SLinus Torvalds t->neigh_vars[2].data = &p->app_probes; 22371da177e4SLinus Torvalds t->neigh_vars[3].data = &p->retrans_time; 22381da177e4SLinus Torvalds t->neigh_vars[4].data = &p->base_reachable_time; 22391da177e4SLinus Torvalds t->neigh_vars[5].data = &p->delay_probe_time; 22401da177e4SLinus Torvalds t->neigh_vars[6].data = &p->gc_staletime; 22411da177e4SLinus Torvalds t->neigh_vars[7].data = &p->queue_len; 22421da177e4SLinus Torvalds t->neigh_vars[8].data = &p->proxy_qlen; 22431da177e4SLinus Torvalds t->neigh_vars[9].data = &p->anycast_delay; 22441da177e4SLinus Torvalds t->neigh_vars[10].data = &p->proxy_delay; 22451da177e4SLinus Torvalds t->neigh_vars[11].data = &p->locktime; 22461da177e4SLinus Torvalds 22471da177e4SLinus Torvalds if (dev) { 22481da177e4SLinus Torvalds dev_name_source = dev->name; 22491da177e4SLinus Torvalds t->neigh_dev[0].ctl_name = dev->ifindex; 22501da177e4SLinus Torvalds t->neigh_vars[12].procname = NULL; 22511da177e4SLinus Torvalds t->neigh_vars[13].procname = NULL; 22521da177e4SLinus Torvalds t->neigh_vars[14].procname = NULL; 22531da177e4SLinus Torvalds t->neigh_vars[15].procname = NULL; 22541da177e4SLinus Torvalds } else { 22551da177e4SLinus Torvalds dev_name_source = t->neigh_dev[0].procname; 22561da177e4SLinus Torvalds t->neigh_vars[12].data = (int *)(p + 1); 22571da177e4SLinus Torvalds t->neigh_vars[13].data = (int *)(p + 1) + 1; 22581da177e4SLinus Torvalds t->neigh_vars[14].data = (int *)(p + 1) + 2; 22591da177e4SLinus Torvalds t->neigh_vars[15].data = (int *)(p + 1) + 3; 22601da177e4SLinus Torvalds } 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds t->neigh_vars[16].data = &p->retrans_time; 22631da177e4SLinus Torvalds t->neigh_vars[17].data = &p->base_reachable_time; 22641da177e4SLinus Torvalds 22651da177e4SLinus Torvalds if (handler || strategy) { 22661da177e4SLinus Torvalds /* RetransTime */ 22671da177e4SLinus Torvalds t->neigh_vars[3].proc_handler = handler; 22681da177e4SLinus Torvalds t->neigh_vars[3].strategy = strategy; 22691da177e4SLinus Torvalds t->neigh_vars[3].extra1 = dev; 22701da177e4SLinus Torvalds /* ReachableTime */ 22711da177e4SLinus Torvalds t->neigh_vars[4].proc_handler = handler; 22721da177e4SLinus Torvalds t->neigh_vars[4].strategy = strategy; 22731da177e4SLinus Torvalds t->neigh_vars[4].extra1 = dev; 22741da177e4SLinus Torvalds /* RetransTime (in milliseconds)*/ 22751da177e4SLinus Torvalds t->neigh_vars[16].proc_handler = handler; 22761da177e4SLinus Torvalds t->neigh_vars[16].strategy = strategy; 22771da177e4SLinus Torvalds t->neigh_vars[16].extra1 = dev; 22781da177e4SLinus Torvalds /* ReachableTime (in milliseconds) */ 22791da177e4SLinus Torvalds t->neigh_vars[17].proc_handler = handler; 22801da177e4SLinus Torvalds t->neigh_vars[17].strategy = strategy; 22811da177e4SLinus Torvalds t->neigh_vars[17].extra1 = dev; 22821da177e4SLinus Torvalds } 22831da177e4SLinus Torvalds 22841da177e4SLinus Torvalds dev_name = net_sysctl_strdup(dev_name_source); 22851da177e4SLinus Torvalds if (!dev_name) { 22861da177e4SLinus Torvalds err = -ENOBUFS; 22871da177e4SLinus Torvalds goto free; 22881da177e4SLinus Torvalds } 22891da177e4SLinus Torvalds 22901da177e4SLinus Torvalds t->neigh_dev[0].procname = dev_name; 22911da177e4SLinus Torvalds 22921da177e4SLinus Torvalds t->neigh_neigh_dir[0].ctl_name = pdev_id; 22931da177e4SLinus Torvalds 22941da177e4SLinus Torvalds t->neigh_proto_dir[0].procname = p_name; 22951da177e4SLinus Torvalds t->neigh_proto_dir[0].ctl_name = p_id; 22961da177e4SLinus Torvalds 22971da177e4SLinus Torvalds t->neigh_dev[0].child = t->neigh_vars; 22981da177e4SLinus Torvalds t->neigh_neigh_dir[0].child = t->neigh_dev; 22991da177e4SLinus Torvalds t->neigh_proto_dir[0].child = t->neigh_neigh_dir; 23001da177e4SLinus Torvalds t->neigh_root_dir[0].child = t->neigh_proto_dir; 23011da177e4SLinus Torvalds 23021da177e4SLinus Torvalds t->sysctl_header = register_sysctl_table(t->neigh_root_dir, 0); 23031da177e4SLinus Torvalds if (!t->sysctl_header) { 23041da177e4SLinus Torvalds err = -ENOBUFS; 23051da177e4SLinus Torvalds goto free_procname; 23061da177e4SLinus Torvalds } 23071da177e4SLinus Torvalds p->sysctl_table = t; 23081da177e4SLinus Torvalds return 0; 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds /* error path */ 23111da177e4SLinus Torvalds free_procname: 23121da177e4SLinus Torvalds kfree(dev_name); 23131da177e4SLinus Torvalds free: 23141da177e4SLinus Torvalds kfree(t); 23151da177e4SLinus Torvalds 23161da177e4SLinus Torvalds return err; 23171da177e4SLinus Torvalds } 23181da177e4SLinus Torvalds 23191da177e4SLinus Torvalds void neigh_sysctl_unregister(struct neigh_parms *p) 23201da177e4SLinus Torvalds { 23211da177e4SLinus Torvalds if (p->sysctl_table) { 23221da177e4SLinus Torvalds struct neigh_sysctl_table *t = p->sysctl_table; 23231da177e4SLinus Torvalds p->sysctl_table = NULL; 23241da177e4SLinus Torvalds unregister_sysctl_table(t->sysctl_header); 23251da177e4SLinus Torvalds kfree(t->neigh_dev[0].procname); 23261da177e4SLinus Torvalds kfree(t); 23271da177e4SLinus Torvalds } 23281da177e4SLinus Torvalds } 23291da177e4SLinus Torvalds 23301da177e4SLinus Torvalds #endif /* CONFIG_SYSCTL */ 23311da177e4SLinus Torvalds 23321da177e4SLinus Torvalds EXPORT_SYMBOL(__neigh_event_send); 23331da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_add); 23341da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_changeaddr); 23351da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_compat_output); 23361da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_connected_output); 23371da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_create); 23381da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_delete); 23391da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_destroy); 23401da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_dump_info); 23411da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_event_ns); 23421da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_ifdown); 23431da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_lookup); 23441da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_lookup_nodev); 23451da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_parms_alloc); 23461da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_parms_release); 23471da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_rand_reach_time); 23481da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_resolve_output); 23491da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_table_clear); 23501da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_table_init); 23511da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_update); 23521da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_update_hhs); 23531da177e4SLinus Torvalds EXPORT_SYMBOL(pneigh_enqueue); 23541da177e4SLinus Torvalds EXPORT_SYMBOL(pneigh_lookup); 23551da177e4SLinus Torvalds 23561da177e4SLinus Torvalds #ifdef CONFIG_ARPD 23571da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_app_ns); 23581da177e4SLinus Torvalds #endif 23591da177e4SLinus Torvalds #ifdef CONFIG_SYSCTL 23601da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_sysctl_register); 23611da177e4SLinus Torvalds EXPORT_SYMBOL(neigh_sysctl_unregister); 23621da177e4SLinus Torvalds #endif 2363