[net-next-2.6.git] / net / bluetooth / rfcomm / tty.c

/*
   RFCOMM implementation for Linux Bluetooth stack (BlueZ).
   Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
   Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>

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

/*
 * RFCOMM TTY.
 */

#include <linux/module.h>

#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>

#include <linux/capability.h>
#include <linux/slab.h>
#include <linux/skbuff.h>

#include <net/bluetooth/bluetooth.h>
#include <net/bluetooth/hci_core.h>
#include <net/bluetooth/rfcomm.h>

#define RFCOMM_TTY_MAGIC 0x6d02		/* magic number for rfcomm struct */
#define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV	/* whole lotta rfcomm devices */
#define RFCOMM_TTY_MAJOR 216		/* device node major id of the usb/bluetooth.c driver */
#define RFCOMM_TTY_MINOR 0

static struct tty_driver *rfcomm_tty_driver;

struct rfcomm_dev {
	struct list_head	list;
	atomic_t		refcnt;

	char			name[12];
	int			id;
	unsigned long		flags;
	atomic_t		opened;
	int			err;

	bdaddr_t		src;
	bdaddr_t		dst;
	u8 			channel;

	uint 			modem_status;

	struct rfcomm_dlc	*dlc;
	struct tty_struct	*tty;
	wait_queue_head_t       wait;
	struct tasklet_struct   wakeup_task;

	struct device		*tty_dev;

	atomic_t 		wmem_alloc;

	struct sk_buff_head	pending;
};

static LIST_HEAD(rfcomm_dev_list);
static DEFINE_RWLOCK(rfcomm_dev_lock);

static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb);
static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);

static void rfcomm_tty_wakeup(unsigned long arg);

/* ---- Device functions ---- */
static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
{
	struct rfcomm_dlc *dlc = dev->dlc;

	BT_DBG("dev %p dlc %p", dev, dlc);

	/* Refcount should only hit zero when called from rfcomm_dev_del()
	   which will have taken us off the list. Everything else are
	   refcounting bugs. */
	BUG_ON(!list_empty(&dev->list));

	rfcomm_dlc_lock(dlc);
	/* Detach DLC if it's owned by this dev */
	if (dlc->owner == dev)
		dlc->owner = NULL;
	rfcomm_dlc_unlock(dlc);

	rfcomm_dlc_put(dlc);

	tty_unregister_device(rfcomm_tty_driver, dev->id);

	kfree(dev);

	/* It's safe to call module_put() here because socket still
	   holds reference to this module. */
	module_put(THIS_MODULE);
}

static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
{
	atomic_inc(&dev->refcnt);
}

static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
{
	/* The reason this isn't actually a race, as you no
	   doubt have a little voice screaming at you in your
	   head, is that the refcount should never actually
	   reach zero unless the device has already been taken
	   off the list, in rfcomm_dev_del(). And if that's not
	   true, we'll hit the BUG() in rfcomm_dev_destruct()
	   anyway. */
	if (atomic_dec_and_test(&dev->refcnt))
		rfcomm_dev_destruct(dev);
}

static struct rfcomm_dev *__rfcomm_dev_get(int id)
{
	struct rfcomm_dev *dev;
	struct list_head  *p;

	list_for_each(p, &rfcomm_dev_list) {
		dev = list_entry(p, struct rfcomm_dev, list);
		if (dev->id == id)
			return dev;
	}

	return NULL;
}

static inline struct rfcomm_dev *rfcomm_dev_get(int id)
{
	struct rfcomm_dev *dev;

	read_lock(&rfcomm_dev_lock);

	dev = __rfcomm_dev_get(id);

	if (dev) {
		if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
			dev = NULL;
		else
			rfcomm_dev_hold(dev);
	}

	read_unlock(&rfcomm_dev_lock);

	return dev;
}

static struct device *rfcomm_get_device(struct rfcomm_dev *dev)
{
	struct hci_dev *hdev;
	struct hci_conn *conn;

	hdev = hci_get_route(&dev->dst, &dev->src);
	if (!hdev)
		return NULL;

	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);

	hci_dev_put(hdev);

	return conn ? &conn->dev : NULL;
}

static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
{
	struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
	return sprintf(buf, "%s\n", batostr(&dev->dst));
}

static ssize_t show_channel(struct device *tty_dev, struct device_attribute *attr, char *buf)
{
	struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
	return sprintf(buf, "%d\n", dev->channel);
}

static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);

