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