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