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                         return 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                 lock_sock(sk);
 520                 skb = skb_peek(&sk->sk_receive_queue);
 521                 amount = skb ? skb->len : 0;
 522                 release_sock(sk);
 523                 err = put_user(amount, (int __user *)arg);
 524                 break;
 525
 526         default:
 527                 err = -ENOIOCTLCMD;
 528                 break;
 529         }
 530
 531         return err;
 532 }
 533 EXPORT_SYMBOL(bt_sock_ioctl);
 534
 535 /* This function expects the sk lock to be held when called */
 536 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 537 {
 538         DECLARE_WAITQUEUE(wait, current);
 539         int err = 0;
 540
 541         BT_DBG("sk %p", sk);
 542
 543         add_wait_queue(sk_sleep(sk), &wait);
 544         set_current_state(TASK_INTERRUPTIBLE);
 545         while (sk->sk_state != state) {
 546                 if (!timeo) {
 547                         err = -EINPROGRESS;
 548                         break;
 549                 }
 550
 551                 if (signal_pending(current)) {
 552                         err = sock_intr_errno(timeo);
 553                         break;
 554                 }
 555
 556                 release_sock(sk);
 557                 timeo = schedule_timeout(timeo);
 558                 lock_sock(sk);
 559                 set_current_state(TASK_INTERRUPTIBLE);
 560
 561                 err = sock_error(sk);
 562                 if (err)
 563                         break;
 564         }
 565         __set_current_state(TASK_RUNNING);
 566         remove_wait_queue(sk_sleep(sk), &wait);
 567         return err;
 568 }
 569 EXPORT_SYMBOL(bt_sock_wait_state);
 570
 571 /* This function expects the sk lock to be held when called */
 572 int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
 573 {
 574         DECLARE_WAITQUEUE(wait, current);
 575         unsigned long timeo;
 576         int err = 0;
 577
 578         BT_DBG("sk %p", sk);
 579
 580         timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
 581
 582         add_wait_queue(sk_sleep(sk), &wait);
 583         set_current_state(TASK_INTERRUPTIBLE);
 584         while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
 585                 if (!timeo) {
 586                         err = -EAGAIN;
 587                         break;
 588                 }
 589
 590                 if (signal_pending(current)) {
 591                         err = sock_intr_errno(timeo);
 592                         break;
 593                 }
 594
 595                 release_sock(sk);
 596                 timeo = schedule_timeout(timeo);
 597                 lock_sock(sk);
 598                 set_current_state(TASK_INTERRUPTIBLE);
 599
 600                 err = sock_error(sk);
 601                 if (err)
 602                         break;
 603         }
 604         __set_current_state(TASK_RUNNING);
 605         remove_wait_queue(sk_sleep(sk), &wait);
 606
 607         return err;
 608 }
 609 EXPORT_SYMBOL(bt_sock_wait_ready);
 610
 611 #ifdef CONFIG_PROC_FS
 612 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
 613         __acquires(seq->private->l->lock)
 614 {
 615         struct bt_sock_list *l = pde_data(file_inode(seq->file));
 616
 617         read_lock(&l->lock);
 618         return seq_hlist_start_head(&l->head, *pos);
 619 }
 620
 621 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 622 {
 623         struct bt_sock_list *l = pde_data(file_inode(seq->file));
 624
 625         return seq_hlist_next(v, &l->head, pos);
 626 }
 627
 628 static void bt_seq_stop(struct seq_file *seq, void *v)
 629         __releases(seq->private->l->lock)
 630 {
 631         struct bt_sock_list *l = pde_data(file_inode(seq->file));
 632
 633         read_unlock(&l->lock);
 634 }
 635
 636 static int bt_seq_show(struct seq_file *seq, void *v)
 637 {
 638         struct bt_sock_list *l = pde_data(file_inode(seq->file));
 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                            refcount_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 int bt_procfs_init(struct net *net, const char *name,
 681                    struct bt_sock_list *sk_list,
 682                    int (*seq_show)(struct seq_file *, void *))
 683 {
 684         sk_list->custom_seq_show = seq_show;
 685
 686         if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
 687                 return -ENOMEM;
 688         return 0;
 689 }
 690
 691 void bt_procfs_cleanup(struct net *net, const char *name)
 692 {
 693         remove_proc_entry(name, net->proc_net);
 694 }
 695 #else
 696 int bt_procfs_init(struct net *net, const char *name,
 697                    struct bt_sock_list *sk_list,
 698                    int (*seq_show)(struct seq_file *, void *))
 699 {
 700         return 0;
 701 }
 702
 703 void bt_procfs_cleanup(struct net *net, const char *name)
 704 {
 705 }
 706 #endif
 707 EXPORT_SYMBOL(bt_procfs_init);
 708 EXPORT_SYMBOL(bt_procfs_cleanup);
 709
 710 static const struct net_proto_family bt_sock_family_ops = {
 711         .owner  = THIS_MODULE,
 712         .family = PF_BLUETOOTH,
 713         .create = bt_sock_create,
 714 };
 715
 716 struct dentry *bt_debugfs;
 717 EXPORT_SYMBOL_GPL(bt_debugfs);
 718
 719 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
 720                 __stringify(BT_SUBSYS_REVISION)
 721
 722 static int __init bt_init(void)
 723 {
 724         int err;
 725
 726         sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
 727
 728         BT_INFO("Core ver %s", VERSION);
 729
 730         err = bt_selftest();
 731         if (err < 0)
 732                 return err;
 733
 734         bt_debugfs = debugfs_create_dir("bluetooth", NULL);
 735
 736         bt_leds_init();
 737
 738         err = bt_sysfs_init();
 739         if (err < 0)
 740                 goto cleanup_led;
 741
 742         err = sock_register(&bt_sock_family_ops);
 743         if (err)
 744                 goto cleanup_sysfs;
 745
 746         BT_INFO("HCI device and connection manager initialized");
 747
 748         err = hci_sock_init();
 749         if (err)
 750                 goto unregister_socket;
 751
 752         err = l2cap_init();
 753         if (err)
 754                 goto cleanup_socket;
 755
 756         err = sco_init();
 757         if (err)
 758                 goto cleanup_cap;
 759
 760         err = mgmt_init();
 761         if (err)
 762                 goto cleanup_sco;
 763
 764         return 0;
 765
 766 cleanup_sco:
 767         sco_exit();
 768 cleanup_cap:
 769         l2cap_exit();
 770 cleanup_socket:
 771         hci_sock_cleanup();
 772 unregister_socket:
 773         sock_unregister(PF_BLUETOOTH);
 774 cleanup_sysfs:
 775         bt_sysfs_cleanup();
 776 cleanup_led:
 777         bt_leds_cleanup();
 778         return err;
 779 }
 780
 781 static void __exit bt_exit(void)
 782 {
 783         mgmt_exit();
 784
 785         sco_exit();
 786
 787         l2cap_exit();
 788
 789         hci_sock_cleanup();
 790
 791         sock_unregister(PF_BLUETOOTH);
 792
 793         bt_sysfs_cleanup();
 794
 795         bt_leds_cleanup();
 796
 797         debugfs_remove_recursive(bt_debugfs);
 798 }
 799
 800 subsys_initcall(bt_init);
 801 module_exit(bt_exit);
 802
 803 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 804 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 805 MODULE_VERSION(VERSION);
 806 MODULE_LICENSE("GPL");
 807 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);