[deliverable/linux.git] / net / bluetooth / af_bluetooth.c

/*
   BlueZ - Bluetooth protocol stack for Linux
   Copyright (C) 2000-2001 Qualcomm Incorporated

   Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2 as
   published by the Free Software Foundation;

   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
   IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
   CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

   ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
   COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
   SOFTWARE IS DISCLAIMED.
*/

/* Bluetooth address family and sockets. */

#include <linux/module.h>
#include <asm/ioctls.h>

#include <net/bluetooth/bluetooth.h>
#include <linux/proc_fs.h>

#define VERSION "2.16"

/* Bluetooth sockets */
#define BT_MAX_PROTO	8
static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
static DEFINE_RWLOCK(bt_proto_lock);

static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
static const char *const bt_key_strings[BT_MAX_PROTO] = {
	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
	"slock-AF_BLUETOOTH-BTPROTO_HCI",
	"slock-AF_BLUETOOTH-BTPROTO_SCO",
	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
};

void bt_sock_reclassify_lock(struct sock *sk, int proto)
{
	BUG_ON(!sk);
	BUG_ON(sock_owned_by_user(sk));

	sock_lock_init_class_and_name(sk,
			bt_slock_key_strings[proto], &bt_slock_key[proto],
				bt_key_strings[proto], &bt_lock_key[proto]);
}
EXPORT_SYMBOL(bt_sock_reclassify_lock);

int bt_sock_register(int proto, const struct net_proto_family *ops)
{
	int err = 0;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	write_lock(&bt_proto_lock);

	if (bt_proto[proto])
		err = -EEXIST;
	else
		bt_proto[proto] = ops;

	write_unlock(&bt_proto_lock);

	return err;
}
EXPORT_SYMBOL(bt_sock_register);

void bt_sock_unregister(int proto)
{
	if (proto < 0 || proto >= BT_MAX_PROTO)
		return;

	write_lock(&bt_proto_lock);
	bt_proto[proto] = NULL;
	write_unlock(&bt_proto_lock);
}
EXPORT_SYMBOL(bt_sock_unregister);

static int bt_sock_create(struct net *net, struct socket *sock, int proto,
			  int kern)
{
	int err;

	if (net != &init_net)
		return -EAFNOSUPPORT;

	if (proto < 0 || proto >= BT_MAX_PROTO)
		return -EINVAL;

	if (!bt_proto[proto])
		request_module("bt-proto-%d", proto);

	err = -EPROTONOSUPPORT;

	read_lock(&bt_proto_lock);

	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
		err = bt_proto[proto]->create(net, sock, proto, kern);
		if (!err)
			bt_sock_reclassify_lock(sock->sk, proto);
		module_put(bt_proto[proto]->owner);
	}

	read_unlock(&bt_proto_lock);

	return err;
}

void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
{
	write_lock(&l->lock);
	sk_add_node(sk, &l->head);
	write_unlock(&l->lock);
}
EXPORT_SYMBOL(bt_sock_link);

void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
{
	write_lock(&l->lock);
	sk_del_node_init(sk);
	write_unlock(&l->lock);
}
EXPORT_SYMBOL(bt_sock_unlink);

void bt_accept_enqueue(struct sock *parent, struct sock *sk)
{
	BT_DBG("parent %p, sk %p", parent, sk);

	sock_hold(sk);
	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
	bt_sk(sk)->parent = parent;
	parent->sk_ack_backlog++;
}
EXPORT_SYMBOL(bt_accept_enqueue);

void bt_accept_unlink(struct sock *sk)
{
	BT_DBG("sk %p state %d", sk, sk->sk_state);

	list_del_init(&bt_sk(sk)->accept_q);
	bt_sk(sk)->parent->sk_ack_backlog--;
	bt_sk(sk)->parent = NULL;
	sock_put(sk);
}
EXPORT_SYMBOL(bt_accept_unlink);

struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
{
	struct list_head *p, *n;
	struct sock *sk;

	BT_DBG("parent %p", parent);

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);

		lock_sock(sk);

		/* FIXME: Is this check still needed */
		if (sk->sk_state == BT_CLOSED) {
			release_sock(sk);
			bt_accept_unlink(sk);
			continue;
		}

		if (sk->sk_state == BT_CONNECTED || !newsock ||
		    test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
			bt_accept_unlink(sk);
			if (newsock)
				sock_graft(sk, newsock);

			release_sock(sk);
			return sk;
		}

		release_sock(sk);
	}

	return NULL;
}
EXPORT_SYMBOL(bt_accept_dequeue);

int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
				struct msghdr *msg, size_t len, int flags)
{
	int noblock = flags & MSG_DONTWAIT;
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	size_t copied;
	int err;

	BT_DBG("sock %p sk %p len %zu", sock, sk, len);

	if (flags & (MSG_OOB))
		return -EOPNOTSUPP;

	msg->msg_namelen = 0;

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb) {
		if (sk->sk_shutdown & RCV_SHUTDOWN)
			return 0;
		return err;
	}

	copied = skb->len;
	if (len < copied) {
		msg->msg_flags |= MSG_TRUNC;
		copied = len;
	}

	skb_reset_transport_header(skb);
	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
	if (err == 0)
		sock_recv_ts_and_drops(msg, sk, skb);

	skb_free_datagram(sk, skb);

	return err ? : copied;
}
EXPORT_SYMBOL(bt_sock_recvmsg);

static long bt_sock_data_wait(struct sock *sk, long timeo)
{
	DECLARE_WAITQUEUE(wait, current);

	add_wait_queue(sk_sleep(sk), &wait);
	for (;;) {
		set_current_state(TASK_INTERRUPTIBLE);

		if (!skb_queue_empty(&sk->sk_receive_queue))
			break;

		if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
			break;

		if (signal_pending(current) || !timeo)
			break;

		set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	}

	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return timeo;
}

int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
			       struct msghdr *msg, size_t size, int flags)
{
	struct sock *sk = sock->sk;
	int err = 0;
	size_t target, copied = 0;
	long timeo;

	if (flags & MSG_OOB)
		return -EOPNOTSUPP;

	msg->msg_namelen = 0;

	BT_DBG("sk %p size %zu", sk, size);

	lock_sock(sk);

	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);

	do {
		struct sk_buff *skb;
		int chunk;

		skb = skb_dequeue(&sk->sk_receive_queue);
		if (!skb) {
			if (copied >= target)
				break;

			err = sock_error(sk);
			if (err)
				break;
			if (sk->sk_shutdown & RCV_SHUTDOWN)
				break;

			err = -EAGAIN;
			if (!timeo)
				break;

			timeo = bt_sock_data_wait(sk, timeo);

			if (signal_pending(current)) {
				err = sock_intr_errno(timeo);
				goto out;
			}
			continue;
		}

		chunk = min_t(unsigned int, skb->len, size);
		if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
			skb_queue_head(&sk->sk_receive_queue, skb);
			if (!copied)
				copied = -EFAULT;
			break;
		}
		copied += chunk;
		size   -= chunk;

		sock_recv_ts_and_drops(msg, sk, skb);

		if (!(flags & MSG_PEEK)) {
			int skb_len = skb_headlen(skb);

			if (chunk <= skb_len) {
				__skb_pull(skb, chunk);
			} else {
				struct sk_buff *frag;

				__skb_pull(skb, skb_len);
				chunk -= skb_len;

				skb_walk_frags(skb, frag) {
					if (chunk <= frag->len) {
						/* Pulling partial data */
						skb->len -= chunk;
						skb->data_len -= chunk;
						__skb_pull(frag, chunk);
						break;
					} else if (frag->len) {
						/* Pulling all frag data */
						chunk -= frag->len;
						skb->len -= frag->len;
						skb->data_len -= frag->len;
						__skb_pull(frag, frag->len);
					}
				}
			}

			if (skb->len) {
				skb_queue_head(&sk->sk_receive_queue, skb);
				break;
			}
			kfree_skb(skb);

		} else {
			/* put message back and return */
			skb_queue_head(&sk->sk_receive_queue, skb);
			break;
		}
	} while (size);

