[PATCH] v4l: 669: added prolink pixelview pv bt878p rev 2e compatibility

[karo-tx-linux.git] / drivers / md / md.c

diff --git a/drivers/md/md.c b/drivers/md/md.c
index f27e8f644dfe24adc8d07db3b02e131e36d8c088..9ecf51ee596fb296f64a75f8372828e0d2701012 100644 (file)
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -74,7 +74,7 @@ static DEFINE_SPINLOCK(pers_lock);
  * Current RAID-1,4,5 parallel reconstruction 'guaranteed speed limit'
  * is 1000 KB/sec, so the extra system load does not show up that much.
  * Increase it if you want to have more _guaranteed_ speed. Note that
- * the RAID driver will use the maximum available bandwith if the IO
+ * the RAID driver will use the maximum available bandwidth if the IO
  * subsystem is idle. There is also an 'absolute maximum' reconstruction
  * speed limit - in case reconstruction slows down your system despite
  * idle IO detection.
@@ -712,6 +712,8 @@ static void super_90_sync(mddev_t *mddev, mdk_rdev_t *rdev)
        int i;
        int active=0, working=0,failed=0,spare=0,nr_disks=0;
 
+       rdev->sb_size = MD_SB_BYTES;
+
        sb = (mdp_super_t*)page_address(rdev->sb_page);
 
        memset(sb, 0, sizeof(*sb));
@@ -3061,6 +3063,7 @@ static int md_thread(void * arg)
         * many dirty RAID5 blocks.
         */
 
+       allow_signal(SIGKILL);
        complete(thread->event);
        while (!kthread_should_stop()) {
                void (*run)(mddev_t *);
@@ -3109,7 +3112,7 @@ mdk_thread_t *md_register_thread(void (*run) (mddev_t *), mddev_t *mddev,
        thread->mddev = mddev;
        thread->name = name;
        thread->timeout = MAX_SCHEDULE_TIMEOUT;
-       thread->tsk = kthread_run(md_thread, thread, mdname(thread->mddev));
+       thread->tsk = kthread_run(md_thread, thread, name, mdname(thread->mddev));
        if (IS_ERR(thread->tsk)) {
                kfree(thread);
                return NULL;
@@ -3463,8 +3466,8 @@ static int is_mddev_idle(mddev_t *mddev)
        idle = 1;
        ITERATE_RDEV(mddev,rdev,tmp) {
                struct gendisk *disk = rdev->bdev->bd_contains->bd_disk;
-               curr_events = disk_stat_read(disk, read_sectors) + 
-                               disk_stat_read(disk, write_sectors) - 
+               curr_events = disk_stat_read(disk, sectors[0]) + 
+                               disk_stat_read(disk, sectors[1]) - 
                                atomic_read(&disk->sync_io);
                /* Allow some slack between valud of curr_events and last_events,
                 * as there are some uninteresting races.
@@ -3565,8 +3568,10 @@ static void md_do_sync(mddev_t *mddev)
                mddev->curr_resync = 2;
 
        try_again:
-               if (signal_pending(current)) {
+               if (signal_pending(current) ||
+                   kthread_should_stop()) {
                        flush_signals(current);
+                       set_bit(MD_RECOVERY_INTR, &mddev->recovery);
                        goto skip;
                }
                ITERATE_MDDEV(mddev2,tmp) {
@@ -3586,8 +3591,9 @@ static void md_do_sync(mddev_t *mddev)
                                         */
                                        continue;
                                prepare_to_wait(&resync_wait, &wq, TASK_INTERRUPTIBLE);
-                               if (!signal_pending(current)
-                                   && mddev2->curr_resync >= mddev->curr_resync) {
+                               if (!signal_pending(current) &&
+                                   !kthread_should_stop() &&
+                                   mddev2->curr_resync >= mddev->curr_resync) {
                                        printk(KERN_INFO "md: delaying resync of %s"
                                               " until %s has finished resync (they"
                                               " share one or more physical units)\n",
@@ -3614,7 +3620,7 @@ static void md_do_sync(mddev_t *mddev)
        printk(KERN_INFO "md: syncing RAID array %s\n", mdname(mddev));
        printk(KERN_INFO "md: minimum _guaranteed_ reconstruction speed:"
                " %d KB/sec/disc.\n", sysctl_speed_limit_min);
-       printk(KERN_INFO "md: using maximum available idle IO bandwith "
+       printk(KERN_INFO "md: using maximum available idle IO bandwidth "
               "(but not more than %d KB/sec) for reconstruction.\n",
               sysctl_speed_limit_max);
 
@@ -3693,7 +3699,7 @@ static void md_do_sync(mddev_t *mddev)
                }
 
 
-               if (signal_pending(current)) {
+               if (signal_pending(current) || kthread_should_stop()) {
                        /*
                         * got a signal, exit.
                         */