Monitor/check_array: Centralize exit path

[thirdparty/mdadm.git] / super-intel.c

diff --git a/super-intel.c b/super-intel.c
index e13c9402a562d621489e8a19ef9a3b3dc629cb47..ba6f810e8af221b851ba73451c6886feaa0175d2 100644 (file)
--- a/super-intel.c
+++ b/super-intel.c
@@ -1383,37 +1383,46 @@ static __u32 imsm_min_reserved_sectors(struct intel_super *super)
        return  (remainder < rv) ? remainder : rv;
 }
 
-/* Return minimum size of a spare that can be used in this array*/
-static unsigned long long min_acceptable_spare_size_imsm(struct supertype *st)
+/*
+ * Return minimum size of a spare and sector size
+ * that can be used in this array
+ */
+int get_spare_criteria_imsm(struct supertype *st, struct spare_criteria *c)
 {
        struct intel_super *super = st->sb;
        struct dl *dl;
        struct extent *e;
        int i;
-       unsigned long long rv = 0;
+       unsigned long long size = 0;
+
+       c->min_size = 0;
+       c->sector_size = 0;
 
        if (!super)
-               return rv;
+               return -EINVAL;
        /* find first active disk in array */
        dl = super->disks;
        while (dl && (is_failed(&dl->disk) || dl->index == -1))
                dl = dl->next;
        if (!dl)
-               return rv;
+               return -EINVAL;
        /* find last lba used by subarrays */
        e = get_extents(super, dl);
        if (!e)
-               return rv;
+               return -EINVAL;
        for (i = 0; e[i].size; i++)
                continue;
        if (i > 0)
-               rv = e[i-1].start + e[i-1].size;
+               size = e[i-1].start + e[i-1].size;
        free(e);
 
        /* add the amount of space needed for metadata */
-       rv = rv + imsm_min_reserved_sectors(super);
+       size += imsm_min_reserved_sectors(super);
 
-       return rv * 512;
+       c->min_size = size * 512;
+       c->sector_size = super->sector_size;
+
+       return 0;
 }
 
 static int is_gen_migration(struct imsm_dev *dev);
@@ -4229,8 +4238,8 @@ static int load_imsm_mpb(int fd, struct intel_super *super, char *devname)
        sectors = mpb_sectors(anchor, sector_size) - 1;
        free(anchor);
 
