netdevice.h 132 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329
  1. /*
  2. * INET An implementation of the TCP/IP protocol suite for the LINUX
  3. * operating system. INET is implemented using the BSD Socket
  4. * interface as the means of communication with the user level.
  5. *
  6. * Definitions for the Interfaces handler.
  7. *
  8. * Version: @(#)dev.h 1.0.10 08/12/93
  9. *
  10. * Authors: Ross Biro
  11. * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  12. * Corey Minyard <wf-rch!minyard@relay.EU.net>
  13. * Donald J. Becker, <becker@cesdis.gsfc.nasa.gov>
  14. * Alan Cox, <alan@lxorguk.ukuu.org.uk>
  15. * Bjorn Ekwall. <bj0rn@blox.se>
  16. * Pekka Riikonen <priikone@poseidon.pspt.fi>
  17. *
  18. * This program is free software; you can redistribute it and/or
  19. * modify it under the terms of the GNU General Public License
  20. * as published by the Free Software Foundation; either version
  21. * 2 of the License, or (at your option) any later version.
  22. *
  23. * Moved to /usr/include/linux for NET3
  24. */
  25. #ifndef _LINUX_NETDEVICE_H
  26. #define _LINUX_NETDEVICE_H
  27. #include <linux/timer.h>
  28. #include <linux/bug.h>
  29. #include <linux/delay.h>
  30. #include <linux/atomic.h>
  31. #include <linux/prefetch.h>
  32. #include <asm/cache.h>
  33. #include <asm/byteorder.h>
  34. #include <linux/percpu.h>
  35. #include <linux/rculist.h>
  36. #include <linux/dmaengine.h>
  37. #include <linux/workqueue.h>
  38. #include <linux/dynamic_queue_limits.h>
  39. #include <linux/ethtool.h>
  40. #include <net/net_namespace.h>
  41. #include <net/dsa.h>
  42. #ifdef CONFIG_DCB
  43. #include <net/dcbnl.h>
  44. #endif
  45. #include <net/netprio_cgroup.h>
  46. #include <linux/netdev_features.h>
  47. #include <linux/neighbour.h>
  48. #include <uapi/linux/netdevice.h>
  49. #include <uapi/linux/if_bonding.h>
  50. #include <uapi/linux/pkt_cls.h>
  51. struct netpoll_info;
  52. struct device;
  53. struct phy_device;
  54. /* 802.11 specific */
  55. struct wireless_dev;
  56. /* 802.15.4 specific */
  57. struct wpan_dev;
  58. struct mpls_dev;
  59. void netdev_set_default_ethtool_ops(struct net_device *dev,
  60. const struct ethtool_ops *ops);
  61. /* Backlog congestion levels */
  62. #define NET_RX_SUCCESS 0 /* keep 'em coming, baby */
  63. #define NET_RX_DROP 1 /* packet dropped */
  64. /*
  65. * Transmit return codes: transmit return codes originate from three different
  66. * namespaces:
  67. *
  68. * - qdisc return codes
  69. * - driver transmit return codes
  70. * - errno values
  71. *
  72. * Drivers are allowed to return any one of those in their hard_start_xmit()
  73. * function. Real network devices commonly used with qdiscs should only return
  74. * the driver transmit return codes though - when qdiscs are used, the actual
  75. * transmission happens asynchronously, so the value is not propagated to
  76. * higher layers. Virtual network devices transmit synchronously; in this case
  77. * the driver transmit return codes are consumed by dev_queue_xmit(), and all
  78. * others are propagated to higher layers.
  79. */
  80. /* qdisc ->enqueue() return codes. */
  81. #define NET_XMIT_SUCCESS 0x00
  82. #define NET_XMIT_DROP 0x01 /* skb dropped */
  83. #define NET_XMIT_CN 0x02 /* congestion notification */
  84. #define NET_XMIT_POLICED 0x03 /* skb is shot by police */
  85. #define NET_XMIT_MASK 0x0f /* qdisc flags in net/sch_generic.h */
  86. /* NET_XMIT_CN is special. It does not guarantee that this packet is lost. It
  87. * indicates that the device will soon be dropping packets, or already drops
  88. * some packets of the same priority; prompting us to send less aggressively. */
  89. #define net_xmit_eval(e) ((e) == NET_XMIT_CN ? 0 : (e))
  90. #define net_xmit_errno(e) ((e) != NET_XMIT_CN ? -ENOBUFS : 0)
  91. /* Driver transmit return codes */
  92. #define NETDEV_TX_MASK 0xf0
  93. enum netdev_tx {
  94. __NETDEV_TX_MIN = INT_MIN, /* make sure enum is signed */
  95. NETDEV_TX_OK = 0x00, /* driver took care of packet */
  96. NETDEV_TX_BUSY = 0x10, /* driver tx path was busy*/
  97. };
  98. typedef enum netdev_tx netdev_tx_t;
  99. /*
  100. * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
  101. * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
  102. */
  103. static inline bool dev_xmit_complete(int rc)
  104. {
  105. /*
  106. * Positive cases with an skb consumed by a driver:
  107. * - successful transmission (rc == NETDEV_TX_OK)
  108. * - error while transmitting (rc < 0)
  109. * - error while queueing to a different device (rc & NET_XMIT_MASK)
  110. */
  111. if (likely(rc < NET_XMIT_MASK))
  112. return true;
  113. return false;
  114. }
  115. /*
  116. * Compute the worst-case header length according to the protocols
  117. * used.
  118. */
  119. #if defined(CONFIG_HYPERV_NET)
  120. # define LL_MAX_HEADER 128
  121. #elif defined(CONFIG_WLAN) || IS_ENABLED(CONFIG_AX25)
  122. # if defined(CONFIG_MAC80211_MESH)
  123. # define LL_MAX_HEADER 128
  124. # else
  125. # define LL_MAX_HEADER 96
  126. # endif
  127. #else
  128. # define LL_MAX_HEADER 32
  129. #endif
  130. #if !IS_ENABLED(CONFIG_NET_IPIP) && !IS_ENABLED(CONFIG_NET_IPGRE) && \
  131. !IS_ENABLED(CONFIG_IPV6_SIT) && !IS_ENABLED(CONFIG_IPV6_TUNNEL)
  132. #define MAX_HEADER LL_MAX_HEADER
  133. #else
  134. #define MAX_HEADER (LL_MAX_HEADER + 48)
  135. #endif
  136. /*
  137. * Old network device statistics. Fields are native words
  138. * (unsigned long) so they can be read and written atomically.
  139. */
  140. struct net_device_stats {
  141. unsigned long rx_packets;
  142. unsigned long tx_packets;
  143. unsigned long rx_bytes;
  144. unsigned long tx_bytes;
  145. unsigned long rx_errors;
  146. unsigned long tx_errors;
  147. unsigned long rx_dropped;
  148. unsigned long tx_dropped;
  149. unsigned long multicast;
  150. unsigned long collisions;
  151. unsigned long rx_length_errors;
  152. unsigned long rx_over_errors;
  153. unsigned long rx_crc_errors;
  154. unsigned long rx_frame_errors;
  155. unsigned long rx_fifo_errors;
  156. unsigned long rx_missed_errors;
  157. unsigned long tx_aborted_errors;
  158. unsigned long tx_carrier_errors;
  159. unsigned long tx_fifo_errors;
  160. unsigned long tx_heartbeat_errors;
  161. unsigned long tx_window_errors;
  162. unsigned long rx_compressed;
  163. unsigned long tx_compressed;
  164. };
  165. #include <linux/cache.h>
  166. #include <linux/skbuff.h>
  167. #ifdef CONFIG_RPS
  168. #include <linux/static_key.h>
  169. extern struct static_key rps_needed;
  170. #endif
  171. struct neighbour;
  172. struct neigh_parms;
  173. struct sk_buff;
  174. struct netdev_hw_addr {
  175. struct list_head list;
  176. unsigned char addr[MAX_ADDR_LEN];
  177. unsigned char type;
  178. #define NETDEV_HW_ADDR_T_LAN 1
  179. #define NETDEV_HW_ADDR_T_SAN 2
  180. #define NETDEV_HW_ADDR_T_SLAVE 3
  181. #define NETDEV_HW_ADDR_T_UNICAST 4
  182. #define NETDEV_HW_ADDR_T_MULTICAST 5
  183. bool global_use;
  184. int sync_cnt;
  185. int refcount;
  186. int synced;
  187. struct rcu_head rcu_head;
  188. };
  189. struct netdev_hw_addr_list {
  190. struct list_head list;
  191. int count;
  192. };
  193. #define netdev_hw_addr_list_count(l) ((l)->count)
  194. #define netdev_hw_addr_list_empty(l) (netdev_hw_addr_list_count(l) == 0)
  195. #define netdev_hw_addr_list_for_each(ha, l) \
  196. list_for_each_entry(ha, &(l)->list, list)
  197. #define netdev_uc_count(dev) netdev_hw_addr_list_count(&(dev)->uc)
  198. #define netdev_uc_empty(dev) netdev_hw_addr_list_empty(&(dev)->uc)
  199. #define netdev_for_each_uc_addr(ha, dev) \
  200. netdev_hw_addr_list_for_each(ha, &(dev)->uc)
  201. #define netdev_mc_count(dev) netdev_hw_addr_list_count(&(dev)->mc)
  202. #define netdev_mc_empty(dev) netdev_hw_addr_list_empty(&(dev)->mc)
  203. #define netdev_for_each_mc_addr(ha, dev) \
  204. netdev_hw_addr_list_for_each(ha, &(dev)->mc)
  205. struct hh_cache {
  206. u16 hh_len;
  207. u16 __pad;
  208. seqlock_t hh_lock;
  209. /* cached hardware header; allow for machine alignment needs. */
  210. #define HH_DATA_MOD 16
  211. #define HH_DATA_OFF(__len) \
  212. (HH_DATA_MOD - (((__len - 1) & (HH_DATA_MOD - 1)) + 1))
  213. #define HH_DATA_ALIGN(__len) \
  214. (((__len)+(HH_DATA_MOD-1))&~(HH_DATA_MOD - 1))
  215. unsigned long hh_data[HH_DATA_ALIGN(LL_MAX_HEADER) / sizeof(long)];
  216. };
  217. /* Reserve HH_DATA_MOD byte-aligned hard_header_len, but at least that much.
  218. * Alternative is:
  219. * dev->hard_header_len ? (dev->hard_header_len +
  220. * (HH_DATA_MOD - 1)) & ~(HH_DATA_MOD - 1) : 0
  221. *
  222. * We could use other alignment values, but we must maintain the
  223. * relationship HH alignment <= LL alignment.
  224. */
  225. #define LL_RESERVED_SPACE(dev) \
  226. ((((dev)->hard_header_len+(dev)->needed_headroom)&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  227. #define LL_RESERVED_SPACE_EXTRA(dev,extra) \
  228. ((((dev)->hard_header_len+(dev)->needed_headroom+(extra))&~(HH_DATA_MOD - 1)) + HH_DATA_MOD)
  229. struct header_ops {
  230. int (*create) (struct sk_buff *skb, struct net_device *dev,
  231. unsigned short type, const void *daddr,
  232. const void *saddr, unsigned int len);
  233. int (*parse)(const struct sk_buff *skb, unsigned char *haddr);
  234. int (*cache)(const struct neighbour *neigh, struct hh_cache *hh, __be16 type);
  235. void (*cache_update)(struct hh_cache *hh,
  236. const struct net_device *dev,
  237. const unsigned char *haddr);
  238. bool (*validate)(const char *ll_header, unsigned int len);
  239. };
  240. /* These flag bits are private to the generic network queueing
  241. * layer; they may not be explicitly referenced by any other
  242. * code.
  243. */
  244. enum netdev_state_t {
  245. __LINK_STATE_START,
  246. __LINK_STATE_PRESENT,
  247. __LINK_STATE_NOCARRIER,
  248. __LINK_STATE_LINKWATCH_PENDING,
  249. __LINK_STATE_DORMANT,
  250. };
  251. /*
  252. * This structure holds boot-time configured netdevice settings. They
  253. * are then used in the device probing.
  254. */
  255. struct netdev_boot_setup {
  256. char name[IFNAMSIZ];
  257. struct ifmap map;
  258. };
  259. #define NETDEV_BOOT_SETUP_MAX 8
  260. int __init netdev_boot_setup(char *str);
  261. /*
  262. * Structure for NAPI scheduling similar to tasklet but with weighting
  263. */
  264. struct napi_struct {
  265. /* The poll_list must only be managed by the entity which
  266. * changes the state of the NAPI_STATE_SCHED bit. This means
  267. * whoever atomically sets that bit can add this napi_struct
  268. * to the per-CPU poll_list, and whoever clears that bit
  269. * can remove from the list right before clearing the bit.
  270. */
  271. struct list_head poll_list;
  272. unsigned long state;
  273. int weight;
  274. unsigned int gro_count;
  275. int (*poll)(struct napi_struct *, int);
  276. #ifdef CONFIG_NETPOLL
  277. spinlock_t poll_lock;
  278. int poll_owner;
  279. #endif
  280. struct net_device *dev;
  281. struct sk_buff *gro_list;
  282. struct sk_buff *skb;
  283. struct hrtimer timer;
  284. struct list_head dev_list;
  285. struct hlist_node napi_hash_node;
  286. unsigned int napi_id;
  287. };
  288. enum {
  289. NAPI_STATE_SCHED, /* Poll is scheduled */
  290. NAPI_STATE_DISABLE, /* Disable pending */
  291. NAPI_STATE_NPSVC, /* Netpoll - don't dequeue from poll_list */
  292. NAPI_STATE_HASHED, /* In NAPI hash (busy polling possible) */
  293. NAPI_STATE_NO_BUSY_POLL,/* Do not add in napi_hash, no busy polling */
  294. };
  295. enum gro_result {
  296. GRO_MERGED,
  297. GRO_MERGED_FREE,
  298. GRO_HELD,
  299. GRO_NORMAL,
  300. GRO_DROP,
  301. };
  302. typedef enum gro_result gro_result_t;
  303. /*
  304. * enum rx_handler_result - Possible return values for rx_handlers.
  305. * @RX_HANDLER_CONSUMED: skb was consumed by rx_handler, do not process it
  306. * further.
  307. * @RX_HANDLER_ANOTHER: Do another round in receive path. This is indicated in
  308. * case skb->dev was changed by rx_handler.
  309. * @RX_HANDLER_EXACT: Force exact delivery, no wildcard.
  310. * @RX_HANDLER_PASS: Do nothing, pass the skb as if no rx_handler was called.
  311. *
  312. * rx_handlers are functions called from inside __netif_receive_skb(), to do
  313. * special processing of the skb, prior to delivery to protocol handlers.
  314. *
  315. * Currently, a net_device can only have a single rx_handler registered. Trying
  316. * to register a second rx_handler will return -EBUSY.
  317. *
  318. * To register a rx_handler on a net_device, use netdev_rx_handler_register().
  319. * To unregister a rx_handler on a net_device, use
  320. * netdev_rx_handler_unregister().
  321. *
  322. * Upon return, rx_handler is expected to tell __netif_receive_skb() what to
  323. * do with the skb.
  324. *
  325. * If the rx_handler consumed the skb in some way, it should return
  326. * RX_HANDLER_CONSUMED. This is appropriate when the rx_handler arranged for
  327. * the skb to be delivered in some other way.
  328. *
  329. * If the rx_handler changed skb->dev, to divert the skb to another
  330. * net_device, it should return RX_HANDLER_ANOTHER. The rx_handler for the
  331. * new device will be called if it exists.
  332. *
  333. * If the rx_handler decides the skb should be ignored, it should return
  334. * RX_HANDLER_EXACT. The skb will only be delivered to protocol handlers that
  335. * are registered on exact device (ptype->dev == skb->dev).
  336. *
  337. * If the rx_handler didn't change skb->dev, but wants the skb to be normally
  338. * delivered, it should return RX_HANDLER_PASS.
  339. *
  340. * A device without a registered rx_handler will behave as if rx_handler
  341. * returned RX_HANDLER_PASS.
  342. */
  343. enum rx_handler_result {
  344. RX_HANDLER_CONSUMED,
  345. RX_HANDLER_ANOTHER,
  346. RX_HANDLER_EXACT,
  347. RX_HANDLER_PASS,
  348. };
  349. typedef enum rx_handler_result rx_handler_result_t;
  350. typedef rx_handler_result_t rx_handler_func_t(struct sk_buff **pskb);
  351. void __napi_schedule(struct napi_struct *n);
  352. void __napi_schedule_irqoff(struct napi_struct *n);
  353. static inline bool napi_disable_pending(struct napi_struct *n)
  354. {
  355. return test_bit(NAPI_STATE_DISABLE, &n->state);
  356. }
  357. /**
  358. * napi_schedule_prep - check if NAPI can be scheduled
  359. * @n: NAPI context
  360. *
  361. * Test if NAPI routine is already running, and if not mark
  362. * it as running. This is used as a condition variable to
  363. * insure only one NAPI poll instance runs. We also make
  364. * sure there is no pending NAPI disable.
  365. */
  366. static inline bool napi_schedule_prep(struct napi_struct *n)
  367. {
  368. return !napi_disable_pending(n) &&
  369. !test_and_set_bit(NAPI_STATE_SCHED, &n->state);
  370. }
  371. /**
  372. * napi_schedule - schedule NAPI poll
  373. * @n: NAPI context
  374. *
  375. * Schedule NAPI poll routine to be called if it is not already
  376. * running.
  377. */
  378. static inline void napi_schedule(struct napi_struct *n)
  379. {
  380. if (napi_schedule_prep(n))
  381. __napi_schedule(n);
  382. }
  383. /**
  384. * napi_schedule_irqoff - schedule NAPI poll
  385. * @n: NAPI context
  386. *
  387. * Variant of napi_schedule(), assuming hard irqs are masked.
  388. */
  389. static inline void napi_schedule_irqoff(struct napi_struct *n)
  390. {
  391. if (napi_schedule_prep(n))
  392. __napi_schedule_irqoff(n);
  393. }
  394. /* Try to reschedule poll. Called by dev->poll() after napi_complete(). */
  395. static inline bool napi_reschedule(struct napi_struct *napi)
  396. {
  397. if (napi_schedule_prep(napi)) {
  398. __napi_schedule(napi);
  399. return true;
  400. }
  401. return false;
  402. }
  403. void __napi_complete(struct napi_struct *n);
  404. void napi_complete_done(struct napi_struct *n, int work_done);
  405. /**
  406. * napi_complete - NAPI processing complete
  407. * @n: NAPI context
  408. *
  409. * Mark NAPI processing as complete.
  410. * Consider using napi_complete_done() instead.
  411. */
  412. static inline void napi_complete(struct napi_struct *n)
  413. {
  414. return napi_complete_done(n, 0);
  415. }
  416. /**
  417. * napi_hash_add - add a NAPI to global hashtable
  418. * @napi: NAPI context
  419. *
  420. * Generate a new napi_id and store a @napi under it in napi_hash.
  421. * Used for busy polling (CONFIG_NET_RX_BUSY_POLL).
  422. * Note: This is normally automatically done from netif_napi_add(),
  423. * so might disappear in a future Linux version.
  424. */
  425. void napi_hash_add(struct napi_struct *napi);
  426. /**
  427. * napi_hash_del - remove a NAPI from global table
  428. * @napi: NAPI context
  429. *
  430. * Warning: caller must observe RCU grace period
  431. * before freeing memory containing @napi, if
  432. * this function returns true.
  433. * Note: core networking stack automatically calls it
  434. * from netif_napi_del().
  435. * Drivers might want to call this helper to combine all
  436. * the needed RCU grace periods into a single one.
  437. */
  438. bool napi_hash_del(struct napi_struct *napi);
  439. /**
  440. * napi_disable - prevent NAPI from scheduling
  441. * @n: NAPI context
  442. *
  443. * Stop NAPI from being scheduled on this context.
  444. * Waits till any outstanding processing completes.
  445. */
  446. void napi_disable(struct napi_struct *n);
  447. /**
  448. * napi_enable - enable NAPI scheduling
  449. * @n: NAPI context
  450. *
  451. * Resume NAPI from being scheduled on this context.
  452. * Must be paired with napi_disable.
  453. */
  454. static inline void napi_enable(struct napi_struct *n)
  455. {
  456. BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state));
  457. smp_mb__before_atomic();
  458. clear_bit(NAPI_STATE_SCHED, &n->state);
  459. clear_bit(NAPI_STATE_NPSVC, &n->state);
  460. }
  461. /**
  462. * napi_synchronize - wait until NAPI is not running
  463. * @n: NAPI context
  464. *
  465. * Wait until NAPI is done being scheduled on this context.
  466. * Waits till any outstanding processing completes but
  467. * does not disable future activations.
  468. */
  469. static inline void napi_synchronize(const struct napi_struct *n)
  470. {
  471. if (IS_ENABLED(CONFIG_SMP))
  472. while (test_bit(NAPI_STATE_SCHED, &n->state))
  473. msleep(1);
  474. else
  475. barrier();
  476. }
  477. enum netdev_queue_state_t {
  478. __QUEUE_STATE_DRV_XOFF,
  479. __QUEUE_STATE_STACK_XOFF,
  480. __QUEUE_STATE_FROZEN,
  481. };
  482. #define QUEUE_STATE_DRV_XOFF (1 << __QUEUE_STATE_DRV_XOFF)
  483. #define QUEUE_STATE_STACK_XOFF (1 << __QUEUE_STATE_STACK_XOFF)
  484. #define QUEUE_STATE_FROZEN (1 << __QUEUE_STATE_FROZEN)
  485. #define QUEUE_STATE_ANY_XOFF (QUEUE_STATE_DRV_XOFF | QUEUE_STATE_STACK_XOFF)
  486. #define QUEUE_STATE_ANY_XOFF_OR_FROZEN (QUEUE_STATE_ANY_XOFF | \
  487. QUEUE_STATE_FROZEN)
  488. #define QUEUE_STATE_DRV_XOFF_OR_FROZEN (QUEUE_STATE_DRV_XOFF | \
  489. QUEUE_STATE_FROZEN)
  490. /*
  491. * __QUEUE_STATE_DRV_XOFF is used by drivers to stop the transmit queue. The
  492. * netif_tx_* functions below are used to manipulate this flag. The
  493. * __QUEUE_STATE_STACK_XOFF flag is used by the stack to stop the transmit
  494. * queue independently. The netif_xmit_*stopped functions below are called
  495. * to check if the queue has been stopped by the driver or stack (either
  496. * of the XOFF bits are set in the state). Drivers should not need to call
  497. * netif_xmit*stopped functions, they should only be using netif_tx_*.
  498. */
  499. struct netdev_queue {
  500. /*
  501. * read-mostly part
  502. */
  503. struct net_device *dev;
  504. struct Qdisc __rcu *qdisc;
  505. struct Qdisc *qdisc_sleeping;
  506. #ifdef CONFIG_SYSFS
  507. struct kobject kobj;
  508. #endif
  509. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  510. int numa_node;
  511. #endif
  512. unsigned long tx_maxrate;
  513. /*
  514. * Number of TX timeouts for this queue
  515. * (/sys/class/net/DEV/Q/trans_timeout)
  516. */
  517. unsigned long trans_timeout;
  518. /*
  519. * write-mostly part
  520. */
  521. spinlock_t _xmit_lock ____cacheline_aligned_in_smp;
  522. int xmit_lock_owner;
  523. /*
  524. * Time (in jiffies) of last Tx
  525. */
  526. unsigned long trans_start;
  527. unsigned long state;
  528. #ifdef CONFIG_BQL
  529. struct dql dql;
  530. #endif
  531. } ____cacheline_aligned_in_smp;
  532. static inline int netdev_queue_numa_node_read(const struct netdev_queue *q)
  533. {
  534. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  535. return q->numa_node;
  536. #else
  537. return NUMA_NO_NODE;
  538. #endif
  539. }
  540. static inline void netdev_queue_numa_node_write(struct netdev_queue *q, int node)
  541. {
  542. #if defined(CONFIG_XPS) && defined(CONFIG_NUMA)
  543. q->numa_node = node;
  544. #endif
  545. }
  546. #ifdef CONFIG_RPS
  547. /*
  548. * This structure holds an RPS map which can be of variable length. The
  549. * map is an array of CPUs.
  550. */
  551. struct rps_map {
  552. unsigned int len;
  553. struct rcu_head rcu;
  554. u16 cpus[0];
  555. };
  556. #define RPS_MAP_SIZE(_num) (sizeof(struct rps_map) + ((_num) * sizeof(u16)))
  557. /*
  558. * The rps_dev_flow structure contains the mapping of a flow to a CPU, the
  559. * tail pointer for that CPU's input queue at the time of last enqueue, and
  560. * a hardware filter index.
  561. */
  562. struct rps_dev_flow {
  563. u16 cpu;
  564. u16 filter;
  565. unsigned int last_qtail;
  566. };
  567. #define RPS_NO_FILTER 0xffff
  568. /*
  569. * The rps_dev_flow_table structure contains a table of flow mappings.
  570. */
  571. struct rps_dev_flow_table {
  572. unsigned int mask;
  573. struct rcu_head rcu;
  574. struct rps_dev_flow flows[0];
  575. };
  576. #define RPS_DEV_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_dev_flow_table) + \
  577. ((_num) * sizeof(struct rps_dev_flow)))
  578. /*
  579. * The rps_sock_flow_table contains mappings of flows to the last CPU
  580. * on which they were processed by the application (set in recvmsg).
  581. * Each entry is a 32bit value. Upper part is the high-order bits
  582. * of flow hash, lower part is CPU number.
  583. * rps_cpu_mask is used to partition the space, depending on number of
  584. * possible CPUs : rps_cpu_mask = roundup_pow_of_two(nr_cpu_ids) - 1
  585. * For example, if 64 CPUs are possible, rps_cpu_mask = 0x3f,
  586. * meaning we use 32-6=26 bits for the hash.
  587. */
  588. struct rps_sock_flow_table {
  589. u32 mask;
  590. u32 ents[0] ____cacheline_aligned_in_smp;
  591. };
  592. #define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
  593. #define RPS_NO_CPU 0xffff
  594. extern u32 rps_cpu_mask;
  595. extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
  596. static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
  597. u32 hash)
  598. {
  599. if (table && hash) {
  600. unsigned int index = hash & table->mask;
  601. u32 val = hash & ~rps_cpu_mask;
  602. /* We only give a hint, preemption can change CPU under us */
  603. val |= raw_smp_processor_id();
  604. if (table->ents[index] != val)
  605. table->ents[index] = val;
  606. }
  607. }
  608. #ifdef CONFIG_RFS_ACCEL
  609. bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
  610. u16 filter_id);
  611. #endif
  612. #endif /* CONFIG_RPS */
  613. /* This structure contains an instance of an RX queue. */
  614. struct netdev_rx_queue {
  615. #ifdef CONFIG_RPS
  616. struct rps_map __rcu *rps_map;
  617. struct rps_dev_flow_table __rcu *rps_flow_table;
  618. #endif
  619. struct kobject kobj;
  620. struct net_device *dev;
  621. } ____cacheline_aligned_in_smp;
  622. /*
  623. * RX queue sysfs structures and functions.
  624. */
  625. struct rx_queue_attribute {
  626. struct attribute attr;
  627. ssize_t (*show)(struct netdev_rx_queue *queue,
  628. struct rx_queue_attribute *attr, char *buf);
  629. ssize_t (*store)(struct netdev_rx_queue *queue,
  630. struct rx_queue_attribute *attr, const char *buf, size_t len);
  631. };
  632. #ifdef CONFIG_XPS
  633. /*
  634. * This structure holds an XPS map which can be of variable length. The
  635. * map is an array of queues.
  636. */
  637. struct xps_map {
  638. unsigned int len;
  639. unsigned int alloc_len;
  640. struct rcu_head rcu;
  641. u16 queues[0];
  642. };
  643. #define XPS_MAP_SIZE(_num) (sizeof(struct xps_map) + ((_num) * sizeof(u16)))
  644. #define XPS_MIN_MAP_ALLOC ((L1_CACHE_ALIGN(offsetof(struct xps_map, queues[1])) \
  645. - sizeof(struct xps_map)) / sizeof(u16))
  646. /*
  647. * This structure holds all XPS maps for device. Maps are indexed by CPU.
  648. */
  649. struct xps_dev_maps {
  650. struct rcu_head rcu;
  651. struct xps_map __rcu *cpu_map[0];
  652. };
  653. #define XPS_DEV_MAPS_SIZE (sizeof(struct xps_dev_maps) + \
  654. (nr_cpu_ids * sizeof(struct xps_map *)))
  655. #endif /* CONFIG_XPS */
  656. #define TC_MAX_QUEUE 16
  657. #define TC_BITMASK 15
  658. /* HW offloaded queuing disciplines txq count and offset maps */
  659. struct netdev_tc_txq {
  660. u16 count;
  661. u16 offset;
  662. };
  663. #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE)
  664. /*
  665. * This structure is to hold information about the device
  666. * configured to run FCoE protocol stack.
  667. */
  668. struct netdev_fcoe_hbainfo {
  669. char manufacturer[64];
  670. char serial_number[64];
  671. char hardware_version[64];
  672. char driver_version[64];
  673. char optionrom_version[64];
  674. char firmware_version[64];
  675. char model[256];
  676. char model_description[256];
  677. };
  678. #endif
  679. #define MAX_PHYS_ITEM_ID_LEN 32
  680. /* This structure holds a unique identifier to identify some
  681. * physical item (port for example) used by a netdevice.
  682. */
  683. struct netdev_phys_item_id {
  684. unsigned char id[MAX_PHYS_ITEM_ID_LEN];
  685. unsigned char id_len;
  686. };
  687. static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
  688. struct netdev_phys_item_id *b)
  689. {
  690. return a->id_len == b->id_len &&
  691. memcmp(a->id, b->id, a->id_len) == 0;
  692. }
  693. typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  694. struct sk_buff *skb);
  695. /* These structures hold the attributes of qdisc and classifiers
  696. * that are being passed to the netdevice through the setup_tc op.
  697. */
  698. enum {
  699. TC_SETUP_MQPRIO,
  700. TC_SETUP_CLSU32,
  701. TC_SETUP_CLSFLOWER,
  702. };
  703. struct tc_cls_u32_offload;
  704. struct tc_to_netdev {
  705. unsigned int type;
  706. union {
  707. u8 tc;
  708. struct tc_cls_u32_offload *cls_u32;
  709. struct tc_cls_flower_offload *cls_flower;
  710. };
  711. };
  712. /*
  713. * This structure defines the management hooks for network devices.
  714. * The following hooks can be defined; unless noted otherwise, they are
  715. * optional and can be filled with a null pointer.
  716. *
  717. * int (*ndo_init)(struct net_device *dev);
  718. * This function is called once when a network device is registered.
  719. * The network device can use this for any late stage initialization
  720. * or semantic validation. It can fail with an error code which will
  721. * be propagated back to register_netdev.
  722. *
  723. * void (*ndo_uninit)(struct net_device *dev);
  724. * This function is called when device is unregistered or when registration
  725. * fails. It is not called if init fails.
  726. *
  727. * int (*ndo_open)(struct net_device *dev);
  728. * This function is called when a network device transitions to the up
  729. * state.
  730. *
  731. * int (*ndo_stop)(struct net_device *dev);
  732. * This function is called when a network device transitions to the down
  733. * state.
  734. *
  735. * netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  736. * struct net_device *dev);
  737. * Called when a packet needs to be transmitted.
  738. * Returns NETDEV_TX_OK. Can return NETDEV_TX_BUSY, but you should stop
  739. * the queue before that can happen; it's for obsolete devices and weird
  740. * corner cases, but the stack really does a non-trivial amount
  741. * of useless work if you return NETDEV_TX_BUSY.
  742. * Required; cannot be NULL.
  743. *
  744. * netdev_features_t (*ndo_fix_features)(struct net_device *dev,
  745. * netdev_features_t features);
  746. * Adjusts the requested feature flags according to device-specific
  747. * constraints, and returns the resulting flags. Must not modify
  748. * the device state.
  749. *
  750. * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
  751. * void *accel_priv, select_queue_fallback_t fallback);
  752. * Called to decide which queue to use when device supports multiple
  753. * transmit queues.
  754. *
  755. * void (*ndo_change_rx_flags)(struct net_device *dev, int flags);
  756. * This function is called to allow device receiver to make
  757. * changes to configuration when multicast or promiscuous is enabled.
  758. *
  759. * void (*ndo_set_rx_mode)(struct net_device *dev);
  760. * This function is called device changes address list filtering.
  761. * If driver handles unicast address filtering, it should set
  762. * IFF_UNICAST_FLT in its priv_flags.
  763. *
  764. * int (*ndo_set_mac_address)(struct net_device *dev, void *addr);
  765. * This function is called when the Media Access Control address
  766. * needs to be changed. If this interface is not defined, the
  767. * MAC address can not be changed.
  768. *
  769. * int (*ndo_validate_addr)(struct net_device *dev);
  770. * Test if Media Access Control address is valid for the device.
  771. *
  772. * int (*ndo_do_ioctl)(struct net_device *dev, struct ifreq *ifr, int cmd);
  773. * Called when a user requests an ioctl which can't be handled by
  774. * the generic interface code. If not defined ioctls return
  775. * not supported error code.
  776. *
  777. * int (*ndo_set_config)(struct net_device *dev, struct ifmap *map);
  778. * Used to set network devices bus interface parameters. This interface
  779. * is retained for legacy reasons; new devices should use the bus
  780. * interface (PCI) for low level management.
  781. *
  782. * int (*ndo_change_mtu)(struct net_device *dev, int new_mtu);
  783. * Called when a user wants to change the Maximum Transfer Unit
  784. * of a device. If not defined, any request to change MTU will
  785. * will return an error.
  786. *
  787. * void (*ndo_tx_timeout)(struct net_device *dev);
  788. * Callback used when the transmitter has not made any progress
  789. * for dev->watchdog ticks.
  790. *
  791. * struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
  792. * struct rtnl_link_stats64 *storage);
  793. * struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  794. * Called when a user wants to get the network device usage
  795. * statistics. Drivers must do one of the following:
  796. * 1. Define @ndo_get_stats64 to fill in a zero-initialised
  797. * rtnl_link_stats64 structure passed by the caller.
  798. * 2. Define @ndo_get_stats to update a net_device_stats structure
  799. * (which should normally be dev->stats) and return a pointer to
  800. * it. The structure may be changed asynchronously only if each
  801. * field is written atomically.
  802. * 3. Update dev->stats asynchronously and atomically, and define
  803. * neither operation.
  804. *
  805. * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
  806. * If device supports VLAN filtering this function is called when a
  807. * VLAN id is registered.
  808. *
  809. * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
  810. * If device supports VLAN filtering this function is called when a
  811. * VLAN id is unregistered.
  812. *
  813. * void (*ndo_poll_controller)(struct net_device *dev);
  814. *
  815. * SR-IOV management functions.
  816. * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  817. * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
  818. * int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
  819. * int max_tx_rate);
  820. * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
  821. * int (*ndo_set_vf_trust)(struct net_device *dev, int vf, bool setting);
  822. * int (*ndo_get_vf_config)(struct net_device *dev,
  823. * int vf, struct ifla_vf_info *ivf);
  824. * int (*ndo_set_vf_link_state)(struct net_device *dev, int vf, int link_state);
  825. * int (*ndo_set_vf_port)(struct net_device *dev, int vf,
  826. * struct nlattr *port[]);
  827. *
  828. * Enable or disable the VF ability to query its RSS Redirection Table and
  829. * Hash Key. This is needed since on some devices VF share this information
  830. * with PF and querying it may introduce a theoretical security risk.
  831. * int (*ndo_set_vf_rss_query_en)(struct net_device *dev, int vf, bool setting);
  832. * int (*ndo_get_vf_port)(struct net_device *dev, int vf, struct sk_buff *skb);
  833. * int (*ndo_setup_tc)(struct net_device *dev, u8 tc)
  834. * Called to setup 'tc' number of traffic classes in the net device. This
  835. * is always called from the stack with the rtnl lock held and netif tx
  836. * queues stopped. This allows the netdevice to perform queue management
  837. * safely.
  838. *
  839. * Fiber Channel over Ethernet (FCoE) offload functions.
  840. * int (*ndo_fcoe_enable)(struct net_device *dev);
  841. * Called when the FCoE protocol stack wants to start using LLD for FCoE
  842. * so the underlying device can perform whatever needed configuration or
  843. * initialization to support acceleration of FCoE traffic.
  844. *
  845. * int (*ndo_fcoe_disable)(struct net_device *dev);
  846. * Called when the FCoE protocol stack wants to stop using LLD for FCoE
  847. * so the underlying device can perform whatever needed clean-ups to
  848. * stop supporting acceleration of FCoE traffic.
  849. *
  850. * int (*ndo_fcoe_ddp_setup)(struct net_device *dev, u16 xid,
  851. * struct scatterlist *sgl, unsigned int sgc);
  852. * Called when the FCoE Initiator wants to initialize an I/O that
  853. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  854. * perform necessary setup and returns 1 to indicate the device is set up
  855. * successfully to perform DDP on this I/O, otherwise this returns 0.
  856. *
  857. * int (*ndo_fcoe_ddp_done)(struct net_device *dev, u16 xid);
  858. * Called when the FCoE Initiator/Target is done with the DDPed I/O as
  859. * indicated by the FC exchange id 'xid', so the underlying device can
  860. * clean up and reuse resources for later DDP requests.
  861. *
  862. * int (*ndo_fcoe_ddp_target)(struct net_device *dev, u16 xid,
  863. * struct scatterlist *sgl, unsigned int sgc);
  864. * Called when the FCoE Target wants to initialize an I/O that
  865. * is a possible candidate for Direct Data Placement (DDP). The LLD can
  866. * perform necessary setup and returns 1 to indicate the device is set up
  867. * successfully to perform DDP on this I/O, otherwise this returns 0.
  868. *
  869. * int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
  870. * struct netdev_fcoe_hbainfo *hbainfo);
  871. * Called when the FCoE Protocol stack wants information on the underlying
  872. * device. This information is utilized by the FCoE protocol stack to
  873. * register attributes with Fiber Channel management service as per the
  874. * FC-GS Fabric Device Management Information(FDMI) specification.
  875. *
  876. * int (*ndo_fcoe_get_wwn)(struct net_device *dev, u64 *wwn, int type);
  877. * Called when the underlying device wants to override default World Wide
  878. * Name (WWN) generation mechanism in FCoE protocol stack to pass its own
  879. * World Wide Port Name (WWPN) or World Wide Node Name (WWNN) to the FCoE
  880. * protocol stack to use.
  881. *
  882. * RFS acceleration.
  883. * int (*ndo_rx_flow_steer)(struct net_device *dev, const struct sk_buff *skb,
  884. * u16 rxq_index, u32 flow_id);
  885. * Set hardware filter for RFS. rxq_index is the target queue index;
  886. * flow_id is a flow ID to be passed to rps_may_expire_flow() later.
  887. * Return the filter ID on success, or a negative error code.
  888. *
  889. * Slave management functions (for bridge, bonding, etc).
  890. * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
  891. * Called to make another netdev an underling.
  892. *
  893. * int (*ndo_del_slave)(struct net_device *dev, struct net_device *slave_dev);
  894. * Called to release previously enslaved netdev.
  895. *
  896. * Feature/offload setting functions.
  897. * int (*ndo_set_features)(struct net_device *dev, netdev_features_t features);
  898. * Called to update device configuration to new features. Passed
  899. * feature set might be less than what was returned by ndo_fix_features()).
  900. * Must return >0 or -errno if it changed dev->features itself.
  901. *
  902. * int (*ndo_fdb_add)(struct ndmsg *ndm, struct nlattr *tb[],
  903. * struct net_device *dev,
  904. * const unsigned char *addr, u16 vid, u16 flags)
  905. * Adds an FDB entry to dev for addr.
  906. * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
  907. * struct net_device *dev,
  908. * const unsigned char *addr, u16 vid)
  909. * Deletes the FDB entry from dev coresponding to addr.
  910. * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
  911. * struct net_device *dev, struct net_device *filter_dev,
  912. * int idx)
  913. * Used to add FDB entries to dump requests. Implementers should add
  914. * entries to skb and update idx with the number of entries.
  915. *
  916. * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh,
  917. * u16 flags)
  918. * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
  919. * struct net_device *dev, u32 filter_mask,
  920. * int nlflags)
  921. * int (*ndo_bridge_dellink)(struct net_device *dev, struct nlmsghdr *nlh,
  922. * u16 flags);
  923. *
  924. * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
  925. * Called to change device carrier. Soft-devices (like dummy, team, etc)
  926. * which do not represent real hardware may define this to allow their
  927. * userspace components to manage their virtual carrier state. Devices
  928. * that determine carrier state from physical hardware properties (eg
  929. * network cables) or protocol-dependent mechanisms (eg
  930. * USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
  931. *
  932. * int (*ndo_get_phys_port_id)(struct net_device *dev,
  933. * struct netdev_phys_item_id *ppid);
  934. * Called to get ID of physical port of this device. If driver does
  935. * not implement this, it is assumed that the hw is not able to have
  936. * multiple net devices on single physical port.
  937. *
  938. * void (*ndo_add_vxlan_port)(struct net_device *dev,
  939. * sa_family_t sa_family, __be16 port);
  940. * Called by vxlan to notify a driver about the UDP port and socket
  941. * address family that vxlan is listening to. It is called only when
  942. * a new port starts listening. The operation is protected by the
  943. * vxlan_net->sock_lock.
  944. *
  945. * void (*ndo_add_geneve_port)(struct net_device *dev,
  946. * sa_family_t sa_family, __be16 port);
  947. * Called by geneve to notify a driver about the UDP port and socket
  948. * address family that geneve is listnening to. It is called only when
  949. * a new port starts listening. The operation is protected by the
  950. * geneve_net->sock_lock.
  951. *
  952. * void (*ndo_del_geneve_port)(struct net_device *dev,
  953. * sa_family_t sa_family, __be16 port);
  954. * Called by geneve to notify the driver about a UDP port and socket
  955. * address family that geneve is not listening to anymore. The operation
  956. * is protected by the geneve_net->sock_lock.
  957. *
  958. * void (*ndo_del_vxlan_port)(struct net_device *dev,
  959. * sa_family_t sa_family, __be16 port);
  960. * Called by vxlan to notify the driver about a UDP port and socket
  961. * address family that vxlan is not listening to anymore. The operation
  962. * is protected by the vxlan_net->sock_lock.
  963. *
  964. * void* (*ndo_dfwd_add_station)(struct net_device *pdev,
  965. * struct net_device *dev)
  966. * Called by upper layer devices to accelerate switching or other
  967. * station functionality into hardware. 'pdev is the lowerdev
  968. * to use for the offload and 'dev' is the net device that will
  969. * back the offload. Returns a pointer to the private structure
  970. * the upper layer will maintain.
  971. * void (*ndo_dfwd_del_station)(struct net_device *pdev, void *priv)
  972. * Called by upper layer device to delete the station created
  973. * by 'ndo_dfwd_add_station'. 'pdev' is the net device backing
  974. * the station and priv is the structure returned by the add
  975. * operation.
  976. * netdev_tx_t (*ndo_dfwd_start_xmit)(struct sk_buff *skb,
  977. * struct net_device *dev,
  978. * void *priv);
  979. * Callback to use for xmit over the accelerated station. This
  980. * is used in place of ndo_start_xmit on accelerated net
  981. * devices.
  982. * netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
  983. * struct net_device *dev
  984. * netdev_features_t features);
  985. * Called by core transmit path to determine if device is capable of
  986. * performing offload operations on a given packet. This is to give
  987. * the device an opportunity to implement any restrictions that cannot
  988. * be otherwise expressed by feature flags. The check is called with
  989. * the set of features that the stack has calculated and it returns
  990. * those the driver believes to be appropriate.
  991. * int (*ndo_set_tx_maxrate)(struct net_device *dev,
  992. * int queue_index, u32 maxrate);
  993. * Called when a user wants to set a max-rate limitation of specific
  994. * TX queue.
  995. * int (*ndo_get_iflink)(const struct net_device *dev);
  996. * Called to get the iflink value of this device.
  997. * void (*ndo_change_proto_down)(struct net_device *dev,
  998. * bool proto_down);
  999. * This function is used to pass protocol port error state information
  1000. * to the switch driver. The switch driver can react to the proto_down
  1001. * by doing a phys down on the associated switch port.
  1002. * int (*ndo_fill_metadata_dst)(struct net_device *dev, struct sk_buff *skb);
  1003. * This function is used to get egress tunnel information for given skb.
  1004. * This is useful for retrieving outer tunnel header parameters while
  1005. * sampling packet.
  1006. * void (*ndo_set_rx_headroom)(struct net_device *dev, int needed_headroom);
  1007. * This function is used to specify the headroom that the skb must
  1008. * consider when allocation skb during packet reception. Setting
  1009. * appropriate rx headroom value allows avoiding skb head copy on
  1010. * forward. Setting a negative value resets the rx headroom to the
  1011. * default value.
  1012. *
  1013. */
  1014. struct net_device_ops {
  1015. int (*ndo_init)(struct net_device *dev);
  1016. void (*ndo_uninit)(struct net_device *dev);
  1017. int (*ndo_open)(struct net_device *dev);
  1018. int (*ndo_stop)(struct net_device *dev);
  1019. netdev_tx_t (*ndo_start_xmit)(struct sk_buff *skb,
  1020. struct net_device *dev);
  1021. netdev_features_t (*ndo_features_check)(struct sk_buff *skb,
  1022. struct net_device *dev,
  1023. netdev_features_t features);
  1024. u16 (*ndo_select_queue)(struct net_device *dev,
  1025. struct sk_buff *skb,
  1026. void *accel_priv,
  1027. select_queue_fallback_t fallback);
  1028. void (*ndo_change_rx_flags)(struct net_device *dev,
  1029. int flags);
  1030. void (*ndo_set_rx_mode)(struct net_device *dev);
  1031. int (*ndo_set_mac_address)(struct net_device *dev,
  1032. void *addr);
  1033. int (*ndo_validate_addr)(struct net_device *dev);
  1034. int (*ndo_do_ioctl)(struct net_device *dev,
  1035. struct ifreq *ifr, int cmd);
  1036. int (*ndo_set_config)(struct net_device *dev,
  1037. struct ifmap *map);
  1038. int (*ndo_change_mtu)(struct net_device *dev,
  1039. int new_mtu);
  1040. int (*ndo_neigh_setup)(struct net_device *dev,
  1041. struct neigh_parms *);
  1042. void (*ndo_tx_timeout) (struct net_device *dev);
  1043. struct rtnl_link_stats64* (*ndo_get_stats64)(struct net_device *dev,
  1044. struct rtnl_link_stats64 *storage);
  1045. struct net_device_stats* (*ndo_get_stats)(struct net_device *dev);
  1046. int (*ndo_vlan_rx_add_vid)(struct net_device *dev,
  1047. __be16 proto, u16 vid);
  1048. int (*ndo_vlan_rx_kill_vid)(struct net_device *dev,
  1049. __be16 proto, u16 vid);
  1050. #ifdef CONFIG_NET_POLL_CONTROLLER
  1051. void (*ndo_poll_controller)(struct net_device *dev);
  1052. int (*ndo_netpoll_setup)(struct net_device *dev,
  1053. struct netpoll_info *info);
  1054. void (*ndo_netpoll_cleanup)(struct net_device *dev);
  1055. #endif
  1056. #ifdef CONFIG_NET_RX_BUSY_POLL
  1057. int (*ndo_busy_poll)(struct napi_struct *dev);
  1058. #endif
  1059. int (*ndo_set_vf_mac)(struct net_device *dev,
  1060. int queue, u8 *mac);
  1061. int (*ndo_set_vf_vlan)(struct net_device *dev,
  1062. int queue, u16 vlan, u8 qos);
  1063. int (*ndo_set_vf_rate)(struct net_device *dev,
  1064. int vf, int min_tx_rate,
  1065. int max_tx_rate);
  1066. int (*ndo_set_vf_spoofchk)(struct net_device *dev,
  1067. int vf, bool setting);
  1068. int (*ndo_set_vf_trust)(struct net_device *dev,
  1069. int vf, bool setting);
  1070. int (*ndo_get_vf_config)(struct net_device *dev,
  1071. int vf,
  1072. struct ifla_vf_info *ivf);
  1073. int (*ndo_set_vf_link_state)(struct net_device *dev,
  1074. int vf, int link_state);
  1075. int (*ndo_get_vf_stats)(struct net_device *dev,
  1076. int vf,
  1077. struct ifla_vf_stats
  1078. *vf_stats);
  1079. int (*ndo_set_vf_port)(struct net_device *dev,
  1080. int vf,
  1081. struct nlattr *port[]);
  1082. int (*ndo_get_vf_port)(struct net_device *dev,
  1083. int vf, struct sk_buff *skb);
  1084. int (*ndo_set_vf_guid)(struct net_device *dev,
  1085. int vf, u64 guid,
  1086. int guid_type);
  1087. int (*ndo_set_vf_rss_query_en)(
  1088. struct net_device *dev,
  1089. int vf, bool setting);
  1090. int (*ndo_setup_tc)(struct net_device *dev,
  1091. u32 handle,
  1092. __be16 protocol,
  1093. struct tc_to_netdev *tc);
  1094. #if IS_ENABLED(CONFIG_FCOE)
  1095. int (*ndo_fcoe_enable)(struct net_device *dev);
  1096. int (*ndo_fcoe_disable)(struct net_device *dev);
  1097. int (*ndo_fcoe_ddp_setup)(struct net_device *dev,
  1098. u16 xid,
  1099. struct scatterlist *sgl,
  1100. unsigned int sgc);
  1101. int (*ndo_fcoe_ddp_done)(struct net_device *dev,
  1102. u16 xid);
  1103. int (*ndo_fcoe_ddp_target)(struct net_device *dev,
  1104. u16 xid,
  1105. struct scatterlist *sgl,
  1106. unsigned int sgc);
  1107. int (*ndo_fcoe_get_hbainfo)(struct net_device *dev,
  1108. struct netdev_fcoe_hbainfo *hbainfo);
  1109. #endif
  1110. #if IS_ENABLED(CONFIG_LIBFCOE)
  1111. #define NETDEV_FCOE_WWNN 0
  1112. #define NETDEV_FCOE_WWPN 1
  1113. int (*ndo_fcoe_get_wwn)(struct net_device *dev,
  1114. u64 *wwn, int type);
  1115. #endif
  1116. #ifdef CONFIG_RFS_ACCEL
  1117. int (*ndo_rx_flow_steer)(struct net_device *dev,
  1118. const struct sk_buff *skb,
  1119. u16 rxq_index,
  1120. u32 flow_id);
  1121. #endif
  1122. int (*ndo_add_slave)(struct net_device *dev,
  1123. struct net_device *slave_dev);
  1124. int (*ndo_del_slave)(struct net_device *dev,
  1125. struct net_device *slave_dev);
  1126. netdev_features_t (*ndo_fix_features)(struct net_device *dev,
  1127. netdev_features_t features);
  1128. int (*ndo_set_features)(struct net_device *dev,
  1129. netdev_features_t features);
  1130. int (*ndo_neigh_construct)(struct neighbour *n);
  1131. void (*ndo_neigh_destroy)(struct neighbour *n);
  1132. int (*ndo_fdb_add)(struct ndmsg *ndm,
  1133. struct nlattr *tb[],
  1134. struct net_device *dev,
  1135. const unsigned char *addr,
  1136. u16 vid,
  1137. u16 flags);
  1138. int (*ndo_fdb_del)(struct ndmsg *ndm,
  1139. struct nlattr *tb[],
  1140. struct net_device *dev,
  1141. const unsigned char *addr,
  1142. u16 vid);
  1143. int (*ndo_fdb_dump)(struct sk_buff *skb,
  1144. struct netlink_callback *cb,
  1145. struct net_device *dev,
  1146. struct net_device *filter_dev,
  1147. int idx);
  1148. int (*ndo_bridge_setlink)(struct net_device *dev,
  1149. struct nlmsghdr *nlh,
  1150. u16 flags);
  1151. int (*ndo_bridge_getlink)(struct sk_buff *skb,
  1152. u32 pid, u32 seq,
  1153. struct net_device *dev,
  1154. u32 filter_mask,
  1155. int nlflags);
  1156. int (*ndo_bridge_dellink)(struct net_device *dev,
  1157. struct nlmsghdr *nlh,
  1158. u16 flags);
  1159. int (*ndo_change_carrier)(struct net_device *dev,
  1160. bool new_carrier);
  1161. int (*ndo_get_phys_port_id)(struct net_device *dev,
  1162. struct netdev_phys_item_id *ppid);
  1163. int (*ndo_get_phys_port_name)(struct net_device *dev,
  1164. char *name, size_t len);
  1165. void (*ndo_add_vxlan_port)(struct net_device *dev,
  1166. sa_family_t sa_family,
  1167. __be16 port);
  1168. void (*ndo_del_vxlan_port)(struct net_device *dev,
  1169. sa_family_t sa_family,
  1170. __be16 port);
  1171. void (*ndo_add_geneve_port)(struct net_device *dev,
  1172. sa_family_t sa_family,
  1173. __be16 port);
  1174. void (*ndo_del_geneve_port)(struct net_device *dev,
  1175. sa_family_t sa_family,
  1176. __be16 port);
  1177. void* (*ndo_dfwd_add_station)(struct net_device *pdev,
  1178. struct net_device *dev);
  1179. void (*ndo_dfwd_del_station)(struct net_device *pdev,
  1180. void *priv);
  1181. netdev_tx_t (*ndo_dfwd_start_xmit) (struct sk_buff *skb,
  1182. struct net_device *dev,
  1183. void *priv);
  1184. int (*ndo_get_lock_subclass)(struct net_device *dev);
  1185. int (*ndo_set_tx_maxrate)(struct net_device *dev,
  1186. int queue_index,
  1187. u32 maxrate);
  1188. int (*ndo_get_iflink)(const struct net_device *dev);
  1189. int (*ndo_change_proto_down)(struct net_device *dev,
  1190. bool proto_down);
  1191. int (*ndo_fill_metadata_dst)(struct net_device *dev,
  1192. struct sk_buff *skb);
  1193. void (*ndo_set_rx_headroom)(struct net_device *dev,
  1194. int needed_headroom);
  1195. };
  1196. /**
  1197. * enum net_device_priv_flags - &struct net_device priv_flags
  1198. *
  1199. * These are the &struct net_device, they are only set internally
  1200. * by drivers and used in the kernel. These flags are invisible to
  1201. * userspace; this means that the order of these flags can change
  1202. * during any kernel release.
  1203. *
  1204. * You should have a pretty good reason to be extending these flags.
  1205. *
  1206. * @IFF_802_1Q_VLAN: 802.1Q VLAN device
  1207. * @IFF_EBRIDGE: Ethernet bridging device
  1208. * @IFF_BONDING: bonding master or slave
  1209. * @IFF_ISATAP: ISATAP interface (RFC4214)
  1210. * @IFF_WAN_HDLC: WAN HDLC device
  1211. * @IFF_XMIT_DST_RELEASE: dev_hard_start_xmit() is allowed to
  1212. * release skb->dst
  1213. * @IFF_DONT_BRIDGE: disallow bridging this ether dev
  1214. * @IFF_DISABLE_NETPOLL: disable netpoll at run-time
  1215. * @IFF_MACVLAN_PORT: device used as macvlan port
  1216. * @IFF_BRIDGE_PORT: device used as bridge port
  1217. * @IFF_OVS_DATAPATH: device used as Open vSwitch datapath port
  1218. * @IFF_TX_SKB_SHARING: The interface supports sharing skbs on transmit
  1219. * @IFF_UNICAST_FLT: Supports unicast filtering
  1220. * @IFF_TEAM_PORT: device used as team port
  1221. * @IFF_SUPP_NOFCS: device supports sending custom FCS
  1222. * @IFF_LIVE_ADDR_CHANGE: device supports hardware address
  1223. * change when it's running
  1224. * @IFF_MACVLAN: Macvlan device
  1225. * @IFF_XMIT_DST_RELEASE_PERM: IFF_XMIT_DST_RELEASE not taking into account
  1226. * underlying stacked devices
  1227. * @IFF_IPVLAN_MASTER: IPvlan master device
  1228. * @IFF_IPVLAN_SLAVE: IPvlan slave device
  1229. * @IFF_L3MDEV_MASTER: device is an L3 master device
  1230. * @IFF_NO_QUEUE: device can run without qdisc attached
  1231. * @IFF_OPENVSWITCH: device is a Open vSwitch master
  1232. * @IFF_L3MDEV_SLAVE: device is enslaved to an L3 master device
  1233. * @IFF_TEAM: device is a team device
  1234. * @IFF_RXFH_CONFIGURED: device has had Rx Flow indirection table configured
  1235. * @IFF_PHONY_HEADROOM: the headroom value is controlled by an external
  1236. * entity (i.e. the master device for bridged veth)
  1237. * @IFF_MACSEC: device is a MACsec device
  1238. */
  1239. enum netdev_priv_flags {
  1240. IFF_802_1Q_VLAN = 1<<0,
  1241. IFF_EBRIDGE = 1<<1,
  1242. IFF_BONDING = 1<<2,
  1243. IFF_ISATAP = 1<<3,
  1244. IFF_WAN_HDLC = 1<<4,
  1245. IFF_XMIT_DST_RELEASE = 1<<5,
  1246. IFF_DONT_BRIDGE = 1<<6,
  1247. IFF_DISABLE_NETPOLL = 1<<7,
  1248. IFF_MACVLAN_PORT = 1<<8,
  1249. IFF_BRIDGE_PORT = 1<<9,
  1250. IFF_OVS_DATAPATH = 1<<10,
  1251. IFF_TX_SKB_SHARING = 1<<11,
  1252. IFF_UNICAST_FLT = 1<<12,
  1253. IFF_TEAM_PORT = 1<<13,
  1254. IFF_SUPP_NOFCS = 1<<14,
  1255. IFF_LIVE_ADDR_CHANGE = 1<<15,
  1256. IFF_MACVLAN = 1<<16,
  1257. IFF_XMIT_DST_RELEASE_PERM = 1<<17,
  1258. IFF_IPVLAN_MASTER = 1<<18,
  1259. IFF_IPVLAN_SLAVE = 1<<19,
  1260. IFF_L3MDEV_MASTER = 1<<20,
  1261. IFF_NO_QUEUE = 1<<21,
  1262. IFF_OPENVSWITCH = 1<<22,
  1263. IFF_L3MDEV_SLAVE = 1<<23,
  1264. IFF_TEAM = 1<<24,
  1265. IFF_RXFH_CONFIGURED = 1<<25,
  1266. IFF_PHONY_HEADROOM = 1<<26,
  1267. IFF_MACSEC = 1<<27,
  1268. };
  1269. #define IFF_802_1Q_VLAN IFF_802_1Q_VLAN
  1270. #define IFF_EBRIDGE IFF_EBRIDGE
  1271. #define IFF_BONDING IFF_BONDING
  1272. #define IFF_ISATAP IFF_ISATAP
  1273. #define IFF_WAN_HDLC IFF_WAN_HDLC
  1274. #define IFF_XMIT_DST_RELEASE IFF_XMIT_DST_RELEASE
  1275. #define IFF_DONT_BRIDGE IFF_DONT_BRIDGE
  1276. #define IFF_DISABLE_NETPOLL IFF_DISABLE_NETPOLL
  1277. #define IFF_MACVLAN_PORT IFF_MACVLAN_PORT
  1278. #define IFF_BRIDGE_PORT IFF_BRIDGE_PORT
  1279. #define IFF_OVS_DATAPATH IFF_OVS_DATAPATH
  1280. #define IFF_TX_SKB_SHARING IFF_TX_SKB_SHARING
  1281. #define IFF_UNICAST_FLT IFF_UNICAST_FLT
  1282. #define IFF_TEAM_PORT IFF_TEAM_PORT
  1283. #define IFF_SUPP_NOFCS IFF_SUPP_NOFCS
  1284. #define IFF_LIVE_ADDR_CHANGE IFF_LIVE_ADDR_CHANGE
  1285. #define IFF_MACVLAN IFF_MACVLAN
  1286. #define IFF_XMIT_DST_RELEASE_PERM IFF_XMIT_DST_RELEASE_PERM
  1287. #define IFF_IPVLAN_MASTER IFF_IPVLAN_MASTER
  1288. #define IFF_IPVLAN_SLAVE IFF_IPVLAN_SLAVE
  1289. #define IFF_L3MDEV_MASTER IFF_L3MDEV_MASTER
  1290. #define IFF_NO_QUEUE IFF_NO_QUEUE
  1291. #define IFF_OPENVSWITCH IFF_OPENVSWITCH
  1292. #define IFF_L3MDEV_SLAVE IFF_L3MDEV_SLAVE
  1293. #define IFF_TEAM IFF_TEAM
  1294. #define IFF_RXFH_CONFIGURED IFF_RXFH_CONFIGURED
  1295. #define IFF_MACSEC IFF_MACSEC
  1296. /**
  1297. * struct net_device - The DEVICE structure.
  1298. * Actually, this whole structure is a big mistake. It mixes I/O
  1299. * data with strictly "high-level" data, and it has to know about
  1300. * almost every data structure used in the INET module.
  1301. *
  1302. * @name: This is the first field of the "visible" part of this structure
  1303. * (i.e. as seen by users in the "Space.c" file). It is the name
  1304. * of the interface.
  1305. *
  1306. * @name_hlist: Device name hash chain, please keep it close to name[]
  1307. * @ifalias: SNMP alias
  1308. * @mem_end: Shared memory end
  1309. * @mem_start: Shared memory start
  1310. * @base_addr: Device I/O address
  1311. * @irq: Device IRQ number
  1312. *
  1313. * @carrier_changes: Stats to monitor carrier on<->off transitions
  1314. *
  1315. * @state: Generic network queuing layer state, see netdev_state_t
  1316. * @dev_list: The global list of network devices
  1317. * @napi_list: List entry used for polling NAPI devices
  1318. * @unreg_list: List entry when we are unregistering the
  1319. * device; see the function unregister_netdev
  1320. * @close_list: List entry used when we are closing the device
  1321. * @ptype_all: Device-specific packet handlers for all protocols
  1322. * @ptype_specific: Device-specific, protocol-specific packet handlers
  1323. *
  1324. * @adj_list: Directly linked devices, like slaves for bonding
  1325. * @all_adj_list: All linked devices, *including* neighbours
  1326. * @features: Currently active device features
  1327. * @hw_features: User-changeable features
  1328. *
  1329. * @wanted_features: User-requested features
  1330. * @vlan_features: Mask of features inheritable by VLAN devices
  1331. *
  1332. * @hw_enc_features: Mask of features inherited by encapsulating devices
  1333. * This field indicates what encapsulation
  1334. * offloads the hardware is capable of doing,
  1335. * and drivers will need to set them appropriately.
  1336. *
  1337. * @mpls_features: Mask of features inheritable by MPLS
  1338. *
  1339. * @ifindex: interface index
  1340. * @group: The group the device belongs to
  1341. *
  1342. * @stats: Statistics struct, which was left as a legacy, use
  1343. * rtnl_link_stats64 instead
  1344. *
  1345. * @rx_dropped: Dropped packets by core network,
  1346. * do not use this in drivers
  1347. * @tx_dropped: Dropped packets by core network,
  1348. * do not use this in drivers
  1349. * @rx_nohandler: nohandler dropped packets by core network on
  1350. * inactive devices, do not use this in drivers
  1351. *
  1352. * @wireless_handlers: List of functions to handle Wireless Extensions,
  1353. * instead of ioctl,
  1354. * see <net/iw_handler.h> for details.
  1355. * @wireless_data: Instance data managed by the core of wireless extensions
  1356. *
  1357. * @netdev_ops: Includes several pointers to callbacks,
  1358. * if one wants to override the ndo_*() functions
  1359. * @ethtool_ops: Management operations
  1360. * @header_ops: Includes callbacks for creating,parsing,caching,etc
  1361. * of Layer 2 headers.
  1362. *
  1363. * @flags: Interface flags (a la BSD)
  1364. * @priv_flags: Like 'flags' but invisible to userspace,
  1365. * see if.h for the definitions
  1366. * @gflags: Global flags ( kept as legacy )
  1367. * @padded: How much padding added by alloc_netdev()
  1368. * @operstate: RFC2863 operstate
  1369. * @link_mode: Mapping policy to operstate
  1370. * @if_port: Selectable AUI, TP, ...
  1371. * @dma: DMA channel
  1372. * @mtu: Interface MTU value
  1373. * @type: Interface hardware type
  1374. * @hard_header_len: Maximum hardware header length.
  1375. *
  1376. * @needed_headroom: Extra headroom the hardware may need, but not in all
  1377. * cases can this be guaranteed
  1378. * @needed_tailroom: Extra tailroom the hardware may need, but not in all
  1379. * cases can this be guaranteed. Some cases also use
  1380. * LL_MAX_HEADER instead to allocate the skb
  1381. *
  1382. * interface address info:
  1383. *
  1384. * @perm_addr: Permanent hw address
  1385. * @addr_assign_type: Hw address assignment type
  1386. * @addr_len: Hardware address length
  1387. * @neigh_priv_len; Used in neigh_alloc(),
  1388. * initialized only in atm/clip.c
  1389. * @dev_id: Used to differentiate devices that share
  1390. * the same link layer address
  1391. * @dev_port: Used to differentiate devices that share
  1392. * the same function
  1393. * @addr_list_lock: XXX: need comments on this one
  1394. * @uc_promisc: Counter that indicates promiscuous mode
  1395. * has been enabled due to the need to listen to
  1396. * additional unicast addresses in a device that
  1397. * does not implement ndo_set_rx_mode()
  1398. * @uc: unicast mac addresses
  1399. * @mc: multicast mac addresses
  1400. * @dev_addrs: list of device hw addresses
  1401. * @queues_kset: Group of all Kobjects in the Tx and RX queues
  1402. * @promiscuity: Number of times the NIC is told to work in
  1403. * promiscuous mode; if it becomes 0 the NIC will
  1404. * exit promiscuous mode
  1405. * @allmulti: Counter, enables or disables allmulticast mode
  1406. *
  1407. * @vlan_info: VLAN info
  1408. * @dsa_ptr: dsa specific data
  1409. * @tipc_ptr: TIPC specific data
  1410. * @atalk_ptr: AppleTalk link
  1411. * @ip_ptr: IPv4 specific data
  1412. * @dn_ptr: DECnet specific data
  1413. * @ip6_ptr: IPv6 specific data
  1414. * @ax25_ptr: AX.25 specific data
  1415. * @ieee80211_ptr: IEEE 802.11 specific data, assign before registering
  1416. *
  1417. * @last_rx: Time of last Rx
  1418. * @dev_addr: Hw address (before bcast,
  1419. * because most packets are unicast)
  1420. *
  1421. * @_rx: Array of RX queues
  1422. * @num_rx_queues: Number of RX queues
  1423. * allocated at register_netdev() time
  1424. * @real_num_rx_queues: Number of RX queues currently active in device
  1425. *
  1426. * @rx_handler: handler for received packets
  1427. * @rx_handler_data: XXX: need comments on this one
  1428. * @ingress_queue: XXX: need comments on this one
  1429. * @broadcast: hw bcast address
  1430. *
  1431. * @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,
  1432. * indexed by RX queue number. Assigned by driver.
  1433. * This must only be set if the ndo_rx_flow_steer
  1434. * operation is defined
  1435. * @index_hlist: Device index hash chain
  1436. *
  1437. * @_tx: Array of TX queues
  1438. * @num_tx_queues: Number of TX queues allocated at alloc_netdev_mq() time
  1439. * @real_num_tx_queues: Number of TX queues currently active in device
  1440. * @qdisc: Root qdisc from userspace point of view
  1441. * @tx_queue_len: Max frames per queue allowed
  1442. * @tx_global_lock: XXX: need comments on this one
  1443. *
  1444. * @xps_maps: XXX: need comments on this one
  1445. *
  1446. * @offload_fwd_mark: Offload device fwding mark
  1447. *
  1448. * @watchdog_timeo: Represents the timeout that is used by
  1449. * the watchdog (see dev_watchdog())
  1450. * @watchdog_timer: List of timers
  1451. *
  1452. * @pcpu_refcnt: Number of references to this device
  1453. * @todo_list: Delayed register/unregister
  1454. * @link_watch_list: XXX: need comments on this one
  1455. *
  1456. * @reg_state: Register/unregister state machine
  1457. * @dismantle: Device is going to be freed
  1458. * @rtnl_link_state: This enum represents the phases of creating
  1459. * a new link
  1460. *
  1461. * @destructor: Called from unregister,
  1462. * can be used to call free_netdev
  1463. * @npinfo: XXX: need comments on this one
  1464. * @nd_net: Network namespace this network device is inside
  1465. *
  1466. * @ml_priv: Mid-layer private
  1467. * @lstats: Loopback statistics
  1468. * @tstats: Tunnel statistics
  1469. * @dstats: Dummy statistics
  1470. * @vstats: Virtual ethernet statistics
  1471. *
  1472. * @garp_port: GARP
  1473. * @mrp_port: MRP
  1474. *
  1475. * @dev: Class/net/name entry
  1476. * @sysfs_groups: Space for optional device, statistics and wireless
  1477. * sysfs groups
  1478. *
  1479. * @sysfs_rx_queue_group: Space for optional per-rx queue attributes
  1480. * @rtnl_link_ops: Rtnl_link_ops
  1481. *
  1482. * @gso_max_size: Maximum size of generic segmentation offload
  1483. * @gso_max_segs: Maximum number of segments that can be passed to the
  1484. * NIC for GSO
  1485. *
  1486. * @dcbnl_ops: Data Center Bridging netlink ops
  1487. * @num_tc: Number of traffic classes in the net device
  1488. * @tc_to_txq: XXX: need comments on this one
  1489. * @prio_tc_map XXX: need comments on this one
  1490. *
  1491. * @fcoe_ddp_xid: Max exchange id for FCoE LRO by ddp
  1492. *
  1493. * @priomap: XXX: need comments on this one
  1494. * @phydev: Physical device may attach itself
  1495. * for hardware timestamping
  1496. *
  1497. * @qdisc_tx_busylock: XXX: need comments on this one
  1498. *
  1499. * @proto_down: protocol port state information can be sent to the
  1500. * switch driver and used to set the phys state of the
  1501. * switch port.
  1502. *
  1503. * FIXME: cleanup struct net_device such that network protocol info
  1504. * moves out.
  1505. */
  1506. struct net_device {
  1507. char name[IFNAMSIZ];
  1508. struct hlist_node name_hlist;
  1509. char *ifalias;
  1510. /*
  1511. * I/O specific fields
  1512. * FIXME: Merge these and struct ifmap into one
  1513. */
  1514. unsigned long mem_end;
  1515. unsigned long mem_start;
  1516. unsigned long base_addr;
  1517. int irq;
  1518. atomic_t carrier_changes;
  1519. /*
  1520. * Some hardware also needs these fields (state,dev_list,
  1521. * napi_list,unreg_list,close_list) but they are not
  1522. * part of the usual set specified in Space.c.
  1523. */
  1524. unsigned long state;
  1525. struct list_head dev_list;
  1526. struct list_head napi_list;
  1527. struct list_head unreg_list;
  1528. struct list_head close_list;
  1529. struct list_head ptype_all;
  1530. struct list_head ptype_specific;
  1531. struct {
  1532. struct list_head upper;
  1533. struct list_head lower;
  1534. } adj_list;
  1535. struct {
  1536. struct list_head upper;
  1537. struct list_head lower;
  1538. } all_adj_list;
  1539. netdev_features_t features;
  1540. netdev_features_t hw_features;
  1541. netdev_features_t wanted_features;
  1542. netdev_features_t vlan_features;
  1543. netdev_features_t hw_enc_features;
  1544. netdev_features_t mpls_features;
  1545. netdev_features_t gso_partial_features;
  1546. int ifindex;
  1547. int group;
  1548. struct net_device_stats stats;
  1549. atomic_long_t rx_dropped;
  1550. atomic_long_t tx_dropped;
  1551. atomic_long_t rx_nohandler;
  1552. #ifdef CONFIG_WIRELESS_EXT
  1553. const struct iw_handler_def *wireless_handlers;
  1554. struct iw_public_data *wireless_data;
  1555. #endif
  1556. const struct net_device_ops *netdev_ops;
  1557. const struct ethtool_ops *ethtool_ops;
  1558. #ifdef CONFIG_NET_SWITCHDEV
  1559. const struct switchdev_ops *switchdev_ops;
  1560. #endif
  1561. #ifdef CONFIG_NET_L3_MASTER_DEV
  1562. const struct l3mdev_ops *l3mdev_ops;
  1563. #endif
  1564. const struct header_ops *header_ops;
  1565. unsigned int flags;
  1566. unsigned int priv_flags;
  1567. unsigned short gflags;
  1568. unsigned short padded;
  1569. unsigned char operstate;
  1570. unsigned char link_mode;
  1571. unsigned char if_port;
  1572. unsigned char dma;
  1573. unsigned int mtu;
  1574. unsigned short type;
  1575. unsigned short hard_header_len;
  1576. unsigned short needed_headroom;
  1577. unsigned short needed_tailroom;
  1578. /* Interface address info. */
  1579. unsigned char perm_addr[MAX_ADDR_LEN];
  1580. unsigned char addr_assign_type;
  1581. unsigned char addr_len;
  1582. unsigned short neigh_priv_len;
  1583. unsigned short dev_id;
  1584. unsigned short dev_port;
  1585. spinlock_t addr_list_lock;
  1586. unsigned char name_assign_type;
  1587. bool uc_promisc;
  1588. struct netdev_hw_addr_list uc;
  1589. struct netdev_hw_addr_list mc;
  1590. struct netdev_hw_addr_list dev_addrs;
  1591. #ifdef CONFIG_SYSFS
  1592. struct kset *queues_kset;
  1593. #endif
  1594. unsigned int promiscuity;
  1595. unsigned int allmulti;
  1596. /* Protocol-specific pointers */
  1597. #if IS_ENABLED(CONFIG_VLAN_8021Q)
  1598. struct vlan_info __rcu *vlan_info;
  1599. #endif
  1600. #if IS_ENABLED(CONFIG_NET_DSA)
  1601. struct dsa_switch_tree *dsa_ptr;
  1602. #endif
  1603. #if IS_ENABLED(CONFIG_TIPC)
  1604. struct tipc_bearer __rcu *tipc_ptr;
  1605. #endif
  1606. void *atalk_ptr;
  1607. struct in_device __rcu *ip_ptr;
  1608. struct dn_dev __rcu *dn_ptr;
  1609. struct inet6_dev __rcu *ip6_ptr;
  1610. void *ax25_ptr;
  1611. struct wireless_dev *ieee80211_ptr;
  1612. struct wpan_dev *ieee802154_ptr;
  1613. #if IS_ENABLED(CONFIG_MPLS_ROUTING)
  1614. struct mpls_dev __rcu *mpls_ptr;
  1615. #endif
  1616. /*
  1617. * Cache lines mostly used on receive path (including eth_type_trans())
  1618. */
  1619. unsigned long last_rx;
  1620. /* Interface address info used in eth_type_trans() */
  1621. unsigned char *dev_addr;
  1622. #ifdef CONFIG_SYSFS
  1623. struct netdev_rx_queue *_rx;
  1624. unsigned int num_rx_queues;
  1625. unsigned int real_num_rx_queues;
  1626. #endif
  1627. unsigned long gro_flush_timeout;
  1628. rx_handler_func_t __rcu *rx_handler;
  1629. void __rcu *rx_handler_data;
  1630. #ifdef CONFIG_NET_CLS_ACT
  1631. struct tcf_proto __rcu *ingress_cl_list;
  1632. #endif
  1633. struct netdev_queue __rcu *ingress_queue;
  1634. #ifdef CONFIG_NETFILTER_INGRESS
  1635. struct list_head nf_hooks_ingress;
  1636. #endif
  1637. unsigned char broadcast[MAX_ADDR_LEN];
  1638. #ifdef CONFIG_RFS_ACCEL
  1639. struct cpu_rmap *rx_cpu_rmap;
  1640. #endif
  1641. struct hlist_node index_hlist;
  1642. /*
  1643. * Cache lines mostly used on transmit path
  1644. */
  1645. struct netdev_queue *_tx ____cacheline_aligned_in_smp;
  1646. unsigned int num_tx_queues;
  1647. unsigned int real_num_tx_queues;
  1648. struct Qdisc *qdisc;
  1649. unsigned long tx_queue_len;
  1650. spinlock_t tx_global_lock;
  1651. int watchdog_timeo;
  1652. #ifdef CONFIG_XPS
  1653. struct xps_dev_maps __rcu *xps_maps;
  1654. #endif
  1655. #ifdef CONFIG_NET_CLS_ACT
  1656. struct tcf_proto __rcu *egress_cl_list;
  1657. #endif
  1658. #ifdef CONFIG_NET_SWITCHDEV
  1659. u32 offload_fwd_mark;
  1660. #endif
  1661. /* These may be needed for future network-power-down code. */
  1662. struct timer_list watchdog_timer;
  1663. int __percpu *pcpu_refcnt;
  1664. struct list_head todo_list;
  1665. struct list_head link_watch_list;
  1666. enum { NETREG_UNINITIALIZED=0,
  1667. NETREG_REGISTERED, /* completed register_netdevice */
  1668. NETREG_UNREGISTERING, /* called unregister_netdevice */
  1669. NETREG_UNREGISTERED, /* completed unregister todo */
  1670. NETREG_RELEASED, /* called free_netdev */
  1671. NETREG_DUMMY, /* dummy device for NAPI poll */
  1672. } reg_state:8;
  1673. bool dismantle;
  1674. enum {
  1675. RTNL_LINK_INITIALIZED,
  1676. RTNL_LINK_INITIALIZING,
  1677. } rtnl_link_state:16;
  1678. void (*destructor)(struct net_device *dev);
  1679. #ifdef CONFIG_NETPOLL
  1680. struct netpoll_info __rcu *npinfo;
  1681. #endif
  1682. possible_net_t nd_net;
  1683. /* mid-layer private */
  1684. union {
  1685. void *ml_priv;
  1686. struct pcpu_lstats __percpu *lstats;
  1687. struct pcpu_sw_netstats __percpu *tstats;
  1688. struct pcpu_dstats __percpu *dstats;
  1689. struct pcpu_vstats __percpu *vstats;
  1690. };
  1691. struct garp_port __rcu *garp_port;
  1692. struct mrp_port __rcu *mrp_port;
  1693. struct device dev;
  1694. const struct attribute_group *sysfs_groups[4];
  1695. const struct attribute_group *sysfs_rx_queue_group;
  1696. const struct rtnl_link_ops *rtnl_link_ops;
  1697. /* for setting kernel sock attribute on TCP connection setup */
  1698. #define GSO_MAX_SIZE 65536
  1699. unsigned int gso_max_size;
  1700. #define GSO_MAX_SEGS 65535
  1701. u16 gso_max_segs;
  1702. #ifdef CONFIG_DCB
  1703. const struct dcbnl_rtnl_ops *dcbnl_ops;
  1704. #endif
  1705. u8 num_tc;
  1706. struct netdev_tc_txq tc_to_txq[TC_MAX_QUEUE];
  1707. u8 prio_tc_map[TC_BITMASK + 1];
  1708. #if IS_ENABLED(CONFIG_FCOE)
  1709. unsigned int fcoe_ddp_xid;
  1710. #endif
  1711. #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
  1712. struct netprio_map __rcu *priomap;
  1713. #endif
  1714. struct phy_device *phydev;
  1715. struct lock_class_key *qdisc_tx_busylock;
  1716. bool proto_down;
  1717. };
  1718. #define to_net_dev(d) container_of(d, struct net_device, dev)
  1719. #define NETDEV_ALIGN 32
  1720. static inline
  1721. int netdev_get_prio_tc_map(const struct net_device *dev, u32 prio)
  1722. {
  1723. return dev->prio_tc_map[prio & TC_BITMASK];
  1724. }
  1725. static inline
  1726. int netdev_set_prio_tc_map(struct net_device *dev, u8 prio, u8 tc)
  1727. {
  1728. if (tc >= dev->num_tc)
  1729. return -EINVAL;
  1730. dev->prio_tc_map[prio & TC_BITMASK] = tc & TC_BITMASK;
  1731. return 0;
  1732. }
  1733. static inline
  1734. void netdev_reset_tc(struct net_device *dev)
  1735. {
  1736. dev->num_tc = 0;
  1737. memset(dev->tc_to_txq, 0, sizeof(dev->tc_to_txq));
  1738. memset(dev->prio_tc_map, 0, sizeof(dev->prio_tc_map));
  1739. }
  1740. static inline
  1741. int netdev_set_tc_queue(struct net_device *dev, u8 tc, u16 count, u16 offset)
  1742. {
  1743. if (tc >= dev->num_tc)
  1744. return -EINVAL;
  1745. dev->tc_to_txq[tc].count = count;
  1746. dev->tc_to_txq[tc].offset = offset;
  1747. return 0;
  1748. }
  1749. static inline
  1750. int netdev_set_num_tc(struct net_device *dev, u8 num_tc)
  1751. {
  1752. if (num_tc > TC_MAX_QUEUE)
  1753. return -EINVAL;
  1754. dev->num_tc = num_tc;
  1755. return 0;
  1756. }
  1757. static inline
  1758. int netdev_get_num_tc(struct net_device *dev)
  1759. {
  1760. return dev->num_tc;
  1761. }
  1762. static inline
  1763. struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
  1764. unsigned int index)
  1765. {
  1766. return &dev->_tx[index];
  1767. }
  1768. static inline struct netdev_queue *skb_get_tx_queue(const struct net_device *dev,
  1769. const struct sk_buff *skb)
  1770. {
  1771. return netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
  1772. }
  1773. static inline void netdev_for_each_tx_queue(struct net_device *dev,
  1774. void (*f)(struct net_device *,
  1775. struct netdev_queue *,
  1776. void *),
  1777. void *arg)
  1778. {
  1779. unsigned int i;
  1780. for (i = 0; i < dev->num_tx_queues; i++)
  1781. f(dev, &dev->_tx[i], arg);
  1782. }
  1783. struct netdev_queue *netdev_pick_tx(struct net_device *dev,
  1784. struct sk_buff *skb,
  1785. void *accel_priv);
  1786. /* returns the headroom that the master device needs to take in account
  1787. * when forwarding to this dev
  1788. */
  1789. static inline unsigned netdev_get_fwd_headroom(struct net_device *dev)
  1790. {
  1791. return dev->priv_flags & IFF_PHONY_HEADROOM ? 0 : dev->needed_headroom;
  1792. }
  1793. static inline void netdev_set_rx_headroom(struct net_device *dev, int new_hr)
  1794. {
  1795. if (dev->netdev_ops->ndo_set_rx_headroom)
  1796. dev->netdev_ops->ndo_set_rx_headroom(dev, new_hr);
  1797. }
  1798. /* set the device rx headroom to the dev's default */
  1799. static inline void netdev_reset_rx_headroom(struct net_device *dev)
  1800. {
  1801. netdev_set_rx_headroom(dev, -1);
  1802. }
  1803. /*
  1804. * Net namespace inlines
  1805. */
  1806. static inline
  1807. struct net *dev_net(const struct net_device *dev)
  1808. {
  1809. return read_pnet(&dev->nd_net);
  1810. }
  1811. static inline
  1812. void dev_net_set(struct net_device *dev, struct net *net)
  1813. {
  1814. write_pnet(&dev->nd_net, net);
  1815. }
  1816. static inline bool netdev_uses_dsa(struct net_device *dev)
  1817. {
  1818. #if IS_ENABLED(CONFIG_NET_DSA)
  1819. if (dev->dsa_ptr != NULL)
  1820. return dsa_uses_tagged_protocol(dev->dsa_ptr);
  1821. #endif
  1822. return false;
  1823. }
  1824. /**
  1825. * netdev_priv - access network device private data
  1826. * @dev: network device
  1827. *
  1828. * Get network device private data
  1829. */
  1830. static inline void *netdev_priv(const struct net_device *dev)
  1831. {
  1832. return (char *)dev + ALIGN(sizeof(struct net_device), NETDEV_ALIGN);
  1833. }
  1834. /* Set the sysfs physical device reference for the network logical device
  1835. * if set prior to registration will cause a symlink during initialization.
  1836. */
  1837. #define SET_NETDEV_DEV(net, pdev) ((net)->dev.parent = (pdev))
  1838. /* Set the sysfs device type for the network logical device to allow
  1839. * fine-grained identification of different network device types. For
  1840. * example Ethernet, Wireless LAN, Bluetooth, WiMAX etc.
  1841. */
  1842. #define SET_NETDEV_DEVTYPE(net, devtype) ((net)->dev.type = (devtype))
  1843. /* Default NAPI poll() weight
  1844. * Device drivers are strongly advised to not use bigger value
  1845. */
  1846. #define NAPI_POLL_WEIGHT 64
  1847. /**
  1848. * netif_napi_add - initialize a NAPI context
  1849. * @dev: network device
  1850. * @napi: NAPI context
  1851. * @poll: polling function
  1852. * @weight: default weight
  1853. *
  1854. * netif_napi_add() must be used to initialize a NAPI context prior to calling
  1855. * *any* of the other NAPI-related functions.
  1856. */
  1857. void netif_napi_add(struct net_device *dev, struct napi_struct *napi,
  1858. int (*poll)(struct napi_struct *, int), int weight);
  1859. /**
  1860. * netif_tx_napi_add - initialize a NAPI context
  1861. * @dev: network device
  1862. * @napi: NAPI context
  1863. * @poll: polling function
  1864. * @weight: default weight
  1865. *
  1866. * This variant of netif_napi_add() should be used from drivers using NAPI
  1867. * to exclusively poll a TX queue.
  1868. * This will avoid we add it into napi_hash[], thus polluting this hash table.
  1869. */
  1870. static inline void netif_tx_napi_add(struct net_device *dev,
  1871. struct napi_struct *napi,
  1872. int (*poll)(struct napi_struct *, int),
  1873. int weight)
  1874. {
  1875. set_bit(NAPI_STATE_NO_BUSY_POLL, &napi->state);
  1876. netif_napi_add(dev, napi, poll, weight);
  1877. }
  1878. /**
  1879. * netif_napi_del - remove a NAPI context
  1880. * @napi: NAPI context
  1881. *
  1882. * netif_napi_del() removes a NAPI context from the network device NAPI list
  1883. */
  1884. void netif_napi_del(struct napi_struct *napi);
  1885. struct napi_gro_cb {
  1886. /* Virtual address of skb_shinfo(skb)->frags[0].page + offset. */
  1887. void *frag0;
  1888. /* Length of frag0. */
  1889. unsigned int frag0_len;
  1890. /* This indicates where we are processing relative to skb->data. */
  1891. int data_offset;
  1892. /* This is non-zero if the packet cannot be merged with the new skb. */
  1893. u16 flush;
  1894. /* Save the IP ID here and check when we get to the transport layer */
  1895. u16 flush_id;
  1896. /* Number of segments aggregated. */
  1897. u16 count;
  1898. /* Start offset for remote checksum offload */
  1899. u16 gro_remcsum_start;
  1900. /* jiffies when first packet was created/queued */
  1901. unsigned long age;
  1902. /* Used in ipv6_gro_receive() and foo-over-udp */
  1903. u16 proto;
  1904. /* This is non-zero if the packet may be of the same flow. */
  1905. u8 same_flow:1;
  1906. /* Used in tunnel GRO receive */
  1907. u8 encap_mark:1;
  1908. /* GRO checksum is valid */
  1909. u8 csum_valid:1;
  1910. /* Number of checksums via CHECKSUM_UNNECESSARY */
  1911. u8 csum_cnt:3;
  1912. /* Free the skb? */
  1913. u8 free:2;
  1914. #define NAPI_GRO_FREE 1
  1915. #define NAPI_GRO_FREE_STOLEN_HEAD 2
  1916. /* Used in foo-over-udp, set in udp[46]_gro_receive */
  1917. u8 is_ipv6:1;
  1918. /* Used in GRE, set in fou/gue_gro_receive */
  1919. u8 is_fou:1;
  1920. /* Used to determine if flush_id can be ignored */
  1921. u8 is_atomic:1;
  1922. /* 5 bit hole */
  1923. /* used to support CHECKSUM_COMPLETE for tunneling protocols */
  1924. __wsum csum;
  1925. /* used in skb_gro_receive() slow path */
  1926. struct sk_buff *last;
  1927. };
  1928. #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
  1929. struct packet_type {
  1930. __be16 type; /* This is really htons(ether_type). */
  1931. struct net_device *dev; /* NULL is wildcarded here */
  1932. int (*func) (struct sk_buff *,
  1933. struct net_device *,
  1934. struct packet_type *,
  1935. struct net_device *);
  1936. bool (*id_match)(struct packet_type *ptype,
  1937. struct sock *sk);
  1938. void *af_packet_priv;
  1939. struct list_head list;
  1940. };
  1941. struct offload_callbacks {
  1942. struct sk_buff *(*gso_segment)(struct sk_buff *skb,
  1943. netdev_features_t features);
  1944. struct sk_buff **(*gro_receive)(struct sk_buff **head,
  1945. struct sk_buff *skb);
  1946. int (*gro_complete)(struct sk_buff *skb, int nhoff);
  1947. };
  1948. struct packet_offload {
  1949. __be16 type; /* This is really htons(ether_type). */
  1950. u16 priority;
  1951. struct offload_callbacks callbacks;
  1952. struct list_head list;
  1953. };
  1954. /* often modified stats are per-CPU, other are shared (netdev->stats) */
  1955. struct pcpu_sw_netstats {
  1956. u64 rx_packets;
  1957. u64 rx_bytes;
  1958. u64 tx_packets;
  1959. u64 tx_bytes;
  1960. struct u64_stats_sync syncp;
  1961. };
  1962. #define __netdev_alloc_pcpu_stats(type, gfp) \
  1963. ({ \
  1964. typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
  1965. if (pcpu_stats) { \
  1966. int __cpu; \
  1967. for_each_possible_cpu(__cpu) { \
  1968. typeof(type) *stat; \
  1969. stat = per_cpu_ptr(pcpu_stats, __cpu); \
  1970. u64_stats_init(&stat->syncp); \
  1971. } \
  1972. } \
  1973. pcpu_stats; \
  1974. })
  1975. #define netdev_alloc_pcpu_stats(type) \
  1976. __netdev_alloc_pcpu_stats(type, GFP_KERNEL)
  1977. enum netdev_lag_tx_type {
  1978. NETDEV_LAG_TX_TYPE_UNKNOWN,
  1979. NETDEV_LAG_TX_TYPE_RANDOM,
  1980. NETDEV_LAG_TX_TYPE_BROADCAST,
  1981. NETDEV_LAG_TX_TYPE_ROUNDROBIN,
  1982. NETDEV_LAG_TX_TYPE_ACTIVEBACKUP,
  1983. NETDEV_LAG_TX_TYPE_HASH,
  1984. };
  1985. struct netdev_lag_upper_info {
  1986. enum netdev_lag_tx_type tx_type;
  1987. };
  1988. struct netdev_lag_lower_state_info {
  1989. u8 link_up : 1,
  1990. tx_enabled : 1;
  1991. };
  1992. #include <linux/notifier.h>
  1993. /* netdevice notifier chain. Please remember to update the rtnetlink
  1994. * notification exclusion list in rtnetlink_event() when adding new
  1995. * types.
  1996. */
  1997. #define NETDEV_UP 0x0001 /* For now you can't veto a device up/down */
  1998. #define NETDEV_DOWN 0x0002
  1999. #define NETDEV_REBOOT 0x0003 /* Tell a protocol stack a network interface
  2000. detected a hardware crash and restarted
  2001. - we can use this eg to kick tcp sessions
  2002. once done */
  2003. #define NETDEV_CHANGE 0x0004 /* Notify device state change */
  2004. #define NETDEV_REGISTER 0x0005
  2005. #define NETDEV_UNREGISTER 0x0006
  2006. #define NETDEV_CHANGEMTU 0x0007 /* notify after mtu change happened */
  2007. #define NETDEV_CHANGEADDR 0x0008
  2008. #define NETDEV_GOING_DOWN 0x0009
  2009. #define NETDEV_CHANGENAME 0x000A
  2010. #define NETDEV_FEAT_CHANGE 0x000B
  2011. #define NETDEV_BONDING_FAILOVER 0x000C
  2012. #define NETDEV_PRE_UP 0x000D
  2013. #define NETDEV_PRE_TYPE_CHANGE 0x000E
  2014. #define NETDEV_POST_TYPE_CHANGE 0x000F
  2015. #define NETDEV_POST_INIT 0x0010
  2016. #define NETDEV_UNREGISTER_FINAL 0x0011
  2017. #define NETDEV_RELEASE 0x0012
  2018. #define NETDEV_NOTIFY_PEERS 0x0013
  2019. #define NETDEV_JOIN 0x0014
  2020. #define NETDEV_CHANGEUPPER 0x0015
  2021. #define NETDEV_RESEND_IGMP 0x0016
  2022. #define NETDEV_PRECHANGEMTU 0x0017 /* notify before mtu change happened */
  2023. #define NETDEV_CHANGEINFODATA 0x0018
  2024. #define NETDEV_BONDING_INFO 0x0019
  2025. #define NETDEV_PRECHANGEUPPER 0x001A
  2026. #define NETDEV_CHANGELOWERSTATE 0x001B
  2027. #define NETDEV_OFFLOAD_PUSH_VXLAN 0x001C
  2028. #define NETDEV_OFFLOAD_PUSH_GENEVE 0x001D
  2029. int register_netdevice_notifier(struct notifier_block *nb);
  2030. int unregister_netdevice_notifier(struct notifier_block *nb);
  2031. struct netdev_notifier_info {
  2032. struct net_device *dev;
  2033. };
  2034. struct netdev_notifier_change_info {
  2035. struct netdev_notifier_info info; /* must be first */
  2036. unsigned int flags_changed;
  2037. };
  2038. struct netdev_notifier_changeupper_info {
  2039. struct netdev_notifier_info info; /* must be first */
  2040. struct net_device *upper_dev; /* new upper dev */
  2041. bool master; /* is upper dev master */
  2042. bool linking; /* is the notification for link or unlink */
  2043. void *upper_info; /* upper dev info */
  2044. };
  2045. struct netdev_notifier_changelowerstate_info {
  2046. struct netdev_notifier_info info; /* must be first */
  2047. void *lower_state_info; /* is lower dev state */
  2048. };
  2049. static inline void netdev_notifier_info_init(struct netdev_notifier_info *info,
  2050. struct net_device *dev)
  2051. {
  2052. info->dev = dev;
  2053. }
  2054. static inline struct net_device *
  2055. netdev_notifier_info_to_dev(const struct netdev_notifier_info *info)
  2056. {
  2057. return info->dev;
  2058. }
  2059. int call_netdevice_notifiers(unsigned long val, struct net_device *dev);
  2060. extern rwlock_t dev_base_lock; /* Device list lock */
  2061. #define for_each_netdev(net, d) \
  2062. list_for_each_entry(d, &(net)->dev_base_head, dev_list)
  2063. #define for_each_netdev_reverse(net, d) \
  2064. list_for_each_entry_reverse(d, &(net)->dev_base_head, dev_list)
  2065. #define for_each_netdev_rcu(net, d) \
  2066. list_for_each_entry_rcu(d, &(net)->dev_base_head, dev_list)
  2067. #define for_each_netdev_safe(net, d, n) \
  2068. list_for_each_entry_safe(d, n, &(net)->dev_base_head, dev_list)
  2069. #define for_each_netdev_continue(net, d) \
  2070. list_for_each_entry_continue(d, &(net)->dev_base_head, dev_list)
  2071. #define for_each_netdev_continue_rcu(net, d) \
  2072. list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
  2073. #define for_each_netdev_in_bond_rcu(bond, slave) \
  2074. for_each_netdev_rcu(&init_net, slave) \
  2075. if (netdev_master_upper_dev_get_rcu(slave) == (bond))
  2076. #define net_device_entry(lh) list_entry(lh, struct net_device, dev_list)
  2077. static inline struct net_device *next_net_device(struct net_device *dev)
  2078. {
  2079. struct list_head *lh;
  2080. struct net *net;
  2081. net = dev_net(dev);
  2082. lh = dev->dev_list.next;
  2083. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2084. }
  2085. static inline struct net_device *next_net_device_rcu(struct net_device *dev)
  2086. {
  2087. struct list_head *lh;
  2088. struct net *net;
  2089. net = dev_net(dev);
  2090. lh = rcu_dereference(list_next_rcu(&dev->dev_list));
  2091. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2092. }
  2093. static inline struct net_device *first_net_device(struct net *net)
  2094. {
  2095. return list_empty(&net->dev_base_head) ? NULL :
  2096. net_device_entry(net->dev_base_head.next);
  2097. }
  2098. static inline struct net_device *first_net_device_rcu(struct net *net)
  2099. {
  2100. struct list_head *lh = rcu_dereference(list_next_rcu(&net->dev_base_head));
  2101. return lh == &net->dev_base_head ? NULL : net_device_entry(lh);
  2102. }
  2103. int netdev_boot_setup_check(struct net_device *dev);
  2104. unsigned long netdev_boot_base(const char *prefix, int unit);
  2105. struct net_device *dev_getbyhwaddr_rcu(struct net *net, unsigned short type,
  2106. const char *hwaddr);
  2107. struct net_device *dev_getfirstbyhwtype(struct net *net, unsigned short type);
  2108. struct net_device *__dev_getfirstbyhwtype(struct net *net, unsigned short type);
  2109. void dev_add_pack(struct packet_type *pt);
  2110. void dev_remove_pack(struct packet_type *pt);
  2111. void __dev_remove_pack(struct packet_type *pt);
  2112. void dev_add_offload(struct packet_offload *po);
  2113. void dev_remove_offload(struct packet_offload *po);
  2114. int dev_get_iflink(const struct net_device *dev);
  2115. int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb);
  2116. struct net_device *__dev_get_by_flags(struct net *net, unsigned short flags,
  2117. unsigned short mask);
  2118. struct net_device *dev_get_by_name(struct net *net, const char *name);
  2119. struct net_device *dev_get_by_name_rcu(struct net *net, const char *name);
  2120. struct net_device *__dev_get_by_name(struct net *net, const char *name);
  2121. int dev_alloc_name(struct net_device *dev, const char *name);
  2122. int dev_open(struct net_device *dev);
  2123. int dev_close(struct net_device *dev);
  2124. int dev_close_many(struct list_head *head, bool unlink);
  2125. void dev_disable_lro(struct net_device *dev);
  2126. int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
  2127. int dev_queue_xmit(struct sk_buff *skb);
  2128. int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
  2129. int register_netdevice(struct net_device *dev);
  2130. void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
  2131. void unregister_netdevice_many(struct list_head *head);
  2132. static inline void unregister_netdevice(struct net_device *dev)
  2133. {
  2134. unregister_netdevice_queue(dev, NULL);
  2135. }
  2136. int netdev_refcnt_read(const struct net_device *dev);
  2137. void free_netdev(struct net_device *dev);
  2138. void netdev_freemem(struct net_device *dev);
  2139. void synchronize_net(void);
  2140. int init_dummy_netdev(struct net_device *dev);
  2141. DECLARE_PER_CPU(int, xmit_recursion);
  2142. static inline int dev_recursion_level(void)
  2143. {
  2144. return this_cpu_read(xmit_recursion);
  2145. }
  2146. struct net_device *dev_get_by_index(struct net *net, int ifindex);
  2147. struct net_device *__dev_get_by_index(struct net *net, int ifindex);
  2148. struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
  2149. int netdev_get_name(struct net *net, char *name, int ifindex);
  2150. int dev_restart(struct net_device *dev);
  2151. int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb);
  2152. static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
  2153. {
  2154. return NAPI_GRO_CB(skb)->data_offset;
  2155. }
  2156. static inline unsigned int skb_gro_len(const struct sk_buff *skb)
  2157. {
  2158. return skb->len - NAPI_GRO_CB(skb)->data_offset;
  2159. }
  2160. static inline void skb_gro_pull(struct sk_buff *skb, unsigned int len)
  2161. {
  2162. NAPI_GRO_CB(skb)->data_offset += len;
  2163. }
  2164. static inline void *skb_gro_header_fast(struct sk_buff *skb,
  2165. unsigned int offset)
  2166. {
  2167. return NAPI_GRO_CB(skb)->frag0 + offset;
  2168. }
  2169. static inline int skb_gro_header_hard(struct sk_buff *skb, unsigned int hlen)
  2170. {
  2171. return NAPI_GRO_CB(skb)->frag0_len < hlen;
  2172. }
  2173. static inline void *skb_gro_header_slow(struct sk_buff *skb, unsigned int hlen,
  2174. unsigned int offset)
  2175. {
  2176. if (!pskb_may_pull(skb, hlen))
  2177. return NULL;
  2178. NAPI_GRO_CB(skb)->frag0 = NULL;
  2179. NAPI_GRO_CB(skb)->frag0_len = 0;
  2180. return skb->data + offset;
  2181. }
  2182. static inline void *skb_gro_network_header(struct sk_buff *skb)
  2183. {
  2184. return (NAPI_GRO_CB(skb)->frag0 ?: skb->data) +
  2185. skb_network_offset(skb);
  2186. }
  2187. static inline void skb_gro_postpull_rcsum(struct sk_buff *skb,
  2188. const void *start, unsigned int len)
  2189. {
  2190. if (NAPI_GRO_CB(skb)->csum_valid)
  2191. NAPI_GRO_CB(skb)->csum = csum_sub(NAPI_GRO_CB(skb)->csum,
  2192. csum_partial(start, len, 0));
  2193. }
  2194. /* GRO checksum functions. These are logical equivalents of the normal
  2195. * checksum functions (in skbuff.h) except that they operate on the GRO
  2196. * offsets and fields in sk_buff.
  2197. */
  2198. __sum16 __skb_gro_checksum_complete(struct sk_buff *skb);
  2199. static inline bool skb_at_gro_remcsum_start(struct sk_buff *skb)
  2200. {
  2201. return (NAPI_GRO_CB(skb)->gro_remcsum_start == skb_gro_offset(skb));
  2202. }
  2203. static inline bool __skb_gro_checksum_validate_needed(struct sk_buff *skb,
  2204. bool zero_okay,
  2205. __sum16 check)
  2206. {
  2207. return ((skb->ip_summed != CHECKSUM_PARTIAL ||
  2208. skb_checksum_start_offset(skb) <
  2209. skb_gro_offset(skb)) &&
  2210. !skb_at_gro_remcsum_start(skb) &&
  2211. NAPI_GRO_CB(skb)->csum_cnt == 0 &&
  2212. (!zero_okay || check));
  2213. }
  2214. static inline __sum16 __skb_gro_checksum_validate_complete(struct sk_buff *skb,
  2215. __wsum psum)
  2216. {
  2217. if (NAPI_GRO_CB(skb)->csum_valid &&
  2218. !csum_fold(csum_add(psum, NAPI_GRO_CB(skb)->csum)))
  2219. return 0;
  2220. NAPI_GRO_CB(skb)->csum = psum;
  2221. return __skb_gro_checksum_complete(skb);
  2222. }
  2223. static inline void skb_gro_incr_csum_unnecessary(struct sk_buff *skb)
  2224. {
  2225. if (NAPI_GRO_CB(skb)->csum_cnt > 0) {
  2226. /* Consume a checksum from CHECKSUM_UNNECESSARY */
  2227. NAPI_GRO_CB(skb)->csum_cnt--;
  2228. } else {
  2229. /* Update skb for CHECKSUM_UNNECESSARY and csum_level when we
  2230. * verified a new top level checksum or an encapsulated one
  2231. * during GRO. This saves work if we fallback to normal path.
  2232. */
  2233. __skb_incr_checksum_unnecessary(skb);
  2234. }
  2235. }
  2236. #define __skb_gro_checksum_validate(skb, proto, zero_okay, check, \
  2237. compute_pseudo) \
  2238. ({ \
  2239. __sum16 __ret = 0; \
  2240. if (__skb_gro_checksum_validate_needed(skb, zero_okay, check)) \
  2241. __ret = __skb_gro_checksum_validate_complete(skb, \
  2242. compute_pseudo(skb, proto)); \
  2243. if (__ret) \
  2244. __skb_mark_checksum_bad(skb); \
  2245. else \
  2246. skb_gro_incr_csum_unnecessary(skb); \
  2247. __ret; \
  2248. })
  2249. #define skb_gro_checksum_validate(skb, proto, compute_pseudo) \
  2250. __skb_gro_checksum_validate(skb, proto, false, 0, compute_pseudo)
  2251. #define skb_gro_checksum_validate_zero_check(skb, proto, check, \
  2252. compute_pseudo) \
  2253. __skb_gro_checksum_validate(skb, proto, true, check, compute_pseudo)
  2254. #define skb_gro_checksum_simple_validate(skb) \
  2255. __skb_gro_checksum_validate(skb, 0, false, 0, null_compute_pseudo)
  2256. static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb)
  2257. {
  2258. return (NAPI_GRO_CB(skb)->csum_cnt == 0 &&
  2259. !NAPI_GRO_CB(skb)->csum_valid);
  2260. }
  2261. static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
  2262. __sum16 check, __wsum pseudo)
  2263. {
  2264. NAPI_GRO_CB(skb)->csum = ~pseudo;
  2265. NAPI_GRO_CB(skb)->csum_valid = 1;
  2266. }
  2267. #define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \
  2268. do { \
  2269. if (__skb_gro_checksum_convert_check(skb)) \
  2270. __skb_gro_checksum_convert(skb, check, \
  2271. compute_pseudo(skb, proto)); \
  2272. } while (0)
  2273. struct gro_remcsum {
  2274. int offset;
  2275. __wsum delta;
  2276. };
  2277. static inline void skb_gro_remcsum_init(struct gro_remcsum *grc)
  2278. {
  2279. grc->offset = 0;
  2280. grc->delta = 0;
  2281. }
  2282. static inline void *skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
  2283. unsigned int off, size_t hdrlen,
  2284. int start, int offset,
  2285. struct gro_remcsum *grc,
  2286. bool nopartial)
  2287. {
  2288. __wsum delta;
  2289. size_t plen = hdrlen + max_t(size_t, offset + sizeof(u16), start);
  2290. BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
  2291. if (!nopartial) {
  2292. NAPI_GRO_CB(skb)->gro_remcsum_start = off + hdrlen + start;
  2293. return ptr;
  2294. }
  2295. ptr = skb_gro_header_fast(skb, off);
  2296. if (skb_gro_header_hard(skb, off + plen)) {
  2297. ptr = skb_gro_header_slow(skb, off + plen, off);
  2298. if (!ptr)
  2299. return NULL;
  2300. }
  2301. delta = remcsum_adjust(ptr + hdrlen, NAPI_GRO_CB(skb)->csum,
  2302. start, offset);
  2303. /* Adjust skb->csum since we changed the packet */
  2304. NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
  2305. grc->offset = off + hdrlen + offset;
  2306. grc->delta = delta;
  2307. return ptr;
  2308. }
  2309. static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
  2310. struct gro_remcsum *grc)
  2311. {
  2312. void *ptr;
  2313. size_t plen = grc->offset + sizeof(u16);
  2314. if (!grc->delta)
  2315. return;
  2316. ptr = skb_gro_header_fast(skb, grc->offset);
  2317. if (skb_gro_header_hard(skb, grc->offset + sizeof(u16))) {
  2318. ptr = skb_gro_header_slow(skb, plen, grc->offset);
  2319. if (!ptr)
  2320. return;
  2321. }
  2322. remcsum_unadjust((__sum16 *)ptr, grc->delta);
  2323. }
  2324. struct skb_csum_offl_spec {
  2325. __u16 ipv4_okay:1,
  2326. ipv6_okay:1,
  2327. encap_okay:1,
  2328. ip_options_okay:1,
  2329. ext_hdrs_okay:1,
  2330. tcp_okay:1,
  2331. udp_okay:1,
  2332. sctp_okay:1,
  2333. vlan_okay:1,
  2334. no_encapped_ipv6:1,
  2335. no_not_encapped:1;
  2336. };
  2337. bool __skb_csum_offload_chk(struct sk_buff *skb,
  2338. const struct skb_csum_offl_spec *spec,
  2339. bool *csum_encapped,
  2340. bool csum_help);
  2341. static inline bool skb_csum_offload_chk(struct sk_buff *skb,
  2342. const struct skb_csum_offl_spec *spec,
  2343. bool *csum_encapped,
  2344. bool csum_help)
  2345. {
  2346. if (skb->ip_summed != CHECKSUM_PARTIAL)
  2347. return false;
  2348. return __skb_csum_offload_chk(skb, spec, csum_encapped, csum_help);
  2349. }
  2350. static inline bool skb_csum_offload_chk_help(struct sk_buff *skb,
  2351. const struct skb_csum_offl_spec *spec)
  2352. {
  2353. bool csum_encapped;
  2354. return skb_csum_offload_chk(skb, spec, &csum_encapped, true);
  2355. }
  2356. static inline bool skb_csum_off_chk_help_cmn(struct sk_buff *skb)
  2357. {
  2358. static const struct skb_csum_offl_spec csum_offl_spec = {
  2359. .ipv4_okay = 1,
  2360. .ip_options_okay = 1,
  2361. .ipv6_okay = 1,
  2362. .vlan_okay = 1,
  2363. .tcp_okay = 1,
  2364. .udp_okay = 1,
  2365. };
  2366. return skb_csum_offload_chk_help(skb, &csum_offl_spec);
  2367. }
  2368. static inline bool skb_csum_off_chk_help_cmn_v4_only(struct sk_buff *skb)
  2369. {
  2370. static const struct skb_csum_offl_spec csum_offl_spec = {
  2371. .ipv4_okay = 1,
  2372. .ip_options_okay = 1,
  2373. .tcp_okay = 1,
  2374. .udp_okay = 1,
  2375. .vlan_okay = 1,
  2376. };
  2377. return skb_csum_offload_chk_help(skb, &csum_offl_spec);
  2378. }
  2379. static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
  2380. unsigned short type,
  2381. const void *daddr, const void *saddr,
  2382. unsigned int len)
  2383. {
  2384. if (!dev->header_ops || !dev->header_ops->create)
  2385. return 0;
  2386. return dev->header_ops->create(skb, dev, type, daddr, saddr, len);
  2387. }
  2388. static inline int dev_parse_header(const struct sk_buff *skb,
  2389. unsigned char *haddr)
  2390. {
  2391. const struct net_device *dev = skb->dev;
  2392. if (!dev->header_ops || !dev->header_ops->parse)
  2393. return 0;
  2394. return dev->header_ops->parse(skb, haddr);
  2395. }
  2396. /* ll_header must have at least hard_header_len allocated */
  2397. static inline bool dev_validate_header(const struct net_device *dev,
  2398. char *ll_header, int len)
  2399. {
  2400. if (likely(len >= dev->hard_header_len))
  2401. return true;
  2402. if (capable(CAP_SYS_RAWIO)) {
  2403. memset(ll_header + len, 0, dev->hard_header_len - len);
  2404. return true;
  2405. }
  2406. if (dev->header_ops && dev->header_ops->validate)
  2407. return dev->header_ops->validate(ll_header, len);
  2408. return false;
  2409. }
  2410. typedef int gifconf_func_t(struct net_device * dev, char __user * bufptr, int len);
  2411. int register_gifconf(unsigned int family, gifconf_func_t *gifconf);
  2412. static inline int unregister_gifconf(unsigned int family)
  2413. {
  2414. return register_gifconf(family, NULL);
  2415. }
  2416. #ifdef CONFIG_NET_FLOW_LIMIT
  2417. #define FLOW_LIMIT_HISTORY (1 << 7) /* must be ^2 and !overflow buckets */
  2418. struct sd_flow_limit {
  2419. u64 count;
  2420. unsigned int num_buckets;
  2421. unsigned int history_head;
  2422. u16 history[FLOW_LIMIT_HISTORY];
  2423. u8 buckets[];
  2424. };
  2425. extern int netdev_flow_limit_table_len;
  2426. #endif /* CONFIG_NET_FLOW_LIMIT */
  2427. /*
  2428. * Incoming packets are placed on per-CPU queues
  2429. */
  2430. struct softnet_data {
  2431. struct list_head poll_list;
  2432. struct sk_buff_head process_queue;
  2433. /* stats */
  2434. unsigned int processed;
  2435. unsigned int time_squeeze;
  2436. unsigned int received_rps;
  2437. #ifdef CONFIG_RPS
  2438. struct softnet_data *rps_ipi_list;
  2439. #endif
  2440. #ifdef CONFIG_NET_FLOW_LIMIT
  2441. struct sd_flow_limit __rcu *flow_limit;
  2442. #endif
  2443. struct Qdisc *output_queue;
  2444. struct Qdisc **output_queue_tailp;
  2445. struct sk_buff *completion_queue;
  2446. #ifdef CONFIG_RPS
  2447. /* input_queue_head should be written by cpu owning this struct,
  2448. * and only read by other cpus. Worth using a cache line.
  2449. */
  2450. unsigned int input_queue_head ____cacheline_aligned_in_smp;
  2451. /* Elements below can be accessed between CPUs for RPS/RFS */
  2452. struct call_single_data csd ____cacheline_aligned_in_smp;
  2453. struct softnet_data *rps_ipi_next;
  2454. unsigned int cpu;
  2455. unsigned int input_queue_tail;
  2456. #endif
  2457. unsigned int dropped;
  2458. struct sk_buff_head input_pkt_queue;
  2459. struct napi_struct backlog;
  2460. };
  2461. static inline void input_queue_head_incr(struct softnet_data *sd)
  2462. {
  2463. #ifdef CONFIG_RPS
  2464. sd->input_queue_head++;
  2465. #endif
  2466. }
  2467. static inline void input_queue_tail_incr_save(struct softnet_data *sd,
  2468. unsigned int *qtail)
  2469. {
  2470. #ifdef CONFIG_RPS
  2471. *qtail = ++sd->input_queue_tail;
  2472. #endif
  2473. }
  2474. DECLARE_PER_CPU_ALIGNED(struct softnet_data, softnet_data);
  2475. void __netif_schedule(struct Qdisc *q);
  2476. void netif_schedule_queue(struct netdev_queue *txq);
  2477. static inline void netif_tx_schedule_all(struct net_device *dev)
  2478. {
  2479. unsigned int i;
  2480. for (i = 0; i < dev->num_tx_queues; i++)
  2481. netif_schedule_queue(netdev_get_tx_queue(dev, i));
  2482. }
  2483. static __always_inline void netif_tx_start_queue(struct netdev_queue *dev_queue)
  2484. {
  2485. clear_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  2486. }
  2487. /**
  2488. * netif_start_queue - allow transmit
  2489. * @dev: network device
  2490. *
  2491. * Allow upper layers to call the device hard_start_xmit routine.
  2492. */
  2493. static inline void netif_start_queue(struct net_device *dev)
  2494. {
  2495. netif_tx_start_queue(netdev_get_tx_queue(dev, 0));
  2496. }
  2497. static inline void netif_tx_start_all_queues(struct net_device *dev)
  2498. {
  2499. unsigned int i;
  2500. for (i = 0; i < dev->num_tx_queues; i++) {
  2501. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  2502. netif_tx_start_queue(txq);
  2503. }
  2504. }
  2505. void netif_tx_wake_queue(struct netdev_queue *dev_queue);
  2506. /**
  2507. * netif_wake_queue - restart transmit
  2508. * @dev: network device
  2509. *
  2510. * Allow upper layers to call the device hard_start_xmit routine.
  2511. * Used for flow control when transmit resources are available.
  2512. */
  2513. static inline void netif_wake_queue(struct net_device *dev)
  2514. {
  2515. netif_tx_wake_queue(netdev_get_tx_queue(dev, 0));
  2516. }
  2517. static inline void netif_tx_wake_all_queues(struct net_device *dev)
  2518. {
  2519. unsigned int i;
  2520. for (i = 0; i < dev->num_tx_queues; i++) {
  2521. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  2522. netif_tx_wake_queue(txq);
  2523. }
  2524. }
  2525. static __always_inline void netif_tx_stop_queue(struct netdev_queue *dev_queue)
  2526. {
  2527. set_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  2528. }
  2529. /**
  2530. * netif_stop_queue - stop transmitted packets
  2531. * @dev: network device
  2532. *
  2533. * Stop upper layers calling the device hard_start_xmit routine.
  2534. * Used for flow control when transmit resources are unavailable.
  2535. */
  2536. static inline void netif_stop_queue(struct net_device *dev)
  2537. {
  2538. netif_tx_stop_queue(netdev_get_tx_queue(dev, 0));
  2539. }
  2540. void netif_tx_stop_all_queues(struct net_device *dev);
  2541. static inline bool netif_tx_queue_stopped(const struct netdev_queue *dev_queue)
  2542. {
  2543. return test_bit(__QUEUE_STATE_DRV_XOFF, &dev_queue->state);
  2544. }
  2545. /**
  2546. * netif_queue_stopped - test if transmit queue is flowblocked
  2547. * @dev: network device
  2548. *
  2549. * Test if transmit queue on device is currently unable to send.
  2550. */
  2551. static inline bool netif_queue_stopped(const struct net_device *dev)
  2552. {
  2553. return netif_tx_queue_stopped(netdev_get_tx_queue(dev, 0));
  2554. }
  2555. static inline bool netif_xmit_stopped(const struct netdev_queue *dev_queue)
  2556. {
  2557. return dev_queue->state & QUEUE_STATE_ANY_XOFF;
  2558. }
  2559. static inline bool
  2560. netif_xmit_frozen_or_stopped(const struct netdev_queue *dev_queue)
  2561. {
  2562. return dev_queue->state & QUEUE_STATE_ANY_XOFF_OR_FROZEN;
  2563. }
  2564. static inline bool
  2565. netif_xmit_frozen_or_drv_stopped(const struct netdev_queue *dev_queue)
  2566. {
  2567. return dev_queue->state & QUEUE_STATE_DRV_XOFF_OR_FROZEN;
  2568. }
  2569. /**
  2570. * netdev_txq_bql_enqueue_prefetchw - prefetch bql data for write
  2571. * @dev_queue: pointer to transmit queue
  2572. *
  2573. * BQL enabled drivers might use this helper in their ndo_start_xmit(),
  2574. * to give appropriate hint to the CPU.
  2575. */
  2576. static inline void netdev_txq_bql_enqueue_prefetchw(struct netdev_queue *dev_queue)
  2577. {
  2578. #ifdef CONFIG_BQL
  2579. prefetchw(&dev_queue->dql.num_queued);
  2580. #endif
  2581. }
  2582. /**
  2583. * netdev_txq_bql_complete_prefetchw - prefetch bql data for write
  2584. * @dev_queue: pointer to transmit queue
  2585. *
  2586. * BQL enabled drivers might use this helper in their TX completion path,
  2587. * to give appropriate hint to the CPU.
  2588. */
  2589. static inline void netdev_txq_bql_complete_prefetchw(struct netdev_queue *dev_queue)
  2590. {
  2591. #ifdef CONFIG_BQL
  2592. prefetchw(&dev_queue->dql.limit);
  2593. #endif
  2594. }
  2595. static inline void netdev_tx_sent_queue(struct netdev_queue *dev_queue,
  2596. unsigned int bytes)
  2597. {
  2598. #ifdef CONFIG_BQL
  2599. dql_queued(&dev_queue->dql, bytes);
  2600. if (likely(dql_avail(&dev_queue->dql) >= 0))
  2601. return;
  2602. set_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  2603. /*
  2604. * The XOFF flag must be set before checking the dql_avail below,
  2605. * because in netdev_tx_completed_queue we update the dql_completed
  2606. * before checking the XOFF flag.
  2607. */
  2608. smp_mb();
  2609. /* check again in case another CPU has just made room avail */
  2610. if (unlikely(dql_avail(&dev_queue->dql) >= 0))
  2611. clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state);
  2612. #endif
  2613. }
  2614. /**
  2615. * netdev_sent_queue - report the number of bytes queued to hardware
  2616. * @dev: network device
  2617. * @bytes: number of bytes queued to the hardware device queue
  2618. *
  2619. * Report the number of bytes queued for sending/completion to the network
  2620. * device hardware queue. @bytes should be a good approximation and should
  2621. * exactly match netdev_completed_queue() @bytes
  2622. */
  2623. static inline void netdev_sent_queue(struct net_device *dev, unsigned int bytes)
  2624. {
  2625. netdev_tx_sent_queue(netdev_get_tx_queue(dev, 0), bytes);
  2626. }
  2627. static inline void netdev_tx_completed_queue(struct netdev_queue *dev_queue,
  2628. unsigned int pkts, unsigned int bytes)
  2629. {
  2630. #ifdef CONFIG_BQL
  2631. if (unlikely(!bytes))
  2632. return;
  2633. dql_completed(&dev_queue->dql, bytes);
  2634. /*
  2635. * Without the memory barrier there is a small possiblity that
  2636. * netdev_tx_sent_queue will miss the update and cause the queue to
  2637. * be stopped forever
  2638. */
  2639. smp_mb();
  2640. if (dql_avail(&dev_queue->dql) < 0)
  2641. return;
  2642. if (test_and_clear_bit(__QUEUE_STATE_STACK_XOFF, &dev_queue->state))
  2643. netif_schedule_queue(dev_queue);
  2644. #endif
  2645. }
  2646. /**
  2647. * netdev_completed_queue - report bytes and packets completed by device
  2648. * @dev: network device
  2649. * @pkts: actual number of packets sent over the medium
  2650. * @bytes: actual number of bytes sent over the medium
  2651. *
  2652. * Report the number of bytes and packets transmitted by the network device
  2653. * hardware queue over the physical medium, @bytes must exactly match the
  2654. * @bytes amount passed to netdev_sent_queue()
  2655. */
  2656. static inline void netdev_completed_queue(struct net_device *dev,
  2657. unsigned int pkts, unsigned int bytes)
  2658. {
  2659. netdev_tx_completed_queue(netdev_get_tx_queue(dev, 0), pkts, bytes);
  2660. }
  2661. static inline void netdev_tx_reset_queue(struct netdev_queue *q)
  2662. {
  2663. #ifdef CONFIG_BQL
  2664. clear_bit(__QUEUE_STATE_STACK_XOFF, &q->state);
  2665. dql_reset(&q->dql);
  2666. #endif
  2667. }
  2668. /**
  2669. * netdev_reset_queue - reset the packets and bytes count of a network device
  2670. * @dev_queue: network device
  2671. *
  2672. * Reset the bytes and packet count of a network device and clear the
  2673. * software flow control OFF bit for this network device
  2674. */
  2675. static inline void netdev_reset_queue(struct net_device *dev_queue)
  2676. {
  2677. netdev_tx_reset_queue(netdev_get_tx_queue(dev_queue, 0));
  2678. }
  2679. /**
  2680. * netdev_cap_txqueue - check if selected tx queue exceeds device queues
  2681. * @dev: network device
  2682. * @queue_index: given tx queue index
  2683. *
  2684. * Returns 0 if given tx queue index >= number of device tx queues,
  2685. * otherwise returns the originally passed tx queue index.
  2686. */
  2687. static inline u16 netdev_cap_txqueue(struct net_device *dev, u16 queue_index)
  2688. {
  2689. if (unlikely(queue_index >= dev->real_num_tx_queues)) {
  2690. net_warn_ratelimited("%s selects TX queue %d, but real number of TX queues is %d\n",
  2691. dev->name, queue_index,
  2692. dev->real_num_tx_queues);
  2693. return 0;
  2694. }
  2695. return queue_index;
  2696. }
  2697. /**
  2698. * netif_running - test if up
  2699. * @dev: network device
  2700. *
  2701. * Test if the device has been brought up.
  2702. */
  2703. static inline bool netif_running(const struct net_device *dev)
  2704. {
  2705. return test_bit(__LINK_STATE_START, &dev->state);
  2706. }
  2707. /*
  2708. * Routines to manage the subqueues on a device. We only need start,
  2709. * stop, and a check if it's stopped. All other device management is
  2710. * done at the overall netdevice level.
  2711. * Also test the device if we're multiqueue.
  2712. */
  2713. /**
  2714. * netif_start_subqueue - allow sending packets on subqueue
  2715. * @dev: network device
  2716. * @queue_index: sub queue index
  2717. *
  2718. * Start individual transmit queue of a device with multiple transmit queues.
  2719. */
  2720. static inline void netif_start_subqueue(struct net_device *dev, u16 queue_index)
  2721. {
  2722. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  2723. netif_tx_start_queue(txq);
  2724. }
  2725. /**
  2726. * netif_stop_subqueue - stop sending packets on subqueue
  2727. * @dev: network device
  2728. * @queue_index: sub queue index
  2729. *
  2730. * Stop individual transmit queue of a device with multiple transmit queues.
  2731. */
  2732. static inline void netif_stop_subqueue(struct net_device *dev, u16 queue_index)
  2733. {
  2734. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  2735. netif_tx_stop_queue(txq);
  2736. }
  2737. /**
  2738. * netif_subqueue_stopped - test status of subqueue
  2739. * @dev: network device
  2740. * @queue_index: sub queue index
  2741. *
  2742. * Check individual transmit queue of a device with multiple transmit queues.
  2743. */
  2744. static inline bool __netif_subqueue_stopped(const struct net_device *dev,
  2745. u16 queue_index)
  2746. {
  2747. struct netdev_queue *txq = netdev_get_tx_queue(dev, queue_index);
  2748. return netif_tx_queue_stopped(txq);
  2749. }
  2750. static inline bool netif_subqueue_stopped(const struct net_device *dev,
  2751. struct sk_buff *skb)
  2752. {
  2753. return __netif_subqueue_stopped(dev, skb_get_queue_mapping(skb));
  2754. }
  2755. void netif_wake_subqueue(struct net_device *dev, u16 queue_index);
  2756. #ifdef CONFIG_XPS
  2757. int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
  2758. u16 index);
  2759. #else
  2760. static inline int netif_set_xps_queue(struct net_device *dev,
  2761. const struct cpumask *mask,
  2762. u16 index)
  2763. {
  2764. return 0;
  2765. }
  2766. #endif
  2767. u16 __skb_tx_hash(const struct net_device *dev, struct sk_buff *skb,
  2768. unsigned int num_tx_queues);
  2769. /*
  2770. * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  2771. * as a distribution range limit for the returned value.
  2772. */
  2773. static inline u16 skb_tx_hash(const struct net_device *dev,
  2774. struct sk_buff *skb)
  2775. {
  2776. return __skb_tx_hash(dev, skb, dev->real_num_tx_queues);
  2777. }
  2778. /**
  2779. * netif_is_multiqueue - test if device has multiple transmit queues
  2780. * @dev: network device
  2781. *
  2782. * Check if device has multiple transmit queues
  2783. */
  2784. static inline bool netif_is_multiqueue(const struct net_device *dev)
  2785. {
  2786. return dev->num_tx_queues > 1;
  2787. }
  2788. int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
  2789. #ifdef CONFIG_SYSFS
  2790. int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
  2791. #else
  2792. static inline int netif_set_real_num_rx_queues(struct net_device *dev,
  2793. unsigned int rxq)
  2794. {
  2795. return 0;
  2796. }
  2797. #endif
  2798. #ifdef CONFIG_SYSFS
  2799. static inline unsigned int get_netdev_rx_queue_index(
  2800. struct netdev_rx_queue *queue)
  2801. {
  2802. struct net_device *dev = queue->dev;
  2803. int index = queue - dev->_rx;
  2804. BUG_ON(index >= dev->num_rx_queues);
  2805. return index;
  2806. }
  2807. #endif
  2808. #define DEFAULT_MAX_NUM_RSS_QUEUES (8)
  2809. int netif_get_num_default_rss_queues(void);
  2810. enum skb_free_reason {
  2811. SKB_REASON_CONSUMED,
  2812. SKB_REASON_DROPPED,
  2813. };
  2814. void __dev_kfree_skb_irq(struct sk_buff *skb, enum skb_free_reason reason);
  2815. void __dev_kfree_skb_any(struct sk_buff *skb, enum skb_free_reason reason);
  2816. /*
  2817. * It is not allowed to call kfree_skb() or consume_skb() from hardware
  2818. * interrupt context or with hardware interrupts being disabled.
  2819. * (in_irq() || irqs_disabled())
  2820. *
  2821. * We provide four helpers that can be used in following contexts :
  2822. *
  2823. * dev_kfree_skb_irq(skb) when caller drops a packet from irq context,
  2824. * replacing kfree_skb(skb)
  2825. *
  2826. * dev_consume_skb_irq(skb) when caller consumes a packet from irq context.
  2827. * Typically used in place of consume_skb(skb) in TX completion path
  2828. *
  2829. * dev_kfree_skb_any(skb) when caller doesn't know its current irq context,
  2830. * replacing kfree_skb(skb)
  2831. *
  2832. * dev_consume_skb_any(skb) when caller doesn't know its current irq context,
  2833. * and consumed a packet. Used in place of consume_skb(skb)
  2834. */
  2835. static inline void dev_kfree_skb_irq(struct sk_buff *skb)
  2836. {
  2837. __dev_kfree_skb_irq(skb, SKB_REASON_DROPPED);
  2838. }
  2839. static inline void dev_consume_skb_irq(struct sk_buff *skb)
  2840. {
  2841. __dev_kfree_skb_irq(skb, SKB_REASON_CONSUMED);
  2842. }
  2843. static inline void dev_kfree_skb_any(struct sk_buff *skb)
  2844. {
  2845. __dev_kfree_skb_any(skb, SKB_REASON_DROPPED);
  2846. }
  2847. static inline void dev_consume_skb_any(struct sk_buff *skb)
  2848. {
  2849. __dev_kfree_skb_any(skb, SKB_REASON_CONSUMED);
  2850. }
  2851. int netif_rx(struct sk_buff *skb);
  2852. int netif_rx_ni(struct sk_buff *skb);
  2853. int netif_receive_skb(struct sk_buff *skb);
  2854. gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
  2855. void napi_gro_flush(struct napi_struct *napi, bool flush_old);
  2856. struct sk_buff *napi_get_frags(struct napi_struct *napi);
  2857. gro_result_t napi_gro_frags(struct napi_struct *napi);
  2858. struct packet_offload *gro_find_receive_by_type(__be16 type);
  2859. struct packet_offload *gro_find_complete_by_type(__be16 type);
  2860. static inline void napi_free_frags(struct napi_struct *napi)
  2861. {
  2862. kfree_skb(napi->skb);
  2863. napi->skb = NULL;
  2864. }
  2865. int netdev_rx_handler_register(struct net_device *dev,
  2866. rx_handler_func_t *rx_handler,
  2867. void *rx_handler_data);
  2868. void netdev_rx_handler_unregister(struct net_device *dev);
  2869. bool dev_valid_name(const char *name);
  2870. int dev_ioctl(struct net *net, unsigned int cmd, void __user *);
  2871. int dev_ethtool(struct net *net, struct ifreq *);
  2872. unsigned int dev_get_flags(const struct net_device *);
  2873. int __dev_change_flags(struct net_device *, unsigned int flags);
  2874. int dev_change_flags(struct net_device *, unsigned int);
  2875. void __dev_notify_flags(struct net_device *, unsigned int old_flags,
  2876. unsigned int gchanges);
  2877. int dev_change_name(struct net_device *, const char *);
  2878. int dev_set_alias(struct net_device *, const char *, size_t);
  2879. int dev_change_net_namespace(struct net_device *, struct net *, const char *);
  2880. int dev_set_mtu(struct net_device *, int);
  2881. void dev_set_group(struct net_device *, int);
  2882. int dev_set_mac_address(struct net_device *, struct sockaddr *);
  2883. int dev_change_carrier(struct net_device *, bool new_carrier);
  2884. int dev_get_phys_port_id(struct net_device *dev,
  2885. struct netdev_phys_item_id *ppid);
  2886. int dev_get_phys_port_name(struct net_device *dev,
  2887. char *name, size_t len);
  2888. int dev_change_proto_down(struct net_device *dev, bool proto_down);
  2889. struct sk_buff *validate_xmit_skb_list(struct sk_buff *skb, struct net_device *dev);
  2890. struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
  2891. struct netdev_queue *txq, int *ret);
  2892. int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
  2893. int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
  2894. bool is_skb_forwardable(const struct net_device *dev,
  2895. const struct sk_buff *skb);
  2896. void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
  2897. extern int netdev_budget;
  2898. /* Called by rtnetlink.c:rtnl_unlock() */
  2899. void netdev_run_todo(void);
  2900. /**
  2901. * dev_put - release reference to device
  2902. * @dev: network device
  2903. *
  2904. * Release reference to device to allow it to be freed.
  2905. */
  2906. static inline void dev_put(struct net_device *dev)
  2907. {
  2908. this_cpu_dec(*dev->pcpu_refcnt);
  2909. }
  2910. /**
  2911. * dev_hold - get reference to device
  2912. * @dev: network device
  2913. *
  2914. * Hold reference to device to keep it from being freed.
  2915. */
  2916. static inline void dev_hold(struct net_device *dev)
  2917. {
  2918. this_cpu_inc(*dev->pcpu_refcnt);
  2919. }
  2920. /* Carrier loss detection, dial on demand. The functions netif_carrier_on
  2921. * and _off may be called from IRQ context, but it is caller
  2922. * who is responsible for serialization of these calls.
  2923. *
  2924. * The name carrier is inappropriate, these functions should really be
  2925. * called netif_lowerlayer_*() because they represent the state of any
  2926. * kind of lower layer not just hardware media.
  2927. */
  2928. void linkwatch_init_dev(struct net_device *dev);
  2929. void linkwatch_fire_event(struct net_device *dev);
  2930. void linkwatch_forget_dev(struct net_device *dev);
  2931. /**
  2932. * netif_carrier_ok - test if carrier present
  2933. * @dev: network device
  2934. *
  2935. * Check if carrier is present on device
  2936. */
  2937. static inline bool netif_carrier_ok(const struct net_device *dev)
  2938. {
  2939. return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
  2940. }
  2941. unsigned long dev_trans_start(struct net_device *dev);
  2942. void __netdev_watchdog_up(struct net_device *dev);
  2943. void netif_carrier_on(struct net_device *dev);
  2944. void netif_carrier_off(struct net_device *dev);
  2945. /**
  2946. * netif_dormant_on - mark device as dormant.
  2947. * @dev: network device
  2948. *
  2949. * Mark device as dormant (as per RFC2863).
  2950. *
  2951. * The dormant state indicates that the relevant interface is not
  2952. * actually in a condition to pass packets (i.e., it is not 'up') but is
  2953. * in a "pending" state, waiting for some external event. For "on-
  2954. * demand" interfaces, this new state identifies the situation where the
  2955. * interface is waiting for events to place it in the up state.
  2956. */
  2957. static inline void netif_dormant_on(struct net_device *dev)
  2958. {
  2959. if (!test_and_set_bit(__LINK_STATE_DORMANT, &dev->state))
  2960. linkwatch_fire_event(dev);
  2961. }
  2962. /**
  2963. * netif_dormant_off - set device as not dormant.
  2964. * @dev: network device
  2965. *
  2966. * Device is not in dormant state.
  2967. */
  2968. static inline void netif_dormant_off(struct net_device *dev)
  2969. {
  2970. if (test_and_clear_bit(__LINK_STATE_DORMANT, &dev->state))
  2971. linkwatch_fire_event(dev);
  2972. }
  2973. /**
  2974. * netif_dormant - test if carrier present
  2975. * @dev: network device
  2976. *
  2977. * Check if carrier is present on device
  2978. */
  2979. static inline bool netif_dormant(const struct net_device *dev)
  2980. {
  2981. return test_bit(__LINK_STATE_DORMANT, &dev->state);
  2982. }
  2983. /**
  2984. * netif_oper_up - test if device is operational
  2985. * @dev: network device
  2986. *
  2987. * Check if carrier is operational
  2988. */
  2989. static inline bool netif_oper_up(const struct net_device *dev)
  2990. {
  2991. return (dev->operstate == IF_OPER_UP ||
  2992. dev->operstate == IF_OPER_UNKNOWN /* backward compat */);
  2993. }
  2994. /**
  2995. * netif_device_present - is device available or removed
  2996. * @dev: network device
  2997. *
  2998. * Check if device has not been removed from system.
  2999. */
  3000. static inline bool netif_device_present(struct net_device *dev)
  3001. {
  3002. return test_bit(__LINK_STATE_PRESENT, &dev->state);
  3003. }
  3004. void netif_device_detach(struct net_device *dev);
  3005. void netif_device_attach(struct net_device *dev);
  3006. /*
  3007. * Network interface message level settings
  3008. */
  3009. enum {
  3010. NETIF_MSG_DRV = 0x0001,
  3011. NETIF_MSG_PROBE = 0x0002,
  3012. NETIF_MSG_LINK = 0x0004,
  3013. NETIF_MSG_TIMER = 0x0008,
  3014. NETIF_MSG_IFDOWN = 0x0010,
  3015. NETIF_MSG_IFUP = 0x0020,
  3016. NETIF_MSG_RX_ERR = 0x0040,
  3017. NETIF_MSG_TX_ERR = 0x0080,
  3018. NETIF_MSG_TX_QUEUED = 0x0100,
  3019. NETIF_MSG_INTR = 0x0200,
  3020. NETIF_MSG_TX_DONE = 0x0400,
  3021. NETIF_MSG_RX_STATUS = 0x0800,
  3022. NETIF_MSG_PKTDATA = 0x1000,
  3023. NETIF_MSG_HW = 0x2000,
  3024. NETIF_MSG_WOL = 0x4000,
  3025. };
  3026. #define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
  3027. #define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
  3028. #define netif_msg_link(p) ((p)->msg_enable & NETIF_MSG_LINK)
  3029. #define netif_msg_timer(p) ((p)->msg_enable & NETIF_MSG_TIMER)
  3030. #define netif_msg_ifdown(p) ((p)->msg_enable & NETIF_MSG_IFDOWN)
  3031. #define netif_msg_ifup(p) ((p)->msg_enable & NETIF_MSG_IFUP)
  3032. #define netif_msg_rx_err(p) ((p)->msg_enable & NETIF_MSG_RX_ERR)
  3033. #define netif_msg_tx_err(p) ((p)->msg_enable & NETIF_MSG_TX_ERR)
  3034. #define netif_msg_tx_queued(p) ((p)->msg_enable & NETIF_MSG_TX_QUEUED)
  3035. #define netif_msg_intr(p) ((p)->msg_enable & NETIF_MSG_INTR)
  3036. #define netif_msg_tx_done(p) ((p)->msg_enable & NETIF_MSG_TX_DONE)
  3037. #define netif_msg_rx_status(p) ((p)->msg_enable & NETIF_MSG_RX_STATUS)
  3038. #define netif_msg_pktdata(p) ((p)->msg_enable & NETIF_MSG_PKTDATA)
  3039. #define netif_msg_hw(p) ((p)->msg_enable & NETIF_MSG_HW)
  3040. #define netif_msg_wol(p) ((p)->msg_enable & NETIF_MSG_WOL)
  3041. static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits)
  3042. {
  3043. /* use default */
  3044. if (debug_value < 0 || debug_value >= (sizeof(u32) * 8))
  3045. return default_msg_enable_bits;
  3046. if (debug_value == 0) /* no output */
  3047. return 0;
  3048. /* set low N bits */
  3049. return (1 << debug_value) - 1;
  3050. }
  3051. static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
  3052. {
  3053. spin_lock(&txq->_xmit_lock);
  3054. txq->xmit_lock_owner = cpu;
  3055. }
  3056. static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
  3057. {
  3058. spin_lock_bh(&txq->_xmit_lock);
  3059. txq->xmit_lock_owner = smp_processor_id();
  3060. }
  3061. static inline bool __netif_tx_trylock(struct netdev_queue *txq)
  3062. {
  3063. bool ok = spin_trylock(&txq->_xmit_lock);
  3064. if (likely(ok))
  3065. txq->xmit_lock_owner = smp_processor_id();
  3066. return ok;
  3067. }
  3068. static inline void __netif_tx_unlock(struct netdev_queue *txq)
  3069. {
  3070. txq->xmit_lock_owner = -1;
  3071. spin_unlock(&txq->_xmit_lock);
  3072. }
  3073. static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
  3074. {
  3075. txq->xmit_lock_owner = -1;
  3076. spin_unlock_bh(&txq->_xmit_lock);
  3077. }
  3078. static inline void txq_trans_update(struct netdev_queue *txq)
  3079. {
  3080. if (txq->xmit_lock_owner != -1)
  3081. txq->trans_start = jiffies;
  3082. }
  3083. /* legacy drivers only, netdev_start_xmit() sets txq->trans_start */
  3084. static inline void netif_trans_update(struct net_device *dev)
  3085. {
  3086. struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
  3087. if (txq->trans_start != jiffies)
  3088. txq->trans_start = jiffies;
  3089. }
  3090. /**
  3091. * netif_tx_lock - grab network device transmit lock
  3092. * @dev: network device
  3093. *
  3094. * Get network device transmit lock
  3095. */
  3096. static inline void netif_tx_lock(struct net_device *dev)
  3097. {
  3098. unsigned int i;
  3099. int cpu;
  3100. spin_lock(&dev->tx_global_lock);
  3101. cpu = smp_processor_id();
  3102. for (i = 0; i < dev->num_tx_queues; i++) {
  3103. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3104. /* We are the only thread of execution doing a
  3105. * freeze, but we have to grab the _xmit_lock in
  3106. * order to synchronize with threads which are in
  3107. * the ->hard_start_xmit() handler and already
  3108. * checked the frozen bit.
  3109. */
  3110. __netif_tx_lock(txq, cpu);
  3111. set_bit(__QUEUE_STATE_FROZEN, &txq->state);
  3112. __netif_tx_unlock(txq);
  3113. }
  3114. }
  3115. static inline void netif_tx_lock_bh(struct net_device *dev)
  3116. {
  3117. local_bh_disable();
  3118. netif_tx_lock(dev);
  3119. }
  3120. static inline void netif_tx_unlock(struct net_device *dev)
  3121. {
  3122. unsigned int i;
  3123. for (i = 0; i < dev->num_tx_queues; i++) {
  3124. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3125. /* No need to grab the _xmit_lock here. If the
  3126. * queue is not stopped for another reason, we
  3127. * force a schedule.
  3128. */
  3129. clear_bit(__QUEUE_STATE_FROZEN, &txq->state);
  3130. netif_schedule_queue(txq);
  3131. }
  3132. spin_unlock(&dev->tx_global_lock);
  3133. }
  3134. static inline void netif_tx_unlock_bh(struct net_device *dev)
  3135. {
  3136. netif_tx_unlock(dev);
  3137. local_bh_enable();
  3138. }
  3139. #define HARD_TX_LOCK(dev, txq, cpu) { \
  3140. if ((dev->features & NETIF_F_LLTX) == 0) { \
  3141. __netif_tx_lock(txq, cpu); \
  3142. } \
  3143. }
  3144. #define HARD_TX_TRYLOCK(dev, txq) \
  3145. (((dev->features & NETIF_F_LLTX) == 0) ? \
  3146. __netif_tx_trylock(txq) : \
  3147. true )
  3148. #define HARD_TX_UNLOCK(dev, txq) { \
  3149. if ((dev->features & NETIF_F_LLTX) == 0) { \
  3150. __netif_tx_unlock(txq); \
  3151. } \
  3152. }
  3153. static inline void netif_tx_disable(struct net_device *dev)
  3154. {
  3155. unsigned int i;
  3156. int cpu;
  3157. local_bh_disable();
  3158. cpu = smp_processor_id();
  3159. for (i = 0; i < dev->num_tx_queues; i++) {
  3160. struct netdev_queue *txq = netdev_get_tx_queue(dev, i);
  3161. __netif_tx_lock(txq, cpu);
  3162. netif_tx_stop_queue(txq);
  3163. __netif_tx_unlock(txq);
  3164. }
  3165. local_bh_enable();
  3166. }
  3167. static inline void netif_addr_lock(struct net_device *dev)
  3168. {
  3169. spin_lock(&dev->addr_list_lock);
  3170. }
  3171. static inline void netif_addr_lock_nested(struct net_device *dev)
  3172. {
  3173. int subclass = SINGLE_DEPTH_NESTING;
  3174. if (dev->netdev_ops->ndo_get_lock_subclass)
  3175. subclass = dev->netdev_ops->ndo_get_lock_subclass(dev);
  3176. spin_lock_nested(&dev->addr_list_lock, subclass);
  3177. }
  3178. static inline void netif_addr_lock_bh(struct net_device *dev)
  3179. {
  3180. spin_lock_bh(&dev->addr_list_lock);
  3181. }
  3182. static inline void netif_addr_unlock(struct net_device *dev)
  3183. {
  3184. spin_unlock(&dev->addr_list_lock);
  3185. }
  3186. static inline void netif_addr_unlock_bh(struct net_device *dev)
  3187. {
  3188. spin_unlock_bh(&dev->addr_list_lock);
  3189. }
  3190. /*
  3191. * dev_addrs walker. Should be used only for read access. Call with
  3192. * rcu_read_lock held.
  3193. */
  3194. #define for_each_dev_addr(dev, ha) \
  3195. list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
  3196. /* These functions live elsewhere (drivers/net/net_init.c, but related) */
  3197. void ether_setup(struct net_device *dev);
  3198. /* Support for loadable net-drivers */
  3199. struct net_device *alloc_netdev_mqs(int sizeof_priv, const char *name,
  3200. unsigned char name_assign_type,
  3201. void (*setup)(struct net_device *),
  3202. unsigned int txqs, unsigned int rxqs);
  3203. #define alloc_netdev(sizeof_priv, name, name_assign_type, setup) \
  3204. alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, 1, 1)
  3205. #define alloc_netdev_mq(sizeof_priv, name, name_assign_type, setup, count) \
  3206. alloc_netdev_mqs(sizeof_priv, name, name_assign_type, setup, count, \
  3207. count)
  3208. int register_netdev(struct net_device *dev);
  3209. void unregister_netdev(struct net_device *dev);
  3210. /* General hardware address lists handling functions */
  3211. int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
  3212. struct netdev_hw_addr_list *from_list, int addr_len);
  3213. void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
  3214. struct netdev_hw_addr_list *from_list, int addr_len);
  3215. int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
  3216. struct net_device *dev,
  3217. int (*sync)(struct net_device *, const unsigned char *),
  3218. int (*unsync)(struct net_device *,
  3219. const unsigned char *));
  3220. void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
  3221. struct net_device *dev,
  3222. int (*unsync)(struct net_device *,
  3223. const unsigned char *));
  3224. void __hw_addr_init(struct netdev_hw_addr_list *list);
  3225. /* Functions used for device addresses handling */
  3226. int dev_addr_add(struct net_device *dev, const unsigned char *addr,
  3227. unsigned char addr_type);
  3228. int dev_addr_del(struct net_device *dev, const unsigned char *addr,
  3229. unsigned char addr_type);
  3230. void dev_addr_flush(struct net_device *dev);
  3231. int dev_addr_init(struct net_device *dev);
  3232. /* Functions used for unicast addresses handling */
  3233. int dev_uc_add(struct net_device *dev, const unsigned char *addr);
  3234. int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr);
  3235. int dev_uc_del(struct net_device *dev, const unsigned char *addr);
  3236. int dev_uc_sync(struct net_device *to, struct net_device *from);
  3237. int dev_uc_sync_multiple(struct net_device *to, struct net_device *from);
  3238. void dev_uc_unsync(struct net_device *to, struct net_device *from);
  3239. void dev_uc_flush(struct net_device *dev);
  3240. void dev_uc_init(struct net_device *dev);
  3241. /**
  3242. * __dev_uc_sync - Synchonize device's unicast list
  3243. * @dev: device to sync
  3244. * @sync: function to call if address should be added
  3245. * @unsync: function to call if address should be removed
  3246. *
  3247. * Add newly added addresses to the interface, and release
  3248. * addresses that have been deleted.
  3249. */
  3250. static inline int __dev_uc_sync(struct net_device *dev,
  3251. int (*sync)(struct net_device *,
  3252. const unsigned char *),
  3253. int (*unsync)(struct net_device *,
  3254. const unsigned char *))
  3255. {
  3256. return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
  3257. }
  3258. /**
  3259. * __dev_uc_unsync - Remove synchronized addresses from device
  3260. * @dev: device to sync
  3261. * @unsync: function to call if address should be removed
  3262. *
  3263. * Remove all addresses that were added to the device by dev_uc_sync().
  3264. */
  3265. static inline void __dev_uc_unsync(struct net_device *dev,
  3266. int (*unsync)(struct net_device *,
  3267. const unsigned char *))
  3268. {
  3269. __hw_addr_unsync_dev(&dev->uc, dev, unsync);
  3270. }
  3271. /* Functions used for multicast addresses handling */
  3272. int dev_mc_add(struct net_device *dev, const unsigned char *addr);
  3273. int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
  3274. int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr);
  3275. int dev_mc_del(struct net_device *dev, const unsigned char *addr);
  3276. int dev_mc_del_global(struct net_device *dev, const unsigned char *addr);
  3277. int dev_mc_sync(struct net_device *to, struct net_device *from);
  3278. int dev_mc_sync_multiple(struct net_device *to, struct net_device *from);
  3279. void dev_mc_unsync(struct net_device *to, struct net_device *from);
  3280. void dev_mc_flush(struct net_device *dev);
  3281. void dev_mc_init(struct net_device *dev);
  3282. /**
  3283. * __dev_mc_sync - Synchonize device's multicast list
  3284. * @dev: device to sync
  3285. * @sync: function to call if address should be added
  3286. * @unsync: function to call if address should be removed
  3287. *
  3288. * Add newly added addresses to the interface, and release
  3289. * addresses that have been deleted.
  3290. */
  3291. static inline int __dev_mc_sync(struct net_device *dev,
  3292. int (*sync)(struct net_device *,
  3293. const unsigned char *),
  3294. int (*unsync)(struct net_device *,
  3295. const unsigned char *))
  3296. {
  3297. return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
  3298. }
  3299. /**
  3300. * __dev_mc_unsync - Remove synchronized addresses from device
  3301. * @dev: device to sync
  3302. * @unsync: function to call if address should be removed
  3303. *
  3304. * Remove all addresses that were added to the device by dev_mc_sync().
  3305. */
  3306. static inline void __dev_mc_unsync(struct net_device *dev,
  3307. int (*unsync)(struct net_device *,
  3308. const unsigned char *))
  3309. {
  3310. __hw_addr_unsync_dev(&dev->mc, dev, unsync);
  3311. }
  3312. /* Functions used for secondary unicast and multicast support */
  3313. void dev_set_rx_mode(struct net_device *dev);
  3314. void __dev_set_rx_mode(struct net_device *dev);
  3315. int dev_set_promiscuity(struct net_device *dev, int inc);
  3316. int dev_set_allmulti(struct net_device *dev, int inc);
  3317. void netdev_state_change(struct net_device *dev);
  3318. void netdev_notify_peers(struct net_device *dev);
  3319. void netdev_features_change(struct net_device *dev);
  3320. /* Load a device via the kmod */
  3321. void dev_load(struct net *net, const char *name);
  3322. struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
  3323. struct rtnl_link_stats64 *storage);
  3324. void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
  3325. const struct net_device_stats *netdev_stats);
  3326. extern int netdev_max_backlog;
  3327. extern int netdev_tstamp_prequeue;
  3328. extern int weight_p;
  3329. bool netdev_has_upper_dev(struct net_device *dev, struct net_device *upper_dev);
  3330. struct net_device *netdev_upper_get_next_dev_rcu(struct net_device *dev,
  3331. struct list_head **iter);
  3332. struct net_device *netdev_all_upper_get_next_dev_rcu(struct net_device *dev,
  3333. struct list_head **iter);
  3334. /* iterate through upper list, must be called under RCU read lock */
  3335. #define netdev_for_each_upper_dev_rcu(dev, updev, iter) \
  3336. for (iter = &(dev)->adj_list.upper, \
  3337. updev = netdev_upper_get_next_dev_rcu(dev, &(iter)); \
  3338. updev; \
  3339. updev = netdev_upper_get_next_dev_rcu(dev, &(iter)))
  3340. /* iterate through upper list, must be called under RCU read lock */
  3341. #define netdev_for_each_all_upper_dev_rcu(dev, updev, iter) \
  3342. for (iter = &(dev)->all_adj_list.upper, \
  3343. updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)); \
  3344. updev; \
  3345. updev = netdev_all_upper_get_next_dev_rcu(dev, &(iter)))
  3346. void *netdev_lower_get_next_private(struct net_device *dev,
  3347. struct list_head **iter);
  3348. void *netdev_lower_get_next_private_rcu(struct net_device *dev,
  3349. struct list_head **iter);
  3350. #define netdev_for_each_lower_private(dev, priv, iter) \
  3351. for (iter = (dev)->adj_list.lower.next, \
  3352. priv = netdev_lower_get_next_private(dev, &(iter)); \
  3353. priv; \
  3354. priv = netdev_lower_get_next_private(dev, &(iter)))
  3355. #define netdev_for_each_lower_private_rcu(dev, priv, iter) \
  3356. for (iter = &(dev)->adj_list.lower, \
  3357. priv = netdev_lower_get_next_private_rcu(dev, &(iter)); \
  3358. priv; \
  3359. priv = netdev_lower_get_next_private_rcu(dev, &(iter)))
  3360. void *netdev_lower_get_next(struct net_device *dev,
  3361. struct list_head **iter);
  3362. #define netdev_for_each_lower_dev(dev, ldev, iter) \
  3363. for (iter = (dev)->adj_list.lower.next, \
  3364. ldev = netdev_lower_get_next(dev, &(iter)); \
  3365. ldev; \
  3366. ldev = netdev_lower_get_next(dev, &(iter)))
  3367. void *netdev_adjacent_get_private(struct list_head *adj_list);
  3368. void *netdev_lower_get_first_private_rcu(struct net_device *dev);
  3369. struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
  3370. struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
  3371. int netdev_upper_dev_link(struct net_device *dev, struct net_device *upper_dev);
  3372. int netdev_master_upper_dev_link(struct net_device *dev,
  3373. struct net_device *upper_dev,
  3374. void *upper_priv, void *upper_info);
  3375. void netdev_upper_dev_unlink(struct net_device *dev,
  3376. struct net_device *upper_dev);
  3377. void netdev_adjacent_rename_links(struct net_device *dev, char *oldname);
  3378. void *netdev_lower_dev_get_private(struct net_device *dev,
  3379. struct net_device *lower_dev);
  3380. void netdev_lower_state_changed(struct net_device *lower_dev,
  3381. void *lower_state_info);
  3382. /* RSS keys are 40 or 52 bytes long */
  3383. #define NETDEV_RSS_KEY_LEN 52
  3384. extern u8 netdev_rss_key[NETDEV_RSS_KEY_LEN] __read_mostly;
  3385. void netdev_rss_key_fill(void *buffer, size_t len);
  3386. int dev_get_nest_level(struct net_device *dev,
  3387. bool (*type_check)(const struct net_device *dev));
  3388. int skb_checksum_help(struct sk_buff *skb);
  3389. struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
  3390. netdev_features_t features, bool tx_path);
  3391. struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
  3392. netdev_features_t features);
  3393. struct netdev_bonding_info {
  3394. ifslave slave;
  3395. ifbond master;
  3396. };
  3397. struct netdev_notifier_bonding_info {
  3398. struct netdev_notifier_info info; /* must be first */
  3399. struct netdev_bonding_info bonding_info;
  3400. };
  3401. void netdev_bonding_info_change(struct net_device *dev,
  3402. struct netdev_bonding_info *bonding_info);
  3403. static inline
  3404. struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
  3405. {
  3406. return __skb_gso_segment(skb, features, true);
  3407. }
  3408. __be16 skb_network_protocol(struct sk_buff *skb, int *depth);
  3409. static inline bool can_checksum_protocol(netdev_features_t features,
  3410. __be16 protocol)
  3411. {
  3412. if (protocol == htons(ETH_P_FCOE))
  3413. return !!(features & NETIF_F_FCOE_CRC);
  3414. /* Assume this is an IP checksum (not SCTP CRC) */
  3415. if (features & NETIF_F_HW_CSUM) {
  3416. /* Can checksum everything */
  3417. return true;
  3418. }
  3419. switch (protocol) {
  3420. case htons(ETH_P_IP):
  3421. return !!(features & NETIF_F_IP_CSUM);
  3422. case htons(ETH_P_IPV6):
  3423. return !!(features & NETIF_F_IPV6_CSUM);
  3424. default:
  3425. return false;
  3426. }
  3427. }
  3428. /* Map an ethertype into IP protocol if possible */
  3429. static inline int eproto_to_ipproto(int eproto)
  3430. {
  3431. switch (eproto) {
  3432. case htons(ETH_P_IP):
  3433. return IPPROTO_IP;
  3434. case htons(ETH_P_IPV6):
  3435. return IPPROTO_IPV6;
  3436. default:
  3437. return -1;
  3438. }
  3439. }
  3440. #ifdef CONFIG_BUG
  3441. void netdev_rx_csum_fault(struct net_device *dev);
  3442. #else
  3443. static inline void netdev_rx_csum_fault(struct net_device *dev)
  3444. {
  3445. }
  3446. #endif
  3447. /* rx skb timestamps */
  3448. void net_enable_timestamp(void);
  3449. void net_disable_timestamp(void);
  3450. #ifdef CONFIG_PROC_FS
  3451. int __init dev_proc_init(void);
  3452. #else
  3453. #define dev_proc_init() 0
  3454. #endif
  3455. static inline netdev_tx_t __netdev_start_xmit(const struct net_device_ops *ops,
  3456. struct sk_buff *skb, struct net_device *dev,
  3457. bool more)
  3458. {
  3459. skb->xmit_more = more ? 1 : 0;
  3460. return ops->ndo_start_xmit(skb, dev);
  3461. }
  3462. static inline netdev_tx_t netdev_start_xmit(struct sk_buff *skb, struct net_device *dev,
  3463. struct netdev_queue *txq, bool more)
  3464. {
  3465. const struct net_device_ops *ops = dev->netdev_ops;
  3466. int rc;
  3467. rc = __netdev_start_xmit(ops, skb, dev, more);
  3468. if (rc == NETDEV_TX_OK)
  3469. txq_trans_update(txq);
  3470. return rc;
  3471. }
  3472. int netdev_class_create_file_ns(struct class_attribute *class_attr,
  3473. const void *ns);
  3474. void netdev_class_remove_file_ns(struct class_attribute *class_attr,
  3475. const void *ns);
  3476. static inline int netdev_class_create_file(struct class_attribute *class_attr)
  3477. {
  3478. return netdev_class_create_file_ns(class_attr, NULL);
  3479. }
  3480. static inline void netdev_class_remove_file(struct class_attribute *class_attr)
  3481. {
  3482. netdev_class_remove_file_ns(class_attr, NULL);
  3483. }
  3484. extern struct kobj_ns_type_operations net_ns_type_operations;
  3485. const char *netdev_drivername(const struct net_device *dev);
  3486. void linkwatch_run_queue(void);
  3487. static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
  3488. netdev_features_t f2)
  3489. {
  3490. if ((f1 ^ f2) & NETIF_F_HW_CSUM) {
  3491. if (f1 & NETIF_F_HW_CSUM)
  3492. f1 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
  3493. else
  3494. f2 |= (NETIF_F_IP_CSUM|NETIF_F_IPV6_CSUM);
  3495. }
  3496. return f1 & f2;
  3497. }
  3498. static inline netdev_features_t netdev_get_wanted_features(
  3499. struct net_device *dev)
  3500. {
  3501. return (dev->features & ~dev->hw_features) | dev->wanted_features;
  3502. }
  3503. netdev_features_t netdev_increment_features(netdev_features_t all,
  3504. netdev_features_t one, netdev_features_t mask);
  3505. /* Allow TSO being used on stacked device :
  3506. * Performing the GSO segmentation before last device
  3507. * is a performance improvement.
  3508. */
  3509. static inline netdev_features_t netdev_add_tso_features(netdev_features_t features,
  3510. netdev_features_t mask)
  3511. {
  3512. return netdev_increment_features(features, NETIF_F_ALL_TSO, mask);
  3513. }
  3514. int __netdev_update_features(struct net_device *dev);
  3515. void netdev_update_features(struct net_device *dev);
  3516. void netdev_change_features(struct net_device *dev);
  3517. void netif_stacked_transfer_operstate(const struct net_device *rootdev,
  3518. struct net_device *dev);
  3519. netdev_features_t passthru_features_check(struct sk_buff *skb,
  3520. struct net_device *dev,
  3521. netdev_features_t features);
  3522. netdev_features_t netif_skb_features(struct sk_buff *skb);
  3523. static inline bool net_gso_ok(netdev_features_t features, int gso_type)
  3524. {
  3525. netdev_features_t feature = (netdev_features_t)gso_type << NETIF_F_GSO_SHIFT;
  3526. /* check flags correspondence */
  3527. BUILD_BUG_ON(SKB_GSO_TCPV4 != (NETIF_F_TSO >> NETIF_F_GSO_SHIFT));
  3528. BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_UFO >> NETIF_F_GSO_SHIFT));
  3529. BUILD_BUG_ON(SKB_GSO_DODGY != (NETIF_F_GSO_ROBUST >> NETIF_F_GSO_SHIFT));
  3530. BUILD_BUG_ON(SKB_GSO_TCP_ECN != (NETIF_F_TSO_ECN >> NETIF_F_GSO_SHIFT));
  3531. BUILD_BUG_ON(SKB_GSO_TCP_FIXEDID != (NETIF_F_TSO_MANGLEID >> NETIF_F_GSO_SHIFT));
  3532. BUILD_BUG_ON(SKB_GSO_TCPV6 != (NETIF_F_TSO6 >> NETIF_F_GSO_SHIFT));
  3533. BUILD_BUG_ON(SKB_GSO_FCOE != (NETIF_F_FSO >> NETIF_F_GSO_SHIFT));
  3534. BUILD_BUG_ON(SKB_GSO_GRE != (NETIF_F_GSO_GRE >> NETIF_F_GSO_SHIFT));
  3535. BUILD_BUG_ON(SKB_GSO_GRE_CSUM != (NETIF_F_GSO_GRE_CSUM >> NETIF_F_GSO_SHIFT));
  3536. BUILD_BUG_ON(SKB_GSO_IPXIP4 != (NETIF_F_GSO_IPXIP4 >> NETIF_F_GSO_SHIFT));
  3537. BUILD_BUG_ON(SKB_GSO_IPXIP6 != (NETIF_F_GSO_IPXIP6 >> NETIF_F_GSO_SHIFT));
  3538. BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL != (NETIF_F_GSO_UDP_TUNNEL >> NETIF_F_GSO_SHIFT));
  3539. BUILD_BUG_ON(SKB_GSO_UDP_TUNNEL_CSUM != (NETIF_F_GSO_UDP_TUNNEL_CSUM >> NETIF_F_GSO_SHIFT));
  3540. BUILD_BUG_ON(SKB_GSO_PARTIAL != (NETIF_F_GSO_PARTIAL >> NETIF_F_GSO_SHIFT));
  3541. BUILD_BUG_ON(SKB_GSO_TUNNEL_REMCSUM != (NETIF_F_GSO_TUNNEL_REMCSUM >> NETIF_F_GSO_SHIFT));
  3542. return (features & feature) == feature;
  3543. }
  3544. static inline bool skb_gso_ok(struct sk_buff *skb, netdev_features_t features)
  3545. {
  3546. return net_gso_ok(features, skb_shinfo(skb)->gso_type) &&
  3547. (!skb_has_frag_list(skb) || (features & NETIF_F_FRAGLIST));
  3548. }
  3549. static inline bool netif_needs_gso(struct sk_buff *skb,
  3550. netdev_features_t features)
  3551. {
  3552. return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
  3553. unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
  3554. (skb->ip_summed != CHECKSUM_UNNECESSARY)));
  3555. }
  3556. static inline void netif_set_gso_max_size(struct net_device *dev,
  3557. unsigned int size)
  3558. {
  3559. dev->gso_max_size = size;
  3560. }
  3561. static inline void skb_gso_error_unwind(struct sk_buff *skb, __be16 protocol,
  3562. int pulled_hlen, u16 mac_offset,
  3563. int mac_len)
  3564. {
  3565. skb->protocol = protocol;
  3566. skb->encapsulation = 1;
  3567. skb_push(skb, pulled_hlen);
  3568. skb_reset_transport_header(skb);
  3569. skb->mac_header = mac_offset;
  3570. skb->network_header = skb->mac_header + mac_len;
  3571. skb->mac_len = mac_len;
  3572. }
  3573. static inline bool netif_is_macsec(const struct net_device *dev)
  3574. {
  3575. return dev->priv_flags & IFF_MACSEC;
  3576. }
  3577. static inline bool netif_is_macvlan(const struct net_device *dev)
  3578. {
  3579. return dev->priv_flags & IFF_MACVLAN;
  3580. }
  3581. static inline bool netif_is_macvlan_port(const struct net_device *dev)
  3582. {
  3583. return dev->priv_flags & IFF_MACVLAN_PORT;
  3584. }
  3585. static inline bool netif_is_ipvlan(const struct net_device *dev)
  3586. {
  3587. return dev->priv_flags & IFF_IPVLAN_SLAVE;
  3588. }
  3589. static inline bool netif_is_ipvlan_port(const struct net_device *dev)
  3590. {
  3591. return dev->priv_flags & IFF_IPVLAN_MASTER;
  3592. }
  3593. static inline bool netif_is_bond_master(const struct net_device *dev)
  3594. {
  3595. return dev->flags & IFF_MASTER && dev->priv_flags & IFF_BONDING;
  3596. }
  3597. static inline bool netif_is_bond_slave(const struct net_device *dev)
  3598. {
  3599. return dev->flags & IFF_SLAVE && dev->priv_flags & IFF_BONDING;
  3600. }
  3601. static inline bool netif_supports_nofcs(struct net_device *dev)
  3602. {
  3603. return dev->priv_flags & IFF_SUPP_NOFCS;
  3604. }
  3605. static inline bool netif_is_l3_master(const struct net_device *dev)
  3606. {
  3607. return dev->priv_flags & IFF_L3MDEV_MASTER;
  3608. }
  3609. static inline bool netif_is_l3_slave(const struct net_device *dev)
  3610. {
  3611. return dev->priv_flags & IFF_L3MDEV_SLAVE;
  3612. }
  3613. static inline bool netif_is_bridge_master(const struct net_device *dev)
  3614. {
  3615. return dev->priv_flags & IFF_EBRIDGE;
  3616. }
  3617. static inline bool netif_is_bridge_port(const struct net_device *dev)
  3618. {
  3619. return dev->priv_flags & IFF_BRIDGE_PORT;
  3620. }
  3621. static inline bool netif_is_ovs_master(const struct net_device *dev)
  3622. {
  3623. return dev->priv_flags & IFF_OPENVSWITCH;
  3624. }
  3625. static inline bool netif_is_team_master(const struct net_device *dev)
  3626. {
  3627. return dev->priv_flags & IFF_TEAM;
  3628. }
  3629. static inline bool netif_is_team_port(const struct net_device *dev)
  3630. {
  3631. return dev->priv_flags & IFF_TEAM_PORT;
  3632. }
  3633. static inline bool netif_is_lag_master(const struct net_device *dev)
  3634. {
  3635. return netif_is_bond_master(dev) || netif_is_team_master(dev);
  3636. }
  3637. static inline bool netif_is_lag_port(const struct net_device *dev)
  3638. {
  3639. return netif_is_bond_slave(dev) || netif_is_team_port(dev);
  3640. }
  3641. static inline bool netif_is_rxfh_configured(const struct net_device *dev)
  3642. {
  3643. return dev->priv_flags & IFF_RXFH_CONFIGURED;
  3644. }
  3645. /* This device needs to keep skb dst for qdisc enqueue or ndo_start_xmit() */
  3646. static inline void netif_keep_dst(struct net_device *dev)
  3647. {
  3648. dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_XMIT_DST_RELEASE_PERM);
  3649. }
  3650. /* return true if dev can't cope with mtu frames that need vlan tag insertion */
  3651. static inline bool netif_reduces_vlan_mtu(struct net_device *dev)
  3652. {
  3653. /* TODO: reserve and use an additional IFF bit, if we get more users */
  3654. return dev->priv_flags & IFF_MACSEC;
  3655. }
  3656. extern struct pernet_operations __net_initdata loopback_net_ops;
  3657. /* Logging, debugging and troubleshooting/diagnostic helpers. */
  3658. /* netdev_printk helpers, similar to dev_printk */
  3659. static inline const char *netdev_name(const struct net_device *dev)
  3660. {
  3661. if (!dev->name[0] || strchr(dev->name, '%'))
  3662. return "(unnamed net_device)";
  3663. return dev->name;
  3664. }
  3665. static inline const char *netdev_reg_state(const struct net_device *dev)
  3666. {
  3667. switch (dev->reg_state) {
  3668. case NETREG_UNINITIALIZED: return " (uninitialized)";
  3669. case NETREG_REGISTERED: return "";
  3670. case NETREG_UNREGISTERING: return " (unregistering)";
  3671. case NETREG_UNREGISTERED: return " (unregistered)";
  3672. case NETREG_RELEASED: return " (released)";
  3673. case NETREG_DUMMY: return " (dummy)";
  3674. }
  3675. WARN_ONCE(1, "%s: unknown reg_state %d\n", dev->name, dev->reg_state);
  3676. return " (unknown)";
  3677. }
  3678. __printf(3, 4)
  3679. void netdev_printk(const char *level, const struct net_device *dev,
  3680. const char *format, ...);
  3681. __printf(2, 3)
  3682. void netdev_emerg(const struct net_device *dev, const char *format, ...);
  3683. __printf(2, 3)
  3684. void netdev_alert(const struct net_device *dev, const char *format, ...);
  3685. __printf(2, 3)
  3686. void netdev_crit(const struct net_device *dev, const char *format, ...);
  3687. __printf(2, 3)
  3688. void netdev_err(const struct net_device *dev, const char *format, ...);
  3689. __printf(2, 3)
  3690. void netdev_warn(const struct net_device *dev, const char *format, ...);
  3691. __printf(2, 3)
  3692. void netdev_notice(const struct net_device *dev, const char *format, ...);
  3693. __printf(2, 3)
  3694. void netdev_info(const struct net_device *dev, const char *format, ...);
  3695. #define MODULE_ALIAS_NETDEV(device) \
  3696. MODULE_ALIAS("netdev-" device)
  3697. #if defined(CONFIG_DYNAMIC_DEBUG)
  3698. #define netdev_dbg(__dev, format, args...) \
  3699. do { \
  3700. dynamic_netdev_dbg(__dev, format, ##args); \
  3701. } while (0)
  3702. #elif defined(DEBUG)
  3703. #define netdev_dbg(__dev, format, args...) \
  3704. netdev_printk(KERN_DEBUG, __dev, format, ##args)
  3705. #else
  3706. #define netdev_dbg(__dev, format, args...) \
  3707. ({ \
  3708. if (0) \
  3709. netdev_printk(KERN_DEBUG, __dev, format, ##args); \
  3710. })
  3711. #endif
  3712. #if defined(VERBOSE_DEBUG)
  3713. #define netdev_vdbg netdev_dbg
  3714. #else
  3715. #define netdev_vdbg(dev, format, args...) \
  3716. ({ \
  3717. if (0) \
  3718. netdev_printk(KERN_DEBUG, dev, format, ##args); \
  3719. 0; \
  3720. })
  3721. #endif
  3722. /*
  3723. * netdev_WARN() acts like dev_printk(), but with the key difference
  3724. * of using a WARN/WARN_ON to get the message out, including the
  3725. * file/line information and a backtrace.
  3726. */
  3727. #define netdev_WARN(dev, format, args...) \
  3728. WARN(1, "netdevice: %s%s\n" format, netdev_name(dev), \
  3729. netdev_reg_state(dev), ##args)
  3730. /* netif printk helpers, similar to netdev_printk */
  3731. #define netif_printk(priv, type, level, dev, fmt, args...) \
  3732. do { \
  3733. if (netif_msg_##type(priv)) \
  3734. netdev_printk(level, (dev), fmt, ##args); \
  3735. } while (0)
  3736. #define netif_level(level, priv, type, dev, fmt, args...) \
  3737. do { \
  3738. if (netif_msg_##type(priv)) \
  3739. netdev_##level(dev, fmt, ##args); \
  3740. } while (0)
  3741. #define netif_emerg(priv, type, dev, fmt, args...) \
  3742. netif_level(emerg, priv, type, dev, fmt, ##args)
  3743. #define netif_alert(priv, type, dev, fmt, args...) \
  3744. netif_level(alert, priv, type, dev, fmt, ##args)
  3745. #define netif_crit(priv, type, dev, fmt, args...) \
  3746. netif_level(crit, priv, type, dev, fmt, ##args)
  3747. #define netif_err(priv, type, dev, fmt, args...) \
  3748. netif_level(err, priv, type, dev, fmt, ##args)
  3749. #define netif_warn(priv, type, dev, fmt, args...) \
  3750. netif_level(warn, priv, type, dev, fmt, ##args)
  3751. #define netif_notice(priv, type, dev, fmt, args...) \
  3752. netif_level(notice, priv, type, dev, fmt, ##args)
  3753. #define netif_info(priv, type, dev, fmt, args...) \
  3754. netif_level(info, priv, type, dev, fmt, ##args)
  3755. #if defined(CONFIG_DYNAMIC_DEBUG)
  3756. #define netif_dbg(priv, type, netdev, format, args...) \
  3757. do { \
  3758. if (netif_msg_##type(priv)) \
  3759. dynamic_netdev_dbg(netdev, format, ##args); \
  3760. } while (0)
  3761. #elif defined(DEBUG)
  3762. #define netif_dbg(priv, type, dev, format, args...) \
  3763. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args)
  3764. #else
  3765. #define netif_dbg(priv, type, dev, format, args...) \
  3766. ({ \
  3767. if (0) \
  3768. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  3769. 0; \
  3770. })
  3771. #endif
  3772. #if defined(VERBOSE_DEBUG)
  3773. #define netif_vdbg netif_dbg
  3774. #else
  3775. #define netif_vdbg(priv, type, dev, format, args...) \
  3776. ({ \
  3777. if (0) \
  3778. netif_printk(priv, type, KERN_DEBUG, dev, format, ##args); \
  3779. 0; \
  3780. })
  3781. #endif
  3782. /*
  3783. * The list of packet types we will receive (as opposed to discard)
  3784. * and the routines to invoke.
  3785. *
  3786. * Why 16. Because with 16 the only overlap we get on a hash of the
  3787. * low nibble of the protocol value is RARP/SNAP/X.25.
  3788. *
  3789. * NOTE: That is no longer true with the addition of VLAN tags. Not
  3790. * sure which should go first, but I bet it won't make much
  3791. * difference if we are running VLANs. The good news is that
  3792. * this protocol won't be in the list unless compiled in, so
  3793. * the average user (w/out VLANs) will not be adversely affected.
  3794. * --BLG
  3795. *
  3796. * 0800 IP
  3797. * 8100 802.1Q VLAN
  3798. * 0001 802.3
  3799. * 0002 AX.25
  3800. * 0004 802.2
  3801. * 8035 RARP
  3802. * 0005 SNAP
  3803. * 0805 X.25
  3804. * 0806 ARP
  3805. * 8137 IPX
  3806. * 0009 Localtalk
  3807. * 86DD IPv6
  3808. */
  3809. #define PTYPE_HASH_SIZE (16)
  3810. #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
  3811. #endif /* _LINUX_NETDEVICE_H */