1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2018-2021, Intel Corporation. */
4 /* Link Aggregation code */
10 * ice_lag_nop_handler - no-op Rx handler to disable LAG
11 * @pskb: pointer to skb pointer
13 rx_handler_result_t ice_lag_nop_handler(struct sk_buff __always_unused **pskb)
15 return RX_HANDLER_PASS;
19 * ice_lag_set_primary - set PF LAG state as Primary
20 * @lag: LAG info struct
22 static void ice_lag_set_primary(struct ice_lag *lag)
24 struct ice_pf *pf = lag->pf;
29 if (lag->role != ICE_LAG_UNSET && lag->role != ICE_LAG_BACKUP) {
30 dev_warn(ice_pf_to_dev(pf), "%s: Attempt to be Primary, but incompatible state.\n",
31 netdev_name(lag->netdev));
35 lag->role = ICE_LAG_PRIMARY;
39 * ice_lag_set_backup - set PF LAG state to Backup
40 * @lag: LAG info struct
42 static void ice_lag_set_backup(struct ice_lag *lag)
44 struct ice_pf *pf = lag->pf;
49 if (lag->role != ICE_LAG_UNSET && lag->role != ICE_LAG_PRIMARY) {
50 dev_dbg(ice_pf_to_dev(pf), "%s: Attempt to be Backup, but incompatible state\n",
51 netdev_name(lag->netdev));
55 lag->role = ICE_LAG_BACKUP;
59 * ice_display_lag_info - print LAG info
60 * @lag: LAG info struct
62 static void ice_display_lag_info(struct ice_lag *lag)
64 const char *name, *peer, *upper, *role, *bonded, *master;
65 struct device *dev = &lag->pf->pdev->dev;
67 name = lag->netdev ? netdev_name(lag->netdev) : "unset";
68 peer = lag->peer_netdev ? netdev_name(lag->peer_netdev) : "unset";
69 upper = lag->upper_netdev ? netdev_name(lag->upper_netdev) : "unset";
70 master = lag->master ? "TRUE" : "FALSE";
71 bonded = lag->bonded ? "BONDED" : "UNBONDED";
90 dev_dbg(dev, "%s %s, peer:%s, upper:%s, role:%s, master:%s\n", name,
91 bonded, peer, upper, role, master);
95 * ice_lag_info_event - handle NETDEV_BONDING_INFO event
96 * @lag: LAG info struct
97 * @ptr: opaque data pointer
99 * ptr is to be cast to (netdev_notifier_bonding_info *)
101 static void ice_lag_info_event(struct ice_lag *lag, void *ptr)
103 struct netdev_notifier_bonding_info *info;
104 struct netdev_bonding_info *bonding_info;
105 struct net_device *event_netdev;
106 const char *lag_netdev_name;
108 event_netdev = netdev_notifier_info_to_dev(ptr);
110 lag_netdev_name = netdev_name(lag->netdev);
111 bonding_info = &info->bonding_info;
113 if (event_netdev != lag->netdev || !lag->bonded || !lag->upper_netdev)
116 if (bonding_info->master.bond_mode != BOND_MODE_ACTIVEBACKUP) {
117 netdev_dbg(lag->netdev, "Bonding event recv, but mode not active/backup\n");
121 if (strcmp(bonding_info->slave.slave_name, lag_netdev_name)) {
122 netdev_dbg(lag->netdev, "Bonding event recv, but slave info not for us\n");
126 if (bonding_info->slave.state)
127 ice_lag_set_backup(lag);
129 ice_lag_set_primary(lag);
132 ice_display_lag_info(lag);
136 * ice_lag_link - handle LAG link event
137 * @lag: LAG info struct
138 * @info: info from the netdev notifier
141 ice_lag_link(struct ice_lag *lag, struct netdev_notifier_changeupper_info *info)
143 struct net_device *netdev_tmp, *upper = info->upper_dev;
144 struct ice_pf *pf = lag->pf;
148 dev_warn(ice_pf_to_dev(pf), "%s Already part of a bond\n",
149 netdev_name(lag->netdev));
152 for_each_netdev_in_bond_rcu(upper, netdev_tmp)
156 if (lag->upper_netdev != upper) {
158 lag->upper_netdev = upper;
161 ice_clear_sriov_cap(pf);
162 ice_clear_rdma_cap(pf);
165 lag->role = ICE_LAG_UNSET;
167 /* if this is the first element in an LAG mark as master */
168 lag->master = !!(peers == 1);
172 * ice_lag_unlink - handle unlink event
173 * @lag: LAG info struct
174 * @info: info from netdev notification
177 ice_lag_unlink(struct ice_lag *lag,
178 struct netdev_notifier_changeupper_info *info)
180 struct net_device *netdev_tmp, *upper = info->upper_dev;
181 struct ice_pf *pf = lag->pf;
185 netdev_dbg(lag->netdev, "bonding unlink event on non-LAG netdev\n");
189 /* determine if we are in the new LAG config or not */
191 for_each_netdev_in_bond_rcu(upper, netdev_tmp) {
192 if (netdev_tmp == lag->netdev) {
202 if (lag->upper_netdev) {
203 dev_put(lag->upper_netdev);
204 lag->upper_netdev = NULL;
207 lag->peer_netdev = NULL;
208 ice_set_sriov_cap(pf);
209 ice_set_rdma_cap(pf);
211 lag->role = ICE_LAG_NONE;
215 * ice_lag_unregister - handle netdev unregister events
216 * @lag: LAG info struct
217 * @netdev: netdev reporting the event
219 static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev)
221 struct ice_pf *pf = lag->pf;
223 /* check to see if this event is for this netdev
224 * check that we are in an aggregate
226 if (netdev != lag->netdev || !lag->bonded)
229 if (lag->upper_netdev) {
230 dev_put(lag->upper_netdev);
231 lag->upper_netdev = NULL;
232 ice_set_sriov_cap(pf);
233 ice_set_rdma_cap(pf);
235 /* perform some cleanup in case we come back */
237 lag->role = ICE_LAG_NONE;
241 * ice_lag_changeupper_event - handle LAG changeupper event
242 * @lag: LAG info struct
243 * @ptr: opaque pointer data
245 * ptr is to be cast into netdev_notifier_changeupper_info
247 static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)
249 struct netdev_notifier_changeupper_info *info;
250 struct net_device *netdev;
253 netdev = netdev_notifier_info_to_dev(ptr);
255 /* not for this netdev */
256 if (netdev != lag->netdev)
259 if (!info->upper_dev) {
260 netdev_dbg(netdev, "changeupper rcvd, but no upper defined\n");
264 netdev_dbg(netdev, "bonding %s\n", info->linking ? "LINK" : "UNLINK");
266 if (!netif_is_lag_master(info->upper_dev)) {
267 netdev_dbg(netdev, "changeupper rcvd, but not master. bail\n");
272 ice_lag_link(lag, info);
274 ice_lag_unlink(lag, info);
276 ice_display_lag_info(lag);
280 * ice_lag_changelower_event - handle LAG changelower event
281 * @lag: LAG info struct
282 * @ptr: opaque data pointer
284 * ptr to be cast to netdev_notifier_changelowerstate_info
286 static void ice_lag_changelower_event(struct ice_lag *lag, void *ptr)
288 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
290 if (netdev != lag->netdev)
293 netdev_dbg(netdev, "bonding info\n");
295 if (!netif_is_lag_port(netdev))
296 netdev_dbg(netdev, "CHANGELOWER rcvd, but netdev not in LAG. Bail\n");
300 * ice_lag_event_handler - handle LAG events from netdev
301 * @notif_blk: notifier block registered by this netdev
303 * @ptr: opaque data containing notifier event
306 ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event,
309 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
312 lag = container_of(notif_blk, struct ice_lag, notif_block);
317 /* Check that the netdev is in the working namespace */
318 if (!net_eq(dev_net(netdev), &init_net))
322 case NETDEV_CHANGEUPPER:
323 ice_lag_changeupper_event(lag, ptr);
325 case NETDEV_CHANGELOWERSTATE:
326 ice_lag_changelower_event(lag, ptr);
328 case NETDEV_BONDING_INFO:
329 ice_lag_info_event(lag, ptr);
331 case NETDEV_UNREGISTER:
332 ice_lag_unregister(lag, netdev);
342 * ice_register_lag_handler - register LAG handler on netdev
345 static int ice_register_lag_handler(struct ice_lag *lag)
347 struct device *dev = ice_pf_to_dev(lag->pf);
348 struct notifier_block *notif_blk;
350 notif_blk = &lag->notif_block;
352 if (!notif_blk->notifier_call) {
353 notif_blk->notifier_call = ice_lag_event_handler;
354 if (register_netdevice_notifier(notif_blk)) {
355 notif_blk->notifier_call = NULL;
356 dev_err(dev, "FAIL register LAG event handler!\n");
359 dev_dbg(dev, "LAG event handler registered\n");
365 * ice_unregister_lag_handler - unregister LAG handler on netdev
368 static void ice_unregister_lag_handler(struct ice_lag *lag)
370 struct device *dev = ice_pf_to_dev(lag->pf);
371 struct notifier_block *notif_blk;
373 notif_blk = &lag->notif_block;
374 if (notif_blk->notifier_call) {
375 unregister_netdevice_notifier(notif_blk);
376 dev_dbg(dev, "LAG event handler unregistered\n");
381 * ice_init_lag - initialize support for LAG
384 * Alloc memory for LAG structs and initialize the elements.
385 * Memory will be freed in ice_deinit_lag
387 int ice_init_lag(struct ice_pf *pf)
389 struct device *dev = ice_pf_to_dev(pf);
394 pf->lag = kzalloc(sizeof(*lag), GFP_KERNEL);
399 vsi = ice_get_main_vsi(pf);
401 dev_err(dev, "couldn't get main vsi, link aggregation init fail\n");
407 lag->netdev = vsi->netdev;
408 lag->role = ICE_LAG_NONE;
410 lag->peer_netdev = NULL;
411 lag->upper_netdev = NULL;
412 lag->notif_block.notifier_call = NULL;
414 err = ice_register_lag_handler(lag);
416 dev_warn(dev, "INIT LAG: Failed to register event handler\n");
420 ice_display_lag_info(lag);
422 dev_dbg(dev, "INIT LAG complete\n");
432 * ice_deinit_lag - Clean up LAG
435 * Clean up kernel LAG info and free memory
436 * This function is meant to only be called on driver remove/shutdown
438 void ice_deinit_lag(struct ice_pf *pf)
448 ice_unregister_lag_handler(lag);
450 dev_put(lag->upper_netdev);
452 dev_put(lag->peer_netdev);