netdevice.h 162 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300
  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. * Definitions for the Interfaces handler.
  8. *
  9. * Version: @(#)dev.h 1.0.10 08/12/93
  10. *
  11. * Authors: Ross Biro
  12. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  13. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  14. * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  15. * Alan Cox, <alan@lxorguk.ukuu.org.uk>
  16. * Bjorn Ekwall. <bj0rn@blox.se>
  17. * Pekka Riikonen <priikone@poseidon.pspt.fi>
  18. *
  19. * Moved to /usr/include/linux for NET3
  20. */
  21. #ifndef _LINUX_NETDEVICE_H
  22. #define _LINUX_NETDEVICE_H
  23. #include <linux/timer.h>
  24. #include <linux/bug.h>
  25. #include <linux/delay.h>
  26. #include <linux/atomic.h>
  27. #include <linux/prefetch.h>
  28. #include <asm/cache.h>
  29. #include <asm/byteorder.h>
  30. #include <linux/percpu.h>
  31. #include <linux/rculist.h>
  32. #include <linux/workqueue.h>
  33. #include <linux/dynamic_queue_limits.h>
  34. #include <linux/ethtool.h>
  35. #include <net/net_namespace.h>
  36. #ifdef CONFIG_DCB
  37. #include <net/dcbnl.h>
  38. #endif
  39. #include <net/netprio_cgroup.h>
  40. #include <net/xdp.h>
  41. #include <linux/netdev_features.h>
  42. #include <linux/neighbour.h>
  43. #include <uapi/linux/netdevice.h>
  44. #include <uapi/linux/if_bonding.h>
  45. #include <uapi/linux/pkt_cls.h>
  46. #include <linux/hashtable.h>
  47. #include <linux/android_kabi.h>
  48. struct netpoll_info;
  49. struct device;
  50. struct phy_device;
  51. struct dsa_port;
  52. struct ip_tunnel_parm;
  53. struct macsec_context;
  54. struct macsec_ops;
  55. struct sfp_bus;
  56. /* 802.11 specific */
  57. struct wireless_dev;
  58. /* 802.15.4 specific */
  59. struct wpan_dev;
  60. struct mpls_dev;
  61. /* UDP Tunnel offloads */
  62. struct udp_tunnel_info;
  63. struct udp_tunnel_nic_info;
  64. struct udp_tunnel_nic;
  65. struct bpf_prog;
  66. struct xdp_buff;
  67. void synchronize_net(void);
  68. void netdev_set_default_ethtool_ops(struct net_device *dev,
  69. const struct ethtool_ops *ops);
  70. /* Backlog congestion levels */
  71. #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
  72. #define NET_RX_DROP 1 /* packet dropped */
  73. #define MAX_NEST_DEV 8
  74. /*
  75. * Transmit return codes: transmit return codes originate from three different
  76. * namespaces:
  77. *
  78. * - qdisc return codes
  79. * - driver transmit return codes
  80. * - errno values
  81. *
  82. * Drivers are allowed to return any one of those in their hard_start_xmit()
  83. * function. Real network devices commonly used with qdiscs should only return
  84. * the driver transmit return codes though - when qdiscs are used, the actual
  85. * transmission happens asynchronously, so the value is not propagated to
  86. * higher layers. Virtual network devices transmit synchronously; in this case
  87. * the driver transmit return codes are consumed by dev_queue_xmit(), and all
  88. * others are propagated to higher layers.
  89. */
  90. /* qdisc ->enqueue() return codes. */
  91. #define NET_XMIT_SUCCESS 0x00
  92. #define NET_XMIT_DROP 0x01 /* skb dropped */
  93. #define NET_XMIT_CN 0x02 /* congestion notification */
  94. #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
  95. /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  96. * indicates that the device will soon be dropping packets, or already drops
  97. * some packets of the same priority; prompting us to send less aggressively. */
  98. #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
  99. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  100. /* Driver transmit return codes */
  101. #define NETDEV_TX_MASK 0xf0
  102. enum netdev_tx {
  103. __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
  104. NETDEV_TX_OK = 0x00, /* driver took care of packet */
  105. NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
  106. };
  107. typedef enum netdev_tx netdev_tx_t;
  108. /*
  109. * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
  110. * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
  111. */
  112. static inline bool dev_xmit_complete(int rc)
  113. {
  114. /*
  115. * Positive cases with an skb consumed by a driver:
  116. * - successful transmission (rc == NETDEV_TX_OK)
  117. * - error while transmitting (rc < 0)
  118. * - error while queueing to a different device (rc & NET_XMIT_MASK)
  119. */
  120. if (likely(rc < NET_XMIT_MASK))
  121. return true;
  122. return false;
  123. }
  124. /*
  125. * Compute the worst-case header length according to the protocols
  126. * used.
  127. */
  128. #if defined(CONFIG_HYPERV_NET)
  129. # define LL_MAX_HEADER 128
  130. #elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
  131. # if defined(CONFIG_MAC80211_MESH)
  132. # define LL_MAX_HEADER 128
  133. # else
  134. # define LL_MAX_HEADER 96
  135. # endif
  136. #else
  137. # define LL_MAX_HEADER 32
  138. #endif
  139. #if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
  140. !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
  141. #define MAX_HEADER LL_MAX_HEADER
  142. #else
  143. #define MAX_HEADER (LL_MAX_HEADER + 48)
  144. #endif
  145. /*
  146. * Old network device statistics. Fields are native words
  147. * (unsigned long) so they can be read and written atomically.
  148. */
  149. struct net_device_stats {
  150. unsigned long rx_packets;
  151. unsigned long tx_packets;
  152. unsigned long rx_bytes;
  153. unsigned long tx_bytes;
  154. unsigned long rx_errors;
  155. unsigned long tx_errors;
  156. unsigned long rx_dropped;
  157. unsigned long tx_dropped;
  158. unsigned long multicast;
  159. unsigned long collisions;
  160. unsigned long rx_length_errors;
  161. unsigned long rx_over_errors;
  162. unsigned long rx_crc_errors;
  163. unsigned long rx_frame_errors;
  164. unsigned long rx_fifo_errors;
  165. unsigned long rx_missed_errors;
  166. unsigned long tx_aborted_errors;
  167. unsigned long tx_carrier_errors;
  168. unsigned long tx_fifo_errors;
  169. unsigned long tx_heartbeat_errors;
  170. unsigned long tx_window_errors;
  171. unsigned long rx_compressed;
  172. unsigned long tx_compressed;
  173. };
  174. #include <linux/cache.h>
  175. #include <linux/skbuff.h>
  176. #ifdef CONFIG_RPS
  177. #include <linux/static_key.h>
  178. extern struct static_key_false rps_needed;
  179. extern struct static_key_false rfs_needed;
  180. #endif
  181. struct neighbour;
  182. struct neigh_parms;
  183. struct sk_buff;
  184. struct netdev_hw_addr {
  185. struct list_head list;
  186. unsigned char addr[MAX_ADDR_LEN];
  187. unsigned char type;
  188. #define NETDEV_HW_ADDR_T_LAN 1
  189. #define NETDEV_HW_ADDR_T_SAN 2
  190. #define NETDEV_HW_ADDR_T_UNICAST 3
  191. #define NETDEV_HW_ADDR_T_MULTICAST 4
  192. bool global_use;
  193. int sync_cnt;
  194. int refcount;
  195. int synced;
  196. struct rcu_head rcu_head;
  197. };
  198. struct netdev_hw_addr_list {
  199. struct list_head list;
  200. int count;
  201. };
  202. #define netdev_hw_addr_list_count(l) ((l)->count)
  203. #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
  204. #define netdev_hw_addr_list_for_each(ha, l) \
  205. list_for_each_entry(ha, &(l)->list, list)
  206. #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
  207. #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
  208. #define netdev_for_each_uc_addr(ha, dev) \
  209. netdev_hw_addr_list_for_each(ha, &(dev)->uc)
  210. #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
  211. #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
  212. #define netdev_for_each_mc_addr(ha, dev) \
  213. netdev_hw_addr_list_for_each(ha, &(dev)->mc)
  214. struct hh_cache {
  215. unsigned int hh_len;
  216. seqlock_t hh_lock;
  217. /* cached hardware header; allow for machine alignment needs. */
  218. #define HH_DATA_MOD 16
  219. #define HH_DATA_OFF(__len) \
  220. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  221. #define HH_DATA_ALIGN(__len) \
  222. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  223. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  224. };
  225. /* Reserve HH_DATA_MOD byte-aligned hard_header_len, but at least that much.
  226. * Alternative is:
  227. * dev->hard_header_len ? (dev->hard_header_len +
  228. * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  229. *
  230. * We could use other alignment values, but we must maintain the
  231. * relationship HH alignment <= LL alignment.
  232. */
  233. #define LL_RESERVED_SPACE(dev) \
  234. ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  235. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  236. ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  237. struct header_ops {
  238. int (*create) (struct sk_buff *skb, struct net_device *dev,
  239. unsigned short type, const void *daddr,
  240. const void *saddr, unsigned int len);
  241. int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
  242. int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
  243. void (*cache_update)(struct hh_cache *hh,
  244. const struct net_device *dev,
  245. const unsigned char *haddr);
  246. bool (*validate)(const char *ll_header, unsigned int len);
  247. __be16 (*parse_protocol)(const struct sk_buff *skb);
  248. ANDROID_KABI_RESERVE(1);
  249. ANDROID_KABI_RESERVE(2);
  250. };
  251. /* These flag bits are private to the generic network queueing
  252. * layer; they may not be explicitly referenced by any other
  253. * code.
  254. */
  255. enum netdev_state_t {
  256. __LINK_STATE_START,
  257. __LINK_STATE_PRESENT,
  258. __LINK_STATE_NOCARRIER,
  259. __LINK_STATE_LINKWATCH_PENDING,
  260. __LINK_STATE_DORMANT,
  261. __LINK_STATE_TESTING,
  262. };
  263. /*
  264. * This structure holds boot-time configured netdevice settings. They
  265. * are then used in the device probing.
  266. */
  267. struct netdev_boot_setup {
  268. char name[IFNAMSIZ];
  269. struct ifmap map;
  270. };
  271. #define NETDEV_BOOT_SETUP_MAX 8
  272. int __init netdev_boot_setup(char *str);
  273. struct gro_list {
  274. struct list_head list;
  275. int count;
  276. };
  277. /*
  278. * size of gro hash buckets, must less than bit number of
  279. * napi_struct::gro_bitmask
  280. */
  281. #define GRO_HASH_BUCKETS 8
  282. /*
  283. * Structure for NAPI scheduling similar to tasklet but with weighting
  284. */
  285. struct napi_struct {
  286. /* The poll_list must only be managed by the entity which
  287. * changes the state of the NAPI_STATE_SCHED bit. This means
  288. * whoever atomically sets that bit can add this napi_struct
  289. * to the per-CPU poll_list, and whoever clears that bit
  290. * can remove from the list right before clearing the bit.
  291. */
  292. struct list_head poll_list;
  293. unsigned long state;
  294. int weight;
  295. int defer_hard_irqs_count;
  296. unsigned long gro_bitmask;
  297. int (*poll)(struct napi_struct *, int);
  298. #ifdef CONFIG_NETPOLL
  299. int poll_owner;
  300. #endif
  301. struct net_device *dev;
  302. struct gro_list gro_hash[GRO_HASH_BUCKETS];
  303. struct sk_buff *skb;
  304. struct list_head rx_list; /* Pending GRO_NORMAL skbs */
  305. int rx_count; /* length of rx_list */
  306. struct hrtimer timer;
  307. struct list_head dev_list;
  308. struct hlist_node napi_hash_node;
  309. unsigned int napi_id;
  310. ANDROID_KABI_RESERVE(1);
  311. ANDROID_KABI_RESERVE(2);
  312. ANDROID_KABI_RESERVE(3);
  313. ANDROID_KABI_RESERVE(4);
  314. };
  315. enum {
  316. NAPI_STATE_SCHED, /* Poll is scheduled */
  317. NAPI_STATE_MISSED, /* reschedule a napi */
  318. NAPI_STATE_DISABLE, /* Disable pending */
  319. NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
  320. NAPI_STATE_LISTED, /* NAPI added to system lists */
  321. NAPI_STATE_NO_BUSY_POLL,/* Do not add in napi_hash, no busy polling */
  322. NAPI_STATE_IN_BUSY_POLL,/* sk_busy_loop() owns this NAPI */
  323. };
  324. enum {
  325. NAPIF_STATE_SCHED = BIT(NAPI_STATE_SCHED),
  326. NAPIF_STATE_MISSED = BIT(NAPI_STATE_MISSED),
  327. NAPIF_STATE_DISABLE = BIT(NAPI_STATE_DISABLE),
  328. NAPIF_STATE_NPSVC = BIT(NAPI_STATE_NPSVC),
  329. NAPIF_STATE_LISTED = BIT(NAPI_STATE_LISTED),
  330. NAPIF_STATE_NO_BUSY_POLL = BIT(NAPI_STATE_NO_BUSY_POLL),
  331. NAPIF_STATE_IN_BUSY_POLL = BIT(NAPI_STATE_IN_BUSY_POLL),
  332. };
  333. enum gro_result {
  334. GRO_MERGED,
  335. GRO_MERGED_FREE,
  336. GRO_HELD,
  337. GRO_NORMAL,
  338. GRO_DROP,
  339. GRO_CONSUMED,
  340. };
  341. typedef enum gro_result gro_result_t;
  342. /*
  343. * enum rx_handler_result - Possible return values for rx_handlers.
  344. * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
  345. * further.
  346. * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
  347. * case skb->dev was changed by rx_handler.
  348. * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
  349. * @RX_HANDLER_PASS: Do nothing, pass the skb as if no rx_handler was called.
  350. *
  351. * rx_handlers are functions called from inside __netif_receive_skb(), to do
  352. * special processing of the skb, prior to delivery to protocol handlers.
  353. *
  354. * Currently, a net_device can only have a single rx_handler registered. Trying
  355. * to register a second rx_handler will return -EBUSY.
  356. *
  357. * To register a rx_handler on a net_device, use netdev_rx_handler_register().
  358. * To unregister a rx_handler on a net_device, use
  359. * netdev_rx_handler_unregister().
  360. *
  361. * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
  362. * do with the skb.
  363. *
  364. * If the rx_handler consumed the skb in some way, it should return
  365. * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
  366. * the skb to be delivered in some other way.
  367. *
  368. * If the rx_handler changed skb->dev, to divert the skb to another
  369. * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
  370. * new device will be called if it exists.
  371. *
  372. * If the rx_handler decides the skb should be ignored, it should return
  373. * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
  374. * are registered on exact device (ptype->dev == skb->dev).
  375. *
  376. * If the rx_handler didn't change skb->dev, but wants the skb to be normally
  377. * delivered, it should return RX_HANDLER_PASS.
  378. *
  379. * A device without a registered rx_handler will behave as if rx_handler
  380. * returned RX_HANDLER_PASS.
  381. */
  382. enum rx_handler_result {
  383. RX_HANDLER_CONSUMED,
  384. RX_HANDLER_ANOTHER,
  385. RX_HANDLER_EXACT,
  386. RX_HANDLER_PASS,
  387. };
  388. typedef enum rx_handler_result rx_handler_result_t;
  389. typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
  390. void __napi_schedule(struct napi_struct *n);
  391. void __napi_schedule_irqoff(struct napi_struct *n);
  392. static inline bool napi_disable_pending(struct napi_struct *n)
  393. {
  394. return test_bit(NAPI_STATE_DISABLE, &n->state);
  395. }
  396. bool napi_schedule_prep(struct napi_struct *n);
  397. /**
  398. * napi_schedule - schedule NAPI poll
  399. * @n: NAPI context
  400. *
  401. * Schedule NAPI poll routine to be called if it is not already
  402. * running.
  403. */
  404. static inline void napi_schedule(struct napi_struct *n)
  405. {
  406. if (napi_schedule_prep(n))
  407. __napi_schedule(n);
  408. }
  409. /**
  410. * napi_schedule_irqoff - schedule NAPI poll
  411. * @n: NAPI context
  412. *
  413. * Variant of napi_schedule(), assuming hard irqs are masked.
  414. */
  415. static inline void napi_schedule_irqoff(struct napi_struct *n)
  416. {
  417. if (napi_schedule_prep(n))
  418. __napi_schedule_irqoff(n);
  419. }
  420. /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
  421. static inline bool napi_reschedule(struct napi_struct *napi)
  422. {
  423. if (napi_schedule_prep(napi)) {
  424. __napi_schedule(napi);
  425. return true;
  426. }
  427. return false;
  428. }
  429. bool napi_complete_done(struct napi_struct *n, int work_done);
  430. /**
  431. * napi_complete - NAPI processing complete
  432. * @n: NAPI context
  433. *
  434. * Mark NAPI processing as complete.
  435. * Consider using napi_complete_done() instead.
  436. * Return false if device should avoid rearming interrupts.
  437. */
  438. static inline bool napi_complete(struct napi_struct *n)
  439. {
  440. return napi_complete_done(n, 0);
  441. }
  442. /**
  443. * napi_disable - prevent NAPI from scheduling
  444. * @n: NAPI context
  445. *
  446. * Stop NAPI from being scheduled on this context.
  447. * Waits till any outstanding processing completes.
  448. */
  449. void napi_disable(struct napi_struct *n);
  450. /**
  451. * napi_enable - enable NAPI scheduling
  452. * @n: NAPI context
  453. *
  454. * Resume NAPI from being scheduled on this context.
  455. * Must be paired with napi_disable.
  456. */
  457. static inline void napi_enable(struct napi_struct *n)
  458. {
  459. BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
  460. smp_mb__before_atomic();
  461. clear_bit(NAPI_STATE_SCHED, &n->state);
  462. clear_bit(NAPI_STATE_NPSVC, &n->state);
  463. }
  464. /**
  465. * napi_synchronize - wait until NAPI is not running
  466. * @n: NAPI context
  467. *
  468. * Wait until NAPI is done being scheduled on this context.
  469. * Waits till any outstanding processing completes but
  470. * does not disable future activations.
  471. */
  472. static inline void napi_synchronize(const struct napi_struct *n)
  473. {
  474. if (IS_ENABLED(CONFIG_SMP))
  475. while (test_bit(NAPI_STATE_SCHED, &n->state))
  476. msleep(1);
  477. else
  478. barrier();
  479. }
  480. /**
  481. * napi_if_scheduled_mark_missed - if napi is running, set the
  482. * NAPIF_STATE_MISSED
  483. * @n: NAPI context
  484. *
  485. * If napi is running, set the NAPIF_STATE_MISSED, and return true if
  486. * NAPI is scheduled.
  487. **/
  488. static inline bool napi_if_scheduled_mark_missed(struct napi_struct *n)
  489. {
  490. unsigned long val, new;
  491. do {
  492. val = READ_ONCE(n->state);
  493. if (val & NAPIF_STATE_DISABLE)
  494. return true;
  495. if (!(val & NAPIF_STATE_SCHED))
  496. return false;
  497. new = val | NAPIF_STATE_MISSED;
  498. } while (cmpxchg(&n->state, val, new) != val);
  499. return true;
  500. }
  501. enum netdev_queue_state_t {
  502. __QUEUE_STATE_DRV_XOFF,
  503. __QUEUE_STATE_STACK_XOFF,
  504. __QUEUE_STATE_FROZEN,
  505. };
  506. #define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
  507. #define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
  508. #define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
  509. #define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
  510. #define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
  511. QUEUE_STATE_FROZEN)
  512. #define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
  513. QUEUE_STATE_FROZEN)
  514. /*
  515. * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The
  516. * netif_tx_* functions below are used to manipulate this flag. The
  517. * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
  518. * queue independently. The netif_xmit_*stopped functions below are called
  519. * to check if the queue has been stopped by the driver or stack (either
  520. * of the XOFF bits are set in the state). Drivers should not need to call
  521. * netif_xmit*stopped functions, they should only be using netif_tx_*.
  522. */
  523. struct netdev_queue {
  524. /*
  525. * read-mostly part
  526. */
  527. struct net_device *dev;
  528. struct Qdisc __rcu *qdisc;
  529. struct Qdisc *qdisc_sleeping;
  530. #ifdef CONFIG_SYSFS
  531. struct kobject kobj;
  532. #endif
  533. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  534. int numa_node;
  535. #endif
  536. unsigned long tx_maxrate;
  537. /*
  538. * Number of TX timeouts for this queue
  539. * (/sys/class/net/DEV/Q/trans_timeout)
  540. */
  541. unsigned long trans_timeout;
  542. /* Subordinate device that the queue has been assigned to */
  543. struct net_device *sb_dev;
  544. #ifdef CONFIG_XDP_SOCKETS
  545. struct xsk_buff_pool *pool;
  546. #endif
  547. /*
  548. * write-mostly part
  549. */
  550. spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
  551. int xmit_lock_owner;
  552. /*
  553. * Time (in jiffies) of last Tx
  554. */
  555. unsigned long trans_start;
  556. unsigned long state;
  557. #ifdef CONFIG_BQL
  558. struct dql dql;
  559. #endif
  560. ANDROID_KABI_RESERVE(1);
  561. ANDROID_KABI_RESERVE(2);
  562. ANDROID_KABI_RESERVE(3);
  563. ANDROID_KABI_RESERVE(4);
  564. } ____cacheline_aligned_in_smp;
  565. extern int sysctl_fb_tunnels_only_for_init_net;
  566. extern int sysctl_devconf_inherit_init_net;
  567. /*
  568. * sysctl_fb_tunnels_only_for_init_net == 0 : For all netns
  569. * == 1 : For initns only
  570. * == 2 : For none.
  571. */
  572. static inline bool net_has_fallback_tunnels(const struct net *net)
  573. {
  574. return !IS_ENABLED(CONFIG_SYSCTL) ||
  575. !sysctl_fb_tunnels_only_for_init_net ||
  576. (net == &init_net && sysctl_fb_tunnels_only_for_init_net == 1);
  577. }
  578. static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
  579. {
  580. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  581. return q->numa_node;
  582. #else
  583. return NUMA_NO_NODE;
  584. #endif
  585. }
  586. static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
  587. {
  588. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  589. q->numa_node = node;
  590. #endif
  591. }
  592. #ifdef CONFIG_RPS
  593. /*
  594. * This structure holds an RPS map which can be of variable length. The
  595. * map is an array of CPUs.
  596. */
  597. struct rps_map {
  598. unsigned int len;
  599. struct rcu_head rcu;
  600. u16 cpus[];
  601. };
  602. #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
  603. /*
  604. * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
  605. * tail pointer for that CPU's input queue at the time of last enqueue, and
  606. * a hardware filter index.
  607. */
  608. struct rps_dev_flow {
  609. u16 cpu;
  610. u16 filter;
  611. unsigned int last_qtail;
  612. };
  613. #define RPS_NO_FILTER 0xffff
  614. /*
  615. * The rps_dev_flow_table structure contains a table of flow mappings.
  616. */
  617. struct rps_dev_flow_table {
  618. unsigned int mask;
  619. struct rcu_head rcu;
  620. struct rps_dev_flow flows[];
  621. };
  622. #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
  623. ((_num) * sizeof(struct rps_dev_flow)))
  624. /*
  625. * The rps_sock_flow_table contains mappings of flows to the last CPU
  626. * on which they were processed by the application (set in recvmsg).
  627. * Each entry is a 32bit value. Upper part is the high-order bits
  628. * of flow hash, lower part is CPU number.
  629. * rps_cpu_mask is used to partition the space, depending on number of
  630. * possible CPUs : rps_cpu_mask = roundup_pow_of_two(nr_cpu_ids) - 1
  631. * For example, if 64 CPUs are possible, rps_cpu_mask = 0x3f,
  632. * meaning we use 32-6=26 bits for the hash.
  633. */
  634. struct rps_sock_flow_table {
  635. u32 mask;
  636. u32 ents[] ____cacheline_aligned_in_smp;
  637. };
  638. #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
  639. #define RPS_NO_CPU 0xffff
  640. extern u32 rps_cpu_mask;
  641. extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
  642. static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
  643. u32 hash)
  644. {
  645. if (table && hash) {
  646. unsigned int index = hash & table->mask;
  647. u32 val = hash & ~rps_cpu_mask;
  648. /* We only give a hint, preemption can change CPU under us */
  649. val |= raw_smp_processor_id();
  650. if (table->ents[index] != val)
  651. table->ents[index] = val;
  652. }
  653. }
  654. #ifdef CONFIG_RFS_ACCEL
  655. bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
  656. u16 filter_id);
  657. #endif
  658. #endif /* CONFIG_RPS */
  659. /* This structure contains an instance of an RX queue. */
  660. struct netdev_rx_queue {
  661. #ifdef CONFIG_RPS
  662. struct rps_map __rcu *rps_map;
  663. struct rps_dev_flow_table __rcu *rps_flow_table;
  664. #endif
  665. struct kobject kobj;
  666. struct net_device *dev;
  667. struct xdp_rxq_info xdp_rxq;
  668. #ifdef CONFIG_XDP_SOCKETS
  669. struct xsk_buff_pool *pool;
  670. #endif
  671. ANDROID_KABI_RESERVE(1);
  672. ANDROID_KABI_RESERVE(2);
  673. ANDROID_KABI_RESERVE(3);
  674. ANDROID_KABI_RESERVE(4);
  675. } ____cacheline_aligned_in_smp;
  676. /*
  677. * RX queue sysfs structures and functions.
  678. */
  679. struct rx_queue_attribute {
  680. struct attribute attr;
  681. ssize_t (*show)(struct netdev_rx_queue *queue, char *buf);
  682. ssize_t (*store)(struct netdev_rx_queue *queue,
  683. const char *buf, size_t len);
  684. };
  685. #ifdef CONFIG_XPS
  686. /*
  687. * This structure holds an XPS map which can be of variable length. The
  688. * map is an array of queues.
  689. */
  690. struct xps_map {
  691. unsigned int len;
  692. unsigned int alloc_len;
  693. struct rcu_head rcu;
  694. u16 queues[];
  695. };
  696. #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
  697. #define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
  698. - sizeof(struct xps_map)) / sizeof(u16))
  699. /*
  700. * This structure holds all XPS maps for device. Maps are indexed by CPU.
  701. */
  702. struct xps_dev_maps {
  703. struct rcu_head rcu;
  704. struct xps_map __rcu *attr_map[]; /* Either CPUs map or RXQs map */
  705. };
  706. #define XPS_CPU_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) + \
  707. (nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))
  708. #define XPS_RXQ_DEV_MAPS_SIZE(_tcs, _rxqs) (sizeof(struct xps_dev_maps) +\
  709. (_rxqs * (_tcs) * sizeof(struct xps_map *)))
  710. #endif /* CONFIG_XPS */
  711. #define TC_MAX_QUEUE 16
  712. #define TC_BITMASK 15
  713. /* HW offloaded queuing disciplines txq count and offset maps */
  714. struct netdev_tc_txq {
  715. u16 count;
  716. u16 offset;
  717. };
  718. #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
  719. /*
  720. * This structure is to hold information about the device
  721. * configured to run FCoE protocol stack.
  722. */
  723. struct netdev_fcoe_hbainfo {
  724. char manufacturer[64];
  725. char serial_number[64];
  726. char hardware_version[64];
  727. char driver_version[64];
  728. char optionrom_version[64];
  729. char firmware_version[64];
  730. char model[256];
  731. char model_description[256];
  732. };
  733. #endif
  734. #define MAX_PHYS_ITEM_ID_LEN 32
  735. /* This structure holds a unique identifier to identify some
  736. * physical item (port for example) used by a netdevice.
  737. */
  738. struct netdev_phys_item_id {
  739. unsigned char id[MAX_PHYS_ITEM_ID_LEN];
  740. unsigned char id_len;
  741. };
  742. static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
  743. struct netdev_phys_item_id *b)
  744. {
  745. return a->id_len == b->id_len &&
  746. memcmp(a->id, b->id, a->id_len) == 0;
  747. }
  748. typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  749. struct sk_buff *skb,
  750. struct net_device *sb_dev);
  751. enum tc_setup_type {
  752. TC_SETUP_QDISC_MQPRIO,
  753. TC_SETUP_CLSU32,
  754. TC_SETUP_CLSFLOWER,
  755. TC_SETUP_CLSMATCHALL,
  756. TC_SETUP_CLSBPF,
  757. TC_SETUP_BLOCK,
  758. TC_SETUP_QDISC_CBS,
  759. TC_SETUP_QDISC_RED,
  760. TC_SETUP_QDISC_PRIO,
  761. TC_SETUP_QDISC_MQ,
  762. TC_SETUP_QDISC_ETF,
  763. TC_SETUP_ROOT_QDISC,
  764. TC_SETUP_QDISC_GRED,
  765. TC_SETUP_QDISC_TAPRIO,
  766. TC_SETUP_FT,
  767. TC_SETUP_QDISC_ETS,
  768. TC_SETUP_QDISC_TBF,
  769. TC_SETUP_QDISC_FIFO,
  770. };
  771. /* These structures hold the attributes of bpf state that are being passed
  772. * to the netdevice through the bpf op.
  773. */
  774. enum bpf_netdev_command {
  775. /* Set or clear a bpf program used in the earliest stages of packet
  776. * rx. The prog will have been loaded as BPF_PROG_TYPE_XDP. The callee
  777. * is responsible for calling bpf_prog_put on any old progs that are
  778. * stored. In case of error, the callee need not release the new prog
  779. * reference, but on success it takes ownership and must bpf_prog_put
  780. * when it is no longer used.
  781. */
  782. XDP_SETUP_PROG,
  783. XDP_SETUP_PROG_HW,
  784. /* BPF program for offload callbacks, invoked at program load time. */
  785. BPF_OFFLOAD_MAP_ALLOC,
  786. BPF_OFFLOAD_MAP_FREE,
  787. XDP_SETUP_XSK_POOL,
  788. };
  789. struct bpf_prog_offload_ops;
  790. struct netlink_ext_ack;
  791. struct xdp_umem;
  792. struct xdp_dev_bulk_queue;
  793. struct bpf_xdp_link;
  794. enum bpf_xdp_mode {
  795. XDP_MODE_SKB = 0,
  796. XDP_MODE_DRV = 1,
  797. XDP_MODE_HW = 2,
  798. __MAX_XDP_MODE
  799. };
  800. struct bpf_xdp_entity {
  801. struct bpf_prog *prog;
  802. struct bpf_xdp_link *link;
  803. };
  804. struct netdev_bpf {
  805. enum bpf_netdev_command command;
  806. union {
  807. /* XDP_SETUP_PROG */
  808. struct {
  809. u32 flags;
  810. struct bpf_prog *prog;
  811. struct netlink_ext_ack *extack;
  812. };
  813. /* BPF_OFFLOAD_MAP_ALLOC, BPF_OFFLOAD_MAP_FREE */
  814. struct {
  815. struct bpf_offloaded_map *offmap;
  816. };
  817. /* XDP_SETUP_XSK_POOL */
  818. struct {
  819. struct xsk_buff_pool *pool;
  820. u16 queue_id;
  821. } xsk;
  822. };
  823. };
  824. /* Flags for ndo_xsk_wakeup. */
  825. #define XDP_WAKEUP_RX (1 << 0)
  826. #define XDP_WAKEUP_TX (1 << 1)
  827. #ifdef CONFIG_XFRM_OFFLOAD
  828. struct xfrmdev_ops {
  829. int (*xdo_dev_state_add) (struct xfrm_state *x);
  830. void (*xdo_dev_state_delete) (struct xfrm_state *x);
  831. void (*xdo_dev_state_free) (struct xfrm_state *x);
  832. bool (*xdo_dev_offload_ok) (struct sk_buff *skb,
  833. struct xfrm_state *x);
  834. void (*xdo_dev_state_advance_esn) (struct xfrm_state *x);
  835. ANDROID_KABI_RESERVE(1);
  836. ANDROID_KABI_RESERVE(2);
  837. ANDROID_KABI_RESERVE(3);
  838. ANDROID_KABI_RESERVE(4);
  839. };
  840. #endif
  841. struct dev_ifalias {
  842. struct rcu_head rcuhead;
  843. char ifalias[];
  844. };
  845. struct devlink;
  846. struct tlsdev_ops;
  847. struct netdev_name_node {
  848. struct hlist_node hlist;
  849. struct list_head list;
  850. struct net_device *dev;
  851. const char *name;
  852. };
  853. int netdev_name_node_alt_create(struct net_device *dev, const char *name);
  854. int netdev_name_node_alt_destroy(struct net_device *dev, const char *name);
  855. struct netdev_net_notifier {
  856. struct list_head list;
  857. struct notifier_block *nb;
  858. };
  859. /*
  860. * This structure defines the management hooks for network devices.
  861. * The following hooks can be defined; unless noted otherwise, they are
  862. * optional and can be filled with a null pointer.
  863. *
  864. * int (*ndo_init)(struct net_device *dev);
  865. * This function is called once when a network device is registered.
  866. * The network device can use this for any late stage initialization
  867. * or semantic validation. It can fail with an error code which will
  868. * be propagated back to register_netdev.
  869. *
  870. * void (*ndo_uninit)(struct net_device *dev);
  871. * This function is called when device is unregistered or when registration
  872. * fails. It is not called if init fails.
  873. *
  874. * int (*ndo_open)(struct net_device *dev);
  875. * This function is called when a network device transitions to the up
  876. * state.
  877. *
  878. * int (*ndo_stop)(struct net_device *dev);
  879. * This function is called when a network device transitions to the down
  880. * state.
  881. *
  882. * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  883. * struct net_device *dev);
  884. * Called when a packet needs to be transmitted.
  885. * Returns NETDEV_TX_OK. Can return NETDEV_TX_BUSY, but you should stop
  886. * the queue before that can happen; it's for obsolete devices and weird
  887. * corner cases, but the stack really does a non-trivial amount
  888. * of useless work if you return NETDEV_TX_BUSY.
  889. * Required; cannot be NULL.
  890. *
  891. * netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
  892. * struct net_device *dev
  893. * netdev_features_t features);
  894. * Called by core transmit path to determine if device is capable of
  895. * performing offload operations on a given packet. This is to give
  896. * the device an opportunity to implement any restrictions that cannot
  897. * be otherwise expressed by feature flags. The check is called with
  898. * the set of features that the stack has calculated and it returns
  899. * those the driver believes to be appropriate.
  900. *
  901. * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
  902. * struct net_device *sb_dev);
  903. * Called to decide which queue to use when device supports multiple
  904. * transmit queues.
  905. *
  906. * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
  907. * This function is called to allow device receiver to make
  908. * changes to configuration when multicast or promiscuous is enabled.
  909. *
  910. * void (*ndo_set_rx_mode)(struct net_device *dev);
  911. * This function is called device changes address list filtering.
  912. * If driver handles unicast address filtering, it should set
  913. * IFF_UNICAST_FLT in its priv_flags.
  914. *
  915. * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  916. * This function is called when the Media Access Control address
  917. * needs to be changed. If this interface is not defined, the
  918. * MAC address can not be changed.
  919. *
  920. * int (*ndo_validate_addr)(struct net_device *dev);
  921. * Test if Media Access Control address is valid for the device.
  922. *
  923. * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
  924. * Called when a user requests an ioctl which can't be handled by
  925. * the generic interface code. If not defined ioctls return
  926. * not supported error code.
  927. *
  928. * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
  929. * Used to set network devices bus interface parameters. This interface
  930. * is retained for legacy reasons; new devices should use the bus
  931. * interface (PCI) for low level management.
  932. *
  933. * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  934. * Called when a user wants to change the Maximum Transfer Unit
  935. * of a device.
  936. *
  937. * void (*ndo_tx_timeout)(struct net_device *dev, unsigned int txqueue);
  938. * Callback used when the transmitter has not made any progress
  939. * for dev->watchdog ticks.
  940. *
  941. * void (*ndo_get_stats64)(struct net_device *dev,
  942. * struct rtnl_link_stats64 *storage);
  943. * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  944. * Called when a user wants to get the network device usage
  945. * statistics. Drivers must do one of the following:
  946. * 1. Define @ndo_get_stats64 to fill in a zero-initialised
  947. * rtnl_link_stats64 structure passed by the caller.
  948. * 2. Define @ndo_get_stats to update a net_device_stats structure
  949. * (which should normally be dev->stats) and return a pointer to
  950. * it. The structure may be changed asynchronously only if each
  951. * field is written atomically.
  952. * 3. Update dev->stats asynchronously and atomically, and define
  953. * neither operation.
  954. *
  955. * bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id)
  956. * Return true if this device supports offload stats of this attr_id.
  957. *
  958. * int (*ndo_get_offload_stats)(int attr_id, const struct net_device *dev,
  959. * void *attr_data)
  960. * Get statistics for offload operations by attr_id. Write it into the
  961. * attr_data pointer.
  962. *
  963. * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
  964. * If device supports VLAN filtering this function is called when a
  965. * VLAN id is registered.
  966. *
  967. * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
  968. * If device supports VLAN filtering this function is called when a
  969. * VLAN id is unregistered.
  970. *
  971. * void (*ndo_poll_controller)(struct net_device *dev);
  972. *
  973. * SR-IOV management functions.
  974. * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  975. * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan,
  976. * u8 qos, __be16 proto);
  977. * int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
  978. * int max_tx_rate);
  979. * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
  980. * int (*ndo_set_vf_trust)(struct net_device *dev, int vf, bool setting);
  981. * int (*ndo_get_vf_config)(struct net_device *dev,
  982. * int vf, struct ifla_vf_info *ivf);
  983. * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state);
  984. * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
  985. * struct nlattr *port[]);
  986. *
  987. * Enable or disable the VF ability to query its RSS Redirection Table and
  988. * Hash Key. This is needed since on some devices VF share this information
  989. * with PF and querying it may introduce a theoretical security risk.
  990. * int (*ndo_set_vf_rss_query_en)(struct net_device *dev, int vf, bool setting);
  991. * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
  992. * int (*ndo_setup_tc)(struct net_device *dev, enum tc_setup_type type,
  993. * void *type_data);
  994. * Called to setup any 'tc' scheduler, classifier or action on @dev.
  995. * This is always called from the stack with the rtnl lock held and netif
  996. * tx queues stopped. This allows the netdevice to perform queue
  997. * management safely.
  998. *
  999. * Fiber Channel over Ethernet (FCoE) offload functions.
  1000. * int (*ndo_fcoe_enable)(struct net_device *dev);
  1001. * Called when the FCoE protocol stack wants to start using LLD for FCoE
  1002. * so the underlying device can perform whatever needed configuration or
  1003. * initialization to support acceleration of FCoE traffic.
  1004. *
  1005. * int (*ndo_fcoe_disable)(struct net_device *dev);
  1006. * Called when the FCoE protocol stack wants to stop using LLD for FCoE
  1007. * so the underlying device can perform whatever needed clean-ups to
  1008. * stop supporting acceleration of FCoE traffic.
  1009. *
  1010. * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
  1011. * struct scatterlist *sgl, unsigned int sgc);
  1012. * Called when the FCoE Initiator wants to initialize an I/O that
  1013. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  1014. * perform necessary setup and returns 1 to indicate the device is set up
  1015. * successfully to perform DDP on this I/O, otherwise this returns 0.
  1016. *
  1017. * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
  1018. * Called when the FCoE Initiator/Target is done with the DDPed I/O as
  1019. * indicated by the FC exchange id 'xid', so the underlying device can
  1020. * clean up and reuse resources for later DDP requests.
  1021. *
  1022. * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
  1023. * struct scatterlist *sgl, unsigned int sgc);
  1024. * Called when the FCoE Target wants to initialize an I/O that
  1025. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  1026. * perform necessary setup and returns 1 to indicate the device is set up
  1027. * successfully to perform DDP on this I/O, otherwise this returns 0.
  1028. *
  1029. * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
  1030. * struct netdev_fcoe_hbainfo *hbainfo);
  1031. * Called when the FCoE Protocol stack wants information on the underlying
  1032. * device. This information is utilized by the FCoE protocol stack to
  1033. * register attributes with Fiber Channel management service as per the
  1034. * FC-GS Fabric Device Management Information(FDMI) specification.
  1035. *
  1036. * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
  1037. * Called when the underlying device wants to override default World Wide
  1038. * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
  1039. * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
  1040. * protocol stack to use.
  1041. *
  1042. * RFS acceleration.
  1043. * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
  1044. * u16 rxq_index, u32 flow_id);
  1045. * Set hardware filter for RFS. rxq_index is the target queue index;
  1046. * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
  1047. * Return the filter ID on success, or a negative error code.
  1048. *
  1049. * Slave management functions (for bridge, bonding, etc).
  1050. * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
  1051. * Called to make another netdev an underling.
  1052. *
  1053. * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
  1054. * Called to release previously enslaved netdev.
  1055. *
  1056. * struct net_device *(*ndo_get_xmit_slave)(struct net_device *dev,
  1057. * struct sk_buff *skb,
  1058. * bool all_slaves);
  1059. * Get the xmit slave of master device. If all_slaves is true, function
  1060. * assume all the slaves can transmit.
  1061. *
  1062. * Feature/offload setting functions.
  1063. * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
  1064. * netdev_features_t features);
  1065. * Adjusts the requested feature flags according to device-specific
  1066. * constraints, and returns the resulting flags. Must not modify
  1067. * the device state.
  1068. *
  1069. * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
  1070. * Called to update device configuration to new features. Passed
  1071. * feature set might be less than what was returned by ndo_fix_features()).
  1072. * Must return >0 or -errno if it changed dev->features itself.
  1073. *
  1074. * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
  1075. * struct net_device *dev,
  1076. * const unsigned char *addr, u16 vid, u16 flags,
  1077. * struct netlink_ext_ack *extack);
  1078. * Adds an FDB entry to dev for addr.
  1079. * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
  1080. * struct net_device *dev,
  1081. * const unsigned char *addr, u16 vid)
  1082. * Deletes the FDB entry from dev coresponding to addr.
  1083. * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
  1084. * struct net_device *dev, struct net_device *filter_dev,
  1085. * int *idx)
  1086. * Used to add FDB entries to dump requests. Implementers should add
  1087. * entries to skb and update idx with the number of entries.
  1088. *
  1089. * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh,
  1090. * u16 flags, struct netlink_ext_ack *extack)
  1091. * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
  1092. * struct net_device *dev, u32 filter_mask,
  1093. * int nlflags)
  1094. * int (*ndo_bridge_dellink)(struct net_device *dev, struct nlmsghdr *nlh,
  1095. * u16 flags);
  1096. *
  1097. * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
  1098. * Called to change device carrier. Soft-devices (like dummy, team, etc)
  1099. * which do not represent real hardware may define this to allow their
  1100. * userspace components to manage their virtual carrier state. Devices
  1101. * that determine carrier state from physical hardware properties (eg
  1102. * network cables) or protocol-dependent mechanisms (eg
  1103. * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
  1104. *
  1105. * int (*ndo_get_phys_port_id)(struct net_device *dev,
  1106. * struct netdev_phys_item_id *ppid);
  1107. * Called to get ID of physical port of this device. If driver does
  1108. * not implement this, it is assumed that the hw is not able to have
  1109. * multiple net devices on single physical port.
  1110. *
  1111. * int (*ndo_get_port_parent_id)(struct net_device *dev,
  1112. * struct netdev_phys_item_id *ppid)
  1113. * Called to get the parent ID of the physical port of this device.
  1114. *
  1115. * void (*ndo_udp_tunnel_add)(struct net_device *dev,
  1116. * struct udp_tunnel_info *ti);
  1117. * Called by UDP tunnel to notify a driver about the UDP port and socket
  1118. * address family that a UDP tunnel is listnening to. It is called only
  1119. * when a new port starts listening. The operation is protected by the
  1120. * RTNL.
  1121. *
  1122. * void (*ndo_udp_tunnel_del)(struct net_device *dev,
  1123. * struct udp_tunnel_info *ti);
  1124. * Called by UDP tunnel to notify the driver about a UDP port and socket
  1125. * address family that the UDP tunnel is not listening to anymore. The
  1126. * operation is protected by the RTNL.
  1127. *
  1128. * void* (*ndo_dfwd_add_station)(struct net_device *pdev,
  1129. * struct net_device *dev)
  1130. * Called by upper layer devices to accelerate switching or other
  1131. * station functionality into hardware. 'pdev is the lowerdev
  1132. * to use for the offload and 'dev' is the net device that will
  1133. * back the offload. Returns a pointer to the private structure
  1134. * the upper layer will maintain.
  1135. * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
  1136. * Called by upper layer device to delete the station created
  1137. * by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
  1138. * the station and priv is the structure returned by the add
  1139. * operation.
  1140. * int (*ndo_set_tx_maxrate)(struct net_device *dev,
  1141. * int queue_index, u32 maxrate);
  1142. * Called when a user wants to set a max-rate limitation of specific
  1143. * TX queue.
  1144. * int (*ndo_get_iflink)(const struct net_device *dev);
  1145. * Called to get the iflink value of this device.
  1146. * void (*ndo_change_proto_down)(struct net_device *dev,
  1147. * bool proto_down);
  1148. * This function is used to pass protocol port error state information
  1149. * to the switch driver. The switch driver can react to the proto_down
  1150. * by doing a phys down on the associated switch port.
  1151. * int (*ndo_fill_metadata_dst)(struct net_device *dev, struct sk_buff *skb);
  1152. * This function is used to get egress tunnel information for given skb.
  1153. * This is useful for retrieving outer tunnel header parameters while
  1154. * sampling packet.
  1155. * void (*ndo_set_rx_headroom)(struct net_device *dev, int needed_headroom);
  1156. * This function is used to specify the headroom that the skb must
  1157. * consider when allocation skb during packet reception. Setting
  1158. * appropriate rx headroom value allows avoiding skb head copy on
  1159. * forward. Setting a negative value resets the rx headroom to the
  1160. * default value.
  1161. * int (*ndo_bpf)(struct net_device *dev, struct netdev_bpf *bpf);
  1162. * This function is used to set or query state related to XDP on the
  1163. * netdevice and manage BPF offload. See definition of
  1164. * enum bpf_netdev_command for details.
  1165. * int (*ndo_xdp_xmit)(struct net_device *dev, int n, struct xdp_frame **xdp,
  1166. * u32 flags);
  1167. * This function is used to submit @n XDP packets for transmit on a
  1168. * netdevice. Returns number of frames successfully transmitted, frames
  1169. * that got dropped are freed/returned via xdp_return_frame().
  1170. * Returns negative number, means general error invoking ndo, meaning
  1171. * no frames were xmit'ed and core-caller will free all frames.
  1172. * int (*ndo_xsk_wakeup)(struct net_device *dev, u32 queue_id, u32 flags);
  1173. * This function is used to wake up the softirq, ksoftirqd or kthread
  1174. * responsible for sending and/or receiving packets on a specific
  1175. * queue id bound to an AF_XDP socket. The flags field specifies if
  1176. * only RX, only Tx, or both should be woken up using the flags
  1177. * XDP_WAKEUP_RX and XDP_WAKEUP_TX.
  1178. * struct devlink_port *(*ndo_get_devlink_port)(struct net_device *dev);
  1179. * Get devlink port instance associated with a given netdev.
  1180. * Called with a reference on the netdevice and devlink locks only,
  1181. * rtnl_lock is not held.
  1182. * int (*ndo_tunnel_ctl)(struct net_device *dev, struct ip_tunnel_parm *p,
  1183. * int cmd);
  1184. * Add, change, delete or get information on an IPv4 tunnel.
  1185. * struct net_device *(*ndo_get_peer_dev)(struct net_device *dev);
  1186. * If a device is paired with a peer device, return the peer instance.
  1187. * The caller must be under RCU read context.
  1188. */
  1189. struct net_device_ops {
  1190. int (*ndo_init)(struct net_device *dev);
  1191. void (*ndo_uninit)(struct net_device *dev);
  1192. int (*ndo_open)(struct net_device *dev);
  1193. int (*ndo_stop)(struct net_device *dev);
  1194. netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  1195. struct net_device *dev);
  1196. netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
  1197. struct net_device *dev,
  1198. netdev_features_t features);
  1199. u16 (*ndo_select_queue)(struct net_device *dev,
  1200. struct sk_buff *skb,
  1201. struct net_device *sb_dev);
  1202. void (*ndo_change_rx_flags)(struct net_device *dev,
  1203. int flags);
  1204. void (*ndo_set_rx_mode)(struct net_device *dev);
  1205. int (*ndo_set_mac_address)(struct net_device *dev,
  1206. void *addr);
  1207. int (*ndo_validate_addr)(struct net_device *dev);
  1208. int (*ndo_do_ioctl)(struct net_device *dev,
  1209. struct ifreq *ifr, int cmd);
  1210. int (*ndo_set_config)(struct net_device *dev,
  1211. struct ifmap *map);
  1212. int (*ndo_change_mtu)(struct net_device *dev,
  1213. int new_mtu);
  1214. int (*ndo_neigh_setup)(struct net_device *dev,
  1215. struct neigh_parms *);
  1216. void (*ndo_tx_timeout) (struct net_device *dev,
  1217. unsigned int txqueue);
  1218. void (*ndo_get_stats64)(struct net_device *dev,
  1219. struct rtnl_link_stats64 *storage);
  1220. bool (*ndo_has_offload_stats)(const struct net_device *dev, int attr_id);
  1221. int (*ndo_get_offload_stats)(int attr_id,
  1222. const struct net_device *dev,
  1223. void *attr_data);
  1224. struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  1225. int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
  1226. __be16 proto, u16 vid);
  1227. int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
  1228. __be16 proto, u16 vid);
  1229. #ifdef CONFIG_NET_POLL_CONTROLLER
  1230. void (*ndo_poll_controller)(struct net_device *dev);
  1231. int (*ndo_netpoll_setup)(struct net_device *dev,
  1232. struct netpoll_info *info);
  1233. void (*ndo_netpoll_cleanup)(struct net_device *dev);
  1234. #endif
  1235. int (*ndo_set_vf_mac)(struct net_device *dev,
  1236. int queue, u8 *mac);
  1237. int (*ndo_set_vf_vlan)(struct net_device *dev,
  1238. int queue, u16 vlan,
  1239. u8 qos, __be16 proto);
  1240. int (*ndo_set_vf_rate)(struct net_device *dev,
  1241. int vf, int min_tx_rate,
  1242. int max_tx_rate);
  1243. int (*ndo_set_vf_spoofchk)(struct net_device *dev,
  1244. int vf, bool setting);
  1245. int (*ndo_set_vf_trust)(struct net_device *dev,
  1246. int vf, bool setting);
  1247. int (*ndo_get_vf_config)(struct net_device *dev,
  1248. int vf,
  1249. struct ifla_vf_info *ivf);
  1250. int (*ndo_set_vf_link_state)(struct net_device *dev,
  1251. int vf, int link_state);
  1252. int (*ndo_get_vf_stats)(struct net_device *dev,
  1253. int vf,
  1254. struct ifla_vf_stats
  1255. *vf_stats);
  1256. int (*ndo_set_vf_port)(struct net_device *dev,
  1257. int vf,
  1258. struct nlattr *port[]);
  1259. int (*ndo_get_vf_port)(struct net_device *dev,
  1260. int vf, struct sk_buff *skb);
  1261. int (*ndo_get_vf_guid)(struct net_device *dev,
  1262. int vf,
  1263. struct ifla_vf_guid *node_guid,
  1264. struct ifla_vf_guid *port_guid);
  1265. int (*ndo_set_vf_guid)(struct net_device *dev,
  1266. int vf, u64 guid,
  1267. int guid_type);
  1268. int (*ndo_set_vf_rss_query_en)(
  1269. struct net_device *dev,
  1270. int vf, bool setting);
  1271. int (*ndo_setup_tc)(struct net_device *dev,
  1272. enum tc_setup_type type,
  1273. void *type_data);
  1274. #if IS_ENABLED(CONFIG_FCOE)
  1275. int (*ndo_fcoe_enable)(struct net_device *dev);
  1276. int (*ndo_fcoe_disable)(struct net_device *dev);
  1277. int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
  1278. u16 xid,
  1279. struct scatterlist *sgl,
  1280. unsigned int sgc);
  1281. int (*ndo_fcoe_ddp_done)(struct net_device *dev,
  1282. u16 xid);
  1283. int (*ndo_fcoe_ddp_target)(struct net_device *dev,
  1284. u16 xid,
  1285. struct scatterlist *sgl,
  1286. unsigned int sgc);
  1287. int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
  1288. struct netdev_fcoe_hbainfo *hbainfo);
  1289. #endif
  1290. #if IS_ENABLED(CONFIG_LIBFCOE)
  1291. #define NETDEV_FCOE_WWNN 0
  1292. #define NETDEV_FCOE_WWPN 1
  1293. int (*ndo_fcoe_get_wwn)(struct net_device *dev,
  1294. u64 *wwn, int type);
  1295. #endif
  1296. #ifdef CONFIG_RFS_ACCEL
  1297. int (*ndo_rx_flow_steer)(struct net_device *dev,
  1298. const struct sk_buff *skb,
  1299. u16 rxq_index,
  1300. u32 flow_id);
  1301. #endif
  1302. int (*ndo_add_slave)(struct net_device *dev,
  1303. struct net_device *slave_dev,
  1304. struct netlink_ext_ack *extack);
  1305. int (*ndo_del_slave)(struct net_device *dev,
  1306. struct net_device *slave_dev);
  1307. struct net_device* (*ndo_get_xmit_slave)(struct net_device *dev,
  1308. struct sk_buff *skb,
  1309. bool all_slaves);
  1310. netdev_features_t (*ndo_fix_features)(struct net_device *dev,
  1311. netdev_features_t features);
  1312. int (*ndo_set_features)(struct net_device *dev,
  1313. netdev_features_t features);
  1314. int (*ndo_neigh_construct)(struct net_device *dev,
  1315. struct neighbour *n);
  1316. void (*ndo_neigh_destroy)(struct net_device *dev,
  1317. struct neighbour *n);
  1318. int (*ndo_fdb_add)(struct ndmsg *ndm,
  1319. struct nlattr *tb[],
  1320. struct net_device *dev,
  1321. const unsigned char *addr,
  1322. u16 vid,
  1323. u16 flags,
  1324. struct netlink_ext_ack *extack);
  1325. int (*ndo_fdb_del)(struct ndmsg *ndm,
  1326. struct nlattr *tb[],
  1327. struct net_device *dev,
  1328. const unsigned char *addr,
  1329. u16 vid);
  1330. int (*ndo_fdb_dump)(struct sk_buff *skb,
  1331. struct netlink_callback *cb,
  1332. struct net_device *dev,
  1333. struct net_device *filter_dev,
  1334. int *idx);
  1335. int (*ndo_fdb_get)(struct sk_buff *skb,
  1336. struct nlattr *tb[],
  1337. struct net_device *dev,
  1338. const unsigned char *addr,
  1339. u16 vid, u32 portid, u32 seq,
  1340. struct netlink_ext_ack *extack);
  1341. int (*ndo_bridge_setlink)(struct net_device *dev,
  1342. struct nlmsghdr *nlh,
  1343. u16 flags,
  1344. struct netlink_ext_ack *extack);
  1345. int (*ndo_bridge_getlink)(struct sk_buff *skb,
  1346. u32 pid, u32 seq,
  1347. struct net_device *dev,
  1348. u32 filter_mask,
  1349. int nlflags);
  1350. int (*ndo_bridge_dellink)(struct net_device *dev,
  1351. struct nlmsghdr *nlh,
  1352. u16 flags);
  1353. int (*ndo_change_carrier)(struct net_device *dev,
  1354. bool new_carrier);
  1355. int (*ndo_get_phys_port_id)(struct net_device *dev,
  1356. struct netdev_phys_item_id *ppid);
  1357. int (*ndo_get_port_parent_id)(struct net_device *dev,
  1358. struct netdev_phys_item_id *ppid);
  1359. int (*ndo_get_phys_port_name)(struct net_device *dev,
  1360. char *name, size_t len);
  1361. void (*ndo_udp_tunnel_add)(struct net_device *dev,
  1362. struct udp_tunnel_info *ti);
  1363. void (*ndo_udp_tunnel_del)(struct net_device *dev,
  1364. struct udp_tunnel_info *ti);
  1365. void* (*ndo_dfwd_add_station)(struct net_device *pdev,
  1366. struct net_device *dev);
  1367. void (*ndo_dfwd_del_station)(struct net_device *pdev,
  1368. void *priv);
  1369. int (*ndo_set_tx_maxrate)(struct net_device *dev,
  1370. int queue_index,
  1371. u32 maxrate);
  1372. int (*ndo_get_iflink)(const struct net_device *dev);
  1373. int (*ndo_change_proto_down)(struct net_device *dev,
  1374. bool proto_down);
  1375. int (*ndo_fill_metadata_dst)(struct net_device *dev,
  1376. struct sk_buff *skb);
  1377. void (*ndo_set_rx_headroom)(struct net_device *dev,
  1378. int needed_headroom);
  1379. int (*ndo_bpf)(struct net_device *dev,
  1380. struct netdev_bpf *bpf);
  1381. int (*ndo_xdp_xmit)(struct net_device *dev, int n,
  1382. struct xdp_frame **xdp,
  1383. u32 flags);
  1384. int (*ndo_xsk_wakeup)(struct net_device *dev,
  1385. u32 queue_id, u32 flags);
  1386. struct devlink_port * (*ndo_get_devlink_port)(struct net_device *dev);
  1387. int (*ndo_tunnel_ctl)(struct net_device *dev,
  1388. struct ip_tunnel_parm *p, int cmd);
  1389. struct net_device * (*ndo_get_peer_dev)(struct net_device *dev);
  1390. ANDROID_KABI_RESERVE(1);
  1391. ANDROID_KABI_RESERVE(2);
  1392. ANDROID_KABI_RESERVE(3);
  1393. ANDROID_KABI_RESERVE(4);
  1394. ANDROID_KABI_RESERVE(5);
  1395. ANDROID_KABI_RESERVE(6);
  1396. ANDROID_KABI_RESERVE(7);
  1397. ANDROID_KABI_RESERVE(8);
  1398. };
  1399. /**
  1400. * enum net_device_priv_flags - &struct net_device priv_flags
  1401. *
  1402. * These are the &struct net_device, they are only set internally
  1403. * by drivers and used in the kernel. These flags are invisible to
  1404. * userspace; this means that the order of these flags can change
  1405. * during any kernel release.
  1406. *
  1407. * You should have a pretty good reason to be extending these flags.
  1408. *
  1409. * @IFF_802_1Q_VLAN: 802.1Q VLAN device
  1410. * @IFF_EBRIDGE: Ethernet bridging device
  1411. * @IFF_BONDING: bonding master or slave
  1412. * @IFF_ISATAP: ISATAP interface (RFC4214)
  1413. * @IFF_WAN_HDLC: WAN HDLC device
  1414. * @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
  1415. * release skb->dst
  1416. * @IFF_DONT_BRIDGE: disallow bridging this ether dev
  1417. * @IFF_DISABLE_NETPOLL: disable netpoll at run-time
  1418. * @IFF_MACVLAN_PORT: device used as macvlan port
  1419. * @IFF_BRIDGE_PORT: device used as bridge port
  1420. * @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
  1421. * @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
  1422. * @IFF_UNICAST_FLT: Supports unicast filtering
  1423. * @IFF_TEAM_PORT: device used as team port
  1424. * @IFF_SUPP_NOFCS: device supports sending custom FCS
  1425. * @IFF_LIVE_ADDR_CHANGE: device supports hardware address
  1426. * change when it's running
  1427. * @IFF_MACVLAN: Macvlan device
  1428. * @IFF_XMIT_DST_RELEASE_PERM: IFF_XMIT_DST_RELEASE not taking into account
  1429. * underlying stacked devices
  1430. * @IFF_L3MDEV_MASTER: device is an L3 master device
  1431. * @IFF_NO_QUEUE: device can run without qdisc attached
  1432. * @IFF_OPENVSWITCH: device is a Open vSwitch master
  1433. * @IFF_L3MDEV_SLAVE: device is enslaved to an L3 master device
  1434. * @IFF_TEAM: device is a team device
  1435. * @IFF_RXFH_CONFIGURED: device has had Rx Flow indirection table configured
  1436. * @IFF_PHONY_HEADROOM: the headroom value is controlled by an external
  1437. * entity (i.e. the master device for bridged veth)
  1438. * @IFF_MACSEC: device is a MACsec device
  1439. * @IFF_NO_RX_HANDLER: device doesn't support the rx_handler hook
  1440. * @IFF_FAILOVER: device is a failover master device
  1441. * @IFF_FAILOVER_SLAVE: device is lower dev of a failover master device
  1442. * @IFF_L3MDEV_RX_HANDLER: only invoke the rx handler of L3 master device
  1443. * @IFF_LIVE_RENAME_OK: rename is allowed while device is up and running
  1444. */
  1445. enum netdev_priv_flags {
  1446. IFF_802_1Q_VLAN = 1<<0,
  1447. IFF_EBRIDGE = 1<<1,
  1448. IFF_BONDING = 1<<2,
  1449. IFF_ISATAP = 1<<3,
  1450. IFF_WAN_HDLC = 1<<4,
  1451. IFF_XMIT_DST_RELEASE = 1<<5,
  1452. IFF_DONT_BRIDGE = 1<<6,
  1453. IFF_DISABLE_NETPOLL = 1<<7,
  1454. IFF_MACVLAN_PORT = 1<<8,
  1455. IFF_BRIDGE_PORT = 1<<9,
  1456. IFF_OVS_DATAPATH = 1<<10,
  1457. IFF_TX_SKB_SHARING = 1<<11,
  1458. IFF_UNICAST_FLT = 1<<12,
  1459. IFF_TEAM_PORT = 1<<13,
  1460. IFF_SUPP_NOFCS = 1<<14,
  1461. IFF_LIVE_ADDR_CHANGE = 1<<15,
  1462. IFF_MACVLAN = 1<<16,
  1463. IFF_XMIT_DST_RELEASE_PERM = 1<<17,
  1464. IFF_L3MDEV_MASTER = 1<<18,
  1465. IFF_NO_QUEUE = 1<<19,
  1466. IFF_OPENVSWITCH = 1<<20,
  1467. IFF_L3MDEV_SLAVE = 1<<21,
  1468. IFF_TEAM = 1<<22,
  1469. IFF_RXFH_CONFIGURED = 1<<23,
  1470. IFF_PHONY_HEADROOM = 1<<24,
  1471. IFF_MACSEC = 1<<25,
  1472. IFF_NO_RX_HANDLER = 1<<26,
  1473. IFF_FAILOVER = 1<<27,
  1474. IFF_FAILOVER_SLAVE = 1<<28,
  1475. IFF_L3MDEV_RX_HANDLER = 1<<29,
  1476. IFF_LIVE_RENAME_OK = 1<<30,
  1477. };
  1478. #define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
  1479. #define IFF_EBRIDGE IFF_EBRIDGE
  1480. #define IFF_BONDING IFF_BONDING
  1481. #define IFF_ISATAP IFF_ISATAP
  1482. #define IFF_WAN_HDLC IFF_WAN_HDLC
  1483. #define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
  1484. #define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
  1485. #define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
  1486. #define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
  1487. #define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
  1488. #define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
  1489. #define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
  1490. #define IFF_UNICAST_FLT IFF_UNICAST_FLT
  1491. #define IFF_TEAM_PORT IFF_TEAM_PORT
  1492. #define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
  1493. #define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
  1494. #define IFF_MACVLAN IFF_MACVLAN
  1495. #define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
  1496. #define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
  1497. #define IFF_NO_QUEUE IFF_NO_QUEUE
  1498. #define IFF_OPENVSWITCH IFF_OPENVSWITCH
  1499. #define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
  1500. #define IFF_TEAM IFF_TEAM
  1501. #define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
  1502. #define IFF_MACSEC IFF_MACSEC
  1503. #define IFF_NO_RX_HANDLER IFF_NO_RX_HANDLER
  1504. #define IFF_FAILOVER IFF_FAILOVER
  1505. #define IFF_FAILOVER_SLAVE IFF_FAILOVER_SLAVE
  1506. #define IFF_L3MDEV_RX_HANDLER IFF_L3MDEV_RX_HANDLER
  1507. #define IFF_LIVE_RENAME_OK IFF_LIVE_RENAME_OK
  1508. /* Specifies the type of the struct net_device::ml_priv pointer */
  1509. enum netdev_ml_priv_type {
  1510. ML_PRIV_NONE,
  1511. ML_PRIV_CAN,
  1512. };
  1513. /**
  1514. * struct net_device - The DEVICE structure.
  1515. *
  1516. * Actually, this whole structure is a big mistake. It mixes I/O
  1517. * data with strictly "high-level" data, and it has to know about
  1518. * almost every data structure used in the INET module.
  1519. *
  1520. * @name: This is the first field of the "visible" part of this structure
  1521. * (i.e. as seen by users in the "Space.c" file). It is the name
  1522. * of the interface.
  1523. *
  1524. * @name_node: Name hashlist node
  1525. * @ifalias: SNMP alias
  1526. * @mem_end: Shared memory end
  1527. * @mem_start: Shared memory start
  1528. * @base_addr: Device I/O address
  1529. * @irq: Device IRQ number
  1530. *
  1531. * @state: Generic network queuing layer state, see netdev_state_t
  1532. * @dev_list: The global list of network devices
  1533. * @napi_list: List entry used for polling NAPI devices
  1534. * @unreg_list: List entry when we are unregistering the
  1535. * device; see the function unregister_netdev
  1536. * @close_list: List entry used when we are closing the device
  1537. * @ptype_all: Device-specific packet handlers for all protocols
  1538. * @ptype_specific: Device-specific, protocol-specific packet handlers
  1539. *
  1540. * @adj_list: Directly linked devices, like slaves for bonding
  1541. * @features: Currently active device features
  1542. * @hw_features: User-changeable features
  1543. *
  1544. * @wanted_features: User-requested features
  1545. * @vlan_features: Mask of features inheritable by VLAN devices
  1546. *
  1547. * @hw_enc_features: Mask of features inherited by encapsulating devices
  1548. * This field indicates what encapsulation
  1549. * offloads the hardware is capable of doing,
  1550. * and drivers will need to set them appropriately.
  1551. *
  1552. * @mpls_features: Mask of features inheritable by MPLS
  1553. * @gso_partial_features: value(s) from NETIF_F_GSO\*
  1554. *
  1555. * @ifindex: interface index
  1556. * @group: The group the device belongs to
  1557. *
  1558. * @stats: Statistics struct, which was left as a legacy, use
  1559. * rtnl_link_stats64 instead
  1560. *
  1561. * @rx_dropped: Dropped packets by core network,
  1562. * do not use this in drivers
  1563. * @tx_dropped: Dropped packets by core network,
  1564. * do not use this in drivers
  1565. * @rx_nohandler: nohandler dropped packets by core network on
  1566. * inactive devices, do not use this in drivers
  1567. * @carrier_up_count: Number of times the carrier has been up
  1568. * @carrier_down_count: Number of times the carrier has been down
  1569. *
  1570. * @wireless_handlers: List of functions to handle Wireless Extensions,
  1571. * instead of ioctl,
  1572. * see <net/iw_handler.h> for details.
  1573. * @wireless_data: Instance data managed by the core of wireless extensions
  1574. *
  1575. * @netdev_ops: Includes several pointers to callbacks,
  1576. * if one wants to override the ndo_*() functions
  1577. * @ethtool_ops: Management operations
  1578. * @l3mdev_ops: Layer 3 master device operations
  1579. * @ndisc_ops: Includes callbacks for different IPv6 neighbour
  1580. * discovery handling. Necessary for e.g. 6LoWPAN.
  1581. * @xfrmdev_ops: Transformation offload operations
  1582. * @tlsdev_ops: Transport Layer Security offload operations
  1583. * @header_ops: Includes callbacks for creating,parsing,caching,etc
  1584. * of Layer 2 headers.
  1585. *
  1586. * @flags: Interface flags (a la BSD)
  1587. * @priv_flags: Like 'flags' but invisible to userspace,
  1588. * see if.h for the definitions
  1589. * @gflags: Global flags ( kept as legacy )
  1590. * @padded: How much padding added by alloc_netdev()
  1591. * @operstate: RFC2863 operstate
  1592. * @link_mode: Mapping policy to operstate
  1593. * @if_port: Selectable AUI, TP, ...
  1594. * @dma: DMA channel
  1595. * @mtu: Interface MTU value
  1596. * @min_mtu: Interface Minimum MTU value
  1597. * @max_mtu: Interface Maximum MTU value
  1598. * @type: Interface hardware type
  1599. * @hard_header_len: Maximum hardware header length.
  1600. * @min_header_len: Minimum hardware header length
  1601. *
  1602. * @needed_headroom: Extra headroom the hardware may need, but not in all
  1603. * cases can this be guaranteed
  1604. * @needed_tailroom: Extra tailroom the hardware may need, but not in all
  1605. * cases can this be guaranteed. Some cases also use
  1606. * LL_MAX_HEADER instead to allocate the skb
  1607. *
  1608. * interface address info:
  1609. *
  1610. * @perm_addr: Permanent hw address
  1611. * @addr_assign_type: Hw address assignment type
  1612. * @addr_len: Hardware address length
  1613. * @upper_level: Maximum depth level of upper devices.
  1614. * @lower_level: Maximum depth level of lower devices.
  1615. * @neigh_priv_len: Used in neigh_alloc()
  1616. * @dev_id: Used to differentiate devices that share
  1617. * the same link layer address
  1618. * @dev_port: Used to differentiate devices that share
  1619. * the same function
  1620. * @addr_list_lock: XXX: need comments on this one
  1621. * @name_assign_type: network interface name assignment type
  1622. * @uc_promisc: Counter that indicates promiscuous mode
  1623. * has been enabled due to the need to listen to
  1624. * additional unicast addresses in a device that
  1625. * does not implement ndo_set_rx_mode()
  1626. * @uc: unicast mac addresses
  1627. * @mc: multicast mac addresses
  1628. * @dev_addrs: list of device hw addresses
  1629. * @queues_kset: Group of all Kobjects in the Tx and RX queues
  1630. * @promiscuity: Number of times the NIC is told to work in
  1631. * promiscuous mode; if it becomes 0 the NIC will
  1632. * exit promiscuous mode
  1633. * @allmulti: Counter, enables or disables allmulticast mode
  1634. *
  1635. * @vlan_info: VLAN info
  1636. * @dsa_ptr: dsa specific data
  1637. * @tipc_ptr: TIPC specific data
  1638. * @atalk_ptr: AppleTalk link
  1639. * @ip_ptr: IPv4 specific data
  1640. * @dn_ptr: DECnet specific data
  1641. * @ip6_ptr: IPv6 specific data
  1642. * @ax25_ptr: AX.25 specific data
  1643. * @ieee80211_ptr: IEEE 802.11 specific data, assign before registering
  1644. * @ieee802154_ptr: IEEE 802.15.4 low-rate Wireless Personal Area Network
  1645. * device struct
  1646. * @mpls_ptr: mpls_dev struct pointer
  1647. *
  1648. * @dev_addr: Hw address (before bcast,
  1649. * because most packets are unicast)
  1650. *
  1651. * @_rx: Array of RX queues
  1652. * @num_rx_queues: Number of RX queues
  1653. * allocated at register_netdev() time
  1654. * @real_num_rx_queues: Number of RX queues currently active in device
  1655. * @xdp_prog: XDP sockets filter program pointer
  1656. * @gro_flush_timeout: timeout for GRO layer in NAPI
  1657. * @napi_defer_hard_irqs: If not zero, provides a counter that would
  1658. * allow to avoid NIC hard IRQ, on busy queues.
  1659. *
  1660. * @rx_handler: handler for received packets
  1661. * @rx_handler_data: XXX: need comments on this one
  1662. * @miniq_ingress: ingress/clsact qdisc specific data for
  1663. * ingress processing
  1664. * @ingress_queue: XXX: need comments on this one
  1665. * @nf_hooks_ingress: netfilter hooks executed for ingress packets
  1666. * @broadcast: hw bcast address
  1667. *
  1668. * @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,
  1669. * indexed by RX queue number. Assigned by driver.
  1670. * This must only be set if the ndo_rx_flow_steer
  1671. * operation is defined
  1672. * @index_hlist: Device index hash chain
  1673. *
  1674. * @_tx: Array of TX queues
  1675. * @num_tx_queues: Number of TX queues allocated at alloc_netdev_mq() time
  1676. * @real_num_tx_queues: Number of TX queues currently active in device
  1677. * @qdisc: Root qdisc from userspace point of view
  1678. * @tx_queue_len: Max frames per queue allowed
  1679. * @tx_global_lock: XXX: need comments on this one
  1680. * @xdp_bulkq: XDP device bulk queue
  1681. * @xps_cpus_map: all CPUs map for XPS device
  1682. * @xps_rxqs_map: all RXQs map for XPS device
  1683. *
  1684. * @xps_maps: XXX: need comments on this one
  1685. * @miniq_egress: clsact qdisc specific data for
  1686. * egress processing
  1687. * @qdisc_hash: qdisc hash table
  1688. * @watchdog_timeo: Represents the timeout that is used by
  1689. * the watchdog (see dev_watchdog())
  1690. * @watchdog_timer: List of timers
  1691. *
  1692. * @proto_down_reason: reason a netdev interface is held down
  1693. * @pcpu_refcnt: Number of references to this device
  1694. * @todo_list: Delayed register/unregister
  1695. * @link_watch_list: XXX: need comments on this one
  1696. *
  1697. * @reg_state: Register/unregister state machine
  1698. * @dismantle: Device is going to be freed
  1699. * @rtnl_link_state: This enum represents the phases of creating
  1700. * a new link
  1701. *
  1702. * @needs_free_netdev: Should unregister perform free_netdev?
  1703. * @priv_destructor: Called from unregister
  1704. * @npinfo: XXX: need comments on this one
  1705. * @nd_net: Network namespace this network device is inside
  1706. *
  1707. * @ml_priv: Mid-layer private
  1708. * @ml_priv_type: Mid-layer private type
  1709. * @lstats: Loopback statistics
  1710. * @tstats: Tunnel statistics
  1711. * @dstats: Dummy statistics
  1712. * @vstats: Virtual ethernet statistics
  1713. *
  1714. * @garp_port: GARP
  1715. * @mrp_port: MRP
  1716. *
  1717. * @dev: Class/net/name entry
  1718. * @sysfs_groups: Space for optional device, statistics and wireless
  1719. * sysfs groups
  1720. *
  1721. * @sysfs_rx_queue_group: Space for optional per-rx queue attributes
  1722. * @rtnl_link_ops: Rtnl_link_ops
  1723. *
  1724. * @gso_max_size: Maximum size of generic segmentation offload
  1725. * @gso_max_segs: Maximum number of segments that can be passed to the
  1726. * NIC for GSO
  1727. *
  1728. * @dcbnl_ops: Data Center Bridging netlink ops
  1729. * @num_tc: Number of traffic classes in the net device
  1730. * @tc_to_txq: XXX: need comments on this one
  1731. * @prio_tc_map: XXX: need comments on this one
  1732. *
  1733. * @fcoe_ddp_xid: Max exchange id for FCoE LRO by ddp
  1734. *
  1735. * @priomap: XXX: need comments on this one
  1736. * @phydev: Physical device may attach itself
  1737. * for hardware timestamping
  1738. * @sfp_bus: attached &struct sfp_bus structure.
  1739. *
  1740. * @qdisc_tx_busylock: lockdep class annotating Qdisc->busylock spinlock
  1741. * @qdisc_running_key: lockdep class annotating Qdisc->running seqcount
  1742. *
  1743. * @proto_down: protocol port state information can be sent to the
  1744. * switch driver and used to set the phys state of the
  1745. * switch port.
  1746. *
  1747. * @wol_enabled: Wake-on-LAN is enabled
  1748. *
  1749. * @net_notifier_list: List of per-net netdev notifier block
  1750. * that follow this device when it is moved
  1751. * to another network namespace.
  1752. *
  1753. * @macsec_ops: MACsec offloading ops
  1754. *
  1755. * @udp_tunnel_nic_info: static structure describing the UDP tunnel
  1756. * offload capabilities of the device
  1757. * @udp_tunnel_nic: UDP tunnel offload state
  1758. * @xdp_state: stores info on attached XDP BPF programs
  1759. *
  1760. * @nested_level: Used as as a parameter of spin_lock_nested() of
  1761. * dev->addr_list_lock.
  1762. * @unlink_list: As netif_addr_lock() can be called recursively,
  1763. * keep a list of interfaces to be deleted.
  1764. *
  1765. * FIXME: cleanup struct net_device such that network protocol info
  1766. * moves out.
  1767. */
  1768. struct net_device {
  1769. char name[IFNAMSIZ];
  1770. struct netdev_name_node *name_node;
  1771. struct dev_ifalias __rcu *ifalias;
  1772. /*
  1773. * I/O specific fields
  1774. * FIXME: Merge these and struct ifmap into one
  1775. */
  1776. unsigned long mem_end;
  1777. unsigned long mem_start;
  1778. unsigned long base_addr;
  1779. int irq;
  1780. /*
  1781. * Some hardware also needs these fields (state,dev_list,
  1782. * napi_list,unreg_list,close_list) but they are not
  1783. * part of the usual set specified in Space.c.
  1784. */
  1785. unsigned long state;
  1786. struct list_head dev_list;
  1787. struct list_head napi_list;
  1788. struct list_head unreg_list;
  1789. struct list_head close_list;
  1790. struct list_head ptype_all;
  1791. struct list_head ptype_specific;
  1792. struct {
  1793. struct list_head upper;
  1794. struct list_head lower;
  1795. } adj_list;
  1796. netdev_features_t features;
  1797. netdev_features_t hw_features;
  1798. netdev_features_t wanted_features;
  1799. netdev_features_t vlan_features;
  1800. netdev_features_t hw_enc_features;
  1801. netdev_features_t mpls_features;
  1802. netdev_features_t gso_partial_features;
  1803. int ifindex;
  1804. int group;
  1805. struct net_device_stats stats;
  1806. atomic_long_t rx_dropped;
  1807. atomic_long_t tx_dropped;
  1808. atomic_long_t rx_nohandler;
  1809. /* Stats to monitor link on/off, flapping */
  1810. atomic_t carrier_up_count;
  1811. atomic_t carrier_down_count;
  1812. #ifdef CONFIG_WIRELESS_EXT
  1813. const struct iw_handler_def *wireless_handlers;
  1814. struct iw_public_data *wireless_data;
  1815. #endif
  1816. const struct net_device_ops *netdev_ops;
  1817. const struct ethtool_ops *ethtool_ops;
  1818. #ifdef CONFIG_NET_L3_MASTER_DEV
  1819. const struct l3mdev_ops *l3mdev_ops;
  1820. #endif
  1821. #if IS_ENABLED(CONFIG_IPV6)
  1822. const struct ndisc_ops *ndisc_ops;
  1823. #endif
  1824. #ifdef CONFIG_XFRM_OFFLOAD
  1825. const struct xfrmdev_ops *xfrmdev_ops;
  1826. #endif
  1827. #if IS_ENABLED(CONFIG_TLS_DEVICE)
  1828. const struct tlsdev_ops *tlsdev_ops;
  1829. #endif
  1830. const struct header_ops *header_ops;
  1831. unsigned int flags;
  1832. unsigned int priv_flags;
  1833. unsigned short gflags;
  1834. unsigned short padded;
  1835. unsigned char operstate;
  1836. unsigned char link_mode;
  1837. unsigned char if_port;
  1838. unsigned char dma;
  1839. /* Note : dev->mtu is often read without holding a lock.
  1840. * Writers usually hold RTNL.
  1841. * It is recommended to use READ_ONCE() to annotate the reads,
  1842. * and to use WRITE_ONCE() to annotate the writes.
  1843. */
  1844. unsigned int mtu;
  1845. unsigned int min_mtu;
  1846. unsigned int max_mtu;
  1847. unsigned short type;
  1848. unsigned short hard_header_len;
  1849. unsigned char min_header_len;
  1850. unsigned char name_assign_type;
  1851. unsigned short needed_headroom;
  1852. unsigned short needed_tailroom;
  1853. /* Interface address info. */
  1854. unsigned char perm_addr[MAX_ADDR_LEN];
  1855. unsigned char addr_assign_type;
  1856. unsigned char addr_len;
  1857. unsigned char upper_level;
  1858. unsigned char lower_level;
  1859. unsigned short neigh_priv_len;
  1860. unsigned short dev_id;
  1861. unsigned short dev_port;
  1862. spinlock_t addr_list_lock;
  1863. struct netdev_hw_addr_list uc;
  1864. struct netdev_hw_addr_list mc;
  1865. struct netdev_hw_addr_list dev_addrs;
  1866. #ifdef CONFIG_SYSFS
  1867. struct kset *queues_kset;
  1868. #endif
  1869. #ifdef CONFIG_LOCKDEP
  1870. struct list_head unlink_list;
  1871. #endif
  1872. unsigned int promiscuity;
  1873. unsigned int allmulti;
  1874. bool uc_promisc;
  1875. #ifdef CONFIG_LOCKDEP
  1876. unsigned char nested_level;
  1877. #endif
  1878. /* Protocol-specific pointers */
  1879. #if IS_ENABLED(CONFIG_VLAN_8021Q)
  1880. struct vlan_info __rcu *vlan_info;
  1881. #endif
  1882. #if IS_ENABLED(CONFIG_NET_DSA)
  1883. struct dsa_port *dsa_ptr;
  1884. #endif
  1885. #if IS_ENABLED(CONFIG_TIPC)
  1886. struct tipc_bearer __rcu *tipc_ptr;
  1887. #endif
  1888. #if IS_ENABLED(CONFIG_IRDA) || IS_ENABLED(CONFIG_ATALK)
  1889. void *atalk_ptr;
  1890. #endif
  1891. struct in_device __rcu *ip_ptr;
  1892. #if IS_ENABLED(CONFIG_DECNET)
  1893. struct dn_dev __rcu *dn_ptr;
  1894. #endif
  1895. struct inet6_dev __rcu *ip6_ptr;
  1896. #if IS_ENABLED(CONFIG_AX25)
  1897. void *ax25_ptr;
  1898. #endif
  1899. struct wireless_dev *ieee80211_ptr;
  1900. struct wpan_dev *ieee802154_ptr;
  1901. #if IS_ENABLED(CONFIG_MPLS_ROUTING)
  1902. struct mpls_dev __rcu *mpls_ptr;
  1903. #endif
  1904. /*
  1905. * Cache lines mostly used on receive path (including eth_type_trans())
  1906. */
  1907. /* Interface address info used in eth_type_trans() */
  1908. unsigned char *dev_addr;
  1909. struct netdev_rx_queue *_rx;
  1910. unsigned int num_rx_queues;
  1911. unsigned int real_num_rx_queues;
  1912. struct bpf_prog __rcu *xdp_prog;
  1913. unsigned long gro_flush_timeout;
  1914. int napi_defer_hard_irqs;
  1915. rx_handler_func_t __rcu *rx_handler;
  1916. void __rcu *rx_handler_data;
  1917. #ifdef CONFIG_NET_CLS_ACT
  1918. struct mini_Qdisc __rcu *miniq_ingress;
  1919. #endif
  1920. struct netdev_queue __rcu *ingress_queue;
  1921. #ifdef CONFIG_NETFILTER_INGRESS
  1922. struct nf_hook_entries __rcu *nf_hooks_ingress;
  1923. #endif
  1924. unsigned char broadcast[MAX_ADDR_LEN];
  1925. #ifdef CONFIG_RFS_ACCEL
  1926. struct cpu_rmap *rx_cpu_rmap;
  1927. #endif
  1928. struct hlist_node index_hlist;
  1929. /*
  1930. * Cache lines mostly used on transmit path
  1931. */
  1932. struct netdev_queue *_tx ____cacheline_aligned_in_smp;
  1933. unsigned int num_tx_queues;
  1934. unsigned int real_num_tx_queues;
  1935. struct Qdisc __rcu *qdisc;
  1936. unsigned int tx_queue_len;
  1937. spinlock_t tx_global_lock;
  1938. struct xdp_dev_bulk_queue __percpu *xdp_bulkq;
  1939. #ifdef CONFIG_XPS
  1940. struct xps_dev_maps __rcu *xps_cpus_map;
  1941. struct xps_dev_maps __rcu *xps_rxqs_map;
  1942. #endif
  1943. #ifdef CONFIG_NET_CLS_ACT
  1944. struct mini_Qdisc __rcu *miniq_egress;
  1945. #endif
  1946. #ifdef CONFIG_NET_SCHED
  1947. DECLARE_HASHTABLE (qdisc_hash, 4);
  1948. #endif
  1949. /* These may be needed for future network-power-down code. */
  1950. struct timer_list watchdog_timer;
  1951. int watchdog_timeo;
  1952. u32 proto_down_reason;
  1953. struct list_head todo_list;
  1954. int __percpu *pcpu_refcnt;
  1955. struct list_head link_watch_list;
  1956. enum { NETREG_UNINITIALIZED=0,
  1957. NETREG_REGISTERED, /* completed register_netdevice */
  1958. NETREG_UNREGISTERING, /* called unregister_netdevice */
  1959. NETREG_UNREGISTERED, /* completed unregister todo */
  1960. NETREG_RELEASED, /* called free_netdev */
  1961. NETREG_DUMMY, /* dummy device for NAPI poll */
  1962. } reg_state:8;
  1963. bool dismantle;
  1964. enum {
  1965. RTNL_LINK_INITIALIZED,
  1966. RTNL_LINK_INITIALIZING,
  1967. } rtnl_link_state:16;
  1968. bool needs_free_netdev;
  1969. void (*priv_destructor)(struct net_device *dev);
  1970. #ifdef CONFIG_NETPOLL
  1971. struct netpoll_info __rcu *npinfo;
  1972. #endif
  1973. possible_net_t nd_net;
  1974. /* mid-layer private */
  1975. void *ml_priv;
  1976. enum netdev_ml_priv_type ml_priv_type;
  1977. union {
  1978. struct pcpu_lstats __percpu *lstats;
  1979. struct pcpu_sw_netstats __percpu *tstats;
  1980. struct pcpu_dstats __percpu *dstats;
  1981. };
  1982. #if IS_ENABLED(CONFIG_GARP)
  1983. struct garp_port __rcu *garp_port;
  1984. #endif
  1985. #if IS_ENABLED(CONFIG_MRP)
  1986. struct mrp_port __rcu *mrp_port;
  1987. #endif
  1988. struct device dev;
  1989. const struct attribute_group *sysfs_groups[4];
  1990. const struct attribute_group *sysfs_rx_queue_group;
  1991. const struct rtnl_link_ops *rtnl_link_ops;
  1992. /* for setting kernel sock attribute on TCP connection setup */
  1993. #define GSO_MAX_SIZE 65536
  1994. unsigned int gso_max_size;
  1995. #define GSO_MAX_SEGS 65535
  1996. u16 gso_max_segs;
  1997. #ifdef CONFIG_DCB
  1998. const struct dcbnl_rtnl_ops *dcbnl_ops;
  1999. #endif
  2000. s16 num_tc;
  2001. struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
  2002. u8 prio_tc_map[TC_BITMASK + 1];
  2003. #if IS_ENABLED(CONFIG_FCOE)
  2004. unsigned int fcoe_ddp_xid;
  2005. #endif
  2006. #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
  2007. struct netprio_map __rcu *priomap;
  2008. #endif
  2009. struct phy_device *phydev;
  2010. struct sfp_bus *sfp_bus;
  2011. struct lock_class_key *qdisc_tx_busylock;
  2012. struct lock_class_key *qdisc_running_key;
  2013. bool proto_down;
  2014. unsigned wol_enabled:1;
  2015. struct list_head net_notifier_list;
  2016. #if IS_ENABLED(CONFIG_MACSEC)
  2017. /* MACsec management functions */
  2018. const struct macsec_ops *macsec_ops;
  2019. #endif
  2020. const struct udp_tunnel_nic_info *udp_tunnel_nic_info;
  2021. struct udp_tunnel_nic *udp_tunnel_nic;
  2022. /* protected by rtnl_lock */
  2023. struct bpf_xdp_entity xdp_state[__MAX_XDP_MODE];
  2024. ANDROID_KABI_RESERVE(1);
  2025. ANDROID_KABI_RESERVE(2);
  2026. ANDROID_KABI_RESERVE(3);
  2027. ANDROID_KABI_RESERVE(4);
  2028. ANDROID_KABI_RESERVE(5);
  2029. ANDROID_KABI_RESERVE(6);
  2030. ANDROID_KABI_RESERVE(7);
  2031. ANDROID_KABI_RESERVE(8);
  2032. };
  2033. #define to_net_dev(d) container_of(d, struct net_device, dev)
  2034. static inline bool netif_elide_gro(const struct net_device *dev)
  2035. {
  2036. if (!(dev->features & NETIF_F_GRO) || dev->xdp_prog)
  2037. return true;
  2038. return false;
  2039. }
  2040. #define NETDEV_ALIGN 32
  2041. static inline
  2042. int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
  2043. {
  2044. return dev->prio_tc_map[prio & TC_BITMASK];
  2045. }
  2046. static inline
  2047. int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
  2048. {
  2049. if (tc >= dev->num_tc)
  2050. return -EINVAL;
  2051. dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
  2052. return 0;
  2053. }
  2054. int netdev_txq_to_tc(struct net_device *dev, unsigned int txq);
  2055. void netdev_reset_tc(struct net_device *dev);
  2056. int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset);
  2057. int netdev_set_num_tc(struct net_device *dev, u8 num_tc);
  2058. static inline
  2059. int netdev_get_num_tc(struct net_device *dev)
  2060. {
  2061. return dev->num_tc;
  2062. }
  2063. static inline void net_prefetch(void *p)
  2064. {
  2065. prefetch(p);
  2066. #if L1_CACHE_BYTES < 128
  2067. prefetch((u8 *)p + L1_CACHE_BYTES);
  2068. #endif
  2069. }
  2070. static inline void net_prefetchw(void *p)
  2071. {
  2072. prefetchw(p);
  2073. #if L1_CACHE_BYTES < 128
  2074. prefetchw((u8 *)p + L1_CACHE_BYTES);
  2075. #endif
  2076. }
  2077. void netdev_unbind_sb_channel(struct net_device *dev,
  2078. struct net_device *sb_dev);
  2079. int netdev_bind_sb_channel_queue(struct net_device *dev,
  2080. struct net_device *sb_dev,
  2081. u8 tc, u16 count, u16 offset);
  2082. int netdev_set_sb_channel(struct net_device *dev, u16 channel);
  2083. static inline int netdev_get_sb_channel(struct net_device *dev)
  2084. {
  2085. return max_t(int, -dev->num_tc, 0);
  2086. }
  2087. static inline
  2088. struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
  2089. unsigned int index)
  2090. {
  2091. return &dev->_tx[index];
  2092. }
  2093. static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
  2094. const struct sk_buff *skb)
  2095. {
  2096. return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
  2097. }
  2098. static inline void netdev_for_each_tx_queue(struct net_device *dev,
  2099. void (*f)(struct net_device *,
  2100. struct netdev_queue *,
  2101. void *),
  2102. void *arg)
  2103. {
  2104. unsigned int i;
  2105. for (i = 0; i < dev->num_tx_queues; i++)
  2106. f(dev, &dev->_tx[i], arg);
  2107. }
  2108. #define netdev_lockdep_set_classes(dev) \
  2109. { \
  2110. static struct lock_class_key qdisc_tx_busylock_key; \
  2111. static struct lock_class_key qdisc_running_key; \
  2112. static struct lock_class_key qdisc_xmit_lock_key; \
  2113. static struct lock_class_key dev_addr_list_lock_key; \
  2114. unsigned int i; \
  2115. \
  2116. (dev)->qdisc_tx_busylock = &qdisc_tx_busylock_key; \
  2117. (dev)->qdisc_running_key = &qdisc_running_key; \
  2118. lockdep_set_class(&(dev)->addr_list_lock, \
  2119. &dev_addr_list_lock_key); \
  2120. for (i = 0; i < (dev)->num_tx_queues; i++) \
  2121. lockdep_set_class(&(dev)->_tx[i]._xmit_lock, \
  2122. &qdisc_xmit_lock_key); \
  2123. }
  2124. u16 netdev_pick_tx(struct net_device *dev, struct sk_buff *skb,
  2125. struct net_device *sb_dev);
  2126. struct netdev_queue *netdev_core_pick_tx(struct net_device *dev,
  2127. struct sk_buff *skb,
  2128. struct net_device *sb_dev);
  2129. /* returns the headroom that the master device needs to take in account
  2130. * when forwarding to this dev
  2131. */
  2132. static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
  2133. {
  2134. return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
  2135. }
  2136. static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
  2137. {
  2138. if (dev->netdev_ops->ndo_set_rx_headroom)
  2139. dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
  2140. }
  2141. /* set the device rx headroom to the dev's default */
  2142. static inline void netdev_reset_rx_headroom(struct net_device *dev)
  2143. {
  2144. netdev_set_rx_headroom(dev, -1);
  2145. }
  2146. static inline void *netdev_get_ml_priv(struct net_device *dev,
  2147. enum netdev_ml_priv_type type)
  2148. {
  2149. if (dev->ml_priv_type != type)
  2150. return NULL;
  2151. return dev->ml_priv;
  2152. }
  2153. static inline void netdev_set_ml_priv(struct net_device *dev,
  2154. void *ml_priv,
  2155. enum netdev_ml_priv_type type)
  2156. {
  2157. WARN(dev->ml_priv_type && dev->ml_priv_type != type,
  2158. "Overwriting already set ml_priv_type (%u) with different ml_priv_type (%u)!\n",
  2159. dev->ml_priv_type, type);
  2160. WARN(!dev->ml_priv_type && dev->ml_priv,
  2161. "Overwriting already set ml_priv and ml_priv_type is ML_PRIV_NONE!\n");
  2162. dev->ml_priv = ml_priv;
  2163. dev->ml_priv_type = type;
  2164. }
  2165. /*
  2166. * Net namespace inlines
  2167. */
  2168. static inline
  2169. struct net *dev_net(const struct net_device *dev)
  2170. {
  2171. return read_pnet(&dev->nd_net);
  2172. }
  2173. static inline
  2174. void dev_net_set(struct net_device *dev, struct net *net)
  2175. {
  2176. write_pnet(&dev->nd_net, net);
  2177. }
  2178. /**
  2179. * netdev_priv - access network device private data
  2180. * @dev: network device
  2181. *
  2182. * Get network device private data
  2183. */
  2184. static inline void *netdev_priv(const struct net_device *dev)
  2185. {
  2186. return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
  2187. }
  2188. /* Set the sysfs physical device reference for the network logical device
  2189. * if set prior to registration will cause a symlink during initialization.
  2190. */
  2191. #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
  2192. /* Set the sysfs device type for the network logical device to allow
  2193. * fine-grained identification of different network device types. For
  2194. * example Ethernet, Wireless LAN, Bluetooth, WiMAX etc.
  2195. */
  2196. #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
  2197. /* Default NAPI poll() weight
  2198. * Device drivers are strongly advised to not use bigger value
  2199. */
  2200. #define NAPI_POLL_WEIGHT 64
  2201. /**
  2202. * netif_napi_add - initialize a NAPI context
  2203. * @dev: network device
  2204. * @napi: NAPI context
  2205. * @poll: polling function
  2206. * @weight: default weight
  2207. *
  2208. * netif_napi_add() must be used to initialize a NAPI context prior to calling
  2209. * *any* of the other NAPI-related functions.
  2210. */
  2211. void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
  2212. int (*poll)(struct napi_struct *, int), int weight);
  2213. /**
  2214. * netif_tx_napi_add - initialize a NAPI context
  2215. * @dev: network device
  2216. * @napi: NAPI context
  2217. * @poll: polling function
  2218. * @weight: default weight
  2219. *
  2220. * This variant of netif_napi_add() should be used from drivers using NAPI
  2221. * to exclusively poll a TX queue.
  2222. * This will avoid we add it into napi_hash[], thus polluting this hash table.
  2223. */
  2224. static inline void netif_tx_napi_add(struct net_device *dev,
  2225. struct napi_struct *napi,
  2226. int (*poll)(struct napi_struct *, int),
  2227. int weight)
  2228. {
  2229. set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
  2230. netif_napi_add(dev, napi, poll, weight);
  2231. }
  2232. /**
  2233. * __netif_napi_del - remove a NAPI context
  2234. * @napi: NAPI context
  2235. *
  2236. * Warning: caller must observe RCU grace period before freeing memory
  2237. * containing @napi. Drivers might want to call this helper to combine
  2238. * all the needed RCU grace periods into a single one.
  2239. */
  2240. void __netif_napi_del(struct napi_struct *napi);
  2241. /**
  2242. * netif_napi_del - remove a NAPI context
  2243. * @napi: NAPI context
  2244. *
  2245. * netif_napi_del() removes a NAPI context from the network device NAPI list
  2246. */
  2247. static inline void netif_napi_del(struct napi_struct *napi)
  2248. {
  2249. __netif_napi_del(napi);
  2250. synchronize_net();
  2251. }
  2252. struct napi_gro_cb {
  2253. /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
  2254. void *frag0;
  2255. /* Length of frag0. */
  2256. unsigned int frag0_len;
  2257. /* This indicates where we are processing relative to skb->data. */
  2258. int data_offset;
  2259. /* This is non-zero if the packet cannot be merged with the new skb. */
  2260. u16 flush;
  2261. /* Save the IP ID here and check when we get to the transport layer */
  2262. u16 flush_id;
  2263. /* Number of segments aggregated. */
  2264. u16 count;
  2265. /* Start offset for remote checksum offload */
  2266. u16 gro_remcsum_start;
  2267. /* jiffies when first packet was created/queued */
  2268. unsigned long age;
  2269. /* Used in ipv6_gro_receive() and foo-over-udp */
  2270. u16 proto;
  2271. /* This is non-zero if the packet may be of the same flow. */
  2272. u8 same_flow:1;
  2273. /* Used in tunnel GRO receive */
  2274. u8 encap_mark:1;
  2275. /* GRO checksum is valid */
  2276. u8 csum_valid:1;
  2277. /* Number of checksums via CHECKSUM_UNNECESSARY */
  2278. u8 csum_cnt:3;
  2279. /* Free the skb? */
  2280. u8 free:2;
  2281. #define NAPI_GRO_FREE 1
  2282. #define NAPI_GRO_FREE_STOLEN_HEAD 2
  2283. /* Used in foo-over-udp, set in udp[46]_gro_receive */
  2284. u8 is_ipv6:1;
  2285. /* Used in GRE, set in fou/gue_gro_receive */
  2286. u8 is_fou:1;
  2287. /* Used to determine if flush_id can be ignored */
  2288. u8 is_atomic:1;
  2289. /* Number of gro_receive callbacks this packet already went through */
  2290. u8 recursion_counter:4;
  2291. /* GRO is done by frag_list pointer chaining. */
  2292. u8 is_flist:1;
  2293. /* used to support CHECKSUM_COMPLETE for tunneling protocols */
  2294. __wsum csum;
  2295. /* used in skb_gro_receive() slow path */
  2296. struct sk_buff *last;
  2297. };
  2298. #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
  2299. #define GRO_RECURSION_LIMIT 15
  2300. static inline int gro_recursion_inc_test(struct sk_buff *skb)
  2301. {
  2302. return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
  2303. }
  2304. typedef struct sk_buff *(*gro_receive_t)(struct list_head *, struct sk_buff *);
  2305. static inline struct sk_buff *call_gro_receive(gro_receive_t cb,
  2306. struct list_head *head,
  2307. struct sk_buff *skb)
  2308. {
  2309. if (unlikely(gro_recursion_inc_test(skb))) {
  2310. NAPI_GRO_CB(skb)->flush |= 1;
  2311. return NULL;
  2312. }
  2313. return cb(head, skb);
  2314. }
  2315. typedef struct sk_buff *(*gro_receive_sk_t)(struct sock *, struct list_head *,
  2316. struct sk_buff *);
  2317. static inline struct sk_buff *call_gro_receive_sk(gro_receive_sk_t cb,
  2318. struct sock *sk,
  2319. struct list_head *head,
  2320. struct sk_buff *skb)
  2321. {
  2322. if (unlikely(gro_recursion_inc_test(skb))) {
  2323. NAPI_GRO_CB(skb)->flush |= 1;
  2324. return NULL;
  2325. }
  2326. return cb(sk, head, skb);
  2327. }
  2328. struct packet_type {
  2329. __be16 type; /* This is really htons(ether_type). */
  2330. bool ignore_outgoing;
  2331. struct net_device *dev; /* NULL is wildcarded here */
  2332. int (*func) (struct sk_buff *,
  2333. struct net_device *,
  2334. struct packet_type *,
  2335. struct net_device *);
  2336. void (*list_func) (struct list_head *,
  2337. struct packet_type *,
  2338. struct net_device *);
  2339. bool (*id_match)(struct packet_type *ptype,
  2340. struct sock *sk);
  2341. struct net *af_packet_net;
  2342. void *af_packet_priv;
  2343. struct list_head list;
  2344. ANDROID_KABI_RESERVE(1);
  2345. ANDROID_KABI_RESERVE(2);
  2346. ANDROID_KABI_RESERVE(3);
  2347. ANDROID_KABI_RESERVE(4);
  2348. };
  2349. struct offload_callbacks {
  2350. struct sk_buff *(*gso_segment)(struct sk_buff *skb,
  2351. netdev_features_t features);
  2352. struct sk_buff *(*gro_receive)(struct list_head *head,
  2353. struct sk_buff *skb);
  2354. int (*gro_complete)(struct sk_buff *skb, int nhoff);
  2355. };
  2356. struct packet_offload {
  2357. __be16 type; /* This is really htons(ether_type). */
  2358. u16 priority;
  2359. struct offload_callbacks callbacks;
  2360. struct list_head list;
  2361. };
  2362. /* often modified stats are per-CPU, other are shared (netdev->stats) */
  2363. struct pcpu_sw_netstats {
  2364. u64 rx_packets;
  2365. u64 rx_bytes;
  2366. u64 tx_packets;
  2367. u64 tx_bytes;
  2368. struct u64_stats_sync syncp;
  2369. } __aligned(4 * sizeof(u64));
  2370. struct pcpu_lstats {
  2371. u64_stats_t packets;
  2372. u64_stats_t bytes;
  2373. struct u64_stats_sync syncp;
  2374. } __aligned(2 * sizeof(u64));
  2375. void dev_lstats_read(struct net_device *dev, u64 *packets, u64 *bytes);
  2376. static inline void dev_sw_netstats_rx_add(struct net_device *dev, unsigned int len)
  2377. {
  2378. struct pcpu_sw_netstats *tstats = this_cpu_ptr(dev->tstats);
  2379. u64_stats_update_begin(&tstats->syncp);
  2380. tstats->rx_bytes += len;
  2381. tstats->rx_packets++;
  2382. u64_stats_update_end(&tstats->syncp);
  2383. }
  2384. static inline void dev_lstats_add(struct net_device *dev, unsigned int len)
  2385. {
  2386. struct pcpu_lstats *lstats = this_cpu_ptr(dev->lstats);
  2387. u64_stats_update_begin(&lstats->syncp);
  2388. u64_stats_add(&lstats->bytes, len);
  2389. u64_stats_inc(&lstats->packets);
  2390. u64_stats_update_end(&lstats->syncp);
  2391. }
  2392. #define __netdev_alloc_pcpu_stats(type, gfp) \
  2393. ({ \
  2394. typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
  2395. if (pcpu_stats) { \
  2396. int __cpu; \
  2397. for_each_possible_cpu(__cpu) { \
  2398. typeof(type) *stat; \
  2399. stat = per_cpu_ptr(pcpu_stats, __cpu); \
  2400. u64_stats_init(&stat->syncp); \
  2401. } \
  2402. } \
  2403. pcpu_stats; \
  2404. })
  2405. #define netdev_alloc_pcpu_stats(type) \
  2406. __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
  2407. enum netdev_lag_tx_type {
  2408. NETDEV_LAG_TX_TYPE_UNKNOWN,
  2409. NETDEV_LAG_TX_TYPE_RANDOM,
  2410. NETDEV_LAG_TX_TYPE_BROADCAST,
  2411. NETDEV_LAG_TX_TYPE_ROUNDROBIN,
  2412. NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
  2413. NETDEV_LAG_TX_TYPE_HASH,
  2414. };
  2415. enum netdev_lag_hash {
  2416. NETDEV_LAG_HASH_NONE,
  2417. NETDEV_LAG_HASH_L2,
  2418. NETDEV_LAG_HASH_L34,
  2419. NETDEV_LAG_HASH_L23,
  2420. NETDEV_LAG_HASH_E23,
  2421. NETDEV_LAG_HASH_E34,
  2422. NETDEV_LAG_HASH_UNKNOWN,
  2423. };
  2424. struct netdev_lag_upper_info {
  2425. enum netdev_lag_tx_type tx_type;
  2426. enum netdev_lag_hash hash_type;
  2427. };
  2428. struct netdev_lag_lower_state_info {
  2429. u8 link_up : 1,
  2430. tx_enabled : 1;
  2431. };
  2432. #include <linux/notifier.h>
  2433. /* netdevice notifier chain. Please remember to update netdev_cmd_to_name()
  2434. * and the rtnetlink notification exclusion list in rtnetlink_event() when
  2435. * adding new types.
  2436. */
  2437. enum netdev_cmd {
  2438. NETDEV_UP = 1, /* For now you can't veto a device up/down */
  2439. NETDEV_DOWN,
  2440. NETDEV_REBOOT, /* Tell a protocol stack a network interface
  2441. detected a hardware crash and restarted
  2442. - we can use this eg to kick tcp sessions
  2443. once done */
  2444. NETDEV_CHANGE, /* Notify device state change */
  2445. NETDEV_REGISTER,
  2446. NETDEV_UNREGISTER,
  2447. NETDEV_CHANGEMTU, /* notify after mtu change happened */
  2448. NETDEV_CHANGEADDR, /* notify after the address change */
  2449. NETDEV_PRE_CHANGEADDR, /* notify before the address change */
  2450. NETDEV_GOING_DOWN,
  2451. NETDEV_CHANGENAME,
  2452. NETDEV_FEAT_CHANGE,
  2453. NETDEV_BONDING_FAILOVER,
  2454. NETDEV_PRE_UP,
  2455. NETDEV_PRE_TYPE_CHANGE,
  2456. NETDEV_POST_TYPE_CHANGE,
  2457. NETDEV_POST_INIT,
  2458. NETDEV_RELEASE,
  2459. NETDEV_NOTIFY_PEERS,
  2460. NETDEV_JOIN,
  2461. NETDEV_CHANGEUPPER,
  2462. NETDEV_RESEND_IGMP,
  2463. NETDEV_PRECHANGEMTU, /* notify before mtu change happened */
  2464. NETDEV_CHANGEINFODATA,
  2465. NETDEV_BONDING_INFO,
  2466. NETDEV_PRECHANGEUPPER,
  2467. NETDEV_CHANGELOWERSTATE,
  2468. NETDEV_UDP_TUNNEL_PUSH_INFO,
  2469. NETDEV_UDP_TUNNEL_DROP_INFO,
  2470. NETDEV_CHANGE_TX_QUEUE_LEN,
  2471. NETDEV_CVLAN_FILTER_PUSH_INFO,
  2472. NETDEV_CVLAN_FILTER_DROP_INFO,
  2473. NETDEV_SVLAN_FILTER_PUSH_INFO,
  2474. NETDEV_SVLAN_FILTER_DROP_INFO,
  2475. };
  2476. const char *netdev_cmd_to_name(enum netdev_cmd cmd);
  2477. int register_netdevice_notifier(struct notifier_block *nb);
  2478. int unregister_netdevice_notifier(struct notifier_block *nb);
  2479. int register_netdevice_notifier_net(struct net *net, struct notifier_block *nb);
  2480. int unregister_netdevice_notifier_net(struct net *net,
  2481. struct notifier_block *nb);
  2482. int register_netdevice_notifier_dev_net(struct net_device *dev,
  2483. struct notifier_block *nb,
  2484. struct netdev_net_notifier *nn);
  2485. int unregister_netdevice_notifier_dev_net(struct net_device *dev,
  2486. struct notifier_block *nb,
  2487. struct netdev_net_notifier *nn);
  2488. struct netdev_notifier_info {
  2489. struct net_device *dev;
  2490. struct netlink_ext_ack *extack;
  2491. };
  2492. struct netdev_notifier_info_ext {
  2493. struct netdev_notifier_info info; /* must be first */
  2494. union {
  2495. u32 mtu;
  2496. } ext;
  2497. };
  2498. struct netdev_notifier_change_info {
  2499. struct netdev_notifier_info info; /* must be first */
  2500. unsigned int flags_changed;
  2501. };
  2502. struct netdev_notifier_changeupper_info {
  2503. struct netdev_notifier_info info; /* must be first */
  2504. struct net_device *upper_dev; /* new upper dev */
  2505. bool master; /* is upper dev master */
  2506. bool linking; /* is the notification for link or unlink */
  2507. void *upper_info; /* upper dev info */
  2508. };
  2509. struct netdev_notifier_changelowerstate_info {
  2510. struct netdev_notifier_info info; /* must be first */
  2511. void *lower_state_info; /* is lower dev state */
  2512. };
  2513. struct netdev_notifier_pre_changeaddr_info {
  2514. struct netdev_notifier_info info; /* must be first */
  2515. const unsigned char *dev_addr;
  2516. };
  2517. static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
  2518. struct net_device *dev)
  2519. {
  2520. info->dev = dev;
  2521. info->extack = NULL;
  2522. }
  2523. static inline struct net_device *
  2524. netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
  2525. {
  2526. return info->dev;
  2527. }
  2528. static inline struct netlink_ext_ack *
  2529. netdev_notifier_info_to_extack(const struct netdev_notifier_info *info)
  2530. {
  2531. return info->extack;
  2532. }
  2533. int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
  2534. extern rwlock_t dev_base_lock; /* Device list lock */
  2535. #define for_each_netdev(net, d) \
  2536. list_for_each_entry(d, &(net)->dev_base_head, dev_list)
  2537. #define for_each_netdev_reverse(net, d) \
  2538. list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
  2539. #define for_each_netdev_rcu(net, d) \
  2540. list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
  2541. #define for_each_netdev_safe(net, d, n) \
  2542. list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
  2543. #define for_each_netdev_continue(net, d) \
  2544. list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
  2545. #define for_each_netdev_continue_reverse(net, d) \
  2546. list_for_each_entry_continue_reverse(d, &(net)->dev_base_head, \
  2547. dev_list)
  2548. #define for_each_netdev_continue_rcu(net, d) \
  2549. list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
  2550. #define for_each_netdev_in_bond_rcu(bond, slave) \
  2551. for_each_netdev_rcu(&init_net, slave) \
  2552. if (netdev_master_upper_dev_get_rcu(slave) == (bond))
  2553. #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
  2554. static inline struct net_device *next_net_device(struct net_device *dev)
  2555. {
  2556. struct list_head *lh;
  2557. struct net *net;
  2558. net = dev_net(dev);
  2559. lh = dev->dev_list.next;
  2560. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2561. }
  2562. static inline struct net_device *next_net_device_rcu(struct net_device *dev)
  2563. {
  2564. struct list_head *lh;
  2565. struct net *net;
  2566. net = dev_net(dev);
  2567. lh = rcu_dereference(list_next_rcu(&dev->dev_list));
  2568. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2569. }
  2570. static inline struct net_device *first_net_device(struct net *net)
  2571. {
  2572. return list_empty(&net->dev_base_head) ? NULL :
  2573. net_device_entry(net->dev_base_head.next);
  2574. }
  2575. static inline struct net_device *first_net_device_rcu(struct net *net)
  2576. {
  2577. struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
  2578. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2579. }
  2580. int netdev_boot_setup_check(struct net_device *dev);
  2581. unsigned long netdev_boot_base(const char *prefix, int unit);
  2582. struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
  2583. const char *hwaddr);
  2584. struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
  2585. struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
  2586. void dev_add_pack(struct packet_type *pt);
  2587. void dev_remove_pack(struct packet_type *pt);
  2588. void __dev_remove_pack(struct packet_type *pt);
  2589. void dev_add_offload(struct packet_offload *po);
  2590. void dev_remove_offload(struct packet_offload *po);
  2591. int dev_get_iflink(const struct net_device *dev);
  2592. int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
  2593. struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
  2594. unsigned short mask);
  2595. struct net_device *dev_get_by_name(struct net *net, const char *name);
  2596. struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
  2597. struct net_device *__dev_get_by_name(struct net *net, const char *name);
  2598. int dev_alloc_name(struct net_device *dev, const char *name);
  2599. int dev_open(struct net_device *dev, struct netlink_ext_ack *extack);
  2600. void dev_close(struct net_device *dev);
  2601. void dev_close_many(struct list_head *head, bool unlink);
  2602. void dev_disable_lro(struct net_device *dev);
  2603. int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
  2604. u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
  2605. struct net_device *sb_dev);
  2606. u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
  2607. struct net_device *sb_dev);
  2608. int dev_queue_xmit(struct sk_buff *skb);
  2609. int dev_queue_xmit_accel(struct sk_buff *skb, struct net_device *sb_dev);
  2610. int __dev_direct_xmit(struct sk_buff *skb, u16 queue_id);
  2611. static inline int dev_direct_xmit(struct sk_buff *skb, u16 queue_id)
  2612. {
  2613. int ret;
  2614. ret = __dev_direct_xmit(skb, queue_id);
  2615. if (!dev_xmit_complete(ret))
  2616. kfree_skb(skb);
  2617. return ret;
  2618. }
  2619. int register_netdevice(struct net_device *dev);
  2620. void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
  2621. void unregister_netdevice_many(struct list_head *head);
  2622. static inline void unregister_netdevice(struct net_device *dev)
  2623. {
  2624. unregister_netdevice_queue(dev, NULL);
  2625. }
  2626. int netdev_refcnt_read(const struct net_device *dev);
  2627. void free_netdev(struct net_device *dev);
  2628. void netdev_freemem(struct net_device *dev);
  2629. int init_dummy_netdev(struct net_device *dev);
  2630. struct net_device *netdev_get_xmit_slave(struct net_device *dev,
  2631. struct sk_buff *skb,
  2632. bool all_slaves);
  2633. struct net_device *dev_get_by_index(struct net *net, int ifindex);
  2634. struct net_device *__dev_get_by_index(struct net *net, int ifindex);
  2635. struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
  2636. struct net_device *dev_get_by_napi_id(unsigned int napi_id);
  2637. int netdev_get_name(struct net *net, char *name, int ifindex);
  2638. int dev_restart(struct net_device *dev);
  2639. int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb);
  2640. int skb_gro_receive_list(struct sk_buff *p, struct sk_buff *skb);
  2641. static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
  2642. {
  2643. return NAPI_GRO_CB(skb)->data_offset;
  2644. }
  2645. static inline unsigned int skb_gro_len(const struct sk_buff *skb)
  2646. {
  2647. return skb->len - NAPI_GRO_CB(skb)->data_offset;
  2648. }
  2649. static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
  2650. {
  2651. NAPI_GRO_CB(skb)->data_offset += len;
  2652. }
  2653. static inline void *skb_gro_header_fast(struct sk_buff *skb,
  2654. unsigned int offset)
  2655. {
  2656. return NAPI_GRO_CB(skb)->frag0 + offset;
  2657. }
  2658. static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
  2659. {
  2660. return NAPI_GRO_CB(skb)->frag0_len < hlen;
  2661. }
  2662. static inline void skb_gro_frag0_invalidate(struct sk_buff *skb)
  2663. {
  2664. NAPI_GRO_CB(skb)->frag0 = NULL;
  2665. NAPI_GRO_CB(skb)->frag0_len = 0;
  2666. }
  2667. static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
  2668. unsigned int offset)
  2669. {
  2670. if (!pskb_may_pull(skb, hlen))
  2671. return NULL;
  2672. skb_gro_frag0_invalidate(skb);
  2673. return skb->data + offset;
  2674. }
  2675. static inline void *skb_gro_network_header(struct sk_buff *skb)
  2676. {
  2677. return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
  2678. skb_network_offset(skb);
  2679. }
  2680. static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
  2681. const void *start, unsigned int len)
  2682. {
  2683. if (NAPI_GRO_CB(skb)->csum_valid)
  2684. NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
  2685. csum_partial(start, len, 0));
  2686. }
  2687. /* GRO checksum functions. These are logical equivalents of the normal
  2688. * checksum functions (in skbuff.h) except that they operate on the GRO
  2689. * offsets and fields in sk_buff.
  2690. */
  2691. __sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
  2692. static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
  2693. {
  2694. return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
  2695. }
  2696. static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
  2697. bool zero_okay,
  2698. __sum16 check)
  2699. {
  2700. return ((skb->ip_summed != CHECKSUM_PARTIAL ||
  2701. skb_checksum_start_offset(skb) <
  2702. skb_gro_offset(skb)) &&
  2703. !skb_at_gro_remcsum_start(skb) &&
  2704. NAPI_GRO_CB(skb)->csum_cnt == 0 &&
  2705. (!zero_okay || check));
  2706. }
  2707. static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
  2708. __wsum psum)
  2709. {
  2710. if (NAPI_GRO_CB(skb)->csum_valid &&
  2711. !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
  2712. return 0;
  2713. NAPI_GRO_CB(skb)->csum = psum;
  2714. return __skb_gro_checksum_complete(skb);
  2715. }
  2716. static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
  2717. {
  2718. if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
  2719. /* Consume a checksum from CHECKSUM_UNNECESSARY */
  2720. NAPI_GRO_CB(skb)->csum_cnt--;
  2721. } else {
  2722. /* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
  2723. * verified a new top level checksum or an encapsulated one
  2724. * during GRO. This saves work if we fallback to normal path.
  2725. */
  2726. __skb_incr_checksum_unnecessary(skb);
  2727. }
  2728. }
  2729. #define __skb_gro_checksum_validate(skb, proto, zero_okay, check, \
  2730. compute_pseudo) \
  2731. ({ \
  2732. __sum16 __ret = 0; \
  2733. if (__skb_gro_checksum_validate_needed(skb, zero_okay, check)) \
  2734. __ret = __skb_gro_checksum_validate_complete(skb, \
  2735. compute_pseudo(skb, proto)); \
  2736. if (!__ret) \
  2737. skb_gro_incr_csum_unnecessary(skb); \
  2738. __ret; \
  2739. })
  2740. #define skb_gro_checksum_validate(skb, proto, compute_pseudo) \
  2741. __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
  2742. #define skb_gro_checksum_validate_zero_check(skb, proto, check, \
  2743. compute_pseudo) \
  2744. __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
  2745. #define skb_gro_checksum_simple_validate(skb) \
  2746. __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
  2747. static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
  2748. {
  2749. return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
  2750. !NAPI_GRO_CB(skb)->csum_valid);
  2751. }
  2752. static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
  2753. __wsum pseudo)
  2754. {
  2755. NAPI_GRO_CB(skb)->csum = ~pseudo;
  2756. NAPI_GRO_CB(skb)->csum_valid = 1;
  2757. }
  2758. #define skb_gro_checksum_try_convert(skb, proto, compute_pseudo) \
  2759. do { \
  2760. if (__skb_gro_checksum_convert_check(skb)) \
  2761. __skb_gro_checksum_convert(skb, \
  2762. compute_pseudo(skb, proto)); \
  2763. } while (0)
  2764. struct gro_remcsum {
  2765. int offset;
  2766. __wsum delta;
  2767. };
  2768. static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
  2769. {
  2770. grc->offset = 0;
  2771. grc->delta = 0;
  2772. }
  2773. static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
  2774. unsigned int off, size_t hdrlen,
  2775. int start, int offset,
  2776. struct gro_remcsum *grc,
  2777. bool nopartial)
  2778. {
  2779. __wsum delta;
  2780. size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
  2781. BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
  2782. if (!nopartial) {
  2783. NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
  2784. return ptr;
  2785. }
  2786. ptr = skb_gro_header_fast(skb, off);
  2787. if (skb_gro_header_hard(skb, off + plen)) {
  2788. ptr = skb_gro_header_slow(skb, off + plen, off);
  2789. if (!ptr)
  2790. return NULL;
  2791. }
  2792. delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
  2793. start, offset);
  2794. /* Adjust skb->csum since we changed the packet */
  2795. NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
  2796. grc->offset = off + hdrlen + offset;
  2797. grc->delta = delta;
  2798. return ptr;
  2799. }
  2800. static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
  2801. struct gro_remcsum *grc)
  2802. {
  2803. void *ptr;
  2804. size_t plen = grc->offset + sizeof(u16);
  2805. if (!grc->delta)
  2806. return;
  2807. ptr = skb_gro_header_fast(skb, grc->offset);
  2808. if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
  2809. ptr = skb_gro_header_slow(skb, plen, grc->offset);
  2810. if (!ptr)
  2811. return;
  2812. }
  2813. remcsum_unadjust((__sum16 *)ptr, grc->delta);
  2814. }
  2815. #ifdef CONFIG_XFRM_OFFLOAD
  2816. static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
  2817. {
  2818. if (PTR_ERR(pp) != -EINPROGRESS)
  2819. NAPI_GRO_CB(skb)->flush |= flush;
  2820. }
  2821. static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
  2822. struct sk_buff *pp,
  2823. int flush,
  2824. struct gro_remcsum *grc)
  2825. {
  2826. if (PTR_ERR(pp) != -EINPROGRESS) {
  2827. NAPI_GRO_CB(skb)->flush |= flush;
  2828. skb_gro_remcsum_cleanup(skb, grc);
  2829. skb->remcsum_offload = 0;
  2830. }
  2831. }
  2832. #else
  2833. static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
  2834. {
  2835. NAPI_GRO_CB(skb)->flush |= flush;
  2836. }
  2837. static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
  2838. struct sk_buff *pp,
  2839. int flush,
  2840. struct gro_remcsum *grc)
  2841. {
  2842. NAPI_GRO_CB(skb)->flush |= flush;
  2843. skb_gro_remcsum_cleanup(skb, grc);
  2844. skb->remcsum_offload = 0;
  2845. }
  2846. #endif
  2847. static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
  2848. unsigned short type,
  2849. const void *daddr, const void *saddr,
  2850. unsigned int len)
  2851. {
  2852. if (!dev->header_ops || !dev->header_ops->create)
  2853. return 0;
  2854. return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
  2855. }
  2856. static inline int dev_parse_header(const struct sk_buff *skb,
  2857. unsigned char *haddr)
  2858. {
  2859. const struct net_device *dev = skb->dev;
  2860. if (!dev->header_ops || !dev->header_ops->parse)
  2861. return 0;
  2862. return dev->header_ops->parse(skb, haddr);
  2863. }
  2864. static inline __be16 dev_parse_header_protocol(const struct sk_buff *skb)
  2865. {
  2866. const struct net_device *dev = skb->dev;
  2867. if (!dev->header_ops || !dev->header_ops->parse_protocol)
  2868. return 0;
  2869. return dev->header_ops->parse_protocol(skb);
  2870. }
  2871. /* ll_header must have at least hard_header_len allocated */
  2872. static inline bool dev_validate_header(const struct net_device *dev,
  2873. char *ll_header, int len)
  2874. {
  2875. if (likely(len >= dev->hard_header_len))
  2876. return true;
  2877. if (len < dev->min_header_len)
  2878. return false;
  2879. if (capable(CAP_SYS_RAWIO)) {
  2880. memset(ll_header + len, 0, dev->hard_header_len - len);
  2881. return true;
  2882. }
  2883. if (dev->header_ops && dev->header_ops->validate)
  2884. return dev->header_ops->validate(ll_header, len);
  2885. return false;
  2886. }
  2887. static inline bool dev_has_header(const struct net_device *dev)
  2888. {
  2889. return dev->header_ops && dev->header_ops->create;
  2890. }
  2891. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr,
  2892. int len, int size);
  2893. int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
  2894. static inline int unregister_gifconf(unsigned int family)
  2895. {
  2896. return register_gifconf(family, NULL);
  2897. }
  2898. #ifdef CONFIG_NET_FLOW_LIMIT
  2899. #define FLOW_LIMIT_HISTORY (1 << 7) /* must be ^2 and !overflow buckets */
  2900. struct sd_flow_limit {
  2901. u64 count;
  2902. unsigned int num_buckets;
  2903. unsigned int history_head;
  2904. u16 history[FLOW_LIMIT_HISTORY];
  2905. u8 buckets[];
  2906. };
  2907. extern int netdev_flow_limit_table_len;
  2908. #endif /* CONFIG_NET_FLOW_LIMIT */
  2909. /*
  2910. * Incoming packets are placed on per-CPU queues
  2911. */
  2912. struct softnet_data {
  2913. struct list_head poll_list;
  2914. struct sk_buff_head process_queue;
  2915. /* stats */
  2916. unsigned int processed;
  2917. unsigned int time_squeeze;
  2918. unsigned int received_rps;
  2919. #ifdef CONFIG_RPS
  2920. struct softnet_data *rps_ipi_list;
  2921. #endif
  2922. #ifdef CONFIG_NET_FLOW_LIMIT
  2923. struct sd_flow_limit __rcu *flow_limit;
  2924. #endif
  2925. struct Qdisc *output_queue;
  2926. struct Qdisc **output_queue_tailp;
  2927. struct sk_buff *completion_queue;
  2928. #ifdef CONFIG_XFRM_OFFLOAD
  2929. struct sk_buff_head xfrm_backlog;
  2930. #endif
  2931. /* written and read only by owning cpu: */
  2932. struct {
  2933. u16 recursion;
  2934. u8 more;
  2935. } xmit;
  2936. #ifdef CONFIG_RPS
  2937. /* input_queue_head should be written by cpu owning this struct,
  2938. * and only read by other cpus. Worth using a cache line.
  2939. */
  2940. unsigned int input_queue_head ____cacheline_aligned_in_smp;
  2941. /* Elements below can be accessed between CPUs for RPS/RFS */
  2942. call_single_data_t csd ____cacheline_aligned_in_smp;
  2943. struct softnet_data *rps_ipi_next;
  2944. unsigned int cpu;
  2945. unsigned int input_queue_tail;
  2946. #endif
  2947. unsigned int dropped;
  2948. struct sk_buff_head input_pkt_queue;
  2949. struct napi_struct backlog;
  2950. };
  2951. static inline void input_queue_head_incr(struct softnet_data *sd)
  2952. {
  2953. #ifdef CONFIG_RPS
  2954. sd->input_queue_head++;
  2955. #endif
  2956. }
  2957. static inline void input_queue_tail_incr_save(struct softnet_data *sd,
  2958. unsigned int *qtail)
  2959. {
  2960. #ifdef CONFIG_RPS
  2961. *qtail = ++sd->input_queue_tail;
  2962. #endif
  2963. }
  2964. DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
  2965. static inline int dev_recursion_level(void)
  2966. {
  2967. return this_cpu_read(softnet_data.xmit.recursion);
  2968. }
  2969. #define XMIT_RECURSION_LIMIT 8
  2970. static inline bool dev_xmit_recursion(void)
  2971. {
  2972. return unlikely(__this_cpu_read(softnet_data.xmit.recursion) >
  2973. XMIT_RECURSION_LIMIT);
  2974. }
  2975. static inline void dev_xmit_recursion_inc(void)
  2976. {
  2977. __this_cpu_inc(softnet_data.xmit.recursion);
  2978. }
  2979. static inline void dev_xmit_recursion_dec(void)
  2980. {
  2981. __this_cpu_dec(softnet_data.xmit.recursion);
  2982. }
  2983. void __netif_schedule(struct Qdisc *q);
  2984. void netif_schedule_queue(struct netdev_queue *txq);
  2985. static inline void netif_tx_schedule_all(struct net_device *dev)
  2986. {
  2987. unsigned int i;
  2988. for (i = 0; i < dev->num_tx_queues; i++)
  2989. netif_schedule_queue(netdev_get_tx_queue(dev, i));
  2990. }
  2991. static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
  2992. {
  2993. clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  2994. }
  2995. /**
  2996. * netif_start_queue - allow transmit
  2997. * @dev: network device
  2998. *
  2999. * Allow upper layers to call the device hard_start_xmit routine.
  3000. */
  3001. static inline void netif_start_queue(struct net_device *dev)
  3002. {
  3003. netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
  3004. }
  3005. static inline void netif_tx_start_all_queues(struct net_device *dev)
  3006. {
  3007. unsigned int i;
  3008. for (i = 0; i < dev->num_tx_queues; i++) {
  3009. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3010. netif_tx_start_queue(txq);
  3011. }
  3012. }
  3013. void netif_tx_wake_queue(struct netdev_queue *dev_queue);
  3014. /**
  3015. * netif_wake_queue - restart transmit
  3016. * @dev: network device
  3017. *
  3018. * Allow upper layers to call the device hard_start_xmit routine.
  3019. * Used for flow control when transmit resources are available.
  3020. */
  3021. static inline void netif_wake_queue(struct net_device *dev)
  3022. {
  3023. netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
  3024. }
  3025. static inline void netif_tx_wake_all_queues(struct net_device *dev)
  3026. {
  3027. unsigned int i;
  3028. for (i = 0; i < dev->num_tx_queues; i++) {
  3029. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3030. netif_tx_wake_queue(txq);
  3031. }
  3032. }
  3033. static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
  3034. {
  3035. set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  3036. }
  3037. /**
  3038. * netif_stop_queue - stop transmitted packets
  3039. * @dev: network device
  3040. *
  3041. * Stop upper layers calling the device hard_start_xmit routine.
  3042. * Used for flow control when transmit resources are unavailable.
  3043. */
  3044. static inline void netif_stop_queue(struct net_device *dev)
  3045. {
  3046. netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
  3047. }
  3048. void netif_tx_stop_all_queues(struct net_device *dev);
  3049. static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
  3050. {
  3051. return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  3052. }
  3053. /**
  3054. * netif_queue_stopped - test if transmit queue is flowblocked
  3055. * @dev: network device
  3056. *
  3057. * Test if transmit queue on device is currently unable to send.
  3058. */
  3059. static inline bool netif_queue_stopped(const struct net_device *dev)
  3060. {
  3061. return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
  3062. }
  3063. static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
  3064. {
  3065. return dev_queue->state & QUEUE_STATE_ANY_XOFF;
  3066. }
  3067. static inline bool
  3068. netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
  3069. {
  3070. return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
  3071. }
  3072. static inline bool
  3073. netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
  3074. {
  3075. return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
  3076. }
  3077. /**
  3078. * netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
  3079. * @dev_queue: pointer to transmit queue
  3080. *
  3081. * BQL enabled drivers might use this helper in their ndo_start_xmit(),
  3082. * to give appropriate hint to the CPU.
  3083. */
  3084. static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
  3085. {
  3086. #ifdef CONFIG_BQL
  3087. prefetchw(&dev_queue->dql.num_queued);
  3088. #endif
  3089. }
  3090. /**
  3091. * netdev_txq_bql_complete_prefetchw - prefetch bql data for write
  3092. * @dev_queue: pointer to transmit queue
  3093. *
  3094. * BQL enabled drivers might use this helper in their TX completion path,
  3095. * to give appropriate hint to the CPU.
  3096. */
  3097. static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
  3098. {
  3099. #ifdef CONFIG_BQL
  3100. prefetchw(&dev_queue->dql.limit);
  3101. #endif
  3102. }
  3103. static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
  3104. unsigned int bytes)
  3105. {
  3106. #ifdef CONFIG_BQL
  3107. dql_queued(&dev_queue->dql, bytes);
  3108. if (likely(dql_avail(&dev_queue->dql) >= 0))
  3109. return;
  3110. set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  3111. /*
  3112. * The XOFF flag must be set before checking the dql_avail below,
  3113. * because in netdev_tx_completed_queue we update the dql_completed
  3114. * before checking the XOFF flag.
  3115. */
  3116. smp_mb();
  3117. /* check again in case another CPU has just made room avail */
  3118. if (unlikely(dql_avail(&dev_queue->dql) >= 0))
  3119. clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  3120. #endif
  3121. }
  3122. /* Variant of netdev_tx_sent_queue() for drivers that are aware
  3123. * that they should not test BQL status themselves.
  3124. * We do want to change __QUEUE_STATE_STACK_XOFF only for the last
  3125. * skb of a batch.
  3126. * Returns true if the doorbell must be used to kick the NIC.
  3127. */
  3128. static inline bool __netdev_tx_sent_queue(struct netdev_queue *dev_queue,
  3129. unsigned int bytes,
  3130. bool xmit_more)
  3131. {
  3132. if (xmit_more) {
  3133. #ifdef CONFIG_BQL
  3134. dql_queued(&dev_queue->dql, bytes);
  3135. #endif
  3136. return netif_tx_queue_stopped(dev_queue);
  3137. }
  3138. netdev_tx_sent_queue(dev_queue, bytes);
  3139. return true;
  3140. }
  3141. /**
  3142. * netdev_sent_queue - report the number of bytes queued to hardware
  3143. * @dev: network device
  3144. * @bytes: number of bytes queued to the hardware device queue
  3145. *
  3146. * Report the number of bytes queued for sending/completion to the network
  3147. * device hardware queue. @bytes should be a good approximation and should
  3148. * exactly match netdev_completed_queue() @bytes
  3149. */
  3150. static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
  3151. {
  3152. netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
  3153. }
  3154. static inline bool __netdev_sent_queue(struct net_device *dev,
  3155. unsigned int bytes,
  3156. bool xmit_more)
  3157. {
  3158. return __netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes,
  3159. xmit_more);
  3160. }
  3161. static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
  3162. unsigned int pkts, unsigned int bytes)
  3163. {
  3164. #ifdef CONFIG_BQL
  3165. if (unlikely(!bytes))
  3166. return;
  3167. dql_completed(&dev_queue->dql, bytes);
  3168. /*
  3169. * Without the memory barrier there is a small possiblity that
  3170. * netdev_tx_sent_queue will miss the update and cause the queue to
  3171. * be stopped forever
  3172. */
  3173. smp_mb();
  3174. if (unlikely(dql_avail(&dev_queue->dql) < 0))
  3175. return;
  3176. if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
  3177. netif_schedule_queue(dev_queue);
  3178. #endif
  3179. }
  3180. /**
  3181. * netdev_completed_queue - report bytes and packets completed by device
  3182. * @dev: network device
  3183. * @pkts: actual number of packets sent over the medium
  3184. * @bytes: actual number of bytes sent over the medium
  3185. *
  3186. * Report the number of bytes and packets transmitted by the network device
  3187. * hardware queue over the physical medium, @bytes must exactly match the
  3188. * @bytes amount passed to netdev_sent_queue()
  3189. */
  3190. static inline void netdev_completed_queue(struct net_device *dev,
  3191. unsigned int pkts, unsigned int bytes)
  3192. {
  3193. netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
  3194. }
  3195. static inline void netdev_tx_reset_queue(struct netdev_queue *q)
  3196. {
  3197. #ifdef CONFIG_BQL
  3198. clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
  3199. dql_reset(&q->dql);
  3200. #endif
  3201. }
  3202. /**
  3203. * netdev_reset_queue - reset the packets and bytes count of a network device
  3204. * @dev_queue: network device
  3205. *
  3206. * Reset the bytes and packet count of a network device and clear the
  3207. * software flow control OFF bit for this network device
  3208. */
  3209. static inline void netdev_reset_queue(struct net_device *dev_queue)
  3210. {
  3211. netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
  3212. }
  3213. /**
  3214. * netdev_cap_txqueue - check if selected tx queue exceeds device queues
  3215. * @dev: network device
  3216. * @queue_index: given tx queue index
  3217. *
  3218. * Returns 0 if given tx queue index >= number of device tx queues,
  3219. * otherwise returns the originally passed tx queue index.
  3220. */
  3221. static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
  3222. {
  3223. if (unlikely(queue_index >= dev->real_num_tx_queues)) {
  3224. net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
  3225. dev->name, queue_index,
  3226. dev->real_num_tx_queues);
  3227. return 0;
  3228. }
  3229. return queue_index;
  3230. }
  3231. /**
  3232. * netif_running - test if up
  3233. * @dev: network device
  3234. *
  3235. * Test if the device has been brought up.
  3236. */
  3237. static inline bool netif_running(const struct net_device *dev)
  3238. {
  3239. return test_bit(__LINK_STATE_START, &dev->state);
  3240. }
  3241. /*
  3242. * Routines to manage the subqueues on a device. We only need start,
  3243. * stop, and a check if it's stopped. All other device management is
  3244. * done at the overall netdevice level.
  3245. * Also test the device if we're multiqueue.
  3246. */
  3247. /**
  3248. * netif_start_subqueue - allow sending packets on subqueue
  3249. * @dev: network device
  3250. * @queue_index: sub queue index
  3251. *
  3252. * Start individual transmit queue of a device with multiple transmit queues.
  3253. */
  3254. static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
  3255. {
  3256. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  3257. netif_tx_start_queue(txq);
  3258. }
  3259. /**
  3260. * netif_stop_subqueue - stop sending packets on subqueue
  3261. * @dev: network device
  3262. * @queue_index: sub queue index
  3263. *
  3264. * Stop individual transmit queue of a device with multiple transmit queues.
  3265. */
  3266. static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
  3267. {
  3268. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  3269. netif_tx_stop_queue(txq);
  3270. }
  3271. /**
  3272. * netif_subqueue_stopped - test status of subqueue
  3273. * @dev: network device
  3274. * @queue_index: sub queue index
  3275. *
  3276. * Check individual transmit queue of a device with multiple transmit queues.
  3277. */
  3278. static inline bool __netif_subqueue_stopped(const struct net_device *dev,
  3279. u16 queue_index)
  3280. {
  3281. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  3282. return netif_tx_queue_stopped(txq);
  3283. }
  3284. static inline bool netif_subqueue_stopped(const struct net_device *dev,
  3285. struct sk_buff *skb)
  3286. {
  3287. return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
  3288. }
  3289. /**
  3290. * netif_wake_subqueue - allow sending packets on subqueue
  3291. * @dev: network device
  3292. * @queue_index: sub queue index
  3293. *
  3294. * Resume individual transmit queue of a device with multiple transmit queues.
  3295. */
  3296. static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
  3297. {
  3298. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  3299. netif_tx_wake_queue(txq);
  3300. }
  3301. #ifdef CONFIG_XPS
  3302. int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
  3303. u16 index);
  3304. int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
  3305. u16 index, bool is_rxqs_map);
  3306. /**
  3307. * netif_attr_test_mask - Test a CPU or Rx queue set in a mask
  3308. * @j: CPU/Rx queue index
  3309. * @mask: bitmask of all cpus/rx queues
  3310. * @nr_bits: number of bits in the bitmask
  3311. *
  3312. * Test if a CPU or Rx queue index is set in a mask of all CPU/Rx queues.
  3313. */
  3314. static inline bool netif_attr_test_mask(unsigned long j,
  3315. const unsigned long *mask,
  3316. unsigned int nr_bits)
  3317. {
  3318. cpu_max_bits_warn(j, nr_bits);
  3319. return test_bit(j, mask);
  3320. }
  3321. /**
  3322. * netif_attr_test_online - Test for online CPU/Rx queue
  3323. * @j: CPU/Rx queue index
  3324. * @online_mask: bitmask for CPUs/Rx queues that are online
  3325. * @nr_bits: number of bits in the bitmask
  3326. *
  3327. * Returns true if a CPU/Rx queue is online.
  3328. */
  3329. static inline bool netif_attr_test_online(unsigned long j,
  3330. const unsigned long *online_mask,
  3331. unsigned int nr_bits)
  3332. {
  3333. cpu_max_bits_warn(j, nr_bits);
  3334. if (online_mask)
  3335. return test_bit(j, online_mask);
  3336. return (j < nr_bits);
  3337. }
  3338. /**
  3339. * netif_attrmask_next - get the next CPU/Rx queue in a cpu/Rx queues mask
  3340. * @n: CPU/Rx queue index
  3341. * @srcp: the cpumask/Rx queue mask pointer
  3342. * @nr_bits: number of bits in the bitmask
  3343. *
  3344. * Returns >= nr_bits if no further CPUs/Rx queues set.
  3345. */
  3346. static inline unsigned int netif_attrmask_next(int n, const unsigned long *srcp,
  3347. unsigned int nr_bits)
  3348. {
  3349. /* -1 is a legal arg here. */
  3350. if (n != -1)
  3351. cpu_max_bits_warn(n, nr_bits);
  3352. if (srcp)
  3353. return find_next_bit(srcp, nr_bits, n + 1);
  3354. return n + 1;
  3355. }
  3356. /**
  3357. * netif_attrmask_next_and - get the next CPU/Rx queue in \*src1p & \*src2p
  3358. * @n: CPU/Rx queue index
  3359. * @src1p: the first CPUs/Rx queues mask pointer
  3360. * @src2p: the second CPUs/Rx queues mask pointer
  3361. * @nr_bits: number of bits in the bitmask
  3362. *
  3363. * Returns >= nr_bits if no further CPUs/Rx queues set in both.
  3364. */
  3365. static inline int netif_attrmask_next_and(int n, const unsigned long *src1p,
  3366. const unsigned long *src2p,
  3367. unsigned int nr_bits)
  3368. {
  3369. /* -1 is a legal arg here. */
  3370. if (n != -1)
  3371. cpu_max_bits_warn(n, nr_bits);
  3372. if (src1p && src2p)
  3373. return find_next_and_bit(src1p, src2p, nr_bits, n + 1);
  3374. else if (src1p)
  3375. return find_next_bit(src1p, nr_bits, n + 1);
  3376. else if (src2p)
  3377. return find_next_bit(src2p, nr_bits, n + 1);
  3378. return n + 1;
  3379. }
  3380. #else
  3381. static inline int netif_set_xps_queue(struct net_device *dev,
  3382. const struct cpumask *mask,
  3383. u16 index)
  3384. {
  3385. return 0;
  3386. }
  3387. static inline int __netif_set_xps_queue(struct net_device *dev,
  3388. const unsigned long *mask,
  3389. u16 index, bool is_rxqs_map)
  3390. {
  3391. return 0;
  3392. }
  3393. #endif
  3394. /**
  3395. * netif_is_multiqueue - test if device has multiple transmit queues
  3396. * @dev: network device
  3397. *
  3398. * Check if device has multiple transmit queues
  3399. */
  3400. static inline bool netif_is_multiqueue(const struct net_device *dev)
  3401. {
  3402. return dev->num_tx_queues > 1;
  3403. }
  3404. int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
  3405. #ifdef CONFIG_SYSFS
  3406. int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
  3407. #else
  3408. static inline int netif_set_real_num_rx_queues(struct net_device *dev,
  3409. unsigned int rxqs)
  3410. {
  3411. dev->real_num_rx_queues = rxqs;
  3412. return 0;
  3413. }
  3414. #endif
  3415. static inline struct netdev_rx_queue *
  3416. __netif_get_rx_queue(struct net_device *dev, unsigned int rxq)
  3417. {
  3418. return dev->_rx + rxq;
  3419. }
  3420. #ifdef CONFIG_SYSFS
  3421. static inline unsigned int get_netdev_rx_queue_index(
  3422. struct netdev_rx_queue *queue)
  3423. {
  3424. struct net_device *dev = queue->dev;
  3425. int index = queue - dev->_rx;
  3426. BUG_ON(index >= dev->num_rx_queues);
  3427. return index;
  3428. }
  3429. #endif
  3430. #define DEFAULT_MAX_NUM_RSS_QUEUES (8)
  3431. int netif_get_num_default_rss_queues(void);
  3432. enum skb_free_reason {
  3433. SKB_REASON_CONSUMED,
  3434. SKB_REASON_DROPPED,
  3435. };
  3436. void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
  3437. void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
  3438. /*
  3439. * It is not allowed to call kfree_skb() or consume_skb() from hardware
  3440. * interrupt context or with hardware interrupts being disabled.
  3441. * (in_irq() || irqs_disabled())
  3442. *
  3443. * We provide four helpers that can be used in following contexts :
  3444. *
  3445. * dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
  3446. * replacing kfree_skb(skb)
  3447. *
  3448. * dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
  3449. * Typically used in place of consume_skb(skb) in TX completion path
  3450. *
  3451. * dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
  3452. * replacing kfree_skb(skb)
  3453. *
  3454. * dev_consume_skb_any(skb) when caller doesn't know its current irq context,
  3455. * and consumed a packet. Used in place of consume_skb(skb)
  3456. */
  3457. static inline void dev_kfree_skb_irq(struct sk_buff *skb)
  3458. {
  3459. __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
  3460. }
  3461. static inline void dev_consume_skb_irq(struct sk_buff *skb)
  3462. {
  3463. __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
  3464. }
  3465. static inline void dev_kfree_skb_any(struct sk_buff *skb)
  3466. {
  3467. __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
  3468. }
  3469. static inline void dev_consume_skb_any(struct sk_buff *skb)
  3470. {
  3471. __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
  3472. }
  3473. void generic_xdp_tx(struct sk_buff *skb, struct bpf_prog *xdp_prog);
  3474. int do_xdp_generic(struct bpf_prog *xdp_prog, struct sk_buff *skb);
  3475. int netif_rx(struct sk_buff *skb);
  3476. int netif_rx_ni(struct sk_buff *skb);
  3477. int netif_rx_any_context(struct sk_buff *skb);
  3478. int netif_receive_skb(struct sk_buff *skb);
  3479. int netif_receive_skb_core(struct sk_buff *skb);
  3480. void netif_receive_skb_list(struct list_head *head);
  3481. gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
  3482. void napi_gro_flush(struct napi_struct *napi, bool flush_old);
  3483. struct sk_buff *napi_get_frags(struct napi_struct *napi);
  3484. gro_result_t napi_gro_frags(struct napi_struct *napi);
  3485. struct packet_offload *gro_find_receive_by_type(__be16 type);
  3486. struct packet_offload *gro_find_complete_by_type(__be16 type);
  3487. static inline void napi_free_frags(struct napi_struct *napi)
  3488. {
  3489. kfree_skb(napi->skb);
  3490. napi->skb = NULL;
  3491. }
  3492. bool netdev_is_rx_handler_busy(struct net_device *dev);
  3493. int netdev_rx_handler_register(struct net_device *dev,
  3494. rx_handler_func_t *rx_handler,
  3495. void *rx_handler_data);
  3496. void netdev_rx_handler_unregister(struct net_device *dev);
  3497. bool dev_valid_name(const char *name);
  3498. static inline bool is_socket_ioctl_cmd(unsigned int cmd)
  3499. {
  3500. return _IOC_TYPE(cmd) == SOCK_IOC_TYPE;
  3501. }
  3502. int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr,
  3503. bool *need_copyout);
  3504. int dev_ifconf(struct net *net, struct ifconf *, int);
  3505. int dev_ethtool(struct net *net, struct ifreq *);
  3506. unsigned int dev_get_flags(const struct net_device *);
  3507. int __dev_change_flags(struct net_device *dev, unsigned int flags,
  3508. struct netlink_ext_ack *extack);
  3509. int dev_change_flags(struct net_device *dev, unsigned int flags,
  3510. struct netlink_ext_ack *extack);
  3511. void __dev_notify_flags(struct net_device *, unsigned int old_flags,
  3512. unsigned int gchanges);
  3513. int dev_change_name(struct net_device *, const char *);
  3514. int dev_set_alias(struct net_device *, const char *, size_t);
  3515. int dev_get_alias(const struct net_device *, char *, size_t);
  3516. int dev_change_net_namespace(struct net_device *, struct net *, const char *);
  3517. int __dev_set_mtu(struct net_device *, int);
  3518. int dev_validate_mtu(struct net_device *dev, int mtu,
  3519. struct netlink_ext_ack *extack);
  3520. int dev_set_mtu_ext(struct net_device *dev, int mtu,
  3521. struct netlink_ext_ack *extack);
  3522. int dev_set_mtu(struct net_device *, int);
  3523. int dev_change_tx_queue_len(struct net_device *, unsigned long);
  3524. void dev_set_group(struct net_device *, int);
  3525. int dev_pre_changeaddr_notify(struct net_device *dev, const char *addr,
  3526. struct netlink_ext_ack *extack);
  3527. int dev_set_mac_address(struct net_device *dev, struct sockaddr *sa,
  3528. struct netlink_ext_ack *extack);
  3529. int dev_set_mac_address_user(struct net_device *dev, struct sockaddr *sa,
  3530. struct netlink_ext_ack *extack);
  3531. int dev_get_mac_address(struct sockaddr *sa, struct net *net, char *dev_name);
  3532. int dev_change_carrier(struct net_device *, bool new_carrier);
  3533. int dev_get_phys_port_id(struct net_device *dev,
  3534. struct netdev_phys_item_id *ppid);
  3535. int dev_get_phys_port_name(struct net_device *dev,
  3536. char *name, size_t len);
  3537. int dev_get_port_parent_id(struct net_device *dev,
  3538. struct netdev_phys_item_id *ppid, bool recurse);
  3539. bool netdev_port_same_parent_id(struct net_device *a, struct net_device *b);
  3540. int dev_change_proto_down(struct net_device *dev, bool proto_down);
  3541. int dev_change_proto_down_generic(struct net_device *dev, bool proto_down);
  3542. void dev_change_proto_down_reason(struct net_device *dev, unsigned long mask,
  3543. u32 value);
  3544. struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev, bool *again);
  3545. struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
  3546. struct netdev_queue *txq, int *ret);
  3547. typedef int (*bpf_op_t)(struct net_device *dev, struct netdev_bpf *bpf);
  3548. int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack,
  3549. int fd, int expected_fd, u32 flags);
  3550. int bpf_xdp_link_attach(const union bpf_attr *attr, struct bpf_prog *prog);
  3551. u32 dev_xdp_prog_id(struct net_device *dev, enum bpf_xdp_mode mode);
  3552. int xdp_umem_query(struct net_device *dev, u16 queue_id);
  3553. int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
  3554. int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
  3555. bool is_skb_forwardable(const struct net_device *dev,
  3556. const struct sk_buff *skb);
  3557. static __always_inline int ____dev_forward_skb(struct net_device *dev,
  3558. struct sk_buff *skb)
  3559. {
  3560. if (skb_orphan_frags(skb, GFP_ATOMIC) ||
  3561. unlikely(!is_skb_forwardable(dev, skb))) {
  3562. atomic_long_inc(&dev->rx_dropped);
  3563. kfree_skb(skb);
  3564. return NET_RX_DROP;
  3565. }
  3566. skb_scrub_packet(skb, true);
  3567. skb->priority = 0;
  3568. return 0;
  3569. }
  3570. bool dev_nit_active(struct net_device *dev);
  3571. void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
  3572. extern int netdev_budget;
  3573. extern unsigned int netdev_budget_usecs;
  3574. /* Called by rtnetlink.c:rtnl_unlock() */
  3575. void netdev_run_todo(void);
  3576. /**
  3577. * dev_put - release reference to device
  3578. * @dev: network device
  3579. *
  3580. * Release reference to device to allow it to be freed.
  3581. */
  3582. static inline void dev_put(struct net_device *dev)
  3583. {
  3584. if (dev)
  3585. this_cpu_dec(*dev->pcpu_refcnt);
  3586. }
  3587. /**
  3588. * dev_hold - get reference to device
  3589. * @dev: network device
  3590. *
  3591. * Hold reference to device to keep it from being freed.
  3592. */
  3593. static inline void dev_hold(struct net_device *dev)
  3594. {
  3595. if (dev)
  3596. this_cpu_inc(*dev->pcpu_refcnt);
  3597. }
  3598. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  3599. * and _off may be called from IRQ context, but it is caller
  3600. * who is responsible for serialization of these calls.
  3601. *
  3602. * The name carrier is inappropriate, these functions should really be
  3603. * called netif_lowerlayer_*() because they represent the state of any
  3604. * kind of lower layer not just hardware media.
  3605. */
  3606. void linkwatch_init_dev(struct net_device *dev);
  3607. void linkwatch_fire_event(struct net_device *dev);
  3608. void linkwatch_forget_dev(struct net_device *dev);
  3609. /**
  3610. * netif_carrier_ok - test if carrier present
  3611. * @dev: network device
  3612. *
  3613. * Check if carrier is present on device
  3614. */
  3615. static inline bool netif_carrier_ok(const struct net_device *dev)
  3616. {
  3617. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  3618. }
  3619. unsigned long dev_trans_start(struct net_device *dev);
  3620. void __netdev_watchdog_up(struct net_device *dev);
  3621. void netif_carrier_on(struct net_device *dev);
  3622. void netif_carrier_off(struct net_device *dev);
  3623. /**
  3624. * netif_dormant_on - mark device as dormant.
  3625. * @dev: network device
  3626. *
  3627. * Mark device as dormant (as per RFC2863).
  3628. *
  3629. * The dormant state indicates that the relevant interface is not
  3630. * actually in a condition to pass packets (i.e., it is not 'up') but is
  3631. * in a "pending" state, waiting for some external event. For "on-
  3632. * demand" interfaces, this new state identifies the situation where the
  3633. * interface is waiting for events to place it in the up state.
  3634. */
  3635. static inline void netif_dormant_on(struct net_device *dev)
  3636. {
  3637. if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  3638. linkwatch_fire_event(dev);
  3639. }
  3640. /**
  3641. * netif_dormant_off - set device as not dormant.
  3642. * @dev: network device
  3643. *
  3644. * Device is not in dormant state.
  3645. */
  3646. static inline void netif_dormant_off(struct net_device *dev)
  3647. {
  3648. if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  3649. linkwatch_fire_event(dev);
  3650. }
  3651. /**
  3652. * netif_dormant - test if device is dormant
  3653. * @dev: network device
  3654. *
  3655. * Check if device is dormant.
  3656. */
  3657. static inline bool netif_dormant(const struct net_device *dev)
  3658. {
  3659. return test_bit(__LINK_STATE_DORMANT, &dev->state);
  3660. }
  3661. /**
  3662. * netif_testing_on - mark device as under test.
  3663. * @dev: network device
  3664. *
  3665. * Mark device as under test (as per RFC2863).
  3666. *
  3667. * The testing state indicates that some test(s) must be performed on
  3668. * the interface. After completion, of the test, the interface state
  3669. * will change to up, dormant, or down, as appropriate.
  3670. */
  3671. static inline void netif_testing_on(struct net_device *dev)
  3672. {
  3673. if (!test_and_set_bit(__LINK_STATE_TESTING, &dev->state))
  3674. linkwatch_fire_event(dev);
  3675. }
  3676. /**
  3677. * netif_testing_off - set device as not under test.
  3678. * @dev: network device
  3679. *
  3680. * Device is not in testing state.
  3681. */
  3682. static inline void netif_testing_off(struct net_device *dev)
  3683. {
  3684. if (test_and_clear_bit(__LINK_STATE_TESTING, &dev->state))
  3685. linkwatch_fire_event(dev);
  3686. }
  3687. /**
  3688. * netif_testing - test if device is under test
  3689. * @dev: network device
  3690. *
  3691. * Check if device is under test
  3692. */
  3693. static inline bool netif_testing(const struct net_device *dev)
  3694. {
  3695. return test_bit(__LINK_STATE_TESTING, &dev->state);
  3696. }
  3697. /**
  3698. * netif_oper_up - test if device is operational
  3699. * @dev: network device
  3700. *
  3701. * Check if carrier is operational
  3702. */
  3703. static inline bool netif_oper_up(const struct net_device *dev)
  3704. {
  3705. return (dev->operstate == IF_OPER_UP ||
  3706. dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
  3707. }
  3708. /**
  3709. * netif_device_present - is device available or removed
  3710. * @dev: network device
  3711. *
  3712. * Check if device has not been removed from system.
  3713. */
  3714. static inline bool netif_device_present(struct net_device *dev)
  3715. {
  3716. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  3717. }
  3718. void netif_device_detach(struct net_device *dev);
  3719. void netif_device_attach(struct net_device *dev);
  3720. /*
  3721. * Network interface message level settings
  3722. */
  3723. enum {
  3724. NETIF_MSG_DRV_BIT,
  3725. NETIF_MSG_PROBE_BIT,
  3726. NETIF_MSG_LINK_BIT,
  3727. NETIF_MSG_TIMER_BIT,
  3728. NETIF_MSG_IFDOWN_BIT,
  3729. NETIF_MSG_IFUP_BIT,
  3730. NETIF_MSG_RX_ERR_BIT,
  3731. NETIF_MSG_TX_ERR_BIT,
  3732. NETIF_MSG_TX_QUEUED_BIT,
  3733. NETIF_MSG_INTR_BIT,
  3734. NETIF_MSG_TX_DONE_BIT,
  3735. NETIF_MSG_RX_STATUS_BIT,
  3736. NETIF_MSG_PKTDATA_BIT,
  3737. NETIF_MSG_HW_BIT,
  3738. NETIF_MSG_WOL_BIT,
  3739. /* When you add a new bit above, update netif_msg_class_names array
  3740. * in net/ethtool/common.c
  3741. */
  3742. NETIF_MSG_CLASS_COUNT,
  3743. };
  3744. /* Both ethtool_ops interface and internal driver implementation use u32 */
  3745. static_assert(NETIF_MSG_CLASS_COUNT <= 32);
  3746. #define __NETIF_MSG_BIT(bit) ((u32)1 << (bit))
  3747. #define __NETIF_MSG(name) __NETIF_MSG_BIT(NETIF_MSG_ ## name ## _BIT)
  3748. #define NETIF_MSG_DRV __NETIF_MSG(DRV)
  3749. #define NETIF_MSG_PROBE __NETIF_MSG(PROBE)
  3750. #define NETIF_MSG_LINK __NETIF_MSG(LINK)
  3751. #define NETIF_MSG_TIMER __NETIF_MSG(TIMER)
  3752. #define NETIF_MSG_IFDOWN __NETIF_MSG(IFDOWN)
  3753. #define NETIF_MSG_IFUP __NETIF_MSG(IFUP)
  3754. #define NETIF_MSG_RX_ERR __NETIF_MSG(RX_ERR)
  3755. #define NETIF_MSG_TX_ERR __NETIF_MSG(TX_ERR)
  3756. #define NETIF_MSG_TX_QUEUED __NETIF_MSG(TX_QUEUED)
  3757. #define NETIF_MSG_INTR __NETIF_MSG(INTR)
  3758. #define NETIF_MSG_TX_DONE __NETIF_MSG(TX_DONE)
  3759. #define NETIF_MSG_RX_STATUS __NETIF_MSG(RX_STATUS)
  3760. #define NETIF_MSG_PKTDATA __NETIF_MSG(PKTDATA)
  3761. #define NETIF_MSG_HW __NETIF_MSG(HW)
  3762. #define NETIF_MSG_WOL __NETIF_MSG(WOL)
  3763. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  3764. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  3765. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  3766. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  3767. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  3768. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  3769. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  3770. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  3771. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  3772. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  3773. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  3774. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  3775. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  3776. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  3777. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  3778. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  3779. {
  3780. /* use default */
  3781. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  3782. return default_msg_enable_bits;
  3783. if (debug_value == 0) /* no output */
  3784. return 0;
  3785. /* set low N bits */
  3786. return (1U << debug_value) - 1;
  3787. }
  3788. static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
  3789. {
  3790. spin_lock(&txq->_xmit_lock);
  3791. /* Pairs with READ_ONCE() in __dev_queue_xmit() */
  3792. WRITE_ONCE(txq->xmit_lock_owner, cpu);
  3793. }
  3794. static inline bool __netif_tx_acquire(struct netdev_queue *txq)
  3795. {
  3796. __acquire(&txq->_xmit_lock);
  3797. return true;
  3798. }
  3799. static inline void __netif_tx_release(struct netdev_queue *txq)
  3800. {
  3801. __release(&txq->_xmit_lock);
  3802. }
  3803. static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
  3804. {
  3805. spin_lock_bh(&txq->_xmit_lock);
  3806. /* Pairs with READ_ONCE() in __dev_queue_xmit() */
  3807. WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
  3808. }
  3809. static inline bool __netif_tx_trylock(struct netdev_queue *txq)
  3810. {
  3811. bool ok = spin_trylock(&txq->_xmit_lock);
  3812. if (likely(ok)) {
  3813. /* Pairs with READ_ONCE() in __dev_queue_xmit() */
  3814. WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
  3815. }
  3816. return ok;
  3817. }
  3818. static inline void __netif_tx_unlock(struct netdev_queue *txq)
  3819. {
  3820. /* Pairs with READ_ONCE() in __dev_queue_xmit() */
  3821. WRITE_ONCE(txq->xmit_lock_owner, -1);
  3822. spin_unlock(&txq->_xmit_lock);
  3823. }
  3824. static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
  3825. {
  3826. /* Pairs with READ_ONCE() in __dev_queue_xmit() */
  3827. WRITE_ONCE(txq->xmit_lock_owner, -1);
  3828. spin_unlock_bh(&txq->_xmit_lock);
  3829. }
  3830. static inline void txq_trans_update(struct netdev_queue *txq)
  3831. {
  3832. if (txq->xmit_lock_owner != -1)
  3833. txq->trans_start = jiffies;
  3834. }
  3835. /* legacy drivers only, netdev_start_xmit() sets txq->trans_start */
  3836. static inline void netif_trans_update(struct net_device *dev)
  3837. {
  3838. struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
  3839. if (txq->trans_start != jiffies)
  3840. txq->trans_start = jiffies;
  3841. }
  3842. /**
  3843. * netif_tx_lock - grab network device transmit lock
  3844. * @dev: network device
  3845. *
  3846. * Get network device transmit lock
  3847. */
  3848. static inline void netif_tx_lock(struct net_device *dev)
  3849. {
  3850. unsigned int i;
  3851. int cpu;
  3852. spin_lock(&dev->tx_global_lock);
  3853. cpu = smp_processor_id();
  3854. for (i = 0; i < dev->num_tx_queues; i++) {
  3855. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3856. /* We are the only thread of execution doing a
  3857. * freeze, but we have to grab the _xmit_lock in
  3858. * order to synchronize with threads which are in
  3859. * the ->hard_start_xmit() handler and already
  3860. * checked the frozen bit.
  3861. */
  3862. __netif_tx_lock(txq, cpu);
  3863. set_bit(__QUEUE_STATE_FROZEN, &txq->state);
  3864. __netif_tx_unlock(txq);
  3865. }
  3866. }
  3867. static inline void netif_tx_lock_bh(struct net_device *dev)
  3868. {
  3869. local_bh_disable();
  3870. netif_tx_lock(dev);
  3871. }
  3872. static inline void netif_tx_unlock(struct net_device *dev)
  3873. {
  3874. unsigned int i;
  3875. for (i = 0; i < dev->num_tx_queues; i++) {
  3876. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3877. /* No need to grab the _xmit_lock here. If the
  3878. * queue is not stopped for another reason, we
  3879. * force a schedule.
  3880. */
  3881. clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
  3882. netif_schedule_queue(txq);
  3883. }
  3884. spin_unlock(&dev->tx_global_lock);
  3885. }
  3886. static inline void netif_tx_unlock_bh(struct net_device *dev)
  3887. {
  3888. netif_tx_unlock(dev);
  3889. local_bh_enable();
  3890. }
  3891. #define HARD_TX_LOCK(dev, txq, cpu) { \
  3892. if ((dev->features & NETIF_F_LLTX) == 0) { \
  3893. __netif_tx_lock(txq, cpu); \
  3894. } else { \
  3895. __netif_tx_acquire(txq); \
  3896. } \
  3897. }
  3898. #define HARD_TX_TRYLOCK(dev, txq) \
  3899. (((dev->features & NETIF_F_LLTX) == 0) ? \
  3900. __netif_tx_trylock(txq) : \
  3901. __netif_tx_acquire(txq))
  3902. #define HARD_TX_UNLOCK(dev, txq) { \
  3903. if ((dev->features & NETIF_F_LLTX) == 0) { \
  3904. __netif_tx_unlock(txq); \
  3905. } else { \
  3906. __netif_tx_release(txq); \
  3907. } \
  3908. }
  3909. static inline void netif_tx_disable(struct net_device *dev)
  3910. {
  3911. unsigned int i;
  3912. int cpu;
  3913. local_bh_disable();
  3914. cpu = smp_processor_id();
  3915. spin_lock(&dev->tx_global_lock);
  3916. for (i = 0; i < dev->num_tx_queues; i++) {
  3917. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3918. __netif_tx_lock(txq, cpu);
  3919. netif_tx_stop_queue(txq);
  3920. __netif_tx_unlock(txq);
  3921. }
  3922. spin_unlock(&dev->tx_global_lock);
  3923. local_bh_enable();
  3924. }
  3925. static inline void netif_addr_lock(struct net_device *dev)
  3926. {
  3927. unsigned char nest_level = 0;
  3928. #ifdef CONFIG_LOCKDEP
  3929. nest_level = dev->nested_level;
  3930. #endif
  3931. spin_lock_nested(&dev->addr_list_lock, nest_level);
  3932. }
  3933. static inline void netif_addr_lock_bh(struct net_device *dev)
  3934. {
  3935. unsigned char nest_level = 0;
  3936. #ifdef CONFIG_LOCKDEP
  3937. nest_level = dev->nested_level;
  3938. #endif
  3939. local_bh_disable();
  3940. spin_lock_nested(&dev->addr_list_lock, nest_level);
  3941. }
  3942. static inline void netif_addr_unlock(struct net_device *dev)
  3943. {
  3944. spin_unlock(&dev->addr_list_lock);
  3945. }
  3946. static inline void netif_addr_unlock_bh(struct net_device *dev)
  3947. {
  3948. spin_unlock_bh(&dev->addr_list_lock);
  3949. }
  3950. /*
  3951. * dev_addrs walker. Should be used only for read access. Call with
  3952. * rcu_read_lock held.
  3953. */
  3954. #define for_each_dev_addr(dev, ha) \
  3955. list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
  3956. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  3957. void ether_setup(struct net_device *dev);
  3958. /* Support for loadable net-drivers */
  3959. struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
  3960. unsigned char name_assign_type,
  3961. void (*setup)(struct net_device *),
  3962. unsigned int txqs, unsigned int rxqs);
  3963. #define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
  3964. alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
  3965. #define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
  3966. alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
  3967. count)
  3968. int register_netdev(struct net_device *dev);
  3969. void unregister_netdev(struct net_device *dev);
  3970. int devm_register_netdev(struct device *dev, struct net_device *ndev);
  3971. /* General hardware address lists handling functions */
  3972. int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
  3973. struct netdev_hw_addr_list *from_list, int addr_len);
  3974. void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
  3975. struct netdev_hw_addr_list *from_list, int addr_len);
  3976. int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
  3977. struct net_device *dev,
  3978. int (*sync)(struct net_device *, const unsigned char *),
  3979. int (*unsync)(struct net_device *,
  3980. const unsigned char *));
  3981. int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
  3982. struct net_device *dev,
  3983. int (*sync)(struct net_device *,
  3984. const unsigned char *, int),
  3985. int (*unsync)(struct net_device *,
  3986. const unsigned char *, int));
  3987. void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
  3988. struct net_device *dev,
  3989. int (*unsync)(struct net_device *,
  3990. const unsigned char *, int));
  3991. void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
  3992. struct net_device *dev,
  3993. int (*unsync)(struct net_device *,
  3994. const unsigned char *));
  3995. void __hw_addr_init(struct netdev_hw_addr_list *list);
  3996. /* Functions used for device addresses handling */
  3997. int dev_addr_add(struct net_device *dev, const unsigned char *addr,
  3998. unsigned char addr_type);
  3999. int dev_addr_del(struct net_device *dev, const unsigned char *addr,
  4000. unsigned char addr_type);
  4001. void dev_addr_flush(struct net_device *dev);
  4002. int dev_addr_init(struct net_device *dev);
  4003. /* Functions used for unicast addresses handling */
  4004. int dev_uc_add(struct net_device *dev, const unsigned char *addr);
  4005. int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
  4006. int dev_uc_del(struct net_device *dev, const unsigned char *addr);
  4007. int dev_uc_sync(struct net_device *to, struct net_device *from);
  4008. int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
  4009. void dev_uc_unsync(struct net_device *to, struct net_device *from);
  4010. void dev_uc_flush(struct net_device *dev);
  4011. void dev_uc_init(struct net_device *dev);
  4012. /**
  4013. * __dev_uc_sync - Synchonize device's unicast list
  4014. * @dev: device to sync
  4015. * @sync: function to call if address should be added
  4016. * @unsync: function to call if address should be removed
  4017. *
  4018. * Add newly added addresses to the interface, and release
  4019. * addresses that have been deleted.
  4020. */
  4021. static inline int __dev_uc_sync(struct net_device *dev,
  4022. int (*sync)(struct net_device *,
  4023. const unsigned char *),
  4024. int (*unsync)(struct net_device *,
  4025. const unsigned char *))
  4026. {
  4027. return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
  4028. }
  4029. /**
  4030. * __dev_uc_unsync - Remove synchronized addresses from device
  4031. * @dev: device to sync
  4032. * @unsync: function to call if address should be removed
  4033. *
  4034. * Remove all addresses that were added to the device by dev_uc_sync().
  4035. */
  4036. static inline void __dev_uc_unsync(struct net_device *dev,
  4037. int (*unsync)(struct net_device *,
  4038. const unsigned char *))
  4039. {
  4040. __hw_addr_unsync_dev(&dev->uc, dev, unsync);
  4041. }
  4042. /* Functions used for multicast addresses handling */
  4043. int dev_mc_add(struct net_device *dev, const unsigned char *addr);
  4044. int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
  4045. int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
  4046. int dev_mc_del(struct net_device *dev, const unsigned char *addr);
  4047. int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
  4048. int dev_mc_sync(struct net_device *to, struct net_device *from);
  4049. int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
  4050. void dev_mc_unsync(struct net_device *to, struct net_device *from);
  4051. void dev_mc_flush(struct net_device *dev);
  4052. void dev_mc_init(struct net_device *dev);
  4053. /**
  4054. * __dev_mc_sync - Synchonize device's multicast list
  4055. * @dev: device to sync
  4056. * @sync: function to call if address should be added
  4057. * @unsync: function to call if address should be removed
  4058. *
  4059. * Add newly added addresses to the interface, and release
  4060. * addresses that have been deleted.
  4061. */
  4062. static inline int __dev_mc_sync(struct net_device *dev,
  4063. int (*sync)(struct net_device *,
  4064. const unsigned char *),
  4065. int (*unsync)(struct net_device *,
  4066. const unsigned char *))
  4067. {
  4068. return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
  4069. }
  4070. /**
  4071. * __dev_mc_unsync - Remove synchronized addresses from device
  4072. * @dev: device to sync
  4073. * @unsync: function to call if address should be removed
  4074. *
  4075. * Remove all addresses that were added to the device by dev_mc_sync().
  4076. */
  4077. static inline void __dev_mc_unsync(struct net_device *dev,
  4078. int (*unsync)(struct net_device *,
  4079. const unsigned char *))
  4080. {
  4081. __hw_addr_unsync_dev(&dev->mc, dev, unsync);
  4082. }
  4083. /* Functions used for secondary unicast and multicast support */
  4084. void dev_set_rx_mode(struct net_device *dev);
  4085. void __dev_set_rx_mode(struct net_device *dev);
  4086. int dev_set_promiscuity(struct net_device *dev, int inc);
  4087. int dev_set_allmulti(struct net_device *dev, int inc);
  4088. void netdev_state_change(struct net_device *dev);
  4089. void netdev_notify_peers(struct net_device *dev);
  4090. void netdev_features_change(struct net_device *dev);
  4091. /* Load a device via the kmod */
  4092. void dev_load(struct net *net, const char *name);
  4093. struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
  4094. struct rtnl_link_stats64 *storage);
  4095. void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
  4096. const struct net_device_stats *netdev_stats);
  4097. void dev_fetch_sw_netstats(struct rtnl_link_stats64 *s,
  4098. const struct pcpu_sw_netstats __percpu *netstats);
  4099. extern int netdev_max_backlog;
  4100. extern int netdev_tstamp_prequeue;
  4101. extern int weight_p;
  4102. extern int dev_weight_rx_bias;
  4103. extern int dev_weight_tx_bias;
  4104. extern int dev_rx_weight;
  4105. extern int dev_tx_weight;
  4106. extern int gro_normal_batch;
  4107. enum {
  4108. NESTED_SYNC_IMM_BIT,
  4109. NESTED_SYNC_TODO_BIT,
  4110. };
  4111. #define __NESTED_SYNC_BIT(bit) ((u32)1 << (bit))
  4112. #define __NESTED_SYNC(name) __NESTED_SYNC_BIT(NESTED_SYNC_ ## name ## _BIT)
  4113. #define NESTED_SYNC_IMM __NESTED_SYNC(IMM)
  4114. #define NESTED_SYNC_TODO __NESTED_SYNC(TODO)
  4115. struct netdev_nested_priv {
  4116. unsigned char flags;
  4117. void *data;
  4118. };
  4119. bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
  4120. struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
  4121. struct list_head **iter);
  4122. struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
  4123. struct list_head **iter);
  4124. #ifdef CONFIG_LOCKDEP
  4125. static LIST_HEAD(net_unlink_list);
  4126. static inline void net_unlink_todo(struct net_device *dev)
  4127. {
  4128. if (list_empty(&dev->unlink_list))
  4129. list_add_tail(&dev->unlink_list, &net_unlink_list);
  4130. }
  4131. #endif
  4132. /* iterate through upper list, must be called under RCU read lock */
  4133. #define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
  4134. for (iter = &(dev)->adj_list.upper, \
  4135. updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
  4136. updev; \
  4137. updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
  4138. int netdev_walk_all_upper_dev_rcu(struct net_device *dev,
  4139. int (*fn)(struct net_device *upper_dev,
  4140. struct netdev_nested_priv *priv),
  4141. struct netdev_nested_priv *priv);
  4142. bool netdev_has_upper_dev_all_rcu(struct net_device *dev,
  4143. struct net_device *upper_dev);
  4144. bool netdev_has_any_upper_dev(struct net_device *dev);
  4145. void *netdev_lower_get_next_private(struct net_device *dev,
  4146. struct list_head **iter);
  4147. void *netdev_lower_get_next_private_rcu(struct net_device *dev,
  4148. struct list_head **iter);
  4149. #define netdev_for_each_lower_private(dev, priv, iter) \
  4150. for (iter = (dev)->adj_list.lower.next, \
  4151. priv = netdev_lower_get_next_private(dev, &(iter)); \
  4152. priv; \
  4153. priv = netdev_lower_get_next_private(dev, &(iter)))
  4154. #define netdev_for_each_lower_private_rcu(dev, priv, iter) \
  4155. for (iter = &(dev)->adj_list.lower, \
  4156. priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
  4157. priv; \
  4158. priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
  4159. void *netdev_lower_get_next(struct net_device *dev,
  4160. struct list_head **iter);
  4161. #define netdev_for_each_lower_dev(dev, ldev, iter) \
  4162. for (iter = (dev)->adj_list.lower.next, \
  4163. ldev = netdev_lower_get_next(dev, &(iter)); \
  4164. ldev; \
  4165. ldev = netdev_lower_get_next(dev, &(iter)))
  4166. struct net_device *netdev_next_lower_dev_rcu(struct net_device *dev,
  4167. struct list_head **iter);
  4168. int netdev_walk_all_lower_dev(struct net_device *dev,
  4169. int (*fn)(struct net_device *lower_dev,
  4170. struct netdev_nested_priv *priv),
  4171. struct netdev_nested_priv *priv);
  4172. int netdev_walk_all_lower_dev_rcu(struct net_device *dev,
  4173. int (*fn)(struct net_device *lower_dev,
  4174. struct netdev_nested_priv *priv),
  4175. struct netdev_nested_priv *priv);
  4176. void *netdev_adjacent_get_private(struct list_head *adj_list);
  4177. void *netdev_lower_get_first_private_rcu(struct net_device *dev);
  4178. struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
  4179. struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
  4180. int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev,
  4181. struct netlink_ext_ack *extack);
  4182. int netdev_master_upper_dev_link(struct net_device *dev,
  4183. struct net_device *upper_dev,
  4184. void *upper_priv, void *upper_info,
  4185. struct netlink_ext_ack *extack);
  4186. void netdev_upper_dev_unlink(struct net_device *dev,
  4187. struct net_device *upper_dev);
  4188. int netdev_adjacent_change_prepare(struct net_device *old_dev,
  4189. struct net_device *new_dev,
  4190. struct net_device *dev,
  4191. struct netlink_ext_ack *extack);
  4192. void netdev_adjacent_change_commit(struct net_device *old_dev,
  4193. struct net_device *new_dev,
  4194. struct net_device *dev);
  4195. void netdev_adjacent_change_abort(struct net_device *old_dev,
  4196. struct net_device *new_dev,
  4197. struct net_device *dev);
  4198. void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
  4199. void *netdev_lower_dev_get_private(struct net_device *dev,
  4200. struct net_device *lower_dev);
  4201. void netdev_lower_state_changed(struct net_device *lower_dev,
  4202. void *lower_state_info);
  4203. /* RSS keys are 40 or 52 bytes long */
  4204. #define NETDEV_RSS_KEY_LEN 52
  4205. extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
  4206. void netdev_rss_key_fill(void *buffer, size_t len);
  4207. int skb_checksum_help(struct sk_buff *skb);
  4208. int skb_crc32c_csum_help(struct sk_buff *skb);
  4209. int skb_csum_hwoffload_help(struct sk_buff *skb,
  4210. const netdev_features_t features);
  4211. struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
  4212. netdev_features_t features, bool tx_path);
  4213. struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
  4214. netdev_features_t features);
  4215. struct netdev_bonding_info {
  4216. ifslave slave;
  4217. ifbond master;
  4218. };
  4219. struct netdev_notifier_bonding_info {
  4220. struct netdev_notifier_info info; /* must be first */
  4221. struct netdev_bonding_info bonding_info;
  4222. };
  4223. void netdev_bonding_info_change(struct net_device *dev,
  4224. struct netdev_bonding_info *bonding_info);
  4225. #if IS_ENABLED(CONFIG_ETHTOOL_NETLINK)
  4226. void ethtool_notify(struct net_device *dev, unsigned int cmd, const void *data);
  4227. #else
  4228. static inline void ethtool_notify(struct net_device *dev, unsigned int cmd,
  4229. const void *data)
  4230. {
  4231. }
  4232. #endif
  4233. static inline
  4234. struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
  4235. {
  4236. return __skb_gso_segment(skb, features, true);
  4237. }
  4238. __be16 skb_network_protocol(struct sk_buff *skb, int *depth);
  4239. static inline bool can_checksum_protocol(netdev_features_t features,
  4240. __be16 protocol)
  4241. {
  4242. if (protocol == htons(ETH_P_FCOE))
  4243. return !!(features & NETIF_F_FCOE_CRC);
  4244. /* Assume this is an IP checksum (not SCTP CRC) */
  4245. if (features & NETIF_F_HW_CSUM) {
  4246. /* Can checksum everything */
  4247. return true;
  4248. }
  4249. switch (protocol) {
  4250. case htons(ETH_P_IP):
  4251. return !!(features & NETIF_F_IP_CSUM);
  4252. case htons(ETH_P_IPV6):
  4253. return !!(features & NETIF_F_IPV6_CSUM);
  4254. default:
  4255. return false;
  4256. }
  4257. }
  4258. #ifdef CONFIG_BUG
  4259. void netdev_rx_csum_fault(struct net_device *dev, struct sk_buff *skb);
  4260. #else
  4261. static inline void netdev_rx_csum_fault(struct net_device *dev,
  4262. struct sk_buff *skb)
  4263. {
  4264. }
  4265. #endif
  4266. /* rx skb timestamps */
  4267. void net_enable_timestamp(void);
  4268. void net_disable_timestamp(void);
  4269. #ifdef CONFIG_PROC_FS
  4270. int __init dev_proc_init(void);
  4271. #else
  4272. #define dev_proc_init() 0
  4273. #endif
  4274. static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
  4275. struct sk_buff *skb, struct net_device *dev,
  4276. bool more)
  4277. {
  4278. __this_cpu_write(softnet_data.xmit.more, more);
  4279. return ops->ndo_start_xmit(skb, dev);
  4280. }
  4281. static inline bool netdev_xmit_more(void)
  4282. {
  4283. return __this_cpu_read(softnet_data.xmit.more);
  4284. }
  4285. static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
  4286. struct netdev_queue *txq, bool more)
  4287. {
  4288. const struct net_device_ops *ops = dev->netdev_ops;
  4289. netdev_tx_t rc;
  4290. rc = __netdev_start_xmit(ops, skb, dev, more);
  4291. if (rc == NETDEV_TX_OK)
  4292. txq_trans_update(txq);
  4293. return rc;
  4294. }
  4295. int netdev_class_create_file_ns(const struct class_attribute *class_attr,
  4296. const void *ns);
  4297. void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
  4298. const void *ns);
  4299. extern const struct kobj_ns_type_operations net_ns_type_operations;
  4300. const char *netdev_drivername(const struct net_device *dev);
  4301. void linkwatch_run_queue(void);
  4302. static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
  4303. netdev_features_t f2)
  4304. {
  4305. if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
  4306. if (f1 & NETIF_F_HW_CSUM)
  4307. f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
  4308. else
  4309. f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
  4310. }
  4311. return f1 & f2;
  4312. }
  4313. static inline netdev_features_t netdev_get_wanted_features(
  4314. struct net_device *dev)
  4315. {
  4316. return (dev->features & ~dev->hw_features) | dev->wanted_features;
  4317. }
  4318. netdev_features_t netdev_increment_features(netdev_features_t all,
  4319. netdev_features_t one, netdev_features_t mask);
  4320. /* Allow TSO being used on stacked device :
  4321. * Performing the GSO segmentation before last device
  4322. * is a performance improvement.
  4323. */
  4324. static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
  4325. netdev_features_t mask)
  4326. {
  4327. return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
  4328. }
  4329. int __netdev_update_features(struct net_device *dev);
  4330. void netdev_update_features(struct net_device *dev);
  4331. void netdev_change_features(struct net_device *dev);
  4332. void netif_stacked_transfer_operstate(const struct net_device *rootdev,
  4333. struct net_device *dev);
  4334. netdev_features_t passthru_features_check(struct sk_buff *skb,
  4335. struct net_device *dev,
  4336. netdev_features_t features);
  4337. netdev_features_t netif_skb_features(struct sk_buff *skb);
  4338. static inline bool net_gso_ok(netdev_features_t features, int gso_type)
  4339. {
  4340. netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
  4341. /* check flags correspondence */
  4342. BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
  4343. BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
  4344. BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
  4345. BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
  4346. BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
  4347. BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
  4348. BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
  4349. BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
  4350. BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
  4351. BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
  4352. BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
  4353. BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
  4354. BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
  4355. BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
  4356. BUILD_BUG_ON(SKB_GSO_SCTP != (NETIF_F_GSO_SCTP >> NETIF_F_GSO_SHIFT));
  4357. BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));
  4358. BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_GSO_UDP >> NETIF_F_GSO_SHIFT));
  4359. BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT));
  4360. BUILD_BUG_ON(SKB_GSO_FRAGLIST != (NETIF_F_GSO_FRAGLIST >> NETIF_F_GSO_SHIFT));
  4361. return (features & feature) == feature;
  4362. }
  4363. static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
  4364. {
  4365. return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
  4366. (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
  4367. }
  4368. static inline bool netif_needs_gso(struct sk_buff *skb,
  4369. netdev_features_t features)
  4370. {
  4371. return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
  4372. unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
  4373. (skb->ip_summed != CHECKSUM_UNNECESSARY)));
  4374. }
  4375. static inline void netif_set_gso_max_size(struct net_device *dev,
  4376. unsigned int size)
  4377. {
  4378. dev->gso_max_size = size;
  4379. }
  4380. static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
  4381. int pulled_hlen, u16 mac_offset,
  4382. int mac_len)
  4383. {
  4384. skb->protocol = protocol;
  4385. skb->encapsulation = 1;
  4386. skb_push(skb, pulled_hlen);
  4387. skb_reset_transport_header(skb);
  4388. skb->mac_header = mac_offset;
  4389. skb->network_header = skb->mac_header + mac_len;
  4390. skb->mac_len = mac_len;
  4391. }
  4392. static inline bool netif_is_macsec(const struct net_device *dev)
  4393. {
  4394. return dev->priv_flags & IFF_MACSEC;
  4395. }
  4396. static inline bool netif_is_macvlan(const struct net_device *dev)
  4397. {
  4398. return dev->priv_flags & IFF_MACVLAN;
  4399. }
  4400. static inline bool netif_is_macvlan_port(const struct net_device *dev)
  4401. {
  4402. return dev->priv_flags & IFF_MACVLAN_PORT;
  4403. }
  4404. static inline bool netif_is_bond_master(const struct net_device *dev)
  4405. {
  4406. return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
  4407. }
  4408. static inline bool netif_is_bond_slave(const struct net_device *dev)
  4409. {
  4410. return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
  4411. }
  4412. static inline bool netif_supports_nofcs(struct net_device *dev)
  4413. {
  4414. return dev->priv_flags & IFF_SUPP_NOFCS;
  4415. }
  4416. static inline bool netif_has_l3_rx_handler(const struct net_device *dev)
  4417. {
  4418. return dev->priv_flags & IFF_L3MDEV_RX_HANDLER;
  4419. }
  4420. static inline bool netif_is_l3_master(const struct net_device *dev)
  4421. {
  4422. return dev->priv_flags & IFF_L3MDEV_MASTER;
  4423. }
  4424. static inline bool netif_is_l3_slave(const struct net_device *dev)
  4425. {
  4426. return dev->priv_flags & IFF_L3MDEV_SLAVE;
  4427. }
  4428. static inline bool netif_is_bridge_master(const struct net_device *dev)
  4429. {
  4430. return dev->priv_flags & IFF_EBRIDGE;
  4431. }
  4432. static inline bool netif_is_bridge_port(const struct net_device *dev)
  4433. {
  4434. return dev->priv_flags & IFF_BRIDGE_PORT;
  4435. }
  4436. static inline bool netif_is_ovs_master(const struct net_device *dev)
  4437. {
  4438. return dev->priv_flags & IFF_OPENVSWITCH;
  4439. }
  4440. static inline bool netif_is_ovs_port(const struct net_device *dev)
  4441. {
  4442. return dev->priv_flags & IFF_OVS_DATAPATH;
  4443. }
  4444. static inline bool netif_is_any_bridge_port(const struct net_device *dev)
  4445. {
  4446. return netif_is_bridge_port(dev) || netif_is_ovs_port(dev);
  4447. }
  4448. static inline bool netif_is_team_master(const struct net_device *dev)
  4449. {
  4450. return dev->priv_flags & IFF_TEAM;
  4451. }
  4452. static inline bool netif_is_team_port(const struct net_device *dev)
  4453. {
  4454. return dev->priv_flags & IFF_TEAM_PORT;
  4455. }
  4456. static inline bool netif_is_lag_master(const struct net_device *dev)
  4457. {
  4458. return netif_is_bond_master(dev) || netif_is_team_master(dev);
  4459. }
  4460. static inline bool netif_is_lag_port(const struct net_device *dev)
  4461. {
  4462. return netif_is_bond_slave(dev) || netif_is_team_port(dev);
  4463. }
  4464. static inline bool netif_is_rxfh_configured(const struct net_device *dev)
  4465. {
  4466. return dev->priv_flags & IFF_RXFH_CONFIGURED;
  4467. }
  4468. static inline bool netif_is_failover(const struct net_device *dev)
  4469. {
  4470. return dev->priv_flags & IFF_FAILOVER;
  4471. }
  4472. static inline bool netif_is_failover_slave(const struct net_device *dev)
  4473. {
  4474. return dev->priv_flags & IFF_FAILOVER_SLAVE;
  4475. }
  4476. /* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
  4477. static inline void netif_keep_dst(struct net_device *dev)
  4478. {
  4479. dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
  4480. }
  4481. /* return true if dev can't cope with mtu frames that need vlan tag insertion */
  4482. static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
  4483. {
  4484. /* TODO: reserve and use an additional IFF bit, if we get more users */
  4485. return dev->priv_flags & IFF_MACSEC;
  4486. }
  4487. extern struct pernet_operations __net_initdata loopback_net_ops;
  4488. /* Logging, debugging and troubleshooting/diagnostic helpers. */
  4489. /* netdev_printk helpers, similar to dev_printk */
  4490. static inline const char *netdev_name(const struct net_device *dev)
  4491. {
  4492. if (!dev->name[0] || strchr(dev->name, '%'))
  4493. return "(unnamed net_device)";
  4494. return dev->name;
  4495. }
  4496. static inline bool netdev_unregistering(const struct net_device *dev)
  4497. {
  4498. return dev->reg_state == NETREG_UNREGISTERING;
  4499. }
  4500. static inline const char *netdev_reg_state(const struct net_device *dev)
  4501. {
  4502. switch (dev->reg_state) {
  4503. case NETREG_UNINITIALIZED: return " (uninitialized)";
  4504. case NETREG_REGISTERED: return "";
  4505. case NETREG_UNREGISTERING: return " (unregistering)";
  4506. case NETREG_UNREGISTERED: return " (unregistered)";
  4507. case NETREG_RELEASED: return " (released)";
  4508. case NETREG_DUMMY: return " (dummy)";
  4509. }
  4510. WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
  4511. return " (unknown)";
  4512. }
  4513. __printf(3, 4) __cold
  4514. void netdev_printk(const char *level, const struct net_device *dev,
  4515. const char *format, ...);
  4516. __printf(2, 3) __cold
  4517. void netdev_emerg(const struct net_device *dev, const char *format, ...);
  4518. __printf(2, 3) __cold
  4519. void netdev_alert(const struct net_device *dev, const char *format, ...);
  4520. __printf(2, 3) __cold
  4521. void netdev_crit(const struct net_device *dev, const char *format, ...);
  4522. __printf(2, 3) __cold
  4523. void netdev_err(const struct net_device *dev, const char *format, ...);
  4524. __printf(2, 3) __cold
  4525. void netdev_warn(const struct net_device *dev, const char *format, ...);
  4526. __printf(2, 3) __cold
  4527. void netdev_notice(const struct net_device *dev, const char *format, ...);
  4528. __printf(2, 3) __cold
  4529. void netdev_info(const struct net_device *dev, const char *format, ...);
  4530. #define netdev_level_once(level, dev, fmt, ...) \
  4531. do { \
  4532. static bool __print_once __read_mostly; \
  4533. \
  4534. if (!__print_once) { \
  4535. __print_once = true; \
  4536. netdev_printk(level, dev, fmt, ##__VA_ARGS__); \
  4537. } \
  4538. } while (0)
  4539. #define netdev_emerg_once(dev, fmt, ...) \
  4540. netdev_level_once(KERN_EMERG, dev, fmt, ##__VA_ARGS__)
  4541. #define netdev_alert_once(dev, fmt, ...) \
  4542. netdev_level_once(KERN_ALERT, dev, fmt, ##__VA_ARGS__)
  4543. #define netdev_crit_once(dev, fmt, ...) \
  4544. netdev_level_once(KERN_CRIT, dev, fmt, ##__VA_ARGS__)
  4545. #define netdev_err_once(dev, fmt, ...) \
  4546. netdev_level_once(KERN_ERR, dev, fmt, ##__VA_ARGS__)
  4547. #define netdev_warn_once(dev, fmt, ...) \
  4548. netdev_level_once(KERN_WARNING, dev, fmt, ##__VA_ARGS__)
  4549. #define netdev_notice_once(dev, fmt, ...) \
  4550. netdev_level_once(KERN_NOTICE, dev, fmt, ##__VA_ARGS__)
  4551. #define netdev_info_once(dev, fmt, ...) \
  4552. netdev_level_once(KERN_INFO, dev, fmt, ##__VA_ARGS__)
  4553. #define MODULE_ALIAS_NETDEV(device) \
  4554. MODULE_ALIAS("netdev-" device)
  4555. #if defined(CONFIG_DYNAMIC_DEBUG) || \
  4556. (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
  4557. #define netdev_dbg(__dev, format, args...) \
  4558. do { \
  4559. dynamic_netdev_dbg(__dev, format, ##args); \
  4560. } while (0)
  4561. #elif defined(DEBUG)
  4562. #define netdev_dbg(__dev, format, args...) \
  4563. netdev_printk(KERN_DEBUG, __dev, format, ##args)
  4564. #else
  4565. #define netdev_dbg(__dev, format, args...) \
  4566. ({ \
  4567. if (0) \
  4568. netdev_printk(KERN_DEBUG, __dev, format, ##args); \
  4569. })
  4570. #endif
  4571. #if defined(VERBOSE_DEBUG)
  4572. #define netdev_vdbg netdev_dbg
  4573. #else
  4574. #define netdev_vdbg(dev, format, args...) \
  4575. ({ \
  4576. if (0) \
  4577. netdev_printk(KERN_DEBUG, dev, format, ##args); \
  4578. 0; \
  4579. })
  4580. #endif
  4581. /*
  4582. * netdev_WARN() acts like dev_printk(), but with the key difference
  4583. * of using a WARN/WARN_ON to get the message out, including the
  4584. * file/line information and a backtrace.
  4585. */
  4586. #define netdev_WARN(dev, format, args...) \
  4587. WARN(1, "netdevice: %s%s: " format, netdev_name(dev), \
  4588. netdev_reg_state(dev), ##args)
  4589. #define netdev_WARN_ONCE(dev, format, args...) \
  4590. WARN_ONCE(1, "netdevice: %s%s: " format, netdev_name(dev), \
  4591. netdev_reg_state(dev), ##args)
  4592. /* netif printk helpers, similar to netdev_printk */
  4593. #define netif_printk(priv, type, level, dev, fmt, args...) \
  4594. do { \
  4595. if (netif_msg_##type(priv)) \
  4596. netdev_printk(level, (dev), fmt, ##args); \
  4597. } while (0)
  4598. #define netif_level(level, priv, type, dev, fmt, args...) \
  4599. do { \
  4600. if (netif_msg_##type(priv)) \
  4601. netdev_##level(dev, fmt, ##args); \
  4602. } while (0)
  4603. #define netif_emerg(priv, type, dev, fmt, args...) \
  4604. netif_level(emerg, priv, type, dev, fmt, ##args)
  4605. #define netif_alert(priv, type, dev, fmt, args...) \
  4606. netif_level(alert, priv, type, dev, fmt, ##args)
  4607. #define netif_crit(priv, type, dev, fmt, args...) \
  4608. netif_level(crit, priv, type, dev, fmt, ##args)
  4609. #define netif_err(priv, type, dev, fmt, args...) \
  4610. netif_level(err, priv, type, dev, fmt, ##args)
  4611. #define netif_warn(priv, type, dev, fmt, args...) \
  4612. netif_level(warn, priv, type, dev, fmt, ##args)
  4613. #define netif_notice(priv, type, dev, fmt, args...) \
  4614. netif_level(notice, priv, type, dev, fmt, ##args)
  4615. #define netif_info(priv, type, dev, fmt, args...) \
  4616. netif_level(info, priv, type, dev, fmt, ##args)
  4617. #if defined(CONFIG_DYNAMIC_DEBUG) || \
  4618. (defined(CONFIG_DYNAMIC_DEBUG_CORE) && defined(DYNAMIC_DEBUG_MODULE))
  4619. #define netif_dbg(priv, type, netdev, format, args...) \
  4620. do { \
  4621. if (netif_msg_##type(priv)) \
  4622. dynamic_netdev_dbg(netdev, format, ##args); \
  4623. } while (0)
  4624. #elif defined(DEBUG)
  4625. #define netif_dbg(priv, type, dev, format, args...) \
  4626. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
  4627. #else
  4628. #define netif_dbg(priv, type, dev, format, args...) \
  4629. ({ \
  4630. if (0) \
  4631. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  4632. 0; \
  4633. })
  4634. #endif
  4635. /* if @cond then downgrade to debug, else print at @level */
  4636. #define netif_cond_dbg(priv, type, netdev, cond, level, fmt, args...) \
  4637. do { \
  4638. if (cond) \
  4639. netif_dbg(priv, type, netdev, fmt, ##args); \
  4640. else \
  4641. netif_ ## level(priv, type, netdev, fmt, ##args); \
  4642. } while (0)
  4643. #if defined(VERBOSE_DEBUG)
  4644. #define netif_vdbg netif_dbg
  4645. #else
  4646. #define netif_vdbg(priv, type, dev, format, args...) \
  4647. ({ \
  4648. if (0) \
  4649. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  4650. 0; \
  4651. })
  4652. #endif
  4653. /*
  4654. * The list of packet types we will receive (as opposed to discard)
  4655. * and the routines to invoke.
  4656. *
  4657. * Why 16. Because with 16 the only overlap we get on a hash of the
  4658. * low nibble of the protocol value is RARP/SNAP/X.25.
  4659. *
  4660. * 0800 IP
  4661. * 0001 802.3
  4662. * 0002 AX.25
  4663. * 0004 802.2
  4664. * 8035 RARP
  4665. * 0005 SNAP
  4666. * 0805 X.25
  4667. * 0806 ARP
  4668. * 8137 IPX
  4669. * 0009 Localtalk
  4670. * 86DD IPv6
  4671. */
  4672. #define PTYPE_HASH_SIZE (16)
  4673. #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
  4674. extern struct net_device *blackhole_netdev;
  4675. #endif /* _LINUX_NETDEVICE_H */