[mirror_ubuntu-artful-kernel.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 <linux/debugfs.h>
#include <asm/ioctls.h>

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

#define VERSION "2.17"

/* 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;

	skb = skb_recv_datagram(sk, flags, noblock, &err);
	if (!skb) {
		if (sk->sk_shutdown & RCV_SHUTDOWN) {
			msg->msg_namelen = 0;
			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);

		if (bt_sk(sk)->skb_msg_name)
			bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
						&msg->msg_namelen);
		else
			msg->msg_namelen = 0;
	}

	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);

/* This function expects the sk lock to be held when called */
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);

/* This function expects the sk lock to be held when called */
int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
{
	DECLARE_WAITQUEUE(wait, current);
	unsigned long timeo;
	int err = 0;

	BT_DBG("sk %p", sk);

	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);

	add_wait_queue(sk_sleep(sk), &wait);
	set_current_state(TASK_INTERRUPTIBLE);
	while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
		if (!timeo) {
			err = -EAGAIN;
			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_ready);

#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  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 %-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->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,
};

struct dentry *bt_debugfs;
EXPORT_SYMBOL_GPL(bt_debugfs);

static int __init bt_init(void)
{
	int err;

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

	bt_debugfs = debugfs_create_dir("bluetooth", NULL);

	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();

	debugfs_remove_recursive(bt_debugfs);
}

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>
ffcecac6	28	#include <linux/debugfs.h>
3241ad82	29	#include <asm/ioctls.h>
1da177e4 LT	30
1da177e4 LT	31	#include <net/bluetooth/bluetooth.h>
256a06c8	32	#include <linux/proc_fs.h>
1da177e4	33
dcbc729e	34	#define VERSION "2.17"
1da177e4 LT	35
	36	/* Bluetooth sockets */
	37	#define BT_MAX_PROTO 8
ec1b4cf7	38	static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
db7aa1c2	39	static DEFINE_RWLOCK(bt_proto_lock);
68845cb2	40
68845cb2	41	static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
36cbd3dc	42	static const char *const bt_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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
db7aa1c2	53	static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
36cbd3dc	54	static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
68845cb2 DY	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	};
db7aa1c2	64
b5a30dda	65	void bt_sock_reclassify_lock(struct sock *sk, int proto)
db7aa1c2	66	{
b5a30dda	67	BUG_ON(!sk);
db7aa1c2 MH	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	}
b5a30dda	74	EXPORT_SYMBOL(bt_sock_reclassify_lock);
1da177e4	75
ec1b4cf7	76	int bt_sock_register(int proto, const struct net_proto_family *ops)
1da177e4	77	{
74da626a MH	78	int err = 0;
74da626a MH	79
1da177e4 LT	80	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	81	return -EINVAL;
	82
74da626a MH	83	write_lock(&bt_proto_lock);
74da626a MH	84
1da177e4	85	if (bt_proto[proto])
74da626a MH	86	err = -EEXIST;
	87	else
	88	bt_proto[proto] = ops;
	89
	90	write_unlock(&bt_proto_lock);
1da177e4	91
74da626a	92	return err;
1da177e4 LT	93	}
	94	EXPORT_SYMBOL(bt_sock_register);
	95
be9f97f0	96	void bt_sock_unregister(int proto)
1da177e4 LT	97	{
1da177e4 LT	98	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
be9f97f0	99	return;
1da177e4	100
74da626a	101	write_lock(&bt_proto_lock);
be9f97f0	102	bt_proto[proto] = NULL;
74da626a	103	write_unlock(&bt_proto_lock);
1da177e4 LT	104	}
	105	EXPORT_SYMBOL(bt_sock_unregister);
	106
3f378b68 EP	107	static int bt_sock_create(struct net net, struct socket sock, int proto,
3f378b68 EP	108	int kern)
1da177e4	109	{
74da626a	110	int err;
1da177e4	111
1b8d7ae4 EB	112	if (net != &init_net)
	113	return -EAFNOSUPPORT;
	114
1da177e4 LT	115	if (proto < 0 \|\| proto >= BT_MAX_PROTO)
	116	return -EINVAL;
	117
95a5afca	118	if (!bt_proto[proto])
1da177e4	119	request_module("bt-proto-%d", proto);
74da626a	120
1da177e4	121	err = -EPROTONOSUPPORT;
74da626a MH	122
	123	read_lock(&bt_proto_lock);
	124
1da177e4	125	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
3f378b68	126	err = bt_proto[proto]->create(net, sock, proto, kern);
b5a30dda OP	127	if (!err)
b5a30dda OP	128	bt_sock_reclassify_lock(sock->sk, proto);
1da177e4 LT	129	module_put(bt_proto[proto]->owner);
1da177e4 LT	130	}
74da626a MH	131
	132	read_unlock(&bt_proto_lock);
	133
