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