Revert "NET: Fix locking issues in PPP, 6pack, mkiss and strip line disciplines."

This reverts commit adeab1afb7de89555c69aab5ca21300c14af6369.

As Alan Cox explained, the TTY layer changes that went recently
to get rid of the tty->low_latency stuff fixes this already,
and even for -stable it's the ->low_latency changes that should
go in to fix this, rather than this patch.

Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 913a5640659428255cfaec0d308996bc824257ca..155160052c8bd5dc690c1bfe04b253654e739cab 100644 (file)
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -398,14 +398,13 @@ static DEFINE_RWLOCK(disc_data_lock);
                                                                                 
 static struct sixpack *sp_get(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct sixpack *sp;
 
-       read_lock_irqsave(&disc_data_lock, flags);
+       read_lock(&disc_data_lock);
        sp = tty->disc_data;
        if (sp)
                atomic_inc(&sp->refcnt);
-       read_unlock_irqrestore(&disc_data_lock, flags);
+       read_unlock(&disc_data_lock);
 
        return sp;
 }
@@ -689,13 +688,12 @@ out:
  */
 static void sixpack_close(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct sixpack *sp;
 
-       write_lock_irqsave(&disc_data_lock, flags);
+       write_lock(&disc_data_lock);
        sp = tty->disc_data;
        tty->disc_data = NULL;
-       write_unlock_irqrestore(&disc_data_lock, flags);
+       write_unlock(&disc_data_lock);
        if (!sp)
                return;
 

diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index a7286500c186b1186749bf13ebb18afda3dd3781..fda2fc83e9a124c66c3f7d3754e8312a36b172f8 100644 (file)
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -244,16 +244,15 @@ static int kiss_esc_crc(unsigned char *s, unsigned char *d, unsigned short crc,
 /* Send one completely decapsulated AX.25 packet to the AX.25 layer. */
 static void ax_bump(struct mkiss *ax)
 {
-       unsigned long flags;
        struct sk_buff *skb;
        int count;
 
-       spin_lock_irqsave(&ax->buflock, flags);
+       spin_lock_bh(&ax->buflock);
        if (ax->rbuff[0] > 0x0f) {
                if (ax->rbuff[0] & 0x80) {
                        if (check_crc_16(ax->rbuff, ax->rcount) < 0) {
                                ax->dev->stats.rx_errors++;
-                               spin_unlock_irqrestore(&ax->buflock, flags);
+                               spin_unlock_bh(&ax->buflock);
 
                                return;
                        }
@@ -268,7 +267,7 @@ static void ax_bump(struct mkiss *ax)
                } else if (ax->rbuff[0] & 0x20)  {
                        if (check_crc_flex(ax->rbuff, ax->rcount) < 0) {
                                ax->dev->stats.rx_errors++;
-                               spin_unlock_irqrestore(&ax->buflock, flags);
+                               spin_unlock_bh(&ax->buflock);
                                return;
                        }
                        if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
@@ -295,7 +294,7 @@ static void ax_bump(struct mkiss *ax)
                printk(KERN_ERR "mkiss: %s: memory squeeze, dropping packet.\n",
                       ax->dev->name);
                ax->dev->stats.rx_dropped++;
-               spin_unlock_irqrestore(&ax->buflock, flags);
+               spin_unlock_bh(&ax->buflock);
                return;
        }
 
@@ -304,13 +303,11 @@ static void ax_bump(struct mkiss *ax)
        netif_rx(skb);
        ax->dev->stats.rx_packets++;
        ax->dev->stats.rx_bytes += count;
-       spin_unlock_irqrestore(&ax->buflock, flags);
+       spin_unlock_bh(&ax->buflock);
 }
 
 static void kiss_unesc(struct mkiss *ax, unsigned char s)
 {
-       unsigned long flags;
-
        switch (s) {
        case END:
                /* drop keeptest bit = VSV */
@@ -337,18 +334,18 @@ static void kiss_unesc(struct mkiss *ax, unsigned char s)
                break;
        }
 
-       spin_lock_irqsave(&ax->buflock, flags);
+       spin_lock_bh(&ax->buflock);
        if (!test_bit(AXF_ERROR, &ax->flags)) {
                if (ax->rcount < ax->buffsize) {
                        ax->rbuff[ax->rcount++] = s;
-                       spin_unlock_irqrestore(&ax->buflock, flags);
+                       spin_unlock_bh(&ax->buflock);
                        return;
                }
 
                ax->dev->stats.rx_over_errors++;
                set_bit(AXF_ERROR, &ax->flags);
        }
-       spin_unlock_irqrestore(&ax->buflock, flags);
+       spin_unlock_bh(&ax->buflock);
 }
 
 static int ax_set_mac_address(struct net_device *dev, void *addr)
@@ -370,7 +367,6 @@ static void ax_changedmtu(struct mkiss *ax)
 {
        struct net_device *dev = ax->dev;
        unsigned char *xbuff, *rbuff, *oxbuff, *orbuff;
-       unsigned long flags;
        int len;
 
        len = dev->mtu * 2;
@@ -396,7 +392,7 @@ static void ax_changedmtu(struct mkiss *ax)
                return;
        }
 
-       spin_lock_irqsave(&ax->buflock, flags);
+       spin_lock_bh(&ax->buflock);
 
        oxbuff    = ax->xbuff;
        ax->xbuff = xbuff;
@@ -427,7 +423,7 @@ static void ax_changedmtu(struct mkiss *ax)
        ax->mtu      = dev->mtu + 73;
        ax->buffsize = len;
 
-       spin_unlock_irqrestore(&ax->buflock, flags);
+       spin_unlock_bh(&ax->buflock);
 
        kfree(oxbuff);
        kfree(orbuff);
@@ -437,7 +433,6 @@ static void ax_changedmtu(struct mkiss *ax)
 static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
 {
        struct mkiss *ax = netdev_priv(dev);
-       unsigned long flags;
        unsigned char *p;
        int actual, count;
 
@@ -454,7 +449,7 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
 
        p = icp;
 
-       spin_lock_irqsave(&ax->buflock, flags);
+       spin_lock_bh(&ax->buflock);
        if ((*p & 0x0f) != 0) {
                /* Configuration Command (kissparms(1).
                 * Protocol spec says: never append CRC.
@@ -484,7 +479,7 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
                                ax->crcauto = (cmd ? 0 : 1);
                                printk(KERN_INFO "mkiss: %s: crc mode %s %d\n", ax->dev->name, (len) ? "set to" : "is", cmd);
                        }
-                       spin_unlock_irqrestore(&ax->buflock, flags);
+                       spin_unlock_bh(&ax->buflock);
                        netif_start_queue(dev);
 
                        return;
@@ -517,7 +512,7 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
                        count = kiss_esc(p, (unsigned char *)ax->xbuff, len);
                }
        }
-       spin_unlock_irqrestore(&ax->buflock, flags);
+       spin_unlock_bh(&ax->buflock);
 
        set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
        actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
@@ -709,14 +704,13 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct mkiss *mkiss_get(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct mkiss *ax;
 
-       read_lock_irqsave(&disc_data_lock, flags);
+       read_lock(&disc_data_lock);
        ax = tty->disc_data;
        if (ax)
                atomic_inc(&ax->refcnt);
-       read_unlock_irqrestore(&disc_data_lock, flags);
+       read_unlock(&disc_data_lock);
 
        return ax;
 }
@@ -815,13 +809,12 @@ out:
 
 static void mkiss_close(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct mkiss *ax;
 
-       write_lock_irqsave(&disc_data_lock, flags);
+       write_lock(&disc_data_lock);
        ax = tty->disc_data;
        tty->disc_data = NULL;
-       write_unlock_irqrestore(&disc_data_lock, flags);
+       write_unlock(&disc_data_lock);
 
        if (!ax)
                return;

diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index 1fd319bf758ef19b3b07282c22d86fc626976ee0..17c116bb332c7e0c41da3f97aeb3ac3755097e87 100644 (file)
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -132,15 +132,13 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct asyncppp *ap_get(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct asyncppp *ap;
 
-       read_lock_irqsave(&disc_data_lock, flags);
+       read_lock(&disc_data_lock);
        ap = tty->disc_data;
        if (ap != NULL)
                atomic_inc(&ap->refcnt);
-       read_unlock_irqrestore(&disc_data_lock, flags);
-
+       read_unlock(&disc_data_lock);
        return ap;
 }
 
@@ -217,13 +215,12 @@ ppp_asynctty_open(struct tty_struct *tty)
 static void
 ppp_asynctty_close(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct asyncppp *ap;
 
-       write_lock_irqsave(&disc_data_lock, flags);
+       write_lock_irq(&disc_data_lock);
        ap = tty->disc_data;
        tty->disc_data = NULL;
-       write_unlock_irqrestore(&disc_data_lock, flags);
+       write_unlock_irq(&disc_data_lock);
        if (!ap)
                return;
 

diff --git a/drivers/net/ppp_synctty.c b/drivers/net/ppp_synctty.c
index 1b3f75febee1ce3ad1aa01e6f3d30671a8f00460..aa3d39f38e2257deee5e72e9df06453be96e3046 100644 (file)
--- a/drivers/net/ppp_synctty.c
+++ b/drivers/net/ppp_synctty.c
@@ -182,15 +182,13 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct syncppp *sp_get(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct syncppp *ap;
 
-       read_lock_irqsave(&disc_data_lock, flags);
+       read_lock(&disc_data_lock);
        ap = tty->disc_data;
        if (ap != NULL)
                atomic_inc(&ap->refcnt);
-       read_unlock_irqrestore(&disc_data_lock, flags);
-
+       read_unlock(&disc_data_lock);
        return ap;
 }
 
@@ -264,13 +262,12 @@ ppp_sync_open(struct tty_struct *tty)
 static void
 ppp_sync_close(struct tty_struct *tty)
 {
-       unsigned long flags;
        struct syncppp *ap;
 
-       write_lock_irqsave(&disc_data_lock, flags);
+       write_lock_irq(&disc_data_lock);
        ap = tty->disc_data;
        tty->disc_data = NULL;
-       write_unlock_irqrestore(&disc_data_lock, flags);
+       write_unlock_irq(&disc_data_lock);
        if (!ap)
                return;
 

diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index 3d39f6587eb9ce80981d4b0e96a1e16f0a3005c9..38366a56b71fa6588d197ea79268d509c9a9629a 100644 (file)
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -856,7 +856,6 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
        unsigned char *orbuff = strip_info->rx_buff;
        unsigned char *osbuff = strip_info->sx_buff;
        unsigned char *otbuff = strip_info->tx_buff;
-       unsigned long flags;
 
        if (new_mtu > MAX_SEND_MTU) {
                printk(KERN_ERR
@@ -865,11 +864,11 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
                return -EINVAL;
        }
 
-       spin_lock_irqsave(&strip_lock, flags);
+       spin_lock_bh(&strip_lock);
        if (!allocate_buffers(strip_info, new_mtu)) {
                printk(KERN_ERR "%s: unable to grow strip buffers, MTU change cancelled.\n",
                       strip_info->dev->name);
-               spin_unlock_irqrestore(&strip_lock, flags);
+               spin_unlock_bh(&strip_lock);
                return -ENOMEM;
        }
 
@@ -893,7 +892,7 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
                }
        }
        strip_info->tx_head = strip_info->tx_buff;
-       spin_unlock_irqrestore(&strip_lock, flags);
+       spin_unlock_bh(&strip_lock);
 
        printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
               strip_info->dev->name, old_mtu, strip_info->mtu);
@@ -984,13 +983,10 @@ static void strip_seq_neighbours(struct seq_file *seq,
                           const MetricomNodeTable * table,
                           const char *title)
 {
-       unsigned long flags;
+       /* We wrap this in a do/while loop, so if the table changes */
+       /* while we're reading it, we just go around and try again. */
        struct timeval t;
 
-       /*
-        * We wrap this in a do/while loop, so if the table changes
-        * while we're reading it, we just go around and try again.
-        */
        do {
                int i;
                t = table->timestamp;
@@ -999,9 +995,9 @@ static void strip_seq_neighbours(struct seq_file *seq,
                for (i = 0; i < table->num_nodes; i++) {
                        MetricomNode node;
 
-                       spin_lock_irqsave(&strip_lock, flags);
+                       spin_lock_bh(&strip_lock);
                        node = table->node[i];
-                       spin_unlock_irqrestore(&strip_lock, flags);
+                       spin_unlock_bh(&strip_lock);
                        seq_printf(seq, "  %s\n", node.c);
                }
        } while (table->timestamp.tv_sec != t.tv_sec
@@ -1540,7 +1536,6 @@ static void strip_send(struct strip *strip_info, struct sk_buff *skb)
 static int strip_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct strip *strip_info = netdev_priv(dev);
-       unsigned long flags;
 
        if (!netif_running(dev)) {
                printk(KERN_ERR "%s: xmit call when iface is down\n",
@@ -1579,11 +1574,11 @@ static int strip_xmit(struct sk_buff *skb, struct net_device *dev)
                               strip_info->dev->name, sx_pps_count / 8);
        }
 
-       spin_lock_irqsave(&strip_lock, flags);
+       spin_lock_bh(&strip_lock);
 
        strip_send(strip_info, skb);
 
-       spin_unlock_irqrestore(&strip_lock, flags);
+       spin_unlock_bh(&strip_lock);
 
        if (skb)
                dev_kfree_skb(skb);
@@ -2268,13 +2263,12 @@ static void strip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
 {
        struct strip *strip_info = tty->disc_data;
        const unsigned char *end = cp + count;
-       unsigned long flags;
 
        if (!strip_info || strip_info->magic != STRIP_MAGIC
            || !netif_running(strip_info->dev))
                return;
 
-       spin_lock_irqsave(&strip_lock, flags);
+       spin_lock_bh(&strip_lock);
 #if 0
        {
                struct timeval tv;
@@ -2341,7 +2335,7 @@ static void strip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
                }
                cp++;
        }
-       spin_unlock_irqrestore(&strip_lock, flags);
+       spin_unlock_bh(&strip_lock);
 }
 
 
@@ -2529,11 +2523,9 @@ static void strip_dev_setup(struct net_device *dev)
 
 static void strip_free(struct strip *strip_info)
 {
-       unsigned long flags;
-
-       spin_lock_irqsave(&strip_lock, flags);
+       spin_lock_bh(&strip_lock);
        list_del_rcu(&strip_info->list);
-       spin_unlock_irqrestore(&strip_lock, flags);
+       spin_unlock_bh(&strip_lock);
 
        strip_info->magic = 0;
 
@@ -2547,7 +2539,6 @@ static void strip_free(struct strip *strip_info)
 static struct strip *strip_alloc(void)
 {
        struct list_head *n;
-       unsigned long flags;
        struct net_device *dev;
        struct strip *strip_info;
 
@@ -2571,7 +2562,7 @@ static struct strip *strip_alloc(void)
        strip_info->idle_timer.function = strip_IdleTask;
 
 
-       spin_lock_irqsave(&strip_lock, flags);
+       spin_lock_bh(&strip_lock);
  rescan:
        /*
         * Search the list to find where to put our new entry
@@ -2590,7 +2581,7 @@ static struct strip *strip_alloc(void)
        sprintf(dev->name, "st%ld", dev->base_addr);
 
        list_add_tail_rcu(&strip_info->list, &strip_list);
-       spin_unlock_irqrestore(&strip_lock, flags);
+       spin_unlock_bh(&strip_lock);
 
        return strip_info;
 }