8e87d142	134	return err;
1da177e4 LT	135	}
	136
	137	void bt_sock_link(struct bt_sock_list l, struct sock sk)
	138	{
94f5bfb8	139	write_lock(&l->lock);
1da177e4	140	sk_add_node(sk, &l->head);
94f5bfb8	141	write_unlock(&l->lock);
1da177e4 LT	142	}
	143	EXPORT_SYMBOL(bt_sock_link);
	144
	145	void bt_sock_unlink(struct bt_sock_list l, struct sock sk)
	146	{
94f5bfb8	147	write_lock(&l->lock);
1da177e4	148	sk_del_node_init(sk);
94f5bfb8	149	write_unlock(&l->lock);
1da177e4 LT	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
8a154a8f	185	lock_sock(sk);
1da177e4 LT	186
	187	/* FIXME: Is this check still needed */
	188	if (sk->sk_state == BT_CLOSED) {
8a154a8f	189	release_sock(sk);
1da177e4 LT	190	bt_accept_unlink(sk);
	191	continue;
	192	}
	193
c4f912e1	194	if (sk->sk_state == BT_CONNECTED \|\| !newsock \|\|
d060991f	195	test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
1da177e4 LT	196	bt_accept_unlink(sk);
	197	if (newsock)
	198	sock_graft(sk, newsock);
d37f50e1	199
8a154a8f	200	release_sock(sk);
1da177e4 LT	201	return sk;
	202	}
	203
8a154a8f	204	release_sock(sk);
1da177e4	205	}
d37f50e1	206
1da177e4 LT	207	return NULL;
	208	}
	209	EXPORT_SYMBOL(bt_accept_dequeue);
	210
	211	int bt_sock_recvmsg(struct kiocb iocb, struct socket sock,
c4f912e1	212	struct msghdr *msg, size_t len, int flags)
1da177e4 LT	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
a418b893	220	BT_DBG("sock %p sk %p len %zu", sock, sk, len);
1da177e4 LT	221
	222	if (flags & (MSG_OOB))
	223	return -EOPNOTSUPP;
	224
5a08ecce AE	225	skb = skb_recv_datagram(sk, flags, noblock, &err);
5a08ecce AE	226	if (!skb) {
d9763698 MH	227	if (sk->sk_shutdown & RCV_SHUTDOWN) {
d9763698 MH	228	msg->msg_namelen = 0;
1da177e4	229	return 0;
d9763698	230	}
1da177e4 LT	231	return err;
	232	}
	233
1da177e4 LT	234	copied = skb->len;
	235	if (len < copied) {
	236	msg->msg_flags \|= MSG_TRUNC;
	237	copied = len;
	238	}
	239
badff6d0	240	skb_reset_transport_header(skb);
1da177e4	241	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
d9763698	242	if (err == 0) {
3b885787	243	sock_recv_ts_and_drops(msg, sk, skb);
1da177e4	244
d9763698 MH	245	if (bt_sk(sk)->skb_msg_name)
	246	bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
	247	&msg->msg_namelen);
	248	else
	249	msg->msg_namelen = 0;
	250	}
	251
1da177e4 LT	252	skb_free_datagram(sk, skb);
	253
	254	return err ? : copied;
	255	}
	256	EXPORT_SYMBOL(bt_sock_recvmsg);
	257
