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