out:
	release_sock(sk);
	return copied ? : err;
}
EXPORT_SYMBOL(bt_sock_stream_recvmsg);

static inline unsigned int bt_accept_poll(struct sock *parent)
{
	struct list_head *p, *n;
	struct sock *sk;

	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
		if (sk->sk_state == BT_CONNECTED ||
		    (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
		     sk->sk_state == BT_CONNECT2))
			return POLLIN | POLLRDNORM;
	}

	return 0;
}

unsigned int bt_sock_poll(struct file *file, struct socket *sock,
			  poll_table *wait)
{
	struct sock *sk = sock->sk;
	unsigned int mask = 0;

	BT_DBG("sock %p, sk %p", sock, sk);

	poll_wait(file, sk_sleep(sk), wait);

	if (sk->sk_state == BT_LISTEN)
		return bt_accept_poll(sk);

	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
		mask |= POLLERR |
			(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);

	if (sk->sk_shutdown & RCV_SHUTDOWN)
		mask |= POLLRDHUP | POLLIN | POLLRDNORM;

	if (sk->sk_shutdown == SHUTDOWN_MASK)
		mask |= POLLHUP;

	if (!skb_queue_empty(&sk->sk_receive_queue))
		mask |= POLLIN | POLLRDNORM;

	if (sk->sk_state == BT_CLOSED)
		mask |= POLLHUP;

	if (sk->sk_state == BT_CONNECT ||
			sk->sk_state == BT_CONNECT2 ||
			sk->sk_state == BT_CONFIG)
		return mask;

	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
	else
		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);

	return mask;
}
EXPORT_SYMBOL(bt_sock_poll);

int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
{
	struct sock *sk = sock->sk;
	struct sk_buff *skb;
	long amount;
	int err;

	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);

	switch (cmd) {
	case TIOCOUTQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
		if (amount < 0)
			amount = 0;
		err = put_user(amount, (int __user *) arg);
		break;

	case TIOCINQ:
		if (sk->sk_state == BT_LISTEN)
			return -EINVAL;

		lock_sock(sk);
		skb = skb_peek(&sk->sk_receive_queue);
		amount = skb ? skb->len : 0;
		release_sock(sk);
		err = put_user(amount, (int __user *) arg);
		break;

	case SIOCGSTAMP:
		err = sock_get_timestamp(sk, (struct timeval __user *) arg);
		break;

	case SIOCGSTAMPNS:
		err = sock_get_timestampns(sk, (struct timespec __user *) arg);
		break;

	default:
		err = -ENOIOCTLCMD;
		break;
	}

	return err;
}
EXPORT_SYMBOL(bt_sock_ioctl);

int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
{
	DECLARE_WAITQUEUE(wait, current);
	int err = 0;

	BT_DBG("sk %p", sk);

	add_wait_queue(sk_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (sk->sk_state != state) {
		if (!timeo) {
			err = -EINPROGRESS;
			break;
		}

		if (signal_pending(current)) {
			err = sock_intr_errno(timeo);
			break;
		}

		release_sock(sk);
		timeo = schedule_timeout(timeo);
		lock_sock(sk);
		set_current_state(TASK_INTERRUPTIBLE);

		err = sock_error(sk);
		if (err)
			break;
	}
	__set_current_state(TASK_RUNNING);
	remove_wait_queue(sk_sleep(sk), &wait);
	return err;
}
EXPORT_SYMBOL(bt_sock_wait_state);

#ifdef CONFIG_PROC_FS
struct bt_seq_state {
	struct bt_sock_list *l;
};

static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
	__acquires(seq->private->l->lock)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	read_lock(&l->lock);
	return seq_hlist_start_head(&l->head, *pos);
}

static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	return seq_hlist_next(v, &l->head, pos);
}

static void bt_seq_stop(struct seq_file *seq, void *v)
	__releases(seq->private->l->lock)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	read_unlock(&l->lock);
}

