1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250 |
- /*
- * Generic address resolution entity
- *
- * Authors:
- * Pedro Roque <roque@di.fc.ul.pt>
- * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- * Fixes:
- * Vitaly E. Lavrov releasing NULL neighbor in neigh_add.
- * Harald Welte Add neighbour cache statistics like rtstat
- */
- #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
- #include <linux/slab.h>
- #include <linux/types.h>
- #include <linux/kernel.h>
- #include <linux/module.h>
- #include <linux/socket.h>
- #include <linux/netdevice.h>
- #include <linux/proc_fs.h>
- #ifdef CONFIG_SYSCTL
- #include <linux/sysctl.h>
- #endif
- #include <linux/times.h>
- #include <net/net_namespace.h>
- #include <net/neighbour.h>
- #include <net/dst.h>
- #include <net/sock.h>
- #include <net/netevent.h>
- #include <net/netlink.h>
- #include <linux/rtnetlink.h>
- #include <linux/random.h>
- #include <linux/string.h>
- #include <linux/log2.h>
- #include <linux/inetdevice.h>
- #include <net/addrconf.h>
- #define DEBUG
- #define NEIGH_DEBUG 1
- #define neigh_dbg(level, fmt, ...) \
- do { \
- if (level <= NEIGH_DEBUG) \
- pr_debug(fmt, ##__VA_ARGS__); \
- } while (0)
- #define PNEIGH_HASHMASK 0xF
- static void neigh_timer_handler(unsigned long arg);
- static void __neigh_notify(struct neighbour *n, int type, int flags);
- static void neigh_update_notify(struct neighbour *neigh);
- static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
- struct net_device *dev);
- #ifdef CONFIG_PROC_FS
- static const struct file_operations neigh_stat_seq_fops;
- #endif
- /*
- Neighbour hash table buckets are protected with rwlock tbl->lock.
- - All the scans/updates to hash buckets MUST be made under this lock.
- - NOTHING clever should be made under this lock: no callbacks
- to protocol backends, no attempts to send something to network.
- It will result in deadlocks, if backend/driver wants to use neighbour
- cache.
- - If the entry requires some non-trivial actions, increase
- its reference count and release table lock.
- Neighbour entries are protected:
- - with reference count.
- - with rwlock neigh->lock
- Reference count prevents destruction.
- neigh->lock mainly serializes ll address data and its validity state.
- However, the same lock is used to protect another entry fields:
- - timer
- - resolution queue
- Again, nothing clever shall be made under neigh->lock,
- the most complicated procedure, which we allow is dev->hard_header.
- It is supposed, that dev->hard_header is simplistic and does
- not make callbacks to neighbour tables.
- */
- static int neigh_blackhole(struct neighbour *neigh, struct sk_buff *skb)
- {
- kfree_skb(skb);
- return -ENETDOWN;
- }
- static void neigh_cleanup_and_release(struct neighbour *neigh)
- {
- if (neigh->parms->neigh_cleanup)
- neigh->parms->neigh_cleanup(neigh);
- __neigh_notify(neigh, RTM_DELNEIGH, 0);
- neigh_release(neigh);
- }
- /*
- * It is random distribution in the interval (1/2)*base...(3/2)*base.
- * It corresponds to default IPv6 settings and is not overridable,
- * because it is really reasonable choice.
- */
- unsigned long neigh_rand_reach_time(unsigned long base)
- {
- return base ? (prandom_u32() % base) + (base >> 1) : 0;
- }
- EXPORT_SYMBOL(neigh_rand_reach_time);
- static int neigh_forced_gc(struct neigh_table *tbl)
- {
- int shrunk = 0;
- int i;
- struct neigh_hash_table *nht;
- NEIGH_CACHE_STAT_INC(tbl, forced_gc_runs);
- write_lock_bh(&tbl->lock);
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- for (i = 0; i < (1 << nht->hash_shift); i++) {
- struct neighbour *n;
- struct neighbour __rcu **np;
- np = &nht->hash_buckets[i];
- while ((n = rcu_dereference_protected(*np,
- lockdep_is_held(&tbl->lock))) != NULL) {
- /* Neighbour record may be discarded if:
- * - nobody refers to it.
- * - it is not permanent
- */
- write_lock(&n->lock);
- if (atomic_read(&n->refcnt) == 1 &&
- !(n->nud_state & NUD_PERMANENT)) {
- rcu_assign_pointer(*np,
- rcu_dereference_protected(n->next,
- lockdep_is_held(&tbl->lock)));
- n->dead = 1;
- shrunk = 1;
- write_unlock(&n->lock);
- neigh_cleanup_and_release(n);
- continue;
- }
- write_unlock(&n->lock);
- np = &n->next;
- }
- }
- tbl->last_flush = jiffies;
- write_unlock_bh(&tbl->lock);
- return shrunk;
- }
- static void neigh_add_timer(struct neighbour *n, unsigned long when)
- {
- neigh_hold(n);
- if (unlikely(mod_timer(&n->timer, when))) {
- printk("NEIGH: BUG, double timer add, state is %x\n",
- n->nud_state);
- dump_stack();
- }
- }
- static int neigh_del_timer(struct neighbour *n)
- {
- if ((n->nud_state & NUD_IN_TIMER) &&
- del_timer(&n->timer)) {
- neigh_release(n);
- return 1;
- }
- return 0;
- }
- static void pneigh_queue_purge(struct sk_buff_head *list)
- {
- struct sk_buff *skb;
- while ((skb = skb_dequeue(list)) != NULL) {
- dev_put(skb->dev);
- kfree_skb(skb);
- }
- }
- static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev)
- {
- int i;
- struct neigh_hash_table *nht;
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- for (i = 0; i < (1 << nht->hash_shift); i++) {
- struct neighbour *n;
- struct neighbour __rcu **np = &nht->hash_buckets[i];
- while ((n = rcu_dereference_protected(*np,
- lockdep_is_held(&tbl->lock))) != NULL) {
- if (dev && n->dev != dev) {
- np = &n->next;
- continue;
- }
- rcu_assign_pointer(*np,
- rcu_dereference_protected(n->next,
- lockdep_is_held(&tbl->lock)));
- write_lock(&n->lock);
- neigh_del_timer(n);
- n->dead = 1;
- if (atomic_read(&n->refcnt) != 1) {
- /* The most unpleasant situation.
- We must destroy neighbour entry,
- but someone still uses it.
- The destroy will be delayed until
- the last user releases us, but
- we must kill timers etc. and move
- it to safe state.
- */
- __skb_queue_purge(&n->arp_queue);
- n->arp_queue_len_bytes = 0;
- n->output = neigh_blackhole;
- if (n->nud_state & NUD_VALID)
- n->nud_state = NUD_NOARP;
- else
- n->nud_state = NUD_NONE;
- neigh_dbg(2, "neigh %p is stray\n", n);
- }
- write_unlock(&n->lock);
- neigh_cleanup_and_release(n);
- }
- }
- }
- void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
- {
- write_lock_bh(&tbl->lock);
- neigh_flush_dev(tbl, dev);
- write_unlock_bh(&tbl->lock);
- }
- EXPORT_SYMBOL(neigh_changeaddr);
- int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev)
- {
- write_lock_bh(&tbl->lock);
- neigh_flush_dev(tbl, dev);
- pneigh_ifdown_and_unlock(tbl, dev);
- del_timer_sync(&tbl->proxy_timer);
- pneigh_queue_purge(&tbl->proxy_queue);
- return 0;
- }
- EXPORT_SYMBOL(neigh_ifdown);
- static struct neighbour *neigh_alloc(struct neigh_table *tbl, struct net_device *dev)
- {
- struct neighbour *n = NULL;
- unsigned long now = jiffies;
- int entries;
- entries = atomic_inc_return(&tbl->entries) - 1;
- if (entries >= tbl->gc_thresh3 ||
- (entries >= tbl->gc_thresh2 &&
- time_after(now, tbl->last_flush + 5 * HZ))) {
- if (!neigh_forced_gc(tbl) &&
- entries >= tbl->gc_thresh3) {
- net_info_ratelimited("%s: neighbor table overflow!\n",
- tbl->id);
- NEIGH_CACHE_STAT_INC(tbl, table_fulls);
- goto out_entries;
- }
- }
- n = kzalloc(tbl->entry_size + dev->neigh_priv_len, GFP_ATOMIC);
- if (!n)
- goto out_entries;
- __skb_queue_head_init(&n->arp_queue);
- rwlock_init(&n->lock);
- seqlock_init(&n->ha_lock);
- n->updated = n->used = now;
- n->nud_state = NUD_NONE;
- n->output = neigh_blackhole;
- seqlock_init(&n->hh.hh_lock);
- n->parms = neigh_parms_clone(&tbl->parms);
- setup_timer(&n->timer, neigh_timer_handler, (unsigned long)n);
- NEIGH_CACHE_STAT_INC(tbl, allocs);
- n->tbl = tbl;
- atomic_set(&n->refcnt, 1);
- n->dead = 1;
- out:
- return n;
- out_entries:
- atomic_dec(&tbl->entries);
- goto out;
- }
- static void neigh_get_hash_rnd(u32 *x)
- {
- get_random_bytes(x, sizeof(*x));
- *x |= 1;
- }
- static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
- {
- size_t size = (1 << shift) * sizeof(struct neighbour *);
- struct neigh_hash_table *ret;
- struct neighbour __rcu **buckets;
- int i;
- ret = kmalloc(sizeof(*ret), GFP_ATOMIC);
- if (!ret)
- return NULL;
- if (size <= PAGE_SIZE)
- buckets = kzalloc(size, GFP_ATOMIC);
- else
- buckets = (struct neighbour __rcu **)
- __get_free_pages(GFP_ATOMIC | __GFP_ZERO,
- get_order(size));
- if (!buckets) {
- kfree(ret);
- return NULL;
- }
- ret->hash_buckets = buckets;
- ret->hash_shift = shift;
- for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
- neigh_get_hash_rnd(&ret->hash_rnd[i]);
- return ret;
- }
- static void neigh_hash_free_rcu(struct rcu_head *head)
- {
- struct neigh_hash_table *nht = container_of(head,
- struct neigh_hash_table,
- rcu);
- size_t size = (1 << nht->hash_shift) * sizeof(struct neighbour *);
- struct neighbour __rcu **buckets = nht->hash_buckets;
- if (size <= PAGE_SIZE)
- kfree(buckets);
- else
- free_pages((unsigned long)buckets, get_order(size));
- kfree(nht);
- }
- static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
- unsigned long new_shift)
- {
- unsigned int i, hash;
- struct neigh_hash_table *new_nht, *old_nht;
- NEIGH_CACHE_STAT_INC(tbl, hash_grows);
- old_nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- new_nht = neigh_hash_alloc(new_shift);
- if (!new_nht)
- return old_nht;
- for (i = 0; i < (1 << old_nht->hash_shift); i++) {
- struct neighbour *n, *next;
- for (n = rcu_dereference_protected(old_nht->hash_buckets[i],
- lockdep_is_held(&tbl->lock));
- n != NULL;
- n = next) {
- hash = tbl->hash(n->primary_key, n->dev,
- new_nht->hash_rnd);
- hash >>= (32 - new_nht->hash_shift);
- next = rcu_dereference_protected(n->next,
- lockdep_is_held(&tbl->lock));
- rcu_assign_pointer(n->next,
- rcu_dereference_protected(
- new_nht->hash_buckets[hash],
- lockdep_is_held(&tbl->lock)));
- rcu_assign_pointer(new_nht->hash_buckets[hash], n);
- }
- }
- rcu_assign_pointer(tbl->nht, new_nht);
- call_rcu(&old_nht->rcu, neigh_hash_free_rcu);
- return new_nht;
- }
- struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
- struct net_device *dev)
- {
- struct neighbour *n;
- NEIGH_CACHE_STAT_INC(tbl, lookups);
- rcu_read_lock_bh();
- n = __neigh_lookup_noref(tbl, pkey, dev);
- if (n) {
- if (!atomic_inc_not_zero(&n->refcnt))
- n = NULL;
- NEIGH_CACHE_STAT_INC(tbl, hits);
- }
- rcu_read_unlock_bh();
- return n;
- }
- EXPORT_SYMBOL(neigh_lookup);
- struct neighbour *neigh_lookup_nodev(struct neigh_table *tbl, struct net *net,
- const void *pkey)
- {
- struct neighbour *n;
- int key_len = tbl->key_len;
- u32 hash_val;
- struct neigh_hash_table *nht;
- NEIGH_CACHE_STAT_INC(tbl, lookups);
- rcu_read_lock_bh();
- nht = rcu_dereference_bh(tbl->nht);
- hash_val = tbl->hash(pkey, NULL, nht->hash_rnd) >> (32 - nht->hash_shift);
- for (n = rcu_dereference_bh(nht->hash_buckets[hash_val]);
- n != NULL;
- n = rcu_dereference_bh(n->next)) {
- if (!memcmp(n->primary_key, pkey, key_len) &&
- net_eq(dev_net(n->dev), net)) {
- if (!atomic_inc_not_zero(&n->refcnt))
- n = NULL;
- NEIGH_CACHE_STAT_INC(tbl, hits);
- break;
- }
- }
- rcu_read_unlock_bh();
- return n;
- }
- EXPORT_SYMBOL(neigh_lookup_nodev);
- struct neighbour *__neigh_create(struct neigh_table *tbl, const void *pkey,
- struct net_device *dev, bool want_ref)
- {
- u32 hash_val;
- int key_len = tbl->key_len;
- int error;
- struct neighbour *n1, *rc, *n = neigh_alloc(tbl, dev);
- struct neigh_hash_table *nht;
- if (!n) {
- rc = ERR_PTR(-ENOBUFS);
- goto out;
- }
- memcpy(n->primary_key, pkey, key_len);
- n->dev = dev;
- dev_hold(dev);
- /* Protocol specific setup. */
- if (tbl->constructor && (error = tbl->constructor(n)) < 0) {
- rc = ERR_PTR(error);
- goto out_neigh_release;
- }
- if (dev->netdev_ops->ndo_neigh_construct) {
- error = dev->netdev_ops->ndo_neigh_construct(n);
- if (error < 0) {
- rc = ERR_PTR(error);
- goto out_neigh_release;
- }
- }
- /* Device specific setup. */
- if (n->parms->neigh_setup &&
- (error = n->parms->neigh_setup(n)) < 0) {
- rc = ERR_PTR(error);
- goto out_neigh_release;
- }
- n->confirmed = jiffies - (NEIGH_VAR(n->parms, BASE_REACHABLE_TIME) << 1);
- write_lock_bh(&tbl->lock);
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- if (atomic_read(&tbl->entries) > (1 << nht->hash_shift))
- nht = neigh_hash_grow(tbl, nht->hash_shift + 1);
- hash_val = tbl->hash(n->primary_key, dev, nht->hash_rnd) >> (32 - nht->hash_shift);
- if (n->parms->dead) {
- rc = ERR_PTR(-EINVAL);
- goto out_tbl_unlock;
- }
- for (n1 = rcu_dereference_protected(nht->hash_buckets[hash_val],
- lockdep_is_held(&tbl->lock));
- n1 != NULL;
- n1 = rcu_dereference_protected(n1->next,
- lockdep_is_held(&tbl->lock))) {
- if (dev == n1->dev && !memcmp(n1->primary_key, n->primary_key, key_len)) {
- if (want_ref)
- neigh_hold(n1);
- rc = n1;
- goto out_tbl_unlock;
- }
- }
- n->dead = 0;
- if (want_ref)
- neigh_hold(n);
- rcu_assign_pointer(n->next,
- rcu_dereference_protected(nht->hash_buckets[hash_val],
- lockdep_is_held(&tbl->lock)));
- rcu_assign_pointer(nht->hash_buckets[hash_val], n);
- write_unlock_bh(&tbl->lock);
- neigh_dbg(2, "neigh %p is created\n", n);
- rc = n;
- out:
- return rc;
- out_tbl_unlock:
- write_unlock_bh(&tbl->lock);
- out_neigh_release:
- neigh_release(n);
- goto out;
- }
- EXPORT_SYMBOL(__neigh_create);
- static u32 pneigh_hash(const void *pkey, int key_len)
- {
- u32 hash_val = *(u32 *)(pkey + key_len - 4);
- hash_val ^= (hash_val >> 16);
- hash_val ^= hash_val >> 8;
- hash_val ^= hash_val >> 4;
- hash_val &= PNEIGH_HASHMASK;
- return hash_val;
- }
- static struct pneigh_entry *__pneigh_lookup_1(struct pneigh_entry *n,
- struct net *net,
- const void *pkey,
- int key_len,
- struct net_device *dev)
- {
- while (n) {
- if (!memcmp(n->key, pkey, key_len) &&
- net_eq(pneigh_net(n), net) &&
- (n->dev == dev || !n->dev))
- return n;
- n = n->next;
- }
- return NULL;
- }
- struct pneigh_entry *__pneigh_lookup(struct neigh_table *tbl,
- struct net *net, const void *pkey, struct net_device *dev)
- {
- int key_len = tbl->key_len;
- u32 hash_val = pneigh_hash(pkey, key_len);
- return __pneigh_lookup_1(tbl->phash_buckets[hash_val],
- net, pkey, key_len, dev);
- }
- EXPORT_SYMBOL_GPL(__pneigh_lookup);
- struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl,
- struct net *net, const void *pkey,
- struct net_device *dev, int creat)
- {
- struct pneigh_entry *n;
- int key_len = tbl->key_len;
- u32 hash_val = pneigh_hash(pkey, key_len);
- read_lock_bh(&tbl->lock);
- n = __pneigh_lookup_1(tbl->phash_buckets[hash_val],
- net, pkey, key_len, dev);
- read_unlock_bh(&tbl->lock);
- if (n || !creat)
- goto out;
- ASSERT_RTNL();
- n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
- if (!n)
- goto out;
- write_pnet(&n->net, net);
- memcpy(n->key, pkey, key_len);
- n->dev = dev;
- if (dev)
- dev_hold(dev);
- if (tbl->pconstructor && tbl->pconstructor(n)) {
- if (dev)
- dev_put(dev);
- kfree(n);
- n = NULL;
- goto out;
- }
- write_lock_bh(&tbl->lock);
- n->next = tbl->phash_buckets[hash_val];
- tbl->phash_buckets[hash_val] = n;
- write_unlock_bh(&tbl->lock);
- out:
- return n;
- }
- EXPORT_SYMBOL(pneigh_lookup);
- int pneigh_delete(struct neigh_table *tbl, struct net *net, const void *pkey,
- struct net_device *dev)
- {
- struct pneigh_entry *n, **np;
- int key_len = tbl->key_len;
- u32 hash_val = pneigh_hash(pkey, key_len);
- write_lock_bh(&tbl->lock);
- for (np = &tbl->phash_buckets[hash_val]; (n = *np) != NULL;
- np = &n->next) {
- if (!memcmp(n->key, pkey, key_len) && n->dev == dev &&
- net_eq(pneigh_net(n), net)) {
- *np = n->next;
- write_unlock_bh(&tbl->lock);
- if (tbl->pdestructor)
- tbl->pdestructor(n);
- if (n->dev)
- dev_put(n->dev);
- kfree(n);
- return 0;
- }
- }
- write_unlock_bh(&tbl->lock);
- return -ENOENT;
- }
- static int pneigh_ifdown_and_unlock(struct neigh_table *tbl,
- struct net_device *dev)
- {
- struct pneigh_entry *n, **np, *freelist = NULL;
- u32 h;
- for (h = 0; h <= PNEIGH_HASHMASK; h++) {
- np = &tbl->phash_buckets[h];
- while ((n = *np) != NULL) {
- if (!dev || n->dev == dev) {
- *np = n->next;
- n->next = freelist;
- freelist = n;
- continue;
- }
- np = &n->next;
- }
- }
- write_unlock_bh(&tbl->lock);
- while ((n = freelist)) {
- freelist = n->next;
- n->next = NULL;
- if (tbl->pdestructor)
- tbl->pdestructor(n);
- if (n->dev)
- dev_put(n->dev);
- kfree(n);
- }
- return -ENOENT;
- }
- static void neigh_parms_destroy(struct neigh_parms *parms);
- static inline void neigh_parms_put(struct neigh_parms *parms)
- {
- if (atomic_dec_and_test(&parms->refcnt))
- neigh_parms_destroy(parms);
- }
- /*
- * neighbour must already be out of the table;
- *
- */
- void neigh_destroy(struct neighbour *neigh)
- {
- struct net_device *dev = neigh->dev;
- NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
- if (!neigh->dead) {
- pr_warn("Destroying alive neighbour %p\n", neigh);
- dump_stack();
- return;
- }
- if (neigh_del_timer(neigh))
- pr_warn("Impossible event\n");
- write_lock_bh(&neigh->lock);
- __skb_queue_purge(&neigh->arp_queue);
- write_unlock_bh(&neigh->lock);
- neigh->arp_queue_len_bytes = 0;
- if (dev->netdev_ops->ndo_neigh_destroy)
- dev->netdev_ops->ndo_neigh_destroy(neigh);
- dev_put(dev);
- neigh_parms_put(neigh->parms);
- neigh_dbg(2, "neigh %p is destroyed\n", neigh);
- atomic_dec(&neigh->tbl->entries);
- kfree_rcu(neigh, rcu);
- }
- EXPORT_SYMBOL(neigh_destroy);
- /* Neighbour state is suspicious;
- disable fast path.
- Called with write_locked neigh.
- */
- static void neigh_suspect(struct neighbour *neigh)
- {
- neigh_dbg(2, "neigh %p is suspected\n", neigh);
- neigh->output = neigh->ops->output;
- }
- /* Neighbour state is OK;
- enable fast path.
- Called with write_locked neigh.
- */
- static void neigh_connect(struct neighbour *neigh)
- {
- neigh_dbg(2, "neigh %p is connected\n", neigh);
- neigh->output = neigh->ops->connected_output;
- }
- static void neigh_periodic_work(struct work_struct *work)
- {
- struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
- struct neighbour *n;
- struct neighbour __rcu **np;
- unsigned int i;
- struct neigh_hash_table *nht;
- NEIGH_CACHE_STAT_INC(tbl, periodic_gc_runs);
- write_lock_bh(&tbl->lock);
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- /*
- * periodically recompute ReachableTime from random function
- */
- if (time_after(jiffies, tbl->last_rand + 300 * HZ)) {
- struct neigh_parms *p;
- tbl->last_rand = jiffies;
- list_for_each_entry(p, &tbl->parms_list, list)
- p->reachable_time =
- neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
- }
- if (atomic_read(&tbl->entries) < tbl->gc_thresh1)
- goto out;
- for (i = 0 ; i < (1 << nht->hash_shift); i++) {
- np = &nht->hash_buckets[i];
- while ((n = rcu_dereference_protected(*np,
- lockdep_is_held(&tbl->lock))) != NULL) {
- unsigned int state;
- write_lock(&n->lock);
- state = n->nud_state;
- if (state & (NUD_PERMANENT | NUD_IN_TIMER)) {
- write_unlock(&n->lock);
- goto next_elt;
- }
- if (time_before(n->used, n->confirmed))
- n->used = n->confirmed;
- if (atomic_read(&n->refcnt) == 1 &&
- (state == NUD_FAILED ||
- time_after(jiffies, n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
- *np = n->next;
- n->dead = 1;
- write_unlock(&n->lock);
- neigh_cleanup_and_release(n);
- continue;
- }
- write_unlock(&n->lock);
- next_elt:
- np = &n->next;
- }
- /*
- * It's fine to release lock here, even if hash table
- * grows while we are preempted.
- */
- write_unlock_bh(&tbl->lock);
- cond_resched();
- write_lock_bh(&tbl->lock);
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- }
- out:
- /* Cycle through all hash buckets every BASE_REACHABLE_TIME/2 ticks.
- * ARP entry timeouts range from 1/2 BASE_REACHABLE_TIME to 3/2
- * BASE_REACHABLE_TIME.
- */
- queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
- NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME) >> 1);
- write_unlock_bh(&tbl->lock);
- }
- static __inline__ int neigh_max_probes(struct neighbour *n)
- {
- struct neigh_parms *p = n->parms;
- return NEIGH_VAR(p, UCAST_PROBES) + NEIGH_VAR(p, APP_PROBES) +
- (n->nud_state & NUD_PROBE ? NEIGH_VAR(p, MCAST_REPROBES) :
- NEIGH_VAR(p, MCAST_PROBES));
- }
- static void neigh_invalidate(struct neighbour *neigh)
- __releases(neigh->lock)
- __acquires(neigh->lock)
- {
- struct sk_buff *skb;
- NEIGH_CACHE_STAT_INC(neigh->tbl, res_failed);
- neigh_dbg(2, "neigh %p is failed\n", neigh);
- neigh->updated = jiffies;
- /* It is very thin place. report_unreachable is very complicated
- routine. Particularly, it can hit the same neighbour entry!
- So that, we try to be accurate and avoid dead loop. --ANK
- */
- while (neigh->nud_state == NUD_FAILED &&
- (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
- write_unlock(&neigh->lock);
- neigh->ops->error_report(neigh, skb);
- write_lock(&neigh->lock);
- }
- __skb_queue_purge(&neigh->arp_queue);
- neigh->arp_queue_len_bytes = 0;
- }
- static void neigh_probe(struct neighbour *neigh)
- __releases(neigh->lock)
- {
- struct sk_buff *skb = skb_peek_tail(&neigh->arp_queue);
- /* keep skb alive even if arp_queue overflows */
- if (skb)
- skb = skb_clone(skb, GFP_ATOMIC);
- write_unlock(&neigh->lock);
- if (neigh->ops->solicit)
- neigh->ops->solicit(neigh, skb);
- atomic_inc(&neigh->probes);
- kfree_skb(skb);
- }
- /* Called when a timer expires for a neighbour entry. */
- static void neigh_timer_handler(unsigned long arg)
- {
- unsigned long now, next;
- struct neighbour *neigh = (struct neighbour *)arg;
- unsigned int state;
- int notify = 0;
- write_lock(&neigh->lock);
- state = neigh->nud_state;
- now = jiffies;
- next = now + HZ;
- if (!(state & NUD_IN_TIMER))
- goto out;
- if (state & NUD_REACHABLE) {
- if (time_before_eq(now,
- neigh->confirmed + neigh->parms->reachable_time)) {
- neigh_dbg(2, "neigh %p is still alive\n", neigh);
- next = neigh->confirmed + neigh->parms->reachable_time;
- } else if (time_before_eq(now,
- neigh->used +
- NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
- neigh_dbg(2, "neigh %p is delayed\n", neigh);
- neigh->nud_state = NUD_DELAY;
- neigh->updated = jiffies;
- neigh_suspect(neigh);
- next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
- } else {
- neigh_dbg(2, "neigh %p is suspected\n", neigh);
- neigh->nud_state = NUD_STALE;
- neigh->updated = jiffies;
- neigh_suspect(neigh);
- notify = 1;
- }
- } else if (state & NUD_DELAY) {
- if (time_before_eq(now,
- neigh->confirmed +
- NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
- neigh_dbg(2, "neigh %p is now reachable\n", neigh);
- neigh->nud_state = NUD_REACHABLE;
- neigh->updated = jiffies;
- neigh_connect(neigh);
- notify = 1;
- next = neigh->confirmed + neigh->parms->reachable_time;
- } else {
- neigh_dbg(2, "neigh %p is probed\n", neigh);
- neigh->nud_state = NUD_PROBE;
- neigh->updated = jiffies;
- atomic_set(&neigh->probes, 0);
- notify = 1;
- next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
- }
- } else {
- /* NUD_PROBE|NUD_INCOMPLETE */
- next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
- }
- if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
- atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
- neigh->nud_state = NUD_FAILED;
- notify = 1;
- neigh_invalidate(neigh);
- goto out;
- }
- if (neigh->nud_state & NUD_IN_TIMER) {
- if (time_before(next, jiffies + HZ/2))
- next = jiffies + HZ/2;
- if (!mod_timer(&neigh->timer, next))
- neigh_hold(neigh);
- }
- if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
- neigh_probe(neigh);
- } else {
- out:
- write_unlock(&neigh->lock);
- }
- if (notify)
- neigh_update_notify(neigh);
- neigh_release(neigh);
- }
- int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb)
- {
- int rc;
- bool immediate_probe = false;
- write_lock_bh(&neigh->lock);
- rc = 0;
- if (neigh->nud_state & (NUD_CONNECTED | NUD_DELAY | NUD_PROBE))
- goto out_unlock_bh;
- if (neigh->dead)
- goto out_dead;
- if (!(neigh->nud_state & (NUD_STALE | NUD_INCOMPLETE))) {
- if (NEIGH_VAR(neigh->parms, MCAST_PROBES) +
- NEIGH_VAR(neigh->parms, APP_PROBES)) {
- unsigned long next, now = jiffies;
- atomic_set(&neigh->probes,
- NEIGH_VAR(neigh->parms, UCAST_PROBES));
- neigh->nud_state = NUD_INCOMPLETE;
- neigh->updated = now;
- next = now + max(NEIGH_VAR(neigh->parms, RETRANS_TIME),
- HZ/2);
- neigh_add_timer(neigh, next);
- immediate_probe = true;
- } else {
- neigh->nud_state = NUD_FAILED;
- neigh->updated = jiffies;
- write_unlock_bh(&neigh->lock);
- kfree_skb(skb);
- return 1;
- }
- } else if (neigh->nud_state & NUD_STALE) {
- neigh_dbg(2, "neigh %p is delayed\n", neigh);
- neigh->nud_state = NUD_DELAY;
- neigh->updated = jiffies;
- neigh_add_timer(neigh, jiffies +
- NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME));
- }
- if (neigh->nud_state == NUD_INCOMPLETE) {
- if (skb) {
- while (neigh->arp_queue_len_bytes + skb->truesize >
- NEIGH_VAR(neigh->parms, QUEUE_LEN_BYTES)) {
- struct sk_buff *buff;
- buff = __skb_dequeue(&neigh->arp_queue);
- if (!buff)
- break;
- neigh->arp_queue_len_bytes -= buff->truesize;
- kfree_skb(buff);
- NEIGH_CACHE_STAT_INC(neigh->tbl, unres_discards);
- }
- skb_dst_force(skb);
- __skb_queue_tail(&neigh->arp_queue, skb);
- neigh->arp_queue_len_bytes += skb->truesize;
- }
- rc = 1;
- }
- out_unlock_bh:
- if (immediate_probe)
- neigh_probe(neigh);
- else
- write_unlock(&neigh->lock);
- local_bh_enable();
- return rc;
- out_dead:
- if (neigh->nud_state & NUD_STALE)
- goto out_unlock_bh;
- write_unlock_bh(&neigh->lock);
- kfree_skb(skb);
- return 1;
- }
- EXPORT_SYMBOL(__neigh_event_send);
- static void neigh_update_hhs(struct neighbour *neigh)
- {
- struct hh_cache *hh;
- void (*update)(struct hh_cache*, const struct net_device*, const unsigned char *)
- = NULL;
- if (neigh->dev->header_ops)
- update = neigh->dev->header_ops->cache_update;
- if (update) {
- hh = &neigh->hh;
- if (hh->hh_len) {
- write_seqlock_bh(&hh->hh_lock);
- update(hh, neigh->dev, neigh->ha);
- write_sequnlock_bh(&hh->hh_lock);
- }
- }
- }
- /* Generic update routine.
- -- lladdr is new lladdr or NULL, if it is not supplied.
- -- new is new state.
- -- flags
- NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
- if it is different.
- NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
- lladdr instead of overriding it
- if it is different.
- It also allows to retain current state
- if lladdr is unchanged.
- NEIGH_UPDATE_F_ADMIN means that the change is administrative.
- NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing
- NTF_ROUTER flag.
- NEIGH_UPDATE_F_ISROUTER indicates if the neighbour is known as
- a router.
- Caller MUST hold reference count on the entry.
- */
- int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
- u32 flags)
- {
- u8 old;
- int err;
- int notify = 0;
- struct net_device *dev;
- int update_isrouter = 0;
- write_lock_bh(&neigh->lock);
- dev = neigh->dev;
- old = neigh->nud_state;
- err = -EPERM;
- if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
- (old & (NUD_NOARP | NUD_PERMANENT)))
- goto out;
- if (neigh->dead)
- goto out;
- if (!(new & NUD_VALID)) {
- neigh_del_timer(neigh);
- if (old & NUD_CONNECTED)
- neigh_suspect(neigh);
- neigh->nud_state = new;
- err = 0;
- notify = old & NUD_VALID;
- if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
- (new & NUD_FAILED)) {
- neigh_invalidate(neigh);
- notify = 1;
- }
- goto out;
- }
- /* Compare new lladdr with cached one */
- if (!dev->addr_len) {
- /* First case: device needs no address. */
- lladdr = neigh->ha;
- } else if (lladdr) {
- /* The second case: if something is already cached
- and a new address is proposed:
- - compare new & old
- - if they are different, check override flag
- */
- if ((old & NUD_VALID) &&
- !memcmp(lladdr, neigh->ha, dev->addr_len))
- lladdr = neigh->ha;
- } else {
- /* No address is supplied; if we know something,
- use it, otherwise discard the request.
- */
- err = -EINVAL;
- if (!(old & NUD_VALID))
- goto out;
- lladdr = neigh->ha;
- }
- /* Update confirmed timestamp for neighbour entry after we
- * received ARP packet even if it doesn't change IP to MAC binding.
- */
- if (new & NUD_CONNECTED)
- neigh->confirmed = jiffies;
- /* If entry was valid and address is not changed,
- do not change entry state, if new one is STALE.
- */
- err = 0;
- update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;
- if (old & NUD_VALID) {
- if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
- update_isrouter = 0;
- if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
- (old & NUD_CONNECTED)) {
- lladdr = neigh->ha;
- new = NUD_STALE;
- } else
- goto out;
- } else {
- if (lladdr == neigh->ha && new == NUD_STALE &&
- ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||
- (old & NUD_CONNECTED))
- )
- new = old;
- }
- }
- /* Update timestamp only once we know we will make a change to the
- * neighbour entry. Otherwise we risk to move the locktime window with
- * noop updates and ignore relevant ARP updates.
- */
- if (new != old || lladdr != neigh->ha)
- neigh->updated = jiffies;
- if (new != old) {
- neigh_del_timer(neigh);
- if (new & NUD_PROBE)
- atomic_set(&neigh->probes, 0);
- if (new & NUD_IN_TIMER)
- neigh_add_timer(neigh, (jiffies +
- ((new & NUD_REACHABLE) ?
- neigh->parms->reachable_time :
- 0)));
- neigh->nud_state = new;
- notify = 1;
- }
- if (lladdr != neigh->ha) {
- write_seqlock(&neigh->ha_lock);
- memcpy(&neigh->ha, lladdr, dev->addr_len);
- write_sequnlock(&neigh->ha_lock);
- neigh_update_hhs(neigh);
- if (!(new & NUD_CONNECTED))
- neigh->confirmed = jiffies -
- (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << 1);
- notify = 1;
- }
- if (new == old)
- goto out;
- if (new & NUD_CONNECTED)
- neigh_connect(neigh);
- else
- neigh_suspect(neigh);
- if (!(old & NUD_VALID)) {
- struct sk_buff *skb;
- /* Again: avoid dead loop if something went wrong */
- while (neigh->nud_state & NUD_VALID &&
- (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
- struct dst_entry *dst = skb_dst(skb);
- struct neighbour *n2, *n1 = neigh;
- write_unlock_bh(&neigh->lock);
- rcu_read_lock();
- /* Why not just use 'neigh' as-is? The problem is that
- * things such as shaper, eql, and sch_teql can end up
- * using alternative, different, neigh objects to output
- * the packet in the output path. So what we need to do
- * here is re-lookup the top-level neigh in the path so
- * we can reinject the packet there.
- */
- n2 = NULL;
- if (dst) {
- n2 = dst_neigh_lookup_skb(dst, skb);
- if (n2)
- n1 = n2;
- }
- n1->output(n1, skb);
- if (n2)
- neigh_release(n2);
- rcu_read_unlock();
- write_lock_bh(&neigh->lock);
- }
- __skb_queue_purge(&neigh->arp_queue);
- neigh->arp_queue_len_bytes = 0;
- }
- out:
- if (update_isrouter) {
- neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
- (neigh->flags | NTF_ROUTER) :
- (neigh->flags & ~NTF_ROUTER);
- }
- write_unlock_bh(&neigh->lock);
- if (notify)
- neigh_update_notify(neigh);
- return err;
- }
- EXPORT_SYMBOL(neigh_update);
- /* Update the neigh to listen temporarily for probe responses, even if it is
- * in a NUD_FAILED state. The caller has to hold neigh->lock for writing.
- */
- void __neigh_set_probe_once(struct neighbour *neigh)
- {
- if (neigh->dead)
- return;
- neigh->updated = jiffies;
- if (!(neigh->nud_state & NUD_FAILED))
- return;
- neigh->nud_state = NUD_INCOMPLETE;
- atomic_set(&neigh->probes, neigh_max_probes(neigh));
- neigh_add_timer(neigh,
- jiffies + NEIGH_VAR(neigh->parms, RETRANS_TIME));
- }
- EXPORT_SYMBOL(__neigh_set_probe_once);
- struct neighbour *neigh_event_ns(struct neigh_table *tbl,
- u8 *lladdr, void *saddr,
- struct net_device *dev)
- {
- struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
- lladdr || !dev->addr_len);
- if (neigh)
- neigh_update(neigh, lladdr, NUD_STALE,
- NEIGH_UPDATE_F_OVERRIDE);
- return neigh;
- }
- EXPORT_SYMBOL(neigh_event_ns);
- /* called with read_lock_bh(&n->lock); */
- static void neigh_hh_init(struct neighbour *n)
- {
- struct net_device *dev = n->dev;
- __be16 prot = n->tbl->protocol;
- struct hh_cache *hh = &n->hh;
- write_lock_bh(&n->lock);
- /* Only one thread can come in here and initialize the
- * hh_cache entry.
- */
- if (!hh->hh_len)
- dev->header_ops->cache(n, hh, prot);
- write_unlock_bh(&n->lock);
- }
- /* Slow and careful. */
- int neigh_resolve_output(struct neighbour *neigh, struct sk_buff *skb)
- {
- int rc = 0;
- if (!neigh_event_send(neigh, skb)) {
- int err;
- struct net_device *dev = neigh->dev;
- unsigned int seq;
- if (dev->header_ops->cache && !neigh->hh.hh_len)
- neigh_hh_init(neigh);
- do {
- __skb_pull(skb, skb_network_offset(skb));
- seq = read_seqbegin(&neigh->ha_lock);
- err = dev_hard_header(skb, dev, ntohs(skb->protocol),
- neigh->ha, NULL, skb->len);
- } while (read_seqretry(&neigh->ha_lock, seq));
- if (err >= 0)
- rc = dev_queue_xmit(skb);
- else
- goto out_kfree_skb;
- }
- out:
- return rc;
- out_kfree_skb:
- rc = -EINVAL;
- kfree_skb(skb);
- goto out;
- }
- EXPORT_SYMBOL(neigh_resolve_output);
- /* As fast as possible without hh cache */
- int neigh_connected_output(struct neighbour *neigh, struct sk_buff *skb)
- {
- struct net_device *dev = neigh->dev;
- unsigned int seq;
- int err;
- do {
- __skb_pull(skb, skb_network_offset(skb));
- seq = read_seqbegin(&neigh->ha_lock);
- err = dev_hard_header(skb, dev, ntohs(skb->protocol),
- neigh->ha, NULL, skb->len);
- } while (read_seqretry(&neigh->ha_lock, seq));
- if (err >= 0)
- err = dev_queue_xmit(skb);
- else {
- err = -EINVAL;
- kfree_skb(skb);
- }
- return err;
- }
- EXPORT_SYMBOL(neigh_connected_output);
- int neigh_direct_output(struct neighbour *neigh, struct sk_buff *skb)
- {
- return dev_queue_xmit(skb);
- }
- EXPORT_SYMBOL(neigh_direct_output);
- static void neigh_proxy_process(unsigned long arg)
- {
- struct neigh_table *tbl = (struct neigh_table *)arg;
- long sched_next = 0;
- unsigned long now = jiffies;
- struct sk_buff *skb, *n;
- spin_lock(&tbl->proxy_queue.lock);
- skb_queue_walk_safe(&tbl->proxy_queue, skb, n) {
- long tdif = NEIGH_CB(skb)->sched_next - now;
- if (tdif <= 0) {
- struct net_device *dev = skb->dev;
- __skb_unlink(skb, &tbl->proxy_queue);
- if (tbl->proxy_redo && netif_running(dev)) {
- rcu_read_lock();
- tbl->proxy_redo(skb);
- rcu_read_unlock();
- } else {
- kfree_skb(skb);
- }
- dev_put(dev);
- } else if (!sched_next || tdif < sched_next)
- sched_next = tdif;
- }
- del_timer(&tbl->proxy_timer);
- if (sched_next)
- mod_timer(&tbl->proxy_timer, jiffies + sched_next);
- spin_unlock(&tbl->proxy_queue.lock);
- }
- void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
- struct sk_buff *skb)
- {
- unsigned long now = jiffies;
- unsigned long sched_next = now + (prandom_u32() %
- NEIGH_VAR(p, PROXY_DELAY));
- if (tbl->proxy_queue.qlen > NEIGH_VAR(p, PROXY_QLEN)) {
- kfree_skb(skb);
- return;
- }
- NEIGH_CB(skb)->sched_next = sched_next;
- NEIGH_CB(skb)->flags |= LOCALLY_ENQUEUED;
- spin_lock(&tbl->proxy_queue.lock);
- if (del_timer(&tbl->proxy_timer)) {
- if (time_before(tbl->proxy_timer.expires, sched_next))
- sched_next = tbl->proxy_timer.expires;
- }
- skb_dst_drop(skb);
- dev_hold(skb->dev);
- __skb_queue_tail(&tbl->proxy_queue, skb);
- mod_timer(&tbl->proxy_timer, sched_next);
- spin_unlock(&tbl->proxy_queue.lock);
- }
- EXPORT_SYMBOL(pneigh_enqueue);
- static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
- struct net *net, int ifindex)
- {
- struct neigh_parms *p;
- list_for_each_entry(p, &tbl->parms_list, list) {
- if ((p->dev && p->dev->ifindex == ifindex && net_eq(neigh_parms_net(p), net)) ||
- (!p->dev && !ifindex && net_eq(net, &init_net)))
- return p;
- }
- return NULL;
- }
- struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
- struct neigh_table *tbl)
- {
- struct neigh_parms *p;
- struct net *net = dev_net(dev);
- const struct net_device_ops *ops = dev->netdev_ops;
- p = kmemdup(&tbl->parms, sizeof(*p), GFP_KERNEL);
- if (p) {
- p->tbl = tbl;
- atomic_set(&p->refcnt, 1);
- p->reachable_time =
- neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
- dev_hold(dev);
- p->dev = dev;
- write_pnet(&p->net, net);
- p->sysctl_table = NULL;
- if (ops->ndo_neigh_setup && ops->ndo_neigh_setup(dev, p)) {
- dev_put(dev);
- kfree(p);
- return NULL;
- }
- write_lock_bh(&tbl->lock);
- list_add(&p->list, &tbl->parms.list);
- write_unlock_bh(&tbl->lock);
- neigh_parms_data_state_cleanall(p);
- }
- return p;
- }
- EXPORT_SYMBOL(neigh_parms_alloc);
- static void neigh_rcu_free_parms(struct rcu_head *head)
- {
- struct neigh_parms *parms =
- container_of(head, struct neigh_parms, rcu_head);
- neigh_parms_put(parms);
- }
- void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms)
- {
- if (!parms || parms == &tbl->parms)
- return;
- write_lock_bh(&tbl->lock);
- list_del(&parms->list);
- parms->dead = 1;
- write_unlock_bh(&tbl->lock);
- if (parms->dev)
- dev_put(parms->dev);
- call_rcu(&parms->rcu_head, neigh_rcu_free_parms);
- }
- EXPORT_SYMBOL(neigh_parms_release);
- static void neigh_parms_destroy(struct neigh_parms *parms)
- {
- kfree(parms);
- }
- static struct lock_class_key neigh_table_proxy_queue_class;
- static struct neigh_table *neigh_tables[NEIGH_NR_TABLES] __read_mostly;
- void neigh_table_init(int index, struct neigh_table *tbl)
- {
- unsigned long now = jiffies;
- unsigned long phsize;
- INIT_LIST_HEAD(&tbl->parms_list);
- list_add(&tbl->parms.list, &tbl->parms_list);
- write_pnet(&tbl->parms.net, &init_net);
- atomic_set(&tbl->parms.refcnt, 1);
- tbl->parms.reachable_time =
- neigh_rand_reach_time(NEIGH_VAR(&tbl->parms, BASE_REACHABLE_TIME));
- tbl->stats = alloc_percpu(struct neigh_statistics);
- if (!tbl->stats)
- panic("cannot create neighbour cache statistics");
- #ifdef CONFIG_PROC_FS
- if (!proc_create_data(tbl->id, 0, init_net.proc_net_stat,
- &neigh_stat_seq_fops, tbl))
- panic("cannot create neighbour proc dir entry");
- #endif
- RCU_INIT_POINTER(tbl->nht, neigh_hash_alloc(3));
- phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);
- tbl->phash_buckets = kzalloc(phsize, GFP_KERNEL);
- if (!tbl->nht || !tbl->phash_buckets)
- panic("cannot allocate neighbour cache hashes");
- if (!tbl->entry_size)
- tbl->entry_size = ALIGN(offsetof(struct neighbour, primary_key) +
- tbl->key_len, NEIGH_PRIV_ALIGN);
- else
- WARN_ON(tbl->entry_size % NEIGH_PRIV_ALIGN);
- rwlock_init(&tbl->lock);
- INIT_DEFERRABLE_WORK(&tbl->gc_work, neigh_periodic_work);
- queue_delayed_work(system_power_efficient_wq, &tbl->gc_work,
- tbl->parms.reachable_time);
- setup_timer(&tbl->proxy_timer, neigh_proxy_process, (unsigned long)tbl);
- skb_queue_head_init_class(&tbl->proxy_queue,
- &neigh_table_proxy_queue_class);
- tbl->last_flush = now;
- tbl->last_rand = now + tbl->parms.reachable_time * 20;
- neigh_tables[index] = tbl;
- }
- EXPORT_SYMBOL(neigh_table_init);
- int neigh_table_clear(int index, struct neigh_table *tbl)
- {
- neigh_tables[index] = NULL;
- /* It is not clean... Fix it to unload IPv6 module safely */
- cancel_delayed_work_sync(&tbl->gc_work);
- del_timer_sync(&tbl->proxy_timer);
- pneigh_queue_purge(&tbl->proxy_queue);
- neigh_ifdown(tbl, NULL);
- if (atomic_read(&tbl->entries))
- pr_crit("neighbour leakage\n");
- call_rcu(&rcu_dereference_protected(tbl->nht, 1)->rcu,
- neigh_hash_free_rcu);
- tbl->nht = NULL;
- kfree(tbl->phash_buckets);
- tbl->phash_buckets = NULL;
- remove_proc_entry(tbl->id, init_net.proc_net_stat);
- free_percpu(tbl->stats);
- tbl->stats = NULL;
- return 0;
- }
- EXPORT_SYMBOL(neigh_table_clear);
- static struct neigh_table *neigh_find_table(int family)
- {
- struct neigh_table *tbl = NULL;
- switch (family) {
- case AF_INET:
- tbl = neigh_tables[NEIGH_ARP_TABLE];
- break;
- case AF_INET6:
- tbl = neigh_tables[NEIGH_ND_TABLE];
- break;
- case AF_DECnet:
- tbl = neigh_tables[NEIGH_DN_TABLE];
- break;
- }
- return tbl;
- }
- static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh)
- {
- struct net *net = sock_net(skb->sk);
- struct ndmsg *ndm;
- struct nlattr *dst_attr;
- struct neigh_table *tbl;
- struct neighbour *neigh;
- struct net_device *dev = NULL;
- int err = -EINVAL;
- ASSERT_RTNL();
- if (nlmsg_len(nlh) < sizeof(*ndm))
- goto out;
- dst_attr = nlmsg_find_attr(nlh, sizeof(*ndm), NDA_DST);
- if (dst_attr == NULL)
- goto out;
- ndm = nlmsg_data(nlh);
- if (ndm->ndm_ifindex) {
- dev = __dev_get_by_index(net, ndm->ndm_ifindex);
- if (dev == NULL) {
- err = -ENODEV;
- goto out;
- }
- }
- tbl = neigh_find_table(ndm->ndm_family);
- if (tbl == NULL)
- return -EAFNOSUPPORT;
- if (nla_len(dst_attr) < tbl->key_len)
- goto out;
- if (ndm->ndm_flags & NTF_PROXY) {
- err = pneigh_delete(tbl, net, nla_data(dst_attr), dev);
- goto out;
- }
- if (dev == NULL)
- goto out;
- neigh = neigh_lookup(tbl, nla_data(dst_attr), dev);
- if (neigh == NULL) {
- err = -ENOENT;
- goto out;
- }
- err = neigh_update(neigh, NULL, NUD_FAILED,
- NEIGH_UPDATE_F_OVERRIDE |
- NEIGH_UPDATE_F_ADMIN);
- neigh_release(neigh);
- out:
- return err;
- }
- static int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh)
- {
- int flags = NEIGH_UPDATE_F_ADMIN | NEIGH_UPDATE_F_OVERRIDE;
- struct net *net = sock_net(skb->sk);
- struct ndmsg *ndm;
- struct nlattr *tb[NDA_MAX+1];
- struct neigh_table *tbl;
- struct net_device *dev = NULL;
- struct neighbour *neigh;
- void *dst, *lladdr;
- int err;
- ASSERT_RTNL();
- err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX, NULL);
- if (err < 0)
- goto out;
- err = -EINVAL;
- if (tb[NDA_DST] == NULL)
- goto out;
- ndm = nlmsg_data(nlh);
- if (ndm->ndm_ifindex) {
- dev = __dev_get_by_index(net, ndm->ndm_ifindex);
- if (dev == NULL) {
- err = -ENODEV;
- goto out;
- }
- if (tb[NDA_LLADDR] && nla_len(tb[NDA_LLADDR]) < dev->addr_len)
- goto out;
- }
- tbl = neigh_find_table(ndm->ndm_family);
- if (tbl == NULL)
- return -EAFNOSUPPORT;
- if (nla_len(tb[NDA_DST]) < tbl->key_len)
- goto out;
- dst = nla_data(tb[NDA_DST]);
- lladdr = tb[NDA_LLADDR] ? nla_data(tb[NDA_LLADDR]) : NULL;
- if (ndm->ndm_flags & NTF_PROXY) {
- struct pneigh_entry *pn;
- err = -ENOBUFS;
- pn = pneigh_lookup(tbl, net, dst, dev, 1);
- if (pn) {
- pn->flags = ndm->ndm_flags;
- err = 0;
- }
- goto out;
- }
- if (dev == NULL)
- goto out;
- neigh = neigh_lookup(tbl, dst, dev);
- if (neigh == NULL) {
- if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
- err = -ENOENT;
- goto out;
- }
- neigh = __neigh_lookup_errno(tbl, dst, dev);
- if (IS_ERR(neigh)) {
- err = PTR_ERR(neigh);
- goto out;
- }
- } else {
- if (nlh->nlmsg_flags & NLM_F_EXCL) {
- err = -EEXIST;
- neigh_release(neigh);
- goto out;
- }
- if (!(nlh->nlmsg_flags & NLM_F_REPLACE))
- flags &= ~NEIGH_UPDATE_F_OVERRIDE;
- }
- if (ndm->ndm_flags & NTF_USE) {
- neigh_event_send(neigh, NULL);
- err = 0;
- } else
- err = neigh_update(neigh, lladdr, ndm->ndm_state, flags);
- neigh_release(neigh);
- out:
- return err;
- }
- static int neightbl_fill_parms(struct sk_buff *skb, struct neigh_parms *parms)
- {
- struct nlattr *nest;
- nest = nla_nest_start(skb, NDTA_PARMS);
- if (nest == NULL)
- return -ENOBUFS;
- if ((parms->dev &&
- nla_put_u32(skb, NDTPA_IFINDEX, parms->dev->ifindex)) ||
- nla_put_u32(skb, NDTPA_REFCNT, atomic_read(&parms->refcnt)) ||
- nla_put_u32(skb, NDTPA_QUEUE_LENBYTES,
- NEIGH_VAR(parms, QUEUE_LEN_BYTES)) ||
- /* approximative value for deprecated QUEUE_LEN (in packets) */
- nla_put_u32(skb, NDTPA_QUEUE_LEN,
- NEIGH_VAR(parms, QUEUE_LEN_BYTES) / SKB_TRUESIZE(ETH_FRAME_LEN)) ||
- nla_put_u32(skb, NDTPA_PROXY_QLEN, NEIGH_VAR(parms, PROXY_QLEN)) ||
- nla_put_u32(skb, NDTPA_APP_PROBES, NEIGH_VAR(parms, APP_PROBES)) ||
- nla_put_u32(skb, NDTPA_UCAST_PROBES,
- NEIGH_VAR(parms, UCAST_PROBES)) ||
- nla_put_u32(skb, NDTPA_MCAST_PROBES,
- NEIGH_VAR(parms, MCAST_PROBES)) ||
- nla_put_u32(skb, NDTPA_MCAST_REPROBES,
- NEIGH_VAR(parms, MCAST_REPROBES)) ||
- nla_put_msecs(skb, NDTPA_REACHABLE_TIME, parms->reachable_time) ||
- nla_put_msecs(skb, NDTPA_BASE_REACHABLE_TIME,
- NEIGH_VAR(parms, BASE_REACHABLE_TIME)) ||
- nla_put_msecs(skb, NDTPA_GC_STALETIME,
- NEIGH_VAR(parms, GC_STALETIME)) ||
- nla_put_msecs(skb, NDTPA_DELAY_PROBE_TIME,
- NEIGH_VAR(parms, DELAY_PROBE_TIME)) ||
- nla_put_msecs(skb, NDTPA_RETRANS_TIME,
- NEIGH_VAR(parms, RETRANS_TIME)) ||
- nla_put_msecs(skb, NDTPA_ANYCAST_DELAY,
- NEIGH_VAR(parms, ANYCAST_DELAY)) ||
- nla_put_msecs(skb, NDTPA_PROXY_DELAY,
- NEIGH_VAR(parms, PROXY_DELAY)) ||
- nla_put_msecs(skb, NDTPA_LOCKTIME,
- NEIGH_VAR(parms, LOCKTIME)))
- goto nla_put_failure;
- return nla_nest_end(skb, nest);
- nla_put_failure:
- nla_nest_cancel(skb, nest);
- return -EMSGSIZE;
- }
- static int neightbl_fill_info(struct sk_buff *skb, struct neigh_table *tbl,
- u32 pid, u32 seq, int type, int flags)
- {
- struct nlmsghdr *nlh;
- struct ndtmsg *ndtmsg;
- nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
- if (nlh == NULL)
- return -EMSGSIZE;
- ndtmsg = nlmsg_data(nlh);
- read_lock_bh(&tbl->lock);
- ndtmsg->ndtm_family = tbl->family;
- ndtmsg->ndtm_pad1 = 0;
- ndtmsg->ndtm_pad2 = 0;
- if (nla_put_string(skb, NDTA_NAME, tbl->id) ||
- nla_put_msecs(skb, NDTA_GC_INTERVAL, tbl->gc_interval) ||
- nla_put_u32(skb, NDTA_THRESH1, tbl->gc_thresh1) ||
- nla_put_u32(skb, NDTA_THRESH2, tbl->gc_thresh2) ||
- nla_put_u32(skb, NDTA_THRESH3, tbl->gc_thresh3))
- goto nla_put_failure;
- {
- unsigned long now = jiffies;
- unsigned int flush_delta = now - tbl->last_flush;
- unsigned int rand_delta = now - tbl->last_rand;
- struct neigh_hash_table *nht;
- struct ndt_config ndc = {
- .ndtc_key_len = tbl->key_len,
- .ndtc_entry_size = tbl->entry_size,
- .ndtc_entries = atomic_read(&tbl->entries),
- .ndtc_last_flush = jiffies_to_msecs(flush_delta),
- .ndtc_last_rand = jiffies_to_msecs(rand_delta),
- .ndtc_proxy_qlen = tbl->proxy_queue.qlen,
- };
- rcu_read_lock_bh();
- nht = rcu_dereference_bh(tbl->nht);
- ndc.ndtc_hash_rnd = nht->hash_rnd[0];
- ndc.ndtc_hash_mask = ((1 << nht->hash_shift) - 1);
- rcu_read_unlock_bh();
- if (nla_put(skb, NDTA_CONFIG, sizeof(ndc), &ndc))
- goto nla_put_failure;
- }
- {
- int cpu;
- struct ndt_stats ndst;
- memset(&ndst, 0, sizeof(ndst));
- for_each_possible_cpu(cpu) {
- struct neigh_statistics *st;
- st = per_cpu_ptr(tbl->stats, cpu);
- ndst.ndts_allocs += st->allocs;
- ndst.ndts_destroys += st->destroys;
- ndst.ndts_hash_grows += st->hash_grows;
- ndst.ndts_res_failed += st->res_failed;
- ndst.ndts_lookups += st->lookups;
- ndst.ndts_hits += st->hits;
- ndst.ndts_rcv_probes_mcast += st->rcv_probes_mcast;
- ndst.ndts_rcv_probes_ucast += st->rcv_probes_ucast;
- ndst.ndts_periodic_gc_runs += st->periodic_gc_runs;
- ndst.ndts_forced_gc_runs += st->forced_gc_runs;
- ndst.ndts_table_fulls += st->table_fulls;
- }
- if (nla_put(skb, NDTA_STATS, sizeof(ndst), &ndst))
- goto nla_put_failure;
- }
- BUG_ON(tbl->parms.dev);
- if (neightbl_fill_parms(skb, &tbl->parms) < 0)
- goto nla_put_failure;
- read_unlock_bh(&tbl->lock);
- nlmsg_end(skb, nlh);
- return 0;
- nla_put_failure:
- read_unlock_bh(&tbl->lock);
- nlmsg_cancel(skb, nlh);
- return -EMSGSIZE;
- }
- static int neightbl_fill_param_info(struct sk_buff *skb,
- struct neigh_table *tbl,
- struct neigh_parms *parms,
- u32 pid, u32 seq, int type,
- unsigned int flags)
- {
- struct ndtmsg *ndtmsg;
- struct nlmsghdr *nlh;
- nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndtmsg), flags);
- if (nlh == NULL)
- return -EMSGSIZE;
- ndtmsg = nlmsg_data(nlh);
- read_lock_bh(&tbl->lock);
- ndtmsg->ndtm_family = tbl->family;
- ndtmsg->ndtm_pad1 = 0;
- ndtmsg->ndtm_pad2 = 0;
- if (nla_put_string(skb, NDTA_NAME, tbl->id) < 0 ||
- neightbl_fill_parms(skb, parms) < 0)
- goto errout;
- read_unlock_bh(&tbl->lock);
- nlmsg_end(skb, nlh);
- return 0;
- errout:
- read_unlock_bh(&tbl->lock);
- nlmsg_cancel(skb, nlh);
- return -EMSGSIZE;
- }
- static const struct nla_policy nl_neightbl_policy[NDTA_MAX+1] = {
- [NDTA_NAME] = { .type = NLA_STRING },
- [NDTA_THRESH1] = { .type = NLA_U32 },
- [NDTA_THRESH2] = { .type = NLA_U32 },
- [NDTA_THRESH3] = { .type = NLA_U32 },
- [NDTA_GC_INTERVAL] = { .type = NLA_U64 },
- [NDTA_PARMS] = { .type = NLA_NESTED },
- };
- static const struct nla_policy nl_ntbl_parm_policy[NDTPA_MAX+1] = {
- [NDTPA_IFINDEX] = { .type = NLA_U32 },
- [NDTPA_QUEUE_LEN] = { .type = NLA_U32 },
- [NDTPA_PROXY_QLEN] = { .type = NLA_U32 },
- [NDTPA_APP_PROBES] = { .type = NLA_U32 },
- [NDTPA_UCAST_PROBES] = { .type = NLA_U32 },
- [NDTPA_MCAST_PROBES] = { .type = NLA_U32 },
- [NDTPA_MCAST_REPROBES] = { .type = NLA_U32 },
- [NDTPA_BASE_REACHABLE_TIME] = { .type = NLA_U64 },
- [NDTPA_GC_STALETIME] = { .type = NLA_U64 },
- [NDTPA_DELAY_PROBE_TIME] = { .type = NLA_U64 },
- [NDTPA_RETRANS_TIME] = { .type = NLA_U64 },
- [NDTPA_ANYCAST_DELAY] = { .type = NLA_U64 },
- [NDTPA_PROXY_DELAY] = { .type = NLA_U64 },
- [NDTPA_LOCKTIME] = { .type = NLA_U64 },
- };
- static int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh)
- {
- struct net *net = sock_net(skb->sk);
- struct neigh_table *tbl;
- struct ndtmsg *ndtmsg;
- struct nlattr *tb[NDTA_MAX+1];
- bool found = false;
- int err, tidx;
- err = nlmsg_parse(nlh, sizeof(*ndtmsg), tb, NDTA_MAX,
- nl_neightbl_policy);
- if (err < 0)
- goto errout;
- if (tb[NDTA_NAME] == NULL) {
- err = -EINVAL;
- goto errout;
- }
- ndtmsg = nlmsg_data(nlh);
- for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
- tbl = neigh_tables[tidx];
- if (!tbl)
- continue;
- if (ndtmsg->ndtm_family && tbl->family != ndtmsg->ndtm_family)
- continue;
- if (nla_strcmp(tb[NDTA_NAME], tbl->id) == 0) {
- found = true;
- break;
- }
- }
- if (!found)
- return -ENOENT;
- /*
- * We acquire tbl->lock to be nice to the periodic timers and
- * make sure they always see a consistent set of values.
- */
- write_lock_bh(&tbl->lock);
- if (tb[NDTA_PARMS]) {
- struct nlattr *tbp[NDTPA_MAX+1];
- struct neigh_parms *p;
- int i, ifindex = 0;
- err = nla_parse_nested(tbp, NDTPA_MAX, tb[NDTA_PARMS],
- nl_ntbl_parm_policy);
- if (err < 0)
- goto errout_tbl_lock;
- if (tbp[NDTPA_IFINDEX])
- ifindex = nla_get_u32(tbp[NDTPA_IFINDEX]);
- p = lookup_neigh_parms(tbl, net, ifindex);
- if (p == NULL) {
- err = -ENOENT;
- goto errout_tbl_lock;
- }
- for (i = 1; i <= NDTPA_MAX; i++) {
- if (tbp[i] == NULL)
- continue;
- switch (i) {
- case NDTPA_QUEUE_LEN:
- NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
- nla_get_u32(tbp[i]) *
- SKB_TRUESIZE(ETH_FRAME_LEN));
- break;
- case NDTPA_QUEUE_LENBYTES:
- NEIGH_VAR_SET(p, QUEUE_LEN_BYTES,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_PROXY_QLEN:
- NEIGH_VAR_SET(p, PROXY_QLEN,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_APP_PROBES:
- NEIGH_VAR_SET(p, APP_PROBES,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_UCAST_PROBES:
- NEIGH_VAR_SET(p, UCAST_PROBES,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_MCAST_PROBES:
- NEIGH_VAR_SET(p, MCAST_PROBES,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_MCAST_REPROBES:
- NEIGH_VAR_SET(p, MCAST_REPROBES,
- nla_get_u32(tbp[i]));
- break;
- case NDTPA_BASE_REACHABLE_TIME:
- NEIGH_VAR_SET(p, BASE_REACHABLE_TIME,
- nla_get_msecs(tbp[i]));
- /* update reachable_time as well, otherwise, the change will
- * only be effective after the next time neigh_periodic_work
- * decides to recompute it (can be multiple minutes)
- */
- p->reachable_time =
- neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
- break;
- case NDTPA_GC_STALETIME:
- NEIGH_VAR_SET(p, GC_STALETIME,
- nla_get_msecs(tbp[i]));
- break;
- case NDTPA_DELAY_PROBE_TIME:
- NEIGH_VAR_SET(p, DELAY_PROBE_TIME,
- nla_get_msecs(tbp[i]));
- break;
- case NDTPA_RETRANS_TIME:
- NEIGH_VAR_SET(p, RETRANS_TIME,
- nla_get_msecs(tbp[i]));
- break;
- case NDTPA_ANYCAST_DELAY:
- NEIGH_VAR_SET(p, ANYCAST_DELAY,
- nla_get_msecs(tbp[i]));
- break;
- case NDTPA_PROXY_DELAY:
- NEIGH_VAR_SET(p, PROXY_DELAY,
- nla_get_msecs(tbp[i]));
- break;
- case NDTPA_LOCKTIME:
- NEIGH_VAR_SET(p, LOCKTIME,
- nla_get_msecs(tbp[i]));
- break;
- }
- }
- }
- err = -ENOENT;
- if ((tb[NDTA_THRESH1] || tb[NDTA_THRESH2] ||
- tb[NDTA_THRESH3] || tb[NDTA_GC_INTERVAL]) &&
- !net_eq(net, &init_net))
- goto errout_tbl_lock;
- if (tb[NDTA_THRESH1])
- tbl->gc_thresh1 = nla_get_u32(tb[NDTA_THRESH1]);
- if (tb[NDTA_THRESH2])
- tbl->gc_thresh2 = nla_get_u32(tb[NDTA_THRESH2]);
- if (tb[NDTA_THRESH3])
- tbl->gc_thresh3 = nla_get_u32(tb[NDTA_THRESH3]);
- if (tb[NDTA_GC_INTERVAL])
- tbl->gc_interval = nla_get_msecs(tb[NDTA_GC_INTERVAL]);
- err = 0;
- errout_tbl_lock:
- write_unlock_bh(&tbl->lock);
- errout:
- return err;
- }
- static int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
- {
- struct net *net = sock_net(skb->sk);
- int family, tidx, nidx = 0;
- int tbl_skip = cb->args[0];
- int neigh_skip = cb->args[1];
- struct neigh_table *tbl;
- family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
- for (tidx = 0; tidx < NEIGH_NR_TABLES; tidx++) {
- struct neigh_parms *p;
- tbl = neigh_tables[tidx];
- if (!tbl)
- continue;
- if (tidx < tbl_skip || (family && tbl->family != family))
- continue;
- if (neightbl_fill_info(skb, tbl, NETLINK_CB(cb->skb).portid,
- cb->nlh->nlmsg_seq, RTM_NEWNEIGHTBL,
- NLM_F_MULTI) < 0)
- break;
- nidx = 0;
- p = list_next_entry(&tbl->parms, list);
- list_for_each_entry_from(p, &tbl->parms_list, list) {
- if (!net_eq(neigh_parms_net(p), net))
- continue;
- if (nidx < neigh_skip)
- goto next;
- if (neightbl_fill_param_info(skb, tbl, p,
- NETLINK_CB(cb->skb).portid,
- cb->nlh->nlmsg_seq,
- RTM_NEWNEIGHTBL,
- NLM_F_MULTI) < 0)
- goto out;
- next:
- nidx++;
- }
- neigh_skip = 0;
- }
- out:
- cb->args[0] = tidx;
- cb->args[1] = nidx;
- return skb->len;
- }
- static int neigh_fill_info(struct sk_buff *skb, struct neighbour *neigh,
- u32 pid, u32 seq, int type, unsigned int flags)
- {
- unsigned long now = jiffies;
- struct nda_cacheinfo ci;
- struct nlmsghdr *nlh;
- struct ndmsg *ndm;
- nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
- if (nlh == NULL)
- return -EMSGSIZE;
- ndm = nlmsg_data(nlh);
- ndm->ndm_family = neigh->ops->family;
- ndm->ndm_pad1 = 0;
- ndm->ndm_pad2 = 0;
- ndm->ndm_flags = neigh->flags;
- ndm->ndm_type = neigh->type;
- ndm->ndm_ifindex = neigh->dev->ifindex;
- if (nla_put(skb, NDA_DST, neigh->tbl->key_len, neigh->primary_key))
- goto nla_put_failure;
- read_lock_bh(&neigh->lock);
- ndm->ndm_state = neigh->nud_state;
- if (neigh->nud_state & NUD_VALID) {
- char haddr[MAX_ADDR_LEN];
- neigh_ha_snapshot(haddr, neigh, neigh->dev);
- if (nla_put(skb, NDA_LLADDR, neigh->dev->addr_len, haddr) < 0) {
- read_unlock_bh(&neigh->lock);
- goto nla_put_failure;
- }
- }
- ci.ndm_used = jiffies_to_clock_t(now - neigh->used);
- ci.ndm_confirmed = jiffies_to_clock_t(now - neigh->confirmed);
- ci.ndm_updated = jiffies_to_clock_t(now - neigh->updated);
- ci.ndm_refcnt = atomic_read(&neigh->refcnt) - 1;
- read_unlock_bh(&neigh->lock);
- if (nla_put_u32(skb, NDA_PROBES, atomic_read(&neigh->probes)) ||
- nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
- goto nla_put_failure;
- nlmsg_end(skb, nlh);
- return 0;
- nla_put_failure:
- nlmsg_cancel(skb, nlh);
- return -EMSGSIZE;
- }
- static int pneigh_fill_info(struct sk_buff *skb, struct pneigh_entry *pn,
- u32 pid, u32 seq, int type, unsigned int flags,
- struct neigh_table *tbl)
- {
- struct nlmsghdr *nlh;
- struct ndmsg *ndm;
- nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), flags);
- if (nlh == NULL)
- return -EMSGSIZE;
- ndm = nlmsg_data(nlh);
- ndm->ndm_family = tbl->family;
- ndm->ndm_pad1 = 0;
- ndm->ndm_pad2 = 0;
- ndm->ndm_flags = pn->flags | NTF_PROXY;
- ndm->ndm_type = RTN_UNICAST;
- ndm->ndm_ifindex = pn->dev ? pn->dev->ifindex : 0;
- ndm->ndm_state = NUD_NONE;
- if (nla_put(skb, NDA_DST, tbl->key_len, pn->key))
- goto nla_put_failure;
- nlmsg_end(skb, nlh);
- return 0;
- nla_put_failure:
- nlmsg_cancel(skb, nlh);
- return -EMSGSIZE;
- }
- static void neigh_update_notify(struct neighbour *neigh)
- {
- call_netevent_notifiers(NETEVENT_NEIGH_UPDATE, neigh);
- __neigh_notify(neigh, RTM_NEWNEIGH, 0);
- }
- static bool neigh_master_filtered(struct net_device *dev, int master_idx)
- {
- struct net_device *master;
- if (!master_idx)
- return false;
- master = netdev_master_upper_dev_get(dev);
- if (!master || master->ifindex != master_idx)
- return true;
- return false;
- }
- static bool neigh_ifindex_filtered(struct net_device *dev, int filter_idx)
- {
- if (filter_idx && dev->ifindex != filter_idx)
- return true;
- return false;
- }
- static int neigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
- struct netlink_callback *cb)
- {
- struct net *net = sock_net(skb->sk);
- const struct nlmsghdr *nlh = cb->nlh;
- struct nlattr *tb[NDA_MAX + 1];
- struct neighbour *n;
- int rc, h, s_h = cb->args[1];
- int idx, s_idx = idx = cb->args[2];
- struct neigh_hash_table *nht;
- int filter_master_idx = 0, filter_idx = 0;
- unsigned int flags = NLM_F_MULTI;
- int err;
- err = nlmsg_parse(nlh, sizeof(struct ndmsg), tb, NDA_MAX, NULL);
- if (!err) {
- if (tb[NDA_IFINDEX]) {
- if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
- return -EINVAL;
- filter_idx = nla_get_u32(tb[NDA_IFINDEX]);
- }
- if (tb[NDA_MASTER]) {
- if (nla_len(tb[NDA_MASTER]) != sizeof(u32))
- return -EINVAL;
- filter_master_idx = nla_get_u32(tb[NDA_MASTER]);
- }
- if (filter_idx || filter_master_idx)
- flags |= NLM_F_DUMP_FILTERED;
- }
- rcu_read_lock_bh();
- nht = rcu_dereference_bh(tbl->nht);
- for (h = s_h; h < (1 << nht->hash_shift); h++) {
- if (h > s_h)
- s_idx = 0;
- for (n = rcu_dereference_bh(nht->hash_buckets[h]), idx = 0;
- n != NULL;
- n = rcu_dereference_bh(n->next)) {
- if (!net_eq(dev_net(n->dev), net))
- continue;
- if (neigh_ifindex_filtered(n->dev, filter_idx))
- continue;
- if (neigh_master_filtered(n->dev, filter_master_idx))
- continue;
- if (idx < s_idx)
- goto next;
- if (neigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
- cb->nlh->nlmsg_seq,
- RTM_NEWNEIGH,
- flags) < 0) {
- rc = -1;
- goto out;
- }
- next:
- idx++;
- }
- }
- rc = skb->len;
- out:
- rcu_read_unlock_bh();
- cb->args[1] = h;
- cb->args[2] = idx;
- return rc;
- }
- static int pneigh_dump_table(struct neigh_table *tbl, struct sk_buff *skb,
- struct netlink_callback *cb)
- {
- struct pneigh_entry *n;
- struct net *net = sock_net(skb->sk);
- int rc, h, s_h = cb->args[3];
- int idx, s_idx = idx = cb->args[4];
- read_lock_bh(&tbl->lock);
- for (h = s_h; h <= PNEIGH_HASHMASK; h++) {
- if (h > s_h)
- s_idx = 0;
- for (n = tbl->phash_buckets[h], idx = 0; n; n = n->next) {
- if (pneigh_net(n) != net)
- continue;
- if (idx < s_idx)
- goto next;
- if (pneigh_fill_info(skb, n, NETLINK_CB(cb->skb).portid,
- cb->nlh->nlmsg_seq,
- RTM_NEWNEIGH,
- NLM_F_MULTI, tbl) < 0) {
- read_unlock_bh(&tbl->lock);
- rc = -1;
- goto out;
- }
- next:
- idx++;
- }
- }
- read_unlock_bh(&tbl->lock);
- rc = skb->len;
- out:
- cb->args[3] = h;
- cb->args[4] = idx;
- return rc;
- }
- static int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb)
- {
- struct neigh_table *tbl;
- int t, family, s_t;
- int proxy = 0;
- int err;
- family = ((struct rtgenmsg *) nlmsg_data(cb->nlh))->rtgen_family;
- /* check for full ndmsg structure presence, family member is
- * the same for both structures
- */
- if (nlmsg_len(cb->nlh) >= sizeof(struct ndmsg) &&
- ((struct ndmsg *) nlmsg_data(cb->nlh))->ndm_flags == NTF_PROXY)
- proxy = 1;
- s_t = cb->args[0];
- for (t = 0; t < NEIGH_NR_TABLES; t++) {
- tbl = neigh_tables[t];
- if (!tbl)
- continue;
- if (t < s_t || (family && tbl->family != family))
- continue;
- if (t > s_t)
- memset(&cb->args[1], 0, sizeof(cb->args) -
- sizeof(cb->args[0]));
- if (proxy)
- err = pneigh_dump_table(tbl, skb, cb);
- else
- err = neigh_dump_table(tbl, skb, cb);
- if (err < 0)
- break;
- }
- cb->args[0] = t;
- return skb->len;
- }
- void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie)
- {
- int chain;
- struct neigh_hash_table *nht;
- rcu_read_lock_bh();
- nht = rcu_dereference_bh(tbl->nht);
- read_lock(&tbl->lock); /* avoid resizes */
- for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
- struct neighbour *n;
- for (n = rcu_dereference_bh(nht->hash_buckets[chain]);
- n != NULL;
- n = rcu_dereference_bh(n->next))
- cb(n, cookie);
- }
- read_unlock(&tbl->lock);
- rcu_read_unlock_bh();
- }
- EXPORT_SYMBOL(neigh_for_each);
- /* The tbl->lock must be held as a writer and BH disabled. */
- void __neigh_for_each_release(struct neigh_table *tbl,
- int (*cb)(struct neighbour *))
- {
- int chain;
- struct neigh_hash_table *nht;
- nht = rcu_dereference_protected(tbl->nht,
- lockdep_is_held(&tbl->lock));
- for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
- struct neighbour *n;
- struct neighbour __rcu **np;
- np = &nht->hash_buckets[chain];
- while ((n = rcu_dereference_protected(*np,
- lockdep_is_held(&tbl->lock))) != NULL) {
- int release;
- write_lock(&n->lock);
- release = cb(n);
- if (release) {
- rcu_assign_pointer(*np,
- rcu_dereference_protected(n->next,
- lockdep_is_held(&tbl->lock)));
- n->dead = 1;
- } else
- np = &n->next;
- write_unlock(&n->lock);
- if (release)
- neigh_cleanup_and_release(n);
- }
- }
- }
- EXPORT_SYMBOL(__neigh_for_each_release);
- int neigh_xmit(int index, struct net_device *dev,
- const void *addr, struct sk_buff *skb)
- {
- int err = -EAFNOSUPPORT;
- if (likely(index < NEIGH_NR_TABLES)) {
- struct neigh_table *tbl;
- struct neighbour *neigh;
- tbl = neigh_tables[index];
- if (!tbl)
- goto out;
- rcu_read_lock_bh();
- neigh = __neigh_lookup_noref(tbl, addr, dev);
- if (!neigh)
- neigh = __neigh_create(tbl, addr, dev, false);
- err = PTR_ERR(neigh);
- if (IS_ERR(neigh)) {
- rcu_read_unlock_bh();
- goto out_kfree_skb;
- }
- err = neigh->output(neigh, skb);
- rcu_read_unlock_bh();
- }
- else if (index == NEIGH_LINK_TABLE) {
- err = dev_hard_header(skb, dev, ntohs(skb->protocol),
- addr, NULL, skb->len);
- if (err < 0)
- goto out_kfree_skb;
- err = dev_queue_xmit(skb);
- }
- out:
- return err;
- out_kfree_skb:
- kfree_skb(skb);
- goto out;
- }
- EXPORT_SYMBOL(neigh_xmit);
- #ifdef CONFIG_PROC_FS
- static struct neighbour *neigh_get_first(struct seq_file *seq)
- {
- struct neigh_seq_state *state = seq->private;
- struct net *net = seq_file_net(seq);
- struct neigh_hash_table *nht = state->nht;
- struct neighbour *n = NULL;
- int bucket = state->bucket;
- state->flags &= ~NEIGH_SEQ_IS_PNEIGH;
- for (bucket = 0; bucket < (1 << nht->hash_shift); bucket++) {
- n = rcu_dereference_bh(nht->hash_buckets[bucket]);
- while (n) {
- if (!net_eq(dev_net(n->dev), net))
- goto next;
- if (state->neigh_sub_iter) {
- loff_t fakep = 0;
- void *v;
- v = state->neigh_sub_iter(state, n, &fakep);
- if (!v)
- goto next;
- }
- if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
- break;
- if (n->nud_state & ~NUD_NOARP)
- break;
- next:
- n = rcu_dereference_bh(n->next);
- }
- if (n)
- break;
- }
- state->bucket = bucket;
- return n;
- }
- static struct neighbour *neigh_get_next(struct seq_file *seq,
- struct neighbour *n,
- loff_t *pos)
- {
- struct neigh_seq_state *state = seq->private;
- struct net *net = seq_file_net(seq);
- struct neigh_hash_table *nht = state->nht;
- if (state->neigh_sub_iter) {
- void *v = state->neigh_sub_iter(state, n, pos);
- if (v)
- return n;
- }
- n = rcu_dereference_bh(n->next);
- while (1) {
- while (n) {
- if (!net_eq(dev_net(n->dev), net))
- goto next;
- if (state->neigh_sub_iter) {
- void *v = state->neigh_sub_iter(state, n, pos);
- if (v)
- return n;
- goto next;
- }
- if (!(state->flags & NEIGH_SEQ_SKIP_NOARP))
- break;
- if (n->nud_state & ~NUD_NOARP)
- break;
- next:
- n = rcu_dereference_bh(n->next);
- }
- if (n)
- break;
- if (++state->bucket >= (1 << nht->hash_shift))
- break;
- n = rcu_dereference_bh(nht->hash_buckets[state->bucket]);
- }
- if (n && pos)
- --(*pos);
- return n;
- }
- static struct neighbour *neigh_get_idx(struct seq_file *seq, loff_t *pos)
- {
- struct neighbour *n = neigh_get_first(seq);
- if (n) {
- --(*pos);
- while (*pos) {
- n = neigh_get_next(seq, n, pos);
- if (!n)
- break;
- }
- }
- return *pos ? NULL : n;
- }
- static struct pneigh_entry *pneigh_get_first(struct seq_file *seq)
- {
- struct neigh_seq_state *state = seq->private;
- struct net *net = seq_file_net(seq);
- struct neigh_table *tbl = state->tbl;
- struct pneigh_entry *pn = NULL;
- int bucket = state->bucket;
- state->flags |= NEIGH_SEQ_IS_PNEIGH;
- for (bucket = 0; bucket <= PNEIGH_HASHMASK; bucket++) {
- pn = tbl->phash_buckets[bucket];
- while (pn && !net_eq(pneigh_net(pn), net))
- pn = pn->next;
- if (pn)
- break;
- }
- state->bucket = bucket;
- return pn;
- }
- static struct pneigh_entry *pneigh_get_next(struct seq_file *seq,
- struct pneigh_entry *pn,
- loff_t *pos)
- {
- struct neigh_seq_state *state = seq->private;
- struct net *net = seq_file_net(seq);
- struct neigh_table *tbl = state->tbl;
- do {
- pn = pn->next;
- } while (pn && !net_eq(pneigh_net(pn), net));
- while (!pn) {
- if (++state->bucket > PNEIGH_HASHMASK)
- break;
- pn = tbl->phash_buckets[state->bucket];
- while (pn && !net_eq(pneigh_net(pn), net))
- pn = pn->next;
- if (pn)
- break;
- }
- if (pn && pos)
- --(*pos);
- return pn;
- }
- static struct pneigh_entry *pneigh_get_idx(struct seq_file *seq, loff_t *pos)
- {
- struct pneigh_entry *pn = pneigh_get_first(seq);
- if (pn) {
- --(*pos);
- while (*pos) {
- pn = pneigh_get_next(seq, pn, pos);
- if (!pn)
- break;
- }
- }
- return *pos ? NULL : pn;
- }
- static void *neigh_get_idx_any(struct seq_file *seq, loff_t *pos)
- {
- struct neigh_seq_state *state = seq->private;
- void *rc;
- loff_t idxpos = *pos;
- rc = neigh_get_idx(seq, &idxpos);
- if (!rc && !(state->flags & NEIGH_SEQ_NEIGH_ONLY))
- rc = pneigh_get_idx(seq, &idxpos);
- return rc;
- }
- void *neigh_seq_start(struct seq_file *seq, loff_t *pos, struct neigh_table *tbl, unsigned int neigh_seq_flags)
- __acquires(rcu_bh)
- {
- struct neigh_seq_state *state = seq->private;
- state->tbl = tbl;
- state->bucket = 0;
- state->flags = (neigh_seq_flags & ~NEIGH_SEQ_IS_PNEIGH);
- rcu_read_lock_bh();
- state->nht = rcu_dereference_bh(tbl->nht);
- return *pos ? neigh_get_idx_any(seq, pos) : SEQ_START_TOKEN;
- }
- EXPORT_SYMBOL(neigh_seq_start);
- void *neigh_seq_next(struct seq_file *seq, void *v, loff_t *pos)
- {
- struct neigh_seq_state *state;
- void *rc;
- if (v == SEQ_START_TOKEN) {
- rc = neigh_get_first(seq);
- goto out;
- }
- state = seq->private;
- if (!(state->flags & NEIGH_SEQ_IS_PNEIGH)) {
- rc = neigh_get_next(seq, v, NULL);
- if (rc)
- goto out;
- if (!(state->flags & NEIGH_SEQ_NEIGH_ONLY))
- rc = pneigh_get_first(seq);
- } else {
- BUG_ON(state->flags & NEIGH_SEQ_NEIGH_ONLY);
- rc = pneigh_get_next(seq, v, NULL);
- }
- out:
- ++(*pos);
- return rc;
- }
- EXPORT_SYMBOL(neigh_seq_next);
- void neigh_seq_stop(struct seq_file *seq, void *v)
- __releases(rcu_bh)
- {
- rcu_read_unlock_bh();
- }
- EXPORT_SYMBOL(neigh_seq_stop);
- /* statistics via seq_file */
- static void *neigh_stat_seq_start(struct seq_file *seq, loff_t *pos)
- {
- struct neigh_table *tbl = seq->private;
- int cpu;
- if (*pos == 0)
- return SEQ_START_TOKEN;
- for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {
- if (!cpu_possible(cpu))
- continue;
- *pos = cpu+1;
- return per_cpu_ptr(tbl->stats, cpu);
- }
- return NULL;
- }
- static void *neigh_stat_seq_next(struct seq_file *seq, void *v, loff_t *pos)
- {
- struct neigh_table *tbl = seq->private;
- int cpu;
- for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {
- if (!cpu_possible(cpu))
- continue;
- *pos = cpu+1;
- return per_cpu_ptr(tbl->stats, cpu);
- }
- return NULL;
- }
- static void neigh_stat_seq_stop(struct seq_file *seq, void *v)
- {
- }
- static int neigh_stat_seq_show(struct seq_file *seq, void *v)
- {
- struct neigh_table *tbl = seq->private;
- struct neigh_statistics *st = v;
- if (v == SEQ_START_TOKEN) {
- seq_printf(seq, "entries allocs destroys hash_grows lookups hits res_failed rcv_probes_mcast rcv_probes_ucast periodic_gc_runs forced_gc_runs unresolved_discards table_fulls\n");
- return 0;
- }
- seq_printf(seq, "%08x %08lx %08lx %08lx %08lx %08lx %08lx "
- "%08lx %08lx %08lx %08lx %08lx %08lx\n",
- atomic_read(&tbl->entries),
- st->allocs,
- st->destroys,
- st->hash_grows,
- st->lookups,
- st->hits,
- st->res_failed,
- st->rcv_probes_mcast,
- st->rcv_probes_ucast,
- st->periodic_gc_runs,
- st->forced_gc_runs,
- st->unres_discards,
- st->table_fulls
- );
- return 0;
- }
- static const struct seq_operations neigh_stat_seq_ops = {
- .start = neigh_stat_seq_start,
- .next = neigh_stat_seq_next,
- .stop = neigh_stat_seq_stop,
- .show = neigh_stat_seq_show,
- };
- static int neigh_stat_seq_open(struct inode *inode, struct file *file)
- {
- int ret = seq_open(file, &neigh_stat_seq_ops);
- if (!ret) {
- struct seq_file *sf = file->private_data;
- sf->private = PDE_DATA(inode);
- }
- return ret;
- };
- static const struct file_operations neigh_stat_seq_fops = {
- .owner = THIS_MODULE,
- .open = neigh_stat_seq_open,
- .read = seq_read,
- .llseek = seq_lseek,
- .release = seq_release,
- };
- #endif /* CONFIG_PROC_FS */
- static inline size_t neigh_nlmsg_size(void)
- {
- return NLMSG_ALIGN(sizeof(struct ndmsg))
- + nla_total_size(MAX_ADDR_LEN) /* NDA_DST */
- + nla_total_size(MAX_ADDR_LEN) /* NDA_LLADDR */
- + nla_total_size(sizeof(struct nda_cacheinfo))
- + nla_total_size(4); /* NDA_PROBES */
- }
- static void __neigh_notify(struct neighbour *n, int type, int flags)
- {
- struct net *net = dev_net(n->dev);
- struct sk_buff *skb;
- int err = -ENOBUFS;
- skb = nlmsg_new(neigh_nlmsg_size(), GFP_ATOMIC);
- if (skb == NULL)
- goto errout;
- err = neigh_fill_info(skb, n, 0, 0, type, flags);
- if (err < 0) {
- /* -EMSGSIZE implies BUG in neigh_nlmsg_size() */
- WARN_ON(err == -EMSGSIZE);
- kfree_skb(skb);
- goto errout;
- }
- rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
- return;
- errout:
- if (err < 0)
- rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
- }
- void neigh_app_ns(struct neighbour *n)
- {
- __neigh_notify(n, RTM_GETNEIGH, NLM_F_REQUEST);
- }
- EXPORT_SYMBOL(neigh_app_ns);
- #ifdef CONFIG_SYSCTL
- static int zero;
- static int int_max = INT_MAX;
- static int unres_qlen_max = INT_MAX / SKB_TRUESIZE(ETH_FRAME_LEN);
- static int proc_unres_qlen(struct ctl_table *ctl, int write,
- void __user *buffer, size_t *lenp, loff_t *ppos)
- {
- int size, ret;
- struct ctl_table tmp = *ctl;
- tmp.extra1 = &zero;
- tmp.extra2 = &unres_qlen_max;
- tmp.data = &size;
- size = *(int *)ctl->data / SKB_TRUESIZE(ETH_FRAME_LEN);
- ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
- if (write && !ret)
- *(int *)ctl->data = size * SKB_TRUESIZE(ETH_FRAME_LEN);
- return ret;
- }
- static struct neigh_parms *neigh_get_dev_parms_rcu(struct net_device *dev,
- int family)
- {
- switch (family) {
- case AF_INET:
- return __in_dev_arp_parms_get_rcu(dev);
- case AF_INET6:
- return __in6_dev_nd_parms_get_rcu(dev);
- }
- return NULL;
- }
- static void neigh_copy_dflt_parms(struct net *net, struct neigh_parms *p,
- int index)
- {
- struct net_device *dev;
- int family = neigh_parms_family(p);
- rcu_read_lock();
- for_each_netdev_rcu(net, dev) {
- struct neigh_parms *dst_p =
- neigh_get_dev_parms_rcu(dev, family);
- if (dst_p && !test_bit(index, dst_p->data_state))
- dst_p->data[index] = p->data[index];
- }
- rcu_read_unlock();
- }
- static void neigh_proc_update(struct ctl_table *ctl, int write)
- {
- struct net_device *dev = ctl->extra1;
- struct neigh_parms *p = ctl->extra2;
- struct net *net = neigh_parms_net(p);
- int index = (int *) ctl->data - p->data;
- if (!write)
- return;
- set_bit(index, p->data_state);
- if (!dev) /* NULL dev means this is default value */
- neigh_copy_dflt_parms(net, p, index);
- }
- static int neigh_proc_dointvec_zero_intmax(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- struct ctl_table tmp = *ctl;
- int ret;
- tmp.extra1 = &zero;
- tmp.extra2 = &int_max;
- ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- int neigh_proc_dointvec(struct ctl_table *ctl, int write,
- void __user *buffer, size_t *lenp, loff_t *ppos)
- {
- int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- EXPORT_SYMBOL(neigh_proc_dointvec);
- int neigh_proc_dointvec_jiffies(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- int ret = proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- EXPORT_SYMBOL(neigh_proc_dointvec_jiffies);
- static int neigh_proc_dointvec_userhz_jiffies(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- int ret = proc_dointvec_userhz_jiffies(ctl, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- int neigh_proc_dointvec_ms_jiffies(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- int ret = proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- EXPORT_SYMBOL(neigh_proc_dointvec_ms_jiffies);
- static int neigh_proc_dointvec_unres_qlen(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- int ret = proc_unres_qlen(ctl, write, buffer, lenp, ppos);
- neigh_proc_update(ctl, write);
- return ret;
- }
- static int neigh_proc_base_reachable_time(struct ctl_table *ctl, int write,
- void __user *buffer,
- size_t *lenp, loff_t *ppos)
- {
- struct neigh_parms *p = ctl->extra2;
- int ret;
- if (strcmp(ctl->procname, "base_reachable_time") == 0)
- ret = neigh_proc_dointvec_jiffies(ctl, write, buffer, lenp, ppos);
- else if (strcmp(ctl->procname, "base_reachable_time_ms") == 0)
- ret = neigh_proc_dointvec_ms_jiffies(ctl, write, buffer, lenp, ppos);
- else
- ret = -1;
- if (write && ret == 0) {
- /* update reachable_time as well, otherwise, the change will
- * only be effective after the next time neigh_periodic_work
- * decides to recompute it
- */
- p->reachable_time =
- neigh_rand_reach_time(NEIGH_VAR(p, BASE_REACHABLE_TIME));
- }
- return ret;
- }
- #define NEIGH_PARMS_DATA_OFFSET(index) \
- (&((struct neigh_parms *) 0)->data[index])
- #define NEIGH_SYSCTL_ENTRY(attr, data_attr, name, mval, proc) \
- [NEIGH_VAR_ ## attr] = { \
- .procname = name, \
- .data = NEIGH_PARMS_DATA_OFFSET(NEIGH_VAR_ ## data_attr), \
- .maxlen = sizeof(int), \
- .mode = mval, \
- .proc_handler = proc, \
- }
- #define NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_zero_intmax)
- #define NEIGH_SYSCTL_JIFFIES_ENTRY(attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_jiffies)
- #define NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_userhz_jiffies)
- #define NEIGH_SYSCTL_MS_JIFFIES_ENTRY(attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
- #define NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(attr, data_attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_ms_jiffies)
- #define NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(attr, data_attr, name) \
- NEIGH_SYSCTL_ENTRY(attr, data_attr, name, 0644, neigh_proc_dointvec_unres_qlen)
- static struct neigh_sysctl_table {
- struct ctl_table_header *sysctl_header;
- struct ctl_table neigh_vars[NEIGH_VAR_MAX + 1];
- } neigh_sysctl_template __read_mostly = {
- .neigh_vars = {
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_PROBES, "mcast_solicit"),
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(UCAST_PROBES, "ucast_solicit"),
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(APP_PROBES, "app_solicit"),
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(MCAST_REPROBES, "mcast_resolicit"),
- NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(RETRANS_TIME, "retrans_time"),
- NEIGH_SYSCTL_JIFFIES_ENTRY(BASE_REACHABLE_TIME, "base_reachable_time"),
- NEIGH_SYSCTL_JIFFIES_ENTRY(DELAY_PROBE_TIME, "delay_first_probe_time"),
- NEIGH_SYSCTL_JIFFIES_ENTRY(GC_STALETIME, "gc_stale_time"),
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(QUEUE_LEN_BYTES, "unres_qlen_bytes"),
- NEIGH_SYSCTL_ZERO_INTMAX_ENTRY(PROXY_QLEN, "proxy_qlen"),
- NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(ANYCAST_DELAY, "anycast_delay"),
- NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(PROXY_DELAY, "proxy_delay"),
- NEIGH_SYSCTL_USERHZ_JIFFIES_ENTRY(LOCKTIME, "locktime"),
- NEIGH_SYSCTL_UNRES_QLEN_REUSED_ENTRY(QUEUE_LEN, QUEUE_LEN_BYTES, "unres_qlen"),
- NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(RETRANS_TIME_MS, RETRANS_TIME, "retrans_time_ms"),
- NEIGH_SYSCTL_MS_JIFFIES_REUSED_ENTRY(BASE_REACHABLE_TIME_MS, BASE_REACHABLE_TIME, "base_reachable_time_ms"),
- [NEIGH_VAR_GC_INTERVAL] = {
- .procname = "gc_interval",
- .maxlen = sizeof(int),
- .mode = 0644,
- .proc_handler = proc_dointvec_jiffies,
- },
- [NEIGH_VAR_GC_THRESH1] = {
- .procname = "gc_thresh1",
- .maxlen = sizeof(int),
- .mode = 0644,
- .extra1 = &zero,
- .extra2 = &int_max,
- .proc_handler = proc_dointvec_minmax,
- },
- [NEIGH_VAR_GC_THRESH2] = {
- .procname = "gc_thresh2",
- .maxlen = sizeof(int),
- .mode = 0644,
- .extra1 = &zero,
- .extra2 = &int_max,
- .proc_handler = proc_dointvec_minmax,
- },
- [NEIGH_VAR_GC_THRESH3] = {
- .procname = "gc_thresh3",
- .maxlen = sizeof(int),
- .mode = 0644,
- .extra1 = &zero,
- .extra2 = &int_max,
- .proc_handler = proc_dointvec_minmax,
- },
- {},
- },
- };
- int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
- proc_handler *handler)
- {
- int i;
- struct neigh_sysctl_table *t;
- const char *dev_name_source;
- char neigh_path[ sizeof("net//neigh/") + IFNAMSIZ + IFNAMSIZ ];
- char *p_name;
- t = kmemdup(&neigh_sysctl_template, sizeof(*t), GFP_KERNEL);
- if (!t)
- goto err;
- for (i = 0; i < NEIGH_VAR_GC_INTERVAL; i++) {
- t->neigh_vars[i].data += (long) p;
- t->neigh_vars[i].extra1 = dev;
- t->neigh_vars[i].extra2 = p;
- }
- if (dev) {
- dev_name_source = dev->name;
- /* Terminate the table early */
- memset(&t->neigh_vars[NEIGH_VAR_GC_INTERVAL], 0,
- sizeof(t->neigh_vars[NEIGH_VAR_GC_INTERVAL]));
- } else {
- struct neigh_table *tbl = p->tbl;
- dev_name_source = "default";
- t->neigh_vars[NEIGH_VAR_GC_INTERVAL].data = &tbl->gc_interval;
- t->neigh_vars[NEIGH_VAR_GC_THRESH1].data = &tbl->gc_thresh1;
- t->neigh_vars[NEIGH_VAR_GC_THRESH2].data = &tbl->gc_thresh2;
- t->neigh_vars[NEIGH_VAR_GC_THRESH3].data = &tbl->gc_thresh3;
- }
- if (handler) {
- /* RetransTime */
- t->neigh_vars[NEIGH_VAR_RETRANS_TIME].proc_handler = handler;
- /* ReachableTime */
- t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler = handler;
- /* RetransTime (in milliseconds)*/
- t->neigh_vars[NEIGH_VAR_RETRANS_TIME_MS].proc_handler = handler;
- /* ReachableTime (in milliseconds) */
- t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler = handler;
- } else {
- /* Those handlers will update p->reachable_time after
- * base_reachable_time(_ms) is set to ensure the new timer starts being
- * applied after the next neighbour update instead of waiting for
- * neigh_periodic_work to update its value (can be multiple minutes)
- * So any handler that replaces them should do this as well
- */
- /* ReachableTime */
- t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME].proc_handler =
- neigh_proc_base_reachable_time;
- /* ReachableTime (in milliseconds) */
- t->neigh_vars[NEIGH_VAR_BASE_REACHABLE_TIME_MS].proc_handler =
- neigh_proc_base_reachable_time;
- }
- /* Don't export sysctls to unprivileged users */
- if (neigh_parms_net(p)->user_ns != &init_user_ns)
- t->neigh_vars[0].procname = NULL;
- switch (neigh_parms_family(p)) {
- case AF_INET:
- p_name = "ipv4";
- break;
- case AF_INET6:
- p_name = "ipv6";
- break;
- default:
- BUG();
- }
- snprintf(neigh_path, sizeof(neigh_path), "net/%s/neigh/%s",
- p_name, dev_name_source);
- t->sysctl_header =
- register_net_sysctl(neigh_parms_net(p), neigh_path, t->neigh_vars);
- if (!t->sysctl_header)
- goto free;
- p->sysctl_table = t;
- return 0;
- free:
- kfree(t);
- err:
- return -ENOBUFS;
- }
- EXPORT_SYMBOL(neigh_sysctl_register);
- void neigh_sysctl_unregister(struct neigh_parms *p)
- {
- if (p->sysctl_table) {
- struct neigh_sysctl_table *t = p->sysctl_table;
- p->sysctl_table = NULL;
- unregister_net_sysctl_table(t->sysctl_header);
- kfree(t);
- }
- }
- EXPORT_SYMBOL(neigh_sysctl_unregister);
- #endif /* CONFIG_SYSCTL */
- static int __init neigh_init(void)
- {
- rtnl_register(PF_UNSPEC, RTM_NEWNEIGH, neigh_add, NULL, NULL);
- rtnl_register(PF_UNSPEC, RTM_DELNEIGH, neigh_delete, NULL, NULL);
- rtnl_register(PF_UNSPEC, RTM_GETNEIGH, NULL, neigh_dump_info, NULL);
- rtnl_register(PF_UNSPEC, RTM_GETNEIGHTBL, NULL, neightbl_dump_info,
- NULL);
- rtnl_register(PF_UNSPEC, RTM_SETNEIGHTBL, neightbl_set, NULL, NULL);
- return 0;
- }
- subsys_initcall(neigh_init);
|