mtd: fix a huge latency problem in the MTD CFI and LPDDR flash drivers.

The use of a memcpy() during a spinlock operation will cause very long
thread context switch delays if the flash chip bandwidth is low and the
data to be copied large, because a spinlock will disable preemption.

For example: A flash with 6,5 MB/s bandwidth will cause under ubifs,
which request sometimes 128 KiB (the flash erase size), a preemption delay of
20 milliseconds. High priority threads will not be served during this
time, regardless whether this threads access the flash or not. This behavior
breaks real time.

The patch changes all the use of spin_lock operations for xxxx->mutex
into mutex operations, which is exact what the name says and means.

I have checked the code of the drivers and there is no use of atomic
pathes like interrupt or timers. The mtdoops facility will also not be used
by this drivers. So it is dave to replace the spin_lock against mutex.

There is no performance regression since the mutex is normally not
acquired.

Changelog:
 06.03.2010 First release
 26.03.2010 Fix mutex[1] issue and tested it for compile failure

Signed-off-by: Stefani Seibold <stefani@seibold.net>
Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Signed-off-by: David Woodhouse <David.Woodhouse@intel.com>

1 files changed, 68 insertions, 68 deletions

diff --git a/drivers/mtd/chips/cfi_cmdset_0020.c b/drivers/mtd/chips/cfi_cmdset_0020.c
index 0667a671525d..e54e8c169d76 100644
--- a/drivers/mtd/chips/cfi_cmdset_0020.c
+++ b/drivers/mtd/chips/cfi_cmdset_0020.c
@@ -265,7 +265,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
         timeo = jiffies + HZ;
  retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us.
          * If it's in FL_ERASING state, suspend it and make it talk now.
@@ -296,15 +296,15 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
                                 /* make sure we're in 'read status' mode */
                                 map_write(map, CMD(0x70), cmd_addr);
                                 chip->state = FL_ERASING;
-                                spin_unlock_bh(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 printk(KERN_ERR "Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", status.x[0]);
                                 return -EIO;
                         }
 
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         cfi_udelay(1);
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                 }
 
                 suspended = 1;
@@ -335,13 +335,13 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in read. WSM status = %lx\n", status.x[0]);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -351,7 +351,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -376,7 +376,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
         }
 
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 
@@ -445,7 +445,7 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
 #ifdef DEBUG_CFI_FEATURES
        printk("%s: chip->state[%d]\n", __func__, chip->state);
 #endif
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us.
          * Later, we can actually think about interrupting it
@@ -470,14 +470,14 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         break;
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in buffer write Xstatus = %lx, status = %lx\n",
                                status.x[0], map_read(map, cmd_adr).x[0]);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -486,7 +486,7 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -503,16 +503,16 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                 if (map_word_andequal(map, status, status_OK, status_OK))
                         break;
 
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (++z > 100) {
                         /* Argh. Not ready for write to buffer */
                         DISABLE_VPP(map);
                         map_write(map, CMD(0x70), cmd_adr);
                         chip->state = FL_STATUS;
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "Chip not ready for buffer write. Xstatus = %lx\n", status.x[0]);
                         return -EIO;
                 }
@@ -532,9 +532,9 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
         map_write(map, CMD(0xd0), cmd_adr);
         chip->state = FL_WRITING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         cfi_udelay(chip->buffer_write_time);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         timeo = jiffies + (HZ/2);
         z = 0;
@@ -543,11 +543,11 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         /* Someone's suspended the write. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ / 2); /* FIXME */
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -563,16 +563,16 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                         map_write(map, CMD(0x70), adr);
                         chip->state = FL_STATUS;
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in bufwrite\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 z++;
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
         if (!z) {
                 chip->buffer_write_time--;
@@ -596,11 +596,11 @@ static inline int do_write_buffer(struct map_info *map, struct flchip *chip,
                 /* put back into read status register mode */
                 map_write(map, CMD(0x70), adr);
                 wake_up(&chip->wq);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 return map_word_bitsset(map, status, CMD(0x02)) ? -EROFS : -EIO;
         }
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
 
         return 0;
 }
@@ -749,7 +749,7 @@ static inline int do_erase_oneblock(struct map_info *map, struct flchip *chip, u
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -766,13 +766,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in erase\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -781,7 +781,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -797,9 +797,9 @@ retry:
         map_write(map, CMD(0xD0), adr);
         chip->state = FL_ERASING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -810,11 +810,11 @@ retry:
                         /* Someone's suspended the erase. Sleep */
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
                         timeo = jiffies + (HZ*20); /* FIXME */
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
                         continue;
                 }
 
@@ -828,14 +828,14 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for erase to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         DISABLE_VPP(map);
@@ -878,7 +878,7 @@ retry:
                                 printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x. Retrying...\n", adr, chipstatus);
                                 timeo = jiffies + HZ;
                                 chip->state = FL_STATUS;
-                                spin_unlock_bh(chip->mutex);
+                                mutex_unlock(&chip->mutex);
                                 goto retry;
                         }
                         printk(KERN_DEBUG "Chip erase failed at 0x%08lx: status 0x%x\n", adr, chipstatus);
