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_NO_USES_ARP(mode) && bond->params.arp_interval) {
  49                 pr_info("%s: %s mode is incompatible with arp monitoring, start mii monitoring\n",
  50                         bond->dev->name, bond_mode_tbl[mode].modename);
  51                 /* disable arp monitoring */
  52                 bond->params.arp_interval = 0;
  53                 /* set miimon to default value */
  54                 bond->params.miimon = BOND_DEFAULT_MIIMON;
  55                 pr_info("%s: Setting MII monitoring interval to %d.\n",
  56                         bond->dev->name, bond->params.miimon);
  57         }
  58
  59         /* don't cache arp_validate between modes */
  60         bond->params.arp_validate = BOND_ARP_VALIDATE_NONE;
  61         bond->params.mode = mode;
  62         return 0;
  63 }
  64
  65 static struct net_device *__bond_option_active_slave_get(struct bonding *bond,
  66                                                          struct slave *slave)
  67 {
  68         return USES_PRIMARY(bond->params.mode) && slave ? slave->dev : NULL;
  69 }
  70
  71 struct net_device *bond_option_active_slave_get_rcu(struct bonding *bond)
  72 {
  73         struct slave *slave = rcu_dereference(bond->curr_active_slave);
  74
  75         return __bond_option_active_slave_get(bond, slave);
  76 }
  77
  78 struct net_device *bond_option_active_slave_get(struct bonding *bond)
  79 {
  80         return __bond_option_active_slave_get(bond, bond->curr_active_slave);
  81 }
  82
  83 int bond_option_active_slave_set(struct bonding *bond,
  84                                  struct net_device *slave_dev)
  85 {
  86         int ret = 0;
  87
  88         if (slave_dev) {
  89                 if (!netif_is_bond_slave(slave_dev)) {
  90                         pr_err("Device %s is not bonding slave.\n",
  91                                slave_dev->name);
  92                         return -EINVAL;
  93                 }
  94
  95                 if (bond->dev != netdev_master_upper_dev_get(slave_dev)) {
  96                         pr_err("%s: Device %s is not our slave.\n",
  97                                bond->dev->name, slave_dev->name);
  98                         return -EINVAL;
  99                 }
 100         }
 101
 102         if (!USES_PRIMARY(bond->params.mode)) {
 103                 pr_err("%s: Unable to change active slave; %s is in mode %d\n",
 104                        bond->dev->name, bond->dev->name, bond->params.mode);
 105                 return -EINVAL;
 106         }
 107
 108         block_netpoll_tx();
 109         read_lock(&bond->lock);
 110         write_lock_bh(&bond->curr_slave_lock);
 111
 112         /* check to see if we are clearing active */
 113         if (!slave_dev) {
 114                 pr_info("%s: Clearing current active slave.\n",
 115                 bond->dev->name);
 116                 rcu_assign_pointer(bond->curr_active_slave, NULL);
 117                 bond_select_active_slave(bond);
 118         } else {
 119                 struct slave *old_active = bond->curr_active_slave;
 120                 struct slave *new_active = bond_slave_get_rtnl(slave_dev);
 121
 122                 BUG_ON(!new_active);
 123
 124                 if (new_active == old_active) {
 125                         /* do nothing */
 126                         pr_info("%s: %s is already the current active slave.\n",
 127                                 bond->dev->name, new_active->dev->name);
 128                 } else {
 129                         if (old_active && (new_active->link == BOND_LINK_UP) &&
 130                             IS_UP(new_active->dev)) {
 131                                 pr_info("%s: Setting %s as active slave.\n",
 132                                         bond->dev->name, new_active->dev->name);
 133                                 bond_change_active_slave(bond, new_active);
 134                         } else {
 135                                 pr_err("%s: Could not set %s as active slave; either %s is down or the link is down.\n",
 136                                        bond->dev->name, new_active->dev->name,
 137                                        new_active->dev->name);
 138                                 ret = -EINVAL;
 139                         }
 140                 }
 141         }
 142
 143         write_unlock_bh(&bond->curr_slave_lock);
 144         read_unlock(&bond->lock);
 145         unblock_netpoll_tx();
 146         return ret;
 147 }