static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
{
	struct rfcomm_dev *dev;
	struct list_head *head = &rfcomm_dev_list, *p;
	int err = 0;

	BT_DBG("id %d channel %d", req->dev_id, req->channel);

	dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;

	write_lock_bh(&rfcomm_dev_lock);

	if (req->dev_id < 0) {
		dev->id = 0;

		list_for_each(p, &rfcomm_dev_list) {
			if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
				break;

			dev->id++;
			head = p;
		}
	} else {
		dev->id = req->dev_id;

		list_for_each(p, &rfcomm_dev_list) {
			struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);

			if (entry->id == dev->id) {
				err = -EADDRINUSE;
				goto out;
			}

			if (entry->id > dev->id - 1)
				break;

			head = p;
		}
	}

	if ((dev->id < 0) || (dev->id > RFCOMM_MAX_DEV - 1)) {
		err = -ENFILE;
		goto out;
	}

	sprintf(dev->name, "rfcomm%d", dev->id);

	list_add(&dev->list, head);
	atomic_set(&dev->refcnt, 1);

	bacpy(&dev->src, &req->src);
	bacpy(&dev->dst, &req->dst);
	dev->channel = req->channel;

	dev->flags = req->flags &
		((1 << RFCOMM_RELEASE_ONHUP) | (1 << RFCOMM_REUSE_DLC));

	atomic_set(&dev->opened, 0);

	init_waitqueue_head(&dev->wait);
	tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);

	skb_queue_head_init(&dev->pending);

	rfcomm_dlc_lock(dlc);

	if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
		struct sock *sk = dlc->owner;
		struct sk_buff *skb;

		BUG_ON(!sk);

		rfcomm_dlc_throttle(dlc);

		while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
			skb_orphan(skb);
			skb_queue_tail(&dev->pending, skb);
			atomic_sub(skb->len, &sk->sk_rmem_alloc);
		}
	}

	dlc->data_ready   = rfcomm_dev_data_ready;
	dlc->state_change = rfcomm_dev_state_change;
	dlc->modem_status = rfcomm_dev_modem_status;

	dlc->owner = dev;
	dev->dlc   = dlc;

	rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);

	rfcomm_dlc_unlock(dlc);

	/* It's safe to call __module_get() here because socket already
	   holds reference to this module. */
	__module_get(THIS_MODULE);

out:
	write_unlock_bh(&rfcomm_dev_lock);

	if (err < 0)
		goto free;

	dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);

	if (IS_ERR(dev->tty_dev)) {
		err = PTR_ERR(dev->tty_dev);
		list_del(&dev->list);
		goto free;
	}

	dev_set_drvdata(dev->tty_dev, dev);

	if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
		BT_ERR("Failed to create address attribute");

	if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
		BT_ERR("Failed to create channel attribute");

	return dev->id;

free:
	kfree(dev);
	return err;
}

static void rfcomm_dev_del(struct rfcomm_dev *dev)
{
	BT_DBG("dev %p", dev);

	BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags));

	if (atomic_read(&dev->opened) > 0)
		return;

	write_lock_bh(&rfcomm_dev_lock);
	list_del_init(&dev->list);
	write_unlock_bh(&rfcomm_dev_lock);

	rfcomm_dev_put(dev);
}

/* ---- Send buffer ---- */
static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
{
	/* We can't let it be zero, because we don't get a callback
	   when tx_credits becomes nonzero, hence we'd never wake up */
	return dlc->mtu * (dlc->tx_credits?:1);
}

static void rfcomm_wfree(struct sk_buff *skb)
{
	struct rfcomm_dev *dev = (void *) skb->sk;
	atomic_sub(skb->truesize, &dev->wmem_alloc);
	if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
		tasklet_schedule(&dev->wakeup_task);
	rfcomm_dev_put(dev);
}

static inline void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
{
	rfcomm_dev_hold(dev);
	atomic_add(skb->truesize, &dev->wmem_alloc);
	skb->sk = (void *) dev;
	skb->destructor = rfcomm_wfree;
}

static struct sk_buff *rfcomm_wmalloc(struct rfcomm_dev *dev, unsigned long size, gfp_t priority)
{
	if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
		struct sk_buff *skb = alloc_skb(size, priority);
		if (skb) {
			rfcomm_set_owner_w(skb, dev);
			return skb;
		}
	}
	return NULL;
}

/* ---- Device IOCTLs ---- */

#define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))

static int rfcomm_create_dev(struct sock *sk, void __user *arg)
{
	struct rfcomm_dev_req req;
	struct rfcomm_dlc *dlc;
	int id;

	if (copy_from_user(&req, arg, sizeof(req)))
		return -EFAULT;

	BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);

	if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
		return -EPERM;

	if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
		/* Socket must be connected */
		if (sk->sk_state != BT_CONNECTED)
			return -EBADFD;

		dlc = rfcomm_pi(sk)->dlc;
		rfcomm_dlc_hold(dlc);
	} else {
		dlc = rfcomm_dlc_alloc(GFP_KERNEL);
		if (!dlc)
			return -ENOMEM;
	}

	id = rfcomm_dev_add(&req, dlc);
	if (id < 0) {
		rfcomm_dlc_put(dlc);
		return id;
	}

	if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
		/* DLC is now used by device.
		 * Socket must be disconnected */
		sk->sk_state = BT_CLOSED;
	}

	return id;
}

