Clarify when update=super-minor happens automatcially

[thirdparty/mdadm.git] / super0.c

diff --git a/super0.c b/super0.c
index 49ad19108b965c08795a0d35464a53aa50974494..9e83193bddbadc20ecf0bb59edb24b7233eb8d72 100644 (file)
--- a/super0.c
+++ b/super0.c
@@ -1,7 +1,7 @@
 /*
  * mdadm - manage Linux "md" devices aka RAID arrays.
  *
- * Copyright (C) 2001-2004 Neil Brown <neilb@cse.unsw.edu.au>
+ * Copyright (C) 2001-2006 Neil Brown <neilb@suse.de>
  *
  *
  *    This program is free software; you can redistribute it and/or modify
@@ -27,8 +27,9 @@
  *           Australia
  */
 
+#define HAVE_STDINT_H 1
 #include "mdadm.h"
-
+#include "sha1.h"
 /*
  * All handling for the 0.90.0 version superblock is in
  * this file.
@@ -84,7 +85,7 @@ void super0_swap_endian(struct mdp_superblock_s *sb)
 
 #ifndef MDASSEMBLE
 
-static void examine_super0(void *sbv)
+static void examine_super0(void *sbv, char *homehost)
 {
        mdp_super_t *sb = sbv;
        time_t atime;
@@ -94,10 +95,19 @@ static void examine_super0(void *sbv)
        printf("          Magic : %08x\n", sb->md_magic);
        printf("        Version : %02d.%02d.%02d\n", sb->major_version, sb->minor_version,
               sb->patch_version);
-       if (sb->minor_version >= 90)
-               printf("           UUID : %08x:%08x:%08x:%08x\n", sb->set_uuid0, sb->set_uuid1,
+       if (sb->minor_version >= 90) {
+               printf("           UUID : %08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
                       sb->set_uuid2, sb->set_uuid3);
-       else
+               if (homehost) {
+                       char buf[20];
+                       void *hash = sha1_buffer(homehost,
+                                                strlen(homehost),
+                                                buf);
+                       if (memcmp(&sb->set_uuid2, hash, 8)==0)
+                               printf(" (local to host %s)", homehost);
+               }
+               printf("\n");
+       } else
                printf("           UUID : %08x\n", sb->set_uuid0);
 
        atime = sb->ctime;
@@ -181,6 +191,8 @@ static void examine_super0(void *sbv)
        case 0:
        case 4:
        case 5:
+       case 6:
+       case 10:
                printf("     Chunk Size : %dK\n", sb->chunk_size/1024);
                break;
        case -1:
@@ -219,9 +231,12 @@ static void brief_examine_super0(void *sbv)
 {
        mdp_super_t *sb = sbv;
        char *c=map_num(pers, sb->level);
+       char devname[20];
+
+       sprintf(devname, "/dev/md%d", sb->md_minor);
 
        printf("ARRAY %s level=%s num-devices=%d UUID=",
-              get_md_name(sb->md_minor),
+              devname,
               c?c:"-unknown-", sb->raid_disks);
        if (sb->minor_version >= 90)
                printf("%08x:%08x:%08x:%08x", sb->set_uuid0, sb->set_uuid1,
@@ -231,7 +246,7 @@ static void brief_examine_super0(void *sbv)
        printf("\n");
 }
 
-static void detail_super0(void *sbv)
+static void detail_super0(void *sbv, char *homehost)
 {
        mdp_super_t *sb = sbv;
        printf("           UUID : ");
@@ -240,6 +255,14 @@ static void detail_super0(void *sbv)
                       sb->set_uuid2, sb->set_uuid3);
        else
                printf("%08x", sb->set_uuid0);
+       if (homehost) {
+               char buf[20];
+               void *hash = sha1_buffer(homehost,
+                                        strlen(homehost),
+                                        buf);
+               if (memcmp(&sb->set_uuid2, hash, 8)==0)
+                       printf(" (local to host %s)", homehost);
+       }
        printf("\n         Events : %d.%d\n\n", sb->events_hi, sb->events_lo);
 }
 
@@ -254,6 +277,18 @@ static void brief_detail_super0(void *sbv)
                printf("%08x", sb->set_uuid0);
 }
 #endif
+
+static int match_home0(void *sbv, char *homehost)
+{
+       mdp_super_t *sb = sbv;
+       char buf[20];
+       char *hash = sha1_buffer(homehost,
+                                strlen(homehost),
+                                buf);
+
+       return (memcmp(&sb->set_uuid2, hash, 8)==0);
+}
+
 static void uuid_from_super0(int uuid[4], void * sbv)
 {
        mdp_super_t *super = sbv;
@@ -308,10 +343,11 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
        } else
                info->reshape_active = 0;
 
-       info->name[0] = 0;
+       sprintf(info->name, "%d", sb->md_minor);
        /* work_disks is calculated rather than read directly */
        for (i=0; i < MD_SB_DISKS; i++)
                if ((sb->disks[i].state & (1<<MD_DISK_SYNC)) &&
+                   (sb->disks[i].raid_disk < info->array.raid_disks) &&
                    (sb->disks[i].state & (1<<MD_DISK_ACTIVE)) &&
                    !(sb->disks[i].state & (1<<MD_DISK_FAULTY)))
                        working ++;
