super1.c

   1 /*
   2  * mdadm - manage Linux "md" devices aka RAID arrays.
   3  *
   4  * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
   5  *
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License
  18  *    along with this program; if not, write to the Free Software
  19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *    Author: Neil Brown
  22  *    Email: <neilb@suse.de>
  23  */
  24
  25 #include "mdadm.h"
  26 /*
  27  * The version-1 superblock :
  28  * All numeric fields are little-endian.
  29  *
  30  * total size: 256 bytes plus 2 per device.
  31  *  1K allows 384 devices.
  32  */
  33 struct mdp_superblock_1 {
  34         /* constant array information - 128 bytes */
  35         __u32   magic;          /* MD_SB_MAGIC: 0xa92b4efc - little endian */
  36         __u32   major_version;  /* 1 */
  37         __u32   feature_map;    /* 0 for now */
  38         __u32   pad0;           /* always set to 0 when writing */
  39
  40         __u8    set_uuid[16];   /* user-space generated. */
  41         char    set_name[32];   /* set and interpreted by user-space */
  42
  43         __u64   ctime;          /* lo 40 bits are seconds, top 24 are microseconds or 0*/
  44         __u32   level;          /* -4 (multipath), -1 (linear), 0,1,4,5 */
  45         __u32   layout;         /* only for raid5 currently */
  46         __u64   size;           /* used size of component devices, in 512byte sectors */
  47
  48         __u32   chunksize;      /* in 512byte sectors */
  49         __u32   raid_disks;
  50         __u32   bitmap_offset;  /* sectors after start of superblock that bitmap starts
  51                                  * NOTE: signed, so bitmap can be before superblock
  52                                  * only meaningful of feature_map[0] is set.
  53                                  */
  54
  55         /* These are only valid with feature bit '4' */
  56         __u32   new_level;      /* new level we are reshaping to                */
  57         __u64   reshape_position;       /* next address in array-space for reshape */
  58         __u32   delta_disks;    /* change in number of raid_disks               */
  59         __u32   new_layout;     /* new layout                                   */
  60         __u32   new_chunk;      /* new chunk size (bytes)                       */
  61         __u8    pad1[128-124];  /* set to 0 when written */
  62
  63         /* constant this-device information - 64 bytes */
  64         __u64   data_offset;    /* sector start of data, often 0 */
  65         __u64   data_size;      /* sectors in this device that can be used for data */
  66         __u64   super_offset;   /* sector start of this superblock */
  67         __u64   recovery_offset;/* sectors before this offset (from data_offset) have been recovered */
  68         __u32   dev_number;     /* permanent identifier of this  device - not role in raid */
  69         __u32   cnt_corrected_read; /* number of read errors that were corrected by re-writing */
  70         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
  71         __u8    devflags;        /* per-device flags.  Only one defined...*/
  72 #define WriteMostly1    1        /* mask for writemostly flag in above */
  73         /* bad block log.  If there are any bad blocks the feature flag is set.
  74          * if offset and size are non-zero, that space is reserved and available.
  75          */
  76         __u8    bblog_shift;    /* shift from sectors to block size for badblocklist */
  77         __u16   bblog_size;     /* number of sectors reserved for badblocklist */
  78         __u32   bblog_offset;   /* sector offset from superblock to bblog, signed */
  79
  80         /* array state information - 64 bytes */
  81         __u64   utime;          /* 40 bits second, 24 btes microseconds */
  82         __u64   events;         /* incremented when superblock updated */
  83         __u64   resync_offset;  /* data before this offset (from data_offset) known to be in sync */
  84         __u32   sb_csum;        /* checksum upto dev_roles[max_dev] */
  85         __u32   max_dev;        /* size of dev_roles[] array to consider */
  86         __u8    pad3[64-32];    /* set to 0 when writing */
  87
  88         /* device state information. Indexed by dev_number.
  89          * 2 bytes per device
  90          * Note there are no per-device state flags. State information is rolled
  91          * into the 'roles' value.  If a device is spare or faulty, then it doesn't
  92          * have a meaningful role.
  93          */
  94         __u16   dev_roles[0];   /* role in array, or 0xffff for a spare, or 0xfffe for faulty */
  95 };
  96
  97 struct misc_dev_info {
  98         __u64 device_size;
  99 };
 100
 101 /* feature_map bits */
 102 #define MD_FEATURE_BITMAP_OFFSET        1
 103 #define MD_FEATURE_RECOVERY_OFFSET      2 /* recovery_offset is present and
 104                                            * must be honoured
 105                                            */
 106 #define MD_FEATURE_RESHAPE_ACTIVE       4
 107 #define MD_FEATURE_BAD_BLOCKS           8 /* badblock list is not empty */
 108
 109 #define MD_FEATURE_ALL                  (1|2|4|8)
 110
 111 #ifndef offsetof
 112 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
 113 #endif
 114 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
 115 {
 116         unsigned int disk_csum, csum;
 117         unsigned long long newcsum;
 118         int size = sizeof(*sb) + __le32_to_cpu(sb->max_dev)*2;
 119         unsigned int *isuper = (unsigned int*)sb;
 120
 121 /* make sure I can count... */
 122         if (offsetof(struct mdp_superblock_1,data_offset) != 128 ||
 123             offsetof(struct mdp_superblock_1, utime) != 192 ||
 124             sizeof(struct mdp_superblock_1) != 256) {
 125                 fprintf(stderr, "WARNING - superblock isn't sized correctly\n");
 126         }
 127
 128         disk_csum = sb->sb_csum;
 129         sb->sb_csum = 0;
 130         newcsum = 0;
 131         for (; size>=4; size -= 4 ) {
 132                 newcsum += __le32_to_cpu(*isuper);
 133                 isuper++;
 134         }
 135
 136         if (size == 2)
 137                 newcsum += __le16_to_cpu(*(unsigned short*) isuper);
 138
 139         csum = (newcsum & 0xffffffff) + (newcsum >> 32);
 140         sb->sb_csum = disk_csum;
 141         return __cpu_to_le32(csum);
 142 }
 143
 144 static char abuf[4096+4096];
 145 static int aread(int fd, void *buf, int len)
 146 {
 147         /* aligned read.
 148          * On devices with a 4K sector size, we need to read
 149          * the full sector and copy relevant bits into
 150          * the buffer
 151          */
 152         int bsize;
 153         char *b;
 154         int n;
 155         if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
 156             bsize <= len)
 157                 return read(fd, buf, len);
 158         if (bsize > 4096)
 159                 return -1;
 160         b = (char*)(((long)(abuf+4096))&~4095UL);
 161
 162         n = read(fd, b, bsize);
 163         if (n <= 0)
 164                 return n;
 165         lseek(fd, len - n, 1);
 166         if (n > len)
 167                 n = len;
 168         memcpy(buf, b, n);
 169         return n;
 170 }
 171
 172 static int awrite(int fd, void *buf, int len)
 173 {
 174         /* aligned write.
 175          * On devices with a 4K sector size, we need to write
 176          * the full sector.  We pre-read if the sector is larger
 177          * than the write.
 178          * The address must be sector-aligned.
 179          */
 180         int bsize;
 181         char *b;
 182         int n;
 183         if (ioctl(fd, BLKSSZGET, &bsize) != 0 ||
 184             bsize <= len)
 185                 return write(fd, buf, len);
 186         if (bsize > 4096)
 187                 return -1;
 188         b = (char*)(((long)(abuf+4096))&~4095UL);
 189
 190         n = read(fd, b, bsize);
 191         if (n <= 0)
 192                 return n;
 193         lseek(fd, -n, 1);
 194         memcpy(b, buf, len);
 195         n = write(fd, b, bsize);
 196         if (n <= 0)
 197                 return n;
 198         lseek(fd, len - n, 1);
 199         return len;
 200 }
 201
 202 #ifndef MDASSEMBLE
 203 static void examine_super1(struct supertype *st, char *homehost)
 204 {
 205         struct mdp_superblock_1 *sb = st->sb;
 206         time_t atime;
 207         unsigned int d;
 208         int role;
 209         int delta_extra = 0;
 210         int i;
 211         char *c;
 212         int l = homehost ? strlen(homehost) : 0;
 213         int layout;
 214         unsigned long long sb_offset;
 215
 216         printf("          Magic : %08x\n", __le32_to_cpu(sb->magic));
 217         printf("        Version : 1");
 218         sb_offset = __le64_to_cpu(sb->super_offset);
 219         if (sb_offset <= 4)
 220                 printf(".1\n");
 221         else if (sb_offset <= 8)
 222                 printf(".2\n");
 223         else
 224                 printf(".0\n");
 225         printf("    Feature Map : 0x%x\n", __le32_to_cpu(sb->feature_map));
 226         printf("     Array UUID : ");
 227         for (i=0; i<16; i++) {
 228                 if ((i&3)==0 && i != 0) printf(":");
 229                 printf("%02x", sb->set_uuid[i]);
 230         }
 231         printf("\n");
 232         printf("           Name : %.32s", sb->set_name);
 233         if (l > 0 && l < 32 &&
 234             sb->set_name[l] == ':' &&
 235             strncmp(sb->set_name, homehost, l) == 0)
 236                 printf("  (local to host %s)", homehost);
 237         printf("\n");
 238         atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL;
 239         printf("  Creation Time : %.24s\n", ctime(&atime));
 240         c=map_num(pers, __le32_to_cpu(sb->level));
 241         printf("     Raid Level : %s\n", c?c:"-unknown-");
 242         printf("   Raid Devices : %d\n", __le32_to_cpu(sb->raid_disks));
 243         printf("\n");
 244         printf(" Avail Dev Size : %llu%s\n",
 245                (unsigned long long)__le64_to_cpu(sb->data_size),
 246                human_size(__le64_to_cpu(sb->data_size)<<9));
 247         if (__le32_to_cpu(sb->level) > 0) {
 248                 int ddsks=0;
 249                 switch(__le32_to_cpu(sb->level)) {
 250                 case 1: ddsks=1;break;
 251                 case 4:
 252                 case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break;
 253                 case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break;
 254                 case 10:
 255                         layout = __le32_to_cpu(sb->layout);
 256                         ddsks = __le32_to_cpu(sb->raid_disks)
 257                                  / (layout&255) / ((layout>>8)&255);
 258                 }
 259                 if (ddsks)
 260                         printf("     Array Size : %llu%s\n",
 261                                ddsks*(unsigned long long)__le64_to_cpu(sb->size),
 262                                human_size(ddsks*__le64_to_cpu(sb->size)<<9));
 263                 if (sb->size != sb->data_size)
 264                         printf("  Used Dev Size : %llu%s\n",
 265                                (unsigned long long)__le64_to_cpu(sb->size),
 266                                human_size(__le64_to_cpu(sb->size)<<9));
 267         }
 268         if (sb->data_offset)
 269                 printf("    Data Offset : %llu sectors\n",
 270                        (unsigned long long)__le64_to_cpu(sb->data_offset));
 271         printf("   Super Offset : %llu sectors\n",
 272                (unsigned long long)__le64_to_cpu(sb->super_offset));
 273         if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)
 274                 printf("Recovery Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->recovery_offset));
 275         printf("          State : %s\n", (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean");
 276         printf("    Device UUID : ");
 277         for (i=0; i<16; i++) {
 278                 if ((i&3)==0 && i != 0) printf(":");
 279                 printf("%02x", sb->device_uuid[i]);
 280         }
 281         printf("\n");
 282         printf("\n");
 283         if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
 284                 printf("Internal Bitmap : %ld sectors from superblock\n",
 285                        (long)(int32_t)__le32_to_cpu(sb->bitmap_offset));
 286         }
 287         if (sb->feature_map & __cpu_to_le32(MD_FEATURE_RESHAPE_ACTIVE)) {
 288                 printf("  Reshape pos'n : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->reshape_position)/2,
 289                        human_size(__le64_to_cpu(sb->reshape_position)<<9));
 290                 if (__le32_to_cpu(sb->delta_disks)) {
 291                         printf("  Delta Devices : %d", __le32_to_cpu(sb->delta_disks));
 292                         printf(" (%d->%d)\n",
 293                                __le32_to_cpu(sb->raid_disks)-__le32_to_cpu(sb->delta_disks),
 294                                __le32_to_cpu(sb->raid_disks));
 295                         if ((int)__le32_to_cpu(sb->delta_disks) < 0)
 296                                 delta_extra = -__le32_to_cpu(sb->delta_disks);
 297                 }
 298                 if (__le32_to_cpu(sb->new_level) != __le32_to_cpu(sb->level)) {
 299                         c = map_num(pers, __le32_to_cpu(sb->new_level));
 300                         printf("      New Level : %s\n", c?c:"-unknown-");
 301                 }
 302                 if (__le32_to_cpu(sb->new_layout) != __le32_to_cpu(sb->layout)) {
 303                         if (__le32_to_cpu(sb->level) == 5) {
 304                                 c = map_num(r5layout, __le32_to_cpu(sb->new_layout));
 305                                 printf("     New Layout : %s\n", c?c:"-unknown-");
 306                         }
 307                         if (__le32_to_cpu(sb->level) == 6) {
 308                                 c = map_num(r6layout, __le32_to_cpu(sb->new_layout));
 309                                 printf("     New Layout : %s\n", c?c:"-unknown-");
 310                         }
 311                         if (__le32_to_cpu(sb->level) == 10) {
 312                                 printf("     New Layout :");
 313                                 print_r10_layout(__le32_to_cpu(sb->new_layout));
 314                                 printf("\n");
 315                         }
 316                 }
 317                 if (__le32_to_cpu(sb->new_chunk) != __le32_to_cpu(sb->chunksize))
 318                         printf("  New Chunksize : %dK\n", __le32_to_cpu(sb->new_chunk)/2);
 319                 printf("\n");
 320         }
 321         if (sb->devflags) {
 322                 printf("      Flags :");
 323                 if (sb->devflags & WriteMostly1)
 324                         printf(" write-mostly");
 325                 printf("\n");
 326         }
 327
 328         atime = __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL;
 329         printf("    Update Time : %.24s\n", ctime(&atime));
 330
 331         if (sb->bblog_size && sb->bblog_offset) {
 332                 printf("  Bad Block Log : %d entries available at offset %ld sectors",
 333                        __le16_to_cpu(sb->bblog_size)*512/8,
 334                        (long)__le32_to_cpu(sb->bblog_offset));
 335                 if (sb->feature_map &
 336                     __cpu_to_le32(MD_FEATURE_BAD_BLOCKS))
 337                         printf(" - bad blocks present.");
 338                 printf("\n");
 339         }
 340
 341
 342         if (calc_sb_1_csum(sb) == sb->sb_csum)
 343                 printf("       Checksum : %x - correct\n", __le32_to_cpu(sb->sb_csum));
 344         else
 345                 printf("       Checksum : %x - expected %x\n", __le32_to_cpu(sb->sb_csum),
 346                        __le32_to_cpu(calc_sb_1_csum(sb)));
 347         printf("         Events : %llu\n", (unsigned long long)__le64_to_cpu(sb->events));
 348         printf("\n");
 349         if (__le32_to_cpu(sb->level) == 5) {
 350                 c = map_num(r5layout, __le32_to_cpu(sb->layout));
 351                 printf("         Layout : %s\n", c?c:"-unknown-");
 352         }
 353         if (__le32_to_cpu(sb->level) == 6) {
 354                 c = map_num(r6layout, __le32_to_cpu(sb->layout));
 355                 printf("         Layout : %s\n", c?c:"-unknown-");
 356         }
 357         if (__le32_to_cpu(sb->level) == 10) {
 358                 int lo = __le32_to_cpu(sb->layout);
 359                 printf("         Layout :");
 360                 print_r10_layout(lo);
 361                 printf("\n");
 362         }
 363         switch(__le32_to_cpu(sb->level)) {
 364         case 0:
 365         case 4:
 366         case 5:
 367         case 6:
 368         case 10:
 369                 printf("     Chunk Size : %dK\n", __le32_to_cpu(sb->chunksize)/2);
 370                 break;
 371         case -1:
 372                 printf("       Rounding : %dK\n", __le32_to_cpu(sb->chunksize)/2);
 373                 break;
 374         default: break;
 375         }
 376         printf("\n");
 377 #if 0
 378         /* This turns out to just be confusing */
 379         printf("    Array Slot : %d (", __le32_to_cpu(sb->dev_number));
 380         for (i= __le32_to_cpu(sb->max_dev); i> 0 ; i--)
 381                 if (__le16_to_cpu(sb->dev_roles[i-1]) != 0xffff)
 382                         break;
 383         for (d=0; d < i; d++) {
 384                 int role = __le16_to_cpu(sb->dev_roles[d]);
 385                 if (d) printf(", ");
 386                 if (role == 0xffff) printf("empty");
 387                 else if(role == 0xfffe) printf("failed");
 388                 else printf("%d", role);
 389         }
 390         printf(")\n");
 391 #endif
 392         printf("   Device Role : ");
 393         d = __le32_to_cpu(sb->dev_number);
 394         if (d < __le32_to_cpu(sb->max_dev))
 395                 role = __le16_to_cpu(sb->dev_roles[d]);
 396         else
 397                 role = 0xFFFF;
 398         if (role >= 0xFFFE)
 399                 printf("spare\n");
 400         else
 401                 printf("Active device %d\n", role);
 402
 403         printf("   Array State : ");
 404         for (d=0; d<__le32_to_cpu(sb->raid_disks) + delta_extra; d++) {
 405                 int cnt = 0;
 406                 unsigned int i;
 407                 for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
 408                         unsigned int role = __le16_to_cpu(sb->dev_roles[i]);
 409                         if (role == d)
 410                                 cnt++;
 411                 }
 412                 if (cnt > 1) printf("?");
 413                 else if (cnt == 1) printf("A");
 414                 else printf (".");
 415         }
 416 #if 0
 417         /* This is confusing too */
 418         faulty = 0;
 419         for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
 420                 int role = __le16_to_cpu(sb->dev_roles[i]);
 421                 if (role == 0xFFFE)
 422                         faulty++;
 423         }
 424         if (faulty) printf(" %d failed", faulty);
 425 #endif
 426         printf(" ('A' == active, '.' == missing)");
 427         printf("\n");
 428 }
 429
 430
 431 static void brief_examine_super1(struct supertype *st, int verbose)
 432 {
 433         struct mdp_superblock_1 *sb = st->sb;
 434         int i;
 435         unsigned long long sb_offset;
 436         char *nm;
 437         char *c=map_num(pers, __le32_to_cpu(sb->level));
 438
 439         nm = strchr(sb->set_name, ':');
 440         if (nm)
 441                 nm++;
 442         else if (sb->set_name[0])
 443                 nm = sb->set_name;
 444         else
 445                 nm = NULL;
 446
 447         printf("ARRAY%s%s", nm ? " /dev/md/":"", nm);
 448         if (verbose && c)
 449                 printf(" level=%s", c);
 450         sb_offset = __le64_to_cpu(sb->super_offset);
 451         if (sb_offset <= 4)
 452                 printf(" metadata=1.1 ");
 453         else if (sb_offset <= 8)
 454                 printf(" metadata=1.2 ");
 455         else
 456                 printf(" metadata=1.0 ");
 457         if (verbose)
 458                 printf("num-devices=%d ", __le32_to_cpu(sb->raid_disks));
 459         printf("UUID=");
 460         for (i=0; i<16; i++) {
 461                 if ((i&3)==0 && i != 0) printf(":");
 462                 printf("%02x", sb->set_uuid[i]);
 463         }
 464         if (sb->set_name[0])
 465                 printf(" name=%.32s", sb->set_name);
 466         printf("\n");
 467 }
 468
 469 static void export_examine_super1(struct supertype *st)
 470 {
 471         struct mdp_superblock_1 *sb = st->sb;
 472         int i;
 473         int len = 32;
 474
 475         printf("MD_LEVEL=%s\n", map_num(pers, __le32_to_cpu(sb->level)));
 476         printf("MD_DEVICES=%d\n", __le32_to_cpu(sb->raid_disks));
 477         for (i=0; i<32; i++)
 478                 if (sb->set_name[i] == '\n' ||
 479                     sb->set_name[i] == '\0') {
 480                         len = i;
 481                         break;
 482                 }
 483         if (len)
 484                 printf("MD_NAME=%.*s\n", len, sb->set_name);
 485         printf("MD_UUID=");
 486         for (i=0; i<16; i++) {
 487                 if ((i&3)==0 && i != 0) printf(":");
 488                 printf("%02x", sb->set_uuid[i]);
 489         }
 490         printf("\n");
 491         printf("MD_UPDATE_TIME=%llu\n",
 492                __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL);
 493         printf("MD_DEV_UUID=");
 494         for (i=0; i<16; i++) {
 495                 if ((i&3)==0 && i != 0) printf(":");
 496                 printf("%02x", sb->device_uuid[i]);
 497         }
 498         printf("\n");
 499         printf("MD_EVENTS=%llu\n",
 500                (unsigned long long)__le64_to_cpu(sb->events));
 501 }
 502
 503 static void detail_super1(struct supertype *st, char *homehost)
 504 {
 505         struct mdp_superblock_1 *sb = st->sb;
 506         int i;
 507         int l = homehost ? strlen(homehost) : 0;
 508
 509         printf("           Name : %.32s", sb->set_name);
 510         if (l > 0 && l < 32 &&
 511             sb->set_name[l] == ':' &&
 512             strncmp(sb->set_name, homehost, l) == 0)
 513                 printf("  (local to host %s)", homehost);
 514         printf("\n           UUID : ");
 515         for (i=0; i<16; i++) {
 516                 if ((i&3)==0 && i != 0) printf(":");
 517                 printf("%02x", sb->set_uuid[i]);
 518         }
 519         printf("\n         Events : %llu\n\n", (unsigned long long)__le64_to_cpu(sb->events));
 520 }
 521
 522 static void brief_detail_super1(struct supertype *st)
 523 {
 524         struct mdp_superblock_1 *sb = st->sb;
 525         int i;
 526
 527         if (sb->set_name[0])
 528                 printf(" name=%.32s", sb->set_name);
 529         printf(" UUID=");
 530         for (i=0; i<16; i++) {
 531                 if ((i&3)==0 && i != 0) printf(":");
 532                 printf("%02x", sb->set_uuid[i]);
 533         }
 534 }
 535
 536 static void export_detail_super1(struct supertype *st)
 537 {
 538         struct mdp_superblock_1 *sb = st->sb;
 539         int i;
 540         int len = 32;
 541
 542         for (i=0; i<32; i++)
 543                 if (sb->set_name[i] == '\n' ||
 544                     sb->set_name[i] == '\0') {
 545                         len = i;
 546                         break;
 547                 }
 548         if (len)
 549                 printf("MD_NAME=%.*s\n", len, sb->set_name);
 550 }
 551
 552 #endif
 553
 554 static int match_home1(struct supertype *st, char *homehost)
 555 {
 556         struct mdp_superblock_1 *sb = st->sb;
 557         int l = homehost ? strlen(homehost) : 0;
 558
 559         return (l > 0 && l < 32 &&
 560                 sb->set_name[l] == ':' &&
 561                 strncmp(sb->set_name, homehost, l) == 0);
 562 }
 563
 564 static void uuid_from_super1(struct supertype *st, int uuid[4])
 565 {
 566         struct mdp_superblock_1 *super = st->sb;
 567         char *cuuid = (char*)uuid;
 568         int i;
 569         for (i=0; i<16; i++)
 570                 cuuid[i] = super->set_uuid[i];
 571 }
 572
 573 static void getinfo_super1(struct supertype *st, struct mdinfo *info, char *map)
 574 {
 575         struct mdp_superblock_1 *sb = st->sb;
 576         int working = 0;
 577         unsigned int i;
 578         unsigned int role;
 579         unsigned int map_disks = info->array.raid_disks;
 580
 581         memset(info, 0, sizeof(*info));
 582         info->array.major_version = 1;
 583         info->array.minor_version = st->minor_version;
 584         info->array.patch_version = 0;
 585         info->array.raid_disks = __le32_to_cpu(sb->raid_disks);
 586         info->array.level = __le32_to_cpu(sb->level);
 587         info->array.layout = __le32_to_cpu(sb->layout);
 588         info->array.md_minor = -1;
 589         info->array.ctime = __le64_to_cpu(sb->ctime);
 590         info->array.utime = __le64_to_cpu(sb->utime);
 591         info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512;
 592         info->array.state =
 593                 (__le64_to_cpu(sb->resync_offset) >= __le64_to_cpu(sb->size))
 594                 ? 1 : 0;
 595
 596         info->data_offset = __le64_to_cpu(sb->data_offset);
 597         info->component_size = __le64_to_cpu(sb->size);
 598
 599         info->disk.major = 0;
 600         info->disk.minor = 0;
 601         info->disk.number = __le32_to_cpu(sb->dev_number);
 602         if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) ||
 603             __le32_to_cpu(sb->max_dev) > 512)
 604                 role = 0xfffe;
 605         else
 606                 role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]);
 607
 608         info->disk.raid_disk = -1;
 609         switch(role) {
 610         case 0xFFFF:
 611                 info->disk.state = 0; /* spare: not active, not sync, not faulty */
 612                 break;
 613         case 0xFFFE:
 614                 info->disk.state = 1; /* faulty */
 615                 break;
 616         default:
 617                 info->disk.state = 6; /* active and in sync */
 618                 info->disk.raid_disk = role;
 619         }
 620         info->events = __le64_to_cpu(sb->events);
 621         sprintf(info->text_version, "1.%d", st->minor_version);
 622         info->safe_mode_delay = 200;
 623
 624         memcpy(info->uuid, sb->set_uuid, 16);
 625
 626         strncpy(info->name, sb->set_name, 32);
 627         info->name[32] = 0;
 628
 629         if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RECOVERY_OFFSET))
 630                 info->recovery_start = __le32_to_cpu(sb->recovery_offset);
 631         else
 632                 info->recovery_start = MaxSector;
 633
 634         if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
 635                 info->reshape_active = 1;
 636                 info->reshape_progress = __le64_to_cpu(sb->reshape_position);
 637                 info->new_level = __le32_to_cpu(sb->new_level);
 638                 info->delta_disks = __le32_to_cpu(sb->delta_disks);
 639                 info->new_layout = __le32_to_cpu(sb->new_layout);
 640                 info->new_chunk = __le32_to_cpu(sb->new_chunk)<<9;
 641                 if (info->delta_disks < 0)
 642                         info->array.raid_disks -= info->delta_disks;
 643         } else
 644                 info->reshape_active = 0;
 645
 646         if (map)
 647                 for (i=0; i<map_disks; i++)
 648                         map[i] = 0;
 649         for (i = 0; i < __le32_to_cpu(sb->max_dev); i++) {
 650                 role = __le16_to_cpu(sb->dev_roles[i]);
 651                 if (/*role == 0xFFFF || */role < (unsigned) info->array.raid_disks) {
 652                         working++;
 653                         if (map && role < map_disks)
 654                                 map[role] = 1;
 655                 }
 656         }
 657
 658         info->array.working_disks = working;
 659 }
 660
 661 static struct mdinfo *container_content1(struct supertype *st, char *subarray)
 662 {
 663         struct mdinfo *info;
 664
 665         if (subarray)
 666                 return NULL;
 667
 668         info = malloc(sizeof(*info));
 669         getinfo_super1(st, info, NULL);
 670         return info;
 671 }
 672
 673 static int update_super1(struct supertype *st, struct mdinfo *info,
 674                          char *update,
 675                          char *devname, int verbose,
 676                          int uuid_set, char *homehost)
 677 {
 678         /* NOTE: for 'assemble' and 'force' we need to return non-zero
 679          * if any change was made.  For others, the return value is
 680          * ignored.
 681          */
 682         int rv = 0;
 683         struct mdp_superblock_1 *sb = st->sb;
 684
 685         if (strcmp(update, "force-one")==0) {
 686                 /* Not enough devices for a working array,
 687                  * so bring this one up-to-date
 688                  */
 689                 if (sb->events != __cpu_to_le64(info->events))
 690                         rv = 1;
 691                 sb->events = __cpu_to_le64(info->events);
 692         } else if (strcmp(update, "force-array")==0) {
 693                 /* Degraded array and 'force' requests to
 694                  * maybe need to mark it 'clean'.
 695                  */
 696                 switch(__le32_to_cpu(sb->level)) {
 697                 case 5: case 4: case 6:
 698                         /* need to force clean */
 699                         if (sb->resync_offset != MaxSector)
 700                                 rv = 1;
 701                         sb->resync_offset = MaxSector;
 702                 }
 703         } else if (strcmp(update, "assemble")==0) {
 704                 int d = info->disk.number;
 705                 int want;
 706                 if (info->disk.state == 6)
 707                         want = info->disk.raid_disk;
 708                 else
 709                         want = 0xFFFF;
 710                 if (sb->dev_roles[d] != __cpu_to_le16(want)) {
 711                         sb->dev_roles[d] = __cpu_to_le16(want);
 712                         rv = 1;
 713                 }
 714                 if (info->reshape_active &&
 715                     sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
 716                     info->delta_disks >= 0 &&
 717                     info->reshape_progress < __le64_to_cpu(sb->reshape_position)) {
 718                         sb->reshape_position = __cpu_to_le64(info->reshape_progress);
 719                         rv = 1;
 720                 }
 721                 if (info->reshape_active &&
 722                     sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE) &&
 723                     info->delta_disks < 0 &&
 724                     info->reshape_progress > __le64_to_cpu(sb->reshape_position)) {
 725                         sb->reshape_position = __cpu_to_le64(info->reshape_progress);
 726                         rv = 1;
 727                 }
 728         } else if (strcmp(update, "linear-grow-new") == 0) {
 729                 unsigned int i;
 730                 int rfd, fd;
 731                 unsigned int max = __le32_to_cpu(sb->max_dev);
 732
 733                 for (i=0 ; i < max ; i++)
 734                         if (__le16_to_cpu(sb->dev_roles[i]) >= 0xfffe)
 735                                 break;
 736                 sb->dev_number = __cpu_to_le32(i);
 737                 info->disk.number = i;
 738                 if (max >= __le32_to_cpu(sb->max_dev))
 739                         sb->max_dev = __cpu_to_le32(max+1);
 740
 741                 if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
 742                     read(rfd, sb->device_uuid, 16) != 16) {
 743                         __u32 r[4] = {random(), random(), random(), random()};
 744                         memcpy(sb->device_uuid, r, 16);
 745                 }
 746                 if (rfd >= 0)
 747                         close(rfd);
 748
 749                 sb->dev_roles[i] =
 750                         __cpu_to_le16(info->disk.raid_disk);
 751
 752                 fd = open(devname, O_RDONLY);
 753                 if (fd >= 0) {
 754                         unsigned long long ds;
 755                         get_dev_size(fd, devname, &ds);
 756                         close(fd);
 757                         ds >>= 9;
 758                         if (__le64_to_cpu(sb->super_offset) <
 759                             __le64_to_cpu(sb->data_offset)) {
 760                                 sb->data_size = __cpu_to_le64(
 761                                         ds - __le64_to_cpu(sb->data_offset));
 762                         } else {
 763                                 ds -= 8*2;
 764                                 ds &= ~(unsigned long long)(4*2-1);
 765                                 sb->super_offset = __cpu_to_le64(ds);
 766                                 sb->data_size = __cpu_to_le64(
 767                                         ds - __le64_to_cpu(sb->data_offset));
 768                         }
 769                 }
 770         } else if (strcmp(update, "linear-grow-update") == 0) {
 771                 sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
 772                 sb->dev_roles[info->disk.number] =
 773                         __cpu_to_le16(info->disk.raid_disk);
 774         } else if (strcmp(update, "resync") == 0) {
 775                 /* make sure resync happens */
 776                 sb->resync_offset = 0ULL;
 777         } else if (strcmp(update, "uuid") == 0) {
 778                 copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
 779
 780                 if (__le32_to_cpu(sb->feature_map)&MD_FEATURE_BITMAP_OFFSET) {
 781                         struct bitmap_super_s *bm;
 782                         bm = (struct bitmap_super_s*)(st->sb+1024);
 783                         memcpy(bm->uuid, sb->set_uuid, 16);
 784                 }
 785         } else if (strcmp(update, "no-bitmap") == 0) {
 786                 sb->feature_map &= ~__cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
 787         } else if (strcmp(update, "homehost") == 0 &&
 788                    homehost) {
 789                 char *c;
 790                 update = "name";
 791                 c = strchr(sb->set_name, ':');
 792                 if (c)
 793                         strncpy(info->name, c+1, 31 - (c-sb->set_name));
 794                 else
 795                         strncpy(info->name, sb->set_name, 32);
 796                 info->name[32] = 0;
 797         } else if (strcmp(update, "name") == 0) {
 798                 if (info->name[0] == 0)
 799                         sprintf(info->name, "%d", info->array.md_minor);
 800                 memset(sb->set_name, 0, sizeof(sb->set_name));
 801                 if (homehost &&
 802                     strchr(info->name, ':') == NULL &&
 803                     strlen(homehost)+1+strlen(info->name) < 32) {
 804                         strcpy(sb->set_name, homehost);
 805                         strcat(sb->set_name, ":");
 806                         strcat(sb->set_name, info->name);
 807                 } else
 808                         strcpy(sb->set_name, info->name);
 809         } else if (strcmp(update, "devicesize") == 0 &&
 810             __le64_to_cpu(sb->super_offset) <
 811             __le64_to_cpu(sb->data_offset)) {
 812                 /* set data_size to device size less data_offset */
 813                 struct misc_dev_info *misc = (struct misc_dev_info*)
 814                         (st->sb + 1024 + 512);
 815                 printf("Size was %llu\n", (unsigned long long)
 816                        __le64_to_cpu(sb->data_size));
 817                 sb->data_size = __cpu_to_le64(
 818                         misc->device_size - __le64_to_cpu(sb->data_offset));
 819                 printf("Size is %llu\n", (unsigned long long)
 820                        __le64_to_cpu(sb->data_size));
 821         } else if (strcmp(update, "_reshape_progress")==0)
 822                 sb->reshape_position = __cpu_to_le64(info->reshape_progress);
 823         else
 824                 rv = -1;
 825
 826         sb->sb_csum = calc_sb_1_csum(sb);
 827         return rv;
 828 }
 829
 830 static int init_super1(struct supertype *st, mdu_array_info_t *info,
 831                        unsigned long long size, char *name, char *homehost, int *uuid)
 832 {
 833         struct mdp_superblock_1 *sb;
 834         int spares;
 835         int rfd;
 836         char defname[10];
 837
 838         if (posix_memalign((void**)&sb, 512, (1024 + 512 +
 839                            sizeof(struct misc_dev_info))) != 0) {
 840                 fprintf(stderr, Name
 841                         ": %s could not allocate superblock\n", __func__);
 842                 return 0;
 843         }
 844         memset(sb, 0, 1024);
 845
 846         st->sb = sb;
 847         if (info == NULL) {
 848                 /* zeroing superblock */
 849                 return 0;
 850         }
 851
 852         spares = info->working_disks - info->active_disks;
 853         if (info->raid_disks + spares  > 384) {
 854                 fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n",
 855                         info->raid_disks , spares, 384);
 856                 return 0;
 857         }
 858
 859         sb->magic = __cpu_to_le32(MD_SB_MAGIC);
 860         sb->major_version = __cpu_to_le32(1);
 861         sb->feature_map = 0;
 862         sb->pad0 = 0;
 863
 864         if (uuid)
 865                 copy_uuid(sb->set_uuid, uuid, super1.swapuuid);
 866         else {
 867                 if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
 868                     read(rfd, sb->set_uuid, 16) != 16) {
 869                         __u32 r[4] = {random(), random(), random(), random()};
 870                         memcpy(sb->set_uuid, r, 16);
 871                 }
 872                 if (rfd >= 0) close(rfd);
 873         }
 874
 875         if (name == NULL || *name == 0) {
 876                 sprintf(defname, "%d", info->md_minor);
 877                 name = defname;
 878         }
 879         memset(sb->set_name, 0, 32);
 880         if (homehost &&
 881             strchr(name, ':')== NULL &&
 882             strlen(homehost)+1+strlen(name) < 32) {
 883                 strcpy(sb->set_name, homehost);
 884                 strcat(sb->set_name, ":");
 885                 strcat(sb->set_name, name);
 886         } else
 887                 strcpy(sb->set_name, name);
 888
 889         sb->ctime = __cpu_to_le64((unsigned long long)time(0));
 890         sb->level = __cpu_to_le32(info->level);
 891         sb->layout = __cpu_to_le32(info->layout);
 892         sb->size = __cpu_to_le64(size*2ULL);
 893         sb->chunksize = __cpu_to_le32(info->chunk_size>>9);
 894         sb->raid_disks = __cpu_to_le32(info->raid_disks);
 895
 896         sb->data_offset = __cpu_to_le64(0);
 897         sb->data_size = __cpu_to_le64(0);
 898         sb->super_offset = __cpu_to_le64(0);
 899         sb->recovery_offset = __cpu_to_le64(0);
 900
 901         sb->utime = sb->ctime;
 902         sb->events = __cpu_to_le64(1);
 903         if (info->state & (1<<MD_SB_CLEAN))
 904                 sb->resync_offset = MaxSector;
 905         else
 906                 sb->resync_offset = 0;
 907         sb->max_dev = __cpu_to_le32((1024- sizeof(struct mdp_superblock_1))/
 908                                     sizeof(sb->dev_roles[0]));
 909         memset(sb->pad3, 0, sizeof(sb->pad3));
 910
 911         memset(sb->dev_roles, 0xff, 1024 - sizeof(struct mdp_superblock_1));
 912
 913         return 1;
 914 }
 915
 916 struct devinfo {
 917         int fd;
 918         char *devname;
 919         mdu_disk_info_t disk;
 920         struct devinfo *next;
 921 };
 922 #ifndef MDASSEMBLE
 923 /* Add a device to the superblock being created */
 924 static int add_to_super1(struct supertype *st, mdu_disk_info_t *dk,
 925                           int fd, char *devname)
 926 {
 927         struct mdp_superblock_1 *sb = st->sb;
 928         __u16 *rp = sb->dev_roles + dk->number;
 929         struct devinfo *di, **dip;
 930
 931         if ((dk->state & 6) == 6) /* active, sync */
 932                 *rp = __cpu_to_le16(dk->raid_disk);
 933         else if ((dk->state & ~2) == 0) /* active or idle -> spare */
 934                 *rp = 0xffff;
 935         else
 936                 *rp = 0xfffe;
 937
 938         if (dk->number >= (int)__le32_to_cpu(sb->max_dev) &&
 939             __le32_to_cpu(sb->max_dev) < 384)
 940                 sb->max_dev = __cpu_to_le32(dk->number+1);
 941
 942         sb->dev_number = __cpu_to_le32(dk->number);
 943         sb->sb_csum = calc_sb_1_csum(sb);
 944
 945         dip = (struct devinfo **)&st->info;
 946         while (*dip)
 947                 dip = &(*dip)->next;
 948         di = malloc(sizeof(struct devinfo));
 949         di->fd = fd;
 950         di->devname = devname;
 951         di->disk = *dk;
 952         di->next = NULL;
 953         *dip = di;
 954
 955         return 0;
 956 }
 957 #endif
 958
 959 static void locate_bitmap1(struct supertype *st, int fd);
 960
 961 static int store_super1(struct supertype *st, int fd)
 962 {
 963         struct mdp_superblock_1 *sb = st->sb;
 964         unsigned long long sb_offset;
 965         int sbsize;
 966         unsigned long long dsize;
 967
 968         if (!get_dev_size(fd, NULL, &dsize))
 969                 return 1;
 970
 971         dsize >>= 9;
 972
 973         if (dsize < 24)
 974                 return 2;
 975
 976         /*
 977          * Calculate the position of the superblock.
 978          * It is always aligned to a 4K boundary and
 979          * depending on minor_version, it can be:
 980          * 0: At least 8K, but less than 12K, from end of device
 981          * 1: At start of device
 982          * 2: 4K from start of device.
 983          */
 984         switch(st->minor_version) {
 985         case 0:
 986                 sb_offset = dsize;
 987                 sb_offset -= 8*2;
 988                 sb_offset &= ~(4*2-1);
 989                 break;
 990         case 1:
 991                 sb_offset = 0;
 992                 break;
 993         case 2:
 994                 sb_offset = 4*2;
 995                 break;
 996         default:
 997                 return -EINVAL;
 998         }
 999
1000
1001
1002         if (sb_offset != __le64_to_cpu(sb->super_offset) &&
1003             0 != __le64_to_cpu(sb->super_offset)
1004                 ) {
1005                 fprintf(stderr, Name ": internal error - sb_offset is wrong\n");
1006                 abort();
1007         }
1008
1009         if (lseek64(fd, sb_offset << 9, 0)< 0LL)
1010                 return 3;
1011
1012         sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev);
1013         sbsize = (sbsize+511)&(~511UL);
1014
1015         if (awrite(fd, sb, sbsize) != sbsize)
1016                 return 4;
1017
1018         if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
1019                 struct bitmap_super_s *bm = (struct bitmap_super_s*)
1020                         (((char*)sb)+1024);
1021                 if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) {
1022                         locate_bitmap1(st, fd);
1023                         if (awrite(fd, bm, sizeof(*bm)) !=
1024                             sizeof(*bm))
1025                             return 5;
1026                 }
1027         }
1028         fsync(fd);
1029         return 0;
1030 }
1031
1032 static int load_super1(struct supertype *st, int fd, char *devname);
1033
1034 static unsigned long choose_bm_space(unsigned long devsize)
1035 {
1036         /* if the device is bigger than 8Gig, save 64k for bitmap usage,
1037          * if bigger than 200Gig, save 128k
1038          * NOTE: result must be multiple of 4K else bad things happen
1039          * on 4K-sector devices.
1040          */
1041         if (devsize < 64*2) return 0;
1042         if (devsize - 64*2 >= 200*1024*1024*2)
1043                 return 128*2;
1044         if (devsize - 4*2 > 8*1024*1024*2)
1045                 return 64*2;
1046         return 4*2;
1047 }
1048
1049 static void free_super1(struct supertype *st);
1050
1051 #ifndef MDASSEMBLE
1052 static int write_init_super1(struct supertype *st)
1053 {
1054         struct mdp_superblock_1 *sb = st->sb;
1055         struct supertype *refst;
1056         int rfd;
1057         int rv = 0;
1058         unsigned long long bm_space;
1059         unsigned long long reserved;
1060         struct devinfo *di;
1061         unsigned long long dsize, array_size;
1062         unsigned long long sb_offset;
1063
1064         for (di = st->info; di && ! rv ; di = di->next) {
1065                 if (di->disk.state == 1)
1066                         continue;
1067                 if (di->fd < 0)
1068                         continue;
1069
1070                 while (Kill(di->devname, NULL, 0, 1, 1) == 0)
1071                         ;
1072
1073                 sb->dev_number = __cpu_to_le32(di->disk.number);
1074                 if (di->disk.state & (1<<MD_DISK_WRITEMOSTLY))
1075                         sb->devflags |= __cpu_to_le32(WriteMostly1);
1076
1077                 if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
1078                     read(rfd, sb->device_uuid, 16) != 16) {
1079                         __u32 r[4] = {random(), random(), random(), random()};
1080                         memcpy(sb->device_uuid, r, 16);
1081                 }
1082                 if (rfd >= 0)
1083                         close(rfd);
1084
1085                 sb->events = 0;
1086
1087                 refst = dup_super(st);
1088                 if (load_super1(refst, di->fd, NULL)==0) {
1089                         struct mdp_superblock_1 *refsb = refst->sb;
1090
1091                         memcpy(sb->device_uuid, refsb->device_uuid, 16);
1092                         if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) {
1093                                 /* same array, so preserve events and
1094                                  * dev_number */
1095                                 sb->events = refsb->events;
1096                                 /* bugs in 2.6.17 and earlier mean the
1097                                  * dev_number chosen in Manage must be preserved
1098                                  */
1099                                 if (get_linux_version() >= 2006018)
1100                                         sb->dev_number = refsb->dev_number;
1101                         }
1102                         free_super1(refst);
1103                 }
1104                 free(refst);
1105
1106                 if (!get_dev_size(di->fd, NULL, &dsize))
1107                         return 1;
1108                 dsize >>= 9;
1109
1110                 if (dsize < 24) {
1111                         close(di->fd);
1112                         return 2;
1113                 }
1114
1115
1116                 /*
1117                  * Calculate the position of the superblock.
1118                  * It is always aligned to a 4K boundary and
1119                  * depending on minor_version, it can be:
1120                  * 0: At least 8K, but less than 12K, from end of device
1121                  * 1: At start of device
1122                  * 2: 4K from start of device.
1123                  * Depending on the array size, we might leave extra space
1124                  * for a bitmap.
1125                  * Also leave 4K for bad-block log.
1126                  */
1127                 array_size = __le64_to_cpu(sb->size);
1128                 /* work out how much space we left for a bitmap,
1129                  * Add 8 sectors for bad block log */
1130                 bm_space = choose_bm_space(array_size) + 8;
1131
1132                 switch(st->minor_version) {
1133                 case 0:
1134                         sb_offset = dsize;
1135                         sb_offset -= 8*2;
1136                         sb_offset &= ~(4*2-1);
1137                         sb->super_offset = __cpu_to_le64(sb_offset);
1138                         sb->data_offset = __cpu_to_le64(0);
1139                         if (sb_offset < array_size + bm_space)
1140                                 bm_space = sb_offset - array_size;
1141                         sb->data_size = __cpu_to_le64(sb_offset - bm_space);
1142                         if (bm_space >= 8) {
1143                                 sb->bblog_size = __cpu_to_le16(8);
1144                                 sb->bblog_offset = __cpu_to_le32((unsigned)-8);
1145                         }
1146                         break;
1147                 case 1:
1148                         sb->super_offset = __cpu_to_le64(0);
1149                         reserved = bm_space + 4*2;
1150                         /* Try for multiple of 1Meg so it is nicely aligned */
1151                         #define ONE_MEG (2*1024)
1152                         reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG;
1153                         if (reserved + __le64_to_cpu(sb->size) > dsize)
1154                                 reserved = dsize - __le64_to_cpu(sb->size);
1155                         /* force 4K alignment */
1156                         reserved &= ~7ULL;
1157
1158                         sb->data_offset = __cpu_to_le64(reserved);
1159                         sb->data_size = __cpu_to_le64(dsize - reserved);
1160                         if (reserved >= 16) {
1161                                 sb->bblog_size = __cpu_to_le16(8);
1162                                 sb->bblog_offset = __cpu_to_le32(reserved-8);
1163                         }
1164                         break;
1165                 case 2:
1166                         sb_offset = 4*2;
1167                         sb->super_offset = __cpu_to_le64(4*2);
1168                         if (4*2 + 4*2 + bm_space + __le64_to_cpu(sb->size)
1169                             > dsize)
1170                                 bm_space = dsize - __le64_to_cpu(sb->size)
1171                                         - 4*2 - 4*2;
1172
1173                         reserved = bm_space + 4*2 + 4*2;
1174                         /* Try for multiple of 1Meg so it is nicely aligned */
1175                         #define ONE_MEG (2*1024)
1176                         reserved = ((reserved + ONE_MEG-1)/ONE_MEG) * ONE_MEG;
1177                         if (reserved + __le64_to_cpu(sb->size) > dsize)
1178                                 reserved = dsize - __le64_to_cpu(sb->size);
1179                         /* force 4K alignment */
1180                         reserved &= ~7ULL;
1181
1182                         sb->data_offset = __cpu_to_le64(reserved);
1183                         sb->data_size = __cpu_to_le64(dsize - reserved);
1184                         if (reserved >= 16+16) {
1185                                 sb->bblog_size = __cpu_to_le16(8);
1186                                 sb->bblog_offset = __cpu_to_le32(reserved-8-8);
1187                         }
1188                         break;
1189                 default:
1190                         return -EINVAL;
1191                 }
1192
1193
1194                 sb->sb_csum = calc_sb_1_csum(sb);
1195                 rv = store_super1(st, di->fd);
1196                 if (rv)
1197                         fprintf(stderr,
1198                                 Name ": failed to write superblock to %s\n",
1199                                 di->devname);
1200
1201                 if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1))
1202                         rv = st->ss->write_bitmap(st, di->fd);
1203                 close(di->fd);
1204                 di->fd = -1;
1205         }
1206         return rv;
1207 }
1208 #endif
1209
1210 static int compare_super1(struct supertype *st, struct supertype *tst)
1211 {
1212         /*
1213          * return:
1214          *  0 same, or first was empty, and second was copied
1215          *  1 second had wrong number
1216          *  2 wrong uuid
1217          *  3 wrong other info
1218          */
1219         struct mdp_superblock_1 *first = st->sb;
1220         struct mdp_superblock_1 *second = tst->sb;
1221
1222         if (second->magic != __cpu_to_le32(MD_SB_MAGIC))
1223                 return 1;
1224         if (second->major_version != __cpu_to_le32(1))
1225                 return 1;
1226
1227         if (!first) {
1228                 if (posix_memalign((void**)&first, 512,
1229                                1024 + 512 +
1230                                sizeof(struct misc_dev_info)) != 0) {
1231                         fprintf(stderr, Name
1232                                 ": %s could not allocate superblock\n", __func__);
1233                         return 1;
1234                 }
1235                 memcpy(first, second, 1024 + 512 +
1236                        sizeof(struct misc_dev_info));
1237                 st->sb = first;
1238                 return 0;
1239         }
1240         if (memcmp(first->set_uuid, second->set_uuid, 16)!= 0)
1241                 return 2;
1242
1243         if (first->ctime      != second->ctime     ||
1244             first->level      != second->level     ||
1245             first->layout     != second->layout    ||
1246             first->size       != second->size      ||
1247             first->chunksize  != second->chunksize ||
1248             first->raid_disks != second->raid_disks)
1249                 return 3;
1250         return 0;
1251 }
1252
1253 static int load_super1(struct supertype *st, int fd, char *devname)
1254 {
1255         unsigned long long dsize;
1256         unsigned long long sb_offset;
1257         struct mdp_superblock_1 *super;
1258         int uuid[4];
1259         struct bitmap_super_s *bsb;
1260         struct misc_dev_info *misc;
1261
1262         free_super1(st);
1263
1264         if (st->ss == NULL || st->minor_version == -1) {
1265                 int bestvers = -1;
1266                 struct supertype tst;
1267                 __u64 bestctime = 0;
1268                 /* guess... choose latest ctime */
1269                 memset(&tst, 0, sizeof(tst));
1270                 tst.ss = &super1;
1271                 for (tst.minor_version = 0; tst.minor_version <= 2 ; tst.minor_version++) {
1272                         switch(load_super1(&tst, fd, devname)) {
1273                         case 0: super = tst.sb;
1274                                 if (bestvers == -1 ||
1275                                     bestctime < __le64_to_cpu(super->ctime)) {
1276                                         bestvers = tst.minor_version;
1277                                         bestctime = __le64_to_cpu(super->ctime);
1278                                 }
1279                                 free(super);
1280                                 tst.sb = NULL;
1281                                 break;
1282                         case 1: return 1; /*bad device */
1283                         case 2: break; /* bad, try next */
1284                         }
1285                 }
1286                 if (bestvers != -1) {
1287                         int rv;
1288                         tst.minor_version = bestvers;
1289                         tst.ss = &super1;
1290                         tst.max_devs = 384;
1291                         rv = load_super1(&tst, fd, devname);
1292                         if (rv == 0)
1293                                 *st = tst;
1294                         return rv;
1295                 }
1296                 return 2;
1297         }
1298         if (!get_dev_size(fd, devname, &dsize))
1299                 return 1;
1300         dsize >>= 9;
1301
1302         if (dsize < 24) {
1303                 if (devname)
1304                         fprintf(stderr, Name ": %s is too small for md: size is %llu sectors.\n",
1305                                 devname, dsize);
1306                 return 1;
1307         }
1308
1309         /*
1310          * Calculate the position of the superblock.
1311          * It is always aligned to a 4K boundary and
1312          * depending on minor_version, it can be:
1313          * 0: At least 8K, but less than 12K, from end of device
1314          * 1: At start of device
1315          * 2: 4K from start of device.
1316          */
1317         switch(st->minor_version) {
1318         case 0:
1319                 sb_offset = dsize;
1320                 sb_offset -= 8*2;
1321                 sb_offset &= ~(4*2-1);
1322                 break;
1323         case 1:
1324                 sb_offset = 0;
1325                 break;
1326         case 2:
1327                 sb_offset = 4*2;
1328                 break;
1329         default:
1330                 return -EINVAL;
1331         }
1332
1333         ioctl(fd, BLKFLSBUF, 0); /* make sure we read current data */
1334
1335
1336         if (lseek64(fd, sb_offset << 9, 0)< 0LL) {
1337                 if (devname)
1338                         fprintf(stderr, Name ": Cannot seek to superblock on %s: %s\n",
1339                                 devname, strerror(errno));
1340                 return 1;
1341         }
1342
1343         if (posix_memalign((void**)&super, 512,
1344                        1024 + 512 +
1345                        sizeof(struct misc_dev_info)) != 0) {
1346                 fprintf(stderr, Name ": %s could not allocate superblock\n",
1347                         __func__);
1348                 return 1;
1349         }
1350
1351         if (aread(fd, super, 1024) != 1024) {
1352                 if (devname)
1353                         fprintf(stderr, Name ": Cannot read superblock on %s\n",
1354                                 devname);
1355                 free(super);
1356                 return 1;
1357         }
1358
1359         if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) {
1360                 if (devname)
1361                         fprintf(stderr, Name ": No super block found on %s (Expected magic %08x, got %08x)\n",
1362                                 devname, MD_SB_MAGIC, __le32_to_cpu(super->magic));
1363                 free(super);
1364                 return 2;
1365         }
1366
1367         if (__le32_to_cpu(super->major_version) != 1) {
1368                 if (devname)
1369                         fprintf(stderr, Name ": Cannot interpret superblock on %s - version is %d\n",
1370                                 devname, __le32_to_cpu(super->major_version));
1371                 free(super);
1372                 return 2;
1373         }
1374         if (__le64_to_cpu(super->super_offset) != sb_offset) {
1375                 if (devname)
1376                         fprintf(stderr, Name ": No superblock found on %s (super_offset is wrong)\n",
1377                                 devname);
1378                 free(super);
1379                 return 2;
1380         }
1381         st->sb = super;
1382
1383         bsb = (struct bitmap_super_s *)(((char*)super)+1024);
1384
1385         misc = (struct misc_dev_info*) (((char*)super)+1024+512);
1386         misc->device_size = dsize;
1387
1388         /* Now check on the bitmap superblock */
1389         if ((__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) == 0)
1390                 return 0;
1391         /* Read the bitmap superblock and make sure it looks
1392          * valid.  If it doesn't clear the bit.  An --assemble --force
1393          * should get that written out.
1394          */
1395         locate_bitmap1(st, fd);
1396         if (aread(fd, ((char*)super)+1024, 512)
1397             != 512)
1398                 goto no_bitmap;
1399
1400         uuid_from_super1(st, uuid);
1401         if (__le32_to_cpu(bsb->magic) != BITMAP_MAGIC ||
1402             memcmp(bsb->uuid, uuid, 16) != 0)
1403                 goto no_bitmap;
1404         return 0;
1405
1406  no_bitmap:
1407         super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map) & ~1);
1408         return 0;
1409 }
1410
1411
1412 static struct supertype *match_metadata_desc1(char *arg)
1413 {
1414         struct supertype *st = malloc(sizeof(*st));
1415         if (!st) return st;
1416
1417         memset(st, 0, sizeof(*st));
1418         st->container_dev = NoMdDev;
1419         st->ss = &super1;
1420         st->max_devs = 384;
1421         st->sb = NULL;
1422         /* leading zeros can be safely ignored.  --detail generates them. */
1423         while (*arg == '0')
1424                 arg++;
1425         if (strcmp(arg, "1.0") == 0 ||
1426             strcmp(arg, "1.00") == 0) {
1427                 st->minor_version = 0;
1428                 return st;
1429         }
1430         if (strcmp(arg, "1.1") == 0 ||
1431             strcmp(arg, "1.01") == 0
1432                 ) {
1433                 st->minor_version = 1;
1434                 return st;
1435         }
1436         if (strcmp(arg, "1.2") == 0 ||
1437 #ifndef DEFAULT_OLD_METADATA /* ifdef in super0.c */
1438             strcmp(arg, "default") == 0 ||
1439 #endif /* DEFAULT_OLD_METADATA */
1440             strcmp(arg, "1.02") == 0) {
1441                 st->minor_version = 2;
1442                 return st;
1443         }
1444         if (strcmp(arg, "1") == 0 ||
1445             strcmp(arg, "default") == 0) {
1446                 st->minor_version = -1;
1447                 return st;
1448         }
1449
1450         free(st);
1451         return NULL;
1452 }
1453
1454 /* find available size on device with this devsize, using
1455  * superblock type st, and reserving 'reserve' sectors for
1456  * a possible bitmap
1457  */
1458 static __u64 avail_size1(struct supertype *st, __u64 devsize)
1459 {
1460         struct mdp_superblock_1 *super = st->sb;
1461         if (devsize < 24)
1462                 return 0;
1463
1464         if (super == NULL)
1465                 /* creating:  allow suitable space for bitmap */
1466                 devsize -= choose_bm_space(devsize);
1467 #ifndef MDASSEMBLE
1468         else if (__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) {
1469                 /* hot-add. allow for actual size of bitmap */
1470                 struct bitmap_super_s *bsb;
1471                 bsb = (struct bitmap_super_s *)(((char*)super)+1024);
1472                 devsize -= bitmap_sectors(bsb);
1473         }
1474 #endif
1475
1476         if (st->minor_version < 0)
1477                 /* not specified, so time to set default */
1478                 st->minor_version = 2;
1479         if (super == NULL && st->minor_version > 0) {
1480                 /* haven't committed to a size yet, so allow some
1481                  * slack for alignment of data_offset.
1482                  * We haven't access to device details so allow
1483                  * 1 Meg if bigger than 1Gig
1484                  */
1485                 if (devsize > 1024*1024*2)
1486                         devsize -= 1024*2;
1487         }
1488         switch(st->minor_version) {
1489         case 0:
1490                 /* at end */
1491                 return ((devsize - 8*2 ) & ~(4*2-1));
1492         case 1:
1493                 /* at start, 4K for superblock and possible bitmap */
1494                 return devsize - 4*2;
1495         case 2:
1496                 /* 4k from start, 4K for superblock and possible bitmap */
1497                 return devsize - (4+4)*2;
1498         }
1499         return 0;
1500 }
1501
1502 static int
1503 add_internal_bitmap1(struct supertype *st,
1504                      int *chunkp, int delay, int write_behind,
1505                      unsigned long long size,
1506                      int may_change, int major)
1507 {
1508         /*
1509          * If not may_change, then this is a 'Grow', and the bitmap
1510          * must fit after the superblock.
1511          * If may_change, then this is create, and we can put the bitmap
1512          * before the superblock if we like, or may move the start.
1513          * If !may_change, the bitmap MUST live at offset of 1K, until
1514          * we get a sysfs interface.
1515          *
1516          * size is in sectors,  chunk is in bytes !!!
1517          */
1518
1519         unsigned long long bits;
1520         unsigned long long max_bits;
1521         unsigned long long min_chunk;
1522         long offset;
1523         unsigned long long chunk = *chunkp;
1524         int room = 0;
1525         struct mdp_superblock_1 *sb = st->sb;
1526         bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024);
1527         int uuid[4];
1528
1529         switch(st->minor_version) {
1530         case 0:
1531                 /* either 3K after the superblock (when hot-add),
1532                  * or some amount of space before.
1533                  */
1534                 if (may_change) {
1535                         /* We are creating array, so we *know* how much room has
1536                          * been left.
1537                          */
1538                         offset = 0;
1539                         room = choose_bm_space(__le64_to_cpu(sb->size));
1540                 } else {
1541                         room = __le64_to_cpu(sb->super_offset)
1542                                 - __le64_to_cpu(sb->data_offset)
1543                                 - __le64_to_cpu(sb->data_size);
1544                         /* remove '1 ||' when we can set offset via sysfs */
1545                         if (1 || (room < 3*2 &&
1546                                   __le32_to_cpu(sb->max_dev) <= 384)) {
1547                                 room = 3*2;
1548                                 offset = 1*2;
1549                         } else {
1550                                 offset = 0; /* means movable offset */
1551                         }
1552                 }
1553                 break;
1554         case 1:
1555         case 2: /* between superblock and data */
1556                 if (may_change) {
1557                         offset = 4*2;
1558                         room = choose_bm_space(__le64_to_cpu(sb->size));
1559                 } else {
1560                         room = __le64_to_cpu(sb->data_offset)
1561                                 - __le64_to_cpu(sb->super_offset);
1562                         if (1 || __le32_to_cpu(sb->max_dev) <= 384) {
1563                                 room -= 2;
1564                                 offset = 2;
1565                         } else {
1566                                 room -= 4*2;
1567                                 offset = 4*2;
1568                         }
1569                 }
1570                 break;
1571         default:
1572                 return 0;
1573         }
1574
1575         if (chunk == UnSet && room > 128*2)
1576                 /* Limit to 128K of bitmap when chunk size not requested */
1577                 room = 128*2;
1578
1579         max_bits = (room * 512 - sizeof(bitmap_super_t)) * 8;
1580
1581         min_chunk = 4096; /* sub-page chunks don't work yet.. */
1582         bits = (size*512)/min_chunk +1;
1583         while (bits > max_bits) {
1584                 min_chunk *= 2;
1585                 bits = (bits+1)/2;
1586         }
1587         if (chunk == UnSet) {
1588                 /* For practical purpose, 64Meg is a good
1589                  * default chunk size for internal bitmaps.
1590                  */
1591                 chunk = min_chunk;
1592                 if (chunk < 64*1024*1024)
1593                         chunk = 64*1024*1024;
1594         } else if (chunk < min_chunk)
1595                 return 0; /* chunk size too small */
1596         if (chunk == 0) /* rounding problem */
1597                 return 0;
1598
1599         if (offset == 0) {
1600                 /* start bitmap on a 4K boundary with enough space for
1601                  * the bitmap
1602                  */
1603                 bits = (size*512) / chunk + 1;
1604                 room = ((bits+7)/8 + sizeof(bitmap_super_t) +4095)/4096;
1605                 room *= 8; /* convert 4K blocks to sectors */
1606                 offset = -room;
1607         }
1608
1609         sb->bitmap_offset = __cpu_to_le32(offset);
1610
1611         sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | 1);
1612         memset(bms, 0, sizeof(*bms));
1613         bms->magic = __cpu_to_le32(BITMAP_MAGIC);
1614         bms->version = __cpu_to_le32(major);
1615         uuid_from_super1(st, uuid);
1616         memcpy(bms->uuid, uuid, 16);
1617         bms->chunksize = __cpu_to_le32(chunk);
1618         bms->daemon_sleep = __cpu_to_le32(delay);
1619         bms->sync_size = __cpu_to_le64(size);
1620         bms->write_behind = __cpu_to_le32(write_behind);
1621
1622         *chunkp = chunk;
1623         return 1;
1624 }
1625
1626
1627 static void locate_bitmap1(struct supertype *st, int fd)
1628 {
1629         unsigned long long offset;
1630         struct mdp_superblock_1 *sb;
1631         int mustfree = 0;
1632
1633         if (!st->sb) {
1634                 if (st->ss->load_super(st, fd, NULL))
1635                         return; /* no error I hope... */
1636                 mustfree = 1;
1637         }
1638         sb = st->sb;
1639
1640         offset = __le64_to_cpu(sb->super_offset);
1641         offset += (int32_t) __le32_to_cpu(sb->bitmap_offset);
1642         if (mustfree)
1643                 free(sb);
1644         lseek64(fd, offset<<9, 0);
1645 }
1646
1647 static int write_bitmap1(struct supertype *st, int fd)
1648 {
1649         struct mdp_superblock_1 *sb = st->sb;
1650         bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+1024);
1651         int rv = 0;
1652
1653         int towrite, n;
1654         char *buf = (char*)(((long)(abuf+4096))&~4095UL);
1655
1656         locate_bitmap1(st, fd);
1657
1658         memset(buf, 0xff, 4096);
1659         memcpy(buf, ((char*)sb)+1024, sizeof(bitmap_super_t));
1660
1661         towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9);
1662         towrite = (towrite+7) >> 3; /* bits to bytes */
1663         towrite += sizeof(bitmap_super_t);
1664         towrite = ROUND_UP(towrite, 512);
1665         while (towrite > 0) {
1666                 n = towrite;
1667                 if (n > 4096)
1668                         n = 4096;
1669                 n = write(fd, buf, n);
1670                 if (n > 0)
1671                         towrite -= n;
1672                 else
1673                         break;
1674                 memset(buf, 0xff, 4096);
1675         }
1676         fsync(fd);
1677         if (towrite)
1678                 rv = -2;
1679
1680         return rv;
1681 }
1682
1683 static void free_super1(struct supertype *st)
1684 {
1685         if (st->sb)
1686                 free(st->sb);
1687         while (st->info) {
1688                 struct devinfo *di = st->info;
1689                 st->info = di->next;
1690                 if (di->fd >= 0)
1691                         close(di->fd);
1692                 free(di);
1693         }
1694         st->sb = NULL;
1695 }
1696
1697 #ifndef MDASSEMBLE
1698 static int validate_geometry1(struct supertype *st, int level,
1699                               int layout, int raiddisks,
1700                               int *chunk, unsigned long long size,
1701                               char *subdev, unsigned long long *freesize,
1702                               int verbose)
1703 {
1704         unsigned long long ldsize;
1705         int fd;
1706
1707         if (level == LEVEL_CONTAINER) {
1708                 if (verbose)
1709                         fprintf(stderr, Name ": 1.x metadata does not support containers\n");
1710                 return 0;
1711         }
1712         if (chunk && *chunk == UnSet)
1713                 *chunk = DEFAULT_CHUNK;
1714
1715         if (!subdev)
1716                 return 1;
1717
1718         fd = open(subdev, O_RDONLY|O_EXCL, 0);
1719         if (fd < 0) {
1720                 if (verbose)
1721                         fprintf(stderr, Name ": super1.x cannot open %s: %s\n",
1722                                 subdev, strerror(errno));
1723                 return 0;
1724         }
1725
1726         if (!get_dev_size(fd, subdev, &ldsize)) {
1727                 close(fd);
1728                 return 0;
1729         }
1730         close(fd);
1731
1732         *freesize = avail_size1(st, ldsize >> 9);
1733         return 1;
1734 }
1735 #endif /* MDASSEMBLE */
1736
1737 struct superswitch super1 = {
1738 #ifndef MDASSEMBLE
1739         .examine_super = examine_super1,
1740         .brief_examine_super = brief_examine_super1,
1741         .export_examine_super = export_examine_super1,
1742         .detail_super = detail_super1,
1743         .brief_detail_super = brief_detail_super1,
1744         .export_detail_super = export_detail_super1,
1745         .write_init_super = write_init_super1,
1746         .validate_geometry = validate_geometry1,
1747         .add_to_super = add_to_super1,
1748 #endif
1749         .match_home = match_home1,
1750         .uuid_from_super = uuid_from_super1,
1751         .getinfo_super = getinfo_super1,
1752         .container_content = container_content1,
1753         .update_super = update_super1,
1754         .init_super = init_super1,
1755         .store_super = store_super1,
1756         .compare_super = compare_super1,
1757         .load_super = load_super1,
1758         .match_metadata_desc = match_metadata_desc1,
1759         .avail_size = avail_size1,
1760         .add_internal_bitmap = add_internal_bitmap1,
1761         .locate_bitmap = locate_bitmap1,
1762         .write_bitmap = write_bitmap1,
1763         .free_super = free_super1,
1764 #if __BYTE_ORDER == BIG_ENDIAN
1765         .swapuuid = 0,
1766 #else
1767         .swapuuid = 1,
1768 #endif
1769         .name = "1.x",
1770 };