md: remove needless setting of thread->timeout in raid10_quiesce

[safe/jmp/linux-2.6] / drivers / md / bitmap.c

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 60e2b32..b1bcd36 100644 (file)
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -287,27 +287,28 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
 
        while ((rdev = next_active_rdev(rdev, mddev)) != NULL) {
                        int size = PAGE_SIZE;
+                       long offset = mddev->bitmap_info.offset;
                        if (page->index == bitmap->file_pages-1)
                                size = roundup(bitmap->last_page_size,
                                               bdev_logical_block_size(rdev->bdev));
                        /* Just make sure we aren't corrupting data or
                         * metadata
                         */
-                       if (bitmap->offset < 0) {
+                       if (offset < 0) {
                                /* DATA  BITMAP METADATA  */
-                               if (bitmap->offset
+                               if (offset
                                    + (long)(page->index * (PAGE_SIZE/512))
                                    + size/512 > 0)
                                        /* bitmap runs in to metadata */
                                        goto bad_alignment;
                                if (rdev->data_offset + mddev->dev_sectors
-                                   > rdev->sb_start + bitmap->offset)
+                                   > rdev->sb_start + offset)
                                        /* data runs in to bitmap */
                                        goto bad_alignment;
                        } else if (rdev->sb_start < rdev->data_offset) {
                                /* METADATA BITMAP DATA */
                                if (rdev->sb_start
-                                   + bitmap->offset
+                                   + offset
                                    + page->index*(PAGE_SIZE/512) + size/512
                                    > rdev->data_offset)
                                        /* bitmap runs in to data */
@@ -316,7 +317,7 @@ static int write_sb_page(struct bitmap *bitmap, struct page *page, int wait)
                                /* DATA METADATA BITMAP - no problems */
                        }
                        md_super_write(mddev, rdev,
-                                      rdev->sb_start + bitmap->offset
+                                      rdev->sb_start + offset
                                       + page->index * (PAGE_SIZE/512),
                                       size,
                                       page);
@@ -550,7 +551,8 @@ static int bitmap_read_sb(struct bitmap *bitmap)
 
                bitmap->sb_page = read_page(bitmap->file, 0, bitmap, bytes);
        } else {
-               bitmap->sb_page = read_sb_page(bitmap->mddev, bitmap->offset,
+               bitmap->sb_page = read_sb_page(bitmap->mddev,
+                                              bitmap->mddev->bitmap_info.offset,
                                               NULL,
                                               0, sizeof(bitmap_super_t));
        }
@@ -563,7 +565,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
        sb = (bitmap_super_t *)kmap_atomic(bitmap->sb_page, KM_USER0);
 
        chunksize = le32_to_cpu(sb->chunksize);
-       daemon_sleep = le32_to_cpu(sb->daemon_sleep);
+       daemon_sleep = le32_to_cpu(sb->daemon_sleep) * HZ;
        write_behind = le32_to_cpu(sb->write_behind);
 
        /* verify that the bitmap-specific fields are valid */
@@ -576,7 +578,7 @@ static int bitmap_read_sb(struct bitmap *bitmap)
                reason = "bitmap chunksize too small";
        else if ((1 << ffz(~chunksize)) != chunksize)
                reason = "bitmap chunksize not a power of 2";
-       else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT / HZ)
+       else if (daemon_sleep < 1 || daemon_sleep > MAX_SCHEDULE_TIMEOUT)
                reason = "daemon sleep period out of range";
        else if (write_behind > COUNTER_MAX)
                reason = "write-behind limit out of range (0 - 16383)";
@@ -610,10 +612,10 @@ static int bitmap_read_sb(struct bitmap *bitmap)
        }
 success:
        /* assign fields using values from superblock */
-       bitmap->chunksize = chunksize;
-       bitmap->daemon_sleep = daemon_sleep;
+       bitmap->mddev->bitmap_info.chunksize = chunksize;
+       bitmap->mddev->bitmap_info.daemon_sleep = daemon_sleep;
        bitmap->daemon_lastrun = jiffies;
