1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Management Component Transport Protocol (MCTP) 4 * 5 * Copyright (c) 2021 Code Construct 6 * Copyright (c) 2021 Google 7 */ 8 9 #include <linux/compat.h> 10 #include <linux/if_arp.h> 11 #include <linux/net.h> 12 #include <linux/mctp.h> 13 #include <linux/module.h> 14 #include <linux/socket.h> 15 16 #include <net/mctp.h> 17 #include <net/mctpdevice.h> 18 #include <net/sock.h> 19 20 #define CREATE_TRACE_POINTS 21 #include <trace/events/mctp.h> 22 23 /* socket implementation */ 24 25 static void mctp_sk_expire_keys(struct timer_list *timer); 26 27 static int mctp_release(struct socket *sock) 28 { 29 struct sock *sk = sock->sk; 30 31 if (sk) { 32 sock->sk = NULL; 33 sk->sk_prot->close(sk, 0); 34 } 35 36 return 0; 37 } 38 39 /* Generic sockaddr checks, padding checks only so far */ 40 static bool mctp_sockaddr_is_ok(const struct sockaddr_mctp *addr) 41 { 42 return !addr->__smctp_pad0 && !addr->__smctp_pad1; 43 } 44 45 static bool mctp_sockaddr_ext_is_ok(const struct sockaddr_mctp_ext *addr) 46 { 47 return !addr->__smctp_pad0[0] && 48 !addr->__smctp_pad0[1] && 49 !addr->__smctp_pad0[2]; 50 } 51 52 static int mctp_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 53 { 54 struct sock *sk = sock->sk; 55 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 56 struct sockaddr_mctp *smctp; 57 int rc; 58 59 if (addrlen < sizeof(*smctp)) 60 return -EINVAL; 61 62 if (addr->sa_family != AF_MCTP) 63 return -EAFNOSUPPORT; 64 65 if (!capable(CAP_NET_BIND_SERVICE)) 66 return -EACCES; 67 68 /* it's a valid sockaddr for MCTP, cast and do protocol checks */ 69 smctp = (struct sockaddr_mctp *)addr; 70 71 if (!mctp_sockaddr_is_ok(smctp)) 72 return -EINVAL; 73 74 lock_sock(sk); 75 76 /* TODO: allow rebind */ 77 if (sk_hashed(sk)) { 78 rc = -EADDRINUSE; 79 goto out_release; 80 } 81 msk->bind_net = smctp->smctp_network; 82 msk->bind_addr = smctp->smctp_addr.s_addr; 83 msk->bind_type = smctp->smctp_type & 0x7f; /* ignore the IC bit */ 84 85 rc = sk->sk_prot->hash(sk); 86 87 out_release: 88 release_sock(sk); 89 90 return rc; 91 } 92 93 static int mctp_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) 94 { 95 DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name); 96 int rc, addrlen = msg->msg_namelen; 97 struct sock *sk = sock->sk; 98 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 99 struct mctp_skb_cb *cb; 100 struct sk_buff *skb = NULL; 101 struct mctp_dst dst; 102 int hlen; 103 104 if (addr) { 105 const u8 tagbits = MCTP_TAG_MASK | MCTP_TAG_OWNER | 106 MCTP_TAG_PREALLOC; 107 108 if (addrlen < sizeof(struct sockaddr_mctp)) 109 return -EINVAL; 110 if (addr->smctp_family != AF_MCTP) 111 return -EINVAL; 112 if (!mctp_sockaddr_is_ok(addr)) 113 return -EINVAL; 114 if (addr->smctp_tag & ~tagbits) 115 return -EINVAL; 116 /* can't preallocate a non-owned tag */ 117 if (addr->smctp_tag & MCTP_TAG_PREALLOC && 118 !(addr->smctp_tag & MCTP_TAG_OWNER)) 119 return -EINVAL; 120 121 } else { 122 /* TODO: connect()ed sockets */ 123 return -EDESTADDRREQ; 124 } 125 126 if (!capable(CAP_NET_RAW)) 127 return -EACCES; 128 129 if (addr->smctp_network == MCTP_NET_ANY) 130 addr->smctp_network = mctp_default_net(sock_net(sk)); 131 132 /* direct addressing */ 133 if (msk->addr_ext && addrlen >= sizeof(struct sockaddr_mctp_ext)) { 134 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *, 135 extaddr, msg->msg_name); 136 137 if (!mctp_sockaddr_ext_is_ok(extaddr)) 138 return -EINVAL; 139 140 rc = mctp_dst_from_extaddr(&dst, sock_net(sk), 141 extaddr->smctp_ifindex, 142 extaddr->smctp_halen, 143 extaddr->smctp_haddr); 144 if (rc) 145 return rc; 146 147 } else { 148 rc = mctp_route_lookup(sock_net(sk), addr->smctp_network, 149 addr->smctp_addr.s_addr, &dst); 150 if (rc) 151 return rc; 152 } 153 154 hlen = LL_RESERVED_SPACE(dst.dev->dev) + sizeof(struct mctp_hdr); 155 156 skb = sock_alloc_send_skb(sk, hlen + 1 + len, 157 msg->msg_flags & MSG_DONTWAIT, &rc); 158 if (!skb) 159 goto err_release_dst; 160 161 skb_reserve(skb, hlen); 162 163 /* set type as fist byte in payload */ 164 *(u8 *)skb_put(skb, 1) = addr->smctp_type; 165 166 rc = memcpy_from_msg((void *)skb_put(skb, len), msg, len); 167 if (rc < 0) 168 goto err_free; 169 170 /* set up cb */ 171 cb = __mctp_cb(skb); 172 cb->net = addr->smctp_network; 173 174 rc = mctp_local_output(sk, &dst, skb, addr->smctp_addr.s_addr, 175 addr->smctp_tag); 176 177 mctp_dst_release(&dst); 178 return rc ? : len; 179 180 err_free: 181 kfree_skb(skb); 182 err_release_dst: 183 mctp_dst_release(&dst); 184 return rc; 185 } 186 187 static int mctp_recvmsg(struct socket *sock, struct msghdr *msg, size_t len, 188 int flags) 189 { 190 DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name); 191 struct sock *sk = sock->sk; 192 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 193 struct sk_buff *skb; 194 size_t msglen; 195 u8 type; 196 int rc; 197 198 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK)) 199 return -EOPNOTSUPP; 200 201 skb = skb_recv_datagram(sk, flags, &rc); 202 if (!skb) 203 return rc; 204 205 if (!skb->len) { 206 rc = 0; 207 goto out_free; 208 } 209 210 /* extract message type, remove from data */ 211 type = *((u8 *)skb->data); 212 msglen = skb->len - 1; 213 214 if (len < msglen) 215 msg->msg_flags |= MSG_TRUNC; 216 else 217 len = msglen; 218 219 rc = skb_copy_datagram_msg(skb, 1, msg, len); 220 if (rc < 0) 221 goto out_free; 222 223 sock_recv_cmsgs(msg, sk, skb); 224 225 if (addr) { 226 struct mctp_skb_cb *cb = mctp_cb(skb); 227 /* TODO: expand mctp_skb_cb for header fields? */ 228 struct mctp_hdr *hdr = mctp_hdr(skb); 229 230 addr = msg->msg_name; 231 addr->smctp_family = AF_MCTP; 232 addr->__smctp_pad0 = 0; 233 addr->smctp_network = cb->net; 234 addr->smctp_addr.s_addr = hdr->src; 235 addr->smctp_type = type; 236 addr->smctp_tag = hdr->flags_seq_tag & 237 (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO); 238 addr->__smctp_pad1 = 0; 239 msg->msg_namelen = sizeof(*addr); 240 241 if (msk->addr_ext) { 242 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *, ae, 243 msg->msg_name); 244 msg->msg_namelen = sizeof(*ae); 245 ae->smctp_ifindex = cb->ifindex; 246 ae->smctp_halen = cb->halen; 247 memset(ae->__smctp_pad0, 0x0, sizeof(ae->__smctp_pad0)); 248 memset(ae->smctp_haddr, 0x0, sizeof(ae->smctp_haddr)); 249 memcpy(ae->smctp_haddr, cb->haddr, cb->halen); 250 } 251 } 252 253 rc = len; 254 255 if (flags & MSG_TRUNC) 256 rc = msglen; 257 258 out_free: 259 skb_free_datagram(sk, skb); 260 return rc; 261 } 262 263 /* We're done with the key; invalidate, stop reassembly, and remove from lists. 264 */ 265 static void __mctp_key_remove(struct mctp_sk_key *key, struct net *net, 266 unsigned long flags, unsigned long reason) 267 __releases(&key->lock) 268 __must_hold(&net->mctp.keys_lock) 269 { 270 struct sk_buff *skb; 271 272 trace_mctp_key_release(key, reason); 273 skb = key->reasm_head; 274 key->reasm_head = NULL; 275 key->reasm_dead = true; 276 key->valid = false; 277 mctp_dev_release_key(key->dev, key); 278 spin_unlock_irqrestore(&key->lock, flags); 279 280 if (!hlist_unhashed(&key->hlist)) { 281 hlist_del_init(&key->hlist); 282 hlist_del_init(&key->sklist); 283 /* unref for the lists */ 284 mctp_key_unref(key); 285 } 286 287 kfree_skb(skb); 288 } 289 290 static int mctp_setsockopt(struct socket *sock, int level, int optname, 291 sockptr_t optval, unsigned int optlen) 292 { 293 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk); 294 int val; 295 296 if (level != SOL_MCTP) 297 return -EINVAL; 298 299 if (optname == MCTP_OPT_ADDR_EXT) { 300 if (optlen != sizeof(int)) 301 return -EINVAL; 302 if (copy_from_sockptr(&val, optval, sizeof(int))) 303 return -EFAULT; 304 msk->addr_ext = val; 305 return 0; 306 } 307 308 return -ENOPROTOOPT; 309 } 310 311 static int mctp_getsockopt(struct socket *sock, int level, int optname, 312 char __user *optval, int __user *optlen) 313 { 314 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk); 315 int len, val; 316 317 if (level != SOL_MCTP) 318 return -EINVAL; 319 320 if (get_user(len, optlen)) 321 return -EFAULT; 322 323 if (optname == MCTP_OPT_ADDR_EXT) { 324 if (len != sizeof(int)) 325 return -EINVAL; 326 val = !!msk->addr_ext; 327 if (copy_to_user(optval, &val, len)) 328 return -EFAULT; 329 return 0; 330 } 331 332 return -EINVAL; 333 } 334 335 /* helpers for reading/writing the tag ioc, handling compatibility across the 336 * two versions, and some basic API error checking 337 */ 338 static int mctp_ioctl_tag_copy_from_user(unsigned long arg, 339 struct mctp_ioc_tag_ctl2 *ctl, 340 bool tagv2) 341 { 342 struct mctp_ioc_tag_ctl ctl_compat; 343 unsigned long size; 344 void *ptr; 345 int rc; 346 347 if (tagv2) { 348 size = sizeof(*ctl); 349 ptr = ctl; 350 } else { 351 size = sizeof(ctl_compat); 352 ptr = &ctl_compat; 353 } 354 355 rc = copy_from_user(ptr, (void __user *)arg, size); 356 if (rc) 357 return -EFAULT; 358 359 if (!tagv2) { 360 /* compat, using defaults for new fields */ 361 ctl->net = MCTP_INITIAL_DEFAULT_NET; 362 ctl->peer_addr = ctl_compat.peer_addr; 363 ctl->local_addr = MCTP_ADDR_ANY; 364 ctl->flags = ctl_compat.flags; 365 ctl->tag = ctl_compat.tag; 366 } 367 368 if (ctl->flags) 369 return -EINVAL; 370 371 if (ctl->local_addr != MCTP_ADDR_ANY && 372 ctl->local_addr != MCTP_ADDR_NULL) 373 return -EINVAL; 374 375 return 0; 376 } 377 378 static int mctp_ioctl_tag_copy_to_user(unsigned long arg, 379 struct mctp_ioc_tag_ctl2 *ctl, 380 bool tagv2) 381 { 382 struct mctp_ioc_tag_ctl ctl_compat; 383 unsigned long size; 384 void *ptr; 385 int rc; 386 387 if (tagv2) { 388 ptr = ctl; 389 size = sizeof(*ctl); 390 } else { 391 ctl_compat.peer_addr = ctl->peer_addr; 392 ctl_compat.tag = ctl->tag; 393 ctl_compat.flags = ctl->flags; 394 395 ptr = &ctl_compat; 396 size = sizeof(ctl_compat); 397 } 398 399 rc = copy_to_user((void __user *)arg, ptr, size); 400 if (rc) 401 return -EFAULT; 402 403 return 0; 404 } 405 406 static int mctp_ioctl_alloctag(struct mctp_sock *msk, bool tagv2, 407 unsigned long arg) 408 { 409 struct net *net = sock_net(&msk->sk); 410 struct mctp_sk_key *key = NULL; 411 struct mctp_ioc_tag_ctl2 ctl; 412 unsigned long flags; 413 u8 tag; 414 int rc; 415 416 rc = mctp_ioctl_tag_copy_from_user(arg, &ctl, tagv2); 417 if (rc) 418 return rc; 419 420 if (ctl.tag) 421 return -EINVAL; 422 423 key = mctp_alloc_local_tag(msk, ctl.net, MCTP_ADDR_ANY, 424 ctl.peer_addr, true, &tag); 425 if (IS_ERR(key)) 426 return PTR_ERR(key); 427 428 ctl.tag = tag | MCTP_TAG_OWNER | MCTP_TAG_PREALLOC; 429 rc = mctp_ioctl_tag_copy_to_user(arg, &ctl, tagv2); 430 if (rc) { 431 unsigned long fl2; 432 /* Unwind our key allocation: the keys list lock needs to be 433 * taken before the individual key locks, and we need a valid 434 * flags value (fl2) to pass to __mctp_key_remove, hence the 435 * second spin_lock_irqsave() rather than a plain spin_lock(). 436 */ 437 spin_lock_irqsave(&net->mctp.keys_lock, flags); 438 spin_lock_irqsave(&key->lock, fl2); 439 __mctp_key_remove(key, net, fl2, MCTP_TRACE_KEY_DROPPED); 440 mctp_key_unref(key); 441 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 442 return rc; 443 } 444 445 mctp_key_unref(key); 446 return 0; 447 } 448 449 static int mctp_ioctl_droptag(struct mctp_sock *msk, bool tagv2, 450 unsigned long arg) 451 { 452 struct net *net = sock_net(&msk->sk); 453 struct mctp_ioc_tag_ctl2 ctl; 454 unsigned long flags, fl2; 455 struct mctp_sk_key *key; 456 struct hlist_node *tmp; 457 int rc; 458 u8 tag; 459 460 rc = mctp_ioctl_tag_copy_from_user(arg, &ctl, tagv2); 461 if (rc) 462 return rc; 463 464 /* Must be a local tag, TO set, preallocated */ 465 if ((ctl.tag & ~MCTP_TAG_MASK) != (MCTP_TAG_OWNER | MCTP_TAG_PREALLOC)) 466 return -EINVAL; 467 468 tag = ctl.tag & MCTP_TAG_MASK; 469 rc = -EINVAL; 470 471 if (ctl.peer_addr == MCTP_ADDR_NULL) 472 ctl.peer_addr = MCTP_ADDR_ANY; 473 474 spin_lock_irqsave(&net->mctp.keys_lock, flags); 475 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) { 476 /* we do an irqsave here, even though we know the irq state, 477 * so we have the flags to pass to __mctp_key_remove 478 */ 479 spin_lock_irqsave(&key->lock, fl2); 480 if (key->manual_alloc && 481 ctl.net == key->net && 482 ctl.peer_addr == key->peer_addr && 483 tag == key->tag) { 484 __mctp_key_remove(key, net, fl2, 485 MCTP_TRACE_KEY_DROPPED); 486 rc = 0; 487 } else { 488 spin_unlock_irqrestore(&key->lock, fl2); 489 } 490 } 491 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 492 493 return rc; 494 } 495 496 static int mctp_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 497 { 498 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk); 499 bool tagv2 = false; 500 501 switch (cmd) { 502 case SIOCMCTPALLOCTAG2: 503 case SIOCMCTPALLOCTAG: 504 tagv2 = cmd == SIOCMCTPALLOCTAG2; 505 return mctp_ioctl_alloctag(msk, tagv2, arg); 506 case SIOCMCTPDROPTAG: 507 case SIOCMCTPDROPTAG2: 508 tagv2 = cmd == SIOCMCTPDROPTAG2; 509 return mctp_ioctl_droptag(msk, tagv2, arg); 510 } 511 512 return -EINVAL; 513 } 514 515 #ifdef CONFIG_COMPAT 516 static int mctp_compat_ioctl(struct socket *sock, unsigned int cmd, 517 unsigned long arg) 518 { 519 void __user *argp = compat_ptr(arg); 520 521 switch (cmd) { 522 /* These have compatible ptr layouts */ 523 case SIOCMCTPALLOCTAG: 524 case SIOCMCTPDROPTAG: 525 return mctp_ioctl(sock, cmd, (unsigned long)argp); 526 } 527 528 return -ENOIOCTLCMD; 529 } 530 #endif 531 532 static const struct proto_ops mctp_dgram_ops = { 533 .family = PF_MCTP, 534 .release = mctp_release, 535 .bind = mctp_bind, 536 .connect = sock_no_connect, 537 .socketpair = sock_no_socketpair, 538 .accept = sock_no_accept, 539 .getname = sock_no_getname, 540 .poll = datagram_poll, 541 .ioctl = mctp_ioctl, 542 .gettstamp = sock_gettstamp, 543 .listen = sock_no_listen, 544 .shutdown = sock_no_shutdown, 545 .setsockopt = mctp_setsockopt, 546 .getsockopt = mctp_getsockopt, 547 .sendmsg = mctp_sendmsg, 548 .recvmsg = mctp_recvmsg, 549 .mmap = sock_no_mmap, 550 #ifdef CONFIG_COMPAT 551 .compat_ioctl = mctp_compat_ioctl, 552 #endif 553 }; 554 555 static void mctp_sk_expire_keys(struct timer_list *timer) 556 { 557 struct mctp_sock *msk = container_of(timer, struct mctp_sock, 558 key_expiry); 559 struct net *net = sock_net(&msk->sk); 560 unsigned long next_expiry, flags, fl2; 561 struct mctp_sk_key *key; 562 struct hlist_node *tmp; 563 bool next_expiry_valid = false; 564 565 spin_lock_irqsave(&net->mctp.keys_lock, flags); 566 567 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) { 568 /* don't expire. manual_alloc is immutable, no locking 569 * required. 570 */ 571 if (key->manual_alloc) 572 continue; 573 574 spin_lock_irqsave(&key->lock, fl2); 575 if (!time_after_eq(key->expiry, jiffies)) { 576 __mctp_key_remove(key, net, fl2, 577 MCTP_TRACE_KEY_TIMEOUT); 578 continue; 579 } 580 581 if (next_expiry_valid) { 582 if (time_before(key->expiry, next_expiry)) 583 next_expiry = key->expiry; 584 } else { 585 next_expiry = key->expiry; 586 next_expiry_valid = true; 587 } 588 spin_unlock_irqrestore(&key->lock, fl2); 589 } 590 591 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 592 593 if (next_expiry_valid) 594 mod_timer(timer, next_expiry); 595 } 596 597 static int mctp_sk_init(struct sock *sk) 598 { 599 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 600 601 INIT_HLIST_HEAD(&msk->keys); 602 timer_setup(&msk->key_expiry, mctp_sk_expire_keys, 0); 603 return 0; 604 } 605 606 static void mctp_sk_close(struct sock *sk, long timeout) 607 { 608 sk_common_release(sk); 609 } 610 611 static int mctp_sk_hash(struct sock *sk) 612 { 613 struct net *net = sock_net(sk); 614 615 /* Bind lookup runs under RCU, remain live during that. */ 616 sock_set_flag(sk, SOCK_RCU_FREE); 617 618 mutex_lock(&net->mctp.bind_lock); 619 sk_add_node_rcu(sk, &net->mctp.binds); 620 mutex_unlock(&net->mctp.bind_lock); 621 622 return 0; 623 } 624 625 static void mctp_sk_unhash(struct sock *sk) 626 { 627 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk); 628 struct net *net = sock_net(sk); 629 unsigned long flags, fl2; 630 struct mctp_sk_key *key; 631 struct hlist_node *tmp; 632 633 /* remove from any type-based binds */ 634 mutex_lock(&net->mctp.bind_lock); 635 sk_del_node_init_rcu(sk); 636 mutex_unlock(&net->mctp.bind_lock); 637 638 /* remove tag allocations */ 639 spin_lock_irqsave(&net->mctp.keys_lock, flags); 640 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) { 641 spin_lock_irqsave(&key->lock, fl2); 642 __mctp_key_remove(key, net, fl2, MCTP_TRACE_KEY_CLOSED); 643 } 644 sock_set_flag(sk, SOCK_DEAD); 645 spin_unlock_irqrestore(&net->mctp.keys_lock, flags); 646 647 /* Since there are no more tag allocations (we have removed all of the 648 * keys), stop any pending expiry events. the timer cannot be re-queued 649 * as the sk is no longer observable 650 */ 651 timer_delete_sync(&msk->key_expiry); 652 } 653 654 static void mctp_sk_destruct(struct sock *sk) 655 { 656 skb_queue_purge(&sk->sk_receive_queue); 657 } 658 659 static struct proto mctp_proto = { 660 .name = "MCTP", 661 .owner = THIS_MODULE, 662 .obj_size = sizeof(struct mctp_sock), 663 .init = mctp_sk_init, 664 .close = mctp_sk_close, 665 .hash = mctp_sk_hash, 666 .unhash = mctp_sk_unhash, 667 }; 668 669 static int mctp_pf_create(struct net *net, struct socket *sock, 670 int protocol, int kern) 671 { 672 const struct proto_ops *ops; 673 struct proto *proto; 674 struct sock *sk; 675 int rc; 676 677 if (protocol) 678 return -EPROTONOSUPPORT; 679 680 /* only datagram sockets are supported */ 681 if (sock->type != SOCK_DGRAM) 682 return -ESOCKTNOSUPPORT; 683 684 proto = &mctp_proto; 685 ops = &mctp_dgram_ops; 686 687 sock->state = SS_UNCONNECTED; 688 sock->ops = ops; 689 690 sk = sk_alloc(net, PF_MCTP, GFP_KERNEL, proto, kern); 691 if (!sk) 692 return -ENOMEM; 693 694 sock_init_data(sock, sk); 695 sk->sk_destruct = mctp_sk_destruct; 696 697 rc = 0; 698 if (sk->sk_prot->init) 699 rc = sk->sk_prot->init(sk); 700 701 if (rc) 702 goto err_sk_put; 703 704 return 0; 705 706 err_sk_put: 707 sock_orphan(sk); 708 sock_put(sk); 709 return rc; 710 } 711 712 static struct net_proto_family mctp_pf = { 713 .family = PF_MCTP, 714 .create = mctp_pf_create, 715 .owner = THIS_MODULE, 716 }; 717 718 static __init int mctp_init(void) 719 { 720 int rc; 721 722 /* ensure our uapi tag definitions match the header format */ 723 BUILD_BUG_ON(MCTP_TAG_OWNER != MCTP_HDR_FLAG_TO); 724 BUILD_BUG_ON(MCTP_TAG_MASK != MCTP_HDR_TAG_MASK); 725 726 pr_info("mctp: management component transport protocol core\n"); 727 728 rc = sock_register(&mctp_pf); 729 if (rc) 730 return rc; 731 732 rc = proto_register(&mctp_proto, 0); 733 if (rc) 734 goto err_unreg_sock; 735 736 rc = mctp_routes_init(); 737 if (rc) 738 goto err_unreg_proto; 739 740 rc = mctp_neigh_init(); 741 if (rc) 742 goto err_unreg_routes; 743 744 rc = mctp_device_init(); 745 if (rc) 746 goto err_unreg_neigh; 747 748 return 0; 749 750 err_unreg_neigh: 751 mctp_neigh_exit(); 752 err_unreg_routes: 753 mctp_routes_exit(); 754 err_unreg_proto: 755 proto_unregister(&mctp_proto); 756 err_unreg_sock: 757 sock_unregister(PF_MCTP); 758 759 return rc; 760 } 761 762 static __exit void mctp_exit(void) 763 { 764 mctp_device_exit(); 765 mctp_neigh_exit(); 766 mctp_routes_exit(); 767 proto_unregister(&mctp_proto); 768 sock_unregister(PF_MCTP); 769 } 770 771 subsys_initcall(mctp_init); 772 module_exit(mctp_exit); 773 774 MODULE_DESCRIPTION("MCTP core"); 775 MODULE_AUTHOR("Jeremy Kerr <jk@codeconstruct.com.au>"); 776 777 MODULE_ALIAS_NETPROTO(PF_MCTP); 778 779 #if IS_ENABLED(CONFIG_MCTP_TEST) 780 #include "test/sock-test.c" 781 #endif 782