br_multicast.c 100 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Bridge multicast support.
  4. *
  5. * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
  6. */
  7. #include <linux/err.h>
  8. #include <linux/export.h>
  9. #include <linux/if_ether.h>
  10. #include <linux/igmp.h>
  11. #include <linux/in.h>
  12. #include <linux/jhash.h>
  13. #include <linux/kernel.h>
  14. #include <linux/log2.h>
  15. #include <linux/netdevice.h>
  16. #include <linux/netfilter_bridge.h>
  17. #include <linux/random.h>
  18. #include <linux/rculist.h>
  19. #include <linux/skbuff.h>
  20. #include <linux/slab.h>
  21. #include <linux/timer.h>
  22. #include <linux/inetdevice.h>
  23. #include <linux/mroute.h>
  24. #include <net/ip.h>
  25. #include <net/switchdev.h>
  26. #if IS_ENABLED(CONFIG_IPV6)
  27. #include <linux/icmpv6.h>
  28. #include <net/ipv6.h>
  29. #include <net/mld.h>
  30. #include <net/ip6_checksum.h>
  31. #include <net/addrconf.h>
  32. #endif
  33. #include "br_private.h"
  34. static const struct rhashtable_params br_mdb_rht_params = {
  35. .head_offset = offsetof(struct net_bridge_mdb_entry, rhnode),
  36. .key_offset = offsetof(struct net_bridge_mdb_entry, addr),
  37. .key_len = sizeof(struct br_ip),
  38. .automatic_shrinking = true,
  39. };
  40. static const struct rhashtable_params br_sg_port_rht_params = {
  41. .head_offset = offsetof(struct net_bridge_port_group, rhnode),
  42. .key_offset = offsetof(struct net_bridge_port_group, key),
  43. .key_len = sizeof(struct net_bridge_port_group_sg_key),
  44. .automatic_shrinking = true,
  45. };
  46. static void br_multicast_start_querier(struct net_bridge *br,
  47. struct bridge_mcast_own_query *query);
  48. static void br_multicast_add_router(struct net_bridge *br,
  49. struct net_bridge_port *port);
  50. static void br_ip4_multicast_leave_group(struct net_bridge *br,
  51. struct net_bridge_port *port,
  52. __be32 group,
  53. __u16 vid,
  54. const unsigned char *src);
  55. static void br_multicast_port_group_rexmit(struct timer_list *t);
  56. static void __del_port_router(struct net_bridge_port *p);
  57. #if IS_ENABLED(CONFIG_IPV6)
  58. static void br_ip6_multicast_leave_group(struct net_bridge *br,
  59. struct net_bridge_port *port,
  60. const struct in6_addr *group,
  61. __u16 vid, const unsigned char *src);
  62. #endif
  63. static struct net_bridge_port_group *
  64. __br_multicast_add_group(struct net_bridge *br,
  65. struct net_bridge_port *port,
  66. struct br_ip *group,
  67. const unsigned char *src,
  68. u8 filter_mode,
  69. bool igmpv2_mldv1,
  70. bool blocked);
  71. static void br_multicast_find_del_pg(struct net_bridge *br,
  72. struct net_bridge_port_group *pg);
  73. static struct net_bridge_port_group *
  74. br_sg_port_find(struct net_bridge *br,
  75. struct net_bridge_port_group_sg_key *sg_p)
  76. {
  77. lockdep_assert_held_once(&br->multicast_lock);
  78. return rhashtable_lookup_fast(&br->sg_port_tbl, sg_p,
  79. br_sg_port_rht_params);
  80. }
  81. static struct net_bridge_mdb_entry *br_mdb_ip_get_rcu(struct net_bridge *br,
  82. struct br_ip *dst)
  83. {
  84. return rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
  85. }
  86. struct net_bridge_mdb_entry *br_mdb_ip_get(struct net_bridge *br,
  87. struct br_ip *dst)
  88. {
  89. struct net_bridge_mdb_entry *ent;
  90. lockdep_assert_held_once(&br->multicast_lock);
  91. rcu_read_lock();
  92. ent = rhashtable_lookup(&br->mdb_hash_tbl, dst, br_mdb_rht_params);
  93. rcu_read_unlock();
  94. return ent;
  95. }
  96. static struct net_bridge_mdb_entry *br_mdb_ip4_get(struct net_bridge *br,
  97. __be32 dst, __u16 vid)
  98. {
  99. struct br_ip br_dst;
  100. memset(&br_dst, 0, sizeof(br_dst));
  101. br_dst.dst.ip4 = dst;
  102. br_dst.proto = htons(ETH_P_IP);
  103. br_dst.vid = vid;
  104. return br_mdb_ip_get(br, &br_dst);
  105. }
  106. #if IS_ENABLED(CONFIG_IPV6)
  107. static struct net_bridge_mdb_entry *br_mdb_ip6_get(struct net_bridge *br,
  108. const struct in6_addr *dst,
  109. __u16 vid)
  110. {
  111. struct br_ip br_dst;
  112. memset(&br_dst, 0, sizeof(br_dst));
  113. br_dst.dst.ip6 = *dst;
  114. br_dst.proto = htons(ETH_P_IPV6);
  115. br_dst.vid = vid;
  116. return br_mdb_ip_get(br, &br_dst);
  117. }
  118. #endif
  119. struct net_bridge_mdb_entry *br_mdb_get(struct net_bridge *br,
  120. struct sk_buff *skb, u16 vid)
  121. {
  122. struct br_ip ip;
  123. if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
  124. return NULL;
  125. if (BR_INPUT_SKB_CB(skb)->igmp)
  126. return NULL;
  127. memset(&ip, 0, sizeof(ip));
  128. ip.proto = skb->protocol;
  129. ip.vid = vid;
  130. switch (skb->protocol) {
  131. case htons(ETH_P_IP):
  132. ip.dst.ip4 = ip_hdr(skb)->daddr;
  133. if (br->multicast_igmp_version == 3) {
  134. struct net_bridge_mdb_entry *mdb;
  135. ip.src.ip4 = ip_hdr(skb)->saddr;
  136. mdb = br_mdb_ip_get_rcu(br, &ip);
  137. if (mdb)
  138. return mdb;
  139. ip.src.ip4 = 0;
  140. }
  141. break;
  142. #if IS_ENABLED(CONFIG_IPV6)
  143. case htons(ETH_P_IPV6):
  144. ip.dst.ip6 = ipv6_hdr(skb)->daddr;
  145. if (br->multicast_mld_version == 2) {
  146. struct net_bridge_mdb_entry *mdb;
  147. ip.src.ip6 = ipv6_hdr(skb)->saddr;
  148. mdb = br_mdb_ip_get_rcu(br, &ip);
  149. if (mdb)
  150. return mdb;
  151. memset(&ip.src.ip6, 0, sizeof(ip.src.ip6));
  152. }
  153. break;
  154. #endif
  155. default:
  156. return NULL;
  157. }
  158. return br_mdb_ip_get_rcu(br, &ip);
  159. }
  160. static bool br_port_group_equal(struct net_bridge_port_group *p,
  161. struct net_bridge_port *port,
  162. const unsigned char *src)
  163. {
  164. if (p->key.port != port)
  165. return false;
  166. if (!(port->flags & BR_MULTICAST_TO_UNICAST))
  167. return true;
  168. return ether_addr_equal(src, p->eth_addr);
  169. }
  170. static void __fwd_add_star_excl(struct net_bridge_port_group *pg,
  171. struct br_ip *sg_ip)
  172. {
  173. struct net_bridge_port_group_sg_key sg_key;
  174. struct net_bridge *br = pg->key.port->br;
  175. struct net_bridge_port_group *src_pg;
  176. memset(&sg_key, 0, sizeof(sg_key));
  177. sg_key.port = pg->key.port;
  178. sg_key.addr = *sg_ip;
  179. if (br_sg_port_find(br, &sg_key))
  180. return;
  181. src_pg = __br_multicast_add_group(br, pg->key.port, sg_ip, pg->eth_addr,
  182. MCAST_INCLUDE, false, false);
  183. if (IS_ERR_OR_NULL(src_pg) ||
  184. src_pg->rt_protocol != RTPROT_KERNEL)
  185. return;
  186. src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
  187. }
  188. static void __fwd_del_star_excl(struct net_bridge_port_group *pg,
  189. struct br_ip *sg_ip)
  190. {
  191. struct net_bridge_port_group_sg_key sg_key;
  192. struct net_bridge *br = pg->key.port->br;
  193. struct net_bridge_port_group *src_pg;
  194. memset(&sg_key, 0, sizeof(sg_key));
  195. sg_key.port = pg->key.port;
  196. sg_key.addr = *sg_ip;
  197. src_pg = br_sg_port_find(br, &sg_key);
  198. if (!src_pg || !(src_pg->flags & MDB_PG_FLAGS_STAR_EXCL) ||
  199. src_pg->rt_protocol != RTPROT_KERNEL)
  200. return;
  201. br_multicast_find_del_pg(br, src_pg);
  202. }
  203. /* When a port group transitions to (or is added as) EXCLUDE we need to add it
  204. * to all other ports' S,G entries which are not blocked by the current group
  205. * for proper replication, the assumption is that any S,G blocked entries
  206. * are already added so the S,G,port lookup should skip them.
  207. * When a port group transitions from EXCLUDE -> INCLUDE mode or is being
  208. * deleted we need to remove it from all ports' S,G entries where it was
  209. * automatically installed before (i.e. where it's MDB_PG_FLAGS_STAR_EXCL).
  210. */
  211. void br_multicast_star_g_handle_mode(struct net_bridge_port_group *pg,
  212. u8 filter_mode)
  213. {
  214. struct net_bridge *br = pg->key.port->br;
  215. struct net_bridge_port_group *pg_lst;
  216. struct net_bridge_mdb_entry *mp;
  217. struct br_ip sg_ip;
  218. if (WARN_ON(!br_multicast_is_star_g(&pg->key.addr)))
  219. return;
  220. mp = br_mdb_ip_get(br, &pg->key.addr);
  221. if (!mp)
  222. return;
  223. memset(&sg_ip, 0, sizeof(sg_ip));
  224. sg_ip = pg->key.addr;
  225. for (pg_lst = mlock_dereference(mp->ports, br);
  226. pg_lst;
  227. pg_lst = mlock_dereference(pg_lst->next, br)) {
  228. struct net_bridge_group_src *src_ent;
  229. if (pg_lst == pg)
  230. continue;
  231. hlist_for_each_entry(src_ent, &pg_lst->src_list, node) {
  232. if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
  233. continue;
  234. sg_ip.src = src_ent->addr.src;
  235. switch (filter_mode) {
  236. case MCAST_INCLUDE:
  237. __fwd_del_star_excl(pg, &sg_ip);
  238. break;
  239. case MCAST_EXCLUDE:
  240. __fwd_add_star_excl(pg, &sg_ip);
  241. break;
  242. }
  243. }
  244. }
  245. }
  246. /* called when adding a new S,G with host_joined == false by default */
  247. static void br_multicast_sg_host_state(struct net_bridge_mdb_entry *star_mp,
  248. struct net_bridge_port_group *sg)
  249. {
  250. struct net_bridge_mdb_entry *sg_mp;
  251. if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
  252. return;
  253. if (!star_mp->host_joined)
  254. return;
  255. sg_mp = br_mdb_ip_get(star_mp->br, &sg->key.addr);
  256. if (!sg_mp)
  257. return;
  258. sg_mp->host_joined = true;
  259. }
  260. /* set the host_joined state of all of *,G's S,G entries */
  261. static void br_multicast_star_g_host_state(struct net_bridge_mdb_entry *star_mp)
  262. {
  263. struct net_bridge *br = star_mp->br;
  264. struct net_bridge_mdb_entry *sg_mp;
  265. struct net_bridge_port_group *pg;
  266. struct br_ip sg_ip;
  267. if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
  268. return;
  269. memset(&sg_ip, 0, sizeof(sg_ip));
  270. sg_ip = star_mp->addr;
  271. for (pg = mlock_dereference(star_mp->ports, br);
  272. pg;
  273. pg = mlock_dereference(pg->next, br)) {
  274. struct net_bridge_group_src *src_ent;
  275. hlist_for_each_entry(src_ent, &pg->src_list, node) {
  276. if (!(src_ent->flags & BR_SGRP_F_INSTALLED))
  277. continue;
  278. sg_ip.src = src_ent->addr.src;
  279. sg_mp = br_mdb_ip_get(br, &sg_ip);
  280. if (!sg_mp)
  281. continue;
  282. sg_mp->host_joined = star_mp->host_joined;
  283. }
  284. }
  285. }
  286. static void br_multicast_sg_del_exclude_ports(struct net_bridge_mdb_entry *sgmp)
  287. {
  288. struct net_bridge_port_group __rcu **pp;
  289. struct net_bridge_port_group *p;
  290. /* *,G exclude ports are only added to S,G entries */
  291. if (WARN_ON(br_multicast_is_star_g(&sgmp->addr)))
  292. return;
  293. /* we need the STAR_EXCLUDE ports if there are non-STAR_EXCLUDE ports
  294. * we should ignore perm entries since they're managed by user-space
  295. */
  296. for (pp = &sgmp->ports;
  297. (p = mlock_dereference(*pp, sgmp->br)) != NULL;
  298. pp = &p->next)
  299. if (!(p->flags & (MDB_PG_FLAGS_STAR_EXCL |
  300. MDB_PG_FLAGS_PERMANENT)))
  301. return;
  302. /* currently the host can only have joined the *,G which means
  303. * we treat it as EXCLUDE {}, so for an S,G it's considered a
  304. * STAR_EXCLUDE entry and we can safely leave it
  305. */
  306. sgmp->host_joined = false;
  307. for (pp = &sgmp->ports;
  308. (p = mlock_dereference(*pp, sgmp->br)) != NULL;) {
  309. if (!(p->flags & MDB_PG_FLAGS_PERMANENT))
  310. br_multicast_del_pg(sgmp, p, pp);
  311. else
  312. pp = &p->next;
  313. }
  314. }
  315. void br_multicast_sg_add_exclude_ports(struct net_bridge_mdb_entry *star_mp,
  316. struct net_bridge_port_group *sg)
  317. {
  318. struct net_bridge_port_group_sg_key sg_key;
  319. struct net_bridge *br = star_mp->br;
  320. struct net_bridge_port_group *pg;
  321. if (WARN_ON(br_multicast_is_star_g(&sg->key.addr)))
  322. return;
  323. if (WARN_ON(!br_multicast_is_star_g(&star_mp->addr)))
  324. return;
  325. br_multicast_sg_host_state(star_mp, sg);
  326. memset(&sg_key, 0, sizeof(sg_key));
  327. sg_key.addr = sg->key.addr;
  328. /* we need to add all exclude ports to the S,G */
  329. for (pg = mlock_dereference(star_mp->ports, br);
  330. pg;
  331. pg = mlock_dereference(pg->next, br)) {
  332. struct net_bridge_port_group *src_pg;
  333. if (pg == sg || pg->filter_mode == MCAST_INCLUDE)
  334. continue;
  335. sg_key.port = pg->key.port;
  336. if (br_sg_port_find(br, &sg_key))
  337. continue;
  338. src_pg = __br_multicast_add_group(br, pg->key.port,
  339. &sg->key.addr,
  340. sg->eth_addr,
  341. MCAST_INCLUDE, false, false);
  342. if (IS_ERR_OR_NULL(src_pg) ||
  343. src_pg->rt_protocol != RTPROT_KERNEL)
  344. continue;
  345. src_pg->flags |= MDB_PG_FLAGS_STAR_EXCL;
  346. }
  347. }
  348. static void br_multicast_fwd_src_add(struct net_bridge_group_src *src)
  349. {
  350. struct net_bridge_mdb_entry *star_mp;
  351. struct net_bridge_port_group *sg;
  352. struct br_ip sg_ip;
  353. if (src->flags & BR_SGRP_F_INSTALLED)
  354. return;
  355. memset(&sg_ip, 0, sizeof(sg_ip));
  356. sg_ip = src->pg->key.addr;
  357. sg_ip.src = src->addr.src;
  358. sg = __br_multicast_add_group(src->br, src->pg->key.port, &sg_ip,
  359. src->pg->eth_addr, MCAST_INCLUDE, false,
  360. !timer_pending(&src->timer));
  361. if (IS_ERR_OR_NULL(sg))
  362. return;
  363. src->flags |= BR_SGRP_F_INSTALLED;
  364. sg->flags &= ~MDB_PG_FLAGS_STAR_EXCL;
  365. /* if it was added by user-space as perm we can skip next steps */
  366. if (sg->rt_protocol != RTPROT_KERNEL &&
  367. (sg->flags & MDB_PG_FLAGS_PERMANENT))
  368. return;
  369. /* the kernel is now responsible for removing this S,G */
  370. del_timer(&sg->timer);
  371. star_mp = br_mdb_ip_get(src->br, &src->pg->key.addr);
  372. if (!star_mp)
  373. return;
  374. br_multicast_sg_add_exclude_ports(star_mp, sg);
  375. }
  376. static void br_multicast_fwd_src_remove(struct net_bridge_group_src *src)
  377. {
  378. struct net_bridge_port_group *p, *pg = src->pg;
  379. struct net_bridge_port_group __rcu **pp;
  380. struct net_bridge_mdb_entry *mp;
  381. struct br_ip sg_ip;
  382. memset(&sg_ip, 0, sizeof(sg_ip));
  383. sg_ip = pg->key.addr;
  384. sg_ip.src = src->addr.src;
  385. mp = br_mdb_ip_get(src->br, &sg_ip);
  386. if (!mp)
  387. return;
  388. for (pp = &mp->ports;
  389. (p = mlock_dereference(*pp, src->br)) != NULL;
  390. pp = &p->next) {
  391. if (!br_port_group_equal(p, pg->key.port, pg->eth_addr))
  392. continue;
  393. if (p->rt_protocol != RTPROT_KERNEL &&
  394. (p->flags & MDB_PG_FLAGS_PERMANENT))
  395. break;
  396. br_multicast_del_pg(mp, p, pp);
  397. break;
  398. }
  399. src->flags &= ~BR_SGRP_F_INSTALLED;
  400. }
  401. /* install S,G and based on src's timer enable or disable forwarding */
  402. static void br_multicast_fwd_src_handle(struct net_bridge_group_src *src)
  403. {
  404. struct net_bridge_port_group_sg_key sg_key;
  405. struct net_bridge_port_group *sg;
  406. u8 old_flags;
  407. br_multicast_fwd_src_add(src);
  408. memset(&sg_key, 0, sizeof(sg_key));
  409. sg_key.addr = src->pg->key.addr;
  410. sg_key.addr.src = src->addr.src;
  411. sg_key.port = src->pg->key.port;
  412. sg = br_sg_port_find(src->br, &sg_key);
  413. if (!sg || (sg->flags & MDB_PG_FLAGS_PERMANENT))
  414. return;
  415. old_flags = sg->flags;
  416. if (timer_pending(&src->timer))
  417. sg->flags &= ~MDB_PG_FLAGS_BLOCKED;
  418. else
  419. sg->flags |= MDB_PG_FLAGS_BLOCKED;
  420. if (old_flags != sg->flags) {
  421. struct net_bridge_mdb_entry *sg_mp;
  422. sg_mp = br_mdb_ip_get(src->br, &sg_key.addr);
  423. if (!sg_mp)
  424. return;
  425. br_mdb_notify(src->br->dev, sg_mp, sg, RTM_NEWMDB);
  426. }
  427. }
  428. static void br_multicast_destroy_mdb_entry(struct net_bridge_mcast_gc *gc)
  429. {
  430. struct net_bridge_mdb_entry *mp;
  431. mp = container_of(gc, struct net_bridge_mdb_entry, mcast_gc);
  432. WARN_ON(!hlist_unhashed(&mp->mdb_node));
  433. WARN_ON(mp->ports);
  434. del_timer_sync(&mp->timer);
  435. kfree_rcu(mp, rcu);
  436. }
  437. static void br_multicast_del_mdb_entry(struct net_bridge_mdb_entry *mp)
  438. {
  439. struct net_bridge *br = mp->br;
  440. rhashtable_remove_fast(&br->mdb_hash_tbl, &mp->rhnode,
  441. br_mdb_rht_params);
  442. hlist_del_init_rcu(&mp->mdb_node);
  443. hlist_add_head(&mp->mcast_gc.gc_node, &br->mcast_gc_list);
  444. queue_work(system_long_wq, &br->mcast_gc_work);
  445. }
  446. static void br_multicast_group_expired(struct timer_list *t)
  447. {
  448. struct net_bridge_mdb_entry *mp = from_timer(mp, t, timer);
  449. struct net_bridge *br = mp->br;
  450. spin_lock(&br->multicast_lock);
  451. if (hlist_unhashed(&mp->mdb_node) || !netif_running(br->dev) ||
  452. timer_pending(&mp->timer))
  453. goto out;
  454. br_multicast_host_leave(mp, true);
  455. if (mp->ports)
  456. goto out;
  457. br_multicast_del_mdb_entry(mp);
  458. out:
  459. spin_unlock(&br->multicast_lock);
  460. }
  461. static void br_multicast_destroy_group_src(struct net_bridge_mcast_gc *gc)
  462. {
  463. struct net_bridge_group_src *src;
  464. src = container_of(gc, struct net_bridge_group_src, mcast_gc);
  465. WARN_ON(!hlist_unhashed(&src->node));
  466. del_timer_sync(&src->timer);
  467. kfree_rcu(src, rcu);
  468. }
  469. static void br_multicast_del_group_src(struct net_bridge_group_src *src)
  470. {
  471. struct net_bridge *br = src->pg->key.port->br;
  472. br_multicast_fwd_src_remove(src);
  473. hlist_del_init_rcu(&src->node);
  474. src->pg->src_ents--;
  475. hlist_add_head(&src->mcast_gc.gc_node, &br->mcast_gc_list);
  476. queue_work(system_long_wq, &br->mcast_gc_work);
  477. }
  478. static void br_multicast_destroy_port_group(struct net_bridge_mcast_gc *gc)
  479. {
  480. struct net_bridge_port_group *pg;
  481. pg = container_of(gc, struct net_bridge_port_group, mcast_gc);
  482. WARN_ON(!hlist_unhashed(&pg->mglist));
  483. WARN_ON(!hlist_empty(&pg->src_list));
  484. del_timer_sync(&pg->rexmit_timer);
  485. del_timer_sync(&pg->timer);
  486. kfree_rcu(pg, rcu);
  487. }
  488. void br_multicast_del_pg(struct net_bridge_mdb_entry *mp,
  489. struct net_bridge_port_group *pg,
  490. struct net_bridge_port_group __rcu **pp)
  491. {
  492. struct net_bridge *br = pg->key.port->br;
  493. struct net_bridge_group_src *ent;
  494. struct hlist_node *tmp;
  495. rcu_assign_pointer(*pp, pg->next);
  496. hlist_del_init(&pg->mglist);
  497. hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
  498. br_multicast_del_group_src(ent);
  499. br_mdb_notify(br->dev, mp, pg, RTM_DELMDB);
  500. if (!br_multicast_is_star_g(&mp->addr)) {
  501. rhashtable_remove_fast(&br->sg_port_tbl, &pg->rhnode,
  502. br_sg_port_rht_params);
  503. br_multicast_sg_del_exclude_ports(mp);
  504. } else {
  505. br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE);
  506. }
  507. hlist_add_head(&pg->mcast_gc.gc_node, &br->mcast_gc_list);
  508. queue_work(system_long_wq, &br->mcast_gc_work);
  509. if (!mp->ports && !mp->host_joined && netif_running(br->dev))
  510. mod_timer(&mp->timer, jiffies);
  511. }
  512. static void br_multicast_find_del_pg(struct net_bridge *br,
  513. struct net_bridge_port_group *pg)
  514. {
  515. struct net_bridge_port_group __rcu **pp;
  516. struct net_bridge_mdb_entry *mp;
  517. struct net_bridge_port_group *p;
  518. mp = br_mdb_ip_get(br, &pg->key.addr);
  519. if (WARN_ON(!mp))
  520. return;
  521. for (pp = &mp->ports;
  522. (p = mlock_dereference(*pp, br)) != NULL;
  523. pp = &p->next) {
  524. if (p != pg)
  525. continue;
  526. br_multicast_del_pg(mp, pg, pp);
  527. return;
  528. }
  529. WARN_ON(1);
  530. }
  531. static void br_multicast_port_group_expired(struct timer_list *t)
  532. {
  533. struct net_bridge_port_group *pg = from_timer(pg, t, timer);
  534. struct net_bridge_group_src *src_ent;
  535. struct net_bridge *br = pg->key.port->br;
  536. struct hlist_node *tmp;
  537. bool changed;
  538. spin_lock(&br->multicast_lock);
  539. if (!netif_running(br->dev) || timer_pending(&pg->timer) ||
  540. hlist_unhashed(&pg->mglist) || pg->flags & MDB_PG_FLAGS_PERMANENT)
  541. goto out;
  542. changed = !!(pg->filter_mode == MCAST_EXCLUDE);
  543. pg->filter_mode = MCAST_INCLUDE;
  544. hlist_for_each_entry_safe(src_ent, tmp, &pg->src_list, node) {
  545. if (!timer_pending(&src_ent->timer)) {
  546. br_multicast_del_group_src(src_ent);
  547. changed = true;
  548. }
  549. }
  550. if (hlist_empty(&pg->src_list)) {
  551. br_multicast_find_del_pg(br, pg);
  552. } else if (changed) {
  553. struct net_bridge_mdb_entry *mp = br_mdb_ip_get(br, &pg->key.addr);
  554. if (changed && br_multicast_is_star_g(&pg->key.addr))
  555. br_multicast_star_g_handle_mode(pg, MCAST_INCLUDE);
  556. if (WARN_ON(!mp))
  557. goto out;
  558. br_mdb_notify(br->dev, mp, pg, RTM_NEWMDB);
  559. }
  560. out:
  561. spin_unlock(&br->multicast_lock);
  562. }
  563. static void br_multicast_gc(struct hlist_head *head)
  564. {
  565. struct net_bridge_mcast_gc *gcent;
  566. struct hlist_node *tmp;
  567. hlist_for_each_entry_safe(gcent, tmp, head, gc_node) {
  568. hlist_del_init(&gcent->gc_node);
  569. gcent->destroy(gcent);
  570. }
  571. }
  572. static struct sk_buff *br_ip4_multicast_alloc_query(struct net_bridge *br,
  573. struct net_bridge_port_group *pg,
  574. __be32 ip_dst, __be32 group,
  575. bool with_srcs, bool over_lmqt,
  576. u8 sflag, u8 *igmp_type,
  577. bool *need_rexmit)
  578. {
  579. struct net_bridge_port *p = pg ? pg->key.port : NULL;
  580. struct net_bridge_group_src *ent;
  581. size_t pkt_size, igmp_hdr_size;
  582. unsigned long now = jiffies;
  583. struct igmpv3_query *ihv3;
  584. void *csum_start = NULL;
  585. __sum16 *csum = NULL;
  586. struct sk_buff *skb;
  587. struct igmphdr *ih;
  588. struct ethhdr *eth;
  589. unsigned long lmqt;
  590. struct iphdr *iph;
  591. u16 lmqt_srcs = 0;
  592. igmp_hdr_size = sizeof(*ih);
  593. if (br->multicast_igmp_version == 3) {
  594. igmp_hdr_size = sizeof(*ihv3);
  595. if (pg && with_srcs) {
  596. lmqt = now + (br->multicast_last_member_interval *
  597. br->multicast_last_member_count);
  598. hlist_for_each_entry(ent, &pg->src_list, node) {
  599. if (over_lmqt == time_after(ent->timer.expires,
  600. lmqt) &&
  601. ent->src_query_rexmit_cnt > 0)
  602. lmqt_srcs++;
  603. }
  604. if (!lmqt_srcs)
  605. return NULL;
  606. igmp_hdr_size += lmqt_srcs * sizeof(__be32);
  607. }
  608. }
  609. pkt_size = sizeof(*eth) + sizeof(*iph) + 4 + igmp_hdr_size;
  610. if ((p && pkt_size > p->dev->mtu) ||
  611. pkt_size > br->dev->mtu)
  612. return NULL;
  613. skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
  614. if (!skb)
  615. goto out;
  616. skb->protocol = htons(ETH_P_IP);
  617. skb_reset_mac_header(skb);
  618. eth = eth_hdr(skb);
  619. ether_addr_copy(eth->h_source, br->dev->dev_addr);
  620. ip_eth_mc_map(ip_dst, eth->h_dest);
  621. eth->h_proto = htons(ETH_P_IP);
  622. skb_put(skb, sizeof(*eth));
  623. skb_set_network_header(skb, skb->len);
  624. iph = ip_hdr(skb);
  625. iph->tot_len = htons(pkt_size - sizeof(*eth));
  626. iph->version = 4;
  627. iph->ihl = 6;
  628. iph->tos = 0xc0;
  629. iph->id = 0;
  630. iph->frag_off = htons(IP_DF);
  631. iph->ttl = 1;
  632. iph->protocol = IPPROTO_IGMP;
  633. iph->saddr = br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR) ?
  634. inet_select_addr(br->dev, 0, RT_SCOPE_LINK) : 0;
  635. iph->daddr = ip_dst;
  636. ((u8 *)&iph[1])[0] = IPOPT_RA;
  637. ((u8 *)&iph[1])[1] = 4;
  638. ((u8 *)&iph[1])[2] = 0;
  639. ((u8 *)&iph[1])[3] = 0;
  640. ip_send_check(iph);
  641. skb_put(skb, 24);
  642. skb_set_transport_header(skb, skb->len);
  643. *igmp_type = IGMP_HOST_MEMBERSHIP_QUERY;
  644. switch (br->multicast_igmp_version) {
  645. case 2:
  646. ih = igmp_hdr(skb);
  647. ih->type = IGMP_HOST_MEMBERSHIP_QUERY;
  648. ih->code = (group ? br->multicast_last_member_interval :
  649. br->multicast_query_response_interval) /
  650. (HZ / IGMP_TIMER_SCALE);
  651. ih->group = group;
  652. ih->csum = 0;
  653. csum = &ih->csum;
  654. csum_start = (void *)ih;
  655. break;
  656. case 3:
  657. ihv3 = igmpv3_query_hdr(skb);
  658. ihv3->type = IGMP_HOST_MEMBERSHIP_QUERY;
  659. ihv3->code = (group ? br->multicast_last_member_interval :
  660. br->multicast_query_response_interval) /
  661. (HZ / IGMP_TIMER_SCALE);
  662. ihv3->group = group;
  663. ihv3->qqic = br->multicast_query_interval / HZ;
  664. ihv3->nsrcs = htons(lmqt_srcs);
  665. ihv3->resv = 0;
  666. ihv3->suppress = sflag;
  667. ihv3->qrv = 2;
  668. ihv3->csum = 0;
  669. csum = &ihv3->csum;
  670. csum_start = (void *)ihv3;
  671. if (!pg || !with_srcs)
  672. break;
  673. lmqt_srcs = 0;
  674. hlist_for_each_entry(ent, &pg->src_list, node) {
  675. if (over_lmqt == time_after(ent->timer.expires,
  676. lmqt) &&
  677. ent->src_query_rexmit_cnt > 0) {
  678. ihv3->srcs[lmqt_srcs++] = ent->addr.src.ip4;
  679. ent->src_query_rexmit_cnt--;
  680. if (need_rexmit && ent->src_query_rexmit_cnt)
  681. *need_rexmit = true;
  682. }
  683. }
  684. if (WARN_ON(lmqt_srcs != ntohs(ihv3->nsrcs))) {
  685. kfree_skb(skb);
  686. return NULL;
  687. }
  688. break;
  689. }
  690. if (WARN_ON(!csum || !csum_start)) {
  691. kfree_skb(skb);
  692. return NULL;
  693. }
  694. *csum = ip_compute_csum(csum_start, igmp_hdr_size);
  695. skb_put(skb, igmp_hdr_size);
  696. __skb_pull(skb, sizeof(*eth));
  697. out:
  698. return skb;
  699. }
  700. #if IS_ENABLED(CONFIG_IPV6)
  701. static struct sk_buff *br_ip6_multicast_alloc_query(struct net_bridge *br,
  702. struct net_bridge_port_group *pg,
  703. const struct in6_addr *ip6_dst,
  704. const struct in6_addr *group,
  705. bool with_srcs, bool over_llqt,
  706. u8 sflag, u8 *igmp_type,
  707. bool *need_rexmit)
  708. {
  709. struct net_bridge_port *p = pg ? pg->key.port : NULL;
  710. struct net_bridge_group_src *ent;
  711. size_t pkt_size, mld_hdr_size;
  712. unsigned long now = jiffies;
  713. struct mld2_query *mld2q;
  714. void *csum_start = NULL;
  715. unsigned long interval;
  716. __sum16 *csum = NULL;
  717. struct ipv6hdr *ip6h;
  718. struct mld_msg *mldq;
  719. struct sk_buff *skb;
  720. unsigned long llqt;
  721. struct ethhdr *eth;
  722. u16 llqt_srcs = 0;
  723. u8 *hopopt;
  724. mld_hdr_size = sizeof(*mldq);
  725. if (br->multicast_mld_version == 2) {
  726. mld_hdr_size = sizeof(*mld2q);
  727. if (pg && with_srcs) {
  728. llqt = now + (br->multicast_last_member_interval *
  729. br->multicast_last_member_count);
  730. hlist_for_each_entry(ent, &pg->src_list, node) {
  731. if (over_llqt == time_after(ent->timer.expires,
  732. llqt) &&
  733. ent->src_query_rexmit_cnt > 0)
  734. llqt_srcs++;
  735. }
  736. if (!llqt_srcs)
  737. return NULL;
  738. mld_hdr_size += llqt_srcs * sizeof(struct in6_addr);
  739. }
  740. }
  741. pkt_size = sizeof(*eth) + sizeof(*ip6h) + 8 + mld_hdr_size;
  742. if ((p && pkt_size > p->dev->mtu) ||
  743. pkt_size > br->dev->mtu)
  744. return NULL;
  745. skb = netdev_alloc_skb_ip_align(br->dev, pkt_size);
  746. if (!skb)
  747. goto out;
  748. skb->protocol = htons(ETH_P_IPV6);
  749. /* Ethernet header */
  750. skb_reset_mac_header(skb);
  751. eth = eth_hdr(skb);
  752. ether_addr_copy(eth->h_source, br->dev->dev_addr);
  753. eth->h_proto = htons(ETH_P_IPV6);
  754. skb_put(skb, sizeof(*eth));
  755. /* IPv6 header + HbH option */
  756. skb_set_network_header(skb, skb->len);
  757. ip6h = ipv6_hdr(skb);
  758. *(__force __be32 *)ip6h = htonl(0x60000000);
  759. ip6h->payload_len = htons(8 + mld_hdr_size);
  760. ip6h->nexthdr = IPPROTO_HOPOPTS;
  761. ip6h->hop_limit = 1;
  762. ip6h->daddr = *ip6_dst;
  763. if (ipv6_dev_get_saddr(dev_net(br->dev), br->dev, &ip6h->daddr, 0,
  764. &ip6h->saddr)) {
  765. kfree_skb(skb);
  766. br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, false);
  767. return NULL;
  768. }
  769. br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
  770. ipv6_eth_mc_map(&ip6h->daddr, eth->h_dest);
  771. hopopt = (u8 *)(ip6h + 1);
  772. hopopt[0] = IPPROTO_ICMPV6; /* next hdr */
  773. hopopt[1] = 0; /* length of HbH */
  774. hopopt[2] = IPV6_TLV_ROUTERALERT; /* Router Alert */
  775. hopopt[3] = 2; /* Length of RA Option */
  776. hopopt[4] = 0; /* Type = 0x0000 (MLD) */
  777. hopopt[5] = 0;
  778. hopopt[6] = IPV6_TLV_PAD1; /* Pad1 */
  779. hopopt[7] = IPV6_TLV_PAD1; /* Pad1 */
  780. skb_put(skb, sizeof(*ip6h) + 8);
  781. /* ICMPv6 */
  782. skb_set_transport_header(skb, skb->len);
  783. interval = ipv6_addr_any(group) ?
  784. br->multicast_query_response_interval :
  785. br->multicast_last_member_interval;
  786. *igmp_type = ICMPV6_MGM_QUERY;
  787. switch (br->multicast_mld_version) {
  788. case 1:
  789. mldq = (struct mld_msg *)icmp6_hdr(skb);
  790. mldq->mld_type = ICMPV6_MGM_QUERY;
  791. mldq->mld_code = 0;
  792. mldq->mld_cksum = 0;
  793. mldq->mld_maxdelay = htons((u16)jiffies_to_msecs(interval));
  794. mldq->mld_reserved = 0;
  795. mldq->mld_mca = *group;
  796. csum = &mldq->mld_cksum;
  797. csum_start = (void *)mldq;
  798. break;
  799. case 2:
  800. mld2q = (struct mld2_query *)icmp6_hdr(skb);
  801. mld2q->mld2q_mrc = htons((u16)jiffies_to_msecs(interval));
  802. mld2q->mld2q_type = ICMPV6_MGM_QUERY;
  803. mld2q->mld2q_code = 0;
  804. mld2q->mld2q_cksum = 0;
  805. mld2q->mld2q_resv1 = 0;
  806. mld2q->mld2q_resv2 = 0;
  807. mld2q->mld2q_suppress = sflag;
  808. mld2q->mld2q_qrv = 2;
  809. mld2q->mld2q_nsrcs = htons(llqt_srcs);
  810. mld2q->mld2q_qqic = br->multicast_query_interval / HZ;
  811. mld2q->mld2q_mca = *group;
  812. csum = &mld2q->mld2q_cksum;
  813. csum_start = (void *)mld2q;
  814. if (!pg || !with_srcs)
  815. break;
  816. llqt_srcs = 0;
  817. hlist_for_each_entry(ent, &pg->src_list, node) {
  818. if (over_llqt == time_after(ent->timer.expires,
  819. llqt) &&
  820. ent->src_query_rexmit_cnt > 0) {
  821. mld2q->mld2q_srcs[llqt_srcs++] = ent->addr.src.ip6;
  822. ent->src_query_rexmit_cnt--;
  823. if (need_rexmit && ent->src_query_rexmit_cnt)
  824. *need_rexmit = true;
  825. }
  826. }
  827. if (WARN_ON(llqt_srcs != ntohs(mld2q->mld2q_nsrcs))) {
  828. kfree_skb(skb);
  829. return NULL;
  830. }
  831. break;
  832. }
  833. if (WARN_ON(!csum || !csum_start)) {
  834. kfree_skb(skb);
  835. return NULL;
  836. }
  837. *csum = csum_ipv6_magic(&ip6h->saddr, &ip6h->daddr, mld_hdr_size,
  838. IPPROTO_ICMPV6,
  839. csum_partial(csum_start, mld_hdr_size, 0));
  840. skb_put(skb, mld_hdr_size);
  841. __skb_pull(skb, sizeof(*eth));
  842. out:
  843. return skb;
  844. }
  845. #endif
  846. static struct sk_buff *br_multicast_alloc_query(struct net_bridge *br,
  847. struct net_bridge_port_group *pg,
  848. struct br_ip *ip_dst,
  849. struct br_ip *group,
  850. bool with_srcs, bool over_lmqt,
  851. u8 sflag, u8 *igmp_type,
  852. bool *need_rexmit)
  853. {
  854. __be32 ip4_dst;
  855. switch (group->proto) {
  856. case htons(ETH_P_IP):
  857. ip4_dst = ip_dst ? ip_dst->dst.ip4 : htonl(INADDR_ALLHOSTS_GROUP);
  858. return br_ip4_multicast_alloc_query(br, pg,
  859. ip4_dst, group->dst.ip4,
  860. with_srcs, over_lmqt,
  861. sflag, igmp_type,
  862. need_rexmit);
  863. #if IS_ENABLED(CONFIG_IPV6)
  864. case htons(ETH_P_IPV6): {
  865. struct in6_addr ip6_dst;
  866. if (ip_dst)
  867. ip6_dst = ip_dst->dst.ip6;
  868. else
  869. ipv6_addr_set(&ip6_dst, htonl(0xff020000), 0, 0,
  870. htonl(1));
  871. return br_ip6_multicast_alloc_query(br, pg,
  872. &ip6_dst, &group->dst.ip6,
  873. with_srcs, over_lmqt,
  874. sflag, igmp_type,
  875. need_rexmit);
  876. }
  877. #endif
  878. }
  879. return NULL;
  880. }
  881. struct net_bridge_mdb_entry *br_multicast_new_group(struct net_bridge *br,
  882. struct br_ip *group)
  883. {
  884. struct net_bridge_mdb_entry *mp;
  885. int err;
  886. mp = br_mdb_ip_get(br, group);
  887. if (mp)
  888. return mp;
  889. if (atomic_read(&br->mdb_hash_tbl.nelems) >= br->hash_max) {
  890. br_opt_toggle(br, BROPT_MULTICAST_ENABLED, false);
  891. return ERR_PTR(-E2BIG);
  892. }
  893. mp = kzalloc(sizeof(*mp), GFP_ATOMIC);
  894. if (unlikely(!mp))
  895. return ERR_PTR(-ENOMEM);
  896. mp->br = br;
  897. mp->addr = *group;
  898. mp->mcast_gc.destroy = br_multicast_destroy_mdb_entry;
  899. timer_setup(&mp->timer, br_multicast_group_expired, 0);
  900. err = rhashtable_lookup_insert_fast(&br->mdb_hash_tbl, &mp->rhnode,
  901. br_mdb_rht_params);
  902. if (err) {
  903. kfree(mp);
  904. mp = ERR_PTR(err);
  905. } else {
  906. hlist_add_head_rcu(&mp->mdb_node, &br->mdb_list);
  907. }
  908. return mp;
  909. }
  910. static void br_multicast_group_src_expired(struct timer_list *t)
  911. {
  912. struct net_bridge_group_src *src = from_timer(src, t, timer);
  913. struct net_bridge_port_group *pg;
  914. struct net_bridge *br = src->br;
  915. spin_lock(&br->multicast_lock);
  916. if (hlist_unhashed(&src->node) || !netif_running(br->dev) ||
  917. timer_pending(&src->timer))
  918. goto out;
  919. pg = src->pg;
  920. if (pg->filter_mode == MCAST_INCLUDE) {
  921. br_multicast_del_group_src(src);
  922. if (!hlist_empty(&pg->src_list))
  923. goto out;
  924. br_multicast_find_del_pg(br, pg);
  925. } else {
  926. br_multicast_fwd_src_handle(src);
  927. }
  928. out:
  929. spin_unlock(&br->multicast_lock);
  930. }
  931. static struct net_bridge_group_src *
  932. br_multicast_find_group_src(struct net_bridge_port_group *pg, struct br_ip *ip)
  933. {
  934. struct net_bridge_group_src *ent;
  935. switch (ip->proto) {
  936. case htons(ETH_P_IP):
  937. hlist_for_each_entry(ent, &pg->src_list, node)
  938. if (ip->src.ip4 == ent->addr.src.ip4)
  939. return ent;
  940. break;
  941. #if IS_ENABLED(CONFIG_IPV6)
  942. case htons(ETH_P_IPV6):
  943. hlist_for_each_entry(ent, &pg->src_list, node)
  944. if (!ipv6_addr_cmp(&ent->addr.src.ip6, &ip->src.ip6))
  945. return ent;
  946. break;
  947. #endif
  948. }
  949. return NULL;
  950. }
  951. static struct net_bridge_group_src *
  952. br_multicast_new_group_src(struct net_bridge_port_group *pg, struct br_ip *src_ip)
  953. {
  954. struct net_bridge_group_src *grp_src;
  955. if (unlikely(pg->src_ents >= PG_SRC_ENT_LIMIT))
  956. return NULL;
  957. switch (src_ip->proto) {
  958. case htons(ETH_P_IP):
  959. if (ipv4_is_zeronet(src_ip->src.ip4) ||
  960. ipv4_is_multicast(src_ip->src.ip4))
  961. return NULL;
  962. break;
  963. #if IS_ENABLED(CONFIG_IPV6)
  964. case htons(ETH_P_IPV6):
  965. if (ipv6_addr_any(&src_ip->src.ip6) ||
  966. ipv6_addr_is_multicast(&src_ip->src.ip6))
  967. return NULL;
  968. break;
  969. #endif
  970. }
  971. grp_src = kzalloc(sizeof(*grp_src), GFP_ATOMIC);
  972. if (unlikely(!grp_src))
  973. return NULL;
  974. grp_src->pg = pg;
  975. grp_src->br = pg->key.port->br;
  976. grp_src->addr = *src_ip;
  977. grp_src->mcast_gc.destroy = br_multicast_destroy_group_src;
  978. timer_setup(&grp_src->timer, br_multicast_group_src_expired, 0);
  979. hlist_add_head_rcu(&grp_src->node, &pg->src_list);
  980. pg->src_ents++;
  981. return grp_src;
  982. }
  983. struct net_bridge_port_group *br_multicast_new_port_group(
  984. struct net_bridge_port *port,
  985. struct br_ip *group,
  986. struct net_bridge_port_group __rcu *next,
  987. unsigned char flags,
  988. const unsigned char *src,
  989. u8 filter_mode,
  990. u8 rt_protocol)
  991. {
  992. struct net_bridge_port_group *p;
  993. p = kzalloc(sizeof(*p), GFP_ATOMIC);
  994. if (unlikely(!p))
  995. return NULL;
  996. p->key.addr = *group;
  997. p->key.port = port;
  998. p->flags = flags;
  999. p->filter_mode = filter_mode;
  1000. p->rt_protocol = rt_protocol;
  1001. p->mcast_gc.destroy = br_multicast_destroy_port_group;
  1002. INIT_HLIST_HEAD(&p->src_list);
  1003. if (!br_multicast_is_star_g(group) &&
  1004. rhashtable_lookup_insert_fast(&port->br->sg_port_tbl, &p->rhnode,
  1005. br_sg_port_rht_params)) {
  1006. kfree(p);
  1007. return NULL;
  1008. }
  1009. rcu_assign_pointer(p->next, next);
  1010. timer_setup(&p->timer, br_multicast_port_group_expired, 0);
  1011. timer_setup(&p->rexmit_timer, br_multicast_port_group_rexmit, 0);
  1012. hlist_add_head(&p->mglist, &port->mglist);
  1013. if (src)
  1014. memcpy(p->eth_addr, src, ETH_ALEN);
  1015. else
  1016. eth_broadcast_addr(p->eth_addr);
  1017. return p;
  1018. }
  1019. void br_multicast_host_join(struct net_bridge_mdb_entry *mp, bool notify)
  1020. {
  1021. if (!mp->host_joined) {
  1022. mp->host_joined = true;
  1023. if (br_multicast_is_star_g(&mp->addr))
  1024. br_multicast_star_g_host_state(mp);
  1025. if (notify)
  1026. br_mdb_notify(mp->br->dev, mp, NULL, RTM_NEWMDB);
  1027. }
  1028. mod_timer(&mp->timer, jiffies + mp->br->multicast_membership_interval);
  1029. }
  1030. void br_multicast_host_leave(struct net_bridge_mdb_entry *mp, bool notify)
  1031. {
  1032. if (!mp->host_joined)
  1033. return;
  1034. mp->host_joined = false;
  1035. if (br_multicast_is_star_g(&mp->addr))
  1036. br_multicast_star_g_host_state(mp);
  1037. if (notify)
  1038. br_mdb_notify(mp->br->dev, mp, NULL, RTM_DELMDB);
  1039. }
  1040. static struct net_bridge_port_group *
  1041. __br_multicast_add_group(struct net_bridge *br,
  1042. struct net_bridge_port *port,
  1043. struct br_ip *group,
  1044. const unsigned char *src,
  1045. u8 filter_mode,
  1046. bool igmpv2_mldv1,
  1047. bool blocked)
  1048. {
  1049. struct net_bridge_port_group __rcu **pp;
  1050. struct net_bridge_port_group *p = NULL;
  1051. struct net_bridge_mdb_entry *mp;
  1052. unsigned long now = jiffies;
  1053. if (!netif_running(br->dev) ||
  1054. (port && port->state == BR_STATE_DISABLED))
  1055. goto out;
  1056. mp = br_multicast_new_group(br, group);
  1057. if (IS_ERR(mp))
  1058. return ERR_PTR(PTR_ERR(mp));
  1059. if (!port) {
  1060. br_multicast_host_join(mp, true);
  1061. goto out;
  1062. }
  1063. for (pp = &mp->ports;
  1064. (p = mlock_dereference(*pp, br)) != NULL;
  1065. pp = &p->next) {
  1066. if (br_port_group_equal(p, port, src))
  1067. goto found;
  1068. if ((unsigned long)p->key.port < (unsigned long)port)
  1069. break;
  1070. }
  1071. p = br_multicast_new_port_group(port, group, *pp, 0, src, filter_mode,
  1072. RTPROT_KERNEL);
  1073. if (unlikely(!p)) {
  1074. p = ERR_PTR(-ENOMEM);
  1075. goto out;
  1076. }
  1077. rcu_assign_pointer(*pp, p);
  1078. if (blocked)
  1079. p->flags |= MDB_PG_FLAGS_BLOCKED;
  1080. br_mdb_notify(br->dev, mp, p, RTM_NEWMDB);
  1081. found:
  1082. if (igmpv2_mldv1)
  1083. mod_timer(&p->timer, now + br->multicast_membership_interval);
  1084. out:
  1085. return p;
  1086. }
  1087. static int br_multicast_add_group(struct net_bridge *br,
  1088. struct net_bridge_port *port,
  1089. struct br_ip *group,
  1090. const unsigned char *src,
  1091. u8 filter_mode,
  1092. bool igmpv2_mldv1)
  1093. {
  1094. struct net_bridge_port_group *pg;
  1095. int err;
  1096. spin_lock(&br->multicast_lock);
  1097. pg = __br_multicast_add_group(br, port, group, src, filter_mode,
  1098. igmpv2_mldv1, false);
  1099. /* NULL is considered valid for host joined groups */
  1100. err = IS_ERR(pg) ? PTR_ERR(pg) : 0;
  1101. spin_unlock(&br->multicast_lock);
  1102. return err;
  1103. }
  1104. static int br_ip4_multicast_add_group(struct net_bridge *br,
  1105. struct net_bridge_port *port,
  1106. __be32 group,
  1107. __u16 vid,
  1108. const unsigned char *src,
  1109. bool igmpv2)
  1110. {
  1111. struct br_ip br_group;
  1112. u8 filter_mode;
  1113. if (ipv4_is_local_multicast(group))
  1114. return 0;
  1115. memset(&br_group, 0, sizeof(br_group));
  1116. br_group.dst.ip4 = group;
  1117. br_group.proto = htons(ETH_P_IP);
  1118. br_group.vid = vid;
  1119. filter_mode = igmpv2 ? MCAST_EXCLUDE : MCAST_INCLUDE;
  1120. return br_multicast_add_group(br, port, &br_group, src, filter_mode,
  1121. igmpv2);
  1122. }
  1123. #if IS_ENABLED(CONFIG_IPV6)
  1124. static int br_ip6_multicast_add_group(struct net_bridge *br,
  1125. struct net_bridge_port *port,
  1126. const struct in6_addr *group,
  1127. __u16 vid,
  1128. const unsigned char *src,
  1129. bool mldv1)
  1130. {
  1131. struct br_ip br_group;
  1132. u8 filter_mode;
  1133. if (ipv6_addr_is_ll_all_nodes(group))
  1134. return 0;
  1135. memset(&br_group, 0, sizeof(br_group));
  1136. br_group.dst.ip6 = *group;
  1137. br_group.proto = htons(ETH_P_IPV6);
  1138. br_group.vid = vid;
  1139. filter_mode = mldv1 ? MCAST_EXCLUDE : MCAST_INCLUDE;
  1140. return br_multicast_add_group(br, port, &br_group, src, filter_mode,
  1141. mldv1);
  1142. }
  1143. #endif
  1144. static void br_multicast_router_expired(struct timer_list *t)
  1145. {
  1146. struct net_bridge_port *port =
  1147. from_timer(port, t, multicast_router_timer);
  1148. struct net_bridge *br = port->br;
  1149. spin_lock(&br->multicast_lock);
  1150. if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
  1151. port->multicast_router == MDB_RTR_TYPE_PERM ||
  1152. timer_pending(&port->multicast_router_timer))
  1153. goto out;
  1154. __del_port_router(port);
  1155. out:
  1156. spin_unlock(&br->multicast_lock);
  1157. }
  1158. static void br_mc_router_state_change(struct net_bridge *p,
  1159. bool is_mc_router)
  1160. {
  1161. struct switchdev_attr attr = {
  1162. .orig_dev = p->dev,
  1163. .id = SWITCHDEV_ATTR_ID_BRIDGE_MROUTER,
  1164. .flags = SWITCHDEV_F_DEFER,
  1165. .u.mrouter = is_mc_router,
  1166. };
  1167. switchdev_port_attr_set(p->dev, &attr);
  1168. }
  1169. static void br_multicast_local_router_expired(struct timer_list *t)
  1170. {
  1171. struct net_bridge *br = from_timer(br, t, multicast_router_timer);
  1172. spin_lock(&br->multicast_lock);
  1173. if (br->multicast_router == MDB_RTR_TYPE_DISABLED ||
  1174. br->multicast_router == MDB_RTR_TYPE_PERM ||
  1175. timer_pending(&br->multicast_router_timer))
  1176. goto out;
  1177. br_mc_router_state_change(br, false);
  1178. out:
  1179. spin_unlock(&br->multicast_lock);
  1180. }
  1181. static void br_multicast_querier_expired(struct net_bridge *br,
  1182. struct bridge_mcast_own_query *query)
  1183. {
  1184. spin_lock(&br->multicast_lock);
  1185. if (!netif_running(br->dev) || !br_opt_get(br, BROPT_MULTICAST_ENABLED))
  1186. goto out;
  1187. br_multicast_start_querier(br, query);
  1188. out:
  1189. spin_unlock(&br->multicast_lock);
  1190. }
  1191. static void br_ip4_multicast_querier_expired(struct timer_list *t)
  1192. {
  1193. struct net_bridge *br = from_timer(br, t, ip4_other_query.timer);
  1194. br_multicast_querier_expired(br, &br->ip4_own_query);
  1195. }
  1196. #if IS_ENABLED(CONFIG_IPV6)
  1197. static void br_ip6_multicast_querier_expired(struct timer_list *t)
  1198. {
  1199. struct net_bridge *br = from_timer(br, t, ip6_other_query.timer);
  1200. br_multicast_querier_expired(br, &br->ip6_own_query);
  1201. }
  1202. #endif
  1203. static void br_multicast_select_own_querier(struct net_bridge *br,
  1204. struct br_ip *ip,
  1205. struct sk_buff *skb)
  1206. {
  1207. if (ip->proto == htons(ETH_P_IP))
  1208. br->ip4_querier.addr.src.ip4 = ip_hdr(skb)->saddr;
  1209. #if IS_ENABLED(CONFIG_IPV6)
  1210. else
  1211. br->ip6_querier.addr.src.ip6 = ipv6_hdr(skb)->saddr;
  1212. #endif
  1213. }
  1214. static void __br_multicast_send_query(struct net_bridge *br,
  1215. struct net_bridge_port *port,
  1216. struct net_bridge_port_group *pg,
  1217. struct br_ip *ip_dst,
  1218. struct br_ip *group,
  1219. bool with_srcs,
  1220. u8 sflag,
  1221. bool *need_rexmit)
  1222. {
  1223. bool over_lmqt = !!sflag;
  1224. struct sk_buff *skb;
  1225. u8 igmp_type;
  1226. again_under_lmqt:
  1227. skb = br_multicast_alloc_query(br, pg, ip_dst, group, with_srcs,
  1228. over_lmqt, sflag, &igmp_type,
  1229. need_rexmit);
  1230. if (!skb)
  1231. return;
  1232. if (port) {
  1233. skb->dev = port->dev;
  1234. br_multicast_count(br, port, skb, igmp_type,
  1235. BR_MCAST_DIR_TX);
  1236. NF_HOOK(NFPROTO_BRIDGE, NF_BR_LOCAL_OUT,
  1237. dev_net(port->dev), NULL, skb, NULL, skb->dev,
  1238. br_dev_queue_push_xmit);
  1239. if (over_lmqt && with_srcs && sflag) {
  1240. over_lmqt = false;
  1241. goto again_under_lmqt;
  1242. }
  1243. } else {
  1244. br_multicast_select_own_querier(br, group, skb);
  1245. br_multicast_count(br, port, skb, igmp_type,
  1246. BR_MCAST_DIR_RX);
  1247. netif_rx(skb);
  1248. }
  1249. }
  1250. static void br_multicast_send_query(struct net_bridge *br,
  1251. struct net_bridge_port *port,
  1252. struct bridge_mcast_own_query *own_query)
  1253. {
  1254. struct bridge_mcast_other_query *other_query = NULL;
  1255. struct br_ip br_group;
  1256. unsigned long time;
  1257. if (!netif_running(br->dev) ||
  1258. !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
  1259. !br_opt_get(br, BROPT_MULTICAST_QUERIER))
  1260. return;
  1261. memset(&br_group.dst, 0, sizeof(br_group.dst));
  1262. if (port ? (own_query == &port->ip4_own_query) :
  1263. (own_query == &br->ip4_own_query)) {
  1264. other_query = &br->ip4_other_query;
  1265. br_group.proto = htons(ETH_P_IP);
  1266. #if IS_ENABLED(CONFIG_IPV6)
  1267. } else {
  1268. other_query = &br->ip6_other_query;
  1269. br_group.proto = htons(ETH_P_IPV6);
  1270. #endif
  1271. }
  1272. if (!other_query || timer_pending(&other_query->timer))
  1273. return;
  1274. __br_multicast_send_query(br, port, NULL, NULL, &br_group, false, 0,
  1275. NULL);
  1276. time = jiffies;
  1277. time += own_query->startup_sent < br->multicast_startup_query_count ?
  1278. br->multicast_startup_query_interval :
  1279. br->multicast_query_interval;
  1280. mod_timer(&own_query->timer, time);
  1281. }
  1282. static void
  1283. br_multicast_port_query_expired(struct net_bridge_port *port,
  1284. struct bridge_mcast_own_query *query)
  1285. {
  1286. struct net_bridge *br = port->br;
  1287. spin_lock(&br->multicast_lock);
  1288. if (port->state == BR_STATE_DISABLED ||
  1289. port->state == BR_STATE_BLOCKING)
  1290. goto out;
  1291. if (query->startup_sent < br->multicast_startup_query_count)
  1292. query->startup_sent++;
  1293. br_multicast_send_query(port->br, port, query);
  1294. out:
  1295. spin_unlock(&br->multicast_lock);
  1296. }
  1297. static void br_ip4_multicast_port_query_expired(struct timer_list *t)
  1298. {
  1299. struct net_bridge_port *port = from_timer(port, t, ip4_own_query.timer);
  1300. br_multicast_port_query_expired(port, &port->ip4_own_query);
  1301. }
  1302. #if IS_ENABLED(CONFIG_IPV6)
  1303. static void br_ip6_multicast_port_query_expired(struct timer_list *t)
  1304. {
  1305. struct net_bridge_port *port = from_timer(port, t, ip6_own_query.timer);
  1306. br_multicast_port_query_expired(port, &port->ip6_own_query);
  1307. }
  1308. #endif
  1309. static void br_multicast_port_group_rexmit(struct timer_list *t)
  1310. {
  1311. struct net_bridge_port_group *pg = from_timer(pg, t, rexmit_timer);
  1312. struct bridge_mcast_other_query *other_query = NULL;
  1313. struct net_bridge *br = pg->key.port->br;
  1314. bool need_rexmit = false;
  1315. spin_lock(&br->multicast_lock);
  1316. if (!netif_running(br->dev) || hlist_unhashed(&pg->mglist) ||
  1317. !br_opt_get(br, BROPT_MULTICAST_ENABLED) ||
  1318. !br_opt_get(br, BROPT_MULTICAST_QUERIER))
  1319. goto out;
  1320. if (pg->key.addr.proto == htons(ETH_P_IP))
  1321. other_query = &br->ip4_other_query;
  1322. #if IS_ENABLED(CONFIG_IPV6)
  1323. else
  1324. other_query = &br->ip6_other_query;
  1325. #endif
  1326. if (!other_query || timer_pending(&other_query->timer))
  1327. goto out;
  1328. if (pg->grp_query_rexmit_cnt) {
  1329. pg->grp_query_rexmit_cnt--;
  1330. __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
  1331. &pg->key.addr, false, 1, NULL);
  1332. }
  1333. __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
  1334. &pg->key.addr, true, 0, &need_rexmit);
  1335. if (pg->grp_query_rexmit_cnt || need_rexmit)
  1336. mod_timer(&pg->rexmit_timer, jiffies +
  1337. br->multicast_last_member_interval);
  1338. out:
  1339. spin_unlock(&br->multicast_lock);
  1340. }
  1341. static void br_mc_disabled_update(struct net_device *dev, bool value)
  1342. {
  1343. struct switchdev_attr attr = {
  1344. .orig_dev = dev,
  1345. .id = SWITCHDEV_ATTR_ID_BRIDGE_MC_DISABLED,
  1346. .flags = SWITCHDEV_F_DEFER,
  1347. .u.mc_disabled = !value,
  1348. };
  1349. switchdev_port_attr_set(dev, &attr);
  1350. }
  1351. int br_multicast_add_port(struct net_bridge_port *port)
  1352. {
  1353. port->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
  1354. timer_setup(&port->multicast_router_timer,
  1355. br_multicast_router_expired, 0);
  1356. timer_setup(&port->ip4_own_query.timer,
  1357. br_ip4_multicast_port_query_expired, 0);
  1358. #if IS_ENABLED(CONFIG_IPV6)
  1359. timer_setup(&port->ip6_own_query.timer,
  1360. br_ip6_multicast_port_query_expired, 0);
  1361. #endif
  1362. br_mc_disabled_update(port->dev,
  1363. br_opt_get(port->br, BROPT_MULTICAST_ENABLED));
  1364. port->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
  1365. if (!port->mcast_stats)
  1366. return -ENOMEM;
  1367. return 0;
  1368. }
  1369. void br_multicast_del_port(struct net_bridge_port *port)
  1370. {
  1371. struct net_bridge *br = port->br;
  1372. struct net_bridge_port_group *pg;
  1373. HLIST_HEAD(deleted_head);
  1374. struct hlist_node *n;
  1375. /* Take care of the remaining groups, only perm ones should be left */
  1376. spin_lock_bh(&br->multicast_lock);
  1377. hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
  1378. br_multicast_find_del_pg(br, pg);
  1379. hlist_move_list(&br->mcast_gc_list, &deleted_head);
  1380. spin_unlock_bh(&br->multicast_lock);
  1381. br_multicast_gc(&deleted_head);
  1382. del_timer_sync(&port->multicast_router_timer);
  1383. free_percpu(port->mcast_stats);
  1384. }
  1385. static void br_multicast_enable(struct bridge_mcast_own_query *query)
  1386. {
  1387. query->startup_sent = 0;
  1388. if (try_to_del_timer_sync(&query->timer) >= 0 ||
  1389. del_timer(&query->timer))
  1390. mod_timer(&query->timer, jiffies);
  1391. }
  1392. static void __br_multicast_enable_port(struct net_bridge_port *port)
  1393. {
  1394. struct net_bridge *br = port->br;
  1395. if (!br_opt_get(br, BROPT_MULTICAST_ENABLED) || !netif_running(br->dev))
  1396. return;
  1397. br_multicast_enable(&port->ip4_own_query);
  1398. #if IS_ENABLED(CONFIG_IPV6)
  1399. br_multicast_enable(&port->ip6_own_query);
  1400. #endif
  1401. if (port->multicast_router == MDB_RTR_TYPE_PERM &&
  1402. hlist_unhashed(&port->rlist))
  1403. br_multicast_add_router(br, port);
  1404. }
  1405. void br_multicast_enable_port(struct net_bridge_port *port)
  1406. {
  1407. struct net_bridge *br = port->br;
  1408. spin_lock(&br->multicast_lock);
  1409. __br_multicast_enable_port(port);
  1410. spin_unlock(&br->multicast_lock);
  1411. }
  1412. void br_multicast_disable_port(struct net_bridge_port *port)
  1413. {
  1414. struct net_bridge *br = port->br;
  1415. struct net_bridge_port_group *pg;
  1416. struct hlist_node *n;
  1417. spin_lock(&br->multicast_lock);
  1418. hlist_for_each_entry_safe(pg, n, &port->mglist, mglist)
  1419. if (!(pg->flags & MDB_PG_FLAGS_PERMANENT))
  1420. br_multicast_find_del_pg(br, pg);
  1421. __del_port_router(port);
  1422. del_timer(&port->multicast_router_timer);
  1423. del_timer(&port->ip4_own_query.timer);
  1424. #if IS_ENABLED(CONFIG_IPV6)
  1425. del_timer(&port->ip6_own_query.timer);
  1426. #endif
  1427. spin_unlock(&br->multicast_lock);
  1428. }
  1429. static int __grp_src_delete_marked(struct net_bridge_port_group *pg)
  1430. {
  1431. struct net_bridge_group_src *ent;
  1432. struct hlist_node *tmp;
  1433. int deleted = 0;
  1434. hlist_for_each_entry_safe(ent, tmp, &pg->src_list, node)
  1435. if (ent->flags & BR_SGRP_F_DELETE) {
  1436. br_multicast_del_group_src(ent);
  1437. deleted++;
  1438. }
  1439. return deleted;
  1440. }
  1441. static void __grp_src_mod_timer(struct net_bridge_group_src *src,
  1442. unsigned long expires)
  1443. {
  1444. mod_timer(&src->timer, expires);
  1445. br_multicast_fwd_src_handle(src);
  1446. }
  1447. static void __grp_src_query_marked_and_rexmit(struct net_bridge_port_group *pg)
  1448. {
  1449. struct bridge_mcast_other_query *other_query = NULL;
  1450. struct net_bridge *br = pg->key.port->br;
  1451. u32 lmqc = br->multicast_last_member_count;
  1452. unsigned long lmqt, lmi, now = jiffies;
  1453. struct net_bridge_group_src *ent;
  1454. if (!netif_running(br->dev) ||
  1455. !br_opt_get(br, BROPT_MULTICAST_ENABLED))
  1456. return;
  1457. if (pg->key.addr.proto == htons(ETH_P_IP))
  1458. other_query = &br->ip4_other_query;
  1459. #if IS_ENABLED(CONFIG_IPV6)
  1460. else
  1461. other_query = &br->ip6_other_query;
  1462. #endif
  1463. lmqt = now + br_multicast_lmqt(br);
  1464. hlist_for_each_entry(ent, &pg->src_list, node) {
  1465. if (ent->flags & BR_SGRP_F_SEND) {
  1466. ent->flags &= ~BR_SGRP_F_SEND;
  1467. if (ent->timer.expires > lmqt) {
  1468. if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
  1469. other_query &&
  1470. !timer_pending(&other_query->timer))
  1471. ent->src_query_rexmit_cnt = lmqc;
  1472. __grp_src_mod_timer(ent, lmqt);
  1473. }
  1474. }
  1475. }
  1476. if (!br_opt_get(br, BROPT_MULTICAST_QUERIER) ||
  1477. !other_query || timer_pending(&other_query->timer))
  1478. return;
  1479. __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
  1480. &pg->key.addr, true, 1, NULL);
  1481. lmi = now + br->multicast_last_member_interval;
  1482. if (!timer_pending(&pg->rexmit_timer) ||
  1483. time_after(pg->rexmit_timer.expires, lmi))
  1484. mod_timer(&pg->rexmit_timer, lmi);
  1485. }
  1486. static void __grp_send_query_and_rexmit(struct net_bridge_port_group *pg)
  1487. {
  1488. struct bridge_mcast_other_query *other_query = NULL;
  1489. struct net_bridge *br = pg->key.port->br;
  1490. unsigned long now = jiffies, lmi;
  1491. if (!netif_running(br->dev) ||
  1492. !br_opt_get(br, BROPT_MULTICAST_ENABLED))
  1493. return;
  1494. if (pg->key.addr.proto == htons(ETH_P_IP))
  1495. other_query = &br->ip4_other_query;
  1496. #if IS_ENABLED(CONFIG_IPV6)
  1497. else
  1498. other_query = &br->ip6_other_query;
  1499. #endif
  1500. if (br_opt_get(br, BROPT_MULTICAST_QUERIER) &&
  1501. other_query && !timer_pending(&other_query->timer)) {
  1502. lmi = now + br->multicast_last_member_interval;
  1503. pg->grp_query_rexmit_cnt = br->multicast_last_member_count - 1;
  1504. __br_multicast_send_query(br, pg->key.port, pg, &pg->key.addr,
  1505. &pg->key.addr, false, 0, NULL);
  1506. if (!timer_pending(&pg->rexmit_timer) ||
  1507. time_after(pg->rexmit_timer.expires, lmi))
  1508. mod_timer(&pg->rexmit_timer, lmi);
  1509. }
  1510. if (pg->filter_mode == MCAST_EXCLUDE &&
  1511. (!timer_pending(&pg->timer) ||
  1512. time_after(pg->timer.expires, now + br_multicast_lmqt(br))))
  1513. mod_timer(&pg->timer, now + br_multicast_lmqt(br));
  1514. }
  1515. /* State Msg type New state Actions
  1516. * INCLUDE (A) IS_IN (B) INCLUDE (A+B) (B)=GMI
  1517. * INCLUDE (A) ALLOW (B) INCLUDE (A+B) (B)=GMI
  1518. * EXCLUDE (X,Y) ALLOW (A) EXCLUDE (X+A,Y-A) (A)=GMI
  1519. */
  1520. static bool br_multicast_isinc_allow(struct net_bridge_port_group *pg,
  1521. void *srcs, u32 nsrcs, size_t src_size)
  1522. {
  1523. struct net_bridge *br = pg->key.port->br;
  1524. struct net_bridge_group_src *ent;
  1525. unsigned long now = jiffies;
  1526. bool changed = false;
  1527. struct br_ip src_ip;
  1528. u32 src_idx;
  1529. memset(&src_ip, 0, sizeof(src_ip));
  1530. src_ip.proto = pg->key.addr.proto;
  1531. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1532. memcpy(&src_ip.src, srcs, src_size);
  1533. ent = br_multicast_find_group_src(pg, &src_ip);
  1534. if (!ent) {
  1535. ent = br_multicast_new_group_src(pg, &src_ip);
  1536. if (ent)
  1537. changed = true;
  1538. }
  1539. if (ent)
  1540. __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
  1541. srcs += src_size;
  1542. }
  1543. return changed;
  1544. }
  1545. /* State Msg type New state Actions
  1546. * INCLUDE (A) IS_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
  1547. * Delete (A-B)
  1548. * Group Timer=GMI
  1549. */
  1550. static void __grp_src_isexc_incl(struct net_bridge_port_group *pg,
  1551. void *srcs, u32 nsrcs, size_t src_size)
  1552. {
  1553. struct net_bridge_group_src *ent;
  1554. struct br_ip src_ip;
  1555. u32 src_idx;
  1556. hlist_for_each_entry(ent, &pg->src_list, node)
  1557. ent->flags |= BR_SGRP_F_DELETE;
  1558. memset(&src_ip, 0, sizeof(src_ip));
  1559. src_ip.proto = pg->key.addr.proto;
  1560. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1561. memcpy(&src_ip.src, srcs, src_size);
  1562. ent = br_multicast_find_group_src(pg, &src_ip);
  1563. if (ent)
  1564. ent->flags &= ~BR_SGRP_F_DELETE;
  1565. else
  1566. ent = br_multicast_new_group_src(pg, &src_ip);
  1567. if (ent)
  1568. br_multicast_fwd_src_handle(ent);
  1569. srcs += src_size;
  1570. }
  1571. __grp_src_delete_marked(pg);
  1572. }
  1573. /* State Msg type New state Actions
  1574. * EXCLUDE (X,Y) IS_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=GMI
  1575. * Delete (X-A)
  1576. * Delete (Y-A)
  1577. * Group Timer=GMI
  1578. */
  1579. static bool __grp_src_isexc_excl(struct net_bridge_port_group *pg,
  1580. void *srcs, u32 nsrcs, size_t src_size)
  1581. {
  1582. struct net_bridge *br = pg->key.port->br;
  1583. struct net_bridge_group_src *ent;
  1584. unsigned long now = jiffies;
  1585. bool changed = false;
  1586. struct br_ip src_ip;
  1587. u32 src_idx;
  1588. hlist_for_each_entry(ent, &pg->src_list, node)
  1589. ent->flags |= BR_SGRP_F_DELETE;
  1590. memset(&src_ip, 0, sizeof(src_ip));
  1591. src_ip.proto = pg->key.addr.proto;
  1592. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1593. memcpy(&src_ip.src, srcs, src_size);
  1594. ent = br_multicast_find_group_src(pg, &src_ip);
  1595. if (ent) {
  1596. ent->flags &= ~BR_SGRP_F_DELETE;
  1597. } else {
  1598. ent = br_multicast_new_group_src(pg, &src_ip);
  1599. if (ent) {
  1600. __grp_src_mod_timer(ent,
  1601. now + br_multicast_gmi(br));
  1602. changed = true;
  1603. }
  1604. }
  1605. srcs += src_size;
  1606. }
  1607. if (__grp_src_delete_marked(pg))
  1608. changed = true;
  1609. return changed;
  1610. }
  1611. static bool br_multicast_isexc(struct net_bridge_port_group *pg,
  1612. void *srcs, u32 nsrcs, size_t src_size)
  1613. {
  1614. struct net_bridge *br = pg->key.port->br;
  1615. bool changed = false;
  1616. switch (pg->filter_mode) {
  1617. case MCAST_INCLUDE:
  1618. __grp_src_isexc_incl(pg, srcs, nsrcs, src_size);
  1619. br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
  1620. changed = true;
  1621. break;
  1622. case MCAST_EXCLUDE:
  1623. changed = __grp_src_isexc_excl(pg, srcs, nsrcs, src_size);
  1624. break;
  1625. }
  1626. pg->filter_mode = MCAST_EXCLUDE;
  1627. mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
  1628. return changed;
  1629. }
  1630. /* State Msg type New state Actions
  1631. * INCLUDE (A) TO_IN (B) INCLUDE (A+B) (B)=GMI
  1632. * Send Q(G,A-B)
  1633. */
  1634. static bool __grp_src_toin_incl(struct net_bridge_port_group *pg,
  1635. void *srcs, u32 nsrcs, size_t src_size)
  1636. {
  1637. struct net_bridge *br = pg->key.port->br;
  1638. u32 src_idx, to_send = pg->src_ents;
  1639. struct net_bridge_group_src *ent;
  1640. unsigned long now = jiffies;
  1641. bool changed = false;
  1642. struct br_ip src_ip;
  1643. hlist_for_each_entry(ent, &pg->src_list, node)
  1644. ent->flags |= BR_SGRP_F_SEND;
  1645. memset(&src_ip, 0, sizeof(src_ip));
  1646. src_ip.proto = pg->key.addr.proto;
  1647. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1648. memcpy(&src_ip.src, srcs, src_size);
  1649. ent = br_multicast_find_group_src(pg, &src_ip);
  1650. if (ent) {
  1651. ent->flags &= ~BR_SGRP_F_SEND;
  1652. to_send--;
  1653. } else {
  1654. ent = br_multicast_new_group_src(pg, &src_ip);
  1655. if (ent)
  1656. changed = true;
  1657. }
  1658. if (ent)
  1659. __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
  1660. srcs += src_size;
  1661. }
  1662. if (to_send)
  1663. __grp_src_query_marked_and_rexmit(pg);
  1664. return changed;
  1665. }
  1666. /* State Msg type New state Actions
  1667. * EXCLUDE (X,Y) TO_IN (A) EXCLUDE (X+A,Y-A) (A)=GMI
  1668. * Send Q(G,X-A)
  1669. * Send Q(G)
  1670. */
  1671. static bool __grp_src_toin_excl(struct net_bridge_port_group *pg,
  1672. void *srcs, u32 nsrcs, size_t src_size)
  1673. {
  1674. struct net_bridge *br = pg->key.port->br;
  1675. u32 src_idx, to_send = pg->src_ents;
  1676. struct net_bridge_group_src *ent;
  1677. unsigned long now = jiffies;
  1678. bool changed = false;
  1679. struct br_ip src_ip;
  1680. hlist_for_each_entry(ent, &pg->src_list, node)
  1681. if (timer_pending(&ent->timer))
  1682. ent->flags |= BR_SGRP_F_SEND;
  1683. memset(&src_ip, 0, sizeof(src_ip));
  1684. src_ip.proto = pg->key.addr.proto;
  1685. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1686. memcpy(&src_ip.src, srcs, src_size);
  1687. ent = br_multicast_find_group_src(pg, &src_ip);
  1688. if (ent) {
  1689. if (timer_pending(&ent->timer)) {
  1690. ent->flags &= ~BR_SGRP_F_SEND;
  1691. to_send--;
  1692. }
  1693. } else {
  1694. ent = br_multicast_new_group_src(pg, &src_ip);
  1695. if (ent)
  1696. changed = true;
  1697. }
  1698. if (ent)
  1699. __grp_src_mod_timer(ent, now + br_multicast_gmi(br));
  1700. srcs += src_size;
  1701. }
  1702. if (to_send)
  1703. __grp_src_query_marked_and_rexmit(pg);
  1704. __grp_send_query_and_rexmit(pg);
  1705. return changed;
  1706. }
  1707. static bool br_multicast_toin(struct net_bridge_port_group *pg,
  1708. void *srcs, u32 nsrcs, size_t src_size)
  1709. {
  1710. bool changed = false;
  1711. switch (pg->filter_mode) {
  1712. case MCAST_INCLUDE:
  1713. changed = __grp_src_toin_incl(pg, srcs, nsrcs, src_size);
  1714. break;
  1715. case MCAST_EXCLUDE:
  1716. changed = __grp_src_toin_excl(pg, srcs, nsrcs, src_size);
  1717. break;
  1718. }
  1719. return changed;
  1720. }
  1721. /* State Msg type New state Actions
  1722. * INCLUDE (A) TO_EX (B) EXCLUDE (A*B,B-A) (B-A)=0
  1723. * Delete (A-B)
  1724. * Send Q(G,A*B)
  1725. * Group Timer=GMI
  1726. */
  1727. static void __grp_src_toex_incl(struct net_bridge_port_group *pg,
  1728. void *srcs, u32 nsrcs, size_t src_size)
  1729. {
  1730. struct net_bridge_group_src *ent;
  1731. u32 src_idx, to_send = 0;
  1732. struct br_ip src_ip;
  1733. hlist_for_each_entry(ent, &pg->src_list, node)
  1734. ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
  1735. memset(&src_ip, 0, sizeof(src_ip));
  1736. src_ip.proto = pg->key.addr.proto;
  1737. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1738. memcpy(&src_ip.src, srcs, src_size);
  1739. ent = br_multicast_find_group_src(pg, &src_ip);
  1740. if (ent) {
  1741. ent->flags = (ent->flags & ~BR_SGRP_F_DELETE) |
  1742. BR_SGRP_F_SEND;
  1743. to_send++;
  1744. } else {
  1745. ent = br_multicast_new_group_src(pg, &src_ip);
  1746. }
  1747. if (ent)
  1748. br_multicast_fwd_src_handle(ent);
  1749. srcs += src_size;
  1750. }
  1751. __grp_src_delete_marked(pg);
  1752. if (to_send)
  1753. __grp_src_query_marked_and_rexmit(pg);
  1754. }
  1755. /* State Msg type New state Actions
  1756. * EXCLUDE (X,Y) TO_EX (A) EXCLUDE (A-Y,Y*A) (A-X-Y)=Group Timer
  1757. * Delete (X-A)
  1758. * Delete (Y-A)
  1759. * Send Q(G,A-Y)
  1760. * Group Timer=GMI
  1761. */
  1762. static bool __grp_src_toex_excl(struct net_bridge_port_group *pg,
  1763. void *srcs, u32 nsrcs, size_t src_size)
  1764. {
  1765. struct net_bridge_group_src *ent;
  1766. u32 src_idx, to_send = 0;
  1767. bool changed = false;
  1768. struct br_ip src_ip;
  1769. hlist_for_each_entry(ent, &pg->src_list, node)
  1770. ent->flags = (ent->flags & ~BR_SGRP_F_SEND) | BR_SGRP_F_DELETE;
  1771. memset(&src_ip, 0, sizeof(src_ip));
  1772. src_ip.proto = pg->key.addr.proto;
  1773. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1774. memcpy(&src_ip.src, srcs, src_size);
  1775. ent = br_multicast_find_group_src(pg, &src_ip);
  1776. if (ent) {
  1777. ent->flags &= ~BR_SGRP_F_DELETE;
  1778. } else {
  1779. ent = br_multicast_new_group_src(pg, &src_ip);
  1780. if (ent) {
  1781. __grp_src_mod_timer(ent, pg->timer.expires);
  1782. changed = true;
  1783. }
  1784. }
  1785. if (ent && timer_pending(&ent->timer)) {
  1786. ent->flags |= BR_SGRP_F_SEND;
  1787. to_send++;
  1788. }
  1789. srcs += src_size;
  1790. }
  1791. if (__grp_src_delete_marked(pg))
  1792. changed = true;
  1793. if (to_send)
  1794. __grp_src_query_marked_and_rexmit(pg);
  1795. return changed;
  1796. }
  1797. static bool br_multicast_toex(struct net_bridge_port_group *pg,
  1798. void *srcs, u32 nsrcs, size_t src_size)
  1799. {
  1800. struct net_bridge *br = pg->key.port->br;
  1801. bool changed = false;
  1802. switch (pg->filter_mode) {
  1803. case MCAST_INCLUDE:
  1804. __grp_src_toex_incl(pg, srcs, nsrcs, src_size);
  1805. br_multicast_star_g_handle_mode(pg, MCAST_EXCLUDE);
  1806. changed = true;
  1807. break;
  1808. case MCAST_EXCLUDE:
  1809. changed = __grp_src_toex_excl(pg, srcs, nsrcs, src_size);
  1810. break;
  1811. }
  1812. pg->filter_mode = MCAST_EXCLUDE;
  1813. mod_timer(&pg->timer, jiffies + br_multicast_gmi(br));
  1814. return changed;
  1815. }
  1816. /* State Msg type New state Actions
  1817. * INCLUDE (A) BLOCK (B) INCLUDE (A) Send Q(G,A*B)
  1818. */
  1819. static void __grp_src_block_incl(struct net_bridge_port_group *pg,
  1820. void *srcs, u32 nsrcs, size_t src_size)
  1821. {
  1822. struct net_bridge_group_src *ent;
  1823. u32 src_idx, to_send = 0;
  1824. struct br_ip src_ip;
  1825. hlist_for_each_entry(ent, &pg->src_list, node)
  1826. ent->flags &= ~BR_SGRP_F_SEND;
  1827. memset(&src_ip, 0, sizeof(src_ip));
  1828. src_ip.proto = pg->key.addr.proto;
  1829. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1830. memcpy(&src_ip.src, srcs, src_size);
  1831. ent = br_multicast_find_group_src(pg, &src_ip);
  1832. if (ent) {
  1833. ent->flags |= BR_SGRP_F_SEND;
  1834. to_send++;
  1835. }
  1836. srcs += src_size;
  1837. }
  1838. if (to_send)
  1839. __grp_src_query_marked_and_rexmit(pg);
  1840. if (pg->filter_mode == MCAST_INCLUDE && hlist_empty(&pg->src_list))
  1841. br_multicast_find_del_pg(pg->key.port->br, pg);
  1842. }
  1843. /* State Msg type New state Actions
  1844. * EXCLUDE (X,Y) BLOCK (A) EXCLUDE (X+(A-Y),Y) (A-X-Y)=Group Timer
  1845. * Send Q(G,A-Y)
  1846. */
  1847. static bool __grp_src_block_excl(struct net_bridge_port_group *pg,
  1848. void *srcs, u32 nsrcs, size_t src_size)
  1849. {
  1850. struct net_bridge_group_src *ent;
  1851. u32 src_idx, to_send = 0;
  1852. bool changed = false;
  1853. struct br_ip src_ip;
  1854. hlist_for_each_entry(ent, &pg->src_list, node)
  1855. ent->flags &= ~BR_SGRP_F_SEND;
  1856. memset(&src_ip, 0, sizeof(src_ip));
  1857. src_ip.proto = pg->key.addr.proto;
  1858. for (src_idx = 0; src_idx < nsrcs; src_idx++) {
  1859. memcpy(&src_ip.src, srcs, src_size);
  1860. ent = br_multicast_find_group_src(pg, &src_ip);
  1861. if (!ent) {
  1862. ent = br_multicast_new_group_src(pg, &src_ip);
  1863. if (ent) {
  1864. __grp_src_mod_timer(ent, pg->timer.expires);
  1865. changed = true;
  1866. }
  1867. }
  1868. if (ent && timer_pending(&ent->timer)) {
  1869. ent->flags |= BR_SGRP_F_SEND;
  1870. to_send++;
  1871. }
  1872. srcs += src_size;
  1873. }
  1874. if (to_send)
  1875. __grp_src_query_marked_and_rexmit(pg);
  1876. return changed;
  1877. }
  1878. static bool br_multicast_block(struct net_bridge_port_group *pg,
  1879. void *srcs, u32 nsrcs, size_t src_size)
  1880. {
  1881. bool changed = false;
  1882. switch (pg->filter_mode) {
  1883. case MCAST_INCLUDE:
  1884. __grp_src_block_incl(pg, srcs, nsrcs, src_size);
  1885. break;
  1886. case MCAST_EXCLUDE:
  1887. changed = __grp_src_block_excl(pg, srcs, nsrcs, src_size);
  1888. break;
  1889. }
  1890. return changed;
  1891. }
  1892. static struct net_bridge_port_group *
  1893. br_multicast_find_port(struct net_bridge_mdb_entry *mp,
  1894. struct net_bridge_port *p,
  1895. const unsigned char *src)
  1896. {
  1897. struct net_bridge *br __maybe_unused = mp->br;
  1898. struct net_bridge_port_group *pg;
  1899. for (pg = mlock_dereference(mp->ports, br);
  1900. pg;
  1901. pg = mlock_dereference(pg->next, br))
  1902. if (br_port_group_equal(pg, p, src))
  1903. return pg;
  1904. return NULL;
  1905. }
  1906. static int br_ip4_multicast_igmp3_report(struct net_bridge *br,
  1907. struct net_bridge_port *port,
  1908. struct sk_buff *skb,
  1909. u16 vid)
  1910. {
  1911. bool igmpv2 = br->multicast_igmp_version == 2;
  1912. struct net_bridge_mdb_entry *mdst;
  1913. struct net_bridge_port_group *pg;
  1914. const unsigned char *src;
  1915. struct igmpv3_report *ih;
  1916. struct igmpv3_grec *grec;
  1917. int i, len, num, type;
  1918. bool changed = false;
  1919. __be32 group;
  1920. int err = 0;
  1921. u16 nsrcs;
  1922. ih = igmpv3_report_hdr(skb);
  1923. num = ntohs(ih->ngrec);
  1924. len = skb_transport_offset(skb) + sizeof(*ih);
  1925. for (i = 0; i < num; i++) {
  1926. len += sizeof(*grec);
  1927. if (!ip_mc_may_pull(skb, len))
  1928. return -EINVAL;
  1929. grec = (void *)(skb->data + len - sizeof(*grec));
  1930. group = grec->grec_mca;
  1931. type = grec->grec_type;
  1932. nsrcs = ntohs(grec->grec_nsrcs);
  1933. len += nsrcs * 4;
  1934. if (!ip_mc_may_pull(skb, len))
  1935. return -EINVAL;
  1936. switch (type) {
  1937. case IGMPV3_MODE_IS_INCLUDE:
  1938. case IGMPV3_MODE_IS_EXCLUDE:
  1939. case IGMPV3_CHANGE_TO_INCLUDE:
  1940. case IGMPV3_CHANGE_TO_EXCLUDE:
  1941. case IGMPV3_ALLOW_NEW_SOURCES:
  1942. case IGMPV3_BLOCK_OLD_SOURCES:
  1943. break;
  1944. default:
  1945. continue;
  1946. }
  1947. src = eth_hdr(skb)->h_source;
  1948. if (nsrcs == 0 &&
  1949. (type == IGMPV3_CHANGE_TO_INCLUDE ||
  1950. type == IGMPV3_MODE_IS_INCLUDE)) {
  1951. if (!port || igmpv2) {
  1952. br_ip4_multicast_leave_group(br, port, group, vid, src);
  1953. continue;
  1954. }
  1955. } else {
  1956. err = br_ip4_multicast_add_group(br, port, group, vid,
  1957. src, igmpv2);
  1958. if (err)
  1959. break;
  1960. }
  1961. if (!port || igmpv2)
  1962. continue;
  1963. spin_lock_bh(&br->multicast_lock);
  1964. mdst = br_mdb_ip4_get(br, group, vid);
  1965. if (!mdst)
  1966. goto unlock_continue;
  1967. pg = br_multicast_find_port(mdst, port, src);
  1968. if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
  1969. goto unlock_continue;
  1970. /* reload grec */
  1971. grec = (void *)(skb->data + len - sizeof(*grec) - (nsrcs * 4));
  1972. switch (type) {
  1973. case IGMPV3_ALLOW_NEW_SOURCES:
  1974. changed = br_multicast_isinc_allow(pg, grec->grec_src,
  1975. nsrcs, sizeof(__be32));
  1976. break;
  1977. case IGMPV3_MODE_IS_INCLUDE:
  1978. changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs,
  1979. sizeof(__be32));
  1980. break;
  1981. case IGMPV3_MODE_IS_EXCLUDE:
  1982. changed = br_multicast_isexc(pg, grec->grec_src, nsrcs,
  1983. sizeof(__be32));
  1984. break;
  1985. case IGMPV3_CHANGE_TO_INCLUDE:
  1986. changed = br_multicast_toin(pg, grec->grec_src, nsrcs,
  1987. sizeof(__be32));
  1988. break;
  1989. case IGMPV3_CHANGE_TO_EXCLUDE:
  1990. changed = br_multicast_toex(pg, grec->grec_src, nsrcs,
  1991. sizeof(__be32));
  1992. break;
  1993. case IGMPV3_BLOCK_OLD_SOURCES:
  1994. changed = br_multicast_block(pg, grec->grec_src, nsrcs,
  1995. sizeof(__be32));
  1996. break;
  1997. }
  1998. if (changed)
  1999. br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
  2000. unlock_continue:
  2001. spin_unlock_bh(&br->multicast_lock);
  2002. }
  2003. return err;
  2004. }
  2005. #if IS_ENABLED(CONFIG_IPV6)
  2006. static int br_ip6_multicast_mld2_report(struct net_bridge *br,
  2007. struct net_bridge_port *port,
  2008. struct sk_buff *skb,
  2009. u16 vid)
  2010. {
  2011. bool mldv1 = br->multicast_mld_version == 1;
  2012. struct net_bridge_mdb_entry *mdst;
  2013. struct net_bridge_port_group *pg;
  2014. unsigned int nsrcs_offset;
  2015. const unsigned char *src;
  2016. struct icmp6hdr *icmp6h;
  2017. struct mld2_grec *grec;
  2018. unsigned int grec_len;
  2019. bool changed = false;
  2020. int i, len, num;
  2021. int err = 0;
  2022. if (!ipv6_mc_may_pull(skb, sizeof(*icmp6h)))
  2023. return -EINVAL;
  2024. icmp6h = icmp6_hdr(skb);
  2025. num = ntohs(icmp6h->icmp6_dataun.un_data16[1]);
  2026. len = skb_transport_offset(skb) + sizeof(*icmp6h);
  2027. for (i = 0; i < num; i++) {
  2028. __be16 *_nsrcs, __nsrcs;
  2029. u16 nsrcs;
  2030. nsrcs_offset = len + offsetof(struct mld2_grec, grec_nsrcs);
  2031. if (skb_transport_offset(skb) + ipv6_transport_len(skb) <
  2032. nsrcs_offset + sizeof(__nsrcs))
  2033. return -EINVAL;
  2034. _nsrcs = skb_header_pointer(skb, nsrcs_offset,
  2035. sizeof(__nsrcs), &__nsrcs);
  2036. if (!_nsrcs)
  2037. return -EINVAL;
  2038. nsrcs = ntohs(*_nsrcs);
  2039. grec_len = struct_size(grec, grec_src, nsrcs);
  2040. if (!ipv6_mc_may_pull(skb, len + grec_len))
  2041. return -EINVAL;
  2042. grec = (struct mld2_grec *)(skb->data + len);
  2043. len += grec_len;
  2044. switch (grec->grec_type) {
  2045. case MLD2_MODE_IS_INCLUDE:
  2046. case MLD2_MODE_IS_EXCLUDE:
  2047. case MLD2_CHANGE_TO_INCLUDE:
  2048. case MLD2_CHANGE_TO_EXCLUDE:
  2049. case MLD2_ALLOW_NEW_SOURCES:
  2050. case MLD2_BLOCK_OLD_SOURCES:
  2051. break;
  2052. default:
  2053. continue;
  2054. }
  2055. src = eth_hdr(skb)->h_source;
  2056. if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
  2057. grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
  2058. nsrcs == 0) {
  2059. if (!port || mldv1) {
  2060. br_ip6_multicast_leave_group(br, port,
  2061. &grec->grec_mca,
  2062. vid, src);
  2063. continue;
  2064. }
  2065. } else {
  2066. err = br_ip6_multicast_add_group(br, port,
  2067. &grec->grec_mca, vid,
  2068. src, mldv1);
  2069. if (err)
  2070. break;
  2071. }
  2072. if (!port || mldv1)
  2073. continue;
  2074. spin_lock_bh(&br->multicast_lock);
  2075. mdst = br_mdb_ip6_get(br, &grec->grec_mca, vid);
  2076. if (!mdst)
  2077. goto unlock_continue;
  2078. pg = br_multicast_find_port(mdst, port, src);
  2079. if (!pg || (pg->flags & MDB_PG_FLAGS_PERMANENT))
  2080. goto unlock_continue;
  2081. switch (grec->grec_type) {
  2082. case MLD2_ALLOW_NEW_SOURCES:
  2083. changed = br_multicast_isinc_allow(pg, grec->grec_src,
  2084. nsrcs,
  2085. sizeof(struct in6_addr));
  2086. break;
  2087. case MLD2_MODE_IS_INCLUDE:
  2088. changed = br_multicast_isinc_allow(pg, grec->grec_src, nsrcs,
  2089. sizeof(struct in6_addr));
  2090. break;
  2091. case MLD2_MODE_IS_EXCLUDE:
  2092. changed = br_multicast_isexc(pg, grec->grec_src, nsrcs,
  2093. sizeof(struct in6_addr));
  2094. break;
  2095. case MLD2_CHANGE_TO_INCLUDE:
  2096. changed = br_multicast_toin(pg, grec->grec_src, nsrcs,
  2097. sizeof(struct in6_addr));
  2098. break;
  2099. case MLD2_CHANGE_TO_EXCLUDE:
  2100. changed = br_multicast_toex(pg, grec->grec_src, nsrcs,
  2101. sizeof(struct in6_addr));
  2102. break;
  2103. case MLD2_BLOCK_OLD_SOURCES:
  2104. changed = br_multicast_block(pg, grec->grec_src, nsrcs,
  2105. sizeof(struct in6_addr));
  2106. break;
  2107. }
  2108. if (changed)
  2109. br_mdb_notify(br->dev, mdst, pg, RTM_NEWMDB);
  2110. unlock_continue:
  2111. spin_unlock_bh(&br->multicast_lock);
  2112. }
  2113. return err;
  2114. }
  2115. #endif
  2116. static bool br_ip4_multicast_select_querier(struct net_bridge *br,
  2117. struct net_bridge_port *port,
  2118. __be32 saddr)
  2119. {
  2120. if (!timer_pending(&br->ip4_own_query.timer) &&
  2121. !timer_pending(&br->ip4_other_query.timer))
  2122. goto update;
  2123. if (!br->ip4_querier.addr.src.ip4)
  2124. goto update;
  2125. if (ntohl(saddr) <= ntohl(br->ip4_querier.addr.src.ip4))
  2126. goto update;
  2127. return false;
  2128. update:
  2129. br->ip4_querier.addr.src.ip4 = saddr;
  2130. /* update protected by general multicast_lock by caller */
  2131. rcu_assign_pointer(br->ip4_querier.port, port);
  2132. return true;
  2133. }
  2134. #if IS_ENABLED(CONFIG_IPV6)
  2135. static bool br_ip6_multicast_select_querier(struct net_bridge *br,
  2136. struct net_bridge_port *port,
  2137. struct in6_addr *saddr)
  2138. {
  2139. if (!timer_pending(&br->ip6_own_query.timer) &&
  2140. !timer_pending(&br->ip6_other_query.timer))
  2141. goto update;
  2142. if (ipv6_addr_cmp(saddr, &br->ip6_querier.addr.src.ip6) <= 0)
  2143. goto update;
  2144. return false;
  2145. update:
  2146. br->ip6_querier.addr.src.ip6 = *saddr;
  2147. /* update protected by general multicast_lock by caller */
  2148. rcu_assign_pointer(br->ip6_querier.port, port);
  2149. return true;
  2150. }
  2151. #endif
  2152. static bool br_multicast_select_querier(struct net_bridge *br,
  2153. struct net_bridge_port *port,
  2154. struct br_ip *saddr)
  2155. {
  2156. switch (saddr->proto) {
  2157. case htons(ETH_P_IP):
  2158. return br_ip4_multicast_select_querier(br, port, saddr->src.ip4);
  2159. #if IS_ENABLED(CONFIG_IPV6)
  2160. case htons(ETH_P_IPV6):
  2161. return br_ip6_multicast_select_querier(br, port, &saddr->src.ip6);
  2162. #endif
  2163. }
  2164. return false;
  2165. }
  2166. static void
  2167. br_multicast_update_query_timer(struct net_bridge *br,
  2168. struct bridge_mcast_other_query *query,
  2169. unsigned long max_delay)
  2170. {
  2171. if (!timer_pending(&query->timer))
  2172. query->delay_time = jiffies + max_delay;
  2173. mod_timer(&query->timer, jiffies + br->multicast_querier_interval);
  2174. }
  2175. static void br_port_mc_router_state_change(struct net_bridge_port *p,
  2176. bool is_mc_router)
  2177. {
  2178. struct switchdev_attr attr = {
  2179. .orig_dev = p->dev,
  2180. .id = SWITCHDEV_ATTR_ID_PORT_MROUTER,
  2181. .flags = SWITCHDEV_F_DEFER,
  2182. .u.mrouter = is_mc_router,
  2183. };
  2184. switchdev_port_attr_set(p->dev, &attr);
  2185. }
  2186. /*
  2187. * Add port to router_list
  2188. * list is maintained ordered by pointer value
  2189. * and locked by br->multicast_lock and RCU
  2190. */
  2191. static void br_multicast_add_router(struct net_bridge *br,
  2192. struct net_bridge_port *port)
  2193. {
  2194. struct net_bridge_port *p;
  2195. struct hlist_node *slot = NULL;
  2196. if (!hlist_unhashed(&port->rlist))
  2197. return;
  2198. hlist_for_each_entry(p, &br->router_list, rlist) {
  2199. if ((unsigned long) port >= (unsigned long) p)
  2200. break;
  2201. slot = &p->rlist;
  2202. }
  2203. if (slot)
  2204. hlist_add_behind_rcu(&port->rlist, slot);
  2205. else
  2206. hlist_add_head_rcu(&port->rlist, &br->router_list);
  2207. br_rtr_notify(br->dev, port, RTM_NEWMDB);
  2208. br_port_mc_router_state_change(port, true);
  2209. }
  2210. static void br_multicast_mark_router(struct net_bridge *br,
  2211. struct net_bridge_port *port)
  2212. {
  2213. unsigned long now = jiffies;
  2214. if (!port) {
  2215. if (br->multicast_router == MDB_RTR_TYPE_TEMP_QUERY) {
  2216. if (!timer_pending(&br->multicast_router_timer))
  2217. br_mc_router_state_change(br, true);
  2218. mod_timer(&br->multicast_router_timer,
  2219. now + br->multicast_querier_interval);
  2220. }
  2221. return;
  2222. }
  2223. if (port->multicast_router == MDB_RTR_TYPE_DISABLED ||
  2224. port->multicast_router == MDB_RTR_TYPE_PERM)
  2225. return;
  2226. br_multicast_add_router(br, port);
  2227. mod_timer(&port->multicast_router_timer,
  2228. now + br->multicast_querier_interval);
  2229. }
  2230. static void br_multicast_query_received(struct net_bridge *br,
  2231. struct net_bridge_port *port,
  2232. struct bridge_mcast_other_query *query,
  2233. struct br_ip *saddr,
  2234. unsigned long max_delay)
  2235. {
  2236. if (!br_multicast_select_querier(br, port, saddr))
  2237. return;
  2238. br_multicast_update_query_timer(br, query, max_delay);
  2239. br_multicast_mark_router(br, port);
  2240. }
  2241. static void br_ip4_multicast_query(struct net_bridge *br,
  2242. struct net_bridge_port *port,
  2243. struct sk_buff *skb,
  2244. u16 vid)
  2245. {
  2246. unsigned int transport_len = ip_transport_len(skb);
  2247. const struct iphdr *iph = ip_hdr(skb);
  2248. struct igmphdr *ih = igmp_hdr(skb);
  2249. struct net_bridge_mdb_entry *mp;
  2250. struct igmpv3_query *ih3;
  2251. struct net_bridge_port_group *p;
  2252. struct net_bridge_port_group __rcu **pp;
  2253. struct br_ip saddr;
  2254. unsigned long max_delay;
  2255. unsigned long now = jiffies;
  2256. __be32 group;
  2257. spin_lock(&br->multicast_lock);
  2258. if (!netif_running(br->dev) ||
  2259. (port && port->state == BR_STATE_DISABLED))
  2260. goto out;
  2261. group = ih->group;
  2262. if (transport_len == sizeof(*ih)) {
  2263. max_delay = ih->code * (HZ / IGMP_TIMER_SCALE);
  2264. if (!max_delay) {
  2265. max_delay = 10 * HZ;
  2266. group = 0;
  2267. }
  2268. } else if (transport_len >= sizeof(*ih3)) {
  2269. ih3 = igmpv3_query_hdr(skb);
  2270. if (ih3->nsrcs ||
  2271. (br->multicast_igmp_version == 3 && group && ih3->suppress))
  2272. goto out;
  2273. max_delay = ih3->code ?
  2274. IGMPV3_MRC(ih3->code) * (HZ / IGMP_TIMER_SCALE) : 1;
  2275. } else {
  2276. goto out;
  2277. }
  2278. if (!group) {
  2279. saddr.proto = htons(ETH_P_IP);
  2280. saddr.src.ip4 = iph->saddr;
  2281. br_multicast_query_received(br, port, &br->ip4_other_query,
  2282. &saddr, max_delay);
  2283. goto out;
  2284. }
  2285. mp = br_mdb_ip4_get(br, group, vid);
  2286. if (!mp)
  2287. goto out;
  2288. max_delay *= br->multicast_last_member_count;
  2289. if (mp->host_joined &&
  2290. (timer_pending(&mp->timer) ?
  2291. time_after(mp->timer.expires, now + max_delay) :
  2292. try_to_del_timer_sync(&mp->timer) >= 0))
  2293. mod_timer(&mp->timer, now + max_delay);
  2294. for (pp = &mp->ports;
  2295. (p = mlock_dereference(*pp, br)) != NULL;
  2296. pp = &p->next) {
  2297. if (timer_pending(&p->timer) ?
  2298. time_after(p->timer.expires, now + max_delay) :
  2299. try_to_del_timer_sync(&p->timer) >= 0 &&
  2300. (br->multicast_igmp_version == 2 ||
  2301. p->filter_mode == MCAST_EXCLUDE))
  2302. mod_timer(&p->timer, now + max_delay);
  2303. }
  2304. out:
  2305. spin_unlock(&br->multicast_lock);
  2306. }
  2307. #if IS_ENABLED(CONFIG_IPV6)
  2308. static int br_ip6_multicast_query(struct net_bridge *br,
  2309. struct net_bridge_port *port,
  2310. struct sk_buff *skb,
  2311. u16 vid)
  2312. {
  2313. unsigned int transport_len = ipv6_transport_len(skb);
  2314. struct mld_msg *mld;
  2315. struct net_bridge_mdb_entry *mp;
  2316. struct mld2_query *mld2q;
  2317. struct net_bridge_port_group *p;
  2318. struct net_bridge_port_group __rcu **pp;
  2319. struct br_ip saddr;
  2320. unsigned long max_delay;
  2321. unsigned long now = jiffies;
  2322. unsigned int offset = skb_transport_offset(skb);
  2323. const struct in6_addr *group = NULL;
  2324. bool is_general_query;
  2325. int err = 0;
  2326. spin_lock(&br->multicast_lock);
  2327. if (!netif_running(br->dev) ||
  2328. (port && port->state == BR_STATE_DISABLED))
  2329. goto out;
  2330. if (transport_len == sizeof(*mld)) {
  2331. if (!pskb_may_pull(skb, offset + sizeof(*mld))) {
  2332. err = -EINVAL;
  2333. goto out;
  2334. }
  2335. mld = (struct mld_msg *) icmp6_hdr(skb);
  2336. max_delay = msecs_to_jiffies(ntohs(mld->mld_maxdelay));
  2337. if (max_delay)
  2338. group = &mld->mld_mca;
  2339. } else {
  2340. if (!pskb_may_pull(skb, offset + sizeof(*mld2q))) {
  2341. err = -EINVAL;
  2342. goto out;
  2343. }
  2344. mld2q = (struct mld2_query *)icmp6_hdr(skb);
  2345. if (!mld2q->mld2q_nsrcs)
  2346. group = &mld2q->mld2q_mca;
  2347. if (br->multicast_mld_version == 2 &&
  2348. !ipv6_addr_any(&mld2q->mld2q_mca) &&
  2349. mld2q->mld2q_suppress)
  2350. goto out;
  2351. max_delay = max(msecs_to_jiffies(mldv2_mrc(mld2q)), 1UL);
  2352. }
  2353. is_general_query = group && ipv6_addr_any(group);
  2354. if (is_general_query) {
  2355. saddr.proto = htons(ETH_P_IPV6);
  2356. saddr.src.ip6 = ipv6_hdr(skb)->saddr;
  2357. br_multicast_query_received(br, port, &br->ip6_other_query,
  2358. &saddr, max_delay);
  2359. goto out;
  2360. } else if (!group) {
  2361. goto out;
  2362. }
  2363. mp = br_mdb_ip6_get(br, group, vid);
  2364. if (!mp)
  2365. goto out;
  2366. max_delay *= br->multicast_last_member_count;
  2367. if (mp->host_joined &&
  2368. (timer_pending(&mp->timer) ?
  2369. time_after(mp->timer.expires, now + max_delay) :
  2370. try_to_del_timer_sync(&mp->timer) >= 0))
  2371. mod_timer(&mp->timer, now + max_delay);
  2372. for (pp = &mp->ports;
  2373. (p = mlock_dereference(*pp, br)) != NULL;
  2374. pp = &p->next) {
  2375. if (timer_pending(&p->timer) ?
  2376. time_after(p->timer.expires, now + max_delay) :
  2377. try_to_del_timer_sync(&p->timer) >= 0 &&
  2378. (br->multicast_mld_version == 1 ||
  2379. p->filter_mode == MCAST_EXCLUDE))
  2380. mod_timer(&p->timer, now + max_delay);
  2381. }
  2382. out:
  2383. spin_unlock(&br->multicast_lock);
  2384. return err;
  2385. }
  2386. #endif
  2387. static void
  2388. br_multicast_leave_group(struct net_bridge *br,
  2389. struct net_bridge_port *port,
  2390. struct br_ip *group,
  2391. struct bridge_mcast_other_query *other_query,
  2392. struct bridge_mcast_own_query *own_query,
  2393. const unsigned char *src)
  2394. {
  2395. struct net_bridge_mdb_entry *mp;
  2396. struct net_bridge_port_group *p;
  2397. unsigned long now;
  2398. unsigned long time;
  2399. spin_lock(&br->multicast_lock);
  2400. if (!netif_running(br->dev) ||
  2401. (port && port->state == BR_STATE_DISABLED))
  2402. goto out;
  2403. mp = br_mdb_ip_get(br, group);
  2404. if (!mp)
  2405. goto out;
  2406. if (port && (port->flags & BR_MULTICAST_FAST_LEAVE)) {
  2407. struct net_bridge_port_group __rcu **pp;
  2408. for (pp = &mp->ports;
  2409. (p = mlock_dereference(*pp, br)) != NULL;
  2410. pp = &p->next) {
  2411. if (!br_port_group_equal(p, port, src))
  2412. continue;
  2413. if (p->flags & MDB_PG_FLAGS_PERMANENT)
  2414. break;
  2415. p->flags |= MDB_PG_FLAGS_FAST_LEAVE;
  2416. br_multicast_del_pg(mp, p, pp);
  2417. }
  2418. goto out;
  2419. }
  2420. if (timer_pending(&other_query->timer))
  2421. goto out;
  2422. if (br_opt_get(br, BROPT_MULTICAST_QUERIER)) {
  2423. __br_multicast_send_query(br, port, NULL, NULL, &mp->addr,
  2424. false, 0, NULL);
  2425. time = jiffies + br->multicast_last_member_count *
  2426. br->multicast_last_member_interval;
  2427. mod_timer(&own_query->timer, time);
  2428. for (p = mlock_dereference(mp->ports, br);
  2429. p != NULL;
  2430. p = mlock_dereference(p->next, br)) {
  2431. if (!br_port_group_equal(p, port, src))
  2432. continue;
  2433. if (!hlist_unhashed(&p->mglist) &&
  2434. (timer_pending(&p->timer) ?
  2435. time_after(p->timer.expires, time) :
  2436. try_to_del_timer_sync(&p->timer) >= 0)) {
  2437. mod_timer(&p->timer, time);
  2438. }
  2439. break;
  2440. }
  2441. }
  2442. now = jiffies;
  2443. time = now + br->multicast_last_member_count *
  2444. br->multicast_last_member_interval;
  2445. if (!port) {
  2446. if (mp->host_joined &&
  2447. (timer_pending(&mp->timer) ?
  2448. time_after(mp->timer.expires, time) :
  2449. try_to_del_timer_sync(&mp->timer) >= 0)) {
  2450. mod_timer(&mp->timer, time);
  2451. }
  2452. goto out;
  2453. }
  2454. for (p = mlock_dereference(mp->ports, br);
  2455. p != NULL;
  2456. p = mlock_dereference(p->next, br)) {
  2457. if (p->key.port != port)
  2458. continue;
  2459. if (!hlist_unhashed(&p->mglist) &&
  2460. (timer_pending(&p->timer) ?
  2461. time_after(p->timer.expires, time) :
  2462. try_to_del_timer_sync(&p->timer) >= 0)) {
  2463. mod_timer(&p->timer, time);
  2464. }
  2465. break;
  2466. }
  2467. out:
  2468. spin_unlock(&br->multicast_lock);
  2469. }
  2470. static void br_ip4_multicast_leave_group(struct net_bridge *br,
  2471. struct net_bridge_port *port,
  2472. __be32 group,
  2473. __u16 vid,
  2474. const unsigned char *src)
  2475. {
  2476. struct br_ip br_group;
  2477. struct bridge_mcast_own_query *own_query;
  2478. if (ipv4_is_local_multicast(group))
  2479. return;
  2480. own_query = port ? &port->ip4_own_query : &br->ip4_own_query;
  2481. memset(&br_group, 0, sizeof(br_group));
  2482. br_group.dst.ip4 = group;
  2483. br_group.proto = htons(ETH_P_IP);
  2484. br_group.vid = vid;
  2485. br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
  2486. own_query, src);
  2487. }
  2488. #if IS_ENABLED(CONFIG_IPV6)
  2489. static void br_ip6_multicast_leave_group(struct net_bridge *br,
  2490. struct net_bridge_port *port,
  2491. const struct in6_addr *group,
  2492. __u16 vid,
  2493. const unsigned char *src)
  2494. {
  2495. struct br_ip br_group;
  2496. struct bridge_mcast_own_query *own_query;
  2497. if (ipv6_addr_is_ll_all_nodes(group))
  2498. return;
  2499. own_query = port ? &port->ip6_own_query : &br->ip6_own_query;
  2500. memset(&br_group, 0, sizeof(br_group));
  2501. br_group.dst.ip6 = *group;
  2502. br_group.proto = htons(ETH_P_IPV6);
  2503. br_group.vid = vid;
  2504. br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
  2505. own_query, src);
  2506. }
  2507. #endif
  2508. static void br_multicast_err_count(const struct net_bridge *br,
  2509. const struct net_bridge_port *p,
  2510. __be16 proto)
  2511. {
  2512. struct bridge_mcast_stats __percpu *stats;
  2513. struct bridge_mcast_stats *pstats;
  2514. if (!br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
  2515. return;
  2516. if (p)
  2517. stats = p->mcast_stats;
  2518. else
  2519. stats = br->mcast_stats;
  2520. if (WARN_ON(!stats))
  2521. return;
  2522. pstats = this_cpu_ptr(stats);
  2523. u64_stats_update_begin(&pstats->syncp);
  2524. switch (proto) {
  2525. case htons(ETH_P_IP):
  2526. pstats->mstats.igmp_parse_errors++;
  2527. break;
  2528. #if IS_ENABLED(CONFIG_IPV6)
  2529. case htons(ETH_P_IPV6):
  2530. pstats->mstats.mld_parse_errors++;
  2531. break;
  2532. #endif
  2533. }
  2534. u64_stats_update_end(&pstats->syncp);
  2535. }
  2536. static void br_multicast_pim(struct net_bridge *br,
  2537. struct net_bridge_port *port,
  2538. const struct sk_buff *skb)
  2539. {
  2540. unsigned int offset = skb_transport_offset(skb);
  2541. struct pimhdr *pimhdr, _pimhdr;
  2542. pimhdr = skb_header_pointer(skb, offset, sizeof(_pimhdr), &_pimhdr);
  2543. if (!pimhdr || pim_hdr_version(pimhdr) != PIM_VERSION ||
  2544. pim_hdr_type(pimhdr) != PIM_TYPE_HELLO)
  2545. return;
  2546. spin_lock(&br->multicast_lock);
  2547. br_multicast_mark_router(br, port);
  2548. spin_unlock(&br->multicast_lock);
  2549. }
  2550. static int br_ip4_multicast_mrd_rcv(struct net_bridge *br,
  2551. struct net_bridge_port *port,
  2552. struct sk_buff *skb)
  2553. {
  2554. if (ip_hdr(skb)->protocol != IPPROTO_IGMP ||
  2555. igmp_hdr(skb)->type != IGMP_MRDISC_ADV)
  2556. return -ENOMSG;
  2557. spin_lock(&br->multicast_lock);
  2558. br_multicast_mark_router(br, port);
  2559. spin_unlock(&br->multicast_lock);
  2560. return 0;
  2561. }
  2562. static int br_multicast_ipv4_rcv(struct net_bridge *br,
  2563. struct net_bridge_port *port,
  2564. struct sk_buff *skb,
  2565. u16 vid)
  2566. {
  2567. const unsigned char *src;
  2568. struct igmphdr *ih;
  2569. int err;
  2570. err = ip_mc_check_igmp(skb);
  2571. if (err == -ENOMSG) {
  2572. if (!ipv4_is_local_multicast(ip_hdr(skb)->daddr)) {
  2573. BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
  2574. } else if (pim_ipv4_all_pim_routers(ip_hdr(skb)->daddr)) {
  2575. if (ip_hdr(skb)->protocol == IPPROTO_PIM)
  2576. br_multicast_pim(br, port, skb);
  2577. } else if (ipv4_is_all_snoopers(ip_hdr(skb)->daddr)) {
  2578. br_ip4_multicast_mrd_rcv(br, port, skb);
  2579. }
  2580. return 0;
  2581. } else if (err < 0) {
  2582. br_multicast_err_count(br, port, skb->protocol);
  2583. return err;
  2584. }
  2585. ih = igmp_hdr(skb);
  2586. src = eth_hdr(skb)->h_source;
  2587. BR_INPUT_SKB_CB(skb)->igmp = ih->type;
  2588. switch (ih->type) {
  2589. case IGMP_HOST_MEMBERSHIP_REPORT:
  2590. case IGMPV2_HOST_MEMBERSHIP_REPORT:
  2591. BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
  2592. err = br_ip4_multicast_add_group(br, port, ih->group, vid, src,
  2593. true);
  2594. break;
  2595. case IGMPV3_HOST_MEMBERSHIP_REPORT:
  2596. err = br_ip4_multicast_igmp3_report(br, port, skb, vid);
  2597. break;
  2598. case IGMP_HOST_MEMBERSHIP_QUERY:
  2599. br_ip4_multicast_query(br, port, skb, vid);
  2600. break;
  2601. case IGMP_HOST_LEAVE_MESSAGE:
  2602. br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
  2603. break;
  2604. }
  2605. br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
  2606. BR_MCAST_DIR_RX);
  2607. return err;
  2608. }
  2609. #if IS_ENABLED(CONFIG_IPV6)
  2610. static void br_ip6_multicast_mrd_rcv(struct net_bridge *br,
  2611. struct net_bridge_port *port,
  2612. struct sk_buff *skb)
  2613. {
  2614. if (icmp6_hdr(skb)->icmp6_type != ICMPV6_MRDISC_ADV)
  2615. return;
  2616. spin_lock(&br->multicast_lock);
  2617. br_multicast_mark_router(br, port);
  2618. spin_unlock(&br->multicast_lock);
  2619. }
  2620. static int br_multicast_ipv6_rcv(struct net_bridge *br,
  2621. struct net_bridge_port *port,
  2622. struct sk_buff *skb,
  2623. u16 vid)
  2624. {
  2625. const unsigned char *src;
  2626. struct mld_msg *mld;
  2627. int err;
  2628. err = ipv6_mc_check_mld(skb);
  2629. if (err == -ENOMSG || err == -ENODATA) {
  2630. if (!ipv6_addr_is_ll_all_nodes(&ipv6_hdr(skb)->daddr))
  2631. BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
  2632. if (err == -ENODATA &&
  2633. ipv6_addr_is_all_snoopers(&ipv6_hdr(skb)->daddr))
  2634. br_ip6_multicast_mrd_rcv(br, port, skb);
  2635. return 0;
  2636. } else if (err < 0) {
  2637. br_multicast_err_count(br, port, skb->protocol);
  2638. return err;
  2639. }
  2640. mld = (struct mld_msg *)skb_transport_header(skb);
  2641. BR_INPUT_SKB_CB(skb)->igmp = mld->mld_type;
  2642. switch (mld->mld_type) {
  2643. case ICMPV6_MGM_REPORT:
  2644. src = eth_hdr(skb)->h_source;
  2645. BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
  2646. err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
  2647. src, true);
  2648. break;
  2649. case ICMPV6_MLD2_REPORT:
  2650. err = br_ip6_multicast_mld2_report(br, port, skb, vid);
  2651. break;
  2652. case ICMPV6_MGM_QUERY:
  2653. err = br_ip6_multicast_query(br, port, skb, vid);
  2654. break;
  2655. case ICMPV6_MGM_REDUCTION:
  2656. src = eth_hdr(skb)->h_source;
  2657. br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
  2658. break;
  2659. }
  2660. br_multicast_count(br, port, skb, BR_INPUT_SKB_CB(skb)->igmp,
  2661. BR_MCAST_DIR_RX);
  2662. return err;
  2663. }
  2664. #endif
  2665. int br_multicast_rcv(struct net_bridge *br, struct net_bridge_port *port,
  2666. struct sk_buff *skb, u16 vid)
  2667. {
  2668. int ret = 0;
  2669. BR_INPUT_SKB_CB(skb)->igmp = 0;
  2670. BR_INPUT_SKB_CB(skb)->mrouters_only = 0;
  2671. if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
  2672. return 0;
  2673. switch (skb->protocol) {
  2674. case htons(ETH_P_IP):
  2675. ret = br_multicast_ipv4_rcv(br, port, skb, vid);
  2676. break;
  2677. #if IS_ENABLED(CONFIG_IPV6)
  2678. case htons(ETH_P_IPV6):
  2679. ret = br_multicast_ipv6_rcv(br, port, skb, vid);
  2680. break;
  2681. #endif
  2682. }
  2683. return ret;
  2684. }
  2685. static void br_multicast_query_expired(struct net_bridge *br,
  2686. struct bridge_mcast_own_query *query,
  2687. struct bridge_mcast_querier *querier)
  2688. {
  2689. spin_lock(&br->multicast_lock);
  2690. if (query->startup_sent < br->multicast_startup_query_count)
  2691. query->startup_sent++;
  2692. RCU_INIT_POINTER(querier->port, NULL);
  2693. br_multicast_send_query(br, NULL, query);
  2694. spin_unlock(&br->multicast_lock);
  2695. }
  2696. static void br_ip4_multicast_query_expired(struct timer_list *t)
  2697. {
  2698. struct net_bridge *br = from_timer(br, t, ip4_own_query.timer);
  2699. br_multicast_query_expired(br, &br->ip4_own_query, &br->ip4_querier);
  2700. }
  2701. #if IS_ENABLED(CONFIG_IPV6)
  2702. static void br_ip6_multicast_query_expired(struct timer_list *t)
  2703. {
  2704. struct net_bridge *br = from_timer(br, t, ip6_own_query.timer);
  2705. br_multicast_query_expired(br, &br->ip6_own_query, &br->ip6_querier);
  2706. }
  2707. #endif
  2708. static void br_multicast_gc_work(struct work_struct *work)
  2709. {
  2710. struct net_bridge *br = container_of(work, struct net_bridge,
  2711. mcast_gc_work);
  2712. HLIST_HEAD(deleted_head);
  2713. spin_lock_bh(&br->multicast_lock);
  2714. hlist_move_list(&br->mcast_gc_list, &deleted_head);
  2715. spin_unlock_bh(&br->multicast_lock);
  2716. br_multicast_gc(&deleted_head);
  2717. }
  2718. void br_multicast_init(struct net_bridge *br)
  2719. {
  2720. br->hash_max = BR_MULTICAST_DEFAULT_HASH_MAX;
  2721. br->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
  2722. br->multicast_last_member_count = 2;
  2723. br->multicast_startup_query_count = 2;
  2724. br->multicast_last_member_interval = HZ;
  2725. br->multicast_query_response_interval = 10 * HZ;
  2726. br->multicast_startup_query_interval = 125 * HZ / 4;
  2727. br->multicast_query_interval = 125 * HZ;
  2728. br->multicast_querier_interval = 255 * HZ;
  2729. br->multicast_membership_interval = 260 * HZ;
  2730. br->ip4_other_query.delay_time = 0;
  2731. br->ip4_querier.port = NULL;
  2732. br->multicast_igmp_version = 2;
  2733. #if IS_ENABLED(CONFIG_IPV6)
  2734. br->multicast_mld_version = 1;
  2735. br->ip6_other_query.delay_time = 0;
  2736. br->ip6_querier.port = NULL;
  2737. #endif
  2738. br_opt_toggle(br, BROPT_MULTICAST_ENABLED, true);
  2739. br_opt_toggle(br, BROPT_HAS_IPV6_ADDR, true);
  2740. spin_lock_init(&br->multicast_lock);
  2741. timer_setup(&br->multicast_router_timer,
  2742. br_multicast_local_router_expired, 0);
  2743. timer_setup(&br->ip4_other_query.timer,
  2744. br_ip4_multicast_querier_expired, 0);
  2745. timer_setup(&br->ip4_own_query.timer,
  2746. br_ip4_multicast_query_expired, 0);
  2747. #if IS_ENABLED(CONFIG_IPV6)
  2748. timer_setup(&br->ip6_other_query.timer,
  2749. br_ip6_multicast_querier_expired, 0);
  2750. timer_setup(&br->ip6_own_query.timer,
  2751. br_ip6_multicast_query_expired, 0);
  2752. #endif
  2753. INIT_HLIST_HEAD(&br->mdb_list);
  2754. INIT_HLIST_HEAD(&br->mcast_gc_list);
  2755. INIT_WORK(&br->mcast_gc_work, br_multicast_gc_work);
  2756. }
  2757. static void br_ip4_multicast_join_snoopers(struct net_bridge *br)
  2758. {
  2759. struct in_device *in_dev = in_dev_get(br->dev);
  2760. if (!in_dev)
  2761. return;
  2762. __ip_mc_inc_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
  2763. in_dev_put(in_dev);
  2764. }
  2765. #if IS_ENABLED(CONFIG_IPV6)
  2766. static void br_ip6_multicast_join_snoopers(struct net_bridge *br)
  2767. {
  2768. struct in6_addr addr;
  2769. ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
  2770. ipv6_dev_mc_inc(br->dev, &addr);
  2771. }
  2772. #else
  2773. static inline void br_ip6_multicast_join_snoopers(struct net_bridge *br)
  2774. {
  2775. }
  2776. #endif
  2777. void br_multicast_join_snoopers(struct net_bridge *br)
  2778. {
  2779. br_ip4_multicast_join_snoopers(br);
  2780. br_ip6_multicast_join_snoopers(br);
  2781. }
  2782. static void br_ip4_multicast_leave_snoopers(struct net_bridge *br)
  2783. {
  2784. struct in_device *in_dev = in_dev_get(br->dev);
  2785. if (WARN_ON(!in_dev))
  2786. return;
  2787. __ip_mc_dec_group(in_dev, htonl(INADDR_ALLSNOOPERS_GROUP), GFP_ATOMIC);
  2788. in_dev_put(in_dev);
  2789. }
  2790. #if IS_ENABLED(CONFIG_IPV6)
  2791. static void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
  2792. {
  2793. struct in6_addr addr;
  2794. ipv6_addr_set(&addr, htonl(0xff020000), 0, 0, htonl(0x6a));
  2795. ipv6_dev_mc_dec(br->dev, &addr);
  2796. }
  2797. #else
  2798. static inline void br_ip6_multicast_leave_snoopers(struct net_bridge *br)
  2799. {
  2800. }
  2801. #endif
  2802. void br_multicast_leave_snoopers(struct net_bridge *br)
  2803. {
  2804. br_ip4_multicast_leave_snoopers(br);
  2805. br_ip6_multicast_leave_snoopers(br);
  2806. }
  2807. static void __br_multicast_open(struct net_bridge *br,
  2808. struct bridge_mcast_own_query *query)
  2809. {
  2810. query->startup_sent = 0;
  2811. if (!br_opt_get(br, BROPT_MULTICAST_ENABLED))
  2812. return;
  2813. mod_timer(&query->timer, jiffies);
  2814. }
  2815. void br_multicast_open(struct net_bridge *br)
  2816. {
  2817. __br_multicast_open(br, &br->ip4_own_query);
  2818. #if IS_ENABLED(CONFIG_IPV6)
  2819. __br_multicast_open(br, &br->ip6_own_query);
  2820. #endif
  2821. }
  2822. void br_multicast_stop(struct net_bridge *br)
  2823. {
  2824. del_timer_sync(&br->multicast_router_timer);
  2825. del_timer_sync(&br->ip4_other_query.timer);
  2826. del_timer_sync(&br->ip4_own_query.timer);
  2827. #if IS_ENABLED(CONFIG_IPV6)
  2828. del_timer_sync(&br->ip6_other_query.timer);
  2829. del_timer_sync(&br->ip6_own_query.timer);
  2830. #endif
  2831. }
  2832. void br_multicast_dev_del(struct net_bridge *br)
  2833. {
  2834. struct net_bridge_mdb_entry *mp;
  2835. HLIST_HEAD(deleted_head);
  2836. struct hlist_node *tmp;
  2837. spin_lock_bh(&br->multicast_lock);
  2838. hlist_for_each_entry_safe(mp, tmp, &br->mdb_list, mdb_node)
  2839. br_multicast_del_mdb_entry(mp);
  2840. hlist_move_list(&br->mcast_gc_list, &deleted_head);
  2841. spin_unlock_bh(&br->multicast_lock);
  2842. br_multicast_gc(&deleted_head);
  2843. cancel_work_sync(&br->mcast_gc_work);
  2844. rcu_barrier();
  2845. }
  2846. int br_multicast_set_router(struct net_bridge *br, unsigned long val)
  2847. {
  2848. int err = -EINVAL;
  2849. spin_lock_bh(&br->multicast_lock);
  2850. switch (val) {
  2851. case MDB_RTR_TYPE_DISABLED:
  2852. case MDB_RTR_TYPE_PERM:
  2853. br_mc_router_state_change(br, val == MDB_RTR_TYPE_PERM);
  2854. del_timer(&br->multicast_router_timer);
  2855. br->multicast_router = val;
  2856. err = 0;
  2857. break;
  2858. case MDB_RTR_TYPE_TEMP_QUERY:
  2859. if (br->multicast_router != MDB_RTR_TYPE_TEMP_QUERY)
  2860. br_mc_router_state_change(br, false);
  2861. br->multicast_router = val;
  2862. err = 0;
  2863. break;
  2864. }
  2865. spin_unlock_bh(&br->multicast_lock);
  2866. return err;
  2867. }
  2868. static void __del_port_router(struct net_bridge_port *p)
  2869. {
  2870. if (hlist_unhashed(&p->rlist))
  2871. return;
  2872. hlist_del_init_rcu(&p->rlist);
  2873. br_rtr_notify(p->br->dev, p, RTM_DELMDB);
  2874. br_port_mc_router_state_change(p, false);
  2875. /* don't allow timer refresh */
  2876. if (p->multicast_router == MDB_RTR_TYPE_TEMP)
  2877. p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
  2878. }
  2879. int br_multicast_set_port_router(struct net_bridge_port *p, unsigned long val)
  2880. {
  2881. struct net_bridge *br = p->br;
  2882. unsigned long now = jiffies;
  2883. int err = -EINVAL;
  2884. spin_lock(&br->multicast_lock);
  2885. if (p->multicast_router == val) {
  2886. /* Refresh the temp router port timer */
  2887. if (p->multicast_router == MDB_RTR_TYPE_TEMP)
  2888. mod_timer(&p->multicast_router_timer,
  2889. now + br->multicast_querier_interval);
  2890. err = 0;
  2891. goto unlock;
  2892. }
  2893. switch (val) {
  2894. case MDB_RTR_TYPE_DISABLED:
  2895. p->multicast_router = MDB_RTR_TYPE_DISABLED;
  2896. __del_port_router(p);
  2897. del_timer(&p->multicast_router_timer);
  2898. break;
  2899. case MDB_RTR_TYPE_TEMP_QUERY:
  2900. p->multicast_router = MDB_RTR_TYPE_TEMP_QUERY;
  2901. __del_port_router(p);
  2902. break;
  2903. case MDB_RTR_TYPE_PERM:
  2904. p->multicast_router = MDB_RTR_TYPE_PERM;
  2905. del_timer(&p->multicast_router_timer);
  2906. br_multicast_add_router(br, p);
  2907. break;
  2908. case MDB_RTR_TYPE_TEMP:
  2909. p->multicast_router = MDB_RTR_TYPE_TEMP;
  2910. br_multicast_mark_router(br, p);
  2911. break;
  2912. default:
  2913. goto unlock;
  2914. }
  2915. err = 0;
  2916. unlock:
  2917. spin_unlock(&br->multicast_lock);
  2918. return err;
  2919. }
  2920. static void br_multicast_start_querier(struct net_bridge *br,
  2921. struct bridge_mcast_own_query *query)
  2922. {
  2923. struct net_bridge_port *port;
  2924. __br_multicast_open(br, query);
  2925. rcu_read_lock();
  2926. list_for_each_entry_rcu(port, &br->port_list, list) {
  2927. if (port->state == BR_STATE_DISABLED ||
  2928. port->state == BR_STATE_BLOCKING)
  2929. continue;
  2930. if (query == &br->ip4_own_query)
  2931. br_multicast_enable(&port->ip4_own_query);
  2932. #if IS_ENABLED(CONFIG_IPV6)
  2933. else
  2934. br_multicast_enable(&port->ip6_own_query);
  2935. #endif
  2936. }
  2937. rcu_read_unlock();
  2938. }
  2939. int br_multicast_toggle(struct net_bridge *br, unsigned long val)
  2940. {
  2941. struct net_bridge_port *port;
  2942. bool change_snoopers = false;
  2943. spin_lock_bh(&br->multicast_lock);
  2944. if (!!br_opt_get(br, BROPT_MULTICAST_ENABLED) == !!val)
  2945. goto unlock;
  2946. br_mc_disabled_update(br->dev, val);
  2947. br_opt_toggle(br, BROPT_MULTICAST_ENABLED, !!val);
  2948. if (!br_opt_get(br, BROPT_MULTICAST_ENABLED)) {
  2949. change_snoopers = true;
  2950. goto unlock;
  2951. }
  2952. if (!netif_running(br->dev))
  2953. goto unlock;
  2954. br_multicast_open(br);
  2955. list_for_each_entry(port, &br->port_list, list)
  2956. __br_multicast_enable_port(port);
  2957. change_snoopers = true;
  2958. unlock:
  2959. spin_unlock_bh(&br->multicast_lock);
  2960. /* br_multicast_join_snoopers has the potential to cause
  2961. * an MLD Report/Leave to be delivered to br_multicast_rcv,
  2962. * which would in turn call br_multicast_add_group, which would
  2963. * attempt to acquire multicast_lock. This function should be
  2964. * called after the lock has been released to avoid deadlocks on
  2965. * multicast_lock.
  2966. *
  2967. * br_multicast_leave_snoopers does not have the problem since
  2968. * br_multicast_rcv first checks BROPT_MULTICAST_ENABLED, and
  2969. * returns without calling br_multicast_ipv4/6_rcv if it's not
  2970. * enabled. Moved both functions out just for symmetry.
  2971. */
  2972. if (change_snoopers) {
  2973. if (br_opt_get(br, BROPT_MULTICAST_ENABLED))
  2974. br_multicast_join_snoopers(br);
  2975. else
  2976. br_multicast_leave_snoopers(br);
  2977. }
  2978. return 0;
  2979. }
  2980. bool br_multicast_enabled(const struct net_device *dev)
  2981. {
  2982. struct net_bridge *br = netdev_priv(dev);
  2983. return !!br_opt_get(br, BROPT_MULTICAST_ENABLED);
  2984. }
  2985. EXPORT_SYMBOL_GPL(br_multicast_enabled);
  2986. bool br_multicast_router(const struct net_device *dev)
  2987. {
  2988. struct net_bridge *br = netdev_priv(dev);
  2989. bool is_router;
  2990. spin_lock_bh(&br->multicast_lock);
  2991. is_router = br_multicast_is_router(br);
  2992. spin_unlock_bh(&br->multicast_lock);
  2993. return is_router;
  2994. }
  2995. EXPORT_SYMBOL_GPL(br_multicast_router);
  2996. int br_multicast_set_querier(struct net_bridge *br, unsigned long val)
  2997. {
  2998. unsigned long max_delay;
  2999. val = !!val;
  3000. spin_lock_bh(&br->multicast_lock);
  3001. if (br_opt_get(br, BROPT_MULTICAST_QUERIER) == val)
  3002. goto unlock;
  3003. br_opt_toggle(br, BROPT_MULTICAST_QUERIER, !!val);
  3004. if (!val)
  3005. goto unlock;
  3006. max_delay = br->multicast_query_response_interval;
  3007. if (!timer_pending(&br->ip4_other_query.timer))
  3008. br->ip4_other_query.delay_time = jiffies + max_delay;
  3009. br_multicast_start_querier(br, &br->ip4_own_query);
  3010. #if IS_ENABLED(CONFIG_IPV6)
  3011. if (!timer_pending(&br->ip6_other_query.timer))
  3012. br->ip6_other_query.delay_time = jiffies + max_delay;
  3013. br_multicast_start_querier(br, &br->ip6_own_query);
  3014. #endif
  3015. unlock:
  3016. spin_unlock_bh(&br->multicast_lock);
  3017. return 0;
  3018. }
  3019. int br_multicast_set_igmp_version(struct net_bridge *br, unsigned long val)
  3020. {
  3021. /* Currently we support only version 2 and 3 */
  3022. switch (val) {
  3023. case 2:
  3024. case 3:
  3025. break;
  3026. default:
  3027. return -EINVAL;
  3028. }
  3029. spin_lock_bh(&br->multicast_lock);
  3030. br->multicast_igmp_version = val;
  3031. spin_unlock_bh(&br->multicast_lock);
  3032. return 0;
  3033. }
  3034. #if IS_ENABLED(CONFIG_IPV6)
  3035. int br_multicast_set_mld_version(struct net_bridge *br, unsigned long val)
  3036. {
  3037. /* Currently we support version 1 and 2 */
  3038. switch (val) {
  3039. case 1:
  3040. case 2:
  3041. break;
  3042. default:
  3043. return -EINVAL;
  3044. }
  3045. spin_lock_bh(&br->multicast_lock);
  3046. br->multicast_mld_version = val;
  3047. spin_unlock_bh(&br->multicast_lock);
  3048. return 0;
  3049. }
  3050. #endif
  3051. /**
  3052. * br_multicast_list_adjacent - Returns snooped multicast addresses
  3053. * @dev: The bridge port adjacent to which to retrieve addresses
  3054. * @br_ip_list: The list to store found, snooped multicast IP addresses in
  3055. *
  3056. * Creates a list of IP addresses (struct br_ip_list) sensed by the multicast
  3057. * snooping feature on all bridge ports of dev's bridge device, excluding
  3058. * the addresses from dev itself.
  3059. *
  3060. * Returns the number of items added to br_ip_list.
  3061. *
  3062. * Notes:
  3063. * - br_ip_list needs to be initialized by caller
  3064. * - br_ip_list might contain duplicates in the end
  3065. * (needs to be taken care of by caller)
  3066. * - br_ip_list needs to be freed by caller
  3067. */
  3068. int br_multicast_list_adjacent(struct net_device *dev,
  3069. struct list_head *br_ip_list)
  3070. {
  3071. struct net_bridge *br;
  3072. struct net_bridge_port *port;
  3073. struct net_bridge_port_group *group;
  3074. struct br_ip_list *entry;
  3075. int count = 0;
  3076. rcu_read_lock();
  3077. if (!br_ip_list || !netif_is_bridge_port(dev))
  3078. goto unlock;
  3079. port = br_port_get_rcu(dev);
  3080. if (!port || !port->br)
  3081. goto unlock;
  3082. br = port->br;
  3083. list_for_each_entry_rcu(port, &br->port_list, list) {
  3084. if (!port->dev || port->dev == dev)
  3085. continue;
  3086. hlist_for_each_entry_rcu(group, &port->mglist, mglist) {
  3087. entry = kmalloc(sizeof(*entry), GFP_ATOMIC);
  3088. if (!entry)
  3089. goto unlock;
  3090. entry->addr = group->key.addr;
  3091. list_add(&entry->list, br_ip_list);
  3092. count++;
  3093. }
  3094. }
  3095. unlock:
  3096. rcu_read_unlock();
  3097. return count;
  3098. }
  3099. EXPORT_SYMBOL_GPL(br_multicast_list_adjacent);
  3100. /**
  3101. * br_multicast_has_querier_anywhere - Checks for a querier on a bridge
  3102. * @dev: The bridge port providing the bridge on which to check for a querier
  3103. * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
  3104. *
  3105. * Checks whether the given interface has a bridge on top and if so returns
  3106. * true if a valid querier exists anywhere on the bridged link layer.
  3107. * Otherwise returns false.
  3108. */
  3109. bool br_multicast_has_querier_anywhere(struct net_device *dev, int proto)
  3110. {
  3111. struct net_bridge *br;
  3112. struct net_bridge_port *port;
  3113. struct ethhdr eth;
  3114. bool ret = false;
  3115. rcu_read_lock();
  3116. if (!netif_is_bridge_port(dev))
  3117. goto unlock;
  3118. port = br_port_get_rcu(dev);
  3119. if (!port || !port->br)
  3120. goto unlock;
  3121. br = port->br;
  3122. memset(&eth, 0, sizeof(eth));
  3123. eth.h_proto = htons(proto);
  3124. ret = br_multicast_querier_exists(br, &eth);
  3125. unlock:
  3126. rcu_read_unlock();
  3127. return ret;
  3128. }
  3129. EXPORT_SYMBOL_GPL(br_multicast_has_querier_anywhere);
  3130. /**
  3131. * br_multicast_has_querier_adjacent - Checks for a querier behind a bridge port
  3132. * @dev: The bridge port adjacent to which to check for a querier
  3133. * @proto: The protocol family to check for: IGMP -> ETH_P_IP, MLD -> ETH_P_IPV6
  3134. *
  3135. * Checks whether the given interface has a bridge on top and if so returns
  3136. * true if a selected querier is behind one of the other ports of this
  3137. * bridge. Otherwise returns false.
  3138. */
  3139. bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto)
  3140. {
  3141. struct net_bridge *br;
  3142. struct net_bridge_port *port;
  3143. bool ret = false;
  3144. rcu_read_lock();
  3145. if (!netif_is_bridge_port(dev))
  3146. goto unlock;
  3147. port = br_port_get_rcu(dev);
  3148. if (!port || !port->br)
  3149. goto unlock;
  3150. br = port->br;
  3151. switch (proto) {
  3152. case ETH_P_IP:
  3153. if (!timer_pending(&br->ip4_other_query.timer) ||
  3154. rcu_dereference(br->ip4_querier.port) == port)
  3155. goto unlock;
  3156. break;
  3157. #if IS_ENABLED(CONFIG_IPV6)
  3158. case ETH_P_IPV6:
  3159. if (!timer_pending(&br->ip6_other_query.timer) ||
  3160. rcu_dereference(br->ip6_querier.port) == port)
  3161. goto unlock;
  3162. break;
  3163. #endif
  3164. default:
  3165. goto unlock;
  3166. }
  3167. ret = true;
  3168. unlock:
  3169. rcu_read_unlock();
  3170. return ret;
  3171. }
  3172. EXPORT_SYMBOL_GPL(br_multicast_has_querier_adjacent);
  3173. static void br_mcast_stats_add(struct bridge_mcast_stats __percpu *stats,
  3174. const struct sk_buff *skb, u8 type, u8 dir)
  3175. {
  3176. struct bridge_mcast_stats *pstats = this_cpu_ptr(stats);
  3177. __be16 proto = skb->protocol;
  3178. unsigned int t_len;
  3179. u64_stats_update_begin(&pstats->syncp);
  3180. switch (proto) {
  3181. case htons(ETH_P_IP):
  3182. t_len = ntohs(ip_hdr(skb)->tot_len) - ip_hdrlen(skb);
  3183. switch (type) {
  3184. case IGMP_HOST_MEMBERSHIP_REPORT:
  3185. pstats->mstats.igmp_v1reports[dir]++;
  3186. break;
  3187. case IGMPV2_HOST_MEMBERSHIP_REPORT:
  3188. pstats->mstats.igmp_v2reports[dir]++;
  3189. break;
  3190. case IGMPV3_HOST_MEMBERSHIP_REPORT:
  3191. pstats->mstats.igmp_v3reports[dir]++;
  3192. break;
  3193. case IGMP_HOST_MEMBERSHIP_QUERY:
  3194. if (t_len != sizeof(struct igmphdr)) {
  3195. pstats->mstats.igmp_v3queries[dir]++;
  3196. } else {
  3197. unsigned int offset = skb_transport_offset(skb);
  3198. struct igmphdr *ih, _ihdr;
  3199. ih = skb_header_pointer(skb, offset,
  3200. sizeof(_ihdr), &_ihdr);
  3201. if (!ih)
  3202. break;
  3203. if (!ih->code)
  3204. pstats->mstats.igmp_v1queries[dir]++;
  3205. else
  3206. pstats->mstats.igmp_v2queries[dir]++;
  3207. }
  3208. break;
  3209. case IGMP_HOST_LEAVE_MESSAGE:
  3210. pstats->mstats.igmp_leaves[dir]++;
  3211. break;
  3212. }
  3213. break;
  3214. #if IS_ENABLED(CONFIG_IPV6)
  3215. case htons(ETH_P_IPV6):
  3216. t_len = ntohs(ipv6_hdr(skb)->payload_len) +
  3217. sizeof(struct ipv6hdr);
  3218. t_len -= skb_network_header_len(skb);
  3219. switch (type) {
  3220. case ICMPV6_MGM_REPORT:
  3221. pstats->mstats.mld_v1reports[dir]++;
  3222. break;
  3223. case ICMPV6_MLD2_REPORT:
  3224. pstats->mstats.mld_v2reports[dir]++;
  3225. break;
  3226. case ICMPV6_MGM_QUERY:
  3227. if (t_len != sizeof(struct mld_msg))
  3228. pstats->mstats.mld_v2queries[dir]++;
  3229. else
  3230. pstats->mstats.mld_v1queries[dir]++;
  3231. break;
  3232. case ICMPV6_MGM_REDUCTION:
  3233. pstats->mstats.mld_leaves[dir]++;
  3234. break;
  3235. }
  3236. break;
  3237. #endif /* CONFIG_IPV6 */
  3238. }
  3239. u64_stats_update_end(&pstats->syncp);
  3240. }
  3241. void br_multicast_count(struct net_bridge *br, const struct net_bridge_port *p,
  3242. const struct sk_buff *skb, u8 type, u8 dir)
  3243. {
  3244. struct bridge_mcast_stats __percpu *stats;
  3245. /* if multicast_disabled is true then igmp type can't be set */
  3246. if (!type || !br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED))
  3247. return;
  3248. if (p)
  3249. stats = p->mcast_stats;
  3250. else
  3251. stats = br->mcast_stats;
  3252. if (WARN_ON(!stats))
  3253. return;
  3254. br_mcast_stats_add(stats, skb, type, dir);
  3255. }
  3256. int br_multicast_init_stats(struct net_bridge *br)
  3257. {
  3258. br->mcast_stats = netdev_alloc_pcpu_stats(struct bridge_mcast_stats);
  3259. if (!br->mcast_stats)
  3260. return -ENOMEM;
  3261. return 0;
  3262. }
  3263. void br_multicast_uninit_stats(struct net_bridge *br)
  3264. {
  3265. free_percpu(br->mcast_stats);
  3266. }
  3267. /* noinline for https://bugs.llvm.org/show_bug.cgi?id=45802#c9 */
  3268. static noinline_for_stack void mcast_stats_add_dir(u64 *dst, u64 *src)
  3269. {
  3270. dst[BR_MCAST_DIR_RX] += src[BR_MCAST_DIR_RX];
  3271. dst[BR_MCAST_DIR_TX] += src[BR_MCAST_DIR_TX];
  3272. }
  3273. void br_multicast_get_stats(const struct net_bridge *br,
  3274. const struct net_bridge_port *p,
  3275. struct br_mcast_stats *dest)
  3276. {
  3277. struct bridge_mcast_stats __percpu *stats;
  3278. struct br_mcast_stats tdst;
  3279. int i;
  3280. memset(dest, 0, sizeof(*dest));
  3281. if (p)
  3282. stats = p->mcast_stats;
  3283. else
  3284. stats = br->mcast_stats;
  3285. if (WARN_ON(!stats))
  3286. return;
  3287. memset(&tdst, 0, sizeof(tdst));
  3288. for_each_possible_cpu(i) {
  3289. struct bridge_mcast_stats *cpu_stats = per_cpu_ptr(stats, i);
  3290. struct br_mcast_stats temp;
  3291. unsigned int start;
  3292. do {
  3293. start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
  3294. memcpy(&temp, &cpu_stats->mstats, sizeof(temp));
  3295. } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
  3296. mcast_stats_add_dir(tdst.igmp_v1queries, temp.igmp_v1queries);
  3297. mcast_stats_add_dir(tdst.igmp_v2queries, temp.igmp_v2queries);
  3298. mcast_stats_add_dir(tdst.igmp_v3queries, temp.igmp_v3queries);
  3299. mcast_stats_add_dir(tdst.igmp_leaves, temp.igmp_leaves);
  3300. mcast_stats_add_dir(tdst.igmp_v1reports, temp.igmp_v1reports);
  3301. mcast_stats_add_dir(tdst.igmp_v2reports, temp.igmp_v2reports);
  3302. mcast_stats_add_dir(tdst.igmp_v3reports, temp.igmp_v3reports);
  3303. tdst.igmp_parse_errors += temp.igmp_parse_errors;
  3304. mcast_stats_add_dir(tdst.mld_v1queries, temp.mld_v1queries);
  3305. mcast_stats_add_dir(tdst.mld_v2queries, temp.mld_v2queries);
  3306. mcast_stats_add_dir(tdst.mld_leaves, temp.mld_leaves);
  3307. mcast_stats_add_dir(tdst.mld_v1reports, temp.mld_v1reports);
  3308. mcast_stats_add_dir(tdst.mld_v2reports, temp.mld_v2reports);
  3309. tdst.mld_parse_errors += temp.mld_parse_errors;
  3310. }
  3311. memcpy(dest, &tdst, sizeof(*dest));
  3312. }
  3313. int br_mdb_hash_init(struct net_bridge *br)
  3314. {
  3315. int err;
  3316. err = rhashtable_init(&br->sg_port_tbl, &br_sg_port_rht_params);
  3317. if (err)
  3318. return err;
  3319. err = rhashtable_init(&br->mdb_hash_tbl, &br_mdb_rht_params);
  3320. if (err) {
  3321. rhashtable_destroy(&br->sg_port_tbl);
  3322. return err;
  3323. }
  3324. return 0;
  3325. }
  3326. void br_mdb_hash_fini(struct net_bridge *br)
  3327. {
  3328. rhashtable_destroy(&br->sg_port_tbl);
  3329. rhashtable_destroy(&br->mdb_hash_tbl);
  3330. }