static int rfcomm_release_dev(void __user *arg)
{
	struct rfcomm_dev_req req;
	struct rfcomm_dev *dev;

	if (copy_from_user(&req, arg, sizeof(req)))
		return -EFAULT;

	BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);

	if (!(dev = rfcomm_dev_get(req.dev_id)))
		return -ENODEV;

	if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
		rfcomm_dev_put(dev);
		return -EPERM;
	}

	if (req.flags & (1 << RFCOMM_HANGUP_NOW))
		rfcomm_dlc_close(dev->dlc, 0);

	/* Shut down TTY synchronously before freeing rfcomm_dev */
	if (dev->tty)
		tty_vhangup(dev->tty);

	if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
		rfcomm_dev_del(dev);
	rfcomm_dev_put(dev);
	return 0;
}

static int rfcomm_get_dev_list(void __user *arg)
{
	struct rfcomm_dev_list_req *dl;
	struct rfcomm_dev_info *di;
	struct list_head *p;
	int n = 0, size, err;
	u16 dev_num;

	BT_DBG("");

	if (get_user(dev_num, (u16 __user *) arg))
		return -EFAULT;

	if (!dev_num || dev_num > (PAGE_SIZE * 4) / sizeof(*di))
		return -EINVAL;

	size = sizeof(*dl) + dev_num * sizeof(*di);

	if (!(dl = kmalloc(size, GFP_KERNEL)))
		return -ENOMEM;

	di = dl->dev_info;

	read_lock_bh(&rfcomm_dev_lock);

	list_for_each(p, &rfcomm_dev_list) {
		struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
		if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
			continue;
		(di + n)->id      = dev->id;
		(di + n)->flags   = dev->flags;
		(di + n)->state   = dev->dlc->state;
		(di + n)->channel = dev->channel;
		bacpy(&(di + n)->src, &dev->src);
		bacpy(&(di + n)->dst, &dev->dst);
		if (++n >= dev_num)
			break;
	}

	read_unlock_bh(&rfcomm_dev_lock);

	dl->dev_num = n;
	size = sizeof(*dl) + n * sizeof(*di);

	err = copy_to_user(arg, dl, size);
	kfree(dl);

	return err ? -EFAULT : 0;
}

static int rfcomm_get_dev_info(void __user *arg)
{
	struct rfcomm_dev *dev;
	struct rfcomm_dev_info di;
	int err = 0;

	BT_DBG("");

	if (copy_from_user(&di, arg, sizeof(di)))
		return -EFAULT;

	if (!(dev = rfcomm_dev_get(di.id)))
		return -ENODEV;

	di.flags   = dev->flags;
	di.channel = dev->channel;
	di.state   = dev->dlc->state;
	bacpy(&di.src, &dev->src);
	bacpy(&di.dst, &dev->dst);

	if (copy_to_user(arg, &di, sizeof(di)))
		err = -EFAULT;

	rfcomm_dev_put(dev);
	return err;
}

int rfcomm_dev_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
{
	BT_DBG("cmd %d arg %p", cmd, arg);

	switch (cmd) {
	case RFCOMMCREATEDEV:
		return rfcomm_create_dev(sk, arg);

	case RFCOMMRELEASEDEV:
		return rfcomm_release_dev(arg);

	case RFCOMMGETDEVLIST:
		return rfcomm_get_dev_list(arg);

	case RFCOMMGETDEVINFO:
		return rfcomm_get_dev_info(arg);
	}

	return -EINVAL;
}

/* ---- DLC callbacks ---- */
static void rfcomm_dev_data_ready(struct rfcomm_dlc *dlc, struct sk_buff *skb)
{
	struct rfcomm_dev *dev = dlc->owner;
	struct tty_struct *tty;

	if (!dev) {
		kfree_skb(skb);
		return;
	}

	if (!(tty = dev->tty) || !skb_queue_empty(&dev->pending)) {
		skb_queue_tail(&dev->pending, skb);
		return;
	}

	BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);

	tty_insert_flip_string(tty, skb->data, skb->len);
	tty_flip_buffer_push(tty);

	kfree_skb(skb);
}