796c86ee MM	258	static long bt_sock_data_wait(struct sock *sk, long timeo)
	259	{
	260	DECLARE_WAITQUEUE(wait, current);
	261
	262	add_wait_queue(sk_sleep(sk), &wait);
	263	for (;;) {
	264	set_current_state(TASK_INTERRUPTIBLE);
	265
	266	if (!skb_queue_empty(&sk->sk_receive_queue))
	267	break;
	268
	269	if (sk->sk_err \|\| (sk->sk_shutdown & RCV_SHUTDOWN))
	270	break;
	271
	272	if (signal_pending(current) \|\| !timeo)
	273	break;
	274
	275	set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	276	release_sock(sk);
	277	timeo = schedule_timeout(timeo);
	278	lock_sock(sk);
	279	clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
	280	}
	281
	282	__set_current_state(TASK_RUNNING);
	283	remove_wait_queue(sk_sleep(sk), &wait);
	284	return timeo;
	285	}
	286
	287	int bt_sock_stream_recvmsg(struct kiocb iocb, struct socket sock,
	288	struct msghdr *msg, size_t size, int flags)
	289	{
	290	struct sock *sk = sock->sk;
	291	int err = 0;
	292	size_t target, copied = 0;
	293	long timeo;
	294
	295	if (flags & MSG_OOB)
	296	return -EOPNOTSUPP;
	297
	298	msg->msg_namelen = 0;
	299
	300	BT_DBG("sk %p size %zu", sk, size);
	301
	302	lock_sock(sk);
	303
	304	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
	305	timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
	306
	307	do {
	308	struct sk_buff *skb;
	309	int chunk;
	310
	311	skb = skb_dequeue(&sk->sk_receive_queue);
	312	if (!skb) {
	313	if (copied >= target)
	314	break;
	315
5a08ecce AE	316	err = sock_error(sk);
5a08ecce AE	317	if (err)
796c86ee MM	318	break;
	319	if (sk->sk_shutdown & RCV_SHUTDOWN)
	320	break;
	321
	322	err = -EAGAIN;
	323	if (!timeo)
	324	break;
	325
	326	timeo = bt_sock_data_wait(sk, timeo);
	327
	328	if (signal_pending(current)) {
	329	err = sock_intr_errno(timeo);
	330	goto out;
	331	}
	332	continue;
	333	}
	334
	335	chunk = min_t(unsigned int, skb->len, size);
5b668eb3	336	if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
796c86ee MM	337	skb_queue_head(&sk->sk_receive_queue, skb);
	338	if (!copied)
	339	copied = -EFAULT;
	340	break;
	341	}
	342	copied += chunk;
	343	size -= chunk;
	344
	345	sock_recv_ts_and_drops(msg, sk, skb);
	346
	347	if (!(flags & MSG_PEEK)) {
5b668eb3 MM	348	int skb_len = skb_headlen(skb);
	349
	350	if (chunk <= skb_len) {
	351	__skb_pull(skb, chunk);
	352	} else {
	353	struct sk_buff *frag;
	354
	355	__skb_pull(skb, skb_len);
	356	chunk -= skb_len;
	357
	358	skb_walk_frags(skb, frag) {
	359	if (chunk <= frag->len) {
	360	/* Pulling partial data */
	361	skb->len -= chunk;
	362	skb->data_len -= chunk;
	363	__skb_pull(frag, chunk);
	364	break;
	365	} else if (frag->len) {
	366	/* Pulling all frag data */
	367	chunk -= frag->len;
	368	skb->len -= frag->len;
	369	skb->data_len -= frag->len;
	370	__skb_pull(frag, frag->len);
	371	}
	372	}
	373	}
	374
796c86ee MM	375	if (skb->len) {
	376	skb_queue_head(&sk->sk_receive_queue, skb);
	377	break;
	378	}
	379	kfree_skb(skb);
	380
	381	} else {
	382	/* put message back and return */
	383	skb_queue_head(&sk->sk_receive_queue, skb);
	384	break;
	385	}
	386	} while (size);
	387
	388	out:
	389	release_sock(sk);
	390	return copied ? : err;
	391	}
	392	EXPORT_SYMBOL(bt_sock_stream_recvmsg);
	393
1da177e4 LT	394	static inline unsigned int bt_accept_poll(struct sock *parent)
	395	{
	396	struct list_head p, n;
	397	struct sock *sk;
	398
	399	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
	400	sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
d5f2d2be	401	if (sk->sk_state == BT_CONNECTED \|\|
c5daa683 GP	402	(test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
c5daa683 GP	403	sk->sk_state == BT_CONNECT2))
1da177e4 LT	404	return POLLIN \| POLLRDNORM;
	405	}
	406
	407	return 0;
	408	}
	409
