xref: /linux/drivers/net/can/dev/skb.c (revision b4ebcbbf66ba6c5816dfe229effb4641c46e4b4c)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (C) 2005 Marc Kleine-Budde, Pengutronix
3  * Copyright (C) 2006 Andrey Volkov, Varma Electronics
4  * Copyright (C) 2008-2009 Wolfgang Grandegger <wg@grandegger.com>
5  */
6 
7 #include <linux/can/can-ml.h>
8 #include <linux/can/dev.h>
9 #include <linux/module.h>
10 #include <net/can.h>
11 
12 #define MOD_DESC "CAN device driver interface"
13 
14 MODULE_DESCRIPTION(MOD_DESC);
15 MODULE_LICENSE("GPL v2");
16 MODULE_AUTHOR("Wolfgang Grandegger <wg@grandegger.com>");
17 
18 /* Local echo of CAN messages
19  *
20  * CAN network devices *should* support a local echo functionality
21  * (see Documentation/networking/can.rst). To test the handling of CAN
22  * interfaces that do not support the local echo both driver types are
23  * implemented. In the case that the driver does not support the echo
24  * the IFF_ECHO remains clear in dev->flags. This causes the PF_CAN core
25  * to perform the echo as a fallback solution.
26  */
27 void can_flush_echo_skb(struct net_device *dev)
28 {
29 	struct can_priv *priv = netdev_priv(dev);
30 	struct net_device_stats *stats = &dev->stats;
31 	int i;
32 
33 	for (i = 0; i < priv->echo_skb_max; i++) {
34 		if (priv->echo_skb[i]) {
35 			kfree_skb(priv->echo_skb[i]);
36 			priv->echo_skb[i] = NULL;
37 			stats->tx_dropped++;
38 			stats->tx_aborted_errors++;
39 		}
40 	}
41 }
42 
43 /* Put the skb on the stack to be looped backed locally lateron
44  *
45  * The function is typically called in the start_xmit function
46  * of the device driver. The driver must protect access to
47  * priv->echo_skb, if necessary.
48  */
49 int can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
50 		     unsigned int idx, unsigned int frame_len)
51 {
52 	struct can_priv *priv = netdev_priv(dev);
53 	struct can_skb_ext *csx;
54 
55 	if (idx >= priv->echo_skb_max) {
56 		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
57 			   __func__, idx, priv->echo_skb_max);
58 		dev_kfree_skb_any(skb);
59 		return -EINVAL;
60 	}
61 
62 	/* check flag whether this packet has to be looped back */
63 	if (!(dev->flags & IFF_ECHO) ||
64 	    (skb->protocol != htons(ETH_P_CAN) &&
65 	     skb->protocol != htons(ETH_P_CANFD) &&
66 	     skb->protocol != htons(ETH_P_CANXL))) {
67 		dev_kfree_skb_any(skb);
68 		return 0;
69 	}
70 
71 	if (!priv->echo_skb[idx]) {
72 		skb = can_create_echo_skb(skb);
73 		if (!skb)
74 			return -ENOMEM;
75 
76 		/* make settings for echo to reduce code in irq context */
77 		skb->ip_summed = CHECKSUM_UNNECESSARY;
78 		skb->dev = dev;
79 
80 		/* save frame_len to reuse it when transmission is completed */
81 		csx = can_skb_ext_find(skb);
82 		if (csx)
83 			csx->can_framelen = frame_len;
84 
85 		if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)
86 			skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
87 
88 		skb_tx_timestamp(skb);
89 
90 		/* save this skb for tx interrupt echo handling */
91 		priv->echo_skb[idx] = skb;
92 	} else {
93 		/* locking problem with netif_stop_queue() ?? */
94 		netdev_err(dev, "%s: BUG! echo_skb %d is occupied!\n", __func__, idx);
95 		dev_kfree_skb_any(skb);
96 		return -EBUSY;
97 	}
98 
99 	return 0;
100 }
101 EXPORT_SYMBOL_GPL(can_put_echo_skb);
102 
103 struct sk_buff *
104 __can_get_echo_skb(struct net_device *dev, unsigned int idx,
105 		   unsigned int *len_ptr, unsigned int *frame_len_ptr)
106 {
107 	struct can_priv *priv = netdev_priv(dev);
108 
109 	if (idx >= priv->echo_skb_max) {
110 		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
111 			   __func__, idx, priv->echo_skb_max);
112 		return NULL;
113 	}
114 
115 	if (priv->echo_skb[idx]) {
116 		/* Using "struct canfd_frame::len" for the frame
117 		 * length is supported on both CAN and CANFD frames.
118 		 */
119 		struct sk_buff *skb = priv->echo_skb[idx];
120 		struct can_skb_ext *csx;
121 
122 		if (skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS)
123 			skb_tstamp_tx(skb, skb_hwtstamps(skb));
124 
125 		/* get the real payload length for netdev statistics */
126 		*len_ptr = can_skb_get_data_len(skb);
127 
128 		if (frame_len_ptr) {
129 			csx = can_skb_ext_find(skb);
130 			if (csx)
131 				*frame_len_ptr = csx->can_framelen;
132 			else
133 				*frame_len_ptr = 0;
134 		}
135 
136 		priv->echo_skb[idx] = NULL;
137 
138 		if (skb->pkt_type == PACKET_LOOPBACK) {
139 			skb->pkt_type = PACKET_BROADCAST;
140 		} else {
141 			dev_consume_skb_any(skb);
142 			return NULL;
143 		}
144 
145 		return skb;
146 	}
147 
148 	return NULL;
149 }
150 
151 /* Get the skb from the stack and loop it back locally
152  *
153  * The function is typically called when the TX done interrupt
154  * is handled in the device driver. The driver must protect
155  * access to priv->echo_skb, if necessary.
156  */
157 unsigned int can_get_echo_skb(struct net_device *dev, unsigned int idx,
158 			      unsigned int *frame_len_ptr)
159 {
160 	struct sk_buff *skb;
161 	unsigned int len;
162 
163 	skb = __can_get_echo_skb(dev, idx, &len, frame_len_ptr);
164 	if (!skb)
165 		return 0;
166 
167 	skb_get(skb);
168 	if (netif_rx(skb) == NET_RX_SUCCESS)
169 		dev_consume_skb_any(skb);
170 	else
171 		dev_kfree_skb_any(skb);
172 
173 	return len;
174 }
175 EXPORT_SYMBOL_GPL(can_get_echo_skb);
176 
177 /* Remove the skb from the stack and free it.
178  *
179  * The function is typically called when TX failed.
180  */
181 void can_free_echo_skb(struct net_device *dev, unsigned int idx,
182 		       unsigned int *frame_len_ptr)
183 {
184 	struct can_priv *priv = netdev_priv(dev);
185 
186 	if (idx >= priv->echo_skb_max) {
187 		netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
188 			   __func__, idx, priv->echo_skb_max);
189 		return;
190 	}
191 
192 	if (priv->echo_skb[idx]) {
193 		struct sk_buff *skb = priv->echo_skb[idx];
194 		struct can_skb_ext *csx;
195 
196 		if (frame_len_ptr) {
197 			csx = can_skb_ext_find(skb);
198 			if (csx)
199 				*frame_len_ptr = csx->can_framelen;
200 			else
201 				*frame_len_ptr = 0;
202 		}
203 
204 		dev_kfree_skb_any(skb);
205 		priv->echo_skb[idx] = NULL;
206 	}
207 }
208 EXPORT_SYMBOL_GPL(can_free_echo_skb);
209 
210 /* fill common values for CAN sk_buffs */
211 static void init_can_skb(struct sk_buff *skb)
212 {
213 	skb->pkt_type = PACKET_BROADCAST;
214 	skb->ip_summed = CHECKSUM_UNNECESSARY;
215 
216 	skb_reset_mac_header(skb);
217 	skb_reset_network_header(skb);
218 	skb_reset_transport_header(skb);
219 }
220 
221 struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf)
222 {
223 	struct sk_buff *skb;
224 	struct can_skb_ext *csx;
225 
226 	skb = netdev_alloc_skb(dev, sizeof(struct can_frame));
227 	if (unlikely(!skb))
228 		goto out_error_cc;
229 
230 	csx = can_skb_ext_add(skb);
231 	if (!csx) {
232 		dev_kfree_skb_any(skb);
233 		goto out_error_cc;
234 	}
235 
236 	skb->protocol = htons(ETH_P_CAN);
237 	init_can_skb(skb);
238 	csx->can_iif = dev->ifindex;
239 
240 	*cf = skb_put_zero(skb, sizeof(struct can_frame));
241 
242 	return skb;
243 
244 out_error_cc:
245 	*cf = NULL;
246 
247 	return NULL;
248 }
249 EXPORT_SYMBOL_GPL(alloc_can_skb);
250 
251 struct sk_buff *alloc_canfd_skb(struct net_device *dev,
252 				struct canfd_frame **cfd)
253 {
254 	struct sk_buff *skb;
255 	struct can_skb_ext *csx;
256 
257 	skb = netdev_alloc_skb(dev, sizeof(struct canfd_frame));
258 	if (unlikely(!skb))
259 		goto out_error_fd;
260 
261 	csx = can_skb_ext_add(skb);
262 	if (!csx) {
263 		dev_kfree_skb_any(skb);
264 		goto out_error_fd;
265 	}
266 
267 	skb->protocol = htons(ETH_P_CANFD);
268 	init_can_skb(skb);
269 	csx->can_iif = dev->ifindex;
270 
271 	*cfd = skb_put_zero(skb, sizeof(struct canfd_frame));
272 
273 	/* set CAN FD flag by default */
274 	(*cfd)->flags = CANFD_FDF;
275 
276 	return skb;
277 
278 out_error_fd:
279 	*cfd = NULL;
280 
281 	return NULL;
282 }
283 EXPORT_SYMBOL_GPL(alloc_canfd_skb);
284 
285 struct sk_buff *alloc_canxl_skb(struct net_device *dev,
286 				struct canxl_frame **cxl,
287 				unsigned int data_len)
288 {
289 	struct sk_buff *skb;
290 	struct can_skb_ext *csx;
291 
292 	if (data_len < CANXL_MIN_DLEN || data_len > CANXL_MAX_DLEN)
293 		goto out_error_xl;
294 
295 	skb = netdev_alloc_skb(dev, CANXL_HDR_SIZE + data_len);
296 	if (unlikely(!skb))
297 		goto out_error_xl;
298 
299 	csx = can_skb_ext_add(skb);
300 	if (!csx) {
301 		dev_kfree_skb_any(skb);
302 		goto out_error_xl;
303 	}
304 
305 	skb->protocol = htons(ETH_P_CANXL);
306 	init_can_skb(skb);
307 	csx->can_iif = dev->ifindex;
308 
309 	*cxl = skb_put_zero(skb, CANXL_HDR_SIZE + data_len);
310 
311 	/* set CAN XL flag and length information by default */
312 	(*cxl)->flags = CANXL_XLF;
313 	(*cxl)->len = data_len;
314 
315 	return skb;
316 
317 out_error_xl:
318 	*cxl = NULL;
319 
320 	return NULL;
321 }
322 EXPORT_SYMBOL_GPL(alloc_canxl_skb);
323 
324 struct sk_buff *alloc_can_err_skb(struct net_device *dev, struct can_frame **cf)
325 {
326 	struct sk_buff *skb;
327 
328 	skb = alloc_can_skb(dev, cf);
329 	if (unlikely(!skb))
330 		return NULL;
331 
332 	(*cf)->can_id = CAN_ERR_FLAG;
333 	(*cf)->len = CAN_ERR_DLC;
334 
335 	return skb;
336 }
337 EXPORT_SYMBOL_GPL(alloc_can_err_skb);
338 
339 /* Check for outgoing skbs that have not been created by the CAN subsystem */
340 static bool can_skb_init_valid(struct net_device *dev, struct sk_buff *skb)
341 {
342 	struct can_skb_ext *csx = can_skb_ext_find(skb);
343 
344 	/* af_packet does not apply CAN skb specific settings */
345 	if (skb->ip_summed == CHECKSUM_NONE || !csx) {
346 		/* init CAN skb content */
347 		if (!csx) {
348 			csx = can_skb_ext_add(skb);
349 			if (!csx)
350 				return false;
351 		}
352 
353 		csx->can_iif = dev->ifindex;
354 		skb->ip_summed = CHECKSUM_UNNECESSARY;
355 
356 		/* perform proper loopback on capable devices */
357 		if (dev->flags & IFF_ECHO)
358 			skb->pkt_type = PACKET_LOOPBACK;
359 		else
360 			skb->pkt_type = PACKET_HOST;
361 
362 		skb_reset_mac_header(skb);
363 		skb_reset_network_header(skb);
364 		skb_reset_transport_header(skb);
365 
366 		/* set CANFD_FDF flag for CAN FD frames */
367 		if (can_is_canfd_skb(skb)) {
368 			struct canfd_frame *cfd;
369 
370 			cfd = (struct canfd_frame *)skb->data;
371 			cfd->flags |= CANFD_FDF;
372 		}
373 	}
374 
375 	return true;
376 }
377 
378 /* Drop a given socketbuffer if it does not contain a valid CAN frame. */
379 bool can_dropped_invalid_skb(struct net_device *dev, struct sk_buff *skb)
380 {
381 	switch (ntohs(skb->protocol)) {
382 	case ETH_P_CAN:
383 		if (!can_is_can_skb(skb))
384 			goto inval_skb;
385 		break;
386 
387 	case ETH_P_CANFD:
388 		if (!can_is_canfd_skb(skb))
389 			goto inval_skb;
390 		break;
391 
392 	case ETH_P_CANXL:
393 		if (!can_cap_enabled(dev, CAN_CAP_XL) || !can_is_canxl_skb(skb))
394 			goto inval_skb;
395 		break;
396 
397 	default:
398 		goto inval_skb;
399 	}
400 
401 	if (!can_skb_init_valid(dev, skb))
402 		goto inval_skb;
403 
404 	return false;
405 
406 inval_skb:
407 	dev_kfree_skb_any(skb);
408 	dev->stats.tx_dropped++;
409 	return true;
410 }
411 EXPORT_SYMBOL_GPL(can_dropped_invalid_skb);
412