br_sysfs_br.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Sysfs attributes of bridge
  4. * Linux ethernet bridge
  5. *
  6. * Authors:
  7. * Stephen Hemminger <shemminger@osdl.org>
  8. */
  9. #include <linux/capability.h>
  10. #include <linux/kernel.h>
  11. #include <linux/netdevice.h>
  12. #include <linux/etherdevice.h>
  13. #include <linux/if_bridge.h>
  14. #include <linux/rtnetlink.h>
  15. #include <linux/spinlock.h>
  16. #include <linux/times.h>
  17. #include <linux/sched/signal.h>
  18. #include "br_private.h"
  19. #define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd)))
  20. /*
  21. * Common code for storing bridge parameters.
  22. */
  23. static ssize_t store_bridge_parm(struct device *d,
  24. const char *buf, size_t len,
  25. int (*set)(struct net_bridge *, unsigned long))
  26. {
  27. struct net_bridge *br = to_bridge(d);
  28. char *endp;
  29. unsigned long val;
  30. int err;
  31. if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
  32. return -EPERM;
  33. val = simple_strtoul(buf, &endp, 0);
  34. if (endp == buf)
  35. return -EINVAL;
  36. if (!rtnl_trylock())
  37. return restart_syscall();
  38. err = (*set)(br, val);
  39. if (!err)
  40. netdev_state_change(br->dev);
  41. rtnl_unlock();
  42. return err ? err : len;
  43. }
  44. static ssize_t forward_delay_show(struct device *d,
  45. struct device_attribute *attr, char *buf)
  46. {
  47. struct net_bridge *br = to_bridge(d);
  48. return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay));
  49. }
  50. static ssize_t forward_delay_store(struct device *d,
  51. struct device_attribute *attr,
  52. const char *buf, size_t len)
  53. {
  54. return store_bridge_parm(d, buf, len, br_set_forward_delay);
  55. }
  56. static DEVICE_ATTR_RW(forward_delay);
  57. static ssize_t hello_time_show(struct device *d, struct device_attribute *attr,
  58. char *buf)
  59. {
  60. return sprintf(buf, "%lu\n",
  61. jiffies_to_clock_t(to_bridge(d)->hello_time));
  62. }
  63. static ssize_t hello_time_store(struct device *d,
  64. struct device_attribute *attr, const char *buf,
  65. size_t len)
  66. {
  67. return store_bridge_parm(d, buf, len, br_set_hello_time);
  68. }
  69. static DEVICE_ATTR_RW(hello_time);
  70. static ssize_t max_age_show(struct device *d, struct device_attribute *attr,
  71. char *buf)
  72. {
  73. return sprintf(buf, "%lu\n",
  74. jiffies_to_clock_t(to_bridge(d)->max_age));
  75. }
  76. static ssize_t max_age_store(struct device *d, struct device_attribute *attr,
  77. const char *buf, size_t len)
  78. {
  79. return store_bridge_parm(d, buf, len, br_set_max_age);
  80. }
  81. static DEVICE_ATTR_RW(max_age);
  82. static ssize_t ageing_time_show(struct device *d,
  83. struct device_attribute *attr, char *buf)
  84. {
  85. struct net_bridge *br = to_bridge(d);
  86. return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time));
  87. }
  88. static int set_ageing_time(struct net_bridge *br, unsigned long val)
  89. {
  90. return br_set_ageing_time(br, val);
  91. }
  92. static ssize_t ageing_time_store(struct device *d,
  93. struct device_attribute *attr,
  94. const char *buf, size_t len)
  95. {
  96. return store_bridge_parm(d, buf, len, set_ageing_time);
  97. }
  98. static DEVICE_ATTR_RW(ageing_time);
  99. static ssize_t stp_state_show(struct device *d,
  100. struct device_attribute *attr, char *buf)
  101. {
  102. struct net_bridge *br = to_bridge(d);
  103. return sprintf(buf, "%d\n", br->stp_enabled);
  104. }
  105. static int set_stp_state(struct net_bridge *br, unsigned long val)
  106. {
  107. return br_stp_set_enabled(br, val, NULL);
  108. }
  109. static ssize_t stp_state_store(struct device *d,
  110. struct device_attribute *attr, const char *buf,
  111. size_t len)
  112. {
  113. return store_bridge_parm(d, buf, len, set_stp_state);
  114. }
  115. static DEVICE_ATTR_RW(stp_state);
  116. static ssize_t group_fwd_mask_show(struct device *d,
  117. struct device_attribute *attr,
  118. char *buf)
  119. {
  120. struct net_bridge *br = to_bridge(d);
  121. return sprintf(buf, "%#x\n", br->group_fwd_mask);
  122. }
  123. static int set_group_fwd_mask(struct net_bridge *br, unsigned long val)
  124. {
  125. if (val & BR_GROUPFWD_RESTRICTED)
  126. return -EINVAL;
  127. br->group_fwd_mask = val;
  128. return 0;
  129. }
  130. static ssize_t group_fwd_mask_store(struct device *d,
  131. struct device_attribute *attr,
  132. const char *buf,
  133. size_t len)
  134. {
  135. return store_bridge_parm(d, buf, len, set_group_fwd_mask);
  136. }
  137. static DEVICE_ATTR_RW(group_fwd_mask);
  138. static ssize_t priority_show(struct device *d, struct device_attribute *attr,
  139. char *buf)
  140. {
  141. struct net_bridge *br = to_bridge(d);
  142. return sprintf(buf, "%d\n",
  143. (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]);
  144. }
  145. static int set_priority(struct net_bridge *br, unsigned long val)
  146. {
  147. br_stp_set_bridge_priority(br, (u16) val);
  148. return 0;
  149. }
  150. static ssize_t priority_store(struct device *d, struct device_attribute *attr,
  151. const char *buf, size_t len)
  152. {
  153. return store_bridge_parm(d, buf, len, set_priority);
  154. }
  155. static DEVICE_ATTR_RW(priority);
  156. static ssize_t root_id_show(struct device *d, struct device_attribute *attr,
  157. char *buf)
  158. {
  159. return br_show_bridge_id(buf, &to_bridge(d)->designated_root);
  160. }
  161. static DEVICE_ATTR_RO(root_id);
  162. static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr,
  163. char *buf)
  164. {
  165. return br_show_bridge_id(buf, &to_bridge(d)->bridge_id);
  166. }
  167. static DEVICE_ATTR_RO(bridge_id);
  168. static ssize_t root_port_show(struct device *d, struct device_attribute *attr,
  169. char *buf)
  170. {
  171. return sprintf(buf, "%d\n", to_bridge(d)->root_port);
  172. }
  173. static DEVICE_ATTR_RO(root_port);
  174. static ssize_t root_path_cost_show(struct device *d,
  175. struct device_attribute *attr, char *buf)
  176. {
  177. return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost);
  178. }
  179. static DEVICE_ATTR_RO(root_path_cost);
  180. static ssize_t topology_change_show(struct device *d,
  181. struct device_attribute *attr, char *buf)
  182. {
  183. return sprintf(buf, "%d\n", to_bridge(d)->topology_change);
  184. }
  185. static DEVICE_ATTR_RO(topology_change);
  186. static ssize_t topology_change_detected_show(struct device *d,
  187. struct device_attribute *attr,
  188. char *buf)
  189. {
  190. struct net_bridge *br = to_bridge(d);
  191. return sprintf(buf, "%d\n", br->topology_change_detected);
  192. }
  193. static DEVICE_ATTR_RO(topology_change_detected);
  194. static ssize_t hello_timer_show(struct device *d,
  195. struct device_attribute *attr, char *buf)
  196. {
  197. struct net_bridge *br = to_bridge(d);
  198. return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer));
  199. }
  200. static DEVICE_ATTR_RO(hello_timer);
  201. static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr,
  202. char *buf)
  203. {
  204. struct net_bridge *br = to_bridge(d);
  205. return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer));
  206. }
  207. static DEVICE_ATTR_RO(tcn_timer);
  208. static ssize_t topology_change_timer_show(struct device *d,
  209. struct device_attribute *attr,
  210. char *buf)
  211. {
  212. struct net_bridge *br = to_bridge(d);
  213. return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer));
  214. }
  215. static DEVICE_ATTR_RO(topology_change_timer);
  216. static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr,
  217. char *buf)
  218. {
  219. struct net_bridge *br = to_bridge(d);
  220. return sprintf(buf, "%ld\n", br_timer_value(&br->gc_work.timer));
  221. }
  222. static DEVICE_ATTR_RO(gc_timer);
  223. static ssize_t group_addr_show(struct device *d,
  224. struct device_attribute *attr, char *buf)
  225. {
  226. struct net_bridge *br = to_bridge(d);
  227. return sprintf(buf, "%pM\n", br->group_addr);
  228. }
  229. static ssize_t group_addr_store(struct device *d,
  230. struct device_attribute *attr,
  231. const char *buf, size_t len)
  232. {
  233. struct net_bridge *br = to_bridge(d);
  234. u8 new_addr[6];
  235. if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN))
  236. return -EPERM;
  237. if (!mac_pton(buf, new_addr))
  238. return -EINVAL;
  239. if (!is_link_local_ether_addr(new_addr))
  240. return -EINVAL;
  241. if (new_addr[5] == 1 || /* 802.3x Pause address */
  242. new_addr[5] == 2 || /* 802.3ad Slow protocols */
  243. new_addr[5] == 3) /* 802.1X PAE address */
  244. return -EINVAL;
  245. if (!rtnl_trylock())
  246. return restart_syscall();
  247. spin_lock_bh(&br->lock);
  248. ether_addr_copy(br->group_addr, new_addr);
  249. spin_unlock_bh(&br->lock);
  250. br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true);
  251. br_recalculate_fwd_mask(br);
  252. netdev_state_change(br->dev);
  253. rtnl_unlock();
  254. return len;
  255. }
  256. static DEVICE_ATTR_RW(group_addr);
  257. static int set_flush(struct net_bridge *br, unsigned long val)
  258. {
  259. br_fdb_flush(br);
  260. return 0;
  261. }
  262. static ssize_t flush_store(struct device *d,
  263. struct device_attribute *attr,
  264. const char *buf, size_t len)
  265. {
  266. return store_bridge_parm(d, buf, len, set_flush);
  267. }
  268. static DEVICE_ATTR_WO(flush);
  269. static ssize_t no_linklocal_learn_show(struct device *d,
  270. struct device_attribute *attr,
  271. char *buf)
  272. {
  273. struct net_bridge *br = to_bridge(d);
  274. return sprintf(buf, "%d\n", br_boolopt_get(br, BR_BOOLOPT_NO_LL_LEARN));
  275. }
  276. static int set_no_linklocal_learn(struct net_bridge *br, unsigned long val)
  277. {
  278. return br_boolopt_toggle(br, BR_BOOLOPT_NO_LL_LEARN, !!val, NULL);
  279. }
  280. static ssize_t no_linklocal_learn_store(struct device *d,
  281. struct device_attribute *attr,
  282. const char *buf, size_t len)
  283. {
  284. return store_bridge_parm(d, buf, len, set_no_linklocal_learn);
  285. }
  286. static DEVICE_ATTR_RW(no_linklocal_learn);
  287. #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
  288. static ssize_t multicast_router_show(struct device *d,
  289. struct device_attribute *attr, char *buf)
  290. {
  291. struct net_bridge *br = to_bridge(d);
  292. return sprintf(buf, "%d\n", br->multicast_router);
  293. }
  294. static ssize_t multicast_router_store(struct device *d,
  295. struct device_attribute *attr,
  296. const char *buf, size_t len)
  297. {
  298. return store_bridge_parm(d, buf, len, br_multicast_set_router);
  299. }
  300. static DEVICE_ATTR_RW(multicast_router);
  301. static ssize_t multicast_snooping_show(struct device *d,
  302. struct device_attribute *attr,
  303. char *buf)
  304. {
  305. struct net_bridge *br = to_bridge(d);
  306. return sprintf(buf, "%d\n", br_opt_get(br, BROPT_MULTICAST_ENABLED));
  307. }
  308. static ssize_t multicast_snooping_store(struct device *d,
  309. struct device_attribute *attr,
  310. const char *buf, size_t len)
  311. {
  312. return store_bridge_parm(d, buf, len, br_multicast_toggle);
  313. }
  314. static DEVICE_ATTR_RW(multicast_snooping);
  315. static ssize_t multicast_query_use_ifaddr_show(struct device *d,
  316. struct device_attribute *attr,
  317. char *buf)
  318. {
  319. struct net_bridge *br = to_bridge(d);
  320. return sprintf(buf, "%d\n",
  321. br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR));
  322. }
  323. static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val)
  324. {
  325. br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val);
  326. return 0;
  327. }
  328. static ssize_t
  329. multicast_query_use_ifaddr_store(struct device *d,
  330. struct device_attribute *attr,
  331. const char *buf, size_t len)
  332. {
  333. return store_bridge_parm(d, buf, len, set_query_use_ifaddr);
  334. }
  335. static DEVICE_ATTR_RW(multicast_query_use_ifaddr);
  336. static ssize_t multicast_querier_show(struct device *d,
  337. struct device_attribute *attr,
  338. char *buf)
  339. {
  340. struct net_bridge *br = to_bridge(d);
  341. return sprintf(buf, "%d\n", br_opt_get(br, BROPT_MULTICAST_QUERIER));
  342. }
  343. static ssize_t multicast_querier_store(struct device *d,
  344. struct device_attribute *attr,
  345. const char *buf, size_t len)
  346. {
  347. return store_bridge_parm(d, buf, len, br_multicast_set_querier);
  348. }
  349. static DEVICE_ATTR_RW(multicast_querier);
  350. static ssize_t hash_elasticity_show(struct device *d,
  351. struct device_attribute *attr, char *buf)
  352. {
  353. return sprintf(buf, "%u\n", RHT_ELASTICITY);
  354. }
  355. static int set_elasticity(struct net_bridge *br, unsigned long val)
  356. {
  357. br_warn(br, "the hash_elasticity option has been deprecated and is always %u\n",
  358. RHT_ELASTICITY);
  359. return 0;
  360. }
  361. static ssize_t hash_elasticity_store(struct device *d,
  362. struct device_attribute *attr,
  363. const char *buf, size_t len)
  364. {
  365. return store_bridge_parm(d, buf, len, set_elasticity);
  366. }
  367. static DEVICE_ATTR_RW(hash_elasticity);
  368. static ssize_t hash_max_show(struct device *d, struct device_attribute *attr,
  369. char *buf)
  370. {
  371. struct net_bridge *br = to_bridge(d);
  372. return sprintf(buf, "%u\n", br->hash_max);
  373. }
  374. static int set_hash_max(struct net_bridge *br, unsigned long val)
  375. {
  376. br->hash_max = val;
  377. return 0;
  378. }
  379. static ssize_t hash_max_store(struct device *d, struct device_attribute *attr,
  380. const char *buf, size_t len)
  381. {
  382. return store_bridge_parm(d, buf, len, set_hash_max);
  383. }
  384. static DEVICE_ATTR_RW(hash_max);
  385. static ssize_t multicast_igmp_version_show(struct device *d,
  386. struct device_attribute *attr,
  387. char *buf)
  388. {
  389. struct net_bridge *br = to_bridge(d);
  390. return sprintf(buf, "%u\n", br->multicast_igmp_version);
  391. }
  392. static ssize_t multicast_igmp_version_store(struct device *d,
  393. struct device_attribute *attr,
  394. const char *buf, size_t len)
  395. {
  396. return store_bridge_parm(d, buf, len, br_multicast_set_igmp_version);
  397. }
  398. static DEVICE_ATTR_RW(multicast_igmp_version);
  399. static ssize_t multicast_last_member_count_show(struct device *d,
  400. struct device_attribute *attr,
  401. char *buf)
  402. {
  403. struct net_bridge *br = to_bridge(d);
  404. return sprintf(buf, "%u\n", br->multicast_last_member_count);
  405. }
  406. static int set_last_member_count(struct net_bridge *br, unsigned long val)
  407. {
  408. br->multicast_last_member_count = val;
  409. return 0;
  410. }
  411. static ssize_t multicast_last_member_count_store(struct device *d,
  412. struct device_attribute *attr,
  413. const char *buf, size_t len)
  414. {
  415. return store_bridge_parm(d, buf, len, set_last_member_count);
  416. }
  417. static DEVICE_ATTR_RW(multicast_last_member_count);
  418. static ssize_t multicast_startup_query_count_show(
  419. struct device *d, struct device_attribute *attr, char *buf)
  420. {
  421. struct net_bridge *br = to_bridge(d);
  422. return sprintf(buf, "%u\n", br->multicast_startup_query_count);
  423. }
  424. static int set_startup_query_count(struct net_bridge *br, unsigned long val)
  425. {
  426. br->multicast_startup_query_count = val;
  427. return 0;
  428. }
  429. static ssize_t multicast_startup_query_count_store(
  430. struct device *d, struct device_attribute *attr, const char *buf,
  431. size_t len)
  432. {
  433. return store_bridge_parm(d, buf, len, set_startup_query_count);
  434. }
  435. static DEVICE_ATTR_RW(multicast_startup_query_count);
  436. static ssize_t multicast_last_member_interval_show(
  437. struct device *d, struct device_attribute *attr, char *buf)
  438. {
  439. struct net_bridge *br = to_bridge(d);
  440. return sprintf(buf, "%lu\n",
  441. jiffies_to_clock_t(br->multicast_last_member_interval));
  442. }
  443. static int set_last_member_interval(struct net_bridge *br, unsigned long val)
  444. {
  445. br->multicast_last_member_interval = clock_t_to_jiffies(val);
  446. return 0;
  447. }
  448. static ssize_t multicast_last_member_interval_store(
  449. struct device *d, struct device_attribute *attr, const char *buf,
  450. size_t len)
  451. {
  452. return store_bridge_parm(d, buf, len, set_last_member_interval);
  453. }
  454. static DEVICE_ATTR_RW(multicast_last_member_interval);
  455. static ssize_t multicast_membership_interval_show(
  456. struct device *d, struct device_attribute *attr, char *buf)
  457. {
  458. struct net_bridge *br = to_bridge(d);
  459. return sprintf(buf, "%lu\n",
  460. jiffies_to_clock_t(br->multicast_membership_interval));
  461. }
  462. static int set_membership_interval(struct net_bridge *br, unsigned long val)
  463. {
  464. br->multicast_membership_interval = clock_t_to_jiffies(val);
  465. return 0;
  466. }
  467. static ssize_t multicast_membership_interval_store(
  468. struct device *d, struct device_attribute *attr, const char *buf,
  469. size_t len)
  470. {
  471. return store_bridge_parm(d, buf, len, set_membership_interval);
  472. }
  473. static DEVICE_ATTR_RW(multicast_membership_interval);
  474. static ssize_t multicast_querier_interval_show(struct device *d,
  475. struct device_attribute *attr,
  476. char *buf)
  477. {
  478. struct net_bridge *br = to_bridge(d);
  479. return sprintf(buf, "%lu\n",
  480. jiffies_to_clock_t(br->multicast_querier_interval));
  481. }
  482. static int set_querier_interval(struct net_bridge *br, unsigned long val)
  483. {
  484. br->multicast_querier_interval = clock_t_to_jiffies(val);
  485. return 0;
  486. }
  487. static ssize_t multicast_querier_interval_store(struct device *d,
  488. struct device_attribute *attr,
  489. const char *buf, size_t len)
  490. {
  491. return store_bridge_parm(d, buf, len, set_querier_interval);
  492. }
  493. static DEVICE_ATTR_RW(multicast_querier_interval);
  494. static ssize_t multicast_query_interval_show(struct device *d,
  495. struct device_attribute *attr,
  496. char *buf)
  497. {
  498. struct net_bridge *br = to_bridge(d);
  499. return sprintf(buf, "%lu\n",
  500. jiffies_to_clock_t(br->multicast_query_interval));
  501. }
  502. static int set_query_interval(struct net_bridge *br, unsigned long val)
  503. {
  504. br->multicast_query_interval = clock_t_to_jiffies(val);
  505. return 0;
  506. }
  507. static ssize_t multicast_query_interval_store(struct device *d,
  508. struct device_attribute *attr,
  509. const char *buf, size_t len)
  510. {
  511. return store_bridge_parm(d, buf, len, set_query_interval);
  512. }
  513. static DEVICE_ATTR_RW(multicast_query_interval);
  514. static ssize_t multicast_query_response_interval_show(
  515. struct device *d, struct device_attribute *attr, char *buf)
  516. {
  517. struct net_bridge *br = to_bridge(d);
  518. return sprintf(
  519. buf, "%lu\n",
  520. jiffies_to_clock_t(br->multicast_query_response_interval));
  521. }
  522. static int set_query_response_interval(struct net_bridge *br, unsigned long val)
  523. {
  524. br->multicast_query_response_interval = clock_t_to_jiffies(val);
  525. return 0;
  526. }
  527. static ssize_t multicast_query_response_interval_store(
  528. struct device *d, struct device_attribute *attr, const char *buf,
  529. size_t len)
  530. {
  531. return store_bridge_parm(d, buf, len, set_query_response_interval);
  532. }
  533. static DEVICE_ATTR_RW(multicast_query_response_interval);
  534. static ssize_t multicast_startup_query_interval_show(
  535. struct device *d, struct device_attribute *attr, char *buf)
  536. {
  537. struct net_bridge *br = to_bridge(d);
  538. return sprintf(
  539. buf, "%lu\n",
  540. jiffies_to_clock_t(br->multicast_startup_query_interval));
  541. }
  542. static int set_startup_query_interval(struct net_bridge *br, unsigned long val)
  543. {
  544. br->multicast_startup_query_interval = clock_t_to_jiffies(val);
  545. return 0;
  546. }
  547. static ssize_t multicast_startup_query_interval_store(
  548. struct device *d, struct device_attribute *attr, const char *buf,
  549. size_t len)
  550. {
  551. return store_bridge_parm(d, buf, len, set_startup_query_interval);
  552. }
  553. static DEVICE_ATTR_RW(multicast_startup_query_interval);
  554. static ssize_t multicast_stats_enabled_show(struct device *d,
  555. struct device_attribute *attr,
  556. char *buf)
  557. {
  558. struct net_bridge *br = to_bridge(d);
  559. return sprintf(buf, "%d\n",
  560. br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED));
  561. }
  562. static int set_stats_enabled(struct net_bridge *br, unsigned long val)
  563. {
  564. br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!val);
  565. return 0;
  566. }
  567. static ssize_t multicast_stats_enabled_store(struct device *d,
  568. struct device_attribute *attr,
  569. const char *buf,
  570. size_t len)
  571. {
  572. return store_bridge_parm(d, buf, len, set_stats_enabled);
  573. }
  574. static DEVICE_ATTR_RW(multicast_stats_enabled);
  575. #if IS_ENABLED(CONFIG_IPV6)
  576. static ssize_t multicast_mld_version_show(struct device *d,
  577. struct device_attribute *attr,
  578. char *buf)
  579. {
  580. struct net_bridge *br = to_bridge(d);
  581. return sprintf(buf, "%u\n", br->multicast_mld_version);
  582. }
  583. static ssize_t multicast_mld_version_store(struct device *d,
  584. struct device_attribute *attr,
  585. const char *buf, size_t len)
  586. {
  587. return store_bridge_parm(d, buf, len, br_multicast_set_mld_version);
  588. }
  589. static DEVICE_ATTR_RW(multicast_mld_version);
  590. #endif
  591. #endif
  592. #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
  593. static ssize_t nf_call_iptables_show(
  594. struct device *d, struct device_attribute *attr, char *buf)
  595. {
  596. struct net_bridge *br = to_bridge(d);
  597. return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IPTABLES));
  598. }
  599. static int set_nf_call_iptables(struct net_bridge *br, unsigned long val)
  600. {
  601. br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val);
  602. return 0;
  603. }
  604. static ssize_t nf_call_iptables_store(
  605. struct device *d, struct device_attribute *attr, const char *buf,
  606. size_t len)
  607. {
  608. return store_bridge_parm(d, buf, len, set_nf_call_iptables);
  609. }
  610. static DEVICE_ATTR_RW(nf_call_iptables);
  611. static ssize_t nf_call_ip6tables_show(
  612. struct device *d, struct device_attribute *attr, char *buf)
  613. {
  614. struct net_bridge *br = to_bridge(d);
  615. return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IP6TABLES));
  616. }
  617. static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val)
  618. {
  619. br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val);
  620. return 0;
  621. }
  622. static ssize_t nf_call_ip6tables_store(
  623. struct device *d, struct device_attribute *attr, const char *buf,
  624. size_t len)
  625. {
  626. return store_bridge_parm(d, buf, len, set_nf_call_ip6tables);
  627. }
  628. static DEVICE_ATTR_RW(nf_call_ip6tables);
  629. static ssize_t nf_call_arptables_show(
  630. struct device *d, struct device_attribute *attr, char *buf)
  631. {
  632. struct net_bridge *br = to_bridge(d);
  633. return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_ARPTABLES));
  634. }
  635. static int set_nf_call_arptables(struct net_bridge *br, unsigned long val)
  636. {
  637. br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val);
  638. return 0;
  639. }
  640. static ssize_t nf_call_arptables_store(
  641. struct device *d, struct device_attribute *attr, const char *buf,
  642. size_t len)
  643. {
  644. return store_bridge_parm(d, buf, len, set_nf_call_arptables);
  645. }
  646. static DEVICE_ATTR_RW(nf_call_arptables);
  647. #endif
  648. #ifdef CONFIG_BRIDGE_VLAN_FILTERING
  649. static ssize_t vlan_filtering_show(struct device *d,
  650. struct device_attribute *attr,
  651. char *buf)
  652. {
  653. struct net_bridge *br = to_bridge(d);
  654. return sprintf(buf, "%d\n", br_opt_get(br, BROPT_VLAN_ENABLED));
  655. }
  656. static ssize_t vlan_filtering_store(struct device *d,
  657. struct device_attribute *attr,
  658. const char *buf, size_t len)
  659. {
  660. return store_bridge_parm(d, buf, len, br_vlan_filter_toggle);
  661. }
  662. static DEVICE_ATTR_RW(vlan_filtering);
  663. static ssize_t vlan_protocol_show(struct device *d,
  664. struct device_attribute *attr,
  665. char *buf)
  666. {
  667. struct net_bridge *br = to_bridge(d);
  668. return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto));
  669. }
  670. static ssize_t vlan_protocol_store(struct device *d,
  671. struct device_attribute *attr,
  672. const char *buf, size_t len)
  673. {
  674. return store_bridge_parm(d, buf, len, br_vlan_set_proto);
  675. }
  676. static DEVICE_ATTR_RW(vlan_protocol);
  677. static ssize_t default_pvid_show(struct device *d,
  678. struct device_attribute *attr,
  679. char *buf)
  680. {
  681. struct net_bridge *br = to_bridge(d);
  682. return sprintf(buf, "%d\n", br->default_pvid);
  683. }
  684. static ssize_t default_pvid_store(struct device *d,
  685. struct device_attribute *attr,
  686. const char *buf, size_t len)
  687. {
  688. return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid);
  689. }
  690. static DEVICE_ATTR_RW(default_pvid);
  691. static ssize_t vlan_stats_enabled_show(struct device *d,
  692. struct device_attribute *attr,
  693. char *buf)
  694. {
  695. struct net_bridge *br = to_bridge(d);
  696. return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_ENABLED));
  697. }
  698. static ssize_t vlan_stats_enabled_store(struct device *d,
  699. struct device_attribute *attr,
  700. const char *buf, size_t len)
  701. {
  702. return store_bridge_parm(d, buf, len, br_vlan_set_stats);
  703. }
  704. static DEVICE_ATTR_RW(vlan_stats_enabled);
  705. static ssize_t vlan_stats_per_port_show(struct device *d,
  706. struct device_attribute *attr,
  707. char *buf)
  708. {
  709. struct net_bridge *br = to_bridge(d);
  710. return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_PER_PORT));
  711. }
  712. static ssize_t vlan_stats_per_port_store(struct device *d,
  713. struct device_attribute *attr,
  714. const char *buf, size_t len)
  715. {
  716. return store_bridge_parm(d, buf, len, br_vlan_set_stats_per_port);
  717. }
  718. static DEVICE_ATTR_RW(vlan_stats_per_port);
  719. #endif
  720. static struct attribute *bridge_attrs[] = {
  721. &dev_attr_forward_delay.attr,
  722. &dev_attr_hello_time.attr,
  723. &dev_attr_max_age.attr,
  724. &dev_attr_ageing_time.attr,
  725. &dev_attr_stp_state.attr,
  726. &dev_attr_group_fwd_mask.attr,
  727. &dev_attr_priority.attr,
  728. &dev_attr_bridge_id.attr,
  729. &dev_attr_root_id.attr,
  730. &dev_attr_root_path_cost.attr,
  731. &dev_attr_root_port.attr,
  732. &dev_attr_topology_change.attr,
  733. &dev_attr_topology_change_detected.attr,
  734. &dev_attr_hello_timer.attr,
  735. &dev_attr_tcn_timer.attr,
  736. &dev_attr_topology_change_timer.attr,
  737. &dev_attr_gc_timer.attr,
  738. &dev_attr_group_addr.attr,
  739. &dev_attr_flush.attr,
  740. &dev_attr_no_linklocal_learn.attr,
  741. #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
  742. &dev_attr_multicast_router.attr,
  743. &dev_attr_multicast_snooping.attr,
  744. &dev_attr_multicast_querier.attr,
  745. &dev_attr_multicast_query_use_ifaddr.attr,
  746. &dev_attr_hash_elasticity.attr,
  747. &dev_attr_hash_max.attr,
  748. &dev_attr_multicast_last_member_count.attr,
  749. &dev_attr_multicast_startup_query_count.attr,
  750. &dev_attr_multicast_last_member_interval.attr,
  751. &dev_attr_multicast_membership_interval.attr,
  752. &dev_attr_multicast_querier_interval.attr,
  753. &dev_attr_multicast_query_interval.attr,
  754. &dev_attr_multicast_query_response_interval.attr,
  755. &dev_attr_multicast_startup_query_interval.attr,
  756. &dev_attr_multicast_stats_enabled.attr,
  757. &dev_attr_multicast_igmp_version.attr,
  758. #if IS_ENABLED(CONFIG_IPV6)
  759. &dev_attr_multicast_mld_version.attr,
  760. #endif
  761. #endif
  762. #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
  763. &dev_attr_nf_call_iptables.attr,
  764. &dev_attr_nf_call_ip6tables.attr,
  765. &dev_attr_nf_call_arptables.attr,
  766. #endif
  767. #ifdef CONFIG_BRIDGE_VLAN_FILTERING
  768. &dev_attr_vlan_filtering.attr,
  769. &dev_attr_vlan_protocol.attr,
  770. &dev_attr_default_pvid.attr,
  771. &dev_attr_vlan_stats_enabled.attr,
  772. &dev_attr_vlan_stats_per_port.attr,
  773. #endif
  774. NULL
  775. };
  776. static const struct attribute_group bridge_group = {
  777. .name = SYSFS_BRIDGE_ATTR,
  778. .attrs = bridge_attrs,
  779. };
  780. /*
  781. * Export the forwarding information table as a binary file
  782. * The records are struct __fdb_entry.
  783. *
  784. * Returns the number of bytes read.
  785. */
  786. static ssize_t brforward_read(struct file *filp, struct kobject *kobj,
  787. struct bin_attribute *bin_attr,
  788. char *buf, loff_t off, size_t count)
  789. {
  790. struct device *dev = kobj_to_dev(kobj);
  791. struct net_bridge *br = to_bridge(dev);
  792. int n;
  793. /* must read whole records */
  794. if (off % sizeof(struct __fdb_entry) != 0)
  795. return -EINVAL;
  796. n = br_fdb_fillbuf(br, buf,
  797. count / sizeof(struct __fdb_entry),
  798. off / sizeof(struct __fdb_entry));
  799. if (n > 0)
  800. n *= sizeof(struct __fdb_entry);
  801. return n;
  802. }
  803. static struct bin_attribute bridge_forward = {
  804. .attr = { .name = SYSFS_BRIDGE_FDB,
  805. .mode = 0444, },
  806. .read = brforward_read,
  807. };
  808. /*
  809. * Add entries in sysfs onto the existing network class device
  810. * for the bridge.
  811. * Adds a attribute group "bridge" containing tuning parameters.
  812. * Binary attribute containing the forward table
  813. * Sub directory to hold links to interfaces.
  814. *
  815. * Note: the ifobj exists only to be a subdirectory
  816. * to hold links. The ifobj exists in same data structure
  817. * as it's parent the bridge so reference counting works.
  818. */
  819. int br_sysfs_addbr(struct net_device *dev)
  820. {
  821. struct kobject *brobj = &dev->dev.kobj;
  822. struct net_bridge *br = netdev_priv(dev);
  823. int err;
  824. err = sysfs_create_group(brobj, &bridge_group);
  825. if (err) {
  826. pr_info("%s: can't create group %s/%s\n",
  827. __func__, dev->name, bridge_group.name);
  828. goto out1;
  829. }
  830. err = sysfs_create_bin_file(brobj, &bridge_forward);
  831. if (err) {
  832. pr_info("%s: can't create attribute file %s/%s\n",
  833. __func__, dev->name, bridge_forward.attr.name);
  834. goto out2;
  835. }
  836. br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj);
  837. if (!br->ifobj) {
  838. pr_info("%s: can't add kobject (directory) %s/%s\n",
  839. __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR);
  840. err = -ENOMEM;
  841. goto out3;
  842. }
  843. return 0;
  844. out3:
  845. sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward);
  846. out2:
  847. sysfs_remove_group(&dev->dev.kobj, &bridge_group);
  848. out1:
  849. return err;
  850. }
  851. void br_sysfs_delbr(struct net_device *dev)
  852. {
  853. struct kobject *kobj = &dev->dev.kobj;
  854. struct net_bridge *br = netdev_priv(dev);
  855. kobject_put(br->ifobj);
  856. sysfs_remove_bin_file(kobj, &bridge_forward);
  857. sysfs_remove_group(kobj, &bridge_group);
  858. }