net/bluetooth/af_bluetooth.c

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