static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
{
	struct rfcomm_dev *dev = dlc->owner;
	if (!dev)
		return;

	BT_DBG("dlc %p dev %p err %d", dlc, dev, err);

	dev->err = err;
	wake_up_interruptible(&dev->wait);

	if (dlc->state == BT_CLOSED) {
		if (!dev->tty) {
			if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
				/* Drop DLC lock here to avoid deadlock
				 * 1. rfcomm_dev_get will take rfcomm_dev_lock
				 *    but in rfcomm_dev_add there's lock order:
				 *    rfcomm_dev_lock -> dlc lock
				 * 2. rfcomm_dev_put will deadlock if it's
				 *    the last reference
				 */
				rfcomm_dlc_unlock(dlc);
				if (rfcomm_dev_get(dev->id) == NULL) {
					rfcomm_dlc_lock(dlc);
					return;
				}

				rfcomm_dev_del(dev);
				rfcomm_dev_put(dev);
				rfcomm_dlc_lock(dlc);
			}
		} else
			tty_hangup(dev->tty);
	}
}

static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
{
	struct rfcomm_dev *dev = dlc->owner;
	if (!dev)
		return;
Commit	Line	Data
8e87d142	1	/*
1da177e4 LT	2	RFCOMM implementation for Linux Bluetooth stack (BlueZ).
	3	Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
	4	Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License version 2 as
	8	published by the Free Software Foundation;
	9
	10	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	11	OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	12	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
	13	IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
8e87d142 YH	14	CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
	15	WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	16	ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
1da177e4 LT	17	OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
1da177e4 LT	18
8e87d142 YH	19	ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
8e87d142 YH	20	COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4 LT	21	SOFTWARE IS DISCLAIMED.
	22	*/
	23
	24	/*
	25	* RFCOMM TTY.
1da177e4 LT	26	*/
1da177e4 LT	27
1da177e4 LT	28	#include <linux/module.h>
	29
	30	#include <linux/tty.h>
	31	#include <linux/tty_driver.h>
	32	#include <linux/tty_flip.h>
	33
4fc268d2	34	#include <linux/capability.h>
1da177e4 LT	35	#include <linux/slab.h>
	36	#include <linux/skbuff.h>
	37
	38	#include <net/bluetooth/bluetooth.h>
0a85b964	39	#include <net/bluetooth/hci_core.h>
1da177e4 LT	40	#include <net/bluetooth/rfcomm.h>
1da177e4 LT	41
1da177e4 LT	42	#define RFCOMM_TTY_MAGIC 0x6d02 /* magic number for rfcomm struct */
	43	#define RFCOMM_TTY_PORTS RFCOMM_MAX_DEV /* whole lotta rfcomm devices */
	44	#define RFCOMM_TTY_MAJOR 216 /* device node major id of the usb/bluetooth.c driver */
	45	#define RFCOMM_TTY_MINOR 0
	46
	47	static struct tty_driver *rfcomm_tty_driver;
	48
	49	struct rfcomm_dev {
	50	struct list_head list;
	51	atomic_t refcnt;
	52
	53	char name[12];
	54	int id;
	55	unsigned long flags;
9a5df923	56	atomic_t opened;
1da177e4 LT	57	int err;
	58
	59	bdaddr_t src;
	60	bdaddr_t dst;
	61	u8 channel;
	62
	63	uint modem_status;
	64
	65	struct rfcomm_dlc *dlc;
	66	struct tty_struct *tty;
	67	wait_queue_head_t wait;
	68	struct tasklet_struct wakeup_task;
	69
c1a33136 MH	70	struct device *tty_dev;
c1a33136 MH	71
1da177e4	72	atomic_t wmem_alloc;
a0c22f22 MH	73
a0c22f22 MH	74	struct sk_buff_head pending;
1da177e4 LT	75	};
	76
	77	static LIST_HEAD(rfcomm_dev_list);
	78	static DEFINE_RWLOCK(rfcomm_dev_lock);
	79
	80	static void rfcomm_dev_data_ready(struct rfcomm_dlc dlc, struct sk_buff skb);
	81	static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err);
	82	static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig);
	83
	84	static void rfcomm_tty_wakeup(unsigned long arg);
	85
	86	/* ---- Device functions ---- */
	87	static void rfcomm_dev_destruct(struct rfcomm_dev *dev)
	88	{
	89	struct rfcomm_dlc *dlc = dev->dlc;
	90
	91	BT_DBG("dev %p dlc %p", dev, dlc);
	92
f951375d DY	93	/* Refcount should only hit zero when called from rfcomm_dev_del()
	94	which will have taken us off the list. Everything else are
	95	refcounting bugs. */
	96	BUG_ON(!list_empty(&dev->list));
8de0a154	97
1da177e4 LT	98	rfcomm_dlc_lock(dlc);
	99	/* Detach DLC if it's owned by this dev */
	100	if (dlc->owner == dev)
	101	dlc->owner = NULL;
	102	rfcomm_dlc_unlock(dlc);
	103
	104	rfcomm_dlc_put(dlc);
	105
	106	tty_unregister_device(rfcomm_tty_driver, dev->id);
	107
1da177e4 LT	108	kfree(dev);
1da177e4 LT	109
8e87d142	110	/* It's safe to call module_put() here because socket still
1da177e4 LT	111	holds reference to this module. */
	112	module_put(THIS_MODULE);
	113	}
	114
	115	static inline void rfcomm_dev_hold(struct rfcomm_dev *dev)
	116	{
	117	atomic_inc(&dev->refcnt);
	118	}
	119
	120	static inline void rfcomm_dev_put(struct rfcomm_dev *dev)
	121	{
	122	/* The reason this isn't actually a race, as you no
	123	doubt have a little voice screaming at you in your
	124	head, is that the refcount should never actually
	125	reach zero unless the device has already been taken
	126	off the list, in rfcomm_dev_del(). And if that's not
	127	true, we'll hit the BUG() in rfcomm_dev_destruct()
	128	anyway. */
	129	if (atomic_dec_and_test(&dev->refcnt))
	130	rfcomm_dev_destruct(dev);
	131	}
	132
	133	static struct rfcomm_dev *__rfcomm_dev_get(int id)
	134	{
	135	struct rfcomm_dev *dev;
	136	struct list_head *p;
	137
	138	list_for_each(p, &rfcomm_dev_list) {
	139	dev = list_entry(p, struct rfcomm_dev, list);
	140	if (dev->id == id)
	141	return dev;
	142	}
	143
	144	return NULL;
	145	}
	146
	147	static inline struct rfcomm_dev *rfcomm_dev_get(int id)
	148	{
	149	struct rfcomm_dev *dev;
	150
	151	read_lock(&rfcomm_dev_lock);
	152
	153	dev = __rfcomm_dev_get(id);
8de0a154 VT	154
	155	if (dev) {
	156	if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
	157	dev = NULL;
	158	else
	159	rfcomm_dev_hold(dev);
	160	}
1da177e4 LT	161
	162	read_unlock(&rfcomm_dev_lock);
	163
	164	return dev;
	165	}
	166
