switchdev.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * net/switchdev/switchdev.c - Switch device API
  4. * Copyright (c) 2014-2015 Jiri Pirko <jiri@resnulli.us>
  5. * Copyright (c) 2014-2015 Scott Feldman <sfeldma@gmail.com>
  6. */
  7. #include <linux/kernel.h>
  8. #include <linux/types.h>
  9. #include <linux/init.h>
  10. #include <linux/mutex.h>
  11. #include <linux/notifier.h>
  12. #include <linux/netdevice.h>
  13. #include <linux/etherdevice.h>
  14. #include <linux/if_bridge.h>
  15. #include <linux/list.h>
  16. #include <linux/workqueue.h>
  17. #include <linux/if_vlan.h>
  18. #include <linux/rtnetlink.h>
  19. #include <net/switchdev.h>
  20. static LIST_HEAD(deferred);
  21. static DEFINE_SPINLOCK(deferred_lock);
  22. typedef void switchdev_deferred_func_t(struct net_device *dev,
  23. const void *data);
  24. struct switchdev_deferred_item {
  25. struct list_head list;
  26. struct net_device *dev;
  27. switchdev_deferred_func_t *func;
  28. unsigned long data[];
  29. };
  30. static struct switchdev_deferred_item *switchdev_deferred_dequeue(void)
  31. {
  32. struct switchdev_deferred_item *dfitem;
  33. spin_lock_bh(&deferred_lock);
  34. if (list_empty(&deferred)) {
  35. dfitem = NULL;
  36. goto unlock;
  37. }
  38. dfitem = list_first_entry(&deferred,
  39. struct switchdev_deferred_item, list);
  40. list_del(&dfitem->list);
  41. unlock:
  42. spin_unlock_bh(&deferred_lock);
  43. return dfitem;
  44. }
  45. /**
  46. * switchdev_deferred_process - Process ops in deferred queue
  47. *
  48. * Called to flush the ops currently queued in deferred ops queue.
  49. * rtnl_lock must be held.
  50. */
  51. void switchdev_deferred_process(void)
  52. {
  53. struct switchdev_deferred_item *dfitem;
  54. ASSERT_RTNL();
  55. while ((dfitem = switchdev_deferred_dequeue())) {
  56. dfitem->func(dfitem->dev, dfitem->data);
  57. dev_put(dfitem->dev);
  58. kfree(dfitem);
  59. }
  60. }
  61. EXPORT_SYMBOL_GPL(switchdev_deferred_process);
  62. static void switchdev_deferred_process_work(struct work_struct *work)
  63. {
  64. rtnl_lock();
  65. switchdev_deferred_process();
  66. rtnl_unlock();
  67. }
  68. static DECLARE_WORK(deferred_process_work, switchdev_deferred_process_work);
  69. static int switchdev_deferred_enqueue(struct net_device *dev,
  70. const void *data, size_t data_len,
  71. switchdev_deferred_func_t *func)
  72. {
  73. struct switchdev_deferred_item *dfitem;
  74. dfitem = kmalloc(sizeof(*dfitem) + data_len, GFP_ATOMIC);
  75. if (!dfitem)
  76. return -ENOMEM;
  77. dfitem->dev = dev;
  78. dfitem->func = func;
  79. memcpy(dfitem->data, data, data_len);
  80. dev_hold(dev);
  81. spin_lock_bh(&deferred_lock);
  82. list_add_tail(&dfitem->list, &deferred);
  83. spin_unlock_bh(&deferred_lock);
  84. schedule_work(&deferred_process_work);
  85. return 0;
  86. }
  87. static int switchdev_port_attr_notify(enum switchdev_notifier_type nt,
  88. struct net_device *dev,
  89. const struct switchdev_attr *attr,
  90. struct switchdev_trans *trans)
  91. {
  92. int err;
  93. int rc;
  94. struct switchdev_notifier_port_attr_info attr_info = {
  95. .attr = attr,
  96. .trans = trans,
  97. .handled = false,
  98. };
  99. rc = call_switchdev_blocking_notifiers(nt, dev,
  100. &attr_info.info, NULL);
  101. err = notifier_to_errno(rc);
  102. if (err) {
  103. WARN_ON(!attr_info.handled);
  104. return err;
  105. }
  106. if (!attr_info.handled)
  107. return -EOPNOTSUPP;
  108. return 0;
  109. }
  110. static int switchdev_port_attr_set_now(struct net_device *dev,
  111. const struct switchdev_attr *attr)
  112. {
  113. struct switchdev_trans trans;
  114. int err;
  115. /* Phase I: prepare for attr set. Driver/device should fail
  116. * here if there are going to be issues in the commit phase,
  117. * such as lack of resources or support. The driver/device
  118. * should reserve resources needed for the commit phase here,
  119. * but should not commit the attr.
  120. */
  121. trans.ph_prepare = true;
  122. err = switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr,
  123. &trans);
  124. if (err)
  125. return err;
  126. /* Phase II: commit attr set. This cannot fail as a fault
  127. * of driver/device. If it does, it's a bug in the driver/device
  128. * because the driver said everythings was OK in phase I.
  129. */
  130. trans.ph_prepare = false;
  131. err = switchdev_port_attr_notify(SWITCHDEV_PORT_ATTR_SET, dev, attr,
  132. &trans);
  133. WARN(err, "%s: Commit of attribute (id=%d) failed.\n",
  134. dev->name, attr->id);
  135. return err;
  136. }
  137. static void switchdev_port_attr_set_deferred(struct net_device *dev,
  138. const void *data)
  139. {
  140. const struct switchdev_attr *attr = data;
  141. int err;
  142. err = switchdev_port_attr_set_now(dev, attr);
  143. if (err && err != -EOPNOTSUPP)
  144. netdev_err(dev, "failed (err=%d) to set attribute (id=%d)\n",
  145. err, attr->id);
  146. if (attr->complete)
  147. attr->complete(dev, err, attr->complete_priv);
  148. }
  149. static int switchdev_port_attr_set_defer(struct net_device *dev,
  150. const struct switchdev_attr *attr)
  151. {
  152. return switchdev_deferred_enqueue(dev, attr, sizeof(*attr),
  153. switchdev_port_attr_set_deferred);
  154. }
  155. /**
  156. * switchdev_port_attr_set - Set port attribute
  157. *
  158. * @dev: port device
  159. * @attr: attribute to set
  160. *
  161. * Use a 2-phase prepare-commit transaction model to ensure
  162. * system is not left in a partially updated state due to
  163. * failure from driver/device.
  164. *
  165. * rtnl_lock must be held and must not be in atomic section,
  166. * in case SWITCHDEV_F_DEFER flag is not set.
  167. */
  168. int switchdev_port_attr_set(struct net_device *dev,
  169. const struct switchdev_attr *attr)
  170. {
  171. if (attr->flags & SWITCHDEV_F_DEFER)
  172. return switchdev_port_attr_set_defer(dev, attr);
  173. ASSERT_RTNL();
  174. return switchdev_port_attr_set_now(dev, attr);
  175. }
  176. EXPORT_SYMBOL_GPL(switchdev_port_attr_set);
  177. static size_t switchdev_obj_size(const struct switchdev_obj *obj)
  178. {
  179. switch (obj->id) {
  180. case SWITCHDEV_OBJ_ID_PORT_VLAN:
  181. return sizeof(struct switchdev_obj_port_vlan);
  182. case SWITCHDEV_OBJ_ID_PORT_MDB:
  183. return sizeof(struct switchdev_obj_port_mdb);
  184. case SWITCHDEV_OBJ_ID_HOST_MDB:
  185. return sizeof(struct switchdev_obj_port_mdb);
  186. default:
  187. BUG();
  188. }
  189. return 0;
  190. }
  191. static int switchdev_port_obj_notify(enum switchdev_notifier_type nt,
  192. struct net_device *dev,
  193. const struct switchdev_obj *obj,
  194. struct switchdev_trans *trans,
  195. struct netlink_ext_ack *extack)
  196. {
  197. int rc;
  198. int err;
  199. struct switchdev_notifier_port_obj_info obj_info = {
  200. .obj = obj,
  201. .trans = trans,
  202. .handled = false,
  203. };
  204. rc = call_switchdev_blocking_notifiers(nt, dev, &obj_info.info, extack);
  205. err = notifier_to_errno(rc);
  206. if (err) {
  207. WARN_ON(!obj_info.handled);
  208. return err;
  209. }
  210. if (!obj_info.handled)
  211. return -EOPNOTSUPP;
  212. return 0;
  213. }
  214. static int switchdev_port_obj_add_now(struct net_device *dev,
  215. const struct switchdev_obj *obj,
  216. struct netlink_ext_ack *extack)
  217. {
  218. struct switchdev_trans trans;
  219. int err;
  220. ASSERT_RTNL();
  221. /* Phase I: prepare for obj add. Driver/device should fail
  222. * here if there are going to be issues in the commit phase,
  223. * such as lack of resources or support. The driver/device
  224. * should reserve resources needed for the commit phase here,
  225. * but should not commit the obj.
  226. */
  227. trans.ph_prepare = true;
  228. err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD,
  229. dev, obj, &trans, extack);
  230. if (err)
  231. return err;
  232. /* Phase II: commit obj add. This cannot fail as a fault
  233. * of driver/device. If it does, it's a bug in the driver/device
  234. * because the driver said everythings was OK in phase I.
  235. */
  236. trans.ph_prepare = false;
  237. err = switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_ADD,
  238. dev, obj, &trans, extack);
  239. WARN(err, "%s: Commit of object (id=%d) failed.\n", dev->name, obj->id);
  240. return err;
  241. }
  242. static void switchdev_port_obj_add_deferred(struct net_device *dev,
  243. const void *data)
  244. {
  245. const struct switchdev_obj *obj = data;
  246. int err;
  247. err = switchdev_port_obj_add_now(dev, obj, NULL);
  248. if (err && err != -EOPNOTSUPP)
  249. netdev_err(dev, "failed (err=%d) to add object (id=%d)\n",
  250. err, obj->id);
  251. if (obj->complete)
  252. obj->complete(dev, err, obj->complete_priv);
  253. }
  254. static int switchdev_port_obj_add_defer(struct net_device *dev,
  255. const struct switchdev_obj *obj)
  256. {
  257. return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj),
  258. switchdev_port_obj_add_deferred);
  259. }
  260. /**
  261. * switchdev_port_obj_add - Add port object
  262. *
  263. * @dev: port device
  264. * @obj: object to add
  265. * @extack: netlink extended ack
  266. *
  267. * Use a 2-phase prepare-commit transaction model to ensure
  268. * system is not left in a partially updated state due to
  269. * failure from driver/device.
  270. *
  271. * rtnl_lock must be held and must not be in atomic section,
  272. * in case SWITCHDEV_F_DEFER flag is not set.
  273. */
  274. int switchdev_port_obj_add(struct net_device *dev,
  275. const struct switchdev_obj *obj,
  276. struct netlink_ext_ack *extack)
  277. {
  278. if (obj->flags & SWITCHDEV_F_DEFER)
  279. return switchdev_port_obj_add_defer(dev, obj);
  280. ASSERT_RTNL();
  281. return switchdev_port_obj_add_now(dev, obj, extack);
  282. }
  283. EXPORT_SYMBOL_GPL(switchdev_port_obj_add);
  284. static int switchdev_port_obj_del_now(struct net_device *dev,
  285. const struct switchdev_obj *obj)
  286. {
  287. return switchdev_port_obj_notify(SWITCHDEV_PORT_OBJ_DEL,
  288. dev, obj, NULL, NULL);
  289. }
  290. static void switchdev_port_obj_del_deferred(struct net_device *dev,
  291. const void *data)
  292. {
  293. const struct switchdev_obj *obj = data;
  294. int err;
  295. err = switchdev_port_obj_del_now(dev, obj);
  296. if (err && err != -EOPNOTSUPP)
  297. netdev_err(dev, "failed (err=%d) to del object (id=%d)\n",
  298. err, obj->id);
  299. if (obj->complete)
  300. obj->complete(dev, err, obj->complete_priv);
  301. }
  302. static int switchdev_port_obj_del_defer(struct net_device *dev,
  303. const struct switchdev_obj *obj)
  304. {
  305. return switchdev_deferred_enqueue(dev, obj, switchdev_obj_size(obj),
  306. switchdev_port_obj_del_deferred);
  307. }
  308. /**
  309. * switchdev_port_obj_del - Delete port object
  310. *
  311. * @dev: port device
  312. * @obj: object to delete
  313. *
  314. * rtnl_lock must be held and must not be in atomic section,
  315. * in case SWITCHDEV_F_DEFER flag is not set.
  316. */
  317. int switchdev_port_obj_del(struct net_device *dev,
  318. const struct switchdev_obj *obj)
  319. {
  320. if (obj->flags & SWITCHDEV_F_DEFER)
  321. return switchdev_port_obj_del_defer(dev, obj);
  322. ASSERT_RTNL();
  323. return switchdev_port_obj_del_now(dev, obj);
  324. }
  325. EXPORT_SYMBOL_GPL(switchdev_port_obj_del);
  326. static ATOMIC_NOTIFIER_HEAD(switchdev_notif_chain);
  327. static BLOCKING_NOTIFIER_HEAD(switchdev_blocking_notif_chain);
  328. /**
  329. * register_switchdev_notifier - Register notifier
  330. * @nb: notifier_block
  331. *
  332. * Register switch device notifier.
  333. */
  334. int register_switchdev_notifier(struct notifier_block *nb)
  335. {
  336. return atomic_notifier_chain_register(&switchdev_notif_chain, nb);
  337. }
  338. EXPORT_SYMBOL_GPL(register_switchdev_notifier);
  339. /**
  340. * unregister_switchdev_notifier - Unregister notifier
  341. * @nb: notifier_block
  342. *
  343. * Unregister switch device notifier.
  344. */
  345. int unregister_switchdev_notifier(struct notifier_block *nb)
  346. {
  347. return atomic_notifier_chain_unregister(&switchdev_notif_chain, nb);
  348. }
  349. EXPORT_SYMBOL_GPL(unregister_switchdev_notifier);
  350. /**
  351. * call_switchdev_notifiers - Call notifiers
  352. * @val: value passed unmodified to notifier function
  353. * @dev: port device
  354. * @info: notifier information data
  355. * @extack: netlink extended ack
  356. * Call all network notifier blocks.
  357. */
  358. int call_switchdev_notifiers(unsigned long val, struct net_device *dev,
  359. struct switchdev_notifier_info *info,
  360. struct netlink_ext_ack *extack)
  361. {
  362. info->dev = dev;
  363. info->extack = extack;
  364. return atomic_notifier_call_chain(&switchdev_notif_chain, val, info);
  365. }
  366. EXPORT_SYMBOL_GPL(call_switchdev_notifiers);
  367. int register_switchdev_blocking_notifier(struct notifier_block *nb)
  368. {
  369. struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain;
  370. return blocking_notifier_chain_register(chain, nb);
  371. }
  372. EXPORT_SYMBOL_GPL(register_switchdev_blocking_notifier);
  373. int unregister_switchdev_blocking_notifier(struct notifier_block *nb)
  374. {
  375. struct blocking_notifier_head *chain = &switchdev_blocking_notif_chain;
  376. return blocking_notifier_chain_unregister(chain, nb);
  377. }
  378. EXPORT_SYMBOL_GPL(unregister_switchdev_blocking_notifier);
  379. int call_switchdev_blocking_notifiers(unsigned long val, struct net_device *dev,
  380. struct switchdev_notifier_info *info,
  381. struct netlink_ext_ack *extack)
  382. {
  383. info->dev = dev;
  384. info->extack = extack;
  385. return blocking_notifier_call_chain(&switchdev_blocking_notif_chain,
  386. val, info);
  387. }
  388. EXPORT_SYMBOL_GPL(call_switchdev_blocking_notifiers);
  389. static int __switchdev_handle_port_obj_add(struct net_device *dev,
  390. struct switchdev_notifier_port_obj_info *port_obj_info,
  391. bool (*check_cb)(const struct net_device *dev),
  392. int (*add_cb)(struct net_device *dev,
  393. const struct switchdev_obj *obj,
  394. struct switchdev_trans *trans,
  395. struct netlink_ext_ack *extack))
  396. {
  397. struct netlink_ext_ack *extack;
  398. struct net_device *lower_dev;
  399. struct list_head *iter;
  400. int err = -EOPNOTSUPP;
  401. extack = switchdev_notifier_info_to_extack(&port_obj_info->info);
  402. if (check_cb(dev)) {
  403. err = add_cb(dev, port_obj_info->obj, port_obj_info->trans,
  404. extack);
  405. if (err != -EOPNOTSUPP)
  406. port_obj_info->handled = true;
  407. return err;
  408. }
  409. /* Switch ports might be stacked under e.g. a LAG. Ignore the
  410. * unsupported devices, another driver might be able to handle them. But
  411. * propagate to the callers any hard errors.
  412. *
  413. * If the driver does its own bookkeeping of stacked ports, it's not
  414. * necessary to go through this helper.
  415. */
  416. netdev_for_each_lower_dev(dev, lower_dev, iter) {
  417. if (netif_is_bridge_master(lower_dev))
  418. continue;
  419. err = __switchdev_handle_port_obj_add(lower_dev, port_obj_info,
  420. check_cb, add_cb);
  421. if (err && err != -EOPNOTSUPP)
  422. return err;
  423. }
  424. return err;
  425. }
  426. int switchdev_handle_port_obj_add(struct net_device *dev,
  427. struct switchdev_notifier_port_obj_info *port_obj_info,
  428. bool (*check_cb)(const struct net_device *dev),
  429. int (*add_cb)(struct net_device *dev,
  430. const struct switchdev_obj *obj,
  431. struct switchdev_trans *trans,
  432. struct netlink_ext_ack *extack))
  433. {
  434. int err;
  435. err = __switchdev_handle_port_obj_add(dev, port_obj_info, check_cb,
  436. add_cb);
  437. if (err == -EOPNOTSUPP)
  438. err = 0;
  439. return err;
  440. }
  441. EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_add);
  442. static int __switchdev_handle_port_obj_del(struct net_device *dev,
  443. struct switchdev_notifier_port_obj_info *port_obj_info,
  444. bool (*check_cb)(const struct net_device *dev),
  445. int (*del_cb)(struct net_device *dev,
  446. const struct switchdev_obj *obj))
  447. {
  448. struct net_device *lower_dev;
  449. struct list_head *iter;
  450. int err = -EOPNOTSUPP;
  451. if (check_cb(dev)) {
  452. err = del_cb(dev, port_obj_info->obj);
  453. if (err != -EOPNOTSUPP)
  454. port_obj_info->handled = true;
  455. return err;
  456. }
  457. /* Switch ports might be stacked under e.g. a LAG. Ignore the
  458. * unsupported devices, another driver might be able to handle them. But
  459. * propagate to the callers any hard errors.
  460. *
  461. * If the driver does its own bookkeeping of stacked ports, it's not
  462. * necessary to go through this helper.
  463. */
  464. netdev_for_each_lower_dev(dev, lower_dev, iter) {
  465. if (netif_is_bridge_master(lower_dev))
  466. continue;
  467. err = __switchdev_handle_port_obj_del(lower_dev, port_obj_info,
  468. check_cb, del_cb);
  469. if (err && err != -EOPNOTSUPP)
  470. return err;
  471. }
  472. return err;
  473. }
  474. int switchdev_handle_port_obj_del(struct net_device *dev,
  475. struct switchdev_notifier_port_obj_info *port_obj_info,
  476. bool (*check_cb)(const struct net_device *dev),
  477. int (*del_cb)(struct net_device *dev,
  478. const struct switchdev_obj *obj))
  479. {
  480. int err;
  481. err = __switchdev_handle_port_obj_del(dev, port_obj_info, check_cb,
  482. del_cb);
  483. if (err == -EOPNOTSUPP)
  484. err = 0;
  485. return err;
  486. }
  487. EXPORT_SYMBOL_GPL(switchdev_handle_port_obj_del);
  488. static int __switchdev_handle_port_attr_set(struct net_device *dev,
  489. struct switchdev_notifier_port_attr_info *port_attr_info,
  490. bool (*check_cb)(const struct net_device *dev),
  491. int (*set_cb)(struct net_device *dev,
  492. const struct switchdev_attr *attr,
  493. struct switchdev_trans *trans))
  494. {
  495. struct net_device *lower_dev;
  496. struct list_head *iter;
  497. int err = -EOPNOTSUPP;
  498. if (check_cb(dev)) {
  499. err = set_cb(dev, port_attr_info->attr, port_attr_info->trans);
  500. if (err != -EOPNOTSUPP)
  501. port_attr_info->handled = true;
  502. return err;
  503. }
  504. /* Switch ports might be stacked under e.g. a LAG. Ignore the
  505. * unsupported devices, another driver might be able to handle them. But
  506. * propagate to the callers any hard errors.
  507. *
  508. * If the driver does its own bookkeeping of stacked ports, it's not
  509. * necessary to go through this helper.
  510. */
  511. netdev_for_each_lower_dev(dev, lower_dev, iter) {
  512. if (netif_is_bridge_master(lower_dev))
  513. continue;
  514. err = __switchdev_handle_port_attr_set(lower_dev, port_attr_info,
  515. check_cb, set_cb);
  516. if (err && err != -EOPNOTSUPP)
  517. return err;
  518. }
  519. return err;
  520. }
  521. int switchdev_handle_port_attr_set(struct net_device *dev,
  522. struct switchdev_notifier_port_attr_info *port_attr_info,
  523. bool (*check_cb)(const struct net_device *dev),
  524. int (*set_cb)(struct net_device *dev,
  525. const struct switchdev_attr *attr,
  526. struct switchdev_trans *trans))
  527. {
  528. int err;
  529. err = __switchdev_handle_port_attr_set(dev, port_attr_info, check_cb,
  530. set_cb);
  531. if (err == -EOPNOTSUPP)
  532. err = 0;
  533. return err;
  534. }
  535. EXPORT_SYMBOL_GPL(switchdev_handle_port_attr_set);