Centralise code for copying uuid
[thirdparty/mdadm.git] / super1.c
1 /*
2  * mdadm - manage Linux "md" devices aka RAID arrays.
3  *
4  * Copyright (C) 2001-2006 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@cse.unsw.edu.au>
23  *    Paper: Neil Brown
24  *           School of Computer Science and Engineering
25  *           The University of New South Wales
26  *           Sydney, 2052
27  *           Australia
28  */
29
30 #include "mdadm.h"
31 /*
32  * The version-1 superblock :
33  * All numeric fields are little-endian.
34  *
35  * total size: 256 bytes plus 2 per device.
36  *  1K allows 384 devices.
37  */
38 struct mdp_superblock_1 {
39         /* constant array information - 128 bytes */
40         __u32   magic;          /* MD_SB_MAGIC: 0xa92b4efc - little endian */
41         __u32   major_version;  /* 1 */
42         __u32   feature_map;    /* 0 for now */
43         __u32   pad0;           /* always set to 0 when writing */
44
45         __u8    set_uuid[16];   /* user-space generated. */
46         char    set_name[32];   /* set and interpreted by user-space */
47
48         __u64   ctime;          /* lo 40 bits are seconds, top 24 are microseconds or 0*/
49         __u32   level;          /* -4 (multipath), -1 (linear), 0,1,4,5 */
50         __u32   layout;         /* only for raid5 currently */
51         __u64   size;           /* used size of component devices, in 512byte sectors */
52
53         __u32   chunksize;      /* in 512byte sectors */
54         __u32   raid_disks;
55         __u32   bitmap_offset;  /* sectors after start of superblock that bitmap starts
56                                  * NOTE: signed, so bitmap can be before superblock
57                                  * only meaningful of feature_map[0] is set.
58                                  */
59
60         /* These are only valid with feature bit '4' */
61         __u32   new_level;      /* new level we are reshaping to                */
62         __u64   reshape_position;       /* next address in array-space for reshape */
63         __u32   delta_disks;    /* change in number of raid_disks               */
64         __u32   new_layout;     /* new layout                                   */
65         __u32   new_chunk;      /* new chunk size (bytes)                       */
66         __u8    pad1[128-124];  /* set to 0 when written */
67
68         /* constant this-device information - 64 bytes */
69         __u64   data_offset;    /* sector start of data, often 0 */
70         __u64   data_size;      /* sectors in this device that can be used for data */
71         __u64   super_offset;   /* sector start of this superblock */
72         __u64   recovery_offset;/* sectors before this offset (from data_offset) have been recovered */
73         __u32   dev_number;     /* permanent identifier of this  device - not role in raid */
74         __u32   cnt_corrected_read; /* number of read errors that were corrected by re-writing */
75         __u8    device_uuid[16]; /* user-space setable, ignored by kernel */
76         __u8    devflags;        /* per-device flags.  Only one defined...*/
77 #define WriteMostly1    1        /* mask for writemostly flag in above */
78         __u8    pad2[64-57];    /* set to 0 when writing */
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 devs[max_dev] */
85         __u32   max_dev;        /* size of devs[] 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
108 #define MD_FEATURE_ALL                  (1|2|4)
109
110 #ifndef offsetof
111 #define offsetof(t,f) ((size_t)&(((t*)0)->f))
112 #endif
113 static unsigned int calc_sb_1_csum(struct mdp_superblock_1 * sb)
114 {
115         unsigned int disk_csum, csum;
116         unsigned long long newcsum;
117         int size = sizeof(*sb) + __le32_to_cpu(sb->max_dev)*2;
118         unsigned int *isuper = (unsigned int*)sb;
119         int i;
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 (i=0; 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 #ifndef MDASSEMBLE
145 static void examine_super1(void *sbv, char *homehost)
146 {
147         struct mdp_superblock_1 *sb = sbv;
148         time_t atime;
149         int d;
150         int faulty;
151         int i;
152         char *c;
153         int l = homehost ? strlen(homehost) : 0;
154         int layout;
155
156         printf("          Magic : %08x\n", __le32_to_cpu(sb->magic));
157         printf("        Version : %02d\n", 1);
158         printf("    Feature Map : 0x%x\n", __le32_to_cpu(sb->feature_map));
159         printf("     Array UUID : ");
160         for (i=0; i<16; i++) {
161                 if ((i&3)==0 && i != 0) printf(":");
162                 printf("%02x", sb->set_uuid[i]);
163         }
164         printf("\n");
165         printf("           Name : %.32s", sb->set_name);
166         if (l > 0 && l < 32 &&
167             sb->set_name[l] == ':' &&
168             strncmp(sb->set_name, homehost, l) == 0)
169                 printf("  (local to host %s)", homehost);
170         printf("\n");
171         atime = __le64_to_cpu(sb->ctime) & 0xFFFFFFFFFFULL;
172         printf("  Creation Time : %.24s\n", ctime(&atime));
173         c=map_num(pers, __le32_to_cpu(sb->level));
174         printf("     Raid Level : %s\n", c?c:"-unknown-");
175         printf("   Raid Devices : %d\n", __le32_to_cpu(sb->raid_disks));
176         printf("\n");
177         printf("  Used Dev Size : %llu%s\n",
178                (unsigned long long)sb->data_size,
179                human_size(sb->data_size<<9));
180         if (__le32_to_cpu(sb->level) >= 0) {
181                 int ddsks=0;
182                 switch(__le32_to_cpu(sb->level)) {
183                 case 1: ddsks=1;break;
184                 case 4:
185                 case 5: ddsks = __le32_to_cpu(sb->raid_disks)-1; break;
186                 case 6: ddsks = __le32_to_cpu(sb->raid_disks)-2; break;
187                 case 10:
188                         layout = __le32_to_cpu(sb->layout);
189                         ddsks = __le32_to_cpu(sb->raid_disks)
190                                  / (layout&255) / ((layout>>8)&255);
191                 }
192                 if (ddsks)
193                         printf("     Array Size : %llu%s\n",
194                                ddsks*(unsigned long long)__le64_to_cpu(sb->size),
195                                human_size(ddsks*__le64_to_cpu(sb->size)<<9));
196                 if (sb->size != sb->data_size)
197                         printf("      Used Size : %llu%s\n",
198                                (unsigned long long)__le64_to_cpu(sb->size),
199                                human_size(__le64_to_cpu(sb->size)<<9));
200         }
201         if (sb->data_offset)
202                 printf("    Data Offset : %llu sectors\n",
203                        (unsigned long long)__le64_to_cpu(sb->data_offset));
204         printf("   Super Offset : %llu sectors\n",
205                (unsigned long long)__le64_to_cpu(sb->super_offset));
206         if (__le32_to_cpu(sb->feature_map) & MD_FEATURE_RECOVERY_OFFSET)
207                 printf("Recovery Offset : %llu sectors\n", (unsigned long long)__le64_to_cpu(sb->recovery_offset));
208         printf("          State : %s\n", (__le64_to_cpu(sb->resync_offset)+1)? "active":"clean");
209         printf("    Device UUID : ");
210         for (i=0; i<16; i++) {
211                 if ((i&3)==0 && i != 0) printf(":");
212                 printf("%02x", sb->device_uuid[i]);
213         }
214         printf("\n");
215         printf("\n");
216         if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
217                 printf("Internal Bitmap : %ld sectors from superblock\n",
218                        (long)__le32_to_cpu(sb->bitmap_offset));
219         }
220         if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
221                 printf("  Reshape pos'n : %llu%s\n", (unsigned long long)__le64_to_cpu(sb->reshape_position)/2,
222                        human_size(__le64_to_cpu(sb->reshape_position)<<9));
223                 if (__le32_to_cpu(sb->delta_disks)) {
224                         printf("  Delta Devices : %d", __le32_to_cpu(sb->delta_disks));
225                         if (__le32_to_cpu(sb->delta_disks))
226                                 printf(" (%d->%d)\n",
227                                        __le32_to_cpu(sb->raid_disks)-__le32_to_cpu(sb->delta_disks),
228                                        __le32_to_cpu(sb->raid_disks));
229                         else
230                                 printf(" (%d->%d)\n", __le32_to_cpu(sb->raid_disks),
231                                        __le32_to_cpu(sb->raid_disks)+__le32_to_cpu(sb->delta_disks));
232                 }
233                 if (__le32_to_cpu(sb->new_level) != __le32_to_cpu(sb->level)) {
234                         c = map_num(pers, __le32_to_cpu(sb->new_level));
235                         printf("      New Level : %s\n", c?c:"-unknown-");
236                 }
237                 if (__le32_to_cpu(sb->new_layout) != __le32_to_cpu(sb->layout)) {
238                         if (__le32_to_cpu(sb->level) == 5) {
239                                 c = map_num(r5layout, __le32_to_cpu(sb->new_layout));
240                                 printf("     New Layout : %s\n", c?c:"-unknown-");
241                         }
242                         if (__le32_to_cpu(sb->level) == 10) {
243                                 printf("     New Layout : near=%d, %s=%d\n",
244                                        __le32_to_cpu(sb->new_layout)&255,
245                                        (__le32_to_cpu(sb->new_layout)&0x10000)?"offset":"far",
246                                        (__le32_to_cpu(sb->new_layout)>>8)&255);
247                         }
248                 }
249                 if (__le32_to_cpu(sb->new_chunk) != __le32_to_cpu(sb->chunksize))
250                         printf("  New Chunksize : %dK\n", __le32_to_cpu(sb->new_chunk)/2);
251                 printf("\n");
252         }
253         if (sb->devflags) {
254                 printf("      Flags :");
255                 if (sb->devflags & WriteMostly1)
256                         printf(" write-mostly");
257                 printf("\n");
258         }
259
260         atime = __le64_to_cpu(sb->utime) & 0xFFFFFFFFFFULL;
261         printf("    Update Time : %.24s\n", ctime(&atime));
262
263         if (calc_sb_1_csum(sb) == sb->sb_csum)
264                 printf("       Checksum : %x - correct\n", __le32_to_cpu(sb->sb_csum));
265         else
266                 printf("       Checksum : %x - expected %x\n", __le32_to_cpu(sb->sb_csum),
267                        __le32_to_cpu(calc_sb_1_csum(sb)));
268         printf("         Events : %llu\n", (unsigned long long)__le64_to_cpu(sb->events));
269         printf("\n");
270         if (__le32_to_cpu(sb->level) == 5) {
271                 c = map_num(r5layout, __le32_to_cpu(sb->layout));
272                 printf("         Layout : %s\n", c?c:"-unknown-");
273         }
274         if (__le32_to_cpu(sb->level) == 10) {
275                 int lo = __le32_to_cpu(sb->layout);
276                 printf("         Layout : near=%d, %s=%d\n",
277                        lo&255,
278                        (lo&0x10000)?"offset":"far",
279                        (lo>>8)&255);
280         }
281         switch(__le32_to_cpu(sb->level)) {
282         case 0:
283         case 4:
284         case 5:
285         case 6:
286         case 10:
287                 printf("     Chunk Size : %dK\n", __le32_to_cpu(sb->chunksize)/2);
288                 break;
289         case -1:
290                 printf("       Rounding : %dK\n", __le32_to_cpu(sb->chunksize)/2);
291                 break;
292         default: break;
293         }
294         printf("\n");
295         printf("    Array Slot : %d (", __le32_to_cpu(sb->dev_number));
296         for (i= __le32_to_cpu(sb->max_dev); i> 0 ; i--)
297                 if (__le16_to_cpu(sb->dev_roles[i-1]) != 0xffff)
298                         break;
299         for (d=0; d < i; d++) {
300                 int role = __le16_to_cpu(sb->dev_roles[d]);
301                 if (d) printf(", ");
302                 if (role == 0xffff) printf("empty");
303                 else if(role == 0xfffe) printf("failed");
304                 else printf("%d", role);
305         }
306         printf(")\n");
307         printf("   Array State : ");
308         for (d=0; d<__le32_to_cpu(sb->raid_disks); d++) {
309                 int cnt = 0;
310                 int me = 0;
311                 int i;
312                 for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
313                         int role = __le16_to_cpu(sb->dev_roles[i]);
314                         if (role == d) {
315                                 if (i == __le32_to_cpu(sb->dev_number))
316                                         me = 1;
317                                 cnt++;
318                         }
319                 }
320                 if (cnt > 1) printf("?");
321                 else if (cnt == 1 && me) printf("U");
322                 else if (cnt == 1) printf("u");
323                 else printf ("_");
324         }
325         faulty = 0;
326         for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
327                 int role = __le16_to_cpu(sb->dev_roles[i]);
328                 if (role == 0xFFFE)
329                         faulty++;
330         }
331         if (faulty) printf(" %d failed", faulty);
332         printf("\n");
333 }
334
335
336 static void brief_examine_super1(void *sbv)
337 {
338         struct mdp_superblock_1 *sb = sbv;
339         int i;
340         char *nm;
341         char *c=map_num(pers, __le32_to_cpu(sb->level));
342
343         nm = strchr(sb->set_name, ':');
344         if (nm)
345                 nm++;
346         else if (sb->set_name[0])
347                 nm = sb->set_name;
348         else
349                 nm = "??";
350
351         printf("ARRAY /dev/md/%s level=%s metadata=1 num-devices=%d UUID=",
352                nm,
353                c?c:"-unknown-", __le32_to_cpu(sb->raid_disks));
354         for (i=0; i<16; i++) {
355                 if ((i&3)==0 && i != 0) printf(":");
356                 printf("%02x", sb->set_uuid[i]);
357         }
358         if (sb->set_name[0])
359                 printf(" name=%.32s", sb->set_name);
360         printf("\n");
361 }
362
363 static void detail_super1(void *sbv, char *homehost)
364 {
365         struct mdp_superblock_1 *sb = sbv;
366         int i;
367         int l = homehost ? strlen(homehost) : 0;
368
369         printf("           Name : %.32s", sb->set_name);
370         if (l > 0 && l < 32 &&
371             sb->set_name[l] == ':' &&
372             strncmp(sb->set_name, homehost, l) == 0)
373                 printf("  (local to host %s)", homehost);
374         printf("\n           UUID : ");
375         for (i=0; i<16; i++) {
376                 if ((i&3)==0 && i != 0) printf(":");
377                 printf("%02x", sb->set_uuid[i]);
378         }
379         printf("\n         Events : %llu\n\n", (unsigned long long)__le64_to_cpu(sb->events));
380 }
381
382 static void brief_detail_super1(void *sbv)
383 {
384         struct mdp_superblock_1 *sb = sbv;
385         int i;
386
387         if (sb->set_name[0])
388                 printf(" name=%.32s", sb->set_name);
389         printf(" UUID=");
390         for (i=0; i<16; i++) {
391                 if ((i&3)==0 && i != 0) printf(":");
392                 printf("%02x", sb->set_uuid[i]);
393         }
394 }
395
396 #endif
397
398 static int match_home1(void *sbv, char *homehost)
399 {
400         struct mdp_superblock_1 *sb = sbv;
401         int l = homehost ? strlen(homehost) : 0;
402
403         return (l > 0 && l < 32 &&
404                 sb->set_name[l] == ':' &&
405                 strncmp(sb->set_name, homehost, l) == 0);
406 }
407
408 static void uuid_from_super1(int uuid[4], void * sbv)
409 {
410         struct mdp_superblock_1 *super = sbv;
411         char *cuuid = (char*)uuid;
412         int i;
413         for (i=0; i<16; i++)
414                 cuuid[i] = super->set_uuid[i];
415 }
416
417 static void getinfo_super1(struct mdinfo *info, void *sbv)
418 {
419         struct mdp_superblock_1 *sb = sbv;
420         int working = 0;
421         int i;
422         int role;
423
424         info->array.major_version = 1;
425         info->array.minor_version = __le32_to_cpu(sb->feature_map);
426         info->array.patch_version = 0;
427         info->array.raid_disks = __le32_to_cpu(sb->raid_disks);
428         info->array.level = __le32_to_cpu(sb->level);
429         info->array.layout = __le32_to_cpu(sb->layout);
430         info->array.md_minor = -1;
431         info->array.ctime = __le64_to_cpu(sb->ctime);
432         info->array.utime = __le64_to_cpu(sb->utime);
433         info->array.chunk_size = __le32_to_cpu(sb->chunksize)*512;
434         info->array.state =
435                 (__le64_to_cpu(sb->resync_offset) >= __le64_to_cpu(sb->size))
436                 ? 1 : 0;
437
438         info->data_offset = __le64_to_cpu(sb->data_offset);
439         info->component_size = __le64_to_cpu(sb->size);
440
441         info->disk.major = 0;
442         info->disk.minor = 0;
443         info->disk.number = __le32_to_cpu(sb->dev_number);
444         if (__le32_to_cpu(sb->dev_number) >= __le32_to_cpu(sb->max_dev) ||
445             __le32_to_cpu(sb->max_dev) > 512)
446                 role = 0xfffe;
447         else
448                 role = __le16_to_cpu(sb->dev_roles[__le32_to_cpu(sb->dev_number)]);
449
450         info->disk.raid_disk = -1;
451         switch(role) {
452         case 0xFFFF:
453                 info->disk.state = 2; /* spare: ACTIVE, not sync, not faulty */
454                 break;
455         case 0xFFFE:
456                 info->disk.state = 1; /* faulty */
457                 break;
458         default:
459                 info->disk.state = 6; /* active and in sync */
460                 info->disk.raid_disk = role;
461         }
462         info->events = __le64_to_cpu(sb->events);
463
464         memcpy(info->uuid, sb->set_uuid, 16);
465
466         strncpy(info->name, sb->set_name, 32);
467         info->name[32] = 0;
468
469         if (sb->feature_map & __le32_to_cpu(MD_FEATURE_RESHAPE_ACTIVE)) {
470                 info->reshape_active = 1;
471                 info->reshape_progress = __le64_to_cpu(sb->reshape_position);
472                 info->new_level = __le32_to_cpu(sb->new_level);
473                 info->delta_disks = __le32_to_cpu(sb->delta_disks);
474                 info->new_layout = __le32_to_cpu(sb->new_layout);
475                 info->new_chunk = __le32_to_cpu(sb->new_chunk)<<9;
476         } else
477                 info->reshape_active = 0;
478
479         for (i=0; i< __le32_to_cpu(sb->max_dev); i++) {
480                 role = __le16_to_cpu(sb->dev_roles[i]);
481                 if (/*role == 0xFFFF || */role < info->array.raid_disks)
482                         working++;
483         }
484
485         info->array.working_disks = working;
486 }
487
488 static int update_super1(struct mdinfo *info, void *sbv, char *update,
489                          char *devname, int verbose,
490                          int uuid_set, char *homehost)
491 {
492         /* NOTE: for 'assemble' and 'force' we need to return non-zero if any change was made.
493          * For others, the return value is ignored.
494          */
495         int rv = 0;
496         struct mdp_superblock_1 *sb = sbv;
497
498         if (strcmp(update, "force-one")==0) {
499                 /* Not enough devices for a working array,
500                  * so bring this one up-to-date
501                  */
502                 if (sb->events != __cpu_to_le64(info->events))
503                         rv = 1;
504                 sb->events = __cpu_to_le64(info->events);
505         }
506         if (strcmp(update, "force-array")==0) {
507                 /* Degraded array and 'force' requests to
508                  * maybe need to mark it 'clean'.
509                  */
510                 switch(__le32_to_cpu(sb->level)) {
511                 case 5: case 4: case 6:
512                         /* need to force clean */
513                         if (sb->resync_offset != ~0ULL)
514                                 rv = 1;
515                         sb->resync_offset = ~0ULL;
516                 }
517         }
518         if (strcmp(update, "assemble")==0) {
519                 int d = info->disk.number;
520                 int want;
521                 if (info->disk.state == 6)
522                         want = __cpu_to_le32(info->disk.raid_disk);
523                 else
524                         want = 0xFFFF;
525                 if (sb->dev_roles[d] != want) {
526                         sb->dev_roles[d] = want;
527                         rv = 1;
528                 }
529         }
530         if (strcmp(update, "grow") == 0) {
531                 sb->raid_disks = __cpu_to_le32(info->array.raid_disks);
532                 /* As we are just adding a spare, there is no need to
533                  * make any change to the dev_roles array
534                  */
535         }
536         if (strcmp(update, "resync") == 0) {
537                 /* make sure resync happens */
538                 sb->resync_offset = 0ULL;
539         }
540         if (strcmp(update, "uuid") == 0) {
541                 copy_uuid(sb->set_uuid, info->uuid, super1.swapuuid);
542
543                 if (__le32_to_cpu(sb->feature_map)&MD_FEATURE_BITMAP_OFFSET) {
544                         struct bitmap_super_s *bm;
545                         bm = (struct bitmap_super_s*)(sbv+1024);
546                         memcpy(bm->uuid, sb->set_uuid, 16);
547                 }
548         }
549         if (strcmp(update, "homehost") == 0 &&
550             homehost) {
551                 char *c;
552                 update = "name";
553                 c = strchr(sb->set_name, ':');
554                 if (c)
555                         strncpy(info->name, c+1, 31 - (c-sb->set_name));
556                 else
557                         strncpy(info->name, sb->set_name, 32);
558                 info->name[32] = 0;
559         }
560         if (strcmp(update, "name") == 0) {
561                 if (info->name[0] == 0)
562                         sprintf(info->name, "%d", info->array.md_minor);
563                 memset(sb->set_name, 0, sizeof(sb->set_name));
564                 if (homehost &&
565                     strchr(info->name, ':') == NULL &&
566                     strlen(homehost)+1+strlen(info->name) < 32) {
567                         strcpy(sb->set_name, homehost);
568                         strcat(sb->set_name, ":");
569                         strcat(sb->set_name, info->name);
570                 } else
571                         strcpy(sb->set_name, info->name);
572         }
573         if (strcmp(update, "devicesize") == 0 &&
574             __le64_to_cpu(sb->super_offset) <
575             __le64_to_cpu(sb->data_offset)) {
576                 /* set data_size to device size less data_offset */
577                 struct misc_dev_info *misc = (struct misc_dev_info*)
578                         (sbv + 1024 + sizeof(struct bitmap_super_s));
579                 printf("Size was %llu\n", __le64_to_cpu(sb->data_size));
580                 sb->data_size = __cpu_to_le64(
581                         misc->device_size - __le64_to_cpu(sb->data_offset));
582                 printf("Size is %llu\n", __le64_to_cpu(sb->data_size));
583         }
584         if (strcmp(update, "_reshape_progress")==0)
585                 sb->reshape_position = __cpu_to_le64(info->reshape_progress);
586
587         sb->sb_csum = calc_sb_1_csum(sb);
588         return rv;
589 }
590
591 static int init_super1(struct supertype *st, void **sbp, mdu_array_info_t *info,
592                        unsigned long long size, char *name, char *homehost, int *uuid)
593 {
594         struct mdp_superblock_1 *sb = malloc(1024 + sizeof(bitmap_super_t) +
595                                              sizeof(struct misc_dev_info));
596         int spares;
597         int rfd;
598         char defname[10];
599         memset(sb, 0, 1024);
600
601         if (info->major_version == -1) {
602                 /* zeroing superblock */
603                 *sbp = sb;
604                 return 0;
605         }
606
607         spares = info->working_disks - info->active_disks;
608         if (info->raid_disks + spares  > 384) {
609                 fprintf(stderr, Name ": too many devices requested: %d+%d > %d\n",
610                         info->raid_disks , spares, 384);
611                 return 0;
612         }
613
614         sb->magic = __cpu_to_le32(MD_SB_MAGIC);
615         sb->major_version = __cpu_to_le32(1);
616         sb->feature_map = 0;
617         sb->pad0 = 0;
618
619         if (uuid)
620                 copy_uuid(sb->set_uuid, uuid, super1.swapuuid);
621         else {
622                 if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
623                     read(rfd, sb->set_uuid, 16) != 16) {
624                         *(__u32*)(sb->set_uuid) = random();
625                         *(__u32*)(sb->set_uuid+4) = random();
626                         *(__u32*)(sb->set_uuid+8) = random();
627                         *(__u32*)(sb->set_uuid+12) = random();
628                 }
629                 if (rfd >= 0) close(rfd);
630         }
631
632         if (name == NULL || *name == 0) {
633                 sprintf(defname, "%d", info->md_minor);
634                 name = defname;
635         }
636         memset(sb->set_name, 0, 32);
637         if (homehost &&
638             strchr(name, ':')== NULL &&
639             strlen(homehost)+1+strlen(name) < 32) {
640                 strcpy(sb->set_name, homehost);
641                 strcat(sb->set_name, ":");
642                 strcat(sb->set_name, name);
643         } else
644                 strcpy(sb->set_name, name);
645
646         sb->ctime = __cpu_to_le64((unsigned long long)time(0));
647         sb->level = __cpu_to_le32(info->level);
648         sb->layout = __cpu_to_le32(info->layout);
649         sb->size = __cpu_to_le64(size*2ULL);
650         sb->chunksize = __cpu_to_le32(info->chunk_size>>9);
651         sb->raid_disks = __cpu_to_le32(info->raid_disks);
652
653         sb->data_offset = __cpu_to_le64(0);
654         sb->data_size = __cpu_to_le64(0);
655         sb->super_offset = __cpu_to_le64(0);
656         sb->recovery_offset = __cpu_to_le64(0);
657
658         sb->utime = sb->ctime;
659         sb->events = __cpu_to_le64(1);
660         if (info->state & (1<<MD_SB_CLEAN))
661                 sb->resync_offset = ~0ULL;
662         else
663                 sb->resync_offset = 0;
664         sb->max_dev = __cpu_to_le32((1024- sizeof(struct mdp_superblock_1))/
665                                     sizeof(sb->dev_roles[0]));
666         memset(sb->pad3, 0, sizeof(sb->pad3));
667
668         memset(sb->dev_roles, 0xff, 1024 - sizeof(struct mdp_superblock_1));
669
670         *sbp = sb;
671         return 1;
672 }
673
674 /* Add a device to the superblock being created */
675 static void add_to_super1(void *sbv, mdu_disk_info_t *dk)
676 {
677         struct mdp_superblock_1 *sb = sbv;
678         __u16 *rp = sb->dev_roles + dk->number;
679         if ((dk->state & 6) == 6) /* active, sync */
680                 *rp = __cpu_to_le16(dk->raid_disk);
681         else if ((dk->state & ~2) == 0) /* active or idle -> spare */
682                 *rp = 0xffff;
683         else
684                 *rp = 0xfffe;
685 }
686
687 static void locate_bitmap1(struct supertype *st, int fd, void *sbv);
688
689 static int store_super1(struct supertype *st, int fd, void *sbv)
690 {
691         struct mdp_superblock_1 *sb = sbv;
692         unsigned long long sb_offset;
693         int sbsize;
694         unsigned long long dsize;
695
696         if (!get_dev_size(fd, NULL, &dsize))
697                 return 1;
698
699         dsize >>= 9;
700
701         if (dsize < 24)
702                 return 2;
703
704         /*
705          * Calculate the position of the superblock.
706          * It is always aligned to a 4K boundary and
707          * depending on minor_version, it can be:
708          * 0: At least 8K, but less than 12K, from end of device
709          * 1: At start of device
710          * 2: 4K from start of device.
711          */
712         switch(st->minor_version) {
713         case 0:
714                 sb_offset = dsize;
715                 sb_offset -= 8*2;
716                 sb_offset &= ~(4*2-1);
717                 break;
718         case 1:
719                 sb_offset = 0;
720                 break;
721         case 2:
722                 sb_offset = 4*2;
723                 break;
724         default:
725                 return -EINVAL;
726         }
727
728
729
730         if (sb_offset != __le64_to_cpu(sb->super_offset) &&
731             0 != __le64_to_cpu(sb->super_offset)
732                 ) {
733                 fprintf(stderr, Name ": internal error - sb_offset is wrong\n");
734                 abort();
735         }
736
737         if (lseek64(fd, sb_offset << 9, 0)< 0LL)
738                 return 3;
739
740         sbsize = sizeof(*sb) + 2 * __le32_to_cpu(sb->max_dev);
741
742         if (write(fd, sb, sbsize) != sbsize)
743                 return 4;
744
745         if (sb->feature_map & __cpu_to_le32(MD_FEATURE_BITMAP_OFFSET)) {
746                 struct bitmap_super_s *bm = (struct bitmap_super_s*)
747                         (((char*)sb)+1024);
748                 if (__le32_to_cpu(bm->magic) == BITMAP_MAGIC) {
749                         locate_bitmap1(st, fd, sbv);
750                         if (write(fd, bm, sizeof(*bm)) != sizeof(*bm))
751                             return 5;
752                 }
753         }
754         fsync(fd);
755         return 0;
756 }
757
758 static int load_super1(struct supertype *st, int fd, void **sbp, char *devname);
759
760 static int write_init_super1(struct supertype *st, void *sbv,
761                              mdu_disk_info_t *dinfo, char *devname)
762 {
763         struct mdp_superblock_1 *sb = sbv;
764         void *refsbv = NULL;
765         int fd = open(devname, O_RDWR | O_EXCL);
766         int rfd;
767         int rv;
768         int bm_space;
769
770         unsigned long space;
771         unsigned long long dsize, array_size;
772         long long sb_offset;
773
774
775         if (fd < 0) {
776                 fprintf(stderr, Name ": Failed to open %s to write superblock\n",
777                         devname);
778                 return -1;
779         }
780
781         sb->dev_number = __cpu_to_le32(dinfo->number);
782         if (dinfo->state & (1<<MD_DISK_WRITEMOSTLY))
783                 sb->devflags |= __cpu_to_le32(WriteMostly1);
784
785         if ((rfd = open("/dev/urandom", O_RDONLY)) < 0 ||
786             read(rfd, sb->device_uuid, 16) != 16) {
787                 *(__u32*)(sb->device_uuid) = random();
788                 *(__u32*)(sb->device_uuid+4) = random();
789                 *(__u32*)(sb->device_uuid+8) = random();
790                 *(__u32*)(sb->device_uuid+12) = random();
791         }
792         if (rfd >= 0) close(rfd);
793         sb->events = 0;
794
795         if (load_super1(st, fd, &refsbv, NULL)==0) {
796                 struct mdp_superblock_1 *refsb = refsbv;
797
798                 memcpy(sb->device_uuid, refsb->device_uuid, 16);
799                 if (memcmp(sb->set_uuid, refsb->set_uuid, 16)==0) {
800                         /* same array, so preserve events and dev_number */
801                         sb->events = refsb->events;
802                         /* bugs in 2.6.17 and earlier mean the dev_number
803                          * chosen in Manage must be preserved
804                          */
805                         if (get_linux_version() >= 2006018)
806                                 sb->dev_number = refsb->dev_number;
807                 }
808                 free(refsb);
809         }
810
811         if (!get_dev_size(fd, NULL, &dsize))
812                 return 1;
813         dsize >>= 9;
814
815         if (dsize < 24) {
816                 close(fd);
817                 return 2;
818         }
819
820
821         /*
822          * Calculate the position of the superblock.
823          * It is always aligned to a 4K boundary and
824          * depending on minor_version, it can be:
825          * 0: At least 8K, but less than 12K, from end of device
826          * 1: At start of device
827          * 2: 4K from start of device.
828          * Depending on the array size, we might leave extra space
829          * for a bitmap.
830          */
831         array_size = __le64_to_cpu(sb->size);
832         /* work out how much space we left of a bitmap */
833         if (array_size >= 200*1024*1024*2)
834                 bm_space = 128*2;
835         else if (array_size > 8*1024*1024*2)
836                 bm_space = 64*2;
837         else
838                 bm_space = 0;
839
840         switch(st->minor_version) {
841         case 0:
842                 sb_offset = dsize;
843                 sb_offset -= 8*2;
844                 sb_offset &= ~(4*2-1);
845                 sb->super_offset = __cpu_to_le64(sb_offset);
846                 sb->data_offset = __cpu_to_le64(0);
847                 sb->data_size = __cpu_to_le64(sb_offset - bm_space);
848                 break;
849         case 1:
850                 sb->super_offset = __cpu_to_le64(0);
851                 sb->data_offset = __cpu_to_le64(bm_space + 4*2);
852                 sb->data_size = __cpu_to_le64(dsize - bm_space - 4*2);
853                 break;
854         case 2:
855                 sb_offset = 4*2;
856                 if (dsize - 4*2 - 64*2 >= array_size && array_size > 8*1024*1024*2)
857                         space = 64*2;
858                 else
859                         space = 4*2;
860                 sb->super_offset = __cpu_to_le64(4*2);
861                 sb->data_offset = __cpu_to_le64(4*2 + 4*2 + bm_space);
862                 sb->data_size = __cpu_to_le64(dsize - 4*2 - 4*2 - bm_space );
863                 break;
864         default:
865                 return -EINVAL;
866         }
867
868
869         sb->sb_csum = calc_sb_1_csum(sb);
870         rv = store_super1(st, fd, sb);
871         if (rv)
872                 fprintf(stderr, Name ": failed to write superblock to %s\n", devname);
873
874         if (rv == 0 && (__le32_to_cpu(sb->feature_map) & 1))
875                 rv = st->ss->write_bitmap(st, fd, sbv);
876         close(fd);
877         return rv;
878 }
879
880 static int compare_super1(void **firstp, void *secondv)
881 {
882         /*
883          * return:
884          *  0 same, or first was empty, and second was copied
885          *  1 second had wrong number
886          *  2 wrong uuid
887          *  3 wrong other info
888          */
889         struct mdp_superblock_1 *first = *firstp;
890         struct mdp_superblock_1 *second = secondv;
891
892         if (second->magic != __cpu_to_le32(MD_SB_MAGIC))
893                 return 1;
894         if (second->major_version != __cpu_to_le32(1))
895                 return 1;
896
897         if (!first) {
898                 first = malloc(1024+sizeof(bitmap_super_t) +
899                                sizeof(struct misc_dev_info));
900                 memcpy(first, second, 1024+sizeof(bitmap_super_t) +
901                        sizeof(struct misc_dev_info));
902                 *firstp = first;
903                 return 0;
904         }
905         if (memcmp(first->set_uuid, second->set_uuid, 16)!= 0)
906                 return 2;
907
908         if (first->ctime      != second->ctime     ||
909             first->level      != second->level     ||
910             first->layout     != second->layout    ||
911             first->size       != second->size      ||
912             first->chunksize  != second->chunksize ||
913             first->raid_disks != second->raid_disks)
914                 return 3;
915         return 0;
916 }
917
918 static int load_super1(struct supertype *st, int fd, void **sbp, char *devname)
919 {
920         unsigned long long dsize;
921         unsigned long long sb_offset;
922         struct mdp_superblock_1 *super;
923         int uuid[4];
924         struct bitmap_super_s *bsb;
925         struct misc_dev_info *misc;
926
927
928         if (st->ss == NULL) {
929                 int bestvers = -1;
930                 __u64 bestctime = 0;
931                 /* guess... choose latest ctime */
932                 st->ss = &super1;
933                 for (st->minor_version = 0; st->minor_version <= 2 ; st->minor_version++) {
934                         switch(load_super1(st, fd, sbp, devname)) {
935                         case 0: super = *sbp;
936                                 if (bestvers == -1 ||
937                                     bestctime < __le64_to_cpu(super->ctime)) {
938                                         bestvers = st->minor_version;
939                                         bestctime = __le64_to_cpu(super->ctime);
940                                 }
941                                 free(super);
942                                 *sbp = NULL;
943                                 break;
944                         case 1: st->ss = NULL; return 1; /*bad device */
945                         case 2: break; /* bad, try next */
946                         }
947                 }
948                 if (bestvers != -1) {
949                         int rv;
950                         st->minor_version = bestvers;
951                         st->ss = &super1;
952                         st->max_devs = 384;
953                         rv = load_super1(st, fd, sbp, devname);
954                         if (rv) st->ss = NULL;
955                         return rv;
956                 }
957                 st->ss = NULL;
958                 return 2;
959         }
960         if (!get_dev_size(fd, devname, &dsize))
961                 return 1;
962         dsize >>= 9;
963
964         if (dsize < 24) {
965                 if (devname)
966                         fprintf(stderr, Name ": %s is too small for md: size is %llu sectors.\n",
967                                 devname, dsize);
968                 return 1;
969         }
970
971         /*
972          * Calculate the position of the superblock.
973          * It is always aligned to a 4K boundary and
974          * depending on minor_version, it can be:
975          * 0: At least 8K, but less than 12K, from end of device
976          * 1: At start of device
977          * 2: 4K from start of device.
978          */
979         switch(st->minor_version) {
980         case 0:
981                 sb_offset = dsize;
982                 sb_offset -= 8*2;
983                 sb_offset &= ~(4*2-1);
984                 break;
985         case 1:
986                 sb_offset = 0;
987                 break;
988         case 2:
989                 sb_offset = 4*2;
990                 break;
991         default:
992                 return -EINVAL;
993         }
994
995         ioctl(fd, BLKFLSBUF, 0); /* make sure we read current data */
996
997
998         if (lseek64(fd, sb_offset << 9, 0)< 0LL) {
999                 if (devname)
1000                         fprintf(stderr, Name ": Cannot seek to superblock on %s: %s\n",
1001                                 devname, strerror(errno));
1002                 return 1;
1003         }
1004
1005         super = malloc(1024 + sizeof(bitmap_super_t) +
1006                        sizeof(struct misc_dev_info));
1007
1008         if (read(fd, super, 1024) != 1024) {
1009                 if (devname)
1010                         fprintf(stderr, Name ": Cannot read superblock on %s\n",
1011                                 devname);
1012                 free(super);
1013                 return 1;
1014         }
1015
1016         if (__le32_to_cpu(super->magic) != MD_SB_MAGIC) {
1017                 if (devname)
1018                         fprintf(stderr, Name ": No super block found on %s (Expected magic %08x, got %08x)\n",
1019                                 devname, MD_SB_MAGIC, __le32_to_cpu(super->magic));
1020                 free(super);
1021                 return 2;
1022         }
1023
1024         if (__le32_to_cpu(super->major_version) != 1) {
1025                 if (devname)
1026                         fprintf(stderr, Name ": Cannot interpret superblock on %s - version is %d\n",
1027                                 devname, __le32_to_cpu(super->major_version));
1028                 free(super);
1029                 return 2;
1030         }
1031         if (__le64_to_cpu(super->super_offset) != sb_offset) {
1032                 if (devname)
1033                         fprintf(stderr, Name ": No superblock found on %s (super_offset is wrong)\n",
1034                                 devname);
1035                 free(super);
1036                 return 2;
1037         }
1038         *sbp = super;
1039
1040         bsb = (struct bitmap_super_s *)(((char*)super)+1024);
1041
1042         misc = (struct misc_dev_info*) (bsb+1);
1043         misc->device_size = dsize;
1044
1045         /* Now check on the bitmap superblock */
1046         if ((__le32_to_cpu(super->feature_map)&MD_FEATURE_BITMAP_OFFSET) == 0)
1047                 return 0;
1048         /* Read the bitmap superblock and make sure it looks
1049          * valid.  If it doesn't clear the bit.  An --assemble --force
1050          * should get that written out.
1051          */
1052         locate_bitmap1(st, fd, super);
1053         if (read(fd, ((char*)super)+1024, sizeof(struct bitmap_super_s))
1054             != sizeof(struct bitmap_super_s))
1055                 goto no_bitmap;
1056
1057         uuid_from_super1(uuid, super);
1058         if (__le32_to_cpu(bsb->magic) != BITMAP_MAGIC ||
1059             memcmp(bsb->uuid, uuid, 16) != 0)
1060                 goto no_bitmap;
1061         return 0;
1062
1063  no_bitmap:
1064         super->feature_map = __cpu_to_le32(__le32_to_cpu(super->feature_map) & ~1);
1065         return 0;
1066 }
1067
1068
1069 static struct supertype *match_metadata_desc1(char *arg)
1070 {
1071         struct supertype *st = malloc(sizeof(*st));
1072         if (!st) return st;
1073
1074         st->ss = &super1;
1075         st->max_devs = 384;
1076         if (strcmp(arg, "1") == 0 ||
1077             strcmp(arg, "1.0") == 0 ||
1078             strcmp(arg, "default/large") == 0) {
1079                 st->minor_version = 0;
1080                 return st;
1081         }
1082         if (strcmp(arg, "1.1") == 0) {
1083                 st->minor_version = 1;
1084                 return st;
1085         }
1086         if (strcmp(arg, "1.2") == 0) {
1087                 st->minor_version = 2;
1088                 return st;
1089         }
1090
1091         free(st);
1092         return NULL;
1093 }
1094
1095 /* find available size on device with this devsize, using
1096  * superblock type st, and reserving 'reserve' sectors for
1097  * a possible bitmap
1098  */
1099 static __u64 avail_size1(struct supertype *st, __u64 devsize)
1100 {
1101         if (devsize < 24)
1102                 return 0;
1103
1104         /* if the device is bigger than 8Gig, save 64k for bitmap usage,
1105          * if bigger than 200Gig, save 128k
1106          */
1107         if (devsize-64*2 >= 200*1024*1024*2)
1108                 devsize -= 128*2;
1109         else if (devsize >= 8*1024*1024*2)
1110                 devsize -= 64*2;
1111
1112         switch(st->minor_version) {
1113         case 0:
1114                 /* at end */
1115                 return ((devsize - 8*2 ) & ~(4*2-1));
1116         case 1:
1117                 /* at start, 4K for superblock and possible bitmap */
1118                 return devsize - 4*2;
1119         case 2:
1120                 /* 4k from start, 4K for superblock and possible bitmap */
1121                 return devsize - (4+4)*2;
1122         }
1123         return 0;
1124 }
1125
1126 static int
1127 add_internal_bitmap1(struct supertype *st, void *sbv,
1128                      int *chunkp, int delay, int write_behind,
1129                      unsigned long long size,
1130                      int may_change, int major)
1131 {
1132         /*
1133          * If not may_change, then this is a 'Grow', and the bitmap
1134          * must fit after the superblock.
1135          * If may_change, then this is create, and we can put the bitmap
1136          * before the superblock if we like, or may move the start.
1137          * If !may_change, the bitmap MUST live at offset of 1K, until
1138          * we get a sysfs interface.
1139          *
1140          * size is in sectors,  chunk is in bytes !!!
1141          */
1142
1143         unsigned long long bits;
1144         unsigned long long max_bits;
1145         unsigned long long min_chunk;
1146         long offset;
1147         int chunk = *chunkp;
1148         int room = 0;
1149         struct mdp_superblock_1 *sb = sbv;
1150         bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb) + 1024);
1151
1152         switch(st->minor_version) {
1153         case 0:
1154                 /* either 3K after the superblock, or some amount of space
1155                  * before.
1156                  */
1157                 if (may_change) {
1158                         /* We are creating array, so we *know* how much room has
1159                          * been left.
1160                          */
1161                         offset = 0;
1162                         if (__le64_to_cpu(sb->size) >= 200*1024*1024*2)
1163                                 room = 128*2;
1164                         else if (__le64_to_cpu(sb->size) > 8*1024*1024*2)
1165                                 room = 64*2;
1166                         else {
1167                                 room = 3*2;
1168                                 offset = 2;
1169                         }
1170                 } else {
1171                         room = __le64_to_cpu(sb->super_offset)
1172                                 - __le64_to_cpu(sb->data_offset)
1173                                 - __le64_to_cpu(sb->data_size);
1174                         /* remove '1 ||' when we can set offset via sysfs */
1175                         if (1 || (room < 3*2 &&
1176                                   __le32_to_cpu(sb->max_dev) <= 384)) {
1177                                 room = 3*2;
1178                                 offset = 1*2;
1179                         } else {
1180                                 offset = 0; /* means movable offset */
1181                         }
1182                 }
1183                 break;
1184         case 1:
1185         case 2: /* between superblock and data */
1186                 if (may_change) {
1187                         offset = 4*2;
1188                         if (__le64_to_cpu(sb->size) >= 200*1024*1024*2)
1189                                 room = 128*2;
1190                         else if (__le64_to_cpu(sb->size) > 8*1024*1024*2)
1191                                 room = 64*2;
1192                         else
1193                                 room = 3*2;
1194                 } else {
1195                         room = __le64_to_cpu(sb->data_offset)
1196                                 - __le64_to_cpu(sb->super_offset);
1197                         if (1 || __le32_to_cpu(sb->max_dev) <= 384) {
1198                                 room -= 2;
1199                                 offset = 2;
1200                         } else {
1201                                 room -= 4*2;
1202                                 offset = 4*2;
1203                         }
1204                 }
1205                 break;
1206         }
1207
1208         if (chunk == UnSet && room > 128*2)
1209                 /* Limit to 128K of bitmap when chunk size not requested */
1210                 room = 128*2;
1211
1212         max_bits = (room * 512 - sizeof(bitmap_super_t)) * 8;
1213
1214         min_chunk = 4096; /* sub-page chunks don't work yet.. */
1215         bits = (size*512)/min_chunk +1;
1216         while (bits > max_bits) {
1217                 min_chunk *= 2;
1218                 bits = (bits+1)/2;
1219         }
1220         if (chunk == UnSet)
1221                 chunk = min_chunk;
1222         else if (chunk < min_chunk)
1223                 return 0; /* chunk size too small */
1224         if (chunk == 0) /* rounding problem */
1225                 return 0;
1226
1227         if (offset == 0) {
1228                 bits = (size*512) / chunk + 1;
1229                 room = ((bits+7)/8 + sizeof(bitmap_super_t) +511)/512;
1230                 offset = -room;
1231         }
1232
1233         sb->bitmap_offset = __cpu_to_le32(offset);
1234
1235         sb->feature_map = __cpu_to_le32(__le32_to_cpu(sb->feature_map) | 1);
1236         memset(bms, 0, sizeof(*bms));
1237         bms->magic = __cpu_to_le32(BITMAP_MAGIC);
1238         bms->version = __cpu_to_le32(major);
1239         uuid_from_super1((int*)bms->uuid, sb);
1240         bms->chunksize = __cpu_to_le32(chunk);
1241         bms->daemon_sleep = __cpu_to_le32(delay);
1242         bms->sync_size = __cpu_to_le64(size);
1243         bms->write_behind = __cpu_to_le32(write_behind);
1244
1245         *chunkp = chunk;
1246         return 1;
1247 }
1248
1249
1250 static void locate_bitmap1(struct supertype *st, int fd, void *sbv)
1251 {
1252         unsigned long long offset;
1253         struct mdp_superblock_1 *sb;
1254         int mustfree = 0;
1255
1256         if (!sbv) {
1257                 if (st->ss->load_super(st, fd, &sbv, NULL))
1258                         return; /* no error I hope... */
1259                 mustfree = 1;
1260         }
1261         sb = sbv;
1262
1263         offset = __le64_to_cpu(sb->super_offset);
1264         offset += (long) __le32_to_cpu(sb->bitmap_offset);
1265         if (mustfree)
1266                 free(sb);
1267         lseek64(fd, offset<<9, 0);
1268 }
1269
1270 static int write_bitmap1(struct supertype *st, int fd, void *sbv)
1271 {
1272         struct mdp_superblock_1 *sb = sbv;
1273         bitmap_super_t *bms = (bitmap_super_t*)(((char*)sb)+1024);
1274         int rv = 0;
1275
1276         int towrite, n;
1277         char buf[4096];
1278
1279         locate_bitmap1(st, fd, sbv);
1280
1281         if (write(fd, ((char*)sb)+1024, sizeof(bitmap_super_t)) !=
1282             sizeof(bitmap_super_t))
1283                 return -2;
1284         towrite = __le64_to_cpu(bms->sync_size) / (__le32_to_cpu(bms->chunksize)>>9);
1285         towrite = (towrite+7) >> 3; /* bits to bytes */
1286         memset(buf, 0xff, sizeof(buf));
1287         while (towrite > 0) {
1288                 n = towrite;
1289                 if (n > sizeof(buf))
1290                         n = sizeof(buf);
1291                 n = write(fd, buf, n);
1292                 if (n > 0)
1293                         towrite -= n;
1294                 else
1295                         break;
1296         }
1297         fsync(fd);
1298         if (towrite)
1299                 rv = -2;
1300
1301         return rv;
1302 }
1303
1304 struct superswitch super1 = {
1305 #ifndef MDASSEMBLE
1306         .examine_super = examine_super1,
1307         .brief_examine_super = brief_examine_super1,
1308         .detail_super = detail_super1,
1309         .brief_detail_super = brief_detail_super1,
1310 #endif
1311         .match_home = match_home1,
1312         .uuid_from_super = uuid_from_super1,
1313         .getinfo_super = getinfo_super1,
1314         .update_super = update_super1,
1315         .init_super = init_super1,
1316         .add_to_super = add_to_super1,
1317         .store_super = store_super1,
1318         .write_init_super = write_init_super1,
1319         .compare_super = compare_super1,
1320         .load_super = load_super1,
1321         .match_metadata_desc = match_metadata_desc1,
1322         .avail_size = avail_size1,
1323         .add_internal_bitmap = add_internal_bitmap1,
1324         .locate_bitmap = locate_bitmap1,
1325         .write_bitmap = write_bitmap1,
1326         .major = 1,
1327 #if __BYTE_ORDER == BIG_ENDIAN
1328         .swapuuid = 0,
1329 #else
1330         .swapuuid = 1,
1331 #endif
1332 };