0a85b964 MH	167	static struct device rfcomm_get_device(struct rfcomm_dev dev)
	168	{
	169	struct hci_dev *hdev;
	170	struct hci_conn *conn;
	171
	172	hdev = hci_get_route(&dev->dst, &dev->src);
	173	if (!hdev)
	174	return NULL;
	175
	176	conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
0a85b964 MH	177
	178	hci_dev_put(hdev);
	179
b2cfcd75	180	return conn ? &conn->dev : NULL;
0a85b964 MH	181	}
0a85b964 MH	182
dae6a0f6 MH	183	static ssize_t show_address(struct device tty_dev, struct device_attribute attr, char *buf)
	184	{
	185	struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
d6b2eb2f	186	return sprintf(buf, "%s\n", batostr(&dev->dst));
dae6a0f6 MH	187	}
	188
	189	static ssize_t show_channel(struct device tty_dev, struct device_attribute attr, char *buf)
	190	{
	191	struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
	192	return sprintf(buf, "%d\n", dev->channel);
	193	}
	194
	195	static DEVICE_ATTR(address, S_IRUGO, show_address, NULL);
	196	static DEVICE_ATTR(channel, S_IRUGO, show_channel, NULL);
	197
1da177e4 LT	198	static int rfcomm_dev_add(struct rfcomm_dev_req req, struct rfcomm_dlc dlc)
	199	{
	200	struct rfcomm_dev *dev;
	201	struct list_head head = &rfcomm_dev_list, p;
	202	int err = 0;
	203
	204	BT_DBG("id %d channel %d", req->dev_id, req->channel);
8e87d142	205
25ea6db0	206	dev = kzalloc(sizeof(struct rfcomm_dev), GFP_KERNEL);
1da177e4 LT	207	if (!dev)
1da177e4 LT	208	return -ENOMEM;
1da177e4 LT	209
	210	write_lock_bh(&rfcomm_dev_lock);
	211
	212	if (req->dev_id < 0) {
	213	dev->id = 0;
	214
	215	list_for_each(p, &rfcomm_dev_list) {
	216	if (list_entry(p, struct rfcomm_dev, list)->id != dev->id)
	217	break;
	218
	219	dev->id++;
	220	head = p;
	221	}
	222	} else {
	223	dev->id = req->dev_id;
	224
	225	list_for_each(p, &rfcomm_dev_list) {
	226	struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
	227
	228	if (entry->id == dev->id) {
	229	err = -EADDRINUSE;
	230	goto out;
	231	}
	232
	233	if (entry->id > dev->id - 1)
	234	break;
	235
	236	head = p;
	237	}
	238	}
	239
	240	if ((dev->id < 0) \|\| (dev->id > RFCOMM_MAX_DEV - 1)) {
	241	err = -ENFILE;
	242	goto out;
	243	}
	244
	245	sprintf(dev->name, "rfcomm%d", dev->id);
	246
	247	list_add(&dev->list, head);
	248	atomic_set(&dev->refcnt, 1);
	249
	250	bacpy(&dev->src, &req->src);
	251	bacpy(&dev->dst, &req->dst);
	252	dev->channel = req->channel;
	253
8e87d142	254	dev->flags = req->flags &
1da177e4 LT	255	((1 << RFCOMM_RELEASE_ONHUP) \| (1 << RFCOMM_REUSE_DLC));
1da177e4 LT	256
9a5df923 MH	257	atomic_set(&dev->opened, 0);
9a5df923 MH	258
1da177e4 LT	259	init_waitqueue_head(&dev->wait);
	260	tasklet_init(&dev->wakeup_task, rfcomm_tty_wakeup, (unsigned long) dev);
	261
a0c22f22 MH	262	skb_queue_head_init(&dev->pending);
a0c22f22 MH	263
1da177e4	264	rfcomm_dlc_lock(dlc);
a0c22f22 MH	265
	266	if (req->flags & (1 << RFCOMM_REUSE_DLC)) {
	267	struct sock *sk = dlc->owner;
	268	struct sk_buff *skb;
	269
	270	BUG_ON(!sk);
	271
	272	rfcomm_dlc_throttle(dlc);
	273
	274	while ((skb = skb_dequeue(&sk->sk_receive_queue))) {
	275	skb_orphan(skb);
	276	skb_queue_tail(&dev->pending, skb);
	277	atomic_sub(skb->len, &sk->sk_rmem_alloc);
	278	}
	279	}
	280
1da177e4 LT	281	dlc->data_ready = rfcomm_dev_data_ready;
	282	dlc->state_change = rfcomm_dev_state_change;
	283	dlc->modem_status = rfcomm_dev_modem_status;
	284
	285	dlc->owner = dev;
	286	dev->dlc = dlc;
8b6b3da7 MH	287
	288	rfcomm_dev_modem_status(dlc, dlc->remote_v24_sig);
	289
1da177e4 LT	290	rfcomm_dlc_unlock(dlc);
1da177e4 LT	291
8e87d142	292	/* It's safe to call __module_get() here because socket already
1da177e4 LT	293	holds reference to this module. */
	294	__module_get(THIS_MODULE);
	295
	296	out:
	297	write_unlock_bh(&rfcomm_dev_lock);
	298
037322ab IJ	299	if (err < 0)
037322ab IJ	300	goto free;
1da177e4	301
c1a33136	302	dev->tty_dev = tty_register_device(rfcomm_tty_driver, dev->id, NULL);
1da177e4	303
8de0a154	304	if (IS_ERR(dev->tty_dev)) {
09c7d829	305	err = PTR_ERR(dev->tty_dev);
8de0a154	306	list_del(&dev->list);
037322ab	307	goto free;
8de0a154 VT	308	}
8de0a154 VT	309
dae6a0f6 MH	310	dev_set_drvdata(dev->tty_dev, dev);
	311
	312	if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
	313	BT_ERR("Failed to create address attribute");
	314
	315	if (device_create_file(dev->tty_dev, &dev_attr_channel) < 0)
	316	BT_ERR("Failed to create channel attribute");
	317
1da177e4	318	return dev->id;
037322ab IJ	319
	320	free:
	321	kfree(dev);
	322	return err;
1da177e4 LT	323	}
	324
	325	static void rfcomm_dev_del(struct rfcomm_dev *dev)
	326	{
	327	BT_DBG("dev %p", dev);
	328
9a5df923 MH	329	BUG_ON(test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags));
	330
	331	if (atomic_read(&dev->opened) > 0)
	332	return;
