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