-       if (posix_memalign(&super->migr_rec_buf, sector_size,
-           MIGR_REC_BUF_SECTORS*sector_size) != 0) {
+       if (posix_memalign(&super->migr_rec_buf, MAX_SECTOR_SIZE,
+           MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE) != 0) {
                pr_err("could not allocate migr_rec buffer\n");
                free(super->buf);
                return 2;
@@ -5258,8 +5267,9 @@ static int init_super_imsm_volume(struct supertype *st, mdu_array_info_t *info,
                        pr_err("could not allocate new mpb\n");
                        return 0;
                }
-               if (posix_memalign(&super->migr_rec_buf, sector_size,
-                                  MIGR_REC_BUF_SECTORS*sector_size) != 0) {
+               if (posix_memalign(&super->migr_rec_buf, MAX_SECTOR_SIZE,
+                                  MIGR_REC_BUF_SECTORS*
+                                  MAX_SECTOR_SIZE) != 0) {
                        pr_err("could not allocate migr_rec buffer\n");
                        free(super->buf);
                        free(super);
@@ -5467,6 +5477,22 @@ static int init_super_imsm(struct supertype *st, mdu_array_info_t *info,
        return 1;
 }
 
+static int drive_validate_sector_size(struct intel_super *super, struct dl *dl)
+{
+       unsigned int member_sector_size;
+
+       if (dl->fd < 0) {
+               pr_err("Invalid file descriptor for %s\n", dl->devname);
+               return 0;
+       }
+
+       if (!get_dev_sector_size(dl->fd, dl->devname, &member_sector_size))
+               return 0;
+       if (member_sector_size != super->sector_size)
+               return 0;
+       return 1;
+}
+
 static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
                                     int fd, char *devname)
 {
@@ -5506,6 +5532,11 @@ static int add_to_super_imsm_volume(struct supertype *st, mdu_disk_info_t *dk,
                return 1;
        }
 
+       if (!drive_validate_sector_size(super, dl)) {
+               pr_err("Combining drives of different sector size in one volume is not allowed\n");
+               return 1;
+       }
+
        /* add a pristine spare to the metadata */
        if (dl->index < 0) {
                dl->index = super->anchor->num_disks;
@@ -5716,21 +5747,15 @@ static int add_to_super_imsm(struct supertype *st, mdu_disk_info_t *dk,
        if (super->sector_size == 0) {
                /* this a first device, so sector_size is not set yet */
                super->sector_size = member_sector_size;
-       } else if (member_sector_size != super->sector_size) {
-               pr_err("Mixing between different sector size is forbidden, aborting...\n");
-               if (dd->devname)
-                       free(dd->devname);
-               free(dd);
-               return 1;
        }
 
        /* clear migr_rec when adding disk to container */
-       memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*super->sector_size);
-       if (lseek64(fd, size - MIGR_REC_SECTOR_POSITION*super->sector_size,
+       memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
+       if (lseek64(fd, size - MIGR_REC_SECTOR_POSITION*member_sector_size,
            SEEK_SET) >= 0) {
                if ((unsigned int)write(fd, super->migr_rec_buf,
-                   MIGR_REC_BUF_SECTORS*super->sector_size) !=
-                   MIGR_REC_BUF_SECTORS*super->sector_size)
+                   MIGR_REC_BUF_SECTORS*member_sector_size) !=
+                   MIGR_REC_BUF_SECTORS*member_sector_size)
                        perror("Write migr_rec failed");
        }
 
@@ -5922,7 +5947,7 @@ static int write_super_imsm(struct supertype *st, int doclose)
        }
        if (clear_migration_record)
                memset(super->migr_rec_buf, 0,
-                   MIGR_REC_BUF_SECTORS*sector_size);
+                   MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
 
        if (sector_size == 4096)
                convert_to_4k(super);
@@ -8445,6 +8470,9 @@ static struct dl *imsm_add_spare(struct intel_super *super, int slot,
                if (dl->index == -1 && !activate_new)
                        continue;
 
+               if (!drive_validate_sector_size(super, dl))
+                       continue;
+
                /* Does this unused device have the requisite free space?
                 * It needs to be able to cover all member volumes
                 */
@@ -10798,8 +10826,10 @@ static int imsm_reshape_is_allowed_on_container(struct supertype *st,
  */
 static struct mdinfo *get_spares_for_grow(struct supertype *st)
 {
-       unsigned long long min_size = min_acceptable_spare_size_imsm(st);
-       return container_choose_spares(st, min_size, NULL, NULL, NULL, 0);
+       struct spare_criteria sc;
+
+       get_spare_criteria_imsm(st, &sc);
+       return container_choose_spares(st, &sc, NULL, NULL, NULL, 0);
 }
 
 /******************************************************************************
@@ -11776,7 +11806,7 @@ static int imsm_manage_reshape(
        /* clear migr_rec on disks after successful migration */
        struct dl *d;
 
-       memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*sector_size);
+       memset(super->migr_rec_buf, 0, MIGR_REC_BUF_SECTORS*MAX_SECTOR_SIZE);
        for (d = super->disks; d; d = d->next) {
                if (d->index < 0 || is_failed(&d->disk))
                        continue;
@@ -11834,7 +11864,7 @@ struct superswitch super_imsm = {
        .update_super   = update_super_imsm,
 
        .avail_size     = avail_size_imsm,
-       .min_acceptable_spare_size = min_acceptable_spare_size_imsm,
+       .get_spare_criteria = get_spare_criteria_imsm,
 
        .compare_super  = compare_super_imsm,