f951375d DY	333
	334	write_lock_bh(&rfcomm_dev_lock);
	335	list_del_init(&dev->list);
	336	write_unlock_bh(&rfcomm_dev_lock);
	337
1da177e4 LT	338	rfcomm_dev_put(dev);
	339	}
	340
	341	/* ---- Send buffer ---- */
	342	static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
	343	{
	344	/* We can't let it be zero, because we don't get a callback
	345	when tx_credits becomes nonzero, hence we'd never wake up */
	346	return dlc->mtu * (dlc->tx_credits?:1);
	347	}
	348
	349	static void rfcomm_wfree(struct sk_buff *skb)
	350	{
	351	struct rfcomm_dev dev = (void ) skb->sk;
	352	atomic_sub(skb->truesize, &dev->wmem_alloc);
	353	if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
	354	tasklet_schedule(&dev->wakeup_task);
	355	rfcomm_dev_put(dev);
	356	}
	357
	358	static inline void rfcomm_set_owner_w(struct sk_buff skb, struct rfcomm_dev dev)
	359	{
	360	rfcomm_dev_hold(dev);
	361	atomic_add(skb->truesize, &dev->wmem_alloc);
	362	skb->sk = (void *) dev;
	363	skb->destructor = rfcomm_wfree;
	364	}
	365