8fc9ced3 GP	410	unsigned int bt_sock_poll(struct file file, struct socket sock,
8fc9ced3 GP	411	poll_table *wait)
1da177e4 LT	412	{
	413	struct sock *sk = sock->sk;
	414	unsigned int mask = 0;
	415
	416	BT_DBG("sock %p, sk %p", sock, sk);
	417
aa395145	418	poll_wait(file, sk_sleep(sk), wait);
1da177e4 LT	419
	420	if (sk->sk_state == BT_LISTEN)
	421	return bt_accept_poll(sk);
	422
	423	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
7d4c04fc	424	mask \|= POLLERR \|
8facd5fb	425	(sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
1da177e4	426
f348d70a	427	if (sk->sk_shutdown & RCV_SHUTDOWN)
db40980f	428	mask \|= POLLRDHUP \| POLLIN \| POLLRDNORM;
f348d70a	429
1da177e4 LT	430	if (sk->sk_shutdown == SHUTDOWN_MASK)
	431	mask \|= POLLHUP;
	432
db40980f	433	if (!skb_queue_empty(&sk->sk_receive_queue))
1da177e4 LT	434	mask \|= POLLIN \| POLLRDNORM;
	435
	436	if (sk->sk_state == BT_CLOSED)
	437	mask \|= POLLHUP;
	438
	439	if (sk->sk_state == BT_CONNECT \|\|
	440	sk->sk_state == BT_CONNECT2 \|\|
	441	sk->sk_state == BT_CONFIG)
	442	return mask;
	443
c5daa683	444	if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
1da177e4 LT	445	mask \|= POLLOUT \| POLLWRNORM \| POLLWRBAND;
	446	else
	447	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
	448
	449	return mask;
	450	}
	451	EXPORT_SYMBOL(bt_sock_poll);
	452
3241ad82 MH	453	int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
	454	{
	455	struct sock *sk = sock->sk;
43cbeee9 MH	456	struct sk_buff *skb;
43cbeee9 MH	457	long amount;
3241ad82 MH	458	int err;
	459
	460	BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
	461
	462	switch (cmd) {
43cbeee9 MH	463	case TIOCOUTQ:
	464	if (sk->sk_state == BT_LISTEN)
	465	return -EINVAL;
	466
31e6d363	467	amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
43cbeee9 MH	468	if (amount < 0)
	469	amount = 0;
	470	err = put_user(amount, (int __user *) arg);
	471	break;
	472
	473	case TIOCINQ:
	474	if (sk->sk_state == BT_LISTEN)
	475	return -EINVAL;
	476
	477	lock_sock(sk);
	478	skb = skb_peek(&sk->sk_receive_queue);
	479	amount = skb ? skb->len : 0;
	480	release_sock(sk);
	481	err = put_user(amount, (int __user *) arg);
	482	break;
	483
3241ad82 MH	484	case SIOCGSTAMP:
	485	err = sock_get_timestamp(sk, (struct timeval __user *) arg);
	486	break;
	487
	488	case SIOCGSTAMPNS:
	489	err = sock_get_timestampns(sk, (struct timespec __user *) arg);
	490	break;
	491
	492	default:
	493	err = -ENOIOCTLCMD;
	494	break;
	495	}
	496
	497	return err;
	498	}
	499	EXPORT_SYMBOL(bt_sock_ioctl);
	500
0fba96f9	501	/* This function expects the sk lock to be held when called */
1da177e4 LT	502	int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
	503	{
	504	DECLARE_WAITQUEUE(wait, current);
	505	int err = 0;
	506
	507	BT_DBG("sk %p", sk);
	508
aa395145	509	add_wait_queue(sk_sleep(sk), &wait);
9be4e3fb	510	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	511	while (sk->sk_state != state) {
1da177e4	512	if (!timeo) {
b4c612a4	513	err = -EINPROGRESS;
1da177e4 LT	514	break;
	515	}
	516
	517	if (signal_pending(current)) {
	518	err = sock_intr_errno(timeo);
	519	break;
	520	}
	521
	522	release_sock(sk);
	523	timeo = schedule_timeout(timeo);
	524	lock_sock(sk);
9be4e3fb	525	set_current_state(TASK_INTERRUPTIBLE);
1da177e4	526
c1cbe4b7 BL	527	err = sock_error(sk);
c1cbe4b7 BL	528	if (err)
1da177e4	529	break;
1da177e4	530	}
9be4e3fb	531	__set_current_state(TASK_RUNNING);
aa395145	532	remove_wait_queue(sk_sleep(sk), &wait);
1da177e4 LT	533	return err;
	534	}
	535	EXPORT_SYMBOL(bt_sock_wait_state);
	536
e793dcf0 JH	537	/* This function expects the sk lock to be held when called */
	538	int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
	539	{
	540	DECLARE_WAITQUEUE(wait, current);
	541	unsigned long timeo;
	542	int err = 0;
	543
	544	BT_DBG("sk %p", sk);
	545
	546	timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
	547
	548	add_wait_queue(sk_sleep(sk), &wait);
	549	set_current_state(TASK_INTERRUPTIBLE);
	550	while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
	551	if (!timeo) {
	552	err = -EAGAIN;
	553	break;
	554	}
	555
	556	if (signal_pending(current)) {
	557	err = sock_intr_errno(timeo);
	558	break;
	559	}
	560
	561	release_sock(sk);
	562	timeo = schedule_timeout(timeo);
	563	lock_sock(sk);
	564	set_current_state(TASK_INTERRUPTIBLE);
	565
	566	err = sock_error(sk);
	567	if (err)
	568	break;
	569	}
	570	__set_current_state(TASK_RUNNING);
	571	remove_wait_queue(sk_sleep(sk), &wait);
	572
	573	return err;
	574	}
	575	EXPORT_SYMBOL(bt_sock_wait_ready);
	576
