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