dd0fc66f	366	static struct sk_buff rfcomm_wmalloc(struct rfcomm_dev dev, unsigned long size, gfp_t priority)
1da177e4 LT	367	{
	368	if (atomic_read(&dev->wmem_alloc) < rfcomm_room(dev->dlc)) {
	369	struct sk_buff *skb = alloc_skb(size, priority);
	370	if (skb) {
	371	rfcomm_set_owner_w(skb, dev);
	372	return skb;
	373	}
	374	}
	375	return NULL;
	376	}
	377
	378	/* ---- Device IOCTLs ---- */
	379
	380	#define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) \| (1 << RFCOMM_RELEASE_ONHUP))
	381
	382	static int rfcomm_create_dev(struct sock sk, void __user arg)
	383	{
	384	struct rfcomm_dev_req req;
	385	struct rfcomm_dlc *dlc;
	386	int id;
	387
	388	if (copy_from_user(&req, arg, sizeof(req)))
	389	return -EFAULT;
	390
8de0a154	391	BT_DBG("sk %p dev_id %d flags 0x%x", sk, req.dev_id, req.flags);
1da177e4 LT	392
	393	if (req.flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN))
	394	return -EPERM;
	395
	396	if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
	397	/* Socket must be connected */
	398	if (sk->sk_state != BT_CONNECTED)
	399	return -EBADFD;
	400
	401	dlc = rfcomm_pi(sk)->dlc;
	402	rfcomm_dlc_hold(dlc);
	403	} else {
	404	dlc = rfcomm_dlc_alloc(GFP_KERNEL);
	405	if (!dlc)
	406	return -ENOMEM;
	407	}
	408
	409	id = rfcomm_dev_add(&req, dlc);
	410	if (id < 0) {
	411	rfcomm_dlc_put(dlc);
	412	return id;
	413	}
	414
	415	if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
	416	/* DLC is now used by device.
	417	* Socket must be disconnected */
	418	sk->sk_state = BT_CLOSED;
	419	}
	420
	421	return id;
	422	}
	423
	424	static int rfcomm_release_dev(void __user *arg)
	425	{
	426	struct rfcomm_dev_req req;
	427	struct rfcomm_dev *dev;
	428
	429	if (copy_from_user(&req, arg, sizeof(req)))
	430	return -EFAULT;
	431
8de0a154	432	BT_DBG("dev_id %d flags 0x%x", req.dev_id, req.flags);
1da177e4 LT	433
	434	if (!(dev = rfcomm_dev_get(req.dev_id)))
	435	return -ENODEV;
	436
	437	if (dev->flags != NOCAP_FLAGS && !capable(CAP_NET_ADMIN)) {
	438	rfcomm_dev_put(dev);
	439	return -EPERM;
	440	}
	441
	442	if (req.flags & (1 << RFCOMM_HANGUP_NOW))
	443	rfcomm_dlc_close(dev->dlc, 0);
	444
84950cf0 MR	445	/* Shut down TTY synchronously before freeing rfcomm_dev */
	446	if (dev->tty)
	447	tty_vhangup(dev->tty);
	448
93d80740 DY	449	if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
93d80740 DY	450	rfcomm_dev_del(dev);
1da177e4 LT	451	rfcomm_dev_put(dev);
	452	return 0;
	453	}
	454
	455	static int rfcomm_get_dev_list(void __user *arg)
	456	{
	457	struct rfcomm_dev_list_req *dl;
	458	struct rfcomm_dev_info *di;
	459	struct list_head *p;
	460	int n = 0, size, err;
	461	u16 dev_num;
	462
	463	BT_DBG("");
	464
	465	if (get_user(dev_num, (u16 __user *) arg))
	466	return -EFAULT;
	467
	468	if (!dev_num \|\| dev_num > (PAGE_SIZE * 4) / sizeof(*di))
	469	return -EINVAL;
	470
	471	size = sizeof(dl) + dev_num sizeof(*di);
	472
	473	if (!(dl = kmalloc(size, GFP_KERNEL)))
	474	return -ENOMEM;
	475
	476	di = dl->dev_info;
	477
	478	read_lock_bh(&rfcomm_dev_lock);
	479
	480	list_for_each(p, &rfcomm_dev_list) {
	481	struct rfcomm_dev *dev = list_entry(p, struct rfcomm_dev, list);
8de0a154 VT	482	if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
8de0a154 VT	483	continue;
1da177e4 LT	484	(di + n)->id = dev->id;
	485	(di + n)->flags = dev->flags;
	486	(di + n)->state = dev->dlc->state;
	487	(di + n)->channel = dev->channel;
	488	bacpy(&(di + n)->src, &dev->src);
	489	bacpy(&(di + n)->dst, &dev->dst);
	490	if (++n >= dev_num)
	491	break;
	492	}
	493
	494	read_unlock_bh(&rfcomm_dev_lock);
	495
	496	dl->dev_num = n;
	497	size = sizeof(dl) + n sizeof(*di);
	498
	499	err = copy_to_user(arg, dl, size);
	500	kfree(dl);
	501
	502	return err ? -EFAULT : 0;
	503	}
	504
	505	static int rfcomm_get_dev_info(void __user *arg)
	506	{
	507	struct rfcomm_dev *dev;
	508	struct rfcomm_dev_info di;
	509	int err = 0;
	510
	511	BT_DBG("");
	512
	513	if (copy_from_user(&di, arg, sizeof(di)))
	514	return -EFAULT;
	515
	516	if (!(dev = rfcomm_dev_get(di.id)))
	517	return -ENODEV;
	518
	519	di.flags = dev->flags;
	520	di.channel = dev->channel;
	521	di.state = dev->dlc->state;
	522	bacpy(&di.src, &dev->src);
	523	bacpy(&di.dst, &dev->dst);
	524
	525	if (copy_to_user(arg, &di, sizeof(di)))
	526	err = -EFAULT;
	527
	528	rfcomm_dev_put(dev);
	529	return err;
	530	}
	531
	532	int rfcomm_dev_ioctl(struct sock sk, unsigned int cmd, void __user arg)
	533	{
	534	BT_DBG("cmd %d arg %p", cmd, arg);
	535
	536	switch (cmd) {
	537	case RFCOMMCREATEDEV:
	538	return rfcomm_create_dev(sk, arg);
	539
	540	case RFCOMMRELEASEDEV:
	541	return rfcomm_release_dev(arg);
	542
	543	case RFCOMMGETDEVLIST:
	544	return rfcomm_get_dev_list(arg);
	545
	546	case RFCOMMGETDEVINFO:
	547	return rfcomm_get_dev_info(arg);
548	}
549
550	return -EINVAL;
551	}
552
553	/* ---- DLC callbacks ---- */
554	static void rfcomm_dev_data_ready(struct rfcomm_dlc dlc, struct sk_buff skb)
555	{
556	struct rfcomm_dev *dev = dlc->owner;
557	struct tty_struct *tty;
8e87d142	558
a0c22f22	559	if (!dev) {
1da177e4 LT	560	kfree_skb(skb);
	561	return;
	562	}
	563
a0c22f22 MH	564	if (!(tty = dev->tty) \|\| !skb_queue_empty(&dev->pending)) {
	565	skb_queue_tail(&dev->pending, skb);
	566	return;
	567	}
	568
1da177e4 LT	569	BT_DBG("dlc %p tty %p len %d", dlc, tty, skb->len);
1da177e4 LT	570
817d6d3b PF	571	tty_insert_flip_string(tty, skb->data, skb->len);
817d6d3b PF	572	tty_flip_buffer_push(tty);
1da177e4 LT	573
	574	kfree_skb(skb);
	575	}
	576
	577	static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
	578	{
	579	struct rfcomm_dev *dev = dlc->owner;
	580	if (!dev)
	581	return;
8e87d142	582
1da177e4 LT	583	BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
	584
	585	dev->err = err;
	586	wake_up_interruptible(&dev->wait);
	587
	588	if (dlc->state == BT_CLOSED) {
	589	if (!dev->tty) {
	590	if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
537d59af DY	591	/* Drop DLC lock here to avoid deadlock
	592	* 1. rfcomm_dev_get will take rfcomm_dev_lock
	593	* but in rfcomm_dev_add there's lock order:
	594	* rfcomm_dev_lock -> dlc lock
	595	* 2. rfcomm_dev_put will deadlock if it's
	596	* the last reference
	597	*/
	598	rfcomm_dlc_unlock(dlc);
	599	if (rfcomm_dev_get(dev->id) == NULL) {
	600	rfcomm_dlc_lock(dlc);
77f2a45f	601	return;
537d59af	602	}
1da177e4	603
77f2a45f	604	rfcomm_dev_del(dev);
1da177e4	605	rfcomm_dev_put(dev);
537d59af	606	rfcomm_dlc_lock(dlc);
1da177e4	607	}
8e87d142	608	} else
1da177e4 LT	609	tty_hangup(dev->tty);
	610	}
	611	}
	612
	613	static void rfcomm_dev_modem_status(struct rfcomm_dlc *dlc, u8 v24_sig)
	614	{
	615	struct rfcomm_dev *dev = dlc->owner;
	616	if (!dev)
	617	return;