net/ethtool/linkmodes.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include "netlink.h"
   4 #include "common.h"
   5 #include "bitset.h"
   6
   7 /* LINKMODES_GET */
   8
   9 struct linkmodes_req_info {
  10         struct ethnl_req_info           base;
  11 };
  12
  13 struct linkmodes_reply_data {
  14         struct ethnl_reply_data         base;
  15         struct ethtool_link_ksettings   ksettings;
  16         struct ethtool_link_settings    *lsettings;
  17         bool                            peer_empty;
  18 };
  19
  20 #define LINKMODES_REPDATA(__reply_base) \
  21         container_of(__reply_base, struct linkmodes_reply_data, base)
  22
  23 const struct nla_policy ethnl_linkmodes_get_policy[] = {
  24         [ETHTOOL_A_LINKMODES_HEADER]            =
  25                 NLA_POLICY_NESTED(ethnl_header_policy),
  26 };
  27
  28 static int linkmodes_prepare_data(const struct ethnl_req_info *req_base,
  29                                   struct ethnl_reply_data *reply_base,
  30                                   struct genl_info *info)
  31 {
  32         struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
  33         struct net_device *dev = reply_base->dev;
  34         int ret;
  35
  36         data->lsettings = &data->ksettings.base;
  37
  38         ret = ethnl_ops_begin(dev);
  39         if (ret < 0)
  40                 return ret;
  41
  42         ret = __ethtool_get_link_ksettings(dev, &data->ksettings);
  43         if (ret < 0 && info) {
  44                 GENL_SET_ERR_MSG(info, "failed to retrieve link settings");
  45                 goto out;
  46         }
  47
  48         data->peer_empty =
  49                 bitmap_empty(data->ksettings.link_modes.lp_advertising,
  50                              __ETHTOOL_LINK_MODE_MASK_NBITS);
  51
  52 out:
  53         ethnl_ops_complete(dev);
  54         return ret;
  55 }
  56
  57 static int linkmodes_reply_size(const struct ethnl_req_info *req_base,
  58                                 const struct ethnl_reply_data *reply_base)
  59 {
  60         const struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
  61         const struct ethtool_link_ksettings *ksettings = &data->ksettings;
  62         const struct ethtool_link_settings *lsettings = &ksettings->base;
  63         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
  64         int len, ret;
  65
  66         len = nla_total_size(sizeof(u8)) /* LINKMODES_AUTONEG */
  67                 + nla_total_size(sizeof(u32)) /* LINKMODES_SPEED */
  68                 + nla_total_size(sizeof(u8)) /* LINKMODES_DUPLEX */
  69                 + 0;
  70         ret = ethnl_bitset_size(ksettings->link_modes.advertising,
  71                                 ksettings->link_modes.supported,
  72                                 __ETHTOOL_LINK_MODE_MASK_NBITS,
  73                                 link_mode_names, compact);
  74         if (ret < 0)
  75                 return ret;
  76         len += ret;
  77         if (!data->peer_empty) {
  78                 ret = ethnl_bitset_size(ksettings->link_modes.lp_advertising,
  79                                         NULL, __ETHTOOL_LINK_MODE_MASK_NBITS,
  80                                         link_mode_names, compact);
  81                 if (ret < 0)
  82                         return ret;
  83                 len += ret;
  84         }
  85
  86         if (lsettings->master_slave_cfg != MASTER_SLAVE_CFG_UNSUPPORTED)
  87                 len += nla_total_size(sizeof(u8));
  88
  89         if (lsettings->master_slave_state != MASTER_SLAVE_STATE_UNSUPPORTED)
  90                 len += nla_total_size(sizeof(u8));
  91
  92         return len;
  93 }
  94
  95 static int linkmodes_fill_reply(struct sk_buff *skb,
  96                                 const struct ethnl_req_info *req_base,
  97                                 const struct ethnl_reply_data *reply_base)
  98 {
  99         const struct linkmodes_reply_data *data = LINKMODES_REPDATA(reply_base);
 100         const struct ethtool_link_ksettings *ksettings = &data->ksettings;
 101         const struct ethtool_link_settings *lsettings = &ksettings->base;
 102         bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
 103         int ret;
 104
 105         if (nla_put_u8(skb, ETHTOOL_A_LINKMODES_AUTONEG, lsettings->autoneg))
 106                 return -EMSGSIZE;
 107
 108         ret = ethnl_put_bitset(skb, ETHTOOL_A_LINKMODES_OURS,
 109                                ksettings->link_modes.advertising,
 110                                ksettings->link_modes.supported,
 111                                __ETHTOOL_LINK_MODE_MASK_NBITS, link_mode_names,
 112                                compact);
 113         if (ret < 0)
 114                 return -EMSGSIZE;
 115         if (!data->peer_empty) {
 116                 ret = ethnl_put_bitset(skb, ETHTOOL_A_LINKMODES_PEER,
 117                                        ksettings->link_modes.lp_advertising,
 118                                        NULL, __ETHTOOL_LINK_MODE_MASK_NBITS,
 119                                        link_mode_names, compact);
 120                 if (ret < 0)
 121                         return -EMSGSIZE;
 122         }
 123
 124         if (nla_put_u32(skb, ETHTOOL_A_LINKMODES_SPEED, lsettings->speed) ||
 125             nla_put_u8(skb, ETHTOOL_A_LINKMODES_DUPLEX, lsettings->duplex))
 126                 return -EMSGSIZE;
 127
 128         if (lsettings->master_slave_cfg != MASTER_SLAVE_CFG_UNSUPPORTED &&
 129             nla_put_u8(skb, ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG,
 130                        lsettings->master_slave_cfg))
 131                 return -EMSGSIZE;
 132
 133         if (lsettings->master_slave_state != MASTER_SLAVE_STATE_UNSUPPORTED &&
 134             nla_put_u8(skb, ETHTOOL_A_LINKMODES_MASTER_SLAVE_STATE,
 135                        lsettings->master_slave_state))
 136                 return -EMSGSIZE;
 137
 138         return 0;
 139 }
 140
 141 const struct ethnl_request_ops ethnl_linkmodes_request_ops = {
 142         .request_cmd            = ETHTOOL_MSG_LINKMODES_GET,
 143         .reply_cmd              = ETHTOOL_MSG_LINKMODES_GET_REPLY,
 144         .hdr_attr               = ETHTOOL_A_LINKMODES_HEADER,
 145         .req_info_size          = sizeof(struct linkmodes_req_info),
 146         .reply_data_size        = sizeof(struct linkmodes_reply_data),
 147
 148         .prepare_data           = linkmodes_prepare_data,
 149         .reply_size             = linkmodes_reply_size,
 150         .fill_reply             = linkmodes_fill_reply,
 151 };
 152
 153 /* LINKMODES_SET */
 154
 155 const struct nla_policy ethnl_linkmodes_set_policy[] = {
 156         [ETHTOOL_A_LINKMODES_HEADER]            =
 157                 NLA_POLICY_NESTED(ethnl_header_policy),
 158         [ETHTOOL_A_LINKMODES_AUTONEG]           = { .type = NLA_U8 },
 159         [ETHTOOL_A_LINKMODES_OURS]              = { .type = NLA_NESTED },
 160         [ETHTOOL_A_LINKMODES_SPEED]             = { .type = NLA_U32 },
 161         [ETHTOOL_A_LINKMODES_DUPLEX]            = { .type = NLA_U8 },
 162         [ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG]  = { .type = NLA_U8 },
 163         [ETHTOOL_A_LINKMODES_LANES]             = NLA_POLICY_RANGE(NLA_U32, 1, 8),
 164 };
 165
 166 /* Set advertised link modes to all supported modes matching requested speed,
 167  * lanes and duplex values. Called when autonegotiation is on, speed, lanes or
 168  * duplex is requested but no link mode change. This is done in userspace with
 169  * ioctl() interface, move it into kernel for netlink.
 170  * Returns true if advertised modes bitmap was modified.
 171  */
 172 static bool ethnl_auto_linkmodes(struct ethtool_link_ksettings *ksettings,
 173                                  bool req_speed, bool req_lanes, bool req_duplex)
 174 {
 175         unsigned long *advertising = ksettings->link_modes.advertising;
 176         unsigned long *supported = ksettings->link_modes.supported;
 177         DECLARE_BITMAP(old_adv, __ETHTOOL_LINK_MODE_MASK_NBITS);
 178         unsigned int i;
 179
 180         bitmap_copy(old_adv, advertising, __ETHTOOL_LINK_MODE_MASK_NBITS);
 181
 182         for (i = 0; i < __ETHTOOL_LINK_MODE_MASK_NBITS; i++) {
 183                 const struct link_mode_info *info = &link_mode_params[i];
 184
 185                 if (info->speed == SPEED_UNKNOWN)
 186                         continue;
 187                 if (test_bit(i, supported) &&
 188                     (!req_speed || info->speed == ksettings->base.speed) &&
 189                     (!req_lanes || info->lanes == ksettings->lanes) &&
 190                     (!req_duplex || info->duplex == ksettings->base.duplex))
 191                         set_bit(i, advertising);
 192                 else
 193                         clear_bit(i, advertising);
 194         }
 195
 196         return !bitmap_equal(old_adv, advertising,
 197                              __ETHTOOL_LINK_MODE_MASK_NBITS);
 198 }
 199
 200 static bool ethnl_validate_master_slave_cfg(u8 cfg)
 201 {
 202         switch (cfg) {
 203         case MASTER_SLAVE_CFG_MASTER_PREFERRED:
 204         case MASTER_SLAVE_CFG_SLAVE_PREFERRED:
 205         case MASTER_SLAVE_CFG_MASTER_FORCE:
 206         case MASTER_SLAVE_CFG_SLAVE_FORCE:
 207                 return true;
 208         }
 209
 210         return false;
 211 }
 212
 213 static int ethnl_check_linkmodes(struct genl_info *info, struct nlattr **tb)
 214 {
 215         const struct nlattr *master_slave_cfg, *lanes_cfg;
 216
 217         master_slave_cfg = tb[ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG];
 218         if (master_slave_cfg &&
 219             !ethnl_validate_master_slave_cfg(nla_get_u8(master_slave_cfg))) {
 220                 NL_SET_ERR_MSG_ATTR(info->extack, master_slave_cfg,
 221                                     "master/slave value is invalid");
 222                 return -EOPNOTSUPP;
 223         }
 224
 225         lanes_cfg = tb[ETHTOOL_A_LINKMODES_LANES];
 226         if (lanes_cfg && !is_power_of_2(nla_get_u32(lanes_cfg))) {
 227                 NL_SET_ERR_MSG_ATTR(info->extack, lanes_cfg,
 228                                     "lanes value is invalid");
 229                 return -EINVAL;
 230         }
 231
 232         return 0;
 233 }
 234
 235 static int ethnl_update_linkmodes(struct genl_info *info, struct nlattr **tb,
 236                                   struct ethtool_link_ksettings *ksettings,
 237                                   bool *mod, const struct net_device *dev)
 238 {
 239         struct ethtool_link_settings *lsettings = &ksettings->base;
 240         bool req_speed, req_lanes, req_duplex;
 241         const struct nlattr *master_slave_cfg, *lanes_cfg;
 242         int ret;
 243
 244         master_slave_cfg = tb[ETHTOOL_A_LINKMODES_MASTER_SLAVE_CFG];
 245         if (master_slave_cfg) {
 246                 if (lsettings->master_slave_cfg == MASTER_SLAVE_CFG_UNSUPPORTED) {
 247                         NL_SET_ERR_MSG_ATTR(info->extack, master_slave_cfg,
 248                                             "master/slave configuration not supported by device");
 249                         return -EOPNOTSUPP;
 250                 }
 251         }
 252
 253         *mod = false;
 254         req_speed = tb[ETHTOOL_A_LINKMODES_SPEED];
 255         req_lanes = tb[ETHTOOL_A_LINKMODES_LANES];
 256         req_duplex = tb[ETHTOOL_A_LINKMODES_DUPLEX];
 257
 258         ethnl_update_u8(&lsettings->autoneg, tb[ETHTOOL_A_LINKMODES_AUTONEG],
 259                         mod);
 260
 261         lanes_cfg = tb[ETHTOOL_A_LINKMODES_LANES];
 262         if (lanes_cfg) {
 263                 /* If autoneg is off and lanes parameter is not supported by the
 264                  * driver, return an error.
 265                  */
 266                 if (!lsettings->autoneg &&
 267                     !dev->ethtool_ops->cap_link_lanes_supported) {
 268                         NL_SET_ERR_MSG_ATTR(info->extack, lanes_cfg,
 269                                             "lanes configuration not supported by device");
 270                         return -EOPNOTSUPP;
 271                 }
 272         } else if (!lsettings->autoneg) {
 273                 /* If autoneg is off and lanes parameter is not passed from user,
 274                  * set the lanes parameter to 0.
 275                  */
 276                 ksettings->lanes = 0;
 277         }
 278
 279         ret = ethnl_update_bitset(ksettings->link_modes.advertising,
 280                                   __ETHTOOL_LINK_MODE_MASK_NBITS,
 281                                   tb[ETHTOOL_A_LINKMODES_OURS], link_mode_names,
 282                                   info->extack, mod);
 283         if (ret < 0)
 284                 return ret;
 285         ethnl_update_u32(&lsettings->speed, tb[ETHTOOL_A_LINKMODES_SPEED],
 286                          mod);
 287         ethnl_update_u32(&ksettings->lanes, lanes_cfg, mod);
 288         ethnl_update_u8(&lsettings->duplex, tb[ETHTOOL_A_LINKMODES_DUPLEX],
 289                         mod);
 290         ethnl_update_u8(&lsettings->master_slave_cfg, master_slave_cfg, mod);
 291
 292         if (!tb[ETHTOOL_A_LINKMODES_OURS] && lsettings->autoneg &&
 293             (req_speed || req_lanes || req_duplex) &&
 294             ethnl_auto_linkmodes(ksettings, req_speed, req_lanes, req_duplex))
 295                 *mod = true;
 296
 297         return 0;
 298 }
 299
 300 int ethnl_set_linkmodes(struct sk_buff *skb, struct genl_info *info)
 301 {
 302         struct ethtool_link_ksettings ksettings = {};
 303         struct ethnl_req_info req_info = {};
 304         struct nlattr **tb = info->attrs;
 305         struct net_device *dev;
 306         bool mod = false;
 307         int ret;
 308
 309         ret = ethnl_check_linkmodes(info, tb);
 310         if (ret < 0)
 311                 return ret;
 312
 313         ret = ethnl_parse_header_dev_get(&req_info,
 314                                          tb[ETHTOOL_A_LINKMODES_HEADER],
 315                                          genl_info_net(info), info->extack,
 316                                          true);
 317         if (ret < 0)
 318                 return ret;
 319         dev = req_info.dev;
 320         ret = -EOPNOTSUPP;
 321         if (!dev->ethtool_ops->get_link_ksettings ||
 322             !dev->ethtool_ops->set_link_ksettings)
 323                 goto out_dev;
 324
 325         rtnl_lock();
 326         ret = ethnl_ops_begin(dev);
 327         if (ret < 0)
 328                 goto out_rtnl;
 329
 330         ret = __ethtool_get_link_ksettings(dev, &ksettings);
 331         if (ret < 0) {
 332                 GENL_SET_ERR_MSG(info, "failed to retrieve link settings");
 333                 goto out_ops;
 334         }
 335
 336         ret = ethnl_update_linkmodes(info, tb, &ksettings, &mod, dev);
 337         if (ret < 0)
 338                 goto out_ops;
 339
 340         if (mod) {
 341                 ret = dev->ethtool_ops->set_link_ksettings(dev, &ksettings);
 342                 if (ret < 0)
 343                         GENL_SET_ERR_MSG(info, "link settings update failed");
 344                 else
 345                         ethtool_notify(dev, ETHTOOL_MSG_LINKMODES_NTF, NULL);
 346         }
 347
 348 out_ops:
 349         ethnl_ops_complete(dev);
 350 out_rtnl:
 351         rtnl_unlock();
 352 out_dev:
 353         dev_put(dev);
 354         return ret;
 355 }