br_vlan.c 48 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. #include <linux/kernel.h>
  3. #include <linux/netdevice.h>
  4. #include <linux/rtnetlink.h>
  5. #include <linux/slab.h>
  6. #include <net/switchdev.h>
  7. #include "br_private.h"
  8. #include "br_private_tunnel.h"
  9. static void nbp_vlan_set_vlan_dev_state(struct net_bridge_port *p, u16 vid);
  10. static inline int br_vlan_cmp(struct rhashtable_compare_arg *arg,
  11. const void *ptr)
  12. {
  13. const struct net_bridge_vlan *vle = ptr;
  14. u16 vid = *(u16 *)arg->key;
  15. return vle->vid != vid;
  16. }
  17. static const struct rhashtable_params br_vlan_rht_params = {
  18. .head_offset = offsetof(struct net_bridge_vlan, vnode),
  19. .key_offset = offsetof(struct net_bridge_vlan, vid),
  20. .key_len = sizeof(u16),
  21. .nelem_hint = 3,
  22. .max_size = VLAN_N_VID,
  23. .obj_cmpfn = br_vlan_cmp,
  24. .automatic_shrinking = true,
  25. };
  26. static struct net_bridge_vlan *br_vlan_lookup(struct rhashtable *tbl, u16 vid)
  27. {
  28. return rhashtable_lookup_fast(tbl, &vid, br_vlan_rht_params);
  29. }
  30. static bool __vlan_add_pvid(struct net_bridge_vlan_group *vg,
  31. const struct net_bridge_vlan *v)
  32. {
  33. if (vg->pvid == v->vid)
  34. return false;
  35. smp_wmb();
  36. br_vlan_set_pvid_state(vg, v->state);
  37. vg->pvid = v->vid;
  38. return true;
  39. }
  40. static bool __vlan_delete_pvid(struct net_bridge_vlan_group *vg, u16 vid)
  41. {
  42. if (vg->pvid != vid)
  43. return false;
  44. smp_wmb();
  45. vg->pvid = 0;
  46. return true;
  47. }
  48. /* return true if anything changed, false otherwise */
  49. static bool __vlan_add_flags(struct net_bridge_vlan *v, u16 flags)
  50. {
  51. struct net_bridge_vlan_group *vg;
  52. u16 old_flags = v->flags;
  53. bool ret;
  54. if (br_vlan_is_master(v))
  55. vg = br_vlan_group(v->br);
  56. else
  57. vg = nbp_vlan_group(v->port);
  58. if (flags & BRIDGE_VLAN_INFO_PVID)
  59. ret = __vlan_add_pvid(vg, v);
  60. else
  61. ret = __vlan_delete_pvid(vg, v->vid);
  62. if (flags & BRIDGE_VLAN_INFO_UNTAGGED)
  63. v->flags |= BRIDGE_VLAN_INFO_UNTAGGED;
  64. else
  65. v->flags &= ~BRIDGE_VLAN_INFO_UNTAGGED;
  66. return ret || !!(old_flags ^ v->flags);
  67. }
  68. static int __vlan_vid_add(struct net_device *dev, struct net_bridge *br,
  69. struct net_bridge_vlan *v, u16 flags,
  70. struct netlink_ext_ack *extack)
  71. {
  72. int err;
  73. /* Try switchdev op first. In case it is not supported, fallback to
  74. * 8021q add.
  75. */
  76. err = br_switchdev_port_vlan_add(dev, v->vid, flags, extack);
  77. if (err == -EOPNOTSUPP)
  78. return vlan_vid_add(dev, br->vlan_proto, v->vid);
  79. v->priv_flags |= BR_VLFLAG_ADDED_BY_SWITCHDEV;
  80. return err;
  81. }
  82. static void __vlan_add_list(struct net_bridge_vlan *v)
  83. {
  84. struct net_bridge_vlan_group *vg;
  85. struct list_head *headp, *hpos;
  86. struct net_bridge_vlan *vent;
  87. if (br_vlan_is_master(v))
  88. vg = br_vlan_group(v->br);
  89. else
  90. vg = nbp_vlan_group(v->port);
  91. headp = &vg->vlan_list;
  92. list_for_each_prev(hpos, headp) {
  93. vent = list_entry(hpos, struct net_bridge_vlan, vlist);
  94. if (v->vid < vent->vid)
  95. continue;
  96. else
  97. break;
  98. }
  99. list_add_rcu(&v->vlist, hpos);
  100. }
  101. static void __vlan_del_list(struct net_bridge_vlan *v)
  102. {
  103. list_del_rcu(&v->vlist);
  104. }
  105. static int __vlan_vid_del(struct net_device *dev, struct net_bridge *br,
  106. const struct net_bridge_vlan *v)
  107. {
  108. int err;
  109. /* Try switchdev op first. In case it is not supported, fallback to
  110. * 8021q del.
  111. */
  112. err = br_switchdev_port_vlan_del(dev, v->vid);
  113. if (!(v->priv_flags & BR_VLFLAG_ADDED_BY_SWITCHDEV))
  114. vlan_vid_del(dev, br->vlan_proto, v->vid);
  115. return err == -EOPNOTSUPP ? 0 : err;
  116. }
  117. /* Returns a master vlan, if it didn't exist it gets created. In all cases
  118. * a reference is taken to the master vlan before returning.
  119. */
  120. static struct net_bridge_vlan *
  121. br_vlan_get_master(struct net_bridge *br, u16 vid,
  122. struct netlink_ext_ack *extack)
  123. {
  124. struct net_bridge_vlan_group *vg;
  125. struct net_bridge_vlan *masterv;
  126. vg = br_vlan_group(br);
  127. masterv = br_vlan_find(vg, vid);
  128. if (!masterv) {
  129. bool changed;
  130. /* missing global ctx, create it now */
  131. if (br_vlan_add(br, vid, 0, &changed, extack))
  132. return NULL;
  133. masterv = br_vlan_find(vg, vid);
  134. if (WARN_ON(!masterv))
  135. return NULL;
  136. refcount_set(&masterv->refcnt, 1);
  137. return masterv;
  138. }
  139. refcount_inc(&masterv->refcnt);
  140. return masterv;
  141. }
  142. static void br_master_vlan_rcu_free(struct rcu_head *rcu)
  143. {
  144. struct net_bridge_vlan *v;
  145. v = container_of(rcu, struct net_bridge_vlan, rcu);
  146. WARN_ON(!br_vlan_is_master(v));
  147. free_percpu(v->stats);
  148. v->stats = NULL;
  149. kfree(v);
  150. }
  151. static void br_vlan_put_master(struct net_bridge_vlan *masterv)
  152. {
  153. struct net_bridge_vlan_group *vg;
  154. if (!br_vlan_is_master(masterv))
  155. return;
  156. vg = br_vlan_group(masterv->br);
  157. if (refcount_dec_and_test(&masterv->refcnt)) {
  158. rhashtable_remove_fast(&vg->vlan_hash,
  159. &masterv->vnode, br_vlan_rht_params);
  160. __vlan_del_list(masterv);
  161. call_rcu(&masterv->rcu, br_master_vlan_rcu_free);
  162. }
  163. }
  164. static void nbp_vlan_rcu_free(struct rcu_head *rcu)
  165. {
  166. struct net_bridge_vlan *v;
  167. v = container_of(rcu, struct net_bridge_vlan, rcu);
  168. WARN_ON(br_vlan_is_master(v));
  169. /* if we had per-port stats configured then free them here */
  170. if (v->priv_flags & BR_VLFLAG_PER_PORT_STATS)
  171. free_percpu(v->stats);
  172. v->stats = NULL;
  173. kfree(v);
  174. }
  175. /* This is the shared VLAN add function which works for both ports and bridge
  176. * devices. There are four possible calls to this function in terms of the
  177. * vlan entry type:
  178. * 1. vlan is being added on a port (no master flags, global entry exists)
  179. * 2. vlan is being added on a bridge (both master and brentry flags)
  180. * 3. vlan is being added on a port, but a global entry didn't exist which
  181. * is being created right now (master flag set, brentry flag unset), the
  182. * global entry is used for global per-vlan features, but not for filtering
  183. * 4. same as 3 but with both master and brentry flags set so the entry
  184. * will be used for filtering in both the port and the bridge
  185. */
  186. static int __vlan_add(struct net_bridge_vlan *v, u16 flags,
  187. struct netlink_ext_ack *extack)
  188. {
  189. struct net_bridge_vlan *masterv = NULL;
  190. struct net_bridge_port *p = NULL;
  191. struct net_bridge_vlan_group *vg;
  192. struct net_device *dev;
  193. struct net_bridge *br;
  194. int err;
  195. if (br_vlan_is_master(v)) {
  196. br = v->br;
  197. dev = br->dev;
  198. vg = br_vlan_group(br);
  199. } else {
  200. p = v->port;
  201. br = p->br;
  202. dev = p->dev;
  203. vg = nbp_vlan_group(p);
  204. }
  205. if (p) {
  206. /* Add VLAN to the device filter if it is supported.
  207. * This ensures tagged traffic enters the bridge when
  208. * promiscuous mode is disabled by br_manage_promisc().
  209. */
  210. err = __vlan_vid_add(dev, br, v, flags, extack);
  211. if (err)
  212. goto out;
  213. /* need to work on the master vlan too */
  214. if (flags & BRIDGE_VLAN_INFO_MASTER) {
  215. bool changed;
  216. err = br_vlan_add(br, v->vid,
  217. flags | BRIDGE_VLAN_INFO_BRENTRY,
  218. &changed, extack);
  219. if (err)
  220. goto out_filt;
  221. if (changed)
  222. br_vlan_notify(br, NULL, v->vid, 0,
  223. RTM_NEWVLAN);
  224. }
  225. masterv = br_vlan_get_master(br, v->vid, extack);
  226. if (!masterv) {
  227. err = -ENOMEM;
  228. goto out_filt;
  229. }
  230. v->brvlan = masterv;
  231. if (br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)) {
  232. v->stats = netdev_alloc_pcpu_stats(struct br_vlan_stats);
  233. if (!v->stats) {
  234. err = -ENOMEM;
  235. goto out_filt;
  236. }
  237. v->priv_flags |= BR_VLFLAG_PER_PORT_STATS;
  238. } else {
  239. v->stats = masterv->stats;
  240. }
  241. } else {
  242. err = br_switchdev_port_vlan_add(dev, v->vid, flags, extack);
  243. if (err && err != -EOPNOTSUPP)
  244. goto out;
  245. }
  246. /* Add the dev mac and count the vlan only if it's usable */
  247. if (br_vlan_should_use(v)) {
  248. err = br_fdb_insert(br, p, dev->dev_addr, v->vid);
  249. if (err) {
  250. br_err(br, "failed insert local address into bridge forwarding table\n");
  251. goto out_filt;
  252. }
  253. vg->num_vlans++;
  254. }
  255. /* set the state before publishing */
  256. v->state = BR_STATE_FORWARDING;
  257. err = rhashtable_lookup_insert_fast(&vg->vlan_hash, &v->vnode,
  258. br_vlan_rht_params);
  259. if (err)
  260. goto out_fdb_insert;
  261. __vlan_add_list(v);
  262. __vlan_add_flags(v, flags);
  263. if (p)
  264. nbp_vlan_set_vlan_dev_state(p, v->vid);
  265. out:
  266. return err;
  267. out_fdb_insert:
  268. if (br_vlan_should_use(v)) {
  269. br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid);
  270. vg->num_vlans--;
  271. }
  272. out_filt:
  273. if (p) {
  274. __vlan_vid_del(dev, br, v);
  275. if (masterv) {
  276. if (v->stats && masterv->stats != v->stats)
  277. free_percpu(v->stats);
  278. v->stats = NULL;
  279. br_vlan_put_master(masterv);
  280. v->brvlan = NULL;
  281. }
  282. } else {
  283. br_switchdev_port_vlan_del(dev, v->vid);
  284. }
  285. goto out;
  286. }
  287. static int __vlan_del(struct net_bridge_vlan *v)
  288. {
  289. struct net_bridge_vlan *masterv = v;
  290. struct net_bridge_vlan_group *vg;
  291. struct net_bridge_port *p = NULL;
  292. int err = 0;
  293. if (br_vlan_is_master(v)) {
  294. vg = br_vlan_group(v->br);
  295. } else {
  296. p = v->port;
  297. vg = nbp_vlan_group(v->port);
  298. masterv = v->brvlan;
  299. }
  300. __vlan_delete_pvid(vg, v->vid);
  301. if (p) {
  302. err = __vlan_vid_del(p->dev, p->br, v);
  303. if (err)
  304. goto out;
  305. } else {
  306. err = br_switchdev_port_vlan_del(v->br->dev, v->vid);
  307. if (err && err != -EOPNOTSUPP)
  308. goto out;
  309. err = 0;
  310. }
  311. if (br_vlan_should_use(v)) {
  312. v->flags &= ~BRIDGE_VLAN_INFO_BRENTRY;
  313. vg->num_vlans--;
  314. }
  315. if (masterv != v) {
  316. vlan_tunnel_info_del(vg, v);
  317. rhashtable_remove_fast(&vg->vlan_hash, &v->vnode,
  318. br_vlan_rht_params);
  319. __vlan_del_list(v);
  320. nbp_vlan_set_vlan_dev_state(p, v->vid);
  321. call_rcu(&v->rcu, nbp_vlan_rcu_free);
  322. }
  323. br_vlan_put_master(masterv);
  324. out:
  325. return err;
  326. }
  327. static void __vlan_group_free(struct net_bridge_vlan_group *vg)
  328. {
  329. WARN_ON(!list_empty(&vg->vlan_list));
  330. rhashtable_destroy(&vg->vlan_hash);
  331. vlan_tunnel_deinit(vg);
  332. kfree(vg);
  333. }
  334. static void __vlan_flush(const struct net_bridge *br,
  335. const struct net_bridge_port *p,
  336. struct net_bridge_vlan_group *vg)
  337. {
  338. struct net_bridge_vlan *vlan, *tmp;
  339. u16 v_start = 0, v_end = 0;
  340. __vlan_delete_pvid(vg, vg->pvid);
  341. list_for_each_entry_safe(vlan, tmp, &vg->vlan_list, vlist) {
  342. /* take care of disjoint ranges */
  343. if (!v_start) {
  344. v_start = vlan->vid;
  345. } else if (vlan->vid - v_end != 1) {
  346. /* found range end, notify and start next one */
  347. br_vlan_notify(br, p, v_start, v_end, RTM_DELVLAN);
  348. v_start = vlan->vid;
  349. }
  350. v_end = vlan->vid;
  351. __vlan_del(vlan);
  352. }
  353. /* notify about the last/whole vlan range */
  354. if (v_start)
  355. br_vlan_notify(br, p, v_start, v_end, RTM_DELVLAN);
  356. }
  357. struct sk_buff *br_handle_vlan(struct net_bridge *br,
  358. const struct net_bridge_port *p,
  359. struct net_bridge_vlan_group *vg,
  360. struct sk_buff *skb)
  361. {
  362. struct br_vlan_stats *stats;
  363. struct net_bridge_vlan *v;
  364. u16 vid;
  365. /* If this packet was not filtered at input, let it pass */
  366. if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
  367. goto out;
  368. /* At this point, we know that the frame was filtered and contains
  369. * a valid vlan id. If the vlan id has untagged flag set,
  370. * send untagged; otherwise, send tagged.
  371. */
  372. br_vlan_get_tag(skb, &vid);
  373. v = br_vlan_find(vg, vid);
  374. /* Vlan entry must be configured at this point. The
  375. * only exception is the bridge is set in promisc mode and the
  376. * packet is destined for the bridge device. In this case
  377. * pass the packet as is.
  378. */
  379. if (!v || !br_vlan_should_use(v)) {
  380. if ((br->dev->flags & IFF_PROMISC) && skb->dev == br->dev) {
  381. goto out;
  382. } else {
  383. kfree_skb(skb);
  384. return NULL;
  385. }
  386. }
  387. if (br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) {
  388. stats = this_cpu_ptr(v->stats);
  389. u64_stats_update_begin(&stats->syncp);
  390. stats->tx_bytes += skb->len;
  391. stats->tx_packets++;
  392. u64_stats_update_end(&stats->syncp);
  393. }
  394. if (v->flags & BRIDGE_VLAN_INFO_UNTAGGED)
  395. __vlan_hwaccel_clear_tag(skb);
  396. if (p && (p->flags & BR_VLAN_TUNNEL) &&
  397. br_handle_egress_vlan_tunnel(skb, v)) {
  398. kfree_skb(skb);
  399. return NULL;
  400. }
  401. out:
  402. return skb;
  403. }
  404. /* Called under RCU */
  405. static bool __allowed_ingress(const struct net_bridge *br,
  406. struct net_bridge_vlan_group *vg,
  407. struct sk_buff *skb, u16 *vid,
  408. u8 *state)
  409. {
  410. struct br_vlan_stats *stats;
  411. struct net_bridge_vlan *v;
  412. bool tagged;
  413. BR_INPUT_SKB_CB(skb)->vlan_filtered = true;
  414. /* If vlan tx offload is disabled on bridge device and frame was
  415. * sent from vlan device on the bridge device, it does not have
  416. * HW accelerated vlan tag.
  417. */
  418. if (unlikely(!skb_vlan_tag_present(skb) &&
  419. skb->protocol == br->vlan_proto)) {
  420. skb = skb_vlan_untag(skb);
  421. if (unlikely(!skb))
  422. return false;
  423. }
  424. if (!br_vlan_get_tag(skb, vid)) {
  425. /* Tagged frame */
  426. if (skb->vlan_proto != br->vlan_proto) {
  427. /* Protocol-mismatch, empty out vlan_tci for new tag */
  428. skb_push(skb, ETH_HLEN);
  429. skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
  430. skb_vlan_tag_get(skb));
  431. if (unlikely(!skb))
  432. return false;
  433. skb_pull(skb, ETH_HLEN);
  434. skb_reset_mac_len(skb);
  435. *vid = 0;
  436. tagged = false;
  437. } else {
  438. tagged = true;
  439. }
  440. } else {
  441. /* Untagged frame */
  442. tagged = false;
  443. }
  444. if (!*vid) {
  445. u16 pvid = br_get_pvid(vg);
  446. /* Frame had a tag with VID 0 or did not have a tag.
  447. * See if pvid is set on this port. That tells us which
  448. * vlan untagged or priority-tagged traffic belongs to.
  449. */
  450. if (!pvid)
  451. goto drop;
  452. /* PVID is set on this port. Any untagged or priority-tagged
  453. * ingress frame is considered to belong to this vlan.
  454. */
  455. *vid = pvid;
  456. if (likely(!tagged))
  457. /* Untagged Frame. */
  458. __vlan_hwaccel_put_tag(skb, br->vlan_proto, pvid);
  459. else
  460. /* Priority-tagged Frame.
  461. * At this point, we know that skb->vlan_tci VID
  462. * field was 0.
  463. * We update only VID field and preserve PCP field.
  464. */
  465. skb->vlan_tci |= pvid;
  466. /* if stats are disabled we can avoid the lookup */
  467. if (!br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) {
  468. if (*state == BR_STATE_FORWARDING) {
  469. *state = br_vlan_get_pvid_state(vg);
  470. if (!br_vlan_state_allowed(*state, true))
  471. goto drop;
  472. }
  473. return true;
  474. }
  475. }
  476. v = br_vlan_find(vg, *vid);
  477. if (!v || !br_vlan_should_use(v))
  478. goto drop;
  479. if (*state == BR_STATE_FORWARDING) {
  480. *state = br_vlan_get_state(v);
  481. if (!br_vlan_state_allowed(*state, true))
  482. goto drop;
  483. }
  484. if (br_opt_get(br, BROPT_VLAN_STATS_ENABLED)) {
  485. stats = this_cpu_ptr(v->stats);
  486. u64_stats_update_begin(&stats->syncp);
  487. stats->rx_bytes += skb->len;
  488. stats->rx_packets++;
  489. u64_stats_update_end(&stats->syncp);
  490. }
  491. return true;
  492. drop:
  493. kfree_skb(skb);
  494. return false;
  495. }
  496. bool br_allowed_ingress(const struct net_bridge *br,
  497. struct net_bridge_vlan_group *vg, struct sk_buff *skb,
  498. u16 *vid, u8 *state)
  499. {
  500. /* If VLAN filtering is disabled on the bridge, all packets are
  501. * permitted.
  502. */
  503. if (!br_opt_get(br, BROPT_VLAN_ENABLED)) {
  504. BR_INPUT_SKB_CB(skb)->vlan_filtered = false;
  505. return true;
  506. }
  507. return __allowed_ingress(br, vg, skb, vid, state);
  508. }
  509. /* Called under RCU. */
  510. bool br_allowed_egress(struct net_bridge_vlan_group *vg,
  511. const struct sk_buff *skb)
  512. {
  513. const struct net_bridge_vlan *v;
  514. u16 vid;
  515. /* If this packet was not filtered at input, let it pass */
  516. if (!BR_INPUT_SKB_CB(skb)->vlan_filtered)
  517. return true;
  518. br_vlan_get_tag(skb, &vid);
  519. v = br_vlan_find(vg, vid);
  520. if (v && br_vlan_should_use(v) &&
  521. br_vlan_state_allowed(br_vlan_get_state(v), false))
  522. return true;
  523. return false;
  524. }
  525. /* Called under RCU */
  526. bool br_should_learn(struct net_bridge_port *p, struct sk_buff *skb, u16 *vid)
  527. {
  528. struct net_bridge_vlan_group *vg;
  529. struct net_bridge *br = p->br;
  530. struct net_bridge_vlan *v;
  531. /* If filtering was disabled at input, let it pass. */
  532. if (!br_opt_get(br, BROPT_VLAN_ENABLED))
  533. return true;
  534. vg = nbp_vlan_group_rcu(p);
  535. if (!vg || !vg->num_vlans)
  536. return false;
  537. if (!br_vlan_get_tag(skb, vid) && skb->vlan_proto != br->vlan_proto)
  538. *vid = 0;
  539. if (!*vid) {
  540. *vid = br_get_pvid(vg);
  541. if (!*vid ||
  542. !br_vlan_state_allowed(br_vlan_get_pvid_state(vg), true))
  543. return false;
  544. return true;
  545. }
  546. v = br_vlan_find(vg, *vid);
  547. if (v && br_vlan_state_allowed(br_vlan_get_state(v), true))
  548. return true;
  549. return false;
  550. }
  551. static int br_vlan_add_existing(struct net_bridge *br,
  552. struct net_bridge_vlan_group *vg,
  553. struct net_bridge_vlan *vlan,
  554. u16 flags, bool *changed,
  555. struct netlink_ext_ack *extack)
  556. {
  557. int err;
  558. err = br_switchdev_port_vlan_add(br->dev, vlan->vid, flags, extack);
  559. if (err && err != -EOPNOTSUPP)
  560. return err;
  561. if (!br_vlan_is_brentry(vlan)) {
  562. /* Trying to change flags of non-existent bridge vlan */
  563. if (!(flags & BRIDGE_VLAN_INFO_BRENTRY)) {
  564. err = -EINVAL;
  565. goto err_flags;
  566. }
  567. /* It was only kept for port vlans, now make it real */
  568. err = br_fdb_insert(br, NULL, br->dev->dev_addr,
  569. vlan->vid);
  570. if (err) {
  571. br_err(br, "failed to insert local address into bridge forwarding table\n");
  572. goto err_fdb_insert;
  573. }
  574. refcount_inc(&vlan->refcnt);
  575. vlan->flags |= BRIDGE_VLAN_INFO_BRENTRY;
  576. vg->num_vlans++;
  577. *changed = true;
  578. }
  579. if (__vlan_add_flags(vlan, flags))
  580. *changed = true;
  581. return 0;
  582. err_fdb_insert:
  583. err_flags:
  584. br_switchdev_port_vlan_del(br->dev, vlan->vid);
  585. return err;
  586. }
  587. /* Must be protected by RTNL.
  588. * Must be called with vid in range from 1 to 4094 inclusive.
  589. * changed must be true only if the vlan was created or updated
  590. */
  591. int br_vlan_add(struct net_bridge *br, u16 vid, u16 flags, bool *changed,
  592. struct netlink_ext_ack *extack)
  593. {
  594. struct net_bridge_vlan_group *vg;
  595. struct net_bridge_vlan *vlan;
  596. int ret;
  597. ASSERT_RTNL();
  598. *changed = false;
  599. vg = br_vlan_group(br);
  600. vlan = br_vlan_find(vg, vid);
  601. if (vlan)
  602. return br_vlan_add_existing(br, vg, vlan, flags, changed,
  603. extack);
  604. vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
  605. if (!vlan)
  606. return -ENOMEM;
  607. vlan->stats = netdev_alloc_pcpu_stats(struct br_vlan_stats);
  608. if (!vlan->stats) {
  609. kfree(vlan);
  610. return -ENOMEM;
  611. }
  612. vlan->vid = vid;
  613. vlan->flags = flags | BRIDGE_VLAN_INFO_MASTER;
  614. vlan->flags &= ~BRIDGE_VLAN_INFO_PVID;
  615. vlan->br = br;
  616. if (flags & BRIDGE_VLAN_INFO_BRENTRY)
  617. refcount_set(&vlan->refcnt, 1);
  618. ret = __vlan_add(vlan, flags, extack);
  619. if (ret) {
  620. free_percpu(vlan->stats);
  621. kfree(vlan);
  622. } else {
  623. *changed = true;
  624. }
  625. return ret;
  626. }
  627. /* Must be protected by RTNL.
  628. * Must be called with vid in range from 1 to 4094 inclusive.
  629. */
  630. int br_vlan_delete(struct net_bridge *br, u16 vid)
  631. {
  632. struct net_bridge_vlan_group *vg;
  633. struct net_bridge_vlan *v;
  634. ASSERT_RTNL();
  635. vg = br_vlan_group(br);
  636. v = br_vlan_find(vg, vid);
  637. if (!v || !br_vlan_is_brentry(v))
  638. return -ENOENT;
  639. br_fdb_find_delete_local(br, NULL, br->dev->dev_addr, vid);
  640. br_fdb_delete_by_port(br, NULL, vid, 0);
  641. vlan_tunnel_info_del(vg, v);
  642. return __vlan_del(v);
  643. }
  644. void br_vlan_flush(struct net_bridge *br)
  645. {
  646. struct net_bridge_vlan_group *vg;
  647. ASSERT_RTNL();
  648. vg = br_vlan_group(br);
  649. __vlan_flush(br, NULL, vg);
  650. RCU_INIT_POINTER(br->vlgrp, NULL);
  651. synchronize_rcu();
  652. __vlan_group_free(vg);
  653. }
  654. struct net_bridge_vlan *br_vlan_find(struct net_bridge_vlan_group *vg, u16 vid)
  655. {
  656. if (!vg)
  657. return NULL;
  658. return br_vlan_lookup(&vg->vlan_hash, vid);
  659. }
  660. /* Must be protected by RTNL. */
  661. static void recalculate_group_addr(struct net_bridge *br)
  662. {
  663. if (br_opt_get(br, BROPT_GROUP_ADDR_SET))
  664. return;
  665. spin_lock_bh(&br->lock);
  666. if (!br_opt_get(br, BROPT_VLAN_ENABLED) ||
  667. br->vlan_proto == htons(ETH_P_8021Q)) {
  668. /* Bridge Group Address */
  669. br->group_addr[5] = 0x00;
  670. } else { /* vlan_enabled && ETH_P_8021AD */
  671. /* Provider Bridge Group Address */
  672. br->group_addr[5] = 0x08;
  673. }
  674. spin_unlock_bh(&br->lock);
  675. }
  676. /* Must be protected by RTNL. */
  677. void br_recalculate_fwd_mask(struct net_bridge *br)
  678. {
  679. if (!br_opt_get(br, BROPT_VLAN_ENABLED) ||
  680. br->vlan_proto == htons(ETH_P_8021Q))
  681. br->group_fwd_mask_required = BR_GROUPFWD_DEFAULT;
  682. else /* vlan_enabled && ETH_P_8021AD */
  683. br->group_fwd_mask_required = BR_GROUPFWD_8021AD &
  684. ~(1u << br->group_addr[5]);
  685. }
  686. int __br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
  687. {
  688. struct switchdev_attr attr = {
  689. .orig_dev = br->dev,
  690. .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
  691. .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
  692. .u.vlan_filtering = val,
  693. };
  694. int err;
  695. if (br_opt_get(br, BROPT_VLAN_ENABLED) == !!val)
  696. return 0;
  697. err = switchdev_port_attr_set(br->dev, &attr);
  698. if (err && err != -EOPNOTSUPP)
  699. return err;
  700. br_opt_toggle(br, BROPT_VLAN_ENABLED, !!val);
  701. br_manage_promisc(br);
  702. recalculate_group_addr(br);
  703. br_recalculate_fwd_mask(br);
  704. return 0;
  705. }
  706. int br_vlan_filter_toggle(struct net_bridge *br, unsigned long val)
  707. {
  708. return __br_vlan_filter_toggle(br, val);
  709. }
  710. bool br_vlan_enabled(const struct net_device *dev)
  711. {
  712. struct net_bridge *br = netdev_priv(dev);
  713. return br_opt_get(br, BROPT_VLAN_ENABLED);
  714. }
  715. EXPORT_SYMBOL_GPL(br_vlan_enabled);
  716. int br_vlan_get_proto(const struct net_device *dev, u16 *p_proto)
  717. {
  718. struct net_bridge *br = netdev_priv(dev);
  719. *p_proto = ntohs(br->vlan_proto);
  720. return 0;
  721. }
  722. EXPORT_SYMBOL_GPL(br_vlan_get_proto);
  723. int __br_vlan_set_proto(struct net_bridge *br, __be16 proto)
  724. {
  725. int err = 0;
  726. struct net_bridge_port *p;
  727. struct net_bridge_vlan *vlan;
  728. struct net_bridge_vlan_group *vg;
  729. __be16 oldproto;
  730. if (br->vlan_proto == proto)
  731. return 0;
  732. /* Add VLANs for the new proto to the device filter. */
  733. list_for_each_entry(p, &br->port_list, list) {
  734. vg = nbp_vlan_group(p);
  735. list_for_each_entry(vlan, &vg->vlan_list, vlist) {
  736. err = vlan_vid_add(p->dev, proto, vlan->vid);
  737. if (err)
  738. goto err_filt;
  739. }
  740. }
  741. oldproto = br->vlan_proto;
  742. br->vlan_proto = proto;
  743. recalculate_group_addr(br);
  744. br_recalculate_fwd_mask(br);
  745. /* Delete VLANs for the old proto from the device filter. */
  746. list_for_each_entry(p, &br->port_list, list) {
  747. vg = nbp_vlan_group(p);
  748. list_for_each_entry(vlan, &vg->vlan_list, vlist)
  749. vlan_vid_del(p->dev, oldproto, vlan->vid);
  750. }
  751. return 0;
  752. err_filt:
  753. list_for_each_entry_continue_reverse(vlan, &vg->vlan_list, vlist)
  754. vlan_vid_del(p->dev, proto, vlan->vid);
  755. list_for_each_entry_continue_reverse(p, &br->port_list, list) {
  756. vg = nbp_vlan_group(p);
  757. list_for_each_entry(vlan, &vg->vlan_list, vlist)
  758. vlan_vid_del(p->dev, proto, vlan->vid);
  759. }
  760. return err;
  761. }
  762. int br_vlan_set_proto(struct net_bridge *br, unsigned long val)
  763. {
  764. if (val != ETH_P_8021Q && val != ETH_P_8021AD)
  765. return -EPROTONOSUPPORT;
  766. return __br_vlan_set_proto(br, htons(val));
  767. }
  768. int br_vlan_set_stats(struct net_bridge *br, unsigned long val)
  769. {
  770. switch (val) {
  771. case 0:
  772. case 1:
  773. br_opt_toggle(br, BROPT_VLAN_STATS_ENABLED, !!val);
  774. break;
  775. default:
  776. return -EINVAL;
  777. }
  778. return 0;
  779. }
  780. int br_vlan_set_stats_per_port(struct net_bridge *br, unsigned long val)
  781. {
  782. struct net_bridge_port *p;
  783. /* allow to change the option if there are no port vlans configured */
  784. list_for_each_entry(p, &br->port_list, list) {
  785. struct net_bridge_vlan_group *vg = nbp_vlan_group(p);
  786. if (vg->num_vlans)
  787. return -EBUSY;
  788. }
  789. switch (val) {
  790. case 0:
  791. case 1:
  792. br_opt_toggle(br, BROPT_VLAN_STATS_PER_PORT, !!val);
  793. break;
  794. default:
  795. return -EINVAL;
  796. }
  797. return 0;
  798. }
  799. static bool vlan_default_pvid(struct net_bridge_vlan_group *vg, u16 vid)
  800. {
  801. struct net_bridge_vlan *v;
  802. if (vid != vg->pvid)
  803. return false;
  804. v = br_vlan_lookup(&vg->vlan_hash, vid);
  805. if (v && br_vlan_should_use(v) &&
  806. (v->flags & BRIDGE_VLAN_INFO_UNTAGGED))
  807. return true;
  808. return false;
  809. }
  810. static void br_vlan_disable_default_pvid(struct net_bridge *br)
  811. {
  812. struct net_bridge_port *p;
  813. u16 pvid = br->default_pvid;
  814. /* Disable default_pvid on all ports where it is still
  815. * configured.
  816. */
  817. if (vlan_default_pvid(br_vlan_group(br), pvid)) {
  818. if (!br_vlan_delete(br, pvid))
  819. br_vlan_notify(br, NULL, pvid, 0, RTM_DELVLAN);
  820. }
  821. list_for_each_entry(p, &br->port_list, list) {
  822. if (vlan_default_pvid(nbp_vlan_group(p), pvid) &&
  823. !nbp_vlan_delete(p, pvid))
  824. br_vlan_notify(br, p, pvid, 0, RTM_DELVLAN);
  825. }
  826. br->default_pvid = 0;
  827. }
  828. int __br_vlan_set_default_pvid(struct net_bridge *br, u16 pvid,
  829. struct netlink_ext_ack *extack)
  830. {
  831. const struct net_bridge_vlan *pvent;
  832. struct net_bridge_vlan_group *vg;
  833. struct net_bridge_port *p;
  834. unsigned long *changed;
  835. bool vlchange;
  836. u16 old_pvid;
  837. int err = 0;
  838. if (!pvid) {
  839. br_vlan_disable_default_pvid(br);
  840. return 0;
  841. }
  842. changed = bitmap_zalloc(BR_MAX_PORTS, GFP_KERNEL);
  843. if (!changed)
  844. return -ENOMEM;
  845. old_pvid = br->default_pvid;
  846. /* Update default_pvid config only if we do not conflict with
  847. * user configuration.
  848. */
  849. vg = br_vlan_group(br);
  850. pvent = br_vlan_find(vg, pvid);
  851. if ((!old_pvid || vlan_default_pvid(vg, old_pvid)) &&
  852. (!pvent || !br_vlan_should_use(pvent))) {
  853. err = br_vlan_add(br, pvid,
  854. BRIDGE_VLAN_INFO_PVID |
  855. BRIDGE_VLAN_INFO_UNTAGGED |
  856. BRIDGE_VLAN_INFO_BRENTRY,
  857. &vlchange, extack);
  858. if (err)
  859. goto out;
  860. if (br_vlan_delete(br, old_pvid))
  861. br_vlan_notify(br, NULL, old_pvid, 0, RTM_DELVLAN);
  862. br_vlan_notify(br, NULL, pvid, 0, RTM_NEWVLAN);
  863. set_bit(0, changed);
  864. }
  865. list_for_each_entry(p, &br->port_list, list) {
  866. /* Update default_pvid config only if we do not conflict with
  867. * user configuration.
  868. */
  869. vg = nbp_vlan_group(p);
  870. if ((old_pvid &&
  871. !vlan_default_pvid(vg, old_pvid)) ||
  872. br_vlan_find(vg, pvid))
  873. continue;
  874. err = nbp_vlan_add(p, pvid,
  875. BRIDGE_VLAN_INFO_PVID |
  876. BRIDGE_VLAN_INFO_UNTAGGED,
  877. &vlchange, extack);
  878. if (err)
  879. goto err_port;
  880. if (nbp_vlan_delete(p, old_pvid))
  881. br_vlan_notify(br, p, old_pvid, 0, RTM_DELVLAN);
  882. br_vlan_notify(p->br, p, pvid, 0, RTM_NEWVLAN);
  883. set_bit(p->port_no, changed);
  884. }
  885. br->default_pvid = pvid;
  886. out:
  887. bitmap_free(changed);
  888. return err;
  889. err_port:
  890. list_for_each_entry_continue_reverse(p, &br->port_list, list) {
  891. if (!test_bit(p->port_no, changed))
  892. continue;
  893. if (old_pvid) {
  894. nbp_vlan_add(p, old_pvid,
  895. BRIDGE_VLAN_INFO_PVID |
  896. BRIDGE_VLAN_INFO_UNTAGGED,
  897. &vlchange, NULL);
  898. br_vlan_notify(p->br, p, old_pvid, 0, RTM_NEWVLAN);
  899. }
  900. nbp_vlan_delete(p, pvid);
  901. br_vlan_notify(br, p, pvid, 0, RTM_DELVLAN);
  902. }
  903. if (test_bit(0, changed)) {
  904. if (old_pvid) {
  905. br_vlan_add(br, old_pvid,
  906. BRIDGE_VLAN_INFO_PVID |
  907. BRIDGE_VLAN_INFO_UNTAGGED |
  908. BRIDGE_VLAN_INFO_BRENTRY,
  909. &vlchange, NULL);
  910. br_vlan_notify(br, NULL, old_pvid, 0, RTM_NEWVLAN);
  911. }
  912. br_vlan_delete(br, pvid);
  913. br_vlan_notify(br, NULL, pvid, 0, RTM_DELVLAN);
  914. }
  915. goto out;
  916. }
  917. int br_vlan_set_default_pvid(struct net_bridge *br, unsigned long val)
  918. {
  919. u16 pvid = val;
  920. int err = 0;
  921. if (val >= VLAN_VID_MASK)
  922. return -EINVAL;
  923. if (pvid == br->default_pvid)
  924. goto out;
  925. /* Only allow default pvid change when filtering is disabled */
  926. if (br_opt_get(br, BROPT_VLAN_ENABLED)) {
  927. pr_info_once("Please disable vlan filtering to change default_pvid\n");
  928. err = -EPERM;
  929. goto out;
  930. }
  931. err = __br_vlan_set_default_pvid(br, pvid, NULL);
  932. out:
  933. return err;
  934. }
  935. int br_vlan_init(struct net_bridge *br)
  936. {
  937. struct net_bridge_vlan_group *vg;
  938. int ret = -ENOMEM;
  939. vg = kzalloc(sizeof(*vg), GFP_KERNEL);
  940. if (!vg)
  941. goto out;
  942. ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
  943. if (ret)
  944. goto err_rhtbl;
  945. ret = vlan_tunnel_init(vg);
  946. if (ret)
  947. goto err_tunnel_init;
  948. INIT_LIST_HEAD(&vg->vlan_list);
  949. br->vlan_proto = htons(ETH_P_8021Q);
  950. br->default_pvid = 1;
  951. rcu_assign_pointer(br->vlgrp, vg);
  952. out:
  953. return ret;
  954. err_tunnel_init:
  955. rhashtable_destroy(&vg->vlan_hash);
  956. err_rhtbl:
  957. kfree(vg);
  958. goto out;
  959. }
  960. int nbp_vlan_init(struct net_bridge_port *p, struct netlink_ext_ack *extack)
  961. {
  962. struct switchdev_attr attr = {
  963. .orig_dev = p->br->dev,
  964. .id = SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING,
  965. .flags = SWITCHDEV_F_SKIP_EOPNOTSUPP,
  966. .u.vlan_filtering = br_opt_get(p->br, BROPT_VLAN_ENABLED),
  967. };
  968. struct net_bridge_vlan_group *vg;
  969. int ret = -ENOMEM;
  970. vg = kzalloc(sizeof(struct net_bridge_vlan_group), GFP_KERNEL);
  971. if (!vg)
  972. goto out;
  973. ret = switchdev_port_attr_set(p->dev, &attr);
  974. if (ret && ret != -EOPNOTSUPP)
  975. goto err_vlan_enabled;
  976. ret = rhashtable_init(&vg->vlan_hash, &br_vlan_rht_params);
  977. if (ret)
  978. goto err_rhtbl;
  979. ret = vlan_tunnel_init(vg);
  980. if (ret)
  981. goto err_tunnel_init;
  982. INIT_LIST_HEAD(&vg->vlan_list);
  983. rcu_assign_pointer(p->vlgrp, vg);
  984. if (p->br->default_pvid) {
  985. bool changed;
  986. ret = nbp_vlan_add(p, p->br->default_pvid,
  987. BRIDGE_VLAN_INFO_PVID |
  988. BRIDGE_VLAN_INFO_UNTAGGED,
  989. &changed, extack);
  990. if (ret)
  991. goto err_vlan_add;
  992. br_vlan_notify(p->br, p, p->br->default_pvid, 0, RTM_NEWVLAN);
  993. }
  994. out:
  995. return ret;
  996. err_vlan_add:
  997. RCU_INIT_POINTER(p->vlgrp, NULL);
  998. synchronize_rcu();
  999. vlan_tunnel_deinit(vg);
  1000. err_tunnel_init:
  1001. rhashtable_destroy(&vg->vlan_hash);
  1002. err_rhtbl:
  1003. err_vlan_enabled:
  1004. kfree(vg);
  1005. goto out;
  1006. }
  1007. /* Must be protected by RTNL.
  1008. * Must be called with vid in range from 1 to 4094 inclusive.
  1009. * changed must be true only if the vlan was created or updated
  1010. */
  1011. int nbp_vlan_add(struct net_bridge_port *port, u16 vid, u16 flags,
  1012. bool *changed, struct netlink_ext_ack *extack)
  1013. {
  1014. struct net_bridge_vlan *vlan;
  1015. int ret;
  1016. ASSERT_RTNL();
  1017. *changed = false;
  1018. vlan = br_vlan_find(nbp_vlan_group(port), vid);
  1019. if (vlan) {
  1020. /* Pass the flags to the hardware bridge */
  1021. ret = br_switchdev_port_vlan_add(port->dev, vid, flags, extack);
  1022. if (ret && ret != -EOPNOTSUPP)
  1023. return ret;
  1024. *changed = __vlan_add_flags(vlan, flags);
  1025. return 0;
  1026. }
  1027. vlan = kzalloc(sizeof(*vlan), GFP_KERNEL);
  1028. if (!vlan)
  1029. return -ENOMEM;
  1030. vlan->vid = vid;
  1031. vlan->port = port;
  1032. ret = __vlan_add(vlan, flags, extack);
  1033. if (ret)
  1034. kfree(vlan);
  1035. else
  1036. *changed = true;
  1037. return ret;
  1038. }
  1039. /* Must be protected by RTNL.
  1040. * Must be called with vid in range from 1 to 4094 inclusive.
  1041. */
  1042. int nbp_vlan_delete(struct net_bridge_port *port, u16 vid)
  1043. {
  1044. struct net_bridge_vlan *v;
  1045. ASSERT_RTNL();
  1046. v = br_vlan_find(nbp_vlan_group(port), vid);
  1047. if (!v)
  1048. return -ENOENT;
  1049. br_fdb_find_delete_local(port->br, port, port->dev->dev_addr, vid);
  1050. br_fdb_delete_by_port(port->br, port, vid, 0);
  1051. return __vlan_del(v);
  1052. }
  1053. void nbp_vlan_flush(struct net_bridge_port *port)
  1054. {
  1055. struct net_bridge_vlan_group *vg;
  1056. ASSERT_RTNL();
  1057. vg = nbp_vlan_group(port);
  1058. __vlan_flush(port->br, port, vg);
  1059. RCU_INIT_POINTER(port->vlgrp, NULL);
  1060. synchronize_rcu();
  1061. __vlan_group_free(vg);
  1062. }
  1063. void br_vlan_get_stats(const struct net_bridge_vlan *v,
  1064. struct br_vlan_stats *stats)
  1065. {
  1066. int i;
  1067. memset(stats, 0, sizeof(*stats));
  1068. for_each_possible_cpu(i) {
  1069. u64 rxpackets, rxbytes, txpackets, txbytes;
  1070. struct br_vlan_stats *cpu_stats;
  1071. unsigned int start;
  1072. cpu_stats = per_cpu_ptr(v->stats, i);
  1073. do {
  1074. start = u64_stats_fetch_begin_irq(&cpu_stats->syncp);
  1075. rxpackets = cpu_stats->rx_packets;
  1076. rxbytes = cpu_stats->rx_bytes;
  1077. txbytes = cpu_stats->tx_bytes;
  1078. txpackets = cpu_stats->tx_packets;
  1079. } while (u64_stats_fetch_retry_irq(&cpu_stats->syncp, start));
  1080. stats->rx_packets += rxpackets;
  1081. stats->rx_bytes += rxbytes;
  1082. stats->tx_bytes += txbytes;
  1083. stats->tx_packets += txpackets;
  1084. }
  1085. }
  1086. int br_vlan_get_pvid(const struct net_device *dev, u16 *p_pvid)
  1087. {
  1088. struct net_bridge_vlan_group *vg;
  1089. struct net_bridge_port *p;
  1090. ASSERT_RTNL();
  1091. p = br_port_get_check_rtnl(dev);
  1092. if (p)
  1093. vg = nbp_vlan_group(p);
  1094. else if (netif_is_bridge_master(dev))
  1095. vg = br_vlan_group(netdev_priv(dev));
  1096. else
  1097. return -EINVAL;
  1098. *p_pvid = br_get_pvid(vg);
  1099. return 0;
  1100. }
  1101. EXPORT_SYMBOL_GPL(br_vlan_get_pvid);
  1102. int br_vlan_get_pvid_rcu(const struct net_device *dev, u16 *p_pvid)
  1103. {
  1104. struct net_bridge_vlan_group *vg;
  1105. struct net_bridge_port *p;
  1106. p = br_port_get_check_rcu(dev);
  1107. if (p)
  1108. vg = nbp_vlan_group_rcu(p);
  1109. else if (netif_is_bridge_master(dev))
  1110. vg = br_vlan_group_rcu(netdev_priv(dev));
  1111. else
  1112. return -EINVAL;
  1113. *p_pvid = br_get_pvid(vg);
  1114. return 0;
  1115. }
  1116. EXPORT_SYMBOL_GPL(br_vlan_get_pvid_rcu);
  1117. int br_vlan_get_info(const struct net_device *dev, u16 vid,
  1118. struct bridge_vlan_info *p_vinfo)
  1119. {
  1120. struct net_bridge_vlan_group *vg;
  1121. struct net_bridge_vlan *v;
  1122. struct net_bridge_port *p;
  1123. ASSERT_RTNL();
  1124. p = br_port_get_check_rtnl(dev);
  1125. if (p)
  1126. vg = nbp_vlan_group(p);
  1127. else if (netif_is_bridge_master(dev))
  1128. vg = br_vlan_group(netdev_priv(dev));
  1129. else
  1130. return -EINVAL;
  1131. v = br_vlan_find(vg, vid);
  1132. if (!v)
  1133. return -ENOENT;
  1134. p_vinfo->vid = vid;
  1135. p_vinfo->flags = v->flags;
  1136. if (vid == br_get_pvid(vg))
  1137. p_vinfo->flags |= BRIDGE_VLAN_INFO_PVID;
  1138. return 0;
  1139. }
  1140. EXPORT_SYMBOL_GPL(br_vlan_get_info);
  1141. static int br_vlan_is_bind_vlan_dev(const struct net_device *dev)
  1142. {
  1143. return is_vlan_dev(dev) &&
  1144. !!(vlan_dev_priv(dev)->flags & VLAN_FLAG_BRIDGE_BINDING);
  1145. }
  1146. static int br_vlan_is_bind_vlan_dev_fn(struct net_device *dev,
  1147. __always_unused struct netdev_nested_priv *priv)
  1148. {
  1149. return br_vlan_is_bind_vlan_dev(dev);
  1150. }
  1151. static bool br_vlan_has_upper_bind_vlan_dev(struct net_device *dev)
  1152. {
  1153. int found;
  1154. rcu_read_lock();
  1155. found = netdev_walk_all_upper_dev_rcu(dev, br_vlan_is_bind_vlan_dev_fn,
  1156. NULL);
  1157. rcu_read_unlock();
  1158. return !!found;
  1159. }
  1160. struct br_vlan_bind_walk_data {
  1161. u16 vid;
  1162. struct net_device *result;
  1163. };
  1164. static int br_vlan_match_bind_vlan_dev_fn(struct net_device *dev,
  1165. struct netdev_nested_priv *priv)
  1166. {
  1167. struct br_vlan_bind_walk_data *data = priv->data;
  1168. int found = 0;
  1169. if (br_vlan_is_bind_vlan_dev(dev) &&
  1170. vlan_dev_priv(dev)->vlan_id == data->vid) {
  1171. data->result = dev;
  1172. found = 1;
  1173. }
  1174. return found;
  1175. }
  1176. static struct net_device *
  1177. br_vlan_get_upper_bind_vlan_dev(struct net_device *dev, u16 vid)
  1178. {
  1179. struct br_vlan_bind_walk_data data = {
  1180. .vid = vid,
  1181. };
  1182. struct netdev_nested_priv priv = {
  1183. .data = (void *)&data,
  1184. };
  1185. rcu_read_lock();
  1186. netdev_walk_all_upper_dev_rcu(dev, br_vlan_match_bind_vlan_dev_fn,
  1187. &priv);
  1188. rcu_read_unlock();
  1189. return data.result;
  1190. }
  1191. static bool br_vlan_is_dev_up(const struct net_device *dev)
  1192. {
  1193. return !!(dev->flags & IFF_UP) && netif_oper_up(dev);
  1194. }
  1195. static void br_vlan_set_vlan_dev_state(const struct net_bridge *br,
  1196. struct net_device *vlan_dev)
  1197. {
  1198. u16 vid = vlan_dev_priv(vlan_dev)->vlan_id;
  1199. struct net_bridge_vlan_group *vg;
  1200. struct net_bridge_port *p;
  1201. bool has_carrier = false;
  1202. if (!netif_carrier_ok(br->dev)) {
  1203. netif_carrier_off(vlan_dev);
  1204. return;
  1205. }
  1206. list_for_each_entry(p, &br->port_list, list) {
  1207. vg = nbp_vlan_group(p);
  1208. if (br_vlan_find(vg, vid) && br_vlan_is_dev_up(p->dev)) {
  1209. has_carrier = true;
  1210. break;
  1211. }
  1212. }
  1213. if (has_carrier)
  1214. netif_carrier_on(vlan_dev);
  1215. else
  1216. netif_carrier_off(vlan_dev);
  1217. }
  1218. static void br_vlan_set_all_vlan_dev_state(struct net_bridge_port *p)
  1219. {
  1220. struct net_bridge_vlan_group *vg = nbp_vlan_group(p);
  1221. struct net_bridge_vlan *vlan;
  1222. struct net_device *vlan_dev;
  1223. list_for_each_entry(vlan, &vg->vlan_list, vlist) {
  1224. vlan_dev = br_vlan_get_upper_bind_vlan_dev(p->br->dev,
  1225. vlan->vid);
  1226. if (vlan_dev) {
  1227. if (br_vlan_is_dev_up(p->dev)) {
  1228. if (netif_carrier_ok(p->br->dev))
  1229. netif_carrier_on(vlan_dev);
  1230. } else {
  1231. br_vlan_set_vlan_dev_state(p->br, vlan_dev);
  1232. }
  1233. }
  1234. }
  1235. }
  1236. static void br_vlan_upper_change(struct net_device *dev,
  1237. struct net_device *upper_dev,
  1238. bool linking)
  1239. {
  1240. struct net_bridge *br = netdev_priv(dev);
  1241. if (!br_vlan_is_bind_vlan_dev(upper_dev))
  1242. return;
  1243. if (linking) {
  1244. br_vlan_set_vlan_dev_state(br, upper_dev);
  1245. br_opt_toggle(br, BROPT_VLAN_BRIDGE_BINDING, true);
  1246. } else {
  1247. br_opt_toggle(br, BROPT_VLAN_BRIDGE_BINDING,
  1248. br_vlan_has_upper_bind_vlan_dev(dev));
  1249. }
  1250. }
  1251. struct br_vlan_link_state_walk_data {
  1252. struct net_bridge *br;
  1253. };
  1254. static int br_vlan_link_state_change_fn(struct net_device *vlan_dev,
  1255. struct netdev_nested_priv *priv)
  1256. {
  1257. struct br_vlan_link_state_walk_data *data = priv->data;
  1258. if (br_vlan_is_bind_vlan_dev(vlan_dev))
  1259. br_vlan_set_vlan_dev_state(data->br, vlan_dev);
  1260. return 0;
  1261. }
  1262. static void br_vlan_link_state_change(struct net_device *dev,
  1263. struct net_bridge *br)
  1264. {
  1265. struct br_vlan_link_state_walk_data data = {
  1266. .br = br
  1267. };
  1268. struct netdev_nested_priv priv = {
  1269. .data = (void *)&data,
  1270. };
  1271. rcu_read_lock();
  1272. netdev_walk_all_upper_dev_rcu(dev, br_vlan_link_state_change_fn,
  1273. &priv);
  1274. rcu_read_unlock();
  1275. }
  1276. /* Must be protected by RTNL. */
  1277. static void nbp_vlan_set_vlan_dev_state(struct net_bridge_port *p, u16 vid)
  1278. {
  1279. struct net_device *vlan_dev;
  1280. if (!br_opt_get(p->br, BROPT_VLAN_BRIDGE_BINDING))
  1281. return;
  1282. vlan_dev = br_vlan_get_upper_bind_vlan_dev(p->br->dev, vid);
  1283. if (vlan_dev)
  1284. br_vlan_set_vlan_dev_state(p->br, vlan_dev);
  1285. }
  1286. /* Must be protected by RTNL. */
  1287. int br_vlan_bridge_event(struct net_device *dev, unsigned long event, void *ptr)
  1288. {
  1289. struct netdev_notifier_changeupper_info *info;
  1290. struct net_bridge *br = netdev_priv(dev);
  1291. int vlcmd = 0, ret = 0;
  1292. bool changed = false;
  1293. switch (event) {
  1294. case NETDEV_REGISTER:
  1295. ret = br_vlan_add(br, br->default_pvid,
  1296. BRIDGE_VLAN_INFO_PVID |
  1297. BRIDGE_VLAN_INFO_UNTAGGED |
  1298. BRIDGE_VLAN_INFO_BRENTRY, &changed, NULL);
  1299. vlcmd = RTM_NEWVLAN;
  1300. break;
  1301. case NETDEV_UNREGISTER:
  1302. changed = !br_vlan_delete(br, br->default_pvid);
  1303. vlcmd = RTM_DELVLAN;
  1304. break;
  1305. case NETDEV_CHANGEUPPER:
  1306. info = ptr;
  1307. br_vlan_upper_change(dev, info->upper_dev, info->linking);
  1308. break;
  1309. case NETDEV_CHANGE:
  1310. case NETDEV_UP:
  1311. if (!br_opt_get(br, BROPT_VLAN_BRIDGE_BINDING))
  1312. break;
  1313. br_vlan_link_state_change(dev, br);
  1314. break;
  1315. }
  1316. if (changed)
  1317. br_vlan_notify(br, NULL, br->default_pvid, 0, vlcmd);
  1318. return ret;
  1319. }
  1320. /* Must be protected by RTNL. */
  1321. void br_vlan_port_event(struct net_bridge_port *p, unsigned long event)
  1322. {
  1323. if (!br_opt_get(p->br, BROPT_VLAN_BRIDGE_BINDING))
  1324. return;
  1325. switch (event) {
  1326. case NETDEV_CHANGE:
  1327. case NETDEV_DOWN:
  1328. case NETDEV_UP:
  1329. br_vlan_set_all_vlan_dev_state(p);
  1330. break;
  1331. }
  1332. }
  1333. static bool br_vlan_stats_fill(struct sk_buff *skb,
  1334. const struct net_bridge_vlan *v)
  1335. {
  1336. struct br_vlan_stats stats;
  1337. struct nlattr *nest;
  1338. nest = nla_nest_start(skb, BRIDGE_VLANDB_ENTRY_STATS);
  1339. if (!nest)
  1340. return false;
  1341. br_vlan_get_stats(v, &stats);
  1342. if (nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_RX_BYTES, stats.rx_bytes,
  1343. BRIDGE_VLANDB_STATS_PAD) ||
  1344. nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_RX_PACKETS,
  1345. stats.rx_packets, BRIDGE_VLANDB_STATS_PAD) ||
  1346. nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_TX_BYTES, stats.tx_bytes,
  1347. BRIDGE_VLANDB_STATS_PAD) ||
  1348. nla_put_u64_64bit(skb, BRIDGE_VLANDB_STATS_TX_PACKETS,
  1349. stats.tx_packets, BRIDGE_VLANDB_STATS_PAD))
  1350. goto out_err;
  1351. nla_nest_end(skb, nest);
  1352. return true;
  1353. out_err:
  1354. nla_nest_cancel(skb, nest);
  1355. return false;
  1356. }
  1357. /* v_opts is used to dump the options which must be equal in the whole range */
  1358. static bool br_vlan_fill_vids(struct sk_buff *skb, u16 vid, u16 vid_range,
  1359. const struct net_bridge_vlan *v_opts,
  1360. u16 flags,
  1361. bool dump_stats)
  1362. {
  1363. struct bridge_vlan_info info;
  1364. struct nlattr *nest;
  1365. nest = nla_nest_start(skb, BRIDGE_VLANDB_ENTRY);
  1366. if (!nest)
  1367. return false;
  1368. memset(&info, 0, sizeof(info));
  1369. info.vid = vid;
  1370. if (flags & BRIDGE_VLAN_INFO_UNTAGGED)
  1371. info.flags |= BRIDGE_VLAN_INFO_UNTAGGED;
  1372. if (flags & BRIDGE_VLAN_INFO_PVID)
  1373. info.flags |= BRIDGE_VLAN_INFO_PVID;
  1374. if (nla_put(skb, BRIDGE_VLANDB_ENTRY_INFO, sizeof(info), &info))
  1375. goto out_err;
  1376. if (vid_range && vid < vid_range &&
  1377. !(flags & BRIDGE_VLAN_INFO_PVID) &&
  1378. nla_put_u16(skb, BRIDGE_VLANDB_ENTRY_RANGE, vid_range))
  1379. goto out_err;
  1380. if (v_opts) {
  1381. if (!br_vlan_opts_fill(skb, v_opts))
  1382. goto out_err;
  1383. if (dump_stats && !br_vlan_stats_fill(skb, v_opts))
  1384. goto out_err;
  1385. }
  1386. nla_nest_end(skb, nest);
  1387. return true;
  1388. out_err:
  1389. nla_nest_cancel(skb, nest);
  1390. return false;
  1391. }
  1392. static size_t rtnl_vlan_nlmsg_size(void)
  1393. {
  1394. return NLMSG_ALIGN(sizeof(struct br_vlan_msg))
  1395. + nla_total_size(0) /* BRIDGE_VLANDB_ENTRY */
  1396. + nla_total_size(sizeof(u16)) /* BRIDGE_VLANDB_ENTRY_RANGE */
  1397. + nla_total_size(sizeof(struct bridge_vlan_info)) /* BRIDGE_VLANDB_ENTRY_INFO */
  1398. + br_vlan_opts_nl_size(); /* bridge vlan options */
  1399. }
  1400. void br_vlan_notify(const struct net_bridge *br,
  1401. const struct net_bridge_port *p,
  1402. u16 vid, u16 vid_range,
  1403. int cmd)
  1404. {
  1405. struct net_bridge_vlan_group *vg;
  1406. struct net_bridge_vlan *v = NULL;
  1407. struct br_vlan_msg *bvm;
  1408. struct nlmsghdr *nlh;
  1409. struct sk_buff *skb;
  1410. int err = -ENOBUFS;
  1411. struct net *net;
  1412. u16 flags = 0;
  1413. int ifindex;
  1414. /* right now notifications are done only with rtnl held */
  1415. ASSERT_RTNL();
  1416. if (p) {
  1417. ifindex = p->dev->ifindex;
  1418. vg = nbp_vlan_group(p);
  1419. net = dev_net(p->dev);
  1420. } else {
  1421. ifindex = br->dev->ifindex;
  1422. vg = br_vlan_group(br);
  1423. net = dev_net(br->dev);
  1424. }
  1425. skb = nlmsg_new(rtnl_vlan_nlmsg_size(), GFP_KERNEL);
  1426. if (!skb)
  1427. goto out_err;
  1428. err = -EMSGSIZE;
  1429. nlh = nlmsg_put(skb, 0, 0, cmd, sizeof(*bvm), 0);
  1430. if (!nlh)
  1431. goto out_err;
  1432. bvm = nlmsg_data(nlh);
  1433. memset(bvm, 0, sizeof(*bvm));
  1434. bvm->family = AF_BRIDGE;
  1435. bvm->ifindex = ifindex;
  1436. switch (cmd) {
  1437. case RTM_NEWVLAN:
  1438. /* need to find the vlan due to flags/options */
  1439. v = br_vlan_find(vg, vid);
  1440. if (!v || !br_vlan_should_use(v))
  1441. goto out_kfree;
  1442. flags = v->flags;
  1443. if (br_get_pvid(vg) == v->vid)
  1444. flags |= BRIDGE_VLAN_INFO_PVID;
  1445. break;
  1446. case RTM_DELVLAN:
  1447. break;
  1448. default:
  1449. goto out_kfree;
  1450. }
  1451. if (!br_vlan_fill_vids(skb, vid, vid_range, v, flags, false))
  1452. goto out_err;
  1453. nlmsg_end(skb, nlh);
  1454. rtnl_notify(skb, net, 0, RTNLGRP_BRVLAN, NULL, GFP_KERNEL);
  1455. return;
  1456. out_err:
  1457. rtnl_set_sk_err(net, RTNLGRP_BRVLAN, err);
  1458. out_kfree:
  1459. kfree_skb(skb);
  1460. }
  1461. /* check if v_curr can enter a range ending in range_end */
  1462. bool br_vlan_can_enter_range(const struct net_bridge_vlan *v_curr,
  1463. const struct net_bridge_vlan *range_end)
  1464. {
  1465. return v_curr->vid - range_end->vid == 1 &&
  1466. range_end->flags == v_curr->flags &&
  1467. br_vlan_opts_eq_range(v_curr, range_end);
  1468. }
  1469. static int br_vlan_dump_dev(const struct net_device *dev,
  1470. struct sk_buff *skb,
  1471. struct netlink_callback *cb,
  1472. u32 dump_flags)
  1473. {
  1474. struct net_bridge_vlan *v, *range_start = NULL, *range_end = NULL;
  1475. bool dump_stats = !!(dump_flags & BRIDGE_VLANDB_DUMPF_STATS);
  1476. struct net_bridge_vlan_group *vg;
  1477. int idx = 0, s_idx = cb->args[1];
  1478. struct nlmsghdr *nlh = NULL;
  1479. struct net_bridge_port *p;
  1480. struct br_vlan_msg *bvm;
  1481. struct net_bridge *br;
  1482. int err = 0;
  1483. u16 pvid;
  1484. if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev))
  1485. return -EINVAL;
  1486. if (netif_is_bridge_master(dev)) {
  1487. br = netdev_priv(dev);
  1488. vg = br_vlan_group_rcu(br);
  1489. p = NULL;
  1490. } else {
  1491. p = br_port_get_rcu(dev);
  1492. if (WARN_ON(!p))
  1493. return -EINVAL;
  1494. vg = nbp_vlan_group_rcu(p);
  1495. br = p->br;
  1496. }
  1497. if (!vg)
  1498. return 0;
  1499. nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq,
  1500. RTM_NEWVLAN, sizeof(*bvm), NLM_F_MULTI);
  1501. if (!nlh)
  1502. return -EMSGSIZE;
  1503. bvm = nlmsg_data(nlh);
  1504. memset(bvm, 0, sizeof(*bvm));
  1505. bvm->family = PF_BRIDGE;
  1506. bvm->ifindex = dev->ifindex;
  1507. pvid = br_get_pvid(vg);
  1508. /* idx must stay at range's beginning until it is filled in */
  1509. list_for_each_entry_rcu(v, &vg->vlan_list, vlist) {
  1510. if (!br_vlan_should_use(v))
  1511. continue;
  1512. if (idx < s_idx) {
  1513. idx++;
  1514. continue;
  1515. }
  1516. if (!range_start) {
  1517. range_start = v;
  1518. range_end = v;
  1519. continue;
  1520. }
  1521. if (dump_stats || v->vid == pvid ||
  1522. !br_vlan_can_enter_range(v, range_end)) {
  1523. u16 vlan_flags = br_vlan_flags(range_start, pvid);
  1524. if (!br_vlan_fill_vids(skb, range_start->vid,
  1525. range_end->vid, range_start,
  1526. vlan_flags, dump_stats)) {
  1527. err = -EMSGSIZE;
  1528. break;
  1529. }
  1530. /* advance number of filled vlans */
  1531. idx += range_end->vid - range_start->vid + 1;
  1532. range_start = v;
  1533. }
  1534. range_end = v;
  1535. }
  1536. /* err will be 0 and range_start will be set in 3 cases here:
  1537. * - first vlan (range_start == range_end)
  1538. * - last vlan (range_start == range_end, not in range)
  1539. * - last vlan range (range_start != range_end, in range)
  1540. */
  1541. if (!err && range_start &&
  1542. !br_vlan_fill_vids(skb, range_start->vid, range_end->vid,
  1543. range_start, br_vlan_flags(range_start, pvid),
  1544. dump_stats))
  1545. err = -EMSGSIZE;
  1546. cb->args[1] = err ? idx : 0;
  1547. nlmsg_end(skb, nlh);
  1548. return err;
  1549. }
  1550. static const struct nla_policy br_vlan_db_dump_pol[BRIDGE_VLANDB_DUMP_MAX + 1] = {
  1551. [BRIDGE_VLANDB_DUMP_FLAGS] = { .type = NLA_U32 },
  1552. };
  1553. static int br_vlan_rtm_dump(struct sk_buff *skb, struct netlink_callback *cb)
  1554. {
  1555. struct nlattr *dtb[BRIDGE_VLANDB_DUMP_MAX + 1];
  1556. int idx = 0, err = 0, s_idx = cb->args[0];
  1557. struct net *net = sock_net(skb->sk);
  1558. struct br_vlan_msg *bvm;
  1559. struct net_device *dev;
  1560. u32 dump_flags = 0;
  1561. err = nlmsg_parse(cb->nlh, sizeof(*bvm), dtb, BRIDGE_VLANDB_DUMP_MAX,
  1562. br_vlan_db_dump_pol, cb->extack);
  1563. if (err < 0)
  1564. return err;
  1565. bvm = nlmsg_data(cb->nlh);
  1566. if (dtb[BRIDGE_VLANDB_DUMP_FLAGS])
  1567. dump_flags = nla_get_u32(dtb[BRIDGE_VLANDB_DUMP_FLAGS]);
  1568. rcu_read_lock();
  1569. if (bvm->ifindex) {
  1570. dev = dev_get_by_index_rcu(net, bvm->ifindex);
  1571. if (!dev) {
  1572. err = -ENODEV;
  1573. goto out_err;
  1574. }
  1575. err = br_vlan_dump_dev(dev, skb, cb, dump_flags);
  1576. /* if the dump completed without an error we return 0 here */
  1577. if (err != -EMSGSIZE)
  1578. goto out_err;
  1579. } else {
  1580. for_each_netdev_rcu(net, dev) {
  1581. if (idx < s_idx)
  1582. goto skip;
  1583. err = br_vlan_dump_dev(dev, skb, cb, dump_flags);
  1584. if (err == -EMSGSIZE)
  1585. break;
  1586. skip:
  1587. idx++;
  1588. }
  1589. }
  1590. cb->args[0] = idx;
  1591. rcu_read_unlock();
  1592. return skb->len;
  1593. out_err:
  1594. rcu_read_unlock();
  1595. return err;
  1596. }
  1597. static const struct nla_policy br_vlan_db_policy[BRIDGE_VLANDB_ENTRY_MAX + 1] = {
  1598. [BRIDGE_VLANDB_ENTRY_INFO] =
  1599. NLA_POLICY_EXACT_LEN(sizeof(struct bridge_vlan_info)),
  1600. [BRIDGE_VLANDB_ENTRY_RANGE] = { .type = NLA_U16 },
  1601. [BRIDGE_VLANDB_ENTRY_STATE] = { .type = NLA_U8 },
  1602. [BRIDGE_VLANDB_ENTRY_TUNNEL_INFO] = { .type = NLA_NESTED },
  1603. };
  1604. static int br_vlan_rtm_process_one(struct net_device *dev,
  1605. const struct nlattr *attr,
  1606. int cmd, struct netlink_ext_ack *extack)
  1607. {
  1608. struct bridge_vlan_info *vinfo, vrange_end, *vinfo_last = NULL;
  1609. struct nlattr *tb[BRIDGE_VLANDB_ENTRY_MAX + 1];
  1610. bool changed = false, skip_processing = false;
  1611. struct net_bridge_vlan_group *vg;
  1612. struct net_bridge_port *p = NULL;
  1613. int err = 0, cmdmap = 0;
  1614. struct net_bridge *br;
  1615. if (netif_is_bridge_master(dev)) {
  1616. br = netdev_priv(dev);
  1617. vg = br_vlan_group(br);
  1618. } else {
  1619. p = br_port_get_rtnl(dev);
  1620. if (WARN_ON(!p))
  1621. return -ENODEV;
  1622. br = p->br;
  1623. vg = nbp_vlan_group(p);
  1624. }
  1625. if (WARN_ON(!vg))
  1626. return -ENODEV;
  1627. err = nla_parse_nested(tb, BRIDGE_VLANDB_ENTRY_MAX, attr,
  1628. br_vlan_db_policy, extack);
  1629. if (err)
  1630. return err;
  1631. if (!tb[BRIDGE_VLANDB_ENTRY_INFO]) {
  1632. NL_SET_ERR_MSG_MOD(extack, "Missing vlan entry info");
  1633. return -EINVAL;
  1634. }
  1635. memset(&vrange_end, 0, sizeof(vrange_end));
  1636. vinfo = nla_data(tb[BRIDGE_VLANDB_ENTRY_INFO]);
  1637. if (vinfo->flags & (BRIDGE_VLAN_INFO_RANGE_BEGIN |
  1638. BRIDGE_VLAN_INFO_RANGE_END)) {
  1639. NL_SET_ERR_MSG_MOD(extack, "Old-style vlan ranges are not allowed when using RTM vlan calls");
  1640. return -EINVAL;
  1641. }
  1642. if (!br_vlan_valid_id(vinfo->vid, extack))
  1643. return -EINVAL;
  1644. if (tb[BRIDGE_VLANDB_ENTRY_RANGE]) {
  1645. vrange_end.vid = nla_get_u16(tb[BRIDGE_VLANDB_ENTRY_RANGE]);
  1646. /* validate user-provided flags without RANGE_BEGIN */
  1647. vrange_end.flags = BRIDGE_VLAN_INFO_RANGE_END | vinfo->flags;
  1648. vinfo->flags |= BRIDGE_VLAN_INFO_RANGE_BEGIN;
  1649. /* vinfo_last is the range start, vinfo the range end */
  1650. vinfo_last = vinfo;
  1651. vinfo = &vrange_end;
  1652. if (!br_vlan_valid_id(vinfo->vid, extack) ||
  1653. !br_vlan_valid_range(vinfo, vinfo_last, extack))
  1654. return -EINVAL;
  1655. }
  1656. switch (cmd) {
  1657. case RTM_NEWVLAN:
  1658. cmdmap = RTM_SETLINK;
  1659. skip_processing = !!(vinfo->flags & BRIDGE_VLAN_INFO_ONLY_OPTS);
  1660. break;
  1661. case RTM_DELVLAN:
  1662. cmdmap = RTM_DELLINK;
  1663. break;
  1664. }
  1665. if (!skip_processing) {
  1666. struct bridge_vlan_info *tmp_last = vinfo_last;
  1667. /* br_process_vlan_info may overwrite vinfo_last */
  1668. err = br_process_vlan_info(br, p, cmdmap, vinfo, &tmp_last,
  1669. &changed, extack);
  1670. /* notify first if anything changed */
  1671. if (changed)
  1672. br_ifinfo_notify(cmdmap, br, p);
  1673. if (err)
  1674. return err;
  1675. }
  1676. /* deal with options */
  1677. if (cmd == RTM_NEWVLAN) {
  1678. struct net_bridge_vlan *range_start, *range_end;
  1679. if (vinfo_last) {
  1680. range_start = br_vlan_find(vg, vinfo_last->vid);
  1681. range_end = br_vlan_find(vg, vinfo->vid);
  1682. } else {
  1683. range_start = br_vlan_find(vg, vinfo->vid);
  1684. range_end = range_start;
  1685. }
  1686. err = br_vlan_process_options(br, p, range_start, range_end,
  1687. tb, extack);
  1688. }
  1689. return err;
  1690. }
  1691. static int br_vlan_rtm_process(struct sk_buff *skb, struct nlmsghdr *nlh,
  1692. struct netlink_ext_ack *extack)
  1693. {
  1694. struct net *net = sock_net(skb->sk);
  1695. struct br_vlan_msg *bvm;
  1696. struct net_device *dev;
  1697. struct nlattr *attr;
  1698. int err, vlans = 0;
  1699. int rem;
  1700. /* this should validate the header and check for remaining bytes */
  1701. err = nlmsg_parse(nlh, sizeof(*bvm), NULL, BRIDGE_VLANDB_MAX, NULL,
  1702. extack);
  1703. if (err < 0)
  1704. return err;
  1705. bvm = nlmsg_data(nlh);
  1706. dev = __dev_get_by_index(net, bvm->ifindex);
  1707. if (!dev)
  1708. return -ENODEV;
  1709. if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
  1710. NL_SET_ERR_MSG_MOD(extack, "The device is not a valid bridge or bridge port");
  1711. return -EINVAL;
  1712. }
  1713. nlmsg_for_each_attr(attr, nlh, sizeof(*bvm), rem) {
  1714. if (nla_type(attr) != BRIDGE_VLANDB_ENTRY)
  1715. continue;
  1716. vlans++;
  1717. err = br_vlan_rtm_process_one(dev, attr, nlh->nlmsg_type,
  1718. extack);
  1719. if (err)
  1720. break;
  1721. }
  1722. if (!vlans) {
  1723. NL_SET_ERR_MSG_MOD(extack, "No vlans found to process");
  1724. err = -EINVAL;
  1725. }
  1726. return err;
  1727. }
  1728. void br_vlan_rtnl_init(void)
  1729. {
  1730. rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_GETVLAN, NULL,
  1731. br_vlan_rtm_dump, 0);
  1732. rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_NEWVLAN,
  1733. br_vlan_rtm_process, NULL, 0);
  1734. rtnl_register_module(THIS_MODULE, PF_BRIDGE, RTM_DELVLAN,
  1735. br_vlan_rtm_process, NULL, 0);
  1736. }
  1737. void br_vlan_rtnl_uninit(void)
  1738. {
  1739. rtnl_unregister(PF_BRIDGE, RTM_GETVLAN);
  1740. rtnl_unregister(PF_BRIDGE, RTM_NEWVLAN);
  1741. rtnl_unregister(PF_BRIDGE, RTM_DELVLAN);
  1742. }