super1: set RESHAPE_NO_BACKUP based on new_offset.

[thirdparty/mdadm.git] / super1.c

diff --git a/super1.c b/super1.c
index e54cd544e416cebdcc22bc5bcaa01134a94ad42f..a9ca2169bf486f7f68b6670557c071eebb621cd9 100644 (file)
--- a/super1.c
+++ b/super1.c
@@ -269,6 +269,7 @@ static void examine_super1(struct supertype *st, char *homehost)
        int l = homehost ? strlen(homehost) : 0;
        int layout;
        unsigned long long sb_offset;
+       struct mdinfo info;
 
        printf("          Magic : %08x\n", __le32_to_cpu(sb->magic));
        printf("        Version : 1");
@@ -337,6 +338,13 @@ static void examine_super1(struct supertype *st, char *homehost)
               (unsigned long long)__le64_to_cpu(sb->super_offset));
        if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)
                printf("Recovery Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->recovery_offset));
+
+       st->ss->getinfo_super(st, &info, NULL);
+       if (info.space_after != 1 &&
+           !(__le32_to_cpu(sb->feature_map) & MD_FEATURE_NEW_OFFSET))
+               printf("   Unused Space : before=%llu sectors, after=%llu sectors\n",
+                      info.space_before, info.space_after);
+
        printf("          State : %s\n", (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean");
        printf("    Device UUID : ");
        for (i=0; i<16; i++) {
@@ -396,7 +404,7 @@ static void examine_super1(struct supertype *st, char *homehost)
        if (sb->bblog_size && sb->bblog_offset) {
                printf("  Bad Block Log : %d entries available at offset %ld sectors",
                       __le16_to_cpu(sb->bblog_size)*512/8,
-                      (long)__le32_to_cpu(sb->bblog_offset));
+                      (long)(int32_t)__le32_to_cpu(sb->bblog_offset));
                if (sb->feature_map &
                    __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
                        printf(" - bad blocks present.");
@@ -998,7 +1006,8 @@ static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 
        if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
                info->reshape_active = 1;
-               if (info->array.level == 10)
+               if ((sb->feature_map & __le32_to_cpu(MD_FEATURE_NEW_OFFSET)) &&
+                   sb->new_offset != 0)
                        info->reshape_active |= RESHAPE_NO_BACKUP;
                info->reshape_progress = __le64_to_cpu(sb->reshape_position);
                info->new_level = __le32_to_cpu(sb->new_level);
@@ -1174,7 +1183,7 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
                 */
                unsigned long long sb_offset = __le64_to_cpu(sb->super_offset);
                unsigned long long data_offset = __le64_to_cpu(sb->data_offset);
-               long bitmap_offset = (long)__le64_to_cpu(sb->bitmap_offset);
+               long bitmap_offset = (long)(int32_t)__le32_to_cpu(sb->bitmap_offset);
                long bm_sectors = 0;
                long space;
 
@@ -1244,6 +1253,35 @@ static int update_super1(struct supertype *st, struct mdinfo *info,
                        misc->device_size - __le64_to_cpu(sb->data_offset));
                printf("Size is %llu\n", (unsigned long long)
                       __le64_to_cpu(sb->data_size));
+       } else if (strcmp(update, "revert-reshape") == 0) {
+               rv = -2;
+               if (!(sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)))
+                       pr_err("No active reshape to revert on %s\n",
+                              devname);
+               else {
+                       rv = 0;
+                       __u32 temp;
+                       sb->raid_disks = __cpu_to_le32(__le32_to_cpu(sb->raid_disks) +
+                                                      __le32_to_cpu(sb->delta_disks));
+                       if (sb->delta_disks == 0)
+                               sb->feature_map ^= __cpu_to_le32(MD_FEATURE_RESHAPE_BACKWARDS);
+                       else
+                               sb->delta_disks = __cpu_to_le32(-__le32_to_cpu(sb->delta_disks));
+
+                       temp = sb->new_layout;
+                       sb->new_layout = sb->layout;
+                       sb->layout = temp;
+
+                       temp = sb->new_chunk;
+                       sb->new_chunk = sb->chunksize;
+                       sb->chunksize = temp;
+
+                       if (sb->feature_map & __cpu_to_le32(MD_FEATURE_NEW_OFFSET)) {
+                               sb->data_offset = __cpu_to_le64(__le64_to_cpu(sb->data_offset) +
+                                                               (long)(int32_t)__le32_to_cpu(sb->new_offset));
+                               sb->new_offset = __cpu_to_le32(-(int32_t)__le32_to_cpu(sb->new_offset));
+                       }
+               }
        } else if (strcmp(update, "_reshape_progress")==0)
                sb->reshape_position = __cpu_to_le64(info->reshape_progress);
        else if (strcmp(update, "writemostly")==0)
@@ -2267,6 +2305,60 @@ static int validate_geometry1(struct supertype *st, int level,
 }
 #endif /* MDASSEMBLE */
 
+void *super1_make_v0(struct supertype *st, struct mdinfo *info, mdp_super_t *sb0)
+{
+       /* Create a v1.0 superblock based on 'info'*/
+       void *ret;
+       struct mdp_superblock_1 *sb;
+       int i;
+       int rfd;
+       unsigned long long offset;
+
+       if (posix_memalign(&ret, 4096, 1024) != 0)
+               return NULL;
+       sb = ret;
+       memset(ret, 0, 1024);
+       sb->magic = __cpu_to_le32(MD_SB_MAGIC);
+       sb->major_version = __cpu_to_le32(1);
+
+       copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
+       sprintf(sb->set_name, "%d", sb0->md_minor);
+       sb->ctime = __cpu_to_le32(info->array.ctime+1);
+       sb->level = __cpu_to_le32(info->array.level);
+       sb->layout = __cpu_to_le32(info->array.layout);
+       sb->size = __cpu_to_le64(info->component_size);
+       sb->chunksize = __cpu_to_le32(info->array.chunk_size/512);
+       sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
+       sb->data_size = sb->size;
+       sb->resync_offset = MaxSector;
+       sb->max_dev = __cpu_to_le32(MD_SB_DISKS);
+       sb->dev_number = __cpu_to_le32(info->disk.number);
+       sb->utime = __cpu_to_le64(info->array.utime);
+
+       offset = st->devsize/512 - 8*2;
+       offset &= ~(4*2-1);
+       sb->super_offset = __cpu_to_le64(offset);
+       //*(__u64*)(st->other + 128 + 8 + 8) = __cpu_to_le64(offset);
+
+       if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
+           read(rfd, sb->device_uuid, 16) != 16) {
+               __u32 r[4] = {random(), random(), random(), random()};
+               memcpy(sb->device_uuid, r, 16);
+       }
+       if (rfd >= 0)
+               close(rfd);
+
+       for (i = 0; i < MD_SB_DISKS; i++) {
+               int state = sb0->disks[i].state;
+               sb->dev_roles[i] = 0xFFFF;
+               if ((state & (1<<MD_DISK_SYNC)) &&
+                   !(state & (1<<MD_DISK_FAULTY)))
+                       sb->dev_roles[i] = __cpu_to_le16(sb0->disks[i].raid_disk);
+       }
+       sb->sb_csum = calc_sb_1_csum(sb);
+       return ret;
+}
+
 struct superswitch super1 = {
 #ifndef MDASSEMBLE
        .examine_super = examine_super1,