static int bt_seq_show(struct seq_file *seq, void *v)
{
	struct bt_seq_state *s = seq->private;
	struct bt_sock_list *l = s->l;

	if (v == SEQ_START_TOKEN) {
		seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Src Dst Parent");

		if (l->custom_seq_show) {
			seq_putc(seq, ' ');
			l->custom_seq_show(seq, v);
		}

		seq_putc(seq, '\n');
	} else {
		struct sock *sk = sk_entry(v);
		struct bt_sock *bt = bt_sk(sk);

		seq_printf(seq,
			   "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
			   sk,
			   atomic_read(&sk->sk_refcnt),
			   sk_rmem_alloc_get(sk),
			   sk_wmem_alloc_get(sk),
			   from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
			   sock_i_ino(sk),
			   &bt->src,
			   &bt->dst,
			   bt->parent? sock_i_ino(bt->parent): 0LU);

		if (l->custom_seq_show) {
			seq_putc(seq, ' ');
			l->custom_seq_show(seq, v);
		}

		seq_putc(seq, '\n');
	}
	return 0;
}

static struct seq_operations bt_seq_ops = {
	.start = bt_seq_start,
	.next  = bt_seq_next,
	.stop  = bt_seq_stop,
	.show  = bt_seq_show,
};

static int bt_seq_open(struct inode *inode, struct file *file)
{
	struct bt_sock_list *sk_list;
	struct bt_seq_state *s;

	sk_list = PDE_DATA(inode);
	s = __seq_open_private(file, &bt_seq_ops,
			       sizeof(struct bt_seq_state));
	if (!s)
		return -ENOMEM;

	s->l = sk_list;
	return 0;
}

static const struct file_operations bt_fops = {
	.open = bt_seq_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release_private
};

int bt_procfs_init(struct net *net, const char *name,
		   struct bt_sock_list* sk_list,
		   int (* seq_show)(struct seq_file *, void *))
{
	sk_list->custom_seq_show = seq_show;

	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
		return -ENOMEM;
	return 0;
}

void bt_procfs_cleanup(struct net *net, const char *name)
{
	remove_proc_entry(name, net->proc_net);
}
#else
int bt_procfs_init(struct net *net, const char *name,
		   struct bt_sock_list* sk_list,
		   int (* seq_show)(struct seq_file *, void *))
{
	return 0;
}

void bt_procfs_cleanup(struct net *net, const char *name)
{
}
#endif
EXPORT_SYMBOL(bt_procfs_init);
EXPORT_SYMBOL(bt_procfs_cleanup);

static struct net_proto_family bt_sock_family_ops = {
	.owner	= THIS_MODULE,
	.family	= PF_BLUETOOTH,
	.create	= bt_sock_create,
};

static int __init bt_init(void)
{
	int err;

	BT_INFO("Core ver %s", VERSION);

	err = bt_sysfs_init();
	if (err < 0)
		return err;

	err = sock_register(&bt_sock_family_ops);
	if (err < 0) {
		bt_sysfs_cleanup();
		return err;
	}

	BT_INFO("HCI device and connection manager initialized");

	err = hci_sock_init();
	if (err < 0)
		goto error;

	err = l2cap_init();
	if (err < 0)
		goto sock_err;

	err = sco_init();
	if (err < 0) {
		l2cap_exit();
		goto sock_err;
	}

	return 0;

sock_err:
	hci_sock_cleanup();

error:
	sock_unregister(PF_BLUETOOTH);
	bt_sysfs_cleanup();

	return err;
}

static void __exit bt_exit(void)
{

	sco_exit();

	l2cap_exit();

	hci_sock_cleanup();

	sock_unregister(PF_BLUETOOTH);

	bt_sysfs_cleanup();
}

subsys_initcall(bt_init);
module_exit(bt_exit);

MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
MODULE_VERSION(VERSION);
MODULE_LICENSE("GPL");
MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	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
8e87d142 YH	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
1da177e4 LT	18	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	19
8e87d142 YH	20	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	21	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	22	SOFTWARE IS DISCLAIMED.
	23	*/
	24
	25	/* Bluetooth address family and sockets. */
	26
