projects/linux·blob master · refs

297 lines · 9.0 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2
3#include <net/netdev_lock.h>
4
5#include "bitset.h"
6#include "common.h"
7#include "netlink.h"
8
9struct features_req_info {
10 struct ethnl_req_info base;
11};
12
13struct features_reply_data {
14 struct ethnl_reply_data base;
15 u32 hw[ETHTOOL_DEV_FEATURE_WORDS];
16 u32 wanted[ETHTOOL_DEV_FEATURE_WORDS];
17 u32 active[ETHTOOL_DEV_FEATURE_WORDS];
18 u32 nochange[ETHTOOL_DEV_FEATURE_WORDS];
19 u32 all[ETHTOOL_DEV_FEATURE_WORDS];
20};
21
22#define FEATURES_REPDATA(__reply_base) \
23 container_of(__reply_base, struct features_reply_data, base)
24
25const struct nla_policy ethnl_features_get_policy[] = {
26 [ETHTOOL_A_FEATURES_HEADER] =
27 NLA_POLICY_NESTED(ethnl_header_policy),
28};
29
30static void ethnl_features_to_bitmap32(u32 *dest, netdev_features_t src)
31{
32 unsigned int i;
33
34 for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; i++)
35 dest[i] = src >> (32 * i);
36}
37
38static int features_prepare_data(const struct ethnl_req_info *req_base,
39 struct ethnl_reply_data *reply_base,
40 const struct genl_info *info)
41{
42 struct features_reply_data *data = FEATURES_REPDATA(reply_base);
43 struct net_device *dev = reply_base->dev;
44 netdev_features_t all_features;
45
46 ethnl_features_to_bitmap32(data->hw, dev->hw_features);
47 ethnl_features_to_bitmap32(data->wanted, dev->wanted_features);
48 ethnl_features_to_bitmap32(data->active, dev->features);
49 ethnl_features_to_bitmap32(data->nochange, NETIF_F_NEVER_CHANGE);
50 all_features = GENMASK_ULL(NETDEV_FEATURE_COUNT - 1, 0);
51 ethnl_features_to_bitmap32(data->all, all_features);
52
53 return 0;
54}
55
56static int features_reply_size(const struct ethnl_req_info *req_base,
57 const struct ethnl_reply_data *reply_base)
58{
59 const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
60 bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
61 unsigned int len = 0;
62 int ret;
63
64 ret = ethnl_bitset32_size(data->hw, data->all, NETDEV_FEATURE_COUNT,
65 netdev_features_strings, compact);
66 if (ret < 0)
67 return ret;
68 len += ret;
69 ret = ethnl_bitset32_size(data->wanted, NULL, NETDEV_FEATURE_COUNT,
70 netdev_features_strings, compact);
71 if (ret < 0)
72 return ret;
73 len += ret;
74 ret = ethnl_bitset32_size(data->active, NULL, NETDEV_FEATURE_COUNT,
75 netdev_features_strings, compact);
76 if (ret < 0)
77 return ret;
78 len += ret;
79 ret = ethnl_bitset32_size(data->nochange, NULL, NETDEV_FEATURE_COUNT,
80 netdev_features_strings, compact);
81 if (ret < 0)
82 return ret;
83 len += ret;
84
85 return len;
86}
87
88static int features_fill_reply(struct sk_buff *skb,
89 const struct ethnl_req_info *req_base,
90 const struct ethnl_reply_data *reply_base)
91{
92 const struct features_reply_data *data = FEATURES_REPDATA(reply_base);
93 bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
94 int ret;
95
96 ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_HW, data->hw,
97 data->all, NETDEV_FEATURE_COUNT,
98 netdev_features_strings, compact);
99 if (ret < 0)
100 return ret;
101 ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_WANTED, data->wanted,
102 NULL, NETDEV_FEATURE_COUNT,
103 netdev_features_strings, compact);
104 if (ret < 0)
105 return ret;
106 ret = ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_ACTIVE, data->active,
107 NULL, NETDEV_FEATURE_COUNT,
108 netdev_features_strings, compact);
109 if (ret < 0)
110 return ret;
111 return ethnl_put_bitset32(skb, ETHTOOL_A_FEATURES_NOCHANGE,
112 data->nochange, NULL, NETDEV_FEATURE_COUNT,
113 netdev_features_strings, compact);
114}
115
116const struct ethnl_request_ops ethnl_features_request_ops = {
117 .request_cmd = ETHTOOL_MSG_FEATURES_GET,
118 .reply_cmd = ETHTOOL_MSG_FEATURES_GET_REPLY,
119 .hdr_attr = ETHTOOL_A_FEATURES_HEADER,
120 .req_info_size = sizeof(struct features_req_info),
121 .reply_data_size = sizeof(struct features_reply_data),
122
123 .prepare_data = features_prepare_data,
124 .reply_size = features_reply_size,
125 .fill_reply = features_fill_reply,
126};
127
128/* FEATURES_SET */
129
130const struct nla_policy ethnl_features_set_policy[] = {
131 [ETHTOOL_A_FEATURES_HEADER] =
132 NLA_POLICY_NESTED(ethnl_header_policy),
133 [ETHTOOL_A_FEATURES_WANTED] = { .type = NLA_NESTED },
134};
135
136static void ethnl_features_to_bitmap(unsigned long *dest, netdev_features_t val)
137{
138 const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
139 unsigned int i;
140
141 for (i = 0; i < words; i++)
142 dest[i] = (unsigned long)(val >> (i * BITS_PER_LONG));
143}
144
145static netdev_features_t ethnl_bitmap_to_features(unsigned long *src)
146{
147 const unsigned int nft_bits = sizeof(netdev_features_t) * BITS_PER_BYTE;
148 const unsigned int words = BITS_TO_LONGS(NETDEV_FEATURE_COUNT);
149 netdev_features_t ret = 0;
150 unsigned int i;
151
152 for (i = 0; i < words; i++)
153 ret |= (netdev_features_t)(src[i]) << (i * BITS_PER_LONG);
154 ret &= ~(netdev_features_t)0 >> (nft_bits - NETDEV_FEATURE_COUNT);
155 return ret;
156}
157
158static int features_send_reply(struct net_device *dev, struct genl_info *info,
159 const unsigned long *wanted,
160 const unsigned long *wanted_mask,
161 const unsigned long *active,
162 const unsigned long *active_mask, bool compact)
163{
164 struct sk_buff *rskb;
165 void *reply_payload;
166 int reply_len = 0;
167 int ret;
168
169 reply_len = ethnl_reply_header_size();
170 ret = ethnl_bitset_size(wanted, wanted_mask, NETDEV_FEATURE_COUNT,
171 netdev_features_strings, compact);
172 if (ret < 0)
173 goto err;
174 reply_len += ret;
175 ret = ethnl_bitset_size(active, active_mask, NETDEV_FEATURE_COUNT,
176 netdev_features_strings, compact);
177 if (ret < 0)
178 goto err;
179 reply_len += ret;
180
181 ret = -ENOMEM;
182 rskb = ethnl_reply_init(reply_len, dev, ETHTOOL_MSG_FEATURES_SET_REPLY,
183 ETHTOOL_A_FEATURES_HEADER, info,
184 &reply_payload);
185 if (!rskb)
186 goto err;
187
188 ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_WANTED, wanted,
189 wanted_mask, NETDEV_FEATURE_COUNT,
190 netdev_features_strings, compact);
191 if (ret < 0)
192 goto nla_put_failure;
193 ret = ethnl_put_bitset(rskb, ETHTOOL_A_FEATURES_ACTIVE, active,
194 active_mask, NETDEV_FEATURE_COUNT,
195 netdev_features_strings, compact);
196 if (ret < 0)
197 goto nla_put_failure;
198
199 genlmsg_end(rskb, reply_payload);
200 ret = genlmsg_reply(rskb, info);
201 return ret;
202
203nla_put_failure:
204 nlmsg_free(rskb);
205 WARN_ONCE(1, "calculated message payload length (%d) not sufficient\n",
206 reply_len);
207err:
208 GENL_SET_ERR_MSG(info, "failed to send reply message");
209 return ret;
210}
211
212int ethnl_set_features(struct sk_buff *skb, struct genl_info *info)
213{
214 DECLARE_BITMAP(wanted_diff_mask, NETDEV_FEATURE_COUNT);
215 DECLARE_BITMAP(active_diff_mask, NETDEV_FEATURE_COUNT);
216 DECLARE_BITMAP(old_active, NETDEV_FEATURE_COUNT);
217 DECLARE_BITMAP(old_wanted, NETDEV_FEATURE_COUNT);
218 DECLARE_BITMAP(new_active, NETDEV_FEATURE_COUNT);
219 DECLARE_BITMAP(new_wanted, NETDEV_FEATURE_COUNT);
220 DECLARE_BITMAP(req_wanted, NETDEV_FEATURE_COUNT);
221 DECLARE_BITMAP(req_mask, NETDEV_FEATURE_COUNT);
222 struct ethnl_req_info req_info = {};
223 struct nlattr **tb = info->attrs;
224 struct net_device *dev;
225 bool mod;
226 int ret;
227
228 if (!tb[ETHTOOL_A_FEATURES_WANTED])
229 return -EINVAL;
230 ret = ethnl_parse_header_dev_get(&req_info,
231 tb[ETHTOOL_A_FEATURES_HEADER],
232 genl_info_net(info), info->extack,
233 true);
234 if (ret < 0)
235 return ret;
236 dev = req_info.dev;
237
238 rtnl_lock();
239 netdev_lock_ops(dev);
240 ret = ethnl_ops_begin(dev);
241 if (ret < 0)
242 goto out_unlock;
243 ethnl_features_to_bitmap(old_active, dev->features);
244 ethnl_features_to_bitmap(old_wanted, dev->wanted_features);
245 ret = ethnl_parse_bitset(req_wanted, req_mask, NETDEV_FEATURE_COUNT,
246 tb[ETHTOOL_A_FEATURES_WANTED],
247 netdev_features_strings, info->extack);
248 if (ret < 0)
249 goto out_ops;
250 if (ethnl_bitmap_to_features(req_mask) & ~NETIF_F_ETHTOOL_BITS) {
251 GENL_SET_ERR_MSG(info, "attempt to change non-ethtool features");
252 ret = -EINVAL;
253 goto out_ops;
254 }
255
256 /* set req_wanted bits not in req_mask from old_wanted */
257 bitmap_and(req_wanted, req_wanted, req_mask, NETDEV_FEATURE_COUNT);
258 bitmap_andnot(new_wanted, old_wanted, req_mask, NETDEV_FEATURE_COUNT);
259 bitmap_or(req_wanted, new_wanted, req_wanted, NETDEV_FEATURE_COUNT);
260 if (!bitmap_equal(req_wanted, old_wanted, NETDEV_FEATURE_COUNT)) {
261 dev->wanted_features &= ~dev->hw_features;
262 dev->wanted_features |= ethnl_bitmap_to_features(req_wanted) & dev->hw_features;
263 __netdev_update_features(dev);
264 }
265 ethnl_features_to_bitmap(new_active, dev->features);
266 mod = !bitmap_equal(old_active, new_active, NETDEV_FEATURE_COUNT);
267
268 ret = 0;
269 if (!(req_info.flags & ETHTOOL_FLAG_OMIT_REPLY)) {
270 bool compact = req_info.flags & ETHTOOL_FLAG_COMPACT_BITSETS;
271
272 bitmap_xor(wanted_diff_mask, req_wanted, new_active,
273 NETDEV_FEATURE_COUNT);
274 bitmap_xor(active_diff_mask, old_active, new_active,
275 NETDEV_FEATURE_COUNT);
276 bitmap_and(wanted_diff_mask, wanted_diff_mask, req_mask,
277 NETDEV_FEATURE_COUNT);
278 bitmap_and(req_wanted, req_wanted, wanted_diff_mask,
279 NETDEV_FEATURE_COUNT);
280 bitmap_and(new_active, new_active, active_diff_mask,
281 NETDEV_FEATURE_COUNT);
282
283 ret = features_send_reply(dev, info, req_wanted,
284 wanted_diff_mask, new_active,
285 active_diff_mask, compact);
286 }
287 if (mod)
288 netdev_features_change(dev);
289
290out_ops:
291 ethnl_ops_complete(dev);
292out_unlock:
293 netdev_unlock_ops(dev);
294 rtnl_unlock();
295 ethnl_parse_header_dev_put(&req_info);
296 return ret;
297}