[PATCH] md: replace magic numbers in sb_dirty with well defined bit flags

Instead of magic numbers (0,1,2,3) in sb_dirty, we have
some flags instead:
MD_CHANGE_DEVS
   Some device state has changed requiring superblock update
   on all devices.
MD_CHANGE_CLEAN
   The array has transitions from 'clean' to 'dirty' or back,
   requiring a superblock update on active devices, but possibly
   not on spares
MD_CHANGE_PENDING
   A superblock update is underway.

We wait for an update to complete by waiting for all flags to be clear.  A
flag can be set at any time, even during an update, without risk that the
change will be lost.

Stop exporting md_update_sb - isn't needed.

Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

7 files changed, 52 insertions, 46 deletions

diff --git a/drivers/md/md.c b/drivers/md/md.c
index 3af6f1f06020..8b08043f07ef 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1587,7 +1587,7 @@ static void sync_sbs(mddev_t * mddev, int nospares)
         }
 }
 
-void md_update_sb(mddev_t * mddev)
+static void md_update_sb(mddev_t * mddev, int force_change)
 {
         int err;
         struct list_head *tmp;
@@ -1598,7 +1598,18 @@ void md_update_sb(mddev_t * mddev)
 repeat:
         spin_lock_irq(&mddev->write_lock);
 
-        if (mddev->degraded && mddev->sb_dirty == 3)
+        set_bit(MD_CHANGE_PENDING, &mddev->flags);
+        if (test_and_clear_bit(MD_CHANGE_DEVS, &mddev->flags))
+                force_change = 1;
+        if (test_and_clear_bit(MD_CHANGE_CLEAN, &mddev->flags))
+                /* just a clean<-> dirty transition, possibly leave spares alone,
+                 * though if events isn't the right even/odd, we will have to do
+                 * spares after all
+                 */
+                nospares = 1;
+        if (force_change)
+                nospares = 0;
+        if (mddev->degraded)
                 /* If the array is degraded, then skipping spares is both
                  * dangerous and fairly pointless.
                  * Dangerous because a device that was removed from the array
@@ -1608,20 +1619,14 @@ repeat:
                  * then a recovery will happen and soon that array won't
                  * be degraded any more and the spare can go back to sleep then.
                  */
-                mddev->sb_dirty = 1;
+                nospares = 0;
 
         sync_req = mddev->in_sync;
         mddev->utime = get_seconds();
-        if (mddev->sb_dirty == 3)
-                /* just a clean<-> dirty transition, possibly leave spares alone,
-                 * though if events isn't the right even/odd, we will have to do
-                 * spares after all
-                 */
-                nospares = 1;
 
         /* If this is just a dirty<->clean transition, and the array is clean
          * and 'events' is odd, we can roll back to the previous clean state */
-        if (mddev->sb_dirty == 3
+        if (nospares
             && (mddev->in_sync && mddev->recovery_cp == MaxSector)
             && (mddev->events & 1))
                 mddev->events--;
@@ -1652,7 +1657,6 @@ repeat:
                 MD_BUG();
                 mddev->events --;
         }
-        mddev->sb_dirty = 2;
         sync_sbs(mddev, nospares);
 
         /*
@@ -1660,7 +1664,7 @@ repeat:
          * nonpersistent superblocks
          */
         if (!mddev->persistent) {
-                mddev->sb_dirty = 0;
+                clear_bit(MD_CHANGE_PENDING, &mddev->flags);
                 spin_unlock_irq(&mddev->write_lock);
                 wake_up(&mddev->sb_wait);
                 return;
@@ -1697,20 +1701,20 @@ repeat:
                         break;
         }
         md_super_wait(mddev);
-        /* if there was a failure, sb_dirty was set to 1, and we re-write super */
+        /* if there was a failure, MD_CHANGE_DEVS was set, and we re-write super */
 
         spin_lock_irq(&mddev->write_lock);
-        if (mddev->in_sync != sync_req|| mddev->sb_dirty == 1) {
+        if (mddev->in_sync != sync_req ||
+            test_bit(MD_CHANGE_DEVS, &mddev->flags)) {
                 /* have to write it out again */
                 spin_unlock_irq(&mddev->write_lock);
                 goto repeat;
         }
-        mddev->sb_dirty = 0;
+        clear_bit(MD_CHANGE_PENDING, &mddev->flags);
         spin_unlock_irq(&mddev->write_lock);
         wake_up(&mddev->sb_wait);
 
 }
-EXPORT_SYMBOL_GPL(md_update_sb);
 
 /* words written to sysfs files may, or my not, be \n terminated.
  * We want to accept with case. For this we use cmd_match.
@@ -1783,7 +1787,7 @@ state_store(mdk_rdev_t *rdev, const char *buf, size_t len)
                 else {
                         mddev_t *mddev = rdev->mddev;
                         kick_rdev_from_array(rdev);
-                        md_update_sb(mddev);
+                        md_update_sb(mddev, 1);
                         md_new_event(mddev);
                         err = 0;
                 }
@@ -2426,7 +2430,7 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
                         spin_lock_irq(&mddev->write_lock);
                         if (atomic_read(&mddev->writes_pending) == 0) {
                                 mddev->in_sync = 1;
-                                mddev->sb_dirty = 1;
+                                set_bit(MD_CHANGE_CLEAN, &mddev->flags);
                         }
                         spin_unlock_irq(&mddev->write_lock);
                 } else {
@@ -2438,7 +2442,7 @@ array_state_store(mddev_t *mddev, const char *buf, size_t len)
         case active:
                 if (mddev->pers) {
                         restart_array(mddev);
-                        mddev->sb_dirty = 0;
+                        clear_bit(MD_CHANGE_CLEAN, &mddev->flags);
                         wake_up(&mddev->sb_wait);
                         err = 0;
                 } else {
@@ -2543,7 +2547,7 @@ size_store(mddev_t *mddev, const char *buf, size_t len)
 
         if (mddev->pers) {
                 err = update_size(mddev, size);
-                md_update_sb(mddev);
+                md_update_sb(mddev, 1);
         } else {
                 if (mddev->size == 0 ||
                     mddev->size > size)
@@ -3111,8 +3115,8 @@ static int do_md_run(mddev_t * mddev)
         
         set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
         
-        if (mddev->sb_dirty)
-                md_update_sb(mddev);
+        if (mddev->flags)
+                md_update_sb(mddev, 0);
 
         set_capacity(disk, mddev->array_size<<1);
 
@@ -3275,10 +3279,10 @@ static int do_md_stop(mddev_t * mddev, int mode)
                         if (mddev->ro)
                                 mddev->ro = 0;
                 }
-                if (!mddev->in_sync || mddev->sb_dirty) {
+                if (!mddev->in_sync || mddev->flags) {
                         /* mark array as shutdown cleanly */