1da177e4	27	#include <linux/module.h>
3241ad82	28	#include <asm/ioctls.h>
1da177e4 LT	29
1da177e4 LT	30	#include <net/bluetooth/bluetooth.h>
256a06c8	31	#include <linux/proc_fs.h>
1da177e4	32
64274518	33	#define VERSION "2.16"
1da177e4 LT	34
	35	/* Bluetooth sockets */
	36	#define BT_MAX_PROTO 8
ec1b4cf7	37	static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2	38	static DEFINE_RWLOCK(bt_proto_lock);
68845cb2	39
68845cb2	40	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc	41	static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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
db7aa1c2	52	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc	53	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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	};
db7aa1c2	63
b5a30dda	64	void bt_sock_reclassify_lock(struct sock *sk, int proto)
db7aa1c2	65	{
b5a30dda	66	BUG_ON(!sk);
db7aa1c2 MH	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	}
b5a30dda	73	EXPORT_SYMBOL(bt_sock_reclassify_lock);
1da177e4	74
ec1b4cf7	75	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	76	{
74da626a MH	77	int err = 0;
74da626a MH	78
1da177e4 LT	79	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	80	return -EINVAL;
	81
74da626a MH	82	write_lock(&bt_proto_lock);
74da626a MH	83
1da177e4	84	if (bt_proto[proto])
74da626a MH	85	err = -EEXIST;
	86	else
	87	bt_proto[proto] = ops;
	88
	89	write_unlock(&bt_proto_lock);
1da177e4	90
74da626a	91	return err;
1da177e4 LT	92	}
	93	EXPORT_SYMBOL(bt_sock_register);
	94
be9f97f0	95	void bt_sock_unregister(int proto)
1da177e4 LT	96	{
1da177e4 LT	97	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
be9f97f0	98	return;
1da177e4	99
74da626a	100	write_lock(&bt_proto_lock);
be9f97f0	101	bt_proto[proto] = NULL;
74da626a	102	write_unlock(&bt_proto_lock);
1da177e4 LT	103	}
	104	EXPORT_SYMBOL(bt_sock_unregister);
	105
3f378b68 EP	106	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	107	int kern)
1da177e4	108	{
74da626a	109	int err;
1da177e4	110
1b8d7ae4 EB	111	if (net != &init_net)
	112	return -EAFNOSUPPORT;
	113
1da177e4 LT	114	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	115	return -EINVAL;
	116
95a5afca	117	if (!bt_proto[proto])
1da177e4	118	request_module("bt-proto-%d", proto);
74da626a	119
1da177e4	120	err = -EPROTONOSUPPORT;
74da626a MH	121
	122	read_lock(&bt_proto_lock);
	123
1da177e4	124	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	125	err = bt_proto[proto]->create(net, sock, proto, kern);
b5a30dda OP	126	if (!err)
b5a30dda OP	127	bt_sock_reclassify_lock(sock->sk, proto);
1da177e4 LT	128	module_put(bt_proto[proto]->owner);
1da177e4 LT	129	}
74da626a MH	130
	131	read_unlock(&bt_proto_lock);
	132
8e87d142	133	return err;
1da177e4 LT	134	}
	135
	136	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	137	{
94f5bfb8	138	write_lock(&l->lock);
1da177e4	139	sk_add_node(sk, &l->head);
94f5bfb8	140	write_unlock(&l->lock);
1da177e4 LT	141	}
	142	EXPORT_SYMBOL(bt_sock_link);
	143
	144	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	145	{
94f5bfb8	146	write_lock(&l->lock);
1da177e4	147	sk_del_node_init(sk);
94f5bfb8	148	write_unlock(&l->lock);
1da177e4 LT	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
8a154a8f	184	lock_sock(sk);
1da177e4 LT	185
	186	/* FIXME: Is this check still needed */
	187	if (sk->sk_state == BT_CLOSED) {
8a154a8f	188	release_sock(sk);
1da177e4 LT	189	bt_accept_unlink(sk);
	190	continue;
	191	}
	192
c4f912e1	193	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
d060991f	194	test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
1da177e4 LT	195	bt_accept_unlink(sk);
	196	if (newsock)
	197	sock_graft(sk, newsock);
d37f50e1	198
8a154a8f	199	release_sock(sk);
1da177e4 LT	200	return sk;
	201	}
	202
