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 int noblock = flags & MSG_DONTWAIT;
255 struct sock *sk = sock->sk;
256 struct sk_buff *skb;
257 size_t copied;
258 size_t skblen;
259 int err;
260
261 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
262
263 if (flags & MSG_OOB)
264 return -EOPNOTSUPP;
265
266 skb = skb_recv_datagram(sk, flags, noblock, &err);
267 if (!skb) {
268 if (sk->sk_shutdown & RCV_SHUTDOWN)
269 return 0;
270
271 return err;
272 }
273
274 skblen = skb->len;
275 copied = skb->len;
276 if (len < copied) {
277 msg->msg_flags |= MSG_TRUNC;
278 copied = len;
279 }
280
281 skb_reset_transport_header(skb);
282 err = skb_copy_datagram_msg(skb, 0, msg, copied);
283 if (err == 0) {
284 sock_recv_ts_and_drops(msg, sk, skb);
285
286 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
287 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
288 &msg->msg_namelen);
289
290 if (bt_sk(sk)->skb_put_cmsg)
291 bt_sk(sk)->skb_put_cmsg(skb, msg, sk);
292 }
293
294 skb_free_datagram(sk, skb);
295
296 if (flags & MSG_TRUNC)
297 copied = skblen;
298
299 return err ? : copied;
300}
301EXPORT_SYMBOL(bt_sock_recvmsg);
302
303static long bt_sock_data_wait(struct sock *sk, long timeo)
304{
305 DECLARE_WAITQUEUE(wait, current);
306
307 add_wait_queue(sk_sleep(sk), &wait);
308 for (;;) {
309 set_current_state(TASK_INTERRUPTIBLE);
310
311 if (!skb_queue_empty(&sk->sk_receive_queue))
312 break;
313
314 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
315 break;
316
317 if (signal_pending(current) || !timeo)
318 break;
319
320 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
321 release_sock(sk);
322 timeo = schedule_timeout(timeo);
323 lock_sock(sk);
324 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
325 }
326
327 __set_current_state(TASK_RUNNING);
328 remove_wait_queue(sk_sleep(sk), &wait);
329 return timeo;
330}
331
332int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
333 size_t size, int flags)
334{
335 struct sock *sk = sock->sk;
336 int err = 0;
337 size_t target, copied = 0;
338 long timeo;
339
340 if (flags & MSG_OOB)
341 return -EOPNOTSUPP;
342
343 BT_DBG("sk %p size %zu", sk, size);
344
345 lock_sock(sk);
346
347 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
348 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
349
350 do {
351 struct sk_buff *skb;
352 int chunk;
353
354 skb = skb_dequeue(&sk->sk_receive_queue);
355 if (!skb) {
356 if (copied >= target)
357 break;
358
359 err = sock_error(sk);
360 if (err)
361 break;
362 if (sk->sk_shutdown & RCV_SHUTDOWN)
363 break;
364
365 err = -EAGAIN;
366 if (!timeo)
367 break;
368
369 timeo = bt_sock_data_wait(sk, timeo);
370
371 if (signal_pending(current)) {
372 err = sock_intr_errno(timeo);
373 goto out;
374 }
375 continue;
376 }
377
378 chunk = min_t(unsigned int, skb->len, size);
379 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
380 skb_queue_head(&sk->sk_receive_queue, skb);
381 if (!copied)
382 copied = -EFAULT;
383 break;
384 }
385 copied += chunk;
386 size -= chunk;
387
388 sock_recv_ts_and_drops(msg, sk, skb);
389
390 if (!(flags & MSG_PEEK)) {
391 int skb_len = skb_headlen(skb);
392
393 if (chunk <= skb_len) {
394 __skb_pull(skb, chunk);
395 } else {
396 struct sk_buff *frag;
397
398 __skb_pull(skb, skb_len);
399 chunk -= skb_len;
400
401 skb_walk_frags(skb, frag) {
402 if (chunk <= frag->len) {
403
404 skb->len -= chunk;
405 skb->data_len -= chunk;
406 __skb_pull(frag, chunk);
407 break;
408 } else if (frag->len) {
409
410 chunk -= frag->len;
411 skb->len -= frag->len;
412 skb->data_len -= frag->len;
413 __skb_pull(frag, frag->len);
414 }
415 }
416 }
417
418 if (skb->len) {
419 skb_queue_head(&sk->sk_receive_queue, skb);
420 break;
421 }
422 kfree_skb(skb);
423
424 } else {
425
426 skb_queue_head(&sk->sk_receive_queue, skb);
427 break;
428 }
429 } while (size);
430
431out:
432 release_sock(sk);
433 return copied ? : err;
434}
435EXPORT_SYMBOL(bt_sock_stream_recvmsg);
436
437static inline __poll_t bt_accept_poll(struct sock *parent)
438{
439 struct bt_sock *s, *n;
440 struct sock *sk;
441
442 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
443 sk = (struct sock *)s;
444 if (sk->sk_state == BT_CONNECTED ||
445 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
446 sk->sk_state == BT_CONNECT2))
447 return EPOLLIN | EPOLLRDNORM;
448 }
449
450 return 0;
451}
452
453__poll_t bt_sock_poll(struct file *file, struct socket *sock,
454 poll_table *wait)
455{
456 struct sock *sk = sock->sk;
457 __poll_t mask = 0;
458
459 poll_wait(file, sk_sleep(sk), wait);
460
461 if (sk->sk_state == BT_LISTEN)
462 return bt_accept_poll(sk);
463
464 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
465 mask |= EPOLLERR |
466 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
467
468 if (sk->sk_shutdown & RCV_SHUTDOWN)
469 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
470
471 if (sk->sk_shutdown == SHUTDOWN_MASK)
472 mask |= EPOLLHUP;
473
474 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
475 mask |= EPOLLIN | EPOLLRDNORM;
476
477 if (sk->sk_state == BT_CLOSED)
478 mask |= EPOLLHUP;
479
480 if (sk->sk_state == BT_CONNECT ||
481 sk->sk_state == BT_CONNECT2 ||
482 sk->sk_state == BT_CONFIG)
483 return mask;
484
485 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
486 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
487 else
488 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
489
490 return mask;
491}
492EXPORT_SYMBOL(bt_sock_poll);
493
494int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
495{
496 struct sock *sk = sock->sk;
497 struct sk_buff *skb;
498 long amount;
499 int err;
500
501 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
502
503 switch (cmd) {
504 case TIOCOUTQ:
505 if (sk->sk_state == BT_LISTEN)
506 return -EINVAL;
507
508 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
509 if (amount < 0)
510 amount = 0;
511 err = put_user(amount, (int __user *) arg);
512 break;
513
514 case TIOCINQ:
515 if (sk->sk_state == BT_LISTEN)
516 return -EINVAL;
517
518 lock_sock(sk);
519 skb = skb_peek(&sk->sk_receive_queue);
520 amount = skb ? skb->len : 0;
521 release_sock(sk);
522 err = put_user(amount, (int __user *) arg);
523 break;
524
525 default:
526 err = -ENOIOCTLCMD;
527 break;
528 }
529
530 return err;
531}
532EXPORT_SYMBOL(bt_sock_ioctl);
533
534
535int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
536{
537 DECLARE_WAITQUEUE(wait, current);
538 int err = 0;
539
540 BT_DBG("sk %p", sk);
541
542 add_wait_queue(sk_sleep(sk), &wait);
543 set_current_state(TASK_INTERRUPTIBLE);
544 while (sk->sk_state != state) {
545 if (!timeo) {
546 err = -EINPROGRESS;
547 break;
548 }
549
550 if (signal_pending(current)) {
551 err = sock_intr_errno(timeo);
552 break;
553 }
554
555 release_sock(sk);
556 timeo = schedule_timeout(timeo);
557 lock_sock(sk);
558 set_current_state(TASK_INTERRUPTIBLE);
559
560 err = sock_error(sk);
561 if (err)
562 break;
563 }
564 __set_current_state(TASK_RUNNING);
565 remove_wait_queue(sk_sleep(sk), &wait);
566 return err;
567}
568EXPORT_SYMBOL(bt_sock_wait_state);
569
570
571int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
572{
573 DECLARE_WAITQUEUE(wait, current);
574 unsigned long timeo;
575 int err = 0;
576
577 BT_DBG("sk %p", sk);
578
579 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
580
581 add_wait_queue(sk_sleep(sk), &wait);
582 set_current_state(TASK_INTERRUPTIBLE);
583 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
584 if (!timeo) {
585 err = -EAGAIN;
586 break;
587 }
588
589 if (signal_pending(current)) {
590 err = sock_intr_errno(timeo);
591 break;
592 }
593
594 release_sock(sk);
595 timeo = schedule_timeout(timeo);
596 lock_sock(sk);
597 set_current_state(TASK_INTERRUPTIBLE);
598
599 err = sock_error(sk);
600 if (err)
601 break;
602 }
603 __set_current_state(TASK_RUNNING);
604 remove_wait_queue(sk_sleep(sk), &wait);
605
606 return err;
607}
608EXPORT_SYMBOL(bt_sock_wait_ready);
609
610#ifdef CONFIG_PROC_FS
611static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
612 __acquires(seq->private->l->lock)
613{
614 struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
615
616 read_lock(&l->lock);
617 return seq_hlist_start_head(&l->head, *pos);
618}
619
620static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
621{
622 struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
623
624 return seq_hlist_next(v, &l->head, pos);
625}
626
627static void bt_seq_stop(struct seq_file *seq, void *v)
628 __releases(seq->private->l->lock)
629{
630 struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
631
632 read_unlock(&l->lock);
633}
634
635static int bt_seq_show(struct seq_file *seq, void *v)
636{
637 struct bt_sock_list *l = PDE_DATA(file_inode(seq->file));
638
639 if (v == SEQ_START_TOKEN) {
640 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
641
642 if (l->custom_seq_show) {
643 seq_putc(seq, ' ');
644 l->custom_seq_show(seq, v);
645 }
646
647 seq_putc(seq, '\n');
648 } else {
649 struct sock *sk = sk_entry(v);
650 struct bt_sock *bt = bt_sk(sk);
651
652 seq_printf(seq,
653 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
654 sk,
655 refcount_read(&sk->sk_refcnt),
656 sk_rmem_alloc_get(sk),
657 sk_wmem_alloc_get(sk),
658 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
659 sock_i_ino(sk),
660 bt->parent? sock_i_ino(bt->parent): 0LU);
661
662 if (l->custom_seq_show) {
663 seq_putc(seq, ' ');
664 l->custom_seq_show(seq, v);
665 }
666
667 seq_putc(seq, '\n');
668 }
669 return 0;
670}
671
672static const struct seq_operations bt_seq_ops = {
673 .start = bt_seq_start,
674 .next = bt_seq_next,
675 .stop = bt_seq_stop,
676 .show = bt_seq_show,
677};
678
679int bt_procfs_init(struct net *net, const char *name,
680 struct bt_sock_list *sk_list,
681 int (* seq_show)(struct seq_file *, void *))
682{
683 sk_list->custom_seq_show = seq_show;
684
685 if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
686 return -ENOMEM;
687 return 0;
688}
689
690void bt_procfs_cleanup(struct net *net, const char *name)
691{
692 remove_proc_entry(name, net->proc_net);
693}
694#else
695int bt_procfs_init(struct net *net, const char *name,
696 struct bt_sock_list *sk_list,
697 int (* seq_show)(struct seq_file *, void *))
698{
699 return 0;
700}
701
702void bt_procfs_cleanup(struct net *net, const char *name)
703{
704}
705#endif
706EXPORT_SYMBOL(bt_procfs_init);
707EXPORT_SYMBOL(bt_procfs_cleanup);
708
709static const struct net_proto_family bt_sock_family_ops = {
710 .owner = THIS_MODULE,
711 .family = PF_BLUETOOTH,
712 .create = bt_sock_create,
713};
714
715struct dentry *bt_debugfs;
716EXPORT_SYMBOL_GPL(bt_debugfs);
717
718#define VERSION __stringify(BT_SUBSYS_VERSION) "." \
719 __stringify(BT_SUBSYS_REVISION)
720
721static int __init bt_init(void)
722{
723 int err;
724
725 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
726
727 BT_INFO("Core ver %s", VERSION);
728
729 err = bt_selftest();
730 if (err < 0)
731 return err;
732
733 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
734
735 bt_leds_init();
736
737 err = bt_sysfs_init();
738 if (err < 0)
739 return err;
740
741 err = sock_register(&bt_sock_family_ops);
742 if (err)
743 goto cleanup_sysfs;
744
745 BT_INFO("HCI device and connection manager initialized");
746
747 err = hci_sock_init();
748 if (err)
749 goto unregister_socket;
750
751 err = l2cap_init();
752 if (err)
753 goto cleanup_socket;
754
755 err = sco_init();
756 if (err)
757 goto cleanup_cap;
758
759 err = mgmt_init();
760 if (err)
761 goto cleanup_sco;
762
763 return 0;
764
765cleanup_sco:
766 sco_exit();
767cleanup_cap:
768 l2cap_exit();
769cleanup_socket:
770 hci_sock_cleanup();
771unregister_socket:
772 sock_unregister(PF_BLUETOOTH);
773cleanup_sysfs:
774 bt_sysfs_cleanup();
775 return err;
776}
777
778static void __exit bt_exit(void)
779{
780 mgmt_exit();
781
782 sco_exit();
783
784 l2cap_exit();
785
786 hci_sock_cleanup();
787
788 sock_unregister(PF_BLUETOOTH);
789
790 bt_sysfs_cleanup();
791
792 bt_leds_cleanup();
793
794 debugfs_remove_recursive(bt_debugfs);
795}
796
797subsys_initcall(bt_init);
798module_exit(bt_exit);
799
800MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
801MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
802MODULE_VERSION(VERSION);
803MODULE_LICENSE("GPL");
804MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
805
