1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved. |
3 | * |
4 | * RMNET Data virtual network driver |
5 | */ |
6 | |
7 | #include <linux/etherdevice.h> |
8 | #include <linux/ethtool.h> |
9 | #include <linux/if_arp.h> |
10 | #include <net/pkt_sched.h> |
11 | #include "rmnet_config.h" |
12 | #include "rmnet_handlers.h" |
13 | #include "rmnet_private.h" |
14 | #include "rmnet_map.h" |
15 | #include "rmnet_vnd.h" |
16 | |
17 | /* RX/TX Fixup */ |
18 | |
19 | void rmnet_vnd_rx_fixup(struct sk_buff *skb, struct net_device *dev) |
20 | { |
21 | struct rmnet_priv *priv = netdev_priv(dev); |
22 | struct rmnet_pcpu_stats *pcpu_ptr; |
23 | |
24 | pcpu_ptr = this_cpu_ptr(priv->pcpu_stats); |
25 | |
26 | u64_stats_update_begin(syncp: &pcpu_ptr->syncp); |
27 | pcpu_ptr->stats.rx_pkts++; |
28 | pcpu_ptr->stats.rx_bytes += skb->len; |
29 | u64_stats_update_end(syncp: &pcpu_ptr->syncp); |
30 | } |
31 | |
32 | void rmnet_vnd_tx_fixup_len(unsigned int len, struct net_device *dev) |
33 | { |
34 | struct rmnet_priv *priv = netdev_priv(dev); |
35 | struct rmnet_pcpu_stats *pcpu_ptr; |
36 | |
37 | pcpu_ptr = this_cpu_ptr(priv->pcpu_stats); |
38 | |
39 | u64_stats_update_begin(syncp: &pcpu_ptr->syncp); |
40 | pcpu_ptr->stats.tx_pkts++; |
41 | pcpu_ptr->stats.tx_bytes += len; |
42 | u64_stats_update_end(syncp: &pcpu_ptr->syncp); |
43 | } |
44 | |
45 | void rmnet_vnd_tx_fixup(struct sk_buff *skb, struct net_device *dev) |
46 | { |
47 | rmnet_vnd_tx_fixup_len(len: skb->len, dev); |
48 | } |
49 | |
50 | /* Network Device Operations */ |
51 | |
52 | static netdev_tx_t rmnet_vnd_start_xmit(struct sk_buff *skb, |
53 | struct net_device *dev) |
54 | { |
55 | struct rmnet_priv *priv; |
56 | |
57 | priv = netdev_priv(dev); |
58 | if (priv->real_dev) { |
59 | rmnet_egress_handler(skb); |
60 | } else { |
61 | this_cpu_inc(priv->pcpu_stats->stats.tx_drops); |
62 | kfree_skb(skb); |
63 | } |
64 | return NETDEV_TX_OK; |
65 | } |
66 | |
67 | static int rmnet_vnd_headroom(struct rmnet_port *port) |
68 | { |
69 | u32 headroom; |
70 | |
71 | headroom = sizeof(struct rmnet_map_header); |
72 | |
73 | if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV4) |
74 | headroom += sizeof(struct rmnet_map_ul_csum_header); |
75 | |
76 | return headroom; |
77 | } |
78 | |
79 | static int rmnet_vnd_change_mtu(struct net_device *rmnet_dev, int new_mtu) |
80 | { |
81 | struct rmnet_priv *priv = netdev_priv(dev: rmnet_dev); |
82 | struct rmnet_port *port; |
83 | u32 headroom; |
84 | |
85 | port = rmnet_get_port_rtnl(real_dev: priv->real_dev); |
86 | |
87 | headroom = rmnet_vnd_headroom(port); |
88 | |
89 | if (new_mtu < 0 || new_mtu > RMNET_MAX_PACKET_SIZE || |
90 | new_mtu > (priv->real_dev->mtu - headroom)) |
91 | return -EINVAL; |
92 | |
93 | rmnet_dev->mtu = new_mtu; |
94 | return 0; |
95 | } |
96 | |
97 | static int rmnet_vnd_get_iflink(const struct net_device *dev) |
98 | { |
99 | struct rmnet_priv *priv = netdev_priv(dev); |
100 | |
101 | return READ_ONCE(priv->real_dev->ifindex); |
102 | } |
103 | |
104 | static int rmnet_vnd_init(struct net_device *dev) |
105 | { |
106 | struct rmnet_priv *priv = netdev_priv(dev); |
107 | int err; |
108 | |
109 | priv->pcpu_stats = alloc_percpu(struct rmnet_pcpu_stats); |
110 | if (!priv->pcpu_stats) |
111 | return -ENOMEM; |
112 | |
113 | err = gro_cells_init(gcells: &priv->gro_cells, dev); |
114 | if (err) { |
115 | free_percpu(pdata: priv->pcpu_stats); |
116 | return err; |
117 | } |
118 | |
119 | return 0; |
120 | } |
121 | |
122 | static void rmnet_vnd_uninit(struct net_device *dev) |
123 | { |
124 | struct rmnet_priv *priv = netdev_priv(dev); |
125 | |
126 | gro_cells_destroy(gcells: &priv->gro_cells); |
127 | free_percpu(pdata: priv->pcpu_stats); |
128 | } |
129 | |
130 | static void rmnet_get_stats64(struct net_device *dev, |
131 | struct rtnl_link_stats64 *s) |
132 | { |
133 | struct rmnet_priv *priv = netdev_priv(dev); |
134 | struct rmnet_vnd_stats total_stats = { }; |
135 | struct rmnet_pcpu_stats *pcpu_ptr; |
136 | struct rmnet_vnd_stats snapshot; |
137 | unsigned int cpu, start; |
138 | |
139 | for_each_possible_cpu(cpu) { |
140 | pcpu_ptr = per_cpu_ptr(priv->pcpu_stats, cpu); |
141 | |
142 | do { |
143 | start = u64_stats_fetch_begin(syncp: &pcpu_ptr->syncp); |
144 | snapshot = pcpu_ptr->stats; /* struct assignment */ |
145 | } while (u64_stats_fetch_retry(syncp: &pcpu_ptr->syncp, start)); |
146 | |
147 | total_stats.rx_pkts += snapshot.rx_pkts; |
148 | total_stats.rx_bytes += snapshot.rx_bytes; |
149 | total_stats.tx_pkts += snapshot.tx_pkts; |
150 | total_stats.tx_bytes += snapshot.tx_bytes; |
151 | total_stats.tx_drops += snapshot.tx_drops; |
152 | } |
153 | |
154 | s->rx_packets = total_stats.rx_pkts; |
155 | s->rx_bytes = total_stats.rx_bytes; |
156 | s->tx_packets = total_stats.tx_pkts; |
157 | s->tx_bytes = total_stats.tx_bytes; |
158 | s->tx_dropped = total_stats.tx_drops; |
159 | } |
160 | |
161 | static const struct net_device_ops rmnet_vnd_ops = { |
162 | .ndo_start_xmit = rmnet_vnd_start_xmit, |
163 | .ndo_change_mtu = rmnet_vnd_change_mtu, |
164 | .ndo_get_iflink = rmnet_vnd_get_iflink, |
165 | .ndo_add_slave = rmnet_add_bridge, |
166 | .ndo_del_slave = rmnet_del_bridge, |
167 | .ndo_init = rmnet_vnd_init, |
168 | .ndo_uninit = rmnet_vnd_uninit, |
169 | .ndo_get_stats64 = rmnet_get_stats64, |
170 | }; |
171 | |
172 | static const char rmnet_gstrings_stats[][ETH_GSTRING_LEN] = { |
173 | "Checksum ok" , |
174 | "Bad IPv4 header checksum" , |
175 | "Checksum valid bit not set" , |
176 | "Checksum validation failed" , |
177 | "Checksum error bad buffer" , |
178 | "Checksum error bad ip version" , |
179 | "Checksum error bad transport" , |
180 | "Checksum skipped on ip fragment" , |
181 | "Checksum skipped" , |
182 | "Checksum computed in software" , |
183 | "Checksum computed in hardware" , |
184 | }; |
185 | |
186 | static void rmnet_get_strings(struct net_device *dev, u32 stringset, u8 *buf) |
187 | { |
188 | switch (stringset) { |
189 | case ETH_SS_STATS: |
190 | memcpy(buf, &rmnet_gstrings_stats, |
191 | sizeof(rmnet_gstrings_stats)); |
192 | break; |
193 | } |
194 | } |
195 | |
196 | static int rmnet_get_sset_count(struct net_device *dev, int sset) |
197 | { |
198 | switch (sset) { |
199 | case ETH_SS_STATS: |
200 | return ARRAY_SIZE(rmnet_gstrings_stats); |
201 | default: |
202 | return -EOPNOTSUPP; |
203 | } |
204 | } |
205 | |
206 | static void rmnet_get_ethtool_stats(struct net_device *dev, |
207 | struct ethtool_stats *stats, u64 *data) |
208 | { |
209 | struct rmnet_priv *priv = netdev_priv(dev); |
210 | struct rmnet_priv_stats *st = &priv->stats; |
211 | |
212 | if (!data) |
213 | return; |
214 | |
215 | memcpy(data, st, ARRAY_SIZE(rmnet_gstrings_stats) * sizeof(u64)); |
216 | } |
217 | |
218 | static int rmnet_get_coalesce(struct net_device *dev, |
219 | struct ethtool_coalesce *coal, |
220 | struct kernel_ethtool_coalesce *kernel_coal, |
221 | struct netlink_ext_ack *extack) |
222 | { |
223 | struct rmnet_priv *priv = netdev_priv(dev); |
224 | struct rmnet_port *port; |
225 | |
226 | port = rmnet_get_port_rtnl(real_dev: priv->real_dev); |
227 | |
228 | memset(kernel_coal, 0, sizeof(*kernel_coal)); |
229 | kernel_coal->tx_aggr_max_bytes = port->egress_agg_params.bytes; |
230 | kernel_coal->tx_aggr_max_frames = port->egress_agg_params.count; |
231 | kernel_coal->tx_aggr_time_usecs = div_u64(dividend: port->egress_agg_params.time_nsec, |
232 | NSEC_PER_USEC); |
233 | |
234 | return 0; |
235 | } |
236 | |
237 | static int rmnet_set_coalesce(struct net_device *dev, |
238 | struct ethtool_coalesce *coal, |
239 | struct kernel_ethtool_coalesce *kernel_coal, |
240 | struct netlink_ext_ack *extack) |
241 | { |
242 | struct rmnet_priv *priv = netdev_priv(dev); |
243 | struct rmnet_port *port; |
244 | |
245 | port = rmnet_get_port_rtnl(real_dev: priv->real_dev); |
246 | |
247 | if (kernel_coal->tx_aggr_max_frames < 1 || kernel_coal->tx_aggr_max_frames > 64) |
248 | return -EINVAL; |
249 | |
250 | if (kernel_coal->tx_aggr_max_bytes > 32768) |
251 | return -EINVAL; |
252 | |
253 | rmnet_map_update_ul_agg_config(port, size: kernel_coal->tx_aggr_max_bytes, |
254 | count: kernel_coal->tx_aggr_max_frames, |
255 | time: kernel_coal->tx_aggr_time_usecs); |
256 | |
257 | return 0; |
258 | } |
259 | |
260 | static const struct ethtool_ops rmnet_ethtool_ops = { |
261 | .supported_coalesce_params = ETHTOOL_COALESCE_TX_AGGR, |
262 | .get_coalesce = rmnet_get_coalesce, |
263 | .set_coalesce = rmnet_set_coalesce, |
264 | .get_ethtool_stats = rmnet_get_ethtool_stats, |
265 | .get_strings = rmnet_get_strings, |
266 | .get_sset_count = rmnet_get_sset_count, |
267 | }; |
268 | |
269 | /* Called by kernel whenever a new rmnet<n> device is created. Sets MTU, |
270 | * flags, ARP type, needed headroom, etc... |
271 | */ |
272 | void rmnet_vnd_setup(struct net_device *rmnet_dev) |
273 | { |
274 | rmnet_dev->netdev_ops = &rmnet_vnd_ops; |
275 | rmnet_dev->mtu = RMNET_DFLT_PACKET_SIZE; |
276 | rmnet_dev->needed_headroom = RMNET_NEEDED_HEADROOM; |
277 | eth_hw_addr_random(dev: rmnet_dev); |
278 | rmnet_dev->tx_queue_len = RMNET_TX_QUEUE_LEN; |
279 | |
280 | /* Raw IP mode */ |
281 | rmnet_dev->header_ops = NULL; /* No header */ |
282 | rmnet_dev->type = ARPHRD_RAWIP; |
283 | rmnet_dev->hard_header_len = 0; |
284 | rmnet_dev->flags &= ~(IFF_BROADCAST | IFF_MULTICAST); |
285 | |
286 | rmnet_dev->needs_free_netdev = true; |
287 | rmnet_dev->ethtool_ops = &rmnet_ethtool_ops; |
288 | |
289 | rmnet_dev->features |= NETIF_F_LLTX; |
290 | |
291 | /* This perm addr will be used as interface identifier by IPv6 */ |
292 | rmnet_dev->addr_assign_type = NET_ADDR_RANDOM; |
293 | eth_random_addr(addr: rmnet_dev->perm_addr); |
294 | } |
295 | |
296 | /* Exposed API */ |
297 | |
298 | int rmnet_vnd_newlink(u8 id, struct net_device *rmnet_dev, |
299 | struct rmnet_port *port, |
300 | struct net_device *real_dev, |
301 | struct rmnet_endpoint *ep, |
302 | struct netlink_ext_ack *extack) |
303 | |
304 | { |
305 | struct rmnet_priv *priv = netdev_priv(dev: rmnet_dev); |
306 | u32 headroom; |
307 | int rc; |
308 | |
309 | if (rmnet_get_endpoint(port, mux_id: id)) { |
310 | NL_SET_ERR_MSG_MOD(extack, "MUX ID already exists" ); |
311 | return -EBUSY; |
312 | } |
313 | |
314 | rmnet_dev->hw_features = NETIF_F_RXCSUM; |
315 | rmnet_dev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; |
316 | rmnet_dev->hw_features |= NETIF_F_SG; |
317 | |
318 | priv->real_dev = real_dev; |
319 | |
320 | headroom = rmnet_vnd_headroom(port); |
321 | |
322 | if (rmnet_vnd_change_mtu(rmnet_dev, new_mtu: real_dev->mtu - headroom)) { |
323 | NL_SET_ERR_MSG_MOD(extack, "Invalid MTU on real dev" ); |
324 | return -EINVAL; |
325 | } |
326 | |
327 | rc = register_netdevice(dev: rmnet_dev); |
328 | if (!rc) { |
329 | ep->egress_dev = rmnet_dev; |
330 | ep->mux_id = id; |
331 | port->nr_rmnet_devs++; |
332 | |
333 | rmnet_dev->rtnl_link_ops = &rmnet_link_ops; |
334 | |
335 | priv->mux_id = id; |
336 | |
337 | netdev_dbg(rmnet_dev, "rmnet dev created\n" ); |
338 | } |
339 | |
340 | return rc; |
341 | } |
342 | |
343 | int rmnet_vnd_dellink(u8 id, struct rmnet_port *port, |
344 | struct rmnet_endpoint *ep) |
345 | { |
346 | if (id >= RMNET_MAX_LOGICAL_EP || !ep->egress_dev) |
347 | return -EINVAL; |
348 | |
349 | ep->egress_dev = NULL; |
350 | port->nr_rmnet_devs--; |
351 | return 0; |
352 | } |
353 | |
354 | int rmnet_vnd_do_flow_control(struct net_device *rmnet_dev, int enable) |
355 | { |
356 | netdev_dbg(rmnet_dev, "Setting VND TX queue state to %d\n" , enable); |
357 | /* Although we expect similar number of enable/disable |
358 | * commands, optimize for the disable. That is more |
359 | * latency sensitive than enable |
360 | */ |
361 | if (unlikely(enable)) |
362 | netif_wake_queue(dev: rmnet_dev); |
363 | else |
364 | netif_stop_queue(dev: rmnet_dev); |
365 | |
366 | return 0; |
367 | } |
368 | |
369 | int rmnet_vnd_validate_real_dev_mtu(struct net_device *real_dev) |
370 | { |
371 | struct hlist_node *tmp_ep; |
372 | struct rmnet_endpoint *ep; |
373 | struct rmnet_port *port; |
374 | unsigned long bkt_ep; |
375 | u32 headroom; |
376 | |
377 | port = rmnet_get_port_rtnl(real_dev); |
378 | |
379 | headroom = rmnet_vnd_headroom(port); |
380 | |
381 | hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) { |
382 | if (ep->egress_dev->mtu > (real_dev->mtu - headroom)) |
383 | return -1; |
384 | } |
385 | |
386 | return 0; |
387 | } |
388 | |
389 | int rmnet_vnd_update_dev_mtu(struct rmnet_port *port, |
390 | struct net_device *real_dev) |
391 | { |
392 | struct hlist_node *tmp_ep; |
393 | struct rmnet_endpoint *ep; |
394 | unsigned long bkt_ep; |
395 | u32 headroom; |
396 | |
397 | headroom = rmnet_vnd_headroom(port); |
398 | |
399 | hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) { |
400 | if (ep->egress_dev->mtu <= (real_dev->mtu - headroom)) |
401 | continue; |
402 | |
403 | if (rmnet_vnd_change_mtu(rmnet_dev: ep->egress_dev, |
404 | new_mtu: real_dev->mtu - headroom)) |
405 | return -1; |
406 | } |
407 | |
408 | return 0; |
409 | } |
410 | |