@@ -887,7 +887,7 @@ retry:
         }
 
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return ret;
 }
 
@@ -995,7 +995,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                 chip = &cfi->chips[i];
 
         retry:
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1009,7 +1009,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                          * with the chip now anyway.
                          */
                 case FL_SYNCING:
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         break;
 
                 default:
@@ -1017,7 +1017,7 @@ static void cfi_staa_sync (struct mtd_info *mtd)
                         set_current_state(TASK_UNINTERRUPTIBLE);
                         add_wait_queue(&chip->wq, &wait);
 
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         schedule();
                         remove_wait_queue(&chip->wq, &wait);
 
@@ -1030,13 +1030,13 @@ static void cfi_staa_sync (struct mtd_info *mtd)
         for (i--; i >=0; i--) {
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 if (chip->state == FL_SYNCING) {
                         chip->state = chip->oldstate;
                         wake_up(&chip->wq);
                 }
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }
 
@@ -1054,7 +1054,7 @@ static inline int do_lock_oneblock(struct map_info *map, struct flchip *chip, un
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -1071,13 +1071,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in lock\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -1086,7 +1086,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -1098,9 +1098,9 @@ retry:
         map_write(map, CMD(0x01), adr);
         chip->state = FL_LOCKING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -1118,21 +1118,21 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for lock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         /* Done and happy. */
         chip->state = FL_STATUS;
         DISABLE_VPP(map);
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 static int cfi_staa_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
@@ -1203,7 +1203,7 @@ static inline int do_unlock_oneblock(struct map_info *map, struct flchip *chip,
 
         timeo = jiffies + HZ;
 retry:
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* Check that the chip's ready to talk to us. */
         switch (chip->state) {
@@ -1220,13 +1220,13 @@ retry:
 
                 /* Urgh. Chip not yet ready to talk to us. */
                 if (time_after(jiffies, timeo)) {
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         printk(KERN_ERR "waiting for chip to be ready timed out in unlock\n");
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the lock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
                 goto retry;
 
@@ -1235,7 +1235,7 @@ retry:
                    someone changes the status */
                 set_current_state(TASK_UNINTERRUPTIBLE);
                 add_wait_queue(&chip->wq, &wait);
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 schedule();
                 remove_wait_queue(&chip->wq, &wait);
                 timeo = jiffies + HZ;
@@ -1247,9 +1247,9 @@ retry:
         map_write(map, CMD(0xD0), adr);
         chip->state = FL_UNLOCKING;
 
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         msleep(1000);
-        spin_lock_bh(chip->mutex);
+        mutex_lock(&chip->mutex);
 
         /* FIXME. Use a timer to check this, and return immediately. */
         /* Once the state machine's known to be working I'll do that */
@@ -1267,21 +1267,21 @@ retry:
                         chip->state = FL_STATUS;
                         printk(KERN_ERR "waiting for unlock to complete timed out. Xstatus = %lx, status = %lx.\n", status.x[0], map_read(map, adr).x[0]);
                         DISABLE_VPP(map);
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                         return -EIO;
                 }
 
                 /* Latency issues. Drop the unlock, wait a while and retry */
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
                 cfi_udelay(1);
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
         }
 
         /* Done and happy. */
         chip->state = FL_STATUS;
         DISABLE_VPP(map);
         wake_up(&chip->wq);
-        spin_unlock_bh(chip->mutex);
+        mutex_unlock(&chip->mutex);
         return 0;
 }
 static int cfi_staa_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
@@ -1334,7 +1334,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
         for (i=0; !ret && i<cfi->numchips; i++) {
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 switch(chip->state) {
                 case FL_READY:
@@ -1354,7 +1354,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                         ret = -EAGAIN;
                         break;
                 }
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 
         /* Unlock the chips again */
@@ -1363,7 +1363,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                 for (i--; i >=0; i--) {
                         chip = &cfi->chips[i];
 
-                        spin_lock_bh(chip->mutex);
+                        mutex_lock(&chip->mutex);
 
                         if (chip->state == FL_PM_SUSPENDED) {
                                 /* No need to force it into a known state here,
@@ -1372,7 +1372,7 @@ static int cfi_staa_suspend(struct mtd_info *mtd)
                                 chip->state = chip->oldstate;
                                 wake_up(&chip->wq);
                         }
-                        spin_unlock_bh(chip->mutex);
+                        mutex_unlock(&chip->mutex);
                 }
         }
 
@@ -1390,7 +1390,7 @@ static void cfi_staa_resume(struct mtd_info *mtd)
 
                 chip = &cfi->chips[i];
 
-                spin_lock_bh(chip->mutex);
+                mutex_lock(&chip->mutex);
 
                 /* Go to known state. Chip may have been power cycled */
                 if (chip->state == FL_PM_SUSPENDED) {
@@ -1399,7 +1399,7 @@ static void cfi_staa_resume(struct mtd_info *mtd)
                         wake_up(&chip->wq);
                 }
 
-                spin_unlock_bh(chip->mutex);
+                mutex_unlock(&chip->mutex);
         }
 }