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 
mctp_address_unicast(mctp_eid_t eid)41 static inline bool mctp_address_unicast(mctp_eid_t eid)
42 {
43 	return eid >= 8 && eid < 255;
44 }
45 
mctp_address_broadcast(mctp_eid_t eid)46 static inline bool mctp_address_broadcast(mctp_eid_t eid)
47 {
48 	return eid == 255;
49 }
50 
mctp_address_null(mctp_eid_t eid)51 static inline bool mctp_address_null(mctp_eid_t eid)
52 {
53 	return eid == 0;
54 }
55 
mctp_address_matches(mctp_eid_t match,mctp_eid_t eid)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 
mctp_hdr(struct sk_buff * skb)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 (src,dest,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 	mctp_eid_t	peer_addr;
137 	mctp_eid_t	local_addr; /* MCTP_ADDR_ANY for local owned tags */
138 	__u8		tag; /* incoming tag match; invert TO for local */
139 
140 	/* we hold a ref to sk when set */
141 	struct sock	*sk;
142 
143 	/* routing lookup list */
144 	struct hlist_node hlist;
145 
146 	/* per-socket list */
147 	struct hlist_node sklist;
148 
149 	/* lock protects against concurrent updates to the reassembly and
150 	 * expiry data below.
151 	 */
152 	spinlock_t	lock;
153 
154 	/* Keys are referenced during the output path, which may sleep */
155 	refcount_t	refs;
156 
157 	/* incoming fragment reassembly context */
158 	struct sk_buff	*reasm_head;
159 	struct sk_buff	**reasm_tailp;
160 	bool		reasm_dead;
161 	u8		last_seq;
162 
163 	/* key validity */
164 	bool		valid;
165 
166 	/* expiry timeout; valid (above) cleared on expiry */
167 	unsigned long	expiry;
168 
169 	/* free to use for device flow state tracking. Initialised to
170 	 * zero on initial key creation
171 	 */
172 	unsigned long	dev_flow_state;
173 	struct mctp_dev	*dev;
174 
175 	/* a tag allocated with SIOCMCTPALLOCTAG ioctl will not expire
176 	 * automatically on timeout or response, instead SIOCMCTPDROPTAG
177 	 * is used.
178 	 */
179 	bool		manual_alloc;
180 };
181 
182 struct mctp_skb_cb {
183 	unsigned int	magic;
184 	unsigned int	net;
185 	int		ifindex; /* extended/direct addressing if set */
186 	mctp_eid_t	src;
187 	unsigned char	halen;
188 	unsigned char	haddr[MAX_ADDR_LEN];
189 };
190 
191 /* skb control-block accessors with a little extra debugging for initial
192  * development.
193  *
194  * TODO: remove checks & mctp_skb_cb->magic; replace callers of __mctp_cb
195  * with mctp_cb().
196  *
197  * __mctp_cb() is only for the initial ingress code; we should see ->magic set
198  * at all times after this.
199  */
__mctp_cb(struct sk_buff * skb)200 static inline struct mctp_skb_cb *__mctp_cb(struct sk_buff *skb)
201 {
202 	struct mctp_skb_cb *cb = (void *)skb->cb;
203 
204 	cb->magic = 0x4d435450;
205 	return cb;
206 }
207 
mctp_cb(struct sk_buff * skb)208 static inline struct mctp_skb_cb *mctp_cb(struct sk_buff *skb)
209 {
210 	struct mctp_skb_cb *cb = (void *)skb->cb;
211 
212 	BUILD_BUG_ON(sizeof(struct mctp_skb_cb) > sizeof(skb->cb));
213 	WARN_ON(cb->magic != 0x4d435450);
214 	return (void *)(skb->cb);
215 }
216 
217 /* If CONFIG_MCTP_FLOWS, we may add one of these as a SKB extension,
218  * indicating the flow to the device driver.
219  */
220 struct mctp_flow {
221 	struct mctp_sk_key *key;
222 };
223 
224 /* Route definition.
225  *
226  * These are held in the pernet->mctp.routes list, with RCU protection for
227  * removed routes. We hold a reference to the netdev; routes need to be
228  * dropped on NETDEV_UNREGISTER events.
229  *
230  * Updates to the route table are performed under rtnl; all reads under RCU,
231  * so routes cannot be referenced over a RCU grace period. Specifically: A
232  * caller cannot block between mctp_route_lookup and mctp_route_release()
233  */
234 struct mctp_route {
235 	mctp_eid_t		min, max;
236 
237 	struct mctp_dev		*dev;
238 	unsigned int		mtu;
239 	unsigned char		type;
240 	int			(*output)(struct mctp_route *route,
241 					  struct sk_buff *skb);
242 
243 	struct list_head	list;
244 	refcount_t		refs;
245 	struct rcu_head		rcu;
246 };
247 
248 /* route interfaces */
249 struct mctp_route *mctp_route_lookup(struct net *net, unsigned int dnet,
250 				     mctp_eid_t daddr);
251 
252 int mctp_local_output(struct sock *sk, struct mctp_route *rt,
253 		      struct sk_buff *skb, mctp_eid_t daddr, u8 req_tag);
254 
255 void mctp_key_unref(struct mctp_sk_key *key);
256 struct mctp_sk_key *mctp_alloc_local_tag(struct mctp_sock *msk,
257 					 mctp_eid_t daddr, mctp_eid_t saddr,
258 					 bool manual, u8 *tagp);
259 
260 /* routing <--> device interface */
261 unsigned int mctp_default_net(struct net *net);
262 int mctp_default_net_set(struct net *net, unsigned int index);
263 int mctp_route_add_local(struct mctp_dev *mdev, mctp_eid_t addr);
264 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr);
265 void mctp_route_remove_dev(struct mctp_dev *mdev);
266 
267 /* neighbour definitions */
268 enum mctp_neigh_source {
269 	MCTP_NEIGH_STATIC,
270 	MCTP_NEIGH_DISCOVER,
271 };
272 
273 struct mctp_neigh {
274 	struct mctp_dev		*dev;
275 	mctp_eid_t		eid;
276 	enum mctp_neigh_source	source;
277 
278 	unsigned char		ha[MAX_ADDR_LEN];
279 
280 	struct list_head	list;
281 	struct rcu_head		rcu;
282 };
283 
284 int mctp_neigh_init(void);
285 void mctp_neigh_exit(void);
286 
287 // ret_hwaddr may be NULL, otherwise must have space for MAX_ADDR_LEN
288 int mctp_neigh_lookup(struct mctp_dev *dev, mctp_eid_t eid,
289 		      void *ret_hwaddr);
290 void mctp_neigh_remove_dev(struct mctp_dev *mdev);
291 
292 int mctp_routes_init(void);
293 void mctp_routes_exit(void);
294 
295 void mctp_device_init(void);
296 void mctp_device_exit(void);
297 
298 #endif /* __NET_MCTP_H */
299