1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Management Component Transport Protocol (MCTP) - routing
4 * implementation.
5 *
6 * This is currently based on a simple routing table, with no dst cache. The
7 * number of routes should stay fairly small, so the lookup cost is small.
8 *
9 * Copyright (c) 2021 Code Construct
10 * Copyright (c) 2021 Google
11 */
12
13 #include <linux/idr.h>
14 #include <linux/kconfig.h>
15 #include <linux/mctp.h>
16 #include <linux/netdevice.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/skbuff.h>
19
20 #include <uapi/linux/if_arp.h>
21
22 #include <net/mctp.h>
23 #include <net/mctpdevice.h>
24 #include <net/netlink.h>
25 #include <net/sock.h>
26
27 #include <trace/events/mctp.h>
28
29 static const unsigned int mctp_message_maxlen = 64 * 1024;
30 static const unsigned long mctp_key_lifetime = 6 * CONFIG_HZ;
31
32 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev);
33
34 /* route output callbacks */
mctp_route_discard(struct mctp_route * route,struct sk_buff * skb)35 static int mctp_route_discard(struct mctp_route *route, struct sk_buff *skb)
36 {
37 kfree_skb(skb);
38 return 0;
39 }
40
mctp_lookup_bind(struct net * net,struct sk_buff * skb)41 static struct mctp_sock *mctp_lookup_bind(struct net *net, struct sk_buff *skb)
42 {
43 struct mctp_skb_cb *cb = mctp_cb(skb);
44 struct mctp_hdr *mh;
45 struct sock *sk;
46 u8 type;
47
48 WARN_ON(!rcu_read_lock_held());
49
50 /* TODO: look up in skb->cb? */
51 mh = mctp_hdr(skb);
52
53 if (!skb_headlen(skb))
54 return NULL;
55
56 type = (*(u8 *)skb->data) & 0x7f;
57
58 sk_for_each_rcu(sk, &net->mctp.binds) {
59 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
60
61 if (msk->bind_net != MCTP_NET_ANY && msk->bind_net != cb->net)
62 continue;
63
64 if (msk->bind_type != type)
65 continue;
66
67 if (!mctp_address_matches(msk->bind_addr, mh->dest))
68 continue;
69
70 return msk;
71 }
72
73 return NULL;
74 }
75
mctp_key_match(struct mctp_sk_key * key,mctp_eid_t local,mctp_eid_t peer,u8 tag)76 static bool mctp_key_match(struct mctp_sk_key *key, mctp_eid_t local,
77 mctp_eid_t peer, u8 tag)
78 {
79 if (!mctp_address_matches(key->local_addr, local))
80 return false;
81
82 if (key->peer_addr != peer)
83 return false;
84
85 if (key->tag != tag)
86 return false;
87
88 return true;
89 }
90
91 /* returns a key (with key->lock held, and refcounted), or NULL if no such
92 * key exists.
93 */
mctp_lookup_key(struct net * net,struct sk_buff * skb,mctp_eid_t peer,unsigned long * irqflags)94 static struct mctp_sk_key *mctp_lookup_key(struct net *net, struct sk_buff *skb,
95 mctp_eid_t peer,
96 unsigned long *irqflags)
97 __acquires(&key->lock)
98 {
99 struct mctp_sk_key *key, *ret;
100 unsigned long flags;
101 struct mctp_hdr *mh;
102 u8 tag;
103
104 mh = mctp_hdr(skb);
105 tag = mh->flags_seq_tag & (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
106
107 ret = NULL;
108 spin_lock_irqsave(&net->mctp.keys_lock, flags);
109
110 hlist_for_each_entry(key, &net->mctp.keys, hlist) {
111 if (!mctp_key_match(key, mh->dest, peer, tag))
112 continue;
113
114 spin_lock(&key->lock);
115 if (key->valid) {
116 refcount_inc(&key->refs);
117 ret = key;
118 break;
119 }
120 spin_unlock(&key->lock);
121 }
122
123 if (ret) {
124 spin_unlock(&net->mctp.keys_lock);
125 *irqflags = flags;
126 } else {
127 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
128 }
129
130 return ret;
131 }
132
mctp_key_alloc(struct mctp_sock * msk,mctp_eid_t local,mctp_eid_t peer,u8 tag,gfp_t gfp)133 static struct mctp_sk_key *mctp_key_alloc(struct mctp_sock *msk,
134 mctp_eid_t local, mctp_eid_t peer,
135 u8 tag, gfp_t gfp)
136 {
137 struct mctp_sk_key *key;
138
139 key = kzalloc(sizeof(*key), gfp);
140 if (!key)
141 return NULL;
142
143 key->peer_addr = peer;
144 key->local_addr = local;
145 key->tag = tag;
146 key->sk = &msk->sk;
147 key->valid = true;
148 spin_lock_init(&key->lock);
149 refcount_set(&key->refs, 1);
150 sock_hold(key->sk);
151
152 return key;
153 }
154
mctp_key_unref(struct mctp_sk_key * key)155 void mctp_key_unref(struct mctp_sk_key *key)
156 {
157 unsigned long flags;
158
159 if (!refcount_dec_and_test(&key->refs))
160 return;
161
162 /* even though no refs exist here, the lock allows us to stay
163 * consistent with the locking requirement of mctp_dev_release_key
164 */
165 spin_lock_irqsave(&key->lock, flags);
166 mctp_dev_release_key(key->dev, key);
167 spin_unlock_irqrestore(&key->lock, flags);
168
169 sock_put(key->sk);
170 kfree(key);
171 }
172
mctp_key_add(struct mctp_sk_key * key,struct mctp_sock * msk)173 static int mctp_key_add(struct mctp_sk_key *key, struct mctp_sock *msk)
174 {
175 struct net *net = sock_net(&msk->sk);
176 struct mctp_sk_key *tmp;
177 unsigned long flags;
178 int rc = 0;
179
180 spin_lock_irqsave(&net->mctp.keys_lock, flags);
181
182 if (sock_flag(&msk->sk, SOCK_DEAD)) {
183 rc = -EINVAL;
184 goto out_unlock;
185 }
186
187 hlist_for_each_entry(tmp, &net->mctp.keys, hlist) {
188 if (mctp_key_match(tmp, key->local_addr, key->peer_addr,
189 key->tag)) {
190 spin_lock(&tmp->lock);
191 if (tmp->valid)
192 rc = -EEXIST;
193 spin_unlock(&tmp->lock);
194 if (rc)
195 break;
196 }
197 }
198
199 if (!rc) {
200 refcount_inc(&key->refs);
201 key->expiry = jiffies + mctp_key_lifetime;
202 timer_reduce(&msk->key_expiry, key->expiry);
203
204 hlist_add_head(&key->hlist, &net->mctp.keys);
205 hlist_add_head(&key->sklist, &msk->keys);
206 }
207
208 out_unlock:
209 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
210
211 return rc;
212 }
213
214 /* Helper for mctp_route_input().
215 * We're done with the key; unlock and unref the key.
216 * For the usual case of automatic expiry we remove the key from lists.
217 * In the case that manual allocation is set on a key we release the lock
218 * and local ref, reset reassembly, but don't remove from lists.
219 */
__mctp_key_done_in(struct mctp_sk_key * key,struct net * net,unsigned long flags,unsigned long reason)220 static void __mctp_key_done_in(struct mctp_sk_key *key, struct net *net,
221 unsigned long flags, unsigned long reason)
222 __releases(&key->lock)
223 {
224 struct sk_buff *skb;
225
226 trace_mctp_key_release(key, reason);
227 skb = key->reasm_head;
228 key->reasm_head = NULL;
229
230 if (!key->manual_alloc) {
231 key->reasm_dead = true;
232 key->valid = false;
233 mctp_dev_release_key(key->dev, key);
234 }
235 spin_unlock_irqrestore(&key->lock, flags);
236
237 if (!key->manual_alloc) {
238 spin_lock_irqsave(&net->mctp.keys_lock, flags);
239 if (!hlist_unhashed(&key->hlist)) {
240 hlist_del_init(&key->hlist);
241 hlist_del_init(&key->sklist);
242 mctp_key_unref(key);
243 }
244 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
245 }
246
247 /* and one for the local reference */
248 mctp_key_unref(key);
249
250 kfree_skb(skb);
251 }
252
253 #ifdef CONFIG_MCTP_FLOWS
mctp_skb_set_flow(struct sk_buff * skb,struct mctp_sk_key * key)254 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key)
255 {
256 struct mctp_flow *flow;
257
258 flow = skb_ext_add(skb, SKB_EXT_MCTP);
259 if (!flow)
260 return;
261
262 refcount_inc(&key->refs);
263 flow->key = key;
264 }
265
mctp_flow_prepare_output(struct sk_buff * skb,struct mctp_dev * dev)266 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev)
267 {
268 struct mctp_sk_key *key;
269 struct mctp_flow *flow;
270
271 flow = skb_ext_find(skb, SKB_EXT_MCTP);
272 if (!flow)
273 return;
274
275 key = flow->key;
276
277 if (key->dev) {
278 WARN_ON(key->dev != dev);
279 return;
280 }
281
282 mctp_dev_set_key(dev, key);
283 }
284 #else
mctp_skb_set_flow(struct sk_buff * skb,struct mctp_sk_key * key)285 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key) {}
mctp_flow_prepare_output(struct sk_buff * skb,struct mctp_dev * dev)286 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev) {}
287 #endif
288
mctp_frag_queue(struct mctp_sk_key * key,struct sk_buff * skb)289 static int mctp_frag_queue(struct mctp_sk_key *key, struct sk_buff *skb)
290 {
291 struct mctp_hdr *hdr = mctp_hdr(skb);
292 u8 exp_seq, this_seq;
293
294 this_seq = (hdr->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT)
295 & MCTP_HDR_SEQ_MASK;
296
297 if (!key->reasm_head) {
298 /* Since we're manipulating the shared frag_list, ensure it isn't
299 * shared with any other SKBs.
300 */
301 key->reasm_head = skb_unshare(skb, GFP_ATOMIC);
302 if (!key->reasm_head)
303 return -ENOMEM;
304
305 key->reasm_tailp = &(skb_shinfo(key->reasm_head)->frag_list);
306 key->last_seq = this_seq;
307 return 0;
308 }
309
310 exp_seq = (key->last_seq + 1) & MCTP_HDR_SEQ_MASK;
311
312 if (this_seq != exp_seq)
313 return -EINVAL;
314
315 if (key->reasm_head->len + skb->len > mctp_message_maxlen)
316 return -EINVAL;
317
318 skb->next = NULL;
319 skb->sk = NULL;
320 *key->reasm_tailp = skb;
321 key->reasm_tailp = &skb->next;
322
323 key->last_seq = this_seq;
324
325 key->reasm_head->data_len += skb->len;
326 key->reasm_head->len += skb->len;
327 key->reasm_head->truesize += skb->truesize;
328
329 return 0;
330 }
331
mctp_route_input(struct mctp_route * route,struct sk_buff * skb)332 static int mctp_route_input(struct mctp_route *route, struct sk_buff *skb)
333 {
334 struct mctp_sk_key *key, *any_key = NULL;
335 struct net *net = dev_net(skb->dev);
336 struct mctp_sock *msk;
337 struct mctp_hdr *mh;
338 unsigned long f;
339 u8 tag, flags;
340 int rc;
341
342 msk = NULL;
343 rc = -EINVAL;
344
345 /* We may be receiving a locally-routed packet; drop source sk
346 * accounting.
347 *
348 * From here, we will either queue the skb - either to a frag_queue, or
349 * to a receiving socket. When that succeeds, we clear the skb pointer;
350 * a non-NULL skb on exit will be otherwise unowned, and hence
351 * kfree_skb()-ed.
352 */
353 skb_orphan(skb);
354
355 /* ensure we have enough data for a header and a type */
356 if (skb->len < sizeof(struct mctp_hdr) + 1)
357 goto out;
358
359 /* grab header, advance data ptr */
360 mh = mctp_hdr(skb);
361 skb_pull(skb, sizeof(struct mctp_hdr));
362
363 if (mh->ver != 1)
364 goto out;
365
366 flags = mh->flags_seq_tag & (MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM);
367 tag = mh->flags_seq_tag & (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
368
369 rcu_read_lock();
370
371 /* lookup socket / reasm context, exactly matching (src,dest,tag).
372 * we hold a ref on the key, and key->lock held.
373 */
374 key = mctp_lookup_key(net, skb, mh->src, &f);
375
376 if (flags & MCTP_HDR_FLAG_SOM) {
377 if (key) {
378 msk = container_of(key->sk, struct mctp_sock, sk);
379 } else {
380 /* first response to a broadcast? do a more general
381 * key lookup to find the socket, but don't use this
382 * key for reassembly - we'll create a more specific
383 * one for future packets if required (ie, !EOM).
384 */
385 any_key = mctp_lookup_key(net, skb, MCTP_ADDR_ANY, &f);
386 if (any_key) {
387 msk = container_of(any_key->sk,
388 struct mctp_sock, sk);
389 spin_unlock_irqrestore(&any_key->lock, f);
390 }
391 }
392
393 if (!key && !msk && (tag & MCTP_HDR_FLAG_TO))
394 msk = mctp_lookup_bind(net, skb);
395
396 if (!msk) {
397 rc = -ENOENT;
398 goto out_unlock;
399 }
400
401 /* single-packet message? deliver to socket, clean up any
402 * pending key.
403 */
404 if (flags & MCTP_HDR_FLAG_EOM) {
405 rc = sock_queue_rcv_skb(&msk->sk, skb);
406 if (!rc)
407 skb = NULL;
408 if (key) {
409 /* we've hit a pending reassembly; not much we
410 * can do but drop it
411 */
412 __mctp_key_done_in(key, net, f,
413 MCTP_TRACE_KEY_REPLIED);
414 key = NULL;
415 }
416 goto out_unlock;
417 }
418
419 /* broadcast response or a bind() - create a key for further
420 * packets for this message
421 */
422 if (!key) {
423 key = mctp_key_alloc(msk, mh->dest, mh->src,
424 tag, GFP_ATOMIC);
425 if (!key) {
426 rc = -ENOMEM;
427 goto out_unlock;
428 }
429
430 /* we can queue without the key lock here, as the
431 * key isn't observable yet
432 */
433 mctp_frag_queue(key, skb);
434
435 /* if the key_add fails, we've raced with another
436 * SOM packet with the same src, dest and tag. There's
437 * no way to distinguish future packets, so all we
438 * can do is drop; we'll free the skb on exit from
439 * this function.
440 */
441 rc = mctp_key_add(key, msk);
442 if (!rc) {
443 trace_mctp_key_acquire(key);
444 skb = NULL;
445 }
446
447 /* we don't need to release key->lock on exit, so
448 * clean up here and suppress the unlock via
449 * setting to NULL
450 */
451 mctp_key_unref(key);
452 key = NULL;
453
454 } else {
455 if (key->reasm_head || key->reasm_dead) {
456 /* duplicate start? drop everything */
457 __mctp_key_done_in(key, net, f,
458 MCTP_TRACE_KEY_INVALIDATED);
459 rc = -EEXIST;
460 key = NULL;
461 } else {
462 rc = mctp_frag_queue(key, skb);
463 if (!rc)
464 skb = NULL;
465 }
466 }
467
468 } else if (key) {
469 /* this packet continues a previous message; reassemble
470 * using the message-specific key
471 */
472
473 /* we need to be continuing an existing reassembly... */
474 if (!key->reasm_head)
475 rc = -EINVAL;
476 else
477 rc = mctp_frag_queue(key, skb);
478
479 if (rc)
480 goto out_unlock;
481
482 /* we've queued; the queue owns the skb now */
483 skb = NULL;
484
485 /* end of message? deliver to socket, and we're done with
486 * the reassembly/response key
487 */
488 if (flags & MCTP_HDR_FLAG_EOM) {
489 rc = sock_queue_rcv_skb(key->sk, key->reasm_head);
490 if (!rc)
491 key->reasm_head = NULL;
492 __mctp_key_done_in(key, net, f, MCTP_TRACE_KEY_REPLIED);
493 key = NULL;
494 }
495
496 } else {
497 /* not a start, no matching key */
498 rc = -ENOENT;
499 }
500
501 out_unlock:
502 rcu_read_unlock();
503 if (key) {
504 spin_unlock_irqrestore(&key->lock, f);
505 mctp_key_unref(key);
506 }
507 if (any_key)
508 mctp_key_unref(any_key);
509 out:
510 kfree_skb(skb);
511 return rc;
512 }
513
mctp_route_mtu(struct mctp_route * rt)514 static unsigned int mctp_route_mtu(struct mctp_route *rt)
515 {
516 return rt->mtu ?: READ_ONCE(rt->dev->dev->mtu);
517 }
518
mctp_route_output(struct mctp_route * route,struct sk_buff * skb)519 static int mctp_route_output(struct mctp_route *route, struct sk_buff *skb)
520 {
521 struct mctp_skb_cb *cb = mctp_cb(skb);
522 struct mctp_hdr *hdr = mctp_hdr(skb);
523 char daddr_buf[MAX_ADDR_LEN];
524 char *daddr = NULL;
525 unsigned int mtu;
526 int rc;
527
528 skb->protocol = htons(ETH_P_MCTP);
529
530 mtu = READ_ONCE(skb->dev->mtu);
531 if (skb->len > mtu) {
532 kfree_skb(skb);
533 return -EMSGSIZE;
534 }
535
536 if (cb->ifindex) {
537 /* direct route; use the hwaddr we stashed in sendmsg */
538 if (cb->halen != skb->dev->addr_len) {
539 /* sanity check, sendmsg should have already caught this */
540 kfree_skb(skb);
541 return -EMSGSIZE;
542 }
543 daddr = cb->haddr;
544 } else {
545 /* If lookup fails let the device handle daddr==NULL */
546 if (mctp_neigh_lookup(route->dev, hdr->dest, daddr_buf) == 0)
547 daddr = daddr_buf;
548 }
549
550 rc = dev_hard_header(skb, skb->dev, ntohs(skb->protocol),
551 daddr, skb->dev->dev_addr, skb->len);
552 if (rc < 0) {
553 kfree_skb(skb);
554 return -EHOSTUNREACH;
555 }
556
557 mctp_flow_prepare_output(skb, route->dev);
558
559 rc = dev_queue_xmit(skb);
560 if (rc)
561 rc = net_xmit_errno(rc);
562
563 return rc;
564 }
565
566 /* route alloc/release */
mctp_route_release(struct mctp_route * rt)567 static void mctp_route_release(struct mctp_route *rt)
568 {
569 if (refcount_dec_and_test(&rt->refs)) {
570 mctp_dev_put(rt->dev);
571 kfree_rcu(rt, rcu);
572 }
573 }
574
575 /* returns a route with the refcount at 1 */
mctp_route_alloc(void)576 static struct mctp_route *mctp_route_alloc(void)
577 {
578 struct mctp_route *rt;
579
580 rt = kzalloc(sizeof(*rt), GFP_KERNEL);
581 if (!rt)
582 return NULL;
583
584 INIT_LIST_HEAD(&rt->list);
585 refcount_set(&rt->refs, 1);
586 rt->output = mctp_route_discard;
587
588 return rt;
589 }
590
mctp_default_net(struct net * net)591 unsigned int mctp_default_net(struct net *net)
592 {
593 return READ_ONCE(net->mctp.default_net);
594 }
595
mctp_default_net_set(struct net * net,unsigned int index)596 int mctp_default_net_set(struct net *net, unsigned int index)
597 {
598 if (index == 0)
599 return -EINVAL;
600 WRITE_ONCE(net->mctp.default_net, index);
601 return 0;
602 }
603
604 /* tag management */
mctp_reserve_tag(struct net * net,struct mctp_sk_key * key,struct mctp_sock * msk)605 static void mctp_reserve_tag(struct net *net, struct mctp_sk_key *key,
606 struct mctp_sock *msk)
607 {
608 struct netns_mctp *mns = &net->mctp;
609
610 lockdep_assert_held(&mns->keys_lock);
611
612 key->expiry = jiffies + mctp_key_lifetime;
613 timer_reduce(&msk->key_expiry, key->expiry);
614
615 /* we hold the net->key_lock here, allowing updates to both
616 * then net and sk
617 */
618 hlist_add_head_rcu(&key->hlist, &mns->keys);
619 hlist_add_head_rcu(&key->sklist, &msk->keys);
620 refcount_inc(&key->refs);
621 }
622
623 /* Allocate a locally-owned tag value for (saddr, daddr), and reserve
624 * it for the socket msk
625 */
mctp_alloc_local_tag(struct mctp_sock * msk,mctp_eid_t daddr,mctp_eid_t saddr,bool manual,u8 * tagp)626 struct mctp_sk_key *mctp_alloc_local_tag(struct mctp_sock *msk,
627 mctp_eid_t daddr, mctp_eid_t saddr,
628 bool manual, u8 *tagp)
629 {
630 struct net *net = sock_net(&msk->sk);
631 struct netns_mctp *mns = &net->mctp;
632 struct mctp_sk_key *key, *tmp;
633 unsigned long flags;
634 u8 tagbits;
635
636 /* for NULL destination EIDs, we may get a response from any peer */
637 if (daddr == MCTP_ADDR_NULL)
638 daddr = MCTP_ADDR_ANY;
639
640 /* be optimistic, alloc now */
641 key = mctp_key_alloc(msk, saddr, daddr, 0, GFP_KERNEL);
642 if (!key)
643 return ERR_PTR(-ENOMEM);
644
645 /* 8 possible tag values */
646 tagbits = 0xff;
647
648 spin_lock_irqsave(&mns->keys_lock, flags);
649
650 /* Walk through the existing keys, looking for potential conflicting
651 * tags. If we find a conflict, clear that bit from tagbits
652 */
653 hlist_for_each_entry(tmp, &mns->keys, hlist) {
654 /* We can check the lookup fields (*_addr, tag) without the
655 * lock held, they don't change over the lifetime of the key.
656 */
657
658 /* if we don't own the tag, it can't conflict */
659 if (tmp->tag & MCTP_HDR_FLAG_TO)
660 continue;
661
662 if (!(mctp_address_matches(tmp->peer_addr, daddr) &&
663 mctp_address_matches(tmp->local_addr, saddr)))
664 continue;
665
666 spin_lock(&tmp->lock);
667 /* key must still be valid. If we find a match, clear the
668 * potential tag value
669 */
670 if (tmp->valid)
671 tagbits &= ~(1 << tmp->tag);
672 spin_unlock(&tmp->lock);
673
674 if (!tagbits)
675 break;
676 }
677
678 if (tagbits) {
679 key->tag = __ffs(tagbits);
680 mctp_reserve_tag(net, key, msk);
681 trace_mctp_key_acquire(key);
682
683 key->manual_alloc = manual;
684 *tagp = key->tag;
685 }
686
687 spin_unlock_irqrestore(&mns->keys_lock, flags);
688
689 if (!tagbits) {
690 mctp_key_unref(key);
691 return ERR_PTR(-EBUSY);
692 }
693
694 return key;
695 }
696
mctp_lookup_prealloc_tag(struct mctp_sock * msk,mctp_eid_t daddr,u8 req_tag,u8 * tagp)697 static struct mctp_sk_key *mctp_lookup_prealloc_tag(struct mctp_sock *msk,
698 mctp_eid_t daddr,
699 u8 req_tag, u8 *tagp)
700 {
701 struct net *net = sock_net(&msk->sk);
702 struct netns_mctp *mns = &net->mctp;
703 struct mctp_sk_key *key, *tmp;
704 unsigned long flags;
705
706 req_tag &= ~(MCTP_TAG_PREALLOC | MCTP_TAG_OWNER);
707 key = NULL;
708
709 spin_lock_irqsave(&mns->keys_lock, flags);
710
711 hlist_for_each_entry(tmp, &mns->keys, hlist) {
712 if (tmp->tag != req_tag)
713 continue;
714
715 if (!mctp_address_matches(tmp->peer_addr, daddr))
716 continue;
717
718 if (!tmp->manual_alloc)
719 continue;
720
721 spin_lock(&tmp->lock);
722 if (tmp->valid) {
723 key = tmp;
724 refcount_inc(&key->refs);
725 spin_unlock(&tmp->lock);
726 break;
727 }
728 spin_unlock(&tmp->lock);
729 }
730 spin_unlock_irqrestore(&mns->keys_lock, flags);
731
732 if (!key)
733 return ERR_PTR(-ENOENT);
734
735 if (tagp)
736 *tagp = key->tag;
737
738 return key;
739 }
740
741 /* routing lookups */
mctp_rt_match_eid(struct mctp_route * rt,unsigned int net,mctp_eid_t eid)742 static bool mctp_rt_match_eid(struct mctp_route *rt,
743 unsigned int net, mctp_eid_t eid)
744 {
745 return READ_ONCE(rt->dev->net) == net &&
746 rt->min <= eid && rt->max >= eid;
747 }
748
749 /* compares match, used for duplicate prevention */
mctp_rt_compare_exact(struct mctp_route * rt1,struct mctp_route * rt2)750 static bool mctp_rt_compare_exact(struct mctp_route *rt1,
751 struct mctp_route *rt2)
752 {
753 ASSERT_RTNL();
754 return rt1->dev->net == rt2->dev->net &&
755 rt1->min == rt2->min &&
756 rt1->max == rt2->max;
757 }
758
mctp_route_lookup(struct net * net,unsigned int dnet,mctp_eid_t daddr)759 struct mctp_route *mctp_route_lookup(struct net *net, unsigned int dnet,
760 mctp_eid_t daddr)
761 {
762 struct mctp_route *tmp, *rt = NULL;
763
764 rcu_read_lock();
765
766 list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
767 /* TODO: add metrics */
768 if (mctp_rt_match_eid(tmp, dnet, daddr)) {
769 if (refcount_inc_not_zero(&tmp->refs)) {
770 rt = tmp;
771 break;
772 }
773 }
774 }
775
776 rcu_read_unlock();
777
778 return rt;
779 }
780
mctp_route_lookup_null(struct net * net,struct net_device * dev)781 static struct mctp_route *mctp_route_lookup_null(struct net *net,
782 struct net_device *dev)
783 {
784 struct mctp_route *tmp, *rt = NULL;
785
786 rcu_read_lock();
787
788 list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
789 if (tmp->dev->dev == dev && tmp->type == RTN_LOCAL &&
790 refcount_inc_not_zero(&tmp->refs)) {
791 rt = tmp;
792 break;
793 }
794 }
795
796 rcu_read_unlock();
797
798 return rt;
799 }
800
mctp_do_fragment_route(struct mctp_route * rt,struct sk_buff * skb,unsigned int mtu,u8 tag)801 static int mctp_do_fragment_route(struct mctp_route *rt, struct sk_buff *skb,
802 unsigned int mtu, u8 tag)
803 {
804 const unsigned int hlen = sizeof(struct mctp_hdr);
805 struct mctp_hdr *hdr, *hdr2;
806 unsigned int pos, size, headroom;
807 struct sk_buff *skb2;
808 int rc;
809 u8 seq;
810
811 hdr = mctp_hdr(skb);
812 seq = 0;
813 rc = 0;
814
815 if (mtu < hlen + 1) {
816 kfree_skb(skb);
817 return -EMSGSIZE;
818 }
819
820 /* keep same headroom as the original skb */
821 headroom = skb_headroom(skb);
822
823 /* we've got the header */
824 skb_pull(skb, hlen);
825
826 for (pos = 0; pos < skb->len;) {
827 /* size of message payload */
828 size = min(mtu - hlen, skb->len - pos);
829
830 skb2 = alloc_skb(headroom + hlen + size, GFP_KERNEL);
831 if (!skb2) {
832 rc = -ENOMEM;
833 break;
834 }
835
836 /* generic skb copy */
837 skb2->protocol = skb->protocol;
838 skb2->priority = skb->priority;
839 skb2->dev = skb->dev;
840 memcpy(skb2->cb, skb->cb, sizeof(skb2->cb));
841
842 if (skb->sk)
843 skb_set_owner_w(skb2, skb->sk);
844
845 /* establish packet */
846 skb_reserve(skb2, headroom);
847 skb_reset_network_header(skb2);
848 skb_put(skb2, hlen + size);
849 skb2->transport_header = skb2->network_header + hlen;
850
851 /* copy header fields, calculate SOM/EOM flags & seq */
852 hdr2 = mctp_hdr(skb2);
853 hdr2->ver = hdr->ver;
854 hdr2->dest = hdr->dest;
855 hdr2->src = hdr->src;
856 hdr2->flags_seq_tag = tag &
857 (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
858
859 if (pos == 0)
860 hdr2->flags_seq_tag |= MCTP_HDR_FLAG_SOM;
861
862 if (pos + size == skb->len)
863 hdr2->flags_seq_tag |= MCTP_HDR_FLAG_EOM;
864
865 hdr2->flags_seq_tag |= seq << MCTP_HDR_SEQ_SHIFT;
866
867 /* copy message payload */
868 skb_copy_bits(skb, pos, skb_transport_header(skb2), size);
869
870 /* we need to copy the extensions, for MCTP flow data */
871 skb_ext_copy(skb2, skb);
872
873 /* do route */
874 rc = rt->output(rt, skb2);
875 if (rc)
876 break;
877
878 seq = (seq + 1) & MCTP_HDR_SEQ_MASK;
879 pos += size;
880 }
881
882 consume_skb(skb);
883 return rc;
884 }
885
mctp_local_output(struct sock * sk,struct mctp_route * rt,struct sk_buff * skb,mctp_eid_t daddr,u8 req_tag)886 int mctp_local_output(struct sock *sk, struct mctp_route *rt,
887 struct sk_buff *skb, mctp_eid_t daddr, u8 req_tag)
888 {
889 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
890 struct mctp_skb_cb *cb = mctp_cb(skb);
891 struct mctp_route tmp_rt = {0};
892 struct mctp_sk_key *key;
893 struct mctp_hdr *hdr;
894 unsigned long flags;
895 unsigned int mtu;
896 mctp_eid_t saddr;
897 bool ext_rt;
898 int rc;
899 u8 tag;
900
901 rc = -ENODEV;
902
903 if (rt) {
904 ext_rt = false;
905 if (WARN_ON(!rt->dev))
906 goto out_release;
907
908 } else if (cb->ifindex) {
909 struct net_device *dev;
910
911 ext_rt = true;
912 rt = &tmp_rt;
913
914 rcu_read_lock();
915 dev = dev_get_by_index_rcu(sock_net(sk), cb->ifindex);
916 if (!dev) {
917 rcu_read_unlock();
918 goto out_free;
919 }
920 rt->dev = __mctp_dev_get(dev);
921 rcu_read_unlock();
922
923 if (!rt->dev)
924 goto out_release;
925
926 /* establish temporary route - we set up enough to keep
927 * mctp_route_output happy
928 */
929 rt->output = mctp_route_output;
930 rt->mtu = 0;
931
932 } else {
933 rc = -EINVAL;
934 goto out_free;
935 }
936
937 spin_lock_irqsave(&rt->dev->addrs_lock, flags);
938 if (rt->dev->num_addrs == 0) {
939 rc = -EHOSTUNREACH;
940 } else {
941 /* use the outbound interface's first address as our source */
942 saddr = rt->dev->addrs[0];
943 rc = 0;
944 }
945 spin_unlock_irqrestore(&rt->dev->addrs_lock, flags);
946
947 if (rc)
948 goto out_release;
949
950 if (req_tag & MCTP_TAG_OWNER) {
951 if (req_tag & MCTP_TAG_PREALLOC)
952 key = mctp_lookup_prealloc_tag(msk, daddr,
953 req_tag, &tag);
954 else
955 key = mctp_alloc_local_tag(msk, daddr, saddr,
956 false, &tag);
957
958 if (IS_ERR(key)) {
959 rc = PTR_ERR(key);
960 goto out_release;
961 }
962 mctp_skb_set_flow(skb, key);
963 /* done with the key in this scope */
964 mctp_key_unref(key);
965 tag |= MCTP_HDR_FLAG_TO;
966 } else {
967 key = NULL;
968 tag = req_tag & MCTP_TAG_MASK;
969 }
970
971 skb->protocol = htons(ETH_P_MCTP);
972 skb->priority = 0;
973 skb_reset_transport_header(skb);
974 skb_push(skb, sizeof(struct mctp_hdr));
975 skb_reset_network_header(skb);
976 skb->dev = rt->dev->dev;
977
978 /* cb->net will have been set on initial ingress */
979 cb->src = saddr;
980
981 /* set up common header fields */
982 hdr = mctp_hdr(skb);
983 hdr->ver = 1;
984 hdr->dest = daddr;
985 hdr->src = saddr;
986
987 mtu = mctp_route_mtu(rt);
988
989 if (skb->len + sizeof(struct mctp_hdr) <= mtu) {
990 hdr->flags_seq_tag = MCTP_HDR_FLAG_SOM |
991 MCTP_HDR_FLAG_EOM | tag;
992 rc = rt->output(rt, skb);
993 } else {
994 rc = mctp_do_fragment_route(rt, skb, mtu, tag);
995 }
996
997 /* route output functions consume the skb, even on error */
998 skb = NULL;
999
1000 out_release:
1001 if (!ext_rt)
1002 mctp_route_release(rt);
1003
1004 mctp_dev_put(tmp_rt.dev);
1005
1006 out_free:
1007 kfree_skb(skb);
1008 return rc;
1009 }
1010
1011 /* route management */
mctp_route_add(struct mctp_dev * mdev,mctp_eid_t daddr_start,unsigned int daddr_extent,unsigned int mtu,unsigned char type)1012 static int mctp_route_add(struct mctp_dev *mdev, mctp_eid_t daddr_start,
1013 unsigned int daddr_extent, unsigned int mtu,
1014 unsigned char type)
1015 {
1016 int (*rtfn)(struct mctp_route *rt, struct sk_buff *skb);
1017 struct net *net = dev_net(mdev->dev);
1018 struct mctp_route *rt, *ert;
1019
1020 if (!mctp_address_unicast(daddr_start))
1021 return -EINVAL;
1022
1023 if (daddr_extent > 0xff || daddr_start + daddr_extent >= 255)
1024 return -EINVAL;
1025
1026 switch (type) {
1027 case RTN_LOCAL:
1028 rtfn = mctp_route_input;
1029 break;
1030 case RTN_UNICAST:
1031 rtfn = mctp_route_output;
1032 break;
1033 default:
1034 return -EINVAL;
1035 }
1036
1037 rt = mctp_route_alloc();
1038 if (!rt)
1039 return -ENOMEM;
1040
1041 rt->min = daddr_start;
1042 rt->max = daddr_start + daddr_extent;
1043 rt->mtu = mtu;
1044 rt->dev = mdev;
1045 mctp_dev_hold(rt->dev);
1046 rt->type = type;
1047 rt->output = rtfn;
1048
1049 ASSERT_RTNL();
1050 /* Prevent duplicate identical routes. */
1051 list_for_each_entry(ert, &net->mctp.routes, list) {
1052 if (mctp_rt_compare_exact(rt, ert)) {
1053 mctp_route_release(rt);
1054 return -EEXIST;
1055 }
1056 }
1057
1058 list_add_rcu(&rt->list, &net->mctp.routes);
1059
1060 return 0;
1061 }
1062
mctp_route_remove(struct mctp_dev * mdev,mctp_eid_t daddr_start,unsigned int daddr_extent,unsigned char type)1063 static int mctp_route_remove(struct mctp_dev *mdev, mctp_eid_t daddr_start,
1064 unsigned int daddr_extent, unsigned char type)
1065 {
1066 struct net *net = dev_net(mdev->dev);
1067 struct mctp_route *rt, *tmp;
1068 mctp_eid_t daddr_end;
1069 bool dropped;
1070
1071 if (daddr_extent > 0xff || daddr_start + daddr_extent >= 255)
1072 return -EINVAL;
1073
1074 daddr_end = daddr_start + daddr_extent;
1075 dropped = false;
1076
1077 ASSERT_RTNL();
1078
1079 list_for_each_entry_safe(rt, tmp, &net->mctp.routes, list) {
1080 if (rt->dev == mdev &&
1081 rt->min == daddr_start && rt->max == daddr_end &&
1082 rt->type == type) {
1083 list_del_rcu(&rt->list);
1084 /* TODO: immediate RTM_DELROUTE */
1085 mctp_route_release(rt);
1086 dropped = true;
1087 }
1088 }
1089
1090 return dropped ? 0 : -ENOENT;
1091 }
1092
mctp_route_add_local(struct mctp_dev * mdev,mctp_eid_t addr)1093 int mctp_route_add_local(struct mctp_dev *mdev, mctp_eid_t addr)
1094 {
1095 return mctp_route_add(mdev, addr, 0, 0, RTN_LOCAL);
1096 }
1097
mctp_route_remove_local(struct mctp_dev * mdev,mctp_eid_t addr)1098 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr)
1099 {
1100 return mctp_route_remove(mdev, addr, 0, RTN_LOCAL);
1101 }
1102
1103 /* removes all entries for a given device */
mctp_route_remove_dev(struct mctp_dev * mdev)1104 void mctp_route_remove_dev(struct mctp_dev *mdev)
1105 {
1106 struct net *net = dev_net(mdev->dev);
1107 struct mctp_route *rt, *tmp;
1108
1109 ASSERT_RTNL();
1110 list_for_each_entry_safe(rt, tmp, &net->mctp.routes, list) {
1111 if (rt->dev == mdev) {
1112 list_del_rcu(&rt->list);
1113 /* TODO: immediate RTM_DELROUTE */
1114 mctp_route_release(rt);
1115 }
1116 }
1117 }
1118
1119 /* Incoming packet-handling */
1120
mctp_pkttype_receive(struct sk_buff * skb,struct net_device * dev,struct packet_type * pt,struct net_device * orig_dev)1121 static int mctp_pkttype_receive(struct sk_buff *skb, struct net_device *dev,
1122 struct packet_type *pt,
1123 struct net_device *orig_dev)
1124 {
1125 struct net *net = dev_net(dev);
1126 struct mctp_dev *mdev;
1127 struct mctp_skb_cb *cb;
1128 struct mctp_route *rt;
1129 struct mctp_hdr *mh;
1130
1131 rcu_read_lock();
1132 mdev = __mctp_dev_get(dev);
1133 rcu_read_unlock();
1134 if (!mdev) {
1135 /* basic non-data sanity checks */
1136 goto err_drop;
1137 }
1138
1139 if (!pskb_may_pull(skb, sizeof(struct mctp_hdr)))
1140 goto err_drop;
1141
1142 skb_reset_transport_header(skb);
1143 skb_reset_network_header(skb);
1144
1145 /* We have enough for a header; decode and route */
1146 mh = mctp_hdr(skb);
1147 if (mh->ver < MCTP_VER_MIN || mh->ver > MCTP_VER_MAX)
1148 goto err_drop;
1149
1150 /* source must be valid unicast or null; drop reserved ranges and
1151 * broadcast
1152 */
1153 if (!(mctp_address_unicast(mh->src) || mctp_address_null(mh->src)))
1154 goto err_drop;
1155
1156 /* dest address: as above, but allow broadcast */
1157 if (!(mctp_address_unicast(mh->dest) || mctp_address_null(mh->dest) ||
1158 mctp_address_broadcast(mh->dest)))
1159 goto err_drop;
1160
1161 /* MCTP drivers must populate halen/haddr */
1162 if (dev->type == ARPHRD_MCTP) {
1163 cb = mctp_cb(skb);
1164 } else {
1165 cb = __mctp_cb(skb);
1166 cb->halen = 0;
1167 }
1168 cb->net = READ_ONCE(mdev->net);
1169 cb->ifindex = dev->ifindex;
1170
1171 rt = mctp_route_lookup(net, cb->net, mh->dest);
1172
1173 /* NULL EID, but addressed to our physical address */
1174 if (!rt && mh->dest == MCTP_ADDR_NULL && skb->pkt_type == PACKET_HOST)
1175 rt = mctp_route_lookup_null(net, dev);
1176
1177 if (!rt)
1178 goto err_drop;
1179
1180 rt->output(rt, skb);
1181 mctp_route_release(rt);
1182 mctp_dev_put(mdev);
1183
1184 return NET_RX_SUCCESS;
1185
1186 err_drop:
1187 kfree_skb(skb);
1188 mctp_dev_put(mdev);
1189 return NET_RX_DROP;
1190 }
1191
1192 static struct packet_type mctp_packet_type = {
1193 .type = cpu_to_be16(ETH_P_MCTP),
1194 .func = mctp_pkttype_receive,
1195 };
1196
1197 /* netlink interface */
1198
1199 static const struct nla_policy rta_mctp_policy[RTA_MAX + 1] = {
1200 [RTA_DST] = { .type = NLA_U8 },
1201 [RTA_METRICS] = { .type = NLA_NESTED },
1202 [RTA_OIF] = { .type = NLA_U32 },
1203 };
1204
1205 /* Common part for RTM_NEWROUTE and RTM_DELROUTE parsing.
1206 * tb must hold RTA_MAX+1 elements.
1207 */
mctp_route_nlparse(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack,struct nlattr ** tb,struct rtmsg ** rtm,struct mctp_dev ** mdev,mctp_eid_t * daddr_start)1208 static int mctp_route_nlparse(struct sk_buff *skb, struct nlmsghdr *nlh,
1209 struct netlink_ext_ack *extack,
1210 struct nlattr **tb, struct rtmsg **rtm,
1211 struct mctp_dev **mdev, mctp_eid_t *daddr_start)
1212 {
1213 struct net *net = sock_net(skb->sk);
1214 struct net_device *dev;
1215 unsigned int ifindex;
1216 int rc;
1217
1218 rc = nlmsg_parse(nlh, sizeof(struct rtmsg), tb, RTA_MAX,
1219 rta_mctp_policy, extack);
1220 if (rc < 0) {
1221 NL_SET_ERR_MSG(extack, "incorrect format");
1222 return rc;
1223 }
1224
1225 if (!tb[RTA_DST]) {
1226 NL_SET_ERR_MSG(extack, "dst EID missing");
1227 return -EINVAL;
1228 }
1229 *daddr_start = nla_get_u8(tb[RTA_DST]);
1230
1231 if (!tb[RTA_OIF]) {
1232 NL_SET_ERR_MSG(extack, "ifindex missing");
1233 return -EINVAL;
1234 }
1235 ifindex = nla_get_u32(tb[RTA_OIF]);
1236
1237 *rtm = nlmsg_data(nlh);
1238 if ((*rtm)->rtm_family != AF_MCTP) {
1239 NL_SET_ERR_MSG(extack, "route family must be AF_MCTP");
1240 return -EINVAL;
1241 }
1242
1243 dev = __dev_get_by_index(net, ifindex);
1244 if (!dev) {
1245 NL_SET_ERR_MSG(extack, "bad ifindex");
1246 return -ENODEV;
1247 }
1248 *mdev = mctp_dev_get_rtnl(dev);
1249 if (!*mdev)
1250 return -ENODEV;
1251
1252 if (dev->flags & IFF_LOOPBACK) {
1253 NL_SET_ERR_MSG(extack, "no routes to loopback");
1254 return -EINVAL;
1255 }
1256
1257 return 0;
1258 }
1259
1260 static const struct nla_policy rta_metrics_policy[RTAX_MAX + 1] = {
1261 [RTAX_MTU] = { .type = NLA_U32 },
1262 };
1263
mctp_newroute(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)1264 static int mctp_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
1265 struct netlink_ext_ack *extack)
1266 {
1267 struct nlattr *tb[RTA_MAX + 1];
1268 struct nlattr *tbx[RTAX_MAX + 1];
1269 mctp_eid_t daddr_start;
1270 struct mctp_dev *mdev;
1271 struct rtmsg *rtm;
1272 unsigned int mtu;
1273 int rc;
1274
1275 rc = mctp_route_nlparse(skb, nlh, extack, tb,
1276 &rtm, &mdev, &daddr_start);
1277 if (rc < 0)
1278 return rc;
1279
1280 if (rtm->rtm_type != RTN_UNICAST) {
1281 NL_SET_ERR_MSG(extack, "rtm_type must be RTN_UNICAST");
1282 return -EINVAL;
1283 }
1284
1285 mtu = 0;
1286 if (tb[RTA_METRICS]) {
1287 rc = nla_parse_nested(tbx, RTAX_MAX, tb[RTA_METRICS],
1288 rta_metrics_policy, NULL);
1289 if (rc < 0)
1290 return rc;
1291 if (tbx[RTAX_MTU])
1292 mtu = nla_get_u32(tbx[RTAX_MTU]);
1293 }
1294
1295 rc = mctp_route_add(mdev, daddr_start, rtm->rtm_dst_len, mtu,
1296 rtm->rtm_type);
1297 return rc;
1298 }
1299
mctp_delroute(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)1300 static int mctp_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
1301 struct netlink_ext_ack *extack)
1302 {
1303 struct nlattr *tb[RTA_MAX + 1];
1304 mctp_eid_t daddr_start;
1305 struct mctp_dev *mdev;
1306 struct rtmsg *rtm;
1307 int rc;
1308
1309 rc = mctp_route_nlparse(skb, nlh, extack, tb,
1310 &rtm, &mdev, &daddr_start);
1311 if (rc < 0)
1312 return rc;
1313
1314 /* we only have unicast routes */
1315 if (rtm->rtm_type != RTN_UNICAST)
1316 return -EINVAL;
1317
1318 rc = mctp_route_remove(mdev, daddr_start, rtm->rtm_dst_len, RTN_UNICAST);
1319 return rc;
1320 }
1321
mctp_fill_rtinfo(struct sk_buff * skb,struct mctp_route * rt,u32 portid,u32 seq,int event,unsigned int flags)1322 static int mctp_fill_rtinfo(struct sk_buff *skb, struct mctp_route *rt,
1323 u32 portid, u32 seq, int event, unsigned int flags)
1324 {
1325 struct nlmsghdr *nlh;
1326 struct rtmsg *hdr;
1327 void *metrics;
1328
1329 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
1330 if (!nlh)
1331 return -EMSGSIZE;
1332
1333 hdr = nlmsg_data(nlh);
1334 hdr->rtm_family = AF_MCTP;
1335
1336 /* we use the _len fields as a number of EIDs, rather than
1337 * a number of bits in the address
1338 */
1339 hdr->rtm_dst_len = rt->max - rt->min;
1340 hdr->rtm_src_len = 0;
1341 hdr->rtm_tos = 0;
1342 hdr->rtm_table = RT_TABLE_DEFAULT;
1343 hdr->rtm_protocol = RTPROT_STATIC; /* everything is user-defined */
1344 hdr->rtm_scope = RT_SCOPE_LINK; /* TODO: scope in mctp_route? */
1345 hdr->rtm_type = rt->type;
1346
1347 if (nla_put_u8(skb, RTA_DST, rt->min))
1348 goto cancel;
1349
1350 metrics = nla_nest_start_noflag(skb, RTA_METRICS);
1351 if (!metrics)
1352 goto cancel;
1353
1354 if (rt->mtu) {
1355 if (nla_put_u32(skb, RTAX_MTU, rt->mtu))
1356 goto cancel;
1357 }
1358
1359 nla_nest_end(skb, metrics);
1360
1361 if (rt->dev) {
1362 if (nla_put_u32(skb, RTA_OIF, rt->dev->dev->ifindex))
1363 goto cancel;
1364 }
1365
1366 /* TODO: conditional neighbour physaddr? */
1367
1368 nlmsg_end(skb, nlh);
1369
1370 return 0;
1371
1372 cancel:
1373 nlmsg_cancel(skb, nlh);
1374 return -EMSGSIZE;
1375 }
1376
mctp_dump_rtinfo(struct sk_buff * skb,struct netlink_callback * cb)1377 static int mctp_dump_rtinfo(struct sk_buff *skb, struct netlink_callback *cb)
1378 {
1379 struct net *net = sock_net(skb->sk);
1380 struct mctp_route *rt;
1381 int s_idx, idx;
1382
1383 /* TODO: allow filtering on route data, possibly under
1384 * cb->strict_check
1385 */
1386
1387 /* TODO: change to struct overlay */
1388 s_idx = cb->args[0];
1389 idx = 0;
1390
1391 rcu_read_lock();
1392 list_for_each_entry_rcu(rt, &net->mctp.routes, list) {
1393 if (idx++ < s_idx)
1394 continue;
1395 if (mctp_fill_rtinfo(skb, rt,
1396 NETLINK_CB(cb->skb).portid,
1397 cb->nlh->nlmsg_seq,
1398 RTM_NEWROUTE, NLM_F_MULTI) < 0)
1399 break;
1400 }
1401
1402 rcu_read_unlock();
1403 cb->args[0] = idx;
1404
1405 return skb->len;
1406 }
1407
1408 /* net namespace implementation */
mctp_routes_net_init(struct net * net)1409 static int __net_init mctp_routes_net_init(struct net *net)
1410 {
1411 struct netns_mctp *ns = &net->mctp;
1412
1413 INIT_LIST_HEAD(&ns->routes);
1414 INIT_HLIST_HEAD(&ns->binds);
1415 mutex_init(&ns->bind_lock);
1416 INIT_HLIST_HEAD(&ns->keys);
1417 spin_lock_init(&ns->keys_lock);
1418 WARN_ON(mctp_default_net_set(net, MCTP_INITIAL_DEFAULT_NET));
1419 return 0;
1420 }
1421
mctp_routes_net_exit(struct net * net)1422 static void __net_exit mctp_routes_net_exit(struct net *net)
1423 {
1424 struct mctp_route *rt;
1425
1426 rcu_read_lock();
1427 list_for_each_entry_rcu(rt, &net->mctp.routes, list)
1428 mctp_route_release(rt);
1429 rcu_read_unlock();
1430 }
1431
1432 static struct pernet_operations mctp_net_ops = {
1433 .init = mctp_routes_net_init,
1434 .exit = mctp_routes_net_exit,
1435 };
1436
1437 static const struct rtnl_msg_handler mctp_route_rtnl_msg_handlers[] = {
1438 {THIS_MODULE, PF_MCTP, RTM_NEWROUTE, mctp_newroute, NULL, 0},
1439 {THIS_MODULE, PF_MCTP, RTM_DELROUTE, mctp_delroute, NULL, 0},
1440 {THIS_MODULE, PF_MCTP, RTM_GETROUTE, NULL, mctp_dump_rtinfo, 0},
1441 };
1442
mctp_routes_init(void)1443 int __init mctp_routes_init(void)
1444 {
1445 int err;
1446
1447 dev_add_pack(&mctp_packet_type);
1448
1449 err = register_pernet_subsys(&mctp_net_ops);
1450 if (err)
1451 goto err_pernet;
1452
1453 err = rtnl_register_many(mctp_route_rtnl_msg_handlers);
1454 if (err)
1455 goto err_rtnl;
1456
1457 return 0;
1458
1459 err_rtnl:
1460 unregister_pernet_subsys(&mctp_net_ops);
1461 err_pernet:
1462 dev_remove_pack(&mctp_packet_type);
1463 return err;
1464 }
1465
mctp_routes_exit(void)1466 void mctp_routes_exit(void)
1467 {
1468 rtnl_unregister_many(mctp_route_rtnl_msg_handlers);
1469 unregister_pernet_subsys(&mctp_net_ops);
1470 dev_remove_pack(&mctp_packet_type);
1471 }
1472
1473 #if IS_ENABLED(CONFIG_MCTP_TEST)
1474 #include "test/route-test.c"
1475 #endif
1476