Loading...
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth address family and sockets. */
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/* Bluetooth sockets */
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_owned_by_user(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 /* FIXME: Is this check still needed */
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 /* Pulling partial data */
356 skb->len -= chunk;
357 skb->data_len -= chunk;
358 __skb_pull(frag, chunk);
359 break;
360 } else if (frag->len) {
361 /* Pulling all frag data */
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 /* put message back and return */
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/* This function expects the sk lock to be held when called */
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/* This function expects the sk lock to be held when called */
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);
1/*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth address family and sockets. */
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/* Bluetooth sockets */
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)
158{
159 BT_DBG("parent %p, sk %p", parent, sk);
160
161 sock_hold(sk);
162 lock_sock(sk);
163 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
164 bt_sk(sk)->parent = parent;
165 release_sock(sk);
166 parent->sk_ack_backlog++;
167}
168EXPORT_SYMBOL(bt_accept_enqueue);
169
170/* Calling function must hold the sk lock.
171 * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
172 */
173void bt_accept_unlink(struct sock *sk)
174{
175 BT_DBG("sk %p state %d", sk, sk->sk_state);
176
177 list_del_init(&bt_sk(sk)->accept_q);
178 bt_sk(sk)->parent->sk_ack_backlog--;
179 bt_sk(sk)->parent = NULL;
180 sock_put(sk);
181}
182EXPORT_SYMBOL(bt_accept_unlink);
183
184struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
185{
186 struct bt_sock *s, *n;
187 struct sock *sk;
188
189 BT_DBG("parent %p", parent);
190
191restart:
192 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
193 sk = (struct sock *)s;
194
195 /* Prevent early freeing of sk due to unlink and sock_kill */
196 sock_hold(sk);
197 lock_sock(sk);
198
199 /* Check sk has not already been unlinked via
200 * bt_accept_unlink() due to serialisation caused by sk locking
201 */
202 if (!bt_sk(sk)->parent) {
203 BT_DBG("sk %p, already unlinked", sk);
204 release_sock(sk);
205 sock_put(sk);
206
207 /* Restart the loop as sk is no longer in the list
208 * and also avoid a potential infinite loop because
209 * list_for_each_entry_safe() is not thread safe.
210 */
211 goto restart;
212 }
213
214 /* sk is safely in the parent list so reduce reference count */
215 sock_put(sk);
216
217 /* FIXME: Is this check still needed */
218 if (sk->sk_state == BT_CLOSED) {
219 bt_accept_unlink(sk);
220 release_sock(sk);
221 continue;
222 }
223
224 if (sk->sk_state == BT_CONNECTED || !newsock ||
225 test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
226 bt_accept_unlink(sk);
227 if (newsock)
228 sock_graft(sk, newsock);
229
230 release_sock(sk);
231 return sk;
232 }
233
234 release_sock(sk);
235 }
236
237 return NULL;
238}
239EXPORT_SYMBOL(bt_accept_dequeue);
240
241int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
242 int flags)
243{
244 int noblock = flags & MSG_DONTWAIT;
245 struct sock *sk = sock->sk;
246 struct sk_buff *skb;
247 size_t copied;
248 size_t skblen;
249 int err;
250
251 BT_DBG("sock %p sk %p len %zu", sock, sk, len);
252
253 if (flags & MSG_OOB)
254 return -EOPNOTSUPP;
255
256 skb = skb_recv_datagram(sk, flags, noblock, &err);
257 if (!skb) {
258 if (sk->sk_shutdown & RCV_SHUTDOWN)
259 return 0;
260
261 return err;
262 }
263
264 skblen = skb->len;
265 copied = skb->len;
266 if (len < copied) {
267 msg->msg_flags |= MSG_TRUNC;
268 copied = len;
269 }
270
271 skb_reset_transport_header(skb);
272 err = skb_copy_datagram_msg(skb, 0, msg, copied);
273 if (err == 0) {
274 sock_recv_ts_and_drops(msg, sk, skb);
275
276 if (msg->msg_name && bt_sk(sk)->skb_msg_name)
277 bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
278 &msg->msg_namelen);
279 }
280
281 skb_free_datagram(sk, skb);
282
283 if (flags & MSG_TRUNC)
284 copied = skblen;
285
286 return err ? : copied;
287}
288EXPORT_SYMBOL(bt_sock_recvmsg);
289
290static long bt_sock_data_wait(struct sock *sk, long timeo)
291{
292 DECLARE_WAITQUEUE(wait, current);
293
294 add_wait_queue(sk_sleep(sk), &wait);
295 for (;;) {
296 set_current_state(TASK_INTERRUPTIBLE);
297
298 if (!skb_queue_empty(&sk->sk_receive_queue))
299 break;
300
301 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
302 break;
303
304 if (signal_pending(current) || !timeo)
305 break;
306
307 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
308 release_sock(sk);
309 timeo = schedule_timeout(timeo);
310 lock_sock(sk);
311 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
312 }
313
314 __set_current_state(TASK_RUNNING);
315 remove_wait_queue(sk_sleep(sk), &wait);
316 return timeo;
317}
318
319int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
320 size_t size, int flags)
321{
322 struct sock *sk = sock->sk;
323 int err = 0;
324 size_t target, copied = 0;
325 long timeo;
326
327 if (flags & MSG_OOB)
328 return -EOPNOTSUPP;
329
330 BT_DBG("sk %p size %zu", sk, size);
331
332 lock_sock(sk);
333
334 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
335 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
336
337 do {
338 struct sk_buff *skb;
339 int chunk;
340
341 skb = skb_dequeue(&sk->sk_receive_queue);
342 if (!skb) {
343 if (copied >= target)
344 break;
345
346 err = sock_error(sk);
347 if (err)
348 break;
349 if (sk->sk_shutdown & RCV_SHUTDOWN)
350 break;
351
352 err = -EAGAIN;
353 if (!timeo)
354 break;
355
356 timeo = bt_sock_data_wait(sk, timeo);
357
358 if (signal_pending(current)) {
359 err = sock_intr_errno(timeo);
360 goto out;
361 }
362 continue;
363 }
364
365 chunk = min_t(unsigned int, skb->len, size);
366 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
367 skb_queue_head(&sk->sk_receive_queue, skb);
368 if (!copied)
369 copied = -EFAULT;
370 break;
371 }
372 copied += chunk;
373 size -= chunk;
374
375 sock_recv_ts_and_drops(msg, sk, skb);
376
377 if (!(flags & MSG_PEEK)) {
378 int skb_len = skb_headlen(skb);
379
380 if (chunk <= skb_len) {
381 __skb_pull(skb, chunk);
382 } else {
383 struct sk_buff *frag;
384
385 __skb_pull(skb, skb_len);
386 chunk -= skb_len;
387
388 skb_walk_frags(skb, frag) {
389 if (chunk <= frag->len) {
390 /* Pulling partial data */
391 skb->len -= chunk;
392 skb->data_len -= chunk;
393 __skb_pull(frag, chunk);
394 break;
395 } else if (frag->len) {
396 /* Pulling all frag data */
397 chunk -= frag->len;
398 skb->len -= frag->len;
399 skb->data_len -= frag->len;
400 __skb_pull(frag, frag->len);
401 }
402 }
403 }
404
405 if (skb->len) {
406 skb_queue_head(&sk->sk_receive_queue, skb);
407 break;
408 }
409 kfree_skb(skb);
410
411 } else {
412 /* put message back and return */
413 skb_queue_head(&sk->sk_receive_queue, skb);
414 break;
415 }
416 } while (size);
417
418out:
419 release_sock(sk);
420 return copied ? : err;
421}
422EXPORT_SYMBOL(bt_sock_stream_recvmsg);
423
424static inline __poll_t bt_accept_poll(struct sock *parent)
425{
426 struct bt_sock *s, *n;
427 struct sock *sk;
428
429 list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
430 sk = (struct sock *)s;
431 if (sk->sk_state == BT_CONNECTED ||
432 (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
433 sk->sk_state == BT_CONNECT2))
434 return EPOLLIN | EPOLLRDNORM;
435 }
436
437 return 0;
438}
439
440__poll_t bt_sock_poll(struct file *file, struct socket *sock,
441 poll_table *wait)
442{
443 struct sock *sk = sock->sk;
444 __poll_t mask = 0;
445
446 BT_DBG("sock %p, sk %p", sock, sk);
447
448 poll_wait(file, sk_sleep(sk), wait);
449
450 if (sk->sk_state == BT_LISTEN)
451 return bt_accept_poll(sk);
452
453 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
454 mask |= EPOLLERR |
455 (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
456
457 if (sk->sk_shutdown & RCV_SHUTDOWN)
458 mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
459
460 if (sk->sk_shutdown == SHUTDOWN_MASK)
461 mask |= EPOLLHUP;
462
463 if (!skb_queue_empty(&sk->sk_receive_queue))
464 mask |= EPOLLIN | EPOLLRDNORM;
465
466 if (sk->sk_state == BT_CLOSED)
467 mask |= EPOLLHUP;
468
469 if (sk->sk_state == BT_CONNECT ||
470 sk->sk_state == BT_CONNECT2 ||
471 sk->sk_state == BT_CONFIG)
472 return mask;
473
474 if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
475 mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
476 else
477 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
478
479 return mask;
480}
481EXPORT_SYMBOL(bt_sock_poll);
482
483int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
484{
485 struct sock *sk = sock->sk;
486 struct sk_buff *skb;
487 long amount;
488 int err;
489
490 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
491
492 switch (cmd) {
493 case TIOCOUTQ:
494 if (sk->sk_state == BT_LISTEN)
495 return -EINVAL;
496
497 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
498 if (amount < 0)
499 amount = 0;
500 err = put_user(amount, (int __user *) arg);
501 break;
502
503 case TIOCINQ:
504 if (sk->sk_state == BT_LISTEN)
505 return -EINVAL;
506
507 lock_sock(sk);
508 skb = skb_peek(&sk->sk_receive_queue);
509 amount = skb ? skb->len : 0;
510 release_sock(sk);
511 err = put_user(amount, (int __user *) arg);
512 break;
513
514 case SIOCGSTAMP:
515 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
516 break;
517
518 case SIOCGSTAMPNS:
519 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
520 break;
521
522 default:
523 err = -ENOIOCTLCMD;
524 break;
525 }
526
527 return err;
528}
529EXPORT_SYMBOL(bt_sock_ioctl);
530
531/* This function expects the sk lock to be held when called */
532int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
533{
534 DECLARE_WAITQUEUE(wait, current);
535 int err = 0;
536
537 BT_DBG("sk %p", sk);
538
539 add_wait_queue(sk_sleep(sk), &wait);
540 set_current_state(TASK_INTERRUPTIBLE);
541 while (sk->sk_state != state) {
542 if (!timeo) {
543 err = -EINPROGRESS;
544 break;
545 }
546
547 if (signal_pending(current)) {
548 err = sock_intr_errno(timeo);
549 break;
550 }
551
552 release_sock(sk);
553 timeo = schedule_timeout(timeo);
554 lock_sock(sk);
555 set_current_state(TASK_INTERRUPTIBLE);
556
557 err = sock_error(sk);
558 if (err)
559 break;
560 }
561 __set_current_state(TASK_RUNNING);
562 remove_wait_queue(sk_sleep(sk), &wait);
563 return err;
564}
565EXPORT_SYMBOL(bt_sock_wait_state);
566
567/* This function expects the sk lock to be held when called */
568int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
569{
570 DECLARE_WAITQUEUE(wait, current);
571 unsigned long timeo;
572 int err = 0;
573
574 BT_DBG("sk %p", sk);
575
576 timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
577
578 add_wait_queue(sk_sleep(sk), &wait);
579 set_current_state(TASK_INTERRUPTIBLE);
580 while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
581 if (!timeo) {
582 err = -EAGAIN;
583 break;
584 }
585
586 if (signal_pending(current)) {
587 err = sock_intr_errno(timeo);
588 break;
589 }
590
591 release_sock(sk);
592 timeo = schedule_timeout(timeo);
593 lock_sock(sk);
594 set_current_state(TASK_INTERRUPTIBLE);
595
596 err = sock_error(sk);
597 if (err)
598 break;
599 }
600 __set_current_state(TASK_RUNNING);
601 remove_wait_queue(sk_sleep(sk), &wait);
602
603 return err;
604}
605EXPORT_SYMBOL(bt_sock_wait_ready);
606
607#ifdef CONFIG_PROC_FS
608struct bt_seq_state {
609 struct bt_sock_list *l;
610};
611
612static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
613 __acquires(seq->private->l->lock)
614{
615 struct bt_seq_state *s = seq->private;
616 struct bt_sock_list *l = s->l;
617
618 read_lock(&l->lock);
619 return seq_hlist_start_head(&l->head, *pos);
620}
621
622static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
623{
624 struct bt_seq_state *s = seq->private;
625 struct bt_sock_list *l = s->l;
626
627 return seq_hlist_next(v, &l->head, pos);
628}
629
630static void bt_seq_stop(struct seq_file *seq, void *v)
631 __releases(seq->private->l->lock)
632{
633 struct bt_seq_state *s = seq->private;
634 struct bt_sock_list *l = s->l;
635
636 read_unlock(&l->lock);
637}
638
639static int bt_seq_show(struct seq_file *seq, void *v)
640{
641 struct bt_seq_state *s = seq->private;
642 struct bt_sock_list *l = s->l;
643
644 if (v == SEQ_START_TOKEN) {
645 seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
646
647 if (l->custom_seq_show) {
648 seq_putc(seq, ' ');
649 l->custom_seq_show(seq, v);
650 }
651
652 seq_putc(seq, '\n');
653 } else {
654 struct sock *sk = sk_entry(v);
655 struct bt_sock *bt = bt_sk(sk);
656
657 seq_printf(seq,
658 "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
659 sk,
660 refcount_read(&sk->sk_refcnt),
661 sk_rmem_alloc_get(sk),
662 sk_wmem_alloc_get(sk),
663 from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
664 sock_i_ino(sk),
665 bt->parent? sock_i_ino(bt->parent): 0LU);
666
667 if (l->custom_seq_show) {
668 seq_putc(seq, ' ');
669 l->custom_seq_show(seq, v);
670 }
671
672 seq_putc(seq, '\n');
673 }
674 return 0;
675}
676
677static const struct seq_operations bt_seq_ops = {
678 .start = bt_seq_start,
679 .next = bt_seq_next,
680 .stop = bt_seq_stop,
681 .show = bt_seq_show,
682};
683
684static int bt_seq_open(struct inode *inode, struct file *file)
685{
686 struct bt_sock_list *sk_list;
687 struct bt_seq_state *s;
688
689 sk_list = PDE_DATA(inode);
690 s = __seq_open_private(file, &bt_seq_ops,
691 sizeof(struct bt_seq_state));
692 if (!s)
693 return -ENOMEM;
694
695 s->l = sk_list;
696 return 0;
697}
698
699static const struct file_operations bt_fops = {
700 .open = bt_seq_open,
701 .read = seq_read,
702 .llseek = seq_lseek,
703 .release = seq_release_private
704};
705
706int bt_procfs_init(struct net *net, const char *name,
707 struct bt_sock_list *sk_list,
708 int (* seq_show)(struct seq_file *, void *))
709{
710 sk_list->custom_seq_show = seq_show;
711
712 if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
713 return -ENOMEM;
714 return 0;
715}
716
717void bt_procfs_cleanup(struct net *net, const char *name)
718{
719 remove_proc_entry(name, net->proc_net);
720}
721#else
722int bt_procfs_init(struct net *net, const char *name,
723 struct bt_sock_list *sk_list,
724 int (* seq_show)(struct seq_file *, void *))
725{
726 return 0;
727}
728
729void bt_procfs_cleanup(struct net *net, const char *name)
730{
731}
732#endif
733EXPORT_SYMBOL(bt_procfs_init);
734EXPORT_SYMBOL(bt_procfs_cleanup);
735
736static const struct net_proto_family bt_sock_family_ops = {
737 .owner = THIS_MODULE,
738 .family = PF_BLUETOOTH,
739 .create = bt_sock_create,
740};
741
742struct dentry *bt_debugfs;
743EXPORT_SYMBOL_GPL(bt_debugfs);
744
745#define VERSION __stringify(BT_SUBSYS_VERSION) "." \
746 __stringify(BT_SUBSYS_REVISION)
747
748static int __init bt_init(void)
749{
750 int err;
751
752 sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
753
754 BT_INFO("Core ver %s", VERSION);
755
756 err = bt_selftest();
757 if (err < 0)
758 return err;
759
760 bt_debugfs = debugfs_create_dir("bluetooth", NULL);
761
762 bt_leds_init();
763
764 err = bt_sysfs_init();
765 if (err < 0)
766 return err;
767
768 err = sock_register(&bt_sock_family_ops);
769 if (err)
770 goto cleanup_sysfs;
771
772 BT_INFO("HCI device and connection manager initialized");
773
774 err = hci_sock_init();
775 if (err)
776 goto unregister_socket;
777
778 err = l2cap_init();
779 if (err)
780 goto cleanup_socket;
781
782 err = sco_init();
783 if (err)
784 goto cleanup_cap;
785
786 err = mgmt_init();
787 if (err)
788 goto cleanup_sco;
789
790 return 0;
791
792cleanup_sco:
793 sco_exit();
794cleanup_cap:
795 l2cap_exit();
796cleanup_socket:
797 hci_sock_cleanup();
798unregister_socket:
799 sock_unregister(PF_BLUETOOTH);
800cleanup_sysfs:
801 bt_sysfs_cleanup();
802 return err;
803}
804
805static void __exit bt_exit(void)
806{
807 mgmt_exit();
808
809 sco_exit();
810
811 l2cap_exit();
812
813 hci_sock_cleanup();
814
815 sock_unregister(PF_BLUETOOTH);
816
817 bt_sysfs_cleanup();
818
819 bt_leds_cleanup();
820
821 debugfs_remove_recursive(bt_debugfs);
822}
823
824subsys_initcall(bt_init);
825module_exit(bt_exit);
826
827MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
828MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
829MODULE_VERSION(VERSION);
830MODULE_LICENSE("GPL");
831MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);