-       bitmap->max_write_behind = write_behind;
+       bitmap->mddev->bitmap_info.max_write_behind = write_behind;
        bitmap->flags |= le32_to_cpu(sb->state);
        if (le32_to_cpu(sb->version) == BITMAP_MAJOR_HOSTENDIAN)
                bitmap->flags |= BITMAP_HOSTENDIAN;
@@ -907,7 +909,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
        chunks = bitmap->chunks;
        file = bitmap->file;
 
-       BUG_ON(!file && !bitmap->offset);
+       BUG_ON(!file && !bitmap->mddev->bitmap_info.offset);
 
 #ifdef INJECT_FAULTS_3
        outofdate = 1;
@@ -967,14 +969,15 @@ static int bitmap_init_from_disk(struct bitmap *bitmap, sector_t start)
                                offset = sizeof(bitmap_super_t);
                                if (!file)
                                        read_sb_page(bitmap->mddev,
-                                                    bitmap->offset,
+                                                    bitmap->mddev->bitmap_info.offset,
                                                     page,
                                                     index, count);
                        } else if (file) {
                                page = read_page(file, index, bitmap, count);
                                offset = 0;
                        } else {
-                               page = read_sb_page(bitmap->mddev, bitmap->offset,
+                               page = read_sb_page(bitmap->mddev,
+                                                   bitmap->mddev->bitmap_info.offset,
                                                    NULL,
                                                    index, count);
                                offset = 0;
@@ -1078,23 +1081,32 @@ static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
  *                     out to disk
  */
 
-void bitmap_daemon_work(struct bitmap *bitmap)
+void bitmap_daemon_work(mddev_t *mddev)
 {
+       struct bitmap *bitmap;
        unsigned long j;
        unsigned long flags;
        struct page *page = NULL, *lastpage = NULL;
        int blocks;
        void *paddr;
 
-       if (bitmap == NULL)
+       /* Use a mutex to guard daemon_work against
+        * bitmap_destroy.
+        */
+       mutex_lock(&mddev->bitmap_info.mutex);
+       bitmap = mddev->bitmap;
+       if (bitmap == NULL) {
+               mutex_unlock(&mddev->bitmap_info.mutex);
                return;
-       if (time_before(jiffies, bitmap->daemon_lastrun + bitmap->daemon_sleep*HZ))
+       }
+       if (time_before(jiffies, bitmap->daemon_lastrun
+                       + bitmap->mddev->bitmap_info.daemon_sleep))
                goto done;
 
        bitmap->daemon_lastrun = jiffies;
        if (bitmap->allclean) {
                bitmap->mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
-               return;
+               goto done;
        }
        bitmap->allclean = 1;
 
@@ -1202,7 +1214,9 @@ void bitmap_daemon_work(struct bitmap *bitmap)
 
  done:
        if (bitmap->allclean == 0)
-               bitmap->mddev->thread->timeout = bitmap->daemon_sleep * HZ;
+               bitmap->mddev->thread->timeout = 
+                       bitmap->mddev->bitmap_info.daemon_sleep;
+       mutex_unlock(&mddev->bitmap_info.mutex);
 }
 
 static bitmap_counter_t *bitmap_get_counter(struct bitmap *bitmap,
@@ -1470,7 +1484,7 @@ void bitmap_cond_end_sync(struct bitmap *bitmap, sector_t sector)
                return;
        }
        if (time_before(jiffies, (bitmap->last_end_sync
-                                 + bitmap->daemon_sleep * HZ)))
+                                 + bitmap->mddev->bitmap_info.daemon_sleep)))
                return;
        wait_event(bitmap->mddev->recovery_wait,
                   atomic_read(&bitmap->mddev->recovery_active) == 0);
