Merge tag 'md-3.9' of git://neil.brown.name/md
authorLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Mar 2013 01:22:08 +0000 (17:22 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Wed, 6 Mar 2013 01:22:08 +0000 (17:22 -0800)
Pull md updates from NeilBrown:
 "Mostly little bugfixes.

  Only "feature" is a new RAID10 layout which slightly improves the
  number of sets of devices that can concurrently fail, without data
  loss."

* tag 'md-3.9' of git://neil.brown.name/md:
  md: expedite metadata update when switching  read-auto -> active
  md: remove CONFIG_MULTICORE_RAID456
  md/raid1,raid10: fix deadlock with freeze_array()
  md/raid0: improve error message when converting RAID4-with-spares to RAID0
  md: raid0: fix error return from create_stripe_zones.
  md: fix two bugs when attempting to resize RAID0 array.
  DM RAID: Add support for MD's RAID10 "far" and "offset" algorithms
  MD RAID10: Improve redundancy for 'far' and 'offset' algorithms (part 2)
  MD RAID10: Improve redundancy for 'far' and 'offset' algorithms (part 1)
  MD RAID10: Minor non-functional code changes
  md: raid1,10: Handle REQ_WRITE_SAME flag in write bios
  md: protect against crash upon fsync on ro array

1  2 
drivers/md/Kconfig
drivers/md/dm-raid.c
drivers/md/raid5.c

diff --combined drivers/md/Kconfig
@@@ -154,17 -154,6 +154,6 @@@ config MD_RAID45
  
          If unsure, say Y.
  
- config MULTICORE_RAID456
-       bool "RAID-4/RAID-5/RAID-6 Multicore processing (EXPERIMENTAL)"
-       depends on MD_RAID456
-       depends on SMP
-       depends on EXPERIMENTAL
-       ---help---
-         Enable the raid456 module to dispatch per-stripe raid operations to a
-         thread pool.
-         If unsure, say N.
  config MD_MULTIPATH
        tristate "Multipath I/O support"
        depends on BLK_DEV_MD
@@@ -210,7 -199,7 +199,7 @@@ config DM_DEBU
  
  config DM_BUFIO
         tristate
 -       depends on BLK_DEV_DM && EXPERIMENTAL
 +       depends on BLK_DEV_DM
         ---help---
         This interface allows you to do buffered I/O on a device and acts
         as a cache, holding recently-read blocks in memory and performing
  
  config DM_BIO_PRISON
         tristate
 -       depends on BLK_DEV_DM && EXPERIMENTAL
 +       depends on BLK_DEV_DM
         ---help---
         Some bio locking schemes used by other device-mapper targets
         including thin provisioning.
@@@ -251,8 -240,8 +240,8 @@@ config DM_SNAPSHO
           Allow volume managers to take writable snapshots of a device.
  
  config DM_THIN_PROVISIONING
 -       tristate "Thin provisioning target (EXPERIMENTAL)"
 -       depends on BLK_DEV_DM && EXPERIMENTAL
 +       tristate "Thin provisioning target"
 +       depends on BLK_DEV_DM
         select DM_PERSISTENT_DATA
         select DM_BIO_PRISON
         ---help---
@@@ -268,37 -257,6 +257,37 @@@ config DM_DEBUG_BLOCK_STACK_TRACIN
  
          If unsure, say N.
  
 +config DM_CACHE
 +       tristate "Cache target (EXPERIMENTAL)"
 +       depends on BLK_DEV_DM
 +       default n
 +       select DM_PERSISTENT_DATA
 +       select DM_BIO_PRISON
 +       ---help---
 +         dm-cache attempts to improve performance of a block device by
 +         moving frequently used data to a smaller, higher performance
 +         device.  Different 'policy' plugins can be used to change the
 +         algorithms used to select which blocks are promoted, demoted,
 +         cleaned etc.  It supports writeback and writethrough modes.
 +
 +config DM_CACHE_MQ
 +       tristate "MQ Cache Policy (EXPERIMENTAL)"
 +       depends on DM_CACHE
 +       default y
 +       ---help---
 +         A cache policy that uses a multiqueue ordered by recent hit
 +         count to select which blocks should be promoted and demoted.
 +         This is meant to be a general purpose policy.  It prioritises
 +         reads over writes.
 +
 +config DM_CACHE_CLEANER
 +       tristate "Cleaner Cache Policy (EXPERIMENTAL)"
 +       depends on DM_CACHE
 +       default y
 +       ---help---
 +         A simple cache policy that writes back all data to the
 +         origin.  Used when decommissioning a dm-cache.
 +
  config DM_MIRROR
         tristate "Mirror target"
         depends on BLK_DEV_DM
@@@ -333,8 -291,8 +322,8 @@@ config DM_RAI
         in one of the available parity distribution methods.
  
  config DM_LOG_USERSPACE
 -      tristate "Mirror userspace logging (EXPERIMENTAL)"
 -      depends on DM_MIRROR && EXPERIMENTAL && NET
 +      tristate "Mirror userspace logging"
 +      depends on DM_MIRROR && NET
        select CONNECTOR
        ---help---
          The userspace logging module provides a mechanism for
@@@ -381,8 -339,8 +370,8 @@@ config DM_MULTIPATH_S
          If unsure, say N.
  
  config DM_DELAY
 -      tristate "I/O delaying target (EXPERIMENTAL)"
 -      depends on BLK_DEV_DM && EXPERIMENTAL
 +      tristate "I/O delaying target"
 +      depends on BLK_DEV_DM
        ---help---
        A target that delays reads and/or writes and can send
        them to different devices.  Useful for testing.
@@@ -396,14 -354,14 +385,14 @@@ config DM_UEVEN
        Generate udev events for DM events.
  
  config DM_FLAKEY
 -       tristate "Flakey target (EXPERIMENTAL)"
 -       depends on BLK_DEV_DM && EXPERIMENTAL
 +       tristate "Flakey target"
 +       depends on BLK_DEV_DM
         ---help---
           A target that intermittently fails I/O for debugging purposes.
  
  config DM_VERITY
 -      tristate "Verity target support (EXPERIMENTAL)"
 -      depends on BLK_DEV_DM && EXPERIMENTAL
 +      tristate "Verity target support"
 +      depends on BLK_DEV_DM
        select CRYPTO
        select CRYPTO_HASH
        select DM_BUFIO
diff --combined drivers/md/dm-raid.c
@@@ -91,15 -91,44 +91,44 @@@ static struct raid_type 
        {"raid6_nc", "RAID6 (N continue)",              2, 4, 6, ALGORITHM_ROTATING_N_CONTINUE}
  };
  
