xref: /openbmc/linux/net/bluetooth/af_bluetooth.c (revision e23feb16)
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 	msg->msg_namelen = 0;
225 
226 	skb = skb_recv_datagram(sk, flags, noblock, &err);
227 	if (!skb) {
228 		if (sk->sk_shutdown & RCV_SHUTDOWN)
229 			return 0;
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 	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 			(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
418 
419 	if (sk->sk_shutdown & RCV_SHUTDOWN)
420 		mask |= POLLRDHUP | POLLIN | POLLRDNORM;
421 
422 	if (sk->sk_shutdown == SHUTDOWN_MASK)
423 		mask |= POLLHUP;
424 
425 	if (!skb_queue_empty(&sk->sk_receive_queue))
426 		mask |= POLLIN | POLLRDNORM;
427 
428 	if (sk->sk_state == BT_CLOSED)
429 		mask |= POLLHUP;
430 
431 	if (sk->sk_state == BT_CONNECT ||
432 			sk->sk_state == BT_CONNECT2 ||
433 			sk->sk_state == BT_CONFIG)
434 		return mask;
435 
436 	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
437 		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
438 	else
439 		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
440 
441 	return mask;
442 }
443 EXPORT_SYMBOL(bt_sock_poll);
444 
445 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
446 {
447 	struct sock *sk = sock->sk;
448 	struct sk_buff *skb;
449 	long amount;
450 	int err;
451 
452 	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
453 
454 	switch (cmd) {
455 	case TIOCOUTQ:
456 		if (sk->sk_state == BT_LISTEN)
457 			return -EINVAL;
458 
459 		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
460 		if (amount < 0)
461 			amount = 0;
462 		err = put_user(amount, (int __user *) arg);
463 		break;
464 
465 	case TIOCINQ:
466 		if (sk->sk_state == BT_LISTEN)
467 			return -EINVAL;
468 
469 		lock_sock(sk);
470 		skb = skb_peek(&sk->sk_receive_queue);
471 		amount = skb ? skb->len : 0;
472 		release_sock(sk);
473 		err = put_user(amount, (int __user *) arg);
474 		break;
475 
476 	case SIOCGSTAMP:
477 		err = sock_get_timestamp(sk, (struct timeval __user *) arg);
478 		break;
479 
480 	case SIOCGSTAMPNS:
481 		err = sock_get_timestampns(sk, (struct timespec __user *) arg);
482 		break;
483 
484 	default:
485 		err = -ENOIOCTLCMD;
486 		break;
487 	}
488 
489 	return err;
490 }
491 EXPORT_SYMBOL(bt_sock_ioctl);
492 
493 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
494 {
495 	DECLARE_WAITQUEUE(wait, current);
496 	int err = 0;
497 
498 	BT_DBG("sk %p", sk);
499 
500 	add_wait_queue(sk_sleep(sk), &wait);
501 	set_current_state(TASK_INTERRUPTIBLE);
502 	while (sk->sk_state != state) {
503 		if (!timeo) {
504 			err = -EINPROGRESS;
505 			break;
506 		}
507 
508 		if (signal_pending(current)) {
509 			err = sock_intr_errno(timeo);
510 			break;
511 		}
512 
513 		release_sock(sk);
514 		timeo = schedule_timeout(timeo);
515 		lock_sock(sk);
516 		set_current_state(TASK_INTERRUPTIBLE);
517 
518 		err = sock_error(sk);
519 		if (err)
520 			break;
521 	}
522 	__set_current_state(TASK_RUNNING);
523 	remove_wait_queue(sk_sleep(sk), &wait);
524 	return err;
525 }
526 EXPORT_SYMBOL(bt_sock_wait_state);
527 
528 #ifdef CONFIG_PROC_FS
529 struct bt_seq_state {
530 	struct bt_sock_list *l;
531 };
532 
533 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
534 	__acquires(seq->private->l->lock)
535 {
536 	struct bt_seq_state *s = seq->private;
537 	struct bt_sock_list *l = s->l;
538 
539 	read_lock(&l->lock);
540 	return seq_hlist_start_head(&l->head, *pos);
541 }
542 
543 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
544 {
545 	struct bt_seq_state *s = seq->private;
546 	struct bt_sock_list *l = s->l;
547 
548 	return seq_hlist_next(v, &l->head, pos);
549 }
550 
551 static void bt_seq_stop(struct seq_file *seq, void *v)
552 	__releases(seq->private->l->lock)
553 {
554 	struct bt_seq_state *s = seq->private;
555 	struct bt_sock_list *l = s->l;
556 
557 	read_unlock(&l->lock);
558 }
559 
560 static int bt_seq_show(struct seq_file *seq, void *v)
561 {
562 	struct bt_seq_state *s = seq->private;
563 	struct bt_sock_list *l = s->l;
564 
565 	if (v == SEQ_START_TOKEN) {
566 		seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Src Dst Parent");
567 
568 		if (l->custom_seq_show) {
569 			seq_putc(seq, ' ');
570 			l->custom_seq_show(seq, v);
571 		}
572 
573 		seq_putc(seq, '\n');
574 	} else {
575 		struct sock *sk = sk_entry(v);
576 		struct bt_sock *bt = bt_sk(sk);
577 
578 		seq_printf(seq,
579 			   "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
580 			   sk,
581 			   atomic_read(&sk->sk_refcnt),
582 			   sk_rmem_alloc_get(sk),
583 			   sk_wmem_alloc_get(sk),
584 			   from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
585 			   sock_i_ino(sk),
586 			   &bt->src,
587 			   &bt->dst,
588 			   bt->parent? sock_i_ino(bt->parent): 0LU);
589 
590 		if (l->custom_seq_show) {
591 			seq_putc(seq, ' ');
592 			l->custom_seq_show(seq, v);
593 		}
594 
595 		seq_putc(seq, '\n');
596 	}
597 	return 0;
598 }
599 
600 static struct seq_operations bt_seq_ops = {
601 	.start = bt_seq_start,
602 	.next  = bt_seq_next,
603 	.stop  = bt_seq_stop,
604 	.show  = bt_seq_show,
605 };
606 
607 static int bt_seq_open(struct inode *inode, struct file *file)
608 {
609 	struct bt_sock_list *sk_list;
610 	struct bt_seq_state *s;
611 
612 	sk_list = PDE_DATA(inode);
613 	s = __seq_open_private(file, &bt_seq_ops,
614 			       sizeof(struct bt_seq_state));
615 	if (!s)
616 		return -ENOMEM;
617 
618 	s->l = sk_list;
619 	return 0;
620 }
621 
622 static const struct file_operations bt_fops = {
623 	.open = bt_seq_open,
624 	.read = seq_read,
625 	.llseek = seq_lseek,
626 	.release = seq_release_private
627 };
628 
629 int bt_procfs_init(struct net *net, const char *name,
630 		   struct bt_sock_list* sk_list,
631 		   int (* seq_show)(struct seq_file *, void *))
632 {
633 	sk_list->custom_seq_show = seq_show;
634 
635 	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
636 		return -ENOMEM;
637 	return 0;
638 }
639 
640 void bt_procfs_cleanup(struct net *net, const char *name)
641 {
642 	remove_proc_entry(name, net->proc_net);
643 }
644 #else
645 int bt_procfs_init(struct net *net, const char *name,
646 		   struct bt_sock_list* sk_list,
647 		   int (* seq_show)(struct seq_file *, void *))
648 {
649 	return 0;
650 }
651 
652 void bt_procfs_cleanup(struct net *net, const char *name)
653 {
654 }
655 #endif
656 EXPORT_SYMBOL(bt_procfs_init);
657 EXPORT_SYMBOL(bt_procfs_cleanup);
658 
659 static struct net_proto_family bt_sock_family_ops = {
660 	.owner	= THIS_MODULE,
661 	.family	= PF_BLUETOOTH,
662 	.create	= bt_sock_create,
663 };
664 
665 static int __init bt_init(void)
666 {
667 	int err;
668 
669 	BT_INFO("Core ver %s", VERSION);
670 
671 	err = bt_sysfs_init();
672 	if (err < 0)
673 		return err;
674 
675 	err = sock_register(&bt_sock_family_ops);
676 	if (err < 0) {
677 		bt_sysfs_cleanup();
678 		return err;
679 	}
680 
681 	BT_INFO("HCI device and connection manager initialized");
682 
683 	err = hci_sock_init();
684 	if (err < 0)
685 		goto error;
686 
687 	err = l2cap_init();
688 	if (err < 0)
689 		goto sock_err;
690 
691 	err = sco_init();
692 	if (err < 0) {
693 		l2cap_exit();
694 		goto sock_err;
695 	}
696 
697 	return 0;
698 
699 sock_err:
700 	hci_sock_cleanup();
701 
702 error:
703 	sock_unregister(PF_BLUETOOTH);
704 	bt_sysfs_cleanup();
705 
706 	return err;
707 }
708 
709 static void __exit bt_exit(void)
710 {
711 
712 	sco_exit();
713 
714 	l2cap_exit();
715 
716 	hci_sock_cleanup();
717 
718 	sock_unregister(PF_BLUETOOTH);
719 
720 	bt_sysfs_cleanup();
721 }
722 
723 subsys_initcall(bt_init);
724 module_exit(bt_exit);
725 
726 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
727 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
728 MODULE_VERSION(VERSION);
729 MODULE_LICENSE("GPL");
730 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
731