5 files changed, 68 insertions, 44 deletions

diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 155160052c8b..913a56406594 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -398,13 +398,14 @@ static DEFINE_RWLOCK(disc_data_lock);
                                                                                 
 static struct sixpack *sp_get(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct sixpack *sp;
 
-        read_lock(&disc_data_lock);
+        read_lock_irqsave(&disc_data_lock, flags);
         sp = tty->disc_data;
         if (sp)
                 atomic_inc(&sp->refcnt);
-        read_unlock(&disc_data_lock);
+        read_unlock_irqrestore(&disc_data_lock, flags);
 
         return sp;
 }
@@ -688,12 +689,13 @@ out:
  */
 static void sixpack_close(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct sixpack *sp;
 
-        write_lock(&disc_data_lock);
+        write_lock_irqsave(&disc_data_lock, flags);
         sp = tty->disc_data;
         tty->disc_data = NULL;
-        write_unlock(&disc_data_lock);
+        write_unlock_irqrestore(&disc_data_lock, flags);
         if (!sp)
                 return;
 
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index fda2fc83e9a1..a7286500c186 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -244,15 +244,16 @@ 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_bh(&ax->buflock);
+        spin_lock_irqsave(&ax->buflock, flags);
         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_bh(&ax->buflock);
+                                spin_unlock_irqrestore(&ax->buflock, flags);
 
                                 return;
                         }
@@ -267,7 +268,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_bh(&ax->buflock);
+                                spin_unlock_irqrestore(&ax->buflock, flags);
                                 return;
                         }
                         if (ax->crcmode != CRC_MODE_FLEX && ax->crcauto) {
@@ -294,7 +295,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_bh(&ax->buflock);
+                spin_unlock_irqrestore(&ax->buflock, flags);
                 return;
         }
 
@@ -303,11 +304,13 @@ static void ax_bump(struct mkiss *ax)
         netif_rx(skb);
         ax->dev->stats.rx_packets++;
         ax->dev->stats.rx_bytes += count;
-        spin_unlock_bh(&ax->buflock);
+        spin_unlock_irqrestore(&ax->buflock, flags);
 }
 
 static void kiss_unesc(struct mkiss *ax, unsigned char s)
 {
+        unsigned long flags;
+
         switch (s) {
         case END:
                 /* drop keeptest bit = VSV */
@@ -334,18 +337,18 @@ static void kiss_unesc(struct mkiss *ax, unsigned char s)
                 break;
         }
 
-        spin_lock_bh(&ax->buflock);
+        spin_lock_irqsave(&ax->buflock, flags);
         if (!test_bit(AXF_ERROR, &ax->flags)) {
                 if (ax->rcount < ax->buffsize) {
                         ax->rbuff[ax->rcount++] = s;
-                        spin_unlock_bh(&ax->buflock);
+                        spin_unlock_irqrestore(&ax->buflock, flags);
                         return;
                 }
 
                 ax->dev->stats.rx_over_errors++;
                 set_bit(AXF_ERROR, &ax->flags);
         }
-        spin_unlock_bh(&ax->buflock);
+        spin_unlock_irqrestore(&ax->buflock, flags);
 }
 
 static int ax_set_mac_address(struct net_device *dev, void *addr)
@@ -367,6 +370,7 @@ 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;
@@ -392,7 +396,7 @@ static void ax_changedmtu(struct mkiss *ax)
                 return;
         }
 
-        spin_lock_bh(&ax->buflock);
+        spin_lock_irqsave(&ax->buflock, flags);
 
         oxbuff    = ax->xbuff;
         ax->xbuff = xbuff;
@@ -423,7 +427,7 @@ static void ax_changedmtu(struct mkiss *ax)
         ax->mtu      = dev->mtu + 73;
         ax->buffsize = len;
 
-        spin_unlock_bh(&ax->buflock);
+        spin_unlock_irqrestore(&ax->buflock, flags);
 
         kfree(oxbuff);
         kfree(orbuff);
@@ -433,6 +437,7 @@ 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;
 