256a06c8 MY	577	#ifdef CONFIG_PROC_FS
	578	struct bt_seq_state {
	579	struct bt_sock_list *l;
	580	};
	581
	582	static void bt_seq_start(struct seq_file seq, loff_t *pos)
	583	__acquires(seq->private->l->lock)
	584	{
	585	struct bt_seq_state *s = seq->private;
	586	struct bt_sock_list *l = s->l;
	587
	588	read_lock(&l->lock);
	589	return seq_hlist_start_head(&l->head, *pos);
	590	}
	591
	592	static void bt_seq_next(struct seq_file seq, void v, loff_t pos)
	593	{
	594	struct bt_seq_state *s = seq->private;
	595	struct bt_sock_list *l = s->l;
	596
	597	return seq_hlist_next(v, &l->head, pos);
	598	}
	599
	600	static void bt_seq_stop(struct seq_file seq, void v)
	601	__releases(seq->private->l->lock)
	602	{
	603	struct bt_seq_state *s = seq->private;
	604	struct bt_sock_list *l = s->l;
	605
	606	read_unlock(&l->lock);
	607	}
	608
	609	static int bt_seq_show(struct seq_file seq, void v)
	610	{
256a06c8 MY	611	struct bt_seq_state *s = seq->private;
256a06c8 MY	612	struct bt_sock_list *l = s->l;
256a06c8 MY	613
256a06c8 MY	614	if (v == SEQ_START_TOKEN) {
c5605755	615	seq_puts(seq ,"sk RefCnt Rmem Wmem User Inode Parent");
256a06c8 MY	616
	617	if (l->custom_seq_show) {
	618	seq_putc(seq, ' ');
	619	l->custom_seq_show(seq, v);
	620	}
	621
	622	seq_putc(seq, '\n');
	623	} else {
09d5d4aa AE	624	struct sock *sk = sk_entry(v);
09d5d4aa AE	625	struct bt_sock *bt = bt_sk(sk);
256a06c8	626
7028a886	627	seq_printf(seq,
5f6cd79f	628	"%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
256a06c8 MY	629	sk,
	630	atomic_read(&sk->sk_refcnt),
	631	sk_rmem_alloc_get(sk),
	632	sk_wmem_alloc_get(sk),
1bbb3095	633	from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
256a06c8	634	sock_i_ino(sk),
256a06c8 MY	635	bt->parent? sock_i_ino(bt->parent): 0LU);
	636
	637	if (l->custom_seq_show) {
	638	seq_putc(seq, ' ');
	639	l->custom_seq_show(seq, v);
	640	}
	641
	642	seq_putc(seq, '\n');
	643	}
	644	return 0;
	645	}
	646
	647	static struct seq_operations bt_seq_ops = {
	648	.start = bt_seq_start,
	649	.next = bt_seq_next,
	650	.stop = bt_seq_stop,
	651	.show = bt_seq_show,
	652	};
	653
	654	static int bt_seq_open(struct inode inode, struct file file)
	655	{
	656	struct bt_sock_list *sk_list;
	657	struct bt_seq_state *s;
	658
d9dda78b	659	sk_list = PDE_DATA(inode);
256a06c8 MY	660	s = __seq_open_private(file, &bt_seq_ops,
256a06c8 MY	661	sizeof(struct bt_seq_state));
31f47073	662	if (!s)
256a06c8 MY	663	return -ENOMEM;
	664
	665	s->l = sk_list;
	666	return 0;
	667	}
	668