8a154a8f	203	release_sock(sk);
1da177e4	204	}
d37f50e1	205
1da177e4 LT	206	return NULL;
	207	}
	208	EXPORT_SYMBOL(bt_accept_dequeue);
	209
	210	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	211	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	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
a418b893	219	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	220
	221	if (flags & (MSG_OOB))
	222	return -EOPNOTSUPP;
	223
4683f42f MK	224	msg->msg_namelen = 0;
4683f42f MK	225
5a08ecce AE	226	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	227	if (!skb) {
1da177e4 LT	228	if (sk->sk_shutdown & RCV_SHUTDOWN)
	229	return 0;
	230	return err;
	231	}
	232
1da177e4 LT	233	copied = skb->len;
	234	if (len < copied) {
	235	msg->msg_flags \|= MSG_TRUNC;
	236	copied = len;
	237	}
	238
badff6d0	239	skb_reset_transport_header(skb);
1da177e4	240	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
3241ad82	241	if (err == 0)
3b885787	242	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4 LT	243
	244	skb_free_datagram(sk, skb);
	245
	246	return err ? : copied;
	247	}
	248	EXPORT_SYMBOL(bt_sock_recvmsg);
	249
796c86ee MM	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
5a08ecce AE	308	err = sock_error(sk);
5a08ecce AE	309	if (err)
796c86ee MM	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);
5b668eb3	328	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	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)) {
5b668eb3 MM	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
796c86ee MM	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
1da177e4 LT	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);
d5f2d2be	393	if (sk->sk_state == BT_CONNECTED \|\|
c5daa683 GP	394	(test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
c5daa683 GP	395	sk->sk_state == BT_CONNECT2))
1da177e4 LT	396	return POLLIN \| POLLRDNORM;
	397	}
	398
	399	return 0;
	400	}
	401
