monitor: Make sure that last_checkpoint is set to 0 after sync

[thirdparty/mdadm.git] / super0.c

diff --git a/super0.c b/super0.c
index e4bbe3e1a0f9585c5d65b4e4813c8a2aeaae574e..467a37373d83dda63fd46297a9b7e066c3e26b94 100644 (file)
--- a/super0.c
+++ b/super0.c
@@ -36,7 +36,6 @@
  * .. other stuff
  */
 
-
 static unsigned long calc_sb0_csum(mdp_super_t *super)
 {
        unsigned long csum = super->sb_csum;
@@ -406,7 +405,8 @@ static void getinfo_super0(struct supertype *st, struct mdinfo *info, char *map)
        info->array.utime = sb->utime;
        info->array.chunk_size = sb->chunk_size;
        info->array.state = sb->state;
-       info->component_size = sb->size*2;
+       info->component_size = sb->size;
+       info->component_size *= 2;
 
        if (sb->state & (1<<MD_SB_BITMAP_PRESENT))
                info->bitmap_offset = 8;
@@ -651,11 +651,21 @@ static int update_super0(struct supertype *st, struct mdinfo *info,
                        pr_err("No active reshape to revert on %s\n",
                               devname);
                else if (sb->delta_disks == 0)
-                       pr_err("%s: Can on revert reshape which changes number of devices\n",
+                       pr_err("%s: Can only revert reshape which changes number of devices\n",
                               devname);
                else {
                        int tmp;
+                       int parity = sb->level == 6 ? 2 : 1;
                        rv = 0;
+
+                       if (sb->level >= 4 && sb->level <= 6 &&
+                           sb->reshape_position % (
+                                   sb->new_chunk/512 *
+                                   (sb->raid_disks - sb->delta_disks - parity))) {
+                               pr_err("Reshape position is not suitably aligned.\n");
+                               pr_err("Try normal assembly and stop again\n");
+                               return -2;
+                       }
                        sb->raid_disks -= sb->delta_disks;
                        sb->delta_disks = -sb->delta_disks;
 
@@ -690,7 +700,6 @@ static int update_super0(struct supertype *st, struct mdinfo *info,
  * host name
  */
 
-
 static int init_super0(struct supertype *st, mdu_array_info_t *info,
                       unsigned long long size, char *ignored_name, char *homehost,
                       int *uuid, unsigned long long data_offset)
@@ -705,7 +714,7 @@ static int init_super0(struct supertype *st, mdu_array_info_t *info,
 
        if (posix_memalign((void**)&sb, 4096,
                           MD_SB_BYTES + ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
-               pr_err("%s could not allocate superblock\n", __func__);
+               pr_err("could not allocate superblock\n");
                return 0;
        }
        memset(sb, 0, MD_SB_BYTES + sizeof(bitmap_super_t));
@@ -797,9 +806,8 @@ static int add_to_super0(struct supertype *st, mdu_disk_info_t *dinfo,
        dk->major = dinfo->major;
        dk->minor = dinfo->minor;
        dk->raid_disk = dinfo->raid_disk;
-       dk->state = dinfo->state;
-       /* In case our source disk was writemostly, don't copy that bit */
-       dk->state &= ~(1<<MD_DISK_WRITEMOSTLY);
+       dk->state = dinfo->state & ((1<<MD_DISK_ACTIVE) |
+                                   (1<<MD_DISK_SYNC));
 
        sb->this_disk = sb->disks[dinfo->number];
        sb->sb_csum = calc_sb0_csum(sb);
@@ -832,7 +840,7 @@ static int store_super0(struct supertype *st, int fd)
 
        if (st->other) {
                /* Writing out v1.0 metadata for --update=metadata */
-               int ret;
+               int ret = 0;
 
                offset = dsize/512 - 8*2;
                offset &= ~(4*2-1);
@@ -861,7 +869,7 @@ static int store_super0(struct supertype *st, int fd)
        if (super->state & (1<<MD_SB_BITMAP_PRESENT)) {
                struct bitmap_super_s * bm = (struct bitmap_super_s*)(super+1);
                if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC)
-                       if (write(fd, bm, ROUND_UP(sizeof(*bm),4096)) != 
+                       if (write(fd, bm, ROUND_UP(sizeof(*bm),4096)) !=
                            ROUND_UP(sizeof(*bm),4096))
                            return 5;
        }
@@ -879,7 +887,7 @@ static int write_init_super0(struct supertype *st)
 
        for (di = st->info ; di && ! rv ; di = di->next) {
 
-               if (di->disk.state == 1)
+               if (di->disk.state & (1 << MD_DISK_FAULTY))
                        continue;
                if (di->fd == -1)
                        continue;
@@ -893,7 +901,7 @@ static int write_init_super0(struct supertype *st)
                rv = store_super0(st, di->fd);
 
                if (rv == 0 && (sb->state & (1<<MD_SB_BITMAP_PRESENT)))
-                       rv = st->ss->write_bitmap(st, di->fd);
+                       rv = st->ss->write_bitmap(st, di->fd, NoUpdate);
 
                if (rv)
                        pr_err("failed to write superblock to %s\n",
@@ -920,9 +928,9 @@ static int compare_super0(struct supertype *st, struct supertype *tst)
                return 1;
        if (!first) {
                if (posix_memalign((void**)&first, 4096,
-                            MD_SB_BYTES + 
+                            MD_SB_BYTES +
                             ROUND_UP(sizeof(struct bitmap_super_s), 4096)) != 0) {
-                       pr_err("%s could not allocate superblock\n", __func__);
+                       pr_err("could not allocate superblock\n");
                        return 1;
                }
                memcpy(first, second, MD_SB_BYTES + sizeof(struct bitmap_super_s));
@@ -947,7 +955,6 @@ static int compare_super0(struct supertype *st, struct supertype *tst)
        return 0;
 }
 
-
 static void free_super0(struct supertype *st);
 
 static int load_super0(struct supertype *st, int fd, char *devname)
@@ -991,7 +998,7 @@ static int load_super0(struct supertype *st, int fd, char *devname)
        if (posix_memalign((void**)&super, 4096,
                           MD_SB_BYTES +
                           ROUND_UP(sizeof(bitmap_super_t), 4096)) != 0) {
-               pr_err("%s could not allocate superblock\n", __func__);
+               pr_err("could not allocate superblock\n");
                return 1;
        }
 
@@ -1118,7 +1125,6 @@ static int add_internal_bitmap0(struct supertype *st, int *chunkp,
        bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + MD_SB_BYTES);
        int uuid[4];
 
-
        min_chunk = 4096; /* sub-page chunks don't work yet.. */
        bits = (size * 512) / min_chunk + 1;
        while (bits > max_bits) {
@@ -1133,7 +1139,7 @@ static int add_internal_bitmap0(struct supertype *st, int *chunkp,
                if (chunk < 64*1024*1024)
                        chunk = 64*1024*1024;
        } else if ((unsigned long long)chunk < min_chunk)
-               return 0; /* chunk size too small */
+               return -EINVAL; /* chunk size too small */
 
        sb->state |= (1<<MD_SB_BITMAP_PRESENT);
 
@@ -1147,20 +1153,19 @@ static int add_internal_bitmap0(struct supertype *st, int *chunkp,
        bms->sync_size = __cpu_to_le64(size);
        bms->write_behind = __cpu_to_le32(write_behind);
        *chunkp = chunk;
-       return 1;
+       return 0;
 }
 
-
-static void locate_bitmap0(struct supertype *st, int fd)
+static int locate_bitmap0(struct supertype *st, int fd, int node_num)
 {
        unsigned long long dsize;
        unsigned long long offset;
 
        if (!get_dev_size(fd, NULL, &dsize))
-               return;
+               return -1;
 
        if (dsize < MD_RESERVED_SECTORS*512)
-               return;
+               return -1;
 
        offset = MD_NEW_SIZE_SECTORS(dsize>>9);
 
@@ -1169,9 +1174,10 @@ static void locate_bitmap0(struct supertype *st, int fd)
        offset += MD_SB_BYTES;
 
        lseek64(fd, offset, 0);
+       return 0;
 }
 
-static int write_bitmap0(struct supertype *st, int fd)
+static int write_bitmap0(struct supertype *st, int fd, enum bitmap_update update)
 {
        unsigned long long dsize;
        unsigned long long offset;
@@ -1265,11 +1271,10 @@ static int validate_geometry0(struct supertype *st, int level,
        }
        if (size >= tbmax * 2ULL*1024*1024*1024) {
                if (verbose)
-                       pr_err("0.90 metadata supports at most "
-                              "%d terabytes per device\n", tbmax);
+                       pr_err("0.90 metadata supports at most %d terabytes per device\n", tbmax);
                return 0;
        }
-       if (chunk && *chunk == UnSet)
+       if (*chunk == UnSet)
                *chunk = DEFAULT_CHUNK;
 
        if (!subdev)