1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/module.h>
28#include <linux/debugfs.h>
29#include <linux/stringify.h>
30#include <linux/sched/signal.h>
31
32#include <asm/ioctls.h>
33
34#include <net/bluetooth/bluetooth.h>
35#include <linux/proc_fs.h>
36
37#include "leds.h"
38#include "selftest.h"
39
40
41#define BT_MAX_PROTO 8
42static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
43static DEFINE_RWLOCK(bt_proto_lock);
44
45static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
46static const char *const bt_key_strings[BT_MAX_PROTO] = {
47 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
51 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
52 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
53 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
54 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
55};
56
57static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
58static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
59 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
60 "slock-AF_BLUETOOTH-BTPROTO_HCI",
61 "slock-AF_BLUETOOTH-BTPROTO_SCO",
62 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
63 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
64 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
65 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
66 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
67};
68
69void bt_sock_reclassify_lock(struct sock *sk, int proto)
70{
71 BUG_ON(!sk);
72 BUG_ON(!sock_allow_reclassification(sk));
73
74 sock_lock_init_class_and_name(sk,
75 bt_slock_key_strings[proto], &bt_slock_key[proto],
76 bt_key_strings[proto], &bt_lock_key[proto]);
77}
78EXPORT_SYMBOL(bt_sock_reclassify_lock);
79
80int bt_sock_register(int proto, const struct net_proto_family *ops)
81{
82 int err = 0;
83
84 if (proto < 0 || proto >= BT_MAX_PROTO)
85 return -EINVAL;
86
87 write_lock(&bt_proto_lock);
88
89 if (bt_proto[proto])
90 err = -EEXIST;
91 else
92 bt_proto[proto] = ops;
93
94 write_unlock(&bt_proto_lock);
95
96 return err;
97}
98EXPORT_SYMBOL(bt_sock_register);
99
100void bt_sock_unregister(int proto)
101{
102 if (proto < 0 || proto >= BT_MAX_PROTO)
103 return;
104
105 write_lock(&bt_proto_lock);
106 bt_proto[proto] = NULL;
107 write_unlock(&bt_proto_lock);
108}
109EXPORT_SYMBOL(bt_sock_unregister);
110
111static int bt_sock_create(struct net *net, struct socket *sock, int proto,
112 int kern)
113{
114 int err;
115
116 if (net != &init_net)
117 return -EAFNOSUPPORT;
118
119 if (proto < 0 || proto >= BT_MAX_PROTO)
120 return -EINVAL;
121
122 if (!bt_proto[proto])
123 request_module("bt-proto-%d", proto);
124
125 err = -EPROTONOSUPPORT;
126
127 read_lock(&bt_proto_lock);
128
129 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
130 err = bt_proto[proto]->create(net, sock, proto, kern);
131 if (!err)
132 bt_sock_reclassify_lock(sock->sk, proto);
133 module_put(bt_proto[proto]->owner);
134 }
135
136 read_unlock(&bt_proto_lock);
137
138 return err;
139}
140
141void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
142{
143 write_lock(&l->lock);
144 sk_add_node(sk, &l->head);
145 write_unlock(&l->lock);
146}
147EXPORT_SYMBOL(bt_sock_link);
148
149void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
150{
151 write_lock(&l->lock);
152 sk_del_node_init(sk);
153 write_unlock(&l->lock);
154}
155EXPORT_SYMBOL(bt_sock_unlink);
156
157void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
158{
159 BT_DBG("parent %p, sk %p", parent, sk);
160
161 sock_hold(sk);
162
163 if (bh)
164 bh_lock_sock_nested(sk);
165 else
166 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
167
168 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
169 bt_sk(sk)->parent = parent;
170
171 if (bh)
172 bh_unlock_sock(sk);
173 else
174 release_sock(sk);
175
176 sk_acceptq_added(parent);
177}
178EXPORT_SYMBOL(bt_accept_enqueue);
179
180
181
182
183void bt_accept_unlink(struct sock *sk)
184{
185 BT_DBG("sk %p state %d", sk, sk->sk_state);
186
187 list_del_init(&bt_sk(sk)->accept_q);
188 sk_acceptq_removed(bt_sk(sk)->parent);
189 bt_sk(sk)->parent = NULL;
190 sock_put(sk);
191}
192EXPORT_SYMBOL(bt_accept_unlink);
193
194struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
195{
196 struct bt_sock *s, *n;
197 struct sock *sk;
198
199 BT_DBG("parent %p", parent);
200
201restart:
202 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
203 sk = (struct sock *)s;
204
205
206 sock_hold(sk);
207 lock_sock(sk);
208
209
210
211
212 if (!bt_sk(sk)->parent) {
213 BT_DBG("sk %p, already unlinked", sk);
214 release_sock(sk);
215 sock_put(sk);
216
217
218
219
220
221 goto restart;
222 }
223
224
225 sock_put(sk);
226
227
228 if (sk->sk_state == BT_CLOSED) {
229 bt_accept_unlink(sk);
230 release_sock(sk);
231 continue;
232 }
233
234 if (sk->sk_state == BT_CONNECTED || !newsock ||
235 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
236 bt_accept_unlink(sk);
237 if (newsock)
238 sock_graft(sk, newsock);
239
240 release_sock(sk);
241 return sk;
242 }
243
244 release_sock(sk);
245 }
246
247 return NULL;
248}
249EXPORT_SYMBOL(bt_accept_dequeue);
250
251int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
252 int flags)
253{
254 struct sock *sk = sock->sk;
255 struct sk_buff *skb;
256 size_t copied;
257 size_t skblen;
258 int err;
259
260 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
261
262 if (flags & MSG_OOB)
263 return -EOPNOTSUPP;
264
265 skb = skb_recv_datagram(sk, flags, &err);
266 if (!skb) {
267 if (sk->sk_shutdown & RCV_SHUTDOWN)
268 return 0;
269
270 return err;
271 }
272
273 skblen = skb->len;
274 copied = skb->len;
275 if (len < copied) {
276 msg->msg_flags |= MSG_TRUNC;
277 copied = len;
278 }
279
280 skb_reset_transport_header(skb);
281 err = skb_copy_datagram_msg(skb, 0, msg, copied);
282 if (err == 0) {
283 sock_recv_cmsgs(msg, sk, skb);
284
285 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
286 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
287 &msg->msg_namelen);
288
289 if (bt_sk(sk)->skb_put_cmsg)
290 bt_sk(sk)->skb_put_cmsg(skb, msg, sk);
291 }
292
293 skb_free_datagram(sk, skb);
294
295 if (flags & MSG_TRUNC)
296 copied = skblen;
297
298 return err ? : copied;
299}
300EXPORT_SYMBOL(bt_sock_recvmsg);
301
302static long bt_sock_data_wait(struct sock *sk, long timeo)
303{
304 DECLARE_WAITQUEUE(wait, current);
305
306 add_wait_queue(sk_sleep(sk), &wait);
307 for (;;) {
308 set_current_state(TASK_INTERRUPTIBLE);
309
310 if (!skb_queue_empty(&sk->sk_receive_queue))
311 break;
312
313 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
314 break;
315
316 if (signal_pending(current) || !timeo)
317 break;
318
319 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
320 release_sock(sk);
321 timeo = schedule_timeout(timeo);
322 lock_sock(sk);
323 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
324 }
325
326 __set_current_state(TASK_RUNNING);
327 remove_wait_queue(sk_sleep(sk), &wait);
328 return timeo;
329}
330
331int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
332 size_t size, int flags)
333{
334 struct sock *sk = sock->sk;
335 int err = 0;
336 size_t target, copied = 0;
337 long timeo;
338
339 if (flags & MSG_OOB)
340 return -EOPNOTSUPP;
341
342 BT_DBG("sk %p size %zu", sk, size);
343
344 lock_sock(sk);
345
346 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
347 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
348
349 do {
350 struct sk_buff *skb;
351 int chunk;
352
353 skb = skb_dequeue(&sk->sk_receive_queue);
354 if (!skb) {
355 if (copied >= target)
356 break;
357
358 err = sock_error(sk);
359 if (err)
360 break;
361 if (sk->sk_shutdown & RCV_SHUTDOWN)
362 break;
363
364 err = -EAGAIN;
365 if (!timeo)
366 break;
367
368 timeo = bt_sock_data_wait(sk, timeo);
369
370 if (signal_pending(current)) {
371 err = sock_intr_errno(timeo);
372 goto out;
373 }
374 continue;
375 }
376
377 chunk = min_t(unsigned int, skb->len, size);
378 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
379 skb_queue_head(&sk->sk_receive_queue, skb);
380 if (!copied)
381 copied = -EFAULT;
382 break;
383 }
384 copied += chunk;
385 size -= chunk;
386
387 sock_recv_cmsgs(msg, sk, skb);
388
389 if (!(flags & MSG_PEEK)) {
390 int skb_len = skb_headlen(skb);
391
392 if (chunk <= skb_len) {
393 __skb_pull(skb, chunk);
394 } else {
395 struct sk_buff *frag;
396
397 __skb_pull(skb, skb_len);
398 chunk -= skb_len;
399
400 skb_walk_frags(skb, frag) {
401 if (chunk <= frag->len) {
402
403 skb->len -= chunk;
404 skb->data_len -= chunk;
405 __skb_pull(frag, chunk);
406 break;
407 } else if (frag->len) {
408
409 chunk -= frag->len;
410 skb->len -= frag->len;
411 skb->data_len -= frag->len;
412 __skb_pull(frag, frag->len);
413 }
414 }
415 }
416
417 if (skb->len) {
418 skb_queue_head(&sk->sk_receive_queue, skb);
419 break;
420 }
421 kfree_skb(skb);
422
423 } else {
424
425 skb_queue_head(&sk->sk_receive_queue, skb);
426 break;
427 }
428 } while (size);
429
430out:
431 release_sock(sk);
432 return copied ? : err;
433}
434EXPORT_SYMBOL(bt_sock_stream_recvmsg);
435
436static inline __poll_t bt_accept_poll(struct sock *parent)
437{
438 struct bt_sock *s, *n;
439 struct sock *sk;
440
441 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
442 sk = (struct sock *)s;
443 if (sk->sk_state == BT_CONNECTED ||
444 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
445 sk->sk_state == BT_CONNECT2))
446 return EPOLLIN | EPOLLRDNORM;
447 }
448
449 return 0;
450}
451
452__poll_t bt_sock_poll(struct file *file, struct socket *sock,
453 poll_table *wait)
454{
455 struct sock *sk = sock->sk;
456 __poll_t mask = 0;
457
458 poll_wait(file, sk_sleep(sk), wait);
459
460 if (sk->sk_state == BT_LISTEN)
461 return bt_accept_poll(sk);
462
463 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
464 mask |= EPOLLERR |
465 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
466
467 if (sk->sk_shutdown & RCV_SHUTDOWN)
468 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
469
470 if (sk->sk_shutdown == SHUTDOWN_MASK)
471 mask |= EPOLLHUP;
472
473 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
474 mask |= EPOLLIN | EPOLLRDNORM;
475
476 if (sk->sk_state == BT_CLOSED)
477 mask |= EPOLLHUP;
478
479 if (sk->sk_state == BT_CONNECT ||
480 sk->sk_state == BT_CONNECT2 ||
481 sk->sk_state == BT_CONFIG)
482 return mask;
483
484 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
485 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
486 else
487 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
488
489 return mask;
490}
491EXPORT_SYMBOL(bt_sock_poll);
492
493int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
494{
495 struct sock *sk = sock->sk;
496 struct sk_buff *skb;
497 long amount;
498 int err;
499
500 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
501
502 switch (cmd) {
503 case TIOCOUTQ:
504 if (sk->sk_state == BT_LISTEN)
505 return -EINVAL;
506
507 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
508 if (amount < 0)
509 amount = 0;
510 err = put_user(amount, (int __user *)arg);
511 break;
512
513 case TIOCINQ:
514 if (sk->sk_state == BT_LISTEN)
515 return -EINVAL;
516
517 lock_sock(sk);
518 skb = skb_peek(&sk->sk_receive_queue);
519 amount = skb ? skb->len : 0;
520 release_sock(sk);
521 err = put_user(amount, (int __user *)arg);
522 break;
523
524 default:
525 err = -ENOIOCTLCMD;
526 break;
527 }
528
529 return err;
530}
531EXPORT_SYMBOL(bt_sock_ioctl);
532
533
534int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
535{
536 DECLARE_WAITQUEUE(wait, current);
537 int err = 0;
538
539 BT_DBG("sk %p", sk);
540
541 add_wait_queue(sk_sleep(sk), &wait);
542 set_current_state(TASK_INTERRUPTIBLE);
543 while (sk->sk_state != state) {
544 if (!timeo) {
545 err = -EINPROGRESS;
546 break;
547 }
548
549 if (signal_pending(current)) {
550 err = sock_intr_errno(timeo);
551 break;
552 }
553
554 release_sock(sk);
555 timeo = schedule_timeout(timeo);
556 lock_sock(sk);
557 set_current_state(TASK_INTERRUPTIBLE);
558
559 err = sock_error(sk);
560 if (err)
561 break;
562 }
563 __set_current_state(TASK_RUNNING);
564 remove_wait_queue(sk_sleep(sk), &wait);
565 return err;
566}
567EXPORT_SYMBOL(bt_sock_wait_state);
568
569
570int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
571{
572 DECLARE_WAITQUEUE(wait, current);
573 unsigned long timeo;
574 int err = 0;
575
576 BT_DBG("sk %p", sk);
577
578 timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
579
580 add_wait_queue(sk_sleep(sk), &wait);
581 set_current_state(TASK_INTERRUPTIBLE);
582 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
583 if (!timeo) {
584 err = -EAGAIN;
585 break;
586 }
587
588 if (signal_pending(current)) {
589 err = sock_intr_errno(timeo);
590 break;
591 }
592
593 release_sock(sk);
594 timeo = schedule_timeout(timeo);
595 lock_sock(sk);
596 set_current_state(TASK_INTERRUPTIBLE);
597
598 err = sock_error(sk);
599 if (err)
600 break;
601 }
602 __set_current_state(TASK_RUNNING);
603 remove_wait_queue(sk_sleep(sk), &wait);
604
605 return err;
606}
607EXPORT_SYMBOL(bt_sock_wait_ready);
608
609#ifdef CONFIG_PROC_FS
610static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
611 __acquires(seq->private->l->lock)
612{
613 struct bt_sock_list *l = pde_data(file_inode(seq->file));
614
615 read_lock(&l->lock);
616 return seq_hlist_start_head(&l->head, *pos);
617}
618
619static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
620{
621 struct bt_sock_list *l = pde_data(file_inode(seq->file));
622
623 return seq_hlist_next(v, &l->head, pos);
624}
625
626static void bt_seq_stop(struct seq_file *seq, void *v)
627 __releases(seq->private->l->lock)
628{
629 struct bt_sock_list *l = pde_data(file_inode(seq->file));
630
631 read_unlock(&l->lock);
632}
633
634static int bt_seq_show(struct seq_file *seq, void *v)
635{
636 struct bt_sock_list *l = pde_data(file_inode(seq->file));
637
638 if (v == SEQ_START_TOKEN) {
639 seq_puts(seq, "sk RefCnt Rmem Wmem User Inode Parent");
640
641 if (l->custom_seq_show) {
642 seq_putc(seq, ' ');
643 l->custom_seq_show(seq, v);
644 }
645
646 seq_putc(seq, '\n');
647 } else {
648 struct sock *sk = sk_entry(v);
649 struct bt_sock *bt = bt_sk(sk);
650
651 seq_printf(seq,
652 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
653 sk,
654 refcount_read(&sk->sk_refcnt),
655 sk_rmem_alloc_get(sk),
656 sk_wmem_alloc_get(sk),
657 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
658 sock_i_ino(sk),
659 bt->parent ? sock_i_ino(bt->parent) : 0LU);
660
661 if (l->custom_seq_show) {
662 seq_putc(seq, ' ');
663 l->custom_seq_show(seq, v);
664 }
665
666 seq_putc(seq, '\n');
667 }
668 return 0;
669}
670
671static const struct seq_operations bt_seq_ops = {
672 .start = bt_seq_start,
673 .next = bt_seq_next,
674 .stop = bt_seq_stop,
675 .show = bt_seq_show,
676};
677
678int bt_procfs_init(struct net *net, const char *name,
679 struct bt_sock_list *sk_list,
680 int (*seq_show)(struct seq_file *, void *))
681{
682 sk_list->custom_seq_show = seq_show;
683
684 if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
685 return -ENOMEM;
686 return 0;
687}
688
689void bt_procfs_cleanup(struct net *net, const char *name)
690{
691 remove_proc_entry(name, net->proc_net);
692}
693#else
694int bt_procfs_init(struct net *net, const char *name,
695 struct bt_sock_list *sk_list,
696 int (*seq_show)(struct seq_file *, void *))
697{
698 return 0;
699}
700
701void bt_procfs_cleanup(struct net *net, const char *name)
702{
703}
704#endif
705EXPORT_SYMBOL(bt_procfs_init);
706EXPORT_SYMBOL(bt_procfs_cleanup);
707
708static const struct net_proto_family bt_sock_family_ops = {
709 .owner = THIS_MODULE,
710 .family = PF_BLUETOOTH,
711 .create = bt_sock_create,
712};
713
714struct dentry *bt_debugfs;
715EXPORT_SYMBOL_GPL(bt_debugfs);
716
717#define VERSION __stringify(BT_SUBSYS_VERSION) "." \
718 __stringify(BT_SUBSYS_REVISION)
719
720static int __init bt_init(void)
721{
722 int err;
723
724 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
725
726 BT_INFO("Core ver %s", VERSION);
727
728 err = bt_selftest();
729 if (err < 0)
730 return err;
731
732 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
733
734 bt_leds_init();
735
736 err = bt_sysfs_init();
737 if (err < 0)
738 return err;
739
740 err = sock_register(&bt_sock_family_ops);
741 if (err)
742 goto cleanup_sysfs;
743
744 BT_INFO("HCI device and connection manager initialized");
745
746 err = hci_sock_init();
747 if (err)
748 goto unregister_socket;
749
750 err = l2cap_init();
751 if (err)
752 goto cleanup_socket;
753
754 err = sco_init();
755 if (err)
756 goto cleanup_cap;
757
758 err = mgmt_init();
759 if (err)
760 goto cleanup_sco;
761
762 return 0;
763
764cleanup_sco:
765 sco_exit();
766cleanup_cap:
767 l2cap_exit();
768cleanup_socket:
769 hci_sock_cleanup();
770unregister_socket:
771 sock_unregister(PF_BLUETOOTH);
772cleanup_sysfs:
773 bt_sysfs_cleanup();
774 return err;
775}
776
777static void __exit bt_exit(void)
778{
779 mgmt_exit();
780
781 sco_exit();
782
783 l2cap_exit();
784
785 hci_sock_cleanup();
786
787 sock_unregister(PF_BLUETOOTH);
788
789 bt_sysfs_cleanup();
790
791 bt_leds_cleanup();
792
793 debugfs_remove_recursive(bt_debugfs);
794}
795
796subsys_initcall(bt_init);
797module_exit(bt_exit);
798
799MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
800MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
801MODULE_VERSION(VERSION);
802MODULE_LICENSE("GPL");
803MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
804
