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