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