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