drivers/net/bonding/bond_options.c

   1 /*
   2  * drivers/net/bond/bond_options.c - bonding options
   3  * Copyright (c) 2013 Jiri Pirko <jiri@resnulli.us>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/errno.h>
  14 #include <linux/if.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/rwlock.h>
  17 #include <linux/rcupdate.h>
  18 #include "bonding.h"
  19
  20 static bool bond_mode_is_valid(int mode)
  21 {
  22         int i;
  23
  24         for (i = 0; bond_mode_tbl[i].modename; i++);
  25
  26         return mode >= 0 && mode < i;
  27 }
  28
  29 int bond_option_mode_set(struct bonding *bond, int mode)
  30 {
  31         if (!bond_mode_is_valid(mode)) {
  32                 pr_err("invalid mode value %d.\n", mode);
  33                 return -EINVAL;
  34         }
  35
  36         if (bond->dev->flags & IFF_UP) {
  37                 pr_err("%s: unable to update mode because interface is up.\n",
  38                        bond->dev->name);
  39                 return -EPERM;
  40         }
  41
  42         if (bond_has_slaves(bond)) {
  43                 pr_err("%s: unable to update mode because bond has slaves.\n",
  44                         bond->dev->name);
  45                 return -EPERM;
  46         }
  47
  48         if (BOND_MODE_IS_LB(mode) && bond->params.arp_interval) {
  49                 pr_err("%s: %s mode is incompatible with arp monitoring.\n",
  50                        bond->dev->name, bond_mode_tbl[mode].modename);
  51                 return -EINVAL;
  52         }
  53
  54         /* don't cache arp_validate between modes */
  55         bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
  56         bond->params.mode = mode;
  57         return 0;
  58 }
  59
  60 static struct net_device *__bond_option_active_slave_get(struct bonding *bond,
  61                                                          struct slave *slave)
  62 {
  63         return USES_PRIMARY(bond->params.mode) && slave ? slave->dev : NULL;
  64 }
  65
  66 struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond)
  67 {
  68         struct slave *slave = rcu_dereference(bond->curr_active_slave);
  69
  70         return __bond_option_active_slave_get(bond, slave);
  71 }
  72
  73 struct net_device *bond_option_active_slave_get(struct bonding *bond)
  74 {
  75         return __bond_option_active_slave_get(bond, bond->curr_active_slave);
  76 }
  77
  78 int bond_option_active_slave_set(struct bonding *bond,
  79                                  struct net_device *slave_dev)
  80 {
  81         int ret = 0;
  82
  83         if (slave_dev) {
  84                 if (!netif_is_bond_slave(slave_dev)) {
  85                         pr_err("Device %s is not bonding slave.\n",
  86                                slave_dev->name);
  87                         return -EINVAL;
  88                 }
  89
  90                 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) {
  91                         pr_err("%s: Device %s is not our slave.\n",
  92                                bond->dev->name, slave_dev->name);
  93                         return -EINVAL;
  94                 }
  95         }
  96
  97         if (!USES_PRIMARY(bond->params.mode)) {
  98                 pr_err("%s: Unable to change active slave; %s is in mode %d\n",
  99                        bond->dev->name, bond->dev->name, bond->params.mode);
 100                 return -EINVAL;
 101         }
 102
 103         block_netpoll_tx();
 104         read_lock(&bond->lock);
 105         write_lock_bh(&bond->curr_slave_lock);
 106
 107         /* check to see if we are clearing active */
 108         if (!slave_dev) {
 109                 pr_info("%s: Clearing current active slave.\n",
 110                 bond->dev->name);
 111                 rcu_assign_pointer(bond->curr_active_slave, NULL);
 112                 bond_select_active_slave(bond);
 113         } else {
 114                 struct slave *old_active = bond->curr_active_slave;
 115                 struct slave *new_active = bond_slave_get_rtnl(slave_dev);
 116
 117                 BUG_ON(!new_active);
 118
 119                 if (new_active == old_active) {
 120                         /* do nothing */
 121                         pr_info("%s: %s is already the current active slave.\n",
 122                                 bond->dev->name, new_active->dev->name);
 123                 } else {
 124                         if (old_active && (new_active->link == BOND_LINK_UP) &&
 125                             IS_UP(new_active->dev)) {
 126                                 pr_info("%s: Setting %s as active slave.\n",
 127                                         bond->dev->name, new_active->dev->name);
 128                                 bond_change_active_slave(bond, new_active);
 129                         } else {
 130                                 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down.\n",
 131                                        bond->dev->name, new_active->dev->name,
 132                                        new_active->dev->name);
 133                                 ret = -EINVAL;
 134                         }
 135                 }
 136         }
 137
 138         write_unlock_bh(&bond->curr_slave_lock);
 139         read_unlock(&bond->lock);
 140         unblock_netpoll_tx();
 141         return ret;
 142 }