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