net/ethtool/rings.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include "netlink.h"
   4 #include "common.h"
   5
   6 struct rings_req_info {
   7         struct ethnl_req_info           base;
   8 };
   9
  10 struct rings_reply_data {
  11         struct ethnl_reply_data         base;
  12         struct ethtool_ringparam        ringparam;
  13         struct kernel_ethtool_ringparam kernel_ringparam;
  14 };
  15
  16 #define RINGS_REPDATA(__reply_base) \
  17         container_of(__reply_base, struct rings_reply_data, base)
  18
  19 const struct nla_policy ethnl_rings_get_policy[] = {
  20         [ETHTOOL_A_RINGS_HEADER]                =
  21                 NLA_POLICY_NESTED(ethnl_header_policy),
  22 };
  23
  24 static int rings_prepare_data(const struct ethnl_req_info *req_base,
  25                               struct ethnl_reply_data *reply_base,
  26                               struct genl_info *info)
  27 {
  28         struct rings_reply_data *data = RINGS_REPDATA(reply_base);
  29         struct netlink_ext_ack *extack = info ? info->extack : NULL;
  30         struct net_device *dev = reply_base->dev;
  31         int ret;
  32
  33         if (!dev->ethtool_ops->get_ringparam)
  34                 return -EOPNOTSUPP;
  35         ret = ethnl_ops_begin(dev);
  36         if (ret < 0)
  37                 return ret;
  38         dev->ethtool_ops->get_ringparam(dev, &data->ringparam,
  39                                         &data->kernel_ringparam, extack);
  40         ethnl_ops_complete(dev);
  41
  42         return 0;
  43 }
  44
  45 static int rings_reply_size(const struct ethnl_req_info *req_base,
  46                             const struct ethnl_reply_data *reply_base)
  47 {
  48         return nla_total_size(sizeof(u32)) +    /* _RINGS_RX_MAX */
  49                nla_total_size(sizeof(u32)) +    /* _RINGS_RX_MINI_MAX */
  50                nla_total_size(sizeof(u32)) +    /* _RINGS_RX_JUMBO_MAX */
  51                nla_total_size(sizeof(u32)) +    /* _RINGS_TX_MAX */
  52                nla_total_size(sizeof(u32)) +    /* _RINGS_RX */
  53                nla_total_size(sizeof(u32)) +    /* _RINGS_RX_MINI */
  54                nla_total_size(sizeof(u32)) +    /* _RINGS_RX_JUMBO */
  55                nla_total_size(sizeof(u32)) +    /* _RINGS_TX */
  56                nla_total_size(sizeof(u32)) +    /* _RINGS_RX_BUF_LEN */
  57                nla_total_size(sizeof(u8));      /* _RINGS_TCP_DATA_SPLIT */
  58 }
  59
  60 static int rings_fill_reply(struct sk_buff *skb,
  61                             const struct ethnl_req_info *req_base,
  62                             const struct ethnl_reply_data *reply_base)
  63 {
  64         const struct rings_reply_data *data = RINGS_REPDATA(reply_base);
  65         const struct kernel_ethtool_ringparam *kr = &data->kernel_ringparam;
  66         const struct ethtool_ringparam *ringparam = &data->ringparam;
  67
  68         WARN_ON(kr->tcp_data_split > ETHTOOL_TCP_DATA_SPLIT_ENABLED);
  69
  70         if ((ringparam->rx_max_pending &&
  71              (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MAX,
  72                           ringparam->rx_max_pending) ||
  73               nla_put_u32(skb, ETHTOOL_A_RINGS_RX,
  74                           ringparam->rx_pending))) ||
  75             (ringparam->rx_mini_max_pending &&
  76              (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI_MAX,
  77                           ringparam->rx_mini_max_pending) ||
  78               nla_put_u32(skb, ETHTOOL_A_RINGS_RX_MINI,
  79                           ringparam->rx_mini_pending))) ||
  80             (ringparam->rx_jumbo_max_pending &&
  81              (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO_MAX,
  82                           ringparam->rx_jumbo_max_pending) ||
  83               nla_put_u32(skb, ETHTOOL_A_RINGS_RX_JUMBO,
  84                           ringparam->rx_jumbo_pending))) ||
  85             (ringparam->tx_max_pending &&
  86              (nla_put_u32(skb, ETHTOOL_A_RINGS_TX_MAX,
  87                           ringparam->tx_max_pending) ||
  88               nla_put_u32(skb, ETHTOOL_A_RINGS_TX,
  89                           ringparam->tx_pending)))  ||
  90             (kr->rx_buf_len &&
  91              (nla_put_u32(skb, ETHTOOL_A_RINGS_RX_BUF_LEN, kr->rx_buf_len))) ||
  92             (kr->tcp_data_split &&
  93              (nla_put_u8(skb, ETHTOOL_A_RINGS_TCP_DATA_SPLIT,
  94                          kr->tcp_data_split))))
  95                 return -EMSGSIZE;
  96
  97         return 0;
  98 }
  99
 100 const struct ethnl_request_ops ethnl_rings_request_ops = {
 101         .request_cmd            = ETHTOOL_MSG_RINGS_GET,
 102         .reply_cmd              = ETHTOOL_MSG_RINGS_GET_REPLY,
 103         .hdr_attr               = ETHTOOL_A_RINGS_HEADER,
 104         .req_info_size          = sizeof(struct rings_req_info),
 105         .reply_data_size        = sizeof(struct rings_reply_data),
 106
 107         .prepare_data           = rings_prepare_data,
 108         .reply_size             = rings_reply_size,
 109         .fill_reply             = rings_fill_reply,
 110 };
 111
 112 /* RINGS_SET */
 113
 114 const struct nla_policy ethnl_rings_set_policy[] = {
 115         [ETHTOOL_A_RINGS_HEADER]                =
 116                 NLA_POLICY_NESTED(ethnl_header_policy),
 117         [ETHTOOL_A_RINGS_RX]                    = { .type = NLA_U32 },
 118         [ETHTOOL_A_RINGS_RX_MINI]               = { .type = NLA_U32 },
 119         [ETHTOOL_A_RINGS_RX_JUMBO]              = { .type = NLA_U32 },
 120         [ETHTOOL_A_RINGS_TX]                    = { .type = NLA_U32 },
 121         [ETHTOOL_A_RINGS_RX_BUF_LEN]            = NLA_POLICY_MIN(NLA_U32, 1),
 122 };
 123
 124 int ethnl_set_rings(struct sk_buff *skb, struct genl_info *info)
 125 {
 126         struct kernel_ethtool_ringparam kernel_ringparam = {};
 127         struct ethtool_ringparam ringparam = {};
 128         struct ethnl_req_info req_info = {};
 129         struct nlattr **tb = info->attrs;
 130         const struct nlattr *err_attr;
 131         const struct ethtool_ops *ops;
 132         struct net_device *dev;
 133         bool mod = false;
 134         int ret;
 135
 136         ret = ethnl_parse_header_dev_get(&req_info,
 137                                          tb[ETHTOOL_A_RINGS_HEADER],
 138                                          genl_info_net(info), info->extack,
 139                                          true);
 140         if (ret < 0)
 141                 return ret;
 142         dev = req_info.dev;
 143         ops = dev->ethtool_ops;
 144         ret = -EOPNOTSUPP;
 145         if (!ops->get_ringparam || !ops->set_ringparam)
 146                 goto out_dev;
 147
 148         rtnl_lock();
 149         ret = ethnl_ops_begin(dev);
 150         if (ret < 0)
 151                 goto out_rtnl;
 152         ops->get_ringparam(dev, &ringparam, &kernel_ringparam, info->extack);
 153
 154         ethnl_update_u32(&ringparam.rx_pending, tb[ETHTOOL_A_RINGS_RX], &mod);
 155         ethnl_update_u32(&ringparam.rx_mini_pending,
 156                          tb[ETHTOOL_A_RINGS_RX_MINI], &mod);
 157         ethnl_update_u32(&ringparam.rx_jumbo_pending,
 158                          tb[ETHTOOL_A_RINGS_RX_JUMBO], &mod);
 159         ethnl_update_u32(&ringparam.tx_pending, tb[ETHTOOL_A_RINGS_TX], &mod);
 160         ethnl_update_u32(&kernel_ringparam.rx_buf_len,
 161                          tb[ETHTOOL_A_RINGS_RX_BUF_LEN], &mod);
 162         ret = 0;
 163         if (!mod)
 164                 goto out_ops;
 165
 166         /* ensure new ring parameters are within limits */
 167         if (ringparam.rx_pending > ringparam.rx_max_pending)
 168                 err_attr = tb[ETHTOOL_A_RINGS_RX];
 169         else if (ringparam.rx_mini_pending > ringparam.rx_mini_max_pending)
 170                 err_attr = tb[ETHTOOL_A_RINGS_RX_MINI];
 171         else if (ringparam.rx_jumbo_pending > ringparam.rx_jumbo_max_pending)
 172                 err_attr = tb[ETHTOOL_A_RINGS_RX_JUMBO];
 173         else if (ringparam.tx_pending > ringparam.tx_max_pending)
 174                 err_attr = tb[ETHTOOL_A_RINGS_TX];
 175         else
 176                 err_attr = NULL;
 177         if (err_attr) {
 178                 ret = -EINVAL;
 179                 NL_SET_ERR_MSG_ATTR(info->extack, err_attr,
 180                                     "requested ring size exceeds maximum");
 181                 goto out_ops;
 182         }
 183
 184         if (kernel_ringparam.rx_buf_len != 0 &&
 185             !(ops->supported_ring_params & ETHTOOL_RING_USE_RX_BUF_LEN)) {
 186                 ret = -EOPNOTSUPP;
 187                 NL_SET_ERR_MSG_ATTR(info->extack,
 188                                     tb[ETHTOOL_A_RINGS_RX_BUF_LEN],
 189                                     "setting rx buf len not supported");
 190                 goto out_ops;
 191         }
 192
 193         ret = dev->ethtool_ops->set_ringparam(dev, &ringparam,
 194                                               &kernel_ringparam, info->extack);
 195         if (ret < 0)
 196                 goto out_ops;
 197         ethtool_notify(dev, ETHTOOL_MSG_RINGS_NTF, NULL);
 198
 199 out_ops:
 200         ethnl_ops_complete(dev);
 201 out_rtnl:
 202         rtnl_unlock();
 203 out_dev:
 204         ethnl_parse_header_dev_put(&req_info);
 205         return ret;
 206 }