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