1 files changed, 144 insertions, 118 deletions

diff --git a/net/bluetooth/rfcomm/tty.c b/net/bluetooth/rfcomm/tty.c
index f9c0980abeea..403ec09f480a 100644
--- a/net/bluetooth/rfcomm/tty.c
+++ b/net/bluetooth/rfcomm/tty.c
@@ -40,6 +40,7 @@
 #define RFCOMM_TTY_MAJOR 216            /* device node major id of the usb/bluetooth.c driver */
 #define RFCOMM_TTY_MINOR 0
 
+static DEFINE_MUTEX(rfcomm_ioctl_mutex);
 static struct tty_driver *rfcomm_tty_driver;
 
 struct rfcomm_dev {
@@ -51,6 +52,8 @@ struct rfcomm_dev {
         unsigned long           flags;
         int                     err;
 
+        unsigned long           status;         /* don't export to userspace */
+
         bdaddr_t                src;
         bdaddr_t                dst;
         u8                      channel;
@@ -58,7 +61,6 @@ struct rfcomm_dev {
         uint                    modem_status;
 
         struct rfcomm_dlc       *dlc;
-        wait_queue_head_t       conn_wait;
 
         struct device           *tty_dev;
 
@@ -83,10 +85,6 @@ static void rfcomm_dev_destruct(struct tty_port *port)
 
         BT_DBG("dev %p dlc %p", dev, dlc);
 
-        spin_lock(&rfcomm_dev_lock);
-        list_del(&dev->list);
-        spin_unlock(&rfcomm_dev_lock);
-
         rfcomm_dlc_lock(dlc);
         /* Detach DLC if it's owned by this dev */
         if (dlc->owner == dev)
@@ -95,7 +93,12 @@ static void rfcomm_dev_destruct(struct tty_port *port)
 
         rfcomm_dlc_put(dlc);
 
-        tty_unregister_device(rfcomm_tty_driver, dev->id);
+        if (dev->tty_dev)
+                tty_unregister_device(rfcomm_tty_driver, dev->id);
+
+        spin_lock(&rfcomm_dev_lock);
+        list_del(&dev->list);
+        spin_unlock(&rfcomm_dev_lock);
 
         kfree(dev);
 
@@ -104,60 +107,24 @@ static void rfcomm_dev_destruct(struct tty_port *port)
         module_put(THIS_MODULE);
 }
 
-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;
-}
-
 /* device-specific initialization: open the dlc */
 static int rfcomm_dev_activate(struct tty_port *port, struct tty_struct *tty)
 {
         struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
-        DEFINE_WAIT(wait);
         int err;
 
         err = rfcomm_dlc_open(dev->dlc, &dev->src, &dev->dst, dev->channel);
         if (err)
-                return err;
-
-        while (1) {
-                prepare_to_wait(&dev->conn_wait, &wait, TASK_INTERRUPTIBLE);
-
-                if (dev->dlc->state == BT_CLOSED) {
-                        err = -dev->err;
-                        break;
-                }
-
-                if (dev->dlc->state == BT_CONNECTED)
-                        break;
-
-                if (signal_pending(current)) {
-                        err = -ERESTARTSYS;
-                        break;
-                }
-
-                tty_unlock(tty);
-                schedule();
-                tty_lock(tty);
-        }
-        finish_wait(&dev->conn_wait, &wait);
+                set_bit(TTY_IO_ERROR, &tty->flags);
+        return err;
+}
 
-        if (!err)
-                device_move(dev->tty_dev, rfcomm_get_device(dev),
-                            DPM_ORDER_DEV_AFTER_PARENT);
+/* we block the open until the dlc->state becomes BT_CONNECTED */
+static int rfcomm_dev_carrier_raised(struct tty_port *port)
+{
+        struct rfcomm_dev *dev = container_of(port, struct rfcomm_dev, port);
 
-        return err;
+        return (dev->dlc->state == BT_CONNECTED);
 }
 
 /* device-specific cleanup: close the dlc */
@@ -176,9 +143,10 @@ static const struct tty_port_operations rfcomm_port_ops = {
         .destruct = rfcomm_dev_destruct,
         .activate = rfcomm_dev_activate,
         .shutdown = rfcomm_dev_shutdown,
+        .carrier_raised = rfcomm_dev_carrier_raised,
 };
 
-static struct rfcomm_dev *__rfcomm_dev_get(int id)
+static struct rfcomm_dev *__rfcomm_dev_lookup(int id)
 {
         struct rfcomm_dev *dev;
 
@@ -195,20 +163,41 @@ static struct rfcomm_dev *rfcomm_dev_get(int id)
 
         spin_lock(&rfcomm_dev_lock);
 
-        dev = __rfcomm_dev_get(id);
+        dev = __rfcomm_dev_lookup(id);
 
-        if (dev) {
-                if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
-                        dev = NULL;
-                else
-                        tty_port_get(&dev->port);
-        }
+        if (dev && !tty_port_get(&dev->port))
+                dev = NULL;
 
         spin_unlock(&rfcomm_dev_lock);
 
         return dev;
 }
 
+static void rfcomm_reparent_device(struct rfcomm_dev *dev)
+{
+        struct hci_dev *hdev;
+        struct hci_conn *conn;
+
+        hdev = hci_get_route(&dev->dst, &dev->src);
+        if (!hdev)
+                return;
+
+        /* The lookup results are unsafe to access without the
+         * hci device lock (FIXME: why is this not documented?)
+         */
+        hci_dev_lock(hdev);
+        conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &dev->dst);
+
+        /* Just because the acl link is in the hash table is no
+         * guarantee the sysfs device has been added ...
+         */
+        if (conn && device_is_registered(&conn->dev))
+                device_move(dev->tty_dev, &conn->dev, DPM_ORDER_DEV_AFTER_PARENT);
+
+        hci_dev_unlock(hdev);
+        hci_dev_put(hdev);
+}
+
 static ssize_t show_address(struct device *tty_dev, struct device_attribute *attr, char *buf)
 {
         struct rfcomm_dev *dev = dev_get_drvdata(tty_dev);
@@ -224,17 +213,16 @@ static ssize_t show_channel(struct device *tty_dev, struct device_attribute *att
 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)
+static struct rfcomm_dev *__rfcomm_dev_add(struct rfcomm_dev_req *req,
+                                           struct rfcomm_dlc *dlc)
 {
         struct rfcomm_dev *dev, *entry;
         struct list_head *head = &rfcomm_dev_list;
         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;
+                return ERR_PTR(-ENOMEM);
 
         spin_lock(&rfcomm_dev_lock);
 
@@ -282,7 +270,6 @@ static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
 
         tty_port_init(&dev->port);
         dev->port.ops = &rfcomm_port_ops;
-        init_waitqueue_head(&dev->conn_wait);
 
         skb_queue_head_init(&dev->pending);
 
@@ -318,22 +305,37 @@ static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
            holds reference to this module. */
         __module_get(THIS_MODULE);
 
+        spin_unlock(&rfcomm_dev_lock);
+        return dev;
+
 out:
         spin_unlock(&rfcomm_dev_lock);
+        kfree(dev);
+        return ERR_PTR(err);
+}
+
+static int rfcomm_dev_add(struct rfcomm_dev_req *req, struct rfcomm_dlc *dlc)
+{
+        struct rfcomm_dev *dev;
+        struct device *tty;
+
+        BT_DBG("id %d channel %d", req->dev_id, req->channel);
 
-        if (err < 0)
-                goto free;
+        dev = __rfcomm_dev_add(req, dlc);
+        if (IS_ERR(dev)) {
+                rfcomm_dlc_put(dlc);
+                return PTR_ERR(dev);
+        }
 
-        dev->tty_dev = tty_port_register_device(&dev->port, rfcomm_tty_driver,
+        tty = tty_port_register_device(&dev->port, rfcomm_tty_driver,
                         dev->id, NULL);
-        if (IS_ERR(dev->tty_dev)) {
-                err = PTR_ERR(dev->tty_dev);
-                spin_lock(&rfcomm_dev_lock);
-                list_del(&dev->list);
-                spin_unlock(&rfcomm_dev_lock);
-                goto free;
+        if (IS_ERR(tty)) {
+                tty_port_put(&dev->port);
+                return PTR_ERR(tty);
         }
 
+        dev->tty_dev = tty;
+        rfcomm_reparent_device(dev);
         dev_set_drvdata(dev->tty_dev, dev);
 
         if (device_create_file(dev->tty_dev, &dev_attr_address) < 0)
@@ -343,24 +345,23 @@ out:
                 BT_ERR("Failed to create channel attribute");
 
         return dev->id;
-
-free:
-        kfree(dev);
-        return err;
 }
 
 /* ---- Send buffer ---- */
-static inline unsigned int rfcomm_room(struct rfcomm_dlc *dlc)
+static inline unsigned int rfcomm_room(struct rfcomm_dev *dev)
 {
-        /* 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);
+        struct rfcomm_dlc *dlc = dev->dlc;
+
+        /* Limit the outstanding number of packets not yet sent to 40 */
+        int pending = 40 - atomic_read(&dev->wmem_alloc);
+
+        return max(0, pending) * dlc->mtu;
 }
 
 static void rfcomm_wfree(struct sk_buff *skb)
 {
         struct rfcomm_dev *dev = (void *) skb->sk;
-        atomic_sub(skb->truesize, &dev->wmem_alloc);
+        atomic_dec(&dev->wmem_alloc);
         if (test_bit(RFCOMM_TTY_ATTACHED, &dev->flags))
                 tty_port_tty_wakeup(&dev->port);
         tty_port_put(&dev->port);
@@ -369,28 +370,24 @@ static void rfcomm_wfree(struct sk_buff *skb)
 static void rfcomm_set_owner_w(struct sk_buff *skb, struct rfcomm_dev *dev)
 {
         tty_port_get(&dev->port);
-        atomic_add(skb->truesize, &dev->wmem_alloc);
+        atomic_inc(&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;
+        struct sk_buff *skb = alloc_skb(size, priority);
+        if (skb)
+                rfcomm_set_owner_w(skb, dev);
+        return skb;
 }
 
 /* ---- Device IOCTLs ---- */
 
 #define NOCAP_FLAGS ((1 << RFCOMM_REUSE_DLC) | (1 << RFCOMM_RELEASE_ONHUP))
 
-static int rfcomm_create_dev(struct sock *sk, void __user *arg)
+static int __rfcomm_create_dev(struct sock *sk, void __user *arg)
 {
         struct rfcomm_dev_req req;
         struct rfcomm_dlc *dlc;
@@ -412,16 +409,22 @@ static int rfcomm_create_dev(struct sock *sk, void __user *arg)
                 dlc = rfcomm_pi(sk)->dlc;
                 rfcomm_dlc_hold(dlc);
         } else {
+                /* Validate the channel is unused */
+                dlc = rfcomm_dlc_exists(&req.src, &req.dst, req.channel);
+                if (IS_ERR(dlc))
+                        return PTR_ERR(dlc);
+                else if (dlc) {
+                        rfcomm_dlc_put(dlc);
+                        return -EBUSY;
+                }
                 dlc = rfcomm_dlc_alloc(GFP_KERNEL);
                 if (!dlc)
                         return -ENOMEM;
         }
 
         id = rfcomm_dev_add(&req, dlc);
-        if (id < 0) {
-                rfcomm_dlc_put(dlc);
+        if (id < 0)
                 return id;
-        }
 
         if (req.flags & (1 << RFCOMM_REUSE_DLC)) {
                 /* DLC is now used by device.
@@ -432,7 +435,7 @@ static int rfcomm_create_dev(struct sock *sk, void __user *arg)
         return id;
 }
 
-static int rfcomm_release_dev(void __user *arg)
+static int __rfcomm_release_dev(void __user *arg)
 {
         struct rfcomm_dev_req req;
         struct rfcomm_dev *dev;
@@ -452,6 +455,12 @@ static int rfcomm_release_dev(void __user *arg)
                 return -EPERM;
         }
 
+        /* only release once */
+        if (test_and_set_bit(RFCOMM_DEV_RELEASED, &dev->status)) {
+                tty_port_put(&dev->port);
+                return -EALREADY;
+        }
+
         if (req.flags & (1 << RFCOMM_HANGUP_NOW))
                 rfcomm_dlc_close(dev->dlc, 0);
 
@@ -462,14 +471,35 @@ static int rfcomm_release_dev(void __user *arg)
                 tty_kref_put(tty);
         }
 
-        if (!test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags) &&
-            !test_and_set_bit(RFCOMM_TTY_RELEASED, &dev->flags))
+        if (!test_bit(RFCOMM_TTY_OWNED, &dev->status))
                 tty_port_put(&dev->port);
 
         tty_port_put(&dev->port);
         return 0;
 }
 
+static int rfcomm_create_dev(struct sock *sk, void __user *arg)
+{
+        int ret;
+
+        mutex_lock(&rfcomm_ioctl_mutex);
+        ret = __rfcomm_create_dev(sk, arg);
+        mutex_unlock(&rfcomm_ioctl_mutex);
+
+        return ret;
+}
+
+static int rfcomm_release_dev(void __user *arg)
+{
+        int ret;
+
+        mutex_lock(&rfcomm_ioctl_mutex);
+        ret = __rfcomm_release_dev(arg);
+        mutex_unlock(&rfcomm_ioctl_mutex);
+
+        return ret;
+}
+
 static int rfcomm_get_dev_list(void __user *arg)
 {
         struct rfcomm_dev *dev;
@@ -497,7 +527,7 @@ static int rfcomm_get_dev_list(void __user *arg)
         spin_lock(&rfcomm_dev_lock);
 
         list_for_each_entry(dev, &rfcomm_dev_list, list) {
-                if (test_bit(RFCOMM_TTY_RELEASED, &dev->flags))
+                if (!tty_port_get(&dev->port))
                         continue;
                 (di + n)->id      = dev->id;
                 (di + n)->flags   = dev->flags;
@@ -505,6 +535,7 @@ static int rfcomm_get_dev_list(void __user *arg)
                 (di + n)->channel = dev->channel;
                 bacpy(&(di + n)->src, &dev->src);
                 bacpy(&(di + n)->dst, &dev->dst);
+                tty_port_put(&dev->port);
                 if (++n >= dev_num)
                         break;
         }
@@ -601,9 +632,11 @@ static void rfcomm_dev_state_change(struct rfcomm_dlc *dlc, int err)
         BT_DBG("dlc %p dev %p err %d", dlc, dev, err);
 
         dev->err = err;
-        wake_up_interruptible(&dev->conn_wait);
+        if (dlc->state == BT_CONNECTED) {
+                rfcomm_reparent_device(dev);
 
-        if (dlc->state == BT_CLOSED)
+                wake_up_interruptible(&dev->port.open_wait);
+        } else if (dlc->state == BT_CLOSED)
                 tty_port_tty_hangup(&dev->port, false);
 }
 
@@ -703,8 +736,10 @@ static int rfcomm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
          * when the last process closes the tty. The behaviour is expected by
          * userspace.
          */
-        if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags))
+        if (test_bit(RFCOMM_RELEASE_ONHUP, &dev->flags)) {
+                set_bit(RFCOMM_TTY_OWNED, &dev->status);
                 tty_port_put(&dev->port);
+        }
 
         return 0;
 }
