net/bluetooth/af_bluetooth.c

0001 /*
0002    BlueZ - Bluetooth protocol stack for Linux
0003    Copyright (C) 2000-2001 Qualcomm Incorporated
0004
0005    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
0006
0007    This program is free software; you can redistribute it and/or modify
0008    it under the terms of the GNU General Public License version 2 as
0009    published by the Free Software Foundation;
0010
0011    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
0012    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0013    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
0014    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
0015    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
0016    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0017    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0018    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0019
0020    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
0021    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
0022    SOFTWARE IS DISCLAIMED.
0023 */
0024
0025 /* Bluetooth address family and sockets. */
0026
0027 #include <linux/module.h>
0028 #include <linux/debugfs.h>
0029 #include <linux/stringify.h>
0030 #include <linux/sched/signal.h>
0031
0032 #include <asm/ioctls.h>
0033
0034 #include <net/bluetooth/bluetooth.h>
0035 #include <linux/proc_fs.h>
0036
0037 #include "leds.h"
0038 #include "selftest.h"
0039
0040 /* Bluetooth sockets */
0041 #define BT_MAX_PROTO    (BTPROTO_LAST + 1)
0042 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
0043 static DEFINE_RWLOCK(bt_proto_lock);
0044
0045 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
0046 static const char *const bt_key_strings[BT_MAX_PROTO] = {
0047     "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
0048     "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
0049     "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
0050     "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
0051     "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
0052     "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
0053     "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
0054     "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
0055     "sk_lock-AF_BLUETOOTH-BTPROTO_ISO",
0056 };
0057
0058 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
0059 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
0060     "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
0061     "slock-AF_BLUETOOTH-BTPROTO_HCI",
0062     "slock-AF_BLUETOOTH-BTPROTO_SCO",
0063     "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
0064     "slock-AF_BLUETOOTH-BTPROTO_BNEP",
0065     "slock-AF_BLUETOOTH-BTPROTO_CMTP",
0066     "slock-AF_BLUETOOTH-BTPROTO_HIDP",
0067     "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
0068     "slock-AF_BLUETOOTH-BTPROTO_ISO",
0069 };
0070
0071 void bt_sock_reclassify_lock(struct sock *sk, int proto)
0072 {
0073     BUG_ON(!sk);
0074     BUG_ON(!sock_allow_reclassification(sk));
0075
0076     sock_lock_init_class_and_name(sk,
0077                       bt_slock_key_strings[proto], &bt_slock_key[proto],
0078                       bt_key_strings[proto], &bt_lock_key[proto]);
0079 }
0080 EXPORT_SYMBOL(bt_sock_reclassify_lock);
0081
0082 int bt_sock_register(int proto, const struct net_proto_family *ops)
0083 {
0084     int err = 0;
0085
0086     if (proto < 0 || proto >= BT_MAX_PROTO)
0087         return -EINVAL;
0088
0089     write_lock(&bt_proto_lock);
0090
0091     if (bt_proto[proto])
0092         err = -EEXIST;
0093     else
0094         bt_proto[proto] = ops;
0095
0096     write_unlock(&bt_proto_lock);
0097
0098     return err;
0099 }
0100 EXPORT_SYMBOL(bt_sock_register);
0101
0102 void bt_sock_unregister(int proto)
0103 {
0104     if (proto < 0 || proto >= BT_MAX_PROTO)
0105         return;
0106
0107     write_lock(&bt_proto_lock);
0108     bt_proto[proto] = NULL;
0109     write_unlock(&bt_proto_lock);
0110 }
0111 EXPORT_SYMBOL(bt_sock_unregister);
0112
0113 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
0114               int kern)
0115 {
0116     int err;
0117
0118     if (net != &init_net)
0119         return -EAFNOSUPPORT;
0120
0121     if (proto < 0 || proto >= BT_MAX_PROTO)
0122         return -EINVAL;
0123
0124     if (!bt_proto[proto])
0125         request_module("bt-proto-%d", proto);
0126
0127     err = -EPROTONOSUPPORT;
0128
0129     read_lock(&bt_proto_lock);
0130
0131     if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
0132         err = bt_proto[proto]->create(net, sock, proto, kern);
0133         if (!err)
0134             bt_sock_reclassify_lock(sock->sk, proto);
0135         module_put(bt_proto[proto]->owner);
0136     }
0137
0138     read_unlock(&bt_proto_lock);
0139
0140     return err;
0141 }
0142
0143 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
0144 {
0145     write_lock(&l->lock);
0146     sk_add_node(sk, &l->head);
0147     write_unlock(&l->lock);
0148 }
0149 EXPORT_SYMBOL(bt_sock_link);
0150
0151 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
0152 {
0153     write_lock(&l->lock);
0154     sk_del_node_init(sk);
0155     write_unlock(&l->lock);
0156 }
0157 EXPORT_SYMBOL(bt_sock_unlink);
0158
0159 void bt_accept_enqueue(struct sock *parent, struct sock *sk, bool bh)
0160 {
0161     BT_DBG("parent %p, sk %p", parent, sk);
0162
0163     sock_hold(sk);
0164
0165     if (bh)
0166         bh_lock_sock_nested(sk);
0167     else
0168         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
0169
0170     list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
0171     bt_sk(sk)->parent = parent;
0172
0173     if (bh)
0174         bh_unlock_sock(sk);
0175     else
0176         release_sock(sk);
0177
0178     sk_acceptq_added(parent);
0179 }
0180 EXPORT_SYMBOL(bt_accept_enqueue);
0181
0182 /* Calling function must hold the sk lock.
0183  * bt_sk(sk)->parent must be non-NULL meaning sk is in the parent list.
0184  */
0185 void bt_accept_unlink(struct sock *sk)
0186 {
0187     BT_DBG("sk %p state %d", sk, sk->sk_state);
0188
0189     list_del_init(&bt_sk(sk)->accept_q);
0190     sk_acceptq_removed(bt_sk(sk)->parent);
0191     bt_sk(sk)->parent = NULL;
0192     sock_put(sk);
0193 }
0194 EXPORT_SYMBOL(bt_accept_unlink);
0195
0196 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
0197 {
0198     struct bt_sock *s, *n;
0199     struct sock *sk;
0200
0201     BT_DBG("parent %p", parent);
0202
0203 restart:
0204     list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
0205         sk = (struct sock *)s;
0206
0207         /* Prevent early freeing of sk due to unlink and sock_kill */
0208         sock_hold(sk);
0209         lock_sock(sk);
0210
0211         /* Check sk has not already been unlinked via
0212          * bt_accept_unlink() due to serialisation caused by sk locking
0213          */
0214         if (!bt_sk(sk)->parent) {
0215             BT_DBG("sk %p, already unlinked", sk);
0216             release_sock(sk);
0217             sock_put(sk);
0218
0219             /* Restart the loop as sk is no longer in the list
0220              * and also avoid a potential infinite loop because
0221              * list_for_each_entry_safe() is not thread safe.
0222              */
0223             goto restart;
0224         }
0225
0226         /* sk is safely in the parent list so reduce reference count */
0227         sock_put(sk);
0228
0229         /* FIXME: Is this check still needed */
0230         if (sk->sk_state == BT_CLOSED) {
0231             bt_accept_unlink(sk);
0232             release_sock(sk);
0233             continue;
0234         }
0235
0236         if (sk->sk_state == BT_CONNECTED || !newsock ||
0237             test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
0238             bt_accept_unlink(sk);
0239             if (newsock)
0240                 sock_graft(sk, newsock);
0241
0242             release_sock(sk);
0243             return sk;
0244         }
0245
0246         release_sock(sk);
0247     }
0248
0249     return NULL;
0250 }
0251 EXPORT_SYMBOL(bt_accept_dequeue);
0252
0253 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
0254             int flags)
0255 {
0256     struct sock *sk = sock->sk;
0257     struct sk_buff *skb;
0258     size_t copied;
0259     size_t skblen;
0260     int err;
0261
0262     BT_DBG("sock %p sk %p len %zu", sock, sk, len);
0263
0264     if (flags & MSG_OOB)
0265         return -EOPNOTSUPP;
0266
0267     skb = skb_recv_datagram(sk, flags, &err);
0268     if (!skb) {
0269         if (sk->sk_shutdown & RCV_SHUTDOWN)
0270             return 0;
0271
0272         return err;
0273     }
0274
0275     skblen = skb->len;
0276     copied = skb->len;
0277     if (len < copied) {
0278         msg->msg_flags |= MSG_TRUNC;
0279         copied = len;
0280     }
0281
0282     skb_reset_transport_header(skb);
0283     err = skb_copy_datagram_msg(skb, 0, msg, copied);
0284     if (err == 0) {
0285         sock_recv_cmsgs(msg, sk, skb);
0286
0287         if (msg->msg_name && bt_sk(sk)->skb_msg_name)
0288             bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
0289                         &msg->msg_namelen);
0290
0291         if (bt_sk(sk)->skb_put_cmsg)
0292             bt_sk(sk)->skb_put_cmsg(skb, msg, sk);
0293     }
0294
0295     skb_free_datagram(sk, skb);
0296
0297     if (flags & MSG_TRUNC)
0298         copied = skblen;
0299
0300     return err ? : copied;
0301 }
0302 EXPORT_SYMBOL(bt_sock_recvmsg);
0303
0304 static long bt_sock_data_wait(struct sock *sk, long timeo)
0305 {
0306     DECLARE_WAITQUEUE(wait, current);
0307
0308     add_wait_queue(sk_sleep(sk), &wait);
0309     for (;;) {
0310         set_current_state(TASK_INTERRUPTIBLE);
0311
0312         if (!skb_queue_empty(&sk->sk_receive_queue))
0313             break;
0314
0315         if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
0316             break;
0317
0318         if (signal_pending(current) || !timeo)
0319             break;
0320
0321         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
0322         release_sock(sk);
0323         timeo = schedule_timeout(timeo);
0324         lock_sock(sk);
0325         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
0326     }
0327
0328     __set_current_state(TASK_RUNNING);
0329     remove_wait_queue(sk_sleep(sk), &wait);
0330     return timeo;
0331 }
0332
0333 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
0334                size_t size, int flags)
0335 {
0336     struct sock *sk = sock->sk;
0337     int err = 0;
0338     size_t target, copied = 0;
0339     long timeo;
0340
0341     if (flags & MSG_OOB)
0342         return -EOPNOTSUPP;
0343
0344     BT_DBG("sk %p size %zu", sk, size);
0345
0346     lock_sock(sk);
0347
0348     target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
0349     timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
0350
0351     do {
0352         struct sk_buff *skb;
0353         int chunk;
0354
0355         skb = skb_dequeue(&sk->sk_receive_queue);
0356         if (!skb) {
0357             if (copied >= target)
0358                 break;
0359
0360             err = sock_error(sk);
0361             if (err)
0362                 break;
0363             if (sk->sk_shutdown & RCV_SHUTDOWN)
0364                 break;
0365
0366             err = -EAGAIN;
0367             if (!timeo)
0368                 break;
0369
0370             timeo = bt_sock_data_wait(sk, timeo);
0371
0372             if (signal_pending(current)) {
0373                 err = sock_intr_errno(timeo);
0374                 goto out;
0375             }
0376             continue;
0377         }
0378
0379         chunk = min_t(unsigned int, skb->len, size);
0380         if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
0381             skb_queue_head(&sk->sk_receive_queue, skb);
0382             if (!copied)
0383                 copied = -EFAULT;
0384             break;
0385         }
0386         copied += chunk;
0387         size   -= chunk;
0388
0389         sock_recv_cmsgs(msg, sk, skb);
0390
0391         if (!(flags & MSG_PEEK)) {
0392             int skb_len = skb_headlen(skb);
0393
0394             if (chunk <= skb_len) {
0395                 __skb_pull(skb, chunk);
0396             } else {
0397                 struct sk_buff *frag;
0398
0399                 __skb_pull(skb, skb_len);
0400                 chunk -= skb_len;
0401
0402                 skb_walk_frags(skb, frag) {
0403                     if (chunk <= frag->len) {
0404                         /* Pulling partial data */
0405                         skb->len -= chunk;
0406                         skb->data_len -= chunk;
0407                         __skb_pull(frag, chunk);
0408                         break;
0409                     } else if (frag->len) {
0410                         /* Pulling all frag data */
0411                         chunk -= frag->len;
0412                         skb->len -= frag->len;
0413                         skb->data_len -= frag->len;
0414                         __skb_pull(frag, frag->len);
0415                     }
0416                 }
0417             }
0418
0419             if (skb->len) {
0420                 skb_queue_head(&sk->sk_receive_queue, skb);
0421                 break;
0422             }
0423             kfree_skb(skb);
0424
0425         } else {
0426             /* put message back and return */
0427             skb_queue_head(&sk->sk_receive_queue, skb);
0428             break;
0429         }
0430     } while (size);
0431
0432 out:
0433     release_sock(sk);
0434     return copied ? : err;
0435 }
0436 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
0437
0438 static inline __poll_t bt_accept_poll(struct sock *parent)
0439 {
0440     struct bt_sock *s, *n;
0441     struct sock *sk;
0442
0443     list_for_each_entry_safe(s, n, &bt_sk(parent)->accept_q, accept_q) {
0444         sk = (struct sock *)s;
0445         if (sk->sk_state == BT_CONNECTED ||
0446             (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
0447              sk->sk_state == BT_CONNECT2))
0448             return EPOLLIN | EPOLLRDNORM;
0449     }
0450
0451     return 0;
0452 }
0453
0454 __poll_t bt_sock_poll(struct file *file, struct socket *sock,
0455               poll_table *wait)
0456 {
0457     struct sock *sk = sock->sk;
0458     __poll_t mask = 0;
0459
0460     poll_wait(file, sk_sleep(sk), wait);
0461
0462     if (sk->sk_state == BT_LISTEN)
0463         return bt_accept_poll(sk);
0464
0465     if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
0466         mask |= EPOLLERR |
0467             (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? EPOLLPRI : 0);
0468
0469     if (sk->sk_shutdown & RCV_SHUTDOWN)
0470         mask |= EPOLLRDHUP | EPOLLIN | EPOLLRDNORM;
0471
0472     if (sk->sk_shutdown == SHUTDOWN_MASK)
0473         mask |= EPOLLHUP;
0474
0475     if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
0476         mask |= EPOLLIN | EPOLLRDNORM;
0477
0478     if (sk->sk_state == BT_CLOSED)
0479         mask |= EPOLLHUP;
0480
0481     if (sk->sk_state == BT_CONNECT ||
0482         sk->sk_state == BT_CONNECT2 ||
0483         sk->sk_state == BT_CONFIG)
0484         return mask;
0485
0486     if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
0487         mask |= EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND;
0488     else
0489         sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
0490
0491     return mask;
0492 }
0493 EXPORT_SYMBOL(bt_sock_poll);
0494
0495 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
0496 {
0497     struct sock *sk = sock->sk;
0498     struct sk_buff *skb;
0499     long amount;
0500     int err;
0501
0502     BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
0503
0504     switch (cmd) {
0505     case TIOCOUTQ:
0506         if (sk->sk_state == BT_LISTEN)
0507             return -EINVAL;
0508
0509         amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
0510         if (amount < 0)
0511             amount = 0;
0512         err = put_user(amount, (int __user *)arg);
0513         break;
0514
0515     case TIOCINQ:
0516         if (sk->sk_state == BT_LISTEN)
0517             return -EINVAL;
0518
0519         lock_sock(sk);
0520         skb = skb_peek(&sk->sk_receive_queue);
0521         amount = skb ? skb->len : 0;
0522         release_sock(sk);
0523         err = put_user(amount, (int __user *)arg);
0524         break;
0525
0526     default:
0527         err = -ENOIOCTLCMD;
0528         break;
0529     }
0530
0531     return err;
0532 }
0533 EXPORT_SYMBOL(bt_sock_ioctl);
0534
0535 /* This function expects the sk lock to be held when called */
0536 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
0537 {
0538     DECLARE_WAITQUEUE(wait, current);
0539     int err = 0;
0540
0541     BT_DBG("sk %p", sk);
0542
0543     add_wait_queue(sk_sleep(sk), &wait);
0544     set_current_state(TASK_INTERRUPTIBLE);
0545     while (sk->sk_state != state) {
0546         if (!timeo) {
0547             err = -EINPROGRESS;
0548             break;
0549         }
0550
0551         if (signal_pending(current)) {
0552             err = sock_intr_errno(timeo);
0553             break;
0554         }
0555
0556         release_sock(sk);
0557         timeo = schedule_timeout(timeo);
0558         lock_sock(sk);
0559         set_current_state(TASK_INTERRUPTIBLE);
0560
0561         err = sock_error(sk);
0562         if (err)
0563             break;
0564     }
0565     __set_current_state(TASK_RUNNING);
0566     remove_wait_queue(sk_sleep(sk), &wait);
0567     return err;
0568 }
0569 EXPORT_SYMBOL(bt_sock_wait_state);
0570
0571 /* This function expects the sk lock to be held when called */
0572 int bt_sock_wait_ready(struct sock *sk, unsigned int msg_flags)
0573 {
0574     DECLARE_WAITQUEUE(wait, current);
0575     unsigned long timeo;
0576     int err = 0;
0577
0578     BT_DBG("sk %p", sk);
0579
0580     timeo = sock_sndtimeo(sk, !!(msg_flags & MSG_DONTWAIT));
0581
0582     add_wait_queue(sk_sleep(sk), &wait);
0583     set_current_state(TASK_INTERRUPTIBLE);
0584     while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
0585         if (!timeo) {
0586             err = -EAGAIN;
0587             break;
0588         }
0589
0590         if (signal_pending(current)) {
0591             err = sock_intr_errno(timeo);
0592             break;
0593         }
0594
0595         release_sock(sk);
0596         timeo = schedule_timeout(timeo);
0597         lock_sock(sk);
0598         set_current_state(TASK_INTERRUPTIBLE);
0599
0600         err = sock_error(sk);
0601         if (err)
0602             break;
0603     }
0604     __set_current_state(TASK_RUNNING);
0605     remove_wait_queue(sk_sleep(sk), &wait);
0606
0607     return err;
0608 }
0609 EXPORT_SYMBOL(bt_sock_wait_ready);
0610
0611 #ifdef CONFIG_PROC_FS
0612 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
0613     __acquires(seq->private->l->lock)
0614 {
0615     struct bt_sock_list *l = pde_data(file_inode(seq->file));
0616
0617     read_lock(&l->lock);
0618     return seq_hlist_start_head(&l->head, *pos);
0619 }
0620
0621 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
0622 {
0623     struct bt_sock_list *l = pde_data(file_inode(seq->file));
0624
0625     return seq_hlist_next(v, &l->head, pos);
0626 }
0627
0628 static void bt_seq_stop(struct seq_file *seq, void *v)
0629     __releases(seq->private->l->lock)
0630 {
0631     struct bt_sock_list *l = pde_data(file_inode(seq->file));
0632
0633     read_unlock(&l->lock);
0634 }
0635
0636 static int bt_seq_show(struct seq_file *seq, void *v)
0637 {
0638     struct bt_sock_list *l = pde_data(file_inode(seq->file));
0639
0640     if (v == SEQ_START_TOKEN) {
0641         seq_puts(seq, "sk               RefCnt Rmem   Wmem   User   Inode  Parent");
0642
0643         if (l->custom_seq_show) {
0644             seq_putc(seq, ' ');
0645             l->custom_seq_show(seq, v);
0646         }
0647
0648         seq_putc(seq, '\n');
0649     } else {
0650         struct sock *sk = sk_entry(v);
0651         struct bt_sock *bt = bt_sk(sk);
0652
0653         seq_printf(seq,
0654                "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
0655                sk,
0656                refcount_read(&sk->sk_refcnt),
0657                sk_rmem_alloc_get(sk),
0658                sk_wmem_alloc_get(sk),
0659                from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
0660                sock_i_ino(sk),
0661                bt->parent ? sock_i_ino(bt->parent) : 0LU);
0662
0663         if (l->custom_seq_show) {
0664             seq_putc(seq, ' ');
0665             l->custom_seq_show(seq, v);
0666         }
0667
0668         seq_putc(seq, '\n');
0669     }
0670     return 0;
0671 }
0672
0673 static const struct seq_operations bt_seq_ops = {
0674     .start = bt_seq_start,
0675     .next  = bt_seq_next,
0676     .stop  = bt_seq_stop,
0677     .show  = bt_seq_show,
0678 };
0679
0680 int bt_procfs_init(struct net *net, const char *name,
0681            struct bt_sock_list *sk_list,
0682            int (*seq_show)(struct seq_file *, void *))
0683 {
0684     sk_list->custom_seq_show = seq_show;
0685
0686     if (!proc_create_seq_data(name, 0, net->proc_net, &bt_seq_ops, sk_list))
0687         return -ENOMEM;
0688     return 0;
0689 }
0690
0691 void bt_procfs_cleanup(struct net *net, const char *name)
0692 {
0693     remove_proc_entry(name, net->proc_net);
0694 }
0695 #else
0696 int bt_procfs_init(struct net *net, const char *name,
0697            struct bt_sock_list *sk_list,
0698            int (*seq_show)(struct seq_file *, void *))
0699 {
0700     return 0;
0701 }
0702
0703 void bt_procfs_cleanup(struct net *net, const char *name)
0704 {
0705 }
0706 #endif
0707 EXPORT_SYMBOL(bt_procfs_init);
0708 EXPORT_SYMBOL(bt_procfs_cleanup);
0709
0710 static const struct net_proto_family bt_sock_family_ops = {
0711     .owner  = THIS_MODULE,
0712     .family = PF_BLUETOOTH,
0713     .create = bt_sock_create,
0714 };
0715
0716 struct dentry *bt_debugfs;
0717 EXPORT_SYMBOL_GPL(bt_debugfs);
0718
0719 #define VERSION __stringify(BT_SUBSYS_VERSION) "." \
0720         __stringify(BT_SUBSYS_REVISION)
0721
0722 static int __init bt_init(void)
0723 {
0724     int err;
0725
0726     sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
0727
0728     BT_INFO("Core ver %s", VERSION);
0729
0730     err = bt_selftest();
0731     if (err < 0)
0732         return err;
0733
0734     bt_debugfs = debugfs_create_dir("bluetooth", NULL);
0735
0736     bt_leds_init();
0737
0738     err = bt_sysfs_init();
0739     if (err < 0)
0740         return err;
0741
0742     err = sock_register(&bt_sock_family_ops);
0743     if (err)
0744         goto cleanup_sysfs;
0745
0746     BT_INFO("HCI device and connection manager initialized");
0747
0748     err = hci_sock_init();
0749     if (err)
0750         goto unregister_socket;
0751
0752     err = l2cap_init();
0753     if (err)
0754         goto cleanup_socket;
0755
0756     err = sco_init();
0757     if (err)
0758         goto cleanup_cap;
0759
0760     err = mgmt_init();
0761     if (err)
0762         goto cleanup_sco;
0763
0764     return 0;
0765
0766 cleanup_sco:
0767     sco_exit();
0768 cleanup_cap:
0769     l2cap_exit();
0770 cleanup_socket:
0771     hci_sock_cleanup();
0772 unregister_socket:
0773     sock_unregister(PF_BLUETOOTH);
0774 cleanup_sysfs:
0775     bt_sysfs_cleanup();
0776     return err;
0777 }
0778
0779 static void __exit bt_exit(void)
0780 {
0781     mgmt_exit();
0782
0783     sco_exit();
0784
0785     l2cap_exit();
0786
0787     hci_sock_cleanup();
0788
0789     sock_unregister(PF_BLUETOOTH);
0790
0791     bt_sysfs_cleanup();
0792
0793     bt_leds_cleanup();
0794
0795     debugfs_remove_recursive(bt_debugfs);
0796 }
0797
0798 subsys_initcall(bt_init);
0799 module_exit(bt_exit);
0800
0801 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
0802 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
0803 MODULE_VERSION(VERSION);
0804 MODULE_LICENSE("GPL");
0805 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);