+ static char *raid10_md_layout_to_format(int layout)
+ {
+       /*
+        * Bit 16 and 17 stand for "offset" and "use_far_sets"
+        * Refer to MD's raid10.c for details
+        */
+       if ((layout & 0x10000) && (layout & 0x20000))
+               return "offset";
+       if ((layout & 0xFF) > 1)
+               return "near";
+       return "far";
+ }
  static unsigned raid10_md_layout_to_copies(int layout)
  {
-       return layout & 0xFF;
+       if ((layout & 0xFF) > 1)
+               return layout & 0xFF;
+       return (layout >> 8) & 0xFF;
  }
  
  static int raid10_format_to_md_layout(char *format, unsigned copies)
  {
-       /* 1 "far" copy, and 'copies' "near" copies */
-       return (1 << 8) | (copies & 0xFF);
+       unsigned n = 1, f = 1;
+       if (!strcmp("near", format))
+               n = copies;
+       else
+               f = copies;
+       if (!strcmp("offset", format))
+               return 0x30000 | (f << 8) | n;
+       if (!strcmp("far", format))
+               return 0x20000 | (f << 8) | n;
+       return (f << 8) | n;
  }
  
  static struct raid_type *get_raid_type(char *name)
@@@ -352,6 -381,7 +381,7 @@@ static int validate_raid_redundancy(str
  {
        unsigned i, rebuild_cnt = 0;
        unsigned rebuilds_per_group, copies, d;
+       unsigned group_size, last_group_start;
  
        for (i = 0; i < rs->md.raid_disks; i++)
                if (!test_bit(In_sync, &rs->dev[i].rdev.flags) ||
                 * as long as the failed devices occur in different mirror
                 * groups (i.e. different stripes).
                 *
-                * Right now, we only allow for "near" copies.  When other
-                * formats are added, we will have to check those too.
-                *
                 * When checking "near" format, make sure no adjacent devices
                 * have failed beyond what can be handled.  In addition to the
                 * simple case where the number of devices is a multiple of the
                 *          A    A    B    B    C
                 *          C    D    D    E    E
                 */
-               for (i = 0; i < rs->md.raid_disks * copies; i++) {
-                       if (!(i % copies))
+               if (!strcmp("near", raid10_md_layout_to_format(rs->md.layout))) {
+                       for (i = 0; i < rs->md.raid_disks * copies; i++) {
+                               if (!(i % copies))
+                                       rebuilds_per_group = 0;
+                               d = i % rs->md.raid_disks;
+                               if ((!rs->dev[d].rdev.sb_page ||
+                                    !test_bit(In_sync, &rs->dev[d].rdev.flags)) &&
+                                   (++rebuilds_per_group >= copies))
+                                       goto too_many;
+                       }
+                       break;
+               }
+               /*
+                * When checking "far" and "offset" formats, we need to ensure
+                * that the device that holds its copy is not also dead or
+                * being rebuilt.  (Note that "far" and "offset" formats only
+                * support two copies right now.  These formats also only ever
+                * use the 'use_far_sets' variant.)
+                *
+                * This check is somewhat complicated by the need to account
+                * for arrays that are not a multiple of (far) copies.  This
+                * results in the need to treat the last (potentially larger)
+                * set differently.
+                */
+               group_size = (rs->md.raid_disks / copies);
+               last_group_start = (rs->md.raid_disks / group_size) - 1;
+               last_group_start *= group_size;
+               for (i = 0; i < rs->md.raid_disks; i++) {
+                       if (!(i % copies) && !(i > last_group_start))
                                rebuilds_per_group = 0;
-                       d = i % rs->md.raid_disks;
-                       if ((!rs->dev[d].rdev.sb_page ||
-                            !test_bit(In_sync, &rs->dev[d].rdev.flags)) &&
+                       if ((!rs->dev[i].rdev.sb_page ||
+                            !test_bit(In_sync, &rs->dev[i].rdev.flags)) &&
                            (++rebuilds_per_group >= copies))
-                               goto too_many;
+                                       goto too_many;
                }
                break;
        default:
@@@ -433,7 -487,7 +487,7 @@@ too_many
   *
   * RAID10-only options:
   *    [raid10_copies <# copies>]        Number of copies.  (Default: 2)
-  *    [raid10_format <near>]            Layout algorithm.  (Default: near)
+  *    [raid10_format <near|far|offset>] Layout algorithm.  (Default: near)
   */
  static int parse_raid_params(struct raid_set *rs, char **argv,
                             unsigned num_raid_params)
                                rs->ti->error = "'raid10_format' is an invalid parameter for this RAID type";
                                return -EINVAL;
                        }
-                       if (strcmp("near", argv[i])) {
+                       if (strcmp("near", argv[i]) &&
+                           strcmp("far", argv[i]) &&
+                           strcmp("offset", argv[i])) {
                                rs->ti->error = "Invalid 'raid10_format' value given";
                                return -EINVAL;
                        }
                        return -EINVAL;
                }
  
+               /*
+                * If the format is not "near", we only support
+                * two copies at the moment.
+                */
+               if (strcmp("near", raid10_format) && (raid10_copies > 2)) {
+                       rs->ti->error = "Too many copies for given RAID10 format.";
+                       return -EINVAL;
+               }
                /* (Len * #mirrors) / #devices */
                sectors_per_dev = rs->ti->len * raid10_copies;
                sector_div(sectors_per_dev, rs->md.raid_disks);
@@@ -854,17 -919,30 +919,30 @@@ static int super_init_validation(struc
        /*
         * Reshaping is not currently allowed
         */
-       if ((le32_to_cpu(sb->level) != mddev->level) ||
-           (le32_to_cpu(sb->layout) != mddev->layout) ||
-           (le32_to_cpu(sb->stripe_sectors) != mddev->chunk_sectors)) {
-               DMERR("Reshaping arrays not yet supported.");
+       if (le32_to_cpu(sb->level) != mddev->level) {
+               DMERR("Reshaping arrays not yet supported. (RAID level change)");
+               return -EINVAL;
+       }
+       if (le32_to_cpu(sb->layout) != mddev->layout) {
+               DMERR("Reshaping arrays not yet supported. (RAID layout change)");
+               DMERR("  0x%X vs 0x%X", le32_to_cpu(sb->layout), mddev->layout);
+               DMERR("  Old layout: %s w/ %d copies",
+                     raid10_md_layout_to_format(le32_to_cpu(sb->layout)),
+                     raid10_md_layout_to_copies(le32_to_cpu(sb->layout)));
+               DMERR("  New layout: %s w/ %d copies",
+                     raid10_md_layout_to_format(mddev->layout),
+                     raid10_md_layout_to_copies(mddev->layout));
+               return -EINVAL;
+       }
+       if (le32_to_cpu(sb->stripe_sectors) != mddev->chunk_sectors) {
+               DMERR("Reshaping arrays not yet supported. (stripe sectors change)");
                return -EINVAL;
        }
  
        /* We can only change the number of devices in RAID1 right now */
        if ((rs->raid_type->level != 1) &&
            (le32_to_cpu(sb->num_devices) != mddev->raid_disks)) {
-               DMERR("Reshaping arrays not yet supported.");
+               DMERR("Reshaping arrays not yet supported. (device count change)");
                return -EINVAL;
        }
  
@@@ -1151,7 -1229,7 +1229,7 @@@ static int raid_ctr(struct dm_target *t
  
        INIT_WORK(&rs->md.event_work, do_table_event);
        ti->private = rs;
 -      ti->num_flush_requests = 1;
 +      ti->num_flush_bios = 1;
  
        mutex_lock(&rs->md.reconfig_mutex);
        ret = md_run(&rs->md);
@@@ -1201,8 -1279,8 +1279,8 @@@ static int raid_map(struct dm_target *t
        return DM_MAPIO_SUBMITTED;
  }
  
 -static int raid_status(struct dm_target *ti, status_type_t type,
 -                     unsigned status_flags, char *result, unsigned maxlen)
 +static void raid_status(struct dm_target *ti, status_type_t type,
 +                      unsigned status_flags, char *result, unsigned maxlen)
  {
        struct raid_set *rs = ti->private;
        unsigned raid_param_cnt = 1; /* at least 1 for chunksize */
                               raid10_md_layout_to_copies(rs->md.layout));
  
                if (rs->print_flags & DMPF_RAID10_FORMAT)
-                       DMEMIT(" raid10_format near");
+                       DMEMIT(" raid10_format %s",
+                              raid10_md_layout_to_format(rs->md.layout));
  
                DMEMIT(" %d", rs->md.raid_disks);
                for (i = 0; i < rs->md.raid_disks; i++) {
                                DMEMIT(" -");
                }
        }
 -
 -      return 0;
  }
  
  static int raid_iterate_devices(struct dm_target *ti, iterate_devices_callout_fn fn, void *data)
@@@ -1403,7 -1484,7 +1482,7 @@@ static void raid_resume(struct dm_targe
  
  static struct target_type raid_target = {
        .name = "raid",
 -      .version = {1, 4, 1},
 +      .version = {1, 4, 2},
        .module = THIS_MODULE,
        .ctr = raid_ctr,
        .dtr = raid_dtr,
  
  static int __init dm_raid_init(void)
  {
+       DMINFO("Loading target version %u.%u.%u",
+              raid_target.version[0],
+              raid_target.version[1],
+              raid_target.version[2]);
        return dm_register_target(&raid_target);
  }
  
diff --combined drivers/md/raid5.c
@@@ -184,6 -184,8 +184,6 @@@ static void return_io(struct bio *retur
                return_bi = bi->bi_next;
                bi->bi_next = NULL;
                bi->bi_size = 0;
 -              trace_block_bio_complete(bdev_get_queue(bi->bi_bdev),
 -                                       bi, 0);
                bio_endio(bi, 0);
                bi = return_bi;
        }
@@@ -363,9 -365,10 +363,9 @@@ static struct stripe_head *__find_strip
                                         short generation)
  {
        struct stripe_head *sh;
 -      struct hlist_node *hn;
  
        pr_debug("__find_stripe, sector %llu\n", (unsigned long long)sector);
 -      hlist_for_each_entry(sh, hn, stripe_hash(conf, sector), hash)
 +      hlist_for_each_entry(sh, stripe_hash(conf, sector), hash)
                if (sh->sector == sector && sh->generation == generation)
                        return sh;
        pr_debug("__stripe %llu not in cache\n", (unsigned long long)sector);
@@@ -1403,7 -1406,7 +1403,7 @@@ static void ops_run_check_pq(struct str
                           &sh->ops.zero_sum_result, percpu->spare_page, &submit);
  }
  
- static void __raid_run_ops(struct stripe_head *sh, unsigned long ops_request)
+ static void raid_run_ops(struct stripe_head *sh, unsigned long ops_request)
  {
        int overlap_clear = 0, i, disks = sh->disks;
        struct dma_async_tx_descriptor *tx = NULL;
        put_cpu();
  }
  
- #ifdef CONFIG_MULTICORE_RAID456
- static void async_run_ops(void *param, async_cookie_t cookie)
- {
-       struct stripe_head *sh = param;
-       unsigned long ops_request = sh->ops.request;
-       clear_bit_unlock(STRIPE_OPS_REQ_PENDING, &sh->state);
-       wake_up(&sh->ops.wait_for_ops);
-       __raid_run_ops(sh, ops_request);
-       release_stripe(sh);
- }
- static void raid_run_ops(struct stripe_head *sh, unsigned long ops_request)
- {
-       /* since handle_stripe can be called outside of raid5d context
-        * we need to ensure sh->ops.request is de-staged before another
-        * request arrives
-        */
-       wait_event(sh->ops.wait_for_ops,
-                  !test_and_set_bit_lock(STRIPE_OPS_REQ_PENDING, &sh->state));
-       sh->ops.request = ops_request;
-       atomic_inc(&sh->count);
-       async_schedule(async_run_ops, sh);
- }
- #else
- #define raid_run_ops __raid_run_ops
- #endif
  static int grow_one_stripe(struct r5conf *conf)
  {
        struct stripe_head *sh;
                return 0;
  
        sh->raid_conf = conf;
-       #ifdef CONFIG_MULTICORE_RAID456
-       init_waitqueue_head(&sh->ops.wait_for_ops);
-       #endif
  
        spin_lock_init(&sh->stripe_lock);
  
@@@ -1627,9 -1597,6 +1594,6 @@@ static int resize_stripes(struct r5con
                        break;
  
                nsh->raid_conf = conf;
-               #ifdef CONFIG_MULTICORE_RAID456
-               init_waitqueue_head(&nsh->ops.wait_for_ops);
-               #endif
                spin_lock_init(&nsh->stripe_lock);
  
                list_add(&nsh->lru, &newstripes);
@@@ -3914,6 -3881,8 +3878,6 @@@ static void raid5_align_endio(struct bi
        rdev_dec_pending(rdev, conf->mddev);
  
        if (!error && uptodate) {
 -              trace_block_bio_complete(bdev_get_queue(raid_bi->bi_bdev),
 -                                       raid_bi, 0);
                bio_endio(raid_bi, 0);
                if (atomic_dec_and_test(&conf->active_aligned_reads))
                        wake_up(&conf->wait_for_stripe);
@@@ -4372,6 -4341,8 +4336,6 @@@ static void make_request(struct mddev *
                if ( rw == WRITE )
                        md_write_end(mddev);
  
 -              trace_block_bio_complete(bdev_get_queue(bi->bi_bdev),
 -                                       bi, 0);
                bio_endio(bi, 0);
        }
  }
@@@ -4748,8 -4719,11 +4712,8 @@@ static int  retry_aligned_read(struct r
                handled++;
        }
        remaining = raid5_dec_bi_active_stripes(raid_bio);
 -      if (remaining == 0) {
 -              trace_block_bio_complete(bdev_get_queue(raid_bio->bi_bdev),
 -                                       raid_bio, 0);
 +      if (remaining == 0)
                bio_endio(raid_bio, 0);
 -      }
        if (atomic_dec_and_test(&conf->active_aligned_reads))
                wake_up(&conf->wait_for_stripe);
        return handled;