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