1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2018-2021, Intel Corporation. */ 3 4 /* Link Aggregation code */ 5 6 #include "ice.h" 7 #include "ice_lag.h" 8 9 /** 10 * ice_lag_nop_handler - no-op Rx handler to disable LAG 11 * @pskb: pointer to skb pointer 12 */ 13 rx_handler_result_t ice_lag_nop_handler(struct sk_buff __always_unused **pskb) 14 { 15 return RX_HANDLER_PASS; 16 } 17 18 /** 19 * ice_lag_set_primary - set PF LAG state as Primary 20 * @lag: LAG info struct 21 */ 22 static void ice_lag_set_primary(struct ice_lag *lag) 23 { 24 struct ice_pf *pf = lag->pf; 25 26 if (!pf) 27 return; 28 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)); 32 return; 33 } 34 35 lag->role = ICE_LAG_PRIMARY; 36 } 37 38 /** 39 * ice_lag_set_backup - set PF LAG state to Backup 40 * @lag: LAG info struct 41 */ 42 static void ice_lag_set_backup(struct ice_lag *lag) 43 { 44 struct ice_pf *pf = lag->pf; 45 46 if (!pf) 47 return; 48 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)); 52 return; 53 } 54 55 lag->role = ICE_LAG_BACKUP; 56 } 57 58 /** 59 * ice_display_lag_info - print LAG info 60 * @lag: LAG info struct 61 */ 62 static void ice_display_lag_info(struct ice_lag *lag) 63 { 64 const char *name, *peer, *upper, *role, *bonded, *master; 65 struct device *dev = &lag->pf->pdev->dev; 66 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"; 72 73 switch (lag->role) { 74 case ICE_LAG_NONE: 75 role = "NONE"; 76 break; 77 case ICE_LAG_PRIMARY: 78 role = "PRIMARY"; 79 break; 80 case ICE_LAG_BACKUP: 81 role = "BACKUP"; 82 break; 83 case ICE_LAG_UNSET: 84 role = "UNSET"; 85 break; 86 default: 87 role = "ERROR"; 88 } 89 90 dev_dbg(dev, "%s %s, peer:%s, upper:%s, role:%s, master:%s\n", name, 91 bonded, peer, upper, role, master); 92 } 93 94 /** 95 * ice_lag_info_event - handle NETDEV_BONDING_INFO event 96 * @lag: LAG info struct 97 * @ptr: opaque data pointer 98 * 99 * ptr is to be cast to (netdev_notifier_bonding_info *) 100 */ 101 static void ice_lag_info_event(struct ice_lag *lag, void *ptr) 102 { 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; 107 108 event_netdev = netdev_notifier_info_to_dev(ptr); 109 info = ptr; 110 lag_netdev_name = netdev_name(lag->netdev); 111 bonding_info = &info->bonding_info; 112 113 if (event_netdev != lag->netdev || !lag->bonded || !lag->upper_netdev) 114 return; 115 116 if (bonding_info->master.bond_mode != BOND_MODE_ACTIVEBACKUP) { 117 netdev_dbg(lag->netdev, "Bonding event recv, but mode not active/backup\n"); 118 goto lag_out; 119 } 120 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"); 123 goto lag_out; 124 } 125 126 if (bonding_info->slave.state) 127 ice_lag_set_backup(lag); 128 else 129 ice_lag_set_primary(lag); 130 131 lag_out: 132 ice_display_lag_info(lag); 133 } 134 135 /** 136 * ice_lag_link - handle LAG link event 137 * @lag: LAG info struct 138 * @info: info from the netdev notifier 139 */ 140 static void 141 ice_lag_link(struct ice_lag *lag, struct netdev_notifier_changeupper_info *info) 142 { 143 struct net_device *netdev_tmp, *upper = info->upper_dev; 144 struct ice_pf *pf = lag->pf; 145 int peers = 0; 146 147 if (lag->bonded) 148 dev_warn(ice_pf_to_dev(pf), "%s Already part of a bond\n", 149 netdev_name(lag->netdev)); 150 151 rcu_read_lock(); 152 for_each_netdev_in_bond_rcu(upper, netdev_tmp) 153 peers++; 154 rcu_read_unlock(); 155 156 if (lag->upper_netdev != upper) { 157 dev_hold(upper); 158 lag->upper_netdev = upper; 159 } 160 161 ice_clear_sriov_cap(pf); 162 ice_clear_rdma_cap(pf); 163 164 lag->bonded = true; 165 lag->role = ICE_LAG_UNSET; 166 167 /* if this is the first element in an LAG mark as master */ 168 lag->master = !!(peers == 1); 169 } 170 171 /** 172 * ice_lag_unlink - handle unlink event 173 * @lag: LAG info struct 174 * @info: info from netdev notification 175 */ 176 static void 177 ice_lag_unlink(struct ice_lag *lag, 178 struct netdev_notifier_changeupper_info *info) 179 { 180 struct net_device *netdev_tmp, *upper = info->upper_dev; 181 struct ice_pf *pf = lag->pf; 182 bool found = false; 183 184 if (!lag->bonded) { 185 netdev_dbg(lag->netdev, "bonding unlink event on non-LAG netdev\n"); 186 return; 187 } 188 189 /* determine if we are in the new LAG config or not */ 190 rcu_read_lock(); 191 for_each_netdev_in_bond_rcu(upper, netdev_tmp) { 192 if (netdev_tmp == lag->netdev) { 193 found = true; 194 break; 195 } 196 } 197 rcu_read_unlock(); 198 199 if (found) 200 return; 201 202 if (lag->upper_netdev) { 203 dev_put(lag->upper_netdev); 204 lag->upper_netdev = NULL; 205 } 206 207 lag->peer_netdev = NULL; 208 ice_set_sriov_cap(pf); 209 ice_set_rdma_cap(pf); 210 lag->bonded = false; 211 lag->role = ICE_LAG_NONE; 212 } 213 214 /** 215 * ice_lag_unregister - handle netdev unregister events 216 * @lag: LAG info struct 217 * @netdev: netdev reporting the event 218 */ 219 static void ice_lag_unregister(struct ice_lag *lag, struct net_device *netdev) 220 { 221 struct ice_pf *pf = lag->pf; 222 223 /* check to see if this event is for this netdev 224 * check that we are in an aggregate 225 */ 226 if (netdev != lag->netdev || !lag->bonded) 227 return; 228 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); 234 } 235 /* perform some cleanup in case we come back */ 236 lag->bonded = false; 237 lag->role = ICE_LAG_NONE; 238 } 239 240 /** 241 * ice_lag_changeupper_event - handle LAG changeupper event 242 * @lag: LAG info struct 243 * @ptr: opaque pointer data 244 * 245 * ptr is to be cast into netdev_notifier_changeupper_info 246 */ 247 static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr) 248 { 249 struct netdev_notifier_changeupper_info *info; 250 struct net_device *netdev; 251 252 info = ptr; 253 netdev = netdev_notifier_info_to_dev(ptr); 254 255 /* not for this netdev */ 256 if (netdev != lag->netdev) 257 return; 258 259 if (!info->upper_dev) { 260 netdev_dbg(netdev, "changeupper rcvd, but no upper defined\n"); 261 return; 262 } 263 264 netdev_dbg(netdev, "bonding %s\n", info->linking ? "LINK" : "UNLINK"); 265 266 if (!netif_is_lag_master(info->upper_dev)) { 267 netdev_dbg(netdev, "changeupper rcvd, but not master. bail\n"); 268 return; 269 } 270 271 if (info->linking) 272 ice_lag_link(lag, info); 273 else 274 ice_lag_unlink(lag, info); 275 276 ice_display_lag_info(lag); 277 } 278 279 /** 280 * ice_lag_changelower_event - handle LAG changelower event 281 * @lag: LAG info struct 282 * @ptr: opaque data pointer 283 * 284 * ptr to be cast to netdev_notifier_changelowerstate_info 285 */ 286 static void ice_lag_changelower_event(struct ice_lag *lag, void *ptr) 287 { 288 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 289 290 if (netdev != lag->netdev) 291 return; 292 293 netdev_dbg(netdev, "bonding info\n"); 294 295 if (!netif_is_lag_port(netdev)) 296 netdev_dbg(netdev, "CHANGELOWER rcvd, but netdev not in LAG. Bail\n"); 297 } 298 299 /** 300 * ice_lag_event_handler - handle LAG events from netdev 301 * @notif_blk: notifier block registered by this netdev 302 * @event: event type 303 * @ptr: opaque data containing notifier event 304 */ 305 static int 306 ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, 307 void *ptr) 308 { 309 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 310 struct ice_lag *lag; 311 312 lag = container_of(notif_blk, struct ice_lag, notif_block); 313 314 if (!lag->netdev) 315 return NOTIFY_DONE; 316 317 /* Check that the netdev is in the working namespace */ 318 if (!net_eq(dev_net(netdev), &init_net)) 319 return NOTIFY_DONE; 320 321 switch (event) { 322 case NETDEV_CHANGEUPPER: 323 ice_lag_changeupper_event(lag, ptr); 324 break; 325 case NETDEV_CHANGELOWERSTATE: 326 ice_lag_changelower_event(lag, ptr); 327 break; 328 case NETDEV_BONDING_INFO: 329 ice_lag_info_event(lag, ptr); 330 break; 331 case NETDEV_UNREGISTER: 332 ice_lag_unregister(lag, netdev); 333 break; 334 default: 335 break; 336 } 337 338 return NOTIFY_DONE; 339 } 340 341 /** 342 * ice_register_lag_handler - register LAG handler on netdev 343 * @lag: LAG struct 344 */ 345 static int ice_register_lag_handler(struct ice_lag *lag) 346 { 347 struct device *dev = ice_pf_to_dev(lag->pf); 348 struct notifier_block *notif_blk; 349 350 notif_blk = &lag->notif_block; 351 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"); 357 return -EINVAL; 358 } 359 dev_dbg(dev, "LAG event handler registered\n"); 360 } 361 return 0; 362 } 363 364 /** 365 * ice_unregister_lag_handler - unregister LAG handler on netdev 366 * @lag: LAG struct 367 */ 368 static void ice_unregister_lag_handler(struct ice_lag *lag) 369 { 370 struct device *dev = ice_pf_to_dev(lag->pf); 371 struct notifier_block *notif_blk; 372 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"); 377 } 378 } 379 380 /** 381 * ice_init_lag - initialize support for LAG 382 * @pf: PF struct 383 * 384 * Alloc memory for LAG structs and initialize the elements. 385 * Memory will be freed in ice_deinit_lag 386 */ 387 int ice_init_lag(struct ice_pf *pf) 388 { 389 struct device *dev = ice_pf_to_dev(pf); 390 struct ice_lag *lag; 391 struct ice_vsi *vsi; 392 int err; 393 394 pf->lag = kzalloc(sizeof(*lag), GFP_KERNEL); 395 if (!pf->lag) 396 return -ENOMEM; 397 lag = pf->lag; 398 399 vsi = ice_get_main_vsi(pf); 400 if (!vsi) { 401 dev_err(dev, "couldn't get main vsi, link aggregation init fail\n"); 402 err = -EIO; 403 goto lag_error; 404 } 405 406 lag->pf = pf; 407 lag->netdev = vsi->netdev; 408 lag->role = ICE_LAG_NONE; 409 lag->bonded = false; 410 lag->peer_netdev = NULL; 411 lag->upper_netdev = NULL; 412 lag->notif_block.notifier_call = NULL; 413 414 err = ice_register_lag_handler(lag); 415 if (err) { 416 dev_warn(dev, "INIT LAG: Failed to register event handler\n"); 417 goto lag_error; 418 } 419 420 ice_display_lag_info(lag); 421 422 dev_dbg(dev, "INIT LAG complete\n"); 423 return 0; 424 425 lag_error: 426 kfree(lag); 427 pf->lag = NULL; 428 return err; 429 } 430 431 /** 432 * ice_deinit_lag - Clean up LAG 433 * @pf: PF struct 434 * 435 * Clean up kernel LAG info and free memory 436 * This function is meant to only be called on driver remove/shutdown 437 */ 438 void ice_deinit_lag(struct ice_pf *pf) 439 { 440 struct ice_lag *lag; 441 442 lag = pf->lag; 443 444 if (!lag) 445 return; 446 447 if (lag->pf) 448 ice_unregister_lag_handler(lag); 449 450 if (lag->upper_netdev) 451 dev_put(lag->upper_netdev); 452 453 if (lag->peer_netdev) 454 dev_put(lag->peer_netdev); 455 456 kfree(lag); 457 458 pf->lag = NULL; 459 } 460