xref: /linux/include/net/mctp.h (revision 5ce42b5de461c3154f61a023b191dd6b77ee66c0)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Management Component Transport Protocol (MCTP)
4  *
5  * Copyright (c) 2021 Code Construct
6  * Copyright (c) 2021 Google
7  */
8 
9 #ifndef __NET_MCTP_H
10 #define __NET_MCTP_H
11 
12 #include <linux/bits.h>
13 #include <linux/mctp.h>
14 #include <linux/netdevice.h>
15 #include <net/net_namespace.h>
16 #include <net/sock.h>
17 
18 /* MCTP packet definitions */
19 struct mctp_hdr {
20 	u8	ver;
21 	u8	dest;
22 	u8	src;
23 	u8	flags_seq_tag;
24 };
25 
26 #define MCTP_VER_MIN	1
27 #define MCTP_VER_MAX	1
28 
29 /* Definitions for flags_seq_tag field */
30 #define MCTP_HDR_FLAG_SOM	BIT(7)
31 #define MCTP_HDR_FLAG_EOM	BIT(6)
32 #define MCTP_HDR_FLAG_TO	BIT(3)
33 #define MCTP_HDR_FLAGS		GENMASK(5, 3)
34 #define MCTP_HDR_SEQ_SHIFT	4
35 #define MCTP_HDR_SEQ_MASK	GENMASK(1, 0)
36 #define MCTP_HDR_TAG_SHIFT	0
37 #define MCTP_HDR_TAG_MASK	GENMASK(2, 0)
38 
39 #define MCTP_INITIAL_DEFAULT_NET	1
40 
41 static inline bool mctp_address_unicast(mctp_eid_t eid)
42 {
43 	return eid >= 8 && eid < 255;
44 }
45 
46 static inline bool mctp_address_broadcast(mctp_eid_t eid)
47 {
48 	return eid == 255;
49 }
50 
51 static inline bool mctp_address_null(mctp_eid_t eid)
52 {
53 	return eid == 0;
54 }
55 
56 static inline bool mctp_address_matches(mctp_eid_t match, mctp_eid_t eid)
57 {
58 	return match == eid || match == MCTP_ADDR_ANY;
59 }
60 
61 static inline struct mctp_hdr *mctp_hdr(struct sk_buff *skb)
62 {
63 	return (struct mctp_hdr *)skb_network_header(skb);
64 }
65 
66 /* socket implementation */
67 struct mctp_sock {
68 	struct sock	sk;
69 
70 	/* bind() params */
71 	unsigned int	bind_net;
72 	mctp_eid_t	bind_addr;
73 	__u8		bind_type;
74 
75 	/* sendmsg()/recvmsg() uses struct sockaddr_mctp_ext */
76 	bool		addr_ext;
77 
78 	/* list of mctp_sk_key, for incoming tag lookup. updates protected
79 	 * by sk->net->keys_lock
80 	 */
81 	struct hlist_head keys;
82 
83 	/* mechanism for expiring allocated keys; will release an allocated
84 	 * tag, and any netdev state for a request/response pairing
85 	 */
86 	struct timer_list key_expiry;
87 };
88 
89 /* Key for matching incoming packets to sockets or reassembly contexts.
90  * Packets are matched on (peer EID, local EID, tag).
91  *
92  * Lifetime / locking requirements:
93  *
94  *  - individual key data (ie, the struct itself) is protected by key->lock;
95  *    changes must be made with that lock held.
96  *
97  *  - the lookup fields: peer_addr, local_addr and tag are set before the
98  *    key is added to lookup lists, and never updated.
99  *
100  *  - A ref to the key must be held (throuh key->refs) if a pointer to the
101  *    key is to be accessed after key->lock is released.
102  *
103  *  - a mctp_sk_key contains a reference to a struct sock; this is valid
104  *    for the life of the key. On sock destruction (through unhash), the key is
105  *    removed from lists (see below), and marked invalid.
106  *
107  * - these mctp_sk_keys appear on two lists:
108  *     1) the struct mctp_sock->keys list
109  *     2) the struct netns_mctp->keys list
110  *
111  *   presences on these lists requires a (single) refcount to be held; both
112  *   lists are updated as a single operation.
113  *
114  *   Updates and lookups in either list are performed under the
115  *   netns_mctp->keys lock. Lookup functions will need to lock the key and
116  *   take a reference before unlocking the keys_lock. Consequently, the list's
117  *   keys_lock *cannot* be acquired with the individual key->lock held.
118  *
119  * - a key may have a sk_buff attached as part of an in-progress message
120  *   reassembly (->reasm_head). The reasm data is protected by the individual
121  *   key->lock.
122  *
123  * - there are two destruction paths for a mctp_sk_key:
124  *
125  *    - through socket unhash (see mctp_sk_unhash). This performs the list
126  *      removal under keys_lock.
127  *
128  *    - where a key is established to receive a reply message: after receiving
129  *      the (complete) reply, or during reassembly errors. Here, we clean up
130  *      the reassembly context (marking reasm_dead, to prevent another from
131  *      starting), and remove the socket from the netns & socket lists.
132  *
133  *    - through an expiry timeout, on a per-socket timer
134  */
135 struct mctp_sk_key {
136 	unsigned int	net;
137 	mctp_eid_t	peer_addr;
138 	mctp_eid_t	local_addr; /* MCTP_ADDR_ANY for local owned tags */
139 	__u8		tag; /* incoming tag match; invert TO for local */
140 
141 	/* we hold a ref to sk when set */
142 	struct sock	*sk;
143 
144 	/* routing lookup list */
145 	struct hlist_node hlist;
146 
147 	/* per-socket list */
148 	struct hlist_node sklist;
149 
150 	/* lock protects against concurrent updates to the reassembly and
151 	 * expiry data below.
152 	 */
153 	spinlock_t	lock;
154 
155 	/* Keys are referenced during the output path, which may sleep */
156 	refcount_t	refs;
157 
158 	/* incoming fragment reassembly context */
159 	struct sk_buff	*reasm_head;
160 	struct sk_buff	**reasm_tailp;
161 	bool		reasm_dead;
162 	u8		last_seq;
163 
164 	/* key validity */
165 	bool		valid;
166 
167 	/* expiry timeout; valid (above) cleared on expiry */
168 	unsigned long	expiry;
169 
170 	/* free to use for device flow state tracking. Initialised to
171 	 * zero on initial key creation
172 	 */
173 	unsigned long	dev_flow_state;
174 	struct mctp_dev	*dev;
175 
176 	/* a tag allocated with SIOCMCTPALLOCTAG ioctl will not expire
177 	 * automatically on timeout or response, instead SIOCMCTPDROPTAG
178 	 * is used.
179 	 */
180 	bool		manual_alloc;
181 };
182 
183 struct mctp_skb_cb {
184 	unsigned int	magic;
185 	unsigned int	net;
186 	int		ifindex; /* extended/direct addressing if set */
187 	mctp_eid_t	src;
188 	unsigned char	halen;
189 	unsigned char	haddr[MAX_ADDR_LEN];
190 };
191 
192 /* skb control-block accessors with a little extra debugging for initial
193  * development.
194  *
195  * TODO: remove checks & mctp_skb_cb->magic; replace callers of __mctp_cb
196  * with mctp_cb().
197  *
198  * __mctp_cb() is only for the initial ingress code; we should see ->magic set
199  * at all times after this.
200  */
201 static inline struct mctp_skb_cb *__mctp_cb(struct sk_buff *skb)
202 {
203 	struct mctp_skb_cb *cb = (void *)skb->cb;
204 
205 	cb->magic = 0x4d435450;
206 	return cb;
207 }
208 
209 static inline struct mctp_skb_cb *mctp_cb(struct sk_buff *skb)
210 {
211 	struct mctp_skb_cb *cb = (void *)skb->cb;
212 
213 	BUILD_BUG_ON(sizeof(struct mctp_skb_cb) > sizeof(skb->cb));
214 	WARN_ON(cb->magic != 0x4d435450);
215 	return (void *)(skb->cb);
216 }
217 
218 /* If CONFIG_MCTP_FLOWS, we may add one of these as a SKB extension,
219  * indicating the flow to the device driver.
220  */
221 struct mctp_flow {
222 	struct mctp_sk_key *key;
223 };
224 
225 /* Route definition.
226  *
227  * These are held in the pernet->mctp.routes list, with RCU protection for
228  * removed routes. We hold a reference to the netdev; routes need to be
229  * dropped on NETDEV_UNREGISTER events.
230  *
231  * Updates to the route table are performed under rtnl; all reads under RCU,
232  * so routes cannot be referenced over a RCU grace period. Specifically: A
233  * caller cannot block between mctp_route_lookup and mctp_route_release()
234  */
235 struct mctp_route {
236 	mctp_eid_t		min, max;
237 
238 	unsigned char		type;
239 	unsigned int		mtu;
240 	struct mctp_dev		*dev;
241 	int			(*output)(struct mctp_route *route,
242 					  struct sk_buff *skb);
243 
244 	struct list_head	list;
245 	refcount_t		refs;
246 	struct rcu_head		rcu;
247 };
248 
249 /* route interfaces */
250 struct mctp_route *mctp_route_lookup(struct net *net, unsigned int dnet,
251 				     mctp_eid_t daddr);
252 
253 /* always takes ownership of skb */
254 int mctp_local_output(struct sock *sk, struct mctp_route *rt,
255 		      struct sk_buff *skb, mctp_eid_t daddr, u8 req_tag);
256 
257 void mctp_key_unref(struct mctp_sk_key *key);
258 struct mctp_sk_key *mctp_alloc_local_tag(struct mctp_sock *msk,
259 					 unsigned int netid,
260 					 mctp_eid_t local, mctp_eid_t peer,
261 					 bool manual, u8 *tagp);
262 
263 /* routing <--> device interface */
264 unsigned int mctp_default_net(struct net *net);
265 int mctp_default_net_set(struct net *net, unsigned int index);
266 int mctp_route_add_local(struct mctp_dev *mdev, mctp_eid_t addr);
267 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr);
268 void mctp_route_remove_dev(struct mctp_dev *mdev);
269 
270 /* neighbour definitions */
271 enum mctp_neigh_source {
272 	MCTP_NEIGH_STATIC,
273 	MCTP_NEIGH_DISCOVER,
274 };
275 
276 struct mctp_neigh {
277 	struct mctp_dev		*dev;
278 	mctp_eid_t		eid;
279 	enum mctp_neigh_source	source;
280 
281 	unsigned char		ha[MAX_ADDR_LEN];
282 
283 	struct list_head	list;
284 	struct rcu_head		rcu;
285 };
286 
287 int mctp_neigh_init(void);
288 void mctp_neigh_exit(void);
289 
290 // ret_hwaddr may be NULL, otherwise must have space for MAX_ADDR_LEN
291 int mctp_neigh_lookup(struct mctp_dev *dev, mctp_eid_t eid,
292 		      void *ret_hwaddr);
293 void mctp_neigh_remove_dev(struct mctp_dev *mdev);
294 
295 int mctp_routes_init(void);
296 void mctp_routes_exit(void);
297 
298 int mctp_device_init(void);
299 void mctp_device_exit(void);
300 
301 #endif /* __NET_MCTP_H */
302