@@ -1531,7 +1545,7 @@ void bitmap_dirty_bits(struct bitmap *bitmap, unsigned long s, unsigned long e)
 void bitmap_flush(mddev_t *mddev)
 {
        struct bitmap *bitmap = mddev->bitmap;
-       int sleep;
+       long sleep;
 
        if (!bitmap) /* there was no bitmap */
                return;
@@ -1539,12 +1553,13 @@ void bitmap_flush(mddev_t *mddev)
        /* run the daemon_work three time to ensure everything is flushed
         * that can be
         */
-       sleep = bitmap->daemon_sleep;
-       bitmap->daemon_sleep = 0;
-       bitmap_daemon_work(bitmap);
-       bitmap_daemon_work(bitmap);
-       bitmap_daemon_work(bitmap);
-       bitmap->daemon_sleep = sleep;
+       sleep = mddev->bitmap_info.daemon_sleep * 2;
+       bitmap->daemon_lastrun -= sleep;
+       bitmap_daemon_work(mddev);
+       bitmap->daemon_lastrun -= sleep;
+       bitmap_daemon_work(mddev);
+       bitmap->daemon_lastrun -= sleep;
+       bitmap_daemon_work(mddev);
        bitmap_update_sb(bitmap);
 }
 
@@ -1574,6 +1589,7 @@ static void bitmap_free(struct bitmap *bitmap)
        kfree(bp);
        kfree(bitmap);
 }
+
 void bitmap_destroy(mddev_t *mddev)
 {
        struct bitmap *bitmap = mddev->bitmap;
@@ -1581,7 +1597,9 @@ void bitmap_destroy(mddev_t *mddev)
        if (!bitmap) /* there was no bitmap */
                return;
 
+       mutex_lock(&mddev->bitmap_info.mutex);
        mddev->bitmap = NULL; /* disconnect from the md device */
+       mutex_unlock(&mddev->bitmap_info.mutex);
        if (mddev->thread)
                mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
 
@@ -1598,16 +1616,16 @@ int bitmap_create(mddev_t *mddev)
        sector_t blocks = mddev->resync_max_sectors;
        unsigned long chunks;
        unsigned long pages;
-       struct file *file = mddev->bitmap_file;
+       struct file *file = mddev->bitmap_info.file;
        int err;
        sector_t start;
 
        BUILD_BUG_ON(sizeof(bitmap_super_t) != 256);
 
-       if (!file && !mddev->bitmap_offset) /* bitmap disabled, nothing to do */
+       if (!file && !mddev->bitmap_info.offset) /* bitmap disabled, nothing to do */
                return 0;
 
-       BUG_ON(file && mddev->bitmap_offset);
+       BUG_ON(file && mddev->bitmap_info.offset);
 
        bitmap = kzalloc(sizeof(*bitmap), GFP_KERNEL);
        if (!bitmap)
@@ -1621,7 +1639,6 @@ int bitmap_create(mddev_t *mddev)
        bitmap->mddev = mddev;
 
        bitmap->file = file;
-       bitmap->offset = mddev->bitmap_offset;
        if (file) {
                get_file(file);
                /* As future accesses to this file will use bmap,
@@ -1630,12 +1647,12 @@ int bitmap_create(mddev_t *mddev)
                 */
                vfs_fsync(file, file->f_dentry, 1);
        }
-       /* read superblock from bitmap file (this sets bitmap->chunksize) */
+       /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
        err = bitmap_read_sb(bitmap);
        if (err)
                goto error;
 
-       bitmap->chunkshift = ffz(~bitmap->chunksize);
+       bitmap->chunkshift = ffz(~mddev->bitmap_info.chunksize);
 
        /* now that chunksize and chunkshift are set, we can use these macros */
        chunks = (blocks + CHUNK_BLOCK_RATIO(bitmap) - 1) >>
@@ -1677,7 +1694,8 @@ int bitmap_create(mddev_t *mddev)
 
        mddev->bitmap = bitmap;
 
-       mddev->thread->timeout = bitmap->daemon_sleep * HZ;
+       mddev->thread->timeout = mddev->bitmap_info.daemon_sleep;
+       md_wakeup_thread(mddev->thread);
 
        bitmap_update_sb(bitmap);