drivers/net/ethernet/intel/ice/ice_lag.c

   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 net_device *event_netdev, *netdev_tmp;
 104         struct netdev_notifier_bonding_info *info;
 105         struct netdev_bonding_info *bonding_info;
 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         rcu_read_lock();
 127         for_each_netdev_in_bond_rcu(lag->upper_netdev, netdev_tmp) {
 128                 if (!netif_is_ice(netdev_tmp))
 129                         continue;
 130
 131                 if (netdev_tmp && netdev_tmp != lag->netdev &&
 132                     lag->peer_netdev != netdev_tmp) {
 133                         dev_hold(netdev_tmp);
 134                         lag->peer_netdev = netdev_tmp;
 135                 }
 136         }
 137         rcu_read_unlock();
 138
 139         if (bonding_info->slave.state)
 140                 ice_lag_set_backup(lag);
 141         else
 142                 ice_lag_set_primary(lag);
 143
 144 lag_out:
 145         ice_display_lag_info(lag);
 146 }
 147
 148 /**
 149  * ice_lag_link - handle LAG link event
 150  * @lag: LAG info struct
 151  * @info: info from the netdev notifier
 152  */
 153 static void
 154 ice_lag_link(struct ice_lag *lag, struct netdev_notifier_changeupper_info *info)
 155 {
 156         struct net_device *netdev_tmp, *upper = info->upper_dev;
 157         struct ice_pf *pf = lag->pf;
 158         int peers = 0;
 159
 160         if (lag->bonded)
 161                 dev_warn(ice_pf_to_dev(pf), "%s Already part of a bond\n",
 162                          netdev_name(lag->netdev));
 163
 164         rcu_read_lock();
 165         for_each_netdev_in_bond_rcu(upper, netdev_tmp)
 166                 peers++;
 167         rcu_read_unlock();
 168
 169         if (lag->upper_netdev != upper) {
 170                 dev_hold(upper);
 171                 lag->upper_netdev = upper;
 172         }
 173
 174         ice_clear_sriov_cap(pf);
 175         ice_clear_rdma_cap(pf);
 176
 177         lag->bonded = true;
 178         lag->role = ICE_LAG_UNSET;
 179
 180         /* if this is the first element in an LAG mark as master */
 181         lag->master = !!(peers == 1);
 182 }
 183
 184 /**
 185  * ice_lag_unlink - handle unlink event
 186  * @lag: LAG info struct
 187  * @info: info from netdev notification
 188  */
 189 static void
 190 ice_lag_unlink(struct ice_lag *lag,
 191                struct netdev_notifier_changeupper_info *info)
 192 {
 193         struct net_device *netdev_tmp, *upper = info->upper_dev;
 194         struct ice_pf *pf = lag->pf;
 195         bool found = false;
 196
 197         if (!lag->bonded) {
 198                 netdev_dbg(lag->netdev, "bonding unlink event on non-LAG netdev\n");
 199                 return;
 200         }
 201
 202         /* determine if we are in the new LAG config or not */
 203         rcu_read_lock();
 204         for_each_netdev_in_bond_rcu(upper, netdev_tmp) {
 205                 if (netdev_tmp == lag->netdev) {
 206                         found = true;
 207                         break;
 208                 }
 209         }
 210         rcu_read_unlock();
 211
 212         if (found)
 213                 return;
 214
 215         if (lag->upper_netdev) {
 216                 dev_put(lag->upper_netdev);
 217                 lag->upper_netdev = NULL;
 218         }
 219
 220         if (lag->peer_netdev) {
 221                 dev_put(lag->peer_netdev);
 222                 lag->peer_netdev = NULL;
 223         }
 224
 225         ice_set_sriov_cap(pf);
 226         ice_set_rdma_cap(pf);
 227         lag->bonded = false;
 228         lag->role = ICE_LAG_NONE;
 229 }
 230
 231 /**
 232  * ice_lag_changeupper_event - handle LAG changeupper event
 233  * @lag: LAG info struct
 234  * @ptr: opaque pointer data
 235  *
 236  * ptr is to be cast into netdev_notifier_changeupper_info
 237  */
 238 static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr)
 239 {
 240         struct netdev_notifier_changeupper_info *info;
 241         struct net_device *netdev;
 242
 243         info = ptr;
 244         netdev = netdev_notifier_info_to_dev(ptr);
 245
 246         /* not for this netdev */
 247         if (netdev != lag->netdev)
 248                 return;
 249
 250         if (!info->upper_dev) {
 251                 netdev_dbg(netdev, "changeupper rcvd, but no upper defined\n");
 252                 return;
 253         }
 254
 255         netdev_dbg(netdev, "bonding %s\n", info->linking ? "LINK" : "UNLINK");
 256
 257         if (!netif_is_lag_master(info->upper_dev)) {
 258                 netdev_dbg(netdev, "changeupper rcvd, but not master. bail\n");
 259                 return;
 260         }
 261
 262         if (info->linking)
 263                 ice_lag_link(lag, info);
 264         else
 265                 ice_lag_unlink(lag, info);
 266
 267         ice_display_lag_info(lag);
 268 }
 269
 270 /**
 271  * ice_lag_changelower_event - handle LAG changelower event
 272  * @lag: LAG info struct
 273  * @ptr: opaque data pointer
 274  *
 275  * ptr to be cast to netdev_notifier_changelowerstate_info
 276  */
 277 static void ice_lag_changelower_event(struct ice_lag *lag, void *ptr)
 278 {
 279         struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
 280
 281         if (netdev != lag->netdev)
 282                 return;
 283
 284         netdev_dbg(netdev, "bonding info\n");
 285
 286         if (!netif_is_lag_port(netdev))
 287                 netdev_dbg(netdev, "CHANGELOWER rcvd, but netdev not in LAG. Bail\n");
 288 }
 289
 290 /**
 291  * ice_lag_event_handler - handle LAG events from netdev
 292  * @notif_blk: notifier block registered by this netdev
 293  * @event: event type
 294  * @ptr: opaque data containing notifier event
 295  */
 296 static int
 297 ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event,
 298                       void *ptr)
 299 {
 300         struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
 301         struct ice_lag *lag;
 302
 303         lag = container_of(notif_blk, struct ice_lag, notif_block);
 304
 305         if (!lag->netdev)
 306                 return NOTIFY_DONE;
 307
 308         /* Check that the netdev is in the working namespace */
 309         if (!net_eq(dev_net(netdev), &init_net))
 310                 return NOTIFY_DONE;
 311
 312         switch (event) {
 313         case NETDEV_CHANGEUPPER:
 314                 ice_lag_changeupper_event(lag, ptr);
 315                 break;
 316         case NETDEV_CHANGELOWERSTATE:
 317                 ice_lag_changelower_event(lag, ptr);
 318                 break;
 319         case NETDEV_BONDING_INFO:
 320                 ice_lag_info_event(lag, ptr);
 321                 break;
 322         default:
 323                 break;
 324         }
 325
 326         return NOTIFY_DONE;
 327 }
 328
 329 /**
 330  * ice_register_lag_handler - register LAG handler on netdev
 331  * @lag: LAG struct
 332  */
 333 static int ice_register_lag_handler(struct ice_lag *lag)
 334 {
 335         struct device *dev = ice_pf_to_dev(lag->pf);
 336         struct notifier_block *notif_blk;
 337
 338         notif_blk = &lag->notif_block;
 339
 340         if (!notif_blk->notifier_call) {
 341                 notif_blk->notifier_call = ice_lag_event_handler;
 342                 if (register_netdevice_notifier(notif_blk)) {
 343                         notif_blk->notifier_call = NULL;
 344                         dev_err(dev, "FAIL register LAG event handler!\n");
 345                         return -EINVAL;
 346                 }
 347                 dev_dbg(dev, "LAG event handler registered\n");
 348         }
 349         return 0;
 350 }
 351
 352 /**
 353  * ice_unregister_lag_handler - unregister LAG handler on netdev
 354  * @lag: LAG struct
 355  */
 356 static void ice_unregister_lag_handler(struct ice_lag *lag)
 357 {
 358         struct device *dev = ice_pf_to_dev(lag->pf);
 359         struct notifier_block *notif_blk;
 360
 361         notif_blk = &lag->notif_block;
 362         if (notif_blk->notifier_call) {
 363                 unregister_netdevice_notifier(notif_blk);
 364                 dev_dbg(dev, "LAG event handler unregistered\n");
 365         }
 366 }
 367
 368 /**
 369  * ice_init_lag - initialize support for LAG
 370  * @pf: PF struct
 371  *
 372  * Alloc memory for LAG structs and initialize the elements.
 373  * Memory will be freed in ice_deinit_lag
 374  */
 375 int ice_init_lag(struct ice_pf *pf)
 376 {
 377         struct device *dev = ice_pf_to_dev(pf);
 378         struct ice_lag *lag;
 379         struct ice_vsi *vsi;
 380         int err;
 381
 382         pf->lag = kzalloc(sizeof(*lag), GFP_KERNEL);
 383         if (!pf->lag)
 384                 return -ENOMEM;
 385         lag = pf->lag;
 386
 387         vsi = ice_get_main_vsi(pf);
 388         if (!vsi) {
 389                 dev_err(dev, "couldn't get main vsi, link aggregation init fail\n");
 390                 err = -EIO;
 391                 goto lag_error;
 392         }
 393
 394         lag->pf = pf;
 395         lag->netdev = vsi->netdev;
 396         lag->role = ICE_LAG_NONE;
 397         lag->bonded = false;
 398         lag->peer_netdev = NULL;
 399         lag->upper_netdev = NULL;
 400         lag->notif_block.notifier_call = NULL;
 401
 402         err = ice_register_lag_handler(lag);
 403         if (err) {
 404                 dev_warn(dev, "INIT LAG: Failed to register event handler\n");
 405                 goto lag_error;
 406         }
 407
 408         ice_display_lag_info(lag);
 409
 410         dev_dbg(dev, "INIT LAG complete\n");
 411         return 0;
 412
 413 lag_error:
 414         kfree(lag);
 415         pf->lag = NULL;
 416         return err;
 417 }
 418
 419 /**
 420  * ice_deinit_lag - Clean up LAG
 421  * @pf: PF struct
 422  *
 423  * Clean up kernel LAG info and free memory
 424  * This function is meant to only be called on driver remove/shutdown
 425  */
 426 void ice_deinit_lag(struct ice_pf *pf)
 427 {
 428         struct ice_lag *lag;
 429
 430         lag = pf->lag;
 431
 432         if (!lag)
 433                 return;
 434
 435         if (lag->pf)
 436                 ice_unregister_lag_handler(lag);
 437
 438         if (lag->upper_netdev)
 439                 dev_put(lag->upper_netdev);
 440
 441         if (lag->peer_netdev)
 442                 dev_put(lag->peer_netdev);
 443
 444         kfree(lag);
 445
 446         pf->lag = NULL;
 447 }