1 // SPDX-License-Identifier: GPL-2.0
3 * Management Component Transport Protocol (MCTP)
5 * Copyright (c) 2021 Code Construct
6 * Copyright (c) 2021 Google
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>
17 #include <net/mctpdevice.h>
20 #define CREATE_TRACE_POINTS
21 #include <trace/events/mctp.h>
23 /* socket implementation */
25 static void mctp_sk_expire_keys(struct timer_list *timer);
27 static int mctp_release(struct socket *sock)
29 struct sock *sk = sock->sk;
33 sk->sk_prot->close(sk, 0);
39 /* Generic sockaddr checks, padding checks only so far */
40 static bool mctp_sockaddr_is_ok(const struct sockaddr_mctp *addr)
42 return !addr->__smctp_pad0 && !addr->__smctp_pad1;
45 static bool mctp_sockaddr_ext_is_ok(const struct sockaddr_mctp_ext *addr)
47 return !addr->__smctp_pad0[0] &&
48 !addr->__smctp_pad0[1] &&
49 !addr->__smctp_pad0[2];
52 static int mctp_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
54 struct sock *sk = sock->sk;
55 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
56 struct sockaddr_mctp *smctp;
59 if (addrlen < sizeof(*smctp))
62 if (addr->sa_family != AF_MCTP)
65 if (!capable(CAP_NET_BIND_SERVICE))
68 /* it's a valid sockaddr for MCTP, cast and do protocol checks */
69 smctp = (struct sockaddr_mctp *)addr;
71 if (!mctp_sockaddr_is_ok(smctp))
76 /* TODO: allow rebind */
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 */
85 rc = sk->sk_prot->hash(sk);
93 static int mctp_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
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 mctp_route *rt;
101 struct sk_buff *skb = NULL;
105 const u8 tagbits = MCTP_TAG_MASK | MCTP_TAG_OWNER |
108 if (addrlen < sizeof(struct sockaddr_mctp))
110 if (addr->smctp_family != AF_MCTP)
112 if (!mctp_sockaddr_is_ok(addr))
114 if (addr->smctp_tag & ~tagbits)
116 /* can't preallocate a non-owned tag */
117 if (addr->smctp_tag & MCTP_TAG_PREALLOC &&
118 !(addr->smctp_tag & MCTP_TAG_OWNER))
122 /* TODO: connect()ed sockets */
123 return -EDESTADDRREQ;
126 if (!capable(CAP_NET_RAW))
129 if (addr->smctp_network == MCTP_NET_ANY)
130 addr->smctp_network = mctp_default_net(sock_net(sk));
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 struct net_device *dev;
140 dev = dev_get_by_index_rcu(sock_net(sk), extaddr->smctp_ifindex);
141 /* check for correct halen */
142 if (dev && extaddr->smctp_halen == dev->addr_len) {
143 hlen = LL_RESERVED_SPACE(dev) + sizeof(struct mctp_hdr);
151 rt = mctp_route_lookup(sock_net(sk), addr->smctp_network,
152 addr->smctp_addr.s_addr);
157 hlen = LL_RESERVED_SPACE(rt->dev->dev) + sizeof(struct mctp_hdr);
160 skb = sock_alloc_send_skb(sk, hlen + 1 + len,
161 msg->msg_flags & MSG_DONTWAIT, &rc);
165 skb_reserve(skb, hlen);
167 /* set type as fist byte in payload */
168 *(u8 *)skb_put(skb, 1) = addr->smctp_type;
170 rc = memcpy_from_msg((void *)skb_put(skb, len), msg, len);
176 cb->net = addr->smctp_network;
179 /* fill extended address in cb */
180 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *,
181 extaddr, msg->msg_name);
183 if (!mctp_sockaddr_ext_is_ok(extaddr) ||
184 extaddr->smctp_halen > sizeof(cb->haddr)) {
189 cb->ifindex = extaddr->smctp_ifindex;
190 /* smctp_halen is checked above */
191 cb->halen = extaddr->smctp_halen;
192 memcpy(cb->haddr, extaddr->smctp_haddr, cb->halen);
195 rc = mctp_local_output(sk, rt, skb, addr->smctp_addr.s_addr,
205 static int mctp_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
208 DECLARE_SOCKADDR(struct sockaddr_mctp *, addr, msg->msg_name);
209 struct sock *sk = sock->sk;
210 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
216 if (flags & ~(MSG_DONTWAIT | MSG_TRUNC | MSG_PEEK))
219 skb = skb_recv_datagram(sk, flags, &rc);
228 /* extract message type, remove from data */
229 type = *((u8 *)skb->data);
230 msglen = skb->len - 1;
233 msg->msg_flags |= MSG_TRUNC;
237 rc = skb_copy_datagram_msg(skb, 1, msg, len);
241 sock_recv_cmsgs(msg, sk, skb);
244 struct mctp_skb_cb *cb = mctp_cb(skb);
245 /* TODO: expand mctp_skb_cb for header fields? */
246 struct mctp_hdr *hdr = mctp_hdr(skb);
248 addr = msg->msg_name;
249 addr->smctp_family = AF_MCTP;
250 addr->__smctp_pad0 = 0;
251 addr->smctp_network = cb->net;
252 addr->smctp_addr.s_addr = hdr->src;
253 addr->smctp_type = type;
254 addr->smctp_tag = hdr->flags_seq_tag &
255 (MCTP_HDR_TAG_MASK | MCTP_HDR_FLAG_TO);
256 addr->__smctp_pad1 = 0;
257 msg->msg_namelen = sizeof(*addr);
260 DECLARE_SOCKADDR(struct sockaddr_mctp_ext *, ae,
262 msg->msg_namelen = sizeof(*ae);
263 ae->smctp_ifindex = cb->ifindex;
264 ae->smctp_halen = cb->halen;
265 memset(ae->__smctp_pad0, 0x0, sizeof(ae->__smctp_pad0));
266 memset(ae->smctp_haddr, 0x0, sizeof(ae->smctp_haddr));
267 memcpy(ae->smctp_haddr, cb->haddr, cb->halen);
273 if (flags & MSG_TRUNC)
277 skb_free_datagram(sk, skb);
281 /* We're done with the key; invalidate, stop reassembly, and remove from lists.
283 static void __mctp_key_remove(struct mctp_sk_key *key, struct net *net,
284 unsigned long flags, unsigned long reason)
285 __releases(&key->lock)
286 __must_hold(&net->mctp.keys_lock)
290 trace_mctp_key_release(key, reason);
291 skb = key->reasm_head;
292 key->reasm_head = NULL;
293 key->reasm_dead = true;
295 mctp_dev_release_key(key->dev, key);
296 spin_unlock_irqrestore(&key->lock, flags);
298 hlist_del(&key->hlist);
299 hlist_del(&key->sklist);
301 /* unref for the lists */
307 static int mctp_setsockopt(struct socket *sock, int level, int optname,
308 sockptr_t optval, unsigned int optlen)
310 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk);
313 if (level != SOL_MCTP)
316 if (optname == MCTP_OPT_ADDR_EXT) {
317 if (optlen != sizeof(int))
319 if (copy_from_sockptr(&val, optval, sizeof(int)))
328 static int mctp_getsockopt(struct socket *sock, int level, int optname,
329 char __user *optval, int __user *optlen)
331 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk);
334 if (level != SOL_MCTP)
337 if (get_user(len, optlen))
340 if (optname == MCTP_OPT_ADDR_EXT) {
341 if (len != sizeof(int))
343 val = !!msk->addr_ext;
344 if (copy_to_user(optval, &val, len))
352 static int mctp_ioctl_alloctag(struct mctp_sock *msk, unsigned long arg)
354 struct net *net = sock_net(&msk->sk);
355 struct mctp_sk_key *key = NULL;
356 struct mctp_ioc_tag_ctl ctl;
360 if (copy_from_user(&ctl, (void __user *)arg, sizeof(ctl)))
369 key = mctp_alloc_local_tag(msk, ctl.peer_addr, MCTP_ADDR_ANY,
374 ctl.tag = tag | MCTP_TAG_OWNER | MCTP_TAG_PREALLOC;
375 if (copy_to_user((void __user *)arg, &ctl, sizeof(ctl))) {
376 spin_lock_irqsave(&key->lock, flags);
377 __mctp_key_remove(key, net, flags, MCTP_TRACE_KEY_DROPPED);
386 static int mctp_ioctl_droptag(struct mctp_sock *msk, unsigned long arg)
388 struct net *net = sock_net(&msk->sk);
389 struct mctp_ioc_tag_ctl ctl;
390 unsigned long flags, fl2;
391 struct mctp_sk_key *key;
392 struct hlist_node *tmp;
396 if (copy_from_user(&ctl, (void __user *)arg, sizeof(ctl)))
402 /* Must be a local tag, TO set, preallocated */
403 if ((ctl.tag & ~MCTP_TAG_MASK) != (MCTP_TAG_OWNER | MCTP_TAG_PREALLOC))
406 tag = ctl.tag & MCTP_TAG_MASK;
409 spin_lock_irqsave(&net->mctp.keys_lock, flags);
410 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) {
411 /* we do an irqsave here, even though we know the irq state,
412 * so we have the flags to pass to __mctp_key_remove
414 spin_lock_irqsave(&key->lock, fl2);
415 if (key->manual_alloc &&
416 ctl.peer_addr == key->peer_addr &&
418 __mctp_key_remove(key, net, fl2,
419 MCTP_TRACE_KEY_DROPPED);
422 spin_unlock_irqrestore(&key->lock, fl2);
425 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
430 static int mctp_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
432 struct mctp_sock *msk = container_of(sock->sk, struct mctp_sock, sk);
435 case SIOCMCTPALLOCTAG:
436 return mctp_ioctl_alloctag(msk, arg);
437 case SIOCMCTPDROPTAG:
438 return mctp_ioctl_droptag(msk, arg);
445 static int mctp_compat_ioctl(struct socket *sock, unsigned int cmd,
448 void __user *argp = compat_ptr(arg);
451 /* These have compatible ptr layouts */
452 case SIOCMCTPALLOCTAG:
453 case SIOCMCTPDROPTAG:
454 return mctp_ioctl(sock, cmd, (unsigned long)argp);
461 static const struct proto_ops mctp_dgram_ops = {
463 .release = mctp_release,
465 .connect = sock_no_connect,
466 .socketpair = sock_no_socketpair,
467 .accept = sock_no_accept,
468 .getname = sock_no_getname,
469 .poll = datagram_poll,
471 .gettstamp = sock_gettstamp,
472 .listen = sock_no_listen,
473 .shutdown = sock_no_shutdown,
474 .setsockopt = mctp_setsockopt,
475 .getsockopt = mctp_getsockopt,
476 .sendmsg = mctp_sendmsg,
477 .recvmsg = mctp_recvmsg,
478 .mmap = sock_no_mmap,
479 .sendpage = sock_no_sendpage,
481 .compat_ioctl = mctp_compat_ioctl,
485 static void mctp_sk_expire_keys(struct timer_list *timer)
487 struct mctp_sock *msk = container_of(timer, struct mctp_sock,
489 struct net *net = sock_net(&msk->sk);
490 unsigned long next_expiry, flags, fl2;
491 struct mctp_sk_key *key;
492 struct hlist_node *tmp;
493 bool next_expiry_valid = false;
495 spin_lock_irqsave(&net->mctp.keys_lock, flags);
497 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) {
498 /* don't expire. manual_alloc is immutable, no locking
501 if (key->manual_alloc)
504 spin_lock_irqsave(&key->lock, fl2);
505 if (!time_after_eq(key->expiry, jiffies)) {
506 __mctp_key_remove(key, net, fl2,
507 MCTP_TRACE_KEY_TIMEOUT);
511 if (next_expiry_valid) {
512 if (time_before(key->expiry, next_expiry))
513 next_expiry = key->expiry;
515 next_expiry = key->expiry;
516 next_expiry_valid = true;
518 spin_unlock_irqrestore(&key->lock, fl2);
521 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
523 if (next_expiry_valid)
524 mod_timer(timer, next_expiry);
527 static int mctp_sk_init(struct sock *sk)
529 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
531 INIT_HLIST_HEAD(&msk->keys);
532 timer_setup(&msk->key_expiry, mctp_sk_expire_keys, 0);
536 static void mctp_sk_close(struct sock *sk, long timeout)
538 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
540 del_timer_sync(&msk->key_expiry);
541 sk_common_release(sk);
544 static int mctp_sk_hash(struct sock *sk)
546 struct net *net = sock_net(sk);
548 mutex_lock(&net->mctp.bind_lock);
549 sk_add_node_rcu(sk, &net->mctp.binds);
550 mutex_unlock(&net->mctp.bind_lock);
555 static void mctp_sk_unhash(struct sock *sk)
557 struct mctp_sock *msk = container_of(sk, struct mctp_sock, sk);
558 struct net *net = sock_net(sk);
559 unsigned long flags, fl2;
560 struct mctp_sk_key *key;
561 struct hlist_node *tmp;
563 /* remove from any type-based binds */
564 mutex_lock(&net->mctp.bind_lock);
565 sk_del_node_init_rcu(sk);
566 mutex_unlock(&net->mctp.bind_lock);
568 /* remove tag allocations */
569 spin_lock_irqsave(&net->mctp.keys_lock, flags);
570 hlist_for_each_entry_safe(key, tmp, &msk->keys, sklist) {
571 spin_lock_irqsave(&key->lock, fl2);
572 __mctp_key_remove(key, net, fl2, MCTP_TRACE_KEY_CLOSED);
574 spin_unlock_irqrestore(&net->mctp.keys_lock, flags);
577 static struct proto mctp_proto = {
579 .owner = THIS_MODULE,
580 .obj_size = sizeof(struct mctp_sock),
581 .init = mctp_sk_init,
582 .close = mctp_sk_close,
583 .hash = mctp_sk_hash,
584 .unhash = mctp_sk_unhash,
587 static int mctp_pf_create(struct net *net, struct socket *sock,
588 int protocol, int kern)
590 const struct proto_ops *ops;
596 return -EPROTONOSUPPORT;
598 /* only datagram sockets are supported */
599 if (sock->type != SOCK_DGRAM)
600 return -ESOCKTNOSUPPORT;
603 ops = &mctp_dgram_ops;
605 sock->state = SS_UNCONNECTED;
608 sk = sk_alloc(net, PF_MCTP, GFP_KERNEL, proto, kern);
612 sock_init_data(sock, sk);
615 if (sk->sk_prot->init)
616 rc = sk->sk_prot->init(sk);
629 static struct net_proto_family mctp_pf = {
631 .create = mctp_pf_create,
632 .owner = THIS_MODULE,
635 static __init int mctp_init(void)
639 /* ensure our uapi tag definitions match the header format */
640 BUILD_BUG_ON(MCTP_TAG_OWNER != MCTP_HDR_FLAG_TO);
641 BUILD_BUG_ON(MCTP_TAG_MASK != MCTP_HDR_TAG_MASK);
643 pr_info("mctp: management component transport protocol core\n");
645 rc = sock_register(&mctp_pf);
649 rc = proto_register(&mctp_proto, 0);
653 rc = mctp_routes_init();
655 goto err_unreg_proto;
657 rc = mctp_neigh_init();
659 goto err_unreg_proto;
666 proto_unregister(&mctp_proto);
668 sock_unregister(PF_MCTP);
673 static __exit void mctp_exit(void)
678 proto_unregister(&mctp_proto);
679 sock_unregister(PF_MCTP);
682 subsys_initcall(mctp_init);
683 module_exit(mctp_exit);
685 MODULE_DESCRIPTION("MCTP core");
686 MODULE_LICENSE("GPL v2");
687 MODULE_AUTHOR("Jeremy Kerr <jk@codeconstruct.com.au>");
689 MODULE_ALIAS_NETPROTO(PF_MCTP);