8fc9ced3 GP	402	unsigned int bt_sock_poll(struct file file, struct socket sock,
8fc9ced3 GP	403	poll_table *wait)
1da177e4 LT	404	{
	405	struct sock *sk = sock->sk;
	406	unsigned int mask = 0;
	407
	408	BT_DBG("sock %p, sk %p", sock, sk);
	409
aa395145	410	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	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))
7d4c04fc	416	mask \|= POLLERR \|
8facd5fb	417	(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
1da177e4	418
f348d70a	419	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	420	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	421
1da177e4 LT	422	if (sk->sk_shutdown == SHUTDOWN_MASK)
	423	mask \|= POLLHUP;
	424
db40980f	425	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	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
c5daa683	436	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
1da177e4 LT	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
3241ad82 MH	445	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	446	{
	447	struct sock *sk = sock->sk;
43cbeee9 MH	448	struct sk_buff *skb;
43cbeee9 MH	449	long amount;
3241ad82 MH	450	int err;
	451
	452	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	453
	454	switch (cmd) {
43cbeee9 MH	455	case TIOCOUTQ:
	456	if (sk->sk_state == BT_LISTEN)
	457	return -EINVAL;
	458
31e6d363	459	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	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
3241ad82 MH	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
1da177e4 LT	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
aa395145	500	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	501	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	502	while (sk->sk_state != state) {
1da177e4	503	if (!timeo) {
b4c612a4	504	err = -EINPROGRESS;
1da177e4 LT	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);
9be4e3fb	516	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	517
c1cbe4b7 BL	518	err = sock_error(sk);
c1cbe4b7 BL	519	if (err)
1da177e4	520	break;
1da177e4	521	}
9be4e3fb	522	__set_current_state(TASK_RUNNING);
aa395145	523	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	524	return err;
	525	}
	526	EXPORT_SYMBOL(bt_sock_wait_state);
	527
256a06c8 MY	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	{
256a06c8 MY	562	struct bt_seq_state *s = seq->private;
256a06c8 MY	563	struct bt_sock_list *l = s->l;
256a06c8 MY	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 {
09d5d4aa AE	575	struct sock *sk = sk_entry(v);
09d5d4aa AE	576	struct bt_sock *bt = bt_sk(sk);
256a06c8	577
7028a886 AE	578	seq_printf(seq,
7028a886 AE	579	"%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
256a06c8 MY	580	sk,
	581	atomic_read(&sk->sk_refcnt),
	582	sk_rmem_alloc_get(sk),
	583	sk_wmem_alloc_get(sk),
1bbb3095	584	from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
256a06c8	585	sock_i_ino(sk),
7028a886 AE	586	&bt->src,
7028a886 AE	587	&bt->dst,
256a06c8 MY	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
d9dda78b	612	sk_list = PDE_DATA(inode);
256a06c8 MY	613	s = __seq_open_private(file, &bt_seq_ops,
256a06c8 MY	614	sizeof(struct bt_seq_state));
31f47073	615	if (!s)
256a06c8 MY	616	return -ENOMEM;
	617
	618	s->l = sk_list;
	619	return 0;
	620	}
	621
14805359 AV	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
b0316615	629	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	630	struct bt_sock_list* sk_list,
	631	int (* seq_show)(struct seq_file , void ))
	632	{
256a06c8 MY	633	sk_list->custom_seq_show = seq_show;
256a06c8 MY	634
4d006263	635	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
256a06c8	636	return -ENOMEM;
256a06c8 MY	637	return 0;
	638	}
	639
	640	void bt_procfs_cleanup(struct net net, const char name)
	641	{
ece31ffd	642	remove_proc_entry(name, net->proc_net);
256a06c8 MY	643	}
256a06c8 MY	644	#else
b0316615	645	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	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
1da177e4 LT	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
1da177e4 LT	665	static int __init bt_init(void)
1da177e4 LT	666	{
27d35284 MH	667	int err;
27d35284 MH	668
1da177e4 LT	669	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	670
27d35284 MH	671	err = bt_sysfs_init();
	672	if (err < 0)
	673	return err;
1da177e4	674
27d35284 MH	675	err = sock_register(&bt_sock_family_ops);
	676	if (err < 0) {
	677	bt_sysfs_cleanup();
	678	return err;
	679	}
1da177e4	680
27d35284	681	BT_INFO("HCI device and connection manager initialized");
1da177e4	682
64274518 GP	683	err = hci_sock_init();
	684	if (err < 0)
	685	goto error;
	686
	687	err = l2cap_init();
0ed54dad	688	if (err < 0)
64274518	689	goto sock_err;
64274518 GP	690
	691	err = sco_init();
	692	if (err < 0) {
	693	l2cap_exit();
	694	goto sock_err;
	695	}
1da177e4 LT	696
1da177e4 LT	697	return 0;
64274518 GP	698
	699	sock_err:
	700	hci_sock_cleanup();
	701
	702	error:
	703	sock_unregister(PF_BLUETOOTH);
	704	bt_sysfs_cleanup();
	705
	706	return err;
1da177e4 LT	707	}
	708
	709	static void __exit bt_exit(void)
	710	{
64274518 GP	711
	712	sco_exit();
	713
	714	l2cap_exit();
	715
1da177e4 LT	716	hci_sock_cleanup();
1da177e4 LT	717
1da177e4	718	sock_unregister(PF_BLUETOOTH);
27d35284 MH	719
27d35284 MH	720	bt_sysfs_cleanup();
1da177e4 LT	721	}
	722
	723	subsys_initcall(bt_init);
	724	module_exit(bt_exit);
	725
63fbd24e	726	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	727	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	728	MODULE_VERSION(VERSION);
	729	MODULE_LICENSE("GPL");
	730	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);