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