1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | |
3 | #include "netlink.h" |
4 | #include "common.h" |
5 | #include "bitset.h" |
6 | |
7 | struct features_req_info { |
8 | struct ethnl_req_info base; |
9 | }; |
10 | |
11 | struct 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 | |
23 | const struct nla_policy ethnl_features_get_policy[] = { |
24 | [ETHTOOL_A_FEATURES_HEADER] = |
25 | NLA_POLICY_NESTED(ethnl_header_policy), |
26 | }; |
27 | |
28 | static 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 | |
36 | static 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(dest: data->hw, src: dev->hw_features); |
45 | ethnl_features_to_bitmap32(dest: data->wanted, src: dev->wanted_features); |
46 | ethnl_features_to_bitmap32(dest: data->active, src: dev->features); |
47 | ethnl_features_to_bitmap32(dest: data->nochange, NETIF_F_NEVER_CHANGE); |
48 | all_features = GENMASK_ULL(NETDEV_FEATURE_COUNT - 1, 0); |
49 | ethnl_features_to_bitmap32(dest: data->all, src: all_features); |
50 | |
51 | return 0; |
52 | } |
53 | |
54 | static 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(val: data->hw, mask: data->all, nbits: NETDEV_FEATURE_COUNT, |
63 | names: netdev_features_strings, compact); |
64 | if (ret < 0) |
65 | return ret; |
66 | len += ret; |
67 | ret = ethnl_bitset32_size(val: data->wanted, NULL, nbits: NETDEV_FEATURE_COUNT, |
68 | names: netdev_features_strings, compact); |
69 | if (ret < 0) |
70 | return ret; |
71 | len += ret; |
72 | ret = ethnl_bitset32_size(val: data->active, NULL, nbits: NETDEV_FEATURE_COUNT, |
73 | names: netdev_features_strings, compact); |
74 | if (ret < 0) |
75 | return ret; |
76 | len += ret; |
77 | ret = ethnl_bitset32_size(val: data->nochange, NULL, nbits: NETDEV_FEATURE_COUNT, |
78 | names: netdev_features_strings, compact); |
79 | if (ret < 0) |
80 | return ret; |
81 | len += ret; |
82 | |
83 | return len; |
84 | } |
85 | |
86 | static 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, attrtype: ETHTOOL_A_FEATURES_HW, val: data->hw, |
95 | mask: data->all, nbits: NETDEV_FEATURE_COUNT, |
96 | names: netdev_features_strings, compact); |
97 | if (ret < 0) |
98 | return ret; |
99 | ret = ethnl_put_bitset32(skb, attrtype: ETHTOOL_A_FEATURES_WANTED, val: data->wanted, |
100 | NULL, nbits: NETDEV_FEATURE_COUNT, |
101 | names: netdev_features_strings, compact); |
102 | if (ret < 0) |
103 | return ret; |
104 | ret = ethnl_put_bitset32(skb, attrtype: ETHTOOL_A_FEATURES_ACTIVE, val: data->active, |
105 | NULL, nbits: NETDEV_FEATURE_COUNT, |
106 | names: netdev_features_strings, compact); |
107 | if (ret < 0) |
108 | return ret; |
109 | return ethnl_put_bitset32(skb, attrtype: ETHTOOL_A_FEATURES_NOCHANGE, |
110 | val: data->nochange, NULL, nbits: NETDEV_FEATURE_COUNT, |
111 | names: netdev_features_strings, compact); |
112 | } |
113 | |
114 | const 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 | |
128 | const 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 | |
134 | static 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 | |
143 | static 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 | |
156 | static 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(val: wanted, mask: wanted_mask, nbits: NETDEV_FEATURE_COUNT, |
169 | names: netdev_features_strings, compact); |
170 | if (ret < 0) |
171 | goto err; |
172 | reply_len += ret; |
173 | ret = ethnl_bitset_size(val: active, mask: active_mask, nbits: NETDEV_FEATURE_COUNT, |
174 | names: netdev_features_strings, compact); |
175 | if (ret < 0) |
176 | goto err; |
177 | reply_len += ret; |
178 | |
179 | ret = -ENOMEM; |
180 | rskb = ethnl_reply_init(payload: reply_len, dev, cmd: ETHTOOL_MSG_FEATURES_SET_REPLY, |
181 | hdr_attrtype: ETHTOOL_A_FEATURES_HEADER, info, |
182 | ehdrp: &reply_payload); |
183 | if (!rskb) |
184 | goto err; |
185 | |
186 | ret = ethnl_put_bitset(skb: rskb, attrtype: ETHTOOL_A_FEATURES_WANTED, val: wanted, |
187 | mask: wanted_mask, nbits: NETDEV_FEATURE_COUNT, |
188 | names: netdev_features_strings, compact); |
189 | if (ret < 0) |
190 | goto nla_put_failure; |
191 | ret = ethnl_put_bitset(skb: rskb, attrtype: ETHTOOL_A_FEATURES_ACTIVE, val: active, |
192 | mask: active_mask, nbits: NETDEV_FEATURE_COUNT, |
193 | names: netdev_features_strings, compact); |
194 | if (ret < 0) |
195 | goto nla_put_failure; |
196 | |
197 | genlmsg_end(skb: rskb, hdr: reply_payload); |
198 | ret = genlmsg_reply(skb: rskb, info); |
199 | return ret; |
200 | |
201 | nla_put_failure: |
202 | nlmsg_free(skb: rskb); |
203 | WARN_ONCE(1, "calculated message payload length (%d) not sufficient\n" , |
204 | reply_len); |
205 | err: |
206 | GENL_SET_ERR_MSG(info, "failed to send reply message" ); |
207 | return ret; |
208 | } |
209 | |
210 | int 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: &req_info, |
229 | nest: tb[ETHTOOL_A_FEATURES_HEADER], |
230 | net: genl_info_net(info), extack: info->extack, |
231 | require_dev: 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(dest: old_active, val: dev->features); |
241 | ethnl_features_to_bitmap(dest: old_wanted, val: dev->wanted_features); |
242 | ret = ethnl_parse_bitset(val: req_wanted, mask: req_mask, nbits: NETDEV_FEATURE_COUNT, |
243 | attr: tb[ETHTOOL_A_FEATURES_WANTED], |
244 | names: netdev_features_strings, extack: info->extack); |
245 | if (ret < 0) |
246 | goto out_ops; |
247 | if (ethnl_bitmap_to_features(src: 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(dst: req_wanted, src1: req_wanted, src2: req_mask, nbits: NETDEV_FEATURE_COUNT); |
255 | bitmap_andnot(dst: new_wanted, src1: old_wanted, src2: req_mask, nbits: NETDEV_FEATURE_COUNT); |
256 | bitmap_or(dst: req_wanted, src1: new_wanted, src2: req_wanted, nbits: NETDEV_FEATURE_COUNT); |
257 | if (!bitmap_equal(src1: req_wanted, src2: old_wanted, nbits: NETDEV_FEATURE_COUNT)) { |
258 | dev->wanted_features &= ~dev->hw_features; |
259 | dev->wanted_features |= ethnl_bitmap_to_features(src: req_wanted) & dev->hw_features; |
260 | __netdev_update_features(dev); |
261 | } |
262 | ethnl_features_to_bitmap(dest: new_active, val: dev->features); |
263 | mod = !bitmap_equal(src1: old_active, src2: new_active, nbits: 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(dst: wanted_diff_mask, src1: req_wanted, src2: new_active, |
270 | nbits: NETDEV_FEATURE_COUNT); |
271 | bitmap_xor(dst: active_diff_mask, src1: old_active, src2: new_active, |
272 | nbits: NETDEV_FEATURE_COUNT); |
273 | bitmap_and(dst: wanted_diff_mask, src1: wanted_diff_mask, src2: req_mask, |
274 | nbits: NETDEV_FEATURE_COUNT); |
275 | bitmap_and(dst: req_wanted, src1: req_wanted, src2: wanted_diff_mask, |
276 | nbits: NETDEV_FEATURE_COUNT); |
277 | bitmap_and(dst: new_active, src1: new_active, src2: active_diff_mask, |
278 | nbits: NETDEV_FEATURE_COUNT); |
279 | |
280 | ret = features_send_reply(dev, info, wanted: req_wanted, |
281 | wanted_mask: wanted_diff_mask, active: new_active, |
282 | active_mask: active_diff_mask, compact); |
283 | } |
284 | if (mod) |
285 | netdev_features_change(dev); |
286 | |
287 | out_ops: |
288 | ethnl_ops_complete(dev); |
289 | out_rtnl: |
290 | rtnl_unlock(); |
291 | ethnl_parse_header_dev_put(req_info: &req_info); |
292 | return ret; |
293 | } |
294 | |