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