1 // SPDX-License-Identifier: GPL-2.0
3 * Management Component Transport Protocol (MCTP) - routing
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.
9 * Copyright (c) 2021 Code Construct
10 * Copyright (c) 2021 Google
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>
20 #include <uapi/linux/if_arp.h>
23 #include <net/mctpdevice.h>
24 #include <net/netlink.h>
27 #include <trace/events/mctp.h>
29 static const unsigned int mctp_message_maxlen = 64 * 1024;
30 static const unsigned long mctp_key_lifetime = 6 * CONFIG_HZ;
32 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev);
34 /* route output callbacks */
35 static int mctp_route_discard(struct mctp_route *route, struct sk_buff *skb)
41 static struct mctp_sock *mctp_lookup_bind(struct net *net, struct sk_buff *skb)
43 struct mctp_skb_cb *cb = mctp_cb(skb);
48 WARN_ON(!rcu_read_lock_held());
50 /* TODO: look up in skb->cb? */
53 if (!skb_headlen(skb))
56 type = (*(u8 *)skb->data) & 0x7f;
58 sk_for_each_rcu(sk, &net->mctp.binds) {
59 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
61 if (msk->bind_net != MCTP_NET_ANY && msk->bind_net != cb->net)
64 if (msk->bind_type != type)
67 if (!mctp_address_matches(msk->bind_addr, mh->dest))
76 static bool mctp_key_match(struct mctp_sk_key *key, mctp_eid_t local,
77 mctp_eid_t peer, u8 tag)
79 if (!mctp_address_matches(key->local_addr, local))
82 if (key->peer_addr != peer)
91 /* returns a key (with key->lock held, and refcounted), or NULL if no such
94 static struct mctp_sk_key *mctp_lookup_key(struct net *net, struct sk_buff *skb,
96 unsigned long *irqflags)
97 __acquires(&key->lock)
99 struct mctp_sk_key *key, *ret;
105 tag = mh->flags_seq_tag & (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
108 spin_lock_irqsave(&net->mctp.keys_lock, flags);
110 hlist_for_each_entry(key, &net->mctp.keys, hlist) {
111 if (!mctp_key_match(key, mh->dest, peer, tag))
114 spin_lock(&key->lock);
116 refcount_inc(&key->refs);
120 spin_unlock(&key->lock);
124 spin_unlock(&net->mctp.keys_lock);
127 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
133 static struct mctp_sk_key *mctp_key_alloc(struct mctp_sock *msk,
134 mctp_eid_t local, mctp_eid_t peer,
137 struct mctp_sk_key *key;
139 key = kzalloc(sizeof(*key), gfp);
143 key->peer_addr = peer;
144 key->local_addr = local;
148 spin_lock_init(&key->lock);
149 refcount_set(&key->refs, 1);
155 void mctp_key_unref(struct mctp_sk_key *key)
159 if (!refcount_dec_and_test(&key->refs))
162 /* even though no refs exist here, the lock allows us to stay
163 * consistent with the locking requirement of mctp_dev_release_key
165 spin_lock_irqsave(&key->lock, flags);
166 mctp_dev_release_key(key->dev, key);
167 spin_unlock_irqrestore(&key->lock, flags);
173 static int mctp_key_add(struct mctp_sk_key *key, struct mctp_sock *msk)
175 struct net *net = sock_net(&msk->sk);
176 struct mctp_sk_key *tmp;
180 spin_lock_irqsave(&net->mctp.keys_lock, flags);
182 if (sock_flag(&msk->sk, SOCK_DEAD)) {
187 hlist_for_each_entry(tmp, &net->mctp.keys, hlist) {
188 if (mctp_key_match(tmp, key->local_addr, key->peer_addr,
190 spin_lock(&tmp->lock);
193 spin_unlock(&tmp->lock);
200 refcount_inc(&key->refs);
201 key->expiry = jiffies + mctp_key_lifetime;
202 timer_reduce(&msk->key_expiry, key->expiry);
204 hlist_add_head(&key->hlist, &net->mctp.keys);
205 hlist_add_head(&key->sklist, &msk->keys);
209 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
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.
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)
226 trace_mctp_key_release(key, reason);
227 skb = key->reasm_head;
228 key->reasm_head = NULL;
230 if (!key->manual_alloc) {
231 key->reasm_dead = true;
233 mctp_dev_release_key(key->dev, key);
235 spin_unlock_irqrestore(&key->lock, flags);
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);
244 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
247 /* and one for the local reference */
253 #ifdef CONFIG_MCTP_FLOWS
254 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key)
256 struct mctp_flow *flow;
258 flow = skb_ext_add(skb, SKB_EXT_MCTP);
262 refcount_inc(&key->refs);
266 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev)
268 struct mctp_sk_key *key;
269 struct mctp_flow *flow;
271 flow = skb_ext_find(skb, SKB_EXT_MCTP);
277 if (WARN_ON(key->dev && key->dev != dev))
280 mctp_dev_set_key(dev, key);
283 static void mctp_skb_set_flow(struct sk_buff *skb, struct mctp_sk_key *key) {}
284 static void mctp_flow_prepare_output(struct sk_buff *skb, struct mctp_dev *dev) {}
287 static int mctp_frag_queue(struct mctp_sk_key *key, struct sk_buff *skb)
289 struct mctp_hdr *hdr = mctp_hdr(skb);
290 u8 exp_seq, this_seq;
292 this_seq = (hdr->flags_seq_tag >> MCTP_HDR_SEQ_SHIFT)
295 if (!key->reasm_head) {
296 key->reasm_head = skb;
297 key->reasm_tailp = &(skb_shinfo(skb)->frag_list);
298 key->last_seq = this_seq;
302 exp_seq = (key->last_seq + 1) & MCTP_HDR_SEQ_MASK;
304 if (this_seq != exp_seq)
307 if (key->reasm_head->len + skb->len > mctp_message_maxlen)
312 *key->reasm_tailp = skb;
313 key->reasm_tailp = &skb->next;
315 key->last_seq = this_seq;
317 key->reasm_head->data_len += skb->len;
318 key->reasm_head->len += skb->len;
319 key->reasm_head->truesize += skb->truesize;
324 static int mctp_route_input(struct mctp_route *route, struct sk_buff *skb)
326 struct mctp_sk_key *key, *any_key = NULL;
327 struct net *net = dev_net(skb->dev);
328 struct mctp_sock *msk;
337 /* we may be receiving a locally-routed packet; drop source sk
342 /* ensure we have enough data for a header and a type */
343 if (skb->len < sizeof(struct mctp_hdr) + 1)
346 /* grab header, advance data ptr */
348 skb_pull(skb, sizeof(struct mctp_hdr));
353 flags = mh->flags_seq_tag & (MCTP_HDR_FLAG_SOM | MCTP_HDR_FLAG_EOM);
354 tag = mh->flags_seq_tag & (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
358 /* lookup socket / reasm context, exactly matching (src,dest,tag).
359 * we hold a ref on the key, and key->lock held.
361 key = mctp_lookup_key(net, skb, mh->src, &f);
363 if (flags & MCTP_HDR_FLAG_SOM) {
365 msk = container_of(key->sk, struct mctp_sock, sk);
367 /* first response to a broadcast? do a more general
368 * key lookup to find the socket, but don't use this
369 * key for reassembly - we'll create a more specific
370 * one for future packets if required (ie, !EOM).
372 any_key = mctp_lookup_key(net, skb, MCTP_ADDR_ANY, &f);
374 msk = container_of(any_key->sk,
375 struct mctp_sock, sk);
376 spin_unlock_irqrestore(&any_key->lock, f);
380 if (!key && !msk && (tag & MCTP_HDR_FLAG_TO))
381 msk = mctp_lookup_bind(net, skb);
388 /* single-packet message? deliver to socket, clean up any
391 if (flags & MCTP_HDR_FLAG_EOM) {
392 sock_queue_rcv_skb(&msk->sk, skb);
394 /* we've hit a pending reassembly; not much we
397 __mctp_key_done_in(key, net, f,
398 MCTP_TRACE_KEY_REPLIED);
405 /* broadcast response or a bind() - create a key for further
406 * packets for this message
409 key = mctp_key_alloc(msk, mh->dest, mh->src,
416 /* we can queue without the key lock here, as the
417 * key isn't observable yet
419 mctp_frag_queue(key, skb);
421 /* if the key_add fails, we've raced with another
422 * SOM packet with the same src, dest and tag. There's
423 * no way to distinguish future packets, so all we
424 * can do is drop; we'll free the skb on exit from
427 rc = mctp_key_add(key, msk);
429 trace_mctp_key_acquire(key);
431 /* we don't need to release key->lock on exit, so
432 * clean up here and suppress the unlock via
439 if (key->reasm_head || key->reasm_dead) {
440 /* duplicate start? drop everything */
441 __mctp_key_done_in(key, net, f,
442 MCTP_TRACE_KEY_INVALIDATED);
446 rc = mctp_frag_queue(key, skb);
451 /* this packet continues a previous message; reassemble
452 * using the message-specific key
455 /* we need to be continuing an existing reassembly... */
456 if (!key->reasm_head)
459 rc = mctp_frag_queue(key, skb);
461 /* end of message? deliver to socket, and we're done with
462 * the reassembly/response key
464 if (!rc && flags & MCTP_HDR_FLAG_EOM) {
465 sock_queue_rcv_skb(key->sk, key->reasm_head);
466 key->reasm_head = NULL;
467 __mctp_key_done_in(key, net, f, MCTP_TRACE_KEY_REPLIED);
472 /* not a start, no matching key */
479 spin_unlock_irqrestore(&key->lock, f);
483 mctp_key_unref(any_key);
490 static unsigned int mctp_route_mtu(struct mctp_route *rt)
492 return rt->mtu ?: READ_ONCE(rt->dev->dev->mtu);
495 static int mctp_route_output(struct mctp_route *route, struct sk_buff *skb)
497 struct mctp_skb_cb *cb = mctp_cb(skb);
498 struct mctp_hdr *hdr = mctp_hdr(skb);
499 char daddr_buf[MAX_ADDR_LEN];
504 skb->protocol = htons(ETH_P_MCTP);
506 mtu = READ_ONCE(skb->dev->mtu);
507 if (skb->len > mtu) {
513 /* direct route; use the hwaddr we stashed in sendmsg */
514 if (cb->halen != skb->dev->addr_len) {
515 /* sanity check, sendmsg should have already caught this */
521 /* If lookup fails let the device handle daddr==NULL */
522 if (mctp_neigh_lookup(route->dev, hdr->dest, daddr_buf) == 0)
526 rc = dev_hard_header(skb, skb->dev, ntohs(skb->protocol),
527 daddr, skb->dev->dev_addr, skb->len);
530 return -EHOSTUNREACH;
533 mctp_flow_prepare_output(skb, route->dev);
535 rc = dev_queue_xmit(skb);
537 rc = net_xmit_errno(rc);
542 /* route alloc/release */
543 static void mctp_route_release(struct mctp_route *rt)
545 if (refcount_dec_and_test(&rt->refs)) {
546 mctp_dev_put(rt->dev);
551 /* returns a route with the refcount at 1 */
552 static struct mctp_route *mctp_route_alloc(void)
554 struct mctp_route *rt;
556 rt = kzalloc(sizeof(*rt), GFP_KERNEL);
560 INIT_LIST_HEAD(&rt->list);
561 refcount_set(&rt->refs, 1);
562 rt->output = mctp_route_discard;
567 unsigned int mctp_default_net(struct net *net)
569 return READ_ONCE(net->mctp.default_net);
572 int mctp_default_net_set(struct net *net, unsigned int index)
576 WRITE_ONCE(net->mctp.default_net, index);
581 static void mctp_reserve_tag(struct net *net, struct mctp_sk_key *key,
582 struct mctp_sock *msk)
584 struct netns_mctp *mns = &net->mctp;
586 lockdep_assert_held(&mns->keys_lock);
588 key->expiry = jiffies + mctp_key_lifetime;
589 timer_reduce(&msk->key_expiry, key->expiry);
591 /* we hold the net->key_lock here, allowing updates to both
594 hlist_add_head_rcu(&key->hlist, &mns->keys);
595 hlist_add_head_rcu(&key->sklist, &msk->keys);
596 refcount_inc(&key->refs);
599 /* Allocate a locally-owned tag value for (saddr, daddr), and reserve
600 * it for the socket msk
602 struct mctp_sk_key *mctp_alloc_local_tag(struct mctp_sock *msk,
603 mctp_eid_t daddr, mctp_eid_t saddr,
604 bool manual, u8 *tagp)
606 struct net *net = sock_net(&msk->sk);
607 struct netns_mctp *mns = &net->mctp;
608 struct mctp_sk_key *key, *tmp;
612 /* for NULL destination EIDs, we may get a response from any peer */
613 if (daddr == MCTP_ADDR_NULL)
614 daddr = MCTP_ADDR_ANY;
616 /* be optimistic, alloc now */
617 key = mctp_key_alloc(msk, saddr, daddr, 0, GFP_KERNEL);
619 return ERR_PTR(-ENOMEM);
621 /* 8 possible tag values */
624 spin_lock_irqsave(&mns->keys_lock, flags);
626 /* Walk through the existing keys, looking for potential conflicting
627 * tags. If we find a conflict, clear that bit from tagbits
629 hlist_for_each_entry(tmp, &mns->keys, hlist) {
630 /* We can check the lookup fields (*_addr, tag) without the
631 * lock held, they don't change over the lifetime of the key.
634 /* if we don't own the tag, it can't conflict */
635 if (tmp->tag & MCTP_HDR_FLAG_TO)
638 if (!(mctp_address_matches(tmp->peer_addr, daddr) &&
639 mctp_address_matches(tmp->local_addr, saddr)))
642 spin_lock(&tmp->lock);
643 /* key must still be valid. If we find a match, clear the
644 * potential tag value
647 tagbits &= ~(1 << tmp->tag);
648 spin_unlock(&tmp->lock);
655 key->tag = __ffs(tagbits);
656 mctp_reserve_tag(net, key, msk);
657 trace_mctp_key_acquire(key);
659 key->manual_alloc = manual;
663 spin_unlock_irqrestore(&mns->keys_lock, flags);
667 return ERR_PTR(-EBUSY);
673 static struct mctp_sk_key *mctp_lookup_prealloc_tag(struct mctp_sock *msk,
675 u8 req_tag, u8 *tagp)
677 struct net *net = sock_net(&msk->sk);
678 struct netns_mctp *mns = &net->mctp;
679 struct mctp_sk_key *key, *tmp;
682 req_tag &= ~(MCTP_TAG_PREALLOC | MCTP_TAG_OWNER);
685 spin_lock_irqsave(&mns->keys_lock, flags);
687 hlist_for_each_entry(tmp, &mns->keys, hlist) {
688 if (tmp->tag != req_tag)
691 if (!mctp_address_matches(tmp->peer_addr, daddr))
694 if (!tmp->manual_alloc)
697 spin_lock(&tmp->lock);
700 refcount_inc(&key->refs);
701 spin_unlock(&tmp->lock);
704 spin_unlock(&tmp->lock);
706 spin_unlock_irqrestore(&mns->keys_lock, flags);
709 return ERR_PTR(-ENOENT);
717 /* routing lookups */
718 static bool mctp_rt_match_eid(struct mctp_route *rt,
719 unsigned int net, mctp_eid_t eid)
721 return READ_ONCE(rt->dev->net) == net &&
722 rt->min <= eid && rt->max >= eid;
725 /* compares match, used for duplicate prevention */
726 static bool mctp_rt_compare_exact(struct mctp_route *rt1,
727 struct mctp_route *rt2)
730 return rt1->dev->net == rt2->dev->net &&
731 rt1->min == rt2->min &&
732 rt1->max == rt2->max;
735 struct mctp_route *mctp_route_lookup(struct net *net, unsigned int dnet,
738 struct mctp_route *tmp, *rt = NULL;
742 list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
743 /* TODO: add metrics */
744 if (mctp_rt_match_eid(tmp, dnet, daddr)) {
745 if (refcount_inc_not_zero(&tmp->refs)) {
757 static struct mctp_route *mctp_route_lookup_null(struct net *net,
758 struct net_device *dev)
760 struct mctp_route *tmp, *rt = NULL;
764 list_for_each_entry_rcu(tmp, &net->mctp.routes, list) {
765 if (tmp->dev->dev == dev && tmp->type == RTN_LOCAL &&
766 refcount_inc_not_zero(&tmp->refs)) {
777 static int mctp_do_fragment_route(struct mctp_route *rt, struct sk_buff *skb,
778 unsigned int mtu, u8 tag)
780 const unsigned int hlen = sizeof(struct mctp_hdr);
781 struct mctp_hdr *hdr, *hdr2;
782 unsigned int pos, size, headroom;
783 struct sk_buff *skb2;
791 if (mtu < hlen + 1) {
796 /* keep same headroom as the original skb */
797 headroom = skb_headroom(skb);
799 /* we've got the header */
802 for (pos = 0; pos < skb->len;) {
803 /* size of message payload */
804 size = min(mtu - hlen, skb->len - pos);
806 skb2 = alloc_skb(headroom + hlen + size, GFP_KERNEL);
812 /* generic skb copy */
813 skb2->protocol = skb->protocol;
814 skb2->priority = skb->priority;
815 skb2->dev = skb->dev;
816 memcpy(skb2->cb, skb->cb, sizeof(skb2->cb));
819 skb_set_owner_w(skb2, skb->sk);
821 /* establish packet */
822 skb_reserve(skb2, headroom);
823 skb_reset_network_header(skb2);
824 skb_put(skb2, hlen + size);
825 skb2->transport_header = skb2->network_header + hlen;
827 /* copy header fields, calculate SOM/EOM flags & seq */
828 hdr2 = mctp_hdr(skb2);
829 hdr2->ver = hdr->ver;
830 hdr2->dest = hdr->dest;
831 hdr2->src = hdr->src;
832 hdr2->flags_seq_tag = tag &
833 (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
836 hdr2->flags_seq_tag |= MCTP_HDR_FLAG_SOM;
838 if (pos + size == skb->len)
839 hdr2->flags_seq_tag |= MCTP_HDR_FLAG_EOM;
841 hdr2->flags_seq_tag |= seq << MCTP_HDR_SEQ_SHIFT;
843 /* copy message payload */
844 skb_copy_bits(skb, pos, skb_transport_header(skb2), size);
846 /* we need to copy the extensions, for MCTP flow data */
847 skb_ext_copy(skb2, skb);
850 rc = rt->output(rt, skb2);
854 seq = (seq + 1) & MCTP_HDR_SEQ_MASK;
862 int mctp_local_output(struct sock *sk, struct mctp_route *rt,
863 struct sk_buff *skb, mctp_eid_t daddr, u8 req_tag)
865 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
866 struct mctp_skb_cb *cb = mctp_cb(skb);
867 struct mctp_route tmp_rt = {0};
868 struct mctp_sk_key *key;
869 struct mctp_hdr *hdr;
881 if (WARN_ON(!rt->dev))
884 } else if (cb->ifindex) {
885 struct net_device *dev;
891 dev = dev_get_by_index_rcu(sock_net(sk), cb->ifindex);
896 rt->dev = __mctp_dev_get(dev);
902 /* establish temporary route - we set up enough to keep
903 * mctp_route_output happy
905 rt->output = mctp_route_output;
913 spin_lock_irqsave(&rt->dev->addrs_lock, flags);
914 if (rt->dev->num_addrs == 0) {
917 /* use the outbound interface's first address as our source */
918 saddr = rt->dev->addrs[0];
921 spin_unlock_irqrestore(&rt->dev->addrs_lock, flags);
926 if (req_tag & MCTP_TAG_OWNER) {
927 if (req_tag & MCTP_TAG_PREALLOC)
928 key = mctp_lookup_prealloc_tag(msk, daddr,
931 key = mctp_alloc_local_tag(msk, daddr, saddr,
938 mctp_skb_set_flow(skb, key);
939 /* done with the key in this scope */
941 tag |= MCTP_HDR_FLAG_TO;
944 tag = req_tag & MCTP_TAG_MASK;
947 skb->protocol = htons(ETH_P_MCTP);
949 skb_reset_transport_header(skb);
950 skb_push(skb, sizeof(struct mctp_hdr));
951 skb_reset_network_header(skb);
952 skb->dev = rt->dev->dev;
954 /* cb->net will have been set on initial ingress */
957 /* set up common header fields */
963 mtu = mctp_route_mtu(rt);
965 if (skb->len + sizeof(struct mctp_hdr) <= mtu) {
966 hdr->flags_seq_tag = MCTP_HDR_FLAG_SOM |
967 MCTP_HDR_FLAG_EOM | tag;
968 rc = rt->output(rt, skb);
970 rc = mctp_do_fragment_route(rt, skb, mtu, tag);
973 /* route output functions consume the skb, even on error */
978 mctp_route_release(rt);
980 mctp_dev_put(tmp_rt.dev);
987 /* route management */
988 static int mctp_route_add(struct mctp_dev *mdev, mctp_eid_t daddr_start,
989 unsigned int daddr_extent, unsigned int mtu,
992 int (*rtfn)(struct mctp_route *rt, struct sk_buff *skb);
993 struct net *net = dev_net(mdev->dev);
994 struct mctp_route *rt, *ert;
996 if (!mctp_address_unicast(daddr_start))
999 if (daddr_extent > 0xff || daddr_start + daddr_extent >= 255)
1004 rtfn = mctp_route_input;
1007 rtfn = mctp_route_output;
1013 rt = mctp_route_alloc();
1017 rt->min = daddr_start;
1018 rt->max = daddr_start + daddr_extent;
1021 mctp_dev_hold(rt->dev);
1026 /* Prevent duplicate identical routes. */
1027 list_for_each_entry(ert, &net->mctp.routes, list) {
1028 if (mctp_rt_compare_exact(rt, ert)) {
1029 mctp_route_release(rt);
1034 list_add_rcu(&rt->list, &net->mctp.routes);
1039 static int mctp_route_remove(struct mctp_dev *mdev, mctp_eid_t daddr_start,
1040 unsigned int daddr_extent, unsigned char type)
1042 struct net *net = dev_net(mdev->dev);
1043 struct mctp_route *rt, *tmp;
1044 mctp_eid_t daddr_end;
1047 if (daddr_extent > 0xff || daddr_start + daddr_extent >= 255)
1050 daddr_end = daddr_start + daddr_extent;
1055 list_for_each_entry_safe(rt, tmp, &net->mctp.routes, list) {
1056 if (rt->dev == mdev &&
1057 rt->min == daddr_start && rt->max == daddr_end &&
1059 list_del_rcu(&rt->list);
1060 /* TODO: immediate RTM_DELROUTE */
1061 mctp_route_release(rt);
1066 return dropped ? 0 : -ENOENT;
1069 int mctp_route_add_local(struct mctp_dev *mdev, mctp_eid_t addr)
1071 return mctp_route_add(mdev, addr, 0, 0, RTN_LOCAL);
1074 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr)
1076 return mctp_route_remove(mdev, addr, 0, RTN_LOCAL);
1079 /* removes all entries for a given device */
1080 void mctp_route_remove_dev(struct mctp_dev *mdev)
1082 struct net *net = dev_net(mdev->dev);
1083 struct mctp_route *rt, *tmp;
1086 list_for_each_entry_safe(rt, tmp, &net->mctp.routes, list) {
1087 if (rt->dev == mdev) {
1088 list_del_rcu(&rt->list);
1089 /* TODO: immediate RTM_DELROUTE */
1090 mctp_route_release(rt);
1095 /* Incoming packet-handling */
1097 static int mctp_pkttype_receive(struct sk_buff *skb, struct net_device *dev,
1098 struct packet_type *pt,
1099 struct net_device *orig_dev)
1101 struct net *net = dev_net(dev);
1102 struct mctp_dev *mdev;
1103 struct mctp_skb_cb *cb;
1104 struct mctp_route *rt;
1105 struct mctp_hdr *mh;
1108 mdev = __mctp_dev_get(dev);
1111 /* basic non-data sanity checks */
1115 if (!pskb_may_pull(skb, sizeof(struct mctp_hdr)))
1118 skb_reset_transport_header(skb);
1119 skb_reset_network_header(skb);
1121 /* We have enough for a header; decode and route */
1123 if (mh->ver < MCTP_VER_MIN || mh->ver > MCTP_VER_MAX)
1126 /* source must be valid unicast or null; drop reserved ranges and
1129 if (!(mctp_address_unicast(mh->src) || mctp_address_null(mh->src)))
1132 /* dest address: as above, but allow broadcast */
1133 if (!(mctp_address_unicast(mh->dest) || mctp_address_null(mh->dest) ||
1134 mctp_address_broadcast(mh->dest)))
1137 /* MCTP drivers must populate halen/haddr */
1138 if (dev->type == ARPHRD_MCTP) {
1141 cb = __mctp_cb(skb);
1144 cb->net = READ_ONCE(mdev->net);
1145 cb->ifindex = dev->ifindex;
1147 rt = mctp_route_lookup(net, cb->net, mh->dest);
1149 /* NULL EID, but addressed to our physical address */
1150 if (!rt && mh->dest == MCTP_ADDR_NULL && skb->pkt_type == PACKET_HOST)
1151 rt = mctp_route_lookup_null(net, dev);
1156 rt->output(rt, skb);
1157 mctp_route_release(rt);
1160 return NET_RX_SUCCESS;
1168 static struct packet_type mctp_packet_type = {
1169 .type = cpu_to_be16(ETH_P_MCTP),
1170 .func = mctp_pkttype_receive,
1173 /* netlink interface */
1175 static const struct nla_policy rta_mctp_policy[RTA_MAX + 1] = {
1176 [RTA_DST] = { .type = NLA_U8 },
1177 [RTA_METRICS] = { .type = NLA_NESTED },
1178 [RTA_OIF] = { .type = NLA_U32 },
1181 /* Common part for RTM_NEWROUTE and RTM_DELROUTE parsing.
1182 * tb must hold RTA_MAX+1 elements.
1184 static int mctp_route_nlparse(struct sk_buff *skb, struct nlmsghdr *nlh,
1185 struct netlink_ext_ack *extack,
1186 struct nlattr **tb, struct rtmsg **rtm,
1187 struct mctp_dev **mdev, mctp_eid_t *daddr_start)
1189 struct net *net = sock_net(skb->sk);
1190 struct net_device *dev;
1191 unsigned int ifindex;
1194 rc = nlmsg_parse(nlh, sizeof(struct rtmsg), tb, RTA_MAX,
1195 rta_mctp_policy, extack);
1197 NL_SET_ERR_MSG(extack, "incorrect format");
1202 NL_SET_ERR_MSG(extack, "dst EID missing");
1205 *daddr_start = nla_get_u8(tb[RTA_DST]);
1208 NL_SET_ERR_MSG(extack, "ifindex missing");
1211 ifindex = nla_get_u32(tb[RTA_OIF]);
1213 *rtm = nlmsg_data(nlh);
1214 if ((*rtm)->rtm_family != AF_MCTP) {
1215 NL_SET_ERR_MSG(extack, "route family must be AF_MCTP");
1219 dev = __dev_get_by_index(net, ifindex);
1221 NL_SET_ERR_MSG(extack, "bad ifindex");
1224 *mdev = mctp_dev_get_rtnl(dev);
1228 if (dev->flags & IFF_LOOPBACK) {
1229 NL_SET_ERR_MSG(extack, "no routes to loopback");
1236 static const struct nla_policy rta_metrics_policy[RTAX_MAX + 1] = {
1237 [RTAX_MTU] = { .type = NLA_U32 },
1240 static int mctp_newroute(struct sk_buff *skb, struct nlmsghdr *nlh,
1241 struct netlink_ext_ack *extack)
1243 struct nlattr *tb[RTA_MAX + 1];
1244 struct nlattr *tbx[RTAX_MAX + 1];
1245 mctp_eid_t daddr_start;
1246 struct mctp_dev *mdev;
1251 rc = mctp_route_nlparse(skb, nlh, extack, tb,
1252 &rtm, &mdev, &daddr_start);
1256 if (rtm->rtm_type != RTN_UNICAST) {
1257 NL_SET_ERR_MSG(extack, "rtm_type must be RTN_UNICAST");
1262 if (tb[RTA_METRICS]) {
1263 rc = nla_parse_nested(tbx, RTAX_MAX, tb[RTA_METRICS],
1264 rta_metrics_policy, NULL);
1268 mtu = nla_get_u32(tbx[RTAX_MTU]);
1271 rc = mctp_route_add(mdev, daddr_start, rtm->rtm_dst_len, mtu,
1276 static int mctp_delroute(struct sk_buff *skb, struct nlmsghdr *nlh,
1277 struct netlink_ext_ack *extack)
1279 struct nlattr *tb[RTA_MAX + 1];
1280 mctp_eid_t daddr_start;
1281 struct mctp_dev *mdev;
1285 rc = mctp_route_nlparse(skb, nlh, extack, tb,
1286 &rtm, &mdev, &daddr_start);
1290 /* we only have unicast routes */
1291 if (rtm->rtm_type != RTN_UNICAST)
1294 rc = mctp_route_remove(mdev, daddr_start, rtm->rtm_dst_len, RTN_UNICAST);
1298 static int mctp_fill_rtinfo(struct sk_buff *skb, struct mctp_route *rt,
1299 u32 portid, u32 seq, int event, unsigned int flags)
1301 struct nlmsghdr *nlh;
1305 nlh = nlmsg_put(skb, portid, seq, event, sizeof(*hdr), flags);
1309 hdr = nlmsg_data(nlh);
1310 hdr->rtm_family = AF_MCTP;
1312 /* we use the _len fields as a number of EIDs, rather than
1313 * a number of bits in the address
1315 hdr->rtm_dst_len = rt->max - rt->min;
1316 hdr->rtm_src_len = 0;
1318 hdr->rtm_table = RT_TABLE_DEFAULT;
1319 hdr->rtm_protocol = RTPROT_STATIC; /* everything is user-defined */
1320 hdr->rtm_scope = RT_SCOPE_LINK; /* TODO: scope in mctp_route? */
1321 hdr->rtm_type = rt->type;
1323 if (nla_put_u8(skb, RTA_DST, rt->min))
1326 metrics = nla_nest_start_noflag(skb, RTA_METRICS);
1331 if (nla_put_u32(skb, RTAX_MTU, rt->mtu))
1335 nla_nest_end(skb, metrics);
1338 if (nla_put_u32(skb, RTA_OIF, rt->dev->dev->ifindex))
1342 /* TODO: conditional neighbour physaddr? */
1344 nlmsg_end(skb, nlh);
1349 nlmsg_cancel(skb, nlh);
1353 static int mctp_dump_rtinfo(struct sk_buff *skb, struct netlink_callback *cb)
1355 struct net *net = sock_net(skb->sk);
1356 struct mctp_route *rt;
1359 /* TODO: allow filtering on route data, possibly under
1363 /* TODO: change to struct overlay */
1364 s_idx = cb->args[0];
1368 list_for_each_entry_rcu(rt, &net->mctp.routes, list) {
1371 if (mctp_fill_rtinfo(skb, rt,
1372 NETLINK_CB(cb->skb).portid,
1374 RTM_NEWROUTE, NLM_F_MULTI) < 0)
1384 /* net namespace implementation */
1385 static int __net_init mctp_routes_net_init(struct net *net)
1387 struct netns_mctp *ns = &net->mctp;
1389 INIT_LIST_HEAD(&ns->routes);
1390 INIT_HLIST_HEAD(&ns->binds);
1391 mutex_init(&ns->bind_lock);
1392 INIT_HLIST_HEAD(&ns->keys);
1393 spin_lock_init(&ns->keys_lock);
1394 WARN_ON(mctp_default_net_set(net, MCTP_INITIAL_DEFAULT_NET));
1398 static void __net_exit mctp_routes_net_exit(struct net *net)
1400 struct mctp_route *rt;
1403 list_for_each_entry_rcu(rt, &net->mctp.routes, list)
1404 mctp_route_release(rt);
1408 static struct pernet_operations mctp_net_ops = {
1409 .init = mctp_routes_net_init,
1410 .exit = mctp_routes_net_exit,
1413 int __init mctp_routes_init(void)
1415 dev_add_pack(&mctp_packet_type);
1417 rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_GETROUTE,
1418 NULL, mctp_dump_rtinfo, 0);
1419 rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_NEWROUTE,
1420 mctp_newroute, NULL, 0);
1421 rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_DELROUTE,
1422 mctp_delroute, NULL, 0);
1424 return register_pernet_subsys(&mctp_net_ops);
1427 void mctp_routes_exit(void)
1429 unregister_pernet_subsys(&mctp_net_ops);
1430 rtnl_unregister(PF_MCTP, RTM_DELROUTE);
1431 rtnl_unregister(PF_MCTP, RTM_NEWROUTE);
1432 rtnl_unregister(PF_MCTP, RTM_GETROUTE);
1433 dev_remove_pack(&mctp_packet_type);
1436 #if IS_ENABLED(CONFIG_MCTP_TEST)
1437 #include "test/route-test.c"