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