@@ -319,7 +355,9 @@ static void getinfo_super0(struct mdinfo *info, void *sbv)
 }
 
 
-static int update_super0(struct mdinfo *info, void *sbv, char *update, char *devname, int verbose)
+static int update_super0(struct mdinfo *info, void *sbv, char *update,
+                        char *devname, int verbose,
+                        int uuid_set, char *homehost)
 {
        /* NOTE: for 'assemble' and 'force' we need to return non-zero if any change was made.
         * For others, the return value is ignored.
@@ -425,7 +463,21 @@ static int update_super0(struct mdinfo *info, void *sbv, char *update, char *dev
                sb->state &= ~(1<<MD_SB_CLEAN);
                sb->recovery_cp = 0;
        }
+       if (strcmp(update, "homehost") == 0 &&
+           homehost) {
+               uuid_set = 0;
+               update = "uuid";
+               info->uuid[0] = sb->set_uuid0;
+               info->uuid[1] = sb->set_uuid1;
+       }
        if (strcmp(update, "uuid") == 0) {
+               if (!uuid_set && homehost) {
+                       char buf[20];
+                       char *hash = sha1_buffer(homehost,
+                                                strlen(homehost),
+                                                buf);
+                       memcpy(info->uuid+2, hash, 8);
+               }
                sb->set_uuid0 = info->uuid[0];
                sb->set_uuid1 = info->uuid[1];
                sb->set_uuid2 = info->uuid[2];
@@ -449,9 +501,17 @@ static __u64 event_super0(void *sbv)
        return md_event(sb);
 }
 
+/*
+ * For verion-0 superblock, the homehost is 'stored' in the
+ * uuid.  8 bytes for a hash of the host leaving 8 bytes
+ * of random material.
+ * We use the first 8 bytes (64bits) of the sha1 of the
+ * host name
+ */
 
 
-static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info, unsigned long long size, char *ignored_name)
+static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
+                      unsigned long long size, char *ignored_name, char *homehost)
 {
        mdp_super_t *sb = malloc(MD_SB_BYTES + sizeof(bitmap_super_t));
        int spares;
@@ -460,6 +520,7 @@ static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
 
        if (info->major_version == -1) {
                /* zeroing the superblock */
+               *sbp = sb;
                return 0;
        }
 
@@ -494,6 +555,13 @@ static int init_super0(struct supertype *st, void **sbp, mdu_array_info_t *info,
        }
        if (rfd >= 0)
                close(rfd);
+       if (homehost) {
+               char buf[20];
+               char *hash = sha1_buffer(homehost,
+                                        strlen(homehost),
+                                        buf);
+               memcpy(&sb->set_uuid2, hash, 8);
+       }
 
        sb->utime = sb->ctime;
        sb->state = info->state;
@@ -557,7 +625,8 @@ static int store_super0(struct supertype *st, int fd, void *sbv)
        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)
-                       write(fd, bm, sizeof(*bm));
+                       if (write(fd, bm, sizeof(*bm)) != sizeof(*bm))
+                           return 5;
        }
 
        fsync(fd);
@@ -576,7 +645,6 @@ static int write_init_super0(struct supertype *st, void *sbv, mdu_disk_info_t *d
        }
 
        sb->disks[dinfo->number].state &= ~(1<<MD_DISK_FAULTY);
-       sb->disks[dinfo->number].state |= (1<<MD_DISK_SYNC);
 
        sb->this_disk = sb->disks[dinfo->number];
        sb->sb_csum = calc_sb0_csum(sb);
@@ -897,6 +965,7 @@ struct superswitch super0 = {
        .detail_super = detail_super0,
        .brief_detail_super = brief_detail_super0,
 #endif
+       .match_home = match_home0,
        .uuid_from_super = uuid_from_super0,
        .getinfo_super = getinfo_super0,
        .update_super = update_super0,