14805359 AV	669	static const struct file_operations bt_fops = {
	670	.open = bt_seq_open,
	671	.read = seq_read,
	672	.llseek = seq_lseek,
	673	.release = seq_release_private
	674	};
	675
b0316615	676	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	677	struct bt_sock_list* sk_list,
	678	int (* seq_show)(struct seq_file , void ))
	679	{
256a06c8 MY	680	sk_list->custom_seq_show = seq_show;
256a06c8 MY	681
4d006263	682	if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
256a06c8	683	return -ENOMEM;
256a06c8 MY	684	return 0;
	685	}
	686
	687	void bt_procfs_cleanup(struct net net, const char name)
	688	{
ece31ffd	689	remove_proc_entry(name, net->proc_net);
256a06c8 MY	690	}
256a06c8 MY	691	#else
b0316615	692	int bt_procfs_init(struct net net, const char name,
256a06c8 MY	693	struct bt_sock_list* sk_list,
	694	int (* seq_show)(struct seq_file , void ))
	695	{
	696	return 0;
	697	}
	698
	699	void bt_procfs_cleanup(struct net net, const char name)
	700	{
	701	}
	702	#endif
	703	EXPORT_SYMBOL(bt_procfs_init);
	704	EXPORT_SYMBOL(bt_procfs_cleanup);
	705
1da177e4 LT	706	static struct net_proto_family bt_sock_family_ops = {
	707	.owner = THIS_MODULE,
	708	.family = PF_BLUETOOTH,
	709	.create = bt_sock_create,
	710	};
	711
ffcecac6 MH	712	struct dentry *bt_debugfs;
	713	EXPORT_SYMBOL_GPL(bt_debugfs);
	714
1da177e4 LT	715	static int __init bt_init(void)
1da177e4 LT	716	{
27d35284 MH	717	int err;
27d35284 MH	718
1da177e4 LT	719	BT_INFO("Core ver %s", VERSION);
1da177e4 LT	720
ffcecac6 MH	721	bt_debugfs = debugfs_create_dir("bluetooth", NULL);
ffcecac6 MH	722
27d35284 MH	723	err = bt_sysfs_init();
	724	if (err < 0)
	725	return err;
1da177e4	726
27d35284 MH	727	err = sock_register(&bt_sock_family_ops);
	728	if (err < 0) {
	729	bt_sysfs_cleanup();
	730	return err;
	731	}
1da177e4	732
27d35284	733	BT_INFO("HCI device and connection manager initialized");
1da177e4	734
64274518 GP	735	err = hci_sock_init();
	736	if (err < 0)
	737	goto error;
	738
	739	err = l2cap_init();
0ed54dad	740	if (err < 0)
64274518	741	goto sock_err;
64274518 GP	742
	743	err = sco_init();
	744	if (err < 0) {
	745	l2cap_exit();
	746	goto sock_err;
	747	}
1da177e4 LT	748
1da177e4 LT	749	return 0;
64274518 GP	750
	751	sock_err:
	752	hci_sock_cleanup();
	753
	754	error:
	755	sock_unregister(PF_BLUETOOTH);
	756	bt_sysfs_cleanup();
	757
	758	return err;
1da177e4 LT	759	}
	760
	761	static void __exit bt_exit(void)
	762	{
64274518 GP	763	sco_exit();
	764
	765	l2cap_exit();
	766
1da177e4 LT	767	hci_sock_cleanup();
1da177e4 LT	768
1da177e4	769	sock_unregister(PF_BLUETOOTH);
27d35284 MH	770
27d35284 MH	771	bt_sysfs_cleanup();
ffcecac6 MH	772
ffcecac6 MH	773	debugfs_remove_recursive(bt_debugfs);
1da177e4 LT	774	}
	775
	776	subsys_initcall(bt_init);
	777	module_exit(bt_exit);
	778
63fbd24e	779	MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
1da177e4 LT	780	MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
	781	MODULE_VERSION(VERSION);
	782	MODULE_LICENSE("GPL");
	783	MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);