@@ -750,7 +785,7 @@ static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, in
         struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
         struct rfcomm_dlc *dlc = dev->dlc;
         struct sk_buff *skb;
-        int err = 0, sent = 0, size;
+        int sent = 0, size;
 
         BT_DBG("tty %p count %d", tty, count);
 
@@ -758,7 +793,6 @@ static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, in
                 size = min_t(uint, count, dlc->mtu);
 
                 skb = rfcomm_wmalloc(dev, size + RFCOMM_SKB_RESERVE, GFP_ATOMIC);
-
                 if (!skb)
                         break;
 
@@ -766,32 +800,24 @@ static int rfcomm_tty_write(struct tty_struct *tty, const unsigned char *buf, in
 
                 memcpy(skb_put(skb, size), buf + sent, size);
 
-                err = rfcomm_dlc_send(dlc, skb);
-                if (err < 0) {
-                        kfree_skb(skb);
-                        break;
-                }
+                rfcomm_dlc_send_noerror(dlc, skb);
 
                 sent  += size;
                 count -= size;
         }
 
-        return sent ? sent : err;
+        return sent;
 }
 
 static int rfcomm_tty_write_room(struct tty_struct *tty)
 {
         struct rfcomm_dev *dev = (struct rfcomm_dev *) tty->driver_data;
-        int room;
+        int room = 0;
 
-        BT_DBG("tty %p", tty);
-
-        if (!dev || !dev->dlc)
-                return 0;
+        if (dev && dev->dlc)
+                room = rfcomm_room(dev);
 
-        room = rfcomm_room(dev->dlc) - atomic_read(&dev->wmem_alloc);
-        if (room < 0)
-                room = 0;
+        BT_DBG("tty %p room %d", tty, room);
 
         return room;
 }
@@ -1125,7 +1151,7 @@ int __init rfcomm_init_ttys(void)
         rfcomm_tty_driver->subtype      = SERIAL_TYPE_NORMAL;
         rfcomm_tty_driver->flags        = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
         rfcomm_tty_driver->init_termios = tty_std_termios;
-        rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+        rfcomm_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL;
         rfcomm_tty_driver->init_termios.c_lflag &= ~ICANON;
         tty_set_operations(rfcomm_tty_driver, &rfcomm_ops);