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