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