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