@@ -449,7 +454,7 @@ static void ax_encaps(struct net_device *dev, unsigned char *icp, int len)
 
         p = icp;
 
-        spin_lock_bh(&ax->buflock);
+        spin_lock_irqsave(&ax->buflock, flags);
         if ((*p & 0x0f) != 0) {
                 /* Configuration Command (kissparms(1).
                  * Protocol spec says: never append CRC.
@@ -479,7 +484,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_bh(&ax->buflock);
+                        spin_unlock_irqrestore(&ax->buflock, flags);
                         netif_start_queue(dev);
 
                         return;
@@ -512,7 +517,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_bh(&ax->buflock);
+        spin_unlock_irqrestore(&ax->buflock, flags);
 
         set_bit(TTY_DO_WRITE_WAKEUP, &ax->tty->flags);
         actual = ax->tty->ops->write(ax->tty, ax->xbuff, count);
@@ -704,13 +709,14 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct mkiss *mkiss_get(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct mkiss *ax;
 
-        read_lock(&disc_data_lock);
+        read_lock_irqsave(&disc_data_lock, flags);
         ax = tty->disc_data;
         if (ax)
                 atomic_inc(&ax->refcnt);
-        read_unlock(&disc_data_lock);
+        read_unlock_irqrestore(&disc_data_lock, flags);
 
         return ax;
 }
@@ -809,12 +815,13 @@ out:
 
 static void mkiss_close(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct mkiss *ax;
 
-        write_lock(&disc_data_lock);
+        write_lock_irqsave(&disc_data_lock, flags);
         ax = tty->disc_data;
         tty->disc_data = NULL;
-        write_unlock(&disc_data_lock);
+        write_unlock_irqrestore(&disc_data_lock, flags);
 
         if (!ax)
                 return;
diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index 17c116bb332c..1fd319bf758e 100644
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -132,13 +132,15 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct asyncppp *ap_get(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct asyncppp *ap;
 
-        read_lock(&disc_data_lock);
+        read_lock_irqsave(&disc_data_lock, flags);
         ap = tty->disc_data;
         if (ap != NULL)
                 atomic_inc(&ap->refcnt);
-        read_unlock(&disc_data_lock);
+        read_unlock_irqrestore(&disc_data_lock, flags);
+
         return ap;
 }
 
@@ -215,12 +217,13 @@ ppp_asynctty_open(struct tty_struct *tty)
 static void
 ppp_asynctty_close(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct asyncppp *ap;
 
-        write_lock_irq(&disc_data_lock);
+        write_lock_irqsave(&disc_data_lock, flags);
         ap = tty->disc_data;
         tty->disc_data = NULL;
-        write_unlock_irq(&disc_data_lock);
+        write_unlock_irqrestore(&disc_data_lock, flags);
         if (!ap)
                 return;
 
diff --git a/drivers/net/ppp_synctty.c b/drivers/net/ppp_synctty.c
index aa3d39f38e22..1b3f75febee1 100644
--- a/drivers/net/ppp_synctty.c
+++ b/drivers/net/ppp_synctty.c
@@ -182,13 +182,15 @@ static DEFINE_RWLOCK(disc_data_lock);
 
 static struct syncppp *sp_get(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct syncppp *ap;
 
-        read_lock(&disc_data_lock);
+        read_lock_irqsave(&disc_data_lock, flags);
         ap = tty->disc_data;
         if (ap != NULL)
                 atomic_inc(&ap->refcnt);
-        read_unlock(&disc_data_lock);
+        read_unlock_irqrestore(&disc_data_lock, flags);
+
         return ap;
 }
 
@@ -262,12 +264,13 @@ ppp_sync_open(struct tty_struct *tty)
 static void
 ppp_sync_close(struct tty_struct *tty)
 {
+        unsigned long flags;
         struct syncppp *ap;
 
-        write_lock_irq(&disc_data_lock);
+        write_lock_irqsave(&disc_data_lock, flags);
         ap = tty->disc_data;
         tty->disc_data = NULL;
-        write_unlock_irq(&disc_data_lock);
+        write_unlock_irqrestore(&disc_data_lock, flags);
         if (!ap)
                 return;
 
diff --git a/drivers/net/wireless/strip.c b/drivers/net/wireless/strip.c
index 38366a56b71f..3d39f6587eb9 100644
--- a/drivers/net/wireless/strip.c
+++ b/drivers/net/wireless/strip.c
@@ -856,6 +856,7 @@ 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
@@ -864,11 +865,11 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
                 return -EINVAL;
         }
 
-        spin_lock_bh(&strip_lock);
+        spin_lock_irqsave(&strip_lock, flags);
         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_bh(&strip_lock);
+                spin_unlock_irqrestore(&strip_lock, flags);
                 return -ENOMEM;
         }
 
@@ -892,7 +893,7 @@ static int strip_change_mtu(struct net_device *dev, int new_mtu)
                 }
         }
         strip_info->tx_head = strip_info->tx_buff;
-        spin_unlock_bh(&strip_lock);
+        spin_unlock_irqrestore(&strip_lock, flags);
 
         printk(KERN_NOTICE "%s: strip MTU changed fom %d to %d.\n",
                strip_info->dev->name, old_mtu, strip_info->mtu);
@@ -983,10 +984,13 @@ static void strip_seq_neighbours(struct seq_file *seq,
                            const MetricomNodeTable * table,
                            const char *title)
 {
-        /* 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. */
+        unsigned long flags;
         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;
@@ -995,9 +999,9 @@ static void strip_seq_neighbours(struct seq_file *seq,
                 for (i = 0; i < table->num_nodes; i++) {
                         MetricomNode node;
 
-                        spin_lock_bh(&strip_lock);
+                        spin_lock_irqsave(&strip_lock, flags);
                         node = table->node[i];
-                        spin_unlock_bh(&strip_lock);
+                        spin_unlock_irqrestore(&strip_lock, flags);
                         seq_printf(seq, "  %s\n", node.c);
                 }
         } while (table->timestamp.tv_sec != t.tv_sec
@@ -1536,6 +1540,7 @@ 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",
@@ -1574,11 +1579,11 @@ static int strip_xmit(struct sk_buff *skb, struct net_device *dev)
                                strip_info->dev->name, sx_pps_count / 8);
         }
 
