Merge tag 'perf-urgent-2021-07-11' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-microblaze.git] / net / ethtool / channels.c
1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include <net/xdp_sock_drv.h>
4
5 #include "netlink.h"
6 #include "common.h"
7
8 struct channels_req_info {
9         struct ethnl_req_info           base;
10 };
11
12 struct channels_reply_data {
13         struct ethnl_reply_data         base;
14         struct ethtool_channels         channels;
15 };
16
17 #define CHANNELS_REPDATA(__reply_base) \
18         container_of(__reply_base, struct channels_reply_data, base)
19
20 const struct nla_policy ethnl_channels_get_policy[] = {
21         [ETHTOOL_A_CHANNELS_HEADER]             =
22                 NLA_POLICY_NESTED(ethnl_header_policy),
23 };
24
25 static int channels_prepare_data(const struct ethnl_req_info *req_base,
26                                  struct ethnl_reply_data *reply_base,
27                                  struct genl_info *info)
28 {
29         struct channels_reply_data *data = CHANNELS_REPDATA(reply_base);
30         struct net_device *dev = reply_base->dev;
31         int ret;
32
33         if (!dev->ethtool_ops->get_channels)
34                 return -EOPNOTSUPP;
35         ret = ethnl_ops_begin(dev);
36         if (ret < 0)
37                 return ret;
38         dev->ethtool_ops->get_channels(dev, &data->channels);
39         ethnl_ops_complete(dev);
40
41         return 0;
42 }
43
44 static int channels_reply_size(const struct ethnl_req_info *req_base,
45                                const struct ethnl_reply_data *reply_base)
46 {
47         return nla_total_size(sizeof(u32)) +    /* _CHANNELS_RX_MAX */
48                nla_total_size(sizeof(u32)) +    /* _CHANNELS_TX_MAX */
49                nla_total_size(sizeof(u32)) +    /* _CHANNELS_OTHER_MAX */
50                nla_total_size(sizeof(u32)) +    /* _CHANNELS_COMBINED_MAX */
51                nla_total_size(sizeof(u32)) +    /* _CHANNELS_RX_COUNT */
52                nla_total_size(sizeof(u32)) +    /* _CHANNELS_TX_COUNT */
53                nla_total_size(sizeof(u32)) +    /* _CHANNELS_OTHER_COUNT */
54                nla_total_size(sizeof(u32));     /* _CHANNELS_COMBINED_COUNT */
55 }
56
57 static int channels_fill_reply(struct sk_buff *skb,
58                                const struct ethnl_req_info *req_base,
59                                const struct ethnl_reply_data *reply_base)
60 {
61         const struct channels_reply_data *data = CHANNELS_REPDATA(reply_base);
62         const struct ethtool_channels *channels = &data->channels;
63
64         if ((channels->max_rx &&
65              (nla_put_u32(skb, ETHTOOL_A_CHANNELS_RX_MAX,
66                           channels->max_rx) ||
67               nla_put_u32(skb, ETHTOOL_A_CHANNELS_RX_COUNT,
68                           channels->rx_count))) ||
69             (channels->max_tx &&
70              (nla_put_u32(skb, ETHTOOL_A_CHANNELS_TX_MAX,
71                           channels->max_tx) ||
72               nla_put_u32(skb, ETHTOOL_A_CHANNELS_TX_COUNT,
73                           channels->tx_count))) ||
74             (channels->max_other &&
75              (nla_put_u32(skb, ETHTOOL_A_CHANNELS_OTHER_MAX,
76                           channels->max_other) ||
77               nla_put_u32(skb, ETHTOOL_A_CHANNELS_OTHER_COUNT,
78                           channels->other_count))) ||
79             (channels->max_combined &&
80              (nla_put_u32(skb, ETHTOOL_A_CHANNELS_COMBINED_MAX,
81                           channels->max_combined) ||
82               nla_put_u32(skb, ETHTOOL_A_CHANNELS_COMBINED_COUNT,
83                           channels->combined_count))))
84                 return -EMSGSIZE;
85
86         return 0;
87 }
88
89 const struct ethnl_request_ops ethnl_channels_request_ops = {
90         .request_cmd            = ETHTOOL_MSG_CHANNELS_GET,
91         .reply_cmd              = ETHTOOL_MSG_CHANNELS_GET_REPLY,
92         .hdr_attr               = ETHTOOL_A_CHANNELS_HEADER,
93         .req_info_size          = sizeof(struct channels_req_info),
94         .reply_data_size        = sizeof(struct channels_reply_data),
95
96         .prepare_data           = channels_prepare_data,
97         .reply_size             = channels_reply_size,
98         .fill_reply             = channels_fill_reply,
99 };
100
101 /* CHANNELS_SET */
102
103 const struct nla_policy ethnl_channels_set_policy[] = {
104         [ETHTOOL_A_CHANNELS_HEADER]             =
105                 NLA_POLICY_NESTED(ethnl_header_policy),
106         [ETHTOOL_A_CHANNELS_RX_COUNT]           = { .type = NLA_U32 },
107         [ETHTOOL_A_CHANNELS_TX_COUNT]           = { .type = NLA_U32 },
108         [ETHTOOL_A_CHANNELS_OTHER_COUNT]        = { .type = NLA_U32 },
109         [ETHTOOL_A_CHANNELS_COMBINED_COUNT]     = { .type = NLA_U32 },
110 };
111
112 int ethnl_set_channels(struct sk_buff *skb, struct genl_info *info)
113 {
114         unsigned int from_channel, old_total, i;
115         bool mod = false, mod_combined = false;
116         struct ethtool_channels channels = {};
117         struct ethnl_req_info req_info = {};
118         struct nlattr **tb = info->attrs;
119         u32 err_attr, max_rx_in_use = 0;
120         const struct ethtool_ops *ops;
121         struct net_device *dev;
122         int ret;
123
124         ret = ethnl_parse_header_dev_get(&req_info,
125                                          tb[ETHTOOL_A_CHANNELS_HEADER],
126                                          genl_info_net(info), info->extack,
127                                          true);
128         if (ret < 0)
129                 return ret;
130         dev = req_info.dev;
131         ops = dev->ethtool_ops;
132         ret = -EOPNOTSUPP;
133         if (!ops->get_channels || !ops->set_channels)
134                 goto out_dev;
135
136         rtnl_lock();
137         ret = ethnl_ops_begin(dev);
138         if (ret < 0)
139                 goto out_rtnl;
140         ops->get_channels(dev, &channels);
141         old_total = channels.combined_count +
142                     max(channels.rx_count, channels.tx_count);
143
144         ethnl_update_u32(&channels.rx_count, tb[ETHTOOL_A_CHANNELS_RX_COUNT],
145                          &mod);
146         ethnl_update_u32(&channels.tx_count, tb[ETHTOOL_A_CHANNELS_TX_COUNT],
147                          &mod);
148         ethnl_update_u32(&channels.other_count,
149                          tb[ETHTOOL_A_CHANNELS_OTHER_COUNT], &mod);
150         ethnl_update_u32(&channels.combined_count,
151                          tb[ETHTOOL_A_CHANNELS_COMBINED_COUNT], &mod_combined);
152         mod |= mod_combined;
153         ret = 0;
154         if (!mod)
155                 goto out_ops;
156
157         /* ensure new channel counts are within limits */
158         if (channels.rx_count > channels.max_rx)
159                 err_attr = ETHTOOL_A_CHANNELS_RX_COUNT;
160         else if (channels.tx_count > channels.max_tx)
161                 err_attr = ETHTOOL_A_CHANNELS_TX_COUNT;
162         else if (channels.other_count > channels.max_other)
163                 err_attr = ETHTOOL_A_CHANNELS_OTHER_COUNT;
164         else if (channels.combined_count > channels.max_combined)
165                 err_attr = ETHTOOL_A_CHANNELS_COMBINED_COUNT;
166         else
167                 err_attr = 0;
168         if (err_attr) {
169                 ret = -EINVAL;
170                 NL_SET_ERR_MSG_ATTR(info->extack, tb[err_attr],
171                                     "requested channel count exceeds maximum");
172                 goto out_ops;
173         }
174
175         /* ensure there is at least one RX and one TX channel */
176         if (!channels.combined_count && !channels.rx_count)
177                 err_attr = ETHTOOL_A_CHANNELS_RX_COUNT;
178         else if (!channels.combined_count && !channels.tx_count)
179                 err_attr = ETHTOOL_A_CHANNELS_TX_COUNT;
180         else
181                 err_attr = 0;
182         if (err_attr) {
183                 if (mod_combined)
184                         err_attr = ETHTOOL_A_CHANNELS_COMBINED_COUNT;
185                 ret = -EINVAL;
186                 NL_SET_ERR_MSG_ATTR(info->extack, tb[err_attr],
187                                     "requested channel counts would result in no RX or TX channel being configured");
188                 goto out_ops;
189         }
190
191         /* ensure the new Rx count fits within the configured Rx flow
192          * indirection table settings
193          */
194         if (netif_is_rxfh_configured(dev) &&
195             !ethtool_get_max_rxfh_channel(dev, &max_rx_in_use) &&
196             (channels.combined_count + channels.rx_count) <= max_rx_in_use) {
197                 ret = -EINVAL;
198                 GENL_SET_ERR_MSG(info, "requested channel counts are too low for existing indirection table settings");
199                 goto out_ops;
200         }
201
202         /* Disabling channels, query zero-copy AF_XDP sockets */
203         from_channel = channels.combined_count +
204                        min(channels.rx_count, channels.tx_count);
205         for (i = from_channel; i < old_total; i++)
206                 if (xsk_get_pool_from_qid(dev, i)) {
207                         ret = -EINVAL;
208                         GENL_SET_ERR_MSG(info, "requested channel counts are too low for existing zerocopy AF_XDP sockets");
209                         goto out_ops;
210                 }
211
212         ret = dev->ethtool_ops->set_channels(dev, &channels);
213         if (ret < 0)
214                 goto out_ops;
215         ethtool_notify(dev, ETHTOOL_MSG_CHANNELS_NTF, NULL);
216
217 out_ops:
218         ethnl_ops_complete(dev);
219 out_rtnl:
220         rtnl_unlock();
221 out_dev:
222         dev_put(dev);
223         return ret;
224 }