tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/* SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) */
2/*
3 * linux/can/skb.h
4 *
5 * Definitions for the CAN network socket buffer
6 *
7 * Copyright (C) 2012 Oliver Hartkopp <socketcan@hartkopp.net>
8 *
9 */
10
11#ifndef _CAN_SKB_H
12#define _CAN_SKB_H
13
14#include <linux/types.h>
15#include <linux/skbuff.h>
16#include <linux/can.h>
17#include <net/sock.h>
18
19void can_flush_echo_skb(struct net_device *dev);
20int can_put_echo_skb(struct sk_buff *skb, struct net_device *dev,
21 unsigned int idx, unsigned int frame_len);
22struct sk_buff *__can_get_echo_skb(struct net_device *dev, unsigned int idx,
23 u8 *len_ptr, unsigned int *frame_len_ptr);
24unsigned int __must_check can_get_echo_skb(struct net_device *dev,
25 unsigned int idx,
26 unsigned int *frame_len_ptr);
27void can_free_echo_skb(struct net_device *dev, unsigned int idx,
28 unsigned int *frame_len_ptr);
29struct sk_buff *alloc_can_skb(struct net_device *dev, struct can_frame **cf);
30struct sk_buff *alloc_canfd_skb(struct net_device *dev,
31 struct canfd_frame **cfd);
32struct sk_buff *alloc_can_err_skb(struct net_device *dev,
33 struct can_frame **cf);
34
35/*
36 * The struct can_skb_priv is used to transport additional information along
37 * with the stored struct can(fd)_frame that can not be contained in existing
38 * struct sk_buff elements.
39 * N.B. that this information must not be modified in cloned CAN sk_buffs.
40 * To modify the CAN frame content or the struct can_skb_priv content
41 * skb_copy() needs to be used instead of skb_clone().
42 */
43
44/**
45 * struct can_skb_priv - private additional data inside CAN sk_buffs
46 * @ifindex: ifindex of the first interface the CAN frame appeared on
47 * @skbcnt: atomic counter to have an unique id together with skb pointer
48 * @frame_len: length of CAN frame in data link layer
49 * @cf: align to the following CAN frame at skb->data
50 */
51struct can_skb_priv {
52 int ifindex;
53 int skbcnt;
54 unsigned int frame_len;
55 struct can_frame cf[];
56};
57
58static inline struct can_skb_priv *can_skb_prv(struct sk_buff *skb)
59{
60 return (struct can_skb_priv *)(skb->head);
61}
62
63static inline void can_skb_reserve(struct sk_buff *skb)
64{
65 skb_reserve(skb, sizeof(struct can_skb_priv));
66}
67
68static inline void can_skb_set_owner(struct sk_buff *skb, struct sock *sk)
69{
70 /* If the socket has already been closed by user space, the
71 * refcount may already be 0 (and the socket will be freed
72 * after the last TX skb has been freed). So only increase
73 * socket refcount if the refcount is > 0.
74 */
75 if (sk && refcount_inc_not_zero(&sk->sk_refcnt)) {
76 skb->destructor = sock_efree;
77 skb->sk = sk;
78 }
79}
80
81/*
82 * returns an unshared skb owned by the original sock to be echo'ed back
83 */
84static inline struct sk_buff *can_create_echo_skb(struct sk_buff *skb)
85{
86 struct sk_buff *nskb;
87
88 nskb = skb_clone(skb, GFP_ATOMIC);
89 if (unlikely(!nskb)) {
90 kfree_skb(skb);
91 return NULL;
92 }
93
94 can_skb_set_owner(nskb, skb->sk);
95 consume_skb(skb);
96 return nskb;
97}
98
99/* Check for outgoing skbs that have not been created by the CAN subsystem */
100static inline bool can_skb_headroom_valid(struct net_device *dev,
101 struct sk_buff *skb)
102{
103 /* af_packet creates a headroom of HH_DATA_MOD bytes which is fine */
104 if (WARN_ON_ONCE(skb_headroom(skb) < sizeof(struct can_skb_priv)))
105 return false;
106
107 /* af_packet does not apply CAN skb specific settings */
108 if (skb->ip_summed == CHECKSUM_NONE) {
109 /* init headroom */
110 can_skb_prv(skb)->ifindex = dev->ifindex;
111 can_skb_prv(skb)->skbcnt = 0;
112
113 skb->ip_summed = CHECKSUM_UNNECESSARY;
114
115 /* perform proper loopback on capable devices */
116 if (dev->flags & IFF_ECHO)
117 skb->pkt_type = PACKET_LOOPBACK;
118 else
119 skb->pkt_type = PACKET_HOST;
120
121 skb_reset_mac_header(skb);
122 skb_reset_network_header(skb);
123 skb_reset_transport_header(skb);
124 }
125
126 return true;
127}
128
129/* Drop a given socketbuffer if it does not contain a valid CAN frame. */
130static inline bool can_dropped_invalid_skb(struct net_device *dev,
131 struct sk_buff *skb)
132{
133 const struct canfd_frame *cfd = (struct canfd_frame *)skb->data;
134
135 if (skb->protocol == htons(ETH_P_CAN)) {
136 if (unlikely(skb->len != CAN_MTU ||
137 cfd->len > CAN_MAX_DLEN))
138 goto inval_skb;
139 } else if (skb->protocol == htons(ETH_P_CANFD)) {
140 if (unlikely(skb->len != CANFD_MTU ||
141 cfd->len > CANFD_MAX_DLEN))
142 goto inval_skb;
143 } else
144 goto inval_skb;
145
146 if (!can_skb_headroom_valid(dev, skb))
147 goto inval_skb;
148
149 return false;
150
151inval_skb:
152 kfree_skb(skb);
153 dev->stats.tx_dropped++;
154 return true;
155}
156
157static inline bool can_is_canfd_skb(const struct sk_buff *skb)
158{
159 /* the CAN specific type of skb is identified by its data length */
160 return skb->len == CANFD_MTU;
161}
162
163#endif /* !_CAN_SKB_H */