-        spin_lock_bh(&strip_lock);
+        spin_lock_irqsave(&strip_lock, flags);
 
         strip_send(strip_info, skb);
 
-        spin_unlock_bh(&strip_lock);
+        spin_unlock_irqrestore(&strip_lock, flags);
 
         if (skb)
                 dev_kfree_skb(skb);
@@ -2263,12 +2268,13 @@ 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_bh(&strip_lock);
+        spin_lock_irqsave(&strip_lock, flags);
 #if 0
         {
                 struct timeval tv;
@@ -2335,7 +2341,7 @@ static void strip_receive_buf(struct tty_struct *tty, const unsigned char *cp,
                 }
                 cp++;
         }
-        spin_unlock_bh(&strip_lock);
+        spin_unlock_irqrestore(&strip_lock, flags);
 }
 
 
@@ -2523,9 +2529,11 @@ static void strip_dev_setup(struct net_device *dev)
 
 static void strip_free(struct strip *strip_info)
 {
-        spin_lock_bh(&strip_lock);
+        unsigned long flags;
+
+        spin_lock_irqsave(&strip_lock, flags);
         list_del_rcu(&strip_info->list);
-        spin_unlock_bh(&strip_lock);
+        spin_unlock_irqrestore(&strip_lock, flags);
 
         strip_info->magic = 0;
 
@@ -2539,6 +2547,7 @@ 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;
 
@@ -2562,7 +2571,7 @@ static struct strip *strip_alloc(void)
         strip_info->idle_timer.function = strip_IdleTask;
 
 
-        spin_lock_bh(&strip_lock);
+        spin_lock_irqsave(&strip_lock, flags);
  rescan:
         /*
          * Search the list to find where to put our new entry
@@ -2581,7 +2590,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_bh(&strip_lock);
+        spin_unlock_irqrestore(&strip_lock, flags);
 
         return strip_info;
 }