rtnetlink.c 137 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280528152825283528452855286528752885289529052915292529352945295529652975298529953005301530253035304530553065307530853095310531153125313531453155316531753185319532053215322532353245325532653275328532953305331533253335334533553365337533853395340534153425343534453455346534753485349535053515352535353545355535653575358535953605361536253635364536553665367536853695370537153725373537453755376537753785379538053815382538353845385538653875388538953905391539253935394539553965397539853995400540154025403540454055406540754085409541054115412541354145415541654175418541954205421542254235424542554265427542854295430543154325433543454355436543754385439544054415442544354445445544654475448544954505451545254535454545554565457545854595460546154625463546454655466546754685469547054715472547354745475547654775478547954805481548254835484548554865487548854895490549154925493549454955496549754985499550055015502550355045505550655075508550955105511551255135514551555165517551855195520552155225523552455255526552755285529553055315532553355345535553655375538553955405541554255435544554555465547554855495550555155525553555455555556555755585559556055615562556355645565556655675568556955705571557255735574557555765577557855795580558155825583558455855586558755885589559055915592559355945595559655975598559956005601560256035604560556065607560856095610561156125613561456155616561756185619562056215622562356245625562656275628562956305631563256335634563556365637563856395640564156425643564456455646564756485649565056515652565356545655565656575658565956605661566256635664566556665667566856695670567156725673567456755676567756785679568056815682568356845685568656875688568956905691569256935694569556965697569856995700570157025703570457055706
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * INET An implementation of the TCP/IP protocol suite for the LINUX
  4. * operating system. INET is implemented using the BSD Socket
  5. * interface as the means of communication with the user level.
  6. *
  7. * Routing netlink socket interface: protocol independent part.
  8. *
  9. * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10. *
  11. * Fixes:
  12. * Vitaly E. Lavrov RTA_OK arithmetics was wrong.
  13. */
  14. #include <linux/bitops.h>
  15. #include <linux/errno.h>
  16. #include <linux/module.h>
  17. #include <linux/types.h>
  18. #include <linux/socket.h>
  19. #include <linux/kernel.h>
  20. #include <linux/timer.h>
  21. #include <linux/string.h>
  22. #include <linux/sockios.h>
  23. #include <linux/net.h>
  24. #include <linux/fcntl.h>
  25. #include <linux/mm.h>
  26. #include <linux/slab.h>
  27. #include <linux/interrupt.h>
  28. #include <linux/capability.h>
  29. #include <linux/skbuff.h>
  30. #include <linux/init.h>
  31. #include <linux/security.h>
  32. #include <linux/mutex.h>
  33. #include <linux/if_addr.h>
  34. #include <linux/if_bridge.h>
  35. #include <linux/if_vlan.h>
  36. #include <linux/pci.h>
  37. #include <linux/etherdevice.h>
  38. #include <linux/bpf.h>
  39. #include <linux/uaccess.h>
  40. #include <linux/inet.h>
  41. #include <linux/netdevice.h>
  42. #include <net/ip.h>
  43. #include <net/protocol.h>
  44. #include <net/arp.h>
  45. #include <net/route.h>
  46. #include <net/udp.h>
  47. #include <net/tcp.h>
  48. #include <net/sock.h>
  49. #include <net/pkt_sched.h>
  50. #include <net/fib_rules.h>
  51. #include <net/rtnetlink.h>
  52. #include <net/net_namespace.h>
  53. #define RTNL_MAX_TYPE 50
  54. #define RTNL_SLAVE_MAX_TYPE 36
  55. struct rtnl_link {
  56. rtnl_doit_func doit;
  57. rtnl_dumpit_func dumpit;
  58. struct module *owner;
  59. unsigned int flags;
  60. struct rcu_head rcu;
  61. };
  62. static DEFINE_MUTEX(rtnl_mutex);
  63. void rtnl_lock(void)
  64. {
  65. mutex_lock(&rtnl_mutex);
  66. }
  67. EXPORT_SYMBOL(rtnl_lock);
  68. int rtnl_lock_killable(void)
  69. {
  70. return mutex_lock_killable(&rtnl_mutex);
  71. }
  72. EXPORT_SYMBOL(rtnl_lock_killable);
  73. static struct sk_buff *defer_kfree_skb_list;
  74. void rtnl_kfree_skbs(struct sk_buff *head, struct sk_buff *tail)
  75. {
  76. if (head && tail) {
  77. tail->next = defer_kfree_skb_list;
  78. defer_kfree_skb_list = head;
  79. }
  80. }
  81. EXPORT_SYMBOL(rtnl_kfree_skbs);
  82. void __rtnl_unlock(void)
  83. {
  84. struct sk_buff *head = defer_kfree_skb_list;
  85. defer_kfree_skb_list = NULL;
  86. mutex_unlock(&rtnl_mutex);
  87. while (head) {
  88. struct sk_buff *next = head->next;
  89. kfree_skb(head);
  90. cond_resched();
  91. head = next;
  92. }
  93. }
  94. void rtnl_unlock(void)
  95. {
  96. /* This fellow will unlock it for us. */
  97. netdev_run_todo();
  98. }
  99. EXPORT_SYMBOL(rtnl_unlock);
  100. int rtnl_trylock(void)
  101. {
  102. return mutex_trylock(&rtnl_mutex);
  103. }
  104. EXPORT_SYMBOL(rtnl_trylock);
  105. int rtnl_is_locked(void)
  106. {
  107. return mutex_is_locked(&rtnl_mutex);
  108. }
  109. EXPORT_SYMBOL(rtnl_is_locked);
  110. bool refcount_dec_and_rtnl_lock(refcount_t *r)
  111. {
  112. return refcount_dec_and_mutex_lock(r, &rtnl_mutex);
  113. }
  114. EXPORT_SYMBOL(refcount_dec_and_rtnl_lock);
  115. #ifdef CONFIG_PROVE_LOCKING
  116. bool lockdep_rtnl_is_held(void)
  117. {
  118. return lockdep_is_held(&rtnl_mutex);
  119. }
  120. EXPORT_SYMBOL(lockdep_rtnl_is_held);
  121. #endif /* #ifdef CONFIG_PROVE_LOCKING */
  122. static struct rtnl_link *__rcu *rtnl_msg_handlers[RTNL_FAMILY_MAX + 1];
  123. static inline int rtm_msgindex(int msgtype)
  124. {
  125. int msgindex = msgtype - RTM_BASE;
  126. /*
  127. * msgindex < 0 implies someone tried to register a netlink
  128. * control code. msgindex >= RTM_NR_MSGTYPES may indicate that
  129. * the message type has not been added to linux/rtnetlink.h
  130. */
  131. BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
  132. return msgindex;
  133. }
  134. static struct rtnl_link *rtnl_get_link(int protocol, int msgtype)
  135. {
  136. struct rtnl_link **tab;
  137. if (protocol >= ARRAY_SIZE(rtnl_msg_handlers))
  138. protocol = PF_UNSPEC;
  139. tab = rcu_dereference_rtnl(rtnl_msg_handlers[protocol]);
  140. if (!tab)
  141. tab = rcu_dereference_rtnl(rtnl_msg_handlers[PF_UNSPEC]);
  142. return tab[msgtype];
  143. }
  144. static int rtnl_register_internal(struct module *owner,
  145. int protocol, int msgtype,
  146. rtnl_doit_func doit, rtnl_dumpit_func dumpit,
  147. unsigned int flags)
  148. {
  149. struct rtnl_link *link, *old;
  150. struct rtnl_link __rcu **tab;
  151. int msgindex;
  152. int ret = -ENOBUFS;
  153. BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
  154. msgindex = rtm_msgindex(msgtype);
  155. rtnl_lock();
  156. tab = rtnl_msg_handlers[protocol];
  157. if (tab == NULL) {
  158. tab = kcalloc(RTM_NR_MSGTYPES, sizeof(void *), GFP_KERNEL);
  159. if (!tab)
  160. goto unlock;
  161. /* ensures we see the 0 stores */
  162. rcu_assign_pointer(rtnl_msg_handlers[protocol], tab);
  163. }
  164. old = rtnl_dereference(tab[msgindex]);
  165. if (old) {
  166. link = kmemdup(old, sizeof(*old), GFP_KERNEL);
  167. if (!link)
  168. goto unlock;
  169. } else {
  170. link = kzalloc(sizeof(*link), GFP_KERNEL);
  171. if (!link)
  172. goto unlock;
  173. }
  174. WARN_ON(link->owner && link->owner != owner);
  175. link->owner = owner;
  176. WARN_ON(doit && link->doit && link->doit != doit);
  177. if (doit)
  178. link->doit = doit;
  179. WARN_ON(dumpit && link->dumpit && link->dumpit != dumpit);
  180. if (dumpit)
  181. link->dumpit = dumpit;
  182. link->flags |= flags;
  183. /* publish protocol:msgtype */
  184. rcu_assign_pointer(tab[msgindex], link);
  185. ret = 0;
  186. if (old)
  187. kfree_rcu(old, rcu);
  188. unlock:
  189. rtnl_unlock();
  190. return ret;
  191. }
  192. /**
  193. * rtnl_register_module - Register a rtnetlink message type
  194. *
  195. * @owner: module registering the hook (THIS_MODULE)
  196. * @protocol: Protocol family or PF_UNSPEC
  197. * @msgtype: rtnetlink message type
  198. * @doit: Function pointer called for each request message
  199. * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
  200. * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions
  201. *
  202. * Like rtnl_register, but for use by removable modules.
  203. */
  204. int rtnl_register_module(struct module *owner,
  205. int protocol, int msgtype,
  206. rtnl_doit_func doit, rtnl_dumpit_func dumpit,
  207. unsigned int flags)
  208. {
  209. return rtnl_register_internal(owner, protocol, msgtype,
  210. doit, dumpit, flags);
  211. }
  212. EXPORT_SYMBOL_GPL(rtnl_register_module);
  213. /**
  214. * rtnl_register - Register a rtnetlink message type
  215. * @protocol: Protocol family or PF_UNSPEC
  216. * @msgtype: rtnetlink message type
  217. * @doit: Function pointer called for each request message
  218. * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
  219. * @flags: rtnl_link_flags to modifiy behaviour of doit/dumpit functions
  220. *
  221. * Registers the specified function pointers (at least one of them has
  222. * to be non-NULL) to be called whenever a request message for the
  223. * specified protocol family and message type is received.
  224. *
  225. * The special protocol family PF_UNSPEC may be used to define fallback
  226. * function pointers for the case when no entry for the specific protocol
  227. * family exists.
  228. */
  229. void rtnl_register(int protocol, int msgtype,
  230. rtnl_doit_func doit, rtnl_dumpit_func dumpit,
  231. unsigned int flags)
  232. {
  233. int err;
  234. err = rtnl_register_internal(NULL, protocol, msgtype, doit, dumpit,
  235. flags);
  236. if (err)
  237. pr_err("Unable to register rtnetlink message handler, "
  238. "protocol = %d, message type = %d\n", protocol, msgtype);
  239. }
  240. /**
  241. * rtnl_unregister - Unregister a rtnetlink message type
  242. * @protocol: Protocol family or PF_UNSPEC
  243. * @msgtype: rtnetlink message type
  244. *
  245. * Returns 0 on success or a negative error code.
  246. */
  247. int rtnl_unregister(int protocol, int msgtype)
  248. {
  249. struct rtnl_link **tab, *link;
  250. int msgindex;
  251. BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
  252. msgindex = rtm_msgindex(msgtype);
  253. rtnl_lock();
  254. tab = rtnl_dereference(rtnl_msg_handlers[protocol]);
  255. if (!tab) {
  256. rtnl_unlock();
  257. return -ENOENT;
  258. }
  259. link = tab[msgindex];
  260. rcu_assign_pointer(tab[msgindex], NULL);
  261. rtnl_unlock();
  262. kfree_rcu(link, rcu);
  263. return 0;
  264. }
  265. EXPORT_SYMBOL_GPL(rtnl_unregister);
  266. /**
  267. * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
  268. * @protocol : Protocol family or PF_UNSPEC
  269. *
  270. * Identical to calling rtnl_unregster() for all registered message types
  271. * of a certain protocol family.
  272. */
  273. void rtnl_unregister_all(int protocol)
  274. {
  275. struct rtnl_link **tab, *link;
  276. int msgindex;
  277. BUG_ON(protocol < 0 || protocol > RTNL_FAMILY_MAX);
  278. rtnl_lock();
  279. tab = rtnl_msg_handlers[protocol];
  280. if (!tab) {
  281. rtnl_unlock();
  282. return;
  283. }
  284. RCU_INIT_POINTER(rtnl_msg_handlers[protocol], NULL);
  285. for (msgindex = 0; msgindex < RTM_NR_MSGTYPES; msgindex++) {
  286. link = tab[msgindex];
  287. if (!link)
  288. continue;
  289. rcu_assign_pointer(tab[msgindex], NULL);
  290. kfree_rcu(link, rcu);
  291. }
  292. rtnl_unlock();
  293. synchronize_net();
  294. kfree(tab);
  295. }
  296. EXPORT_SYMBOL_GPL(rtnl_unregister_all);
  297. static LIST_HEAD(link_ops);
  298. static const struct rtnl_link_ops *rtnl_link_ops_get(const char *kind)
  299. {
  300. const struct rtnl_link_ops *ops;
  301. list_for_each_entry(ops, &link_ops, list) {
  302. if (!strcmp(ops->kind, kind))
  303. return ops;
  304. }
  305. return NULL;
  306. }
  307. /**
  308. * __rtnl_link_register - Register rtnl_link_ops with rtnetlink.
  309. * @ops: struct rtnl_link_ops * to register
  310. *
  311. * The caller must hold the rtnl_mutex. This function should be used
  312. * by drivers that create devices during module initialization. It
  313. * must be called before registering the devices.
  314. *
  315. * Returns 0 on success or a negative error code.
  316. */
  317. int __rtnl_link_register(struct rtnl_link_ops *ops)
  318. {
  319. if (rtnl_link_ops_get(ops->kind))
  320. return -EEXIST;
  321. /* The check for setup is here because if ops
  322. * does not have that filled up, it is not possible
  323. * to use the ops for creating device. So do not
  324. * fill up dellink as well. That disables rtnl_dellink.
  325. */
  326. if (ops->setup && !ops->dellink)
  327. ops->dellink = unregister_netdevice_queue;
  328. list_add_tail(&ops->list, &link_ops);
  329. return 0;
  330. }
  331. EXPORT_SYMBOL_GPL(__rtnl_link_register);
  332. /**
  333. * rtnl_link_register - Register rtnl_link_ops with rtnetlink.
  334. * @ops: struct rtnl_link_ops * to register
  335. *
  336. * Returns 0 on success or a negative error code.
  337. */
  338. int rtnl_link_register(struct rtnl_link_ops *ops)
  339. {
  340. int err;
  341. /* Sanity-check max sizes to avoid stack buffer overflow. */
  342. if (WARN_ON(ops->maxtype > RTNL_MAX_TYPE ||
  343. ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE))
  344. return -EINVAL;
  345. rtnl_lock();
  346. err = __rtnl_link_register(ops);
  347. rtnl_unlock();
  348. return err;
  349. }
  350. EXPORT_SYMBOL_GPL(rtnl_link_register);
  351. static void __rtnl_kill_links(struct net *net, struct rtnl_link_ops *ops)
  352. {
  353. struct net_device *dev;
  354. LIST_HEAD(list_kill);
  355. for_each_netdev(net, dev) {
  356. if (dev->rtnl_link_ops == ops)
  357. ops->dellink(dev, &list_kill);
  358. }
  359. unregister_netdevice_many(&list_kill);
  360. }
  361. /**
  362. * __rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
  363. * @ops: struct rtnl_link_ops * to unregister
  364. *
  365. * The caller must hold the rtnl_mutex and guarantee net_namespace_list
  366. * integrity (hold pernet_ops_rwsem for writing to close the race
  367. * with setup_net() and cleanup_net()).
  368. */
  369. void __rtnl_link_unregister(struct rtnl_link_ops *ops)
  370. {
  371. struct net *net;
  372. for_each_net(net) {
  373. __rtnl_kill_links(net, ops);
  374. }
  375. list_del(&ops->list);
  376. }
  377. EXPORT_SYMBOL_GPL(__rtnl_link_unregister);
  378. /* Return with the rtnl_lock held when there are no network
  379. * devices unregistering in any network namespace.
  380. */
  381. static void rtnl_lock_unregistering_all(void)
  382. {
  383. struct net *net;
  384. bool unregistering;
  385. DEFINE_WAIT_FUNC(wait, woken_wake_function);
  386. add_wait_queue(&netdev_unregistering_wq, &wait);
  387. for (;;) {
  388. unregistering = false;
  389. rtnl_lock();
  390. /* We held write locked pernet_ops_rwsem, and parallel
  391. * setup_net() and cleanup_net() are not possible.
  392. */
  393. for_each_net(net) {
  394. if (net->dev_unreg_count > 0) {
  395. unregistering = true;
  396. break;
  397. }
  398. }
  399. if (!unregistering)
  400. break;
  401. __rtnl_unlock();
  402. wait_woken(&wait, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  403. }
  404. remove_wait_queue(&netdev_unregistering_wq, &wait);
  405. }
  406. /**
  407. * rtnl_link_unregister - Unregister rtnl_link_ops from rtnetlink.
  408. * @ops: struct rtnl_link_ops * to unregister
  409. */
  410. void rtnl_link_unregister(struct rtnl_link_ops *ops)
  411. {
  412. /* Close the race with setup_net() and cleanup_net() */
  413. down_write(&pernet_ops_rwsem);
  414. rtnl_lock_unregistering_all();
  415. __rtnl_link_unregister(ops);
  416. rtnl_unlock();
  417. up_write(&pernet_ops_rwsem);
  418. }
  419. EXPORT_SYMBOL_GPL(rtnl_link_unregister);
  420. static size_t rtnl_link_get_slave_info_data_size(const struct net_device *dev)
  421. {
  422. struct net_device *master_dev;
  423. const struct rtnl_link_ops *ops;
  424. size_t size = 0;
  425. rcu_read_lock();
  426. master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
  427. if (!master_dev)
  428. goto out;
  429. ops = master_dev->rtnl_link_ops;
  430. if (!ops || !ops->get_slave_size)
  431. goto out;
  432. /* IFLA_INFO_SLAVE_DATA + nested data */
  433. size = nla_total_size(sizeof(struct nlattr)) +
  434. ops->get_slave_size(master_dev, dev);
  435. out:
  436. rcu_read_unlock();
  437. return size;
  438. }
  439. static size_t rtnl_link_get_size(const struct net_device *dev)
  440. {
  441. const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
  442. size_t size;
  443. if (!ops)
  444. return 0;
  445. size = nla_total_size(sizeof(struct nlattr)) + /* IFLA_LINKINFO */
  446. nla_total_size(strlen(ops->kind) + 1); /* IFLA_INFO_KIND */
  447. if (ops->get_size)
  448. /* IFLA_INFO_DATA + nested data */
  449. size += nla_total_size(sizeof(struct nlattr)) +
  450. ops->get_size(dev);
  451. if (ops->get_xstats_size)
  452. /* IFLA_INFO_XSTATS */
  453. size += nla_total_size(ops->get_xstats_size(dev));
  454. size += rtnl_link_get_slave_info_data_size(dev);
  455. return size;
  456. }
  457. static LIST_HEAD(rtnl_af_ops);
  458. static const struct rtnl_af_ops *rtnl_af_lookup(const int family)
  459. {
  460. const struct rtnl_af_ops *ops;
  461. list_for_each_entry_rcu(ops, &rtnl_af_ops, list) {
  462. if (ops->family == family)
  463. return ops;
  464. }
  465. return NULL;
  466. }
  467. /**
  468. * rtnl_af_register - Register rtnl_af_ops with rtnetlink.
  469. * @ops: struct rtnl_af_ops * to register
  470. *
  471. * Returns 0 on success or a negative error code.
  472. */
  473. void rtnl_af_register(struct rtnl_af_ops *ops)
  474. {
  475. rtnl_lock();
  476. list_add_tail_rcu(&ops->list, &rtnl_af_ops);
  477. rtnl_unlock();
  478. }
  479. EXPORT_SYMBOL_GPL(rtnl_af_register);
  480. /**
  481. * rtnl_af_unregister - Unregister rtnl_af_ops from rtnetlink.
  482. * @ops: struct rtnl_af_ops * to unregister
  483. */
  484. void rtnl_af_unregister(struct rtnl_af_ops *ops)
  485. {
  486. rtnl_lock();
  487. list_del_rcu(&ops->list);
  488. rtnl_unlock();
  489. synchronize_rcu();
  490. }
  491. EXPORT_SYMBOL_GPL(rtnl_af_unregister);
  492. static size_t rtnl_link_get_af_size(const struct net_device *dev,
  493. u32 ext_filter_mask)
  494. {
  495. struct rtnl_af_ops *af_ops;
  496. size_t size;
  497. /* IFLA_AF_SPEC */
  498. size = nla_total_size(sizeof(struct nlattr));
  499. rcu_read_lock();
  500. list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
  501. if (af_ops->get_link_af_size) {
  502. /* AF_* + nested data */
  503. size += nla_total_size(sizeof(struct nlattr)) +
  504. af_ops->get_link_af_size(dev, ext_filter_mask);
  505. }
  506. }
  507. rcu_read_unlock();
  508. return size;
  509. }
  510. static bool rtnl_have_link_slave_info(const struct net_device *dev)
  511. {
  512. struct net_device *master_dev;
  513. bool ret = false;
  514. rcu_read_lock();
  515. master_dev = netdev_master_upper_dev_get_rcu((struct net_device *)dev);
  516. if (master_dev && master_dev->rtnl_link_ops)
  517. ret = true;
  518. rcu_read_unlock();
  519. return ret;
  520. }
  521. static int rtnl_link_slave_info_fill(struct sk_buff *skb,
  522. const struct net_device *dev)
  523. {
  524. struct net_device *master_dev;
  525. const struct rtnl_link_ops *ops;
  526. struct nlattr *slave_data;
  527. int err;
  528. master_dev = netdev_master_upper_dev_get((struct net_device *) dev);
  529. if (!master_dev)
  530. return 0;
  531. ops = master_dev->rtnl_link_ops;
  532. if (!ops)
  533. return 0;
  534. if (nla_put_string(skb, IFLA_INFO_SLAVE_KIND, ops->kind) < 0)
  535. return -EMSGSIZE;
  536. if (ops->fill_slave_info) {
  537. slave_data = nla_nest_start_noflag(skb, IFLA_INFO_SLAVE_DATA);
  538. if (!slave_data)
  539. return -EMSGSIZE;
  540. err = ops->fill_slave_info(skb, master_dev, dev);
  541. if (err < 0)
  542. goto err_cancel_slave_data;
  543. nla_nest_end(skb, slave_data);
  544. }
  545. return 0;
  546. err_cancel_slave_data:
  547. nla_nest_cancel(skb, slave_data);
  548. return err;
  549. }
  550. static int rtnl_link_info_fill(struct sk_buff *skb,
  551. const struct net_device *dev)
  552. {
  553. const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
  554. struct nlattr *data;
  555. int err;
  556. if (!ops)
  557. return 0;
  558. if (nla_put_string(skb, IFLA_INFO_KIND, ops->kind) < 0)
  559. return -EMSGSIZE;
  560. if (ops->fill_xstats) {
  561. err = ops->fill_xstats(skb, dev);
  562. if (err < 0)
  563. return err;
  564. }
  565. if (ops->fill_info) {
  566. data = nla_nest_start_noflag(skb, IFLA_INFO_DATA);
  567. if (data == NULL)
  568. return -EMSGSIZE;
  569. err = ops->fill_info(skb, dev);
  570. if (err < 0)
  571. goto err_cancel_data;
  572. nla_nest_end(skb, data);
  573. }
  574. return 0;
  575. err_cancel_data:
  576. nla_nest_cancel(skb, data);
  577. return err;
  578. }
  579. static int rtnl_link_fill(struct sk_buff *skb, const struct net_device *dev)
  580. {
  581. struct nlattr *linkinfo;
  582. int err = -EMSGSIZE;
  583. linkinfo = nla_nest_start_noflag(skb, IFLA_LINKINFO);
  584. if (linkinfo == NULL)
  585. goto out;
  586. err = rtnl_link_info_fill(skb, dev);
  587. if (err < 0)
  588. goto err_cancel_link;
  589. err = rtnl_link_slave_info_fill(skb, dev);
  590. if (err < 0)
  591. goto err_cancel_link;
  592. nla_nest_end(skb, linkinfo);
  593. return 0;
  594. err_cancel_link:
  595. nla_nest_cancel(skb, linkinfo);
  596. out:
  597. return err;
  598. }
  599. int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigned int group, int echo)
  600. {
  601. struct sock *rtnl = net->rtnl;
  602. int err = 0;
  603. NETLINK_CB(skb).dst_group = group;
  604. if (echo)
  605. refcount_inc(&skb->users);
  606. netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL);
  607. if (echo)
  608. err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT);
  609. return err;
  610. }
  611. int rtnl_unicast(struct sk_buff *skb, struct net *net, u32 pid)
  612. {
  613. struct sock *rtnl = net->rtnl;
  614. return nlmsg_unicast(rtnl, skb, pid);
  615. }
  616. EXPORT_SYMBOL(rtnl_unicast);
  617. void rtnl_notify(struct sk_buff *skb, struct net *net, u32 pid, u32 group,
  618. struct nlmsghdr *nlh, gfp_t flags)
  619. {
  620. struct sock *rtnl = net->rtnl;
  621. int report = 0;
  622. if (nlh)
  623. report = nlmsg_report(nlh);
  624. nlmsg_notify(rtnl, skb, pid, group, report, flags);
  625. }
  626. EXPORT_SYMBOL(rtnl_notify);
  627. void rtnl_set_sk_err(struct net *net, u32 group, int error)
  628. {
  629. struct sock *rtnl = net->rtnl;
  630. netlink_set_err(rtnl, 0, group, error);
  631. }
  632. EXPORT_SYMBOL(rtnl_set_sk_err);
  633. int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
  634. {
  635. struct nlattr *mx;
  636. int i, valid = 0;
  637. /* nothing is dumped for dst_default_metrics, so just skip the loop */
  638. if (metrics == dst_default_metrics.metrics)
  639. return 0;
  640. mx = nla_nest_start_noflag(skb, RTA_METRICS);
  641. if (mx == NULL)
  642. return -ENOBUFS;
  643. for (i = 0; i < RTAX_MAX; i++) {
  644. if (metrics[i]) {
  645. if (i == RTAX_CC_ALGO - 1) {
  646. char tmp[TCP_CA_NAME_MAX], *name;
  647. name = tcp_ca_get_name_by_key(metrics[i], tmp);
  648. if (!name)
  649. continue;
  650. if (nla_put_string(skb, i + 1, name))
  651. goto nla_put_failure;
  652. } else if (i == RTAX_FEATURES - 1) {
  653. u32 user_features = metrics[i] & RTAX_FEATURE_MASK;
  654. if (!user_features)
  655. continue;
  656. BUILD_BUG_ON(RTAX_FEATURE_MASK & DST_FEATURE_MASK);
  657. if (nla_put_u32(skb, i + 1, user_features))
  658. goto nla_put_failure;
  659. } else {
  660. if (nla_put_u32(skb, i + 1, metrics[i]))
  661. goto nla_put_failure;
  662. }
  663. valid++;
  664. }
  665. }
  666. if (!valid) {
  667. nla_nest_cancel(skb, mx);
  668. return 0;
  669. }
  670. return nla_nest_end(skb, mx);
  671. nla_put_failure:
  672. nla_nest_cancel(skb, mx);
  673. return -EMSGSIZE;
  674. }
  675. EXPORT_SYMBOL(rtnetlink_put_metrics);
  676. int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
  677. long expires, u32 error)
  678. {
  679. struct rta_cacheinfo ci = {
  680. .rta_error = error,
  681. .rta_id = id,
  682. };
  683. if (dst) {
  684. ci.rta_lastuse = jiffies_delta_to_clock_t(jiffies - dst->lastuse);
  685. ci.rta_used = dst->__use;
  686. ci.rta_clntref = atomic_read(&dst->__refcnt);
  687. }
  688. if (expires) {
  689. unsigned long clock;
  690. clock = jiffies_to_clock_t(abs(expires));
  691. clock = min_t(unsigned long, clock, INT_MAX);
  692. ci.rta_expires = (expires > 0) ? clock : -clock;
  693. }
  694. return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
  695. }
  696. EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
  697. static void set_operstate(struct net_device *dev, unsigned char transition)
  698. {
  699. unsigned char operstate = dev->operstate;
  700. switch (transition) {
  701. case IF_OPER_UP:
  702. if ((operstate == IF_OPER_DORMANT ||
  703. operstate == IF_OPER_TESTING ||
  704. operstate == IF_OPER_UNKNOWN) &&
  705. !netif_dormant(dev) && !netif_testing(dev))
  706. operstate = IF_OPER_UP;
  707. break;
  708. case IF_OPER_TESTING:
  709. if (operstate == IF_OPER_UP ||
  710. operstate == IF_OPER_UNKNOWN)
  711. operstate = IF_OPER_TESTING;
  712. break;
  713. case IF_OPER_DORMANT:
  714. if (operstate == IF_OPER_UP ||
  715. operstate == IF_OPER_UNKNOWN)
  716. operstate = IF_OPER_DORMANT;
  717. break;
  718. }
  719. if (dev->operstate != operstate) {
  720. write_lock_bh(&dev_base_lock);
  721. dev->operstate = operstate;
  722. write_unlock_bh(&dev_base_lock);
  723. netdev_state_change(dev);
  724. }
  725. }
  726. static unsigned int rtnl_dev_get_flags(const struct net_device *dev)
  727. {
  728. return (dev->flags & ~(IFF_PROMISC | IFF_ALLMULTI)) |
  729. (dev->gflags & (IFF_PROMISC | IFF_ALLMULTI));
  730. }
  731. static unsigned int rtnl_dev_combine_flags(const struct net_device *dev,
  732. const struct ifinfomsg *ifm)
  733. {
  734. unsigned int flags = ifm->ifi_flags;
  735. /* bugwards compatibility: ifi_change == 0 is treated as ~0 */
  736. if (ifm->ifi_change)
  737. flags = (flags & ifm->ifi_change) |
  738. (rtnl_dev_get_flags(dev) & ~ifm->ifi_change);
  739. return flags;
  740. }
  741. static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
  742. const struct rtnl_link_stats64 *b)
  743. {
  744. a->rx_packets = b->rx_packets;
  745. a->tx_packets = b->tx_packets;
  746. a->rx_bytes = b->rx_bytes;
  747. a->tx_bytes = b->tx_bytes;
  748. a->rx_errors = b->rx_errors;
  749. a->tx_errors = b->tx_errors;
  750. a->rx_dropped = b->rx_dropped;
  751. a->tx_dropped = b->tx_dropped;
  752. a->multicast = b->multicast;
  753. a->collisions = b->collisions;
  754. a->rx_length_errors = b->rx_length_errors;
  755. a->rx_over_errors = b->rx_over_errors;
  756. a->rx_crc_errors = b->rx_crc_errors;
  757. a->rx_frame_errors = b->rx_frame_errors;
  758. a->rx_fifo_errors = b->rx_fifo_errors;
  759. a->rx_missed_errors = b->rx_missed_errors;
  760. a->tx_aborted_errors = b->tx_aborted_errors;
  761. a->tx_carrier_errors = b->tx_carrier_errors;
  762. a->tx_fifo_errors = b->tx_fifo_errors;
  763. a->tx_heartbeat_errors = b->tx_heartbeat_errors;
  764. a->tx_window_errors = b->tx_window_errors;
  765. a->rx_compressed = b->rx_compressed;
  766. a->tx_compressed = b->tx_compressed;
  767. a->rx_nohandler = b->rx_nohandler;
  768. }
  769. /* All VF info */
  770. static inline int rtnl_vfinfo_size(const struct net_device *dev,
  771. u32 ext_filter_mask)
  772. {
  773. if (dev->dev.parent && (ext_filter_mask & RTEXT_FILTER_VF)) {
  774. int num_vfs = dev_num_vf(dev->dev.parent);
  775. size_t size = nla_total_size(0);
  776. size += num_vfs *
  777. (nla_total_size(0) +
  778. nla_total_size(sizeof(struct ifla_vf_mac)) +
  779. nla_total_size(sizeof(struct ifla_vf_broadcast)) +
  780. nla_total_size(sizeof(struct ifla_vf_vlan)) +
  781. nla_total_size(0) + /* nest IFLA_VF_VLAN_LIST */
  782. nla_total_size(MAX_VLAN_LIST_LEN *
  783. sizeof(struct ifla_vf_vlan_info)) +
  784. nla_total_size(sizeof(struct ifla_vf_spoofchk)) +
  785. nla_total_size(sizeof(struct ifla_vf_tx_rate)) +
  786. nla_total_size(sizeof(struct ifla_vf_rate)) +
  787. nla_total_size(sizeof(struct ifla_vf_link_state)) +
  788. nla_total_size(sizeof(struct ifla_vf_rss_query_en)) +
  789. nla_total_size(0) + /* nest IFLA_VF_STATS */
  790. /* IFLA_VF_STATS_RX_PACKETS */
  791. nla_total_size_64bit(sizeof(__u64)) +
  792. /* IFLA_VF_STATS_TX_PACKETS */
  793. nla_total_size_64bit(sizeof(__u64)) +
  794. /* IFLA_VF_STATS_RX_BYTES */
  795. nla_total_size_64bit(sizeof(__u64)) +
  796. /* IFLA_VF_STATS_TX_BYTES */
  797. nla_total_size_64bit(sizeof(__u64)) +
  798. /* IFLA_VF_STATS_BROADCAST */
  799. nla_total_size_64bit(sizeof(__u64)) +
  800. /* IFLA_VF_STATS_MULTICAST */
  801. nla_total_size_64bit(sizeof(__u64)) +
  802. /* IFLA_VF_STATS_RX_DROPPED */
  803. nla_total_size_64bit(sizeof(__u64)) +
  804. /* IFLA_VF_STATS_TX_DROPPED */
  805. nla_total_size_64bit(sizeof(__u64)) +
  806. nla_total_size(sizeof(struct ifla_vf_trust)));
  807. return size;
  808. } else
  809. return 0;
  810. }
  811. static size_t rtnl_port_size(const struct net_device *dev,
  812. u32 ext_filter_mask)
  813. {
  814. size_t port_size = nla_total_size(4) /* PORT_VF */
  815. + nla_total_size(PORT_PROFILE_MAX) /* PORT_PROFILE */
  816. + nla_total_size(PORT_UUID_MAX) /* PORT_INSTANCE_UUID */
  817. + nla_total_size(PORT_UUID_MAX) /* PORT_HOST_UUID */
  818. + nla_total_size(1) /* PROT_VDP_REQUEST */
  819. + nla_total_size(2); /* PORT_VDP_RESPONSE */
  820. size_t vf_ports_size = nla_total_size(sizeof(struct nlattr));
  821. size_t vf_port_size = nla_total_size(sizeof(struct nlattr))
  822. + port_size;
  823. size_t port_self_size = nla_total_size(sizeof(struct nlattr))
  824. + port_size;
  825. if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
  826. !(ext_filter_mask & RTEXT_FILTER_VF))
  827. return 0;
  828. if (dev_num_vf(dev->dev.parent))
  829. return port_self_size + vf_ports_size +
  830. vf_port_size * dev_num_vf(dev->dev.parent);
  831. else
  832. return port_self_size;
  833. }
  834. static size_t rtnl_xdp_size(void)
  835. {
  836. size_t xdp_size = nla_total_size(0) + /* nest IFLA_XDP */
  837. nla_total_size(1) + /* XDP_ATTACHED */
  838. nla_total_size(4) + /* XDP_PROG_ID (or 1st mode) */
  839. nla_total_size(4); /* XDP_<mode>_PROG_ID */
  840. return xdp_size;
  841. }
  842. static size_t rtnl_prop_list_size(const struct net_device *dev)
  843. {
  844. struct netdev_name_node *name_node;
  845. size_t size;
  846. if (list_empty(&dev->name_node->list))
  847. return 0;
  848. size = nla_total_size(0);
  849. list_for_each_entry(name_node, &dev->name_node->list, list)
  850. size += nla_total_size(ALTIFNAMSIZ);
  851. return size;
  852. }
  853. static size_t rtnl_proto_down_size(const struct net_device *dev)
  854. {
  855. size_t size = nla_total_size(1);
  856. if (dev->proto_down_reason)
  857. size += nla_total_size(0) + nla_total_size(4);
  858. return size;
  859. }
  860. static noinline size_t if_nlmsg_size(const struct net_device *dev,
  861. u32 ext_filter_mask)
  862. {
  863. return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  864. + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
  865. + nla_total_size(IFALIASZ) /* IFLA_IFALIAS */
  866. + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
  867. + nla_total_size_64bit(sizeof(struct rtnl_link_ifmap))
  868. + nla_total_size(sizeof(struct rtnl_link_stats))
  869. + nla_total_size_64bit(sizeof(struct rtnl_link_stats64))
  870. + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  871. + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
  872. + nla_total_size(4) /* IFLA_TXQLEN */
  873. + nla_total_size(4) /* IFLA_WEIGHT */
  874. + nla_total_size(4) /* IFLA_MTU */
  875. + nla_total_size(4) /* IFLA_LINK */
  876. + nla_total_size(4) /* IFLA_MASTER */
  877. + nla_total_size(1) /* IFLA_CARRIER */
  878. + nla_total_size(4) /* IFLA_PROMISCUITY */
  879. + nla_total_size(4) /* IFLA_NUM_TX_QUEUES */
  880. + nla_total_size(4) /* IFLA_NUM_RX_QUEUES */
  881. + nla_total_size(4) /* IFLA_GSO_MAX_SEGS */
  882. + nla_total_size(4) /* IFLA_GSO_MAX_SIZE */
  883. + nla_total_size(1) /* IFLA_OPERSTATE */
  884. + nla_total_size(1) /* IFLA_LINKMODE */
  885. + nla_total_size(4) /* IFLA_CARRIER_CHANGES */
  886. + nla_total_size(4) /* IFLA_LINK_NETNSID */
  887. + nla_total_size(4) /* IFLA_GROUP */
  888. + nla_total_size(ext_filter_mask
  889. & RTEXT_FILTER_VF ? 4 : 0) /* IFLA_NUM_VF */
  890. + rtnl_vfinfo_size(dev, ext_filter_mask) /* IFLA_VFINFO_LIST */
  891. + rtnl_port_size(dev, ext_filter_mask) /* IFLA_VF_PORTS + IFLA_PORT_SELF */
  892. + rtnl_link_get_size(dev) /* IFLA_LINKINFO */
  893. + rtnl_link_get_af_size(dev, ext_filter_mask) /* IFLA_AF_SPEC */
  894. + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_PORT_ID */
  895. + nla_total_size(MAX_PHYS_ITEM_ID_LEN) /* IFLA_PHYS_SWITCH_ID */
  896. + nla_total_size(IFNAMSIZ) /* IFLA_PHYS_PORT_NAME */
  897. + rtnl_xdp_size() /* IFLA_XDP */
  898. + nla_total_size(4) /* IFLA_EVENT */
  899. + nla_total_size(4) /* IFLA_NEW_NETNSID */
  900. + nla_total_size(4) /* IFLA_NEW_IFINDEX */
  901. + rtnl_proto_down_size(dev) /* proto down */
  902. + nla_total_size(4) /* IFLA_TARGET_NETNSID */
  903. + nla_total_size(4) /* IFLA_CARRIER_UP_COUNT */
  904. + nla_total_size(4) /* IFLA_CARRIER_DOWN_COUNT */
  905. + nla_total_size(4) /* IFLA_MIN_MTU */
  906. + nla_total_size(4) /* IFLA_MAX_MTU */
  907. + rtnl_prop_list_size(dev)
  908. + nla_total_size(MAX_ADDR_LEN) /* IFLA_PERM_ADDRESS */
  909. + 0;
  910. }
  911. static int rtnl_vf_ports_fill(struct sk_buff *skb, struct net_device *dev)
  912. {
  913. struct nlattr *vf_ports;
  914. struct nlattr *vf_port;
  915. int vf;
  916. int err;
  917. vf_ports = nla_nest_start_noflag(skb, IFLA_VF_PORTS);
  918. if (!vf_ports)
  919. return -EMSGSIZE;
  920. for (vf = 0; vf < dev_num_vf(dev->dev.parent); vf++) {
  921. vf_port = nla_nest_start_noflag(skb, IFLA_VF_PORT);
  922. if (!vf_port)
  923. goto nla_put_failure;
  924. if (nla_put_u32(skb, IFLA_PORT_VF, vf))
  925. goto nla_put_failure;
  926. err = dev->netdev_ops->ndo_get_vf_port(dev, vf, skb);
  927. if (err == -EMSGSIZE)
  928. goto nla_put_failure;
  929. if (err) {
  930. nla_nest_cancel(skb, vf_port);
  931. continue;
  932. }
  933. nla_nest_end(skb, vf_port);
  934. }
  935. nla_nest_end(skb, vf_ports);
  936. return 0;
  937. nla_put_failure:
  938. nla_nest_cancel(skb, vf_ports);
  939. return -EMSGSIZE;
  940. }
  941. static int rtnl_port_self_fill(struct sk_buff *skb, struct net_device *dev)
  942. {
  943. struct nlattr *port_self;
  944. int err;
  945. port_self = nla_nest_start_noflag(skb, IFLA_PORT_SELF);
  946. if (!port_self)
  947. return -EMSGSIZE;
  948. err = dev->netdev_ops->ndo_get_vf_port(dev, PORT_SELF_VF, skb);
  949. if (err) {
  950. nla_nest_cancel(skb, port_self);
  951. return (err == -EMSGSIZE) ? err : 0;
  952. }
  953. nla_nest_end(skb, port_self);
  954. return 0;
  955. }
  956. static int rtnl_port_fill(struct sk_buff *skb, struct net_device *dev,
  957. u32 ext_filter_mask)
  958. {
  959. int err;
  960. if (!dev->netdev_ops->ndo_get_vf_port || !dev->dev.parent ||
  961. !(ext_filter_mask & RTEXT_FILTER_VF))
  962. return 0;
  963. err = rtnl_port_self_fill(skb, dev);
  964. if (err)
  965. return err;
  966. if (dev_num_vf(dev->dev.parent)) {
  967. err = rtnl_vf_ports_fill(skb, dev);
  968. if (err)
  969. return err;
  970. }
  971. return 0;
  972. }
  973. static int rtnl_phys_port_id_fill(struct sk_buff *skb, struct net_device *dev)
  974. {
  975. int err;
  976. struct netdev_phys_item_id ppid;
  977. err = dev_get_phys_port_id(dev, &ppid);
  978. if (err) {
  979. if (err == -EOPNOTSUPP)
  980. return 0;
  981. return err;
  982. }
  983. if (nla_put(skb, IFLA_PHYS_PORT_ID, ppid.id_len, ppid.id))
  984. return -EMSGSIZE;
  985. return 0;
  986. }
  987. static int rtnl_phys_port_name_fill(struct sk_buff *skb, struct net_device *dev)
  988. {
  989. char name[IFNAMSIZ];
  990. int err;
  991. err = dev_get_phys_port_name(dev, name, sizeof(name));
  992. if (err) {
  993. if (err == -EOPNOTSUPP)
  994. return 0;
  995. return err;
  996. }
  997. if (nla_put_string(skb, IFLA_PHYS_PORT_NAME, name))
  998. return -EMSGSIZE;
  999. return 0;
  1000. }
  1001. static int rtnl_phys_switch_id_fill(struct sk_buff *skb, struct net_device *dev)
  1002. {
  1003. struct netdev_phys_item_id ppid = { };
  1004. int err;
  1005. err = dev_get_port_parent_id(dev, &ppid, false);
  1006. if (err) {
  1007. if (err == -EOPNOTSUPP)
  1008. return 0;
  1009. return err;
  1010. }
  1011. if (nla_put(skb, IFLA_PHYS_SWITCH_ID, ppid.id_len, ppid.id))
  1012. return -EMSGSIZE;
  1013. return 0;
  1014. }
  1015. static noinline_for_stack int rtnl_fill_stats(struct sk_buff *skb,
  1016. struct net_device *dev)
  1017. {
  1018. struct rtnl_link_stats64 *sp;
  1019. struct nlattr *attr;
  1020. attr = nla_reserve_64bit(skb, IFLA_STATS64,
  1021. sizeof(struct rtnl_link_stats64), IFLA_PAD);
  1022. if (!attr)
  1023. return -EMSGSIZE;
  1024. sp = nla_data(attr);
  1025. dev_get_stats(dev, sp);
  1026. attr = nla_reserve(skb, IFLA_STATS,
  1027. sizeof(struct rtnl_link_stats));
  1028. if (!attr)
  1029. return -EMSGSIZE;
  1030. copy_rtnl_link_stats(nla_data(attr), sp);
  1031. return 0;
  1032. }
  1033. static noinline_for_stack int rtnl_fill_vfinfo(struct sk_buff *skb,
  1034. struct net_device *dev,
  1035. int vfs_num,
  1036. struct nlattr *vfinfo)
  1037. {
  1038. struct ifla_vf_rss_query_en vf_rss_query_en;
  1039. struct nlattr *vf, *vfstats, *vfvlanlist;
  1040. struct ifla_vf_link_state vf_linkstate;
  1041. struct ifla_vf_vlan_info vf_vlan_info;
  1042. struct ifla_vf_spoofchk vf_spoofchk;
  1043. struct ifla_vf_tx_rate vf_tx_rate;
  1044. struct ifla_vf_stats vf_stats;
  1045. struct ifla_vf_trust vf_trust;
  1046. struct ifla_vf_vlan vf_vlan;
  1047. struct ifla_vf_rate vf_rate;
  1048. struct ifla_vf_mac vf_mac;
  1049. struct ifla_vf_broadcast vf_broadcast;
  1050. struct ifla_vf_info ivi;
  1051. struct ifla_vf_guid node_guid;
  1052. struct ifla_vf_guid port_guid;
  1053. memset(&ivi, 0, sizeof(ivi));
  1054. /* Not all SR-IOV capable drivers support the
  1055. * spoofcheck and "RSS query enable" query. Preset to
  1056. * -1 so the user space tool can detect that the driver
  1057. * didn't report anything.
  1058. */
  1059. ivi.spoofchk = -1;
  1060. ivi.rss_query_en = -1;
  1061. ivi.trusted = -1;
  1062. /* The default value for VF link state is "auto"
  1063. * IFLA_VF_LINK_STATE_AUTO which equals zero
  1064. */
  1065. ivi.linkstate = 0;
  1066. /* VLAN Protocol by default is 802.1Q */
  1067. ivi.vlan_proto = htons(ETH_P_8021Q);
  1068. if (dev->netdev_ops->ndo_get_vf_config(dev, vfs_num, &ivi))
  1069. return 0;
  1070. memset(&vf_vlan_info, 0, sizeof(vf_vlan_info));
  1071. memset(&node_guid, 0, sizeof(node_guid));
  1072. memset(&port_guid, 0, sizeof(port_guid));
  1073. vf_mac.vf =
  1074. vf_vlan.vf =
  1075. vf_vlan_info.vf =
  1076. vf_rate.vf =
  1077. vf_tx_rate.vf =
  1078. vf_spoofchk.vf =
  1079. vf_linkstate.vf =
  1080. vf_rss_query_en.vf =
  1081. vf_trust.vf =
  1082. node_guid.vf =
  1083. port_guid.vf = ivi.vf;
  1084. memcpy(vf_mac.mac, ivi.mac, sizeof(ivi.mac));
  1085. memcpy(vf_broadcast.broadcast, dev->broadcast, dev->addr_len);
  1086. vf_vlan.vlan = ivi.vlan;
  1087. vf_vlan.qos = ivi.qos;
  1088. vf_vlan_info.vlan = ivi.vlan;
  1089. vf_vlan_info.qos = ivi.qos;
  1090. vf_vlan_info.vlan_proto = ivi.vlan_proto;
  1091. vf_tx_rate.rate = ivi.max_tx_rate;
  1092. vf_rate.min_tx_rate = ivi.min_tx_rate;
  1093. vf_rate.max_tx_rate = ivi.max_tx_rate;
  1094. vf_spoofchk.setting = ivi.spoofchk;
  1095. vf_linkstate.link_state = ivi.linkstate;
  1096. vf_rss_query_en.setting = ivi.rss_query_en;
  1097. vf_trust.setting = ivi.trusted;
  1098. vf = nla_nest_start_noflag(skb, IFLA_VF_INFO);
  1099. if (!vf)
  1100. goto nla_put_vfinfo_failure;
  1101. if (nla_put(skb, IFLA_VF_MAC, sizeof(vf_mac), &vf_mac) ||
  1102. nla_put(skb, IFLA_VF_BROADCAST, sizeof(vf_broadcast), &vf_broadcast) ||
  1103. nla_put(skb, IFLA_VF_VLAN, sizeof(vf_vlan), &vf_vlan) ||
  1104. nla_put(skb, IFLA_VF_RATE, sizeof(vf_rate),
  1105. &vf_rate) ||
  1106. nla_put(skb, IFLA_VF_TX_RATE, sizeof(vf_tx_rate),
  1107. &vf_tx_rate) ||
  1108. nla_put(skb, IFLA_VF_SPOOFCHK, sizeof(vf_spoofchk),
  1109. &vf_spoofchk) ||
  1110. nla_put(skb, IFLA_VF_LINK_STATE, sizeof(vf_linkstate),
  1111. &vf_linkstate) ||
  1112. nla_put(skb, IFLA_VF_RSS_QUERY_EN,
  1113. sizeof(vf_rss_query_en),
  1114. &vf_rss_query_en) ||
  1115. nla_put(skb, IFLA_VF_TRUST,
  1116. sizeof(vf_trust), &vf_trust))
  1117. goto nla_put_vf_failure;
  1118. if (dev->netdev_ops->ndo_get_vf_guid &&
  1119. !dev->netdev_ops->ndo_get_vf_guid(dev, vfs_num, &node_guid,
  1120. &port_guid)) {
  1121. if (nla_put(skb, IFLA_VF_IB_NODE_GUID, sizeof(node_guid),
  1122. &node_guid) ||
  1123. nla_put(skb, IFLA_VF_IB_PORT_GUID, sizeof(port_guid),
  1124. &port_guid))
  1125. goto nla_put_vf_failure;
  1126. }
  1127. vfvlanlist = nla_nest_start_noflag(skb, IFLA_VF_VLAN_LIST);
  1128. if (!vfvlanlist)
  1129. goto nla_put_vf_failure;
  1130. if (nla_put(skb, IFLA_VF_VLAN_INFO, sizeof(vf_vlan_info),
  1131. &vf_vlan_info)) {
  1132. nla_nest_cancel(skb, vfvlanlist);
  1133. goto nla_put_vf_failure;
  1134. }
  1135. nla_nest_end(skb, vfvlanlist);
  1136. memset(&vf_stats, 0, sizeof(vf_stats));
  1137. if (dev->netdev_ops->ndo_get_vf_stats)
  1138. dev->netdev_ops->ndo_get_vf_stats(dev, vfs_num,
  1139. &vf_stats);
  1140. vfstats = nla_nest_start_noflag(skb, IFLA_VF_STATS);
  1141. if (!vfstats)
  1142. goto nla_put_vf_failure;
  1143. if (nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_PACKETS,
  1144. vf_stats.rx_packets, IFLA_VF_STATS_PAD) ||
  1145. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_PACKETS,
  1146. vf_stats.tx_packets, IFLA_VF_STATS_PAD) ||
  1147. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_BYTES,
  1148. vf_stats.rx_bytes, IFLA_VF_STATS_PAD) ||
  1149. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_BYTES,
  1150. vf_stats.tx_bytes, IFLA_VF_STATS_PAD) ||
  1151. nla_put_u64_64bit(skb, IFLA_VF_STATS_BROADCAST,
  1152. vf_stats.broadcast, IFLA_VF_STATS_PAD) ||
  1153. nla_put_u64_64bit(skb, IFLA_VF_STATS_MULTICAST,
  1154. vf_stats.multicast, IFLA_VF_STATS_PAD) ||
  1155. nla_put_u64_64bit(skb, IFLA_VF_STATS_RX_DROPPED,
  1156. vf_stats.rx_dropped, IFLA_VF_STATS_PAD) ||
  1157. nla_put_u64_64bit(skb, IFLA_VF_STATS_TX_DROPPED,
  1158. vf_stats.tx_dropped, IFLA_VF_STATS_PAD)) {
  1159. nla_nest_cancel(skb, vfstats);
  1160. goto nla_put_vf_failure;
  1161. }
  1162. nla_nest_end(skb, vfstats);
  1163. nla_nest_end(skb, vf);
  1164. return 0;
  1165. nla_put_vf_failure:
  1166. nla_nest_cancel(skb, vf);
  1167. nla_put_vfinfo_failure:
  1168. nla_nest_cancel(skb, vfinfo);
  1169. return -EMSGSIZE;
  1170. }
  1171. static noinline_for_stack int rtnl_fill_vf(struct sk_buff *skb,
  1172. struct net_device *dev,
  1173. u32 ext_filter_mask)
  1174. {
  1175. struct nlattr *vfinfo;
  1176. int i, num_vfs;
  1177. if (!dev->dev.parent || ((ext_filter_mask & RTEXT_FILTER_VF) == 0))
  1178. return 0;
  1179. num_vfs = dev_num_vf(dev->dev.parent);
  1180. if (nla_put_u32(skb, IFLA_NUM_VF, num_vfs))
  1181. return -EMSGSIZE;
  1182. if (!dev->netdev_ops->ndo_get_vf_config)
  1183. return 0;
  1184. vfinfo = nla_nest_start_noflag(skb, IFLA_VFINFO_LIST);
  1185. if (!vfinfo)
  1186. return -EMSGSIZE;
  1187. for (i = 0; i < num_vfs; i++) {
  1188. if (rtnl_fill_vfinfo(skb, dev, i, vfinfo))
  1189. return -EMSGSIZE;
  1190. }
  1191. nla_nest_end(skb, vfinfo);
  1192. return 0;
  1193. }
  1194. static int rtnl_fill_link_ifmap(struct sk_buff *skb, struct net_device *dev)
  1195. {
  1196. struct rtnl_link_ifmap map;
  1197. memset(&map, 0, sizeof(map));
  1198. map.mem_start = dev->mem_start;
  1199. map.mem_end = dev->mem_end;
  1200. map.base_addr = dev->base_addr;
  1201. map.irq = dev->irq;
  1202. map.dma = dev->dma;
  1203. map.port = dev->if_port;
  1204. if (nla_put_64bit(skb, IFLA_MAP, sizeof(map), &map, IFLA_PAD))
  1205. return -EMSGSIZE;
  1206. return 0;
  1207. }
  1208. static u32 rtnl_xdp_prog_skb(struct net_device *dev)
  1209. {
  1210. const struct bpf_prog *generic_xdp_prog;
  1211. ASSERT_RTNL();
  1212. generic_xdp_prog = rtnl_dereference(dev->xdp_prog);
  1213. if (!generic_xdp_prog)
  1214. return 0;
  1215. return generic_xdp_prog->aux->id;
  1216. }
  1217. static u32 rtnl_xdp_prog_drv(struct net_device *dev)
  1218. {
  1219. return dev_xdp_prog_id(dev, XDP_MODE_DRV);
  1220. }
  1221. static u32 rtnl_xdp_prog_hw(struct net_device *dev)
  1222. {
  1223. return dev_xdp_prog_id(dev, XDP_MODE_HW);
  1224. }
  1225. static int rtnl_xdp_report_one(struct sk_buff *skb, struct net_device *dev,
  1226. u32 *prog_id, u8 *mode, u8 tgt_mode, u32 attr,
  1227. u32 (*get_prog_id)(struct net_device *dev))
  1228. {
  1229. u32 curr_id;
  1230. int err;
  1231. curr_id = get_prog_id(dev);
  1232. if (!curr_id)
  1233. return 0;
  1234. *prog_id = curr_id;
  1235. err = nla_put_u32(skb, attr, curr_id);
  1236. if (err)
  1237. return err;
  1238. if (*mode != XDP_ATTACHED_NONE)
  1239. *mode = XDP_ATTACHED_MULTI;
  1240. else
  1241. *mode = tgt_mode;
  1242. return 0;
  1243. }
  1244. static int rtnl_xdp_fill(struct sk_buff *skb, struct net_device *dev)
  1245. {
  1246. struct nlattr *xdp;
  1247. u32 prog_id;
  1248. int err;
  1249. u8 mode;
  1250. xdp = nla_nest_start_noflag(skb, IFLA_XDP);
  1251. if (!xdp)
  1252. return -EMSGSIZE;
  1253. prog_id = 0;
  1254. mode = XDP_ATTACHED_NONE;
  1255. err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_SKB,
  1256. IFLA_XDP_SKB_PROG_ID, rtnl_xdp_prog_skb);
  1257. if (err)
  1258. goto err_cancel;
  1259. err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_DRV,
  1260. IFLA_XDP_DRV_PROG_ID, rtnl_xdp_prog_drv);
  1261. if (err)
  1262. goto err_cancel;
  1263. err = rtnl_xdp_report_one(skb, dev, &prog_id, &mode, XDP_ATTACHED_HW,
  1264. IFLA_XDP_HW_PROG_ID, rtnl_xdp_prog_hw);
  1265. if (err)
  1266. goto err_cancel;
  1267. err = nla_put_u8(skb, IFLA_XDP_ATTACHED, mode);
  1268. if (err)
  1269. goto err_cancel;
  1270. if (prog_id && mode != XDP_ATTACHED_MULTI) {
  1271. err = nla_put_u32(skb, IFLA_XDP_PROG_ID, prog_id);
  1272. if (err)
  1273. goto err_cancel;
  1274. }
  1275. nla_nest_end(skb, xdp);
  1276. return 0;
  1277. err_cancel:
  1278. nla_nest_cancel(skb, xdp);
  1279. return err;
  1280. }
  1281. static u32 rtnl_get_event(unsigned long event)
  1282. {
  1283. u32 rtnl_event_type = IFLA_EVENT_NONE;
  1284. switch (event) {
  1285. case NETDEV_REBOOT:
  1286. rtnl_event_type = IFLA_EVENT_REBOOT;
  1287. break;
  1288. case NETDEV_FEAT_CHANGE:
  1289. rtnl_event_type = IFLA_EVENT_FEATURES;
  1290. break;
  1291. case NETDEV_BONDING_FAILOVER:
  1292. rtnl_event_type = IFLA_EVENT_BONDING_FAILOVER;
  1293. break;
  1294. case NETDEV_NOTIFY_PEERS:
  1295. rtnl_event_type = IFLA_EVENT_NOTIFY_PEERS;
  1296. break;
  1297. case NETDEV_RESEND_IGMP:
  1298. rtnl_event_type = IFLA_EVENT_IGMP_RESEND;
  1299. break;
  1300. case NETDEV_CHANGEINFODATA:
  1301. rtnl_event_type = IFLA_EVENT_BONDING_OPTIONS;
  1302. break;
  1303. default:
  1304. break;
  1305. }
  1306. return rtnl_event_type;
  1307. }
  1308. static int put_master_ifindex(struct sk_buff *skb, struct net_device *dev)
  1309. {
  1310. const struct net_device *upper_dev;
  1311. int ret = 0;
  1312. rcu_read_lock();
  1313. upper_dev = netdev_master_upper_dev_get_rcu(dev);
  1314. if (upper_dev)
  1315. ret = nla_put_u32(skb, IFLA_MASTER, upper_dev->ifindex);
  1316. rcu_read_unlock();
  1317. return ret;
  1318. }
  1319. static int nla_put_iflink(struct sk_buff *skb, const struct net_device *dev,
  1320. bool force)
  1321. {
  1322. int ifindex = dev_get_iflink(dev);
  1323. if (force || dev->ifindex != ifindex)
  1324. return nla_put_u32(skb, IFLA_LINK, ifindex);
  1325. return 0;
  1326. }
  1327. static noinline_for_stack int nla_put_ifalias(struct sk_buff *skb,
  1328. struct net_device *dev)
  1329. {
  1330. char buf[IFALIASZ];
  1331. int ret;
  1332. ret = dev_get_alias(dev, buf, sizeof(buf));
  1333. return ret > 0 ? nla_put_string(skb, IFLA_IFALIAS, buf) : 0;
  1334. }
  1335. static int rtnl_fill_link_netnsid(struct sk_buff *skb,
  1336. const struct net_device *dev,
  1337. struct net *src_net, gfp_t gfp)
  1338. {
  1339. bool put_iflink = false;
  1340. if (dev->rtnl_link_ops && dev->rtnl_link_ops->get_link_net) {
  1341. struct net *link_net = dev->rtnl_link_ops->get_link_net(dev);
  1342. if (!net_eq(dev_net(dev), link_net)) {
  1343. int id = peernet2id_alloc(src_net, link_net, gfp);
  1344. if (nla_put_s32(skb, IFLA_LINK_NETNSID, id))
  1345. return -EMSGSIZE;
  1346. put_iflink = true;
  1347. }
  1348. }
  1349. return nla_put_iflink(skb, dev, put_iflink);
  1350. }
  1351. static int rtnl_fill_link_af(struct sk_buff *skb,
  1352. const struct net_device *dev,
  1353. u32 ext_filter_mask)
  1354. {
  1355. const struct rtnl_af_ops *af_ops;
  1356. struct nlattr *af_spec;
  1357. af_spec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
  1358. if (!af_spec)
  1359. return -EMSGSIZE;
  1360. list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
  1361. struct nlattr *af;
  1362. int err;
  1363. if (!af_ops->fill_link_af)
  1364. continue;
  1365. af = nla_nest_start_noflag(skb, af_ops->family);
  1366. if (!af)
  1367. return -EMSGSIZE;
  1368. err = af_ops->fill_link_af(skb, dev, ext_filter_mask);
  1369. /*
  1370. * Caller may return ENODATA to indicate that there
  1371. * was no data to be dumped. This is not an error, it
  1372. * means we should trim the attribute header and
  1373. * continue.
  1374. */
  1375. if (err == -ENODATA)
  1376. nla_nest_cancel(skb, af);
  1377. else if (err < 0)
  1378. return -EMSGSIZE;
  1379. nla_nest_end(skb, af);
  1380. }
  1381. nla_nest_end(skb, af_spec);
  1382. return 0;
  1383. }
  1384. static int rtnl_fill_alt_ifnames(struct sk_buff *skb,
  1385. const struct net_device *dev)
  1386. {
  1387. struct netdev_name_node *name_node;
  1388. int count = 0;
  1389. list_for_each_entry(name_node, &dev->name_node->list, list) {
  1390. if (nla_put_string(skb, IFLA_ALT_IFNAME, name_node->name))
  1391. return -EMSGSIZE;
  1392. count++;
  1393. }
  1394. return count;
  1395. }
  1396. static int rtnl_fill_prop_list(struct sk_buff *skb,
  1397. const struct net_device *dev)
  1398. {
  1399. struct nlattr *prop_list;
  1400. int ret;
  1401. prop_list = nla_nest_start(skb, IFLA_PROP_LIST);
  1402. if (!prop_list)
  1403. return -EMSGSIZE;
  1404. ret = rtnl_fill_alt_ifnames(skb, dev);
  1405. if (ret <= 0)
  1406. goto nest_cancel;
  1407. nla_nest_end(skb, prop_list);
  1408. return 0;
  1409. nest_cancel:
  1410. nla_nest_cancel(skb, prop_list);
  1411. return ret;
  1412. }
  1413. static int rtnl_fill_proto_down(struct sk_buff *skb,
  1414. const struct net_device *dev)
  1415. {
  1416. struct nlattr *pr;
  1417. u32 preason;
  1418. if (nla_put_u8(skb, IFLA_PROTO_DOWN, dev->proto_down))
  1419. goto nla_put_failure;
  1420. preason = dev->proto_down_reason;
  1421. if (!preason)
  1422. return 0;
  1423. pr = nla_nest_start(skb, IFLA_PROTO_DOWN_REASON);
  1424. if (!pr)
  1425. return -EMSGSIZE;
  1426. if (nla_put_u32(skb, IFLA_PROTO_DOWN_REASON_VALUE, preason)) {
  1427. nla_nest_cancel(skb, pr);
  1428. goto nla_put_failure;
  1429. }
  1430. nla_nest_end(skb, pr);
  1431. return 0;
  1432. nla_put_failure:
  1433. return -EMSGSIZE;
  1434. }
  1435. static int rtnl_fill_ifinfo(struct sk_buff *skb,
  1436. struct net_device *dev, struct net *src_net,
  1437. int type, u32 pid, u32 seq, u32 change,
  1438. unsigned int flags, u32 ext_filter_mask,
  1439. u32 event, int *new_nsid, int new_ifindex,
  1440. int tgt_netnsid, gfp_t gfp)
  1441. {
  1442. struct ifinfomsg *ifm;
  1443. struct nlmsghdr *nlh;
  1444. struct Qdisc *qdisc;
  1445. ASSERT_RTNL();
  1446. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
  1447. if (nlh == NULL)
  1448. return -EMSGSIZE;
  1449. ifm = nlmsg_data(nlh);
  1450. ifm->ifi_family = AF_UNSPEC;
  1451. ifm->__ifi_pad = 0;
  1452. ifm->ifi_type = dev->type;
  1453. ifm->ifi_index = dev->ifindex;
  1454. ifm->ifi_flags = dev_get_flags(dev);
  1455. ifm->ifi_change = change;
  1456. if (tgt_netnsid >= 0 && nla_put_s32(skb, IFLA_TARGET_NETNSID, tgt_netnsid))
  1457. goto nla_put_failure;
  1458. qdisc = rtnl_dereference(dev->qdisc);
  1459. if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
  1460. nla_put_u32(skb, IFLA_TXQLEN, dev->tx_queue_len) ||
  1461. nla_put_u8(skb, IFLA_OPERSTATE,
  1462. netif_running(dev) ? dev->operstate : IF_OPER_DOWN) ||
  1463. nla_put_u8(skb, IFLA_LINKMODE, dev->link_mode) ||
  1464. nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
  1465. nla_put_u32(skb, IFLA_MIN_MTU, dev->min_mtu) ||
  1466. nla_put_u32(skb, IFLA_MAX_MTU, dev->max_mtu) ||
  1467. nla_put_u32(skb, IFLA_GROUP, dev->group) ||
  1468. nla_put_u32(skb, IFLA_PROMISCUITY, dev->promiscuity) ||
  1469. nla_put_u32(skb, IFLA_NUM_TX_QUEUES, dev->num_tx_queues) ||
  1470. nla_put_u32(skb, IFLA_GSO_MAX_SEGS, dev->gso_max_segs) ||
  1471. nla_put_u32(skb, IFLA_GSO_MAX_SIZE, dev->gso_max_size) ||
  1472. #ifdef CONFIG_RPS
  1473. nla_put_u32(skb, IFLA_NUM_RX_QUEUES, dev->num_rx_queues) ||
  1474. #endif
  1475. put_master_ifindex(skb, dev) ||
  1476. nla_put_u8(skb, IFLA_CARRIER, netif_carrier_ok(dev)) ||
  1477. (qdisc &&
  1478. nla_put_string(skb, IFLA_QDISC, qdisc->ops->id)) ||
  1479. nla_put_ifalias(skb, dev) ||
  1480. nla_put_u32(skb, IFLA_CARRIER_CHANGES,
  1481. atomic_read(&dev->carrier_up_count) +
  1482. atomic_read(&dev->carrier_down_count)) ||
  1483. nla_put_u32(skb, IFLA_CARRIER_UP_COUNT,
  1484. atomic_read(&dev->carrier_up_count)) ||
  1485. nla_put_u32(skb, IFLA_CARRIER_DOWN_COUNT,
  1486. atomic_read(&dev->carrier_down_count)))
  1487. goto nla_put_failure;
  1488. if (rtnl_fill_proto_down(skb, dev))
  1489. goto nla_put_failure;
  1490. if (event != IFLA_EVENT_NONE) {
  1491. if (nla_put_u32(skb, IFLA_EVENT, event))
  1492. goto nla_put_failure;
  1493. }
  1494. if (rtnl_fill_link_ifmap(skb, dev))
  1495. goto nla_put_failure;
  1496. if (dev->addr_len) {
  1497. if (nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr) ||
  1498. nla_put(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast))
  1499. goto nla_put_failure;
  1500. }
  1501. if (rtnl_phys_port_id_fill(skb, dev))
  1502. goto nla_put_failure;
  1503. if (rtnl_phys_port_name_fill(skb, dev))
  1504. goto nla_put_failure;
  1505. if (rtnl_phys_switch_id_fill(skb, dev))
  1506. goto nla_put_failure;
  1507. if (rtnl_fill_stats(skb, dev))
  1508. goto nla_put_failure;
  1509. if (rtnl_fill_vf(skb, dev, ext_filter_mask))
  1510. goto nla_put_failure;
  1511. if (rtnl_port_fill(skb, dev, ext_filter_mask))
  1512. goto nla_put_failure;
  1513. if (rtnl_xdp_fill(skb, dev))
  1514. goto nla_put_failure;
  1515. if (dev->rtnl_link_ops || rtnl_have_link_slave_info(dev)) {
  1516. if (rtnl_link_fill(skb, dev) < 0)
  1517. goto nla_put_failure;
  1518. }
  1519. if (rtnl_fill_link_netnsid(skb, dev, src_net, gfp))
  1520. goto nla_put_failure;
  1521. if (new_nsid &&
  1522. nla_put_s32(skb, IFLA_NEW_NETNSID, *new_nsid) < 0)
  1523. goto nla_put_failure;
  1524. if (new_ifindex &&
  1525. nla_put_s32(skb, IFLA_NEW_IFINDEX, new_ifindex) < 0)
  1526. goto nla_put_failure;
  1527. if (memchr_inv(dev->perm_addr, '\0', dev->addr_len) &&
  1528. nla_put(skb, IFLA_PERM_ADDRESS, dev->addr_len, dev->perm_addr))
  1529. goto nla_put_failure;
  1530. rcu_read_lock();
  1531. if (rtnl_fill_link_af(skb, dev, ext_filter_mask))
  1532. goto nla_put_failure_rcu;
  1533. rcu_read_unlock();
  1534. if (rtnl_fill_prop_list(skb, dev))
  1535. goto nla_put_failure;
  1536. nlmsg_end(skb, nlh);
  1537. return 0;
  1538. nla_put_failure_rcu:
  1539. rcu_read_unlock();
  1540. nla_put_failure:
  1541. nlmsg_cancel(skb, nlh);
  1542. return -EMSGSIZE;
  1543. }
  1544. static const struct nla_policy ifla_policy[IFLA_MAX+1] = {
  1545. [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
  1546. [IFLA_ADDRESS] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
  1547. [IFLA_BROADCAST] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN },
  1548. [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
  1549. [IFLA_MTU] = { .type = NLA_U32 },
  1550. [IFLA_LINK] = { .type = NLA_U32 },
  1551. [IFLA_MASTER] = { .type = NLA_U32 },
  1552. [IFLA_CARRIER] = { .type = NLA_U8 },
  1553. [IFLA_TXQLEN] = { .type = NLA_U32 },
  1554. [IFLA_WEIGHT] = { .type = NLA_U32 },
  1555. [IFLA_OPERSTATE] = { .type = NLA_U8 },
  1556. [IFLA_LINKMODE] = { .type = NLA_U8 },
  1557. [IFLA_LINKINFO] = { .type = NLA_NESTED },
  1558. [IFLA_NET_NS_PID] = { .type = NLA_U32 },
  1559. [IFLA_NET_NS_FD] = { .type = NLA_U32 },
  1560. /* IFLA_IFALIAS is a string, but policy is set to NLA_BINARY to
  1561. * allow 0-length string (needed to remove an alias).
  1562. */
  1563. [IFLA_IFALIAS] = { .type = NLA_BINARY, .len = IFALIASZ - 1 },
  1564. [IFLA_VFINFO_LIST] = {. type = NLA_NESTED },
  1565. [IFLA_VF_PORTS] = { .type = NLA_NESTED },
  1566. [IFLA_PORT_SELF] = { .type = NLA_NESTED },
  1567. [IFLA_AF_SPEC] = { .type = NLA_NESTED },
  1568. [IFLA_EXT_MASK] = { .type = NLA_U32 },
  1569. [IFLA_PROMISCUITY] = { .type = NLA_U32 },
  1570. [IFLA_NUM_TX_QUEUES] = { .type = NLA_U32 },
  1571. [IFLA_NUM_RX_QUEUES] = { .type = NLA_U32 },
  1572. [IFLA_GSO_MAX_SEGS] = { .type = NLA_U32 },
  1573. [IFLA_GSO_MAX_SIZE] = { .type = NLA_U32 },
  1574. [IFLA_PHYS_PORT_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
  1575. [IFLA_CARRIER_CHANGES] = { .type = NLA_U32 }, /* ignored */
  1576. [IFLA_PHYS_SWITCH_ID] = { .type = NLA_BINARY, .len = MAX_PHYS_ITEM_ID_LEN },
  1577. [IFLA_LINK_NETNSID] = { .type = NLA_S32 },
  1578. [IFLA_PROTO_DOWN] = { .type = NLA_U8 },
  1579. [IFLA_XDP] = { .type = NLA_NESTED },
  1580. [IFLA_EVENT] = { .type = NLA_U32 },
  1581. [IFLA_GROUP] = { .type = NLA_U32 },
  1582. [IFLA_TARGET_NETNSID] = { .type = NLA_S32 },
  1583. [IFLA_CARRIER_UP_COUNT] = { .type = NLA_U32 },
  1584. [IFLA_CARRIER_DOWN_COUNT] = { .type = NLA_U32 },
  1585. [IFLA_MIN_MTU] = { .type = NLA_U32 },
  1586. [IFLA_MAX_MTU] = { .type = NLA_U32 },
  1587. [IFLA_PROP_LIST] = { .type = NLA_NESTED },
  1588. [IFLA_ALT_IFNAME] = { .type = NLA_STRING,
  1589. .len = ALTIFNAMSIZ - 1 },
  1590. [IFLA_PERM_ADDRESS] = { .type = NLA_REJECT },
  1591. [IFLA_PROTO_DOWN_REASON] = { .type = NLA_NESTED },
  1592. };
  1593. static const struct nla_policy ifla_info_policy[IFLA_INFO_MAX+1] = {
  1594. [IFLA_INFO_KIND] = { .type = NLA_STRING },
  1595. [IFLA_INFO_DATA] = { .type = NLA_NESTED },
  1596. [IFLA_INFO_SLAVE_KIND] = { .type = NLA_STRING },
  1597. [IFLA_INFO_SLAVE_DATA] = { .type = NLA_NESTED },
  1598. };
  1599. static const struct nla_policy ifla_vf_policy[IFLA_VF_MAX+1] = {
  1600. [IFLA_VF_MAC] = { .len = sizeof(struct ifla_vf_mac) },
  1601. [IFLA_VF_BROADCAST] = { .type = NLA_REJECT },
  1602. [IFLA_VF_VLAN] = { .len = sizeof(struct ifla_vf_vlan) },
  1603. [IFLA_VF_VLAN_LIST] = { .type = NLA_NESTED },
  1604. [IFLA_VF_TX_RATE] = { .len = sizeof(struct ifla_vf_tx_rate) },
  1605. [IFLA_VF_SPOOFCHK] = { .len = sizeof(struct ifla_vf_spoofchk) },
  1606. [IFLA_VF_RATE] = { .len = sizeof(struct ifla_vf_rate) },
  1607. [IFLA_VF_LINK_STATE] = { .len = sizeof(struct ifla_vf_link_state) },
  1608. [IFLA_VF_RSS_QUERY_EN] = { .len = sizeof(struct ifla_vf_rss_query_en) },
  1609. [IFLA_VF_STATS] = { .type = NLA_NESTED },
  1610. [IFLA_VF_TRUST] = { .len = sizeof(struct ifla_vf_trust) },
  1611. [IFLA_VF_IB_NODE_GUID] = { .len = sizeof(struct ifla_vf_guid) },
  1612. [IFLA_VF_IB_PORT_GUID] = { .len = sizeof(struct ifla_vf_guid) },
  1613. };
  1614. static const struct nla_policy ifla_port_policy[IFLA_PORT_MAX+1] = {
  1615. [IFLA_PORT_VF] = { .type = NLA_U32 },
  1616. [IFLA_PORT_PROFILE] = { .type = NLA_STRING,
  1617. .len = PORT_PROFILE_MAX },
  1618. [IFLA_PORT_INSTANCE_UUID] = { .type = NLA_BINARY,
  1619. .len = PORT_UUID_MAX },
  1620. [IFLA_PORT_HOST_UUID] = { .type = NLA_STRING,
  1621. .len = PORT_UUID_MAX },
  1622. [IFLA_PORT_REQUEST] = { .type = NLA_U8, },
  1623. [IFLA_PORT_RESPONSE] = { .type = NLA_U16, },
  1624. /* Unused, but we need to keep it here since user space could
  1625. * fill it. It's also broken with regard to NLA_BINARY use in
  1626. * combination with structs.
  1627. */
  1628. [IFLA_PORT_VSI_TYPE] = { .type = NLA_BINARY,
  1629. .len = sizeof(struct ifla_port_vsi) },
  1630. };
  1631. static const struct nla_policy ifla_xdp_policy[IFLA_XDP_MAX + 1] = {
  1632. [IFLA_XDP_UNSPEC] = { .strict_start_type = IFLA_XDP_EXPECTED_FD },
  1633. [IFLA_XDP_FD] = { .type = NLA_S32 },
  1634. [IFLA_XDP_EXPECTED_FD] = { .type = NLA_S32 },
  1635. [IFLA_XDP_ATTACHED] = { .type = NLA_U8 },
  1636. [IFLA_XDP_FLAGS] = { .type = NLA_U32 },
  1637. [IFLA_XDP_PROG_ID] = { .type = NLA_U32 },
  1638. };
  1639. static const struct rtnl_link_ops *linkinfo_to_kind_ops(const struct nlattr *nla)
  1640. {
  1641. const struct rtnl_link_ops *ops = NULL;
  1642. struct nlattr *linfo[IFLA_INFO_MAX + 1];
  1643. if (nla_parse_nested_deprecated(linfo, IFLA_INFO_MAX, nla, ifla_info_policy, NULL) < 0)
  1644. return NULL;
  1645. if (linfo[IFLA_INFO_KIND]) {
  1646. char kind[MODULE_NAME_LEN];
  1647. nla_strlcpy(kind, linfo[IFLA_INFO_KIND], sizeof(kind));
  1648. ops = rtnl_link_ops_get(kind);
  1649. }
  1650. return ops;
  1651. }
  1652. static bool link_master_filtered(struct net_device *dev, int master_idx)
  1653. {
  1654. struct net_device *master;
  1655. if (!master_idx)
  1656. return false;
  1657. master = netdev_master_upper_dev_get(dev);
  1658. if (!master || master->ifindex != master_idx)
  1659. return true;
  1660. return false;
  1661. }
  1662. static bool link_kind_filtered(const struct net_device *dev,
  1663. const struct rtnl_link_ops *kind_ops)
  1664. {
  1665. if (kind_ops && dev->rtnl_link_ops != kind_ops)
  1666. return true;
  1667. return false;
  1668. }
  1669. static bool link_dump_filtered(struct net_device *dev,
  1670. int master_idx,
  1671. const struct rtnl_link_ops *kind_ops)
  1672. {
  1673. if (link_master_filtered(dev, master_idx) ||
  1674. link_kind_filtered(dev, kind_ops))
  1675. return true;
  1676. return false;
  1677. }
  1678. /**
  1679. * rtnl_get_net_ns_capable - Get netns if sufficiently privileged.
  1680. * @sk: netlink socket
  1681. * @netnsid: network namespace identifier
  1682. *
  1683. * Returns the network namespace identified by netnsid on success or an error
  1684. * pointer on failure.
  1685. */
  1686. struct net *rtnl_get_net_ns_capable(struct sock *sk, int netnsid)
  1687. {
  1688. struct net *net;
  1689. net = get_net_ns_by_id(sock_net(sk), netnsid);
  1690. if (!net)
  1691. return ERR_PTR(-EINVAL);
  1692. /* For now, the caller is required to have CAP_NET_ADMIN in
  1693. * the user namespace owning the target net ns.
  1694. */
  1695. if (!sk_ns_capable(sk, net->user_ns, CAP_NET_ADMIN)) {
  1696. put_net(net);
  1697. return ERR_PTR(-EACCES);
  1698. }
  1699. return net;
  1700. }
  1701. EXPORT_SYMBOL_GPL(rtnl_get_net_ns_capable);
  1702. static int rtnl_valid_dump_ifinfo_req(const struct nlmsghdr *nlh,
  1703. bool strict_check, struct nlattr **tb,
  1704. struct netlink_ext_ack *extack)
  1705. {
  1706. int hdrlen;
  1707. if (strict_check) {
  1708. struct ifinfomsg *ifm;
  1709. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
  1710. NL_SET_ERR_MSG(extack, "Invalid header for link dump");
  1711. return -EINVAL;
  1712. }
  1713. ifm = nlmsg_data(nlh);
  1714. if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
  1715. ifm->ifi_change) {
  1716. NL_SET_ERR_MSG(extack, "Invalid values in header for link dump request");
  1717. return -EINVAL;
  1718. }
  1719. if (ifm->ifi_index) {
  1720. NL_SET_ERR_MSG(extack, "Filter by device index not supported for link dumps");
  1721. return -EINVAL;
  1722. }
  1723. return nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb,
  1724. IFLA_MAX, ifla_policy,
  1725. extack);
  1726. }
  1727. /* A hack to preserve kernel<->userspace interface.
  1728. * The correct header is ifinfomsg. It is consistent with rtnl_getlink.
  1729. * However, before Linux v3.9 the code here assumed rtgenmsg and that's
  1730. * what iproute2 < v3.9.0 used.
  1731. * We can detect the old iproute2. Even including the IFLA_EXT_MASK
  1732. * attribute, its netlink message is shorter than struct ifinfomsg.
  1733. */
  1734. hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
  1735. sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
  1736. return nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy,
  1737. extack);
  1738. }
  1739. static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
  1740. {
  1741. struct netlink_ext_ack *extack = cb->extack;
  1742. const struct nlmsghdr *nlh = cb->nlh;
  1743. struct net *net = sock_net(skb->sk);
  1744. struct net *tgt_net = net;
  1745. int h, s_h;
  1746. int idx = 0, s_idx;
  1747. struct net_device *dev;
  1748. struct hlist_head *head;
  1749. struct nlattr *tb[IFLA_MAX+1];
  1750. u32 ext_filter_mask = 0;
  1751. const struct rtnl_link_ops *kind_ops = NULL;
  1752. unsigned int flags = NLM_F_MULTI;
  1753. int master_idx = 0;
  1754. int netnsid = -1;
  1755. int err, i;
  1756. s_h = cb->args[0];
  1757. s_idx = cb->args[1];
  1758. err = rtnl_valid_dump_ifinfo_req(nlh, cb->strict_check, tb, extack);
  1759. if (err < 0) {
  1760. if (cb->strict_check)
  1761. return err;
  1762. goto walk_entries;
  1763. }
  1764. for (i = 0; i <= IFLA_MAX; ++i) {
  1765. if (!tb[i])
  1766. continue;
  1767. /* new attributes should only be added with strict checking */
  1768. switch (i) {
  1769. case IFLA_TARGET_NETNSID:
  1770. netnsid = nla_get_s32(tb[i]);
  1771. tgt_net = rtnl_get_net_ns_capable(skb->sk, netnsid);
  1772. if (IS_ERR(tgt_net)) {
  1773. NL_SET_ERR_MSG(extack, "Invalid target network namespace id");
  1774. return PTR_ERR(tgt_net);
  1775. }
  1776. break;
  1777. case IFLA_EXT_MASK:
  1778. ext_filter_mask = nla_get_u32(tb[i]);
  1779. break;
  1780. case IFLA_MASTER:
  1781. master_idx = nla_get_u32(tb[i]);
  1782. break;
  1783. case IFLA_LINKINFO:
  1784. kind_ops = linkinfo_to_kind_ops(tb[i]);
  1785. break;
  1786. default:
  1787. if (cb->strict_check) {
  1788. NL_SET_ERR_MSG(extack, "Unsupported attribute in link dump request");
  1789. return -EINVAL;
  1790. }
  1791. }
  1792. }
  1793. if (master_idx || kind_ops)
  1794. flags |= NLM_F_DUMP_FILTERED;
  1795. walk_entries:
  1796. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  1797. idx = 0;
  1798. head = &tgt_net->dev_index_head[h];
  1799. hlist_for_each_entry(dev, head, index_hlist) {
  1800. if (link_dump_filtered(dev, master_idx, kind_ops))
  1801. goto cont;
  1802. if (idx < s_idx)
  1803. goto cont;
  1804. err = rtnl_fill_ifinfo(skb, dev, net,
  1805. RTM_NEWLINK,
  1806. NETLINK_CB(cb->skb).portid,
  1807. nlh->nlmsg_seq, 0, flags,
  1808. ext_filter_mask, 0, NULL, 0,
  1809. netnsid, GFP_KERNEL);
  1810. if (err < 0) {
  1811. if (likely(skb->len))
  1812. goto out;
  1813. goto out_err;
  1814. }
  1815. cont:
  1816. idx++;
  1817. }
  1818. }
  1819. out:
  1820. err = skb->len;
  1821. out_err:
  1822. cb->args[1] = idx;
  1823. cb->args[0] = h;
  1824. cb->seq = net->dev_base_seq;
  1825. nl_dump_check_consistent(cb, nlmsg_hdr(skb));
  1826. if (netnsid >= 0)
  1827. put_net(tgt_net);
  1828. return err;
  1829. }
  1830. int rtnl_nla_parse_ifla(struct nlattr **tb, const struct nlattr *head, int len,
  1831. struct netlink_ext_ack *exterr)
  1832. {
  1833. return nla_parse_deprecated(tb, IFLA_MAX, head, len, ifla_policy,
  1834. exterr);
  1835. }
  1836. EXPORT_SYMBOL(rtnl_nla_parse_ifla);
  1837. struct net *rtnl_link_get_net(struct net *src_net, struct nlattr *tb[])
  1838. {
  1839. struct net *net;
  1840. /* Examine the link attributes and figure out which
  1841. * network namespace we are talking about.
  1842. */
  1843. if (tb[IFLA_NET_NS_PID])
  1844. net = get_net_ns_by_pid(nla_get_u32(tb[IFLA_NET_NS_PID]));
  1845. else if (tb[IFLA_NET_NS_FD])
  1846. net = get_net_ns_by_fd(nla_get_u32(tb[IFLA_NET_NS_FD]));
  1847. else
  1848. net = get_net(src_net);
  1849. return net;
  1850. }
  1851. EXPORT_SYMBOL(rtnl_link_get_net);
  1852. /* Figure out which network namespace we are talking about by
  1853. * examining the link attributes in the following order:
  1854. *
  1855. * 1. IFLA_NET_NS_PID
  1856. * 2. IFLA_NET_NS_FD
  1857. * 3. IFLA_TARGET_NETNSID
  1858. */
  1859. static struct net *rtnl_link_get_net_by_nlattr(struct net *src_net,
  1860. struct nlattr *tb[])
  1861. {
  1862. struct net *net;
  1863. if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD])
  1864. return rtnl_link_get_net(src_net, tb);
  1865. if (!tb[IFLA_TARGET_NETNSID])
  1866. return get_net(src_net);
  1867. net = get_net_ns_by_id(src_net, nla_get_u32(tb[IFLA_TARGET_NETNSID]));
  1868. if (!net)
  1869. return ERR_PTR(-EINVAL);
  1870. return net;
  1871. }
  1872. static struct net *rtnl_link_get_net_capable(const struct sk_buff *skb,
  1873. struct net *src_net,
  1874. struct nlattr *tb[], int cap)
  1875. {
  1876. struct net *net;
  1877. net = rtnl_link_get_net_by_nlattr(src_net, tb);
  1878. if (IS_ERR(net))
  1879. return net;
  1880. if (!netlink_ns_capable(skb, net->user_ns, cap)) {
  1881. put_net(net);
  1882. return ERR_PTR(-EPERM);
  1883. }
  1884. return net;
  1885. }
  1886. /* Verify that rtnetlink requests do not pass additional properties
  1887. * potentially referring to different network namespaces.
  1888. */
  1889. static int rtnl_ensure_unique_netns(struct nlattr *tb[],
  1890. struct netlink_ext_ack *extack,
  1891. bool netns_id_only)
  1892. {
  1893. if (netns_id_only) {
  1894. if (!tb[IFLA_NET_NS_PID] && !tb[IFLA_NET_NS_FD])
  1895. return 0;
  1896. NL_SET_ERR_MSG(extack, "specified netns attribute not supported");
  1897. return -EOPNOTSUPP;
  1898. }
  1899. if (tb[IFLA_TARGET_NETNSID] && (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD]))
  1900. goto invalid_attr;
  1901. if (tb[IFLA_NET_NS_PID] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_FD]))
  1902. goto invalid_attr;
  1903. if (tb[IFLA_NET_NS_FD] && (tb[IFLA_TARGET_NETNSID] || tb[IFLA_NET_NS_PID]))
  1904. goto invalid_attr;
  1905. return 0;
  1906. invalid_attr:
  1907. NL_SET_ERR_MSG(extack, "multiple netns identifying attributes specified");
  1908. return -EINVAL;
  1909. }
  1910. static int validate_linkmsg(struct net_device *dev, struct nlattr *tb[])
  1911. {
  1912. if (dev) {
  1913. if (tb[IFLA_ADDRESS] &&
  1914. nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
  1915. return -EINVAL;
  1916. if (tb[IFLA_BROADCAST] &&
  1917. nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
  1918. return -EINVAL;
  1919. }
  1920. if (tb[IFLA_AF_SPEC]) {
  1921. struct nlattr *af;
  1922. int rem, err;
  1923. nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
  1924. const struct rtnl_af_ops *af_ops;
  1925. rcu_read_lock();
  1926. af_ops = rtnl_af_lookup(nla_type(af));
  1927. if (!af_ops) {
  1928. rcu_read_unlock();
  1929. return -EAFNOSUPPORT;
  1930. }
  1931. if (!af_ops->set_link_af) {
  1932. rcu_read_unlock();
  1933. return -EOPNOTSUPP;
  1934. }
  1935. if (af_ops->validate_link_af) {
  1936. err = af_ops->validate_link_af(dev, af);
  1937. if (err < 0) {
  1938. rcu_read_unlock();
  1939. return err;
  1940. }
  1941. }
  1942. rcu_read_unlock();
  1943. }
  1944. }
  1945. return 0;
  1946. }
  1947. static int handle_infiniband_guid(struct net_device *dev, struct ifla_vf_guid *ivt,
  1948. int guid_type)
  1949. {
  1950. const struct net_device_ops *ops = dev->netdev_ops;
  1951. return ops->ndo_set_vf_guid(dev, ivt->vf, ivt->guid, guid_type);
  1952. }
  1953. static int handle_vf_guid(struct net_device *dev, struct ifla_vf_guid *ivt, int guid_type)
  1954. {
  1955. if (dev->type != ARPHRD_INFINIBAND)
  1956. return -EOPNOTSUPP;
  1957. return handle_infiniband_guid(dev, ivt, guid_type);
  1958. }
  1959. static int do_setvfinfo(struct net_device *dev, struct nlattr **tb)
  1960. {
  1961. const struct net_device_ops *ops = dev->netdev_ops;
  1962. int err = -EINVAL;
  1963. if (tb[IFLA_VF_MAC]) {
  1964. struct ifla_vf_mac *ivm = nla_data(tb[IFLA_VF_MAC]);
  1965. if (ivm->vf >= INT_MAX)
  1966. return -EINVAL;
  1967. err = -EOPNOTSUPP;
  1968. if (ops->ndo_set_vf_mac)
  1969. err = ops->ndo_set_vf_mac(dev, ivm->vf,
  1970. ivm->mac);
  1971. if (err < 0)
  1972. return err;
  1973. }
  1974. if (tb[IFLA_VF_VLAN]) {
  1975. struct ifla_vf_vlan *ivv = nla_data(tb[IFLA_VF_VLAN]);
  1976. if (ivv->vf >= INT_MAX)
  1977. return -EINVAL;
  1978. err = -EOPNOTSUPP;
  1979. if (ops->ndo_set_vf_vlan)
  1980. err = ops->ndo_set_vf_vlan(dev, ivv->vf, ivv->vlan,
  1981. ivv->qos,
  1982. htons(ETH_P_8021Q));
  1983. if (err < 0)
  1984. return err;
  1985. }
  1986. if (tb[IFLA_VF_VLAN_LIST]) {
  1987. struct ifla_vf_vlan_info *ivvl[MAX_VLAN_LIST_LEN];
  1988. struct nlattr *attr;
  1989. int rem, len = 0;
  1990. err = -EOPNOTSUPP;
  1991. if (!ops->ndo_set_vf_vlan)
  1992. return err;
  1993. nla_for_each_nested(attr, tb[IFLA_VF_VLAN_LIST], rem) {
  1994. if (nla_type(attr) != IFLA_VF_VLAN_INFO ||
  1995. nla_len(attr) < NLA_HDRLEN) {
  1996. return -EINVAL;
  1997. }
  1998. if (len >= MAX_VLAN_LIST_LEN)
  1999. return -EOPNOTSUPP;
  2000. ivvl[len] = nla_data(attr);
  2001. len++;
  2002. }
  2003. if (len == 0)
  2004. return -EINVAL;
  2005. if (ivvl[0]->vf >= INT_MAX)
  2006. return -EINVAL;
  2007. err = ops->ndo_set_vf_vlan(dev, ivvl[0]->vf, ivvl[0]->vlan,
  2008. ivvl[0]->qos, ivvl[0]->vlan_proto);
  2009. if (err < 0)
  2010. return err;
  2011. }
  2012. if (tb[IFLA_VF_TX_RATE]) {
  2013. struct ifla_vf_tx_rate *ivt = nla_data(tb[IFLA_VF_TX_RATE]);
  2014. struct ifla_vf_info ivf;
  2015. if (ivt->vf >= INT_MAX)
  2016. return -EINVAL;
  2017. err = -EOPNOTSUPP;
  2018. if (ops->ndo_get_vf_config)
  2019. err = ops->ndo_get_vf_config(dev, ivt->vf, &ivf);
  2020. if (err < 0)
  2021. return err;
  2022. err = -EOPNOTSUPP;
  2023. if (ops->ndo_set_vf_rate)
  2024. err = ops->ndo_set_vf_rate(dev, ivt->vf,
  2025. ivf.min_tx_rate,
  2026. ivt->rate);
  2027. if (err < 0)
  2028. return err;
  2029. }
  2030. if (tb[IFLA_VF_RATE]) {
  2031. struct ifla_vf_rate *ivt = nla_data(tb[IFLA_VF_RATE]);
  2032. if (ivt->vf >= INT_MAX)
  2033. return -EINVAL;
  2034. err = -EOPNOTSUPP;
  2035. if (ops->ndo_set_vf_rate)
  2036. err = ops->ndo_set_vf_rate(dev, ivt->vf,
  2037. ivt->min_tx_rate,
  2038. ivt->max_tx_rate);
  2039. if (err < 0)
  2040. return err;
  2041. }
  2042. if (tb[IFLA_VF_SPOOFCHK]) {
  2043. struct ifla_vf_spoofchk *ivs = nla_data(tb[IFLA_VF_SPOOFCHK]);
  2044. if (ivs->vf >= INT_MAX)
  2045. return -EINVAL;
  2046. err = -EOPNOTSUPP;
  2047. if (ops->ndo_set_vf_spoofchk)
  2048. err = ops->ndo_set_vf_spoofchk(dev, ivs->vf,
  2049. ivs->setting);
  2050. if (err < 0)
  2051. return err;
  2052. }
  2053. if (tb[IFLA_VF_LINK_STATE]) {
  2054. struct ifla_vf_link_state *ivl = nla_data(tb[IFLA_VF_LINK_STATE]);
  2055. if (ivl->vf >= INT_MAX)
  2056. return -EINVAL;
  2057. err = -EOPNOTSUPP;
  2058. if (ops->ndo_set_vf_link_state)
  2059. err = ops->ndo_set_vf_link_state(dev, ivl->vf,
  2060. ivl->link_state);
  2061. if (err < 0)
  2062. return err;
  2063. }
  2064. if (tb[IFLA_VF_RSS_QUERY_EN]) {
  2065. struct ifla_vf_rss_query_en *ivrssq_en;
  2066. err = -EOPNOTSUPP;
  2067. ivrssq_en = nla_data(tb[IFLA_VF_RSS_QUERY_EN]);
  2068. if (ivrssq_en->vf >= INT_MAX)
  2069. return -EINVAL;
  2070. if (ops->ndo_set_vf_rss_query_en)
  2071. err = ops->ndo_set_vf_rss_query_en(dev, ivrssq_en->vf,
  2072. ivrssq_en->setting);
  2073. if (err < 0)
  2074. return err;
  2075. }
  2076. if (tb[IFLA_VF_TRUST]) {
  2077. struct ifla_vf_trust *ivt = nla_data(tb[IFLA_VF_TRUST]);
  2078. if (ivt->vf >= INT_MAX)
  2079. return -EINVAL;
  2080. err = -EOPNOTSUPP;
  2081. if (ops->ndo_set_vf_trust)
  2082. err = ops->ndo_set_vf_trust(dev, ivt->vf, ivt->setting);
  2083. if (err < 0)
  2084. return err;
  2085. }
  2086. if (tb[IFLA_VF_IB_NODE_GUID]) {
  2087. struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_NODE_GUID]);
  2088. if (ivt->vf >= INT_MAX)
  2089. return -EINVAL;
  2090. if (!ops->ndo_set_vf_guid)
  2091. return -EOPNOTSUPP;
  2092. return handle_vf_guid(dev, ivt, IFLA_VF_IB_NODE_GUID);
  2093. }
  2094. if (tb[IFLA_VF_IB_PORT_GUID]) {
  2095. struct ifla_vf_guid *ivt = nla_data(tb[IFLA_VF_IB_PORT_GUID]);
  2096. if (ivt->vf >= INT_MAX)
  2097. return -EINVAL;
  2098. if (!ops->ndo_set_vf_guid)
  2099. return -EOPNOTSUPP;
  2100. return handle_vf_guid(dev, ivt, IFLA_VF_IB_PORT_GUID);
  2101. }
  2102. return err;
  2103. }
  2104. static int do_set_master(struct net_device *dev, int ifindex,
  2105. struct netlink_ext_ack *extack)
  2106. {
  2107. struct net_device *upper_dev = netdev_master_upper_dev_get(dev);
  2108. const struct net_device_ops *ops;
  2109. int err;
  2110. if (upper_dev) {
  2111. if (upper_dev->ifindex == ifindex)
  2112. return 0;
  2113. ops = upper_dev->netdev_ops;
  2114. if (ops->ndo_del_slave) {
  2115. err = ops->ndo_del_slave(upper_dev, dev);
  2116. if (err)
  2117. return err;
  2118. } else {
  2119. return -EOPNOTSUPP;
  2120. }
  2121. }
  2122. if (ifindex) {
  2123. upper_dev = __dev_get_by_index(dev_net(dev), ifindex);
  2124. if (!upper_dev)
  2125. return -EINVAL;
  2126. ops = upper_dev->netdev_ops;
  2127. if (ops->ndo_add_slave) {
  2128. err = ops->ndo_add_slave(upper_dev, dev, extack);
  2129. if (err)
  2130. return err;
  2131. } else {
  2132. return -EOPNOTSUPP;
  2133. }
  2134. }
  2135. return 0;
  2136. }
  2137. static const struct nla_policy ifla_proto_down_reason_policy[IFLA_PROTO_DOWN_REASON_VALUE + 1] = {
  2138. [IFLA_PROTO_DOWN_REASON_MASK] = { .type = NLA_U32 },
  2139. [IFLA_PROTO_DOWN_REASON_VALUE] = { .type = NLA_U32 },
  2140. };
  2141. static int do_set_proto_down(struct net_device *dev,
  2142. struct nlattr *nl_proto_down,
  2143. struct nlattr *nl_proto_down_reason,
  2144. struct netlink_ext_ack *extack)
  2145. {
  2146. struct nlattr *pdreason[IFLA_PROTO_DOWN_REASON_MAX + 1];
  2147. const struct net_device_ops *ops = dev->netdev_ops;
  2148. unsigned long mask = 0;
  2149. u32 value;
  2150. bool proto_down;
  2151. int err;
  2152. if (!ops->ndo_change_proto_down) {
  2153. NL_SET_ERR_MSG(extack, "Protodown not supported by device");
  2154. return -EOPNOTSUPP;
  2155. }
  2156. if (nl_proto_down_reason) {
  2157. err = nla_parse_nested_deprecated(pdreason,
  2158. IFLA_PROTO_DOWN_REASON_MAX,
  2159. nl_proto_down_reason,
  2160. ifla_proto_down_reason_policy,
  2161. NULL);
  2162. if (err < 0)
  2163. return err;
  2164. if (!pdreason[IFLA_PROTO_DOWN_REASON_VALUE]) {
  2165. NL_SET_ERR_MSG(extack, "Invalid protodown reason value");
  2166. return -EINVAL;
  2167. }
  2168. value = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_VALUE]);
  2169. if (pdreason[IFLA_PROTO_DOWN_REASON_MASK])
  2170. mask = nla_get_u32(pdreason[IFLA_PROTO_DOWN_REASON_MASK]);
  2171. dev_change_proto_down_reason(dev, mask, value);
  2172. }
  2173. if (nl_proto_down) {
  2174. proto_down = nla_get_u8(nl_proto_down);
  2175. /* Dont turn off protodown if there are active reasons */
  2176. if (!proto_down && dev->proto_down_reason) {
  2177. NL_SET_ERR_MSG(extack, "Cannot clear protodown, active reasons");
  2178. return -EBUSY;
  2179. }
  2180. err = dev_change_proto_down(dev,
  2181. proto_down);
  2182. if (err)
  2183. return err;
  2184. }
  2185. return 0;
  2186. }
  2187. #define DO_SETLINK_MODIFIED 0x01
  2188. /* notify flag means notify + modified. */
  2189. #define DO_SETLINK_NOTIFY 0x03
  2190. static int do_setlink(const struct sk_buff *skb,
  2191. struct net_device *dev, struct ifinfomsg *ifm,
  2192. struct netlink_ext_ack *extack,
  2193. struct nlattr **tb, char *ifname, int status)
  2194. {
  2195. const struct net_device_ops *ops = dev->netdev_ops;
  2196. int err;
  2197. err = validate_linkmsg(dev, tb);
  2198. if (err < 0)
  2199. return err;
  2200. if (tb[IFLA_NET_NS_PID] || tb[IFLA_NET_NS_FD] || tb[IFLA_TARGET_NETNSID]) {
  2201. const char *pat = ifname && ifname[0] ? ifname : NULL;
  2202. struct net *net = rtnl_link_get_net_capable(skb, dev_net(dev),
  2203. tb, CAP_NET_ADMIN);
  2204. if (IS_ERR(net)) {
  2205. err = PTR_ERR(net);
  2206. goto errout;
  2207. }
  2208. err = dev_change_net_namespace(dev, net, pat);
  2209. put_net(net);
  2210. if (err)
  2211. goto errout;
  2212. status |= DO_SETLINK_MODIFIED;
  2213. }
  2214. if (tb[IFLA_MAP]) {
  2215. struct rtnl_link_ifmap *u_map;
  2216. struct ifmap k_map;
  2217. if (!ops->ndo_set_config) {
  2218. err = -EOPNOTSUPP;
  2219. goto errout;
  2220. }
  2221. if (!netif_device_present(dev)) {
  2222. err = -ENODEV;
  2223. goto errout;
  2224. }
  2225. u_map = nla_data(tb[IFLA_MAP]);
  2226. k_map.mem_start = (unsigned long) u_map->mem_start;
  2227. k_map.mem_end = (unsigned long) u_map->mem_end;
  2228. k_map.base_addr = (unsigned short) u_map->base_addr;
  2229. k_map.irq = (unsigned char) u_map->irq;
  2230. k_map.dma = (unsigned char) u_map->dma;
  2231. k_map.port = (unsigned char) u_map->port;
  2232. err = ops->ndo_set_config(dev, &k_map);
  2233. if (err < 0)
  2234. goto errout;
  2235. status |= DO_SETLINK_NOTIFY;
  2236. }
  2237. if (tb[IFLA_ADDRESS]) {
  2238. struct sockaddr *sa;
  2239. int len;
  2240. len = sizeof(sa_family_t) + max_t(size_t, dev->addr_len,
  2241. sizeof(*sa));
  2242. sa = kmalloc(len, GFP_KERNEL);
  2243. if (!sa) {
  2244. err = -ENOMEM;
  2245. goto errout;
  2246. }
  2247. sa->sa_family = dev->type;
  2248. memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
  2249. dev->addr_len);
  2250. err = dev_set_mac_address_user(dev, sa, extack);
  2251. kfree(sa);
  2252. if (err)
  2253. goto errout;
  2254. status |= DO_SETLINK_MODIFIED;
  2255. }
  2256. if (tb[IFLA_MTU]) {
  2257. err = dev_set_mtu_ext(dev, nla_get_u32(tb[IFLA_MTU]), extack);
  2258. if (err < 0)
  2259. goto errout;
  2260. status |= DO_SETLINK_MODIFIED;
  2261. }
  2262. if (tb[IFLA_GROUP]) {
  2263. dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
  2264. status |= DO_SETLINK_NOTIFY;
  2265. }
  2266. /*
  2267. * Interface selected by interface index but interface
  2268. * name provided implies that a name change has been
  2269. * requested.
  2270. */
  2271. if (ifm->ifi_index > 0 && ifname[0]) {
  2272. err = dev_change_name(dev, ifname);
  2273. if (err < 0)
  2274. goto errout;
  2275. status |= DO_SETLINK_MODIFIED;
  2276. }
  2277. if (tb[IFLA_IFALIAS]) {
  2278. err = dev_set_alias(dev, nla_data(tb[IFLA_IFALIAS]),
  2279. nla_len(tb[IFLA_IFALIAS]));
  2280. if (err < 0)
  2281. goto errout;
  2282. status |= DO_SETLINK_NOTIFY;
  2283. }
  2284. if (tb[IFLA_BROADCAST]) {
  2285. nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
  2286. call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
  2287. }
  2288. if (ifm->ifi_flags || ifm->ifi_change) {
  2289. err = dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
  2290. extack);
  2291. if (err < 0)
  2292. goto errout;
  2293. }
  2294. if (tb[IFLA_MASTER]) {
  2295. err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
  2296. if (err)
  2297. goto errout;
  2298. status |= DO_SETLINK_MODIFIED;
  2299. }
  2300. if (tb[IFLA_CARRIER]) {
  2301. err = dev_change_carrier(dev, nla_get_u8(tb[IFLA_CARRIER]));
  2302. if (err)
  2303. goto errout;
  2304. status |= DO_SETLINK_MODIFIED;
  2305. }
  2306. if (tb[IFLA_TXQLEN]) {
  2307. unsigned int value = nla_get_u32(tb[IFLA_TXQLEN]);
  2308. err = dev_change_tx_queue_len(dev, value);
  2309. if (err)
  2310. goto errout;
  2311. status |= DO_SETLINK_MODIFIED;
  2312. }
  2313. if (tb[IFLA_GSO_MAX_SIZE]) {
  2314. u32 max_size = nla_get_u32(tb[IFLA_GSO_MAX_SIZE]);
  2315. if (max_size > GSO_MAX_SIZE) {
  2316. err = -EINVAL;
  2317. goto errout;
  2318. }
  2319. if (dev->gso_max_size ^ max_size) {
  2320. netif_set_gso_max_size(dev, max_size);
  2321. status |= DO_SETLINK_MODIFIED;
  2322. }
  2323. }
  2324. if (tb[IFLA_GSO_MAX_SEGS]) {
  2325. u32 max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
  2326. if (max_segs > GSO_MAX_SEGS) {
  2327. err = -EINVAL;
  2328. goto errout;
  2329. }
  2330. if (dev->gso_max_segs ^ max_segs) {
  2331. dev->gso_max_segs = max_segs;
  2332. status |= DO_SETLINK_MODIFIED;
  2333. }
  2334. }
  2335. if (tb[IFLA_OPERSTATE])
  2336. set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
  2337. if (tb[IFLA_LINKMODE]) {
  2338. unsigned char value = nla_get_u8(tb[IFLA_LINKMODE]);
  2339. write_lock_bh(&dev_base_lock);
  2340. if (dev->link_mode ^ value)
  2341. status |= DO_SETLINK_NOTIFY;
  2342. dev->link_mode = value;
  2343. write_unlock_bh(&dev_base_lock);
  2344. }
  2345. if (tb[IFLA_VFINFO_LIST]) {
  2346. struct nlattr *vfinfo[IFLA_VF_MAX + 1];
  2347. struct nlattr *attr;
  2348. int rem;
  2349. nla_for_each_nested(attr, tb[IFLA_VFINFO_LIST], rem) {
  2350. if (nla_type(attr) != IFLA_VF_INFO ||
  2351. nla_len(attr) < NLA_HDRLEN) {
  2352. err = -EINVAL;
  2353. goto errout;
  2354. }
  2355. err = nla_parse_nested_deprecated(vfinfo, IFLA_VF_MAX,
  2356. attr,
  2357. ifla_vf_policy,
  2358. NULL);
  2359. if (err < 0)
  2360. goto errout;
  2361. err = do_setvfinfo(dev, vfinfo);
  2362. if (err < 0)
  2363. goto errout;
  2364. status |= DO_SETLINK_NOTIFY;
  2365. }
  2366. }
  2367. err = 0;
  2368. if (tb[IFLA_VF_PORTS]) {
  2369. struct nlattr *port[IFLA_PORT_MAX+1];
  2370. struct nlattr *attr;
  2371. int vf;
  2372. int rem;
  2373. err = -EOPNOTSUPP;
  2374. if (!ops->ndo_set_vf_port)
  2375. goto errout;
  2376. nla_for_each_nested(attr, tb[IFLA_VF_PORTS], rem) {
  2377. if (nla_type(attr) != IFLA_VF_PORT ||
  2378. nla_len(attr) < NLA_HDRLEN) {
  2379. err = -EINVAL;
  2380. goto errout;
  2381. }
  2382. err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
  2383. attr,
  2384. ifla_port_policy,
  2385. NULL);
  2386. if (err < 0)
  2387. goto errout;
  2388. if (!port[IFLA_PORT_VF]) {
  2389. err = -EOPNOTSUPP;
  2390. goto errout;
  2391. }
  2392. vf = nla_get_u32(port[IFLA_PORT_VF]);
  2393. err = ops->ndo_set_vf_port(dev, vf, port);
  2394. if (err < 0)
  2395. goto errout;
  2396. status |= DO_SETLINK_NOTIFY;
  2397. }
  2398. }
  2399. err = 0;
  2400. if (tb[IFLA_PORT_SELF]) {
  2401. struct nlattr *port[IFLA_PORT_MAX+1];
  2402. err = nla_parse_nested_deprecated(port, IFLA_PORT_MAX,
  2403. tb[IFLA_PORT_SELF],
  2404. ifla_port_policy, NULL);
  2405. if (err < 0)
  2406. goto errout;
  2407. err = -EOPNOTSUPP;
  2408. if (ops->ndo_set_vf_port)
  2409. err = ops->ndo_set_vf_port(dev, PORT_SELF_VF, port);
  2410. if (err < 0)
  2411. goto errout;
  2412. status |= DO_SETLINK_NOTIFY;
  2413. }
  2414. if (tb[IFLA_AF_SPEC]) {
  2415. struct nlattr *af;
  2416. int rem;
  2417. nla_for_each_nested(af, tb[IFLA_AF_SPEC], rem) {
  2418. const struct rtnl_af_ops *af_ops;
  2419. rcu_read_lock();
  2420. BUG_ON(!(af_ops = rtnl_af_lookup(nla_type(af))));
  2421. err = af_ops->set_link_af(dev, af);
  2422. if (err < 0) {
  2423. rcu_read_unlock();
  2424. goto errout;
  2425. }
  2426. rcu_read_unlock();
  2427. status |= DO_SETLINK_NOTIFY;
  2428. }
  2429. }
  2430. err = 0;
  2431. if (tb[IFLA_PROTO_DOWN] || tb[IFLA_PROTO_DOWN_REASON]) {
  2432. err = do_set_proto_down(dev, tb[IFLA_PROTO_DOWN],
  2433. tb[IFLA_PROTO_DOWN_REASON], extack);
  2434. if (err)
  2435. goto errout;
  2436. status |= DO_SETLINK_NOTIFY;
  2437. }
  2438. if (tb[IFLA_XDP]) {
  2439. struct nlattr *xdp[IFLA_XDP_MAX + 1];
  2440. u32 xdp_flags = 0;
  2441. err = nla_parse_nested_deprecated(xdp, IFLA_XDP_MAX,
  2442. tb[IFLA_XDP],
  2443. ifla_xdp_policy, NULL);
  2444. if (err < 0)
  2445. goto errout;
  2446. if (xdp[IFLA_XDP_ATTACHED] || xdp[IFLA_XDP_PROG_ID]) {
  2447. err = -EINVAL;
  2448. goto errout;
  2449. }
  2450. if (xdp[IFLA_XDP_FLAGS]) {
  2451. xdp_flags = nla_get_u32(xdp[IFLA_XDP_FLAGS]);
  2452. if (xdp_flags & ~XDP_FLAGS_MASK) {
  2453. err = -EINVAL;
  2454. goto errout;
  2455. }
  2456. if (hweight32(xdp_flags & XDP_FLAGS_MODES) > 1) {
  2457. err = -EINVAL;
  2458. goto errout;
  2459. }
  2460. }
  2461. if (xdp[IFLA_XDP_FD]) {
  2462. int expected_fd = -1;
  2463. if (xdp_flags & XDP_FLAGS_REPLACE) {
  2464. if (!xdp[IFLA_XDP_EXPECTED_FD]) {
  2465. err = -EINVAL;
  2466. goto errout;
  2467. }
  2468. expected_fd =
  2469. nla_get_s32(xdp[IFLA_XDP_EXPECTED_FD]);
  2470. }
  2471. err = dev_change_xdp_fd(dev, extack,
  2472. nla_get_s32(xdp[IFLA_XDP_FD]),
  2473. expected_fd,
  2474. xdp_flags);
  2475. if (err)
  2476. goto errout;
  2477. status |= DO_SETLINK_NOTIFY;
  2478. }
  2479. }
  2480. errout:
  2481. if (status & DO_SETLINK_MODIFIED) {
  2482. if ((status & DO_SETLINK_NOTIFY) == DO_SETLINK_NOTIFY)
  2483. netdev_state_change(dev);
  2484. if (err < 0)
  2485. net_warn_ratelimited("A link change request failed with some changes committed already. Interface %s may have been left with an inconsistent configuration, please check.\n",
  2486. dev->name);
  2487. }
  2488. return err;
  2489. }
  2490. static struct net_device *rtnl_dev_get(struct net *net,
  2491. struct nlattr *ifname_attr,
  2492. struct nlattr *altifname_attr,
  2493. char *ifname)
  2494. {
  2495. char buffer[ALTIFNAMSIZ];
  2496. if (!ifname) {
  2497. ifname = buffer;
  2498. if (ifname_attr)
  2499. nla_strlcpy(ifname, ifname_attr, IFNAMSIZ);
  2500. else if (altifname_attr)
  2501. nla_strlcpy(ifname, altifname_attr, ALTIFNAMSIZ);
  2502. else
  2503. return NULL;
  2504. }
  2505. return __dev_get_by_name(net, ifname);
  2506. }
  2507. static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  2508. struct netlink_ext_ack *extack)
  2509. {
  2510. struct net *net = sock_net(skb->sk);
  2511. struct ifinfomsg *ifm;
  2512. struct net_device *dev;
  2513. int err;
  2514. struct nlattr *tb[IFLA_MAX+1];
  2515. char ifname[IFNAMSIZ];
  2516. err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
  2517. ifla_policy, extack);
  2518. if (err < 0)
  2519. goto errout;
  2520. err = rtnl_ensure_unique_netns(tb, extack, false);
  2521. if (err < 0)
  2522. goto errout;
  2523. if (tb[IFLA_IFNAME])
  2524. nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
  2525. else
  2526. ifname[0] = '\0';
  2527. err = -EINVAL;
  2528. ifm = nlmsg_data(nlh);
  2529. if (ifm->ifi_index > 0)
  2530. dev = __dev_get_by_index(net, ifm->ifi_index);
  2531. else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
  2532. dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
  2533. else
  2534. goto errout;
  2535. if (dev == NULL) {
  2536. err = -ENODEV;
  2537. goto errout;
  2538. }
  2539. err = do_setlink(skb, dev, ifm, extack, tb, ifname, 0);
  2540. errout:
  2541. return err;
  2542. }
  2543. static int rtnl_group_dellink(const struct net *net, int group)
  2544. {
  2545. struct net_device *dev, *aux;
  2546. LIST_HEAD(list_kill);
  2547. bool found = false;
  2548. if (!group)
  2549. return -EPERM;
  2550. for_each_netdev(net, dev) {
  2551. if (dev->group == group) {
  2552. const struct rtnl_link_ops *ops;
  2553. found = true;
  2554. ops = dev->rtnl_link_ops;
  2555. if (!ops || !ops->dellink)
  2556. return -EOPNOTSUPP;
  2557. }
  2558. }
  2559. if (!found)
  2560. return -ENODEV;
  2561. for_each_netdev_safe(net, dev, aux) {
  2562. if (dev->group == group) {
  2563. const struct rtnl_link_ops *ops;
  2564. ops = dev->rtnl_link_ops;
  2565. ops->dellink(dev, &list_kill);
  2566. }
  2567. }
  2568. unregister_netdevice_many(&list_kill);
  2569. return 0;
  2570. }
  2571. int rtnl_delete_link(struct net_device *dev)
  2572. {
  2573. const struct rtnl_link_ops *ops;
  2574. LIST_HEAD(list_kill);
  2575. ops = dev->rtnl_link_ops;
  2576. if (!ops || !ops->dellink)
  2577. return -EOPNOTSUPP;
  2578. ops->dellink(dev, &list_kill);
  2579. unregister_netdevice_many(&list_kill);
  2580. return 0;
  2581. }
  2582. EXPORT_SYMBOL_GPL(rtnl_delete_link);
  2583. static int rtnl_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
  2584. struct netlink_ext_ack *extack)
  2585. {
  2586. struct net *net = sock_net(skb->sk);
  2587. struct net *tgt_net = net;
  2588. struct net_device *dev = NULL;
  2589. struct ifinfomsg *ifm;
  2590. struct nlattr *tb[IFLA_MAX+1];
  2591. int err;
  2592. int netnsid = -1;
  2593. err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
  2594. ifla_policy, extack);
  2595. if (err < 0)
  2596. return err;
  2597. err = rtnl_ensure_unique_netns(tb, extack, true);
  2598. if (err < 0)
  2599. return err;
  2600. if (tb[IFLA_TARGET_NETNSID]) {
  2601. netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
  2602. tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
  2603. if (IS_ERR(tgt_net))
  2604. return PTR_ERR(tgt_net);
  2605. }
  2606. err = -EINVAL;
  2607. ifm = nlmsg_data(nlh);
  2608. if (ifm->ifi_index > 0)
  2609. dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
  2610. else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
  2611. dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
  2612. tb[IFLA_ALT_IFNAME], NULL);
  2613. else if (tb[IFLA_GROUP])
  2614. err = rtnl_group_dellink(tgt_net, nla_get_u32(tb[IFLA_GROUP]));
  2615. else
  2616. goto out;
  2617. if (!dev) {
  2618. if (tb[IFLA_IFNAME] || ifm->ifi_index > 0)
  2619. err = -ENODEV;
  2620. goto out;
  2621. }
  2622. err = rtnl_delete_link(dev);
  2623. out:
  2624. if (netnsid >= 0)
  2625. put_net(tgt_net);
  2626. return err;
  2627. }
  2628. int rtnl_configure_link(struct net_device *dev, const struct ifinfomsg *ifm)
  2629. {
  2630. unsigned int old_flags;
  2631. int err;
  2632. old_flags = dev->flags;
  2633. if (ifm && (ifm->ifi_flags || ifm->ifi_change)) {
  2634. err = __dev_change_flags(dev, rtnl_dev_combine_flags(dev, ifm),
  2635. NULL);
  2636. if (err < 0)
  2637. return err;
  2638. }
  2639. if (dev->rtnl_link_state == RTNL_LINK_INITIALIZED) {
  2640. __dev_notify_flags(dev, old_flags, (old_flags ^ dev->flags));
  2641. } else {
  2642. dev->rtnl_link_state = RTNL_LINK_INITIALIZED;
  2643. __dev_notify_flags(dev, old_flags, ~0U);
  2644. }
  2645. return 0;
  2646. }
  2647. EXPORT_SYMBOL(rtnl_configure_link);
  2648. struct net_device *rtnl_create_link(struct net *net, const char *ifname,
  2649. unsigned char name_assign_type,
  2650. const struct rtnl_link_ops *ops,
  2651. struct nlattr *tb[],
  2652. struct netlink_ext_ack *extack)
  2653. {
  2654. struct net_device *dev;
  2655. unsigned int num_tx_queues = 1;
  2656. unsigned int num_rx_queues = 1;
  2657. if (tb[IFLA_NUM_TX_QUEUES])
  2658. num_tx_queues = nla_get_u32(tb[IFLA_NUM_TX_QUEUES]);
  2659. else if (ops->get_num_tx_queues)
  2660. num_tx_queues = ops->get_num_tx_queues();
  2661. if (tb[IFLA_NUM_RX_QUEUES])
  2662. num_rx_queues = nla_get_u32(tb[IFLA_NUM_RX_QUEUES]);
  2663. else if (ops->get_num_rx_queues)
  2664. num_rx_queues = ops->get_num_rx_queues();
  2665. if (num_tx_queues < 1 || num_tx_queues > 4096) {
  2666. NL_SET_ERR_MSG(extack, "Invalid number of transmit queues");
  2667. return ERR_PTR(-EINVAL);
  2668. }
  2669. if (num_rx_queues < 1 || num_rx_queues > 4096) {
  2670. NL_SET_ERR_MSG(extack, "Invalid number of receive queues");
  2671. return ERR_PTR(-EINVAL);
  2672. }
  2673. dev = alloc_netdev_mqs(ops->priv_size, ifname, name_assign_type,
  2674. ops->setup, num_tx_queues, num_rx_queues);
  2675. if (!dev)
  2676. return ERR_PTR(-ENOMEM);
  2677. dev_net_set(dev, net);
  2678. dev->rtnl_link_ops = ops;
  2679. dev->rtnl_link_state = RTNL_LINK_INITIALIZING;
  2680. if (tb[IFLA_MTU]) {
  2681. u32 mtu = nla_get_u32(tb[IFLA_MTU]);
  2682. int err;
  2683. err = dev_validate_mtu(dev, mtu, extack);
  2684. if (err) {
  2685. free_netdev(dev);
  2686. return ERR_PTR(err);
  2687. }
  2688. dev->mtu = mtu;
  2689. }
  2690. if (tb[IFLA_ADDRESS]) {
  2691. memcpy(dev->dev_addr, nla_data(tb[IFLA_ADDRESS]),
  2692. nla_len(tb[IFLA_ADDRESS]));
  2693. dev->addr_assign_type = NET_ADDR_SET;
  2694. }
  2695. if (tb[IFLA_BROADCAST])
  2696. memcpy(dev->broadcast, nla_data(tb[IFLA_BROADCAST]),
  2697. nla_len(tb[IFLA_BROADCAST]));
  2698. if (tb[IFLA_TXQLEN])
  2699. dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
  2700. if (tb[IFLA_OPERSTATE])
  2701. set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
  2702. if (tb[IFLA_LINKMODE])
  2703. dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
  2704. if (tb[IFLA_GROUP])
  2705. dev_set_group(dev, nla_get_u32(tb[IFLA_GROUP]));
  2706. if (tb[IFLA_GSO_MAX_SIZE])
  2707. netif_set_gso_max_size(dev, nla_get_u32(tb[IFLA_GSO_MAX_SIZE]));
  2708. if (tb[IFLA_GSO_MAX_SEGS])
  2709. dev->gso_max_segs = nla_get_u32(tb[IFLA_GSO_MAX_SEGS]);
  2710. return dev;
  2711. }
  2712. EXPORT_SYMBOL(rtnl_create_link);
  2713. static int rtnl_group_changelink(const struct sk_buff *skb,
  2714. struct net *net, int group,
  2715. struct ifinfomsg *ifm,
  2716. struct netlink_ext_ack *extack,
  2717. struct nlattr **tb)
  2718. {
  2719. struct net_device *dev, *aux;
  2720. int err;
  2721. for_each_netdev_safe(net, dev, aux) {
  2722. if (dev->group == group) {
  2723. err = do_setlink(skb, dev, ifm, extack, tb, NULL, 0);
  2724. if (err < 0)
  2725. return err;
  2726. }
  2727. }
  2728. return 0;
  2729. }
  2730. static int __rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  2731. struct nlattr **attr, struct netlink_ext_ack *extack)
  2732. {
  2733. struct nlattr *slave_attr[RTNL_SLAVE_MAX_TYPE + 1];
  2734. unsigned char name_assign_type = NET_NAME_USER;
  2735. struct nlattr *linkinfo[IFLA_INFO_MAX + 1];
  2736. const struct rtnl_link_ops *m_ops;
  2737. struct net_device *master_dev;
  2738. struct net *net = sock_net(skb->sk);
  2739. const struct rtnl_link_ops *ops;
  2740. struct nlattr *tb[IFLA_MAX + 1];
  2741. struct net *dest_net, *link_net;
  2742. struct nlattr **slave_data;
  2743. char kind[MODULE_NAME_LEN];
  2744. struct net_device *dev;
  2745. struct ifinfomsg *ifm;
  2746. char ifname[IFNAMSIZ];
  2747. struct nlattr **data;
  2748. int err;
  2749. #ifdef CONFIG_MODULES
  2750. replay:
  2751. #endif
  2752. err = nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
  2753. ifla_policy, extack);
  2754. if (err < 0)
  2755. return err;
  2756. err = rtnl_ensure_unique_netns(tb, extack, false);
  2757. if (err < 0)
  2758. return err;
  2759. if (tb[IFLA_IFNAME])
  2760. nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
  2761. else
  2762. ifname[0] = '\0';
  2763. ifm = nlmsg_data(nlh);
  2764. if (ifm->ifi_index > 0)
  2765. dev = __dev_get_by_index(net, ifm->ifi_index);
  2766. else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
  2767. dev = rtnl_dev_get(net, NULL, tb[IFLA_ALT_IFNAME], ifname);
  2768. else
  2769. dev = NULL;
  2770. master_dev = NULL;
  2771. m_ops = NULL;
  2772. if (dev) {
  2773. master_dev = netdev_master_upper_dev_get(dev);
  2774. if (master_dev)
  2775. m_ops = master_dev->rtnl_link_ops;
  2776. }
  2777. err = validate_linkmsg(dev, tb);
  2778. if (err < 0)
  2779. return err;
  2780. if (tb[IFLA_LINKINFO]) {
  2781. err = nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX,
  2782. tb[IFLA_LINKINFO],
  2783. ifla_info_policy, NULL);
  2784. if (err < 0)
  2785. return err;
  2786. } else
  2787. memset(linkinfo, 0, sizeof(linkinfo));
  2788. if (linkinfo[IFLA_INFO_KIND]) {
  2789. nla_strlcpy(kind, linkinfo[IFLA_INFO_KIND], sizeof(kind));
  2790. ops = rtnl_link_ops_get(kind);
  2791. } else {
  2792. kind[0] = '\0';
  2793. ops = NULL;
  2794. }
  2795. data = NULL;
  2796. if (ops) {
  2797. if (ops->maxtype > RTNL_MAX_TYPE)
  2798. return -EINVAL;
  2799. if (ops->maxtype && linkinfo[IFLA_INFO_DATA]) {
  2800. err = nla_parse_nested_deprecated(attr, ops->maxtype,
  2801. linkinfo[IFLA_INFO_DATA],
  2802. ops->policy, extack);
  2803. if (err < 0)
  2804. return err;
  2805. data = attr;
  2806. }
  2807. if (ops->validate) {
  2808. err = ops->validate(tb, data, extack);
  2809. if (err < 0)
  2810. return err;
  2811. }
  2812. }
  2813. slave_data = NULL;
  2814. if (m_ops) {
  2815. if (m_ops->slave_maxtype > RTNL_SLAVE_MAX_TYPE)
  2816. return -EINVAL;
  2817. if (m_ops->slave_maxtype &&
  2818. linkinfo[IFLA_INFO_SLAVE_DATA]) {
  2819. err = nla_parse_nested_deprecated(slave_attr,
  2820. m_ops->slave_maxtype,
  2821. linkinfo[IFLA_INFO_SLAVE_DATA],
  2822. m_ops->slave_policy,
  2823. extack);
  2824. if (err < 0)
  2825. return err;
  2826. slave_data = slave_attr;
  2827. }
  2828. }
  2829. if (dev) {
  2830. int status = 0;
  2831. if (nlh->nlmsg_flags & NLM_F_EXCL)
  2832. return -EEXIST;
  2833. if (nlh->nlmsg_flags & NLM_F_REPLACE)
  2834. return -EOPNOTSUPP;
  2835. if (linkinfo[IFLA_INFO_DATA]) {
  2836. if (!ops || ops != dev->rtnl_link_ops ||
  2837. !ops->changelink)
  2838. return -EOPNOTSUPP;
  2839. err = ops->changelink(dev, tb, data, extack);
  2840. if (err < 0)
  2841. return err;
  2842. status |= DO_SETLINK_NOTIFY;
  2843. }
  2844. if (linkinfo[IFLA_INFO_SLAVE_DATA]) {
  2845. if (!m_ops || !m_ops->slave_changelink)
  2846. return -EOPNOTSUPP;
  2847. err = m_ops->slave_changelink(master_dev, dev, tb,
  2848. slave_data, extack);
  2849. if (err < 0)
  2850. return err;
  2851. status |= DO_SETLINK_NOTIFY;
  2852. }
  2853. return do_setlink(skb, dev, ifm, extack, tb, ifname, status);
  2854. }
  2855. if (!(nlh->nlmsg_flags & NLM_F_CREATE)) {
  2856. if (ifm->ifi_index == 0 && tb[IFLA_GROUP])
  2857. return rtnl_group_changelink(skb, net,
  2858. nla_get_u32(tb[IFLA_GROUP]),
  2859. ifm, extack, tb);
  2860. return -ENODEV;
  2861. }
  2862. if (tb[IFLA_MAP] || tb[IFLA_PROTINFO])
  2863. return -EOPNOTSUPP;
  2864. if (!ops) {
  2865. #ifdef CONFIG_MODULES
  2866. if (kind[0]) {
  2867. __rtnl_unlock();
  2868. request_module("rtnl-link-%s", kind);
  2869. rtnl_lock();
  2870. ops = rtnl_link_ops_get(kind);
  2871. if (ops)
  2872. goto replay;
  2873. }
  2874. #endif
  2875. NL_SET_ERR_MSG(extack, "Unknown device type");
  2876. return -EOPNOTSUPP;
  2877. }
  2878. if (!ops->setup)
  2879. return -EOPNOTSUPP;
  2880. if (!ifname[0]) {
  2881. snprintf(ifname, IFNAMSIZ, "%s%%d", ops->kind);
  2882. name_assign_type = NET_NAME_ENUM;
  2883. }
  2884. dest_net = rtnl_link_get_net_capable(skb, net, tb, CAP_NET_ADMIN);
  2885. if (IS_ERR(dest_net))
  2886. return PTR_ERR(dest_net);
  2887. if (tb[IFLA_LINK_NETNSID]) {
  2888. int id = nla_get_s32(tb[IFLA_LINK_NETNSID]);
  2889. link_net = get_net_ns_by_id(dest_net, id);
  2890. if (!link_net) {
  2891. NL_SET_ERR_MSG(extack, "Unknown network namespace id");
  2892. err = -EINVAL;
  2893. goto out;
  2894. }
  2895. err = -EPERM;
  2896. if (!netlink_ns_capable(skb, link_net->user_ns, CAP_NET_ADMIN))
  2897. goto out;
  2898. } else {
  2899. link_net = NULL;
  2900. }
  2901. dev = rtnl_create_link(link_net ? : dest_net, ifname,
  2902. name_assign_type, ops, tb, extack);
  2903. if (IS_ERR(dev)) {
  2904. err = PTR_ERR(dev);
  2905. goto out;
  2906. }
  2907. dev->ifindex = ifm->ifi_index;
  2908. if (ops->newlink) {
  2909. err = ops->newlink(link_net ? : net, dev, tb, data, extack);
  2910. /* Drivers should call free_netdev() in ->destructor
  2911. * and unregister it on failure after registration
  2912. * so that device could be finally freed in rtnl_unlock.
  2913. */
  2914. if (err < 0) {
  2915. /* If device is not registered at all, free it now */
  2916. if (dev->reg_state == NETREG_UNINITIALIZED ||
  2917. dev->reg_state == NETREG_UNREGISTERED)
  2918. free_netdev(dev);
  2919. goto out;
  2920. }
  2921. } else {
  2922. err = register_netdevice(dev);
  2923. if (err < 0) {
  2924. free_netdev(dev);
  2925. goto out;
  2926. }
  2927. }
  2928. err = rtnl_configure_link(dev, ifm);
  2929. if (err < 0)
  2930. goto out_unregister;
  2931. if (link_net) {
  2932. err = dev_change_net_namespace(dev, dest_net, ifname);
  2933. if (err < 0)
  2934. goto out_unregister;
  2935. }
  2936. if (tb[IFLA_MASTER]) {
  2937. err = do_set_master(dev, nla_get_u32(tb[IFLA_MASTER]), extack);
  2938. if (err)
  2939. goto out_unregister;
  2940. }
  2941. out:
  2942. if (link_net)
  2943. put_net(link_net);
  2944. put_net(dest_net);
  2945. return err;
  2946. out_unregister:
  2947. if (ops->newlink) {
  2948. LIST_HEAD(list_kill);
  2949. ops->dellink(dev, &list_kill);
  2950. unregister_netdevice_many(&list_kill);
  2951. } else {
  2952. unregister_netdevice(dev);
  2953. }
  2954. goto out;
  2955. }
  2956. static int rtnl_newlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  2957. struct netlink_ext_ack *extack)
  2958. {
  2959. struct nlattr **attr;
  2960. int ret;
  2961. attr = kmalloc_array(RTNL_MAX_TYPE + 1, sizeof(*attr), GFP_KERNEL);
  2962. if (!attr)
  2963. return -ENOMEM;
  2964. ret = __rtnl_newlink(skb, nlh, attr, extack);
  2965. kfree(attr);
  2966. return ret;
  2967. }
  2968. static int rtnl_valid_getlink_req(struct sk_buff *skb,
  2969. const struct nlmsghdr *nlh,
  2970. struct nlattr **tb,
  2971. struct netlink_ext_ack *extack)
  2972. {
  2973. struct ifinfomsg *ifm;
  2974. int i, err;
  2975. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
  2976. NL_SET_ERR_MSG(extack, "Invalid header for get link");
  2977. return -EINVAL;
  2978. }
  2979. if (!netlink_strict_get_check(skb))
  2980. return nlmsg_parse_deprecated(nlh, sizeof(*ifm), tb, IFLA_MAX,
  2981. ifla_policy, extack);
  2982. ifm = nlmsg_data(nlh);
  2983. if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
  2984. ifm->ifi_change) {
  2985. NL_SET_ERR_MSG(extack, "Invalid values in header for get link request");
  2986. return -EINVAL;
  2987. }
  2988. err = nlmsg_parse_deprecated_strict(nlh, sizeof(*ifm), tb, IFLA_MAX,
  2989. ifla_policy, extack);
  2990. if (err)
  2991. return err;
  2992. for (i = 0; i <= IFLA_MAX; i++) {
  2993. if (!tb[i])
  2994. continue;
  2995. switch (i) {
  2996. case IFLA_IFNAME:
  2997. case IFLA_ALT_IFNAME:
  2998. case IFLA_EXT_MASK:
  2999. case IFLA_TARGET_NETNSID:
  3000. break;
  3001. default:
  3002. NL_SET_ERR_MSG(extack, "Unsupported attribute in get link request");
  3003. return -EINVAL;
  3004. }
  3005. }
  3006. return 0;
  3007. }
  3008. static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  3009. struct netlink_ext_ack *extack)
  3010. {
  3011. struct net *net = sock_net(skb->sk);
  3012. struct net *tgt_net = net;
  3013. struct ifinfomsg *ifm;
  3014. struct nlattr *tb[IFLA_MAX+1];
  3015. struct net_device *dev = NULL;
  3016. struct sk_buff *nskb;
  3017. int netnsid = -1;
  3018. int err;
  3019. u32 ext_filter_mask = 0;
  3020. err = rtnl_valid_getlink_req(skb, nlh, tb, extack);
  3021. if (err < 0)
  3022. return err;
  3023. err = rtnl_ensure_unique_netns(tb, extack, true);
  3024. if (err < 0)
  3025. return err;
  3026. if (tb[IFLA_TARGET_NETNSID]) {
  3027. netnsid = nla_get_s32(tb[IFLA_TARGET_NETNSID]);
  3028. tgt_net = rtnl_get_net_ns_capable(NETLINK_CB(skb).sk, netnsid);
  3029. if (IS_ERR(tgt_net))
  3030. return PTR_ERR(tgt_net);
  3031. }
  3032. if (tb[IFLA_EXT_MASK])
  3033. ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
  3034. err = -EINVAL;
  3035. ifm = nlmsg_data(nlh);
  3036. if (ifm->ifi_index > 0)
  3037. dev = __dev_get_by_index(tgt_net, ifm->ifi_index);
  3038. else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
  3039. dev = rtnl_dev_get(tgt_net, tb[IFLA_IFNAME],
  3040. tb[IFLA_ALT_IFNAME], NULL);
  3041. else
  3042. goto out;
  3043. err = -ENODEV;
  3044. if (dev == NULL)
  3045. goto out;
  3046. err = -ENOBUFS;
  3047. nskb = nlmsg_new(if_nlmsg_size(dev, ext_filter_mask), GFP_KERNEL);
  3048. if (nskb == NULL)
  3049. goto out;
  3050. err = rtnl_fill_ifinfo(nskb, dev, net,
  3051. RTM_NEWLINK, NETLINK_CB(skb).portid,
  3052. nlh->nlmsg_seq, 0, 0, ext_filter_mask,
  3053. 0, NULL, 0, netnsid, GFP_KERNEL);
  3054. if (err < 0) {
  3055. /* -EMSGSIZE implies BUG in if_nlmsg_size */
  3056. WARN_ON(err == -EMSGSIZE);
  3057. kfree_skb(nskb);
  3058. } else
  3059. err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
  3060. out:
  3061. if (netnsid >= 0)
  3062. put_net(tgt_net);
  3063. return err;
  3064. }
  3065. static int rtnl_alt_ifname(int cmd, struct net_device *dev, struct nlattr *attr,
  3066. bool *changed, struct netlink_ext_ack *extack)
  3067. {
  3068. char *alt_ifname;
  3069. size_t size;
  3070. int err;
  3071. err = nla_validate(attr, attr->nla_len, IFLA_MAX, ifla_policy, extack);
  3072. if (err)
  3073. return err;
  3074. if (cmd == RTM_NEWLINKPROP) {
  3075. size = rtnl_prop_list_size(dev);
  3076. size += nla_total_size(ALTIFNAMSIZ);
  3077. if (size >= U16_MAX) {
  3078. NL_SET_ERR_MSG(extack,
  3079. "effective property list too long");
  3080. return -EINVAL;
  3081. }
  3082. }
  3083. alt_ifname = nla_strdup(attr, GFP_KERNEL_ACCOUNT);
  3084. if (!alt_ifname)
  3085. return -ENOMEM;
  3086. if (cmd == RTM_NEWLINKPROP) {
  3087. err = netdev_name_node_alt_create(dev, alt_ifname);
  3088. if (!err)
  3089. alt_ifname = NULL;
  3090. } else if (cmd == RTM_DELLINKPROP) {
  3091. err = netdev_name_node_alt_destroy(dev, alt_ifname);
  3092. } else {
  3093. WARN_ON_ONCE(1);
  3094. err = -EINVAL;
  3095. }
  3096. kfree(alt_ifname);
  3097. if (!err)
  3098. *changed = true;
  3099. return err;
  3100. }
  3101. static int rtnl_linkprop(int cmd, struct sk_buff *skb, struct nlmsghdr *nlh,
  3102. struct netlink_ext_ack *extack)
  3103. {
  3104. struct net *net = sock_net(skb->sk);
  3105. struct nlattr *tb[IFLA_MAX + 1];
  3106. struct net_device *dev;
  3107. struct ifinfomsg *ifm;
  3108. bool changed = false;
  3109. struct nlattr *attr;
  3110. int err, rem;
  3111. err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy, extack);
  3112. if (err)
  3113. return err;
  3114. err = rtnl_ensure_unique_netns(tb, extack, true);
  3115. if (err)
  3116. return err;
  3117. ifm = nlmsg_data(nlh);
  3118. if (ifm->ifi_index > 0)
  3119. dev = __dev_get_by_index(net, ifm->ifi_index);
  3120. else if (tb[IFLA_IFNAME] || tb[IFLA_ALT_IFNAME])
  3121. dev = rtnl_dev_get(net, tb[IFLA_IFNAME],
  3122. tb[IFLA_ALT_IFNAME], NULL);
  3123. else
  3124. return -EINVAL;
  3125. if (!dev)
  3126. return -ENODEV;
  3127. if (!tb[IFLA_PROP_LIST])
  3128. return 0;
  3129. nla_for_each_nested(attr, tb[IFLA_PROP_LIST], rem) {
  3130. switch (nla_type(attr)) {
  3131. case IFLA_ALT_IFNAME:
  3132. err = rtnl_alt_ifname(cmd, dev, attr, &changed, extack);
  3133. if (err)
  3134. return err;
  3135. break;
  3136. }
  3137. }
  3138. if (changed)
  3139. netdev_state_change(dev);
  3140. return 0;
  3141. }
  3142. static int rtnl_newlinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
  3143. struct netlink_ext_ack *extack)
  3144. {
  3145. return rtnl_linkprop(RTM_NEWLINKPROP, skb, nlh, extack);
  3146. }
  3147. static int rtnl_dellinkprop(struct sk_buff *skb, struct nlmsghdr *nlh,
  3148. struct netlink_ext_ack *extack)
  3149. {
  3150. return rtnl_linkprop(RTM_DELLINKPROP, skb, nlh, extack);
  3151. }
  3152. static u32 rtnl_calcit(struct sk_buff *skb, struct nlmsghdr *nlh)
  3153. {
  3154. struct net *net = sock_net(skb->sk);
  3155. size_t min_ifinfo_dump_size = 0;
  3156. struct nlattr *tb[IFLA_MAX+1];
  3157. u32 ext_filter_mask = 0;
  3158. struct net_device *dev;
  3159. int hdrlen;
  3160. /* Same kernel<->userspace interface hack as in rtnl_dump_ifinfo. */
  3161. hdrlen = nlmsg_len(nlh) < sizeof(struct ifinfomsg) ?
  3162. sizeof(struct rtgenmsg) : sizeof(struct ifinfomsg);
  3163. if (nlmsg_parse_deprecated(nlh, hdrlen, tb, IFLA_MAX, ifla_policy, NULL) >= 0) {
  3164. if (tb[IFLA_EXT_MASK])
  3165. ext_filter_mask = nla_get_u32(tb[IFLA_EXT_MASK]);
  3166. }
  3167. if (!ext_filter_mask)
  3168. return NLMSG_GOODSIZE;
  3169. /*
  3170. * traverse the list of net devices and compute the minimum
  3171. * buffer size based upon the filter mask.
  3172. */
  3173. rcu_read_lock();
  3174. for_each_netdev_rcu(net, dev) {
  3175. min_ifinfo_dump_size = max(min_ifinfo_dump_size,
  3176. if_nlmsg_size(dev, ext_filter_mask));
  3177. }
  3178. rcu_read_unlock();
  3179. return nlmsg_total_size(min_ifinfo_dump_size);
  3180. }
  3181. static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
  3182. {
  3183. int idx;
  3184. int s_idx = cb->family;
  3185. int type = cb->nlh->nlmsg_type - RTM_BASE;
  3186. int ret = 0;
  3187. if (s_idx == 0)
  3188. s_idx = 1;
  3189. for (idx = 1; idx <= RTNL_FAMILY_MAX; idx++) {
  3190. struct rtnl_link **tab;
  3191. struct rtnl_link *link;
  3192. rtnl_dumpit_func dumpit;
  3193. if (idx < s_idx || idx == PF_PACKET)
  3194. continue;
  3195. if (type < 0 || type >= RTM_NR_MSGTYPES)
  3196. continue;
  3197. tab = rcu_dereference_rtnl(rtnl_msg_handlers[idx]);
  3198. if (!tab)
  3199. continue;
  3200. link = tab[type];
  3201. if (!link)
  3202. continue;
  3203. dumpit = link->dumpit;
  3204. if (!dumpit)
  3205. continue;
  3206. if (idx > s_idx) {
  3207. memset(&cb->args[0], 0, sizeof(cb->args));
  3208. cb->prev_seq = 0;
  3209. cb->seq = 0;
  3210. }
  3211. ret = dumpit(skb, cb);
  3212. if (ret)
  3213. break;
  3214. }
  3215. cb->family = idx;
  3216. return skb->len ? : ret;
  3217. }
  3218. struct sk_buff *rtmsg_ifinfo_build_skb(int type, struct net_device *dev,
  3219. unsigned int change,
  3220. u32 event, gfp_t flags, int *new_nsid,
  3221. int new_ifindex)
  3222. {
  3223. struct net *net = dev_net(dev);
  3224. struct sk_buff *skb;
  3225. int err = -ENOBUFS;
  3226. size_t if_info_size;
  3227. skb = nlmsg_new((if_info_size = if_nlmsg_size(dev, 0)), flags);
  3228. if (skb == NULL)
  3229. goto errout;
  3230. err = rtnl_fill_ifinfo(skb, dev, dev_net(dev),
  3231. type, 0, 0, change, 0, 0, event,
  3232. new_nsid, new_ifindex, -1, flags);
  3233. if (err < 0) {
  3234. /* -EMSGSIZE implies BUG in if_nlmsg_size() */
  3235. WARN_ON(err == -EMSGSIZE);
  3236. kfree_skb(skb);
  3237. goto errout;
  3238. }
  3239. return skb;
  3240. errout:
  3241. if (err < 0)
  3242. rtnl_set_sk_err(net, RTNLGRP_LINK, err);
  3243. return NULL;
  3244. }
  3245. void rtmsg_ifinfo_send(struct sk_buff *skb, struct net_device *dev, gfp_t flags)
  3246. {
  3247. struct net *net = dev_net(dev);
  3248. rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, flags);
  3249. }
  3250. static void rtmsg_ifinfo_event(int type, struct net_device *dev,
  3251. unsigned int change, u32 event,
  3252. gfp_t flags, int *new_nsid, int new_ifindex)
  3253. {
  3254. struct sk_buff *skb;
  3255. if (dev->reg_state != NETREG_REGISTERED)
  3256. return;
  3257. skb = rtmsg_ifinfo_build_skb(type, dev, change, event, flags, new_nsid,
  3258. new_ifindex);
  3259. if (skb)
  3260. rtmsg_ifinfo_send(skb, dev, flags);
  3261. }
  3262. void rtmsg_ifinfo(int type, struct net_device *dev, unsigned int change,
  3263. gfp_t flags)
  3264. {
  3265. rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
  3266. NULL, 0);
  3267. }
  3268. void rtmsg_ifinfo_newnet(int type, struct net_device *dev, unsigned int change,
  3269. gfp_t flags, int *new_nsid, int new_ifindex)
  3270. {
  3271. rtmsg_ifinfo_event(type, dev, change, rtnl_get_event(0), flags,
  3272. new_nsid, new_ifindex);
  3273. }
  3274. static int nlmsg_populate_fdb_fill(struct sk_buff *skb,
  3275. struct net_device *dev,
  3276. u8 *addr, u16 vid, u32 pid, u32 seq,
  3277. int type, unsigned int flags,
  3278. int nlflags, u16 ndm_state)
  3279. {
  3280. struct nlmsghdr *nlh;
  3281. struct ndmsg *ndm;
  3282. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ndm), nlflags);
  3283. if (!nlh)
  3284. return -EMSGSIZE;
  3285. ndm = nlmsg_data(nlh);
  3286. ndm->ndm_family = AF_BRIDGE;
  3287. ndm->ndm_pad1 = 0;
  3288. ndm->ndm_pad2 = 0;
  3289. ndm->ndm_flags = flags;
  3290. ndm->ndm_type = 0;
  3291. ndm->ndm_ifindex = dev->ifindex;
  3292. ndm->ndm_state = ndm_state;
  3293. if (nla_put(skb, NDA_LLADDR, ETH_ALEN, addr))
  3294. goto nla_put_failure;
  3295. if (vid)
  3296. if (nla_put(skb, NDA_VLAN, sizeof(u16), &vid))
  3297. goto nla_put_failure;
  3298. nlmsg_end(skb, nlh);
  3299. return 0;
  3300. nla_put_failure:
  3301. nlmsg_cancel(skb, nlh);
  3302. return -EMSGSIZE;
  3303. }
  3304. static inline size_t rtnl_fdb_nlmsg_size(void)
  3305. {
  3306. return NLMSG_ALIGN(sizeof(struct ndmsg)) +
  3307. nla_total_size(ETH_ALEN) + /* NDA_LLADDR */
  3308. nla_total_size(sizeof(u16)) + /* NDA_VLAN */
  3309. 0;
  3310. }
  3311. static void rtnl_fdb_notify(struct net_device *dev, u8 *addr, u16 vid, int type,
  3312. u16 ndm_state)
  3313. {
  3314. struct net *net = dev_net(dev);
  3315. struct sk_buff *skb;
  3316. int err = -ENOBUFS;
  3317. skb = nlmsg_new(rtnl_fdb_nlmsg_size(), GFP_ATOMIC);
  3318. if (!skb)
  3319. goto errout;
  3320. err = nlmsg_populate_fdb_fill(skb, dev, addr, vid,
  3321. 0, 0, type, NTF_SELF, 0, ndm_state);
  3322. if (err < 0) {
  3323. kfree_skb(skb);
  3324. goto errout;
  3325. }
  3326. rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
  3327. return;
  3328. errout:
  3329. rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
  3330. }
  3331. /*
  3332. * ndo_dflt_fdb_add - default netdevice operation to add an FDB entry
  3333. */
  3334. int ndo_dflt_fdb_add(struct ndmsg *ndm,
  3335. struct nlattr *tb[],
  3336. struct net_device *dev,
  3337. const unsigned char *addr, u16 vid,
  3338. u16 flags)
  3339. {
  3340. int err = -EINVAL;
  3341. /* If aging addresses are supported device will need to
  3342. * implement its own handler for this.
  3343. */
  3344. if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
  3345. pr_info("%s: FDB only supports static addresses\n", dev->name);
  3346. return err;
  3347. }
  3348. if (vid) {
  3349. pr_info("%s: vlans aren't supported yet for dev_uc|mc_add()\n", dev->name);
  3350. return err;
  3351. }
  3352. if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
  3353. err = dev_uc_add_excl(dev, addr);
  3354. else if (is_multicast_ether_addr(addr))
  3355. err = dev_mc_add_excl(dev, addr);
  3356. /* Only return duplicate errors if NLM_F_EXCL is set */
  3357. if (err == -EEXIST && !(flags & NLM_F_EXCL))
  3358. err = 0;
  3359. return err;
  3360. }
  3361. EXPORT_SYMBOL(ndo_dflt_fdb_add);
  3362. static int fdb_vid_parse(struct nlattr *vlan_attr, u16 *p_vid,
  3363. struct netlink_ext_ack *extack)
  3364. {
  3365. u16 vid = 0;
  3366. if (vlan_attr) {
  3367. if (nla_len(vlan_attr) != sizeof(u16)) {
  3368. NL_SET_ERR_MSG(extack, "invalid vlan attribute size");
  3369. return -EINVAL;
  3370. }
  3371. vid = nla_get_u16(vlan_attr);
  3372. if (!vid || vid >= VLAN_VID_MASK) {
  3373. NL_SET_ERR_MSG(extack, "invalid vlan id");
  3374. return -EINVAL;
  3375. }
  3376. }
  3377. *p_vid = vid;
  3378. return 0;
  3379. }
  3380. static int rtnl_fdb_add(struct sk_buff *skb, struct nlmsghdr *nlh,
  3381. struct netlink_ext_ack *extack)
  3382. {
  3383. struct net *net = sock_net(skb->sk);
  3384. struct ndmsg *ndm;
  3385. struct nlattr *tb[NDA_MAX+1];
  3386. struct net_device *dev;
  3387. u8 *addr;
  3388. u16 vid;
  3389. int err;
  3390. err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
  3391. extack);
  3392. if (err < 0)
  3393. return err;
  3394. ndm = nlmsg_data(nlh);
  3395. if (ndm->ndm_ifindex == 0) {
  3396. NL_SET_ERR_MSG(extack, "invalid ifindex");
  3397. return -EINVAL;
  3398. }
  3399. dev = __dev_get_by_index(net, ndm->ndm_ifindex);
  3400. if (dev == NULL) {
  3401. NL_SET_ERR_MSG(extack, "unknown ifindex");
  3402. return -ENODEV;
  3403. }
  3404. if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
  3405. NL_SET_ERR_MSG(extack, "invalid address");
  3406. return -EINVAL;
  3407. }
  3408. if (dev->type != ARPHRD_ETHER) {
  3409. NL_SET_ERR_MSG(extack, "FDB add only supported for Ethernet devices");
  3410. return -EINVAL;
  3411. }
  3412. addr = nla_data(tb[NDA_LLADDR]);
  3413. err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
  3414. if (err)
  3415. return err;
  3416. err = -EOPNOTSUPP;
  3417. /* Support fdb on master device the net/bridge default case */
  3418. if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
  3419. netif_is_bridge_port(dev)) {
  3420. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  3421. const struct net_device_ops *ops = br_dev->netdev_ops;
  3422. err = ops->ndo_fdb_add(ndm, tb, dev, addr, vid,
  3423. nlh->nlmsg_flags, extack);
  3424. if (err)
  3425. goto out;
  3426. else
  3427. ndm->ndm_flags &= ~NTF_MASTER;
  3428. }
  3429. /* Embedded bridge, macvlan, and any other device support */
  3430. if ((ndm->ndm_flags & NTF_SELF)) {
  3431. if (dev->netdev_ops->ndo_fdb_add)
  3432. err = dev->netdev_ops->ndo_fdb_add(ndm, tb, dev, addr,
  3433. vid,
  3434. nlh->nlmsg_flags,
  3435. extack);
  3436. else
  3437. err = ndo_dflt_fdb_add(ndm, tb, dev, addr, vid,
  3438. nlh->nlmsg_flags);
  3439. if (!err) {
  3440. rtnl_fdb_notify(dev, addr, vid, RTM_NEWNEIGH,
  3441. ndm->ndm_state);
  3442. ndm->ndm_flags &= ~NTF_SELF;
  3443. }
  3444. }
  3445. out:
  3446. return err;
  3447. }
  3448. /*
  3449. * ndo_dflt_fdb_del - default netdevice operation to delete an FDB entry
  3450. */
  3451. int ndo_dflt_fdb_del(struct ndmsg *ndm,
  3452. struct nlattr *tb[],
  3453. struct net_device *dev,
  3454. const unsigned char *addr, u16 vid)
  3455. {
  3456. int err = -EINVAL;
  3457. /* If aging addresses are supported device will need to
  3458. * implement its own handler for this.
  3459. */
  3460. if (!(ndm->ndm_state & NUD_PERMANENT)) {
  3461. pr_info("%s: FDB only supports static addresses\n", dev->name);
  3462. return err;
  3463. }
  3464. if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
  3465. err = dev_uc_del(dev, addr);
  3466. else if (is_multicast_ether_addr(addr))
  3467. err = dev_mc_del(dev, addr);
  3468. return err;
  3469. }
  3470. EXPORT_SYMBOL(ndo_dflt_fdb_del);
  3471. static int rtnl_fdb_del(struct sk_buff *skb, struct nlmsghdr *nlh,
  3472. struct netlink_ext_ack *extack)
  3473. {
  3474. struct net *net = sock_net(skb->sk);
  3475. struct ndmsg *ndm;
  3476. struct nlattr *tb[NDA_MAX+1];
  3477. struct net_device *dev;
  3478. __u8 *addr;
  3479. int err;
  3480. u16 vid;
  3481. if (!netlink_capable(skb, CAP_NET_ADMIN))
  3482. return -EPERM;
  3483. err = nlmsg_parse_deprecated(nlh, sizeof(*ndm), tb, NDA_MAX, NULL,
  3484. extack);
  3485. if (err < 0)
  3486. return err;
  3487. ndm = nlmsg_data(nlh);
  3488. if (ndm->ndm_ifindex == 0) {
  3489. NL_SET_ERR_MSG(extack, "invalid ifindex");
  3490. return -EINVAL;
  3491. }
  3492. dev = __dev_get_by_index(net, ndm->ndm_ifindex);
  3493. if (dev == NULL) {
  3494. NL_SET_ERR_MSG(extack, "unknown ifindex");
  3495. return -ENODEV;
  3496. }
  3497. if (!tb[NDA_LLADDR] || nla_len(tb[NDA_LLADDR]) != ETH_ALEN) {
  3498. NL_SET_ERR_MSG(extack, "invalid address");
  3499. return -EINVAL;
  3500. }
  3501. if (dev->type != ARPHRD_ETHER) {
  3502. NL_SET_ERR_MSG(extack, "FDB delete only supported for Ethernet devices");
  3503. return -EINVAL;
  3504. }
  3505. addr = nla_data(tb[NDA_LLADDR]);
  3506. err = fdb_vid_parse(tb[NDA_VLAN], &vid, extack);
  3507. if (err)
  3508. return err;
  3509. err = -EOPNOTSUPP;
  3510. /* Support fdb on master device the net/bridge default case */
  3511. if ((!ndm->ndm_flags || ndm->ndm_flags & NTF_MASTER) &&
  3512. netif_is_bridge_port(dev)) {
  3513. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  3514. const struct net_device_ops *ops = br_dev->netdev_ops;
  3515. if (ops->ndo_fdb_del)
  3516. err = ops->ndo_fdb_del(ndm, tb, dev, addr, vid);
  3517. if (err)
  3518. goto out;
  3519. else
  3520. ndm->ndm_flags &= ~NTF_MASTER;
  3521. }
  3522. /* Embedded bridge, macvlan, and any other device support */
  3523. if (ndm->ndm_flags & NTF_SELF) {
  3524. if (dev->netdev_ops->ndo_fdb_del)
  3525. err = dev->netdev_ops->ndo_fdb_del(ndm, tb, dev, addr,
  3526. vid);
  3527. else
  3528. err = ndo_dflt_fdb_del(ndm, tb, dev, addr, vid);
  3529. if (!err) {
  3530. rtnl_fdb_notify(dev, addr, vid, RTM_DELNEIGH,
  3531. ndm->ndm_state);
  3532. ndm->ndm_flags &= ~NTF_SELF;
  3533. }
  3534. }
  3535. out:
  3536. return err;
  3537. }
  3538. static int nlmsg_populate_fdb(struct sk_buff *skb,
  3539. struct netlink_callback *cb,
  3540. struct net_device *dev,
  3541. int *idx,
  3542. struct netdev_hw_addr_list *list)
  3543. {
  3544. struct netdev_hw_addr *ha;
  3545. int err;
  3546. u32 portid, seq;
  3547. portid = NETLINK_CB(cb->skb).portid;
  3548. seq = cb->nlh->nlmsg_seq;
  3549. list_for_each_entry(ha, &list->list, list) {
  3550. if (*idx < cb->args[2])
  3551. goto skip;
  3552. err = nlmsg_populate_fdb_fill(skb, dev, ha->addr, 0,
  3553. portid, seq,
  3554. RTM_NEWNEIGH, NTF_SELF,
  3555. NLM_F_MULTI, NUD_PERMANENT);
  3556. if (err < 0)
  3557. return err;
  3558. skip:
  3559. *idx += 1;
  3560. }
  3561. return 0;
  3562. }
  3563. /**
  3564. * ndo_dflt_fdb_dump - default netdevice operation to dump an FDB table.
  3565. * @skb: socket buffer to store message in
  3566. * @cb: netlink callback
  3567. * @dev: netdevice
  3568. * @filter_dev: ignored
  3569. * @idx: the number of FDB table entries dumped is added to *@idx
  3570. *
  3571. * Default netdevice operation to dump the existing unicast address list.
  3572. * Returns number of addresses from list put in skb.
  3573. */
  3574. int ndo_dflt_fdb_dump(struct sk_buff *skb,
  3575. struct netlink_callback *cb,
  3576. struct net_device *dev,
  3577. struct net_device *filter_dev,
  3578. int *idx)
  3579. {
  3580. int err;
  3581. if (dev->type != ARPHRD_ETHER)
  3582. return -EINVAL;
  3583. netif_addr_lock_bh(dev);
  3584. err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->uc);
  3585. if (err)
  3586. goto out;
  3587. err = nlmsg_populate_fdb(skb, cb, dev, idx, &dev->mc);
  3588. out:
  3589. netif_addr_unlock_bh(dev);
  3590. return err;
  3591. }
  3592. EXPORT_SYMBOL(ndo_dflt_fdb_dump);
  3593. static int valid_fdb_dump_strict(const struct nlmsghdr *nlh,
  3594. int *br_idx, int *brport_idx,
  3595. struct netlink_ext_ack *extack)
  3596. {
  3597. struct nlattr *tb[NDA_MAX + 1];
  3598. struct ndmsg *ndm;
  3599. int err, i;
  3600. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
  3601. NL_SET_ERR_MSG(extack, "Invalid header for fdb dump request");
  3602. return -EINVAL;
  3603. }
  3604. ndm = nlmsg_data(nlh);
  3605. if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
  3606. ndm->ndm_flags || ndm->ndm_type) {
  3607. NL_SET_ERR_MSG(extack, "Invalid values in header for fdb dump request");
  3608. return -EINVAL;
  3609. }
  3610. err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
  3611. NDA_MAX, NULL, extack);
  3612. if (err < 0)
  3613. return err;
  3614. *brport_idx = ndm->ndm_ifindex;
  3615. for (i = 0; i <= NDA_MAX; ++i) {
  3616. if (!tb[i])
  3617. continue;
  3618. switch (i) {
  3619. case NDA_IFINDEX:
  3620. if (nla_len(tb[i]) != sizeof(u32)) {
  3621. NL_SET_ERR_MSG(extack, "Invalid IFINDEX attribute in fdb dump request");
  3622. return -EINVAL;
  3623. }
  3624. *brport_idx = nla_get_u32(tb[NDA_IFINDEX]);
  3625. break;
  3626. case NDA_MASTER:
  3627. if (nla_len(tb[i]) != sizeof(u32)) {
  3628. NL_SET_ERR_MSG(extack, "Invalid MASTER attribute in fdb dump request");
  3629. return -EINVAL;
  3630. }
  3631. *br_idx = nla_get_u32(tb[NDA_MASTER]);
  3632. break;
  3633. default:
  3634. NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb dump request");
  3635. return -EINVAL;
  3636. }
  3637. }
  3638. return 0;
  3639. }
  3640. static int valid_fdb_dump_legacy(const struct nlmsghdr *nlh,
  3641. int *br_idx, int *brport_idx,
  3642. struct netlink_ext_ack *extack)
  3643. {
  3644. struct nlattr *tb[IFLA_MAX+1];
  3645. int err;
  3646. /* A hack to preserve kernel<->userspace interface.
  3647. * Before Linux v4.12 this code accepted ndmsg since iproute2 v3.3.0.
  3648. * However, ndmsg is shorter than ifinfomsg thus nlmsg_parse() bails.
  3649. * So, check for ndmsg with an optional u32 attribute (not used here).
  3650. * Fortunately these sizes don't conflict with the size of ifinfomsg
  3651. * with an optional attribute.
  3652. */
  3653. if (nlmsg_len(nlh) != sizeof(struct ndmsg) &&
  3654. (nlmsg_len(nlh) != sizeof(struct ndmsg) +
  3655. nla_attr_size(sizeof(u32)))) {
  3656. struct ifinfomsg *ifm;
  3657. err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
  3658. tb, IFLA_MAX, ifla_policy,
  3659. extack);
  3660. if (err < 0) {
  3661. return -EINVAL;
  3662. } else if (err == 0) {
  3663. if (tb[IFLA_MASTER])
  3664. *br_idx = nla_get_u32(tb[IFLA_MASTER]);
  3665. }
  3666. ifm = nlmsg_data(nlh);
  3667. *brport_idx = ifm->ifi_index;
  3668. }
  3669. return 0;
  3670. }
  3671. static int rtnl_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb)
  3672. {
  3673. struct net_device *dev;
  3674. struct net_device *br_dev = NULL;
  3675. const struct net_device_ops *ops = NULL;
  3676. const struct net_device_ops *cops = NULL;
  3677. struct net *net = sock_net(skb->sk);
  3678. struct hlist_head *head;
  3679. int brport_idx = 0;
  3680. int br_idx = 0;
  3681. int h, s_h;
  3682. int idx = 0, s_idx;
  3683. int err = 0;
  3684. int fidx = 0;
  3685. if (cb->strict_check)
  3686. err = valid_fdb_dump_strict(cb->nlh, &br_idx, &brport_idx,
  3687. cb->extack);
  3688. else
  3689. err = valid_fdb_dump_legacy(cb->nlh, &br_idx, &brport_idx,
  3690. cb->extack);
  3691. if (err < 0)
  3692. return err;
  3693. if (br_idx) {
  3694. br_dev = __dev_get_by_index(net, br_idx);
  3695. if (!br_dev)
  3696. return -ENODEV;
  3697. ops = br_dev->netdev_ops;
  3698. }
  3699. s_h = cb->args[0];
  3700. s_idx = cb->args[1];
  3701. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  3702. idx = 0;
  3703. head = &net->dev_index_head[h];
  3704. hlist_for_each_entry(dev, head, index_hlist) {
  3705. if (brport_idx && (dev->ifindex != brport_idx))
  3706. continue;
  3707. if (!br_idx) { /* user did not specify a specific bridge */
  3708. if (netif_is_bridge_port(dev)) {
  3709. br_dev = netdev_master_upper_dev_get(dev);
  3710. cops = br_dev->netdev_ops;
  3711. }
  3712. } else {
  3713. if (dev != br_dev &&
  3714. !netif_is_bridge_port(dev))
  3715. continue;
  3716. if (br_dev != netdev_master_upper_dev_get(dev) &&
  3717. !(dev->priv_flags & IFF_EBRIDGE))
  3718. continue;
  3719. cops = ops;
  3720. }
  3721. if (idx < s_idx)
  3722. goto cont;
  3723. if (netif_is_bridge_port(dev)) {
  3724. if (cops && cops->ndo_fdb_dump) {
  3725. err = cops->ndo_fdb_dump(skb, cb,
  3726. br_dev, dev,
  3727. &fidx);
  3728. if (err == -EMSGSIZE)
  3729. goto out;
  3730. }
  3731. }
  3732. if (dev->netdev_ops->ndo_fdb_dump)
  3733. err = dev->netdev_ops->ndo_fdb_dump(skb, cb,
  3734. dev, NULL,
  3735. &fidx);
  3736. else
  3737. err = ndo_dflt_fdb_dump(skb, cb, dev, NULL,
  3738. &fidx);
  3739. if (err == -EMSGSIZE)
  3740. goto out;
  3741. cops = NULL;
  3742. /* reset fdb offset to 0 for rest of the interfaces */
  3743. cb->args[2] = 0;
  3744. fidx = 0;
  3745. cont:
  3746. idx++;
  3747. }
  3748. }
  3749. out:
  3750. cb->args[0] = h;
  3751. cb->args[1] = idx;
  3752. cb->args[2] = fidx;
  3753. return skb->len;
  3754. }
  3755. static int valid_fdb_get_strict(const struct nlmsghdr *nlh,
  3756. struct nlattr **tb, u8 *ndm_flags,
  3757. int *br_idx, int *brport_idx, u8 **addr,
  3758. u16 *vid, struct netlink_ext_ack *extack)
  3759. {
  3760. struct ndmsg *ndm;
  3761. int err, i;
  3762. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ndm))) {
  3763. NL_SET_ERR_MSG(extack, "Invalid header for fdb get request");
  3764. return -EINVAL;
  3765. }
  3766. ndm = nlmsg_data(nlh);
  3767. if (ndm->ndm_pad1 || ndm->ndm_pad2 || ndm->ndm_state ||
  3768. ndm->ndm_type) {
  3769. NL_SET_ERR_MSG(extack, "Invalid values in header for fdb get request");
  3770. return -EINVAL;
  3771. }
  3772. if (ndm->ndm_flags & ~(NTF_MASTER | NTF_SELF)) {
  3773. NL_SET_ERR_MSG(extack, "Invalid flags in header for fdb get request");
  3774. return -EINVAL;
  3775. }
  3776. err = nlmsg_parse_deprecated_strict(nlh, sizeof(struct ndmsg), tb,
  3777. NDA_MAX, nda_policy, extack);
  3778. if (err < 0)
  3779. return err;
  3780. *ndm_flags = ndm->ndm_flags;
  3781. *brport_idx = ndm->ndm_ifindex;
  3782. for (i = 0; i <= NDA_MAX; ++i) {
  3783. if (!tb[i])
  3784. continue;
  3785. switch (i) {
  3786. case NDA_MASTER:
  3787. *br_idx = nla_get_u32(tb[i]);
  3788. break;
  3789. case NDA_LLADDR:
  3790. if (nla_len(tb[i]) != ETH_ALEN) {
  3791. NL_SET_ERR_MSG(extack, "Invalid address in fdb get request");
  3792. return -EINVAL;
  3793. }
  3794. *addr = nla_data(tb[i]);
  3795. break;
  3796. case NDA_VLAN:
  3797. err = fdb_vid_parse(tb[i], vid, extack);
  3798. if (err)
  3799. return err;
  3800. break;
  3801. case NDA_VNI:
  3802. break;
  3803. default:
  3804. NL_SET_ERR_MSG(extack, "Unsupported attribute in fdb get request");
  3805. return -EINVAL;
  3806. }
  3807. }
  3808. return 0;
  3809. }
  3810. static int rtnl_fdb_get(struct sk_buff *in_skb, struct nlmsghdr *nlh,
  3811. struct netlink_ext_ack *extack)
  3812. {
  3813. struct net_device *dev = NULL, *br_dev = NULL;
  3814. const struct net_device_ops *ops = NULL;
  3815. struct net *net = sock_net(in_skb->sk);
  3816. struct nlattr *tb[NDA_MAX + 1];
  3817. struct sk_buff *skb;
  3818. int brport_idx = 0;
  3819. u8 ndm_flags = 0;
  3820. int br_idx = 0;
  3821. u8 *addr = NULL;
  3822. u16 vid = 0;
  3823. int err;
  3824. err = valid_fdb_get_strict(nlh, tb, &ndm_flags, &br_idx,
  3825. &brport_idx, &addr, &vid, extack);
  3826. if (err < 0)
  3827. return err;
  3828. if (!addr) {
  3829. NL_SET_ERR_MSG(extack, "Missing lookup address for fdb get request");
  3830. return -EINVAL;
  3831. }
  3832. if (brport_idx) {
  3833. dev = __dev_get_by_index(net, brport_idx);
  3834. if (!dev) {
  3835. NL_SET_ERR_MSG(extack, "Unknown device ifindex");
  3836. return -ENODEV;
  3837. }
  3838. }
  3839. if (br_idx) {
  3840. if (dev) {
  3841. NL_SET_ERR_MSG(extack, "Master and device are mutually exclusive");
  3842. return -EINVAL;
  3843. }
  3844. br_dev = __dev_get_by_index(net, br_idx);
  3845. if (!br_dev) {
  3846. NL_SET_ERR_MSG(extack, "Invalid master ifindex");
  3847. return -EINVAL;
  3848. }
  3849. ops = br_dev->netdev_ops;
  3850. }
  3851. if (dev) {
  3852. if (!ndm_flags || (ndm_flags & NTF_MASTER)) {
  3853. if (!netif_is_bridge_port(dev)) {
  3854. NL_SET_ERR_MSG(extack, "Device is not a bridge port");
  3855. return -EINVAL;
  3856. }
  3857. br_dev = netdev_master_upper_dev_get(dev);
  3858. if (!br_dev) {
  3859. NL_SET_ERR_MSG(extack, "Master of device not found");
  3860. return -EINVAL;
  3861. }
  3862. ops = br_dev->netdev_ops;
  3863. } else {
  3864. if (!(ndm_flags & NTF_SELF)) {
  3865. NL_SET_ERR_MSG(extack, "Missing NTF_SELF");
  3866. return -EINVAL;
  3867. }
  3868. ops = dev->netdev_ops;
  3869. }
  3870. }
  3871. if (!br_dev && !dev) {
  3872. NL_SET_ERR_MSG(extack, "No device specified");
  3873. return -ENODEV;
  3874. }
  3875. if (!ops || !ops->ndo_fdb_get) {
  3876. NL_SET_ERR_MSG(extack, "Fdb get operation not supported by device");
  3877. return -EOPNOTSUPP;
  3878. }
  3879. skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
  3880. if (!skb)
  3881. return -ENOBUFS;
  3882. if (br_dev)
  3883. dev = br_dev;
  3884. err = ops->ndo_fdb_get(skb, tb, dev, addr, vid,
  3885. NETLINK_CB(in_skb).portid,
  3886. nlh->nlmsg_seq, extack);
  3887. if (err)
  3888. goto out;
  3889. return rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
  3890. out:
  3891. kfree_skb(skb);
  3892. return err;
  3893. }
  3894. static int brport_nla_put_flag(struct sk_buff *skb, u32 flags, u32 mask,
  3895. unsigned int attrnum, unsigned int flag)
  3896. {
  3897. if (mask & flag)
  3898. return nla_put_u8(skb, attrnum, !!(flags & flag));
  3899. return 0;
  3900. }
  3901. int ndo_dflt_bridge_getlink(struct sk_buff *skb, u32 pid, u32 seq,
  3902. struct net_device *dev, u16 mode,
  3903. u32 flags, u32 mask, int nlflags,
  3904. u32 filter_mask,
  3905. int (*vlan_fill)(struct sk_buff *skb,
  3906. struct net_device *dev,
  3907. u32 filter_mask))
  3908. {
  3909. struct nlmsghdr *nlh;
  3910. struct ifinfomsg *ifm;
  3911. struct nlattr *br_afspec;
  3912. struct nlattr *protinfo;
  3913. u8 operstate = netif_running(dev) ? dev->operstate : IF_OPER_DOWN;
  3914. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  3915. int err = 0;
  3916. nlh = nlmsg_put(skb, pid, seq, RTM_NEWLINK, sizeof(*ifm), nlflags);
  3917. if (nlh == NULL)
  3918. return -EMSGSIZE;
  3919. ifm = nlmsg_data(nlh);
  3920. ifm->ifi_family = AF_BRIDGE;
  3921. ifm->__ifi_pad = 0;
  3922. ifm->ifi_type = dev->type;
  3923. ifm->ifi_index = dev->ifindex;
  3924. ifm->ifi_flags = dev_get_flags(dev);
  3925. ifm->ifi_change = 0;
  3926. if (nla_put_string(skb, IFLA_IFNAME, dev->name) ||
  3927. nla_put_u32(skb, IFLA_MTU, dev->mtu) ||
  3928. nla_put_u8(skb, IFLA_OPERSTATE, operstate) ||
  3929. (br_dev &&
  3930. nla_put_u32(skb, IFLA_MASTER, br_dev->ifindex)) ||
  3931. (dev->addr_len &&
  3932. nla_put(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr)) ||
  3933. (dev->ifindex != dev_get_iflink(dev) &&
  3934. nla_put_u32(skb, IFLA_LINK, dev_get_iflink(dev))))
  3935. goto nla_put_failure;
  3936. br_afspec = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
  3937. if (!br_afspec)
  3938. goto nla_put_failure;
  3939. if (nla_put_u16(skb, IFLA_BRIDGE_FLAGS, BRIDGE_FLAGS_SELF)) {
  3940. nla_nest_cancel(skb, br_afspec);
  3941. goto nla_put_failure;
  3942. }
  3943. if (mode != BRIDGE_MODE_UNDEF) {
  3944. if (nla_put_u16(skb, IFLA_BRIDGE_MODE, mode)) {
  3945. nla_nest_cancel(skb, br_afspec);
  3946. goto nla_put_failure;
  3947. }
  3948. }
  3949. if (vlan_fill) {
  3950. err = vlan_fill(skb, dev, filter_mask);
  3951. if (err) {
  3952. nla_nest_cancel(skb, br_afspec);
  3953. goto nla_put_failure;
  3954. }
  3955. }
  3956. nla_nest_end(skb, br_afspec);
  3957. protinfo = nla_nest_start(skb, IFLA_PROTINFO);
  3958. if (!protinfo)
  3959. goto nla_put_failure;
  3960. if (brport_nla_put_flag(skb, flags, mask,
  3961. IFLA_BRPORT_MODE, BR_HAIRPIN_MODE) ||
  3962. brport_nla_put_flag(skb, flags, mask,
  3963. IFLA_BRPORT_GUARD, BR_BPDU_GUARD) ||
  3964. brport_nla_put_flag(skb, flags, mask,
  3965. IFLA_BRPORT_FAST_LEAVE,
  3966. BR_MULTICAST_FAST_LEAVE) ||
  3967. brport_nla_put_flag(skb, flags, mask,
  3968. IFLA_BRPORT_PROTECT, BR_ROOT_BLOCK) ||
  3969. brport_nla_put_flag(skb, flags, mask,
  3970. IFLA_BRPORT_LEARNING, BR_LEARNING) ||
  3971. brport_nla_put_flag(skb, flags, mask,
  3972. IFLA_BRPORT_LEARNING_SYNC, BR_LEARNING_SYNC) ||
  3973. brport_nla_put_flag(skb, flags, mask,
  3974. IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD) ||
  3975. brport_nla_put_flag(skb, flags, mask,
  3976. IFLA_BRPORT_PROXYARP, BR_PROXYARP) ||
  3977. brport_nla_put_flag(skb, flags, mask,
  3978. IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD) ||
  3979. brport_nla_put_flag(skb, flags, mask,
  3980. IFLA_BRPORT_BCAST_FLOOD, BR_BCAST_FLOOD)) {
  3981. nla_nest_cancel(skb, protinfo);
  3982. goto nla_put_failure;
  3983. }
  3984. nla_nest_end(skb, protinfo);
  3985. nlmsg_end(skb, nlh);
  3986. return 0;
  3987. nla_put_failure:
  3988. nlmsg_cancel(skb, nlh);
  3989. return err ? err : -EMSGSIZE;
  3990. }
  3991. EXPORT_SYMBOL_GPL(ndo_dflt_bridge_getlink);
  3992. static int valid_bridge_getlink_req(const struct nlmsghdr *nlh,
  3993. bool strict_check, u32 *filter_mask,
  3994. struct netlink_ext_ack *extack)
  3995. {
  3996. struct nlattr *tb[IFLA_MAX+1];
  3997. int err, i;
  3998. if (strict_check) {
  3999. struct ifinfomsg *ifm;
  4000. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
  4001. NL_SET_ERR_MSG(extack, "Invalid header for bridge link dump");
  4002. return -EINVAL;
  4003. }
  4004. ifm = nlmsg_data(nlh);
  4005. if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
  4006. ifm->ifi_change || ifm->ifi_index) {
  4007. NL_SET_ERR_MSG(extack, "Invalid values in header for bridge link dump request");
  4008. return -EINVAL;
  4009. }
  4010. err = nlmsg_parse_deprecated_strict(nlh,
  4011. sizeof(struct ifinfomsg),
  4012. tb, IFLA_MAX, ifla_policy,
  4013. extack);
  4014. } else {
  4015. err = nlmsg_parse_deprecated(nlh, sizeof(struct ifinfomsg),
  4016. tb, IFLA_MAX, ifla_policy,
  4017. extack);
  4018. }
  4019. if (err < 0)
  4020. return err;
  4021. /* new attributes should only be added with strict checking */
  4022. for (i = 0; i <= IFLA_MAX; ++i) {
  4023. if (!tb[i])
  4024. continue;
  4025. switch (i) {
  4026. case IFLA_EXT_MASK:
  4027. *filter_mask = nla_get_u32(tb[i]);
  4028. break;
  4029. default:
  4030. if (strict_check) {
  4031. NL_SET_ERR_MSG(extack, "Unsupported attribute in bridge link dump request");
  4032. return -EINVAL;
  4033. }
  4034. }
  4035. }
  4036. return 0;
  4037. }
  4038. static int rtnl_bridge_getlink(struct sk_buff *skb, struct netlink_callback *cb)
  4039. {
  4040. const struct nlmsghdr *nlh = cb->nlh;
  4041. struct net *net = sock_net(skb->sk);
  4042. struct net_device *dev;
  4043. int idx = 0;
  4044. u32 portid = NETLINK_CB(cb->skb).portid;
  4045. u32 seq = nlh->nlmsg_seq;
  4046. u32 filter_mask = 0;
  4047. int err;
  4048. err = valid_bridge_getlink_req(nlh, cb->strict_check, &filter_mask,
  4049. cb->extack);
  4050. if (err < 0 && cb->strict_check)
  4051. return err;
  4052. rcu_read_lock();
  4053. for_each_netdev_rcu(net, dev) {
  4054. const struct net_device_ops *ops = dev->netdev_ops;
  4055. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  4056. if (br_dev && br_dev->netdev_ops->ndo_bridge_getlink) {
  4057. if (idx >= cb->args[0]) {
  4058. err = br_dev->netdev_ops->ndo_bridge_getlink(
  4059. skb, portid, seq, dev,
  4060. filter_mask, NLM_F_MULTI);
  4061. if (err < 0 && err != -EOPNOTSUPP) {
  4062. if (likely(skb->len))
  4063. break;
  4064. goto out_err;
  4065. }
  4066. }
  4067. idx++;
  4068. }
  4069. if (ops->ndo_bridge_getlink) {
  4070. if (idx >= cb->args[0]) {
  4071. err = ops->ndo_bridge_getlink(skb, portid,
  4072. seq, dev,
  4073. filter_mask,
  4074. NLM_F_MULTI);
  4075. if (err < 0 && err != -EOPNOTSUPP) {
  4076. if (likely(skb->len))
  4077. break;
  4078. goto out_err;
  4079. }
  4080. }
  4081. idx++;
  4082. }
  4083. }
  4084. err = skb->len;
  4085. out_err:
  4086. rcu_read_unlock();
  4087. cb->args[0] = idx;
  4088. return err;
  4089. }
  4090. static inline size_t bridge_nlmsg_size(void)
  4091. {
  4092. return NLMSG_ALIGN(sizeof(struct ifinfomsg))
  4093. + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
  4094. + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
  4095. + nla_total_size(sizeof(u32)) /* IFLA_MASTER */
  4096. + nla_total_size(sizeof(u32)) /* IFLA_MTU */
  4097. + nla_total_size(sizeof(u32)) /* IFLA_LINK */
  4098. + nla_total_size(sizeof(u32)) /* IFLA_OPERSTATE */
  4099. + nla_total_size(sizeof(u8)) /* IFLA_PROTINFO */
  4100. + nla_total_size(sizeof(struct nlattr)) /* IFLA_AF_SPEC */
  4101. + nla_total_size(sizeof(u16)) /* IFLA_BRIDGE_FLAGS */
  4102. + nla_total_size(sizeof(u16)); /* IFLA_BRIDGE_MODE */
  4103. }
  4104. static int rtnl_bridge_notify(struct net_device *dev)
  4105. {
  4106. struct net *net = dev_net(dev);
  4107. struct sk_buff *skb;
  4108. int err = -EOPNOTSUPP;
  4109. if (!dev->netdev_ops->ndo_bridge_getlink)
  4110. return 0;
  4111. skb = nlmsg_new(bridge_nlmsg_size(), GFP_ATOMIC);
  4112. if (!skb) {
  4113. err = -ENOMEM;
  4114. goto errout;
  4115. }
  4116. err = dev->netdev_ops->ndo_bridge_getlink(skb, 0, 0, dev, 0, 0);
  4117. if (err < 0)
  4118. goto errout;
  4119. /* Notification info is only filled for bridge ports, not the bridge
  4120. * device itself. Therefore, a zero notification length is valid and
  4121. * should not result in an error.
  4122. */
  4123. if (!skb->len)
  4124. goto errout;
  4125. rtnl_notify(skb, net, 0, RTNLGRP_LINK, NULL, GFP_ATOMIC);
  4126. return 0;
  4127. errout:
  4128. WARN_ON(err == -EMSGSIZE);
  4129. kfree_skb(skb);
  4130. if (err)
  4131. rtnl_set_sk_err(net, RTNLGRP_LINK, err);
  4132. return err;
  4133. }
  4134. static int rtnl_bridge_setlink(struct sk_buff *skb, struct nlmsghdr *nlh,
  4135. struct netlink_ext_ack *extack)
  4136. {
  4137. struct net *net = sock_net(skb->sk);
  4138. struct ifinfomsg *ifm;
  4139. struct net_device *dev;
  4140. struct nlattr *br_spec, *attr = NULL;
  4141. int rem, err = -EOPNOTSUPP;
  4142. u16 flags = 0;
  4143. bool have_flags = false;
  4144. if (nlmsg_len(nlh) < sizeof(*ifm))
  4145. return -EINVAL;
  4146. ifm = nlmsg_data(nlh);
  4147. if (ifm->ifi_family != AF_BRIDGE)
  4148. return -EPFNOSUPPORT;
  4149. dev = __dev_get_by_index(net, ifm->ifi_index);
  4150. if (!dev) {
  4151. NL_SET_ERR_MSG(extack, "unknown ifindex");
  4152. return -ENODEV;
  4153. }
  4154. br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
  4155. if (br_spec) {
  4156. nla_for_each_nested(attr, br_spec, rem) {
  4157. if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
  4158. if (nla_len(attr) < sizeof(flags))
  4159. return -EINVAL;
  4160. have_flags = true;
  4161. flags = nla_get_u16(attr);
  4162. break;
  4163. }
  4164. }
  4165. }
  4166. if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
  4167. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  4168. if (!br_dev || !br_dev->netdev_ops->ndo_bridge_setlink) {
  4169. err = -EOPNOTSUPP;
  4170. goto out;
  4171. }
  4172. err = br_dev->netdev_ops->ndo_bridge_setlink(dev, nlh, flags,
  4173. extack);
  4174. if (err)
  4175. goto out;
  4176. flags &= ~BRIDGE_FLAGS_MASTER;
  4177. }
  4178. if ((flags & BRIDGE_FLAGS_SELF)) {
  4179. if (!dev->netdev_ops->ndo_bridge_setlink)
  4180. err = -EOPNOTSUPP;
  4181. else
  4182. err = dev->netdev_ops->ndo_bridge_setlink(dev, nlh,
  4183. flags,
  4184. extack);
  4185. if (!err) {
  4186. flags &= ~BRIDGE_FLAGS_SELF;
  4187. /* Generate event to notify upper layer of bridge
  4188. * change
  4189. */
  4190. err = rtnl_bridge_notify(dev);
  4191. }
  4192. }
  4193. if (have_flags)
  4194. memcpy(nla_data(attr), &flags, sizeof(flags));
  4195. out:
  4196. return err;
  4197. }
  4198. static int rtnl_bridge_dellink(struct sk_buff *skb, struct nlmsghdr *nlh,
  4199. struct netlink_ext_ack *extack)
  4200. {
  4201. struct net *net = sock_net(skb->sk);
  4202. struct ifinfomsg *ifm;
  4203. struct net_device *dev;
  4204. struct nlattr *br_spec, *attr = NULL;
  4205. int rem, err = -EOPNOTSUPP;
  4206. u16 flags = 0;
  4207. bool have_flags = false;
  4208. if (nlmsg_len(nlh) < sizeof(*ifm))
  4209. return -EINVAL;
  4210. ifm = nlmsg_data(nlh);
  4211. if (ifm->ifi_family != AF_BRIDGE)
  4212. return -EPFNOSUPPORT;
  4213. dev = __dev_get_by_index(net, ifm->ifi_index);
  4214. if (!dev) {
  4215. NL_SET_ERR_MSG(extack, "unknown ifindex");
  4216. return -ENODEV;
  4217. }
  4218. br_spec = nlmsg_find_attr(nlh, sizeof(struct ifinfomsg), IFLA_AF_SPEC);
  4219. if (br_spec) {
  4220. nla_for_each_nested(attr, br_spec, rem) {
  4221. if (nla_type(attr) == IFLA_BRIDGE_FLAGS) {
  4222. if (nla_len(attr) < sizeof(flags))
  4223. return -EINVAL;
  4224. have_flags = true;
  4225. flags = nla_get_u16(attr);
  4226. break;
  4227. }
  4228. }
  4229. }
  4230. if (!flags || (flags & BRIDGE_FLAGS_MASTER)) {
  4231. struct net_device *br_dev = netdev_master_upper_dev_get(dev);
  4232. if (!br_dev || !br_dev->netdev_ops->ndo_bridge_dellink) {
  4233. err = -EOPNOTSUPP;
  4234. goto out;
  4235. }
  4236. err = br_dev->netdev_ops->ndo_bridge_dellink(dev, nlh, flags);
  4237. if (err)
  4238. goto out;
  4239. flags &= ~BRIDGE_FLAGS_MASTER;
  4240. }
  4241. if ((flags & BRIDGE_FLAGS_SELF)) {
  4242. if (!dev->netdev_ops->ndo_bridge_dellink)
  4243. err = -EOPNOTSUPP;
  4244. else
  4245. err = dev->netdev_ops->ndo_bridge_dellink(dev, nlh,
  4246. flags);
  4247. if (!err) {
  4248. flags &= ~BRIDGE_FLAGS_SELF;
  4249. /* Generate event to notify upper layer of bridge
  4250. * change
  4251. */
  4252. err = rtnl_bridge_notify(dev);
  4253. }
  4254. }
  4255. if (have_flags)
  4256. memcpy(nla_data(attr), &flags, sizeof(flags));
  4257. out:
  4258. return err;
  4259. }
  4260. static bool stats_attr_valid(unsigned int mask, int attrid, int idxattr)
  4261. {
  4262. return (mask & IFLA_STATS_FILTER_BIT(attrid)) &&
  4263. (!idxattr || idxattr == attrid);
  4264. }
  4265. #define IFLA_OFFLOAD_XSTATS_FIRST (IFLA_OFFLOAD_XSTATS_UNSPEC + 1)
  4266. static int rtnl_get_offload_stats_attr_size(int attr_id)
  4267. {
  4268. switch (attr_id) {
  4269. case IFLA_OFFLOAD_XSTATS_CPU_HIT:
  4270. return sizeof(struct rtnl_link_stats64);
  4271. }
  4272. return 0;
  4273. }
  4274. static int rtnl_get_offload_stats(struct sk_buff *skb, struct net_device *dev,
  4275. int *prividx)
  4276. {
  4277. struct nlattr *attr = NULL;
  4278. int attr_id, size;
  4279. void *attr_data;
  4280. int err;
  4281. if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
  4282. dev->netdev_ops->ndo_get_offload_stats))
  4283. return -ENODATA;
  4284. for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
  4285. attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
  4286. if (attr_id < *prividx)
  4287. continue;
  4288. size = rtnl_get_offload_stats_attr_size(attr_id);
  4289. if (!size)
  4290. continue;
  4291. if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
  4292. continue;
  4293. attr = nla_reserve_64bit(skb, attr_id, size,
  4294. IFLA_OFFLOAD_XSTATS_UNSPEC);
  4295. if (!attr)
  4296. goto nla_put_failure;
  4297. attr_data = nla_data(attr);
  4298. memset(attr_data, 0, size);
  4299. err = dev->netdev_ops->ndo_get_offload_stats(attr_id, dev,
  4300. attr_data);
  4301. if (err)
  4302. goto get_offload_stats_failure;
  4303. }
  4304. if (!attr)
  4305. return -ENODATA;
  4306. *prividx = 0;
  4307. return 0;
  4308. nla_put_failure:
  4309. err = -EMSGSIZE;
  4310. get_offload_stats_failure:
  4311. *prividx = attr_id;
  4312. return err;
  4313. }
  4314. static int rtnl_get_offload_stats_size(const struct net_device *dev)
  4315. {
  4316. int nla_size = 0;
  4317. int attr_id;
  4318. int size;
  4319. if (!(dev->netdev_ops && dev->netdev_ops->ndo_has_offload_stats &&
  4320. dev->netdev_ops->ndo_get_offload_stats))
  4321. return 0;
  4322. for (attr_id = IFLA_OFFLOAD_XSTATS_FIRST;
  4323. attr_id <= IFLA_OFFLOAD_XSTATS_MAX; attr_id++) {
  4324. if (!dev->netdev_ops->ndo_has_offload_stats(dev, attr_id))
  4325. continue;
  4326. size = rtnl_get_offload_stats_attr_size(attr_id);
  4327. nla_size += nla_total_size_64bit(size);
  4328. }
  4329. if (nla_size != 0)
  4330. nla_size += nla_total_size(0);
  4331. return nla_size;
  4332. }
  4333. static int rtnl_fill_statsinfo(struct sk_buff *skb, struct net_device *dev,
  4334. int type, u32 pid, u32 seq, u32 change,
  4335. unsigned int flags, unsigned int filter_mask,
  4336. int *idxattr, int *prividx)
  4337. {
  4338. struct if_stats_msg *ifsm;
  4339. struct nlmsghdr *nlh;
  4340. struct nlattr *attr;
  4341. int s_prividx = *prividx;
  4342. int err;
  4343. ASSERT_RTNL();
  4344. nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifsm), flags);
  4345. if (!nlh)
  4346. return -EMSGSIZE;
  4347. ifsm = nlmsg_data(nlh);
  4348. ifsm->family = PF_UNSPEC;
  4349. ifsm->pad1 = 0;
  4350. ifsm->pad2 = 0;
  4351. ifsm->ifindex = dev->ifindex;
  4352. ifsm->filter_mask = filter_mask;
  4353. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, *idxattr)) {
  4354. struct rtnl_link_stats64 *sp;
  4355. attr = nla_reserve_64bit(skb, IFLA_STATS_LINK_64,
  4356. sizeof(struct rtnl_link_stats64),
  4357. IFLA_STATS_UNSPEC);
  4358. if (!attr)
  4359. goto nla_put_failure;
  4360. sp = nla_data(attr);
  4361. dev_get_stats(dev, sp);
  4362. }
  4363. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, *idxattr)) {
  4364. const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
  4365. if (ops && ops->fill_linkxstats) {
  4366. *idxattr = IFLA_STATS_LINK_XSTATS;
  4367. attr = nla_nest_start_noflag(skb,
  4368. IFLA_STATS_LINK_XSTATS);
  4369. if (!attr)
  4370. goto nla_put_failure;
  4371. err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
  4372. nla_nest_end(skb, attr);
  4373. if (err)
  4374. goto nla_put_failure;
  4375. *idxattr = 0;
  4376. }
  4377. }
  4378. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE,
  4379. *idxattr)) {
  4380. const struct rtnl_link_ops *ops = NULL;
  4381. const struct net_device *master;
  4382. master = netdev_master_upper_dev_get(dev);
  4383. if (master)
  4384. ops = master->rtnl_link_ops;
  4385. if (ops && ops->fill_linkxstats) {
  4386. *idxattr = IFLA_STATS_LINK_XSTATS_SLAVE;
  4387. attr = nla_nest_start_noflag(skb,
  4388. IFLA_STATS_LINK_XSTATS_SLAVE);
  4389. if (!attr)
  4390. goto nla_put_failure;
  4391. err = ops->fill_linkxstats(skb, dev, prividx, *idxattr);
  4392. nla_nest_end(skb, attr);
  4393. if (err)
  4394. goto nla_put_failure;
  4395. *idxattr = 0;
  4396. }
  4397. }
  4398. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS,
  4399. *idxattr)) {
  4400. *idxattr = IFLA_STATS_LINK_OFFLOAD_XSTATS;
  4401. attr = nla_nest_start_noflag(skb,
  4402. IFLA_STATS_LINK_OFFLOAD_XSTATS);
  4403. if (!attr)
  4404. goto nla_put_failure;
  4405. err = rtnl_get_offload_stats(skb, dev, prividx);
  4406. if (err == -ENODATA)
  4407. nla_nest_cancel(skb, attr);
  4408. else
  4409. nla_nest_end(skb, attr);
  4410. if (err && err != -ENODATA)
  4411. goto nla_put_failure;
  4412. *idxattr = 0;
  4413. }
  4414. if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, *idxattr)) {
  4415. struct rtnl_af_ops *af_ops;
  4416. *idxattr = IFLA_STATS_AF_SPEC;
  4417. attr = nla_nest_start_noflag(skb, IFLA_STATS_AF_SPEC);
  4418. if (!attr)
  4419. goto nla_put_failure;
  4420. rcu_read_lock();
  4421. list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
  4422. if (af_ops->fill_stats_af) {
  4423. struct nlattr *af;
  4424. int err;
  4425. af = nla_nest_start_noflag(skb,
  4426. af_ops->family);
  4427. if (!af) {
  4428. rcu_read_unlock();
  4429. goto nla_put_failure;
  4430. }
  4431. err = af_ops->fill_stats_af(skb, dev);
  4432. if (err == -ENODATA) {
  4433. nla_nest_cancel(skb, af);
  4434. } else if (err < 0) {
  4435. rcu_read_unlock();
  4436. goto nla_put_failure;
  4437. }
  4438. nla_nest_end(skb, af);
  4439. }
  4440. }
  4441. rcu_read_unlock();
  4442. nla_nest_end(skb, attr);
  4443. *idxattr = 0;
  4444. }
  4445. nlmsg_end(skb, nlh);
  4446. return 0;
  4447. nla_put_failure:
  4448. /* not a multi message or no progress mean a real error */
  4449. if (!(flags & NLM_F_MULTI) || s_prividx == *prividx)
  4450. nlmsg_cancel(skb, nlh);
  4451. else
  4452. nlmsg_end(skb, nlh);
  4453. return -EMSGSIZE;
  4454. }
  4455. static size_t if_nlmsg_stats_size(const struct net_device *dev,
  4456. u32 filter_mask)
  4457. {
  4458. size_t size = NLMSG_ALIGN(sizeof(struct if_stats_msg));
  4459. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_64, 0))
  4460. size += nla_total_size_64bit(sizeof(struct rtnl_link_stats64));
  4461. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS, 0)) {
  4462. const struct rtnl_link_ops *ops = dev->rtnl_link_ops;
  4463. int attr = IFLA_STATS_LINK_XSTATS;
  4464. if (ops && ops->get_linkxstats_size) {
  4465. size += nla_total_size(ops->get_linkxstats_size(dev,
  4466. attr));
  4467. /* for IFLA_STATS_LINK_XSTATS */
  4468. size += nla_total_size(0);
  4469. }
  4470. }
  4471. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_XSTATS_SLAVE, 0)) {
  4472. struct net_device *_dev = (struct net_device *)dev;
  4473. const struct rtnl_link_ops *ops = NULL;
  4474. const struct net_device *master;
  4475. /* netdev_master_upper_dev_get can't take const */
  4476. master = netdev_master_upper_dev_get(_dev);
  4477. if (master)
  4478. ops = master->rtnl_link_ops;
  4479. if (ops && ops->get_linkxstats_size) {
  4480. int attr = IFLA_STATS_LINK_XSTATS_SLAVE;
  4481. size += nla_total_size(ops->get_linkxstats_size(dev,
  4482. attr));
  4483. /* for IFLA_STATS_LINK_XSTATS_SLAVE */
  4484. size += nla_total_size(0);
  4485. }
  4486. }
  4487. if (stats_attr_valid(filter_mask, IFLA_STATS_LINK_OFFLOAD_XSTATS, 0))
  4488. size += rtnl_get_offload_stats_size(dev);
  4489. if (stats_attr_valid(filter_mask, IFLA_STATS_AF_SPEC, 0)) {
  4490. struct rtnl_af_ops *af_ops;
  4491. /* for IFLA_STATS_AF_SPEC */
  4492. size += nla_total_size(0);
  4493. rcu_read_lock();
  4494. list_for_each_entry_rcu(af_ops, &rtnl_af_ops, list) {
  4495. if (af_ops->get_stats_af_size) {
  4496. size += nla_total_size(
  4497. af_ops->get_stats_af_size(dev));
  4498. /* for AF_* */
  4499. size += nla_total_size(0);
  4500. }
  4501. }
  4502. rcu_read_unlock();
  4503. }
  4504. return size;
  4505. }
  4506. static int rtnl_valid_stats_req(const struct nlmsghdr *nlh, bool strict_check,
  4507. bool is_dump, struct netlink_ext_ack *extack)
  4508. {
  4509. struct if_stats_msg *ifsm;
  4510. if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifsm))) {
  4511. NL_SET_ERR_MSG(extack, "Invalid header for stats dump");
  4512. return -EINVAL;
  4513. }
  4514. if (!strict_check)
  4515. return 0;
  4516. ifsm = nlmsg_data(nlh);
  4517. /* only requests using strict checks can pass data to influence
  4518. * the dump. The legacy exception is filter_mask.
  4519. */
  4520. if (ifsm->pad1 || ifsm->pad2 || (is_dump && ifsm->ifindex)) {
  4521. NL_SET_ERR_MSG(extack, "Invalid values in header for stats dump request");
  4522. return -EINVAL;
  4523. }
  4524. if (nlmsg_attrlen(nlh, sizeof(*ifsm))) {
  4525. NL_SET_ERR_MSG(extack, "Invalid attributes after stats header");
  4526. return -EINVAL;
  4527. }
  4528. if (ifsm->filter_mask >= IFLA_STATS_FILTER_BIT(IFLA_STATS_MAX + 1)) {
  4529. NL_SET_ERR_MSG(extack, "Invalid stats requested through filter mask");
  4530. return -EINVAL;
  4531. }
  4532. return 0;
  4533. }
  4534. static int rtnl_stats_get(struct sk_buff *skb, struct nlmsghdr *nlh,
  4535. struct netlink_ext_ack *extack)
  4536. {
  4537. struct net *net = sock_net(skb->sk);
  4538. struct net_device *dev = NULL;
  4539. int idxattr = 0, prividx = 0;
  4540. struct if_stats_msg *ifsm;
  4541. struct sk_buff *nskb;
  4542. u32 filter_mask;
  4543. int err;
  4544. err = rtnl_valid_stats_req(nlh, netlink_strict_get_check(skb),
  4545. false, extack);
  4546. if (err)
  4547. return err;
  4548. ifsm = nlmsg_data(nlh);
  4549. if (ifsm->ifindex > 0)
  4550. dev = __dev_get_by_index(net, ifsm->ifindex);
  4551. else
  4552. return -EINVAL;
  4553. if (!dev)
  4554. return -ENODEV;
  4555. filter_mask = ifsm->filter_mask;
  4556. if (!filter_mask)
  4557. return -EINVAL;
  4558. nskb = nlmsg_new(if_nlmsg_stats_size(dev, filter_mask), GFP_KERNEL);
  4559. if (!nskb)
  4560. return -ENOBUFS;
  4561. err = rtnl_fill_statsinfo(nskb, dev, RTM_NEWSTATS,
  4562. NETLINK_CB(skb).portid, nlh->nlmsg_seq, 0,
  4563. 0, filter_mask, &idxattr, &prividx);
  4564. if (err < 0) {
  4565. /* -EMSGSIZE implies BUG in if_nlmsg_stats_size */
  4566. WARN_ON(err == -EMSGSIZE);
  4567. kfree_skb(nskb);
  4568. } else {
  4569. err = rtnl_unicast(nskb, net, NETLINK_CB(skb).portid);
  4570. }
  4571. return err;
  4572. }
  4573. static int rtnl_stats_dump(struct sk_buff *skb, struct netlink_callback *cb)
  4574. {
  4575. struct netlink_ext_ack *extack = cb->extack;
  4576. int h, s_h, err, s_idx, s_idxattr, s_prividx;
  4577. struct net *net = sock_net(skb->sk);
  4578. unsigned int flags = NLM_F_MULTI;
  4579. struct if_stats_msg *ifsm;
  4580. struct hlist_head *head;
  4581. struct net_device *dev;
  4582. u32 filter_mask = 0;
  4583. int idx = 0;
  4584. s_h = cb->args[0];
  4585. s_idx = cb->args[1];
  4586. s_idxattr = cb->args[2];
  4587. s_prividx = cb->args[3];
  4588. cb->seq = net->dev_base_seq;
  4589. err = rtnl_valid_stats_req(cb->nlh, cb->strict_check, true, extack);
  4590. if (err)
  4591. return err;
  4592. ifsm = nlmsg_data(cb->nlh);
  4593. filter_mask = ifsm->filter_mask;
  4594. if (!filter_mask) {
  4595. NL_SET_ERR_MSG(extack, "Filter mask must be set for stats dump");
  4596. return -EINVAL;
  4597. }
  4598. for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
  4599. idx = 0;
  4600. head = &net->dev_index_head[h];
  4601. hlist_for_each_entry(dev, head, index_hlist) {
  4602. if (idx < s_idx)
  4603. goto cont;
  4604. err = rtnl_fill_statsinfo(skb, dev, RTM_NEWSTATS,
  4605. NETLINK_CB(cb->skb).portid,
  4606. cb->nlh->nlmsg_seq, 0,
  4607. flags, filter_mask,
  4608. &s_idxattr, &s_prividx);
  4609. /* If we ran out of room on the first message,
  4610. * we're in trouble
  4611. */
  4612. WARN_ON((err == -EMSGSIZE) && (skb->len == 0));
  4613. if (err < 0)
  4614. goto out;
  4615. s_prividx = 0;
  4616. s_idxattr = 0;
  4617. nl_dump_check_consistent(cb, nlmsg_hdr(skb));
  4618. cont:
  4619. idx++;
  4620. }
  4621. }
  4622. out:
  4623. cb->args[3] = s_prividx;
  4624. cb->args[2] = s_idxattr;
  4625. cb->args[1] = idx;
  4626. cb->args[0] = h;
  4627. return skb->len;
  4628. }
  4629. /* Process one rtnetlink message. */
  4630. static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
  4631. struct netlink_ext_ack *extack)
  4632. {
  4633. struct net *net = sock_net(skb->sk);
  4634. struct rtnl_link *link;
  4635. struct module *owner;
  4636. int err = -EOPNOTSUPP;
  4637. rtnl_doit_func doit;
  4638. unsigned int flags;
  4639. int kind;
  4640. int family;
  4641. int type;
  4642. type = nlh->nlmsg_type;
  4643. if (type > RTM_MAX)
  4644. return -EOPNOTSUPP;
  4645. type -= RTM_BASE;
  4646. /* All the messages must have at least 1 byte length */
  4647. if (nlmsg_len(nlh) < sizeof(struct rtgenmsg))
  4648. return 0;
  4649. family = ((struct rtgenmsg *)nlmsg_data(nlh))->rtgen_family;
  4650. kind = type&3;
  4651. if (kind != 2 && !netlink_net_capable(skb, CAP_NET_ADMIN))
  4652. return -EPERM;
  4653. rcu_read_lock();
  4654. if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
  4655. struct sock *rtnl;
  4656. rtnl_dumpit_func dumpit;
  4657. u32 min_dump_alloc = 0;
  4658. link = rtnl_get_link(family, type);
  4659. if (!link || !link->dumpit) {
  4660. family = PF_UNSPEC;
  4661. link = rtnl_get_link(family, type);
  4662. if (!link || !link->dumpit)
  4663. goto err_unlock;
  4664. }
  4665. owner = link->owner;
  4666. dumpit = link->dumpit;
  4667. if (type == RTM_GETLINK - RTM_BASE)
  4668. min_dump_alloc = rtnl_calcit(skb, nlh);
  4669. err = 0;
  4670. /* need to do this before rcu_read_unlock() */
  4671. if (!try_module_get(owner))
  4672. err = -EPROTONOSUPPORT;
  4673. rcu_read_unlock();
  4674. rtnl = net->rtnl;
  4675. if (err == 0) {
  4676. struct netlink_dump_control c = {
  4677. .dump = dumpit,
  4678. .min_dump_alloc = min_dump_alloc,
  4679. .module = owner,
  4680. };
  4681. err = netlink_dump_start(rtnl, skb, nlh, &c);
  4682. /* netlink_dump_start() will keep a reference on
  4683. * module if dump is still in progress.
  4684. */
  4685. module_put(owner);
  4686. }
  4687. return err;
  4688. }
  4689. link = rtnl_get_link(family, type);
  4690. if (!link || !link->doit) {
  4691. family = PF_UNSPEC;
  4692. link = rtnl_get_link(PF_UNSPEC, type);
  4693. if (!link || !link->doit)
  4694. goto out_unlock;
  4695. }
  4696. owner = link->owner;
  4697. if (!try_module_get(owner)) {
  4698. err = -EPROTONOSUPPORT;
  4699. goto out_unlock;
  4700. }
  4701. flags = link->flags;
  4702. if (flags & RTNL_FLAG_DOIT_UNLOCKED) {
  4703. doit = link->doit;
  4704. rcu_read_unlock();
  4705. if (doit)
  4706. err = doit(skb, nlh, extack);
  4707. module_put(owner);
  4708. return err;
  4709. }
  4710. rcu_read_unlock();
  4711. rtnl_lock();
  4712. link = rtnl_get_link(family, type);
  4713. if (link && link->doit)
  4714. err = link->doit(skb, nlh, extack);
  4715. rtnl_unlock();
  4716. module_put(owner);
  4717. return err;
  4718. out_unlock:
  4719. rcu_read_unlock();
  4720. return err;
  4721. err_unlock:
  4722. rcu_read_unlock();
  4723. return -EOPNOTSUPP;
  4724. }
  4725. static void rtnetlink_rcv(struct sk_buff *skb)
  4726. {
  4727. netlink_rcv_skb(skb, &rtnetlink_rcv_msg);
  4728. }
  4729. static int rtnetlink_bind(struct net *net, int group)
  4730. {
  4731. switch (group) {
  4732. case RTNLGRP_IPV4_MROUTE_R:
  4733. case RTNLGRP_IPV6_MROUTE_R:
  4734. if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  4735. return -EPERM;
  4736. break;
  4737. }
  4738. return 0;
  4739. }
  4740. static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
  4741. {
  4742. struct net_device *dev = netdev_notifier_info_to_dev(ptr);
  4743. switch (event) {
  4744. case NETDEV_REBOOT:
  4745. case NETDEV_CHANGEMTU:
  4746. case NETDEV_CHANGEADDR:
  4747. case NETDEV_CHANGENAME:
  4748. case NETDEV_FEAT_CHANGE:
  4749. case NETDEV_BONDING_FAILOVER:
  4750. case NETDEV_POST_TYPE_CHANGE:
  4751. case NETDEV_NOTIFY_PEERS:
  4752. case NETDEV_CHANGEUPPER:
  4753. case NETDEV_RESEND_IGMP:
  4754. case NETDEV_CHANGEINFODATA:
  4755. case NETDEV_CHANGELOWERSTATE:
  4756. case NETDEV_CHANGE_TX_QUEUE_LEN:
  4757. rtmsg_ifinfo_event(RTM_NEWLINK, dev, 0, rtnl_get_event(event),
  4758. GFP_KERNEL, NULL, 0);
  4759. break;
  4760. default:
  4761. break;
  4762. }
  4763. return NOTIFY_DONE;
  4764. }
  4765. static struct notifier_block rtnetlink_dev_notifier = {
  4766. .notifier_call = rtnetlink_event,
  4767. };
  4768. static int __net_init rtnetlink_net_init(struct net *net)
  4769. {
  4770. struct sock *sk;
  4771. struct netlink_kernel_cfg cfg = {
  4772. .groups = RTNLGRP_MAX,
  4773. .input = rtnetlink_rcv,
  4774. .cb_mutex = &rtnl_mutex,
  4775. .flags = NL_CFG_F_NONROOT_RECV,
  4776. .bind = rtnetlink_bind,
  4777. };
  4778. sk = netlink_kernel_create(net, NETLINK_ROUTE, &cfg);
  4779. if (!sk)
  4780. return -ENOMEM;
  4781. net->rtnl = sk;
  4782. return 0;
  4783. }
  4784. static void __net_exit rtnetlink_net_exit(struct net *net)
  4785. {
  4786. netlink_kernel_release(net->rtnl);
  4787. net->rtnl = NULL;
  4788. }
  4789. static struct pernet_operations rtnetlink_net_ops = {
  4790. .init = rtnetlink_net_init,
  4791. .exit = rtnetlink_net_exit,
  4792. };
  4793. void __init rtnetlink_init(void)
  4794. {
  4795. if (register_pernet_subsys(&rtnetlink_net_ops))
  4796. panic("rtnetlink_init: cannot initialize rtnetlink\n");
  4797. register_netdevice_notifier(&rtnetlink_dev_notifier);
  4798. rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink,
  4799. rtnl_dump_ifinfo, 0);
  4800. rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL, 0);
  4801. rtnl_register(PF_UNSPEC, RTM_NEWLINK, rtnl_newlink, NULL, 0);
  4802. rtnl_register(PF_UNSPEC, RTM_DELLINK, rtnl_dellink, NULL, 0);
  4803. rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all, 0);
  4804. rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all, 0);
  4805. rtnl_register(PF_UNSPEC, RTM_GETNETCONF, NULL, rtnl_dump_all, 0);
  4806. rtnl_register(PF_UNSPEC, RTM_NEWLINKPROP, rtnl_newlinkprop, NULL, 0);
  4807. rtnl_register(PF_UNSPEC, RTM_DELLINKPROP, rtnl_dellinkprop, NULL, 0);
  4808. rtnl_register(PF_BRIDGE, RTM_NEWNEIGH, rtnl_fdb_add, NULL, 0);
  4809. rtnl_register(PF_BRIDGE, RTM_DELNEIGH, rtnl_fdb_del, NULL, 0);
  4810. rtnl_register(PF_BRIDGE, RTM_GETNEIGH, rtnl_fdb_get, rtnl_fdb_dump, 0);
  4811. rtnl_register(PF_BRIDGE, RTM_GETLINK, NULL, rtnl_bridge_getlink, 0);
  4812. rtnl_register(PF_BRIDGE, RTM_DELLINK, rtnl_bridge_dellink, NULL, 0);
  4813. rtnl_register(PF_BRIDGE, RTM_SETLINK, rtnl_bridge_setlink, NULL, 0);
  4814. rtnl_register(PF_UNSPEC, RTM_GETSTATS, rtnl_stats_get, rtnl_stats_dump,
  4815. 0);
  4816. }